11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * scsi.c Copyright (C) 1992 Drew Eckhardt 31da177e4SLinus Torvalds * Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale 41da177e4SLinus Torvalds * Copyright (C) 2002, 2003 Christoph Hellwig 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * generic mid-level SCSI driver 71da177e4SLinus Torvalds * Initial versions: Drew Eckhardt 81da177e4SLinus Torvalds * Subsequent revisions: Eric Youngdale 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * <drew@colorado.edu> 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Bug correction thanks go to : 131da177e4SLinus Torvalds * Rik Faith <faith@cs.unc.edu> 141da177e4SLinus Torvalds * Tommy Thorn <tthorn> 151da177e4SLinus Torvalds * Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de> 161da177e4SLinus Torvalds * 171da177e4SLinus Torvalds * Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to 181da177e4SLinus Torvalds * add scatter-gather, multiple outstanding request, and other 191da177e4SLinus Torvalds * enhancements. 201da177e4SLinus Torvalds * 211da177e4SLinus Torvalds * Native multichannel, wide scsi, /proc/scsi and hot plugging 221da177e4SLinus Torvalds * support added by Michael Neuffer <mike@i-connect.net> 231da177e4SLinus Torvalds * 241da177e4SLinus Torvalds * Added request_module("scsi_hostadapter") for kerneld: 251da177e4SLinus Torvalds * (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf) 261da177e4SLinus Torvalds * Bjorn Ekwall <bj0rn@blox.se> 271da177e4SLinus Torvalds * (changed to kmod) 281da177e4SLinus Torvalds * 291da177e4SLinus Torvalds * Major improvements to the timeout, abort, and reset processing, 301da177e4SLinus Torvalds * as well as performance modifications for large queue depths by 311da177e4SLinus Torvalds * Leonard N. Zubkoff <lnz@dandelion.com> 321da177e4SLinus Torvalds * 331da177e4SLinus Torvalds * Converted cli() code to spinlocks, Ingo Molnar 341da177e4SLinus Torvalds * 351da177e4SLinus Torvalds * Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli 361da177e4SLinus Torvalds * 371da177e4SLinus Torvalds * out_of_space hacks, D. Gilbert (dpg) 990608 381da177e4SLinus Torvalds */ 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds #include <linux/module.h> 411da177e4SLinus Torvalds #include <linux/moduleparam.h> 421da177e4SLinus Torvalds #include <linux/kernel.h> 431da177e4SLinus Torvalds #include <linux/timer.h> 441da177e4SLinus Torvalds #include <linux/string.h> 451da177e4SLinus Torvalds #include <linux/slab.h> 461da177e4SLinus Torvalds #include <linux/blkdev.h> 471da177e4SLinus Torvalds #include <linux/delay.h> 481da177e4SLinus Torvalds #include <linux/init.h> 491da177e4SLinus Torvalds #include <linux/completion.h> 501da177e4SLinus Torvalds #include <linux/unistd.h> 511da177e4SLinus Torvalds #include <linux/spinlock.h> 521da177e4SLinus Torvalds #include <linux/kmod.h> 531da177e4SLinus Torvalds #include <linux/interrupt.h> 541da177e4SLinus Torvalds #include <linux/notifier.h> 551da177e4SLinus Torvalds #include <linux/cpu.h> 560b950672SArjan van de Ven #include <linux/mutex.h> 572955b47dSDan Williams #include <linux/async.h> 583c6bdaeaSMartin K. Petersen #include <asm/unaligned.h> 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds #include <scsi/scsi.h> 611da177e4SLinus Torvalds #include <scsi/scsi_cmnd.h> 621da177e4SLinus Torvalds #include <scsi/scsi_dbg.h> 631da177e4SLinus Torvalds #include <scsi/scsi_device.h> 647b3d9545SLinus Torvalds #include <scsi/scsi_driver.h> 651da177e4SLinus Torvalds #include <scsi/scsi_eh.h> 661da177e4SLinus Torvalds #include <scsi/scsi_host.h> 671da177e4SLinus Torvalds #include <scsi/scsi_tcq.h> 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds #include "scsi_priv.h" 701da177e4SLinus Torvalds #include "scsi_logging.h" 711da177e4SLinus Torvalds 72bf816235SKei Tokunaga #define CREATE_TRACE_POINTS 73bf816235SKei Tokunaga #include <trace/events/scsi.h> 74bf816235SKei Tokunaga 7552c1da39SAdrian Bunk static void scsi_done(struct scsi_cmnd *cmd); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* 781da177e4SLinus Torvalds * Definitions and constants. 791da177e4SLinus Torvalds */ 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds #define MIN_RESET_DELAY (2*HZ) 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds /* Do not call reset on error if we just did a reset within 15 sec. */ 841da177e4SLinus Torvalds #define MIN_RESET_PERIOD (15*HZ) 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds /* 871da177e4SLinus Torvalds * Note - the initial logging level can be set here to log events at boot time. 881da177e4SLinus Torvalds * After the system is up, you may enable logging via the /proc interface. 891da177e4SLinus Torvalds */ 901da177e4SLinus Torvalds unsigned int scsi_logging_level; 911da177e4SLinus Torvalds #if defined(CONFIG_SCSI_LOGGING) 921da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_logging_level); 931da177e4SLinus Torvalds #endif 941da177e4SLinus Torvalds 95ea80dadeSJames Bottomley /* sd, scsi core and power management need to coordinate flushing async actions */ 962955b47dSDan Williams ASYNC_DOMAIN(scsi_sd_probe_domain); 97a7a20d10SDan Williams EXPORT_SYMBOL(scsi_sd_probe_domain); 98a7a20d10SDan Williams 998a1cdc9cSMatthew Wilcox /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI. 1008a1cdc9cSMatthew Wilcox * You may not alter any existing entry (although adding new ones is 1018a1cdc9cSMatthew Wilcox * encouraged once assigned by ANSI/INCITS T10 1028a1cdc9cSMatthew Wilcox */ 1034ff36718SMatthew Wilcox static const char *const scsi_device_types[] = { 1048a1cdc9cSMatthew Wilcox "Direct-Access ", 1058a1cdc9cSMatthew Wilcox "Sequential-Access", 1061da177e4SLinus Torvalds "Printer ", 1071da177e4SLinus Torvalds "Processor ", 1081da177e4SLinus Torvalds "WORM ", 1098a1cdc9cSMatthew Wilcox "CD-ROM ", 1101da177e4SLinus Torvalds "Scanner ", 1118a1cdc9cSMatthew Wilcox "Optical Device ", 1128a1cdc9cSMatthew Wilcox "Medium Changer ", 1131da177e4SLinus Torvalds "Communications ", 1144ff36718SMatthew Wilcox "ASC IT8 ", 1154ff36718SMatthew Wilcox "ASC IT8 ", 1161da177e4SLinus Torvalds "RAID ", 1171da177e4SLinus Torvalds "Enclosure ", 1188a1cdc9cSMatthew Wilcox "Direct-Access-RBC", 1194ff36718SMatthew Wilcox "Optical card ", 1204ff36718SMatthew Wilcox "Bridge controller", 1214ff36718SMatthew Wilcox "Object storage ", 1224ff36718SMatthew Wilcox "Automation/Drive ", 1231da177e4SLinus Torvalds }; 1244ff36718SMatthew Wilcox 125eb44820cSRob Landley /** 126eb44820cSRob Landley * scsi_device_type - Return 17 char string indicating device type. 127eb44820cSRob Landley * @type: type number to look up 128eb44820cSRob Landley */ 129eb44820cSRob Landley 1304ff36718SMatthew Wilcox const char * scsi_device_type(unsigned type) 1314ff36718SMatthew Wilcox { 1324ff36718SMatthew Wilcox if (type == 0x1e) 1334ff36718SMatthew Wilcox return "Well-known LUN "; 1344ff36718SMatthew Wilcox if (type == 0x1f) 1354ff36718SMatthew Wilcox return "No Device "; 13680c6e3c0SEric Sesterhenn if (type >= ARRAY_SIZE(scsi_device_types)) 1374ff36718SMatthew Wilcox return "Unknown "; 1384ff36718SMatthew Wilcox return scsi_device_types[type]; 1394ff36718SMatthew Wilcox } 1404ff36718SMatthew Wilcox 1414ff36718SMatthew Wilcox EXPORT_SYMBOL(scsi_device_type); 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds struct scsi_host_cmd_pool { 1445b7f1680SJames Bottomley struct kmem_cache *cmd_slab; 1455b7f1680SJames Bottomley struct kmem_cache *sense_slab; 1461da177e4SLinus Torvalds unsigned int users; 1475b7f1680SJames Bottomley char *cmd_name; 1485b7f1680SJames Bottomley char *sense_name; 1491da177e4SLinus Torvalds unsigned int slab_flags; 150c53033f6SAl Viro gfp_t gfp_mask; 1511da177e4SLinus Torvalds }; 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds static struct scsi_host_cmd_pool scsi_cmd_pool = { 1545b7f1680SJames Bottomley .cmd_name = "scsi_cmd_cache", 1555b7f1680SJames Bottomley .sense_name = "scsi_sense_cache", 1561da177e4SLinus Torvalds .slab_flags = SLAB_HWCACHE_ALIGN, 1571da177e4SLinus Torvalds }; 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds static struct scsi_host_cmd_pool scsi_cmd_dma_pool = { 1605b7f1680SJames Bottomley .cmd_name = "scsi_cmd_cache(DMA)", 1615b7f1680SJames Bottomley .sense_name = "scsi_sense_cache(DMA)", 1621da177e4SLinus Torvalds .slab_flags = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA, 1631da177e4SLinus Torvalds .gfp_mask = __GFP_DMA, 1641da177e4SLinus Torvalds }; 1651da177e4SLinus Torvalds 1660b950672SArjan van de Ven static DEFINE_MUTEX(host_cmd_pool_mutex); 1671da177e4SLinus Torvalds 168eb44820cSRob Landley /** 169e507e30bSJames Bottomley * scsi_pool_alloc_command - internal function to get a fully allocated command 170e507e30bSJames Bottomley * @pool: slab pool to allocate the command from 171e507e30bSJames Bottomley * @gfp_mask: mask for the allocation 172e507e30bSJames Bottomley * 173e507e30bSJames Bottomley * Returns a fully allocated command (with the allied sense buffer) or 174e507e30bSJames Bottomley * NULL on failure 175e507e30bSJames Bottomley */ 176e507e30bSJames Bottomley static struct scsi_cmnd * 177e507e30bSJames Bottomley scsi_pool_alloc_command(struct scsi_host_cmd_pool *pool, gfp_t gfp_mask) 178e507e30bSJames Bottomley { 179e507e30bSJames Bottomley struct scsi_cmnd *cmd; 180e507e30bSJames Bottomley 181ebef264bSWei Yongjun cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask); 182e507e30bSJames Bottomley if (!cmd) 183e507e30bSJames Bottomley return NULL; 184e507e30bSJames Bottomley 185e507e30bSJames Bottomley cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab, 186e507e30bSJames Bottomley gfp_mask | pool->gfp_mask); 187e507e30bSJames Bottomley if (!cmd->sense_buffer) { 188e507e30bSJames Bottomley kmem_cache_free(pool->cmd_slab, cmd); 189e507e30bSJames Bottomley return NULL; 190e507e30bSJames Bottomley } 191e507e30bSJames Bottomley 192e507e30bSJames Bottomley return cmd; 193e507e30bSJames Bottomley } 194e507e30bSJames Bottomley 195e507e30bSJames Bottomley /** 196e507e30bSJames Bottomley * scsi_pool_free_command - internal function to release a command 197e507e30bSJames Bottomley * @pool: slab pool to allocate the command from 198e507e30bSJames Bottomley * @cmd: command to release 199e507e30bSJames Bottomley * 200e507e30bSJames Bottomley * the command must previously have been allocated by 201e507e30bSJames Bottomley * scsi_pool_alloc_command. 202e507e30bSJames Bottomley */ 203e507e30bSJames Bottomley static void 204e507e30bSJames Bottomley scsi_pool_free_command(struct scsi_host_cmd_pool *pool, 205e507e30bSJames Bottomley struct scsi_cmnd *cmd) 206e507e30bSJames Bottomley { 2077027ad72SMartin K. Petersen if (cmd->prot_sdb) 2087027ad72SMartin K. Petersen kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb); 2097027ad72SMartin K. Petersen 210e507e30bSJames Bottomley kmem_cache_free(pool->sense_slab, cmd->sense_buffer); 211e507e30bSJames Bottomley kmem_cache_free(pool->cmd_slab, cmd); 212e507e30bSJames Bottomley } 213e507e30bSJames Bottomley 214e507e30bSJames Bottomley /** 2157027ad72SMartin K. Petersen * scsi_host_alloc_command - internal function to allocate command 2167027ad72SMartin K. Petersen * @shost: SCSI host whose pool to allocate from 2177027ad72SMartin K. Petersen * @gfp_mask: mask for the allocation 2187027ad72SMartin K. Petersen * 2197027ad72SMartin K. Petersen * Returns a fully allocated command with sense buffer and protection 2207027ad72SMartin K. Petersen * data buffer (where applicable) or NULL on failure 2217027ad72SMartin K. Petersen */ 2227027ad72SMartin K. Petersen static struct scsi_cmnd * 2237027ad72SMartin K. Petersen scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask) 2247027ad72SMartin K. Petersen { 2257027ad72SMartin K. Petersen struct scsi_cmnd *cmd; 2267027ad72SMartin K. Petersen 2277027ad72SMartin K. Petersen cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask); 2287027ad72SMartin K. Petersen if (!cmd) 2297027ad72SMartin K. Petersen return NULL; 2307027ad72SMartin K. Petersen 2317027ad72SMartin K. Petersen if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) { 2327027ad72SMartin K. Petersen cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask); 2337027ad72SMartin K. Petersen 2347027ad72SMartin K. Petersen if (!cmd->prot_sdb) { 2357027ad72SMartin K. Petersen scsi_pool_free_command(shost->cmd_pool, cmd); 2367027ad72SMartin K. Petersen return NULL; 2377027ad72SMartin K. Petersen } 2387027ad72SMartin K. Petersen } 2397027ad72SMartin K. Petersen 2407027ad72SMartin K. Petersen return cmd; 2417027ad72SMartin K. Petersen } 2427027ad72SMartin K. Petersen 2437027ad72SMartin K. Petersen /** 244eb44820cSRob Landley * __scsi_get_command - Allocate a struct scsi_cmnd 245eb44820cSRob Landley * @shost: host to transmit command 246eb44820cSRob Landley * @gfp_mask: allocation mask 247eb44820cSRob Landley * 248eb44820cSRob Landley * Description: allocate a struct scsi_cmd from host's slab, recycling from the 249eb44820cSRob Landley * host's free_list if necessary. 250eb44820cSRob Landley */ 251b58d9154SFUJITA Tomonori struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask) 2521da177e4SLinus Torvalds { 253b4c2554dSMartin K. Petersen struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask); 254164fc5dcSHugh Dickins 2551da177e4SLinus Torvalds if (unlikely(!cmd)) { 2561da177e4SLinus Torvalds unsigned long flags; 2571da177e4SLinus Torvalds 2581da177e4SLinus Torvalds spin_lock_irqsave(&shost->free_list_lock, flags); 2591da177e4SLinus Torvalds if (likely(!list_empty(&shost->free_list))) { 2601da177e4SLinus Torvalds cmd = list_entry(shost->free_list.next, 2611da177e4SLinus Torvalds struct scsi_cmnd, list); 2621da177e4SLinus Torvalds list_del_init(&cmd->list); 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds spin_unlock_irqrestore(&shost->free_list_lock, flags); 265de25deb1SFUJITA Tomonori 266de25deb1SFUJITA Tomonori if (cmd) { 267b4c2554dSMartin K. Petersen void *buf, *prot; 268b4c2554dSMartin K. Petersen 269de25deb1SFUJITA Tomonori buf = cmd->sense_buffer; 270b4c2554dSMartin K. Petersen prot = cmd->prot_sdb; 271b4c2554dSMartin K. Petersen 272de25deb1SFUJITA Tomonori memset(cmd, 0, sizeof(*cmd)); 273b4c2554dSMartin K. Petersen 274de25deb1SFUJITA Tomonori cmd->sense_buffer = buf; 275b4c2554dSMartin K. Petersen cmd->prot_sdb = prot; 276de25deb1SFUJITA Tomonori } 2771da177e4SLinus Torvalds } 2781da177e4SLinus Torvalds 2791da177e4SLinus Torvalds return cmd; 2801da177e4SLinus Torvalds } 281b58d9154SFUJITA Tomonori EXPORT_SYMBOL_GPL(__scsi_get_command); 2821da177e4SLinus Torvalds 283eb44820cSRob Landley /** 284eb44820cSRob Landley * scsi_get_command - Allocate and setup a scsi command block 285eb44820cSRob Landley * @dev: parent scsi device 286eb44820cSRob Landley * @gfp_mask: allocator flags 2871da177e4SLinus Torvalds * 2881da177e4SLinus Torvalds * Returns: The allocated scsi command structure. 2891da177e4SLinus Torvalds */ 290c53033f6SAl Viro struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask) 2911da177e4SLinus Torvalds { 2921da177e4SLinus Torvalds struct scsi_cmnd *cmd; 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds /* Bail if we can't get a reference to the device */ 2951da177e4SLinus Torvalds if (!get_device(&dev->sdev_gendev)) 2961da177e4SLinus Torvalds return NULL; 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds cmd = __scsi_get_command(dev->host, gfp_mask); 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds if (likely(cmd != NULL)) { 3011da177e4SLinus Torvalds unsigned long flags; 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds cmd->device = dev; 3041da177e4SLinus Torvalds INIT_LIST_HEAD(&cmd->list); 3051da177e4SLinus Torvalds spin_lock_irqsave(&dev->list_lock, flags); 3061da177e4SLinus Torvalds list_add_tail(&cmd->list, &dev->cmd_list); 3071da177e4SLinus Torvalds spin_unlock_irqrestore(&dev->list_lock, flags); 30879e448bfSMatthew Dobson cmd->jiffies_at_alloc = jiffies; 3091da177e4SLinus Torvalds } else 3101da177e4SLinus Torvalds put_device(&dev->sdev_gendev); 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds return cmd; 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_get_command); 3151da177e4SLinus Torvalds 316eb44820cSRob Landley /** 317eb44820cSRob Landley * __scsi_put_command - Free a struct scsi_cmnd 318eb44820cSRob Landley * @shost: dev->host 319eb44820cSRob Landley * @cmd: Command to free 320eb44820cSRob Landley * @dev: parent scsi device 321eb44820cSRob Landley */ 322b58d9154SFUJITA Tomonori void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd, 323b58d9154SFUJITA Tomonori struct device *dev) 324b58d9154SFUJITA Tomonori { 325b58d9154SFUJITA Tomonori unsigned long flags; 326b58d9154SFUJITA Tomonori 327b58d9154SFUJITA Tomonori /* changing locks here, don't need to restore the irq state */ 328b58d9154SFUJITA Tomonori spin_lock_irqsave(&shost->free_list_lock, flags); 329b58d9154SFUJITA Tomonori if (unlikely(list_empty(&shost->free_list))) { 330b58d9154SFUJITA Tomonori list_add(&cmd->list, &shost->free_list); 331b58d9154SFUJITA Tomonori cmd = NULL; 332b58d9154SFUJITA Tomonori } 333b58d9154SFUJITA Tomonori spin_unlock_irqrestore(&shost->free_list_lock, flags); 334b58d9154SFUJITA Tomonori 335e507e30bSJames Bottomley if (likely(cmd != NULL)) 336e507e30bSJames Bottomley scsi_pool_free_command(shost->cmd_pool, cmd); 337b58d9154SFUJITA Tomonori 338b58d9154SFUJITA Tomonori put_device(dev); 339b58d9154SFUJITA Tomonori } 340b58d9154SFUJITA Tomonori EXPORT_SYMBOL(__scsi_put_command); 341b58d9154SFUJITA Tomonori 342eb44820cSRob Landley /** 343eb44820cSRob Landley * scsi_put_command - Free a scsi command block 344eb44820cSRob Landley * @cmd: command block to free 3451da177e4SLinus Torvalds * 3461da177e4SLinus Torvalds * Returns: Nothing. 3471da177e4SLinus Torvalds * 3481da177e4SLinus Torvalds * Notes: The command must not belong to any lists. 3491da177e4SLinus Torvalds */ 3501da177e4SLinus Torvalds void scsi_put_command(struct scsi_cmnd *cmd) 3511da177e4SLinus Torvalds { 3521da177e4SLinus Torvalds struct scsi_device *sdev = cmd->device; 3531da177e4SLinus Torvalds unsigned long flags; 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds /* serious error if the command hasn't come from a device list */ 3561da177e4SLinus Torvalds spin_lock_irqsave(&cmd->device->list_lock, flags); 3571da177e4SLinus Torvalds BUG_ON(list_empty(&cmd->list)); 3581da177e4SLinus Torvalds list_del_init(&cmd->list); 359b58d9154SFUJITA Tomonori spin_unlock_irqrestore(&cmd->device->list_lock, flags); 3601da177e4SLinus Torvalds 361b58d9154SFUJITA Tomonori __scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev); 3621da177e4SLinus Torvalds } 3631da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_put_command); 3641da177e4SLinus Torvalds 3651c353f7dSJames Bottomley static struct scsi_host_cmd_pool *scsi_get_host_cmd_pool(gfp_t gfp_mask) 3661da177e4SLinus Torvalds { 3671c353f7dSJames Bottomley struct scsi_host_cmd_pool *retval = NULL, *pool; 3681da177e4SLinus Torvalds /* 3691da177e4SLinus Torvalds * Select a command slab for this host and create it if not 370eb44820cSRob Landley * yet existent. 3711da177e4SLinus Torvalds */ 3720b950672SArjan van de Ven mutex_lock(&host_cmd_pool_mutex); 3731c353f7dSJames Bottomley pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool : 3741c353f7dSJames Bottomley &scsi_cmd_pool; 3751da177e4SLinus Torvalds if (!pool->users) { 3765b7f1680SJames Bottomley pool->cmd_slab = kmem_cache_create(pool->cmd_name, 3771da177e4SLinus Torvalds sizeof(struct scsi_cmnd), 0, 37820c2df83SPaul Mundt pool->slab_flags, NULL); 3795b7f1680SJames Bottomley if (!pool->cmd_slab) 3801da177e4SLinus Torvalds goto fail; 3815b7f1680SJames Bottomley 3825b7f1680SJames Bottomley pool->sense_slab = kmem_cache_create(pool->sense_name, 3835b7f1680SJames Bottomley SCSI_SENSE_BUFFERSIZE, 0, 3845b7f1680SJames Bottomley pool->slab_flags, NULL); 3855b7f1680SJames Bottomley if (!pool->sense_slab) { 3865b7f1680SJames Bottomley kmem_cache_destroy(pool->cmd_slab); 3875b7f1680SJames Bottomley goto fail; 3885b7f1680SJames Bottomley } 3891da177e4SLinus Torvalds } 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds pool->users++; 3921c353f7dSJames Bottomley retval = pool; 3931c353f7dSJames Bottomley fail: 3940b950672SArjan van de Ven mutex_unlock(&host_cmd_pool_mutex); 3951c353f7dSJames Bottomley return retval; 3961c353f7dSJames Bottomley } 3971da177e4SLinus Torvalds 3981c353f7dSJames Bottomley static void scsi_put_host_cmd_pool(gfp_t gfp_mask) 3991c353f7dSJames Bottomley { 4001c353f7dSJames Bottomley struct scsi_host_cmd_pool *pool; 401de25deb1SFUJITA Tomonori 402166a7287SFUJITA Tomonori mutex_lock(&host_cmd_pool_mutex); 4031c353f7dSJames Bottomley pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool : 4041c353f7dSJames Bottomley &scsi_cmd_pool; 4051c353f7dSJames Bottomley /* 4061c353f7dSJames Bottomley * This may happen if a driver has a mismatched get and put 4071c353f7dSJames Bottomley * of the command pool; the driver should be implicated in 4081c353f7dSJames Bottomley * the stack trace 4091c353f7dSJames Bottomley */ 4101c353f7dSJames Bottomley BUG_ON(pool->users == 0); 4111c353f7dSJames Bottomley 4125b7f1680SJames Bottomley if (!--pool->users) { 4135b7f1680SJames Bottomley kmem_cache_destroy(pool->cmd_slab); 4145b7f1680SJames Bottomley kmem_cache_destroy(pool->sense_slab); 4155b7f1680SJames Bottomley } 4160b950672SArjan van de Ven mutex_unlock(&host_cmd_pool_mutex); 4171c353f7dSJames Bottomley } 4181c353f7dSJames Bottomley 4191c353f7dSJames Bottomley /** 4201c353f7dSJames Bottomley * scsi_allocate_command - get a fully allocated SCSI command 4211c353f7dSJames Bottomley * @gfp_mask: allocation mask 4221c353f7dSJames Bottomley * 4231c353f7dSJames Bottomley * This function is for use outside of the normal host based pools. 4241c353f7dSJames Bottomley * It allocates the relevant command and takes an additional reference 4251c353f7dSJames Bottomley * on the pool it used. This function *must* be paired with 4261c353f7dSJames Bottomley * scsi_free_command which also has the identical mask, otherwise the 4271c353f7dSJames Bottomley * free pool counts will eventually go wrong and you'll trigger a bug. 4281c353f7dSJames Bottomley * 4291c353f7dSJames Bottomley * This function should *only* be used by drivers that need a static 4301c353f7dSJames Bottomley * command allocation at start of day for internal functions. 4311c353f7dSJames Bottomley */ 4321c353f7dSJames Bottomley struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask) 4331c353f7dSJames Bottomley { 4341c353f7dSJames Bottomley struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask); 4351c353f7dSJames Bottomley 4361c353f7dSJames Bottomley if (!pool) 4371c353f7dSJames Bottomley return NULL; 4381c353f7dSJames Bottomley 4391c353f7dSJames Bottomley return scsi_pool_alloc_command(pool, gfp_mask); 4401c353f7dSJames Bottomley } 4411c353f7dSJames Bottomley EXPORT_SYMBOL(scsi_allocate_command); 4421c353f7dSJames Bottomley 4431c353f7dSJames Bottomley /** 4441c353f7dSJames Bottomley * scsi_free_command - free a command allocated by scsi_allocate_command 4451c353f7dSJames Bottomley * @gfp_mask: mask used in the original allocation 4461c353f7dSJames Bottomley * @cmd: command to free 4471c353f7dSJames Bottomley * 4481c353f7dSJames Bottomley * Note: using the original allocation mask is vital because that's 4491c353f7dSJames Bottomley * what determines which command pool we use to free the command. Any 4501c353f7dSJames Bottomley * mismatch will cause the system to BUG eventually. 4511c353f7dSJames Bottomley */ 4521c353f7dSJames Bottomley void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd) 4531c353f7dSJames Bottomley { 4541c353f7dSJames Bottomley struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask); 4551c353f7dSJames Bottomley 4561c353f7dSJames Bottomley /* 4571c353f7dSJames Bottomley * this could trigger if the mask to scsi_allocate_command 4581c353f7dSJames Bottomley * doesn't match this mask. Otherwise we're guaranteed that this 4591c353f7dSJames Bottomley * succeeds because scsi_allocate_command must have taken a reference 4601c353f7dSJames Bottomley * on the pool 4611c353f7dSJames Bottomley */ 4621c353f7dSJames Bottomley BUG_ON(!pool); 4631c353f7dSJames Bottomley 4641c353f7dSJames Bottomley scsi_pool_free_command(pool, cmd); 4651c353f7dSJames Bottomley /* 4661c353f7dSJames Bottomley * scsi_put_host_cmd_pool is called twice; once to release the 4671c353f7dSJames Bottomley * reference we took above, and once to release the reference 4681c353f7dSJames Bottomley * originally taken by scsi_allocate_command 4691c353f7dSJames Bottomley */ 4701c353f7dSJames Bottomley scsi_put_host_cmd_pool(gfp_mask); 4711c353f7dSJames Bottomley scsi_put_host_cmd_pool(gfp_mask); 4721c353f7dSJames Bottomley } 4731c353f7dSJames Bottomley EXPORT_SYMBOL(scsi_free_command); 4741c353f7dSJames Bottomley 4751c353f7dSJames Bottomley /** 4761c353f7dSJames Bottomley * scsi_setup_command_freelist - Setup the command freelist for a scsi host. 4771c353f7dSJames Bottomley * @shost: host to allocate the freelist for. 4781c353f7dSJames Bottomley * 4791c353f7dSJames Bottomley * Description: The command freelist protects against system-wide out of memory 4801c353f7dSJames Bottomley * deadlock by preallocating one SCSI command structure for each host, so the 4811c353f7dSJames Bottomley * system can always write to a swap file on a device associated with that host. 4821c353f7dSJames Bottomley * 4831c353f7dSJames Bottomley * Returns: Nothing. 4841c353f7dSJames Bottomley */ 4851c353f7dSJames Bottomley int scsi_setup_command_freelist(struct Scsi_Host *shost) 4861c353f7dSJames Bottomley { 4871c353f7dSJames Bottomley struct scsi_cmnd *cmd; 4881c353f7dSJames Bottomley const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL; 4891c353f7dSJames Bottomley 4901c353f7dSJames Bottomley spin_lock_init(&shost->free_list_lock); 4911c353f7dSJames Bottomley INIT_LIST_HEAD(&shost->free_list); 4921c353f7dSJames Bottomley 4931c353f7dSJames Bottomley shost->cmd_pool = scsi_get_host_cmd_pool(gfp_mask); 4941c353f7dSJames Bottomley 4951c353f7dSJames Bottomley if (!shost->cmd_pool) 4961da177e4SLinus Torvalds return -ENOMEM; 4971c353f7dSJames Bottomley 4981c353f7dSJames Bottomley /* 4991c353f7dSJames Bottomley * Get one backup command for this host. 5001c353f7dSJames Bottomley */ 5017027ad72SMartin K. Petersen cmd = scsi_host_alloc_command(shost, gfp_mask); 5021c353f7dSJames Bottomley if (!cmd) { 5031c353f7dSJames Bottomley scsi_put_host_cmd_pool(gfp_mask); 50461d7416aSAlan D. Brunelle shost->cmd_pool = NULL; 5051c353f7dSJames Bottomley return -ENOMEM; 5061c353f7dSJames Bottomley } 5071c353f7dSJames Bottomley list_add(&cmd->list, &shost->free_list); 5081c353f7dSJames Bottomley return 0; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds 511eb44820cSRob Landley /** 512eb44820cSRob Landley * scsi_destroy_command_freelist - Release the command freelist for a scsi host. 513eb44820cSRob Landley * @shost: host whose freelist is going to be destroyed 5141da177e4SLinus Torvalds */ 5151da177e4SLinus Torvalds void scsi_destroy_command_freelist(struct Scsi_Host *shost) 5161da177e4SLinus Torvalds { 51761d7416aSAlan D. Brunelle /* 51861d7416aSAlan D. Brunelle * If cmd_pool is NULL the free list was not initialized, so 51961d7416aSAlan D. Brunelle * do not attempt to release resources. 52061d7416aSAlan D. Brunelle */ 52161d7416aSAlan D. Brunelle if (!shost->cmd_pool) 52261d7416aSAlan D. Brunelle return; 52361d7416aSAlan D. Brunelle 5241da177e4SLinus Torvalds while (!list_empty(&shost->free_list)) { 5251da177e4SLinus Torvalds struct scsi_cmnd *cmd; 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list); 5281da177e4SLinus Torvalds list_del_init(&cmd->list); 529e507e30bSJames Bottomley scsi_pool_free_command(shost->cmd_pool, cmd); 5301da177e4SLinus Torvalds } 5311c353f7dSJames Bottomley shost->cmd_pool = NULL; 5321c353f7dSJames Bottomley scsi_put_host_cmd_pool(shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL); 533de25deb1SFUJITA Tomonori } 534de25deb1SFUJITA Tomonori 5351da177e4SLinus Torvalds #ifdef CONFIG_SCSI_LOGGING 5361da177e4SLinus Torvalds void scsi_log_send(struct scsi_cmnd *cmd) 5371da177e4SLinus Torvalds { 5381da177e4SLinus Torvalds unsigned int level; 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds /* 5411da177e4SLinus Torvalds * If ML QUEUE log level is greater than or equal to: 5421da177e4SLinus Torvalds * 5431da177e4SLinus Torvalds * 1: nothing (match completion) 5441da177e4SLinus Torvalds * 5451da177e4SLinus Torvalds * 2: log opcode + command of all commands 5461da177e4SLinus Torvalds * 5471da177e4SLinus Torvalds * 3: same as 2 plus dump cmd address 5481da177e4SLinus Torvalds * 5491da177e4SLinus Torvalds * 4: same as 3 plus dump extra junk 5501da177e4SLinus Torvalds */ 5511da177e4SLinus Torvalds if (unlikely(scsi_logging_level)) { 5521da177e4SLinus Torvalds level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT, 5531da177e4SLinus Torvalds SCSI_LOG_MLQUEUE_BITS); 5541da177e4SLinus Torvalds if (level > 1) { 555a4d04a4cSMartin K. Petersen scmd_printk(KERN_INFO, cmd, "Send: "); 5561da177e4SLinus Torvalds if (level > 2) 5571da177e4SLinus Torvalds printk("0x%p ", cmd); 558a4d04a4cSMartin K. Petersen printk("\n"); 5591da177e4SLinus Torvalds scsi_print_command(cmd); 5601da177e4SLinus Torvalds if (level > 3) { 5611da177e4SLinus Torvalds printk(KERN_INFO "buffer = 0x%p, bufflen = %d," 5627b3d9545SLinus Torvalds " queuecommand 0x%p\n", 563a73e45b3SBoaz Harrosh scsi_sglist(cmd), scsi_bufflen(cmd), 564a4d04a4cSMartin K. Petersen cmd->device->host->hostt->queuecommand); 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds } 5671da177e4SLinus Torvalds } 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds } 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds void scsi_log_completion(struct scsi_cmnd *cmd, int disposition) 5721da177e4SLinus Torvalds { 5731da177e4SLinus Torvalds unsigned int level; 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds /* 5761da177e4SLinus Torvalds * If ML COMPLETE log level is greater than or equal to: 5771da177e4SLinus Torvalds * 5781da177e4SLinus Torvalds * 1: log disposition, result, opcode + command, and conditionally 5791da177e4SLinus Torvalds * sense data for failures or non SUCCESS dispositions. 5801da177e4SLinus Torvalds * 5811da177e4SLinus Torvalds * 2: same as 1 but for all command completions. 5821da177e4SLinus Torvalds * 5831da177e4SLinus Torvalds * 3: same as 2 plus dump cmd address 5841da177e4SLinus Torvalds * 5851da177e4SLinus Torvalds * 4: same as 3 plus dump extra junk 5861da177e4SLinus Torvalds */ 5871da177e4SLinus Torvalds if (unlikely(scsi_logging_level)) { 5881da177e4SLinus Torvalds level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT, 5891da177e4SLinus Torvalds SCSI_LOG_MLCOMPLETE_BITS); 5901da177e4SLinus Torvalds if (((level > 0) && (cmd->result || disposition != SUCCESS)) || 5911da177e4SLinus Torvalds (level > 1)) { 592a4d04a4cSMartin K. Petersen scmd_printk(KERN_INFO, cmd, "Done: "); 5931da177e4SLinus Torvalds if (level > 2) 5941da177e4SLinus Torvalds printk("0x%p ", cmd); 5951da177e4SLinus Torvalds /* 5961da177e4SLinus Torvalds * Dump truncated values, so we usually fit within 5971da177e4SLinus Torvalds * 80 chars. 5981da177e4SLinus Torvalds */ 5991da177e4SLinus Torvalds switch (disposition) { 6001da177e4SLinus Torvalds case SUCCESS: 601a4d04a4cSMartin K. Petersen printk("SUCCESS\n"); 6021da177e4SLinus Torvalds break; 6031da177e4SLinus Torvalds case NEEDS_RETRY: 604a4d04a4cSMartin K. Petersen printk("RETRY\n"); 6051da177e4SLinus Torvalds break; 6061da177e4SLinus Torvalds case ADD_TO_MLQUEUE: 607a4d04a4cSMartin K. Petersen printk("MLQUEUE\n"); 6081da177e4SLinus Torvalds break; 6091da177e4SLinus Torvalds case FAILED: 610a4d04a4cSMartin K. Petersen printk("FAILED\n"); 6111da177e4SLinus Torvalds break; 6121da177e4SLinus Torvalds case TIMEOUT_ERROR: 6131da177e4SLinus Torvalds /* 6141da177e4SLinus Torvalds * If called via scsi_times_out. 6151da177e4SLinus Torvalds */ 616a4d04a4cSMartin K. Petersen printk("TIMEOUT\n"); 6171da177e4SLinus Torvalds break; 6181da177e4SLinus Torvalds default: 619a4d04a4cSMartin K. Petersen printk("UNKNOWN\n"); 6201da177e4SLinus Torvalds } 621a4d04a4cSMartin K. Petersen scsi_print_result(cmd); 6221da177e4SLinus Torvalds scsi_print_command(cmd); 623a4d04a4cSMartin K. Petersen if (status_byte(cmd->result) & CHECK_CONDITION) 6241da177e4SLinus Torvalds scsi_print_sense("", cmd); 625a4d04a4cSMartin K. Petersen if (level > 3) 626a4d04a4cSMartin K. Petersen scmd_printk(KERN_INFO, cmd, 627a4d04a4cSMartin K. Petersen "scsi host busy %d failed %d\n", 628a4d04a4cSMartin K. Petersen cmd->device->host->host_busy, 629a4d04a4cSMartin K. Petersen cmd->device->host->host_failed); 6301da177e4SLinus Torvalds } 6311da177e4SLinus Torvalds } 6321da177e4SLinus Torvalds } 6331da177e4SLinus Torvalds #endif 6341da177e4SLinus Torvalds 635eb44820cSRob Landley /** 636eb44820cSRob Landley * scsi_cmd_get_serial - Assign a serial number to a command 637eb44820cSRob Landley * @host: the scsi host 638eb44820cSRob Landley * @cmd: command to assign serial number to 639eb44820cSRob Landley * 640eb44820cSRob Landley * Description: a serial number identifies a request for error recovery 6411da177e4SLinus Torvalds * and debugging purposes. Protected by the Host_Lock of host. 6421da177e4SLinus Torvalds */ 643f281233dSJeff Garzik void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd) 6441da177e4SLinus Torvalds { 6451da177e4SLinus Torvalds cmd->serial_number = host->cmd_serial_number++; 6461da177e4SLinus Torvalds if (cmd->serial_number == 0) 6471da177e4SLinus Torvalds cmd->serial_number = host->cmd_serial_number++; 6481da177e4SLinus Torvalds } 649f281233dSJeff Garzik EXPORT_SYMBOL(scsi_cmd_get_serial); 6501da177e4SLinus Torvalds 651eb44820cSRob Landley /** 652eb44820cSRob Landley * scsi_dispatch_command - Dispatch a command to the low-level driver. 653eb44820cSRob Landley * @cmd: command block we are dispatching. 6541da177e4SLinus Torvalds * 655eb44820cSRob Landley * Return: nonzero return request was rejected and device's queue needs to be 656eb44820cSRob Landley * plugged. 6571da177e4SLinus Torvalds */ 6581da177e4SLinus Torvalds int scsi_dispatch_cmd(struct scsi_cmnd *cmd) 6591da177e4SLinus Torvalds { 6601da177e4SLinus Torvalds struct Scsi_Host *host = cmd->device->host; 6611da177e4SLinus Torvalds unsigned long timeout; 6621da177e4SLinus Torvalds int rtn = 0; 6631da177e4SLinus Torvalds 664242f9dcbSJens Axboe atomic_inc(&cmd->device->iorequest_cnt); 665242f9dcbSJens Axboe 6661da177e4SLinus Torvalds /* check if the device is still usable */ 6671da177e4SLinus Torvalds if (unlikely(cmd->device->sdev_state == SDEV_DEL)) { 6681da177e4SLinus Torvalds /* in SDEV_DEL we error all commands. DID_NO_CONNECT 6691da177e4SLinus Torvalds * returns an immediate error upwards, and signals 6701da177e4SLinus Torvalds * that the device is no longer present */ 6711da177e4SLinus Torvalds cmd->result = DID_NO_CONNECT << 16; 672242f9dcbSJens Axboe scsi_done(cmd); 6731da177e4SLinus Torvalds /* return 0 (because the command has been processed) */ 6741da177e4SLinus Torvalds goto out; 6751da177e4SLinus Torvalds } 6761da177e4SLinus Torvalds 6770f1d87a2SJames Bottomley /* Check to see if the scsi lld made this device blocked. */ 6780f1d87a2SJames Bottomley if (unlikely(scsi_device_blocked(cmd->device))) { 6791da177e4SLinus Torvalds /* 6800f1d87a2SJames Bottomley * in blocked state, the command is just put back on 6810f1d87a2SJames Bottomley * the device queue. The suspend state has already 6820f1d87a2SJames Bottomley * blocked the queue so future requests should not 6830f1d87a2SJames Bottomley * occur until the device transitions out of the 6840f1d87a2SJames Bottomley * suspend state. 6851da177e4SLinus Torvalds */ 686242f9dcbSJens Axboe 6871da177e4SLinus Torvalds scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n")); 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds /* 6921da177e4SLinus Torvalds * NOTE: rtn is still zero here because we don't need the 6931da177e4SLinus Torvalds * queue to be plugged on return (it's already stopped) 6941da177e4SLinus Torvalds */ 6951da177e4SLinus Torvalds goto out; 6961da177e4SLinus Torvalds } 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds /* 6991da177e4SLinus Torvalds * If SCSI-2 or lower, store the LUN value in cmnd. 7001da177e4SLinus Torvalds */ 7014d7db04aSJames Bottomley if (cmd->device->scsi_level <= SCSI_2 && 7024d7db04aSJames Bottomley cmd->device->scsi_level != SCSI_UNKNOWN) { 7031da177e4SLinus Torvalds cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) | 7041da177e4SLinus Torvalds (cmd->device->lun << 5 & 0xe0); 7051da177e4SLinus Torvalds } 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds /* 7081da177e4SLinus Torvalds * We will wait MIN_RESET_DELAY clock ticks after the last reset so 7091da177e4SLinus Torvalds * we can avoid the drive not being ready. 7101da177e4SLinus Torvalds */ 7111da177e4SLinus Torvalds timeout = host->last_reset + MIN_RESET_DELAY; 7121da177e4SLinus Torvalds 7131da177e4SLinus Torvalds if (host->resetting && time_before(jiffies, timeout)) { 7141da177e4SLinus Torvalds int ticks_remaining = timeout - jiffies; 7151da177e4SLinus Torvalds /* 7161da177e4SLinus Torvalds * NOTE: This may be executed from within an interrupt 7171da177e4SLinus Torvalds * handler! This is bad, but for now, it'll do. The irq 7181da177e4SLinus Torvalds * level of the interrupt handler has been masked out by the 7191da177e4SLinus Torvalds * platform dependent interrupt handling code already, so the 7201da177e4SLinus Torvalds * sti() here will not cause another call to the SCSI host's 7211da177e4SLinus Torvalds * interrupt handler (assuming there is one irq-level per 7221da177e4SLinus Torvalds * host). 7231da177e4SLinus Torvalds */ 7241da177e4SLinus Torvalds while (--ticks_remaining >= 0) 7251da177e4SLinus Torvalds mdelay(1 + 999 / HZ); 7261da177e4SLinus Torvalds host->resetting = 0; 7271da177e4SLinus Torvalds } 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds scsi_log_send(cmd); 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds /* 7321da177e4SLinus Torvalds * Before we queue this command, check if the command 7331da177e4SLinus Torvalds * length exceeds what the host adapter can handle. 7341da177e4SLinus Torvalds */ 735db4742ddSBoaz Harrosh if (cmd->cmd_len > cmd->device->host->max_cmd_len) { 7361da177e4SLinus Torvalds SCSI_LOG_MLQUEUE(3, 737db4742ddSBoaz Harrosh printk("queuecommand : command too long. " 738db4742ddSBoaz Harrosh "cdb_size=%d host->max_cmd_len=%d\n", 739db4742ddSBoaz Harrosh cmd->cmd_len, cmd->device->host->max_cmd_len)); 7401da177e4SLinus Torvalds cmd->result = (DID_ABORT << 16); 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds scsi_done(cmd); 7431da177e4SLinus Torvalds goto out; 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds 746d2c9d9eaSMike Anderson if (unlikely(host->shost_state == SHOST_DEL)) { 7471da177e4SLinus Torvalds cmd->result = (DID_NO_CONNECT << 16); 7481da177e4SLinus Torvalds scsi_done(cmd); 7491da177e4SLinus Torvalds } else { 750bf816235SKei Tokunaga trace_scsi_dispatch_cmd_start(cmd); 751f281233dSJeff Garzik cmd->scsi_done = scsi_done; 752f281233dSJeff Garzik rtn = host->hostt->queuecommand(host, cmd); 7531da177e4SLinus Torvalds } 754f281233dSJeff Garzik 7551da177e4SLinus Torvalds if (rtn) { 756bf816235SKei Tokunaga trace_scsi_dispatch_cmd_error(cmd, rtn); 757f0c0a376SMike Christie if (rtn != SCSI_MLQUEUE_DEVICE_BUSY && 758f0c0a376SMike Christie rtn != SCSI_MLQUEUE_TARGET_BUSY) 759f0c0a376SMike Christie rtn = SCSI_MLQUEUE_HOST_BUSY; 760f0c0a376SMike Christie 761f0c0a376SMike Christie scsi_queue_insert(cmd, rtn); 762f0c0a376SMike Christie 7631da177e4SLinus Torvalds SCSI_LOG_MLQUEUE(3, 7641da177e4SLinus Torvalds printk("queuecommand : request rejected\n")); 7651da177e4SLinus Torvalds } 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds out: 7681da177e4SLinus Torvalds SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n")); 7691da177e4SLinus Torvalds return rtn; 7701da177e4SLinus Torvalds } 7711da177e4SLinus Torvalds 7721da177e4SLinus Torvalds /** 7731da177e4SLinus Torvalds * scsi_done - Enqueue the finished SCSI command into the done queue. 7741da177e4SLinus Torvalds * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives 7751da177e4SLinus Torvalds * ownership back to SCSI Core -- i.e. the LLDD has finished with it. 7761da177e4SLinus Torvalds * 777eb44820cSRob Landley * Description: This function is the mid-level's (SCSI Core) interrupt routine, 778eb44820cSRob Landley * which regains ownership of the SCSI command (de facto) from a LLDD, and 779eb44820cSRob Landley * enqueues the command to the done queue for further processing. 7801da177e4SLinus Torvalds * 7811da177e4SLinus Torvalds * This is the producer of the done queue who enqueues at the tail. 7821da177e4SLinus Torvalds * 7831da177e4SLinus Torvalds * This function is interrupt context safe. 7841da177e4SLinus Torvalds */ 78552c1da39SAdrian Bunk static void scsi_done(struct scsi_cmnd *cmd) 7861da177e4SLinus Torvalds { 787bf816235SKei Tokunaga trace_scsi_dispatch_cmd_done(cmd); 788242f9dcbSJens Axboe blk_complete_request(cmd->request); 7891da177e4SLinus Torvalds } 7901da177e4SLinus Torvalds 791eb44820cSRob Landley /** 792eb44820cSRob Landley * scsi_finish_command - cleanup and pass command back to upper layer 793eb44820cSRob Landley * @cmd: the command 7941da177e4SLinus Torvalds * 795eb44820cSRob Landley * Description: Pass command off to upper layer for finishing of I/O 7961da177e4SLinus Torvalds * request, waking processes that are waiting on results, 7971da177e4SLinus Torvalds * etc. 7981da177e4SLinus Torvalds */ 7991da177e4SLinus Torvalds void scsi_finish_command(struct scsi_cmnd *cmd) 8001da177e4SLinus Torvalds { 8011da177e4SLinus Torvalds struct scsi_device *sdev = cmd->device; 802f0c0a376SMike Christie struct scsi_target *starget = scsi_target(sdev); 8031da177e4SLinus Torvalds struct Scsi_Host *shost = sdev->host; 8047b3d9545SLinus Torvalds struct scsi_driver *drv; 8057b3d9545SLinus Torvalds unsigned int good_bytes; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds scsi_device_unbusy(sdev); 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds /* 8101da177e4SLinus Torvalds * Clear the flags which say that the device/host is no longer 8111da177e4SLinus Torvalds * capable of accepting new commands. These are set in scsi_queue.c 8121da177e4SLinus Torvalds * for both the queue full condition on a device, and for a 8131da177e4SLinus Torvalds * host full condition on the host. 8141da177e4SLinus Torvalds * 8151da177e4SLinus Torvalds * XXX(hch): What about locking? 8161da177e4SLinus Torvalds */ 8171da177e4SLinus Torvalds shost->host_blocked = 0; 818f0c0a376SMike Christie starget->target_blocked = 0; 8191da177e4SLinus Torvalds sdev->device_blocked = 0; 8201da177e4SLinus Torvalds 8211da177e4SLinus Torvalds /* 8221da177e4SLinus Torvalds * If we have valid sense information, then some kind of recovery 8231da177e4SLinus Torvalds * must have taken place. Make a note of this. 8241da177e4SLinus Torvalds */ 8251da177e4SLinus Torvalds if (SCSI_SENSE_VALID(cmd)) 8261da177e4SLinus Torvalds cmd->result |= (DRIVER_SENSE << 24); 8271da177e4SLinus Torvalds 8283bf743e7SJeff Garzik SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev, 8293bf743e7SJeff Garzik "Notifying upper driver of completion " 8303bf743e7SJeff Garzik "(result %x)\n", cmd->result)); 8311da177e4SLinus Torvalds 832f18573abSFUJITA Tomonori good_bytes = scsi_bufflen(cmd); 8337b3d9545SLinus Torvalds if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) { 834427e59f0SJames Bottomley int old_good_bytes = good_bytes; 8357b3d9545SLinus Torvalds drv = scsi_cmd_to_driver(cmd); 8367b3d9545SLinus Torvalds if (drv->done) 8377b3d9545SLinus Torvalds good_bytes = drv->done(cmd); 838427e59f0SJames Bottomley /* 839427e59f0SJames Bottomley * USB may not give sense identifying bad sector and 840427e59f0SJames Bottomley * simply return a residue instead, so subtract off the 841427e59f0SJames Bottomley * residue if drv->done() error processing indicates no 842427e59f0SJames Bottomley * change to the completion length. 843427e59f0SJames Bottomley */ 844427e59f0SJames Bottomley if (good_bytes == old_good_bytes) 845427e59f0SJames Bottomley good_bytes -= scsi_get_resid(cmd); 8467b3d9545SLinus Torvalds } 8477b3d9545SLinus Torvalds scsi_io_completion(cmd, good_bytes); 8481da177e4SLinus Torvalds } 8491da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_finish_command); 8501da177e4SLinus Torvalds 851eb44820cSRob Landley /** 852eb44820cSRob Landley * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth 853eb44820cSRob Landley * @sdev: SCSI Device in question 854eb44820cSRob Landley * @tagged: Do we use tagged queueing (non-0) or do we treat 8551da177e4SLinus Torvalds * this device as an untagged device (0) 856eb44820cSRob Landley * @tags: Number of tags allowed if tagged queueing enabled, 8571da177e4SLinus Torvalds * or number of commands the low level driver can 8581da177e4SLinus Torvalds * queue up in non-tagged mode (as per cmd_per_lun). 8591da177e4SLinus Torvalds * 8601da177e4SLinus Torvalds * Returns: Nothing 8611da177e4SLinus Torvalds * 8621da177e4SLinus Torvalds * Lock Status: None held on entry 8631da177e4SLinus Torvalds * 8641da177e4SLinus Torvalds * Notes: Low level drivers may call this at any time and we will do 8651da177e4SLinus Torvalds * the right thing depending on whether or not the device is 8661da177e4SLinus Torvalds * currently active and whether or not it even has the 8671da177e4SLinus Torvalds * command blocks built yet. 8681da177e4SLinus Torvalds */ 8691da177e4SLinus Torvalds void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags) 8701da177e4SLinus Torvalds { 8711da177e4SLinus Torvalds unsigned long flags; 8721da177e4SLinus Torvalds 8731da177e4SLinus Torvalds /* 8741da177e4SLinus Torvalds * refuse to set tagged depth to an unworkable size 8751da177e4SLinus Torvalds */ 8761da177e4SLinus Torvalds if (tags <= 0) 8771da177e4SLinus Torvalds return; 8781da177e4SLinus Torvalds 8791da177e4SLinus Torvalds spin_lock_irqsave(sdev->request_queue->queue_lock, flags); 8801da177e4SLinus Torvalds 881885ace9eSMike Christie /* 882885ace9eSMike Christie * Check to see if the queue is managed by the block layer. 883885ace9eSMike Christie * If it is, and we fail to adjust the depth, exit. 884885ace9eSMike Christie * 885885ace9eSMike Christie * Do not resize the tag map if it is a host wide share bqt, 886885ace9eSMike Christie * because the size should be the hosts's can_queue. If there 887885ace9eSMike Christie * is more IO than the LLD's can_queue (so there are not enuogh 888885ace9eSMike Christie * tags) request_fn's host queue ready check will handle it. 889885ace9eSMike Christie */ 890885ace9eSMike Christie if (!sdev->host->bqt) { 8911da177e4SLinus Torvalds if (blk_queue_tagged(sdev->request_queue) && 8921da177e4SLinus Torvalds blk_queue_resize_tags(sdev->request_queue, tags) != 0) 8931da177e4SLinus Torvalds goto out; 894885ace9eSMike Christie } 8951da177e4SLinus Torvalds 8961da177e4SLinus Torvalds sdev->queue_depth = tags; 8971da177e4SLinus Torvalds switch (tagged) { 8981da177e4SLinus Torvalds case MSG_ORDERED_TAG: 8991da177e4SLinus Torvalds sdev->ordered_tags = 1; 9001da177e4SLinus Torvalds sdev->simple_tags = 1; 9011da177e4SLinus Torvalds break; 9021da177e4SLinus Torvalds case MSG_SIMPLE_TAG: 9031da177e4SLinus Torvalds sdev->ordered_tags = 0; 9041da177e4SLinus Torvalds sdev->simple_tags = 1; 9051da177e4SLinus Torvalds break; 9061da177e4SLinus Torvalds default: 9079ccfc756SJames Bottomley sdev_printk(KERN_WARNING, sdev, 9081da177e4SLinus Torvalds "scsi_adjust_queue_depth, bad queue type, " 9099ccfc756SJames Bottomley "disabled\n"); 9101da177e4SLinus Torvalds case 0: 9111da177e4SLinus Torvalds sdev->ordered_tags = sdev->simple_tags = 0; 9121da177e4SLinus Torvalds sdev->queue_depth = tags; 9131da177e4SLinus Torvalds break; 9141da177e4SLinus Torvalds } 9151da177e4SLinus Torvalds out: 9161da177e4SLinus Torvalds spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_adjust_queue_depth); 9191da177e4SLinus Torvalds 920eb44820cSRob Landley /** 921eb44820cSRob Landley * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth 922eb44820cSRob Landley * @sdev: SCSI Device in question 923eb44820cSRob Landley * @depth: Current number of outstanding SCSI commands on this device, 924eb44820cSRob Landley * not counting the one returned as QUEUE_FULL. 9251da177e4SLinus Torvalds * 926eb44820cSRob Landley * Description: This function will track successive QUEUE_FULL events on a 9271da177e4SLinus Torvalds * specific SCSI device to determine if and when there is a 9281da177e4SLinus Torvalds * need to adjust the queue depth on the device. 9291da177e4SLinus Torvalds * 930eb44820cSRob Landley * Returns: 0 - No change needed, >0 - Adjust queue depth to this new depth, 9311da177e4SLinus Torvalds * -1 - Drop back to untagged operation using host->cmd_per_lun 9321da177e4SLinus Torvalds * as the untagged command depth 9331da177e4SLinus Torvalds * 9341da177e4SLinus Torvalds * Lock Status: None held on entry 9351da177e4SLinus Torvalds * 9361da177e4SLinus Torvalds * Notes: Low level drivers may call this at any time and we will do 9371da177e4SLinus Torvalds * "The Right Thing." We are interrupt context safe. 9381da177e4SLinus Torvalds */ 9391da177e4SLinus Torvalds int scsi_track_queue_full(struct scsi_device *sdev, int depth) 9401da177e4SLinus Torvalds { 9414a84067dSVasu Dev 9424a84067dSVasu Dev /* 9434a84067dSVasu Dev * Don't let QUEUE_FULLs on the same 9444a84067dSVasu Dev * jiffies count, they could all be from 9454a84067dSVasu Dev * same event. 9464a84067dSVasu Dev */ 9474a84067dSVasu Dev if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4)) 9481da177e4SLinus Torvalds return 0; 9491da177e4SLinus Torvalds 9504a84067dSVasu Dev sdev->last_queue_full_time = jiffies; 9511da177e4SLinus Torvalds if (sdev->last_queue_full_depth != depth) { 9521da177e4SLinus Torvalds sdev->last_queue_full_count = 1; 9531da177e4SLinus Torvalds sdev->last_queue_full_depth = depth; 9541da177e4SLinus Torvalds } else { 9551da177e4SLinus Torvalds sdev->last_queue_full_count++; 9561da177e4SLinus Torvalds } 9571da177e4SLinus Torvalds 9581da177e4SLinus Torvalds if (sdev->last_queue_full_count <= 10) 9591da177e4SLinus Torvalds return 0; 9601da177e4SLinus Torvalds if (sdev->last_queue_full_depth < 8) { 9611da177e4SLinus Torvalds /* Drop back to untagged */ 9621da177e4SLinus Torvalds scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun); 9631da177e4SLinus Torvalds return -1; 9641da177e4SLinus Torvalds } 9651da177e4SLinus Torvalds 9661da177e4SLinus Torvalds if (sdev->ordered_tags) 9671da177e4SLinus Torvalds scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth); 9681da177e4SLinus Torvalds else 9691da177e4SLinus Torvalds scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth); 9701da177e4SLinus Torvalds return depth; 9711da177e4SLinus Torvalds } 9721da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_track_queue_full); 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds /** 975881a256dSMatthew Wilcox * scsi_vpd_inquiry - Request a device provide us with a VPD page 976881a256dSMatthew Wilcox * @sdev: The device to ask 977881a256dSMatthew Wilcox * @buffer: Where to put the result 978881a256dSMatthew Wilcox * @page: Which Vital Product Data to return 979881a256dSMatthew Wilcox * @len: The length of the buffer 980881a256dSMatthew Wilcox * 981881a256dSMatthew Wilcox * This is an internal helper function. You probably want to use 982881a256dSMatthew Wilcox * scsi_get_vpd_page instead. 983881a256dSMatthew Wilcox * 984881a256dSMatthew Wilcox * Returns 0 on success or a negative error number. 985881a256dSMatthew Wilcox */ 986881a256dSMatthew Wilcox static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer, 987881a256dSMatthew Wilcox u8 page, unsigned len) 988881a256dSMatthew Wilcox { 989881a256dSMatthew Wilcox int result; 990881a256dSMatthew Wilcox unsigned char cmd[16]; 991881a256dSMatthew Wilcox 992881a256dSMatthew Wilcox cmd[0] = INQUIRY; 993881a256dSMatthew Wilcox cmd[1] = 1; /* EVPD */ 994881a256dSMatthew Wilcox cmd[2] = page; 995881a256dSMatthew Wilcox cmd[3] = len >> 8; 996881a256dSMatthew Wilcox cmd[4] = len & 0xff; 997881a256dSMatthew Wilcox cmd[5] = 0; /* Control byte */ 998881a256dSMatthew Wilcox 999881a256dSMatthew Wilcox /* 1000881a256dSMatthew Wilcox * I'm not convinced we need to try quite this hard to get VPD, but 1001881a256dSMatthew Wilcox * all the existing users tried this hard. 1002881a256dSMatthew Wilcox */ 1003881a256dSMatthew Wilcox result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, 100495a3639eSJames Bottomley len, NULL, 30 * HZ, 3, NULL); 1005881a256dSMatthew Wilcox if (result) 1006881a256dSMatthew Wilcox return result; 1007881a256dSMatthew Wilcox 1008881a256dSMatthew Wilcox /* Sanity check that we got the page back that we asked for */ 1009881a256dSMatthew Wilcox if (buffer[1] != page) 1010881a256dSMatthew Wilcox return -EIO; 1011881a256dSMatthew Wilcox 1012881a256dSMatthew Wilcox return 0; 1013881a256dSMatthew Wilcox } 1014881a256dSMatthew Wilcox 1015881a256dSMatthew Wilcox /** 1016881a256dSMatthew Wilcox * scsi_get_vpd_page - Get Vital Product Data from a SCSI device 1017881a256dSMatthew Wilcox * @sdev: The device to ask 1018881a256dSMatthew Wilcox * @page: Which Vital Product Data to return 1019786f8ba2SRandy Dunlap * @buf: where to store the VPD 1020786f8ba2SRandy Dunlap * @buf_len: number of bytes in the VPD buffer area 1021881a256dSMatthew Wilcox * 1022881a256dSMatthew Wilcox * SCSI devices may optionally supply Vital Product Data. Each 'page' 1023881a256dSMatthew Wilcox * of VPD is defined in the appropriate SCSI document (eg SPC, SBC). 1024881a256dSMatthew Wilcox * If the device supports this VPD page, this routine returns a pointer 1025881a256dSMatthew Wilcox * to a buffer containing the data from that page. The caller is 1026881a256dSMatthew Wilcox * responsible for calling kfree() on this pointer when it is no longer 1027881a256dSMatthew Wilcox * needed. If we cannot retrieve the VPD page this routine returns %NULL. 1028881a256dSMatthew Wilcox */ 1029e3deec09SJames Bottomley int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf, 1030e3deec09SJames Bottomley int buf_len) 1031881a256dSMatthew Wilcox { 1032881a256dSMatthew Wilcox int i, result; 1033881a256dSMatthew Wilcox 10347562523eSMartin K. Petersen if (sdev->skip_vpd_pages) 10357562523eSMartin K. Petersen goto fail; 10367562523eSMartin K. Petersen 1037881a256dSMatthew Wilcox /* Ask for all the pages supported by this device */ 1038e3deec09SJames Bottomley result = scsi_vpd_inquiry(sdev, buf, 0, buf_len); 1039881a256dSMatthew Wilcox if (result) 1040881a256dSMatthew Wilcox goto fail; 1041881a256dSMatthew Wilcox 1042881a256dSMatthew Wilcox /* If the user actually wanted this page, we can skip the rest */ 1043881a256dSMatthew Wilcox if (page == 0) 104416d3ea26SMartin K. Petersen return 0; 1045881a256dSMatthew Wilcox 1046e3deec09SJames Bottomley for (i = 0; i < min((int)buf[3], buf_len - 4); i++) 1047881a256dSMatthew Wilcox if (buf[i + 4] == page) 1048881a256dSMatthew Wilcox goto found; 1049e3deec09SJames Bottomley 105016d3ea26SMartin K. Petersen if (i < buf[3] && i >= buf_len - 4) 1051e3deec09SJames Bottomley /* ran off the end of the buffer, give us benefit of doubt */ 1052e3deec09SJames Bottomley goto found; 1053881a256dSMatthew Wilcox /* The device claims it doesn't support the requested page */ 1054881a256dSMatthew Wilcox goto fail; 1055881a256dSMatthew Wilcox 1056881a256dSMatthew Wilcox found: 1057e3deec09SJames Bottomley result = scsi_vpd_inquiry(sdev, buf, page, buf_len); 1058881a256dSMatthew Wilcox if (result) 1059881a256dSMatthew Wilcox goto fail; 1060881a256dSMatthew Wilcox 1061e3deec09SJames Bottomley return 0; 1062881a256dSMatthew Wilcox 1063881a256dSMatthew Wilcox fail: 1064e3deec09SJames Bottomley return -EINVAL; 1065881a256dSMatthew Wilcox } 1066881a256dSMatthew Wilcox EXPORT_SYMBOL_GPL(scsi_get_vpd_page); 1067881a256dSMatthew Wilcox 1068881a256dSMatthew Wilcox /** 10693c6bdaeaSMartin K. Petersen * scsi_report_opcode - Find out if a given command opcode is supported 10703c6bdaeaSMartin K. Petersen * @sdev: scsi device to query 10713c6bdaeaSMartin K. Petersen * @buffer: scratch buffer (must be at least 20 bytes long) 10723c6bdaeaSMartin K. Petersen * @len: length of buffer 10733c6bdaeaSMartin K. Petersen * @opcode: opcode for command to look up 10743c6bdaeaSMartin K. Petersen * 10753c6bdaeaSMartin K. Petersen * Uses the REPORT SUPPORTED OPERATION CODES to look up the given 107666c28f97SMartin K. Petersen * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is 107766c28f97SMartin K. Petersen * unsupported and 1 if the device claims to support the command. 10783c6bdaeaSMartin K. Petersen */ 10793c6bdaeaSMartin K. Petersen int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, 10803c6bdaeaSMartin K. Petersen unsigned int len, unsigned char opcode) 10813c6bdaeaSMartin K. Petersen { 10823c6bdaeaSMartin K. Petersen unsigned char cmd[16]; 10833c6bdaeaSMartin K. Petersen struct scsi_sense_hdr sshdr; 10843c6bdaeaSMartin K. Petersen int result; 10853c6bdaeaSMartin K. Petersen 10863c6bdaeaSMartin K. Petersen if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3) 108766c28f97SMartin K. Petersen return -EINVAL; 10883c6bdaeaSMartin K. Petersen 10893c6bdaeaSMartin K. Petersen memset(cmd, 0, 16); 10903c6bdaeaSMartin K. Petersen cmd[0] = MAINTENANCE_IN; 10913c6bdaeaSMartin K. Petersen cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES; 10923c6bdaeaSMartin K. Petersen cmd[2] = 1; /* One command format */ 10933c6bdaeaSMartin K. Petersen cmd[3] = opcode; 10943c6bdaeaSMartin K. Petersen put_unaligned_be32(len, &cmd[6]); 10953c6bdaeaSMartin K. Petersen memset(buffer, 0, len); 10963c6bdaeaSMartin K. Petersen 10973c6bdaeaSMartin K. Petersen result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len, 10983c6bdaeaSMartin K. Petersen &sshdr, 30 * HZ, 3, NULL); 10993c6bdaeaSMartin K. Petersen 11003c6bdaeaSMartin K. Petersen if (result && scsi_sense_valid(&sshdr) && 11013c6bdaeaSMartin K. Petersen sshdr.sense_key == ILLEGAL_REQUEST && 11023c6bdaeaSMartin K. Petersen (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00) 110366c28f97SMartin K. Petersen return -EINVAL; 11043c6bdaeaSMartin K. Petersen 11053c6bdaeaSMartin K. Petersen if ((buffer[1] & 3) == 3) /* Command supported */ 11063c6bdaeaSMartin K. Petersen return 1; 11073c6bdaeaSMartin K. Petersen 11083c6bdaeaSMartin K. Petersen return 0; 11093c6bdaeaSMartin K. Petersen } 11103c6bdaeaSMartin K. Petersen EXPORT_SYMBOL(scsi_report_opcode); 11113c6bdaeaSMartin K. Petersen 11123c6bdaeaSMartin K. Petersen /** 1113eb44820cSRob Landley * scsi_device_get - get an additional reference to a scsi_device 11141da177e4SLinus Torvalds * @sdev: device to get a reference to 11151da177e4SLinus Torvalds * 1116eb44820cSRob Landley * Description: Gets a reference to the scsi_device and increments the use count 11171da177e4SLinus Torvalds * of the underlying LLDD module. You must hold host_lock of the 11181da177e4SLinus Torvalds * parent Scsi_Host or already have a reference when calling this. 11191da177e4SLinus Torvalds */ 11201da177e4SLinus Torvalds int scsi_device_get(struct scsi_device *sdev) 11211da177e4SLinus Torvalds { 112285b6c720SJames Bottomley if (sdev->sdev_state == SDEV_DEL) 11231da177e4SLinus Torvalds return -ENXIO; 11241da177e4SLinus Torvalds if (!get_device(&sdev->sdev_gendev)) 11251da177e4SLinus Torvalds return -ENXIO; 112685b6c720SJames Bottomley /* We can fail this if we're doing SCSI operations 112785b6c720SJames Bottomley * from module exit (like cache flush) */ 112885b6c720SJames Bottomley try_module_get(sdev->host->hostt->module); 112985b6c720SJames Bottomley 11301da177e4SLinus Torvalds return 0; 11311da177e4SLinus Torvalds } 11321da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_device_get); 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds /** 11351da177e4SLinus Torvalds * scsi_device_put - release a reference to a scsi_device 11361da177e4SLinus Torvalds * @sdev: device to release a reference on. 11371da177e4SLinus Torvalds * 1138eb44820cSRob Landley * Description: Release a reference to the scsi_device and decrements the use 1139eb44820cSRob Landley * count of the underlying LLDD module. The device is freed once the last 11401da177e4SLinus Torvalds * user vanishes. 11411da177e4SLinus Torvalds */ 11421da177e4SLinus Torvalds void scsi_device_put(struct scsi_device *sdev) 11431da177e4SLinus Torvalds { 1144504fb37aSIngo Molnar #ifdef CONFIG_MODULE_UNLOAD 1145f479ab87SJames Bottomley struct module *module = sdev->host->hostt->module; 1146f479ab87SJames Bottomley 114785b6c720SJames Bottomley /* The module refcount will be zero if scsi_device_get() 114885b6c720SJames Bottomley * was called from a module removal routine */ 1149f479ab87SJames Bottomley if (module && module_refcount(module) != 0) 1150f479ab87SJames Bottomley module_put(module); 1151a506b44bSDaniel Walker #endif 11521da177e4SLinus Torvalds put_device(&sdev->sdev_gendev); 11531da177e4SLinus Torvalds } 11541da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_device_put); 11551da177e4SLinus Torvalds 1156eb44820cSRob Landley /* helper for shost_for_each_device, see that for documentation */ 11571da177e4SLinus Torvalds struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost, 11581da177e4SLinus Torvalds struct scsi_device *prev) 11591da177e4SLinus Torvalds { 11601da177e4SLinus Torvalds struct list_head *list = (prev ? &prev->siblings : &shost->__devices); 11611da177e4SLinus Torvalds struct scsi_device *next = NULL; 11621da177e4SLinus Torvalds unsigned long flags; 11631da177e4SLinus Torvalds 11641da177e4SLinus Torvalds spin_lock_irqsave(shost->host_lock, flags); 11651da177e4SLinus Torvalds while (list->next != &shost->__devices) { 11661da177e4SLinus Torvalds next = list_entry(list->next, struct scsi_device, siblings); 11671da177e4SLinus Torvalds /* skip devices that we can't get a reference to */ 11681da177e4SLinus Torvalds if (!scsi_device_get(next)) 11691da177e4SLinus Torvalds break; 11701da177e4SLinus Torvalds next = NULL; 11711da177e4SLinus Torvalds list = list->next; 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds spin_unlock_irqrestore(shost->host_lock, flags); 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds if (prev) 11761da177e4SLinus Torvalds scsi_device_put(prev); 11771da177e4SLinus Torvalds return next; 11781da177e4SLinus Torvalds } 11791da177e4SLinus Torvalds EXPORT_SYMBOL(__scsi_iterate_devices); 11801da177e4SLinus Torvalds 11811da177e4SLinus Torvalds /** 11821da177e4SLinus Torvalds * starget_for_each_device - helper to walk all devices of a target 11831da177e4SLinus Torvalds * @starget: target whose devices we want to iterate over. 1184eb44820cSRob Landley * @data: Opaque passed to each function call. 1185eb44820cSRob Landley * @fn: Function to call on each device 11861da177e4SLinus Torvalds * 1187522939d4SMaciej W. Rozycki * This traverses over each device of @starget. The devices have 11881da177e4SLinus Torvalds * a reference that must be released by scsi_host_put when breaking 11891da177e4SLinus Torvalds * out of the loop. 11901da177e4SLinus Torvalds */ 11911da177e4SLinus Torvalds void starget_for_each_device(struct scsi_target *starget, void *data, 11921da177e4SLinus Torvalds void (*fn)(struct scsi_device *, void *)) 11931da177e4SLinus Torvalds { 11941da177e4SLinus Torvalds struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 11951da177e4SLinus Torvalds struct scsi_device *sdev; 11961da177e4SLinus Torvalds 11971da177e4SLinus Torvalds shost_for_each_device(sdev, shost) { 11981da177e4SLinus Torvalds if ((sdev->channel == starget->channel) && 11991da177e4SLinus Torvalds (sdev->id == starget->id)) 12001da177e4SLinus Torvalds fn(sdev, data); 12011da177e4SLinus Torvalds } 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds EXPORT_SYMBOL(starget_for_each_device); 12041da177e4SLinus Torvalds 12051da177e4SLinus Torvalds /** 120614f501a4SRandy Dunlap * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED) 1207522939d4SMaciej W. Rozycki * @starget: target whose devices we want to iterate over. 120814f501a4SRandy Dunlap * @data: parameter for callback @fn() 120914f501a4SRandy Dunlap * @fn: callback function that is invoked for each device 1210522939d4SMaciej W. Rozycki * 1211522939d4SMaciej W. Rozycki * This traverses over each device of @starget. It does _not_ 1212522939d4SMaciej W. Rozycki * take a reference on the scsi_device, so the whole loop must be 1213522939d4SMaciej W. Rozycki * protected by shost->host_lock. 1214522939d4SMaciej W. Rozycki * 1215522939d4SMaciej W. Rozycki * Note: The only reason why drivers would want to use this is because 1216522939d4SMaciej W. Rozycki * they need to access the device list in irq context. Otherwise you 1217522939d4SMaciej W. Rozycki * really want to use starget_for_each_device instead. 1218522939d4SMaciej W. Rozycki **/ 1219522939d4SMaciej W. Rozycki void __starget_for_each_device(struct scsi_target *starget, void *data, 1220522939d4SMaciej W. Rozycki void (*fn)(struct scsi_device *, void *)) 1221522939d4SMaciej W. Rozycki { 1222522939d4SMaciej W. Rozycki struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1223522939d4SMaciej W. Rozycki struct scsi_device *sdev; 1224522939d4SMaciej W. Rozycki 1225522939d4SMaciej W. Rozycki __shost_for_each_device(sdev, shost) { 1226522939d4SMaciej W. Rozycki if ((sdev->channel == starget->channel) && 1227522939d4SMaciej W. Rozycki (sdev->id == starget->id)) 1228522939d4SMaciej W. Rozycki fn(sdev, data); 1229522939d4SMaciej W. Rozycki } 1230522939d4SMaciej W. Rozycki } 1231522939d4SMaciej W. Rozycki EXPORT_SYMBOL(__starget_for_each_device); 1232522939d4SMaciej W. Rozycki 1233522939d4SMaciej W. Rozycki /** 12341da177e4SLinus Torvalds * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED) 12351da177e4SLinus Torvalds * @starget: SCSI target pointer 12361da177e4SLinus Torvalds * @lun: SCSI Logical Unit Number 12371da177e4SLinus Torvalds * 1238eb44820cSRob Landley * Description: Looks up the scsi_device with the specified @lun for a given 12391da177e4SLinus Torvalds * @starget. The returned scsi_device does not have an additional 12401da177e4SLinus Torvalds * reference. You must hold the host's host_lock over this call and 124132aeef60SHannes Reinecke * any access to the returned scsi_device. A scsi_device in state 124232aeef60SHannes Reinecke * SDEV_DEL is skipped. 12431da177e4SLinus Torvalds * 1244dc8875e1SRandy Dunlap * Note: The only reason why drivers should use this is because 1245eb44820cSRob Landley * they need to access the device list in irq context. Otherwise you 12461da177e4SLinus Torvalds * really want to use scsi_device_lookup_by_target instead. 12471da177e4SLinus Torvalds **/ 12481da177e4SLinus Torvalds struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget, 12491da177e4SLinus Torvalds uint lun) 12501da177e4SLinus Torvalds { 12511da177e4SLinus Torvalds struct scsi_device *sdev; 12521da177e4SLinus Torvalds 12531da177e4SLinus Torvalds list_for_each_entry(sdev, &starget->devices, same_target_siblings) { 125432aeef60SHannes Reinecke if (sdev->sdev_state == SDEV_DEL) 125532aeef60SHannes Reinecke continue; 12561da177e4SLinus Torvalds if (sdev->lun ==lun) 12571da177e4SLinus Torvalds return sdev; 12581da177e4SLinus Torvalds } 12591da177e4SLinus Torvalds 12601da177e4SLinus Torvalds return NULL; 12611da177e4SLinus Torvalds } 12621da177e4SLinus Torvalds EXPORT_SYMBOL(__scsi_device_lookup_by_target); 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds /** 12651da177e4SLinus Torvalds * scsi_device_lookup_by_target - find a device given the target 12661da177e4SLinus Torvalds * @starget: SCSI target pointer 12671da177e4SLinus Torvalds * @lun: SCSI Logical Unit Number 12681da177e4SLinus Torvalds * 1269477e608cSBartlomiej Zolnierkiewicz * Description: Looks up the scsi_device with the specified @lun for a given 1270477e608cSBartlomiej Zolnierkiewicz * @starget. The returned scsi_device has an additional reference that 1271eb44820cSRob Landley * needs to be released with scsi_device_put once you're done with it. 12721da177e4SLinus Torvalds **/ 12731da177e4SLinus Torvalds struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget, 12741da177e4SLinus Torvalds uint lun) 12751da177e4SLinus Torvalds { 12761da177e4SLinus Torvalds struct scsi_device *sdev; 12771da177e4SLinus Torvalds struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 12781da177e4SLinus Torvalds unsigned long flags; 12791da177e4SLinus Torvalds 12801da177e4SLinus Torvalds spin_lock_irqsave(shost->host_lock, flags); 12811da177e4SLinus Torvalds sdev = __scsi_device_lookup_by_target(starget, lun); 12821da177e4SLinus Torvalds if (sdev && scsi_device_get(sdev)) 12831da177e4SLinus Torvalds sdev = NULL; 12841da177e4SLinus Torvalds spin_unlock_irqrestore(shost->host_lock, flags); 12851da177e4SLinus Torvalds 12861da177e4SLinus Torvalds return sdev; 12871da177e4SLinus Torvalds } 12881da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_device_lookup_by_target); 12891da177e4SLinus Torvalds 12901da177e4SLinus Torvalds /** 1291eb44820cSRob Landley * __scsi_device_lookup - find a device given the host (UNLOCKED) 12921da177e4SLinus Torvalds * @shost: SCSI host pointer 12931da177e4SLinus Torvalds * @channel: SCSI channel (zero if only one channel) 1294eb44820cSRob Landley * @id: SCSI target number (physical unit number) 12951da177e4SLinus Torvalds * @lun: SCSI Logical Unit Number 12961da177e4SLinus Torvalds * 1297eb44820cSRob Landley * Description: Looks up the scsi_device with the specified @channel, @id, @lun 1298eb44820cSRob Landley * for a given host. The returned scsi_device does not have an additional 1299eb44820cSRob Landley * reference. You must hold the host's host_lock over this call and any access 1300eb44820cSRob Landley * to the returned scsi_device. 13011da177e4SLinus Torvalds * 13021da177e4SLinus Torvalds * Note: The only reason why drivers would want to use this is because 1303eb44820cSRob Landley * they need to access the device list in irq context. Otherwise you 13041da177e4SLinus Torvalds * really want to use scsi_device_lookup instead. 13051da177e4SLinus Torvalds **/ 13061da177e4SLinus Torvalds struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost, 13071da177e4SLinus Torvalds uint channel, uint id, uint lun) 13081da177e4SLinus Torvalds { 13091da177e4SLinus Torvalds struct scsi_device *sdev; 13101da177e4SLinus Torvalds 13111da177e4SLinus Torvalds list_for_each_entry(sdev, &shost->__devices, siblings) { 13121da177e4SLinus Torvalds if (sdev->channel == channel && sdev->id == id && 13131da177e4SLinus Torvalds sdev->lun ==lun) 13141da177e4SLinus Torvalds return sdev; 13151da177e4SLinus Torvalds } 13161da177e4SLinus Torvalds 13171da177e4SLinus Torvalds return NULL; 13181da177e4SLinus Torvalds } 13191da177e4SLinus Torvalds EXPORT_SYMBOL(__scsi_device_lookup); 13201da177e4SLinus Torvalds 13211da177e4SLinus Torvalds /** 13221da177e4SLinus Torvalds * scsi_device_lookup - find a device given the host 13231da177e4SLinus Torvalds * @shost: SCSI host pointer 13241da177e4SLinus Torvalds * @channel: SCSI channel (zero if only one channel) 13251da177e4SLinus Torvalds * @id: SCSI target number (physical unit number) 13261da177e4SLinus Torvalds * @lun: SCSI Logical Unit Number 13271da177e4SLinus Torvalds * 1328eb44820cSRob Landley * Description: Looks up the scsi_device with the specified @channel, @id, @lun 1329eb44820cSRob Landley * for a given host. The returned scsi_device has an additional reference that 1330eb44820cSRob Landley * needs to be released with scsi_device_put once you're done with it. 13311da177e4SLinus Torvalds **/ 13321da177e4SLinus Torvalds struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost, 13331da177e4SLinus Torvalds uint channel, uint id, uint lun) 13341da177e4SLinus Torvalds { 13351da177e4SLinus Torvalds struct scsi_device *sdev; 13361da177e4SLinus Torvalds unsigned long flags; 13371da177e4SLinus Torvalds 13381da177e4SLinus Torvalds spin_lock_irqsave(shost->host_lock, flags); 13391da177e4SLinus Torvalds sdev = __scsi_device_lookup(shost, channel, id, lun); 13401da177e4SLinus Torvalds if (sdev && scsi_device_get(sdev)) 13411da177e4SLinus Torvalds sdev = NULL; 13421da177e4SLinus Torvalds spin_unlock_irqrestore(shost->host_lock, flags); 13431da177e4SLinus Torvalds 13441da177e4SLinus Torvalds return sdev; 13451da177e4SLinus Torvalds } 13461da177e4SLinus Torvalds EXPORT_SYMBOL(scsi_device_lookup); 13471da177e4SLinus Torvalds 13481da177e4SLinus Torvalds MODULE_DESCRIPTION("SCSI core"); 13491da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 13501da177e4SLinus Torvalds 13511da177e4SLinus Torvalds module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR); 13521da177e4SLinus Torvalds MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels"); 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds static int __init init_scsi(void) 13551da177e4SLinus Torvalds { 13569bf09c23SJens Axboe int error; 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds error = scsi_init_queue(); 13591da177e4SLinus Torvalds if (error) 13601da177e4SLinus Torvalds return error; 13611da177e4SLinus Torvalds error = scsi_init_procfs(); 13621da177e4SLinus Torvalds if (error) 13631da177e4SLinus Torvalds goto cleanup_queue; 13641da177e4SLinus Torvalds error = scsi_init_devinfo(); 13651da177e4SLinus Torvalds if (error) 13661da177e4SLinus Torvalds goto cleanup_procfs; 13671da177e4SLinus Torvalds error = scsi_init_hosts(); 13681da177e4SLinus Torvalds if (error) 13691da177e4SLinus Torvalds goto cleanup_devlist; 13701da177e4SLinus Torvalds error = scsi_init_sysctl(); 13711da177e4SLinus Torvalds if (error) 13721da177e4SLinus Torvalds goto cleanup_hosts; 13731da177e4SLinus Torvalds error = scsi_sysfs_register(); 13741da177e4SLinus Torvalds if (error) 13751da177e4SLinus Torvalds goto cleanup_sysctl; 13761da177e4SLinus Torvalds 137784314fd4SJames Smart scsi_netlink_init(); 137884314fd4SJames Smart 13791da177e4SLinus Torvalds printk(KERN_NOTICE "SCSI subsystem initialized\n"); 13801da177e4SLinus Torvalds return 0; 13811da177e4SLinus Torvalds 13821da177e4SLinus Torvalds cleanup_sysctl: 13831da177e4SLinus Torvalds scsi_exit_sysctl(); 13841da177e4SLinus Torvalds cleanup_hosts: 13851da177e4SLinus Torvalds scsi_exit_hosts(); 13861da177e4SLinus Torvalds cleanup_devlist: 13871da177e4SLinus Torvalds scsi_exit_devinfo(); 13881da177e4SLinus Torvalds cleanup_procfs: 13891da177e4SLinus Torvalds scsi_exit_procfs(); 13901da177e4SLinus Torvalds cleanup_queue: 13911da177e4SLinus Torvalds scsi_exit_queue(); 13921da177e4SLinus Torvalds printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n", 13931da177e4SLinus Torvalds -error); 13941da177e4SLinus Torvalds return error; 13951da177e4SLinus Torvalds } 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds static void __exit exit_scsi(void) 13981da177e4SLinus Torvalds { 139984314fd4SJames Smart scsi_netlink_exit(); 14001da177e4SLinus Torvalds scsi_sysfs_unregister(); 14011da177e4SLinus Torvalds scsi_exit_sysctl(); 14021da177e4SLinus Torvalds scsi_exit_hosts(); 14031da177e4SLinus Torvalds scsi_exit_devinfo(); 14041da177e4SLinus Torvalds scsi_exit_procfs(); 14051da177e4SLinus Torvalds scsi_exit_queue(); 1406a4683487SDan Williams async_unregister_domain(&scsi_sd_probe_domain); 14071da177e4SLinus Torvalds } 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds subsys_initcall(init_scsi); 14101da177e4SLinus Torvalds module_exit(exit_scsi); 1411