v2.5.0.7 -> v2.5.0.8
[opensuse:kernel.git] / drivers / scsi / scsi_lib.c
1 /*
2  *  scsi_lib.c Copyright (C) 1999 Eric Youngdale
3  *
4  *  SCSI queueing library.
5  *      Initial versions: Eric Youngdale (eric@andante.org).
6  *                        Based upon conversations with large numbers
7  *                        of people at Linux Expo.
8  */
9
10 /*
11  * The fundamental purpose of this file is to contain a library of utility
12  * routines that can be used by low-level drivers.   Ultimately the idea
13  * is that there should be a sufficiently rich number of functions that it
14  * would be possible for a driver author to fashion a queueing function for
15  * a low-level driver if they wished.   Note however that this file also
16  * contains the "default" versions of these functions, as we don't want to
17  * go through and retrofit queueing functions into all 30 some-odd drivers.
18  */
19
20 #define __NO_VERSION__
21 #include <linux/module.h>
22
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/slab.h>
27 #include <linux/ioport.h>
28 #include <linux/kernel.h>
29 #include <linux/stat.h>
30 #include <linux/blk.h>
31 #include <linux/interrupt.h>
32 #include <linux/delay.h>
33 #include <linux/smp_lock.h>
34 #include <linux/completion.h>
35
36
37 #define __KERNEL_SYSCALLS__
38
39 #include <linux/unistd.h>
40
41 #include <asm/system.h>
42 #include <asm/irq.h>
43 #include <asm/dma.h>
44
45 #include "scsi.h"
46 #include "hosts.h"
47 #include "constants.h"
48 #include <scsi/scsi_ioctl.h>
49
50 /*
51  * This entire source file deals with the new queueing code.
52  */
53
54 /*
55  * Function:    __scsi_insert_special()
56  *
57  * Purpose:     worker for scsi_insert_special_*()
58  *
59  * Arguments:   q - request queue where request should be inserted
60  *              rq - request to be inserted
61  *              data - private data
62  *              at_head - insert request at head or tail of queue
63  *
64  * Lock status: Assumed that queue lock is not held upon entry.
65  *
66  * Returns:     Nothing
67  */
68 static void __scsi_insert_special(request_queue_t *q, struct request *rq,
69                                   void *data, int at_head)
70 {
71         unsigned long flags;
72
73         ASSERT_LOCK(&q->queue_lock, 0);
74
75         /*
76          * tell I/O scheduler that this isn't a regular read/write (ie it
77          * must not attempt merges on this) and that it acts as a soft
78          * barrier
79          */
80         rq->flags = REQ_SPECIAL | REQ_BARRIER;
81
82         rq->special = data;
83         rq->q = NULL;
84         rq->bio = rq->biotail = NULL;
85         rq->nr_segments = 0;
86         rq->elevator_sequence = 0;
87
88         /*
89          * We have the option of inserting the head or the tail of the queue.
90          * Typically we use the tail for new ioctls and so forth.  We use the
91          * head of the queue for things like a QUEUE_FULL message from a
92          * device, or a host that is unable to accept a particular command.
93          */
94         spin_lock_irqsave(&q->queue_lock, flags);
95         __elv_add_request(q, rq, !at_head, 0);
96         q->request_fn(q);
97         spin_unlock_irqrestore(&q->queue_lock, flags);
98 }
99
100
101 /*
102  * Function:    scsi_insert_special_cmd()
103  *
104  * Purpose:     Insert pre-formed command into request queue.
105  *
106  * Arguments:   SCpnt   - command that is ready to be queued.
107  *              at_head - boolean.  True if we should insert at head
108  *                        of queue, false if we should insert at tail.
109  *
110  * Lock status: Assumed that lock is not held upon entry.
111  *
112  * Returns:     Nothing
113  *
114  * Notes:       This function is called from character device and from
115  *              ioctl types of functions where the caller knows exactly
116  *              what SCSI command needs to be issued.   The idea is that
117  *              we merely inject the command into the queue (at the head
118  *              for now), and then call the queue request function to actually
119  *              process it.
120  */
121 int scsi_insert_special_cmd(Scsi_Cmnd * SCpnt, int at_head)
122 {
123         request_queue_t *q = &SCpnt->device->request_queue;
124
125         __scsi_insert_special(q, &SCpnt->request, SCpnt, at_head);
126         return 0;
127 }
128
129 /*
130  * Function:    scsi_insert_special_req()
131  *
132  * Purpose:     Insert pre-formed request into request queue.
133  *
134  * Arguments:   SRpnt   - request that is ready to be queued.
135  *              at_head - boolean.  True if we should insert at head
136  *                        of queue, false if we should insert at tail.
137  *
138  * Lock status: Assumed that lock is not held upon entry.
139  *
140  * Returns:     Nothing
141  *
142  * Notes:       This function is called from character device and from
143  *              ioctl types of functions where the caller knows exactly
144  *              what SCSI command needs to be issued.   The idea is that
145  *              we merely inject the command into the queue (at the head
146  *              for now), and then call the queue request function to actually
147  *              process it.
148  */
149 int scsi_insert_special_req(Scsi_Request * SRpnt, int at_head)
150 {
151         request_queue_t *q = &SRpnt->sr_device->request_queue;
152
153         __scsi_insert_special(q, &SRpnt->sr_request, SRpnt, at_head);
154         return 0;
155 }
156
157 /*
158  * Function:    scsi_init_cmd_errh()
159  *
160  * Purpose:     Initialize SCpnt fields related to error handling.
161  *
162  * Arguments:   SCpnt   - command that is ready to be queued.
163  *
164  * Returns:     Nothing
165  *
166  * Notes:       This function has the job of initializing a number of
167  *              fields related to error handling.   Typically this will
168  *              be called once for each command, as required.
169  */
170 int scsi_init_cmd_errh(Scsi_Cmnd * SCpnt)
171 {
172         SCpnt->owner = SCSI_OWNER_MIDLEVEL;
173         SCpnt->reset_chain = NULL;
174         SCpnt->serial_number = 0;
175         SCpnt->serial_number_at_timeout = 0;
176         SCpnt->flags = 0;
177         SCpnt->retries = 0;
178
179         SCpnt->abort_reason = 0;
180
181         memset((void *) SCpnt->sense_buffer, 0, sizeof SCpnt->sense_buffer);
182
183         if (SCpnt->cmd_len == 0)
184                 SCpnt->cmd_len = COMMAND_SIZE(SCpnt->cmnd[0]);
185
186         /*
187          * We need saved copies of a number of fields - this is because
188          * error handling may need to overwrite these with different values
189          * to run different commands, and once error handling is complete,
190          * we will need to restore these values prior to running the actual
191          * command.
192          */
193         SCpnt->old_use_sg = SCpnt->use_sg;
194         SCpnt->old_cmd_len = SCpnt->cmd_len;
195         SCpnt->sc_old_data_direction = SCpnt->sc_data_direction;
196         SCpnt->old_underflow = SCpnt->underflow;
197         memcpy((void *) SCpnt->data_cmnd,
198                (const void *) SCpnt->cmnd, sizeof(SCpnt->cmnd));
199         SCpnt->buffer = SCpnt->request_buffer;
200         SCpnt->bufflen = SCpnt->request_bufflen;
201
202         SCpnt->reset_chain = NULL;
203
204         SCpnt->internal_timeout = NORMAL_TIMEOUT;
205         SCpnt->abort_reason = 0;
206
207         return 1;
208 }
209
210 /*
211  * Function:    scsi_queue_next_request()
212  *
213  * Purpose:     Handle post-processing of completed commands.
214  *
215  * Arguments:   SCpnt   - command that may need to be requeued.
216  *
217  * Returns:     Nothing
218  *
219  * Notes:       After command completion, there may be blocks left
220  *              over which weren't finished by the previous command
221  *              this can be for a number of reasons - the main one is
222  *              that a medium error occurred, and the sectors after
223  *              the bad block need to be re-read.
224  *
225  *              If SCpnt is NULL, it means that the previous command
226  *              was completely finished, and we should simply start
227  *              a new command, if possible.
228  *
229  *              This is where a lot of special case code has begun to
230  *              accumulate.  It doesn't really affect readability or
231  *              anything, but it might be considered architecturally
232  *              inelegant.  If more of these special cases start to
233  *              accumulate, I am thinking along the lines of implementing
234  *              an atexit() like technology that gets run when commands
235  *              complete.  I am not convinced that it is worth the
236  *              added overhead, however.  Right now as things stand,
237  *              there are simple conditional checks, and most hosts
238  *              would skip past.
239  *
240  *              Another possible solution would be to tailor different
241  *              handler functions, sort of like what we did in scsi_merge.c.
242  *              This is probably a better solution, but the number of different
243  *              permutations grows as 2**N, and if too many more special cases
244  *              get added, we start to get screwed.
245  */
246 void scsi_queue_next_request(request_queue_t * q, Scsi_Cmnd * SCpnt)
247 {
248         int all_clear;
249         unsigned long flags;
250         Scsi_Device *SDpnt;
251         struct Scsi_Host *SHpnt;
252
253         ASSERT_LOCK(&q->queue_lock, 0);
254
255         spin_lock_irqsave(&q->queue_lock, flags);
256         if (SCpnt != NULL) {
257
258                 /*
259                  * For some reason, we are not done with this request.
260                  * This happens for I/O errors in the middle of the request,
261                  * in which case we need to request the blocks that come after
262                  * the bad sector.
263                  */
264                 SCpnt->request.special = (void *) SCpnt;
265                 __elv_add_request(q, &SCpnt->request, 0, 0);
266         }
267
268         /*
269          * Just hit the requeue function for the queue.
270          */
271         q->request_fn(q);
272
273         SDpnt = (Scsi_Device *) q->queuedata;
274         SHpnt = SDpnt->host;
275
276         /*
277          * If this is a single-lun device, and we are currently finished
278          * with this device, then see if we need to get another device
279          * started.  FIXME(eric) - if this function gets too cluttered
280          * with special case code, then spin off separate versions and
281          * use function pointers to pick the right one.
282          */
283         if (SDpnt->single_lun && blk_queue_empty(q) && SDpnt->device_busy ==0) {
284                 request_queue_t *q;
285
286                 for (SDpnt = SHpnt->host_queue; SDpnt; SDpnt = SDpnt->next) {
287                         if (((SHpnt->can_queue > 0)
288                              && (SHpnt->host_busy >= SHpnt->can_queue))
289                             || (SHpnt->host_blocked)
290                             || (SHpnt->host_self_blocked)
291                             || (SDpnt->device_blocked)) {
292                                 break;
293                         }
294
295                         q = &SDpnt->request_queue;
296                         q->request_fn(q);
297                 }
298         }
299
300         /*
301          * Now see whether there are other devices on the bus which
302          * might be starved.  If so, hit the request function.  If we
303          * don't find any, then it is safe to reset the flag.  If we
304          * find any device that it is starved, it isn't safe to reset the
305          * flag as the queue function releases the lock and thus some
306          * other device might have become starved along the way.
307          */
308         all_clear = 1;
309         if (SHpnt->some_device_starved) {
310                 for (SDpnt = SHpnt->host_queue; SDpnt; SDpnt = SDpnt->next) {
311                         request_queue_t *q;
312                         if ((SHpnt->can_queue > 0 && (SHpnt->host_busy >= SHpnt->can_queue))
313                             || (SHpnt->host_blocked) 
314                             || (SHpnt->host_self_blocked)) {
315                                 break;
316                         }
317                         if (SDpnt->device_blocked || !SDpnt->starved) {
318                                 continue;
319                         }
320                         q = &SDpnt->request_queue;
321                         q->request_fn(q);
322                         all_clear = 0;
323                 }
324                 if (SDpnt == NULL && all_clear) {
325                         SHpnt->some_device_starved = 0;
326                 }
327         }
328         spin_unlock_irqrestore(&q->queue_lock, flags);
329 }
330
331 /*
332  * Function:    scsi_end_request()
333  *
334  * Purpose:     Post-processing of completed commands called from interrupt
335  *              handler or a bottom-half handler.
336  *
337  * Arguments:   SCpnt    - command that is complete.
338  *              uptodate - 1 if I/O indicates success, 0 for I/O error.
339  *              sectors  - number of sectors we want to mark.
340  *              requeue  - indicates whether we should requeue leftovers.
341  *              frequeue - indicates that if we release the command block
342  *                         that the queue request function should be called.
343  *
344  * Lock status: Assumed that lock is not held upon entry.
345  *
346  * Returns:     Nothing
347  *
348  * Notes:       This is called for block device requests in order to
349  *              mark some number of sectors as complete.
350  * 
351  *              We are guaranteeing that the request queue will be goosed
352  *              at some point during this call.
353  */
354 static Scsi_Cmnd *__scsi_end_request(Scsi_Cmnd * SCpnt, 
355                                      int uptodate, 
356                                      int sectors,
357                                      int requeue,
358                                      int frequeue)
359 {
360         request_queue_t *q = &SCpnt->device->request_queue;
361         struct request *req = &SCpnt->request;
362
363         ASSERT_LOCK(&q->queue_lock, 0);
364
365         /*
366          * If there are blocks left over at the end, set up the command
367          * to queue the remainder of them.
368          */
369         if (end_that_request_first(req, 1, sectors)) {
370                 if (!requeue)
371                         return SCpnt;
372
373                 /*
374                  * Bleah.  Leftovers again.  Stick the leftovers in
375                  * the front of the queue, and goose the queue again.
376                  */
377                 scsi_queue_next_request(q, SCpnt);
378                 return SCpnt;
379         }
380
381         /*
382          * This request is done.  If there is someone blocked waiting for this
383          * request, wake them up.
384          */
385         if (req->waiting)
386                 complete(req->waiting);
387
388         add_blkdev_randomness(MAJOR(req->rq_dev));
389
390         /*
391          * This will goose the queue request function at the end, so we don't
392          * need to worry about launching another command.
393          */
394         __scsi_release_command(SCpnt);
395
396         if (frequeue)
397                 scsi_queue_next_request(q, NULL);
398
399         return NULL;
400 }
401
402 /*
403  * Function:    scsi_end_request()
404  *
405  * Purpose:     Post-processing of completed commands called from interrupt
406  *              handler or a bottom-half handler.
407  *
408  * Arguments:   SCpnt    - command that is complete.
409  *              uptodate - 1 if I/O indicates success, 0 for I/O error.
410  *              sectors  - number of sectors we want to mark.
411  *
412  * Lock status: Assumed that lock is not held upon entry.
413  *
414  * Returns:     Nothing
415  *
416  * Notes:       This is called for block device requests in order to
417  *              mark some number of sectors as complete.
418  * 
419  *              We are guaranteeing that the request queue will be goosed
420  *              at some point during this call.
421  */
422 Scsi_Cmnd *scsi_end_request(Scsi_Cmnd * SCpnt, int uptodate, int sectors)
423 {
424         return __scsi_end_request(SCpnt, uptodate, sectors, 1, 1);
425 }
426
427 /*
428  * Function:    scsi_release_buffers()
429  *
430  * Purpose:     Completion processing for block device I/O requests.
431  *
432  * Arguments:   SCpnt   - command that we are bailing.
433  *
434  * Lock status: Assumed that no lock is held upon entry.
435  *
436  * Returns:     Nothing
437  *
438  * Notes:       In the event that an upper level driver rejects a
439  *              command, we must release resources allocated during
440  *              the __init_io() function.  Primarily this would involve
441  *              the scatter-gather table, and potentially any bounce
442  *              buffers.
443  */
444 static void scsi_release_buffers(Scsi_Cmnd * SCpnt)
445 {
446         struct request *req = &SCpnt->request;
447
448         ASSERT_LOCK(&SCpnt->device->request_queue.queue_lock, 0);
449
450         /*
451          * Free up any indirection buffers we allocated for DMA purposes. 
452          */
453         if (SCpnt->use_sg) {
454                 struct scatterlist *sgpnt;
455                 void **bbpnt;
456                 int i;
457
458                 sgpnt = (struct scatterlist *) SCpnt->request_buffer;
459                 bbpnt = SCpnt->bounce_buffers;
460
461                 if (bbpnt) {
462                         for (i = 0; i < SCpnt->use_sg; i++) {
463                                 if (bbpnt[i])
464                                         scsi_free(sgpnt[i].address, sgpnt[i].length);
465                         }
466                 }
467                 scsi_free(SCpnt->request_buffer, SCpnt->sglist_len);
468         } else {
469                 if (SCpnt->request_buffer != req->buffer)
470                         scsi_free(SCpnt->request_buffer,SCpnt->request_bufflen);
471         }
472
473         /*
474          * Zero these out.  They now point to freed memory, and it is
475          * dangerous to hang onto the pointers.
476          */
477         SCpnt->buffer  = NULL;
478         SCpnt->bufflen = 0;
479         SCpnt->request_buffer = NULL;
480         SCpnt->request_bufflen = 0;
481 }
482
483 /*
484  * Function:    scsi_io_completion()
485  *
486  * Purpose:     Completion processing for block device I/O requests.
487  *
488  * Arguments:   SCpnt   - command that is finished.
489  *
490  * Lock status: Assumed that no lock is held upon entry.
491  *
492  * Returns:     Nothing
493  *
494  * Notes:       This function is matched in terms of capabilities to
495  *              the function that created the scatter-gather list.
496  *              In other words, if there are no bounce buffers
497  *              (the normal case for most drivers), we don't need
498  *              the logic to deal with cleaning up afterwards.
499  */
500 void scsi_io_completion(Scsi_Cmnd * SCpnt, int good_sectors,
501                         int block_sectors)
502 {
503         int result = SCpnt->result;
504         int this_count = SCpnt->bufflen >> 9;
505         request_queue_t *q = &SCpnt->device->request_queue;
506         struct request *req = &SCpnt->request;
507
508         /*
509          * We must do one of several things here:
510          *
511          *      Call scsi_end_request.  This will finish off the specified
512          *      number of sectors.  If we are done, the command block will
513          *      be released, and the queue function will be goosed.  If we
514          *      are not done, then scsi_end_request will directly goose
515          *      the queue.
516          *
517          *      We can just use scsi_queue_next_request() here.  This
518          *      would be used if we just wanted to retry, for example.
519          *
520          */
521         ASSERT_LOCK(&q->queue_lock, 0);
522
523         /*
524          * Free up any indirection buffers we allocated for DMA purposes. 
525          * For the case of a READ, we need to copy the data out of the
526          * bounce buffer and into the real buffer.
527          */
528         if (SCpnt->use_sg) {
529                 struct scatterlist *sgpnt;
530                 void **bbpnt;
531                 int i;
532
533                 sgpnt = (struct scatterlist *) SCpnt->buffer;
534                 bbpnt = SCpnt->bounce_buffers;
535
536                 if (bbpnt) {
537                         for (i = 0; i < SCpnt->use_sg; i++) {
538                                 if (bbpnt[i]) {
539                                         if (rq_data_dir(req) == READ) {
540                                                 memcpy(bbpnt[i],
541                                                        sgpnt[i].address,
542                                                        sgpnt[i].length);
543                                         }
544                                         scsi_free(sgpnt[i].address, sgpnt[i].length);
545                                 }
546                         }
547                 }
548                 scsi_free(SCpnt->buffer, SCpnt->sglist_len);
549         } else {
550                 if (SCpnt->buffer != req->buffer) {
551                         if (rq_data_dir(req) == READ) {
552                                 unsigned long flags;
553                                 char *to = bio_kmap_irq(req->bio, &flags);
554
555                                 memcpy(to, SCpnt->buffer, SCpnt->bufflen);
556                                 bio_kunmap_irq(to, &flags);
557                         }
558                         scsi_free(SCpnt->buffer, SCpnt->bufflen);
559                 }
560         }
561
562         /*
563          * Zero these out.  They now point to freed memory, and it is
564          * dangerous to hang onto the pointers.
565          */
566         SCpnt->buffer  = NULL;
567         SCpnt->bufflen = 0;
568         SCpnt->request_buffer = NULL;
569         SCpnt->request_bufflen = 0;
570
571         /*
572          * Next deal with any sectors which we were able to correctly
573          * handle.
574          */
575         if (good_sectors > 0) {
576                 SCSI_LOG_HLCOMPLETE(1, printk("%ld sectors total, %d sectors done.\n",
577                                               req->nr_sectors, good_sectors));
578                 SCSI_LOG_HLCOMPLETE(1, printk("use_sg is %d\n ", SCpnt->use_sg));
579
580                 req->errors = 0;
581                 /*
582                  * If multiple sectors are requested in one buffer, then
583                  * they will have been finished off by the first command.
584                  * If not, then we have a multi-buffer command.
585                  *
586                  * If block_sectors != 0, it means we had a medium error
587                  * of some sort, and that we want to mark some number of
588                  * sectors as not uptodate.  Thus we want to inhibit
589                  * requeueing right here - we will requeue down below
590                  * when we handle the bad sectors.
591                  */
592                 SCpnt = __scsi_end_request(SCpnt, 
593                                            1, 
594                                            good_sectors,
595                                            result == 0,
596                                            1);
597
598                 /*
599                  * If the command completed without error, then either finish off the
600                  * rest of the command, or start a new one.
601                  */
602                 if (result == 0 || SCpnt == NULL ) {
603                         return;
604                 }
605         }
606         /*
607          * Now, if we were good little boys and girls, Santa left us a request
608          * sense buffer.  We can extract information from this, so we
609          * can choose a block to remap, etc.
610          */
611         if (driver_byte(result) != 0) {
612                 if (suggestion(result) == SUGGEST_REMAP) {
613 #ifdef REMAP
614                         /*
615                          * Not yet implemented.  A read will fail after being remapped,
616                          * a write will call the strategy routine again.
617                          */
618                         if (SCpnt->device->remap) {
619                                 result = 0;
620                         }
621 #endif
622                 }
623                 if ((SCpnt->sense_buffer[0] & 0x7f) == 0x70) {
624                         /*
625                          * If the device is in the process of becoming ready,
626                          * retry.
627                          */
628                         if (SCpnt->sense_buffer[12] == 0x04 &&
629                             SCpnt->sense_buffer[13] == 0x01) {
630                                 scsi_queue_next_request(q, SCpnt);
631                                 return;
632                         }
633                         if ((SCpnt->sense_buffer[2] & 0xf) == UNIT_ATTENTION) {
634                                 if (SCpnt->device->removable) {
635                                         /* detected disc change.  set a bit 
636                                          * and quietly refuse further access.
637                                          */
638                                         SCpnt->device->changed = 1;
639                                         SCpnt = scsi_end_request(SCpnt, 0, this_count);
640                                         return;
641                                 } else {
642                                         /*
643                                         * Must have been a power glitch, or a
644                                         * bus reset.  Could not have been a
645                                         * media change, so we just retry the
646                                         * request and see what happens.  
647                                         */
648                                         scsi_queue_next_request(q, SCpnt);
649                                         return;
650                                 }
651                         }
652                 }
653                 /* If we had an ILLEGAL REQUEST returned, then we may have
654                  * performed an unsupported command.  The only thing this should be
655                  * would be a ten byte read where only a six byte read was supported.
656                  * Also, on a system where READ CAPACITY failed, we have have read
657                  * past the end of the disk.
658                  */
659
660                 switch (SCpnt->sense_buffer[2]) {
661                 case ILLEGAL_REQUEST:
662                         if (SCpnt->device->ten) {
663                                 SCpnt->device->ten = 0;
664                                 /*
665                                  * This will cause a retry with a 6-byte
666                                  * command.
667                                  */
668                                 scsi_queue_next_request(q, SCpnt);
669                                 result = 0;
670                         } else {
671                                 SCpnt = scsi_end_request(SCpnt, 0, this_count);
672                                 return;
673                         }
674                         break;
675                 case NOT_READY:
676                         printk(KERN_INFO "Device %s not ready.\n",
677                                kdevname(req->rq_dev));
678                         SCpnt = scsi_end_request(SCpnt, 0, this_count);
679                         return;
680                         break;
681                 case MEDIUM_ERROR:
682                 case VOLUME_OVERFLOW:
683                         printk("scsi%d: ERROR on channel %d, id %d, lun %d, CDB: ",
684                                SCpnt->host->host_no, (int) SCpnt->channel,
685                                (int) SCpnt->target, (int) SCpnt->lun);
686                         print_command(SCpnt->cmnd);
687                         print_sense("sd", SCpnt);
688                         SCpnt = scsi_end_request(SCpnt, 0, block_sectors);
689                         return;
690                 default:
691                         break;
692                 }
693         }                       /* driver byte != 0 */
694         if (host_byte(result) == DID_RESET) {
695                 /*
696                  * Third party bus reset or reset for error
697                  * recovery reasons.  Just retry the request
698                  * and see what happens.  
699                  */
700                 scsi_queue_next_request(q, SCpnt);
701                 return;
702         }
703         if (result) {
704                 struct Scsi_Device_Template *STpnt;
705
706                 STpnt = scsi_get_request_dev(&SCpnt->request);
707                 printk("SCSI %s error : host %d channel %d id %d lun %d return code = %x\n",
708                        (STpnt ? STpnt->name : "device"),
709                        SCpnt->device->host->host_no,
710                        SCpnt->device->channel,
711                        SCpnt->device->id,
712                        SCpnt->device->lun, result);
713
714                 if (driver_byte(result) & DRIVER_SENSE)
715                         print_sense("sd", SCpnt);
716                 /*
717                  * Mark a single buffer as not uptodate.  Queue the remainder.
718                  * We sometimes get this cruft in the event that a medium error
719                  * isn't properly reported.
720                  */
721                 SCpnt = scsi_end_request(SCpnt, 0, req->current_nr_sectors);
722                 return;
723         }
724 }
725
726 /*
727  * Function:    scsi_get_request_dev()
728  *
729  * Purpose:     Find the upper-level driver that is responsible for this
730  *              request
731  *
732  * Arguments:   request   - I/O request we are preparing to queue.
733  *
734  * Lock status: No locks assumed to be held, but as it happens the
735  *              q->queue_lock is held when this is called.
736  *
737  * Returns:     Nothing
738  *
739  * Notes:       The requests in the request queue may have originated
740  *              from any block device driver.  We need to find out which
741  *              one so that we can later form the appropriate command.
742  */
743 struct Scsi_Device_Template *scsi_get_request_dev(struct request *req)
744 {
745         struct Scsi_Device_Template *spnt;
746         kdev_t dev = req->rq_dev;
747         int major = MAJOR(dev);
748
749         ASSERT_LOCK(&req->q->queue_lock, 1);
750
751         for (spnt = scsi_devicelist; spnt; spnt = spnt->next) {
752                 /*
753                  * Search for a block device driver that supports this
754                  * major.
755                  */
756                 if (spnt->blk && spnt->major == major) {
757                         return spnt;
758                 }
759                 /*
760                  * I am still not entirely satisfied with this solution,
761                  * but it is good enough for now.  Disks have a number of
762                  * major numbers associated with them, the primary
763                  * 8, which we test above, and a secondary range of 7
764                  * different consecutive major numbers.   If this ever
765                  * becomes insufficient, then we could add another function
766                  * to the structure, and generalize this completely.
767                  */
768                 if( spnt->min_major != 0 
769                     && spnt->max_major != 0
770                     && major >= spnt->min_major
771                     && major <= spnt->max_major )
772                 {
773                         return spnt;
774                 }
775         }
776         return NULL;
777 }
778
779 /*
780  * Function:    scsi_request_fn()
781  *
782  * Purpose:     Generic version of request function for SCSI hosts.
783  *
784  * Arguments:   q       - Pointer to actual queue.
785  *
786  * Returns:     Nothing
787  *
788  * Lock status: IO request lock assumed to be held when called.
789  *
790  * Notes:       The theory is that this function is something which individual
791  *              drivers could also supply if they wished to.   The problem
792  *              is that we have 30 some odd low-level drivers in the kernel
793  *              tree already, and it would be most difficult to retrofit
794  *              this crap into all of them.   Thus this function has the job
795  *              of acting as a generic queue manager for all of those existing
796  *              drivers.
797  */
798 void scsi_request_fn(request_queue_t * q)
799 {
800         struct request *req;
801         Scsi_Cmnd *SCpnt;
802         Scsi_Request *SRpnt;
803         Scsi_Device *SDpnt;
804         struct Scsi_Host *SHpnt;
805         struct Scsi_Device_Template *STpnt;
806
807         ASSERT_LOCK(&q->queue_lock, 1);
808
809         SDpnt = (Scsi_Device *) q->queuedata;
810         if (!SDpnt) {
811                 panic("Missing device");
812         }
813         SHpnt = SDpnt->host;
814
815         /*
816          * To start with, we keep looping until the queue is empty, or until
817          * the host is no longer able to accept any more requests.
818          */
819         while (1 == 1) {
820                 /*
821                  * Check this again - each time we loop through we will have
822                  * released the lock and grabbed it again, so each time
823                  * we need to check to see if the queue is plugged or not.
824                  */
825                 if (SHpnt->in_recovery || blk_queue_plugged(q))
826                         return;
827
828                 /*
829                  * If the device cannot accept another request, then quit.
830                  */
831                 if (SDpnt->device_blocked) {
832                         break;
833                 }
834                 if ((SHpnt->can_queue > 0 && (SHpnt->host_busy >= SHpnt->can_queue))
835                     || (SHpnt->host_blocked) 
836                     || (SHpnt->host_self_blocked)) {
837                         /*
838                          * If we are unable to process any commands at all for
839                          * this device, then we consider it to be starved.
840                          * What this means is that there are no outstanding
841                          * commands for this device and hence we need a
842                          * little help getting it started again
843                          * once the host isn't quite so busy.
844                          */
845                         if (SDpnt->device_busy == 0) {
846                                 SDpnt->starved = 1;
847                                 SHpnt->some_device_starved = 1;
848                         }
849                         break;
850                 } else {
851                         SDpnt->starved = 0;
852                 }
853
854                 /*
855                  * FIXME(eric)
856                  * I am not sure where the best place to do this is.  We need
857                  * to hook in a place where we are likely to come if in user
858                  * space.   Technically the error handling thread should be
859                  * doing this crap, but the error handler isn't used by
860                  * most hosts.
861                  */
862                 if (SDpnt->was_reset) {
863                         /*
864                          * We need to relock the door, but we might
865                          * be in an interrupt handler.  Only do this
866                          * from user space, since we do not want to
867                          * sleep from an interrupt.
868                          *
869                          * FIXME(eric) - have the error handler thread do
870                          * this work.
871                          */
872                         SDpnt->was_reset = 0;
873                         if (SDpnt->removable && !in_interrupt()) {
874                                 spin_unlock_irq(&q->queue_lock);
875                                 scsi_ioctl(SDpnt, SCSI_IOCTL_DOORLOCK, 0);
876                                 spin_lock_irq(&q->queue_lock);
877                                 continue;
878                         }
879                 }
880
881                 /*
882                  * If we couldn't find a request that could be queued, then we
883                  * can also quit.
884                  */
885                 if (blk_queue_empty(q))
886                         break;
887
888                 /*
889                  * get next queueable request.
890                  */
891                 req = elv_next_request(q);
892
893                 /*
894                  * Find the actual device driver associated with this command.
895                  * The SPECIAL requests are things like character device or
896                  * ioctls, which did not originate from ll_rw_blk.  Note that
897                  * the special field is also used to indicate the SCpnt for
898                  * the remainder of a partially fulfilled request that can 
899                  * come up when there is a medium error.  We have to treat
900                  * these two cases differently.  We differentiate by looking
901                  * at request.cmd, as this tells us the real story.
902                  */
903                 if (req->flags & REQ_SPECIAL) {
904                         STpnt = NULL;
905                         SCpnt = (Scsi_Cmnd *) req->special;
906                         SRpnt = (Scsi_Request *) req->special;
907
908                         if( SRpnt->sr_magic == SCSI_REQ_MAGIC ) {
909                                 SCpnt = scsi_allocate_device(SRpnt->sr_device, 
910                                                              FALSE, FALSE);
911                                 if (!SCpnt)
912                                         break;
913                                 scsi_init_cmd_from_req(SCpnt, SRpnt);
914                         }
915
916                 } else if (req->flags & REQ_CMD) {
917                         SRpnt = NULL;
918                         STpnt = scsi_get_request_dev(req);
919                         if (!STpnt) {
920                                 panic("Unable to find device associated with request");
921                         }
922                         /*
923                          * Now try and find a command block that we can use.
924                          */
925                         if (req->special) {
926                                 SCpnt = (Scsi_Cmnd *) req->special;
927                                 /*
928                                  * We need to recount the number of
929                                  * scatter-gather segments here - the
930                                  * normal case code assumes this to be
931                                  * correct, as it would be a performance
932                                  * loss to always recount.  Handling
933                                  * errors is always unusual, of course.
934                                  */
935                                 recount_segments(SCpnt);
936                         } else {
937                                 SCpnt = scsi_allocate_device(SDpnt, FALSE, FALSE);
938                         }
939                         /*
940                          * If so, we are ready to do something.  Bump the count
941                          * while the queue is locked and then break out of the
942                          * loop. Otherwise loop around and try another request.
943                          */
944                         if (!SCpnt)
945                                 break;
946                 } else {
947                         blk_dump_rq_flags(req, "SCSI bad req");
948                         break;
949                 }
950
951                 /*
952                  * Now bump the usage count for both the host and the
953                  * device.
954                  */
955                 SHpnt->host_busy++;
956                 SDpnt->device_busy++;
957
958                 /*
959                  * Finally, before we release the lock, we copy the
960                  * request to the command block, and remove the
961                  * request from the request list.   Note that we always
962                  * operate on the queue head - there is absolutely no
963                  * reason to search the list, because all of the commands
964                  * in this queue are for the same device.
965                  */
966                 blkdev_dequeue_request(req);
967
968                 if (req != &SCpnt->request && req != &SRpnt->sr_request ) {
969                         memcpy(&SCpnt->request, req, sizeof(struct request));
970
971                         /*
972                          * We have copied the data out of the request block -
973                          * it is now in a field in SCpnt.  Release the request
974                          * block.
975                          */
976                         blkdev_release_request(req);
977                 }
978                 /*
979                  * Now it is finally safe to release the lock.  We are
980                  * not going to noodle the request list until this
981                  * request has been queued and we loop back to queue
982                  * another.  
983                  */
984                 req = NULL;
985                 spin_unlock_irq(&q->queue_lock);
986
987                 if (SCpnt->request.flags & REQ_CMD) {
988                         /*
989                          * This will do a couple of things:
990                          *  1) Fill in the actual SCSI command.
991                          *  2) Fill in any other upper-level specific fields
992                          * (timeout).
993                          *
994                          * If this returns 0, it means that the request failed
995                          * (reading past end of disk, reading offline device,
996                          * etc).   This won't actually talk to the device, but
997                          * some kinds of consistency checking may cause the     
998                          * request to be rejected immediately.
999                          */
1000                         if (STpnt == NULL)
1001                                 STpnt = scsi_get_request_dev(&SCpnt->request);
1002
1003                         /* 
1004                          * This sets up the scatter-gather table (allocating if
1005                          * required).  Hosts that need bounce buffers will also
1006                          * get those allocated here.  
1007                          */
1008                         if (!SDpnt->scsi_init_io_fn(SCpnt)) {
1009                                 SCpnt = __scsi_end_request(SCpnt, 0, 
1010                                                            SCpnt->request.nr_sectors, 0, 0);
1011                                 if( SCpnt != NULL )
1012                                 {
1013                                         panic("Should not have leftover blocks\n");
1014                                 }
1015                                 spin_lock_irq(&q->queue_lock);
1016                                 SHpnt->host_busy--;
1017                                 SDpnt->device_busy--;
1018                                 continue;
1019                         }
1020                         /*
1021                          * Initialize the actual SCSI command for this request.
1022                          */
1023                         if (!STpnt->init_command(SCpnt)) {
1024                                 scsi_release_buffers(SCpnt);
1025                                 SCpnt = __scsi_end_request(SCpnt, 0, 
1026                                                            SCpnt->request.nr_sectors, 0, 0);
1027                                 if( SCpnt != NULL )
1028                                 {
1029                                         panic("Should not have leftover blocks\n");
1030                                 }
1031                                 spin_lock_irq(&q->queue_lock);
1032                                 SHpnt->host_busy--;
1033                                 SDpnt->device_busy--;
1034                                 continue;
1035                         }
1036                 }
1037                 /*
1038                  * Finally, initialize any error handling parameters, and set up
1039                  * the timers for timeouts.
1040                  */
1041                 scsi_init_cmd_errh(SCpnt);
1042
1043                 /*
1044                  * Dispatch the command to the low-level driver.
1045                  */
1046                 scsi_dispatch_cmd(SCpnt);
1047
1048                 /*
1049                  * Now we need to grab the lock again.  We are about to mess
1050                  * with the request queue and try to find another command.
1051                  */
1052                 spin_lock_irq(&q->queue_lock);
1053         }
1054 }
1055
1056 /*
1057  * Function:    scsi_block_requests()
1058  *
1059  * Purpose:     Utility function used by low-level drivers to prevent further
1060  *              commands from being queued to the device.
1061  *
1062  * Arguments:   SHpnt       - Host in question
1063  *
1064  * Returns:     Nothing
1065  *
1066  * Lock status: No locks are assumed held.
1067  *
1068  * Notes:       There is no timer nor any other means by which the requests
1069  *              get unblocked other than the low-level driver calling
1070  *              scsi_unblock_requests().
1071  */
1072 void scsi_block_requests(struct Scsi_Host * SHpnt)
1073 {
1074         SHpnt->host_self_blocked = TRUE;
1075 }
1076
1077 /*
1078  * Function:    scsi_unblock_requests()
1079  *
1080  * Purpose:     Utility function used by low-level drivers to allow further
1081  *              commands from being queued to the device.
1082  *
1083  * Arguments:   SHpnt       - Host in question
1084  *
1085  * Returns:     Nothing
1086  *
1087  * Lock status: No locks are assumed held.
1088  *
1089  * Notes:       There is no timer nor any other means by which the requests
1090  *              get unblocked other than the low-level driver calling
1091  *              scsi_unblock_requests().
1092  *
1093  *              This is done as an API function so that changes to the
1094  *              internals of the scsi mid-layer won't require wholesale
1095  *              changes to drivers that use this feature.
1096  */
1097 void scsi_unblock_requests(struct Scsi_Host * SHpnt)
1098 {
1099         Scsi_Device *SDloop;
1100
1101         SHpnt->host_self_blocked = FALSE;
1102         /* Now that we are unblocked, try to start the queues. */
1103         for (SDloop = SHpnt->host_queue; SDloop; SDloop = SDloop->next)
1104                 scsi_queue_next_request(&SDloop->request_queue, NULL);
1105 }
1106
1107 /*
1108  * Function:    scsi_report_bus_reset()
1109  *
1110  * Purpose:     Utility function used by low-level drivers to report that
1111  *              they have observed a bus reset on the bus being handled.
1112  *
1113  * Arguments:   SHpnt       - Host in question
1114  *              channel     - channel on which reset was observed.
1115  *
1116  * Returns:     Nothing
1117  *
1118  * Lock status: No locks are assumed held.
1119  *
1120  * Notes:       This only needs to be called if the reset is one which
1121  *              originates from an unknown location.  Resets originated
1122  *              by the mid-level itself don't need to call this, but there
1123  *              should be no harm.
1124  *
1125  *              The main purpose of this is to make sure that a CHECK_CONDITION
1126  *              is properly treated.
1127  */
1128 void scsi_report_bus_reset(struct Scsi_Host * SHpnt, int channel)
1129 {
1130         Scsi_Device *SDloop;
1131         for (SDloop = SHpnt->host_queue; SDloop; SDloop = SDloop->next) {
1132                 if (channel == SDloop->channel) {
1133                         SDloop->was_reset = 1;
1134                         SDloop->expecting_cc_ua = 1;
1135                 }
1136         }
1137 }
1138
1139 /*
1140  * FIXME(eric) - these are empty stubs for the moment.  I need to re-implement
1141  * host blocking from scratch. The theory is that hosts that wish to block
1142  * will register/deregister using these functions instead of the old way
1143  * of setting the wish_block flag.
1144  *
1145  * The details of the implementation remain to be settled, however the
1146  * stubs are here now so that the actual drivers will properly compile.
1147  */
1148 void scsi_register_blocked_host(struct Scsi_Host * SHpnt)
1149 {
1150 }
1151
1152 void scsi_deregister_blocked_host(struct Scsi_Host * SHpnt)
1153 {
1154 }