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