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