xref: /openbmc/linux/kernel/irq/proc.c (revision 4bb1e4e7) 
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  */
35 static struct proc_dir_entry *root_irq_dir;
36 
37 #ifdef CONFIG_SMP
38 
39 enum {
40 	AFFINITY,
41 	AFFINITY_LIST,
42 	EFFECTIVE,
43 	EFFECTIVE_LIST,
44 };
45 
46 static 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 	switch (type) {
52 	case AFFINITY:
53 	case AFFINITY_LIST:
54 		mask = desc->irq_common_data.affinity;
55 #ifdef CONFIG_GENERIC_PENDING_IRQ
56 		if (irqd_is_setaffinity_pending(&desc->irq_data))
57 			mask = desc->pending_mask;
58 #endif
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 
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 
89 	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
90 		return -ENOMEM;
91 
92 	raw_spin_lock_irqsave(&desc->lock, flags);
93 	if (desc->affinity_hint)
94 		cpumask_copy(mask, desc->affinity_hint);
95 	raw_spin_unlock_irqrestore(&desc->lock, flags);
96 
97 	seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
98 	free_cpumask_var(mask);
99 
100 	return 0;
101 }
102 
103 int no_irq_affinity;
104 static int irq_affinity_proc_show(struct seq_file *m, void *v)
105 {
106 	return show_irq_affinity(AFFINITY, m);
107 }
108 
109 static int irq_affinity_list_proc_show(struct seq_file *m, void *v)
110 {
111 	return show_irq_affinity(AFFINITY_LIST, m);
112 }
113 
114 
115 static ssize_t write_irq_affinity(int type, struct file *file,
116 		const char __user *buffer, size_t count, loff_t *pos)
117 {
118 	unsigned int irq = (int)(long)PDE_DATA(file_inode(file));
119 	cpumask_var_t new_value;
120 	int err;
121 
122 	if (!irq_can_set_affinity_usr(irq) || no_irq_affinity)
123 		return -EIO;
124 
125 	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
126 		return -ENOMEM;
127 
128 	if (type)
129 		err = cpumask_parselist_user(buffer, count, new_value);
130 	else
131 		err = cpumask_parse_user(buffer, count, new_value);
132 	if (err)
133 		goto free_cpumask;
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 	 */
140 	if (!cpumask_intersects(new_value, cpu_online_mask)) {
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;
146 	} else {
147 		err = irq_set_affinity(irq, new_value);
148 		if (!err)
149 			err = count;
150 	}
151 
152 free_cpumask:
153 	free_cpumask_var(new_value);
154 	return err;
155 }
156 
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 
169 static int irq_affinity_proc_open(struct inode *inode, struct file *file)
170 {
171 	return single_open(file, irq_affinity_proc_show, PDE_DATA(inode));
172 }
173 
174 static int irq_affinity_list_proc_open(struct inode *inode, struct file *file)
175 {
176 	return single_open(file, irq_affinity_list_proc_show, PDE_DATA(inode));
177 }
178 
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 
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 
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 }
205 #endif
206 
207 static int default_affinity_show(struct seq_file *m, void *v)
208 {
209 	seq_printf(m, "%*pb\n", cpumask_pr_args(irq_default_affinity));
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)
215 {
216 	cpumask_var_t new_value;
217 	int err;
218 
219 	if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
220 		return -ENOMEM;
221 
222 	err = cpumask_parse_user(buffer, count, new_value);
223 	if (err)
224 		goto out;
225 
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 	 */
231 	if (!cpumask_intersects(new_value, cpu_online_mask)) {
232 		err = -EINVAL;
233 		goto out;
234 	}
235 
236 	cpumask_copy(irq_default_affinity, new_value);
237 	err = count;
238 
239 out:
240 	free_cpumask_var(new_value);
241 	return err;
242 }
243 
244 static int default_affinity_open(struct inode *inode, struct file *file)
245 {
246 	return single_open(file, default_affinity_show, PDE_DATA(inode));
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 };
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 
261 	seq_printf(m, "%d\n", irq_desc_get_node(desc));
262 	return 0;
263 }
264 #endif
265 
266 static int irq_spurious_proc_show(struct seq_file *m, void *v)
267 {
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 
276 #define MAX_NAMELEN 128
277 
278 static int name_unique(unsigned int irq, struct irqaction *new_action)
279 {
280 	struct irq_desc *desc = irq_to_desc(irq);
281 	struct irqaction *action;
282 	unsigned long flags;
283 	int ret = 1;
284 
285 	raw_spin_lock_irqsave(&desc->lock, flags);
286 	for_each_action_of_desc(desc, action) {
287 		if ((action != new_action) && action->name &&
288 				!strcmp(new_action->name, action->name)) {
289 			ret = 0;
290 			break;
291 		}
292 	}
293 	raw_spin_unlock_irqrestore(&desc->lock, flags);
294 	return ret;
295 }
296 
297 void register_handler_proc(unsigned int irq, struct irqaction *action)
298 {
299 	char name [MAX_NAMELEN];
300 	struct irq_desc *desc = irq_to_desc(irq);
301 
302 	if (!desc->dir || action->dir || !action->name ||
303 					!name_unique(irq, action))
304 		return;
305 
306 	snprintf(name, MAX_NAMELEN, "%s", action->name);
307 
308 	/* create /proc/irq/1234/handler/ */
309 	action->dir = proc_mkdir(name, desc->dir);
310 }
311 
312 #undef MAX_NAMELEN
313 
314 #define MAX_NAMELEN 10
315 
316 void register_irq_proc(unsigned int irq, struct irq_desc *desc)
317 {
318 	static DEFINE_MUTEX(register_lock);
319 	void __maybe_unused *irqp = (void *)(unsigned long) irq;
320 	char name [MAX_NAMELEN];
321 
322 	if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip))
323 		return;
324 
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 
335 	sprintf(name, "%d", irq);
336 
337 	/* create /proc/irq/1234 */
338 	desc->dir = proc_mkdir(name, root_irq_dir);
339 	if (!desc->dir)
340 		goto out_unlock;
341 
342 #ifdef CONFIG_SMP
343 	/* create /proc/irq/<irq>/smp_affinity */
344 	proc_create_data("smp_affinity", 0644, desc->dir,
345 			 &irq_affinity_proc_fops, irqp);
346 
347 	/* create /proc/irq/<irq>/affinity_hint */
348 	proc_create_single_data("affinity_hint", 0444, desc->dir,
349 			irq_affinity_hint_proc_show, irqp);
350 
351 	/* create /proc/irq/<irq>/smp_affinity_list */
352 	proc_create_data("smp_affinity_list", 0644, desc->dir,
353 			 &irq_affinity_list_proc_fops, irqp);
354 
355 	proc_create_single_data("node", 0444, desc->dir, irq_node_proc_show,
356 			irqp);
357 # ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
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);
362 # endif
363 #endif
364 	proc_create_single_data("spurious", 0444, desc->dir,
365 			irq_spurious_proc_show, (void *)(long)irq);
366 
367 out_unlock:
368 	mutex_unlock(&register_lock);
369 }
370 
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);
380 	remove_proc_entry("smp_affinity_list", desc->dir);
381 	remove_proc_entry("node", desc->dir);
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
386 #endif
387 	remove_proc_entry("spurious", desc->dir);
388 
389 	sprintf(name, "%u", irq);
390 	remove_proc_entry(name, root_irq_dir);
391 }
392 
393 #undef MAX_NAMELEN
394 
395 void unregister_handler_proc(unsigned int irq, struct irqaction *action)
396 {
397 	proc_remove(action->dir);
398 }
399 
400 static void register_default_affinity_proc(void)
401 {
402 #ifdef CONFIG_SMP
403 	proc_create("irq/default_smp_affinity", 0644, NULL,
404 		    &default_affinity_proc_fops);
405 #endif
406 }
407 
408 void init_irq_proc(void)
409 {
410 	unsigned int irq;
411 	struct irq_desc *desc;
412 
413 	/* create /proc/irq */
414 	root_irq_dir = proc_mkdir("irq", NULL);
415 	if (!root_irq_dir)
416 		return;
417 
418 	register_default_affinity_proc();
419 
420 	/*
421 	 * Create entries for all existing IRQs.
422 	 */
423 	for_each_irq_desc(irq, desc)
424 		register_irq_proc(irq, desc);
425 }
426 
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 
434 #ifndef ACTUAL_NR_IRQS
435 # define ACTUAL_NR_IRQS nr_irqs
436 #endif
437 
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 
447 	if (i > ACTUAL_NR_IRQS)
448 		return 0;
449 
450 	if (i == ACTUAL_NR_IRQS)
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 
464 	rcu_read_lock();
465 	desc = irq_to_desc(i);
466 	if (!desc)
467 		goto outsparse;
468 
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;
475 
476 	seq_printf(p, "%*d: ", prec, i);
477 	for_each_online_cpu(j)
478 		seq_printf(p, "%10u ", desc->kstat_irqs ?
479 					*per_cpu_ptr(desc->kstat_irqs, j) : 0);
480 
481 	raw_spin_lock_irqsave(&desc->lock, flags);
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 	}
492 	if (desc->irq_data.domain)
493 		seq_printf(p, " %*d", prec, (int) desc->irq_data.hwirq);
494 	else
495 		seq_printf(p, " %*s", prec, "");
496 #ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
497 	seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
498 #endif
499 	if (desc->name)
500 		seq_printf(p, "-%-8s", desc->name);
501 
502 	action = desc->action;
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');
510 	raw_spin_unlock_irqrestore(&desc->lock, flags);
511 outsparse:
512 	rcu_read_unlock();
513 	return 0;
514 }
515 #endif
516