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