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))) 42 static unsigned long bl_dev[__MAX_SSID + 1][__BL_DEV_WORDS]; 43 typedef enum {add, free} range_action; 44 45 /* 46 * Function: blacklist_range 47 * (Un-)blacklist the devices from-to 48 */ 49 static 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 77 static 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 101 static 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; 141 out: 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 149 static 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 226 static int __init 227 blacklist_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 */ 245 int 246 is_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 */ 256 static 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 /* 266 * Evaluate the subchannels without an online device. This way, 267 * no path-verification will be triggered on those subchannels 268 * and it avoids unnecessary delays. 269 */ 270 css_schedule_eval_cond(CSS_EVAL_NOT_ONLINE, 0); 271 } else if (strcmp("add", parm) == 0) 272 rc = blacklist_parse_parameters(buf, add, 0); 273 else if (strcmp("purge", parm) == 0) 274 return ccw_purge_blacklisted(); 275 else 276 return -EINVAL; 277 278 279 return rc; 280 } 281 282 /* Iterator struct for all devices. */ 283 struct ccwdev_iter { 284 int devno; 285 int ssid; 286 int in_range; 287 }; 288 289 static void * 290 cio_ignore_proc_seq_start(struct seq_file *s, loff_t *offset) 291 { 292 struct ccwdev_iter *iter = s->private; 293 294 if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1)) 295 return NULL; 296 memset(iter, 0, sizeof(*iter)); 297 iter->ssid = *offset / (__MAX_SUBCHANNEL + 1); 298 iter->devno = *offset % (__MAX_SUBCHANNEL + 1); 299 return iter; 300 } 301 302 static void 303 cio_ignore_proc_seq_stop(struct seq_file *s, void *it) 304 { 305 } 306 307 static void * 308 cio_ignore_proc_seq_next(struct seq_file *s, void *it, loff_t *offset) 309 { 310 struct ccwdev_iter *iter; 311 loff_t p = *offset; 312 313 (*offset)++; 314 if (p >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1)) 315 return NULL; 316 iter = it; 317 if (iter->devno == __MAX_SUBCHANNEL) { 318 iter->devno = 0; 319 iter->ssid++; 320 if (iter->ssid > __MAX_SSID) 321 return NULL; 322 } else 323 iter->devno++; 324 return iter; 325 } 326 327 static int 328 cio_ignore_proc_seq_show(struct seq_file *s, void *it) 329 { 330 struct ccwdev_iter *iter; 331 332 iter = it; 333 if (!is_blacklisted(iter->ssid, iter->devno)) 334 /* Not blacklisted, nothing to output. */ 335 return 0; 336 if (!iter->in_range) { 337 /* First device in range. */ 338 if ((iter->devno == __MAX_SUBCHANNEL) || 339 !is_blacklisted(iter->ssid, iter->devno + 1)) { 340 /* Singular device. */ 341 seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno); 342 return 0; 343 } 344 iter->in_range = 1; 345 seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno); 346 return 0; 347 } 348 if ((iter->devno == __MAX_SUBCHANNEL) || 349 !is_blacklisted(iter->ssid, iter->devno + 1)) { 350 /* Last device in range. */ 351 iter->in_range = 0; 352 seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno); 353 } 354 return 0; 355 } 356 357 static ssize_t 358 cio_ignore_write(struct file *file, const char __user *user_buf, 359 size_t user_len, loff_t *offset) 360 { 361 char *buf; 362 ssize_t rc, ret, i; 363 364 if (*offset) 365 return -EINVAL; 366 if (user_len > 65536) 367 user_len = 65536; 368 buf = vzalloc(user_len + 1); /* maybe better use the stack? */ 369 if (buf == NULL) 370 return -ENOMEM; 371 372 if (strncpy_from_user (buf, user_buf, user_len) < 0) { 373 rc = -EFAULT; 374 goto out_free; 375 } 376 377 i = user_len - 1; 378 while ((i >= 0) && (isspace(buf[i]) || (buf[i] == 0))) { 379 buf[i] = '\0'; 380 i--; 381 } 382 ret = blacklist_parse_proc_parameters(buf); 383 if (ret) 384 rc = ret; 385 else 386 rc = user_len; 387 388 out_free: 389 vfree (buf); 390 return rc; 391 } 392 393 static const struct seq_operations cio_ignore_proc_seq_ops = { 394 .start = cio_ignore_proc_seq_start, 395 .stop = cio_ignore_proc_seq_stop, 396 .next = cio_ignore_proc_seq_next, 397 .show = cio_ignore_proc_seq_show, 398 }; 399 400 static int 401 cio_ignore_proc_open(struct inode *inode, struct file *file) 402 { 403 return seq_open_private(file, &cio_ignore_proc_seq_ops, 404 sizeof(struct ccwdev_iter)); 405 } 406 407 static const struct proc_ops cio_ignore_proc_ops = { 408 .proc_open = cio_ignore_proc_open, 409 .proc_read = seq_read, 410 .proc_lseek = seq_lseek, 411 .proc_release = seq_release_private, 412 .proc_write = cio_ignore_write, 413 }; 414 415 static int 416 cio_ignore_proc_init (void) 417 { 418 struct proc_dir_entry *entry; 419 420 entry = proc_create("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR, NULL, 421 &cio_ignore_proc_ops); 422 if (!entry) 423 return -ENOENT; 424 return 0; 425 } 426 427 __initcall (cio_ignore_proc_init); 428 429 #endif /* CONFIG_PROC_FS */ 430