Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit cd9070c9c512ff7995f9019392e0ae548df3a088

Authored by Christoph Hellwig 2014-01-23 19:07:41 +0800

Exists in ti-lsk-linux-4.1.y and in 10 other branches

scsi: fix the {host,target,device}_blocked counter mess

Seems like these counters are missing any sort of synchronization for
updates, as a over 10 year old comment from me noted.  Fix this by
using atomic counters, and while we're at it also make sure they are
in the same cacheline as the _busy counters and not needlessly stored
to in every I/O completion.

With the new model the _busy counters can temporarily go negative,
so all the readers are updated to check for > 0 values.  Longer
term every successful I/O completion will reset the counters to zero,
so the temporarily negative values will not cause any harm.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Reviewed-by: Webb Scales <webbnh@hp.com>
Acked-by: Jens Axboe <axboe@kernel.dk>
Tested-by: Bart Van Assche <bvanassche@acm.org>
Tested-by: Robert Elliott <elliott@hp.com>

Showing 5 changed files with 58 additions and 53 deletions Inline Diff

drivers/scsi/scsi.c
drivers/scsi/scsi_lib.c
drivers/scsi/scsi_sysfs.c
include/scsi/scsi_device.h
include/scsi/scsi_host.h

drivers/scsi/scsi.c

Diff comments View file @ cd9070c

 /*
  *  scsi.c Copyright (C) 1992 Drew Eckhardt
  *         Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
  *         Copyright (C) 2002, 2003 Christoph Hellwig
  *
  *  generic mid-level SCSI driver
  *      Initial versions: Drew Eckhardt
  *      Subsequent revisions: Eric Youngdale
  *
  *  <drew@colorado.edu>
  *
  *  Bug correction thanks go to :
  *      Rik Faith <faith@cs.unc.edu>
  *      Tommy Thorn <tthorn>
  *      Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
  *
  *  Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
  *  add scatter-gather, multiple outstanding request, and other
  *  enhancements.
  *
  *  Native multichannel, wide scsi, /proc/scsi and hot plugging
  *  support added by Michael Neuffer <mike@i-connect.net>
  *
  *  Added request_module("scsi_hostadapter") for kerneld:
  *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
  *  Bjorn Ekwall  <bj0rn@blox.se>
  *  (changed to kmod)
  *
  *  Major improvements to the timeout, abort, and reset processing,
  *  as well as performance modifications for large queue depths by
  *  Leonard N. Zubkoff <lnz@dandelion.com>
  *
  *  Converted cli() code to spinlocks, Ingo Molnar
  *
  *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
  *
  *  out_of_space hacks, D. Gilbert (dpg) 990608
  */
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/kernel.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/completion.h>
 #include <linux/unistd.h>
 #include <linux/spinlock.h>
 #include <linux/kmod.h>
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/mutex.h>
 #include <linux/async.h>
 #include <asm/unaligned.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_driver.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_tcq.h>
 #include "scsi_priv.h"
 #include "scsi_logging.h"
 #define CREATE_TRACE_POINTS
 #include <trace/events/scsi.h>
 /*
  * Definitions and constants.
  */
 /*
  * Note - the initial logging level can be set here to log events at boot time.
  * After the system is up, you may enable logging via the /proc interface.
  */
 unsigned int scsi_logging_level;
 #if defined(CONFIG_SCSI_LOGGING)
 EXPORT_SYMBOL(scsi_logging_level);
 #endif
 /* sd, scsi core and power management need to coordinate flushing async actions */
 ASYNC_DOMAIN(scsi_sd_probe_domain);
 EXPORT_SYMBOL(scsi_sd_probe_domain);
 /*
  * Separate domain (from scsi_sd_probe_domain) to maximize the benefit of
  * asynchronous system resume operations.  It is marked 'exclusive' to avoid
  * being included in the async_synchronize_full() that is invoked by
  * dpm_resume()
  */
 ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain);
 EXPORT_SYMBOL(scsi_sd_pm_domain);
 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
  * You may not alter any existing entry (although adding new ones is
  * encouraged once assigned by ANSI/INCITS T10
  */
 static const char *const scsi_device_types[] = {
 	"Direct-Access    ",
 	"Sequential-Access",
 	"Printer          ",
 	"Processor        ",
 	"WORM             ",
 	"CD-ROM           ",
 	"Scanner          ",
 	"Optical Device   ",
 	"Medium Changer   ",
 	"Communications   ",
 	"ASC IT8          ",
 	"ASC IT8          ",
 	"RAID             ",
 	"Enclosure        ",
 	"Direct-Access-RBC",
 	"Optical card     ",
 	"Bridge controller",
 	"Object storage   ",
 	"Automation/Drive ",
 };
 /**
  * scsi_device_type - Return 17 char string indicating device type.
  * @type: type number to look up
  */
 const char * scsi_device_type(unsigned type)
 {
 	if (type == 0x1e)
 		return "Well-known LUN   ";
 	if (type == 0x1f)
 		return "No Device        ";
 	if (type >= ARRAY_SIZE(scsi_device_types))
 		return "Unknown          ";
 	return scsi_device_types[type];
 }
 EXPORT_SYMBOL(scsi_device_type);
 struct scsi_host_cmd_pool {
 	struct kmem_cache	*cmd_slab;
 	struct kmem_cache	*sense_slab;
 	unsigned int		users;
 	char			*cmd_name;
 	char			*sense_name;
 	unsigned int		slab_flags;
 	gfp_t			gfp_mask;
 };
 static struct scsi_host_cmd_pool scsi_cmd_pool = {
 	.cmd_name	= "scsi_cmd_cache",
 	.sense_name	= "scsi_sense_cache",
 	.slab_flags	= SLAB_HWCACHE_ALIGN,
 };
 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 	.cmd_name	= "scsi_cmd_cache(DMA)",
 	.sense_name	= "scsi_sense_cache(DMA)",
 	.slab_flags	= SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
 	.gfp_mask	= __GFP_DMA,
 };
 static DEFINE_MUTEX(host_cmd_pool_mutex);
 /**
  * scsi_host_free_command - internal function to release a command
  * @shost:	host to free the command for
  * @cmd:	command to release
  *
  * the command must previously have been allocated by
  * scsi_host_alloc_command.
  */
 static void
 scsi_host_free_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
 {
 	struct scsi_host_cmd_pool *pool = shost->cmd_pool;
 	if (cmd->prot_sdb)
 		kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
 	kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 	kmem_cache_free(pool->cmd_slab, cmd);
 }
 /**
  * scsi_host_alloc_command - internal function to allocate command
  * @shost:	SCSI host whose pool to allocate from
  * @gfp_mask:	mask for the allocation
  *
  * Returns a fully allocated command with sense buffer and protection
  * data buffer (where applicable) or NULL on failure
  */
 static struct scsi_cmnd *
 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 {
 	struct scsi_host_cmd_pool *pool = shost->cmd_pool;
 	struct scsi_cmnd *cmd;
 	cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
 	if (!cmd)
 		goto fail;
 	cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
 					     gfp_mask | pool->gfp_mask);
 	if (!cmd->sense_buffer)
 		goto fail_free_cmd;
 	if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
 		cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
 		if (!cmd->prot_sdb)
 			goto fail_free_sense;
 	}
 	return cmd;
 fail_free_sense:
 	kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 fail_free_cmd:
 	kmem_cache_free(pool->cmd_slab, cmd);
 fail:
 	return NULL;
 }
 /**
  * __scsi_get_command - Allocate a struct scsi_cmnd
  * @shost: host to transmit command
  * @gfp_mask: allocation mask
  *
  * Description: allocate a struct scsi_cmd from host's slab, recycling from the
  *              host's free_list if necessary.
  */
 static struct scsi_cmnd *
 __scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 {
 	struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
 	if (unlikely(!cmd)) {
 		unsigned long flags;
 		spin_lock_irqsave(&shost->free_list_lock, flags);
 		if (likely(!list_empty(&shost->free_list))) {
 			cmd = list_entry(shost->free_list.next,
 					 struct scsi_cmnd, list);
 			list_del_init(&cmd->list);
 		}
 		spin_unlock_irqrestore(&shost->free_list_lock, flags);
 		if (cmd) {
 			void *buf, *prot;
 			buf = cmd->sense_buffer;
 			prot = cmd->prot_sdb;
 			memset(cmd, 0, sizeof(*cmd));
 			cmd->sense_buffer = buf;
 			cmd->prot_sdb = prot;
 		}
 	}
 	return cmd;
 }
 /**
  * scsi_get_command - Allocate and setup a scsi command block
  * @dev: parent scsi device
  * @gfp_mask: allocator flags
  *
  * Returns:	The allocated scsi command structure.
  */
 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
 {
 	struct scsi_cmnd *cmd = __scsi_get_command(dev->host, gfp_mask);
 	unsigned long flags;
 	if (unlikely(cmd == NULL))
 		return NULL;
 	cmd->device = dev;
 	INIT_LIST_HEAD(&cmd->list);
 	INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler);
 	spin_lock_irqsave(&dev->list_lock, flags);
 	list_add_tail(&cmd->list, &dev->cmd_list);
 	spin_unlock_irqrestore(&dev->list_lock, flags);
 	cmd->jiffies_at_alloc = jiffies;
 	return cmd;
 }
 /**
  * __scsi_put_command - Free a struct scsi_cmnd
  * @shost: dev->host
  * @cmd: Command to free
  */
 static void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
 {
 	unsigned long flags;
 	if (unlikely(list_empty(&shost->free_list))) {
 		spin_lock_irqsave(&shost->free_list_lock, flags);
 		if (list_empty(&shost->free_list)) {
 			list_add(&cmd->list, &shost->free_list);
 			cmd = NULL;
 		}
 		spin_unlock_irqrestore(&shost->free_list_lock, flags);
 	}
 	if (likely(cmd != NULL))
 		scsi_host_free_command(shost, cmd);
 }
 /**
  * scsi_put_command - Free a scsi command block
  * @cmd: command block to free
  *
  * Returns:	Nothing.
  *
  * Notes:	The command must not belong to any lists.
  */
 void scsi_put_command(struct scsi_cmnd *cmd)
 {
 	unsigned long flags;
 	/* serious error if the command hasn't come from a device list */
 	spin_lock_irqsave(&cmd->device->list_lock, flags);
 	BUG_ON(list_empty(&cmd->list));
 	list_del_init(&cmd->list);
 	spin_unlock_irqrestore(&cmd->device->list_lock, flags);
 	BUG_ON(delayed_work_pending(&cmd->abort_work));
 	__scsi_put_command(cmd->device->host, cmd);
 }
 static struct scsi_host_cmd_pool *
 scsi_find_host_cmd_pool(struct Scsi_Host *shost)
 {
 	if (shost->hostt->cmd_size)
 		return shost->hostt->cmd_pool;
 	if (shost->unchecked_isa_dma)
 		return &scsi_cmd_dma_pool;
 	return &scsi_cmd_pool;
 }
 static void
 scsi_free_host_cmd_pool(struct scsi_host_cmd_pool *pool)
 {
 	kfree(pool->sense_name);
 	kfree(pool->cmd_name);
 	kfree(pool);
 }
 static struct scsi_host_cmd_pool *
 scsi_alloc_host_cmd_pool(struct Scsi_Host *shost)
 {
 	struct scsi_host_template *hostt = shost->hostt;
 	struct scsi_host_cmd_pool *pool;
 	pool = kzalloc(sizeof(*pool), GFP_KERNEL);
 	if (!pool)
 		return NULL;
 	pool->cmd_name = kasprintf(GFP_KERNEL, "%s_cmd", hostt->name);
 	pool->sense_name = kasprintf(GFP_KERNEL, "%s_sense", hostt->name);
 	if (!pool->cmd_name || !pool->sense_name) {
 		scsi_free_host_cmd_pool(pool);
 		return NULL;
 	}
 	pool->slab_flags = SLAB_HWCACHE_ALIGN;
 	if (shost->unchecked_isa_dma) {
 		pool->slab_flags |= SLAB_CACHE_DMA;
 		pool->gfp_mask = __GFP_DMA;
 	}
 	return pool;
 }
 static struct scsi_host_cmd_pool *
 scsi_get_host_cmd_pool(struct Scsi_Host *shost)
 {
 	struct scsi_host_template *hostt = shost->hostt;
 	struct scsi_host_cmd_pool *retval = NULL, *pool;
 	size_t cmd_size = sizeof(struct scsi_cmnd) + hostt->cmd_size;
 	/*
 	 * Select a command slab for this host and create it if not
 	 * yet existent.
 	 */
 	mutex_lock(&host_cmd_pool_mutex);
 	pool = scsi_find_host_cmd_pool(shost);
 	if (!pool) {
 		pool = scsi_alloc_host_cmd_pool(shost);
 		if (!pool)
 			goto out;
 	}
 	if (!pool->users) {
 		pool->cmd_slab = kmem_cache_create(pool->cmd_name, cmd_size, 0,
 						   pool->slab_flags, NULL);
 		if (!pool->cmd_slab)
 			goto out_free_pool;
 		pool->sense_slab = kmem_cache_create(pool->sense_name,
 						     SCSI_SENSE_BUFFERSIZE, 0,
 						     pool->slab_flags, NULL);
 		if (!pool->sense_slab)
 			goto out_free_slab;
 	}
 	pool->users++;
 	retval = pool;
 out:
 	mutex_unlock(&host_cmd_pool_mutex);
 	return retval;
 out_free_slab:
 	kmem_cache_destroy(pool->cmd_slab);
 out_free_pool:
 	if (hostt->cmd_size)
 		scsi_free_host_cmd_pool(pool);
 	goto out;
 }
 static void scsi_put_host_cmd_pool(struct Scsi_Host *shost)
 {
 	struct scsi_host_template *hostt = shost->hostt;
 	struct scsi_host_cmd_pool *pool;
 	mutex_lock(&host_cmd_pool_mutex);
 	pool = scsi_find_host_cmd_pool(shost);
 	/*
 	 * This may happen if a driver has a mismatched get and put
 	 * of the command pool; the driver should be implicated in
 	 * the stack trace
 	 */
 	BUG_ON(pool->users == 0);
 	if (!--pool->users) {
 		kmem_cache_destroy(pool->cmd_slab);
 		kmem_cache_destroy(pool->sense_slab);
 		if (hostt->cmd_size)
 			scsi_free_host_cmd_pool(pool);
 	}
 	mutex_unlock(&host_cmd_pool_mutex);
 }
 /**
  * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
  * @shost: host to allocate the freelist for.
  *
  * Description: The command freelist protects against system-wide out of memory
  * deadlock by preallocating one SCSI command structure for each host, so the
  * system can always write to a swap file on a device associated with that host.
  *
  * Returns:	Nothing.
  */
 int scsi_setup_command_freelist(struct Scsi_Host *shost)
 {
 	const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
 	struct scsi_cmnd *cmd;
 	spin_lock_init(&shost->free_list_lock);
 	INIT_LIST_HEAD(&shost->free_list);
 	shost->cmd_pool = scsi_get_host_cmd_pool(shost);
 	if (!shost->cmd_pool)
 		return -ENOMEM;
 	/*
 	 * Get one backup command for this host.
 	 */
 	cmd = scsi_host_alloc_command(shost, gfp_mask);
 	if (!cmd) {
 		scsi_put_host_cmd_pool(shost);
 		shost->cmd_pool = NULL;
 		return -ENOMEM;
 	}
 	list_add(&cmd->list, &shost->free_list);
 	return 0;
 }
 /**
  * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
  * @shost: host whose freelist is going to be destroyed
  */
 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
 {
 	/*
 	 * If cmd_pool is NULL the free list was not initialized, so
 	 * do not attempt to release resources.
 	 */
 	if (!shost->cmd_pool)
 		return;
 	while (!list_empty(&shost->free_list)) {
 		struct scsi_cmnd *cmd;
 		cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
 		list_del_init(&cmd->list);
 		scsi_host_free_command(shost, cmd);
 	}
 	shost->cmd_pool = NULL;
 	scsi_put_host_cmd_pool(shost);
 }
 #ifdef CONFIG_SCSI_LOGGING
 void scsi_log_send(struct scsi_cmnd *cmd)
 {
 	unsigned int level;
 	/*
 	 * If ML QUEUE log level is greater than or equal to:
 	 *
 	 * 1: nothing (match completion)
 	 *
 	 * 2: log opcode + command of all commands
 	 *
 	 * 3: same as 2 plus dump cmd address
 	 *
 	 * 4: same as 3 plus dump extra junk
 	 */
 	if (unlikely(scsi_logging_level)) {
 		level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 				       SCSI_LOG_MLQUEUE_BITS);
 		if (level > 1) {
 			scmd_printk(KERN_INFO, cmd, "Send: ");
 			if (level > 2)
 				printk("0x%p ", cmd);
 			printk("\n");
 			scsi_print_command(cmd);
 			if (level > 3) {
 				printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 				       " queuecommand 0x%p\n",
 					scsi_sglist(cmd), scsi_bufflen(cmd),
 					cmd->device->host->hostt->queuecommand);
 			}
 		}
 	}
 }
 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 {
 	unsigned int level;
 	/*
 	 * If ML COMPLETE log level is greater than or equal to:
 	 *
 	 * 1: log disposition, result, opcode + command, and conditionally
 	 * sense data for failures or non SUCCESS dispositions.
 	 *
 	 * 2: same as 1 but for all command completions.
 	 *
 	 * 3: same as 2 plus dump cmd address
 	 *
 	 * 4: same as 3 plus dump extra junk
 	 */
 	if (unlikely(scsi_logging_level)) {
 		level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 				       SCSI_LOG_MLCOMPLETE_BITS);
 		if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 		    (level > 1)) {
 			scmd_printk(KERN_INFO, cmd, "Done: ");
 			if (level > 2)
 				printk("0x%p ", cmd);
 			/*
 			 * Dump truncated values, so we usually fit within
 			 * 80 chars.
 			 */
 			switch (disposition) {
 			case SUCCESS:
 				printk("SUCCESS\n");
 				break;
 			case NEEDS_RETRY:
 				printk("RETRY\n");
 				break;
 			case ADD_TO_MLQUEUE:
 				printk("MLQUEUE\n");
 				break;
 			case FAILED:
 				printk("FAILED\n");
 				break;
 			case TIMEOUT_ERROR:
 				/*
 				 * If called via scsi_times_out.
 				 */
 				printk("TIMEOUT\n");
 				break;
 			default:
 				printk("UNKNOWN\n");
 			}
 			scsi_print_result(cmd);
 			scsi_print_command(cmd);
 			if (status_byte(cmd->result) & CHECK_CONDITION)
 				scsi_print_sense("", cmd);
 			if (level > 3)
 				scmd_printk(KERN_INFO, cmd,
 					    "scsi host busy %d failed %d\n",
 					    atomic_read(&cmd->device->host->host_busy),
 					    cmd->device->host->host_failed);
 		}
 	}
 }
 #endif
 /**
  * scsi_cmd_get_serial - Assign a serial number to a command
  * @host: the scsi host
  * @cmd: command to assign serial number to
  *
  * Description: a serial number identifies a request for error recovery
  * and debugging purposes.  Protected by the Host_Lock of host.
  */
 void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 {
 	cmd->serial_number = host->cmd_serial_number++;
 	if (cmd->serial_number == 0)
 		cmd->serial_number = host->cmd_serial_number++;
 }
 EXPORT_SYMBOL(scsi_cmd_get_serial);
 /**
  * scsi_dispatch_command - Dispatch a command to the low-level driver.
  * @cmd: command block we are dispatching.
  *
  * Return: nonzero return request was rejected and device's queue needs to be
  * plugged.
  */
 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 {
 	struct Scsi_Host *host = cmd->device->host;
 	int rtn = 0;
 	atomic_inc(&cmd->device->iorequest_cnt);
 	/* check if the device is still usable */
 	if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 		/* in SDEV_DEL we error all commands. DID_NO_CONNECT
 		 * returns an immediate error upwards, and signals
 		 * that the device is no longer present */
 		cmd->result = DID_NO_CONNECT << 16;
 		goto done;
 	}
 	/* Check to see if the scsi lld made this device blocked. */
 	if (unlikely(scsi_device_blocked(cmd->device))) {
 		/*
 		 * in blocked state, the command is just put back on
 		 * the device queue.  The suspend state has already
 		 * blocked the queue so future requests should not
 		 * occur until the device transitions out of the
 		 * suspend state.
 		 */
 		SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 			"queuecommand : device blocked\n"));
 		return SCSI_MLQUEUE_DEVICE_BUSY;
 	}
 	/*
 	 * If SCSI-2 or lower, store the LUN value in cmnd.
 	 */
 	if (cmd->device->scsi_level <= SCSI_2 &&
 	    cmd->device->scsi_level != SCSI_UNKNOWN) {
 		cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 			       (cmd->device->lun << 5 & 0xe0);
 	}
 	scsi_log_send(cmd);
 	/*
 	 * Before we queue this command, check if the command
 	 * length exceeds what the host adapter can handle.
 	 */
 	if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 		SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 			       "queuecommand : command too long. "
 			       "cdb_size=%d host->max_cmd_len=%d\n",
 			       cmd->cmd_len, cmd->device->host->max_cmd_len));
 		cmd->result = (DID_ABORT << 16);
 		goto done;
 	}
 	if (unlikely(host->shost_state == SHOST_DEL)) {
 		cmd->result = (DID_NO_CONNECT << 16);
 		goto done;
 	}
 	trace_scsi_dispatch_cmd_start(cmd);
 	rtn = host->hostt->queuecommand(host, cmd);
 	if (rtn) {
 		trace_scsi_dispatch_cmd_error(cmd, rtn);
 		if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
 		    rtn != SCSI_MLQUEUE_TARGET_BUSY)
 			rtn = SCSI_MLQUEUE_HOST_BUSY;
 		SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 			"queuecommand : request rejected\n"));
 	}
 	return rtn;
  done:
 	cmd->scsi_done(cmd);
 	return 0;
 }
 /**
  * scsi_finish_command - cleanup and pass command back to upper layer
  * @cmd: the command
  *
  * Description: Pass command off to upper layer for finishing of I/O
  *              request, waking processes that are waiting on results,
  *              etc.
  */
 void scsi_finish_command(struct scsi_cmnd *cmd)
 {
 	struct scsi_device *sdev = cmd->device;
 	struct scsi_target *starget = scsi_target(sdev);
 	struct Scsi_Host *shost = sdev->host;
 	struct scsi_driver *drv;
 	unsigned int good_bytes;
 	scsi_device_unbusy(sdev);
-        /*
+	/*
-         * Clear the flags which say that the device/host is no longer
+	 * Clear the flags that say that the device/target/host is no longer
-         * capable of accepting new commands.  These are set in scsi_queue.c
+	 * capable of accepting new commands.
-         * for both the queue full condition on a device, and for a
+	 */
-         * host full condition on the host.
+	if (atomic_read(&shost->host_blocked))
-	 *
+		atomic_set(&shost->host_blocked, 0);
-	 * XXX(hch): What about locking?
+	if (atomic_read(&starget->target_blocked))
-         */
+		atomic_set(&starget->target_blocked, 0);
-        shost->host_blocked = 0;
+	if (atomic_read(&sdev->device_blocked))
-	starget->target_blocked = 0;
+		atomic_set(&sdev->device_blocked, 0);
-        sdev->device_blocked = 0;
 	/*
 	 * If we have valid sense information, then some kind of recovery
 	 * must have taken place.  Make a note of this.
 	 */
 	if (SCSI_SENSE_VALID(cmd))
 		cmd->result |= (DRIVER_SENSE << 24);
 	SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 				"Notifying upper driver of completion "
 				"(result %x)\n", cmd->result));
 	good_bytes = scsi_bufflen(cmd);
         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 		int old_good_bytes = good_bytes;
 		drv = scsi_cmd_to_driver(cmd);
 		if (drv->done)
 			good_bytes = drv->done(cmd);
 		/*
 		 * USB may not give sense identifying bad sector and
 		 * simply return a residue instead, so subtract off the
 		 * residue if drv->done() error processing indicates no
 		 * change to the completion length.
 		 */
 		if (good_bytes == old_good_bytes)
 			good_bytes -= scsi_get_resid(cmd);
 	}
 	scsi_io_completion(cmd, good_bytes);
 }
 /**
  * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
  * @sdev: SCSI Device in question
  * @tagged: Do we use tagged queueing (non-0) or do we treat
  *          this device as an untagged device (0)
  * @tags: Number of tags allowed if tagged queueing enabled,
  *        or number of commands the low level driver can
  *        queue up in non-tagged mode (as per cmd_per_lun).
  *
  * Returns:	Nothing
  *
  * Lock Status:	None held on entry
  *
  * Notes:	Low level drivers may call this at any time and we will do
  * 		the right thing depending on whether or not the device is
  * 		currently active and whether or not it even has the
  * 		command blocks built yet.
  */
 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 {
 	unsigned long flags;
 	/*
 	 * refuse to set tagged depth to an unworkable size
 	 */
 	if (tags <= 0)
 		return;
 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 	/*
 	 * Check to see if the queue is managed by the block layer.
 	 * If it is, and we fail to adjust the depth, exit.
 	 *
 	 * Do not resize the tag map if it is a host wide share bqt,
 	 * because the size should be the hosts's can_queue. If there
 	 * is more IO than the LLD's can_queue (so there are not enuogh
 	 * tags) request_fn's host queue ready check will handle it.
 	 */
 	if (!sdev->host->bqt) {
 		if (blk_queue_tagged(sdev->request_queue) &&
 		    blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 			goto out;
 	}
 	sdev->queue_depth = tags;
 	switch (tagged) {
 		case 0:
 			sdev->ordered_tags = 0;
 			sdev->simple_tags = 0;
 			break;
 		case MSG_ORDERED_TAG:
 			sdev->ordered_tags = 1;
 			sdev->simple_tags = 1;
 			break;
 		case MSG_SIMPLE_TAG:
 			sdev->ordered_tags = 0;
 			sdev->simple_tags = 1;
 			break;
 		default:
 			sdev->ordered_tags = 0;
 			sdev->simple_tags = 0;
 			sdev_printk(KERN_WARNING, sdev,
 				    "scsi_adjust_queue_depth, bad queue type, "
 				    "disabled\n");
 	}
  out:
 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 }
 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 /**
  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
  * @sdev: SCSI Device in question
  * @depth: Current number of outstanding SCSI commands on this device,
  *         not counting the one returned as QUEUE_FULL.
  *
  * Description:	This function will track successive QUEUE_FULL events on a
  * 		specific SCSI device to determine if and when there is a
  * 		need to adjust the queue depth on the device.
  *
  * Returns:	0 - No change needed, >0 - Adjust queue depth to this new depth,
  * 		-1 - Drop back to untagged operation using host->cmd_per_lun
  * 			as the untagged command depth
  *
  * Lock Status:	None held on entry
  *
  * Notes:	Low level drivers may call this at any time and we will do
  * 		"The Right Thing."  We are interrupt context safe.
  */
 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 {
 	/*
 	 * Don't let QUEUE_FULLs on the same
 	 * jiffies count, they could all be from
 	 * same event.
 	 */
 	if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
 		return 0;
 	sdev->last_queue_full_time = jiffies;
 	if (sdev->last_queue_full_depth != depth) {
 		sdev->last_queue_full_count = 1;
 		sdev->last_queue_full_depth = depth;
 	} else {
 		sdev->last_queue_full_count++;
 	}
 	if (sdev->last_queue_full_count <= 10)
 		return 0;
 	if (sdev->last_queue_full_depth < 8) {
 		/* Drop back to untagged */
 		scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 		return -1;
 	}
 	if (sdev->ordered_tags)
 		scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 	else
 		scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 	return depth;
 }
 EXPORT_SYMBOL(scsi_track_queue_full);
 /**
  * scsi_vpd_inquiry - Request a device provide us with a VPD page
  * @sdev: The device to ask
  * @buffer: Where to put the result
  * @page: Which Vital Product Data to return
  * @len: The length of the buffer
  *
  * This is an internal helper function.  You probably want to use
  * scsi_get_vpd_page instead.
  *
  * Returns size of the vpd page on success or a negative error number.
  */
 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
 							u8 page, unsigned len)
 {
 	int result;
 	unsigned char cmd[16];
 	if (len < 4)
 		return -EINVAL;
 	cmd[0] = INQUIRY;
 	cmd[1] = 1;		/* EVPD */
 	cmd[2] = page;
 	cmd[3] = len >> 8;
 	cmd[4] = len & 0xff;
 	cmd[5] = 0;		/* Control byte */
 	/*
 	 * I'm not convinced we need to try quite this hard to get VPD, but
 	 * all the existing users tried this hard.
 	 */
 	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
 				  len, NULL, 30 * HZ, 3, NULL);
 	if (result)
 		return -EIO;
 	/* Sanity check that we got the page back that we asked for */
 	if (buffer[1] != page)
 		return -EIO;
 	return get_unaligned_be16(&buffer[2]) + 4;
 }
 /**
  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
  * @sdev: The device to ask
  * @page: Which Vital Product Data to return
  * @buf: where to store the VPD
  * @buf_len: number of bytes in the VPD buffer area
  *
  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
  * If the device supports this VPD page, this routine returns a pointer
  * to a buffer containing the data from that page.  The caller is
  * responsible for calling kfree() on this pointer when it is no longer
  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
  */
 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
 		      int buf_len)
 {
 	int i, result;
 	if (sdev->skip_vpd_pages)
 		goto fail;
 	/* Ask for all the pages supported by this device */
 	result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
 	if (result < 4)
 		goto fail;
 	/* If the user actually wanted this page, we can skip the rest */
 	if (page == 0)
 		return 0;
 	for (i = 4; i < min(result, buf_len); i++)
 		if (buf[i] == page)
 			goto found;
 	if (i < result && i >= buf_len)
 		/* ran off the end of the buffer, give us benefit of doubt */
 		goto found;
 	/* The device claims it doesn't support the requested page */
 	goto fail;
  found:
 	result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
 	if (result < 0)
 		goto fail;
 	return 0;
  fail:
 	return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
 /**
  * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure
  * @sdev: The device to ask
  *
  * Attach the 'Device Identification' VPD page (0x83) and the
  * 'Unit Serial Number' VPD page (0x80) to a SCSI device
  * structure. This information can be used to identify the device
  * uniquely.
  */
 void scsi_attach_vpd(struct scsi_device *sdev)
 {
 	int result, i;
 	int vpd_len = SCSI_VPD_PG_LEN;
 	int pg80_supported = 0;
 	int pg83_supported = 0;
 	unsigned char *vpd_buf;
 	if (sdev->skip_vpd_pages)
 		return;
 retry_pg0:
 	vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
 	if (!vpd_buf)
 		return;
 	/* Ask for all the pages supported by this device */
 	result = scsi_vpd_inquiry(sdev, vpd_buf, 0, vpd_len);
 	if (result < 0) {
 		kfree(vpd_buf);
 		return;
 	}
 	if (result > vpd_len) {
 		vpd_len = result;
 		kfree(vpd_buf);
 		goto retry_pg0;
 	}
 	for (i = 4; i < result; i++) {
 		if (vpd_buf[i] == 0x80)
 			pg80_supported = 1;
 		if (vpd_buf[i] == 0x83)
 			pg83_supported = 1;
 	}
 	kfree(vpd_buf);
 	vpd_len = SCSI_VPD_PG_LEN;
 	if (pg80_supported) {
 retry_pg80:
 		vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
 		if (!vpd_buf)
 			return;
 		result = scsi_vpd_inquiry(sdev, vpd_buf, 0x80, vpd_len);
 		if (result < 0) {
 			kfree(vpd_buf);
 			return;
 		}
 		if (result > vpd_len) {
 			vpd_len = result;
 			kfree(vpd_buf);
 			goto retry_pg80;
 		}
 		sdev->vpd_pg80_len = result;
 		sdev->vpd_pg80 = vpd_buf;
 		vpd_len = SCSI_VPD_PG_LEN;
 	}
 	if (pg83_supported) {
 retry_pg83:
 		vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
 		if (!vpd_buf)
 			return;
 		result = scsi_vpd_inquiry(sdev, vpd_buf, 0x83, vpd_len);
 		if (result < 0) {
 			kfree(vpd_buf);
 			return;
 		}
 		if (result > vpd_len) {
 			vpd_len = result;
 			kfree(vpd_buf);
 			goto retry_pg83;
 		}
 		sdev->vpd_pg83_len = result;
 		sdev->vpd_pg83 = vpd_buf;
 	}
 }
 /**
  * scsi_report_opcode - Find out if a given command opcode is supported
  * @sdev:	scsi device to query
  * @buffer:	scratch buffer (must be at least 20 bytes long)
  * @len:	length of buffer
  * @opcode:	opcode for command to look up
  *
  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
  * unsupported and 1 if the device claims to support the command.
  */
 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
 		       unsigned int len, unsigned char opcode)
 {
 	unsigned char cmd[16];
 	struct scsi_sense_hdr sshdr;
 	int result;
 	if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
 		return -EINVAL;
 	memset(cmd, 0, 16);
 	cmd[0] = MAINTENANCE_IN;
 	cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
 	cmd[2] = 1;		/* One command format */
 	cmd[3] = opcode;
 	put_unaligned_be32(len, &cmd[6]);
 	memset(buffer, 0, len);
 	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
 				  &sshdr, 30 * HZ, 3, NULL);
 	if (result && scsi_sense_valid(&sshdr) &&
 	    sshdr.sense_key == ILLEGAL_REQUEST &&
 	    (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
 		return -EINVAL;
 	if ((buffer[1] & 3) == 3) /* Command supported */
 		return 1;
 	return 0;
 }
 EXPORT_SYMBOL(scsi_report_opcode);
 /**
  * scsi_device_get  -  get an additional reference to a scsi_device
  * @sdev:	device to get a reference to
  *
  * Description: Gets a reference to the scsi_device and increments the use count
  * of the underlying LLDD module.  You must hold host_lock of the
  * parent Scsi_Host or already have a reference when calling this.
  */
 int scsi_device_get(struct scsi_device *sdev)
 {
 	if (sdev->sdev_state == SDEV_DEL)
 		return -ENXIO;
 	if (!get_device(&sdev->sdev_gendev))
 		return -ENXIO;
 	/* We can fail this if we're doing SCSI operations
 	 * from module exit (like cache flush) */
 	try_module_get(sdev->host->hostt->module);
 	return 0;
 }
 EXPORT_SYMBOL(scsi_device_get);
 /**
  * scsi_device_put  -  release a reference to a scsi_device
  * @sdev:	device to release a reference on.
  *
  * Description: Release a reference to the scsi_device and decrements the use
  * count of the underlying LLDD module.  The device is freed once the last
  * user vanishes.
  */
 void scsi_device_put(struct scsi_device *sdev)
 {
 #ifdef CONFIG_MODULE_UNLOAD
 	struct module *module = sdev->host->hostt->module;
 	/* The module refcount will be zero if scsi_device_get()
 	 * was called from a module removal routine */
 	if (module && module_refcount(module) != 0)
 		module_put(module);
 #endif
 	put_device(&sdev->sdev_gendev);
 }
 EXPORT_SYMBOL(scsi_device_put);
 /* helper for shost_for_each_device, see that for documentation */
 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
 					   struct scsi_device *prev)
 {
 	struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
 	struct scsi_device *next = NULL;
 	unsigned long flags;
 	spin_lock_irqsave(shost->host_lock, flags);
 	while (list->next != &shost->__devices) {
 		next = list_entry(list->next, struct scsi_device, siblings);
 		/* skip devices that we can't get a reference to */
 		if (!scsi_device_get(next))
 			break;
 		next = NULL;
 		list = list->next;
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	if (prev)
 		scsi_device_put(prev);
 	return next;
 }
 EXPORT_SYMBOL(__scsi_iterate_devices);
 /**
  * starget_for_each_device  -  helper to walk all devices of a target
  * @starget:	target whose devices we want to iterate over.
  * @data:	Opaque passed to each function call.
  * @fn:		Function to call on each device
  *
  * This traverses over each device of @starget.  The devices have
  * a reference that must be released by scsi_host_put when breaking
  * out of the loop.
  */
 void starget_for_each_device(struct scsi_target *starget, void *data,
 		     void (*fn)(struct scsi_device *, void *))
 {
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	struct scsi_device *sdev;
 	shost_for_each_device(sdev, shost) {
 		if ((sdev->channel == starget->channel) &&
 		    (sdev->id == starget->id))
 			fn(sdev, data);
 	}
 }
 EXPORT_SYMBOL(starget_for_each_device);
 /**
  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
  * @starget:	target whose devices we want to iterate over.
  * @data:	parameter for callback @fn()
  * @fn:		callback function that is invoked for each device
  *
  * This traverses over each device of @starget.  It does _not_
  * take a reference on the scsi_device, so the whole loop must be
  * protected by shost->host_lock.
  *
  * Note:  The only reason why drivers would want to use this is because
  * they need to access the device list in irq context.  Otherwise you
  * really want to use starget_for_each_device instead.
  **/
 void __starget_for_each_device(struct scsi_target *starget, void *data,
 			       void (*fn)(struct scsi_device *, void *))
 {
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	struct scsi_device *sdev;
 	__shost_for_each_device(sdev, shost) {
 		if ((sdev->channel == starget->channel) &&
 		    (sdev->id == starget->id))
 			fn(sdev, data);
 	}
 }
 EXPORT_SYMBOL(__starget_for_each_device);
 /**
  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
  * @starget:	SCSI target pointer
  * @lun:	SCSI Logical Unit Number
  *
  * Description: Looks up the scsi_device with the specified @lun for a given
  * @starget.  The returned scsi_device does not have an additional
  * reference.  You must hold the host's host_lock over this call and
  * any access to the returned scsi_device. A scsi_device in state
  * SDEV_DEL is skipped.
  *
  * Note:  The only reason why drivers should use this is because
  * they need to access the device list in irq context.  Otherwise you
  * really want to use scsi_device_lookup_by_target instead.
  **/
 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
 						   u64 lun)
 {
 	struct scsi_device *sdev;
 	list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
 		if (sdev->sdev_state == SDEV_DEL)
 			continue;
 		if (sdev->lun ==lun)
 			return sdev;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
 /**
  * scsi_device_lookup_by_target - find a device given the target
  * @starget:	SCSI target pointer
  * @lun:	SCSI Logical Unit Number
  *
  * Description: Looks up the scsi_device with the specified @lun for a given
  * @starget.  The returned scsi_device has an additional reference that
  * needs to be released with scsi_device_put once you're done with it.
  **/
 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
 						 u64 lun)
 {
 	struct scsi_device *sdev;
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	unsigned long flags;
 	spin_lock_irqsave(shost->host_lock, flags);
 	sdev = __scsi_device_lookup_by_target(starget, lun);
 	if (sdev && scsi_device_get(sdev))
 		sdev = NULL;
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	return sdev;
 }
 EXPORT_SYMBOL(scsi_device_lookup_by_target);
 /**
  * __scsi_device_lookup - find a device given the host (UNLOCKED)
  * @shost:	SCSI host pointer
  * @channel:	SCSI channel (zero if only one channel)
  * @id:		SCSI target number (physical unit number)
  * @lun:	SCSI Logical Unit Number
  *
  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
  * for a given host. The returned scsi_device does not have an additional
  * reference.  You must hold the host's host_lock over this call and any access
  * to the returned scsi_device.
  *
  * Note:  The only reason why drivers would want to use this is because
  * they need to access the device list in irq context.  Otherwise you
  * really want to use scsi_device_lookup instead.
  **/
 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
 		uint channel, uint id, u64 lun)
 {
 	struct scsi_device *sdev;
 	list_for_each_entry(sdev, &shost->__devices, siblings) {
 		if (sdev->channel == channel && sdev->id == id &&
 				sdev->lun ==lun)
 			return sdev;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL(__scsi_device_lookup);
 /**
  * scsi_device_lookup - find a device given the host
  * @shost:	SCSI host pointer
  * @channel:	SCSI channel (zero if only one channel)
  * @id:		SCSI target number (physical unit number)
  * @lun:	SCSI Logical Unit Number
  *
  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
  * for a given host.  The returned scsi_device has an additional reference that
  * needs to be released with scsi_device_put once you're done with it.
  **/
 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
 		uint channel, uint id, u64 lun)
 {
 	struct scsi_device *sdev;
 	unsigned long flags;
 	spin_lock_irqsave(shost->host_lock, flags);
 	sdev = __scsi_device_lookup(shost, channel, id, lun);
 	if (sdev && scsi_device_get(sdev))
 		sdev = NULL;
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	return sdev;
 }
 EXPORT_SYMBOL(scsi_device_lookup);
 MODULE_DESCRIPTION("SCSI core");
 MODULE_LICENSE("GPL");
 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
 static int __init init_scsi(void)
 {
 	int error;
 	error = scsi_init_queue();
 	if (error)
 		return error;
 	error = scsi_init_procfs();
 	if (error)
 		goto cleanup_queue;
 	error = scsi_init_devinfo();
 	if (error)
 		goto cleanup_procfs;
 	error = scsi_init_hosts();
 	if (error)
 		goto cleanup_devlist;
 	error = scsi_init_sysctl();
 	if (error)
 		goto cleanup_hosts;
 	error = scsi_sysfs_register();
 	if (error)
 		goto cleanup_sysctl;
 	scsi_netlink_init();
 	printk(KERN_NOTICE "SCSI subsystem initialized\n");
 	return 0;
 cleanup_sysctl:
 	scsi_exit_sysctl();
 cleanup_hosts:
 	scsi_exit_hosts();
 cleanup_devlist:
 	scsi_exit_devinfo();
 cleanup_procfs:
 	scsi_exit_procfs();
 cleanup_queue:
 	scsi_exit_queue();
 	printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
 	       -error);
 	return error;
 }
 static void __exit exit_scsi(void)
 {
 	scsi_netlink_exit();
 	scsi_sysfs_unregister();
 	scsi_exit_sysctl();
 	scsi_exit_hosts();
 	scsi_exit_devinfo();
 	scsi_exit_procfs();
 	scsi_exit_queue();
 	async_unregister_domain(&scsi_sd_probe_domain);
 }
 subsys_initcall(init_scsi);
 module_exit(exit_scsi);

drivers/scsi/scsi_lib.c

Diff comments View file @ cd9070c

1	/*	1	/*
2	* scsi_lib.c Copyright (C) 1999 Eric Youngdale	2	* scsi_lib.c Copyright (C) 1999 Eric Youngdale
3	*	3	*
4	* SCSI queueing library.	4	* SCSI queueing library.
5	* Initial versions: Eric Youngdale (eric@andante.org).	5	* Initial versions: Eric Youngdale (eric@andante.org).
6	* Based upon conversations with large numbers	6	* Based upon conversations with large numbers
7	* of people at Linux Expo.	7	* of people at Linux Expo.
8	*/	8	*/
9		9
10	#include <linux/bio.h>	10	#include <linux/bio.h>
11	#include <linux/bitops.h>	11	#include <linux/bitops.h>
12	#include <linux/blkdev.h>	12	#include <linux/blkdev.h>
13	#include <linux/completion.h>	13	#include <linux/completion.h>
14	#include <linux/kernel.h>	14	#include <linux/kernel.h>
15	#include <linux/export.h>	15	#include <linux/export.h>
16	#include <linux/mempool.h>	16	#include <linux/mempool.h>
17	#include <linux/slab.h>	17	#include <linux/slab.h>
18	#include <linux/init.h>	18	#include <linux/init.h>
19	#include <linux/pci.h>	19	#include <linux/pci.h>
20	#include <linux/delay.h>	20	#include <linux/delay.h>
21	#include <linux/hardirq.h>	21	#include <linux/hardirq.h>
22	#include <linux/scatterlist.h>	22	#include <linux/scatterlist.h>
23		23
24	#include <scsi/scsi.h>	24	#include <scsi/scsi.h>
25	#include <scsi/scsi_cmnd.h>	25	#include <scsi/scsi_cmnd.h>
26	#include <scsi/scsi_dbg.h>	26	#include <scsi/scsi_dbg.h>
27	#include <scsi/scsi_device.h>	27	#include <scsi/scsi_device.h>
28	#include <scsi/scsi_driver.h>	28	#include <scsi/scsi_driver.h>
29	#include <scsi/scsi_eh.h>	29	#include <scsi/scsi_eh.h>
30	#include <scsi/scsi_host.h>	30	#include <scsi/scsi_host.h>
31		31
32	#include <trace/events/scsi.h>	32	#include <trace/events/scsi.h>
33		33
34	#include "scsi_priv.h"	34	#include "scsi_priv.h"
35	#include "scsi_logging.h"	35	#include "scsi_logging.h"
36		36
37		37
38	#define SG_MEMPOOL_NR ARRAY_SIZE(scsi_sg_pools)	38	#define SG_MEMPOOL_NR ARRAY_SIZE(scsi_sg_pools)
39	#define SG_MEMPOOL_SIZE 2	39	#define SG_MEMPOOL_SIZE 2
40		40
41	struct scsi_host_sg_pool {	41	struct scsi_host_sg_pool {
42	size_t size;	42	size_t size;
43	char *name;	43	char *name;
44	struct kmem_cache *slab;	44	struct kmem_cache *slab;
45	mempool_t *pool;	45	mempool_t *pool;
46	};	46	};
47		47
48	#define SP(x) { x, "sgpool-" __stringify(x) }	48	#define SP(x) { x, "sgpool-" __stringify(x) }
49	#if (SCSI_MAX_SG_SEGMENTS < 32)	49	#if (SCSI_MAX_SG_SEGMENTS < 32)
50	#error SCSI_MAX_SG_SEGMENTS is too small (must be 32 or greater)	50	#error SCSI_MAX_SG_SEGMENTS is too small (must be 32 or greater)
51	#endif	51	#endif
52	static struct scsi_host_sg_pool scsi_sg_pools[] = {	52	static struct scsi_host_sg_pool scsi_sg_pools[] = {
53	SP(8),	53	SP(8),
54	SP(16),	54	SP(16),
55	#if (SCSI_MAX_SG_SEGMENTS > 32)	55	#if (SCSI_MAX_SG_SEGMENTS > 32)
56	SP(32),	56	SP(32),
57	#if (SCSI_MAX_SG_SEGMENTS > 64)	57	#if (SCSI_MAX_SG_SEGMENTS > 64)
58	SP(64),	58	SP(64),
59	#if (SCSI_MAX_SG_SEGMENTS > 128)	59	#if (SCSI_MAX_SG_SEGMENTS > 128)
60	SP(128),	60	SP(128),
61	#if (SCSI_MAX_SG_SEGMENTS > 256)	61	#if (SCSI_MAX_SG_SEGMENTS > 256)
62	#error SCSI_MAX_SG_SEGMENTS is too large (256 MAX)	62	#error SCSI_MAX_SG_SEGMENTS is too large (256 MAX)
63	#endif	63	#endif
64	#endif	64	#endif
65	#endif	65	#endif
66	#endif	66	#endif
67	SP(SCSI_MAX_SG_SEGMENTS)	67	SP(SCSI_MAX_SG_SEGMENTS)
68	};	68	};
69	#undef SP	69	#undef SP
70		70
71	struct kmem_cache *scsi_sdb_cache;	71	struct kmem_cache *scsi_sdb_cache;
72		72
73	/*	73	/*
74	* When to reinvoke queueing after a resource shortage. It's 3 msecs to	74	* When to reinvoke queueing after a resource shortage. It's 3 msecs to
75	* not change behaviour from the previous unplug mechanism, experimentation	75	* not change behaviour from the previous unplug mechanism, experimentation
76	* may prove this needs changing.	76	* may prove this needs changing.
77	*/	77	*/
78	#define SCSI_QUEUE_DELAY 3	78	#define SCSI_QUEUE_DELAY 3
79		79
80	static void	80	static void
81	scsi_set_blocked(struct scsi_cmnd *cmd, int reason)	81	scsi_set_blocked(struct scsi_cmnd *cmd, int reason)
82	{	82	{
83	struct Scsi_Host *host = cmd->device->host;	83	struct Scsi_Host *host = cmd->device->host;
84	struct scsi_device *device = cmd->device;	84	struct scsi_device *device = cmd->device;
85	struct scsi_target *starget = scsi_target(device);	85	struct scsi_target *starget = scsi_target(device);
86		86
87	/*	87	/*
88	* Set the appropriate busy bit for the device/host.	88	* Set the appropriate busy bit for the device/host.
89	*	89	*
90	* If the host/device isn't busy, assume that something actually	90	* If the host/device isn't busy, assume that something actually
91	* completed, and that we should be able to queue a command now.	91	* completed, and that we should be able to queue a command now.
92	*	92	*
93	* Note that the prior mid-layer assumption that any host could	93	* Note that the prior mid-layer assumption that any host could
94	* always queue at least one command is now broken. The mid-layer	94	* always queue at least one command is now broken. The mid-layer
95	* will implement a user specifiable stall (see	95	* will implement a user specifiable stall (see
96	* scsi_host.max_host_blocked and scsi_device.max_device_blocked)	96	* scsi_host.max_host_blocked and scsi_device.max_device_blocked)
97	* if a command is requeued with no other commands outstanding	97	* if a command is requeued with no other commands outstanding
98	* either for the device or for the host.	98	* either for the device or for the host.
99	*/	99	*/
100	switch (reason) {	100	switch (reason) {
101	case SCSI_MLQUEUE_HOST_BUSY:	101	case SCSI_MLQUEUE_HOST_BUSY:
102	host->host_blocked = host->max_host_blocked;	102	atomic_set(&host->host_blocked, host->max_host_blocked);
103	break;	103	break;
104	case SCSI_MLQUEUE_DEVICE_BUSY:	104	case SCSI_MLQUEUE_DEVICE_BUSY:
105	case SCSI_MLQUEUE_EH_RETRY:	105	case SCSI_MLQUEUE_EH_RETRY:
106	device->device_blocked = device->max_device_blocked;	106	atomic_set(&device->device_blocked,
		107	device->max_device_blocked);
107	break;	108	break;
108	case SCSI_MLQUEUE_TARGET_BUSY:	109	case SCSI_MLQUEUE_TARGET_BUSY:
109	starget->target_blocked = starget->max_target_blocked;	110	atomic_set(&starget->target_blocked,
		111	starget->max_target_blocked);
110	break;	112	break;
111	}	113	}
112	}	114	}
113		115
114	/**	116	/**
115	* __scsi_queue_insert - private queue insertion	117	* __scsi_queue_insert - private queue insertion
116	* @cmd: The SCSI command being requeued	118	* @cmd: The SCSI command being requeued
117	* @reason: The reason for the requeue	119	* @reason: The reason for the requeue
118	* @unbusy: Whether the queue should be unbusied	120	* @unbusy: Whether the queue should be unbusied
119	*	121	*
120	* This is a private queue insertion. The public interface	122	* This is a private queue insertion. The public interface
121	* scsi_queue_insert() always assumes the queue should be unbusied	123	* scsi_queue_insert() always assumes the queue should be unbusied
122	* because it's always called before the completion. This function is	124	* because it's always called before the completion. This function is
123	* for a requeue after completion, which should only occur in this	125	* for a requeue after completion, which should only occur in this
124	* file.	126	* file.
125	*/	127	*/
126	static void __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy)	128	static void __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy)
127	{	129	{
128	struct scsi_device *device = cmd->device;	130	struct scsi_device *device = cmd->device;
129	struct request_queue *q = device->request_queue;	131	struct request_queue *q = device->request_queue;
130	unsigned long flags;	132	unsigned long flags;
131		133
132	SCSI_LOG_MLQUEUE(1, scmd_printk(KERN_INFO, cmd,	134	SCSI_LOG_MLQUEUE(1, scmd_printk(KERN_INFO, cmd,
133	"Inserting command %p into mlqueue\n", cmd));	135	"Inserting command %p into mlqueue\n", cmd));
134		136
135	scsi_set_blocked(cmd, reason);	137	scsi_set_blocked(cmd, reason);
136		138
137	/*	139	/*
138	* Decrement the counters, since these commands are no longer	140	* Decrement the counters, since these commands are no longer
139	* active on the host/device.	141	* active on the host/device.
140	*/	142	*/
141	if (unbusy)	143	if (unbusy)
142	scsi_device_unbusy(device);	144	scsi_device_unbusy(device);
143		145
144	/*	146	/*
145	* Requeue this command. It will go before all other commands	147	* Requeue this command. It will go before all other commands
146	* that are already in the queue. Schedule requeue work under	148	* that are already in the queue. Schedule requeue work under
147	* lock such that the kblockd_schedule_work() call happens	149	* lock such that the kblockd_schedule_work() call happens
148	* before blk_cleanup_queue() finishes.	150	* before blk_cleanup_queue() finishes.
149	*/	151	*/
150	cmd->result = 0;	152	cmd->result = 0;
151	spin_lock_irqsave(q->queue_lock, flags);	153	spin_lock_irqsave(q->queue_lock, flags);
152	blk_requeue_request(q, cmd->request);	154	blk_requeue_request(q, cmd->request);
153	kblockd_schedule_work(&device->requeue_work);	155	kblockd_schedule_work(&device->requeue_work);
154	spin_unlock_irqrestore(q->queue_lock, flags);	156	spin_unlock_irqrestore(q->queue_lock, flags);
155	}	157	}
156		158
157	/*	159	/*
158	* Function: scsi_queue_insert()	160	* Function: scsi_queue_insert()
159	*	161	*
160	* Purpose: Insert a command in the midlevel queue.	162	* Purpose: Insert a command in the midlevel queue.
161	*	163	*
162	* Arguments: cmd - command that we are adding to queue.	164	* Arguments: cmd - command that we are adding to queue.
163	* reason - why we are inserting command to queue.	165	* reason - why we are inserting command to queue.
164	*	166	*
165	* Lock status: Assumed that lock is not held upon entry.	167	* Lock status: Assumed that lock is not held upon entry.
166	*	168	*
167	* Returns: Nothing.	169	* Returns: Nothing.
168	*	170	*
169	* Notes: We do this for one of two cases. Either the host is busy	171	* Notes: We do this for one of two cases. Either the host is busy
170	* and it cannot accept any more commands for the time being,	172	* and it cannot accept any more commands for the time being,
171	* or the device returned QUEUE_FULL and can accept no more	173	* or the device returned QUEUE_FULL and can accept no more
172	* commands.	174	* commands.
173	* Notes: This could be called either from an interrupt context or a	175	* Notes: This could be called either from an interrupt context or a
174	* normal process context.	176	* normal process context.
175	*/	177	*/
176	void scsi_queue_insert(struct scsi_cmnd *cmd, int reason)	178	void scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
177	{	179	{
178	__scsi_queue_insert(cmd, reason, 1);	180	__scsi_queue_insert(cmd, reason, 1);
179	}	181	}
180	/**	182	/**
181	* scsi_execute - insert request and wait for the result	183	* scsi_execute - insert request and wait for the result
182	* @sdev: scsi device	184	* @sdev: scsi device
183	* @cmd: scsi command	185	* @cmd: scsi command
184	* @data_direction: data direction	186	* @data_direction: data direction
185	* @buffer: data buffer	187	* @buffer: data buffer
186	* @bufflen: len of buffer	188	* @bufflen: len of buffer
187	* @sense: optional sense buffer	189	* @sense: optional sense buffer
188	* @timeout: request timeout in seconds	190	* @timeout: request timeout in seconds
189	* @retries: number of times to retry request	191	* @retries: number of times to retry request
190	* @flags: or into request flags;	192	* @flags: or into request flags;
191	* @resid: optional residual length	193	* @resid: optional residual length
192	*	194	*
193	* returns the req->errors value which is the scsi_cmnd result	195	* returns the req->errors value which is the scsi_cmnd result
194	* field.	196	* field.
195	*/	197	*/
196	int scsi_execute(struct scsi_device sdev, const unsigned char cmd,	198	int scsi_execute(struct scsi_device sdev, const unsigned char cmd,
197	int data_direction, void *buffer, unsigned bufflen,	199	int data_direction, void *buffer, unsigned bufflen,
198	unsigned char *sense, int timeout, int retries, u64 flags,	200	unsigned char *sense, int timeout, int retries, u64 flags,
199	int *resid)	201	int *resid)
200	{	202	{
201	struct request *req;	203	struct request *req;
202	int write = (data_direction == DMA_TO_DEVICE);	204	int write = (data_direction == DMA_TO_DEVICE);
203	int ret = DRIVER_ERROR << 24;	205	int ret = DRIVER_ERROR << 24;
204		206
205	req = blk_get_request(sdev->request_queue, write, __GFP_WAIT);	207	req = blk_get_request(sdev->request_queue, write, __GFP_WAIT);
206	if (!req)	208	if (!req)
207	return ret;	209	return ret;
208	blk_rq_set_block_pc(req);	210	blk_rq_set_block_pc(req);
209		211
210	if (bufflen && blk_rq_map_kern(sdev->request_queue, req,	212	if (bufflen && blk_rq_map_kern(sdev->request_queue, req,
211	buffer, bufflen, __GFP_WAIT))	213	buffer, bufflen, __GFP_WAIT))
212	goto out;	214	goto out;
213		215
214	req->cmd_len = COMMAND_SIZE(cmd[0]);	216	req->cmd_len = COMMAND_SIZE(cmd[0]);
215	memcpy(req->cmd, cmd, req->cmd_len);	217	memcpy(req->cmd, cmd, req->cmd_len);
216	req->sense = sense;	218	req->sense = sense;
217	req->sense_len = 0;	219	req->sense_len = 0;
218	req->retries = retries;	220	req->retries = retries;
219	req->timeout = timeout;	221	req->timeout = timeout;
220	req->cmd_flags \|= flags \| REQ_QUIET \| REQ_PREEMPT;	222	req->cmd_flags \|= flags \| REQ_QUIET \| REQ_PREEMPT;
221		223
222	/*	224	/*
223	* head injection required here otherwise quiesce won't work	225	* head injection required here otherwise quiesce won't work
224	*/	226	*/
225	blk_execute_rq(req->q, NULL, req, 1);	227	blk_execute_rq(req->q, NULL, req, 1);
226		228
227	/*	229	/*
228	* Some devices (USB mass-storage in particular) may transfer	230	* Some devices (USB mass-storage in particular) may transfer
229	* garbage data together with a residue indicating that the data	231	* garbage data together with a residue indicating that the data
230	* is invalid. Prevent the garbage from being misinterpreted	232	* is invalid. Prevent the garbage from being misinterpreted
231	* and prevent security leaks by zeroing out the excess data.	233	* and prevent security leaks by zeroing out the excess data.
232	*/	234	*/
233	if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen))	235	if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen))
234	memset(buffer + (bufflen - req->resid_len), 0, req->resid_len);	236	memset(buffer + (bufflen - req->resid_len), 0, req->resid_len);
235		237
236	if (resid)	238	if (resid)
237	*resid = req->resid_len;	239	*resid = req->resid_len;
238	ret = req->errors;	240	ret = req->errors;
239	out:	241	out:
240	blk_put_request(req);	242	blk_put_request(req);
241		243
242	return ret;	244	return ret;
243	}	245	}
244	EXPORT_SYMBOL(scsi_execute);	246	EXPORT_SYMBOL(scsi_execute);
245		247
246	int scsi_execute_req_flags(struct scsi_device sdev, const unsigned char cmd,	248	int scsi_execute_req_flags(struct scsi_device sdev, const unsigned char cmd,
247	int data_direction, void *buffer, unsigned bufflen,	249	int data_direction, void *buffer, unsigned bufflen,
248	struct scsi_sense_hdr *sshdr, int timeout, int retries,	250	struct scsi_sense_hdr *sshdr, int timeout, int retries,
249	int *resid, u64 flags)	251	int *resid, u64 flags)
250	{	252	{
251	char *sense = NULL;	253	char *sense = NULL;
252	int result;	254	int result;
253		255
254	if (sshdr) {	256	if (sshdr) {
255	sense = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);	257	sense = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
256	if (!sense)	258	if (!sense)
257	return DRIVER_ERROR << 24;	259	return DRIVER_ERROR << 24;
258	}	260	}
259	result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen,	261	result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen,
260	sense, timeout, retries, flags, resid);	262	sense, timeout, retries, flags, resid);
261	if (sshdr)	263	if (sshdr)
262	scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, sshdr);	264	scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, sshdr);
263		265
264	kfree(sense);	266	kfree(sense);
265	return result;	267	return result;
266	}	268	}
267	EXPORT_SYMBOL(scsi_execute_req_flags);	269	EXPORT_SYMBOL(scsi_execute_req_flags);
268		270
269	/*	271	/*
270	* Function: scsi_init_cmd_errh()	272	* Function: scsi_init_cmd_errh()
271	*	273	*
272	* Purpose: Initialize cmd fields related to error handling.	274	* Purpose: Initialize cmd fields related to error handling.
273	*	275	*
274	* Arguments: cmd - command that is ready to be queued.	276	* Arguments: cmd - command that is ready to be queued.
275	*	277	*
276	* Notes: This function has the job of initializing a number of	278	* Notes: This function has the job of initializing a number of
277	* fields related to error handling. Typically this will	279	* fields related to error handling. Typically this will
278	* be called once for each command, as required.	280	* be called once for each command, as required.
279	*/	281	*/
280	static void scsi_init_cmd_errh(struct scsi_cmnd *cmd)	282	static void scsi_init_cmd_errh(struct scsi_cmnd *cmd)
281	{	283	{
282	cmd->serial_number = 0;	284	cmd->serial_number = 0;
283	scsi_set_resid(cmd, 0);	285	scsi_set_resid(cmd, 0);
284	memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);	286	memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
285	if (cmd->cmd_len == 0)	287	if (cmd->cmd_len == 0)
286	cmd->cmd_len = scsi_command_size(cmd->cmnd);	288	cmd->cmd_len = scsi_command_size(cmd->cmnd);
287	}	289	}
288		290
289	void scsi_device_unbusy(struct scsi_device *sdev)	291	void scsi_device_unbusy(struct scsi_device *sdev)
290	{	292	{
291	struct Scsi_Host *shost = sdev->host;	293	struct Scsi_Host *shost = sdev->host;
292	struct scsi_target *starget = scsi_target(sdev);	294	struct scsi_target *starget = scsi_target(sdev);
293	unsigned long flags;	295	unsigned long flags;
294		296
295	atomic_dec(&shost->host_busy);	297	atomic_dec(&shost->host_busy);
296	atomic_dec(&starget->target_busy);	298	atomic_dec(&starget->target_busy);
297		299
298	if (unlikely(scsi_host_in_recovery(shost) &&	300	if (unlikely(scsi_host_in_recovery(shost) &&
299	(shost->host_failed \|\| shost->host_eh_scheduled))) {	301	(shost->host_failed \|\| shost->host_eh_scheduled))) {
300	spin_lock_irqsave(shost->host_lock, flags);	302	spin_lock_irqsave(shost->host_lock, flags);
301	scsi_eh_wakeup(shost);	303	scsi_eh_wakeup(shost);
302	spin_unlock_irqrestore(shost->host_lock, flags);	304	spin_unlock_irqrestore(shost->host_lock, flags);
303	}	305	}
304		306
305	atomic_dec(&sdev->device_busy);	307	atomic_dec(&sdev->device_busy);
306	}	308	}
307		309
308	/*	310	/*
309	* Called for single_lun devices on IO completion. Clear starget_sdev_user,	311	* Called for single_lun devices on IO completion. Clear starget_sdev_user,
310	* and call blk_run_queue for all the scsi_devices on the target -	312	* and call blk_run_queue for all the scsi_devices on the target -
311	* including current_sdev first.	313	* including current_sdev first.
312	*	314	*
313	* Called with no scsi locks held.	315	* Called with no scsi locks held.
314	*/	316	*/
315	static void scsi_single_lun_run(struct scsi_device *current_sdev)	317	static void scsi_single_lun_run(struct scsi_device *current_sdev)
316	{	318	{
317	struct Scsi_Host *shost = current_sdev->host;	319	struct Scsi_Host *shost = current_sdev->host;
318	struct scsi_device sdev, tmp;	320	struct scsi_device sdev, tmp;
319	struct scsi_target *starget = scsi_target(current_sdev);	321	struct scsi_target *starget = scsi_target(current_sdev);
320	unsigned long flags;	322	unsigned long flags;
321		323
322	spin_lock_irqsave(shost->host_lock, flags);	324	spin_lock_irqsave(shost->host_lock, flags);
323	starget->starget_sdev_user = NULL;	325	starget->starget_sdev_user = NULL;
324	spin_unlock_irqrestore(shost->host_lock, flags);	326	spin_unlock_irqrestore(shost->host_lock, flags);
325		327
326	/*	328	/*
327	* Call blk_run_queue for all LUNs on the target, starting with	329	* Call blk_run_queue for all LUNs on the target, starting with
328	* current_sdev. We race with others (to set starget_sdev_user),	330	* current_sdev. We race with others (to set starget_sdev_user),
329	* but in most cases, we will be first. Ideally, each LU on the	331	* but in most cases, we will be first. Ideally, each LU on the
330	* target would get some limited time or requests on the target.	332	* target would get some limited time or requests on the target.
331	*/	333	*/
332	blk_run_queue(current_sdev->request_queue);	334	blk_run_queue(current_sdev->request_queue);
333		335
334	spin_lock_irqsave(shost->host_lock, flags);	336	spin_lock_irqsave(shost->host_lock, flags);
335	if (starget->starget_sdev_user)	337	if (starget->starget_sdev_user)
336	goto out;	338	goto out;
337	list_for_each_entry_safe(sdev, tmp, &starget->devices,	339	list_for_each_entry_safe(sdev, tmp, &starget->devices,
338	same_target_siblings) {	340	same_target_siblings) {
339	if (sdev == current_sdev)	341	if (sdev == current_sdev)
340	continue;	342	continue;
341	if (scsi_device_get(sdev))	343	if (scsi_device_get(sdev))
342	continue;	344	continue;
343		345
344	spin_unlock_irqrestore(shost->host_lock, flags);	346	spin_unlock_irqrestore(shost->host_lock, flags);
345	blk_run_queue(sdev->request_queue);	347	blk_run_queue(sdev->request_queue);
346	spin_lock_irqsave(shost->host_lock, flags);	348	spin_lock_irqsave(shost->host_lock, flags);
347		349
348	scsi_device_put(sdev);	350	scsi_device_put(sdev);
349	}	351	}
350	out:	352	out:
351	spin_unlock_irqrestore(shost->host_lock, flags);	353	spin_unlock_irqrestore(shost->host_lock, flags);
352	}	354	}
353		355
354	static inline int scsi_device_is_busy(struct scsi_device *sdev)	356	static inline bool scsi_device_is_busy(struct scsi_device *sdev)
355	{	357	{
356	if (atomic_read(&sdev->device_busy) >= sdev->queue_depth \|\|	358	if (atomic_read(&sdev->device_busy) >= sdev->queue_depth)
357	sdev->device_blocked)	359	return true;
358	return 1;	360	if (atomic_read(&sdev->device_blocked) > 0)
359	return 0;	361	return true;
		362	return false;
360	}	363	}
361		364
362	static inline int scsi_target_is_busy(struct scsi_target *starget)	365	static inline bool scsi_target_is_busy(struct scsi_target *starget)
363	{	366	{
364	return ((starget->can_queue > 0 &&	367	if (starget->can_queue > 0 &&
365	atomic_read(&starget->target_busy) >= starget->can_queue) \|\|	368	atomic_read(&starget->target_busy) >= starget->can_queue)
366	starget->target_blocked);	369	return true;
		370	if (atomic_read(&starget->target_blocked) > 0)
		371	return true;
		372	return false;
367	}	373	}
368		374
369	static inline int scsi_host_is_busy(struct Scsi_Host *shost)	375	static inline bool scsi_host_is_busy(struct Scsi_Host *shost)
370	{	376	{
371	if ((shost->can_queue > 0 &&	377	if (shost->can_queue > 0 &&
372	atomic_read(&shost->host_busy) >= shost->can_queue) \|\|	378	atomic_read(&shost->host_busy) >= shost->can_queue)
373	shost->host_blocked \|\| shost->host_self_blocked)	379	return true;
374	return 1;	380	if (atomic_read(&shost->host_blocked) > 0)
375		381	return true;
376	return 0;	382	if (shost->host_self_blocked)
		383	return true;
		384	return false;
377	}	385	}
378		386
379	static void scsi_starved_list_run(struct Scsi_Host *shost)	387	static void scsi_starved_list_run(struct Scsi_Host *shost)
380	{	388	{
381	LIST_HEAD(starved_list);	389	LIST_HEAD(starved_list);
382	struct scsi_device *sdev;	390	struct scsi_device *sdev;
383	unsigned long flags;	391	unsigned long flags;
384		392
385	spin_lock_irqsave(shost->host_lock, flags);	393	spin_lock_irqsave(shost->host_lock, flags);
386	list_splice_init(&shost->starved_list, &starved_list);	394	list_splice_init(&shost->starved_list, &starved_list);
387		395
388	while (!list_empty(&starved_list)) {	396	while (!list_empty(&starved_list)) {
389	struct request_queue *slq;	397	struct request_queue *slq;
390		398
391	/*	399	/*
392	* As long as shost is accepting commands and we have	400	* As long as shost is accepting commands and we have
393	* starved queues, call blk_run_queue. scsi_request_fn	401	* starved queues, call blk_run_queue. scsi_request_fn
394	* drops the queue_lock and can add us back to the	402	* drops the queue_lock and can add us back to the
395	* starved_list.	403	* starved_list.
396	*	404	*
397	* host_lock protects the starved_list and starved_entry.	405	* host_lock protects the starved_list and starved_entry.
398	* scsi_request_fn must get the host_lock before checking	406	* scsi_request_fn must get the host_lock before checking
399	* or modifying starved_list or starved_entry.	407	* or modifying starved_list or starved_entry.
400	*/	408	*/
401	if (scsi_host_is_busy(shost))	409	if (scsi_host_is_busy(shost))
402	break;	410	break;
403		411
404	sdev = list_entry(starved_list.next,	412	sdev = list_entry(starved_list.next,
405	struct scsi_device, starved_entry);	413	struct scsi_device, starved_entry);
406	list_del_init(&sdev->starved_entry);	414	list_del_init(&sdev->starved_entry);
407	if (scsi_target_is_busy(scsi_target(sdev))) {	415	if (scsi_target_is_busy(scsi_target(sdev))) {
408	list_move_tail(&sdev->starved_entry,	416	list_move_tail(&sdev->starved_entry,
409	&shost->starved_list);	417	&shost->starved_list);
410	continue;	418	continue;
411	}	419	}
412		420
413	/*	421	/*
414	* Once we drop the host lock, a racing scsi_remove_device()	422	* Once we drop the host lock, a racing scsi_remove_device()
415	* call may remove the sdev from the starved list and destroy	423	* call may remove the sdev from the starved list and destroy
416	* it and the queue. Mitigate by taking a reference to the	424	* it and the queue. Mitigate by taking a reference to the
417	* queue and never touching the sdev again after we drop the	425	* queue and never touching the sdev again after we drop the
418	* host lock. Note: if __scsi_remove_device() invokes	426	* host lock. Note: if __scsi_remove_device() invokes
419	* blk_cleanup_queue() before the queue is run from this	427	* blk_cleanup_queue() before the queue is run from this
420	* function then blk_run_queue() will return immediately since	428	* function then blk_run_queue() will return immediately since
421	* blk_cleanup_queue() marks the queue with QUEUE_FLAG_DYING.	429	* blk_cleanup_queue() marks the queue with QUEUE_FLAG_DYING.
422	*/	430	*/
423	slq = sdev->request_queue;	431	slq = sdev->request_queue;
424	if (!blk_get_queue(slq))	432	if (!blk_get_queue(slq))
425	continue;	433	continue;
426	spin_unlock_irqrestore(shost->host_lock, flags);	434	spin_unlock_irqrestore(shost->host_lock, flags);
427		435
428	blk_run_queue(slq);	436	blk_run_queue(slq);
429	blk_put_queue(slq);	437	blk_put_queue(slq);
430		438
431	spin_lock_irqsave(shost->host_lock, flags);	439	spin_lock_irqsave(shost->host_lock, flags);
432	}	440	}
433	/* put any unprocessed entries back */	441	/* put any unprocessed entries back */
434	list_splice(&starved_list, &shost->starved_list);	442	list_splice(&starved_list, &shost->starved_list);
435	spin_unlock_irqrestore(shost->host_lock, flags);	443	spin_unlock_irqrestore(shost->host_lock, flags);
436	}	444	}
437		445
438	/*	446	/*
439	* Function: scsi_run_queue()	447	* Function: scsi_run_queue()
440	*	448	*
441	* Purpose: Select a proper request queue to serve next	449	* Purpose: Select a proper request queue to serve next
442	*	450	*
443	* Arguments: q - last request's queue	451	* Arguments: q - last request's queue
444	*	452	*
445	* Returns: Nothing	453	* Returns: Nothing
446	*	454	*
447	* Notes: The previous command was completely finished, start	455	* Notes: The previous command was completely finished, start
448	* a new one if possible.	456	* a new one if possible.
449	*/	457	*/
450	static void scsi_run_queue(struct request_queue *q)	458	static void scsi_run_queue(struct request_queue *q)
451	{	459	{
452	struct scsi_device *sdev = q->queuedata;	460	struct scsi_device *sdev = q->queuedata;
453		461
454	if (scsi_target(sdev)->single_lun)	462	if (scsi_target(sdev)->single_lun)
455	scsi_single_lun_run(sdev);	463	scsi_single_lun_run(sdev);
456	if (!list_empty(&sdev->host->starved_list))	464	if (!list_empty(&sdev->host->starved_list))
457	scsi_starved_list_run(sdev->host);	465	scsi_starved_list_run(sdev->host);
458		466
459	blk_run_queue(q);	467	blk_run_queue(q);
460	}	468	}
461		469
462	void scsi_requeue_run_queue(struct work_struct *work)	470	void scsi_requeue_run_queue(struct work_struct *work)
463	{	471	{
464	struct scsi_device *sdev;	472	struct scsi_device *sdev;
465	struct request_queue *q;	473	struct request_queue *q;
466		474
467	sdev = container_of(work, struct scsi_device, requeue_work);	475	sdev = container_of(work, struct scsi_device, requeue_work);
468	q = sdev->request_queue;	476	q = sdev->request_queue;
469	scsi_run_queue(q);	477	scsi_run_queue(q);
470	}	478	}
471		479
472	/*	480	/*
473	* Function: scsi_requeue_command()	481	* Function: scsi_requeue_command()
474	*	482	*
475	* Purpose: Handle post-processing of completed commands.	483	* Purpose: Handle post-processing of completed commands.
476	*	484	*
477	* Arguments: q - queue to operate on	485	* Arguments: q - queue to operate on
478	* cmd - command that may need to be requeued.	486	* cmd - command that may need to be requeued.
479	*	487	*
480	* Returns: Nothing	488	* Returns: Nothing
481	*	489	*
482	* Notes: After command completion, there may be blocks left	490	* Notes: After command completion, there may be blocks left
483	* over which weren't finished by the previous command	491	* over which weren't finished by the previous command
484	* this can be for a number of reasons - the main one is	492	* this can be for a number of reasons - the main one is
485	* I/O errors in the middle of the request, in which case	493	* I/O errors in the middle of the request, in which case
486	* we need to request the blocks that come after the bad	494	* we need to request the blocks that come after the bad
487	* sector.	495	* sector.
488	* Notes: Upon return, cmd is a stale pointer.	496	* Notes: Upon return, cmd is a stale pointer.
489	*/	497	*/
490	static void scsi_requeue_command(struct request_queue q, struct scsi_cmnd cmd)	498	static void scsi_requeue_command(struct request_queue q, struct scsi_cmnd cmd)
491	{	499	{
492	struct scsi_device *sdev = cmd->device;	500	struct scsi_device *sdev = cmd->device;
493	struct request *req = cmd->request;	501	struct request *req = cmd->request;
494	unsigned long flags;	502	unsigned long flags;
495		503
496	spin_lock_irqsave(q->queue_lock, flags);	504	spin_lock_irqsave(q->queue_lock, flags);
497	blk_unprep_request(req);	505	blk_unprep_request(req);
498	req->special = NULL;	506	req->special = NULL;
499	scsi_put_command(cmd);	507	scsi_put_command(cmd);
500	blk_requeue_request(q, req);	508	blk_requeue_request(q, req);
501	spin_unlock_irqrestore(q->queue_lock, flags);	509	spin_unlock_irqrestore(q->queue_lock, flags);
502		510
503	scsi_run_queue(q);	511	scsi_run_queue(q);
504		512
505	put_device(&sdev->sdev_gendev);	513	put_device(&sdev->sdev_gendev);
506	}	514	}
507		515
508	void scsi_next_command(struct scsi_cmnd *cmd)	516	void scsi_next_command(struct scsi_cmnd *cmd)
509	{	517	{
510	struct scsi_device *sdev = cmd->device;	518	struct scsi_device *sdev = cmd->device;
511	struct request_queue *q = sdev->request_queue;	519	struct request_queue *q = sdev->request_queue;
512		520
513	scsi_put_command(cmd);	521	scsi_put_command(cmd);
514	scsi_run_queue(q);	522	scsi_run_queue(q);
515		523
516	put_device(&sdev->sdev_gendev);	524	put_device(&sdev->sdev_gendev);
517	}	525	}
518		526
519	void scsi_run_host_queues(struct Scsi_Host *shost)	527	void scsi_run_host_queues(struct Scsi_Host *shost)
520	{	528	{
521	struct scsi_device *sdev;	529	struct scsi_device *sdev;
522		530
523	shost_for_each_device(sdev, shost)	531	shost_for_each_device(sdev, shost)
524	scsi_run_queue(sdev->request_queue);	532	scsi_run_queue(sdev->request_queue);
525	}	533	}
526		534
527	static inline unsigned int scsi_sgtable_index(unsigned short nents)	535	static inline unsigned int scsi_sgtable_index(unsigned short nents)
528	{	536	{
529	unsigned int index;	537	unsigned int index;
530		538
531	BUG_ON(nents > SCSI_MAX_SG_SEGMENTS);	539	BUG_ON(nents > SCSI_MAX_SG_SEGMENTS);
532		540
533	if (nents <= 8)	541	if (nents <= 8)
534	index = 0;	542	index = 0;
535	else	543	else
536	index = get_count_order(nents) - 3;	544	index = get_count_order(nents) - 3;
537		545
538	return index;	546	return index;
539	}	547	}
540		548
541	static void scsi_sg_free(struct scatterlist *sgl, unsigned int nents)	549	static void scsi_sg_free(struct scatterlist *sgl, unsigned int nents)
542	{	550	{
543	struct scsi_host_sg_pool *sgp;	551	struct scsi_host_sg_pool *sgp;
544		552
545	sgp = scsi_sg_pools + scsi_sgtable_index(nents);	553	sgp = scsi_sg_pools + scsi_sgtable_index(nents);
546	mempool_free(sgl, sgp->pool);	554	mempool_free(sgl, sgp->pool);
547	}	555	}
548		556
549	static struct scatterlist *scsi_sg_alloc(unsigned int nents, gfp_t gfp_mask)	557	static struct scatterlist *scsi_sg_alloc(unsigned int nents, gfp_t gfp_mask)
550	{	558	{
551	struct scsi_host_sg_pool *sgp;	559	struct scsi_host_sg_pool *sgp;
552		560
553	sgp = scsi_sg_pools + scsi_sgtable_index(nents);	561	sgp = scsi_sg_pools + scsi_sgtable_index(nents);
554	return mempool_alloc(sgp->pool, gfp_mask);	562	return mempool_alloc(sgp->pool, gfp_mask);
555	}	563	}
556		564
557	static int scsi_alloc_sgtable(struct scsi_data_buffer *sdb, int nents,	565	static int scsi_alloc_sgtable(struct scsi_data_buffer *sdb, int nents,
558	gfp_t gfp_mask)	566	gfp_t gfp_mask)
559	{	567	{
560	int ret;	568	int ret;
561		569
562	BUG_ON(!nents);	570	BUG_ON(!nents);
563		571
564	ret = __sg_alloc_table(&sdb->table, nents, SCSI_MAX_SG_SEGMENTS,	572	ret = __sg_alloc_table(&sdb->table, nents, SCSI_MAX_SG_SEGMENTS,
565	gfp_mask, scsi_sg_alloc);	573	gfp_mask, scsi_sg_alloc);
566	if (unlikely(ret))	574	if (unlikely(ret))
567	__sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS,	575	__sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS,
568	scsi_sg_free);	576	scsi_sg_free);
569		577
570	return ret;	578	return ret;
571	}	579	}
572		580
573	static void scsi_free_sgtable(struct scsi_data_buffer *sdb)	581	static void scsi_free_sgtable(struct scsi_data_buffer *sdb)
574	{	582	{
575	__sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS, scsi_sg_free);	583	__sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS, scsi_sg_free);
576	}	584	}
577		585
578	/*	586	/*
579	* Function: scsi_release_buffers()	587	* Function: scsi_release_buffers()
580	*	588	*
581	* Purpose: Free resources allocate for a scsi_command.	589	* Purpose: Free resources allocate for a scsi_command.
582	*	590	*
583	* Arguments: cmd - command that we are bailing.	591	* Arguments: cmd - command that we are bailing.
584	*	592	*
585	* Lock status: Assumed that no lock is held upon entry.	593	* Lock status: Assumed that no lock is held upon entry.
586	*	594	*
587	* Returns: Nothing	595	* Returns: Nothing
588	*	596	*
589	* Notes: In the event that an upper level driver rejects a	597	* Notes: In the event that an upper level driver rejects a
590	* command, we must release resources allocated during	598	* command, we must release resources allocated during
591	* the __init_io() function. Primarily this would involve	599	* the __init_io() function. Primarily this would involve
592	* the scatter-gather table.	600	* the scatter-gather table.
593	*/	601	*/
594	static void scsi_release_buffers(struct scsi_cmnd *cmd)	602	static void scsi_release_buffers(struct scsi_cmnd *cmd)
595	{	603	{
596	if (cmd->sdb.table.nents)	604	if (cmd->sdb.table.nents)
597	scsi_free_sgtable(&cmd->sdb);	605	scsi_free_sgtable(&cmd->sdb);
598		606
599	memset(&cmd->sdb, 0, sizeof(cmd->sdb));	607	memset(&cmd->sdb, 0, sizeof(cmd->sdb));
600		608
601	if (scsi_prot_sg_count(cmd))	609	if (scsi_prot_sg_count(cmd))
602	scsi_free_sgtable(cmd->prot_sdb);	610	scsi_free_sgtable(cmd->prot_sdb);
603	}	611	}
604		612
605	static void scsi_release_bidi_buffers(struct scsi_cmnd *cmd)	613	static void scsi_release_bidi_buffers(struct scsi_cmnd *cmd)
606	{	614	{
607	struct scsi_data_buffer *bidi_sdb = cmd->request->next_rq->special;	615	struct scsi_data_buffer *bidi_sdb = cmd->request->next_rq->special;
608		616
609	scsi_free_sgtable(bidi_sdb);	617	scsi_free_sgtable(bidi_sdb);
610	kmem_cache_free(scsi_sdb_cache, bidi_sdb);	618	kmem_cache_free(scsi_sdb_cache, bidi_sdb);
611	cmd->request->next_rq->special = NULL;	619	cmd->request->next_rq->special = NULL;
612	}	620	}
613		621
614	/**	622	/**
615	* __scsi_error_from_host_byte - translate SCSI error code into errno	623	* __scsi_error_from_host_byte - translate SCSI error code into errno
616	* @cmd: SCSI command (unused)	624	* @cmd: SCSI command (unused)
617	* @result: scsi error code	625	* @result: scsi error code
618	*	626	*
619	* Translate SCSI error code into standard UNIX errno.	627	* Translate SCSI error code into standard UNIX errno.
620	* Return values:	628	* Return values:
621	* -ENOLINK temporary transport failure	629	* -ENOLINK temporary transport failure
622	* -EREMOTEIO permanent target failure, do not retry	630	* -EREMOTEIO permanent target failure, do not retry
623	* -EBADE permanent nexus failure, retry on other path	631	* -EBADE permanent nexus failure, retry on other path
624	* -ENOSPC No write space available	632	* -ENOSPC No write space available
625	* -ENODATA Medium error	633	* -ENODATA Medium error
626	* -EIO unspecified I/O error	634	* -EIO unspecified I/O error
627	*/	635	*/
628	static int __scsi_error_from_host_byte(struct scsi_cmnd *cmd, int result)	636	static int __scsi_error_from_host_byte(struct scsi_cmnd *cmd, int result)
629	{	637	{
630	int error = 0;	638	int error = 0;
631		639
632	switch(host_byte(result)) {	640	switch(host_byte(result)) {
633	case DID_TRANSPORT_FAILFAST:	641	case DID_TRANSPORT_FAILFAST:
634	error = -ENOLINK;	642	error = -ENOLINK;
635	break;	643	break;
636	case DID_TARGET_FAILURE:	644	case DID_TARGET_FAILURE:
637	set_host_byte(cmd, DID_OK);	645	set_host_byte(cmd, DID_OK);
638	error = -EREMOTEIO;	646	error = -EREMOTEIO;
639	break;	647	break;
640	case DID_NEXUS_FAILURE:	648	case DID_NEXUS_FAILURE:
641	set_host_byte(cmd, DID_OK);	649	set_host_byte(cmd, DID_OK);
642	error = -EBADE;	650	error = -EBADE;
643	break;	651	break;
644	case DID_ALLOC_FAILURE:	652	case DID_ALLOC_FAILURE:
645	set_host_byte(cmd, DID_OK);	653	set_host_byte(cmd, DID_OK);
646	error = -ENOSPC;	654	error = -ENOSPC;
647	break;	655	break;
648	case DID_MEDIUM_ERROR:	656	case DID_MEDIUM_ERROR:
649	set_host_byte(cmd, DID_OK);	657	set_host_byte(cmd, DID_OK);
650	error = -ENODATA;	658	error = -ENODATA;
651	break;	659	break;
652	default:	660	default:
653	error = -EIO;	661	error = -EIO;
654	break;	662	break;
655	}	663	}
656		664
657	return error;	665	return error;
658	}	666	}
659		667
660	/*	668	/*
661	* Function: scsi_io_completion()	669	* Function: scsi_io_completion()
662	*	670	*
663	* Purpose: Completion processing for block device I/O requests.	671	* Purpose: Completion processing for block device I/O requests.
664	*	672	*
665	* Arguments: cmd - command that is finished.	673	* Arguments: cmd - command that is finished.
666	*	674	*
667	* Lock status: Assumed that no lock is held upon entry.	675	* Lock status: Assumed that no lock is held upon entry.
668	*	676	*
669	* Returns: Nothing	677	* Returns: Nothing
670	*	678	*
671	* Notes: We will finish off the specified number of sectors. If we	679	* Notes: We will finish off the specified number of sectors. If we
672	* are done, the command block will be released and the queue	680	* are done, the command block will be released and the queue
673	* function will be goosed. If we are not done then we have to	681	* function will be goosed. If we are not done then we have to
674	* figure out what to do next:	682	* figure out what to do next:
675	*	683	*
676	* a) We can call scsi_requeue_command(). The request	684	* a) We can call scsi_requeue_command(). The request
677	* will be unprepared and put back on the queue. Then	685	* will be unprepared and put back on the queue. Then
678	* a new command will be created for it. This should	686	* a new command will be created for it. This should
679	* be used if we made forward progress, or if we want	687	* be used if we made forward progress, or if we want
680	* to switch from READ(10) to READ(6) for example.	688	* to switch from READ(10) to READ(6) for example.
681	*	689	*
682	* b) We can call __scsi_queue_insert(). The request will	690	* b) We can call __scsi_queue_insert(). The request will
683	* be put back on the queue and retried using the same	691	* be put back on the queue and retried using the same
684	* command as before, possibly after a delay.	692	* command as before, possibly after a delay.
685	*	693	*
686	* c) We can call blk_end_request() with -EIO to fail	694	* c) We can call blk_end_request() with -EIO to fail
687	* the remainder of the request.	695	* the remainder of the request.
688	*/	696	*/
689	void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)	697	void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
690	{	698	{
691	int result = cmd->result;	699	int result = cmd->result;
692	struct request_queue *q = cmd->device->request_queue;	700	struct request_queue *q = cmd->device->request_queue;
693	struct request *req = cmd->request;	701	struct request *req = cmd->request;
694	int error = 0;	702	int error = 0;
695	struct scsi_sense_hdr sshdr;	703	struct scsi_sense_hdr sshdr;
696	int sense_valid = 0;	704	int sense_valid = 0;
697	int sense_deferred = 0;	705	int sense_deferred = 0;
698	enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY,	706	enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY,
699	ACTION_DELAYED_RETRY} action;	707	ACTION_DELAYED_RETRY} action;
700	unsigned long wait_for = (cmd->allowed + 1) * req->timeout;	708	unsigned long wait_for = (cmd->allowed + 1) * req->timeout;
701		709
702	if (result) {	710	if (result) {
703	sense_valid = scsi_command_normalize_sense(cmd, &sshdr);	711	sense_valid = scsi_command_normalize_sense(cmd, &sshdr);
704	if (sense_valid)	712	if (sense_valid)
705	sense_deferred = scsi_sense_is_deferred(&sshdr);	713	sense_deferred = scsi_sense_is_deferred(&sshdr);
706	}	714	}
707		715
708	if (req->cmd_type == REQ_TYPE_BLOCK_PC) { /* SG_IO ioctl from block level */	716	if (req->cmd_type == REQ_TYPE_BLOCK_PC) { /* SG_IO ioctl from block level */
709	if (result) {	717	if (result) {
710	if (sense_valid && req->sense) {	718	if (sense_valid && req->sense) {
711	/*	719	/*
712	* SG_IO wants current and deferred errors	720	* SG_IO wants current and deferred errors
713	*/	721	*/
714	int len = 8 + cmd->sense_buffer[7];	722	int len = 8 + cmd->sense_buffer[7];
715		723
716	if (len > SCSI_SENSE_BUFFERSIZE)	724	if (len > SCSI_SENSE_BUFFERSIZE)
717	len = SCSI_SENSE_BUFFERSIZE;	725	len = SCSI_SENSE_BUFFERSIZE;
718	memcpy(req->sense, cmd->sense_buffer, len);	726	memcpy(req->sense, cmd->sense_buffer, len);
719	req->sense_len = len;	727	req->sense_len = len;
720	}	728	}
721	if (!sense_deferred)	729	if (!sense_deferred)
722	error = __scsi_error_from_host_byte(cmd, result);	730	error = __scsi_error_from_host_byte(cmd, result);
723	}	731	}
724	/*	732	/*
725	* __scsi_error_from_host_byte may have reset the host_byte	733	* __scsi_error_from_host_byte may have reset the host_byte
726	*/	734	*/
727	req->errors = cmd->result;	735	req->errors = cmd->result;
728		736
729	req->resid_len = scsi_get_resid(cmd);	737	req->resid_len = scsi_get_resid(cmd);
730		738
731	if (scsi_bidi_cmnd(cmd)) {	739	if (scsi_bidi_cmnd(cmd)) {
732	/*	740	/*
733	* Bidi commands Must be complete as a whole,	741	* Bidi commands Must be complete as a whole,
734	* both sides at once.	742	* both sides at once.
735	*/	743	*/
736	req->next_rq->resid_len = scsi_in(cmd)->resid;	744	req->next_rq->resid_len = scsi_in(cmd)->resid;
737		745
738	scsi_release_buffers(cmd);	746	scsi_release_buffers(cmd);
739	scsi_release_bidi_buffers(cmd);	747	scsi_release_bidi_buffers(cmd);
740		748
741	blk_end_request_all(req, 0);	749	blk_end_request_all(req, 0);
742		750
743	scsi_next_command(cmd);	751	scsi_next_command(cmd);
744	return;	752	return;
745	}	753	}
746	} else if (blk_rq_bytes(req) == 0 && result && !sense_deferred) {	754	} else if (blk_rq_bytes(req) == 0 && result && !sense_deferred) {
747	/*	755	/*
748	* Certain non BLOCK_PC requests are commands that don't	756	* Certain non BLOCK_PC requests are commands that don't
749	* actually transfer anything (FLUSH), so cannot use	757	* actually transfer anything (FLUSH), so cannot use
750	* good_bytes != blk_rq_bytes(req) as the signal for an error.	758	* good_bytes != blk_rq_bytes(req) as the signal for an error.
751	* This sets the error explicitly for the problem case.	759	* This sets the error explicitly for the problem case.
752	*/	760	*/
753	error = __scsi_error_from_host_byte(cmd, result);	761	error = __scsi_error_from_host_byte(cmd, result);
754	}	762	}
755		763
756	/* no bidi support for !REQ_TYPE_BLOCK_PC yet */	764	/* no bidi support for !REQ_TYPE_BLOCK_PC yet */
757	BUG_ON(blk_bidi_rq(req));	765	BUG_ON(blk_bidi_rq(req));
758		766
759	/*	767	/*
760	* Next deal with any sectors which we were able to correctly	768	* Next deal with any sectors which we were able to correctly
761	* handle.	769	* handle.
762	*/	770	*/
763	SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, cmd,	771	SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, cmd,
764	"%u sectors total, %d bytes done.\n",	772	"%u sectors total, %d bytes done.\n",
765	blk_rq_sectors(req), good_bytes));	773	blk_rq_sectors(req), good_bytes));
766		774
767	/*	775	/*
768	* Recovered errors need reporting, but they're always treated	776	* Recovered errors need reporting, but they're always treated
769	* as success, so fiddle the result code here. For BLOCK_PC	777	* as success, so fiddle the result code here. For BLOCK_PC
770	* we already took a copy of the original into rq->errors which	778	* we already took a copy of the original into rq->errors which
771	* is what gets returned to the user	779	* is what gets returned to the user
772	*/	780	*/
773	if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) {	781	if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) {
774	/* if ATA PASS-THROUGH INFORMATION AVAILABLE skip	782	/* if ATA PASS-THROUGH INFORMATION AVAILABLE skip
775	* print since caller wants ATA registers. Only occurs on	783	* print since caller wants ATA registers. Only occurs on
776	* SCSI ATA PASS_THROUGH commands when CK_COND=1	784	* SCSI ATA PASS_THROUGH commands when CK_COND=1
777	*/	785	*/
778	if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))	786	if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
779	;	787	;
780	else if (!(req->cmd_flags & REQ_QUIET))	788	else if (!(req->cmd_flags & REQ_QUIET))
781	scsi_print_sense("", cmd);	789	scsi_print_sense("", cmd);
782	result = 0;	790	result = 0;
783	/* BLOCK_PC may have set error */	791	/* BLOCK_PC may have set error */
784	error = 0;	792	error = 0;
785	}	793	}
786		794
787	/*	795	/*
788	* If we finished all bytes in the request we are done now.	796	* If we finished all bytes in the request we are done now.
789	*/	797	*/
790	if (!blk_end_request(req, error, good_bytes))	798	if (!blk_end_request(req, error, good_bytes))
791	goto next_command;	799	goto next_command;
792		800
793	/*	801	/*
794	* Kill remainder if no retrys.	802	* Kill remainder if no retrys.
795	*/	803	*/
796	if (error && scsi_noretry_cmd(cmd)) {	804	if (error && scsi_noretry_cmd(cmd)) {
797	blk_end_request_all(req, error);	805	blk_end_request_all(req, error);
798	goto next_command;	806	goto next_command;
799	}	807	}
800		808
801	/*	809	/*
802	* If there had been no error, but we have leftover bytes in the	810	* If there had been no error, but we have leftover bytes in the
803	* requeues just queue the command up again.	811	* requeues just queue the command up again.
804	*/	812	*/
805	if (result == 0)	813	if (result == 0)
806	goto requeue;	814	goto requeue;
807		815
808	error = __scsi_error_from_host_byte(cmd, result);	816	error = __scsi_error_from_host_byte(cmd, result);
809		817
810	if (host_byte(result) == DID_RESET) {	818	if (host_byte(result) == DID_RESET) {
811	/* Third party bus reset or reset for error recovery	819	/* Third party bus reset or reset for error recovery
812	* reasons. Just retry the command and see what	820	* reasons. Just retry the command and see what
813	* happens.	821	* happens.
814	*/	822	*/
815	action = ACTION_RETRY;	823	action = ACTION_RETRY;
816	} else if (sense_valid && !sense_deferred) {	824	} else if (sense_valid && !sense_deferred) {
817	switch (sshdr.sense_key) {	825	switch (sshdr.sense_key) {
818	case UNIT_ATTENTION:	826	case UNIT_ATTENTION:
819	if (cmd->device->removable) {	827	if (cmd->device->removable) {
820	/* Detected disc change. Set a bit	828	/* Detected disc change. Set a bit
821	* and quietly refuse further access.	829	* and quietly refuse further access.
822	*/	830	*/
823	cmd->device->changed = 1;	831	cmd->device->changed = 1;
824	action = ACTION_FAIL;	832	action = ACTION_FAIL;
825	} else {	833	} else {
826	/* Must have been a power glitch, or a	834	/* Must have been a power glitch, or a
827	* bus reset. Could not have been a	835	* bus reset. Could not have been a
828	* media change, so we just retry the	836	* media change, so we just retry the
829	* command and see what happens.	837	* command and see what happens.
830	*/	838	*/
831	action = ACTION_RETRY;	839	action = ACTION_RETRY;
832	}	840	}
833	break;	841	break;
834	case ILLEGAL_REQUEST:	842	case ILLEGAL_REQUEST:
835	/* If we had an ILLEGAL REQUEST returned, then	843	/* If we had an ILLEGAL REQUEST returned, then
836	* we may have performed an unsupported	844	* we may have performed an unsupported
837	* command. The only thing this should be	845	* command. The only thing this should be
838	* would be a ten byte read where only a six	846	* would be a ten byte read where only a six
839	* byte read was supported. Also, on a system	847	* byte read was supported. Also, on a system
840	* where READ CAPACITY failed, we may have	848	* where READ CAPACITY failed, we may have
841	* read past the end of the disk.	849	* read past the end of the disk.
842	*/	850	*/
843	if ((cmd->device->use_10_for_rw &&	851	if ((cmd->device->use_10_for_rw &&
844	sshdr.asc == 0x20 && sshdr.ascq == 0x00) &&	852	sshdr.asc == 0x20 && sshdr.ascq == 0x00) &&
845	(cmd->cmnd[0] == READ_10 \|\|	853	(cmd->cmnd[0] == READ_10 \|\|
846	cmd->cmnd[0] == WRITE_10)) {	854	cmd->cmnd[0] == WRITE_10)) {
847	/* This will issue a new 6-byte command. */	855	/* This will issue a new 6-byte command. */
848	cmd->device->use_10_for_rw = 0;	856	cmd->device->use_10_for_rw = 0;
849	action = ACTION_REPREP;	857	action = ACTION_REPREP;
850	} else if (sshdr.asc == 0x10) /* DIX */ {	858	} else if (sshdr.asc == 0x10) /* DIX */ {
851	action = ACTION_FAIL;	859	action = ACTION_FAIL;
852	error = -EILSEQ;	860	error = -EILSEQ;
853	/* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */	861	/* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
854	} else if (sshdr.asc == 0x20 \|\| sshdr.asc == 0x24) {	862	} else if (sshdr.asc == 0x20 \|\| sshdr.asc == 0x24) {
855	action = ACTION_FAIL;	863	action = ACTION_FAIL;
856	error = -EREMOTEIO;	864	error = -EREMOTEIO;
857	} else	865	} else
858	action = ACTION_FAIL;	866	action = ACTION_FAIL;
859	break;	867	break;
860	case ABORTED_COMMAND:	868	case ABORTED_COMMAND:
861	action = ACTION_FAIL;	869	action = ACTION_FAIL;
862	if (sshdr.asc == 0x10) /* DIF */	870	if (sshdr.asc == 0x10) /* DIF */
863	error = -EILSEQ;	871	error = -EILSEQ;
864	break;	872	break;
865	case NOT_READY:	873	case NOT_READY:
866	/* If the device is in the process of becoming	874	/* If the device is in the process of becoming
867	* ready, or has a temporary blockage, retry.	875	* ready, or has a temporary blockage, retry.
868	*/	876	*/
869	if (sshdr.asc == 0x04) {	877	if (sshdr.asc == 0x04) {
870	switch (sshdr.ascq) {	878	switch (sshdr.ascq) {
871	case 0x01: /* becoming ready */	879	case 0x01: /* becoming ready */
872	case 0x04: /* format in progress */	880	case 0x04: /* format in progress */
873	case 0x05: /* rebuild in progress */	881	case 0x05: /* rebuild in progress */
874	case 0x06: /* recalculation in progress */	882	case 0x06: /* recalculation in progress */
875	case 0x07: /* operation in progress */	883	case 0x07: /* operation in progress */
876	case 0x08: /* Long write in progress */	884	case 0x08: /* Long write in progress */
877	case 0x09: /* self test in progress */	885	case 0x09: /* self test in progress */
878	case 0x14: /* space allocation in progress */	886	case 0x14: /* space allocation in progress */
879	action = ACTION_DELAYED_RETRY;	887	action = ACTION_DELAYED_RETRY;
880	break;	888	break;
881	default:	889	default:
882	action = ACTION_FAIL;	890	action = ACTION_FAIL;
883	break;	891	break;
884	}	892	}
885	} else	893	} else
886	action = ACTION_FAIL;	894	action = ACTION_FAIL;
887	break;	895	break;
888	case VOLUME_OVERFLOW:	896	case VOLUME_OVERFLOW:
889	/* See SSC3rXX or current. */	897	/* See SSC3rXX or current. */
890	action = ACTION_FAIL;	898	action = ACTION_FAIL;
891	break;	899	break;
892	default:	900	default:
893	action = ACTION_FAIL;	901	action = ACTION_FAIL;
894	break;	902	break;
895	}	903	}
896	} else	904	} else
897	action = ACTION_FAIL;	905	action = ACTION_FAIL;
898		906
899	if (action != ACTION_FAIL &&	907	if (action != ACTION_FAIL &&
900	time_before(cmd->jiffies_at_alloc + wait_for, jiffies))	908	time_before(cmd->jiffies_at_alloc + wait_for, jiffies))
901	action = ACTION_FAIL;	909	action = ACTION_FAIL;
902		910
903	switch (action) {	911	switch (action) {
904	case ACTION_FAIL:	912	case ACTION_FAIL:
905	/* Give up and fail the remainder of the request */	913	/* Give up and fail the remainder of the request */
906	if (!(req->cmd_flags & REQ_QUIET)) {	914	if (!(req->cmd_flags & REQ_QUIET)) {
907	scsi_print_result(cmd);	915	scsi_print_result(cmd);
908	if (driver_byte(result) & DRIVER_SENSE)	916	if (driver_byte(result) & DRIVER_SENSE)
909	scsi_print_sense("", cmd);	917	scsi_print_sense("", cmd);
910	scsi_print_command(cmd);	918	scsi_print_command(cmd);
911	}	919	}
912	if (!blk_end_request_err(req, error))	920	if (!blk_end_request_err(req, error))
913	goto next_command;	921	goto next_command;
914	/FALLTHRU/	922	/FALLTHRU/
915	case ACTION_REPREP:	923	case ACTION_REPREP:
916	requeue:	924	requeue:
917	/* Unprep the request and put it back at the head of the queue.	925	/* Unprep the request and put it back at the head of the queue.
918	* A new command will be prepared and issued.	926	* A new command will be prepared and issued.
919	*/	927	*/
920	scsi_release_buffers(cmd);	928	scsi_release_buffers(cmd);
921	scsi_requeue_command(q, cmd);	929	scsi_requeue_command(q, cmd);
922	break;	930	break;
923	case ACTION_RETRY:	931	case ACTION_RETRY:
924	/* Retry the same command immediately */	932	/* Retry the same command immediately */
925	__scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, 0);	933	__scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, 0);
926	break;	934	break;
927	case ACTION_DELAYED_RETRY:	935	case ACTION_DELAYED_RETRY:
928	/* Retry the same command after a delay */	936	/* Retry the same command after a delay */
929	__scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, 0);	937	__scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, 0);
930	break;	938	break;
931	}	939	}
932	return;	940	return;
933		941
934	next_command:	942	next_command:
935	scsi_release_buffers(cmd);	943	scsi_release_buffers(cmd);
936	scsi_next_command(cmd);	944	scsi_next_command(cmd);
937	}	945	}
938		946
939	static int scsi_init_sgtable(struct request req, struct scsi_data_buffer sdb,	947	static int scsi_init_sgtable(struct request req, struct scsi_data_buffer sdb,
940	gfp_t gfp_mask)	948	gfp_t gfp_mask)
941	{	949	{
942	int count;	950	int count;
943		951
944	/*	952	/*
945	* If sg table allocation fails, requeue request later.	953	* If sg table allocation fails, requeue request later.
946	*/	954	*/
947	if (unlikely(scsi_alloc_sgtable(sdb, req->nr_phys_segments,	955	if (unlikely(scsi_alloc_sgtable(sdb, req->nr_phys_segments,
948	gfp_mask))) {	956	gfp_mask))) {
949	return BLKPREP_DEFER;	957	return BLKPREP_DEFER;
950	}	958	}
951		959
952	/*	960	/*
953	* Next, walk the list, and fill in the addresses and sizes of	961	* Next, walk the list, and fill in the addresses and sizes of
954	* each segment.	962	* each segment.
955	*/	963	*/
956	count = blk_rq_map_sg(req->q, req, sdb->table.sgl);	964	count = blk_rq_map_sg(req->q, req, sdb->table.sgl);
957	BUG_ON(count > sdb->table.nents);	965	BUG_ON(count > sdb->table.nents);
958	sdb->table.nents = count;	966	sdb->table.nents = count;
959	sdb->length = blk_rq_bytes(req);	967	sdb->length = blk_rq_bytes(req);
960	return BLKPREP_OK;	968	return BLKPREP_OK;
961	}	969	}
962		970
963	/*	971	/*
964	* Function: scsi_init_io()	972	* Function: scsi_init_io()
965	*	973	*
966	* Purpose: SCSI I/O initialize function.	974	* Purpose: SCSI I/O initialize function.
967	*	975	*
968	* Arguments: cmd - Command descriptor we wish to initialize	976	* Arguments: cmd - Command descriptor we wish to initialize
969	*	977	*
970	* Returns: 0 on success	978	* Returns: 0 on success
971	* BLKPREP_DEFER if the failure is retryable	979	* BLKPREP_DEFER if the failure is retryable
972	* BLKPREP_KILL if the failure is fatal	980	* BLKPREP_KILL if the failure is fatal
973	*/	981	*/
974	int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)	982	int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
975	{	983	{
976	struct scsi_device *sdev = cmd->device;	984	struct scsi_device *sdev = cmd->device;
977	struct request *rq = cmd->request;	985	struct request *rq = cmd->request;
978	int error;	986	int error;
979		987
980	BUG_ON(!rq->nr_phys_segments);	988	BUG_ON(!rq->nr_phys_segments);
981		989
982	error = scsi_init_sgtable(rq, &cmd->sdb, gfp_mask);	990	error = scsi_init_sgtable(rq, &cmd->sdb, gfp_mask);
983	if (error)	991	if (error)
984	goto err_exit;	992	goto err_exit;
985		993
986	if (blk_bidi_rq(rq)) {	994	if (blk_bidi_rq(rq)) {
987	struct scsi_data_buffer *bidi_sdb = kmem_cache_zalloc(	995	struct scsi_data_buffer *bidi_sdb = kmem_cache_zalloc(
988	scsi_sdb_cache, GFP_ATOMIC);	996	scsi_sdb_cache, GFP_ATOMIC);
989	if (!bidi_sdb) {	997	if (!bidi_sdb) {
990	error = BLKPREP_DEFER;	998	error = BLKPREP_DEFER;
991	goto err_exit;	999	goto err_exit;
992	}	1000	}
993		1001
994	rq->next_rq->special = bidi_sdb;	1002	rq->next_rq->special = bidi_sdb;
995	error = scsi_init_sgtable(rq->next_rq, bidi_sdb, GFP_ATOMIC);	1003	error = scsi_init_sgtable(rq->next_rq, bidi_sdb, GFP_ATOMIC);
996	if (error)	1004	if (error)
997	goto err_exit;	1005	goto err_exit;
998	}	1006	}
999		1007
1000	if (blk_integrity_rq(rq)) {	1008	if (blk_integrity_rq(rq)) {
1001	struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;	1009	struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;
1002	int ivecs, count;	1010	int ivecs, count;
1003		1011
1004	BUG_ON(prot_sdb == NULL);	1012	BUG_ON(prot_sdb == NULL);
1005	ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);	1013	ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);
1006		1014
1007	if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask)) {	1015	if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask)) {
1008	error = BLKPREP_DEFER;	1016	error = BLKPREP_DEFER;
1009	goto err_exit;	1017	goto err_exit;
1010	}	1018	}
1011		1019
1012	count = blk_rq_map_integrity_sg(rq->q, rq->bio,	1020	count = blk_rq_map_integrity_sg(rq->q, rq->bio,
1013	prot_sdb->table.sgl);	1021	prot_sdb->table.sgl);
1014	BUG_ON(unlikely(count > ivecs));	1022	BUG_ON(unlikely(count > ivecs));
1015	BUG_ON(unlikely(count > queue_max_integrity_segments(rq->q)));	1023	BUG_ON(unlikely(count > queue_max_integrity_segments(rq->q)));
1016		1024
1017	cmd->prot_sdb = prot_sdb;	1025	cmd->prot_sdb = prot_sdb;
1018	cmd->prot_sdb->table.nents = count;	1026	cmd->prot_sdb->table.nents = count;
1019	}	1027	}
1020		1028
1021	return BLKPREP_OK ;	1029	return BLKPREP_OK ;
1022		1030
1023	err_exit:	1031	err_exit:
1024	scsi_release_buffers(cmd);	1032	scsi_release_buffers(cmd);
1025	cmd->request->special = NULL;	1033	cmd->request->special = NULL;
1026	scsi_put_command(cmd);	1034	scsi_put_command(cmd);
1027	put_device(&sdev->sdev_gendev);	1035	put_device(&sdev->sdev_gendev);
1028	return error;	1036	return error;
1029	}	1037	}
1030	EXPORT_SYMBOL(scsi_init_io);	1038	EXPORT_SYMBOL(scsi_init_io);
1031		1039
1032	static struct scsi_cmnd scsi_get_cmd_from_req(struct scsi_device sdev,	1040	static struct scsi_cmnd scsi_get_cmd_from_req(struct scsi_device sdev,
1033	struct request *req)	1041	struct request *req)
1034	{	1042	{
1035	struct scsi_cmnd *cmd;	1043	struct scsi_cmnd *cmd;
1036		1044
1037	if (!req->special) {	1045	if (!req->special) {
1038	/* Bail if we can't get a reference to the device */	1046	/* Bail if we can't get a reference to the device */
1039	if (!get_device(&sdev->sdev_gendev))	1047	if (!get_device(&sdev->sdev_gendev))
1040	return NULL;	1048	return NULL;
1041		1049
1042	cmd = scsi_get_command(sdev, GFP_ATOMIC);	1050	cmd = scsi_get_command(sdev, GFP_ATOMIC);
1043	if (unlikely(!cmd)) {	1051	if (unlikely(!cmd)) {
1044	put_device(&sdev->sdev_gendev);	1052	put_device(&sdev->sdev_gendev);
1045	return NULL;	1053	return NULL;
1046	}	1054	}
1047	req->special = cmd;	1055	req->special = cmd;
1048	} else {	1056	} else {
1049	cmd = req->special;	1057	cmd = req->special;
1050	}	1058	}
1051		1059
1052	/* pull a tag out of the request if we have one */	1060	/* pull a tag out of the request if we have one */
1053	cmd->tag = req->tag;	1061	cmd->tag = req->tag;
1054	cmd->request = req;	1062	cmd->request = req;
1055		1063
1056	cmd->cmnd = req->cmd;	1064	cmd->cmnd = req->cmd;
1057	cmd->prot_op = SCSI_PROT_NORMAL;	1065	cmd->prot_op = SCSI_PROT_NORMAL;
1058		1066
1059	return cmd;	1067	return cmd;
1060	}	1068	}
1061		1069
1062	static int scsi_setup_blk_pc_cmnd(struct scsi_device sdev, struct request req)	1070	static int scsi_setup_blk_pc_cmnd(struct scsi_device sdev, struct request req)
1063	{	1071	{
1064	struct scsi_cmnd *cmd = req->special;	1072	struct scsi_cmnd *cmd = req->special;
1065		1073
1066	/*	1074	/*
1067	* BLOCK_PC requests may transfer data, in which case they must	1075	* BLOCK_PC requests may transfer data, in which case they must
1068	* a bio attached to them. Or they might contain a SCSI command	1076	* a bio attached to them. Or they might contain a SCSI command
1069	* that does not transfer data, in which case they may optionally	1077	* that does not transfer data, in which case they may optionally
1070	* submit a request without an attached bio.	1078	* submit a request without an attached bio.
1071	*/	1079	*/
1072	if (req->bio) {	1080	if (req->bio) {
1073	int ret = scsi_init_io(cmd, GFP_ATOMIC);	1081	int ret = scsi_init_io(cmd, GFP_ATOMIC);
1074	if (unlikely(ret))	1082	if (unlikely(ret))
1075	return ret;	1083	return ret;
1076	} else {	1084	} else {
1077	BUG_ON(blk_rq_bytes(req));	1085	BUG_ON(blk_rq_bytes(req));
1078		1086
1079	memset(&cmd->sdb, 0, sizeof(cmd->sdb));	1087	memset(&cmd->sdb, 0, sizeof(cmd->sdb));
1080	}	1088	}
1081		1089
1082	cmd->cmd_len = req->cmd_len;	1090	cmd->cmd_len = req->cmd_len;
1083	cmd->transfersize = blk_rq_bytes(req);	1091	cmd->transfersize = blk_rq_bytes(req);
1084	cmd->allowed = req->retries;	1092	cmd->allowed = req->retries;
1085	return BLKPREP_OK;	1093	return BLKPREP_OK;
1086	}	1094	}
1087		1095
1088	/*	1096	/*
1089	* Setup a REQ_TYPE_FS command. These are simple request from filesystems	1097	* Setup a REQ_TYPE_FS command. These are simple request from filesystems
1090	* that still need to be translated to SCSI CDBs from the ULD.	1098	* that still need to be translated to SCSI CDBs from the ULD.
1091	*/	1099	*/
1092	static int scsi_setup_fs_cmnd(struct scsi_device sdev, struct request req)	1100	static int scsi_setup_fs_cmnd(struct scsi_device sdev, struct request req)
1093	{	1101	{
1094	struct scsi_cmnd *cmd = req->special;	1102	struct scsi_cmnd *cmd = req->special;
1095		1103
1096	if (unlikely(sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh	1104	if (unlikely(sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh
1097	&& sdev->scsi_dh_data->scsi_dh->prep_fn)) {	1105	&& sdev->scsi_dh_data->scsi_dh->prep_fn)) {
1098	int ret = sdev->scsi_dh_data->scsi_dh->prep_fn(sdev, req);	1106	int ret = sdev->scsi_dh_data->scsi_dh->prep_fn(sdev, req);
1099	if (ret != BLKPREP_OK)	1107	if (ret != BLKPREP_OK)
1100	return ret;	1108	return ret;
1101	}	1109	}
1102		1110
1103	memset(cmd->cmnd, 0, BLK_MAX_CDB);	1111	memset(cmd->cmnd, 0, BLK_MAX_CDB);
1104	return scsi_cmd_to_driver(cmd)->init_command(cmd);	1112	return scsi_cmd_to_driver(cmd)->init_command(cmd);
1105	}	1113	}
1106		1114
1107	static int scsi_setup_cmnd(struct scsi_device sdev, struct request req)	1115	static int scsi_setup_cmnd(struct scsi_device sdev, struct request req)
1108	{	1116	{
1109	struct scsi_cmnd *cmd = req->special;	1117	struct scsi_cmnd *cmd = req->special;
1110		1118
1111	if (!blk_rq_bytes(req))	1119	if (!blk_rq_bytes(req))
1112	cmd->sc_data_direction = DMA_NONE;	1120	cmd->sc_data_direction = DMA_NONE;
1113	else if (rq_data_dir(req) == WRITE)	1121	else if (rq_data_dir(req) == WRITE)
1114	cmd->sc_data_direction = DMA_TO_DEVICE;	1122	cmd->sc_data_direction = DMA_TO_DEVICE;
1115	else	1123	else
1116	cmd->sc_data_direction = DMA_FROM_DEVICE;	1124	cmd->sc_data_direction = DMA_FROM_DEVICE;
1117		1125
1118	switch (req->cmd_type) {	1126	switch (req->cmd_type) {
1119	case REQ_TYPE_FS:	1127	case REQ_TYPE_FS:
1120	return scsi_setup_fs_cmnd(sdev, req);	1128	return scsi_setup_fs_cmnd(sdev, req);
1121	case REQ_TYPE_BLOCK_PC:	1129	case REQ_TYPE_BLOCK_PC:
1122	return scsi_setup_blk_pc_cmnd(sdev, req);	1130	return scsi_setup_blk_pc_cmnd(sdev, req);
1123	default:	1131	default:
1124	return BLKPREP_KILL;	1132	return BLKPREP_KILL;
1125	}	1133	}
1126	}	1134	}
1127		1135
1128	static int	1136	static int
1129	scsi_prep_state_check(struct scsi_device sdev, struct request req)	1137	scsi_prep_state_check(struct scsi_device sdev, struct request req)
1130	{	1138	{
1131	int ret = BLKPREP_OK;	1139	int ret = BLKPREP_OK;
1132		1140
1133	/*	1141	/*
1134	* If the device is not in running state we will reject some	1142	* If the device is not in running state we will reject some
1135	* or all commands.	1143	* or all commands.
1136	*/	1144	*/
1137	if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {	1145	if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {
1138	switch (sdev->sdev_state) {	1146	switch (sdev->sdev_state) {
1139	case SDEV_OFFLINE:	1147	case SDEV_OFFLINE:
1140	case SDEV_TRANSPORT_OFFLINE:	1148	case SDEV_TRANSPORT_OFFLINE:
1141	/*	1149	/*
1142	* If the device is offline we refuse to process any	1150	* If the device is offline we refuse to process any
1143	* commands. The device must be brought online	1151	* commands. The device must be brought online
1144	* before trying any recovery commands.	1152	* before trying any recovery commands.
1145	*/	1153	*/
1146	sdev_printk(KERN_ERR, sdev,	1154	sdev_printk(KERN_ERR, sdev,
1147	"rejecting I/O to offline device\n");	1155	"rejecting I/O to offline device\n");
1148	ret = BLKPREP_KILL;	1156	ret = BLKPREP_KILL;
1149	break;	1157	break;
1150	case SDEV_DEL:	1158	case SDEV_DEL:
1151	/*	1159	/*
1152	* If the device is fully deleted, we refuse to	1160	* If the device is fully deleted, we refuse to
1153	* process any commands as well.	1161	* process any commands as well.
1154	*/	1162	*/
1155	sdev_printk(KERN_ERR, sdev,	1163	sdev_printk(KERN_ERR, sdev,
1156	"rejecting I/O to dead device\n");	1164	"rejecting I/O to dead device\n");
1157	ret = BLKPREP_KILL;	1165	ret = BLKPREP_KILL;
1158	break;	1166	break;
1159	case SDEV_QUIESCE:	1167	case SDEV_QUIESCE:
1160	case SDEV_BLOCK:	1168	case SDEV_BLOCK:
1161	case SDEV_CREATED_BLOCK:	1169	case SDEV_CREATED_BLOCK:
1162	/*	1170	/*
1163	* If the devices is blocked we defer normal commands.	1171	* If the devices is blocked we defer normal commands.
1164	*/	1172	*/
1165	if (!(req->cmd_flags & REQ_PREEMPT))	1173	if (!(req->cmd_flags & REQ_PREEMPT))
1166	ret = BLKPREP_DEFER;	1174	ret = BLKPREP_DEFER;
1167	break;	1175	break;
1168	default:	1176	default:
1169	/*	1177	/*
1170	* For any other not fully online state we only allow	1178	* For any other not fully online state we only allow
1171	* special commands. In particular any user initiated	1179	* special commands. In particular any user initiated
1172	* command is not allowed.	1180	* command is not allowed.
1173	*/	1181	*/
1174	if (!(req->cmd_flags & REQ_PREEMPT))	1182	if (!(req->cmd_flags & REQ_PREEMPT))
1175	ret = BLKPREP_KILL;	1183	ret = BLKPREP_KILL;
1176	break;	1184	break;
1177	}	1185	}
1178	}	1186	}
1179	return ret;	1187	return ret;
1180	}	1188	}
1181		1189
1182	static int	1190	static int
1183	scsi_prep_return(struct request_queue q, struct request req, int ret)	1191	scsi_prep_return(struct request_queue q, struct request req, int ret)
1184	{	1192	{
1185	struct scsi_device *sdev = q->queuedata;	1193	struct scsi_device *sdev = q->queuedata;
1186		1194
1187	switch (ret) {	1195	switch (ret) {
1188	case BLKPREP_KILL:	1196	case BLKPREP_KILL:
1189	req->errors = DID_NO_CONNECT << 16;	1197	req->errors = DID_NO_CONNECT << 16;
1190	/* release the command and kill it */	1198	/* release the command and kill it */
1191	if (req->special) {	1199	if (req->special) {
1192	struct scsi_cmnd *cmd = req->special;	1200	struct scsi_cmnd *cmd = req->special;
1193	scsi_release_buffers(cmd);	1201	scsi_release_buffers(cmd);
1194	scsi_put_command(cmd);	1202	scsi_put_command(cmd);
1195	put_device(&sdev->sdev_gendev);	1203	put_device(&sdev->sdev_gendev);
1196	req->special = NULL;	1204	req->special = NULL;
1197	}	1205	}
1198	break;	1206	break;
1199	case BLKPREP_DEFER:	1207	case BLKPREP_DEFER:
1200	/*	1208	/*
1201	* If we defer, the blk_peek_request() returns NULL, but the	1209	* If we defer, the blk_peek_request() returns NULL, but the
1202	* queue must be restarted, so we schedule a callback to happen	1210	* queue must be restarted, so we schedule a callback to happen
1203	* shortly.	1211	* shortly.
1204	*/	1212	*/
1205	if (atomic_read(&sdev->device_busy) == 0)	1213	if (atomic_read(&sdev->device_busy) == 0)
1206	blk_delay_queue(q, SCSI_QUEUE_DELAY);	1214	blk_delay_queue(q, SCSI_QUEUE_DELAY);
1207	break;	1215	break;
1208	default:	1216	default:
1209	req->cmd_flags \|= REQ_DONTPREP;	1217	req->cmd_flags \|= REQ_DONTPREP;
1210	}	1218	}
1211		1219
1212	return ret;	1220	return ret;
1213	}	1221	}
1214		1222
1215	static int scsi_prep_fn(struct request_queue q, struct request req)	1223	static int scsi_prep_fn(struct request_queue q, struct request req)
1216	{	1224	{
1217	struct scsi_device *sdev = q->queuedata;	1225	struct scsi_device *sdev = q->queuedata;
1218	struct scsi_cmnd *cmd;	1226	struct scsi_cmnd *cmd;
1219	int ret;	1227	int ret;
1220		1228
1221	ret = scsi_prep_state_check(sdev, req);	1229	ret = scsi_prep_state_check(sdev, req);
1222	if (ret != BLKPREP_OK)	1230	if (ret != BLKPREP_OK)
1223	goto out;	1231	goto out;
1224		1232
1225	cmd = scsi_get_cmd_from_req(sdev, req);	1233	cmd = scsi_get_cmd_from_req(sdev, req);
1226	if (unlikely(!cmd)) {	1234	if (unlikely(!cmd)) {
1227	ret = BLKPREP_DEFER;	1235	ret = BLKPREP_DEFER;
1228	goto out;	1236	goto out;
1229	}	1237	}
1230		1238
1231	ret = scsi_setup_cmnd(sdev, req);	1239	ret = scsi_setup_cmnd(sdev, req);
1232	out:	1240	out:
1233	return scsi_prep_return(q, req, ret);	1241	return scsi_prep_return(q, req, ret);
1234	}	1242	}
1235		1243
1236	static void scsi_unprep_fn(struct request_queue q, struct request req)	1244	static void scsi_unprep_fn(struct request_queue q, struct request req)
1237	{	1245	{
1238	if (req->cmd_type == REQ_TYPE_FS) {	1246	if (req->cmd_type == REQ_TYPE_FS) {
1239	struct scsi_cmnd *cmd = req->special;	1247	struct scsi_cmnd *cmd = req->special;
1240	struct scsi_driver *drv = scsi_cmd_to_driver(cmd);	1248	struct scsi_driver *drv = scsi_cmd_to_driver(cmd);
1241		1249
1242	if (drv->uninit_command)	1250	if (drv->uninit_command)
1243	drv->uninit_command(cmd);	1251	drv->uninit_command(cmd);
1244	}	1252	}
1245	}	1253	}
1246		1254
1247	/*	1255	/*
1248	* scsi_dev_queue_ready: if we can send requests to sdev, return 1 else	1256	* scsi_dev_queue_ready: if we can send requests to sdev, return 1 else
1249	* return 0.	1257	* return 0.
1250	*	1258	*
1251	* Called with the queue_lock held.	1259	* Called with the queue_lock held.
1252	*/	1260	*/
1253	static inline int scsi_dev_queue_ready(struct request_queue *q,	1261	static inline int scsi_dev_queue_ready(struct request_queue *q,
1254	struct scsi_device *sdev)	1262	struct scsi_device *sdev)
1255	{	1263	{
1256	unsigned int busy;	1264	unsigned int busy;
1257		1265
1258	busy = atomic_inc_return(&sdev->device_busy) - 1;	1266	busy = atomic_inc_return(&sdev->device_busy) - 1;
1259	if (sdev->device_blocked) {	1267	if (atomic_read(&sdev->device_blocked)) {
1260	if (busy)	1268	if (busy)
1261	goto out_dec;	1269	goto out_dec;
1262		1270
1263	/*	1271	/*
1264	* unblock after device_blocked iterates to zero	1272	* unblock after device_blocked iterates to zero
1265	*/	1273	*/
1266	if (--sdev->device_blocked != 0) {	1274	if (atomic_dec_return(&sdev->device_blocked) > 0) {
1267	blk_delay_queue(q, SCSI_QUEUE_DELAY);	1275	blk_delay_queue(q, SCSI_QUEUE_DELAY);
1268	goto out_dec;	1276	goto out_dec;
1269	}	1277	}
1270	SCSI_LOG_MLQUEUE(3, sdev_printk(KERN_INFO, sdev,	1278	SCSI_LOG_MLQUEUE(3, sdev_printk(KERN_INFO, sdev,
1271	"unblocking device at zero depth\n"));	1279	"unblocking device at zero depth\n"));
1272	}	1280	}
1273		1281
1274	if (busy >= sdev->queue_depth)	1282	if (busy >= sdev->queue_depth)
1275	goto out_dec;	1283	goto out_dec;
1276		1284
1277	return 1;	1285	return 1;
1278	out_dec:	1286	out_dec:
1279	atomic_dec(&sdev->device_busy);	1287	atomic_dec(&sdev->device_busy);
1280	return 0;	1288	return 0;
1281	}	1289	}
1282		1290
1283	/*	1291	/*
1284	* scsi_target_queue_ready: checks if there we can send commands to target	1292	* scsi_target_queue_ready: checks if there we can send commands to target
1285	* @sdev: scsi device on starget to check.	1293	* @sdev: scsi device on starget to check.
1286	*/	1294	*/
1287	static inline int scsi_target_queue_ready(struct Scsi_Host *shost,	1295	static inline int scsi_target_queue_ready(struct Scsi_Host *shost,
1288	struct scsi_device *sdev)	1296	struct scsi_device *sdev)
1289	{	1297	{
1290	struct scsi_target *starget = scsi_target(sdev);	1298	struct scsi_target *starget = scsi_target(sdev);
1291	unsigned int busy;	1299	unsigned int busy;
1292		1300
1293	if (starget->single_lun) {	1301	if (starget->single_lun) {
1294	spin_lock_irq(shost->host_lock);	1302	spin_lock_irq(shost->host_lock);
1295	if (starget->starget_sdev_user &&	1303	if (starget->starget_sdev_user &&
1296	starget->starget_sdev_user != sdev) {	1304	starget->starget_sdev_user != sdev) {
1297	spin_unlock_irq(shost->host_lock);	1305	spin_unlock_irq(shost->host_lock);
1298	return 0;	1306	return 0;
1299	}	1307	}
1300	starget->starget_sdev_user = sdev;	1308	starget->starget_sdev_user = sdev;
1301	spin_unlock_irq(shost->host_lock);	1309	spin_unlock_irq(shost->host_lock);
1302	}	1310	}
1303		1311
1304	busy = atomic_inc_return(&starget->target_busy) - 1;	1312	busy = atomic_inc_return(&starget->target_busy) - 1;
1305	if (starget->target_blocked) {	1313	if (atomic_read(&starget->target_blocked) > 0) {
1306	if (busy)	1314	if (busy)
1307	goto starved;	1315	goto starved;
1308		1316
1309	/*	1317	/*
1310	* unblock after target_blocked iterates to zero	1318	* unblock after target_blocked iterates to zero
1311	*/	1319	*/
1312	spin_lock_irq(shost->host_lock);	1320	if (atomic_dec_return(&starget->target_blocked) > 0)
1313	if (--starget->target_blocked != 0) {
1314	spin_unlock_irq(shost->host_lock);
1315	goto out_dec;	1321	goto out_dec;
1316	}
1317	spin_unlock_irq(shost->host_lock);
1318		1322
1319	SCSI_LOG_MLQUEUE(3, starget_printk(KERN_INFO, starget,	1323	SCSI_LOG_MLQUEUE(3, starget_printk(KERN_INFO, starget,
1320	"unblocking target at zero depth\n"));	1324	"unblocking target at zero depth\n"));
1321	}	1325	}
1322		1326
1323	if (starget->can_queue > 0 && busy >= starget->can_queue)	1327	if (starget->can_queue > 0 && busy >= starget->can_queue)
1324	goto starved;	1328	goto starved;
1325		1329
1326	return 1;	1330	return 1;
1327		1331
1328	starved:	1332	starved:
1329	spin_lock_irq(shost->host_lock);	1333	spin_lock_irq(shost->host_lock);
1330	list_move_tail(&sdev->starved_entry, &shost->starved_list);	1334	list_move_tail(&sdev->starved_entry, &shost->starved_list);
1331	spin_unlock_irq(shost->host_lock);	1335	spin_unlock_irq(shost->host_lock);
1332	out_dec:	1336	out_dec:
1333	atomic_dec(&starget->target_busy);	1337	atomic_dec(&starget->target_busy);
1334	return 0;	1338	return 0;
1335	}	1339	}
1336		1340
1337	/*	1341	/*
1338	* scsi_host_queue_ready: if we can send requests to shost, return 1 else	1342	* scsi_host_queue_ready: if we can send requests to shost, return 1 else
1339	* return 0. We must end up running the queue again whenever 0 is	1343	* return 0. We must end up running the queue again whenever 0 is
1340	* returned, else IO can hang.	1344	* returned, else IO can hang.
1341	*/	1345	*/
1342	static inline int scsi_host_queue_ready(struct request_queue *q,	1346	static inline int scsi_host_queue_ready(struct request_queue *q,
1343	struct Scsi_Host *shost,	1347	struct Scsi_Host *shost,
1344	struct scsi_device *sdev)	1348	struct scsi_device *sdev)
1345	{	1349	{
1346	unsigned int busy;	1350	unsigned int busy;
1347		1351
1348	if (scsi_host_in_recovery(shost))	1352	if (scsi_host_in_recovery(shost))
1349	return 0;	1353	return 0;
1350		1354
1351	busy = atomic_inc_return(&shost->host_busy) - 1;	1355	busy = atomic_inc_return(&shost->host_busy) - 1;
1352	if (shost->host_blocked) {	1356	if (atomic_read(&shost->host_blocked) > 0) {
1353	if (busy)	1357	if (busy)
1354	goto starved;	1358	goto starved;
1355		1359
1356	/*	1360	/*
1357	* unblock after host_blocked iterates to zero	1361	* unblock after host_blocked iterates to zero
1358	*/	1362	*/
1359	spin_lock_irq(shost->host_lock);	1363	if (atomic_dec_return(&shost->host_blocked) > 0)
1360	if (--shost->host_blocked != 0) {
1361	spin_unlock_irq(shost->host_lock);
1362	goto out_dec;	1364	goto out_dec;
1363	}
1364	spin_unlock_irq(shost->host_lock);
1365		1365
1366	SCSI_LOG_MLQUEUE(3,	1366	SCSI_LOG_MLQUEUE(3,
1367	shost_printk(KERN_INFO, shost,	1367	shost_printk(KERN_INFO, shost,
1368	"unblocking host at zero depth\n"));	1368	"unblocking host at zero depth\n"));
1369	}	1369	}
1370		1370
1371	if (shost->can_queue > 0 && busy >= shost->can_queue)	1371	if (shost->can_queue > 0 && busy >= shost->can_queue)
1372	goto starved;	1372	goto starved;
1373	if (shost->host_self_blocked)	1373	if (shost->host_self_blocked)
1374	goto starved;	1374	goto starved;
1375		1375
1376	/* We're OK to process the command, so we can't be starved */	1376	/* We're OK to process the command, so we can't be starved */
1377	if (!list_empty(&sdev->starved_entry)) {	1377	if (!list_empty(&sdev->starved_entry)) {
1378	spin_lock_irq(shost->host_lock);	1378	spin_lock_irq(shost->host_lock);
1379	if (!list_empty(&sdev->starved_entry))	1379	if (!list_empty(&sdev->starved_entry))
1380	list_del_init(&sdev->starved_entry);	1380	list_del_init(&sdev->starved_entry);
1381	spin_unlock_irq(shost->host_lock);	1381	spin_unlock_irq(shost->host_lock);
1382	}	1382	}
1383		1383
1384	return 1;	1384	return 1;
1385		1385
1386	starved:	1386	starved:
1387	spin_lock_irq(shost->host_lock);	1387	spin_lock_irq(shost->host_lock);
1388	if (list_empty(&sdev->starved_entry))	1388	if (list_empty(&sdev->starved_entry))
1389	list_add_tail(&sdev->starved_entry, &shost->starved_list);	1389	list_add_tail(&sdev->starved_entry, &shost->starved_list);
1390	spin_unlock_irq(shost->host_lock);	1390	spin_unlock_irq(shost->host_lock);
1391	out_dec:	1391	out_dec:
1392	atomic_dec(&shost->host_busy);	1392	atomic_dec(&shost->host_busy);
1393	return 0;	1393	return 0;
1394	}	1394	}
1395		1395
1396	/*	1396	/*
1397	* Busy state exporting function for request stacking drivers.	1397	* Busy state exporting function for request stacking drivers.
1398	*	1398	*
1399	* For efficiency, no lock is taken to check the busy state of	1399	* For efficiency, no lock is taken to check the busy state of
1400	* shost/starget/sdev, since the returned value is not guaranteed and	1400	* shost/starget/sdev, since the returned value is not guaranteed and
1401	* may be changed after request stacking drivers call the function,	1401	* may be changed after request stacking drivers call the function,
1402	* regardless of taking lock or not.	1402	* regardless of taking lock or not.
1403	*	1403	*
1404	* When scsi can't dispatch I/Os anymore and needs to kill I/Os scsi	1404	* When scsi can't dispatch I/Os anymore and needs to kill I/Os scsi
1405	* needs to return 'not busy'. Otherwise, request stacking drivers	1405	* needs to return 'not busy'. Otherwise, request stacking drivers
1406	* may hold requests forever.	1406	* may hold requests forever.
1407	*/	1407	*/
1408	static int scsi_lld_busy(struct request_queue *q)	1408	static int scsi_lld_busy(struct request_queue *q)
1409	{	1409	{
1410	struct scsi_device *sdev = q->queuedata;	1410	struct scsi_device *sdev = q->queuedata;
1411	struct Scsi_Host *shost;	1411	struct Scsi_Host *shost;
1412		1412
1413	if (blk_queue_dying(q))	1413	if (blk_queue_dying(q))
1414	return 0;	1414	return 0;
1415		1415
1416	shost = sdev->host;	1416	shost = sdev->host;
1417		1417
1418	/*	1418	/*
1419	* Ignore host/starget busy state.	1419	* Ignore host/starget busy state.
1420	* Since block layer does not have a concept of fairness across	1420	* Since block layer does not have a concept of fairness across
1421	* multiple queues, congestion of host/starget needs to be handled	1421	* multiple queues, congestion of host/starget needs to be handled
1422	* in SCSI layer.	1422	* in SCSI layer.
1423	*/	1423	*/
1424	if (scsi_host_in_recovery(shost) \|\| scsi_device_is_busy(sdev))	1424	if (scsi_host_in_recovery(shost) \|\| scsi_device_is_busy(sdev))
1425	return 1;	1425	return 1;
1426		1426
1427	return 0;	1427	return 0;
1428	}	1428	}
1429		1429
1430	/*	1430	/*
1431	* Kill a request for a dead device	1431	* Kill a request for a dead device
1432	*/	1432	*/
1433	static void scsi_kill_request(struct request req, struct request_queue q)	1433	static void scsi_kill_request(struct request req, struct request_queue q)
1434	{	1434	{
1435	struct scsi_cmnd *cmd = req->special;	1435	struct scsi_cmnd *cmd = req->special;
1436	struct scsi_device *sdev;	1436	struct scsi_device *sdev;
1437	struct scsi_target *starget;	1437	struct scsi_target *starget;
1438	struct Scsi_Host *shost;	1438	struct Scsi_Host *shost;
1439		1439
1440	blk_start_request(req);	1440	blk_start_request(req);
1441		1441
1442	scmd_printk(KERN_INFO, cmd, "killing request\n");	1442	scmd_printk(KERN_INFO, cmd, "killing request\n");
1443		1443
1444	sdev = cmd->device;	1444	sdev = cmd->device;
1445	starget = scsi_target(sdev);	1445	starget = scsi_target(sdev);
1446	shost = sdev->host;	1446	shost = sdev->host;
1447	scsi_init_cmd_errh(cmd);	1447	scsi_init_cmd_errh(cmd);
1448	cmd->result = DID_NO_CONNECT << 16;	1448	cmd->result = DID_NO_CONNECT << 16;
1449	atomic_inc(&cmd->device->iorequest_cnt);	1449	atomic_inc(&cmd->device->iorequest_cnt);
1450		1450
1451	/*	1451	/*
1452	* SCSI request completion path will do scsi_device_unbusy(),	1452	* SCSI request completion path will do scsi_device_unbusy(),
1453	* bump busy counts. To bump the counters, we need to dance	1453	* bump busy counts. To bump the counters, we need to dance
1454	* with the locks as normal issue path does.	1454	* with the locks as normal issue path does.
1455	*/	1455	*/
1456	atomic_inc(&sdev->device_busy);	1456	atomic_inc(&sdev->device_busy);
1457	atomic_inc(&shost->host_busy);	1457	atomic_inc(&shost->host_busy);
1458	atomic_inc(&starget->target_busy);	1458	atomic_inc(&starget->target_busy);
1459		1459
1460	blk_complete_request(req);	1460	blk_complete_request(req);
1461	}	1461	}
1462		1462
1463	static void scsi_softirq_done(struct request *rq)	1463	static void scsi_softirq_done(struct request *rq)
1464	{	1464	{
1465	struct scsi_cmnd *cmd = rq->special;	1465	struct scsi_cmnd *cmd = rq->special;
1466	unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;	1466	unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;
1467	int disposition;	1467	int disposition;
1468		1468
1469	INIT_LIST_HEAD(&cmd->eh_entry);	1469	INIT_LIST_HEAD(&cmd->eh_entry);
1470		1470
1471	atomic_inc(&cmd->device->iodone_cnt);	1471	atomic_inc(&cmd->device->iodone_cnt);
1472	if (cmd->result)	1472	if (cmd->result)
1473	atomic_inc(&cmd->device->ioerr_cnt);	1473	atomic_inc(&cmd->device->ioerr_cnt);
1474		1474
1475	disposition = scsi_decide_disposition(cmd);	1475	disposition = scsi_decide_disposition(cmd);
1476	if (disposition != SUCCESS &&	1476	if (disposition != SUCCESS &&
1477	time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {	1477	time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
1478	sdev_printk(KERN_ERR, cmd->device,	1478	sdev_printk(KERN_ERR, cmd->device,
1479	"timing out command, waited %lus\n",	1479	"timing out command, waited %lus\n",
1480	wait_for/HZ);	1480	wait_for/HZ);
1481	disposition = SUCCESS;	1481	disposition = SUCCESS;
1482	}	1482	}
1483		1483
1484	scsi_log_completion(cmd, disposition);	1484	scsi_log_completion(cmd, disposition);
1485		1485
1486	switch (disposition) {	1486	switch (disposition) {
1487	case SUCCESS:	1487	case SUCCESS:
1488	scsi_finish_command(cmd);	1488	scsi_finish_command(cmd);
1489	break;	1489	break;
1490	case NEEDS_RETRY:	1490	case NEEDS_RETRY:
1491	scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);	1491	scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
1492	break;	1492	break;
1493	case ADD_TO_MLQUEUE:	1493	case ADD_TO_MLQUEUE:
1494	scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);	1494	scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
1495	break;	1495	break;
1496	default:	1496	default:
1497	if (!scsi_eh_scmd_add(cmd, 0))	1497	if (!scsi_eh_scmd_add(cmd, 0))
1498	scsi_finish_command(cmd);	1498	scsi_finish_command(cmd);
1499	}	1499	}
1500	}	1500	}
1501		1501
1502	/**	1502	/**
1503	* scsi_done - Invoke completion on finished SCSI command.	1503	* scsi_done - Invoke completion on finished SCSI command.
1504	* @cmd: The SCSI Command for which a low-level device driver (LLDD) gives	1504	* @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
1505	* ownership back to SCSI Core -- i.e. the LLDD has finished with it.	1505	* ownership back to SCSI Core -- i.e. the LLDD has finished with it.
1506	*	1506	*
1507	* Description: This function is the mid-level's (SCSI Core) interrupt routine,	1507	* Description: This function is the mid-level's (SCSI Core) interrupt routine,
1508	* which regains ownership of the SCSI command (de facto) from a LLDD, and	1508	* which regains ownership of the SCSI command (de facto) from a LLDD, and
1509	* calls blk_complete_request() for further processing.	1509	* calls blk_complete_request() for further processing.
1510	*	1510	*
1511	* This function is interrupt context safe.	1511	* This function is interrupt context safe.
1512	*/	1512	*/
1513	static void scsi_done(struct scsi_cmnd *cmd)	1513	static void scsi_done(struct scsi_cmnd *cmd)
1514	{	1514	{
1515	trace_scsi_dispatch_cmd_done(cmd);	1515	trace_scsi_dispatch_cmd_done(cmd);
1516	blk_complete_request(cmd->request);	1516	blk_complete_request(cmd->request);
1517	}	1517	}
1518		1518
1519	/*	1519	/*
1520	* Function: scsi_request_fn()	1520	* Function: scsi_request_fn()
1521	*	1521	*
1522	* Purpose: Main strategy routine for SCSI.	1522	* Purpose: Main strategy routine for SCSI.
1523	*	1523	*
1524	* Arguments: q - Pointer to actual queue.	1524	* Arguments: q - Pointer to actual queue.
1525	*	1525	*
1526	* Returns: Nothing	1526	* Returns: Nothing
1527	*	1527	*
1528	* Lock status: IO request lock assumed to be held when called.	1528	* Lock status: IO request lock assumed to be held when called.
1529	*/	1529	*/
1530	static void scsi_request_fn(struct request_queue *q)	1530	static void scsi_request_fn(struct request_queue *q)
1531	__releases(q->queue_lock)	1531	__releases(q->queue_lock)
1532	__acquires(q->queue_lock)	1532	__acquires(q->queue_lock)
1533	{	1533	{
1534	struct scsi_device *sdev = q->queuedata;	1534	struct scsi_device *sdev = q->queuedata;
1535	struct Scsi_Host *shost;	1535	struct Scsi_Host *shost;
1536	struct scsi_cmnd *cmd;	1536	struct scsi_cmnd *cmd;
1537	struct request *req;	1537	struct request *req;
1538		1538
1539	/*	1539	/*
1540	* To start with, we keep looping until the queue is empty, or until	1540	* To start with, we keep looping until the queue is empty, or until
1541	* the host is no longer able to accept any more requests.	1541	* the host is no longer able to accept any more requests.
1542	*/	1542	*/
1543	shost = sdev->host;	1543	shost = sdev->host;
1544	for (;;) {	1544	for (;;) {
1545	int rtn;	1545	int rtn;
1546	/*	1546	/*
1547	* get next queueable request. We do this early to make sure	1547	* get next queueable request. We do this early to make sure
1548	* that the request is fully prepared even if we cannot	1548	* that the request is fully prepared even if we cannot
1549	* accept it.	1549	* accept it.
1550	*/	1550	*/
1551	req = blk_peek_request(q);	1551	req = blk_peek_request(q);
1552	if (!req)	1552	if (!req)
1553	break;	1553	break;
1554		1554
1555	if (unlikely(!scsi_device_online(sdev))) {	1555	if (unlikely(!scsi_device_online(sdev))) {
1556	sdev_printk(KERN_ERR, sdev,	1556	sdev_printk(KERN_ERR, sdev,
1557	"rejecting I/O to offline device\n");	1557	"rejecting I/O to offline device\n");
1558	scsi_kill_request(req, q);	1558	scsi_kill_request(req, q);
1559	continue;	1559	continue;
1560	}	1560	}
1561		1561
1562	if (!scsi_dev_queue_ready(q, sdev))	1562	if (!scsi_dev_queue_ready(q, sdev))
1563	break;	1563	break;
1564		1564
1565	/*	1565	/*
1566	* Remove the request from the request list.	1566	* Remove the request from the request list.
1567	*/	1567	*/
1568	if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))	1568	if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))
1569	blk_start_request(req);	1569	blk_start_request(req);
1570		1570
1571	spin_unlock_irq(q->queue_lock);	1571	spin_unlock_irq(q->queue_lock);
1572	cmd = req->special;	1572	cmd = req->special;
1573	if (unlikely(cmd == NULL)) {	1573	if (unlikely(cmd == NULL)) {
1574	printk(KERN_CRIT "impossible request in %s.\n"	1574	printk(KERN_CRIT "impossible request in %s.\n"
1575	"please mail a stack trace to "	1575	"please mail a stack trace to "
1576	"linux-scsi@vger.kernel.org\n",	1576	"linux-scsi@vger.kernel.org\n",
1577	__func__);	1577	__func__);
1578	blk_dump_rq_flags(req, "foo");	1578	blk_dump_rq_flags(req, "foo");
1579	BUG();	1579	BUG();
1580	}	1580	}
1581		1581
1582	/*	1582	/*
1583	* We hit this when the driver is using a host wide	1583	* We hit this when the driver is using a host wide
1584	* tag map. For device level tag maps the queue_depth check	1584	* tag map. For device level tag maps the queue_depth check
1585	* in the device ready fn would prevent us from trying	1585	* in the device ready fn would prevent us from trying
1586	* to allocate a tag. Since the map is a shared host resource	1586	* to allocate a tag. Since the map is a shared host resource
1587	* we add the dev to the starved list so it eventually gets	1587	* we add the dev to the starved list so it eventually gets
1588	* a run when a tag is freed.	1588	* a run when a tag is freed.
1589	*/	1589	*/
1590	if (blk_queue_tagged(q) && !blk_rq_tagged(req)) {	1590	if (blk_queue_tagged(q) && !blk_rq_tagged(req)) {
1591	spin_lock_irq(shost->host_lock);	1591	spin_lock_irq(shost->host_lock);
1592	if (list_empty(&sdev->starved_entry))	1592	if (list_empty(&sdev->starved_entry))
1593	list_add_tail(&sdev->starved_entry,	1593	list_add_tail(&sdev->starved_entry,
1594	&shost->starved_list);	1594	&shost->starved_list);
1595	spin_unlock_irq(shost->host_lock);	1595	spin_unlock_irq(shost->host_lock);
1596	goto not_ready;	1596	goto not_ready;
1597	}	1597	}
1598		1598
1599	if (!scsi_target_queue_ready(shost, sdev))	1599	if (!scsi_target_queue_ready(shost, sdev))
1600	goto not_ready;	1600	goto not_ready;
1601		1601
1602	if (!scsi_host_queue_ready(q, shost, sdev))	1602	if (!scsi_host_queue_ready(q, shost, sdev))
1603	goto host_not_ready;	1603	goto host_not_ready;
1604		1604
1605	/*	1605	/*
1606	* Finally, initialize any error handling parameters, and set up	1606	* Finally, initialize any error handling parameters, and set up
1607	* the timers for timeouts.	1607	* the timers for timeouts.
1608	*/	1608	*/
1609	scsi_init_cmd_errh(cmd);	1609	scsi_init_cmd_errh(cmd);
1610		1610
1611	/*	1611	/*
1612	* Dispatch the command to the low-level driver.	1612	* Dispatch the command to the low-level driver.
1613	*/	1613	*/
1614	cmd->scsi_done = scsi_done;	1614	cmd->scsi_done = scsi_done;
1615	rtn = scsi_dispatch_cmd(cmd);	1615	rtn = scsi_dispatch_cmd(cmd);
1616	if (rtn) {	1616	if (rtn) {
1617	scsi_queue_insert(cmd, rtn);	1617	scsi_queue_insert(cmd, rtn);
1618	spin_lock_irq(q->queue_lock);	1618	spin_lock_irq(q->queue_lock);
1619	goto out_delay;	1619	goto out_delay;
1620	}	1620	}
1621	spin_lock_irq(q->queue_lock);	1621	spin_lock_irq(q->queue_lock);
1622	}	1622	}
1623		1623
1624	return;	1624	return;
1625		1625
1626	host_not_ready:	1626	host_not_ready:
1627	atomic_dec(&scsi_target(sdev)->target_busy);	1627	atomic_dec(&scsi_target(sdev)->target_busy);
1628	not_ready:	1628	not_ready:
1629	/*	1629	/*
1630	* lock q, handle tag, requeue req, and decrement device_busy. We	1630	* lock q, handle tag, requeue req, and decrement device_busy. We
1631	* must return with queue_lock held.	1631	* must return with queue_lock held.
1632	*	1632	*
1633	* Decrementing device_busy without checking it is OK, as all such	1633	* Decrementing device_busy without checking it is OK, as all such
1634	* cases (host limits or settings) should run the queue at some	1634	* cases (host limits or settings) should run the queue at some
1635	* later time.	1635	* later time.
1636	*/	1636	*/
1637	spin_lock_irq(q->queue_lock);	1637	spin_lock_irq(q->queue_lock);
1638	blk_requeue_request(q, req);	1638	blk_requeue_request(q, req);
1639	atomic_dec(&sdev->device_busy);	1639	atomic_dec(&sdev->device_busy);
1640	out_delay:	1640	out_delay:
1641	if (atomic_read(&sdev->device_busy) && !scsi_device_blocked(sdev))	1641	if (atomic_read(&sdev->device_busy) && !scsi_device_blocked(sdev))
1642	blk_delay_queue(q, SCSI_QUEUE_DELAY);	1642	blk_delay_queue(q, SCSI_QUEUE_DELAY);
1643	}	1643	}
1644		1644
1645	static u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost)	1645	static u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost)
1646	{	1646	{
1647	struct device *host_dev;	1647	struct device *host_dev;
1648	u64 bounce_limit = 0xffffffff;	1648	u64 bounce_limit = 0xffffffff;
1649		1649
1650	if (shost->unchecked_isa_dma)	1650	if (shost->unchecked_isa_dma)
1651	return BLK_BOUNCE_ISA;	1651	return BLK_BOUNCE_ISA;
1652	/*	1652	/*
1653	* Platforms with virtual-DMA translation	1653	* Platforms with virtual-DMA translation
1654	* hardware have no practical limit.	1654	* hardware have no practical limit.
1655	*/	1655	*/
1656	if (!PCI_DMA_BUS_IS_PHYS)	1656	if (!PCI_DMA_BUS_IS_PHYS)
1657	return BLK_BOUNCE_ANY;	1657	return BLK_BOUNCE_ANY;
1658		1658
1659	host_dev = scsi_get_device(shost);	1659	host_dev = scsi_get_device(shost);
1660	if (host_dev && host_dev->dma_mask)	1660	if (host_dev && host_dev->dma_mask)
1661	bounce_limit = (u64)dma_max_pfn(host_dev) << PAGE_SHIFT;	1661	bounce_limit = (u64)dma_max_pfn(host_dev) << PAGE_SHIFT;
1662		1662
1663	return bounce_limit;	1663	return bounce_limit;
1664	}	1664	}
1665		1665
1666	struct request_queue __scsi_alloc_queue(struct Scsi_Host shost,	1666	struct request_queue __scsi_alloc_queue(struct Scsi_Host shost,
1667	request_fn_proc *request_fn)	1667	request_fn_proc *request_fn)
1668	{	1668	{
1669	struct request_queue *q;	1669	struct request_queue *q;
1670	struct device *dev = shost->dma_dev;	1670	struct device *dev = shost->dma_dev;
1671		1671
1672	q = blk_init_queue(request_fn, NULL);	1672	q = blk_init_queue(request_fn, NULL);
1673	if (!q)	1673	if (!q)
1674	return NULL;	1674	return NULL;
1675		1675
1676	/*	1676	/*
1677	* this limit is imposed by hardware restrictions	1677	* this limit is imposed by hardware restrictions
1678	*/	1678	*/
1679	blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,	1679	blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
1680	SCSI_MAX_SG_CHAIN_SEGMENTS));	1680	SCSI_MAX_SG_CHAIN_SEGMENTS));
1681		1681
1682	if (scsi_host_prot_dma(shost)) {	1682	if (scsi_host_prot_dma(shost)) {
1683	shost->sg_prot_tablesize =	1683	shost->sg_prot_tablesize =
1684	min_not_zero(shost->sg_prot_tablesize,	1684	min_not_zero(shost->sg_prot_tablesize,
1685	(unsigned short)SCSI_MAX_PROT_SG_SEGMENTS);	1685	(unsigned short)SCSI_MAX_PROT_SG_SEGMENTS);
1686	BUG_ON(shost->sg_prot_tablesize < shost->sg_tablesize);	1686	BUG_ON(shost->sg_prot_tablesize < shost->sg_tablesize);
1687	blk_queue_max_integrity_segments(q, shost->sg_prot_tablesize);	1687	blk_queue_max_integrity_segments(q, shost->sg_prot_tablesize);
1688	}	1688	}
1689		1689
1690	blk_queue_max_hw_sectors(q, shost->max_sectors);	1690	blk_queue_max_hw_sectors(q, shost->max_sectors);
1691	blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));	1691	blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
1692	blk_queue_segment_boundary(q, shost->dma_boundary);	1692	blk_queue_segment_boundary(q, shost->dma_boundary);
1693	dma_set_seg_boundary(dev, shost->dma_boundary);	1693	dma_set_seg_boundary(dev, shost->dma_boundary);
1694		1694
1695	blk_queue_max_segment_size(q, dma_get_max_seg_size(dev));	1695	blk_queue_max_segment_size(q, dma_get_max_seg_size(dev));
1696		1696
1697	if (!shost->use_clustering)	1697	if (!shost->use_clustering)
1698	q->limits.cluster = 0;	1698	q->limits.cluster = 0;
1699		1699
1700	/*	1700	/*
1701	* set a reasonable default alignment on word boundaries: the	1701	* set a reasonable default alignment on word boundaries: the
1702	* host and device may alter it using	1702	* host and device may alter it using
1703	* blk_queue_update_dma_alignment() later.	1703	* blk_queue_update_dma_alignment() later.
1704	*/	1704	*/
1705	blk_queue_dma_alignment(q, 0x03);	1705	blk_queue_dma_alignment(q, 0x03);
1706		1706
1707	return q;	1707	return q;
1708	}	1708	}
1709	EXPORT_SYMBOL(__scsi_alloc_queue);	1709	EXPORT_SYMBOL(__scsi_alloc_queue);
1710		1710
1711	struct request_queue scsi_alloc_queue(struct scsi_device sdev)	1711	struct request_queue scsi_alloc_queue(struct scsi_device sdev)
1712	{	1712	{
1713	struct request_queue *q;	1713	struct request_queue *q;
1714		1714
1715	q = __scsi_alloc_queue(sdev->host, scsi_request_fn);	1715	q = __scsi_alloc_queue(sdev->host, scsi_request_fn);
1716	if (!q)	1716	if (!q)
1717	return NULL;	1717	return NULL;
1718		1718
1719	blk_queue_prep_rq(q, scsi_prep_fn);	1719	blk_queue_prep_rq(q, scsi_prep_fn);
1720	blk_queue_unprep_rq(q, scsi_unprep_fn);	1720	blk_queue_unprep_rq(q, scsi_unprep_fn);
1721	blk_queue_softirq_done(q, scsi_softirq_done);	1721	blk_queue_softirq_done(q, scsi_softirq_done);
1722	blk_queue_rq_timed_out(q, scsi_times_out);	1722	blk_queue_rq_timed_out(q, scsi_times_out);
1723	blk_queue_lld_busy(q, scsi_lld_busy);	1723	blk_queue_lld_busy(q, scsi_lld_busy);
1724	return q;	1724	return q;
1725	}	1725	}
1726		1726
1727	/*	1727	/*
1728	* Function: scsi_block_requests()	1728	* Function: scsi_block_requests()
1729	*	1729	*
1730	* Purpose: Utility function used by low-level drivers to prevent further	1730	* Purpose: Utility function used by low-level drivers to prevent further
1731	* commands from being queued to the device.	1731	* commands from being queued to the device.
1732	*	1732	*
1733	* Arguments: shost - Host in question	1733	* Arguments: shost - Host in question
1734	*	1734	*
1735	* Returns: Nothing	1735	* Returns: Nothing
1736	*	1736	*
1737	* Lock status: No locks are assumed held.	1737	* Lock status: No locks are assumed held.
1738	*	1738	*
1739	* Notes: There is no timer nor any other means by which the requests	1739	* Notes: There is no timer nor any other means by which the requests
1740	* get unblocked other than the low-level driver calling	1740	* get unblocked other than the low-level driver calling
1741	* scsi_unblock_requests().	1741	* scsi_unblock_requests().
1742	*/	1742	*/
1743	void scsi_block_requests(struct Scsi_Host *shost)	1743	void scsi_block_requests(struct Scsi_Host *shost)
1744	{	1744	{
1745	shost->host_self_blocked = 1;	1745	shost->host_self_blocked = 1;
1746	}	1746	}
1747	EXPORT_SYMBOL(scsi_block_requests);	1747	EXPORT_SYMBOL(scsi_block_requests);
1748		1748
1749	/*	1749	/*
1750	* Function: scsi_unblock_requests()	1750	* Function: scsi_unblock_requests()
1751	*	1751	*
1752	* Purpose: Utility function used by low-level drivers to allow further	1752	* Purpose: Utility function used by low-level drivers to allow further
1753	* commands from being queued to the device.	1753	* commands from being queued to the device.
1754	*	1754	*
1755	* Arguments: shost - Host in question	1755	* Arguments: shost - Host in question
1756	*	1756	*
1757	* Returns: Nothing	1757	* Returns: Nothing
1758	*	1758	*
1759	* Lock status: No locks are assumed held.	1759	* Lock status: No locks are assumed held.
1760	*	1760	*
1761	* Notes: There is no timer nor any other means by which the requests	1761	* Notes: There is no timer nor any other means by which the requests
1762	* get unblocked other than the low-level driver calling	1762	* get unblocked other than the low-level driver calling
1763	* scsi_unblock_requests().	1763	* scsi_unblock_requests().
1764	*	1764	*
1765	* This is done as an API function so that changes to the	1765	* This is done as an API function so that changes to the
1766	* internals of the scsi mid-layer won't require wholesale	1766	* internals of the scsi mid-layer won't require wholesale
1767	* changes to drivers that use this feature.	1767	* changes to drivers that use this feature.
1768	*/	1768	*/
1769	void scsi_unblock_requests(struct Scsi_Host *shost)	1769	void scsi_unblock_requests(struct Scsi_Host *shost)
1770	{	1770	{
1771	shost->host_self_blocked = 0;	1771	shost->host_self_blocked = 0;
1772	scsi_run_host_queues(shost);	1772	scsi_run_host_queues(shost);
1773	}	1773	}
1774	EXPORT_SYMBOL(scsi_unblock_requests);	1774	EXPORT_SYMBOL(scsi_unblock_requests);
1775		1775
1776	int __init scsi_init_queue(void)	1776	int __init scsi_init_queue(void)
1777	{	1777	{
1778	int i;	1778	int i;
1779		1779
1780	scsi_sdb_cache = kmem_cache_create("scsi_data_buffer",	1780	scsi_sdb_cache = kmem_cache_create("scsi_data_buffer",
1781	sizeof(struct scsi_data_buffer),	1781	sizeof(struct scsi_data_buffer),
1782	0, 0, NULL);	1782	0, 0, NULL);
1783	if (!scsi_sdb_cache) {	1783	if (!scsi_sdb_cache) {
1784	printk(KERN_ERR "SCSI: can't init scsi sdb cache\n");	1784	printk(KERN_ERR "SCSI: can't init scsi sdb cache\n");
1785	return -ENOMEM;	1785	return -ENOMEM;
1786	}	1786	}
1787		1787
1788	for (i = 0; i < SG_MEMPOOL_NR; i++) {	1788	for (i = 0; i < SG_MEMPOOL_NR; i++) {
1789	struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;	1789	struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
1790	int size = sgp->size * sizeof(struct scatterlist);	1790	int size = sgp->size * sizeof(struct scatterlist);
1791		1791
1792	sgp->slab = kmem_cache_create(sgp->name, size, 0,	1792	sgp->slab = kmem_cache_create(sgp->name, size, 0,
1793	SLAB_HWCACHE_ALIGN, NULL);	1793	SLAB_HWCACHE_ALIGN, NULL);
1794	if (!sgp->slab) {	1794	if (!sgp->slab) {
1795	printk(KERN_ERR "SCSI: can't init sg slab %s\n",	1795	printk(KERN_ERR "SCSI: can't init sg slab %s\n",
1796	sgp->name);	1796	sgp->name);
1797	goto cleanup_sdb;	1797	goto cleanup_sdb;
1798	}	1798	}
1799		1799
1800	sgp->pool = mempool_create_slab_pool(SG_MEMPOOL_SIZE,	1800	sgp->pool = mempool_create_slab_pool(SG_MEMPOOL_SIZE,
1801	sgp->slab);	1801	sgp->slab);
1802	if (!sgp->pool) {	1802	if (!sgp->pool) {
1803	printk(KERN_ERR "SCSI: can't init sg mempool %s\n",	1803	printk(KERN_ERR "SCSI: can't init sg mempool %s\n",
1804	sgp->name);	1804	sgp->name);
1805	goto cleanup_sdb;	1805	goto cleanup_sdb;
1806	}	1806	}
1807	}	1807	}
1808		1808
1809	return 0;	1809	return 0;
1810		1810
1811	cleanup_sdb:	1811	cleanup_sdb:
1812	for (i = 0; i < SG_MEMPOOL_NR; i++) {	1812	for (i = 0; i < SG_MEMPOOL_NR; i++) {
1813	struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;	1813	struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
1814	if (sgp->pool)	1814	if (sgp->pool)
1815	mempool_destroy(sgp->pool);	1815	mempool_destroy(sgp->pool);
1816	if (sgp->slab)	1816	if (sgp->slab)
1817	kmem_cache_destroy(sgp->slab);	1817	kmem_cache_destroy(sgp->slab);
1818	}	1818	}
1819	kmem_cache_destroy(scsi_sdb_cache);	1819	kmem_cache_destroy(scsi_sdb_cache);
1820		1820
1821	return -ENOMEM;	1821	return -ENOMEM;
1822	}	1822	}
1823		1823
1824	void scsi_exit_queue(void)	1824	void scsi_exit_queue(void)
1825	{	1825	{
1826	int i;	1826	int i;
1827		1827
1828	kmem_cache_destroy(scsi_sdb_cache);	1828	kmem_cache_destroy(scsi_sdb_cache);
1829		1829
1830	for (i = 0; i < SG_MEMPOOL_NR; i++) {	1830	for (i = 0; i < SG_MEMPOOL_NR; i++) {
1831	struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;	1831	struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
1832	mempool_destroy(sgp->pool);	1832	mempool_destroy(sgp->pool);
1833	kmem_cache_destroy(sgp->slab);	1833	kmem_cache_destroy(sgp->slab);
1834	}	1834	}
1835	}	1835	}
1836		1836
1837	/**	1837	/**
1838	* scsi_mode_select - issue a mode select	1838	* scsi_mode_select - issue a mode select
1839	* @sdev: SCSI device to be queried	1839	* @sdev: SCSI device to be queried
1840	* @pf: Page format bit (1 == standard, 0 == vendor specific)	1840	* @pf: Page format bit (1 == standard, 0 == vendor specific)
1841	* @sp: Save page bit (0 == don't save, 1 == save)	1841	* @sp: Save page bit (0 == don't save, 1 == save)
1842	* @modepage: mode page being requested	1842	* @modepage: mode page being requested
1843	* @buffer: request buffer (may not be smaller than eight bytes)	1843	* @buffer: request buffer (may not be smaller than eight bytes)
1844	* @len: length of request buffer.	1844	* @len: length of request buffer.
1845	* @timeout: command timeout	1845	* @timeout: command timeout
1846	* @retries: number of retries before failing	1846	* @retries: number of retries before failing
1847	* @data: returns a structure abstracting the mode header data	1847	* @data: returns a structure abstracting the mode header data
1848	* @sshdr: place to put sense data (or NULL if no sense to be collected).	1848	* @sshdr: place to put sense data (or NULL if no sense to be collected).
1849	* must be SCSI_SENSE_BUFFERSIZE big.	1849	* must be SCSI_SENSE_BUFFERSIZE big.
1850	*	1850	*
1851	* Returns zero if successful; negative error number or scsi	1851	* Returns zero if successful; negative error number or scsi
1852	* status on error	1852	* status on error
1853	*	1853	*
1854	*/	1854	*/
1855	int	1855	int
1856	scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage,	1856	scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage,
1857	unsigned char *buffer, int len, int timeout, int retries,	1857	unsigned char *buffer, int len, int timeout, int retries,
1858	struct scsi_mode_data data, struct scsi_sense_hdr sshdr)	1858	struct scsi_mode_data data, struct scsi_sense_hdr sshdr)
1859	{	1859	{
1860	unsigned char cmd[10];	1860	unsigned char cmd[10];
1861	unsigned char *real_buffer;	1861	unsigned char *real_buffer;
1862	int ret;	1862	int ret;
1863		1863
1864	memset(cmd, 0, sizeof(cmd));	1864	memset(cmd, 0, sizeof(cmd));
1865	cmd[1] = (pf ? 0x10 : 0) \| (sp ? 0x01 : 0);	1865	cmd[1] = (pf ? 0x10 : 0) \| (sp ? 0x01 : 0);
1866		1866
1867	if (sdev->use_10_for_ms) {	1867	if (sdev->use_10_for_ms) {
1868	if (len > 65535)	1868	if (len > 65535)
1869	return -EINVAL;	1869	return -EINVAL;
1870	real_buffer = kmalloc(8 + len, GFP_KERNEL);	1870	real_buffer = kmalloc(8 + len, GFP_KERNEL);
1871	if (!real_buffer)	1871	if (!real_buffer)
1872	return -ENOMEM;	1872	return -ENOMEM;
1873	memcpy(real_buffer + 8, buffer, len);	1873	memcpy(real_buffer + 8, buffer, len);
1874	len += 8;	1874	len += 8;
1875	real_buffer[0] = 0;	1875	real_buffer[0] = 0;
1876	real_buffer[1] = 0;	1876	real_buffer[1] = 0;
1877	real_buffer[2] = data->medium_type;	1877	real_buffer[2] = data->medium_type;
1878	real_buffer[3] = data->device_specific;	1878	real_buffer[3] = data->device_specific;
1879	real_buffer[4] = data->longlba ? 0x01 : 0;	1879	real_buffer[4] = data->longlba ? 0x01 : 0;
1880	real_buffer[5] = 0;	1880	real_buffer[5] = 0;
1881	real_buffer[6] = data->block_descriptor_length >> 8;	1881	real_buffer[6] = data->block_descriptor_length >> 8;
1882	real_buffer[7] = data->block_descriptor_length;	1882	real_buffer[7] = data->block_descriptor_length;
1883		1883
1884	cmd[0] = MODE_SELECT_10;	1884	cmd[0] = MODE_SELECT_10;
1885	cmd[7] = len >> 8;	1885	cmd[7] = len >> 8;
1886	cmd[8] = len;	1886	cmd[8] = len;
1887	} else {	1887	} else {
1888	if (len > 255 \|\| data->block_descriptor_length > 255 \|\|	1888	if (len > 255 \|\| data->block_descriptor_length > 255 \|\|
1889	data->longlba)	1889	data->longlba)
1890	return -EINVAL;	1890	return -EINVAL;
1891		1891
1892	real_buffer = kmalloc(4 + len, GFP_KERNEL);	1892	real_buffer = kmalloc(4 + len, GFP_KERNEL);
1893	if (!real_buffer)	1893	if (!real_buffer)
1894	return -ENOMEM;	1894	return -ENOMEM;
1895	memcpy(real_buffer + 4, buffer, len);	1895	memcpy(real_buffer + 4, buffer, len);
1896	len += 4;	1896	len += 4;
1897	real_buffer[0] = 0;	1897	real_buffer[0] = 0;
1898	real_buffer[1] = data->medium_type;	1898	real_buffer[1] = data->medium_type;
1899	real_buffer[2] = data->device_specific;	1899	real_buffer[2] = data->device_specific;
1900	real_buffer[3] = data->block_descriptor_length;	1900	real_buffer[3] = data->block_descriptor_length;
1901		1901
1902		1902
1903	cmd[0] = MODE_SELECT;	1903	cmd[0] = MODE_SELECT;
1904	cmd[4] = len;	1904	cmd[4] = len;
1905	}	1905	}
1906		1906
1907	ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len,	1907	ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len,
1908	sshdr, timeout, retries, NULL);	1908	sshdr, timeout, retries, NULL);
1909	kfree(real_buffer);	1909	kfree(real_buffer);
1910	return ret;	1910	return ret;
1911	}	1911	}
1912	EXPORT_SYMBOL_GPL(scsi_mode_select);	1912	EXPORT_SYMBOL_GPL(scsi_mode_select);
1913		1913
1914	/**	1914	/**
1915	* scsi_mode_sense - issue a mode sense, falling back from 10 to six bytes if necessary.	1915	* scsi_mode_sense - issue a mode sense, falling back from 10 to six bytes if necessary.
1916	* @sdev: SCSI device to be queried	1916	* @sdev: SCSI device to be queried
1917	* @dbd: set if mode sense will allow block descriptors to be returned	1917	* @dbd: set if mode sense will allow block descriptors to be returned
1918	* @modepage: mode page being requested	1918	* @modepage: mode page being requested
1919	* @buffer: request buffer (may not be smaller than eight bytes)	1919	* @buffer: request buffer (may not be smaller than eight bytes)
1920	* @len: length of request buffer.	1920	* @len: length of request buffer.
1921	* @timeout: command timeout	1921	* @timeout: command timeout
1922	* @retries: number of retries before failing	1922	* @retries: number of retries before failing
1923	* @data: returns a structure abstracting the mode header data	1923	* @data: returns a structure abstracting the mode header data
1924	* @sshdr: place to put sense data (or NULL if no sense to be collected).	1924	* @sshdr: place to put sense data (or NULL if no sense to be collected).
1925	* must be SCSI_SENSE_BUFFERSIZE big.	1925	* must be SCSI_SENSE_BUFFERSIZE big.
1926	*	1926	*
1927	* Returns zero if unsuccessful, or the header offset (either 4	1927	* Returns zero if unsuccessful, or the header offset (either 4
1928	* or 8 depending on whether a six or ten byte command was	1928	* or 8 depending on whether a six or ten byte command was
1929	* issued) if successful.	1929	* issued) if successful.
1930	*/	1930	*/
1931	int	1931	int
1932	scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,	1932	scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
1933	unsigned char *buffer, int len, int timeout, int retries,	1933	unsigned char *buffer, int len, int timeout, int retries,
1934	struct scsi_mode_data data, struct scsi_sense_hdr sshdr)	1934	struct scsi_mode_data data, struct scsi_sense_hdr sshdr)
1935	{	1935	{
1936	unsigned char cmd[12];	1936	unsigned char cmd[12];
1937	int use_10_for_ms;	1937	int use_10_for_ms;
1938	int header_length;	1938	int header_length;
1939	int result;	1939	int result;
1940	struct scsi_sense_hdr my_sshdr;	1940	struct scsi_sense_hdr my_sshdr;
1941		1941
1942	memset(data, 0, sizeof(*data));	1942	memset(data, 0, sizeof(*data));
1943	memset(&cmd[0], 0, 12);	1943	memset(&cmd[0], 0, 12);
1944	cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */	1944	cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */
1945	cmd[2] = modepage;	1945	cmd[2] = modepage;
1946		1946
1947	/* caller might not be interested in sense, but we need it */	1947	/* caller might not be interested in sense, but we need it */
1948	if (!sshdr)	1948	if (!sshdr)
1949	sshdr = &my_sshdr;	1949	sshdr = &my_sshdr;
1950		1950
1951	retry:	1951	retry:
1952	use_10_for_ms = sdev->use_10_for_ms;	1952	use_10_for_ms = sdev->use_10_for_ms;
1953		1953
1954	if (use_10_for_ms) {	1954	if (use_10_for_ms) {
1955	if (len < 8)	1955	if (len < 8)
1956	len = 8;	1956	len = 8;
1957		1957
1958	cmd[0] = MODE_SENSE_10;	1958	cmd[0] = MODE_SENSE_10;
1959	cmd[8] = len;	1959	cmd[8] = len;
1960	header_length = 8;	1960	header_length = 8;
1961	} else {	1961	} else {
1962	if (len < 4)	1962	if (len < 4)
1963	len = 4;	1963	len = 4;
1964		1964
1965	cmd[0] = MODE_SENSE;	1965	cmd[0] = MODE_SENSE;
1966	cmd[4] = len;	1966	cmd[4] = len;
1967	header_length = 4;	1967	header_length = 4;
1968	}	1968	}
1969		1969
1970	memset(buffer, 0, len);	1970	memset(buffer, 0, len);
1971		1971
1972	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,	1972	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1973	sshdr, timeout, retries, NULL);	1973	sshdr, timeout, retries, NULL);
1974		1974
1975	/* This code looks awful: what it's doing is making sure an	1975	/* This code looks awful: what it's doing is making sure an
1976	* ILLEGAL REQUEST sense return identifies the actual command	1976	* ILLEGAL REQUEST sense return identifies the actual command
1977	* byte as the problem. MODE_SENSE commands can return	1977	* byte as the problem. MODE_SENSE commands can return
1978	* ILLEGAL REQUEST if the code page isn't supported */	1978	* ILLEGAL REQUEST if the code page isn't supported */
1979		1979
1980	if (use_10_for_ms && !scsi_status_is_good(result) &&	1980	if (use_10_for_ms && !scsi_status_is_good(result) &&
1981	(driver_byte(result) & DRIVER_SENSE)) {	1981	(driver_byte(result) & DRIVER_SENSE)) {
1982	if (scsi_sense_valid(sshdr)) {	1982	if (scsi_sense_valid(sshdr)) {
1983	if ((sshdr->sense_key == ILLEGAL_REQUEST) &&	1983	if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
1984	(sshdr->asc == 0x20) && (sshdr->ascq == 0)) {	1984	(sshdr->asc == 0x20) && (sshdr->ascq == 0)) {
1985	/*	1985	/*
1986	* Invalid command operation code	1986	* Invalid command operation code
1987	*/	1987	*/
1988	sdev->use_10_for_ms = 0;	1988	sdev->use_10_for_ms = 0;
1989	goto retry;	1989	goto retry;
1990	}	1990	}
1991	}	1991	}
1992	}	1992	}
1993		1993
1994	if(scsi_status_is_good(result)) {	1994	if(scsi_status_is_good(result)) {
1995	if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b &&	1995	if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b &&
1996	(modepage == 6 \|\| modepage == 8))) {	1996	(modepage == 6 \|\| modepage == 8))) {
1997	/* Initio breakage? */	1997	/* Initio breakage? */
1998	header_length = 0;	1998	header_length = 0;
1999	data->length = 13;	1999	data->length = 13;
2000	data->medium_type = 0;	2000	data->medium_type = 0;
2001	data->device_specific = 0;	2001	data->device_specific = 0;
2002	data->longlba = 0;	2002	data->longlba = 0;
2003	data->block_descriptor_length = 0;	2003	data->block_descriptor_length = 0;
2004	} else if(use_10_for_ms) {	2004	} else if(use_10_for_ms) {
2005	data->length = buffer[0]*256 + buffer[1] + 2;	2005	data->length = buffer[0]*256 + buffer[1] + 2;
2006	data->medium_type = buffer[2];	2006	data->medium_type = buffer[2];
2007	data->device_specific = buffer[3];	2007	data->device_specific = buffer[3];
2008	data->longlba = buffer[4] & 0x01;	2008	data->longlba = buffer[4] & 0x01;
2009	data->block_descriptor_length = buffer[6]*256	2009	data->block_descriptor_length = buffer[6]*256
2010	+ buffer[7];	2010	+ buffer[7];
2011	} else {	2011	} else {
2012	data->length = buffer[0] + 1;	2012	data->length = buffer[0] + 1;
2013	data->medium_type = buffer[1];	2013	data->medium_type = buffer[1];
2014	data->device_specific = buffer[2];	2014	data->device_specific = buffer[2];
2015	data->block_descriptor_length = buffer[3];	2015	data->block_descriptor_length = buffer[3];
2016	}	2016	}
2017	data->header_length = header_length;	2017	data->header_length = header_length;
2018	}	2018	}
2019		2019
2020	return result;	2020	return result;
2021	}	2021	}
2022	EXPORT_SYMBOL(scsi_mode_sense);	2022	EXPORT_SYMBOL(scsi_mode_sense);
2023		2023
2024	/**	2024	/**
2025	* scsi_test_unit_ready - test if unit is ready	2025	* scsi_test_unit_ready - test if unit is ready
2026	* @sdev: scsi device to change the state of.	2026	* @sdev: scsi device to change the state of.
2027	* @timeout: command timeout	2027	* @timeout: command timeout
2028	* @retries: number of retries before failing	2028	* @retries: number of retries before failing
2029	* @sshdr_external: Optional pointer to struct scsi_sense_hdr for	2029	* @sshdr_external: Optional pointer to struct scsi_sense_hdr for
2030	* returning sense. Make sure that this is cleared before passing	2030	* returning sense. Make sure that this is cleared before passing
2031	* in.	2031	* in.
2032	*	2032	*
2033	* Returns zero if unsuccessful or an error if TUR failed. For	2033	* Returns zero if unsuccessful or an error if TUR failed. For
2034	* removable media, UNIT_ATTENTION sets ->changed flag.	2034	* removable media, UNIT_ATTENTION sets ->changed flag.
2035	**/	2035	**/
2036	int	2036	int
2037	scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries,	2037	scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries,
2038	struct scsi_sense_hdr *sshdr_external)	2038	struct scsi_sense_hdr *sshdr_external)
2039	{	2039	{
2040	char cmd[] = {	2040	char cmd[] = {
2041	TEST_UNIT_READY, 0, 0, 0, 0, 0,	2041	TEST_UNIT_READY, 0, 0, 0, 0, 0,
2042	};	2042	};
2043	struct scsi_sense_hdr *sshdr;	2043	struct scsi_sense_hdr *sshdr;
2044	int result;	2044	int result;
2045		2045
2046	if (!sshdr_external)	2046	if (!sshdr_external)
2047	sshdr = kzalloc(sizeof(*sshdr), GFP_KERNEL);	2047	sshdr = kzalloc(sizeof(*sshdr), GFP_KERNEL);
2048	else	2048	else
2049	sshdr = sshdr_external;	2049	sshdr = sshdr_external;
2050		2050
2051	/* try to eat the UNIT_ATTENTION if there are enough retries */	2051	/* try to eat the UNIT_ATTENTION if there are enough retries */
2052	do {	2052	do {
2053	result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, sshdr,	2053	result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, sshdr,
2054	timeout, retries, NULL);	2054	timeout, retries, NULL);
2055	if (sdev->removable && scsi_sense_valid(sshdr) &&	2055	if (sdev->removable && scsi_sense_valid(sshdr) &&
2056	sshdr->sense_key == UNIT_ATTENTION)	2056	sshdr->sense_key == UNIT_ATTENTION)
2057	sdev->changed = 1;	2057	sdev->changed = 1;
2058	} while (scsi_sense_valid(sshdr) &&	2058	} while (scsi_sense_valid(sshdr) &&
2059	sshdr->sense_key == UNIT_ATTENTION && --retries);	2059	sshdr->sense_key == UNIT_ATTENTION && --retries);
2060		2060
2061	if (!sshdr_external)	2061	if (!sshdr_external)
2062	kfree(sshdr);	2062	kfree(sshdr);
2063	return result;	2063	return result;
2064	}	2064	}
2065	EXPORT_SYMBOL(scsi_test_unit_ready);	2065	EXPORT_SYMBOL(scsi_test_unit_ready);
2066		2066
2067	/**	2067	/**
2068	* scsi_device_set_state - Take the given device through the device state model.	2068	* scsi_device_set_state - Take the given device through the device state model.
2069	* @sdev: scsi device to change the state of.	2069	* @sdev: scsi device to change the state of.
2070	* @state: state to change to.	2070	* @state: state to change to.
2071	*	2071	*
2072	* Returns zero if unsuccessful or an error if the requested	2072	* Returns zero if unsuccessful or an error if the requested
2073	* transition is illegal.	2073	* transition is illegal.
2074	*/	2074	*/
2075	int	2075	int
2076	scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)	2076	scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)
2077	{	2077	{
2078	enum scsi_device_state oldstate = sdev->sdev_state;	2078	enum scsi_device_state oldstate = sdev->sdev_state;
2079		2079
2080	if (state == oldstate)	2080	if (state == oldstate)
2081	return 0;	2081	return 0;
2082		2082
2083	switch (state) {	2083	switch (state) {
2084	case SDEV_CREATED:	2084	case SDEV_CREATED:
2085	switch (oldstate) {	2085	switch (oldstate) {
2086	case SDEV_CREATED_BLOCK:	2086	case SDEV_CREATED_BLOCK:
2087	break;	2087	break;
2088	default:	2088	default:
2089	goto illegal;	2089	goto illegal;
2090	}	2090	}
2091	break;	2091	break;
2092		2092
2093	case SDEV_RUNNING:	2093	case SDEV_RUNNING:
2094	switch (oldstate) {	2094	switch (oldstate) {
2095	case SDEV_CREATED:	2095	case SDEV_CREATED:
2096	case SDEV_OFFLINE:	2096	case SDEV_OFFLINE:
2097	case SDEV_TRANSPORT_OFFLINE:	2097	case SDEV_TRANSPORT_OFFLINE:
2098	case SDEV_QUIESCE:	2098	case SDEV_QUIESCE:
2099	case SDEV_BLOCK:	2099	case SDEV_BLOCK:
2100	break;	2100	break;
2101	default:	2101	default:
2102	goto illegal;	2102	goto illegal;
2103	}	2103	}
2104	break;	2104	break;
2105		2105
2106	case SDEV_QUIESCE:	2106	case SDEV_QUIESCE:
2107	switch (oldstate) {	2107	switch (oldstate) {
2108	case SDEV_RUNNING:	2108	case SDEV_RUNNING:
2109	case SDEV_OFFLINE:	2109	case SDEV_OFFLINE:
2110	case SDEV_TRANSPORT_OFFLINE:	2110	case SDEV_TRANSPORT_OFFLINE:
2111	break;	2111	break;
2112	default:	2112	default:
2113	goto illegal;	2113	goto illegal;
2114	}	2114	}
2115	break;	2115	break;
2116		2116
2117	case SDEV_OFFLINE:	2117	case SDEV_OFFLINE:
2118	case SDEV_TRANSPORT_OFFLINE:	2118	case SDEV_TRANSPORT_OFFLINE:
2119	switch (oldstate) {	2119	switch (oldstate) {
2120	case SDEV_CREATED:	2120	case SDEV_CREATED:
2121	case SDEV_RUNNING:	2121	case SDEV_RUNNING:
2122	case SDEV_QUIESCE:	2122	case SDEV_QUIESCE:
2123	case SDEV_BLOCK:	2123	case SDEV_BLOCK:
2124	break;	2124	break;
2125	default:	2125	default:
2126	goto illegal;	2126	goto illegal;
2127	}	2127	}
2128	break;	2128	break;
2129		2129
2130	case SDEV_BLOCK:	2130	case SDEV_BLOCK:
2131	switch (oldstate) {	2131	switch (oldstate) {
2132	case SDEV_RUNNING:	2132	case SDEV_RUNNING:
2133	case SDEV_CREATED_BLOCK:	2133	case SDEV_CREATED_BLOCK:
2134	break;	2134	break;
2135	default:	2135	default:
2136	goto illegal;	2136	goto illegal;
2137	}	2137	}
2138	break;	2138	break;
2139		2139
2140	case SDEV_CREATED_BLOCK:	2140	case SDEV_CREATED_BLOCK:
2141	switch (oldstate) {	2141	switch (oldstate) {
2142	case SDEV_CREATED:	2142	case SDEV_CREATED:
2143	break;	2143	break;
2144	default:	2144	default:
2145	goto illegal;	2145	goto illegal;
2146	}	2146	}
2147	break;	2147	break;
2148		2148
2149	case SDEV_CANCEL:	2149	case SDEV_CANCEL:
2150	switch (oldstate) {	2150	switch (oldstate) {
2151	case SDEV_CREATED:	2151	case SDEV_CREATED:
2152	case SDEV_RUNNING:	2152	case SDEV_RUNNING:
2153	case SDEV_QUIESCE:	2153	case SDEV_QUIESCE:
2154	case SDEV_OFFLINE:	2154	case SDEV_OFFLINE:
2155	case SDEV_TRANSPORT_OFFLINE:	2155	case SDEV_TRANSPORT_OFFLINE:
2156	case SDEV_BLOCK:	2156	case SDEV_BLOCK:
2157	break;	2157	break;
2158	default:	2158	default:
2159	goto illegal;	2159	goto illegal;
2160	}	2160	}
2161	break;	2161	break;
2162		2162
2163	case SDEV_DEL:	2163	case SDEV_DEL:
2164	switch (oldstate) {	2164	switch (oldstate) {
2165	case SDEV_CREATED:	2165	case SDEV_CREATED:
2166	case SDEV_RUNNING:	2166	case SDEV_RUNNING:
2167	case SDEV_OFFLINE:	2167	case SDEV_OFFLINE:
2168	case SDEV_TRANSPORT_OFFLINE:	2168	case SDEV_TRANSPORT_OFFLINE:
2169	case SDEV_CANCEL:	2169	case SDEV_CANCEL:
2170	case SDEV_CREATED_BLOCK:	2170	case SDEV_CREATED_BLOCK:
2171	break;	2171	break;
2172	default:	2172	default:
2173	goto illegal;	2173	goto illegal;
2174	}	2174	}
2175	break;	2175	break;
2176		2176
2177	}	2177	}
2178	sdev->sdev_state = state;	2178	sdev->sdev_state = state;
2179	return 0;	2179	return 0;
2180		2180
2181	illegal:	2181	illegal:
2182	SCSI_LOG_ERROR_RECOVERY(1,	2182	SCSI_LOG_ERROR_RECOVERY(1,
2183	sdev_printk(KERN_ERR, sdev,	2183	sdev_printk(KERN_ERR, sdev,
2184	"Illegal state transition %s->%s",	2184	"Illegal state transition %s->%s",
2185	scsi_device_state_name(oldstate),	2185	scsi_device_state_name(oldstate),
2186	scsi_device_state_name(state))	2186	scsi_device_state_name(state))
2187	);	2187	);
2188	return -EINVAL;	2188	return -EINVAL;
2189	}	2189	}
2190	EXPORT_SYMBOL(scsi_device_set_state);	2190	EXPORT_SYMBOL(scsi_device_set_state);
2191		2191
2192	/**	2192	/**
2193	* sdev_evt_emit - emit a single SCSI device uevent	2193	* sdev_evt_emit - emit a single SCSI device uevent
2194	* @sdev: associated SCSI device	2194	* @sdev: associated SCSI device
2195	* @evt: event to emit	2195	* @evt: event to emit
2196	*	2196	*
2197	* Send a single uevent (scsi_event) to the associated scsi_device.	2197	* Send a single uevent (scsi_event) to the associated scsi_device.
2198	*/	2198	*/
2199	static void scsi_evt_emit(struct scsi_device sdev, struct scsi_event evt)	2199	static void scsi_evt_emit(struct scsi_device sdev, struct scsi_event evt)
2200	{	2200	{
2201	int idx = 0;	2201	int idx = 0;
2202	char *envp[3];	2202	char *envp[3];
2203		2203
2204	switch (evt->evt_type) {	2204	switch (evt->evt_type) {
2205	case SDEV_EVT_MEDIA_CHANGE:	2205	case SDEV_EVT_MEDIA_CHANGE:
2206	envp[idx++] = "SDEV_MEDIA_CHANGE=1";	2206	envp[idx++] = "SDEV_MEDIA_CHANGE=1";
2207	break;	2207	break;
2208	case SDEV_EVT_INQUIRY_CHANGE_REPORTED:	2208	case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
2209	envp[idx++] = "SDEV_UA=INQUIRY_DATA_HAS_CHANGED";	2209	envp[idx++] = "SDEV_UA=INQUIRY_DATA_HAS_CHANGED";
2210	break;	2210	break;
2211	case SDEV_EVT_CAPACITY_CHANGE_REPORTED:	2211	case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
2212	envp[idx++] = "SDEV_UA=CAPACITY_DATA_HAS_CHANGED";	2212	envp[idx++] = "SDEV_UA=CAPACITY_DATA_HAS_CHANGED";
2213	break;	2213	break;
2214	case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:	2214	case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
2215	envp[idx++] = "SDEV_UA=THIN_PROVISIONING_SOFT_THRESHOLD_REACHED";	2215	envp[idx++] = "SDEV_UA=THIN_PROVISIONING_SOFT_THRESHOLD_REACHED";
2216	break;	2216	break;
2217	case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:	2217	case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
2218	envp[idx++] = "SDEV_UA=MODE_PARAMETERS_CHANGED";	2218	envp[idx++] = "SDEV_UA=MODE_PARAMETERS_CHANGED";
2219	break;	2219	break;
2220	case SDEV_EVT_LUN_CHANGE_REPORTED:	2220	case SDEV_EVT_LUN_CHANGE_REPORTED:
2221	envp[idx++] = "SDEV_UA=REPORTED_LUNS_DATA_HAS_CHANGED";	2221	envp[idx++] = "SDEV_UA=REPORTED_LUNS_DATA_HAS_CHANGED";
2222	break;	2222	break;
2223	default:	2223	default:
2224	/* do nothing */	2224	/* do nothing */
2225	break;	2225	break;
2226	}	2226	}
2227		2227
2228	envp[idx++] = NULL;	2228	envp[idx++] = NULL;
2229		2229
2230	kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp);	2230	kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp);
2231	}	2231	}
2232		2232
2233	/**	2233	/**
2234	* sdev_evt_thread - send a uevent for each scsi event	2234	* sdev_evt_thread - send a uevent for each scsi event
2235	* @work: work struct for scsi_device	2235	* @work: work struct for scsi_device
2236	*	2236	*
2237	* Dispatch queued events to their associated scsi_device kobjects	2237	* Dispatch queued events to their associated scsi_device kobjects
2238	* as uevents.	2238	* as uevents.
2239	*/	2239	*/
2240	void scsi_evt_thread(struct work_struct *work)	2240	void scsi_evt_thread(struct work_struct *work)
2241	{	2241	{
2242	struct scsi_device *sdev;	2242	struct scsi_device *sdev;
2243	enum scsi_device_event evt_type;	2243	enum scsi_device_event evt_type;
2244	LIST_HEAD(event_list);	2244	LIST_HEAD(event_list);
2245		2245
2246	sdev = container_of(work, struct scsi_device, event_work);	2246	sdev = container_of(work, struct scsi_device, event_work);
2247		2247
2248	for (evt_type = SDEV_EVT_FIRST; evt_type <= SDEV_EVT_LAST; evt_type++)	2248	for (evt_type = SDEV_EVT_FIRST; evt_type <= SDEV_EVT_LAST; evt_type++)
2249	if (test_and_clear_bit(evt_type, sdev->pending_events))	2249	if (test_and_clear_bit(evt_type, sdev->pending_events))
2250	sdev_evt_send_simple(sdev, evt_type, GFP_KERNEL);	2250	sdev_evt_send_simple(sdev, evt_type, GFP_KERNEL);
2251		2251
2252	while (1) {	2252	while (1) {
2253	struct scsi_event *evt;	2253	struct scsi_event *evt;
2254	struct list_head this, tmp;	2254	struct list_head this, tmp;
2255	unsigned long flags;	2255	unsigned long flags;
2256		2256
2257	spin_lock_irqsave(&sdev->list_lock, flags);	2257	spin_lock_irqsave(&sdev->list_lock, flags);
2258	list_splice_init(&sdev->event_list, &event_list);	2258	list_splice_init(&sdev->event_list, &event_list);
2259	spin_unlock_irqrestore(&sdev->list_lock, flags);	2259	spin_unlock_irqrestore(&sdev->list_lock, flags);
2260		2260
2261	if (list_empty(&event_list))	2261	if (list_empty(&event_list))
2262	break;	2262	break;
2263		2263
2264	list_for_each_safe(this, tmp, &event_list) {	2264	list_for_each_safe(this, tmp, &event_list) {
2265	evt = list_entry(this, struct scsi_event, node);	2265	evt = list_entry(this, struct scsi_event, node);
2266	list_del(&evt->node);	2266	list_del(&evt->node);
2267	scsi_evt_emit(sdev, evt);	2267	scsi_evt_emit(sdev, evt);
2268	kfree(evt);	2268	kfree(evt);
2269	}	2269	}
2270	}	2270	}
2271	}	2271	}
2272		2272
2273	/**	2273	/**
2274	* sdev_evt_send - send asserted event to uevent thread	2274	* sdev_evt_send - send asserted event to uevent thread
2275	* @sdev: scsi_device event occurred on	2275	* @sdev: scsi_device event occurred on
2276	* @evt: event to send	2276	* @evt: event to send
2277	*	2277	*
2278	* Assert scsi device event asynchronously.	2278	* Assert scsi device event asynchronously.
2279	*/	2279	*/
2280	void sdev_evt_send(struct scsi_device sdev, struct scsi_event evt)	2280	void sdev_evt_send(struct scsi_device sdev, struct scsi_event evt)
2281	{	2281	{
2282	unsigned long flags;	2282	unsigned long flags;
2283		2283
2284	#if 0	2284	#if 0
2285	/* FIXME: currently this check eliminates all media change events	2285	/* FIXME: currently this check eliminates all media change events
2286	* for polled devices. Need to update to discriminate between AN	2286	* for polled devices. Need to update to discriminate between AN
2287	* and polled events */	2287	* and polled events */
2288	if (!test_bit(evt->evt_type, sdev->supported_events)) {	2288	if (!test_bit(evt->evt_type, sdev->supported_events)) {
2289	kfree(evt);	2289	kfree(evt);
2290	return;	2290	return;
2291	}	2291	}
2292	#endif	2292	#endif
2293		2293
2294	spin_lock_irqsave(&sdev->list_lock, flags);	2294	spin_lock_irqsave(&sdev->list_lock, flags);
2295	list_add_tail(&evt->node, &sdev->event_list);	2295	list_add_tail(&evt->node, &sdev->event_list);
2296	schedule_work(&sdev->event_work);	2296	schedule_work(&sdev->event_work);
2297	spin_unlock_irqrestore(&sdev->list_lock, flags);	2297	spin_unlock_irqrestore(&sdev->list_lock, flags);
2298	}	2298	}
2299	EXPORT_SYMBOL_GPL(sdev_evt_send);	2299	EXPORT_SYMBOL_GPL(sdev_evt_send);
2300		2300
2301	/**	2301	/**
2302	* sdev_evt_alloc - allocate a new scsi event	2302	* sdev_evt_alloc - allocate a new scsi event
2303	* @evt_type: type of event to allocate	2303	* @evt_type: type of event to allocate
2304	* @gfpflags: GFP flags for allocation	2304	* @gfpflags: GFP flags for allocation
2305	*	2305	*
2306	* Allocates and returns a new scsi_event.	2306	* Allocates and returns a new scsi_event.
2307	*/	2307	*/
2308	struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,	2308	struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
2309	gfp_t gfpflags)	2309	gfp_t gfpflags)
2310	{	2310	{
2311	struct scsi_event *evt = kzalloc(sizeof(struct scsi_event), gfpflags);	2311	struct scsi_event *evt = kzalloc(sizeof(struct scsi_event), gfpflags);
2312	if (!evt)	2312	if (!evt)
2313	return NULL;	2313	return NULL;
2314		2314
2315	evt->evt_type = evt_type;	2315	evt->evt_type = evt_type;
2316	INIT_LIST_HEAD(&evt->node);	2316	INIT_LIST_HEAD(&evt->node);
2317		2317
2318	/* evt_type-specific initialization, if any */	2318	/* evt_type-specific initialization, if any */
2319	switch (evt_type) {	2319	switch (evt_type) {
2320	case SDEV_EVT_MEDIA_CHANGE:	2320	case SDEV_EVT_MEDIA_CHANGE:
2321	case SDEV_EVT_INQUIRY_CHANGE_REPORTED:	2321	case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
2322	case SDEV_EVT_CAPACITY_CHANGE_REPORTED:	2322	case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
2323	case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:	2323	case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
2324	case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:	2324	case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
2325	case SDEV_EVT_LUN_CHANGE_REPORTED:	2325	case SDEV_EVT_LUN_CHANGE_REPORTED:
2326	default:	2326	default:
2327	/* do nothing */	2327	/* do nothing */
2328	break;	2328	break;
2329	}	2329	}
2330		2330
2331	return evt;	2331	return evt;
2332	}	2332	}
2333	EXPORT_SYMBOL_GPL(sdev_evt_alloc);	2333	EXPORT_SYMBOL_GPL(sdev_evt_alloc);
2334		2334
2335	/**	2335	/**
2336	* sdev_evt_send_simple - send asserted event to uevent thread	2336	* sdev_evt_send_simple - send asserted event to uevent thread
2337	* @sdev: scsi_device event occurred on	2337	* @sdev: scsi_device event occurred on
2338	* @evt_type: type of event to send	2338	* @evt_type: type of event to send
2339	* @gfpflags: GFP flags for allocation	2339	* @gfpflags: GFP flags for allocation
2340	*	2340	*
2341	* Assert scsi device event asynchronously, given an event type.	2341	* Assert scsi device event asynchronously, given an event type.
2342	*/	2342	*/
2343	void sdev_evt_send_simple(struct scsi_device *sdev,	2343	void sdev_evt_send_simple(struct scsi_device *sdev,
2344	enum scsi_device_event evt_type, gfp_t gfpflags)	2344	enum scsi_device_event evt_type, gfp_t gfpflags)
2345	{	2345	{
2346	struct scsi_event *evt = sdev_evt_alloc(evt_type, gfpflags);	2346	struct scsi_event *evt = sdev_evt_alloc(evt_type, gfpflags);
2347	if (!evt) {	2347	if (!evt) {
2348	sdev_printk(KERN_ERR, sdev, "event %d eaten due to OOM\n",	2348	sdev_printk(KERN_ERR, sdev, "event %d eaten due to OOM\n",
2349	evt_type);	2349	evt_type);
2350	return;	2350	return;
2351	}	2351	}
2352		2352
2353	sdev_evt_send(sdev, evt);	2353	sdev_evt_send(sdev, evt);
2354	}	2354	}
2355	EXPORT_SYMBOL_GPL(sdev_evt_send_simple);	2355	EXPORT_SYMBOL_GPL(sdev_evt_send_simple);
2356		2356
2357	/**	2357	/**
2358	* scsi_device_quiesce - Block user issued commands.	2358	* scsi_device_quiesce - Block user issued commands.
2359	* @sdev: scsi device to quiesce.	2359	* @sdev: scsi device to quiesce.
2360	*	2360	*
2361	* This works by trying to transition to the SDEV_QUIESCE state	2361	* This works by trying to transition to the SDEV_QUIESCE state
2362	* (which must be a legal transition). When the device is in this	2362	* (which must be a legal transition). When the device is in this
2363	* state, only special requests will be accepted, all others will	2363	* state, only special requests will be accepted, all others will
2364	* be deferred. Since special requests may also be requeued requests,	2364	* be deferred. Since special requests may also be requeued requests,
2365	* a successful return doesn't guarantee the device will be	2365	* a successful return doesn't guarantee the device will be
2366	* totally quiescent.	2366	* totally quiescent.
2367	*	2367	*
2368	* Must be called with user context, may sleep.	2368	* Must be called with user context, may sleep.
2369	*	2369	*
2370	* Returns zero if unsuccessful or an error if not.	2370	* Returns zero if unsuccessful or an error if not.
2371	*/	2371	*/
2372	int	2372	int
2373	scsi_device_quiesce(struct scsi_device *sdev)	2373	scsi_device_quiesce(struct scsi_device *sdev)
2374	{	2374	{
2375	int err = scsi_device_set_state(sdev, SDEV_QUIESCE);	2375	int err = scsi_device_set_state(sdev, SDEV_QUIESCE);
2376	if (err)	2376	if (err)
2377	return err;	2377	return err;
2378		2378
2379	scsi_run_queue(sdev->request_queue);	2379	scsi_run_queue(sdev->request_queue);
2380	while (atomic_read(&sdev->device_busy)) {	2380	while (atomic_read(&sdev->device_busy)) {
2381	msleep_interruptible(200);	2381	msleep_interruptible(200);
2382	scsi_run_queue(sdev->request_queue);	2382	scsi_run_queue(sdev->request_queue);
2383	}	2383	}
2384	return 0;	2384	return 0;
2385	}	2385	}
2386	EXPORT_SYMBOL(scsi_device_quiesce);	2386	EXPORT_SYMBOL(scsi_device_quiesce);
2387		2387
2388	/**	2388	/**
2389	* scsi_device_resume - Restart user issued commands to a quiesced device.	2389	* scsi_device_resume - Restart user issued commands to a quiesced device.
2390	* @sdev: scsi device to resume.	2390	* @sdev: scsi device to resume.
2391	*	2391	*
2392	* Moves the device from quiesced back to running and restarts the	2392	* Moves the device from quiesced back to running and restarts the
2393	* queues.	2393	* queues.
2394	*	2394	*
2395	* Must be called with user context, may sleep.	2395	* Must be called with user context, may sleep.
2396	*/	2396	*/
2397	void scsi_device_resume(struct scsi_device *sdev)	2397	void scsi_device_resume(struct scsi_device *sdev)
2398	{	2398	{
2399	/* check if the device state was mutated prior to resume, and if	2399	/* check if the device state was mutated prior to resume, and if
2400	* so assume the state is being managed elsewhere (for example	2400	* so assume the state is being managed elsewhere (for example
2401	* device deleted during suspend)	2401	* device deleted during suspend)
2402	*/	2402	*/
2403	if (sdev->sdev_state != SDEV_QUIESCE \|\|	2403	if (sdev->sdev_state != SDEV_QUIESCE \|\|
2404	scsi_device_set_state(sdev, SDEV_RUNNING))	2404	scsi_device_set_state(sdev, SDEV_RUNNING))
2405	return;	2405	return;
2406	scsi_run_queue(sdev->request_queue);	2406	scsi_run_queue(sdev->request_queue);
2407	}	2407	}
2408	EXPORT_SYMBOL(scsi_device_resume);	2408	EXPORT_SYMBOL(scsi_device_resume);
2409		2409
2410	static void	2410	static void
2411	device_quiesce_fn(struct scsi_device sdev, void data)	2411	device_quiesce_fn(struct scsi_device sdev, void data)
2412	{	2412	{
2413	scsi_device_quiesce(sdev);	2413	scsi_device_quiesce(sdev);
2414	}	2414	}
2415		2415
2416	void	2416	void
2417	scsi_target_quiesce(struct scsi_target *starget)	2417	scsi_target_quiesce(struct scsi_target *starget)
2418	{	2418	{
2419	starget_for_each_device(starget, NULL, device_quiesce_fn);	2419	starget_for_each_device(starget, NULL, device_quiesce_fn);
2420	}	2420	}
2421	EXPORT_SYMBOL(scsi_target_quiesce);	2421	EXPORT_SYMBOL(scsi_target_quiesce);
2422		2422
2423	static void	2423	static void
2424	device_resume_fn(struct scsi_device sdev, void data)	2424	device_resume_fn(struct scsi_device sdev, void data)
2425	{	2425	{
2426	scsi_device_resume(sdev);	2426	scsi_device_resume(sdev);
2427	}	2427	}
2428		2428
2429	void	2429	void
2430	scsi_target_resume(struct scsi_target *starget)	2430	scsi_target_resume(struct scsi_target *starget)
2431	{	2431	{
2432	starget_for_each_device(starget, NULL, device_resume_fn);	2432	starget_for_each_device(starget, NULL, device_resume_fn);
2433	}	2433	}
2434	EXPORT_SYMBOL(scsi_target_resume);	2434	EXPORT_SYMBOL(scsi_target_resume);
2435		2435
2436	/**	2436	/**
2437	* scsi_internal_device_block - internal function to put a device temporarily into the SDEV_BLOCK state	2437	* scsi_internal_device_block - internal function to put a device temporarily into the SDEV_BLOCK state
2438	* @sdev: device to block	2438	* @sdev: device to block
2439	*	2439	*
2440	* Block request made by scsi lld's to temporarily stop all	2440	* Block request made by scsi lld's to temporarily stop all
2441	* scsi commands on the specified device. Called from interrupt	2441	* scsi commands on the specified device. Called from interrupt
2442	* or normal process context.	2442	* or normal process context.
2443	*	2443	*
2444	* Returns zero if successful or error if not	2444	* Returns zero if successful or error if not
2445	*	2445	*
2446	* Notes:	2446	* Notes:
2447	* This routine transitions the device to the SDEV_BLOCK state	2447	* This routine transitions the device to the SDEV_BLOCK state
2448	* (which must be a legal transition). When the device is in this	2448	* (which must be a legal transition). When the device is in this
2449	* state, all commands are deferred until the scsi lld reenables	2449	* state, all commands are deferred until the scsi lld reenables
2450	* the device with scsi_device_unblock or device_block_tmo fires.	2450	* the device with scsi_device_unblock or device_block_tmo fires.
2451	*/	2451	*/
2452	int	2452	int
2453	scsi_internal_device_block(struct scsi_device *sdev)	2453	scsi_internal_device_block(struct scsi_device *sdev)
2454	{	2454	{
2455	struct request_queue *q = sdev->request_queue;	2455	struct request_queue *q = sdev->request_queue;
2456	unsigned long flags;	2456	unsigned long flags;
2457	int err = 0;	2457	int err = 0;
2458		2458
2459	err = scsi_device_set_state(sdev, SDEV_BLOCK);	2459	err = scsi_device_set_state(sdev, SDEV_BLOCK);
2460	if (err) {	2460	if (err) {
2461	err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK);	2461	err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK);
2462		2462
2463	if (err)	2463	if (err)
2464	return err;	2464	return err;
2465	}	2465	}
2466		2466
2467	/*	2467	/*
2468	* The device has transitioned to SDEV_BLOCK. Stop the	2468	* The device has transitioned to SDEV_BLOCK. Stop the
2469	* block layer from calling the midlayer with this device's	2469	* block layer from calling the midlayer with this device's
2470	* request queue.	2470	* request queue.
2471	*/	2471	*/
2472	spin_lock_irqsave(q->queue_lock, flags);	2472	spin_lock_irqsave(q->queue_lock, flags);
2473	blk_stop_queue(q);	2473	blk_stop_queue(q);
2474	spin_unlock_irqrestore(q->queue_lock, flags);	2474	spin_unlock_irqrestore(q->queue_lock, flags);
2475		2475
2476	return 0;	2476	return 0;
2477	}	2477	}
2478	EXPORT_SYMBOL_GPL(scsi_internal_device_block);	2478	EXPORT_SYMBOL_GPL(scsi_internal_device_block);
2479		2479
2480	/**	2480	/**
2481	* scsi_internal_device_unblock - resume a device after a block request	2481	* scsi_internal_device_unblock - resume a device after a block request
2482	* @sdev: device to resume	2482	* @sdev: device to resume
2483	* @new_state: state to set devices to after unblocking	2483	* @new_state: state to set devices to after unblocking
2484	*	2484	*
2485	* Called by scsi lld's or the midlayer to restart the device queue	2485	* Called by scsi lld's or the midlayer to restart the device queue
2486	* for the previously suspended scsi device. Called from interrupt or	2486	* for the previously suspended scsi device. Called from interrupt or
2487	* normal process context.	2487	* normal process context.
2488	*	2488	*
2489	* Returns zero if successful or error if not.	2489	* Returns zero if successful or error if not.
2490	*	2490	*
2491	* Notes:	2491	* Notes:
2492	* This routine transitions the device to the SDEV_RUNNING state	2492	* This routine transitions the device to the SDEV_RUNNING state
2493	* or to one of the offline states (which must be a legal transition)	2493	* or to one of the offline states (which must be a legal transition)
2494	* allowing the midlayer to goose the queue for this device.	2494	* allowing the midlayer to goose the queue for this device.
2495	*/	2495	*/
2496	int	2496	int
2497	scsi_internal_device_unblock(struct scsi_device *sdev,	2497	scsi_internal_device_unblock(struct scsi_device *sdev,
2498	enum scsi_device_state new_state)	2498	enum scsi_device_state new_state)
2499	{	2499	{
2500	struct request_queue *q = sdev->request_queue;	2500	struct request_queue *q = sdev->request_queue;
2501	unsigned long flags;	2501	unsigned long flags;
2502		2502
2503	/*	2503	/*
2504	* Try to transition the scsi device to SDEV_RUNNING or one of the	2504	* Try to transition the scsi device to SDEV_RUNNING or one of the
2505	* offlined states and goose the device queue if successful.	2505	* offlined states and goose the device queue if successful.
2506	*/	2506	*/
2507	if ((sdev->sdev_state == SDEV_BLOCK) \|\|	2507	if ((sdev->sdev_state == SDEV_BLOCK) \|\|
2508	(sdev->sdev_state == SDEV_TRANSPORT_OFFLINE))	2508	(sdev->sdev_state == SDEV_TRANSPORT_OFFLINE))
2509	sdev->sdev_state = new_state;	2509	sdev->sdev_state = new_state;
2510	else if (sdev->sdev_state == SDEV_CREATED_BLOCK) {	2510	else if (sdev->sdev_state == SDEV_CREATED_BLOCK) {
2511	if (new_state == SDEV_TRANSPORT_OFFLINE \|\|	2511	if (new_state == SDEV_TRANSPORT_OFFLINE \|\|
2512	new_state == SDEV_OFFLINE)	2512	new_state == SDEV_OFFLINE)
2513	sdev->sdev_state = new_state;	2513	sdev->sdev_state = new_state;
2514	else	2514	else
2515	sdev->sdev_state = SDEV_CREATED;	2515	sdev->sdev_state = SDEV_CREATED;
2516	} else if (sdev->sdev_state != SDEV_CANCEL &&	2516	} else if (sdev->sdev_state != SDEV_CANCEL &&
2517	sdev->sdev_state != SDEV_OFFLINE)	2517	sdev->sdev_state != SDEV_OFFLINE)
2518	return -EINVAL;	2518	return -EINVAL;
2519		2519
2520	spin_lock_irqsave(q->queue_lock, flags);	2520	spin_lock_irqsave(q->queue_lock, flags);
2521	blk_start_queue(q);	2521	blk_start_queue(q);
2522	spin_unlock_irqrestore(q->queue_lock, flags);	2522	spin_unlock_irqrestore(q->queue_lock, flags);
2523		2523
2524	return 0;	2524	return 0;
2525	}	2525	}
2526	EXPORT_SYMBOL_GPL(scsi_internal_device_unblock);	2526	EXPORT_SYMBOL_GPL(scsi_internal_device_unblock);
2527		2527
2528	static void	2528	static void
2529	device_block(struct scsi_device sdev, void data)	2529	device_block(struct scsi_device sdev, void data)
2530	{	2530	{
2531	scsi_internal_device_block(sdev);	2531	scsi_internal_device_block(sdev);
2532	}	2532	}
2533		2533
2534	static int	2534	static int
2535	target_block(struct device dev, void data)	2535	target_block(struct device dev, void data)
2536	{	2536	{
2537	if (scsi_is_target_device(dev))	2537	if (scsi_is_target_device(dev))
2538	starget_for_each_device(to_scsi_target(dev), NULL,	2538	starget_for_each_device(to_scsi_target(dev), NULL,
2539	device_block);	2539	device_block);
2540	return 0;	2540	return 0;
2541	}	2541	}
2542		2542
2543	void	2543	void
2544	scsi_target_block(struct device *dev)	2544	scsi_target_block(struct device *dev)
2545	{	2545	{
2546	if (scsi_is_target_device(dev))	2546	if (scsi_is_target_device(dev))
2547	starget_for_each_device(to_scsi_target(dev), NULL,	2547	starget_for_each_device(to_scsi_target(dev), NULL,
2548	device_block);	2548	device_block);
2549	else	2549	else
2550	device_for_each_child(dev, NULL, target_block);	2550	device_for_each_child(dev, NULL, target_block);
2551	}	2551	}
2552	EXPORT_SYMBOL_GPL(scsi_target_block);	2552	EXPORT_SYMBOL_GPL(scsi_target_block);
2553		2553
2554	static void	2554	static void
2555	device_unblock(struct scsi_device sdev, void data)	2555	device_unblock(struct scsi_device sdev, void data)
2556	{	2556	{
2557	scsi_internal_device_unblock(sdev, (enum scsi_device_state )data);	2557	scsi_internal_device_unblock(sdev, (enum scsi_device_state )data);
2558	}	2558	}
2559		2559
2560	static int	2560	static int
2561	target_unblock(struct device dev, void data)	2561	target_unblock(struct device dev, void data)
2562	{	2562	{
2563	if (scsi_is_target_device(dev))	2563	if (scsi_is_target_device(dev))
2564	starget_for_each_device(to_scsi_target(dev), data,	2564	starget_for_each_device(to_scsi_target(dev), data,
2565	device_unblock);	2565	device_unblock);
2566	return 0;	2566	return 0;
2567	}	2567	}
2568		2568
2569	void	2569	void
2570	scsi_target_unblock(struct device *dev, enum scsi_device_state new_state)	2570	scsi_target_unblock(struct device *dev, enum scsi_device_state new_state)
2571	{	2571	{
2572	if (scsi_is_target_device(dev))	2572	if (scsi_is_target_device(dev))
2573	starget_for_each_device(to_scsi_target(dev), &new_state,	2573	starget_for_each_device(to_scsi_target(dev), &new_state,
2574	device_unblock);	2574	device_unblock);
2575	else	2575	else
2576	device_for_each_child(dev, &new_state, target_unblock);	2576	device_for_each_child(dev, &new_state, target_unblock);
2577	}	2577	}
2578	EXPORT_SYMBOL_GPL(scsi_target_unblock);	2578	EXPORT_SYMBOL_GPL(scsi_target_unblock);
2579		2579
2580	/**	2580	/**
2581	* scsi_kmap_atomic_sg - find and atomically map an sg-elemnt	2581	* scsi_kmap_atomic_sg - find and atomically map an sg-elemnt
2582	* @sgl: scatter-gather list	2582	* @sgl: scatter-gather list
2583	* @sg_count: number of segments in sg	2583	* @sg_count: number of segments in sg
2584	* @offset: offset in bytes into sg, on return offset into the mapped area	2584	* @offset: offset in bytes into sg, on return offset into the mapped area
2585	* @len: bytes to map, on return number of bytes mapped	2585	* @len: bytes to map, on return number of bytes mapped
2586	*	2586	*
2587	* Returns virtual address of the start of the mapped page	2587	* Returns virtual address of the start of the mapped page
2588	*/	2588	*/
2589	void scsi_kmap_atomic_sg(struct scatterlist sgl, int sg_count,	2589	void scsi_kmap_atomic_sg(struct scatterlist sgl, int sg_count,
2590	size_t offset, size_t len)	2590	size_t offset, size_t len)
2591	{	2591	{
2592	int i;	2592	int i;
2593	size_t sg_len = 0, len_complete = 0;	2593	size_t sg_len = 0, len_complete = 0;
2594	struct scatterlist *sg;	2594	struct scatterlist *sg;
2595	struct page *page;	2595	struct page *page;
2596		2596
2597	WARN_ON(!irqs_disabled());	2597	WARN_ON(!irqs_disabled());
2598		2598
2599	for_each_sg(sgl, sg, sg_count, i) {	2599	for_each_sg(sgl, sg, sg_count, i) {
2600	len_complete = sg_len; /* Complete sg-entries */	2600	len_complete = sg_len; /* Complete sg-entries */
2601	sg_len += sg->length;	2601	sg_len += sg->length;
2602	if (sg_len > *offset)	2602	if (sg_len > *offset)
2603	break;	2603	break;
2604	}	2604	}
2605		2605
2606	if (unlikely(i == sg_count)) {	2606	if (unlikely(i == sg_count)) {
2607	printk(KERN_ERR "%s: Bytes in sg: %zu, requested offset %zu, "	2607	printk(KERN_ERR "%s: Bytes in sg: %zu, requested offset %zu, "
2608	"elements %d\n",	2608	"elements %d\n",
2609	__func__, sg_len, *offset, sg_count);	2609	__func__, sg_len, *offset, sg_count);
2610	WARN_ON(1);	2610	WARN_ON(1);
2611	return NULL;	2611	return NULL;
2612	}	2612	}
2613		2613
2614	/* Offset starting from the beginning of first page in this sg-entry */	2614	/* Offset starting from the beginning of first page in this sg-entry */
2615	offset = offset - len_complete + sg->offset;	2615	offset = offset - len_complete + sg->offset;
2616		2616
2617	/* Assumption: contiguous pages can be accessed as "page + i" */	2617	/* Assumption: contiguous pages can be accessed as "page + i" */
2618	page = nth_page(sg_page(sg), (*offset >> PAGE_SHIFT));	2618	page = nth_page(sg_page(sg), (*offset >> PAGE_SHIFT));
2619	*offset &= ~PAGE_MASK;	2619	*offset &= ~PAGE_MASK;
2620		2620
2621	/* Bytes in this sg-entry from offset to the end of the page /	2621	/* Bytes in this sg-entry from offset to the end of the page /
2622	sg_len = PAGE_SIZE - *offset;	2622	sg_len = PAGE_SIZE - *offset;
2623	if (*len > sg_len)	2623	if (*len > sg_len)
2624	*len = sg_len;	2624	*len = sg_len;
2625		2625
2626	return kmap_atomic(page);	2626	return kmap_atomic(page);
2627	}	2627	}
2628	EXPORT_SYMBOL(scsi_kmap_atomic_sg);	2628	EXPORT_SYMBOL(scsi_kmap_atomic_sg);
2629		2629
2630	/**	2630	/**
2631	* scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously mapped with scsi_kmap_atomic_sg	2631	* scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously mapped with scsi_kmap_atomic_sg
2632	* @virt: virtual address to be unmapped	2632	* @virt: virtual address to be unmapped
2633	*/	2633	*/
2634	void scsi_kunmap_atomic_sg(void *virt)	2634	void scsi_kunmap_atomic_sg(void *virt)
2635	{	2635	{
2636	kunmap_atomic(virt);	2636	kunmap_atomic(virt);
2637	}	2637	}
2638	EXPORT_SYMBOL(scsi_kunmap_atomic_sg);	2638	EXPORT_SYMBOL(scsi_kunmap_atomic_sg);
2639		2639
2640	void sdev_disable_disk_events(struct scsi_device *sdev)	2640	void sdev_disable_disk_events(struct scsi_device *sdev)
2641	{	2641	{
2642	atomic_inc(&sdev->disk_events_disable_depth);	2642	atomic_inc(&sdev->disk_events_disable_depth);
2643	}	2643	}
2644	EXPORT_SYMBOL(sdev_disable_disk_events);	2644	EXPORT_SYMBOL(sdev_disable_disk_events);
2645		2645

drivers/scsi/scsi_sysfs.c

Diff comments View file @ cd9070c

 /*
  * scsi_sysfs.c
  *
  * SCSI sysfs interface routines.
  *
  * Created to pull SCSI mid layer sysfs routines into one file.
  */
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/device.h>
 #include <linux/pm_runtime.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_driver.h>
 #include "scsi_priv.h"
 #include "scsi_logging.h"
 static struct device_type scsi_dev_type;
 static const struct {
 	enum scsi_device_state	value;
 	char			*name;
 } sdev_states[] = {
 	{ SDEV_CREATED, "created" },
 	{ SDEV_RUNNING, "running" },
 	{ SDEV_CANCEL, "cancel" },
 	{ SDEV_DEL, "deleted" },
 	{ SDEV_QUIESCE, "quiesce" },
 	{ SDEV_OFFLINE,	"offline" },
 	{ SDEV_TRANSPORT_OFFLINE, "transport-offline" },
 	{ SDEV_BLOCK,	"blocked" },
 	{ SDEV_CREATED_BLOCK, "created-blocked" },
 };
 const char *scsi_device_state_name(enum scsi_device_state state)
 {
 	int i;
 	char *name = NULL;
 	for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
 		if (sdev_states[i].value == state) {
 			name = sdev_states[i].name;
 			break;
 		}
 	}
 	return name;
 }
 static const struct {
 	enum scsi_host_state	value;
 	char			*name;
 } shost_states[] = {
 	{ SHOST_CREATED, "created" },
 	{ SHOST_RUNNING, "running" },
 	{ SHOST_CANCEL, "cancel" },
 	{ SHOST_DEL, "deleted" },
 	{ SHOST_RECOVERY, "recovery" },
 	{ SHOST_CANCEL_RECOVERY, "cancel/recovery" },
 	{ SHOST_DEL_RECOVERY, "deleted/recovery", },
 };
 const char *scsi_host_state_name(enum scsi_host_state state)
 {
 	int i;
 	char *name = NULL;
 	for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
 		if (shost_states[i].value == state) {
 			name = shost_states[i].name;
 			break;
 		}
 	}
 	return name;
 }
 static int check_set(unsigned long long *val, char *src)
 {
 	char *last;
 	if (strncmp(src, "-", 20) == 0) {
 		*val = SCAN_WILD_CARD;
 	} else {
 		/*
 		 * Doesn't check for int overflow
 		 */
 		*val = simple_strtoull(src, &last, 0);
 		if (*last != '\0')
 			return 1;
 	}
 	return 0;
 }
 static int scsi_scan(struct Scsi_Host *shost, const char *str)
 {
 	char s1[15], s2[15], s3[17], junk;
 	unsigned long long channel, id, lun;
 	int res;
 	res = sscanf(str, "%10s %10s %16s %c", s1, s2, s3, &junk);
 	if (res != 3)
 		return -EINVAL;
 	if (check_set(&channel, s1))
 		return -EINVAL;
 	if (check_set(&id, s2))
 		return -EINVAL;
 	if (check_set(&lun, s3))
 		return -EINVAL;
 	if (shost->transportt->user_scan)
 		res = shost->transportt->user_scan(shost, channel, id, lun);
 	else
 		res = scsi_scan_host_selected(shost, channel, id, lun, 1);
 	return res;
 }
 /*
  * shost_show_function: macro to create an attr function that can be used to
  * show a non-bit field.
  */
 #define shost_show_function(name, field, format_string)			\
 static ssize_t								\
 show_##name (struct device *dev, struct device_attribute *attr, 	\
 	     char *buf)							\
 {									\
 	struct Scsi_Host *shost = class_to_shost(dev);			\
 	return snprintf (buf, 20, format_string, shost->field);		\
 }
 /*
  * shost_rd_attr: macro to create a function and attribute variable for a
  * read only field.
  */
 #define shost_rd_attr2(name, field, format_string)			\
 	shost_show_function(name, field, format_string)			\
 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
 #define shost_rd_attr(field, format_string) \
 shost_rd_attr2(field, field, format_string)
 /*
  * Create the actual show/store functions and data structures.
  */
 static ssize_t
 store_scan(struct device *dev, struct device_attribute *attr,
 	   const char *buf, size_t count)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	int res;
 	res = scsi_scan(shost, buf);
 	if (res == 0)
 		res = count;
 	return res;
 };
 static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
 static ssize_t
 store_shost_state(struct device *dev, struct device_attribute *attr,
 		  const char *buf, size_t count)
 {
 	int i;
 	struct Scsi_Host *shost = class_to_shost(dev);
 	enum scsi_host_state state = 0;
 	for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
 		const int len = strlen(shost_states[i].name);
 		if (strncmp(shost_states[i].name, buf, len) == 0 &&
 		   buf[len] == '\n') {
 			state = shost_states[i].value;
 			break;
 		}
 	}
 	if (!state)
 		return -EINVAL;
 	if (scsi_host_set_state(shost, state))
 		return -EINVAL;
 	return count;
 }
 static ssize_t
 show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	const char *name = scsi_host_state_name(shost->shost_state);
 	if (!name)
 		return -EINVAL;
 	return snprintf(buf, 20, "%s\n", name);
 }
 /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
 struct device_attribute dev_attr_hstate =
 	__ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
 static ssize_t
 show_shost_mode(unsigned int mode, char *buf)
 {
 	ssize_t len = 0;
 	if (mode & MODE_INITIATOR)
 		len = sprintf(buf, "%s", "Initiator");
 	if (mode & MODE_TARGET)
 		len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target");
 	len += sprintf(buf + len, "\n");
 	return len;
 }
 static ssize_t
 show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
 			  char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	unsigned int supported_mode = shost->hostt->supported_mode;
 	if (supported_mode == MODE_UNKNOWN)
 		/* by default this should be initiator */
 		supported_mode = MODE_INITIATOR;
 	return show_shost_mode(supported_mode, buf);
 }
 static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
 static ssize_t
 show_shost_active_mode(struct device *dev,
 		       struct device_attribute *attr, char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	if (shost->active_mode == MODE_UNKNOWN)
 		return snprintf(buf, 20, "unknown\n");
 	else
 		return show_shost_mode(shost->active_mode, buf);
 }
 static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
 static int check_reset_type(const char *str)
 {
 	if (sysfs_streq(str, "adapter"))
 		return SCSI_ADAPTER_RESET;
 	else if (sysfs_streq(str, "firmware"))
 		return SCSI_FIRMWARE_RESET;
 	else
 		return 0;
 }
 static ssize_t
 store_host_reset(struct device *dev, struct device_attribute *attr,
 		const char *buf, size_t count)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	struct scsi_host_template *sht = shost->hostt;
 	int ret = -EINVAL;
 	int type;
 	type = check_reset_type(buf);
 	if (!type)
 		goto exit_store_host_reset;
 	if (sht->host_reset)
 		ret = sht->host_reset(shost, type);
 exit_store_host_reset:
 	if (ret == 0)
 		ret = count;
 	return ret;
 }
 static DEVICE_ATTR(host_reset, S_IWUSR, NULL, store_host_reset);
 static ssize_t
 show_shost_eh_deadline(struct device *dev,
 		      struct device_attribute *attr, char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	if (shost->eh_deadline == -1)
 		return snprintf(buf, strlen("off") + 2, "off\n");
 	return sprintf(buf, "%u\n", shost->eh_deadline / HZ);
 }
 static ssize_t
 store_shost_eh_deadline(struct device *dev, struct device_attribute *attr,
 		const char *buf, size_t count)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	int ret = -EINVAL;
 	unsigned long deadline, flags;
 	if (shost->transportt &&
 	    (shost->transportt->eh_strategy_handler ||
 	     !shost->hostt->eh_host_reset_handler))
 		return ret;
 	if (!strncmp(buf, "off", strlen("off")))
 		deadline = -1;
 	else {
 		ret = kstrtoul(buf, 10, &deadline);
 		if (ret)
 			return ret;
 		if (deadline * HZ > UINT_MAX)
 			return -EINVAL;
 	}
 	spin_lock_irqsave(shost->host_lock, flags);
 	if (scsi_host_in_recovery(shost))
 		ret = -EBUSY;
 	else {
 		if (deadline == -1)
 			shost->eh_deadline = -1;
 		else
 			shost->eh_deadline = deadline * HZ;
 		ret = count;
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	return ret;
 }
 static DEVICE_ATTR(eh_deadline, S_IRUGO | S_IWUSR, show_shost_eh_deadline, store_shost_eh_deadline);
 shost_rd_attr(unique_id, "%u\n");
 shost_rd_attr(cmd_per_lun, "%hd\n");
 shost_rd_attr(can_queue, "%hd\n");
 shost_rd_attr(sg_tablesize, "%hu\n");
 shost_rd_attr(sg_prot_tablesize, "%hu\n");
 shost_rd_attr(unchecked_isa_dma, "%d\n");
 shost_rd_attr(prot_capabilities, "%u\n");
 shost_rd_attr(prot_guard_type, "%hd\n");
 shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
 static ssize_t
 show_host_busy(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	return snprintf(buf, 20, "%d\n", atomic_read(&shost->host_busy));
 }
 static DEVICE_ATTR(host_busy, S_IRUGO, show_host_busy, NULL);
 static struct attribute *scsi_sysfs_shost_attrs[] = {
 	&dev_attr_unique_id.attr,
 	&dev_attr_host_busy.attr,
 	&dev_attr_cmd_per_lun.attr,
 	&dev_attr_can_queue.attr,
 	&dev_attr_sg_tablesize.attr,
 	&dev_attr_sg_prot_tablesize.attr,
 	&dev_attr_unchecked_isa_dma.attr,
 	&dev_attr_proc_name.attr,
 	&dev_attr_scan.attr,
 	&dev_attr_hstate.attr,
 	&dev_attr_supported_mode.attr,
 	&dev_attr_active_mode.attr,
 	&dev_attr_prot_capabilities.attr,
 	&dev_attr_prot_guard_type.attr,
 	&dev_attr_host_reset.attr,
 	&dev_attr_eh_deadline.attr,
 	NULL
 };
 struct attribute_group scsi_shost_attr_group = {
 	.attrs =	scsi_sysfs_shost_attrs,
 };
 const struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
 	&scsi_shost_attr_group,
 	NULL
 };
 static void scsi_device_cls_release(struct device *class_dev)
 {
 	struct scsi_device *sdev;
 	sdev = class_to_sdev(class_dev);
 	put_device(&sdev->sdev_gendev);
 }
 static void scsi_device_dev_release_usercontext(struct work_struct *work)
 {
 	struct scsi_device *sdev;
 	struct device *parent;
 	struct list_head *this, *tmp;
 	unsigned long flags;
 	sdev = container_of(work, struct scsi_device, ew.work);
 	parent = sdev->sdev_gendev.parent;
 	spin_lock_irqsave(sdev->host->host_lock, flags);
 	list_del(&sdev->siblings);
 	list_del(&sdev->same_target_siblings);
 	list_del(&sdev->starved_entry);
 	spin_unlock_irqrestore(sdev->host->host_lock, flags);
 	cancel_work_sync(&sdev->event_work);
 	list_for_each_safe(this, tmp, &sdev->event_list) {
 		struct scsi_event *evt;
 		evt = list_entry(this, struct scsi_event, node);
 		list_del(&evt->node);
 		kfree(evt);
 	}
 	blk_put_queue(sdev->request_queue);
 	/* NULL queue means the device can't be used */
 	sdev->request_queue = NULL;
 	kfree(sdev->vpd_pg83);
 	kfree(sdev->vpd_pg80);
 	kfree(sdev->inquiry);
 	kfree(sdev);
 	if (parent)
 		put_device(parent);
 }
 static void scsi_device_dev_release(struct device *dev)
 {
 	struct scsi_device *sdp = to_scsi_device(dev);
 	execute_in_process_context(scsi_device_dev_release_usercontext,
 				   &sdp->ew);
 }
 static struct class sdev_class = {
 	.name		= "scsi_device",
 	.dev_release	= scsi_device_cls_release,
 };
 /* all probing is done in the individual ->probe routines */
 static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
 {
 	struct scsi_device *sdp;
 	if (dev->type != &scsi_dev_type)
 		return 0;
 	sdp = to_scsi_device(dev);
 	if (sdp->no_uld_attach)
 		return 0;
 	return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
 }
 static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
 	struct scsi_device *sdev;
 	if (dev->type != &scsi_dev_type)
 		return 0;
 	sdev = to_scsi_device(dev);
 	add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
 	return 0;
 }
 struct bus_type scsi_bus_type = {
         .name		= "scsi",
         .match		= scsi_bus_match,
 	.uevent		= scsi_bus_uevent,
 #ifdef CONFIG_PM
 	.pm		= &scsi_bus_pm_ops,
 #endif
 };
 EXPORT_SYMBOL_GPL(scsi_bus_type);
 int scsi_sysfs_register(void)
 {
 	int error;
 	error = bus_register(&scsi_bus_type);
 	if (!error) {
 		error = class_register(&sdev_class);
 		if (error)
 			bus_unregister(&scsi_bus_type);
 	}
 	return error;
 }
 void scsi_sysfs_unregister(void)
 {
 	class_unregister(&sdev_class);
 	bus_unregister(&scsi_bus_type);
 }
 /*
  * sdev_show_function: macro to create an attr function that can be used to
  * show a non-bit field.
  */
 #define sdev_show_function(field, format_string)				\
 static ssize_t								\
 sdev_show_##field (struct device *dev, struct device_attribute *attr,	\
 		   char *buf)						\
 {									\
 	struct scsi_device *sdev;					\
 	sdev = to_scsi_device(dev);					\
 	return snprintf (buf, 20, format_string, sdev->field);		\
 }									\
 /*
  * sdev_rd_attr: macro to create a function and attribute variable for a
  * read only field.
  */
 #define sdev_rd_attr(field, format_string)				\
 	sdev_show_function(field, format_string)			\
 static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
 /*
  * sdev_rw_attr: create a function and attribute variable for a
  * read/write field.
  */
 #define sdev_rw_attr(field, format_string)				\
 	sdev_show_function(field, format_string)				\
 									\
 static ssize_t								\
 sdev_store_##field (struct device *dev, struct device_attribute *attr,	\
 		    const char *buf, size_t count)			\
 {									\
 	struct scsi_device *sdev;					\
 	sdev = to_scsi_device(dev);					\
 	sscanf (buf, format_string, &sdev->field);			\
 	return count;							\
 }									\
 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
 /* Currently we don't export bit fields, but we might in future,
  * so leave this code in */
 #if 0
 /*
  * sdev_rd_attr: create a function and attribute variable for a
  * read/write bit field.
  */
 #define sdev_rw_attr_bit(field)						\
 	sdev_show_function(field, "%d\n")					\
 									\
 static ssize_t								\
 sdev_store_##field (struct device *dev, struct device_attribute *attr,	\
 		    const char *buf, size_t count)			\
 {									\
 	int ret;							\
 	struct scsi_device *sdev;					\
 	ret = scsi_sdev_check_buf_bit(buf);				\
 	if (ret >= 0)	{						\
 		sdev = to_scsi_device(dev);				\
 		sdev->field = ret;					\
 		ret = count;						\
 	}								\
 	return ret;							\
 }									\
 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
 /*
  * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
  * else return -EINVAL.
  */
 static int scsi_sdev_check_buf_bit(const char *buf)
 {
 	if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {
 		if (buf[0] == '1')
 			return 1;
 		else if (buf[0] == '0')
 			return 0;
 		else
 			return -EINVAL;
 	} else
 		return -EINVAL;
 }
 #endif
 /*
  * Create the actual show/store functions and data structures.
  */
-sdev_rd_attr (device_blocked, "%d\n");
 sdev_rd_attr (type, "%d\n");
 sdev_rd_attr (scsi_level, "%d\n");
 sdev_rd_attr (vendor, "%.8s\n");
 sdev_rd_attr (model, "%.16s\n");
 sdev_rd_attr (rev, "%.4s\n");
 static ssize_t
 sdev_show_device_busy(struct device *dev, struct device_attribute *attr,
 		char *buf)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_busy));
 }
 static DEVICE_ATTR(device_busy, S_IRUGO, sdev_show_device_busy, NULL);
+static ssize_t
+sdev_show_device_blocked(struct device *dev, struct device_attribute *attr,
+		char *buf)
+{
+	struct scsi_device *sdev = to_scsi_device(dev);
+	return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_blocked));
+}
+static DEVICE_ATTR(device_blocked, S_IRUGO, sdev_show_device_blocked, NULL);
 /*
  * TODO: can we make these symlinks to the block layer ones?
  */
 static ssize_t
 sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct scsi_device *sdev;
 	sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
 }
 static ssize_t
 sdev_store_timeout (struct device *dev, struct device_attribute *attr,
 		    const char *buf, size_t count)
 {
 	struct scsi_device *sdev;
 	int timeout;
 	sdev = to_scsi_device(dev);
 	sscanf (buf, "%d\n", &timeout);
 	blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
 	return count;
 }
 static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
 static ssize_t
 sdev_show_eh_timeout(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct scsi_device *sdev;
 	sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%u\n", sdev->eh_timeout / HZ);
 }
 static ssize_t
 sdev_store_eh_timeout(struct device *dev, struct device_attribute *attr,
 		    const char *buf, size_t count)
 {
 	struct scsi_device *sdev;
 	unsigned int eh_timeout;
 	int err;
 	if (!capable(CAP_SYS_ADMIN))
 		return -EACCES;
 	sdev = to_scsi_device(dev);
 	err = kstrtouint(buf, 10, &eh_timeout);
 	if (err)
 		return err;
 	sdev->eh_timeout = eh_timeout * HZ;
 	return count;
 }
 static DEVICE_ATTR(eh_timeout, S_IRUGO | S_IWUSR, sdev_show_eh_timeout, sdev_store_eh_timeout);
 static ssize_t
 store_rescan_field (struct device *dev, struct device_attribute *attr,
 		    const char *buf, size_t count)
 {
 	scsi_rescan_device(dev);
 	return count;
 }
 static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);
 static ssize_t
 sdev_store_delete(struct device *dev, struct device_attribute *attr,
 		  const char *buf, size_t count)
 {
 	if (device_remove_file_self(dev, attr))
 		scsi_remove_device(to_scsi_device(dev));
 	return count;
 };
 static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
 static ssize_t
 store_state_field(struct device *dev, struct device_attribute *attr,
 		  const char *buf, size_t count)
 {
 	int i;
 	struct scsi_device *sdev = to_scsi_device(dev);
 	enum scsi_device_state state = 0;
 	for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
 		const int len = strlen(sdev_states[i].name);
 		if (strncmp(sdev_states[i].name, buf, len) == 0 &&
 		   buf[len] == '\n') {
 			state = sdev_states[i].value;
 			break;
 		}
 	}
 	if (!state)
 		return -EINVAL;
 	if (scsi_device_set_state(sdev, state))
 		return -EINVAL;
 	return count;
 }
 static ssize_t
 show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	const char *name = scsi_device_state_name(sdev->sdev_state);
 	if (!name)
 		return -EINVAL;
 	return snprintf(buf, 20, "%s\n", name);
 }
 static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
 static ssize_t
 show_queue_type_field(struct device *dev, struct device_attribute *attr,
 		      char *buf)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	const char *name = "none";
 	if (sdev->ordered_tags)
 		name = "ordered";
 	else if (sdev->simple_tags)
 		name = "simple";
 	return snprintf(buf, 20, "%s\n", name);
 }
 static ssize_t
 store_queue_type_field(struct device *dev, struct device_attribute *attr,
 		       const char *buf, size_t count)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	struct scsi_host_template *sht = sdev->host->hostt;
 	int tag_type = 0, retval;
 	int prev_tag_type = scsi_get_tag_type(sdev);
 	if (!sdev->tagged_supported || !sht->change_queue_type)
 		return -EINVAL;
 	if (strncmp(buf, "ordered", 7) == 0)
 		tag_type = MSG_ORDERED_TAG;
 	else if (strncmp(buf, "simple", 6) == 0)
 		tag_type = MSG_SIMPLE_TAG;
 	else if (strncmp(buf, "none", 4) != 0)
 		return -EINVAL;
 	if (tag_type == prev_tag_type)
 		return count;
 	retval = sht->change_queue_type(sdev, tag_type);
 	if (retval < 0)
 		return retval;
 	return count;
 }
 static DEVICE_ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
 		   store_queue_type_field);
 #define sdev_vpd_pg_attr(_page)						\
 static ssize_t							\
 show_vpd_##_page(struct file *filp, struct kobject *kobj,	\
 		 struct bin_attribute *bin_attr,			\
 		 char *buf, loff_t off, size_t count)			\
 {									\
 	struct device *dev = container_of(kobj, struct device, kobj);	\
 	struct scsi_device *sdev = to_scsi_device(dev);			\
 	if (!sdev->vpd_##_page)						\
 		return -EINVAL;						\
 	return memory_read_from_buffer(buf, count, &off,		\
 				       sdev->vpd_##_page,		\
 				       sdev->vpd_##_page##_len);	\
 }									\
 static struct bin_attribute dev_attr_vpd_##_page = {		\
 	.attr =	{.name = __stringify(vpd_##_page), .mode = S_IRUGO },	\
 	.size = 0,							\
 	.read = show_vpd_##_page,					\
 };
 sdev_vpd_pg_attr(pg83);
 sdev_vpd_pg_attr(pg80);
 static ssize_t
 show_iostat_counterbits(struct device *dev, struct device_attribute *attr,
 			char *buf)
 {
 	return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
 }
 static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);
 #define show_sdev_iostat(field)						\
 static ssize_t								\
 show_iostat_##field(struct device *dev, struct device_attribute *attr,	\
 		    char *buf)						\
 {									\
 	struct scsi_device *sdev = to_scsi_device(dev);			\
 	unsigned long long count = atomic_read(&sdev->field);		\
 	return snprintf(buf, 20, "0x%llx\n", count);			\
 }									\
 static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
 show_sdev_iostat(iorequest_cnt);
 show_sdev_iostat(iodone_cnt);
 show_sdev_iostat(ioerr_cnt);
 static ssize_t
 sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct scsi_device *sdev;
 	sdev = to_scsi_device(dev);
 	return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);
 }
 static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
 #define DECLARE_EVT_SHOW(name, Cap_name)				\
 static ssize_t								\
 sdev_show_evt_##name(struct device *dev, struct device_attribute *attr,	\
 		     char *buf)						\
 {									\
 	struct scsi_device *sdev = to_scsi_device(dev);			\
 	int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
 	return snprintf(buf, 20, "%d\n", val);				\
 }
 #define DECLARE_EVT_STORE(name, Cap_name)				\
 static ssize_t								\
 sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
 		      const char *buf, size_t count)			\
 {									\
 	struct scsi_device *sdev = to_scsi_device(dev);			\
 	int val = simple_strtoul(buf, NULL, 0);				\
 	if (val == 0)							\
 		clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events);	\
 	else if (val == 1)						\
 		set_bit(SDEV_EVT_##Cap_name, sdev->supported_events);	\
 	else								\
 		return -EINVAL;						\
 	return count;							\
 }
 #define DECLARE_EVT(name, Cap_name)					\
 	DECLARE_EVT_SHOW(name, Cap_name)				\
 	DECLARE_EVT_STORE(name, Cap_name)				\
 	static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name,	\
 			   sdev_store_evt_##name);
 #define REF_EVT(name) &dev_attr_evt_##name.attr
 DECLARE_EVT(media_change, MEDIA_CHANGE)
 DECLARE_EVT(inquiry_change_reported, INQUIRY_CHANGE_REPORTED)
 DECLARE_EVT(capacity_change_reported, CAPACITY_CHANGE_REPORTED)
 DECLARE_EVT(soft_threshold_reached, SOFT_THRESHOLD_REACHED_REPORTED)
 DECLARE_EVT(mode_parameter_change_reported, MODE_PARAMETER_CHANGE_REPORTED)
 DECLARE_EVT(lun_change_reported, LUN_CHANGE_REPORTED)
 static ssize_t
 sdev_store_queue_depth(struct device *dev, struct device_attribute *attr,
 		       const char *buf, size_t count)
 {
 	int depth, retval;
 	struct scsi_device *sdev = to_scsi_device(dev);
 	struct scsi_host_template *sht = sdev->host->hostt;
 	if (!sht->change_queue_depth)
 		return -EINVAL;
 	depth = simple_strtoul(buf, NULL, 0);
 	if (depth < 1)
 		return -EINVAL;
 	retval = sht->change_queue_depth(sdev, depth,
 					 SCSI_QDEPTH_DEFAULT);
 	if (retval < 0)
 		return retval;
 	sdev->max_queue_depth = sdev->queue_depth;
 	return count;
 }
 sdev_show_function(queue_depth, "%d\n");
 static DEVICE_ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
 		   sdev_store_queue_depth);
 static ssize_t
 sdev_show_queue_ramp_up_period(struct device *dev,
 			       struct device_attribute *attr,
 			       char *buf)
 {
 	struct scsi_device *sdev;
 	sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%u\n",
 			jiffies_to_msecs(sdev->queue_ramp_up_period));
 }
 static ssize_t
 sdev_store_queue_ramp_up_period(struct device *dev,
 				struct device_attribute *attr,
 				const char *buf, size_t count)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	unsigned long period;
 	if (strict_strtoul(buf, 10, &period))
 		return -EINVAL;
 	sdev->queue_ramp_up_period = msecs_to_jiffies(period);
 	return period;
 }
 static DEVICE_ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
 		   sdev_show_queue_ramp_up_period,
 		   sdev_store_queue_ramp_up_period);
 static umode_t scsi_sdev_attr_is_visible(struct kobject *kobj,
 					 struct attribute *attr, int i)
 {
 	struct device *dev = container_of(kobj, struct device, kobj);
 	struct scsi_device *sdev = to_scsi_device(dev);
 	if (attr == &dev_attr_queue_depth.attr &&
 	    !sdev->host->hostt->change_queue_depth)
 		return S_IRUGO;
 	if (attr == &dev_attr_queue_ramp_up_period.attr &&
 	    !sdev->host->hostt->change_queue_depth)
 		return 0;
 	if (attr == &dev_attr_queue_type.attr &&
 	    !sdev->host->hostt->change_queue_type)
 		return S_IRUGO;
 	return attr->mode;
 }
 /* Default template for device attributes.  May NOT be modified */
 static struct attribute *scsi_sdev_attrs[] = {
 	&dev_attr_device_blocked.attr,
 	&dev_attr_type.attr,
 	&dev_attr_scsi_level.attr,
 	&dev_attr_device_busy.attr,
 	&dev_attr_vendor.attr,
 	&dev_attr_model.attr,
 	&dev_attr_rev.attr,
 	&dev_attr_rescan.attr,
 	&dev_attr_delete.attr,
 	&dev_attr_state.attr,
 	&dev_attr_timeout.attr,
 	&dev_attr_eh_timeout.attr,
 	&dev_attr_iocounterbits.attr,
 	&dev_attr_iorequest_cnt.attr,
 	&dev_attr_iodone_cnt.attr,
 	&dev_attr_ioerr_cnt.attr,
 	&dev_attr_modalias.attr,
 	&dev_attr_queue_depth.attr,
 	&dev_attr_queue_type.attr,
 	&dev_attr_queue_ramp_up_period.attr,
 	REF_EVT(media_change),
 	REF_EVT(inquiry_change_reported),
 	REF_EVT(capacity_change_reported),
 	REF_EVT(soft_threshold_reached),
 	REF_EVT(mode_parameter_change_reported),
 	REF_EVT(lun_change_reported),
 	NULL
 };
 static struct bin_attribute *scsi_sdev_bin_attrs[] = {
 	&dev_attr_vpd_pg83,
 	&dev_attr_vpd_pg80,
 	NULL
 };
 static struct attribute_group scsi_sdev_attr_group = {
 	.attrs =	scsi_sdev_attrs,
 	.bin_attrs =	scsi_sdev_bin_attrs,
 	.is_visible =	scsi_sdev_attr_is_visible,
 };
 static const struct attribute_group *scsi_sdev_attr_groups[] = {
 	&scsi_sdev_attr_group,
 	NULL
 };
 static int scsi_target_add(struct scsi_target *starget)
 {
 	int error;
 	if (starget->state != STARGET_CREATED)
 		return 0;
 	error = device_add(&starget->dev);
 	if (error) {
 		dev_err(&starget->dev, "target device_add failed, error %d\n", error);
 		return error;
 	}
 	transport_add_device(&starget->dev);
 	starget->state = STARGET_RUNNING;
 	pm_runtime_set_active(&starget->dev);
 	pm_runtime_enable(&starget->dev);
 	device_enable_async_suspend(&starget->dev);
 	return 0;
 }
 /**
  * scsi_sysfs_add_sdev - add scsi device to sysfs
  * @sdev:	scsi_device to add
  *
  * Return value:
  * 	0 on Success / non-zero on Failure
  **/
 int scsi_sysfs_add_sdev(struct scsi_device *sdev)
 {
 	int error, i;
 	struct request_queue *rq = sdev->request_queue;
 	struct scsi_target *starget = sdev->sdev_target;
 	error = scsi_device_set_state(sdev, SDEV_RUNNING);
 	if (error)
 		return error;
 	error = scsi_target_add(starget);
 	if (error)
 		return error;
 	transport_configure_device(&starget->dev);
 	device_enable_async_suspend(&sdev->sdev_gendev);
 	scsi_autopm_get_target(starget);
 	pm_runtime_set_active(&sdev->sdev_gendev);
 	pm_runtime_forbid(&sdev->sdev_gendev);
 	pm_runtime_enable(&sdev->sdev_gendev);
 	scsi_autopm_put_target(starget);
 	/* The following call will keep sdev active indefinitely, until
 	 * its driver does a corresponding scsi_autopm_pm_device().  Only
 	 * drivers supporting autosuspend will do this.
 	 */
 	scsi_autopm_get_device(sdev);
 	error = device_add(&sdev->sdev_gendev);
 	if (error) {
 		sdev_printk(KERN_INFO, sdev,
 				"failed to add device: %d\n", error);
 		return error;
 	}
 	device_enable_async_suspend(&sdev->sdev_dev);
 	error = device_add(&sdev->sdev_dev);
 	if (error) {
 		sdev_printk(KERN_INFO, sdev,
 				"failed to add class device: %d\n", error);
 		device_del(&sdev->sdev_gendev);
 		return error;
 	}
 	transport_add_device(&sdev->sdev_gendev);
 	sdev->is_visible = 1;
 	error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
 	if (error)
 		/* we're treating error on bsg register as non-fatal,
 		 * so pretend nothing went wrong */
 		sdev_printk(KERN_INFO, sdev,
 			    "Failed to register bsg queue, errno=%d\n", error);
 	/* add additional host specific attributes */
 	if (sdev->host->hostt->sdev_attrs) {
 		for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) {
 			error = device_create_file(&sdev->sdev_gendev,
 					sdev->host->hostt->sdev_attrs[i]);
 			if (error)
 				return error;
 		}
 	}
 	return error;
 }
 void __scsi_remove_device(struct scsi_device *sdev)
 {
 	struct device *dev = &sdev->sdev_gendev;
 	if (sdev->is_visible) {
 		if (scsi_device_set_state(sdev, SDEV_CANCEL) != 0)
 			return;
 		bsg_unregister_queue(sdev->request_queue);
 		device_unregister(&sdev->sdev_dev);
 		transport_remove_device(dev);
 		device_del(dev);
 	} else
 		put_device(&sdev->sdev_dev);
 	/*
 	 * Stop accepting new requests and wait until all queuecommand() and
 	 * scsi_run_queue() invocations have finished before tearing down the
 	 * device.
 	 */
 	scsi_device_set_state(sdev, SDEV_DEL);
 	blk_cleanup_queue(sdev->request_queue);
 	cancel_work_sync(&sdev->requeue_work);
 	if (sdev->host->hostt->slave_destroy)
 		sdev->host->hostt->slave_destroy(sdev);
 	transport_destroy_device(dev);
 	/*
 	 * Paired with the kref_get() in scsi_sysfs_initialize().  We have
 	 * remoed sysfs visibility from the device, so make the target
 	 * invisible if this was the last device underneath it.
 	 */
 	scsi_target_reap(scsi_target(sdev));
 	put_device(dev);
 }
 /**
  * scsi_remove_device - unregister a device from the scsi bus
  * @sdev:	scsi_device to unregister
  **/
 void scsi_remove_device(struct scsi_device *sdev)
 {
 	struct Scsi_Host *shost = sdev->host;
 	mutex_lock(&shost->scan_mutex);
 	__scsi_remove_device(sdev);
 	mutex_unlock(&shost->scan_mutex);
 }
 EXPORT_SYMBOL(scsi_remove_device);
 static void __scsi_remove_target(struct scsi_target *starget)
 {
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	unsigned long flags;
 	struct scsi_device *sdev;
 	spin_lock_irqsave(shost->host_lock, flags);
  restart:
 	list_for_each_entry(sdev, &shost->__devices, siblings) {
 		if (sdev->channel != starget->channel ||
 		    sdev->id != starget->id ||
 		    scsi_device_get(sdev))
 			continue;
 		spin_unlock_irqrestore(shost->host_lock, flags);
 		scsi_remove_device(sdev);
 		scsi_device_put(sdev);
 		spin_lock_irqsave(shost->host_lock, flags);
 		goto restart;
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 }
 /**
  * scsi_remove_target - try to remove a target and all its devices
  * @dev: generic starget or parent of generic stargets to be removed
  *
  * Note: This is slightly racy.  It is possible that if the user
  * requests the addition of another device then the target won't be
  * removed.
  */
 void scsi_remove_target(struct device *dev)
 {
 	struct Scsi_Host *shost = dev_to_shost(dev->parent);
 	struct scsi_target *starget, *last = NULL;
 	unsigned long flags;
 	/* remove targets being careful to lookup next entry before
 	 * deleting the last
 	 */
 	spin_lock_irqsave(shost->host_lock, flags);
 	list_for_each_entry(starget, &shost->__targets, siblings) {
 		if (starget->state == STARGET_DEL)
 			continue;
 		if (starget->dev.parent == dev || &starget->dev == dev) {
 			/* assuming new targets arrive at the end */
 			kref_get(&starget->reap_ref);
 			spin_unlock_irqrestore(shost->host_lock, flags);
 			if (last)
 				scsi_target_reap(last);
 			last = starget;
 			__scsi_remove_target(starget);
 			spin_lock_irqsave(shost->host_lock, flags);
 		}
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	if (last)
 		scsi_target_reap(last);
 }
 EXPORT_SYMBOL(scsi_remove_target);
 int scsi_register_driver(struct device_driver *drv)
 {
 	drv->bus = &scsi_bus_type;
 	return driver_register(drv);
 }
 EXPORT_SYMBOL(scsi_register_driver);
 int scsi_register_interface(struct class_interface *intf)
 {
 	intf->class = &sdev_class;
 	return class_interface_register(intf);
 }
 EXPORT_SYMBOL(scsi_register_interface);
 /**
  * scsi_sysfs_add_host - add scsi host to subsystem
  * @shost:     scsi host struct to add to subsystem
  **/
 int scsi_sysfs_add_host(struct Scsi_Host *shost)
 {
 	int error, i;
 	/* add host specific attributes */
 	if (shost->hostt->shost_attrs) {
 		for (i = 0; shost->hostt->shost_attrs[i]; i++) {
 			error = device_create_file(&shost->shost_dev,
 					shost->hostt->shost_attrs[i]);
 			if (error)
 				return error;
 		}
 	}
 	transport_register_device(&shost->shost_gendev);
 	transport_configure_device(&shost->shost_gendev);
 	return 0;
 }
 static struct device_type scsi_dev_type = {
 	.name =		"scsi_device",
 	.release =	scsi_device_dev_release,
 	.groups =	scsi_sdev_attr_groups,
 };
 void scsi_sysfs_device_initialize(struct scsi_device *sdev)
 {
 	unsigned long flags;
 	struct Scsi_Host *shost = sdev->host;
 	struct scsi_target  *starget = sdev->sdev_target;
 	device_initialize(&sdev->sdev_gendev);
 	sdev->sdev_gendev.bus = &scsi_bus_type;
 	sdev->sdev_gendev.type = &scsi_dev_type;
 	dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%llu",
 		     sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
 	device_initialize(&sdev->sdev_dev);
 	sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev);
 	sdev->sdev_dev.class = &sdev_class;
 	dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%llu",
 		     sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
 	sdev->scsi_level = starget->scsi_level;
 	transport_setup_device(&sdev->sdev_gendev);
 	spin_lock_irqsave(shost->host_lock, flags);
 	list_add_tail(&sdev->same_target_siblings, &starget->devices);
 	list_add_tail(&sdev->siblings, &shost->__devices);
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	/*
 	 * device can now only be removed via __scsi_remove_device() so hold
 	 * the target.  Target will be held in CREATED state until something
 	 * beneath it becomes visible (in which case it moves to RUNNING)
 	 */
 	kref_get(&starget->reap_ref);
 }
 int scsi_is_sdev_device(const struct device *dev)
 {
 	return dev->type == &scsi_dev_type;
 }
 EXPORT_SYMBOL(scsi_is_sdev_device);
 /* A blank transport template that is used in drivers that don't
  * yet implement Transport Attributes */
 struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };

include/scsi/scsi_device.h

Diff comments View file @ cd9070c

 #ifndef _SCSI_SCSI_DEVICE_H
 #define _SCSI_SCSI_DEVICE_H
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
 #include <linux/blkdev.h>
 #include <scsi/scsi.h>
 #include <linux/atomic.h>
 struct device;
 struct request_queue;
 struct scsi_cmnd;
 struct scsi_lun;
 struct scsi_sense_hdr;
 struct scsi_mode_data {
 	__u32	length;
 	__u16	block_descriptor_length;
 	__u8	medium_type;
 	__u8	device_specific;
 	__u8	header_length;
 	__u8	longlba:1;
 };
 /*
  * sdev state: If you alter this, you also need to alter scsi_sysfs.c
  * (for the ascii descriptions) and the state model enforcer:
  * scsi_lib:scsi_device_set_state().
  */
 enum scsi_device_state {
 	SDEV_CREATED = 1,	/* device created but not added to sysfs
 				 * Only internal commands allowed (for inq) */
 	SDEV_RUNNING,		/* device properly configured
 				 * All commands allowed */
 	SDEV_CANCEL,		/* beginning to delete device
 				 * Only error handler commands allowed */
 	SDEV_DEL,		/* device deleted
 				 * no commands allowed */
 	SDEV_QUIESCE,		/* Device quiescent.  No block commands
 				 * will be accepted, only specials (which
 				 * originate in the mid-layer) */
 	SDEV_OFFLINE,		/* Device offlined (by error handling or
 				 * user request */
 	SDEV_TRANSPORT_OFFLINE,	/* Offlined by transport class error handler */
 	SDEV_BLOCK,		/* Device blocked by scsi lld.  No
 				 * scsi commands from user or midlayer
 				 * should be issued to the scsi
 				 * lld. */
 	SDEV_CREATED_BLOCK,	/* same as above but for created devices */
 };
 enum scsi_device_event {
 	SDEV_EVT_MEDIA_CHANGE	= 1,	/* media has changed */
 	SDEV_EVT_INQUIRY_CHANGE_REPORTED,		/* 3F 03  UA reported */
 	SDEV_EVT_CAPACITY_CHANGE_REPORTED,		/* 2A 09  UA reported */
 	SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED,	/* 38 07  UA reported */
 	SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED,	/* 2A 01  UA reported */
 	SDEV_EVT_LUN_CHANGE_REPORTED,			/* 3F 0E  UA reported */
 	SDEV_EVT_FIRST		= SDEV_EVT_MEDIA_CHANGE,
 	SDEV_EVT_LAST		= SDEV_EVT_LUN_CHANGE_REPORTED,
 	SDEV_EVT_MAXBITS	= SDEV_EVT_LAST + 1
 };
 struct scsi_event {
 	enum scsi_device_event	evt_type;
 	struct list_head	node;
 	/* put union of data structures, for non-simple event types,
 	 * here
 	 */
 };
 struct scsi_device {
 	struct Scsi_Host *host;
 	struct request_queue *request_queue;
 	/* the next two are protected by the host->host_lock */
 	struct list_head    siblings;   /* list of all devices on this host */
 	struct list_head    same_target_siblings; /* just the devices sharing same target id */
 	atomic_t device_busy;		/* commands actually active on LLDD */
+	atomic_t device_blocked;	/* Device returned QUEUE_FULL. */
 	spinlock_t list_lock;
 	struct list_head cmd_list;	/* queue of in use SCSI Command structures */
 	struct list_head starved_entry;
 	struct scsi_cmnd *current_cmnd;	/* currently active command */
 	unsigned short queue_depth;	/* How deep of a queue we want */
 	unsigned short max_queue_depth;	/* max queue depth */
 	unsigned short last_queue_full_depth; /* These two are used by */
 	unsigned short last_queue_full_count; /* scsi_track_queue_full() */
 	unsigned long last_queue_full_time;	/* last queue full time */
 	unsigned long queue_ramp_up_period;	/* ramp up period in jiffies */
 #define SCSI_DEFAULT_RAMP_UP_PERIOD	(120 * HZ)
 	unsigned long last_queue_ramp_up;	/* last queue ramp up time */
 	unsigned int id, channel;
 	u64 lun;
 	unsigned int manufacturer;	/* Manufacturer of device, for using
 					 * vendor-specific cmd's */
 	unsigned sector_size;	/* size in bytes */
 	void *hostdata;		/* available to low-level driver */
 	char type;
 	char scsi_level;
 	char inq_periph_qual;	/* PQ from INQUIRY data */
 	unsigned char inquiry_len;	/* valid bytes in 'inquiry' */
 	unsigned char * inquiry;	/* INQUIRY response data */
 	const char * vendor;		/* [back_compat] point into 'inquiry' ... */
 	const char * model;		/* ... after scan; point to static string */
 	const char * rev;		/* ... "nullnullnullnull" before scan */
 #define SCSI_VPD_PG_LEN                255
 	int vpd_pg83_len;
 	unsigned char *vpd_pg83;
 	int vpd_pg80_len;
 	unsigned char *vpd_pg80;
 	unsigned char current_tag;	/* current tag */
 	struct scsi_target      *sdev_target;   /* used only for single_lun */
 	unsigned int	sdev_bflags; /* black/white flags as also found in
 				 * scsi_devinfo.[hc]. For now used only to
 				 * pass settings from slave_alloc to scsi
 				 * core. */
 	unsigned int eh_timeout; /* Error handling timeout */
 	unsigned writeable:1;
 	unsigned removable:1;
 	unsigned changed:1;	/* Data invalid due to media change */
 	unsigned busy:1;	/* Used to prevent races */
 	unsigned lockable:1;	/* Able to prevent media removal */
 	unsigned locked:1;      /* Media removal disabled */
 	unsigned borken:1;	/* Tell the Seagate driver to be
 				 * painfully slow on this device */
 	unsigned disconnect:1;	/* can disconnect */
 	unsigned soft_reset:1;	/* Uses soft reset option */
 	unsigned sdtr:1;	/* Device supports SDTR messages */
 	unsigned wdtr:1;	/* Device supports WDTR messages */
 	unsigned ppr:1;		/* Device supports PPR messages */
 	unsigned tagged_supported:1;	/* Supports SCSI-II tagged queuing */
 	unsigned simple_tags:1;	/* simple queue tag messages are enabled */
 	unsigned ordered_tags:1;/* ordered queue tag messages are enabled */
 	unsigned was_reset:1;	/* There was a bus reset on the bus for
 				 * this device */
 	unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
 				     * because we did a bus reset. */
 	unsigned use_10_for_rw:1; /* first try 10-byte read / write */
 	unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
 	unsigned no_report_opcodes:1;	/* no REPORT SUPPORTED OPERATION CODES */
 	unsigned no_write_same:1;	/* no WRITE SAME command */
 	unsigned use_16_for_rw:1; /* Use read/write(16) over read/write(10) */
 	unsigned skip_ms_page_8:1;	/* do not use MODE SENSE page 0x08 */
 	unsigned skip_ms_page_3f:1;	/* do not use MODE SENSE page 0x3f */
 	unsigned skip_vpd_pages:1;	/* do not read VPD pages */
 	unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
 	unsigned no_start_on_add:1;	/* do not issue start on add */
 	unsigned allow_restart:1; /* issue START_UNIT in error handler */
 	unsigned manage_start_stop:1;	/* Let HLD (sd) manage start/stop */
 	unsigned start_stop_pwr_cond:1;	/* Set power cond. in START_STOP_UNIT */
 	unsigned no_uld_attach:1; /* disable connecting to upper level drivers */
 	unsigned select_no_atn:1;
 	unsigned fix_capacity:1;	/* READ_CAPACITY is too high by 1 */
 	unsigned guess_capacity:1;	/* READ_CAPACITY might be too high by 1 */
 	unsigned retry_hwerror:1;	/* Retry HARDWARE_ERROR */
 	unsigned last_sector_bug:1;	/* do not use multisector accesses on
 					   SD_LAST_BUGGY_SECTORS */
 	unsigned no_read_disc_info:1;	/* Avoid READ_DISC_INFO cmds */
 	unsigned no_read_capacity_16:1; /* Avoid READ_CAPACITY_16 cmds */
 	unsigned try_rc_10_first:1;	/* Try READ_CAPACACITY_10 first */
 	unsigned is_visible:1;	/* is the device visible in sysfs */
 	unsigned wce_default_on:1;	/* Cache is ON by default */
 	unsigned no_dif:1;	/* T10 PI (DIF) should be disabled */
 	unsigned broken_fua:1;		/* Don't set FUA bit */
 	atomic_t disk_events_disable_depth; /* disable depth for disk events */
 	DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS); /* supported events */
 	DECLARE_BITMAP(pending_events, SDEV_EVT_MAXBITS); /* pending events */
 	struct list_head event_list;	/* asserted events */
 	struct work_struct event_work;
-	unsigned int device_blocked;	/* Device returned QUEUE_FULL. */
 	unsigned int max_device_blocked; /* what device_blocked counts down from  */
 #define SCSI_DEFAULT_DEVICE_BLOCKED	3
 	atomic_t iorequest_cnt;
 	atomic_t iodone_cnt;
 	atomic_t ioerr_cnt;
 	struct device		sdev_gendev,
 				sdev_dev;
 	struct execute_work	ew; /* used to get process context on put */
 	struct work_struct	requeue_work;
 	struct scsi_dh_data	*scsi_dh_data;
 	enum scsi_device_state sdev_state;
 	unsigned long		sdev_data[0];
 } __attribute__((aligned(sizeof(unsigned long))));
 struct scsi_dh_devlist {
 	char *vendor;
 	char *model;
 };
 typedef void (*activate_complete)(void *, int);
 struct scsi_device_handler {
 	/* Used by the infrastructure */
 	struct list_head list; /* list of scsi_device_handlers */
 	/* Filled by the hardware handler */
 	struct module *module;
 	const char *name;
 	const struct scsi_dh_devlist *devlist;
 	int (*check_sense)(struct scsi_device *, struct scsi_sense_hdr *);
 	int (*attach)(struct scsi_device *);
 	void (*detach)(struct scsi_device *);
 	int (*activate)(struct scsi_device *, activate_complete, void *);
 	int (*prep_fn)(struct scsi_device *, struct request *);
 	int (*set_params)(struct scsi_device *, const char *);
 	bool (*match)(struct scsi_device *);
 };
 struct scsi_dh_data {
 	struct scsi_device_handler *scsi_dh;
 	struct scsi_device *sdev;
 	struct kref kref;
 	char buf[0];
 };
 #define	to_scsi_device(d)	\
 	container_of(d, struct scsi_device, sdev_gendev)
 #define	class_to_sdev(d)	\
 	container_of(d, struct scsi_device, sdev_dev)
 #define transport_class_to_sdev(class_dev) \
 	to_scsi_device(class_dev->parent)
 #define sdev_printk(prefix, sdev, fmt, a...)	\
 	dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
 #define sdev_dbg(sdev, fmt, a...) \
 	dev_dbg(&(sdev)->sdev_gendev, fmt, ##a)
 #define scmd_printk(prefix, scmd, fmt, a...)				\
         (scmd)->request->rq_disk ?					\
 	sdev_printk(prefix, (scmd)->device, "[%s] " fmt,		\
 		    (scmd)->request->rq_disk->disk_name, ##a) :		\
 	sdev_printk(prefix, (scmd)->device, fmt, ##a)
 #define scmd_dbg(scmd, fmt, a...)					   \
 	do {								   \
 		if ((scmd)->request->rq_disk)				   \
 			sdev_dbg((scmd)->device, "[%s] " fmt,		   \
 				 (scmd)->request->rq_disk->disk_name, ##a);\
 		else							   \
 			sdev_dbg((scmd)->device, fmt, ##a);		   \
 	} while (0)
 enum scsi_target_state {
 	STARGET_CREATED = 1,
 	STARGET_RUNNING,
 	STARGET_DEL,
 };
 /*
  * scsi_target: representation of a scsi target, for now, this is only
  * used for single_lun devices. If no one has active IO to the target,
  * starget_sdev_user is NULL, else it points to the active sdev.
  */
 struct scsi_target {
 	struct scsi_device	*starget_sdev_user;
 	struct list_head	siblings;
 	struct list_head	devices;
 	struct device		dev;
 	struct kref		reap_ref; /* last put renders target invisible */
 	unsigned int		channel;
 	unsigned int		id; /* target id ... replace
 				     * scsi_device.id eventually */
 	unsigned int		create:1; /* signal that it needs to be added */
 	unsigned int		single_lun:1;	/* Indicates we should only
 						 * allow I/O to one of the luns
 						 * for the device at a time. */
 	unsigned int		pdt_1f_for_no_lun:1;	/* PDT = 0x1f
 						 * means no lun present. */
 	unsigned int		no_report_luns:1;	/* Don't use
 						 * REPORT LUNS for scanning. */
 	unsigned int		expecting_lun_change:1;	/* A device has reported
 						 * a 3F/0E UA, other devices on
 						 * the same target will also. */
 	/* commands actually active on LLD. */
 	atomic_t		target_busy;
+	atomic_t		target_blocked;
 	/*
 	 * LLDs should set this in the slave_alloc host template callout.
 	 * If set to zero then there is not limit.
 	 */
 	unsigned int		can_queue;
-	unsigned int		target_blocked;
 	unsigned int		max_target_blocked;
 #define SCSI_DEFAULT_TARGET_BLOCKED	3
 	char			scsi_level;
 	enum scsi_target_state	state;
 	void 			*hostdata; /* available to low-level driver */
 	unsigned long		starget_data[0]; /* for the transport */
 	/* starget_data must be the last element!!!! */
 } __attribute__((aligned(sizeof(unsigned long))));
 #define to_scsi_target(d)	container_of(d, struct scsi_target, dev)
 static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
 {
 	return to_scsi_target(sdev->sdev_gendev.parent);
 }
 #define transport_class_to_starget(class_dev) \
 	to_scsi_target(class_dev->parent)
 #define starget_printk(prefix, starget, fmt, a...)	\
 	dev_printk(prefix, &(starget)->dev, fmt, ##a)
 extern struct scsi_device *__scsi_add_device(struct Scsi_Host *,
 		uint, uint, u64, void *hostdata);
 extern int scsi_add_device(struct Scsi_Host *host, uint channel,
 			   uint target, u64 lun);
 extern int scsi_register_device_handler(struct scsi_device_handler *scsi_dh);
 extern void scsi_remove_device(struct scsi_device *);
 extern int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh);
 void scsi_attach_vpd(struct scsi_device *sdev);
 extern int scsi_device_get(struct scsi_device *);
 extern void scsi_device_put(struct scsi_device *);
 extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *,
 					      uint, uint, u64);
 extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *,
 						uint, uint, u64);
 extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *,
 							u64);
 extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *,
 							  u64);
 extern void starget_for_each_device(struct scsi_target *, void *,
 		     void (*fn)(struct scsi_device *, void *));
 extern void __starget_for_each_device(struct scsi_target *, void *,
 				      void (*fn)(struct scsi_device *,
 						 void *));
 /* only exposed to implement shost_for_each_device */
 extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *,
 						  struct scsi_device *);
 /**
  * shost_for_each_device - iterate over all devices of a host
  * @sdev: the &struct scsi_device to use as a cursor
  * @shost: the &struct scsi_host to iterate over
  *
  * Iterator that returns each device attached to @shost.  This loop
  * takes a reference on each device and releases it at the end.  If
  * you break out of the loop, you must call scsi_device_put(sdev).
  */
 #define shost_for_each_device(sdev, shost) \
 	for ((sdev) = __scsi_iterate_devices((shost), NULL); \
 	     (sdev); \
 	     (sdev) = __scsi_iterate_devices((shost), (sdev)))
 /**
  * __shost_for_each_device - iterate over all devices of a host (UNLOCKED)
  * @sdev: the &struct scsi_device to use as a cursor
  * @shost: the &struct scsi_host to iterate over
  *
  * Iterator that returns each device attached to @shost.  It does _not_
  * take a reference on the scsi_device, so the whole loop must be
  * protected by shost->host_lock.
  *
  * Note: The only reason to use this is because you need to access the
  * device list in interrupt context.  Otherwise you really want to use
  * shost_for_each_device instead.
  */
 #define __shost_for_each_device(sdev, shost) \
 	list_for_each_entry((sdev), &((shost)->__devices), siblings)
 extern void scsi_adjust_queue_depth(struct scsi_device *, int, int);
 extern int scsi_track_queue_full(struct scsi_device *, int);
 extern int scsi_set_medium_removal(struct scsi_device *, char);
 extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
 			   unsigned char *buffer, int len, int timeout,
 			   int retries, struct scsi_mode_data *data,
 			   struct scsi_sense_hdr *);
 extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
 			    int modepage, unsigned char *buffer, int len,
 			    int timeout, int retries,
 			    struct scsi_mode_data *data,
 			    struct scsi_sense_hdr *);
 extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
 				int retries, struct scsi_sense_hdr *sshdr);
 extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf,
 			     int buf_len);
 extern int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
 			      unsigned int len, unsigned char opcode);
 extern int scsi_device_set_state(struct scsi_device *sdev,
 				 enum scsi_device_state state);
 extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
 					  gfp_t gfpflags);
 extern void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt);
 extern void sdev_evt_send_simple(struct scsi_device *sdev,
 			  enum scsi_device_event evt_type, gfp_t gfpflags);
 extern int scsi_device_quiesce(struct scsi_device *sdev);
 extern void scsi_device_resume(struct scsi_device *sdev);
 extern void scsi_target_quiesce(struct scsi_target *);
 extern void scsi_target_resume(struct scsi_target *);
 extern void scsi_scan_target(struct device *parent, unsigned int channel,
 			     unsigned int id, u64 lun, int rescan);
 extern void scsi_target_reap(struct scsi_target *);
 extern void scsi_target_block(struct device *);
 extern void scsi_target_unblock(struct device *, enum scsi_device_state);
 extern void scsi_remove_target(struct device *);
 extern void int_to_scsilun(u64, struct scsi_lun *);
 extern u64 scsilun_to_int(struct scsi_lun *);
 extern const char *scsi_device_state_name(enum scsi_device_state);
 extern int scsi_is_sdev_device(const struct device *);
 extern int scsi_is_target_device(const struct device *);
 extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
 			int data_direction, void *buffer, unsigned bufflen,
 			unsigned char *sense, int timeout, int retries,
 			u64 flags, int *resid);
 extern int scsi_execute_req_flags(struct scsi_device *sdev,
 	const unsigned char *cmd, int data_direction, void *buffer,
 	unsigned bufflen, struct scsi_sense_hdr *sshdr, int timeout,
 	int retries, int *resid, u64 flags);
 static inline int scsi_execute_req(struct scsi_device *sdev,
 	const unsigned char *cmd, int data_direction, void *buffer,
 	unsigned bufflen, struct scsi_sense_hdr *sshdr, int timeout,
 	int retries, int *resid)
 {
 	return scsi_execute_req_flags(sdev, cmd, data_direction, buffer,
 		bufflen, sshdr, timeout, retries, resid, 0);
 }
 extern void sdev_disable_disk_events(struct scsi_device *sdev);
 extern void sdev_enable_disk_events(struct scsi_device *sdev);
 #ifdef CONFIG_PM_RUNTIME
 extern int scsi_autopm_get_device(struct scsi_device *);
 extern void scsi_autopm_put_device(struct scsi_device *);
 #else
 static inline int scsi_autopm_get_device(struct scsi_device *d) { return 0; }
 static inline void scsi_autopm_put_device(struct scsi_device *d) {}
 #endif /* CONFIG_PM_RUNTIME */
 static inline int __must_check scsi_device_reprobe(struct scsi_device *sdev)
 {
 	return device_reprobe(&sdev->sdev_gendev);
 }
 static inline unsigned int sdev_channel(struct scsi_device *sdev)
 {
 	return sdev->channel;
 }
 static inline unsigned int sdev_id(struct scsi_device *sdev)
 {
 	return sdev->id;
 }
 #define scmd_id(scmd) sdev_id((scmd)->device)
 #define scmd_channel(scmd) sdev_channel((scmd)->device)
 /*
  * checks for positions of the SCSI state machine
  */
 static inline int scsi_device_online(struct scsi_device *sdev)
 {
 	return (sdev->sdev_state != SDEV_OFFLINE &&
 		sdev->sdev_state != SDEV_TRANSPORT_OFFLINE &&
 		sdev->sdev_state != SDEV_DEL);
 }
 static inline int scsi_device_blocked(struct scsi_device *sdev)
 {
 	return sdev->sdev_state == SDEV_BLOCK ||
 		sdev->sdev_state == SDEV_CREATED_BLOCK;
 }
 static inline int scsi_device_created(struct scsi_device *sdev)
 {
 	return sdev->sdev_state == SDEV_CREATED ||
 		sdev->sdev_state == SDEV_CREATED_BLOCK;
 }
 /* accessor functions for the SCSI parameters */
 static inline int scsi_device_sync(struct scsi_device *sdev)
 {
 	return sdev->sdtr;
 }
 static inline int scsi_device_wide(struct scsi_device *sdev)
 {
 	return sdev->wdtr;
 }
 static inline int scsi_device_dt(struct scsi_device *sdev)
 {
 	return sdev->ppr;
 }
 static inline int scsi_device_dt_only(struct scsi_device *sdev)
 {
 	if (sdev->inquiry_len < 57)
 		return 0;
 	return (sdev->inquiry[56] & 0x0c) == 0x04;
 }
 static inline int scsi_device_ius(struct scsi_device *sdev)
 {
 	if (sdev->inquiry_len < 57)
 		return 0;
 	return sdev->inquiry[56] & 0x01;
 }
 static inline int scsi_device_qas(struct scsi_device *sdev)
 {
 	if (sdev->inquiry_len < 57)
 		return 0;
 	return sdev->inquiry[56] & 0x02;
 }
 static inline int scsi_device_enclosure(struct scsi_device *sdev)
 {
 	return sdev->inquiry ? (sdev->inquiry[6] & (1<<6)) : 1;
 }
 static inline int scsi_device_protection(struct scsi_device *sdev)
 {
 	if (sdev->no_dif)
 		return 0;
 	return sdev->scsi_level > SCSI_2 && sdev->inquiry[5] & (1<<0);
 }
 static inline int scsi_device_tpgs(struct scsi_device *sdev)
 {
 	return sdev->inquiry ? (sdev->inquiry[5] >> 4) & 0x3 : 0;
 }
 #define MODULE_ALIAS_SCSI_DEVICE(type) \
 	MODULE_ALIAS("scsi:t-" __stringify(type) "*")
 #define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x"

include/scsi/scsi_host.h

Diff comments View file @ cd9070c

 #ifndef _SCSI_SCSI_HOST_H
 #define _SCSI_SCSI_HOST_H
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/types.h>
 #include <linux/workqueue.h>
 #include <linux/mutex.h>
 #include <linux/seq_file.h>
 #include <scsi/scsi.h>
 struct request_queue;
 struct block_device;
 struct completion;
 struct module;
 struct scsi_cmnd;
 struct scsi_device;
 struct scsi_host_cmd_pool;
 struct scsi_target;
 struct Scsi_Host;
 struct scsi_host_cmd_pool;
 struct scsi_transport_template;
 struct blk_queue_tags;
 /*
  * The various choices mean:
  * NONE: Self evident.	Host adapter is not capable of scatter-gather.
  * ALL:	 Means that the host adapter module can do scatter-gather,
  *	 and that there is no limit to the size of the table to which
  *	 we scatter/gather data.  The value we set here is the maximum
  *	 single element sglist.  To use chained sglists, the adapter
  *	 has to set a value beyond ALL (and correctly use the chain
  *	 handling API.
  * Anything else:  Indicates the maximum number of chains that can be
  *	 used in one scatter-gather request.
  */
 #define SG_NONE 0
 #define SG_ALL	SCSI_MAX_SG_SEGMENTS
 #define MODE_UNKNOWN 0x00
 #define MODE_INITIATOR 0x01
 #define MODE_TARGET 0x02
 #define DISABLE_CLUSTERING 0
 #define ENABLE_CLUSTERING 1
 enum {
 	SCSI_QDEPTH_DEFAULT,	/* default requested change, e.g. from sysfs */
 	SCSI_QDEPTH_QFULL,	/* scsi-ml requested due to queue full */
 	SCSI_QDEPTH_RAMP_UP,	/* scsi-ml requested due to threshold event */
 };
 struct scsi_host_template {
 	struct module *module;
 	const char *name;
 	/*
 	 * Used to initialize old-style drivers.  For new-style drivers
 	 * just perform all work in your module initialization function.
 	 *
 	 * Status:  OBSOLETE
 	 */
 	int (* detect)(struct scsi_host_template *);
 	/*
 	 * Used as unload callback for hosts with old-style drivers.
 	 *
 	 * Status: OBSOLETE
 	 */
 	int (* release)(struct Scsi_Host *);
 	/*
 	 * The info function will return whatever useful information the
 	 * developer sees fit.  If not provided, then the name field will
 	 * be used instead.
 	 *
 	 * Status: OPTIONAL
 	 */
 	const char *(* info)(struct Scsi_Host *);
 	/*
 	 * Ioctl interface
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
 #ifdef CONFIG_COMPAT
 	/*
 	 * Compat handler. Handle 32bit ABI.
 	 * When unknown ioctl is passed return -ENOIOCTLCMD.
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* compat_ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
 #endif
 	/*
 	 * The queuecommand function is used to queue up a scsi
 	 * command block to the LLDD.  When the driver finished
 	 * processing the command the done callback is invoked.
 	 *
 	 * If queuecommand returns 0, then the HBA has accepted the
 	 * command.  The done() function must be called on the command
 	 * when the driver has finished with it. (you may call done on the
 	 * command before queuecommand returns, but in this case you
 	 * *must* return 0 from queuecommand).
 	 *
 	 * Queuecommand may also reject the command, in which case it may
 	 * not touch the command and must not call done() for it.
 	 *
 	 * There are two possible rejection returns:
 	 *
 	 *   SCSI_MLQUEUE_DEVICE_BUSY: Block this device temporarily, but
 	 *   allow commands to other devices serviced by this host.
 	 *
 	 *   SCSI_MLQUEUE_HOST_BUSY: Block all devices served by this
 	 *   host temporarily.
 	 *
          * For compatibility, any other non-zero return is treated the
          * same as SCSI_MLQUEUE_HOST_BUSY.
 	 *
 	 * NOTE: "temporarily" means either until the next command for#
 	 * this device/host completes, or a period of time determined by
 	 * I/O pressure in the system if there are no other outstanding
 	 * commands.
 	 *
 	 * STATUS: REQUIRED
 	 */
 	int (* queuecommand)(struct Scsi_Host *, struct scsi_cmnd *);
 	/*
 	 * This is an error handling strategy routine.  You don't need to
 	 * define one of these if you don't want to - there is a default
 	 * routine that is present that should work in most cases.  For those
 	 * driver authors that have the inclination and ability to write their
 	 * own strategy routine, this is where it is specified.  Note - the
 	 * strategy routine is *ALWAYS* run in the context of the kernel eh
 	 * thread.  Thus you are guaranteed to *NOT* be in an interrupt
 	 * handler when you execute this, and you are also guaranteed to
 	 * *NOT* have any other commands being queued while you are in the
 	 * strategy routine. When you return from this function, operations
 	 * return to normal.
 	 *
 	 * See scsi_error.c scsi_unjam_host for additional comments about
 	 * what this function should and should not be attempting to do.
 	 *
 	 * Status: REQUIRED	(at least one of them)
 	 */
 	int (* eh_abort_handler)(struct scsi_cmnd *);
 	int (* eh_device_reset_handler)(struct scsi_cmnd *);
 	int (* eh_target_reset_handler)(struct scsi_cmnd *);
 	int (* eh_bus_reset_handler)(struct scsi_cmnd *);
 	int (* eh_host_reset_handler)(struct scsi_cmnd *);
 	/*
 	 * Before the mid layer attempts to scan for a new device where none
 	 * currently exists, it will call this entry in your driver.  Should
 	 * your driver need to allocate any structs or perform any other init
 	 * items in order to send commands to a currently unused target/lun
 	 * combo, then this is where you can perform those allocations.  This
 	 * is specifically so that drivers won't have to perform any kind of
 	 * "is this a new device" checks in their queuecommand routine,
 	 * thereby making the hot path a bit quicker.
 	 *
 	 * Return values: 0 on success, non-0 on failure
 	 *
 	 * Deallocation:  If we didn't find any devices at this ID, you will
 	 * get an immediate call to slave_destroy().  If we find something
 	 * here then you will get a call to slave_configure(), then the
 	 * device will be used for however long it is kept around, then when
 	 * the device is removed from the system (or * possibly at reboot
 	 * time), you will then get a call to slave_destroy().  This is
 	 * assuming you implement slave_configure and slave_destroy.
 	 * However, if you allocate memory and hang it off the device struct,
 	 * then you must implement the slave_destroy() routine at a minimum
 	 * in order to avoid leaking memory
 	 * each time a device is tore down.
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* slave_alloc)(struct scsi_device *);
 	/*
 	 * Once the device has responded to an INQUIRY and we know the
 	 * device is online, we call into the low level driver with the
 	 * struct scsi_device *.  If the low level device driver implements
 	 * this function, it *must* perform the task of setting the queue
 	 * depth on the device.  All other tasks are optional and depend
 	 * on what the driver supports and various implementation details.
 	 *
 	 * Things currently recommended to be handled at this time include:
 	 *
 	 * 1.  Setting the device queue depth.  Proper setting of this is
 	 *     described in the comments for scsi_adjust_queue_depth.
 	 * 2.  Determining if the device supports the various synchronous
 	 *     negotiation protocols.  The device struct will already have
 	 *     responded to INQUIRY and the results of the standard items
 	 *     will have been shoved into the various device flag bits, eg.
 	 *     device->sdtr will be true if the device supports SDTR messages.
 	 * 3.  Allocating command structs that the device will need.
 	 * 4.  Setting the default timeout on this device (if needed).
 	 * 5.  Anything else the low level driver might want to do on a device
 	 *     specific setup basis...
 	 * 6.  Return 0 on success, non-0 on error.  The device will be marked
 	 *     as offline on error so that no access will occur.  If you return
 	 *     non-0, your slave_destroy routine will never get called for this
 	 *     device, so don't leave any loose memory hanging around, clean
 	 *     up after yourself before returning non-0
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* slave_configure)(struct scsi_device *);
 	/*
 	 * Immediately prior to deallocating the device and after all activity
 	 * has ceased the mid layer calls this point so that the low level
 	 * driver may completely detach itself from the scsi device and vice
 	 * versa.  The low level driver is responsible for freeing any memory
 	 * it allocated in the slave_alloc or slave_configure calls.
 	 *
 	 * Status: OPTIONAL
 	 */
 	void (* slave_destroy)(struct scsi_device *);
 	/*
 	 * Before the mid layer attempts to scan for a new device attached
 	 * to a target where no target currently exists, it will call this
 	 * entry in your driver.  Should your driver need to allocate any
 	 * structs or perform any other init items in order to send commands
 	 * to a currently unused target, then this is where you can perform
 	 * those allocations.
 	 *
 	 * Return values: 0 on success, non-0 on failure
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* target_alloc)(struct scsi_target *);
 	/*
 	 * Immediately prior to deallocating the target structure, and
 	 * after all activity to attached scsi devices has ceased, the
 	 * midlayer calls this point so that the driver may deallocate
 	 * and terminate any references to the target.
 	 *
 	 * Status: OPTIONAL
 	 */
 	void (* target_destroy)(struct scsi_target *);
 	/*
 	 * If a host has the ability to discover targets on its own instead
 	 * of scanning the entire bus, it can fill in this function and
 	 * call scsi_scan_host().  This function will be called periodically
 	 * until it returns 1 with the scsi_host and the elapsed time of
 	 * the scan in jiffies.
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* scan_finished)(struct Scsi_Host *, unsigned long);
 	/*
 	 * If the host wants to be called before the scan starts, but
 	 * after the midlayer has set up ready for the scan, it can fill
 	 * in this function.
 	 *
 	 * Status: OPTIONAL
 	 */
 	void (* scan_start)(struct Scsi_Host *);
 	/*
 	 * Fill in this function to allow the queue depth of this host
 	 * to be changeable (on a per device basis).  Returns either
 	 * the current queue depth setting (may be different from what
 	 * was passed in) or an error.  An error should only be
 	 * returned if the requested depth is legal but the driver was
 	 * unable to set it.  If the requested depth is illegal, the
 	 * driver should set and return the closest legal queue depth.
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* change_queue_depth)(struct scsi_device *, int, int);
 	/*
 	 * Fill in this function to allow the changing of tag types
 	 * (this also allows the enabling/disabling of tag command
 	 * queueing).  An error should only be returned if something
 	 * went wrong in the driver while trying to set the tag type.
 	 * If the driver doesn't support the requested tag type, then
 	 * it should set the closest type it does support without
 	 * returning an error.  Returns the actual tag type set.
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* change_queue_type)(struct scsi_device *, int);
 	/*
 	 * This function determines the BIOS parameters for a given
 	 * harddisk.  These tend to be numbers that are made up by
 	 * the host adapter.  Parameters:
 	 * size, device, list (heads, sectors, cylinders)
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (* bios_param)(struct scsi_device *, struct block_device *,
 			sector_t, int []);
 	/*
 	 * This function is called when one or more partitions on the
 	 * device reach beyond the end of the device.
 	 *
 	 * Status: OPTIONAL
 	 */
 	void (*unlock_native_capacity)(struct scsi_device *);
 	/*
 	 * Can be used to export driver statistics and other infos to the
 	 * world outside the kernel ie. userspace and it also provides an
 	 * interface to feed the driver with information.
 	 *
 	 * Status: OBSOLETE
 	 */
 	int (*show_info)(struct seq_file *, struct Scsi_Host *);
 	int (*write_info)(struct Scsi_Host *, char *, int);
 	/*
 	 * This is an optional routine that allows the transport to become
 	 * involved when a scsi io timer fires. The return value tells the
 	 * timer routine how to finish the io timeout handling:
 	 * EH_HANDLED:		I fixed the error, please complete the command
 	 * EH_RESET_TIMER:	I need more time, reset the timer and
 	 *			begin counting again
 	 * EH_NOT_HANDLED	Begin normal error recovery
 	 *
 	 * Status: OPTIONAL
 	 */
 	enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *);
 	/* This is an optional routine that allows transport to initiate
 	 * LLD adapter or firmware reset using sysfs attribute.
 	 *
 	 * Return values: 0 on success, -ve value on failure.
 	 *
 	 * Status: OPTIONAL
 	 */
 	int (*host_reset)(struct Scsi_Host *shost, int reset_type);
 #define SCSI_ADAPTER_RESET	1
 #define SCSI_FIRMWARE_RESET	2
 	/*
 	 * Name of proc directory
 	 */
 	const char *proc_name;
 	/*
 	 * Used to store the procfs directory if a driver implements the
 	 * show_info method.
 	 */
 	struct proc_dir_entry *proc_dir;
 	/*
 	 * This determines if we will use a non-interrupt driven
 	 * or an interrupt driven scheme.  It is set to the maximum number
 	 * of simultaneous commands a given host adapter will accept.
 	 */
 	int can_queue;
 	/*
 	 * In many instances, especially where disconnect / reconnect are
 	 * supported, our host also has an ID on the SCSI bus.  If this is
 	 * the case, then it must be reserved.  Please set this_id to -1 if
 	 * your setup is in single initiator mode, and the host lacks an
 	 * ID.
 	 */
 	int this_id;
 	/*
 	 * This determines the degree to which the host adapter is capable
 	 * of scatter-gather.
 	 */
 	unsigned short sg_tablesize;
 	unsigned short sg_prot_tablesize;
 	/*
 	 * Set this if the host adapter has limitations beside segment count.
 	 */
 	unsigned int max_sectors;
 	/*
 	 * DMA scatter gather segment boundary limit. A segment crossing this
 	 * boundary will be split in two.
 	 */
 	unsigned long dma_boundary;
 	/*
 	 * This specifies "machine infinity" for host templates which don't
 	 * limit the transfer size.  Note this limit represents an absolute
 	 * maximum, and may be over the transfer limits allowed for
 	 * individual devices (e.g. 256 for SCSI-1).
 	 */
 #define SCSI_DEFAULT_MAX_SECTORS	1024
 	/*
 	 * True if this host adapter can make good use of linked commands.
 	 * This will allow more than one command to be queued to a given
 	 * unit on a given host.  Set this to the maximum number of command
 	 * blocks to be provided for each device.  Set this to 1 for one
 	 * command block per lun, 2 for two, etc.  Do not set this to 0.
 	 * You should make sure that the host adapter will do the right thing
 	 * before you try setting this above 1.
 	 */
 	short cmd_per_lun;
 	/*
 	 * present contains counter indicating how many boards of this
 	 * type were found when we did the scan.
 	 */
 	unsigned char present;
 	/*
 	 * This specifies the mode that a LLD supports.
 	 */
 	unsigned supported_mode:2;
 	/*
 	 * True if this host adapter uses unchecked DMA onto an ISA bus.
 	 */
 	unsigned unchecked_isa_dma:1;
 	/*
 	 * True if this host adapter can make good use of clustering.
 	 * I originally thought that if the tablesize was large that it
 	 * was a waste of CPU cycles to prepare a cluster list, but
 	 * it works out that the Buslogic is faster if you use a smaller
 	 * number of segments (i.e. use clustering).  I guess it is
 	 * inefficient.
 	 */
 	unsigned use_clustering:1;
 	/*
 	 * True for emulated SCSI host adapters (e.g. ATAPI).
 	 */
 	unsigned emulated:1;
 	/*
 	 * True if the low-level driver performs its own reset-settle delays.
 	 */
 	unsigned skip_settle_delay:1;
 	/*
 	 * True if we are using ordered write support.
 	 */
 	unsigned ordered_tag:1;
 	/* True if the controller does not support WRITE SAME */
 	unsigned no_write_same:1;
 	/*
 	 * True if asynchronous aborts are not supported
 	 */
 	unsigned no_async_abort:1;
 	/*
 	 * Countdown for host blocking with no commands outstanding.
 	 */
 	unsigned int max_host_blocked;
 	/*
 	 * Default value for the blocking.  If the queue is empty,
 	 * host_blocked counts down in the request_fn until it restarts
 	 * host operations as zero is reached.
 	 *
 	 * FIXME: This should probably be a value in the template
 	 */
 #define SCSI_DEFAULT_HOST_BLOCKED	7
 	/*
 	 * Pointer to the sysfs class properties for this host, NULL terminated.
 	 */
 	struct device_attribute **shost_attrs;
 	/*
 	 * Pointer to the SCSI device properties for this host, NULL terminated.
 	 */
 	struct device_attribute **sdev_attrs;
 	/*
 	 * List of hosts per template.
 	 *
 	 * This is only for use by scsi_module.c for legacy templates.
 	 * For these access to it is synchronized implicitly by
 	 * module_init/module_exit.
 	 */
 	struct list_head legacy_hosts;
 	/*
 	 * Vendor Identifier associated with the host
 	 *
 	 * Note: When specifying vendor_id, be sure to read the
 	 *   Vendor Type and ID formatting requirements specified in
 	 *   scsi_netlink.h
 	 */
 	u64 vendor_id;
 	/*
 	 * Additional per-command data allocated for the driver.
 	 */
 	unsigned int cmd_size;
 	struct scsi_host_cmd_pool *cmd_pool;
 };
 /*
  * Temporary #define for host lock push down. Can be removed when all
  * drivers have been updated to take advantage of unlocked
  * queuecommand.
  *
  */
 #define DEF_SCSI_QCMD(func_name) \
 	int func_name(struct Scsi_Host *shost, struct scsi_cmnd *cmd)	\
 	{								\
 		unsigned long irq_flags;				\
 		int rc;							\
 		spin_lock_irqsave(shost->host_lock, irq_flags);		\
 		scsi_cmd_get_serial(shost, cmd);			\
 		rc = func_name##_lck (cmd, cmd->scsi_done);			\
 		spin_unlock_irqrestore(shost->host_lock, irq_flags);	\
 		return rc;						\
 	}
 /*
  * shost state: If you alter this, you also need to alter scsi_sysfs.c
  * (for the ascii descriptions) and the state model enforcer:
  * scsi_host_set_state()
  */
 enum scsi_host_state {
 	SHOST_CREATED = 1,
 	SHOST_RUNNING,
 	SHOST_CANCEL,
 	SHOST_DEL,
 	SHOST_RECOVERY,
 	SHOST_CANCEL_RECOVERY,
 	SHOST_DEL_RECOVERY,
 };
 struct Scsi_Host {
 	/*
 	 * __devices is protected by the host_lock, but you should
 	 * usually use scsi_device_lookup / shost_for_each_device
 	 * to access it and don't care about locking yourself.
 	 * In the rare case of beeing in irq context you can use
 	 * their __ prefixed variants with the lock held. NEVER
 	 * access this list directly from a driver.
 	 */
 	struct list_head	__devices;
 	struct list_head	__targets;
 	struct scsi_host_cmd_pool *cmd_pool;
 	spinlock_t		free_list_lock;
 	struct list_head	free_list; /* backup store of cmd structs */
 	struct list_head	starved_list;
 	spinlock_t		default_lock;
 	spinlock_t		*host_lock;
 	struct mutex		scan_mutex;/* serialize scanning activity */
 	struct list_head	eh_cmd_q;
 	struct task_struct    * ehandler;  /* Error recovery thread. */
 	struct completion     * eh_action; /* Wait for specific actions on the
 					      host. */
 	wait_queue_head_t       host_wait;
 	struct scsi_host_template *hostt;
 	struct scsi_transport_template *transportt;
 	/*
 	 * Area to keep a shared tag map (if needed, will be
 	 * NULL if not).
 	 */
 	struct blk_queue_tag	*bqt;
 	atomic_t host_busy;		   /* commands actually active on low-level */
+	atomic_t host_blocked;
 	unsigned int host_failed;	   /* commands that failed.
 					      protected by host_lock */
 	unsigned int host_eh_scheduled;    /* EH scheduled without command */
 	unsigned int host_no;  /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
 	/* next two fields are used to bound the time spent in error handling */
 	int eh_deadline;
 	unsigned long last_reset;
 	/*
 	 * These three parameters can be used to allow for wide scsi,
 	 * and for host adapters that support multiple busses
 	 * The first two should be set to 1 more than the actual max id
 	 * or lun (e.g. 8 for SCSI parallel systems).
 	 */
 	unsigned int max_channel;
 	unsigned int max_id;
 	u64 max_lun;
 	/*
 	 * This is a unique identifier that must be assigned so that we
 	 * have some way of identifying each detected host adapter properly
 	 * and uniquely.  For hosts that do not support more than one card
 	 * in the system at one time, this does not need to be set.  It is
 	 * initialized to 0 in scsi_register.
 	 */
 	unsigned int unique_id;
 	/*
 	 * The maximum length of SCSI commands that this host can accept.
 	 * Probably 12 for most host adapters, but could be 16 for others.
 	 * or 260 if the driver supports variable length cdbs.
 	 * For drivers that don't set this field, a value of 12 is
 	 * assumed.
 	 */
 	unsigned short max_cmd_len;
 	int this_id;
 	int can_queue;
 	short cmd_per_lun;
 	short unsigned int sg_tablesize;
 	short unsigned int sg_prot_tablesize;
 	unsigned int max_sectors;
 	unsigned long dma_boundary;
 	/*
 	 * Used to assign serial numbers to the cmds.
 	 * Protected by the host lock.
 	 */
 	unsigned long cmd_serial_number;
 	unsigned active_mode:2;
 	unsigned unchecked_isa_dma:1;
 	unsigned use_clustering:1;
 	unsigned use_blk_tcq:1;
 	/*
 	 * Host has requested that no further requests come through for the
 	 * time being.
 	 */
 	unsigned host_self_blocked:1;
 	/*
 	 * Host uses correct SCSI ordering not PC ordering. The bit is
 	 * set for the minority of drivers whose authors actually read
 	 * the spec ;).
 	 */
 	unsigned reverse_ordering:1;
 	/*
 	 * Ordered write support
 	 */
 	unsigned ordered_tag:1;
 	/* Task mgmt function in progress */
 	unsigned tmf_in_progress:1;
 	/* Asynchronous scan in progress */
 	unsigned async_scan:1;
 	/* Don't resume host in EH */
 	unsigned eh_noresume:1;
 	/* The controller does not support WRITE SAME */
 	unsigned no_write_same:1;
 	/*
 	 * Optional work queue to be utilized by the transport
 	 */
 	char work_q_name[20];
 	struct workqueue_struct *work_q;
 	/*
 	 * Task management function work queue
 	 */
 	struct workqueue_struct *tmf_work_q;
-	/*
-	 * Host has rejected a command because it was busy.
-	 */
-	unsigned int host_blocked;
 	/*
 	 * Value host_blocked counts down from
 	 */
 	unsigned int max_host_blocked;
 	/* Protection Information */
 	unsigned int prot_capabilities;
 	unsigned char prot_guard_type;
 	/*
 	 * q used for scsi_tgt msgs, async events or any other requests that
 	 * need to be processed in userspace
 	 */
 	struct request_queue *uspace_req_q;
 	/* legacy crap */
 	unsigned long base;
 	unsigned long io_port;
 	unsigned char n_io_port;
 	unsigned char dma_channel;
 	unsigned int  irq;
 	enum scsi_host_state shost_state;
 	/* ldm bits */
 	struct device		shost_gendev, shost_dev;
 	/*
 	 * List of hosts per template.
 	 *
 	 * This is only for use by scsi_module.c for legacy templates.
 	 * For these access to it is synchronized implicitly by
 	 * module_init/module_exit.
 	 */
 	struct list_head sht_legacy_list;
 	/*
 	 * Points to the transport data (if any) which is allocated
 	 * separately
 	 */
 	void *shost_data;
 	/*
 	 * Points to the physical bus device we'd use to do DMA
 	 * Needed just in case we have virtual hosts.
 	 */
 	struct device *dma_dev;
 	/*
 	 * We should ensure that this is aligned, both for better performance
 	 * and also because some compilers (m68k) don't automatically force
 	 * alignment to a long boundary.
 	 */
 	unsigned long hostdata[0]  /* Used for storage of host specific stuff */
 		__attribute__ ((aligned (sizeof(unsigned long))));
 };
 #define		class_to_shost(d)	\
 	container_of(d, struct Scsi_Host, shost_dev)
 #define shost_printk(prefix, shost, fmt, a...)	\
 	dev_printk(prefix, &(shost)->shost_gendev, fmt, ##a)
 static inline void *shost_priv(struct Scsi_Host *shost)
 {
 	return (void *)shost->hostdata;
 }
 int scsi_is_host_device(const struct device *);
 static inline struct Scsi_Host *dev_to_shost(struct device *dev)
 {
 	while (!scsi_is_host_device(dev)) {
 		if (!dev->parent)
 			return NULL;
 		dev = dev->parent;
 	}
 	return container_of(dev, struct Scsi_Host, shost_gendev);
 }
 static inline int scsi_host_in_recovery(struct Scsi_Host *shost)
 {
 	return shost->shost_state == SHOST_RECOVERY ||
 		shost->shost_state == SHOST_CANCEL_RECOVERY ||
 		shost->shost_state == SHOST_DEL_RECOVERY ||
 		shost->tmf_in_progress;
 }
 extern int scsi_queue_work(struct Scsi_Host *, struct work_struct *);
 extern void scsi_flush_work(struct Scsi_Host *);
 extern struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *, int);
 extern int __must_check scsi_add_host_with_dma(struct Scsi_Host *,
 					       struct device *,
 					       struct device *);
 extern void scsi_scan_host(struct Scsi_Host *);
 extern void scsi_rescan_device(struct device *);
 extern void scsi_remove_host(struct Scsi_Host *);
 extern struct Scsi_Host *scsi_host_get(struct Scsi_Host *);
 extern void scsi_host_put(struct Scsi_Host *t);
 extern struct Scsi_Host *scsi_host_lookup(unsigned short);
 extern const char *scsi_host_state_name(enum scsi_host_state);
 extern void scsi_cmd_get_serial(struct Scsi_Host *, struct scsi_cmnd *);
 static inline int __must_check scsi_add_host(struct Scsi_Host *host,
 					     struct device *dev)
 {
 	return scsi_add_host_with_dma(host, dev, dev);
 }
 static inline struct device *scsi_get_device(struct Scsi_Host *shost)
 {
         return shost->shost_gendev.parent;
 }
 /**
  * scsi_host_scan_allowed - Is scanning of this host allowed
  * @shost:	Pointer to Scsi_Host.
  **/
 static inline int scsi_host_scan_allowed(struct Scsi_Host *shost)
 {
 	return shost->shost_state == SHOST_RUNNING ||
 	       shost->shost_state == SHOST_RECOVERY;
 }
 extern void scsi_unblock_requests(struct Scsi_Host *);
 extern void scsi_block_requests(struct Scsi_Host *);
 struct class_container;
 extern struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
 						void (*) (struct request_queue *));
 /*
  * These two functions are used to allocate and free a pseudo device
  * which will connect to the host adapter itself rather than any
  * physical device.  You must deallocate when you are done with the
  * thing.  This physical pseudo-device isn't real and won't be available
  * from any high-level drivers.
  */
 extern void scsi_free_host_dev(struct scsi_device *);
 extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
 /*
  * DIF defines the exchange of protection information between
  * initiator and SBC block device.
  *
  * DIX defines the exchange of protection information between OS and
  * initiator.
  */
 enum scsi_host_prot_capabilities {
 	SHOST_DIF_TYPE1_PROTECTION = 1 << 0, /* T10 DIF Type 1 */
 	SHOST_DIF_TYPE2_PROTECTION = 1 << 1, /* T10 DIF Type 2 */
 	SHOST_DIF_TYPE3_PROTECTION = 1 << 2, /* T10 DIF Type 3 */
 	SHOST_DIX_TYPE0_PROTECTION = 1 << 3, /* DIX between OS and HBA only */
 	SHOST_DIX_TYPE1_PROTECTION = 1 << 4, /* DIX with DIF Type 1 */
 	SHOST_DIX_TYPE2_PROTECTION = 1 << 5, /* DIX with DIF Type 2 */
 	SHOST_DIX_TYPE3_PROTECTION = 1 << 6, /* DIX with DIF Type 3 */
 };
 /*
  * SCSI hosts which support the Data Integrity Extensions must
  * indicate their capabilities by setting the prot_capabilities using
  * this call.
  */
 static inline void scsi_host_set_prot(struct Scsi_Host *shost, unsigned int mask)
 {
 	shost->prot_capabilities = mask;
 }
 static inline unsigned int scsi_host_get_prot(struct Scsi_Host *shost)
 {
 	return shost->prot_capabilities;
 }
 static inline int scsi_host_prot_dma(struct Scsi_Host *shost)
 {
 	return shost->prot_capabilities >= SHOST_DIX_TYPE0_PROTECTION;
 }
 static inline unsigned int scsi_host_dif_capable(struct Scsi_Host *shost, unsigned int target_type)
 {
 	static unsigned char cap[] = { 0,
 				       SHOST_DIF_TYPE1_PROTECTION,
 				       SHOST_DIF_TYPE2_PROTECTION,
 				       SHOST_DIF_TYPE3_PROTECTION };
 	if (target_type >= ARRAY_SIZE(cap))
 		return 0;
 	return shost->prot_capabilities & cap[target_type] ? target_type : 0;
 }
 static inline unsigned int scsi_host_dix_capable(struct Scsi_Host *shost, unsigned int target_type)
 {
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
 	static unsigned char cap[] = { SHOST_DIX_TYPE0_PROTECTION,
 				       SHOST_DIX_TYPE1_PROTECTION,
 				       SHOST_DIX_TYPE2_PROTECTION,
 				       SHOST_DIX_TYPE3_PROTECTION };
 	if (target_type >= ARRAY_SIZE(cap))
 		return 0;
 	return shost->prot_capabilities & cap[target_type];
 #endif
 	return 0;
 }
 /*
  * All DIX-capable initiators must support the T10-mandated CRC
  * checksum.  Controllers can optionally implement the IP checksum
  * scheme which has much lower impact on system performance.  Note
  * that the main rationale for the checksum is to match integrity
  * metadata with data.  Detecting bit errors are a job for ECC memory
  * and buses.
  */
 enum scsi_host_guard_type {
 	SHOST_DIX_GUARD_CRC = 1 << 0,
 	SHOST_DIX_GUARD_IP  = 1 << 1,
 };
 static inline void scsi_host_set_guard(struct Scsi_Host *shost, unsigned char type)
 {
 	shost->prot_guard_type = type;
 }
 static inline unsigned char scsi_host_get_guard(struct Scsi_Host *shost)
 {
 	return shost->prot_guard_type;
 }
 /* legacy interfaces */
 extern struct Scsi_Host *scsi_register(struct scsi_host_template *, int);
 extern void scsi_unregister(struct Scsi_Host *);
 extern int scsi_host_set_state(struct Scsi_Host *, enum scsi_host_state);