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
188EXPORT_SYMBOL_GPL(scsi_complete_async_scans);
189
190#ifndef MODULE
191
192
193
194
195
196late_initcall(scsi_complete_async_scans);
197#endif
198
199
200
201
202
203
204
205
206
207
208static void scsi_unlock_floptical(struct scsi_device *sdev,
209 unsigned char *result)
210{
211 unsigned char scsi_cmd[MAX_COMMAND_SIZE];
212
213 printk(KERN_NOTICE "scsi: unlocking floptical drive\n");
214 scsi_cmd[0] = MODE_SENSE;
215 scsi_cmd[1] = 0;
216 scsi_cmd[2] = 0x2e;
217 scsi_cmd[3] = 0;
218 scsi_cmd[4] = 0x2a;
219 scsi_cmd[5] = 0;
220 scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
221 SCSI_TIMEOUT, 3, NULL);
222}
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
239 unsigned int lun, void *hostdata)
240{
241 struct scsi_device *sdev;
242 int display_failure_msg = 1, ret;
243 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
244 extern void scsi_evt_thread(struct work_struct *work);
245
246 sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
247 GFP_ATOMIC);
248 if (!sdev)
249 goto out;
250
251 sdev->vendor = scsi_null_device_strs;
252 sdev->model = scsi_null_device_strs;
253 sdev->rev = scsi_null_device_strs;
254 sdev->host = shost;
255 sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
256 sdev->id = starget->id;
257 sdev->lun = lun;
258 sdev->channel = starget->channel;
259 sdev->sdev_state = SDEV_CREATED;
260 INIT_LIST_HEAD(&sdev->siblings);
261 INIT_LIST_HEAD(&sdev->same_target_siblings);
262 INIT_LIST_HEAD(&sdev->cmd_list);
263 INIT_LIST_HEAD(&sdev->starved_entry);
264 INIT_LIST_HEAD(&sdev->event_list);
265 spin_lock_init(&sdev->list_lock);
266 INIT_WORK(&sdev->event_work, scsi_evt_thread);
267
268 sdev->sdev_gendev.parent = get_device(&starget->dev);
269 sdev->sdev_target = starget;
270
271
272 sdev->hostdata = hostdata;
273
274
275
276 sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
277
278
279
280
281 sdev->type = -1;
282
283
284
285
286
287
288 sdev->borken = 1;
289
290 sdev->request_queue = scsi_alloc_queue(sdev);
291 if (!sdev->request_queue) {
292
293
294 put_device(&starget->dev);
295 kfree(sdev);
296 goto out;
297 }
298
299 sdev->request_queue->queuedata = sdev;
300 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
301
302 scsi_sysfs_device_initialize(sdev);
303
304 if (shost->hostt->slave_alloc) {
305 ret = shost->hostt->slave_alloc(sdev);
306 if (ret) {
307
308
309
310
311 if (ret == -ENXIO)
312 display_failure_msg = 0;
313 goto out_device_destroy;
314 }
315 }
316
317 return sdev;
318
319out_device_destroy:
320 scsi_device_set_state(sdev, SDEV_DEL);
321 transport_destroy_device(&sdev->sdev_gendev);
322 put_device(&sdev->sdev_dev);
323 put_device(&sdev->sdev_gendev);
324out:
325 if (display_failure_msg)
326 printk(ALLOC_FAILURE_MSG, __func__);
327 return NULL;
328}
329
330static void scsi_target_destroy(struct scsi_target *starget)
331{
332 struct device *dev = &starget->dev;
333 struct Scsi_Host *shost = dev_to_shost(dev->parent);
334 unsigned long flags;
335
336 transport_destroy_device(dev);
337 spin_lock_irqsave(shost->host_lock, flags);
338 if (shost->hostt->target_destroy)
339 shost->hostt->target_destroy(starget);
340 list_del_init(&starget->siblings);
341 spin_unlock_irqrestore(shost->host_lock, flags);
342 put_device(dev);
343}
344
345static void scsi_target_dev_release(struct device *dev)
346{
347 struct device *parent = dev->parent;
348 struct scsi_target *starget = to_scsi_target(dev);
349
350 kfree(starget);
351 put_device(parent);
352}
353
354static struct device_type scsi_target_type = {
355 .name = "scsi_target",
356 .release = scsi_target_dev_release,
357};
358
359int scsi_is_target_device(const struct device *dev)
360{
361 return dev->type == &scsi_target_type;
362}
363EXPORT_SYMBOL(scsi_is_target_device);
364
365static struct scsi_target *__scsi_find_target(struct device *parent,
366 int channel, uint id)
367{
368 struct scsi_target *starget, *found_starget = NULL;
369 struct Scsi_Host *shost = dev_to_shost(parent);
370
371
372
373 list_for_each_entry(starget, &shost->__targets, siblings) {
374 if (starget->id == id &&
375 starget->channel == channel) {
376 found_starget = starget;
377 break;
378 }
379 }
380 if (found_starget)
381 get_device(&found_starget->dev);
382
383 return found_starget;
384}
385
386
387
388
389
390
391
392
393
394
395
396
397
398static struct scsi_target *scsi_alloc_target(struct device *parent,
399 int channel, uint id)
400{
401 struct Scsi_Host *shost = dev_to_shost(parent);
402 struct device *dev = NULL;
403 unsigned long flags;
404 const int size = sizeof(struct scsi_target)
405 + shost->transportt->target_size;
406 struct scsi_target *starget;
407 struct scsi_target *found_target;
408 int error;
409
410 starget = kzalloc(size, GFP_KERNEL);
411 if (!starget) {
412 printk(KERN_ERR "%s: allocation failure\n", __func__);
413 return NULL;
414 }
415 dev = &starget->dev;
416 device_initialize(dev);
417 starget->reap_ref = 1;
418 dev->parent = get_device(parent);
419 dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
420 dev->bus = &scsi_bus_type;
421 dev->type = &scsi_target_type;
422 starget->id = id;
423 starget->channel = channel;
424 starget->can_queue = 0;
425 INIT_LIST_HEAD(&starget->siblings);
426 INIT_LIST_HEAD(&starget->devices);
427 starget->state = STARGET_CREATED;
428 starget->scsi_level = SCSI_2;
429 starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;
430 retry:
431 spin_lock_irqsave(shost->host_lock, flags);
432
433 found_target = __scsi_find_target(parent, channel, id);
434 if (found_target)
435 goto found;
436
437 list_add_tail(&starget->siblings, &shost->__targets);
438 spin_unlock_irqrestore(shost->host_lock, flags);
439
440 transport_setup_device(dev);
441 if (shost->hostt->target_alloc) {
442 error = shost->hostt->target_alloc(starget);
443
444 if(error) {
445 dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
446
447
448 scsi_target_destroy(starget);
449 return NULL;
450 }
451 }
452 get_device(dev);
453
454 return starget;
455
456 found:
457 found_target->reap_ref++;
458 spin_unlock_irqrestore(shost->host_lock, flags);
459 if (found_target->state != STARGET_DEL) {
460 put_device(dev);
461 return found_target;
462 }
463
464
465 put_device(&found_target->dev);
466 flush_scheduled_work();
467 goto retry;
468}
469
470static void scsi_target_reap_usercontext(struct work_struct *work)
471{
472 struct scsi_target *starget =
473 container_of(work, struct scsi_target, ew.work);
474
475 transport_remove_device(&starget->dev);
476 device_del(&starget->dev);
477 scsi_target_destroy(starget);
478}
479
480
481
482
483
484
485
486
487
488void scsi_target_reap(struct scsi_target *starget)
489{
490 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
491 unsigned long flags;
492 enum scsi_target_state state;
493 int empty = 0;
494
495 spin_lock_irqsave(shost->host_lock, flags);
496 state = starget->state;
497 if (--starget->reap_ref == 0 && list_empty(&starget->devices)) {
498 empty = 1;
499 starget->state = STARGET_DEL;
500 }
501 spin_unlock_irqrestore(shost->host_lock, flags);
502
503 if (!empty)
504 return;
505
506 BUG_ON(state == STARGET_DEL);
507 if (state == STARGET_CREATED)
508 scsi_target_destroy(starget);
509 else
510 execute_in_process_context(scsi_target_reap_usercontext,
511 &starget->ew);
512}
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528static void sanitize_inquiry_string(unsigned char *s, int len)
529{
530 int terminated = 0;
531
532 for (; len > 0; (--len, ++s)) {
533 if (*s == 0)
534 terminated = 1;
535 if (terminated || *s < 0x20 || *s > 0x7e)
536 *s = ' ';
537 }
538}
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
555 int result_len, int *bflags)
556{
557 unsigned char scsi_cmd[MAX_COMMAND_SIZE];
558 int first_inquiry_len, try_inquiry_len, next_inquiry_len;
559 int response_len = 0;
560 int pass, count, result;
561 struct scsi_sense_hdr sshdr;
562
563 *bflags = 0;
564
565
566
567
568 first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;
569 try_inquiry_len = first_inquiry_len;
570 pass = 1;
571
572 next_pass:
573 SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
574 "scsi scan: INQUIRY pass %d length %d\n",
575 pass, try_inquiry_len));
576
577
578 for (count = 0; count < 3; ++count) {
579 int resid;
580
581 memset(scsi_cmd, 0, 6);
582 scsi_cmd[0] = INQUIRY;
583 scsi_cmd[4] = (unsigned char) try_inquiry_len;
584
585 memset(inq_result, 0, try_inquiry_len);
586
587 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
588 inq_result, try_inquiry_len, &sshdr,
589 HZ / 2 + HZ * scsi_inq_timeout, 3,
590 &resid);
591
592 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY %s "
593 "with code 0x%x\n",
594 result ? "failed" : "successful", result));
595
596 if (result) {
597
598
599
600
601
602
603 if ((driver_byte(result) & DRIVER_SENSE) &&
604 scsi_sense_valid(&sshdr)) {
605 if ((sshdr.sense_key == UNIT_ATTENTION) &&
606 ((sshdr.asc == 0x28) ||
607 (sshdr.asc == 0x29)) &&
608 (sshdr.ascq == 0))
609 continue;
610 }
611 } else {
612
613
614
615
616
617 if (resid == try_inquiry_len)
618 continue;
619 }
620 break;
621 }
622
623 if (result == 0) {
624 sanitize_inquiry_string(&inq_result[8], 8);
625 sanitize_inquiry_string(&inq_result[16], 16);
626 sanitize_inquiry_string(&inq_result[32], 4);
627
628 response_len = inq_result[4] + 5;
629 if (response_len > 255)
630 response_len = first_inquiry_len;
631
632
633
634
635
636
637
638
639 *bflags = scsi_get_device_flags(sdev, &inq_result[8],
640 &inq_result[16]);
641
642
643
644 if (pass == 1) {
645 if (BLIST_INQUIRY_36 & *bflags)
646 next_inquiry_len = 36;
647 else if (BLIST_INQUIRY_58 & *bflags)
648 next_inquiry_len = 58;
649 else if (sdev->inquiry_len)
650 next_inquiry_len = sdev->inquiry_len;
651 else
652 next_inquiry_len = response_len;
653
654
655 if (next_inquiry_len > try_inquiry_len) {
656 try_inquiry_len = next_inquiry_len;
657 pass = 2;
658 goto next_pass;
659 }
660 }
661
662 } else if (pass == 2) {
663 printk(KERN_INFO "scsi scan: %d byte inquiry failed. "
664 "Consider BLIST_INQUIRY_36 for this device\n",
665 try_inquiry_len);
666
667
668
669 try_inquiry_len = first_inquiry_len;
670 pass = 3;
671 goto next_pass;
672 }
673
674
675
676 if (result)
677 return -EIO;
678
679
680 sdev->inquiry_len = min(try_inquiry_len, response_len);
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697 if (sdev->inquiry_len < 36) {
698 printk(KERN_INFO "scsi scan: INQUIRY result too short (%d),"
699 " using 36\n", sdev->inquiry_len);
700 sdev->inquiry_len = 36;
701 }
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721 sdev->scsi_level = inq_result[2] & 0x07;
722 if (sdev->scsi_level >= 2 ||
723 (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
724 sdev->scsi_level++;
725 sdev->sdev_target->scsi_level = sdev->scsi_level;
726
727 return 0;
728}
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
746 int *bflags, int async)
747{
748 int ret;
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770 sdev->inquiry = kmemdup(inq_result,
771 max_t(size_t, sdev->inquiry_len, 36),
772 GFP_ATOMIC);
773 if (sdev->inquiry == NULL)
774 return SCSI_SCAN_NO_RESPONSE;
775
776 sdev->vendor = (char *) (sdev->inquiry + 8);
777 sdev->model = (char *) (sdev->inquiry + 16);
778 sdev->rev = (char *) (sdev->inquiry + 32);
779
780 if (*bflags & BLIST_ISROM) {
781 sdev->type = TYPE_ROM;
782 sdev->removable = 1;
783 } else {
784 sdev->type = (inq_result[0] & 0x1f);
785 sdev->removable = (inq_result[1] & 0x80) >> 7;
786 }
787
788 switch (sdev->type) {
789 case TYPE_RBC:
790 case TYPE_TAPE:
791 case TYPE_DISK:
792 case TYPE_PRINTER:
793 case TYPE_MOD:
794 case TYPE_PROCESSOR:
795 case TYPE_SCANNER:
796 case TYPE_MEDIUM_CHANGER:
797 case TYPE_ENCLOSURE:
798 case TYPE_COMM:
799 case TYPE_RAID:
800 case TYPE_OSD:
801 sdev->writeable = 1;
802 break;
803 case TYPE_ROM:
804 case TYPE_WORM:
805 sdev->writeable = 0;
806 break;
807 default:
808 printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);
809 }
810
811 if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {
812
813
814
815
816 if ((*bflags & BLIST_REPORTLUN2) == 0)
817 *bflags |= BLIST_NOREPORTLUN;
818 }
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836 sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;
837 sdev->lockable = sdev->removable;
838 sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);
839
840 if (sdev->scsi_level >= SCSI_3 ||
841 (sdev->inquiry_len > 56 && inq_result[56] & 0x04))
842 sdev->ppr = 1;
843 if (inq_result[7] & 0x60)
844 sdev->wdtr = 1;
845 if (inq_result[7] & 0x10)
846 sdev->sdtr = 1;
847
848 sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "
849 "ANSI: %d%s\n", scsi_device_type(sdev->type),
850 sdev->vendor, sdev->model, sdev->rev,
851 sdev->inq_periph_qual, inq_result[2] & 0x07,
852 (inq_result[3] & 0x0f) == 1 ? " CCS" : "");
853
854 if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
855 !(*bflags & BLIST_NOTQ))
856 sdev->tagged_supported = 1;
857
858
859
860
861
862
863 if ((*bflags & BLIST_BORKEN) == 0)
864 sdev->borken = 0;
865
866 if (*bflags & BLIST_NO_ULD_ATTACH)
867 sdev->no_uld_attach = 1;
868
869
870
871
872
873 if (*bflags & BLIST_SELECT_NO_ATN)
874 sdev->select_no_atn = 1;
875
876
877
878
879
880 if (*bflags & BLIST_MAX_512)
881 blk_queue_max_hw_sectors(sdev->request_queue, 512);
882
883
884
885
886
887 if (*bflags & BLIST_NOSTARTONADD)
888 sdev->no_start_on_add = 1;
889
890 if (*bflags & BLIST_SINGLELUN)
891 scsi_target(sdev)->single_lun = 1;
892
893 sdev->use_10_for_rw = 1;
894
895 if (*bflags & BLIST_MS_SKIP_PAGE_08)
896 sdev->skip_ms_page_8 = 1;
897
898 if (*bflags & BLIST_MS_SKIP_PAGE_3F)
899 sdev->skip_ms_page_3f = 1;
900
901 if (*bflags & BLIST_USE_10_BYTE_MS)
902 sdev->use_10_for_ms = 1;
903
904
905
906 ret = scsi_device_set_state(sdev, SDEV_RUNNING);
907 if (ret) {
908 ret = scsi_device_set_state(sdev, SDEV_BLOCK);
909
910 if (ret) {
911 sdev_printk(KERN_ERR, sdev,
912 "in wrong state %s to complete scan\n",
913 scsi_device_state_name(sdev->sdev_state));
914 return SCSI_SCAN_NO_RESPONSE;
915 }
916 }
917
918 if (*bflags & BLIST_MS_192_BYTES_FOR_3F)
919 sdev->use_192_bytes_for_3f = 1;
920
921 if (*bflags & BLIST_NOT_LOCKABLE)
922 sdev->lockable = 0;
923
924 if (*bflags & BLIST_RETRY_HWERROR)
925 sdev->retry_hwerror = 1;
926
927 transport_configure_device(&sdev->sdev_gendev);
928
929 if (sdev->host->hostt->slave_configure) {
930 ret = sdev->host->hostt->slave_configure(sdev);
931 if (ret) {
932
933
934
935
936 if (ret != -ENXIO) {
937 sdev_printk(KERN_ERR, sdev,
938 "failed to configure device\n");
939 }
940 return SCSI_SCAN_NO_RESPONSE;
941 }
942 }
943
944 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
1304static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
1305 int rescan)
1306{
1307 char devname[64];
1308 unsigned char scsi_cmd[MAX_COMMAND_SIZE];
1309 unsigned int length;
1310 unsigned int lun;
1311 unsigned int num_luns;
1312 unsigned int retries;
1313 int result;
1314 struct scsi_lun *lunp, *lun_data;
1315 u8 *data;
1316 struct scsi_sense_hdr sshdr;
1317 struct scsi_device *sdev;
1318 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1319 int ret = 0;
1320
1321
1322
1323
1324
1325
1326 if (bflags & BLIST_NOREPORTLUN)
1327 return 1;
1328 if (starget->scsi_level < SCSI_2 &&
1329 starget->scsi_level != SCSI_UNKNOWN)
1330 return 1;
1331 if (starget->scsi_level < SCSI_3 &&
1332 (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))
1333 return 1;
1334 if (bflags & BLIST_NOLUN)
1335 return 0;
1336
1337 if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
1338 sdev = scsi_alloc_sdev(starget, 0, NULL);
1339 if (!sdev)
1340 return 0;
1341 if (scsi_device_get(sdev)) {
1342 __scsi_remove_device(sdev);
1343 return 0;
1344 }
1345 }
1346
1347 sprintf(devname, "host %d channel %d id %d",
1348 shost->host_no, sdev->channel, sdev->id);
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360 length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
1361 lun_data = kmalloc(length, GFP_ATOMIC |
1362 (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
1363 if (!lun_data) {
1364 printk(ALLOC_FAILURE_MSG, __func__);
1365 goto out;
1366 }
1367
1368 scsi_cmd[0] = REPORT_LUNS;
1369
1370
1371
1372
1373 memset(&scsi_cmd[1], 0, 5);
1374
1375
1376
1377
1378 scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
1379 scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
1380 scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
1381 scsi_cmd[9] = (unsigned char) length & 0xff;
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, printk (KERN_INFO "scsi scan: Sending"
1398 " REPORT LUNS to %s (try %d)\n", devname,
1399 retries));
1400
1401 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
1402 lun_data, length, &sshdr,
1403 SCSI_TIMEOUT + 4 * HZ, 3, NULL);
1404
1405 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS"
1406 " %s (try %d) result 0x%x\n", result
1407 ? "failed" : "successful", retries, result));
1408 if (result == 0)
1409 break;
1410 else if (scsi_sense_valid(&sshdr)) {
1411 if (sshdr.sense_key != UNIT_ATTENTION)
1412 break;
1413 }
1414 }
1415
1416 if (result) {
1417
1418
1419
1420 ret = 1;
1421 goto out_err;
1422 }
1423
1424
1425
1426
1427 data = (u8 *) lun_data->scsi_lun;
1428 length = ((data[0] << 24) | (data[1] << 16) |
1429 (data[2] << 8) | (data[3] << 0));
1430
1431 num_luns = (length / sizeof(struct scsi_lun));
1432 if (num_luns > max_scsi_report_luns) {
1433 printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"
1434 " of %d luns reported, try increasing"
1435 " max_scsi_report_luns.\n", devname,
1436 max_scsi_report_luns, num_luns);
1437 num_luns = max_scsi_report_luns;
1438 }
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
1451
1452
1453
1454 if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {
1455 int i;
1456
1457
1458
1459
1460
1461
1462 printk(KERN_WARNING "scsi: %s lun 0x", devname);
1463 data = (char *)lunp->scsi_lun;
1464 for (i = 0; i < sizeof(struct scsi_lun); i++)
1465 printk("%02x", data[i]);
1466 printk(" has a LUN larger than currently supported.\n");
1467 } else if (lun > sdev->host->max_lun) {
1468 printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"
1469 " than allowed by the host adapter\n",
1470 devname, lun);
1471 } else {
1472 int res;
1473
1474 res = scsi_probe_and_add_lun(starget,
1475 lun, NULL, NULL, rescan, NULL);
1476 if (res == SCSI_SCAN_NO_RESPONSE) {
1477
1478
1479
1480 sdev_printk(KERN_ERR, sdev,
1481 "Unexpected response"
1482 " from lun %d while scanning, scan"
1483 " aborted\n", lun);
1484 break;
1485 }
1486 }
1487 }
1488
1489 out_err:
1490 kfree(lun_data);
1491 out:
1492 scsi_device_put(sdev);
1493 if (scsi_device_created(sdev))
1494
1495
1496
1497 __scsi_remove_device(sdev);
1498 return ret;
1499}
1500
1501struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
1502 uint id, uint lun, void *hostdata)
1503{
1504 struct scsi_device *sdev = ERR_PTR(-ENODEV);
1505 struct device *parent = &shost->shost_gendev;
1506 struct scsi_target *starget;
1507
1508 if (strncmp(scsi_scan_type, "none", 4) == 0)
1509 return ERR_PTR(-ENODEV);
1510
1511 starget = scsi_alloc_target(parent, channel, id);
1512 if (!starget)
1513 return ERR_PTR(-ENOMEM);
1514 scsi_autopm_get_target(starget);
1515
1516 mutex_lock(&shost->scan_mutex);
1517 if (!shost->async_scan)
1518 scsi_complete_async_scans();
1519
1520 if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1521 scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
1522 scsi_autopm_put_host(shost);
1523 }
1524 mutex_unlock(&shost->scan_mutex);
1525 scsi_autopm_put_target(starget);
1526 scsi_target_reap(starget);
1527 put_device(&starget->dev);
1528
1529 return sdev;
1530}
1531EXPORT_SYMBOL(__scsi_add_device);
1532
1533int scsi_add_device(struct Scsi_Host *host, uint channel,
1534 uint target, uint lun)
1535{
1536 struct scsi_device *sdev =
1537 __scsi_add_device(host, channel, target, lun, NULL);
1538 if (IS_ERR(sdev))
1539 return PTR_ERR(sdev);
1540
1541 scsi_device_put(sdev);
1542 return 0;
1543}
1544EXPORT_SYMBOL(scsi_add_device);
1545
1546void scsi_rescan_device(struct device *dev)
1547{
1548 struct scsi_driver *drv;
1549
1550 if (!dev->driver)
1551 return;
1552
1553 drv = to_scsi_driver(dev->driver);
1554 if (try_module_get(drv->owner)) {
1555 if (drv->rescan)
1556 drv->rescan(dev);
1557 module_put(drv->owner);
1558 }
1559}
1560EXPORT_SYMBOL(scsi_rescan_device);
1561
1562static void __scsi_scan_target(struct device *parent, unsigned int channel,
1563 unsigned int id, unsigned int lun, int rescan)
1564{
1565 struct Scsi_Host *shost = dev_to_shost(parent);
1566 int bflags = 0;
1567 int res;
1568 struct scsi_target *starget;
1569
1570 if (shost->this_id == id)
1571
1572
1573
1574 return;
1575
1576 starget = scsi_alloc_target(parent, channel, id);
1577 if (!starget)
1578 return;
1579 scsi_autopm_get_target(starget);
1580
1581 if (lun != SCAN_WILD_CARD) {
1582
1583
1584
1585 scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
1586 goto out_reap;
1587 }
1588
1589
1590
1591
1592
1593 res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
1594 if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
1595 if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
1596
1597
1598
1599
1600 scsi_sequential_lun_scan(starget, bflags,
1601 starget->scsi_level, rescan);
1602 }
1603
1604 out_reap:
1605 scsi_autopm_put_target(starget);
1606
1607
1608 scsi_target_reap(starget);
1609
1610 put_device(&starget->dev);
1611}
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628void scsi_scan_target(struct device *parent, unsigned int channel,
1629 unsigned int id, unsigned int lun, int rescan)
1630{
1631 struct Scsi_Host *shost = dev_to_shost(parent);
1632
1633 if (strncmp(scsi_scan_type, "none", 4) == 0)
1634 return;
1635
1636 mutex_lock(&shost->scan_mutex);
1637 if (!shost->async_scan)
1638 scsi_complete_async_scans();
1639
1640 if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1641 __scsi_scan_target(parent, channel, id, lun, rescan);
1642 scsi_autopm_put_host(shost);
1643 }
1644 mutex_unlock(&shost->scan_mutex);
1645}
1646EXPORT_SYMBOL(scsi_scan_target);
1647
1648static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
1649 unsigned int id, unsigned int lun, int rescan)
1650{
1651 uint order_id;
1652
1653 if (id == SCAN_WILD_CARD)
1654 for (id = 0; id < shost->max_id; ++id) {
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664 if (shost->reverse_ordering)
1665
1666
1667
1668 order_id = shost->max_id - id - 1;
1669 else
1670 order_id = id;
1671 __scsi_scan_target(&shost->shost_gendev, channel,
1672 order_id, lun, rescan);
1673 }
1674 else
1675 __scsi_scan_target(&shost->shost_gendev, channel,
1676 id, lun, rescan);
1677}
1678
1679int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
1680 unsigned int id, unsigned int lun, int rescan)
1681{
1682 SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
1683 "%s: <%u:%u:%u>\n",
1684 __func__, channel, id, lun));
1685
1686 if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
1687 ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
1688 ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
1689 return -EINVAL;
1690
1691 mutex_lock(&shost->scan_mutex);
1692 if (!shost->async_scan)
1693 scsi_complete_async_scans();
1694
1695 if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1696 if (channel == SCAN_WILD_CARD)
1697 for (channel = 0; channel <= shost->max_channel;
1698 channel++)
1699 scsi_scan_channel(shost, channel, id, lun,
1700 rescan);
1701 else
1702 scsi_scan_channel(shost, channel, id, lun, rescan);
1703 scsi_autopm_put_host(shost);
1704 }
1705 mutex_unlock(&shost->scan_mutex);
1706
1707 return 0;
1708}
1709
1710static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
1711{
1712 struct scsi_device *sdev;
1713 shost_for_each_device(sdev, shost) {
1714 if (!scsi_host_scan_allowed(shost) ||
1715 scsi_sysfs_add_sdev(sdev) != 0)
1716 __scsi_remove_device(sdev);
1717 }
1718}
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
1731{
1732 struct async_scan_data *data;
1733 unsigned long flags;
1734
1735 if (strncmp(scsi_scan_type, "sync", 4) == 0)
1736 return NULL;
1737
1738 if (shost->async_scan) {
1739 printk("%s called twice for host %d", __func__,
1740 shost->host_no);
1741 dump_stack();
1742 return NULL;
1743 }
1744
1745 data = kmalloc(sizeof(*data), GFP_KERNEL);
1746 if (!data)
1747 goto err;
1748 data->shost = scsi_host_get(shost);
1749 if (!data->shost)
1750 goto err;
1751 init_completion(&data->prev_finished);
1752
1753 mutex_lock(&shost->scan_mutex);
1754 spin_lock_irqsave(shost->host_lock, flags);
1755 shost->async_scan = 1;
1756 spin_unlock_irqrestore(shost->host_lock, flags);
1757 mutex_unlock(&shost->scan_mutex);
1758
1759 spin_lock(&async_scan_lock);
1760 if (list_empty(&scanning_hosts))
1761 complete(&data->prev_finished);
1762 list_add_tail(&data->list, &scanning_hosts);
1763 spin_unlock(&async_scan_lock);
1764
1765 return data;
1766
1767 err:
1768 kfree(data);
1769 return NULL;
1770}
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780static void scsi_finish_async_scan(struct async_scan_data *data)
1781{
1782 struct Scsi_Host *shost;
1783 unsigned long flags;
1784
1785 if (!data)
1786 return;
1787
1788 shost = data->shost;
1789
1790 mutex_lock(&shost->scan_mutex);
1791
1792 if (!shost->async_scan) {
1793 printk("%s called twice for host %d", __func__,
1794 shost->host_no);
1795 dump_stack();
1796 mutex_unlock(&shost->scan_mutex);
1797 return;
1798 }
1799
1800 wait_for_completion(&data->prev_finished);
1801
1802 scsi_sysfs_add_devices(shost);
1803
1804 spin_lock_irqsave(shost->host_lock, flags);
1805 shost->async_scan = 0;
1806 spin_unlock_irqrestore(shost->host_lock, flags);
1807
1808 mutex_unlock(&shost->scan_mutex);
1809
1810 spin_lock(&async_scan_lock);
1811 list_del(&data->list);
1812 if (!list_empty(&scanning_hosts)) {
1813 struct async_scan_data *next = list_entry(scanning_hosts.next,
1814 struct async_scan_data, list);
1815 complete(&next->prev_finished);
1816 }
1817 spin_unlock(&async_scan_lock);
1818
1819 scsi_host_put(shost);
1820 kfree(data);
1821}
1822
1823static void do_scsi_scan_host(struct Scsi_Host *shost)
1824{
1825 if (shost->hostt->scan_finished) {
1826 unsigned long start = jiffies;
1827 if (shost->hostt->scan_start)
1828 shost->hostt->scan_start(shost);
1829
1830 while (!shost->hostt->scan_finished(shost, jiffies - start))
1831 msleep(10);
1832 } else {
1833 scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
1834 SCAN_WILD_CARD, 0);
1835 }
1836}
1837
1838static int do_scan_async(void *_data)
1839{
1840 struct async_scan_data *data = _data;
1841 struct Scsi_Host *shost = data->shost;
1842
1843 do_scsi_scan_host(shost);
1844 scsi_finish_async_scan(data);
1845 scsi_autopm_put_host(shost);
1846 return 0;
1847}
1848
1849
1850
1851
1852
1853void scsi_scan_host(struct Scsi_Host *shost)
1854{
1855 struct task_struct *p;
1856 struct async_scan_data *data;
1857
1858 if (strncmp(scsi_scan_type, "none", 4) == 0)
1859 return;
1860 if (scsi_autopm_get_host(shost) < 0)
1861 return;
1862
1863 data = scsi_prep_async_scan(shost);
1864 if (!data) {
1865 do_scsi_scan_host(shost);
1866 scsi_autopm_put_host(shost);
1867 return;
1868 }
1869
1870 p = kthread_run(do_scan_async, data, "scsi_scan_%d", shost->host_no);
1871 if (IS_ERR(p))
1872 do_scan_async(data);
1873
1874}
1875EXPORT_SYMBOL(scsi_scan_host);
1876
1877void scsi_forget_host(struct Scsi_Host *shost)
1878{
1879 struct scsi_device *sdev;
1880 unsigned long flags;
1881
1882 restart:
1883 spin_lock_irqsave(shost->host_lock, flags);
1884 list_for_each_entry(sdev, &shost->__devices, siblings) {
1885 if (sdev->sdev_state == SDEV_DEL)
1886 continue;
1887 spin_unlock_irqrestore(shost->host_lock, flags);
1888 __scsi_remove_device(sdev);
1889 goto restart;
1890 }
1891 spin_unlock_irqrestore(shost->host_lock, flags);
1892}
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
1912{
1913 struct scsi_device *sdev = NULL;
1914 struct scsi_target *starget;
1915
1916 mutex_lock(&shost->scan_mutex);
1917 if (!scsi_host_scan_allowed(shost))
1918 goto out;
1919 starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
1920 if (!starget)
1921 goto out;
1922
1923 sdev = scsi_alloc_sdev(starget, 0, NULL);
1924 if (sdev)
1925 sdev->borken = 0;
1926 else
1927 scsi_target_reap(starget);
1928 put_device(&starget->dev);
1929 out:
1930 mutex_unlock(&shost->scan_mutex);
1931 return sdev;
1932}
1933EXPORT_SYMBOL(scsi_get_host_dev);
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943void scsi_free_host_dev(struct scsi_device *sdev)
1944{
1945 BUG_ON(sdev->id != sdev->host->this_id);
1946
1947 __scsi_remove_device(sdev);
1948}
1949EXPORT_SYMBOL(scsi_free_host_dev);
1950
1951