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