kernel/irq/proc.c

   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 (action = desc->action ; action; action = action->next) {
 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(&register_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(&register_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