// SPDX-License-Identifier: GPL-2.0 /* * S/390 common I/O routines -- blacklisting of specific devices * * Copyright IBM Corp. 1999, 2013 * Author(s): Ingo Adlung (adlung@de.ibm.com) * Cornelia Huck (cornelia.huck@de.ibm.com) * Arnd Bergmann (arndb@de.ibm.com) */ #define KMSG_COMPONENT "cio" #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt #include <linux/init.h> #include <linux/vmalloc.h> #include <linux/proc_fs.h> #include <linux/seq_file.h> #include <linux/ctype.h> #include <linux/device.h> #include <linux/uaccess.h> #include <asm/cio.h> #include <asm/ipl.h> #include "blacklist.h" #include "cio.h" #include "cio_debug.h" #include "css.h" #include "device.h" /* * "Blacklisting" of certain devices: * Device numbers given in the commandline as cio_ignore=... won't be known * to Linux. * * These can be single devices or ranges of devices */ /* 65536 bits for each set to indicate if a devno is blacklisted or not */ #define __BL_DEV_WORDS ((__MAX_SUBCHANNEL + (8*sizeof(long) - 1)) / \ (8*sizeof(long))) static unsigned long bl_dev[__MAX_SSID + 1][__BL_DEV_WORDS]; typedef enum {add, free} range_action; /* * Function: blacklist_range * (Un-)blacklist the devices from-to */ static int blacklist_range(range_action action, unsigned int from_ssid, unsigned int to_ssid, unsigned int from, unsigned int to, int msgtrigger) { if ((from_ssid > to_ssid) || ((from_ssid == to_ssid) && (from > to))) { if (msgtrigger) pr_warn("0.%x.%04x to 0.%x.%04x is not a valid range for cio_ignore\n", from_ssid, from, to_ssid, to); return 1; } while ((from_ssid < to_ssid) || ((from_ssid == to_ssid) && (from <= to))) { if (action == add) set_bit(from, bl_dev[from_ssid]); else clear_bit(from, bl_dev[from_ssid]); from++; if (from > __MAX_SUBCHANNEL) { from_ssid++; from = 0; } } return 0; } static int pure_hex(char **cp, unsigned int *val, int min_digit, int max_digit, int max_val) { int diff; diff = 0; *val = 0; while (diff <= max_digit) { int value = hex_to_bin(**cp); if (value < 0) break; *val = *val * 16 + value; (*cp)++; diff++; } if ((diff < min_digit) || (diff > max_digit) || (*val > max_val)) return 1; return 0; } static int parse_busid(char *str, unsigned int *cssid, unsigned int *ssid, unsigned int *devno, int msgtrigger) { char *str_work; int val, rc, ret; rc = 1; if (*str == '\0') goto out; /* old style */ str_work = str; val = simple_strtoul(str, &str_work, 16); if (*str_work == '\0') { if (val <= __MAX_SUBCHANNEL) { *devno = val; *ssid = 0; *cssid = 0; rc = 0; } goto out; } /* new style */ str_work = str; ret = pure_hex(&str_work, cssid, 1, 2, __MAX_CSSID); if (ret || (str_work[0] != '.')) goto out; str_work++; ret = pure_hex(&str_work, ssid, 1, 1, __MAX_SSID); if (ret || (str_work[0] != '.')) goto out; str_work++; ret = pure_hex(&str_work, devno, 4, 4, __MAX_SUBCHANNEL); if (ret || (str_work[0] != '\0')) goto out; rc = 0; out: if (rc && msgtrigger) pr_warn("%s is not a valid device for the cio_ignore kernel parameter\n", str); return rc; } static int blacklist_parse_parameters(char *str, range_action action, int msgtrigger) { unsigned int from_cssid, to_cssid, from_ssid, to_ssid, from, to; int rc, totalrc; char *parm; range_action ra; totalrc = 0; while ((parm = strsep(&str, ","))) { rc = 0; ra = action; if (*parm == '!') { if (ra == add) ra = free; else ra = add; parm++; } if (strcmp(parm, "all") == 0) { from_cssid = 0; from_ssid = 0; from = 0; to_cssid = __MAX_CSSID; to_ssid = __MAX_SSID; to = __MAX_SUBCHANNEL; } else if (strcmp(parm, "ipldev") == 0) { if (ipl_info.type == IPL_TYPE_CCW) { from_cssid = 0; from_ssid = ipl_info.data.ccw.dev_id.ssid; from = ipl_info.data.ccw.dev_id.devno; } else if (ipl_info.type == IPL_TYPE_FCP || ipl_info.type == IPL_TYPE_FCP_DUMP) { from_cssid = 0; from_ssid = ipl_info.data.fcp.dev_id.ssid; from = ipl_info.data.fcp.dev_id.devno; } else { continue; } to_cssid = from_cssid; to_ssid = from_ssid; to = from; } else if (strcmp(parm, "condev") == 0) { if (console_devno == -1) continue; from_cssid = to_cssid = 0; from_ssid = to_ssid = 0; from = to = console_devno; } else { rc = parse_busid(strsep(&parm, "-"), &from_cssid, &from_ssid, &from, msgtrigger); if (!rc) { if (parm != NULL) rc = parse_busid(parm, &to_cssid, &to_ssid, &to, msgtrigger); else { to_cssid = from_cssid; to_ssid = from_ssid; to = from; } } } if (!rc) { rc = blacklist_range(ra, from_ssid, to_ssid, from, to, msgtrigger); if (rc) totalrc = -EINVAL; } else totalrc = -EINVAL; } return totalrc; } static int __init blacklist_setup (char *str) { CIO_MSG_EVENT(6, "Reading blacklist parameters\n"); if (blacklist_parse_parameters(str, add, 1)) return 0; return 1; } __setup ("cio_ignore=", blacklist_setup); /* Checking if devices are blacklisted */ /* * Function: is_blacklisted * Returns 1 if the given devicenumber can be found in the blacklist, * otherwise 0. * Used by validate_subchannel() */ int is_blacklisted (int ssid, int devno) { return test_bit (devno, bl_dev[ssid]); } #ifdef CONFIG_PROC_FS /* * Function: blacklist_parse_proc_parameters * parse the stuff which is piped to /proc/cio_ignore */ static int blacklist_parse_proc_parameters(char *buf) { int rc; char *parm; parm = strsep(&buf, " "); if (strcmp("free", parm) == 0) { rc = blacklist_parse_parameters(buf, free, 0); /* * Evaluate the subchannels without an online device. This way, * no path-verification will be triggered on those subchannels * and it avoids unnecessary delays. */ css_schedule_eval_cond(CSS_EVAL_NOT_ONLINE, 0); } else if (strcmp("add", parm) == 0) rc = blacklist_parse_parameters(buf, add, 0); else if (strcmp("purge", parm) == 0) return ccw_purge_blacklisted(); else return -EINVAL; return rc; } /* Iterator struct for all devices. */ struct ccwdev_iter { int devno; int ssid; int in_range; }; static void * cio_ignore_proc_seq_start(struct seq_file *s, loff_t *offset) { struct ccwdev_iter *iter = s->private; if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1)) return NULL; memset(iter, 0, sizeof(*iter)); iter->ssid = *offset / (__MAX_SUBCHANNEL + 1); iter->devno = *offset % (__MAX_SUBCHANNEL + 1); return iter; } static void cio_ignore_proc_seq_stop(struct seq_file *s, void *it) { } static void * cio_ignore_proc_seq_next(struct seq_file *s, void *it, loff_t *offset) { struct ccwdev_iter *iter; loff_t p = *offset; (*offset)++; if (p >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1)) return NULL; iter = it; if (iter->devno == __MAX_SUBCHANNEL) { iter->devno = 0; iter->ssid++; if (iter->ssid > __MAX_SSID) return NULL; } else iter->devno++; return iter; } static int cio_ignore_proc_seq_show(struct seq_file *s, void *it) { struct ccwdev_iter *iter; iter = it; if (!is_blacklisted(iter->ssid, iter->devno)) /* Not blacklisted, nothing to output. */ return 0; if (!iter->in_range) { /* First device in range. */ if ((iter->devno == __MAX_SUBCHANNEL) || !is_blacklisted(iter->ssid, iter->devno + 1)) { /* Singular device. */ seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno); return 0; } iter->in_range = 1; seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno); return 0; } if ((iter->devno == __MAX_SUBCHANNEL) || !is_blacklisted(iter->ssid, iter->devno + 1)) { /* Last device in range. */ iter->in_range = 0; seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno); } return 0; } static ssize_t cio_ignore_write(struct file *file, const char __user *user_buf, size_t user_len, loff_t *offset) { char *buf; ssize_t rc, ret, i; if (*offset) return -EINVAL; if (user_len > 65536) user_len = 65536; buf = vzalloc(user_len + 1); /* maybe better use the stack? */ if (buf == NULL) return -ENOMEM; if (strncpy_from_user (buf, user_buf, user_len) < 0) { rc = -EFAULT; goto out_free; } i = user_len - 1; while ((i >= 0) && (isspace(buf[i]) || (buf[i] == 0))) { buf[i] = '\0'; i--; } ret = blacklist_parse_proc_parameters(buf); if (ret) rc = ret; else rc = user_len; out_free: vfree (buf); return rc; } static const struct seq_operations cio_ignore_proc_seq_ops = { .start = cio_ignore_proc_seq_start, .stop = cio_ignore_proc_seq_stop, .next = cio_ignore_proc_seq_next, .show = cio_ignore_proc_seq_show, }; static int cio_ignore_proc_open(struct inode *inode, struct file *file) { return seq_open_private(file, &cio_ignore_proc_seq_ops, sizeof(struct ccwdev_iter)); } static const struct proc_ops cio_ignore_proc_ops = { .proc_open = cio_ignore_proc_open, .proc_read = seq_read, .proc_lseek = seq_lseek, .proc_release = seq_release_private, .proc_write = cio_ignore_write, }; static int cio_ignore_proc_init (void) { struct proc_dir_entry *entry; entry = proc_create("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR, NULL, &cio_ignore_proc_ops); if (!entry) return -ENOENT; return 0; } __initcall (cio_ignore_proc_init); #endif /* CONFIG_PROC_FS */