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