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