[mirror_ubuntu-jammy-kernel.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);
}

#ifndef CONFIG_AUTO_IRQ_AFFINITY
static inline int irq_select_affinity_usr(unsigned int irq)
{
	/*
	 * If the interrupt is started up already then this fails. The
	 * interrupt is assigned to an online CPU already. There is no
	 * point to move it around randomly. Tell user space that the
	 * selected mask is bogus.
	 *
	 * If not then any change to the affinity is pointless because the
	 * startup code invokes irq_setup_affinity() which will select
	 * a online CPU anyway.
	 */
	return -EINVAL;
}
#else
/* ALPHA magic affinity auto selector. Keep it for historical reasons. */
static inline int irq_select_affinity_usr(unsigned int irq)
{
	return irq_select_affinity(irq);
}
#endif

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 proc_ops irq_affinity_proc_ops = {
	.proc_open	= irq_affinity_proc_open,
	.proc_read	= seq_read,
	.proc_lseek	= seq_lseek,
	.proc_release	= single_release,
	.proc_write	= irq_affinity_proc_write,
};

static const struct proc_ops irq_affinity_list_proc_ops = {
	.proc_open	= irq_affinity_list_proc_open,
	.proc_read	= seq_read,
	.proc_lseek	= seq_lseek,
	.proc_release	= single_release,
	.proc_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 proc_ops default_affinity_proc_ops = {
	.proc_open	= default_affinity_open,
	.proc_read	= seq_read,
	.proc_lseek	= seq_lseek,
	.proc_release	= single_release,
	.proc_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_ops, 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_ops, 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_ops);
#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 || irq_settings_is_hidden(desc))
		goto outsparse;

	if (desc->kstat_irqs) {
		for_each_online_cpu(j)
			any_count |= data_race(*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	}
4b060420 MT	113
cba6437a TG	114	#ifndef CONFIG_AUTO_IRQ_AFFINITY
	115	static inline int irq_select_affinity_usr(unsigned int irq)
	116	{
	117	/*
	118	* If the interrupt is started up already then this fails. The
	119	* interrupt is assigned to an online CPU already. There is no
	120	* point to move it around randomly. Tell user space that the
	121	* selected mask is bogus.
	122	*
	123	* If not then any change to the affinity is pointless because the
	124	* startup code invokes irq_setup_affinity() which will select
	125	* a online CPU anyway.
	126	*/
	127	return -EINVAL;
	128	}
	129	#else
	130	/* ALPHA magic affinity auto selector. Keep it for historical reasons. */
	131	static inline int irq_select_affinity_usr(unsigned int irq)
	132	{
	133	return irq_select_affinity(irq);
	134	}
	135	#endif
4b060420 MT	136
4b060420 MT	137	static ssize_t write_irq_affinity(int type, struct file *file,
f18e439d	138	const char __user buffer, size_t count, loff_t pos)
1da177e4	139	{
d9dda78b	140	unsigned int irq = (int)(long)PDE_DATA(file_inode(file));
0de26520	141	cpumask_var_t new_value;
f18e439d	142	int err;
1da177e4	143
9c255583	144	if (!irq_can_set_affinity_usr(irq) \|\| no_irq_affinity)
1da177e4 LT	145	return -EIO;
1da177e4 LT	146
0de26520 RR	147	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
	148	return -ENOMEM;
	149
4b060420 MT	150	if (type)
	151	err = cpumask_parselist_user(buffer, count, new_value);
	152	else
	153	err = cpumask_parse_user(buffer, count, new_value);
1da177e4	154	if (err)
0de26520	155	goto free_cpumask;
1da177e4 LT	156
	157	/*
	158	* Do not allow disabling IRQs completely - it's a too easy
	159	* way to make the system unusable accidentally :-) At least
	160	* one online CPU still has to be targeted.
	161	*/
0de26520	162	if (!cpumask_intersects(new_value, cpu_online_mask)) {
cba4235e TG	163	/*
	164	* Special case for empty set - allow the architecture code
	165	* to set default SMP affinity.
	166	*/
	167	err = irq_select_affinity_usr(irq) ? -EINVAL : count;
0de26520	168	} else {
6714796e WY	169	err = irq_set_affinity(irq, new_value);
	170	if (!err)
	171	err = count;
0de26520 RR	172	}
	173
	174	free_cpumask:
	175	free_cpumask_var(new_value);
	176	return err;
1da177e4 LT	177	}
1da177e4 LT	178
4b060420 MT	179	static ssize_t irq_affinity_proc_write(struct file *file,
	180	const char __user buffer, size_t count, loff_t pos)
	181	{
	182	return write_irq_affinity(0, file, buffer, count, pos);
	183	}
	184
	185	static ssize_t irq_affinity_list_proc_write(struct file *file,
	186	const char __user buffer, size_t count, loff_t pos)
	187	{
	188	return write_irq_affinity(1, file, buffer, count, pos);
	189	}
	190
f18e439d	191	static int irq_affinity_proc_open(struct inode inode, struct file file)
18404756	192	{
d9dda78b	193	return single_open(file, irq_affinity_proc_show, PDE_DATA(inode));
18404756 MK	194	}
18404756 MK	195
4b060420 MT	196	static int irq_affinity_list_proc_open(struct inode inode, struct file file)
4b060420 MT	197	{
d9dda78b	198	return single_open(file, irq_affinity_list_proc_show, PDE_DATA(inode));
4b060420 MT	199	}
4b060420 MT	200
97a32539 AD	201	static const struct proc_ops irq_affinity_proc_ops = {
	202	.proc_open = irq_affinity_proc_open,
	203	.proc_read = seq_read,
	204	.proc_lseek = seq_lseek,
	205	.proc_release = single_release,
	206	.proc_write = irq_affinity_proc_write,
f18e439d AD	207	};
f18e439d AD	208
97a32539 AD	209	static const struct proc_ops irq_affinity_list_proc_ops = {
	210	.proc_open = irq_affinity_list_proc_open,
	211	.proc_read = seq_read,
	212	.proc_lseek = seq_lseek,
	213	.proc_release = single_release,
	214	.proc_write = irq_affinity_list_proc_write,
4b060420 MT	215	};
4b060420 MT	216
0d3f5425 TG	217	#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	218	static int irq_effective_aff_proc_show(struct seq_file m, void v)
	219	{
	220	return show_irq_affinity(EFFECTIVE, m);
	221	}
	222
	223	static int irq_effective_aff_list_proc_show(struct seq_file m, void v)
	224	{
	225	return show_irq_affinity(EFFECTIVE_LIST, m);
	226	}
0d3f5425 TG	227	#endif
0d3f5425 TG	228
f18e439d AD	229	static int default_affinity_show(struct seq_file m, void v)
f18e439d AD	230	{
c1d7f03f	231	seq_printf(m, "%*pb\n", cpumask_pr_args(irq_default_affinity));
f18e439d AD	232	return 0;
	233	}
	234
	235	static ssize_t default_affinity_write(struct file *file,
	236	const char __user buffer, size_t count, loff_t ppos)
18404756	237	{
d036e67b	238	cpumask_var_t new_value;
f18e439d	239	int err;
18404756	240
d036e67b RR	241	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
	242	return -ENOMEM;
	243
	244	err = cpumask_parse_user(buffer, count, new_value);
18404756	245	if (err)
d036e67b	246	goto out;
18404756	247
18404756 MK	248	/*
	249	* Do not allow disabling IRQs completely - it's a too easy
	250	* way to make the system unusable accidentally :-) At least
	251	* one online CPU still has to be targeted.
	252	*/
d036e67b RR	253	if (!cpumask_intersects(new_value, cpu_online_mask)) {
	254	err = -EINVAL;
	255	goto out;
	256	}
18404756	257
d036e67b RR	258	cpumask_copy(irq_default_affinity, new_value);
d036e67b RR	259	err = count;
18404756	260
d036e67b RR	261	out:
	262	free_cpumask_var(new_value);
	263	return err;
18404756	264	}
f18e439d AD	265
	266	static int default_affinity_open(struct inode inode, struct file file)
	267	{
d9dda78b	268	return single_open(file, default_affinity_show, PDE_DATA(inode));
f18e439d AD	269	}
f18e439d AD	270
97a32539 AD	271	static const struct proc_ops default_affinity_proc_ops = {
	272	.proc_open = default_affinity_open,
	273	.proc_read = seq_read,
	274	.proc_lseek = seq_lseek,
	275	.proc_release = single_release,
	276	.proc_write = default_affinity_write,
f18e439d	277	};
92d6b71a DS	278
	279	static int irq_node_proc_show(struct seq_file m, void v)
	280	{
	281	struct irq_desc *desc = irq_to_desc((long) m->private);
	282
6783011b	283	seq_printf(m, "%d\n", irq_desc_get_node(desc));
92d6b71a DS	284	return 0;
92d6b71a DS	285	}
1da177e4 LT	286	#endif
1da177e4 LT	287
a1afb637	288	static int irq_spurious_proc_show(struct seq_file m, void v)
96d97cf0	289	{
a1afb637 AD	290	struct irq_desc *desc = irq_to_desc((long) m->private);
	291
	292	seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
	293	desc->irq_count, desc->irqs_unhandled,
	294	jiffies_to_msecs(desc->last_unhandled));
	295	return 0;
	296	}
	297
1da177e4 LT	298	#define MAX_NAMELEN 128
	299
	300	static int name_unique(unsigned int irq, struct irqaction *new_action)
	301	{
08678b08	302	struct irq_desc *desc = irq_to_desc(irq);
1da177e4	303	struct irqaction *action;
d2d9433a DA	304	unsigned long flags;
d2d9433a DA	305	int ret = 1;
1da177e4	306
239007b8	307	raw_spin_lock_irqsave(&desc->lock, flags);
f944b5a7	308	for_each_action_of_desc(desc, action) {
1da177e4	309	if ((action != new_action) && action->name &&
d2d9433a DA	310	!strcmp(new_action->name, action->name)) {
	311	ret = 0;
	312	break;
	313	}
	314	}
239007b8	315	raw_spin_unlock_irqrestore(&desc->lock, flags);
d2d9433a	316	return ret;
1da177e4 LT	317	}
	318
	319	void register_handler_proc(unsigned int irq, struct irqaction *action)
	320	{
	321	char name [MAX_NAMELEN];
08678b08	322	struct irq_desc *desc = irq_to_desc(irq);
1da177e4	323
08678b08	324	if (!desc->dir \|\| action->dir \|\| !action->name \|\|
1da177e4 LT	325	!name_unique(irq, action))
	326	return;
	327
1da177e4 LT	328	snprintf(name, MAX_NAMELEN, "%s", action->name);
	329
	330	/* create /proc/irq/1234/handler/ */
08678b08	331	action->dir = proc_mkdir(name, desc->dir);
1da177e4 LT	332	}
	333
	334	#undef MAX_NAMELEN
	335
	336	#define MAX_NAMELEN 10
	337
2c6927a3	338	void register_irq_proc(unsigned int irq, struct irq_desc *desc)
1da177e4	339	{
95c2b175	340	static DEFINE_MUTEX(register_lock);
c1a80386	341	void __maybe_unused irqp = (void )(unsigned long) irq;
1da177e4 LT	342	char name [MAX_NAMELEN];
1da177e4 LT	343
95c2b175	344	if (!root_irq_dir \|\| (desc->irq_data.chip == &no_irq_chip))
1da177e4 LT	345	return;
1da177e4 LT	346
95c2b175 BH	347	/*
	348	* irq directories are registered only when a handler is
	349	* added, not when the descriptor is created, so multiple
	350	* tasks might try to register at the same time.
	351	*/
	352	mutex_lock(&register_lock);
	353
	354	if (desc->dir)
	355	goto out_unlock;
	356
1da177e4 LT	357	sprintf(name, "%d", irq);
	358
	359	/* create /proc/irq/1234 */
08678b08	360	desc->dir = proc_mkdir(name, root_irq_dir);
c82a43d4	361	if (!desc->dir)
95c2b175	362	goto out_unlock;
1da177e4 LT	363
1da177e4 LT	364	#ifdef CONFIG_SMP
f18e439d	365	/* create /proc/irq/<irq>/smp_affinity */
bab5c790	366	proc_create_data("smp_affinity", 0644, desc->dir,
97a32539	367	&irq_affinity_proc_ops, irqp);
92d6b71a	368
e7a297b0	369	/* create /proc/irq/<irq>/affinity_hint */
3f3942ac CH	370	proc_create_single_data("affinity_hint", 0444, desc->dir,
3f3942ac CH	371	irq_affinity_hint_proc_show, irqp);
e7a297b0	372
4b060420	373	/* create /proc/irq/<irq>/smp_affinity_list */
bab5c790	374	proc_create_data("smp_affinity_list", 0644, desc->dir,
97a32539	375	&irq_affinity_list_proc_ops, irqp);
4b060420	376
3f3942ac CH	377	proc_create_single_data("node", 0444, desc->dir, irq_node_proc_show,
3f3942ac CH	378	irqp);
0d3f5425	379	# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
3f3942ac CH	380	proc_create_single_data("effective_affinity", 0444, desc->dir,
	381	irq_effective_aff_proc_show, irqp);
	382	proc_create_single_data("effective_affinity_list", 0444, desc->dir,
	383	irq_effective_aff_list_proc_show, irqp);
0d3f5425	384	# endif
1da177e4	385	#endif
3f3942ac CH	386	proc_create_single_data("spurious", 0444, desc->dir,
3f3942ac CH	387	irq_spurious_proc_show, (void *)(long)irq);
95c2b175 BH	388
	389	out_unlock:
	390	mutex_unlock(&register_lock);
1da177e4 LT	391	}
1da177e4 LT	392
13bfe99e TG	393	void unregister_irq_proc(unsigned int irq, struct irq_desc *desc)
	394	{
	395	char name [MAX_NAMELEN];
	396
	397	if (!root_irq_dir \|\| !desc->dir)
	398	return;
	399	#ifdef CONFIG_SMP
	400	remove_proc_entry("smp_affinity", desc->dir);
	401	remove_proc_entry("affinity_hint", desc->dir);
def945ee	402	remove_proc_entry("smp_affinity_list", desc->dir);
13bfe99e	403	remove_proc_entry("node", desc->dir);
0d3f5425 TG	404	# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
	405	remove_proc_entry("effective_affinity", desc->dir);
	406	remove_proc_entry("effective_affinity_list", desc->dir);
	407	# endif
13bfe99e TG	408	#endif
	409	remove_proc_entry("spurious", desc->dir);
	410
13bfe99e TG	411	sprintf(name, "%u", irq);
	412	remove_proc_entry(name, root_irq_dir);
	413	}
	414
1da177e4 LT	415	#undef MAX_NAMELEN
	416
	417	void unregister_handler_proc(unsigned int irq, struct irqaction *action)
	418	{
a8ca16ea	419	proc_remove(action->dir);
1da177e4 LT	420	}
1da177e4 LT	421
3786fc71	422	static void register_default_affinity_proc(void)
18404756 MK	423	{
18404756 MK	424	#ifdef CONFIG_SMP
bab5c790	425	proc_create("irq/default_smp_affinity", 0644, NULL,
97a32539	426	&default_affinity_proc_ops);
18404756 MK	427	#endif
	428	}
	429
1da177e4 LT	430	void init_irq_proc(void)
1da177e4 LT	431	{
2c6927a3 YL	432	unsigned int irq;
2c6927a3 YL	433	struct irq_desc *desc;
1da177e4 LT	434
	435	/* create /proc/irq */
	436	root_irq_dir = proc_mkdir("irq", NULL);
	437	if (!root_irq_dir)
	438	return;
	439
18404756 MK	440	register_default_affinity_proc();
18404756 MK	441
1da177e4 LT	442	/*
	443	* Create entries for all existing IRQs.
	444	*/
fe3464ca	445	for_each_irq_desc(irq, desc)
2c6927a3	446	register_irq_proc(irq, desc);
1da177e4 LT	447	}
1da177e4 LT	448
c78b9b65 TG	449	#ifdef CONFIG_GENERIC_IRQ_SHOW
	450
	451	int __weak arch_show_interrupts(struct seq_file *p, int prec)
	452	{
	453	return 0;
	454	}
	455
a6e120ed TG	456	#ifndef ACTUAL_NR_IRQS
	457	# define ACTUAL_NR_IRQS nr_irqs
	458	#endif
	459
c78b9b65 TG	460	int show_interrupts(struct seq_file p, void v)
	461	{
	462	static int prec;
	463
	464	unsigned long flags, any_count = 0;
	465	int i = (loff_t ) v, j;
	466	struct irqaction *action;
	467	struct irq_desc *desc;
	468
a6e120ed	469	if (i > ACTUAL_NR_IRQS)
c78b9b65 TG	470	return 0;
c78b9b65 TG	471
a6e120ed	472	if (i == ACTUAL_NR_IRQS)
c78b9b65 TG	473	return arch_show_interrupts(p, prec);
	474
	475	/* print header and calculate the width of the first column */
	476	if (i == 0) {
	477	for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
	478	j *= 10;
	479
	480	seq_printf(p, "%*s", prec + 8, "");
	481	for_each_online_cpu(j)
	482	seq_printf(p, "CPU%-8d", j);
	483	seq_putc(p, '\n');
	484	}
	485
74bdf781	486	rcu_read_lock();
c78b9b65	487	desc = irq_to_desc(i);
83cfac95	488	if (!desc \|\| irq_settings_is_hidden(desc))
c291ee62	489	goto outsparse;
c78b9b65	490
9e42ad10	491	if (desc->kstat_irqs) {
74bdf781	492	for_each_online_cpu(j)
9e42ad10 TG	493	any_count \|= data_race(*per_cpu_ptr(desc->kstat_irqs, j));
9e42ad10 TG	494	}
74bdf781 ED	495
	496	if ((!desc->action \|\| irq_desc_is_chained(desc)) && !any_count)
	497	goto outsparse;
c78b9b65 TG	498
	499	seq_printf(p, "%*d: ", prec, i);
	500	for_each_online_cpu(j)
74bdf781 ED	501	seq_printf(p, "%10u ", desc->kstat_irqs ?
74bdf781 ED	502	*per_cpu_ptr(desc->kstat_irqs, j) : 0);
ab7798ff	503
74bdf781	504	raw_spin_lock_irqsave(&desc->lock, flags);
ab7798ff TG	505	if (desc->irq_data.chip) {
	506	if (desc->irq_data.chip->irq_print_chip)
	507	desc->irq_data.chip->irq_print_chip(&desc->irq_data, p);
	508	else if (desc->irq_data.chip->name)
	509	seq_printf(p, " %8s", desc->irq_data.chip->name);
	510	else
	511	seq_printf(p, " %8s", "-");
	512	} else {
	513	seq_printf(p, " %8s", "None");
	514	}
c12d2f42 GL	515	if (desc->irq_data.domain)
c12d2f42 GL	516	seq_printf(p, " %*d", prec, (int) desc->irq_data.hwirq);
f435da41 HS	517	else
f435da41 HS	518	seq_printf(p, " %*s", prec, "");
94b2c363	519	#ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
ab7798ff TG	520	seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
ab7798ff TG	521	#endif
ee0401ec TG	522	if (desc->name)
ee0401ec TG	523	seq_printf(p, "-%-8s", desc->name);
c78b9b65	524
74bdf781	525	action = desc->action;
c78b9b65 TG	526	if (action) {
	527	seq_printf(p, " %s", action->name);
	528	while ((action = action->next) != NULL)
	529	seq_printf(p, ", %s", action->name);
	530	}
	531
	532	seq_putc(p, '\n');
c78b9b65	533	raw_spin_unlock_irqrestore(&desc->lock, flags);
c291ee62	534	outsparse:
74bdf781	535	rcu_read_unlock();
c78b9b65 TG	536	return 0;
	537	}
	538	#endif