[linux-2.6-block.git] / kernel / irq / proc.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
 *
 * This file contains the /proc/irq/ handling code.
 */

#include <linux/irq.h>
#include <linux/gfp.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/interrupt.h>
#include <linux/kernel_stat.h>
#include <linux/mutex.h>

#include "internals.h"

/*
 * Access rules:
 *
 * procfs protects read/write of /proc/irq/N/ files against a
 * concurrent free of the interrupt descriptor. remove_proc_entry()
 * immediately prevents new read/writes to happen and waits for
 * already running read/write functions to complete.
 *
 * We remove the proc entries first and then delete the interrupt
 * descriptor from the radix tree and free it. So it is guaranteed
 * that irq_to_desc(N) is valid as long as the read/writes are
 * permitted by procfs.
 *
 * The read from /proc/interrupts is a different problem because there
 * is no protection. So the lookup and the access to irqdesc
 * information must be protected by sparse_irq_lock.
 */
static struct proc_dir_entry *root_irq_dir;

#ifdef CONFIG_SMP

enum {
	AFFINITY,
	AFFINITY_LIST,
	EFFECTIVE,
	EFFECTIVE_LIST,
};

static int show_irq_affinity(int type, struct seq_file *m)
{
	struct irq_desc *desc = irq_to_desc((long)m->private);
	const struct cpumask *mask;

	switch (type) {
	case AFFINITY:
	case AFFINITY_LIST:
		mask = desc->irq_common_data.affinity;
#ifdef CONFIG_GENERIC_PENDING_IRQ
		if (irqd_is_setaffinity_pending(&desc->irq_data))
			mask = desc->pending_mask;
#endif
		break;
	case EFFECTIVE:
	case EFFECTIVE_LIST:
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
		mask = irq_data_get_effective_affinity_mask(&desc->irq_data);
		break;
#endif
	default:
		return -EINVAL;
	}

	switch (type) {
	case AFFINITY_LIST:
	case EFFECTIVE_LIST:
		seq_printf(m, "%*pbl\n", cpumask_pr_args(mask));
		break;
	case AFFINITY:
	case EFFECTIVE:
		seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
		break;
	}
	return 0;
}

static int irq_affinity_hint_proc_show(struct seq_file *m, void *v)
{
	struct irq_desc *desc = irq_to_desc((long)m->private);
	unsigned long flags;
	cpumask_var_t mask;

	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
		return -ENOMEM;

	raw_spin_lock_irqsave(&desc->lock, flags);
	if (desc->affinity_hint)
		cpumask_copy(mask, desc->affinity_hint);
	raw_spin_unlock_irqrestore(&desc->lock, flags);

	seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
	free_cpumask_var(mask);

	return 0;
}

int no_irq_affinity;
static int irq_affinity_proc_show(struct seq_file *m, void *v)
{
	return show_irq_affinity(AFFINITY, m);
}

static int irq_affinity_list_proc_show(struct seq_file *m, void *v)
{
	return show_irq_affinity(AFFINITY_LIST, m);
}


static ssize_t write_irq_affinity(int type, struct file *file,
		const char __user *buffer, size_t count, loff_t *pos)
{
	unsigned int irq = (int)(long)PDE_DATA(file_inode(file));
	cpumask_var_t new_value;
	int err;

	if (!irq_can_set_affinity_usr(irq) || no_irq_affinity)
		return -EIO;

	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
		return -ENOMEM;

	if (type)
		err = cpumask_parselist_user(buffer, count, new_value);
	else
		err = cpumask_parse_user(buffer, count, new_value);
	if (err)
		goto free_cpumask;

	/*
	 * Do not allow disabling IRQs completely - it's a too easy
	 * way to make the system unusable accidentally :-) At least
	 * one online CPU still has to be targeted.
	 */
	if (!cpumask_intersects(new_value, cpu_online_mask)) {
		/*
		 * Special case for empty set - allow the architecture code
		 * to set default SMP affinity.
		 */
		err = irq_select_affinity_usr(irq) ? -EINVAL : count;
	} else {
		err = irq_set_affinity(irq, new_value);
		if (!err)
			err = count;
	}

free_cpumask:
	free_cpumask_var(new_value);
	return err;
}

static ssize_t irq_affinity_proc_write(struct file *file,
		const char __user *buffer, size_t count, loff_t *pos)
{
	return write_irq_affinity(0, file, buffer, count, pos);
}

static ssize_t irq_affinity_list_proc_write(struct file *file,
		const char __user *buffer, size_t count, loff_t *pos)
{
	return write_irq_affinity(1, file, buffer, count, pos);
}

static int irq_affinity_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, irq_affinity_proc_show, PDE_DATA(inode));
}

static int irq_affinity_list_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, irq_affinity_list_proc_show, PDE_DATA(inode));
}

static const struct file_operations irq_affinity_proc_fops = {
	.open		= irq_affinity_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= irq_affinity_proc_write,
};

static const struct file_operations irq_affinity_list_proc_fops = {
	.open		= irq_affinity_list_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= irq_affinity_list_proc_write,
};

#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
static int irq_effective_aff_proc_show(struct seq_file *m, void *v)
{
	return show_irq_affinity(EFFECTIVE, m);
}

static int irq_effective_aff_list_proc_show(struct seq_file *m, void *v)
{
	return show_irq_affinity(EFFECTIVE_LIST, m);
}
#endif

static int default_affinity_show(struct seq_file *m, void *v)
{
	seq_printf(m, "%*pb\n", cpumask_pr_args(irq_default_affinity));
	return 0;
}

static ssize_t default_affinity_write(struct file *file,
		const char __user *buffer, size_t count, loff_t *ppos)
{
	cpumask_var_t new_value;
	int err;

	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
		return -ENOMEM;

	err = cpumask_parse_user(buffer, count, new_value);
	if (err)
		goto out;

	/*
	 * Do not allow disabling IRQs completely - it's a too easy
	 * way to make the system unusable accidentally :-) At least
	 * one online CPU still has to be targeted.
	 */
	if (!cpumask_intersects(new_value, cpu_online_mask)) {
		err = -EINVAL;
		goto out;
	}

	cpumask_copy(irq_default_affinity, new_value);
	err = count;

out:
	free_cpumask_var(new_value);
	return err;
}

static int default_affinity_open(struct inode *inode, struct file *file)
{
	return single_open(file, default_affinity_show, PDE_DATA(inode));
}

static const struct file_operations default_affinity_proc_fops = {
	.open		= default_affinity_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= default_affinity_write,
};

static int irq_node_proc_show(struct seq_file *m, void *v)
{
	struct irq_desc *desc = irq_to_desc((long) m->private);

	seq_printf(m, "%d\n", irq_desc_get_node(desc));
	return 0;
}
#endif

static int irq_spurious_proc_show(struct seq_file *m, void *v)
{
	struct irq_desc *desc = irq_to_desc((long) m->private);

	seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
		   desc->irq_count, desc->irqs_unhandled,
		   jiffies_to_msecs(desc->last_unhandled));
	return 0;
}

#define MAX_NAMELEN 128

static int name_unique(unsigned int irq, struct irqaction *new_action)
{
	struct irq_desc *desc = irq_to_desc(irq);
	struct irqaction *action;
	unsigned long flags;
	int ret = 1;

	raw_spin_lock_irqsave(&desc->lock, flags);
	for_each_action_of_desc(desc, action) {
		if ((action != new_action) && action->name &&
				!strcmp(new_action->name, action->name)) {
			ret = 0;
			break;
		}
	}
	raw_spin_unlock_irqrestore(&desc->lock, flags);
	return ret;
}

void register_handler_proc(unsigned int irq, struct irqaction *action)
{
	char name [MAX_NAMELEN];
	struct irq_desc *desc = irq_to_desc(irq);

	if (!desc->dir || action->dir || !action->name ||
					!name_unique(irq, action))
		return;

	snprintf(name, MAX_NAMELEN, "%s", action->name);

	/* create /proc/irq/1234/handler/ */
	action->dir = proc_mkdir(name, desc->dir);
}

#undef MAX_NAMELEN

#define MAX_NAMELEN 10

void register_irq_proc(unsigned int irq, struct irq_desc *desc)
{
	static DEFINE_MUTEX(register_lock);
	void __maybe_unused *irqp = (void *)(unsigned long) irq;
	char name [MAX_NAMELEN];

	if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip))
		return;

	/*
	 * irq directories are registered only when a handler is
	 * added, not when the descriptor is created, so multiple
	 * tasks might try to register at the same time.
	 */
	mutex_lock(&register_lock);

	if (desc->dir)
		goto out_unlock;

	sprintf(name, "%d", irq);

	/* create /proc/irq/1234 */
	desc->dir = proc_mkdir(name, root_irq_dir);
	if (!desc->dir)
		goto out_unlock;

#ifdef CONFIG_SMP
	/* create /proc/irq/<irq>/smp_affinity */
	proc_create_data("smp_affinity", 0644, desc->dir,
			 &irq_affinity_proc_fops, irqp);

	/* create /proc/irq/<irq>/affinity_hint */
	proc_create_single_data("affinity_hint", 0444, desc->dir,
			irq_affinity_hint_proc_show, irqp);

	/* create /proc/irq/<irq>/smp_affinity_list */
	proc_create_data("smp_affinity_list", 0644, desc->dir,
			 &irq_affinity_list_proc_fops, irqp);

	proc_create_single_data("node", 0444, desc->dir, irq_node_proc_show,
			irqp);
# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	proc_create_single_data("effective_affinity", 0444, desc->dir,
			irq_effective_aff_proc_show, irqp);
	proc_create_single_data("effective_affinity_list", 0444, desc->dir,
			irq_effective_aff_list_proc_show, irqp);
# endif
#endif
	proc_create_single_data("spurious", 0444, desc->dir,
			irq_spurious_proc_show, (void *)(long)irq);

out_unlock:
	mutex_unlock(&register_lock);
}

void unregister_irq_proc(unsigned int irq, struct irq_desc *desc)
{
	char name [MAX_NAMELEN];

	if (!root_irq_dir || !desc->dir)
		return;
#ifdef CONFIG_SMP
	remove_proc_entry("smp_affinity", desc->dir);
	remove_proc_entry("affinity_hint", desc->dir);
	remove_proc_entry("smp_affinity_list", desc->dir);
	remove_proc_entry("node", desc->dir);
# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	remove_proc_entry("effective_affinity", desc->dir);
	remove_proc_entry("effective_affinity_list", desc->dir);
# endif
#endif
	remove_proc_entry("spurious", desc->dir);

	sprintf(name, "%u", irq);
	remove_proc_entry(name, root_irq_dir);
}

#undef MAX_NAMELEN

void unregister_handler_proc(unsigned int irq, struct irqaction *action)
{
	proc_remove(action->dir);
}

static void register_default_affinity_proc(void)
{
#ifdef CONFIG_SMP
	proc_create("irq/default_smp_affinity", 0644, NULL,
		    &default_affinity_proc_fops);
#endif
}

void init_irq_proc(void)
{
	unsigned int irq;
	struct irq_desc *desc;

	/* create /proc/irq */
	root_irq_dir = proc_mkdir("irq", NULL);
	if (!root_irq_dir)
		return;

	register_default_affinity_proc();

	/*
	 * Create entries for all existing IRQs.
	 */
	for_each_irq_desc(irq, desc)
		register_irq_proc(irq, desc);
}

#ifdef CONFIG_GENERIC_IRQ_SHOW

int __weak arch_show_interrupts(struct seq_file *p, int prec)
{
	return 0;
}

#ifndef ACTUAL_NR_IRQS
# define ACTUAL_NR_IRQS nr_irqs
#endif

int show_interrupts(struct seq_file *p, void *v)
{
	static int prec;

	unsigned long flags, any_count = 0;
	int i = *(loff_t *) v, j;
	struct irqaction *action;
	struct irq_desc *desc;

	if (i > ACTUAL_NR_IRQS)
		return 0;

	if (i == ACTUAL_NR_IRQS)
		return arch_show_interrupts(p, prec);

	/* print header and calculate the width of the first column */
	if (i == 0) {
		for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
			j *= 10;

		seq_printf(p, "%*s", prec + 8, "");
		for_each_online_cpu(j)
			seq_printf(p, "CPU%-8d", j);
		seq_putc(p, '\n');
	}

	rcu_read_lock();
	desc = irq_to_desc(i);
	if (!desc)
		goto outsparse;

	if (desc->kstat_irqs)
		for_each_online_cpu(j)
			any_count |= *per_cpu_ptr(desc->kstat_irqs, j);

	if ((!desc->action || irq_desc_is_chained(desc)) && !any_count)
		goto outsparse;

	seq_printf(p, "%*d: ", prec, i);
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", desc->kstat_irqs ?
					*per_cpu_ptr(desc->kstat_irqs, j) : 0);

	raw_spin_lock_irqsave(&desc->lock, flags);
	if (desc->irq_data.chip) {
		if (desc->irq_data.chip->irq_print_chip)
			desc->irq_data.chip->irq_print_chip(&desc->irq_data, p);
		else if (desc->irq_data.chip->name)
			seq_printf(p, " %8s", desc->irq_data.chip->name);
		else
			seq_printf(p, " %8s", "-");
	} else {
		seq_printf(p, " %8s", "None");
	}
	if (desc->irq_data.domain)
		seq_printf(p, " %*d", prec, (int) desc->irq_data.hwirq);
	else
		seq_printf(p, " %*s", prec, "");
#ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
	seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
#endif
	if (desc->name)
		seq_printf(p, "-%-8s", desc->name);

	action = desc->action;
	if (action) {
		seq_printf(p, "  %s", action->name);
		while ((action = action->next) != NULL)
			seq_printf(p, ", %s", action->name);
	}

	seq_putc(p, '\n');
	raw_spin_unlock_irqrestore(&desc->lock, flags);
outsparse:
	rcu_read_unlock();
	return 0;
}
#endif
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4	2	/*
1da177e4 LT	3	* Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar
	4	*
	5	* This file contains the /proc/irq/ handling code.
	6	*/
	7
	8	#include <linux/irq.h>
5a0e3ad6	9	#include <linux/gfp.h>
1da177e4	10	#include <linux/proc_fs.h>
f18e439d	11	#include <linux/seq_file.h>
1da177e4	12	#include <linux/interrupt.h>
c78b9b65	13	#include <linux/kernel_stat.h>
95c2b175	14	#include <linux/mutex.h>
1da177e4	15
97a41e26 AB	16	#include "internals.h"
97a41e26 AB	17
c291ee62 TG	18	/*
	19	* Access rules:
	20	*
	21	* procfs protects read/write of /proc/irq/N/ files against a
	22	* concurrent free of the interrupt descriptor. remove_proc_entry()
	23	* immediately prevents new read/writes to happen and waits for
	24	* already running read/write functions to complete.
	25	*
	26	* We remove the proc entries first and then delete the interrupt
	27	* descriptor from the radix tree and free it. So it is guaranteed
	28	* that irq_to_desc(N) is valid as long as the read/writes are
	29	* permitted by procfs.
	30	*
	31	* The read from /proc/interrupts is a different problem because there
	32	* is no protection. So the lookup and the access to irqdesc
	33	* information must be protected by sparse_irq_lock.
	34	*/
4a733ee1	35	static struct proc_dir_entry *root_irq_dir;
1da177e4 LT	36
	37	#ifdef CONFIG_SMP
	38
0d3f5425 TG	39	enum {
	40	AFFINITY,
	41	AFFINITY_LIST,
	42	EFFECTIVE,
	43	EFFECTIVE_LIST,
	44	};
	45
047dc633	46	static int show_irq_affinity(int type, struct seq_file *m)
1da177e4	47	{
08678b08	48	struct irq_desc *desc = irq_to_desc((long)m->private);
0d3f5425	49	const struct cpumask *mask;
42ee2b74	50
0d3f5425 TG	51	switch (type) {
	52	case AFFINITY:
	53	case AFFINITY_LIST:
	54	mask = desc->irq_common_data.affinity;
42ee2b74	55	#ifdef CONFIG_GENERIC_PENDING_IRQ
0d3f5425 TG	56	if (irqd_is_setaffinity_pending(&desc->irq_data))
0d3f5425 TG	57	mask = desc->pending_mask;
42ee2b74	58	#endif
0d3f5425 TG	59	break;
	60	case EFFECTIVE:
	61	case EFFECTIVE_LIST:
	62	#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
6bc6d4ab	63	mask = irq_data_get_effective_affinity_mask(&desc->irq_data);
0d3f5425	64	break;
0d3f5425	65	#endif
b33394ba TG	66	default:
b33394ba TG	67	return -EINVAL;
ce8bdd69	68	}
0d3f5425 TG	69
	70	switch (type) {
	71	case AFFINITY_LIST:
	72	case EFFECTIVE_LIST:
c1d7f03f	73	seq_printf(m, "%*pbl\n", cpumask_pr_args(mask));
0d3f5425 TG	74	break;
	75	case AFFINITY:
	76	case EFFECTIVE:
c1d7f03f	77	seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
0d3f5425 TG	78	break;
0d3f5425 TG	79	}
f18e439d	80	return 0;
1da177e4 LT	81	}
1da177e4 LT	82
e7a297b0 PWJ	83	static int irq_affinity_hint_proc_show(struct seq_file m, void v)
	84	{
	85	struct irq_desc *desc = irq_to_desc((long)m->private);
	86	unsigned long flags;
	87	cpumask_var_t mask;
	88
4308ad80	89	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
e7a297b0 PWJ	90	return -ENOMEM;
	91
	92	raw_spin_lock_irqsave(&desc->lock, flags);
	93	if (desc->affinity_hint)
	94	cpumask_copy(mask, desc->affinity_hint);
e7a297b0 PWJ	95	raw_spin_unlock_irqrestore(&desc->lock, flags);
e7a297b0 PWJ	96
c1d7f03f	97	seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
e7a297b0 PWJ	98	free_cpumask_var(mask);
	99
	100	return 0;
	101	}
	102
1da177e4	103	int no_irq_affinity;
4b060420 MT	104	static int irq_affinity_proc_show(struct seq_file m, void v)
4b060420 MT	105	{
0d3f5425	106	return show_irq_affinity(AFFINITY, m);
4b060420 MT	107	}
	108
	109	static int irq_affinity_list_proc_show(struct seq_file m, void v)
	110	{
0d3f5425	111	return show_irq_affinity(AFFINITY_LIST, m);
4b060420 MT	112	}
	113
	114
	115	static ssize_t write_irq_affinity(int type, struct file *file,
f18e439d	116	const char __user buffer, size_t count, loff_t pos)
1da177e4	117	{
d9dda78b	118	unsigned int irq = (int)(long)PDE_DATA(file_inode(file));
0de26520	119	cpumask_var_t new_value;
f18e439d	120	int err;
1da177e4	121
9c255583	122	if (!irq_can_set_affinity_usr(irq) \|\| no_irq_affinity)
1da177e4 LT	123	return -EIO;
1da177e4 LT	124
0de26520 RR	125	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
	126	return -ENOMEM;
	127
4b060420 MT	128	if (type)
	129	err = cpumask_parselist_user(buffer, count, new_value);
	130	else
	131	err = cpumask_parse_user(buffer, count, new_value);
1da177e4	132	if (err)
0de26520	133	goto free_cpumask;
1da177e4 LT	134
	135	/*
	136	* Do not allow disabling IRQs completely - it's a too easy
	137	* way to make the system unusable accidentally :-) At least
	138	* one online CPU still has to be targeted.
	139	*/
0de26520	140	if (!cpumask_intersects(new_value, cpu_online_mask)) {
cba4235e TG	141	/*
	142	* Special case for empty set - allow the architecture code
	143	* to set default SMP affinity.
	144	*/
	145	err = irq_select_affinity_usr(irq) ? -EINVAL : count;
0de26520	146	} else {
6714796e WY	147	err = irq_set_affinity(irq, new_value);
	148	if (!err)
	149	err = count;
0de26520 RR	150	}
	151
	152	free_cpumask:
	153	free_cpumask_var(new_value);
	154	return err;
1da177e4 LT	155	}
1da177e4 LT	156
4b060420 MT	157	static ssize_t irq_affinity_proc_write(struct file *file,
	158	const char __user buffer, size_t count, loff_t pos)
	159	{
	160	return write_irq_affinity(0, file, buffer, count, pos);
	161	}
	162
	163	static ssize_t irq_affinity_list_proc_write(struct file *file,
	164	const char __user buffer, size_t count, loff_t pos)
	165	{
	166	return write_irq_affinity(1, file, buffer, count, pos);
	167	}
	168
f18e439d	169	static int irq_affinity_proc_open(struct inode inode, struct file file)
18404756	170	{
d9dda78b	171	return single_open(file, irq_affinity_proc_show, PDE_DATA(inode));
18404756 MK	172	}
18404756 MK	173
4b060420 MT	174	static int irq_affinity_list_proc_open(struct inode inode, struct file file)
4b060420 MT	175	{
d9dda78b	176	return single_open(file, irq_affinity_list_proc_show, PDE_DATA(inode));
4b060420 MT	177	}
4b060420 MT	178
f18e439d AD	179	static const struct file_operations irq_affinity_proc_fops = {
	180	.open = irq_affinity_proc_open,
	181	.read = seq_read,
	182	.llseek = seq_lseek,
	183	.release = single_release,
	184	.write = irq_affinity_proc_write,
	185	};
	186
4b060420 MT	187	static const struct file_operations irq_affinity_list_proc_fops = {
	188	.open = irq_affinity_list_proc_open,
	189	.read = seq_read,
	190	.llseek = seq_lseek,
	191	.release = single_release,
	192	.write = irq_affinity_list_proc_write,
	193	};
	194
0d3f5425 TG	195	#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	196	static int irq_effective_aff_proc_show(struct seq_file m, void v)
	197	{
	198	return show_irq_affinity(EFFECTIVE, m);
	199	}
	200
	201	static int irq_effective_aff_list_proc_show(struct seq_file m, void v)
	202	{
	203	return show_irq_affinity(EFFECTIVE_LIST, m);
	204	}
0d3f5425 TG	205	#endif
0d3f5425 TG	206
f18e439d AD	207	static int default_affinity_show(struct seq_file m, void v)
f18e439d AD	208	{
c1d7f03f	209	seq_printf(m, "%*pb\n", cpumask_pr_args(irq_default_affinity));
f18e439d AD	210	return 0;
	211	}
	212
	213	static ssize_t default_affinity_write(struct file *file,
	214	const char __user buffer, size_t count, loff_t ppos)
18404756	215	{
d036e67b	216	cpumask_var_t new_value;
f18e439d	217	int err;
18404756	218
d036e67b RR	219	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
	220	return -ENOMEM;
	221
	222	err = cpumask_parse_user(buffer, count, new_value);
18404756	223	if (err)
d036e67b	224	goto out;
18404756	225
18404756 MK	226	/*
	227	* Do not allow disabling IRQs completely - it's a too easy
	228	* way to make the system unusable accidentally :-) At least
	229	* one online CPU still has to be targeted.
	230	*/
d036e67b RR	231	if (!cpumask_intersects(new_value, cpu_online_mask)) {
	232	err = -EINVAL;
	233	goto out;
	234	}
18404756	235
d036e67b RR	236	cpumask_copy(irq_default_affinity, new_value);
d036e67b RR	237	err = count;
18404756	238
d036e67b RR	239	out:
	240	free_cpumask_var(new_value);
	241	return err;
18404756	242	}
f18e439d AD	243
	244	static int default_affinity_open(struct inode inode, struct file file)
	245	{
d9dda78b	246	return single_open(file, default_affinity_show, PDE_DATA(inode));
f18e439d AD	247	}
	248
	249	static const struct file_operations default_affinity_proc_fops = {
	250	.open = default_affinity_open,
	251	.read = seq_read,
	252	.llseek = seq_lseek,
	253	.release = single_release,
	254	.write = default_affinity_write,
	255	};
92d6b71a DS	256
	257	static int irq_node_proc_show(struct seq_file m, void v)
	258	{
	259	struct irq_desc *desc = irq_to_desc((long) m->private);
	260
6783011b	261	seq_printf(m, "%d\n", irq_desc_get_node(desc));
92d6b71a DS	262	return 0;
92d6b71a DS	263	}
1da177e4 LT	264	#endif
1da177e4 LT	265
a1afb637	266	static int irq_spurious_proc_show(struct seq_file m, void v)
96d97cf0	267	{
a1afb637 AD	268	struct irq_desc *desc = irq_to_desc((long) m->private);
	269
	270	seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
	271	desc->irq_count, desc->irqs_unhandled,
	272	jiffies_to_msecs(desc->last_unhandled));
	273	return 0;
	274	}
	275
1da177e4 LT	276	#define MAX_NAMELEN 128
	277
	278	static int name_unique(unsigned int irq, struct irqaction *new_action)
	279	{
08678b08	280	struct irq_desc *desc = irq_to_desc(irq);
1da177e4	281	struct irqaction *action;
d2d9433a DA	282	unsigned long flags;
d2d9433a DA	283	int ret = 1;
1da177e4	284
239007b8	285	raw_spin_lock_irqsave(&desc->lock, flags);
f944b5a7	286	for_each_action_of_desc(desc, action) {
1da177e4	287	if ((action != new_action) && action->name &&
d2d9433a DA	288	!strcmp(new_action->name, action->name)) {
	289	ret = 0;
	290	break;
	291	}
	292	}
239007b8	293	raw_spin_unlock_irqrestore(&desc->lock, flags);
d2d9433a	294	return ret;
1da177e4 LT	295	}
	296
	297	void register_handler_proc(unsigned int irq, struct irqaction *action)
	298	{
	299	char name [MAX_NAMELEN];
08678b08	300	struct irq_desc *desc = irq_to_desc(irq);
1da177e4	301
08678b08	302	if (!desc->dir \|\| action->dir \|\| !action->name \|\|
1da177e4 LT	303	!name_unique(irq, action))
	304	return;
	305
1da177e4 LT	306	snprintf(name, MAX_NAMELEN, "%s", action->name);
	307
	308	/* create /proc/irq/1234/handler/ */
08678b08	309	action->dir = proc_mkdir(name, desc->dir);
1da177e4 LT	310	}
	311
	312	#undef MAX_NAMELEN
	313
	314	#define MAX_NAMELEN 10
	315
2c6927a3	316	void register_irq_proc(unsigned int irq, struct irq_desc *desc)
1da177e4	317	{
95c2b175	318	static DEFINE_MUTEX(register_lock);
c1a80386	319	void __maybe_unused irqp = (void )(unsigned long) irq;
1da177e4 LT	320	char name [MAX_NAMELEN];
1da177e4 LT	321
95c2b175	322	if (!root_irq_dir \|\| (desc->irq_data.chip == &no_irq_chip))
1da177e4 LT	323	return;
1da177e4 LT	324
95c2b175 BH	325	/*
	326	* irq directories are registered only when a handler is
	327	* added, not when the descriptor is created, so multiple
	328	* tasks might try to register at the same time.
	329	*/
	330	mutex_lock(&register_lock);
	331
	332	if (desc->dir)
	333	goto out_unlock;
	334
1da177e4 LT	335	sprintf(name, "%d", irq);
	336
	337	/* create /proc/irq/1234 */
08678b08	338	desc->dir = proc_mkdir(name, root_irq_dir);
c82a43d4	339	if (!desc->dir)
95c2b175	340	goto out_unlock;
1da177e4 LT	341
1da177e4 LT	342	#ifdef CONFIG_SMP
f18e439d	343	/* create /proc/irq/<irq>/smp_affinity */
bab5c790	344	proc_create_data("smp_affinity", 0644, desc->dir,
c1a80386	345	&irq_affinity_proc_fops, irqp);
92d6b71a	346
e7a297b0	347	/* create /proc/irq/<irq>/affinity_hint */
3f3942ac CH	348	proc_create_single_data("affinity_hint", 0444, desc->dir,
3f3942ac CH	349	irq_affinity_hint_proc_show, irqp);
e7a297b0	350
4b060420	351	/* create /proc/irq/<irq>/smp_affinity_list */
bab5c790	352	proc_create_data("smp_affinity_list", 0644, desc->dir,
c1a80386	353	&irq_affinity_list_proc_fops, irqp);
4b060420	354
3f3942ac CH	355	proc_create_single_data("node", 0444, desc->dir, irq_node_proc_show,
3f3942ac CH	356	irqp);
0d3f5425	357	# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
3f3942ac CH	358	proc_create_single_data("effective_affinity", 0444, desc->dir,
	359	irq_effective_aff_proc_show, irqp);
	360	proc_create_single_data("effective_affinity_list", 0444, desc->dir,
	361	irq_effective_aff_list_proc_show, irqp);
0d3f5425	362	# endif
1da177e4	363	#endif
3f3942ac CH	364	proc_create_single_data("spurious", 0444, desc->dir,
3f3942ac CH	365	irq_spurious_proc_show, (void *)(long)irq);
95c2b175 BH	366
	367	out_unlock:
	368	mutex_unlock(&register_lock);
1da177e4 LT	369	}
1da177e4 LT	370
13bfe99e TG	371	void unregister_irq_proc(unsigned int irq, struct irq_desc *desc)
	372	{
	373	char name [MAX_NAMELEN];
	374
	375	if (!root_irq_dir \|\| !desc->dir)
	376	return;
	377	#ifdef CONFIG_SMP
	378	remove_proc_entry("smp_affinity", desc->dir);
	379	remove_proc_entry("affinity_hint", desc->dir);
def945ee	380	remove_proc_entry("smp_affinity_list", desc->dir);
13bfe99e	381	remove_proc_entry("node", desc->dir);
0d3f5425 TG	382	# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	383	remove_proc_entry("effective_affinity", desc->dir);
	384	remove_proc_entry("effective_affinity_list", desc->dir);
	385	# endif
13bfe99e TG	386	#endif
	387	remove_proc_entry("spurious", desc->dir);
	388
13bfe99e TG	389	sprintf(name, "%u", irq);
	390	remove_proc_entry(name, root_irq_dir);
	391	}
	392
1da177e4 LT	393	#undef MAX_NAMELEN
	394
	395	void unregister_handler_proc(unsigned int irq, struct irqaction *action)
	396	{
a8ca16ea	397	proc_remove(action->dir);
1da177e4 LT	398	}
1da177e4 LT	399
3786fc71	400	static void register_default_affinity_proc(void)
18404756 MK	401	{
18404756 MK	402	#ifdef CONFIG_SMP
bab5c790	403	proc_create("irq/default_smp_affinity", 0644, NULL,
f18e439d	404	&default_affinity_proc_fops);
18404756 MK	405	#endif
	406	}
	407
1da177e4 LT	408	void init_irq_proc(void)
1da177e4 LT	409	{
2c6927a3 YL	410	unsigned int irq;
2c6927a3 YL	411	struct irq_desc *desc;
1da177e4 LT	412
	413	/* create /proc/irq */
	414	root_irq_dir = proc_mkdir("irq", NULL);
	415	if (!root_irq_dir)
	416	return;
	417
18404756 MK	418	register_default_affinity_proc();
18404756 MK	419
1da177e4 LT	420	/*
	421	* Create entries for all existing IRQs.
	422	*/
fe3464ca	423	for_each_irq_desc(irq, desc)
2c6927a3	424	register_irq_proc(irq, desc);
1da177e4 LT	425	}
1da177e4 LT	426
c78b9b65 TG	427	#ifdef CONFIG_GENERIC_IRQ_SHOW
	428
	429	int __weak arch_show_interrupts(struct seq_file *p, int prec)
	430	{
	431	return 0;
	432	}
	433
a6e120ed TG	434	#ifndef ACTUAL_NR_IRQS
	435	# define ACTUAL_NR_IRQS nr_irqs
	436	#endif
	437
c78b9b65 TG	438	int show_interrupts(struct seq_file p, void v)
	439	{
	440	static int prec;
	441
	442	unsigned long flags, any_count = 0;
	443	int i = (loff_t ) v, j;
	444	struct irqaction *action;
	445	struct irq_desc *desc;
	446
a6e120ed	447	if (i > ACTUAL_NR_IRQS)
c78b9b65 TG	448	return 0;
c78b9b65 TG	449
a6e120ed	450	if (i == ACTUAL_NR_IRQS)
c78b9b65 TG	451	return arch_show_interrupts(p, prec);
	452
	453	/* print header and calculate the width of the first column */
	454	if (i == 0) {
	455	for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
	456	j *= 10;
	457
	458	seq_printf(p, "%*s", prec + 8, "");
	459	for_each_online_cpu(j)
	460	seq_printf(p, "CPU%-8d", j);
	461	seq_putc(p, '\n');
	462	}
	463
74bdf781	464	rcu_read_lock();
c78b9b65 TG	465	desc = irq_to_desc(i);
c78b9b65 TG	466	if (!desc)
c291ee62	467	goto outsparse;
c78b9b65	468
74bdf781 ED	469	if (desc->kstat_irqs)
	470	for_each_online_cpu(j)
	471	any_count \|= *per_cpu_ptr(desc->kstat_irqs, j);
	472
	473	if ((!desc->action \|\| irq_desc_is_chained(desc)) && !any_count)
	474	goto outsparse;
c78b9b65 TG	475
	476	seq_printf(p, "%*d: ", prec, i);
	477	for_each_online_cpu(j)
74bdf781 ED	478	seq_printf(p, "%10u ", desc->kstat_irqs ?
74bdf781 ED	479	*per_cpu_ptr(desc->kstat_irqs, j) : 0);
ab7798ff	480
74bdf781	481	raw_spin_lock_irqsave(&desc->lock, flags);
ab7798ff TG	482	if (desc->irq_data.chip) {
	483	if (desc->irq_data.chip->irq_print_chip)
	484	desc->irq_data.chip->irq_print_chip(&desc->irq_data, p);
	485	else if (desc->irq_data.chip->name)
	486	seq_printf(p, " %8s", desc->irq_data.chip->name);
	487	else
	488	seq_printf(p, " %8s", "-");
	489	} else {
	490	seq_printf(p, " %8s", "None");
	491	}
c12d2f42 GL	492	if (desc->irq_data.domain)
c12d2f42 GL	493	seq_printf(p, " %*d", prec, (int) desc->irq_data.hwirq);
f435da41 HS	494	else
f435da41 HS	495	seq_printf(p, " %*s", prec, "");
94b2c363	496	#ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
ab7798ff TG	497	seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
ab7798ff TG	498	#endif
ee0401ec TG	499	if (desc->name)
ee0401ec TG	500	seq_printf(p, "-%-8s", desc->name);
c78b9b65	501
74bdf781	502	action = desc->action;
c78b9b65 TG	503	if (action) {
	504	seq_printf(p, " %s", action->name);
	505	while ((action = action->next) != NULL)
	506	seq_printf(p, ", %s", action->name);
	507	}
	508
	509	seq_putc(p, '\n');
c78b9b65	510	raw_spin_unlock_irqrestore(&desc->lock, flags);
c291ee62	511	outsparse:
74bdf781	512	rcu_read_unlock();
c78b9b65 TG	513	return 0;
	514	}
	515	#endif