1
2
3
4
5
6
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
16static struct proc_dir_entry *root_irq_dir;
17
18#ifdef CONFIG_SMP
19
20static 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
38int no_irq_affinity;
39static 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
64
65
66
67 if (!cpumask_intersects(new_value, cpu_online_mask)) {
68
69
70 err = irq_select_affinity_usr(irq) ? -EINVAL : count;
71 } else {
72 irq_set_affinity(irq, new_value);
73 err = count;
74 }
75
76free_cpumask:
77 free_cpumask_var(new_value);
78 return err;
79}
80
81static 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
86static 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
94static 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
101static 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
121
122
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
132out:
133 free_cpumask_var(new_value);
134 return err;
135}
136
137static int default_affinity_open(struct inode *inode, struct file *file)
138{
139 return single_open(file, default_affinity_show, NULL);
140}
141
142static 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
151static 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
165static 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
184void 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
197 action->dir = proc_mkdir(name, desc->dir);
198}
199
200#undef MAX_NAMELEN
201
202#define MAX_NAMELEN 10
203
204void 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
216 desc->dir = proc_mkdir(name, root_irq_dir);
217
218#ifdef CONFIG_SMP
219
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
233void 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
242static 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
250void init_irq_proc(void)
251{
252 unsigned int irq;
253 struct irq_desc *desc;
254
255
256 root_irq_dir = proc_mkdir("irq", NULL);
257 if (!root_irq_dir)
258 return;
259
260 register_default_affinity_proc();
261
262
263
264
265 for_each_irq_desc(irq, desc) {
266 if (!desc)
267 continue;
268
269 register_irq_proc(irq, desc);
270 }
271}
272
273
