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