1 /* 2 * File...........: linux/drivers/s390/block/dasd_devmap.c 3 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> 4 * Horst Hummel <Horst.Hummel@de.ibm.com> 5 * Carsten Otte <Cotte@de.ibm.com> 6 * Martin Schwidefsky <schwidefsky@de.ibm.com> 7 * Bugreports.to..: <Linux390@de.ibm.com> 8 * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999-2001 9 * 10 * Device mapping and dasd= parameter parsing functions. All devmap 11 * functions may not be called from interrupt context. In particular 12 * dasd_get_device is a no-no from interrupt context. 13 * 14 */ 15 16 #define KMSG_COMPONENT "dasd" 17 18 #include <linux/ctype.h> 19 #include <linux/init.h> 20 #include <linux/module.h> 21 22 #include <asm/debug.h> 23 #include <asm/uaccess.h> 24 #include <asm/ipl.h> 25 26 /* This is ugly... */ 27 #define PRINTK_HEADER "dasd_devmap:" 28 #define DASD_BUS_ID_SIZE 20 29 30 #include "dasd_int.h" 31 32 struct kmem_cache *dasd_page_cache; 33 EXPORT_SYMBOL_GPL(dasd_page_cache); 34 35 /* 36 * dasd_devmap_t is used to store the features and the relation 37 * between device number and device index. To find a dasd_devmap_t 38 * that corresponds to a device number of a device index each 39 * dasd_devmap_t is added to two linked lists, one to search by 40 * the device number and one to search by the device index. As 41 * soon as big minor numbers are available the device index list 42 * can be removed since the device number will then be identical 43 * to the device index. 44 */ 45 struct dasd_devmap { 46 struct list_head list; 47 char bus_id[DASD_BUS_ID_SIZE]; 48 unsigned int devindex; 49 unsigned short features; 50 struct dasd_device *device; 51 struct dasd_uid uid; 52 }; 53 54 /* 55 * Parameter parsing functions for dasd= parameter. The syntax is: 56 * <devno> : (0x)?[0-9a-fA-F]+ 57 * <busid> : [0-0a-f]\.[0-9a-f]\.(0x)?[0-9a-fA-F]+ 58 * <feature> : ro 59 * <feature_list> : \(<feature>(:<feature>)*\) 60 * <devno-range> : <devno>(-<devno>)?<feature_list>? 61 * <busid-range> : <busid>(-<busid>)?<feature_list>? 62 * <devices> : <devno-range>|<busid-range> 63 * <dasd_module> : dasd_diag_mod|dasd_eckd_mod|dasd_fba_mod 64 * 65 * <dasd> : autodetect|probeonly|<devices>(,<devices>)* 66 */ 67 68 int dasd_probeonly = 0; /* is true, when probeonly mode is active */ 69 int dasd_autodetect = 0; /* is true, when autodetection is active */ 70 int dasd_nopav = 0; /* is true, when PAV is disabled */ 71 EXPORT_SYMBOL_GPL(dasd_nopav); 72 int dasd_nofcx; /* disable High Performance Ficon */ 73 EXPORT_SYMBOL_GPL(dasd_nofcx); 74 75 /* 76 * char *dasd[] is intended to hold the ranges supplied by the dasd= statement 77 * it is named 'dasd' to directly be filled by insmod with the comma separated 78 * strings when running as a module. 79 */ 80 static char *dasd[256]; 81 module_param_array(dasd, charp, NULL, 0); 82 83 /* 84 * Single spinlock to protect devmap and servermap structures and lists. 85 */ 86 static DEFINE_SPINLOCK(dasd_devmap_lock); 87 88 /* 89 * Hash lists for devmap structures. 90 */ 91 static struct list_head dasd_hashlists[256]; 92 int dasd_max_devindex; 93 94 static struct dasd_devmap *dasd_add_busid(const char *, int); 95 96 static inline int 97 dasd_hash_busid(const char *bus_id) 98 { 99 int hash, i; 100 101 hash = 0; 102 for (i = 0; (i < DASD_BUS_ID_SIZE) && *bus_id; i++, bus_id++) 103 hash += *bus_id; 104 return hash & 0xff; 105 } 106 107 #ifndef MODULE 108 /* 109 * The parameter parsing functions for builtin-drivers are called 110 * before kmalloc works. Store the pointers to the parameters strings 111 * into dasd[] for later processing. 112 */ 113 static int __init 114 dasd_call_setup(char *str) 115 { 116 static int count = 0; 117 118 if (count < 256) 119 dasd[count++] = str; 120 return 1; 121 } 122 123 __setup ("dasd=", dasd_call_setup); 124 #endif /* #ifndef MODULE */ 125 126 #define DASD_IPLDEV "ipldev" 127 128 /* 129 * Read a device busid/devno from a string. 130 */ 131 static int 132 133 dasd_busid(char **str, int *id0, int *id1, int *devno) 134 { 135 int val, old_style; 136 137 /* Interpret ipldev busid */ 138 if (strncmp(DASD_IPLDEV, *str, strlen(DASD_IPLDEV)) == 0) { 139 if (ipl_info.type != IPL_TYPE_CCW) { 140 pr_err("The IPL device is not a CCW device\n"); 141 return -EINVAL; 142 } 143 *id0 = 0; 144 *id1 = ipl_info.data.ccw.dev_id.ssid; 145 *devno = ipl_info.data.ccw.dev_id.devno; 146 *str += strlen(DASD_IPLDEV); 147 148 return 0; 149 } 150 /* check for leading '0x' */ 151 old_style = 0; 152 if ((*str)[0] == '0' && (*str)[1] == 'x') { 153 *str += 2; 154 old_style = 1; 155 } 156 if (!isxdigit((*str)[0])) /* We require at least one hex digit */ 157 return -EINVAL; 158 val = simple_strtoul(*str, str, 16); 159 if (old_style || (*str)[0] != '.') { 160 *id0 = *id1 = 0; 161 if (val < 0 || val > 0xffff) 162 return -EINVAL; 163 *devno = val; 164 return 0; 165 } 166 /* New style x.y.z busid */ 167 if (val < 0 || val > 0xff) 168 return -EINVAL; 169 *id0 = val; 170 (*str)++; 171 if (!isxdigit((*str)[0])) /* We require at least one hex digit */ 172 return -EINVAL; 173 val = simple_strtoul(*str, str, 16); 174 if (val < 0 || val > 0xff || (*str)++[0] != '.') 175 return -EINVAL; 176 *id1 = val; 177 if (!isxdigit((*str)[0])) /* We require at least one hex digit */ 178 return -EINVAL; 179 val = simple_strtoul(*str, str, 16); 180 if (val < 0 || val > 0xffff) 181 return -EINVAL; 182 *devno = val; 183 return 0; 184 } 185 186 /* 187 * Read colon separated list of dasd features. Currently there is 188 * only one: "ro" for read-only devices. The default feature set 189 * is empty (value 0). 190 */ 191 static int 192 dasd_feature_list(char *str, char **endp) 193 { 194 int features, len, rc; 195 196 rc = 0; 197 if (*str != '(') { 198 *endp = str; 199 return DASD_FEATURE_DEFAULT; 200 } 201 str++; 202 features = 0; 203 204 while (1) { 205 for (len = 0; 206 str[len] && str[len] != ':' && str[len] != ')'; len++); 207 if (len == 2 && !strncmp(str, "ro", 2)) 208 features |= DASD_FEATURE_READONLY; 209 else if (len == 4 && !strncmp(str, "diag", 4)) 210 features |= DASD_FEATURE_USEDIAG; 211 else if (len == 6 && !strncmp(str, "erplog", 6)) 212 features |= DASD_FEATURE_ERPLOG; 213 else if (len == 8 && !strncmp(str, "failfast", 8)) 214 features |= DASD_FEATURE_FAILFAST; 215 else { 216 pr_warning("%*s is not a supported device option\n", 217 len, str); 218 rc = -EINVAL; 219 } 220 str += len; 221 if (*str != ':') 222 break; 223 str++; 224 } 225 if (*str != ')') { 226 pr_warning("A closing parenthesis ')' is missing in the " 227 "dasd= parameter\n"); 228 rc = -EINVAL; 229 } else 230 str++; 231 *endp = str; 232 if (rc != 0) 233 return rc; 234 return features; 235 } 236 237 /* 238 * Try to match the first element on the comma separated parse string 239 * with one of the known keywords. If a keyword is found, take the approprate 240 * action and return a pointer to the residual string. If the first element 241 * could not be matched to any keyword then return an error code. 242 */ 243 static char * 244 dasd_parse_keyword( char *parsestring ) { 245 246 char *nextcomma, *residual_str; 247 int length; 248 249 nextcomma = strchr(parsestring,','); 250 if (nextcomma) { 251 length = nextcomma - parsestring; 252 residual_str = nextcomma + 1; 253 } else { 254 length = strlen(parsestring); 255 residual_str = parsestring + length; 256 } 257 if (strncmp("autodetect", parsestring, length) == 0) { 258 dasd_autodetect = 1; 259 pr_info("The autodetection mode has been activated\n"); 260 return residual_str; 261 } 262 if (strncmp("probeonly", parsestring, length) == 0) { 263 dasd_probeonly = 1; 264 pr_info("The probeonly mode has been activated\n"); 265 return residual_str; 266 } 267 if (strncmp("nopav", parsestring, length) == 0) { 268 if (MACHINE_IS_VM) 269 pr_info("'nopav' is not supported on z/VM\n"); 270 else { 271 dasd_nopav = 1; 272 pr_info("PAV support has be deactivated\n"); 273 } 274 return residual_str; 275 } 276 if (strncmp("nofcx", parsestring, length) == 0) { 277 dasd_nofcx = 1; 278 pr_info("High Performance FICON support has been " 279 "deactivated\n"); 280 return residual_str; 281 } 282 if (strncmp("fixedbuffers", parsestring, length) == 0) { 283 if (dasd_page_cache) 284 return residual_str; 285 dasd_page_cache = 286 kmem_cache_create("dasd_page_cache", PAGE_SIZE, 287 PAGE_SIZE, SLAB_CACHE_DMA, 288 NULL); 289 if (!dasd_page_cache) 290 DBF_EVENT(DBF_WARNING, "%s", "Failed to create slab, " 291 "fixed buffer mode disabled."); 292 else 293 DBF_EVENT(DBF_INFO, "%s", 294 "turning on fixed buffer mode"); 295 return residual_str; 296 } 297 return ERR_PTR(-EINVAL); 298 } 299 300 /* 301 * Try to interprete the first element on the comma separated parse string 302 * as a device number or a range of devices. If the interpretation is 303 * successfull, create the matching dasd_devmap entries and return a pointer 304 * to the residual string. 305 * If interpretation fails or in case of an error, return an error code. 306 */ 307 static char * 308 dasd_parse_range( char *parsestring ) { 309 310 struct dasd_devmap *devmap; 311 int from, from_id0, from_id1; 312 int to, to_id0, to_id1; 313 int features, rc; 314 char bus_id[DASD_BUS_ID_SIZE+1], *str; 315 316 str = parsestring; 317 rc = dasd_busid(&str, &from_id0, &from_id1, &from); 318 if (rc == 0) { 319 to = from; 320 to_id0 = from_id0; 321 to_id1 = from_id1; 322 if (*str == '-') { 323 str++; 324 rc = dasd_busid(&str, &to_id0, &to_id1, &to); 325 } 326 } 327 if (rc == 0 && 328 (from_id0 != to_id0 || from_id1 != to_id1 || from > to)) 329 rc = -EINVAL; 330 if (rc) { 331 pr_err("%s is not a valid device range\n", parsestring); 332 return ERR_PTR(rc); 333 } 334 features = dasd_feature_list(str, &str); 335 if (features < 0) 336 return ERR_PTR(-EINVAL); 337 /* each device in dasd= parameter should be set initially online */ 338 features |= DASD_FEATURE_INITIAL_ONLINE; 339 while (from <= to) { 340 sprintf(bus_id, "%01x.%01x.%04x", 341 from_id0, from_id1, from++); 342 devmap = dasd_add_busid(bus_id, features); 343 if (IS_ERR(devmap)) 344 return (char *)devmap; 345 } 346 if (*str == ',') 347 return str + 1; 348 if (*str == '\0') 349 return str; 350 pr_warning("The dasd= parameter value %s has an invalid ending\n", 351 str); 352 return ERR_PTR(-EINVAL); 353 } 354 355 static char * 356 dasd_parse_next_element( char *parsestring ) { 357 char * residual_str; 358 residual_str = dasd_parse_keyword(parsestring); 359 if (!IS_ERR(residual_str)) 360 return residual_str; 361 residual_str = dasd_parse_range(parsestring); 362 return residual_str; 363 } 364 365 /* 366 * Parse parameters stored in dasd[] 367 * The 'dasd=...' parameter allows to specify a comma separated list of 368 * keywords and device ranges. When the dasd driver is build into the kernel, 369 * the complete list will be stored as one element of the dasd[] array. 370 * When the dasd driver is build as a module, then the list is broken into 371 * it's elements and each dasd[] entry contains one element. 372 */ 373 int 374 dasd_parse(void) 375 { 376 int rc, i; 377 char *parsestring; 378 379 rc = 0; 380 for (i = 0; i < 256; i++) { 381 if (dasd[i] == NULL) 382 break; 383 parsestring = dasd[i]; 384 /* loop over the comma separated list in the parsestring */ 385 while (*parsestring) { 386 parsestring = dasd_parse_next_element(parsestring); 387 if(IS_ERR(parsestring)) { 388 rc = PTR_ERR(parsestring); 389 break; 390 } 391 } 392 if (rc) { 393 DBF_EVENT(DBF_ALERT, "%s", "invalid range found"); 394 break; 395 } 396 } 397 return rc; 398 } 399 400 /* 401 * Add a devmap for the device specified by busid. It is possible that 402 * the devmap already exists (dasd= parameter). The order of the devices 403 * added through this function will define the kdevs for the individual 404 * devices. 405 */ 406 static struct dasd_devmap * 407 dasd_add_busid(const char *bus_id, int features) 408 { 409 struct dasd_devmap *devmap, *new, *tmp; 410 int hash; 411 412 new = (struct dasd_devmap *) 413 kzalloc(sizeof(struct dasd_devmap), GFP_KERNEL); 414 if (!new) 415 return ERR_PTR(-ENOMEM); 416 spin_lock(&dasd_devmap_lock); 417 devmap = NULL; 418 hash = dasd_hash_busid(bus_id); 419 list_for_each_entry(tmp, &dasd_hashlists[hash], list) 420 if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) { 421 devmap = tmp; 422 break; 423 } 424 if (!devmap) { 425 /* This bus_id is new. */ 426 new->devindex = dasd_max_devindex++; 427 strncpy(new->bus_id, bus_id, DASD_BUS_ID_SIZE); 428 new->features = features; 429 new->device = NULL; 430 list_add(&new->list, &dasd_hashlists[hash]); 431 devmap = new; 432 new = NULL; 433 } 434 spin_unlock(&dasd_devmap_lock); 435 kfree(new); 436 return devmap; 437 } 438 439 /* 440 * Find devmap for device with given bus_id. 441 */ 442 static struct dasd_devmap * 443 dasd_find_busid(const char *bus_id) 444 { 445 struct dasd_devmap *devmap, *tmp; 446 int hash; 447 448 spin_lock(&dasd_devmap_lock); 449 devmap = ERR_PTR(-ENODEV); 450 hash = dasd_hash_busid(bus_id); 451 list_for_each_entry(tmp, &dasd_hashlists[hash], list) { 452 if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) { 453 devmap = tmp; 454 break; 455 } 456 } 457 spin_unlock(&dasd_devmap_lock); 458 return devmap; 459 } 460 461 /* 462 * Check if busid has been added to the list of dasd ranges. 463 */ 464 int 465 dasd_busid_known(const char *bus_id) 466 { 467 return IS_ERR(dasd_find_busid(bus_id)) ? -ENOENT : 0; 468 } 469 470 /* 471 * Forget all about the device numbers added so far. 472 * This may only be called at module unload or system shutdown. 473 */ 474 static void 475 dasd_forget_ranges(void) 476 { 477 struct dasd_devmap *devmap, *n; 478 int i; 479 480 spin_lock(&dasd_devmap_lock); 481 for (i = 0; i < 256; i++) { 482 list_for_each_entry_safe(devmap, n, &dasd_hashlists[i], list) { 483 BUG_ON(devmap->device != NULL); 484 list_del(&devmap->list); 485 kfree(devmap); 486 } 487 } 488 spin_unlock(&dasd_devmap_lock); 489 } 490 491 /* 492 * Find the device struct by its device index. 493 */ 494 struct dasd_device * 495 dasd_device_from_devindex(int devindex) 496 { 497 struct dasd_devmap *devmap, *tmp; 498 struct dasd_device *device; 499 int i; 500 501 spin_lock(&dasd_devmap_lock); 502 devmap = NULL; 503 for (i = 0; (i < 256) && !devmap; i++) 504 list_for_each_entry(tmp, &dasd_hashlists[i], list) 505 if (tmp->devindex == devindex) { 506 /* Found the devmap for the device. */ 507 devmap = tmp; 508 break; 509 } 510 if (devmap && devmap->device) { 511 device = devmap->device; 512 dasd_get_device(device); 513 } else 514 device = ERR_PTR(-ENODEV); 515 spin_unlock(&dasd_devmap_lock); 516 return device; 517 } 518 519 /* 520 * Return devmap for cdev. If no devmap exists yet, create one and 521 * connect it to the cdev. 522 */ 523 static struct dasd_devmap * 524 dasd_devmap_from_cdev(struct ccw_device *cdev) 525 { 526 struct dasd_devmap *devmap; 527 528 devmap = dasd_find_busid(dev_name(&cdev->dev)); 529 if (IS_ERR(devmap)) 530 devmap = dasd_add_busid(dev_name(&cdev->dev), 531 DASD_FEATURE_DEFAULT); 532 return devmap; 533 } 534 535 /* 536 * Create a dasd device structure for cdev. 537 */ 538 struct dasd_device * 539 dasd_create_device(struct ccw_device *cdev) 540 { 541 struct dasd_devmap *devmap; 542 struct dasd_device *device; 543 unsigned long flags; 544 int rc; 545 546 devmap = dasd_devmap_from_cdev(cdev); 547 if (IS_ERR(devmap)) 548 return (void *) devmap; 549 550 device = dasd_alloc_device(); 551 if (IS_ERR(device)) 552 return device; 553 atomic_set(&device->ref_count, 3); 554 555 spin_lock(&dasd_devmap_lock); 556 if (!devmap->device) { 557 devmap->device = device; 558 device->devindex = devmap->devindex; 559 device->features = devmap->features; 560 get_device(&cdev->dev); 561 device->cdev = cdev; 562 rc = 0; 563 } else 564 /* Someone else was faster. */ 565 rc = -EBUSY; 566 spin_unlock(&dasd_devmap_lock); 567 568 if (rc) { 569 dasd_free_device(device); 570 return ERR_PTR(rc); 571 } 572 573 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 574 dev_set_drvdata(&cdev->dev, device); 575 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 576 577 return device; 578 } 579 580 /* 581 * Wait queue for dasd_delete_device waits. 582 */ 583 static DECLARE_WAIT_QUEUE_HEAD(dasd_delete_wq); 584 585 /* 586 * Remove a dasd device structure. The passed referenced 587 * is destroyed. 588 */ 589 void 590 dasd_delete_device(struct dasd_device *device) 591 { 592 struct ccw_device *cdev; 593 struct dasd_devmap *devmap; 594 unsigned long flags; 595 596 /* First remove device pointer from devmap. */ 597 devmap = dasd_find_busid(dev_name(&device->cdev->dev)); 598 BUG_ON(IS_ERR(devmap)); 599 spin_lock(&dasd_devmap_lock); 600 if (devmap->device != device) { 601 spin_unlock(&dasd_devmap_lock); 602 dasd_put_device(device); 603 return; 604 } 605 devmap->device = NULL; 606 spin_unlock(&dasd_devmap_lock); 607 608 /* Disconnect dasd_device structure from ccw_device structure. */ 609 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 610 dev_set_drvdata(&device->cdev->dev, NULL); 611 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 612 613 /* 614 * Drop ref_count by 3, one for the devmap reference, one for 615 * the cdev reference and one for the passed reference. 616 */ 617 atomic_sub(3, &device->ref_count); 618 619 /* Wait for reference counter to drop to zero. */ 620 wait_event(dasd_delete_wq, atomic_read(&device->ref_count) == 0); 621 622 /* Disconnect dasd_device structure from ccw_device structure. */ 623 cdev = device->cdev; 624 device->cdev = NULL; 625 626 /* Put ccw_device structure. */ 627 put_device(&cdev->dev); 628 629 /* Now the device structure can be freed. */ 630 dasd_free_device(device); 631 } 632 633 /* 634 * Reference counter dropped to zero. Wake up waiter 635 * in dasd_delete_device. 636 */ 637 void 638 dasd_put_device_wake(struct dasd_device *device) 639 { 640 wake_up(&dasd_delete_wq); 641 } 642 643 /* 644 * Return dasd_device structure associated with cdev. 645 * This function needs to be called with the ccw device 646 * lock held. It can be used from interrupt context. 647 */ 648 struct dasd_device * 649 dasd_device_from_cdev_locked(struct ccw_device *cdev) 650 { 651 struct dasd_device *device = dev_get_drvdata(&cdev->dev); 652 653 if (!device) 654 return ERR_PTR(-ENODEV); 655 dasd_get_device(device); 656 return device; 657 } 658 659 /* 660 * Return dasd_device structure associated with cdev. 661 */ 662 struct dasd_device * 663 dasd_device_from_cdev(struct ccw_device *cdev) 664 { 665 struct dasd_device *device; 666 unsigned long flags; 667 668 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 669 device = dasd_device_from_cdev_locked(cdev); 670 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 671 return device; 672 } 673 674 /* 675 * SECTION: files in sysfs 676 */ 677 678 /* 679 * failfast controls the behaviour, if no path is available 680 */ 681 static ssize_t dasd_ff_show(struct device *dev, struct device_attribute *attr, 682 char *buf) 683 { 684 struct dasd_devmap *devmap; 685 int ff_flag; 686 687 devmap = dasd_find_busid(dev_name(dev)); 688 if (!IS_ERR(devmap)) 689 ff_flag = (devmap->features & DASD_FEATURE_FAILFAST) != 0; 690 else 691 ff_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_FAILFAST) != 0; 692 return snprintf(buf, PAGE_SIZE, ff_flag ? "1\n" : "0\n"); 693 } 694 695 static ssize_t dasd_ff_store(struct device *dev, struct device_attribute *attr, 696 const char *buf, size_t count) 697 { 698 struct dasd_devmap *devmap; 699 int val; 700 char *endp; 701 702 devmap = dasd_devmap_from_cdev(to_ccwdev(dev)); 703 if (IS_ERR(devmap)) 704 return PTR_ERR(devmap); 705 706 val = simple_strtoul(buf, &endp, 0); 707 if (((endp + 1) < (buf + count)) || (val > 1)) 708 return -EINVAL; 709 710 spin_lock(&dasd_devmap_lock); 711 if (val) 712 devmap->features |= DASD_FEATURE_FAILFAST; 713 else 714 devmap->features &= ~DASD_FEATURE_FAILFAST; 715 if (devmap->device) 716 devmap->device->features = devmap->features; 717 spin_unlock(&dasd_devmap_lock); 718 return count; 719 } 720 721 static DEVICE_ATTR(failfast, 0644, dasd_ff_show, dasd_ff_store); 722 723 /* 724 * readonly controls the readonly status of a dasd 725 */ 726 static ssize_t 727 dasd_ro_show(struct device *dev, struct device_attribute *attr, char *buf) 728 { 729 struct dasd_devmap *devmap; 730 int ro_flag; 731 732 devmap = dasd_find_busid(dev_name(dev)); 733 if (!IS_ERR(devmap)) 734 ro_flag = (devmap->features & DASD_FEATURE_READONLY) != 0; 735 else 736 ro_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_READONLY) != 0; 737 return snprintf(buf, PAGE_SIZE, ro_flag ? "1\n" : "0\n"); 738 } 739 740 static ssize_t 741 dasd_ro_store(struct device *dev, struct device_attribute *attr, 742 const char *buf, size_t count) 743 { 744 struct dasd_devmap *devmap; 745 int val; 746 char *endp; 747 748 devmap = dasd_devmap_from_cdev(to_ccwdev(dev)); 749 if (IS_ERR(devmap)) 750 return PTR_ERR(devmap); 751 752 val = simple_strtoul(buf, &endp, 0); 753 if (((endp + 1) < (buf + count)) || (val > 1)) 754 return -EINVAL; 755 756 spin_lock(&dasd_devmap_lock); 757 if (val) 758 devmap->features |= DASD_FEATURE_READONLY; 759 else 760 devmap->features &= ~DASD_FEATURE_READONLY; 761 if (devmap->device) 762 devmap->device->features = devmap->features; 763 if (devmap->device && devmap->device->block 764 && devmap->device->block->gdp) 765 set_disk_ro(devmap->device->block->gdp, val); 766 spin_unlock(&dasd_devmap_lock); 767 return count; 768 } 769 770 static DEVICE_ATTR(readonly, 0644, dasd_ro_show, dasd_ro_store); 771 /* 772 * erplog controls the logging of ERP related data 773 * (e.g. failing channel programs). 774 */ 775 static ssize_t 776 dasd_erplog_show(struct device *dev, struct device_attribute *attr, char *buf) 777 { 778 struct dasd_devmap *devmap; 779 int erplog; 780 781 devmap = dasd_find_busid(dev_name(dev)); 782 if (!IS_ERR(devmap)) 783 erplog = (devmap->features & DASD_FEATURE_ERPLOG) != 0; 784 else 785 erplog = (DASD_FEATURE_DEFAULT & DASD_FEATURE_ERPLOG) != 0; 786 return snprintf(buf, PAGE_SIZE, erplog ? "1\n" : "0\n"); 787 } 788 789 static ssize_t 790 dasd_erplog_store(struct device *dev, struct device_attribute *attr, 791 const char *buf, size_t count) 792 { 793 struct dasd_devmap *devmap; 794 int val; 795 char *endp; 796 797 devmap = dasd_devmap_from_cdev(to_ccwdev(dev)); 798 if (IS_ERR(devmap)) 799 return PTR_ERR(devmap); 800 801 val = simple_strtoul(buf, &endp, 0); 802 if (((endp + 1) < (buf + count)) || (val > 1)) 803 return -EINVAL; 804 805 spin_lock(&dasd_devmap_lock); 806 if (val) 807 devmap->features |= DASD_FEATURE_ERPLOG; 808 else 809 devmap->features &= ~DASD_FEATURE_ERPLOG; 810 if (devmap->device) 811 devmap->device->features = devmap->features; 812 spin_unlock(&dasd_devmap_lock); 813 return count; 814 } 815 816 static DEVICE_ATTR(erplog, 0644, dasd_erplog_show, dasd_erplog_store); 817 818 /* 819 * use_diag controls whether the driver should use diag rather than ssch 820 * to talk to the device 821 */ 822 static ssize_t 823 dasd_use_diag_show(struct device *dev, struct device_attribute *attr, char *buf) 824 { 825 struct dasd_devmap *devmap; 826 int use_diag; 827 828 devmap = dasd_find_busid(dev_name(dev)); 829 if (!IS_ERR(devmap)) 830 use_diag = (devmap->features & DASD_FEATURE_USEDIAG) != 0; 831 else 832 use_diag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USEDIAG) != 0; 833 return sprintf(buf, use_diag ? "1\n" : "0\n"); 834 } 835 836 static ssize_t 837 dasd_use_diag_store(struct device *dev, struct device_attribute *attr, 838 const char *buf, size_t count) 839 { 840 struct dasd_devmap *devmap; 841 ssize_t rc; 842 int val; 843 char *endp; 844 845 devmap = dasd_devmap_from_cdev(to_ccwdev(dev)); 846 if (IS_ERR(devmap)) 847 return PTR_ERR(devmap); 848 849 val = simple_strtoul(buf, &endp, 0); 850 if (((endp + 1) < (buf + count)) || (val > 1)) 851 return -EINVAL; 852 853 spin_lock(&dasd_devmap_lock); 854 /* Changing diag discipline flag is only allowed in offline state. */ 855 rc = count; 856 if (!devmap->device) { 857 if (val) 858 devmap->features |= DASD_FEATURE_USEDIAG; 859 else 860 devmap->features &= ~DASD_FEATURE_USEDIAG; 861 } else 862 rc = -EPERM; 863 spin_unlock(&dasd_devmap_lock); 864 return rc; 865 } 866 867 static DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store); 868 869 static ssize_t 870 dasd_discipline_show(struct device *dev, struct device_attribute *attr, 871 char *buf) 872 { 873 struct dasd_device *device; 874 ssize_t len; 875 876 device = dasd_device_from_cdev(to_ccwdev(dev)); 877 if (IS_ERR(device)) 878 goto out; 879 else if (!device->discipline) { 880 dasd_put_device(device); 881 goto out; 882 } else { 883 len = snprintf(buf, PAGE_SIZE, "%s\n", 884 device->discipline->name); 885 dasd_put_device(device); 886 return len; 887 } 888 out: 889 len = snprintf(buf, PAGE_SIZE, "none\n"); 890 return len; 891 } 892 893 static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL); 894 895 static ssize_t 896 dasd_device_status_show(struct device *dev, struct device_attribute *attr, 897 char *buf) 898 { 899 struct dasd_device *device; 900 ssize_t len; 901 902 device = dasd_device_from_cdev(to_ccwdev(dev)); 903 if (!IS_ERR(device)) { 904 switch (device->state) { 905 case DASD_STATE_NEW: 906 len = snprintf(buf, PAGE_SIZE, "new\n"); 907 break; 908 case DASD_STATE_KNOWN: 909 len = snprintf(buf, PAGE_SIZE, "detected\n"); 910 break; 911 case DASD_STATE_BASIC: 912 len = snprintf(buf, PAGE_SIZE, "basic\n"); 913 break; 914 case DASD_STATE_UNFMT: 915 len = snprintf(buf, PAGE_SIZE, "unformatted\n"); 916 break; 917 case DASD_STATE_READY: 918 len = snprintf(buf, PAGE_SIZE, "ready\n"); 919 break; 920 case DASD_STATE_ONLINE: 921 len = snprintf(buf, PAGE_SIZE, "online\n"); 922 break; 923 default: 924 len = snprintf(buf, PAGE_SIZE, "no stat\n"); 925 break; 926 } 927 dasd_put_device(device); 928 } else 929 len = snprintf(buf, PAGE_SIZE, "unknown\n"); 930 return len; 931 } 932 933 static DEVICE_ATTR(status, 0444, dasd_device_status_show, NULL); 934 935 static ssize_t 936 dasd_alias_show(struct device *dev, struct device_attribute *attr, char *buf) 937 { 938 struct dasd_devmap *devmap; 939 int alias; 940 941 devmap = dasd_find_busid(dev_name(dev)); 942 spin_lock(&dasd_devmap_lock); 943 if (IS_ERR(devmap) || strlen(devmap->uid.vendor) == 0) { 944 spin_unlock(&dasd_devmap_lock); 945 return sprintf(buf, "0\n"); 946 } 947 if (devmap->uid.type == UA_BASE_PAV_ALIAS || 948 devmap->uid.type == UA_HYPER_PAV_ALIAS) 949 alias = 1; 950 else 951 alias = 0; 952 spin_unlock(&dasd_devmap_lock); 953 return sprintf(buf, alias ? "1\n" : "0\n"); 954 } 955 956 static DEVICE_ATTR(alias, 0444, dasd_alias_show, NULL); 957 958 static ssize_t 959 dasd_vendor_show(struct device *dev, struct device_attribute *attr, char *buf) 960 { 961 struct dasd_devmap *devmap; 962 char *vendor; 963 964 devmap = dasd_find_busid(dev_name(dev)); 965 spin_lock(&dasd_devmap_lock); 966 if (!IS_ERR(devmap) && strlen(devmap->uid.vendor) > 0) 967 vendor = devmap->uid.vendor; 968 else 969 vendor = ""; 970 spin_unlock(&dasd_devmap_lock); 971 972 return snprintf(buf, PAGE_SIZE, "%s\n", vendor); 973 } 974 975 static DEVICE_ATTR(vendor, 0444, dasd_vendor_show, NULL); 976 977 #define UID_STRLEN ( /* vendor */ 3 + 1 + /* serial */ 14 + 1 +\ 978 /* SSID */ 4 + 1 + /* unit addr */ 2 + 1 +\ 979 /* vduit */ 32 + 1) 980 981 static ssize_t 982 dasd_uid_show(struct device *dev, struct device_attribute *attr, char *buf) 983 { 984 struct dasd_devmap *devmap; 985 char uid_string[UID_STRLEN]; 986 char ua_string[3]; 987 struct dasd_uid *uid; 988 989 devmap = dasd_find_busid(dev_name(dev)); 990 spin_lock(&dasd_devmap_lock); 991 if (IS_ERR(devmap) || strlen(devmap->uid.vendor) == 0) { 992 spin_unlock(&dasd_devmap_lock); 993 return sprintf(buf, "\n"); 994 } 995 uid = &devmap->uid; 996 switch (uid->type) { 997 case UA_BASE_DEVICE: 998 sprintf(ua_string, "%02x", uid->real_unit_addr); 999 break; 1000 case UA_BASE_PAV_ALIAS: 1001 sprintf(ua_string, "%02x", uid->base_unit_addr); 1002 break; 1003 case UA_HYPER_PAV_ALIAS: 1004 sprintf(ua_string, "xx"); 1005 break; 1006 default: 1007 /* should not happen, treat like base device */ 1008 sprintf(ua_string, "%02x", uid->real_unit_addr); 1009 break; 1010 } 1011 if (strlen(uid->vduit) > 0) 1012 snprintf(uid_string, sizeof(uid_string), 1013 "%s.%s.%04x.%s.%s", 1014 uid->vendor, uid->serial, 1015 uid->ssid, ua_string, 1016 uid->vduit); 1017 else 1018 snprintf(uid_string, sizeof(uid_string), 1019 "%s.%s.%04x.%s", 1020 uid->vendor, uid->serial, 1021 uid->ssid, ua_string); 1022 spin_unlock(&dasd_devmap_lock); 1023 return snprintf(buf, PAGE_SIZE, "%s\n", uid_string); 1024 } 1025 1026 static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL); 1027 1028 /* 1029 * extended error-reporting 1030 */ 1031 static ssize_t 1032 dasd_eer_show(struct device *dev, struct device_attribute *attr, char *buf) 1033 { 1034 struct dasd_devmap *devmap; 1035 int eer_flag; 1036 1037 devmap = dasd_find_busid(dev_name(dev)); 1038 if (!IS_ERR(devmap) && devmap->device) 1039 eer_flag = dasd_eer_enabled(devmap->device); 1040 else 1041 eer_flag = 0; 1042 return snprintf(buf, PAGE_SIZE, eer_flag ? "1\n" : "0\n"); 1043 } 1044 1045 static ssize_t 1046 dasd_eer_store(struct device *dev, struct device_attribute *attr, 1047 const char *buf, size_t count) 1048 { 1049 struct dasd_devmap *devmap; 1050 int val, rc; 1051 char *endp; 1052 1053 devmap = dasd_devmap_from_cdev(to_ccwdev(dev)); 1054 if (IS_ERR(devmap)) 1055 return PTR_ERR(devmap); 1056 if (!devmap->device) 1057 return -ENODEV; 1058 1059 val = simple_strtoul(buf, &endp, 0); 1060 if (((endp + 1) < (buf + count)) || (val > 1)) 1061 return -EINVAL; 1062 1063 if (val) { 1064 rc = dasd_eer_enable(devmap->device); 1065 if (rc) 1066 return rc; 1067 } else 1068 dasd_eer_disable(devmap->device); 1069 return count; 1070 } 1071 1072 static DEVICE_ATTR(eer_enabled, 0644, dasd_eer_show, dasd_eer_store); 1073 1074 static struct attribute * dasd_attrs[] = { 1075 &dev_attr_readonly.attr, 1076 &dev_attr_discipline.attr, 1077 &dev_attr_status.attr, 1078 &dev_attr_alias.attr, 1079 &dev_attr_vendor.attr, 1080 &dev_attr_uid.attr, 1081 &dev_attr_use_diag.attr, 1082 &dev_attr_eer_enabled.attr, 1083 &dev_attr_erplog.attr, 1084 &dev_attr_failfast.attr, 1085 NULL, 1086 }; 1087 1088 static struct attribute_group dasd_attr_group = { 1089 .attrs = dasd_attrs, 1090 }; 1091 1092 /* 1093 * Return copy of the device unique identifier. 1094 */ 1095 int 1096 dasd_get_uid(struct ccw_device *cdev, struct dasd_uid *uid) 1097 { 1098 struct dasd_devmap *devmap; 1099 1100 devmap = dasd_find_busid(dev_name(&cdev->dev)); 1101 if (IS_ERR(devmap)) 1102 return PTR_ERR(devmap); 1103 spin_lock(&dasd_devmap_lock); 1104 *uid = devmap->uid; 1105 spin_unlock(&dasd_devmap_lock); 1106 return 0; 1107 } 1108 EXPORT_SYMBOL_GPL(dasd_get_uid); 1109 1110 /* 1111 * Register the given device unique identifier into devmap struct. 1112 * In addition check if the related storage server subsystem ID is already 1113 * contained in the dasd_server_ssid_list. If subsystem ID is not contained, 1114 * create new entry. 1115 * Return 0 if server was already in serverlist, 1116 * 1 if the server was added successful 1117 * <0 in case of error. 1118 */ 1119 int 1120 dasd_set_uid(struct ccw_device *cdev, struct dasd_uid *uid) 1121 { 1122 struct dasd_devmap *devmap; 1123 1124 devmap = dasd_find_busid(dev_name(&cdev->dev)); 1125 if (IS_ERR(devmap)) 1126 return PTR_ERR(devmap); 1127 1128 spin_lock(&dasd_devmap_lock); 1129 devmap->uid = *uid; 1130 spin_unlock(&dasd_devmap_lock); 1131 1132 return 0; 1133 } 1134 EXPORT_SYMBOL_GPL(dasd_set_uid); 1135 1136 /* 1137 * Return value of the specified feature. 1138 */ 1139 int 1140 dasd_get_feature(struct ccw_device *cdev, int feature) 1141 { 1142 struct dasd_devmap *devmap; 1143 1144 devmap = dasd_find_busid(dev_name(&cdev->dev)); 1145 if (IS_ERR(devmap)) 1146 return PTR_ERR(devmap); 1147 1148 return ((devmap->features & feature) != 0); 1149 } 1150 1151 /* 1152 * Set / reset given feature. 1153 * Flag indicates wether to set (!=0) or the reset (=0) the feature. 1154 */ 1155 int 1156 dasd_set_feature(struct ccw_device *cdev, int feature, int flag) 1157 { 1158 struct dasd_devmap *devmap; 1159 1160 devmap = dasd_find_busid(dev_name(&cdev->dev)); 1161 if (IS_ERR(devmap)) 1162 return PTR_ERR(devmap); 1163 1164 spin_lock(&dasd_devmap_lock); 1165 if (flag) 1166 devmap->features |= feature; 1167 else 1168 devmap->features &= ~feature; 1169 if (devmap->device) 1170 devmap->device->features = devmap->features; 1171 spin_unlock(&dasd_devmap_lock); 1172 return 0; 1173 } 1174 1175 1176 int 1177 dasd_add_sysfs_files(struct ccw_device *cdev) 1178 { 1179 return sysfs_create_group(&cdev->dev.kobj, &dasd_attr_group); 1180 } 1181 1182 void 1183 dasd_remove_sysfs_files(struct ccw_device *cdev) 1184 { 1185 sysfs_remove_group(&cdev->dev.kobj, &dasd_attr_group); 1186 } 1187 1188 1189 int 1190 dasd_devmap_init(void) 1191 { 1192 int i; 1193 1194 /* Initialize devmap structures. */ 1195 dasd_max_devindex = 0; 1196 for (i = 0; i < 256; i++) 1197 INIT_LIST_HEAD(&dasd_hashlists[i]); 1198 return 0; 1199 } 1200 1201 void 1202 dasd_devmap_exit(void) 1203 { 1204 dasd_forget_ranges(); 1205 } 1206