1 /* 2 * scsi_sysfs.c 3 * 4 * SCSI sysfs interface routines. 5 * 6 * Created to pull SCSI mid layer sysfs routines into one file. 7 */ 8 9 #include <linux/module.h> 10 #include <linux/slab.h> 11 #include <linux/init.h> 12 #include <linux/blkdev.h> 13 #include <linux/device.h> 14 #include <linux/pm_runtime.h> 15 16 #include <scsi/scsi.h> 17 #include <scsi/scsi_device.h> 18 #include <scsi/scsi_host.h> 19 #include <scsi/scsi_tcq.h> 20 #include <scsi/scsi_dh.h> 21 #include <scsi/scsi_transport.h> 22 #include <scsi/scsi_driver.h> 23 #include <scsi/scsi_devinfo.h> 24 25 #include "scsi_priv.h" 26 #include "scsi_logging.h" 27 28 static struct device_type scsi_dev_type; 29 30 static const struct { 31 enum scsi_device_state value; 32 char *name; 33 } sdev_states[] = { 34 { SDEV_CREATED, "created" }, 35 { SDEV_RUNNING, "running" }, 36 { SDEV_CANCEL, "cancel" }, 37 { SDEV_DEL, "deleted" }, 38 { SDEV_QUIESCE, "quiesce" }, 39 { SDEV_OFFLINE, "offline" }, 40 { SDEV_TRANSPORT_OFFLINE, "transport-offline" }, 41 { SDEV_BLOCK, "blocked" }, 42 { SDEV_CREATED_BLOCK, "created-blocked" }, 43 }; 44 45 const char *scsi_device_state_name(enum scsi_device_state state) 46 { 47 int i; 48 char *name = NULL; 49 50 for (i = 0; i < ARRAY_SIZE(sdev_states); i++) { 51 if (sdev_states[i].value == state) { 52 name = sdev_states[i].name; 53 break; 54 } 55 } 56 return name; 57 } 58 59 static const struct { 60 enum scsi_host_state value; 61 char *name; 62 } shost_states[] = { 63 { SHOST_CREATED, "created" }, 64 { SHOST_RUNNING, "running" }, 65 { SHOST_CANCEL, "cancel" }, 66 { SHOST_DEL, "deleted" }, 67 { SHOST_RECOVERY, "recovery" }, 68 { SHOST_CANCEL_RECOVERY, "cancel/recovery" }, 69 { SHOST_DEL_RECOVERY, "deleted/recovery", }, 70 }; 71 const char *scsi_host_state_name(enum scsi_host_state state) 72 { 73 int i; 74 char *name = NULL; 75 76 for (i = 0; i < ARRAY_SIZE(shost_states); i++) { 77 if (shost_states[i].value == state) { 78 name = shost_states[i].name; 79 break; 80 } 81 } 82 return name; 83 } 84 85 #ifdef CONFIG_SCSI_DH 86 static const struct { 87 unsigned char value; 88 char *name; 89 } sdev_access_states[] = { 90 { SCSI_ACCESS_STATE_OPTIMAL, "active/optimized" }, 91 { SCSI_ACCESS_STATE_ACTIVE, "active/non-optimized" }, 92 { SCSI_ACCESS_STATE_STANDBY, "standby" }, 93 { SCSI_ACCESS_STATE_UNAVAILABLE, "unavailable" }, 94 { SCSI_ACCESS_STATE_LBA, "lba-dependent" }, 95 { SCSI_ACCESS_STATE_OFFLINE, "offline" }, 96 { SCSI_ACCESS_STATE_TRANSITIONING, "transitioning" }, 97 }; 98 99 static const char *scsi_access_state_name(unsigned char state) 100 { 101 int i; 102 char *name = NULL; 103 104 for (i = 0; i < ARRAY_SIZE(sdev_access_states); i++) { 105 if (sdev_access_states[i].value == state) { 106 name = sdev_access_states[i].name; 107 break; 108 } 109 } 110 return name; 111 } 112 #endif 113 114 static int check_set(unsigned long long *val, char *src) 115 { 116 char *last; 117 118 if (strcmp(src, "-") == 0) { 119 *val = SCAN_WILD_CARD; 120 } else { 121 /* 122 * Doesn't check for int overflow 123 */ 124 *val = simple_strtoull(src, &last, 0); 125 if (*last != '\0') 126 return 1; 127 } 128 return 0; 129 } 130 131 static int scsi_scan(struct Scsi_Host *shost, const char *str) 132 { 133 char s1[15], s2[15], s3[17], junk; 134 unsigned long long channel, id, lun; 135 int res; 136 137 res = sscanf(str, "%10s %10s %16s %c", s1, s2, s3, &junk); 138 if (res != 3) 139 return -EINVAL; 140 if (check_set(&channel, s1)) 141 return -EINVAL; 142 if (check_set(&id, s2)) 143 return -EINVAL; 144 if (check_set(&lun, s3)) 145 return -EINVAL; 146 if (shost->transportt->user_scan) 147 res = shost->transportt->user_scan(shost, channel, id, lun); 148 else 149 res = scsi_scan_host_selected(shost, channel, id, lun, 150 SCSI_SCAN_MANUAL); 151 return res; 152 } 153 154 /* 155 * shost_show_function: macro to create an attr function that can be used to 156 * show a non-bit field. 157 */ 158 #define shost_show_function(name, field, format_string) \ 159 static ssize_t \ 160 show_##name (struct device *dev, struct device_attribute *attr, \ 161 char *buf) \ 162 { \ 163 struct Scsi_Host *shost = class_to_shost(dev); \ 164 return snprintf (buf, 20, format_string, shost->field); \ 165 } 166 167 /* 168 * shost_rd_attr: macro to create a function and attribute variable for a 169 * read only field. 170 */ 171 #define shost_rd_attr2(name, field, format_string) \ 172 shost_show_function(name, field, format_string) \ 173 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL); 174 175 #define shost_rd_attr(field, format_string) \ 176 shost_rd_attr2(field, field, format_string) 177 178 /* 179 * Create the actual show/store functions and data structures. 180 */ 181 182 static ssize_t 183 store_scan(struct device *dev, struct device_attribute *attr, 184 const char *buf, size_t count) 185 { 186 struct Scsi_Host *shost = class_to_shost(dev); 187 int res; 188 189 res = scsi_scan(shost, buf); 190 if (res == 0) 191 res = count; 192 return res; 193 }; 194 static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan); 195 196 static ssize_t 197 store_shost_state(struct device *dev, struct device_attribute *attr, 198 const char *buf, size_t count) 199 { 200 int i; 201 struct Scsi_Host *shost = class_to_shost(dev); 202 enum scsi_host_state state = 0; 203 204 for (i = 0; i < ARRAY_SIZE(shost_states); i++) { 205 const int len = strlen(shost_states[i].name); 206 if (strncmp(shost_states[i].name, buf, len) == 0 && 207 buf[len] == '\n') { 208 state = shost_states[i].value; 209 break; 210 } 211 } 212 if (!state) 213 return -EINVAL; 214 215 if (scsi_host_set_state(shost, state)) 216 return -EINVAL; 217 return count; 218 } 219 220 static ssize_t 221 show_shost_state(struct device *dev, struct device_attribute *attr, char *buf) 222 { 223 struct Scsi_Host *shost = class_to_shost(dev); 224 const char *name = scsi_host_state_name(shost->shost_state); 225 226 if (!name) 227 return -EINVAL; 228 229 return snprintf(buf, 20, "%s\n", name); 230 } 231 232 /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */ 233 static struct device_attribute dev_attr_hstate = 234 __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state); 235 236 static ssize_t 237 show_shost_mode(unsigned int mode, char *buf) 238 { 239 ssize_t len = 0; 240 241 if (mode & MODE_INITIATOR) 242 len = sprintf(buf, "%s", "Initiator"); 243 244 if (mode & MODE_TARGET) 245 len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target"); 246 247 len += sprintf(buf + len, "\n"); 248 249 return len; 250 } 251 252 static ssize_t 253 show_shost_supported_mode(struct device *dev, struct device_attribute *attr, 254 char *buf) 255 { 256 struct Scsi_Host *shost = class_to_shost(dev); 257 unsigned int supported_mode = shost->hostt->supported_mode; 258 259 if (supported_mode == MODE_UNKNOWN) 260 /* by default this should be initiator */ 261 supported_mode = MODE_INITIATOR; 262 263 return show_shost_mode(supported_mode, buf); 264 } 265 266 static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL); 267 268 static ssize_t 269 show_shost_active_mode(struct device *dev, 270 struct device_attribute *attr, char *buf) 271 { 272 struct Scsi_Host *shost = class_to_shost(dev); 273 274 if (shost->active_mode == MODE_UNKNOWN) 275 return snprintf(buf, 20, "unknown\n"); 276 else 277 return show_shost_mode(shost->active_mode, buf); 278 } 279 280 static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL); 281 282 static int check_reset_type(const char *str) 283 { 284 if (sysfs_streq(str, "adapter")) 285 return SCSI_ADAPTER_RESET; 286 else if (sysfs_streq(str, "firmware")) 287 return SCSI_FIRMWARE_RESET; 288 else 289 return 0; 290 } 291 292 static ssize_t 293 store_host_reset(struct device *dev, struct device_attribute *attr, 294 const char *buf, size_t count) 295 { 296 struct Scsi_Host *shost = class_to_shost(dev); 297 struct scsi_host_template *sht = shost->hostt; 298 int ret = -EINVAL; 299 int type; 300 301 type = check_reset_type(buf); 302 if (!type) 303 goto exit_store_host_reset; 304 305 if (sht->host_reset) 306 ret = sht->host_reset(shost, type); 307 else 308 ret = -EOPNOTSUPP; 309 310 exit_store_host_reset: 311 if (ret == 0) 312 ret = count; 313 return ret; 314 } 315 316 static DEVICE_ATTR(host_reset, S_IWUSR, NULL, store_host_reset); 317 318 static ssize_t 319 show_shost_eh_deadline(struct device *dev, 320 struct device_attribute *attr, char *buf) 321 { 322 struct Scsi_Host *shost = class_to_shost(dev); 323 324 if (shost->eh_deadline == -1) 325 return snprintf(buf, strlen("off") + 2, "off\n"); 326 return sprintf(buf, "%u\n", shost->eh_deadline / HZ); 327 } 328 329 static ssize_t 330 store_shost_eh_deadline(struct device *dev, struct device_attribute *attr, 331 const char *buf, size_t count) 332 { 333 struct Scsi_Host *shost = class_to_shost(dev); 334 int ret = -EINVAL; 335 unsigned long deadline, flags; 336 337 if (shost->transportt && 338 (shost->transportt->eh_strategy_handler || 339 !shost->hostt->eh_host_reset_handler)) 340 return ret; 341 342 if (!strncmp(buf, "off", strlen("off"))) 343 deadline = -1; 344 else { 345 ret = kstrtoul(buf, 10, &deadline); 346 if (ret) 347 return ret; 348 if (deadline * HZ > UINT_MAX) 349 return -EINVAL; 350 } 351 352 spin_lock_irqsave(shost->host_lock, flags); 353 if (scsi_host_in_recovery(shost)) 354 ret = -EBUSY; 355 else { 356 if (deadline == -1) 357 shost->eh_deadline = -1; 358 else 359 shost->eh_deadline = deadline * HZ; 360 361 ret = count; 362 } 363 spin_unlock_irqrestore(shost->host_lock, flags); 364 365 return ret; 366 } 367 368 static DEVICE_ATTR(eh_deadline, S_IRUGO | S_IWUSR, show_shost_eh_deadline, store_shost_eh_deadline); 369 370 shost_rd_attr(unique_id, "%u\n"); 371 shost_rd_attr(cmd_per_lun, "%hd\n"); 372 shost_rd_attr(can_queue, "%hd\n"); 373 shost_rd_attr(sg_tablesize, "%hu\n"); 374 shost_rd_attr(sg_prot_tablesize, "%hu\n"); 375 shost_rd_attr(unchecked_isa_dma, "%d\n"); 376 shost_rd_attr(prot_capabilities, "%u\n"); 377 shost_rd_attr(prot_guard_type, "%hd\n"); 378 shost_rd_attr2(proc_name, hostt->proc_name, "%s\n"); 379 380 static ssize_t 381 show_host_busy(struct device *dev, struct device_attribute *attr, char *buf) 382 { 383 struct Scsi_Host *shost = class_to_shost(dev); 384 return snprintf(buf, 20, "%d\n", scsi_host_busy(shost)); 385 } 386 static DEVICE_ATTR(host_busy, S_IRUGO, show_host_busy, NULL); 387 388 static ssize_t 389 show_use_blk_mq(struct device *dev, struct device_attribute *attr, char *buf) 390 { 391 return sprintf(buf, "1\n"); 392 } 393 static DEVICE_ATTR(use_blk_mq, S_IRUGO, show_use_blk_mq, NULL); 394 395 static struct attribute *scsi_sysfs_shost_attrs[] = { 396 &dev_attr_use_blk_mq.attr, 397 &dev_attr_unique_id.attr, 398 &dev_attr_host_busy.attr, 399 &dev_attr_cmd_per_lun.attr, 400 &dev_attr_can_queue.attr, 401 &dev_attr_sg_tablesize.attr, 402 &dev_attr_sg_prot_tablesize.attr, 403 &dev_attr_unchecked_isa_dma.attr, 404 &dev_attr_proc_name.attr, 405 &dev_attr_scan.attr, 406 &dev_attr_hstate.attr, 407 &dev_attr_supported_mode.attr, 408 &dev_attr_active_mode.attr, 409 &dev_attr_prot_capabilities.attr, 410 &dev_attr_prot_guard_type.attr, 411 &dev_attr_host_reset.attr, 412 &dev_attr_eh_deadline.attr, 413 NULL 414 }; 415 416 static struct attribute_group scsi_shost_attr_group = { 417 .attrs = scsi_sysfs_shost_attrs, 418 }; 419 420 const struct attribute_group *scsi_sysfs_shost_attr_groups[] = { 421 &scsi_shost_attr_group, 422 NULL 423 }; 424 425 static void scsi_device_cls_release(struct device *class_dev) 426 { 427 struct scsi_device *sdev; 428 429 sdev = class_to_sdev(class_dev); 430 put_device(&sdev->sdev_gendev); 431 } 432 433 static void scsi_device_dev_release_usercontext(struct work_struct *work) 434 { 435 struct scsi_device *sdev; 436 struct device *parent; 437 struct list_head *this, *tmp; 438 struct scsi_vpd *vpd_pg80 = NULL, *vpd_pg83 = NULL; 439 unsigned long flags; 440 441 sdev = container_of(work, struct scsi_device, ew.work); 442 443 scsi_dh_release_device(sdev); 444 445 parent = sdev->sdev_gendev.parent; 446 447 spin_lock_irqsave(sdev->host->host_lock, flags); 448 list_del(&sdev->siblings); 449 list_del(&sdev->same_target_siblings); 450 list_del(&sdev->starved_entry); 451 spin_unlock_irqrestore(sdev->host->host_lock, flags); 452 453 cancel_work_sync(&sdev->event_work); 454 455 list_for_each_safe(this, tmp, &sdev->event_list) { 456 struct scsi_event *evt; 457 458 evt = list_entry(this, struct scsi_event, node); 459 list_del(&evt->node); 460 kfree(evt); 461 } 462 463 blk_put_queue(sdev->request_queue); 464 /* NULL queue means the device can't be used */ 465 sdev->request_queue = NULL; 466 467 mutex_lock(&sdev->inquiry_mutex); 468 rcu_swap_protected(sdev->vpd_pg80, vpd_pg80, 469 lockdep_is_held(&sdev->inquiry_mutex)); 470 rcu_swap_protected(sdev->vpd_pg83, vpd_pg83, 471 lockdep_is_held(&sdev->inquiry_mutex)); 472 mutex_unlock(&sdev->inquiry_mutex); 473 474 if (vpd_pg83) 475 kfree_rcu(vpd_pg83, rcu); 476 if (vpd_pg80) 477 kfree_rcu(vpd_pg80, rcu); 478 kfree(sdev->inquiry); 479 kfree(sdev); 480 481 if (parent) 482 put_device(parent); 483 } 484 485 static void scsi_device_dev_release(struct device *dev) 486 { 487 struct scsi_device *sdp = to_scsi_device(dev); 488 execute_in_process_context(scsi_device_dev_release_usercontext, 489 &sdp->ew); 490 } 491 492 static struct class sdev_class = { 493 .name = "scsi_device", 494 .dev_release = scsi_device_cls_release, 495 }; 496 497 /* all probing is done in the individual ->probe routines */ 498 static int scsi_bus_match(struct device *dev, struct device_driver *gendrv) 499 { 500 struct scsi_device *sdp; 501 502 if (dev->type != &scsi_dev_type) 503 return 0; 504 505 sdp = to_scsi_device(dev); 506 if (sdp->no_uld_attach) 507 return 0; 508 return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0; 509 } 510 511 static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env) 512 { 513 struct scsi_device *sdev; 514 515 if (dev->type != &scsi_dev_type) 516 return 0; 517 518 sdev = to_scsi_device(dev); 519 520 add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type); 521 return 0; 522 } 523 524 struct bus_type scsi_bus_type = { 525 .name = "scsi", 526 .match = scsi_bus_match, 527 .uevent = scsi_bus_uevent, 528 #ifdef CONFIG_PM 529 .pm = &scsi_bus_pm_ops, 530 #endif 531 }; 532 EXPORT_SYMBOL_GPL(scsi_bus_type); 533 534 int scsi_sysfs_register(void) 535 { 536 int error; 537 538 error = bus_register(&scsi_bus_type); 539 if (!error) { 540 error = class_register(&sdev_class); 541 if (error) 542 bus_unregister(&scsi_bus_type); 543 } 544 545 return error; 546 } 547 548 void scsi_sysfs_unregister(void) 549 { 550 class_unregister(&sdev_class); 551 bus_unregister(&scsi_bus_type); 552 } 553 554 /* 555 * sdev_show_function: macro to create an attr function that can be used to 556 * show a non-bit field. 557 */ 558 #define sdev_show_function(field, format_string) \ 559 static ssize_t \ 560 sdev_show_##field (struct device *dev, struct device_attribute *attr, \ 561 char *buf) \ 562 { \ 563 struct scsi_device *sdev; \ 564 sdev = to_scsi_device(dev); \ 565 return snprintf (buf, 20, format_string, sdev->field); \ 566 } \ 567 568 /* 569 * sdev_rd_attr: macro to create a function and attribute variable for a 570 * read only field. 571 */ 572 #define sdev_rd_attr(field, format_string) \ 573 sdev_show_function(field, format_string) \ 574 static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL); 575 576 577 /* 578 * sdev_rw_attr: create a function and attribute variable for a 579 * read/write field. 580 */ 581 #define sdev_rw_attr(field, format_string) \ 582 sdev_show_function(field, format_string) \ 583 \ 584 static ssize_t \ 585 sdev_store_##field (struct device *dev, struct device_attribute *attr, \ 586 const char *buf, size_t count) \ 587 { \ 588 struct scsi_device *sdev; \ 589 sdev = to_scsi_device(dev); \ 590 sscanf (buf, format_string, &sdev->field); \ 591 return count; \ 592 } \ 593 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field); 594 595 /* Currently we don't export bit fields, but we might in future, 596 * so leave this code in */ 597 #if 0 598 /* 599 * sdev_rd_attr: create a function and attribute variable for a 600 * read/write bit field. 601 */ 602 #define sdev_rw_attr_bit(field) \ 603 sdev_show_function(field, "%d\n") \ 604 \ 605 static ssize_t \ 606 sdev_store_##field (struct device *dev, struct device_attribute *attr, \ 607 const char *buf, size_t count) \ 608 { \ 609 int ret; \ 610 struct scsi_device *sdev; \ 611 ret = scsi_sdev_check_buf_bit(buf); \ 612 if (ret >= 0) { \ 613 sdev = to_scsi_device(dev); \ 614 sdev->field = ret; \ 615 ret = count; \ 616 } \ 617 return ret; \ 618 } \ 619 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field); 620 621 /* 622 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1", 623 * else return -EINVAL. 624 */ 625 static int scsi_sdev_check_buf_bit(const char *buf) 626 { 627 if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) { 628 if (buf[0] == '1') 629 return 1; 630 else if (buf[0] == '0') 631 return 0; 632 else 633 return -EINVAL; 634 } else 635 return -EINVAL; 636 } 637 #endif 638 /* 639 * Create the actual show/store functions and data structures. 640 */ 641 sdev_rd_attr (type, "%d\n"); 642 sdev_rd_attr (scsi_level, "%d\n"); 643 sdev_rd_attr (vendor, "%.8s\n"); 644 sdev_rd_attr (model, "%.16s\n"); 645 sdev_rd_attr (rev, "%.4s\n"); 646 647 static ssize_t 648 sdev_show_device_busy(struct device *dev, struct device_attribute *attr, 649 char *buf) 650 { 651 struct scsi_device *sdev = to_scsi_device(dev); 652 return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_busy)); 653 } 654 static DEVICE_ATTR(device_busy, S_IRUGO, sdev_show_device_busy, NULL); 655 656 static ssize_t 657 sdev_show_device_blocked(struct device *dev, struct device_attribute *attr, 658 char *buf) 659 { 660 struct scsi_device *sdev = to_scsi_device(dev); 661 return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_blocked)); 662 } 663 static DEVICE_ATTR(device_blocked, S_IRUGO, sdev_show_device_blocked, NULL); 664 665 /* 666 * TODO: can we make these symlinks to the block layer ones? 667 */ 668 static ssize_t 669 sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf) 670 { 671 struct scsi_device *sdev; 672 sdev = to_scsi_device(dev); 673 return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ); 674 } 675 676 static ssize_t 677 sdev_store_timeout (struct device *dev, struct device_attribute *attr, 678 const char *buf, size_t count) 679 { 680 struct scsi_device *sdev; 681 int timeout; 682 sdev = to_scsi_device(dev); 683 sscanf (buf, "%d\n", &timeout); 684 blk_queue_rq_timeout(sdev->request_queue, timeout * HZ); 685 return count; 686 } 687 static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout); 688 689 static ssize_t 690 sdev_show_eh_timeout(struct device *dev, struct device_attribute *attr, char *buf) 691 { 692 struct scsi_device *sdev; 693 sdev = to_scsi_device(dev); 694 return snprintf(buf, 20, "%u\n", sdev->eh_timeout / HZ); 695 } 696 697 static ssize_t 698 sdev_store_eh_timeout(struct device *dev, struct device_attribute *attr, 699 const char *buf, size_t count) 700 { 701 struct scsi_device *sdev; 702 unsigned int eh_timeout; 703 int err; 704 705 if (!capable(CAP_SYS_ADMIN)) 706 return -EACCES; 707 708 sdev = to_scsi_device(dev); 709 err = kstrtouint(buf, 10, &eh_timeout); 710 if (err) 711 return err; 712 sdev->eh_timeout = eh_timeout * HZ; 713 714 return count; 715 } 716 static DEVICE_ATTR(eh_timeout, S_IRUGO | S_IWUSR, sdev_show_eh_timeout, sdev_store_eh_timeout); 717 718 static ssize_t 719 store_rescan_field (struct device *dev, struct device_attribute *attr, 720 const char *buf, size_t count) 721 { 722 scsi_rescan_device(dev); 723 return count; 724 } 725 static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field); 726 727 static ssize_t 728 sdev_store_delete(struct device *dev, struct device_attribute *attr, 729 const char *buf, size_t count) 730 { 731 struct kernfs_node *kn; 732 733 kn = sysfs_break_active_protection(&dev->kobj, &attr->attr); 734 WARN_ON_ONCE(!kn); 735 /* 736 * Concurrent writes into the "delete" sysfs attribute may trigger 737 * concurrent calls to device_remove_file() and scsi_remove_device(). 738 * device_remove_file() handles concurrent removal calls by 739 * serializing these and by ignoring the second and later removal 740 * attempts. Concurrent calls of scsi_remove_device() are 741 * serialized. The second and later calls of scsi_remove_device() are 742 * ignored because the first call of that function changes the device 743 * state into SDEV_DEL. 744 */ 745 device_remove_file(dev, attr); 746 scsi_remove_device(to_scsi_device(dev)); 747 if (kn) 748 sysfs_unbreak_active_protection(kn); 749 return count; 750 }; 751 static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete); 752 753 static ssize_t 754 store_state_field(struct device *dev, struct device_attribute *attr, 755 const char *buf, size_t count) 756 { 757 int i, ret; 758 struct scsi_device *sdev = to_scsi_device(dev); 759 enum scsi_device_state state = 0; 760 761 for (i = 0; i < ARRAY_SIZE(sdev_states); i++) { 762 const int len = strlen(sdev_states[i].name); 763 if (strncmp(sdev_states[i].name, buf, len) == 0 && 764 buf[len] == '\n') { 765 state = sdev_states[i].value; 766 break; 767 } 768 } 769 if (!state) 770 return -EINVAL; 771 772 mutex_lock(&sdev->state_mutex); 773 ret = scsi_device_set_state(sdev, state); 774 /* 775 * If the device state changes to SDEV_RUNNING, we need to run 776 * the queue to avoid I/O hang. 777 */ 778 if (ret == 0 && state == SDEV_RUNNING) 779 blk_mq_run_hw_queues(sdev->request_queue, true); 780 mutex_unlock(&sdev->state_mutex); 781 782 return ret == 0 ? count : -EINVAL; 783 } 784 785 static ssize_t 786 show_state_field(struct device *dev, struct device_attribute *attr, char *buf) 787 { 788 struct scsi_device *sdev = to_scsi_device(dev); 789 const char *name = scsi_device_state_name(sdev->sdev_state); 790 791 if (!name) 792 return -EINVAL; 793 794 return snprintf(buf, 20, "%s\n", name); 795 } 796 797 static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field); 798 799 static ssize_t 800 show_queue_type_field(struct device *dev, struct device_attribute *attr, 801 char *buf) 802 { 803 struct scsi_device *sdev = to_scsi_device(dev); 804 const char *name = "none"; 805 806 if (sdev->simple_tags) 807 name = "simple"; 808 809 return snprintf(buf, 20, "%s\n", name); 810 } 811 812 static ssize_t 813 store_queue_type_field(struct device *dev, struct device_attribute *attr, 814 const char *buf, size_t count) 815 { 816 struct scsi_device *sdev = to_scsi_device(dev); 817 818 if (!sdev->tagged_supported) 819 return -EINVAL; 820 821 sdev_printk(KERN_INFO, sdev, 822 "ignoring write to deprecated queue_type attribute"); 823 return count; 824 } 825 826 static DEVICE_ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field, 827 store_queue_type_field); 828 829 #define sdev_vpd_pg_attr(_page) \ 830 static ssize_t \ 831 show_vpd_##_page(struct file *filp, struct kobject *kobj, \ 832 struct bin_attribute *bin_attr, \ 833 char *buf, loff_t off, size_t count) \ 834 { \ 835 struct device *dev = container_of(kobj, struct device, kobj); \ 836 struct scsi_device *sdev = to_scsi_device(dev); \ 837 struct scsi_vpd *vpd_page; \ 838 int ret = -EINVAL; \ 839 \ 840 rcu_read_lock(); \ 841 vpd_page = rcu_dereference(sdev->vpd_##_page); \ 842 if (vpd_page) \ 843 ret = memory_read_from_buffer(buf, count, &off, \ 844 vpd_page->data, vpd_page->len); \ 845 rcu_read_unlock(); \ 846 return ret; \ 847 } \ 848 static struct bin_attribute dev_attr_vpd_##_page = { \ 849 .attr = {.name = __stringify(vpd_##_page), .mode = S_IRUGO }, \ 850 .size = 0, \ 851 .read = show_vpd_##_page, \ 852 }; 853 854 sdev_vpd_pg_attr(pg83); 855 sdev_vpd_pg_attr(pg80); 856 857 static ssize_t show_inquiry(struct file *filep, struct kobject *kobj, 858 struct bin_attribute *bin_attr, 859 char *buf, loff_t off, size_t count) 860 { 861 struct device *dev = container_of(kobj, struct device, kobj); 862 struct scsi_device *sdev = to_scsi_device(dev); 863 864 if (!sdev->inquiry) 865 return -EINVAL; 866 867 return memory_read_from_buffer(buf, count, &off, sdev->inquiry, 868 sdev->inquiry_len); 869 } 870 871 static struct bin_attribute dev_attr_inquiry = { 872 .attr = { 873 .name = "inquiry", 874 .mode = S_IRUGO, 875 }, 876 .size = 0, 877 .read = show_inquiry, 878 }; 879 880 static ssize_t 881 show_iostat_counterbits(struct device *dev, struct device_attribute *attr, 882 char *buf) 883 { 884 return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8); 885 } 886 887 static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL); 888 889 #define show_sdev_iostat(field) \ 890 static ssize_t \ 891 show_iostat_##field(struct device *dev, struct device_attribute *attr, \ 892 char *buf) \ 893 { \ 894 struct scsi_device *sdev = to_scsi_device(dev); \ 895 unsigned long long count = atomic_read(&sdev->field); \ 896 return snprintf(buf, 20, "0x%llx\n", count); \ 897 } \ 898 static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL) 899 900 show_sdev_iostat(iorequest_cnt); 901 show_sdev_iostat(iodone_cnt); 902 show_sdev_iostat(ioerr_cnt); 903 904 static ssize_t 905 sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf) 906 { 907 struct scsi_device *sdev; 908 sdev = to_scsi_device(dev); 909 return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type); 910 } 911 static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL); 912 913 #define DECLARE_EVT_SHOW(name, Cap_name) \ 914 static ssize_t \ 915 sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \ 916 char *buf) \ 917 { \ 918 struct scsi_device *sdev = to_scsi_device(dev); \ 919 int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\ 920 return snprintf(buf, 20, "%d\n", val); \ 921 } 922 923 #define DECLARE_EVT_STORE(name, Cap_name) \ 924 static ssize_t \ 925 sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\ 926 const char *buf, size_t count) \ 927 { \ 928 struct scsi_device *sdev = to_scsi_device(dev); \ 929 int val = simple_strtoul(buf, NULL, 0); \ 930 if (val == 0) \ 931 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \ 932 else if (val == 1) \ 933 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \ 934 else \ 935 return -EINVAL; \ 936 return count; \ 937 } 938 939 #define DECLARE_EVT(name, Cap_name) \ 940 DECLARE_EVT_SHOW(name, Cap_name) \ 941 DECLARE_EVT_STORE(name, Cap_name) \ 942 static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name, \ 943 sdev_store_evt_##name); 944 #define REF_EVT(name) &dev_attr_evt_##name.attr 945 946 DECLARE_EVT(media_change, MEDIA_CHANGE) 947 DECLARE_EVT(inquiry_change_reported, INQUIRY_CHANGE_REPORTED) 948 DECLARE_EVT(capacity_change_reported, CAPACITY_CHANGE_REPORTED) 949 DECLARE_EVT(soft_threshold_reached, SOFT_THRESHOLD_REACHED_REPORTED) 950 DECLARE_EVT(mode_parameter_change_reported, MODE_PARAMETER_CHANGE_REPORTED) 951 DECLARE_EVT(lun_change_reported, LUN_CHANGE_REPORTED) 952 953 static ssize_t 954 sdev_store_queue_depth(struct device *dev, struct device_attribute *attr, 955 const char *buf, size_t count) 956 { 957 int depth, retval; 958 struct scsi_device *sdev = to_scsi_device(dev); 959 struct scsi_host_template *sht = sdev->host->hostt; 960 961 if (!sht->change_queue_depth) 962 return -EINVAL; 963 964 depth = simple_strtoul(buf, NULL, 0); 965 966 if (depth < 1 || depth > sdev->host->can_queue) 967 return -EINVAL; 968 969 retval = sht->change_queue_depth(sdev, depth); 970 if (retval < 0) 971 return retval; 972 973 sdev->max_queue_depth = sdev->queue_depth; 974 975 return count; 976 } 977 sdev_show_function(queue_depth, "%d\n"); 978 979 static DEVICE_ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth, 980 sdev_store_queue_depth); 981 982 static ssize_t 983 sdev_show_wwid(struct device *dev, struct device_attribute *attr, 984 char *buf) 985 { 986 struct scsi_device *sdev = to_scsi_device(dev); 987 ssize_t count; 988 989 count = scsi_vpd_lun_id(sdev, buf, PAGE_SIZE); 990 if (count > 0) { 991 buf[count] = '\n'; 992 count++; 993 } 994 return count; 995 } 996 static DEVICE_ATTR(wwid, S_IRUGO, sdev_show_wwid, NULL); 997 998 #define BLIST_FLAG_NAME(name) \ 999 [const_ilog2((__force __u64)BLIST_##name)] = #name 1000 static const char *const sdev_bflags_name[] = { 1001 #include "scsi_devinfo_tbl.c" 1002 }; 1003 #undef BLIST_FLAG_NAME 1004 1005 static ssize_t 1006 sdev_show_blacklist(struct device *dev, struct device_attribute *attr, 1007 char *buf) 1008 { 1009 struct scsi_device *sdev = to_scsi_device(dev); 1010 int i; 1011 ssize_t len = 0; 1012 1013 for (i = 0; i < sizeof(sdev->sdev_bflags) * BITS_PER_BYTE; i++) { 1014 const char *name = NULL; 1015 1016 if (!(sdev->sdev_bflags & (__force blist_flags_t)BIT(i))) 1017 continue; 1018 if (i < ARRAY_SIZE(sdev_bflags_name) && sdev_bflags_name[i]) 1019 name = sdev_bflags_name[i]; 1020 1021 if (name) 1022 len += snprintf(buf + len, PAGE_SIZE - len, 1023 "%s%s", len ? " " : "", name); 1024 else 1025 len += snprintf(buf + len, PAGE_SIZE - len, 1026 "%sINVALID_BIT(%d)", len ? " " : "", i); 1027 } 1028 if (len) 1029 len += snprintf(buf + len, PAGE_SIZE - len, "\n"); 1030 return len; 1031 } 1032 static DEVICE_ATTR(blacklist, S_IRUGO, sdev_show_blacklist, NULL); 1033 1034 #ifdef CONFIG_SCSI_DH 1035 static ssize_t 1036 sdev_show_dh_state(struct device *dev, struct device_attribute *attr, 1037 char *buf) 1038 { 1039 struct scsi_device *sdev = to_scsi_device(dev); 1040 1041 if (!sdev->handler) 1042 return snprintf(buf, 20, "detached\n"); 1043 1044 return snprintf(buf, 20, "%s\n", sdev->handler->name); 1045 } 1046 1047 static ssize_t 1048 sdev_store_dh_state(struct device *dev, struct device_attribute *attr, 1049 const char *buf, size_t count) 1050 { 1051 struct scsi_device *sdev = to_scsi_device(dev); 1052 int err = -EINVAL; 1053 1054 if (sdev->sdev_state == SDEV_CANCEL || 1055 sdev->sdev_state == SDEV_DEL) 1056 return -ENODEV; 1057 1058 if (!sdev->handler) { 1059 /* 1060 * Attach to a device handler 1061 */ 1062 err = scsi_dh_attach(sdev->request_queue, buf); 1063 } else if (!strncmp(buf, "activate", 8)) { 1064 /* 1065 * Activate a device handler 1066 */ 1067 if (sdev->handler->activate) 1068 err = sdev->handler->activate(sdev, NULL, NULL); 1069 else 1070 err = 0; 1071 } else if (!strncmp(buf, "detach", 6)) { 1072 /* 1073 * Detach from a device handler 1074 */ 1075 sdev_printk(KERN_WARNING, sdev, 1076 "can't detach handler %s.\n", 1077 sdev->handler->name); 1078 err = -EINVAL; 1079 } 1080 1081 return err < 0 ? err : count; 1082 } 1083 1084 static DEVICE_ATTR(dh_state, S_IRUGO | S_IWUSR, sdev_show_dh_state, 1085 sdev_store_dh_state); 1086 1087 static ssize_t 1088 sdev_show_access_state(struct device *dev, 1089 struct device_attribute *attr, 1090 char *buf) 1091 { 1092 struct scsi_device *sdev = to_scsi_device(dev); 1093 unsigned char access_state; 1094 const char *access_state_name; 1095 1096 if (!sdev->handler) 1097 return -EINVAL; 1098 1099 access_state = (sdev->access_state & SCSI_ACCESS_STATE_MASK); 1100 access_state_name = scsi_access_state_name(access_state); 1101 1102 return sprintf(buf, "%s\n", 1103 access_state_name ? access_state_name : "unknown"); 1104 } 1105 static DEVICE_ATTR(access_state, S_IRUGO, sdev_show_access_state, NULL); 1106 1107 static ssize_t 1108 sdev_show_preferred_path(struct device *dev, 1109 struct device_attribute *attr, 1110 char *buf) 1111 { 1112 struct scsi_device *sdev = to_scsi_device(dev); 1113 1114 if (!sdev->handler) 1115 return -EINVAL; 1116 1117 if (sdev->access_state & SCSI_ACCESS_STATE_PREFERRED) 1118 return sprintf(buf, "1\n"); 1119 else 1120 return sprintf(buf, "0\n"); 1121 } 1122 static DEVICE_ATTR(preferred_path, S_IRUGO, sdev_show_preferred_path, NULL); 1123 #endif 1124 1125 static ssize_t 1126 sdev_show_queue_ramp_up_period(struct device *dev, 1127 struct device_attribute *attr, 1128 char *buf) 1129 { 1130 struct scsi_device *sdev; 1131 sdev = to_scsi_device(dev); 1132 return snprintf(buf, 20, "%u\n", 1133 jiffies_to_msecs(sdev->queue_ramp_up_period)); 1134 } 1135 1136 static ssize_t 1137 sdev_store_queue_ramp_up_period(struct device *dev, 1138 struct device_attribute *attr, 1139 const char *buf, size_t count) 1140 { 1141 struct scsi_device *sdev = to_scsi_device(dev); 1142 unsigned int period; 1143 1144 if (kstrtouint(buf, 10, &period)) 1145 return -EINVAL; 1146 1147 sdev->queue_ramp_up_period = msecs_to_jiffies(period); 1148 return count; 1149 } 1150 1151 static DEVICE_ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR, 1152 sdev_show_queue_ramp_up_period, 1153 sdev_store_queue_ramp_up_period); 1154 1155 static umode_t scsi_sdev_attr_is_visible(struct kobject *kobj, 1156 struct attribute *attr, int i) 1157 { 1158 struct device *dev = container_of(kobj, struct device, kobj); 1159 struct scsi_device *sdev = to_scsi_device(dev); 1160 1161 1162 if (attr == &dev_attr_queue_depth.attr && 1163 !sdev->host->hostt->change_queue_depth) 1164 return S_IRUGO; 1165 1166 if (attr == &dev_attr_queue_ramp_up_period.attr && 1167 !sdev->host->hostt->change_queue_depth) 1168 return 0; 1169 1170 #ifdef CONFIG_SCSI_DH 1171 if (attr == &dev_attr_access_state.attr && 1172 !sdev->handler) 1173 return 0; 1174 if (attr == &dev_attr_preferred_path.attr && 1175 !sdev->handler) 1176 return 0; 1177 #endif 1178 return attr->mode; 1179 } 1180 1181 static umode_t scsi_sdev_bin_attr_is_visible(struct kobject *kobj, 1182 struct bin_attribute *attr, int i) 1183 { 1184 struct device *dev = container_of(kobj, struct device, kobj); 1185 struct scsi_device *sdev = to_scsi_device(dev); 1186 1187 1188 if (attr == &dev_attr_vpd_pg80 && !sdev->vpd_pg80) 1189 return 0; 1190 1191 if (attr == &dev_attr_vpd_pg83 && !sdev->vpd_pg83) 1192 return 0; 1193 1194 return S_IRUGO; 1195 } 1196 1197 /* Default template for device attributes. May NOT be modified */ 1198 static struct attribute *scsi_sdev_attrs[] = { 1199 &dev_attr_device_blocked.attr, 1200 &dev_attr_type.attr, 1201 &dev_attr_scsi_level.attr, 1202 &dev_attr_device_busy.attr, 1203 &dev_attr_vendor.attr, 1204 &dev_attr_model.attr, 1205 &dev_attr_rev.attr, 1206 &dev_attr_rescan.attr, 1207 &dev_attr_delete.attr, 1208 &dev_attr_state.attr, 1209 &dev_attr_timeout.attr, 1210 &dev_attr_eh_timeout.attr, 1211 &dev_attr_iocounterbits.attr, 1212 &dev_attr_iorequest_cnt.attr, 1213 &dev_attr_iodone_cnt.attr, 1214 &dev_attr_ioerr_cnt.attr, 1215 &dev_attr_modalias.attr, 1216 &dev_attr_queue_depth.attr, 1217 &dev_attr_queue_type.attr, 1218 &dev_attr_wwid.attr, 1219 &dev_attr_blacklist.attr, 1220 #ifdef CONFIG_SCSI_DH 1221 &dev_attr_dh_state.attr, 1222 &dev_attr_access_state.attr, 1223 &dev_attr_preferred_path.attr, 1224 #endif 1225 &dev_attr_queue_ramp_up_period.attr, 1226 REF_EVT(media_change), 1227 REF_EVT(inquiry_change_reported), 1228 REF_EVT(capacity_change_reported), 1229 REF_EVT(soft_threshold_reached), 1230 REF_EVT(mode_parameter_change_reported), 1231 REF_EVT(lun_change_reported), 1232 NULL 1233 }; 1234 1235 static struct bin_attribute *scsi_sdev_bin_attrs[] = { 1236 &dev_attr_vpd_pg83, 1237 &dev_attr_vpd_pg80, 1238 &dev_attr_inquiry, 1239 NULL 1240 }; 1241 static struct attribute_group scsi_sdev_attr_group = { 1242 .attrs = scsi_sdev_attrs, 1243 .bin_attrs = scsi_sdev_bin_attrs, 1244 .is_visible = scsi_sdev_attr_is_visible, 1245 .is_bin_visible = scsi_sdev_bin_attr_is_visible, 1246 }; 1247 1248 static const struct attribute_group *scsi_sdev_attr_groups[] = { 1249 &scsi_sdev_attr_group, 1250 NULL 1251 }; 1252 1253 static int scsi_target_add(struct scsi_target *starget) 1254 { 1255 int error; 1256 1257 if (starget->state != STARGET_CREATED) 1258 return 0; 1259 1260 error = device_add(&starget->dev); 1261 if (error) { 1262 dev_err(&starget->dev, "target device_add failed, error %d\n", error); 1263 return error; 1264 } 1265 transport_add_device(&starget->dev); 1266 starget->state = STARGET_RUNNING; 1267 1268 pm_runtime_set_active(&starget->dev); 1269 pm_runtime_enable(&starget->dev); 1270 device_enable_async_suspend(&starget->dev); 1271 1272 return 0; 1273 } 1274 1275 /** 1276 * scsi_sysfs_add_sdev - add scsi device to sysfs 1277 * @sdev: scsi_device to add 1278 * 1279 * Return value: 1280 * 0 on Success / non-zero on Failure 1281 **/ 1282 int scsi_sysfs_add_sdev(struct scsi_device *sdev) 1283 { 1284 int error, i; 1285 struct request_queue *rq = sdev->request_queue; 1286 struct scsi_target *starget = sdev->sdev_target; 1287 1288 error = scsi_target_add(starget); 1289 if (error) 1290 return error; 1291 1292 transport_configure_device(&starget->dev); 1293 1294 device_enable_async_suspend(&sdev->sdev_gendev); 1295 scsi_autopm_get_target(starget); 1296 pm_runtime_set_active(&sdev->sdev_gendev); 1297 pm_runtime_forbid(&sdev->sdev_gendev); 1298 pm_runtime_enable(&sdev->sdev_gendev); 1299 scsi_autopm_put_target(starget); 1300 1301 scsi_autopm_get_device(sdev); 1302 1303 scsi_dh_add_device(sdev); 1304 1305 error = device_add(&sdev->sdev_gendev); 1306 if (error) { 1307 sdev_printk(KERN_INFO, sdev, 1308 "failed to add device: %d\n", error); 1309 return error; 1310 } 1311 1312 device_enable_async_suspend(&sdev->sdev_dev); 1313 error = device_add(&sdev->sdev_dev); 1314 if (error) { 1315 sdev_printk(KERN_INFO, sdev, 1316 "failed to add class device: %d\n", error); 1317 device_del(&sdev->sdev_gendev); 1318 return error; 1319 } 1320 transport_add_device(&sdev->sdev_gendev); 1321 sdev->is_visible = 1; 1322 1323 error = bsg_scsi_register_queue(rq, &sdev->sdev_gendev); 1324 if (error) 1325 /* we're treating error on bsg register as non-fatal, 1326 * so pretend nothing went wrong */ 1327 sdev_printk(KERN_INFO, sdev, 1328 "Failed to register bsg queue, errno=%d\n", error); 1329 1330 /* add additional host specific attributes */ 1331 if (sdev->host->hostt->sdev_attrs) { 1332 for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) { 1333 error = device_create_file(&sdev->sdev_gendev, 1334 sdev->host->hostt->sdev_attrs[i]); 1335 if (error) 1336 return error; 1337 } 1338 } 1339 1340 if (sdev->host->hostt->sdev_groups) { 1341 error = sysfs_create_groups(&sdev->sdev_gendev.kobj, 1342 sdev->host->hostt->sdev_groups); 1343 if (error) 1344 return error; 1345 } 1346 1347 scsi_autopm_put_device(sdev); 1348 return error; 1349 } 1350 1351 void __scsi_remove_device(struct scsi_device *sdev) 1352 { 1353 struct device *dev = &sdev->sdev_gendev; 1354 int res; 1355 1356 /* 1357 * This cleanup path is not reentrant and while it is impossible 1358 * to get a new reference with scsi_device_get() someone can still 1359 * hold a previously acquired one. 1360 */ 1361 if (sdev->sdev_state == SDEV_DEL) 1362 return; 1363 1364 if (sdev->is_visible) { 1365 /* 1366 * If scsi_internal_target_block() is running concurrently, 1367 * wait until it has finished before changing the device state. 1368 */ 1369 mutex_lock(&sdev->state_mutex); 1370 /* 1371 * If blocked, we go straight to DEL and restart the queue so 1372 * any commands issued during driver shutdown (like sync 1373 * cache) are errored immediately. 1374 */ 1375 res = scsi_device_set_state(sdev, SDEV_CANCEL); 1376 if (res != 0) { 1377 res = scsi_device_set_state(sdev, SDEV_DEL); 1378 if (res == 0) 1379 scsi_start_queue(sdev); 1380 } 1381 mutex_unlock(&sdev->state_mutex); 1382 1383 if (res != 0) 1384 return; 1385 1386 if (sdev->host->hostt->sdev_groups) 1387 sysfs_remove_groups(&sdev->sdev_gendev.kobj, 1388 sdev->host->hostt->sdev_groups); 1389 1390 bsg_unregister_queue(sdev->request_queue); 1391 device_unregister(&sdev->sdev_dev); 1392 transport_remove_device(dev); 1393 device_del(dev); 1394 } else 1395 put_device(&sdev->sdev_dev); 1396 1397 /* 1398 * Stop accepting new requests and wait until all queuecommand() and 1399 * scsi_run_queue() invocations have finished before tearing down the 1400 * device. 1401 */ 1402 mutex_lock(&sdev->state_mutex); 1403 scsi_device_set_state(sdev, SDEV_DEL); 1404 mutex_unlock(&sdev->state_mutex); 1405 1406 blk_cleanup_queue(sdev->request_queue); 1407 cancel_work_sync(&sdev->requeue_work); 1408 1409 if (sdev->host->hostt->slave_destroy) 1410 sdev->host->hostt->slave_destroy(sdev); 1411 transport_destroy_device(dev); 1412 1413 /* 1414 * Paired with the kref_get() in scsi_sysfs_initialize(). We have 1415 * remoed sysfs visibility from the device, so make the target 1416 * invisible if this was the last device underneath it. 1417 */ 1418 scsi_target_reap(scsi_target(sdev)); 1419 1420 put_device(dev); 1421 } 1422 1423 /** 1424 * scsi_remove_device - unregister a device from the scsi bus 1425 * @sdev: scsi_device to unregister 1426 **/ 1427 void scsi_remove_device(struct scsi_device *sdev) 1428 { 1429 struct Scsi_Host *shost = sdev->host; 1430 1431 mutex_lock(&shost->scan_mutex); 1432 __scsi_remove_device(sdev); 1433 mutex_unlock(&shost->scan_mutex); 1434 } 1435 EXPORT_SYMBOL(scsi_remove_device); 1436 1437 static void __scsi_remove_target(struct scsi_target *starget) 1438 { 1439 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1440 unsigned long flags; 1441 struct scsi_device *sdev; 1442 1443 spin_lock_irqsave(shost->host_lock, flags); 1444 restart: 1445 list_for_each_entry(sdev, &shost->__devices, siblings) { 1446 /* 1447 * We cannot call scsi_device_get() here, as 1448 * we might've been called from rmmod() causing 1449 * scsi_device_get() to fail the module_is_live() 1450 * check. 1451 */ 1452 if (sdev->channel != starget->channel || 1453 sdev->id != starget->id) 1454 continue; 1455 if (sdev->sdev_state == SDEV_DEL || 1456 sdev->sdev_state == SDEV_CANCEL || 1457 !get_device(&sdev->sdev_gendev)) 1458 continue; 1459 spin_unlock_irqrestore(shost->host_lock, flags); 1460 scsi_remove_device(sdev); 1461 put_device(&sdev->sdev_gendev); 1462 spin_lock_irqsave(shost->host_lock, flags); 1463 goto restart; 1464 } 1465 spin_unlock_irqrestore(shost->host_lock, flags); 1466 } 1467 1468 /** 1469 * scsi_remove_target - try to remove a target and all its devices 1470 * @dev: generic starget or parent of generic stargets to be removed 1471 * 1472 * Note: This is slightly racy. It is possible that if the user 1473 * requests the addition of another device then the target won't be 1474 * removed. 1475 */ 1476 void scsi_remove_target(struct device *dev) 1477 { 1478 struct Scsi_Host *shost = dev_to_shost(dev->parent); 1479 struct scsi_target *starget; 1480 unsigned long flags; 1481 1482 restart: 1483 spin_lock_irqsave(shost->host_lock, flags); 1484 list_for_each_entry(starget, &shost->__targets, siblings) { 1485 if (starget->state == STARGET_DEL || 1486 starget->state == STARGET_REMOVE || 1487 starget->state == STARGET_CREATED_REMOVE) 1488 continue; 1489 if (starget->dev.parent == dev || &starget->dev == dev) { 1490 kref_get(&starget->reap_ref); 1491 if (starget->state == STARGET_CREATED) 1492 starget->state = STARGET_CREATED_REMOVE; 1493 else 1494 starget->state = STARGET_REMOVE; 1495 spin_unlock_irqrestore(shost->host_lock, flags); 1496 __scsi_remove_target(starget); 1497 scsi_target_reap(starget); 1498 goto restart; 1499 } 1500 } 1501 spin_unlock_irqrestore(shost->host_lock, flags); 1502 } 1503 EXPORT_SYMBOL(scsi_remove_target); 1504 1505 int scsi_register_driver(struct device_driver *drv) 1506 { 1507 drv->bus = &scsi_bus_type; 1508 1509 return driver_register(drv); 1510 } 1511 EXPORT_SYMBOL(scsi_register_driver); 1512 1513 int scsi_register_interface(struct class_interface *intf) 1514 { 1515 intf->class = &sdev_class; 1516 1517 return class_interface_register(intf); 1518 } 1519 EXPORT_SYMBOL(scsi_register_interface); 1520 1521 /** 1522 * scsi_sysfs_add_host - add scsi host to subsystem 1523 * @shost: scsi host struct to add to subsystem 1524 **/ 1525 int scsi_sysfs_add_host(struct Scsi_Host *shost) 1526 { 1527 int error, i; 1528 1529 /* add host specific attributes */ 1530 if (shost->hostt->shost_attrs) { 1531 for (i = 0; shost->hostt->shost_attrs[i]; i++) { 1532 error = device_create_file(&shost->shost_dev, 1533 shost->hostt->shost_attrs[i]); 1534 if (error) 1535 return error; 1536 } 1537 } 1538 1539 transport_register_device(&shost->shost_gendev); 1540 transport_configure_device(&shost->shost_gendev); 1541 return 0; 1542 } 1543 1544 static struct device_type scsi_dev_type = { 1545 .name = "scsi_device", 1546 .release = scsi_device_dev_release, 1547 .groups = scsi_sdev_attr_groups, 1548 }; 1549 1550 void scsi_sysfs_device_initialize(struct scsi_device *sdev) 1551 { 1552 unsigned long flags; 1553 struct Scsi_Host *shost = sdev->host; 1554 struct scsi_target *starget = sdev->sdev_target; 1555 1556 device_initialize(&sdev->sdev_gendev); 1557 sdev->sdev_gendev.bus = &scsi_bus_type; 1558 sdev->sdev_gendev.type = &scsi_dev_type; 1559 dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%llu", 1560 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun); 1561 1562 device_initialize(&sdev->sdev_dev); 1563 sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev); 1564 sdev->sdev_dev.class = &sdev_class; 1565 dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%llu", 1566 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun); 1567 /* 1568 * Get a default scsi_level from the target (derived from sibling 1569 * devices). This is the best we can do for guessing how to set 1570 * sdev->lun_in_cdb for the initial INQUIRY command. For LUN 0 the 1571 * setting doesn't matter, because all the bits are zero anyway. 1572 * But it does matter for higher LUNs. 1573 */ 1574 sdev->scsi_level = starget->scsi_level; 1575 if (sdev->scsi_level <= SCSI_2 && 1576 sdev->scsi_level != SCSI_UNKNOWN && 1577 !shost->no_scsi2_lun_in_cdb) 1578 sdev->lun_in_cdb = 1; 1579 1580 transport_setup_device(&sdev->sdev_gendev); 1581 spin_lock_irqsave(shost->host_lock, flags); 1582 list_add_tail(&sdev->same_target_siblings, &starget->devices); 1583 list_add_tail(&sdev->siblings, &shost->__devices); 1584 spin_unlock_irqrestore(shost->host_lock, flags); 1585 /* 1586 * device can now only be removed via __scsi_remove_device() so hold 1587 * the target. Target will be held in CREATED state until something 1588 * beneath it becomes visible (in which case it moves to RUNNING) 1589 */ 1590 kref_get(&starget->reap_ref); 1591 } 1592 1593 int scsi_is_sdev_device(const struct device *dev) 1594 { 1595 return dev->type == &scsi_dev_type; 1596 } 1597 EXPORT_SYMBOL(scsi_is_sdev_device); 1598 1599 /* A blank transport template that is used in drivers that don't 1600 * yet implement Transport Attributes */ 1601 struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, }; 1602