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 enum {
  41         AFFINITY,
  42         AFFINITY_LIST,
  43         EFFECTIVE,
  44         EFFECTIVE_LIST,
  45 };
  46
  47 static int show_irq_affinity(int type, struct seq_file *m)
  48 {
  49         struct irq_desc *desc = irq_to_desc((long)m->private);
  50         const struct cpumask *mask;
  51
  52         switch (type) {
  53         case AFFINITY:
  54         case AFFINITY_LIST:
  55                 mask = desc->irq_common_data.affinity;
  56 #ifdef CONFIG_GENERIC_PENDING_IRQ
  57                 if (irqd_is_setaffinity_pending(&desc->irq_data))
  58                         mask = desc->pending_mask;
  59 #endif
  60                 break;
  61         case EFFECTIVE:
  62         case EFFECTIVE_LIST:
  63 #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
  64                 mask = desc->irq_common_data.effective_affinity;
  65                 break;
  66 #else
  67                 return -EINVAL;
  68 #endif
  69         };
  70
  71         switch (type) {
  72         case AFFINITY_LIST:
  73         case EFFECTIVE_LIST:
  74                 seq_printf(m, "%*pbl\n", cpumask_pr_args(mask));
  75                 break;
  76         case AFFINITY:
  77         case EFFECTIVE:
  78                 seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
  79                 break;
  80         }
  81         return 0;
  82 }
  83
  84 static int irq_affinity_hint_proc_show(struct seq_file *m, void *v)
  85 {
  86         struct irq_desc *desc = irq_to_desc((long)m->private);
  87         unsigned long flags;
  88         cpumask_var_t mask;
  89
  90         if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
  91                 return -ENOMEM;
  92
  93         raw_spin_lock_irqsave(&desc->lock, flags);
  94         if (desc->affinity_hint)
  95                 cpumask_copy(mask, desc->affinity_hint);
  96         raw_spin_unlock_irqrestore(&desc->lock, flags);
  97
  98         seq_printf(m, "%*pb\n", cpumask_pr_args(mask));
  99         free_cpumask_var(mask);
 100
 101         return 0;
 102 }
 103
 104 #ifndef is_affinity_mask_valid
 105 #define is_affinity_mask_valid(val) 1
 106 #endif
 107
 108 int no_irq_affinity;
 109 static int irq_affinity_proc_show(struct seq_file *m, void *v)
 110 {
 111         return show_irq_affinity(AFFINITY, m);
 112 }
 113
 114 static int irq_affinity_list_proc_show(struct seq_file *m, void *v)
 115 {
 116         return show_irq_affinity(AFFINITY_LIST, m);
 117 }
 118
 119
 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
 127         if (!irq_can_set_affinity_usr(irq) || no_irq_affinity)
 128                 return -EIO;
 129
 130         if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
 131                 return -ENOMEM;
 132
 133         if (type)
 134                 err = cpumask_parselist_user(buffer, count, new_value);
 135         else
 136                 err = cpumask_parse_user(buffer, count, new_value);
 137         if (err)
 138                 goto free_cpumask;
 139
 140         if (!is_affinity_mask_valid(new_value)) {
 141                 err = -EINVAL;
 142                 goto free_cpumask;
 143         }
 144
 145         /*
 146          * Do not allow disabling IRQs completely - it's a too easy
 147          * way to make the system unusable accidentally :-) At least
 148          * one online CPU still has to be targeted.
 149          */
 150         if (!cpumask_intersects(new_value, cpu_online_mask)) {
 151                 /*
 152                  * Special case for empty set - allow the architecture code
 153                  * to set default SMP affinity.
 154                  */
 155                 err = irq_select_affinity_usr(irq) ? -EINVAL : count;
 156         } else {
 157                 irq_set_affinity(irq, new_value);
 158                 err = count;
 159         }
 160
 161 free_cpumask:
 162         free_cpumask_var(new_value);
 163         return err;
 164 }
 165
 166 static ssize_t irq_affinity_proc_write(struct file *file,
 167                 const char __user *buffer, size_t count, loff_t *pos)
 168 {
 169         return write_irq_affinity(0, file, buffer, count, pos);
 170 }
 171
 172 static ssize_t irq_affinity_list_proc_write(struct file *file,
 173                 const char __user *buffer, size_t count, loff_t *pos)
 174 {
 175         return write_irq_affinity(1, file, buffer, count, pos);
 176 }
 177
 178 static int irq_affinity_proc_open(struct inode *inode, struct file *file)
 179 {
 180         return single_open(file, irq_affinity_proc_show, PDE_DATA(inode));
 181 }
 182
 183 static int irq_affinity_list_proc_open(struct inode *inode, struct file *file)
 184 {
 185         return single_open(file, irq_affinity_list_proc_show, PDE_DATA(inode));
 186 }
 187
 188 static int irq_affinity_hint_proc_open(struct inode *inode, struct file *file)
 189 {
 190         return single_open(file, irq_affinity_hint_proc_show, PDE_DATA(inode));
 191 }
 192
 193 static const struct file_operations irq_affinity_proc_fops = {
 194         .open           = irq_affinity_proc_open,
 195         .read           = seq_read,
 196         .llseek         = seq_lseek,
 197         .release        = single_release,
 198         .write          = irq_affinity_proc_write,
 199 };
 200
 201 static const struct file_operations irq_affinity_hint_proc_fops = {
 202         .open           = irq_affinity_hint_proc_open,
 203         .read           = seq_read,
 204         .llseek         = seq_lseek,
 205         .release        = single_release,
 206 };
 207
 208 static const struct file_operations irq_affinity_list_proc_fops = {
 209         .open           = irq_affinity_list_proc_open,
 210         .read           = seq_read,
 211         .llseek         = seq_lseek,
 212         .release        = single_release,
 213         .write          = irq_affinity_list_proc_write,
 214 };
 215
 216 #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
 217 static int irq_effective_aff_proc_show(struct seq_file *m, void *v)
 218 {
 219         return show_irq_affinity(EFFECTIVE, m);
 220 }
 221
 222 static int irq_effective_aff_list_proc_show(struct seq_file *m, void *v)
 223 {
 224         return show_irq_affinity(EFFECTIVE_LIST, m);
 225 }
 226
 227 static int irq_effective_aff_proc_open(struct inode *inode, struct file *file)
 228 {
 229         return single_open(file, irq_effective_aff_proc_show, PDE_DATA(inode));
 230 }
 231
 232 static int irq_effective_aff_list_proc_open(struct inode *inode,
 233                                             struct file *file)
 234 {
 235         return single_open(file, irq_effective_aff_list_proc_show,
 236                            PDE_DATA(inode));
 237 }
 238
 239 static const struct file_operations irq_effective_aff_proc_fops = {
 240         .open           = irq_effective_aff_proc_open,
 241         .read           = seq_read,
 242         .llseek         = seq_lseek,
 243         .release        = single_release,
 244 };
 245
 246 static const struct file_operations irq_effective_aff_list_proc_fops = {
 247         .open           = irq_effective_aff_list_proc_open,
 248         .read           = seq_read,
 249         .llseek         = seq_lseek,
 250         .release        = single_release,
 251 };
 252 #endif
 253
 254 static int default_affinity_show(struct seq_file *m, void *v)
 255 {
 256         seq_printf(m, "%*pb\n", cpumask_pr_args(irq_default_affinity));
 257         return 0;
 258 }
 259
 260 static ssize_t default_affinity_write(struct file *file,
 261                 const char __user *buffer, size_t count, loff_t *ppos)
 262 {
 263         cpumask_var_t new_value;
 264         int err;
 265
 266         if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
 267                 return -ENOMEM;
 268
 269         err = cpumask_parse_user(buffer, count, new_value);
 270         if (err)
 271                 goto out;
 272
 273         if (!is_affinity_mask_valid(new_value)) {
 274                 err = -EINVAL;
 275                 goto out;
 276         }
 277
 278         /*
 279          * Do not allow disabling IRQs completely - it's a too easy
 280          * way to make the system unusable accidentally :-) At least
 281          * one online CPU still has to be targeted.
 282          */
 283         if (!cpumask_intersects(new_value, cpu_online_mask)) {
 284                 err = -EINVAL;
 285                 goto out;
 286         }
 287
 288         cpumask_copy(irq_default_affinity, new_value);
 289         err = count;
 290
 291 out:
 292         free_cpumask_var(new_value);
 293         return err;
 294 }
 295
 296 static int default_affinity_open(struct inode *inode, struct file *file)
 297 {
 298         return single_open(file, default_affinity_show, PDE_DATA(inode));
 299 }
 300
 301 static const struct file_operations default_affinity_proc_fops = {
 302         .open           = default_affinity_open,
 303         .read           = seq_read,
 304         .llseek         = seq_lseek,
 305         .release        = single_release,
 306         .write          = default_affinity_write,
 307 };
 308
 309 static int irq_node_proc_show(struct seq_file *m, void *v)
 310 {
 311         struct irq_desc *desc = irq_to_desc((long) m->private);
 312
 313         seq_printf(m, "%d\n", irq_desc_get_node(desc));
 314         return 0;
 315 }
 316
 317 static int irq_node_proc_open(struct inode *inode, struct file *file)
 318 {
 319         return single_open(file, irq_node_proc_show, PDE_DATA(inode));
 320 }
 321
 322 static const struct file_operations irq_node_proc_fops = {
 323         .open           = irq_node_proc_open,
 324         .read           = seq_read,
 325         .llseek         = seq_lseek,
 326         .release        = single_release,
 327 };
 328 #endif
 329
 330 static int irq_spurious_proc_show(struct seq_file *m, void *v)
 331 {
 332         struct irq_desc *desc = irq_to_desc((long) m->private);
 333
 334         seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
 335                    desc->irq_count, desc->irqs_unhandled,
 336                    jiffies_to_msecs(desc->last_unhandled));
 337         return 0;
 338 }
 339
 340 static int irq_spurious_proc_open(struct inode *inode, struct file *file)
 341 {
 342         return single_open(file, irq_spurious_proc_show, PDE_DATA(inode));
 343 }
 344
 345 static const struct file_operations irq_spurious_proc_fops = {
 346         .open           = irq_spurious_proc_open,
 347         .read           = seq_read,
 348         .llseek         = seq_lseek,
 349         .release        = single_release,
 350 };
 351
 352 #define MAX_NAMELEN 128
 353
 354 static int name_unique(unsigned int irq, struct irqaction *new_action)
 355 {
 356         struct irq_desc *desc = irq_to_desc(irq);
 357         struct irqaction *action;
 358         unsigned long flags;
 359         int ret = 1;
 360
 361         raw_spin_lock_irqsave(&desc->lock, flags);
 362         for_each_action_of_desc(desc, action) {
 363                 if ((action != new_action) && action->name &&
 364                                 !strcmp(new_action->name, action->name)) {
 365                         ret = 0;
 366                         break;
 367                 }
 368         }
 369         raw_spin_unlock_irqrestore(&desc->lock, flags);
 370         return ret;
 371 }
 372
 373 void register_handler_proc(unsigned int irq, struct irqaction *action)
 374 {
 375         char name [MAX_NAMELEN];
 376         struct irq_desc *desc = irq_to_desc(irq);
 377
 378         if (!desc->dir || action->dir || !action->name ||
 379                                         !name_unique(irq, action))
 380                 return;
 381
 382         snprintf(name, MAX_NAMELEN, "%s", action->name);
 383
 384         /* create /proc/irq/1234/handler/ */
 385         action->dir = proc_mkdir(name, desc->dir);
 386 }
 387
 388 #undef MAX_NAMELEN
 389
 390 #define MAX_NAMELEN 10
 391
 392 void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 393 {
 394         static DEFINE_MUTEX(register_lock);
 395         void __maybe_unused *irqp = (void *)(unsigned long) irq;
 396         char name [MAX_NAMELEN];
 397
 398         if (!root_irq_dir || (desc->irq_data.chip == &no_irq_chip))
 399                 return;
 400
 401         /*
 402          * irq directories are registered only when a handler is
 403          * added, not when the descriptor is created, so multiple
 404          * tasks might try to register at the same time.
 405          */
 406         mutex_lock(&register_lock);
 407
 408         if (desc->dir)
 409                 goto out_unlock;
 410
 411         sprintf(name, "%d", irq);
 412
 413         /* create /proc/irq/1234 */
 414         desc->dir = proc_mkdir(name, root_irq_dir);
 415         if (!desc->dir)
 416                 goto out_unlock;
 417
 418 #ifdef CONFIG_SMP
 419         /* create /proc/irq/<irq>/smp_affinity */
 420         proc_create_data("smp_affinity", 0644, desc->dir,
 421                          &irq_affinity_proc_fops, irqp);
 422
 423         /* create /proc/irq/<irq>/affinity_hint */
 424         proc_create_data("affinity_hint", 0444, desc->dir,
 425                          &irq_affinity_hint_proc_fops, irqp);
 426
 427         /* create /proc/irq/<irq>/smp_affinity_list */
 428         proc_create_data("smp_affinity_list", 0644, desc->dir,
 429                          &irq_affinity_list_proc_fops, irqp);
 430
 431         proc_create_data("node", 0444, desc->dir,
 432                          &irq_node_proc_fops, irqp);
 433 # ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
 434         proc_create_data("effective_affinity", 0444, desc->dir,
 435                          &irq_effective_aff_proc_fops, irqp);
 436         proc_create_data("effective_affinity_list", 0444, desc->dir,
 437                          &irq_effective_aff_list_proc_fops, irqp);
 438 # endif
 439 #endif
 440         proc_create_data("spurious", 0444, desc->dir,
 441                          &irq_spurious_proc_fops, (void *)(long)irq);
 442
 443 out_unlock:
 444         mutex_unlock(&register_lock);
 445 }
 446
 447 void unregister_irq_proc(unsigned int irq, struct irq_desc *desc)
 448 {
 449         char name [MAX_NAMELEN];
 450
 451         if (!root_irq_dir || !desc->dir)
 452                 return;
 453 #ifdef CONFIG_SMP
 454         remove_proc_entry("smp_affinity", desc->dir);
 455         remove_proc_entry("affinity_hint", desc->dir);
 456         remove_proc_entry("smp_affinity_list", desc->dir);
 457         remove_proc_entry("node", desc->dir);
 458 # ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
 459         remove_proc_entry("effective_affinity", desc->dir);
 460         remove_proc_entry("effective_affinity_list", desc->dir);
 461 # endif
 462 #endif
 463         remove_proc_entry("spurious", desc->dir);
 464
 465         sprintf(name, "%u", irq);
 466         remove_proc_entry(name, root_irq_dir);
 467 }
 468
 469 #undef MAX_NAMELEN
 470
 471 void unregister_handler_proc(unsigned int irq, struct irqaction *action)
 472 {
 473         proc_remove(action->dir);
 474 }
 475
 476 static void register_default_affinity_proc(void)
 477 {
 478 #ifdef CONFIG_SMP
 479         proc_create("irq/default_smp_affinity", 0644, NULL,
 480                     &default_affinity_proc_fops);
 481 #endif
 482 }
 483
 484 void init_irq_proc(void)
 485 {
 486         unsigned int irq;
 487         struct irq_desc *desc;
 488
 489         /* create /proc/irq */
 490         root_irq_dir = proc_mkdir("irq", NULL);
 491         if (!root_irq_dir)
 492                 return;
 493
 494         register_default_affinity_proc();
 495
 496         /*
 497          * Create entries for all existing IRQs.
 498          */
 499         for_each_irq_desc(irq, desc)
 500                 register_irq_proc(irq, desc);
 501 }
 502
 503 #ifdef CONFIG_GENERIC_IRQ_SHOW
 504
 505 int __weak arch_show_interrupts(struct seq_file *p, int prec)
 506 {
 507         return 0;
 508 }
 509
 510 #ifndef ACTUAL_NR_IRQS
 511 # define ACTUAL_NR_IRQS nr_irqs
 512 #endif
 513
 514 int show_interrupts(struct seq_file *p, void *v)
 515 {
 516         static int prec;
 517
 518         unsigned long flags, any_count = 0;
 519         int i = *(loff_t *) v, j;
 520         struct irqaction *action;
 521         struct irq_desc *desc;
 522
 523         if (i > ACTUAL_NR_IRQS)
 524                 return 0;
 525
 526         if (i == ACTUAL_NR_IRQS)
 527                 return arch_show_interrupts(p, prec);
 528
 529         /* print header and calculate the width of the first column */
 530         if (i == 0) {
 531                 for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
 532                         j *= 10;
 533
 534                 seq_printf(p, "%*s", prec + 8, "");
 535                 for_each_online_cpu(j)
 536                         seq_printf(p, "CPU%-8d", j);
 537                 seq_putc(p, '\n');
 538         }
 539
 540         irq_lock_sparse();
 541         desc = irq_to_desc(i);
 542         if (!desc)
 543                 goto outsparse;
 544
 545         raw_spin_lock_irqsave(&desc->lock, flags);
 546         for_each_online_cpu(j)
 547                 any_count |= kstat_irqs_cpu(i, j);
 548         action = desc->action;
 549         if ((!action || irq_desc_is_chained(desc)) && !any_count)
 550                 goto out;
 551
 552         seq_printf(p, "%*d: ", prec, i);
 553         for_each_online_cpu(j)
 554                 seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
 555
 556         if (desc->irq_data.chip) {
 557                 if (desc->irq_data.chip->irq_print_chip)
 558                         desc->irq_data.chip->irq_print_chip(&desc->irq_data, p);
 559                 else if (desc->irq_data.chip->name)
 560                         seq_printf(p, " %8s", desc->irq_data.chip->name);
 561                 else
 562                         seq_printf(p, " %8s", "-");
 563         } else {
 564                 seq_printf(p, " %8s", "None");
 565         }
 566         if (desc->irq_data.domain)
 567                 seq_printf(p, " %*d", prec, (int) desc->irq_data.hwirq);
 568         else
 569                 seq_printf(p, " %*s", prec, "");
 570 #ifdef CONFIG_GENERIC_IRQ_SHOW_LEVEL
 571         seq_printf(p, " %-8s", irqd_is_level_type(&desc->irq_data) ? "Level" : "Edge");
 572 #endif
 573         if (desc->name)
 574                 seq_printf(p, "-%-8s", desc->name);
 575
 576         if (action) {
 577                 seq_printf(p, "  %s", action->name);
 578                 while ((action = action->next) != NULL)
 579                         seq_printf(p, ", %s", action->name);
 580         }
 581
 582         seq_putc(p, '\n');
 583 out:
 584         raw_spin_unlock_irqrestore(&desc->lock, flags);
 585 outsparse:
 586         irq_unlock_sparse();
 587         return 0;
 588 }
 589 #endif