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