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