SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 "cio: 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 "cio: 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 "cio: 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 "cio: invalid cio_ignore "
 177                                        "range %x.%x.%04x-%x.%x.%04x\n",
 178                                        from_id0, from_ssid, from,
 179                                        to_id0, to_ssid, to);
 180                                 continue;
 181                         }
 182                         blacklist_range (ra, from, to, to_ssid);
 183                 }
 184         }
 185         return 1;
 186 }
 187
 188 /* Parsing the commandline for blacklist parameters, e.g. to blacklist
 189  * bus ids 0.0.1234, 0.0.1235 and 0.0.1236, you could use any of:
 190  * - cio_ignore=1234-1236
 191  * - cio_ignore=0x1234-0x1235,1236
 192  * - cio_ignore=0x1234,1235-1236
 193  * - cio_ignore=1236 cio_ignore=1234-0x1236
 194  * - cio_ignore=1234 cio_ignore=1236 cio_ignore=0x1235
 195  * - cio_ignore=0.0.1234-0.0.1236
 196  * - cio_ignore=0.0.1234,0x1235,1236
 197  * - ...
 198  */
 199 static int __init
 200 blacklist_setup (char *str)
 201 {
 202         return blacklist_parse_parameters (str, add);
 203 }
 204
 205 __setup ("cio_ignore=", blacklist_setup);
 206
 207 /* Checking if devices are blacklisted */
 208
 209 /*
 210  * Function: is_blacklisted
 211  * Returns 1 if the given devicenumber can be found in the blacklist,
 212  * otherwise 0.
 213  * Used by validate_subchannel()
 214  */
 215 int
 216 is_blacklisted (int ssid, int devno)
 217 {
 218         return test_bit (devno, bl_dev[ssid]);
 219 }
 220
 221 #ifdef CONFIG_PROC_FS
 222 /*
 223  * Function: blacklist_parse_proc_parameters
 224  * parse the stuff which is piped to /proc/cio_ignore
 225  */
 226 static void
 227 blacklist_parse_proc_parameters (char *buf)
 228 {
 229         if (strncmp (buf, "free ", 5) == 0) {
 230                 blacklist_parse_parameters (buf + 5, free);
 231         } else if (strncmp (buf, "add ", 4) == 0) {
 232                 /*
 233                  * We don't need to check for known devices since
 234                  * css_probe_device will handle this correctly.
 235                  */
 236                 blacklist_parse_parameters (buf + 4, add);
 237         } else {
 238                 printk (KERN_WARNING "cio: cio_ignore: Parse error; \n"
 239                         KERN_WARNING "try using 'free all|<devno-range>,"
 240                                      "<devno-range>,...'\n"
 241                         KERN_WARNING "or 'add <devno-range>,"
 242                                      "<devno-range>,...'\n");
 243                 return;
 244         }
 245
 246         css_schedule_reprobe();
 247 }
 248
 249 /* Iterator struct for all devices. */
 250 struct ccwdev_iter {
 251         int devno;
 252         int ssid;
 253         int in_range;
 254 };
 255
 256 static void *
 257 cio_ignore_proc_seq_start(struct seq_file *s, loff_t *offset)
 258 {
 259         struct ccwdev_iter *iter;
 260
 261         if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
 262                 return NULL;
 263         iter = kzalloc(sizeof(struct ccwdev_iter), GFP_KERNEL);
 264         if (!iter)
 265                 return ERR_PTR(-ENOMEM);
 266         iter->ssid = *offset / (__MAX_SUBCHANNEL + 1);
 267         iter->devno = *offset % (__MAX_SUBCHANNEL + 1);
 268         return iter;
 269 }
 270
 271 static void
 272 cio_ignore_proc_seq_stop(struct seq_file *s, void *it)
 273 {
 274         if (!IS_ERR(it))
 275                 kfree(it);
 276 }
 277
 278 static void *
 279 cio_ignore_proc_seq_next(struct seq_file *s, void *it, loff_t *offset)
 280 {
 281         struct ccwdev_iter *iter;
 282
 283         if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
 284                 return NULL;
 285         iter = it;
 286         if (iter->devno == __MAX_SUBCHANNEL) {
 287                 iter->devno = 0;
 288                 iter->ssid++;
 289                 if (iter->ssid > __MAX_SSID)
 290                         return NULL;
 291         } else
 292                 iter->devno++;
 293         (*offset)++;
 294         return iter;
 295 }
 296
 297 static int
 298 cio_ignore_proc_seq_show(struct seq_file *s, void *it)
 299 {
 300         struct ccwdev_iter *iter;
 301
 302         iter = it;
 303         if (!is_blacklisted(iter->ssid, iter->devno))
 304                 /* Not blacklisted, nothing to output. */
 305                 return 0;
 306         if (!iter->in_range) {
 307                 /* First device in range. */
 308                 if ((iter->devno == __MAX_SUBCHANNEL) ||
 309                     !is_blacklisted(iter->ssid, iter->devno + 1))
 310                         /* Singular device. */
 311                         return seq_printf(s, "0.%x.%04x\n",
 312                                           iter->ssid, iter->devno);
 313                 iter->in_range = 1;
 314                 return seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno);
 315         }
 316         if ((iter->devno == __MAX_SUBCHANNEL) ||
 317             !is_blacklisted(iter->ssid, iter->devno + 1)) {
 318                 /* Last device in range. */
 319                 iter->in_range = 0;
 320                 return seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno);
 321         }
 322         return 0;
 323 }
 324
 325 static ssize_t
 326 cio_ignore_write(struct file *file, const char __user *user_buf,
 327                  size_t user_len, loff_t *offset)
 328 {
 329         char *buf;
 330
 331         if (*offset)
 332                 return -EINVAL;
 333         if (user_len > 65536)
 334                 user_len = 65536;
 335         buf = vmalloc (user_len + 1); /* maybe better use the stack? */
 336         if (buf == NULL)
 337                 return -ENOMEM;
 338         if (strncpy_from_user (buf, user_buf, user_len) < 0) {
 339                 vfree (buf);
 340                 return -EFAULT;
 341         }
 342         buf[user_len] = '\0';
 343
 344         blacklist_parse_proc_parameters (buf);
 345
 346         vfree (buf);
 347         return user_len;
 348 }
 349
 350 static const struct seq_operations cio_ignore_proc_seq_ops = {
 351         .start = cio_ignore_proc_seq_start,
 352         .stop  = cio_ignore_proc_seq_stop,
 353         .next  = cio_ignore_proc_seq_next,
 354         .show  = cio_ignore_proc_seq_show,
 355 };
 356
 357 static int
 358 cio_ignore_proc_open(struct inode *inode, struct file *file)
 359 {
 360         return seq_open(file, &cio_ignore_proc_seq_ops);
 361 }
 362
 363 static const struct file_operations cio_ignore_proc_fops = {
 364         .open    = cio_ignore_proc_open,
 365         .read    = seq_read,
 366         .llseek  = seq_lseek,
 367         .release = seq_release,
 368         .write   = cio_ignore_write,
 369 };
 370
 371 static int
 372 cio_ignore_proc_init (void)
 373 {
 374         struct proc_dir_entry *entry;
 375
 376         entry = proc_create("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR, NULL,
 377                             &cio_ignore_proc_fops);
 378         if (!entry)
 379                 return -ENOENT;
 380         return 0;
 381 }
 382
 383 __initcall (cio_ignore_proc_init);
 384
 385 #endif /* CONFIG_PROC_FS */