xref: /openbmc/linux/drivers/scsi/scsi.c (revision e23feb16)
1 /*
2  *  scsi.c Copyright (C) 1992 Drew Eckhardt
3  *         Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
4  *         Copyright (C) 2002, 2003 Christoph Hellwig
5  *
6  *  generic mid-level SCSI driver
7  *      Initial versions: Drew Eckhardt
8  *      Subsequent revisions: Eric Youngdale
9  *
10  *  <drew@colorado.edu>
11  *
12  *  Bug correction thanks go to :
13  *      Rik Faith <faith@cs.unc.edu>
14  *      Tommy Thorn <tthorn>
15  *      Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
16  *
17  *  Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
18  *  add scatter-gather, multiple outstanding request, and other
19  *  enhancements.
20  *
21  *  Native multichannel, wide scsi, /proc/scsi and hot plugging
22  *  support added by Michael Neuffer <mike@i-connect.net>
23  *
24  *  Added request_module("scsi_hostadapter") for kerneld:
25  *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
26  *  Bjorn Ekwall  <bj0rn@blox.se>
27  *  (changed to kmod)
28  *
29  *  Major improvements to the timeout, abort, and reset processing,
30  *  as well as performance modifications for large queue depths by
31  *  Leonard N. Zubkoff <lnz@dandelion.com>
32  *
33  *  Converted cli() code to spinlocks, Ingo Molnar
34  *
35  *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
36  *
37  *  out_of_space hacks, D. Gilbert (dpg) 990608
38  */
39 
40 #include <linux/module.h>
41 #include <linux/moduleparam.h>
42 #include <linux/kernel.h>
43 #include <linux/timer.h>
44 #include <linux/string.h>
45 #include <linux/slab.h>
46 #include <linux/blkdev.h>
47 #include <linux/delay.h>
48 #include <linux/init.h>
49 #include <linux/completion.h>
50 #include <linux/unistd.h>
51 #include <linux/spinlock.h>
52 #include <linux/kmod.h>
53 #include <linux/interrupt.h>
54 #include <linux/notifier.h>
55 #include <linux/cpu.h>
56 #include <linux/mutex.h>
57 #include <linux/async.h>
58 #include <asm/unaligned.h>
59 
60 #include <scsi/scsi.h>
61 #include <scsi/scsi_cmnd.h>
62 #include <scsi/scsi_dbg.h>
63 #include <scsi/scsi_device.h>
64 #include <scsi/scsi_driver.h>
65 #include <scsi/scsi_eh.h>
66 #include <scsi/scsi_host.h>
67 #include <scsi/scsi_tcq.h>
68 
69 #include "scsi_priv.h"
70 #include "scsi_logging.h"
71 
72 #define CREATE_TRACE_POINTS
73 #include <trace/events/scsi.h>
74 
75 static void scsi_done(struct scsi_cmnd *cmd);
76 
77 /*
78  * Definitions and constants.
79  */
80 
81 #define MIN_RESET_DELAY (2*HZ)
82 
83 /* Do not call reset on error if we just did a reset within 15 sec. */
84 #define MIN_RESET_PERIOD (15*HZ)
85 
86 /*
87  * Note - the initial logging level can be set here to log events at boot time.
88  * After the system is up, you may enable logging via the /proc interface.
89  */
90 unsigned int scsi_logging_level;
91 #if defined(CONFIG_SCSI_LOGGING)
92 EXPORT_SYMBOL(scsi_logging_level);
93 #endif
94 
95 /* sd, scsi core and power management need to coordinate flushing async actions */
96 ASYNC_DOMAIN(scsi_sd_probe_domain);
97 EXPORT_SYMBOL(scsi_sd_probe_domain);
98 
99 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
100  * You may not alter any existing entry (although adding new ones is
101  * encouraged once assigned by ANSI/INCITS T10
102  */
103 static const char *const scsi_device_types[] = {
104 	"Direct-Access    ",
105 	"Sequential-Access",
106 	"Printer          ",
107 	"Processor        ",
108 	"WORM             ",
109 	"CD-ROM           ",
110 	"Scanner          ",
111 	"Optical Device   ",
112 	"Medium Changer   ",
113 	"Communications   ",
114 	"ASC IT8          ",
115 	"ASC IT8          ",
116 	"RAID             ",
117 	"Enclosure        ",
118 	"Direct-Access-RBC",
119 	"Optical card     ",
120 	"Bridge controller",
121 	"Object storage   ",
122 	"Automation/Drive ",
123 };
124 
125 /**
126  * scsi_device_type - Return 17 char string indicating device type.
127  * @type: type number to look up
128  */
129 
130 const char * scsi_device_type(unsigned type)
131 {
132 	if (type == 0x1e)
133 		return "Well-known LUN   ";
134 	if (type == 0x1f)
135 		return "No Device        ";
136 	if (type >= ARRAY_SIZE(scsi_device_types))
137 		return "Unknown          ";
138 	return scsi_device_types[type];
139 }
140 
141 EXPORT_SYMBOL(scsi_device_type);
142 
143 struct scsi_host_cmd_pool {
144 	struct kmem_cache	*cmd_slab;
145 	struct kmem_cache	*sense_slab;
146 	unsigned int		users;
147 	char			*cmd_name;
148 	char			*sense_name;
149 	unsigned int		slab_flags;
150 	gfp_t			gfp_mask;
151 };
152 
153 static struct scsi_host_cmd_pool scsi_cmd_pool = {
154 	.cmd_name	= "scsi_cmd_cache",
155 	.sense_name	= "scsi_sense_cache",
156 	.slab_flags	= SLAB_HWCACHE_ALIGN,
157 };
158 
159 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
160 	.cmd_name	= "scsi_cmd_cache(DMA)",
161 	.sense_name	= "scsi_sense_cache(DMA)",
162 	.slab_flags	= SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
163 	.gfp_mask	= __GFP_DMA,
164 };
165 
166 static DEFINE_MUTEX(host_cmd_pool_mutex);
167 
168 /**
169  * scsi_pool_alloc_command - internal function to get a fully allocated command
170  * @pool:	slab pool to allocate the command from
171  * @gfp_mask:	mask for the allocation
172  *
173  * Returns a fully allocated command (with the allied sense buffer) or
174  * NULL on failure
175  */
176 static struct scsi_cmnd *
177 scsi_pool_alloc_command(struct scsi_host_cmd_pool *pool, gfp_t gfp_mask)
178 {
179 	struct scsi_cmnd *cmd;
180 
181 	cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
182 	if (!cmd)
183 		return NULL;
184 
185 	cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
186 					     gfp_mask | pool->gfp_mask);
187 	if (!cmd->sense_buffer) {
188 		kmem_cache_free(pool->cmd_slab, cmd);
189 		return NULL;
190 	}
191 
192 	return cmd;
193 }
194 
195 /**
196  * scsi_pool_free_command - internal function to release a command
197  * @pool:	slab pool to allocate the command from
198  * @cmd:	command to release
199  *
200  * the command must previously have been allocated by
201  * scsi_pool_alloc_command.
202  */
203 static void
204 scsi_pool_free_command(struct scsi_host_cmd_pool *pool,
205 			 struct scsi_cmnd *cmd)
206 {
207 	if (cmd->prot_sdb)
208 		kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
209 
210 	kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
211 	kmem_cache_free(pool->cmd_slab, cmd);
212 }
213 
214 /**
215  * scsi_host_alloc_command - internal function to allocate command
216  * @shost:	SCSI host whose pool to allocate from
217  * @gfp_mask:	mask for the allocation
218  *
219  * Returns a fully allocated command with sense buffer and protection
220  * data buffer (where applicable) or NULL on failure
221  */
222 static struct scsi_cmnd *
223 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
224 {
225 	struct scsi_cmnd *cmd;
226 
227 	cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask);
228 	if (!cmd)
229 		return NULL;
230 
231 	if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
232 		cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
233 
234 		if (!cmd->prot_sdb) {
235 			scsi_pool_free_command(shost->cmd_pool, cmd);
236 			return NULL;
237 		}
238 	}
239 
240 	return cmd;
241 }
242 
243 /**
244  * __scsi_get_command - Allocate a struct scsi_cmnd
245  * @shost: host to transmit command
246  * @gfp_mask: allocation mask
247  *
248  * Description: allocate a struct scsi_cmd from host's slab, recycling from the
249  *              host's free_list if necessary.
250  */
251 struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
252 {
253 	struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
254 
255 	if (unlikely(!cmd)) {
256 		unsigned long flags;
257 
258 		spin_lock_irqsave(&shost->free_list_lock, flags);
259 		if (likely(!list_empty(&shost->free_list))) {
260 			cmd = list_entry(shost->free_list.next,
261 					 struct scsi_cmnd, list);
262 			list_del_init(&cmd->list);
263 		}
264 		spin_unlock_irqrestore(&shost->free_list_lock, flags);
265 
266 		if (cmd) {
267 			void *buf, *prot;
268 
269 			buf = cmd->sense_buffer;
270 			prot = cmd->prot_sdb;
271 
272 			memset(cmd, 0, sizeof(*cmd));
273 
274 			cmd->sense_buffer = buf;
275 			cmd->prot_sdb = prot;
276 		}
277 	}
278 
279 	return cmd;
280 }
281 EXPORT_SYMBOL_GPL(__scsi_get_command);
282 
283 /**
284  * scsi_get_command - Allocate and setup a scsi command block
285  * @dev: parent scsi device
286  * @gfp_mask: allocator flags
287  *
288  * Returns:	The allocated scsi command structure.
289  */
290 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
291 {
292 	struct scsi_cmnd *cmd;
293 
294 	/* Bail if we can't get a reference to the device */
295 	if (!get_device(&dev->sdev_gendev))
296 		return NULL;
297 
298 	cmd = __scsi_get_command(dev->host, gfp_mask);
299 
300 	if (likely(cmd != NULL)) {
301 		unsigned long flags;
302 
303 		cmd->device = dev;
304 		INIT_LIST_HEAD(&cmd->list);
305 		spin_lock_irqsave(&dev->list_lock, flags);
306 		list_add_tail(&cmd->list, &dev->cmd_list);
307 		spin_unlock_irqrestore(&dev->list_lock, flags);
308 		cmd->jiffies_at_alloc = jiffies;
309 	} else
310 		put_device(&dev->sdev_gendev);
311 
312 	return cmd;
313 }
314 EXPORT_SYMBOL(scsi_get_command);
315 
316 /**
317  * __scsi_put_command - Free a struct scsi_cmnd
318  * @shost: dev->host
319  * @cmd: Command to free
320  * @dev: parent scsi device
321  */
322 void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd,
323 			struct device *dev)
324 {
325 	unsigned long flags;
326 
327 	/* changing locks here, don't need to restore the irq state */
328 	spin_lock_irqsave(&shost->free_list_lock, flags);
329 	if (unlikely(list_empty(&shost->free_list))) {
330 		list_add(&cmd->list, &shost->free_list);
331 		cmd = NULL;
332 	}
333 	spin_unlock_irqrestore(&shost->free_list_lock, flags);
334 
335 	if (likely(cmd != NULL))
336 		scsi_pool_free_command(shost->cmd_pool, cmd);
337 
338 	put_device(dev);
339 }
340 EXPORT_SYMBOL(__scsi_put_command);
341 
342 /**
343  * scsi_put_command - Free a scsi command block
344  * @cmd: command block to free
345  *
346  * Returns:	Nothing.
347  *
348  * Notes:	The command must not belong to any lists.
349  */
350 void scsi_put_command(struct scsi_cmnd *cmd)
351 {
352 	struct scsi_device *sdev = cmd->device;
353 	unsigned long flags;
354 
355 	/* serious error if the command hasn't come from a device list */
356 	spin_lock_irqsave(&cmd->device->list_lock, flags);
357 	BUG_ON(list_empty(&cmd->list));
358 	list_del_init(&cmd->list);
359 	spin_unlock_irqrestore(&cmd->device->list_lock, flags);
360 
361 	__scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
362 }
363 EXPORT_SYMBOL(scsi_put_command);
364 
365 static struct scsi_host_cmd_pool *scsi_get_host_cmd_pool(gfp_t gfp_mask)
366 {
367 	struct scsi_host_cmd_pool *retval = NULL, *pool;
368 	/*
369 	 * Select a command slab for this host and create it if not
370 	 * yet existent.
371 	 */
372 	mutex_lock(&host_cmd_pool_mutex);
373 	pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
374 		&scsi_cmd_pool;
375 	if (!pool->users) {
376 		pool->cmd_slab = kmem_cache_create(pool->cmd_name,
377 						   sizeof(struct scsi_cmnd), 0,
378 						   pool->slab_flags, NULL);
379 		if (!pool->cmd_slab)
380 			goto fail;
381 
382 		pool->sense_slab = kmem_cache_create(pool->sense_name,
383 						     SCSI_SENSE_BUFFERSIZE, 0,
384 						     pool->slab_flags, NULL);
385 		if (!pool->sense_slab) {
386 			kmem_cache_destroy(pool->cmd_slab);
387 			goto fail;
388 		}
389 	}
390 
391 	pool->users++;
392 	retval = pool;
393  fail:
394 	mutex_unlock(&host_cmd_pool_mutex);
395 	return retval;
396 }
397 
398 static void scsi_put_host_cmd_pool(gfp_t gfp_mask)
399 {
400 	struct scsi_host_cmd_pool *pool;
401 
402 	mutex_lock(&host_cmd_pool_mutex);
403 	pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
404 		&scsi_cmd_pool;
405 	/*
406 	 * This may happen if a driver has a mismatched get and put
407 	 * of the command pool; the driver should be implicated in
408 	 * the stack trace
409 	 */
410 	BUG_ON(pool->users == 0);
411 
412 	if (!--pool->users) {
413 		kmem_cache_destroy(pool->cmd_slab);
414 		kmem_cache_destroy(pool->sense_slab);
415 	}
416 	mutex_unlock(&host_cmd_pool_mutex);
417 }
418 
419 /**
420  * scsi_allocate_command - get a fully allocated SCSI command
421  * @gfp_mask:	allocation mask
422  *
423  * This function is for use outside of the normal host based pools.
424  * It allocates the relevant command and takes an additional reference
425  * on the pool it used.  This function *must* be paired with
426  * scsi_free_command which also has the identical mask, otherwise the
427  * free pool counts will eventually go wrong and you'll trigger a bug.
428  *
429  * This function should *only* be used by drivers that need a static
430  * command allocation at start of day for internal functions.
431  */
432 struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask)
433 {
434 	struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
435 
436 	if (!pool)
437 		return NULL;
438 
439 	return scsi_pool_alloc_command(pool, gfp_mask);
440 }
441 EXPORT_SYMBOL(scsi_allocate_command);
442 
443 /**
444  * scsi_free_command - free a command allocated by scsi_allocate_command
445  * @gfp_mask:	mask used in the original allocation
446  * @cmd:	command to free
447  *
448  * Note: using the original allocation mask is vital because that's
449  * what determines which command pool we use to free the command.  Any
450  * mismatch will cause the system to BUG eventually.
451  */
452 void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd)
453 {
454 	struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
455 
456 	/*
457 	 * this could trigger if the mask to scsi_allocate_command
458 	 * doesn't match this mask.  Otherwise we're guaranteed that this
459 	 * succeeds because scsi_allocate_command must have taken a reference
460 	 * on the pool
461 	 */
462 	BUG_ON(!pool);
463 
464 	scsi_pool_free_command(pool, cmd);
465 	/*
466 	 * scsi_put_host_cmd_pool is called twice; once to release the
467 	 * reference we took above, and once to release the reference
468 	 * originally taken by scsi_allocate_command
469 	 */
470 	scsi_put_host_cmd_pool(gfp_mask);
471 	scsi_put_host_cmd_pool(gfp_mask);
472 }
473 EXPORT_SYMBOL(scsi_free_command);
474 
475 /**
476  * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
477  * @shost: host to allocate the freelist for.
478  *
479  * Description: The command freelist protects against system-wide out of memory
480  * deadlock by preallocating one SCSI command structure for each host, so the
481  * system can always write to a swap file on a device associated with that host.
482  *
483  * Returns:	Nothing.
484  */
485 int scsi_setup_command_freelist(struct Scsi_Host *shost)
486 {
487 	struct scsi_cmnd *cmd;
488 	const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
489 
490 	spin_lock_init(&shost->free_list_lock);
491 	INIT_LIST_HEAD(&shost->free_list);
492 
493 	shost->cmd_pool = scsi_get_host_cmd_pool(gfp_mask);
494 
495 	if (!shost->cmd_pool)
496 		return -ENOMEM;
497 
498 	/*
499 	 * Get one backup command for this host.
500 	 */
501 	cmd = scsi_host_alloc_command(shost, gfp_mask);
502 	if (!cmd) {
503 		scsi_put_host_cmd_pool(gfp_mask);
504 		shost->cmd_pool = NULL;
505 		return -ENOMEM;
506 	}
507 	list_add(&cmd->list, &shost->free_list);
508 	return 0;
509 }
510 
511 /**
512  * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
513  * @shost: host whose freelist is going to be destroyed
514  */
515 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
516 {
517 	/*
518 	 * If cmd_pool is NULL the free list was not initialized, so
519 	 * do not attempt to release resources.
520 	 */
521 	if (!shost->cmd_pool)
522 		return;
523 
524 	while (!list_empty(&shost->free_list)) {
525 		struct scsi_cmnd *cmd;
526 
527 		cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
528 		list_del_init(&cmd->list);
529 		scsi_pool_free_command(shost->cmd_pool, cmd);
530 	}
531 	shost->cmd_pool = NULL;
532 	scsi_put_host_cmd_pool(shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL);
533 }
534 
535 #ifdef CONFIG_SCSI_LOGGING
536 void scsi_log_send(struct scsi_cmnd *cmd)
537 {
538 	unsigned int level;
539 
540 	/*
541 	 * If ML QUEUE log level is greater than or equal to:
542 	 *
543 	 * 1: nothing (match completion)
544 	 *
545 	 * 2: log opcode + command of all commands
546 	 *
547 	 * 3: same as 2 plus dump cmd address
548 	 *
549 	 * 4: same as 3 plus dump extra junk
550 	 */
551 	if (unlikely(scsi_logging_level)) {
552 		level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
553 				       SCSI_LOG_MLQUEUE_BITS);
554 		if (level > 1) {
555 			scmd_printk(KERN_INFO, cmd, "Send: ");
556 			if (level > 2)
557 				printk("0x%p ", cmd);
558 			printk("\n");
559 			scsi_print_command(cmd);
560 			if (level > 3) {
561 				printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
562 				       " queuecommand 0x%p\n",
563 					scsi_sglist(cmd), scsi_bufflen(cmd),
564 					cmd->device->host->hostt->queuecommand);
565 
566 			}
567 		}
568 	}
569 }
570 
571 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
572 {
573 	unsigned int level;
574 
575 	/*
576 	 * If ML COMPLETE log level is greater than or equal to:
577 	 *
578 	 * 1: log disposition, result, opcode + command, and conditionally
579 	 * sense data for failures or non SUCCESS dispositions.
580 	 *
581 	 * 2: same as 1 but for all command completions.
582 	 *
583 	 * 3: same as 2 plus dump cmd address
584 	 *
585 	 * 4: same as 3 plus dump extra junk
586 	 */
587 	if (unlikely(scsi_logging_level)) {
588 		level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
589 				       SCSI_LOG_MLCOMPLETE_BITS);
590 		if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
591 		    (level > 1)) {
592 			scmd_printk(KERN_INFO, cmd, "Done: ");
593 			if (level > 2)
594 				printk("0x%p ", cmd);
595 			/*
596 			 * Dump truncated values, so we usually fit within
597 			 * 80 chars.
598 			 */
599 			switch (disposition) {
600 			case SUCCESS:
601 				printk("SUCCESS\n");
602 				break;
603 			case NEEDS_RETRY:
604 				printk("RETRY\n");
605 				break;
606 			case ADD_TO_MLQUEUE:
607 				printk("MLQUEUE\n");
608 				break;
609 			case FAILED:
610 				printk("FAILED\n");
611 				break;
612 			case TIMEOUT_ERROR:
613 				/*
614 				 * If called via scsi_times_out.
615 				 */
616 				printk("TIMEOUT\n");
617 				break;
618 			default:
619 				printk("UNKNOWN\n");
620 			}
621 			scsi_print_result(cmd);
622 			scsi_print_command(cmd);
623 			if (status_byte(cmd->result) & CHECK_CONDITION)
624 				scsi_print_sense("", cmd);
625 			if (level > 3)
626 				scmd_printk(KERN_INFO, cmd,
627 					    "scsi host busy %d failed %d\n",
628 					    cmd->device->host->host_busy,
629 					    cmd->device->host->host_failed);
630 		}
631 	}
632 }
633 #endif
634 
635 /**
636  * scsi_cmd_get_serial - Assign a serial number to a command
637  * @host: the scsi host
638  * @cmd: command to assign serial number to
639  *
640  * Description: a serial number identifies a request for error recovery
641  * and debugging purposes.  Protected by the Host_Lock of host.
642  */
643 void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
644 {
645 	cmd->serial_number = host->cmd_serial_number++;
646 	if (cmd->serial_number == 0)
647 		cmd->serial_number = host->cmd_serial_number++;
648 }
649 EXPORT_SYMBOL(scsi_cmd_get_serial);
650 
651 /**
652  * scsi_dispatch_command - Dispatch a command to the low-level driver.
653  * @cmd: command block we are dispatching.
654  *
655  * Return: nonzero return request was rejected and device's queue needs to be
656  * plugged.
657  */
658 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
659 {
660 	struct Scsi_Host *host = cmd->device->host;
661 	unsigned long timeout;
662 	int rtn = 0;
663 
664 	atomic_inc(&cmd->device->iorequest_cnt);
665 
666 	/* check if the device is still usable */
667 	if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
668 		/* in SDEV_DEL we error all commands. DID_NO_CONNECT
669 		 * returns an immediate error upwards, and signals
670 		 * that the device is no longer present */
671 		cmd->result = DID_NO_CONNECT << 16;
672 		scsi_done(cmd);
673 		/* return 0 (because the command has been processed) */
674 		goto out;
675 	}
676 
677 	/* Check to see if the scsi lld made this device blocked. */
678 	if (unlikely(scsi_device_blocked(cmd->device))) {
679 		/*
680 		 * in blocked state, the command is just put back on
681 		 * the device queue.  The suspend state has already
682 		 * blocked the queue so future requests should not
683 		 * occur until the device transitions out of the
684 		 * suspend state.
685 		 */
686 
687 		scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
688 
689 		SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
690 
691 		/*
692 		 * NOTE: rtn is still zero here because we don't need the
693 		 * queue to be plugged on return (it's already stopped)
694 		 */
695 		goto out;
696 	}
697 
698 	/*
699 	 * If SCSI-2 or lower, store the LUN value in cmnd.
700 	 */
701 	if (cmd->device->scsi_level <= SCSI_2 &&
702 	    cmd->device->scsi_level != SCSI_UNKNOWN) {
703 		cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
704 			       (cmd->device->lun << 5 & 0xe0);
705 	}
706 
707 	/*
708 	 * We will wait MIN_RESET_DELAY clock ticks after the last reset so
709 	 * we can avoid the drive not being ready.
710 	 */
711 	timeout = host->last_reset + MIN_RESET_DELAY;
712 
713 	if (host->resetting && time_before(jiffies, timeout)) {
714 		int ticks_remaining = timeout - jiffies;
715 		/*
716 		 * NOTE: This may be executed from within an interrupt
717 		 * handler!  This is bad, but for now, it'll do.  The irq
718 		 * level of the interrupt handler has been masked out by the
719 		 * platform dependent interrupt handling code already, so the
720 		 * sti() here will not cause another call to the SCSI host's
721 		 * interrupt handler (assuming there is one irq-level per
722 		 * host).
723 		 */
724 		while (--ticks_remaining >= 0)
725 			mdelay(1 + 999 / HZ);
726 		host->resetting = 0;
727 	}
728 
729 	scsi_log_send(cmd);
730 
731 	/*
732 	 * Before we queue this command, check if the command
733 	 * length exceeds what the host adapter can handle.
734 	 */
735 	if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
736 		SCSI_LOG_MLQUEUE(3,
737 			printk("queuecommand : command too long. "
738 			       "cdb_size=%d host->max_cmd_len=%d\n",
739 			       cmd->cmd_len, cmd->device->host->max_cmd_len));
740 		cmd->result = (DID_ABORT << 16);
741 
742 		scsi_done(cmd);
743 		goto out;
744 	}
745 
746 	if (unlikely(host->shost_state == SHOST_DEL)) {
747 		cmd->result = (DID_NO_CONNECT << 16);
748 		scsi_done(cmd);
749 	} else {
750 		trace_scsi_dispatch_cmd_start(cmd);
751 		cmd->scsi_done = scsi_done;
752 		rtn = host->hostt->queuecommand(host, cmd);
753 	}
754 
755 	if (rtn) {
756 		trace_scsi_dispatch_cmd_error(cmd, rtn);
757 		if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
758 		    rtn != SCSI_MLQUEUE_TARGET_BUSY)
759 			rtn = SCSI_MLQUEUE_HOST_BUSY;
760 
761 		scsi_queue_insert(cmd, rtn);
762 
763 		SCSI_LOG_MLQUEUE(3,
764 		    printk("queuecommand : request rejected\n"));
765 	}
766 
767  out:
768 	SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
769 	return rtn;
770 }
771 
772 /**
773  * scsi_done - Enqueue the finished SCSI command into the done queue.
774  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
775  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
776  *
777  * Description: This function is the mid-level's (SCSI Core) interrupt routine,
778  * which regains ownership of the SCSI command (de facto) from a LLDD, and
779  * enqueues the command to the done queue for further processing.
780  *
781  * This is the producer of the done queue who enqueues at the tail.
782  *
783  * This function is interrupt context safe.
784  */
785 static void scsi_done(struct scsi_cmnd *cmd)
786 {
787 	trace_scsi_dispatch_cmd_done(cmd);
788 	blk_complete_request(cmd->request);
789 }
790 
791 /**
792  * scsi_finish_command - cleanup and pass command back to upper layer
793  * @cmd: the command
794  *
795  * Description: Pass command off to upper layer for finishing of I/O
796  *              request, waking processes that are waiting on results,
797  *              etc.
798  */
799 void scsi_finish_command(struct scsi_cmnd *cmd)
800 {
801 	struct scsi_device *sdev = cmd->device;
802 	struct scsi_target *starget = scsi_target(sdev);
803 	struct Scsi_Host *shost = sdev->host;
804 	struct scsi_driver *drv;
805 	unsigned int good_bytes;
806 
807 	scsi_device_unbusy(sdev);
808 
809         /*
810          * Clear the flags which say that the device/host is no longer
811          * capable of accepting new commands.  These are set in scsi_queue.c
812          * for both the queue full condition on a device, and for a
813          * host full condition on the host.
814 	 *
815 	 * XXX(hch): What about locking?
816          */
817         shost->host_blocked = 0;
818 	starget->target_blocked = 0;
819         sdev->device_blocked = 0;
820 
821 	/*
822 	 * If we have valid sense information, then some kind of recovery
823 	 * must have taken place.  Make a note of this.
824 	 */
825 	if (SCSI_SENSE_VALID(cmd))
826 		cmd->result |= (DRIVER_SENSE << 24);
827 
828 	SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
829 				"Notifying upper driver of completion "
830 				"(result %x)\n", cmd->result));
831 
832 	good_bytes = scsi_bufflen(cmd);
833         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
834 		int old_good_bytes = good_bytes;
835 		drv = scsi_cmd_to_driver(cmd);
836 		if (drv->done)
837 			good_bytes = drv->done(cmd);
838 		/*
839 		 * USB may not give sense identifying bad sector and
840 		 * simply return a residue instead, so subtract off the
841 		 * residue if drv->done() error processing indicates no
842 		 * change to the completion length.
843 		 */
844 		if (good_bytes == old_good_bytes)
845 			good_bytes -= scsi_get_resid(cmd);
846 	}
847 	scsi_io_completion(cmd, good_bytes);
848 }
849 EXPORT_SYMBOL(scsi_finish_command);
850 
851 /**
852  * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
853  * @sdev: SCSI Device in question
854  * @tagged: Do we use tagged queueing (non-0) or do we treat
855  *          this device as an untagged device (0)
856  * @tags: Number of tags allowed if tagged queueing enabled,
857  *        or number of commands the low level driver can
858  *        queue up in non-tagged mode (as per cmd_per_lun).
859  *
860  * Returns:	Nothing
861  *
862  * Lock Status:	None held on entry
863  *
864  * Notes:	Low level drivers may call this at any time and we will do
865  * 		the right thing depending on whether or not the device is
866  * 		currently active and whether or not it even has the
867  * 		command blocks built yet.
868  */
869 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
870 {
871 	unsigned long flags;
872 
873 	/*
874 	 * refuse to set tagged depth to an unworkable size
875 	 */
876 	if (tags <= 0)
877 		return;
878 
879 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
880 
881 	/*
882 	 * Check to see if the queue is managed by the block layer.
883 	 * If it is, and we fail to adjust the depth, exit.
884 	 *
885 	 * Do not resize the tag map if it is a host wide share bqt,
886 	 * because the size should be the hosts's can_queue. If there
887 	 * is more IO than the LLD's can_queue (so there are not enuogh
888 	 * tags) request_fn's host queue ready check will handle it.
889 	 */
890 	if (!sdev->host->bqt) {
891 		if (blk_queue_tagged(sdev->request_queue) &&
892 		    blk_queue_resize_tags(sdev->request_queue, tags) != 0)
893 			goto out;
894 	}
895 
896 	sdev->queue_depth = tags;
897 	switch (tagged) {
898 		case MSG_ORDERED_TAG:
899 			sdev->ordered_tags = 1;
900 			sdev->simple_tags = 1;
901 			break;
902 		case MSG_SIMPLE_TAG:
903 			sdev->ordered_tags = 0;
904 			sdev->simple_tags = 1;
905 			break;
906 		default:
907 			sdev_printk(KERN_WARNING, sdev,
908 				    "scsi_adjust_queue_depth, bad queue type, "
909 				    "disabled\n");
910 		case 0:
911 			sdev->ordered_tags = sdev->simple_tags = 0;
912 			sdev->queue_depth = tags;
913 			break;
914 	}
915  out:
916 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
917 }
918 EXPORT_SYMBOL(scsi_adjust_queue_depth);
919 
920 /**
921  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
922  * @sdev: SCSI Device in question
923  * @depth: Current number of outstanding SCSI commands on this device,
924  *         not counting the one returned as QUEUE_FULL.
925  *
926  * Description:	This function will track successive QUEUE_FULL events on a
927  * 		specific SCSI device to determine if and when there is a
928  * 		need to adjust the queue depth on the device.
929  *
930  * Returns:	0 - No change needed, >0 - Adjust queue depth to this new depth,
931  * 		-1 - Drop back to untagged operation using host->cmd_per_lun
932  * 			as the untagged command depth
933  *
934  * Lock Status:	None held on entry
935  *
936  * Notes:	Low level drivers may call this at any time and we will do
937  * 		"The Right Thing."  We are interrupt context safe.
938  */
939 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
940 {
941 
942 	/*
943 	 * Don't let QUEUE_FULLs on the same
944 	 * jiffies count, they could all be from
945 	 * same event.
946 	 */
947 	if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
948 		return 0;
949 
950 	sdev->last_queue_full_time = jiffies;
951 	if (sdev->last_queue_full_depth != depth) {
952 		sdev->last_queue_full_count = 1;
953 		sdev->last_queue_full_depth = depth;
954 	} else {
955 		sdev->last_queue_full_count++;
956 	}
957 
958 	if (sdev->last_queue_full_count <= 10)
959 		return 0;
960 	if (sdev->last_queue_full_depth < 8) {
961 		/* Drop back to untagged */
962 		scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
963 		return -1;
964 	}
965 
966 	if (sdev->ordered_tags)
967 		scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
968 	else
969 		scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
970 	return depth;
971 }
972 EXPORT_SYMBOL(scsi_track_queue_full);
973 
974 /**
975  * scsi_vpd_inquiry - Request a device provide us with a VPD page
976  * @sdev: The device to ask
977  * @buffer: Where to put the result
978  * @page: Which Vital Product Data to return
979  * @len: The length of the buffer
980  *
981  * This is an internal helper function.  You probably want to use
982  * scsi_get_vpd_page instead.
983  *
984  * Returns 0 on success or a negative error number.
985  */
986 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
987 							u8 page, unsigned len)
988 {
989 	int result;
990 	unsigned char cmd[16];
991 
992 	cmd[0] = INQUIRY;
993 	cmd[1] = 1;		/* EVPD */
994 	cmd[2] = page;
995 	cmd[3] = len >> 8;
996 	cmd[4] = len & 0xff;
997 	cmd[5] = 0;		/* Control byte */
998 
999 	/*
1000 	 * I'm not convinced we need to try quite this hard to get VPD, but
1001 	 * all the existing users tried this hard.
1002 	 */
1003 	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
1004 				  len, NULL, 30 * HZ, 3, NULL);
1005 	if (result)
1006 		return result;
1007 
1008 	/* Sanity check that we got the page back that we asked for */
1009 	if (buffer[1] != page)
1010 		return -EIO;
1011 
1012 	return 0;
1013 }
1014 
1015 /**
1016  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
1017  * @sdev: The device to ask
1018  * @page: Which Vital Product Data to return
1019  * @buf: where to store the VPD
1020  * @buf_len: number of bytes in the VPD buffer area
1021  *
1022  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
1023  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
1024  * If the device supports this VPD page, this routine returns a pointer
1025  * to a buffer containing the data from that page.  The caller is
1026  * responsible for calling kfree() on this pointer when it is no longer
1027  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
1028  */
1029 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
1030 		      int buf_len)
1031 {
1032 	int i, result;
1033 
1034 	if (sdev->skip_vpd_pages)
1035 		goto fail;
1036 
1037 	/* Ask for all the pages supported by this device */
1038 	result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
1039 	if (result)
1040 		goto fail;
1041 
1042 	/* If the user actually wanted this page, we can skip the rest */
1043 	if (page == 0)
1044 		return 0;
1045 
1046 	for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
1047 		if (buf[i + 4] == page)
1048 			goto found;
1049 
1050 	if (i < buf[3] && i >= buf_len - 4)
1051 		/* ran off the end of the buffer, give us benefit of doubt */
1052 		goto found;
1053 	/* The device claims it doesn't support the requested page */
1054 	goto fail;
1055 
1056  found:
1057 	result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
1058 	if (result)
1059 		goto fail;
1060 
1061 	return 0;
1062 
1063  fail:
1064 	return -EINVAL;
1065 }
1066 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
1067 
1068 /**
1069  * scsi_report_opcode - Find out if a given command opcode is supported
1070  * @sdev:	scsi device to query
1071  * @buffer:	scratch buffer (must be at least 20 bytes long)
1072  * @len:	length of buffer
1073  * @opcode:	opcode for command to look up
1074  *
1075  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
1076  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
1077  * unsupported and 1 if the device claims to support the command.
1078  */
1079 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
1080 		       unsigned int len, unsigned char opcode)
1081 {
1082 	unsigned char cmd[16];
1083 	struct scsi_sense_hdr sshdr;
1084 	int result;
1085 
1086 	if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
1087 		return -EINVAL;
1088 
1089 	memset(cmd, 0, 16);
1090 	cmd[0] = MAINTENANCE_IN;
1091 	cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
1092 	cmd[2] = 1;		/* One command format */
1093 	cmd[3] = opcode;
1094 	put_unaligned_be32(len, &cmd[6]);
1095 	memset(buffer, 0, len);
1096 
1097 	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1098 				  &sshdr, 30 * HZ, 3, NULL);
1099 
1100 	if (result && scsi_sense_valid(&sshdr) &&
1101 	    sshdr.sense_key == ILLEGAL_REQUEST &&
1102 	    (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
1103 		return -EINVAL;
1104 
1105 	if ((buffer[1] & 3) == 3) /* Command supported */
1106 		return 1;
1107 
1108 	return 0;
1109 }
1110 EXPORT_SYMBOL(scsi_report_opcode);
1111 
1112 /**
1113  * scsi_device_get  -  get an additional reference to a scsi_device
1114  * @sdev:	device to get a reference to
1115  *
1116  * Description: Gets a reference to the scsi_device and increments the use count
1117  * of the underlying LLDD module.  You must hold host_lock of the
1118  * parent Scsi_Host or already have a reference when calling this.
1119  */
1120 int scsi_device_get(struct scsi_device *sdev)
1121 {
1122 	if (sdev->sdev_state == SDEV_DEL)
1123 		return -ENXIO;
1124 	if (!get_device(&sdev->sdev_gendev))
1125 		return -ENXIO;
1126 	/* We can fail this if we're doing SCSI operations
1127 	 * from module exit (like cache flush) */
1128 	try_module_get(sdev->host->hostt->module);
1129 
1130 	return 0;
1131 }
1132 EXPORT_SYMBOL(scsi_device_get);
1133 
1134 /**
1135  * scsi_device_put  -  release a reference to a scsi_device
1136  * @sdev:	device to release a reference on.
1137  *
1138  * Description: Release a reference to the scsi_device and decrements the use
1139  * count of the underlying LLDD module.  The device is freed once the last
1140  * user vanishes.
1141  */
1142 void scsi_device_put(struct scsi_device *sdev)
1143 {
1144 #ifdef CONFIG_MODULE_UNLOAD
1145 	struct module *module = sdev->host->hostt->module;
1146 
1147 	/* The module refcount will be zero if scsi_device_get()
1148 	 * was called from a module removal routine */
1149 	if (module && module_refcount(module) != 0)
1150 		module_put(module);
1151 #endif
1152 	put_device(&sdev->sdev_gendev);
1153 }
1154 EXPORT_SYMBOL(scsi_device_put);
1155 
1156 /* helper for shost_for_each_device, see that for documentation */
1157 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1158 					   struct scsi_device *prev)
1159 {
1160 	struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1161 	struct scsi_device *next = NULL;
1162 	unsigned long flags;
1163 
1164 	spin_lock_irqsave(shost->host_lock, flags);
1165 	while (list->next != &shost->__devices) {
1166 		next = list_entry(list->next, struct scsi_device, siblings);
1167 		/* skip devices that we can't get a reference to */
1168 		if (!scsi_device_get(next))
1169 			break;
1170 		next = NULL;
1171 		list = list->next;
1172 	}
1173 	spin_unlock_irqrestore(shost->host_lock, flags);
1174 
1175 	if (prev)
1176 		scsi_device_put(prev);
1177 	return next;
1178 }
1179 EXPORT_SYMBOL(__scsi_iterate_devices);
1180 
1181 /**
1182  * starget_for_each_device  -  helper to walk all devices of a target
1183  * @starget:	target whose devices we want to iterate over.
1184  * @data:	Opaque passed to each function call.
1185  * @fn:		Function to call on each device
1186  *
1187  * This traverses over each device of @starget.  The devices have
1188  * a reference that must be released by scsi_host_put when breaking
1189  * out of the loop.
1190  */
1191 void starget_for_each_device(struct scsi_target *starget, void *data,
1192 		     void (*fn)(struct scsi_device *, void *))
1193 {
1194 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1195 	struct scsi_device *sdev;
1196 
1197 	shost_for_each_device(sdev, shost) {
1198 		if ((sdev->channel == starget->channel) &&
1199 		    (sdev->id == starget->id))
1200 			fn(sdev, data);
1201 	}
1202 }
1203 EXPORT_SYMBOL(starget_for_each_device);
1204 
1205 /**
1206  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1207  * @starget:	target whose devices we want to iterate over.
1208  * @data:	parameter for callback @fn()
1209  * @fn:		callback function that is invoked for each device
1210  *
1211  * This traverses over each device of @starget.  It does _not_
1212  * take a reference on the scsi_device, so the whole loop must be
1213  * protected by shost->host_lock.
1214  *
1215  * Note:  The only reason why drivers would want to use this is because
1216  * they need to access the device list in irq context.  Otherwise you
1217  * really want to use starget_for_each_device instead.
1218  **/
1219 void __starget_for_each_device(struct scsi_target *starget, void *data,
1220 			       void (*fn)(struct scsi_device *, void *))
1221 {
1222 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1223 	struct scsi_device *sdev;
1224 
1225 	__shost_for_each_device(sdev, shost) {
1226 		if ((sdev->channel == starget->channel) &&
1227 		    (sdev->id == starget->id))
1228 			fn(sdev, data);
1229 	}
1230 }
1231 EXPORT_SYMBOL(__starget_for_each_device);
1232 
1233 /**
1234  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1235  * @starget:	SCSI target pointer
1236  * @lun:	SCSI Logical Unit Number
1237  *
1238  * Description: Looks up the scsi_device with the specified @lun for a given
1239  * @starget.  The returned scsi_device does not have an additional
1240  * reference.  You must hold the host's host_lock over this call and
1241  * any access to the returned scsi_device. A scsi_device in state
1242  * SDEV_DEL is skipped.
1243  *
1244  * Note:  The only reason why drivers should use this is because
1245  * they need to access the device list in irq context.  Otherwise you
1246  * really want to use scsi_device_lookup_by_target instead.
1247  **/
1248 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1249 						   uint lun)
1250 {
1251 	struct scsi_device *sdev;
1252 
1253 	list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1254 		if (sdev->sdev_state == SDEV_DEL)
1255 			continue;
1256 		if (sdev->lun ==lun)
1257 			return sdev;
1258 	}
1259 
1260 	return NULL;
1261 }
1262 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1263 
1264 /**
1265  * scsi_device_lookup_by_target - find a device given the target
1266  * @starget:	SCSI target pointer
1267  * @lun:	SCSI Logical Unit Number
1268  *
1269  * Description: Looks up the scsi_device with the specified @lun for a given
1270  * @starget.  The returned scsi_device has an additional reference that
1271  * needs to be released with scsi_device_put once you're done with it.
1272  **/
1273 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1274 						 uint lun)
1275 {
1276 	struct scsi_device *sdev;
1277 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1278 	unsigned long flags;
1279 
1280 	spin_lock_irqsave(shost->host_lock, flags);
1281 	sdev = __scsi_device_lookup_by_target(starget, lun);
1282 	if (sdev && scsi_device_get(sdev))
1283 		sdev = NULL;
1284 	spin_unlock_irqrestore(shost->host_lock, flags);
1285 
1286 	return sdev;
1287 }
1288 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1289 
1290 /**
1291  * __scsi_device_lookup - find a device given the host (UNLOCKED)
1292  * @shost:	SCSI host pointer
1293  * @channel:	SCSI channel (zero if only one channel)
1294  * @id:		SCSI target number (physical unit number)
1295  * @lun:	SCSI Logical Unit Number
1296  *
1297  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1298  * for a given host. The returned scsi_device does not have an additional
1299  * reference.  You must hold the host's host_lock over this call and any access
1300  * to the returned scsi_device.
1301  *
1302  * Note:  The only reason why drivers would want to use this is because
1303  * they need to access the device list in irq context.  Otherwise you
1304  * really want to use scsi_device_lookup instead.
1305  **/
1306 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1307 		uint channel, uint id, uint lun)
1308 {
1309 	struct scsi_device *sdev;
1310 
1311 	list_for_each_entry(sdev, &shost->__devices, siblings) {
1312 		if (sdev->channel == channel && sdev->id == id &&
1313 				sdev->lun ==lun)
1314 			return sdev;
1315 	}
1316 
1317 	return NULL;
1318 }
1319 EXPORT_SYMBOL(__scsi_device_lookup);
1320 
1321 /**
1322  * scsi_device_lookup - find a device given the host
1323  * @shost:	SCSI host pointer
1324  * @channel:	SCSI channel (zero if only one channel)
1325  * @id:		SCSI target number (physical unit number)
1326  * @lun:	SCSI Logical Unit Number
1327  *
1328  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1329  * for a given host.  The returned scsi_device has an additional reference that
1330  * needs to be released with scsi_device_put once you're done with it.
1331  **/
1332 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1333 		uint channel, uint id, uint lun)
1334 {
1335 	struct scsi_device *sdev;
1336 	unsigned long flags;
1337 
1338 	spin_lock_irqsave(shost->host_lock, flags);
1339 	sdev = __scsi_device_lookup(shost, channel, id, lun);
1340 	if (sdev && scsi_device_get(sdev))
1341 		sdev = NULL;
1342 	spin_unlock_irqrestore(shost->host_lock, flags);
1343 
1344 	return sdev;
1345 }
1346 EXPORT_SYMBOL(scsi_device_lookup);
1347 
1348 MODULE_DESCRIPTION("SCSI core");
1349 MODULE_LICENSE("GPL");
1350 
1351 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1352 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1353 
1354 static int __init init_scsi(void)
1355 {
1356 	int error;
1357 
1358 	error = scsi_init_queue();
1359 	if (error)
1360 		return error;
1361 	error = scsi_init_procfs();
1362 	if (error)
1363 		goto cleanup_queue;
1364 	error = scsi_init_devinfo();
1365 	if (error)
1366 		goto cleanup_procfs;
1367 	error = scsi_init_hosts();
1368 	if (error)
1369 		goto cleanup_devlist;
1370 	error = scsi_init_sysctl();
1371 	if (error)
1372 		goto cleanup_hosts;
1373 	error = scsi_sysfs_register();
1374 	if (error)
1375 		goto cleanup_sysctl;
1376 
1377 	scsi_netlink_init();
1378 
1379 	printk(KERN_NOTICE "SCSI subsystem initialized\n");
1380 	return 0;
1381 
1382 cleanup_sysctl:
1383 	scsi_exit_sysctl();
1384 cleanup_hosts:
1385 	scsi_exit_hosts();
1386 cleanup_devlist:
1387 	scsi_exit_devinfo();
1388 cleanup_procfs:
1389 	scsi_exit_procfs();
1390 cleanup_queue:
1391 	scsi_exit_queue();
1392 	printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1393 	       -error);
1394 	return error;
1395 }
1396 
1397 static void __exit exit_scsi(void)
1398 {
1399 	scsi_netlink_exit();
1400 	scsi_sysfs_unregister();
1401 	scsi_exit_sysctl();
1402 	scsi_exit_hosts();
1403 	scsi_exit_devinfo();
1404 	scsi_exit_procfs();
1405 	scsi_exit_queue();
1406 	async_unregister_domain(&scsi_sd_probe_domain);
1407 }
1408 
1409 subsys_initcall(init_scsi);
1410 module_exit(exit_scsi);
1411