Branch data Line data Source code
1 : : /*
2 : : * scsi_scan.c
3 : : *
4 : : * Copyright (C) 2000 Eric Youngdale,
5 : : * Copyright (C) 2002 Patrick Mansfield
6 : : *
7 : : * The general scanning/probing algorithm is as follows, exceptions are
8 : : * made to it depending on device specific flags, compilation options, and
9 : : * global variable (boot or module load time) settings.
10 : : *
11 : : * A specific LUN is scanned via an INQUIRY command; if the LUN has a
12 : : * device attached, a scsi_device is allocated and setup for it.
13 : : *
14 : : * For every id of every channel on the given host:
15 : : *
16 : : * Scan LUN 0; if the target responds to LUN 0 (even if there is no
17 : : * device or storage attached to LUN 0):
18 : : *
19 : : * If LUN 0 has a device attached, allocate and setup a
20 : : * scsi_device for it.
21 : : *
22 : : * If target is SCSI-3 or up, issue a REPORT LUN, and scan
23 : : * all of the LUNs returned by the REPORT LUN; else,
24 : : * sequentially scan LUNs up until some maximum is reached,
25 : : * or a LUN is seen that cannot have a device attached to it.
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 : : * Default timeout
55 : : */
56 : : #define SCSI_TIMEOUT (2*HZ)
57 : :
58 : : /*
59 : : * Prefix values for the SCSI id's (stored in sysfs name field)
60 : : */
61 : : #define SCSI_UID_SER_NUM 'S'
62 : : #define SCSI_UID_UNKNOWN 'Z'
63 : :
64 : : /*
65 : : * Return values of some of the scanning functions.
66 : : *
67 : : * SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this
68 : : * includes allocation or general failures preventing IO from being sent.
69 : : *
70 : : * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available
71 : : * on the given LUN.
72 : : *
73 : : * SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a
74 : : * given LUN.
75 : : */
76 : : #define SCSI_SCAN_NO_RESPONSE 0
77 : : #define SCSI_SCAN_TARGET_PRESENT 1
78 : : #define SCSI_SCAN_LUN_PRESENT 2
79 : :
80 : : static const char *scsi_null_device_strs = "nullnullnullnull";
81 : :
82 : : #define MAX_SCSI_LUNS 512
83 : :
84 : : #ifdef CONFIG_SCSI_MULTI_LUN
85 : : static unsigned int max_scsi_luns = MAX_SCSI_LUNS;
86 : : #else
87 : : static unsigned int max_scsi_luns = 1;
88 : : #endif
89 : :
90 : : module_param_named(max_luns, max_scsi_luns, uint, S_IRUGO|S_IWUSR);
91 : : MODULE_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 : :
100 : : static char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
101 : :
102 : : module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
103 : : MODULE_PARM_DESC(scan, "sync, async or none");
104 : :
105 : : /*
106 : : * max_scsi_report_luns: the maximum number of LUNS that will be
107 : : * returned from the REPORT LUNS command. 8 times this value must
108 : : * be allocated. In theory this could be up to an 8 byte value, but
109 : : * in practice, the maximum number of LUNs suppored by any device
110 : : * is about 16k.
111 : : */
112 : : static unsigned int max_scsi_report_luns = 511;
113 : :
114 : : module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);
115 : : MODULE_PARM_DESC(max_report_luns,
116 : : "REPORT LUNS maximum number of LUNS received (should be"
117 : : " between 1 and 16384)");
118 : :
119 : : static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
120 : :
121 : : module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
122 : : MODULE_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 : : /* This lock protects only this list */
127 : : static DEFINE_SPINLOCK(async_scan_lock);
128 : : static LIST_HEAD(scanning_hosts);
129 : :
130 : : struct async_scan_data {
131 : : struct list_head list;
132 : : struct Scsi_Host *shost;
133 : : struct completion prev_finished;
134 : : };
135 : :
136 : : /**
137 : : * scsi_complete_async_scans - Wait for asynchronous scans to complete
138 : : *
139 : : * When this function returns, any host which started scanning before
140 : : * this function was called will have finished its scan. Hosts which
141 : : * started scanning after this function was called may or may not have
142 : : * finished.
143 : : */
144 : 0 : int scsi_complete_async_scans(void)
145 : : {
146 : : struct async_scan_data *data;
147 : :
148 : : do {
149 [ # # ]: 0 : if (list_empty(&scanning_hosts))
150 : : return 0;
151 : : /* If we can't get memory immediately, that's OK. Just
152 : : * sleep a little. Even if we never get memory, the async
153 : : * scans will finish eventually.
154 : : */
155 : : data = kmalloc(sizeof(*data), GFP_KERNEL);
156 [ # # ]: 0 : if (!data)
157 : 0 : msleep(1);
158 [ # # ]: 0 : } while (!data);
159 : :
160 : 0 : data->shost = NULL;
161 : : init_completion(&data->prev_finished);
162 : :
163 : : spin_lock(&async_scan_lock);
164 : : /* Check that there's still somebody else on the list */
165 [ # # ]: 0 : if (list_empty(&scanning_hosts))
166 : : goto done;
167 : 0 : list_add_tail(&data->list, &scanning_hosts);
168 : : spin_unlock(&async_scan_lock);
169 : :
170 : 0 : printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");
171 : 0 : wait_for_completion(&data->prev_finished);
172 : :
173 : : spin_lock(&async_scan_lock);
174 : : list_del(&data->list);
175 [ # # ]: 0 : if (!list_empty(&scanning_hosts)) {
176 : : struct async_scan_data *next = list_entry(scanning_hosts.next,
177 : : struct async_scan_data, list);
178 : 0 : complete(&next->prev_finished);
179 : : }
180 : : done:
181 : : spin_unlock(&async_scan_lock);
182 : :
183 : 0 : kfree(data);
184 : 0 : return 0;
185 : : }
186 : :
187 : : /**
188 : : * scsi_unlock_floptical - unlock device via a special MODE SENSE command
189 : : * @sdev: scsi device to send command to
190 : : * @result: area to store the result of the MODE SENSE
191 : : *
192 : : * Description:
193 : : * Send a vendor specific MODE SENSE (not a MODE SELECT) command.
194 : : * Called for BLIST_KEY devices.
195 : : **/
196 : 0 : static void scsi_unlock_floptical(struct scsi_device *sdev,
197 : : unsigned char *result)
198 : : {
199 : : unsigned char scsi_cmd[MAX_COMMAND_SIZE];
200 : :
201 : 0 : printk(KERN_NOTICE "scsi: unlocking floptical drive\n");
202 : 0 : scsi_cmd[0] = MODE_SENSE;
203 : 0 : scsi_cmd[1] = 0;
204 : 0 : scsi_cmd[2] = 0x2e;
205 : 0 : scsi_cmd[3] = 0;
206 : 0 : scsi_cmd[4] = 0x2a; /* size */
207 : 0 : scsi_cmd[5] = 0;
208 : : scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
209 : : SCSI_TIMEOUT, 3, NULL);
210 : 0 : }
211 : :
212 : : /**
213 : : * scsi_alloc_sdev - allocate and setup a scsi_Device
214 : : * @starget: which target to allocate a &scsi_device for
215 : : * @lun: which lun
216 : : * @hostdata: usually NULL and set by ->slave_alloc instead
217 : : *
218 : : * Description:
219 : : * Allocate, initialize for io, and return a pointer to a scsi_Device.
220 : : * Stores the @shost, @channel, @id, and @lun in the scsi_Device, and
221 : : * adds scsi_Device to the appropriate list.
222 : : *
223 : : * Return value:
224 : : * scsi_Device pointer, or NULL on failure.
225 : : **/
226 : 0 : static 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 : 0 : 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 : 0 : sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
236 : : GFP_ATOMIC);
237 [ # # ]: 0 : if (!sdev)
238 : : goto out;
239 : :
240 : 0 : sdev->vendor = scsi_null_device_strs;
241 : 0 : sdev->model = scsi_null_device_strs;
242 : 0 : sdev->rev = scsi_null_device_strs;
243 : 0 : sdev->host = shost;
244 : 0 : sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
245 : 0 : sdev->id = starget->id;
246 : 0 : sdev->lun = lun;
247 : 0 : sdev->channel = starget->channel;
248 : 0 : sdev->sdev_state = SDEV_CREATED;
249 : 0 : INIT_LIST_HEAD(&sdev->siblings);
250 : 0 : INIT_LIST_HEAD(&sdev->same_target_siblings);
251 : 0 : INIT_LIST_HEAD(&sdev->cmd_list);
252 : 0 : INIT_LIST_HEAD(&sdev->starved_entry);
253 : 0 : INIT_LIST_HEAD(&sdev->event_list);
254 : 0 : spin_lock_init(&sdev->list_lock);
255 : 0 : INIT_WORK(&sdev->event_work, scsi_evt_thread);
256 : 0 : INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);
257 : :
258 : 0 : sdev->sdev_gendev.parent = get_device(&starget->dev);
259 : 0 : sdev->sdev_target = starget;
260 : :
261 : : /* usually NULL and set by ->slave_alloc instead */
262 : 0 : sdev->hostdata = hostdata;
263 : :
264 : : /* if the device needs this changing, it may do so in the
265 : : * slave_configure function */
266 : 0 : sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
267 : :
268 : : /*
269 : : * Some low level driver could use device->type
270 : : */
271 : 0 : sdev->type = -1;
272 : :
273 : : /*
274 : : * Assume that the device will have handshaking problems,
275 : : * and then fix this field later if it turns out it
276 : : * doesn't
277 : : */
278 : 0 : sdev->borken = 1;
279 : :
280 : 0 : sdev->request_queue = scsi_alloc_queue(sdev);
281 [ # # ]: 0 : if (!sdev->request_queue) {
282 : : /* release fn is set up in scsi_sysfs_device_initialise, so
283 : : * have to free and put manually here */
284 : 0 : put_device(&starget->dev);
285 : 0 : kfree(sdev);
286 : 0 : goto out;
287 : : }
288 [ # # ][ # # ]: 0 : WARN_ON_ONCE(!blk_get_queue(sdev->request_queue));
[ # # ]
289 : 0 : sdev->request_queue->queuedata = sdev;
290 : 0 : scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
291 : :
292 : 0 : scsi_sysfs_device_initialize(sdev);
293 : :
294 [ # # ]: 0 : if (shost->hostt->slave_alloc) {
295 : 0 : ret = shost->hostt->slave_alloc(sdev);
296 [ # # ]: 0 : if (ret) {
297 : : /*
298 : : * if LLDD reports slave not present, don't clutter
299 : : * console with alloc failure messages
300 : : */
301 [ # # ]: 0 : if (ret == -ENXIO)
302 : : display_failure_msg = 0;
303 : : goto out_device_destroy;
304 : : }
305 : : }
306 : :
307 : 0 : return sdev;
308 : :
309 : : out_device_destroy:
310 : 0 : __scsi_remove_device(sdev);
311 : : out:
312 [ # # ]: 0 : if (display_failure_msg)
313 : 0 : printk(ALLOC_FAILURE_MSG, __func__);
314 : : return NULL;
315 : : }
316 : :
317 : 0 : static void scsi_target_destroy(struct scsi_target *starget)
318 : : {
319 : 0 : struct device *dev = &starget->dev;
320 : 0 : struct Scsi_Host *shost = dev_to_shost(dev->parent);
321 : : unsigned long flags;
322 : :
323 : 0 : transport_destroy_device(dev);
324 : 0 : spin_lock_irqsave(shost->host_lock, flags);
325 [ # # ]: 0 : if (shost->hostt->target_destroy)
326 : 0 : shost->hostt->target_destroy(starget);
327 : 0 : list_del_init(&starget->siblings);
328 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
329 : 0 : put_device(dev);
330 : 0 : }
331 : :
332 : 0 : static void scsi_target_dev_release(struct device *dev)
333 : : {
334 : 0 : struct device *parent = dev->parent;
335 : 0 : struct scsi_target *starget = to_scsi_target(dev);
336 : :
337 : 0 : kfree(starget);
338 : 0 : put_device(parent);
339 : 0 : }
340 : :
341 : : static struct device_type scsi_target_type = {
342 : : .name = "scsi_target",
343 : : .release = scsi_target_dev_release,
344 : : };
345 : :
346 : 0 : int scsi_is_target_device(const struct device *dev)
347 : : {
348 : 0 : return dev->type == &scsi_target_type;
349 : : }
350 : : EXPORT_SYMBOL(scsi_is_target_device);
351 : :
352 : 0 : static 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 : : * Search for an existing target for this sdev.
359 : : */
360 [ # # ]: 0 : list_for_each_entry(starget, &shost->__targets, siblings) {
361 [ # # ][ # # ]: 0 : if (starget->id == id &&
362 : 0 : starget->channel == channel) {
363 : : found_starget = starget;
364 : : break;
365 : : }
366 : : }
367 [ # # ]: 0 : if (found_starget)
368 : 0 : get_device(&found_starget->dev);
369 : :
370 : 0 : return found_starget;
371 : : }
372 : :
373 : : /**
374 : : * scsi_alloc_target - allocate a new or find an existing target
375 : : * @parent: parent of the target (need not be a scsi host)
376 : : * @channel: target channel number (zero if no channels)
377 : : * @id: target id number
378 : : *
379 : : * Return an existing target if one exists, provided it hasn't already
380 : : * gone into STARGET_DEL state, otherwise allocate a new target.
381 : : *
382 : : * The target is returned with an incremented reference, so the caller
383 : : * is responsible for both reaping and doing a last put
384 : : */
385 : 0 : static 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 : 0 : + 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 [ # # ]: 0 : if (!starget) {
399 : 0 : printk(KERN_ERR "%s: allocation failure\n", __func__);
400 : 0 : return NULL;
401 : : }
402 : 0 : dev = &starget->dev;
403 : 0 : device_initialize(dev);
404 : 0 : starget->reap_ref = 1;
405 : 0 : dev->parent = get_device(parent);
406 : 0 : dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
407 : 0 : dev->bus = &scsi_bus_type;
408 : 0 : dev->type = &scsi_target_type;
409 : 0 : starget->id = id;
410 : 0 : starget->channel = channel;
411 : 0 : starget->can_queue = 0;
412 : 0 : INIT_LIST_HEAD(&starget->siblings);
413 : 0 : INIT_LIST_HEAD(&starget->devices);
414 : 0 : starget->state = STARGET_CREATED;
415 : 0 : starget->scsi_level = SCSI_2;
416 : 0 : starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;
417 : : retry:
418 : 0 : spin_lock_irqsave(shost->host_lock, flags);
419 : :
420 : 0 : found_target = __scsi_find_target(parent, channel, id);
421 [ # # ]: 0 : if (found_target)
422 : : goto found;
423 : :
424 : 0 : list_add_tail(&starget->siblings, &shost->__targets);
425 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
426 : : /* allocate and add */
427 : 0 : transport_setup_device(dev);
428 [ # # ]: 0 : if (shost->hostt->target_alloc) {
429 : 0 : error = shost->hostt->target_alloc(starget);
430 : :
431 [ # # ]: 0 : if(error) {
432 : 0 : dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
433 : : /* don't want scsi_target_reap to do the final
434 : : * put because it will be under the host lock */
435 : 0 : scsi_target_destroy(starget);
436 : 0 : return NULL;
437 : : }
438 : : }
439 : 0 : get_device(dev);
440 : :
441 : 0 : return starget;
442 : :
443 : : found:
444 : 0 : found_target->reap_ref++;
445 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
446 [ # # ]: 0 : if (found_target->state != STARGET_DEL) {
447 : 0 : put_device(dev);
448 : 0 : return found_target;
449 : : }
450 : : /* Unfortunately, we found a dying target; need to
451 : : * wait until it's dead before we can get a new one */
452 : 0 : put_device(&found_target->dev);
453 : 0 : flush_scheduled_work();
454 : 0 : goto retry;
455 : : }
456 : :
457 : 0 : static void scsi_target_reap_usercontext(struct work_struct *work)
458 : : {
459 : 0 : struct scsi_target *starget =
460 : : container_of(work, struct scsi_target, ew.work);
461 : :
462 : 0 : transport_remove_device(&starget->dev);
463 : 0 : device_del(&starget->dev);
464 : 0 : scsi_target_destroy(starget);
465 : 0 : }
466 : :
467 : : /**
468 : : * scsi_target_reap - check to see if target is in use and destroy if not
469 : : * @starget: target to be checked
470 : : *
471 : : * This is used after removing a LUN or doing a last put of the target
472 : : * it checks atomically that nothing is using the target and removes
473 : : * it if so.
474 : : */
475 : 0 : void scsi_target_reap(struct scsi_target *starget)
476 : : {
477 : 0 : 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 : 0 : spin_lock_irqsave(shost->host_lock, flags);
483 : 0 : state = starget->state;
484 [ # # ][ # # ]: 0 : if (--starget->reap_ref == 0 && list_empty(&starget->devices)) {
485 : : empty = 1;
486 : 0 : starget->state = STARGET_DEL;
487 : : }
488 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
489 : :
490 [ # # ]: 0 : if (!empty)
491 : 0 : return;
492 : :
493 [ # # ]: 0 : BUG_ON(state == STARGET_DEL);
494 [ # # ]: 0 : if (state == STARGET_CREATED)
495 : 0 : scsi_target_destroy(starget);
496 : : else
497 : 0 : execute_in_process_context(scsi_target_reap_usercontext,
498 : : &starget->ew);
499 : : }
500 : :
501 : : /**
502 : : * sanitize_inquiry_string - remove non-graphical chars from an INQUIRY result string
503 : : * @s: INQUIRY result string to sanitize
504 : : * @len: length of the string
505 : : *
506 : : * Description:
507 : : * The SCSI spec says that INQUIRY vendor, product, and revision
508 : : * strings must consist entirely of graphic ASCII characters,
509 : : * padded on the right with spaces. Since not all devices obey
510 : : * this rule, we will replace non-graphic or non-ASCII characters
511 : : * with spaces. Exception: a NUL character is interpreted as a
512 : : * string terminator, so all the following characters are set to
513 : : * spaces.
514 : : **/
515 : : static void sanitize_inquiry_string(unsigned char *s, int len)
516 : : {
517 : : int terminated = 0;
518 : :
519 [ # # ][ # # ]: 0 : for (; len > 0; (--len, ++s)) {
[ # # ]
520 [ # # ][ # # ]: 0 : if (*s == 0)
[ # # ]
521 : : terminated = 1;
522 [ # # ][ # # ]: 0 : if (terminated || *s < 0x20 || *s > 0x7e)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
523 : 0 : *s = ' ';
524 : : }
525 : : }
526 : :
527 : : /**
528 : : * scsi_probe_lun - probe a single LUN using a SCSI INQUIRY
529 : : * @sdev: scsi_device to probe
530 : : * @inq_result: area to store the INQUIRY result
531 : : * @result_len: len of inq_result
532 : : * @bflags: store any bflags found here
533 : : *
534 : : * Description:
535 : : * Probe the lun associated with @req using a standard SCSI INQUIRY;
536 : : *
537 : : * If the INQUIRY is successful, zero is returned and the
538 : : * INQUIRY data is in @inq_result; the scsi_level and INQUIRY length
539 : : * are copied to the scsi_device any flags value is stored in *@bflags.
540 : : **/
541 : 0 : static 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 : 0 : *bflags = 0;
551 : :
552 : : /* Perform up to 3 passes. The first pass uses a conservative
553 : : * transfer length of 36 unless sdev->inquiry_len specifies a
554 : : * different value. */
555 [ # # ]: 0 : 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 : : /* Each pass gets up to three chances to ignore Unit Attention */
565 [ # # ]: 0 : for (count = 0; count < 3; ++count) {
566 : : int resid;
567 : :
568 : 0 : memset(scsi_cmd, 0, 6);
569 : 0 : scsi_cmd[0] = INQUIRY;
570 : 0 : scsi_cmd[4] = (unsigned char) try_inquiry_len;
571 : :
572 [ # # ]: 0 : memset(inq_result, 0, try_inquiry_len);
573 : :
574 : 0 : result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
575 : : inq_result, try_inquiry_len, &sshdr,
576 : 0 : 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 [ # # ]: 0 : if (result) {
584 : : /*
585 : : * not-ready to ready transition [asc/ascq=0x28/0x0]
586 : : * or power-on, reset [asc/ascq=0x29/0x0], continue.
587 : : * INQUIRY should not yield UNIT_ATTENTION
588 : : * but many buggy devices do so anyway.
589 : : */
590 [ # # ][ # # ]: 0 : if ((driver_byte(result) & DRIVER_SENSE) &&
591 : : scsi_sense_valid(&sshdr)) {
592 [ # # ][ # # ]: 0 : if ((sshdr.sense_key == UNIT_ATTENTION) &&
593 : 0 : ((sshdr.asc == 0x28) ||
594 [ # # ]: 0 : (sshdr.asc == 0x29)) &&
595 : 0 : (sshdr.ascq == 0))
596 : 0 : continue;
597 : : }
598 : : } else {
599 : : /*
600 : : * if nothing was transferred, we try
601 : : * again. It's a workaround for some USB
602 : : * devices.
603 : : */
604 [ # # ]: 0 : if (resid == try_inquiry_len)
605 : 0 : continue;
606 : : }
607 : 0 : break;
608 : : }
609 : :
610 [ # # ]: 0 : if (result == 0) {
611 : 0 : sanitize_inquiry_string(&inq_result[8], 8);
612 : 0 : sanitize_inquiry_string(&inq_result[16], 16);
613 : 0 : sanitize_inquiry_string(&inq_result[32], 4);
614 : :
615 : 0 : response_len = inq_result[4] + 5;
616 [ # # ]: 0 : if (response_len > 255)
617 : : response_len = first_inquiry_len; /* sanity */
618 : :
619 : : /*
620 : : * Get any flags for this device.
621 : : *
622 : : * XXX add a bflags to scsi_device, and replace the
623 : : * corresponding bit fields in scsi_device, so bflags
624 : : * need not be passed as an argument.
625 : : */
626 : 0 : *bflags = scsi_get_device_flags(sdev, &inq_result[8],
627 : : &inq_result[16]);
628 : :
629 : : /* When the first pass succeeds we gain information about
630 : : * what larger transfer lengths might work. */
631 [ # # ]: 0 : if (pass == 1) {
632 [ # # ]: 0 : if (BLIST_INQUIRY_36 & *bflags)
633 : : next_inquiry_len = 36;
634 [ # # ]: 0 : else if (BLIST_INQUIRY_58 & *bflags)
635 : : next_inquiry_len = 58;
636 [ # # ]: 0 : else if (sdev->inquiry_len)
637 : 0 : next_inquiry_len = sdev->inquiry_len;
638 : : else
639 : : next_inquiry_len = response_len;
640 : :
641 : : /* If more data is available perform the second pass */
642 [ # # ]: 0 : 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 [ # # ]: 0 : } else if (pass == 2) {
650 : 0 : printk(KERN_INFO "scsi scan: %d byte inquiry failed. "
651 : : "Consider BLIST_INQUIRY_36 for this device\n",
652 : : try_inquiry_len);
653 : :
654 : : /* If this pass failed, the third pass goes back and transfers
655 : : * the same amount as we successfully got in the first pass. */
656 : : try_inquiry_len = first_inquiry_len;
657 : : pass = 3;
658 : : goto next_pass;
659 : : }
660 : :
661 : : /* If the last transfer attempt got an error, assume the
662 : : * peripheral doesn't exist or is dead. */
663 [ # # ]: 0 : if (result)
664 : : return -EIO;
665 : :
666 : : /* Don't report any more data than the device says is valid */
667 : 0 : sdev->inquiry_len = min(try_inquiry_len, response_len);
668 : :
669 : : /*
670 : : * XXX Abort if the response length is less than 36? If less than
671 : : * 32, the lookup of the device flags (above) could be invalid,
672 : : * and it would be possible to take an incorrect action - we do
673 : : * not want to hang because of a short INQUIRY. On the flip side,
674 : : * if the device is spun down or becoming ready (and so it gives a
675 : : * short INQUIRY), an abort here prevents any further use of the
676 : : * device, including spin up.
677 : : *
678 : : * On the whole, the best approach seems to be to assume the first
679 : : * 36 bytes are valid no matter what the device says. That's
680 : : * better than copying < 36 bytes to the inquiry-result buffer
681 : : * and displaying garbage for the Vendor, Product, or Revision
682 : : * strings.
683 : : */
684 [ # # ]: 0 : if (sdev->inquiry_len < 36) {
685 : 0 : printk(KERN_INFO "scsi scan: INQUIRY result too short (%d),"
686 : : " using 36\n", sdev->inquiry_len);
687 : 0 : sdev->inquiry_len = 36;
688 : : }
689 : :
690 : : /*
691 : : * Related to the above issue:
692 : : *
693 : : * XXX Devices (disk or all?) should be sent a TEST UNIT READY,
694 : : * and if not ready, sent a START_STOP to start (maybe spin up) and
695 : : * then send the INQUIRY again, since the INQUIRY can change after
696 : : * a device is initialized.
697 : : *
698 : : * Ideally, start a device if explicitly asked to do so. This
699 : : * assumes that a device is spun up on power on, spun down on
700 : : * request, and then spun up on request.
701 : : */
702 : :
703 : : /*
704 : : * The scanning code needs to know the scsi_level, even if no
705 : : * device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so
706 : : * non-zero LUNs can be scanned.
707 : : */
708 : 0 : sdev->scsi_level = inq_result[2] & 0x07;
709 [ # # ][ # # ]: 0 : if (sdev->scsi_level >= 2 ||
710 [ # # ]: 0 : (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
711 : 0 : sdev->scsi_level++;
712 : 0 : sdev->sdev_target->scsi_level = sdev->scsi_level;
713 : :
714 : : return 0;
715 : : }
716 : :
717 : : /**
718 : : * scsi_add_lun - allocate and fully initialze a scsi_device
719 : : * @sdev: holds information to be stored in the new scsi_device
720 : : * @inq_result: holds the result of a previous INQUIRY to the LUN
721 : : * @bflags: black/white list flag
722 : : * @async: 1 if this device is being scanned asynchronously
723 : : *
724 : : * Description:
725 : : * Initialize the scsi_device @sdev. Optionally set fields based
726 : : * on values in *@bflags.
727 : : *
728 : : * Return:
729 : : * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
730 : : * SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
731 : : **/
732 : 0 : static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
733 : : int *bflags, int async)
734 : : {
735 : : int ret;
736 : :
737 : : /*
738 : : * XXX do not save the inquiry, since it can change underneath us,
739 : : * save just vendor/model/rev.
740 : : *
741 : : * Rather than save it and have an ioctl that retrieves the saved
742 : : * value, have an ioctl that executes the same INQUIRY code used
743 : : * in scsi_probe_lun, let user level programs doing INQUIRY
744 : : * scanning run at their own risk, or supply a user level program
745 : : * that can correctly scan.
746 : : */
747 : :
748 : : /*
749 : : * Copy at least 36 bytes of INQUIRY data, so that we don't
750 : : * dereference unallocated memory when accessing the Vendor,
751 : : * Product, and Revision strings. Badly behaved devices may set
752 : : * the INQUIRY Additional Length byte to a small value, indicating
753 : : * these strings are invalid, but often they contain plausible data
754 : : * nonetheless. It doesn't matter if the device sent < 36 bytes
755 : : * total, since scsi_probe_lun() initializes inq_result with 0s.
756 : : */
757 : 0 : sdev->inquiry = kmemdup(inq_result,
758 : 0 : max_t(size_t, sdev->inquiry_len, 36),
759 : : GFP_ATOMIC);
760 [ # # ]: 0 : if (sdev->inquiry == NULL)
761 : : return SCSI_SCAN_NO_RESPONSE;
762 : :
763 : 0 : sdev->vendor = (char *) (sdev->inquiry + 8);
764 : 0 : sdev->model = (char *) (sdev->inquiry + 16);
765 : 0 : sdev->rev = (char *) (sdev->inquiry + 32);
766 : :
767 [ # # ]: 0 : if (strncmp(sdev->vendor, "ATA ", 8) == 0) {
768 : : /*
769 : : * sata emulation layer device. This is a hack to work around
770 : : * the SATL power management specifications which state that
771 : : * when the SATL detects the device has gone into standby
772 : : * mode, it shall respond with NOT READY.
773 : : */
774 : 0 : sdev->allow_restart = 1;
775 : : }
776 : :
777 [ # # ]: 0 : if (*bflags & BLIST_ISROM) {
778 : 0 : sdev->type = TYPE_ROM;
779 : 0 : sdev->removable = 1;
780 : : } else {
781 : 0 : sdev->type = (inq_result[0] & 0x1f);
782 : 0 : sdev->removable = (inq_result[1] & 0x80) >> 7;
783 : : }
784 : :
785 [ # # ][ # # ]: 0 : 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 : 0 : sdev->writeable = 1;
799 : 0 : break;
800 : : case TYPE_ROM:
801 : : case TYPE_WORM:
802 : 0 : sdev->writeable = 0;
803 : 0 : break;
804 : : default:
805 : 0 : printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);
806 : : }
807 : :
808 [ # # ]: 0 : if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {
809 : : /* RBC and MMC devices can return SCSI-3 compliance and yet
810 : : * still not support REPORT LUNS, so make them act as
811 : : * BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is
812 : : * specifically set */
813 [ # # ]: 0 : if ((*bflags & BLIST_REPORTLUN2) == 0)
814 : 0 : *bflags |= BLIST_NOREPORTLUN;
815 : : }
816 : :
817 : : /*
818 : : * For a peripheral qualifier (PQ) value of 1 (001b), the SCSI
819 : : * spec says: The device server is capable of supporting the
820 : : * specified peripheral device type on this logical unit. However,
821 : : * the physical device is not currently connected to this logical
822 : : * unit.
823 : : *
824 : : * The above is vague, as it implies that we could treat 001 and
825 : : * 011 the same. Stay compatible with previous code, and create a
826 : : * scsi_device for a PQ of 1
827 : : *
828 : : * Don't set the device offline here; rather let the upper
829 : : * level drivers eval the PQ to decide whether they should
830 : : * attach. So remove ((inq_result[0] >> 5) & 7) == 1 check.
831 : : */
832 : :
833 : 0 : sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;
834 : 0 : sdev->lockable = sdev->removable;
835 [ # # ][ # # ]: 0 : sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);
836 : :
837 [ # # ][ # # ]: 0 : if (sdev->scsi_level >= SCSI_3 ||
838 [ # # ]: 0 : (sdev->inquiry_len > 56 && inq_result[56] & 0x04))
839 : 0 : sdev->ppr = 1;
840 [ # # ]: 0 : if (inq_result[7] & 0x60)
841 : 0 : sdev->wdtr = 1;
842 [ # # ]: 0 : if (inq_result[7] & 0x10)
843 : 0 : sdev->sdtr = 1;
844 : :
845 [ # # ]: 0 : 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 [ # # ][ # # ]: 0 : if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
[ # # ]
852 : 0 : !(*bflags & BLIST_NOTQ))
853 : 0 : sdev->tagged_supported = 1;
854 : :
855 : : /*
856 : : * Some devices (Texel CD ROM drives) have handshaking problems
857 : : * when used with the Seagate controllers. borken is initialized
858 : : * to 1, and then set it to 0 here.
859 : : */
860 [ # # ]: 0 : if ((*bflags & BLIST_BORKEN) == 0)
861 : 0 : sdev->borken = 0;
862 : :
863 [ # # ]: 0 : if (*bflags & BLIST_NO_ULD_ATTACH)
864 : 0 : sdev->no_uld_attach = 1;
865 : :
866 : : /*
867 : : * Apparently some really broken devices (contrary to the SCSI
868 : : * standards) need to be selected without asserting ATN
869 : : */
870 [ # # ]: 0 : if (*bflags & BLIST_SELECT_NO_ATN)
871 : 0 : sdev->select_no_atn = 1;
872 : :
873 : : /*
874 : : * Maximum 512 sector transfer length
875 : : * broken RA4x00 Compaq Disk Array
876 : : */
877 [ # # ]: 0 : if (*bflags & BLIST_MAX_512)
878 : 0 : blk_queue_max_hw_sectors(sdev->request_queue, 512);
879 : :
880 : : /*
881 : : * Some devices may not want to have a start command automatically
882 : : * issued when a device is added.
883 : : */
884 [ # # ]: 0 : if (*bflags & BLIST_NOSTARTONADD)
885 : 0 : sdev->no_start_on_add = 1;
886 : :
887 [ # # ]: 0 : if (*bflags & BLIST_SINGLELUN)
888 : 0 : scsi_target(sdev)->single_lun = 1;
889 : :
890 : 0 : sdev->use_10_for_rw = 1;
891 : :
892 [ # # ]: 0 : if (*bflags & BLIST_MS_SKIP_PAGE_08)
893 : 0 : sdev->skip_ms_page_8 = 1;
894 : :
895 [ # # ]: 0 : if (*bflags & BLIST_MS_SKIP_PAGE_3F)
896 : 0 : sdev->skip_ms_page_3f = 1;
897 : :
898 [ # # ]: 0 : if (*bflags & BLIST_USE_10_BYTE_MS)
899 : 0 : sdev->use_10_for_ms = 1;
900 : :
901 : : /* set the device running here so that slave configure
902 : : * may do I/O */
903 : 0 : ret = scsi_device_set_state(sdev, SDEV_RUNNING);
904 [ # # ]: 0 : if (ret) {
905 : 0 : ret = scsi_device_set_state(sdev, SDEV_BLOCK);
906 : :
907 [ # # ]: 0 : if (ret) {
908 : 0 : sdev_printk(KERN_ERR, sdev,
909 : : "in wrong state %s to complete scan\n",
910 : : scsi_device_state_name(sdev->sdev_state));
911 : 0 : return SCSI_SCAN_NO_RESPONSE;
912 : : }
913 : : }
914 : :
915 [ # # ]: 0 : if (*bflags & BLIST_MS_192_BYTES_FOR_3F)
916 : 0 : sdev->use_192_bytes_for_3f = 1;
917 : :
918 [ # # ]: 0 : if (*bflags & BLIST_NOT_LOCKABLE)
919 : 0 : sdev->lockable = 0;
920 : :
921 [ # # ]: 0 : if (*bflags & BLIST_RETRY_HWERROR)
922 : 0 : sdev->retry_hwerror = 1;
923 : :
924 [ # # ]: 0 : if (*bflags & BLIST_NO_DIF)
925 : 0 : sdev->no_dif = 1;
926 : :
927 : 0 : sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;
928 : :
929 [ # # ]: 0 : if (*bflags & BLIST_SKIP_VPD_PAGES)
930 : 0 : sdev->skip_vpd_pages = 1;
931 : :
932 : 0 : transport_configure_device(&sdev->sdev_gendev);
933 : :
934 [ # # ]: 0 : if (sdev->host->hostt->slave_configure) {
935 : 0 : ret = sdev->host->hostt->slave_configure(sdev);
936 [ # # ]: 0 : if (ret) {
937 : : /*
938 : : * if LLDD reports slave not present, don't clutter
939 : : * console with alloc failure messages
940 : : */
941 [ # # ]: 0 : if (ret != -ENXIO) {
942 : 0 : sdev_printk(KERN_ERR, sdev,
943 : : "failed to configure device\n");
944 : : }
945 : : return SCSI_SCAN_NO_RESPONSE;
946 : : }
947 : : }
948 : :
949 : 0 : sdev->max_queue_depth = sdev->queue_depth;
950 : :
951 : : /*
952 : : * Ok, the device is now all set up, we can
953 : : * register it and tell the rest of the kernel
954 : : * about it.
955 : : */
956 [ # # ][ # # ]: 0 : if (!async && scsi_sysfs_add_sdev(sdev) != 0)
957 : : return SCSI_SCAN_NO_RESPONSE;
958 : :
959 : : return SCSI_SCAN_LUN_PRESENT;
960 : : }
961 : :
962 : : #ifdef CONFIG_SCSI_LOGGING
963 : : /**
964 : : * scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace
965 : : * @buf: Output buffer with at least end-first+1 bytes of space
966 : : * @inq: Inquiry buffer (input)
967 : : * @first: Offset of string into inq
968 : : * @end: Index after last character in inq
969 : : */
970 : : static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,
971 : : unsigned first, unsigned end)
972 : : {
973 : : unsigned term = 0, idx;
974 : :
975 : : for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {
976 : : if (inq[idx+first] > ' ') {
977 : : buf[idx] = inq[idx+first];
978 : : term = idx+1;
979 : : } else {
980 : : buf[idx] = ' ';
981 : : }
982 : : }
983 : : buf[term] = 0;
984 : : return buf;
985 : : }
986 : : #endif
987 : :
988 : : /**
989 : : * scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it
990 : : * @starget: pointer to target device structure
991 : : * @lun: LUN of target device
992 : : * @bflagsp: store bflags here if not NULL
993 : : * @sdevp: probe the LUN corresponding to this scsi_device
994 : : * @rescan: if nonzero skip some code only needed on first scan
995 : : * @hostdata: passed to scsi_alloc_sdev()
996 : : *
997 : : * Description:
998 : : * Call scsi_probe_lun, if a LUN with an attached device is found,
999 : : * allocate and set it up by calling scsi_add_lun.
1000 : : *
1001 : : * Return:
1002 : : * SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
1003 : : * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is
1004 : : * attached at the LUN
1005 : : * SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
1006 : : **/
1007 : 0 : static int scsi_probe_and_add_lun(struct scsi_target *starget,
1008 : : uint lun, int *bflagsp,
1009 : : struct scsi_device **sdevp, int rescan,
1010 : : void *hostdata)
1011 : : {
1012 : 0 : struct scsi_device *sdev;
1013 : : unsigned char *result;
1014 : : int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;
1015 : 0 : struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1016 : :
1017 : : /*
1018 : : * The rescan flag is used as an optimization, the first scan of a
1019 : : * host adapter calls into here with rescan == 0.
1020 : : */
1021 : 0 : sdev = scsi_device_lookup_by_target(starget, lun);
1022 [ # # ]: 0 : if (sdev) {
1023 [ # # ][ # # ]: 0 : if (rescan || !scsi_device_created(sdev)) {
1024 : : SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
1025 : : "scsi scan: device exists on %s\n",
1026 : : dev_name(&sdev->sdev_gendev)));
1027 [ # # ]: 0 : if (sdevp)
1028 : 0 : *sdevp = sdev;
1029 : : else
1030 : 0 : scsi_device_put(sdev);
1031 : :
1032 [ # # ]: 0 : if (bflagsp)
1033 : 0 : *bflagsp = scsi_get_device_flags(sdev,
1034 : 0 : sdev->vendor,
1035 : 0 : sdev->model);
1036 : : return SCSI_SCAN_LUN_PRESENT;
1037 : : }
1038 : 0 : scsi_device_put(sdev);
1039 : : } else
1040 : 0 : sdev = scsi_alloc_sdev(starget, lun, hostdata);
1041 [ # # ]: 0 : if (!sdev)
1042 : : goto out;
1043 : :
1044 [ # # ]: 0 : result = kmalloc(result_len, GFP_ATOMIC |
1045 : 0 : ((shost->unchecked_isa_dma) ? __GFP_DMA : 0));
1046 [ # # ]: 0 : if (!result)
1047 : : goto out_free_sdev;
1048 : :
1049 [ # # ]: 0 : if (scsi_probe_lun(sdev, result, result_len, &bflags))
1050 : : goto out_free_result;
1051 : :
1052 [ # # ]: 0 : if (bflagsp)
1053 : 0 : *bflagsp = bflags;
1054 : : /*
1055 : : * result contains valid SCSI INQUIRY data.
1056 : : */
1057 [ # # ][ # # ]: 0 : if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {
1058 : : /*
1059 : : * For a Peripheral qualifier 3 (011b), the SCSI
1060 : : * spec says: The device server is not capable of
1061 : : * supporting a physical device on this logical
1062 : : * unit.
1063 : : *
1064 : : * For disks, this implies that there is no
1065 : : * logical disk configured at sdev->lun, but there
1066 : : * is a target id responding.
1067 : : */
1068 : : SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"
1069 : : " peripheral qualifier of 3, device not"
1070 : : " added\n"))
1071 : : if (lun == 0) {
1072 : : SCSI_LOG_SCAN_BUS(1, {
1073 : : unsigned char vend[9];
1074 : : unsigned char mod[17];
1075 : :
1076 : : sdev_printk(KERN_INFO, sdev,
1077 : : "scsi scan: consider passing scsi_mod."
1078 : : "dev_flags=%s:%s:0x240 or 0x1000240\n",
1079 : : scsi_inq_str(vend, result, 8, 16),
1080 : : scsi_inq_str(mod, result, 16, 32));
1081 : : });
1082 : :
1083 : : }
1084 : :
1085 : : res = SCSI_SCAN_TARGET_PRESENT;
1086 : : goto out_free_result;
1087 : : }
1088 : :
1089 : : /*
1090 : : * Some targets may set slight variations of PQ and PDT to signal
1091 : : * that no LUN is present, so don't add sdev in these cases.
1092 : : * Two specific examples are:
1093 : : * 1) NetApp targets: return PQ=1, PDT=0x1f
1094 : : * 2) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved"
1095 : : * in the UFI 1.0 spec (we cannot rely on reserved bits).
1096 : : *
1097 : : * References:
1098 : : * 1) SCSI SPC-3, pp. 145-146
1099 : : * PQ=1: "A peripheral device having the specified peripheral
1100 : : * device type is not connected to this logical unit. However, the
1101 : : * device server is capable of supporting the specified peripheral
1102 : : * device type on this logical unit."
1103 : : * PDT=0x1f: "Unknown or no device type"
1104 : : * 2) USB UFI 1.0, p. 20
1105 : : * PDT=00h Direct-access device (floppy)
1106 : : * PDT=1Fh none (no FDD connected to the requested logical unit)
1107 : : */
1108 [ # # ][ # # ]: 0 : if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&
[ # # ]
1109 [ # # ]: 0 : (result[0] & 0x1f) == 0x1f &&
1110 : : !scsi_is_wlun(lun)) {
1111 : : SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
1112 : : "scsi scan: peripheral device type"
1113 : : " of 31, no device added\n"));
1114 : : res = SCSI_SCAN_TARGET_PRESENT;
1115 : : goto out_free_result;
1116 : : }
1117 : :
1118 : 0 : res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);
1119 [ # # ]: 0 : if (res == SCSI_SCAN_LUN_PRESENT) {
1120 [ # # ]: 0 : if (bflags & BLIST_KEY) {
1121 : 0 : sdev->lockable = 0;
1122 : 0 : scsi_unlock_floptical(sdev, result);
1123 : : }
1124 : : }
1125 : :
1126 : : out_free_result:
1127 : 0 : kfree(result);
1128 : : out_free_sdev:
1129 [ # # ]: 0 : if (res == SCSI_SCAN_LUN_PRESENT) {
1130 [ # # ]: 0 : if (sdevp) {
1131 [ # # ]: 0 : if (scsi_device_get(sdev) == 0) {
1132 : 0 : *sdevp = sdev;
1133 : : } else {
1134 : 0 : __scsi_remove_device(sdev);
1135 : : res = SCSI_SCAN_NO_RESPONSE;
1136 : : }
1137 : : }
1138 : : } else
1139 : 0 : __scsi_remove_device(sdev);
1140 : : out:
1141 : 0 : return res;
1142 : : }
1143 : :
1144 : : /**
1145 : : * scsi_sequential_lun_scan - sequentially scan a SCSI target
1146 : : * @starget: pointer to target structure to scan
1147 : : * @bflags: black/white list flag for LUN 0
1148 : : * @scsi_level: Which version of the standard does this device adhere to
1149 : : * @rescan: passed to scsi_probe_add_lun()
1150 : : *
1151 : : * Description:
1152 : : * Generally, scan from LUN 1 (LUN 0 is assumed to already have been
1153 : : * scanned) to some maximum lun until a LUN is found with no device
1154 : : * attached. Use the bflags to figure out any oddities.
1155 : : *
1156 : : * Modifies sdevscan->lun.
1157 : : **/
1158 : 0 : static void scsi_sequential_lun_scan(struct scsi_target *starget,
1159 : : int bflags, int scsi_level, int rescan)
1160 : : {
1161 : : unsigned int sparse_lun, lun, max_dev_lun;
1162 : 0 : struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1163 : :
1164 : : SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of"
1165 : : "%s\n", dev_name(&starget->dev)));
1166 : :
1167 : 0 : max_dev_lun = min(max_scsi_luns, shost->max_lun);
1168 : : /*
1169 : : * If this device is known to support sparse multiple units,
1170 : : * override the other settings, and scan all of them. Normally,
1171 : : * SCSI-3 devices should be scanned via the REPORT LUNS.
1172 : : */
1173 [ # # ]: 0 : if (bflags & BLIST_SPARSELUN) {
1174 : : max_dev_lun = shost->max_lun;
1175 : : sparse_lun = 1;
1176 : : } else
1177 : : sparse_lun = 0;
1178 : :
1179 : : /*
1180 : : * If less than SCSI_1_CSS, and no special lun scaning, stop
1181 : : * scanning; this matches 2.4 behaviour, but could just be a bug
1182 : : * (to continue scanning a SCSI_1_CSS device).
1183 : : *
1184 : : * This test is broken. We might not have any device on lun0 for
1185 : : * a sparselun device, and if that's the case then how would we
1186 : : * know the real scsi_level, eh? It might make sense to just not
1187 : : * scan any SCSI_1 device for non-0 luns, but that check would best
1188 : : * go into scsi_alloc_sdev() and just have it return null when asked
1189 : : * to alloc an sdev for lun > 0 on an already found SCSI_1 device.
1190 : : *
1191 : : if ((sdevscan->scsi_level < SCSI_1_CCS) &&
1192 : : ((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN))
1193 : : == 0))
1194 : : return;
1195 : : */
1196 : : /*
1197 : : * If this device is known to support multiple units, override
1198 : : * the other settings, and scan all of them.
1199 : : */
1200 [ # # ]: 0 : if (bflags & BLIST_FORCELUN)
1201 : : max_dev_lun = shost->max_lun;
1202 : : /*
1203 : : * REGAL CDC-4X: avoid hang after LUN 4
1204 : : */
1205 [ # # ]: 0 : if (bflags & BLIST_MAX5LUN)
1206 : 0 : max_dev_lun = min(5U, max_dev_lun);
1207 : : /*
1208 : : * Do not scan SCSI-2 or lower device past LUN 7, unless
1209 : : * BLIST_LARGELUN.
1210 : : */
1211 [ # # ][ # # ]: 0 : if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))
1212 : 0 : max_dev_lun = min(8U, max_dev_lun);
1213 : :
1214 : : /*
1215 : : * We have already scanned LUN 0, so start at LUN 1. Keep scanning
1216 : : * until we reach the max, or no LUN is found and we are not
1217 : : * sparse_lun.
1218 : : */
1219 [ # # ]: 0 : for (lun = 1; lun < max_dev_lun; ++lun)
1220 [ # # ]: 0 : if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,
1221 [ # # ]: 0 : NULL) != SCSI_SCAN_LUN_PRESENT) &&
1222 : : !sparse_lun)
1223 : 0 : return;
1224 : : }
1225 : :
1226 : : /**
1227 : : * scsilun_to_int - convert a scsi_lun to an int
1228 : : * @scsilun: struct scsi_lun to be converted.
1229 : : *
1230 : : * Description:
1231 : : * Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered
1232 : : * integer, and return the result. The caller must check for
1233 : : * truncation before using this function.
1234 : : *
1235 : : * Notes:
1236 : : * The struct scsi_lun is assumed to be four levels, with each level
1237 : : * effectively containing a SCSI byte-ordered (big endian) short; the
1238 : : * addressing bits of each level are ignored (the highest two bits).
1239 : : * For a description of the LUN format, post SCSI-3 see the SCSI
1240 : : * Architecture Model, for SCSI-3 see the SCSI Controller Commands.
1241 : : *
1242 : : * Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns
1243 : : * the integer: 0x0b030a04
1244 : : **/
1245 : 0 : int scsilun_to_int(struct scsi_lun *scsilun)
1246 : : {
1247 : : int i;
1248 : : unsigned int lun;
1249 : :
1250 : : lun = 0;
1251 [ # # ][ # # ]: 0 : for (i = 0; i < sizeof(lun); i += 2)
1252 : 0 : lun = lun | (((scsilun->scsi_lun[i] << 8) |
1253 : 0 : scsilun->scsi_lun[i + 1]) << (i * 8));
1254 : 0 : return lun;
1255 : : }
1256 : : EXPORT_SYMBOL(scsilun_to_int);
1257 : :
1258 : : /**
1259 : : * int_to_scsilun - reverts an int into a scsi_lun
1260 : : * @lun: integer to be reverted
1261 : : * @scsilun: struct scsi_lun to be set.
1262 : : *
1263 : : * Description:
1264 : : * Reverts the functionality of the scsilun_to_int, which packed
1265 : : * an 8-byte lun value into an int. This routine unpacks the int
1266 : : * back into the lun value.
1267 : : * Note: the scsilun_to_int() routine does not truly handle all
1268 : : * 8bytes of the lun value. This functions restores only as much
1269 : : * as was set by the routine.
1270 : : *
1271 : : * Notes:
1272 : : * Given an integer : 0x0b030a04, this function returns a
1273 : : * scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00
1274 : : *
1275 : : **/
1276 : 0 : void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)
1277 : : {
1278 : : int i;
1279 : :
1280 : 0 : memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));
1281 : :
1282 [ # # ]: 0 : for (i = 0; i < sizeof(lun); i += 2) {
1283 : 0 : scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
1284 : 0 : scsilun->scsi_lun[i+1] = lun & 0xFF;
1285 : 0 : lun = lun >> 16;
1286 : : }
1287 : 0 : }
1288 : : EXPORT_SYMBOL(int_to_scsilun);
1289 : :
1290 : : /**
1291 : : * scsi_report_lun_scan - Scan using SCSI REPORT LUN results
1292 : : * @starget: which target
1293 : : * @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN
1294 : : * @rescan: nonzero if we can skip code only needed on first scan
1295 : : *
1296 : : * Description:
1297 : : * Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command.
1298 : : * Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.
1299 : : *
1300 : : * If BLINK_REPORTLUN2 is set, scan a target that supports more than 8
1301 : : * LUNs even if it's older than SCSI-3.
1302 : : * If BLIST_NOREPORTLUN is set, return 1 always.
1303 : : * If BLIST_NOLUN is set, return 0 always.
1304 : : * If starget->no_report_luns is set, return 1 always.
1305 : : *
1306 : : * Return:
1307 : : * 0: scan completed (or no memory, so further scanning is futile)
1308 : : * 1: could not scan with REPORT LUN
1309 : : **/
1310 : 0 : static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
1311 : : int rescan)
1312 : : {
1313 : : char devname[64];
1314 : : unsigned char scsi_cmd[MAX_COMMAND_SIZE];
1315 : : unsigned int length;
1316 : : unsigned int lun;
1317 : : unsigned int num_luns;
1318 : : unsigned int retries;
1319 : : int result;
1320 : : struct scsi_lun *lunp, *lun_data;
1321 : : u8 *data;
1322 : : struct scsi_sense_hdr sshdr;
1323 : 0 : struct scsi_device *sdev;
1324 : 0 : struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1325 : : int ret = 0;
1326 : :
1327 : : /*
1328 : : * Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set.
1329 : : * Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does
1330 : : * support more than 8 LUNs.
1331 : : * Don't attempt if the target doesn't support REPORT LUNS.
1332 : : */
1333 [ # # ]: 0 : if (bflags & BLIST_NOREPORTLUN)
1334 : : return 1;
1335 [ # # ]: 0 : if (starget->scsi_level < SCSI_2 &&
1336 : : starget->scsi_level != SCSI_UNKNOWN)
1337 : : return 1;
1338 [ # # ][ # # ]: 0 : if (starget->scsi_level < SCSI_3 &&
1339 [ # # ]: 0 : (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))
1340 : : return 1;
1341 [ # # ]: 0 : if (bflags & BLIST_NOLUN)
1342 : : return 0;
1343 [ # # ]: 0 : if (starget->no_report_luns)
1344 : : return 1;
1345 : :
1346 [ # # ]: 0 : if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
1347 : 0 : sdev = scsi_alloc_sdev(starget, 0, NULL);
1348 [ # # ]: 0 : if (!sdev)
1349 : : return 0;
1350 [ # # ]: 0 : if (scsi_device_get(sdev)) {
1351 : 0 : __scsi_remove_device(sdev);
1352 : 0 : return 0;
1353 : : }
1354 : : }
1355 : :
1356 : 0 : sprintf(devname, "host %d channel %d id %d",
1357 : : shost->host_no, sdev->channel, sdev->id);
1358 : :
1359 : : /*
1360 : : * Allocate enough to hold the header (the same size as one scsi_lun)
1361 : : * plus the max number of luns we are requesting.
1362 : : *
1363 : : * Reallocating and trying again (with the exact amount we need)
1364 : : * would be nice, but then we need to somehow limit the size
1365 : : * allocated based on the available memory and the limits of
1366 : : * kmalloc - we don't want a kmalloc() failure of a huge value to
1367 : : * prevent us from finding any LUNs on this target.
1368 : : */
1369 : 0 : length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
1370 [ # # ]: 0 : lun_data = kmalloc(length, GFP_ATOMIC |
1371 : 0 : (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
1372 [ # # ]: 0 : if (!lun_data) {
1373 : 0 : printk(ALLOC_FAILURE_MSG, __func__);
1374 : 0 : goto out;
1375 : : }
1376 : :
1377 : 0 : scsi_cmd[0] = REPORT_LUNS;
1378 : :
1379 : : /*
1380 : : * bytes 1 - 5: reserved, set to zero.
1381 : : */
1382 : 0 : memset(&scsi_cmd[1], 0, 5);
1383 : :
1384 : : /*
1385 : : * bytes 6 - 9: length of the command.
1386 : : */
1387 : 0 : scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
1388 : 0 : scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
1389 : 0 : scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
1390 : 0 : scsi_cmd[9] = (unsigned char) length & 0xff;
1391 : :
1392 : 0 : scsi_cmd[10] = 0; /* reserved */
1393 : 0 : scsi_cmd[11] = 0; /* control */
1394 : :
1395 : : /*
1396 : : * We can get a UNIT ATTENTION, for example a power on/reset, so
1397 : : * retry a few times (like sd.c does for TEST UNIT READY).
1398 : : * Experience shows some combinations of adapter/devices get at
1399 : : * least two power on/resets.
1400 : : *
1401 : : * Illegal requests (for devices that do not support REPORT LUNS)
1402 : : * should come through as a check condition, and will not generate
1403 : : * a retry.
1404 : : */
1405 [ # # ]: 0 : for (retries = 0; retries < 3; retries++) {
1406 : : SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending"
1407 : : " REPORT LUNS to %s (try %d)\n", devname,
1408 : : retries));
1409 : :
1410 : : result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
1411 : : lun_data, length, &sshdr,
1412 : : SCSI_TIMEOUT + 4 * HZ, 3, NULL);
1413 : :
1414 : : SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS"
1415 : : " %s (try %d) result 0x%x\n", result
1416 : : ? "failed" : "successful", retries, result));
1417 [ # # ]: 0 : if (result == 0)
1418 : : break;
1419 [ # # ]: 0 : else if (scsi_sense_valid(&sshdr)) {
1420 [ # # ]: 0 : if (sshdr.sense_key != UNIT_ATTENTION)
1421 : : break;
1422 : : }
1423 : : }
1424 : :
1425 [ # # ]: 0 : if (result) {
1426 : : /*
1427 : : * The device probably does not support a REPORT LUN command
1428 : : */
1429 : : ret = 1;
1430 : : goto out_err;
1431 : : }
1432 : :
1433 : : /*
1434 : : * Get the length from the first four bytes of lun_data.
1435 : : */
1436 : : data = (u8 *) lun_data->scsi_lun;
1437 : 0 : length = ((data[0] << 24) | (data[1] << 16) |
1438 : 0 : (data[2] << 8) | (data[3] << 0));
1439 : :
1440 : 0 : num_luns = (length / sizeof(struct scsi_lun));
1441 [ # # ]: 0 : if (num_luns > max_scsi_report_luns) {
1442 : 0 : printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"
1443 : : " of %d luns reported, try increasing"
1444 : : " max_scsi_report_luns.\n", devname,
1445 : : max_scsi_report_luns, num_luns);
1446 : 0 : num_luns = max_scsi_report_luns;
1447 : : }
1448 : :
1449 : : SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
1450 : : "scsi scan: REPORT LUN scan\n"));
1451 : :
1452 : : /*
1453 : : * Scan the luns in lun_data. The entry at offset 0 is really
1454 : : * the header, so start at 1 and go up to and including num_luns.
1455 : : */
1456 [ # # ]: 0 : for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {
1457 : : lun = scsilun_to_int(lunp);
1458 : :
1459 : : /*
1460 : : * Check if the unused part of lunp is non-zero, and so
1461 : : * does not fit in lun.
1462 : : */
1463 [ # # ]: 0 : if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {
1464 : : int i;
1465 : :
1466 : : /*
1467 : : * Output an error displaying the LUN in byte order,
1468 : : * this differs from what linux would print for the
1469 : : * integer LUN value.
1470 : : */
1471 : 0 : printk(KERN_WARNING "scsi: %s lun 0x", devname);
1472 : 0 : data = (char *)lunp->scsi_lun;
1473 [ # # ]: 0 : for (i = 0; i < sizeof(struct scsi_lun); i++)
1474 : 0 : printk("%02x", data[i]);
1475 : 0 : printk(" has a LUN larger than currently supported.\n");
1476 [ # # ]: 0 : } else if (lun > sdev->host->max_lun) {
1477 : 0 : printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"
1478 : : " than allowed by the host adapter\n",
1479 : : devname, lun);
1480 : : } else {
1481 : : int res;
1482 : :
1483 : 0 : res = scsi_probe_and_add_lun(starget,
1484 : : lun, NULL, NULL, rescan, NULL);
1485 [ # # ]: 0 : if (res == SCSI_SCAN_NO_RESPONSE) {
1486 : : /*
1487 : : * Got some results, but now none, abort.
1488 : : */
1489 : 0 : sdev_printk(KERN_ERR, sdev,
1490 : : "Unexpected response"
1491 : : " from lun %d while scanning, scan"
1492 : : " aborted\n", lun);
1493 : 0 : break;
1494 : : }
1495 : : }
1496 : : }
1497 : :
1498 : : out_err:
1499 : 0 : kfree(lun_data);
1500 : : out:
1501 : 0 : scsi_device_put(sdev);
1502 [ # # ]: 0 : if (scsi_device_created(sdev))
1503 : : /*
1504 : : * the sdev we used didn't appear in the report luns scan
1505 : : */
1506 : 0 : __scsi_remove_device(sdev);
1507 : 0 : return ret;
1508 : : }
1509 : :
1510 : 0 : struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
1511 : : uint id, uint lun, void *hostdata)
1512 : : {
1513 : 0 : struct scsi_device *sdev = ERR_PTR(-ENODEV);
1514 : 0 : struct device *parent = &shost->shost_gendev;
1515 : : struct scsi_target *starget;
1516 : :
1517 [ # # ]: 0 : if (strncmp(scsi_scan_type, "none", 4) == 0)
1518 : : return ERR_PTR(-ENODEV);
1519 : :
1520 : 0 : starget = scsi_alloc_target(parent, channel, id);
1521 [ # # ]: 0 : if (!starget)
1522 : : return ERR_PTR(-ENOMEM);
1523 : : scsi_autopm_get_target(starget);
1524 : :
1525 : 0 : mutex_lock(&shost->scan_mutex);
1526 [ # # ]: 0 : if (!shost->async_scan)
1527 : 0 : scsi_complete_async_scans();
1528 : :
1529 [ # # ]: 0 : if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1530 : 0 : scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
1531 : : scsi_autopm_put_host(shost);
1532 : : }
1533 : 0 : mutex_unlock(&shost->scan_mutex);
1534 : : scsi_autopm_put_target(starget);
1535 : 0 : scsi_target_reap(starget);
1536 : 0 : put_device(&starget->dev);
1537 : :
1538 : 0 : return sdev;
1539 : : }
1540 : : EXPORT_SYMBOL(__scsi_add_device);
1541 : :
1542 : 0 : int scsi_add_device(struct Scsi_Host *host, uint channel,
1543 : : uint target, uint lun)
1544 : : {
1545 : 0 : struct scsi_device *sdev =
1546 : : __scsi_add_device(host, channel, target, lun, NULL);
1547 [ # # ]: 0 : if (IS_ERR(sdev))
1548 : 0 : return PTR_ERR(sdev);
1549 : :
1550 : 0 : scsi_device_put(sdev);
1551 : 0 : return 0;
1552 : : }
1553 : : EXPORT_SYMBOL(scsi_add_device);
1554 : :
1555 : 0 : void scsi_rescan_device(struct device *dev)
1556 : : {
1557 : : struct scsi_driver *drv;
1558 : :
1559 [ # # ]: 0 : if (!dev->driver)
1560 : 0 : return;
1561 : :
1562 : : drv = to_scsi_driver(dev->driver);
1563 [ # # ]: 0 : if (try_module_get(drv->owner)) {
1564 [ # # ]: 0 : if (drv->rescan)
1565 : 0 : drv->rescan(dev);
1566 : 0 : module_put(drv->owner);
1567 : : }
1568 : : }
1569 : : EXPORT_SYMBOL(scsi_rescan_device);
1570 : :
1571 : 0 : static void __scsi_scan_target(struct device *parent, unsigned int channel,
1572 : : unsigned int id, unsigned int lun, int rescan)
1573 : : {
1574 : : struct Scsi_Host *shost = dev_to_shost(parent);
1575 : 0 : int bflags = 0;
1576 : : int res;
1577 : : struct scsi_target *starget;
1578 : :
1579 [ # # ]: 0 : if (shost->this_id == id)
1580 : : /*
1581 : : * Don't scan the host adapter
1582 : : */
1583 : 0 : return;
1584 : :
1585 : 0 : starget = scsi_alloc_target(parent, channel, id);
1586 [ # # ]: 0 : if (!starget)
1587 : : return;
1588 : : scsi_autopm_get_target(starget);
1589 : :
1590 [ # # ]: 0 : if (lun != SCAN_WILD_CARD) {
1591 : : /*
1592 : : * Scan for a specific host/chan/id/lun.
1593 : : */
1594 : 0 : scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
1595 : 0 : goto out_reap;
1596 : : }
1597 : :
1598 : : /*
1599 : : * Scan LUN 0, if there is some response, scan further. Ideally, we
1600 : : * would not configure LUN 0 until all LUNs are scanned.
1601 : : */
1602 : 0 : res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
1603 [ # # ]: 0 : if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
1604 [ # # ]: 0 : if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
1605 : : /*
1606 : : * The REPORT LUN did not scan the target,
1607 : : * do a sequential scan.
1608 : : */
1609 : 0 : scsi_sequential_lun_scan(starget, bflags,
1610 : 0 : starget->scsi_level, rescan);
1611 : : }
1612 : :
1613 : : out_reap:
1614 : : scsi_autopm_put_target(starget);
1615 : : /* now determine if the target has any children at all
1616 : : * and if not, nuke it */
1617 : 0 : scsi_target_reap(starget);
1618 : :
1619 : 0 : put_device(&starget->dev);
1620 : : }
1621 : :
1622 : : /**
1623 : : * scsi_scan_target - scan a target id, possibly including all LUNs on the target.
1624 : : * @parent: host to scan
1625 : : * @channel: channel to scan
1626 : : * @id: target id to scan
1627 : : * @lun: Specific LUN to scan or SCAN_WILD_CARD
1628 : : * @rescan: passed to LUN scanning routines
1629 : : *
1630 : : * Description:
1631 : : * Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,
1632 : : * and possibly all LUNs on the target id.
1633 : : *
1634 : : * First try a REPORT LUN scan, if that does not scan the target, do a
1635 : : * sequential scan of LUNs on the target id.
1636 : : **/
1637 : 0 : void scsi_scan_target(struct device *parent, unsigned int channel,
1638 : : unsigned int id, unsigned int lun, int rescan)
1639 : : {
1640 : 0 : struct Scsi_Host *shost = dev_to_shost(parent);
1641 : :
1642 [ # # ]: 0 : if (strncmp(scsi_scan_type, "none", 4) == 0)
1643 : 0 : return;
1644 : :
1645 : 0 : mutex_lock(&shost->scan_mutex);
1646 [ # # ]: 0 : if (!shost->async_scan)
1647 : 0 : scsi_complete_async_scans();
1648 : :
1649 [ # # ]: 0 : if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1650 : 0 : __scsi_scan_target(parent, channel, id, lun, rescan);
1651 : : scsi_autopm_put_host(shost);
1652 : : }
1653 : 0 : mutex_unlock(&shost->scan_mutex);
1654 : : }
1655 : : EXPORT_SYMBOL(scsi_scan_target);
1656 : :
1657 : 0 : static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
1658 : : unsigned int id, unsigned int lun, int rescan)
1659 : : {
1660 : : uint order_id;
1661 : :
1662 [ # # ]: 0 : if (id == SCAN_WILD_CARD)
1663 [ # # ]: 0 : for (id = 0; id < shost->max_id; ++id) {
1664 : : /*
1665 : : * XXX adapter drivers when possible (FCP, iSCSI)
1666 : : * could modify max_id to match the current max,
1667 : : * not the absolute max.
1668 : : *
1669 : : * XXX add a shost id iterator, so for example,
1670 : : * the FC ID can be the same as a target id
1671 : : * without a huge overhead of sparse id's.
1672 : : */
1673 [ # # ]: 0 : if (shost->reverse_ordering)
1674 : : /*
1675 : : * Scan from high to low id.
1676 : : */
1677 : 0 : order_id = shost->max_id - id - 1;
1678 : : else
1679 : : order_id = id;
1680 : 0 : __scsi_scan_target(&shost->shost_gendev, channel,
1681 : : order_id, lun, rescan);
1682 : : }
1683 : : else
1684 : 0 : __scsi_scan_target(&shost->shost_gendev, channel,
1685 : : id, lun, rescan);
1686 : 0 : }
1687 : :
1688 : 0 : int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
1689 : : unsigned int id, unsigned int lun, int rescan)
1690 : : {
1691 : : SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
1692 : : "%s: <%u:%u:%u>\n",
1693 : : __func__, channel, id, lun));
1694 : :
1695 [ # # ][ # # ]: 0 : if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
[ # # ]
1696 [ # # ][ # # ]: 0 : ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
1697 [ # # ]: 0 : ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
1698 : : return -EINVAL;
1699 : :
1700 : 0 : mutex_lock(&shost->scan_mutex);
1701 [ # # ]: 0 : if (!shost->async_scan)
1702 : 0 : scsi_complete_async_scans();
1703 : :
1704 [ # # ]: 0 : if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1705 [ # # ]: 0 : if (channel == SCAN_WILD_CARD)
1706 [ # # ]: 0 : for (channel = 0; channel <= shost->max_channel;
1707 : 0 : channel++)
1708 : 0 : scsi_scan_channel(shost, channel, id, lun,
1709 : : rescan);
1710 : : else
1711 : 0 : scsi_scan_channel(shost, channel, id, lun, rescan);
1712 : : scsi_autopm_put_host(shost);
1713 : : }
1714 : 0 : mutex_unlock(&shost->scan_mutex);
1715 : :
1716 : 0 : return 0;
1717 : : }
1718 : :
1719 : 0 : static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
1720 : : {
1721 : : struct scsi_device *sdev;
1722 [ # # ]: 0 : shost_for_each_device(sdev, shost) {
1723 : : /* target removed before the device could be added */
1724 [ # # ]: 0 : if (sdev->sdev_state == SDEV_DEL)
1725 : 0 : continue;
1726 [ # # # # ]: 0 : if (!scsi_host_scan_allowed(shost) ||
1727 : 0 : scsi_sysfs_add_sdev(sdev) != 0)
1728 : 0 : __scsi_remove_device(sdev);
1729 : : }
1730 : 0 : }
1731 : :
1732 : : /**
1733 : : * scsi_prep_async_scan - prepare for an async scan
1734 : : * @shost: the host which will be scanned
1735 : : * Returns: a cookie to be passed to scsi_finish_async_scan()
1736 : : *
1737 : : * Tells the midlayer this host is going to do an asynchronous scan.
1738 : : * It reserves the host's position in the scanning list and ensures
1739 : : * that other asynchronous scans started after this one won't affect the
1740 : : * ordering of the discovered devices.
1741 : : */
1742 : 0 : static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
1743 : : {
1744 : : struct async_scan_data *data;
1745 : : unsigned long flags;
1746 : :
1747 [ # # ]: 0 : if (strncmp(scsi_scan_type, "sync", 4) == 0)
1748 : : return NULL;
1749 : :
1750 [ # # ]: 0 : if (shost->async_scan) {
1751 : 0 : printk("%s called twice for host %d", __func__,
1752 : : shost->host_no);
1753 : 0 : dump_stack();
1754 : 0 : return NULL;
1755 : : }
1756 : :
1757 : : data = kmalloc(sizeof(*data), GFP_KERNEL);
1758 [ # # ]: 0 : if (!data)
1759 : : goto err;
1760 : 0 : data->shost = scsi_host_get(shost);
1761 [ # # ]: 0 : if (!data->shost)
1762 : : goto err;
1763 : : init_completion(&data->prev_finished);
1764 : :
1765 : 0 : mutex_lock(&shost->scan_mutex);
1766 : 0 : spin_lock_irqsave(shost->host_lock, flags);
1767 : 0 : shost->async_scan = 1;
1768 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
1769 : 0 : mutex_unlock(&shost->scan_mutex);
1770 : :
1771 : : spin_lock(&async_scan_lock);
1772 [ # # ]: 0 : if (list_empty(&scanning_hosts))
1773 : 0 : complete(&data->prev_finished);
1774 : 0 : list_add_tail(&data->list, &scanning_hosts);
1775 : : spin_unlock(&async_scan_lock);
1776 : :
1777 : 0 : return data;
1778 : :
1779 : : err:
1780 : 0 : kfree(data);
1781 : 0 : return NULL;
1782 : : }
1783 : :
1784 : : /**
1785 : : * scsi_finish_async_scan - asynchronous scan has finished
1786 : : * @data: cookie returned from earlier call to scsi_prep_async_scan()
1787 : : *
1788 : : * All the devices currently attached to this host have been found.
1789 : : * This function announces all the devices it has found to the rest
1790 : : * of the system.
1791 : : */
1792 : 0 : static void scsi_finish_async_scan(struct async_scan_data *data)
1793 : : {
1794 : : struct Scsi_Host *shost;
1795 : : unsigned long flags;
1796 : :
1797 [ # # ]: 0 : if (!data)
1798 : : return;
1799 : :
1800 : 0 : shost = data->shost;
1801 : :
1802 : 0 : mutex_lock(&shost->scan_mutex);
1803 : :
1804 [ # # ]: 0 : if (!shost->async_scan) {
1805 : 0 : printk("%s called twice for host %d", __func__,
1806 : : shost->host_no);
1807 : 0 : dump_stack();
1808 : 0 : mutex_unlock(&shost->scan_mutex);
1809 : 0 : return;
1810 : : }
1811 : :
1812 : 0 : wait_for_completion(&data->prev_finished);
1813 : :
1814 : 0 : scsi_sysfs_add_devices(shost);
1815 : :
1816 : 0 : spin_lock_irqsave(shost->host_lock, flags);
1817 : 0 : shost->async_scan = 0;
1818 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
1819 : :
1820 : 0 : mutex_unlock(&shost->scan_mutex);
1821 : :
1822 : : spin_lock(&async_scan_lock);
1823 : : list_del(&data->list);
1824 [ # # ]: 0 : if (!list_empty(&scanning_hosts)) {
1825 : : struct async_scan_data *next = list_entry(scanning_hosts.next,
1826 : : struct async_scan_data, list);
1827 : 0 : complete(&next->prev_finished);
1828 : : }
1829 : : spin_unlock(&async_scan_lock);
1830 : :
1831 : : scsi_autopm_put_host(shost);
1832 : 0 : scsi_host_put(shost);
1833 : 0 : kfree(data);
1834 : : }
1835 : :
1836 : 0 : static void do_scsi_scan_host(struct Scsi_Host *shost)
1837 : : {
1838 [ # # ]: 0 : if (shost->hostt->scan_finished) {
1839 : 0 : unsigned long start = jiffies;
1840 [ # # ]: 0 : if (shost->hostt->scan_start)
1841 : 0 : shost->hostt->scan_start(shost);
1842 : :
1843 [ # # ]: 0 : while (!shost->hostt->scan_finished(shost, jiffies - start))
1844 : 0 : msleep(10);
1845 : : } else {
1846 : 0 : scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
1847 : : SCAN_WILD_CARD, 0);
1848 : : }
1849 : 0 : }
1850 : :
1851 : 0 : static void do_scan_async(void *_data, async_cookie_t c)
1852 : : {
1853 : : struct async_scan_data *data = _data;
1854 : 0 : struct Scsi_Host *shost = data->shost;
1855 : :
1856 : 0 : do_scsi_scan_host(shost);
1857 : 0 : scsi_finish_async_scan(data);
1858 : 0 : }
1859 : :
1860 : : /**
1861 : : * scsi_scan_host - scan the given adapter
1862 : : * @shost: adapter to scan
1863 : : **/
1864 : 0 : void scsi_scan_host(struct Scsi_Host *shost)
1865 : : {
1866 : : struct async_scan_data *data;
1867 : :
1868 [ # # ]: 0 : if (strncmp(scsi_scan_type, "none", 4) == 0)
1869 : : return;
1870 : : if (scsi_autopm_get_host(shost) < 0)
1871 : : return;
1872 : :
1873 : 0 : data = scsi_prep_async_scan(shost);
1874 [ # # ]: 0 : if (!data) {
1875 : 0 : do_scsi_scan_host(shost);
1876 : : scsi_autopm_put_host(shost);
1877 : : return;
1878 : : }
1879 : :
1880 : : /* register with the async subsystem so wait_for_device_probe()
1881 : : * will flush this work
1882 : : */
1883 : 0 : async_schedule(do_scan_async, data);
1884 : :
1885 : : /* scsi_autopm_put_host(shost) is called in scsi_finish_async_scan() */
1886 : : }
1887 : : EXPORT_SYMBOL(scsi_scan_host);
1888 : :
1889 : 0 : void scsi_forget_host(struct Scsi_Host *shost)
1890 : : {
1891 : : struct scsi_device *sdev;
1892 : : unsigned long flags;
1893 : :
1894 : : restart:
1895 : 0 : spin_lock_irqsave(shost->host_lock, flags);
1896 [ # # ]: 0 : list_for_each_entry(sdev, &shost->__devices, siblings) {
1897 [ # # ]: 0 : if (sdev->sdev_state == SDEV_DEL)
1898 : 0 : continue;
1899 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
1900 : 0 : __scsi_remove_device(sdev);
1901 : 0 : goto restart;
1902 : : }
1903 : 0 : spin_unlock_irqrestore(shost->host_lock, flags);
1904 : 0 : }
1905 : :
1906 : : /**
1907 : : * scsi_get_host_dev - Create a scsi_device that points to the host adapter itself
1908 : : * @shost: Host that needs a scsi_device
1909 : : *
1910 : : * Lock status: None assumed.
1911 : : *
1912 : : * Returns: The scsi_device or NULL
1913 : : *
1914 : : * Notes:
1915 : : * Attach a single scsi_device to the Scsi_Host - this should
1916 : : * be made to look like a "pseudo-device" that points to the
1917 : : * HA itself.
1918 : : *
1919 : : * Note - this device is not accessible from any high-level
1920 : : * drivers (including generics), which is probably not
1921 : : * optimal. We can add hooks later to attach.
1922 : : */
1923 : 0 : struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
1924 : : {
1925 : : struct scsi_device *sdev = NULL;
1926 : : struct scsi_target *starget;
1927 : :
1928 : 0 : mutex_lock(&shost->scan_mutex);
1929 [ # # ]: 0 : if (!scsi_host_scan_allowed(shost))
1930 : : goto out;
1931 : 0 : starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
1932 [ # # ]: 0 : if (!starget)
1933 : : goto out;
1934 : :
1935 : 0 : sdev = scsi_alloc_sdev(starget, 0, NULL);
1936 [ # # ]: 0 : if (sdev)
1937 : 0 : sdev->borken = 0;
1938 : : else
1939 : 0 : scsi_target_reap(starget);
1940 : 0 : put_device(&starget->dev);
1941 : : out:
1942 : 0 : mutex_unlock(&shost->scan_mutex);
1943 : 0 : return sdev;
1944 : : }
1945 : : EXPORT_SYMBOL(scsi_get_host_dev);
1946 : :
1947 : : /**
1948 : : * scsi_free_host_dev - Free a scsi_device that points to the host adapter itself
1949 : : * @sdev: Host device to be freed
1950 : : *
1951 : : * Lock status: None assumed.
1952 : : *
1953 : : * Returns: Nothing
1954 : : */
1955 : 0 : void scsi_free_host_dev(struct scsi_device *sdev)
1956 : : {
1957 [ # # ]: 0 : BUG_ON(sdev->id != sdev->host->this_id);
1958 : :
1959 : 0 : __scsi_remove_device(sdev);
1960 : 0 : }
1961 : : EXPORT_SYMBOL(scsi_free_host_dev);
1962 : :
|
