[XFRM] Documentaion: Fix error example at XFRMOUTSTATEMODEERROR.
[linux-2.6] / block / ll_rw_blk.c
1 /*
2  * Copyright (C) 1991, 1992 Linus Torvalds
3  * Copyright (C) 1994,      Karl Keyte: Added support for disk statistics
4  * Elevator latency, (C) 2000  Andrea Arcangeli <andrea@suse.de> SuSE
5  * Queue request tables / lock, selectable elevator, Jens Axboe <axboe@suse.de>
6  * kernel-doc documentation started by NeilBrown <neilb@cse.unsw.edu.au> -  July2000
7  * bio rewrite, highmem i/o, etc, Jens Axboe <axboe@suse.de> - may 2001
8  */
9
10 /*
11  * This handles all read/write requests to block devices
12  */
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/backing-dev.h>
16 #include <linux/bio.h>
17 #include <linux/blkdev.h>
18 #include <linux/highmem.h>
19 #include <linux/mm.h>
20 #include <linux/kernel_stat.h>
21 #include <linux/string.h>
22 #include <linux/init.h>
23 #include <linux/bootmem.h>      /* for max_pfn/max_low_pfn */
24 #include <linux/completion.h>
25 #include <linux/slab.h>
26 #include <linux/swap.h>
27 #include <linux/writeback.h>
28 #include <linux/task_io_accounting_ops.h>
29 #include <linux/interrupt.h>
30 #include <linux/cpu.h>
31 #include <linux/blktrace_api.h>
32 #include <linux/fault-inject.h>
33 #include <linux/scatterlist.h>
34
35 /*
36  * for max sense size
37  */
38 #include <scsi/scsi_cmnd.h>
39
40 static void blk_unplug_work(struct work_struct *work);
41 static void blk_unplug_timeout(unsigned long data);
42 static void drive_stat_acct(struct request *rq, int new_io);
43 static void init_request_from_bio(struct request *req, struct bio *bio);
44 static int __make_request(struct request_queue *q, struct bio *bio);
45 static struct io_context *current_io_context(gfp_t gfp_flags, int node);
46 static void blk_recalc_rq_segments(struct request *rq);
47 static void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
48                             struct bio *bio);
49
50 /*
51  * For the allocated request tables
52  */
53 static struct kmem_cache *request_cachep;
54
55 /*
56  * For queue allocation
57  */
58 static struct kmem_cache *requestq_cachep;
59
60 /*
61  * For io context allocations
62  */
63 static struct kmem_cache *iocontext_cachep;
64
65 /*
66  * Controlling structure to kblockd
67  */
68 static struct workqueue_struct *kblockd_workqueue;
69
70 unsigned long blk_max_low_pfn, blk_max_pfn;
71
72 EXPORT_SYMBOL(blk_max_low_pfn);
73 EXPORT_SYMBOL(blk_max_pfn);
74
75 static DEFINE_PER_CPU(struct list_head, blk_cpu_done);
76
77 /* Amount of time in which a process may batch requests */
78 #define BLK_BATCH_TIME  (HZ/50UL)
79
80 /* Number of requests a "batching" process may submit */
81 #define BLK_BATCH_REQ   32
82
83 /*
84  * Return the threshold (number of used requests) at which the queue is
85  * considered to be congested.  It include a little hysteresis to keep the
86  * context switch rate down.
87  */
88 static inline int queue_congestion_on_threshold(struct request_queue *q)
89 {
90         return q->nr_congestion_on;
91 }
92
93 /*
94  * The threshold at which a queue is considered to be uncongested
95  */
96 static inline int queue_congestion_off_threshold(struct request_queue *q)
97 {
98         return q->nr_congestion_off;
99 }
100
101 static void blk_queue_congestion_threshold(struct request_queue *q)
102 {
103         int nr;
104
105         nr = q->nr_requests - (q->nr_requests / 8) + 1;
106         if (nr > q->nr_requests)
107                 nr = q->nr_requests;
108         q->nr_congestion_on = nr;
109
110         nr = q->nr_requests - (q->nr_requests / 8) - (q->nr_requests / 16) - 1;
111         if (nr < 1)
112                 nr = 1;
113         q->nr_congestion_off = nr;
114 }
115
116 /**
117  * blk_get_backing_dev_info - get the address of a queue's backing_dev_info
118  * @bdev:       device
119  *
120  * Locates the passed device's request queue and returns the address of its
121  * backing_dev_info
122  *
123  * Will return NULL if the request queue cannot be located.
124  */
125 struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev)
126 {
127         struct backing_dev_info *ret = NULL;
128         struct request_queue *q = bdev_get_queue(bdev);
129
130         if (q)
131                 ret = &q->backing_dev_info;
132         return ret;
133 }
134 EXPORT_SYMBOL(blk_get_backing_dev_info);
135
136 /**
137  * blk_queue_prep_rq - set a prepare_request function for queue
138  * @q:          queue
139  * @pfn:        prepare_request function
140  *
141  * It's possible for a queue to register a prepare_request callback which
142  * is invoked before the request is handed to the request_fn. The goal of
143  * the function is to prepare a request for I/O, it can be used to build a
144  * cdb from the request data for instance.
145  *
146  */
147 void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn)
148 {
149         q->prep_rq_fn = pfn;
150 }
151
152 EXPORT_SYMBOL(blk_queue_prep_rq);
153
154 /**
155  * blk_queue_merge_bvec - set a merge_bvec function for queue
156  * @q:          queue
157  * @mbfn:       merge_bvec_fn
158  *
159  * Usually queues have static limitations on the max sectors or segments that
160  * we can put in a request. Stacking drivers may have some settings that
161  * are dynamic, and thus we have to query the queue whether it is ok to
162  * add a new bio_vec to a bio at a given offset or not. If the block device
163  * has such limitations, it needs to register a merge_bvec_fn to control
164  * the size of bio's sent to it. Note that a block device *must* allow a
165  * single page to be added to an empty bio. The block device driver may want
166  * to use the bio_split() function to deal with these bio's. By default
167  * no merge_bvec_fn is defined for a queue, and only the fixed limits are
168  * honored.
169  */
170 void blk_queue_merge_bvec(struct request_queue *q, merge_bvec_fn *mbfn)
171 {
172         q->merge_bvec_fn = mbfn;
173 }
174
175 EXPORT_SYMBOL(blk_queue_merge_bvec);
176
177 void blk_queue_softirq_done(struct request_queue *q, softirq_done_fn *fn)
178 {
179         q->softirq_done_fn = fn;
180 }
181
182 EXPORT_SYMBOL(blk_queue_softirq_done);
183
184 /**
185  * blk_queue_make_request - define an alternate make_request function for a device
186  * @q:  the request queue for the device to be affected
187  * @mfn: the alternate make_request function
188  *
189  * Description:
190  *    The normal way for &struct bios to be passed to a device
191  *    driver is for them to be collected into requests on a request
192  *    queue, and then to allow the device driver to select requests
193  *    off that queue when it is ready.  This works well for many block
194  *    devices. However some block devices (typically virtual devices
195  *    such as md or lvm) do not benefit from the processing on the
196  *    request queue, and are served best by having the requests passed
197  *    directly to them.  This can be achieved by providing a function
198  *    to blk_queue_make_request().
199  *
200  * Caveat:
201  *    The driver that does this *must* be able to deal appropriately
202  *    with buffers in "highmemory". This can be accomplished by either calling
203  *    __bio_kmap_atomic() to get a temporary kernel mapping, or by calling
204  *    blk_queue_bounce() to create a buffer in normal memory.
205  **/
206 void blk_queue_make_request(struct request_queue * q, make_request_fn * mfn)
207 {
208         /*
209          * set defaults
210          */
211         q->nr_requests = BLKDEV_MAX_RQ;
212         blk_queue_max_phys_segments(q, MAX_PHYS_SEGMENTS);
213         blk_queue_max_hw_segments(q, MAX_HW_SEGMENTS);
214         q->make_request_fn = mfn;
215         q->backing_dev_info.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
216         q->backing_dev_info.state = 0;
217         q->backing_dev_info.capabilities = BDI_CAP_MAP_COPY;
218         blk_queue_max_sectors(q, SAFE_MAX_SECTORS);
219         blk_queue_hardsect_size(q, 512);
220         blk_queue_dma_alignment(q, 511);
221         blk_queue_congestion_threshold(q);
222         q->nr_batching = BLK_BATCH_REQ;
223
224         q->unplug_thresh = 4;           /* hmm */
225         q->unplug_delay = (3 * HZ) / 1000;      /* 3 milliseconds */
226         if (q->unplug_delay == 0)
227                 q->unplug_delay = 1;
228
229         INIT_WORK(&q->unplug_work, blk_unplug_work);
230
231         q->unplug_timer.function = blk_unplug_timeout;
232         q->unplug_timer.data = (unsigned long)q;
233
234         /*
235          * by default assume old behaviour and bounce for any highmem page
236          */
237         blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
238 }
239
240 EXPORT_SYMBOL(blk_queue_make_request);
241
242 static void rq_init(struct request_queue *q, struct request *rq)
243 {
244         INIT_LIST_HEAD(&rq->queuelist);
245         INIT_LIST_HEAD(&rq->donelist);
246
247         rq->errors = 0;
248         rq->bio = rq->biotail = NULL;
249         INIT_HLIST_NODE(&rq->hash);
250         RB_CLEAR_NODE(&rq->rb_node);
251         rq->ioprio = 0;
252         rq->buffer = NULL;
253         rq->ref_count = 1;
254         rq->q = q;
255         rq->special = NULL;
256         rq->data_len = 0;
257         rq->data = NULL;
258         rq->nr_phys_segments = 0;
259         rq->sense = NULL;
260         rq->end_io = NULL;
261         rq->end_io_data = NULL;
262         rq->completion_data = NULL;
263         rq->next_rq = NULL;
264 }
265
266 /**
267  * blk_queue_ordered - does this queue support ordered writes
268  * @q:        the request queue
269  * @ordered:  one of QUEUE_ORDERED_*
270  * @prepare_flush_fn: rq setup helper for cache flush ordered writes
271  *
272  * Description:
273  *   For journalled file systems, doing ordered writes on a commit
274  *   block instead of explicitly doing wait_on_buffer (which is bad
275  *   for performance) can be a big win. Block drivers supporting this
276  *   feature should call this function and indicate so.
277  *
278  **/
279 int blk_queue_ordered(struct request_queue *q, unsigned ordered,
280                       prepare_flush_fn *prepare_flush_fn)
281 {
282         if (ordered & (QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH) &&
283             prepare_flush_fn == NULL) {
284                 printk(KERN_ERR "blk_queue_ordered: prepare_flush_fn required\n");
285                 return -EINVAL;
286         }
287
288         if (ordered != QUEUE_ORDERED_NONE &&
289             ordered != QUEUE_ORDERED_DRAIN &&
290             ordered != QUEUE_ORDERED_DRAIN_FLUSH &&
291             ordered != QUEUE_ORDERED_DRAIN_FUA &&
292             ordered != QUEUE_ORDERED_TAG &&
293             ordered != QUEUE_ORDERED_TAG_FLUSH &&
294             ordered != QUEUE_ORDERED_TAG_FUA) {
295                 printk(KERN_ERR "blk_queue_ordered: bad value %d\n", ordered);
296                 return -EINVAL;
297         }
298
299         q->ordered = ordered;
300         q->next_ordered = ordered;
301         q->prepare_flush_fn = prepare_flush_fn;
302
303         return 0;
304 }
305
306 EXPORT_SYMBOL(blk_queue_ordered);
307
308 /*
309  * Cache flushing for ordered writes handling
310  */
311 inline unsigned blk_ordered_cur_seq(struct request_queue *q)
312 {
313         if (!q->ordseq)
314                 return 0;
315         return 1 << ffz(q->ordseq);
316 }
317
318 unsigned blk_ordered_req_seq(struct request *rq)
319 {
320         struct request_queue *q = rq->q;
321
322         BUG_ON(q->ordseq == 0);
323
324         if (rq == &q->pre_flush_rq)
325                 return QUEUE_ORDSEQ_PREFLUSH;
326         if (rq == &q->bar_rq)
327                 return QUEUE_ORDSEQ_BAR;
328         if (rq == &q->post_flush_rq)
329                 return QUEUE_ORDSEQ_POSTFLUSH;
330
331         /*
332          * !fs requests don't need to follow barrier ordering.  Always
333          * put them at the front.  This fixes the following deadlock.
334          *
335          * http://thread.gmane.org/gmane.linux.kernel/537473
336          */
337         if (!blk_fs_request(rq))
338                 return QUEUE_ORDSEQ_DRAIN;
339
340         if ((rq->cmd_flags & REQ_ORDERED_COLOR) ==
341             (q->orig_bar_rq->cmd_flags & REQ_ORDERED_COLOR))
342                 return QUEUE_ORDSEQ_DRAIN;
343         else
344                 return QUEUE_ORDSEQ_DONE;
345 }
346
347 void blk_ordered_complete_seq(struct request_queue *q, unsigned seq, int error)
348 {
349         struct request *rq;
350
351         if (error && !q->orderr)
352                 q->orderr = error;
353
354         BUG_ON(q->ordseq & seq);
355         q->ordseq |= seq;
356
357         if (blk_ordered_cur_seq(q) != QUEUE_ORDSEQ_DONE)
358                 return;
359
360         /*
361          * Okay, sequence complete.
362          */
363         q->ordseq = 0;
364         rq = q->orig_bar_rq;
365
366         if (__blk_end_request(rq, q->orderr, blk_rq_bytes(rq)))
367                 BUG();
368 }
369
370 static void pre_flush_end_io(struct request *rq, int error)
371 {
372         elv_completed_request(rq->q, rq);
373         blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_PREFLUSH, error);
374 }
375
376 static void bar_end_io(struct request *rq, int error)
377 {
378         elv_completed_request(rq->q, rq);
379         blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_BAR, error);
380 }
381
382 static void post_flush_end_io(struct request *rq, int error)
383 {
384         elv_completed_request(rq->q, rq);
385         blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_POSTFLUSH, error);
386 }
387
388 static void queue_flush(struct request_queue *q, unsigned which)
389 {
390         struct request *rq;
391         rq_end_io_fn *end_io;
392
393         if (which == QUEUE_ORDERED_PREFLUSH) {
394                 rq = &q->pre_flush_rq;
395                 end_io = pre_flush_end_io;
396         } else {
397                 rq = &q->post_flush_rq;
398                 end_io = post_flush_end_io;
399         }
400
401         rq->cmd_flags = REQ_HARDBARRIER;
402         rq_init(q, rq);
403         rq->elevator_private = NULL;
404         rq->elevator_private2 = NULL;
405         rq->rq_disk = q->bar_rq.rq_disk;
406         rq->end_io = end_io;
407         q->prepare_flush_fn(q, rq);
408
409         elv_insert(q, rq, ELEVATOR_INSERT_FRONT);
410 }
411
412 static inline struct request *start_ordered(struct request_queue *q,
413                                             struct request *rq)
414 {
415         q->orderr = 0;
416         q->ordered = q->next_ordered;
417         q->ordseq |= QUEUE_ORDSEQ_STARTED;
418
419         /*
420          * Prep proxy barrier request.
421          */
422         blkdev_dequeue_request(rq);
423         q->orig_bar_rq = rq;
424         rq = &q->bar_rq;
425         rq->cmd_flags = 0;
426         rq_init(q, rq);
427         if (bio_data_dir(q->orig_bar_rq->bio) == WRITE)
428                 rq->cmd_flags |= REQ_RW;
429         if (q->ordered & QUEUE_ORDERED_FUA)
430                 rq->cmd_flags |= REQ_FUA;
431         rq->elevator_private = NULL;
432         rq->elevator_private2 = NULL;
433         init_request_from_bio(rq, q->orig_bar_rq->bio);
434         rq->end_io = bar_end_io;
435
436         /*
437          * Queue ordered sequence.  As we stack them at the head, we
438          * need to queue in reverse order.  Note that we rely on that
439          * no fs request uses ELEVATOR_INSERT_FRONT and thus no fs
440          * request gets inbetween ordered sequence. If this request is
441          * an empty barrier, we don't need to do a postflush ever since
442          * there will be no data written between the pre and post flush.
443          * Hence a single flush will suffice.
444          */
445         if ((q->ordered & QUEUE_ORDERED_POSTFLUSH) && !blk_empty_barrier(rq))
446                 queue_flush(q, QUEUE_ORDERED_POSTFLUSH);
447         else
448                 q->ordseq |= QUEUE_ORDSEQ_POSTFLUSH;
449
450         elv_insert(q, rq, ELEVATOR_INSERT_FRONT);
451
452         if (q->ordered & QUEUE_ORDERED_PREFLUSH) {
453                 queue_flush(q, QUEUE_ORDERED_PREFLUSH);
454                 rq = &q->pre_flush_rq;
455         } else
456                 q->ordseq |= QUEUE_ORDSEQ_PREFLUSH;
457
458         if ((q->ordered & QUEUE_ORDERED_TAG) || q->in_flight == 0)
459                 q->ordseq |= QUEUE_ORDSEQ_DRAIN;
460         else
461                 rq = NULL;
462
463         return rq;
464 }
465
466 int blk_do_ordered(struct request_queue *q, struct request **rqp)
467 {
468         struct request *rq = *rqp;
469         const int is_barrier = blk_fs_request(rq) && blk_barrier_rq(rq);
470
471         if (!q->ordseq) {
472                 if (!is_barrier)
473                         return 1;
474
475                 if (q->next_ordered != QUEUE_ORDERED_NONE) {
476                         *rqp = start_ordered(q, rq);
477                         return 1;
478                 } else {
479                         /*
480                          * This can happen when the queue switches to
481                          * ORDERED_NONE while this request is on it.
482                          */
483                         blkdev_dequeue_request(rq);
484                         if (__blk_end_request(rq, -EOPNOTSUPP,
485                                               blk_rq_bytes(rq)))
486                                 BUG();
487                         *rqp = NULL;
488                         return 0;
489                 }
490         }
491
492         /*
493          * Ordered sequence in progress
494          */
495
496         /* Special requests are not subject to ordering rules. */
497         if (!blk_fs_request(rq) &&
498             rq != &q->pre_flush_rq && rq != &q->post_flush_rq)
499                 return 1;
500
501         if (q->ordered & QUEUE_ORDERED_TAG) {
502                 /* Ordered by tag.  Blocking the next barrier is enough. */
503                 if (is_barrier && rq != &q->bar_rq)
504                         *rqp = NULL;
505         } else {
506                 /* Ordered by draining.  Wait for turn. */
507                 WARN_ON(blk_ordered_req_seq(rq) < blk_ordered_cur_seq(q));
508                 if (blk_ordered_req_seq(rq) > blk_ordered_cur_seq(q))
509                         *rqp = NULL;
510         }
511
512         return 1;
513 }
514
515 static void req_bio_endio(struct request *rq, struct bio *bio,
516                           unsigned int nbytes, int error)
517 {
518         struct request_queue *q = rq->q;
519
520         if (&q->bar_rq != rq) {
521                 if (error)
522                         clear_bit(BIO_UPTODATE, &bio->bi_flags);
523                 else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
524                         error = -EIO;
525
526                 if (unlikely(nbytes > bio->bi_size)) {
527                         printk("%s: want %u bytes done, only %u left\n",
528                                __FUNCTION__, nbytes, bio->bi_size);
529                         nbytes = bio->bi_size;
530                 }
531
532                 bio->bi_size -= nbytes;
533                 bio->bi_sector += (nbytes >> 9);
534                 if (bio->bi_size == 0)
535                         bio_endio(bio, error);
536         } else {
537
538                 /*
539                  * Okay, this is the barrier request in progress, just
540                  * record the error;
541                  */
542                 if (error && !q->orderr)
543                         q->orderr = error;
544         }
545 }
546
547 /**
548  * blk_queue_bounce_limit - set bounce buffer limit for queue
549  * @q:  the request queue for the device
550  * @dma_addr:   bus address limit
551  *
552  * Description:
553  *    Different hardware can have different requirements as to what pages
554  *    it can do I/O directly to. A low level driver can call
555  *    blk_queue_bounce_limit to have lower memory pages allocated as bounce
556  *    buffers for doing I/O to pages residing above @page.
557  **/
558 void blk_queue_bounce_limit(struct request_queue *q, u64 dma_addr)
559 {
560         unsigned long bounce_pfn = dma_addr >> PAGE_SHIFT;
561         int dma = 0;
562
563         q->bounce_gfp = GFP_NOIO;
564 #if BITS_PER_LONG == 64
565         /* Assume anything <= 4GB can be handled by IOMMU.
566            Actually some IOMMUs can handle everything, but I don't
567            know of a way to test this here. */
568         if (bounce_pfn < (min_t(u64,0xffffffff,BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
569                 dma = 1;
570         q->bounce_pfn = max_low_pfn;
571 #else
572         if (bounce_pfn < blk_max_low_pfn)
573                 dma = 1;
574         q->bounce_pfn = bounce_pfn;
575 #endif
576         if (dma) {
577                 init_emergency_isa_pool();
578                 q->bounce_gfp = GFP_NOIO | GFP_DMA;
579                 q->bounce_pfn = bounce_pfn;
580         }
581 }
582
583 EXPORT_SYMBOL(blk_queue_bounce_limit);
584
585 /**
586  * blk_queue_max_sectors - set max sectors for a request for this queue
587  * @q:  the request queue for the device
588  * @max_sectors:  max sectors in the usual 512b unit
589  *
590  * Description:
591  *    Enables a low level driver to set an upper limit on the size of
592  *    received requests.
593  **/
594 void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors)
595 {
596         if ((max_sectors << 9) < PAGE_CACHE_SIZE) {
597                 max_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
598                 printk("%s: set to minimum %d\n", __FUNCTION__, max_sectors);
599         }
600
601         if (BLK_DEF_MAX_SECTORS > max_sectors)
602                 q->max_hw_sectors = q->max_sectors = max_sectors;
603         else {
604                 q->max_sectors = BLK_DEF_MAX_SECTORS;
605                 q->max_hw_sectors = max_sectors;
606         }
607 }
608
609 EXPORT_SYMBOL(blk_queue_max_sectors);
610
611 /**
612  * blk_queue_max_phys_segments - set max phys segments for a request for this queue
613  * @q:  the request queue for the device
614  * @max_segments:  max number of segments
615  *
616  * Description:
617  *    Enables a low level driver to set an upper limit on the number of
618  *    physical data segments in a request.  This would be the largest sized
619  *    scatter list the driver could handle.
620  **/
621 void blk_queue_max_phys_segments(struct request_queue *q,
622                                  unsigned short max_segments)
623 {
624         if (!max_segments) {
625                 max_segments = 1;
626                 printk("%s: set to minimum %d\n", __FUNCTION__, max_segments);
627         }
628
629         q->max_phys_segments = max_segments;
630 }
631
632 EXPORT_SYMBOL(blk_queue_max_phys_segments);
633
634 /**
635  * blk_queue_max_hw_segments - set max hw segments for a request for this queue
636  * @q:  the request queue for the device
637  * @max_segments:  max number of segments
638  *
639  * Description:
640  *    Enables a low level driver to set an upper limit on the number of
641  *    hw data segments in a request.  This would be the largest number of
642  *    address/length pairs the host adapter can actually give as once
643  *    to the device.
644  **/
645 void blk_queue_max_hw_segments(struct request_queue *q,
646                                unsigned short max_segments)
647 {
648         if (!max_segments) {
649                 max_segments = 1;
650                 printk("%s: set to minimum %d\n", __FUNCTION__, max_segments);
651         }
652
653         q->max_hw_segments = max_segments;
654 }
655
656 EXPORT_SYMBOL(blk_queue_max_hw_segments);
657
658 /**
659  * blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
660  * @q:  the request queue for the device
661  * @max_size:  max size of segment in bytes
662  *
663  * Description:
664  *    Enables a low level driver to set an upper limit on the size of a
665  *    coalesced segment
666  **/
667 void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
668 {
669         if (max_size < PAGE_CACHE_SIZE) {
670                 max_size = PAGE_CACHE_SIZE;
671                 printk("%s: set to minimum %d\n", __FUNCTION__, max_size);
672         }
673
674         q->max_segment_size = max_size;
675 }
676
677 EXPORT_SYMBOL(blk_queue_max_segment_size);
678
679 /**
680  * blk_queue_hardsect_size - set hardware sector size for the queue
681  * @q:  the request queue for the device
682  * @size:  the hardware sector size, in bytes
683  *
684  * Description:
685  *   This should typically be set to the lowest possible sector size
686  *   that the hardware can operate on (possible without reverting to
687  *   even internal read-modify-write operations). Usually the default
688  *   of 512 covers most hardware.
689  **/
690 void blk_queue_hardsect_size(struct request_queue *q, unsigned short size)
691 {
692         q->hardsect_size = size;
693 }
694
695 EXPORT_SYMBOL(blk_queue_hardsect_size);
696
697 /*
698  * Returns the minimum that is _not_ zero, unless both are zero.
699  */
700 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
701
702 /**
703  * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers
704  * @t:  the stacking driver (top)
705  * @b:  the underlying device (bottom)
706  **/
707 void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
708 {
709         /* zero is "infinity" */
710         t->max_sectors = min_not_zero(t->max_sectors,b->max_sectors);
711         t->max_hw_sectors = min_not_zero(t->max_hw_sectors,b->max_hw_sectors);
712
713         t->max_phys_segments = min(t->max_phys_segments,b->max_phys_segments);
714         t->max_hw_segments = min(t->max_hw_segments,b->max_hw_segments);
715         t->max_segment_size = min(t->max_segment_size,b->max_segment_size);
716         t->hardsect_size = max(t->hardsect_size,b->hardsect_size);
717         if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags))
718                 clear_bit(QUEUE_FLAG_CLUSTER, &t->queue_flags);
719 }
720
721 EXPORT_SYMBOL(blk_queue_stack_limits);
722
723 /**
724  * blk_queue_dma_drain - Set up a drain buffer for excess dma.
725  *
726  * @q:  the request queue for the device
727  * @buf:        physically contiguous buffer
728  * @size:       size of the buffer in bytes
729  *
730  * Some devices have excess DMA problems and can't simply discard (or
731  * zero fill) the unwanted piece of the transfer.  They have to have a
732  * real area of memory to transfer it into.  The use case for this is
733  * ATAPI devices in DMA mode.  If the packet command causes a transfer
734  * bigger than the transfer size some HBAs will lock up if there
735  * aren't DMA elements to contain the excess transfer.  What this API
736  * does is adjust the queue so that the buf is always appended
737  * silently to the scatterlist.
738  *
739  * Note: This routine adjusts max_hw_segments to make room for
740  * appending the drain buffer.  If you call
741  * blk_queue_max_hw_segments() or blk_queue_max_phys_segments() after
742  * calling this routine, you must set the limit to one fewer than your
743  * device can support otherwise there won't be room for the drain
744  * buffer.
745  */
746 int blk_queue_dma_drain(struct request_queue *q, void *buf,
747                                 unsigned int size)
748 {
749         if (q->max_hw_segments < 2 || q->max_phys_segments < 2)
750                 return -EINVAL;
751         /* make room for appending the drain */
752         --q->max_hw_segments;
753         --q->max_phys_segments;
754         q->dma_drain_buffer = buf;
755         q->dma_drain_size = size;
756
757         return 0;
758 }
759
760 EXPORT_SYMBOL_GPL(blk_queue_dma_drain);
761
762 /**
763  * blk_queue_segment_boundary - set boundary rules for segment merging
764  * @q:  the request queue for the device
765  * @mask:  the memory boundary mask
766  **/
767 void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
768 {
769         if (mask < PAGE_CACHE_SIZE - 1) {
770                 mask = PAGE_CACHE_SIZE - 1;
771                 printk("%s: set to minimum %lx\n", __FUNCTION__, mask);
772         }
773
774         q->seg_boundary_mask = mask;
775 }
776
777 EXPORT_SYMBOL(blk_queue_segment_boundary);
778
779 /**
780  * blk_queue_dma_alignment - set dma length and memory alignment
781  * @q:     the request queue for the device
782  * @mask:  alignment mask
783  *
784  * description:
785  *    set required memory and length aligment for direct dma transactions.
786  *    this is used when buiding direct io requests for the queue.
787  *
788  **/
789 void blk_queue_dma_alignment(struct request_queue *q, int mask)
790 {
791         q->dma_alignment = mask;
792 }
793
794 EXPORT_SYMBOL(blk_queue_dma_alignment);
795
796 /**
797  * blk_queue_update_dma_alignment - update dma length and memory alignment
798  * @q:     the request queue for the device
799  * @mask:  alignment mask
800  *
801  * description:
802  *    update required memory and length aligment for direct dma transactions.
803  *    If the requested alignment is larger than the current alignment, then
804  *    the current queue alignment is updated to the new value, otherwise it
805  *    is left alone.  The design of this is to allow multiple objects
806  *    (driver, device, transport etc) to set their respective
807  *    alignments without having them interfere.
808  *
809  **/
810 void blk_queue_update_dma_alignment(struct request_queue *q, int mask)
811 {
812         BUG_ON(mask > PAGE_SIZE);
813
814         if (mask > q->dma_alignment)
815                 q->dma_alignment = mask;
816 }
817
818 EXPORT_SYMBOL(blk_queue_update_dma_alignment);
819
820 /**
821  * blk_queue_find_tag - find a request by its tag and queue
822  * @q:   The request queue for the device
823  * @tag: The tag of the request
824  *
825  * Notes:
826  *    Should be used when a device returns a tag and you want to match
827  *    it with a request.
828  *
829  *    no locks need be held.
830  **/
831 struct request *blk_queue_find_tag(struct request_queue *q, int tag)
832 {
833         return blk_map_queue_find_tag(q->queue_tags, tag);
834 }
835
836 EXPORT_SYMBOL(blk_queue_find_tag);
837
838 /**
839  * __blk_free_tags - release a given set of tag maintenance info
840  * @bqt:        the tag map to free
841  *
842  * Tries to free the specified @bqt@.  Returns true if it was
843  * actually freed and false if there are still references using it
844  */
845 static int __blk_free_tags(struct blk_queue_tag *bqt)
846 {
847         int retval;
848
849         retval = atomic_dec_and_test(&bqt->refcnt);
850         if (retval) {
851                 BUG_ON(bqt->busy);
852
853                 kfree(bqt->tag_index);
854                 bqt->tag_index = NULL;
855
856                 kfree(bqt->tag_map);
857                 bqt->tag_map = NULL;
858
859                 kfree(bqt);
860
861         }
862
863         return retval;
864 }
865
866 /**
867  * __blk_queue_free_tags - release tag maintenance info
868  * @q:  the request queue for the device
869  *
870  *  Notes:
871  *    blk_cleanup_queue() will take care of calling this function, if tagging
872  *    has been used. So there's no need to call this directly.
873  **/
874 static void __blk_queue_free_tags(struct request_queue *q)
875 {
876         struct blk_queue_tag *bqt = q->queue_tags;
877
878         if (!bqt)
879                 return;
880
881         __blk_free_tags(bqt);
882
883         q->queue_tags = NULL;
884         q->queue_flags &= ~(1 << QUEUE_FLAG_QUEUED);
885 }
886
887
888 /**
889  * blk_free_tags - release a given set of tag maintenance info
890  * @bqt:        the tag map to free
891  *
892  * For externally managed @bqt@ frees the map.  Callers of this
893  * function must guarantee to have released all the queues that
894  * might have been using this tag map.
895  */
896 void blk_free_tags(struct blk_queue_tag *bqt)
897 {
898         if (unlikely(!__blk_free_tags(bqt)))
899                 BUG();
900 }
901 EXPORT_SYMBOL(blk_free_tags);
902
903 /**
904  * blk_queue_free_tags - release tag maintenance info
905  * @q:  the request queue for the device
906  *
907  *  Notes:
908  *      This is used to disabled tagged queuing to a device, yet leave
909  *      queue in function.
910  **/
911 void blk_queue_free_tags(struct request_queue *q)
912 {
913         clear_bit(QUEUE_FLAG_QUEUED, &q->queue_flags);
914 }
915
916 EXPORT_SYMBOL(blk_queue_free_tags);
917
918 static int
919 init_tag_map(struct request_queue *q, struct blk_queue_tag *tags, int depth)
920 {
921         struct request **tag_index;
922         unsigned long *tag_map;
923         int nr_ulongs;
924
925         if (q && depth > q->nr_requests * 2) {
926                 depth = q->nr_requests * 2;
927                 printk(KERN_ERR "%s: adjusted depth to %d\n",
928                                 __FUNCTION__, depth);
929         }
930
931         tag_index = kzalloc(depth * sizeof(struct request *), GFP_ATOMIC);
932         if (!tag_index)
933                 goto fail;
934
935         nr_ulongs = ALIGN(depth, BITS_PER_LONG) / BITS_PER_LONG;
936         tag_map = kzalloc(nr_ulongs * sizeof(unsigned long), GFP_ATOMIC);
937         if (!tag_map)
938                 goto fail;
939
940         tags->real_max_depth = depth;
941         tags->max_depth = depth;
942         tags->tag_index = tag_index;
943         tags->tag_map = tag_map;
944
945         return 0;
946 fail:
947         kfree(tag_index);
948         return -ENOMEM;
949 }
950
951 static struct blk_queue_tag *__blk_queue_init_tags(struct request_queue *q,
952                                                    int depth)
953 {
954         struct blk_queue_tag *tags;
955
956         tags = kmalloc(sizeof(struct blk_queue_tag), GFP_ATOMIC);
957         if (!tags)
958                 goto fail;
959
960         if (init_tag_map(q, tags, depth))
961                 goto fail;
962
963         tags->busy = 0;
964         atomic_set(&tags->refcnt, 1);
965         return tags;
966 fail:
967         kfree(tags);
968         return NULL;
969 }
970
971 /**
972  * blk_init_tags - initialize the tag info for an external tag map
973  * @depth:      the maximum queue depth supported
974  * @tags: the tag to use
975  **/
976 struct blk_queue_tag *blk_init_tags(int depth)
977 {
978         return __blk_queue_init_tags(NULL, depth);
979 }
980 EXPORT_SYMBOL(blk_init_tags);
981
982 /**
983  * blk_queue_init_tags - initialize the queue tag info
984  * @q:  the request queue for the device
985  * @depth:  the maximum queue depth supported
986  * @tags: the tag to use
987  **/
988 int blk_queue_init_tags(struct request_queue *q, int depth,
989                         struct blk_queue_tag *tags)
990 {
991         int rc;
992
993         BUG_ON(tags && q->queue_tags && tags != q->queue_tags);
994
995         if (!tags && !q->queue_tags) {
996                 tags = __blk_queue_init_tags(q, depth);
997
998                 if (!tags)
999                         goto fail;
1000         } else if (q->queue_tags) {
1001                 if ((rc = blk_queue_resize_tags(q, depth)))
1002                         return rc;
1003                 set_bit(QUEUE_FLAG_QUEUED, &q->queue_flags);
1004                 return 0;
1005         } else
1006                 atomic_inc(&tags->refcnt);
1007
1008         /*
1009          * assign it, all done
1010          */
1011         q->queue_tags = tags;
1012         q->queue_flags |= (1 << QUEUE_FLAG_QUEUED);
1013         INIT_LIST_HEAD(&q->tag_busy_list);
1014         return 0;
1015 fail:
1016         kfree(tags);
1017         return -ENOMEM;
1018 }
1019
1020 EXPORT_SYMBOL(blk_queue_init_tags);
1021
1022 /**
1023  * blk_queue_resize_tags - change the queueing depth
1024  * @q:  the request queue for the device
1025  * @new_depth: the new max command queueing depth
1026  *
1027  *  Notes:
1028  *    Must be called with the queue lock held.
1029  **/
1030 int blk_queue_resize_tags(struct request_queue *q, int new_depth)
1031 {
1032         struct blk_queue_tag *bqt = q->queue_tags;
1033         struct request **tag_index;
1034         unsigned long *tag_map;
1035         int max_depth, nr_ulongs;
1036
1037         if (!bqt)
1038                 return -ENXIO;
1039
1040         /*
1041          * if we already have large enough real_max_depth.  just
1042          * adjust max_depth.  *NOTE* as requests with tag value
1043          * between new_depth and real_max_depth can be in-flight, tag
1044          * map can not be shrunk blindly here.
1045          */
1046         if (new_depth <= bqt->real_max_depth) {
1047                 bqt->max_depth = new_depth;
1048                 return 0;
1049         }
1050
1051         /*
1052          * Currently cannot replace a shared tag map with a new
1053          * one, so error out if this is the case
1054          */
1055         if (atomic_read(&bqt->refcnt) != 1)
1056                 return -EBUSY;
1057
1058         /*
1059          * save the old state info, so we can copy it back
1060          */
1061         tag_index = bqt->tag_index;
1062         tag_map = bqt->tag_map;
1063         max_depth = bqt->real_max_depth;
1064
1065         if (init_tag_map(q, bqt, new_depth))
1066                 return -ENOMEM;
1067
1068         memcpy(bqt->tag_index, tag_index, max_depth * sizeof(struct request *));
1069         nr_ulongs = ALIGN(max_depth, BITS_PER_LONG) / BITS_PER_LONG;
1070         memcpy(bqt->tag_map, tag_map, nr_ulongs * sizeof(unsigned long));
1071
1072         kfree(tag_index);
1073         kfree(tag_map);
1074         return 0;
1075 }
1076
1077 EXPORT_SYMBOL(blk_queue_resize_tags);
1078
1079 /**
1080  * blk_queue_end_tag - end tag operations for a request
1081  * @q:  the request queue for the device
1082  * @rq: the request that has completed
1083  *
1084  *  Description:
1085  *    Typically called when end_that_request_first() returns 0, meaning
1086  *    all transfers have been done for a request. It's important to call
1087  *    this function before end_that_request_last(), as that will put the
1088  *    request back on the free list thus corrupting the internal tag list.
1089  *
1090  *  Notes:
1091  *   queue lock must be held.
1092  **/
1093 void blk_queue_end_tag(struct request_queue *q, struct request *rq)
1094 {
1095         struct blk_queue_tag *bqt = q->queue_tags;
1096         int tag = rq->tag;
1097
1098         BUG_ON(tag == -1);
1099
1100         if (unlikely(tag >= bqt->real_max_depth))
1101                 /*
1102                  * This can happen after tag depth has been reduced.
1103                  * FIXME: how about a warning or info message here?
1104                  */
1105                 return;
1106
1107         list_del_init(&rq->queuelist);
1108         rq->cmd_flags &= ~REQ_QUEUED;
1109         rq->tag = -1;
1110
1111         if (unlikely(bqt->tag_index[tag] == NULL))
1112                 printk(KERN_ERR "%s: tag %d is missing\n",
1113                        __FUNCTION__, tag);
1114
1115         bqt->tag_index[tag] = NULL;
1116
1117         if (unlikely(!test_bit(tag, bqt->tag_map))) {
1118                 printk(KERN_ERR "%s: attempt to clear non-busy tag (%d)\n",
1119                        __FUNCTION__, tag);
1120                 return;
1121         }
1122         /*
1123          * The tag_map bit acts as a lock for tag_index[bit], so we need
1124          * unlock memory barrier semantics.
1125          */
1126         clear_bit_unlock(tag, bqt->tag_map);
1127         bqt->busy--;
1128 }
1129
1130 EXPORT_SYMBOL(blk_queue_end_tag);
1131
1132 /**
1133  * blk_queue_start_tag - find a free tag and assign it
1134  * @q:  the request queue for the device
1135  * @rq:  the block request that needs tagging
1136  *
1137  *  Description:
1138  *    This can either be used as a stand-alone helper, or possibly be
1139  *    assigned as the queue &prep_rq_fn (in which case &struct request
1140  *    automagically gets a tag assigned). Note that this function
1141  *    assumes that any type of request can be queued! if this is not
1142  *    true for your device, you must check the request type before
1143  *    calling this function.  The request will also be removed from
1144  *    the request queue, so it's the drivers responsibility to readd
1145  *    it if it should need to be restarted for some reason.
1146  *
1147  *  Notes:
1148  *   queue lock must be held.
1149  **/
1150 int blk_queue_start_tag(struct request_queue *q, struct request *rq)
1151 {
1152         struct blk_queue_tag *bqt = q->queue_tags;
1153         int tag;
1154
1155         if (unlikely((rq->cmd_flags & REQ_QUEUED))) {
1156                 printk(KERN_ERR 
1157                        "%s: request %p for device [%s] already tagged %d",
1158                        __FUNCTION__, rq,
1159                        rq->rq_disk ? rq->rq_disk->disk_name : "?", rq->tag);
1160                 BUG();
1161         }
1162
1163         /*
1164          * Protect against shared tag maps, as we may not have exclusive
1165          * access to the tag map.
1166          */
1167         do {
1168                 tag = find_first_zero_bit(bqt->tag_map, bqt->max_depth);
1169                 if (tag >= bqt->max_depth)
1170                         return 1;
1171
1172         } while (test_and_set_bit_lock(tag, bqt->tag_map));
1173         /*
1174          * We need lock ordering semantics given by test_and_set_bit_lock.
1175          * See blk_queue_end_tag for details.
1176          */
1177
1178         rq->cmd_flags |= REQ_QUEUED;
1179         rq->tag = tag;
1180         bqt->tag_index[tag] = rq;
1181         blkdev_dequeue_request(rq);
1182         list_add(&rq->queuelist, &q->tag_busy_list);
1183         bqt->busy++;
1184         return 0;
1185 }
1186
1187 EXPORT_SYMBOL(blk_queue_start_tag);
1188
1189 /**
1190  * blk_queue_invalidate_tags - invalidate all pending tags
1191  * @q:  the request queue for the device
1192  *
1193  *  Description:
1194  *   Hardware conditions may dictate a need to stop all pending requests.
1195  *   In this case, we will safely clear the block side of the tag queue and
1196  *   readd all requests to the request queue in the right order.
1197  *
1198  *  Notes:
1199  *   queue lock must be held.
1200  **/
1201 void blk_queue_invalidate_tags(struct request_queue *q)
1202 {
1203         struct list_head *tmp, *n;
1204
1205         list_for_each_safe(tmp, n, &q->tag_busy_list)
1206                 blk_requeue_request(q, list_entry_rq(tmp));
1207 }
1208
1209 EXPORT_SYMBOL(blk_queue_invalidate_tags);
1210
1211 void blk_dump_rq_flags(struct request *rq, char *msg)
1212 {
1213         int bit;
1214
1215         printk("%s: dev %s: type=%x, flags=%x\n", msg,
1216                 rq->rq_disk ? rq->rq_disk->disk_name : "?", rq->cmd_type,
1217                 rq->cmd_flags);
1218
1219         printk("\nsector %llu, nr/cnr %lu/%u\n", (unsigned long long)rq->sector,
1220                                                        rq->nr_sectors,
1221                                                        rq->current_nr_sectors);
1222         printk("bio %p, biotail %p, buffer %p, data %p, len %u\n", rq->bio, rq->biotail, rq->buffer, rq->data, rq->data_len);
1223
1224         if (blk_pc_request(rq)) {
1225                 printk("cdb: ");
1226                 for (bit = 0; bit < sizeof(rq->cmd); bit++)
1227                         printk("%02x ", rq->cmd[bit]);
1228                 printk("\n");
1229         }
1230 }
1231
1232 EXPORT_SYMBOL(blk_dump_rq_flags);
1233
1234 void blk_recount_segments(struct request_queue *q, struct bio *bio)
1235 {
1236         struct request rq;
1237         struct bio *nxt = bio->bi_next;
1238         rq.q = q;
1239         rq.bio = rq.biotail = bio;
1240         bio->bi_next = NULL;
1241         blk_recalc_rq_segments(&rq);
1242         bio->bi_next = nxt;
1243         bio->bi_phys_segments = rq.nr_phys_segments;
1244         bio->bi_hw_segments = rq.nr_hw_segments;
1245         bio->bi_flags |= (1 << BIO_SEG_VALID);
1246 }
1247 EXPORT_SYMBOL(blk_recount_segments);
1248
1249 static void blk_recalc_rq_segments(struct request *rq)
1250 {
1251         int nr_phys_segs;
1252         int nr_hw_segs;
1253         unsigned int phys_size;
1254         unsigned int hw_size;
1255         struct bio_vec *bv, *bvprv = NULL;
1256         int seg_size;
1257         int hw_seg_size;
1258         int cluster;
1259         struct req_iterator iter;
1260         int high, highprv = 1;
1261         struct request_queue *q = rq->q;
1262
1263         if (!rq->bio)
1264                 return;
1265
1266         cluster = q->queue_flags & (1 << QUEUE_FLAG_CLUSTER);
1267         hw_seg_size = seg_size = 0;
1268         phys_size = hw_size = nr_phys_segs = nr_hw_segs = 0;
1269         rq_for_each_segment(bv, rq, iter) {
1270                 /*
1271                  * the trick here is making sure that a high page is never
1272                  * considered part of another segment, since that might
1273                  * change with the bounce page.
1274                  */
1275                 high = page_to_pfn(bv->bv_page) > q->bounce_pfn;
1276                 if (high || highprv)
1277                         goto new_hw_segment;
1278                 if (cluster) {
1279                         if (seg_size + bv->bv_len > q->max_segment_size)
1280                                 goto new_segment;
1281                         if (!BIOVEC_PHYS_MERGEABLE(bvprv, bv))
1282                                 goto new_segment;
1283                         if (!BIOVEC_SEG_BOUNDARY(q, bvprv, bv))
1284                                 goto new_segment;
1285                         if (BIOVEC_VIRT_OVERSIZE(hw_seg_size + bv->bv_len))
1286                                 goto new_hw_segment;
1287
1288                         seg_size += bv->bv_len;
1289                         hw_seg_size += bv->bv_len;
1290                         bvprv = bv;
1291                         continue;
1292                 }
1293 new_segment:
1294                 if (BIOVEC_VIRT_MERGEABLE(bvprv, bv) &&
1295                     !BIOVEC_VIRT_OVERSIZE(hw_seg_size + bv->bv_len))
1296                         hw_seg_size += bv->bv_len;
1297                 else {
1298 new_hw_segment:
1299                         if (nr_hw_segs == 1 &&
1300                             hw_seg_size > rq->bio->bi_hw_front_size)
1301                                 rq->bio->bi_hw_front_size = hw_seg_size;
1302                         hw_seg_size = BIOVEC_VIRT_START_SIZE(bv) + bv->bv_len;
1303                         nr_hw_segs++;
1304                 }
1305
1306                 nr_phys_segs++;
1307                 bvprv = bv;
1308                 seg_size = bv->bv_len;
1309                 highprv = high;
1310         }
1311
1312         if (nr_hw_segs == 1 &&
1313             hw_seg_size > rq->bio->bi_hw_front_size)
1314                 rq->bio->bi_hw_front_size = hw_seg_size;
1315         if (hw_seg_size > rq->biotail->bi_hw_back_size)
1316                 rq->biotail->bi_hw_back_size = hw_seg_size;
1317         rq->nr_phys_segments = nr_phys_segs;
1318         rq->nr_hw_segments = nr_hw_segs;
1319 }
1320
1321 static int blk_phys_contig_segment(struct request_queue *q, struct bio *bio,
1322                                    struct bio *nxt)
1323 {
1324         if (!(q->queue_flags & (1 << QUEUE_FLAG_CLUSTER)))
1325                 return 0;
1326
1327         if (!BIOVEC_PHYS_MERGEABLE(__BVEC_END(bio), __BVEC_START(nxt)))
1328                 return 0;
1329         if (bio->bi_size + nxt->bi_size > q->max_segment_size)
1330                 return 0;
1331
1332         /*
1333          * bio and nxt are contigous in memory, check if the queue allows
1334          * these two to be merged into one
1335          */
1336         if (BIO_SEG_BOUNDARY(q, bio, nxt))
1337                 return 1;
1338
1339         return 0;
1340 }
1341
1342 static int blk_hw_contig_segment(struct request_queue *q, struct bio *bio,
1343                                  struct bio *nxt)
1344 {
1345         if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
1346                 blk_recount_segments(q, bio);
1347         if (unlikely(!bio_flagged(nxt, BIO_SEG_VALID)))
1348                 blk_recount_segments(q, nxt);
1349         if (!BIOVEC_VIRT_MERGEABLE(__BVEC_END(bio), __BVEC_START(nxt)) ||
1350             BIOVEC_VIRT_OVERSIZE(bio->bi_hw_back_size + nxt->bi_hw_front_size))
1351                 return 0;
1352         if (bio->bi_hw_back_size + nxt->bi_hw_front_size > q->max_segment_size)
1353                 return 0;
1354
1355         return 1;
1356 }
1357
1358 /*
1359  * map a request to scatterlist, return number of sg entries setup. Caller
1360  * must make sure sg can hold rq->nr_phys_segments entries
1361  */
1362 int blk_rq_map_sg(struct request_queue *q, struct request *rq,
1363                   struct scatterlist *sglist)
1364 {
1365         struct bio_vec *bvec, *bvprv;
1366         struct req_iterator iter;
1367         struct scatterlist *sg;
1368         int nsegs, cluster;
1369
1370         nsegs = 0;
1371         cluster = q->queue_flags & (1 << QUEUE_FLAG_CLUSTER);
1372
1373         /*
1374          * for each bio in rq
1375          */
1376         bvprv = NULL;
1377         sg = NULL;
1378         rq_for_each_segment(bvec, rq, iter) {
1379                 int nbytes = bvec->bv_len;
1380
1381                 if (bvprv && cluster) {
1382                         if (sg->length + nbytes > q->max_segment_size)
1383                                 goto new_segment;
1384
1385                         if (!BIOVEC_PHYS_MERGEABLE(bvprv, bvec))
1386                                 goto new_segment;
1387                         if (!BIOVEC_SEG_BOUNDARY(q, bvprv, bvec))
1388                                 goto new_segment;
1389
1390                         sg->length += nbytes;
1391                 } else {
1392 new_segment:
1393                         if (!sg)
1394                                 sg = sglist;
1395                         else {
1396                                 /*
1397                                  * If the driver previously mapped a shorter
1398                                  * list, we could see a termination bit
1399                                  * prematurely unless it fully inits the sg
1400                                  * table on each mapping. We KNOW that there
1401                                  * must be more entries here or the driver
1402                                  * would be buggy, so force clear the
1403                                  * termination bit to avoid doing a full
1404                                  * sg_init_table() in drivers for each command.
1405                                  */
1406                                 sg->page_link &= ~0x02;
1407                                 sg = sg_next(sg);
1408                         }
1409
1410                         sg_set_page(sg, bvec->bv_page, nbytes, bvec->bv_offset);
1411                         nsegs++;
1412                 }
1413                 bvprv = bvec;
1414         } /* segments in rq */
1415
1416         if (q->dma_drain_size) {
1417                 sg->page_link &= ~0x02;
1418                 sg = sg_next(sg);
1419                 sg_set_page(sg, virt_to_page(q->dma_drain_buffer),
1420                             q->dma_drain_size,
1421                             ((unsigned long)q->dma_drain_buffer) &
1422                             (PAGE_SIZE - 1));
1423                 nsegs++;
1424         }
1425
1426         if (sg)
1427                 sg_mark_end(sg);
1428
1429         return nsegs;
1430 }
1431
1432 EXPORT_SYMBOL(blk_rq_map_sg);
1433
1434 /*
1435  * the standard queue merge functions, can be overridden with device
1436  * specific ones if so desired
1437  */
1438
1439 static inline int ll_new_mergeable(struct request_queue *q,
1440                                    struct request *req,
1441                                    struct bio *bio)
1442 {
1443         int nr_phys_segs = bio_phys_segments(q, bio);
1444
1445         if (req->nr_phys_segments + nr_phys_segs > q->max_phys_segments) {
1446                 req->cmd_flags |= REQ_NOMERGE;
1447                 if (req == q->last_merge)
1448                         q->last_merge = NULL;
1449                 return 0;
1450         }
1451
1452         /*
1453          * A hw segment is just getting larger, bump just the phys
1454          * counter.
1455          */
1456         req->nr_phys_segments += nr_phys_segs;
1457         return 1;
1458 }
1459
1460 static inline int ll_new_hw_segment(struct request_queue *q,
1461                                     struct request *req,
1462                                     struct bio *bio)
1463 {
1464         int nr_hw_segs = bio_hw_segments(q, bio);
1465         int nr_phys_segs = bio_phys_segments(q, bio);
1466
1467         if (req->nr_hw_segments + nr_hw_segs > q->max_hw_segments
1468             || req->nr_phys_segments + nr_phys_segs > q->max_phys_segments) {
1469                 req->cmd_flags |= REQ_NOMERGE;
1470                 if (req == q->last_merge)
1471                         q->last_merge = NULL;
1472                 return 0;
1473         }
1474
1475         /*
1476          * This will form the start of a new hw segment.  Bump both
1477          * counters.
1478          */
1479         req->nr_hw_segments += nr_hw_segs;
1480         req->nr_phys_segments += nr_phys_segs;
1481         return 1;
1482 }
1483
1484 static int ll_back_merge_fn(struct request_queue *q, struct request *req,
1485                             struct bio *bio)
1486 {
1487         unsigned short max_sectors;
1488         int len;
1489
1490         if (unlikely(blk_pc_request(req)))
1491                 max_sectors = q->max_hw_sectors;
1492         else
1493                 max_sectors = q->max_sectors;
1494
1495         if (req->nr_sectors + bio_sectors(bio) > max_sectors) {
1496                 req->cmd_flags |= REQ_NOMERGE;
1497                 if (req == q->last_merge)
1498                         q->last_merge = NULL;
1499                 return 0;
1500         }
1501         if (unlikely(!bio_flagged(req->biotail, BIO_SEG_VALID)))
1502                 blk_recount_segments(q, req->biotail);
1503         if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
1504                 blk_recount_segments(q, bio);
1505         len = req->biotail->bi_hw_back_size + bio->bi_hw_front_size;
1506         if (BIOVEC_VIRT_MERGEABLE(__BVEC_END(req->biotail), __BVEC_START(bio)) &&
1507             !BIOVEC_VIRT_OVERSIZE(len)) {
1508                 int mergeable =  ll_new_mergeable(q, req, bio);
1509
1510                 if (mergeable) {
1511                         if (req->nr_hw_segments == 1)
1512                                 req->bio->bi_hw_front_size = len;
1513                         if (bio->bi_hw_segments == 1)
1514                                 bio->bi_hw_back_size = len;
1515                 }
1516                 return mergeable;
1517         }
1518
1519         return ll_new_hw_segment(q, req, bio);
1520 }
1521
1522 static int ll_front_merge_fn(struct request_queue *q, struct request *req, 
1523                              struct bio *bio)
1524 {
1525         unsigned short max_sectors;
1526         int len;
1527
1528         if (unlikely(blk_pc_request(req)))
1529                 max_sectors = q->max_hw_sectors;
1530         else
1531                 max_sectors = q->max_sectors;
1532
1533
1534         if (req->nr_sectors + bio_sectors(bio) > max_sectors) {
1535                 req->cmd_flags |= REQ_NOMERGE;
1536                 if (req == q->last_merge)
1537                         q->last_merge = NULL;
1538                 return 0;
1539         }
1540         len = bio->bi_hw_back_size + req->bio->bi_hw_front_size;
1541         if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
1542                 blk_recount_segments(q, bio);
1543         if (unlikely(!bio_flagged(req->bio, BIO_SEG_VALID)))
1544                 blk_recount_segments(q, req->bio);
1545         if (BIOVEC_VIRT_MERGEABLE(__BVEC_END(bio), __BVEC_START(req->bio)) &&
1546             !BIOVEC_VIRT_OVERSIZE(len)) {
1547                 int mergeable =  ll_new_mergeable(q, req, bio);
1548
1549                 if (mergeable) {
1550                         if (bio->bi_hw_segments == 1)
1551                                 bio->bi_hw_front_size = len;
1552                         if (req->nr_hw_segments == 1)
1553                                 req->biotail->bi_hw_back_size = len;
1554                 }
1555                 return mergeable;
1556         }
1557
1558         return ll_new_hw_segment(q, req, bio);
1559 }
1560
1561 static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
1562                                 struct request *next)
1563 {
1564         int total_phys_segments;
1565         int total_hw_segments;
1566
1567         /*
1568          * First check if the either of the requests are re-queued
1569          * requests.  Can't merge them if they are.
1570          */
1571         if (req->special || next->special)
1572                 return 0;
1573
1574         /*
1575          * Will it become too large?
1576          */
1577         if ((req->nr_sectors + next->nr_sectors) > q->max_sectors)
1578                 return 0;
1579
1580         total_phys_segments = req->nr_phys_segments + next->nr_phys_segments;
1581         if (blk_phys_contig_segment(q, req->biotail, next->bio))
1582                 total_phys_segments--;
1583
1584         if (total_phys_segments > q->max_phys_segments)
1585                 return 0;
1586
1587         total_hw_segments = req->nr_hw_segments + next->nr_hw_segments;
1588         if (blk_hw_contig_segment(q, req->biotail, next->bio)) {
1589                 int len = req->biotail->bi_hw_back_size + next->bio->bi_hw_front_size;
1590                 /*
1591                  * propagate the combined length to the end of the requests
1592                  */
1593                 if (req->nr_hw_segments == 1)
1594                         req->bio->bi_hw_front_size = len;
1595                 if (next->nr_hw_segments == 1)
1596                         next->biotail->bi_hw_back_size = len;
1597                 total_hw_segments--;
1598         }
1599
1600         if (total_hw_segments > q->max_hw_segments)
1601                 return 0;
1602
1603         /* Merge is OK... */
1604         req->nr_phys_segments = total_phys_segments;
1605         req->nr_hw_segments = total_hw_segments;
1606         return 1;
1607 }
1608
1609 /*
1610  * "plug" the device if there are no outstanding requests: this will
1611  * force the transfer to start only after we have put all the requests
1612  * on the list.
1613  *
1614  * This is called with interrupts off and no requests on the queue and
1615  * with the queue lock held.
1616  */
1617 void blk_plug_device(struct request_queue *q)
1618 {
1619         WARN_ON(!irqs_disabled());
1620
1621         /*
1622          * don't plug a stopped queue, it must be paired with blk_start_queue()
1623          * which will restart the queueing
1624          */
1625         if (blk_queue_stopped(q))
1626                 return;
1627
1628         if (!test_and_set_bit(QUEUE_FLAG_PLUGGED, &q->queue_flags)) {
1629                 mod_timer(&q->unplug_timer, jiffies + q->unplug_delay);
1630                 blk_add_trace_generic(q, NULL, 0, BLK_TA_PLUG);
1631         }
1632 }
1633
1634 EXPORT_SYMBOL(blk_plug_device);
1635
1636 /*
1637  * remove the queue from the plugged list, if present. called with
1638  * queue lock held and interrupts disabled.
1639  */
1640 int blk_remove_plug(struct request_queue *q)
1641 {
1642         WARN_ON(!irqs_disabled());
1643
1644         if (!test_and_clear_bit(QUEUE_FLAG_PLUGGED, &q->queue_flags))
1645                 return 0;
1646
1647         del_timer(&q->unplug_timer);
1648         return 1;
1649 }
1650
1651 EXPORT_SYMBOL(blk_remove_plug);
1652
1653 /*
1654  * remove the plug and let it rip..
1655  */
1656 void __generic_unplug_device(struct request_queue *q)
1657 {
1658         if (unlikely(blk_queue_stopped(q)))
1659                 return;
1660
1661         if (!blk_remove_plug(q))
1662                 return;
1663
1664         q->request_fn(q);
1665 }
1666 EXPORT_SYMBOL(__generic_unplug_device);
1667
1668 /**
1669  * generic_unplug_device - fire a request queue
1670  * @q:    The &struct request_queue in question
1671  *
1672  * Description:
1673  *   Linux uses plugging to build bigger requests queues before letting
1674  *   the device have at them. If a queue is plugged, the I/O scheduler
1675  *   is still adding and merging requests on the queue. Once the queue
1676  *   gets unplugged, the request_fn defined for the queue is invoked and
1677  *   transfers started.
1678  **/
1679 void generic_unplug_device(struct request_queue *q)
1680 {
1681         spin_lock_irq(q->queue_lock);
1682         __generic_unplug_device(q);
1683         spin_unlock_irq(q->queue_lock);
1684 }
1685 EXPORT_SYMBOL(generic_unplug_device);
1686
1687 static void blk_backing_dev_unplug(struct backing_dev_info *bdi,
1688                                    struct page *page)
1689 {
1690         struct request_queue *q = bdi->unplug_io_data;
1691
1692         blk_unplug(q);
1693 }
1694
1695 static void blk_unplug_work(struct work_struct *work)
1696 {
1697         struct request_queue *q =
1698                 container_of(work, struct request_queue, unplug_work);
1699
1700         blk_add_trace_pdu_int(q, BLK_TA_UNPLUG_IO, NULL,
1701                                 q->rq.count[READ] + q->rq.count[WRITE]);
1702
1703         q->unplug_fn(q);
1704 }
1705
1706 static void blk_unplug_timeout(unsigned long data)
1707 {
1708         struct request_queue *q = (struct request_queue *)data;
1709
1710         blk_add_trace_pdu_int(q, BLK_TA_UNPLUG_TIMER, NULL,
1711                                 q->rq.count[READ] + q->rq.count[WRITE]);
1712
1713         kblockd_schedule_work(&q->unplug_work);
1714 }
1715
1716 void blk_unplug(struct request_queue *q)
1717 {
1718         /*
1719          * devices don't necessarily have an ->unplug_fn defined
1720          */
1721         if (q->unplug_fn) {
1722                 blk_add_trace_pdu_int(q, BLK_TA_UNPLUG_IO, NULL,
1723                                         q->rq.count[READ] + q->rq.count[WRITE]);
1724
1725                 q->unplug_fn(q);
1726         }
1727 }
1728 EXPORT_SYMBOL(blk_unplug);
1729
1730 /**
1731  * blk_start_queue - restart a previously stopped queue
1732  * @q:    The &struct request_queue in question
1733  *
1734  * Description:
1735  *   blk_start_queue() will clear the stop flag on the queue, and call
1736  *   the request_fn for the queue if it was in a stopped state when
1737  *   entered. Also see blk_stop_queue(). Queue lock must be held.
1738  **/
1739 void blk_start_queue(struct request_queue *q)
1740 {
1741         WARN_ON(!irqs_disabled());
1742
1743         clear_bit(QUEUE_FLAG_STOPPED, &q->queue_flags);
1744
1745         /*
1746          * one level of recursion is ok and is much faster than kicking
1747          * the unplug handling
1748          */
1749         if (!test_and_set_bit(QUEUE_FLAG_REENTER, &q->queue_flags)) {
1750                 q->request_fn(q);
1751                 clear_bit(QUEUE_FLAG_REENTER, &q->queue_flags);
1752         } else {
1753                 blk_plug_device(q);
1754                 kblockd_schedule_work(&q->unplug_work);
1755         }
1756 }
1757
1758 EXPORT_SYMBOL(blk_start_queue);
1759
1760 /**
1761  * blk_stop_queue - stop a queue
1762  * @q:    The &struct request_queue in question
1763  *
1764  * Description:
1765  *   The Linux block layer assumes that a block driver will consume all
1766  *   entries on the request queue when the request_fn strategy is called.
1767  *   Often this will not happen, because of hardware limitations (queue
1768  *   depth settings). If a device driver gets a 'queue full' response,
1769  *   or if it simply chooses not to queue more I/O at one point, it can
1770  *   call this function to prevent the request_fn from being called until
1771  *   the driver has signalled it's ready to go again. This happens by calling
1772  *   blk_start_queue() to restart queue operations. Queue lock must be held.
1773  **/
1774 void blk_stop_queue(struct request_queue *q)
1775 {
1776         blk_remove_plug(q);
1777         set_bit(QUEUE_FLAG_STOPPED, &q->queue_flags);
1778 }
1779 EXPORT_SYMBOL(blk_stop_queue);
1780
1781 /**
1782  * blk_sync_queue - cancel any pending callbacks on a queue
1783  * @q: the queue
1784  *
1785  * Description:
1786  *     The block layer may perform asynchronous callback activity
1787  *     on a queue, such as calling the unplug function after a timeout.
1788  *     A block device may call blk_sync_queue to ensure that any
1789  *     such activity is cancelled, thus allowing it to release resources
1790  *     that the callbacks might use. The caller must already have made sure
1791  *     that its ->make_request_fn will not re-add plugging prior to calling
1792  *     this function.
1793  *
1794  */
1795 void blk_sync_queue(struct request_queue *q)
1796 {
1797         del_timer_sync(&q->unplug_timer);
1798         kblockd_flush_work(&q->unplug_work);
1799 }
1800 EXPORT_SYMBOL(blk_sync_queue);
1801
1802 /**
1803  * blk_run_queue - run a single device queue
1804  * @q:  The queue to run
1805  */
1806 void blk_run_queue(struct request_queue *q)
1807 {
1808         unsigned long flags;
1809
1810         spin_lock_irqsave(q->queue_lock, flags);
1811         blk_remove_plug(q);
1812
1813         /*
1814          * Only recurse once to avoid overrunning the stack, let the unplug
1815          * handling reinvoke the handler shortly if we already got there.
1816          */
1817         if (!elv_queue_empty(q)) {
1818                 if (!test_and_set_bit(QUEUE_FLAG_REENTER, &q->queue_flags)) {
1819                         q->request_fn(q);
1820                         clear_bit(QUEUE_FLAG_REENTER, &q->queue_flags);
1821                 } else {
1822                         blk_plug_device(q);
1823                         kblockd_schedule_work(&q->unplug_work);
1824                 }
1825         }
1826
1827         spin_unlock_irqrestore(q->queue_lock, flags);
1828 }
1829 EXPORT_SYMBOL(blk_run_queue);
1830
1831 /**
1832  * blk_cleanup_queue: - release a &struct request_queue when it is no longer needed
1833  * @kobj:    the kobj belonging of the request queue to be released
1834  *
1835  * Description:
1836  *     blk_cleanup_queue is the pair to blk_init_queue() or
1837  *     blk_queue_make_request().  It should be called when a request queue is
1838  *     being released; typically when a block device is being de-registered.
1839  *     Currently, its primary task it to free all the &struct request
1840  *     structures that were allocated to the queue and the queue itself.
1841  *
1842  * Caveat:
1843  *     Hopefully the low level driver will have finished any
1844  *     outstanding requests first...
1845  **/
1846 static void blk_release_queue(struct kobject *kobj)
1847 {
1848         struct request_queue *q =
1849                 container_of(kobj, struct request_queue, kobj);
1850         struct request_list *rl = &q->rq;
1851
1852         blk_sync_queue(q);
1853
1854         if (rl->rq_pool)
1855                 mempool_destroy(rl->rq_pool);
1856
1857         if (q->queue_tags)
1858                 __blk_queue_free_tags(q);
1859
1860         blk_trace_shutdown(q);
1861
1862         bdi_destroy(&q->backing_dev_info);
1863         kmem_cache_free(requestq_cachep, q);
1864 }
1865
1866 void blk_put_queue(struct request_queue *q)
1867 {
1868         kobject_put(&q->kobj);
1869 }
1870 EXPORT_SYMBOL(blk_put_queue);
1871
1872 void blk_cleanup_queue(struct request_queue * q)
1873 {
1874         mutex_lock(&q->sysfs_lock);
1875         set_bit(QUEUE_FLAG_DEAD, &q->queue_flags);
1876         mutex_unlock(&q->sysfs_lock);
1877
1878         if (q->elevator)
1879                 elevator_exit(q->elevator);
1880
1881         blk_put_queue(q);
1882 }
1883
1884 EXPORT_SYMBOL(blk_cleanup_queue);
1885
1886 static int blk_init_free_list(struct request_queue *q)
1887 {
1888         struct request_list *rl = &q->rq;
1889
1890         rl->count[READ] = rl->count[WRITE] = 0;
1891         rl->starved[READ] = rl->starved[WRITE] = 0;
1892         rl->elvpriv = 0;
1893         init_waitqueue_head(&rl->wait[READ]);
1894         init_waitqueue_head(&rl->wait[WRITE]);
1895
1896         rl->rq_pool = mempool_create_node(BLKDEV_MIN_RQ, mempool_alloc_slab,
1897                                 mempool_free_slab, request_cachep, q->node);
1898
1899         if (!rl->rq_pool)
1900                 return -ENOMEM;
1901
1902         return 0;
1903 }
1904
1905 struct request_queue *blk_alloc_queue(gfp_t gfp_mask)
1906 {
1907         return blk_alloc_queue_node(gfp_mask, -1);
1908 }
1909 EXPORT_SYMBOL(blk_alloc_queue);
1910
1911 static struct kobj_type queue_ktype;
1912
1913 struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
1914 {
1915         struct request_queue *q;
1916         int err;
1917
1918         q = kmem_cache_alloc_node(requestq_cachep,
1919                                 gfp_mask | __GFP_ZERO, node_id);
1920         if (!q)
1921                 return NULL;
1922
1923         q->backing_dev_info.unplug_io_fn = blk_backing_dev_unplug;
1924         q->backing_dev_info.unplug_io_data = q;
1925         err = bdi_init(&q->backing_dev_info);
1926         if (err) {
1927                 kmem_cache_free(requestq_cachep, q);
1928                 return NULL;
1929         }
1930
1931         init_timer(&q->unplug_timer);
1932
1933         kobject_init(&q->kobj, &queue_ktype);
1934
1935         mutex_init(&q->sysfs_lock);
1936
1937         return q;
1938 }
1939 EXPORT_SYMBOL(blk_alloc_queue_node);
1940
1941 /**
1942  * blk_init_queue  - prepare a request queue for use with a block device
1943  * @rfn:  The function to be called to process requests that have been
1944  *        placed on the queue.
1945  * @lock: Request queue spin lock
1946  *
1947  * Description:
1948  *    If a block device wishes to use the standard request handling procedures,
1949  *    which sorts requests and coalesces adjacent requests, then it must
1950  *    call blk_init_queue().  The function @rfn will be called when there
1951  *    are requests on the queue that need to be processed.  If the device
1952  *    supports plugging, then @rfn may not be called immediately when requests
1953  *    are available on the queue, but may be called at some time later instead.
1954  *    Plugged queues are generally unplugged when a buffer belonging to one
1955  *    of the requests on the queue is needed, or due to memory pressure.
1956  *
1957  *    @rfn is not required, or even expected, to remove all requests off the
1958  *    queue, but only as many as it can handle at a time.  If it does leave
1959  *    requests on the queue, it is responsible for arranging that the requests
1960  *    get dealt with eventually.
1961  *
1962  *    The queue spin lock must be held while manipulating the requests on the
1963  *    request queue; this lock will be taken also from interrupt context, so irq
1964  *    disabling is needed for it.
1965  *
1966  *    Function returns a pointer to the initialized request queue, or NULL if
1967  *    it didn't succeed.
1968  *
1969  * Note:
1970  *    blk_init_queue() must be paired with a blk_cleanup_queue() call
1971  *    when the block device is deactivated (such as at module unload).
1972  **/
1973
1974 struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)
1975 {
1976         return blk_init_queue_node(rfn, lock, -1);
1977 }
1978 EXPORT_SYMBOL(blk_init_queue);
1979
1980 struct request_queue *
1981 blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)
1982 {
1983         struct request_queue *q = blk_alloc_queue_node(GFP_KERNEL, node_id);
1984
1985         if (!q)
1986                 return NULL;
1987
1988         q->node = node_id;
1989         if (blk_init_free_list(q)) {
1990                 kmem_cache_free(requestq_cachep, q);
1991                 return NULL;
1992         }
1993
1994         /*
1995          * if caller didn't supply a lock, they get per-queue locking with
1996          * our embedded lock
1997          */
1998         if (!lock) {
1999                 spin_lock_init(&q->__queue_lock);
2000                 lock = &q->__queue_lock;
2001         }
2002
2003         q->request_fn           = rfn;
2004         q->prep_rq_fn           = NULL;
2005         q->unplug_fn            = generic_unplug_device;
2006         q->queue_flags          = (1 << QUEUE_FLAG_CLUSTER);
2007         q->queue_lock           = lock;
2008
2009         blk_queue_segment_boundary(q, 0xffffffff);
2010
2011         blk_queue_make_request(q, __make_request);
2012         blk_queue_max_segment_size(q, MAX_SEGMENT_SIZE);
2013
2014         blk_queue_max_hw_segments(q, MAX_HW_SEGMENTS);
2015         blk_queue_max_phys_segments(q, MAX_PHYS_SEGMENTS);
2016
2017         q->sg_reserved_size = INT_MAX;
2018
2019         /*
2020          * all done
2021          */
2022         if (!elevator_init(q, NULL)) {
2023                 blk_queue_congestion_threshold(q);
2024                 return q;
2025         }
2026
2027         blk_put_queue(q);
2028         return NULL;
2029 }
2030 EXPORT_SYMBOL(blk_init_queue_node);
2031
2032 int blk_get_queue(struct request_queue *q)
2033 {
2034         if (likely(!test_bit(QUEUE_FLAG_DEAD, &q->queue_flags))) {
2035                 kobject_get(&q->kobj);
2036                 return 0;
2037         }
2038
2039         return 1;
2040 }
2041
2042 EXPORT_SYMBOL(blk_get_queue);
2043
2044 static inline void blk_free_request(struct request_queue *q, struct request *rq)
2045 {
2046         if (rq->cmd_flags & REQ_ELVPRIV)
2047                 elv_put_request(q, rq);
2048         mempool_free(rq, q->rq.rq_pool);
2049 }
2050
2051 static struct request *
2052 blk_alloc_request(struct request_queue *q, int rw, int priv, gfp_t gfp_mask)
2053 {
2054         struct request *rq = mempool_alloc(q->rq.rq_pool, gfp_mask);
2055
2056         if (!rq)
2057                 return NULL;
2058
2059         /*
2060          * first three bits are identical in rq->cmd_flags and bio->bi_rw,
2061          * see bio.h and blkdev.h
2062          */
2063         rq->cmd_flags = rw | REQ_ALLOCED;
2064
2065         if (priv) {
2066                 if (unlikely(elv_set_request(q, rq, gfp_mask))) {
2067                         mempool_free(rq, q->rq.rq_pool);
2068                         return NULL;
2069                 }
2070                 rq->cmd_flags |= REQ_ELVPRIV;
2071         }
2072
2073         return rq;
2074 }
2075
2076 /*
2077  * ioc_batching returns true if the ioc is a valid batching request and
2078  * should be given priority access to a request.
2079  */
2080 static inline int ioc_batching(struct request_queue *q, struct io_context *ioc)
2081 {
2082         if (!ioc)
2083                 return 0;
2084
2085         /*
2086          * Make sure the process is able to allocate at least 1 request
2087          * even if the batch times out, otherwise we could theoretically
2088          * lose wakeups.
2089          */
2090         return ioc->nr_batch_requests == q->nr_batching ||
2091                 (ioc->nr_batch_requests > 0
2092                 && time_before(jiffies, ioc->last_waited + BLK_BATCH_TIME));
2093 }
2094
2095 /*
2096  * ioc_set_batching sets ioc to be a new "batcher" if it is not one. This
2097  * will cause the process to be a "batcher" on all queues in the system. This
2098  * is the behaviour we want though - once it gets a wakeup it should be given
2099  * a nice run.
2100  */
2101 static void ioc_set_batching(struct request_queue *q, struct io_context *ioc)
2102 {
2103         if (!ioc || ioc_batching(q, ioc))
2104                 return;
2105
2106         ioc->nr_batch_requests = q->nr_batching;
2107         ioc->last_waited = jiffies;
2108 }
2109
2110 static void __freed_request(struct request_queue *q, int rw)
2111 {
2112         struct request_list *rl = &q->rq;
2113
2114         if (rl->count[rw] < queue_congestion_off_threshold(q))
2115                 blk_clear_queue_congested(q, rw);
2116
2117         if (rl->count[rw] + 1 <= q->nr_requests) {
2118                 if (waitqueue_active(&rl->wait[rw]))
2119                         wake_up(&rl->wait[rw]);
2120
2121                 blk_clear_queue_full(q, rw);
2122         }
2123 }
2124
2125 /*
2126  * A request has just been released.  Account for it, update the full and
2127  * congestion status, wake up any waiters.   Called under q->queue_lock.
2128  */
2129 static void freed_request(struct request_queue *q, int rw, int priv)
2130 {
2131         struct request_list *rl = &q->rq;
2132
2133         rl->count[rw]--;
2134         if (priv)
2135                 rl->elvpriv--;
2136
2137         __freed_request(q, rw);
2138
2139         if (unlikely(rl->starved[rw ^ 1]))
2140                 __freed_request(q, rw ^ 1);
2141 }
2142
2143 #define blkdev_free_rq(list) list_entry((list)->next, struct request, queuelist)
2144 /*
2145  * Get a free request, queue_lock must be held.
2146  * Returns NULL on failure, with queue_lock held.
2147  * Returns !NULL on success, with queue_lock *not held*.
2148  */
2149 static struct request *get_request(struct request_queue *q, int rw_flags,
2150                                    struct bio *bio, gfp_t gfp_mask)
2151 {
2152         struct request *rq = NULL;
2153         struct request_list *rl = &q->rq;
2154         struct io_context *ioc = NULL;
2155         const int rw = rw_flags & 0x01;
2156         int may_queue, priv;
2157
2158         may_queue = elv_may_queue(q, rw_flags);
2159         if (may_queue == ELV_MQUEUE_NO)
2160                 goto rq_starved;
2161
2162         if (rl->count[rw]+1 >= queue_congestion_on_threshold(q)) {
2163                 if (rl->count[rw]+1 >= q->nr_requests) {
2164                         ioc = current_io_context(GFP_ATOMIC, q->node);
2165                         /*
2166                          * The queue will fill after this allocation, so set
2167                          * it as full, and mark this process as "batching".
2168                          * This process will be allowed to complete a batch of
2169                          * requests, others will be blocked.
2170                          */
2171                         if (!blk_queue_full(q, rw)) {
2172                                 ioc_set_batching(q, ioc);
2173                                 blk_set_queue_full(q, rw);
2174                         } else {
2175                                 if (may_queue != ELV_MQUEUE_MUST
2176                                                 && !ioc_batching(q, ioc)) {
2177                                         /*
2178                                          * The queue is full and the allocating
2179                                          * process is not a "batcher", and not
2180                                          * exempted by the IO scheduler
2181                                          */
2182                                         goto out;
2183                                 }
2184                         }
2185                 }
2186                 blk_set_queue_congested(q, rw);
2187         }
2188
2189         /*
2190          * Only allow batching queuers to allocate up to 50% over the defined
2191          * limit of requests, otherwise we could have thousands of requests
2192          * allocated with any setting of ->nr_requests
2193          */
2194         if (rl->count[rw] >= (3 * q->nr_requests / 2))
2195                 goto out;
2196
2197         rl->count[rw]++;
2198         rl->starved[rw] = 0;
2199
2200         priv = !test_bit(QUEUE_FLAG_ELVSWITCH, &q->queue_flags);
2201         if (priv)
2202                 rl->elvpriv++;
2203
2204         spin_unlock_irq(q->queue_lock);
2205
2206         rq = blk_alloc_request(q, rw_flags, priv, gfp_mask);
2207         if (unlikely(!rq)) {
2208                 /*
2209                  * Allocation failed presumably due to memory. Undo anything
2210                  * we might have messed up.
2211                  *
2212                  * Allocating task should really be put onto the front of the
2213                  * wait queue, but this is pretty rare.
2214                  */
2215                 spin_lock_irq(q->queue_lock);
2216                 freed_request(q, rw, priv);
2217
2218                 /*
2219                  * in the very unlikely event that allocation failed and no
2220                  * requests for this direction was pending, mark us starved
2221                  * so that freeing of a request in the other direction will
2222                  * notice us. another possible fix would be to split the
2223                  * rq mempool into READ and WRITE
2224                  */
2225 rq_starved:
2226                 if (unlikely(rl->count[rw] == 0))
2227                         rl->starved[rw] = 1;
2228
2229                 goto out;
2230         }
2231
2232         /*
2233          * ioc may be NULL here, and ioc_batching will be false. That's
2234          * OK, if the queue is under the request limit then requests need
2235          * not count toward the nr_batch_requests limit. There will always
2236          * be some limit enforced by BLK_BATCH_TIME.
2237          */
2238         if (ioc_batching(q, ioc))
2239                 ioc->nr_batch_requests--;
2240         
2241         rq_init(q, rq);
2242
2243         blk_add_trace_generic(q, bio, rw, BLK_TA_GETRQ);
2244 out:
2245         return rq;
2246 }
2247
2248 /*
2249  * No available requests for this queue, unplug the device and wait for some
2250  * requests to become available.
2251  *
2252  * Called with q->queue_lock held, and returns with it unlocked.
2253  */
2254 static struct request *get_request_wait(struct request_queue *q, int rw_flags,
2255                                         struct bio *bio)
2256 {
2257         const int rw = rw_flags & 0x01;
2258         struct request *rq;
2259
2260         rq = get_request(q, rw_flags, bio, GFP_NOIO);
2261         while (!rq) {
2262                 DEFINE_WAIT(wait);
2263                 struct request_list *rl = &q->rq;
2264
2265                 prepare_to_wait_exclusive(&rl->wait[rw], &wait,
2266                                 TASK_UNINTERRUPTIBLE);
2267
2268                 rq = get_request(q, rw_flags, bio, GFP_NOIO);
2269
2270                 if (!rq) {
2271                         struct io_context *ioc;
2272
2273                         blk_add_trace_generic(q, bio, rw, BLK_TA_SLEEPRQ);
2274
2275                         __generic_unplug_device(q);
2276                         spin_unlock_irq(q->queue_lock);
2277                         io_schedule();
2278
2279                         /*
2280                          * After sleeping, we become a "batching" process and
2281                          * will be able to allocate at least one request, and
2282                          * up to a big batch of them for a small period time.
2283                          * See ioc_batching, ioc_set_batching
2284                          */
2285                         ioc = current_io_context(GFP_NOIO, q->node);
2286                         ioc_set_batching(q, ioc);
2287
2288                         spin_lock_irq(q->queue_lock);
2289                 }
2290                 finish_wait(&rl->wait[rw], &wait);
2291         }
2292
2293         return rq;
2294 }
2295
2296 struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask)
2297 {
2298         struct request *rq;
2299
2300         BUG_ON(rw != READ && rw != WRITE);
2301
2302         spin_lock_irq(q->queue_lock);
2303         if (gfp_mask & __GFP_WAIT) {
2304                 rq = get_request_wait(q, rw, NULL);
2305         } else {
2306                 rq = get_request(q, rw, NULL, gfp_mask);
2307                 if (!rq)
2308                         spin_unlock_irq(q->queue_lock);
2309         }
2310         /* q->queue_lock is unlocked at this point */
2311
2312         return rq;
2313 }
2314 EXPORT_SYMBOL(blk_get_request);
2315
2316 /**
2317  * blk_start_queueing - initiate dispatch of requests to device
2318  * @q:          request queue to kick into gear
2319  *
2320  * This is basically a helper to remove the need to know whether a queue
2321  * is plugged or not if someone just wants to initiate dispatch of requests
2322  * for this queue.
2323  *
2324  * The queue lock must be held with interrupts disabled.
2325  */
2326 void blk_start_queueing(struct request_queue *q)
2327 {
2328         if (!blk_queue_plugged(q))
2329                 q->request_fn(q);
2330         else
2331                 __generic_unplug_device(q);
2332 }
2333 EXPORT_SYMBOL(blk_start_queueing);
2334
2335 /**
2336  * blk_requeue_request - put a request back on queue
2337  * @q:          request queue where request should be inserted
2338  * @rq:         request to be inserted
2339  *
2340  * Description:
2341  *    Drivers often keep queueing requests until the hardware cannot accept
2342  *    more, when that condition happens we need to put the request back
2343  *    on the queue. Must be called with queue lock held.
2344  */
2345 void blk_requeue_request(struct request_queue *q, struct request *rq)
2346 {
2347         blk_add_trace_rq(q, rq, BLK_TA_REQUEUE);
2348
2349         if (blk_rq_tagged(rq))
2350                 blk_queue_end_tag(q, rq);
2351
2352         elv_requeue_request(q, rq);
2353 }
2354
2355 EXPORT_SYMBOL(blk_requeue_request);
2356
2357 /**
2358  * blk_insert_request - insert a special request in to a request queue
2359  * @q:          request queue where request should be inserted
2360  * @rq:         request to be inserted
2361  * @at_head:    insert request at head or tail of queue
2362  * @data:       private data
2363  *
2364  * Description:
2365  *    Many block devices need to execute commands asynchronously, so they don't
2366  *    block the whole kernel from preemption during request execution.  This is
2367  *    accomplished normally by inserting aritficial requests tagged as
2368  *    REQ_SPECIAL in to the corresponding request queue, and letting them be
2369  *    scheduled for actual execution by the request queue.
2370  *
2371  *    We have the option of inserting the head or the tail of the queue.
2372  *    Typically we use the tail for new ioctls and so forth.  We use the head
2373  *    of the queue for things like a QUEUE_FULL message from a device, or a
2374  *    host that is unable to accept a particular command.
2375  */
2376 void blk_insert_request(struct request_queue *q, struct request *rq,
2377                         int at_head, void *data)
2378 {
2379         int where = at_head ? ELEVATOR_INSERT_FRONT : ELEVATOR_INSERT_BACK;
2380         unsigned long flags;
2381
2382         /*
2383          * tell I/O scheduler that this isn't a regular read/write (ie it
2384          * must not attempt merges on this) and that it acts as a soft
2385          * barrier
2386          */
2387         rq->cmd_type = REQ_TYPE_SPECIAL;
2388         rq->cmd_flags |= REQ_SOFTBARRIER;
2389
2390         rq->special = data;
2391
2392         spin_lock_irqsave(q->queue_lock, flags);
2393
2394         /*
2395          * If command is tagged, release the tag
2396          */
2397         if (blk_rq_tagged(rq))
2398                 blk_queue_end_tag(q, rq);
2399
2400         drive_stat_acct(rq, 1);
2401         __elv_add_request(q, rq, where, 0);
2402         blk_start_queueing(q);
2403         spin_unlock_irqrestore(q->queue_lock, flags);
2404 }
2405
2406 EXPORT_SYMBOL(blk_insert_request);
2407
2408 static int __blk_rq_unmap_user(struct bio *bio)
2409 {
2410         int ret = 0;
2411
2412         if (bio) {
2413                 if (bio_flagged(bio, BIO_USER_MAPPED))
2414                         bio_unmap_user(bio);
2415                 else
2416                         ret = bio_uncopy_user(bio);
2417         }
2418
2419         return ret;
2420 }
2421
2422 int blk_rq_append_bio(struct request_queue *q, struct request *rq,
2423                       struct bio *bio)
2424 {
2425         if (!rq->bio)
2426                 blk_rq_bio_prep(q, rq, bio);
2427         else if (!ll_back_merge_fn(q, rq, bio))
2428                 return -EINVAL;
2429         else {
2430                 rq->biotail->bi_next = bio;
2431                 rq->biotail = bio;
2432
2433                 rq->data_len += bio->bi_size;
2434         }
2435         return 0;
2436 }
2437 EXPORT_SYMBOL(blk_rq_append_bio);
2438
2439 static int __blk_rq_map_user(struct request_queue *q, struct request *rq,
2440                              void __user *ubuf, unsigned int len)
2441 {
2442         unsigned long uaddr;
2443         struct bio *bio, *orig_bio;
2444         int reading, ret;
2445
2446         reading = rq_data_dir(rq) == READ;
2447
2448         /*
2449          * if alignment requirement is satisfied, map in user pages for
2450          * direct dma. else, set up kernel bounce buffers
2451          */
2452         uaddr = (unsigned long) ubuf;
2453         if (!(uaddr & queue_dma_alignment(q)) && !(len & queue_dma_alignment(q)))
2454                 bio = bio_map_user(q, NULL, uaddr, len, reading);
2455         else
2456                 bio = bio_copy_user(q, uaddr, len, reading);
2457
2458         if (IS_ERR(bio))
2459                 return PTR_ERR(bio);
2460
2461         orig_bio = bio;
2462         blk_queue_bounce(q, &bio);
2463
2464         /*
2465          * We link the bounce buffer in and could have to traverse it
2466          * later so we have to get a ref to prevent it from being freed
2467          */
2468         bio_get(bio);
2469
2470         ret = blk_rq_append_bio(q, rq, bio);
2471         if (!ret)
2472                 return bio->bi_size;
2473
2474         /* if it was boucned we must call the end io function */
2475         bio_endio(bio, 0);
2476         __blk_rq_unmap_user(orig_bio);
2477         bio_put(bio);
2478         return ret;
2479 }
2480
2481 /**
2482  * blk_rq_map_user - map user data to a request, for REQ_BLOCK_PC usage
2483  * @q:          request queue where request should be inserted
2484  * @rq:         request structure to fill
2485  * @ubuf:       the user buffer
2486  * @len:        length of user data
2487  *
2488  * Description:
2489  *    Data will be mapped directly for zero copy io, if possible. Otherwise
2490  *    a kernel bounce buffer is used.
2491  *
2492  *    A matching blk_rq_unmap_user() must be issued at the end of io, while
2493  *    still in process context.
2494  *
2495  *    Note: The mapped bio may need to be bounced through blk_queue_bounce()
2496  *    before being submitted to the device, as pages mapped may be out of
2497  *    reach. It's the callers responsibility to make sure this happens. The
2498  *    original bio must be passed back in to blk_rq_unmap_user() for proper
2499  *    unmapping.
2500  */
2501 int blk_rq_map_user(struct request_queue *q, struct request *rq,
2502                     void __user *ubuf, unsigned long len)
2503 {
2504         unsigned long bytes_read = 0;
2505         struct bio *bio = NULL;
2506         int ret;
2507
2508         if (len > (q->max_hw_sectors << 9))
2509                 return -EINVAL;
2510         if (!len || !ubuf)
2511                 return -EINVAL;
2512
2513         while (bytes_read != len) {
2514                 unsigned long map_len, end, start;
2515
2516                 map_len = min_t(unsigned long, len - bytes_read, BIO_MAX_SIZE);
2517                 end = ((unsigned long)ubuf + map_len + PAGE_SIZE - 1)
2518                                                                 >> PAGE_SHIFT;
2519                 start = (unsigned long)ubuf >> PAGE_SHIFT;
2520
2521                 /*
2522                  * A bad offset could cause us to require BIO_MAX_PAGES + 1
2523                  * pages. If this happens we just lower the requested
2524                  * mapping len by a page so that we can fit
2525                  */
2526                 if (end - start > BIO_MAX_PAGES)
2527                         map_len -= PAGE_SIZE;
2528
2529                 ret = __blk_rq_map_user(q, rq, ubuf, map_len);
2530                 if (ret < 0)
2531                         goto unmap_rq;
2532                 if (!bio)
2533                         bio = rq->bio;
2534                 bytes_read += ret;
2535                 ubuf += ret;
2536         }
2537
2538         rq->buffer = rq->data = NULL;
2539         return 0;
2540 unmap_rq:
2541         blk_rq_unmap_user(bio);
2542         return ret;
2543 }
2544
2545 EXPORT_SYMBOL(blk_rq_map_user);
2546
2547 /**
2548  * blk_rq_map_user_iov - map user data to a request, for REQ_BLOCK_PC usage
2549  * @q:          request queue where request should be inserted
2550  * @rq:         request to map data to
2551  * @iov:        pointer to the iovec
2552  * @iov_count:  number of elements in the iovec
2553  * @len:        I/O byte count
2554  *
2555  * Description:
2556  *    Data will be mapped directly for zero copy io, if possible. Otherwise
2557  *    a kernel bounce buffer is used.
2558  *
2559  *    A matching blk_rq_unmap_user() must be issued at the end of io, while
2560  *    still in process context.
2561  *
2562  *    Note: The mapped bio may need to be bounced through blk_queue_bounce()
2563  *    before being submitted to the device, as pages mapped may be out of
2564  *    reach. It's the callers responsibility to make sure this happens. The
2565  *    original bio must be passed back in to blk_rq_unmap_user() for proper
2566  *    unmapping.
2567  */
2568 int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
2569                         struct sg_iovec *iov, int iov_count, unsigned int len)
2570 {
2571         struct bio *bio;
2572
2573         if (!iov || iov_count <= 0)
2574                 return -EINVAL;
2575
2576         /* we don't allow misaligned data like bio_map_user() does.  If the
2577          * user is using sg, they're expected to know the alignment constraints
2578          * and respect them accordingly */
2579         bio = bio_map_user_iov(q, NULL, iov, iov_count, rq_data_dir(rq)== READ);
2580         if (IS_ERR(bio))
2581                 return PTR_ERR(bio);
2582
2583         if (bio->bi_size != len) {
2584                 bio_endio(bio, 0);
2585                 bio_unmap_user(bio);
2586                 return -EINVAL;
2587         }
2588
2589         bio_get(bio);
2590         blk_rq_bio_prep(q, rq, bio);
2591         rq->buffer = rq->data = NULL;
2592         return 0;
2593 }
2594
2595 EXPORT_SYMBOL(blk_rq_map_user_iov);
2596
2597 /**
2598  * blk_rq_unmap_user - unmap a request with user data
2599  * @bio:               start of bio list
2600  *
2601  * Description:
2602  *    Unmap a rq previously mapped by blk_rq_map_user(). The caller must
2603  *    supply the original rq->bio from the blk_rq_map_user() return, since
2604  *    the io completion may have changed rq->bio.
2605  */
2606 int blk_rq_unmap_user(struct bio *bio)
2607 {
2608         struct bio *mapped_bio;
2609         int ret = 0, ret2;
2610
2611         while (bio) {
2612                 mapped_bio = bio;
2613                 if (unlikely(bio_flagged(bio, BIO_BOUNCED)))
2614                         mapped_bio = bio->bi_private;
2615
2616                 ret2 = __blk_rq_unmap_user(mapped_bio);
2617                 if (ret2 && !ret)
2618                         ret = ret2;
2619
2620                 mapped_bio = bio;
2621                 bio = bio->bi_next;
2622                 bio_put(mapped_bio);
2623         }
2624
2625         return ret;
2626 }
2627
2628 EXPORT_SYMBOL(blk_rq_unmap_user);
2629
2630 /**
2631  * blk_rq_map_kern - map kernel data to a request, for REQ_BLOCK_PC usage
2632  * @q:          request queue where request should be inserted
2633  * @rq:         request to fill
2634  * @kbuf:       the kernel buffer
2635  * @len:        length of user data
2636  * @gfp_mask:   memory allocation flags
2637  */
2638 int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
2639                     unsigned int len, gfp_t gfp_mask)
2640 {
2641         struct bio *bio;
2642
2643         if (len > (q->max_hw_sectors << 9))
2644                 return -EINVAL;
2645         if (!len || !kbuf)
2646                 return -EINVAL;
2647
2648         bio = bio_map_kern(q, kbuf, len, gfp_mask);
2649         if (IS_ERR(bio))
2650                 return PTR_ERR(bio);
2651
2652         if (rq_data_dir(rq) == WRITE)
2653                 bio->bi_rw |= (1 << BIO_RW);
2654
2655         blk_rq_bio_prep(q, rq, bio);
2656         blk_queue_bounce(q, &rq->bio);
2657         rq->buffer = rq->data = NULL;
2658         return 0;
2659 }
2660
2661 EXPORT_SYMBOL(blk_rq_map_kern);
2662
2663 /**
2664  * blk_execute_rq_nowait - insert a request into queue for execution
2665  * @q:          queue to insert the request in
2666  * @bd_disk:    matching gendisk
2667  * @rq:         request to insert
2668  * @at_head:    insert request at head or tail of queue
2669  * @done:       I/O completion handler
2670  *
2671  * Description:
2672  *    Insert a fully prepared request at the back of the io scheduler queue
2673  *    for execution.  Don't wait for completion.
2674  */
2675 void blk_execute_rq_nowait(struct request_queue *q, struct gendisk *bd_disk,
2676                            struct request *rq, int at_head,
2677                            rq_end_io_fn *done)
2678 {
2679         int where = at_head ? ELEVATOR_INSERT_FRONT : ELEVATOR_INSERT_BACK;
2680
2681         rq->rq_disk = bd_disk;
2682         rq->cmd_flags |= REQ_NOMERGE;
2683         rq->end_io = done;
2684         WARN_ON(irqs_disabled());
2685         spin_lock_irq(q->queue_lock);
2686         __elv_add_request(q, rq, where, 1);
2687         __generic_unplug_device(q);
2688         spin_unlock_irq(q->queue_lock);
2689 }
2690 EXPORT_SYMBOL_GPL(blk_execute_rq_nowait);
2691
2692 /**
2693  * blk_execute_rq - insert a request into queue for execution
2694  * @q:          queue to insert the request in
2695  * @bd_disk:    matching gendisk
2696  * @rq:         request to insert
2697  * @at_head:    insert request at head or tail of queue
2698  *
2699  * Description:
2700  *    Insert a fully prepared request at the back of the io scheduler queue
2701  *    for execution and wait for completion.
2702  */
2703 int blk_execute_rq(struct request_queue *q, struct gendisk *bd_disk,
2704                    struct request *rq, int at_head)
2705 {
2706         DECLARE_COMPLETION_ONSTACK(wait);
2707         char sense[SCSI_SENSE_BUFFERSIZE];
2708         int err = 0;
2709
2710         /*
2711          * we need an extra reference to the request, so we can look at
2712          * it after io completion
2713          */
2714         rq->ref_count++;
2715
2716         if (!rq->sense) {
2717                 memset(sense, 0, sizeof(sense));
2718                 rq->sense = sense;
2719                 rq->sense_len = 0;
2720         }
2721
2722         rq->end_io_data = &wait;
2723         blk_execute_rq_nowait(q, bd_disk, rq, at_head, blk_end_sync_rq);
2724         wait_for_completion(&wait);
2725
2726         if (rq->errors)
2727                 err = -EIO;
2728
2729         return err;
2730 }
2731
2732 EXPORT_SYMBOL(blk_execute_rq);
2733
2734 static void bio_end_empty_barrier(struct bio *bio, int err)
2735 {
2736         if (err)
2737                 clear_bit(BIO_UPTODATE, &bio->bi_flags);
2738
2739         complete(bio->bi_private);
2740 }
2741
2742 /**
2743  * blkdev_issue_flush - queue a flush
2744  * @bdev:       blockdev to issue flush for
2745  * @error_sector:       error sector
2746  *
2747  * Description:
2748  *    Issue a flush for the block device in question. Caller can supply
2749  *    room for storing the error offset in case of a flush error, if they
2750  *    wish to.  Caller must run wait_for_completion() on its own.
2751  */
2752 int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
2753 {
2754         DECLARE_COMPLETION_ONSTACK(wait);
2755         struct request_queue *q;
2756         struct bio *bio;
2757         int ret;
2758
2759         if (bdev->bd_disk == NULL)
2760                 return -ENXIO;
2761
2762         q = bdev_get_queue(bdev);
2763         if (!q)
2764                 return -ENXIO;
2765
2766         bio = bio_alloc(GFP_KERNEL, 0);
2767         if (!bio)
2768                 return -ENOMEM;
2769
2770         bio->bi_end_io = bio_end_empty_barrier;
2771         bio->bi_private = &wait;
2772         bio->bi_bdev = bdev;
2773         submit_bio(1 << BIO_RW_BARRIER, bio);
2774
2775         wait_for_completion(&wait);
2776
2777         /*
2778          * The driver must store the error location in ->bi_sector, if
2779          * it supports it. For non-stacked drivers, this should be copied
2780          * from rq->sector.
2781          */
2782         if (error_sector)
2783                 *error_sector = bio->bi_sector;
2784
2785         ret = 0;
2786         if (!bio_flagged(bio, BIO_UPTODATE))
2787                 ret = -EIO;
2788
2789         bio_put(bio);
2790         return ret;
2791 }
2792
2793 EXPORT_SYMBOL(blkdev_issue_flush);
2794
2795 static void drive_stat_acct(struct request *rq, int new_io)
2796 {
2797         int rw = rq_data_dir(rq);
2798
2799         if (!blk_fs_request(rq) || !rq->rq_disk)
2800                 return;
2801
2802         if (!new_io) {
2803                 __disk_stat_inc(rq->rq_disk, merges[rw]);
2804         } else {
2805                 disk_round_stats(rq->rq_disk);
2806                 rq->rq_disk->in_flight++;
2807         }
2808 }
2809
2810 /*
2811  * add-request adds a request to the linked list.
2812  * queue lock is held and interrupts disabled, as we muck with the
2813  * request queue list.
2814  */
2815 static inline void add_request(struct request_queue * q, struct request * req)
2816 {
2817         drive_stat_acct(req, 1);
2818
2819         /*
2820          * elevator indicated where it wants this request to be
2821          * inserted at elevator_merge time
2822          */
2823         __elv_add_request(q, req, ELEVATOR_INSERT_SORT, 0);
2824 }
2825  
2826 /*
2827  * disk_round_stats()   - Round off the performance stats on a struct
2828  * disk_stats.
2829  *
2830  * The average IO queue length and utilisation statistics are maintained
2831  * by observing the current state of the queue length and the amount of
2832  * time it has been in this state for.
2833  *
2834  * Normally, that accounting is done on IO completion, but that can result
2835  * in more than a second's worth of IO being accounted for within any one
2836  * second, leading to >100% utilisation.  To deal with that, we call this
2837  * function to do a round-off before returning the results when reading
2838  * /proc/diskstats.  This accounts immediately for all queue usage up to
2839  * the current jiffies and restarts the counters again.
2840  */
2841 void disk_round_stats(struct gendisk *disk)
2842 {
2843         unsigned long now = jiffies;
2844
2845         if (now == disk->stamp)
2846                 return;
2847
2848         if (disk->in_flight) {
2849                 __disk_stat_add(disk, time_in_queue,
2850                                 disk->in_flight * (now - disk->stamp));
2851                 __disk_stat_add(disk, io_ticks, (now - disk->stamp));
2852         }
2853         disk->stamp = now;
2854 }
2855
2856 EXPORT_SYMBOL_GPL(disk_round_stats);
2857
2858 /*
2859  * queue lock must be held
2860  */
2861 void __blk_put_request(struct request_queue *q, struct request *req)
2862 {
2863         if (unlikely(!q))
2864                 return;
2865         if (unlikely(--req->ref_count))
2866                 return;
2867
2868         elv_completed_request(q, req);
2869
2870         /*
2871          * Request may not have originated from ll_rw_blk. if not,
2872          * it didn't come out of our reserved rq pools
2873          */
2874         if (req->cmd_flags & REQ_ALLOCED) {
2875                 int rw = rq_data_dir(req);
2876                 int priv = req->cmd_flags & REQ_ELVPRIV;
2877
2878                 BUG_ON(!list_empty(&req->queuelist));
2879                 BUG_ON(!hlist_unhashed(&req->hash));
2880
2881                 blk_free_request(q, req);
2882                 freed_request(q, rw, priv);
2883         }
2884 }
2885
2886 EXPORT_SYMBOL_GPL(__blk_put_request);
2887
2888 void blk_put_request(struct request *req)
2889 {
2890         unsigned long flags;
2891         struct request_queue *q = req->q;
2892
2893         /*
2894          * Gee, IDE calls in w/ NULL q.  Fix IDE and remove the
2895          * following if (q) test.
2896          */
2897         if (q) {
2898                 spin_lock_irqsave(q->queue_lock, flags);
2899                 __blk_put_request(q, req);
2900                 spin_unlock_irqrestore(q->queue_lock, flags);
2901         }
2902 }
2903
2904 EXPORT_SYMBOL(blk_put_request);
2905
2906 /**
2907  * blk_end_sync_rq - executes a completion event on a request
2908  * @rq: request to complete
2909  * @error: end io status of the request
2910  */
2911 void blk_end_sync_rq(struct request *rq, int error)
2912 {
2913         struct completion *waiting = rq->end_io_data;
2914
2915         rq->end_io_data = NULL;
2916         __blk_put_request(rq->q, rq);
2917
2918         /*
2919          * complete last, if this is a stack request the process (and thus
2920          * the rq pointer) could be invalid right after this complete()
2921          */
2922         complete(waiting);
2923 }
2924 EXPORT_SYMBOL(blk_end_sync_rq);
2925
2926 /*
2927  * Has to be called with the request spinlock acquired
2928  */
2929 static int attempt_merge(struct request_queue *q, struct request *req,
2930                           struct request *next)
2931 {
2932         if (!rq_mergeable(req) || !rq_mergeable(next))
2933                 return 0;
2934
2935         /*
2936          * not contiguous
2937          */
2938         if (req->sector + req->nr_sectors != next->sector)
2939                 return 0;
2940
2941         if (rq_data_dir(req) != rq_data_dir(next)
2942             || req->rq_disk != next->rq_disk
2943             || next->special)
2944                 return 0;
2945
2946         /*
2947          * If we are allowed to merge, then append bio list
2948          * from next to rq and release next. merge_requests_fn
2949          * will have updated segment counts, update sector
2950          * counts here.
2951          */
2952         if (!ll_merge_requests_fn(q, req, next))
2953                 return 0;
2954
2955         /*
2956          * At this point we have either done a back merge
2957          * or front merge. We need the smaller start_time of
2958          * the merged requests to be the current request
2959          * for accounting purposes.
2960          */
2961         if (time_after(req->start_time, next->start_time))
2962                 req->start_time = next->start_time;
2963
2964         req->biotail->bi_next = next->bio;
2965         req->biotail = next->biotail;
2966
2967         req->nr_sectors = req->hard_nr_sectors += next->hard_nr_sectors;
2968
2969         elv_merge_requests(q, req, next);
2970
2971         if (req->rq_disk) {
2972                 disk_round_stats(req->rq_disk);
2973                 req->rq_disk->in_flight--;
2974         }
2975
2976         req->ioprio = ioprio_best(req->ioprio, next->ioprio);
2977
2978         __blk_put_request(q, next);
2979         return 1;
2980 }
2981
2982 static inline int attempt_back_merge(struct request_queue *q,
2983                                      struct request *rq)
2984 {
2985         struct request *next = elv_latter_request(q, rq);
2986
2987         if (next)
2988                 return attempt_merge(q, rq, next);
2989
2990         return 0;
2991 }
2992
2993 static inline int attempt_front_merge(struct request_queue *q,
2994                                       struct request *rq)
2995 {
2996         struct request *prev = elv_former_request(q, rq);
2997
2998         if (prev)
2999                 return attempt_merge(q, prev, rq);
3000
3001         return 0;
3002 }
3003
3004 static void init_request_from_bio(struct request *req, struct bio *bio)
3005 {
3006         req->cmd_type = REQ_TYPE_FS;
3007
3008         /*
3009          * inherit FAILFAST from bio (for read-ahead, and explicit FAILFAST)
3010          */
3011         if (bio_rw_ahead(bio) || bio_failfast(bio))
3012                 req->cmd_flags |= REQ_FAILFAST;
3013
3014         /*
3015          * REQ_BARRIER implies no merging, but lets make it explicit
3016          */
3017         if (unlikely(bio_barrier(bio)))
3018                 req->cmd_flags |= (REQ_HARDBARRIER | REQ_NOMERGE);
3019
3020         if (bio_sync(bio))
3021                 req->cmd_flags |= REQ_RW_SYNC;
3022         if (bio_rw_meta(bio))
3023                 req->cmd_flags |= REQ_RW_META;
3024
3025         req->errors = 0;
3026         req->hard_sector = req->sector = bio->bi_sector;
3027         req->ioprio = bio_prio(bio);
3028         req->start_time = jiffies;
3029         blk_rq_bio_prep(req->q, req, bio);
3030 }
3031
3032 static int __make_request(struct request_queue *q, struct bio *bio)
3033 {
3034         struct request *req;
3035         int el_ret, nr_sectors, barrier, err;
3036         const unsigned short prio = bio_prio(bio);
3037         const int sync = bio_sync(bio);
3038         int rw_flags;
3039
3040         nr_sectors = bio_sectors(bio);
3041
3042         /*
3043          * low level driver can indicate that it wants pages above a
3044          * certain limit bounced to low memory (ie for highmem, or even
3045          * ISA dma in theory)
3046          */
3047         blk_queue_bounce(q, &bio);
3048
3049         barrier = bio_barrier(bio);
3050         if (unlikely(barrier) && (q->next_ordered == QUEUE_ORDERED_NONE)) {
3051                 err = -EOPNOTSUPP;
3052                 goto end_io;
3053         }
3054
3055         spin_lock_irq(q->queue_lock);
3056
3057         if (unlikely(barrier) || elv_queue_empty(q))
3058                 goto get_rq;
3059
3060         el_ret = elv_merge(q, &req, bio);
3061         switch (el_ret) {
3062                 case ELEVATOR_BACK_MERGE:
3063                         BUG_ON(!rq_mergeable(req));
3064
3065                         if (!ll_back_merge_fn(q, req, bio))
3066                                 break;
3067
3068                         blk_add_trace_bio(q, bio, BLK_TA_BACKMERGE);
3069
3070                         req->biotail->bi_next = bio;
3071                         req->biotail = bio;
3072                         req->nr_sectors = req->hard_nr_sectors += nr_sectors;
3073                         req->ioprio = ioprio_best(req->ioprio, prio);
3074                         drive_stat_acct(req, 0);
3075                         if (!attempt_back_merge(q, req))
3076                                 elv_merged_request(q, req, el_ret);
3077                         goto out;
3078
3079                 case ELEVATOR_FRONT_MERGE:
3080                         BUG_ON(!rq_mergeable(req));
3081
3082                         if (!ll_front_merge_fn(q, req, bio))
3083                                 break;
3084
3085                         blk_add_trace_bio(q, bio, BLK_TA_FRONTMERGE);
3086
3087                         bio->bi_next = req->bio;
3088                         req->bio = bio;
3089
3090                         /*
3091                          * may not be valid. if the low level driver said
3092                          * it didn't need a bounce buffer then it better
3093                          * not touch req->buffer either...
3094                          */
3095                         req->buffer = bio_data(bio);
3096                         req->current_nr_sectors = bio_cur_sectors(bio);
3097                         req->hard_cur_sectors = req->current_nr_sectors;
3098                         req->sector = req->hard_sector = bio->bi_sector;
3099                         req->nr_sectors = req->hard_nr_sectors += nr_sectors;
3100                         req->ioprio = ioprio_best(req->ioprio, prio);
3101                         drive_stat_acct(req, 0);
3102                         if (!attempt_front_merge(q, req))
3103                                 elv_merged_request(q, req, el_ret);
3104                         goto out;
3105
3106                 /* ELV_NO_MERGE: elevator says don't/can't merge. */
3107                 default:
3108                         ;
3109         }
3110
3111 get_rq:
3112         /*
3113          * This sync check and mask will be re-done in init_request_from_bio(),
3114          * but we need to set it earlier to expose the sync flag to the
3115          * rq allocator and io schedulers.
3116          */
3117         rw_flags = bio_data_dir(bio);
3118         if (sync)
3119                 rw_flags |= REQ_RW_SYNC;
3120
3121         /*
3122          * Grab a free request. This is might sleep but can not fail.
3123          * Returns with the queue unlocked.
3124          */
3125         req = get_request_wait(q, rw_flags, bio);
3126
3127         /*
3128          * After dropping the lock and possibly sleeping here, our request
3129          * may now be mergeable after it had proven unmergeable (above).
3130          * We don't worry about that case for efficiency. It won't happen
3131          * often, and the elevators are able to handle it.
3132          */
3133         init_request_from_bio(req, bio);
3134
3135         spin_lock_irq(q->queue_lock);
3136         if (elv_queue_empty(q))
3137                 blk_plug_device(q);
3138         add_request(q, req);
3139 out:
3140         if (sync)
3141                 __generic_unplug_device(q);
3142
3143         spin_unlock_irq(q->queue_lock);
3144         return 0;
3145
3146 end_io:
3147         bio_endio(bio, err);
3148         return 0;
3149 }
3150
3151 /*
3152  * If bio->bi_dev is a partition, remap the location
3153  */
3154 static inline void blk_partition_remap(struct bio *bio)
3155 {
3156         struct block_device *bdev = bio->bi_bdev;
3157
3158         if (bio_sectors(bio) && bdev != bdev->bd_contains) {
3159                 struct hd_struct *p = bdev->bd_part;
3160                 const int rw = bio_data_dir(bio);
3161
3162                 p->sectors[rw] += bio_sectors(bio);
3163                 p->ios[rw]++;
3164
3165                 bio->bi_sector += p->start_sect;
3166                 bio->bi_bdev = bdev->bd_contains;
3167
3168                 blk_add_trace_remap(bdev_get_queue(bio->bi_bdev), bio,
3169                                     bdev->bd_dev, bio->bi_sector,
3170                                     bio->bi_sector - p->start_sect);
3171         }
3172 }
3173
3174 static void handle_bad_sector(struct bio *bio)
3175 {
3176         char b[BDEVNAME_SIZE];
3177
3178         printk(KERN_INFO "attempt to access beyond end of device\n");
3179         printk(KERN_INFO "%s: rw=%ld, want=%Lu, limit=%Lu\n",
3180                         bdevname(bio->bi_bdev, b),
3181                         bio->bi_rw,
3182                         (unsigned long long)bio->bi_sector + bio_sectors(bio),
3183                         (long long)(bio->bi_bdev->bd_inode->i_size >> 9));
3184
3185         set_bit(BIO_EOF, &bio->bi_flags);
3186 }
3187
3188 #ifdef CONFIG_FAIL_MAKE_REQUEST
3189
3190 static DECLARE_FAULT_ATTR(fail_make_request);
3191
3192 static int __init setup_fail_make_request(char *str)
3193 {
3194         return setup_fault_attr(&fail_make_request, str);
3195 }
3196 __setup("fail_make_request=", setup_fail_make_request);
3197
3198 static int should_fail_request(struct bio *bio)
3199 {
3200         if ((bio->bi_bdev->bd_disk->flags & GENHD_FL_FAIL) ||
3201             (bio->bi_bdev->bd_part && bio->bi_bdev->bd_part->make_it_fail))
3202                 return should_fail(&fail_make_request, bio->bi_size);
3203
3204         return 0;
3205 }
3206
3207 static int __init fail_make_request_debugfs(void)
3208 {
3209         return init_fault_attr_dentries(&fail_make_request,
3210                                         "fail_make_request");
3211 }
3212
3213 late_initcall(fail_make_request_debugfs);
3214
3215 #else /* CONFIG_FAIL_MAKE_REQUEST */
3216
3217 static inline int should_fail_request(struct bio *bio)
3218 {
3219         return 0;
3220 }
3221
3222 #endif /* CONFIG_FAIL_MAKE_REQUEST */
3223
3224 /*
3225  * Check whether this bio extends beyond the end of the device.
3226  */
3227 static inline int bio_check_eod(struct bio *bio, unsigned int nr_sectors)
3228 {
3229         sector_t maxsector;
3230
3231         if (!nr_sectors)
3232                 return 0;
3233
3234         /* Test device or partition size, when known. */
3235         maxsector = bio->bi_bdev->bd_inode->i_size >> 9;
3236         if (maxsector) {
3237                 sector_t sector = bio->bi_sector;
3238
3239                 if (maxsector < nr_sectors || maxsector - nr_sectors < sector) {
3240                         /*
3241                          * This may well happen - the kernel calls bread()
3242                          * without checking the size of the device, e.g., when
3243                          * mounting a device.
3244                          */
3245                         handle_bad_sector(bio);
3246                         return 1;
3247                 }
3248         }
3249
3250         return 0;
3251 }
3252
3253 /**
3254  * generic_make_request: hand a buffer to its device driver for I/O
3255  * @bio:  The bio describing the location in memory and on the device.
3256  *
3257  * generic_make_request() is used to make I/O requests of block
3258  * devices. It is passed a &struct bio, which describes the I/O that needs
3259  * to be done.
3260  *
3261  * generic_make_request() does not return any status.  The
3262  * success/failure status of the request, along with notification of
3263  * completion, is delivered asynchronously through the bio->bi_end_io
3264  * function described (one day) else where.
3265  *
3266  * The caller of generic_make_request must make sure that bi_io_vec
3267  * are set to describe the memory buffer, and that bi_dev and bi_sector are
3268  * set to describe the device address, and the
3269  * bi_end_io and optionally bi_private are set to describe how
3270  * completion notification should be signaled.
3271  *
3272  * generic_make_request and the drivers it calls may use bi_next if this
3273  * bio happens to be merged with someone else, and may change bi_dev and
3274  * bi_sector for remaps as it sees fit.  So the values of these fields
3275  * should NOT be depended on after the call to generic_make_request.
3276  */
3277 static inline void __generic_make_request(struct bio *bio)
3278 {
3279         struct request_queue *q;
3280         sector_t old_sector;
3281         int ret, nr_sectors = bio_sectors(bio);
3282         dev_t old_dev;
3283         int err = -EIO;
3284
3285         might_sleep();
3286
3287         if (bio_check_eod(bio, nr_sectors))
3288                 goto end_io;
3289
3290         /*
3291          * Resolve the mapping until finished. (drivers are
3292          * still free to implement/resolve their own stacking
3293          * by explicitly returning 0)
3294          *
3295          * NOTE: we don't repeat the blk_size check for each new device.
3296          * Stacking drivers are expected to know what they are doing.
3297          */
3298         old_sector = -1;
3299         old_dev = 0;
3300         do {
3301                 char b[BDEVNAME_SIZE];
3302
3303                 q = bdev_get_queue(bio->bi_bdev);
3304                 if (!q) {
3305                         printk(KERN_ERR
3306                                "generic_make_request: Trying to access "
3307                                 "nonexistent block-device %s (%Lu)\n",
3308                                 bdevname(bio->bi_bdev, b),
3309                                 (long long) bio->bi_sector);
3310 end_io:
3311                         bio_endio(bio, err);
3312                         break;
3313                 }
3314
3315                 if (unlikely(nr_sectors > q->max_hw_sectors)) {
3316                         printk("bio too big device %s (%u > %u)\n", 
3317                                 bdevname(bio->bi_bdev, b),
3318                                 bio_sectors(bio),
3319                                 q->max_hw_sectors);
3320                         goto end_io;
3321                 }
3322
3323                 if (unlikely(test_bit(QUEUE_FLAG_DEAD, &q->queue_flags)))
3324                         goto end_io;
3325
3326                 if (should_fail_request(bio))
3327                         goto end_io;
3328
3329                 /*
3330                  * If this device has partitions, remap block n
3331                  * of partition p to block n+start(p) of the disk.
3332                  */
3333                 blk_partition_remap(bio);
3334
3335                 if (old_sector != -1)
3336                         blk_add_trace_remap(q, bio, old_dev, bio->bi_sector,
3337                                             old_sector);
3338
3339                 blk_add_trace_bio(q, bio, BLK_TA_QUEUE);
3340
3341                 old_sector = bio->bi_sector;
3342                 old_dev = bio->bi_bdev->bd_dev;
3343
3344                 if (bio_check_eod(bio, nr_sectors))
3345                         goto end_io;
3346                 if (bio_empty_barrier(bio) && !q->prepare_flush_fn) {
3347                         err = -EOPNOTSUPP;
3348                         goto end_io;
3349                 }
3350
3351                 ret = q->make_request_fn(q, bio);
3352         } while (ret);
3353 }
3354
3355 /*
3356  * We only want one ->make_request_fn to be active at a time,
3357  * else stack usage with stacked devices could be a problem.
3358  * So use current->bio_{list,tail} to keep a list of requests
3359  * submited by a make_request_fn function.
3360  * current->bio_tail is also used as a flag to say if
3361  * generic_make_request is currently active in this task or not.
3362  * If it is NULL, then no make_request is active.  If it is non-NULL,
3363  * then a make_request is active, and new requests should be added
3364  * at the tail
3365  */
3366 void generic_make_request(struct bio *bio)
3367 {
3368         if (current->bio_tail) {
3369                 /* make_request is active */
3370                 *(current->bio_tail) = bio;
3371                 bio->bi_next = NULL;
3372                 current->bio_tail = &bio->bi_next;
3373                 return;
3374         }
3375         /* following loop may be a bit non-obvious, and so deserves some
3376          * explanation.
3377          * Before entering the loop, bio->bi_next is NULL (as all callers
3378          * ensure that) so we have a list with a single bio.
3379          * We pretend that we have just taken it off a longer list, so
3380          * we assign bio_list to the next (which is NULL) and bio_tail
3381          * to &bio_list, thus initialising the bio_list of new bios to be
3382          * added.  __generic_make_request may indeed add some more bios
3383          * through a recursive call to generic_make_request.  If it
3384          * did, we find a non-NULL value in bio_list and re-enter the loop
3385          * from the top.  In this case we really did just take the bio
3386          * of the top of the list (no pretending) and so fixup bio_list and
3387          * bio_tail or bi_next, and call into __generic_make_request again.
3388          *
3389          * The loop was structured like this to make only one call to
3390          * __generic_make_request (which is important as it is large and
3391          * inlined) and to keep the structure simple.
3392          */
3393         BUG_ON(bio->bi_next);
3394         do {
3395                 current->bio_list = bio->bi_next;
3396                 if (bio->bi_next == NULL)
3397                         current->bio_tail = &current->bio_list;
3398                 else
3399                         bio->bi_next = NULL;
3400                 __generic_make_request(bio);
3401                 bio = current->bio_list;
3402         } while (bio);
3403         current->bio_tail = NULL; /* deactivate */
3404 }
3405
3406 EXPORT_SYMBOL(generic_make_request);
3407
3408 /**
3409  * submit_bio: submit a bio to the block device layer for I/O
3410  * @rw: whether to %READ or %WRITE, or maybe to %READA (read ahead)
3411  * @bio: The &struct bio which describes the I/O
3412  *
3413  * submit_bio() is very similar in purpose to generic_make_request(), and
3414  * uses that function to do most of the work. Both are fairly rough
3415  * interfaces, @bio must be presetup and ready for I/O.
3416  *
3417  */
3418 void submit_bio(int rw, struct bio *bio)
3419 {
3420         int count = bio_sectors(bio);
3421
3422         bio->bi_rw |= rw;
3423
3424         /*
3425          * If it's a regular read/write or a barrier with data attached,
3426          * go through the normal accounting stuff before submission.
3427          */
3428         if (!bio_empty_barrier(bio)) {
3429
3430                 BIO_BUG_ON(!bio->bi_size);
3431                 BIO_BUG_ON(!bio->bi_io_vec);
3432
3433                 if (rw & WRITE) {
3434                         count_vm_events(PGPGOUT, count);
3435                 } else {
3436                         task_io_account_read(bio->bi_size);
3437                         count_vm_events(PGPGIN, count);
3438                 }
3439
3440                 if (unlikely(block_dump)) {
3441                         char b[BDEVNAME_SIZE];
3442                         printk(KERN_DEBUG "%s(%d): %s block %Lu on %s\n",
3443                         current->comm, task_pid_nr(current),
3444                                 (rw & WRITE) ? "WRITE" : "READ",
3445                                 (unsigned long long)bio->bi_sector,
3446                                 bdevname(bio->bi_bdev,b));
3447                 }
3448         }
3449
3450         generic_make_request(bio);
3451 }
3452
3453 EXPORT_SYMBOL(submit_bio);
3454
3455 static void blk_recalc_rq_sectors(struct request *rq, int nsect)
3456 {
3457         if (blk_fs_request(rq)) {
3458                 rq->hard_sector += nsect;
3459                 rq->hard_nr_sectors -= nsect;
3460
3461                 /*
3462                  * Move the I/O submission pointers ahead if required.
3463                  */
3464                 if ((rq->nr_sectors >= rq->hard_nr_sectors) &&
3465                     (rq->sector <= rq->hard_sector)) {
3466                         rq->sector = rq->hard_sector;
3467                         rq->nr_sectors = rq->hard_nr_sectors;
3468                         rq->hard_cur_sectors = bio_cur_sectors(rq->bio);
3469                         rq->current_nr_sectors = rq->hard_cur_sectors;
3470                         rq->buffer = bio_data(rq->bio);
3471                 }
3472
3473                 /*
3474                  * if total number of sectors is less than the first segment
3475                  * size, something has gone terribly wrong
3476                  */
3477                 if (rq->nr_sectors < rq->current_nr_sectors) {
3478                         printk("blk: request botched\n");
3479                         rq->nr_sectors = rq->current_nr_sectors;
3480                 }
3481         }
3482 }
3483
3484 /**
3485  * __end_that_request_first - end I/O on a request
3486  * @req:      the request being processed
3487  * @error:    0 for success, < 0 for error
3488  * @nr_bytes: number of bytes to complete
3489  *
3490  * Description:
3491  *     Ends I/O on a number of bytes attached to @req, and sets it up
3492  *     for the next range of segments (if any) in the cluster.
3493  *
3494  * Return:
3495  *     0 - we are done with this request, call end_that_request_last()
3496  *     1 - still buffers pending for this request
3497  **/
3498 static int __end_that_request_first(struct request *req, int error,
3499                                     int nr_bytes)
3500 {
3501         int total_bytes, bio_nbytes, next_idx = 0;
3502         struct bio *bio;
3503
3504         blk_add_trace_rq(req->q, req, BLK_TA_COMPLETE);
3505
3506         /*
3507          * for a REQ_BLOCK_PC request, we want to carry any eventual
3508          * sense key with us all the way through
3509          */
3510         if (!blk_pc_request(req))
3511                 req->errors = 0;
3512
3513         if (error) {
3514                 if (blk_fs_request(req) && !(req->cmd_flags & REQ_QUIET))
3515                         printk("end_request: I/O error, dev %s, sector %llu\n",
3516                                 req->rq_disk ? req->rq_disk->disk_name : "?",
3517                                 (unsigned long long)req->sector);
3518         }
3519
3520         if (blk_fs_request(req) && req->rq_disk) {
3521                 const int rw = rq_data_dir(req);
3522
3523                 disk_stat_add(req->rq_disk, sectors[rw], nr_bytes >> 9);
3524         }
3525
3526         total_bytes = bio_nbytes = 0;
3527         while ((bio = req->bio) != NULL) {
3528                 int nbytes;
3529
3530                 /*
3531                  * For an empty barrier request, the low level driver must
3532                  * store a potential error location in ->sector. We pass
3533                  * that back up in ->bi_sector.
3534                  */
3535                 if (blk_empty_barrier(req))
3536                         bio->bi_sector = req->sector;
3537
3538                 if (nr_bytes >= bio->bi_size) {
3539                         req->bio = bio->bi_next;
3540                         nbytes = bio->bi_size;
3541                         req_bio_endio(req, bio, nbytes, error);
3542                         next_idx = 0;
3543                         bio_nbytes = 0;
3544                 } else {
3545                         int idx = bio->bi_idx + next_idx;
3546
3547                         if (unlikely(bio->bi_idx >= bio->bi_vcnt)) {
3548                                 blk_dump_rq_flags(req, "__end_that");
3549                                 printk("%s: bio idx %d >= vcnt %d\n",
3550                                                 __FUNCTION__,
3551                                                 bio->bi_idx, bio->bi_vcnt);
3552                                 break;
3553                         }
3554
3555                         nbytes = bio_iovec_idx(bio, idx)->bv_len;
3556                         BIO_BUG_ON(nbytes > bio->bi_size);
3557
3558                         /*
3559                          * not a complete bvec done
3560                          */
3561                         if (unlikely(nbytes > nr_bytes)) {
3562                                 bio_nbytes += nr_bytes;
3563                                 total_bytes += nr_bytes;
3564                                 break;
3565                         }
3566
3567                         /*
3568                          * advance to the next vector
3569                          */
3570                         next_idx++;
3571                         bio_nbytes += nbytes;
3572                 }
3573
3574                 total_bytes += nbytes;
3575                 nr_bytes -= nbytes;
3576
3577                 if ((bio = req->bio)) {
3578                         /*
3579                          * end more in this run, or just return 'not-done'
3580                          */
3581                         if (unlikely(nr_bytes <= 0))
3582                                 break;
3583                 }
3584         }
3585
3586         /*
3587          * completely done
3588          */
3589         if (!req->bio)
3590                 return 0;
3591
3592         /*
3593          * if the request wasn't completed, update state
3594          */
3595         if (bio_nbytes) {
3596                 req_bio_endio(req, bio, bio_nbytes, error);
3597                 bio->bi_idx += next_idx;
3598                 bio_iovec(bio)->bv_offset += nr_bytes;
3599                 bio_iovec(bio)->bv_len -= nr_bytes;
3600         }
3601
3602         blk_recalc_rq_sectors(req, total_bytes >> 9);
3603         blk_recalc_rq_segments(req);
3604         return 1;
3605 }
3606
3607 /*
3608  * splice the completion data to a local structure and hand off to
3609  * process_completion_queue() to complete the requests
3610  */
3611 static void blk_done_softirq(struct softirq_action *h)
3612 {
3613         struct list_head *cpu_list, local_list;
3614
3615         local_irq_disable();
3616         cpu_list = &__get_cpu_var(blk_cpu_done);
3617         list_replace_init(cpu_list, &local_list);
3618         local_irq_enable();
3619
3620         while (!list_empty(&local_list)) {
3621                 struct request *rq = list_entry(local_list.next, struct request, donelist);
3622
3623                 list_del_init(&rq->donelist);
3624                 rq->q->softirq_done_fn(rq);
3625         }
3626 }
3627
3628 static int __cpuinit blk_cpu_notify(struct notifier_block *self, unsigned long action,
3629                           void *hcpu)
3630 {
3631         /*
3632          * If a CPU goes away, splice its entries to the current CPU
3633          * and trigger a run of the softirq
3634          */
3635         if (action == CPU_DEAD || action == CPU_DEAD_FROZEN) {
3636                 int cpu = (unsigned long) hcpu;
3637
3638                 local_irq_disable();
3639                 list_splice_init(&per_cpu(blk_cpu_done, cpu),
3640                                  &__get_cpu_var(blk_cpu_done));
3641                 raise_softirq_irqoff(BLOCK_SOFTIRQ);
3642                 local_irq_enable();
3643         }
3644
3645         return NOTIFY_OK;
3646 }
3647
3648
3649 static struct notifier_block blk_cpu_notifier __cpuinitdata = {
3650         .notifier_call  = blk_cpu_notify,
3651 };
3652
3653 /**
3654  * blk_complete_request - end I/O on a request
3655  * @req:      the request being processed
3656  *
3657  * Description:
3658  *     Ends all I/O on a request. It does not handle partial completions,
3659  *     unless the driver actually implements this in its completion callback
3660  *     through requeueing. The actual completion happens out-of-order,
3661  *     through a softirq handler. The user must have registered a completion
3662  *     callback through blk_queue_softirq_done().
3663  **/
3664
3665 void blk_complete_request(struct request *req)
3666 {
3667         struct list_head *cpu_list;
3668         unsigned long flags;
3669
3670         BUG_ON(!req->q->softirq_done_fn);
3671                 
3672         local_irq_save(flags);
3673
3674         cpu_list = &__get_cpu_var(blk_cpu_done);
3675         list_add_tail(&req->donelist, cpu_list);
3676         raise_softirq_irqoff(BLOCK_SOFTIRQ);
3677
3678         local_irq_restore(flags);
3679 }
3680
3681 EXPORT_SYMBOL(blk_complete_request);
3682         
3683 /*
3684  * queue lock must be held
3685  */
3686 static void end_that_request_last(struct request *req, int error)
3687 {
3688         struct gendisk *disk = req->rq_disk;
3689
3690         if (blk_rq_tagged(req))
3691                 blk_queue_end_tag(req->q, req);
3692
3693         if (blk_queued_rq(req))
3694                 blkdev_dequeue_request(req);
3695
3696         if (unlikely(laptop_mode) && blk_fs_request(req))
3697                 laptop_io_completion();
3698
3699         /*
3700          * Account IO completion.  bar_rq isn't accounted as a normal
3701          * IO on queueing nor completion.  Accounting the containing
3702          * request is enough.
3703          */
3704         if (disk && blk_fs_request(req) && req != &req->q->bar_rq) {
3705                 unsigned long duration = jiffies - req->start_time;
3706                 const int rw = rq_data_dir(req);
3707
3708                 __disk_stat_inc(disk, ios[rw]);
3709                 __disk_stat_add(disk, ticks[rw], duration);
3710                 disk_round_stats(disk);
3711                 disk->in_flight--;
3712         }
3713
3714         if (req->end_io)
3715                 req->end_io(req, error);
3716         else {
3717                 if (blk_bidi_rq(req))
3718                         __blk_put_request(req->next_rq->q, req->next_rq);
3719
3720                 __blk_put_request(req->q, req);
3721         }
3722 }
3723
3724 static inline void __end_request(struct request *rq, int uptodate,
3725                                  unsigned int nr_bytes)
3726 {
3727         int error = 0;
3728
3729         if (uptodate <= 0)
3730                 error = uptodate ? uptodate : -EIO;
3731
3732         __blk_end_request(rq, error, nr_bytes);
3733 }
3734
3735 /**
3736  * blk_rq_bytes - Returns bytes left to complete in the entire request
3737  **/
3738 unsigned int blk_rq_bytes(struct request *rq)
3739 {
3740         if (blk_fs_request(rq))
3741                 return rq->hard_nr_sectors << 9;
3742
3743         return rq->data_len;
3744 }
3745 EXPORT_SYMBOL_GPL(blk_rq_bytes);
3746
3747 /**
3748  * blk_rq_cur_bytes - Returns bytes left to complete in the current segment
3749  **/
3750 unsigned int blk_rq_cur_bytes(struct request *rq)
3751 {
3752         if (blk_fs_request(rq))
3753                 return rq->current_nr_sectors << 9;
3754
3755         if (rq->bio)
3756                 return rq->bio->bi_size;
3757
3758         return rq->data_len;
3759 }
3760 EXPORT_SYMBOL_GPL(blk_rq_cur_bytes);
3761
3762 /**
3763  * end_queued_request - end all I/O on a queued request
3764  * @rq:         the request being processed
3765  * @uptodate:   error value or 0/1 uptodate flag
3766  *
3767  * Description:
3768  *     Ends all I/O on a request, and removes it from the block layer queues.
3769  *     Not suitable for normal IO completion, unless the driver still has
3770  *     the request attached to the block layer.
3771  *
3772  **/
3773 void end_queued_request(struct request *rq, int uptodate)
3774 {
3775         __end_request(rq, uptodate, blk_rq_bytes(rq));
3776 }
3777 EXPORT_SYMBOL(end_queued_request);
3778
3779 /**
3780  * end_dequeued_request - end all I/O on a dequeued request
3781  * @rq:         the request being processed
3782  * @uptodate:   error value or 0/1 uptodate flag
3783  *
3784  * Description:
3785  *     Ends all I/O on a request. The request must already have been
3786  *     dequeued using blkdev_dequeue_request(), as is normally the case
3787  *     for most drivers.
3788  *
3789  **/
3790 void end_dequeued_request(struct request *rq, int uptodate)
3791 {
3792         __end_request(rq, uptodate, blk_rq_bytes(rq));
3793 }
3794 EXPORT_SYMBOL(end_dequeued_request);
3795
3796
3797 /**
3798  * end_request - end I/O on the current segment of the request
3799  * @req:        the request being processed
3800  * @uptodate:   error value or 0/1 uptodate flag
3801  *
3802  * Description:
3803  *     Ends I/O on the current segment of a request. If that is the only
3804  *     remaining segment, the request is also completed and freed.
3805  *
3806  *     This is a remnant of how older block drivers handled IO completions.
3807  *     Modern drivers typically end IO on the full request in one go, unless
3808  *     they have a residual value to account for. For that case this function
3809  *     isn't really useful, unless the residual just happens to be the
3810  *     full current segment. In other words, don't use this function in new
3811  *     code. Either use end_request_completely(), or the
3812  *     end_that_request_chunk() (along with end_that_request_last()) for
3813  *     partial completions.
3814  *
3815  **/
3816 void end_request(struct request *req, int uptodate)
3817 {
3818         __end_request(req, uptodate, req->hard_cur_sectors << 9);
3819 }
3820 EXPORT_SYMBOL(end_request);
3821
3822 /**
3823  * blk_end_io - Generic end_io function to complete a request.
3824  * @rq:           the request being processed
3825  * @error:        0 for success, < 0 for error
3826  * @nr_bytes:     number of bytes to complete @rq
3827  * @bidi_bytes:   number of bytes to complete @rq->next_rq
3828  * @drv_callback: function called between completion of bios in the request
3829  *                and completion of the request.
3830  *                If the callback returns non 0, this helper returns without
3831  *                completion of the request.
3832  *
3833  * Description:
3834  *     Ends I/O on a number of bytes attached to @rq and @rq->next_rq.
3835  *     If @rq has leftover, sets it up for the next range of segments.
3836  *
3837  * Return:
3838  *     0 - we are done with this request
3839  *     1 - this request is not freed yet, it still has pending buffers.
3840  **/
3841 static int blk_end_io(struct request *rq, int error, int nr_bytes,
3842                       int bidi_bytes, int (drv_callback)(struct request *))
3843 {
3844         struct request_queue *q = rq->q;
3845         unsigned long flags = 0UL;
3846
3847         if (blk_fs_request(rq) || blk_pc_request(rq)) {
3848                 if (__end_that_request_first(rq, error, nr_bytes))
3849                         return 1;
3850
3851                 /* Bidi request must be completed as a whole */
3852                 if (blk_bidi_rq(rq) &&
3853                     __end_that_request_first(rq->next_rq, error, bidi_bytes))
3854                         return 1;
3855         }
3856
3857         /* Special feature for tricky drivers */
3858         if (drv_callback && drv_callback(rq))
3859                 return 1;
3860
3861         add_disk_randomness(rq->rq_disk);
3862
3863         spin_lock_irqsave(q->queue_lock, flags);
3864         end_that_request_last(rq, error);
3865         spin_unlock_irqrestore(q->queue_lock, flags);
3866
3867         return 0;
3868 }
3869
3870 /**
3871  * blk_end_request - Helper function for drivers to complete the request.
3872  * @rq:       the request being processed
3873  * @error:    0 for success, < 0 for error
3874  * @nr_bytes: number of bytes to complete
3875  *
3876  * Description:
3877  *     Ends I/O on a number of bytes attached to @rq.
3878  *     If @rq has leftover, sets it up for the next range of segments.
3879  *
3880  * Return:
3881  *     0 - we are done with this request
3882  *     1 - still buffers pending for this request
3883  **/
3884 int blk_end_request(struct request *rq, int error, int nr_bytes)
3885 {
3886         return blk_end_io(rq, error, nr_bytes, 0, NULL);
3887 }
3888 EXPORT_SYMBOL_GPL(blk_end_request);
3889
3890 /**
3891  * __blk_end_request - Helper function for drivers to complete the request.
3892  * @rq:       the request being processed
3893  * @error:    0 for success, < 0 for error
3894  * @nr_bytes: number of bytes to complete
3895  *
3896  * Description:
3897  *     Must be called with queue lock held unlike blk_end_request().
3898  *
3899  * Return:
3900  *     0 - we are done with this request
3901  *     1 - still buffers pending for this request
3902  **/
3903 int __blk_end_request(struct request *rq, int error, int nr_bytes)
3904 {
3905         if (blk_fs_request(rq) || blk_pc_request(rq)) {
3906                 if (__end_that_request_first(rq, error, nr_bytes))
3907                         return 1;
3908         }
3909
3910         add_disk_randomness(rq->rq_disk);
3911
3912         end_that_request_last(rq, error);
3913
3914         return 0;
3915 }
3916 EXPORT_SYMBOL_GPL(__blk_end_request);
3917
3918 /**
3919  * blk_end_bidi_request - Helper function for drivers to complete bidi request.
3920  * @rq:         the bidi request being processed
3921  * @error:      0 for success, < 0 for error
3922  * @nr_bytes:   number of bytes to complete @rq
3923  * @bidi_bytes: number of bytes to complete @rq->next_rq
3924  *
3925  * Description:
3926  *     Ends I/O on a number of bytes attached to @rq and @rq->next_rq.
3927  *
3928  * Return:
3929  *     0 - we are done with this request
3930  *     1 - still buffers pending for this request
3931  **/
3932 int blk_end_bidi_request(struct request *rq, int error, int nr_bytes,
3933                          int bidi_bytes)
3934 {
3935         return blk_end_io(rq, error, nr_bytes, bidi_bytes, NULL);
3936 }
3937 EXPORT_SYMBOL_GPL(blk_end_bidi_request);
3938
3939 /**
3940  * blk_end_request_callback - Special helper function for tricky drivers
3941  * @rq:           the request being processed
3942  * @error:        0 for success, < 0 for error
3943  * @nr_bytes:     number of bytes to complete
3944  * @drv_callback: function called between completion of bios in the request
3945  *                and completion of the request.
3946  *                If the callback returns non 0, this helper returns without
3947  *                completion of the request.
3948  *
3949  * Description:
3950  *     Ends I/O on a number of bytes attached to @rq.
3951  *     If @rq has leftover, sets it up for the next range of segments.
3952  *
3953  *     This special helper function is used only for existing tricky drivers.
3954  *     (e.g. cdrom_newpc_intr() of ide-cd)
3955  *     This interface will be removed when such drivers are rewritten.
3956  *     Don't use this interface in other places anymore.
3957  *
3958  * Return:
3959  *     0 - we are done with this request
3960  *     1 - this request is not freed yet.
3961  *         this request still has pending buffers or
3962  *         the driver doesn't want to finish this request yet.
3963  **/
3964 int blk_end_request_callback(struct request *rq, int error, int nr_bytes,
3965                              int (drv_callback)(struct request *))
3966 {
3967         return blk_end_io(rq, error, nr_bytes, 0, drv_callback);
3968 }
3969 EXPORT_SYMBOL_GPL(blk_end_request_callback);
3970
3971 static void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
3972                             struct bio *bio)
3973 {
3974         /* first two bits are identical in rq->cmd_flags and bio->bi_rw */
3975         rq->cmd_flags |= (bio->bi_rw & 3);
3976
3977         rq->nr_phys_segments = bio_phys_segments(q, bio);
3978         rq->nr_hw_segments = bio_hw_segments(q, bio);
3979         rq->current_nr_sectors = bio_cur_sectors(bio);
3980         rq->hard_cur_sectors = rq->current_nr_sectors;
3981         rq->hard_nr_sectors = rq->nr_sectors = bio_sectors(bio);
3982         rq->buffer = bio_data(bio);
3983         rq->data_len = bio->bi_size;
3984
3985         rq->bio = rq->biotail = bio;
3986
3987         if (bio->bi_bdev)
3988                 rq->rq_disk = bio->bi_bdev->bd_disk;
3989 }
3990
3991 int kblockd_schedule_work(struct work_struct *work)
3992 {
3993         return queue_work(kblockd_workqueue, work);
3994 }
3995
3996 EXPORT_SYMBOL(kblockd_schedule_work);
3997
3998 void kblockd_flush_work(struct work_struct *work)
3999 {
4000         cancel_work_sync(work);
4001 }
4002 EXPORT_SYMBOL(kblockd_flush_work);
4003
4004 int __init blk_dev_init(void)
4005 {
4006         int i;
4007
4008         kblockd_workqueue = create_workqueue("kblockd");
4009         if (!kblockd_workqueue)
4010                 panic("Failed to create kblockd\n");
4011
4012         request_cachep = kmem_cache_create("blkdev_requests",
4013                         sizeof(struct request), 0, SLAB_PANIC, NULL);
4014
4015         requestq_cachep = kmem_cache_create("blkdev_queue",
4016                         sizeof(struct request_queue), 0, SLAB_PANIC, NULL);
4017
4018         iocontext_cachep = kmem_cache_create("blkdev_ioc",
4019                         sizeof(struct io_context), 0, SLAB_PANIC, NULL);
4020
4021         for_each_possible_cpu(i)
4022                 INIT_LIST_HEAD(&per_cpu(blk_cpu_done, i));
4023
4024         open_softirq(BLOCK_SOFTIRQ, blk_done_softirq, NULL);
4025         register_hotcpu_notifier(&blk_cpu_notifier);
4026
4027         blk_max_low_pfn = max_low_pfn - 1;
4028         blk_max_pfn = max_pfn - 1;
4029
4030         return 0;
4031 }
4032
4033 static void cfq_dtor(struct io_context *ioc)
4034 {
4035         struct cfq_io_context *cic[1];
4036         int r;
4037
4038         /*
4039          * We don't have a specific key to lookup with, so use the gang
4040          * lookup to just retrieve the first item stored. The cfq exit
4041          * function will iterate the full tree, so any member will do.
4042          */
4043         r = radix_tree_gang_lookup(&ioc->radix_root, (void **) cic, 0, 1);
4044         if (r > 0)
4045                 cic[0]->dtor(ioc);
4046 }
4047
4048 /*
4049  * IO Context helper functions. put_io_context() returns 1 if there are no
4050  * more users of this io context, 0 otherwise.
4051  */
4052 int put_io_context(struct io_context *ioc)
4053 {
4054         if (ioc == NULL)
4055                 return 1;
4056
4057         BUG_ON(atomic_read(&ioc->refcount) == 0);
4058
4059         if (atomic_dec_and_test(&ioc->refcount)) {
4060                 rcu_read_lock();
4061                 if (ioc->aic && ioc->aic->dtor)
4062                         ioc->aic->dtor(ioc->aic);
4063                 rcu_read_unlock();
4064                 cfq_dtor(ioc);
4065
4066                 kmem_cache_free(iocontext_cachep, ioc);
4067                 return 1;
4068         }
4069         return 0;
4070 }
4071 EXPORT_SYMBOL(put_io_context);
4072
4073 static void cfq_exit(struct io_context *ioc)
4074 {
4075         struct cfq_io_context *cic[1];
4076         int r;
4077
4078         rcu_read_lock();
4079         /*
4080          * See comment for cfq_dtor()
4081          */
4082         r = radix_tree_gang_lookup(&ioc->radix_root, (void **) cic, 0, 1);
4083         rcu_read_unlock();
4084
4085         if (r > 0)
4086                 cic[0]->exit(ioc);
4087 }
4088
4089 /* Called by the exitting task */
4090 void exit_io_context(void)
4091 {
4092         struct io_context *ioc;
4093
4094         task_lock(current);
4095         ioc = current->io_context;
4096         current->io_context = NULL;
4097         task_unlock(current);
4098
4099         if (atomic_dec_and_test(&ioc->nr_tasks)) {
4100                 if (ioc->aic && ioc->aic->exit)
4101                         ioc->aic->exit(ioc->aic);
4102                 cfq_exit(ioc);
4103
4104                 put_io_context(ioc);
4105         }
4106 }
4107
4108 struct io_context *alloc_io_context(gfp_t gfp_flags, int node)
4109 {
4110         struct io_context *ret;
4111
4112         ret = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node);
4113         if (ret) {
4114                 atomic_set(&ret->refcount, 1);
4115                 atomic_set(&ret->nr_tasks, 1);
4116                 spin_lock_init(&ret->lock);
4117                 ret->ioprio_changed = 0;
4118                 ret->ioprio = 0;
4119                 ret->last_waited = jiffies; /* doesn't matter... */
4120                 ret->nr_batch_requests = 0; /* because this is 0 */
4121                 ret->aic = NULL;
4122                 INIT_RADIX_TREE(&ret->radix_root, GFP_ATOMIC | __GFP_HIGH);
4123                 ret->ioc_data = NULL;
4124         }
4125
4126         return ret;
4127 }
4128
4129 /*
4130  * If the current task has no IO context then create one and initialise it.
4131  * Otherwise, return its existing IO context.
4132  *
4133  * This returned IO context doesn't have a specifically elevated refcount,
4134  * but since the current task itself holds a reference, the context can be
4135  * used in general code, so long as it stays within `current` context.
4136  */
4137 static struct io_context *current_io_context(gfp_t gfp_flags, int node)
4138 {
4139         struct task_struct *tsk = current;
4140         struct io_context *ret;
4141
4142         ret = tsk->io_context;
4143         if (likely(ret))
4144                 return ret;
4145
4146         ret = alloc_io_context(gfp_flags, node);
4147         if (ret) {
4148                 /* make sure set_task_ioprio() sees the settings above */
4149                 smp_wmb();
4150                 tsk->io_context = ret;
4151         }
4152
4153         return ret;
4154 }
4155
4156 /*
4157  * If the current task has no IO context then create one and initialise it.
4158  * If it does have a context, take a ref on it.
4159  *
4160  * This is always called in the context of the task which submitted the I/O.
4161  */
4162 struct io_context *get_io_context(gfp_t gfp_flags, int node)
4163 {
4164         struct io_context *ret = NULL;
4165
4166         /*
4167          * Check for unlikely race with exiting task. ioc ref count is
4168          * zero when ioc is being detached.
4169          */
4170         do {
4171                 ret = current_io_context(gfp_flags, node);
4172                 if (unlikely(!ret))
4173                         break;
4174         } while (!atomic_inc_not_zero(&ret->refcount));
4175
4176         return ret;
4177 }
4178 EXPORT_SYMBOL(get_io_context);
4179
4180 void copy_io_context(struct io_context **pdst, struct io_context **psrc)
4181 {
4182         struct io_context *src = *psrc;
4183         struct io_context *dst = *pdst;
4184
4185         if (src) {
4186                 BUG_ON(atomic_read(&src->refcount) == 0);
4187                 atomic_inc(&src->refcount);
4188                 put_io_context(dst);
4189                 *pdst = src;
4190         }
4191 }
4192 EXPORT_SYMBOL(copy_io_context);
4193
4194 void swap_io_context(struct io_context **ioc1, struct io_context **ioc2)
4195 {
4196         struct io_context *temp;
4197         temp = *ioc1;
4198         *ioc1 = *ioc2;
4199         *ioc2 = temp;
4200 }
4201 EXPORT_SYMBOL(swap_io_context);
4202
4203 /*
4204  * sysfs parts below
4205  */
4206 struct queue_sysfs_entry {
4207         struct attribute attr;
4208         ssize_t (*show)(struct request_queue *, char *);
4209         ssize_t (*store)(struct request_queue *, const char *, size_t);
4210 };
4211
4212 static ssize_t
4213 queue_var_show(unsigned int var, char *page)
4214 {
4215         return sprintf(page, "%d\n", var);
4216 }
4217
4218 static ssize_t
4219 queue_var_store(unsigned long *var, const char *page, size_t count)
4220 {
4221         char *p = (char *) page;
4222
4223         *var = simple_strtoul(p, &p, 10);
4224         return count;
4225 }
4226
4227 static ssize_t queue_requests_show(struct request_queue *q, char *page)
4228 {
4229         return queue_var_show(q->nr_requests, (page));
4230 }
4231
4232 static ssize_t
4233 queue_requests_store(struct request_queue *q, const char *page, size_t count)
4234 {
4235         struct request_list *rl = &q->rq;
4236         unsigned long nr;
4237         int ret = queue_var_store(&nr, page, count);
4238         if (nr < BLKDEV_MIN_RQ)
4239                 nr = BLKDEV_MIN_RQ;
4240
4241         spin_lock_irq(q->queue_lock);
4242         q->nr_requests = nr;
4243         blk_queue_congestion_threshold(q);
4244
4245         if (rl->count[READ] >= queue_congestion_on_threshold(q))
4246                 blk_set_queue_congested(q, READ);
4247         else if (rl->count[READ] < queue_congestion_off_threshold(q))
4248                 blk_clear_queue_congested(q, READ);
4249
4250         if (rl->count[WRITE] >= queue_congestion_on_threshold(q))
4251                 blk_set_queue_congested(q, WRITE);
4252         else if (rl->count[WRITE] < queue_congestion_off_threshold(q))
4253                 blk_clear_queue_congested(q, WRITE);
4254
4255         if (rl->count[READ] >= q->nr_requests) {
4256                 blk_set_queue_full(q, READ);
4257         } else if (rl->count[READ]+1 <= q->nr_requests) {
4258                 blk_clear_queue_full(q, READ);
4259                 wake_up(&rl->wait[READ]);
4260         }
4261
4262         if (rl->count[WRITE] >= q->nr_requests) {
4263                 blk_set_queue_full(q, WRITE);
4264         } else if (rl->count[WRITE]+1 <= q->nr_requests) {
4265                 blk_clear_queue_full(q, WRITE);
4266                 wake_up(&rl->wait[WRITE]);
4267         }
4268         spin_unlock_irq(q->queue_lock);
4269         return ret;
4270 }
4271
4272 static ssize_t queue_ra_show(struct request_queue *q, char *page)
4273 {
4274         int ra_kb = q->backing_dev_info.ra_pages << (PAGE_CACHE_SHIFT - 10);
4275
4276         return queue_var_show(ra_kb, (page));
4277 }
4278
4279 static ssize_t
4280 queue_ra_store(struct request_queue *q, const char *page, size_t count)
4281 {
4282         unsigned long ra_kb;
4283         ssize_t ret = queue_var_store(&ra_kb, page, count);
4284
4285         spin_lock_irq(q->queue_lock);
4286         q->backing_dev_info.ra_pages = ra_kb >> (PAGE_CACHE_SHIFT - 10);
4287         spin_unlock_irq(q->queue_lock);
4288
4289         return ret;
4290 }
4291
4292 static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
4293 {
4294         int max_sectors_kb = q->max_sectors >> 1;
4295
4296         return queue_var_show(max_sectors_kb, (page));
4297 }
4298
4299 static ssize_t
4300 queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
4301 {
4302         unsigned long max_sectors_kb,
4303                         max_hw_sectors_kb = q->max_hw_sectors >> 1,
4304                         page_kb = 1 << (PAGE_CACHE_SHIFT - 10);
4305         ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
4306
4307         if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
4308                 return -EINVAL;
4309         /*
4310          * Take the queue lock to update the readahead and max_sectors
4311          * values synchronously:
4312          */
4313         spin_lock_irq(q->queue_lock);
4314         q->max_sectors = max_sectors_kb << 1;
4315         spin_unlock_irq(q->queue_lock);
4316
4317         return ret;
4318 }
4319
4320 static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
4321 {
4322         int max_hw_sectors_kb = q->max_hw_sectors >> 1;
4323
4324         return queue_var_show(max_hw_sectors_kb, (page));
4325 }
4326
4327
4328 static struct queue_sysfs_entry queue_requests_entry = {
4329         .attr = {.name = "nr_requests", .mode = S_IRUGO | S_IWUSR },
4330         .show = queue_requests_show,
4331         .store = queue_requests_store,
4332 };
4333
4334 static struct queue_sysfs_entry queue_ra_entry = {
4335         .attr = {.name = "read_ahead_kb", .mode = S_IRUGO | S_IWUSR },
4336         .show = queue_ra_show,
4337         .store = queue_ra_store,
4338 };
4339
4340 static struct queue_sysfs_entry queue_max_sectors_entry = {
4341         .attr = {.name = "max_sectors_kb", .mode = S_IRUGO | S_IWUSR },
4342         .show = queue_max_sectors_show,
4343         .store = queue_max_sectors_store,
4344 };
4345
4346 static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
4347         .attr = {.name = "max_hw_sectors_kb", .mode = S_IRUGO },
4348         .show = queue_max_hw_sectors_show,
4349 };
4350
4351 static struct queue_sysfs_entry queue_iosched_entry = {
4352         .attr = {.name = "scheduler", .mode = S_IRUGO | S_IWUSR },
4353         .show = elv_iosched_show,
4354         .store = elv_iosched_store,
4355 };
4356
4357 static struct attribute *default_attrs[] = {
4358         &queue_requests_entry.attr,
4359         &queue_ra_entry.attr,
4360         &queue_max_hw_sectors_entry.attr,
4361         &queue_max_sectors_entry.attr,
4362         &queue_iosched_entry.attr,
4363         NULL,
4364 };
4365
4366 #define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
4367
4368 static ssize_t
4369 queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4370 {
4371         struct queue_sysfs_entry *entry = to_queue(attr);
4372         struct request_queue *q =
4373                 container_of(kobj, struct request_queue, kobj);
4374         ssize_t res;
4375
4376         if (!entry->show)
4377                 return -EIO;
4378         mutex_lock(&q->sysfs_lock);
4379         if (test_bit(QUEUE_FLAG_DEAD, &q->queue_flags)) {
4380                 mutex_unlock(&q->sysfs_lock);
4381                 return -ENOENT;
4382         }
4383         res = entry->show(q, page);
4384         mutex_unlock(&q->sysfs_lock);
4385         return res;
4386 }
4387
4388 static ssize_t
4389 queue_attr_store(struct kobject *kobj, struct attribute *attr,
4390                     const char *page, size_t length)
4391 {
4392         struct queue_sysfs_entry *entry = to_queue(attr);
4393         struct request_queue *q = container_of(kobj, struct request_queue, kobj);
4394
4395         ssize_t res;
4396
4397         if (!entry->store)
4398                 return -EIO;
4399         mutex_lock(&q->sysfs_lock);
4400         if (test_bit(QUEUE_FLAG_DEAD, &q->queue_flags)) {
4401                 mutex_unlock(&q->sysfs_lock);
4402                 return -ENOENT;
4403         }
4404         res = entry->store(q, page, length);
4405         mutex_unlock(&q->sysfs_lock);
4406         return res;
4407 }
4408
4409 static struct sysfs_ops queue_sysfs_ops = {
4410         .show   = queue_attr_show,
4411         .store  = queue_attr_store,
4412 };
4413
4414 static struct kobj_type queue_ktype = {
4415         .sysfs_ops      = &queue_sysfs_ops,
4416         .default_attrs  = default_attrs,
4417         .release        = blk_release_queue,
4418 };
4419
4420 int blk_register_queue(struct gendisk *disk)
4421 {
4422         int ret;
4423
4424         struct request_queue *q = disk->queue;
4425
4426         if (!q || !q->request_fn)
4427                 return -ENXIO;
4428
4429         ret = kobject_add(&q->kobj, kobject_get(&disk->dev.kobj),
4430                           "%s", "queue");
4431         if (ret < 0)
4432                 return ret;
4433
4434         kobject_uevent(&q->kobj, KOBJ_ADD);
4435
4436         ret = elv_register_queue(q);
4437         if (ret) {
4438                 kobject_uevent(&q->kobj, KOBJ_REMOVE);
4439                 kobject_del(&q->kobj);
4440                 return ret;
4441         }
4442
4443         return 0;
4444 }
4445
4446 void blk_unregister_queue(struct gendisk *disk)
4447 {
4448         struct request_queue *q = disk->queue;
4449
4450         if (q && q->request_fn) {
4451                 elv_unregister_queue(q);
4452
4453                 kobject_uevent(&q->kobj, KOBJ_REMOVE);
4454                 kobject_del(&q->kobj);
4455                 kobject_put(&disk->dev.kobj);
4456         }
4457 }