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