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>
58 #include <linux/mutex.h>
60 #include <scsi/scsi.h>
61 #include <scsi/scsi_cmnd.h>
62 #include <scsi/scsi_dbg.h>
63 #include <scsi/scsi_device.h>
64 #include <scsi/scsi_eh.h>
65 #include <scsi/scsi_host.h>
66 #include <scsi/scsi_tcq.h>
67 #include <scsi/scsi_request.h>
69 #include "scsi_priv.h"
70 #include "scsi_logging.h"
72 static void scsi_done(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
] = {
118 EXPORT_SYMBOL(scsi_device_types
);
121 * Function: scsi_allocate_request
123 * Purpose: Allocate a request descriptor.
125 * Arguments: device - device for which we want a request
126 * gfp_mask - allocation flags passed to kmalloc
128 * Lock status: No locks assumed to be held. This function is SMP-safe.
130 * Returns: Pointer to request block.
132 struct scsi_request
*scsi_allocate_request(struct scsi_device
*sdev
,
135 const int offset
= ALIGN(sizeof(struct scsi_request
), 4);
136 const int size
= offset
+ sizeof(struct request
);
137 struct scsi_request
*sreq
;
139 sreq
= kmalloc(size
, gfp_mask
);
140 if (likely(sreq
!= NULL
)) {
141 memset(sreq
, 0, size
);
142 sreq
->sr_request
= (struct request
*)(((char *)sreq
) + offset
);
143 sreq
->sr_device
= sdev
;
144 sreq
->sr_host
= sdev
->host
;
145 sreq
->sr_magic
= SCSI_REQ_MAGIC
;
146 sreq
->sr_data_direction
= DMA_BIDIRECTIONAL
;
151 EXPORT_SYMBOL(scsi_allocate_request
);
153 void __scsi_release_request(struct scsi_request
*sreq
)
155 struct request
*req
= sreq
->sr_request
;
157 /* unlikely because the tag was usually ended earlier by the
158 * mid-layer. However, for layering reasons ULD's don't end
159 * the tag of commands they generate. */
160 if (unlikely(blk_rq_tagged(req
))) {
162 struct request_queue
*q
= req
->q
;
164 spin_lock_irqsave(q
->queue_lock
, flags
);
165 blk_queue_end_tag(q
, req
);
166 spin_unlock_irqrestore(q
->queue_lock
, flags
);
170 if (likely(sreq
->sr_command
!= NULL
)) {
171 struct scsi_cmnd
*cmd
= sreq
->sr_command
;
173 sreq
->sr_command
= NULL
;
174 scsi_next_command(cmd
);
179 * Function: scsi_release_request
181 * Purpose: Release a request descriptor.
183 * Arguments: sreq - request to release
185 * Lock status: No locks assumed to be held. This function is SMP-safe.
187 void scsi_release_request(struct scsi_request
*sreq
)
189 __scsi_release_request(sreq
);
192 EXPORT_SYMBOL(scsi_release_request
);
194 struct scsi_host_cmd_pool
{
198 unsigned int slab_flags
;
202 static struct scsi_host_cmd_pool scsi_cmd_pool
= {
203 .name
= "scsi_cmd_cache",
204 .slab_flags
= SLAB_HWCACHE_ALIGN
,
207 static struct scsi_host_cmd_pool scsi_cmd_dma_pool
= {
208 .name
= "scsi_cmd_cache(DMA)",
209 .slab_flags
= SLAB_HWCACHE_ALIGN
|SLAB_CACHE_DMA
,
210 .gfp_mask
= __GFP_DMA
,
213 static DEFINE_MUTEX(host_cmd_pool_mutex
);
215 static struct scsi_cmnd
*__scsi_get_command(struct Scsi_Host
*shost
,
218 struct scsi_cmnd
*cmd
;
220 cmd
= kmem_cache_alloc(shost
->cmd_pool
->slab
,
221 gfp_mask
| shost
->cmd_pool
->gfp_mask
);
223 if (unlikely(!cmd
)) {
226 spin_lock_irqsave(&shost
->free_list_lock
, flags
);
227 if (likely(!list_empty(&shost
->free_list
))) {
228 cmd
= list_entry(shost
->free_list
.next
,
229 struct scsi_cmnd
, list
);
230 list_del_init(&cmd
->list
);
232 spin_unlock_irqrestore(&shost
->free_list_lock
, flags
);
239 * Function: scsi_get_command()
241 * Purpose: Allocate and setup a scsi command block
243 * Arguments: dev - parent scsi device
244 * gfp_mask- allocator flags
246 * Returns: The allocated scsi command structure.
248 struct scsi_cmnd
*scsi_get_command(struct scsi_device
*dev
, gfp_t gfp_mask
)
250 struct scsi_cmnd
*cmd
;
252 /* Bail if we can't get a reference to the device */
253 if (!get_device(&dev
->sdev_gendev
))
256 cmd
= __scsi_get_command(dev
->host
, gfp_mask
);
258 if (likely(cmd
!= NULL
)) {
261 memset(cmd
, 0, sizeof(*cmd
));
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
);
268 cmd
->jiffies_at_alloc
= jiffies
;
270 put_device(&dev
->sdev_gendev
);
274 EXPORT_SYMBOL(scsi_get_command
);
277 * Function: scsi_put_command()
279 * Purpose: Free a scsi command block
281 * Arguments: cmd - command block to free
285 * Notes: The command must not belong to any lists.
287 void scsi_put_command(struct scsi_cmnd
*cmd
)
289 struct scsi_device
*sdev
= cmd
->device
;
290 struct Scsi_Host
*shost
= sdev
->host
;
293 /* serious error if the command hasn't come from a device list */
294 spin_lock_irqsave(&cmd
->device
->list_lock
, flags
);
295 BUG_ON(list_empty(&cmd
->list
));
296 list_del_init(&cmd
->list
);
297 spin_unlock(&cmd
->device
->list_lock
);
298 /* changing locks here, don't need to restore the irq state */
299 spin_lock(&shost
->free_list_lock
);
300 if (unlikely(list_empty(&shost
->free_list
))) {
301 list_add(&cmd
->list
, &shost
->free_list
);
304 spin_unlock_irqrestore(&shost
->free_list_lock
, flags
);
306 if (likely(cmd
!= NULL
))
307 kmem_cache_free(shost
->cmd_pool
->slab
, cmd
);
309 put_device(&sdev
->sdev_gendev
);
311 EXPORT_SYMBOL(scsi_put_command
);
314 * Function: scsi_setup_command_freelist()
316 * Purpose: Setup the command freelist for a scsi host.
318 * Arguments: shost - host to allocate the freelist for.
322 int scsi_setup_command_freelist(struct Scsi_Host
*shost
)
324 struct scsi_host_cmd_pool
*pool
;
325 struct scsi_cmnd
*cmd
;
327 spin_lock_init(&shost
->free_list_lock
);
328 INIT_LIST_HEAD(&shost
->free_list
);
331 * Select a command slab for this host and create it if not
334 mutex_lock(&host_cmd_pool_mutex
);
335 pool
= (shost
->unchecked_isa_dma
? &scsi_cmd_dma_pool
: &scsi_cmd_pool
);
337 pool
->slab
= kmem_cache_create(pool
->name
,
338 sizeof(struct scsi_cmnd
), 0,
339 pool
->slab_flags
, NULL
, NULL
);
345 shost
->cmd_pool
= pool
;
346 mutex_unlock(&host_cmd_pool_mutex
);
349 * Get one backup command for this host.
351 cmd
= kmem_cache_alloc(shost
->cmd_pool
->slab
,
352 GFP_KERNEL
| shost
->cmd_pool
->gfp_mask
);
355 list_add(&cmd
->list
, &shost
->free_list
);
360 kmem_cache_destroy(pool
->slab
);
363 mutex_unlock(&host_cmd_pool_mutex
);
369 * Function: scsi_destroy_command_freelist()
371 * Purpose: Release the command freelist for a scsi host.
373 * Arguments: shost - host that's freelist is going to be destroyed
375 void scsi_destroy_command_freelist(struct Scsi_Host
*shost
)
377 while (!list_empty(&shost
->free_list
)) {
378 struct scsi_cmnd
*cmd
;
380 cmd
= list_entry(shost
->free_list
.next
, struct scsi_cmnd
, list
);
381 list_del_init(&cmd
->list
);
382 kmem_cache_free(shost
->cmd_pool
->slab
, cmd
);
385 mutex_lock(&host_cmd_pool_mutex
);
386 if (!--shost
->cmd_pool
->users
)
387 kmem_cache_destroy(shost
->cmd_pool
->slab
);
388 mutex_unlock(&host_cmd_pool_mutex
);
391 #ifdef CONFIG_SCSI_LOGGING
392 void scsi_log_send(struct scsi_cmnd
*cmd
)
395 struct scsi_device
*sdev
;
398 * If ML QUEUE log level is greater than or equal to:
400 * 1: nothing (match completion)
402 * 2: log opcode + command of all commands
404 * 3: same as 2 plus dump cmd address
406 * 4: same as 3 plus dump extra junk
408 if (unlikely(scsi_logging_level
)) {
409 level
= SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT
,
410 SCSI_LOG_MLQUEUE_BITS
);
413 sdev_printk(KERN_INFO
, sdev
, "send ");
415 printk("0x%p ", cmd
);
417 * spaces to match disposition and cmd->result
418 * output in scsi_log_completion.
421 scsi_print_command(cmd
);
423 printk(KERN_INFO
"buffer = 0x%p, bufflen = %d,"
424 " done = 0x%p, queuecommand 0x%p\n",
425 cmd
->buffer
, cmd
->bufflen
,
427 sdev
->host
->hostt
->queuecommand
);
434 void scsi_log_completion(struct scsi_cmnd
*cmd
, int disposition
)
437 struct scsi_device
*sdev
;
440 * If ML COMPLETE log level is greater than or equal to:
442 * 1: log disposition, result, opcode + command, and conditionally
443 * sense data for failures or non SUCCESS dispositions.
445 * 2: same as 1 but for all command completions.
447 * 3: same as 2 plus dump cmd address
449 * 4: same as 3 plus dump extra junk
451 if (unlikely(scsi_logging_level
)) {
452 level
= SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT
,
453 SCSI_LOG_MLCOMPLETE_BITS
);
454 if (((level
> 0) && (cmd
->result
|| disposition
!= SUCCESS
)) ||
457 sdev_printk(KERN_INFO
, sdev
, "done ");
459 printk("0x%p ", cmd
);
461 * Dump truncated values, so we usually fit within
464 switch (disposition
) {
479 * If called via scsi_times_out.
486 printk(" %8x ", cmd
->result
);
487 scsi_print_command(cmd
);
488 if (status_byte(cmd
->result
) & CHECK_CONDITION
) {
490 * XXX The scsi_print_sense formatting/prefix
491 * doesn't match this function.
493 scsi_print_sense("", cmd
);
496 printk(KERN_INFO
"scsi host busy %d failed %d\n",
497 sdev
->host
->host_busy
,
498 sdev
->host
->host_failed
);
506 * Assign a serial number and pid to the request for error recovery
507 * and debugging purposes. Protected by the Host_Lock of host.
509 static inline void scsi_cmd_get_serial(struct Scsi_Host
*host
, struct scsi_cmnd
*cmd
)
511 cmd
->serial_number
= host
->cmd_serial_number
++;
512 if (cmd
->serial_number
== 0)
513 cmd
->serial_number
= host
->cmd_serial_number
++;
515 cmd
->pid
= host
->cmd_pid
++;
517 cmd
->pid
= host
->cmd_pid
++;
521 * Function: scsi_dispatch_command
523 * Purpose: Dispatch a command to the low-level driver.
525 * Arguments: cmd - command block we are dispatching.
529 int scsi_dispatch_cmd(struct scsi_cmnd
*cmd
)
531 struct Scsi_Host
*host
= cmd
->device
->host
;
532 unsigned long flags
= 0;
533 unsigned long timeout
;
536 /* check if the device is still usable */
537 if (unlikely(cmd
->device
->sdev_state
== SDEV_DEL
)) {
538 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
539 * returns an immediate error upwards, and signals
540 * that the device is no longer present */
541 cmd
->result
= DID_NO_CONNECT
<< 16;
542 atomic_inc(&cmd
->device
->iorequest_cnt
);
544 /* return 0 (because the command has been processed) */
548 /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */
549 if (unlikely(cmd
->device
->sdev_state
== SDEV_BLOCK
)) {
551 * in SDEV_BLOCK, the command is just put back on the device
552 * queue. The suspend state has already blocked the queue so
553 * future requests should not occur until the device
554 * transitions out of the suspend state.
556 scsi_queue_insert(cmd
, SCSI_MLQUEUE_DEVICE_BUSY
);
558 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
561 * NOTE: rtn is still zero here because we don't need the
562 * queue to be plugged on return (it's already stopped)
568 * If SCSI-2 or lower, store the LUN value in cmnd.
570 if (cmd
->device
->scsi_level
<= SCSI_2
) {
571 cmd
->cmnd
[1] = (cmd
->cmnd
[1] & 0x1f) |
572 (cmd
->device
->lun
<< 5 & 0xe0);
576 * We will wait MIN_RESET_DELAY clock ticks after the last reset so
577 * we can avoid the drive not being ready.
579 timeout
= host
->last_reset
+ MIN_RESET_DELAY
;
581 if (host
->resetting
&& time_before(jiffies
, timeout
)) {
582 int ticks_remaining
= timeout
- jiffies
;
584 * NOTE: This may be executed from within an interrupt
585 * handler! This is bad, but for now, it'll do. The irq
586 * level of the interrupt handler has been masked out by the
587 * platform dependent interrupt handling code already, so the
588 * sti() here will not cause another call to the SCSI host's
589 * interrupt handler (assuming there is one irq-level per
592 while (--ticks_remaining
>= 0)
593 mdelay(1 + 999 / HZ
);
598 * AK: unlikely race here: for some reason the timer could
599 * expire before the serial number is set up below.
601 scsi_add_timer(cmd
, cmd
->timeout_per_command
, scsi_times_out
);
606 * We will use a queued command if possible, otherwise we will
607 * emulate the queuing and calling of completion function ourselves.
609 atomic_inc(&cmd
->device
->iorequest_cnt
);
612 * Before we queue this command, check if the command
613 * length exceeds what the host adapter can handle.
615 if (CDB_SIZE(cmd
) > cmd
->device
->host
->max_cmd_len
) {
617 printk("queuecommand : command too long.\n"));
618 cmd
->result
= (DID_ABORT
<< 16);
624 spin_lock_irqsave(host
->host_lock
, flags
);
625 scsi_cmd_get_serial(host
, cmd
);
627 if (unlikely(host
->shost_state
== SHOST_DEL
)) {
628 cmd
->result
= (DID_NO_CONNECT
<< 16);
631 rtn
= host
->hostt
->queuecommand(cmd
, scsi_done
);
633 spin_unlock_irqrestore(host
->host_lock
, flags
);
635 if (scsi_delete_timer(cmd
)) {
636 atomic_inc(&cmd
->device
->iodone_cnt
);
637 scsi_queue_insert(cmd
,
638 (rtn
== SCSI_MLQUEUE_DEVICE_BUSY
) ?
639 rtn
: SCSI_MLQUEUE_HOST_BUSY
);
642 printk("queuecommand : request rejected\n"));
646 SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
651 * Function: scsi_init_cmd_from_req
653 * Purpose: Queue a SCSI command
654 * Purpose: Initialize a struct scsi_cmnd from a struct scsi_request
656 * Arguments: cmd - command descriptor.
657 * sreq - Request from the queue.
659 * Lock status: None needed.
663 * Notes: Mainly transfer data from the request structure to the
664 * command structure. The request structure is allocated
665 * using the normal memory allocator, and requests can pile
666 * up to more or less any depth. The command structure represents
667 * a consumable resource, as these are allocated into a pool
668 * when the SCSI subsystem initializes. The preallocation is
669 * required so that in low-memory situations a disk I/O request
670 * won't cause the memory manager to try and write out a page.
671 * The request structure is generally used by ioctls and character
674 void scsi_init_cmd_from_req(struct scsi_cmnd
*cmd
, struct scsi_request
*sreq
)
676 sreq
->sr_command
= cmd
;
678 cmd
->cmd_len
= sreq
->sr_cmd_len
;
679 cmd
->use_sg
= sreq
->sr_use_sg
;
681 cmd
->request
= sreq
->sr_request
;
682 memcpy(cmd
->data_cmnd
, sreq
->sr_cmnd
, sizeof(cmd
->data_cmnd
));
683 cmd
->serial_number
= 0;
684 cmd
->bufflen
= sreq
->sr_bufflen
;
685 cmd
->buffer
= sreq
->sr_buffer
;
687 cmd
->allowed
= sreq
->sr_allowed
;
688 cmd
->done
= sreq
->sr_done
;
689 cmd
->timeout_per_command
= sreq
->sr_timeout_per_command
;
690 cmd
->sc_data_direction
= sreq
->sr_data_direction
;
691 cmd
->sglist_len
= sreq
->sr_sglist_len
;
692 cmd
->underflow
= sreq
->sr_underflow
;
693 cmd
->sc_request
= sreq
;
694 memcpy(cmd
->cmnd
, sreq
->sr_cmnd
, sizeof(sreq
->sr_cmnd
));
697 * Zero the sense buffer. Some host adapters automatically request
698 * sense on error. 0 is not a valid sense code.
700 memset(cmd
->sense_buffer
, 0, sizeof(sreq
->sr_sense_buffer
));
701 cmd
->request_buffer
= sreq
->sr_buffer
;
702 cmd
->request_bufflen
= sreq
->sr_bufflen
;
703 cmd
->old_use_sg
= cmd
->use_sg
;
704 if (cmd
->cmd_len
== 0)
705 cmd
->cmd_len
= COMMAND_SIZE(cmd
->cmnd
[0]);
706 cmd
->old_cmd_len
= cmd
->cmd_len
;
707 cmd
->sc_old_data_direction
= cmd
->sc_data_direction
;
708 cmd
->old_underflow
= cmd
->underflow
;
711 * Start the timer ticking.
715 SCSI_LOG_MLQUEUE(3, printk("Leaving scsi_init_cmd_from_req()\n"));
719 * Per-CPU I/O completion queue.
721 static DEFINE_PER_CPU(struct list_head
, scsi_done_q
);
724 * scsi_done - Enqueue the finished SCSI command into the done queue.
725 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
726 * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
728 * This function is the mid-level's (SCSI Core) interrupt routine, which
729 * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues
730 * the command to the done queue for further processing.
732 * This is the producer of the done queue who enqueues at the tail.
734 * This function is interrupt context safe.
736 static void scsi_done(struct scsi_cmnd
*cmd
)
739 * We don't have to worry about this one timing out any more.
740 * If we are unable to remove the timer, then the command
741 * has already timed out. In which case, we have no choice but to
742 * let the timeout function run, as we have no idea where in fact
743 * that function could really be. It might be on another processor,
746 if (!scsi_delete_timer(cmd
))
751 /* Private entry to scsi_done() to complete a command when the timer
752 * isn't running --- used by scsi_times_out */
753 void __scsi_done(struct scsi_cmnd
*cmd
)
755 struct request
*rq
= cmd
->request
;
758 * Set the serial numbers back to zero
760 cmd
->serial_number
= 0;
762 atomic_inc(&cmd
->device
->iodone_cnt
);
764 atomic_inc(&cmd
->device
->ioerr_cnt
);
769 * The uptodate/nbytes values don't matter, as we allow partial
770 * completes and thus will check this in the softirq callback
772 rq
->completion_data
= cmd
;
773 blk_complete_request(rq
);
777 * Function: scsi_retry_command
779 * Purpose: Send a command back to the low level to be retried.
781 * Notes: This command is always executed in the context of the
782 * bottom half handler, or the error handler thread. Low
783 * level drivers should not become re-entrant as a result of
786 int scsi_retry_command(struct scsi_cmnd
*cmd
)
789 * Restore the SCSI command state.
791 scsi_setup_cmd_retry(cmd
);
794 * Zero the sense information from the last time we tried
797 memset(cmd
->sense_buffer
, 0, sizeof(cmd
->sense_buffer
));
799 return scsi_queue_insert(cmd
, SCSI_MLQUEUE_EH_RETRY
);
803 * Function: scsi_finish_command
805 * Purpose: Pass command off to upper layer for finishing of I/O
806 * request, waking processes that are waiting on results,
809 void scsi_finish_command(struct scsi_cmnd
*cmd
)
811 struct scsi_device
*sdev
= cmd
->device
;
812 struct Scsi_Host
*shost
= sdev
->host
;
813 struct scsi_request
*sreq
;
815 scsi_device_unbusy(sdev
);
818 * Clear the flags which say that the device/host is no longer
819 * capable of accepting new commands. These are set in scsi_queue.c
820 * for both the queue full condition on a device, and for a
821 * host full condition on the host.
823 * XXX(hch): What about locking?
825 shost
->host_blocked
= 0;
826 sdev
->device_blocked
= 0;
829 * If we have valid sense information, then some kind of recovery
830 * must have taken place. Make a note of this.
832 if (SCSI_SENSE_VALID(cmd
))
833 cmd
->result
|= (DRIVER_SENSE
<< 24);
835 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO
, sdev
,
836 "Notifying upper driver of completion "
837 "(result %x)\n", cmd
->result
));
840 * We can get here with use_sg=0, causing a panic in the upper level
842 cmd
->use_sg
= cmd
->old_use_sg
;
845 * If there is an associated request structure, copy the data over
846 * before we call the completion function.
848 sreq
= cmd
->sc_request
;
850 sreq
->sr_result
= sreq
->sr_command
->result
;
851 if (sreq
->sr_result
) {
852 memcpy(sreq
->sr_sense_buffer
,
853 sreq
->sr_command
->sense_buffer
,
854 sizeof(sreq
->sr_sense_buffer
));
860 EXPORT_SYMBOL(scsi_finish_command
);
863 * Function: scsi_adjust_queue_depth()
865 * Purpose: Allow low level drivers to tell us to change the queue depth
866 * on a specific SCSI device
868 * Arguments: sdev - SCSI Device in question
869 * tagged - Do we use tagged queueing (non-0) or do we treat
870 * this device as an untagged device (0)
871 * tags - Number of tags allowed if tagged queueing enabled,
872 * or number of commands the low level driver can
873 * queue up in non-tagged mode (as per cmd_per_lun).
877 * Lock Status: None held on entry
879 * Notes: Low level drivers may call this at any time and we will do
880 * the right thing depending on whether or not the device is
881 * currently active and whether or not it even has the
882 * command blocks built yet.
884 void scsi_adjust_queue_depth(struct scsi_device
*sdev
, int tagged
, int tags
)
889 * refuse to set tagged depth to an unworkable size
894 spin_lock_irqsave(sdev
->request_queue
->queue_lock
, flags
);
896 /* Check to see if the queue is managed by the block layer
897 * if it is, and we fail to adjust the depth, exit */
898 if (blk_queue_tagged(sdev
->request_queue
) &&
899 blk_queue_resize_tags(sdev
->request_queue
, tags
) != 0)
902 sdev
->queue_depth
= tags
;
904 case MSG_ORDERED_TAG
:
905 sdev
->ordered_tags
= 1;
906 sdev
->simple_tags
= 1;
909 sdev
->ordered_tags
= 0;
910 sdev
->simple_tags
= 1;
913 sdev_printk(KERN_WARNING
, sdev
,
914 "scsi_adjust_queue_depth, bad queue type, "
917 sdev
->ordered_tags
= sdev
->simple_tags
= 0;
918 sdev
->queue_depth
= tags
;
922 spin_unlock_irqrestore(sdev
->request_queue
->queue_lock
, flags
);
924 EXPORT_SYMBOL(scsi_adjust_queue_depth
);
927 * Function: scsi_track_queue_full()
929 * Purpose: This function will track successive QUEUE_FULL events on a
930 * specific SCSI device to determine if and when there is a
931 * need to adjust the queue depth on the device.
933 * Arguments: sdev - SCSI Device in question
934 * depth - Current number of outstanding SCSI commands on
935 * this device, not counting the one returned as
938 * Returns: 0 - No change needed
939 * >0 - Adjust queue depth to this new depth
940 * -1 - Drop back to untagged operation using host->cmd_per_lun
941 * as the untagged command depth
943 * Lock Status: None held on entry
945 * Notes: Low level drivers may call this at any time and we will do
946 * "The Right Thing." We are interrupt context safe.
948 int scsi_track_queue_full(struct scsi_device
*sdev
, int depth
)
950 if ((jiffies
>> 4) == sdev
->last_queue_full_time
)
953 sdev
->last_queue_full_time
= (jiffies
>> 4);
954 if (sdev
->last_queue_full_depth
!= depth
) {
955 sdev
->last_queue_full_count
= 1;
956 sdev
->last_queue_full_depth
= depth
;
958 sdev
->last_queue_full_count
++;
961 if (sdev
->last_queue_full_count
<= 10)
963 if (sdev
->last_queue_full_depth
< 8) {
964 /* Drop back to untagged */
965 scsi_adjust_queue_depth(sdev
, 0, sdev
->host
->cmd_per_lun
);
969 if (sdev
->ordered_tags
)
970 scsi_adjust_queue_depth(sdev
, MSG_ORDERED_TAG
, depth
);
972 scsi_adjust_queue_depth(sdev
, MSG_SIMPLE_TAG
, depth
);
975 EXPORT_SYMBOL(scsi_track_queue_full
);
978 * scsi_device_get - get an addition reference to a scsi_device
979 * @sdev: device to get a reference to
981 * Gets a reference to the scsi_device and increments the use count
982 * of the underlying LLDD module. You must hold host_lock of the
983 * parent Scsi_Host or already have a reference when calling this.
985 int scsi_device_get(struct scsi_device
*sdev
)
987 if (sdev
->sdev_state
== SDEV_DEL
|| sdev
->sdev_state
== SDEV_CANCEL
)
989 if (!get_device(&sdev
->sdev_gendev
))
991 if (!try_module_get(sdev
->host
->hostt
->module
)) {
992 put_device(&sdev
->sdev_gendev
);
997 EXPORT_SYMBOL(scsi_device_get
);
1000 * scsi_device_put - release a reference to a scsi_device
1001 * @sdev: device to release a reference on.
1003 * Release a reference to the scsi_device and decrements the use count
1004 * of the underlying LLDD module. The device is freed once the last
1007 void scsi_device_put(struct scsi_device
*sdev
)
1009 module_put(sdev
->host
->hostt
->module
);
1010 put_device(&sdev
->sdev_gendev
);
1012 EXPORT_SYMBOL(scsi_device_put
);
1014 /* helper for shost_for_each_device, thus not documented */
1015 struct scsi_device
*__scsi_iterate_devices(struct Scsi_Host
*shost
,
1016 struct scsi_device
*prev
)
1018 struct list_head
*list
= (prev
? &prev
->siblings
: &shost
->__devices
);
1019 struct scsi_device
*next
= NULL
;
1020 unsigned long flags
;
1022 spin_lock_irqsave(shost
->host_lock
, flags
);
1023 while (list
->next
!= &shost
->__devices
) {
1024 next
= list_entry(list
->next
, struct scsi_device
, siblings
);
1025 /* skip devices that we can't get a reference to */
1026 if (!scsi_device_get(next
))
1031 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1034 scsi_device_put(prev
);
1037 EXPORT_SYMBOL(__scsi_iterate_devices
);
1040 * starget_for_each_device - helper to walk all devices of a target
1041 * @starget: target whose devices we want to iterate over.
1043 * This traverses over each devices of @shost. The devices have
1044 * a reference that must be released by scsi_host_put when breaking
1047 void starget_for_each_device(struct scsi_target
*starget
, void * data
,
1048 void (*fn
)(struct scsi_device
*, void *))
1050 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
1051 struct scsi_device
*sdev
;
1053 shost_for_each_device(sdev
, shost
) {
1054 if ((sdev
->channel
== starget
->channel
) &&
1055 (sdev
->id
== starget
->id
))
1059 EXPORT_SYMBOL(starget_for_each_device
);
1062 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1063 * @starget: SCSI target pointer
1064 * @lun: SCSI Logical Unit Number
1066 * Looks up the scsi_device with the specified @lun for a give
1067 * @starget. The returned scsi_device does not have an additional
1068 * reference. You must hold the host's host_lock over this call and
1069 * any access to the returned scsi_device.
1071 * Note: The only reason why drivers would want to use this is because
1072 * they're need to access the device list in irq context. Otherwise you
1073 * really want to use scsi_device_lookup_by_target instead.
1075 struct scsi_device
*__scsi_device_lookup_by_target(struct scsi_target
*starget
,
1078 struct scsi_device
*sdev
;
1080 list_for_each_entry(sdev
, &starget
->devices
, same_target_siblings
) {
1081 if (sdev
->lun
==lun
)
1087 EXPORT_SYMBOL(__scsi_device_lookup_by_target
);
1090 * scsi_device_lookup_by_target - find a device given the target
1091 * @starget: SCSI target pointer
1092 * @lun: SCSI Logical Unit Number
1094 * Looks up the scsi_device with the specified @channel, @id, @lun for a
1095 * give host. The returned scsi_device has an additional reference that
1096 * needs to be release with scsi_host_put once you're done with it.
1098 struct scsi_device
*scsi_device_lookup_by_target(struct scsi_target
*starget
,
1101 struct scsi_device
*sdev
;
1102 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
1103 unsigned long flags
;
1105 spin_lock_irqsave(shost
->host_lock
, flags
);
1106 sdev
= __scsi_device_lookup_by_target(starget
, lun
);
1107 if (sdev
&& scsi_device_get(sdev
))
1109 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1113 EXPORT_SYMBOL(scsi_device_lookup_by_target
);
1116 * scsi_device_lookup - find a device given the host (UNLOCKED)
1117 * @shost: SCSI host pointer
1118 * @channel: SCSI channel (zero if only one channel)
1119 * @pun: SCSI target number (physical unit number)
1120 * @lun: SCSI Logical Unit Number
1122 * Looks up the scsi_device with the specified @channel, @id, @lun for a
1123 * give host. The returned scsi_device does not have an additional reference.
1124 * You must hold the host's host_lock over this call and any access to the
1125 * returned scsi_device.
1127 * Note: The only reason why drivers would want to use this is because
1128 * they're need to access the device list in irq context. Otherwise you
1129 * really want to use scsi_device_lookup instead.
1131 struct scsi_device
*__scsi_device_lookup(struct Scsi_Host
*shost
,
1132 uint channel
, uint id
, uint lun
)
1134 struct scsi_device
*sdev
;
1136 list_for_each_entry(sdev
, &shost
->__devices
, siblings
) {
1137 if (sdev
->channel
== channel
&& sdev
->id
== id
&&
1144 EXPORT_SYMBOL(__scsi_device_lookup
);
1147 * scsi_device_lookup - find a device given the host
1148 * @shost: SCSI host pointer
1149 * @channel: SCSI channel (zero if only one channel)
1150 * @id: SCSI target number (physical unit number)
1151 * @lun: SCSI Logical Unit Number
1153 * Looks up the scsi_device with the specified @channel, @id, @lun for a
1154 * give host. The returned scsi_device has an additional reference that
1155 * needs to be release with scsi_host_put once you're done with it.
1157 struct scsi_device
*scsi_device_lookup(struct Scsi_Host
*shost
,
1158 uint channel
, uint id
, uint lun
)
1160 struct scsi_device
*sdev
;
1161 unsigned long flags
;
1163 spin_lock_irqsave(shost
->host_lock
, flags
);
1164 sdev
= __scsi_device_lookup(shost
, channel
, id
, lun
);
1165 if (sdev
&& scsi_device_get(sdev
))
1167 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1171 EXPORT_SYMBOL(scsi_device_lookup
);
1174 * scsi_device_cancel - cancel outstanding IO to this device
1175 * @sdev: Pointer to struct scsi_device
1176 * @recovery: Boolean instructing function to recover device or not.
1179 int scsi_device_cancel(struct scsi_device
*sdev
, int recovery
)
1181 struct scsi_cmnd
*scmd
;
1182 LIST_HEAD(active_list
);
1183 struct list_head
*lh
, *lh_sf
;
1184 unsigned long flags
;
1186 scsi_device_set_state(sdev
, SDEV_CANCEL
);
1188 spin_lock_irqsave(&sdev
->list_lock
, flags
);
1189 list_for_each_entry(scmd
, &sdev
->cmd_list
, list
) {
1190 if (scmd
->request
&& scmd
->request
->rq_status
!= RQ_INACTIVE
) {
1192 * If we are unable to remove the timer, it means
1193 * that the command has already timed out or
1196 if (!scsi_delete_timer(scmd
))
1198 list_add_tail(&scmd
->eh_entry
, &active_list
);
1201 spin_unlock_irqrestore(&sdev
->list_lock
, flags
);
1203 if (!list_empty(&active_list
)) {
1204 list_for_each_safe(lh
, lh_sf
, &active_list
) {
1205 scmd
= list_entry(lh
, struct scsi_cmnd
, eh_entry
);
1208 !scsi_eh_scmd_add(scmd
, SCSI_EH_CANCEL_CMD
)) {
1209 scmd
->result
= (DID_ABORT
<< 16);
1210 scsi_finish_command(scmd
);
1217 EXPORT_SYMBOL(scsi_device_cancel
);
1219 MODULE_DESCRIPTION("SCSI core");
1220 MODULE_LICENSE("GPL");
1222 module_param(scsi_logging_level
, int, S_IRUGO
|S_IWUSR
);
1223 MODULE_PARM_DESC(scsi_logging_level
, "a bit mask of logging levels");
1225 static int __init
init_scsi(void)
1229 error
= scsi_init_queue();
1232 error
= scsi_init_procfs();
1235 error
= scsi_init_devinfo();
1237 goto cleanup_procfs
;
1238 error
= scsi_init_hosts();
1240 goto cleanup_devlist
;
1241 error
= scsi_init_sysctl();
1244 error
= scsi_sysfs_register();
1246 goto cleanup_sysctl
;
1249 INIT_LIST_HEAD(&per_cpu(scsi_done_q
, i
));
1251 devfs_mk_dir("scsi");
1252 printk(KERN_NOTICE
"SCSI subsystem initialized\n");
1260 scsi_exit_devinfo();
1265 printk(KERN_ERR
"SCSI subsystem failed to initialize, error = %d\n",
1270 static void __exit
exit_scsi(void)
1272 scsi_sysfs_unregister();
1275 scsi_exit_devinfo();
1276 devfs_remove("scsi");
1281 subsys_initcall(init_scsi
);
1282 module_exit(exit_scsi
);