4 * SCSI sysfs interface routines.
6 * Created to pull SCSI mid layer sysfs routines into one file.
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>
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>
24 #include "scsi_priv.h"
25 #include "scsi_logging.h"
27 static struct device_type scsi_dev_type
;
30 enum scsi_device_state value
;
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" },
44 const char *scsi_device_state_name(enum scsi_device_state state
)
49 for (i
= 0; i
< ARRAY_SIZE(sdev_states
); i
++) {
50 if (sdev_states
[i
].value
== state
) {
51 name
= sdev_states
[i
].name
;
59 enum scsi_host_state value
;
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", },
70 const char *scsi_host_state_name(enum scsi_host_state state
)
75 for (i
= 0; i
< ARRAY_SIZE(shost_states
); i
++) {
76 if (shost_states
[i
].value
== state
) {
77 name
= shost_states
[i
].name
;
87 } sdev_access_states
[] = {
88 { SCSI_ACCESS_STATE_OPTIMAL
, "active/optimized" },
89 { SCSI_ACCESS_STATE_ACTIVE
, "active/non-optimized" },
90 { SCSI_ACCESS_STATE_STANDBY
, "standby" },
91 { SCSI_ACCESS_STATE_UNAVAILABLE
, "unavailable" },
92 { SCSI_ACCESS_STATE_LBA
, "lba-dependent" },
93 { SCSI_ACCESS_STATE_OFFLINE
, "offline" },
94 { SCSI_ACCESS_STATE_TRANSITIONING
, "transitioning" },
97 const char *scsi_access_state_name(unsigned char state
)
102 for (i
= 0; i
< ARRAY_SIZE(sdev_access_states
); i
++) {
103 if (sdev_access_states
[i
].value
== state
) {
104 name
= sdev_access_states
[i
].name
;
111 static int check_set(unsigned long long *val
, char *src
)
115 if (strncmp(src
, "-", 20) == 0) {
116 *val
= SCAN_WILD_CARD
;
119 * Doesn't check for int overflow
121 *val
= simple_strtoull(src
, &last
, 0);
128 static int scsi_scan(struct Scsi_Host
*shost
, const char *str
)
130 char s1
[15], s2
[15], s3
[17], junk
;
131 unsigned long long channel
, id
, lun
;
134 res
= sscanf(str
, "%10s %10s %16s %c", s1
, s2
, s3
, &junk
);
137 if (check_set(&channel
, s1
))
139 if (check_set(&id
, s2
))
141 if (check_set(&lun
, s3
))
143 if (shost
->transportt
->user_scan
)
144 res
= shost
->transportt
->user_scan(shost
, channel
, id
, lun
);
146 res
= scsi_scan_host_selected(shost
, channel
, id
, lun
, 1);
151 * shost_show_function: macro to create an attr function that can be used to
152 * show a non-bit field.
154 #define shost_show_function(name, field, format_string) \
156 show_##name (struct device *dev, struct device_attribute *attr, \
159 struct Scsi_Host *shost = class_to_shost(dev); \
160 return snprintf (buf, 20, format_string, shost->field); \
164 * shost_rd_attr: macro to create a function and attribute variable for a
167 #define shost_rd_attr2(name, field, format_string) \
168 shost_show_function(name, field, format_string) \
169 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
171 #define shost_rd_attr(field, format_string) \
172 shost_rd_attr2(field, field, format_string)
175 * Create the actual show/store functions and data structures.
179 store_scan(struct device
*dev
, struct device_attribute
*attr
,
180 const char *buf
, size_t count
)
182 struct Scsi_Host
*shost
= class_to_shost(dev
);
185 res
= scsi_scan(shost
, buf
);
190 static DEVICE_ATTR(scan
, S_IWUSR
, NULL
, store_scan
);
193 store_shost_state(struct device
*dev
, struct device_attribute
*attr
,
194 const char *buf
, size_t count
)
197 struct Scsi_Host
*shost
= class_to_shost(dev
);
198 enum scsi_host_state state
= 0;
200 for (i
= 0; i
< ARRAY_SIZE(shost_states
); i
++) {
201 const int len
= strlen(shost_states
[i
].name
);
202 if (strncmp(shost_states
[i
].name
, buf
, len
) == 0 &&
204 state
= shost_states
[i
].value
;
211 if (scsi_host_set_state(shost
, state
))
217 show_shost_state(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
219 struct Scsi_Host
*shost
= class_to_shost(dev
);
220 const char *name
= scsi_host_state_name(shost
->shost_state
);
225 return snprintf(buf
, 20, "%s\n", name
);
228 /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
229 struct device_attribute dev_attr_hstate
=
230 __ATTR(state
, S_IRUGO
| S_IWUSR
, show_shost_state
, store_shost_state
);
233 show_shost_mode(unsigned int mode
, char *buf
)
237 if (mode
& MODE_INITIATOR
)
238 len
= sprintf(buf
, "%s", "Initiator");
240 if (mode
& MODE_TARGET
)
241 len
+= sprintf(buf
+ len
, "%s%s", len
? ", " : "", "Target");
243 len
+= sprintf(buf
+ len
, "\n");
249 show_shost_supported_mode(struct device
*dev
, struct device_attribute
*attr
,
252 struct Scsi_Host
*shost
= class_to_shost(dev
);
253 unsigned int supported_mode
= shost
->hostt
->supported_mode
;
255 if (supported_mode
== MODE_UNKNOWN
)
256 /* by default this should be initiator */
257 supported_mode
= MODE_INITIATOR
;
259 return show_shost_mode(supported_mode
, buf
);
262 static DEVICE_ATTR(supported_mode
, S_IRUGO
| S_IWUSR
, show_shost_supported_mode
, NULL
);
265 show_shost_active_mode(struct device
*dev
,
266 struct device_attribute
*attr
, char *buf
)
268 struct Scsi_Host
*shost
= class_to_shost(dev
);
270 if (shost
->active_mode
== MODE_UNKNOWN
)
271 return snprintf(buf
, 20, "unknown\n");
273 return show_shost_mode(shost
->active_mode
, buf
);
276 static DEVICE_ATTR(active_mode
, S_IRUGO
| S_IWUSR
, show_shost_active_mode
, NULL
);
278 static int check_reset_type(const char *str
)
280 if (sysfs_streq(str
, "adapter"))
281 return SCSI_ADAPTER_RESET
;
282 else if (sysfs_streq(str
, "firmware"))
283 return SCSI_FIRMWARE_RESET
;
289 store_host_reset(struct device
*dev
, struct device_attribute
*attr
,
290 const char *buf
, size_t count
)
292 struct Scsi_Host
*shost
= class_to_shost(dev
);
293 struct scsi_host_template
*sht
= shost
->hostt
;
297 type
= check_reset_type(buf
);
299 goto exit_store_host_reset
;
302 ret
= sht
->host_reset(shost
, type
);
304 exit_store_host_reset
:
310 static DEVICE_ATTR(host_reset
, S_IWUSR
, NULL
, store_host_reset
);
313 show_shost_eh_deadline(struct device
*dev
,
314 struct device_attribute
*attr
, char *buf
)
316 struct Scsi_Host
*shost
= class_to_shost(dev
);
318 if (shost
->eh_deadline
== -1)
319 return snprintf(buf
, strlen("off") + 2, "off\n");
320 return sprintf(buf
, "%u\n", shost
->eh_deadline
/ HZ
);
324 store_shost_eh_deadline(struct device
*dev
, struct device_attribute
*attr
,
325 const char *buf
, size_t count
)
327 struct Scsi_Host
*shost
= class_to_shost(dev
);
329 unsigned long deadline
, flags
;
331 if (shost
->transportt
&&
332 (shost
->transportt
->eh_strategy_handler
||
333 !shost
->hostt
->eh_host_reset_handler
))
336 if (!strncmp(buf
, "off", strlen("off")))
339 ret
= kstrtoul(buf
, 10, &deadline
);
342 if (deadline
* HZ
> UINT_MAX
)
346 spin_lock_irqsave(shost
->host_lock
, flags
);
347 if (scsi_host_in_recovery(shost
))
351 shost
->eh_deadline
= -1;
353 shost
->eh_deadline
= deadline
* HZ
;
357 spin_unlock_irqrestore(shost
->host_lock
, flags
);
362 static DEVICE_ATTR(eh_deadline
, S_IRUGO
| S_IWUSR
, show_shost_eh_deadline
, store_shost_eh_deadline
);
364 shost_rd_attr(use_blk_mq
, "%d\n");
365 shost_rd_attr(unique_id
, "%u\n");
366 shost_rd_attr(cmd_per_lun
, "%hd\n");
367 shost_rd_attr(can_queue
, "%hd\n");
368 shost_rd_attr(sg_tablesize
, "%hu\n");
369 shost_rd_attr(sg_prot_tablesize
, "%hu\n");
370 shost_rd_attr(unchecked_isa_dma
, "%d\n");
371 shost_rd_attr(prot_capabilities
, "%u\n");
372 shost_rd_attr(prot_guard_type
, "%hd\n");
373 shost_rd_attr2(proc_name
, hostt
->proc_name
, "%s\n");
376 show_host_busy(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
378 struct Scsi_Host
*shost
= class_to_shost(dev
);
379 return snprintf(buf
, 20, "%d\n", atomic_read(&shost
->host_busy
));
381 static DEVICE_ATTR(host_busy
, S_IRUGO
, show_host_busy
, NULL
);
383 static struct attribute
*scsi_sysfs_shost_attrs
[] = {
384 &dev_attr_use_blk_mq
.attr
,
385 &dev_attr_unique_id
.attr
,
386 &dev_attr_host_busy
.attr
,
387 &dev_attr_cmd_per_lun
.attr
,
388 &dev_attr_can_queue
.attr
,
389 &dev_attr_sg_tablesize
.attr
,
390 &dev_attr_sg_prot_tablesize
.attr
,
391 &dev_attr_unchecked_isa_dma
.attr
,
392 &dev_attr_proc_name
.attr
,
394 &dev_attr_hstate
.attr
,
395 &dev_attr_supported_mode
.attr
,
396 &dev_attr_active_mode
.attr
,
397 &dev_attr_prot_capabilities
.attr
,
398 &dev_attr_prot_guard_type
.attr
,
399 &dev_attr_host_reset
.attr
,
400 &dev_attr_eh_deadline
.attr
,
404 struct attribute_group scsi_shost_attr_group
= {
405 .attrs
= scsi_sysfs_shost_attrs
,
408 const struct attribute_group
*scsi_sysfs_shost_attr_groups
[] = {
409 &scsi_shost_attr_group
,
413 static void scsi_device_cls_release(struct device
*class_dev
)
415 struct scsi_device
*sdev
;
417 sdev
= class_to_sdev(class_dev
);
418 put_device(&sdev
->sdev_gendev
);
421 static void scsi_device_dev_release_usercontext(struct work_struct
*work
)
423 struct scsi_device
*sdev
;
424 struct device
*parent
;
425 struct list_head
*this, *tmp
;
428 sdev
= container_of(work
, struct scsi_device
, ew
.work
);
430 scsi_dh_release_device(sdev
);
432 parent
= sdev
->sdev_gendev
.parent
;
434 spin_lock_irqsave(sdev
->host
->host_lock
, flags
);
435 list_del(&sdev
->siblings
);
436 list_del(&sdev
->same_target_siblings
);
437 list_del(&sdev
->starved_entry
);
438 spin_unlock_irqrestore(sdev
->host
->host_lock
, flags
);
440 cancel_work_sync(&sdev
->event_work
);
442 list_for_each_safe(this, tmp
, &sdev
->event_list
) {
443 struct scsi_event
*evt
;
445 evt
= list_entry(this, struct scsi_event
, node
);
446 list_del(&evt
->node
);
450 blk_put_queue(sdev
->request_queue
);
451 /* NULL queue means the device can't be used */
452 sdev
->request_queue
= NULL
;
454 kfree(sdev
->vpd_pg83
);
455 kfree(sdev
->vpd_pg80
);
456 kfree(sdev
->inquiry
);
463 static void scsi_device_dev_release(struct device
*dev
)
465 struct scsi_device
*sdp
= to_scsi_device(dev
);
466 execute_in_process_context(scsi_device_dev_release_usercontext
,
470 static struct class sdev_class
= {
471 .name
= "scsi_device",
472 .dev_release
= scsi_device_cls_release
,
475 /* all probing is done in the individual ->probe routines */
476 static int scsi_bus_match(struct device
*dev
, struct device_driver
*gendrv
)
478 struct scsi_device
*sdp
;
480 if (dev
->type
!= &scsi_dev_type
)
483 sdp
= to_scsi_device(dev
);
484 if (sdp
->no_uld_attach
)
486 return (sdp
->inq_periph_qual
== SCSI_INQ_PQ_CON
)? 1: 0;
489 static int scsi_bus_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
491 struct scsi_device
*sdev
;
493 if (dev
->type
!= &scsi_dev_type
)
496 sdev
= to_scsi_device(dev
);
498 add_uevent_var(env
, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT
, sdev
->type
);
502 struct bus_type scsi_bus_type
= {
504 .match
= scsi_bus_match
,
505 .uevent
= scsi_bus_uevent
,
507 .pm
= &scsi_bus_pm_ops
,
510 EXPORT_SYMBOL_GPL(scsi_bus_type
);
512 int scsi_sysfs_register(void)
516 error
= bus_register(&scsi_bus_type
);
518 error
= class_register(&sdev_class
);
520 bus_unregister(&scsi_bus_type
);
526 void scsi_sysfs_unregister(void)
528 class_unregister(&sdev_class
);
529 bus_unregister(&scsi_bus_type
);
533 * sdev_show_function: macro to create an attr function that can be used to
534 * show a non-bit field.
536 #define sdev_show_function(field, format_string) \
538 sdev_show_##field (struct device *dev, struct device_attribute *attr, \
541 struct scsi_device *sdev; \
542 sdev = to_scsi_device(dev); \
543 return snprintf (buf, 20, format_string, sdev->field); \
547 * sdev_rd_attr: macro to create a function and attribute variable for a
550 #define sdev_rd_attr(field, format_string) \
551 sdev_show_function(field, format_string) \
552 static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
556 * sdev_rw_attr: create a function and attribute variable for a
559 #define sdev_rw_attr(field, format_string) \
560 sdev_show_function(field, format_string) \
563 sdev_store_##field (struct device *dev, struct device_attribute *attr, \
564 const char *buf, size_t count) \
566 struct scsi_device *sdev; \
567 sdev = to_scsi_device(dev); \
568 sscanf (buf, format_string, &sdev->field); \
571 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
573 /* Currently we don't export bit fields, but we might in future,
574 * so leave this code in */
577 * sdev_rd_attr: create a function and attribute variable for a
578 * read/write bit field.
580 #define sdev_rw_attr_bit(field) \
581 sdev_show_function(field, "%d\n") \
584 sdev_store_##field (struct device *dev, struct device_attribute *attr, \
585 const char *buf, size_t count) \
588 struct scsi_device *sdev; \
589 ret = scsi_sdev_check_buf_bit(buf); \
591 sdev = to_scsi_device(dev); \
597 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
600 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
601 * else return -EINVAL.
603 static int scsi_sdev_check_buf_bit(const char *buf
)
605 if ((buf
[1] == '\0') || ((buf
[1] == '\n') && (buf
[2] == '\0'))) {
608 else if (buf
[0] == '0')
617 * Create the actual show/store functions and data structures.
619 sdev_rd_attr (type
, "%d\n");
620 sdev_rd_attr (scsi_level
, "%d\n");
621 sdev_rd_attr (vendor
, "%.8s\n");
622 sdev_rd_attr (model
, "%.16s\n");
623 sdev_rd_attr (rev
, "%.4s\n");
626 sdev_show_device_busy(struct device
*dev
, struct device_attribute
*attr
,
629 struct scsi_device
*sdev
= to_scsi_device(dev
);
630 return snprintf(buf
, 20, "%d\n", atomic_read(&sdev
->device_busy
));
632 static DEVICE_ATTR(device_busy
, S_IRUGO
, sdev_show_device_busy
, NULL
);
635 sdev_show_device_blocked(struct device
*dev
, struct device_attribute
*attr
,
638 struct scsi_device
*sdev
= to_scsi_device(dev
);
639 return snprintf(buf
, 20, "%d\n", atomic_read(&sdev
->device_blocked
));
641 static DEVICE_ATTR(device_blocked
, S_IRUGO
, sdev_show_device_blocked
, NULL
);
644 * TODO: can we make these symlinks to the block layer ones?
647 sdev_show_timeout (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
649 struct scsi_device
*sdev
;
650 sdev
= to_scsi_device(dev
);
651 return snprintf(buf
, 20, "%d\n", sdev
->request_queue
->rq_timeout
/ HZ
);
655 sdev_store_timeout (struct device
*dev
, struct device_attribute
*attr
,
656 const char *buf
, size_t count
)
658 struct scsi_device
*sdev
;
660 sdev
= to_scsi_device(dev
);
661 sscanf (buf
, "%d\n", &timeout
);
662 blk_queue_rq_timeout(sdev
->request_queue
, timeout
* HZ
);
665 static DEVICE_ATTR(timeout
, S_IRUGO
| S_IWUSR
, sdev_show_timeout
, sdev_store_timeout
);
668 sdev_show_eh_timeout(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
670 struct scsi_device
*sdev
;
671 sdev
= to_scsi_device(dev
);
672 return snprintf(buf
, 20, "%u\n", sdev
->eh_timeout
/ HZ
);
676 sdev_store_eh_timeout(struct device
*dev
, struct device_attribute
*attr
,
677 const char *buf
, size_t count
)
679 struct scsi_device
*sdev
;
680 unsigned int eh_timeout
;
683 if (!capable(CAP_SYS_ADMIN
))
686 sdev
= to_scsi_device(dev
);
687 err
= kstrtouint(buf
, 10, &eh_timeout
);
690 sdev
->eh_timeout
= eh_timeout
* HZ
;
694 static DEVICE_ATTR(eh_timeout
, S_IRUGO
| S_IWUSR
, sdev_show_eh_timeout
, sdev_store_eh_timeout
);
697 store_rescan_field (struct device
*dev
, struct device_attribute
*attr
,
698 const char *buf
, size_t count
)
700 scsi_rescan_device(dev
);
703 static DEVICE_ATTR(rescan
, S_IWUSR
, NULL
, store_rescan_field
);
706 sdev_store_delete(struct device
*dev
, struct device_attribute
*attr
,
707 const char *buf
, size_t count
)
709 if (device_remove_file_self(dev
, attr
))
710 scsi_remove_device(to_scsi_device(dev
));
713 static DEVICE_ATTR(delete, S_IWUSR
, NULL
, sdev_store_delete
);
716 store_state_field(struct device
*dev
, struct device_attribute
*attr
,
717 const char *buf
, size_t count
)
720 struct scsi_device
*sdev
= to_scsi_device(dev
);
721 enum scsi_device_state state
= 0;
723 for (i
= 0; i
< ARRAY_SIZE(sdev_states
); i
++) {
724 const int len
= strlen(sdev_states
[i
].name
);
725 if (strncmp(sdev_states
[i
].name
, buf
, len
) == 0 &&
727 state
= sdev_states
[i
].value
;
734 if (scsi_device_set_state(sdev
, state
))
740 show_state_field(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
742 struct scsi_device
*sdev
= to_scsi_device(dev
);
743 const char *name
= scsi_device_state_name(sdev
->sdev_state
);
748 return snprintf(buf
, 20, "%s\n", name
);
751 static DEVICE_ATTR(state
, S_IRUGO
| S_IWUSR
, show_state_field
, store_state_field
);
754 show_queue_type_field(struct device
*dev
, struct device_attribute
*attr
,
757 struct scsi_device
*sdev
= to_scsi_device(dev
);
758 const char *name
= "none";
760 if (sdev
->simple_tags
)
763 return snprintf(buf
, 20, "%s\n", name
);
767 store_queue_type_field(struct device
*dev
, struct device_attribute
*attr
,
768 const char *buf
, size_t count
)
770 struct scsi_device
*sdev
= to_scsi_device(dev
);
772 if (!sdev
->tagged_supported
)
775 sdev_printk(KERN_INFO
, sdev
,
776 "ignoring write to deprecated queue_type attribute");
780 static DEVICE_ATTR(queue_type
, S_IRUGO
| S_IWUSR
, show_queue_type_field
,
781 store_queue_type_field
);
783 #define sdev_vpd_pg_attr(_page) \
785 show_vpd_##_page(struct file *filp, struct kobject *kobj, \
786 struct bin_attribute *bin_attr, \
787 char *buf, loff_t off, size_t count) \
789 struct device *dev = container_of(kobj, struct device, kobj); \
790 struct scsi_device *sdev = to_scsi_device(dev); \
792 if (!sdev->vpd_##_page) \
795 ret = memory_read_from_buffer(buf, count, &off, \
796 rcu_dereference(sdev->vpd_##_page), \
797 sdev->vpd_##_page##_len); \
801 static struct bin_attribute dev_attr_vpd_##_page = { \
802 .attr = {.name = __stringify(vpd_##_page), .mode = S_IRUGO }, \
804 .read = show_vpd_##_page, \
807 sdev_vpd_pg_attr(pg83
);
808 sdev_vpd_pg_attr(pg80
);
810 static ssize_t
show_inquiry(struct file
*filep
, struct kobject
*kobj
,
811 struct bin_attribute
*bin_attr
,
812 char *buf
, loff_t off
, size_t count
)
814 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
815 struct scsi_device
*sdev
= to_scsi_device(dev
);
820 return memory_read_from_buffer(buf
, count
, &off
, sdev
->inquiry
,
824 static struct bin_attribute dev_attr_inquiry
= {
830 .read
= show_inquiry
,
834 show_iostat_counterbits(struct device
*dev
, struct device_attribute
*attr
,
837 return snprintf(buf
, 20, "%d\n", (int)sizeof(atomic_t
) * 8);
840 static DEVICE_ATTR(iocounterbits
, S_IRUGO
, show_iostat_counterbits
, NULL
);
842 #define show_sdev_iostat(field) \
844 show_iostat_##field(struct device *dev, struct device_attribute *attr, \
847 struct scsi_device *sdev = to_scsi_device(dev); \
848 unsigned long long count = atomic_read(&sdev->field); \
849 return snprintf(buf, 20, "0x%llx\n", count); \
851 static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
853 show_sdev_iostat(iorequest_cnt
);
854 show_sdev_iostat(iodone_cnt
);
855 show_sdev_iostat(ioerr_cnt
);
858 sdev_show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
860 struct scsi_device
*sdev
;
861 sdev
= to_scsi_device(dev
);
862 return snprintf (buf
, 20, SCSI_DEVICE_MODALIAS_FMT
"\n", sdev
->type
);
864 static DEVICE_ATTR(modalias
, S_IRUGO
, sdev_show_modalias
, NULL
);
866 #define DECLARE_EVT_SHOW(name, Cap_name) \
868 sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
871 struct scsi_device *sdev = to_scsi_device(dev); \
872 int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
873 return snprintf(buf, 20, "%d\n", val); \
876 #define DECLARE_EVT_STORE(name, Cap_name) \
878 sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
879 const char *buf, size_t count) \
881 struct scsi_device *sdev = to_scsi_device(dev); \
882 int val = simple_strtoul(buf, NULL, 0); \
884 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
886 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
892 #define DECLARE_EVT(name, Cap_name) \
893 DECLARE_EVT_SHOW(name, Cap_name) \
894 DECLARE_EVT_STORE(name, Cap_name) \
895 static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name, \
896 sdev_store_evt_##name);
897 #define REF_EVT(name) &dev_attr_evt_##name.attr
899 DECLARE_EVT(media_change
, MEDIA_CHANGE
)
900 DECLARE_EVT(inquiry_change_reported
, INQUIRY_CHANGE_REPORTED
)
901 DECLARE_EVT(capacity_change_reported
, CAPACITY_CHANGE_REPORTED
)
902 DECLARE_EVT(soft_threshold_reached
, SOFT_THRESHOLD_REACHED_REPORTED
)
903 DECLARE_EVT(mode_parameter_change_reported
, MODE_PARAMETER_CHANGE_REPORTED
)
904 DECLARE_EVT(lun_change_reported
, LUN_CHANGE_REPORTED
)
907 sdev_store_queue_depth(struct device
*dev
, struct device_attribute
*attr
,
908 const char *buf
, size_t count
)
911 struct scsi_device
*sdev
= to_scsi_device(dev
);
912 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
914 if (!sht
->change_queue_depth
)
917 depth
= simple_strtoul(buf
, NULL
, 0);
919 if (depth
< 1 || depth
> sdev
->host
->can_queue
)
922 retval
= sht
->change_queue_depth(sdev
, depth
);
926 sdev
->max_queue_depth
= sdev
->queue_depth
;
930 sdev_show_function(queue_depth
, "%d\n");
932 static DEVICE_ATTR(queue_depth
, S_IRUGO
| S_IWUSR
, sdev_show_queue_depth
,
933 sdev_store_queue_depth
);
936 sdev_show_wwid(struct device
*dev
, struct device_attribute
*attr
,
939 struct scsi_device
*sdev
= to_scsi_device(dev
);
942 count
= scsi_vpd_lun_id(sdev
, buf
, PAGE_SIZE
);
949 static DEVICE_ATTR(wwid
, S_IRUGO
, sdev_show_wwid
, NULL
);
951 #ifdef CONFIG_SCSI_DH
953 sdev_show_dh_state(struct device
*dev
, struct device_attribute
*attr
,
956 struct scsi_device
*sdev
= to_scsi_device(dev
);
959 return snprintf(buf
, 20, "detached\n");
961 return snprintf(buf
, 20, "%s\n", sdev
->handler
->name
);
965 sdev_store_dh_state(struct device
*dev
, struct device_attribute
*attr
,
966 const char *buf
, size_t count
)
968 struct scsi_device
*sdev
= to_scsi_device(dev
);
971 if (sdev
->sdev_state
== SDEV_CANCEL
||
972 sdev
->sdev_state
== SDEV_DEL
)
975 if (!sdev
->handler
) {
977 * Attach to a device handler
979 err
= scsi_dh_attach(sdev
->request_queue
, buf
);
980 } else if (!strncmp(buf
, "activate", 8)) {
982 * Activate a device handler
984 if (sdev
->handler
->activate
)
985 err
= sdev
->handler
->activate(sdev
, NULL
, NULL
);
988 } else if (!strncmp(buf
, "detach", 6)) {
990 * Detach from a device handler
992 sdev_printk(KERN_WARNING
, sdev
,
993 "can't detach handler %s.\n",
994 sdev
->handler
->name
);
998 return err
< 0 ? err
: count
;
1001 static DEVICE_ATTR(dh_state
, S_IRUGO
| S_IWUSR
, sdev_show_dh_state
,
1002 sdev_store_dh_state
);
1005 sdev_show_access_state(struct device
*dev
,
1006 struct device_attribute
*attr
,
1009 struct scsi_device
*sdev
= to_scsi_device(dev
);
1010 unsigned char access_state
;
1011 const char *access_state_name
;
1016 access_state
= (sdev
->access_state
& SCSI_ACCESS_STATE_MASK
);
1017 access_state_name
= scsi_access_state_name(access_state
);
1019 return sprintf(buf
, "%s\n",
1020 access_state_name
? access_state_name
: "unknown");
1022 static DEVICE_ATTR(access_state
, S_IRUGO
, sdev_show_access_state
, NULL
);
1025 sdev_show_preferred_path(struct device
*dev
,
1026 struct device_attribute
*attr
,
1029 struct scsi_device
*sdev
= to_scsi_device(dev
);
1034 if (sdev
->access_state
& SCSI_ACCESS_STATE_PREFERRED
)
1035 return sprintf(buf
, "1\n");
1037 return sprintf(buf
, "0\n");
1039 static DEVICE_ATTR(preferred_path
, S_IRUGO
, sdev_show_preferred_path
, NULL
);
1043 sdev_show_queue_ramp_up_period(struct device
*dev
,
1044 struct device_attribute
*attr
,
1047 struct scsi_device
*sdev
;
1048 sdev
= to_scsi_device(dev
);
1049 return snprintf(buf
, 20, "%u\n",
1050 jiffies_to_msecs(sdev
->queue_ramp_up_period
));
1054 sdev_store_queue_ramp_up_period(struct device
*dev
,
1055 struct device_attribute
*attr
,
1056 const char *buf
, size_t count
)
1058 struct scsi_device
*sdev
= to_scsi_device(dev
);
1059 unsigned int period
;
1061 if (kstrtouint(buf
, 10, &period
))
1064 sdev
->queue_ramp_up_period
= msecs_to_jiffies(period
);
1068 static DEVICE_ATTR(queue_ramp_up_period
, S_IRUGO
| S_IWUSR
,
1069 sdev_show_queue_ramp_up_period
,
1070 sdev_store_queue_ramp_up_period
);
1072 static umode_t
scsi_sdev_attr_is_visible(struct kobject
*kobj
,
1073 struct attribute
*attr
, int i
)
1075 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1076 struct scsi_device
*sdev
= to_scsi_device(dev
);
1079 if (attr
== &dev_attr_queue_depth
.attr
&&
1080 !sdev
->host
->hostt
->change_queue_depth
)
1083 if (attr
== &dev_attr_queue_ramp_up_period
.attr
&&
1084 !sdev
->host
->hostt
->change_queue_depth
)
1087 #ifdef CONFIG_SCSI_DH
1088 if (attr
== &dev_attr_access_state
.attr
&&
1091 if (attr
== &dev_attr_preferred_path
.attr
&&
1098 static umode_t
scsi_sdev_bin_attr_is_visible(struct kobject
*kobj
,
1099 struct bin_attribute
*attr
, int i
)
1101 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1102 struct scsi_device
*sdev
= to_scsi_device(dev
);
1105 if (attr
== &dev_attr_vpd_pg80
&& !sdev
->vpd_pg80
)
1108 if (attr
== &dev_attr_vpd_pg83
&& !sdev
->vpd_pg83
)
1114 /* Default template for device attributes. May NOT be modified */
1115 static struct attribute
*scsi_sdev_attrs
[] = {
1116 &dev_attr_device_blocked
.attr
,
1117 &dev_attr_type
.attr
,
1118 &dev_attr_scsi_level
.attr
,
1119 &dev_attr_device_busy
.attr
,
1120 &dev_attr_vendor
.attr
,
1121 &dev_attr_model
.attr
,
1123 &dev_attr_rescan
.attr
,
1124 &dev_attr_delete
.attr
,
1125 &dev_attr_state
.attr
,
1126 &dev_attr_timeout
.attr
,
1127 &dev_attr_eh_timeout
.attr
,
1128 &dev_attr_iocounterbits
.attr
,
1129 &dev_attr_iorequest_cnt
.attr
,
1130 &dev_attr_iodone_cnt
.attr
,
1131 &dev_attr_ioerr_cnt
.attr
,
1132 &dev_attr_modalias
.attr
,
1133 &dev_attr_queue_depth
.attr
,
1134 &dev_attr_queue_type
.attr
,
1135 &dev_attr_wwid
.attr
,
1136 #ifdef CONFIG_SCSI_DH
1137 &dev_attr_dh_state
.attr
,
1138 &dev_attr_access_state
.attr
,
1139 &dev_attr_preferred_path
.attr
,
1141 &dev_attr_queue_ramp_up_period
.attr
,
1142 REF_EVT(media_change
),
1143 REF_EVT(inquiry_change_reported
),
1144 REF_EVT(capacity_change_reported
),
1145 REF_EVT(soft_threshold_reached
),
1146 REF_EVT(mode_parameter_change_reported
),
1147 REF_EVT(lun_change_reported
),
1151 static struct bin_attribute
*scsi_sdev_bin_attrs
[] = {
1157 static struct attribute_group scsi_sdev_attr_group
= {
1158 .attrs
= scsi_sdev_attrs
,
1159 .bin_attrs
= scsi_sdev_bin_attrs
,
1160 .is_visible
= scsi_sdev_attr_is_visible
,
1161 .is_bin_visible
= scsi_sdev_bin_attr_is_visible
,
1164 static const struct attribute_group
*scsi_sdev_attr_groups
[] = {
1165 &scsi_sdev_attr_group
,
1169 static int scsi_target_add(struct scsi_target
*starget
)
1173 if (starget
->state
!= STARGET_CREATED
)
1176 error
= device_add(&starget
->dev
);
1178 dev_err(&starget
->dev
, "target device_add failed, error %d\n", error
);
1181 transport_add_device(&starget
->dev
);
1182 starget
->state
= STARGET_RUNNING
;
1184 pm_runtime_set_active(&starget
->dev
);
1185 pm_runtime_enable(&starget
->dev
);
1186 device_enable_async_suspend(&starget
->dev
);
1192 * scsi_sysfs_add_sdev - add scsi device to sysfs
1193 * @sdev: scsi_device to add
1196 * 0 on Success / non-zero on Failure
1198 int scsi_sysfs_add_sdev(struct scsi_device
*sdev
)
1201 struct request_queue
*rq
= sdev
->request_queue
;
1202 struct scsi_target
*starget
= sdev
->sdev_target
;
1204 error
= scsi_device_set_state(sdev
, SDEV_RUNNING
);
1208 error
= scsi_target_add(starget
);
1212 transport_configure_device(&starget
->dev
);
1214 device_enable_async_suspend(&sdev
->sdev_gendev
);
1215 scsi_autopm_get_target(starget
);
1216 pm_runtime_set_active(&sdev
->sdev_gendev
);
1217 pm_runtime_forbid(&sdev
->sdev_gendev
);
1218 pm_runtime_enable(&sdev
->sdev_gendev
);
1219 scsi_autopm_put_target(starget
);
1221 scsi_autopm_get_device(sdev
);
1223 error
= scsi_dh_add_device(sdev
);
1226 * device_handler is optional, so any error can be ignored
1228 sdev_printk(KERN_INFO
, sdev
,
1229 "failed to add device handler: %d\n", error
);
1231 error
= device_add(&sdev
->sdev_gendev
);
1233 sdev_printk(KERN_INFO
, sdev
,
1234 "failed to add device: %d\n", error
);
1235 scsi_dh_remove_device(sdev
);
1239 device_enable_async_suspend(&sdev
->sdev_dev
);
1240 error
= device_add(&sdev
->sdev_dev
);
1242 sdev_printk(KERN_INFO
, sdev
,
1243 "failed to add class device: %d\n", error
);
1244 scsi_dh_remove_device(sdev
);
1245 device_del(&sdev
->sdev_gendev
);
1248 transport_add_device(&sdev
->sdev_gendev
);
1249 sdev
->is_visible
= 1;
1251 error
= bsg_register_queue(rq
, &sdev
->sdev_gendev
, NULL
, NULL
);
1254 /* we're treating error on bsg register as non-fatal,
1255 * so pretend nothing went wrong */
1256 sdev_printk(KERN_INFO
, sdev
,
1257 "Failed to register bsg queue, errno=%d\n", error
);
1259 /* add additional host specific attributes */
1260 if (sdev
->host
->hostt
->sdev_attrs
) {
1261 for (i
= 0; sdev
->host
->hostt
->sdev_attrs
[i
]; i
++) {
1262 error
= device_create_file(&sdev
->sdev_gendev
,
1263 sdev
->host
->hostt
->sdev_attrs
[i
]);
1269 scsi_autopm_put_device(sdev
);
1273 void __scsi_remove_device(struct scsi_device
*sdev
)
1275 struct device
*dev
= &sdev
->sdev_gendev
;
1278 * This cleanup path is not reentrant and while it is impossible
1279 * to get a new reference with scsi_device_get() someone can still
1280 * hold a previously acquired one.
1282 if (sdev
->sdev_state
== SDEV_DEL
)
1285 if (sdev
->is_visible
) {
1286 if (scsi_device_set_state(sdev
, SDEV_CANCEL
) != 0)
1289 bsg_unregister_queue(sdev
->request_queue
);
1290 device_unregister(&sdev
->sdev_dev
);
1291 transport_remove_device(dev
);
1292 scsi_dh_remove_device(sdev
);
1295 put_device(&sdev
->sdev_dev
);
1298 * Stop accepting new requests and wait until all queuecommand() and
1299 * scsi_run_queue() invocations have finished before tearing down the
1302 scsi_device_set_state(sdev
, SDEV_DEL
);
1303 blk_cleanup_queue(sdev
->request_queue
);
1304 cancel_work_sync(&sdev
->requeue_work
);
1306 if (sdev
->host
->hostt
->slave_destroy
)
1307 sdev
->host
->hostt
->slave_destroy(sdev
);
1308 transport_destroy_device(dev
);
1311 * Paired with the kref_get() in scsi_sysfs_initialize(). We have
1312 * remoed sysfs visibility from the device, so make the target
1313 * invisible if this was the last device underneath it.
1315 scsi_target_reap(scsi_target(sdev
));
1321 * scsi_remove_device - unregister a device from the scsi bus
1322 * @sdev: scsi_device to unregister
1324 void scsi_remove_device(struct scsi_device
*sdev
)
1326 struct Scsi_Host
*shost
= sdev
->host
;
1328 mutex_lock(&shost
->scan_mutex
);
1329 __scsi_remove_device(sdev
);
1330 mutex_unlock(&shost
->scan_mutex
);
1332 EXPORT_SYMBOL(scsi_remove_device
);
1334 static void __scsi_remove_target(struct scsi_target
*starget
)
1336 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
1337 unsigned long flags
;
1338 struct scsi_device
*sdev
;
1340 spin_lock_irqsave(shost
->host_lock
, flags
);
1342 list_for_each_entry(sdev
, &shost
->__devices
, siblings
) {
1343 if (sdev
->channel
!= starget
->channel
||
1344 sdev
->id
!= starget
->id
||
1345 scsi_device_get(sdev
))
1347 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1348 scsi_remove_device(sdev
);
1349 scsi_device_put(sdev
);
1350 spin_lock_irqsave(shost
->host_lock
, flags
);
1353 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1357 * scsi_remove_target - try to remove a target and all its devices
1358 * @dev: generic starget or parent of generic stargets to be removed
1360 * Note: This is slightly racy. It is possible that if the user
1361 * requests the addition of another device then the target won't be
1364 void scsi_remove_target(struct device
*dev
)
1366 struct Scsi_Host
*shost
= dev_to_shost(dev
->parent
);
1367 struct scsi_target
*starget
, *last_target
= NULL
;
1368 unsigned long flags
;
1371 spin_lock_irqsave(shost
->host_lock
, flags
);
1372 list_for_each_entry(starget
, &shost
->__targets
, siblings
) {
1373 if (starget
->state
== STARGET_DEL
||
1374 starget
== last_target
)
1376 if (starget
->dev
.parent
== dev
|| &starget
->dev
== dev
) {
1377 kref_get(&starget
->reap_ref
);
1378 last_target
= starget
;
1379 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1380 __scsi_remove_target(starget
);
1381 scsi_target_reap(starget
);
1385 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1387 EXPORT_SYMBOL(scsi_remove_target
);
1389 int scsi_register_driver(struct device_driver
*drv
)
1391 drv
->bus
= &scsi_bus_type
;
1393 return driver_register(drv
);
1395 EXPORT_SYMBOL(scsi_register_driver
);
1397 int scsi_register_interface(struct class_interface
*intf
)
1399 intf
->class = &sdev_class
;
1401 return class_interface_register(intf
);
1403 EXPORT_SYMBOL(scsi_register_interface
);
1406 * scsi_sysfs_add_host - add scsi host to subsystem
1407 * @shost: scsi host struct to add to subsystem
1409 int scsi_sysfs_add_host(struct Scsi_Host
*shost
)
1413 /* add host specific attributes */
1414 if (shost
->hostt
->shost_attrs
) {
1415 for (i
= 0; shost
->hostt
->shost_attrs
[i
]; i
++) {
1416 error
= device_create_file(&shost
->shost_dev
,
1417 shost
->hostt
->shost_attrs
[i
]);
1423 transport_register_device(&shost
->shost_gendev
);
1424 transport_configure_device(&shost
->shost_gendev
);
1428 static struct device_type scsi_dev_type
= {
1429 .name
= "scsi_device",
1430 .release
= scsi_device_dev_release
,
1431 .groups
= scsi_sdev_attr_groups
,
1434 void scsi_sysfs_device_initialize(struct scsi_device
*sdev
)
1436 unsigned long flags
;
1437 struct Scsi_Host
*shost
= sdev
->host
;
1438 struct scsi_target
*starget
= sdev
->sdev_target
;
1440 device_initialize(&sdev
->sdev_gendev
);
1441 sdev
->sdev_gendev
.bus
= &scsi_bus_type
;
1442 sdev
->sdev_gendev
.type
= &scsi_dev_type
;
1443 dev_set_name(&sdev
->sdev_gendev
, "%d:%d:%d:%llu",
1444 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
);
1446 device_initialize(&sdev
->sdev_dev
);
1447 sdev
->sdev_dev
.parent
= get_device(&sdev
->sdev_gendev
);
1448 sdev
->sdev_dev
.class = &sdev_class
;
1449 dev_set_name(&sdev
->sdev_dev
, "%d:%d:%d:%llu",
1450 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
);
1452 * Get a default scsi_level from the target (derived from sibling
1453 * devices). This is the best we can do for guessing how to set
1454 * sdev->lun_in_cdb for the initial INQUIRY command. For LUN 0 the
1455 * setting doesn't matter, because all the bits are zero anyway.
1456 * But it does matter for higher LUNs.
1458 sdev
->scsi_level
= starget
->scsi_level
;
1459 if (sdev
->scsi_level
<= SCSI_2
&&
1460 sdev
->scsi_level
!= SCSI_UNKNOWN
&&
1461 !shost
->no_scsi2_lun_in_cdb
)
1462 sdev
->lun_in_cdb
= 1;
1464 transport_setup_device(&sdev
->sdev_gendev
);
1465 spin_lock_irqsave(shost
->host_lock
, flags
);
1466 list_add_tail(&sdev
->same_target_siblings
, &starget
->devices
);
1467 list_add_tail(&sdev
->siblings
, &shost
->__devices
);
1468 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1470 * device can now only be removed via __scsi_remove_device() so hold
1471 * the target. Target will be held in CREATED state until something
1472 * beneath it becomes visible (in which case it moves to RUNNING)
1474 kref_get(&starget
->reap_ref
);
1477 int scsi_is_sdev_device(const struct device
*dev
)
1479 return dev
->type
== &scsi_dev_type
;
1481 EXPORT_SYMBOL(scsi_is_sdev_device
);
1483 /* A blank transport template that is used in drivers that don't
1484 * yet implement Transport Attributes */
1485 struct scsi_transport_template blank_transport_template
= { { { {NULL
, }, }, }, };