1// SPDX-License-Identifier: GPL-2.0 2/* 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 * Copyright IBM Corp. 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#include <linux/slab.h> 22 23#include <asm/debug.h> 24#include <linux/uaccess.h> 25#include <asm/ipl.h> 26 27/* This is ugly... */ 28#define PRINTK_HEADER "dasd_devmap:" 29#define DASD_BUS_ID_SIZE 20 30#define DASD_MAX_PARAMS 256 31 32#include "dasd_int.h" 33 34struct kmem_cache *dasd_page_cache; 35EXPORT_SYMBOL_GPL(dasd_page_cache); 36 37/* 38 * dasd_devmap_t is used to store the features and the relation 39 * between device number and device index. To find a dasd_devmap_t 40 * that corresponds to a device number of a device index each 41 * dasd_devmap_t is added to two linked lists, one to search by 42 * the device number and one to search by the device index. As 43 * soon as big minor numbers are available the device index list 44 * can be removed since the device number will then be identical 45 * to the device index. 46 */ 47struct dasd_devmap { 48 struct list_head list; 49 char bus_id[DASD_BUS_ID_SIZE]; 50 unsigned int devindex; 51 unsigned short features; 52 struct dasd_device *device; 53}; 54 55/* 56 * Parameter parsing functions for dasd= parameter. The syntax is: 57 * <devno> : (0x)?[0-9a-fA-F]+ 58 * <busid> : [0-0a-f]\.[0-9a-f]\.(0x)?[0-9a-fA-F]+ 59 * <feature> : ro 60 * <feature_list> : \(<feature>(:<feature>)*\) 61 * <devno-range> : <devno>(-<devno>)?<feature_list>? 62 * <busid-range> : <busid>(-<busid>)?<feature_list>? 63 * <devices> : <devno-range>|<busid-range> 64 * <dasd_module> : dasd_diag_mod|dasd_eckd_mod|dasd_fba_mod 65 * 66 * <dasd> : autodetect|probeonly|<devices>(,<devices>)* 67 */ 68 69int dasd_probeonly = 0; /* is true, when probeonly mode is active */ 70int dasd_autodetect = 0; /* is true, when autodetection is active */ 71int dasd_nopav = 0; /* is true, when PAV is disabled */ 72EXPORT_SYMBOL_GPL(dasd_nopav); 73int dasd_nofcx; /* disable High Performance Ficon */ 74EXPORT_SYMBOL_GPL(dasd_nofcx); 75 76/* 77 * char *dasd[] is intended to hold the ranges supplied by the dasd= statement 78 * it is named 'dasd' to directly be filled by insmod with the comma separated 79 * strings when running as a module. 80 */ 81static char *dasd[DASD_MAX_PARAMS]; 82module_param_array(dasd, charp, NULL, S_IRUGO); 83 84/* 85 * Single spinlock to protect devmap and servermap structures and lists. 86 */ 87static DEFINE_SPINLOCK(dasd_devmap_lock); 88 89/* 90 * Hash lists for devmap structures. 91 */ 92static struct list_head dasd_hashlists[256]; 93int dasd_max_devindex; 94 95static struct dasd_devmap *dasd_add_busid(const char *, int); 96 97static inline int 98dasd_hash_busid(const char *bus_id) 99{ 100 int hash, i; 101 102 hash = 0; 103 for (i = 0; (i < DASD_BUS_ID_SIZE) && *bus_id; i++, bus_id++) 104 hash += *bus_id; 105 return hash & 0xff; 106} 107 108#ifndef MODULE 109static int __init dasd_call_setup(char *opt) 110{ 111 static int i __initdata; 112 char *tmp; 113 114 while (i < DASD_MAX_PARAMS) { 115 tmp = strsep(&opt, ","); 116 if (!tmp) 117 break; 118 119 dasd[i++] = tmp; 120 } 121 122 return 1; 123} 124 125__setup ("dasd=", dasd_call_setup); 126#endif /* #ifndef MODULE */ 127 128#define DASD_IPLDEV "ipldev" 129 130/* 131 * Read a device busid/devno from a string. 132 */ 133static int __init dasd_busid(char *str, int *id0, int *id1, int *devno) 134{ 135 unsigned int val; 136 char *tok; 137 138 /* Interpret ipldev busid */ 139 if (strncmp(DASD_IPLDEV, str, strlen(DASD_IPLDEV)) == 0) { 140 if (ipl_info.type != IPL_TYPE_CCW) { 141 pr_err("The IPL device is not a CCW device\n"); 142 return -EINVAL; 143 } 144 *id0 = 0; 145 *id1 = ipl_info.data.ccw.dev_id.ssid; 146 *devno = ipl_info.data.ccw.dev_id.devno; 147 148 return 0; 149 } 150 151 /* Old style 0xXXXX or XXXX */ 152 if (!kstrtouint(str, 16, &val)) { 153 *id0 = *id1 = 0; 154 if (val > 0xffff) 155 return -EINVAL; 156 *devno = val; 157 return 0; 158 } 159 160 /* New style x.y.z busid */ 161 tok = strsep(&str, "."); 162 if (kstrtouint(tok, 16, &val) || val > 0xff) 163 return -EINVAL; 164 *id0 = val; 165 166 tok = strsep(&str, "."); 167 if (kstrtouint(tok, 16, &val) || val > 0xff) 168 return -EINVAL; 169 *id1 = val; 170 171 tok = strsep(&str, "."); 172 if (kstrtouint(tok, 16, &val) || val > 0xffff) 173 return -EINVAL; 174 *devno = val; 175 176 return 0; 177} 178 179/* 180 * Read colon separated list of dasd features. 181 */ 182static int __init dasd_feature_list(char *str) 183{ 184 int features, len, rc; 185 186 features = 0; 187 rc = 0; 188 189 if (!str) 190 return DASD_FEATURE_DEFAULT; 191 192 while (1) { 193 for (len = 0; 194 str[len] && str[len] != ':' && str[len] != ')'; len++); 195 if (len == 2 && !strncmp(str, "ro", 2)) 196 features |= DASD_FEATURE_READONLY; 197 else if (len == 4 && !strncmp(str, "diag", 4)) 198 features |= DASD_FEATURE_USEDIAG; 199 else if (len == 3 && !strncmp(str, "raw", 3)) 200 features |= DASD_FEATURE_USERAW; 201 else if (len == 6 && !strncmp(str, "erplog", 6)) 202 features |= DASD_FEATURE_ERPLOG; 203 else if (len == 8 && !strncmp(str, "failfast", 8)) 204 features |= DASD_FEATURE_FAILFAST; 205 else { 206 pr_warn("%.*s is not a supported device option\n", 207 len, str); 208 rc = -EINVAL; 209 } 210 str += len; 211 if (*str != ':') 212 break; 213 str++; 214 } 215 216 return rc ? : features; 217} 218 219/* 220 * Try to match the first element on the comma separated parse string 221 * with one of the known keywords. If a keyword is found, take the approprate 222 * action and return a pointer to the residual string. If the first element 223 * could not be matched to any keyword then return an error code. 224 */ 225static int __init dasd_parse_keyword(char *keyword) 226{ 227 int length = strlen(keyword); 228 229 if (strncmp("autodetect", keyword, length) == 0) { 230 dasd_autodetect = 1; 231 pr_info("The autodetection mode has been activated\n"); 232 return 0; 233 } 234 if (strncmp("probeonly", keyword, length) == 0) { 235 dasd_probeonly = 1; 236 pr_info("The probeonly mode has been activated\n"); 237 return 0; 238 } 239 if (strncmp("nopav", keyword, length) == 0) { 240 if (MACHINE_IS_VM) 241 pr_info("'nopav' is not supported on z/VM\n"); 242 else { 243 dasd_nopav = 1; 244 pr_info("PAV support has be deactivated\n"); 245 } 246 return 0; 247 } 248 if (strncmp("nofcx", keyword, length) == 0) { 249 dasd_nofcx = 1; 250 pr_info("High Performance FICON support has been " 251 "deactivated\n"); 252 return 0; 253 } 254 if (strncmp("fixedbuffers", keyword, length) == 0) { 255 if (dasd_page_cache) 256 return 0; 257 dasd_page_cache = 258 kmem_cache_create("dasd_page_cache", PAGE_SIZE, 259 PAGE_SIZE, SLAB_CACHE_DMA, 260 NULL); 261 if (!dasd_page_cache) 262 DBF_EVENT(DBF_WARNING, "%s", "Failed to create slab, " 263 "fixed buffer mode disabled."); 264 else 265 DBF_EVENT(DBF_INFO, "%s", 266 "turning on fixed buffer mode"); 267 return 0; 268 } 269 270 return -EINVAL; 271} 272 273/* 274 * Split a string of a device range into its pieces and return the from, to, and 275 * feature parts separately. 276 * e.g.: 277 * 0.0.1234-0.0.5678(ro:erplog) -> from: 0.0.1234 to: 0.0.5678 features: ro:erplog 278 * 0.0.8765(raw) -> from: 0.0.8765 to: null features: raw 279 * 0x4321 -> from: 0x4321 to: null features: null 280 */ 281static int __init dasd_evaluate_range_param(char *range, char **from_str, 282 char **to_str, char **features_str) 283{ 284 int rc = 0; 285 286 /* Do we have a range or a single device? */ 287 if (strchr(range, '-')) { 288 *from_str = strsep(&range, "-"); 289 *to_str = strsep(&range, "("); 290 *features_str = strsep(&range, ")"); 291 } else { 292 *from_str = strsep(&range, "("); 293 *features_str = strsep(&range, ")"); 294 } 295 296 if (*features_str && !range) { 297 pr_warn("A closing parenthesis ')' is missing in the dasd= parameter\n"); 298 rc = -EINVAL; 299 } 300 301 return rc; 302} 303 304/* 305 * Try to interprete the range string as a device number or a range of devices. 306 * If the interpretation is successful, create the matching dasd_devmap entries. 307 * If interpretation fails or in case of an error, return an error code. 308 */ 309static int __init dasd_parse_range(const char *range) 310{ 311 struct dasd_devmap *devmap; 312 int from, from_id0, from_id1; 313 int to, to_id0, to_id1; 314 int features; 315 char bus_id[DASD_BUS_ID_SIZE + 1]; 316 char *features_str = NULL; 317 char *from_str = NULL; 318 char *to_str = NULL; 319 int rc = 0; 320 char *tmp; 321 322 tmp = kstrdup(range, GFP_KERNEL); 323 if (!tmp) 324 return -ENOMEM; 325 326 if (dasd_evaluate_range_param(tmp, &from_str, &to_str, &features_str)) { 327 rc = -EINVAL; 328 goto out; 329 } 330 331 if (dasd_busid(from_str, &from_id0, &from_id1, &from)) { 332 rc = -EINVAL; 333 goto out; 334 } 335 336 to = from; 337 to_id0 = from_id0; 338 to_id1 = from_id1; 339 if (to_str) { 340 if (dasd_busid(to_str, &to_id0, &to_id1, &to)) { 341 rc = -EINVAL; 342 goto out; 343 } 344 if (from_id0 != to_id0 || from_id1 != to_id1 || from > to) { 345 pr_err("%s is not a valid device range\n", range); 346 rc = -EINVAL; 347 goto out; 348 } 349 } 350 351 features = dasd_feature_list(features_str); 352 if (features < 0) { 353 rc = -EINVAL; 354 goto out; 355 } 356 /* each device in dasd= parameter should be set initially online */ 357 features |= DASD_FEATURE_INITIAL_ONLINE; 358 while (from <= to) { 359 sprintf(bus_id, "%01x.%01x.%04x", from_id0, from_id1, from++); 360 devmap = dasd_add_busid(bus_id, features); 361 if (IS_ERR(devmap)) { 362 rc = PTR_ERR(devmap); 363 goto out; 364 } 365 } 366 367out: 368 kfree(tmp); 369 370 return rc; 371} 372 373/* 374 * Parse parameters stored in dasd[] 375 * The 'dasd=...' parameter allows to specify a comma separated list of 376 * keywords and device ranges. The parameters in that list will be stored as 377 * separate elementes in dasd[]. 378 */ 379int __init dasd_parse(void) 380{ 381 int rc, i; 382 char *cur; 383 384 rc = 0; 385 for (i = 0; i < DASD_MAX_PARAMS; i++) { 386 cur = dasd[i]; 387 if (!cur) 388 break; 389 if (*cur == '\0') 390 continue; 391 392 rc = dasd_parse_keyword(cur); 393 if (rc) 394 rc = dasd_parse_range(cur); 395 396 if (rc) 397 break; 398 } 399 400 return rc; 401} 402 403/* 404 * Add a devmap for the device specified by busid. It is possible that 405 * the devmap already exists (dasd= parameter). The order of the devices 406 * added through this function will define the kdevs for the individual 407 * devices. 408 */ 409static struct dasd_devmap * 410dasd_add_busid(const char *bus_id, int features) 411{ 412 struct dasd_devmap *devmap, *new, *tmp; 413 int hash; 414 415 new = kzalloc(sizeof(struct dasd_devmap), GFP_KERNEL); 416 if (!new) 417 return ERR_PTR(-ENOMEM); 418 spin_lock(&dasd_devmap_lock); 419 devmap = NULL; 420 hash = dasd_hash_busid(bus_id); 421 list_for_each_entry(tmp, &dasd_hashlists[hash], list) 422 if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) { 423 devmap = tmp; 424 break; 425 } 426 if (!devmap) { 427 /* This bus_id is new. */ 428 new->devindex = dasd_max_devindex++; 429 strlcpy(new->bus_id, bus_id, DASD_BUS_ID_SIZE); 430 new->features = features; 431 new->device = NULL; 432 list_add(&new->list, &dasd_hashlists[hash]); 433 devmap = new; 434 new = NULL; 435 } 436 spin_unlock(&dasd_devmap_lock); 437 kfree(new); 438 return devmap; 439} 440 441/* 442 * Find devmap for device with given bus_id. 443 */ 444static struct dasd_devmap * 445dasd_find_busid(const char *bus_id) 446{ 447 struct dasd_devmap *devmap, *tmp; 448 int hash; 449 450 spin_lock(&dasd_devmap_lock); 451 devmap = ERR_PTR(-ENODEV); 452 hash = dasd_hash_busid(bus_id); 453 list_for_each_entry(tmp, &dasd_hashlists[hash], list) { 454 if (strncmp(tmp->bus_id, bus_id, DASD_BUS_ID_SIZE) == 0) { 455 devmap = tmp; 456 break; 457 } 458 } 459 spin_unlock(&dasd_devmap_lock); 460 return devmap; 461} 462 463/* 464 * Check if busid has been added to the list of dasd ranges. 465 */ 466int 467dasd_busid_known(const char *bus_id) 468{ 469 return IS_ERR(dasd_find_busid(bus_id)) ? -ENOENT : 0; 470} 471 472/* 473 * Forget all about the device numbers added so far. 474 * This may only be called at module unload or system shutdown. 475 */ 476static void 477dasd_forget_ranges(void) 478{ 479 struct dasd_devmap *devmap, *n; 480 int i; 481 482 spin_lock(&dasd_devmap_lock); 483 for (i = 0; i < 256; i++) { 484 list_for_each_entry_safe(devmap, n, &dasd_hashlists[i], list) { 485 BUG_ON(devmap->device != NULL); 486 list_del(&devmap->list); 487 kfree(devmap); 488 } 489 } 490 spin_unlock(&dasd_devmap_lock); 491} 492 493/* 494 * Find the device struct by its device index. 495 */ 496struct dasd_device * 497dasd_device_from_devindex(int devindex) 498{ 499 struct dasd_devmap *devmap, *tmp; 500 struct dasd_device *device; 501 int i; 502 503 spin_lock(&dasd_devmap_lock); 504 devmap = NULL; 505 for (i = 0; (i < 256) && !devmap; i++) 506 list_for_each_entry(tmp, &dasd_hashlists[i], list) 507 if (tmp->devindex == devindex) { 508 /* Found the devmap for the device. */ 509 devmap = tmp; 510 break; 511 } 512 if (devmap && devmap->device) { 513 device = devmap->device; 514 dasd_get_device(device); 515 } else 516 device = ERR_PTR(-ENODEV); 517 spin_unlock(&dasd_devmap_lock); 518 return device; 519} 520 521/* 522 * Return devmap for cdev. If no devmap exists yet, create one and 523 * connect it to the cdev. 524 */ 525static struct dasd_devmap * 526dasd_devmap_from_cdev(struct ccw_device *cdev) 527{ 528 struct dasd_devmap *devmap; 529 530 devmap = dasd_find_busid(dev_name(&cdev->dev)); 531 if (IS_ERR(devmap)) 532 devmap = dasd_add_busid(dev_name(&cdev->dev), 533 DASD_FEATURE_DEFAULT); 534 return devmap; 535} 536 537/* 538 * Create a dasd device structure for cdev. 539 */ 540struct dasd_device * 541dasd_create_device(struct ccw_device *cdev) 542{ 543 struct dasd_devmap *devmap; 544 struct dasd_device *device; 545 unsigned long flags; 546 int rc; 547 548 devmap = dasd_devmap_from_cdev(cdev); 549 if (IS_ERR(devmap)) 550 return (void *) devmap; 551 552 device = dasd_alloc_device(); 553 if (IS_ERR(device)) 554 return device; 555 atomic_set(&device->ref_count, 3); 556 557 spin_lock(&dasd_devmap_lock); 558 if (!devmap->device) { 559 devmap->device = device; 560 device->devindex = devmap->devindex; 561 device->features = devmap->features; 562 get_device(&cdev->dev); 563 device->cdev = cdev; 564 rc = 0; 565 } else 566 /* Someone else was faster. */ 567 rc = -EBUSY; 568 spin_unlock(&dasd_devmap_lock); 569 570 if (rc) { 571 dasd_free_device(device); 572 return ERR_PTR(rc); 573 } 574 575 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 576 dev_set_drvdata(&cdev->dev, device); 577 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 578 579 return device; 580} 581 582/* 583 * Wait queue for dasd_delete_device waits. 584 */ 585static DECLARE_WAIT_QUEUE_HEAD(dasd_delete_wq); 586 587/* 588 * Remove a dasd device structure. The passed referenced 589 * is destroyed. 590 */ 591void 592dasd_delete_device(struct dasd_device *device) 593{ 594 struct ccw_device *cdev; 595 struct dasd_devmap *devmap; 596 unsigned long flags; 597 598 /* First remove device pointer from devmap. */ 599 devmap = dasd_find_busid(dev_name(&device->cdev->dev)); 600 BUG_ON(IS_ERR(devmap)); 601 spin_lock(&dasd_devmap_lock); 602 if (devmap->device != device) { 603 spin_unlock(&dasd_devmap_lock); 604 dasd_put_device(device); 605 return; 606 } 607 devmap->device = NULL; 608 spin_unlock(&dasd_devmap_lock); 609 610 /* Disconnect dasd_device structure from ccw_device structure. */ 611 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 612 dev_set_drvdata(&device->cdev->dev, NULL); 613 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 614 615 /* 616 * Drop ref_count by 3, one for the devmap reference, one for 617 * the cdev reference and one for the passed reference. 618 */ 619 atomic_sub(3, &device->ref_count); 620 621 /* Wait for reference counter to drop to zero. */ 622 wait_event(dasd_delete_wq, atomic_read(&device->ref_count) == 0); 623 624 dasd_generic_free_discipline(device); 625 /* Disconnect dasd_device structure from ccw_device structure. */ 626 cdev = device->cdev; 627 device->cdev = NULL; 628 629 /* Put ccw_device structure. */ 630 put_device(&cdev->dev); 631 632 /* Now the device structure can be freed. */ 633 dasd_free_device(device); 634} 635 636/* 637 * Reference counter dropped to zero. Wake up waiter 638 * in dasd_delete_device. 639 */ 640void 641dasd_put_device_wake(struct dasd_device *device) 642{ 643 wake_up(&dasd_delete_wq); 644} 645EXPORT_SYMBOL_GPL(dasd_put_device_wake); 646 647/* 648 * Return dasd_device structure associated with cdev. 649 * This function needs to be called with the ccw device 650 * lock held. It can be used from interrupt context. 651 */ 652struct dasd_device * 653dasd_device_from_cdev_locked(struct ccw_device *cdev) 654{ 655 struct dasd_device *device = dev_get_drvdata(&cdev->dev); 656 657 if (!device) 658 return ERR_PTR(-ENODEV); 659 dasd_get_device(device); 660 return device; 661} 662 663/* 664 * Return dasd_device structure associated with cdev. 665 */ 666struct dasd_device * 667dasd_device_from_cdev(struct ccw_device *cdev) 668{ 669 struct dasd_device *device; 670 unsigned long flags; 671 672 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 673 device = dasd_device_from_cdev_locked(cdev); 674 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 675 return device; 676} 677 678void dasd_add_link_to_gendisk(struct gendisk *gdp, struct dasd_device *device) 679{ 680 struct dasd_devmap *devmap; 681 682 devmap = dasd_find_busid(dev_name(&device->cdev->dev)); 683 if (IS_ERR(devmap)) 684 return; 685 spin_lock(&dasd_devmap_lock); 686 gdp->private_data = devmap; 687 spin_unlock(&dasd_devmap_lock); 688} 689 690struct dasd_device *dasd_device_from_gendisk(struct gendisk *gdp) 691{ 692 struct dasd_device *device; 693 struct dasd_devmap *devmap; 694 695 if (!gdp->private_data) 696 return NULL; 697 device = NULL; 698 spin_lock(&dasd_devmap_lock); 699 devmap = gdp->private_data; 700 if (devmap && devmap->device) { 701 device = devmap->device; 702 dasd_get_device(device); 703 } 704 spin_unlock(&dasd_devmap_lock); 705 return device; 706} 707 708/* 709 * SECTION: files in sysfs 710 */ 711 712/* 713 * failfast controls the behaviour, if no path is available 714 */ 715static ssize_t dasd_ff_show(struct device *dev, struct device_attribute *attr, 716 char *buf) 717{ 718 struct dasd_devmap *devmap; 719 int ff_flag; 720 721 devmap = dasd_find_busid(dev_name(dev)); 722 if (!IS_ERR(devmap)) 723 ff_flag = (devmap->features & DASD_FEATURE_FAILFAST) != 0; 724 else 725 ff_flag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_FAILFAST) != 0; 726 return snprintf(buf, PAGE_SIZE, ff_flag ? "1\n" : "0\n"); 727} 728 729static ssize_t dasd_ff_store(struct device *dev, struct device_attribute *attr, 730 const char *buf, size_t count) 731{ 732 unsigned int val; 733 int rc; 734 735 if (kstrtouint(buf, 0, &val) || val > 1) 736 return -EINVAL; 737 738 rc = dasd_set_feature(to_ccwdev(dev), DASD_FEATURE_FAILFAST, val); 739 740 return rc ? : count; 741} 742 743static DEVICE_ATTR(failfast, 0644, dasd_ff_show, dasd_ff_store); 744 745/* 746 * readonly controls the readonly status of a dasd 747 */ 748static ssize_t 749dasd_ro_show(struct device *dev, struct device_attribute *attr, char *buf) 750{ 751 struct dasd_devmap *devmap; 752 struct dasd_device *device; 753 int ro_flag = 0; 754 755 devmap = dasd_find_busid(dev_name(dev)); 756 if (IS_ERR(devmap)) 757 goto out; 758 759 ro_flag = !!(devmap->features & DASD_FEATURE_READONLY); 760 761 spin_lock(&dasd_devmap_lock); 762 device = devmap->device; 763 if (device) 764 ro_flag |= test_bit(DASD_FLAG_DEVICE_RO, &device->flags); 765 spin_unlock(&dasd_devmap_lock); 766 767out: 768 return snprintf(buf, PAGE_SIZE, ro_flag ? "1\n" : "0\n"); 769} 770 771static ssize_t 772dasd_ro_store(struct device *dev, struct device_attribute *attr, 773 const char *buf, size_t count) 774{ 775 struct ccw_device *cdev = to_ccwdev(dev); 776 struct dasd_device *device; 777 unsigned long flags; 778 unsigned int val; 779 int rc; 780 781 if (kstrtouint(buf, 0, &val) || val > 1) 782 return -EINVAL; 783 784 rc = dasd_set_feature(cdev, DASD_FEATURE_READONLY, val); 785 if (rc) 786 return rc; 787 788 device = dasd_device_from_cdev(cdev); 789 if (IS_ERR(device)) 790 return count; 791 792 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 793 val = val || test_bit(DASD_FLAG_DEVICE_RO, &device->flags); 794 795 if (!device->block || !device->block->gdp || 796 test_bit(DASD_FLAG_OFFLINE, &device->flags)) { 797 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 798 goto out; 799 } 800 /* Increase open_count to avoid losing the block device */ 801 atomic_inc(&device->block->open_count); 802 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 803 804 set_disk_ro(device->block->gdp, val); 805 atomic_dec(&device->block->open_count); 806 807out: 808 dasd_put_device(device); 809 810 return count; 811} 812 813static DEVICE_ATTR(readonly, 0644, dasd_ro_show, dasd_ro_store); 814/* 815 * erplog controls the logging of ERP related data 816 * (e.g. failing channel programs). 817 */ 818static ssize_t 819dasd_erplog_show(struct device *dev, struct device_attribute *attr, char *buf) 820{ 821 struct dasd_devmap *devmap; 822 int erplog; 823 824 devmap = dasd_find_busid(dev_name(dev)); 825 if (!IS_ERR(devmap)) 826 erplog = (devmap->features & DASD_FEATURE_ERPLOG) != 0; 827 else 828 erplog = (DASD_FEATURE_DEFAULT & DASD_FEATURE_ERPLOG) != 0; 829 return snprintf(buf, PAGE_SIZE, erplog ? "1\n" : "0\n"); 830} 831 832static ssize_t 833dasd_erplog_store(struct device *dev, struct device_attribute *attr, 834 const char *buf, size_t count) 835{ 836 unsigned int val; 837 int rc; 838 839 if (kstrtouint(buf, 0, &val) || val > 1) 840 return -EINVAL; 841 842 rc = dasd_set_feature(to_ccwdev(dev), DASD_FEATURE_ERPLOG, val); 843 844 return rc ? : count; 845} 846 847static DEVICE_ATTR(erplog, 0644, dasd_erplog_show, dasd_erplog_store); 848 849/* 850 * use_diag controls whether the driver should use diag rather than ssch 851 * to talk to the device 852 */ 853static ssize_t 854dasd_use_diag_show(struct device *dev, struct device_attribute *attr, char *buf) 855{ 856 struct dasd_devmap *devmap; 857 int use_diag; 858 859 devmap = dasd_find_busid(dev_name(dev)); 860 if (!IS_ERR(devmap)) 861 use_diag = (devmap->features & DASD_FEATURE_USEDIAG) != 0; 862 else 863 use_diag = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USEDIAG) != 0; 864 return sprintf(buf, use_diag ? "1\n" : "0\n"); 865} 866 867static ssize_t 868dasd_use_diag_store(struct device *dev, struct device_attribute *attr, 869 const char *buf, size_t count) 870{ 871 struct dasd_devmap *devmap; 872 unsigned int val; 873 ssize_t rc; 874 875 devmap = dasd_devmap_from_cdev(to_ccwdev(dev)); 876 if (IS_ERR(devmap)) 877 return PTR_ERR(devmap); 878 879 if (kstrtouint(buf, 0, &val) || val > 1) 880 return -EINVAL; 881 882 spin_lock(&dasd_devmap_lock); 883 /* Changing diag discipline flag is only allowed in offline state. */ 884 rc = count; 885 if (!devmap->device && !(devmap->features & DASD_FEATURE_USERAW)) { 886 if (val) 887 devmap->features |= DASD_FEATURE_USEDIAG; 888 else 889 devmap->features &= ~DASD_FEATURE_USEDIAG; 890 } else 891 rc = -EPERM; 892 spin_unlock(&dasd_devmap_lock); 893 return rc; 894} 895 896static DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store); 897 898/* 899 * use_raw controls whether the driver should give access to raw eckd data or 900 * operate in standard mode 901 */ 902static ssize_t 903dasd_use_raw_show(struct device *dev, struct device_attribute *attr, char *buf) 904{ 905 struct dasd_devmap *devmap; 906 int use_raw; 907 908 devmap = dasd_find_busid(dev_name(dev)); 909 if (!IS_ERR(devmap)) 910 use_raw = (devmap->features & DASD_FEATURE_USERAW) != 0; 911 else 912 use_raw = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USERAW) != 0; 913 return sprintf(buf, use_raw ? "1\n" : "0\n"); 914} 915 916static ssize_t 917dasd_use_raw_store(struct device *dev, struct device_attribute *attr, 918 const char *buf, size_t count) 919{ 920 struct dasd_devmap *devmap; 921 ssize_t rc; 922 unsigned long val; 923 924 devmap = dasd_devmap_from_cdev(to_ccwdev(dev)); 925 if (IS_ERR(devmap)) 926 return PTR_ERR(devmap); 927 928 if ((kstrtoul(buf, 10, &val) != 0) || val > 1) 929 return -EINVAL; 930 931 spin_lock(&dasd_devmap_lock); 932 /* Changing diag discipline flag is only allowed in offline state. */ 933 rc = count; 934 if (!devmap->device && !(devmap->features & DASD_FEATURE_USEDIAG)) { 935 if (val) 936 devmap->features |= DASD_FEATURE_USERAW; 937 else 938 devmap->features &= ~DASD_FEATURE_USERAW; 939 } else 940 rc = -EPERM; 941 spin_unlock(&dasd_devmap_lock); 942 return rc; 943} 944 945static DEVICE_ATTR(raw_track_access, 0644, dasd_use_raw_show, 946 dasd_use_raw_store); 947 948static ssize_t 949dasd_safe_offline_store(struct device *dev, struct device_attribute *attr, 950 const char *buf, size_t count) 951{ 952 struct ccw_device *cdev = to_ccwdev(dev); 953 struct dasd_device *device; 954 unsigned long flags; 955 int rc; 956 957 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 958 device = dasd_device_from_cdev_locked(cdev); 959 if (IS_ERR(device)) { 960 rc = PTR_ERR(device); 961 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 962 goto out; 963 } 964 965 if (test_bit(DASD_FLAG_OFFLINE, &device->flags) || 966 test_bit(DASD_FLAG_SAFE_OFFLINE_RUNNING, &device->flags)) { 967 /* Already doing offline processing */ 968 dasd_put_device(device); 969 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 970 rc = -EBUSY; 971 goto out; 972 } 973 974 set_bit(DASD_FLAG_SAFE_OFFLINE, &device->flags); 975 dasd_put_device(device); 976 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 977 978 rc = ccw_device_set_offline(cdev); 979 980out: 981 return rc ? rc : count; 982} 983 984static DEVICE_ATTR(safe_offline, 0200, NULL, dasd_safe_offline_store); 985 986static ssize_t 987dasd_access_show(struct device *dev, struct device_attribute *attr, 988 char *buf) 989{ 990 struct ccw_device *cdev = to_ccwdev(dev); 991 struct dasd_device *device; 992 int count; 993 994 device = dasd_device_from_cdev(cdev); 995 if (IS_ERR(device)) 996 return PTR_ERR(device); 997 998 if (!device->discipline) 999 count = -ENODEV; 1000 else if (!device->discipline->host_access_count) 1001 count = -EOPNOTSUPP; 1002 else 1003 count = device->discipline->host_access_count(device); 1004 1005 dasd_put_device(device); 1006 if (count < 0) 1007 return count; 1008 1009 return sprintf(buf, "%d\n", count); 1010} 1011 1012static DEVICE_ATTR(host_access_count, 0444, dasd_access_show, NULL); 1013 1014static ssize_t 1015dasd_discipline_show(struct device *dev, struct device_attribute *attr, 1016 char *buf) 1017{ 1018 struct dasd_device *device; 1019 ssize_t len; 1020 1021 device = dasd_device_from_cdev(to_ccwdev(dev)); 1022 if (IS_ERR(device)) 1023 goto out; 1024 else if (!device->discipline) { 1025 dasd_put_device(device); 1026 goto out; 1027 } else { 1028 len = snprintf(buf, PAGE_SIZE, "%s\n", 1029 device->discipline->name); 1030 dasd_put_device(device); 1031 return len; 1032 } 1033out: 1034 len = snprintf(buf, PAGE_SIZE, "none\n"); 1035 return len; 1036} 1037 1038static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL); 1039 1040static ssize_t 1041dasd_device_status_show(struct device *dev, struct device_attribute *attr, 1042 char *buf) 1043{ 1044 struct dasd_device *device; 1045 ssize_t len; 1046 1047 device = dasd_device_from_cdev(to_ccwdev(dev)); 1048 if (!IS_ERR(device)) { 1049 switch (device->state) { 1050 case DASD_STATE_NEW: 1051 len = snprintf(buf, PAGE_SIZE, "new\n"); 1052 break; 1053 case DASD_STATE_KNOWN: 1054 len = snprintf(buf, PAGE_SIZE, "detected\n"); 1055 break; 1056 case DASD_STATE_BASIC: 1057 len = snprintf(buf, PAGE_SIZE, "basic\n"); 1058 break; 1059 case DASD_STATE_UNFMT: 1060 len = snprintf(buf, PAGE_SIZE, "unformatted\n"); 1061 break; 1062 case DASD_STATE_READY: 1063 len = snprintf(buf, PAGE_SIZE, "ready\n"); 1064 break; 1065 case DASD_STATE_ONLINE: 1066 len = snprintf(buf, PAGE_SIZE, "online\n"); 1067 break; 1068 default: 1069 len = snprintf(buf, PAGE_SIZE, "no stat\n"); 1070 break; 1071 } 1072 dasd_put_device(device); 1073 } else 1074 len = snprintf(buf, PAGE_SIZE, "unknown\n"); 1075 return len; 1076} 1077 1078static DEVICE_ATTR(status, 0444, dasd_device_status_show, NULL); 1079 1080static ssize_t dasd_alias_show(struct device *dev, 1081 struct device_attribute *attr, char *buf) 1082{ 1083 struct dasd_device *device; 1084 struct dasd_uid uid; 1085 1086 device = dasd_device_from_cdev(to_ccwdev(dev)); 1087 if (IS_ERR(device)) 1088 return sprintf(buf, "0\n"); 1089 1090 if (device->discipline && device->discipline->get_uid && 1091 !device->discipline->get_uid(device, &uid)) { 1092 if (uid.type == UA_BASE_PAV_ALIAS || 1093 uid.type == UA_HYPER_PAV_ALIAS) { 1094 dasd_put_device(device); 1095 return sprintf(buf, "1\n"); 1096 } 1097 } 1098 dasd_put_device(device); 1099 1100 return sprintf(buf, "0\n"); 1101} 1102 1103static DEVICE_ATTR(alias, 0444, dasd_alias_show, NULL); 1104 1105static ssize_t dasd_vendor_show(struct device *dev, 1106 struct device_attribute *attr, char *buf) 1107{ 1108 struct dasd_device *device; 1109 struct dasd_uid uid; 1110 char *vendor; 1111 1112 device = dasd_device_from_cdev(to_ccwdev(dev)); 1113 vendor = ""; 1114 if (IS_ERR(device)) 1115 return snprintf(buf, PAGE_SIZE, "%s\n", vendor); 1116 1117 if (device->discipline && device->discipline->get_uid && 1118 !device->discipline->get_uid(device, &uid)) 1119 vendor = uid.vendor; 1120 1121 dasd_put_device(device); 1122 1123 return snprintf(buf, PAGE_SIZE, "%s\n", vendor); 1124} 1125 1126static DEVICE_ATTR(vendor, 0444, dasd_vendor_show, NULL); 1127 1128#define UID_STRLEN ( /* vendor */ 3 + 1 + /* serial */ 14 + 1 +\ 1129 /* SSID */ 4 + 1 + /* unit addr */ 2 + 1 +\ 1130 /* vduit */ 32 + 1) 1131 1132static ssize_t 1133dasd_uid_show(struct device *dev, struct device_attribute *attr, char *buf) 1134{ 1135 struct dasd_device *device; 1136 struct dasd_uid uid; 1137 char uid_string[UID_STRLEN]; 1138 char ua_string[3]; 1139 1140 device = dasd_device_from_cdev(to_ccwdev(dev)); 1141 uid_string[0] = 0; 1142 if (IS_ERR(device)) 1143 return snprintf(buf, PAGE_SIZE, "%s\n", uid_string); 1144 1145 if (device->discipline && device->discipline->get_uid && 1146 !device->discipline->get_uid(device, &uid)) { 1147 switch (uid.type) { 1148 case UA_BASE_DEVICE: 1149 snprintf(ua_string, sizeof(ua_string), "%02x", 1150 uid.real_unit_addr); 1151 break; 1152 case UA_BASE_PAV_ALIAS: 1153 snprintf(ua_string, sizeof(ua_string), "%02x", 1154 uid.base_unit_addr); 1155 break; 1156 case UA_HYPER_PAV_ALIAS: 1157 snprintf(ua_string, sizeof(ua_string), "xx"); 1158 break; 1159 default: 1160 /* should not happen, treat like base device */ 1161 snprintf(ua_string, sizeof(ua_string), "%02x", 1162 uid.real_unit_addr); 1163 break; 1164 } 1165 1166 if (strlen(uid.vduit) > 0) 1167 snprintf(uid_string, sizeof(uid_string), 1168 "%s.%s.%04x.%s.%s", 1169 uid.vendor, uid.serial, uid.ssid, ua_string, 1170 uid.vduit); 1171 else 1172 snprintf(uid_string, sizeof(uid_string), 1173 "%s.%s.%04x.%s", 1174 uid.vendor, uid.serial, uid.ssid, ua_string); 1175 } 1176 dasd_put_device(device); 1177 1178 return snprintf(buf, PAGE_SIZE, "%s\n", uid_string); 1179} 1180static DEVICE_ATTR(uid, 0444, dasd_uid_show, NULL); 1181 1182/* 1183 * extended error-reporting 1184 */ 1185static ssize_t 1186dasd_eer_show(struct device *dev, struct device_attribute *attr, char *buf) 1187{ 1188 struct dasd_devmap *devmap; 1189 int eer_flag; 1190 1191 devmap = dasd_find_busid(dev_name(dev)); 1192 if (!IS_ERR(devmap) && devmap->device) 1193 eer_flag = dasd_eer_enabled(devmap->device); 1194 else 1195 eer_flag = 0; 1196 return snprintf(buf, PAGE_SIZE, eer_flag ? "1\n" : "0\n"); 1197} 1198 1199static ssize_t 1200dasd_eer_store(struct device *dev, struct device_attribute *attr, 1201 const char *buf, size_t count) 1202{ 1203 struct dasd_device *device; 1204 unsigned int val; 1205 int rc = 0; 1206 1207 device = dasd_device_from_cdev(to_ccwdev(dev)); 1208 if (IS_ERR(device)) 1209 return PTR_ERR(device); 1210 1211 if (kstrtouint(buf, 0, &val) || val > 1) 1212 return -EINVAL; 1213 1214 if (val) 1215 rc = dasd_eer_enable(device); 1216 else 1217 dasd_eer_disable(device); 1218 1219 dasd_put_device(device); 1220 1221 return rc ? : count; 1222} 1223 1224static DEVICE_ATTR(eer_enabled, 0644, dasd_eer_show, dasd_eer_store); 1225 1226/* 1227 * expiration time for default requests 1228 */ 1229static ssize_t 1230dasd_expires_show(struct device *dev, struct device_attribute *attr, char *buf) 1231{ 1232 struct dasd_device *device; 1233 int len; 1234 1235 device = dasd_device_from_cdev(to_ccwdev(dev)); 1236 if (IS_ERR(device)) 1237 return -ENODEV; 1238 len = snprintf(buf, PAGE_SIZE, "%lu\n", device->default_expires); 1239 dasd_put_device(device); 1240 return len; 1241} 1242 1243static ssize_t 1244dasd_expires_store(struct device *dev, struct device_attribute *attr, 1245 const char *buf, size_t count) 1246{ 1247 struct dasd_device *device; 1248 unsigned long val; 1249 1250 device = dasd_device_from_cdev(to_ccwdev(dev)); 1251 if (IS_ERR(device)) 1252 return -ENODEV; 1253 1254 if ((kstrtoul(buf, 10, &val) != 0) || 1255 (val > DASD_EXPIRES_MAX) || val == 0) { 1256 dasd_put_device(device); 1257 return -EINVAL; 1258 } 1259 1260 if (val) 1261 device->default_expires = val; 1262 1263 dasd_put_device(device); 1264 return count; 1265} 1266 1267static DEVICE_ATTR(expires, 0644, dasd_expires_show, dasd_expires_store); 1268 1269static ssize_t 1270dasd_retries_show(struct device *dev, struct device_attribute *attr, char *buf) 1271{ 1272 struct dasd_device *device; 1273 int len; 1274 1275 device = dasd_device_from_cdev(to_ccwdev(dev)); 1276 if (IS_ERR(device)) 1277 return -ENODEV; 1278 len = snprintf(buf, PAGE_SIZE, "%lu\n", device->default_retries); 1279 dasd_put_device(device); 1280 return len; 1281} 1282 1283static ssize_t 1284dasd_retries_store(struct device *dev, struct device_attribute *attr, 1285 const char *buf, size_t count) 1286{ 1287 struct dasd_device *device; 1288 unsigned long val; 1289 1290 device = dasd_device_from_cdev(to_ccwdev(dev)); 1291 if (IS_ERR(device)) 1292 return -ENODEV; 1293 1294 if ((kstrtoul(buf, 10, &val) != 0) || 1295 (val > DASD_RETRIES_MAX)) { 1296 dasd_put_device(device); 1297 return -EINVAL; 1298 } 1299 1300 if (val) 1301 device->default_retries = val; 1302 1303 dasd_put_device(device); 1304 return count; 1305} 1306 1307static DEVICE_ATTR(retries, 0644, dasd_retries_show, dasd_retries_store); 1308 1309static ssize_t 1310dasd_timeout_show(struct device *dev, struct device_attribute *attr, 1311 char *buf) 1312{ 1313 struct dasd_device *device; 1314 int len; 1315 1316 device = dasd_device_from_cdev(to_ccwdev(dev)); 1317 if (IS_ERR(device)) 1318 return -ENODEV; 1319 len = snprintf(buf, PAGE_SIZE, "%lu\n", device->blk_timeout); 1320 dasd_put_device(device); 1321 return len; 1322} 1323 1324static ssize_t 1325dasd_timeout_store(struct device *dev, struct device_attribute *attr, 1326 const char *buf, size_t count) 1327{ 1328 struct dasd_device *device; 1329 struct request_queue *q; 1330 unsigned long val; 1331 1332 device = dasd_device_from_cdev(to_ccwdev(dev)); 1333 if (IS_ERR(device) || !device->block) 1334 return -ENODEV; 1335 1336 if ((kstrtoul(buf, 10, &val) != 0) || 1337 val > UINT_MAX / HZ) { 1338 dasd_put_device(device); 1339 return -EINVAL; 1340 } 1341 q = device->block->request_queue; 1342 if (!q) { 1343 dasd_put_device(device); 1344 return -ENODEV; 1345 } 1346 1347 device->blk_timeout = val; 1348 1349 blk_queue_rq_timeout(q, device->blk_timeout * HZ); 1350 1351 dasd_put_device(device); 1352 return count; 1353} 1354 1355static DEVICE_ATTR(timeout, 0644, 1356 dasd_timeout_show, dasd_timeout_store); 1357 1358 1359static ssize_t 1360dasd_path_reset_store(struct device *dev, struct device_attribute *attr, 1361 const char *buf, size_t count) 1362{ 1363 struct dasd_device *device; 1364 unsigned int val; 1365 1366 device = dasd_device_from_cdev(to_ccwdev(dev)); 1367 if (IS_ERR(device)) 1368 return -ENODEV; 1369 1370 if ((kstrtouint(buf, 16, &val) != 0) || val > 0xff) 1371 val = 0; 1372 1373 if (device->discipline && device->discipline->reset_path) 1374 device->discipline->reset_path(device, (__u8) val); 1375 1376 dasd_put_device(device); 1377 return count; 1378} 1379 1380static DEVICE_ATTR(path_reset, 0200, NULL, dasd_path_reset_store); 1381 1382static ssize_t dasd_hpf_show(struct device *dev, struct device_attribute *attr, 1383 char *buf) 1384{ 1385 struct dasd_device *device; 1386 int hpf; 1387 1388 device = dasd_device_from_cdev(to_ccwdev(dev)); 1389 if (IS_ERR(device)) 1390 return -ENODEV; 1391 if (!device->discipline || !device->discipline->hpf_enabled) { 1392 dasd_put_device(device); 1393 return snprintf(buf, PAGE_SIZE, "%d\n", dasd_nofcx); 1394 } 1395 hpf = device->discipline->hpf_enabled(device); 1396 dasd_put_device(device); 1397 return snprintf(buf, PAGE_SIZE, "%d\n", hpf); 1398} 1399 1400static DEVICE_ATTR(hpf, 0444, dasd_hpf_show, NULL); 1401 1402static ssize_t dasd_reservation_policy_show(struct device *dev, 1403 struct device_attribute *attr, 1404 char *buf) 1405{ 1406 struct dasd_devmap *devmap; 1407 int rc = 0; 1408 1409 devmap = dasd_find_busid(dev_name(dev)); 1410 if (IS_ERR(devmap)) { 1411 rc = snprintf(buf, PAGE_SIZE, "ignore\n"); 1412 } else { 1413 spin_lock(&dasd_devmap_lock); 1414 if (devmap->features & DASD_FEATURE_FAILONSLCK) 1415 rc = snprintf(buf, PAGE_SIZE, "fail\n"); 1416 else 1417 rc = snprintf(buf, PAGE_SIZE, "ignore\n"); 1418 spin_unlock(&dasd_devmap_lock); 1419 } 1420 return rc; 1421} 1422 1423static ssize_t dasd_reservation_policy_store(struct device *dev, 1424 struct device_attribute *attr, 1425 const char *buf, size_t count) 1426{ 1427 struct ccw_device *cdev = to_ccwdev(dev); 1428 int rc; 1429 1430 if (sysfs_streq("ignore", buf)) 1431 rc = dasd_set_feature(cdev, DASD_FEATURE_FAILONSLCK, 0); 1432 else if (sysfs_streq("fail", buf)) 1433 rc = dasd_set_feature(cdev, DASD_FEATURE_FAILONSLCK, 1); 1434 else 1435 rc = -EINVAL; 1436 1437 return rc ? : count; 1438} 1439 1440static DEVICE_ATTR(reservation_policy, 0644, 1441 dasd_reservation_policy_show, dasd_reservation_policy_store); 1442 1443static ssize_t dasd_reservation_state_show(struct device *dev, 1444 struct device_attribute *attr, 1445 char *buf) 1446{ 1447 struct dasd_device *device; 1448 int rc = 0; 1449 1450 device = dasd_device_from_cdev(to_ccwdev(dev)); 1451 if (IS_ERR(device)) 1452 return snprintf(buf, PAGE_SIZE, "none\n"); 1453 1454 if (test_bit(DASD_FLAG_IS_RESERVED, &device->flags)) 1455 rc = snprintf(buf, PAGE_SIZE, "reserved\n"); 1456 else if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags)) 1457 rc = snprintf(buf, PAGE_SIZE, "lost\n"); 1458 else 1459 rc = snprintf(buf, PAGE_SIZE, "none\n"); 1460 dasd_put_device(device); 1461 return rc; 1462} 1463 1464static ssize_t dasd_reservation_state_store(struct device *dev, 1465 struct device_attribute *attr, 1466 const char *buf, size_t count) 1467{ 1468 struct dasd_device *device; 1469 int rc = 0; 1470 1471 device = dasd_device_from_cdev(to_ccwdev(dev)); 1472 if (IS_ERR(device)) 1473 return -ENODEV; 1474 if (sysfs_streq("reset", buf)) 1475 clear_bit(DASD_FLAG_LOCK_STOLEN, &device->flags); 1476 else 1477 rc = -EINVAL; 1478 dasd_put_device(device); 1479 1480 if (rc) 1481 return rc; 1482 else 1483 return count; 1484} 1485 1486static DEVICE_ATTR(last_known_reservation_state, 0644, 1487 dasd_reservation_state_show, dasd_reservation_state_store); 1488 1489static ssize_t dasd_pm_show(struct device *dev, 1490 struct device_attribute *attr, char *buf) 1491{ 1492 struct dasd_device *device; 1493 u8 opm, nppm, cablepm, cuirpm, hpfpm, ifccpm; 1494 1495 device = dasd_device_from_cdev(to_ccwdev(dev)); 1496 if (IS_ERR(device)) 1497 return sprintf(buf, "0\n"); 1498 1499 opm = dasd_path_get_opm(device); 1500 nppm = dasd_path_get_nppm(device); 1501 cablepm = dasd_path_get_cablepm(device); 1502 cuirpm = dasd_path_get_cuirpm(device); 1503 hpfpm = dasd_path_get_hpfpm(device); 1504 ifccpm = dasd_path_get_ifccpm(device); 1505 dasd_put_device(device); 1506 1507 return sprintf(buf, "%02x %02x %02x %02x %02x %02x\n", opm, nppm, 1508 cablepm, cuirpm, hpfpm, ifccpm); 1509} 1510 1511static DEVICE_ATTR(path_masks, 0444, dasd_pm_show, NULL); 1512 1513/* 1514 * threshold value for IFCC/CCC errors 1515 */ 1516static ssize_t 1517dasd_path_threshold_show(struct device *dev, 1518 struct device_attribute *attr, char *buf) 1519{ 1520 struct dasd_device *device; 1521 int len; 1522 1523 device = dasd_device_from_cdev(to_ccwdev(dev)); 1524 if (IS_ERR(device)) 1525 return -ENODEV; 1526 len = snprintf(buf, PAGE_SIZE, "%lu\n", device->path_thrhld); 1527 dasd_put_device(device); 1528 return len; 1529} 1530 1531static ssize_t 1532dasd_path_threshold_store(struct device *dev, struct device_attribute *attr, 1533 const char *buf, size_t count) 1534{ 1535 struct dasd_device *device; 1536 unsigned long flags; 1537 unsigned long val; 1538 1539 device = dasd_device_from_cdev(to_ccwdev(dev)); 1540 if (IS_ERR(device)) 1541 return -ENODEV; 1542 1543 if (kstrtoul(buf, 10, &val) != 0 || val > DASD_THRHLD_MAX) { 1544 dasd_put_device(device); 1545 return -EINVAL; 1546 } 1547 spin_lock_irqsave(get_ccwdev_lock(to_ccwdev(dev)), flags); 1548 device->path_thrhld = val; 1549 spin_unlock_irqrestore(get_ccwdev_lock(to_ccwdev(dev)), flags); 1550 dasd_put_device(device); 1551 return count; 1552} 1553static DEVICE_ATTR(path_threshold, 0644, dasd_path_threshold_show, 1554 dasd_path_threshold_store); 1555 1556/* 1557 * configure if path is disabled after IFCC/CCC error threshold is 1558 * exceeded 1559 */ 1560static ssize_t 1561dasd_path_autodisable_show(struct device *dev, 1562 struct device_attribute *attr, char *buf) 1563{ 1564 struct dasd_devmap *devmap; 1565 int flag; 1566 1567 devmap = dasd_find_busid(dev_name(dev)); 1568 if (!IS_ERR(devmap)) 1569 flag = (devmap->features & DASD_FEATURE_PATH_AUTODISABLE) != 0; 1570 else 1571 flag = (DASD_FEATURE_DEFAULT & 1572 DASD_FEATURE_PATH_AUTODISABLE) != 0; 1573 return snprintf(buf, PAGE_SIZE, flag ? "1\n" : "0\n"); 1574} 1575 1576static ssize_t 1577dasd_path_autodisable_store(struct device *dev, 1578 struct device_attribute *attr, 1579 const char *buf, size_t count) 1580{ 1581 unsigned int val; 1582 int rc; 1583 1584 if (kstrtouint(buf, 0, &val) || val > 1) 1585 return -EINVAL; 1586 1587 rc = dasd_set_feature(to_ccwdev(dev), 1588 DASD_FEATURE_PATH_AUTODISABLE, val); 1589 1590 return rc ? : count; 1591} 1592 1593static DEVICE_ATTR(path_autodisable, 0644, 1594 dasd_path_autodisable_show, 1595 dasd_path_autodisable_store); 1596/* 1597 * interval for IFCC/CCC checks 1598 * meaning time with no IFCC/CCC error before the error counter 1599 * gets reset 1600 */ 1601static ssize_t 1602dasd_path_interval_show(struct device *dev, 1603 struct device_attribute *attr, char *buf) 1604{ 1605 struct dasd_device *device; 1606 int len; 1607 1608 device = dasd_device_from_cdev(to_ccwdev(dev)); 1609 if (IS_ERR(device)) 1610 return -ENODEV; 1611 len = snprintf(buf, PAGE_SIZE, "%lu\n", device->path_interval); 1612 dasd_put_device(device); 1613 return len; 1614} 1615 1616static ssize_t 1617dasd_path_interval_store(struct device *dev, struct device_attribute *attr, 1618 const char *buf, size_t count) 1619{ 1620 struct dasd_device *device; 1621 unsigned long flags; 1622 unsigned long val; 1623 1624 device = dasd_device_from_cdev(to_ccwdev(dev)); 1625 if (IS_ERR(device)) 1626 return -ENODEV; 1627 1628 if ((kstrtoul(buf, 10, &val) != 0) || 1629 (val > DASD_INTERVAL_MAX) || val == 0) { 1630 dasd_put_device(device); 1631 return -EINVAL; 1632 } 1633 spin_lock_irqsave(get_ccwdev_lock(to_ccwdev(dev)), flags); 1634 if (val) 1635 device->path_interval = val; 1636 spin_unlock_irqrestore(get_ccwdev_lock(to_ccwdev(dev)), flags); 1637 dasd_put_device(device); 1638 return count; 1639} 1640 1641static DEVICE_ATTR(path_interval, 0644, dasd_path_interval_show, 1642 dasd_path_interval_store); 1643 1644 1645#define DASD_DEFINE_ATTR(_name, _func) \ 1646static ssize_t dasd_##_name##_show(struct device *dev, \ 1647 struct device_attribute *attr, \ 1648 char *buf) \ 1649{ \ 1650 struct ccw_device *cdev = to_ccwdev(dev); \ 1651 struct dasd_device *device = dasd_device_from_cdev(cdev); \ 1652 int val = 0; \ 1653 \ 1654 if (IS_ERR(device)) \ 1655 return -ENODEV; \ 1656 if (device->discipline && _func) \ 1657 val = _func(device); \ 1658 dasd_put_device(device); \ 1659 \ 1660 return snprintf(buf, PAGE_SIZE, "%d\n", val); \ 1661} \ 1662static DEVICE_ATTR(_name, 0444, dasd_##_name##_show, NULL); \ 1663 1664DASD_DEFINE_ATTR(ese, device->discipline->is_ese); 1665DASD_DEFINE_ATTR(extent_size, device->discipline->ext_size); 1666DASD_DEFINE_ATTR(pool_id, device->discipline->ext_pool_id); 1667DASD_DEFINE_ATTR(space_configured, device->discipline->space_configured); 1668DASD_DEFINE_ATTR(space_allocated, device->discipline->space_allocated); 1669DASD_DEFINE_ATTR(logical_capacity, device->discipline->logical_capacity); 1670DASD_DEFINE_ATTR(warn_threshold, device->discipline->ext_pool_warn_thrshld); 1671DASD_DEFINE_ATTR(cap_at_warnlevel, device->discipline->ext_pool_cap_at_warnlevel); 1672DASD_DEFINE_ATTR(pool_oos, device->discipline->ext_pool_oos); 1673 1674static struct attribute * dasd_attrs[] = { 1675 &dev_attr_readonly.attr, 1676 &dev_attr_discipline.attr, 1677 &dev_attr_status.attr, 1678 &dev_attr_alias.attr, 1679 &dev_attr_vendor.attr, 1680 &dev_attr_uid.attr, 1681 &dev_attr_use_diag.attr, 1682 &dev_attr_raw_track_access.attr, 1683 &dev_attr_eer_enabled.attr, 1684 &dev_attr_erplog.attr, 1685 &dev_attr_failfast.attr, 1686 &dev_attr_expires.attr, 1687 &dev_attr_retries.attr, 1688 &dev_attr_timeout.attr, 1689 &dev_attr_reservation_policy.attr, 1690 &dev_attr_last_known_reservation_state.attr, 1691 &dev_attr_safe_offline.attr, 1692 &dev_attr_host_access_count.attr, 1693 &dev_attr_path_masks.attr, 1694 &dev_attr_path_threshold.attr, 1695 &dev_attr_path_autodisable.attr, 1696 &dev_attr_path_interval.attr, 1697 &dev_attr_path_reset.attr, 1698 &dev_attr_hpf.attr, 1699 &dev_attr_ese.attr, 1700 NULL, 1701}; 1702 1703static const struct attribute_group dasd_attr_group = { 1704 .attrs = dasd_attrs, 1705}; 1706 1707static struct attribute *capacity_attrs[] = { 1708 &dev_attr_space_configured.attr, 1709 &dev_attr_space_allocated.attr, 1710 &dev_attr_logical_capacity.attr, 1711 NULL, 1712}; 1713 1714static const struct attribute_group capacity_attr_group = { 1715 .name = "capacity", 1716 .attrs = capacity_attrs, 1717}; 1718 1719static struct attribute *ext_pool_attrs[] = { 1720 &dev_attr_pool_id.attr, 1721 &dev_attr_extent_size.attr, 1722 &dev_attr_warn_threshold.attr, 1723 &dev_attr_cap_at_warnlevel.attr, 1724 &dev_attr_pool_oos.attr, 1725 NULL, 1726}; 1727 1728static const struct attribute_group ext_pool_attr_group = { 1729 .name = "extent_pool", 1730 .attrs = ext_pool_attrs, 1731}; 1732 1733static const struct attribute_group *dasd_attr_groups[] = { 1734 &dasd_attr_group, 1735 &capacity_attr_group, 1736 &ext_pool_attr_group, 1737 NULL, 1738}; 1739 1740/* 1741 * Return value of the specified feature. 1742 */ 1743int 1744dasd_get_feature(struct ccw_device *cdev, int feature) 1745{ 1746 struct dasd_devmap *devmap; 1747 1748 devmap = dasd_find_busid(dev_name(&cdev->dev)); 1749 if (IS_ERR(devmap)) 1750 return PTR_ERR(devmap); 1751 1752 return ((devmap->features & feature) != 0); 1753} 1754 1755/* 1756 * Set / reset given feature. 1757 * Flag indicates whether to set (!=0) or the reset (=0) the feature. 1758 */ 1759int 1760dasd_set_feature(struct ccw_device *cdev, int feature, int flag) 1761{ 1762 struct dasd_devmap *devmap; 1763 1764 devmap = dasd_devmap_from_cdev(cdev); 1765 if (IS_ERR(devmap)) 1766 return PTR_ERR(devmap); 1767 1768 spin_lock(&dasd_devmap_lock); 1769 if (flag) 1770 devmap->features |= feature; 1771 else 1772 devmap->features &= ~feature; 1773 if (devmap->device) 1774 devmap->device->features = devmap->features; 1775 spin_unlock(&dasd_devmap_lock); 1776 return 0; 1777} 1778EXPORT_SYMBOL(dasd_set_feature); 1779 1780 1781int dasd_add_sysfs_files(struct ccw_device *cdev) 1782{ 1783 return sysfs_create_groups(&cdev->dev.kobj, dasd_attr_groups); 1784} 1785 1786void 1787dasd_remove_sysfs_files(struct ccw_device *cdev) 1788{ 1789 sysfs_remove_groups(&cdev->dev.kobj, dasd_attr_groups); 1790} 1791 1792 1793int 1794dasd_devmap_init(void) 1795{ 1796 int i; 1797 1798 /* Initialize devmap structures. */ 1799 dasd_max_devindex = 0; 1800 for (i = 0; i < 256; i++) 1801 INIT_LIST_HEAD(&dasd_hashlists[i]); 1802 return 0; 1803} 1804 1805void 1806dasd_devmap_exit(void) 1807{ 1808 dasd_forget_ranges(); 1809} 1810