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