1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <linux/module.h>
29#include <linux/moduleparam.h>
30#include <linux/init.h>
31#include <linux/blkdev.h>
32#include <linux/delay.h>
33#include <linux/kthread.h>
34#include <linux/spinlock.h>
35#include <linux/async.h>
36
37#include <scsi/scsi.h>
38#include <scsi/scsi_cmnd.h>
39#include <scsi/scsi_device.h>
40#include <scsi/scsi_driver.h>
41#include <scsi/scsi_devinfo.h>
42#include <scsi/scsi_host.h>
43#include <scsi/scsi_transport.h>
44#include <scsi/scsi_eh.h>
45
46#include "scsi_priv.h"
47#include "scsi_logging.h"
48
49#define ALLOC_FAILURE_MSG KERN_ERR "%s: Allocation failure during" \
50 " SCSI scanning, some SCSI devices might not be configured\n"
51
52
53
54
55#define SCSI_TIMEOUT (2*HZ)
56
57
58
59
60#define SCSI_UID_SER_NUM 'S'
61#define SCSI_UID_UNKNOWN 'Z'
62
63
64
65
66
67
68
69
70
71
72
73
74
75#define SCSI_SCAN_NO_RESPONSE 0
76#define SCSI_SCAN_TARGET_PRESENT 1
77#define SCSI_SCAN_LUN_PRESENT 2
78
79static const char *scsi_null_device_strs = "nullnullnullnull";
80
81#define MAX_SCSI_LUNS 512
82
83#ifdef CONFIG_SCSI_MULTI_LUN
84static unsigned int max_scsi_luns = MAX_SCSI_LUNS;
85#else
86static unsigned int max_scsi_luns = 1;
87#endif
88
89module_param_named(max_luns, max_scsi_luns, uint, S_IRUGO|S_IWUSR);
90MODULE_PARM_DESC(max_luns,
91 "last scsi LUN (should be between 1 and 2^32-1)");
92
93#ifdef CONFIG_SCSI_SCAN_ASYNC
94#define SCSI_SCAN_TYPE_DEFAULT "async"
95#else
96#define SCSI_SCAN_TYPE_DEFAULT "sync"
97#endif
98
99static char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
100
101module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
102MODULE_PARM_DESC(scan, "sync, async or none");
103
104
105
106
107
108
109
110
111static unsigned int max_scsi_report_luns = 511;
112
113module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);
114MODULE_PARM_DESC(max_report_luns,
115 "REPORT LUNS maximum number of LUNS received (should be"
116 " between 1 and 16384)");
117
118static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
119
120module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
121MODULE_PARM_DESC(inq_timeout,
122 "Timeout (in seconds) waiting for devices to answer INQUIRY."
123 " Default is 20. Some devices may need more; most need less.");
124
125
126static DEFINE_SPINLOCK(async_scan_lock);
127static LIST_HEAD(scanning_hosts);
128
129struct async_scan_data {
130 struct list_head list;
131 struct Scsi_Host *shost;
132 struct completion prev_finished;
133};
134
135
136
137
138
139
140
141
142
143int scsi_complete_async_scans(void)
144{
145 struct async_scan_data *data;
146
147 do {
148 if (list_empty(&scanning_hosts))
149 return 0;
150
151
152
153
154 data = kmalloc(sizeof(*data), GFP_KERNEL);
155 if (!data)
156 msleep(1);
157 } while (!data);
158
159 data->shost = NULL;
160 init_completion(&data->prev_finished);
161
162 spin_lock(&async_scan_lock);
163
164 if (list_empty(&scanning_hosts))
165 goto done;
166 list_add_tail(&data->list, &scanning_hosts);
167 spin_unlock(&async_scan_lock);
168
169 printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");
170 wait_for_completion(&data->prev_finished);
171
172 spin_lock(&async_scan_lock);
173 list_del(&data->list);
174 if (!list_empty(&scanning_hosts)) {
175 struct async_scan_data *next = list_entry(scanning_hosts.next,
176 struct async_scan_data, list);
177 complete(&next->prev_finished);
178 }
179 done:
180 spin_unlock(&async_scan_lock);
181
182 kfree(data);
183 return 0;
184}
185
186
187EXPORT_SYMBOL_GPL(scsi_complete_async_scans);
188
189#ifndef MODULE
190
191
192
193
194
195late_initcall(scsi_complete_async_scans);
196#endif
197
198
199
200
201
202
203
204
205
206
207static void scsi_unlock_floptical(struct scsi_device *sdev,
208 unsigned char *result)
209{
210 unsigned char scsi_cmd[MAX_COMMAND_SIZE];
211
212 printk(KERN_NOTICE "scsi: unlocking floptical drive\n");
213 scsi_cmd[0] = MODE_SENSE;
214 scsi_cmd[1] = 0;
215 scsi_cmd[2] = 0x2e;
216 scsi_cmd[3] = 0;
217 scsi_cmd[4] = 0x2a;
218 scsi_cmd[5] = 0;
219 scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
220 SCSI_TIMEOUT, 3, NULL);
221}
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
238 unsigned int lun, void *hostdata)
239{
240 struct scsi_device *sdev;
241 int display_failure_msg = 1, ret;
242 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
243 extern void scsi_evt_thread(struct work_struct *work);
244
245 sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
246 GFP_ATOMIC);
247 if (!sdev)
248 goto out;
249
250 sdev->vendor = scsi_null_device_strs;
251 sdev->model = scsi_null_device_strs;
252 sdev->rev = scsi_null_device_strs;
253 sdev->host = shost;
254 sdev->id = starget->id;
255 sdev->lun = lun;
256 sdev->channel = starget->channel;
257 sdev->sdev_state = SDEV_CREATED;
258 INIT_LIST_HEAD(&sdev->siblings);
259 INIT_LIST_HEAD(&sdev->same_target_siblings);
260 INIT_LIST_HEAD(&sdev->cmd_list);
261 INIT_LIST_HEAD(&sdev->starved_entry);
262 INIT_LIST_HEAD(&sdev->event_list);
263 spin_lock_init(&sdev->list_lock);
264 INIT_WORK(&sdev->event_work, scsi_evt_thread);
265
266 sdev->sdev_gendev.parent = get_device(&starget->dev);
267 sdev->sdev_target = starget;
268
269
270 sdev->hostdata = hostdata;
271
272
273
274 sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
275
276
277
278
279 sdev->type = -1;
280
281
282
283
284
285
286 sdev->borken = 1;
287
288 sdev->request_queue = scsi_alloc_queue(sdev);
289 if (!sdev->request_queue) {
290
291
292 put_device(&starget->dev);
293 kfree(sdev);
294 goto out;
295 }
296
297 sdev->request_queue->queuedata = sdev;
298 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
299
300 scsi_sysfs_device_initialize(sdev);
301
302 if (shost->hostt->slave_alloc) {
303 ret = shost->hostt->slave_alloc(sdev);
304 if (ret) {
305
306
307
308
309 if (ret == -ENXIO)
310 display_failure_msg = 0;
311 goto out_device_destroy;
312 }
313 }
314
315 return sdev;
316
317out_device_destroy:
318 scsi_device_set_state(sdev, SDEV_DEL);
319 transport_destroy_device(&sdev->sdev_gendev);
320 put_device(&sdev->sdev_dev);
321 put_device(&sdev->sdev_gendev);
322out:
323 if (display_failure_msg)
324 printk(ALLOC_FAILURE_MSG, __func__);
325 return NULL;
326}
327
328static void scsi_target_destroy(struct scsi_target *starget)
329{
330 struct device *dev = &starget->dev;
331 struct Scsi_Host *shost = dev_to_shost(dev->parent);
332 unsigned long flags;
333
334 transport_destroy_device(dev);
335 spin_lock_irqsave(shost->host_lock, flags);
336 if (shost->hostt->target_destroy)
337 shost->hostt->target_destroy(starget);
338 list_del_init(&starget->siblings);
339 spin_unlock_irqrestore(shost->host_lock, flags);
340 put_device(dev);
341}
342
343static void scsi_target_dev_release(struct device *dev)
344{
345 struct device *parent = dev->parent;
346 struct scsi_target *starget = to_scsi_target(dev);
347
348 kfree(starget);
349 put_device(parent);
350}
351
352static struct device_type scsi_target_type = {
353 .name = "scsi_target",
354 .release = scsi_target_dev_release,
355};
356
357int scsi_is_target_device(const struct device *dev)
358{
359 return dev->type == &scsi_target_type;
360}
361EXPORT_SYMBOL(scsi_is_target_device);
362
363static struct scsi_target *__scsi_find_target(struct device *parent,
364 int channel, uint id)
365{
366 struct scsi_target *starget, *found_starget = NULL;
367 struct Scsi_Host *shost = dev_to_shost(parent);
368
369
370
371 list_for_each_entry(starget, &shost->__targets, siblings) {
372 if (starget->id == id &&
373 starget->channel == channel) {
374 found_starget = starget;
375 break;
376 }
377 }
378 if (found_starget)
379 get_device(&found_starget->dev);
380
381 return found_starget;
382}
383
384
385
386
387
388
389
390
391
392
393
394
395
396static struct scsi_target *scsi_alloc_target(struct device *parent,
397 int channel, uint id)
398{
399 struct Scsi_Host *shost = dev_to_shost(parent);
400 struct device *dev = NULL;
401 unsigned long flags;
402 const int size = sizeof(struct scsi_target)
403 + shost->transportt->target_size;
404 struct scsi_target *starget;
405 struct scsi_target *found_target;
406 int error;
407
408 starget = kzalloc(size, GFP_KERNEL);
409 if (!starget) {
410 printk(KERN_ERR "%s: allocation failure\n", __func__);
411 return NULL;
412 }
413 dev = &starget->dev;
414 device_initialize(dev);
415 starget->reap_ref = 1;
416 dev->parent = get_device(parent);
417 dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
418#ifndef CONFIG_SYSFS_DEPRECATED
419 dev->bus = &scsi_bus_type;
420#endif
421 dev->type = &scsi_target_type;
422 starget->id = id;
423 starget->channel = channel;
424 starget->can_queue = 0;
425 INIT_LIST_HEAD(&starget->siblings);
426 INIT_LIST_HEAD(&starget->devices);
427 starget->state = STARGET_CREATED;
428 starget->scsi_level = SCSI_2;
429 starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;
430 retry:
431 spin_lock_irqsave(shost->host_lock, flags);
432
433 found_target = __scsi_find_target(parent, channel, id);
434 if (found_target)
435 goto found;
436
437 list_add_tail(&starget->siblings, &shost->__targets);
438 spin_unlock_irqrestore(shost->host_lock, flags);
439
440 transport_setup_device(dev);
441 if (shost->hostt->target_alloc) {
442 error = shost->hostt->target_alloc(starget);
443
444 if(error) {
445 dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
446
447
448 scsi_target_destroy(starget);
449 return NULL;
450 }
451 }
452 get_device(dev);
453
454 return starget;
455
456 found:
457 found_target->reap_ref++;
458 spin_unlock_irqrestore(shost->host_lock, flags);
459 if (found_target->state != STARGET_DEL) {
460 put_device(parent);
461 kfree(starget);
462 return found_target;
463 }
464
465
466 put_device(&found_target->dev);
467 flush_scheduled_work();
468 goto retry;
469}
470
471static void scsi_target_reap_usercontext(struct work_struct *work)
472{
473 struct scsi_target *starget =
474 container_of(work, struct scsi_target, ew.work);
475
476 transport_remove_device(&starget->dev);
477 device_del(&starget->dev);
478 scsi_target_destroy(starget);
479}
480
481
482
483
484
485
486
487
488
489void scsi_target_reap(struct scsi_target *starget)
490{
491 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
492 unsigned long flags;
493 enum scsi_target_state state;
494 int empty;
495
496 spin_lock_irqsave(shost->host_lock, flags);
497 state = starget->state;
498 empty = --starget->reap_ref == 0 &&
499 list_empty(&starget->devices) ? 1 : 0;
500 spin_unlock_irqrestore(shost->host_lock, flags);
501
502 if (!empty)
503 return;
504
505 BUG_ON(state == STARGET_DEL);
506 starget->state = STARGET_DEL;
507 if (state == STARGET_CREATED)
508 scsi_target_destroy(starget);
509 else
510 execute_in_process_context(scsi_target_reap_usercontext,
511 &starget->ew);
512}
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528static void sanitize_inquiry_string(unsigned char *s, int len)
529{
530 int terminated = 0;
531
532 for (; len > 0; (--len, ++s)) {
533 if (*s == 0)
534 terminated = 1;
535 if (terminated || *s < 0x20 || *s > 0x7e)
536 *s = ' ';
537 }
538}
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
555 int result_len, int *bflags)
556{
557 unsigned char scsi_cmd[MAX_COMMAND_SIZE];
558 int first_inquiry_len, try_inquiry_len, next_inquiry_len;
559 int response_len = 0;
560 int pass, count, result;
561 struct scsi_sense_hdr sshdr;
562
563 *bflags = 0;
564
565
566
567
568 first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;
569 try_inquiry_len = first_inquiry_len;
570 pass = 1;
571
572 next_pass:
573 SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
574 "scsi scan: INQUIRY pass %d length %d\n",
575 pass, try_inquiry_len));
576
577
578 for (count = 0; count < 3; ++count) {
579 int resid;
580
581 memset(scsi_cmd, 0, 6);
582 scsi_cmd[0] = INQUIRY;
583 scsi_cmd[4] = (unsigned char) try_inquiry_len;
584
585 memset(inq_result, 0, try_inquiry_len);
586
587 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
588 inq_result, try_inquiry_len, &sshdr,
589 HZ / 2 + HZ * scsi_inq_timeout, 3,
590 &resid);
591
592 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY %s "
593 "with code 0x%x\n",
594 result ? "failed" : "successful", result));
595
596 if (result) {
597
598
599
600
601
602
603 if ((driver_byte(result) & DRIVER_SENSE) &&
604 scsi_sense_valid(&sshdr)) {
605 if ((sshdr.sense_key == UNIT_ATTENTION) &&
606 ((sshdr.asc == 0x28) ||
607 (sshdr.asc == 0x29)) &&
608 (sshdr.ascq == 0))
609 continue;
610 }
611 } else {
612
613
614
615
616
617 if (resid == try_inquiry_len)
618 continue;
619 }
620 break;
621 }
622
623 if (result == 0) {
624 sanitize_inquiry_string(&inq_result[8], 8);
625 sanitize_inquiry_string(&inq_result[16], 16);
626 sanitize_inquiry_string(&inq_result[32], 4);
627
628 response_len = inq_result[4] + 5;
629 if (response_len > 255)
630 response_len = first_inquiry_len;
631
632
633
634
635
636
637
638
639 *bflags = scsi_get_device_flags(sdev, &inq_result[8],
640 &inq_result[16]);
641
642
643
644 if (pass == 1) {
645 if (BLIST_INQUIRY_36 & *bflags)
646 next_inquiry_len = 36;
647 else if (BLIST_INQUIRY_58 & *bflags)
648 next_inquiry_len = 58;
649 else if (sdev->inquiry_len)
650 next_inquiry_len = sdev->inquiry_len;
651 else
652 next_inquiry_len = response_len;
653
654
655 if (next_inquiry_len > try_inquiry_len) {
656 try_inquiry_len = next_inquiry_len;
657 pass = 2;
658 goto next_pass;
659 }
660 }
661
662 } else if (pass == 2) {
663 printk(KERN_INFO "scsi scan: %d byte inquiry failed. "
664 "Consider BLIST_INQUIRY_36 for this device\n",
665 try_inquiry_len);
666
667
668
669 try_inquiry_len = first_inquiry_len;
670 pass = 3;
671 goto next_pass;
672 }
673
674
675
676 if (result)
677 return -EIO;
678
679
680 sdev->inquiry_len = min(try_inquiry_len, response_len);
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697 if (sdev->inquiry_len < 36) {
698 printk(KERN_INFO "scsi scan: INQUIRY result too short (%d),"
699 " using 36\n", sdev->inquiry_len);
700 sdev->inquiry_len = 36;
701 }
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721 sdev->scsi_level = inq_result[2] & 0x07;
722 if (sdev->scsi_level >= 2 ||
723 (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
724 sdev->scsi_level++;
725 sdev->sdev_target->scsi_level = sdev->scsi_level;
726
727 return 0;
728}
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
746 int *bflags, int async)
747{
748 int ret;
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770 sdev->inquiry = kmemdup(inq_result,
771 max_t(size_t, sdev->inquiry_len, 36),
772 GFP_ATOMIC);
773 if (sdev->inquiry == NULL)
774 return SCSI_SCAN_NO_RESPONSE;
775
776 sdev->vendor = (char *) (sdev->inquiry + 8);
777 sdev->model = (char *) (sdev->inquiry + 16);
778 sdev->rev = (char *) (sdev->inquiry + 32);
779
780 if (*bflags & BLIST_ISROM) {
781 sdev->type = TYPE_ROM;
782 sdev->removable = 1;
783 } else {
784 sdev->type = (inq_result[0] & 0x1f);
785 sdev->removable = (inq_result[1] & 0x80) >> 7;
786 }
787
788 switch (sdev->type) {
789 case TYPE_RBC:
790 case TYPE_TAPE:
791 case TYPE_DISK:
792 case TYPE_PRINTER:
793 case TYPE_MOD:
794 case TYPE_PROCESSOR:
795 case TYPE_SCANNER:
796 case TYPE_MEDIUM_CHANGER:
797 case TYPE_ENCLOSURE:
798 case TYPE_COMM:
799 case TYPE_RAID:
800 case TYPE_OSD:
801 sdev->writeable = 1;
802 break;
803 case TYPE_ROM:
804 case TYPE_WORM:
805 sdev->writeable = 0;
806 break;
807 default:
808 printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);
809 }
810
811 if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {
812
813
814
815
816 if ((*bflags & BLIST_REPORTLUN2) == 0)
817 *bflags |= BLIST_NOREPORTLUN;
818 }
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836 sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;
837 sdev->lockable = sdev->removable;
838 sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);
839
840 if (sdev->scsi_level >= SCSI_3 ||
841 (sdev->inquiry_len > 56 && inq_result[56] & 0x04))
842 sdev->ppr = 1;
843 if (inq_result[7] & 0x60)
844 sdev->wdtr = 1;
845 if (inq_result[7] & 0x10)
846 sdev->sdtr = 1;
847
848 sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "
849 "ANSI: %d%s\n", scsi_device_type(sdev->type),
850 sdev->vendor, sdev->model, sdev->rev,
851 sdev->inq_periph_qual, inq_result[2] & 0x07,
852 (inq_result[3] & 0x0f) == 1 ? " CCS" : "");
853
854 if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
855 !(*bflags & BLIST_NOTQ))
856 sdev->tagged_supported = 1;
857
858
859
860
861
862
863 if ((*bflags & BLIST_BORKEN) == 0)
864 sdev->borken = 0;
865
866 if (*bflags & BLIST_NO_ULD_ATTACH)
867 sdev->no_uld_attach = 1;
868
869
870
871
872
873 if (*bflags & BLIST_SELECT_NO_ATN)
874 sdev->select_no_atn = 1;
875
876
877
878
879
880 if (*bflags & BLIST_MAX_512)
881 blk_queue_max_sectors(sdev->request_queue, 512);
882
883
884
885
886
887 if (*bflags & BLIST_NOSTARTONADD)
888 sdev->no_start_on_add = 1;
889
890 if (*bflags & BLIST_SINGLELUN)
891 scsi_target(sdev)->single_lun = 1;
892
893 sdev->use_10_for_rw = 1;
894
895 if (*bflags & BLIST_MS_SKIP_PAGE_08)
896 sdev->skip_ms_page_8 = 1;
897
898 if (*bflags & BLIST_MS_SKIP_PAGE_3F)
899 sdev->skip_ms_page_3f = 1;
900
901 if (*bflags & BLIST_USE_10_BYTE_MS)
902 sdev->use_10_for_ms = 1;
903
904
905
906 ret = scsi_device_set_state(sdev, SDEV_RUNNING);
907 if (ret) {
908 ret = scsi_device_set_state(sdev, SDEV_BLOCK);
909
910 if (ret) {
911 sdev_printk(KERN_ERR, sdev,
912 "in wrong state %s to complete scan\n",
913 scsi_device_state_name(sdev->sdev_state));
914 return SCSI_SCAN_NO_RESPONSE;
915 }
916 }
917
918 if (*bflags & BLIST_MS_192_BYTES_FOR_3F)
919 sdev->use_192_bytes_for_3f = 1;
920
921 if (*bflags & BLIST_NOT_LOCKABLE)
922 sdev->lockable = 0;
923
924 if (*bflags & BLIST_RETRY_HWERROR)
925 sdev->retry_hwerror = 1;
926
927 transport_configure_device(&sdev->sdev_gendev);
928
929 if (sdev->host->hostt->slave_configure) {
930 ret = sdev->host->hostt->slave_configure(sdev);
931 if (ret) {
932
933
934
935
936 if (ret != -ENXIO) {
937 sdev_printk(KERN_ERR, sdev,
938 "failed to configure device\n");
939 }
940 return SCSI_SCAN_NO_RESPONSE;
941 }
942 }
943
944
945
946
947
948
949 if (!async && scsi_sysfs_add_sdev(sdev) != 0)
950 return SCSI_SCAN_NO_RESPONSE;
951
952 return SCSI_SCAN_LUN_PRESENT;
953}
954
955#ifdef CONFIG_SCSI_LOGGING
956
957
958
959
960
961
962
963static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,
964 unsigned first, unsigned end)
965{
966 unsigned term = 0, idx;
967
968 for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {
969 if (inq[idx+first] > ' ') {
970 buf[idx] = inq[idx+first];
971 term = idx+1;
972 } else {
973 buf[idx] = ' ';
974 }
975 }
976 buf[term] = 0;
977 return buf;
978}
979#endif
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000static int scsi_probe_and_add_lun(struct scsi_target *starget,
1001 uint lun, int *bflagsp,
1002 struct scsi_device **sdevp, int rescan,
1003 void *hostdata)
1004{
1005 struct scsi_device *sdev;
1006 unsigned char *result;
1007 int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;
1008 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1009
1010
1011
1012
1013
1014 sdev = scsi_device_lookup_by_target(starget, lun);
1015 if (sdev) {
1016 if (rescan || !scsi_device_created(sdev)) {
1017 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
1018 "scsi scan: device exists on %s\n",
1019 dev_name(&sdev->sdev_gendev)));
1020 if (sdevp)
1021 *sdevp = sdev;
1022 else
1023 scsi_device_put(sdev);
1024
1025 if (bflagsp)
1026 *bflagsp = scsi_get_device_flags(sdev,
1027 sdev->vendor,
1028 sdev->model);
1029 return SCSI_SCAN_LUN_PRESENT;
1030 }
1031 scsi_device_put(sdev);
1032 } else
1033 sdev = scsi_alloc_sdev(starget, lun, hostdata);
1034 if (!sdev)
1035 goto out;
1036
1037 result = kmalloc(result_len, GFP_ATOMIC |
1038 ((shost->unchecked_isa_dma) ? __GFP_DMA : 0));
1039 if (!result)
1040 goto out_free_sdev;
1041
1042 if (scsi_probe_lun(sdev, result, result_len, &bflags))
1043 goto out_free_result;
1044
1045 if (bflagsp)
1046 *bflagsp = bflags;
1047
1048
1049
1050 if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061 SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"
1062 " peripheral qualifier of 3, device not"
1063 " added\n"))
1064 if (lun == 0) {
1065 SCSI_LOG_SCAN_BUS(1, {
1066 unsigned char vend[9];
1067 unsigned char mod[17];
1068
1069 sdev_printk(KERN_INFO, sdev,
1070 "scsi scan: consider passing scsi_mod."
1071 "dev_flags=%s:%s:0x240 or 0x1000240\n",
1072 scsi_inq_str(vend, result, 8, 16),
1073 scsi_inq_str(mod, result, 16, 32));
1074 });
1075
1076 }
1077
1078 res = SCSI_SCAN_TARGET_PRESENT;
1079 goto out_free_result;
1080 }
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101 if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&
1102 (result[0] & 0x1f) == 0x1f &&
1103 !scsi_is_wlun(lun)) {
1104 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
1105 "scsi scan: peripheral device type"
1106 " of 31, no device added\n"));
1107 res = SCSI_SCAN_TARGET_PRESENT;
1108 goto out_free_result;
1109 }
1110
1111 res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);
1112 if (res == SCSI_SCAN_LUN_PRESENT) {
1113 if (bflags & BLIST_KEY) {
1114 sdev->lockable = 0;
1115 scsi_unlock_floptical(sdev, result);
1116 }
1117 }
1118
1119 out_free_result:
1120 kfree(result);
1121 out_free_sdev:
1122 if (res == SCSI_SCAN_LUN_PRESENT) {
1123 if (sdevp) {
1124 if (scsi_device_get(sdev) == 0) {
1125 *sdevp = sdev;
1126 } else {
1127 __scsi_remove_device(sdev);
1128 res = SCSI_SCAN_NO_RESPONSE;
1129 }
1130 }
1131 } else
1132 __scsi_remove_device(sdev);
1133 out:
1134 return res;
1135}
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151static void scsi_sequential_lun_scan(struct scsi_target *starget,
1152 int bflags, int scsi_level, int rescan)
1153{
1154 unsigned int sparse_lun, lun, max_dev_lun;
1155 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1156
1157 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of"
1158 "%s\n", dev_name(&starget->dev)));
1159
1160 max_dev_lun = min(max_scsi_luns, shost->max_lun);
1161
1162
1163
1164
1165
1166 if (bflags & BLIST_SPARSELUN) {
1167 max_dev_lun = shost->max_lun;
1168 sparse_lun = 1;
1169 } else
1170 sparse_lun = 0;
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193 if (bflags & BLIST_FORCELUN)
1194 max_dev_lun = shost->max_lun;
1195
1196
1197
1198 if (bflags & BLIST_MAX5LUN)
1199 max_dev_lun = min(5U, max_dev_lun);
1200
1201
1202
1203
1204 if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))
1205 max_dev_lun = min(8U, max_dev_lun);
1206
1207
1208
1209
1210
1211
1212 for (lun = 1; lun < max_dev_lun; ++lun)
1213 if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,
1214 NULL) != SCSI_SCAN_LUN_PRESENT) &&
1215 !sparse_lun)
1216 return;
1217}
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238int scsilun_to_int(struct scsi_lun *scsilun)
1239{
1240 int i;
1241 unsigned int lun;
1242
1243 lun = 0;
1244 for (i = 0; i < sizeof(lun); i += 2)
1245 lun = lun | (((scsilun->scsi_lun[i] << 8) |
1246 scsilun->scsi_lun[i + 1]) << (i * 8));
1247 return lun;
1248}
1249EXPORT_SYMBOL(scsilun_to_int);
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)
1270{
1271 int i;
1272
1273 memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));
1274
1275 for (i = 0; i < sizeof(lun); i += 2) {
1276 scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
1277 scsilun->scsi_lun[i+1] = lun & 0xFF;
1278 lun = lun >> 16;
1279 }
1280}
1281EXPORT_SYMBOL(int_to_scsilun);
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
1303 int rescan)
1304{
1305 char devname[64];
1306 unsigned char scsi_cmd[MAX_COMMAND_SIZE];
1307 unsigned int length;
1308 unsigned int lun;
1309 unsigned int num_luns;
1310 unsigned int retries;
1311 int result;
1312 struct scsi_lun *lunp, *lun_data;
1313 u8 *data;
1314 struct scsi_sense_hdr sshdr;
1315 struct scsi_device *sdev;
1316 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1317 int ret = 0;
1318
1319
1320
1321
1322
1323
1324 if (bflags & BLIST_NOREPORTLUN)
1325 return 1;
1326 if (starget->scsi_level < SCSI_2 &&
1327 starget->scsi_level != SCSI_UNKNOWN)
1328 return 1;
1329 if (starget->scsi_level < SCSI_3 &&
1330 (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))
1331 return 1;
1332 if (bflags & BLIST_NOLUN)
1333 return 0;
1334
1335 if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
1336 sdev = scsi_alloc_sdev(starget, 0, NULL);
1337 if (!sdev)
1338 return 0;
1339 if (scsi_device_get(sdev))
1340 return 0;
1341 }
1342
1343 sprintf(devname, "host %d channel %d id %d",
1344 shost->host_no, sdev->channel, sdev->id);
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356 length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
1357 lun_data = kmalloc(length, GFP_ATOMIC |
1358 (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
1359 if (!lun_data) {
1360 printk(ALLOC_FAILURE_MSG, __func__);
1361 goto out;
1362 }
1363
1364 scsi_cmd[0] = REPORT_LUNS;
1365
1366
1367
1368
1369 memset(&scsi_cmd[1], 0, 5);
1370
1371
1372
1373
1374 scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
1375 scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
1376 scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
1377 scsi_cmd[9] = (unsigned char) length & 0xff;
1378
1379 scsi_cmd[10] = 0;
1380 scsi_cmd[11] = 0;
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392 for (retries = 0; retries < 3; retries++) {
1393 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending"
1394 " REPORT LUNS to %s (try %d)\n", devname,
1395 retries));
1396
1397 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
1398 lun_data, length, &sshdr,
1399 SCSI_TIMEOUT + 4 * HZ, 3, NULL);
1400
1401 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS"
1402 " %s (try %d) result 0x%x\n", result
1403 ? "failed" : "successful", retries, result));
1404 if (result == 0)
1405 break;
1406 else if (scsi_sense_valid(&sshdr)) {
1407 if (sshdr.sense_key != UNIT_ATTENTION)
1408 break;
1409 }
1410 }
1411
1412 if (result) {
1413
1414
1415
1416 ret = 1;
1417 goto out_err;
1418 }
1419
1420
1421
1422
1423 data = (u8 *) lun_data->scsi_lun;
1424 length = ((data[0] << 24) | (data[1] << 16) |
1425 (data[2] << 8) | (data[3] << 0));
1426
1427 num_luns = (length / sizeof(struct scsi_lun));
1428 if (num_luns > max_scsi_report_luns) {
1429 printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"
1430 " of %d luns reported, try increasing"
1431 " max_scsi_report_luns.\n", devname,
1432 max_scsi_report_luns, num_luns);
1433 num_luns = max_scsi_report_luns;
1434 }
1435
1436 SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
1437 "scsi scan: REPORT LUN scan\n"));
1438
1439
1440
1441
1442
1443 for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {
1444 lun = scsilun_to_int(lunp);
1445
1446
1447
1448
1449
1450 if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {
1451 int i;
1452
1453
1454
1455
1456
1457
1458 printk(KERN_WARNING "scsi: %s lun 0x", devname);
1459 data = (char *)lunp->scsi_lun;
1460 for (i = 0; i < sizeof(struct scsi_lun); i++)
1461 printk("%02x", data[i]);
1462 printk(" has a LUN larger than currently supported.\n");
1463 } else if (lun > sdev->host->max_lun) {
1464 printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"
1465 " than allowed by the host adapter\n",
1466 devname, lun);
1467 } else {
1468 int res;
1469
1470 res = scsi_probe_and_add_lun(starget,
1471 lun, NULL, NULL, rescan, NULL);
1472 if (res == SCSI_SCAN_NO_RESPONSE) {
1473
1474
1475
1476 sdev_printk(KERN_ERR, sdev,
1477 "Unexpected response"
1478 " from lun %d while scanning, scan"
1479 " aborted\n", lun);
1480 break;
1481 }
1482 }
1483 }
1484
1485 out_err:
1486 kfree(lun_data);
1487 out:
1488 scsi_device_put(sdev);
1489 if (scsi_device_created(sdev))
1490
1491
1492
1493 __scsi_remove_device(sdev);
1494 return ret;
1495}
1496
1497struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
1498 uint id, uint lun, void *hostdata)
1499{
1500 struct scsi_device *sdev = ERR_PTR(-ENODEV);
1501 struct device *parent = &shost->shost_gendev;
1502 struct scsi_target *starget;
1503
1504 if (strncmp(scsi_scan_type, "none", 4) == 0)
1505 return ERR_PTR(-ENODEV);
1506
1507 starget = scsi_alloc_target(parent, channel, id);
1508 if (!starget)
1509 return ERR_PTR(-ENOMEM);
1510
1511 mutex_lock(&shost->scan_mutex);
1512 if (!shost->async_scan)
1513 scsi_complete_async_scans();
1514
1515 if (scsi_host_scan_allowed(shost))
1516 scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
1517 mutex_unlock(&shost->scan_mutex);
1518 scsi_target_reap(starget);
1519 put_device(&starget->dev);
1520
1521 return sdev;
1522}
1523EXPORT_SYMBOL(__scsi_add_device);
1524
1525int scsi_add_device(struct Scsi_Host *host, uint channel,
1526 uint target, uint lun)
1527{
1528 struct scsi_device *sdev =
1529 __scsi_add_device(host, channel, target, lun, NULL);
1530 if (IS_ERR(sdev))
1531 return PTR_ERR(sdev);
1532
1533 scsi_device_put(sdev);
1534 return 0;
1535}
1536EXPORT_SYMBOL(scsi_add_device);
1537
1538void scsi_rescan_device(struct device *dev)
1539{
1540 struct scsi_driver *drv;
1541
1542 if (!dev->driver)
1543 return;
1544
1545 drv = to_scsi_driver(dev->driver);
1546 if (try_module_get(drv->owner)) {
1547 if (drv->rescan)
1548 drv->rescan(dev);
1549 module_put(drv->owner);
1550 }
1551}
1552EXPORT_SYMBOL(scsi_rescan_device);
1553
1554static void __scsi_scan_target(struct device *parent, unsigned int channel,
1555 unsigned int id, unsigned int lun, int rescan)
1556{
1557 struct Scsi_Host *shost = dev_to_shost(parent);
1558 int bflags = 0;
1559 int res;
1560 struct scsi_target *starget;
1561
1562 if (shost->this_id == id)
1563
1564
1565
1566 return;
1567
1568 starget = scsi_alloc_target(parent, channel, id);
1569 if (!starget)
1570 return;
1571
1572 if (lun != SCAN_WILD_CARD) {
1573
1574
1575
1576 scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
1577 goto out_reap;
1578 }
1579
1580
1581
1582
1583
1584 res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
1585 if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
1586 if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
1587
1588
1589
1590
1591 scsi_sequential_lun_scan(starget, bflags,
1592 starget->scsi_level, rescan);
1593 }
1594
1595 out_reap:
1596
1597
1598 scsi_target_reap(starget);
1599
1600 put_device(&starget->dev);
1601}
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618void scsi_scan_target(struct device *parent, unsigned int channel,
1619 unsigned int id, unsigned int lun, int rescan)
1620{
1621 struct Scsi_Host *shost = dev_to_shost(parent);
1622
1623 if (strncmp(scsi_scan_type, "none", 4) == 0)
1624 return;
1625
1626 mutex_lock(&shost->scan_mutex);
1627 if (!shost->async_scan)
1628 scsi_complete_async_scans();
1629
1630 if (scsi_host_scan_allowed(shost))
1631 __scsi_scan_target(parent, channel, id, lun, rescan);
1632 mutex_unlock(&shost->scan_mutex);
1633}
1634EXPORT_SYMBOL(scsi_scan_target);
1635
1636static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
1637 unsigned int id, unsigned int lun, int rescan)
1638{
1639 uint order_id;
1640
1641 if (id == SCAN_WILD_CARD)
1642 for (id = 0; id < shost->max_id; ++id) {
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652 if (shost->reverse_ordering)
1653
1654
1655
1656 order_id = shost->max_id - id - 1;
1657 else
1658 order_id = id;
1659 __scsi_scan_target(&shost->shost_gendev, channel,
1660 order_id, lun, rescan);
1661 }
1662 else
1663 __scsi_scan_target(&shost->shost_gendev, channel,
1664 id, lun, rescan);
1665}
1666
1667int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
1668 unsigned int id, unsigned int lun, int rescan)
1669{
1670 SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
1671 "%s: <%u:%u:%u>\n",
1672 __func__, channel, id, lun));
1673
1674 if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
1675 ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
1676 ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
1677 return -EINVAL;
1678
1679 mutex_lock(&shost->scan_mutex);
1680 if (!shost->async_scan)
1681 scsi_complete_async_scans();
1682
1683 if (scsi_host_scan_allowed(shost)) {
1684 if (channel == SCAN_WILD_CARD)
1685 for (channel = 0; channel <= shost->max_channel;
1686 channel++)
1687 scsi_scan_channel(shost, channel, id, lun,
1688 rescan);
1689 else
1690 scsi_scan_channel(shost, channel, id, lun, rescan);
1691 }
1692 mutex_unlock(&shost->scan_mutex);
1693
1694 return 0;
1695}
1696
1697static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
1698{
1699 struct scsi_device *sdev;
1700 shost_for_each_device(sdev, shost) {
1701 if (!scsi_host_scan_allowed(shost) ||
1702 scsi_sysfs_add_sdev(sdev) != 0)
1703 __scsi_remove_device(sdev);
1704 }
1705}
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
1718{
1719 struct async_scan_data *data;
1720 unsigned long flags;
1721
1722 if (strncmp(scsi_scan_type, "sync", 4) == 0)
1723 return NULL;
1724
1725 if (shost->async_scan) {
1726 printk("%s called twice for host %d", __func__,
1727 shost->host_no);
1728 dump_stack();
1729 return NULL;
1730 }
1731
1732 data = kmalloc(sizeof(*data), GFP_KERNEL);
1733 if (!data)
1734 goto err;
1735 data->shost = scsi_host_get(shost);
1736 if (!data->shost)
1737 goto err;
1738 init_completion(&data->prev_finished);
1739
1740 mutex_lock(&shost->scan_mutex);
1741 spin_lock_irqsave(shost->host_lock, flags);
1742 shost->async_scan = 1;
1743 spin_unlock_irqrestore(shost->host_lock, flags);
1744 mutex_unlock(&shost->scan_mutex);
1745
1746 spin_lock(&async_scan_lock);
1747 if (list_empty(&scanning_hosts))
1748 complete(&data->prev_finished);
1749 list_add_tail(&data->list, &scanning_hosts);
1750 spin_unlock(&async_scan_lock);
1751
1752 return data;
1753
1754 err:
1755 kfree(data);
1756 return NULL;
1757}
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767static void scsi_finish_async_scan(struct async_scan_data *data)
1768{
1769 struct Scsi_Host *shost;
1770 unsigned long flags;
1771
1772 if (!data)
1773 return;
1774
1775 shost = data->shost;
1776
1777 mutex_lock(&shost->scan_mutex);
1778
1779 if (!shost->async_scan) {
1780 printk("%s called twice for host %d", __func__,
1781 shost->host_no);
1782 dump_stack();
1783 mutex_unlock(&shost->scan_mutex);
1784 return;
1785 }
1786
1787 wait_for_completion(&data->prev_finished);
1788
1789 scsi_sysfs_add_devices(shost);
1790
1791 spin_lock_irqsave(shost->host_lock, flags);
1792 shost->async_scan = 0;
1793 spin_unlock_irqrestore(shost->host_lock, flags);
1794
1795 mutex_unlock(&shost->scan_mutex);
1796
1797 spin_lock(&async_scan_lock);
1798 list_del(&data->list);
1799 if (!list_empty(&scanning_hosts)) {
1800 struct async_scan_data *next = list_entry(scanning_hosts.next,
1801 struct async_scan_data, list);
1802 complete(&next->prev_finished);
1803 }
1804 spin_unlock(&async_scan_lock);
1805
1806 scsi_host_put(shost);
1807 kfree(data);
1808}
1809
1810static void do_scsi_scan_host(struct Scsi_Host *shost)
1811{
1812 if (shost->hostt->scan_finished) {
1813 unsigned long start = jiffies;
1814 if (shost->hostt->scan_start)
1815 shost->hostt->scan_start(shost);
1816
1817 while (!shost->hostt->scan_finished(shost, jiffies - start))
1818 msleep(10);
1819 } else {
1820 scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
1821 SCAN_WILD_CARD, 0);
1822 }
1823}
1824
1825static int do_scan_async(void *_data)
1826{
1827 struct async_scan_data *data = _data;
1828 do_scsi_scan_host(data->shost);
1829 scsi_finish_async_scan(data);
1830 return 0;
1831}
1832
1833
1834
1835
1836
1837void scsi_scan_host(struct Scsi_Host *shost)
1838{
1839 struct task_struct *p;
1840 struct async_scan_data *data;
1841
1842 if (strncmp(scsi_scan_type, "none", 4) == 0)
1843 return;
1844
1845 data = scsi_prep_async_scan(shost);
1846 if (!data) {
1847 do_scsi_scan_host(shost);
1848 return;
1849 }
1850
1851 p = kthread_run(do_scan_async, data, "scsi_scan_%d", shost->host_no);
1852 if (IS_ERR(p))
1853 do_scan_async(data);
1854}
1855EXPORT_SYMBOL(scsi_scan_host);
1856
1857void scsi_forget_host(struct Scsi_Host *shost)
1858{
1859 struct scsi_device *sdev;
1860 unsigned long flags;
1861
1862 restart:
1863 spin_lock_irqsave(shost->host_lock, flags);
1864 list_for_each_entry(sdev, &shost->__devices, siblings) {
1865 if (sdev->sdev_state == SDEV_DEL)
1866 continue;
1867 spin_unlock_irqrestore(shost->host_lock, flags);
1868 __scsi_remove_device(sdev);
1869 goto restart;
1870 }
1871 spin_unlock_irqrestore(shost->host_lock, flags);
1872}
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
1895{
1896 struct scsi_device *sdev = NULL;
1897 struct scsi_target *starget;
1898
1899 mutex_lock(&shost->scan_mutex);
1900 if (!scsi_host_scan_allowed(shost))
1901 goto out;
1902 starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
1903 if (!starget)
1904 goto out;
1905
1906 sdev = scsi_alloc_sdev(starget, 0, NULL);
1907 if (sdev) {
1908 sdev->sdev_gendev.parent = get_device(&starget->dev);
1909 sdev->borken = 0;
1910 } else
1911 scsi_target_reap(starget);
1912 put_device(&starget->dev);
1913 out:
1914 mutex_unlock(&shost->scan_mutex);
1915 return sdev;
1916}
1917EXPORT_SYMBOL(scsi_get_host_dev);
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932void scsi_free_host_dev(struct scsi_device *sdev)
1933{
1934 BUG_ON(sdev->id != sdev->host->this_id);
1935
1936 __scsi_remove_device(sdev);
1937}
1938EXPORT_SYMBOL(scsi_free_host_dev);
1939
1940