2 * scsi.c Copyright (C) 1992 Drew Eckhardt
3 * Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
4 * Copyright (C) 2002, 2003 Christoph Hellwig
6 * generic mid-level SCSI driver
7 * Initial versions: Drew Eckhardt
8 * Subsequent revisions: Eric Youngdale
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>
17 * Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
18 * add scatter-gather, multiple outstanding request, and other
21 * Native multichannel, wide scsi, /proc/scsi and hot plugging
22 * support added by Michael Neuffer <mike@i-connect.net>
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>
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>
33 * Converted cli() code to spinlocks, Ingo Molnar
35 * Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
37 * out_of_space hacks, D. Gilbert (dpg) 990608
40 #include <linux/module.h>
41 #include <linux/moduleparam.h>
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/timer.h>
45 #include <linux/string.h>
46 #include <linux/slab.h>
47 #include <linux/blkdev.h>
48 #include <linux/delay.h>
49 #include <linux/init.h>
50 #include <linux/completion.h>
51 #include <linux/devfs_fs_kernel.h>
52 #include <linux/unistd.h>
53 #include <linux/spinlock.h>
54 #include <linux/kmod.h>
55 #include <linux/interrupt.h>
56 #include <linux/notifier.h>
57 #include <linux/cpu.h>
59 #include <scsi/scsi.h>
60 #include <scsi/scsi_cmnd.h>
61 #include <scsi/scsi_dbg.h>
62 #include <scsi/scsi_device.h>
63 #include <scsi/scsi_eh.h>
64 #include <scsi/scsi_host.h>
65 #include <scsi/scsi_tcq.h>
66 #include <scsi/scsi_request.h>
68 #include "scsi_priv.h"
69 #include "scsi_logging.h"
71 static void scsi_done(struct scsi_cmnd
*cmd
);
72 static int scsi_retry_command(struct scsi_cmnd
*cmd
);
75 * Definitions and constants.
78 #define MIN_RESET_DELAY (2*HZ)
80 /* Do not call reset on error if we just did a reset within 15 sec. */
81 #define MIN_RESET_PERIOD (15*HZ)
84 * Macro to determine the size of SCSI command. This macro takes vendor
85 * unique commands into account. SCSI commands in groups 6 and 7 are
86 * vendor unique and we will depend upon the command length being
87 * supplied correctly in cmd_len.
89 #define CDB_SIZE(cmd) (((((cmd)->cmnd[0] >> 5) & 7) < 6) ? \
90 COMMAND_SIZE((cmd)->cmnd[0]) : (cmd)->cmd_len)
93 * Note - the initial logging level can be set here to log events at boot time.
94 * After the system is up, you may enable logging via the /proc interface.
96 unsigned int scsi_logging_level
;
97 #if defined(CONFIG_SCSI_LOGGING)
98 EXPORT_SYMBOL(scsi_logging_level
);
101 const char *const scsi_device_types
[MAX_SCSI_DEVICE_CODE
] = {
117 EXPORT_SYMBOL(scsi_device_types
);
120 * Function: scsi_allocate_request
122 * Purpose: Allocate a request descriptor.
124 * Arguments: device - device for which we want a request
125 * gfp_mask - allocation flags passed to kmalloc
127 * Lock status: No locks assumed to be held. This function is SMP-safe.
129 * Returns: Pointer to request block.
131 struct scsi_request
*scsi_allocate_request(struct scsi_device
*sdev
,
134 const int offset
= ALIGN(sizeof(struct scsi_request
), 4);
135 const int size
= offset
+ sizeof(struct request
);
136 struct scsi_request
*sreq
;
138 sreq
= kmalloc(size
, gfp_mask
);
139 if (likely(sreq
!= NULL
)) {
140 memset(sreq
, 0, size
);
141 sreq
->sr_request
= (struct request
*)(((char *)sreq
) + offset
);
142 sreq
->sr_device
= sdev
;
143 sreq
->sr_host
= sdev
->host
;
144 sreq
->sr_magic
= SCSI_REQ_MAGIC
;
145 sreq
->sr_data_direction
= DMA_BIDIRECTIONAL
;
150 EXPORT_SYMBOL(scsi_allocate_request
);
152 void __scsi_release_request(struct scsi_request
*sreq
)
154 struct request
*req
= sreq
->sr_request
;
156 /* unlikely because the tag was usually ended earlier by the
157 * mid-layer. However, for layering reasons ULD's don't end
158 * the tag of commands they generate. */
159 if (unlikely(blk_rq_tagged(req
))) {
161 struct request_queue
*q
= req
->q
;
163 spin_lock_irqsave(q
->queue_lock
, flags
);
164 blk_queue_end_tag(q
, req
);
165 spin_unlock_irqrestore(q
->queue_lock
, flags
);
169 if (likely(sreq
->sr_command
!= NULL
)) {
170 struct scsi_cmnd
*cmd
= sreq
->sr_command
;
172 sreq
->sr_command
= NULL
;
173 scsi_next_command(cmd
);
178 * Function: scsi_release_request
180 * Purpose: Release a request descriptor.
182 * Arguments: sreq - request to release
184 * Lock status: No locks assumed to be held. This function is SMP-safe.
186 void scsi_release_request(struct scsi_request
*sreq
)
188 __scsi_release_request(sreq
);
191 EXPORT_SYMBOL(scsi_release_request
);
193 struct scsi_host_cmd_pool
{
197 unsigned int slab_flags
;
198 unsigned int gfp_mask
;
201 static struct scsi_host_cmd_pool scsi_cmd_pool
= {
202 .name
= "scsi_cmd_cache",
203 .slab_flags
= SLAB_HWCACHE_ALIGN
,
206 static struct scsi_host_cmd_pool scsi_cmd_dma_pool
= {
207 .name
= "scsi_cmd_cache(DMA)",
208 .slab_flags
= SLAB_HWCACHE_ALIGN
|SLAB_CACHE_DMA
,
209 .gfp_mask
= __GFP_DMA
,
212 static DECLARE_MUTEX(host_cmd_pool_mutex
);
214 static struct scsi_cmnd
*__scsi_get_command(struct Scsi_Host
*shost
,
217 struct scsi_cmnd
*cmd
;
219 cmd
= kmem_cache_alloc(shost
->cmd_pool
->slab
,
220 gfp_mask
| shost
->cmd_pool
->gfp_mask
);
222 if (unlikely(!cmd
)) {
225 spin_lock_irqsave(&shost
->free_list_lock
, flags
);
226 if (likely(!list_empty(&shost
->free_list
))) {
227 cmd
= list_entry(shost
->free_list
.next
,
228 struct scsi_cmnd
, list
);
229 list_del_init(&cmd
->list
);
231 spin_unlock_irqrestore(&shost
->free_list_lock
, flags
);
238 * Function: scsi_get_command()
240 * Purpose: Allocate and setup a scsi command block
242 * Arguments: dev - parent scsi device
243 * gfp_mask- allocator flags
245 * Returns: The allocated scsi command structure.
247 struct scsi_cmnd
*scsi_get_command(struct scsi_device
*dev
, int gfp_mask
)
249 struct scsi_cmnd
*cmd
;
251 /* Bail if we can't get a reference to the device */
252 if (!get_device(&dev
->sdev_gendev
))
255 cmd
= __scsi_get_command(dev
->host
, gfp_mask
);
257 if (likely(cmd
!= NULL
)) {
260 memset(cmd
, 0, sizeof(*cmd
));
262 cmd
->state
= SCSI_STATE_UNUSED
;
263 init_timer(&cmd
->eh_timeout
);
264 INIT_LIST_HEAD(&cmd
->list
);
265 spin_lock_irqsave(&dev
->list_lock
, flags
);
266 list_add_tail(&cmd
->list
, &dev
->cmd_list
);
267 spin_unlock_irqrestore(&dev
->list_lock
, flags
);
269 put_device(&dev
->sdev_gendev
);
273 EXPORT_SYMBOL(scsi_get_command
);
276 * Function: scsi_put_command()
278 * Purpose: Free a scsi command block
280 * Arguments: cmd - command block to free
284 * Notes: The command must not belong to any lists.
286 void scsi_put_command(struct scsi_cmnd
*cmd
)
288 struct scsi_device
*sdev
= cmd
->device
;
289 struct Scsi_Host
*shost
= sdev
->host
;
292 /* serious error if the command hasn't come from a device list */
293 spin_lock_irqsave(&cmd
->device
->list_lock
, flags
);
294 BUG_ON(list_empty(&cmd
->list
));
295 list_del_init(&cmd
->list
);
296 spin_unlock(&cmd
->device
->list_lock
);
297 /* changing locks here, don't need to restore the irq state */
298 spin_lock(&shost
->free_list_lock
);
299 if (unlikely(list_empty(&shost
->free_list
))) {
300 list_add(&cmd
->list
, &shost
->free_list
);
303 spin_unlock_irqrestore(&shost
->free_list_lock
, flags
);
305 if (likely(cmd
!= NULL
))
306 kmem_cache_free(shost
->cmd_pool
->slab
, cmd
);
308 put_device(&sdev
->sdev_gendev
);
310 EXPORT_SYMBOL(scsi_put_command
);
313 * Function: scsi_setup_command_freelist()
315 * Purpose: Setup the command freelist for a scsi host.
317 * Arguments: shost - host to allocate the freelist for.
321 int scsi_setup_command_freelist(struct Scsi_Host
*shost
)
323 struct scsi_host_cmd_pool
*pool
;
324 struct scsi_cmnd
*cmd
;
326 spin_lock_init(&shost
->free_list_lock
);
327 INIT_LIST_HEAD(&shost
->free_list
);
330 * Select a command slab for this host and create it if not
333 down(&host_cmd_pool_mutex
);
334 pool
= (shost
->unchecked_isa_dma
? &scsi_cmd_dma_pool
: &scsi_cmd_pool
);
336 pool
->slab
= kmem_cache_create(pool
->name
,
337 sizeof(struct scsi_cmnd
), 0,
338 pool
->slab_flags
, NULL
, NULL
);
344 shost
->cmd_pool
= pool
;
345 up(&host_cmd_pool_mutex
);
348 * Get one backup command for this host.
350 cmd
= kmem_cache_alloc(shost
->cmd_pool
->slab
,
351 GFP_KERNEL
| shost
->cmd_pool
->gfp_mask
);
354 list_add(&cmd
->list
, &shost
->free_list
);
359 kmem_cache_destroy(pool
->slab
);
362 up(&host_cmd_pool_mutex
);
368 * Function: scsi_destroy_command_freelist()
370 * Purpose: Release the command freelist for a scsi host.
372 * Arguments: shost - host that's freelist is going to be destroyed
374 void scsi_destroy_command_freelist(struct Scsi_Host
*shost
)
376 while (!list_empty(&shost
->free_list
)) {
377 struct scsi_cmnd
*cmd
;
379 cmd
= list_entry(shost
->free_list
.next
, struct scsi_cmnd
, list
);
380 list_del_init(&cmd
->list
);
381 kmem_cache_free(shost
->cmd_pool
->slab
, cmd
);
384 down(&host_cmd_pool_mutex
);
385 if (!--shost
->cmd_pool
->users
)
386 kmem_cache_destroy(shost
->cmd_pool
->slab
);
387 up(&host_cmd_pool_mutex
);
390 #ifdef CONFIG_SCSI_LOGGING
391 void scsi_log_send(struct scsi_cmnd
*cmd
)
394 struct scsi_device
*sdev
;
397 * If ML QUEUE log level is greater than or equal to:
399 * 1: nothing (match completion)
401 * 2: log opcode + command of all commands
403 * 3: same as 2 plus dump cmd address
405 * 4: same as 3 plus dump extra junk
407 if (unlikely(scsi_logging_level
)) {
408 level
= SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT
,
409 SCSI_LOG_MLQUEUE_BITS
);
412 printk(KERN_INFO
"scsi <%d:%d:%d:%d> send ",
413 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
,
416 printk("0x%p ", cmd
);
418 * spaces to match disposition and cmd->result
419 * output in scsi_log_completion.
422 scsi_print_command(cmd
);
424 printk(KERN_INFO
"buffer = 0x%p, bufflen = %d,"
425 " done = 0x%p, queuecommand 0x%p\n",
426 cmd
->buffer
, cmd
->bufflen
,
428 sdev
->host
->hostt
->queuecommand
);
435 void scsi_log_completion(struct scsi_cmnd
*cmd
, int disposition
)
438 struct scsi_device
*sdev
;
441 * If ML COMPLETE log level is greater than or equal to:
443 * 1: log disposition, result, opcode + command, and conditionally
444 * sense data for failures or non SUCCESS dispositions.
446 * 2: same as 1 but for all command completions.
448 * 3: same as 2 plus dump cmd address
450 * 4: same as 3 plus dump extra junk
452 if (unlikely(scsi_logging_level
)) {
453 level
= SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT
,
454 SCSI_LOG_MLCOMPLETE_BITS
);
455 if (((level
> 0) && (cmd
->result
|| disposition
!= SUCCESS
)) ||
458 printk(KERN_INFO
"scsi <%d:%d:%d:%d> done ",
459 sdev
->host
->host_no
, sdev
->channel
, sdev
->id
,
462 printk("0x%p ", cmd
);
464 * Dump truncated values, so we usually fit within
467 switch (disposition
) {
482 * If called via scsi_times_out.
489 printk(" %8x ", cmd
->result
);
490 scsi_print_command(cmd
);
491 if (status_byte(cmd
->result
) & CHECK_CONDITION
) {
493 * XXX The scsi_print_sense formatting/prefix
494 * doesn't match this function.
496 scsi_print_sense("", cmd
);
499 printk(KERN_INFO
"scsi host busy %d failed %d\n",
500 sdev
->host
->host_busy
,
501 sdev
->host
->host_failed
);
509 * Assign a serial number and pid to the request for error recovery
510 * and debugging purposes. Protected by the Host_Lock of host.
512 static inline void scsi_cmd_get_serial(struct Scsi_Host
*host
, struct scsi_cmnd
*cmd
)
514 cmd
->serial_number
= host
->cmd_serial_number
++;
515 if (cmd
->serial_number
== 0)
516 cmd
->serial_number
= host
->cmd_serial_number
++;
518 cmd
->pid
= host
->cmd_pid
++;
520 cmd
->pid
= host
->cmd_pid
++;
524 * Function: scsi_dispatch_command
526 * Purpose: Dispatch a command to the low-level driver.
528 * Arguments: cmd - command block we are dispatching.
532 int scsi_dispatch_cmd(struct scsi_cmnd
*cmd
)
534 struct Scsi_Host
*host
= cmd
->device
->host
;
535 unsigned long flags
= 0;
536 unsigned long timeout
;
539 /* check if the device is still usable */
540 if (unlikely(cmd
->device
->sdev_state
== SDEV_DEL
)) {
541 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
542 * returns an immediate error upwards, and signals
543 * that the device is no longer present */
544 cmd
->result
= DID_NO_CONNECT
<< 16;
545 atomic_inc(&cmd
->device
->iorequest_cnt
);
547 /* return 0 (because the command has been processed) */
551 /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */
552 if (unlikely(cmd
->device
->sdev_state
== SDEV_BLOCK
)) {
554 * in SDEV_BLOCK, the command is just put back on the device
555 * queue. The suspend state has already blocked the queue so
556 * future requests should not occur until the device
557 * transitions out of the suspend state.
559 scsi_queue_insert(cmd
, SCSI_MLQUEUE_DEVICE_BUSY
);
561 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
564 * NOTE: rtn is still zero here because we don't need the
565 * queue to be plugged on return (it's already stopped)
571 * If SCSI-2 or lower, store the LUN value in cmnd.
573 if (cmd
->device
->scsi_level
<= SCSI_2
) {
574 cmd
->cmnd
[1] = (cmd
->cmnd
[1] & 0x1f) |
575 (cmd
->device
->lun
<< 5 & 0xe0);
579 * We will wait MIN_RESET_DELAY clock ticks after the last reset so
580 * we can avoid the drive not being ready.
582 timeout
= host
->last_reset
+ MIN_RESET_DELAY
;
584 if (host
->resetting
&& time_before(jiffies
, timeout
)) {
585 int ticks_remaining
= timeout
- jiffies
;
587 * NOTE: This may be executed from within an interrupt
588 * handler! This is bad, but for now, it'll do. The irq
589 * level of the interrupt handler has been masked out by the
590 * platform dependent interrupt handling code already, so the
591 * sti() here will not cause another call to the SCSI host's
592 * interrupt handler (assuming there is one irq-level per
595 while (--ticks_remaining
>= 0)
596 mdelay(1 + 999 / HZ
);
601 * AK: unlikely race here: for some reason the timer could
602 * expire before the serial number is set up below.
604 scsi_add_timer(cmd
, cmd
->timeout_per_command
, scsi_times_out
);
609 * We will use a queued command if possible, otherwise we will
610 * emulate the queuing and calling of completion function ourselves.
613 cmd
->state
= SCSI_STATE_QUEUED
;
615 atomic_inc(&cmd
->device
->iorequest_cnt
);
618 * Before we queue this command, check if the command
619 * length exceeds what the host adapter can handle.
621 if (CDB_SIZE(cmd
) > cmd
->device
->host
->max_cmd_len
) {
623 printk("queuecommand : command too long.\n"));
624 cmd
->result
= (DID_ABORT
<< 16);
630 spin_lock_irqsave(host
->host_lock
, flags
);
631 scsi_cmd_get_serial(host
, cmd
);
633 if (unlikely(test_bit(SHOST_CANCEL
, &host
->shost_state
))) {
634 cmd
->result
= (DID_NO_CONNECT
<< 16);
637 rtn
= host
->hostt
->queuecommand(cmd
, scsi_done
);
639 spin_unlock_irqrestore(host
->host_lock
, flags
);
641 if (scsi_delete_timer(cmd
)) {
642 atomic_inc(&cmd
->device
->iodone_cnt
);
643 scsi_queue_insert(cmd
,
644 (rtn
== SCSI_MLQUEUE_DEVICE_BUSY
) ?
645 rtn
: SCSI_MLQUEUE_HOST_BUSY
);
648 printk("queuecommand : request rejected\n"));
652 SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
657 * Function: scsi_init_cmd_from_req
659 * Purpose: Queue a SCSI command
660 * Purpose: Initialize a struct scsi_cmnd from a struct scsi_request
662 * Arguments: cmd - command descriptor.
663 * sreq - Request from the queue.
665 * Lock status: None needed.
669 * Notes: Mainly transfer data from the request structure to the
670 * command structure. The request structure is allocated
671 * using the normal memory allocator, and requests can pile
672 * up to more or less any depth. The command structure represents
673 * a consumable resource, as these are allocated into a pool
674 * when the SCSI subsystem initializes. The preallocation is
675 * required so that in low-memory situations a disk I/O request
676 * won't cause the memory manager to try and write out a page.
677 * The request structure is generally used by ioctls and character
680 void scsi_init_cmd_from_req(struct scsi_cmnd
*cmd
, struct scsi_request
*sreq
)
682 sreq
->sr_command
= cmd
;
684 cmd
->cmd_len
= sreq
->sr_cmd_len
;
685 cmd
->use_sg
= sreq
->sr_use_sg
;
687 cmd
->request
= sreq
->sr_request
;
688 memcpy(cmd
->data_cmnd
, sreq
->sr_cmnd
, sizeof(cmd
->data_cmnd
));
689 cmd
->serial_number
= 0;
690 cmd
->bufflen
= sreq
->sr_bufflen
;
691 cmd
->buffer
= sreq
->sr_buffer
;
693 cmd
->allowed
= sreq
->sr_allowed
;
694 cmd
->done
= sreq
->sr_done
;
695 cmd
->timeout_per_command
= sreq
->sr_timeout_per_command
;
696 cmd
->sc_data_direction
= sreq
->sr_data_direction
;
697 cmd
->sglist_len
= sreq
->sr_sglist_len
;
698 cmd
->underflow
= sreq
->sr_underflow
;
699 cmd
->sc_request
= sreq
;
700 memcpy(cmd
->cmnd
, sreq
->sr_cmnd
, sizeof(sreq
->sr_cmnd
));
703 * Zero the sense buffer. Some host adapters automatically request
704 * sense on error. 0 is not a valid sense code.
706 memset(cmd
->sense_buffer
, 0, sizeof(sreq
->sr_sense_buffer
));
707 cmd
->request_buffer
= sreq
->sr_buffer
;
708 cmd
->request_bufflen
= sreq
->sr_bufflen
;
709 cmd
->old_use_sg
= cmd
->use_sg
;
710 if (cmd
->cmd_len
== 0)
711 cmd
->cmd_len
= COMMAND_SIZE(cmd
->cmnd
[0]);
712 cmd
->old_cmd_len
= cmd
->cmd_len
;
713 cmd
->sc_old_data_direction
= cmd
->sc_data_direction
;
714 cmd
->old_underflow
= cmd
->underflow
;
717 * Start the timer ticking.
721 SCSI_LOG_MLQUEUE(3, printk("Leaving scsi_init_cmd_from_req()\n"));
725 * Per-CPU I/O completion queue.
727 static DEFINE_PER_CPU(struct list_head
, scsi_done_q
);
730 * scsi_done - Enqueue the finished SCSI command into the done queue.
731 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
732 * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
734 * This function is the mid-level's (SCSI Core) interrupt routine, which
735 * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues
736 * the command to the done queue for further processing.
738 * This is the producer of the done queue who enqueues at the tail.
740 * This function is interrupt context safe.
742 static void scsi_done(struct scsi_cmnd
*cmd
)
745 * We don't have to worry about this one timing out any more.
746 * If we are unable to remove the timer, then the command
747 * has already timed out. In which case, we have no choice but to
748 * let the timeout function run, as we have no idea where in fact
749 * that function could really be. It might be on another processor,
752 if (!scsi_delete_timer(cmd
))
757 /* Private entry to scsi_done() to complete a command when the timer
758 * isn't running --- used by scsi_times_out */
759 void __scsi_done(struct scsi_cmnd
*cmd
)
764 * Set the serial numbers back to zero
766 cmd
->serial_number
= 0;
767 cmd
->state
= SCSI_STATE_BHQUEUE
;
769 atomic_inc(&cmd
->device
->iodone_cnt
);
771 atomic_inc(&cmd
->device
->ioerr_cnt
);
774 * Next, enqueue the command into the done queue.
775 * It is a per-CPU queue, so we just disable local interrupts
776 * and need no spinlock.
778 local_irq_save(flags
);
779 list_add_tail(&cmd
->eh_entry
, &__get_cpu_var(scsi_done_q
));
780 raise_softirq_irqoff(SCSI_SOFTIRQ
);
781 local_irq_restore(flags
);
785 * scsi_softirq - Perform post-interrupt processing of finished SCSI commands.
787 * This is the consumer of the done queue.
789 * This is called with all interrupts enabled. This should reduce
790 * interrupt latency, stack depth, and reentrancy of the low-level
793 static void scsi_softirq(struct softirq_action
*h
)
799 list_splice_init(&__get_cpu_var(scsi_done_q
), &local_q
);
802 while (!list_empty(&local_q
)) {
803 struct scsi_cmnd
*cmd
= list_entry(local_q
.next
,
804 struct scsi_cmnd
, eh_entry
);
805 list_del_init(&cmd
->eh_entry
);
807 disposition
= scsi_decide_disposition(cmd
);
808 scsi_log_completion(cmd
, disposition
);
809 switch (disposition
) {
811 scsi_finish_command(cmd
);
814 scsi_retry_command(cmd
);
817 scsi_queue_insert(cmd
, SCSI_MLQUEUE_DEVICE_BUSY
);
820 if (!scsi_eh_scmd_add(cmd
, 0))
821 scsi_finish_command(cmd
);
827 * Function: scsi_retry_command
829 * Purpose: Send a command back to the low level to be retried.
831 * Notes: This command is always executed in the context of the
832 * bottom half handler, or the error handler thread. Low
833 * level drivers should not become re-entrant as a result of
836 static int scsi_retry_command(struct scsi_cmnd
*cmd
)
839 * Restore the SCSI command state.
841 scsi_setup_cmd_retry(cmd
);
844 * Zero the sense information from the last time we tried
847 memset(cmd
->sense_buffer
, 0, sizeof(cmd
->sense_buffer
));
849 return scsi_queue_insert(cmd
, SCSI_MLQUEUE_EH_RETRY
);
853 * Function: scsi_finish_command
855 * Purpose: Pass command off to upper layer for finishing of I/O
856 * request, waking processes that are waiting on results,
859 void scsi_finish_command(struct scsi_cmnd
*cmd
)
861 struct scsi_device
*sdev
= cmd
->device
;
862 struct Scsi_Host
*shost
= sdev
->host
;
863 struct scsi_request
*sreq
;
865 scsi_device_unbusy(sdev
);
868 * Clear the flags which say that the device/host is no longer
869 * capable of accepting new commands. These are set in scsi_queue.c
870 * for both the queue full condition on a device, and for a
871 * host full condition on the host.
873 * XXX(hch): What about locking?
875 shost
->host_blocked
= 0;
876 sdev
->device_blocked
= 0;
879 * If we have valid sense information, then some kind of recovery
880 * must have taken place. Make a note of this.
882 if (SCSI_SENSE_VALID(cmd
))
883 cmd
->result
|= (DRIVER_SENSE
<< 24);
885 SCSI_LOG_MLCOMPLETE(4, printk("Notifying upper driver of completion "
886 "for device %d %x\n", sdev
->id
, cmd
->result
));
888 cmd
->state
= SCSI_STATE_FINISHED
;
891 * We can get here with use_sg=0, causing a panic in the upper level
893 cmd
->use_sg
= cmd
->old_use_sg
;
896 * If there is an associated request structure, copy the data over
897 * before we call the completion function.
899 sreq
= cmd
->sc_request
;
901 sreq
->sr_result
= sreq
->sr_command
->result
;
902 if (sreq
->sr_result
) {
903 memcpy(sreq
->sr_sense_buffer
,
904 sreq
->sr_command
->sense_buffer
,
905 sizeof(sreq
->sr_sense_buffer
));
911 EXPORT_SYMBOL(scsi_finish_command
);
914 * Function: scsi_adjust_queue_depth()
916 * Purpose: Allow low level drivers to tell us to change the queue depth
917 * on a specific SCSI device
919 * Arguments: sdev - SCSI Device in question
920 * tagged - Do we use tagged queueing (non-0) or do we treat
921 * this device as an untagged device (0)
922 * tags - Number of tags allowed if tagged queueing enabled,
923 * or number of commands the low level driver can
924 * queue up in non-tagged mode (as per cmd_per_lun).
928 * Lock Status: None held on entry
930 * Notes: Low level drivers may call this at any time and we will do
931 * the right thing depending on whether or not the device is
932 * currently active and whether or not it even has the
933 * command blocks built yet.
935 void scsi_adjust_queue_depth(struct scsi_device
*sdev
, int tagged
, int tags
)
940 * refuse to set tagged depth to an unworkable size
945 spin_lock_irqsave(sdev
->request_queue
->queue_lock
, flags
);
947 /* Check to see if the queue is managed by the block layer
948 * if it is, and we fail to adjust the depth, exit */
949 if (blk_queue_tagged(sdev
->request_queue
) &&
950 blk_queue_resize_tags(sdev
->request_queue
, tags
) != 0)
953 sdev
->queue_depth
= tags
;
955 case MSG_ORDERED_TAG
:
956 sdev
->ordered_tags
= 1;
957 sdev
->simple_tags
= 1;
960 sdev
->ordered_tags
= 0;
961 sdev
->simple_tags
= 1;
964 printk(KERN_WARNING
"(scsi%d:%d:%d:%d) "
965 "scsi_adjust_queue_depth, bad queue type, "
966 "disabled\n", sdev
->host
->host_no
,
967 sdev
->channel
, sdev
->id
, sdev
->lun
);
969 sdev
->ordered_tags
= sdev
->simple_tags
= 0;
970 sdev
->queue_depth
= tags
;
974 spin_unlock_irqrestore(sdev
->request_queue
->queue_lock
, flags
);
976 EXPORT_SYMBOL(scsi_adjust_queue_depth
);
979 * Function: scsi_track_queue_full()
981 * Purpose: This function will track successive QUEUE_FULL events on a
982 * specific SCSI device to determine if and when there is a
983 * need to adjust the queue depth on the device.
985 * Arguments: sdev - SCSI Device in question
986 * depth - Current number of outstanding SCSI commands on
987 * this device, not counting the one returned as
990 * Returns: 0 - No change needed
991 * >0 - Adjust queue depth to this new depth
992 * -1 - Drop back to untagged operation using host->cmd_per_lun
993 * as the untagged command depth
995 * Lock Status: None held on entry
997 * Notes: Low level drivers may call this at any time and we will do
998 * "The Right Thing." We are interrupt context safe.
1000 int scsi_track_queue_full(struct scsi_device
*sdev
, int depth
)
1002 if ((jiffies
>> 4) == sdev
->last_queue_full_time
)
1005 sdev
->last_queue_full_time
= (jiffies
>> 4);
1006 if (sdev
->last_queue_full_depth
!= depth
) {
1007 sdev
->last_queue_full_count
= 1;
1008 sdev
->last_queue_full_depth
= depth
;
1010 sdev
->last_queue_full_count
++;
1013 if (sdev
->last_queue_full_count
<= 10)
1015 if (sdev
->last_queue_full_depth
< 8) {
1016 /* Drop back to untagged */
1017 scsi_adjust_queue_depth(sdev
, 0, sdev
->host
->cmd_per_lun
);
1021 if (sdev
->ordered_tags
)
1022 scsi_adjust_queue_depth(sdev
, MSG_ORDERED_TAG
, depth
);
1024 scsi_adjust_queue_depth(sdev
, MSG_SIMPLE_TAG
, depth
);
1027 EXPORT_SYMBOL(scsi_track_queue_full
);
1030 * scsi_device_get - get an addition reference to a scsi_device
1031 * @sdev: device to get a reference to
1033 * Gets a reference to the scsi_device and increments the use count
1034 * of the underlying LLDD module. You must hold host_lock of the
1035 * parent Scsi_Host or already have a reference when calling this.
1037 int scsi_device_get(struct scsi_device
*sdev
)
1039 if (sdev
->sdev_state
== SDEV_DEL
|| sdev
->sdev_state
== SDEV_CANCEL
)
1041 if (!get_device(&sdev
->sdev_gendev
))
1043 if (!try_module_get(sdev
->host
->hostt
->module
)) {
1044 put_device(&sdev
->sdev_gendev
);
1049 EXPORT_SYMBOL(scsi_device_get
);
1052 * scsi_device_put - release a reference to a scsi_device
1053 * @sdev: device to release a reference on.
1055 * Release a reference to the scsi_device and decrements the use count
1056 * of the underlying LLDD module. The device is freed once the last
1059 void scsi_device_put(struct scsi_device
*sdev
)
1061 module_put(sdev
->host
->hostt
->module
);
1062 put_device(&sdev
->sdev_gendev
);
1064 EXPORT_SYMBOL(scsi_device_put
);
1066 /* helper for shost_for_each_device, thus not documented */
1067 struct scsi_device
*__scsi_iterate_devices(struct Scsi_Host
*shost
,
1068 struct scsi_device
*prev
)
1070 struct list_head
*list
= (prev
? &prev
->siblings
: &shost
->__devices
);
1071 struct scsi_device
*next
= NULL
;
1072 unsigned long flags
;
1074 spin_lock_irqsave(shost
->host_lock
, flags
);
1075 while (list
->next
!= &shost
->__devices
) {
1076 next
= list_entry(list
->next
, struct scsi_device
, siblings
);
1077 /* skip devices that we can't get a reference to */
1078 if (!scsi_device_get(next
))
1083 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1086 scsi_device_put(prev
);
1089 EXPORT_SYMBOL(__scsi_iterate_devices
);
1092 * starget_for_each_device - helper to walk all devices of a target
1093 * @starget: target whose devices we want to iterate over.
1095 * This traverses over each devices of @shost. The devices have
1096 * a reference that must be released by scsi_host_put when breaking
1099 void starget_for_each_device(struct scsi_target
*starget
, void * data
,
1100 void (*fn
)(struct scsi_device
*, void *))
1102 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
1103 struct scsi_device
*sdev
;
1105 shost_for_each_device(sdev
, shost
) {
1106 if ((sdev
->channel
== starget
->channel
) &&
1107 (sdev
->id
== starget
->id
))
1111 EXPORT_SYMBOL(starget_for_each_device
);
1114 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1115 * @starget: SCSI target pointer
1116 * @lun: SCSI Logical Unit Number
1118 * Looks up the scsi_device with the specified @lun for a give
1119 * @starget. The returned scsi_device does not have an additional
1120 * reference. You must hold the host's host_lock over this call and
1121 * any access to the returned scsi_device.
1123 * Note: The only reason why drivers would want to use this is because
1124 * they're need to access the device list in irq context. Otherwise you
1125 * really want to use scsi_device_lookup_by_target instead.
1127 struct scsi_device
*__scsi_device_lookup_by_target(struct scsi_target
*starget
,
1130 struct scsi_device
*sdev
;
1132 list_for_each_entry(sdev
, &starget
->devices
, same_target_siblings
) {
1133 if (sdev
->lun
==lun
)
1139 EXPORT_SYMBOL(__scsi_device_lookup_by_target
);
1142 * scsi_device_lookup_by_target - find a device given the target
1143 * @starget: SCSI target pointer
1144 * @lun: SCSI Logical Unit Number
1146 * Looks up the scsi_device with the specified @channel, @id, @lun for a
1147 * give host. The returned scsi_device has an additional reference that
1148 * needs to be release with scsi_host_put once you're done with it.
1150 struct scsi_device
*scsi_device_lookup_by_target(struct scsi_target
*starget
,
1153 struct scsi_device
*sdev
;
1154 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
1155 unsigned long flags
;
1157 spin_lock_irqsave(shost
->host_lock
, flags
);
1158 sdev
= __scsi_device_lookup_by_target(starget
, lun
);
1159 if (sdev
&& scsi_device_get(sdev
))
1161 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1165 EXPORT_SYMBOL(scsi_device_lookup_by_target
);
1168 * scsi_device_lookup - find a device given the host (UNLOCKED)
1169 * @shost: SCSI host pointer
1170 * @channel: SCSI channel (zero if only one channel)
1171 * @pun: SCSI target number (physical unit number)
1172 * @lun: SCSI Logical Unit Number
1174 * Looks up the scsi_device with the specified @channel, @id, @lun for a
1175 * give host. The returned scsi_device does not have an additional reference.
1176 * You must hold the host's host_lock over this call and any access to the
1177 * returned scsi_device.
1179 * Note: The only reason why drivers would want to use this is because
1180 * they're need to access the device list in irq context. Otherwise you
1181 * really want to use scsi_device_lookup instead.
1183 struct scsi_device
*__scsi_device_lookup(struct Scsi_Host
*shost
,
1184 uint channel
, uint id
, uint lun
)
1186 struct scsi_device
*sdev
;
1188 list_for_each_entry(sdev
, &shost
->__devices
, siblings
) {
1189 if (sdev
->channel
== channel
&& sdev
->id
== id
&&
1196 EXPORT_SYMBOL(__scsi_device_lookup
);
1199 * scsi_device_lookup - find a device given the host
1200 * @shost: SCSI host pointer
1201 * @channel: SCSI channel (zero if only one channel)
1202 * @id: SCSI target number (physical unit number)
1203 * @lun: SCSI Logical Unit Number
1205 * Looks up the scsi_device with the specified @channel, @id, @lun for a
1206 * give host. The returned scsi_device has an additional reference that
1207 * needs to be release with scsi_host_put once you're done with it.
1209 struct scsi_device
*scsi_device_lookup(struct Scsi_Host
*shost
,
1210 uint channel
, uint id
, uint lun
)
1212 struct scsi_device
*sdev
;
1213 unsigned long flags
;
1215 spin_lock_irqsave(shost
->host_lock
, flags
);
1216 sdev
= __scsi_device_lookup(shost
, channel
, id
, lun
);
1217 if (sdev
&& scsi_device_get(sdev
))
1219 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1223 EXPORT_SYMBOL(scsi_device_lookup
);
1226 * scsi_device_cancel - cancel outstanding IO to this device
1227 * @sdev: Pointer to struct scsi_device
1228 * @recovery: Boolean instructing function to recover device or not.
1231 int scsi_device_cancel(struct scsi_device
*sdev
, int recovery
)
1233 struct scsi_cmnd
*scmd
;
1234 LIST_HEAD(active_list
);
1235 struct list_head
*lh
, *lh_sf
;
1236 unsigned long flags
;
1238 scsi_device_set_state(sdev
, SDEV_CANCEL
);
1240 spin_lock_irqsave(&sdev
->list_lock
, flags
);
1241 list_for_each_entry(scmd
, &sdev
->cmd_list
, list
) {
1242 if (scmd
->request
&& scmd
->request
->rq_status
!= RQ_INACTIVE
) {
1244 * If we are unable to remove the timer, it means
1245 * that the command has already timed out or
1248 if (!scsi_delete_timer(scmd
))
1250 list_add_tail(&scmd
->eh_entry
, &active_list
);
1253 spin_unlock_irqrestore(&sdev
->list_lock
, flags
);
1255 if (!list_empty(&active_list
)) {
1256 list_for_each_safe(lh
, lh_sf
, &active_list
) {
1257 scmd
= list_entry(lh
, struct scsi_cmnd
, eh_entry
);
1260 scsi_eh_scmd_add(scmd
, SCSI_EH_CANCEL_CMD
);
1262 scmd
->result
= (DID_ABORT
<< 16);
1263 scsi_finish_command(scmd
);
1270 EXPORT_SYMBOL(scsi_device_cancel
);
1272 #ifdef CONFIG_HOTPLUG_CPU
1273 static int scsi_cpu_notify(struct notifier_block
*self
,
1274 unsigned long action
, void *hcpu
)
1276 int cpu
= (unsigned long)hcpu
;
1280 /* Drain scsi_done_q. */
1281 local_irq_disable();
1282 list_splice_init(&per_cpu(scsi_done_q
, cpu
),
1283 &__get_cpu_var(scsi_done_q
));
1284 raise_softirq_irqoff(SCSI_SOFTIRQ
);
1293 static struct notifier_block __devinitdata scsi_cpu_nb
= {
1294 .notifier_call
= scsi_cpu_notify
,
1297 #define register_scsi_cpu() register_cpu_notifier(&scsi_cpu_nb)
1298 #define unregister_scsi_cpu() unregister_cpu_notifier(&scsi_cpu_nb)
1300 #define register_scsi_cpu()
1301 #define unregister_scsi_cpu()
1302 #endif /* CONFIG_HOTPLUG_CPU */
1304 MODULE_DESCRIPTION("SCSI core");
1305 MODULE_LICENSE("GPL");
1307 module_param(scsi_logging_level
, int, S_IRUGO
|S_IWUSR
);
1308 MODULE_PARM_DESC(scsi_logging_level
, "a bit mask of logging levels");
1310 static int __init
init_scsi(void)
1314 error
= scsi_init_queue();
1317 error
= scsi_init_procfs();
1320 error
= scsi_init_devinfo();
1322 goto cleanup_procfs
;
1323 error
= scsi_init_hosts();
1325 goto cleanup_devlist
;
1326 error
= scsi_init_sysctl();
1329 error
= scsi_sysfs_register();
1331 goto cleanup_sysctl
;
1333 for (i
= 0; i
< NR_CPUS
; i
++)
1334 INIT_LIST_HEAD(&per_cpu(scsi_done_q
, i
));
1336 devfs_mk_dir("scsi");
1337 open_softirq(SCSI_SOFTIRQ
, scsi_softirq
, NULL
);
1338 register_scsi_cpu();
1339 printk(KERN_NOTICE
"SCSI subsystem initialized\n");
1347 scsi_exit_devinfo();
1352 printk(KERN_ERR
"SCSI subsystem failed to initialize, error = %d\n",
1357 static void __exit
exit_scsi(void)
1359 scsi_sysfs_unregister();
1362 scsi_exit_devinfo();
1363 devfs_remove("scsi");
1366 unregister_scsi_cpu();
1369 subsys_initcall(init_scsi
);
1370 module_exit(exit_scsi
);