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