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, PDE(inode)->data);
 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_proc_show(struct seq_file *m, void *v)
 152 {
 153         struct irq_desc *desc = irq_to_desc((long) m->private);
 154
 155         seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
 156                    desc->irq_count, desc->irqs_unhandled,
 157                    jiffies_to_msecs(desc->last_unhandled));
 158         return 0;
 159 }
 160
 161 static int irq_spurious_proc_open(struct inode *inode, struct file *file)
 162 {
 163         return single_open(file, irq_spurious_proc_show, NULL);
 164 }
 165
 166 static const struct file_operations irq_spurious_proc_fops = {
 167         .open           = irq_spurious_proc_open,
 168         .read           = seq_read,
 169         .llseek         = seq_lseek,
 170         .release        = single_release,
 171 };
 172
 173 #define MAX_NAMELEN 128
 174
 175 static int name_unique(unsigned int irq, struct irqaction *new_action)
 176 {
 177         struct irq_desc *desc = irq_to_desc(irq);
 178         struct irqaction *action;
 179         unsigned long flags;
 180         int ret = 1;
 181
 182         raw_spin_lock_irqsave(&desc->lock, flags);
 183         for (action = desc->action ; action; action = action->next) {
 184                 if ((action != new_action) && action->name &&
 185                                 !strcmp(new_action->name, action->name)) {
 186                         ret = 0;
 187                         break;
 188                 }
 189         }
 190         raw_spin_unlock_irqrestore(&desc->lock, flags);
 191         return ret;
 192 }
 193
 194 void register_handler_proc(unsigned int irq, struct irqaction *action)
 195 {
 196         char name [MAX_NAMELEN];
 197         struct irq_desc *desc = irq_to_desc(irq);
 198
 199         if (!desc->dir || action->dir || !action->name ||
 200                                         !name_unique(irq, action))
 201                 return;
 202
 203         memset(name, 0, MAX_NAMELEN);
 204         snprintf(name, MAX_NAMELEN, "%s", action->name);
 205
 206         /* create /proc/irq/1234/handler/ */
 207         action->dir = proc_mkdir(name, desc->dir);
 208 }
 209
 210 #undef MAX_NAMELEN
 211
 212 #define MAX_NAMELEN 10
 213
 214 void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 215 {
 216         char name [MAX_NAMELEN];
 217
 218         if (!root_irq_dir || (desc->chip == &no_irq_chip) || desc->dir)
 219                 return;
 220
 221         memset(name, 0, MAX_NAMELEN);
 222         sprintf(name, "%d", irq);
 223
 224         /* create /proc/irq/1234 */
 225         desc->dir = proc_mkdir(name, root_irq_dir);
 226         if (!desc->dir)
 227                 return;
 228
 229 #ifdef CONFIG_SMP
 230         /* create /proc/irq/<irq>/smp_affinity */
 231         proc_create_data("smp_affinity", 0600, desc->dir,
 232                          &irq_affinity_proc_fops, (void *)(long)irq);
 233 #endif
 234
 235         proc_create_data("spurious", 0444, desc->dir,
 236                          &irq_spurious_proc_fops, (void *)(long)irq);
 237 }
 238
 239 #undef MAX_NAMELEN
 240
 241 void unregister_handler_proc(unsigned int irq, struct irqaction *action)
 242 {
 243         if (action->dir) {
 244                 struct irq_desc *desc = irq_to_desc(irq);
 245
 246                 remove_proc_entry(action->dir->name, desc->dir);
 247         }
 248 }
 249
 250 static void register_default_affinity_proc(void)
 251 {
 252 #ifdef CONFIG_SMP
 253         proc_create("irq/default_smp_affinity", 0600, NULL,
 254                     &default_affinity_proc_fops);
 255 #endif
 256 }
 257
 258 void init_irq_proc(void)
 259 {
 260         unsigned int irq;
 261         struct irq_desc *desc;
 262
 263         /* create /proc/irq */
 264         root_irq_dir = proc_mkdir("irq", NULL);
 265         if (!root_irq_dir)
 266                 return;
 267
 268         register_default_affinity_proc();
 269
 270         /*
 271          * Create entries for all existing IRQs.
 272          */
 273         for_each_irq_desc(irq, desc) {
 274                 if (!desc)
 275                         continue;
 276
 277                 register_irq_proc(irq, desc);
 278         }
 279 }
 280