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