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
  58#include <scsi/scsi.h>
  59#include <scsi/scsi_cmnd.h>
  60#include <scsi/scsi_dbg.h>
  61#include <scsi/scsi_device.h>
  62#include <scsi/scsi_driver.h>
  63#include <scsi/scsi_eh.h>
  64#include <scsi/scsi_host.h>
  65#include <scsi/scsi_tcq.h>
  66
  67#include "scsi_priv.h"
  68#include "scsi_logging.h"
  69
  70#define CREATE_TRACE_POINTS
  71#include <trace/events/scsi.h>
  72
  73static void scsi_done(struct scsi_cmnd *cmd);
  74
  75/*
  76 * Definitions and constants.
  77 */
  78
  79#define MIN_RESET_DELAY (2*HZ)
  80
  81/* Do not call reset on error if we just did a reset within 15 sec. */
  82#define MIN_RESET_PERIOD (15*HZ)
  83
  84/*
  85 * Note - the initial logging level can be set here to log events at boot time.
  86 * After the system is up, you may enable logging via the /proc interface.
  87 */
  88unsigned int scsi_logging_level;
  89#if defined(CONFIG_SCSI_LOGGING)
  90EXPORT_SYMBOL(scsi_logging_level);
  91#endif
  92
  93/* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
  94 * You may not alter any existing entry (although adding new ones is
  95 * encouraged once assigned by ANSI/INCITS T10
  96 */
  97static const char *const scsi_device_types[] = {
  98	"Direct-Access    ",
  99	"Sequential-Access",
 100	"Printer          ",
 101	"Processor        ",
 102	"WORM             ",
 103	"CD-ROM           ",
 104	"Scanner          ",
 105	"Optical Device   ",
 106	"Medium Changer   ",
 107	"Communications   ",
 108	"ASC IT8          ",
 109	"ASC IT8          ",
 110	"RAID             ",
 111	"Enclosure        ",
 112	"Direct-Access-RBC",
 113	"Optical card     ",
 114	"Bridge controller",
 115	"Object storage   ",
 116	"Automation/Drive ",
 117};
 118
 119/**
 120 * scsi_device_type - Return 17 char string indicating device type.
 121 * @type: type number to look up
 122 */
 123
 124const char * scsi_device_type(unsigned type)
 125{
 126	if (type == 0x1e)
 127		return "Well-known LUN   ";
 128	if (type == 0x1f)
 129		return "No Device        ";
 130	if (type >= ARRAY_SIZE(scsi_device_types))
 131		return "Unknown          ";
 132	return scsi_device_types[type];
 133}
 134
 135EXPORT_SYMBOL(scsi_device_type);
 136
 137struct scsi_host_cmd_pool {
 138	struct kmem_cache	*cmd_slab;
 139	struct kmem_cache	*sense_slab;
 140	unsigned int		users;
 141	char			*cmd_name;
 142	char			*sense_name;
 143	unsigned int		slab_flags;
 144	gfp_t			gfp_mask;
 145};
 146
 147static struct scsi_host_cmd_pool scsi_cmd_pool = {
 148	.cmd_name	= "scsi_cmd_cache",
 149	.sense_name	= "scsi_sense_cache",
 150	.slab_flags	= SLAB_HWCACHE_ALIGN,
 151};
 152
 153static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 154	.cmd_name	= "scsi_cmd_cache(DMA)",
 155	.sense_name	= "scsi_sense_cache(DMA)",
 156	.slab_flags	= SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
 157	.gfp_mask	= __GFP_DMA,
 158};
 159
 160static DEFINE_MUTEX(host_cmd_pool_mutex);
 161
 162/**
 163 * scsi_pool_alloc_command - internal function to get a fully allocated command
 164 * @pool:	slab pool to allocate the command from
 165 * @gfp_mask:	mask for the allocation
 166 *
 167 * Returns a fully allocated command (with the allied sense buffer) or
 168 * NULL on failure
 169 */
 170static struct scsi_cmnd *
 171scsi_pool_alloc_command(struct scsi_host_cmd_pool *pool, gfp_t gfp_mask)
 172{
 173	struct scsi_cmnd *cmd;
 174
 175	cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
 176	if (!cmd)
 177		return NULL;
 178
 179	cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
 180					     gfp_mask | pool->gfp_mask);
 181	if (!cmd->sense_buffer) {
 182		kmem_cache_free(pool->cmd_slab, cmd);
 183		return NULL;
 184	}
 185
 186	return cmd;
 187}
 188
 189/**
 190 * scsi_pool_free_command - internal function to release a command
 191 * @pool:	slab pool to allocate the command from
 192 * @cmd:	command to release
 193 *
 194 * the command must previously have been allocated by
 195 * scsi_pool_alloc_command.
 196 */
 197static void
 198scsi_pool_free_command(struct scsi_host_cmd_pool *pool,
 199			 struct scsi_cmnd *cmd)
 200{
 201	if (cmd->prot_sdb)
 202		kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
 203
 204	kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 205	kmem_cache_free(pool->cmd_slab, cmd);
 206}
 207
 208/**
 209 * scsi_host_alloc_command - internal function to allocate command
 210 * @shost:	SCSI host whose pool to allocate from
 211 * @gfp_mask:	mask for the allocation
 212 *
 213 * Returns a fully allocated command with sense buffer and protection
 214 * data buffer (where applicable) or NULL on failure
 215 */
 216static struct scsi_cmnd *
 217scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 218{
 219	struct scsi_cmnd *cmd;
 220
 221	cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask);
 222	if (!cmd)
 223		return NULL;
 224
 225	if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
 226		cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
 227
 228		if (!cmd->prot_sdb) {
 229			scsi_pool_free_command(shost->cmd_pool, cmd);
 230			return NULL;
 231		}
 232	}
 233
 234	return cmd;
 235}
 236
 237/**
 238 * __scsi_get_command - Allocate a struct scsi_cmnd
 239 * @shost: host to transmit command
 240 * @gfp_mask: allocation mask
 241 *
 242 * Description: allocate a struct scsi_cmd from host's slab, recycling from the
 243 *              host's free_list if necessary.
 244 */
 245struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 246{
 247	struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
 248
 249	if (unlikely(!cmd)) {
 250		unsigned long flags;
 251
 252		spin_lock_irqsave(&shost->free_list_lock, flags);
 253		if (likely(!list_empty(&shost->free_list))) {
 254			cmd = list_entry(shost->free_list.next,
 255					 struct scsi_cmnd, list);
 256			list_del_init(&cmd->list);
 257		}
 258		spin_unlock_irqrestore(&shost->free_list_lock, flags);
 259
 260		if (cmd) {
 261			void *buf, *prot;
 262
 263			buf = cmd->sense_buffer;
 264			prot = cmd->prot_sdb;
 265
 266			memset(cmd, 0, sizeof(*cmd));
 267
 268			cmd->sense_buffer = buf;
 269			cmd->prot_sdb = prot;
 270		}
 271	}
 272
 273	return cmd;
 274}
 275EXPORT_SYMBOL_GPL(__scsi_get_command);
 276
 277/**
 278 * scsi_get_command - Allocate and setup a scsi command block
 279 * @dev: parent scsi device
 280 * @gfp_mask: allocator flags
 281 *
 282 * Returns:	The allocated scsi command structure.
 283 */
 284struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
 285{
 286	struct scsi_cmnd *cmd;
 287
 288	/* Bail if we can't get a reference to the device */
 289	if (!get_device(&dev->sdev_gendev))
 290		return NULL;
 291
 292	cmd = __scsi_get_command(dev->host, gfp_mask);
 293
 294	if (likely(cmd != NULL)) {
 295		unsigned long flags;
 296
 297		cmd->device = dev;
 298		INIT_LIST_HEAD(&cmd->list);
 299		spin_lock_irqsave(&dev->list_lock, flags);
 300		list_add_tail(&cmd->list, &dev->cmd_list);
 301		spin_unlock_irqrestore(&dev->list_lock, flags);
 302		cmd->jiffies_at_alloc = jiffies;
 303	} else
 304		put_device(&dev->sdev_gendev);
 305
 306	return cmd;
 307}
 308EXPORT_SYMBOL(scsi_get_command);
 309
 310/**
 311 * __scsi_put_command - Free a struct scsi_cmnd
 312 * @shost: dev->host
 313 * @cmd: Command to free
 314 * @dev: parent scsi device
 315 */
 316void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd,
 317			struct device *dev)
 318{
 319	unsigned long flags;
 320
 321	/* changing locks here, don't need to restore the irq state */
 322	spin_lock_irqsave(&shost->free_list_lock, flags);
 323	if (unlikely(list_empty(&shost->free_list))) {
 324		list_add(&cmd->list, &shost->free_list);
 325		cmd = NULL;
 326	}
 327	spin_unlock_irqrestore(&shost->free_list_lock, flags);
 328
 329	if (likely(cmd != NULL))
 330		scsi_pool_free_command(shost->cmd_pool, cmd);
 331
 332	put_device(dev);
 333}
 334EXPORT_SYMBOL(__scsi_put_command);
 335
 336/**
 337 * scsi_put_command - Free a scsi command block
 338 * @cmd: command block to free
 339 *
 340 * Returns:	Nothing.
 341 *
 342 * Notes:	The command must not belong to any lists.
 343 */
 344void scsi_put_command(struct scsi_cmnd *cmd)
 345{
 346	struct scsi_device *sdev = cmd->device;
 347	unsigned long flags;
 348
 349	/* serious error if the command hasn't come from a device list */
 350	spin_lock_irqsave(&cmd->device->list_lock, flags);
 351	BUG_ON(list_empty(&cmd->list));
 352	list_del_init(&cmd->list);
 353	spin_unlock_irqrestore(&cmd->device->list_lock, flags);
 354
 355	__scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
 356}
 357EXPORT_SYMBOL(scsi_put_command);
 358
 359static struct scsi_host_cmd_pool *scsi_get_host_cmd_pool(gfp_t gfp_mask)
 360{
 361	struct scsi_host_cmd_pool *retval = NULL, *pool;
 362	/*
 363	 * Select a command slab for this host and create it if not
 364	 * yet existent.
 365	 */
 366	mutex_lock(&host_cmd_pool_mutex);
 367	pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
 368		&scsi_cmd_pool;
 369	if (!pool->users) {
 370		pool->cmd_slab = kmem_cache_create(pool->cmd_name,
 371						   sizeof(struct scsi_cmnd), 0,
 372						   pool->slab_flags, NULL);
 373		if (!pool->cmd_slab)
 374			goto fail;
 375
 376		pool->sense_slab = kmem_cache_create(pool->sense_name,
 377						     SCSI_SENSE_BUFFERSIZE, 0,
 378						     pool->slab_flags, NULL);
 379		if (!pool->sense_slab) {
 380			kmem_cache_destroy(pool->cmd_slab);
 381			goto fail;
 382		}
 383	}
 384
 385	pool->users++;
 386	retval = pool;
 387 fail:
 388	mutex_unlock(&host_cmd_pool_mutex);
 389	return retval;
 390}
 391
 392static void scsi_put_host_cmd_pool(gfp_t gfp_mask)
 393{
 394	struct scsi_host_cmd_pool *pool;
 395
 396	mutex_lock(&host_cmd_pool_mutex);
 397	pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
 398		&scsi_cmd_pool;
 399	/*
 400	 * This may happen if a driver has a mismatched get and put
 401	 * of the command pool; the driver should be implicated in
 402	 * the stack trace
 403	 */
 404	BUG_ON(pool->users == 0);
 405
 406	if (!--pool->users) {
 407		kmem_cache_destroy(pool->cmd_slab);
 408		kmem_cache_destroy(pool->sense_slab);
 409	}
 410	mutex_unlock(&host_cmd_pool_mutex);
 411}
 412
 413/**
 414 * scsi_allocate_command - get a fully allocated SCSI command
 415 * @gfp_mask:	allocation mask
 416 *
 417 * This function is for use outside of the normal host based pools.
 418 * It allocates the relevant command and takes an additional reference
 419 * on the pool it used.  This function *must* be paired with
 420 * scsi_free_command which also has the identical mask, otherwise the
 421 * free pool counts will eventually go wrong and you'll trigger a bug.
 422 *
 423 * This function should *only* be used by drivers that need a static
 424 * command allocation at start of day for internal functions.
 425 */
 426struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask)
 427{
 428	struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
 429
 430	if (!pool)
 431		return NULL;
 432
 433	return scsi_pool_alloc_command(pool, gfp_mask);
 434}
 435EXPORT_SYMBOL(scsi_allocate_command);
 436
 437/**
 438 * scsi_free_command - free a command allocated by scsi_allocate_command
 439 * @gfp_mask:	mask used in the original allocation
 440 * @cmd:	command to free
 441 *
 442 * Note: using the original allocation mask is vital because that's
 443 * what determines which command pool we use to free the command.  Any
 444 * mismatch will cause the system to BUG eventually.
 445 */
 446void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd)
 447{
 448	struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
 449
 450	/*
 451	 * this could trigger if the mask to scsi_allocate_command
 452	 * doesn't match this mask.  Otherwise we're guaranteed that this
 453	 * succeeds because scsi_allocate_command must have taken a reference
 454	 * on the pool
 455	 */
 456	BUG_ON(!pool);
 457
 458	scsi_pool_free_command(pool, cmd);
 459	/*
 460	 * scsi_put_host_cmd_pool is called twice; once to release the
 461	 * reference we took above, and once to release the reference
 462	 * originally taken by scsi_allocate_command
 463	 */
 464	scsi_put_host_cmd_pool(gfp_mask);
 465	scsi_put_host_cmd_pool(gfp_mask);
 466}
 467EXPORT_SYMBOL(scsi_free_command);
 468
 469/**
 470 * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
 471 * @shost: host to allocate the freelist for.
 472 *
 473 * Description: The command freelist protects against system-wide out of memory
 474 * deadlock by preallocating one SCSI command structure for each host, so the
 475 * system can always write to a swap file on a device associated with that host.
 476 *
 477 * Returns:	Nothing.
 478 */
 479int scsi_setup_command_freelist(struct Scsi_Host *shost)
 480{
 481	struct scsi_cmnd *cmd;
 482	const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
 483
 484	spin_lock_init(&shost->free_list_lock);
 485	INIT_LIST_HEAD(&shost->free_list);
 486
 487	shost->cmd_pool = scsi_get_host_cmd_pool(gfp_mask);
 488
 489	if (!shost->cmd_pool)
 490		return -ENOMEM;
 491
 492	/*
 493	 * Get one backup command for this host.
 494	 */
 495	cmd = scsi_host_alloc_command(shost, gfp_mask);
 496	if (!cmd) {
 497		scsi_put_host_cmd_pool(gfp_mask);
 498		shost->cmd_pool = NULL;
 499		return -ENOMEM;
 500	}
 501	list_add(&cmd->list, &shost->free_list);
 502	return 0;
 503}
 504
 505/**
 506 * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
 507 * @shost: host whose freelist is going to be destroyed
 508 */
 509void scsi_destroy_command_freelist(struct Scsi_Host *shost)
 510{
 511	/*
 512	 * If cmd_pool is NULL the free list was not initialized, so
 513	 * do not attempt to release resources.
 514	 */
 515	if (!shost->cmd_pool)
 516		return;
 517
 518	while (!list_empty(&shost->free_list)) {
 519		struct scsi_cmnd *cmd;
 520
 521		cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
 522		list_del_init(&cmd->list);
 523		scsi_pool_free_command(shost->cmd_pool, cmd);
 524	}
 525	shost->cmd_pool = NULL;
 526	scsi_put_host_cmd_pool(shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL);
 527}
 528
 529#ifdef CONFIG_SCSI_LOGGING
 530void scsi_log_send(struct scsi_cmnd *cmd)
 531{
 532	unsigned int level;
 533
 534	/*
 535	 * If ML QUEUE log level is greater than or equal to:
 536	 *
 537	 * 1: nothing (match completion)
 538	 *
 539	 * 2: log opcode + command of all commands
 540	 *
 541	 * 3: same as 2 plus dump cmd address
 542	 *
 543	 * 4: same as 3 plus dump extra junk
 544	 */
 545	if (unlikely(scsi_logging_level)) {
 546		level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 547				       SCSI_LOG_MLQUEUE_BITS);
 548		if (level > 1) {
 549			scmd_printk(KERN_INFO, cmd, "Send: ");
 550			if (level > 2)
 551				printk("0x%p ", cmd);
 552			printk("\n");
 553			scsi_print_command(cmd);
 554			if (level > 3) {
 555				printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 556				       " queuecommand 0x%p\n",
 557					scsi_sglist(cmd), scsi_bufflen(cmd),
 558					cmd->device->host->hostt->queuecommand);
 559
 560			}
 561		}
 562	}
 563}
 564
 565void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 566{
 567	unsigned int level;
 568
 569	/*
 570	 * If ML COMPLETE log level is greater than or equal to:
 571	 *
 572	 * 1: log disposition, result, opcode + command, and conditionally
 573	 * sense data for failures or non SUCCESS dispositions.
 574	 *
 575	 * 2: same as 1 but for all command completions.
 576	 *
 577	 * 3: same as 2 plus dump cmd address
 578	 *
 579	 * 4: same as 3 plus dump extra junk
 580	 */
 581	if (unlikely(scsi_logging_level)) {
 582		level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 583				       SCSI_LOG_MLCOMPLETE_BITS);
 584		if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 585		    (level > 1)) {
 586			scmd_printk(KERN_INFO, cmd, "Done: ");
 587			if (level > 2)
 588				printk("0x%p ", cmd);
 589			/*
 590			 * Dump truncated values, so we usually fit within
 591			 * 80 chars.
 592			 */
 593			switch (disposition) {
 594			case SUCCESS:
 595				printk("SUCCESS\n");
 596				break;
 597			case NEEDS_RETRY:
 598				printk("RETRY\n");
 599				break;
 600			case ADD_TO_MLQUEUE:
 601				printk("MLQUEUE\n");
 602				break;
 603			case FAILED:
 604				printk("FAILED\n");
 605				break;
 606			case TIMEOUT_ERROR:
 607				/* 
 608				 * If called via scsi_times_out.
 609				 */
 610				printk("TIMEOUT\n");
 611				break;
 612			default:
 613				printk("UNKNOWN\n");
 614			}
 615			scsi_print_result(cmd);
 616			scsi_print_command(cmd);
 617			if (status_byte(cmd->result) & CHECK_CONDITION)
 618				scsi_print_sense("", cmd);
 619			if (level > 3)
 620				scmd_printk(KERN_INFO, cmd,
 621					    "scsi host busy %d failed %d\n",
 622					    cmd->device->host->host_busy,
 623					    cmd->device->host->host_failed);
 624		}
 625	}
 626}
 627#endif
 628
 629/**
 630 * scsi_cmd_get_serial - Assign a serial number to a command
 631 * @host: the scsi host
 632 * @cmd: command to assign serial number to
 633 *
 634 * Description: a serial number identifies a request for error recovery
 635 * and debugging purposes.  Protected by the Host_Lock of host.
 636 */
 637void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 638{
 639	cmd->serial_number = host->cmd_serial_number++;
 640	if (cmd->serial_number == 0) 
 641		cmd->serial_number = host->cmd_serial_number++;
 642}
 643EXPORT_SYMBOL(scsi_cmd_get_serial);
 644
 645/**
 646 * scsi_dispatch_command - Dispatch a command to the low-level driver.
 647 * @cmd: command block we are dispatching.
 648 *
 649 * Return: nonzero return request was rejected and device's queue needs to be
 650 * plugged.
 651 */
 652int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 653{
 654	struct Scsi_Host *host = cmd->device->host;
 655	unsigned long timeout;
 656	int rtn = 0;
 657
 658	atomic_inc(&cmd->device->iorequest_cnt);
 659
 660	/* check if the device is still usable */
 661	if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 662		/* in SDEV_DEL we error all commands. DID_NO_CONNECT
 663		 * returns an immediate error upwards, and signals
 664		 * that the device is no longer present */
 665		cmd->result = DID_NO_CONNECT << 16;
 666		scsi_done(cmd);
 667		/* return 0 (because the command has been processed) */
 668		goto out;
 669	}
 670
 671	/* Check to see if the scsi lld made this device blocked. */
 672	if (unlikely(scsi_device_blocked(cmd->device))) {
 673		/* 
 674		 * in blocked state, the command is just put back on
 675		 * the device queue.  The suspend state has already
 676		 * blocked the queue so future requests should not
 677		 * occur until the device transitions out of the
 678		 * suspend state.
 679		 */
 680
 681		scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
 682
 683		SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
 684
 685		/*
 686		 * NOTE: rtn is still zero here because we don't need the
 687		 * queue to be plugged on return (it's already stopped)
 688		 */
 689		goto out;
 690	}
 691
 692	/* 
 693	 * If SCSI-2 or lower, store the LUN value in cmnd.
 694	 */
 695	if (cmd->device->scsi_level <= SCSI_2 &&
 696	    cmd->device->scsi_level != SCSI_UNKNOWN) {
 697		cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 698			       (cmd->device->lun << 5 & 0xe0);
 699	}
 700
 701	/*
 702	 * We will wait MIN_RESET_DELAY clock ticks after the last reset so
 703	 * we can avoid the drive not being ready.
 704	 */
 705	timeout = host->last_reset + MIN_RESET_DELAY;
 706
 707	if (host->resetting && time_before(jiffies, timeout)) {
 708		int ticks_remaining = timeout - jiffies;
 709		/*
 710		 * NOTE: This may be executed from within an interrupt
 711		 * handler!  This is bad, but for now, it'll do.  The irq
 712		 * level of the interrupt handler has been masked out by the
 713		 * platform dependent interrupt handling code already, so the
 714		 * sti() here will not cause another call to the SCSI host's
 715		 * interrupt handler (assuming there is one irq-level per
 716		 * host).
 717		 */
 718		while (--ticks_remaining >= 0)
 719			mdelay(1 + 999 / HZ);
 720		host->resetting = 0;
 721	}
 722
 723	scsi_log_send(cmd);
 724
 725	/*
 726	 * Before we queue this command, check if the command
 727	 * length exceeds what the host adapter can handle.
 728	 */
 729	if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 730		SCSI_LOG_MLQUEUE(3,
 731			printk("queuecommand : command too long. "
 732			       "cdb_size=%d host->max_cmd_len=%d\n",
 733			       cmd->cmd_len, cmd->device->host->max_cmd_len));
 734		cmd->result = (DID_ABORT << 16);
 735
 736		scsi_done(cmd);
 737		goto out;
 738	}
 739
 740	if (unlikely(host->shost_state == SHOST_DEL)) {
 741		cmd->result = (DID_NO_CONNECT << 16);
 742		scsi_done(cmd);
 743	} else {
 744		trace_scsi_dispatch_cmd_start(cmd);
 745		cmd->scsi_done = scsi_done;
 746		rtn = host->hostt->queuecommand(host, cmd);
 747	}
 748
 749	if (rtn) {
 750		trace_scsi_dispatch_cmd_error(cmd, rtn);
 751		if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
 752		    rtn != SCSI_MLQUEUE_TARGET_BUSY)
 753			rtn = SCSI_MLQUEUE_HOST_BUSY;
 754
 755		scsi_queue_insert(cmd, rtn);
 756
 757		SCSI_LOG_MLQUEUE(3,
 758		    printk("queuecommand : request rejected\n"));
 759	}
 760
 761 out:
 762	SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
 763	return rtn;
 764}
 765
 766/**
 767 * scsi_done - Enqueue the finished SCSI command into the done queue.
 768 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
 769 * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
 770 *
 771 * Description: This function is the mid-level's (SCSI Core) interrupt routine,
 772 * which regains ownership of the SCSI command (de facto) from a LLDD, and
 773 * enqueues the command to the done queue for further processing.
 774 *
 775 * This is the producer of the done queue who enqueues at the tail.
 776 *
 777 * This function is interrupt context safe.
 778 */
 779static void scsi_done(struct scsi_cmnd *cmd)
 780{
 781	trace_scsi_dispatch_cmd_done(cmd);
 782	blk_complete_request(cmd->request);
 783}
 784
 785/* Move this to a header if it becomes more generally useful */
 786static struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
 787{
 788	return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
 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 */
 799void 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}
 849EXPORT_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 */
 869void 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}
 918EXPORT_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 */
 939int 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}
 972EXPORT_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 */
 986static 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 */
1029int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
1030		      int buf_len)
1031{
1032	int i, result;
1033
1034	/* Ask for all the pages supported by this device */
1035	result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
1036	if (result)
1037		goto fail;
1038
1039	/* If the user actually wanted this page, we can skip the rest */
1040	if (page == 0)
1041		return 0;
1042
1043	for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
1044		if (buf[i + 4] == page)
1045			goto found;
1046
1047	if (i < buf[3] && i >= buf_len - 4)
1048		/* ran off the end of the buffer, give us benefit of doubt */
1049		goto found;
1050	/* The device claims it doesn't support the requested page */
1051	goto fail;
1052
1053 found:
1054	result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
1055	if (result)
1056		goto fail;
1057
1058	return 0;
1059
1060 fail:
1061	return -EINVAL;
1062}
1063EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
1064
1065/**
1066 * scsi_device_get  -  get an additional reference to a scsi_device
1067 * @sdev:	device to get a reference to
1068 *
1069 * Description: Gets a reference to the scsi_device and increments the use count
1070 * of the underlying LLDD module.  You must hold host_lock of the
1071 * parent Scsi_Host or already have a reference when calling this.
1072 */
1073int scsi_device_get(struct scsi_device *sdev)
1074{
1075	if (sdev->sdev_state == SDEV_DEL)
1076		return -ENXIO;
1077	if (!get_device(&sdev->sdev_gendev))
1078		return -ENXIO;
1079	/* We can fail this if we're doing SCSI operations
1080	 * from module exit (like cache flush) */
1081	try_module_get(sdev->host->hostt->module);
1082
1083	return 0;
1084}
1085EXPORT_SYMBOL(scsi_device_get);
1086
1087/**
1088 * scsi_device_put  -  release a reference to a scsi_device
1089 * @sdev:	device to release a reference on.
1090 *
1091 * Description: Release a reference to the scsi_device and decrements the use
1092 * count of the underlying LLDD module.  The device is freed once the last
1093 * user vanishes.
1094 */
1095void scsi_device_put(struct scsi_device *sdev)
1096{
1097#ifdef CONFIG_MODULE_UNLOAD
1098	struct module *module = sdev->host->hostt->module;
1099
1100	/* The module refcount will be zero if scsi_device_get()
1101	 * was called from a module removal routine */
1102	if (module && module_refcount(module) != 0)
1103		module_put(module);
1104#endif
1105	put_device(&sdev->sdev_gendev);
1106}
1107EXPORT_SYMBOL(scsi_device_put);
1108
1109/* helper for shost_for_each_device, see that for documentation */
1110struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1111					   struct scsi_device *prev)
1112{
1113	struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1114	struct scsi_device *next = NULL;
1115	unsigned long flags;
1116
1117	spin_lock_irqsave(shost->host_lock, flags);
1118	while (list->next != &shost->__devices) {
1119		next = list_entry(list->next, struct scsi_device, siblings);
1120		/* skip devices that we can't get a reference to */
1121		if (!scsi_device_get(next))
1122			break;
1123		next = NULL;
1124		list = list->next;
1125	}
1126	spin_unlock_irqrestore(shost->host_lock, flags);
1127
1128	if (prev)
1129		scsi_device_put(prev);
1130	return next;
1131}
1132EXPORT_SYMBOL(__scsi_iterate_devices);
1133
1134/**
1135 * starget_for_each_device  -  helper to walk all devices of a target
1136 * @starget:	target whose devices we want to iterate over.
1137 * @data:	Opaque passed to each function call.
1138 * @fn:		Function to call on each device
1139 *
1140 * This traverses over each device of @starget.  The devices have
1141 * a reference that must be released by scsi_host_put when breaking
1142 * out of the loop.
1143 */
1144void starget_for_each_device(struct scsi_target *starget, void *data,
1145		     void (*fn)(struct scsi_device *, void *))
1146{
1147	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1148	struct scsi_device *sdev;
1149
1150	shost_for_each_device(sdev, shost) {
1151		if ((sdev->channel == starget->channel) &&
1152		    (sdev->id == starget->id))
1153			fn(sdev, data);
1154	}
1155}
1156EXPORT_SYMBOL(starget_for_each_device);
1157
1158/**
1159 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1160 * @starget:	target whose devices we want to iterate over.
1161 * @data:	parameter for callback @fn()
1162 * @fn:		callback function that is invoked for each device
1163 *
1164 * This traverses over each device of @starget.  It does _not_
1165 * take a reference on the scsi_device, so the whole loop must be
1166 * protected by shost->host_lock.
1167 *
1168 * Note:  The only reason why drivers would want to use this is because
1169 * they need to access the device list in irq context.  Otherwise you
1170 * really want to use starget_for_each_device instead.
1171 **/
1172void __starget_for_each_device(struct scsi_target *starget, void *data,
1173			       void (*fn)(struct scsi_device *, void *))
1174{
1175	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1176	struct scsi_device *sdev;
1177
1178	__shost_for_each_device(sdev, shost) {
1179		if ((sdev->channel == starget->channel) &&
1180		    (sdev->id == starget->id))
1181			fn(sdev, data);
1182	}
1183}
1184EXPORT_SYMBOL(__starget_for_each_device);
1185
1186/**
1187 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1188 * @starget:	SCSI target pointer
1189 * @lun:	SCSI Logical Unit Number
1190 *
1191 * Description: Looks up the scsi_device with the specified @lun for a given
1192 * @starget.  The returned scsi_device does not have an additional
1193 * reference.  You must hold the host's host_lock over this call and
1194 * any access to the returned scsi_device. A scsi_device in state
1195 * SDEV_DEL is skipped.
1196 *
1197 * Note:  The only reason why drivers should use this is because
1198 * they need to access the device list in irq context.  Otherwise you
1199 * really want to use scsi_device_lookup_by_target instead.
1200 **/
1201struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1202						   uint lun)
1203{
1204	struct scsi_device *sdev;
1205
1206	list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1207		if (sdev->sdev_state == SDEV_DEL)
1208			continue;
1209		if (sdev->lun ==lun)
1210			return sdev;
1211	}
1212
1213	return NULL;
1214}
1215EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1216
1217/**
1218 * scsi_device_lookup_by_target - find a device given the target
1219 * @starget:	SCSI target pointer
1220 * @lun:	SCSI Logical Unit Number
1221 *
1222 * Description: Looks up the scsi_device with the specified @lun for a given
1223 * @starget.  The returned scsi_device has an additional reference that
1224 * needs to be released with scsi_device_put once you're done with it.
1225 **/
1226struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1227						 uint lun)
1228{
1229	struct scsi_device *sdev;
1230	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1231	unsigned long flags;
1232
1233	spin_lock_irqsave(shost->host_lock, flags);
1234	sdev = __scsi_device_lookup_by_target(starget, lun);
1235	if (sdev && scsi_device_get(sdev))
1236		sdev = NULL;
1237	spin_unlock_irqrestore(shost->host_lock, flags);
1238
1239	return sdev;
1240}
1241EXPORT_SYMBOL(scsi_device_lookup_by_target);
1242
1243/**
1244 * __scsi_device_lookup - find a device given the host (UNLOCKED)
1245 * @shost:	SCSI host pointer
1246 * @channel:	SCSI channel (zero if only one channel)
1247 * @id:		SCSI target number (physical unit number)
1248 * @lun:	SCSI Logical Unit Number
1249 *
1250 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1251 * for a given host. The returned scsi_device does not have an additional
1252 * reference.  You must hold the host's host_lock over this call and any access
1253 * to the returned scsi_device.
1254 *
1255 * Note:  The only reason why drivers would want to use this is because
1256 * they need to access the device list in irq context.  Otherwise you
1257 * really want to use scsi_device_lookup instead.
1258 **/
1259struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1260		uint channel, uint id, uint lun)
1261{
1262	struct scsi_device *sdev;
1263
1264	list_for_each_entry(sdev, &shost->__devices, siblings) {
1265		if (sdev->channel == channel && sdev->id == id &&
1266				sdev->lun ==lun)
1267			return sdev;
1268	}
1269
1270	return NULL;
1271}
1272EXPORT_SYMBOL(__scsi_device_lookup);
1273
1274/**
1275 * scsi_device_lookup - find a device given the host
1276 * @shost:	SCSI host pointer
1277 * @channel:	SCSI channel (zero if only one channel)
1278 * @id:		SCSI target number (physical unit number)
1279 * @lun:	SCSI Logical Unit Number
1280 *
1281 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1282 * for a given host.  The returned scsi_device has an additional reference that
1283 * needs to be released with scsi_device_put once you're done with it.
1284 **/
1285struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1286		uint channel, uint id, uint lun)
1287{
1288	struct scsi_device *sdev;
1289	unsigned long flags;
1290
1291	spin_lock_irqsave(shost->host_lock, flags);
1292	sdev = __scsi_device_lookup(shost, channel, id, lun);
1293	if (sdev && scsi_device_get(sdev))
1294		sdev = NULL;
1295	spin_unlock_irqrestore(shost->host_lock, flags);
1296
1297	return sdev;
1298}
1299EXPORT_SYMBOL(scsi_device_lookup);
1300
1301MODULE_DESCRIPTION("SCSI core");
1302MODULE_LICENSE("GPL");
1303
1304module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1305MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1306
1307static int __init init_scsi(void)
1308{
1309	int error;
1310
1311	error = scsi_init_queue();
1312	if (error)
1313		return error;
1314	error = scsi_init_procfs();
1315	if (error)
1316		goto cleanup_queue;
1317	error = scsi_init_devinfo();
1318	if (error)
1319		goto cleanup_procfs;
1320	error = scsi_init_hosts();
1321	if (error)
1322		goto cleanup_devlist;
1323	error = scsi_init_sysctl();
1324	if (error)
1325		goto cleanup_hosts;
1326	error = scsi_sysfs_register();
1327	if (error)
1328		goto cleanup_sysctl;
1329
1330	scsi_netlink_init();
1331
1332	printk(KERN_NOTICE "SCSI subsystem initialized\n");
1333	return 0;
1334
1335cleanup_sysctl:
1336	scsi_exit_sysctl();
1337cleanup_hosts:
1338	scsi_exit_hosts();
1339cleanup_devlist:
1340	scsi_exit_devinfo();
1341cleanup_procfs:
1342	scsi_exit_procfs();
1343cleanup_queue:
1344	scsi_exit_queue();
1345	printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1346	       -error);
1347	return error;
1348}
1349
1350static void __exit exit_scsi(void)
1351{
1352	scsi_netlink_exit();
1353	scsi_sysfs_unregister();
1354	scsi_exit_sysctl();
1355	scsi_exit_hosts();
1356	scsi_exit_devinfo();
1357	scsi_exit_procfs();
1358	scsi_exit_queue();
1359}
1360
1361subsys_initcall(init_scsi);
1362module_exit(exit_scsi);