1701 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * scsi_sysfs.c4 *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 const 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_DH88static 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#endif115 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 overflow125 */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 else151 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 to158 * 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 a171 * 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_t185store_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_t199store_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_t223show_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_t239show_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_t255show_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_t271show_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 else279 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 else291 return 0;292}293 294static ssize_t295store_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 else310 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_t321show_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_t332store_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 else361 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_t382show_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_t390show_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_t397show_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 NULL425};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 NULL434};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 struct scsi_vpd *vpd_pgb7 = NULL;453 unsigned long flags;454 455 might_sleep();456 457 scsi_dh_release_device(sdev);458 459 parent = sdev->sdev_gendev.parent;460 461 spin_lock_irqsave(sdev->host->host_lock, flags);462 list_del(&sdev->siblings);463 list_del(&sdev->same_target_siblings);464 list_del(&sdev->starved_entry);465 spin_unlock_irqrestore(sdev->host->host_lock, flags);466 467 cancel_work_sync(&sdev->event_work);468 469 list_for_each_safe(this, tmp, &sdev->event_list) {470 struct scsi_event *evt;471 472 evt = list_entry(this, struct scsi_event, node);473 list_del(&evt->node);474 kfree(evt);475 }476 477 blk_put_queue(sdev->request_queue);478 /* NULL queue means the device can't be used */479 sdev->request_queue = NULL;480 481 sbitmap_free(&sdev->budget_map);482 483 mutex_lock(&sdev->inquiry_mutex);484 vpd_pg0 = rcu_replace_pointer(sdev->vpd_pg0, vpd_pg0,485 lockdep_is_held(&sdev->inquiry_mutex));486 vpd_pg80 = rcu_replace_pointer(sdev->vpd_pg80, vpd_pg80,487 lockdep_is_held(&sdev->inquiry_mutex));488 vpd_pg83 = rcu_replace_pointer(sdev->vpd_pg83, vpd_pg83,489 lockdep_is_held(&sdev->inquiry_mutex));490 vpd_pg89 = rcu_replace_pointer(sdev->vpd_pg89, vpd_pg89,491 lockdep_is_held(&sdev->inquiry_mutex));492 vpd_pgb0 = rcu_replace_pointer(sdev->vpd_pgb0, vpd_pgb0,493 lockdep_is_held(&sdev->inquiry_mutex));494 vpd_pgb1 = rcu_replace_pointer(sdev->vpd_pgb1, vpd_pgb1,495 lockdep_is_held(&sdev->inquiry_mutex));496 vpd_pgb2 = rcu_replace_pointer(sdev->vpd_pgb2, vpd_pgb2,497 lockdep_is_held(&sdev->inquiry_mutex));498 vpd_pgb7 = rcu_replace_pointer(sdev->vpd_pgb7, vpd_pgb7,499 lockdep_is_held(&sdev->inquiry_mutex));500 mutex_unlock(&sdev->inquiry_mutex);501 502 if (vpd_pg0)503 kfree_rcu(vpd_pg0, rcu);504 if (vpd_pg83)505 kfree_rcu(vpd_pg83, rcu);506 if (vpd_pg80)507 kfree_rcu(vpd_pg80, rcu);508 if (vpd_pg89)509 kfree_rcu(vpd_pg89, rcu);510 if (vpd_pgb0)511 kfree_rcu(vpd_pgb0, rcu);512 if (vpd_pgb1)513 kfree_rcu(vpd_pgb1, rcu);514 if (vpd_pgb2)515 kfree_rcu(vpd_pgb2, rcu);516 if (vpd_pgb7)517 kfree_rcu(vpd_pgb7, rcu);518 kfree(sdev->inquiry);519 kfree(sdev);520 521 if (parent)522 put_device(parent);523}524 525static struct class sdev_class = {526 .name = "scsi_device",527 .dev_release = scsi_device_cls_release,528};529 530/* all probing is done in the individual ->probe routines */531static int scsi_bus_match(struct device *dev, const struct device_driver *gendrv)532{533 struct scsi_device *sdp;534 535 if (dev->type != &scsi_dev_type)536 return 0;537 538 sdp = to_scsi_device(dev);539 if (sdp->no_uld_attach)540 return 0;541 return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;542}543 544static int scsi_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)545{546 const struct scsi_device *sdev;547 548 if (dev->type != &scsi_dev_type)549 return 0;550 551 sdev = to_scsi_device(dev);552 553 add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);554 return 0;555}556 557const struct bus_type scsi_bus_type = {558 .name = "scsi",559 .match = scsi_bus_match,560 .uevent = scsi_bus_uevent,561#ifdef CONFIG_PM562 .pm = &scsi_bus_pm_ops,563#endif564};565 566int scsi_sysfs_register(void)567{568 int error;569 570 error = bus_register(&scsi_bus_type);571 if (!error) {572 error = class_register(&sdev_class);573 if (error)574 bus_unregister(&scsi_bus_type);575 }576 577 return error;578}579 580void scsi_sysfs_unregister(void)581{582 class_unregister(&sdev_class);583 bus_unregister(&scsi_bus_type);584}585 586/*587 * sdev_show_function: macro to create an attr function that can be used to588 * show a non-bit field.589 */590#define sdev_show_function(field, format_string) \591static ssize_t \592sdev_show_##field (struct device *dev, struct device_attribute *attr, \593 char *buf) \594{ \595 struct scsi_device *sdev; \596 sdev = to_scsi_device(dev); \597 return snprintf (buf, 20, format_string, sdev->field); \598} \599 600/*601 * sdev_rd_attr: macro to create a function and attribute variable for a602 * read only field.603 */604#define sdev_rd_attr(field, format_string) \605 sdev_show_function(field, format_string) \606static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);607 608 609/*610 * sdev_rw_attr: create a function and attribute variable for a611 * read/write field.612 */613#define sdev_rw_attr(field, format_string) \614 sdev_show_function(field, format_string) \615 \616static ssize_t \617sdev_store_##field (struct device *dev, struct device_attribute *attr, \618 const char *buf, size_t count) \619{ \620 struct scsi_device *sdev; \621 sdev = to_scsi_device(dev); \622 sscanf (buf, format_string, &sdev->field); \623 return count; \624} \625static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);626 627/* Currently we don't export bit fields, but we might in future,628 * so leave this code in */629#if 0630/*631 * sdev_rd_attr: create a function and attribute variable for a632 * read/write bit field.633 */634#define sdev_rw_attr_bit(field) \635 sdev_show_function(field, "%d\n") \636 \637static ssize_t \638sdev_store_##field (struct device *dev, struct device_attribute *attr, \639 const char *buf, size_t count) \640{ \641 int ret; \642 struct scsi_device *sdev; \643 ret = scsi_sdev_check_buf_bit(buf); \644 if (ret >= 0) { \645 sdev = to_scsi_device(dev); \646 sdev->field = ret; \647 ret = count; \648 } \649 return ret; \650} \651static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);652 653/*654 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",655 * else return -EINVAL.656 */657static int scsi_sdev_check_buf_bit(const char *buf)658{659 if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {660 if (buf[0] == '1')661 return 1;662 else if (buf[0] == '0')663 return 0;664 else665 return -EINVAL;666 } else667 return -EINVAL;668}669#endif670/*671 * Create the actual show/store functions and data structures.672 */673sdev_rd_attr (type, "%d\n");674sdev_rd_attr (scsi_level, "%d\n");675sdev_rd_attr (vendor, "%.8s\n");676sdev_rd_attr (model, "%.16s\n");677sdev_rd_attr (rev, "%.4s\n");678sdev_rd_attr (cdl_supported, "%d\n");679 680static ssize_t681sdev_show_device_busy(struct device *dev, struct device_attribute *attr,682 char *buf)683{684 struct scsi_device *sdev = to_scsi_device(dev);685 return snprintf(buf, 20, "%d\n", scsi_device_busy(sdev));686}687static DEVICE_ATTR(device_busy, S_IRUGO, sdev_show_device_busy, NULL);688 689static ssize_t690sdev_show_device_blocked(struct device *dev, struct device_attribute *attr,691 char *buf)692{693 struct scsi_device *sdev = to_scsi_device(dev);694 return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_blocked));695}696static DEVICE_ATTR(device_blocked, S_IRUGO, sdev_show_device_blocked, NULL);697 698/*699 * TODO: can we make these symlinks to the block layer ones?700 */701static ssize_t702sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)703{704 struct scsi_device *sdev;705 sdev = to_scsi_device(dev);706 return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);707}708 709static ssize_t710sdev_store_timeout (struct device *dev, struct device_attribute *attr,711 const char *buf, size_t count)712{713 struct scsi_device *sdev;714 int timeout;715 sdev = to_scsi_device(dev);716 sscanf (buf, "%d\n", &timeout);717 blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);718 return count;719}720static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);721 722static ssize_t723sdev_show_eh_timeout(struct device *dev, struct device_attribute *attr, char *buf)724{725 struct scsi_device *sdev;726 sdev = to_scsi_device(dev);727 return snprintf(buf, 20, "%u\n", sdev->eh_timeout / HZ);728}729 730static ssize_t731sdev_store_eh_timeout(struct device *dev, struct device_attribute *attr,732 const char *buf, size_t count)733{734 struct scsi_device *sdev;735 unsigned int eh_timeout;736 int err;737 738 if (!capable(CAP_SYS_ADMIN))739 return -EACCES;740 741 sdev = to_scsi_device(dev);742 err = kstrtouint(buf, 10, &eh_timeout);743 if (err)744 return err;745 sdev->eh_timeout = eh_timeout * HZ;746 747 return count;748}749static DEVICE_ATTR(eh_timeout, S_IRUGO | S_IWUSR, sdev_show_eh_timeout, sdev_store_eh_timeout);750 751static ssize_t752store_rescan_field (struct device *dev, struct device_attribute *attr,753 const char *buf, size_t count)754{755 scsi_rescan_device(to_scsi_device(dev));756 return count;757}758static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);759 760static ssize_t761sdev_store_delete(struct device *dev, struct device_attribute *attr,762 const char *buf, size_t count)763{764 struct kernfs_node *kn;765 struct scsi_device *sdev = to_scsi_device(dev);766 767 /*768 * We need to try to get module, avoiding the module been removed769 * during delete.770 */771 if (scsi_device_get(sdev))772 return -ENODEV;773 774 kn = sysfs_break_active_protection(&dev->kobj, &attr->attr);775 WARN_ON_ONCE(!kn);776 /*777 * Concurrent writes into the "delete" sysfs attribute may trigger778 * concurrent calls to device_remove_file() and scsi_remove_device().779 * device_remove_file() handles concurrent removal calls by780 * serializing these and by ignoring the second and later removal781 * attempts. Concurrent calls of scsi_remove_device() are782 * serialized. The second and later calls of scsi_remove_device() are783 * ignored because the first call of that function changes the device784 * state into SDEV_DEL.785 */786 device_remove_file(dev, attr);787 scsi_remove_device(sdev);788 if (kn)789 sysfs_unbreak_active_protection(kn);790 scsi_device_put(sdev);791 return count;792};793static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);794 795static ssize_t796store_state_field(struct device *dev, struct device_attribute *attr,797 const char *buf, size_t count)798{799 int i, ret;800 struct scsi_device *sdev = to_scsi_device(dev);801 enum scsi_device_state state = 0;802 bool rescan_dev = false;803 804 for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {805 const int len = strlen(sdev_states[i].name);806 if (strncmp(sdev_states[i].name, buf, len) == 0 &&807 buf[len] == '\n') {808 state = sdev_states[i].value;809 break;810 }811 }812 switch (state) {813 case SDEV_RUNNING:814 case SDEV_OFFLINE:815 break;816 default:817 return -EINVAL;818 }819 820 mutex_lock(&sdev->state_mutex);821 switch (sdev->sdev_state) {822 case SDEV_RUNNING:823 case SDEV_OFFLINE:824 break;825 default:826 mutex_unlock(&sdev->state_mutex);827 return -EINVAL;828 }829 if (sdev->sdev_state == SDEV_RUNNING && state == SDEV_RUNNING) {830 ret = 0;831 } else {832 ret = scsi_device_set_state(sdev, state);833 if (ret == 0 && state == SDEV_RUNNING)834 rescan_dev = true;835 }836 mutex_unlock(&sdev->state_mutex);837 838 if (rescan_dev) {839 /*840 * If the device state changes to SDEV_RUNNING, we need to841 * run the queue to avoid I/O hang, and rescan the device842 * to revalidate it. Running the queue first is necessary843 * because another thread may be waiting inside844 * blk_mq_freeze_queue_wait() and because that call may be845 * waiting for pending I/O to finish.846 */847 blk_mq_run_hw_queues(sdev->request_queue, true);848 scsi_rescan_device(sdev);849 }850 851 return ret == 0 ? count : -EINVAL;852}853 854static ssize_t855show_state_field(struct device *dev, struct device_attribute *attr, char *buf)856{857 struct scsi_device *sdev = to_scsi_device(dev);858 const char *name = scsi_device_state_name(sdev->sdev_state);859 860 if (!name)861 return -EINVAL;862 863 return snprintf(buf, 20, "%s\n", name);864}865 866static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);867 868static ssize_t869show_queue_type_field(struct device *dev, struct device_attribute *attr,870 char *buf)871{872 struct scsi_device *sdev = to_scsi_device(dev);873 const char *name = "none";874 875 if (sdev->simple_tags)876 name = "simple";877 878 return snprintf(buf, 20, "%s\n", name);879}880 881static ssize_t882store_queue_type_field(struct device *dev, struct device_attribute *attr,883 const char *buf, size_t count)884{885 struct scsi_device *sdev = to_scsi_device(dev);886 887 if (!sdev->tagged_supported)888 return -EINVAL;889 890 sdev_printk(KERN_INFO, sdev,891 "ignoring write to deprecated queue_type attribute");892 return count;893}894 895static DEVICE_ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,896 store_queue_type_field);897 898#define sdev_vpd_pg_attr(_page) \899static ssize_t \900show_vpd_##_page(struct file *filp, struct kobject *kobj, \901 struct bin_attribute *bin_attr, \902 char *buf, loff_t off, size_t count) \903{ \904 struct device *dev = kobj_to_dev(kobj); \905 struct scsi_device *sdev = to_scsi_device(dev); \906 struct scsi_vpd *vpd_page; \907 int ret = -EINVAL; \908 \909 rcu_read_lock(); \910 vpd_page = rcu_dereference(sdev->vpd_##_page); \911 if (vpd_page) \912 ret = memory_read_from_buffer(buf, count, &off, \913 vpd_page->data, vpd_page->len); \914 rcu_read_unlock(); \915 return ret; \916} \917static struct bin_attribute dev_attr_vpd_##_page = { \918 .attr = {.name = __stringify(vpd_##_page), .mode = S_IRUGO }, \919 .size = 0, \920 .read = show_vpd_##_page, \921};922 923sdev_vpd_pg_attr(pg83);924sdev_vpd_pg_attr(pg80);925sdev_vpd_pg_attr(pg89);926sdev_vpd_pg_attr(pgb0);927sdev_vpd_pg_attr(pgb1);928sdev_vpd_pg_attr(pgb2);929sdev_vpd_pg_attr(pgb7);930sdev_vpd_pg_attr(pg0);931 932static ssize_t show_inquiry(struct file *filep, struct kobject *kobj,933 struct bin_attribute *bin_attr,934 char *buf, loff_t off, size_t count)935{936 struct device *dev = kobj_to_dev(kobj);937 struct scsi_device *sdev = to_scsi_device(dev);938 939 if (!sdev->inquiry)940 return -EINVAL;941 942 return memory_read_from_buffer(buf, count, &off, sdev->inquiry,943 sdev->inquiry_len);944}945 946static struct bin_attribute dev_attr_inquiry = {947 .attr = {948 .name = "inquiry",949 .mode = S_IRUGO,950 },951 .size = 0,952 .read = show_inquiry,953};954 955static ssize_t956show_iostat_counterbits(struct device *dev, struct device_attribute *attr,957 char *buf)958{959 return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);960}961 962static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);963 964#define show_sdev_iostat(field) \965static ssize_t \966show_iostat_##field(struct device *dev, struct device_attribute *attr, \967 char *buf) \968{ \969 struct scsi_device *sdev = to_scsi_device(dev); \970 unsigned long long count = atomic_read(&sdev->field); \971 return snprintf(buf, 20, "0x%llx\n", count); \972} \973static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)974 975show_sdev_iostat(iorequest_cnt);976show_sdev_iostat(iodone_cnt);977show_sdev_iostat(ioerr_cnt);978show_sdev_iostat(iotmo_cnt);979 980static ssize_t981sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)982{983 struct scsi_device *sdev;984 sdev = to_scsi_device(dev);985 return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);986}987static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);988 989#define DECLARE_EVT_SHOW(name, Cap_name) \990static ssize_t \991sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \992 char *buf) \993{ \994 struct scsi_device *sdev = to_scsi_device(dev); \995 int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\996 return snprintf(buf, 20, "%d\n", val); \997}998 999#define DECLARE_EVT_STORE(name, Cap_name) \1000static ssize_t \1001sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\1002 const char *buf, size_t count) \1003{ \1004 struct scsi_device *sdev = to_scsi_device(dev); \1005 int val = simple_strtoul(buf, NULL, 0); \1006 if (val == 0) \1007 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \1008 else if (val == 1) \1009 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \1010 else \1011 return -EINVAL; \1012 return count; \1013}1014 1015#define DECLARE_EVT(name, Cap_name) \1016 DECLARE_EVT_SHOW(name, Cap_name) \1017 DECLARE_EVT_STORE(name, Cap_name) \1018 static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name, \1019 sdev_store_evt_##name);1020#define REF_EVT(name) &dev_attr_evt_##name.attr1021 1022DECLARE_EVT(media_change, MEDIA_CHANGE)1023DECLARE_EVT(inquiry_change_reported, INQUIRY_CHANGE_REPORTED)1024DECLARE_EVT(capacity_change_reported, CAPACITY_CHANGE_REPORTED)1025DECLARE_EVT(soft_threshold_reached, SOFT_THRESHOLD_REACHED_REPORTED)1026DECLARE_EVT(mode_parameter_change_reported, MODE_PARAMETER_CHANGE_REPORTED)1027DECLARE_EVT(lun_change_reported, LUN_CHANGE_REPORTED)1028 1029static ssize_t1030sdev_store_queue_depth(struct device *dev, struct device_attribute *attr,1031 const char *buf, size_t count)1032{1033 int depth, retval;1034 struct scsi_device *sdev = to_scsi_device(dev);1035 const struct scsi_host_template *sht = sdev->host->hostt;1036 1037 if (!sht->change_queue_depth)1038 return -EINVAL;1039 1040 depth = simple_strtoul(buf, NULL, 0);1041 1042 if (depth < 1 || depth > sdev->host->can_queue)1043 return -EINVAL;1044 1045 retval = sht->change_queue_depth(sdev, depth);1046 if (retval < 0)1047 return retval;1048 1049 sdev->max_queue_depth = sdev->queue_depth;1050 1051 return count;1052}1053sdev_show_function(queue_depth, "%d\n");1054 1055static DEVICE_ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,1056 sdev_store_queue_depth);1057 1058static ssize_t1059sdev_show_wwid(struct device *dev, struct device_attribute *attr,1060 char *buf)1061{1062 struct scsi_device *sdev = to_scsi_device(dev);1063 ssize_t count;1064 1065 count = scsi_vpd_lun_id(sdev, buf, PAGE_SIZE);1066 if (count > 0) {1067 buf[count] = '\n';1068 count++;1069 }1070 return count;1071}1072static DEVICE_ATTR(wwid, S_IRUGO, sdev_show_wwid, NULL);1073 1074#define BLIST_FLAG_NAME(name) \1075 [const_ilog2((__force __u64)BLIST_##name)] = #name1076static const char *const sdev_bflags_name[] = {1077#include "scsi_devinfo_tbl.c"1078};1079#undef BLIST_FLAG_NAME1080 1081static ssize_t1082sdev_show_blacklist(struct device *dev, struct device_attribute *attr,1083 char *buf)1084{1085 struct scsi_device *sdev = to_scsi_device(dev);1086 int i;1087 ssize_t len = 0;1088 1089 for (i = 0; i < sizeof(sdev->sdev_bflags) * BITS_PER_BYTE; i++) {1090 const char *name = NULL;1091 1092 if (!(sdev->sdev_bflags & (__force blist_flags_t)BIT(i)))1093 continue;1094 if (i < ARRAY_SIZE(sdev_bflags_name) && sdev_bflags_name[i])1095 name = sdev_bflags_name[i];1096 1097 if (name)1098 len += scnprintf(buf + len, PAGE_SIZE - len,1099 "%s%s", len ? " " : "", name);1100 else1101 len += scnprintf(buf + len, PAGE_SIZE - len,1102 "%sINVALID_BIT(%d)", len ? " " : "", i);1103 }1104 if (len)1105 len += scnprintf(buf + len, PAGE_SIZE - len, "\n");1106 return len;1107}1108static DEVICE_ATTR(blacklist, S_IRUGO, sdev_show_blacklist, NULL);1109 1110#ifdef CONFIG_SCSI_DH1111static ssize_t1112sdev_show_dh_state(struct device *dev, struct device_attribute *attr,1113 char *buf)1114{1115 struct scsi_device *sdev = to_scsi_device(dev);1116 1117 if (!sdev->handler)1118 return snprintf(buf, 20, "detached\n");1119 1120 return snprintf(buf, 20, "%s\n", sdev->handler->name);1121}1122 1123static ssize_t1124sdev_store_dh_state(struct device *dev, struct device_attribute *attr,1125 const char *buf, size_t count)1126{1127 struct scsi_device *sdev = to_scsi_device(dev);1128 int err = -EINVAL;1129 1130 if (sdev->sdev_state == SDEV_CANCEL ||1131 sdev->sdev_state == SDEV_DEL)1132 return -ENODEV;1133 1134 if (!sdev->handler) {1135 /*1136 * Attach to a device handler1137 */1138 err = scsi_dh_attach(sdev->request_queue, buf);1139 } else if (!strncmp(buf, "activate", 8)) {1140 /*1141 * Activate a device handler1142 */1143 if (sdev->handler->activate)1144 err = sdev->handler->activate(sdev, NULL, NULL);1145 else1146 err = 0;1147 } else if (!strncmp(buf, "detach", 6)) {1148 /*1149 * Detach from a device handler1150 */1151 sdev_printk(KERN_WARNING, sdev,1152 "can't detach handler %s.\n",1153 sdev->handler->name);1154 err = -EINVAL;1155 }1156 1157 return err < 0 ? err : count;1158}1159 1160static DEVICE_ATTR(dh_state, S_IRUGO | S_IWUSR, sdev_show_dh_state,1161 sdev_store_dh_state);1162 1163static ssize_t1164sdev_show_access_state(struct device *dev,1165 struct device_attribute *attr,1166 char *buf)1167{1168 struct scsi_device *sdev = to_scsi_device(dev);1169 unsigned char access_state;1170 const char *access_state_name;1171 1172 if (!sdev->handler)1173 return -EINVAL;1174 1175 access_state = (sdev->access_state & SCSI_ACCESS_STATE_MASK);1176 access_state_name = scsi_access_state_name(access_state);1177 1178 return sprintf(buf, "%s\n",1179 access_state_name ? access_state_name : "unknown");1180}1181static DEVICE_ATTR(access_state, S_IRUGO, sdev_show_access_state, NULL);1182 1183static ssize_t1184sdev_show_preferred_path(struct device *dev,1185 struct device_attribute *attr,1186 char *buf)1187{1188 struct scsi_device *sdev = to_scsi_device(dev);1189 1190 if (!sdev->handler)1191 return -EINVAL;1192 1193 if (sdev->access_state & SCSI_ACCESS_STATE_PREFERRED)1194 return sprintf(buf, "1\n");1195 else1196 return sprintf(buf, "0\n");1197}1198static DEVICE_ATTR(preferred_path, S_IRUGO, sdev_show_preferred_path, NULL);1199#endif1200 1201static ssize_t1202sdev_show_queue_ramp_up_period(struct device *dev,1203 struct device_attribute *attr,1204 char *buf)1205{1206 struct scsi_device *sdev;1207 sdev = to_scsi_device(dev);1208 return snprintf(buf, 20, "%u\n",1209 jiffies_to_msecs(sdev->queue_ramp_up_period));1210}1211 1212static ssize_t1213sdev_store_queue_ramp_up_period(struct device *dev,1214 struct device_attribute *attr,1215 const char *buf, size_t count)1216{1217 struct scsi_device *sdev = to_scsi_device(dev);1218 unsigned int period;1219 1220 if (kstrtouint(buf, 10, &period))1221 return -EINVAL;1222 1223 sdev->queue_ramp_up_period = msecs_to_jiffies(period);1224 return count;1225}1226 1227static DEVICE_ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,1228 sdev_show_queue_ramp_up_period,1229 sdev_store_queue_ramp_up_period);1230 1231static ssize_t sdev_show_cdl_enable(struct device *dev,1232 struct device_attribute *attr, char *buf)1233{1234 struct scsi_device *sdev = to_scsi_device(dev);1235 1236 return sysfs_emit(buf, "%d\n", (int)sdev->cdl_enable);1237}1238 1239static ssize_t sdev_store_cdl_enable(struct device *dev,1240 struct device_attribute *attr,1241 const char *buf, size_t count)1242{1243 int ret;1244 bool v;1245 1246 if (kstrtobool(buf, &v))1247 return -EINVAL;1248 1249 ret = scsi_cdl_enable(to_scsi_device(dev), v);1250 if (ret)1251 return ret;1252 1253 return count;1254}1255static DEVICE_ATTR(cdl_enable, S_IRUGO | S_IWUSR,1256 sdev_show_cdl_enable, sdev_store_cdl_enable);1257 1258static umode_t scsi_sdev_attr_is_visible(struct kobject *kobj,1259 struct attribute *attr, int i)1260{1261 struct device *dev = kobj_to_dev(kobj);1262 struct scsi_device *sdev = to_scsi_device(dev);1263 1264 1265 if (attr == &dev_attr_queue_depth.attr &&1266 !sdev->host->hostt->change_queue_depth)1267 return S_IRUGO;1268 1269 if (attr == &dev_attr_queue_ramp_up_period.attr &&1270 !sdev->host->hostt->change_queue_depth)1271 return 0;1272 1273 return attr->mode;1274}1275 1276static umode_t scsi_sdev_bin_attr_is_visible(struct kobject *kobj,1277 struct bin_attribute *attr, int i)1278{1279 struct device *dev = kobj_to_dev(kobj);1280 struct scsi_device *sdev = to_scsi_device(dev);1281 1282 1283 if (attr == &dev_attr_vpd_pg0 && !sdev->vpd_pg0)1284 return 0;1285 1286 if (attr == &dev_attr_vpd_pg80 && !sdev->vpd_pg80)1287 return 0;1288 1289 if (attr == &dev_attr_vpd_pg83 && !sdev->vpd_pg83)1290 return 0;1291 1292 if (attr == &dev_attr_vpd_pg89 && !sdev->vpd_pg89)1293 return 0;1294 1295 if (attr == &dev_attr_vpd_pgb0 && !sdev->vpd_pgb0)1296 return 0;1297 1298 if (attr == &dev_attr_vpd_pgb1 && !sdev->vpd_pgb1)1299 return 0;1300 1301 if (attr == &dev_attr_vpd_pgb2 && !sdev->vpd_pgb2)1302 return 0;1303 1304 if (attr == &dev_attr_vpd_pgb7 && !sdev->vpd_pgb7)1305 return 0;1306 1307 return S_IRUGO;1308}1309 1310/* Default template for device attributes. May NOT be modified */1311static struct attribute *scsi_sdev_attrs[] = {1312 &dev_attr_device_blocked.attr,1313 &dev_attr_type.attr,1314 &dev_attr_scsi_level.attr,1315 &dev_attr_device_busy.attr,1316 &dev_attr_vendor.attr,1317 &dev_attr_model.attr,1318 &dev_attr_rev.attr,1319 &dev_attr_rescan.attr,1320 &dev_attr_delete.attr,1321 &dev_attr_state.attr,1322 &dev_attr_timeout.attr,1323 &dev_attr_eh_timeout.attr,1324 &dev_attr_iocounterbits.attr,1325 &dev_attr_iorequest_cnt.attr,1326 &dev_attr_iodone_cnt.attr,1327 &dev_attr_ioerr_cnt.attr,1328 &dev_attr_iotmo_cnt.attr,1329 &dev_attr_modalias.attr,1330 &dev_attr_queue_depth.attr,1331 &dev_attr_queue_type.attr,1332 &dev_attr_wwid.attr,1333 &dev_attr_blacklist.attr,1334#ifdef CONFIG_SCSI_DH1335 &dev_attr_dh_state.attr,1336 &dev_attr_access_state.attr,1337 &dev_attr_preferred_path.attr,1338#endif1339 &dev_attr_queue_ramp_up_period.attr,1340 &dev_attr_cdl_supported.attr,1341 &dev_attr_cdl_enable.attr,1342 REF_EVT(media_change),1343 REF_EVT(inquiry_change_reported),1344 REF_EVT(capacity_change_reported),1345 REF_EVT(soft_threshold_reached),1346 REF_EVT(mode_parameter_change_reported),1347 REF_EVT(lun_change_reported),1348 NULL1349};1350 1351static struct bin_attribute *scsi_sdev_bin_attrs[] = {1352 &dev_attr_vpd_pg0,1353 &dev_attr_vpd_pg83,1354 &dev_attr_vpd_pg80,1355 &dev_attr_vpd_pg89,1356 &dev_attr_vpd_pgb0,1357 &dev_attr_vpd_pgb1,1358 &dev_attr_vpd_pgb2,1359 &dev_attr_vpd_pgb7,1360 &dev_attr_inquiry,1361 NULL1362};1363static struct attribute_group scsi_sdev_attr_group = {1364 .attrs = scsi_sdev_attrs,1365 .bin_attrs = scsi_sdev_bin_attrs,1366 .is_visible = scsi_sdev_attr_is_visible,1367 .is_bin_visible = scsi_sdev_bin_attr_is_visible,1368};1369 1370static const struct attribute_group *scsi_sdev_attr_groups[] = {1371 &scsi_sdev_attr_group,1372 NULL1373};1374 1375static int scsi_target_add(struct scsi_target *starget)1376{1377 int error;1378 1379 if (starget->state != STARGET_CREATED)1380 return 0;1381 1382 error = device_add(&starget->dev);1383 if (error) {1384 dev_err(&starget->dev, "target device_add failed, error %d\n", error);1385 return error;1386 }1387 transport_add_device(&starget->dev);1388 starget->state = STARGET_RUNNING;1389 1390 pm_runtime_set_active(&starget->dev);1391 pm_runtime_enable(&starget->dev);1392 device_enable_async_suspend(&starget->dev);1393 1394 return 0;1395}1396 1397/**1398 * scsi_sysfs_add_sdev - add scsi device to sysfs1399 * @sdev: scsi_device to add1400 *1401 * Return value:1402 * 0 on Success / non-zero on Failure1403 **/1404int scsi_sysfs_add_sdev(struct scsi_device *sdev)1405{1406 int error;1407 struct scsi_target *starget = sdev->sdev_target;1408 1409 error = scsi_target_add(starget);1410 if (error)1411 return error;1412 1413 transport_configure_device(&starget->dev);1414 1415 device_enable_async_suspend(&sdev->sdev_gendev);1416 scsi_autopm_get_target(starget);1417 pm_runtime_set_active(&sdev->sdev_gendev);1418 if (!sdev->rpm_autosuspend)1419 pm_runtime_forbid(&sdev->sdev_gendev);1420 pm_runtime_enable(&sdev->sdev_gendev);1421 scsi_autopm_put_target(starget);1422 1423 scsi_autopm_get_device(sdev);1424 1425 scsi_dh_add_device(sdev);1426 1427 error = device_add(&sdev->sdev_gendev);1428 if (error) {1429 sdev_printk(KERN_INFO, sdev,1430 "failed to add device: %d\n", error);1431 return error;1432 }1433 1434 device_enable_async_suspend(&sdev->sdev_dev);1435 error = device_add(&sdev->sdev_dev);1436 if (error) {1437 sdev_printk(KERN_INFO, sdev,1438 "failed to add class device: %d\n", error);1439 device_del(&sdev->sdev_gendev);1440 return error;1441 }1442 transport_add_device(&sdev->sdev_gendev);1443 sdev->is_visible = 1;1444 1445 if (IS_ENABLED(CONFIG_BLK_DEV_BSG)) {1446 sdev->bsg_dev = scsi_bsg_register_queue(sdev);1447 if (IS_ERR(sdev->bsg_dev)) {1448 error = PTR_ERR(sdev->bsg_dev);1449 sdev_printk(KERN_INFO, sdev,1450 "Failed to register bsg queue, errno=%d\n",1451 error);1452 sdev->bsg_dev = NULL;1453 }1454 }1455 1456 scsi_autopm_put_device(sdev);1457 return error;1458}1459 1460void __scsi_remove_device(struct scsi_device *sdev)1461{1462 struct device *dev = &sdev->sdev_gendev;1463 int res;1464 1465 /*1466 * This cleanup path is not reentrant and while it is impossible1467 * to get a new reference with scsi_device_get() someone can still1468 * hold a previously acquired one.1469 */1470 if (sdev->sdev_state == SDEV_DEL)1471 return;1472 1473 if (sdev->is_visible) {1474 /*1475 * If scsi_internal_target_block() is running concurrently,1476 * wait until it has finished before changing the device state.1477 */1478 mutex_lock(&sdev->state_mutex);1479 /*1480 * If blocked, we go straight to DEL and restart the queue so1481 * any commands issued during driver shutdown (like sync1482 * cache) are errored immediately.1483 */1484 res = scsi_device_set_state(sdev, SDEV_CANCEL);1485 if (res != 0) {1486 res = scsi_device_set_state(sdev, SDEV_DEL);1487 if (res == 0)1488 scsi_start_queue(sdev);1489 }1490 mutex_unlock(&sdev->state_mutex);1491 1492 if (res != 0)1493 return;1494 1495 if (IS_ENABLED(CONFIG_BLK_DEV_BSG) && sdev->bsg_dev)1496 bsg_unregister_queue(sdev->bsg_dev);1497 device_unregister(&sdev->sdev_dev);1498 transport_remove_device(dev);1499 device_del(dev);1500 } else1501 put_device(&sdev->sdev_dev);1502 1503 /*1504 * Stop accepting new requests and wait until all queuecommand() and1505 * scsi_run_queue() invocations have finished before tearing down the1506 * device.1507 */1508 mutex_lock(&sdev->state_mutex);1509 scsi_device_set_state(sdev, SDEV_DEL);1510 mutex_unlock(&sdev->state_mutex);1511 1512 blk_mq_destroy_queue(sdev->request_queue);1513 kref_put(&sdev->host->tagset_refcnt, scsi_mq_free_tags);1514 cancel_work_sync(&sdev->requeue_work);1515 1516 if (sdev->host->hostt->slave_destroy)1517 sdev->host->hostt->slave_destroy(sdev);1518 transport_destroy_device(dev);1519 1520 /*1521 * Paired with the kref_get() in scsi_sysfs_initialize(). We have1522 * removed sysfs visibility from the device, so make the target1523 * invisible if this was the last device underneath it.1524 */1525 scsi_target_reap(scsi_target(sdev));1526 1527 put_device(dev);1528}1529 1530/**1531 * scsi_remove_device - unregister a device from the scsi bus1532 * @sdev: scsi_device to unregister1533 **/1534void scsi_remove_device(struct scsi_device *sdev)1535{1536 struct Scsi_Host *shost = sdev->host;1537 1538 mutex_lock(&shost->scan_mutex);1539 __scsi_remove_device(sdev);1540 mutex_unlock(&shost->scan_mutex);1541}1542EXPORT_SYMBOL(scsi_remove_device);1543 1544static void __scsi_remove_target(struct scsi_target *starget)1545{1546 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);1547 unsigned long flags;1548 struct scsi_device *sdev;1549 1550 spin_lock_irqsave(shost->host_lock, flags);1551 restart:1552 list_for_each_entry(sdev, &shost->__devices, siblings) {1553 /*1554 * We cannot call scsi_device_get() here, as1555 * we might've been called from rmmod() causing1556 * scsi_device_get() to fail the module_is_live()1557 * check.1558 */1559 if (sdev->channel != starget->channel ||1560 sdev->id != starget->id)1561 continue;1562 if (sdev->sdev_state == SDEV_DEL ||1563 sdev->sdev_state == SDEV_CANCEL ||1564 !get_device(&sdev->sdev_gendev))1565 continue;1566 spin_unlock_irqrestore(shost->host_lock, flags);1567 scsi_remove_device(sdev);1568 put_device(&sdev->sdev_gendev);1569 spin_lock_irqsave(shost->host_lock, flags);1570 goto restart;1571 }1572 spin_unlock_irqrestore(shost->host_lock, flags);1573}1574 1575/**1576 * scsi_remove_target - try to remove a target and all its devices1577 * @dev: generic starget or parent of generic stargets to be removed1578 *1579 * Note: This is slightly racy. It is possible that if the user1580 * requests the addition of another device then the target won't be1581 * removed.1582 */1583void scsi_remove_target(struct device *dev)1584{1585 struct Scsi_Host *shost = dev_to_shost(dev->parent);1586 struct scsi_target *starget;1587 unsigned long flags;1588 1589restart:1590 spin_lock_irqsave(shost->host_lock, flags);1591 list_for_each_entry(starget, &shost->__targets, siblings) {1592 if (starget->state == STARGET_DEL ||1593 starget->state == STARGET_REMOVE ||1594 starget->state == STARGET_CREATED_REMOVE)1595 continue;1596 if (starget->dev.parent == dev || &starget->dev == dev) {1597 kref_get(&starget->reap_ref);1598 if (starget->state == STARGET_CREATED)1599 starget->state = STARGET_CREATED_REMOVE;1600 else1601 starget->state = STARGET_REMOVE;1602 spin_unlock_irqrestore(shost->host_lock, flags);1603 __scsi_remove_target(starget);1604 scsi_target_reap(starget);1605 goto restart;1606 }1607 }1608 spin_unlock_irqrestore(shost->host_lock, flags);1609}1610EXPORT_SYMBOL(scsi_remove_target);1611 1612int __scsi_register_driver(struct device_driver *drv, struct module *owner)1613{1614 drv->bus = &scsi_bus_type;1615 drv->owner = owner;1616 1617 return driver_register(drv);1618}1619EXPORT_SYMBOL(__scsi_register_driver);1620 1621int scsi_register_interface(struct class_interface *intf)1622{1623 intf->class = &sdev_class;1624 1625 return class_interface_register(intf);1626}1627EXPORT_SYMBOL(scsi_register_interface);1628 1629/**1630 * scsi_sysfs_add_host - add scsi host to subsystem1631 * @shost: scsi host struct to add to subsystem1632 **/1633int scsi_sysfs_add_host(struct Scsi_Host *shost)1634{1635 transport_register_device(&shost->shost_gendev);1636 transport_configure_device(&shost->shost_gendev);1637 return 0;1638}1639 1640static const struct device_type scsi_dev_type = {1641 .name = "scsi_device",1642 .release = scsi_device_dev_release,1643 .groups = scsi_sdev_attr_groups,1644};1645 1646void scsi_sysfs_device_initialize(struct scsi_device *sdev)1647{1648 unsigned long flags;1649 struct Scsi_Host *shost = sdev->host;1650 const struct scsi_host_template *hostt = shost->hostt;1651 struct scsi_target *starget = sdev->sdev_target;1652 1653 device_initialize(&sdev->sdev_gendev);1654 sdev->sdev_gendev.bus = &scsi_bus_type;1655 sdev->sdev_gendev.type = &scsi_dev_type;1656 scsi_enable_async_suspend(&sdev->sdev_gendev);1657 dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%llu",1658 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);1659 sdev->sdev_gendev.groups = hostt->sdev_groups;1660 1661 device_initialize(&sdev->sdev_dev);1662 sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev);1663 sdev->sdev_dev.class = &sdev_class;1664 dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%llu",1665 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);1666 /*1667 * Get a default scsi_level from the target (derived from sibling1668 * devices). This is the best we can do for guessing how to set1669 * sdev->lun_in_cdb for the initial INQUIRY command. For LUN 0 the1670 * setting doesn't matter, because all the bits are zero anyway.1671 * But it does matter for higher LUNs.1672 */1673 sdev->scsi_level = starget->scsi_level;1674 if (sdev->scsi_level <= SCSI_2 &&1675 sdev->scsi_level != SCSI_UNKNOWN &&1676 !shost->no_scsi2_lun_in_cdb)1677 sdev->lun_in_cdb = 1;1678 1679 transport_setup_device(&sdev->sdev_gendev);1680 spin_lock_irqsave(shost->host_lock, flags);1681 list_add_tail(&sdev->same_target_siblings, &starget->devices);1682 list_add_tail(&sdev->siblings, &shost->__devices);1683 spin_unlock_irqrestore(shost->host_lock, flags);1684 /*1685 * device can now only be removed via __scsi_remove_device() so hold1686 * the target. Target will be held in CREATED state until something1687 * beneath it becomes visible (in which case it moves to RUNNING)1688 */1689 kref_get(&starget->reap_ref);1690}1691 1692int scsi_is_sdev_device(const struct device *dev)1693{1694 return dev->type == &scsi_dev_type;1695}1696EXPORT_SYMBOL(scsi_is_sdev_device);1697 1698/* A blank transport template that is used in drivers that don't1699 * yet implement Transport Attributes */1700struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };1701