irq: introduce nr_irqs
[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_desc + (long)m->private;
23         cpumask_t *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_t new_value;
44         int err;
45
46         if (!irq_desc[irq].chip->set_affinity || no_irq_affinity ||
47             irq_balancing_disabled(irq))
48                 return -EIO;
49
50         err = cpumask_parse_user(buffer, count, new_value);
51         if (err)
52                 return err;
53
54         if (!is_affinity_mask_valid(new_value))
55                 return -EINVAL;
56
57         /*
58          * Do not allow disabling IRQs completely - it's a too easy
59          * way to make the system unusable accidentally :-) At least
60          * one online CPU still has to be targeted.
61          */
62         if (!cpus_intersects(new_value, cpu_online_map))
63                 /* Special case for empty set - allow the architecture
64                    code to set default SMP affinity. */
65                 return irq_select_affinity(irq) ? -EINVAL : count;
66
67         irq_set_affinity(irq, new_value);
68
69         return count;
70 }
71
72 static int irq_affinity_proc_open(struct inode *inode, struct file *file)
73 {
74         return single_open(file, irq_affinity_proc_show, PDE(inode)->data);
75 }
76
77 static const struct file_operations irq_affinity_proc_fops = {
78         .open           = irq_affinity_proc_open,
79         .read           = seq_read,
80         .llseek         = seq_lseek,
81         .release        = single_release,
82         .write          = irq_affinity_proc_write,
83 };
84
85 static int default_affinity_show(struct seq_file *m, void *v)
86 {
87         seq_cpumask(m, &irq_default_affinity);
88         seq_putc(m, '\n');
89         return 0;
90 }
91
92 static ssize_t default_affinity_write(struct file *file,
93                 const char __user *buffer, size_t count, loff_t *ppos)
94 {
95         cpumask_t new_value;
96         int err;
97
98         err = cpumask_parse_user(buffer, count, new_value);
99         if (err)
100                 return err;
101
102         if (!is_affinity_mask_valid(new_value))
103                 return -EINVAL;
104
105         /*
106          * Do not allow disabling IRQs completely - it's a too easy
107          * way to make the system unusable accidentally :-) At least
108          * one online CPU still has to be targeted.
109          */
110         if (!cpus_intersects(new_value, cpu_online_map))
111                 return -EINVAL;
112
113         irq_default_affinity = new_value;
114
115         return count;
116 }
117
118 static int default_affinity_open(struct inode *inode, struct file *file)
119 {
120         return single_open(file, default_affinity_show, NULL);
121 }
122
123 static const struct file_operations default_affinity_proc_fops = {
124         .open           = default_affinity_open,
125         .read           = seq_read,
126         .llseek         = seq_lseek,
127         .release        = single_release,
128         .write          = default_affinity_write,
129 };
130 #endif
131
132 static int irq_spurious_read(char *page, char **start, off_t off,
133                                   int count, int *eof, void *data)
134 {
135         struct irq_desc *d = &irq_desc[(long) data];
136         return sprintf(page, "count %u\n"
137                              "unhandled %u\n"
138                              "last_unhandled %u ms\n",
139                         d->irq_count,
140                         d->irqs_unhandled,
141                         jiffies_to_msecs(d->last_unhandled));
142 }
143
144 #define MAX_NAMELEN 128
145
146 static int name_unique(unsigned int irq, struct irqaction *new_action)
147 {
148         struct irq_desc *desc = irq_desc + irq;
149         struct irqaction *action;
150         unsigned long flags;
151         int ret = 1;
152
153         spin_lock_irqsave(&desc->lock, flags);
154         for (action = desc->action ; action; action = action->next) {
155                 if ((action != new_action) && action->name &&
156                                 !strcmp(new_action->name, action->name)) {
157                         ret = 0;
158                         break;
159                 }
160         }
161         spin_unlock_irqrestore(&desc->lock, flags);
162         return ret;
163 }
164
165 void register_handler_proc(unsigned int irq, struct irqaction *action)
166 {
167         char name [MAX_NAMELEN];
168
169         if (!irq_desc[irq].dir || action->dir || !action->name ||
170                                         !name_unique(irq, action))
171                 return;
172
173         memset(name, 0, MAX_NAMELEN);
174         snprintf(name, MAX_NAMELEN, "%s", action->name);
175
176         /* create /proc/irq/1234/handler/ */
177         action->dir = proc_mkdir(name, irq_desc[irq].dir);
178 }
179
180 #undef MAX_NAMELEN
181
182 #define MAX_NAMELEN 10
183
184 void register_irq_proc(unsigned int irq)
185 {
186         char name [MAX_NAMELEN];
187         struct proc_dir_entry *entry;
188
189         if (!root_irq_dir ||
190                 (irq_desc[irq].chip == &no_irq_chip) ||
191                         irq_desc[irq].dir)
192                 return;
193
194         memset(name, 0, MAX_NAMELEN);
195         sprintf(name, "%d", irq);
196
197         /* create /proc/irq/1234 */
198         irq_desc[irq].dir = proc_mkdir(name, root_irq_dir);
199
200 #ifdef CONFIG_SMP
201         /* create /proc/irq/<irq>/smp_affinity */
202         proc_create_data("smp_affinity", 0600, irq_desc[irq].dir,
203                          &irq_affinity_proc_fops, (void *)(long)irq);
204 #endif
205
206         entry = create_proc_entry("spurious", 0444, irq_desc[irq].dir);
207         if (entry) {
208                 entry->data = (void *)(long)irq;
209                 entry->read_proc = irq_spurious_read;
210         }
211 }
212
213 #undef MAX_NAMELEN
214
215 void unregister_handler_proc(unsigned int irq, struct irqaction *action)
216 {
217         if (action->dir)
218                 remove_proc_entry(action->dir->name, irq_desc[irq].dir);
219 }
220
221 void register_default_affinity_proc(void)
222 {
223 #ifdef CONFIG_SMP
224         proc_create("irq/default_smp_affinity", 0600, NULL,
225                     &default_affinity_proc_fops);
226 #endif
227 }
228
229 void init_irq_proc(void)
230 {
231         int i;
232
233         /* create /proc/irq */
234         root_irq_dir = proc_mkdir("irq", NULL);
235         if (!root_irq_dir)
236                 return;
237
238         register_default_affinity_proc();
239
240         /*
241          * Create entries for all existing IRQs.
242          */
243         for (i = 0; i < nr_irqs; i++)
244                 register_irq_proc(i);
245 }
246