Merge master.kernel.org:/pub/scm/linux/kernel/git/kyle/parisc-2.6
[linux-2.6] / drivers / s390 / cio / blacklist.c
1 /*
2  *  drivers/s390/cio/blacklist.c
3  *   S/390 common I/O routines -- blacklisting of specific devices
4  *
5  *    Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
6  *                            IBM Corporation
7  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
8  *               Cornelia Huck (cornelia.huck@de.ibm.com)
9  *               Arnd Bergmann (arndb@de.ibm.com)
10  */
11
12 #include <linux/config.h>
13 #include <linux/init.h>
14 #include <linux/vmalloc.h>
15 #include <linux/slab.h>
16 #include <linux/proc_fs.h>
17 #include <linux/seq_file.h>
18 #include <linux/ctype.h>
19 #include <linux/device.h>
20
21 #include <asm/cio.h>
22 #include <asm/uaccess.h>
23
24 #include "blacklist.h"
25 #include "cio.h"
26 #include "cio_debug.h"
27 #include "css.h"
28
29 /*
30  * "Blacklisting" of certain devices:
31  * Device numbers given in the commandline as cio_ignore=... won't be known
32  * to Linux.
33  *
34  * These can be single devices or ranges of devices
35  */
36
37 /* 65536 bits for each set to indicate if a devno is blacklisted or not */
38 #define __BL_DEV_WORDS ((__MAX_SUBCHANNEL + (8*sizeof(long) - 1)) / \
39                          (8*sizeof(long)))
40 static unsigned long bl_dev[__MAX_SSID + 1][__BL_DEV_WORDS];
41 typedef enum {add, free} range_action;
42
43 /*
44  * Function: blacklist_range
45  * (Un-)blacklist the devices from-to
46  */
47 static inline void
48 blacklist_range (range_action action, unsigned int from, unsigned int to,
49                  unsigned int ssid)
50 {
51         if (!to)
52                 to = from;
53
54         if (from > to || to > __MAX_SUBCHANNEL || ssid > __MAX_SSID) {
55                 printk (KERN_WARNING "Invalid blacklist range "
56                         "0.%x.%04x to 0.%x.%04x, skipping\n",
57                         ssid, from, ssid, to);
58                 return;
59         }
60         for (; from <= to; from++) {
61                 if (action == add)
62                         set_bit (from, bl_dev[ssid]);
63                 else
64                         clear_bit (from, bl_dev[ssid]);
65         }
66 }
67
68 /*
69  * Function: blacklist_busid
70  * Get devno/busid from given string.
71  * Shamelessly grabbed from dasd_devmap.c.
72  */
73 static inline int
74 blacklist_busid(char **str, int *id0, int *ssid, int *devno)
75 {
76         int val, old_style;
77         char *sav;
78
79         sav = *str;
80
81         /* check for leading '0x' */
82         old_style = 0;
83         if ((*str)[0] == '0' && (*str)[1] == 'x') {
84                 *str += 2;
85                 old_style = 1;
86         }
87         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
88                 goto confused;
89         val = simple_strtoul(*str, str, 16);
90         if (old_style || (*str)[0] != '.') {
91                 *id0 = *ssid = 0;
92                 if (val < 0 || val > 0xffff)
93                         goto confused;
94                 *devno = val;
95                 if ((*str)[0] != ',' && (*str)[0] != '-' &&
96                     (*str)[0] != '\n' && (*str)[0] != '\0')
97                         goto confused;
98                 return 0;
99         }
100         /* New style x.y.z busid */
101         if (val < 0 || val > 0xff)
102                 goto confused;
103         *id0 = val;
104         (*str)++;
105         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
106                 goto confused;
107         val = simple_strtoul(*str, str, 16);
108         if (val < 0 || val > 0xff || (*str)++[0] != '.')
109                 goto confused;
110         *ssid = val;
111         if (!isxdigit((*str)[0]))       /* We require at least one hex digit */
112                 goto confused;
113         val = simple_strtoul(*str, str, 16);
114         if (val < 0 || val > 0xffff)
115                 goto confused;
116         *devno = val;
117         if ((*str)[0] != ',' && (*str)[0] != '-' &&
118             (*str)[0] != '\n' && (*str)[0] != '\0')
119                 goto confused;
120         return 0;
121 confused:
122         strsep(str, ",\n");
123         printk(KERN_WARNING "Invalid cio_ignore parameter '%s'\n", sav);
124         return 1;
125 }
126
127 static inline int
128 blacklist_parse_parameters (char *str, range_action action)
129 {
130         unsigned int from, to, from_id0, to_id0, from_ssid, to_ssid;
131
132         while (*str != 0 && *str != '\n') {
133                 range_action ra = action;
134                 while(*str == ',')
135                         str++;
136                 if (*str == '!') {
137                         ra = !action;
138                         ++str;
139                 }
140
141                 /*
142                  * Since we have to parse the proc commands and the
143                  * kernel arguments we have to check four cases
144                  */
145                 if (strncmp(str,"all,",4) == 0 || strcmp(str,"all") == 0 ||
146                     strncmp(str,"all\n",4) == 0 || strncmp(str,"all ",4) == 0) {
147                         int j;
148
149                         str += 3;
150                         for (j=0; j <= __MAX_SSID; j++)
151                                 blacklist_range(ra, 0, __MAX_SUBCHANNEL, j);
152                 } else {
153                         int rc;
154
155                         rc = blacklist_busid(&str, &from_id0,
156                                              &from_ssid, &from);
157                         if (rc)
158                                 continue;
159                         to = from;
160                         to_id0 = from_id0;
161                         to_ssid = from_ssid;
162                         if (*str == '-') {
163                                 str++;
164                                 rc = blacklist_busid(&str, &to_id0,
165                                                      &to_ssid, &to);
166                                 if (rc)
167                                         continue;
168                         }
169                         if (*str == '-') {
170                                 printk(KERN_WARNING "invalid cio_ignore "
171                                         "parameter '%s'\n",
172                                         strsep(&str, ",\n"));
173                                 continue;
174                         }
175                         if ((from_id0 != to_id0) ||
176                             (from_ssid != to_ssid)) {
177                                 printk(KERN_WARNING "invalid cio_ignore range "
178                                         "%x.%x.%04x-%x.%x.%04x\n",
179                                         from_id0, from_ssid, from,
180                                         to_id0, to_ssid, to);
181                                 continue;
182                         }
183                         pr_debug("blacklist_setup: adding range "
184                                  "from %x.%x.%04x to %x.%x.%04x\n",
185                                  from_id0, from_ssid, from, to_id0, to_ssid, to);
186                         blacklist_range (ra, from, to, to_ssid);
187                 }
188         }
189         return 1;
190 }
191
192 /* Parsing the commandline for blacklist parameters, e.g. to blacklist
193  * bus ids 0.0.1234, 0.0.1235 and 0.0.1236, you could use any of:
194  * - cio_ignore=1234-1236
195  * - cio_ignore=0x1234-0x1235,1236
196  * - cio_ignore=0x1234,1235-1236
197  * - cio_ignore=1236 cio_ignore=1234-0x1236
198  * - cio_ignore=1234 cio_ignore=1236 cio_ignore=0x1235
199  * - cio_ignore=0.0.1234-0.0.1236
200  * - cio_ignore=0.0.1234,0x1235,1236
201  * - ...
202  */
203 static int __init
204 blacklist_setup (char *str)
205 {
206         CIO_MSG_EVENT(6, "Reading blacklist parameters\n");
207         return blacklist_parse_parameters (str, add);
208 }
209
210 __setup ("cio_ignore=", blacklist_setup);
211
212 /* Checking if devices are blacklisted */
213
214 /*
215  * Function: is_blacklisted
216  * Returns 1 if the given devicenumber can be found in the blacklist,
217  * otherwise 0.
218  * Used by validate_subchannel()
219  */
220 int
221 is_blacklisted (int ssid, int devno)
222 {
223         return test_bit (devno, bl_dev[ssid]);
224 }
225
226 #ifdef CONFIG_PROC_FS
227 /*
228  * Function: blacklist_parse_proc_parameters
229  * parse the stuff which is piped to /proc/cio_ignore
230  */
231 static inline void
232 blacklist_parse_proc_parameters (char *buf)
233 {
234         if (strncmp (buf, "free ", 5) == 0) {
235                 blacklist_parse_parameters (buf + 5, free);
236         } else if (strncmp (buf, "add ", 4) == 0) {
237                 /* 
238                  * We don't need to check for known devices since
239                  * css_probe_device will handle this correctly. 
240                  */
241                 blacklist_parse_parameters (buf + 4, add);
242         } else {
243                 printk (KERN_WARNING "cio_ignore: Parse error; \n"
244                         KERN_WARNING "try using 'free all|<devno-range>,"
245                                      "<devno-range>,...'\n"
246                         KERN_WARNING "or 'add <devno-range>,"
247                                      "<devno-range>,...'\n");
248                 return;
249         }
250
251         css_schedule_reprobe();
252 }
253
254 /* Iterator struct for all devices. */
255 struct ccwdev_iter {
256         int devno;
257         int ssid;
258         int in_range;
259 };
260
261 static void *
262 cio_ignore_proc_seq_start(struct seq_file *s, loff_t *offset)
263 {
264         struct ccwdev_iter *iter;
265
266         if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
267                 return NULL;
268         iter = kzalloc(sizeof(struct ccwdev_iter), GFP_KERNEL);
269         if (!iter)
270                 return ERR_PTR(-ENOMEM);
271         iter->ssid = *offset / (__MAX_SUBCHANNEL + 1);
272         iter->devno = *offset % (__MAX_SUBCHANNEL + 1);
273         return iter;
274 }
275
276 static void
277 cio_ignore_proc_seq_stop(struct seq_file *s, void *it)
278 {
279         if (!IS_ERR(it))
280                 kfree(it);
281 }
282
283 static void *
284 cio_ignore_proc_seq_next(struct seq_file *s, void *it, loff_t *offset)
285 {
286         struct ccwdev_iter *iter;
287
288         if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
289                 return NULL;
290         iter = it;
291         if (iter->devno == __MAX_SUBCHANNEL) {
292                 iter->devno = 0;
293                 iter->ssid++;
294                 if (iter->ssid > __MAX_SSID)
295                         return NULL;
296         } else
297                 iter->devno++;
298         (*offset)++;
299         return iter;
300 }
301
302 static int
303 cio_ignore_proc_seq_show(struct seq_file *s, void *it)
304 {
305         struct ccwdev_iter *iter;
306
307         iter = it;
308         if (!is_blacklisted(iter->ssid, iter->devno))
309                 /* Not blacklisted, nothing to output. */
310                 return 0;
311         if (!iter->in_range) {
312                 /* First device in range. */
313                 if ((iter->devno == __MAX_SUBCHANNEL) ||
314                     !is_blacklisted(iter->ssid, iter->devno + 1))
315                         /* Singular device. */
316                         return seq_printf(s, "0.%x.%04x\n",
317                                           iter->ssid, iter->devno);
318                 iter->in_range = 1;
319                 return seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno);
320         }
321         if ((iter->devno == __MAX_SUBCHANNEL) ||
322             !is_blacklisted(iter->ssid, iter->devno + 1)) {
323                 /* Last device in range. */
324                 iter->in_range = 0;
325                 return seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno);
326         }
327         return 0;
328 }
329
330 static ssize_t
331 cio_ignore_write(struct file *file, const char __user *user_buf,
332                  size_t user_len, loff_t *offset)
333 {
334         char *buf;
335
336         if (*offset)
337                 return -EINVAL;
338         if (user_len > 65536)
339                 user_len = 65536;
340         buf = vmalloc (user_len + 1); /* maybe better use the stack? */
341         if (buf == NULL)
342                 return -ENOMEM;
343         if (strncpy_from_user (buf, user_buf, user_len) < 0) {
344                 vfree (buf);
345                 return -EFAULT;
346         }
347         buf[user_len] = '\0';
348
349         blacklist_parse_proc_parameters (buf);
350
351         vfree (buf);
352         return user_len;
353 }
354
355 static struct seq_operations cio_ignore_proc_seq_ops = {
356         .start = cio_ignore_proc_seq_start,
357         .stop  = cio_ignore_proc_seq_stop,
358         .next  = cio_ignore_proc_seq_next,
359         .show  = cio_ignore_proc_seq_show,
360 };
361
362 static int
363 cio_ignore_proc_open(struct inode *inode, struct file *file)
364 {
365         return seq_open(file, &cio_ignore_proc_seq_ops);
366 }
367
368 static struct file_operations cio_ignore_proc_fops = {
369         .open    = cio_ignore_proc_open,
370         .read    = seq_read,
371         .llseek  = seq_lseek,
372         .release = seq_release,
373         .write   = cio_ignore_write,
374 };
375
376 static int
377 cio_ignore_proc_init (void)
378 {
379         struct proc_dir_entry *entry;
380
381         entry = create_proc_entry ("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR,
382                                    &proc_root);
383         if (!entry)
384                 return -ENOENT;
385
386         entry->proc_fops = &cio_ignore_proc_fops;
387
388         return 0;
389 }
390
391 __initcall (cio_ignore_proc_init);
392
393 #endif /* CONFIG_PROC_FS */