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