xref: /openbmc/linux/drivers/scsi/scsi.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
2  *  scsi.c Copyright (C) 1992 Drew Eckhardt
3  *         Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
4  *         Copyright (C) 2002, 2003 Christoph Hellwig
5  *
6  *  generic mid-level SCSI driver
7  *      Initial versions: Drew Eckhardt
8  *      Subsequent revisions: Eric Youngdale
9  *
10  *  <drew@colorado.edu>
11  *
12  *  Bug correction thanks go to :
13  *      Rik Faith <faith@cs.unc.edu>
14  *      Tommy Thorn <tthorn>
15  *      Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
16  *
17  *  Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
18  *  add scatter-gather, multiple outstanding request, and other
19  *  enhancements.
20  *
21  *  Native multichannel, wide scsi, /proc/scsi and hot plugging
22  *  support added by Michael Neuffer <mike@i-connect.net>
23  *
24  *  Added request_module("scsi_hostadapter") for kerneld:
25  *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
26  *  Bjorn Ekwall  <bj0rn@blox.se>
27  *  (changed to kmod)
28  *
29  *  Major improvements to the timeout, abort, and reset processing,
30  *  as well as performance modifications for large queue depths by
31  *  Leonard N. Zubkoff <lnz@dandelion.com>
32  *
33  *  Converted cli() code to spinlocks, Ingo Molnar
34  *
35  *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
36  *
37  *  out_of_space hacks, D. Gilbert (dpg) 990608
38  */
39 
40 #include <linux/module.h>
41 #include <linux/moduleparam.h>
42 #include <linux/kernel.h>
43 #include <linux/timer.h>
44 #include <linux/string.h>
45 #include <linux/slab.h>
46 #include <linux/blkdev.h>
47 #include <linux/delay.h>
48 #include <linux/init.h>
49 #include <linux/completion.h>
50 #include <linux/unistd.h>
51 #include <linux/spinlock.h>
52 #include <linux/kmod.h>
53 #include <linux/interrupt.h>
54 #include <linux/notifier.h>
55 #include <linux/cpu.h>
56 #include <linux/mutex.h>
57 
58 #include <scsi/scsi.h>
59 #include <scsi/scsi_cmnd.h>
60 #include <scsi/scsi_dbg.h>
61 #include <scsi/scsi_device.h>
62 #include <scsi/scsi_eh.h>
63 #include <scsi/scsi_host.h>
64 #include <scsi/scsi_tcq.h>
65 
66 #include "scsi_priv.h"
67 #include "scsi_logging.h"
68 
69 static void scsi_done(struct scsi_cmnd *cmd);
70 
71 /*
72  * Definitions and constants.
73  */
74 
75 #define MIN_RESET_DELAY (2*HZ)
76 
77 /* Do not call reset on error if we just did a reset within 15 sec. */
78 #define MIN_RESET_PERIOD (15*HZ)
79 
80 /*
81  * Macro to determine the size of SCSI command. This macro takes vendor
82  * unique commands into account. SCSI commands in groups 6 and 7 are
83  * vendor unique and we will depend upon the command length being
84  * supplied correctly in cmd_len.
85  */
86 #define CDB_SIZE(cmd)	(((((cmd)->cmnd[0] >> 5) & 7) < 6) ? \
87 				COMMAND_SIZE((cmd)->cmnd[0]) : (cmd)->cmd_len)
88 
89 /*
90  * Note - the initial logging level can be set here to log events at boot time.
91  * After the system is up, you may enable logging via the /proc interface.
92  */
93 unsigned int scsi_logging_level;
94 #if defined(CONFIG_SCSI_LOGGING)
95 EXPORT_SYMBOL(scsi_logging_level);
96 #endif
97 
98 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
99  * You may not alter any existing entry (although adding new ones is
100  * encouraged once assigned by ANSI/INCITS T10
101  */
102 static const char *const scsi_device_types[] = {
103 	"Direct-Access    ",
104 	"Sequential-Access",
105 	"Printer          ",
106 	"Processor        ",
107 	"WORM             ",
108 	"CD-ROM           ",
109 	"Scanner          ",
110 	"Optical Device   ",
111 	"Medium Changer   ",
112 	"Communications   ",
113 	"ASC IT8          ",
114 	"ASC IT8          ",
115 	"RAID             ",
116 	"Enclosure        ",
117 	"Direct-Access-RBC",
118 	"Optical card     ",
119 	"Bridge controller",
120 	"Object storage   ",
121 	"Automation/Drive ",
122 };
123 
124 const char * scsi_device_type(unsigned type)
125 {
126 	if (type == 0x1e)
127 		return "Well-known LUN   ";
128 	if (type == 0x1f)
129 		return "No Device        ";
130 	if (type >= ARRAY_SIZE(scsi_device_types))
131 		return "Unknown          ";
132 	return scsi_device_types[type];
133 }
134 
135 EXPORT_SYMBOL(scsi_device_type);
136 
137 struct scsi_host_cmd_pool {
138 	struct kmem_cache	*slab;
139 	unsigned int	users;
140 	char		*name;
141 	unsigned int	slab_flags;
142 	gfp_t		gfp_mask;
143 };
144 
145 static struct scsi_host_cmd_pool scsi_cmd_pool = {
146 	.name		= "scsi_cmd_cache",
147 	.slab_flags	= SLAB_HWCACHE_ALIGN,
148 };
149 
150 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
151 	.name		= "scsi_cmd_cache(DMA)",
152 	.slab_flags	= SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
153 	.gfp_mask	= __GFP_DMA,
154 };
155 
156 static DEFINE_MUTEX(host_cmd_pool_mutex);
157 
158 struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
159 {
160 	struct scsi_cmnd *cmd;
161 
162 	cmd = kmem_cache_alloc(shost->cmd_pool->slab,
163 			gfp_mask | shost->cmd_pool->gfp_mask);
164 
165 	if (unlikely(!cmd)) {
166 		unsigned long flags;
167 
168 		spin_lock_irqsave(&shost->free_list_lock, flags);
169 		if (likely(!list_empty(&shost->free_list))) {
170 			cmd = list_entry(shost->free_list.next,
171 					 struct scsi_cmnd, list);
172 			list_del_init(&cmd->list);
173 		}
174 		spin_unlock_irqrestore(&shost->free_list_lock, flags);
175 	}
176 
177 	return cmd;
178 }
179 EXPORT_SYMBOL_GPL(__scsi_get_command);
180 
181 /*
182  * Function:	scsi_get_command()
183  *
184  * Purpose:	Allocate and setup a scsi command block
185  *
186  * Arguments:	dev	- parent scsi device
187  *		gfp_mask- allocator flags
188  *
189  * Returns:	The allocated scsi command structure.
190  */
191 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
192 {
193 	struct scsi_cmnd *cmd;
194 
195 	/* Bail if we can't get a reference to the device */
196 	if (!get_device(&dev->sdev_gendev))
197 		return NULL;
198 
199 	cmd = __scsi_get_command(dev->host, gfp_mask);
200 
201 	if (likely(cmd != NULL)) {
202 		unsigned long flags;
203 
204 		memset(cmd, 0, sizeof(*cmd));
205 		cmd->device = dev;
206 		init_timer(&cmd->eh_timeout);
207 		INIT_LIST_HEAD(&cmd->list);
208 		spin_lock_irqsave(&dev->list_lock, flags);
209 		list_add_tail(&cmd->list, &dev->cmd_list);
210 		spin_unlock_irqrestore(&dev->list_lock, flags);
211 		cmd->jiffies_at_alloc = jiffies;
212 	} else
213 		put_device(&dev->sdev_gendev);
214 
215 	return cmd;
216 }
217 EXPORT_SYMBOL(scsi_get_command);
218 
219 void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd,
220 			struct device *dev)
221 {
222 	unsigned long flags;
223 
224 	/* changing locks here, don't need to restore the irq state */
225 	spin_lock_irqsave(&shost->free_list_lock, flags);
226 	if (unlikely(list_empty(&shost->free_list))) {
227 		list_add(&cmd->list, &shost->free_list);
228 		cmd = NULL;
229 	}
230 	spin_unlock_irqrestore(&shost->free_list_lock, flags);
231 
232 	if (likely(cmd != NULL))
233 		kmem_cache_free(shost->cmd_pool->slab, cmd);
234 
235 	put_device(dev);
236 }
237 EXPORT_SYMBOL(__scsi_put_command);
238 
239 /*
240  * Function:	scsi_put_command()
241  *
242  * Purpose:	Free a scsi command block
243  *
244  * Arguments:	cmd	- command block to free
245  *
246  * Returns:	Nothing.
247  *
248  * Notes:	The command must not belong to any lists.
249  */
250 void scsi_put_command(struct scsi_cmnd *cmd)
251 {
252 	struct scsi_device *sdev = cmd->device;
253 	unsigned long flags;
254 
255 	/* serious error if the command hasn't come from a device list */
256 	spin_lock_irqsave(&cmd->device->list_lock, flags);
257 	BUG_ON(list_empty(&cmd->list));
258 	list_del_init(&cmd->list);
259 	spin_unlock_irqrestore(&cmd->device->list_lock, flags);
260 
261 	__scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
262 }
263 EXPORT_SYMBOL(scsi_put_command);
264 
265 /*
266  * Function:	scsi_setup_command_freelist()
267  *
268  * Purpose:	Setup the command freelist for a scsi host.
269  *
270  * Arguments:	shost	- host to allocate the freelist for.
271  *
272  * Returns:	Nothing.
273  */
274 int scsi_setup_command_freelist(struct Scsi_Host *shost)
275 {
276 	struct scsi_host_cmd_pool *pool;
277 	struct scsi_cmnd *cmd;
278 
279 	spin_lock_init(&shost->free_list_lock);
280 	INIT_LIST_HEAD(&shost->free_list);
281 
282 	/*
283 	 * Select a command slab for this host and create it if not
284 	 * yet existant.
285 	 */
286 	mutex_lock(&host_cmd_pool_mutex);
287 	pool = (shost->unchecked_isa_dma ? &scsi_cmd_dma_pool : &scsi_cmd_pool);
288 	if (!pool->users) {
289 		pool->slab = kmem_cache_create(pool->name,
290 				sizeof(struct scsi_cmnd), 0,
291 				pool->slab_flags, NULL, NULL);
292 		if (!pool->slab)
293 			goto fail;
294 	}
295 
296 	pool->users++;
297 	shost->cmd_pool = pool;
298 	mutex_unlock(&host_cmd_pool_mutex);
299 
300 	/*
301 	 * Get one backup command for this host.
302 	 */
303 	cmd = kmem_cache_alloc(shost->cmd_pool->slab,
304 			GFP_KERNEL | shost->cmd_pool->gfp_mask);
305 	if (!cmd)
306 		goto fail2;
307 	list_add(&cmd->list, &shost->free_list);
308 	return 0;
309 
310  fail2:
311 	if (!--pool->users)
312 		kmem_cache_destroy(pool->slab);
313 	return -ENOMEM;
314  fail:
315 	mutex_unlock(&host_cmd_pool_mutex);
316 	return -ENOMEM;
317 
318 }
319 
320 /*
321  * Function:	scsi_destroy_command_freelist()
322  *
323  * Purpose:	Release the command freelist for a scsi host.
324  *
325  * Arguments:	shost	- host that's freelist is going to be destroyed
326  */
327 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
328 {
329 	while (!list_empty(&shost->free_list)) {
330 		struct scsi_cmnd *cmd;
331 
332 		cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
333 		list_del_init(&cmd->list);
334 		kmem_cache_free(shost->cmd_pool->slab, cmd);
335 	}
336 
337 	mutex_lock(&host_cmd_pool_mutex);
338 	if (!--shost->cmd_pool->users)
339 		kmem_cache_destroy(shost->cmd_pool->slab);
340 	mutex_unlock(&host_cmd_pool_mutex);
341 }
342 
343 #ifdef CONFIG_SCSI_LOGGING
344 void scsi_log_send(struct scsi_cmnd *cmd)
345 {
346 	unsigned int level;
347 
348 	/*
349 	 * If ML QUEUE log level is greater than or equal to:
350 	 *
351 	 * 1: nothing (match completion)
352 	 *
353 	 * 2: log opcode + command of all commands
354 	 *
355 	 * 3: same as 2 plus dump cmd address
356 	 *
357 	 * 4: same as 3 plus dump extra junk
358 	 */
359 	if (unlikely(scsi_logging_level)) {
360 		level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
361 				       SCSI_LOG_MLQUEUE_BITS);
362 		if (level > 1) {
363 			scmd_printk(KERN_INFO, cmd, "Send: ");
364 			if (level > 2)
365 				printk("0x%p ", cmd);
366 			printk("\n");
367 			scsi_print_command(cmd);
368 			if (level > 3) {
369 				printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
370 				       " done = 0x%p, queuecommand 0x%p\n",
371 					cmd->request_buffer, cmd->request_bufflen,
372 					cmd->done,
373 					cmd->device->host->hostt->queuecommand);
374 
375 			}
376 		}
377 	}
378 }
379 
380 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
381 {
382 	unsigned int level;
383 
384 	/*
385 	 * If ML COMPLETE log level is greater than or equal to:
386 	 *
387 	 * 1: log disposition, result, opcode + command, and conditionally
388 	 * sense data for failures or non SUCCESS dispositions.
389 	 *
390 	 * 2: same as 1 but for all command completions.
391 	 *
392 	 * 3: same as 2 plus dump cmd address
393 	 *
394 	 * 4: same as 3 plus dump extra junk
395 	 */
396 	if (unlikely(scsi_logging_level)) {
397 		level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
398 				       SCSI_LOG_MLCOMPLETE_BITS);
399 		if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
400 		    (level > 1)) {
401 			scmd_printk(KERN_INFO, cmd, "Done: ");
402 			if (level > 2)
403 				printk("0x%p ", cmd);
404 			/*
405 			 * Dump truncated values, so we usually fit within
406 			 * 80 chars.
407 			 */
408 			switch (disposition) {
409 			case SUCCESS:
410 				printk("SUCCESS\n");
411 				break;
412 			case NEEDS_RETRY:
413 				printk("RETRY\n");
414 				break;
415 			case ADD_TO_MLQUEUE:
416 				printk("MLQUEUE\n");
417 				break;
418 			case FAILED:
419 				printk("FAILED\n");
420 				break;
421 			case TIMEOUT_ERROR:
422 				/*
423 				 * If called via scsi_times_out.
424 				 */
425 				printk("TIMEOUT\n");
426 				break;
427 			default:
428 				printk("UNKNOWN\n");
429 			}
430 			scsi_print_result(cmd);
431 			scsi_print_command(cmd);
432 			if (status_byte(cmd->result) & CHECK_CONDITION)
433 				scsi_print_sense("", cmd);
434 			if (level > 3)
435 				scmd_printk(KERN_INFO, cmd,
436 					    "scsi host busy %d failed %d\n",
437 					    cmd->device->host->host_busy,
438 					    cmd->device->host->host_failed);
439 		}
440 	}
441 }
442 #endif
443 
444 /*
445  * Assign a serial number and pid to the request for error recovery
446  * and debugging purposes.  Protected by the Host_Lock of host.
447  */
448 static inline void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
449 {
450 	cmd->serial_number = host->cmd_serial_number++;
451 	if (cmd->serial_number == 0)
452 		cmd->serial_number = host->cmd_serial_number++;
453 
454 	cmd->pid = host->cmd_pid++;
455 	if (cmd->pid == 0)
456 		cmd->pid = host->cmd_pid++;
457 }
458 
459 /*
460  * Function:    scsi_dispatch_command
461  *
462  * Purpose:     Dispatch a command to the low-level driver.
463  *
464  * Arguments:   cmd - command block we are dispatching.
465  *
466  * Notes:
467  */
468 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
469 {
470 	struct Scsi_Host *host = cmd->device->host;
471 	unsigned long flags = 0;
472 	unsigned long timeout;
473 	int rtn = 0;
474 
475 	/* check if the device is still usable */
476 	if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
477 		/* in SDEV_DEL we error all commands. DID_NO_CONNECT
478 		 * returns an immediate error upwards, and signals
479 		 * that the device is no longer present */
480 		cmd->result = DID_NO_CONNECT << 16;
481 		atomic_inc(&cmd->device->iorequest_cnt);
482 		__scsi_done(cmd);
483 		/* return 0 (because the command has been processed) */
484 		goto out;
485 	}
486 
487 	/* Check to see if the scsi lld put this device into state SDEV_BLOCK. */
488 	if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) {
489 		/*
490 		 * in SDEV_BLOCK, the command is just put back on the device
491 		 * queue.  The suspend state has already blocked the queue so
492 		 * future requests should not occur until the device
493 		 * transitions out of the suspend state.
494 		 */
495 		scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
496 
497 		SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
498 
499 		/*
500 		 * NOTE: rtn is still zero here because we don't need the
501 		 * queue to be plugged on return (it's already stopped)
502 		 */
503 		goto out;
504 	}
505 
506 	/*
507 	 * If SCSI-2 or lower, store the LUN value in cmnd.
508 	 */
509 	if (cmd->device->scsi_level <= SCSI_2 &&
510 	    cmd->device->scsi_level != SCSI_UNKNOWN) {
511 		cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
512 			       (cmd->device->lun << 5 & 0xe0);
513 	}
514 
515 	/*
516 	 * We will wait MIN_RESET_DELAY clock ticks after the last reset so
517 	 * we can avoid the drive not being ready.
518 	 */
519 	timeout = host->last_reset + MIN_RESET_DELAY;
520 
521 	if (host->resetting && time_before(jiffies, timeout)) {
522 		int ticks_remaining = timeout - jiffies;
523 		/*
524 		 * NOTE: This may be executed from within an interrupt
525 		 * handler!  This is bad, but for now, it'll do.  The irq
526 		 * level of the interrupt handler has been masked out by the
527 		 * platform dependent interrupt handling code already, so the
528 		 * sti() here will not cause another call to the SCSI host's
529 		 * interrupt handler (assuming there is one irq-level per
530 		 * host).
531 		 */
532 		while (--ticks_remaining >= 0)
533 			mdelay(1 + 999 / HZ);
534 		host->resetting = 0;
535 	}
536 
537 	/*
538 	 * AK: unlikely race here: for some reason the timer could
539 	 * expire before the serial number is set up below.
540 	 */
541 	scsi_add_timer(cmd, cmd->timeout_per_command, scsi_times_out);
542 
543 	scsi_log_send(cmd);
544 
545 	/*
546 	 * We will use a queued command if possible, otherwise we will
547 	 * emulate the queuing and calling of completion function ourselves.
548 	 */
549 	atomic_inc(&cmd->device->iorequest_cnt);
550 
551 	/*
552 	 * Before we queue this command, check if the command
553 	 * length exceeds what the host adapter can handle.
554 	 */
555 	if (CDB_SIZE(cmd) > cmd->device->host->max_cmd_len) {
556 		SCSI_LOG_MLQUEUE(3,
557 				printk("queuecommand : command too long.\n"));
558 		cmd->result = (DID_ABORT << 16);
559 
560 		scsi_done(cmd);
561 		goto out;
562 	}
563 
564 	spin_lock_irqsave(host->host_lock, flags);
565 	scsi_cmd_get_serial(host, cmd);
566 
567 	if (unlikely(host->shost_state == SHOST_DEL)) {
568 		cmd->result = (DID_NO_CONNECT << 16);
569 		scsi_done(cmd);
570 	} else {
571 		rtn = host->hostt->queuecommand(cmd, scsi_done);
572 	}
573 	spin_unlock_irqrestore(host->host_lock, flags);
574 	if (rtn) {
575 		if (scsi_delete_timer(cmd)) {
576 			atomic_inc(&cmd->device->iodone_cnt);
577 			scsi_queue_insert(cmd,
578 					  (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ?
579 					  rtn : SCSI_MLQUEUE_HOST_BUSY);
580 		}
581 		SCSI_LOG_MLQUEUE(3,
582 		    printk("queuecommand : request rejected\n"));
583 	}
584 
585  out:
586 	SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
587 	return rtn;
588 }
589 
590 /**
591  * scsi_req_abort_cmd -- Request command recovery for the specified command
592  * cmd: pointer to the SCSI command of interest
593  *
594  * This function requests that SCSI Core start recovery for the
595  * command by deleting the timer and adding the command to the eh
596  * queue.  It can be called by either LLDDs or SCSI Core.  LLDDs who
597  * implement their own error recovery MAY ignore the timeout event if
598  * they generated scsi_req_abort_cmd.
599  */
600 void scsi_req_abort_cmd(struct scsi_cmnd *cmd)
601 {
602 	if (!scsi_delete_timer(cmd))
603 		return;
604 	scsi_times_out(cmd);
605 }
606 EXPORT_SYMBOL(scsi_req_abort_cmd);
607 
608 /**
609  * scsi_done - Enqueue the finished SCSI command into the done queue.
610  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
611  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
612  *
613  * This function is the mid-level's (SCSI Core) interrupt routine, which
614  * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues
615  * the command to the done queue for further processing.
616  *
617  * This is the producer of the done queue who enqueues at the tail.
618  *
619  * This function is interrupt context safe.
620  */
621 static void scsi_done(struct scsi_cmnd *cmd)
622 {
623 	/*
624 	 * We don't have to worry about this one timing out any more.
625 	 * If we are unable to remove the timer, then the command
626 	 * has already timed out.  In which case, we have no choice but to
627 	 * let the timeout function run, as we have no idea where in fact
628 	 * that function could really be.  It might be on another processor,
629 	 * etc, etc.
630 	 */
631 	if (!scsi_delete_timer(cmd))
632 		return;
633 	__scsi_done(cmd);
634 }
635 
636 /* Private entry to scsi_done() to complete a command when the timer
637  * isn't running --- used by scsi_times_out */
638 void __scsi_done(struct scsi_cmnd *cmd)
639 {
640 	struct request *rq = cmd->request;
641 
642 	/*
643 	 * Set the serial numbers back to zero
644 	 */
645 	cmd->serial_number = 0;
646 
647 	atomic_inc(&cmd->device->iodone_cnt);
648 	if (cmd->result)
649 		atomic_inc(&cmd->device->ioerr_cnt);
650 
651 	BUG_ON(!rq);
652 
653 	/*
654 	 * The uptodate/nbytes values don't matter, as we allow partial
655 	 * completes and thus will check this in the softirq callback
656 	 */
657 	rq->completion_data = cmd;
658 	blk_complete_request(rq);
659 }
660 
661 /*
662  * Function:    scsi_finish_command
663  *
664  * Purpose:     Pass command off to upper layer for finishing of I/O
665  *              request, waking processes that are waiting on results,
666  *              etc.
667  */
668 void scsi_finish_command(struct scsi_cmnd *cmd)
669 {
670 	struct scsi_device *sdev = cmd->device;
671 	struct Scsi_Host *shost = sdev->host;
672 
673 	scsi_device_unbusy(sdev);
674 
675         /*
676          * Clear the flags which say that the device/host is no longer
677          * capable of accepting new commands.  These are set in scsi_queue.c
678          * for both the queue full condition on a device, and for a
679          * host full condition on the host.
680 	 *
681 	 * XXX(hch): What about locking?
682          */
683         shost->host_blocked = 0;
684         sdev->device_blocked = 0;
685 
686 	/*
687 	 * If we have valid sense information, then some kind of recovery
688 	 * must have taken place.  Make a note of this.
689 	 */
690 	if (SCSI_SENSE_VALID(cmd))
691 		cmd->result |= (DRIVER_SENSE << 24);
692 
693 	SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
694 				"Notifying upper driver of completion "
695 				"(result %x)\n", cmd->result));
696 
697 	cmd->done(cmd);
698 }
699 EXPORT_SYMBOL(scsi_finish_command);
700 
701 /*
702  * Function:	scsi_adjust_queue_depth()
703  *
704  * Purpose:	Allow low level drivers to tell us to change the queue depth
705  * 		on a specific SCSI device
706  *
707  * Arguments:	sdev	- SCSI Device in question
708  * 		tagged	- Do we use tagged queueing (non-0) or do we treat
709  * 			  this device as an untagged device (0)
710  * 		tags	- Number of tags allowed if tagged queueing enabled,
711  * 			  or number of commands the low level driver can
712  * 			  queue up in non-tagged mode (as per cmd_per_lun).
713  *
714  * Returns:	Nothing
715  *
716  * Lock Status:	None held on entry
717  *
718  * Notes:	Low level drivers may call this at any time and we will do
719  * 		the right thing depending on whether or not the device is
720  * 		currently active and whether or not it even has the
721  * 		command blocks built yet.
722  */
723 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
724 {
725 	unsigned long flags;
726 
727 	/*
728 	 * refuse to set tagged depth to an unworkable size
729 	 */
730 	if (tags <= 0)
731 		return;
732 
733 	spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
734 
735 	/* Check to see if the queue is managed by the block layer
736 	 * if it is, and we fail to adjust the depth, exit */
737 	if (blk_queue_tagged(sdev->request_queue) &&
738 	    blk_queue_resize_tags(sdev->request_queue, tags) != 0)
739 		goto out;
740 
741 	sdev->queue_depth = tags;
742 	switch (tagged) {
743 		case MSG_ORDERED_TAG:
744 			sdev->ordered_tags = 1;
745 			sdev->simple_tags = 1;
746 			break;
747 		case MSG_SIMPLE_TAG:
748 			sdev->ordered_tags = 0;
749 			sdev->simple_tags = 1;
750 			break;
751 		default:
752 			sdev_printk(KERN_WARNING, sdev,
753 				    "scsi_adjust_queue_depth, bad queue type, "
754 				    "disabled\n");
755 		case 0:
756 			sdev->ordered_tags = sdev->simple_tags = 0;
757 			sdev->queue_depth = tags;
758 			break;
759 	}
760  out:
761 	spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
762 }
763 EXPORT_SYMBOL(scsi_adjust_queue_depth);
764 
765 /*
766  * Function:	scsi_track_queue_full()
767  *
768  * Purpose:	This function will track successive QUEUE_FULL events on a
769  * 		specific SCSI device to determine if and when there is a
770  * 		need to adjust the queue depth on the device.
771  *
772  * Arguments:	sdev	- SCSI Device in question
773  * 		depth	- Current number of outstanding SCSI commands on
774  * 			  this device, not counting the one returned as
775  * 			  QUEUE_FULL.
776  *
777  * Returns:	0 - No change needed
778  * 		>0 - Adjust queue depth to this new depth
779  * 		-1 - Drop back to untagged operation using host->cmd_per_lun
780  * 			as the untagged command depth
781  *
782  * Lock Status:	None held on entry
783  *
784  * Notes:	Low level drivers may call this at any time and we will do
785  * 		"The Right Thing."  We are interrupt context safe.
786  */
787 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
788 {
789 	if ((jiffies >> 4) == sdev->last_queue_full_time)
790 		return 0;
791 
792 	sdev->last_queue_full_time = (jiffies >> 4);
793 	if (sdev->last_queue_full_depth != depth) {
794 		sdev->last_queue_full_count = 1;
795 		sdev->last_queue_full_depth = depth;
796 	} else {
797 		sdev->last_queue_full_count++;
798 	}
799 
800 	if (sdev->last_queue_full_count <= 10)
801 		return 0;
802 	if (sdev->last_queue_full_depth < 8) {
803 		/* Drop back to untagged */
804 		scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
805 		return -1;
806 	}
807 
808 	if (sdev->ordered_tags)
809 		scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
810 	else
811 		scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
812 	return depth;
813 }
814 EXPORT_SYMBOL(scsi_track_queue_full);
815 
816 /**
817  * scsi_device_get  -  get an addition reference to a scsi_device
818  * @sdev:	device to get a reference to
819  *
820  * Gets a reference to the scsi_device and increments the use count
821  * of the underlying LLDD module.  You must hold host_lock of the
822  * parent Scsi_Host or already have a reference when calling this.
823  */
824 int scsi_device_get(struct scsi_device *sdev)
825 {
826 	if (sdev->sdev_state == SDEV_DEL)
827 		return -ENXIO;
828 	if (!get_device(&sdev->sdev_gendev))
829 		return -ENXIO;
830 	/* We can fail this if we're doing SCSI operations
831 	 * from module exit (like cache flush) */
832 	try_module_get(sdev->host->hostt->module);
833 
834 	return 0;
835 }
836 EXPORT_SYMBOL(scsi_device_get);
837 
838 /**
839  * scsi_device_put  -  release a reference to a scsi_device
840  * @sdev:	device to release a reference on.
841  *
842  * Release a reference to the scsi_device and decrements the use count
843  * of the underlying LLDD module.  The device is freed once the last
844  * user vanishes.
845  */
846 void scsi_device_put(struct scsi_device *sdev)
847 {
848 #ifdef CONFIG_MODULE_UNLOAD
849 	struct module *module = sdev->host->hostt->module;
850 
851 	/* The module refcount will be zero if scsi_device_get()
852 	 * was called from a module removal routine */
853 	if (module && module_refcount(module) != 0)
854 		module_put(module);
855 #endif
856 	put_device(&sdev->sdev_gendev);
857 }
858 EXPORT_SYMBOL(scsi_device_put);
859 
860 /* helper for shost_for_each_device, thus not documented */
861 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
862 					   struct scsi_device *prev)
863 {
864 	struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
865 	struct scsi_device *next = NULL;
866 	unsigned long flags;
867 
868 	spin_lock_irqsave(shost->host_lock, flags);
869 	while (list->next != &shost->__devices) {
870 		next = list_entry(list->next, struct scsi_device, siblings);
871 		/* skip devices that we can't get a reference to */
872 		if (!scsi_device_get(next))
873 			break;
874 		next = NULL;
875 		list = list->next;
876 	}
877 	spin_unlock_irqrestore(shost->host_lock, flags);
878 
879 	if (prev)
880 		scsi_device_put(prev);
881 	return next;
882 }
883 EXPORT_SYMBOL(__scsi_iterate_devices);
884 
885 /**
886  * starget_for_each_device  -  helper to walk all devices of a target
887  * @starget:	target whose devices we want to iterate over.
888  *
889  * This traverses over each devices of @shost.  The devices have
890  * a reference that must be released by scsi_host_put when breaking
891  * out of the loop.
892  */
893 void starget_for_each_device(struct scsi_target *starget, void * data,
894 		     void (*fn)(struct scsi_device *, void *))
895 {
896 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
897 	struct scsi_device *sdev;
898 
899 	shost_for_each_device(sdev, shost) {
900 		if ((sdev->channel == starget->channel) &&
901 		    (sdev->id == starget->id))
902 			fn(sdev, data);
903 	}
904 }
905 EXPORT_SYMBOL(starget_for_each_device);
906 
907 /**
908  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
909  * @starget:	SCSI target pointer
910  * @lun:	SCSI Logical Unit Number
911  *
912  * Looks up the scsi_device with the specified @lun for a give
913  * @starget. The returned scsi_device does not have an additional
914  * reference.  You must hold the host's host_lock over this call and
915  * any access to the returned scsi_device.
916  *
917  * Note:  The only reason why drivers would want to use this is because
918  * they're need to access the device list in irq context.  Otherwise you
919  * really want to use scsi_device_lookup_by_target instead.
920  **/
921 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
922 						   uint lun)
923 {
924 	struct scsi_device *sdev;
925 
926 	list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
927 		if (sdev->lun ==lun)
928 			return sdev;
929 	}
930 
931 	return NULL;
932 }
933 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
934 
935 /**
936  * scsi_device_lookup_by_target - find a device given the target
937  * @starget:	SCSI target pointer
938  * @lun:	SCSI Logical Unit Number
939  *
940  * Looks up the scsi_device with the specified @channel, @id, @lun for a
941  * give host.  The returned scsi_device has an additional reference that
942  * needs to be release with scsi_host_put once you're done with it.
943  **/
944 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
945 						 uint lun)
946 {
947 	struct scsi_device *sdev;
948 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
949 	unsigned long flags;
950 
951 	spin_lock_irqsave(shost->host_lock, flags);
952 	sdev = __scsi_device_lookup_by_target(starget, lun);
953 	if (sdev && scsi_device_get(sdev))
954 		sdev = NULL;
955 	spin_unlock_irqrestore(shost->host_lock, flags);
956 
957 	return sdev;
958 }
959 EXPORT_SYMBOL(scsi_device_lookup_by_target);
960 
961 /**
962  * scsi_device_lookup - find a device given the host (UNLOCKED)
963  * @shost:	SCSI host pointer
964  * @channel:	SCSI channel (zero if only one channel)
965  * @pun:	SCSI target number (physical unit number)
966  * @lun:	SCSI Logical Unit Number
967  *
968  * Looks up the scsi_device with the specified @channel, @id, @lun for a
969  * give host. The returned scsi_device does not have an additional reference.
970  * You must hold the host's host_lock over this call and any access to the
971  * returned scsi_device.
972  *
973  * Note:  The only reason why drivers would want to use this is because
974  * they're need to access the device list in irq context.  Otherwise you
975  * really want to use scsi_device_lookup instead.
976  **/
977 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
978 		uint channel, uint id, uint lun)
979 {
980 	struct scsi_device *sdev;
981 
982 	list_for_each_entry(sdev, &shost->__devices, siblings) {
983 		if (sdev->channel == channel && sdev->id == id &&
984 				sdev->lun ==lun)
985 			return sdev;
986 	}
987 
988 	return NULL;
989 }
990 EXPORT_SYMBOL(__scsi_device_lookup);
991 
992 /**
993  * scsi_device_lookup - find a device given the host
994  * @shost:	SCSI host pointer
995  * @channel:	SCSI channel (zero if only one channel)
996  * @id:		SCSI target number (physical unit number)
997  * @lun:	SCSI Logical Unit Number
998  *
999  * Looks up the scsi_device with the specified @channel, @id, @lun for a
1000  * give host.  The returned scsi_device has an additional reference that
1001  * needs to be release with scsi_host_put once you're done with it.
1002  **/
1003 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1004 		uint channel, uint id, uint lun)
1005 {
1006 	struct scsi_device *sdev;
1007 	unsigned long flags;
1008 
1009 	spin_lock_irqsave(shost->host_lock, flags);
1010 	sdev = __scsi_device_lookup(shost, channel, id, lun);
1011 	if (sdev && scsi_device_get(sdev))
1012 		sdev = NULL;
1013 	spin_unlock_irqrestore(shost->host_lock, flags);
1014 
1015 	return sdev;
1016 }
1017 EXPORT_SYMBOL(scsi_device_lookup);
1018 
1019 /**
1020  * scsi_device_cancel - cancel outstanding IO to this device
1021  * @sdev:	Pointer to struct scsi_device
1022  * @recovery:	Boolean instructing function to recover device or not.
1023  *
1024  **/
1025 int scsi_device_cancel(struct scsi_device *sdev, int recovery)
1026 {
1027 	struct scsi_cmnd *scmd;
1028 	LIST_HEAD(active_list);
1029 	struct list_head *lh, *lh_sf;
1030 	unsigned long flags;
1031 
1032 	scsi_device_set_state(sdev, SDEV_CANCEL);
1033 
1034 	spin_lock_irqsave(&sdev->list_lock, flags);
1035 	list_for_each_entry(scmd, &sdev->cmd_list, list) {
1036 		if (scmd->request) {
1037 			/*
1038 			 * If we are unable to remove the timer, it means
1039 			 * that the command has already timed out or
1040 			 * finished.
1041 			 */
1042 			if (!scsi_delete_timer(scmd))
1043 				continue;
1044 			list_add_tail(&scmd->eh_entry, &active_list);
1045 		}
1046 	}
1047 	spin_unlock_irqrestore(&sdev->list_lock, flags);
1048 
1049 	if (!list_empty(&active_list)) {
1050 		list_for_each_safe(lh, lh_sf, &active_list) {
1051 			scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
1052 			list_del_init(lh);
1053 			if (recovery &&
1054 			    !scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD)) {
1055 				scmd->result = (DID_ABORT << 16);
1056 				scsi_finish_command(scmd);
1057 			}
1058 		}
1059 	}
1060 
1061 	return 0;
1062 }
1063 EXPORT_SYMBOL(scsi_device_cancel);
1064 
1065 MODULE_DESCRIPTION("SCSI core");
1066 MODULE_LICENSE("GPL");
1067 
1068 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1069 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1070 
1071 static int __init init_scsi(void)
1072 {
1073 	int error;
1074 
1075 	error = scsi_init_queue();
1076 	if (error)
1077 		return error;
1078 	error = scsi_init_procfs();
1079 	if (error)
1080 		goto cleanup_queue;
1081 	error = scsi_init_devinfo();
1082 	if (error)
1083 		goto cleanup_procfs;
1084 	error = scsi_init_hosts();
1085 	if (error)
1086 		goto cleanup_devlist;
1087 	error = scsi_init_sysctl();
1088 	if (error)
1089 		goto cleanup_hosts;
1090 	error = scsi_sysfs_register();
1091 	if (error)
1092 		goto cleanup_sysctl;
1093 
1094 	scsi_netlink_init();
1095 
1096 	printk(KERN_NOTICE "SCSI subsystem initialized\n");
1097 	return 0;
1098 
1099 cleanup_sysctl:
1100 	scsi_exit_sysctl();
1101 cleanup_hosts:
1102 	scsi_exit_hosts();
1103 cleanup_devlist:
1104 	scsi_exit_devinfo();
1105 cleanup_procfs:
1106 	scsi_exit_procfs();
1107 cleanup_queue:
1108 	scsi_exit_queue();
1109 	printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1110 	       -error);
1111 	return error;
1112 }
1113 
1114 static void __exit exit_scsi(void)
1115 {
1116 	scsi_netlink_exit();
1117 	scsi_sysfs_unregister();
1118 	scsi_exit_sysctl();
1119 	scsi_exit_hosts();
1120 	scsi_exit_devinfo();
1121 	scsi_exit_procfs();
1122 	scsi_exit_queue();
1123 }
1124 
1125 subsys_initcall(init_scsi);
1126 module_exit(exit_scsi);
1127