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