linux/drivers/scsi/scsi.c
<<
>>
Prefs
   1/*
   2 *  scsi.c Copyright (C) 1992 Drew Eckhardt
   3 *         Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
   4 *         Copyright (C) 2002, 2003 Christoph Hellwig
   5 *
   6 *  generic mid-level SCSI driver
   7 *      Initial versions: Drew Eckhardt
   8 *      Subsequent revisions: Eric Youngdale
   9 *
  10 *  <drew@colorado.edu>
  11 *
  12 *  Bug correction thanks go to :
  13 *      Rik Faith <faith@cs.unc.edu>
  14 *      Tommy Thorn <tthorn>
  15 *      Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
  16 *
  17 *  Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
  18 *  add scatter-gather, multiple outstanding request, and other
  19 *  enhancements.
  20 *
  21 *  Native multichannel, wide scsi, /proc/scsi and hot plugging
  22 *  support added by Michael Neuffer <mike@i-connect.net>
  23 *
  24 *  Added request_module("scsi_hostadapter") for kerneld:
  25 *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
  26 *  Bjorn Ekwall  <bj0rn@blox.se>
  27 *  (changed to kmod)
  28 *
  29 *  Major improvements to the timeout, abort, and reset processing,
  30 *  as well as performance modifications for large queue depths by
  31 *  Leonard N. Zubkoff <lnz@dandelion.com>
  32 *
  33 *  Converted cli() code to spinlocks, Ingo Molnar
  34 *
  35 *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
  36 *
  37 *  out_of_space hacks, D. Gilbert (dpg) 990608
  38 */
  39
  40#include <linux/module.h>
  41#include <linux/moduleparam.h>
  42#include <linux/kernel.h>
  43#include <linux/timer.h>
  44#include <linux/string.h>
  45#include <linux/slab.h>
  46#include <linux/blkdev.h>
  47#include <linux/delay.h>
  48#include <linux/init.h>
  49#include <linux/completion.h>
  50#include <linux/unistd.h>
  51#include <linux/spinlock.h>
  52#include <linux/kmod.h>
  53#include <linux/interrupt.h>
  54#include <linux/notifier.h>
  55#include <linux/cpu.h>
  56#include <linux/mutex.h>
  57#include <linux/async.h>
  58#include <asm/unaligned.h>
  59
  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>
  68
  69#include "scsi_priv.h"
  70#include "scsi_logging.h"
  71
  72#define CREATE_TRACE_POINTS
  73#include <trace/events/scsi.h>
  74
  75static void scsi_done(struct scsi_cmnd *cmd);
  76
  77/*
  78 * Definitions and constants.
  79 */
  80
  81#define MIN_RESET_DELAY (2*HZ)
  82
  83/* Do not call reset on error if we just did a reset within 15 sec. */
  84#define MIN_RESET_PERIOD (15*HZ)
  85
  86/*
  87 * Note - the initial logging level can be set here to log events at boot time.
  88 * After the system is up, you may enable logging via the /proc interface.
  89 */
  90unsigned int scsi_logging_level;
  91#if defined(CONFIG_SCSI_LOGGING)
  92EXPORT_SYMBOL(scsi_logging_level);
  93#endif
  94
  95/* sd, scsi core and power management need to coordinate flushing async actions */
  96ASYNC_DOMAIN(scsi_sd_probe_domain);
  97EXPORT_SYMBOL(scsi_sd_probe_domain);
  98
  99/* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
 100 * You may not alter any existing entry (although adding new ones is
 101 * encouraged once assigned by ANSI/INCITS T10
 102 */
 103static const char *const scsi_device_types[] = {
 104        "Direct-Access    ",
 105        "Sequential-Access",
 106        "Printer          ",
 107        "Processor        ",
 108        "WORM             ",
 109        "CD-ROM           ",
 110        "Scanner          ",
 111        "Optical Device   ",
 112        "Medium Changer   ",
 113        "Communications   ",
 114        "ASC IT8          ",
 115        "ASC IT8          ",
 116        "RAID             ",
 117        "Enclosure        ",
 118        "Direct-Access-RBC",
 119        "Optical card     ",
 120        "Bridge controller",
 121        "Object storage   ",
 122        "Automation/Drive ",
 123};
 124
 125/**
 126 * scsi_device_type - Return 17 char string indicating device type.
 127 * @type: type number to look up
 128 */
 129
 130const char * scsi_device_type(unsigned type)
 131{
 132        if (type == 0x1e)
 133                return "Well-known LUN   ";
 134        if (type == 0x1f)
 135                return "No Device        ";
 136        if (type >= ARRAY_SIZE(scsi_device_types))
 137                return "Unknown          ";
 138        return scsi_device_types[type];
 139}
 140
 141EXPORT_SYMBOL(scsi_device_type);
 142
 143struct scsi_host_cmd_pool {
 144        struct kmem_cache       *cmd_slab;
 145        struct kmem_cache       *sense_slab;
 146        unsigned int            users;
 147        char                    *cmd_name;
 148        char                    *sense_name;
 149        unsigned int            slab_flags;
 150        gfp_t                   gfp_mask;
 151};
 152
 153static struct scsi_host_cmd_pool scsi_cmd_pool = {
 154        .cmd_name       = "scsi_cmd_cache",
 155        .sense_name     = "scsi_sense_cache",
 156        .slab_flags     = SLAB_HWCACHE_ALIGN,
 157};
 158
 159static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 160        .cmd_name       = "scsi_cmd_cache(DMA)",
 161        .sense_name     = "scsi_sense_cache(DMA)",
 162        .slab_flags     = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
 163        .gfp_mask       = __GFP_DMA,
 164};
 165
 166static DEFINE_MUTEX(host_cmd_pool_mutex);
 167
 168/**
 169 * scsi_pool_alloc_command - internal function to get a fully allocated command
 170 * @pool:       slab pool to allocate the command from
 171 * @gfp_mask:   mask for the allocation
 172 *
 173 * Returns a fully allocated command (with the allied sense buffer) or
 174 * NULL on failure
 175 */
 176static struct scsi_cmnd *
 177scsi_pool_alloc_command(struct scsi_host_cmd_pool *pool, gfp_t gfp_mask)
 178{
 179        struct scsi_cmnd *cmd;
 180
 181        cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask);
 182        if (!cmd)
 183                return NULL;
 184
 185        cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab,
 186                                             gfp_mask | pool->gfp_mask);
 187        if (!cmd->sense_buffer) {
 188                kmem_cache_free(pool->cmd_slab, cmd);
 189                return NULL;
 190        }
 191
 192        return cmd;
 193}
 194
 195/**
 196 * scsi_pool_free_command - internal function to release a command
 197 * @pool:       slab pool to allocate the command from
 198 * @cmd:        command to release
 199 *
 200 * the command must previously have been allocated by
 201 * scsi_pool_alloc_command.
 202 */
 203static void
 204scsi_pool_free_command(struct scsi_host_cmd_pool *pool,
 205                         struct scsi_cmnd *cmd)
 206{
 207        if (cmd->prot_sdb)
 208                kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb);
 209
 210        kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 211        kmem_cache_free(pool->cmd_slab, cmd);
 212}
 213
 214/**
 215 * scsi_host_alloc_command - internal function to allocate command
 216 * @shost:      SCSI host whose pool to allocate from
 217 * @gfp_mask:   mask for the allocation
 218 *
 219 * Returns a fully allocated command with sense buffer and protection
 220 * data buffer (where applicable) or NULL on failure
 221 */
 222static struct scsi_cmnd *
 223scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 224{
 225        struct scsi_cmnd *cmd;
 226
 227        cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask);
 228        if (!cmd)
 229                return NULL;
 230
 231        if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) {
 232                cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask);
 233
 234                if (!cmd->prot_sdb) {
 235                        scsi_pool_free_command(shost->cmd_pool, cmd);
 236                        return NULL;
 237                }
 238        }
 239
 240        return cmd;
 241}
 242
 243/**
 244 * __scsi_get_command - Allocate a struct scsi_cmnd
 245 * @shost: host to transmit command
 246 * @gfp_mask: allocation mask
 247 *
 248 * Description: allocate a struct scsi_cmd from host's slab, recycling from the
 249 *              host's free_list if necessary.
 250 */
 251struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
 252{
 253        struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask);
 254
 255        if (unlikely(!cmd)) {
 256                unsigned long flags;
 257
 258                spin_lock_irqsave(&shost->free_list_lock, flags);
 259                if (likely(!list_empty(&shost->free_list))) {
 260                        cmd = list_entry(shost->free_list.next,
 261                                         struct scsi_cmnd, list);
 262                        list_del_init(&cmd->list);
 263                }
 264                spin_unlock_irqrestore(&shost->free_list_lock, flags);
 265
 266                if (cmd) {
 267                        void *buf, *prot;
 268
 269                        buf = cmd->sense_buffer;
 270                        prot = cmd->prot_sdb;
 271
 272                        memset(cmd, 0, sizeof(*cmd));
 273
 274                        cmd->sense_buffer = buf;
 275                        cmd->prot_sdb = prot;
 276                }
 277        }
 278
 279        return cmd;
 280}
 281EXPORT_SYMBOL_GPL(__scsi_get_command);
 282
 283/**
 284 * scsi_get_command - Allocate and setup a scsi command block
 285 * @dev: parent scsi device
 286 * @gfp_mask: allocator flags
 287 *
 288 * Returns:     The allocated scsi command structure.
 289 */
 290struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
 291{
 292        struct scsi_cmnd *cmd;
 293
 294        /* Bail if we can't get a reference to the device */
 295        if (!get_device(&dev->sdev_gendev))
 296                return NULL;
 297
 298        cmd = __scsi_get_command(dev->host, gfp_mask);
 299
 300        if (likely(cmd != NULL)) {
 301                unsigned long flags;
 302
 303                cmd->device = dev;
 304                INIT_LIST_HEAD(&cmd->list);
 305                spin_lock_irqsave(&dev->list_lock, flags);
 306                list_add_tail(&cmd->list, &dev->cmd_list);
 307                spin_unlock_irqrestore(&dev->list_lock, flags);
 308                cmd->jiffies_at_alloc = jiffies;
 309        } else
 310                put_device(&dev->sdev_gendev);
 311
 312        return cmd;
 313}
 314EXPORT_SYMBOL(scsi_get_command);
 315
 316/**
 317 * __scsi_put_command - Free a struct scsi_cmnd
 318 * @shost: dev->host
 319 * @cmd: Command to free
 320 * @dev: parent scsi device
 321 */
 322void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd,
 323                        struct device *dev)
 324{
 325        unsigned long flags;
 326
 327        /* changing locks here, don't need to restore the irq state */
 328        spin_lock_irqsave(&shost->free_list_lock, flags);
 329        if (unlikely(list_empty(&shost->free_list))) {
 330                list_add(&cmd->list, &shost->free_list);
 331                cmd = NULL;
 332        }
 333        spin_unlock_irqrestore(&shost->free_list_lock, flags);
 334
 335        if (likely(cmd != NULL))
 336                scsi_pool_free_command(shost->cmd_pool, cmd);
 337
 338        put_device(dev);
 339}
 340EXPORT_SYMBOL(__scsi_put_command);
 341
 342/**
 343 * scsi_put_command - Free a scsi command block
 344 * @cmd: command block to free
 345 *
 346 * Returns:     Nothing.
 347 *
 348 * Notes:       The command must not belong to any lists.
 349 */
 350void scsi_put_command(struct scsi_cmnd *cmd)
 351{
 352        struct scsi_device *sdev = cmd->device;
 353        unsigned long flags;
 354
 355        /* serious error if the command hasn't come from a device list */
 356        spin_lock_irqsave(&cmd->device->list_lock, flags);
 357        BUG_ON(list_empty(&cmd->list));
 358        list_del_init(&cmd->list);
 359        spin_unlock_irqrestore(&cmd->device->list_lock, flags);
 360
 361        __scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
 362}
 363EXPORT_SYMBOL(scsi_put_command);
 364
 365static struct scsi_host_cmd_pool *scsi_get_host_cmd_pool(gfp_t gfp_mask)
 366{
 367        struct scsi_host_cmd_pool *retval = NULL, *pool;
 368        /*
 369         * Select a command slab for this host and create it if not
 370         * yet existent.
 371         */
 372        mutex_lock(&host_cmd_pool_mutex);
 373        pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
 374                &scsi_cmd_pool;
 375        if (!pool->users) {
 376                pool->cmd_slab = kmem_cache_create(pool->cmd_name,
 377                                                   sizeof(struct scsi_cmnd), 0,
 378                                                   pool->slab_flags, NULL);
 379                if (!pool->cmd_slab)
 380                        goto fail;
 381
 382                pool->sense_slab = kmem_cache_create(pool->sense_name,
 383                                                     SCSI_SENSE_BUFFERSIZE, 0,
 384                                                     pool->slab_flags, NULL);
 385                if (!pool->sense_slab) {
 386                        kmem_cache_destroy(pool->cmd_slab);
 387                        goto fail;
 388                }
 389        }
 390
 391        pool->users++;
 392        retval = pool;
 393 fail:
 394        mutex_unlock(&host_cmd_pool_mutex);
 395        return retval;
 396}
 397
 398static void scsi_put_host_cmd_pool(gfp_t gfp_mask)
 399{
 400        struct scsi_host_cmd_pool *pool;
 401
 402        mutex_lock(&host_cmd_pool_mutex);
 403        pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool :
 404                &scsi_cmd_pool;
 405        /*
 406         * This may happen if a driver has a mismatched get and put
 407         * of the command pool; the driver should be implicated in
 408         * the stack trace
 409         */
 410        BUG_ON(pool->users == 0);
 411
 412        if (!--pool->users) {
 413                kmem_cache_destroy(pool->cmd_slab);
 414                kmem_cache_destroy(pool->sense_slab);
 415        }
 416        mutex_unlock(&host_cmd_pool_mutex);
 417}
 418
 419/**
 420 * scsi_allocate_command - get a fully allocated SCSI command
 421 * @gfp_mask:   allocation mask
 422 *
 423 * This function is for use outside of the normal host based pools.
 424 * It allocates the relevant command and takes an additional reference
 425 * on the pool it used.  This function *must* be paired with
 426 * scsi_free_command which also has the identical mask, otherwise the
 427 * free pool counts will eventually go wrong and you'll trigger a bug.
 428 *
 429 * This function should *only* be used by drivers that need a static
 430 * command allocation at start of day for internal functions.
 431 */
 432struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask)
 433{
 434        struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
 435
 436        if (!pool)
 437                return NULL;
 438
 439        return scsi_pool_alloc_command(pool, gfp_mask);
 440}
 441EXPORT_SYMBOL(scsi_allocate_command);
 442
 443/**
 444 * scsi_free_command - free a command allocated by scsi_allocate_command
 445 * @gfp_mask:   mask used in the original allocation
 446 * @cmd:        command to free
 447 *
 448 * Note: using the original allocation mask is vital because that's
 449 * what determines which command pool we use to free the command.  Any
 450 * mismatch will cause the system to BUG eventually.
 451 */
 452void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd)
 453{
 454        struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask);
 455
 456        /*
 457         * this could trigger if the mask to scsi_allocate_command
 458         * doesn't match this mask.  Otherwise we're guaranteed that this
 459         * succeeds because scsi_allocate_command must have taken a reference
 460         * on the pool
 461         */
 462        BUG_ON(!pool);
 463
 464        scsi_pool_free_command(pool, cmd);
 465        /*
 466         * scsi_put_host_cmd_pool is called twice; once to release the
 467         * reference we took above, and once to release the reference
 468         * originally taken by scsi_allocate_command
 469         */
 470        scsi_put_host_cmd_pool(gfp_mask);
 471        scsi_put_host_cmd_pool(gfp_mask);
 472}
 473EXPORT_SYMBOL(scsi_free_command);
 474
 475/**
 476 * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
 477 * @shost: host to allocate the freelist for.
 478 *
 479 * Description: The command freelist protects against system-wide out of memory
 480 * deadlock by preallocating one SCSI command structure for each host, so the
 481 * system can always write to a swap file on a device associated with that host.
 482 *
 483 * Returns:     Nothing.
 484 */
 485int scsi_setup_command_freelist(struct Scsi_Host *shost)
 486{
 487        struct scsi_cmnd *cmd;
 488        const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
 489
 490        spin_lock_init(&shost->free_list_lock);
 491        INIT_LIST_HEAD(&shost->free_list);
 492
 493        shost->cmd_pool = scsi_get_host_cmd_pool(gfp_mask);
 494
 495        if (!shost->cmd_pool)
 496                return -ENOMEM;
 497
 498        /*
 499         * Get one backup command for this host.
 500         */
 501        cmd = scsi_host_alloc_command(shost, gfp_mask);
 502        if (!cmd) {
 503                scsi_put_host_cmd_pool(gfp_mask);
 504                shost->cmd_pool = NULL;
 505                return -ENOMEM;
 506        }
 507        list_add(&cmd->list, &shost->free_list);
 508        return 0;
 509}
 510
 511/**
 512 * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
 513 * @shost: host whose freelist is going to be destroyed
 514 */
 515void scsi_destroy_command_freelist(struct Scsi_Host *shost)
 516{
 517        /*
 518         * If cmd_pool is NULL the free list was not initialized, so
 519         * do not attempt to release resources.
 520         */
 521        if (!shost->cmd_pool)
 522                return;
 523
 524        while (!list_empty(&shost->free_list)) {
 525                struct scsi_cmnd *cmd;
 526
 527                cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
 528                list_del_init(&cmd->list);
 529                scsi_pool_free_command(shost->cmd_pool, cmd);
 530        }
 531        shost->cmd_pool = NULL;
 532        scsi_put_host_cmd_pool(shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL);
 533}
 534
 535#ifdef CONFIG_SCSI_LOGGING
 536void scsi_log_send(struct scsi_cmnd *cmd)
 537{
 538        unsigned int level;
 539
 540        /*
 541         * If ML QUEUE log level is greater than or equal to:
 542         *
 543         * 1: nothing (match completion)
 544         *
 545         * 2: log opcode + command of all commands
 546         *
 547         * 3: same as 2 plus dump cmd address
 548         *
 549         * 4: same as 3 plus dump extra junk
 550         */
 551        if (unlikely(scsi_logging_level)) {
 552                level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 553                                       SCSI_LOG_MLQUEUE_BITS);
 554                if (level > 1) {
 555                        scmd_printk(KERN_INFO, cmd, "Send: ");
 556                        if (level > 2)
 557                                printk("0x%p ", cmd);
 558                        printk("\n");
 559                        scsi_print_command(cmd);
 560                        if (level > 3) {
 561                                printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 562                                       " queuecommand 0x%p\n",
 563                                        scsi_sglist(cmd), scsi_bufflen(cmd),
 564                                        cmd->device->host->hostt->queuecommand);
 565
 566                        }
 567                }
 568        }
 569}
 570
 571void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 572{
 573        unsigned int level;
 574
 575        /*
 576         * If ML COMPLETE log level is greater than or equal to:
 577         *
 578         * 1: log disposition, result, opcode + command, and conditionally
 579         * sense data for failures or non SUCCESS dispositions.
 580         *
 581         * 2: same as 1 but for all command completions.
 582         *
 583         * 3: same as 2 plus dump cmd address
 584         *
 585         * 4: same as 3 plus dump extra junk
 586         */
 587        if (unlikely(scsi_logging_level)) {
 588                level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 589                                       SCSI_LOG_MLCOMPLETE_BITS);
 590                if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 591                    (level > 1)) {
 592                        scmd_printk(KERN_INFO, cmd, "Done: ");
 593                        if (level > 2)
 594                                printk("0x%p ", cmd);
 595                        /*
 596                         * Dump truncated values, so we usually fit within
 597                         * 80 chars.
 598                         */
 599                        switch (disposition) {
 600                        case SUCCESS:
 601                                printk("SUCCESS\n");
 602                                break;
 603                        case NEEDS_RETRY:
 604                                printk("RETRY\n");
 605                                break;
 606                        case ADD_TO_MLQUEUE:
 607                                printk("MLQUEUE\n");
 608                                break;
 609                        case FAILED:
 610                                printk("FAILED\n");
 611                                break;
 612                        case TIMEOUT_ERROR:
 613                                /* 
 614                                 * If called via scsi_times_out.
 615                                 */
 616                                printk("TIMEOUT\n");
 617                                break;
 618                        default:
 619                                printk("UNKNOWN\n");
 620                        }
 621                        scsi_print_result(cmd);
 622                        scsi_print_command(cmd);
 623                        if (status_byte(cmd->result) & CHECK_CONDITION)
 624                                scsi_print_sense("", cmd);
 625                        if (level > 3)
 626                                scmd_printk(KERN_INFO, cmd,
 627                                            "scsi host busy %d failed %d\n",
 628                                            cmd->device->host->host_busy,
 629                                            cmd->device->host->host_failed);
 630                }
 631        }
 632}
 633#endif
 634
 635/**
 636 * scsi_cmd_get_serial - Assign a serial number to a command
 637 * @host: the scsi host
 638 * @cmd: command to assign serial number to
 639 *
 640 * Description: a serial number identifies a request for error recovery
 641 * and debugging purposes.  Protected by the Host_Lock of host.
 642 */
 643void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 644{
 645        cmd->serial_number = host->cmd_serial_number++;
 646        if (cmd->serial_number == 0) 
 647                cmd->serial_number = host->cmd_serial_number++;
 648}
 649EXPORT_SYMBOL(scsi_cmd_get_serial);
 650
 651/**
 652 * scsi_dispatch_command - Dispatch a command to the low-level driver.
 653 * @cmd: command block we are dispatching.
 654 *
 655 * Return: nonzero return request was rejected and device's queue needs to be
 656 * plugged.
 657 */
 658int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 659{
 660        struct Scsi_Host *host = cmd->device->host;
 661        unsigned long timeout;
 662        int rtn = 0;
 663
 664        atomic_inc(&cmd->device->iorequest_cnt);
 665
 666        /* check if the device is still usable */
 667        if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 668                /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 669                 * returns an immediate error upwards, and signals
 670                 * that the device is no longer present */
 671                cmd->result = DID_NO_CONNECT << 16;
 672                scsi_done(cmd);
 673                /* return 0 (because the command has been processed) */
 674                goto out;
 675        }
 676
 677        /* Check to see if the scsi lld made this device blocked. */
 678        if (unlikely(scsi_device_blocked(cmd->device))) {
 679                /* 
 680                 * in blocked state, the command is just put back on
 681                 * the device queue.  The suspend state has already
 682                 * blocked the queue so future requests should not
 683                 * occur until the device transitions out of the
 684                 * suspend state.
 685                 */
 686
 687                scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
 688
 689                SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
 690
 691                /*
 692                 * NOTE: rtn is still zero here because we don't need the
 693                 * queue to be plugged on return (it's already stopped)
 694                 */
 695                goto out;
 696        }
 697
 698        /* 
 699         * If SCSI-2 or lower, store the LUN value in cmnd.
 700         */
 701        if (cmd->device->scsi_level <= SCSI_2 &&
 702            cmd->device->scsi_level != SCSI_UNKNOWN) {
 703                cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 704                               (cmd->device->lun << 5 & 0xe0);
 705        }
 706
 707        /*
 708         * We will wait MIN_RESET_DELAY clock ticks after the last reset so
 709         * we can avoid the drive not being ready.
 710         */
 711        timeout = host->last_reset + MIN_RESET_DELAY;
 712
 713        if (host->resetting && time_before(jiffies, timeout)) {
 714                int ticks_remaining = timeout - jiffies;
 715                /*
 716                 * NOTE: This may be executed from within an interrupt
 717                 * handler!  This is bad, but for now, it'll do.  The irq
 718                 * level of the interrupt handler has been masked out by the
 719                 * platform dependent interrupt handling code already, so the
 720                 * sti() here will not cause another call to the SCSI host's
 721                 * interrupt handler (assuming there is one irq-level per
 722                 * host).
 723                 */
 724                while (--ticks_remaining >= 0)
 725                        mdelay(1 + 999 / HZ);
 726                host->resetting = 0;
 727        }
 728
 729        scsi_log_send(cmd);
 730
 731        /*
 732         * Before we queue this command, check if the command
 733         * length exceeds what the host adapter can handle.
 734         */
 735        if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 736                SCSI_LOG_MLQUEUE(3,
 737                        printk("queuecommand : command too long. "
 738                               "cdb_size=%d host->max_cmd_len=%d\n",
 739                               cmd->cmd_len, cmd->device->host->max_cmd_len));
 740                cmd->result = (DID_ABORT << 16);
 741
 742                scsi_done(cmd);
 743                goto out;
 744        }
 745
 746        if (unlikely(host->shost_state == SHOST_DEL)) {
 747                cmd->result = (DID_NO_CONNECT << 16);
 748                scsi_done(cmd);
 749        } else {
 750                trace_scsi_dispatch_cmd_start(cmd);
 751                cmd->scsi_done = scsi_done;
 752                rtn = host->hostt->queuecommand(host, cmd);
 753        }
 754
 755        if (rtn) {
 756                trace_scsi_dispatch_cmd_error(cmd, rtn);
 757                if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
 758                    rtn != SCSI_MLQUEUE_TARGET_BUSY)
 759                        rtn = SCSI_MLQUEUE_HOST_BUSY;
 760
 761                scsi_queue_insert(cmd, rtn);
 762
 763                SCSI_LOG_MLQUEUE(3,
 764                    printk("queuecommand : request rejected\n"));
 765        }
 766
 767 out:
 768        SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
 769        return rtn;
 770}
 771
 772/**
 773 * scsi_done - Enqueue the finished SCSI command into the done queue.
 774 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
 775 * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
 776 *
 777 * Description: This function is the mid-level's (SCSI Core) interrupt routine,
 778 * which regains ownership of the SCSI command (de facto) from a LLDD, and
 779 * enqueues the command to the done queue for further processing.
 780 *
 781 * This is the producer of the done queue who enqueues at the tail.
 782 *
 783 * This function is interrupt context safe.
 784 */
 785static void scsi_done(struct scsi_cmnd *cmd)
 786{
 787        trace_scsi_dispatch_cmd_done(cmd);
 788        blk_complete_request(cmd->request);
 789}
 790
 791/**
 792 * scsi_finish_command - cleanup and pass command back to upper layer
 793 * @cmd: the command
 794 *
 795 * Description: Pass command off to upper layer for finishing of I/O
 796 *              request, waking processes that are waiting on results,
 797 *              etc.
 798 */
 799void scsi_finish_command(struct scsi_cmnd *cmd)
 800{
 801        struct scsi_device *sdev = cmd->device;
 802        struct scsi_target *starget = scsi_target(sdev);
 803        struct Scsi_Host *shost = sdev->host;
 804        struct scsi_driver *drv;
 805        unsigned int good_bytes;
 806
 807        scsi_device_unbusy(sdev);
 808
 809        /*
 810         * Clear the flags which say that the device/host is no longer
 811         * capable of accepting new commands.  These are set in scsi_queue.c
 812         * for both the queue full condition on a device, and for a
 813         * host full condition on the host.
 814         *
 815         * XXX(hch): What about locking?
 816         */
 817        shost->host_blocked = 0;
 818        starget->target_blocked = 0;
 819        sdev->device_blocked = 0;
 820
 821        /*
 822         * If we have valid sense information, then some kind of recovery
 823         * must have taken place.  Make a note of this.
 824         */
 825        if (SCSI_SENSE_VALID(cmd))
 826                cmd->result |= (DRIVER_SENSE << 24);
 827
 828        SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 829                                "Notifying upper driver of completion "
 830                                "(result %x)\n", cmd->result));
 831
 832        good_bytes = scsi_bufflen(cmd);
 833        if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 834                int old_good_bytes = good_bytes;
 835                drv = scsi_cmd_to_driver(cmd);
 836                if (drv->done)
 837                        good_bytes = drv->done(cmd);
 838                /*
 839                 * USB may not give sense identifying bad sector and
 840                 * simply return a residue instead, so subtract off the
 841                 * residue if drv->done() error processing indicates no
 842                 * change to the completion length.
 843                 */
 844                if (good_bytes == old_good_bytes)
 845                        good_bytes -= scsi_get_resid(cmd);
 846        }
 847        scsi_io_completion(cmd, good_bytes);
 848}
 849EXPORT_SYMBOL(scsi_finish_command);
 850
 851/**
 852 * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
 853 * @sdev: SCSI Device in question
 854 * @tagged: Do we use tagged queueing (non-0) or do we treat
 855 *          this device as an untagged device (0)
 856 * @tags: Number of tags allowed if tagged queueing enabled,
 857 *        or number of commands the low level driver can
 858 *        queue up in non-tagged mode (as per cmd_per_lun).
 859 *
 860 * Returns:     Nothing
 861 *
 862 * Lock Status: None held on entry
 863 *
 864 * Notes:       Low level drivers may call this at any time and we will do
 865 *              the right thing depending on whether or not the device is
 866 *              currently active and whether or not it even has the
 867 *              command blocks built yet.
 868 */
 869void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 870{
 871        unsigned long flags;
 872
 873        /*
 874         * refuse to set tagged depth to an unworkable size
 875         */
 876        if (tags <= 0)
 877                return;
 878
 879        spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 880
 881        /*
 882         * Check to see if the queue is managed by the block layer.
 883         * If it is, and we fail to adjust the depth, exit.
 884         *
 885         * Do not resize the tag map if it is a host wide share bqt,
 886         * because the size should be the hosts's can_queue. If there
 887         * is more IO than the LLD's can_queue (so there are not enuogh
 888         * tags) request_fn's host queue ready check will handle it.
 889         */
 890        if (!sdev->host->bqt) {
 891                if (blk_queue_tagged(sdev->request_queue) &&
 892                    blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 893                        goto out;
 894        }
 895
 896        sdev->queue_depth = tags;
 897        switch (tagged) {
 898                case MSG_ORDERED_TAG:
 899                        sdev->ordered_tags = 1;
 900                        sdev->simple_tags = 1;
 901                        break;
 902                case MSG_SIMPLE_TAG:
 903                        sdev->ordered_tags = 0;
 904                        sdev->simple_tags = 1;
 905                        break;
 906                default:
 907                        sdev_printk(KERN_WARNING, sdev,
 908                                    "scsi_adjust_queue_depth, bad queue type, "
 909                                    "disabled\n");
 910                case 0:
 911                        sdev->ordered_tags = sdev->simple_tags = 0;
 912                        sdev->queue_depth = tags;
 913                        break;
 914        }
 915 out:
 916        spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 917}
 918EXPORT_SYMBOL(scsi_adjust_queue_depth);
 919
 920/**
 921 * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
 922 * @sdev: SCSI Device in question
 923 * @depth: Current number of outstanding SCSI commands on this device,
 924 *         not counting the one returned as QUEUE_FULL.
 925 *
 926 * Description: This function will track successive QUEUE_FULL events on a
 927 *              specific SCSI device to determine if and when there is a
 928 *              need to adjust the queue depth on the device.
 929 *
 930 * Returns:     0 - No change needed, >0 - Adjust queue depth to this new depth,
 931 *              -1 - Drop back to untagged operation using host->cmd_per_lun
 932 *                      as the untagged command depth
 933 *
 934 * Lock Status: None held on entry
 935 *
 936 * Notes:       Low level drivers may call this at any time and we will do
 937 *              "The Right Thing."  We are interrupt context safe.
 938 */
 939int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 940{
 941
 942        /*
 943         * Don't let QUEUE_FULLs on the same
 944         * jiffies count, they could all be from
 945         * same event.
 946         */
 947        if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
 948                return 0;
 949
 950        sdev->last_queue_full_time = jiffies;
 951        if (sdev->last_queue_full_depth != depth) {
 952                sdev->last_queue_full_count = 1;
 953                sdev->last_queue_full_depth = depth;
 954        } else {
 955                sdev->last_queue_full_count++;
 956        }
 957
 958        if (sdev->last_queue_full_count <= 10)
 959                return 0;
 960        if (sdev->last_queue_full_depth < 8) {
 961                /* Drop back to untagged */
 962                scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 963                return -1;
 964        }
 965        
 966        if (sdev->ordered_tags)
 967                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 968        else
 969                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 970        return depth;
 971}
 972EXPORT_SYMBOL(scsi_track_queue_full);
 973
 974/**
 975 * scsi_vpd_inquiry - Request a device provide us with a VPD page
 976 * @sdev: The device to ask
 977 * @buffer: Where to put the result
 978 * @page: Which Vital Product Data to return
 979 * @len: The length of the buffer
 980 *
 981 * This is an internal helper function.  You probably want to use
 982 * scsi_get_vpd_page instead.
 983 *
 984 * Returns 0 on success or a negative error number.
 985 */
 986static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
 987                                                        u8 page, unsigned len)
 988{
 989        int result;
 990        unsigned char cmd[16];
 991
 992        cmd[0] = INQUIRY;
 993        cmd[1] = 1;             /* EVPD */
 994        cmd[2] = page;
 995        cmd[3] = len >> 8;
 996        cmd[4] = len & 0xff;
 997        cmd[5] = 0;             /* Control byte */
 998
 999        /*
1000         * I'm not convinced we need to try quite this hard to get VPD, but
1001         * all the existing users tried this hard.
1002         */
1003        result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
1004                                  len, NULL, 30 * HZ, 3, NULL);
1005        if (result)
1006                return result;
1007
1008        /* Sanity check that we got the page back that we asked for */
1009        if (buffer[1] != page)
1010                return -EIO;
1011
1012        return 0;
1013}
1014
1015/**
1016 * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
1017 * @sdev: The device to ask
1018 * @page: Which Vital Product Data to return
1019 * @buf: where to store the VPD
1020 * @buf_len: number of bytes in the VPD buffer area
1021 *
1022 * SCSI devices may optionally supply Vital Product Data.  Each 'page'
1023 * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
1024 * If the device supports this VPD page, this routine returns a pointer
1025 * to a buffer containing the data from that page.  The caller is
1026 * responsible for calling kfree() on this pointer when it is no longer
1027 * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
1028 */
1029int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
1030                      int buf_len)
1031{
1032        int i, result;
1033
1034        /* Ask for all the pages supported by this device */
1035        result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
1036        if (result)
1037                goto fail;
1038
1039        /* If the user actually wanted this page, we can skip the rest */
1040        if (page == 0)
1041                return 0;
1042
1043        for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
1044                if (buf[i + 4] == page)
1045                        goto found;
1046
1047        if (i < buf[3] && i >= buf_len - 4)
1048                /* ran off the end of the buffer, give us benefit of doubt */
1049                goto found;
1050        /* The device claims it doesn't support the requested page */
1051        goto fail;
1052
1053 found:
1054        result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
1055        if (result)
1056                goto fail;
1057
1058        return 0;
1059
1060 fail:
1061        return -EINVAL;
1062}
1063EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
1064
1065/**
1066 * scsi_report_opcode - Find out if a given command opcode is supported
1067 * @sdev:       scsi device to query
1068 * @buffer:     scratch buffer (must be at least 20 bytes long)
1069 * @len:        length of buffer
1070 * @opcode:     opcode for command to look up
1071 *
1072 * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
1073 * opcode. Returns 0 if RSOC fails or if the command opcode is
1074 * unsupported. Returns 1 if the device claims to support the command.
1075 */
1076int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
1077                       unsigned int len, unsigned char opcode)
1078{
1079        unsigned char cmd[16];
1080        struct scsi_sense_hdr sshdr;
1081        int result;
1082
1083        if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
1084                return 0;
1085
1086        memset(cmd, 0, 16);
1087        cmd[0] = MAINTENANCE_IN;
1088        cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
1089        cmd[2] = 1;             /* One command format */
1090        cmd[3] = opcode;
1091        put_unaligned_be32(len, &cmd[6]);
1092        memset(buffer, 0, len);
1093
1094        result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1095                                  &sshdr, 30 * HZ, 3, NULL);
1096
1097        if (result && scsi_sense_valid(&sshdr) &&
1098            sshdr.sense_key == ILLEGAL_REQUEST &&
1099            (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
1100                return 0;
1101
1102        if ((buffer[1] & 3) == 3) /* Command supported */
1103                return 1;
1104
1105        return 0;
1106}
1107EXPORT_SYMBOL(scsi_report_opcode);
1108
1109/**
1110 * scsi_device_get  -  get an additional reference to a scsi_device
1111 * @sdev:       device to get a reference to
1112 *
1113 * Description: Gets a reference to the scsi_device and increments the use count
1114 * of the underlying LLDD module.  You must hold host_lock of the
1115 * parent Scsi_Host or already have a reference when calling this.
1116 */
1117int scsi_device_get(struct scsi_device *sdev)
1118{
1119        if (sdev->sdev_state == SDEV_DEL)
1120                return -ENXIO;
1121        if (!get_device(&sdev->sdev_gendev))
1122                return -ENXIO;
1123        /* We can fail this if we're doing SCSI operations
1124         * from module exit (like cache flush) */
1125        try_module_get(sdev->host->hostt->module);
1126
1127        return 0;
1128}
1129EXPORT_SYMBOL(scsi_device_get);
1130
1131/**
1132 * scsi_device_put  -  release a reference to a scsi_device
1133 * @sdev:       device to release a reference on.
1134 *
1135 * Description: Release a reference to the scsi_device and decrements the use
1136 * count of the underlying LLDD module.  The device is freed once the last
1137 * user vanishes.
1138 */
1139void scsi_device_put(struct scsi_device *sdev)
1140{
1141#ifdef CONFIG_MODULE_UNLOAD
1142        struct module *module = sdev->host->hostt->module;
1143
1144        /* The module refcount will be zero if scsi_device_get()
1145         * was called from a module removal routine */
1146        if (module && module_refcount(module) != 0)
1147                module_put(module);
1148#endif
1149        put_device(&sdev->sdev_gendev);
1150}
1151EXPORT_SYMBOL(scsi_device_put);
1152
1153/* helper for shost_for_each_device, see that for documentation */
1154struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1155                                           struct scsi_device *prev)
1156{
1157        struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1158        struct scsi_device *next = NULL;
1159        unsigned long flags;
1160
1161        spin_lock_irqsave(shost->host_lock, flags);
1162        while (list->next != &shost->__devices) {
1163                next = list_entry(list->next, struct scsi_device, siblings);
1164                /* skip devices that we can't get a reference to */
1165                if (!scsi_device_get(next))
1166                        break;
1167                next = NULL;
1168                list = list->next;
1169        }
1170        spin_unlock_irqrestore(shost->host_lock, flags);
1171
1172        if (prev)
1173                scsi_device_put(prev);
1174        return next;
1175}
1176EXPORT_SYMBOL(__scsi_iterate_devices);
1177
1178/**
1179 * starget_for_each_device  -  helper to walk all devices of a target
1180 * @starget:    target whose devices we want to iterate over.
1181 * @data:       Opaque passed to each function call.
1182 * @fn:         Function to call on each device
1183 *
1184 * This traverses over each device of @starget.  The devices have
1185 * a reference that must be released by scsi_host_put when breaking
1186 * out of the loop.
1187 */
1188void starget_for_each_device(struct scsi_target *starget, void *data,
1189                     void (*fn)(struct scsi_device *, void *))
1190{
1191        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1192        struct scsi_device *sdev;
1193
1194        shost_for_each_device(sdev, shost) {
1195                if ((sdev->channel == starget->channel) &&
1196                    (sdev->id == starget->id))
1197                        fn(sdev, data);
1198        }
1199}
1200EXPORT_SYMBOL(starget_for_each_device);
1201
1202/**
1203 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1204 * @starget:    target whose devices we want to iterate over.
1205 * @data:       parameter for callback @fn()
1206 * @fn:         callback function that is invoked for each device
1207 *
1208 * This traverses over each device of @starget.  It does _not_
1209 * take a reference on the scsi_device, so the whole loop must be
1210 * protected by shost->host_lock.
1211 *
1212 * Note:  The only reason why drivers would want to use this is because
1213 * they need to access the device list in irq context.  Otherwise you
1214 * really want to use starget_for_each_device instead.
1215 **/
1216void __starget_for_each_device(struct scsi_target *starget, void *data,
1217                               void (*fn)(struct scsi_device *, void *))
1218{
1219        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1220        struct scsi_device *sdev;
1221
1222        __shost_for_each_device(sdev, shost) {
1223                if ((sdev->channel == starget->channel) &&
1224                    (sdev->id == starget->id))
1225                        fn(sdev, data);
1226        }
1227}
1228EXPORT_SYMBOL(__starget_for_each_device);
1229
1230/**
1231 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1232 * @starget:    SCSI target pointer
1233 * @lun:        SCSI Logical Unit Number
1234 *
1235 * Description: Looks up the scsi_device with the specified @lun for a given
1236 * @starget.  The returned scsi_device does not have an additional
1237 * reference.  You must hold the host's host_lock over this call and
1238 * any access to the returned scsi_device. A scsi_device in state
1239 * SDEV_DEL is skipped.
1240 *
1241 * Note:  The only reason why drivers should use this is because
1242 * they need to access the device list in irq context.  Otherwise you
1243 * really want to use scsi_device_lookup_by_target instead.
1244 **/
1245struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1246                                                   uint lun)
1247{
1248        struct scsi_device *sdev;
1249
1250        list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1251                if (sdev->sdev_state == SDEV_DEL)
1252                        continue;
1253                if (sdev->lun ==lun)
1254                        return sdev;
1255        }
1256
1257        return NULL;
1258}
1259EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1260
1261/**
1262 * scsi_device_lookup_by_target - find a device given the target
1263 * @starget:    SCSI target pointer
1264 * @lun:        SCSI Logical Unit Number
1265 *
1266 * Description: Looks up the scsi_device with the specified @lun for a given
1267 * @starget.  The returned scsi_device has an additional reference that
1268 * needs to be released with scsi_device_put once you're done with it.
1269 **/
1270struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1271                                                 uint lun)
1272{
1273        struct scsi_device *sdev;
1274        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1275        unsigned long flags;
1276
1277        spin_lock_irqsave(shost->host_lock, flags);
1278        sdev = __scsi_device_lookup_by_target(starget, lun);
1279        if (sdev && scsi_device_get(sdev))
1280                sdev = NULL;
1281        spin_unlock_irqrestore(shost->host_lock, flags);
1282
1283        return sdev;
1284}
1285EXPORT_SYMBOL(scsi_device_lookup_by_target);
1286
1287/**
1288 * __scsi_device_lookup - find a device given the host (UNLOCKED)
1289 * @shost:      SCSI host pointer
1290 * @channel:    SCSI channel (zero if only one channel)
1291 * @id:         SCSI target number (physical unit number)
1292 * @lun:        SCSI Logical Unit Number
1293 *
1294 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1295 * for a given host. The returned scsi_device does not have an additional
1296 * reference.  You must hold the host's host_lock over this call and any access
1297 * to the returned scsi_device.
1298 *
1299 * Note:  The only reason why drivers would want to use this is because
1300 * they need to access the device list in irq context.  Otherwise you
1301 * really want to use scsi_device_lookup instead.
1302 **/
1303struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1304                uint channel, uint id, uint lun)
1305{
1306        struct scsi_device *sdev;
1307
1308        list_for_each_entry(sdev, &shost->__devices, siblings) {
1309                if (sdev->channel == channel && sdev->id == id &&
1310                                sdev->lun ==lun)
1311                        return sdev;
1312        }
1313
1314        return NULL;
1315}
1316EXPORT_SYMBOL(__scsi_device_lookup);
1317
1318/**
1319 * scsi_device_lookup - find a device given the host
1320 * @shost:      SCSI host pointer
1321 * @channel:    SCSI channel (zero if only one channel)
1322 * @id:         SCSI target number (physical unit number)
1323 * @lun:        SCSI Logical Unit Number
1324 *
1325 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1326 * for a given host.  The returned scsi_device has an additional reference that
1327 * needs to be released with scsi_device_put once you're done with it.
1328 **/
1329struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1330                uint channel, uint id, uint lun)
1331{
1332        struct scsi_device *sdev;
1333        unsigned long flags;
1334
1335        spin_lock_irqsave(shost->host_lock, flags);
1336        sdev = __scsi_device_lookup(shost, channel, id, lun);
1337        if (sdev && scsi_device_get(sdev))
1338                sdev = NULL;
1339        spin_unlock_irqrestore(shost->host_lock, flags);
1340
1341        return sdev;
1342}
1343EXPORT_SYMBOL(scsi_device_lookup);
1344
1345MODULE_DESCRIPTION("SCSI core");
1346MODULE_LICENSE("GPL");
1347
1348module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1349MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1350
1351static int __init init_scsi(void)
1352{
1353        int error;
1354
1355        error = scsi_init_queue();
1356        if (error)
1357                return error;
1358        error = scsi_init_procfs();
1359        if (error)
1360                goto cleanup_queue;
1361        error = scsi_init_devinfo();
1362        if (error)
1363                goto cleanup_procfs;
1364        error = scsi_init_hosts();
1365        if (error)
1366                goto cleanup_devlist;
1367        error = scsi_init_sysctl();
1368        if (error)
1369                goto cleanup_hosts;
1370        error = scsi_sysfs_register();
1371        if (error)
1372                goto cleanup_sysctl;
1373
1374        scsi_netlink_init();
1375
1376        printk(KERN_NOTICE "SCSI subsystem initialized\n");
1377        return 0;
1378
1379cleanup_sysctl:
1380        scsi_exit_sysctl();
1381cleanup_hosts:
1382        scsi_exit_hosts();
1383cleanup_devlist:
1384        scsi_exit_devinfo();
1385cleanup_procfs:
1386        scsi_exit_procfs();
1387cleanup_queue:
1388        scsi_exit_queue();
1389        printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1390               -error);
1391        return error;
1392}
1393
1394static void __exit exit_scsi(void)
1395{
1396        scsi_netlink_exit();
1397        scsi_sysfs_unregister();
1398        scsi_exit_sysctl();
1399        scsi_exit_hosts();
1400        scsi_exit_devinfo();
1401        scsi_exit_procfs();
1402        scsi_exit_queue();
1403        async_unregister_domain(&scsi_sd_probe_domain);
1404}
1405
1406subsys_initcall(init_scsi);
1407module_exit(exit_scsi);
1408
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.