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