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