proc.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  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>
  9#include <linux/gfp.h>
 10#include <linux/proc_fs.h>
 11#include <linux/seq_file.h>
 12#include <linux/interrupt.h>
 13#include <linux/kernel_stat.h>
 14#include <linux/mutex.h>
 15
 16#include "internals.h"
 17
 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 */
 35static struct proc_dir_entry *root_irq_dir;
 36
 37#ifdef CONFIG_SMP
 38
 39enum {
 40	AFFINITY,
 41	AFFINITY_LIST,
 42	EFFECTIVE,
 43	EFFECTIVE_LIST,
 44};
 45
 46static int show_irq_affinity(int type, struct seq_file *m)
 47{
 48	struct irq_desc *desc = irq_to_desc((long)m->private);
 49	const struct cpumask *mask;
 50
 51	guard(raw_spinlock_irq)(&desc->lock);
 52
 53	switch (type) {
 54	case AFFINITY:
 55	case AFFINITY_LIST:
 56		mask = desc->irq_common_data.affinity;
 57		if (irq_move_pending(&desc->irq_data))
 58			mask = irq_desc_get_pending_mask(desc);
 59		break;
 60	case EFFECTIVE:
 61	case EFFECTIVE_LIST:
 62#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
 63		mask = irq_data_get_effective_affinity_mask(&desc->irq_data);
 64		break;
 65#endif
 66	default:
 67		return -EINVAL;
 68	}
 69
 70	switch (type) {
 71	case AFFINITY_LIST:
 72	case EFFECTIVE_LIST:
 73		seq_printf(m, "%*pbl\n", cpumask_pr_args(mask));
 74		break;
 75	case AFFINITY:
 76	case EFFECTIVE:
 77		seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
 78		break;
 79	}
 80	return 0;
 81}
 82
 83static 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	cpumask_var_t mask;
 87
 88	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
 89		return -ENOMEM;
 90
 91	scoped_guard(raw_spinlock_irq, &desc->lock) {
 92		if (desc->affinity_hint)
 93			cpumask_copy(mask, desc->affinity_hint);
 94	}
 95
 96	seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
 97	free_cpumask_var(mask);
 98	return 0;
 99}
100
101int no_irq_affinity;
102static int irq_affinity_proc_show(struct seq_file *m, void *v)
103{
104	return show_irq_affinity(AFFINITY, m);
105}
106
107static int irq_affinity_list_proc_show(struct seq_file *m, void *v)
108{
109	return show_irq_affinity(AFFINITY_LIST, m);
110}
111
112#ifndef CONFIG_AUTO_IRQ_AFFINITY
113static inline int irq_select_affinity_usr(unsigned int irq)
114{
115	/*
116	 * If the interrupt is started up already then this fails. The
117	 * interrupt is assigned to an online CPU already. There is no
118	 * point to move it around randomly. Tell user space that the
119	 * selected mask is bogus.
120	 *
121	 * If not then any change to the affinity is pointless because the
122	 * startup code invokes irq_setup_affinity() which will select
123	 * a online CPU anyway.
124	 */
125	return -EINVAL;
126}
127#else
128/* ALPHA magic affinity auto selector. Keep it for historical reasons. */
129static inline int irq_select_affinity_usr(unsigned int irq)
130{
131	return irq_select_affinity(irq);
132}
133#endif
134
135static ssize_t write_irq_affinity(int type, struct file *file,
136		const char __user *buffer, size_t count, loff_t *pos)
137{
138	unsigned int irq = (int)(long)pde_data(file_inode(file));
139	cpumask_var_t new_value;
140	int err;
141
142	if (!irq_can_set_affinity_usr(irq) || no_irq_affinity)
143		return -EPERM;
144
145	if (!zalloc_cpumask_var(&new_value, GFP_KERNEL))
146		return -ENOMEM;
147
148	if (type)
149		err = cpumask_parselist_user(buffer, count, new_value);
150	else
151		err = cpumask_parse_user(buffer, count, new_value);
152	if (err)
153		goto free_cpumask;
154
155	/*
156	 * Do not allow disabling IRQs completely - it's a too easy
157	 * way to make the system unusable accidentally :-) At least
158	 * one online CPU still has to be targeted.
159	 */
160	if (!cpumask_intersects(new_value, cpu_online_mask)) {
161		/*
162		 * Special case for empty set - allow the architecture code
163		 * to set default SMP affinity.
164		 */
165		err = irq_select_affinity_usr(irq) ? -EINVAL : count;
166	} else {
167		err = irq_set_affinity(irq, new_value);
168		if (!err)
169			err = count;
170	}
171
172free_cpumask:
173	free_cpumask_var(new_value);
174	return err;
175}
176
177static ssize_t irq_affinity_proc_write(struct file *file,
178		const char __user *buffer, size_t count, loff_t *pos)
179{
180	return write_irq_affinity(0, file, buffer, count, pos);
181}
182
183static ssize_t irq_affinity_list_proc_write(struct file *file,
184		const char __user *buffer, size_t count, loff_t *pos)
185{
186	return write_irq_affinity(1, file, buffer, count, pos);
187}
188
189static int irq_affinity_proc_open(struct inode *inode, struct file *file)
190{
191	return single_open(file, irq_affinity_proc_show, pde_data(inode));
192}
193
194static int irq_affinity_list_proc_open(struct inode *inode, struct file *file)
195{
196	return single_open(file, irq_affinity_list_proc_show, pde_data(inode));
197}
198
199static const struct proc_ops irq_affinity_proc_ops = {
200	.proc_open	= irq_affinity_proc_open,
201	.proc_read	= seq_read,
202	.proc_lseek	= seq_lseek,
203	.proc_release	= single_release,
204	.proc_write	= irq_affinity_proc_write,
205};
206
207static const struct proc_ops irq_affinity_list_proc_ops = {
208	.proc_open	= irq_affinity_list_proc_open,
209	.proc_read	= seq_read,
210	.proc_lseek	= seq_lseek,
211	.proc_release	= single_release,
212	.proc_write	= irq_affinity_list_proc_write,
213};
214
215#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
216static int irq_effective_aff_proc_show(struct seq_file *m, void *v)
217{
218	return show_irq_affinity(EFFECTIVE, m);
219}
220
221static int irq_effective_aff_list_proc_show(struct seq_file *m, void *v)
222{
223	return show_irq_affinity(EFFECTIVE_LIST, m);
224}
225#endif
226
227static int default_affinity_show(struct seq_file *m, void *v)
228{
229	seq_printf(m, "%*pb\n", cpumask_pr_args(irq_default_affinity));
230	return 0;
231}
232
233static ssize_t default_affinity_write(struct file *file,
234		const char __user *buffer, size_t count, loff_t *ppos)
235{
236	cpumask_var_t new_value;
237	int err;
238
239	if (!zalloc_cpumask_var(&new_value, GFP_KERNEL))
240		return -ENOMEM;
241
242	err = cpumask_parse_user(buffer, count, new_value);
243	if (err)
244		goto out;
245
246	/*
247	 * Do not allow disabling IRQs completely - it's a too easy
248	 * way to make the system unusable accidentally :-) At least
249	 * one online CPU still has to be targeted.
250	 */
251	if (!cpumask_intersects(new_value, cpu_online_mask)) {
252		err = -EINVAL;
253		goto out;
254	}
255
256	cpumask_copy(irq_default_affinity, new_value);
257	err = count;
258
259out:
260	free_cpumask_var(new_value);
261	return err;
262}
263
264static int default_affinity_open(struct inode *inode, struct file *file)
265{
266	return single_open(file, default_affinity_show, pde_data(inode));
267}
268
269static const struct proc_ops default_affinity_proc_ops = {
270	.proc_open	= default_affinity_open,
271	.proc_read	= seq_read,
272	.proc_lseek	= seq_lseek,
273	.proc_release	= single_release,
274	.proc_write	= default_affinity_write,
275};
276
277static int irq_node_proc_show(struct seq_file *m, void *v)
278{
279	struct irq_desc *desc = irq_to_desc((long) m->private);
280
281	seq_printf(m, "%d\n", irq_desc_get_node(desc));
282	return 0;
283}
284#endif
285
286static int irq_spurious_proc_show(struct seq_file *m, void *v)
287{
288	struct irq_desc *desc = irq_to_desc((long) m->private);
289
290	seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
291		   desc->irq_count, desc->irqs_unhandled,
292		   jiffies_to_msecs(desc->last_unhandled));
293	return 0;
294}
295
296#define MAX_NAMELEN 128
297
298static bool name_unique(unsigned int irq, struct irqaction *new_action)
299{
300	struct irq_desc *desc = irq_to_desc(irq);
301	struct irqaction *action;
302
303	guard(raw_spinlock_irq)(&desc->lock);
304	for_each_action_of_desc(desc, action) {
305		if ((action != new_action) && action->name &&
306		    !strcmp(new_action->name, action->name))
307			return false;
308	}
309	return true;
310}
311
312void register_handler_proc(unsigned int irq, struct irqaction *action)
313{
314	char name[MAX_NAMELEN];
315	struct irq_desc *desc = irq_to_desc(irq);
316
317	if (!desc->dir || action->dir || !action->name || !name_unique(irq, action))
318		return;
319
320	snprintf(name, MAX_NAMELEN, "%s", action->name);
321
322	/* create /proc/irq/1234/handler/ */
323	action->dir = proc_mkdir(name, desc->dir);
324}
325
326#undef MAX_NAMELEN
327
328#define MAX_NAMELEN 10
329
330void register_irq_proc(unsigned int irq, struct irq_desc *desc)
331{
332	static DEFINE_MUTEX(register_lock);
333	void __maybe_unused *irqp = (void *)(unsigned long) irq;
334	char name [MAX_NAMELEN];
335
336	if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip))
337		return;
338
339	/*
340	 * irq directories are registered only when a handler is
341	 * added, not when the descriptor is created, so multiple
342	 * tasks might try to register at the same time.
343	 */
344	guard(mutex)(&register_lock);
345
346	if (desc->dir)
347		return;
348
349	/* create /proc/irq/1234 */
350	sprintf(name, "%u", irq);
351	desc->dir = proc_mkdir(name, root_irq_dir);
352	if (!desc->dir)
353		return;
354
355#ifdef CONFIG_SMP
356	umode_t umode = S_IRUGO;
357
358	if (irq_can_set_affinity_usr(desc->irq_data.irq))
359		umode |= S_IWUSR;
360
361	/* create /proc/irq/<irq>/smp_affinity */
362	proc_create_data("smp_affinity", umode, desc->dir, &irq_affinity_proc_ops, irqp);
363
364	/* create /proc/irq/<irq>/affinity_hint */
365	proc_create_single_data("affinity_hint", 0444, desc->dir,
366				irq_affinity_hint_proc_show, irqp);
367
368	/* create /proc/irq/<irq>/smp_affinity_list */
369	proc_create_data("smp_affinity_list", umode, desc->dir,
370			 &irq_affinity_list_proc_ops, irqp);
371
372	proc_create_single_data("node", 0444, desc->dir, irq_node_proc_show, irqp);
373# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
374	proc_create_single_data("effective_affinity", 0444, desc->dir,
375				irq_effective_aff_proc_show, irqp);
376	proc_create_single_data("effective_affinity_list", 0444, desc->dir,
377				irq_effective_aff_list_proc_show, irqp);
378# endif
379#endif
380	proc_create_single_data("spurious", 0444, desc->dir,
381				irq_spurious_proc_show, (void *)(long)irq);
382
383}
384
385void unregister_irq_proc(unsigned int irq, struct irq_desc *desc)
386{
387	char name [MAX_NAMELEN];
388
389	if (!root_irq_dir || !desc->dir)
390		return;
391#ifdef CONFIG_SMP
392	remove_proc_entry("smp_affinity", desc->dir);
393	remove_proc_entry("affinity_hint", desc->dir);
394	remove_proc_entry("smp_affinity_list", desc->dir);
395	remove_proc_entry("node", desc->dir);
396# ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
397	remove_proc_entry("effective_affinity", desc->dir);
398	remove_proc_entry("effective_affinity_list", desc->dir);
399# endif
400#endif
401	remove_proc_entry("spurious", desc->dir);
402
403	sprintf(name, "%u", irq);
404	remove_proc_entry(name, root_irq_dir);
405}
406
407#undef MAX_NAMELEN
408
409void unregister_handler_proc(unsigned int irq, struct irqaction *action)
410{
411	proc_remove(action->dir);
412}
413
414static void register_default_affinity_proc(void)
415{
416#ifdef CONFIG_SMP
417	proc_create("irq/default_smp_affinity", 0644, NULL,
418		    &default_affinity_proc_ops);
419#endif
420}
421
422void init_irq_proc(void)
423{
424	unsigned int irq;
425	struct irq_desc *desc;
426
427	/* create /proc/irq */
428	root_irq_dir = proc_mkdir("irq", NULL);
429	if (!root_irq_dir)
430		return;
431
432	register_default_affinity_proc();
433
434	/*
435	 * Create entries for all existing IRQs.
436	 */
437	for_each_irq_desc(irq, desc)
438		register_irq_proc(irq, desc);
439}
440
441#ifdef CONFIG_GENERIC_IRQ_SHOW
442
443int __weak arch_show_interrupts(struct seq_file *p, int prec)
444{
445	return 0;
446}
447
448#ifndef ACTUAL_NR_IRQS
449# define ACTUAL_NR_IRQS irq_get_nr_irqs()
450#endif
451
452int show_interrupts(struct seq_file *p, void *v)
453{
454	const unsigned int nr_irqs = irq_get_nr_irqs();
455	static int prec;
456
457	int i = *(loff_t *) v, j;
458	struct irqaction *action;
459	struct irq_desc *desc;
460
461	if (i > ACTUAL_NR_IRQS)
462		return 0;
463
464	if (i == ACTUAL_NR_IRQS)
465		return arch_show_interrupts(p, prec);
466
467	/* print header and calculate the width of the first column */
468	if (i == 0) {
469		for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
470			j *= 10;
471
472		seq_printf(p, "%*s", prec + 8, "");
473		for_each_online_cpu(j)
474			seq_printf(p, "CPU%-8d", j);
475		seq_putc(p, '\n');
476	}
477
478	guard(rcu)();
479	desc = irq_to_desc(i);
480	if (!desc || irq_settings_is_hidden(desc))
481		return 0;
482
483	if (!desc->action || irq_desc_is_chained(desc) || !desc->kstat_irqs)
484		return 0;
485
486	seq_printf(p, "%*d:", prec, i);
487	for_each_online_cpu(j) {
488		unsigned int cnt = desc->kstat_irqs ? per_cpu(desc->kstat_irqs->cnt, j) : 0;
489
490		seq_put_decimal_ull_width(p, " ", cnt, 10);
491	}
492	seq_putc(p, ' ');
493
494	guard(raw_spinlock_irq)(&desc->lock);
495	if (desc->irq_data.chip) {
496		if (desc->irq_data.chip->irq_print_chip)
497			desc->irq_data.chip->irq_print_chip(&desc->irq_data, p);
498		else if (desc->irq_data.chip->name)
499			seq_printf(p, "%8s", desc->irq_data.chip->name);
500		else
501			seq_printf(p, "%8s", "-");
502	} else {
503		seq_printf(p, "%8s", "None");
504	}
505	if (desc->irq_data.domain)
506		seq_printf(p, " %*lu", prec, desc->irq_data.hwirq);
507	else
508		seq_printf(p, " %*s", prec, "");
509#ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
510	seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
511#endif
512	if (desc->name)
513		seq_printf(p, "-%-8s", desc->name);
514
515	action = desc->action;
516	if (action) {
517		seq_printf(p, "  %s", action->name);
518		while ((action = action->next) != NULL)
519			seq_printf(p, ", %s", action->name);
520	}
521
522	seq_putc(p, '\n');
523	return 0;
524}
525#endif