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