block: Introduce __blk_segment_map_sg() helper
[linux-3.10.git] / block / blk-merge.c
1 /*
2  * Functions related to segment and merge handling
3  */
4 #include <linux/kernel.h>
5 #include <linux/module.h>
6 #include <linux/bio.h>
7 #include <linux/blkdev.h>
8 #include <linux/scatterlist.h>
9
10 #include "blk.h"
11
12 static unsigned int __blk_recalc_rq_segments(struct request_queue *q,
13                                              struct bio *bio)
14 {
15         struct bio_vec *bv, *bvprv = NULL;
16         int cluster, i, high, highprv = 1;
17         unsigned int seg_size, nr_phys_segs;
18         struct bio *fbio, *bbio;
19
20         if (!bio)
21                 return 0;
22
23         fbio = bio;
24         cluster = blk_queue_cluster(q);
25         seg_size = 0;
26         nr_phys_segs = 0;
27         for_each_bio(bio) {
28                 bio_for_each_segment(bv, bio, i) {
29                         /*
30                          * the trick here is making sure that a high page is
31                          * never considered part of another segment, since that
32                          * might change with the bounce page.
33                          */
34                         high = page_to_pfn(bv->bv_page) > queue_bounce_pfn(q);
35                         if (high || highprv)
36                                 goto new_segment;
37                         if (cluster) {
38                                 if (seg_size + bv->bv_len
39                                     > queue_max_segment_size(q))
40                                         goto new_segment;
41                                 if (!BIOVEC_PHYS_MERGEABLE(bvprv, bv))
42                                         goto new_segment;
43                                 if (!BIOVEC_SEG_BOUNDARY(q, bvprv, bv))
44                                         goto new_segment;
45
46                                 seg_size += bv->bv_len;
47                                 bvprv = bv;
48                                 continue;
49                         }
50 new_segment:
51                         if (nr_phys_segs == 1 && seg_size >
52                             fbio->bi_seg_front_size)
53                                 fbio->bi_seg_front_size = seg_size;
54
55                         nr_phys_segs++;
56                         bvprv = bv;
57                         seg_size = bv->bv_len;
58                         highprv = high;
59                 }
60                 bbio = bio;
61         }
62
63         if (nr_phys_segs == 1 && seg_size > fbio->bi_seg_front_size)
64                 fbio->bi_seg_front_size = seg_size;
65         if (seg_size > bbio->bi_seg_back_size)
66                 bbio->bi_seg_back_size = seg_size;
67
68         return nr_phys_segs;
69 }
70
71 void blk_recalc_rq_segments(struct request *rq)
72 {
73         rq->nr_phys_segments = __blk_recalc_rq_segments(rq->q, rq->bio);
74 }
75
76 void blk_recount_segments(struct request_queue *q, struct bio *bio)
77 {
78         struct bio *nxt = bio->bi_next;
79
80         bio->bi_next = NULL;
81         bio->bi_phys_segments = __blk_recalc_rq_segments(q, bio);
82         bio->bi_next = nxt;
83         bio->bi_flags |= (1 << BIO_SEG_VALID);
84 }
85 EXPORT_SYMBOL(blk_recount_segments);
86
87 static int blk_phys_contig_segment(struct request_queue *q, struct bio *bio,
88                                    struct bio *nxt)
89 {
90         if (!blk_queue_cluster(q))
91                 return 0;
92
93         if (bio->bi_seg_back_size + nxt->bi_seg_front_size >
94             queue_max_segment_size(q))
95                 return 0;
96
97         if (!bio_has_data(bio))
98                 return 1;
99
100         if (!BIOVEC_PHYS_MERGEABLE(__BVEC_END(bio), __BVEC_START(nxt)))
101                 return 0;
102
103         /*
104          * bio and nxt are contiguous in memory; check if the queue allows
105          * these two to be merged into one
106          */
107         if (BIO_SEG_BOUNDARY(q, bio, nxt))
108                 return 1;
109
110         return 0;
111 }
112
113 static void
114 __blk_segment_map_sg(struct request_queue *q, struct bio_vec *bvec,
115                      struct scatterlist *sglist, struct bio_vec **bvprv,
116                      struct scatterlist **sg, int *nsegs, int *cluster)
117 {
118
119         int nbytes = bvec->bv_len;
120
121         if (*bvprv && *cluster) {
122                 if ((*sg)->length + nbytes > queue_max_segment_size(q))
123                         goto new_segment;
124
125                 if (!BIOVEC_PHYS_MERGEABLE(*bvprv, bvec))
126                         goto new_segment;
127                 if (!BIOVEC_SEG_BOUNDARY(q, *bvprv, bvec))
128                         goto new_segment;
129
130                 (*sg)->length += nbytes;
131         } else {
132 new_segment:
133                 if (!*sg)
134                         *sg = sglist;
135                 else {
136                         /*
137                          * If the driver previously mapped a shorter
138                          * list, we could see a termination bit
139                          * prematurely unless it fully inits the sg
140                          * table on each mapping. We KNOW that there
141                          * must be more entries here or the driver
142                          * would be buggy, so force clear the
143                          * termination bit to avoid doing a full
144                          * sg_init_table() in drivers for each command.
145                          */
146                         (*sg)->page_link &= ~0x02;
147                         *sg = sg_next(*sg);
148                 }
149
150                 sg_set_page(*sg, bvec->bv_page, nbytes, bvec->bv_offset);
151                 (*nsegs)++;
152         }
153         *bvprv = bvec;
154 }
155
156 /*
157  * map a request to scatterlist, return number of sg entries setup. Caller
158  * must make sure sg can hold rq->nr_phys_segments entries
159  */
160 int blk_rq_map_sg(struct request_queue *q, struct request *rq,
161                   struct scatterlist *sglist)
162 {
163         struct bio_vec *bvec, *bvprv;
164         struct req_iterator iter;
165         struct scatterlist *sg;
166         int nsegs, cluster;
167
168         nsegs = 0;
169         cluster = blk_queue_cluster(q);
170
171         /*
172          * for each bio in rq
173          */
174         bvprv = NULL;
175         sg = NULL;
176         rq_for_each_segment(bvec, rq, iter) {
177                 __blk_segment_map_sg(q, bvec, sglist, &bvprv, &sg,
178                                      &nsegs, &cluster);
179         } /* segments in rq */
180
181
182         if (unlikely(rq->cmd_flags & REQ_COPY_USER) &&
183             (blk_rq_bytes(rq) & q->dma_pad_mask)) {
184                 unsigned int pad_len =
185                         (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1;
186
187                 sg->length += pad_len;
188                 rq->extra_len += pad_len;
189         }
190
191         if (q->dma_drain_size && q->dma_drain_needed(rq)) {
192                 if (rq->cmd_flags & REQ_WRITE)
193                         memset(q->dma_drain_buffer, 0, q->dma_drain_size);
194
195                 sg->page_link &= ~0x02;
196                 sg = sg_next(sg);
197                 sg_set_page(sg, virt_to_page(q->dma_drain_buffer),
198                             q->dma_drain_size,
199                             ((unsigned long)q->dma_drain_buffer) &
200                             (PAGE_SIZE - 1));
201                 nsegs++;
202                 rq->extra_len += q->dma_drain_size;
203         }
204
205         if (sg)
206                 sg_mark_end(sg);
207
208         return nsegs;
209 }
210 EXPORT_SYMBOL(blk_rq_map_sg);
211
212 static inline int ll_new_hw_segment(struct request_queue *q,
213                                     struct request *req,
214                                     struct bio *bio)
215 {
216         int nr_phys_segs = bio_phys_segments(q, bio);
217
218         if (req->nr_phys_segments + nr_phys_segs > queue_max_segments(q))
219                 goto no_merge;
220
221         if (bio_integrity(bio) && blk_integrity_merge_bio(q, req, bio))
222                 goto no_merge;
223
224         /*
225          * This will form the start of a new hw segment.  Bump both
226          * counters.
227          */
228         req->nr_phys_segments += nr_phys_segs;
229         return 1;
230
231 no_merge:
232         req->cmd_flags |= REQ_NOMERGE;
233         if (req == q->last_merge)
234                 q->last_merge = NULL;
235         return 0;
236 }
237
238 int ll_back_merge_fn(struct request_queue *q, struct request *req,
239                      struct bio *bio)
240 {
241         unsigned short max_sectors;
242
243         if (unlikely(req->cmd_type == REQ_TYPE_BLOCK_PC))
244                 max_sectors = queue_max_hw_sectors(q);
245         else
246                 max_sectors = queue_max_sectors(q);
247
248         if (blk_rq_sectors(req) + bio_sectors(bio) > max_sectors) {
249                 req->cmd_flags |= REQ_NOMERGE;
250                 if (req == q->last_merge)
251                         q->last_merge = NULL;
252                 return 0;
253         }
254         if (!bio_flagged(req->biotail, BIO_SEG_VALID))
255                 blk_recount_segments(q, req->biotail);
256         if (!bio_flagged(bio, BIO_SEG_VALID))
257                 blk_recount_segments(q, bio);
258
259         return ll_new_hw_segment(q, req, bio);
260 }
261
262 int ll_front_merge_fn(struct request_queue *q, struct request *req,
263                       struct bio *bio)
264 {
265         unsigned short max_sectors;
266
267         if (unlikely(req->cmd_type == REQ_TYPE_BLOCK_PC))
268                 max_sectors = queue_max_hw_sectors(q);
269         else
270                 max_sectors = queue_max_sectors(q);
271
272
273         if (blk_rq_sectors(req) + bio_sectors(bio) > max_sectors) {
274                 req->cmd_flags |= REQ_NOMERGE;
275                 if (req == q->last_merge)
276                         q->last_merge = NULL;
277                 return 0;
278         }
279         if (!bio_flagged(bio, BIO_SEG_VALID))
280                 blk_recount_segments(q, bio);
281         if (!bio_flagged(req->bio, BIO_SEG_VALID))
282                 blk_recount_segments(q, req->bio);
283
284         return ll_new_hw_segment(q, req, bio);
285 }
286
287 static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
288                                 struct request *next)
289 {
290         int total_phys_segments;
291         unsigned int seg_size =
292                 req->biotail->bi_seg_back_size + next->bio->bi_seg_front_size;
293
294         /*
295          * First check if the either of the requests are re-queued
296          * requests.  Can't merge them if they are.
297          */
298         if (req->special || next->special)
299                 return 0;
300
301         /*
302          * Will it become too large?
303          */
304         if ((blk_rq_sectors(req) + blk_rq_sectors(next)) > queue_max_sectors(q))
305                 return 0;
306
307         total_phys_segments = req->nr_phys_segments + next->nr_phys_segments;
308         if (blk_phys_contig_segment(q, req->biotail, next->bio)) {
309                 if (req->nr_phys_segments == 1)
310                         req->bio->bi_seg_front_size = seg_size;
311                 if (next->nr_phys_segments == 1)
312                         next->biotail->bi_seg_back_size = seg_size;
313                 total_phys_segments--;
314         }
315
316         if (total_phys_segments > queue_max_segments(q))
317                 return 0;
318
319         if (blk_integrity_rq(req) && blk_integrity_merge_rq(q, req, next))
320                 return 0;
321
322         /* Merge is OK... */
323         req->nr_phys_segments = total_phys_segments;
324         return 1;
325 }
326
327 /**
328  * blk_rq_set_mixed_merge - mark a request as mixed merge
329  * @rq: request to mark as mixed merge
330  *
331  * Description:
332  *     @rq is about to be mixed merged.  Make sure the attributes
333  *     which can be mixed are set in each bio and mark @rq as mixed
334  *     merged.
335  */
336 void blk_rq_set_mixed_merge(struct request *rq)
337 {
338         unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK;
339         struct bio *bio;
340
341         if (rq->cmd_flags & REQ_MIXED_MERGE)
342                 return;
343
344         /*
345          * @rq will no longer represent mixable attributes for all the
346          * contained bios.  It will just track those of the first one.
347          * Distributes the attributs to each bio.
348          */
349         for (bio = rq->bio; bio; bio = bio->bi_next) {
350                 WARN_ON_ONCE((bio->bi_rw & REQ_FAILFAST_MASK) &&
351                              (bio->bi_rw & REQ_FAILFAST_MASK) != ff);
352                 bio->bi_rw |= ff;
353         }
354         rq->cmd_flags |= REQ_MIXED_MERGE;
355 }
356
357 static void blk_account_io_merge(struct request *req)
358 {
359         if (blk_do_io_stat(req)) {
360                 struct hd_struct *part;
361                 int cpu;
362
363                 cpu = part_stat_lock();
364                 part = req->part;
365
366                 part_round_stats(cpu, part);
367                 part_dec_in_flight(part, rq_data_dir(req));
368
369                 hd_struct_put(part);
370                 part_stat_unlock();
371         }
372 }
373
374 /*
375  * Has to be called with the request spinlock acquired
376  */
377 static int attempt_merge(struct request_queue *q, struct request *req,
378                           struct request *next)
379 {
380         if (!rq_mergeable(req) || !rq_mergeable(next))
381                 return 0;
382
383         /*
384          * Don't merge file system requests and discard requests
385          */
386         if ((req->cmd_flags & REQ_DISCARD) != (next->cmd_flags & REQ_DISCARD))
387                 return 0;
388
389         /*
390          * Don't merge discard requests and secure discard requests
391          */
392         if ((req->cmd_flags & REQ_SECURE) != (next->cmd_flags & REQ_SECURE))
393                 return 0;
394
395         /*
396          * not contiguous
397          */
398         if (blk_rq_pos(req) + blk_rq_sectors(req) != blk_rq_pos(next))
399                 return 0;
400
401         if (rq_data_dir(req) != rq_data_dir(next)
402             || req->rq_disk != next->rq_disk
403             || next->special)
404                 return 0;
405
406         /*
407          * If we are allowed to merge, then append bio list
408          * from next to rq and release next. merge_requests_fn
409          * will have updated segment counts, update sector
410          * counts here.
411          */
412         if (!ll_merge_requests_fn(q, req, next))
413                 return 0;
414
415         /*
416          * If failfast settings disagree or any of the two is already
417          * a mixed merge, mark both as mixed before proceeding.  This
418          * makes sure that all involved bios have mixable attributes
419          * set properly.
420          */
421         if ((req->cmd_flags | next->cmd_flags) & REQ_MIXED_MERGE ||
422             (req->cmd_flags & REQ_FAILFAST_MASK) !=
423             (next->cmd_flags & REQ_FAILFAST_MASK)) {
424                 blk_rq_set_mixed_merge(req);
425                 blk_rq_set_mixed_merge(next);
426         }
427
428         /*
429          * At this point we have either done a back merge
430          * or front merge. We need the smaller start_time of
431          * the merged requests to be the current request
432          * for accounting purposes.
433          */
434         if (time_after(req->start_time, next->start_time))
435                 req->start_time = next->start_time;
436
437         req->biotail->bi_next = next->bio;
438         req->biotail = next->biotail;
439
440         req->__data_len += blk_rq_bytes(next);
441
442         elv_merge_requests(q, req, next);
443
444         /*
445          * 'next' is going away, so update stats accordingly
446          */
447         blk_account_io_merge(next);
448
449         req->ioprio = ioprio_best(req->ioprio, next->ioprio);
450         if (blk_rq_cpu_valid(next))
451                 req->cpu = next->cpu;
452
453         /* owner-ship of bio passed from next to req */
454         next->bio = NULL;
455         __blk_put_request(q, next);
456         return 1;
457 }
458
459 int attempt_back_merge(struct request_queue *q, struct request *rq)
460 {
461         struct request *next = elv_latter_request(q, rq);
462
463         if (next)
464                 return attempt_merge(q, rq, next);
465
466         return 0;
467 }
468
469 int attempt_front_merge(struct request_queue *q, struct request *rq)
470 {
471         struct request *prev = elv_former_request(q, rq);
472
473         if (prev)
474                 return attempt_merge(q, prev, rq);
475
476         return 0;
477 }
478
479 int blk_attempt_req_merge(struct request_queue *q, struct request *rq,
480                           struct request *next)
481 {
482         return attempt_merge(q, rq, next);
483 }
484
485 bool blk_rq_merge_ok(struct request *rq, struct bio *bio)
486 {
487         if (!rq_mergeable(rq))
488                 return false;
489
490         /* don't merge file system requests and discard requests */
491         if ((bio->bi_rw & REQ_DISCARD) != (rq->bio->bi_rw & REQ_DISCARD))
492                 return false;
493
494         /* don't merge discard requests and secure discard requests */
495         if ((bio->bi_rw & REQ_SECURE) != (rq->bio->bi_rw & REQ_SECURE))
496                 return false;
497
498         /* different data direction or already started, don't merge */
499         if (bio_data_dir(bio) != rq_data_dir(rq))
500                 return false;
501
502         /* must be same device and not a special request */
503         if (rq->rq_disk != bio->bi_bdev->bd_disk || rq->special)
504                 return false;
505
506         /* only merge integrity protected bio into ditto rq */
507         if (bio_integrity(bio) != blk_integrity_rq(rq))
508                 return false;
509
510         return true;
511 }
512
513 int blk_try_merge(struct request *rq, struct bio *bio)
514 {
515         if (blk_rq_pos(rq) + blk_rq_sectors(rq) == bio->bi_sector)
516                 return ELEVATOR_BACK_MERGE;
517         else if (blk_rq_pos(rq) - bio_sectors(bio) == bio->bi_sector)
518                 return ELEVATOR_FRONT_MERGE;
519         return ELEVATOR_NO_MERGE;
520 }