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