drivers/scsi/scsi_sysfs.c

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