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 <asm/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_warning("0.%x.%04x to 0.%x.%04x is not a valid " 55 "range for cio_ignore\n", from_ssid, from, 56 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_warning("%s is not a valid device for the cio_ignore " 144 "kernel parameter\n", 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 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 css_schedule_reprobe(); 273 274 return rc; 275 } 276 277 /* Iterator struct for all devices. */ 278 struct ccwdev_iter { 279 int devno; 280 int ssid; 281 int in_range; 282 }; 283 284 static void * 285 cio_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 297 static void 298 cio_ignore_proc_seq_stop(struct seq_file *s, void *it) 299 { 300 } 301 302 static void * 303 cio_ignore_proc_seq_next(struct seq_file *s, void *it, loff_t *offset) 304 { 305 struct ccwdev_iter *iter; 306 307 if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1)) 308 return NULL; 309 iter = it; 310 if (iter->devno == __MAX_SUBCHANNEL) { 311 iter->devno = 0; 312 iter->ssid++; 313 if (iter->ssid > __MAX_SSID) 314 return NULL; 315 } else 316 iter->devno++; 317 (*offset)++; 318 return iter; 319 } 320 321 static int 322 cio_ignore_proc_seq_show(struct seq_file *s, void *it) 323 { 324 struct ccwdev_iter *iter; 325 326 iter = it; 327 if (!is_blacklisted(iter->ssid, iter->devno)) 328 /* Not blacklisted, nothing to output. */ 329 return 0; 330 if (!iter->in_range) { 331 /* First device in range. */ 332 if ((iter->devno == __MAX_SUBCHANNEL) || 333 !is_blacklisted(iter->ssid, iter->devno + 1)) 334 /* Singular device. */ 335 return seq_printf(s, "0.%x.%04x\n", 336 iter->ssid, iter->devno); 337 iter->in_range = 1; 338 return seq_printf(s, "0.%x.%04x-", iter->ssid, iter->devno); 339 } 340 if ((iter->devno == __MAX_SUBCHANNEL) || 341 !is_blacklisted(iter->ssid, iter->devno + 1)) { 342 /* Last device in range. */ 343 iter->in_range = 0; 344 return seq_printf(s, "0.%x.%04x\n", iter->ssid, iter->devno); 345 } 346 return 0; 347 } 348 349 static ssize_t 350 cio_ignore_write(struct file *file, const char __user *user_buf, 351 size_t user_len, loff_t *offset) 352 { 353 char *buf; 354 ssize_t rc, ret, i; 355 356 if (*offset) 357 return -EINVAL; 358 if (user_len > 65536) 359 user_len = 65536; 360 buf = vzalloc(user_len + 1); /* maybe better use the stack? */ 361 if (buf == NULL) 362 return -ENOMEM; 363 364 if (strncpy_from_user (buf, user_buf, user_len) < 0) { 365 rc = -EFAULT; 366 goto out_free; 367 } 368 369 i = user_len - 1; 370 while ((i >= 0) && (isspace(buf[i]) || (buf[i] == 0))) { 371 buf[i] = '\0'; 372 i--; 373 } 374 ret = blacklist_parse_proc_parameters(buf); 375 if (ret) 376 rc = ret; 377 else 378 rc = user_len; 379 380 out_free: 381 vfree (buf); 382 return rc; 383 } 384 385 static const struct seq_operations cio_ignore_proc_seq_ops = { 386 .start = cio_ignore_proc_seq_start, 387 .stop = cio_ignore_proc_seq_stop, 388 .next = cio_ignore_proc_seq_next, 389 .show = cio_ignore_proc_seq_show, 390 }; 391 392 static int 393 cio_ignore_proc_open(struct inode *inode, struct file *file) 394 { 395 return seq_open_private(file, &cio_ignore_proc_seq_ops, 396 sizeof(struct ccwdev_iter)); 397 } 398 399 static const struct file_operations cio_ignore_proc_fops = { 400 .open = cio_ignore_proc_open, 401 .read = seq_read, 402 .llseek = seq_lseek, 403 .release = seq_release_private, 404 .write = cio_ignore_write, 405 }; 406 407 static int 408 cio_ignore_proc_init (void) 409 { 410 struct proc_dir_entry *entry; 411 412 entry = proc_create("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR, NULL, 413 &cio_ignore_proc_fops); 414 if (!entry) 415 return -ENOENT; 416 return 0; 417 } 418 419 __initcall (cio_ignore_proc_init); 420 421 #endif /* CONFIG_PROC_FS */ 422