block/blk-merge.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Functions related to segment and merge handling
   4  */
   5 #include <linux/kernel.h>
   6 #include <linux/module.h>
   7 #include <linux/bio.h>
   8 #include <linux/blkdev.h>
   9 #include <linux/blk-integrity.h>
  10 #include <linux/scatterlist.h>
  11 #include <linux/part_stat.h>
  12 #include <linux/blk-cgroup.h>
  13
  14 #include <trace/events/block.h>
  15
  16 #include "blk.h"
  17 #include "blk-mq-sched.h"
  18 #include "blk-rq-qos.h"
  19 #include "blk-throttle.h"
  20
  21 static inline void bio_get_first_bvec(struct bio *bio, struct bio_vec *bv)
  22 {
  23         *bv = mp_bvec_iter_bvec(bio->bi_io_vec, bio->bi_iter);
  24 }
  25
  26 static inline void bio_get_last_bvec(struct bio *bio, struct bio_vec *bv)
  27 {
  28         struct bvec_iter iter = bio->bi_iter;
  29         int idx;
  30
  31         bio_get_first_bvec(bio, bv);
  32         if (bv->bv_len == bio->bi_iter.bi_size)
  33                 return;         /* this bio only has a single bvec */
  34
  35         bio_advance_iter(bio, &iter, iter.bi_size);
  36
  37         if (!iter.bi_bvec_done)
  38                 idx = iter.bi_idx - 1;
  39         else    /* in the middle of bvec */
  40                 idx = iter.bi_idx;
  41
  42         *bv = bio->bi_io_vec[idx];
  43
  44         /*
  45          * iter.bi_bvec_done records actual length of the last bvec
  46          * if this bio ends in the middle of one io vector
  47          */
  48         if (iter.bi_bvec_done)
  49                 bv->bv_len = iter.bi_bvec_done;
  50 }
  51
  52 static inline bool bio_will_gap(struct request_queue *q,
  53                 struct request *prev_rq, struct bio *prev, struct bio *next)
  54 {
  55         struct bio_vec pb, nb;
  56
  57         if (!bio_has_data(prev) || !queue_virt_boundary(q))
  58                 return false;
  59
  60         /*
  61          * Don't merge if the 1st bio starts with non-zero offset, otherwise it
  62          * is quite difficult to respect the sg gap limit.  We work hard to
  63          * merge a huge number of small single bios in case of mkfs.
  64          */
  65         if (prev_rq)
  66                 bio_get_first_bvec(prev_rq->bio, &pb);
  67         else
  68                 bio_get_first_bvec(prev, &pb);
  69         if (pb.bv_offset & queue_virt_boundary(q))
  70                 return true;
  71
  72         /*
  73          * We don't need to worry about the situation that the merged segment
  74          * ends in unaligned virt boundary:
  75          *
  76          * - if 'pb' ends aligned, the merged segment ends aligned
  77          * - if 'pb' ends unaligned, the next bio must include
  78          *   one single bvec of 'nb', otherwise the 'nb' can't
  79          *   merge with 'pb'
  80          */
  81         bio_get_last_bvec(prev, &pb);
  82         bio_get_first_bvec(next, &nb);
  83         if (biovec_phys_mergeable(q, &pb, &nb))
  84                 return false;
  85         return __bvec_gap_to_prev(&q->limits, &pb, nb.bv_offset);
  86 }
  87
  88 static inline bool req_gap_back_merge(struct request *req, struct bio *bio)
  89 {
  90         return bio_will_gap(req->q, req, req->biotail, bio);
  91 }
  92
  93 static inline bool req_gap_front_merge(struct request *req, struct bio *bio)
  94 {
  95         return bio_will_gap(req->q, NULL, bio, req->bio);
  96 }
  97
  98 /*
  99  * The max size one bio can handle is UINT_MAX becasue bvec_iter.bi_size
 100  * is defined as 'unsigned int', meantime it has to be aligned to with the
 101  * logical block size, which is the minimum accepted unit by hardware.
 102  */
 103 static unsigned int bio_allowed_max_sectors(struct queue_limits *lim)
 104 {
 105         return round_down(UINT_MAX, lim->logical_block_size) >> SECTOR_SHIFT;
 106 }
 107
 108 static struct bio *bio_split_discard(struct bio *bio, struct queue_limits *lim,
 109                 unsigned *nsegs, struct bio_set *bs)
 110 {
 111         unsigned int max_discard_sectors, granularity;
 112         sector_t tmp;
 113         unsigned split_sectors;
 114
 115         *nsegs = 1;
 116
 117         /* Zero-sector (unknown) and one-sector granularities are the same.  */
 118         granularity = max(lim->discard_granularity >> 9, 1U);
 119
 120         max_discard_sectors =
 121                 min(lim->max_discard_sectors, bio_allowed_max_sectors(lim));
 122         max_discard_sectors -= max_discard_sectors % granularity;
 123
 124         if (unlikely(!max_discard_sectors)) {
 125                 /* XXX: warn */
 126                 return NULL;
 127         }
 128
 129         if (bio_sectors(bio) <= max_discard_sectors)
 130                 return NULL;
 131
 132         split_sectors = max_discard_sectors;
 133
 134         /*
 135          * If the next starting sector would be misaligned, stop the discard at
 136          * the previous aligned sector.
 137          */
 138         tmp = bio->bi_iter.bi_sector + split_sectors -
 139                 ((lim->discard_alignment >> 9) % granularity);
 140         tmp = sector_div(tmp, granularity);
 141
 142         if (split_sectors > tmp)
 143                 split_sectors -= tmp;
 144
 145         return bio_split(bio, split_sectors, GFP_NOIO, bs);
 146 }
 147
 148 static struct bio *bio_split_write_zeroes(struct bio *bio,
 149                 struct queue_limits *lim, unsigned *nsegs, struct bio_set *bs)
 150 {
 151         *nsegs = 0;
 152         if (!lim->max_write_zeroes_sectors)
 153                 return NULL;
 154         if (bio_sectors(bio) <= lim->max_write_zeroes_sectors)
 155                 return NULL;
 156         return bio_split(bio, lim->max_write_zeroes_sectors, GFP_NOIO, bs);
 157 }
 158
 159 /*
 160  * Return the maximum number of sectors from the start of a bio that may be
 161  * submitted as a single request to a block device. If enough sectors remain,
 162  * align the end to the physical block size. Otherwise align the end to the
 163  * logical block size. This approach minimizes the number of non-aligned
 164  * requests that are submitted to a block device if the start of a bio is not
 165  * aligned to a physical block boundary.
 166  */
 167 static inline unsigned get_max_io_size(struct bio *bio,
 168                 struct queue_limits *lim)
 169 {
 170         unsigned pbs = lim->physical_block_size >> SECTOR_SHIFT;
 171         unsigned lbs = lim->logical_block_size >> SECTOR_SHIFT;
 172         unsigned max_sectors = lim->max_sectors, start, end;
 173
 174         if (lim->chunk_sectors) {
 175                 max_sectors = min(max_sectors,
 176                         blk_chunk_sectors_left(bio->bi_iter.bi_sector,
 177                                                lim->chunk_sectors));
 178         }
 179
 180         start = bio->bi_iter.bi_sector & (pbs - 1);
 181         end = (start + max_sectors) & ~(pbs - 1);
 182         if (end > start)
 183                 return end - start;
 184         return max_sectors & ~(lbs - 1);
 185 }
 186
 187 static inline unsigned get_max_segment_size(struct queue_limits *lim,
 188                 struct page *start_page, unsigned long offset)
 189 {
 190         unsigned long mask = lim->seg_boundary_mask;
 191
 192         offset = mask & (page_to_phys(start_page) + offset);
 193
 194         /*
 195          * overflow may be triggered in case of zero page physical address
 196          * on 32bit arch, use queue's max segment size when that happens.
 197          */
 198         return min_not_zero(mask - offset + 1,
 199                         (unsigned long)lim->max_segment_size);
 200 }
 201
 202 /**
 203  * bvec_split_segs - verify whether or not a bvec should be split in the middle
 204  * @lim:      [in] queue limits to split based on
 205  * @bv:       [in] bvec to examine
 206  * @nsegs:    [in,out] Number of segments in the bio being built. Incremented
 207  *            by the number of segments from @bv that may be appended to that
 208  *            bio without exceeding @max_segs
 209  * @bytes:    [in,out] Number of bytes in the bio being built. Incremented
 210  *            by the number of bytes from @bv that may be appended to that
 211  *            bio without exceeding @max_bytes
 212  * @max_segs: [in] upper bound for *@nsegs
 213  * @max_bytes: [in] upper bound for *@bytes
 214  *
 215  * When splitting a bio, it can happen that a bvec is encountered that is too
 216  * big to fit in a single segment and hence that it has to be split in the
 217  * middle. This function verifies whether or not that should happen. The value
 218  * %true is returned if and only if appending the entire @bv to a bio with
 219  * *@nsegs segments and *@sectors sectors would make that bio unacceptable for
 220  * the block driver.
 221  */
 222 static bool bvec_split_segs(struct queue_limits *lim, const struct bio_vec *bv,
 223                 unsigned *nsegs, unsigned *bytes, unsigned max_segs,
 224                 unsigned max_bytes)
 225 {
 226         unsigned max_len = min(max_bytes, UINT_MAX) - *bytes;
 227         unsigned len = min(bv->bv_len, max_len);
 228         unsigned total_len = 0;
 229         unsigned seg_size = 0;
 230
 231         while (len && *nsegs < max_segs) {
 232                 seg_size = get_max_segment_size(lim, bv->bv_page,
 233                                                 bv->bv_offset + total_len);
 234                 seg_size = min(seg_size, len);
 235
 236                 (*nsegs)++;
 237                 total_len += seg_size;
 238                 len -= seg_size;
 239
 240                 if ((bv->bv_offset + total_len) & lim->virt_boundary_mask)
 241                         break;
 242         }
 243
 244         *bytes += total_len;
 245
 246         /* tell the caller to split the bvec if it is too big to fit */
 247         return len > 0 || bv->bv_len > max_len;
 248 }
 249
 250 /**
 251  * bio_split_rw - split a bio in two bios
 252  * @bio:  [in] bio to be split
 253  * @lim:  [in] queue limits to split based on
 254  * @segs: [out] number of segments in the bio with the first half of the sectors
 255  * @bs:   [in] bio set to allocate the clone from
 256  * @max_bytes: [in] maximum number of bytes per bio
 257  *
 258  * Clone @bio, update the bi_iter of the clone to represent the first sectors
 259  * of @bio and update @bio->bi_iter to represent the remaining sectors. The
 260  * following is guaranteed for the cloned bio:
 261  * - That it has at most @max_bytes worth of data
 262  * - That it has at most queue_max_segments(@q) segments.
 263  *
 264  * Except for discard requests the cloned bio will point at the bi_io_vec of
 265  * the original bio. It is the responsibility of the caller to ensure that the
 266  * original bio is not freed before the cloned bio. The caller is also
 267  * responsible for ensuring that @bs is only destroyed after processing of the
 268  * split bio has finished.
 269  */
 270 static struct bio *bio_split_rw(struct bio *bio, struct queue_limits *lim,
 271                 unsigned *segs, struct bio_set *bs, unsigned max_bytes)
 272 {
 273         struct bio_vec bv, bvprv, *bvprvp = NULL;
 274         struct bvec_iter iter;
 275         unsigned nsegs = 0, bytes = 0;
 276
 277         bio_for_each_bvec(bv, bio, iter) {
 278                 /*
 279                  * If the queue doesn't support SG gaps and adding this
 280                  * offset would create a gap, disallow it.
 281                  */
 282                 if (bvprvp && bvec_gap_to_prev(lim, bvprvp, bv.bv_offset))
 283                         goto split;
 284
 285                 if (nsegs < lim->max_segments &&
 286                     bytes + bv.bv_len <= max_bytes &&
 287                     bv.bv_offset + bv.bv_len <= PAGE_SIZE) {
 288                         nsegs++;
 289                         bytes += bv.bv_len;
 290                 } else {
 291                         if (bvec_split_segs(lim, &bv, &nsegs, &bytes,
 292                                         lim->max_segments, max_bytes))
 293                                 goto split;
 294                 }
 295
 296                 bvprv = bv;
 297                 bvprvp = &bvprv;
 298         }
 299
 300         *segs = nsegs;
 301         return NULL;
 302 split:
 303         /*
 304          * We can't sanely support splitting for a REQ_NOWAIT bio. End it
 305          * with EAGAIN if splitting is required and return an error pointer.
 306          */
 307         if (bio->bi_opf & REQ_NOWAIT) {
 308                 bio->bi_status = BLK_STS_AGAIN;
 309                 bio_endio(bio);
 310                 return ERR_PTR(-EAGAIN);
 311         }
 312
 313         *segs = nsegs;
 314
 315         /*
 316          * Individual bvecs might not be logical block aligned. Round down the
 317          * split size so that each bio is properly block size aligned, even if
 318          * we do not use the full hardware limits.
 319          */
 320         bytes = ALIGN_DOWN(bytes, lim->logical_block_size);
 321
 322         /*
 323          * Bio splitting may cause subtle trouble such as hang when doing sync
 324          * iopoll in direct IO routine. Given performance gain of iopoll for
 325          * big IO can be trival, disable iopoll when split needed.
 326          */
 327         bio_clear_polled(bio);
 328         return bio_split(bio, bytes >> SECTOR_SHIFT, GFP_NOIO, bs);
 329 }
 330
 331 /**
 332  * __bio_split_to_limits - split a bio to fit the queue limits
 333  * @bio:     bio to be split
 334  * @lim:     queue limits to split based on
 335  * @nr_segs: returns the number of segments in the returned bio
 336  *
 337  * Check if @bio needs splitting based on the queue limits, and if so split off
 338  * a bio fitting the limits from the beginning of @bio and return it.  @bio is
 339  * shortened to the remainder and re-submitted.
 340  *
 341  * The split bio is allocated from @q->bio_split, which is provided by the
 342  * block layer.
 343  */
 344 struct bio *__bio_split_to_limits(struct bio *bio, struct queue_limits *lim,
 345                        unsigned int *nr_segs)
 346 {
 347         struct bio_set *bs = &bio->bi_bdev->bd_disk->bio_split;
 348         struct bio *split;
 349
 350         switch (bio_op(bio)) {
 351         case REQ_OP_DISCARD:
 352         case REQ_OP_SECURE_ERASE:
 353                 split = bio_split_discard(bio, lim, nr_segs, bs);
 354                 break;
 355         case REQ_OP_WRITE_ZEROES:
 356                 split = bio_split_write_zeroes(bio, lim, nr_segs, bs);
 357                 break;
 358         default:
 359                 split = bio_split_rw(bio, lim, nr_segs, bs,
 360                                 get_max_io_size(bio, lim) << SECTOR_SHIFT);
 361                 if (IS_ERR(split))
 362                         return NULL;
 363                 break;
 364         }
 365
 366         if (split) {
 367                 /* there isn't chance to merge the split bio */
 368                 split->bi_opf |= REQ_NOMERGE;
 369
 370                 blkcg_bio_issue_init(split);
 371                 bio_chain(split, bio);
 372                 trace_block_split(split, bio->bi_iter.bi_sector);
 373                 submit_bio_noacct(bio);
 374                 return split;
 375         }
 376         return bio;
 377 }
 378
 379 /**
 380  * bio_split_to_limits - split a bio to fit the queue limits
 381  * @bio:     bio to be split
 382  *
 383  * Check if @bio needs splitting based on the queue limits of @bio->bi_bdev, and
 384  * if so split off a bio fitting the limits from the beginning of @bio and
 385  * return it.  @bio is shortened to the remainder and re-submitted.
 386  *
 387  * The split bio is allocated from @q->bio_split, which is provided by the
 388  * block layer.
 389  */
 390 struct bio *bio_split_to_limits(struct bio *bio)
 391 {
 392         struct queue_limits *lim = &bdev_get_queue(bio->bi_bdev)->limits;
 393         unsigned int nr_segs;
 394
 395         if (bio_may_exceed_limits(bio, lim))
 396                 return __bio_split_to_limits(bio, lim, &nr_segs);
 397         return bio;
 398 }
 399 EXPORT_SYMBOL(bio_split_to_limits);
 400
 401 unsigned int blk_recalc_rq_segments(struct request *rq)
 402 {
 403         unsigned int nr_phys_segs = 0;
 404         unsigned int bytes = 0;
 405         struct req_iterator iter;
 406         struct bio_vec bv;
 407
 408         if (!rq->bio)
 409                 return 0;
 410
 411         switch (bio_op(rq->bio)) {
 412         case REQ_OP_DISCARD:
 413         case REQ_OP_SECURE_ERASE:
 414                 if (queue_max_discard_segments(rq->q) > 1) {
 415                         struct bio *bio = rq->bio;
 416
 417                         for_each_bio(bio)
 418                                 nr_phys_segs++;
 419                         return nr_phys_segs;
 420                 }
 421                 return 1;
 422         case REQ_OP_WRITE_ZEROES:
 423                 return 0;
 424         default:
 425                 break;
 426         }
 427
 428         rq_for_each_bvec(bv, rq, iter)
 429                 bvec_split_segs(&rq->q->limits, &bv, &nr_phys_segs, &bytes,
 430                                 UINT_MAX, UINT_MAX);
 431         return nr_phys_segs;
 432 }
 433
 434 static inline struct scatterlist *blk_next_sg(struct scatterlist **sg,
 435                 struct scatterlist *sglist)
 436 {
 437         if (!*sg)
 438                 return sglist;
 439
 440         /*
 441          * If the driver previously mapped a shorter list, we could see a
 442          * termination bit prematurely unless it fully inits the sg table
 443          * on each mapping. We KNOW that there must be more entries here
 444          * or the driver would be buggy, so force clear the termination bit
 445          * to avoid doing a full sg_init_table() in drivers for each command.
 446          */
 447         sg_unmark_end(*sg);
 448         return sg_next(*sg);
 449 }
 450
 451 static unsigned blk_bvec_map_sg(struct request_queue *q,
 452                 struct bio_vec *bvec, struct scatterlist *sglist,
 453                 struct scatterlist **sg)
 454 {
 455         unsigned nbytes = bvec->bv_len;
 456         unsigned nsegs = 0, total = 0;
 457
 458         while (nbytes > 0) {
 459                 unsigned offset = bvec->bv_offset + total;
 460                 unsigned len = min(get_max_segment_size(&q->limits,
 461                                    bvec->bv_page, offset), nbytes);
 462                 struct page *page = bvec->bv_page;
 463
 464                 /*
 465                  * Unfortunately a fair number of drivers barf on scatterlists
 466                  * that have an offset larger than PAGE_SIZE, despite other
 467                  * subsystems dealing with that invariant just fine.  For now
 468                  * stick to the legacy format where we never present those from
 469                  * the block layer, but the code below should be removed once
 470                  * these offenders (mostly MMC/SD drivers) are fixed.
 471                  */
 472                 page += (offset >> PAGE_SHIFT);
 473                 offset &= ~PAGE_MASK;
 474
 475                 *sg = blk_next_sg(sg, sglist);
 476                 sg_set_page(*sg, page, len, offset);
 477
 478                 total += len;
 479                 nbytes -= len;
 480                 nsegs++;
 481         }
 482
 483         return nsegs;
 484 }
 485
 486 static inline int __blk_bvec_map_sg(struct bio_vec bv,
 487                 struct scatterlist *sglist, struct scatterlist **sg)
 488 {
 489         *sg = blk_next_sg(sg, sglist);
 490         sg_set_page(*sg, bv.bv_page, bv.bv_len, bv.bv_offset);
 491         return 1;
 492 }
 493
 494 /* only try to merge bvecs into one sg if they are from two bios */
 495 static inline bool
 496 __blk_segment_map_sg_merge(struct request_queue *q, struct bio_vec *bvec,
 497                            struct bio_vec *bvprv, struct scatterlist **sg)
 498 {
 499
 500         int nbytes = bvec->bv_len;
 501
 502         if (!*sg)
 503                 return false;
 504
 505         if ((*sg)->length + nbytes > queue_max_segment_size(q))
 506                 return false;
 507
 508         if (!biovec_phys_mergeable(q, bvprv, bvec))
 509                 return false;
 510
 511         (*sg)->length += nbytes;
 512
 513         return true;
 514 }
 515
 516 static int __blk_bios_map_sg(struct request_queue *q, struct bio *bio,
 517                              struct scatterlist *sglist,
 518                              struct scatterlist **sg)
 519 {
 520         struct bio_vec bvec, bvprv = { NULL };
 521         struct bvec_iter iter;
 522         int nsegs = 0;
 523         bool new_bio = false;
 524
 525         for_each_bio(bio) {
 526                 bio_for_each_bvec(bvec, bio, iter) {
 527                         /*
 528                          * Only try to merge bvecs from two bios given we
 529                          * have done bio internal merge when adding pages
 530                          * to bio
 531                          */
 532                         if (new_bio &&
 533                             __blk_segment_map_sg_merge(q, &bvec, &bvprv, sg))
 534                                 goto next_bvec;
 535
 536                         if (bvec.bv_offset + bvec.bv_len <= PAGE_SIZE)
 537                                 nsegs += __blk_bvec_map_sg(bvec, sglist, sg);
 538                         else
 539                                 nsegs += blk_bvec_map_sg(q, &bvec, sglist, sg);
 540  next_bvec:
 541                         new_bio = false;
 542                 }
 543                 if (likely(bio->bi_iter.bi_size)) {
 544                         bvprv = bvec;
 545                         new_bio = true;
 546                 }
 547         }
 548
 549         return nsegs;
 550 }
 551
 552 /*
 553  * map a request to scatterlist, return number of sg entries setup. Caller
 554  * must make sure sg can hold rq->nr_phys_segments entries
 555  */
 556 int __blk_rq_map_sg(struct request_queue *q, struct request *rq,
 557                 struct scatterlist *sglist, struct scatterlist **last_sg)
 558 {
 559         int nsegs = 0;
 560
 561         if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
 562                 nsegs = __blk_bvec_map_sg(rq->special_vec, sglist, last_sg);
 563         else if (rq->bio)
 564                 nsegs = __blk_bios_map_sg(q, rq->bio, sglist, last_sg);
 565
 566         if (*last_sg)
 567                 sg_mark_end(*last_sg);
 568
 569         /*
 570          * Something must have been wrong if the figured number of
 571          * segment is bigger than number of req's physical segments
 572          */
 573         WARN_ON(nsegs > blk_rq_nr_phys_segments(rq));
 574
 575         return nsegs;
 576 }
 577 EXPORT_SYMBOL(__blk_rq_map_sg);
 578
 579 static inline unsigned int blk_rq_get_max_segments(struct request *rq)
 580 {
 581         if (req_op(rq) == REQ_OP_DISCARD)
 582                 return queue_max_discard_segments(rq->q);
 583         return queue_max_segments(rq->q);
 584 }
 585
 586 static inline unsigned int blk_rq_get_max_sectors(struct request *rq,
 587                                                   sector_t offset)
 588 {
 589         struct request_queue *q = rq->q;
 590         unsigned int max_sectors;
 591
 592         if (blk_rq_is_passthrough(rq))
 593                 return q->limits.max_hw_sectors;
 594
 595         max_sectors = blk_queue_get_max_sectors(q, req_op(rq));
 596         if (!q->limits.chunk_sectors ||
 597             req_op(rq) == REQ_OP_DISCARD ||
 598             req_op(rq) == REQ_OP_SECURE_ERASE)
 599                 return max_sectors;
 600         return min(max_sectors,
 601                    blk_chunk_sectors_left(offset, q->limits.chunk_sectors));
 602 }
 603
 604 static inline int ll_new_hw_segment(struct request *req, struct bio *bio,
 605                 unsigned int nr_phys_segs)
 606 {
 607         if (!blk_cgroup_mergeable(req, bio))
 608                 goto no_merge;
 609
 610         if (blk_integrity_merge_bio(req->q, req, bio) == false)
 611                 goto no_merge;
 612
 613         /* discard request merge won't add new segment */
 614         if (req_op(req) == REQ_OP_DISCARD)
 615                 return 1;
 616
 617         if (req->nr_phys_segments + nr_phys_segs > blk_rq_get_max_segments(req))
 618                 goto no_merge;
 619
 620         /*
 621          * This will form the start of a new hw segment.  Bump both
 622          * counters.
 623          */
 624         req->nr_phys_segments += nr_phys_segs;
 625         return 1;
 626
 627 no_merge:
 628         req_set_nomerge(req->q, req);
 629         return 0;
 630 }
 631
 632 int ll_back_merge_fn(struct request *req, struct bio *bio, unsigned int nr_segs)
 633 {
 634         if (req_gap_back_merge(req, bio))
 635                 return 0;
 636         if (blk_integrity_rq(req) &&
 637             integrity_req_gap_back_merge(req, bio))
 638                 return 0;
 639         if (!bio_crypt_ctx_back_mergeable(req, bio))
 640                 return 0;
 641         if (blk_rq_sectors(req) + bio_sectors(bio) >
 642             blk_rq_get_max_sectors(req, blk_rq_pos(req))) {
 643                 req_set_nomerge(req->q, req);
 644                 return 0;
 645         }
 646
 647         return ll_new_hw_segment(req, bio, nr_segs);
 648 }
 649
 650 static int ll_front_merge_fn(struct request *req, struct bio *bio,
 651                 unsigned int nr_segs)
 652 {
 653         if (req_gap_front_merge(req, bio))
 654                 return 0;
 655         if (blk_integrity_rq(req) &&
 656             integrity_req_gap_front_merge(req, bio))
 657                 return 0;
 658         if (!bio_crypt_ctx_front_mergeable(req, bio))
 659                 return 0;
 660         if (blk_rq_sectors(req) + bio_sectors(bio) >
 661             blk_rq_get_max_sectors(req, bio->bi_iter.bi_sector)) {
 662                 req_set_nomerge(req->q, req);
 663                 return 0;
 664         }
 665
 666         return ll_new_hw_segment(req, bio, nr_segs);
 667 }
 668
 669 static bool req_attempt_discard_merge(struct request_queue *q, struct request *req,
 670                 struct request *next)
 671 {
 672         unsigned short segments = blk_rq_nr_discard_segments(req);
 673
 674         if (segments >= queue_max_discard_segments(q))
 675                 goto no_merge;
 676         if (blk_rq_sectors(req) + bio_sectors(next->bio) >
 677             blk_rq_get_max_sectors(req, blk_rq_pos(req)))
 678                 goto no_merge;
 679
 680         req->nr_phys_segments = segments + blk_rq_nr_discard_segments(next);
 681         return true;
 682 no_merge:
 683         req_set_nomerge(q, req);
 684         return false;
 685 }
 686
 687 static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
 688                                 struct request *next)
 689 {
 690         int total_phys_segments;
 691
 692         if (req_gap_back_merge(req, next->bio))
 693                 return 0;
 694
 695         /*
 696          * Will it become too large?
 697          */
 698         if ((blk_rq_sectors(req) + blk_rq_sectors(next)) >
 699             blk_rq_get_max_sectors(req, blk_rq_pos(req)))
 700                 return 0;
 701
 702         total_phys_segments = req->nr_phys_segments + next->nr_phys_segments;
 703         if (total_phys_segments > blk_rq_get_max_segments(req))
 704                 return 0;
 705
 706         if (!blk_cgroup_mergeable(req, next->bio))
 707                 return 0;
 708
 709         if (blk_integrity_merge_rq(q, req, next) == false)
 710                 return 0;
 711
 712         if (!bio_crypt_ctx_merge_rq(req, next))
 713                 return 0;
 714
 715         /* Merge is OK... */
 716         req->nr_phys_segments = total_phys_segments;
 717         return 1;
 718 }
 719
 720 /**
 721  * blk_rq_set_mixed_merge - mark a request as mixed merge
 722  * @rq: request to mark as mixed merge
 723  *
 724  * Description:
 725  *     @rq is about to be mixed merged.  Make sure the attributes
 726  *     which can be mixed are set in each bio and mark @rq as mixed
 727  *     merged.
 728  */
 729 void blk_rq_set_mixed_merge(struct request *rq)
 730 {
 731         blk_opf_t ff = rq->cmd_flags & REQ_FAILFAST_MASK;
 732         struct bio *bio;
 733
 734         if (rq->rq_flags & RQF_MIXED_MERGE)
 735                 return;
 736
 737         /*
 738          * @rq will no longer represent mixable attributes for all the
 739          * contained bios.  It will just track those of the first one.
 740          * Distributes the attributs to each bio.
 741          */
 742         for (bio = rq->bio; bio; bio = bio->bi_next) {
 743                 WARN_ON_ONCE((bio->bi_opf & REQ_FAILFAST_MASK) &&
 744                              (bio->bi_opf & REQ_FAILFAST_MASK) != ff);
 745                 bio->bi_opf |= ff;
 746         }
 747         rq->rq_flags |= RQF_MIXED_MERGE;
 748 }
 749
 750 static inline blk_opf_t bio_failfast(const struct bio *bio)
 751 {
 752         if (bio->bi_opf & REQ_RAHEAD)
 753                 return REQ_FAILFAST_MASK;
 754
 755         return bio->bi_opf & REQ_FAILFAST_MASK;
 756 }
 757
 758 /*
 759  * After we are marked as MIXED_MERGE, any new RA bio has to be updated
 760  * as failfast, and request's failfast has to be updated in case of
 761  * front merge.
 762  */
 763 static inline void blk_update_mixed_merge(struct request *req,
 764                 struct bio *bio, bool front_merge)
 765 {
 766         if (req->rq_flags & RQF_MIXED_MERGE) {
 767                 if (bio->bi_opf & REQ_RAHEAD)
 768                         bio->bi_opf |= REQ_FAILFAST_MASK;
 769
 770                 if (front_merge) {
 771                         req->cmd_flags &= ~REQ_FAILFAST_MASK;
 772                         req->cmd_flags |= bio->bi_opf & REQ_FAILFAST_MASK;
 773                 }
 774         }
 775 }
 776
 777 static void blk_account_io_merge_request(struct request *req)
 778 {
 779         if (blk_do_io_stat(req)) {
 780                 part_stat_lock();
 781                 part_stat_inc(req->part, merges[op_stat_group(req_op(req))]);
 782                 part_stat_unlock();
 783         }
 784 }
 785
 786 static enum elv_merge blk_try_req_merge(struct request *req,
 787                                         struct request *next)
 788 {
 789         if (blk_discard_mergable(req))
 790                 return ELEVATOR_DISCARD_MERGE;
 791         else if (blk_rq_pos(req) + blk_rq_sectors(req) == blk_rq_pos(next))
 792                 return ELEVATOR_BACK_MERGE;
 793
 794         return ELEVATOR_NO_MERGE;
 795 }
 796
 797 /*
 798  * For non-mq, this has to be called with the request spinlock acquired.
 799  * For mq with scheduling, the appropriate queue wide lock should be held.
 800  */
 801 static struct request *attempt_merge(struct request_queue *q,
 802                                      struct request *req, struct request *next)
 803 {
 804         if (!rq_mergeable(req) || !rq_mergeable(next))
 805                 return NULL;
 806
 807         if (req_op(req) != req_op(next))
 808                 return NULL;
 809
 810         if (rq_data_dir(req) != rq_data_dir(next))
 811                 return NULL;
 812
 813         if (req->ioprio != next->ioprio)
 814                 return NULL;
 815
 816         /*
 817          * If we are allowed to merge, then append bio list
 818          * from next to rq and release next. merge_requests_fn
 819          * will have updated segment counts, update sector
 820          * counts here. Handle DISCARDs separately, as they
 821          * have separate settings.
 822          */
 823
 824         switch (blk_try_req_merge(req, next)) {
 825         case ELEVATOR_DISCARD_MERGE:
 826                 if (!req_attempt_discard_merge(q, req, next))
 827                         return NULL;
 828                 break;
 829         case ELEVATOR_BACK_MERGE:
 830                 if (!ll_merge_requests_fn(q, req, next))
 831                         return NULL;
 832                 break;
 833         default:
 834                 return NULL;
 835         }
 836
 837         /*
 838          * If failfast settings disagree or any of the two is already
 839          * a mixed merge, mark both as mixed before proceeding.  This
 840          * makes sure that all involved bios have mixable attributes
 841          * set properly.
 842          */
 843         if (((req->rq_flags | next->rq_flags) & RQF_MIXED_MERGE) ||
 844             (req->cmd_flags & REQ_FAILFAST_MASK) !=
 845             (next->cmd_flags & REQ_FAILFAST_MASK)) {
 846                 blk_rq_set_mixed_merge(req);
 847                 blk_rq_set_mixed_merge(next);
 848         }
 849
 850         /*
 851          * At this point we have either done a back merge or front merge. We
 852          * need the smaller start_time_ns of the merged requests to be the
 853          * current request for accounting purposes.
 854          */
 855         if (next->start_time_ns < req->start_time_ns)
 856                 req->start_time_ns = next->start_time_ns;
 857
 858         req->biotail->bi_next = next->bio;
 859         req->biotail = next->biotail;
 860
 861         req->__data_len += blk_rq_bytes(next);
 862
 863         if (!blk_discard_mergable(req))
 864                 elv_merge_requests(q, req, next);
 865
 866         blk_crypto_rq_put_keyslot(next);
 867
 868         /*
 869          * 'next' is going away, so update stats accordingly
 870          */
 871         blk_account_io_merge_request(next);
 872
 873         trace_block_rq_merge(next);
 874
 875         /*
 876          * ownership of bio passed from next to req, return 'next' for
 877          * the caller to free
 878          */
 879         next->bio = NULL;
 880         return next;
 881 }
 882
 883 static struct request *attempt_back_merge(struct request_queue *q,
 884                 struct request *rq)
 885 {
 886         struct request *next = elv_latter_request(q, rq);
 887
 888         if (next)
 889                 return attempt_merge(q, rq, next);
 890
 891         return NULL;
 892 }
 893
 894 static struct request *attempt_front_merge(struct request_queue *q,
 895                 struct request *rq)
 896 {
 897         struct request *prev = elv_former_request(q, rq);
 898
 899         if (prev)
 900                 return attempt_merge(q, prev, rq);
 901
 902         return NULL;
 903 }
 904
 905 /*
 906  * Try to merge 'next' into 'rq'. Return true if the merge happened, false
 907  * otherwise. The caller is responsible for freeing 'next' if the merge
 908  * happened.
 909  */
 910 bool blk_attempt_req_merge(struct request_queue *q, struct request *rq,
 911                            struct request *next)
 912 {
 913         return attempt_merge(q, rq, next);
 914 }
 915
 916 bool blk_rq_merge_ok(struct request *rq, struct bio *bio)
 917 {
 918         if (!rq_mergeable(rq) || !bio_mergeable(bio))
 919                 return false;
 920
 921         if (req_op(rq) != bio_op(bio))
 922                 return false;
 923
 924         /* different data direction or already started, don't merge */
 925         if (bio_data_dir(bio) != rq_data_dir(rq))
 926                 return false;
 927
 928         /* don't merge across cgroup boundaries */
 929         if (!blk_cgroup_mergeable(rq, bio))
 930                 return false;
 931
 932         /* only merge integrity protected bio into ditto rq */
 933         if (blk_integrity_merge_bio(rq->q, rq, bio) == false)
 934                 return false;
 935
 936         /* Only merge if the crypt contexts are compatible */
 937         if (!bio_crypt_rq_ctx_compatible(rq, bio))
 938                 return false;
 939
 940         if (rq->ioprio != bio_prio(bio))
 941                 return false;
 942
 943         return true;
 944 }
 945
 946 enum elv_merge blk_try_merge(struct request *rq, struct bio *bio)
 947 {
 948         if (blk_discard_mergable(rq))
 949                 return ELEVATOR_DISCARD_MERGE;
 950         else if (blk_rq_pos(rq) + blk_rq_sectors(rq) == bio->bi_iter.bi_sector)
 951                 return ELEVATOR_BACK_MERGE;
 952         else if (blk_rq_pos(rq) - bio_sectors(bio) == bio->bi_iter.bi_sector)
 953                 return ELEVATOR_FRONT_MERGE;
 954         return ELEVATOR_NO_MERGE;
 955 }
 956
 957 static void blk_account_io_merge_bio(struct request *req)
 958 {
 959         if (!blk_do_io_stat(req))
 960                 return;
 961
 962         part_stat_lock();
 963         part_stat_inc(req->part, merges[op_stat_group(req_op(req))]);
 964         part_stat_unlock();
 965 }
 966
 967 enum bio_merge_status {
 968         BIO_MERGE_OK,
 969         BIO_MERGE_NONE,
 970         BIO_MERGE_FAILED,
 971 };
 972
 973 static enum bio_merge_status bio_attempt_back_merge(struct request *req,
 974                 struct bio *bio, unsigned int nr_segs)
 975 {
 976         const blk_opf_t ff = bio_failfast(bio);
 977
 978         if (!ll_back_merge_fn(req, bio, nr_segs))
 979                 return BIO_MERGE_FAILED;
 980
 981         trace_block_bio_backmerge(bio);
 982         rq_qos_merge(req->q, req, bio);
 983
 984         if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff)
 985                 blk_rq_set_mixed_merge(req);
 986
 987         blk_update_mixed_merge(req, bio, false);
 988
 989         req->biotail->bi_next = bio;
 990         req->biotail = bio;
 991         req->__data_len += bio->bi_iter.bi_size;
 992
 993         bio_crypt_free_ctx(bio);
 994
 995         blk_account_io_merge_bio(req);
 996         return BIO_MERGE_OK;
 997 }
 998
 999 static enum bio_merge_status bio_attempt_front_merge(struct request *req,
1000                 struct bio *bio, unsigned int nr_segs)
1001 {
1002         const blk_opf_t ff = bio_failfast(bio);
1003
1004         if (!ll_front_merge_fn(req, bio, nr_segs))
1005                 return BIO_MERGE_FAILED;
1006
1007         trace_block_bio_frontmerge(bio);
1008         rq_qos_merge(req->q, req, bio);
1009
1010         if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff)
1011                 blk_rq_set_mixed_merge(req);
1012
1013         blk_update_mixed_merge(req, bio, true);
1014
1015         bio->bi_next = req->bio;
1016         req->bio = bio;
1017
1018         req->__sector = bio->bi_iter.bi_sector;
1019         req->__data_len += bio->bi_iter.bi_size;
1020
1021         bio_crypt_do_front_merge(req, bio);
1022
1023         blk_account_io_merge_bio(req);
1024         return BIO_MERGE_OK;
1025 }
1026
1027 static enum bio_merge_status bio_attempt_discard_merge(struct request_queue *q,
1028                 struct request *req, struct bio *bio)
1029 {
1030         unsigned short segments = blk_rq_nr_discard_segments(req);
1031
1032         if (segments >= queue_max_discard_segments(q))
1033                 goto no_merge;
1034         if (blk_rq_sectors(req) + bio_sectors(bio) >
1035             blk_rq_get_max_sectors(req, blk_rq_pos(req)))
1036                 goto no_merge;
1037
1038         rq_qos_merge(q, req, bio);
1039
1040         req->biotail->bi_next = bio;
1041         req->biotail = bio;
1042         req->__data_len += bio->bi_iter.bi_size;
1043         req->nr_phys_segments = segments + 1;
1044
1045         blk_account_io_merge_bio(req);
1046         return BIO_MERGE_OK;
1047 no_merge:
1048         req_set_nomerge(q, req);
1049         return BIO_MERGE_FAILED;
1050 }
1051
1052 static enum bio_merge_status blk_attempt_bio_merge(struct request_queue *q,
1053                                                    struct request *rq,
1054                                                    struct bio *bio,
1055                                                    unsigned int nr_segs,
1056                                                    bool sched_allow_merge)
1057 {
1058         if (!blk_rq_merge_ok(rq, bio))
1059                 return BIO_MERGE_NONE;
1060
1061         switch (blk_try_merge(rq, bio)) {
1062         case ELEVATOR_BACK_MERGE:
1063                 if (!sched_allow_merge || blk_mq_sched_allow_merge(q, rq, bio))
1064                         return bio_attempt_back_merge(rq, bio, nr_segs);
1065                 break;
1066         case ELEVATOR_FRONT_MERGE:
1067                 if (!sched_allow_merge || blk_mq_sched_allow_merge(q, rq, bio))
1068                         return bio_attempt_front_merge(rq, bio, nr_segs);
1069                 break;
1070         case ELEVATOR_DISCARD_MERGE:
1071                 return bio_attempt_discard_merge(q, rq, bio);
1072         default:
1073                 return BIO_MERGE_NONE;
1074         }
1075
1076         return BIO_MERGE_FAILED;
1077 }
1078
1079 /**
1080  * blk_attempt_plug_merge - try to merge with %current's plugged list
1081  * @q: request_queue new bio is being queued at
1082  * @bio: new bio being queued
1083  * @nr_segs: number of segments in @bio
1084  * from the passed in @q already in the plug list
1085  *
1086  * Determine whether @bio being queued on @q can be merged with the previous
1087  * request on %current's plugged list.  Returns %true if merge was successful,
1088  * otherwise %false.
1089  *
1090  * Plugging coalesces IOs from the same issuer for the same purpose without
1091  * going through @q->queue_lock.  As such it's more of an issuing mechanism
1092  * than scheduling, and the request, while may have elvpriv data, is not
1093  * added on the elevator at this point.  In addition, we don't have
1094  * reliable access to the elevator outside queue lock.  Only check basic
1095  * merging parameters without querying the elevator.
1096  *
1097  * Caller must ensure !blk_queue_nomerges(q) beforehand.
1098  */
1099 bool blk_attempt_plug_merge(struct request_queue *q, struct bio *bio,
1100                 unsigned int nr_segs)
1101 {
1102         struct blk_plug *plug;
1103         struct request *rq;
1104
1105         plug = blk_mq_plug(bio);
1106         if (!plug || rq_list_empty(plug->mq_list))
1107                 return false;
1108
1109         rq_list_for_each(&plug->mq_list, rq) {
1110                 if (rq->q == q) {
1111                         if (blk_attempt_bio_merge(q, rq, bio, nr_segs, false) ==
1112                             BIO_MERGE_OK)
1113                                 return true;
1114                         break;
1115                 }
1116
1117                 /*
1118                  * Only keep iterating plug list for merges if we have multiple
1119                  * queues
1120                  */
1121                 if (!plug->multiple_queues)
1122                         break;
1123         }
1124         return false;
1125 }
1126
1127 /*
1128  * Iterate list of requests and see if we can merge this bio with any
1129  * of them.
1130  */
1131 bool blk_bio_list_merge(struct request_queue *q, struct list_head *list,
1132                         struct bio *bio, unsigned int nr_segs)
1133 {
1134         struct request *rq;
1135         int checked = 8;
1136
1137         list_for_each_entry_reverse(rq, list, queuelist) {
1138                 if (!checked--)
1139                         break;
1140
1141                 switch (blk_attempt_bio_merge(q, rq, bio, nr_segs, true)) {
1142                 case BIO_MERGE_NONE:
1143                         continue;
1144                 case BIO_MERGE_OK:
1145                         return true;
1146                 case BIO_MERGE_FAILED:
1147                         return false;
1148                 }
1149
1150         }
1151
1152         return false;
1153 }
1154 EXPORT_SYMBOL_GPL(blk_bio_list_merge);
1155
1156 bool blk_mq_sched_try_merge(struct request_queue *q, struct bio *bio,
1157                 unsigned int nr_segs, struct request **merged_request)
1158 {
1159         struct request *rq;
1160
1161         switch (elv_merge(q, &rq, bio)) {
1162         case ELEVATOR_BACK_MERGE:
1163                 if (!blk_mq_sched_allow_merge(q, rq, bio))
1164                         return false;
1165                 if (bio_attempt_back_merge(rq, bio, nr_segs) != BIO_MERGE_OK)
1166                         return false;
1167                 *merged_request = attempt_back_merge(q, rq);
1168                 if (!*merged_request)
1169                         elv_merged_request(q, rq, ELEVATOR_BACK_MERGE);
1170                 return true;
1171         case ELEVATOR_FRONT_MERGE:
1172                 if (!blk_mq_sched_allow_merge(q, rq, bio))
1173                         return false;
1174                 if (bio_attempt_front_merge(rq, bio, nr_segs) != BIO_MERGE_OK)
1175                         return false;
1176                 *merged_request = attempt_front_merge(q, rq);
1177                 if (!*merged_request)
1178                         elv_merged_request(q, rq, ELEVATOR_FRONT_MERGE);
1179                 return true;
1180         case ELEVATOR_DISCARD_MERGE:
1181                 return bio_attempt_discard_merge(q, rq, bio) == BIO_MERGE_OK;
1182         default:
1183                 return false;
1184         }
1185 }
1186 EXPORT_SYMBOL_GPL(blk_mq_sched_try_merge);