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_transport.h>
21 #include <scsi/scsi_driver.h>
23 #include "scsi_priv.h"
24 #include "scsi_logging.h"
26 static struct device_type scsi_dev_type
;
29 enum scsi_device_state value
;
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_TRANSPORT_OFFLINE
, "transport-offline" },
39 { SDEV_BLOCK
, "blocked" },
40 { SDEV_CREATED_BLOCK
, "created-blocked" },
43 const char *scsi_device_state_name(enum scsi_device_state state
)
48 for (i
= 0; i
< ARRAY_SIZE(sdev_states
); i
++) {
49 if (sdev_states
[i
].value
== state
) {
50 name
= sdev_states
[i
].name
;
58 enum scsi_host_state value
;
61 { SHOST_CREATED
, "created" },
62 { SHOST_RUNNING
, "running" },
63 { SHOST_CANCEL
, "cancel" },
64 { SHOST_DEL
, "deleted" },
65 { SHOST_RECOVERY
, "recovery" },
66 { SHOST_CANCEL_RECOVERY
, "cancel/recovery" },
67 { SHOST_DEL_RECOVERY
, "deleted/recovery", },
69 const char *scsi_host_state_name(enum scsi_host_state state
)
74 for (i
= 0; i
< ARRAY_SIZE(shost_states
); i
++) {
75 if (shost_states
[i
].value
== state
) {
76 name
= shost_states
[i
].name
;
83 static int check_set(unsigned int *val
, char *src
)
87 if (strncmp(src
, "-", 20) == 0) {
88 *val
= SCAN_WILD_CARD
;
91 * Doesn't check for int overflow
93 *val
= simple_strtoul(src
, &last
, 0);
100 static int scsi_scan(struct Scsi_Host
*shost
, const char *str
)
102 char s1
[15], s2
[15], s3
[15], junk
;
103 unsigned int channel
, id
, lun
;
106 res
= sscanf(str
, "%10s %10s %10s %c", s1
, s2
, s3
, &junk
);
109 if (check_set(&channel
, s1
))
111 if (check_set(&id
, s2
))
113 if (check_set(&lun
, s3
))
115 if (shost
->transportt
->user_scan
)
116 res
= shost
->transportt
->user_scan(shost
, channel
, id
, lun
);
118 res
= scsi_scan_host_selected(shost
, channel
, id
, lun
, 1);
123 * shost_show_function: macro to create an attr function that can be used to
124 * show a non-bit field.
126 #define shost_show_function(name, field, format_string) \
128 show_##name (struct device *dev, struct device_attribute *attr, \
131 struct Scsi_Host *shost = class_to_shost(dev); \
132 return snprintf (buf, 20, format_string, shost->field); \
136 * shost_rd_attr: macro to create a function and attribute variable for a
139 #define shost_rd_attr2(name, field, format_string) \
140 shost_show_function(name, field, format_string) \
141 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
143 #define shost_rd_attr(field, format_string) \
144 shost_rd_attr2(field, field, format_string)
147 * Create the actual show/store functions and data structures.
151 store_scan(struct device
*dev
, struct device_attribute
*attr
,
152 const char *buf
, size_t count
)
154 struct Scsi_Host
*shost
= class_to_shost(dev
);
157 res
= scsi_scan(shost
, buf
);
162 static DEVICE_ATTR(scan
, S_IWUSR
, NULL
, store_scan
);
165 store_shost_state(struct device
*dev
, struct device_attribute
*attr
,
166 const char *buf
, size_t count
)
169 struct Scsi_Host
*shost
= class_to_shost(dev
);
170 enum scsi_host_state state
= 0;
172 for (i
= 0; i
< ARRAY_SIZE(shost_states
); i
++) {
173 const int len
= strlen(shost_states
[i
].name
);
174 if (strncmp(shost_states
[i
].name
, buf
, len
) == 0 &&
176 state
= shost_states
[i
].value
;
183 if (scsi_host_set_state(shost
, state
))
189 show_shost_state(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
191 struct Scsi_Host
*shost
= class_to_shost(dev
);
192 const char *name
= scsi_host_state_name(shost
->shost_state
);
197 return snprintf(buf
, 20, "%s\n", name
);
200 /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
201 struct device_attribute dev_attr_hstate
=
202 __ATTR(state
, S_IRUGO
| S_IWUSR
, show_shost_state
, store_shost_state
);
205 show_shost_mode(unsigned int mode
, char *buf
)
209 if (mode
& MODE_INITIATOR
)
210 len
= sprintf(buf
, "%s", "Initiator");
212 if (mode
& MODE_TARGET
)
213 len
+= sprintf(buf
+ len
, "%s%s", len
? ", " : "", "Target");
215 len
+= sprintf(buf
+ len
, "\n");
221 show_shost_supported_mode(struct device
*dev
, struct device_attribute
*attr
,
224 struct Scsi_Host
*shost
= class_to_shost(dev
);
225 unsigned int supported_mode
= shost
->hostt
->supported_mode
;
227 if (supported_mode
== MODE_UNKNOWN
)
228 /* by default this should be initiator */
229 supported_mode
= MODE_INITIATOR
;
231 return show_shost_mode(supported_mode
, buf
);
234 static DEVICE_ATTR(supported_mode
, S_IRUGO
| S_IWUSR
, show_shost_supported_mode
, NULL
);
237 show_shost_active_mode(struct device
*dev
,
238 struct device_attribute
*attr
, char *buf
)
240 struct Scsi_Host
*shost
= class_to_shost(dev
);
242 if (shost
->active_mode
== MODE_UNKNOWN
)
243 return snprintf(buf
, 20, "unknown\n");
245 return show_shost_mode(shost
->active_mode
, buf
);
248 static DEVICE_ATTR(active_mode
, S_IRUGO
| S_IWUSR
, show_shost_active_mode
, NULL
);
250 static int check_reset_type(const char *str
)
252 if (sysfs_streq(str
, "adapter"))
253 return SCSI_ADAPTER_RESET
;
254 else if (sysfs_streq(str
, "firmware"))
255 return SCSI_FIRMWARE_RESET
;
261 store_host_reset(struct device
*dev
, struct device_attribute
*attr
,
262 const char *buf
, size_t count
)
264 struct Scsi_Host
*shost
= class_to_shost(dev
);
265 struct scsi_host_template
*sht
= shost
->hostt
;
269 type
= check_reset_type(buf
);
271 goto exit_store_host_reset
;
274 ret
= sht
->host_reset(shost
, type
);
276 exit_store_host_reset
:
282 static DEVICE_ATTR(host_reset
, S_IWUSR
, NULL
, store_host_reset
);
284 shost_rd_attr(unique_id
, "%u\n");
285 shost_rd_attr(host_busy
, "%hu\n");
286 shost_rd_attr(cmd_per_lun
, "%hd\n");
287 shost_rd_attr(can_queue
, "%hd\n");
288 shost_rd_attr(sg_tablesize
, "%hu\n");
289 shost_rd_attr(sg_prot_tablesize
, "%hu\n");
290 shost_rd_attr(unchecked_isa_dma
, "%d\n");
291 shost_rd_attr(prot_capabilities
, "%u\n");
292 shost_rd_attr(prot_guard_type
, "%hd\n");
293 shost_rd_attr2(proc_name
, hostt
->proc_name
, "%s\n");
295 static struct attribute
*scsi_sysfs_shost_attrs
[] = {
296 &dev_attr_unique_id
.attr
,
297 &dev_attr_host_busy
.attr
,
298 &dev_attr_cmd_per_lun
.attr
,
299 &dev_attr_can_queue
.attr
,
300 &dev_attr_sg_tablesize
.attr
,
301 &dev_attr_sg_prot_tablesize
.attr
,
302 &dev_attr_unchecked_isa_dma
.attr
,
303 &dev_attr_proc_name
.attr
,
305 &dev_attr_hstate
.attr
,
306 &dev_attr_supported_mode
.attr
,
307 &dev_attr_active_mode
.attr
,
308 &dev_attr_prot_capabilities
.attr
,
309 &dev_attr_prot_guard_type
.attr
,
310 &dev_attr_host_reset
.attr
,
314 struct attribute_group scsi_shost_attr_group
= {
315 .attrs
= scsi_sysfs_shost_attrs
,
318 const struct attribute_group
*scsi_sysfs_shost_attr_groups
[] = {
319 &scsi_shost_attr_group
,
323 static void scsi_device_cls_release(struct device
*class_dev
)
325 struct scsi_device
*sdev
;
327 sdev
= class_to_sdev(class_dev
);
328 put_device(&sdev
->sdev_gendev
);
331 static void scsi_device_dev_release_usercontext(struct work_struct
*work
)
333 struct scsi_device
*sdev
;
334 struct device
*parent
;
335 struct list_head
*this, *tmp
;
338 sdev
= container_of(work
, struct scsi_device
, ew
.work
);
340 parent
= sdev
->sdev_gendev
.parent
;
342 spin_lock_irqsave(sdev
->host
->host_lock
, flags
);
343 list_del(&sdev
->siblings
);
344 list_del(&sdev
->same_target_siblings
);
345 list_del(&sdev
->starved_entry
);
346 spin_unlock_irqrestore(sdev
->host
->host_lock
, flags
);
348 cancel_work_sync(&sdev
->event_work
);
350 list_for_each_safe(this, tmp
, &sdev
->event_list
) {
351 struct scsi_event
*evt
;
353 evt
= list_entry(this, struct scsi_event
, node
);
354 list_del(&evt
->node
);
358 blk_put_queue(sdev
->request_queue
);
359 /* NULL queue means the device can't be used */
360 sdev
->request_queue
= NULL
;
362 kfree(sdev
->inquiry
);
369 static void scsi_device_dev_release(struct device
*dev
)
371 struct scsi_device
*sdp
= to_scsi_device(dev
);
372 execute_in_process_context(scsi_device_dev_release_usercontext
,
376 static struct class sdev_class
= {
377 .name
= "scsi_device",
378 .dev_release
= scsi_device_cls_release
,
381 /* all probing is done in the individual ->probe routines */
382 static int scsi_bus_match(struct device
*dev
, struct device_driver
*gendrv
)
384 struct scsi_device
*sdp
;
386 if (dev
->type
!= &scsi_dev_type
)
389 sdp
= to_scsi_device(dev
);
390 if (sdp
->no_uld_attach
)
392 return (sdp
->inq_periph_qual
== SCSI_INQ_PQ_CON
)? 1: 0;
395 static int scsi_bus_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
397 struct scsi_device
*sdev
;
399 if (dev
->type
!= &scsi_dev_type
)
402 sdev
= to_scsi_device(dev
);
404 add_uevent_var(env
, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT
, sdev
->type
);
408 struct bus_type scsi_bus_type
= {
410 .match
= scsi_bus_match
,
411 .uevent
= scsi_bus_uevent
,
413 .pm
= &scsi_bus_pm_ops
,
416 EXPORT_SYMBOL_GPL(scsi_bus_type
);
418 int scsi_sysfs_register(void)
422 error
= bus_register(&scsi_bus_type
);
424 error
= class_register(&sdev_class
);
426 bus_unregister(&scsi_bus_type
);
432 void scsi_sysfs_unregister(void)
434 class_unregister(&sdev_class
);
435 bus_unregister(&scsi_bus_type
);
439 * sdev_show_function: macro to create an attr function that can be used to
440 * show a non-bit field.
442 #define sdev_show_function(field, format_string) \
444 sdev_show_##field (struct device *dev, struct device_attribute *attr, \
447 struct scsi_device *sdev; \
448 sdev = to_scsi_device(dev); \
449 return snprintf (buf, 20, format_string, sdev->field); \
453 * sdev_rd_attr: macro to create a function and attribute variable for a
456 #define sdev_rd_attr(field, format_string) \
457 sdev_show_function(field, format_string) \
458 static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
462 * sdev_rw_attr: create a function and attribute variable for a
465 #define sdev_rw_attr(field, format_string) \
466 sdev_show_function(field, format_string) \
469 sdev_store_##field (struct device *dev, struct device_attribute *attr, \
470 const char *buf, size_t count) \
472 struct scsi_device *sdev; \
473 sdev = to_scsi_device(dev); \
474 sscanf (buf, format_string, &sdev->field); \
477 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
479 /* Currently we don't export bit fields, but we might in future,
480 * so leave this code in */
483 * sdev_rd_attr: create a function and attribute variable for a
484 * read/write bit field.
486 #define sdev_rw_attr_bit(field) \
487 sdev_show_function(field, "%d\n") \
490 sdev_store_##field (struct device *dev, struct device_attribute *attr, \
491 const char *buf, size_t count) \
494 struct scsi_device *sdev; \
495 ret = scsi_sdev_check_buf_bit(buf); \
497 sdev = to_scsi_device(dev); \
503 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
506 * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
507 * else return -EINVAL.
509 static int scsi_sdev_check_buf_bit(const char *buf
)
511 if ((buf
[1] == '\0') || ((buf
[1] == '\n') && (buf
[2] == '\0'))) {
514 else if (buf
[0] == '0')
523 * Create the actual show/store functions and data structures.
525 sdev_rd_attr (device_blocked
, "%d\n");
526 sdev_rd_attr (queue_depth
, "%d\n");
527 sdev_rd_attr (type
, "%d\n");
528 sdev_rd_attr (scsi_level
, "%d\n");
529 sdev_rd_attr (vendor
, "%.8s\n");
530 sdev_rd_attr (model
, "%.16s\n");
531 sdev_rd_attr (rev
, "%.4s\n");
534 * TODO: can we make these symlinks to the block layer ones?
537 sdev_show_timeout (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
539 struct scsi_device
*sdev
;
540 sdev
= to_scsi_device(dev
);
541 return snprintf(buf
, 20, "%d\n", sdev
->request_queue
->rq_timeout
/ HZ
);
545 sdev_store_timeout (struct device
*dev
, struct device_attribute
*attr
,
546 const char *buf
, size_t count
)
548 struct scsi_device
*sdev
;
550 sdev
= to_scsi_device(dev
);
551 sscanf (buf
, "%d\n", &timeout
);
552 blk_queue_rq_timeout(sdev
->request_queue
, timeout
* HZ
);
555 static DEVICE_ATTR(timeout
, S_IRUGO
| S_IWUSR
, sdev_show_timeout
, sdev_store_timeout
);
558 store_rescan_field (struct device
*dev
, struct device_attribute
*attr
,
559 const char *buf
, size_t count
)
561 scsi_rescan_device(dev
);
564 static DEVICE_ATTR(rescan
, S_IWUSR
, NULL
, store_rescan_field
);
566 static void sdev_store_delete_callback(struct device
*dev
)
568 scsi_remove_device(to_scsi_device(dev
));
572 sdev_store_delete(struct device
*dev
, struct device_attribute
*attr
,
573 const char *buf
, size_t count
)
577 /* An attribute cannot be unregistered by one of its own methods,
578 * so we have to use this roundabout approach.
580 rc
= device_schedule_callback(dev
, sdev_store_delete_callback
);
585 static DEVICE_ATTR(delete, S_IWUSR
, NULL
, sdev_store_delete
);
588 store_state_field(struct device
*dev
, struct device_attribute
*attr
,
589 const char *buf
, size_t count
)
592 struct scsi_device
*sdev
= to_scsi_device(dev
);
593 enum scsi_device_state state
= 0;
595 for (i
= 0; i
< ARRAY_SIZE(sdev_states
); i
++) {
596 const int len
= strlen(sdev_states
[i
].name
);
597 if (strncmp(sdev_states
[i
].name
, buf
, len
) == 0 &&
599 state
= sdev_states
[i
].value
;
606 if (scsi_device_set_state(sdev
, state
))
612 show_state_field(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
614 struct scsi_device
*sdev
= to_scsi_device(dev
);
615 const char *name
= scsi_device_state_name(sdev
->sdev_state
);
620 return snprintf(buf
, 20, "%s\n", name
);
623 static DEVICE_ATTR(state
, S_IRUGO
| S_IWUSR
, show_state_field
, store_state_field
);
626 show_queue_type_field(struct device
*dev
, struct device_attribute
*attr
,
629 struct scsi_device
*sdev
= to_scsi_device(dev
);
630 const char *name
= "none";
632 if (sdev
->ordered_tags
)
634 else if (sdev
->simple_tags
)
637 return snprintf(buf
, 20, "%s\n", name
);
640 static DEVICE_ATTR(queue_type
, S_IRUGO
, show_queue_type_field
, NULL
);
643 show_iostat_counterbits(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
645 return snprintf(buf
, 20, "%d\n", (int)sizeof(atomic_t
) * 8);
648 static DEVICE_ATTR(iocounterbits
, S_IRUGO
, show_iostat_counterbits
, NULL
);
650 #define show_sdev_iostat(field) \
652 show_iostat_##field(struct device *dev, struct device_attribute *attr, \
655 struct scsi_device *sdev = to_scsi_device(dev); \
656 unsigned long long count = atomic_read(&sdev->field); \
657 return snprintf(buf, 20, "0x%llx\n", count); \
659 static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
661 show_sdev_iostat(iorequest_cnt
);
662 show_sdev_iostat(iodone_cnt
);
663 show_sdev_iostat(ioerr_cnt
);
666 sdev_show_modalias(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
668 struct scsi_device
*sdev
;
669 sdev
= to_scsi_device(dev
);
670 return snprintf (buf
, 20, SCSI_DEVICE_MODALIAS_FMT
"\n", sdev
->type
);
672 static DEVICE_ATTR(modalias
, S_IRUGO
, sdev_show_modalias
, NULL
);
674 #define DECLARE_EVT_SHOW(name, Cap_name) \
676 sdev_show_evt_##name(struct device *dev, struct device_attribute *attr, \
679 struct scsi_device *sdev = to_scsi_device(dev); \
680 int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
681 return snprintf(buf, 20, "%d\n", val); \
684 #define DECLARE_EVT_STORE(name, Cap_name) \
686 sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
687 const char *buf, size_t count) \
689 struct scsi_device *sdev = to_scsi_device(dev); \
690 int val = simple_strtoul(buf, NULL, 0); \
692 clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
694 set_bit(SDEV_EVT_##Cap_name, sdev->supported_events); \
700 #define DECLARE_EVT(name, Cap_name) \
701 DECLARE_EVT_SHOW(name, Cap_name) \
702 DECLARE_EVT_STORE(name, Cap_name) \
703 static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name, \
704 sdev_store_evt_##name);
705 #define REF_EVT(name) &dev_attr_evt_##name.attr
707 DECLARE_EVT(media_change
, MEDIA_CHANGE
)
709 /* Default template for device attributes. May NOT be modified */
710 static struct attribute
*scsi_sdev_attrs
[] = {
711 &dev_attr_device_blocked
.attr
,
713 &dev_attr_scsi_level
.attr
,
714 &dev_attr_vendor
.attr
,
715 &dev_attr_model
.attr
,
717 &dev_attr_rescan
.attr
,
718 &dev_attr_delete
.attr
,
719 &dev_attr_state
.attr
,
720 &dev_attr_timeout
.attr
,
721 &dev_attr_iocounterbits
.attr
,
722 &dev_attr_iorequest_cnt
.attr
,
723 &dev_attr_iodone_cnt
.attr
,
724 &dev_attr_ioerr_cnt
.attr
,
725 &dev_attr_modalias
.attr
,
726 REF_EVT(media_change
),
730 static struct attribute_group scsi_sdev_attr_group
= {
731 .attrs
= scsi_sdev_attrs
,
734 static const struct attribute_group
*scsi_sdev_attr_groups
[] = {
735 &scsi_sdev_attr_group
,
740 sdev_store_queue_depth_rw(struct device
*dev
, struct device_attribute
*attr
,
741 const char *buf
, size_t count
)
744 struct scsi_device
*sdev
= to_scsi_device(dev
);
745 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
747 if (!sht
->change_queue_depth
)
750 depth
= simple_strtoul(buf
, NULL
, 0);
755 retval
= sht
->change_queue_depth(sdev
, depth
,
756 SCSI_QDEPTH_DEFAULT
);
760 sdev
->max_queue_depth
= sdev
->queue_depth
;
765 static struct device_attribute sdev_attr_queue_depth_rw
=
766 __ATTR(queue_depth
, S_IRUGO
| S_IWUSR
, sdev_show_queue_depth
,
767 sdev_store_queue_depth_rw
);
770 sdev_show_queue_ramp_up_period(struct device
*dev
,
771 struct device_attribute
*attr
,
774 struct scsi_device
*sdev
;
775 sdev
= to_scsi_device(dev
);
776 return snprintf(buf
, 20, "%u\n",
777 jiffies_to_msecs(sdev
->queue_ramp_up_period
));
781 sdev_store_queue_ramp_up_period(struct device
*dev
,
782 struct device_attribute
*attr
,
783 const char *buf
, size_t count
)
785 struct scsi_device
*sdev
= to_scsi_device(dev
);
786 unsigned long period
;
788 if (strict_strtoul(buf
, 10, &period
))
791 sdev
->queue_ramp_up_period
= msecs_to_jiffies(period
);
795 static struct device_attribute sdev_attr_queue_ramp_up_period
=
796 __ATTR(queue_ramp_up_period
, S_IRUGO
| S_IWUSR
,
797 sdev_show_queue_ramp_up_period
,
798 sdev_store_queue_ramp_up_period
);
801 sdev_store_queue_type_rw(struct device
*dev
, struct device_attribute
*attr
,
802 const char *buf
, size_t count
)
804 struct scsi_device
*sdev
= to_scsi_device(dev
);
805 struct scsi_host_template
*sht
= sdev
->host
->hostt
;
806 int tag_type
= 0, retval
;
807 int prev_tag_type
= scsi_get_tag_type(sdev
);
809 if (!sdev
->tagged_supported
|| !sht
->change_queue_type
)
812 if (strncmp(buf
, "ordered", 7) == 0)
813 tag_type
= MSG_ORDERED_TAG
;
814 else if (strncmp(buf
, "simple", 6) == 0)
815 tag_type
= MSG_SIMPLE_TAG
;
816 else if (strncmp(buf
, "none", 4) != 0)
819 if (tag_type
== prev_tag_type
)
822 retval
= sht
->change_queue_type(sdev
, tag_type
);
829 static int scsi_target_add(struct scsi_target
*starget
)
833 if (starget
->state
!= STARGET_CREATED
)
836 error
= device_add(&starget
->dev
);
838 dev_err(&starget
->dev
, "target device_add failed, error %d\n", error
);
841 transport_add_device(&starget
->dev
);
842 starget
->state
= STARGET_RUNNING
;
844 pm_runtime_set_active(&starget
->dev
);
845 pm_runtime_enable(&starget
->dev
);
846 device_enable_async_suspend(&starget
->dev
);
851 static struct device_attribute sdev_attr_queue_type_rw
=
852 __ATTR(queue_type
, S_IRUGO
| S_IWUSR
, show_queue_type_field
,
853 sdev_store_queue_type_rw
);
856 * scsi_sysfs_add_sdev - add scsi device to sysfs
857 * @sdev: scsi_device to add
860 * 0 on Success / non-zero on Failure
862 int scsi_sysfs_add_sdev(struct scsi_device
*sdev
)
865 struct request_queue
*rq
= sdev
->request_queue
;
866 struct scsi_target
*starget
= sdev
->sdev_target
;
868 error
= scsi_target_add(starget
);
872 transport_configure_device(&starget
->dev
);
874 device_enable_async_suspend(&sdev
->sdev_gendev
);
875 scsi_autopm_get_target(starget
);
876 pm_runtime_set_active(&sdev
->sdev_gendev
);
877 pm_runtime_forbid(&sdev
->sdev_gendev
);
878 pm_runtime_enable(&sdev
->sdev_gendev
);
879 scsi_autopm_put_target(starget
);
881 /* The following call will keep sdev active indefinitely, until
882 * its driver does a corresponding scsi_autopm_pm_device(). Only
883 * drivers supporting autosuspend will do this.
885 scsi_autopm_get_device(sdev
);
887 error
= device_add(&sdev
->sdev_gendev
);
889 sdev_printk(KERN_INFO
, sdev
,
890 "failed to add device: %d\n", error
);
893 device_enable_async_suspend(&sdev
->sdev_dev
);
894 error
= device_add(&sdev
->sdev_dev
);
896 sdev_printk(KERN_INFO
, sdev
,
897 "failed to add class device: %d\n", error
);
898 device_del(&sdev
->sdev_gendev
);
901 transport_add_device(&sdev
->sdev_gendev
);
902 sdev
->is_visible
= 1;
904 /* create queue files, which may be writable, depending on the host */
905 if (sdev
->host
->hostt
->change_queue_depth
) {
906 error
= device_create_file(&sdev
->sdev_gendev
,
907 &sdev_attr_queue_depth_rw
);
908 error
= device_create_file(&sdev
->sdev_gendev
,
909 &sdev_attr_queue_ramp_up_period
);
912 error
= device_create_file(&sdev
->sdev_gendev
, &dev_attr_queue_depth
);
916 if (sdev
->host
->hostt
->change_queue_type
)
917 error
= device_create_file(&sdev
->sdev_gendev
, &sdev_attr_queue_type_rw
);
919 error
= device_create_file(&sdev
->sdev_gendev
, &dev_attr_queue_type
);
923 error
= bsg_register_queue(rq
, &sdev
->sdev_gendev
, NULL
, NULL
);
926 /* we're treating error on bsg register as non-fatal,
927 * so pretend nothing went wrong */
928 sdev_printk(KERN_INFO
, sdev
,
929 "Failed to register bsg queue, errno=%d\n", error
);
931 /* add additional host specific attributes */
932 if (sdev
->host
->hostt
->sdev_attrs
) {
933 for (i
= 0; sdev
->host
->hostt
->sdev_attrs
[i
]; i
++) {
934 error
= device_create_file(&sdev
->sdev_gendev
,
935 sdev
->host
->hostt
->sdev_attrs
[i
]);
944 void __scsi_remove_device(struct scsi_device
*sdev
)
946 struct device
*dev
= &sdev
->sdev_gendev
;
948 if (sdev
->is_visible
) {
949 if (scsi_device_set_state(sdev
, SDEV_CANCEL
) != 0)
952 bsg_unregister_queue(sdev
->request_queue
);
953 device_unregister(&sdev
->sdev_dev
);
954 transport_remove_device(dev
);
957 put_device(&sdev
->sdev_dev
);
960 * Stop accepting new requests and wait until all queuecommand() and
961 * scsi_run_queue() invocations have finished before tearing down the
964 scsi_device_set_state(sdev
, SDEV_DEL
);
965 blk_cleanup_queue(sdev
->request_queue
);
966 cancel_work_sync(&sdev
->requeue_work
);
968 if (sdev
->host
->hostt
->slave_destroy
)
969 sdev
->host
->hostt
->slave_destroy(sdev
);
970 transport_destroy_device(dev
);
973 * Paired with the kref_get() in scsi_sysfs_initialize(). We have
974 * remoed sysfs visibility from the device, so make the target
975 * invisible if this was the last device underneath it.
977 scsi_target_reap(scsi_target(sdev
));
983 * scsi_remove_device - unregister a device from the scsi bus
984 * @sdev: scsi_device to unregister
986 void scsi_remove_device(struct scsi_device
*sdev
)
988 struct Scsi_Host
*shost
= sdev
->host
;
990 mutex_lock(&shost
->scan_mutex
);
991 __scsi_remove_device(sdev
);
992 mutex_unlock(&shost
->scan_mutex
);
994 EXPORT_SYMBOL(scsi_remove_device
);
996 static void __scsi_remove_target(struct scsi_target
*starget
)
998 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
1000 struct scsi_device
*sdev
;
1002 spin_lock_irqsave(shost
->host_lock
, flags
);
1004 list_for_each_entry(sdev
, &shost
->__devices
, siblings
) {
1005 if (sdev
->channel
!= starget
->channel
||
1006 sdev
->id
!= starget
->id
||
1007 scsi_device_get(sdev
))
1009 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1010 scsi_remove_device(sdev
);
1011 scsi_device_put(sdev
);
1012 spin_lock_irqsave(shost
->host_lock
, flags
);
1015 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1019 * scsi_remove_target - try to remove a target and all its devices
1020 * @dev: generic starget or parent of generic stargets to be removed
1022 * Note: This is slightly racy. It is possible that if the user
1023 * requests the addition of another device then the target won't be
1026 void scsi_remove_target(struct device
*dev
)
1028 struct Scsi_Host
*shost
= dev_to_shost(dev
->parent
);
1029 struct scsi_target
*starget
, *last_target
= NULL
;
1030 unsigned long flags
;
1033 spin_lock_irqsave(shost
->host_lock
, flags
);
1034 list_for_each_entry(starget
, &shost
->__targets
, siblings
) {
1035 if (starget
->state
== STARGET_DEL
||
1036 starget
== last_target
)
1038 if (starget
->dev
.parent
== dev
|| &starget
->dev
== dev
) {
1039 kref_get(&starget
->reap_ref
);
1040 last_target
= starget
;
1041 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1042 __scsi_remove_target(starget
);
1043 scsi_target_reap(starget
);
1047 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1049 EXPORT_SYMBOL(scsi_remove_target
);
1051 int scsi_register_driver(struct device_driver
*drv
)
1053 drv
->bus
= &scsi_bus_type
;
1055 return driver_register(drv
);
1057 EXPORT_SYMBOL(scsi_register_driver
);
1059 int scsi_register_interface(struct class_interface
*intf
)
1061 intf
->class = &sdev_class
;
1063 return class_interface_register(intf
);
1065 EXPORT_SYMBOL(scsi_register_interface
);
1068 * scsi_sysfs_add_host - add scsi host to subsystem
1069 * @shost: scsi host struct to add to subsystem
1071 int scsi_sysfs_add_host(struct Scsi_Host
*shost
)
1075 /* add host specific attributes */
1076 if (shost
->hostt
->shost_attrs
) {
1077 for (i
= 0; shost
->hostt
->shost_attrs
[i
]; i
++) {
1078 error
= device_create_file(&shost
->shost_dev
,
1079 shost
->hostt
->shost_attrs
[i
]);
1085 transport_register_device(&shost
->shost_gendev
);
1086 transport_configure_device(&shost
->shost_gendev
);
1090 static struct device_type scsi_dev_type
= {
1091 .name
= "scsi_device",
1092 .release
= scsi_device_dev_release
,
1093 .groups
= scsi_sdev_attr_groups
,
1096 void scsi_sysfs_device_initialize(struct scsi_device
*sdev
)
1098 unsigned long flags
;
1099 struct Scsi_Host
*shost
= sdev
->host
;
1100 struct scsi_target
*starget
= sdev
->sdev_target
;
1102 device_initialize(&sdev
->sdev_gendev
);
1103 sdev
->sdev_gendev
.bus
= &scsi_bus_type
;
1104 sdev
->sdev_gendev
.type
= &scsi_dev_type
;
1105 dev_set_name(&sdev
->sdev_gendev
, "%d:%d:%d:%d",
1106 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
);
1108 device_initialize(&sdev
->sdev_dev
);
1109 sdev
->sdev_dev
.parent
= get_device(&sdev
->sdev_gendev
);
1110 sdev
->sdev_dev
.class = &sdev_class
;
1111 dev_set_name(&sdev
->sdev_dev
, "%d:%d:%d:%d",
1112 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
, sdev
->lun
);
1113 sdev
->scsi_level
= starget
->scsi_level
;
1114 transport_setup_device(&sdev
->sdev_gendev
);
1115 spin_lock_irqsave(shost
->host_lock
, flags
);
1116 list_add_tail(&sdev
->same_target_siblings
, &starget
->devices
);
1117 list_add_tail(&sdev
->siblings
, &shost
->__devices
);
1118 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1120 * device can now only be removed via __scsi_remove_device() so hold
1121 * the target. Target will be held in CREATED state until something
1122 * beneath it becomes visible (in which case it moves to RUNNING)
1124 kref_get(&starget
->reap_ref
);
1127 int scsi_is_sdev_device(const struct device
*dev
)
1129 return dev
->type
== &scsi_dev_type
;
1131 EXPORT_SYMBOL(scsi_is_sdev_device
);
1133 /* A blank transport template that is used in drivers that don't
1134 * yet implement Transport Attributes */
1135 struct scsi_transport_template blank_transport_template
= { { { {NULL
, }, }, }, };