proc.c 13 KB

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