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