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/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 #include <linux/async.h>
58 #include <asm/unaligned.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_driver.h>
65 #include <scsi/scsi_eh.h>
66 #include <scsi/scsi_host.h>
67 #include <scsi/scsi_tcq.h>
69 #include "scsi_priv.h"
70 #include "scsi_logging.h"
72 #define CREATE_TRACE_POINTS
73 #include <trace/events/scsi.h>
76 * Definitions and constants.
80 * Note - the initial logging level can be set here to log events at boot time.
81 * After the system is up, you may enable logging via the /proc interface.
83 unsigned int scsi_logging_level
;
84 #if defined(CONFIG_SCSI_LOGGING)
85 EXPORT_SYMBOL(scsi_logging_level
);
88 /* sd, scsi core and power management need to coordinate flushing async actions */
89 ASYNC_DOMAIN(scsi_sd_probe_domain
);
90 EXPORT_SYMBOL(scsi_sd_probe_domain
);
93 * Separate domain (from scsi_sd_probe_domain) to maximize the benefit of
94 * asynchronous system resume operations. It is marked 'exclusive' to avoid
95 * being included in the async_synchronize_full() that is invoked by
98 ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain
);
99 EXPORT_SYMBOL(scsi_sd_pm_domain
);
101 struct scsi_host_cmd_pool
{
102 struct kmem_cache
*cmd_slab
;
103 struct kmem_cache
*sense_slab
;
107 unsigned int slab_flags
;
110 static struct scsi_host_cmd_pool scsi_cmd_pool
= {
111 .cmd_name
= "scsi_cmd_cache",
112 .sense_name
= "scsi_sense_cache",
113 .slab_flags
= SLAB_HWCACHE_ALIGN
,
116 static struct scsi_host_cmd_pool scsi_cmd_dma_pool
= {
117 .cmd_name
= "scsi_cmd_cache(DMA)",
118 .sense_name
= "scsi_sense_cache(DMA)",
119 .slab_flags
= SLAB_HWCACHE_ALIGN
|SLAB_CACHE_DMA
,
122 static DEFINE_MUTEX(host_cmd_pool_mutex
);
125 * scsi_host_free_command - internal function to release a command
126 * @shost: host to free the command for
127 * @cmd: command to release
129 * the command must previously have been allocated by
130 * scsi_host_alloc_command.
133 scsi_host_free_command(struct Scsi_Host
*shost
, struct scsi_cmnd
*cmd
)
135 struct scsi_host_cmd_pool
*pool
= shost
->cmd_pool
;
138 kmem_cache_free(scsi_sdb_cache
, cmd
->prot_sdb
);
139 kmem_cache_free(pool
->sense_slab
, cmd
->sense_buffer
);
140 kmem_cache_free(pool
->cmd_slab
, cmd
);
144 * scsi_host_alloc_command - internal function to allocate command
145 * @shost: SCSI host whose pool to allocate from
146 * @gfp_mask: mask for the allocation
148 * Returns a fully allocated command with sense buffer and protection
149 * data buffer (where applicable) or NULL on failure
151 static struct scsi_cmnd
*
152 scsi_host_alloc_command(struct Scsi_Host
*shost
, gfp_t gfp_mask
)
154 struct scsi_host_cmd_pool
*pool
= shost
->cmd_pool
;
155 struct scsi_cmnd
*cmd
;
157 cmd
= kmem_cache_zalloc(pool
->cmd_slab
, gfp_mask
);
161 cmd
->sense_buffer
= kmem_cache_alloc(pool
->sense_slab
, gfp_mask
);
162 if (!cmd
->sense_buffer
)
165 if (scsi_host_get_prot(shost
) >= SHOST_DIX_TYPE0_PROTECTION
) {
166 cmd
->prot_sdb
= kmem_cache_zalloc(scsi_sdb_cache
, gfp_mask
);
168 goto fail_free_sense
;
174 kmem_cache_free(pool
->sense_slab
, cmd
->sense_buffer
);
176 kmem_cache_free(pool
->cmd_slab
, cmd
);
182 * __scsi_get_command - Allocate a struct scsi_cmnd
183 * @shost: host to transmit command
184 * @gfp_mask: allocation mask
186 * Description: allocate a struct scsi_cmd from host's slab, recycling from the
187 * host's free_list if necessary.
189 static struct scsi_cmnd
*
190 __scsi_get_command(struct Scsi_Host
*shost
, gfp_t gfp_mask
)
192 struct scsi_cmnd
*cmd
= scsi_host_alloc_command(shost
, gfp_mask
);
194 if (unlikely(!cmd
)) {
197 spin_lock_irqsave(&shost
->free_list_lock
, flags
);
198 if (likely(!list_empty(&shost
->free_list
))) {
199 cmd
= list_entry(shost
->free_list
.next
,
200 struct scsi_cmnd
, list
);
201 list_del_init(&cmd
->list
);
203 spin_unlock_irqrestore(&shost
->free_list_lock
, flags
);
208 buf
= cmd
->sense_buffer
;
209 prot
= cmd
->prot_sdb
;
211 memset(cmd
, 0, sizeof(*cmd
));
213 cmd
->sense_buffer
= buf
;
214 cmd
->prot_sdb
= prot
;
222 * scsi_get_command - Allocate and setup a scsi command block
223 * @dev: parent scsi device
224 * @gfp_mask: allocator flags
226 * Returns: The allocated scsi command structure.
228 struct scsi_cmnd
*scsi_get_command(struct scsi_device
*dev
, gfp_t gfp_mask
)
230 struct scsi_cmnd
*cmd
= __scsi_get_command(dev
->host
, gfp_mask
);
233 if (unlikely(cmd
== NULL
))
237 INIT_LIST_HEAD(&cmd
->list
);
238 INIT_DELAYED_WORK(&cmd
->abort_work
, scmd_eh_abort_handler
);
239 spin_lock_irqsave(&dev
->list_lock
, flags
);
240 list_add_tail(&cmd
->list
, &dev
->cmd_list
);
241 spin_unlock_irqrestore(&dev
->list_lock
, flags
);
242 cmd
->jiffies_at_alloc
= jiffies
;
247 * __scsi_put_command - Free a struct scsi_cmnd
249 * @cmd: Command to free
251 static void __scsi_put_command(struct Scsi_Host
*shost
, struct scsi_cmnd
*cmd
)
255 if (unlikely(list_empty(&shost
->free_list
))) {
256 spin_lock_irqsave(&shost
->free_list_lock
, flags
);
257 if (list_empty(&shost
->free_list
)) {
258 list_add(&cmd
->list
, &shost
->free_list
);
261 spin_unlock_irqrestore(&shost
->free_list_lock
, flags
);
264 if (likely(cmd
!= NULL
))
265 scsi_host_free_command(shost
, cmd
);
269 * scsi_put_command - Free a scsi command block
270 * @cmd: command block to free
274 * Notes: The command must not belong to any lists.
276 void scsi_put_command(struct scsi_cmnd
*cmd
)
280 /* serious error if the command hasn't come from a device list */
281 spin_lock_irqsave(&cmd
->device
->list_lock
, flags
);
282 BUG_ON(list_empty(&cmd
->list
));
283 list_del_init(&cmd
->list
);
284 spin_unlock_irqrestore(&cmd
->device
->list_lock
, flags
);
286 BUG_ON(delayed_work_pending(&cmd
->abort_work
));
288 __scsi_put_command(cmd
->device
->host
, cmd
);
291 static struct scsi_host_cmd_pool
*
292 scsi_find_host_cmd_pool(struct Scsi_Host
*shost
)
294 if (shost
->hostt
->cmd_size
)
295 return shost
->hostt
->cmd_pool
;
296 if (shost
->unchecked_isa_dma
)
297 return &scsi_cmd_dma_pool
;
298 return &scsi_cmd_pool
;
302 scsi_free_host_cmd_pool(struct scsi_host_cmd_pool
*pool
)
304 kfree(pool
->sense_name
);
305 kfree(pool
->cmd_name
);
309 static struct scsi_host_cmd_pool
*
310 scsi_alloc_host_cmd_pool(struct Scsi_Host
*shost
)
312 struct scsi_host_template
*hostt
= shost
->hostt
;
313 struct scsi_host_cmd_pool
*pool
;
315 pool
= kzalloc(sizeof(*pool
), GFP_KERNEL
);
319 pool
->cmd_name
= kasprintf(GFP_KERNEL
, "%s_cmd", hostt
->proc_name
);
320 pool
->sense_name
= kasprintf(GFP_KERNEL
, "%s_sense", hostt
->proc_name
);
321 if (!pool
->cmd_name
|| !pool
->sense_name
) {
322 scsi_free_host_cmd_pool(pool
);
326 pool
->slab_flags
= SLAB_HWCACHE_ALIGN
;
327 if (shost
->unchecked_isa_dma
)
328 pool
->slab_flags
|= SLAB_CACHE_DMA
;
331 hostt
->cmd_pool
= pool
;
336 static struct scsi_host_cmd_pool
*
337 scsi_get_host_cmd_pool(struct Scsi_Host
*shost
)
339 struct scsi_host_template
*hostt
= shost
->hostt
;
340 struct scsi_host_cmd_pool
*retval
= NULL
, *pool
;
341 size_t cmd_size
= sizeof(struct scsi_cmnd
) + hostt
->cmd_size
;
344 * Select a command slab for this host and create it if not
347 mutex_lock(&host_cmd_pool_mutex
);
348 pool
= scsi_find_host_cmd_pool(shost
);
350 pool
= scsi_alloc_host_cmd_pool(shost
);
356 pool
->cmd_slab
= kmem_cache_create(pool
->cmd_name
, cmd_size
, 0,
357 pool
->slab_flags
, NULL
);
361 pool
->sense_slab
= kmem_cache_create(pool
->sense_name
,
362 SCSI_SENSE_BUFFERSIZE
, 0,
363 pool
->slab_flags
, NULL
);
364 if (!pool
->sense_slab
)
371 mutex_unlock(&host_cmd_pool_mutex
);
375 kmem_cache_destroy(pool
->cmd_slab
);
377 if (hostt
->cmd_size
) {
378 scsi_free_host_cmd_pool(pool
);
379 hostt
->cmd_pool
= NULL
;
384 static void scsi_put_host_cmd_pool(struct Scsi_Host
*shost
)
386 struct scsi_host_template
*hostt
= shost
->hostt
;
387 struct scsi_host_cmd_pool
*pool
;
389 mutex_lock(&host_cmd_pool_mutex
);
390 pool
= scsi_find_host_cmd_pool(shost
);
393 * This may happen if a driver has a mismatched get and put
394 * of the command pool; the driver should be implicated in
397 BUG_ON(pool
->users
== 0);
399 if (!--pool
->users
) {
400 kmem_cache_destroy(pool
->cmd_slab
);
401 kmem_cache_destroy(pool
->sense_slab
);
402 if (hostt
->cmd_size
) {
403 scsi_free_host_cmd_pool(pool
);
404 hostt
->cmd_pool
= NULL
;
407 mutex_unlock(&host_cmd_pool_mutex
);
411 * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
412 * @shost: host to allocate the freelist for.
414 * Description: The command freelist protects against system-wide out of memory
415 * deadlock by preallocating one SCSI command structure for each host, so the
416 * system can always write to a swap file on a device associated with that host.
420 int scsi_setup_command_freelist(struct Scsi_Host
*shost
)
422 struct scsi_cmnd
*cmd
;
424 spin_lock_init(&shost
->free_list_lock
);
425 INIT_LIST_HEAD(&shost
->free_list
);
427 shost
->cmd_pool
= scsi_get_host_cmd_pool(shost
);
428 if (!shost
->cmd_pool
)
432 * Get one backup command for this host.
434 cmd
= scsi_host_alloc_command(shost
, GFP_KERNEL
);
436 scsi_put_host_cmd_pool(shost
);
437 shost
->cmd_pool
= NULL
;
440 list_add(&cmd
->list
, &shost
->free_list
);
445 * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
446 * @shost: host whose freelist is going to be destroyed
448 void scsi_destroy_command_freelist(struct Scsi_Host
*shost
)
451 * If cmd_pool is NULL the free list was not initialized, so
452 * do not attempt to release resources.
454 if (!shost
->cmd_pool
)
457 while (!list_empty(&shost
->free_list
)) {
458 struct scsi_cmnd
*cmd
;
460 cmd
= list_entry(shost
->free_list
.next
, struct scsi_cmnd
, list
);
461 list_del_init(&cmd
->list
);
462 scsi_host_free_command(shost
, cmd
);
464 shost
->cmd_pool
= NULL
;
465 scsi_put_host_cmd_pool(shost
);
468 #ifdef CONFIG_SCSI_LOGGING
469 void scsi_log_send(struct scsi_cmnd
*cmd
)
474 * If ML QUEUE log level is greater than or equal to:
476 * 1: nothing (match completion)
478 * 2: log opcode + command of all commands + cmd address
484 if (unlikely(scsi_logging_level
)) {
485 level
= SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT
,
486 SCSI_LOG_MLQUEUE_BITS
);
488 scmd_printk(KERN_INFO
, cmd
,
489 "Send: scmd 0x%p\n", cmd
);
490 scsi_print_command(cmd
);
495 void scsi_log_completion(struct scsi_cmnd
*cmd
, int disposition
)
500 * If ML COMPLETE log level is greater than or equal to:
502 * 1: log disposition, result, opcode + command, and conditionally
503 * sense data for failures or non SUCCESS dispositions.
505 * 2: same as 1 but for all command completions.
509 * 4: same as 3 plus dump extra junk
511 if (unlikely(scsi_logging_level
)) {
512 level
= SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT
,
513 SCSI_LOG_MLCOMPLETE_BITS
);
514 if (((level
> 0) && (cmd
->result
|| disposition
!= SUCCESS
)) ||
516 scsi_print_result(cmd
, "Done", disposition
);
517 scsi_print_command(cmd
);
518 if (status_byte(cmd
->result
) & CHECK_CONDITION
)
519 scsi_print_sense(cmd
);
521 scmd_printk(KERN_INFO
, cmd
,
522 "scsi host busy %d failed %d\n",
523 atomic_read(&cmd
->device
->host
->host_busy
),
524 cmd
->device
->host
->host_failed
);
531 * scsi_cmd_get_serial - Assign a serial number to a command
532 * @host: the scsi host
533 * @cmd: command to assign serial number to
535 * Description: a serial number identifies a request for error recovery
536 * and debugging purposes. Protected by the Host_Lock of host.
538 void scsi_cmd_get_serial(struct Scsi_Host
*host
, struct scsi_cmnd
*cmd
)
540 cmd
->serial_number
= host
->cmd_serial_number
++;
541 if (cmd
->serial_number
== 0)
542 cmd
->serial_number
= host
->cmd_serial_number
++;
544 EXPORT_SYMBOL(scsi_cmd_get_serial
);
547 * scsi_finish_command - cleanup and pass command back to upper layer
550 * Description: Pass command off to upper layer for finishing of I/O
551 * request, waking processes that are waiting on results,
554 void scsi_finish_command(struct scsi_cmnd
*cmd
)
556 struct scsi_device
*sdev
= cmd
->device
;
557 struct scsi_target
*starget
= scsi_target(sdev
);
558 struct Scsi_Host
*shost
= sdev
->host
;
559 struct scsi_driver
*drv
;
560 unsigned int good_bytes
;
562 scsi_device_unbusy(sdev
);
565 * Clear the flags that say that the device/target/host is no longer
566 * capable of accepting new commands.
568 if (atomic_read(&shost
->host_blocked
))
569 atomic_set(&shost
->host_blocked
, 0);
570 if (atomic_read(&starget
->target_blocked
))
571 atomic_set(&starget
->target_blocked
, 0);
572 if (atomic_read(&sdev
->device_blocked
))
573 atomic_set(&sdev
->device_blocked
, 0);
576 * If we have valid sense information, then some kind of recovery
577 * must have taken place. Make a note of this.
579 if (SCSI_SENSE_VALID(cmd
))
580 cmd
->result
|= (DRIVER_SENSE
<< 24);
582 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO
, sdev
,
583 "Notifying upper driver of completion "
584 "(result %x)\n", cmd
->result
));
586 good_bytes
= scsi_bufflen(cmd
);
587 if (cmd
->request
->cmd_type
!= REQ_TYPE_BLOCK_PC
) {
588 int old_good_bytes
= good_bytes
;
589 drv
= scsi_cmd_to_driver(cmd
);
591 good_bytes
= drv
->done(cmd
);
593 * USB may not give sense identifying bad sector and
594 * simply return a residue instead, so subtract off the
595 * residue if drv->done() error processing indicates no
596 * change to the completion length.
598 if (good_bytes
== old_good_bytes
)
599 good_bytes
-= scsi_get_resid(cmd
);
601 scsi_io_completion(cmd
, good_bytes
);
605 * scsi_change_queue_depth - change a device's queue depth
606 * @sdev: SCSI Device in question
607 * @depth: number of commands allowed to be queued to the driver
609 * Sets the device queue depth and returns the new value.
611 int scsi_change_queue_depth(struct scsi_device
*sdev
, int depth
)
614 sdev
->queue_depth
= depth
;
618 if (sdev
->request_queue
)
619 blk_set_queue_depth(sdev
->request_queue
, depth
);
621 return sdev
->queue_depth
;
623 EXPORT_SYMBOL(scsi_change_queue_depth
);
626 * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
627 * @sdev: SCSI Device in question
628 * @depth: Current number of outstanding SCSI commands on this device,
629 * not counting the one returned as QUEUE_FULL.
631 * Description: This function will track successive QUEUE_FULL events on a
632 * specific SCSI device to determine if and when there is a
633 * need to adjust the queue depth on the device.
635 * Returns: 0 - No change needed, >0 - Adjust queue depth to this new depth,
636 * -1 - Drop back to untagged operation using host->cmd_per_lun
637 * as the untagged command depth
639 * Lock Status: None held on entry
641 * Notes: Low level drivers may call this at any time and we will do
642 * "The Right Thing." We are interrupt context safe.
644 int scsi_track_queue_full(struct scsi_device
*sdev
, int depth
)
648 * Don't let QUEUE_FULLs on the same
649 * jiffies count, they could all be from
652 if ((jiffies
>> 4) == (sdev
->last_queue_full_time
>> 4))
655 sdev
->last_queue_full_time
= jiffies
;
656 if (sdev
->last_queue_full_depth
!= depth
) {
657 sdev
->last_queue_full_count
= 1;
658 sdev
->last_queue_full_depth
= depth
;
660 sdev
->last_queue_full_count
++;
663 if (sdev
->last_queue_full_count
<= 10)
666 return scsi_change_queue_depth(sdev
, depth
);
668 EXPORT_SYMBOL(scsi_track_queue_full
);
671 * scsi_vpd_inquiry - Request a device provide us with a VPD page
672 * @sdev: The device to ask
673 * @buffer: Where to put the result
674 * @page: Which Vital Product Data to return
675 * @len: The length of the buffer
677 * This is an internal helper function. You probably want to use
678 * scsi_get_vpd_page instead.
680 * Returns size of the vpd page on success or a negative error number.
682 static int scsi_vpd_inquiry(struct scsi_device
*sdev
, unsigned char *buffer
,
683 u8 page
, unsigned len
)
686 unsigned char cmd
[16];
692 cmd
[1] = 1; /* EVPD */
696 cmd
[5] = 0; /* Control byte */
699 * I'm not convinced we need to try quite this hard to get VPD, but
700 * all the existing users tried this hard.
702 result
= scsi_execute_req(sdev
, cmd
, DMA_FROM_DEVICE
, buffer
,
703 len
, NULL
, 30 * HZ
, 3, NULL
);
707 /* Sanity check that we got the page back that we asked for */
708 if (buffer
[1] != page
)
711 return get_unaligned_be16(&buffer
[2]) + 4;
715 * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
716 * @sdev: The device to ask
717 * @page: Which Vital Product Data to return
718 * @buf: where to store the VPD
719 * @buf_len: number of bytes in the VPD buffer area
721 * SCSI devices may optionally supply Vital Product Data. Each 'page'
722 * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
723 * If the device supports this VPD page, this routine returns a pointer
724 * to a buffer containing the data from that page. The caller is
725 * responsible for calling kfree() on this pointer when it is no longer
726 * needed. If we cannot retrieve the VPD page this routine returns %NULL.
728 int scsi_get_vpd_page(struct scsi_device
*sdev
, u8 page
, unsigned char *buf
,
733 if (sdev
->skip_vpd_pages
)
736 /* Ask for all the pages supported by this device */
737 result
= scsi_vpd_inquiry(sdev
, buf
, 0, buf_len
);
741 /* If the user actually wanted this page, we can skip the rest */
745 for (i
= 4; i
< min(result
, buf_len
); i
++)
749 if (i
< result
&& i
>= buf_len
)
750 /* ran off the end of the buffer, give us benefit of doubt */
752 /* The device claims it doesn't support the requested page */
756 result
= scsi_vpd_inquiry(sdev
, buf
, page
, buf_len
);
765 EXPORT_SYMBOL_GPL(scsi_get_vpd_page
);
768 * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure
769 * @sdev: The device to ask
771 * Attach the 'Device Identification' VPD page (0x83) and the
772 * 'Unit Serial Number' VPD page (0x80) to a SCSI device
773 * structure. This information can be used to identify the device
776 void scsi_attach_vpd(struct scsi_device
*sdev
)
779 int vpd_len
= SCSI_VPD_PG_LEN
;
780 int pg80_supported
= 0;
781 int pg83_supported
= 0;
782 unsigned char __rcu
*vpd_buf
, *orig_vpd_buf
= NULL
;
784 if (!scsi_device_supports_vpd(sdev
))
788 vpd_buf
= kmalloc(vpd_len
, GFP_KERNEL
);
792 /* Ask for all the pages supported by this device */
793 result
= scsi_vpd_inquiry(sdev
, vpd_buf
, 0, vpd_len
);
798 if (result
> vpd_len
) {
804 for (i
= 4; i
< result
; i
++) {
805 if (vpd_buf
[i
] == 0x80)
807 if (vpd_buf
[i
] == 0x83)
811 vpd_len
= SCSI_VPD_PG_LEN
;
813 if (pg80_supported
) {
815 vpd_buf
= kmalloc(vpd_len
, GFP_KERNEL
);
819 result
= scsi_vpd_inquiry(sdev
, vpd_buf
, 0x80, vpd_len
);
824 if (result
> vpd_len
) {
829 mutex_lock(&sdev
->inquiry_mutex
);
830 orig_vpd_buf
= sdev
->vpd_pg80
;
831 sdev
->vpd_pg80_len
= result
;
832 rcu_assign_pointer(sdev
->vpd_pg80
, vpd_buf
);
833 mutex_unlock(&sdev
->inquiry_mutex
);
839 vpd_len
= SCSI_VPD_PG_LEN
;
842 if (pg83_supported
) {
844 vpd_buf
= kmalloc(vpd_len
, GFP_KERNEL
);
848 result
= scsi_vpd_inquiry(sdev
, vpd_buf
, 0x83, vpd_len
);
853 if (result
> vpd_len
) {
858 mutex_lock(&sdev
->inquiry_mutex
);
859 orig_vpd_buf
= sdev
->vpd_pg83
;
860 sdev
->vpd_pg83_len
= result
;
861 rcu_assign_pointer(sdev
->vpd_pg83
, vpd_buf
);
862 mutex_unlock(&sdev
->inquiry_mutex
);
870 * scsi_report_opcode - Find out if a given command opcode is supported
871 * @sdev: scsi device to query
872 * @buffer: scratch buffer (must be at least 20 bytes long)
873 * @len: length of buffer
874 * @opcode: opcode for command to look up
876 * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
877 * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
878 * unsupported and 1 if the device claims to support the command.
880 int scsi_report_opcode(struct scsi_device
*sdev
, unsigned char *buffer
,
881 unsigned int len
, unsigned char opcode
)
883 unsigned char cmd
[16];
884 struct scsi_sense_hdr sshdr
;
887 if (sdev
->no_report_opcodes
|| sdev
->scsi_level
< SCSI_SPC_3
)
891 cmd
[0] = MAINTENANCE_IN
;
892 cmd
[1] = MI_REPORT_SUPPORTED_OPERATION_CODES
;
893 cmd
[2] = 1; /* One command format */
895 put_unaligned_be32(len
, &cmd
[6]);
896 memset(buffer
, 0, len
);
898 result
= scsi_execute_req(sdev
, cmd
, DMA_FROM_DEVICE
, buffer
, len
,
899 &sshdr
, 30 * HZ
, 3, NULL
);
901 if (result
&& scsi_sense_valid(&sshdr
) &&
902 sshdr
.sense_key
== ILLEGAL_REQUEST
&&
903 (sshdr
.asc
== 0x20 || sshdr
.asc
== 0x24) && sshdr
.ascq
== 0x00)
906 if ((buffer
[1] & 3) == 3) /* Command supported */
911 EXPORT_SYMBOL(scsi_report_opcode
);
914 * scsi_device_get - get an additional reference to a scsi_device
915 * @sdev: device to get a reference to
917 * Description: Gets a reference to the scsi_device and increments the use count
918 * of the underlying LLDD module. You must hold host_lock of the
919 * parent Scsi_Host or already have a reference when calling this.
921 * This will fail if a device is deleted or cancelled, or when the LLD module
922 * is in the process of being unloaded.
924 int scsi_device_get(struct scsi_device
*sdev
)
926 if (sdev
->sdev_state
== SDEV_DEL
|| sdev
->sdev_state
== SDEV_CANCEL
)
928 if (!get_device(&sdev
->sdev_gendev
))
930 if (!try_module_get(sdev
->host
->hostt
->module
))
931 goto fail_put_device
;
935 put_device(&sdev
->sdev_gendev
);
939 EXPORT_SYMBOL(scsi_device_get
);
942 * scsi_device_put - release a reference to a scsi_device
943 * @sdev: device to release a reference on.
945 * Description: Release a reference to the scsi_device and decrements the use
946 * count of the underlying LLDD module. The device is freed once the last
949 void scsi_device_put(struct scsi_device
*sdev
)
951 module_put(sdev
->host
->hostt
->module
);
952 put_device(&sdev
->sdev_gendev
);
954 EXPORT_SYMBOL(scsi_device_put
);
956 /* helper for shost_for_each_device, see that for documentation */
957 struct scsi_device
*__scsi_iterate_devices(struct Scsi_Host
*shost
,
958 struct scsi_device
*prev
)
960 struct list_head
*list
= (prev
? &prev
->siblings
: &shost
->__devices
);
961 struct scsi_device
*next
= NULL
;
964 spin_lock_irqsave(shost
->host_lock
, flags
);
965 while (list
->next
!= &shost
->__devices
) {
966 next
= list_entry(list
->next
, struct scsi_device
, siblings
);
967 /* skip devices that we can't get a reference to */
968 if (!scsi_device_get(next
))
973 spin_unlock_irqrestore(shost
->host_lock
, flags
);
976 scsi_device_put(prev
);
979 EXPORT_SYMBOL(__scsi_iterate_devices
);
982 * starget_for_each_device - helper to walk all devices of a target
983 * @starget: target whose devices we want to iterate over.
984 * @data: Opaque passed to each function call.
985 * @fn: Function to call on each device
987 * This traverses over each device of @starget. The devices have
988 * a reference that must be released by scsi_host_put when breaking
991 void starget_for_each_device(struct scsi_target
*starget
, void *data
,
992 void (*fn
)(struct scsi_device
*, void *))
994 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
995 struct scsi_device
*sdev
;
997 shost_for_each_device(sdev
, shost
) {
998 if ((sdev
->channel
== starget
->channel
) &&
999 (sdev
->id
== starget
->id
))
1003 EXPORT_SYMBOL(starget_for_each_device
);
1006 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1007 * @starget: target whose devices we want to iterate over.
1008 * @data: parameter for callback @fn()
1009 * @fn: callback function that is invoked for each device
1011 * This traverses over each device of @starget. It does _not_
1012 * take a reference on the scsi_device, so the whole loop must be
1013 * protected by shost->host_lock.
1015 * Note: The only reason why drivers would want to use this is because
1016 * they need to access the device list in irq context. Otherwise you
1017 * really want to use starget_for_each_device instead.
1019 void __starget_for_each_device(struct scsi_target
*starget
, void *data
,
1020 void (*fn
)(struct scsi_device
*, void *))
1022 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
1023 struct scsi_device
*sdev
;
1025 __shost_for_each_device(sdev
, shost
) {
1026 if ((sdev
->channel
== starget
->channel
) &&
1027 (sdev
->id
== starget
->id
))
1031 EXPORT_SYMBOL(__starget_for_each_device
);
1034 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1035 * @starget: SCSI target pointer
1036 * @lun: SCSI Logical Unit Number
1038 * Description: Looks up the scsi_device with the specified @lun for a given
1039 * @starget. The returned scsi_device does not have an additional
1040 * reference. You must hold the host's host_lock over this call and
1041 * any access to the returned scsi_device. A scsi_device in state
1042 * SDEV_DEL is skipped.
1044 * Note: The only reason why drivers should use this is because
1045 * they need to access the device list in irq context. Otherwise you
1046 * really want to use scsi_device_lookup_by_target instead.
1048 struct scsi_device
*__scsi_device_lookup_by_target(struct scsi_target
*starget
,
1051 struct scsi_device
*sdev
;
1053 list_for_each_entry(sdev
, &starget
->devices
, same_target_siblings
) {
1054 if (sdev
->sdev_state
== SDEV_DEL
)
1056 if (sdev
->lun
==lun
)
1062 EXPORT_SYMBOL(__scsi_device_lookup_by_target
);
1065 * scsi_device_lookup_by_target - find a device given the target
1066 * @starget: SCSI target pointer
1067 * @lun: SCSI Logical Unit Number
1069 * Description: Looks up the scsi_device with the specified @lun for a given
1070 * @starget. The returned scsi_device has an additional reference that
1071 * needs to be released with scsi_device_put once you're done with it.
1073 struct scsi_device
*scsi_device_lookup_by_target(struct scsi_target
*starget
,
1076 struct scsi_device
*sdev
;
1077 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
1078 unsigned long flags
;
1080 spin_lock_irqsave(shost
->host_lock
, flags
);
1081 sdev
= __scsi_device_lookup_by_target(starget
, lun
);
1082 if (sdev
&& scsi_device_get(sdev
))
1084 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1088 EXPORT_SYMBOL(scsi_device_lookup_by_target
);
1091 * __scsi_device_lookup - find a device given the host (UNLOCKED)
1092 * @shost: SCSI host pointer
1093 * @channel: SCSI channel (zero if only one channel)
1094 * @id: SCSI target number (physical unit number)
1095 * @lun: SCSI Logical Unit Number
1097 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1098 * for a given host. The returned scsi_device does not have an additional
1099 * reference. You must hold the host's host_lock over this call and any access
1100 * to the returned scsi_device.
1102 * Note: The only reason why drivers would want to use this is because
1103 * they need to access the device list in irq context. Otherwise you
1104 * really want to use scsi_device_lookup instead.
1106 struct scsi_device
*__scsi_device_lookup(struct Scsi_Host
*shost
,
1107 uint channel
, uint id
, u64 lun
)
1109 struct scsi_device
*sdev
;
1111 list_for_each_entry(sdev
, &shost
->__devices
, siblings
) {
1112 if (sdev
->channel
== channel
&& sdev
->id
== id
&&
1119 EXPORT_SYMBOL(__scsi_device_lookup
);
1122 * scsi_device_lookup - find a device given the host
1123 * @shost: SCSI host pointer
1124 * @channel: SCSI channel (zero if only one channel)
1125 * @id: SCSI target number (physical unit number)
1126 * @lun: SCSI Logical Unit Number
1128 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1129 * for a given host. The returned scsi_device has an additional reference that
1130 * needs to be released with scsi_device_put once you're done with it.
1132 struct scsi_device
*scsi_device_lookup(struct Scsi_Host
*shost
,
1133 uint channel
, uint id
, u64 lun
)
1135 struct scsi_device
*sdev
;
1136 unsigned long flags
;
1138 spin_lock_irqsave(shost
->host_lock
, flags
);
1139 sdev
= __scsi_device_lookup(shost
, channel
, id
, lun
);
1140 if (sdev
&& scsi_device_get(sdev
))
1142 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1146 EXPORT_SYMBOL(scsi_device_lookup
);
1148 MODULE_DESCRIPTION("SCSI core");
1149 MODULE_LICENSE("GPL");
1151 module_param(scsi_logging_level
, int, S_IRUGO
|S_IWUSR
);
1152 MODULE_PARM_DESC(scsi_logging_level
, "a bit mask of logging levels");
1154 #ifdef CONFIG_SCSI_MQ_DEFAULT
1155 bool scsi_use_blk_mq
= true;
1157 bool scsi_use_blk_mq
= false;
1159 module_param_named(use_blk_mq
, scsi_use_blk_mq
, bool, S_IWUSR
| S_IRUGO
);
1161 static int __init
init_scsi(void)
1165 error
= scsi_init_queue();
1168 error
= scsi_init_procfs();
1171 error
= scsi_init_devinfo();
1173 goto cleanup_procfs
;
1174 error
= scsi_init_hosts();
1176 goto cleanup_devlist
;
1177 error
= scsi_init_sysctl();
1180 error
= scsi_sysfs_register();
1182 goto cleanup_sysctl
;
1184 scsi_netlink_init();
1186 printk(KERN_NOTICE
"SCSI subsystem initialized\n");
1194 scsi_exit_devinfo();
1199 printk(KERN_ERR
"SCSI subsystem failed to initialize, error = %d\n",
1204 static void __exit
exit_scsi(void)
1206 scsi_netlink_exit();
1207 scsi_sysfs_unregister();
1210 scsi_exit_devinfo();
1213 async_unregister_domain(&scsi_sd_probe_domain
);
1216 subsys_initcall(init_scsi
);
1217 module_exit(exit_scsi
);