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