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 static int
 228 __s390_redo_validation(struct subchannel_id schid, void *data)
 229 {
 230         int ret;
 231         struct subchannel *sch;
 232
 233         sch = get_subchannel_by_schid(schid);
 234         if (sch) {
 235                 /* Already known. */
 236                 put_device(&sch->dev);
 237                 return 0;
 238         }
 239         ret = css_probe_device(schid);
 240         if (ret == -ENXIO)
 241                 return ret; /* We're through. */
 242         if (ret == -ENOMEM)
 243                 /* Stop validation for now. Bad, but no need for a panic. */
 244                 return ret;
 245         return 0;
 246 }
 247
 248 /*
 249  * Function: s390_redo_validation
 250  * Look for no longer blacklisted devices
 251  * FIXME: there must be a better way to do this */
 252 static inline void
 253 s390_redo_validation (void)
 254 {
 255         CIO_TRACE_EVENT (0, "redoval");
 256
 257         for_each_subchannel(__s390_redo_validation, NULL);
 258 }
 259
 260 /*
 261  * Function: blacklist_parse_proc_parameters
 262  * parse the stuff which is piped to /proc/cio_ignore
 263  */
 264 static inline void
 265 blacklist_parse_proc_parameters (char *buf)
 266 {
 267         if (strncmp (buf, "free ", 5) == 0) {
 268                 blacklist_parse_parameters (buf + 5, free);
 269         } else if (strncmp (buf, "add ", 4) == 0) {
 270                 /*
 271                  * We don't need to check for known devices since
 272                  * css_probe_device will handle this correctly.
 273                  */
 274                 blacklist_parse_parameters (buf + 4, add);
 275         } else {
 276                 printk (KERN_WARNING "cio_ignore: Parse error; \n"
 277                         KERN_WARNING "try using 'free all|<devno-range>,"
 278                                      "<devno-range>,...'\n"
 279                         KERN_WARNING "or 'add <devno-range>,"
 280                                      "<devno-range>,...'\n");
 281                 return;
 282         }
 283
 284         s390_redo_validation ();
 285 }
 286
 287 /* Iterator struct for all devices. */
 288 struct ccwdev_iter {
 289         int devno;
 290         int ssid;
 291         int in_range;
 292 };
 293
 294 static void *
 295 cio_ignore_proc_seq_start(struct seq_file *s, loff_t *offset)
 296 {
 297         struct ccwdev_iter *iter;
 298
 299         if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
 300                 return NULL;
 301         iter = kzalloc(sizeof(struct ccwdev_iter), GFP_KERNEL);
 302         if (!iter)
 303                 return ERR_PTR(-ENOMEM);
 304         iter->ssid = *offset / (__MAX_SUBCHANNEL + 1);
 305         iter->devno = *offset % (__MAX_SUBCHANNEL + 1);
 306         return iter;
 307 }
 308
 309 static void
 310 cio_ignore_proc_seq_stop(struct seq_file *s, void *it)
 311 {
 312         if (!IS_ERR(it))
 313                 kfree(it);
 314 }
 315
 316 static void *
 317 cio_ignore_proc_seq_next(struct seq_file *s, void *it, loff_t *offset)
 318 {
 319         struct ccwdev_iter *iter;
 320
 321         if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
 322                 return NULL;
 323         iter = it;
 324         if (iter->devno == __MAX_SUBCHANNEL) {
 325                 iter->devno = 0;
 326                 iter->ssid++;
 327                 if (iter->ssid > __MAX_SSID)
 328                         return NULL;
 329         } else
 330                 iter->devno++;
 331         (*offset)++;
 332         return iter;
 333 }
 334
 335 static int
 336 cio_ignore_proc_seq_show(struct seq_file *s, void *it)
 337 {
 338         struct ccwdev_iter *iter;
 339
 340         iter = it;
 341         if (!is_blacklisted(iter->ssid, iter->devno))
 342                 /* Not blacklisted, nothing to output. */
 343                 return 0;
 344         if (!iter->in_range) {
 345                 /* First device in range. */
 346                 if ((iter->devno == __MAX_SUBCHANNEL) ||
 347                     !is_blacklisted(iter->ssid, iter->devno + 1))
 348                         /* Singular device. */
 349                         return seq_printf(s, "0.%x.%04x\n",
 350                                           iter->ssid, iter->devno);
 351                 iter->in_range = 1;
 352                 return seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno);
 353         }
 354         if ((iter->devno == __MAX_SUBCHANNEL) ||
 355             !is_blacklisted(iter->ssid, iter->devno + 1)) {
 356                 /* Last device in range. */
 357                 iter->in_range = 0;
 358                 return seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno);
 359         }
 360         return 0;
 361 }
 362
 363 static ssize_t
 364 cio_ignore_write(struct file *file, const char __user *user_buf,
 365                  size_t user_len, loff_t *offset)
 366 {
 367         char *buf;
 368
 369         if (*offset)
 370                 return -EINVAL;
 371         if (user_len > 65536)
 372                 user_len = 65536;
 373         buf = vmalloc (user_len + 1); /* maybe better use the stack? */
 374         if (buf == NULL)
 375                 return -ENOMEM;
 376         if (strncpy_from_user (buf, user_buf, user_len) < 0) {
 377                 vfree (buf);
 378                 return -EFAULT;
 379         }
 380         buf[user_len] = '\0';
 381
 382         blacklist_parse_proc_parameters (buf);
 383
 384         vfree (buf);
 385         return user_len;
 386 }
 387
 388 static struct seq_operations cio_ignore_proc_seq_ops = {
 389         .start = cio_ignore_proc_seq_start,
 390         .stop  = cio_ignore_proc_seq_stop,
 391         .next  = cio_ignore_proc_seq_next,
 392         .show  = cio_ignore_proc_seq_show,
 393 };
 394
 395 static int
 396 cio_ignore_proc_open(struct inode *inode, struct file *file)
 397 {
 398         return seq_open(file, &cio_ignore_proc_seq_ops);
 399 }
 400
 401 static struct file_operations cio_ignore_proc_fops = {
 402         .open    = cio_ignore_proc_open,
 403         .read    = seq_read,
 404         .llseek  = seq_lseek,
 405         .release = seq_release,
 406         .write   = cio_ignore_write,
 407 };
 408
 409 static int
 410 cio_ignore_proc_init (void)
 411 {
 412         struct proc_dir_entry *entry;
 413
 414         entry = create_proc_entry ("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR,
 415                                    &proc_root);
 416         if (!entry)
 417                 return -ENOENT;
 418
 419         entry->proc_fops = &cio_ignore_proc_fops;
 420
 421         return 0;
 422 }
 423
 424 __initcall (cio_ignore_proc_init);
 425
 426 #endif /* CONFIG_PROC_FS */