scsi_lib.c 68.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10
/*
 *  scsi_lib.c Copyright (C) 1999 Eric Youngdale
 *
 *  SCSI queueing library.
 *      Initial versions: Eric Youngdale (eric@andante.org).
 *                        Based upon conversations with large numbers
 *                        of people at Linux Expo.
 */

#include <linux/bio.h>
J
James Bottomley 已提交
11
#include <linux/bitops.h>
L
Linus Torvalds 已提交
12 13 14
#include <linux/blkdev.h>
#include <linux/completion.h>
#include <linux/kernel.h>
15
#include <linux/export.h>
L
Linus Torvalds 已提交
16 17 18 19 20
#include <linux/mempool.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/delay.h>
21
#include <linux/hardirq.h>
J
Jens Axboe 已提交
22
#include <linux/scatterlist.h>
L
Linus Torvalds 已提交
23 24

#include <scsi/scsi.h>
25
#include <scsi/scsi_cmnd.h>
L
Linus Torvalds 已提交
26 27 28 29 30 31 32 33 34 35
#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_priv.h"
#include "scsi_logging.h"


36
#define SG_MEMPOOL_NR		ARRAY_SIZE(scsi_sg_pools)
37
#define SG_MEMPOOL_SIZE		2
L
Linus Torvalds 已提交
38 39 40

struct scsi_host_sg_pool {
	size_t		size;
41
	char		*name;
42
	struct kmem_cache	*slab;
L
Linus Torvalds 已提交
43 44 45
	mempool_t	*pool;
};

J
James Bottomley 已提交
46 47 48 49
#define SP(x) { x, "sgpool-" __stringify(x) }
#if (SCSI_MAX_SG_SEGMENTS < 32)
#error SCSI_MAX_SG_SEGMENTS is too small (must be 32 or greater)
#endif
A
Adrian Bunk 已提交
50
static struct scsi_host_sg_pool scsi_sg_pools[] = {
L
Linus Torvalds 已提交
51 52
	SP(8),
	SP(16),
F
FUJITA Tomonori 已提交
53
#if (SCSI_MAX_SG_SEGMENTS > 32)
J
James Bottomley 已提交
54
	SP(32),
F
FUJITA Tomonori 已提交
55
#if (SCSI_MAX_SG_SEGMENTS > 64)
J
James Bottomley 已提交
56 57
	SP(64),
#if (SCSI_MAX_SG_SEGMENTS > 128)
L
Linus Torvalds 已提交
58
	SP(128),
J
James Bottomley 已提交
59 60
#if (SCSI_MAX_SG_SEGMENTS > 256)
#error SCSI_MAX_SG_SEGMENTS is too large (256 MAX)
F
FUJITA Tomonori 已提交
61 62 63
#endif
#endif
#endif
J
James Bottomley 已提交
64 65
#endif
	SP(SCSI_MAX_SG_SEGMENTS)
66
};
L
Linus Torvalds 已提交
67 68
#undef SP

69
struct kmem_cache *scsi_sdb_cache;
70

J
Jens Axboe 已提交
71 72 73 74 75 76 77
/*
 * When to reinvoke queueing after a resource shortage. It's 3 msecs to
 * not change behaviour from the previous unplug mechanism, experimentation
 * may prove this needs changing.
 */
#define SCSI_QUEUE_DELAY	3

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
/*
 * Function:	scsi_unprep_request()
 *
 * Purpose:	Remove all preparation done for a request, including its
 *		associated scsi_cmnd, so that it can be requeued.
 *
 * Arguments:	req	- request to unprepare
 *
 * Lock status:	Assumed that no locks are held upon entry.
 *
 * Returns:	Nothing.
 */
static void scsi_unprep_request(struct request *req)
{
	struct scsi_cmnd *cmd = req->special;

94
	blk_unprep_request(req);
95
	req->special = NULL;
96 97

	scsi_put_command(cmd);
98
	put_device(&cmd->device->sdev_gendev);
99
}
100

101 102 103 104 105
/**
 * __scsi_queue_insert - private queue insertion
 * @cmd: The SCSI command being requeued
 * @reason:  The reason for the requeue
 * @unbusy: Whether the queue should be unbusied
L
Linus Torvalds 已提交
106
 *
107 108 109 110 111
 * This is a private queue insertion.  The public interface
 * scsi_queue_insert() always assumes the queue should be unbusied
 * because it's always called before the completion.  This function is
 * for a requeue after completion, which should only occur in this
 * file.
L
Linus Torvalds 已提交
112
 */
113
static void __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy)
L
Linus Torvalds 已提交
114 115 116
{
	struct Scsi_Host *host = cmd->device->host;
	struct scsi_device *device = cmd->device;
117
	struct scsi_target *starget = scsi_target(device);
118 119
	struct request_queue *q = device->request_queue;
	unsigned long flags;
L
Linus Torvalds 已提交
120 121 122 123 124

	SCSI_LOG_MLQUEUE(1,
		 printk("Inserting command %p into mlqueue\n", cmd));

	/*
125
	 * Set the appropriate busy bit for the device/host.
L
Linus Torvalds 已提交
126 127 128 129 130 131 132 133 134 135 136
	 *
	 * If the host/device isn't busy, assume that something actually
	 * completed, and that we should be able to queue a command now.
	 *
	 * Note that the prior mid-layer assumption that any host could
	 * always queue at least one command is now broken.  The mid-layer
	 * will implement a user specifiable stall (see
	 * scsi_host.max_host_blocked and scsi_device.max_device_blocked)
	 * if a command is requeued with no other commands outstanding
	 * either for the device or for the host.
	 */
137 138
	switch (reason) {
	case SCSI_MLQUEUE_HOST_BUSY:
L
Linus Torvalds 已提交
139
		host->host_blocked = host->max_host_blocked;
140 141
		break;
	case SCSI_MLQUEUE_DEVICE_BUSY:
142
	case SCSI_MLQUEUE_EH_RETRY:
L
Linus Torvalds 已提交
143
		device->device_blocked = device->max_device_blocked;
144 145 146 147 148
		break;
	case SCSI_MLQUEUE_TARGET_BUSY:
		starget->target_blocked = starget->max_target_blocked;
		break;
	}
L
Linus Torvalds 已提交
149 150 151 152 153

	/*
	 * Decrement the counters, since these commands are no longer
	 * active on the host/device.
	 */
154 155
	if (unbusy)
		scsi_device_unbusy(device);
L
Linus Torvalds 已提交
156 157

	/*
158
	 * Requeue this command.  It will go before all other commands
159 160 161
	 * that are already in the queue. Schedule requeue work under
	 * lock such that the kblockd_schedule_work() call happens
	 * before blk_cleanup_queue() finishes.
J
Jens Axboe 已提交
162
	 */
163
	spin_lock_irqsave(q->queue_lock, flags);
J
James Bottomley 已提交
164
	blk_requeue_request(q, cmd->request);
165
	kblockd_schedule_work(q, &device->requeue_work);
166
	spin_unlock_irqrestore(q->queue_lock, flags);
L
Linus Torvalds 已提交
167 168
}

169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
/*
 * Function:    scsi_queue_insert()
 *
 * Purpose:     Insert a command in the midlevel queue.
 *
 * Arguments:   cmd    - command that we are adding to queue.
 *              reason - why we are inserting command to queue.
 *
 * Lock status: Assumed that lock is not held upon entry.
 *
 * Returns:     Nothing.
 *
 * Notes:       We do this for one of two cases.  Either the host is busy
 *              and it cannot accept any more commands for the time being,
 *              or the device returned QUEUE_FULL and can accept no more
 *              commands.
 * Notes:       This could be called either from an interrupt context or a
 *              normal process context.
 */
188
void scsi_queue_insert(struct scsi_cmnd *cmd, int reason)
189
{
190
	__scsi_queue_insert(cmd, reason, 1);
191
}
192
/**
193
 * scsi_execute - insert request and wait for the result
194 195 196 197 198 199 200 201
 * @sdev:	scsi device
 * @cmd:	scsi command
 * @data_direction: data direction
 * @buffer:	data buffer
 * @bufflen:	len of buffer
 * @sense:	optional sense buffer
 * @timeout:	request timeout in seconds
 * @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
 */
208 209
int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
		 int data_direction, void *buffer, unsigned bufflen,
210 211
		 unsigned char *sense, int timeout, int retries, int flags,
		 int *resid)
212 213 214 215 216 217
{
	struct request *req;
	int write = (data_direction == DMA_TO_DEVICE);
	int ret = DRIVER_ERROR << 24;

	req = blk_get_request(sdev->request_queue, write, __GFP_WAIT);
218 219
	if (!req)
		return ret;
220 221 222 223 224 225 226 227 228

	if (bufflen &&	blk_rq_map_kern(sdev->request_queue, req,
					buffer, bufflen, __GFP_WAIT))
		goto out;

	req->cmd_len = COMMAND_SIZE(cmd[0]);
	memcpy(req->cmd, cmd, req->cmd_len);
	req->sense = sense;
	req->sense_len = 0;
229
	req->retries = retries;
230
	req->timeout = timeout;
231 232
	req->cmd_type = REQ_TYPE_BLOCK_PC;
	req->cmd_flags |= flags | REQ_QUIET | REQ_PREEMPT;
233 234 235 236 237 238

	/*
	 * head injection *required* here otherwise quiesce won't work
	 */
	blk_execute_rq(req->q, NULL, req, 1);

239 240 241 242 243 244
	/*
	 * Some devices (USB mass-storage in particular) may transfer
	 * garbage data together with a residue indicating that the data
	 * is invalid.  Prevent the garbage from being misinterpreted
	 * and prevent security leaks by zeroing out the excess data.
	 */
T
Tejun Heo 已提交
245 246
	if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen))
		memset(buffer + (bufflen - req->resid_len), 0, req->resid_len);
247

248
	if (resid)
T
Tejun Heo 已提交
249
		*resid = req->resid_len;
250 251 252 253 254 255
	ret = req->errors;
 out:
	blk_put_request(req);

	return ret;
}
256
EXPORT_SYMBOL(scsi_execute);
257

258
int scsi_execute_req_flags(struct scsi_device *sdev, const unsigned char *cmd,
259
		     int data_direction, void *buffer, unsigned bufflen,
260
		     struct scsi_sense_hdr *sshdr, int timeout, int retries,
261
		     int *resid, int flags)
262 263
{
	char *sense = NULL;
264 265
	int result;
	
266
	if (sshdr) {
J
Jes Sorensen 已提交
267
		sense = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
268 269 270
		if (!sense)
			return DRIVER_ERROR << 24;
	}
271
	result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen,
272
			      sense, timeout, retries, flags, resid);
273
	if (sshdr)
274
		scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, sshdr);
275 276 277 278

	kfree(sense);
	return result;
}
279
EXPORT_SYMBOL(scsi_execute_req_flags);
280

L
Linus Torvalds 已提交
281 282 283 284 285 286 287 288 289 290 291
/*
 * Function:    scsi_init_cmd_errh()
 *
 * Purpose:     Initialize cmd fields related to error handling.
 *
 * Arguments:   cmd	- command that is ready to be queued.
 *
 * Notes:       This function has the job of initializing a number of
 *              fields related to error handling.   Typically this will
 *              be called once for each command, as required.
 */
292
static void scsi_init_cmd_errh(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
293 294
{
	cmd->serial_number = 0;
B
Boaz Harrosh 已提交
295
	scsi_set_resid(cmd, 0);
296
	memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
297
	if (cmd->cmd_len == 0)
298
		cmd->cmd_len = scsi_command_size(cmd->cmnd);
L
Linus Torvalds 已提交
299 300 301 302 303
}

void scsi_device_unbusy(struct scsi_device *sdev)
{
	struct Scsi_Host *shost = sdev->host;
304
	struct scsi_target *starget = scsi_target(sdev);
L
Linus Torvalds 已提交
305 306 307 308
	unsigned long flags;

	spin_lock_irqsave(shost->host_lock, flags);
	shost->host_busy--;
309
	starget->target_busy--;
310
	if (unlikely(scsi_host_in_recovery(shost) &&
311
		     (shost->host_failed || shost->host_eh_scheduled)))
L
Linus Torvalds 已提交
312 313
		scsi_eh_wakeup(shost);
	spin_unlock(shost->host_lock);
已提交
314
	spin_lock(sdev->request_queue->queue_lock);
L
Linus Torvalds 已提交
315
	sdev->device_busy--;
已提交
316
	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
L
Linus Torvalds 已提交
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
}

/*
 * Called for single_lun devices on IO completion. Clear starget_sdev_user,
 * and call blk_run_queue for all the scsi_devices on the target -
 * including current_sdev first.
 *
 * Called with *no* scsi locks held.
 */
static void scsi_single_lun_run(struct scsi_device *current_sdev)
{
	struct Scsi_Host *shost = current_sdev->host;
	struct scsi_device *sdev, *tmp;
	struct scsi_target *starget = scsi_target(current_sdev);
	unsigned long flags;

	spin_lock_irqsave(shost->host_lock, flags);
	starget->starget_sdev_user = NULL;
	spin_unlock_irqrestore(shost->host_lock, flags);

	/*
	 * Call blk_run_queue for all LUNs on the target, starting with
	 * current_sdev. We race with others (to set starget_sdev_user),
	 * but in most cases, we will be first. Ideally, each LU on the
	 * target would get some limited time or requests on the target.
	 */
	blk_run_queue(current_sdev->request_queue);

	spin_lock_irqsave(shost->host_lock, flags);
	if (starget->starget_sdev_user)
		goto out;
	list_for_each_entry_safe(sdev, tmp, &starget->devices,
			same_target_siblings) {
		if (sdev == current_sdev)
			continue;
		if (scsi_device_get(sdev))
			continue;

		spin_unlock_irqrestore(shost->host_lock, flags);
		blk_run_queue(sdev->request_queue);
		spin_lock_irqsave(shost->host_lock, flags);
	
		scsi_device_put(sdev);
	}
 out:
	spin_unlock_irqrestore(shost->host_lock, flags);
}

365 366 367 368 369 370 371 372
static inline int scsi_device_is_busy(struct scsi_device *sdev)
{
	if (sdev->device_busy >= sdev->queue_depth || sdev->device_blocked)
		return 1;

	return 0;
}

373 374 375 376 377 378 379
static inline int scsi_target_is_busy(struct scsi_target *starget)
{
	return ((starget->can_queue > 0 &&
		 starget->target_busy >= starget->can_queue) ||
		 starget->target_blocked);
}

380 381 382 383 384 385 386 387 388
static inline int scsi_host_is_busy(struct Scsi_Host *shost)
{
	if ((shost->can_queue > 0 && shost->host_busy >= shost->can_queue) ||
	    shost->host_blocked || shost->host_self_blocked)
		return 1;

	return 0;
}

389
static void scsi_starved_list_run(struct Scsi_Host *shost)
L
Linus Torvalds 已提交
390
{
391
	LIST_HEAD(starved_list);
392
	struct scsi_device *sdev;
L
Linus Torvalds 已提交
393 394 395
	unsigned long flags;

	spin_lock_irqsave(shost->host_lock, flags);
396 397 398
	list_splice_init(&shost->starved_list, &starved_list);

	while (!list_empty(&starved_list)) {
399 400
		struct request_queue *slq;

L
Linus Torvalds 已提交
401 402 403 404 405 406 407 408 409 410
		/*
		 * As long as shost is accepting commands and we have
		 * starved queues, call blk_run_queue. scsi_request_fn
		 * drops the queue_lock and can add us back to the
		 * starved_list.
		 *
		 * host_lock protects the starved_list and starved_entry.
		 * scsi_request_fn must get the host_lock before checking
		 * or modifying starved_list or starved_entry.
		 */
411
		if (scsi_host_is_busy(shost))
412 413
			break;

414 415 416
		sdev = list_entry(starved_list.next,
				  struct scsi_device, starved_entry);
		list_del_init(&sdev->starved_entry);
417 418 419 420 421 422
		if (scsi_target_is_busy(scsi_target(sdev))) {
			list_move_tail(&sdev->starved_entry,
				       &shost->starved_list);
			continue;
		}

423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
		/*
		 * Once we drop the host lock, a racing scsi_remove_device()
		 * call may remove the sdev from the starved list and destroy
		 * it and the queue.  Mitigate by taking a reference to the
		 * queue and never touching the sdev again after we drop the
		 * host lock.  Note: if __scsi_remove_device() invokes
		 * blk_cleanup_queue() before the queue is run from this
		 * function then blk_run_queue() will return immediately since
		 * blk_cleanup_queue() marks the queue with QUEUE_FLAG_DYING.
		 */
		slq = sdev->request_queue;
		if (!blk_get_queue(slq))
			continue;
		spin_unlock_irqrestore(shost->host_lock, flags);

		blk_run_queue(slq);
		blk_put_queue(slq);

		spin_lock_irqsave(shost->host_lock, flags);
L
Linus Torvalds 已提交
442
	}
443 444
	/* put any unprocessed entries back */
	list_splice(&starved_list, &shost->starved_list);
L
Linus Torvalds 已提交
445
	spin_unlock_irqrestore(shost->host_lock, flags);
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
}

/*
 * Function:   scsi_run_queue()
 *
 * Purpose:    Select a proper request queue to serve next
 *
 * Arguments:  q       - last request's queue
 *
 * Returns:     Nothing
 *
 * Notes:      The previous command was completely finished, start
 *             a new one if possible.
 */
static void scsi_run_queue(struct request_queue *q)
{
	struct scsi_device *sdev = q->queuedata;

	if (scsi_target(sdev)->single_lun)
		scsi_single_lun_run(sdev);
	if (!list_empty(&sdev->host->starved_list))
		scsi_starved_list_run(sdev->host);
L
Linus Torvalds 已提交
468 469 470 471

	blk_run_queue(q);
}

472 473 474 475 476 477 478 479 480 481
void scsi_requeue_run_queue(struct work_struct *work)
{
	struct scsi_device *sdev;
	struct request_queue *q;

	sdev = container_of(work, struct scsi_device, requeue_work);
	q = sdev->request_queue;
	scsi_run_queue(q);
}

L
Linus Torvalds 已提交
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
/*
 * Function:	scsi_requeue_command()
 *
 * Purpose:	Handle post-processing of completed commands.
 *
 * Arguments:	q	- queue to operate on
 *		cmd	- command that may need to be requeued.
 *
 * Returns:	Nothing
 *
 * Notes:	After command completion, there may be blocks left
 *		over which weren't finished by the previous command
 *		this can be for a number of reasons - the main one is
 *		I/O errors in the middle of the request, in which case
 *		we need to request the blocks that come after the bad
 *		sector.
498
 * Notes:	Upon return, cmd is a stale pointer.
L
Linus Torvalds 已提交
499 500 501
 */
static void scsi_requeue_command(struct request_queue *q, struct scsi_cmnd *cmd)
{
502
	struct scsi_device *sdev = cmd->device;
503
	struct request *req = cmd->request;
504 505
	unsigned long flags;

506 507 508 509 510 511 512 513
	/*
	 * We need to hold a reference on the device to avoid the queue being
	 * killed after the unlock and before scsi_run_queue is invoked which
	 * may happen because scsi_unprep_request() puts the command which
	 * releases its reference on the device.
	 */
	get_device(&sdev->sdev_gendev);

514
	spin_lock_irqsave(q->queue_lock, flags);
515
	scsi_unprep_request(req);
516
	blk_requeue_request(q, req);
517
	spin_unlock_irqrestore(q->queue_lock, flags);
L
Linus Torvalds 已提交
518 519

	scsi_run_queue(q);
520 521

	put_device(&sdev->sdev_gendev);
L
Linus Torvalds 已提交
522 523 524 525
}

void scsi_next_command(struct scsi_cmnd *cmd)
{
526 527 528
	struct scsi_device *sdev = cmd->device;
	struct request_queue *q = sdev->request_queue;

L
Linus Torvalds 已提交
529 530
	scsi_put_command(cmd);
	scsi_run_queue(q);
531 532

	put_device(&sdev->sdev_gendev);
L
Linus Torvalds 已提交
533 534 535 536 537 538 539 540 541 542
}

void scsi_run_host_queues(struct Scsi_Host *shost)
{
	struct scsi_device *sdev;

	shost_for_each_device(sdev, shost)
		scsi_run_queue(sdev->request_queue);
}

543 544
static void __scsi_release_buffers(struct scsi_cmnd *, int);

L
Linus Torvalds 已提交
545 546 547 548 549 550 551
/*
 * Function:    scsi_end_request()
 *
 * Purpose:     Post-processing of completed commands (usually invoked at end
 *		of upper level post-processing and scsi_io_completion).
 *
 * Arguments:   cmd	 - command that is complete.
552
 *              error    - 0 if I/O indicates success, < 0 for I/O error.
L
Linus Torvalds 已提交
553 554 555 556 557
 *              bytes    - number of bytes of completed I/O
 *		requeue  - indicates whether we should requeue leftovers.
 *
 * Lock status: Assumed that lock is not held upon entry.
 *
558
 * Returns:     cmd if requeue required, NULL otherwise.
L
Linus Torvalds 已提交
559 560 561 562 563 564
 *
 * Notes:       This is called for block device requests in order to
 *              mark some number of sectors as complete.
 * 
 *		We are guaranteeing that the request queue will be goosed
 *		at some point during this call.
565
 * Notes:	If cmd was requeued, upon return it will be a stale pointer.
L
Linus Torvalds 已提交
566
 */
567
static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int error,
L
Linus Torvalds 已提交
568 569
					  int bytes, int requeue)
{
570
	struct request_queue *q = cmd->device->request_queue;
L
Linus Torvalds 已提交
571 572 573 574 575 576
	struct request *req = cmd->request;

	/*
	 * If there are blocks left over at the end, set up the command
	 * to queue the remainder of them.
	 */
577
	if (blk_end_request(req, error, bytes)) {
L
Linus Torvalds 已提交
578
		/* kill remainder if no retrys */
579
		if (error && scsi_noretry_cmd(cmd))
580
			blk_end_request_all(req, error);
L
Linus Torvalds 已提交
581
		else {
582
			if (requeue) {
L
Linus Torvalds 已提交
583 584 585 586 587
				/*
				 * Bleah.  Leftovers again.  Stick the
				 * leftovers in the front of the
				 * queue, and goose the queue again.
				 */
588
				scsi_release_buffers(cmd);
L
Linus Torvalds 已提交
589
				scsi_requeue_command(q, cmd);
590 591
				cmd = NULL;
			}
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599
			return cmd;
		}
	}

	/*
	 * This will goose the queue request function at the end, so we don't
	 * need to worry about launching another command.
	 */
600
	__scsi_release_buffers(cmd, 0);
L
Linus Torvalds 已提交
601 602 603 604
	scsi_next_command(cmd);
	return NULL;
}

605 606 607 608
static inline unsigned int scsi_sgtable_index(unsigned short nents)
{
	unsigned int index;

J
James Bottomley 已提交
609 610 611
	BUG_ON(nents > SCSI_MAX_SG_SEGMENTS);

	if (nents <= 8)
612
		index = 0;
J
James Bottomley 已提交
613 614
	else
		index = get_count_order(nents) - 3;
L
Linus Torvalds 已提交
615

616 617 618
	return index;
}

619
static void scsi_sg_free(struct scatterlist *sgl, unsigned int nents)
620 621 622
{
	struct scsi_host_sg_pool *sgp;

623 624 625
	sgp = scsi_sg_pools + scsi_sgtable_index(nents);
	mempool_free(sgl, sgp->pool);
}
626

627 628 629
static struct scatterlist *scsi_sg_alloc(unsigned int nents, gfp_t gfp_mask)
{
	struct scsi_host_sg_pool *sgp;
630

631 632 633
	sgp = scsi_sg_pools + scsi_sgtable_index(nents);
	return mempool_alloc(sgp->pool, gfp_mask);
}
634

B
Boaz Harrosh 已提交
635 636
static int scsi_alloc_sgtable(struct scsi_data_buffer *sdb, int nents,
			      gfp_t gfp_mask)
637 638
{
	int ret;
639

B
Boaz Harrosh 已提交
640
	BUG_ON(!nents);
641

B
Boaz Harrosh 已提交
642 643
	ret = __sg_alloc_table(&sdb->table, nents, SCSI_MAX_SG_SEGMENTS,
			       gfp_mask, scsi_sg_alloc);
644
	if (unlikely(ret))
B
Boaz Harrosh 已提交
645
		__sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS,
646
				scsi_sg_free);
J
Jens Axboe 已提交
647

648
	return ret;
L
Linus Torvalds 已提交
649 650
}

B
Boaz Harrosh 已提交
651
static void scsi_free_sgtable(struct scsi_data_buffer *sdb)
L
Linus Torvalds 已提交
652
{
B
Boaz Harrosh 已提交
653
	__sg_free_table(&sdb->table, SCSI_MAX_SG_SEGMENTS, scsi_sg_free);
L
Linus Torvalds 已提交
654 655
}

656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
static void __scsi_release_buffers(struct scsi_cmnd *cmd, int do_bidi_check)
{

	if (cmd->sdb.table.nents)
		scsi_free_sgtable(&cmd->sdb);

	memset(&cmd->sdb, 0, sizeof(cmd->sdb));

	if (do_bidi_check && scsi_bidi_cmnd(cmd)) {
		struct scsi_data_buffer *bidi_sdb =
			cmd->request->next_rq->special;
		scsi_free_sgtable(bidi_sdb);
		kmem_cache_free(scsi_sdb_cache, bidi_sdb);
		cmd->request->next_rq->special = NULL;
	}

	if (scsi_prot_sg_count(cmd))
		scsi_free_sgtable(cmd->prot_sdb);
}

L
Linus Torvalds 已提交
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
/*
 * Function:    scsi_release_buffers()
 *
 * Purpose:     Completion processing for block device I/O requests.
 *
 * Arguments:   cmd	- command that we are bailing.
 *
 * Lock status: Assumed that no lock is held upon entry.
 *
 * Returns:     Nothing
 *
 * Notes:       In the event that an upper level driver rejects a
 *		command, we must release resources allocated during
 *		the __init_io() function.  Primarily this would involve
 *		the scatter-gather table, and potentially any bounce
 *		buffers.
 */
693
void scsi_release_buffers(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
694
{
695
	__scsi_release_buffers(cmd, 1);
L
Linus Torvalds 已提交
696
}
697
EXPORT_SYMBOL(scsi_release_buffers);
L
Linus Torvalds 已提交
698

699 700 701 702 703 704 705 706 707 708
/**
 * __scsi_error_from_host_byte - translate SCSI error code into errno
 * @cmd:	SCSI command (unused)
 * @result:	scsi error code
 *
 * Translate SCSI error code into standard UNIX errno.
 * Return values:
 * -ENOLINK	temporary transport failure
 * -EREMOTEIO	permanent target failure, do not retry
 * -EBADE	permanent nexus failure, retry on other path
709
 * -ENOSPC	No write space available
710
 * -ENODATA	Medium error
711 712
 * -EIO		unspecified I/O error
 */
713 714 715 716 717 718 719 720 721
static int __scsi_error_from_host_byte(struct scsi_cmnd *cmd, int result)
{
	int error = 0;

	switch(host_byte(result)) {
	case DID_TRANSPORT_FAILFAST:
		error = -ENOLINK;
		break;
	case DID_TARGET_FAILURE:
722
		set_host_byte(cmd, DID_OK);
723 724 725
		error = -EREMOTEIO;
		break;
	case DID_NEXUS_FAILURE:
726
		set_host_byte(cmd, DID_OK);
727 728
		error = -EBADE;
		break;
729 730 731 732
	case DID_ALLOC_FAILURE:
		set_host_byte(cmd, DID_OK);
		error = -ENOSPC;
		break;
733 734 735 736
	case DID_MEDIUM_ERROR:
		set_host_byte(cmd, DID_OK);
		error = -ENODATA;
		break;
737 738 739 740 741 742 743 744
	default:
		error = -EIO;
		break;
	}

	return error;
}

L
Linus Torvalds 已提交
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
/*
 * Function:    scsi_io_completion()
 *
 * Purpose:     Completion processing for block device I/O requests.
 *
 * Arguments:   cmd   - command that is finished.
 *
 * Lock status: Assumed that no lock is held upon entry.
 *
 * Returns:     Nothing
 *
 * Notes:       This function is matched in terms of capabilities to
 *              the function that created the scatter-gather list.
 *              In other words, if there are no bounce buffers
 *              (the normal case for most drivers), we don't need
 *              the logic to deal with cleaning up afterwards.
 *
A
Alan Stern 已提交
762 763 764 765 766
 *		We must call scsi_end_request().  This will finish off
 *		the specified number of sectors.  If we are done, the
 *		command block will be released and the queue function
 *		will be goosed.  If we are not done then we have to
 *		figure out what to do next:
L
Linus Torvalds 已提交
767
 *
A
Alan Stern 已提交
768 769 770 771 772
 *		a) We can call scsi_requeue_command().  The request
 *		   will be unprepared and put back on the queue.  Then
 *		   a new command will be created for it.  This should
 *		   be used if we made forward progress, or if we want
 *		   to switch from READ(10) to READ(6) for example.
L
Linus Torvalds 已提交
773
 *
A
Alan Stern 已提交
774 775 776 777 778 779
 *		b) We can call scsi_queue_insert().  The request will
 *		   be put back on the queue and retried using the same
 *		   command as before, possibly after a delay.
 *
 *		c) We can call blk_end_request() with -EIO to fail
 *		   the remainder of the request.
L
Linus Torvalds 已提交
780
 */
781
void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
L
Linus Torvalds 已提交
782 783
{
	int result = cmd->result;
784
	struct request_queue *q = cmd->device->request_queue;
L
Linus Torvalds 已提交
785
	struct request *req = cmd->request;
786
	int error = 0;
L
Linus Torvalds 已提交
787 788 789
	struct scsi_sense_hdr sshdr;
	int sense_valid = 0;
	int sense_deferred = 0;
A
Alan Stern 已提交
790 791 792
	enum {ACTION_FAIL, ACTION_REPREP, ACTION_RETRY,
	      ACTION_DELAYED_RETRY} action;
	char *description = NULL;
793
	unsigned long wait_for = (cmd->allowed + 1) * req->timeout;
L
Linus Torvalds 已提交
794 795 796 797 798 799

	if (result) {
		sense_valid = scsi_command_normalize_sense(cmd, &sshdr);
		if (sense_valid)
			sense_deferred = scsi_sense_is_deferred(&sshdr);
	}
800

801
	if (req->cmd_type == REQ_TYPE_BLOCK_PC) { /* SG_IO ioctl from block level */
L
Linus Torvalds 已提交
802 803 804 805 806 807 808 809 810 811 812 813
		if (result) {
			if (sense_valid && req->sense) {
				/*
				 * SG_IO wants current and deferred errors
				 */
				int len = 8 + cmd->sense_buffer[7];

				if (len > SCSI_SENSE_BUFFERSIZE)
					len = SCSI_SENSE_BUFFERSIZE;
				memcpy(req->sense, cmd->sense_buffer,  len);
				req->sense_len = len;
			}
814
			if (!sense_deferred)
815
				error = __scsi_error_from_host_byte(cmd, result);
816
		}
817 818 819 820
		/*
		 * __scsi_error_from_host_byte may have reset the host_byte
		 */
		req->errors = cmd->result;
821 822 823

		req->resid_len = scsi_get_resid(cmd);

824
		if (scsi_bidi_cmnd(cmd)) {
825 826 827 828 829 830
			/*
			 * Bidi commands Must be complete as a whole,
			 * both sides at once.
			 */
			req->next_rq->resid_len = scsi_in(cmd)->resid;

831
			scsi_release_buffers(cmd);
832 833 834
			blk_end_request_all(req, 0);

			scsi_next_command(cmd);
835 836
			return;
		}
L
Linus Torvalds 已提交
837 838
	}

839 840
	/* no bidi support for !REQ_TYPE_BLOCK_PC yet */
	BUG_ON(blk_bidi_rq(req));
B
Boaz Harrosh 已提交
841

L
Linus Torvalds 已提交
842 843 844 845
	/*
	 * Next deal with any sectors which we were able to correctly
	 * handle.
	 */
846
	SCSI_LOG_HLCOMPLETE(1, printk("%u sectors total, "
847
				      "%d bytes done.\n",
848
				      blk_rq_sectors(req), good_bytes));
849

850 851 852 853 854 855
	/*
	 * Recovered errors need reporting, but they're always treated
	 * as success, so fiddle the result code here.  For BLOCK_PC
	 * we already took a copy of the original into rq->errors which
	 * is what gets returned to the user
	 */
856 857 858 859 860 861 862 863
	if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) {
		/* if ATA PASS-THROUGH INFORMATION AVAILABLE skip
		 * print since caller wants ATA registers. Only occurs on
		 * SCSI ATA PASS_THROUGH commands when CK_COND=1
		 */
		if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
			;
		else if (!(req->cmd_flags & REQ_QUIET))
864 865 866 867 868 869 870 871
			scsi_print_sense("", cmd);
		result = 0;
		/* BLOCK_PC may have set error */
		error = 0;
	}

	/*
	 * A number of bytes were successfully read.  If there
872 873 874
	 * are leftovers and there is some kind of error
	 * (result != 0), retry the rest.
	 */
875
	if (scsi_end_request(cmd, error, good_bytes, result == 0) == NULL)
876
		return;
877

878
	error = __scsi_error_from_host_byte(cmd, result);
879

A
Alan Stern 已提交
880 881 882 883 884 885 886
	if (host_byte(result) == DID_RESET) {
		/* Third party bus reset or reset for error recovery
		 * reasons.  Just retry the command and see what
		 * happens.
		 */
		action = ACTION_RETRY;
	} else if (sense_valid && !sense_deferred) {
L
Linus Torvalds 已提交
887 888 889
		switch (sshdr.sense_key) {
		case UNIT_ATTENTION:
			if (cmd->device->removable) {
890
				/* Detected disc change.  Set a bit
L
Linus Torvalds 已提交
891 892 893
				 * and quietly refuse further access.
				 */
				cmd->device->changed = 1;
A
Alan Stern 已提交
894 895
				description = "Media Changed";
				action = ACTION_FAIL;
L
Linus Torvalds 已提交
896
			} else {
897 898 899
				/* Must have been a power glitch, or a
				 * bus reset.  Could not have been a
				 * media change, so we just retry the
A
Alan Stern 已提交
900
				 * command and see what happens.
901
				 */
A
Alan Stern 已提交
902
				action = ACTION_RETRY;
L
Linus Torvalds 已提交
903 904 905
			}
			break;
		case ILLEGAL_REQUEST:
906 907 908 909 910 911 912 913
			/* If we had an ILLEGAL REQUEST returned, then
			 * we may have performed an unsupported
			 * command.  The only thing this should be
			 * would be a ten byte read where only a six
			 * byte read was supported.  Also, on a system
			 * where READ CAPACITY failed, we may have
			 * read past the end of the disk.
			 */
914 915
			if ((cmd->device->use_10_for_rw &&
			    sshdr.asc == 0x20 && sshdr.ascq == 0x00) &&
L
Linus Torvalds 已提交
916 917
			    (cmd->cmnd[0] == READ_10 ||
			     cmd->cmnd[0] == WRITE_10)) {
A
Alan Stern 已提交
918
				/* This will issue a new 6-byte command. */
L
Linus Torvalds 已提交
919
				cmd->device->use_10_for_rw = 0;
A
Alan Stern 已提交
920
				action = ACTION_REPREP;
921 922 923 924
			} else if (sshdr.asc == 0x10) /* DIX */ {
				description = "Host Data Integrity Failure";
				action = ACTION_FAIL;
				error = -EILSEQ;
925
			/* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942
			} else if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
				switch (cmd->cmnd[0]) {
				case UNMAP:
					description = "Discard failure";
					break;
				case WRITE_SAME:
				case WRITE_SAME_16:
					if (cmd->cmnd[1] & 0x8)
						description = "Discard failure";
					else
						description =
							"Write same failure";
					break;
				default:
					description = "Invalid command failure";
					break;
				}
943
				action = ACTION_FAIL;
944
				error = -EREMOTEIO;
A
Alan Stern 已提交
945 946 947
			} else
				action = ACTION_FAIL;
			break;
948
		case ABORTED_COMMAND:
949
			action = ACTION_FAIL;
950
			if (sshdr.asc == 0x10) { /* DIF */
951 952
				description = "Target Data Integrity Failure";
				error = -EILSEQ;
953
			}
L
Linus Torvalds 已提交
954 955
			break;
		case NOT_READY:
956
			/* If the device is in the process of becoming
J
James Bottomley 已提交
957
			 * ready, or has a temporary blockage, retry.
L
Linus Torvalds 已提交
958
			 */
J
James Bottomley 已提交
959 960 961 962 963 964 965 966 967
			if (sshdr.asc == 0x04) {
				switch (sshdr.ascq) {
				case 0x01: /* becoming ready */
				case 0x04: /* format in progress */
				case 0x05: /* rebuild in progress */
				case 0x06: /* recalculation in progress */
				case 0x07: /* operation in progress */
				case 0x08: /* Long write in progress */
				case 0x09: /* self test in progress */
968
				case 0x14: /* space allocation in progress */
A
Alan Stern 已提交
969
					action = ACTION_DELAYED_RETRY;
J
James Bottomley 已提交
970
					break;
971 972 973 974
				default:
					description = "Device not ready";
					action = ACTION_FAIL;
					break;
J
James Bottomley 已提交
975
				}
A
Alan Stern 已提交
976 977 978
			} else {
				description = "Device not ready";
				action = ACTION_FAIL;
L
Linus Torvalds 已提交
979
			}
A
Alan Stern 已提交
980
			break;
L
Linus Torvalds 已提交
981
		case VOLUME_OVERFLOW:
982
			/* See SSC3rXX or current. */
A
Alan Stern 已提交
983 984
			action = ACTION_FAIL;
			break;
L
Linus Torvalds 已提交
985
		default:
A
Alan Stern 已提交
986 987
			description = "Unhandled sense code";
			action = ACTION_FAIL;
L
Linus Torvalds 已提交
988 989
			break;
		}
A
Alan Stern 已提交
990 991 992
	} else {
		description = "Unhandled error code";
		action = ACTION_FAIL;
993
	}
A
Alan Stern 已提交
994

995 996 997 998 999 1000
	if (action != ACTION_FAIL &&
	    time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
		action = ACTION_FAIL;
		description = "Command timed out";
	}

A
Alan Stern 已提交
1001 1002 1003
	switch (action) {
	case ACTION_FAIL:
		/* Give up and fail the remainder of the request */
1004
		scsi_release_buffers(cmd);
1005
		if (!(req->cmd_flags & REQ_QUIET)) {
A
Alan Stern 已提交
1006
			if (description)
1007
				scmd_printk(KERN_INFO, cmd, "%s\n",
A
Alan Stern 已提交
1008
					    description);
1009
			scsi_print_result(cmd);
1010 1011
			if (driver_byte(result) & DRIVER_SENSE)
				scsi_print_sense("", cmd);
1012
			scsi_print_command(cmd);
1013
		}
1014
		if (blk_end_request_err(req, error))
1015 1016 1017
			scsi_requeue_command(q, cmd);
		else
			scsi_next_command(cmd);
A
Alan Stern 已提交
1018 1019 1020 1021 1022
		break;
	case ACTION_REPREP:
		/* Unprep the request and put it back at the head of the queue.
		 * A new command will be prepared and issued.
		 */
1023
		scsi_release_buffers(cmd);
A
Alan Stern 已提交
1024 1025 1026 1027
		scsi_requeue_command(q, cmd);
		break;
	case ACTION_RETRY:
		/* Retry the same command immediately */
1028
		__scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY, 0);
A
Alan Stern 已提交
1029 1030 1031
		break;
	case ACTION_DELAYED_RETRY:
		/* Retry the same command after a delay */
1032
		__scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY, 0);
A
Alan Stern 已提交
1033
		break;
L
Linus Torvalds 已提交
1034 1035 1036
	}
}

1037 1038
static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
			     gfp_t gfp_mask)
L
Linus Torvalds 已提交
1039
{
1040
	int count;
L
Linus Torvalds 已提交
1041 1042

	/*
C
Christoph Hellwig 已提交
1043
	 * If sg table allocation fails, requeue request later.
L
Linus Torvalds 已提交
1044
	 */
B
Boaz Harrosh 已提交
1045 1046
	if (unlikely(scsi_alloc_sgtable(sdb, req->nr_phys_segments,
					gfp_mask))) {
L
Linus Torvalds 已提交
1047
		return BLKPREP_DEFER;
A
Alan Stern 已提交
1048
	}
L
Linus Torvalds 已提交
1049

C
Christoph Hellwig 已提交
1050
	req->buffer = NULL;
L
Linus Torvalds 已提交
1051 1052 1053 1054 1055

	/* 
	 * Next, walk the list, and fill in the addresses and sizes of
	 * each segment.
	 */
B
Boaz Harrosh 已提交
1056 1057 1058
	count = blk_rq_map_sg(req->q, req, sdb->table.sgl);
	BUG_ON(count > sdb->table.nents);
	sdb->table.nents = count;
1059
	sdb->length = blk_rq_bytes(req);
1060
	return BLKPREP_OK;
L
Linus Torvalds 已提交
1061
}
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075

/*
 * Function:    scsi_init_io()
 *
 * Purpose:     SCSI I/O initialize function.
 *
 * Arguments:   cmd   - Command descriptor we wish to initialize
 *
 * Returns:     0 on success
 *		BLKPREP_DEFER if the failure is retryable
 *		BLKPREP_KILL if the failure is fatal
 */
int scsi_init_io(struct scsi_cmnd *cmd, gfp_t gfp_mask)
{
1076 1077 1078
	struct request *rq = cmd->request;

	int error = scsi_init_sgtable(rq, &cmd->sdb, gfp_mask);
1079 1080 1081
	if (error)
		goto err_exit;

1082
	if (blk_bidi_rq(rq)) {
1083
		struct scsi_data_buffer *bidi_sdb = kmem_cache_zalloc(
1084
			scsi_sdb_cache, GFP_ATOMIC);
1085 1086 1087 1088 1089
		if (!bidi_sdb) {
			error = BLKPREP_DEFER;
			goto err_exit;
		}

1090 1091
		rq->next_rq->special = bidi_sdb;
		error = scsi_init_sgtable(rq->next_rq, bidi_sdb, GFP_ATOMIC);
1092 1093 1094 1095
		if (error)
			goto err_exit;
	}

1096
	if (blk_integrity_rq(rq)) {
1097 1098 1099 1100
		struct scsi_data_buffer *prot_sdb = cmd->prot_sdb;
		int ivecs, count;

		BUG_ON(prot_sdb == NULL);
1101
		ivecs = blk_rq_count_integrity_sg(rq->q, rq->bio);
1102 1103 1104 1105 1106 1107

		if (scsi_alloc_sgtable(prot_sdb, ivecs, gfp_mask)) {
			error = BLKPREP_DEFER;
			goto err_exit;
		}

1108
		count = blk_rq_map_integrity_sg(rq->q, rq->bio,
1109 1110
						prot_sdb->table.sgl);
		BUG_ON(unlikely(count > ivecs));
1111
		BUG_ON(unlikely(count > queue_max_integrity_segments(rq->q)));
1112 1113 1114 1115 1116

		cmd->prot_sdb = prot_sdb;
		cmd->prot_sdb->table.nents = count;
	}

1117 1118 1119 1120
	return BLKPREP_OK ;

err_exit:
	scsi_release_buffers(cmd);
F
FUJITA Tomonori 已提交
1121
	cmd->request->special = NULL;
1122
	scsi_put_command(cmd);
1123
	put_device(&cmd->device->sdev_gendev);
1124 1125
	return error;
}
1126
EXPORT_SYMBOL(scsi_init_io);
L
Linus Torvalds 已提交
1127

C
Christoph Hellwig 已提交
1128 1129 1130 1131 1132 1133
static struct scsi_cmnd *scsi_get_cmd_from_req(struct scsi_device *sdev,
		struct request *req)
{
	struct scsi_cmnd *cmd;

	if (!req->special) {
1134 1135 1136 1137
		/* Bail if we can't get a reference to the device */
		if (!get_device(&sdev->sdev_gendev))
			return NULL;

C
Christoph Hellwig 已提交
1138
		cmd = scsi_get_command(sdev, GFP_ATOMIC);
1139 1140
		if (unlikely(!cmd)) {
			put_device(&sdev->sdev_gendev);
C
Christoph Hellwig 已提交
1141
			return NULL;
1142
		}
C
Christoph Hellwig 已提交
1143 1144 1145 1146 1147 1148 1149 1150 1151
		req->special = cmd;
	} else {
		cmd = req->special;
	}

	/* pull a tag out of the request if we have one */
	cmd->tag = req->tag;
	cmd->request = req;

1152
	cmd->cmnd = req->cmd;
1153
	cmd->prot_op = SCSI_PROT_NORMAL;
1154

C
Christoph Hellwig 已提交
1155 1156 1157
	return cmd;
}

1158
int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
J
James Bottomley 已提交
1159
{
C
Christoph Hellwig 已提交
1160
	struct scsi_cmnd *cmd;
1161 1162 1163 1164
	int ret = scsi_prep_state_check(sdev, req);

	if (ret != BLKPREP_OK)
		return ret;
C
Christoph Hellwig 已提交
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180

	cmd = scsi_get_cmd_from_req(sdev, req);
	if (unlikely(!cmd))
		return BLKPREP_DEFER;

	/*
	 * BLOCK_PC requests may transfer data, in which case they must
	 * a bio attached to them.  Or they might contain a SCSI command
	 * that does not transfer data, in which case they may optionally
	 * submit a request without an attached bio.
	 */
	if (req->bio) {
		int ret;

		BUG_ON(!req->nr_phys_segments);

1181
		ret = scsi_init_io(cmd, GFP_ATOMIC);
C
Christoph Hellwig 已提交
1182 1183 1184
		if (unlikely(ret))
			return ret;
	} else {
T
Tejun Heo 已提交
1185
		BUG_ON(blk_rq_bytes(req));
C
Christoph Hellwig 已提交
1186

B
Boaz Harrosh 已提交
1187
		memset(&cmd->sdb, 0, sizeof(cmd->sdb));
C
Christoph Hellwig 已提交
1188 1189
		req->buffer = NULL;
	}
J
James Bottomley 已提交
1190 1191

	cmd->cmd_len = req->cmd_len;
T
Tejun Heo 已提交
1192
	if (!blk_rq_bytes(req))
J
James Bottomley 已提交
1193 1194 1195 1196 1197 1198
		cmd->sc_data_direction = DMA_NONE;
	else if (rq_data_dir(req) == WRITE)
		cmd->sc_data_direction = DMA_TO_DEVICE;
	else
		cmd->sc_data_direction = DMA_FROM_DEVICE;
	
T
Tejun Heo 已提交
1199
	cmd->transfersize = blk_rq_bytes(req);
J
James Bottomley 已提交
1200
	cmd->allowed = req->retries;
C
Christoph Hellwig 已提交
1201
	return BLKPREP_OK;
J
James Bottomley 已提交
1202
}
1203
EXPORT_SYMBOL(scsi_setup_blk_pc_cmnd);
J
James Bottomley 已提交
1204

C
Christoph Hellwig 已提交
1205 1206 1207 1208 1209
/*
 * Setup a REQ_TYPE_FS command.  These are simple read/write request
 * from filesystems that still need to be translated to SCSI CDBs from
 * the ULD.
 */
1210
int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req)
L
Linus Torvalds 已提交
1211 1212
{
	struct scsi_cmnd *cmd;
1213
	int ret = scsi_prep_state_check(sdev, req);
L
Linus Torvalds 已提交
1214

1215 1216
	if (ret != BLKPREP_OK)
		return ret;
1217 1218 1219 1220 1221 1222 1223 1224

	if (unlikely(sdev->scsi_dh_data && sdev->scsi_dh_data->scsi_dh
			 && sdev->scsi_dh_data->scsi_dh->prep_fn)) {
		ret = sdev->scsi_dh_data->scsi_dh->prep_fn(sdev, req);
		if (ret != BLKPREP_OK)
			return ret;
	}

L
Linus Torvalds 已提交
1225
	/*
C
Christoph Hellwig 已提交
1226
	 * Filesystem requests must transfer data.
L
Linus Torvalds 已提交
1227
	 */
C
Christoph Hellwig 已提交
1228 1229 1230 1231 1232 1233
	BUG_ON(!req->nr_phys_segments);

	cmd = scsi_get_cmd_from_req(sdev, req);
	if (unlikely(!cmd))
		return BLKPREP_DEFER;

1234
	memset(cmd->cmnd, 0, BLK_MAX_CDB);
1235
	return scsi_init_io(cmd, GFP_ATOMIC);
C
Christoph Hellwig 已提交
1236
}
1237
EXPORT_SYMBOL(scsi_setup_fs_cmnd);
C
Christoph Hellwig 已提交
1238

1239
int scsi_prep_state_check(struct scsi_device *sdev, struct request *req)
C
Christoph Hellwig 已提交
1240 1241 1242
{
	int ret = BLKPREP_OK;

L
Linus Torvalds 已提交
1243
	/*
C
Christoph Hellwig 已提交
1244 1245
	 * If the device is not in running state we will reject some
	 * or all commands.
L
Linus Torvalds 已提交
1246
	 */
C
Christoph Hellwig 已提交
1247 1248 1249
	if (unlikely(sdev->sdev_state != SDEV_RUNNING)) {
		switch (sdev->sdev_state) {
		case SDEV_OFFLINE:
1250
		case SDEV_TRANSPORT_OFFLINE:
C
Christoph Hellwig 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
			/*
			 * If the device is offline we refuse to process any
			 * commands.  The device must be brought online
			 * before trying any recovery commands.
			 */
			sdev_printk(KERN_ERR, sdev,
				    "rejecting I/O to offline device\n");
			ret = BLKPREP_KILL;
			break;
		case SDEV_DEL:
			/*
			 * If the device is fully deleted, we refuse to
			 * process any commands as well.
			 */
1265
			sdev_printk(KERN_ERR, sdev,
C
Christoph Hellwig 已提交
1266 1267 1268 1269 1270
				    "rejecting I/O to dead device\n");
			ret = BLKPREP_KILL;
			break;
		case SDEV_QUIESCE:
		case SDEV_BLOCK:
1271
		case SDEV_CREATED_BLOCK:
C
Christoph Hellwig 已提交
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
			/*
			 * If the devices is blocked we defer normal commands.
			 */
			if (!(req->cmd_flags & REQ_PREEMPT))
				ret = BLKPREP_DEFER;
			break;
		default:
			/*
			 * For any other not fully online state we only allow
			 * special commands.  In particular any user initiated
			 * command is not allowed.
			 */
			if (!(req->cmd_flags & REQ_PREEMPT))
				ret = BLKPREP_KILL;
			break;
L
Linus Torvalds 已提交
1287 1288
		}
	}
1289 1290 1291
	return ret;
}
EXPORT_SYMBOL(scsi_prep_state_check);
L
Linus Torvalds 已提交
1292

1293 1294 1295
int scsi_prep_return(struct request_queue *q, struct request *req, int ret)
{
	struct scsi_device *sdev = q->queuedata;
L
Linus Torvalds 已提交
1296

C
Christoph Hellwig 已提交
1297 1298 1299
	switch (ret) {
	case BLKPREP_KILL:
		req->errors = DID_NO_CONNECT << 16;
1300 1301 1302 1303 1304
		/* release the command and kill it */
		if (req->special) {
			struct scsi_cmnd *cmd = req->special;
			scsi_release_buffers(cmd);
			scsi_put_command(cmd);
1305
			put_device(&cmd->device->sdev_gendev);
1306 1307
			req->special = NULL;
		}
C
Christoph Hellwig 已提交
1308 1309
		break;
	case BLKPREP_DEFER:
L
Linus Torvalds 已提交
1310
		/*
1311
		 * If we defer, the blk_peek_request() returns NULL, but the
J
Jens Axboe 已提交
1312 1313
		 * queue must be restarted, so we schedule a callback to happen
		 * shortly.
L
Linus Torvalds 已提交
1314
		 */
C
Christoph Hellwig 已提交
1315
		if (sdev->device_busy == 0)
J
Jens Axboe 已提交
1316
			blk_delay_queue(q, SCSI_QUEUE_DELAY);
C
Christoph Hellwig 已提交
1317 1318 1319
		break;
	default:
		req->cmd_flags |= REQ_DONTPREP;
L
Linus Torvalds 已提交
1320 1321
	}

C
Christoph Hellwig 已提交
1322
	return ret;
L
Linus Torvalds 已提交
1323
}
1324 1325
EXPORT_SYMBOL(scsi_prep_return);

1326
int scsi_prep_fn(struct request_queue *q, struct request *req)
1327 1328 1329 1330 1331 1332 1333 1334
{
	struct scsi_device *sdev = q->queuedata;
	int ret = BLKPREP_KILL;

	if (req->cmd_type == REQ_TYPE_BLOCK_PC)
		ret = scsi_setup_blk_pc_cmnd(sdev, req);
	return scsi_prep_return(q, req, ret);
}
1335
EXPORT_SYMBOL(scsi_prep_fn);
L
Linus Torvalds 已提交
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351

/*
 * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else
 * return 0.
 *
 * Called with the queue_lock held.
 */
static inline int scsi_dev_queue_ready(struct request_queue *q,
				  struct scsi_device *sdev)
{
	if (sdev->device_busy == 0 && sdev->device_blocked) {
		/*
		 * unblock after device_blocked iterates to zero
		 */
		if (--sdev->device_blocked == 0) {
			SCSI_LOG_MLQUEUE(3,
1352 1353
				   sdev_printk(KERN_INFO, sdev,
				   "unblocking device at zero depth\n"));
L
Linus Torvalds 已提交
1354
		} else {
J
Jens Axboe 已提交
1355
			blk_delay_queue(q, SCSI_QUEUE_DELAY);
L
Linus Torvalds 已提交
1356 1357 1358
			return 0;
		}
	}
1359
	if (scsi_device_is_busy(sdev))
L
Linus Torvalds 已提交
1360 1361 1362 1363 1364
		return 0;

	return 1;
}

1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390

/*
 * scsi_target_queue_ready: checks if there we can send commands to target
 * @sdev: scsi device on starget to check.
 *
 * Called with the host lock held.
 */
static inline int scsi_target_queue_ready(struct Scsi_Host *shost,
					   struct scsi_device *sdev)
{
	struct scsi_target *starget = scsi_target(sdev);

	if (starget->single_lun) {
		if (starget->starget_sdev_user &&
		    starget->starget_sdev_user != sdev)
			return 0;
		starget->starget_sdev_user = sdev;
	}

	if (starget->target_busy == 0 && starget->target_blocked) {
		/*
		 * unblock after target_blocked iterates to zero
		 */
		if (--starget->target_blocked == 0) {
			SCSI_LOG_MLQUEUE(3, starget_printk(KERN_INFO, starget,
					 "unblocking target at zero depth\n"));
1391
		} else
1392 1393 1394 1395
			return 0;
	}

	if (scsi_target_is_busy(starget)) {
1396
		list_move_tail(&sdev->starved_entry, &shost->starved_list);
1397
		return 0;
1398 1399 1400 1401 1402
	}

	return 1;
}

L
Linus Torvalds 已提交
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
/*
 * scsi_host_queue_ready: if we can send requests to shost, return 1 else
 * return 0. We must end up running the queue again whenever 0 is
 * returned, else IO can hang.
 *
 * Called with host_lock held.
 */
static inline int scsi_host_queue_ready(struct request_queue *q,
				   struct Scsi_Host *shost,
				   struct scsi_device *sdev)
{
1414
	if (scsi_host_in_recovery(shost))
L
Linus Torvalds 已提交
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
		return 0;
	if (shost->host_busy == 0 && shost->host_blocked) {
		/*
		 * unblock after host_blocked iterates to zero
		 */
		if (--shost->host_blocked == 0) {
			SCSI_LOG_MLQUEUE(3,
				printk("scsi%d unblocking host at zero depth\n",
					shost->host_no));
		} else {
			return 0;
		}
	}
1428
	if (scsi_host_is_busy(shost)) {
L
Linus Torvalds 已提交
1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
		if (list_empty(&sdev->starved_entry))
			list_add_tail(&sdev->starved_entry, &shost->starved_list);
		return 0;
	}

	/* We're OK to process the command, so we can't be starved */
	if (!list_empty(&sdev->starved_entry))
		list_del_init(&sdev->starved_entry);

	return 1;
}

1441 1442 1443 1444 1445 1446 1447 1448
/*
 * Busy state exporting function for request stacking drivers.
 *
 * For efficiency, no lock is taken to check the busy state of
 * shost/starget/sdev, since the returned value is not guaranteed and
 * may be changed after request stacking drivers call the function,
 * regardless of taking lock or not.
 *
1449 1450 1451
 * When scsi can't dispatch I/Os anymore and needs to kill I/Os scsi
 * needs to return 'not busy'. Otherwise, request stacking drivers
 * may hold requests forever.
1452 1453 1454 1455 1456 1457
 */
static int scsi_lld_busy(struct request_queue *q)
{
	struct scsi_device *sdev = q->queuedata;
	struct Scsi_Host *shost;

B
Bart Van Assche 已提交
1458
	if (blk_queue_dying(q))
1459 1460 1461 1462
		return 0;

	shost = sdev->host;

1463 1464 1465 1466 1467 1468 1469
	/*
	 * Ignore host/starget busy state.
	 * Since block layer does not have a concept of fairness across
	 * multiple queues, congestion of host/starget needs to be handled
	 * in SCSI layer.
	 */
	if (scsi_host_in_recovery(shost) || scsi_device_is_busy(sdev))
1470 1471 1472 1473 1474
		return 1;

	return 0;
}

L
Linus Torvalds 已提交
1475
/*
1476
 * Kill a request for a dead device
L
Linus Torvalds 已提交
1477
 */
1478
static void scsi_kill_request(struct request *req, struct request_queue *q)
L
Linus Torvalds 已提交
1479
{
1480
	struct scsi_cmnd *cmd = req->special;
1481 1482 1483
	struct scsi_device *sdev;
	struct scsi_target *starget;
	struct Scsi_Host *shost;
L
Linus Torvalds 已提交
1484

1485
	blk_start_request(req);
1486

1487 1488
	scmd_printk(KERN_INFO, cmd, "killing request\n");

1489 1490 1491
	sdev = cmd->device;
	starget = scsi_target(sdev);
	shost = sdev->host;
1492 1493 1494
	scsi_init_cmd_errh(cmd);
	cmd->result = DID_NO_CONNECT << 16;
	atomic_inc(&cmd->device->iorequest_cnt);
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504

	/*
	 * SCSI request completion path will do scsi_device_unbusy(),
	 * bump busy counts.  To bump the counters, we need to dance
	 * with the locks as normal issue path does.
	 */
	sdev->device_busy++;
	spin_unlock(sdev->request_queue->queue_lock);
	spin_lock(shost->host_lock);
	shost->host_busy++;
1505
	starget->target_busy++;
1506 1507 1508
	spin_unlock(shost->host_lock);
	spin_lock(sdev->request_queue->queue_lock);

J
Jens Axboe 已提交
1509
	blk_complete_request(req);
L
Linus Torvalds 已提交
1510 1511
}

1512 1513
static void scsi_softirq_done(struct request *rq)
{
J
Jens Axboe 已提交
1514 1515
	struct scsi_cmnd *cmd = rq->special;
	unsigned long wait_for = (cmd->allowed + 1) * rq->timeout;
1516 1517 1518 1519
	int disposition;

	INIT_LIST_HEAD(&cmd->eh_entry);

J
Jens Axboe 已提交
1520 1521 1522 1523
	atomic_inc(&cmd->device->iodone_cnt);
	if (cmd->result)
		atomic_inc(&cmd->device->ioerr_cnt);

1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
	disposition = scsi_decide_disposition(cmd);
	if (disposition != SUCCESS &&
	    time_before(cmd->jiffies_at_alloc + wait_for, jiffies)) {
		sdev_printk(KERN_ERR, cmd->device,
			    "timing out command, waited %lus\n",
			    wait_for/HZ);
		disposition = SUCCESS;
	}
			
	scsi_log_completion(cmd, disposition);

	switch (disposition) {
		case SUCCESS:
			scsi_finish_command(cmd);
			break;
		case NEEDS_RETRY:
1540
			scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
			break;
		case ADD_TO_MLQUEUE:
			scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
			break;
		default:
			if (!scsi_eh_scmd_add(cmd, 0))
				scsi_finish_command(cmd);
	}
}

L
Linus Torvalds 已提交
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
/*
 * Function:    scsi_request_fn()
 *
 * Purpose:     Main strategy routine for SCSI.
 *
 * Arguments:   q       - Pointer to actual queue.
 *
 * Returns:     Nothing
 *
 * Lock status: IO request lock assumed to be held when called.
 */
static void scsi_request_fn(struct request_queue *q)
1563 1564
	__releases(q->queue_lock)
	__acquires(q->queue_lock)
L
Linus Torvalds 已提交
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
{
	struct scsi_device *sdev = q->queuedata;
	struct Scsi_Host *shost;
	struct scsi_cmnd *cmd;
	struct request *req;

	/*
	 * To start with, we keep looping until the queue is empty, or until
	 * the host is no longer able to accept any more requests.
	 */
	shost = sdev->host;
J
Jens Axboe 已提交
1576
	for (;;) {
L
Linus Torvalds 已提交
1577 1578 1579 1580 1581 1582
		int rtn;
		/*
		 * get next queueable request.  We do this early to make sure
		 * that the request is fully prepared even if we cannot 
		 * accept it.
		 */
1583
		req = blk_peek_request(q);
L
Linus Torvalds 已提交
1584 1585 1586 1587
		if (!req || !scsi_dev_queue_ready(q, sdev))
			break;

		if (unlikely(!scsi_device_online(sdev))) {
1588 1589
			sdev_printk(KERN_ERR, sdev,
				    "rejecting I/O to offline device\n");
1590
			scsi_kill_request(req, q);
L
Linus Torvalds 已提交
1591 1592 1593 1594 1595 1596 1597 1598
			continue;
		}


		/*
		 * Remove the request from the request list.
		 */
		if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))
1599
			blk_start_request(req);
L
Linus Torvalds 已提交
1600 1601 1602
		sdev->device_busy++;

		spin_unlock(q->queue_lock);
1603 1604 1605 1606
		cmd = req->special;
		if (unlikely(cmd == NULL)) {
			printk(KERN_CRIT "impossible request in %s.\n"
					 "please mail a stack trace to "
1607
					 "linux-scsi@vger.kernel.org\n",
1608
					 __func__);
1609
			blk_dump_rq_flags(req, "foo");
1610 1611
			BUG();
		}
L
Linus Torvalds 已提交
1612 1613
		spin_lock(shost->host_lock);

1614 1615 1616 1617 1618 1619 1620 1621
		/*
		 * We hit this when the driver is using a host wide
		 * tag map. For device level tag maps the queue_depth check
		 * in the device ready fn would prevent us from trying
		 * to allocate a tag. Since the map is a shared host resource
		 * we add the dev to the starved list so it eventually gets
		 * a run when a tag is freed.
		 */
1622
		if (blk_queue_tagged(q) && !blk_rq_tagged(req)) {
1623 1624 1625 1626 1627 1628
			if (list_empty(&sdev->starved_entry))
				list_add_tail(&sdev->starved_entry,
					      &shost->starved_list);
			goto not_ready;
		}

1629 1630 1631
		if (!scsi_target_queue_ready(shost, sdev))
			goto not_ready;

L
Linus Torvalds 已提交
1632 1633
		if (!scsi_host_queue_ready(q, shost, sdev))
			goto not_ready;
1634 1635

		scsi_target(sdev)->target_busy++;
L
Linus Torvalds 已提交
1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
		shost->host_busy++;

		/*
		 * XXX(hch): This is rather suboptimal, scsi_dispatch_cmd will
		 *		take the lock again.
		 */
		spin_unlock_irq(shost->host_lock);

		/*
		 * Finally, initialize any error handling parameters, and set up
		 * the timers for timeouts.
		 */
		scsi_init_cmd_errh(cmd);

		/*
		 * Dispatch the command to the low-level driver.
		 */
		rtn = scsi_dispatch_cmd(cmd);
		spin_lock_irq(q->queue_lock);
J
Jens Axboe 已提交
1655 1656
		if (rtn)
			goto out_delay;
L
Linus Torvalds 已提交
1657 1658
	}

1659
	return;
L
Linus Torvalds 已提交
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674

 not_ready:
	spin_unlock_irq(shost->host_lock);

	/*
	 * lock q, handle tag, requeue req, and decrement device_busy. We
	 * must return with queue_lock held.
	 *
	 * Decrementing device_busy without checking it is OK, as all such
	 * cases (host limits or settings) should run the queue at some
	 * later time.
	 */
	spin_lock_irq(q->queue_lock);
	blk_requeue_request(q, req);
	sdev->device_busy--;
J
Jens Axboe 已提交
1675 1676 1677
out_delay:
	if (sdev->device_busy == 0)
		blk_delay_queue(q, SCSI_QUEUE_DELAY);
L
Linus Torvalds 已提交
1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
}

u64 scsi_calculate_bounce_limit(struct Scsi_Host *shost)
{
	struct device *host_dev;
	u64 bounce_limit = 0xffffffff;

	if (shost->unchecked_isa_dma)
		return BLK_BOUNCE_ISA;
	/*
	 * Platforms with virtual-DMA translation
	 * hardware have no practical limit.
	 */
	if (!PCI_DMA_BUS_IS_PHYS)
		return BLK_BOUNCE_ANY;

	host_dev = scsi_get_device(shost);
	if (host_dev && host_dev->dma_mask)
1696
		bounce_limit = (u64)dma_max_pfn(host_dev) << PAGE_SHIFT;
L
Linus Torvalds 已提交
1697 1698 1699 1700 1701

	return bounce_limit;
}
EXPORT_SYMBOL(scsi_calculate_bounce_limit);

1702 1703
struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
					 request_fn_proc *request_fn)
L
Linus Torvalds 已提交
1704 1705
{
	struct request_queue *q;
1706
	struct device *dev = shost->dma_dev;
L
Linus Torvalds 已提交
1707

1708
	q = blk_init_queue(request_fn, NULL);
L
Linus Torvalds 已提交
1709 1710 1711
	if (!q)
		return NULL;

1712 1713 1714
	/*
	 * this limit is imposed by hardware restrictions
	 */
1715 1716
	blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
					SCSI_MAX_SG_CHAIN_SEGMENTS));
1717

1718 1719 1720 1721 1722 1723 1724 1725
	if (scsi_host_prot_dma(shost)) {
		shost->sg_prot_tablesize =
			min_not_zero(shost->sg_prot_tablesize,
				     (unsigned short)SCSI_MAX_PROT_SG_SEGMENTS);
		BUG_ON(shost->sg_prot_tablesize < shost->sg_tablesize);
		blk_queue_max_integrity_segments(q, shost->sg_prot_tablesize);
	}

1726
	blk_queue_max_hw_sectors(q, shost->max_sectors);
L
Linus Torvalds 已提交
1727 1728
	blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
	blk_queue_segment_boundary(q, shost->dma_boundary);
1729
	dma_set_seg_boundary(dev, shost->dma_boundary);
L
Linus Torvalds 已提交
1730

1731 1732
	blk_queue_max_segment_size(q, dma_get_max_seg_size(dev));

L
Linus Torvalds 已提交
1733
	if (!shost->use_clustering)
1734
		q->limits.cluster = 0;
1735 1736 1737 1738 1739 1740 1741 1742

	/*
	 * set a reasonable default alignment on word boundaries: the
	 * host and device may alter it using
	 * blk_queue_update_dma_alignment() later.
	 */
	blk_queue_dma_alignment(q, 0x03);

L
Linus Torvalds 已提交
1743 1744
	return q;
}
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
EXPORT_SYMBOL(__scsi_alloc_queue);

struct request_queue *scsi_alloc_queue(struct scsi_device *sdev)
{
	struct request_queue *q;

	q = __scsi_alloc_queue(sdev->host, scsi_request_fn);
	if (!q)
		return NULL;

	blk_queue_prep_rq(q, scsi_prep_fn);
	blk_queue_softirq_done(q, scsi_softirq_done);
J
Jens Axboe 已提交
1757
	blk_queue_rq_timed_out(q, scsi_times_out);
1758
	blk_queue_lld_busy(q, scsi_lld_busy);
1759 1760
	return q;
}
L
Linus Torvalds 已提交
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814

/*
 * Function:    scsi_block_requests()
 *
 * Purpose:     Utility function used by low-level drivers to prevent further
 *		commands from being queued to the device.
 *
 * Arguments:   shost       - Host in question
 *
 * Returns:     Nothing
 *
 * Lock status: No locks are assumed held.
 *
 * Notes:       There is no timer nor any other means by which the requests
 *		get unblocked other than the low-level driver calling
 *		scsi_unblock_requests().
 */
void scsi_block_requests(struct Scsi_Host *shost)
{
	shost->host_self_blocked = 1;
}
EXPORT_SYMBOL(scsi_block_requests);

/*
 * Function:    scsi_unblock_requests()
 *
 * Purpose:     Utility function used by low-level drivers to allow further
 *		commands from being queued to the device.
 *
 * Arguments:   shost       - Host in question
 *
 * Returns:     Nothing
 *
 * Lock status: No locks are assumed held.
 *
 * Notes:       There is no timer nor any other means by which the requests
 *		get unblocked other than the low-level driver calling
 *		scsi_unblock_requests().
 *
 *		This is done as an API function so that changes to the
 *		internals of the scsi mid-layer won't require wholesale
 *		changes to drivers that use this feature.
 */
void scsi_unblock_requests(struct Scsi_Host *shost)
{
	shost->host_self_blocked = 0;
	scsi_run_host_queues(shost);
}
EXPORT_SYMBOL(scsi_unblock_requests);

int __init scsi_init_queue(void)
{
	int i;

1815 1816 1817 1818 1819
	scsi_sdb_cache = kmem_cache_create("scsi_data_buffer",
					   sizeof(struct scsi_data_buffer),
					   0, 0, NULL);
	if (!scsi_sdb_cache) {
		printk(KERN_ERR "SCSI: can't init scsi sdb cache\n");
F
FUJITA Tomonori 已提交
1820
		return -ENOMEM;
1821 1822
	}

L
Linus Torvalds 已提交
1823 1824 1825 1826 1827
	for (i = 0; i < SG_MEMPOOL_NR; i++) {
		struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
		int size = sgp->size * sizeof(struct scatterlist);

		sgp->slab = kmem_cache_create(sgp->name, size, 0,
1828
				SLAB_HWCACHE_ALIGN, NULL);
L
Linus Torvalds 已提交
1829 1830 1831
		if (!sgp->slab) {
			printk(KERN_ERR "SCSI: can't init sg slab %s\n",
					sgp->name);
1832
			goto cleanup_sdb;
L
Linus Torvalds 已提交
1833 1834
		}

1835 1836
		sgp->pool = mempool_create_slab_pool(SG_MEMPOOL_SIZE,
						     sgp->slab);
L
Linus Torvalds 已提交
1837 1838 1839
		if (!sgp->pool) {
			printk(KERN_ERR "SCSI: can't init sg mempool %s\n",
					sgp->name);
1840
			goto cleanup_sdb;
L
Linus Torvalds 已提交
1841 1842 1843 1844
		}
	}

	return 0;
1845

1846
cleanup_sdb:
1847 1848 1849 1850 1851 1852 1853
	for (i = 0; i < SG_MEMPOOL_NR; i++) {
		struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
		if (sgp->pool)
			mempool_destroy(sgp->pool);
		if (sgp->slab)
			kmem_cache_destroy(sgp->slab);
	}
1854
	kmem_cache_destroy(scsi_sdb_cache);
1855 1856

	return -ENOMEM;
L
Linus Torvalds 已提交
1857 1858 1859 1860 1861 1862
}

void scsi_exit_queue(void)
{
	int i;

1863
	kmem_cache_destroy(scsi_sdb_cache);
1864

L
Linus Torvalds 已提交
1865 1866 1867 1868 1869 1870
	for (i = 0; i < SG_MEMPOOL_NR; i++) {
		struct scsi_host_sg_pool *sgp = scsi_sg_pools + i;
		mempool_destroy(sgp->pool);
		kmem_cache_destroy(sgp->slab);
	}
}
1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882

/**
 *	scsi_mode_select - issue a mode select
 *	@sdev:	SCSI device to be queried
 *	@pf:	Page format bit (1 == standard, 0 == vendor specific)
 *	@sp:	Save page bit (0 == don't save, 1 == save)
 *	@modepage: mode page being requested
 *	@buffer: request buffer (may not be smaller than eight bytes)
 *	@len:	length of request buffer.
 *	@timeout: command timeout
 *	@retries: number of retries before failing
 *	@data: returns a structure abstracting the mode header data
1883
 *	@sshdr: place to put sense data (or NULL if no sense to be collected).
1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
 *		must be SCSI_SENSE_BUFFERSIZE big.
 *
 *	Returns zero if successful; negative error number or scsi
 *	status on error
 *
 */
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 *sshdr)
{
	unsigned char cmd[10];
	unsigned char *real_buffer;
	int ret;

	memset(cmd, 0, sizeof(cmd));
	cmd[1] = (pf ? 0x10 : 0) | (sp ? 0x01 : 0);

	if (sdev->use_10_for_ms) {
		if (len > 65535)
			return -EINVAL;
		real_buffer = kmalloc(8 + len, GFP_KERNEL);
		if (!real_buffer)
			return -ENOMEM;
		memcpy(real_buffer + 8, buffer, len);
		len += 8;
		real_buffer[0] = 0;
		real_buffer[1] = 0;
		real_buffer[2] = data->medium_type;
		real_buffer[3] = data->device_specific;
		real_buffer[4] = data->longlba ? 0x01 : 0;
		real_buffer[5] = 0;
		real_buffer[6] = data->block_descriptor_length >> 8;
		real_buffer[7] = data->block_descriptor_length;

		cmd[0] = MODE_SELECT_10;
		cmd[7] = len >> 8;
		cmd[8] = len;
	} else {
		if (len > 255 || data->block_descriptor_length > 255 ||
		    data->longlba)
			return -EINVAL;

		real_buffer = kmalloc(4 + len, GFP_KERNEL);
		if (!real_buffer)
			return -ENOMEM;
		memcpy(real_buffer + 4, buffer, len);
		len += 4;
		real_buffer[0] = 0;
		real_buffer[1] = data->medium_type;
		real_buffer[2] = data->device_specific;
		real_buffer[3] = data->block_descriptor_length;
		

		cmd[0] = MODE_SELECT;
		cmd[4] = len;
	}

	ret = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, real_buffer, len,
1943
			       sshdr, timeout, retries, NULL);
1944 1945 1946 1947 1948
	kfree(real_buffer);
	return ret;
}
EXPORT_SYMBOL_GPL(scsi_mode_select);

L
Linus Torvalds 已提交
1949
/**
1950
 *	scsi_mode_sense - issue a mode sense, falling back from 10 to six bytes if necessary.
1951
 *	@sdev:	SCSI device to be queried
L
Linus Torvalds 已提交
1952 1953 1954 1955 1956 1957 1958
 *	@dbd:	set if mode sense will allow block descriptors to be returned
 *	@modepage: mode page being requested
 *	@buffer: request buffer (may not be smaller than eight bytes)
 *	@len:	length of request buffer.
 *	@timeout: command timeout
 *	@retries: number of retries before failing
 *	@data: returns a structure abstracting the mode header data
1959
 *	@sshdr: place to put sense data (or NULL if no sense to be collected).
1960
 *		must be SCSI_SENSE_BUFFERSIZE big.
L
Linus Torvalds 已提交
1961 1962 1963 1964
 *
 *	Returns zero if unsuccessful, or the header offset (either 4
 *	or 8 depending on whether a six or ten byte command was
 *	issued) if successful.
1965
 */
L
Linus Torvalds 已提交
1966
int
1967
scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
L
Linus Torvalds 已提交
1968
		  unsigned char *buffer, int len, int timeout, int retries,
1969 1970
		  struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
{
L
Linus Torvalds 已提交
1971 1972 1973
	unsigned char cmd[12];
	int use_10_for_ms;
	int header_length;
1974
	int result;
1975
	struct scsi_sense_hdr my_sshdr;
L
Linus Torvalds 已提交
1976 1977 1978 1979 1980 1981

	memset(data, 0, sizeof(*data));
	memset(&cmd[0], 0, 12);
	cmd[1] = dbd & 0x18;	/* allows DBD and LLBA bits */
	cmd[2] = modepage;

1982 1983 1984 1985
	/* caller might not be interested in sense, but we need it */
	if (!sshdr)
		sshdr = &my_sshdr;

L
Linus Torvalds 已提交
1986
 retry:
1987
	use_10_for_ms = sdev->use_10_for_ms;
L
Linus Torvalds 已提交
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006

	if (use_10_for_ms) {
		if (len < 8)
			len = 8;

		cmd[0] = MODE_SENSE_10;
		cmd[8] = len;
		header_length = 8;
	} else {
		if (len < 4)
			len = 4;

		cmd[0] = MODE_SENSE;
		cmd[4] = len;
		header_length = 4;
	}

	memset(buffer, 0, len);

2007
	result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
2008
				  sshdr, timeout, retries, NULL);
L
Linus Torvalds 已提交
2009 2010 2011 2012 2013 2014

	/* This code looks awful: what it's doing is making sure an
	 * ILLEGAL REQUEST sense return identifies the actual command
	 * byte as the problem.  MODE_SENSE commands can return
	 * ILLEGAL REQUEST if the code page isn't supported */

2015 2016
	if (use_10_for_ms && !scsi_status_is_good(result) &&
	    (driver_byte(result) & DRIVER_SENSE)) {
2017 2018 2019
		if (scsi_sense_valid(sshdr)) {
			if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
			    (sshdr->asc == 0x20) && (sshdr->ascq == 0)) {
L
Linus Torvalds 已提交
2020 2021 2022
				/* 
				 * Invalid command operation code
				 */
2023
				sdev->use_10_for_ms = 0;
L
Linus Torvalds 已提交
2024 2025 2026 2027 2028
				goto retry;
			}
		}
	}

2029
	if(scsi_status_is_good(result)) {
2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
		if (unlikely(buffer[0] == 0x86 && buffer[1] == 0x0b &&
			     (modepage == 6 || modepage == 8))) {
			/* Initio breakage? */
			header_length = 0;
			data->length = 13;
			data->medium_type = 0;
			data->device_specific = 0;
			data->longlba = 0;
			data->block_descriptor_length = 0;
		} else if(use_10_for_ms) {
L
Linus Torvalds 已提交
2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051
			data->length = buffer[0]*256 + buffer[1] + 2;
			data->medium_type = buffer[2];
			data->device_specific = buffer[3];
			data->longlba = buffer[4] & 0x01;
			data->block_descriptor_length = buffer[6]*256
				+ buffer[7];
		} else {
			data->length = buffer[0] + 1;
			data->medium_type = buffer[1];
			data->device_specific = buffer[2];
			data->block_descriptor_length = buffer[3];
		}
2052
		data->header_length = header_length;
L
Linus Torvalds 已提交
2053 2054
	}

2055
	return result;
L
Linus Torvalds 已提交
2056 2057 2058
}
EXPORT_SYMBOL(scsi_mode_sense);

2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
/**
 *	scsi_test_unit_ready - test if unit is ready
 *	@sdev:	scsi device to change the state of.
 *	@timeout: command timeout
 *	@retries: number of retries before failing
 *	@sshdr_external: Optional pointer to struct scsi_sense_hdr for
 *		returning sense. Make sure that this is cleared before passing
 *		in.
 *
 *	Returns zero if unsuccessful or an error if TUR failed.  For
2069
 *	removable media, UNIT_ATTENTION sets ->changed flag.
2070
 **/
L
Linus Torvalds 已提交
2071
int
2072 2073
scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries,
		     struct scsi_sense_hdr *sshdr_external)
L
Linus Torvalds 已提交
2074 2075 2076 2077
{
	char cmd[] = {
		TEST_UNIT_READY, 0, 0, 0, 0, 0,
	};
2078
	struct scsi_sense_hdr *sshdr;
L
Linus Torvalds 已提交
2079
	int result;
2080 2081 2082 2083 2084 2085 2086 2087 2088

	if (!sshdr_external)
		sshdr = kzalloc(sizeof(*sshdr), GFP_KERNEL);
	else
		sshdr = sshdr_external;

	/* try to eat the UNIT_ATTENTION if there are enough retries */
	do {
		result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL, 0, sshdr,
2089
					  timeout, retries, NULL);
2090 2091 2092 2093 2094
		if (sdev->removable && scsi_sense_valid(sshdr) &&
		    sshdr->sense_key == UNIT_ATTENTION)
			sdev->changed = 1;
	} while (scsi_sense_valid(sshdr) &&
		 sshdr->sense_key == UNIT_ATTENTION && --retries);
2095 2096 2097

	if (!sshdr_external)
		kfree(sshdr);
L
Linus Torvalds 已提交
2098 2099 2100 2101 2102
	return result;
}
EXPORT_SYMBOL(scsi_test_unit_ready);

/**
2103
 *	scsi_device_set_state - Take the given device through the device state model.
L
Linus Torvalds 已提交
2104 2105 2106 2107 2108
 *	@sdev:	scsi device to change the state of.
 *	@state:	state to change to.
 *
 *	Returns zero if unsuccessful or an error if the requested 
 *	transition is illegal.
2109
 */
L
Linus Torvalds 已提交
2110 2111 2112 2113 2114 2115 2116 2117 2118 2119
int
scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)
{
	enum scsi_device_state oldstate = sdev->sdev_state;

	if (state == oldstate)
		return 0;

	switch (state) {
	case SDEV_CREATED:
2120 2121 2122 2123 2124 2125 2126
		switch (oldstate) {
		case SDEV_CREATED_BLOCK:
			break;
		default:
			goto illegal;
		}
		break;
L
Linus Torvalds 已提交
2127 2128 2129 2130 2131
			
	case SDEV_RUNNING:
		switch (oldstate) {
		case SDEV_CREATED:
		case SDEV_OFFLINE:
2132
		case SDEV_TRANSPORT_OFFLINE:
L
Linus Torvalds 已提交
2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144
		case SDEV_QUIESCE:
		case SDEV_BLOCK:
			break;
		default:
			goto illegal;
		}
		break;

	case SDEV_QUIESCE:
		switch (oldstate) {
		case SDEV_RUNNING:
		case SDEV_OFFLINE:
2145
		case SDEV_TRANSPORT_OFFLINE:
L
Linus Torvalds 已提交
2146 2147 2148 2149 2150 2151 2152
			break;
		default:
			goto illegal;
		}
		break;

	case SDEV_OFFLINE:
2153
	case SDEV_TRANSPORT_OFFLINE:
L
Linus Torvalds 已提交
2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
		switch (oldstate) {
		case SDEV_CREATED:
		case SDEV_RUNNING:
		case SDEV_QUIESCE:
		case SDEV_BLOCK:
			break;
		default:
			goto illegal;
		}
		break;

	case SDEV_BLOCK:
		switch (oldstate) {
		case SDEV_RUNNING:
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177
		case SDEV_CREATED_BLOCK:
			break;
		default:
			goto illegal;
		}
		break;

	case SDEV_CREATED_BLOCK:
		switch (oldstate) {
		case SDEV_CREATED:
L
Linus Torvalds 已提交
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187
			break;
		default:
			goto illegal;
		}
		break;

	case SDEV_CANCEL:
		switch (oldstate) {
		case SDEV_CREATED:
		case SDEV_RUNNING:
2188
		case SDEV_QUIESCE:
L
Linus Torvalds 已提交
2189
		case SDEV_OFFLINE:
2190
		case SDEV_TRANSPORT_OFFLINE:
L
Linus Torvalds 已提交
2191 2192 2193 2194 2195 2196 2197 2198 2199
		case SDEV_BLOCK:
			break;
		default:
			goto illegal;
		}
		break;

	case SDEV_DEL:
		switch (oldstate) {
2200 2201 2202
		case SDEV_CREATED:
		case SDEV_RUNNING:
		case SDEV_OFFLINE:
2203
		case SDEV_TRANSPORT_OFFLINE:
L
Linus Torvalds 已提交
2204
		case SDEV_CANCEL:
2205
		case SDEV_CREATED_BLOCK:
L
Linus Torvalds 已提交
2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
			break;
		default:
			goto illegal;
		}
		break;

	}
	sdev->sdev_state = state;
	return 0;

 illegal:
	SCSI_LOG_ERROR_RECOVERY(1, 
2218 2219 2220 2221
				sdev_printk(KERN_ERR, sdev,
					    "Illegal state transition %s->%s\n",
					    scsi_device_state_name(oldstate),
					    scsi_device_state_name(state))
L
Linus Torvalds 已提交
2222 2223 2224 2225 2226
				);
	return -EINVAL;
}
EXPORT_SYMBOL(scsi_device_set_state);

2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242
/**
 * 	sdev_evt_emit - emit a single SCSI device uevent
 *	@sdev: associated SCSI device
 *	@evt: event to emit
 *
 *	Send a single uevent (scsi_event) to the associated scsi_device.
 */
static void scsi_evt_emit(struct scsi_device *sdev, struct scsi_event *evt)
{
	int idx = 0;
	char *envp[3];

	switch (evt->evt_type) {
	case SDEV_EVT_MEDIA_CHANGE:
		envp[idx++] = "SDEV_MEDIA_CHANGE=1";
		break;
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
	case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
		envp[idx++] = "SDEV_UA=INQUIRY_DATA_HAS_CHANGED";
		break;
	case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
		envp[idx++] = "SDEV_UA=CAPACITY_DATA_HAS_CHANGED";
		break;
	case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
	       envp[idx++] = "SDEV_UA=THIN_PROVISIONING_SOFT_THRESHOLD_REACHED";
		break;
	case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
		envp[idx++] = "SDEV_UA=MODE_PARAMETERS_CHANGED";
		break;
	case SDEV_EVT_LUN_CHANGE_REPORTED:
		envp[idx++] = "SDEV_UA=REPORTED_LUNS_DATA_HAS_CHANGED";
		break;
2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
	default:
		/* do nothing */
		break;
	}

	envp[idx++] = NULL;

	kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp);
}

/**
 * 	sdev_evt_thread - send a uevent for each scsi event
 *	@work: work struct for scsi_device
 *
 *	Dispatch queued events to their associated scsi_device kobjects
 *	as uevents.
 */
void scsi_evt_thread(struct work_struct *work)
{
	struct scsi_device *sdev;
2278
	enum scsi_device_event evt_type;
2279 2280 2281 2282
	LIST_HEAD(event_list);

	sdev = container_of(work, struct scsi_device, event_work);

2283 2284 2285 2286
	for (evt_type = SDEV_EVT_FIRST; evt_type <= SDEV_EVT_LAST; evt_type++)
		if (test_and_clear_bit(evt_type, sdev->pending_events))
			sdev_evt_send_simple(sdev, evt_type, GFP_KERNEL);

2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
	while (1) {
		struct scsi_event *evt;
		struct list_head *this, *tmp;
		unsigned long flags;

		spin_lock_irqsave(&sdev->list_lock, flags);
		list_splice_init(&sdev->event_list, &event_list);
		spin_unlock_irqrestore(&sdev->list_lock, flags);

		if (list_empty(&event_list))
			break;

		list_for_each_safe(this, tmp, &event_list) {
			evt = list_entry(this, struct scsi_event, node);
			list_del(&evt->node);
			scsi_evt_emit(sdev, evt);
			kfree(evt);
		}
	}
}

/**
 * 	sdev_evt_send - send asserted event to uevent thread
 *	@sdev: scsi_device event occurred on
 *	@evt: event to send
 *
 *	Assert scsi device event asynchronously.
 */
void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt)
{
	unsigned long flags;

2319 2320 2321 2322
#if 0
	/* FIXME: currently this check eliminates all media change events
	 * for polled devices.  Need to update to discriminate between AN
	 * and polled events */
2323 2324 2325 2326
	if (!test_bit(evt->evt_type, sdev->supported_events)) {
		kfree(evt);
		return;
	}
2327
#endif
2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355

	spin_lock_irqsave(&sdev->list_lock, flags);
	list_add_tail(&evt->node, &sdev->event_list);
	schedule_work(&sdev->event_work);
	spin_unlock_irqrestore(&sdev->list_lock, flags);
}
EXPORT_SYMBOL_GPL(sdev_evt_send);

/**
 * 	sdev_evt_alloc - allocate a new scsi event
 *	@evt_type: type of event to allocate
 *	@gfpflags: GFP flags for allocation
 *
 *	Allocates and returns a new scsi_event.
 */
struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
				  gfp_t gfpflags)
{
	struct scsi_event *evt = kzalloc(sizeof(struct scsi_event), gfpflags);
	if (!evt)
		return NULL;

	evt->evt_type = evt_type;
	INIT_LIST_HEAD(&evt->node);

	/* evt_type-specific initialization, if any */
	switch (evt_type) {
	case SDEV_EVT_MEDIA_CHANGE:
2356 2357 2358 2359 2360
	case SDEV_EVT_INQUIRY_CHANGE_REPORTED:
	case SDEV_EVT_CAPACITY_CHANGE_REPORTED:
	case SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED:
	case SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED:
	case SDEV_EVT_LUN_CHANGE_REPORTED:
2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391
	default:
		/* do nothing */
		break;
	}

	return evt;
}
EXPORT_SYMBOL_GPL(sdev_evt_alloc);

/**
 * 	sdev_evt_send_simple - send asserted event to uevent thread
 *	@sdev: scsi_device event occurred on
 *	@evt_type: type of event to send
 *	@gfpflags: GFP flags for allocation
 *
 *	Assert scsi device event asynchronously, given an event type.
 */
void sdev_evt_send_simple(struct scsi_device *sdev,
			  enum scsi_device_event evt_type, gfp_t gfpflags)
{
	struct scsi_event *evt = sdev_evt_alloc(evt_type, gfpflags);
	if (!evt) {
		sdev_printk(KERN_ERR, sdev, "event %d eaten due to OOM\n",
			    evt_type);
		return;
	}

	sdev_evt_send(sdev, evt);
}
EXPORT_SYMBOL_GPL(sdev_evt_send_simple);

L
Linus Torvalds 已提交
2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405
/**
 *	scsi_device_quiesce - Block user issued commands.
 *	@sdev:	scsi device to quiesce.
 *
 *	This works by trying to transition to the SDEV_QUIESCE state
 *	(which must be a legal transition).  When the device is in this
 *	state, only special requests will be accepted, all others will
 *	be deferred.  Since special requests may also be requeued requests,
 *	a successful return doesn't guarantee the device will be 
 *	totally quiescent.
 *
 *	Must be called with user context, may sleep.
 *
 *	Returns zero if unsuccessful or an error if not.
2406
 */
L
Linus Torvalds 已提交
2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430
int
scsi_device_quiesce(struct scsi_device *sdev)
{
	int err = scsi_device_set_state(sdev, SDEV_QUIESCE);
	if (err)
		return err;

	scsi_run_queue(sdev->request_queue);
	while (sdev->device_busy) {
		msleep_interruptible(200);
		scsi_run_queue(sdev->request_queue);
	}
	return 0;
}
EXPORT_SYMBOL(scsi_device_quiesce);

/**
 *	scsi_device_resume - Restart user issued commands to a quiesced device.
 *	@sdev:	scsi device to resume.
 *
 *	Moves the device from quiesced back to running and restarts the
 *	queues.
 *
 *	Must be called with user context, may sleep.
2431
 */
2432
void scsi_device_resume(struct scsi_device *sdev)
L
Linus Torvalds 已提交
2433
{
2434 2435 2436 2437 2438 2439
	/* check if the device state was mutated prior to resume, and if
	 * so assume the state is being managed elsewhere (for example
	 * device deleted during suspend)
	 */
	if (sdev->sdev_state != SDEV_QUIESCE ||
	    scsi_device_set_state(sdev, SDEV_RUNNING))
L
Linus Torvalds 已提交
2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
		return;
	scsi_run_queue(sdev->request_queue);
}
EXPORT_SYMBOL(scsi_device_resume);

static void
device_quiesce_fn(struct scsi_device *sdev, void *data)
{
	scsi_device_quiesce(sdev);
}

void
scsi_target_quiesce(struct scsi_target *starget)
{
	starget_for_each_device(starget, NULL, device_quiesce_fn);
}
EXPORT_SYMBOL(scsi_target_quiesce);

static void
device_resume_fn(struct scsi_device *sdev, void *data)
{
	scsi_device_resume(sdev);
}

void
scsi_target_resume(struct scsi_target *starget)
{
	starget_for_each_device(starget, NULL, device_resume_fn);
}
EXPORT_SYMBOL(scsi_target_resume);

/**
2472
 * scsi_internal_device_block - internal function to put a device temporarily into the SDEV_BLOCK state
L
Linus Torvalds 已提交
2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485
 * @sdev:	device to block
 *
 * Block request made by scsi lld's to temporarily stop all
 * scsi commands on the specified device.  Called from interrupt
 * or normal process context.
 *
 * Returns zero if successful or error if not
 *
 * Notes:       
 *	This routine transitions the device to the SDEV_BLOCK state
 *	(which must be a legal transition).  When the device is in this
 *	state, all commands are deferred until the scsi lld reenables
 *	the device with scsi_device_unblock or device_block_tmo fires.
2486
 */
L
Linus Torvalds 已提交
2487 2488 2489
int
scsi_internal_device_block(struct scsi_device *sdev)
{
2490
	struct request_queue *q = sdev->request_queue;
L
Linus Torvalds 已提交
2491 2492 2493 2494
	unsigned long flags;
	int err = 0;

	err = scsi_device_set_state(sdev, SDEV_BLOCK);
2495 2496 2497 2498 2499 2500
	if (err) {
		err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK);

		if (err)
			return err;
	}
L
Linus Torvalds 已提交
2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517

	/* 
	 * The device has transitioned to SDEV_BLOCK.  Stop the
	 * block layer from calling the midlayer with this device's
	 * request queue. 
	 */
	spin_lock_irqsave(q->queue_lock, flags);
	blk_stop_queue(q);
	spin_unlock_irqrestore(q->queue_lock, flags);

	return 0;
}
EXPORT_SYMBOL_GPL(scsi_internal_device_block);
 
/**
 * scsi_internal_device_unblock - resume a device after a block request
 * @sdev:	device to resume
2518
 * @new_state:	state to set devices to after unblocking
L
Linus Torvalds 已提交
2519 2520 2521 2522 2523 2524 2525 2526 2527
 *
 * Called by scsi lld's or the midlayer to restart the device queue
 * for the previously suspended scsi device.  Called from interrupt or
 * normal process context.
 *
 * Returns zero if successful or error if not.
 *
 * Notes:       
 *	This routine transitions the device to the SDEV_RUNNING state
2528
 *	or to one of the offline states (which must be a legal transition)
2529
 *	allowing the midlayer to goose the queue for this device.
2530
 */
L
Linus Torvalds 已提交
2531
int
2532 2533
scsi_internal_device_unblock(struct scsi_device *sdev,
			     enum scsi_device_state new_state)
L
Linus Torvalds 已提交
2534
{
2535
	struct request_queue *q = sdev->request_queue; 
L
Linus Torvalds 已提交
2536
	unsigned long flags;
2537 2538 2539 2540

	/*
	 * Try to transition the scsi device to SDEV_RUNNING or one of the
	 * offlined states and goose the device queue if successful.
L
Linus Torvalds 已提交
2541
	 */
2542 2543
	if ((sdev->sdev_state == SDEV_BLOCK) ||
	    (sdev->sdev_state == SDEV_TRANSPORT_OFFLINE))
2544 2545 2546 2547 2548 2549 2550 2551
		sdev->sdev_state = new_state;
	else if (sdev->sdev_state == SDEV_CREATED_BLOCK) {
		if (new_state == SDEV_TRANSPORT_OFFLINE ||
		    new_state == SDEV_OFFLINE)
			sdev->sdev_state = new_state;
		else
			sdev->sdev_state = SDEV_CREATED;
	} else if (sdev->sdev_state != SDEV_CANCEL &&
2552
		 sdev->sdev_state != SDEV_OFFLINE)
2553
		return -EINVAL;
L
Linus Torvalds 已提交
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591

	spin_lock_irqsave(q->queue_lock, flags);
	blk_start_queue(q);
	spin_unlock_irqrestore(q->queue_lock, flags);

	return 0;
}
EXPORT_SYMBOL_GPL(scsi_internal_device_unblock);

static void
device_block(struct scsi_device *sdev, void *data)
{
	scsi_internal_device_block(sdev);
}

static int
target_block(struct device *dev, void *data)
{
	if (scsi_is_target_device(dev))
		starget_for_each_device(to_scsi_target(dev), NULL,
					device_block);
	return 0;
}

void
scsi_target_block(struct device *dev)
{
	if (scsi_is_target_device(dev))
		starget_for_each_device(to_scsi_target(dev), NULL,
					device_block);
	else
		device_for_each_child(dev, NULL, target_block);
}
EXPORT_SYMBOL_GPL(scsi_target_block);

static void
device_unblock(struct scsi_device *sdev, void *data)
{
2592
	scsi_internal_device_unblock(sdev, *(enum scsi_device_state *)data);
L
Linus Torvalds 已提交
2593 2594 2595 2596 2597 2598
}

static int
target_unblock(struct device *dev, void *data)
{
	if (scsi_is_target_device(dev))
2599
		starget_for_each_device(to_scsi_target(dev), data,
L
Linus Torvalds 已提交
2600 2601 2602 2603 2604
					device_unblock);
	return 0;
}

void
2605
scsi_target_unblock(struct device *dev, enum scsi_device_state new_state)
L
Linus Torvalds 已提交
2606 2607
{
	if (scsi_is_target_device(dev))
2608
		starget_for_each_device(to_scsi_target(dev), &new_state,
L
Linus Torvalds 已提交
2609 2610
					device_unblock);
	else
2611
		device_for_each_child(dev, &new_state, target_unblock);
L
Linus Torvalds 已提交
2612 2613
}
EXPORT_SYMBOL_GPL(scsi_target_unblock);
2614 2615 2616

/**
 * scsi_kmap_atomic_sg - find and atomically map an sg-elemnt
2617
 * @sgl:	scatter-gather list
2618 2619 2620 2621 2622 2623
 * @sg_count:	number of segments in sg
 * @offset:	offset in bytes into sg, on return offset into the mapped area
 * @len:	bytes to map, on return number of bytes mapped
 *
 * Returns virtual address of the start of the mapped page
 */
J
Jens Axboe 已提交
2624
void *scsi_kmap_atomic_sg(struct scatterlist *sgl, int sg_count,
2625 2626 2627 2628
			  size_t *offset, size_t *len)
{
	int i;
	size_t sg_len = 0, len_complete = 0;
J
Jens Axboe 已提交
2629
	struct scatterlist *sg;
2630 2631
	struct page *page;

2632 2633
	WARN_ON(!irqs_disabled());

J
Jens Axboe 已提交
2634
	for_each_sg(sgl, sg, sg_count, i) {
2635
		len_complete = sg_len; /* Complete sg-entries */
J
Jens Axboe 已提交
2636
		sg_len += sg->length;
2637 2638 2639 2640 2641
		if (sg_len > *offset)
			break;
	}

	if (unlikely(i == sg_count)) {
2642 2643
		printk(KERN_ERR "%s: Bytes in sg: %zu, requested offset %zu, "
			"elements %d\n",
2644
		       __func__, sg_len, *offset, sg_count);
2645 2646 2647 2648 2649
		WARN_ON(1);
		return NULL;
	}

	/* Offset starting from the beginning of first page in this sg-entry */
J
Jens Axboe 已提交
2650
	*offset = *offset - len_complete + sg->offset;
2651 2652

	/* Assumption: contiguous pages can be accessed as "page + i" */
J
Jens Axboe 已提交
2653
	page = nth_page(sg_page(sg), (*offset >> PAGE_SHIFT));
2654 2655 2656 2657 2658 2659 2660
	*offset &= ~PAGE_MASK;

	/* Bytes in this sg-entry from *offset to the end of the page */
	sg_len = PAGE_SIZE - *offset;
	if (*len > sg_len)
		*len = sg_len;

2661
	return kmap_atomic(page);
2662 2663 2664 2665
}
EXPORT_SYMBOL(scsi_kmap_atomic_sg);

/**
2666
 * scsi_kunmap_atomic_sg - atomically unmap a virtual address, previously mapped with scsi_kmap_atomic_sg
2667 2668 2669 2670
 * @virt:	virtual address to be unmapped
 */
void scsi_kunmap_atomic_sg(void *virt)
{
2671
	kunmap_atomic(virt);
2672 2673
}
EXPORT_SYMBOL(scsi_kunmap_atomic_sg);
2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687

void sdev_disable_disk_events(struct scsi_device *sdev)
{
	atomic_inc(&sdev->disk_events_disable_depth);
}
EXPORT_SYMBOL(sdev_disable_disk_events);

void sdev_enable_disk_events(struct scsi_device *sdev)
{
	if (WARN_ON_ONCE(atomic_read(&sdev->disk_events_disable_depth) <= 0))
		return;
	atomic_dec(&sdev->disk_events_disable_depth);
}
EXPORT_SYMBOL(sdev_enable_disk_events);