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