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/proc_fs.h>
  11 #include <linux/seq_file.h>
  12 #include <linux/interrupt.h>
  13
  14 #include "internals.h"
  15
  16 static struct proc_dir_entry *root_irq_dir;
  17
  18 #ifdef CONFIG_SMP
  19
  20 static int irq_affinity_proc_show(struct seq_file *m, void *v)
  21 {
  22         struct irq_desc *desc = irq_to_desc((long)m->private);
  23         const struct cpumask *mask = desc->affinity;
  24
  25 #ifdef CONFIG_GENERIC_PENDING_IRQ
  26         if (desc->status & IRQ_MOVE_PENDING)
  27                 mask = desc->pending_mask;
  28 #endif
  29         seq_cpumask(m, mask);
  30         seq_putc(m, '\n');
  31         return 0;
  32 }
  33
  34 #ifndef is_affinity_mask_valid
  35 #define is_affinity_mask_valid(val) 1
  36 #endif
  37
  38 int no_irq_affinity;
  39 static ssize_t irq_affinity_proc_write(struct file *file,
  40                 const char __user *buffer, size_t count, loff_t *pos)
  41 {
  42         unsigned int irq = (int)(long)PDE(file->f_path.dentry->d_inode)->data;
  43         cpumask_var_t new_value;
  44         int err;
  45
  46         if (!irq_to_desc(irq)->chip->set_affinity || no_irq_affinity ||
  47             irq_balancing_disabled(irq))
  48                 return -EIO;
  49
  50         if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
  51                 return -ENOMEM;
  52
  53         err = cpumask_parse_user(buffer, count, new_value);
  54         if (err)
  55                 goto free_cpumask;
  56
  57         if (!is_affinity_mask_valid(new_value)) {
  58                 err = -EINVAL;
  59                 goto free_cpumask;
  60         }
  61
  62         /*
  63          * Do not allow disabling IRQs completely - it's a too easy
  64          * way to make the system unusable accidentally :-) At least
  65          * one online CPU still has to be targeted.
  66          */
  67         if (!cpumask_intersects(new_value, cpu_online_mask)) {
  68                 /* Special case for empty set - allow the architecture
  69                    code to set default SMP affinity. */
  70                 err = irq_select_affinity_usr(irq) ? -EINVAL : count;
  71         } else {
  72                 irq_set_affinity(irq, new_value);
  73                 err = count;
  74         }
  75
  76 free_cpumask:
  77         free_cpumask_var(new_value);
  78         return err;
  79 }
  80
  81 static int irq_affinity_proc_open(struct inode *inode, struct file *file)
  82 {
  83         return single_open(file, irq_affinity_proc_show, PDE(inode)->data);
  84 }
  85
  86 static const struct file_operations irq_affinity_proc_fops = {
  87         .open           = irq_affinity_proc_open,
  88         .read           = seq_read,
  89         .llseek         = seq_lseek,
  90         .release        = single_release,
  91         .write          = irq_affinity_proc_write,
  92 };
  93
  94 static int default_affinity_show(struct seq_file *m, void *v)
  95 {
  96         seq_cpumask(m, irq_default_affinity);
  97         seq_putc(m, '\n');
  98         return 0;
  99 }
 100
 101 static ssize_t default_affinity_write(struct file *file,
 102                 const char __user *buffer, size_t count, loff_t *ppos)
 103 {
 104         cpumask_var_t new_value;
 105         int err;
 106
 107         if (!alloc_cpumask_var(&new_value, GFP_KERNEL))
 108                 return -ENOMEM;
 109
 110         err = cpumask_parse_user(buffer, count, new_value);
 111         if (err)
 112                 goto out;
 113
 114         if (!is_affinity_mask_valid(new_value)) {
 115                 err = -EINVAL;
 116                 goto out;
 117         }
 118
 119         /*
 120          * Do not allow disabling IRQs completely - it's a too easy
 121          * way to make the system unusable accidentally :-) At least
 122          * one online CPU still has to be targeted.
 123          */
 124         if (!cpumask_intersects(new_value, cpu_online_mask)) {
 125                 err = -EINVAL;
 126                 goto out;
 127         }
 128
 129         cpumask_copy(irq_default_affinity, new_value);
 130         err = count;
 131
 132 out:
 133         free_cpumask_var(new_value);
 134         return err;
 135 }
 136
 137 static int default_affinity_open(struct inode *inode, struct file *file)
 138 {
 139         return single_open(file, default_affinity_show, NULL);
 140 }
 141
 142 static const struct file_operations default_affinity_proc_fops = {
 143         .open           = default_affinity_open,
 144         .read           = seq_read,
 145         .llseek         = seq_lseek,
 146         .release        = single_release,
 147         .write          = default_affinity_write,
 148 };
 149 #endif
 150
 151 static int irq_spurious_read(char *page, char **start, off_t off,
 152                                   int count, int *eof, void *data)
 153 {
 154         struct irq_desc *desc = irq_to_desc((long) data);
 155         return sprintf(page, "count %u\n"
 156                              "unhandled %u\n"
 157                              "last_unhandled %u ms\n",
 158                         desc->irq_count,
 159                         desc->irqs_unhandled,
 160                         jiffies_to_msecs(desc->last_unhandled));
 161 }
 162
 163 #define MAX_NAMELEN 128
 164
 165 static int name_unique(unsigned int irq, struct irqaction *new_action)
 166 {
 167         struct irq_desc *desc = irq_to_desc(irq);
 168         struct irqaction *action;
 169         unsigned long flags;
 170         int ret = 1;
 171
 172         spin_lock_irqsave(&desc->lock, flags);
 173         for (action = desc->action ; action; action = action->next) {
 174                 if ((action != new_action) && action->name &&
 175                                 !strcmp(new_action->name, action->name)) {
 176                         ret = 0;
 177                         break;
 178                 }
 179         }
 180         spin_unlock_irqrestore(&desc->lock, flags);
 181         return ret;
 182 }
 183
 184 void register_handler_proc(unsigned int irq, struct irqaction *action)
 185 {
 186         char name [MAX_NAMELEN];
 187         struct irq_desc *desc = irq_to_desc(irq);
 188
 189         if (!desc->dir || action->dir || !action->name ||
 190                                         !name_unique(irq, action))
 191                 return;
 192
 193         memset(name, 0, MAX_NAMELEN);
 194         snprintf(name, MAX_NAMELEN, "%s", action->name);
 195
 196         /* create /proc/irq/1234/handler/ */
 197         action->dir = proc_mkdir(name, desc->dir);
 198 }
 199
 200 #undef MAX_NAMELEN
 201
 202 #define MAX_NAMELEN 10
 203
 204 void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 205 {
 206         char name [MAX_NAMELEN];
 207         struct proc_dir_entry *entry;
 208
 209         if (!root_irq_dir || (desc->chip == &no_irq_chip) || desc->dir)
 210                 return;
 211
 212         memset(name, 0, MAX_NAMELEN);
 213         sprintf(name, "%d", irq);
 214
 215         /* create /proc/irq/1234 */
 216         desc->dir = proc_mkdir(name, root_irq_dir);
 217
 218 #ifdef CONFIG_SMP
 219         /* create /proc/irq/<irq>/smp_affinity */
 220         proc_create_data("smp_affinity", 0600, desc->dir,
 221                          &irq_affinity_proc_fops, (void *)(long)irq);
 222 #endif
 223
 224         entry = create_proc_entry("spurious", 0444, desc->dir);
 225         if (entry) {
 226                 entry->data = (void *)(long)irq;
 227                 entry->read_proc = irq_spurious_read;
 228         }
 229 }
 230
 231 #undef MAX_NAMELEN
 232
 233 void unregister_handler_proc(unsigned int irq, struct irqaction *action)
 234 {
 235         if (action->dir) {
 236                 struct irq_desc *desc = irq_to_desc(irq);
 237
 238                 remove_proc_entry(action->dir->name, desc->dir);
 239         }
 240 }
 241
 242 static void register_default_affinity_proc(void)
 243 {
 244 #ifdef CONFIG_SMP
 245         proc_create("irq/default_smp_affinity", 0600, NULL,
 246                     &default_affinity_proc_fops);
 247 #endif
 248 }
 249
 250 void init_irq_proc(void)
 251 {
 252         unsigned int irq;
 253         struct irq_desc *desc;
 254
 255         /* create /proc/irq */
 256         root_irq_dir = proc_mkdir("irq", NULL);
 257         if (!root_irq_dir)
 258                 return;
 259
 260         register_default_affinity_proc();
 261
 262         /*
 263          * Create entries for all existing IRQs.
 264          */
 265         for_each_irq_desc(irq, desc) {
 266                 if (!desc)
 267                         continue;
 268
 269                 register_irq_proc(irq, desc);
 270         }
 271 }
 272