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