genirq: switch /proc/irq/*/spurious to seq_file
[linux-2.6.git] / 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_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         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         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