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 struct bio *blk_bio_discard_split(struct request_queue *q, 13 struct bio *bio, 14 struct bio_set *bs, 15 unsigned *nsegs) 16 { 17 unsigned int max_discard_sectors, granularity; 18 int alignment; 19 sector_t tmp; 20 unsigned split_sectors; 21 22 *nsegs = 1; 23 24 /* Zero-sector (unknown) and one-sector granularities are the same. */ 25 granularity = max(q->limits.discard_granularity >> 9, 1U); 26 27 max_discard_sectors = min(q->limits.max_discard_sectors, UINT_MAX >> 9); 28 max_discard_sectors -= max_discard_sectors % granularity; 29 30 if (unlikely(!max_discard_sectors)) { 31 /* XXX: warn */ 32 return NULL; 33 } 34 35 if (bio_sectors(bio) <= max_discard_sectors) 36 return NULL; 37 38 split_sectors = max_discard_sectors; 39 40 /* 41 * If the next starting sector would be misaligned, stop the discard at 42 * the previous aligned sector. 43 */ 44 alignment = (q->limits.discard_alignment >> 9) % granularity; 45 46 tmp = bio->bi_iter.bi_sector + split_sectors - alignment; 47 tmp = sector_div(tmp, granularity); 48 49 if (split_sectors > tmp) 50 split_sectors -= tmp; 51 52 return bio_split(bio, split_sectors, GFP_NOIO, bs); 53 } 54 55 static struct bio *blk_bio_write_same_split(struct request_queue *q, 56 struct bio *bio, 57 struct bio_set *bs, 58 unsigned *nsegs) 59 { 60 *nsegs = 1; 61 62 if (!q->limits.max_write_same_sectors) 63 return NULL; 64 65 if (bio_sectors(bio) <= q->limits.max_write_same_sectors) 66 return NULL; 67 68 return bio_split(bio, q->limits.max_write_same_sectors, GFP_NOIO, bs); 69 } 70 71 static struct bio *blk_bio_segment_split(struct request_queue *q, 72 struct bio *bio, 73 struct bio_set *bs, 74 unsigned *segs) 75 { 76 struct bio_vec bv, bvprv, *bvprvp = NULL; 77 struct bvec_iter iter; 78 unsigned seg_size = 0, nsegs = 0, sectors = 0; 79 unsigned front_seg_size = bio->bi_seg_front_size; 80 bool do_split = true; 81 struct bio *new = NULL; 82 83 bio_for_each_segment(bv, bio, iter) { 84 if (sectors + (bv.bv_len >> 9) > queue_max_sectors(q)) 85 goto split; 86 87 /* 88 * If the queue doesn't support SG gaps and adding this 89 * offset would create a gap, disallow it. 90 */ 91 if (bvprvp && bvec_gap_to_prev(q, bvprvp, bv.bv_offset)) 92 goto split; 93 94 if (bvprvp && blk_queue_cluster(q)) { 95 if (seg_size + bv.bv_len > queue_max_segment_size(q)) 96 goto new_segment; 97 if (!BIOVEC_PHYS_MERGEABLE(bvprvp, &bv)) 98 goto new_segment; 99 if (!BIOVEC_SEG_BOUNDARY(q, bvprvp, &bv)) 100 goto new_segment; 101 102 seg_size += bv.bv_len; 103 bvprv = bv; 104 bvprvp = &bvprv; 105 sectors += bv.bv_len >> 9; 106 107 if (nsegs == 1 && seg_size > front_seg_size) 108 front_seg_size = seg_size; 109 continue; 110 } 111 new_segment: 112 if (nsegs == queue_max_segments(q)) 113 goto split; 114 115 nsegs++; 116 bvprv = bv; 117 bvprvp = &bvprv; 118 seg_size = bv.bv_len; 119 sectors += bv.bv_len >> 9; 120 121 if (nsegs == 1 && seg_size > front_seg_size) 122 front_seg_size = seg_size; 123 } 124 125 do_split = false; 126 split: 127 *segs = nsegs; 128 129 if (do_split) { 130 new = bio_split(bio, sectors, GFP_NOIO, bs); 131 if (new) 132 bio = new; 133 } 134 135 bio->bi_seg_front_size = front_seg_size; 136 if (seg_size > bio->bi_seg_back_size) 137 bio->bi_seg_back_size = seg_size; 138 139 return do_split ? new : NULL; 140 } 141 142 void blk_queue_split(struct request_queue *q, struct bio **bio, 143 struct bio_set *bs) 144 { 145 struct bio *split, *res; 146 unsigned nsegs; 147 148 if ((*bio)->bi_rw & REQ_DISCARD) 149 split = blk_bio_discard_split(q, *bio, bs, &nsegs); 150 else if ((*bio)->bi_rw & REQ_WRITE_SAME) 151 split = blk_bio_write_same_split(q, *bio, bs, &nsegs); 152 else 153 split = blk_bio_segment_split(q, *bio, q->bio_split, &nsegs); 154 155 /* physical segments can be figured out during splitting */ 156 res = split ? split : *bio; 157 res->bi_phys_segments = nsegs; 158 bio_set_flag(res, BIO_SEG_VALID); 159 160 if (split) { 161 /* there isn't chance to merge the splitted bio */ 162 split->bi_rw |= REQ_NOMERGE; 163 164 bio_chain(split, *bio); 165 generic_make_request(*bio); 166 *bio = split; 167 } 168 } 169 EXPORT_SYMBOL(blk_queue_split); 170 171 static unsigned int __blk_recalc_rq_segments(struct request_queue *q, 172 struct bio *bio, 173 bool no_sg_merge) 174 { 175 struct bio_vec bv, bvprv = { NULL }; 176 int cluster, prev = 0; 177 unsigned int seg_size, nr_phys_segs; 178 struct bio *fbio, *bbio; 179 struct bvec_iter iter; 180 181 if (!bio) 182 return 0; 183 184 /* 185 * This should probably be returning 0, but blk_add_request_payload() 186 * (Christoph!!!!) 187 */ 188 if (bio->bi_rw & REQ_DISCARD) 189 return 1; 190 191 if (bio->bi_rw & REQ_WRITE_SAME) 192 return 1; 193 194 fbio = bio; 195 cluster = blk_queue_cluster(q); 196 seg_size = 0; 197 nr_phys_segs = 0; 198 for_each_bio(bio) { 199 bio_for_each_segment(bv, bio, iter) { 200 /* 201 * If SG merging is disabled, each bio vector is 202 * a segment 203 */ 204 if (no_sg_merge) 205 goto new_segment; 206 207 if (prev && cluster) { 208 if (seg_size + bv.bv_len 209 > queue_max_segment_size(q)) 210 goto new_segment; 211 if (!BIOVEC_PHYS_MERGEABLE(&bvprv, &bv)) 212 goto new_segment; 213 if (!BIOVEC_SEG_BOUNDARY(q, &bvprv, &bv)) 214 goto new_segment; 215 216 seg_size += bv.bv_len; 217 bvprv = bv; 218 continue; 219 } 220 new_segment: 221 if (nr_phys_segs == 1 && seg_size > 222 fbio->bi_seg_front_size) 223 fbio->bi_seg_front_size = seg_size; 224 225 nr_phys_segs++; 226 bvprv = bv; 227 prev = 1; 228 seg_size = bv.bv_len; 229 } 230 bbio = bio; 231 } 232 233 if (nr_phys_segs == 1 && seg_size > fbio->bi_seg_front_size) 234 fbio->bi_seg_front_size = seg_size; 235 if (seg_size > bbio->bi_seg_back_size) 236 bbio->bi_seg_back_size = seg_size; 237 238 return nr_phys_segs; 239 } 240 241 void blk_recalc_rq_segments(struct request *rq) 242 { 243 bool no_sg_merge = !!test_bit(QUEUE_FLAG_NO_SG_MERGE, 244 &rq->q->queue_flags); 245 246 rq->nr_phys_segments = __blk_recalc_rq_segments(rq->q, rq->bio, 247 no_sg_merge); 248 } 249 250 void blk_recount_segments(struct request_queue *q, struct bio *bio) 251 { 252 unsigned short seg_cnt; 253 254 /* estimate segment number by bi_vcnt for non-cloned bio */ 255 if (bio_flagged(bio, BIO_CLONED)) 256 seg_cnt = bio_segments(bio); 257 else 258 seg_cnt = bio->bi_vcnt; 259 260 if (test_bit(QUEUE_FLAG_NO_SG_MERGE, &q->queue_flags) && 261 (seg_cnt < queue_max_segments(q))) 262 bio->bi_phys_segments = seg_cnt; 263 else { 264 struct bio *nxt = bio->bi_next; 265 266 bio->bi_next = NULL; 267 bio->bi_phys_segments = __blk_recalc_rq_segments(q, bio, false); 268 bio->bi_next = nxt; 269 } 270 271 bio_set_flag(bio, BIO_SEG_VALID); 272 } 273 EXPORT_SYMBOL(blk_recount_segments); 274 275 static int blk_phys_contig_segment(struct request_queue *q, struct bio *bio, 276 struct bio *nxt) 277 { 278 struct bio_vec end_bv = { NULL }, nxt_bv; 279 struct bvec_iter iter; 280 281 if (!blk_queue_cluster(q)) 282 return 0; 283 284 if (bio->bi_seg_back_size + nxt->bi_seg_front_size > 285 queue_max_segment_size(q)) 286 return 0; 287 288 if (!bio_has_data(bio)) 289 return 1; 290 291 bio_for_each_segment(end_bv, bio, iter) 292 if (end_bv.bv_len == iter.bi_size) 293 break; 294 295 nxt_bv = bio_iovec(nxt); 296 297 if (!BIOVEC_PHYS_MERGEABLE(&end_bv, &nxt_bv)) 298 return 0; 299 300 /* 301 * bio and nxt are contiguous in memory; check if the queue allows 302 * these two to be merged into one 303 */ 304 if (BIOVEC_SEG_BOUNDARY(q, &end_bv, &nxt_bv)) 305 return 1; 306 307 return 0; 308 } 309 310 static inline void 311 __blk_segment_map_sg(struct request_queue *q, struct bio_vec *bvec, 312 struct scatterlist *sglist, struct bio_vec *bvprv, 313 struct scatterlist **sg, int *nsegs, int *cluster) 314 { 315 316 int nbytes = bvec->bv_len; 317 318 if (*sg && *cluster) { 319 if ((*sg)->length + nbytes > queue_max_segment_size(q)) 320 goto new_segment; 321 322 if (!BIOVEC_PHYS_MERGEABLE(bvprv, bvec)) 323 goto new_segment; 324 if (!BIOVEC_SEG_BOUNDARY(q, bvprv, bvec)) 325 goto new_segment; 326 327 (*sg)->length += nbytes; 328 } else { 329 new_segment: 330 if (!*sg) 331 *sg = sglist; 332 else { 333 /* 334 * If the driver previously mapped a shorter 335 * list, we could see a termination bit 336 * prematurely unless it fully inits the sg 337 * table on each mapping. We KNOW that there 338 * must be more entries here or the driver 339 * would be buggy, so force clear the 340 * termination bit to avoid doing a full 341 * sg_init_table() in drivers for each command. 342 */ 343 sg_unmark_end(*sg); 344 *sg = sg_next(*sg); 345 } 346 347 sg_set_page(*sg, bvec->bv_page, nbytes, bvec->bv_offset); 348 (*nsegs)++; 349 } 350 *bvprv = *bvec; 351 } 352 353 static int __blk_bios_map_sg(struct request_queue *q, struct bio *bio, 354 struct scatterlist *sglist, 355 struct scatterlist **sg) 356 { 357 struct bio_vec bvec, bvprv = { NULL }; 358 struct bvec_iter iter; 359 int nsegs, cluster; 360 361 nsegs = 0; 362 cluster = blk_queue_cluster(q); 363 364 if (bio->bi_rw & REQ_DISCARD) { 365 /* 366 * This is a hack - drivers should be neither modifying the 367 * biovec, nor relying on bi_vcnt - but because of 368 * blk_add_request_payload(), a discard bio may or may not have 369 * a payload we need to set up here (thank you Christoph) and 370 * bi_vcnt is really the only way of telling if we need to. 371 */ 372 373 if (bio->bi_vcnt) 374 goto single_segment; 375 376 return 0; 377 } 378 379 if (bio->bi_rw & REQ_WRITE_SAME) { 380 single_segment: 381 *sg = sglist; 382 bvec = bio_iovec(bio); 383 sg_set_page(*sg, bvec.bv_page, bvec.bv_len, bvec.bv_offset); 384 return 1; 385 } 386 387 for_each_bio(bio) 388 bio_for_each_segment(bvec, bio, iter) 389 __blk_segment_map_sg(q, &bvec, sglist, &bvprv, sg, 390 &nsegs, &cluster); 391 392 return nsegs; 393 } 394 395 /* 396 * map a request to scatterlist, return number of sg entries setup. Caller 397 * must make sure sg can hold rq->nr_phys_segments entries 398 */ 399 int blk_rq_map_sg(struct request_queue *q, struct request *rq, 400 struct scatterlist *sglist) 401 { 402 struct scatterlist *sg = NULL; 403 int nsegs = 0; 404 405 if (rq->bio) 406 nsegs = __blk_bios_map_sg(q, rq->bio, sglist, &sg); 407 408 if (unlikely(rq->cmd_flags & REQ_COPY_USER) && 409 (blk_rq_bytes(rq) & q->dma_pad_mask)) { 410 unsigned int pad_len = 411 (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1; 412 413 sg->length += pad_len; 414 rq->extra_len += pad_len; 415 } 416 417 if (q->dma_drain_size && q->dma_drain_needed(rq)) { 418 if (rq->cmd_flags & REQ_WRITE) 419 memset(q->dma_drain_buffer, 0, q->dma_drain_size); 420 421 sg_unmark_end(sg); 422 sg = sg_next(sg); 423 sg_set_page(sg, virt_to_page(q->dma_drain_buffer), 424 q->dma_drain_size, 425 ((unsigned long)q->dma_drain_buffer) & 426 (PAGE_SIZE - 1)); 427 nsegs++; 428 rq->extra_len += q->dma_drain_size; 429 } 430 431 if (sg) 432 sg_mark_end(sg); 433 434 /* 435 * Something must have been wrong if the figured number of 436 * segment is bigger than number of req's physical segments 437 */ 438 WARN_ON(nsegs > rq->nr_phys_segments); 439 440 return nsegs; 441 } 442 EXPORT_SYMBOL(blk_rq_map_sg); 443 444 static inline int ll_new_hw_segment(struct request_queue *q, 445 struct request *req, 446 struct bio *bio) 447 { 448 int nr_phys_segs = bio_phys_segments(q, bio); 449 450 if (req->nr_phys_segments + nr_phys_segs > queue_max_segments(q)) 451 goto no_merge; 452 453 if (blk_integrity_merge_bio(q, req, bio) == false) 454 goto no_merge; 455 456 /* 457 * This will form the start of a new hw segment. Bump both 458 * counters. 459 */ 460 req->nr_phys_segments += nr_phys_segs; 461 return 1; 462 463 no_merge: 464 req->cmd_flags |= REQ_NOMERGE; 465 if (req == q->last_merge) 466 q->last_merge = NULL; 467 return 0; 468 } 469 470 int ll_back_merge_fn(struct request_queue *q, struct request *req, 471 struct bio *bio) 472 { 473 if (req_gap_back_merge(req, bio)) 474 return 0; 475 if (blk_integrity_rq(req) && 476 integrity_req_gap_back_merge(req, bio)) 477 return 0; 478 if (blk_rq_sectors(req) + bio_sectors(bio) > 479 blk_rq_get_max_sectors(req)) { 480 req->cmd_flags |= REQ_NOMERGE; 481 if (req == q->last_merge) 482 q->last_merge = NULL; 483 return 0; 484 } 485 if (!bio_flagged(req->biotail, BIO_SEG_VALID)) 486 blk_recount_segments(q, req->biotail); 487 if (!bio_flagged(bio, BIO_SEG_VALID)) 488 blk_recount_segments(q, bio); 489 490 return ll_new_hw_segment(q, req, bio); 491 } 492 493 int ll_front_merge_fn(struct request_queue *q, struct request *req, 494 struct bio *bio) 495 { 496 497 if (req_gap_front_merge(req, bio)) 498 return 0; 499 if (blk_integrity_rq(req) && 500 integrity_req_gap_front_merge(req, bio)) 501 return 0; 502 if (blk_rq_sectors(req) + bio_sectors(bio) > 503 blk_rq_get_max_sectors(req)) { 504 req->cmd_flags |= REQ_NOMERGE; 505 if (req == q->last_merge) 506 q->last_merge = NULL; 507 return 0; 508 } 509 if (!bio_flagged(bio, BIO_SEG_VALID)) 510 blk_recount_segments(q, bio); 511 if (!bio_flagged(req->bio, BIO_SEG_VALID)) 512 blk_recount_segments(q, req->bio); 513 514 return ll_new_hw_segment(q, req, bio); 515 } 516 517 /* 518 * blk-mq uses req->special to carry normal driver per-request payload, it 519 * does not indicate a prepared command that we cannot merge with. 520 */ 521 static bool req_no_special_merge(struct request *req) 522 { 523 struct request_queue *q = req->q; 524 525 return !q->mq_ops && req->special; 526 } 527 528 static int ll_merge_requests_fn(struct request_queue *q, struct request *req, 529 struct request *next) 530 { 531 int total_phys_segments; 532 unsigned int seg_size = 533 req->biotail->bi_seg_back_size + next->bio->bi_seg_front_size; 534 535 /* 536 * First check if the either of the requests are re-queued 537 * requests. Can't merge them if they are. 538 */ 539 if (req_no_special_merge(req) || req_no_special_merge(next)) 540 return 0; 541 542 if (req_gap_back_merge(req, next->bio)) 543 return 0; 544 545 /* 546 * Will it become too large? 547 */ 548 if ((blk_rq_sectors(req) + blk_rq_sectors(next)) > 549 blk_rq_get_max_sectors(req)) 550 return 0; 551 552 total_phys_segments = req->nr_phys_segments + next->nr_phys_segments; 553 if (blk_phys_contig_segment(q, req->biotail, next->bio)) { 554 if (req->nr_phys_segments == 1) 555 req->bio->bi_seg_front_size = seg_size; 556 if (next->nr_phys_segments == 1) 557 next->biotail->bi_seg_back_size = seg_size; 558 total_phys_segments--; 559 } 560 561 if (total_phys_segments > queue_max_segments(q)) 562 return 0; 563 564 if (blk_integrity_merge_rq(q, req, next) == false) 565 return 0; 566 567 /* Merge is OK... */ 568 req->nr_phys_segments = total_phys_segments; 569 return 1; 570 } 571 572 /** 573 * blk_rq_set_mixed_merge - mark a request as mixed merge 574 * @rq: request to mark as mixed merge 575 * 576 * Description: 577 * @rq is about to be mixed merged. Make sure the attributes 578 * which can be mixed are set in each bio and mark @rq as mixed 579 * merged. 580 */ 581 void blk_rq_set_mixed_merge(struct request *rq) 582 { 583 unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK; 584 struct bio *bio; 585 586 if (rq->cmd_flags & REQ_MIXED_MERGE) 587 return; 588 589 /* 590 * @rq will no longer represent mixable attributes for all the 591 * contained bios. It will just track those of the first one. 592 * Distributes the attributs to each bio. 593 */ 594 for (bio = rq->bio; bio; bio = bio->bi_next) { 595 WARN_ON_ONCE((bio->bi_rw & REQ_FAILFAST_MASK) && 596 (bio->bi_rw & REQ_FAILFAST_MASK) != ff); 597 bio->bi_rw |= ff; 598 } 599 rq->cmd_flags |= REQ_MIXED_MERGE; 600 } 601 602 static void blk_account_io_merge(struct request *req) 603 { 604 if (blk_do_io_stat(req)) { 605 struct hd_struct *part; 606 int cpu; 607 608 cpu = part_stat_lock(); 609 part = req->part; 610 611 part_round_stats(cpu, part); 612 part_dec_in_flight(part, rq_data_dir(req)); 613 614 hd_struct_put(part); 615 part_stat_unlock(); 616 } 617 } 618 619 /* 620 * Has to be called with the request spinlock acquired 621 */ 622 static int attempt_merge(struct request_queue *q, struct request *req, 623 struct request *next) 624 { 625 if (!rq_mergeable(req) || !rq_mergeable(next)) 626 return 0; 627 628 if (!blk_check_merge_flags(req->cmd_flags, next->cmd_flags)) 629 return 0; 630 631 /* 632 * not contiguous 633 */ 634 if (blk_rq_pos(req) + blk_rq_sectors(req) != blk_rq_pos(next)) 635 return 0; 636 637 if (rq_data_dir(req) != rq_data_dir(next) 638 || req->rq_disk != next->rq_disk 639 || req_no_special_merge(next)) 640 return 0; 641 642 if (req->cmd_flags & REQ_WRITE_SAME && 643 !blk_write_same_mergeable(req->bio, next->bio)) 644 return 0; 645 646 /* 647 * If we are allowed to merge, then append bio list 648 * from next to rq and release next. merge_requests_fn 649 * will have updated segment counts, update sector 650 * counts here. 651 */ 652 if (!ll_merge_requests_fn(q, req, next)) 653 return 0; 654 655 /* 656 * If failfast settings disagree or any of the two is already 657 * a mixed merge, mark both as mixed before proceeding. This 658 * makes sure that all involved bios have mixable attributes 659 * set properly. 660 */ 661 if ((req->cmd_flags | next->cmd_flags) & REQ_MIXED_MERGE || 662 (req->cmd_flags & REQ_FAILFAST_MASK) != 663 (next->cmd_flags & REQ_FAILFAST_MASK)) { 664 blk_rq_set_mixed_merge(req); 665 blk_rq_set_mixed_merge(next); 666 } 667 668 /* 669 * At this point we have either done a back merge 670 * or front merge. We need the smaller start_time of 671 * the merged requests to be the current request 672 * for accounting purposes. 673 */ 674 if (time_after(req->start_time, next->start_time)) 675 req->start_time = next->start_time; 676 677 req->biotail->bi_next = next->bio; 678 req->biotail = next->biotail; 679 680 req->__data_len += blk_rq_bytes(next); 681 682 elv_merge_requests(q, req, next); 683 684 /* 685 * 'next' is going away, so update stats accordingly 686 */ 687 blk_account_io_merge(next); 688 689 req->ioprio = ioprio_best(req->ioprio, next->ioprio); 690 if (blk_rq_cpu_valid(next)) 691 req->cpu = next->cpu; 692 693 /* owner-ship of bio passed from next to req */ 694 next->bio = NULL; 695 __blk_put_request(q, next); 696 return 1; 697 } 698 699 int attempt_back_merge(struct request_queue *q, struct request *rq) 700 { 701 struct request *next = elv_latter_request(q, rq); 702 703 if (next) 704 return attempt_merge(q, rq, next); 705 706 return 0; 707 } 708 709 int attempt_front_merge(struct request_queue *q, struct request *rq) 710 { 711 struct request *prev = elv_former_request(q, rq); 712 713 if (prev) 714 return attempt_merge(q, prev, rq); 715 716 return 0; 717 } 718 719 int blk_attempt_req_merge(struct request_queue *q, struct request *rq, 720 struct request *next) 721 { 722 return attempt_merge(q, rq, next); 723 } 724 725 bool blk_rq_merge_ok(struct request *rq, struct bio *bio) 726 { 727 if (!rq_mergeable(rq) || !bio_mergeable(bio)) 728 return false; 729 730 if (!blk_check_merge_flags(rq->cmd_flags, bio->bi_rw)) 731 return false; 732 733 /* different data direction or already started, don't merge */ 734 if (bio_data_dir(bio) != rq_data_dir(rq)) 735 return false; 736 737 /* must be same device and not a special request */ 738 if (rq->rq_disk != bio->bi_bdev->bd_disk || req_no_special_merge(rq)) 739 return false; 740 741 /* only merge integrity protected bio into ditto rq */ 742 if (blk_integrity_merge_bio(rq->q, rq, bio) == false) 743 return false; 744 745 /* must be using the same buffer */ 746 if (rq->cmd_flags & REQ_WRITE_SAME && 747 !blk_write_same_mergeable(rq->bio, bio)) 748 return false; 749 750 return true; 751 } 752 753 int blk_try_merge(struct request *rq, struct bio *bio) 754 { 755 if (blk_rq_pos(rq) + blk_rq_sectors(rq) == bio->bi_iter.bi_sector) 756 return ELEVATOR_BACK_MERGE; 757 else if (blk_rq_pos(rq) - bio_sectors(bio) == bio->bi_iter.bi_sector) 758 return ELEVATOR_FRONT_MERGE; 759 return ELEVATOR_NO_MERGE; 760 } 761