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/sched.h>
  44 #include <linux/timer.h>
  45 #include <linux/string.h>
  46 #include <linux/slab.h>
  47 #include <linux/blkdev.h>
  48 #include <linux/delay.h>
  49 #include <linux/init.h>
  50 #include <linux/completion.h>
  51 #include <linux/devfs_fs_kernel.h>
  52 #include <linux/unistd.h>
  53 #include <linux/spinlock.h>
  54 #include <linux/kmod.h>
  55 #include <linux/interrupt.h>
  56 #include <linux/notifier.h>
  57 #include <linux/cpu.h>
  58
  59 #include <scsi/scsi.h>
  60 #include <scsi/scsi_cmnd.h>
  61 #include <scsi/scsi_dbg.h>
  62 #include <scsi/scsi_device.h>
  63 #include <scsi/scsi_eh.h>
  64 #include <scsi/scsi_host.h>
  65 #include <scsi/scsi_tcq.h>
  66 #include <scsi/scsi_request.h>
  67
  68 #include "scsi_priv.h"
  69 #include "scsi_logging.h"
  70
  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  * Macro to determine the size of SCSI command. This macro takes vendor
  83  * unique commands into account. SCSI commands in groups 6 and 7 are
  84  * vendor unique and we will depend upon the command length being
  85  * supplied correctly in cmd_len.
  86  */
  87 #define CDB_SIZE(cmd)   (((((cmd)->cmnd[0] >> 5) & 7) < 6) ? \
  88                                 COMMAND_SIZE((cmd)->cmnd[0]) : (cmd)->cmd_len)
  89
  90 /*
  91  * Data declarations.
  92  */
  93 unsigned long scsi_pid;
  94 static unsigned long serial_number;
  95
  96 /*
  97  * Note - the initial logging level can be set here to log events at boot time.
  98  * After the system is up, you may enable logging via the /proc interface.
  99  */
 100 unsigned int scsi_logging_level;
 101 #if defined(CONFIG_SCSI_LOGGING)
 102 EXPORT_SYMBOL(scsi_logging_level);
 103 #endif
 104
 105 const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE] = {
 106         "Direct-Access    ",
 107         "Sequential-Access",
 108         "Printer          ",
 109         "Processor        ",
 110         "WORM             ",
 111         "CD-ROM           ",
 112         "Scanner          ",
 113         "Optical Device   ",
 114         "Medium Changer   ",
 115         "Communications   ",
 116         "Unknown          ",
 117         "Unknown          ",
 118         "RAID             ",
 119         "Enclosure        ",
 120 };
 121 EXPORT_SYMBOL(scsi_device_types);
 122
 123 /*
 124  * Function:    scsi_allocate_request
 125  *
 126  * Purpose:     Allocate a request descriptor.
 127  *
 128  * Arguments:   device          - device for which we want a request
 129  *              gfp_mask        - allocation flags passed to kmalloc
 130  *
 131  * Lock status: No locks assumed to be held.  This function is SMP-safe.
 132  *
 133  * Returns:     Pointer to request block.
 134  */
 135 struct scsi_request *scsi_allocate_request(struct scsi_device *sdev,
 136                                            int gfp_mask)
 137 {
 138         const int offset = ALIGN(sizeof(struct scsi_request), 4);
 139         const int size = offset + sizeof(struct request);
 140         struct scsi_request *sreq;
 141
 142         sreq = kmalloc(size, gfp_mask);
 143         if (likely(sreq != NULL)) {
 144                 memset(sreq, 0, size);
 145                 sreq->sr_request = (struct request *)(((char *)sreq) + offset);
 146                 sreq->sr_device = sdev;
 147                 sreq->sr_host = sdev->host;
 148                 sreq->sr_magic = SCSI_REQ_MAGIC;
 149                 sreq->sr_data_direction = DMA_BIDIRECTIONAL;
 150         }
 151
 152         return sreq;
 153 }
 154 EXPORT_SYMBOL(scsi_allocate_request);
 155
 156 void __scsi_release_request(struct scsi_request *sreq)
 157 {
 158         struct request *req = sreq->sr_request;
 159
 160         /* unlikely because the tag was usually ended earlier by the
 161          * mid-layer. However, for layering reasons ULD's don't end
 162          * the tag of commands they generate. */
 163         if (unlikely(blk_rq_tagged(req))) {
 164                 unsigned long flags;
 165                 struct request_queue *q = req->q;
 166
 167                 spin_lock_irqsave(q->queue_lock, flags);
 168                 blk_queue_end_tag(q, req);
 169                 spin_unlock_irqrestore(q->queue_lock, flags);
 170         }
 171
 172
 173         if (likely(sreq->sr_command != NULL)) {
 174                 struct scsi_cmnd *cmd = sreq->sr_command;
 175
 176                 sreq->sr_command = NULL;
 177                 scsi_next_command(cmd);
 178         }
 179 }
 180
 181 /*
 182  * Function:    scsi_release_request
 183  *
 184  * Purpose:     Release a request descriptor.
 185  *
 186  * Arguments:   sreq    - request to release
 187  *
 188  * Lock status: No locks assumed to be held.  This function is SMP-safe.
 189  */
 190 void scsi_release_request(struct scsi_request *sreq)
 191 {
 192         __scsi_release_request(sreq);
 193         kfree(sreq);
 194 }
 195 EXPORT_SYMBOL(scsi_release_request);
 196
 197 struct scsi_host_cmd_pool {
 198         kmem_cache_t    *slab;
 199         unsigned int    users;
 200         char            *name;
 201         unsigned int    slab_flags;
 202         unsigned int    gfp_mask;
 203 };
 204
 205 static struct scsi_host_cmd_pool scsi_cmd_pool = {
 206         .name           = "scsi_cmd_cache",
 207         .slab_flags     = SLAB_HWCACHE_ALIGN,
 208 };
 209
 210 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
 211         .name           = "scsi_cmd_cache(DMA)",
 212         .slab_flags     = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
 213         .gfp_mask       = __GFP_DMA,
 214 };
 215
 216 static DECLARE_MUTEX(host_cmd_pool_mutex);
 217
 218 static struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost,
 219                                             int gfp_mask)
 220 {
 221         struct scsi_cmnd *cmd;
 222
 223         cmd = kmem_cache_alloc(shost->cmd_pool->slab,
 224                         gfp_mask | shost->cmd_pool->gfp_mask);
 225
 226         if (unlikely(!cmd)) {
 227                 unsigned long flags;
 228
 229                 spin_lock_irqsave(&shost->free_list_lock, flags);
 230                 if (likely(!list_empty(&shost->free_list))) {
 231                         cmd = list_entry(shost->free_list.next,
 232                                          struct scsi_cmnd, list);
 233                         list_del_init(&cmd->list);
 234                 }
 235                 spin_unlock_irqrestore(&shost->free_list_lock, flags);
 236         }
 237
 238         return cmd;
 239 }
 240
 241 /*
 242  * Function:    scsi_get_command()
 243  *
 244  * Purpose:     Allocate and setup a scsi command block
 245  *
 246  * Arguments:   dev     - parent scsi device
 247  *              gfp_mask- allocator flags
 248  *
 249  * Returns:     The allocated scsi command structure.
 250  */
 251 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, int gfp_mask)
 252 {
 253         struct scsi_cmnd *cmd;
 254
 255         /* Bail if we can't get a reference to the device */
 256         if (!get_device(&dev->sdev_gendev))
 257                 return NULL;
 258
 259         cmd = __scsi_get_command(dev->host, gfp_mask);
 260
 261         if (likely(cmd != NULL)) {
 262                 unsigned long flags;
 263
 264                 memset(cmd, 0, sizeof(*cmd));
 265                 cmd->device = dev;
 266                 cmd->state = SCSI_STATE_UNUSED;
 267                 cmd->owner = SCSI_OWNER_NOBODY;
 268                 init_timer(&cmd->eh_timeout);
 269                 INIT_LIST_HEAD(&cmd->list);
 270                 spin_lock_irqsave(&dev->list_lock, flags);
 271                 list_add_tail(&cmd->list, &dev->cmd_list);
 272                 spin_unlock_irqrestore(&dev->list_lock, flags);
 273         } else
 274                 put_device(&dev->sdev_gendev);
 275
 276         return cmd;
 277 }
 278 EXPORT_SYMBOL(scsi_get_command);
 279
 280 /*
 281  * Function:    scsi_put_command()
 282  *
 283  * Purpose:     Free a scsi command block
 284  *
 285  * Arguments:   cmd     - command block to free
 286  *
 287  * Returns:     Nothing.
 288  *
 289  * Notes:       The command must not belong to any lists.
 290  */
 291 void scsi_put_command(struct scsi_cmnd *cmd)
 292 {
 293         struct scsi_device *sdev = cmd->device;
 294         struct Scsi_Host *shost = sdev->host;
 295         unsigned long flags;
 296
 297         /* serious error if the command hasn't come from a device list */
 298         spin_lock_irqsave(&cmd->device->list_lock, flags);
 299         BUG_ON(list_empty(&cmd->list));
 300         list_del_init(&cmd->list);
 301         spin_unlock(&cmd->device->list_lock);
 302         /* changing locks here, don't need to restore the irq state */
 303         spin_lock(&shost->free_list_lock);
 304         if (unlikely(list_empty(&shost->free_list))) {
 305                 list_add(&cmd->list, &shost->free_list);
 306                 cmd = NULL;
 307         }
 308         spin_unlock_irqrestore(&shost->free_list_lock, flags);
 309
 310         if (likely(cmd != NULL))
 311                 kmem_cache_free(shost->cmd_pool->slab, cmd);
 312
 313         put_device(&sdev->sdev_gendev);
 314 }
 315 EXPORT_SYMBOL(scsi_put_command);
 316
 317 /*
 318  * Function:    scsi_setup_command_freelist()
 319  *
 320  * Purpose:     Setup the command freelist for a scsi host.
 321  *
 322  * Arguments:   shost   - host to allocate the freelist for.
 323  *
 324  * Returns:     Nothing.
 325  */
 326 int scsi_setup_command_freelist(struct Scsi_Host *shost)
 327 {
 328         struct scsi_host_cmd_pool *pool;
 329         struct scsi_cmnd *cmd;
 330
 331         spin_lock_init(&shost->free_list_lock);
 332         INIT_LIST_HEAD(&shost->free_list);
 333
 334         /*
 335          * Select a command slab for this host and create it if not
 336          * yet existant.
 337          */
 338         down(&host_cmd_pool_mutex);
 339         pool = (shost->unchecked_isa_dma ? &scsi_cmd_dma_pool : &scsi_cmd_pool);
 340         if (!pool->users) {
 341                 pool->slab = kmem_cache_create(pool->name,
 342                                 sizeof(struct scsi_cmnd), 0,
 343                                 pool->slab_flags, NULL, NULL);
 344                 if (!pool->slab)
 345                         goto fail;
 346         }
 347
 348         pool->users++;
 349         shost->cmd_pool = pool;
 350         up(&host_cmd_pool_mutex);
 351
 352         /*
 353          * Get one backup command for this host.
 354          */
 355         cmd = kmem_cache_alloc(shost->cmd_pool->slab,
 356                         GFP_KERNEL | shost->cmd_pool->gfp_mask);
 357         if (!cmd)
 358                 goto fail2;
 359         list_add(&cmd->list, &shost->free_list);
 360         return 0;
 361
 362  fail2:
 363         if (!--pool->users)
 364                 kmem_cache_destroy(pool->slab);
 365         return -ENOMEM;
 366  fail:
 367         up(&host_cmd_pool_mutex);
 368         return -ENOMEM;
 369
 370 }
 371
 372 /*
 373  * Function:    scsi_destroy_command_freelist()
 374  *
 375  * Purpose:     Release the command freelist for a scsi host.
 376  *
 377  * Arguments:   shost   - host that's freelist is going to be destroyed
 378  */
 379 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
 380 {
 381         while (!list_empty(&shost->free_list)) {
 382                 struct scsi_cmnd *cmd;
 383
 384                 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
 385                 list_del_init(&cmd->list);
 386                 kmem_cache_free(shost->cmd_pool->slab, cmd);
 387         }
 388
 389         down(&host_cmd_pool_mutex);
 390         if (!--shost->cmd_pool->users)
 391                 kmem_cache_destroy(shost->cmd_pool->slab);
 392         up(&host_cmd_pool_mutex);
 393 }
 394
 395 #ifdef CONFIG_SCSI_LOGGING
 396 void scsi_log_send(struct scsi_cmnd *cmd)
 397 {
 398         unsigned int level;
 399         struct scsi_device *sdev;
 400
 401         /*
 402          * If ML QUEUE log level is greater than or equal to:
 403          *
 404          * 1: nothing (match completion)
 405          *
 406          * 2: log opcode + command of all commands
 407          *
 408          * 3: same as 2 plus dump cmd address
 409          *
 410          * 4: same as 3 plus dump extra junk
 411          */
 412         if (unlikely(scsi_logging_level)) {
 413                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
 414                                        SCSI_LOG_MLQUEUE_BITS);
 415                 if (level > 1) {
 416                         sdev = cmd->device;
 417                         printk(KERN_INFO "scsi <%d:%d:%d:%d> send ",
 418                                sdev->host->host_no, sdev->channel, sdev->id,
 419                                sdev->lun);
 420                         if (level > 2)
 421                                 printk("0x%p ", cmd);
 422                         /*
 423                          * spaces to match disposition and cmd->result
 424                          * output in scsi_log_completion.
 425                          */
 426                         printk("                 ");
 427                         scsi_print_command(cmd);
 428                         if (level > 3) {
 429                                 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
 430                                        " done = 0x%p, queuecommand 0x%p\n",
 431                                         cmd->buffer, cmd->bufflen,
 432                                         cmd->done,
 433                                         sdev->host->hostt->queuecommand);
 434
 435                         }
 436                 }
 437         }
 438 }
 439
 440 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 441 {
 442         unsigned int level;
 443         struct scsi_device *sdev;
 444
 445         /*
 446          * If ML COMPLETE log level is greater than or equal to:
 447          *
 448          * 1: log disposition, result, opcode + command, and conditionally
 449          * sense data for failures or non SUCCESS dispositions.
 450          *
 451          * 2: same as 1 but for all command completions.
 452          *
 453          * 3: same as 2 plus dump cmd address
 454          *
 455          * 4: same as 3 plus dump extra junk
 456          */
 457         if (unlikely(scsi_logging_level)) {
 458                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
 459                                        SCSI_LOG_MLCOMPLETE_BITS);
 460                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
 461                     (level > 1)) {
 462                         sdev = cmd->device;
 463                         printk(KERN_INFO "scsi <%d:%d:%d:%d> done ",
 464                                sdev->host->host_no, sdev->channel, sdev->id,
 465                                sdev->lun);
 466                         if (level > 2)
 467                                 printk("0x%p ", cmd);
 468                         /*
 469                          * Dump truncated values, so we usually fit within
 470                          * 80 chars.
 471                          */
 472                         switch (disposition) {
 473                         case SUCCESS:
 474                                 printk("SUCCESS");
 475                                 break;
 476                         case NEEDS_RETRY:
 477                                 printk("RETRY  ");
 478                                 break;
 479                         case ADD_TO_MLQUEUE:
 480                                 printk("MLQUEUE");
 481                                 break;
 482                         case FAILED:
 483                                 printk("FAILED ");
 484                                 break;
 485                         case TIMEOUT_ERROR:
 486                                 /*
 487                                  * If called via scsi_times_out.
 488                                  */
 489                                 printk("TIMEOUT");
 490                                 break;
 491                         default:
 492                                 printk("UNKNOWN");
 493                         }
 494                         printk(" %8x ", cmd->result);
 495                         scsi_print_command(cmd);
 496                         if (status_byte(cmd->result) & CHECK_CONDITION) {
 497                                 /*
 498                                  * XXX The print_sense formatting/prefix
 499                                  * doesn't match this function.
 500                                  */
 501                                 scsi_print_sense("", cmd);
 502                         }
 503                         if (level > 3) {
 504                                 printk(KERN_INFO "scsi host busy %d failed %d\n",
 505                                        sdev->host->host_busy,
 506                                        sdev->host->host_failed);
 507                         }
 508                 }
 509         }
 510 }
 511 #endif
 512
 513 /*
 514  * Function:    scsi_dispatch_command
 515  *
 516  * Purpose:     Dispatch a command to the low-level driver.
 517  *
 518  * Arguments:   cmd - command block we are dispatching.
 519  *
 520  * Notes:
 521  */
 522 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
 523 {
 524         struct Scsi_Host *host = cmd->device->host;
 525         unsigned long flags = 0;
 526         unsigned long timeout;
 527         int rtn = 0;
 528
 529         /* check if the device is still usable */
 530         if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
 531                 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
 532                  * returns an immediate error upwards, and signals
 533                  * that the device is no longer present */
 534                 cmd->result = DID_NO_CONNECT << 16;
 535                 scsi_done(cmd);
 536                 /* return 0 (because the command has been processed) */
 537                 goto out;
 538         }
 539
 540         /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */
 541         if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) {
 542                 /*
 543                  * in SDEV_BLOCK, the command is just put back on the device
 544                  * queue.  The suspend state has already blocked the queue so
 545                  * future requests should not occur until the device
 546                  * transitions out of the suspend state.
 547                  */
 548                 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
 549
 550                 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
 551
 552                 /*
 553                  * NOTE: rtn is still zero here because we don't need the
 554                  * queue to be plugged on return (it's already stopped)
 555                  */
 556                 goto out;
 557         }
 558
 559         /* Assign a unique nonzero serial_number. */
 560         /* XXX(hch): this is racy */
 561         if (++serial_number == 0)
 562                 serial_number = 1;
 563         cmd->serial_number = serial_number;
 564         cmd->pid = scsi_pid++;
 565
 566         /*
 567          * If SCSI-2 or lower, store the LUN value in cmnd.
 568          */
 569         if (cmd->device->scsi_level <= SCSI_2) {
 570                 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
 571                                (cmd->device->lun << 5 & 0xe0);
 572         }
 573
 574         /*
 575          * We will wait MIN_RESET_DELAY clock ticks after the last reset so
 576          * we can avoid the drive not being ready.
 577          */
 578         timeout = host->last_reset + MIN_RESET_DELAY;
 579
 580         if (host->resetting && time_before(jiffies, timeout)) {
 581                 int ticks_remaining = timeout - jiffies;
 582                 /*
 583                  * NOTE: This may be executed from within an interrupt
 584                  * handler!  This is bad, but for now, it'll do.  The irq
 585                  * level of the interrupt handler has been masked out by the
 586                  * platform dependent interrupt handling code already, so the
 587                  * sti() here will not cause another call to the SCSI host's
 588                  * interrupt handler (assuming there is one irq-level per
 589                  * host).
 590                  */
 591                 while (--ticks_remaining >= 0)
 592                         mdelay(1 + 999 / HZ);
 593                 host->resetting = 0;
 594         }
 595
 596         scsi_add_timer(cmd, cmd->timeout_per_command, scsi_times_out);
 597
 598         scsi_log_send(cmd);
 599
 600         /*
 601          * We will use a queued command if possible, otherwise we will
 602          * emulate the queuing and calling of completion function ourselves.
 603          */
 604
 605         cmd->state = SCSI_STATE_QUEUED;
 606         cmd->owner = SCSI_OWNER_LOWLEVEL;
 607
 608         /*
 609          * Before we queue this command, check if the command
 610          * length exceeds what the host adapter can handle.
 611          */
 612         if (CDB_SIZE(cmd) > cmd->device->host->max_cmd_len) {
 613                 SCSI_LOG_MLQUEUE(3,
 614                                 printk("queuecommand : command too long.\n"));
 615                 cmd->result = (DID_ABORT << 16);
 616
 617                 scsi_done(cmd);
 618                 goto out;
 619         }
 620
 621         spin_lock_irqsave(host->host_lock, flags);
 622         if (unlikely(test_bit(SHOST_CANCEL, &host->shost_state))) {
 623                 cmd->result = (DID_NO_CONNECT << 16);
 624                 scsi_done(cmd);
 625         } else {
 626                 rtn = host->hostt->queuecommand(cmd, scsi_done);
 627         }
 628         spin_unlock_irqrestore(host->host_lock, flags);
 629         if (rtn) {
 630                 scsi_queue_insert(cmd,
 631                                 (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ?
 632                                  rtn : SCSI_MLQUEUE_HOST_BUSY);
 633                 SCSI_LOG_MLQUEUE(3,
 634                     printk("queuecommand : request rejected\n"));
 635         }
 636
 637  out:
 638         SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
 639         return rtn;
 640 }
 641
 642 /*
 643  * Function:    scsi_init_cmd_from_req
 644  *
 645  * Purpose:     Queue a SCSI command
 646  * Purpose:     Initialize a struct scsi_cmnd from a struct scsi_request
 647  *
 648  * Arguments:   cmd       - command descriptor.
 649  *              sreq      - Request from the queue.
 650  *
 651  * Lock status: None needed.
 652  *
 653  * Returns:     Nothing.
 654  *
 655  * Notes:       Mainly transfer data from the request structure to the
 656  *              command structure.  The request structure is allocated
 657  *              using the normal memory allocator, and requests can pile
 658  *              up to more or less any depth.  The command structure represents
 659  *              a consumable resource, as these are allocated into a pool
 660  *              when the SCSI subsystem initializes.  The preallocation is
 661  *              required so that in low-memory situations a disk I/O request
 662  *              won't cause the memory manager to try and write out a page.
 663  *              The request structure is generally used by ioctls and character
 664  *              devices.
 665  */
 666 void scsi_init_cmd_from_req(struct scsi_cmnd *cmd, struct scsi_request *sreq)
 667 {
 668         sreq->sr_command = cmd;
 669
 670         cmd->owner = SCSI_OWNER_MIDLEVEL;
 671         cmd->cmd_len = sreq->sr_cmd_len;
 672         cmd->use_sg = sreq->sr_use_sg;
 673
 674         cmd->request = sreq->sr_request;
 675         memcpy(cmd->data_cmnd, sreq->sr_cmnd, sizeof(cmd->data_cmnd));
 676         cmd->serial_number = 0;
 677         cmd->serial_number_at_timeout = 0;
 678         cmd->bufflen = sreq->sr_bufflen;
 679         cmd->buffer = sreq->sr_buffer;
 680         cmd->retries = 0;
 681         cmd->allowed = sreq->sr_allowed;
 682         cmd->done = sreq->sr_done;
 683         cmd->timeout_per_command = sreq->sr_timeout_per_command;
 684         cmd->sc_data_direction = sreq->sr_data_direction;
 685         cmd->sglist_len = sreq->sr_sglist_len;
 686         cmd->underflow = sreq->sr_underflow;
 687         cmd->sc_request = sreq;
 688         memcpy(cmd->cmnd, sreq->sr_cmnd, sizeof(sreq->sr_cmnd));
 689
 690         /*
 691          * Zero the sense buffer.  Some host adapters automatically request
 692          * sense on error.  0 is not a valid sense code.
 693          */
 694         memset(cmd->sense_buffer, 0, sizeof(sreq->sr_sense_buffer));
 695         cmd->request_buffer = sreq->sr_buffer;
 696         cmd->request_bufflen = sreq->sr_bufflen;
 697         cmd->old_use_sg = cmd->use_sg;
 698         if (cmd->cmd_len == 0)
 699                 cmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]);
 700         cmd->old_cmd_len = cmd->cmd_len;
 701         cmd->sc_old_data_direction = cmd->sc_data_direction;
 702         cmd->old_underflow = cmd->underflow;
 703
 704         /*
 705          * Start the timer ticking.
 706          */
 707         cmd->internal_timeout = NORMAL_TIMEOUT;
 708         cmd->abort_reason = 0;
 709         cmd->result = 0;
 710
 711         SCSI_LOG_MLQUEUE(3, printk("Leaving scsi_init_cmd_from_req()\n"));
 712 }
 713
 714 /*
 715  * Per-CPU I/O completion queue.
 716  */
 717 static DEFINE_PER_CPU(struct list_head, scsi_done_q);
 718
 719 /**
 720  * scsi_done - Enqueue the finished SCSI command into the done queue.
 721  * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
 722  * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
 723  *
 724  * This function is the mid-level's (SCSI Core) interrupt routine, which
 725  * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues
 726  * the command to the done queue for further processing.
 727  *
 728  * This is the producer of the done queue who enqueues at the tail.
 729  *
 730  * This function is interrupt context safe.
 731  */
 732 void scsi_done(struct scsi_cmnd *cmd)
 733 {
 734         /*
 735          * We don't have to worry about this one timing out any more.
 736          * If we are unable to remove the timer, then the command
 737          * has already timed out.  In which case, we have no choice but to
 738          * let the timeout function run, as we have no idea where in fact
 739          * that function could really be.  It might be on another processor,
 740          * etc, etc.
 741          */
 742         if (!scsi_delete_timer(cmd))
 743                 return;
 744         __scsi_done(cmd);
 745 }
 746
 747 /* Private entry to scsi_done() to complete a command when the timer
 748  * isn't running --- used by scsi_times_out */
 749 void __scsi_done(struct scsi_cmnd *cmd)
 750 {
 751         unsigned long flags;
 752
 753         /*
 754          * Set the serial numbers back to zero
 755          */
 756         cmd->serial_number = 0;
 757         cmd->serial_number_at_timeout = 0;
 758         cmd->state = SCSI_STATE_BHQUEUE;
 759         cmd->owner = SCSI_OWNER_BH_HANDLER;
 760
 761         /*
 762          * Next, enqueue the command into the done queue.
 763          * It is a per-CPU queue, so we just disable local interrupts
 764          * and need no spinlock.
 765          */
 766         local_irq_save(flags);
 767         list_add_tail(&cmd->eh_entry, &__get_cpu_var(scsi_done_q));
 768         raise_softirq_irqoff(SCSI_SOFTIRQ);
 769         local_irq_restore(flags);
 770 }
 771
 772 /**
 773  * scsi_softirq - Perform post-interrupt processing of finished SCSI commands.
 774  *
 775  * This is the consumer of the done queue.
 776  *
 777  * This is called with all interrupts enabled.  This should reduce
 778  * interrupt latency, stack depth, and reentrancy of the low-level
 779  * drivers.
 780  */
 781 static void scsi_softirq(struct softirq_action *h)
 782 {
 783         int disposition;
 784         LIST_HEAD(local_q);
 785
 786         local_irq_disable();
 787         list_splice_init(&__get_cpu_var(scsi_done_q), &local_q);
 788         local_irq_enable();
 789
 790         while (!list_empty(&local_q)) {
 791                 struct scsi_cmnd *cmd = list_entry(local_q.next,
 792                                                    struct scsi_cmnd, eh_entry);
 793                 list_del_init(&cmd->eh_entry);
 794
 795                 disposition = scsi_decide_disposition(cmd);
 796                 scsi_log_completion(cmd, disposition);
 797                 switch (disposition) {
 798                 case SUCCESS:
 799                         scsi_finish_command(cmd);
 800                         break;
 801                 case NEEDS_RETRY:
 802                         scsi_retry_command(cmd);
 803                         break;
 804                 case ADD_TO_MLQUEUE:
 805                         scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
 806                         break;
 807                 default:
 808                         if (!scsi_eh_scmd_add(cmd, 0))
 809                                 scsi_finish_command(cmd);
 810                 }
 811         }
 812 }
 813
 814 /*
 815  * Function:    scsi_retry_command
 816  *
 817  * Purpose:     Send a command back to the low level to be retried.
 818  *
 819  * Notes:       This command is always executed in the context of the
 820  *              bottom half handler, or the error handler thread. Low
 821  *              level drivers should not become re-entrant as a result of
 822  *              this.
 823  */
 824 int scsi_retry_command(struct scsi_cmnd *cmd)
 825 {
 826         /*
 827          * Restore the SCSI command state.
 828          */
 829         scsi_setup_cmd_retry(cmd);
 830
 831         /*
 832          * Zero the sense information from the last time we tried
 833          * this command.
 834          */
 835         memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
 836
 837         return scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
 838 }
 839
 840 /*
 841  * Function:    scsi_finish_command
 842  *
 843  * Purpose:     Pass command off to upper layer for finishing of I/O
 844  *              request, waking processes that are waiting on results,
 845  *              etc.
 846  */
 847 void scsi_finish_command(struct scsi_cmnd *cmd)
 848 {
 849         struct scsi_device *sdev = cmd->device;
 850         struct Scsi_Host *shost = sdev->host;
 851         struct scsi_request *sreq;
 852
 853         scsi_device_unbusy(sdev);
 854
 855         /*
 856          * Clear the flags which say that the device/host is no longer
 857          * capable of accepting new commands.  These are set in scsi_queue.c
 858          * for both the queue full condition on a device, and for a
 859          * host full condition on the host.
 860          *
 861          * XXX(hch): What about locking?
 862          */
 863         shost->host_blocked = 0;
 864         sdev->device_blocked = 0;
 865
 866         /*
 867          * If we have valid sense information, then some kind of recovery
 868          * must have taken place.  Make a note of this.
 869          */
 870         if (SCSI_SENSE_VALID(cmd))
 871                 cmd->result |= (DRIVER_SENSE << 24);
 872
 873         SCSI_LOG_MLCOMPLETE(4, printk("Notifying upper driver of completion "
 874                                 "for device %d %x\n", sdev->id, cmd->result));
 875
 876         cmd->owner = SCSI_OWNER_HIGHLEVEL;
 877         cmd->state = SCSI_STATE_FINISHED;
 878
 879         /*
 880          * We can get here with use_sg=0, causing a panic in the upper level
 881          */
 882         cmd->use_sg = cmd->old_use_sg;
 883
 884         /*
 885          * If there is an associated request structure, copy the data over
 886          * before we call the completion function.
 887          */
 888         sreq = cmd->sc_request;
 889         if (sreq) {
 890                sreq->sr_result = sreq->sr_command->result;
 891                if (sreq->sr_result) {
 892                        memcpy(sreq->sr_sense_buffer,
 893                               sreq->sr_command->sense_buffer,
 894                               sizeof(sreq->sr_sense_buffer));
 895                }
 896         }
 897
 898         cmd->done(cmd);
 899 }
 900 EXPORT_SYMBOL(scsi_finish_command);
 901
 902 /*
 903  * Function:    scsi_adjust_queue_depth()
 904  *
 905  * Purpose:     Allow low level drivers to tell us to change the queue depth
 906  *              on a specific SCSI device
 907  *
 908  * Arguments:   sdev    - SCSI Device in question
 909  *              tagged  - Do we use tagged queueing (non-0) or do we treat
 910  *                        this device as an untagged device (0)
 911  *              tags    - Number of tags allowed if tagged queueing enabled,
 912  *                        or number of commands the low level driver can
 913  *                        queue up in non-tagged mode (as per cmd_per_lun).
 914  *
 915  * Returns:     Nothing
 916  *
 917  * Lock Status: None held on entry
 918  *
 919  * Notes:       Low level drivers may call this at any time and we will do
 920  *              the right thing depending on whether or not the device is
 921  *              currently active and whether or not it even has the
 922  *              command blocks built yet.
 923  *
 924  * XXX(hch):    What exactly is device_request_lock trying to protect?
 925  */
 926 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
 927 {
 928         static DEFINE_SPINLOCK(device_request_lock);
 929         unsigned long flags;
 930
 931         /*
 932          * refuse to set tagged depth to an unworkable size
 933          */
 934         if (tags <= 0)
 935                 return;
 936
 937         spin_lock_irqsave(&device_request_lock, flags);
 938         spin_lock(sdev->request_queue->queue_lock);
 939
 940         /* Check to see if the queue is managed by the block layer
 941          * if it is, and we fail to adjust the depth, exit */
 942         if (blk_queue_tagged(sdev->request_queue) &&
 943             blk_queue_resize_tags(sdev->request_queue, tags) != 0)
 944                 goto out;
 945
 946         sdev->queue_depth = tags;
 947         switch (tagged) {
 948                 case MSG_ORDERED_TAG:
 949                         sdev->ordered_tags = 1;
 950                         sdev->simple_tags = 1;
 951                         break;
 952                 case MSG_SIMPLE_TAG:
 953                         sdev->ordered_tags = 0;
 954                         sdev->simple_tags = 1;
 955                         break;
 956                 default:
 957                         printk(KERN_WARNING "(scsi%d:%d:%d:%d) "
 958                                 "scsi_adjust_queue_depth, bad queue type, "
 959                                 "disabled\n", sdev->host->host_no,
 960                                 sdev->channel, sdev->id, sdev->lun);
 961                 case 0:
 962                         sdev->ordered_tags = sdev->simple_tags = 0;
 963                         sdev->queue_depth = tags;
 964                         break;
 965         }
 966  out:
 967         spin_unlock(sdev->request_queue->queue_lock);
 968         spin_unlock_irqrestore(&device_request_lock, flags);
 969 }
 970 EXPORT_SYMBOL(scsi_adjust_queue_depth);
 971
 972 /*
 973  * Function:    scsi_track_queue_full()
 974  *
 975  * Purpose:     This function will track successive QUEUE_FULL events on a
 976  *              specific SCSI device to determine if and when there is a
 977  *              need to adjust the queue depth on the device.
 978  *
 979  * Arguments:   sdev    - SCSI Device in question
 980  *              depth   - Current number of outstanding SCSI commands on
 981  *                        this device, not counting the one returned as
 982  *                        QUEUE_FULL.
 983  *
 984  * Returns:     0 - No change needed
 985  *              >0 - Adjust queue depth to this new depth
 986  *              -1 - Drop back to untagged operation using host->cmd_per_lun
 987  *                      as the untagged command depth
 988  *
 989  * Lock Status: None held on entry
 990  *
 991  * Notes:       Low level drivers may call this at any time and we will do
 992  *              "The Right Thing."  We are interrupt context safe.
 993  */
 994 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 995 {
 996         if ((jiffies >> 4) == sdev->last_queue_full_time)
 997                 return 0;
 998
 999         sdev->last_queue_full_time = (jiffies >> 4);
1000         if (sdev->last_queue_full_depth != depth) {
1001                 sdev->last_queue_full_count = 1;
1002                 sdev->last_queue_full_depth = depth;
1003         } else {
1004                 sdev->last_queue_full_count++;
1005         }
1006
1007         if (sdev->last_queue_full_count <= 10)
1008                 return 0;
1009         if (sdev->last_queue_full_depth < 8) {
1010                 /* Drop back to untagged */
1011                 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
1012                 return -1;
1013         }
1014
1015         if (sdev->ordered_tags)
1016                 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
1017         else
1018                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
1019         return depth;
1020 }
1021 EXPORT_SYMBOL(scsi_track_queue_full);
1022
1023 /**
1024  * scsi_device_get  -  get an addition reference to a scsi_device
1025  * @sdev:       device to get a reference to
1026  *
1027  * Gets a reference to the scsi_device and increments the use count
1028  * of the underlying LLDD module.  You must hold host_lock of the
1029  * parent Scsi_Host or already have a reference when calling this.
1030  */
1031 int scsi_device_get(struct scsi_device *sdev)
1032 {
1033         if (sdev->sdev_state == SDEV_DEL || sdev->sdev_state == SDEV_CANCEL)
1034                 return -ENXIO;
1035         if (!get_device(&sdev->sdev_gendev))
1036                 return -ENXIO;
1037         if (!try_module_get(sdev->host->hostt->module)) {
1038                 put_device(&sdev->sdev_gendev);
1039                 return -ENXIO;
1040         }
1041         return 0;
1042 }
1043 EXPORT_SYMBOL(scsi_device_get);
1044
1045 /**
1046  * scsi_device_put  -  release a reference to a scsi_device
1047  * @sdev:       device to release a reference on.
1048  *
1049  * Release a reference to the scsi_device and decrements the use count
1050  * of the underlying LLDD module.  The device is freed once the last
1051  * user vanishes.
1052  */
1053 void scsi_device_put(struct scsi_device *sdev)
1054 {
1055         module_put(sdev->host->hostt->module);
1056         put_device(&sdev->sdev_gendev);
1057 }
1058 EXPORT_SYMBOL(scsi_device_put);
1059
1060 /* helper for shost_for_each_device, thus not documented */
1061 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1062                                            struct scsi_device *prev)
1063 {
1064         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1065         struct scsi_device *next = NULL;
1066         unsigned long flags;
1067
1068         spin_lock_irqsave(shost->host_lock, flags);
1069         while (list->next != &shost->__devices) {
1070                 next = list_entry(list->next, struct scsi_device, siblings);
1071                 /* skip devices that we can't get a reference to */
1072                 if (!scsi_device_get(next))
1073                         break;
1074                 next = NULL;
1075                 list = list->next;
1076         }
1077         spin_unlock_irqrestore(shost->host_lock, flags);
1078
1079         if (prev)
1080                 scsi_device_put(prev);
1081         return next;
1082 }
1083 EXPORT_SYMBOL(__scsi_iterate_devices);
1084
1085 /**
1086  * starget_for_each_device  -  helper to walk all devices of a target
1087  * @starget:    target whose devices we want to iterate over.
1088  *
1089  * This traverses over each devices of @shost.  The devices have
1090  * a reference that must be released by scsi_host_put when breaking
1091  * out of the loop.
1092  */
1093 void starget_for_each_device(struct scsi_target *starget, void * data,
1094                      void (*fn)(struct scsi_device *, void *))
1095 {
1096         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1097         struct scsi_device *sdev;
1098
1099         shost_for_each_device(sdev, shost) {
1100                 if ((sdev->channel == starget->channel) &&
1101                     (sdev->id == starget->id))
1102                         fn(sdev, data);
1103         }
1104 }
1105 EXPORT_SYMBOL(starget_for_each_device);
1106
1107 /**
1108  * scsi_device_lookup - find a device given the host (UNLOCKED)
1109  * @shost:      SCSI host pointer
1110  * @channel:    SCSI channel (zero if only one channel)
1111  * @pun:        SCSI target number (physical unit number)
1112  * @lun:        SCSI Logical Unit Number
1113  *
1114  * Looks up the scsi_device with the specified @channel, @id, @lun for a
1115  * give host. The returned scsi_device does not have an additional reference.
1116  * You must hold the host's host_lock over this call and any access to the
1117  * returned scsi_device.
1118  *
1119  * Note:  The only reason why drivers would want to use this is because
1120  * they're need to access the device list in irq context.  Otherwise you
1121  * really want to use scsi_device_lookup instead.
1122  **/
1123 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1124                 uint channel, uint id, uint lun)
1125 {
1126         struct scsi_device *sdev;
1127
1128         list_for_each_entry(sdev, &shost->__devices, siblings) {
1129                 if (sdev->channel == channel && sdev->id == id &&
1130                                 sdev->lun ==lun)
1131                         return sdev;
1132         }
1133
1134         return NULL;
1135 }
1136 EXPORT_SYMBOL(__scsi_device_lookup);
1137
1138 /**
1139  * scsi_device_lookup - find a device given the host
1140  * @shost:      SCSI host pointer
1141  * @channel:    SCSI channel (zero if only one channel)
1142  * @id:         SCSI target number (physical unit number)
1143  * @lun:        SCSI Logical Unit Number
1144  *
1145  * Looks up the scsi_device with the specified @channel, @id, @lun for a
1146  * give host.  The returned scsi_device has an additional reference that
1147  * needs to be release with scsi_host_put once you're done with it.
1148  **/
1149 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1150                 uint channel, uint id, uint lun)
1151 {
1152         struct scsi_device *sdev;
1153         unsigned long flags;
1154
1155         spin_lock_irqsave(shost->host_lock, flags);
1156         sdev = __scsi_device_lookup(shost, channel, id, lun);
1157         if (sdev && scsi_device_get(sdev))
1158                 sdev = NULL;
1159         spin_unlock_irqrestore(shost->host_lock, flags);
1160
1161         return sdev;
1162 }
1163 EXPORT_SYMBOL(scsi_device_lookup);
1164
1165 /**
1166  * scsi_device_cancel - cancel outstanding IO to this device
1167  * @sdev:       Pointer to struct scsi_device
1168  * @recovery:   Boolean instructing function to recover device or not.
1169  *
1170  **/
1171 int scsi_device_cancel(struct scsi_device *sdev, int recovery)
1172 {
1173         struct scsi_cmnd *scmd;
1174         LIST_HEAD(active_list);
1175         struct list_head *lh, *lh_sf;
1176         unsigned long flags;
1177
1178         scsi_device_set_state(sdev, SDEV_CANCEL);
1179
1180         spin_lock_irqsave(&sdev->list_lock, flags);
1181         list_for_each_entry(scmd, &sdev->cmd_list, list) {
1182                 if (scmd->request && scmd->request->rq_status != RQ_INACTIVE) {
1183                         /*
1184                          * If we are unable to remove the timer, it means
1185                          * that the command has already timed out or
1186                          * finished.
1187                          */
1188                         if (!scsi_delete_timer(scmd))
1189                                 continue;
1190                         list_add_tail(&scmd->eh_entry, &active_list);
1191                 }
1192         }
1193         spin_unlock_irqrestore(&sdev->list_lock, flags);
1194
1195         if (!list_empty(&active_list)) {
1196                 list_for_each_safe(lh, lh_sf, &active_list) {
1197                         scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
1198                         list_del_init(lh);
1199                         if (recovery) {
1200                                 scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD);
1201                         } else {
1202                                 scmd->result = (DID_ABORT << 16);
1203                                 scsi_finish_command(scmd);
1204                         }
1205                 }
1206         }
1207
1208         return 0;
1209 }
1210 EXPORT_SYMBOL(scsi_device_cancel);
1211
1212 #ifdef CONFIG_HOTPLUG_CPU
1213 static int scsi_cpu_notify(struct notifier_block *self,
1214                            unsigned long action, void *hcpu)
1215 {
1216         int cpu = (unsigned long)hcpu;
1217
1218         switch(action) {
1219         case CPU_DEAD:
1220                 /* Drain scsi_done_q. */
1221                 local_irq_disable();
1222                 list_splice_init(&per_cpu(scsi_done_q, cpu),
1223                                  &__get_cpu_var(scsi_done_q));
1224                 raise_softirq_irqoff(SCSI_SOFTIRQ);
1225                 local_irq_enable();
1226                 break;
1227         default:
1228                 break;
1229         }
1230         return NOTIFY_OK;
1231 }
1232
1233 static struct notifier_block __devinitdata scsi_cpu_nb = {
1234         .notifier_call  = scsi_cpu_notify,
1235 };
1236
1237 #define register_scsi_cpu() register_cpu_notifier(&scsi_cpu_nb)
1238 #define unregister_scsi_cpu() unregister_cpu_notifier(&scsi_cpu_nb)
1239 #else
1240 #define register_scsi_cpu()
1241 #define unregister_scsi_cpu()
1242 #endif /* CONFIG_HOTPLUG_CPU */
1243
1244 MODULE_DESCRIPTION("SCSI core");
1245 MODULE_LICENSE("GPL");
1246
1247 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1248 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1249
1250 static int __init init_scsi(void)
1251 {
1252         int error, i;
1253
1254         error = scsi_init_queue();
1255         if (error)
1256                 return error;
1257         error = scsi_init_procfs();
1258         if (error)
1259                 goto cleanup_queue;
1260         error = scsi_init_devinfo();
1261         if (error)
1262                 goto cleanup_procfs;
1263         error = scsi_init_hosts();
1264         if (error)
1265                 goto cleanup_devlist;
1266         error = scsi_init_sysctl();
1267         if (error)
1268                 goto cleanup_hosts;
1269         error = scsi_sysfs_register();
1270         if (error)
1271                 goto cleanup_sysctl;
1272
1273         for (i = 0; i < NR_CPUS; i++)
1274                 INIT_LIST_HEAD(&per_cpu(scsi_done_q, i));
1275
1276         devfs_mk_dir("scsi");
1277         open_softirq(SCSI_SOFTIRQ, scsi_softirq, NULL);
1278         register_scsi_cpu();
1279         printk(KERN_NOTICE "SCSI subsystem initialized\n");
1280         return 0;
1281
1282 cleanup_sysctl:
1283         scsi_exit_sysctl();
1284 cleanup_hosts:
1285         scsi_exit_hosts();
1286 cleanup_devlist:
1287         scsi_exit_devinfo();
1288 cleanup_procfs:
1289         scsi_exit_procfs();
1290 cleanup_queue:
1291         scsi_exit_queue();
1292         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1293                -error);
1294         return error;
1295 }
1296
1297 static void __exit exit_scsi(void)
1298 {
1299         scsi_sysfs_unregister();
1300         scsi_exit_sysctl();
1301         scsi_exit_hosts();
1302         scsi_exit_devinfo();
1303         devfs_remove("scsi");
1304         scsi_exit_procfs();
1305         scsi_exit_queue();
1306         unregister_scsi_cpu();
1307 }
1308
1309 subsys_initcall(init_scsi);
1310 module_exit(exit_scsi);