PageRenderTime 237ms CodeModel.GetById 37ms app.highlight 184ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/scsi/scsi_lib.c

https://bitbucket.org/abioy/linux
C | 2560 lines | 1523 code | 310 blank | 727 comment | 289 complexity | a2587118637162b49f349d2c4f4766d6 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

   1/*
   2 *  scsi_lib.c Copyright (C) 1999 Eric Youngdale
   3 *
   4 *  SCSI queueing library.
   5 *      Initial versions: Eric Youngdale (eric@andante.org).
   6 *                        Based upon conversations with large numbers
   7 *                        of people at Linux Expo.
   8 */
   9
  10#include <linux/bio.h>
  11#include <linux/bitops.h>
  12#include <linux/blkdev.h>
  13#include <linux/completion.h>
  14#include <linux/kernel.h>
  15#include <linux/mempool.h>
  16#include <linux/slab.h>
  17#include <linux/init.h>
  18#include <linux/pci.h>
  19#include <linux/delay.h>
  20#include <linux/hardirq.h>
  21#include <linux/scatterlist.h>
  22
  23#include <scsi/scsi.h>
  24#include <scsi/scsi_cmnd.h>
  25#include <scsi/scsi_dbg.h>
  26#include <scsi/scsi_device.h>
  27#include <scsi/scsi_driver.h>
  28#include <scsi/scsi_eh.h>
  29#include <scsi/scsi_host.h>
  30
  31#include "scsi_priv.h"
  32#include "scsi_logging.h"
  33
  34
  35#define SG_MEMPOOL_NR		ARRAY_SIZE(scsi_sg_pools)
  36#define SG_MEMPOOL_SIZE		2
  37
  38struct scsi_host_sg_pool {
  39	size_t		size;
  40	char		*name;
  41	struct kmem_cache	*slab;
  42	mempool_t	*pool;
  43};
  44
  45#define SP(x) { x, "sgpool-" __stringify(x) }
  46#if (SCSI_MAX_SG_SEGMENTS < 32)
  47#error SCSI_MAX_SG_SEGMENTS is too small (must be 32 or greater)
  48#endif
  49static struct scsi_host_sg_pool scsi_sg_pools[] = {
  50	SP(8),
  51	SP(16),
  52#if (SCSI_MAX_SG_SEGMENTS > 32)
  53	SP(32),
  54#if (SCSI_MAX_SG_SEGMENTS > 64)
  55	SP(64),
  56#if (SCSI_MAX_SG_SEGMENTS > 128)
  57	SP(128),
  58#if (SCSI_MAX_SG_SEGMENTS > 256)
  59#error SCSI_MAX_SG_SEGMENTS is too large (256 MAX)
  60#endif
  61#endif
  62#endif
  63#endif
  64	SP(SCSI_MAX_SG_SEGMENTS)
  65};
  66#undef SP
  67
  68struct kmem_cache *scsi_sdb_cache;
  69
  70static void scsi_run_queue(struct request_queue *q);
  71
  72/*
  73 * Function:	scsi_unprep_request()
  74 *
  75 * Purpose:	Remove all preparation done for a request, including its
  76 *		associated scsi_cmnd, so that it can be requeued.
  77 *
  78 * Arguments:	req	- request to unprepare
  79 *
  80 * Lock status:	Assumed that no locks are held upon entry.
  81 *
  82 * Returns:	Nothing.
  83 */
  84static void scsi_unprep_request(struct request *req)
  85{
  86	struct scsi_cmnd *cmd = req->special;
  87
  88	req->cmd_flags &= ~REQ_DONTPREP;
  89	req->special = NULL;
  90
  91	scsi_put_command(cmd);
  92}
  93
  94/**
  95 * __scsi_queue_insert - private queue insertion
  96 * @cmd: The SCSI command being requeued
  97 * @reason:  The reason for the requeue
  98 * @unbusy: Whether the queue should be unbusied
  99 *
 100 * This is a private queue insertion.  The public interface
 101 * scsi_queue_insert() always assumes the queue should be unbusied
 102 * because it's always called before the completion.  This function is
 103 * for a requeue after completion, which should only occur in this
 104 * file.
 105 */
 106static int __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy)
 107{
 108	struct Scsi_Host *host = cmd->device->host;
 109	struct scsi_device *device = cmd->device;
 110	struct scsi_target *starget = scsi_target(device);
 111	struct request_queue *q = device->request_queue;
 112	unsigned long flags;
 113
 114	SCSI_LOG_MLQUEUE(1,
 115		 printk("Inserting command %p into mlqueue\n", cmd));
 116
 117	/*
 118	 * Set the appropriate busy bit for the device/host.
 119	 *
 120	 * If the host/device isn't busy, assume that something actually
 121	 * completed, and that we should be able to queue a command now.
 122	 *
 123	 * Note that the prior mid-layer assumption that any host could
 124	 * always queue at least one command is now broken.  The mid-layer
 125	 * will implement a user specifiable stall (see
 126	 * scsi_host.max_host_blocked and scsi_device.max_device_blocked)
 127	 * if a command is requeued with no other commands outstanding
 128	 * either for the device or for the host.
 129	 */
 130	switch (reason) {
 131	case SCSI_MLQUEUE_HOST_BUSY:
 132		host->host_blocked = host->max_host_blocked;
 133		break;
 134	case SCSI_MLQUEUE_DEVICE_BUSY:
 135		device->device_blocked = device->max_device_blocked;
 136		break;
 137	case SCSI_MLQUEUE_TARGET_BUSY:
 138		starget->target_blocked = starget->max_target_blocked;
 139		break;
 140	}
 141
 142	/*
 143	 * Decrement the counters, since these commands are no longer
 144	 * active on the host/device.
 145	 */
 146	if (unbusy)
 147		scsi_device_unbusy(device);
 148
 149	/*
 150	 * Requeue this command.  It will go before all other commands
 151	 * that are already in the queue.
 152	 *
 153	 * NOTE: there is magic here about the way the queue is plugged if
 154	 * we have no outstanding commands.
 155	 * 
 156	 * Although we *don't* plug the queue, we call the request
 157	 * function.  The SCSI request function detects the blocked condition
 158	 * and plugs the queue appropriately.
 159         */
 160	spin_lock_irqsave(q->queue_lock, flags);
 161	blk_requeue_request(q, cmd->request);
 162	spin_unlock_irqrestore(q->queue_lock, flags);
 163
 164	scsi_run_queue(q);
 165
 166	return 0;
 167}
 168
 169/*
 170 * Function:    scsi_queue_insert()
 171 *
 172 * Purpose:     Insert a command in the midlevel queue.
 173 *
 174 * Arguments:   cmd    - command that we are adding to queue.
 175 *              reason - why we are inserting command to queue.
 176 *
 177 * Lock status: Assumed that lock is not held upon entry.
 178 *
 179 * Returns:     Nothing.
 180 *
 181 * Notes:       We do this for one of two cases.  Either the host is busy
 182 *              and it cannot accept any more commands for the time being,
 183 *              or the device returned QUEUE_FULL and can accept no more
 184 *              commands.
 185 * Notes:       This could be called either from an interrupt context or a
 186 *              normal process context.
 187 */
 188int scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
 189{
 190	return __scsi_queue_insert(cmd, reason, 1);
 191}
 192/**
 193 * scsi_execute - insert request and wait for the result
 194 * @sdev:	scsi device
 195 * @cmd:	scsi command
 196 * @data_direction: data direction
 197 * @buffer:	data buffer
 198 * @bufflen:	len of buffer
 199 * @sense:	optional sense buffer
 200 * @timeout:	request timeout in seconds
 201 * @retries:	number of times to retry request
 202 * @flags:	or into request flags;
 203 * @resid:	optional residual length
 204 *
 205 * returns the req->errors value which is the scsi_cmnd result
 206 * field.
 207 */
 208int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
 209		 int data_direction, void *buffer, unsigned bufflen,
 210		 unsigned char *sense, int timeout, int retries, int flags,
 211		 int *resid)
 212{
 213	struct request *req;
 214	int write = (data_direction == DMA_TO_DEVICE);
 215	int ret = DRIVER_ERROR << 24;
 216
 217	req = blk_get_request(sdev->request_queue, write, __GFP_WAIT);
 218
 219	if (bufflen &&	blk_rq_map_kern(sdev->request_queue, req,
 220					buffer, bufflen, __GFP_WAIT))
 221		goto out;
 222
 223	req->cmd_len = COMMAND_SIZE(cmd[0]);
 224	memcpy(req->cmd, cmd, req->cmd_len);
 225	req->sense = sense;
 226	req->sense_len = 0;
 227	req->retries = retries;
 228	req->timeout = timeout;
 229	req->cmd_type = REQ_TYPE_BLOCK_PC;
 230	req->cmd_flags |= flags | REQ_QUIET | REQ_PREEMPT;
 231
 232	/*
 233	 * head injection *required* here otherwise quiesce won't work
 234	 */
 235	blk_execute_rq(req->q, NULL, req, 1);
 236
 237	/*
 238	 * Some devices (USB mass-storage in particular) may transfer
 239	 * garbage data together with a residue indicating that the data
 240	 * is invalid.  Prevent the garbage from being misinterpreted
 241	 * and prevent security leaks by zeroing out the excess data.
 242	 */
 243	if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen))
 244		memset(buffer + (bufflen - req->resid_len), 0, req->resid_len);
 245
 246	if (resid)
 247		*resid = req->resid_len;
 248	ret = req->errors;
 249 out:
 250	blk_put_request(req);
 251
 252	return ret;
 253}
 254EXPORT_SYMBOL(scsi_execute);
 255
 256
 257int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
 258		     int data_direction, void *buffer, unsigned bufflen,
 259		     struct scsi_sense_hdr *sshdr, int timeout, int retries,
 260		     int *resid)
 261{
 262	char *sense = NULL;
 263	int result;
 264	
 265	if (sshdr) {
 266		sense = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
 267		if (!sense)
 268			return DRIVER_ERROR << 24;
 269	}
 270	result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen,
 271			      sense, timeout, retries, 0, resid);
 272	if (sshdr)
 273		scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, sshdr);
 274
 275	kfree(sense);
 276	return result;
 277}
 278EXPORT_SYMBOL(scsi_execute_req);
 279
 280/*
 281 * Function:    scsi_init_cmd_errh()
 282 *
 283 * Purpose:     Initialize cmd fields related to error handling.
 284 *
 285 * Arguments:   cmd	- command that is ready to be queued.
 286 *
 287 * Notes:       This function has the job of initializing a number of
 288 *              fields related to error handling.   Typically this will
 289 *              be called once for each command, as required.
 290 */
 291static void scsi_init_cmd_errh(struct scsi_cmnd *cmd)
 292{
 293	cmd->serial_number = 0;
 294	scsi_set_resid(cmd, 0);
 295	memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
 296	if (cmd->cmd_len == 0)
 297		cmd->cmd_len = scsi_command_size(cmd->cmnd);
 298}
 299
 300void scsi_device_unbusy(struct scsi_device *sdev)
 301{
 302	struct Scsi_Host *shost = sdev->host;
 303	struct scsi_target *starget = scsi_target(sdev);
 304	unsigned long flags;
 305
 306	spin_lock_irqsave(shost->host_lock, flags);
 307	shost->host_busy--;
 308	starget->target_busy--;
 309	if (unlikely(scsi_host_in_recovery(shost) &&
 310		     (shost->host_failed || shost->host_eh_scheduled)))
 311		scsi_eh_wakeup(shost);
 312	spin_unlock(shost->host_lock);
 313	spin_lock(sdev->request_queue->queue_lock);
 314	sdev->device_busy--;
 315	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 316}
 317
 318/*
 319 * Called for single_lun devices on IO completion. Clear starget_sdev_user,
 320 * and call blk_run_queue for all the scsi_devices on the target -
 321 * including current_sdev first.
 322 *
 323 * Called with *no* scsi locks held.
 324 */
 325static void scsi_single_lun_run(struct scsi_device *current_sdev)
 326{
 327	struct Scsi_Host *shost = current_sdev->host;
 328	struct scsi_device *sdev, *tmp;
 329	struct scsi_target *starget = scsi_target(current_sdev);
 330	unsigned long flags;
 331
 332	spin_lock_irqsave(shost->host_lock, flags);
 333	starget->starget_sdev_user = NULL;
 334	spin_unlock_irqrestore(shost->host_lock, flags);
 335
 336	/*
 337	 * Call blk_run_queue for all LUNs on the target, starting with
 338	 * current_sdev. We race with others (to set starget_sdev_user),
 339	 * but in most cases, we will be first. Ideally, each LU on the
 340	 * target would get some limited time or requests on the target.
 341	 */
 342	blk_run_queue(current_sdev->request_queue);
 343
 344	spin_lock_irqsave(shost->host_lock, flags);
 345	if (starget->starget_sdev_user)
 346		goto out;
 347	list_for_each_entry_safe(sdev, tmp, &starget->devices,
 348			same_target_siblings) {
 349		if (sdev == current_sdev)
 350			continue;
 351		if (scsi_device_get(sdev))
 352			continue;
 353
 354		spin_unlock_irqrestore(shost->host_lock, flags);
 355		blk_run_queue(sdev->request_queue);
 356		spin_lock_irqsave(shost->host_lock, flags);
 357	
 358		scsi_device_put(sdev);
 359	}
 360 out:
 361	spin_unlock_irqrestore(shost->host_lock, flags);
 362}
 363
 364static inline int scsi_device_is_busy(struct scsi_device *sdev)
 365{
 366	if (sdev->device_busy >= sdev->queue_depth || sdev->device_blocked)
 367		return 1;
 368
 369	return 0;
 370}
 371
 372static inline int scsi_target_is_busy(struct scsi_target *starget)
 373{
 374	return ((starget->can_queue > 0 &&
 375		 starget->target_busy >= starget->can_queue) ||
 376		 starget->target_blocked);
 377}
 378
 379static inline int scsi_host_is_busy(struct Scsi_Host *shost)
 380{
 381	if ((shost->can_queue > 0 && shost->host_busy >= shost->can_queue) ||
 382	    shost->host_blocked || shost->host_self_blocked)
 383		return 1;
 384
 385	return 0;
 386}
 387
 388/*
 389 * Function:	scsi_run_queue()
 390 *
 391 * Purpose:	Select a proper request queue to serve next
 392 *
 393 * Arguments:	q	- last request's queue
 394 *
 395 * Returns:     Nothing
 396 *
 397 * Notes:	The previous command was completely finished, start
 398 *		a new one if possible.
 399 */
 400static void scsi_run_queue(struct request_queue *q)
 401{
 402	struct scsi_device *sdev = q->queuedata;
 403	struct Scsi_Host *shost = sdev->host;
 404	LIST_HEAD(starved_list);
 405	unsigned long flags;
 406
 407	if (scsi_target(sdev)->single_lun)
 408		scsi_single_lun_run(sdev);
 409
 410	spin_lock_irqsave(shost->host_lock, flags);
 411	list_splice_init(&shost->starved_list, &starved_list);
 412
 413	while (!list_empty(&starved_list)) {
 414		int flagset;
 415
 416		/*
 417		 * As long as shost is accepting commands and we have
 418		 * starved queues, call blk_run_queue. scsi_request_fn
 419		 * drops the queue_lock and can add us back to the
 420		 * starved_list.
 421		 *
 422		 * host_lock protects the starved_list and starved_entry.
 423		 * scsi_request_fn must get the host_lock before checking
 424		 * or modifying starved_list or starved_entry.
 425		 */
 426		if (scsi_host_is_busy(shost))
 427			break;
 428
 429		sdev = list_entry(starved_list.next,
 430				  struct scsi_device, starved_entry);
 431		list_del_init(&sdev->starved_entry);
 432		if (scsi_target_is_busy(scsi_target(sdev))) {
 433			list_move_tail(&sdev->starved_entry,
 434				       &shost->starved_list);
 435			continue;
 436		}
 437
 438		spin_unlock(shost->host_lock);
 439
 440		spin_lock(sdev->request_queue->queue_lock);
 441		flagset = test_bit(QUEUE_FLAG_REENTER, &q->queue_flags) &&
 442				!test_bit(QUEUE_FLAG_REENTER,
 443					&sdev->request_queue->queue_flags);
 444		if (flagset)
 445			queue_flag_set(QUEUE_FLAG_REENTER, sdev->request_queue);
 446		__blk_run_queue(sdev->request_queue);
 447		if (flagset)
 448			queue_flag_clear(QUEUE_FLAG_REENTER, sdev->request_queue);
 449		spin_unlock(sdev->request_queue->queue_lock);
 450
 451		spin_lock(shost->host_lock);
 452	}
 453	/* put any unprocessed entries back */
 454	list_splice(&starved_list, &shost->starved_list);
 455	spin_unlock_irqrestore(shost->host_lock, flags);
 456
 457	blk_run_queue(q);
 458}
 459
 460/*
 461 * Function:	scsi_requeue_command()
 462 *
 463 * Purpose:	Handle post-processing of completed commands.
 464 *
 465 * Arguments:	q	- queue to operate on
 466 *		cmd	- command that may need to be requeued.
 467 *
 468 * Returns:	Nothing
 469 *
 470 * Notes:	After command completion, there may be blocks left
 471 *		over which weren't finished by the previous command
 472 *		this can be for a number of reasons - the main one is
 473 *		I/O errors in the middle of the request, in which case
 474 *		we need to request the blocks that come after the bad
 475 *		sector.
 476 * Notes:	Upon return, cmd is a stale pointer.
 477 */
 478static void scsi_requeue_command(struct request_queue *q, struct scsi_cmnd *cmd)
 479{
 480	struct request *req = cmd->request;
 481	unsigned long flags;
 482
 483	spin_lock_irqsave(q->queue_lock, flags);
 484	scsi_unprep_request(req);
 485	blk_requeue_request(q, req);
 486	spin_unlock_irqrestore(q->queue_lock, flags);
 487
 488	scsi_run_queue(q);
 489}
 490
 491void scsi_next_command(struct scsi_cmnd *cmd)
 492{
 493	struct scsi_device *sdev = cmd->device;
 494	struct request_queue *q = sdev->request_queue;
 495
 496	/* need to hold a reference on the device before we let go of the cmd */
 497	get_device(&sdev->sdev_gendev);
 498
 499	scsi_put_command(cmd);
 500	scsi_run_queue(q);
 501
 502	/* ok to remove device now */
 503	put_device(&sdev->sdev_gendev);
 504}
 505
 506void scsi_run_host_queues(struct Scsi_Host *shost)
 507{
 508	struct scsi_device *sdev;
 509
 510	shost_for_each_device(sdev, shost)
 511		scsi_run_queue(sdev->request_queue);
 512}
 513
 514static void __scsi_release_buffers(struct scsi_cmnd *, int);
 515
 516/*
 517 * Function:    scsi_end_request()
 518 *
 519 * Purpose:     Post-processing of completed commands (usually invoked at end
 520 *		of upper level post-processing and scsi_io_completion).
 521 *
 522 * Arguments:   cmd	 - command that is complete.
 523 *              error    - 0 if I/O indicates success, < 0 for I/O error.
 524 *              bytes    - number of bytes of completed I/O
 525 *		requeue  - indicates whether we should requeue leftovers.
 526 *
 527 * Lock status: Assumed that lock is not held upon entry.
 528 *
 529 * Returns:     cmd if requeue required, NULL otherwise.
 530 *
 531 * Notes:       This is called for block device requests in order to
 532 *              mark some number of sectors as complete.
 533 * 
 534 *		We are guaranteeing that the request queue will be goosed
 535 *		at some point during this call.
 536 * Notes:	If cmd was requeued, upon return it will be a stale pointer.
 537 */
 538static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int error,
 539					  int bytes, int requeue)
 540{
 541	struct request_queue *q = cmd->device->request_queue;
 542	struct request *req = cmd->request;
 543
 544	/*
 545	 * If there are blocks left over at the end, set up the command
 546	 * to queue the remainder of them.
 547	 */
 548	if (blk_end_request(req, error, bytes)) {
 549		/* kill remainder if no retrys */
 550		if (error && scsi_noretry_cmd(cmd))
 551			blk_end_request_all(req, error);
 552		else {
 553			if (requeue) {
 554				/*
 555				 * Bleah.  Leftovers again.  Stick the
 556				 * leftovers in the front of the
 557				 * queue, and goose the queue again.
 558				 */
 559				scsi_release_buffers(cmd);
 560				scsi_requeue_command(q, cmd);
 561				cmd = NULL;
 562			}
 563			return cmd;
 564		}
 565	}
 566
 567	/*
 568	 * This will goose the queue request function at the end, so we don't
 569	 * need to worry about launching another command.
 570	 */
 571	__scsi_release_buffers(cmd, 0);
 572	scsi_next_command(cmd);
 573	return NULL;
 574}
 575
 576static inline unsigned int scsi_sgtable_index(unsigned short nents)
 577{
 578	unsigned int index;
 579
 580	BUG_ON(nents > SCSI_MAX_SG_SEGMENTS);
 581
 582	if (nents <= 8)
 583		index = 0;
 584	else
 585		index = get_count_order(nents) - 3;
 586
 587	return index;
 588}
 589
 590static void scsi_sg_free(struct scatterlist *sgl, unsigned int nents)
 591{
 592	struct scsi_host_sg_pool *sgp;
 593
 594	sgp = scsi_sg_pools + scsi_sgtable_index(nents);
 595	mempool_free(sgl, sgp->pool);
 596}
 597
 598static struct scatterlist *scsi_sg_alloc(unsigned int nents, gfp_t gfp_mask)
 599{
 600	struct scsi_host_sg_pool *sgp;
 601
 602	sgp = scsi_sg_pools + scsi_sgtable_index(nents);
 603	return mempool_alloc(sgp->pool, gfp_mask);
 604}
 605
 606static int scsi_alloc_sgtable(struct scsi_data_buffer *sdb, int nents,
 607			      gfp_t gfp_mask)
 608{
 609	int ret;
 610
 611	BUG_ON(!nents);
 612
 613	ret = __sg_alloc_table(&sdb->table, nents, SCSI_MAX_SG_SEGMENTS,
 614			       gfp_mask, scsi_sg_alloc);
 615	if (unlikely(ret))
 616		__sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS,
 617				scsi_sg_free);
 618
 619	return ret;
 620}
 621
 622static void scsi_free_sgtable(struct scsi_data_buffer *sdb)
 623{
 624	__sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS, scsi_sg_free);
 625}
 626
 627static void __scsi_release_buffers(struct scsi_cmnd *cmd, int do_bidi_check)
 628{
 629
 630	if (cmd->sdb.table.nents)
 631		scsi_free_sgtable(&cmd->sdb);
 632
 633	memset(&cmd->sdb, 0, sizeof(cmd->sdb));
 634
 635	if (do_bidi_check && scsi_bidi_cmnd(cmd)) {
 636		struct scsi_data_buffer *bidi_sdb =
 637			cmd->request->next_rq->special;
 638		scsi_free_sgtable(bidi_sdb);
 639		kmem_cache_free(scsi_sdb_cache, bidi_sdb);
 640		cmd->request->next_rq->special = NULL;
 641	}
 642
 643	if (scsi_prot_sg_count(cmd))
 644		scsi_free_sgtable(cmd->prot_sdb);
 645}
 646
 647/*
 648 * Function:    scsi_release_buffers()
 649 *
 650 * Purpose:     Completion processing for block device I/O requests.
 651 *
 652 * Arguments:   cmd	- command that we are bailing.
 653 *
 654 * Lock status: Assumed that no lock is held upon entry.
 655 *
 656 * Returns:     Nothing
 657 *
 658 * Notes:       In the event that an upper level driver rejects a
 659 *		command, we must release resources allocated during
 660 *		the __init_io() function.  Primarily this would involve
 661 *		the scatter-gather table, and potentially any bounce
 662 *		buffers.
 663 */
 664void scsi_release_buffers(struct scsi_cmnd *cmd)
 665{
 666	__scsi_release_buffers(cmd, 1);
 667}
 668EXPORT_SYMBOL(scsi_release_buffers);
 669
 670/*
 671 * Function:    scsi_io_completion()
 672 *
 673 * Purpose:     Completion processing for block device I/O requests.
 674 *
 675 * Arguments:   cmd   - command that is finished.
 676 *
 677 * Lock status: Assumed that no lock is held upon entry.
 678 *
 679 * Returns:     Nothing
 680 *
 681 * Notes:       This function is matched in terms of capabilities to
 682 *              the function that created the scatter-gather list.
 683 *              In other words, if there are no bounce buffers
 684 *              (the normal case for most drivers), we don't need
 685 *              the logic to deal with cleaning up afterwards.
 686 *
 687 *		We must call scsi_end_request().  This will finish off
 688 *		the specified number of sectors.  If we are done, the
 689 *		command block will be released and the queue function
 690 *		will be goosed.  If we are not done then we have to
 691 *		figure out what to do next:
 692 *
 693 *		a) We can call scsi_requeue_command().  The request
 694 *		   will be unprepared and put back on the queue.  Then
 695 *		   a new command will be created for it.  This should
 696 *		   be used if we made forward progress, or if we want
 697 *		   to switch from READ(10) to READ(6) for example.
 698 *
 699 *		b) We can call scsi_queue_insert().  The request will
 700 *		   be put back on the queue and retried using the same
 701 *		   command as before, possibly after a delay.
 702 *
 703 *		c) We can call blk_end_request() with -EIO to fail
 704 *		   the remainder of the request.
 705 */
 706void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
 707{
 708	int result = cmd->result;
 709	struct request_queue *q = cmd->device->request_queue;
 710	struct request *req = cmd->request;
 711	int error = 0;
 712	struct scsi_sense_hdr sshdr;
 713	int sense_valid = 0;
 714	int sense_deferred = 0;
 715	enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY,
 716	      ACTION_DELAYED_RETRY} action;
 717	char *description = NULL;
 718
 719	if (result) {
 720		sense_valid = scsi_command_normalize_sense(cmd, &sshdr);
 721		if (sense_valid)
 722			sense_deferred = scsi_sense_is_deferred(&sshdr);
 723	}
 724
 725	if (blk_pc_request(req)) { /* SG_IO ioctl from block level */
 726		req->errors = result;
 727		if (result) {
 728			if (sense_valid && req->sense) {
 729				/*
 730				 * SG_IO wants current and deferred errors
 731				 */
 732				int len = 8 + cmd->sense_buffer[7];
 733
 734				if (len > SCSI_SENSE_BUFFERSIZE)
 735					len = SCSI_SENSE_BUFFERSIZE;
 736				memcpy(req->sense, cmd->sense_buffer,  len);
 737				req->sense_len = len;
 738			}
 739			if (!sense_deferred)
 740				error = -EIO;
 741		}
 742
 743		req->resid_len = scsi_get_resid(cmd);
 744
 745		if (scsi_bidi_cmnd(cmd)) {
 746			/*
 747			 * Bidi commands Must be complete as a whole,
 748			 * both sides at once.
 749			 */
 750			req->next_rq->resid_len = scsi_in(cmd)->resid;
 751
 752			scsi_release_buffers(cmd);
 753			blk_end_request_all(req, 0);
 754
 755			scsi_next_command(cmd);
 756			return;
 757		}
 758	}
 759
 760	BUG_ON(blk_bidi_rq(req)); /* bidi not support for !blk_pc_request yet */
 761
 762	/*
 763	 * Next deal with any sectors which we were able to correctly
 764	 * handle.
 765	 */
 766	SCSI_LOG_HLCOMPLETE(1, printk("%u sectors total, "
 767				      "%d bytes done.\n",
 768				      blk_rq_sectors(req), good_bytes));
 769
 770	/*
 771	 * Recovered errors need reporting, but they're always treated
 772	 * as success, so fiddle the result code here.  For BLOCK_PC
 773	 * we already took a copy of the original into rq->errors which
 774	 * is what gets returned to the user
 775	 */
 776	if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) {
 777		/* if ATA PASS-THROUGH INFORMATION AVAILABLE skip
 778		 * print since caller wants ATA registers. Only occurs on
 779		 * SCSI ATA PASS_THROUGH commands when CK_COND=1
 780		 */
 781		if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
 782			;
 783		else if (!(req->cmd_flags & REQ_QUIET))
 784			scsi_print_sense("", cmd);
 785		result = 0;
 786		/* BLOCK_PC may have set error */
 787		error = 0;
 788	}
 789
 790	/*
 791	 * A number of bytes were successfully read.  If there
 792	 * are leftovers and there is some kind of error
 793	 * (result != 0), retry the rest.
 794	 */
 795	if (scsi_end_request(cmd, error, good_bytes, result == 0) == NULL)
 796		return;
 797
 798	error = -EIO;
 799
 800	if (host_byte(result) == DID_RESET) {
 801		/* Third party bus reset or reset for error recovery
 802		 * reasons.  Just retry the command and see what
 803		 * happens.
 804		 */
 805		action = ACTION_RETRY;
 806	} else if (sense_valid && !sense_deferred) {
 807		switch (sshdr.sense_key) {
 808		case UNIT_ATTENTION:
 809			if (cmd->device->removable) {
 810				/* Detected disc change.  Set a bit
 811				 * and quietly refuse further access.
 812				 */
 813				cmd->device->changed = 1;
 814				description = "Media Changed";
 815				action = ACTION_FAIL;
 816			} else {
 817				/* Must have been a power glitch, or a
 818				 * bus reset.  Could not have been a
 819				 * media change, so we just retry the
 820				 * command and see what happens.
 821				 */
 822				action = ACTION_RETRY;
 823			}
 824			break;
 825		case ILLEGAL_REQUEST:
 826			/* If we had an ILLEGAL REQUEST returned, then
 827			 * we may have performed an unsupported
 828			 * command.  The only thing this should be
 829			 * would be a ten byte read where only a six
 830			 * byte read was supported.  Also, on a system
 831			 * where READ CAPACITY failed, we may have
 832			 * read past the end of the disk.
 833			 */
 834			if ((cmd->device->use_10_for_rw &&
 835			    sshdr.asc == 0x20 && sshdr.ascq == 0x00) &&
 836			    (cmd->cmnd[0] == READ_10 ||
 837			     cmd->cmnd[0] == WRITE_10)) {
 838				/* This will issue a new 6-byte command. */
 839				cmd->device->use_10_for_rw = 0;
 840				action = ACTION_REPREP;
 841			} else if (sshdr.asc == 0x10) /* DIX */ {
 842				description = "Host Data Integrity Failure";
 843				action = ACTION_FAIL;
 844				error = -EILSEQ;
 845			} else
 846				action = ACTION_FAIL;
 847			break;
 848		case ABORTED_COMMAND:
 849			action = ACTION_FAIL;
 850			if (sshdr.asc == 0x10) { /* DIF */
 851				description = "Target Data Integrity Failure";
 852				error = -EILSEQ;
 853			}
 854			break;
 855		case NOT_READY:
 856			/* If the device is in the process of becoming
 857			 * ready, or has a temporary blockage, retry.
 858			 */
 859			if (sshdr.asc == 0x04) {
 860				switch (sshdr.ascq) {
 861				case 0x01: /* becoming ready */
 862				case 0x04: /* format in progress */
 863				case 0x05: /* rebuild in progress */
 864				case 0x06: /* recalculation in progress */
 865				case 0x07: /* operation in progress */
 866				case 0x08: /* Long write in progress */
 867				case 0x09: /* self test in progress */
 868				case 0x14: /* space allocation in progress */
 869					action = ACTION_DELAYED_RETRY;
 870					break;
 871				default:
 872					description = "Device not ready";
 873					action = ACTION_FAIL;
 874					break;
 875				}
 876			} else {
 877				description = "Device not ready";
 878				action = ACTION_FAIL;
 879			}
 880			break;
 881		case VOLUME_OVERFLOW:
 882			/* See SSC3rXX or current. */
 883			action = ACTION_FAIL;
 884			break;
 885		default:
 886			description = "Unhandled sense code";
 887			action = ACTION_FAIL;
 888			break;
 889		}
 890	} else {
 891		description = "Unhandled error code";
 892		action = ACTION_FAIL;
 893	}
 894
 895	switch (action) {
 896	case ACTION_FAIL:
 897		/* Give up and fail the remainder of the request */
 898		scsi_release_buffers(cmd);
 899		if (!(req->cmd_flags & REQ_QUIET)) {
 900			if (description)
 901				scmd_printk(KERN_INFO, cmd, "%s\n",
 902					    description);
 903			scsi_print_result(cmd);
 904			if (driver_byte(result) & DRIVER_SENSE)
 905				scsi_print_sense("", cmd);
 906			scsi_print_command(cmd);
 907		}
 908		if (blk_end_request_err(req, error))
 909			scsi_requeue_command(q, cmd);
 910		else
 911			scsi_next_command(cmd);
 912		break;
 913	case ACTION_REPREP:
 914		/* Unprep the request and put it back at the head of the queue.
 915		 * A new command will be prepared and issued.
 916		 */
 917		scsi_release_buffers(cmd);
 918		scsi_requeue_command(q, cmd);
 919		break;
 920	case ACTION_RETRY:
 921		/* Retry the same command immediately */
 922		__scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, 0);
 923		break;
 924	case ACTION_DELAYED_RETRY:
 925		/* Retry the same command after a delay */
 926		__scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, 0);
 927		break;
 928	}
 929}
 930
 931static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
 932			     gfp_t gfp_mask)
 933{
 934	int count;
 935
 936	/*
 937	 * If sg table allocation fails, requeue request later.
 938	 */
 939	if (unlikely(scsi_alloc_sgtable(sdb, req->nr_phys_segments,
 940					gfp_mask))) {
 941		return BLKPREP_DEFER;
 942	}
 943
 944	req->buffer = NULL;
 945
 946	/* 
 947	 * Next, walk the list, and fill in the addresses and sizes of
 948	 * each segment.
 949	 */
 950	count = blk_rq_map_sg(req->q, req, sdb->table.sgl);
 951	BUG_ON(count > sdb->table.nents);
 952	sdb->table.nents = count;
 953	sdb->length = blk_rq_bytes(req);
 954	return BLKPREP_OK;
 955}
 956
 957/*
 958 * Function:    scsi_init_io()
 959 *
 960 * Purpose:     SCSI I/O initialize function.
 961 *
 962 * Arguments:   cmd   - Command descriptor we wish to initialize
 963 *
 964 * Returns:     0 on success
 965 *		BLKPREP_DEFER if the failure is retryable
 966 *		BLKPREP_KILL if the failure is fatal
 967 */
 968int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
 969{
 970	int error = scsi_init_sgtable(cmd->request, &cmd->sdb, gfp_mask);
 971	if (error)
 972		goto err_exit;
 973
 974	if (blk_bidi_rq(cmd->request)) {
 975		struct scsi_data_buffer *bidi_sdb = kmem_cache_zalloc(
 976			scsi_sdb_cache, GFP_ATOMIC);
 977		if (!bidi_sdb) {
 978			error = BLKPREP_DEFER;
 979			goto err_exit;
 980		}
 981
 982		cmd->request->next_rq->special = bidi_sdb;
 983		error = scsi_init_sgtable(cmd->request->next_rq, bidi_sdb,
 984								    GFP_ATOMIC);
 985		if (error)
 986			goto err_exit;
 987	}
 988
 989	if (blk_integrity_rq(cmd->request)) {
 990		struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;
 991		int ivecs, count;
 992
 993		BUG_ON(prot_sdb == NULL);
 994		ivecs = blk_rq_count_integrity_sg(cmd->request);
 995
 996		if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask)) {
 997			error = BLKPREP_DEFER;
 998			goto err_exit;
 999		}
1000
1001		count = blk_rq_map_integrity_sg(cmd->request,
1002						prot_sdb->table.sgl);
1003		BUG_ON(unlikely(count > ivecs));
1004
1005		cmd->prot_sdb = prot_sdb;
1006		cmd->prot_sdb->table.nents = count;
1007	}
1008
1009	return BLKPREP_OK ;
1010
1011err_exit:
1012	scsi_release_buffers(cmd);
1013	if (error == BLKPREP_KILL)
1014		scsi_put_command(cmd);
1015	else /* BLKPREP_DEFER */
1016		scsi_unprep_request(cmd->request);
1017
1018	return error;
1019}
1020EXPORT_SYMBOL(scsi_init_io);
1021
1022static struct scsi_cmnd *scsi_get_cmd_from_req(struct scsi_device *sdev,
1023		struct request *req)
1024{
1025	struct scsi_cmnd *cmd;
1026
1027	if (!req->special) {
1028		cmd = scsi_get_command(sdev, GFP_ATOMIC);
1029		if (unlikely(!cmd))
1030			return NULL;
1031		req->special = cmd;
1032	} else {
1033		cmd = req->special;
1034	}
1035
1036	/* pull a tag out of the request if we have one */
1037	cmd->tag = req->tag;
1038	cmd->request = req;
1039
1040	cmd->cmnd = req->cmd;
1041
1042	return cmd;
1043}
1044
1045int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
1046{
1047	struct scsi_cmnd *cmd;
1048	int ret = scsi_prep_state_check(sdev, req);
1049
1050	if (ret != BLKPREP_OK)
1051		return ret;
1052
1053	cmd = scsi_get_cmd_from_req(sdev, req);
1054	if (unlikely(!cmd))
1055		return BLKPREP_DEFER;
1056
1057	/*
1058	 * BLOCK_PC requests may transfer data, in which case they must
1059	 * a bio attached to them.  Or they might contain a SCSI command
1060	 * that does not transfer data, in which case they may optionally
1061	 * submit a request without an attached bio.
1062	 */
1063	if (req->bio) {
1064		int ret;
1065
1066		BUG_ON(!req->nr_phys_segments);
1067
1068		ret = scsi_init_io(cmd, GFP_ATOMIC);
1069		if (unlikely(ret))
1070			return ret;
1071	} else {
1072		BUG_ON(blk_rq_bytes(req));
1073
1074		memset(&cmd->sdb, 0, sizeof(cmd->sdb));
1075		req->buffer = NULL;
1076	}
1077
1078	cmd->cmd_len = req->cmd_len;
1079	if (!blk_rq_bytes(req))
1080		cmd->sc_data_direction = DMA_NONE;
1081	else if (rq_data_dir(req) == WRITE)
1082		cmd->sc_data_direction = DMA_TO_DEVICE;
1083	else
1084		cmd->sc_data_direction = DMA_FROM_DEVICE;
1085	
1086	cmd->transfersize = blk_rq_bytes(req);
1087	cmd->allowed = req->retries;
1088	return BLKPREP_OK;
1089}
1090EXPORT_SYMBOL(scsi_setup_blk_pc_cmnd);
1091
1092/*
1093 * Setup a REQ_TYPE_FS command.  These are simple read/write request
1094 * from filesystems that still need to be translated to SCSI CDBs from
1095 * the ULD.
1096 */
1097int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req)
1098{
1099	struct scsi_cmnd *cmd;
1100	int ret = scsi_prep_state_check(sdev, req);
1101
1102	if (ret != BLKPREP_OK)
1103		return ret;
1104
1105	if (unlikely(sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh
1106			 && sdev->scsi_dh_data->scsi_dh->prep_fn)) {
1107		ret = sdev->scsi_dh_data->scsi_dh->prep_fn(sdev, req);
1108		if (ret != BLKPREP_OK)
1109			return ret;
1110	}
1111
1112	/*
1113	 * Filesystem requests must transfer data.
1114	 */
1115	BUG_ON(!req->nr_phys_segments);
1116
1117	cmd = scsi_get_cmd_from_req(sdev, req);
1118	if (unlikely(!cmd))
1119		return BLKPREP_DEFER;
1120
1121	memset(cmd->cmnd, 0, BLK_MAX_CDB);
1122	return scsi_init_io(cmd, GFP_ATOMIC);
1123}
1124EXPORT_SYMBOL(scsi_setup_fs_cmnd);
1125
1126int scsi_prep_state_check(struct scsi_device *sdev, struct request *req)
1127{
1128	int ret = BLKPREP_OK;
1129
1130	/*
1131	 * If the device is not in running state we will reject some
1132	 * or all commands.
1133	 */
1134	if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {
1135		switch (sdev->sdev_state) {
1136		case SDEV_OFFLINE:
1137			/*
1138			 * If the device is offline we refuse to process any
1139			 * commands.  The device must be brought online
1140			 * before trying any recovery commands.
1141			 */
1142			sdev_printk(KERN_ERR, sdev,
1143				    "rejecting I/O to offline device\n");
1144			ret = BLKPREP_KILL;
1145			break;
1146		case SDEV_DEL:
1147			/*
1148			 * If the device is fully deleted, we refuse to
1149			 * process any commands as well.
1150			 */
1151			sdev_printk(KERN_ERR, sdev,
1152				    "rejecting I/O to dead device\n");
1153			ret = BLKPREP_KILL;
1154			break;
1155		case SDEV_QUIESCE:
1156		case SDEV_BLOCK:
1157		case SDEV_CREATED_BLOCK:
1158			/*
1159			 * If the devices is blocked we defer normal commands.
1160			 */
1161			if (!(req->cmd_flags & REQ_PREEMPT))
1162				ret = BLKPREP_DEFER;
1163			break;
1164		default:
1165			/*
1166			 * For any other not fully online state we only allow
1167			 * special commands.  In particular any user initiated
1168			 * command is not allowed.
1169			 */
1170			if (!(req->cmd_flags & REQ_PREEMPT))
1171				ret = BLKPREP_KILL;
1172			break;
1173		}
1174	}
1175	return ret;
1176}
1177EXPORT_SYMBOL(scsi_prep_state_check);
1178
1179int scsi_prep_return(struct request_queue *q, struct request *req, int ret)
1180{
1181	struct scsi_device *sdev = q->queuedata;
1182
1183	switch (ret) {
1184	case BLKPREP_KILL:
1185		req->errors = DID_NO_CONNECT << 16;
1186		/* release the command and kill it */
1187		if (req->special) {
1188			struct scsi_cmnd *cmd = req->special;
1189			scsi_release_buffers(cmd);
1190			scsi_put_command(cmd);
1191			req->special = NULL;
1192		}
1193		break;
1194	case BLKPREP_DEFER:
1195		/*
1196		 * If we defer, the blk_peek_request() returns NULL, but the
1197		 * queue must be restarted, so we plug here if no returning
1198		 * command will automatically do that.
1199		 */
1200		if (sdev->device_busy == 0)
1201			blk_plug_device(q);
1202		break;
1203	default:
1204		req->cmd_flags |= REQ_DONTPREP;
1205	}
1206
1207	return ret;
1208}
1209EXPORT_SYMBOL(scsi_prep_return);
1210
1211int scsi_prep_fn(struct request_queue *q, struct request *req)
1212{
1213	struct scsi_device *sdev = q->queuedata;
1214	int ret = BLKPREP_KILL;
1215
1216	if (req->cmd_type == REQ_TYPE_BLOCK_PC)
1217		ret = scsi_setup_blk_pc_cmnd(sdev, req);
1218	return scsi_prep_return(q, req, ret);
1219}
1220EXPORT_SYMBOL(scsi_prep_fn);
1221
1222/*
1223 * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else
1224 * return 0.
1225 *
1226 * Called with the queue_lock held.
1227 */
1228static inline int scsi_dev_queue_ready(struct request_queue *q,
1229				  struct scsi_device *sdev)
1230{
1231	if (sdev->device_busy == 0 && sdev->device_blocked) {
1232		/*
1233		 * unblock after device_blocked iterates to zero
1234		 */
1235		if (--sdev->device_blocked == 0) {
1236			SCSI_LOG_MLQUEUE(3,
1237				   sdev_printk(KERN_INFO, sdev,
1238				   "unblocking device at zero depth\n"));
1239		} else {
1240			blk_plug_device(q);
1241			return 0;
1242		}
1243	}
1244	if (scsi_device_is_busy(sdev))
1245		return 0;
1246
1247	return 1;
1248}
1249
1250
1251/*
1252 * scsi_target_queue_ready: checks if there we can send commands to target
1253 * @sdev: scsi device on starget to check.
1254 *
1255 * Called with the host lock held.
1256 */
1257static inline int scsi_target_queue_ready(struct Scsi_Host *shost,
1258					   struct scsi_device *sdev)
1259{
1260	struct scsi_target *starget = scsi_target(sdev);
1261
1262	if (starget->single_lun) {
1263		if (starget->starget_sdev_user &&
1264		    starget->starget_sdev_user != sdev)
1265			return 0;
1266		starget->starget_sdev_user = sdev;
1267	}
1268
1269	if (starget->target_busy == 0 && starget->target_blocked) {
1270		/*
1271		 * unblock after target_blocked iterates to zero
1272		 */
1273		if (--starget->target_blocked == 0) {
1274			SCSI_LOG_MLQUEUE(3, starget_printk(KERN_INFO, starget,
1275					 "unblocking target at zero depth\n"));
1276		} else
1277			return 0;
1278	}
1279
1280	if (scsi_target_is_busy(starget)) {
1281		if (list_empty(&sdev->starved_entry)) {
1282			list_add_tail(&sdev->starved_entry,
1283				      &shost->starved_list);
1284			return 0;
1285		}
1286	}
1287
1288	/* We're OK to process the command, so we can't be starved */
1289	if (!list_empty(&sdev->starved_entry))
1290		list_del_init(&sdev->starved_entry);
1291	return 1;
1292}
1293
1294/*
1295 * scsi_host_queue_ready: if we can send requests to shost, return 1 else
1296 * return 0. We must end up running the queue again whenever 0 is
1297 * returned, else IO can hang.
1298 *
1299 * Called with host_lock held.
1300 */
1301static inline int scsi_host_queue_ready(struct request_queue *q,
1302				   struct Scsi_Host *shost,
1303				   struct scsi_device *sdev)
1304{
1305	if (scsi_host_in_recovery(shost))
1306		return 0;
1307	if (shost->host_busy == 0 && shost->host_blocked) {
1308		/*
1309		 * unblock after host_blocked iterates to zero
1310		 */
1311		if (--shost->host_blocked == 0) {
1312			SCSI_LOG_MLQUEUE(3,
1313				printk("scsi%d unblocking host at zero depth\n",
1314					shost->host_no));
1315		} else {
1316			return 0;
1317		}
1318	}
1319	if (scsi_host_is_busy(shost)) {
1320		if (list_empty(&sdev->starved_entry))
1321			list_add_tail(&sdev->starved_entry, &shost->starved_list);
1322		return 0;
1323	}
1324
1325	/* We're OK to process the command, so we can't be starved */
1326	if (!list_empty(&sdev->starved_entry))
1327		list_del_init(&sdev->starved_entry);
1328
1329	return 1;
1330}
1331
1332/*
1333 * Busy state exporting function for request stacking drivers.
1334 *
1335 * For efficiency, no lock is taken to check the busy state of
1336 * shost/starget/sdev, since the returned value is not guaranteed and
1337 * may be changed after request stacking drivers call the function,
1338 * regardless of taking lock or not.
1339 *
1340 * When scsi can't dispatch I/Os anymore and needs to kill I/Os
1341 * (e.g. !sdev), scsi needs to return 'not busy'.
1342 * Otherwise, request stacking drivers may hold requests forever.
1343 */
1344static int scsi_lld_busy(struct request_queue *q)
1345{
1346	struct scsi_device *sdev = q->queuedata;
1347	struct Scsi_Host *shost;
1348	struct scsi_target *starget;
1349
1350	if (!sdev)
1351		return 0;
1352
1353	shost = sdev->host;
1354	starget = scsi_target(sdev);
1355
1356	if (scsi_host_in_recovery(shost) || scsi_host_is_busy(shost) ||
1357	    scsi_target_is_busy(starget) || scsi_device_is_busy(sdev))
1358		return 1;
1359
1360	return 0;
1361}
1362
1363/*
1364 * Kill a request for a dead device
1365 */
1366static void scsi_kill_request(struct request *req, struct request_queue *q)
1367{
1368	struct scsi_cmnd *cmd = req->special;
1369	struct scsi_device *sdev;
1370	struct scsi_target *starget;
1371	struct Scsi_Host *shost;
1372
1373	blk_start_request(req);
1374
1375	if (unlikely(cmd == NULL)) {
1376		printk(KERN_CRIT "impossible request in %s.\n",
1377				 __func__);
1378		BUG();
1379	}
1380
1381	sdev = cmd->device;
1382	starget = scsi_target(sdev);
1383	shost = sdev->host;
1384	scsi_init_cmd_errh(cmd);
1385	cmd->result = DID_NO_CONNECT << 16;
1386	atomic_inc(&cmd->device->iorequest_cnt);
1387
1388	/*
1389	 * SCSI request completion path will do scsi_device_unbusy(),
1390	 * bump busy counts.  To bump the counters, we need to dance
1391	 * with the locks as normal issue path does.
1392	 */
1393	sdev->device_busy++;
1394	spin_unlock(sdev->request_queue->queue_lock);
1395	spin_lock(shost->host_lock);
1396	shost->host_busy++;
1397	starget->target_busy++;
1398	spin_unlock(shost->host_lock);
1399	spin_lock(sdev->request_queue->queue_lock);
1400
1401	blk_complete_request(req);
1402}
1403
1404static void scsi_softirq_done(struct request *rq)
1405{
1406	struct scsi_cmnd *cmd = rq->special;
1407	unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;
1408	int disposition;
1409
1410	INIT_LIST_HEAD(&cmd->eh_entry);
1411
1412	/*
1413	 * Set the serial numbers back to zero
1414	 */
1415	cmd->serial_number = 0;
1416
1417	atomic_inc(&cmd->device->iodone_cnt);
1418	if (cmd->result)
1419		atomic_inc(&cmd->device->ioerr_cnt);
1420
1421	disposition = scsi_decide_disposition(cmd);
1422	if (disposition != SUCCESS &&
1423	    time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
1424		sdev_printk(KERN_ERR, cmd->device,
1425			    "timing out command, waited %lus\n",
1426			    wait_for/HZ);
1427		disposition = SUCCESS;
1428	}
1429			
1430	scsi_log_completion(cmd, disposition);
1431
1432	switch (disposition) {
1433		case SUCCESS:
1434			scsi_finish_command(cmd);
1435			break;
1436		case NEEDS_RETRY:
1437			scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
1438			break;
1439		case ADD_TO_MLQUEUE:
1440			scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
1441			break;
1442		default:
1443			if (!scsi_eh_scmd_add(cmd, 0))
1444				scsi_finish_command(cmd);
1445	}
1446}
1447
1448/*
1449 * Function:    scsi_request_fn()
1450 *
1451 * Purpose:     Main strategy routine for SCSI.
1452 *
1453 * Arguments:   q       - Pointer to actual queue.
1454 *
1455 * Returns:     Nothing
1456 *
1457 * Lock status: IO request lock assumed to be held when called.
1458 */
1459static void scsi_request_fn(struct request_queue *q)
1460{
1461	struct scsi_device *sdev = q->queuedata;
1462	struct Scsi_Host *shost;
1463	struct scsi_cmnd *cmd;
1464	struct request *req;
1465
1466	if (!sdev) {
1467		printk("scsi: killing requests for dead queue\n");
1468		while ((req = blk_peek_request(q)) != NULL)
1469			scsi_kill_request(req, q);
1470		return;
1471	}
1472
1473	if(!get_device(&sdev->sdev_gendev))
1474		/* We must be tearing the block queue down already */
1475		return;
1476
1477	/*
1478	 * To start with, we keep looping until the queue is empty, or until
1479	 * the host is no longer able to accept any more requests.
1480	 */
1481	shost = sdev->host;
1482	while (!blk_queue_plugged(q)) {
1483		int rtn;
1484		/*
1485		 * get next queueable request.  We do this early to make sure
1486		 * that the request is fully prepared even if we cannot 
1487		 * accept it.
1488		 */
1489		req = blk_peek_request(q);
1490		if (!req || !scsi_dev_queue_ready(q, sdev))
1491			break;
1492
1493		if (unlikely(!scsi_device_online(sdev))) {
1494			sdev_printk(KERN_ERR, sdev,
1495				    "rejecting I/O to offline device\n");
1496			scsi_kill_request(req, q);
1497			continue;
1498		}
1499
1500
1501		/*
1502		 * Remove the request from the request list.
1503		 */
1504		if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))
1505			blk_start_request(req);
1506		sdev->device_busy++;
1507
1508		spin_unlock(q->queue_lock);
1509		cmd = req->special;
1510		if (unlikely(cmd == NULL)) {
1511			printk(KERN_CRIT "impossible request in %s.\n"
1512					 "please mail a stack trace to "
1513					 "linux-scsi@vger.kernel.org\n",
1514					 __func__);
1515			blk_dump_rq_flags(req, "foo");
1516			BUG();
1517		}
1518		spin_lock(shost->host_lock);
1519
1520		/*
1521		 * We hit this when the driver is using a host wide
1522		 * tag map. For device level tag maps the queue_depth check
1523		 * in the device ready fn would prevent us from trying
1524		 * to allocate a tag. Since the map is a shared host resource
1525		 * we add the dev to the starved list so it eventually gets
1526		 * a run when a tag is freed.
1527		 */
1528		if (blk_queue_tagged(q) && !blk_rq_tagged(req)) {
1529			if (list_empty(&sdev->starved_entry))
1530				list_add_tail(&sdev->starved_entry,
1531					      &shost->starved_list);
1532			goto not_ready;
1533		}
1534
1535		if (!scsi_target_queue_ready(shost, sdev))
1536			goto not_ready;
1537
1538		if (!scsi_host_queue_ready(q, shost, sdev))
1539			goto not_ready;
1540
1541		scsi_target(sdev)->target_busy++;
1542		shost->host_busy++;
1543
1544		/*
1545		 * XXX(hch): This is rather suboptimal, scsi_dispatch_cmd will
1546		 *		take the lock again.
1547		 */
1548		spin_unlock_irq(shost->host_lock);
1549
1550		/*
1551		 * Finally, initialize any error handling parameters, and set up
1552		 * the timers for timeouts.
1553		 */
1554		scsi_init_cmd_errh(cmd);
1555
1556		/*
1557		 * Dispatch the command to the low-level driver.
1558		 */
1559		rtn = scsi_dispatch_cmd(cmd);
1560		spin_lock_irq(q->queue_lock);
1561		if(rtn) {
1562			/* we're refusing the command; because of
1563			 * the way locks get dropped, we need to 
1564			 * check here if plugging is required */
1565			if(sdev->device_busy == 0)
1566				blk_plug_device(q);
1567
1568			break;
1569		}
1570	}
1571
1572	goto out;
1573
1574 not_ready:
1575	spin_unlock_irq(shost->host_lock);
1576
1577	/*
1578	 * lock q, handle tag, requeue req, and decrement device_busy. We
1579	 * must return with queue_lock held.
1580	 *
1581	 * Decrementing device_busy without checking it is OK, as all such
1582	 * cases (host limits or settings) should run the queue at some
1583	 * later time.
1584	 */
1585	spin_lock_irq(q->queue_lock);
1586	blk_requeue_request(q, req);
1587	sdev->device_busy--;
1588	if(sdev->device_busy == 0)
1589		blk_plug_device(q);
1590 out:
1591	/* must be careful here...if we trigger the ->remove() function
1592	 * we cannot be holding the q lock */
1593	spin_unlock_irq(q->queue_lock);
1594	put_device(&sdev->sdev_gendev);
1595	spin_lock_irq(q->queue_lock);
1596}
1597
1598u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost)
1599{
1600	struct device *host_dev;
1601	u64 bounce_limit = 0xffffffff;
1602
1603	if (shost->unchecked_isa_dma)
1604		return BLK_BOUNCE_ISA;
1605	/*
1606	 * Platforms with virtual-DMA translation
1607	 * hardware have no practical limit.
1608	 */
1609	if (!PCI_DMA_BUS_IS_PHYS)
1610		return BLK_BOUNCE_ANY;
1611
1612	host_dev = scsi_get_device(shost);
1613	if (host_dev && host_dev->dma_mask)
1614		bounce_limit = *host_dev->dma_mask;
1615
1616	return bounce_limit;
1617}
1618EXPORT_SYMBOL(scsi_calculate_bounce_limit);
1619
1620struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
1621					 request_fn_proc *request_fn)
1622{
1623	struct request_queue *q;
1624	struct device *dev = shost->shost_gendev.parent;
1625
1626	q = blk_init_queue(request_fn, NULL);
1627	if (!q)
1628		return NULL;
1629
1630	/*
1631	 * this limit is imposed by hardware restrictions
1632	 */
1633	blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
1634					SCSI_MAX_SG_CHAIN_SEGMENTS));
1635
1636	blk_queue_max_hw_sectors(q, shost->max_sectors);
1637	blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
1638	blk_queue_segment_boundary(q, shost->dma_boundary);
1639	dma_set_seg_boundary(dev, shost->dma_boundary);
1640
1641	blk_queue_max_segment_size(q, dma_get_max_seg_size(dev));
1642
1643	/* New queue, no concurrency on queue_flags */
1644	if (!shost->use_clustering)
1645		queue_flag_clear_unlocked(QUEUE_FLAG_CLUSTER, q);
1646
1647	/*
1648	 * set a reasonable default alignment on word boundaries: the
1649	 * host and device may alter it using
1650	 * blk_queue_update_dma_alignment() later.
1651	 */
1652	blk_queue_dma_alignment(q, 0x03);
1653
1654	return q;
1655}
1656EXPORT_SYMBOL(__scsi_alloc_queue);
1657
1658struct request_queue *scsi_alloc_queue(struct scsi_device *sdev)
1659{
1660	struct request_queue *q;
1661
1662	q = __scsi_alloc_queue(sdev->host, scsi_request_fn);
1663	if (!q)
1664		return NULL;
1665
1666	blk_queue_prep_rq(q, scsi_prep_fn);
1667	blk_queue_softirq_done(q, scsi_softirq_done);
1668	blk_queue_rq_timed_out(q, scsi_times_out);
1669	blk_queue_lld_busy(q, scsi_lld_busy);
1670	return q;
1671}
1672
1673void scsi_free_queue(struct request_queue *q)
1674{
1675	blk_cleanup_queue(q);
1676}
1677
1678/*
1679 * Function:    scsi_block_requests()
1680 *
1681 * Purpose:     Utility function used by low-level drivers to prevent further
1682 *		commands from being queued to the device.
1683 *
1684 * Arguments:   shost       - Host in question
1685 *
1686 * Returns:     Nothing
1687 *
1688 * Lock status: No locks are assumed held.
1689 *
1690 * Notes:       There is no timer nor any other means by which the requests
1691 *		get unblocked other than the low-level driver calling
1692 *		scsi_unblock_requests().
1693 */
1694void scsi_block_requests(struct Scsi_Host *shost)
1695{
1696	shost->host_self_blocked = 1;
1697}
1698EXPORT_SYMBOL(scsi_block_requests);
1699
1700/*
1701 * Function:    scsi_unblock_requests()
1702 *
1703 * Purpose:     Utility function used by low-level drivers to allow further
1704 *		commands from being queued to the device.
1705 *
1706 * Arguments:   shost       - Host in question
1707 *
1708 * Returns:     Nothing
1709 *
1710 * Lock status: No locks are assumed held.
1711 *
1712 * Notes:       There is no timer nor any other means by which the requests
1713 *		get unblocked other than the low-level driver calling
1714 *		scsi_unblock_requests().
1715 *
1716 *		This is done as an API function so that changes to the
1717 *		internals of the scsi mid-layer won't require wholesale
1718 *		changes to drivers that use this feature.
1719 */
1720void scsi_unblock_requests(struct Scsi_Host *shost)
1721{
1722	shost->host_self_blocked = 0;
1723	scsi_run_host_queues(shost);
1724}
1725EXPORT_SYMBOL(scsi_unblock_requests);
1726
1727int __init scsi_init_queue(void)
1728{
1729	int i;
1730
1731	scsi_sdb_cache = kmem_cache_create("scsi_data_buffer",
1732					   sizeof(struct scsi_data_buffer),
1733					   0, 0, NULL);
1734	if (!scsi_sdb_cache) {
1735		printk(KERN_ERR "SCSI: can't init scsi sdb cache\n");
1736		return -ENOMEM;
1737	}
1738
1739	for (i = 0; i < SG_MEMPOOL_NR; i++) {
1740		struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
1741		int size = sgp->size * sizeof(struct scatterlist);
1742
1743		sgp->slab = kmem_cache_create(sgp->name, size, 0,
1744				SLAB_HWCACHE_ALIGN, NULL);
1745		if (!sgp->slab) {
1746			printk(KERN_ERR "SCSI: can't init sg slab %s\n",
1747					sgp->name);
1748			goto cleanup_sdb;
1749		}
1750
1751		sgp->pool = mempool_create_slab_pool(SG_MEMPOOL_SIZE,
1752						     sgp->slab);
1753		if (!sgp->pool) {
1754			printk(KERN_ERR "SCSI: can't init sg mempool %s\n",
1755					sgp->name);
1756			goto cleanup_sdb;
1757		}
1758	}
1759
1760	return 0;
1761
1762cleanup_sdb:
1763	for (i = 0; i < SG_MEMPOOL_NR; i++) {
1764		struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
1765		if (sgp->pool)
1766			mempool_destroy(sgp->pool);
1767		if (sgp->slab)
1768			kmem_cache_destroy(sgp->slab);
1769	}
1770	kmem_cache_destroy(scsi_sdb_cache);
1771
1772	return -ENOMEM;
1773}
1774
1775void scsi_exit_queue(void)
1776{
1777	int i;
1778
1779	kmem_cache_destroy(scsi_sdb_cache);
1780
1781	for (i = 0; i < SG_MEMPOOL_NR; i++) {
1782		struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
1783		mempool_destroy(sgp->pool);
1784		kmem_cache_destroy(sgp->slab);
1785	}
1786}
1787
1788/**
1789 *	scsi_mode_select - issue a mode select
1790 *	@sdev:	SCSI device to be queried
1791 *	@pf:	Page format bit (1 == standard, 0 == vendor specific)
1792 *	@sp:	Save page bit (0 == don't save, 1 == save)
1793 *	@modepage: mode page being requested
1794 *	@buffer: request buffer (may not be smaller than eight bytes)
1795 *	@len:	length of request buffer.
1796 *	@timeout: command timeout
1797 *	@retries: number of retries before failing
1798 *	@data: returns a structure abstracting the mode header data
1799 *	@sshdr: place to put sense data (or NULL if no sense to be collected).
1800 *		must be SCSI_SENSE_BUFFERSIZE big.
1801 *
1802 *	Returns zero if successful; negative error number or scsi
1803 *	status on error
1804 *
1805 */
1806int
1807scsi_mode_select(struct scsi_device *sdev, int pf, int sp, int modepage,
1808		 unsigned char *buffer, int len, int timeout, int retries,
1809		 struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
1810{
1811	unsigned char cmd[10];
1812	unsigned char *real_buffer;
1813	int ret;
1814
1815	memset(cmd, 0, sizeof(cmd));
1816	cmd[1] = (pf ? 0x10 : 0) | (sp ? 0x01 : 0);
1817
1818	if (sdev->use_10_for_ms) {
1819		if (len > 65535)
1820			return -EINVAL;
1821		real_buffer = kmalloc(8 + len, GFP_KERNEL);
1822		if (!real_buffer)
1823			return -ENOMEM;
1824		memcpy(real_buffer + 8, buffer, len);
1825		len += 8;
1826		real_buffer[0] = 0;
1827		real_buffer[1] = 0;
1828		real_buffer[2] = data->medium_type;
1829		real_buffer[3] = data->device_specific;
1830		real_buffer[4] = data->longlba ? 0x01 : 0;
1831		real_buffer[5] = 0;
1832		real_buffer[6] = data->block_descriptor_length >> 8;
1833		real_buffer[7] = data->block_descriptor_length;
1834
1835		cmd[0] = MODE_SELECT_10;
1836		cmd[7] = len >> 8;
1837		cmd[8] = len;
1838	} else {
1839		if (len > 255 || data->block_descriptor_length > 255 ||
1840		    data->longlba)
1841			return -EINVAL;
1842
1843		real_buffer = kmalloc(4 + len, GFP_KERNEL);
1844		if (!real_buffer)
1845			return -ENOMEM;
1846		memcpy(real_buffer + 4, buffer, len);
1847		len += 4;
1848		real_buffer[0] = 0;
1849		real_buffer[1] = data->medium_type;
1850		real_buffer[2] = data->device_specific;
1851		real_buffer[3] = data->block_descriptor_length;
1852		
1853
1854		cmd[0] = MODE_SELECT;
1855		cmd[4] = len;
1856	}
1857
1858	ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len,
1859			       sshdr, timeout, retries, NULL);
1860	kfree(real_buffer);
1861	return ret;
1862}
1863EXPORT_SYMBOL_GPL(scsi_mode_select);
1864
1865/**
1866 *	scsi_mode_sense - issue a mode sense, falling back from 10 to six bytes if necessary.
1867 *	@sdev:	SCSI device to be queried
1868 *	@dbd:	set if mode sense will allow block descriptors to be returned
1869 *	@modepage: mode page being requested
1870 *	@buffer: request buffer (may not be smaller than eight bytes)
1871 *	@len:	length of request buffer.
1872 *	@timeout: command timeout
1873 *	@retries: number of retries before failing
1874 *	@data: returns a structure abstracting the mode header data
1875 *	@sshdr: place to put sense data (or NULL if no sense to be collected).
1876 *		must be SCSI_SENSE_BUFFERSIZE big.
1877 *
1878 *	Returns zero if unsuccessful, or the header offset (either 4
1879 *	or 8 depending on whether a six or ten byte command was
1880 *	issued) if successful.
1881 */
1882int
1883scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
1884		  unsigned char *buffer, int len, int timeout, int retries,
1885		  struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
1886{
1887	unsigned char cmd[12];
1888	int use_10_for_ms;
1889	int header_length;
1890	int result;
1891	struct scsi_sense_hdr my_sshdr;
1892
1893	memset(da

Large files files are truncated, but you can click here to view the full file