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_transport.h>
  21 #include <scsi/scsi_driver.h>
  22
  23 #include "scsi_priv.h"
  24 #include "scsi_logging.h"
  25
  26 static struct device_type scsi_dev_type;
  27
  28 static const struct {
  29         enum scsi_device_state  value;
  30         char                    *name;
  31 } sdev_states[] = {
  32         { SDEV_CREATED, "created" },
  33         { SDEV_RUNNING, "running" },
  34         { SDEV_CANCEL, "cancel" },
  35         { SDEV_DEL, "deleted" },
  36         { SDEV_QUIESCE, "quiesce" },
  37         { SDEV_OFFLINE, "offline" },
  38         { SDEV_BLOCK,   "blocked" },
  39         { SDEV_CREATED_BLOCK, "created-blocked" },
  40 };
  41
  42 const char *scsi_device_state_name(enum scsi_device_state state)
  43 {
  44         int i;
  45         char *name = NULL;
  46
  47         for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
  48                 if (sdev_states[i].value == state) {
  49                         name = sdev_states[i].name;
  50                         break;
  51                 }
  52         }
  53         return name;
  54 }
  55
  56 static const struct {
  57         enum scsi_host_state    value;
  58         char                    *name;
  59 } shost_states[] = {
  60         { SHOST_CREATED, "created" },
  61         { SHOST_RUNNING, "running" },
  62         { SHOST_CANCEL, "cancel" },
  63         { SHOST_DEL, "deleted" },
  64         { SHOST_RECOVERY, "recovery" },
  65         { SHOST_CANCEL_RECOVERY, "cancel/recovery" },
  66         { SHOST_DEL_RECOVERY, "deleted/recovery", },
  67 };
  68 const char *scsi_host_state_name(enum scsi_host_state state)
  69 {
  70         int i;
  71         char *name = NULL;
  72
  73         for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
  74                 if (shost_states[i].value == state) {
  75                         name = shost_states[i].name;
  76                         break;
  77                 }
  78         }
  79         return name;
  80 }
  81
  82 static int check_set(unsigned int *val, char *src)
  83 {
  84         char *last;
  85
  86         if (strncmp(src, "-", 20) == 0) {
  87                 *val = SCAN_WILD_CARD;
  88         } else {
  89                 /*
  90                  * Doesn't check for int overflow
  91                  */
  92                 *val = simple_strtoul(src, &last, 0);
  93                 if (*last != '\0')
  94                         return 1;
  95         }
  96         return 0;
  97 }
  98
  99 static int scsi_scan(struct Scsi_Host *shost, const char *str)
 100 {
 101         char s1[15], s2[15], s3[15], junk;
 102         unsigned int channel, id, lun;
 103         int res;
 104
 105         res = sscanf(str, "%10s %10s %10s %c", s1, s2, s3, &junk);
 106         if (res != 3)
 107                 return -EINVAL;
 108         if (check_set(&channel, s1))
 109                 return -EINVAL;
 110         if (check_set(&id, s2))
 111                 return -EINVAL;
 112         if (check_set(&lun, s3))
 113                 return -EINVAL;
 114         if (shost->transportt->user_scan)
 115                 res = shost->transportt->user_scan(shost, channel, id, lun);
 116         else
 117                 res = scsi_scan_host_selected(shost, channel, id, lun, 1);
 118         return res;
 119 }
 120
 121 /*
 122  * shost_show_function: macro to create an attr function that can be used to
 123  * show a non-bit field.
 124  */
 125 #define shost_show_function(name, field, format_string)                 \
 126 static ssize_t                                                          \
 127 show_##name (struct device *dev, struct device_attribute *attr,         \
 128              char *buf)                                                 \
 129 {                                                                       \
 130         struct Scsi_Host *shost = class_to_shost(dev);                  \
 131         return snprintf (buf, 20, format_string, shost->field);         \
 132 }
 133
 134 /*
 135  * shost_rd_attr: macro to create a function and attribute variable for a
 136  * read only field.
 137  */
 138 #define shost_rd_attr2(name, field, format_string)                      \
 139         shost_show_function(name, field, format_string)                 \
 140 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
 141
 142 #define shost_rd_attr(field, format_string) \
 143 shost_rd_attr2(field, field, format_string)
 144
 145 /*
 146  * Create the actual show/store functions and data structures.
 147  */
 148
 149 static ssize_t
 150 store_scan(struct device *dev, struct device_attribute *attr,
 151            const char *buf, size_t count)
 152 {
 153         struct Scsi_Host *shost = class_to_shost(dev);
 154         int res;
 155
 156         res = scsi_scan(shost, buf);
 157         if (res == 0)
 158                 res = count;
 159         return res;
 160 };
 161 static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
 162
 163 static ssize_t
 164 store_shost_state(struct device *dev, struct device_attribute *attr,
 165                   const char *buf, size_t count)
 166 {
 167         int i;
 168         struct Scsi_Host *shost = class_to_shost(dev);
 169         enum scsi_host_state state = 0;
 170
 171         for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
 172                 const int len = strlen(shost_states[i].name);
 173                 if (strncmp(shost_states[i].name, buf, len) == 0 &&
 174                    buf[len] == '\n') {
 175                         state = shost_states[i].value;
 176                         break;
 177                 }
 178         }
 179         if (!state)
 180                 return -EINVAL;
 181
 182         if (scsi_host_set_state(shost, state))
 183                 return -EINVAL;
 184         return count;
 185 }
 186
 187 static ssize_t
 188 show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
 189 {
 190         struct Scsi_Host *shost = class_to_shost(dev);
 191         const char *name = scsi_host_state_name(shost->shost_state);
 192
 193         if (!name)
 194                 return -EINVAL;
 195
 196         return snprintf(buf, 20, "%s\n", name);
 197 }
 198
 199 /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
 200 struct device_attribute dev_attr_hstate =
 201         __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
 202
 203 static ssize_t
 204 show_shost_mode(unsigned int mode, char *buf)
 205 {
 206         ssize_t len = 0;
 207
 208         if (mode & MODE_INITIATOR)
 209                 len = sprintf(buf, "%s", "Initiator");
 210
 211         if (mode & MODE_TARGET)
 212                 len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target");
 213
 214         len += sprintf(buf + len, "\n");
 215
 216         return len;
 217 }
 218
 219 static ssize_t
 220 show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
 221                           char *buf)
 222 {
 223         struct Scsi_Host *shost = class_to_shost(dev);
 224         unsigned int supported_mode = shost->hostt->supported_mode;
 225
 226         if (supported_mode == MODE_UNKNOWN)
 227                 /* by default this should be initiator */
 228                 supported_mode = MODE_INITIATOR;
 229
 230         return show_shost_mode(supported_mode, buf);
 231 }
 232
 233 static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
 234
 235 static ssize_t
 236 show_shost_active_mode(struct device *dev,
 237                        struct device_attribute *attr, char *buf)
 238 {
 239         struct Scsi_Host *shost = class_to_shost(dev);
 240
 241         if (shost->active_mode == MODE_UNKNOWN)
 242                 return snprintf(buf, 20, "unknown\n");
 243         else
 244                 return show_shost_mode(shost->active_mode, buf);
 245 }
 246
 247 static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
 248
 249 static int check_reset_type(const char *str)
 250 {
 251         if (sysfs_streq(str, "adapter"))
 252                 return SCSI_ADAPTER_RESET;
 253         else if (sysfs_streq(str, "firmware"))
 254                 return SCSI_FIRMWARE_RESET;
 255         else
 256                 return 0;
 257 }
 258
 259 static ssize_t
 260 store_host_reset(struct device *dev, struct device_attribute *attr,
 261                 const char *buf, size_t count)
 262 {
 263         struct Scsi_Host *shost = class_to_shost(dev);
 264         struct scsi_host_template *sht = shost->hostt;
 265         int ret = -EINVAL;
 266         int type;
 267
 268         type = check_reset_type(buf);
 269         if (!type)
 270                 goto exit_store_host_reset;
 271
 272         if (sht->host_reset)
 273                 ret = sht->host_reset(shost, type);
 274
 275 exit_store_host_reset:
 276         if (ret == 0)
 277                 ret = count;
 278         return ret;
 279 }
 280
 281 static DEVICE_ATTR(host_reset, S_IWUSR, NULL, store_host_reset);
 282
 283 shost_rd_attr(unique_id, "%u\n");
 284 shost_rd_attr(host_busy, "%hu\n");
 285 shost_rd_attr(cmd_per_lun, "%hd\n");
 286 shost_rd_attr(can_queue, "%hd\n");
 287 shost_rd_attr(sg_tablesize, "%hu\n");
 288 shost_rd_attr(sg_prot_tablesize, "%hu\n");
 289 shost_rd_attr(unchecked_isa_dma, "%d\n");
 290 shost_rd_attr(prot_capabilities, "%u\n");
 291 shost_rd_attr(prot_guard_type, "%hd\n");
 292 shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
 293
 294 static struct attribute *scsi_sysfs_shost_attrs[] = {
 295         &dev_attr_unique_id.attr,
 296         &dev_attr_host_busy.attr,
 297         &dev_attr_cmd_per_lun.attr,
 298         &dev_attr_can_queue.attr,
 299         &dev_attr_sg_tablesize.attr,
 300         &dev_attr_sg_prot_tablesize.attr,
 301         &dev_attr_unchecked_isa_dma.attr,
 302         &dev_attr_proc_name.attr,
 303         &dev_attr_scan.attr,
 304         &dev_attr_hstate.attr,
 305         &dev_attr_supported_mode.attr,
 306         &dev_attr_active_mode.attr,
 307         &dev_attr_prot_capabilities.attr,
 308         &dev_attr_prot_guard_type.attr,
 309         &dev_attr_host_reset.attr,
 310         NULL
 311 };
 312
 313 struct attribute_group scsi_shost_attr_group = {
 314         .attrs =        scsi_sysfs_shost_attrs,
 315 };
 316
 317 const struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
 318         &scsi_shost_attr_group,
 319         NULL
 320 };
 321
 322 static void scsi_device_cls_release(struct device *class_dev)
 323 {
 324         struct scsi_device *sdev;
 325
 326         sdev = class_to_sdev(class_dev);
 327         put_device(&sdev->sdev_gendev);
 328 }
 329
 330 static void scsi_device_dev_release_usercontext(struct work_struct *work)
 331 {
 332         struct scsi_device *sdev;
 333         struct device *parent;
 334         struct list_head *this, *tmp;
 335         unsigned long flags;
 336
 337         sdev = container_of(work, struct scsi_device, ew.work);
 338
 339         parent = sdev->sdev_gendev.parent;
 340
 341         spin_lock_irqsave(sdev->host->host_lock, flags);
 342         list_del(&sdev->siblings);
 343         list_del(&sdev->same_target_siblings);
 344         list_del(&sdev->starved_entry);
 345         spin_unlock_irqrestore(sdev->host->host_lock, flags);
 346
 347         cancel_work_sync(&sdev->event_work);
 348
 349         list_for_each_safe(this, tmp, &sdev->event_list) {
 350                 struct scsi_event *evt;
 351
 352                 evt = list_entry(this, struct scsi_event, node);
 353                 list_del(&evt->node);
 354                 kfree(evt);
 355         }
 356
 357         blk_put_queue(sdev->request_queue);
 358         /* NULL queue means the device can't be used */
 359         sdev->request_queue = NULL;
 360
 361         kfree(sdev->inquiry);
 362         kfree(sdev);
 363
 364         if (parent)
 365                 put_device(parent);
 366 }
 367
 368 static void scsi_device_dev_release(struct device *dev)
 369 {
 370         struct scsi_device *sdp = to_scsi_device(dev);
 371         execute_in_process_context(scsi_device_dev_release_usercontext,
 372                                    &sdp->ew);
 373 }
 374
 375 static struct class sdev_class = {
 376         .name           = "scsi_device",
 377         .dev_release    = scsi_device_cls_release,
 378 };
 379
 380 /* all probing is done in the individual ->probe routines */
 381 static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
 382 {
 383         struct scsi_device *sdp;
 384
 385         if (dev->type != &scsi_dev_type)
 386                 return 0;
 387
 388         sdp = to_scsi_device(dev);
 389         if (sdp->no_uld_attach)
 390                 return 0;
 391         return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
 392 }
 393
 394 static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 395 {
 396         struct scsi_device *sdev;
 397
 398         if (dev->type != &scsi_dev_type)
 399                 return 0;
 400
 401         sdev = to_scsi_device(dev);
 402
 403         add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
 404         return 0;
 405 }
 406
 407 struct bus_type scsi_bus_type = {
 408         .name           = "scsi",
 409         .match          = scsi_bus_match,
 410         .uevent         = scsi_bus_uevent,
 411 #ifdef CONFIG_PM
 412         .pm             = &scsi_bus_pm_ops,
 413 #endif
 414 };
 415 EXPORT_SYMBOL_GPL(scsi_bus_type);
 416
 417 int scsi_sysfs_register(void)
 418 {
 419         int error;
 420
 421         error = bus_register(&scsi_bus_type);
 422         if (!error) {
 423                 error = class_register(&sdev_class);
 424                 if (error)
 425                         bus_unregister(&scsi_bus_type);
 426         }
 427
 428         return error;
 429 }
 430
 431 void scsi_sysfs_unregister(void)
 432 {
 433         class_unregister(&sdev_class);
 434         bus_unregister(&scsi_bus_type);
 435 }
 436
 437 /*
 438  * sdev_show_function: macro to create an attr function that can be used to
 439  * show a non-bit field.
 440  */
 441 #define sdev_show_function(field, format_string)                                \
 442 static ssize_t                                                          \
 443 sdev_show_##field (struct device *dev, struct device_attribute *attr,   \
 444                    char *buf)                                           \
 445 {                                                                       \
 446         struct scsi_device *sdev;                                       \
 447         sdev = to_scsi_device(dev);                                     \
 448         return snprintf (buf, 20, format_string, sdev->field);          \
 449 }                                                                       \
 450
 451 /*
 452  * sdev_rd_attr: macro to create a function and attribute variable for a
 453  * read only field.
 454  */
 455 #define sdev_rd_attr(field, format_string)                              \
 456         sdev_show_function(field, format_string)                        \
 457 static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
 458
 459
 460 /*
 461  * sdev_rw_attr: create a function and attribute variable for a
 462  * read/write field.
 463  */
 464 #define sdev_rw_attr(field, format_string)                              \
 465         sdev_show_function(field, format_string)                                \
 466                                                                         \
 467 static ssize_t                                                          \
 468 sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
 469                     const char *buf, size_t count)                      \
 470 {                                                                       \
 471         struct scsi_device *sdev;                                       \
 472         sdev = to_scsi_device(dev);                                     \
 473         sscanf (buf, format_string, &sdev->field);                      \
 474         return count;                                                   \
 475 }                                                                       \
 476 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
 477
 478 /* Currently we don't export bit fields, but we might in future,
 479  * so leave this code in */
 480 #if 0
 481 /*
 482  * sdev_rd_attr: create a function and attribute variable for a
 483  * read/write bit field.
 484  */
 485 #define sdev_rw_attr_bit(field)                                         \
 486         sdev_show_function(field, "%d\n")                                       \
 487                                                                         \
 488 static ssize_t                                                          \
 489 sdev_store_##field (struct device *dev, struct device_attribute *attr,  \
 490                     const char *buf, size_t count)                      \
 491 {                                                                       \
 492         int ret;                                                        \
 493         struct scsi_device *sdev;                                       \
 494         ret = scsi_sdev_check_buf_bit(buf);                             \
 495         if (ret >= 0)   {                                               \
 496                 sdev = to_scsi_device(dev);                             \
 497                 sdev->field = ret;                                      \
 498                 ret = count;                                            \
 499         }                                                               \
 500         return ret;                                                     \
 501 }                                                                       \
 502 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
 503
 504 /*
 505  * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
 506  * else return -EINVAL.
 507  */
 508 static int scsi_sdev_check_buf_bit(const char *buf)
 509 {
 510         if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {
 511                 if (buf[0] == '1')
 512                         return 1;
 513                 else if (buf[0] == '0')
 514                         return 0;
 515                 else
 516                         return -EINVAL;
 517         } else
 518                 return -EINVAL;
 519 }
 520 #endif
 521 /*
 522  * Create the actual show/store functions and data structures.
 523  */
 524 sdev_rd_attr (device_blocked, "%d\n");
 525 sdev_rd_attr (queue_depth, "%d\n");
 526 sdev_rd_attr (type, "%d\n");
 527 sdev_rd_attr (scsi_level, "%d\n");
 528 sdev_rd_attr (vendor, "%.8s\n");
 529 sdev_rd_attr (model, "%.16s\n");
 530 sdev_rd_attr (rev, "%.4s\n");
 531
 532 /*
 533  * TODO: can we make these symlinks to the block layer ones?
 534  */
 535 static ssize_t
 536 sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
 537 {
 538         struct scsi_device *sdev;
 539         sdev = to_scsi_device(dev);
 540         return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
 541 }
 542
 543 static ssize_t
 544 sdev_store_timeout (struct device *dev, struct device_attribute *attr,
 545                     const char *buf, size_t count)
 546 {
 547         struct scsi_device *sdev;
 548         int timeout;
 549         sdev = to_scsi_device(dev);
 550         sscanf (buf, "%d\n", &timeout);
 551         blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
 552         return count;
 553 }
 554 static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
 555
 556 static ssize_t
 557 store_rescan_field (struct device *dev, struct device_attribute *attr,
 558                     const char *buf, size_t count)
 559 {
 560         scsi_rescan_device(dev);
 561         return count;
 562 }
 563 static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);
 564
 565 static void sdev_store_delete_callback(struct device *dev)
 566 {
 567         scsi_remove_device(to_scsi_device(dev));
 568 }
 569
 570 static ssize_t
 571 sdev_store_delete(struct device *dev, struct device_attribute *attr,
 572                   const char *buf, size_t count)
 573 {
 574         int rc;
 575
 576         /* An attribute cannot be unregistered by one of its own methods,
 577          * so we have to use this roundabout approach.
 578          */
 579         rc = device_schedule_callback(dev, sdev_store_delete_callback);
 580         if (rc)
 581                 count = rc;
 582         return count;
 583 };
 584 static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
 585
 586 static ssize_t
 587 store_state_field(struct device *dev, struct device_attribute *attr,
 588                   const char *buf, size_t count)
 589 {
 590         int i;
 591         struct scsi_device *sdev = to_scsi_device(dev);
 592         enum scsi_device_state state = 0;
 593
 594         for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
 595                 const int len = strlen(sdev_states[i].name);
 596                 if (strncmp(sdev_states[i].name, buf, len) == 0 &&
 597                    buf[len] == '\n') {
 598                         state = sdev_states[i].value;
 599                         break;
 600                 }
 601         }
 602         if (!state)
 603                 return -EINVAL;
 604
 605         if (scsi_device_set_state(sdev, state))
 606                 return -EINVAL;
 607         return count;
 608 }
 609
 610 static ssize_t
 611 show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
 612 {
 613         struct scsi_device *sdev = to_scsi_device(dev);
 614         const char *name = scsi_device_state_name(sdev->sdev_state);
 615
 616         if (!name)
 617                 return -EINVAL;
 618
 619         return snprintf(buf, 20, "%s\n", name);
 620 }
 621
 622 static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
 623
 624 static ssize_t
 625 show_queue_type_field(struct device *dev, struct device_attribute *attr,
 626                       char *buf)
 627 {
 628         struct scsi_device *sdev = to_scsi_device(dev);
 629         const char *name = "none";
 630
 631         if (sdev->ordered_tags)
 632                 name = "ordered";
 633         else if (sdev->simple_tags)
 634                 name = "simple";
 635
 636         return snprintf(buf, 20, "%s\n", name);
 637 }
 638
 639 static DEVICE_ATTR(queue_type, S_IRUGO, show_queue_type_field, NULL);
 640
 641 static ssize_t
 642 show_iostat_counterbits(struct device *dev, struct device_attribute *attr,                              char *buf)
 643 {
 644         return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
 645 }
 646
 647 static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);
 648
 649 #define show_sdev_iostat(field)                                         \
 650 static ssize_t                                                          \
 651 show_iostat_##field(struct device *dev, struct device_attribute *attr,  \
 652                     char *buf)                                          \
 653 {                                                                       \
 654         struct scsi_device *sdev = to_scsi_device(dev);                 \
 655         unsigned long long count = atomic_read(&sdev->field);           \
 656         return snprintf(buf, 20, "0x%llx\n", count);                    \
 657 }                                                                       \
 658 static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
 659
 660 show_sdev_iostat(iorequest_cnt);
 661 show_sdev_iostat(iodone_cnt);
 662 show_sdev_iostat(ioerr_cnt);
 663
 664 static ssize_t
 665 sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 666 {
 667         struct scsi_device *sdev;
 668         sdev = to_scsi_device(dev);
 669         return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);
 670 }
 671 static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
 672
 673 #define DECLARE_EVT_SHOW(name, Cap_name)                                \
 674 static ssize_t                                                          \
 675 sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
 676                      char *buf)                                         \
 677 {                                                                       \
 678         struct scsi_device *sdev = to_scsi_device(dev);                 \
 679         int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
 680         return snprintf(buf, 20, "%d\n", val);                          \
 681 }
 682
 683 #define DECLARE_EVT_STORE(name, Cap_name)                               \
 684 static ssize_t                                                          \
 685 sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
 686                       const char *buf, size_t count)                    \
 687 {                                                                       \
 688         struct scsi_device *sdev = to_scsi_device(dev);                 \
 689         int val = simple_strtoul(buf, NULL, 0);                         \
 690         if (val == 0)                                                   \
 691                 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
 692         else if (val == 1)                                              \
 693                 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events);   \
 694         else                                                            \
 695                 return -EINVAL;                                         \
 696         return count;                                                   \
 697 }
 698
 699 #define DECLARE_EVT(name, Cap_name)                                     \
 700         DECLARE_EVT_SHOW(name, Cap_name)                                \
 701         DECLARE_EVT_STORE(name, Cap_name)                               \
 702         static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name,   \
 703                            sdev_store_evt_##name);
 704 #define REF_EVT(name) &dev_attr_evt_##name.attr
 705
 706 DECLARE_EVT(media_change, MEDIA_CHANGE)
 707
 708 /* Default template for device attributes.  May NOT be modified */
 709 static struct attribute *scsi_sdev_attrs[] = {
 710         &dev_attr_device_blocked.attr,
 711         &dev_attr_type.attr,
 712         &dev_attr_scsi_level.attr,
 713         &dev_attr_vendor.attr,
 714         &dev_attr_model.attr,
 715         &dev_attr_rev.attr,
 716         &dev_attr_rescan.attr,
 717         &dev_attr_delete.attr,
 718         &dev_attr_state.attr,
 719         &dev_attr_timeout.attr,
 720         &dev_attr_iocounterbits.attr,
 721         &dev_attr_iorequest_cnt.attr,
 722         &dev_attr_iodone_cnt.attr,
 723         &dev_attr_ioerr_cnt.attr,
 724         &dev_attr_modalias.attr,
 725         REF_EVT(media_change),
 726         NULL
 727 };
 728
 729 static struct attribute_group scsi_sdev_attr_group = {
 730         .attrs =        scsi_sdev_attrs,
 731 };
 732
 733 static const struct attribute_group *scsi_sdev_attr_groups[] = {
 734         &scsi_sdev_attr_group,
 735         NULL
 736 };
 737
 738 static ssize_t
 739 sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr,
 740                           const char *buf, size_t count)
 741 {
 742         int depth, retval;
 743         struct scsi_device *sdev = to_scsi_device(dev);
 744         struct scsi_host_template *sht = sdev->host->hostt;
 745
 746         if (!sht->change_queue_depth)
 747                 return -EINVAL;
 748
 749         depth = simple_strtoul(buf, NULL, 0);
 750
 751         if (depth < 1)
 752                 return -EINVAL;
 753
 754         retval = sht->change_queue_depth(sdev, depth,
 755                                          SCSI_QDEPTH_DEFAULT);
 756         if (retval < 0)
 757                 return retval;
 758
 759         sdev->max_queue_depth = sdev->queue_depth;
 760
 761         return count;
 762 }
 763
 764 static struct device_attribute sdev_attr_queue_depth_rw =
 765         __ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
 766                sdev_store_queue_depth_rw);
 767
 768 static ssize_t
 769 sdev_show_queue_ramp_up_period(struct device *dev,
 770                                struct device_attribute *attr,
 771                                char *buf)
 772 {
 773         struct scsi_device *sdev;
 774         sdev = to_scsi_device(dev);
 775         return snprintf(buf, 20, "%u\n",
 776                         jiffies_to_msecs(sdev->queue_ramp_up_period));
 777 }
 778
 779 static ssize_t
 780 sdev_store_queue_ramp_up_period(struct device *dev,
 781                                 struct device_attribute *attr,
 782                                 const char *buf, size_t count)
 783 {
 784         struct scsi_device *sdev = to_scsi_device(dev);
 785         unsigned long period;
 786
 787         if (strict_strtoul(buf, 10, &period))
 788                 return -EINVAL;
 789
 790         sdev->queue_ramp_up_period = msecs_to_jiffies(period);
 791         return count;
 792 }
 793
 794 static struct device_attribute sdev_attr_queue_ramp_up_period =
 795         __ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
 796                sdev_show_queue_ramp_up_period,
 797                sdev_store_queue_ramp_up_period);
 798
 799 static ssize_t
 800 sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr,
 801                          const char *buf, size_t count)
 802 {
 803         struct scsi_device *sdev = to_scsi_device(dev);
 804         struct scsi_host_template *sht = sdev->host->hostt;
 805         int tag_type = 0, retval;
 806         int prev_tag_type = scsi_get_tag_type(sdev);
 807
 808         if (!sdev->tagged_supported || !sht->change_queue_type)
 809                 return -EINVAL;
 810
 811         if (strncmp(buf, "ordered", 7) == 0)
 812                 tag_type = MSG_ORDERED_TAG;
 813         else if (strncmp(buf, "simple", 6) == 0)
 814                 tag_type = MSG_SIMPLE_TAG;
 815         else if (strncmp(buf, "none", 4) != 0)
 816                 return -EINVAL;
 817
 818         if (tag_type == prev_tag_type)
 819                 return count;
 820
 821         retval = sht->change_queue_type(sdev, tag_type);
 822         if (retval < 0)
 823                 return retval;
 824
 825         return count;
 826 }
 827
 828 static int scsi_target_add(struct scsi_target *starget)
 829 {
 830         int error;
 831
 832         if (starget->state != STARGET_CREATED)
 833                 return 0;
 834
 835         error = device_add(&starget->dev);
 836         if (error) {
 837                 dev_err(&starget->dev, "target device_add failed, error %d\n", error);
 838                 return error;
 839         }
 840         transport_add_device(&starget->dev);
 841         starget->state = STARGET_RUNNING;
 842
 843         pm_runtime_set_active(&starget->dev);
 844         pm_runtime_enable(&starget->dev);
 845         device_enable_async_suspend(&starget->dev);
 846
 847         return 0;
 848 }
 849
 850 static struct device_attribute sdev_attr_queue_type_rw =
 851         __ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
 852                sdev_store_queue_type_rw);
 853
 854 /**
 855  * scsi_sysfs_add_sdev - add scsi device to sysfs
 856  * @sdev:       scsi_device to add
 857  *
 858  * Return value:
 859  *      0 on Success / non-zero on Failure
 860  **/
 861 int scsi_sysfs_add_sdev(struct scsi_device *sdev)
 862 {
 863         int error, i;
 864         struct request_queue *rq = sdev->request_queue;
 865         struct scsi_target *starget = sdev->sdev_target;
 866
 867         error = scsi_device_set_state(sdev, SDEV_RUNNING);
 868         if (error)
 869                 return error;
 870
 871         error = scsi_target_add(starget);
 872         if (error)
 873                 return error;
 874
 875         transport_configure_device(&starget->dev);
 876
 877         device_enable_async_suspend(&sdev->sdev_gendev);
 878         scsi_autopm_get_target(starget);
 879         pm_runtime_set_active(&sdev->sdev_gendev);
 880         pm_runtime_forbid(&sdev->sdev_gendev);
 881         pm_runtime_enable(&sdev->sdev_gendev);
 882         scsi_autopm_put_target(starget);
 883
 884         /* The following call will keep sdev active indefinitely, until
 885          * its driver does a corresponding scsi_autopm_pm_device().  Only
 886          * drivers supporting autosuspend will do this.
 887          */
 888         scsi_autopm_get_device(sdev);
 889
 890         error = device_add(&sdev->sdev_gendev);
 891         if (error) {
 892                 sdev_printk(KERN_INFO, sdev,
 893                                 "failed to add device: %d\n", error);
 894                 return error;
 895         }
 896         device_enable_async_suspend(&sdev->sdev_dev);
 897         error = device_add(&sdev->sdev_dev);
 898         if (error) {
 899                 sdev_printk(KERN_INFO, sdev,
 900                                 "failed to add class device: %d\n", error);
 901                 device_del(&sdev->sdev_gendev);
 902                 return error;
 903         }
 904         transport_add_device(&sdev->sdev_gendev);
 905         sdev->is_visible = 1;
 906
 907         /* create queue files, which may be writable, depending on the host */
 908         if (sdev->host->hostt->change_queue_depth) {
 909                 error = device_create_file(&sdev->sdev_gendev,
 910                                            &sdev_attr_queue_depth_rw);
 911                 error = device_create_file(&sdev->sdev_gendev,
 912                                            &sdev_attr_queue_ramp_up_period);
 913         }
 914         else
 915                 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_depth);
 916         if (error)
 917                 return error;
 918
 919         if (sdev->host->hostt->change_queue_type)
 920                 error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_type_rw);
 921         else
 922                 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_type);
 923         if (error)
 924                 return error;
 925
 926         error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
 927
 928         if (error)
 929                 /* we're treating error on bsg register as non-fatal,
 930                  * so pretend nothing went wrong */
 931                 sdev_printk(KERN_INFO, sdev,
 932                             "Failed to register bsg queue, errno=%d\n", error);
 933
 934         /* add additional host specific attributes */
 935         if (sdev->host->hostt->sdev_attrs) {
 936                 for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) {
 937                         error = device_create_file(&sdev->sdev_gendev,
 938                                         sdev->host->hostt->sdev_attrs[i]);
 939                         if (error)
 940                                 return error;
 941                 }
 942         }
 943
 944         return error;
 945 }
 946
 947 void __scsi_remove_device(struct scsi_device *sdev)
 948 {
 949         struct device *dev = &sdev->sdev_gendev;
 950
 951         if (sdev->is_visible) {
 952                 if (scsi_device_set_state(sdev, SDEV_CANCEL) != 0)
 953                         return;
 954
 955                 bsg_unregister_queue(sdev->request_queue);
 956                 device_unregister(&sdev->sdev_dev);
 957                 transport_remove_device(dev);
 958                 device_del(dev);
 959         } else
 960                 put_device(&sdev->sdev_dev);
 961
 962         /*
 963          * Stop accepting new requests and wait until all queuecommand() and
 964          * scsi_run_queue() invocations have finished before tearing down the
 965          * device.
 966          */
 967         scsi_device_set_state(sdev, SDEV_DEL);
 968         blk_cleanup_queue(sdev->request_queue);
 969         cancel_work_sync(&sdev->requeue_work);
 970
 971         if (sdev->host->hostt->slave_destroy)
 972                 sdev->host->hostt->slave_destroy(sdev);
 973         transport_destroy_device(dev);
 974
 975         /*
 976          * Paired with the kref_get() in scsi_sysfs_initialize().  We have
 977          * remoed sysfs visibility from the device, so make the target
 978          * invisible if this was the last device underneath it.
 979          */
 980         scsi_target_reap(scsi_target(sdev));
 981
 982         put_device(dev);
 983 }
 984
 985 /**
 986  * scsi_remove_device - unregister a device from the scsi bus
 987  * @sdev:       scsi_device to unregister
 988  **/
 989 void scsi_remove_device(struct scsi_device *sdev)
 990 {
 991         struct Scsi_Host *shost = sdev->host;
 992
 993         mutex_lock(&shost->scan_mutex);
 994         __scsi_remove_device(sdev);
 995         mutex_unlock(&shost->scan_mutex);
 996 }
 997 EXPORT_SYMBOL(scsi_remove_device);
 998
 999 static void __scsi_remove_target(struct scsi_target *starget)
1000 {
1001         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1002         unsigned long flags;
1003         struct scsi_device *sdev;
1004
1005         spin_lock_irqsave(shost->host_lock, flags);
1006  restart:
1007         list_for_each_entry(sdev, &shost->__devices, siblings) {
1008                 if (sdev->channel != starget->channel ||
1009                     sdev->id != starget->id ||
1010                     scsi_device_get(sdev))
1011                         continue;
1012                 spin_unlock_irqrestore(shost->host_lock, flags);
1013                 scsi_remove_device(sdev);
1014                 scsi_device_put(sdev);
1015                 spin_lock_irqsave(shost->host_lock, flags);
1016                 goto restart;
1017         }
1018         spin_unlock_irqrestore(shost->host_lock, flags);
1019 }
1020
1021 /**
1022  * scsi_remove_target - try to remove a target and all its devices
1023  * @dev: generic starget or parent of generic stargets to be removed
1024  *
1025  * Note: This is slightly racy.  It is possible that if the user
1026  * requests the addition of another device then the target won't be
1027  * removed.
1028  */
1029 void scsi_remove_target(struct device *dev)
1030 {
1031         struct Scsi_Host *shost = dev_to_shost(dev->parent);
1032         struct scsi_target *starget;
1033         unsigned long flags;
1034
1035 restart:
1036         spin_lock_irqsave(shost->host_lock, flags);
1037         list_for_each_entry(starget, &shost->__targets, siblings) {
1038                 if (starget->state == STARGET_DEL)
1039                         continue;
1040                 if (starget->dev.parent == dev || &starget->dev == dev) {
1041                         kref_get(&starget->reap_ref);
1042                         spin_unlock_irqrestore(shost->host_lock, flags);
1043                         __scsi_remove_target(starget);
1044                         scsi_target_reap(starget);
1045                         goto restart;
1046                 }
1047         }
1048         spin_unlock_irqrestore(shost->host_lock, flags);
1049 }
1050 EXPORT_SYMBOL(scsi_remove_target);
1051
1052 int scsi_register_driver(struct device_driver *drv)
1053 {
1054         drv->bus = &scsi_bus_type;
1055
1056         return driver_register(drv);
1057 }
1058 EXPORT_SYMBOL(scsi_register_driver);
1059
1060 int scsi_register_interface(struct class_interface *intf)
1061 {
1062         intf->class = &sdev_class;
1063
1064         return class_interface_register(intf);
1065 }
1066 EXPORT_SYMBOL(scsi_register_interface);
1067
1068 /**
1069  * scsi_sysfs_add_host - add scsi host to subsystem
1070  * @shost:     scsi host struct to add to subsystem
1071  **/
1072 int scsi_sysfs_add_host(struct Scsi_Host *shost)
1073 {
1074         int error, i;
1075
1076         /* add host specific attributes */
1077         if (shost->hostt->shost_attrs) {
1078                 for (i = 0; shost->hostt->shost_attrs[i]; i++) {
1079                         error = device_create_file(&shost->shost_dev,
1080                                         shost->hostt->shost_attrs[i]);
1081                         if (error)
1082                                 return error;
1083                 }
1084         }
1085
1086         transport_register_device(&shost->shost_gendev);
1087         transport_configure_device(&shost->shost_gendev);
1088         return 0;
1089 }
1090
1091 static struct device_type scsi_dev_type = {
1092         .name =         "scsi_device",
1093         .release =      scsi_device_dev_release,
1094         .groups =       scsi_sdev_attr_groups,
1095 };
1096
1097 void scsi_sysfs_device_initialize(struct scsi_device *sdev)
1098 {
1099         unsigned long flags;
1100         struct Scsi_Host *shost = sdev->host;
1101         struct scsi_target  *starget = sdev->sdev_target;
1102
1103         device_initialize(&sdev->sdev_gendev);
1104         sdev->sdev_gendev.bus = &scsi_bus_type;
1105         sdev->sdev_gendev.type = &scsi_dev_type;
1106         dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%d",
1107                      sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
1108
1109         device_initialize(&sdev->sdev_dev);
1110         sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev);
1111         sdev->sdev_dev.class = &sdev_class;
1112         dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%d",
1113                      sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
1114         sdev->scsi_level = starget->scsi_level;
1115         transport_setup_device(&sdev->sdev_gendev);
1116         spin_lock_irqsave(shost->host_lock, flags);
1117         list_add_tail(&sdev->same_target_siblings, &starget->devices);
1118         list_add_tail(&sdev->siblings, &shost->__devices);
1119         spin_unlock_irqrestore(shost->host_lock, flags);
1120         /*
1121          * device can now only be removed via __scsi_remove_device() so hold
1122          * the target.  Target will be held in CREATED state until something
1123          * beneath it becomes visible (in which case it moves to RUNNING)
1124          */
1125         kref_get(&starget->reap_ref);
1126 }
1127
1128 int scsi_is_sdev_device(const struct device *dev)
1129 {
1130         return dev->type == &scsi_dev_type;
1131 }
1132 EXPORT_SYMBOL(scsi_is_sdev_device);
1133
1134 /* A blank transport template that is used in drivers that don't
1135  * yet implement Transport Attributes */
1136 struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };