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