drivers/scsi/scsi.c

   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  */
  83 unsigned int scsi_logging_level;
  84 #if defined(CONFIG_SCSI_LOGGING)
  85 EXPORT_SYMBOL(scsi_logging_level);
  86 #endif
  87
  88 /* sd, scsi core and power management need to coordinate flushing async actions */
  89 ASYNC_DOMAIN(scsi_sd_probe_domain);
  90 EXPORT_SYMBOL(scsi_sd_probe_domain);
  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  */
  98 ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain);
  99 EXPORT_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  */
 105 static 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
 134 const 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
 145 EXPORT_SYMBOL(scsi_device_type);
 146
 147 struct 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
 157 static 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
 163 static 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
 170 static 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  */
 180 static void
 181 scsi_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  */
 199 static struct scsi_cmnd *
 200 scsi_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
 222 fail_free_sense:
 223         kmem_cache_free(pool->sense_slab, cmd->sense_buffer);
 224 fail_free_cmd:
 225         kmem_cache_free(pool->cmd_slab, cmd);
 226 fail:
 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  */
 238 static 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  */
 277 struct 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  */
 300 static 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  */
 325 void 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
 340 static struct scsi_host_cmd_pool *
 341 scsi_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
 350 static void
 351 scsi_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
 358 static struct scsi_host_cmd_pool *
 359 scsi_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         return pool;
 381 }
 382
 383 static struct scsi_host_cmd_pool *
 384 scsi_get_host_cmd_pool(struct Scsi_Host *shost)
 385 {
 386         struct scsi_host_template *hostt = shost->hostt;
 387         struct scsi_host_cmd_pool *retval = NULL, *pool;
 388         size_t cmd_size = sizeof(struct scsi_cmnd) + hostt->cmd_size;
 389
 390         /*
 391          * Select a command slab for this host and create it if not
 392          * yet existent.
 393          */
 394         mutex_lock(&host_cmd_pool_mutex);
 395         pool = scsi_find_host_cmd_pool(shost);
 396         if (!pool) {
 397                 pool = scsi_alloc_host_cmd_pool(shost);
 398                 if (!pool)
 399                         goto out;
 400         }
 401
 402         if (!pool->users) {
 403                 pool->cmd_slab = kmem_cache_create(pool->cmd_name, cmd_size, 0,
 404                                                    pool->slab_flags, NULL);
 405                 if (!pool->cmd_slab)
 406                         goto out_free_pool;
 407
 408                 pool->sense_slab = kmem_cache_create(pool->sense_name,
 409                                                      SCSI_SENSE_BUFFERSIZE, 0,
 410                                                      pool->slab_flags, NULL);
 411                 if (!pool->sense_slab)
 412                         goto out_free_slab;
 413         }
 414
 415         pool->users++;
 416         retval = pool;
 417 out:
 418         mutex_unlock(&host_cmd_pool_mutex);
 419         return retval;
 420
 421 out_free_slab:
 422         kmem_cache_destroy(pool->cmd_slab);
 423 out_free_pool:
 424         if (hostt->cmd_size)
 425                 scsi_free_host_cmd_pool(pool);
 426         goto out;
 427 }
 428
 429 static void scsi_put_host_cmd_pool(struct Scsi_Host *shost)
 430 {
 431         struct scsi_host_template *hostt = shost->hostt;
 432         struct scsi_host_cmd_pool *pool;
 433
 434         mutex_lock(&host_cmd_pool_mutex);
 435         pool = scsi_find_host_cmd_pool(shost);
 436
 437         /*
 438          * This may happen if a driver has a mismatched get and put
 439          * of the command pool; the driver should be implicated in
 440          * the stack trace
 441          */
 442         BUG_ON(pool->users == 0);
 443
 444         if (!--pool->users) {
 445                 kmem_cache_destroy(pool->cmd_slab);
 446                 kmem_cache_destroy(pool->sense_slab);
 447                 if (hostt->cmd_size)
 448                         scsi_free_host_cmd_pool(pool);
 449         }
 450         mutex_unlock(&host_cmd_pool_mutex);
 451 }
 452
 453 /**
 454  * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
 455  * @shost: host to allocate the freelist for.
 456  *
 457  * Description: The command freelist protects against system-wide out of memory
 458  * deadlock by preallocating one SCSI command structure for each host, so the
 459  * system can always write to a swap file on a device associated with that host.
 460  *
 461  * Returns:     Nothing.
 462  */
 463 int scsi_setup_command_freelist(struct Scsi_Host *shost)
 464 {
 465         const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL;
 466         struct scsi_cmnd *cmd;
 467
 468         spin_lock_init(&shost->free_list_lock);
 469         INIT_LIST_HEAD(&shost->free_list);
 470
 471         shost->cmd_pool = scsi_get_host_cmd_pool(shost);
 472         if (!shost->cmd_pool)
 473                 return -ENOMEM;
 474
 475         /*
 476          * Get one backup command for this host.
 477          */
 478         cmd = scsi_host_alloc_command(shost, gfp_mask);
 479         if (!cmd) {
 480                 scsi_put_host_cmd_pool(shost);
 481                 shost->cmd_pool = NULL;
 482                 return -ENOMEM;
 483         }
 484         list_add(&cmd->list, &shost->free_list);
 485         return 0;
 486 }
 487
 488 /**
 489  * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
 490  * @shost: host whose freelist is going to be destroyed
 491  */
 492 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
 493 {
 494         /*
 495          * If cmd_pool is NULL the free list was not initialized, so
 496          * do not attempt to release resources.
 497          */
 498         if (!shost->cmd_pool)
 499                 return;
 500
 501         while (!list_empty(&shost->free_list)) {
 502                 struct scsi_cmnd *cmd;
 503
 504                 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
 505                 list_del_init(&cmd->list);
 506                 scsi_host_free_command(shost, cmd);
 507         }
 508         shost->cmd_pool = NULL;
 509         scsi_put_host_cmd_pool(shost);
 510 }
 511
 512 #ifdef CONFIG_SCSI_LOGGING
 513 void scsi_log_send(struct scsi_cmnd *cmd)
 514 {
 515         unsigned int level;
 516
 517         /*
 518          * If ML QUEUE log level is greater than or equal to:
 519          *
 520          * 1: nothing (match completion)
 521          *
 522          * 2: log opcode + command of all commands
 523          *
 524          * 3: same as 2 plus dump cmd address
 525          *
 526          * 4: same as 3 plus dump extra junk
 527          */
 528         if (unlikely(scsi_logging_level)) {
 529                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 530                                        SCSI_LOG_MLQUEUE_BITS);
 531                 if (level > 1) {
 532                         scmd_printk(KERN_INFO, cmd, "Send: ");
 533                         if (level > 2)
 534                                 printk("0x%p ", cmd);
 535                         printk("\n");
 536                         scsi_print_command(cmd);
 537                         if (level > 3) {
 538                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 539                                        " queuecommand 0x%p\n",
 540                                         scsi_sglist(cmd), scsi_bufflen(cmd),
 541                                         cmd->device->host->hostt->queuecommand);
 542
 543                         }
 544                 }
 545         }
 546 }
 547
 548 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 549 {
 550         unsigned int level;
 551
 552         /*
 553          * If ML COMPLETE log level is greater than or equal to:
 554          *
 555          * 1: log disposition, result, opcode + command, and conditionally
 556          * sense data for failures or non SUCCESS dispositions.
 557          *
 558          * 2: same as 1 but for all command completions.
 559          *
 560          * 3: same as 2 plus dump cmd address
 561          *
 562          * 4: same as 3 plus dump extra junk
 563          */
 564         if (unlikely(scsi_logging_level)) {
 565                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 566                                        SCSI_LOG_MLCOMPLETE_BITS);
 567                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 568                     (level > 1)) {
 569                         scmd_printk(KERN_INFO, cmd, "Done: ");
 570                         if (level > 2)
 571                                 printk("0x%p ", cmd);
 572                         /*
 573                          * Dump truncated values, so we usually fit within
 574                          * 80 chars.
 575                          */
 576                         switch (disposition) {
 577                         case SUCCESS:
 578                                 printk("SUCCESS\n");
 579                                 break;
 580                         case NEEDS_RETRY:
 581                                 printk("RETRY\n");
 582                                 break;
 583                         case ADD_TO_MLQUEUE:
 584                                 printk("MLQUEUE\n");
 585                                 break;
 586                         case FAILED:
 587                                 printk("FAILED\n");
 588                                 break;
 589                         case TIMEOUT_ERROR:
 590                                 /*
 591                                  * If called via scsi_times_out.
 592                                  */
 593                                 printk("TIMEOUT\n");
 594                                 break;
 595                         default:
 596                                 printk("UNKNOWN\n");
 597                         }
 598                         scsi_print_result(cmd);
 599                         scsi_print_command(cmd);
 600                         if (status_byte(cmd->result) & CHECK_CONDITION)
 601                                 scsi_print_sense("", cmd);
 602                         if (level > 3)
 603                                 scmd_printk(KERN_INFO, cmd,
 604                                             "scsi host busy %d failed %d\n",
 605                                             atomic_read(&cmd->device->host->host_busy),
 606                                             cmd->device->host->host_failed);
 607                 }
 608         }
 609 }
 610 #endif
 611
 612 /**
 613  * scsi_cmd_get_serial - Assign a serial number to a command
 614  * @host: the scsi host
 615  * @cmd: command to assign serial number to
 616  *
 617  * Description: a serial number identifies a request for error recovery
 618  * and debugging purposes.  Protected by the Host_Lock of host.
 619  */
 620 void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 621 {
 622         cmd->serial_number = host->cmd_serial_number++;
 623         if (cmd->serial_number == 0)
 624                 cmd->serial_number = host->cmd_serial_number++;
 625 }
 626 EXPORT_SYMBOL(scsi_cmd_get_serial);
 627
 628 /**
 629  * scsi_dispatch_command - Dispatch a command to the low-level driver.
 630  * @cmd: command block we are dispatching.
 631  *
 632  * Return: nonzero return request was rejected and device's queue needs to be
 633  * plugged.
 634  */
 635 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 636 {
 637         struct Scsi_Host *host = cmd->device->host;
 638         int rtn = 0;
 639
 640         atomic_inc(&cmd->device->iorequest_cnt);
 641
 642         /* check if the device is still usable */
 643         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 644                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 645                  * returns an immediate error upwards, and signals
 646                  * that the device is no longer present */
 647                 cmd->result = DID_NO_CONNECT << 16;
 648                 goto done;
 649         }
 650
 651         /* Check to see if the scsi lld made this device blocked. */
 652         if (unlikely(scsi_device_blocked(cmd->device))) {
 653                 /*
 654                  * in blocked state, the command is just put back on
 655                  * the device queue.  The suspend state has already
 656                  * blocked the queue so future requests should not
 657                  * occur until the device transitions out of the
 658                  * suspend state.
 659                  */
 660                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 661                         "queuecommand : device blocked\n"));
 662                 return SCSI_MLQUEUE_DEVICE_BUSY;
 663         }
 664
 665         /*
 666          * If SCSI-2 or lower, store the LUN value in cmnd.
 667          */
 668         if (cmd->device->scsi_level <= SCSI_2 &&
 669             cmd->device->scsi_level != SCSI_UNKNOWN) {
 670                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 671                                (cmd->device->lun << 5 & 0xe0);
 672         }
 673
 674         scsi_log_send(cmd);
 675
 676         /*
 677          * Before we queue this command, check if the command
 678          * length exceeds what the host adapter can handle.
 679          */
 680         if (cmd->cmd_len > cmd->device->host->max_cmd_len) {
 681                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 682                                "queuecommand : command too long. "
 683                                "cdb_size=%d host->max_cmd_len=%d\n",
 684                                cmd->cmd_len, cmd->device->host->max_cmd_len));
 685                 cmd->result = (DID_ABORT << 16);
 686                 goto done;
 687         }
 688
 689         if (unlikely(host->shost_state == SHOST_DEL)) {
 690                 cmd->result = (DID_NO_CONNECT << 16);
 691                 goto done;
 692
 693         }
 694
 695         trace_scsi_dispatch_cmd_start(cmd);
 696         rtn = host->hostt->queuecommand(host, cmd);
 697         if (rtn) {
 698                 trace_scsi_dispatch_cmd_error(cmd, rtn);
 699                 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
 700                     rtn != SCSI_MLQUEUE_TARGET_BUSY)
 701                         rtn = SCSI_MLQUEUE_HOST_BUSY;
 702
 703                 SCSI_LOG_MLQUEUE(3, scmd_printk(KERN_INFO, cmd,
 704                         "queuecommand : request rejected\n"));
 705         }
 706
 707         return rtn;
 708  done:
 709         cmd->scsi_done(cmd);
 710         return 0;
 711 }
 712
 713 /**
 714  * scsi_finish_command - cleanup and pass command back to upper layer
 715  * @cmd: the command
 716  *
 717  * Description: Pass command off to upper layer for finishing of I/O
 718  *              request, waking processes that are waiting on results,
 719  *              etc.
 720  */
 721 void scsi_finish_command(struct scsi_cmnd *cmd)
 722 {
 723         struct scsi_device *sdev = cmd->device;
 724         struct scsi_target *starget = scsi_target(sdev);
 725         struct Scsi_Host *shost = sdev->host;
 726         struct scsi_driver *drv;
 727         unsigned int good_bytes;
 728
 729         scsi_device_unbusy(sdev);
 730
 731         /*
 732          * Clear the flags that say that the device/target/host is no longer
 733          * capable of accepting new commands.
 734          */
 735         if (atomic_read(&shost->host_blocked))
 736                 atomic_set(&shost->host_blocked, 0);
 737         if (atomic_read(&starget->target_blocked))
 738                 atomic_set(&starget->target_blocked, 0);
 739         if (atomic_read(&sdev->device_blocked))
 740                 atomic_set(&sdev->device_blocked, 0);
 741
 742         /*
 743          * If we have valid sense information, then some kind of recovery
 744          * must have taken place.  Make a note of this.
 745          */
 746         if (SCSI_SENSE_VALID(cmd))
 747                 cmd->result |= (DRIVER_SENSE << 24);
 748
 749         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
 750                                 "Notifying upper driver of completion "
 751                                 "(result %x)\n", cmd->result));
 752
 753         good_bytes = scsi_bufflen(cmd);
 754         if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
 755                 int old_good_bytes = good_bytes;
 756                 drv = scsi_cmd_to_driver(cmd);
 757                 if (drv->done)
 758                         good_bytes = drv->done(cmd);
 759                 /*
 760                  * USB may not give sense identifying bad sector and
 761                  * simply return a residue instead, so subtract off the
 762                  * residue if drv->done() error processing indicates no
 763                  * change to the completion length.
 764                  */
 765                 if (good_bytes == old_good_bytes)
 766                         good_bytes -= scsi_get_resid(cmd);
 767         }
 768         scsi_io_completion(cmd, good_bytes);
 769 }
 770
 771 /**
 772  * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
 773  * @sdev: SCSI Device in question
 774  * @tagged: Do we use tagged queueing (non-0) or do we treat
 775  *          this device as an untagged device (0)
 776  * @tags: Number of tags allowed if tagged queueing enabled,
 777  *        or number of commands the low level driver can
 778  *        queue up in non-tagged mode (as per cmd_per_lun).
 779  *
 780  * Returns:     Nothing
 781  *
 782  * Lock Status: None held on entry
 783  *
 784  * Notes:       Low level drivers may call this at any time and we will do
 785  *              the right thing depending on whether or not the device is
 786  *              currently active and whether or not it even has the
 787  *              command blocks built yet.
 788  */
 789 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 790 {
 791         unsigned long flags;
 792
 793         /*
 794          * refuse to set tagged depth to an unworkable size
 795          */
 796         if (tags <= 0)
 797                 return;
 798
 799         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 800
 801         /*
 802          * Check to see if the queue is managed by the block layer.
 803          * If it is, and we fail to adjust the depth, exit.
 804          *
 805          * Do not resize the tag map if it is a host wide share bqt,
 806          * because the size should be the hosts's can_queue. If there
 807          * is more IO than the LLD's can_queue (so there are not enuogh
 808          * tags) request_fn's host queue ready check will handle it.
 809          */
 810         if (!shost_use_blk_mq(sdev->host) && !sdev->host->bqt) {
 811                 if (blk_queue_tagged(sdev->request_queue) &&
 812                     blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 813                         goto out;
 814         }
 815
 816         sdev->queue_depth = tags;
 817         switch (tagged) {
 818                 case 0:
 819                         sdev->ordered_tags = 0;
 820                         sdev->simple_tags = 0;
 821                         break;
 822                 case MSG_ORDERED_TAG:
 823                         sdev->ordered_tags = 1;
 824                         sdev->simple_tags = 1;
 825                         break;
 826                 case MSG_SIMPLE_TAG:
 827                         sdev->ordered_tags = 0;
 828                         sdev->simple_tags = 1;
 829                         break;
 830                 default:
 831                         sdev->ordered_tags = 0;
 832                         sdev->simple_tags = 0;
 833                         sdev_printk(KERN_WARNING, sdev,
 834                                     "scsi_adjust_queue_depth, bad queue type, "
 835                                     "disabled\n");
 836         }
 837  out:
 838         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 839 }
 840 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 841
 842 /**
 843  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
 844  * @sdev: SCSI Device in question
 845  * @depth: Current number of outstanding SCSI commands on this device,
 846  *         not counting the one returned as QUEUE_FULL.
 847  *
 848  * Description: This function will track successive QUEUE_FULL events on a
 849  *              specific SCSI device to determine if and when there is a
 850  *              need to adjust the queue depth on the device.
 851  *
 852  * Returns:     0 - No change needed, >0 - Adjust queue depth to this new depth,
 853  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 854  *                      as the untagged command depth
 855  *
 856  * Lock Status: None held on entry
 857  *
 858  * Notes:       Low level drivers may call this at any time and we will do
 859  *              "The Right Thing."  We are interrupt context safe.
 860  */
 861 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 862 {
 863
 864         /*
 865          * Don't let QUEUE_FULLs on the same
 866          * jiffies count, they could all be from
 867          * same event.
 868          */
 869         if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
 870                 return 0;
 871
 872         sdev->last_queue_full_time = jiffies;
 873         if (sdev->last_queue_full_depth != depth) {
 874                 sdev->last_queue_full_count = 1;
 875                 sdev->last_queue_full_depth = depth;
 876         } else {
 877                 sdev->last_queue_full_count++;
 878         }
 879
 880         if (sdev->last_queue_full_count <= 10)
 881                 return 0;
 882         if (sdev->last_queue_full_depth < 8) {
 883                 /* Drop back to untagged */
 884                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 885                 return -1;
 886         }
 887
 888         if (sdev->ordered_tags)
 889                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
 890         else
 891                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 892         return depth;
 893 }
 894 EXPORT_SYMBOL(scsi_track_queue_full);
 895
 896 /**
 897  * scsi_vpd_inquiry - Request a device provide us with a VPD page
 898  * @sdev: The device to ask
 899  * @buffer: Where to put the result
 900  * @page: Which Vital Product Data to return
 901  * @len: The length of the buffer
 902  *
 903  * This is an internal helper function.  You probably want to use
 904  * scsi_get_vpd_page instead.
 905  *
 906  * Returns size of the vpd page on success or a negative error number.
 907  */
 908 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
 909                                                         u8 page, unsigned len)
 910 {
 911         int result;
 912         unsigned char cmd[16];
 913
 914         if (len < 4)
 915                 return -EINVAL;
 916
 917         cmd[0] = INQUIRY;
 918         cmd[1] = 1;             /* EVPD */
 919         cmd[2] = page;
 920         cmd[3] = len >> 8;
 921         cmd[4] = len & 0xff;
 922         cmd[5] = 0;             /* Control byte */
 923
 924         /*
 925          * I'm not convinced we need to try quite this hard to get VPD, but
 926          * all the existing users tried this hard.
 927          */
 928         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
 929                                   len, NULL, 30 * HZ, 3, NULL);
 930         if (result)
 931                 return -EIO;
 932
 933         /* Sanity check that we got the page back that we asked for */
 934         if (buffer[1] != page)
 935                 return -EIO;
 936
 937         return get_unaligned_be16(&buffer[2]) + 4;
 938 }
 939
 940 /**
 941  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
 942  * @sdev: The device to ask
 943  * @page: Which Vital Product Data to return
 944  * @buf: where to store the VPD
 945  * @buf_len: number of bytes in the VPD buffer area
 946  *
 947  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
 948  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
 949  * If the device supports this VPD page, this routine returns a pointer
 950  * to a buffer containing the data from that page.  The caller is
 951  * responsible for calling kfree() on this pointer when it is no longer
 952  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
 953  */
 954 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
 955                       int buf_len)
 956 {
 957         int i, result;
 958
 959         if (sdev->skip_vpd_pages)
 960                 goto fail;
 961
 962         /* Ask for all the pages supported by this device */
 963         result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
 964         if (result < 4)
 965                 goto fail;
 966
 967         /* If the user actually wanted this page, we can skip the rest */
 968         if (page == 0)
 969                 return 0;
 970
 971         for (i = 4; i < min(result, buf_len); i++)
 972                 if (buf[i] == page)
 973                         goto found;
 974
 975         if (i < result && i >= buf_len)
 976                 /* ran off the end of the buffer, give us benefit of doubt */
 977                 goto found;
 978         /* The device claims it doesn't support the requested page */
 979         goto fail;
 980
 981  found:
 982         result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
 983         if (result < 0)
 984                 goto fail;
 985
 986         return 0;
 987
 988  fail:
 989         return -EINVAL;
 990 }
 991 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
 992
 993 /**
 994  * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure
 995  * @sdev: The device to ask
 996  *
 997  * Attach the 'Device Identification' VPD page (0x83) and the
 998  * 'Unit Serial Number' VPD page (0x80) to a SCSI device
 999  * structure. This information can be used to identify the device
1000  * uniquely.
1001  */
1002 void scsi_attach_vpd(struct scsi_device *sdev)
1003 {
1004         int result, i;
1005         int vpd_len = SCSI_VPD_PG_LEN;
1006         int pg80_supported = 0;
1007         int pg83_supported = 0;
1008         unsigned char *vpd_buf;
1009
1010         if (sdev->skip_vpd_pages)
1011                 return;
1012 retry_pg0:
1013         vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
1014         if (!vpd_buf)
1015                 return;
1016
1017         /* Ask for all the pages supported by this device */
1018         result = scsi_vpd_inquiry(sdev, vpd_buf, 0, vpd_len);
1019         if (result < 0) {
1020                 kfree(vpd_buf);
1021                 return;
1022         }
1023         if (result > vpd_len) {
1024                 vpd_len = result;
1025                 kfree(vpd_buf);
1026                 goto retry_pg0;
1027         }
1028
1029         for (i = 4; i < result; i++) {
1030                 if (vpd_buf[i] == 0x80)
1031                         pg80_supported = 1;
1032                 if (vpd_buf[i] == 0x83)
1033                         pg83_supported = 1;
1034         }
1035         kfree(vpd_buf);
1036         vpd_len = SCSI_VPD_PG_LEN;
1037
1038         if (pg80_supported) {
1039 retry_pg80:
1040                 vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
1041                 if (!vpd_buf)
1042                         return;
1043
1044                 result = scsi_vpd_inquiry(sdev, vpd_buf, 0x80, vpd_len);
1045                 if (result < 0) {
1046                         kfree(vpd_buf);
1047                         return;
1048                 }
1049                 if (result > vpd_len) {
1050                         vpd_len = result;
1051                         kfree(vpd_buf);
1052                         goto retry_pg80;
1053                 }
1054                 sdev->vpd_pg80_len = result;
1055                 sdev->vpd_pg80 = vpd_buf;
1056                 vpd_len = SCSI_VPD_PG_LEN;
1057         }
1058
1059         if (pg83_supported) {
1060 retry_pg83:
1061                 vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
1062                 if (!vpd_buf)
1063                         return;
1064
1065                 result = scsi_vpd_inquiry(sdev, vpd_buf, 0x83, vpd_len);
1066                 if (result < 0) {
1067                         kfree(vpd_buf);
1068                         return;
1069                 }
1070                 if (result > vpd_len) {
1071                         vpd_len = result;
1072                         kfree(vpd_buf);
1073                         goto retry_pg83;
1074                 }
1075                 sdev->vpd_pg83_len = result;
1076                 sdev->vpd_pg83 = vpd_buf;
1077         }
1078 }
1079
1080 /**
1081  * scsi_report_opcode - Find out if a given command opcode is supported
1082  * @sdev:       scsi device to query
1083  * @buffer:     scratch buffer (must be at least 20 bytes long)
1084  * @len:        length of buffer
1085  * @opcode:     opcode for command to look up
1086  *
1087  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
1088  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
1089  * unsupported and 1 if the device claims to support the command.
1090  */
1091 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
1092                        unsigned int len, unsigned char opcode)
1093 {
1094         unsigned char cmd[16];
1095         struct scsi_sense_hdr sshdr;
1096         int result;
1097
1098         if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
1099                 return -EINVAL;
1100
1101         memset(cmd, 0, 16);
1102         cmd[0] = MAINTENANCE_IN;
1103         cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
1104         cmd[2] = 1;             /* One command format */
1105         cmd[3] = opcode;
1106         put_unaligned_be32(len, &cmd[6]);
1107         memset(buffer, 0, len);
1108
1109         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1110                                   &sshdr, 30 * HZ, 3, NULL);
1111
1112         if (result && scsi_sense_valid(&sshdr) &&
1113             sshdr.sense_key == ILLEGAL_REQUEST &&
1114             (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
1115                 return -EINVAL;
1116
1117         if ((buffer[1] & 3) == 3) /* Command supported */
1118                 return 1;
1119
1120         return 0;
1121 }
1122 EXPORT_SYMBOL(scsi_report_opcode);
1123
1124 /**
1125  * scsi_device_get  -  get an additional reference to a scsi_device
1126  * @sdev:       device to get a reference to
1127  *
1128  * Description: Gets a reference to the scsi_device and increments the use count
1129  * of the underlying LLDD module.  You must hold host_lock of the
1130  * parent Scsi_Host or already have a reference when calling this.
1131  */
1132 int scsi_device_get(struct scsi_device *sdev)
1133 {
1134         if (sdev->sdev_state == SDEV_DEL)
1135                 return -ENXIO;
1136         if (!get_device(&sdev->sdev_gendev))
1137                 return -ENXIO;
1138         /* We can fail this if we're doing SCSI operations
1139          * from module exit (like cache flush) */
1140         try_module_get(sdev->host->hostt->module);
1141
1142         return 0;
1143 }
1144 EXPORT_SYMBOL(scsi_device_get);
1145
1146 /**
1147  * scsi_device_put  -  release a reference to a scsi_device
1148  * @sdev:       device to release a reference on.
1149  *
1150  * Description: Release a reference to the scsi_device and decrements the use
1151  * count of the underlying LLDD module.  The device is freed once the last
1152  * user vanishes.
1153  */
1154 void scsi_device_put(struct scsi_device *sdev)
1155 {
1156 #ifdef CONFIG_MODULE_UNLOAD
1157         struct module *module = sdev->host->hostt->module;
1158
1159         /* The module refcount will be zero if scsi_device_get()
1160          * was called from a module removal routine */
1161         if (module && module_refcount(module) != 0)
1162                 module_put(module);
1163 #endif
1164         put_device(&sdev->sdev_gendev);
1165 }
1166 EXPORT_SYMBOL(scsi_device_put);
1167
1168 /* helper for shost_for_each_device, see that for documentation */
1169 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1170                                            struct scsi_device *prev)
1171 {
1172         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1173         struct scsi_device *next = NULL;
1174         unsigned long flags;
1175
1176         spin_lock_irqsave(shost->host_lock, flags);
1177         while (list->next != &shost->__devices) {
1178                 next = list_entry(list->next, struct scsi_device, siblings);
1179                 /* skip devices that we can't get a reference to */
1180                 if (!scsi_device_get(next))
1181                         break;
1182                 next = NULL;
1183                 list = list->next;
1184         }
1185         spin_unlock_irqrestore(shost->host_lock, flags);
1186
1187         if (prev)
1188                 scsi_device_put(prev);
1189         return next;
1190 }
1191 EXPORT_SYMBOL(__scsi_iterate_devices);
1192
1193 /**
1194  * starget_for_each_device  -  helper to walk all devices of a target
1195  * @starget:    target whose devices we want to iterate over.
1196  * @data:       Opaque passed to each function call.
1197  * @fn:         Function to call on each device
1198  *
1199  * This traverses over each device of @starget.  The devices have
1200  * a reference that must be released by scsi_host_put when breaking
1201  * out of the loop.
1202  */
1203 void starget_for_each_device(struct scsi_target *starget, void *data,
1204                      void (*fn)(struct scsi_device *, void *))
1205 {
1206         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1207         struct scsi_device *sdev;
1208
1209         shost_for_each_device(sdev, shost) {
1210                 if ((sdev->channel == starget->channel) &&
1211                     (sdev->id == starget->id))
1212                         fn(sdev, data);
1213         }
1214 }
1215 EXPORT_SYMBOL(starget_for_each_device);
1216
1217 /**
1218  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1219  * @starget:    target whose devices we want to iterate over.
1220  * @data:       parameter for callback @fn()
1221  * @fn:         callback function that is invoked for each device
1222  *
1223  * This traverses over each device of @starget.  It does _not_
1224  * take a reference on the scsi_device, so the whole loop must be
1225  * protected by shost->host_lock.
1226  *
1227  * Note:  The only reason why drivers would want to use this is because
1228  * they need to access the device list in irq context.  Otherwise you
1229  * really want to use starget_for_each_device instead.
1230  **/
1231 void __starget_for_each_device(struct scsi_target *starget, void *data,
1232                                void (*fn)(struct scsi_device *, void *))
1233 {
1234         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1235         struct scsi_device *sdev;
1236
1237         __shost_for_each_device(sdev, shost) {
1238                 if ((sdev->channel == starget->channel) &&
1239                     (sdev->id == starget->id))
1240                         fn(sdev, data);
1241         }
1242 }
1243 EXPORT_SYMBOL(__starget_for_each_device);
1244
1245 /**
1246  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1247  * @starget:    SCSI target pointer
1248  * @lun:        SCSI Logical Unit Number
1249  *
1250  * Description: Looks up the scsi_device with the specified @lun for a given
1251  * @starget.  The returned scsi_device does not have an additional
1252  * reference.  You must hold the host's host_lock over this call and
1253  * any access to the returned scsi_device. A scsi_device in state
1254  * SDEV_DEL is skipped.
1255  *
1256  * Note:  The only reason why drivers should use this is because
1257  * they need to access the device list in irq context.  Otherwise you
1258  * really want to use scsi_device_lookup_by_target instead.
1259  **/
1260 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1261                                                    u64 lun)
1262 {
1263         struct scsi_device *sdev;
1264
1265         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1266                 if (sdev->sdev_state == SDEV_DEL)
1267                         continue;
1268                 if (sdev->lun ==lun)
1269                         return sdev;
1270         }
1271
1272         return NULL;
1273 }
1274 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1275
1276 /**
1277  * scsi_device_lookup_by_target - find a device given the target
1278  * @starget:    SCSI target pointer
1279  * @lun:        SCSI Logical Unit Number
1280  *
1281  * Description: Looks up the scsi_device with the specified @lun for a given
1282  * @starget.  The returned scsi_device has an additional reference that
1283  * needs to be released with scsi_device_put once you're done with it.
1284  **/
1285 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1286                                                  u64 lun)
1287 {
1288         struct scsi_device *sdev;
1289         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1290         unsigned long flags;
1291
1292         spin_lock_irqsave(shost->host_lock, flags);
1293         sdev = __scsi_device_lookup_by_target(starget, lun);
1294         if (sdev && scsi_device_get(sdev))
1295                 sdev = NULL;
1296         spin_unlock_irqrestore(shost->host_lock, flags);
1297
1298         return sdev;
1299 }
1300 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1301
1302 /**
1303  * __scsi_device_lookup - find a device given the host (UNLOCKED)
1304  * @shost:      SCSI host pointer
1305  * @channel:    SCSI channel (zero if only one channel)
1306  * @id:         SCSI target number (physical unit number)
1307  * @lun:        SCSI Logical Unit Number
1308  *
1309  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1310  * for a given host. The returned scsi_device does not have an additional
1311  * reference.  You must hold the host's host_lock over this call and any access
1312  * to the returned scsi_device.
1313  *
1314  * Note:  The only reason why drivers would want to use this is because
1315  * they need to access the device list in irq context.  Otherwise you
1316  * really want to use scsi_device_lookup instead.
1317  **/
1318 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1319                 uint channel, uint id, u64 lun)
1320 {
1321         struct scsi_device *sdev;
1322
1323         list_for_each_entry(sdev, &shost->__devices, siblings) {
1324                 if (sdev->channel == channel && sdev->id == id &&
1325                                 sdev->lun ==lun)
1326                         return sdev;
1327         }
1328
1329         return NULL;
1330 }
1331 EXPORT_SYMBOL(__scsi_device_lookup);
1332
1333 /**
1334  * scsi_device_lookup - find a device given the host
1335  * @shost:      SCSI host pointer
1336  * @channel:    SCSI channel (zero if only one channel)
1337  * @id:         SCSI target number (physical unit number)
1338  * @lun:        SCSI Logical Unit Number
1339  *
1340  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1341  * for a given host.  The returned scsi_device has an additional reference that
1342  * needs to be released with scsi_device_put once you're done with it.
1343  **/
1344 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1345                 uint channel, uint id, u64 lun)
1346 {
1347         struct scsi_device *sdev;
1348         unsigned long flags;
1349
1350         spin_lock_irqsave(shost->host_lock, flags);
1351         sdev = __scsi_device_lookup(shost, channel, id, lun);
1352         if (sdev && scsi_device_get(sdev))
1353                 sdev = NULL;
1354         spin_unlock_irqrestore(shost->host_lock, flags);
1355
1356         return sdev;
1357 }
1358 EXPORT_SYMBOL(scsi_device_lookup);
1359
1360 MODULE_DESCRIPTION("SCSI core");
1361 MODULE_LICENSE("GPL");
1362
1363 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1364 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1365
1366 bool scsi_use_blk_mq = false;
1367 module_param_named(use_blk_mq, scsi_use_blk_mq, bool, S_IWUSR | S_IRUGO);
1368
1369 static int __init init_scsi(void)
1370 {
1371         int error;
1372
1373         error = scsi_init_queue();
1374         if (error)
1375                 return error;
1376         error = scsi_init_procfs();
1377         if (error)
1378                 goto cleanup_queue;
1379         error = scsi_init_devinfo();
1380         if (error)
1381                 goto cleanup_procfs;
1382         error = scsi_init_hosts();
1383         if (error)
1384                 goto cleanup_devlist;
1385         error = scsi_init_sysctl();
1386         if (error)
1387                 goto cleanup_hosts;
1388         error = scsi_sysfs_register();
1389         if (error)
1390                 goto cleanup_sysctl;
1391
1392         scsi_netlink_init();
1393
1394         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1395         return 0;
1396
1397 cleanup_sysctl:
1398         scsi_exit_sysctl();
1399 cleanup_hosts:
1400         scsi_exit_hosts();
1401 cleanup_devlist:
1402         scsi_exit_devinfo();
1403 cleanup_procfs:
1404         scsi_exit_procfs();
1405 cleanup_queue:
1406         scsi_exit_queue();
1407         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1408                -error);
1409         return error;
1410 }
1411
1412 static void __exit exit_scsi(void)
1413 {
1414         scsi_netlink_exit();
1415         scsi_sysfs_unregister();
1416         scsi_exit_sysctl();
1417         scsi_exit_hosts();
1418         scsi_exit_devinfo();
1419         scsi_exit_procfs();
1420         scsi_exit_queue();
1421         async_unregister_domain(&scsi_sd_probe_domain);
1422 }
1423
1424 subsys_initcall(init_scsi);
1425 module_exit(exit_scsi);