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