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