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