LCOV - code coverage report
Current view: top level - block - blk-merge.c (source / functions) Hit Total Coverage
Test: Real Lines: 198 273 72.5 %
Date: 2020-10-17 15:46:16 Functions: 2 28 7.1 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :            : 
      11                 :            : #include <trace/events/block.h>
      12                 :            : 
      13                 :            : #include "blk.h"
      14                 :            : 
      15                 :          3 : static inline bool bio_will_gap(struct request_queue *q,
      16                 :            :                 struct request *prev_rq, struct bio *prev, struct bio *next)
      17                 :            : {
      18                 :            :         struct bio_vec pb, nb;
      19                 :            : 
      20                 :          3 :         if (!bio_has_data(prev) || !queue_virt_boundary(q))
      21                 :            :                 return false;
      22                 :            : 
      23                 :            :         /*
      24                 :            :          * Don't merge if the 1st bio starts with non-zero offset, otherwise it
      25                 :            :          * is quite difficult to respect the sg gap limit.  We work hard to
      26                 :            :          * merge a huge number of small single bios in case of mkfs.
      27                 :            :          */
      28                 :          0 :         if (prev_rq)
      29                 :          0 :                 bio_get_first_bvec(prev_rq->bio, &pb);
      30                 :            :         else
      31                 :          0 :                 bio_get_first_bvec(prev, &pb);
      32                 :          0 :         if (pb.bv_offset & queue_virt_boundary(q))
      33                 :            :                 return true;
      34                 :            : 
      35                 :            :         /*
      36                 :            :          * We don't need to worry about the situation that the merged segment
      37                 :            :          * ends in unaligned virt boundary:
      38                 :            :          *
      39                 :            :          * - if 'pb' ends aligned, the merged segment ends aligned
      40                 :            :          * - if 'pb' ends unaligned, the next bio must include
      41                 :            :          *   one single bvec of 'nb', otherwise the 'nb' can't
      42                 :            :          *   merge with 'pb'
      43                 :            :          */
      44                 :          0 :         bio_get_last_bvec(prev, &pb);
      45                 :          0 :         bio_get_first_bvec(next, &nb);
      46                 :          0 :         if (biovec_phys_mergeable(q, &pb, &nb))
      47                 :            :                 return false;
      48                 :          0 :         return __bvec_gap_to_prev(q, &pb, nb.bv_offset);
      49                 :            : }
      50                 :            : 
      51                 :            : static inline bool req_gap_back_merge(struct request *req, struct bio *bio)
      52                 :            : {
      53                 :          3 :         return bio_will_gap(req->q, req, req->biotail, bio);
      54                 :            : }
      55                 :            : 
      56                 :            : static inline bool req_gap_front_merge(struct request *req, struct bio *bio)
      57                 :            : {
      58                 :          3 :         return bio_will_gap(req->q, NULL, bio, req->bio);
      59                 :            : }
      60                 :            : 
      61                 :          0 : static struct bio *blk_bio_discard_split(struct request_queue *q,
      62                 :            :                                          struct bio *bio,
      63                 :            :                                          struct bio_set *bs,
      64                 :            :                                          unsigned *nsegs)
      65                 :            : {
      66                 :            :         unsigned int max_discard_sectors, granularity;
      67                 :            :         int alignment;
      68                 :            :         sector_t tmp;
      69                 :            :         unsigned split_sectors;
      70                 :            : 
      71                 :          0 :         *nsegs = 1;
      72                 :            : 
      73                 :            :         /* Zero-sector (unknown) and one-sector granularities are the same.  */
      74                 :          0 :         granularity = max(q->limits.discard_granularity >> 9, 1U);
      75                 :            : 
      76                 :          0 :         max_discard_sectors = min(q->limits.max_discard_sectors,
      77                 :            :                         bio_allowed_max_sectors(q));
      78                 :          0 :         max_discard_sectors -= max_discard_sectors % granularity;
      79                 :            : 
      80                 :          0 :         if (unlikely(!max_discard_sectors)) {
      81                 :            :                 /* XXX: warn */
      82                 :            :                 return NULL;
      83                 :            :         }
      84                 :            : 
      85                 :          0 :         if (bio_sectors(bio) <= max_discard_sectors)
      86                 :            :                 return NULL;
      87                 :            : 
      88                 :            :         split_sectors = max_discard_sectors;
      89                 :            : 
      90                 :            :         /*
      91                 :            :          * If the next starting sector would be misaligned, stop the discard at
      92                 :            :          * the previous aligned sector.
      93                 :            :          */
      94                 :          0 :         alignment = (q->limits.discard_alignment >> 9) % granularity;
      95                 :            : 
      96                 :          0 :         tmp = bio->bi_iter.bi_sector + split_sectors - alignment;
      97                 :          0 :         tmp = sector_div(tmp, granularity);
      98                 :            : 
      99                 :          0 :         if (split_sectors > tmp)
     100                 :          0 :                 split_sectors -= tmp;
     101                 :            : 
     102                 :          0 :         return bio_split(bio, split_sectors, GFP_NOIO, bs);
     103                 :            : }
     104                 :            : 
     105                 :          0 : static struct bio *blk_bio_write_zeroes_split(struct request_queue *q,
     106                 :            :                 struct bio *bio, struct bio_set *bs, unsigned *nsegs)
     107                 :            : {
     108                 :          0 :         *nsegs = 0;
     109                 :            : 
     110                 :          0 :         if (!q->limits.max_write_zeroes_sectors)
     111                 :            :                 return NULL;
     112                 :            : 
     113                 :          0 :         if (bio_sectors(bio) <= q->limits.max_write_zeroes_sectors)
     114                 :            :                 return NULL;
     115                 :            : 
     116                 :          0 :         return bio_split(bio, q->limits.max_write_zeroes_sectors, GFP_NOIO, bs);
     117                 :            : }
     118                 :            : 
     119                 :          0 : static struct bio *blk_bio_write_same_split(struct request_queue *q,
     120                 :            :                                             struct bio *bio,
     121                 :            :                                             struct bio_set *bs,
     122                 :            :                                             unsigned *nsegs)
     123                 :            : {
     124                 :          0 :         *nsegs = 1;
     125                 :            : 
     126                 :          0 :         if (!q->limits.max_write_same_sectors)
     127                 :            :                 return NULL;
     128                 :            : 
     129                 :          0 :         if (bio_sectors(bio) <= q->limits.max_write_same_sectors)
     130                 :            :                 return NULL;
     131                 :            : 
     132                 :          0 :         return bio_split(bio, q->limits.max_write_same_sectors, GFP_NOIO, bs);
     133                 :            : }
     134                 :            : 
     135                 :            : /*
     136                 :            :  * Return the maximum number of sectors from the start of a bio that may be
     137                 :            :  * submitted as a single request to a block device. If enough sectors remain,
     138                 :            :  * align the end to the physical block size. Otherwise align the end to the
     139                 :            :  * logical block size. This approach minimizes the number of non-aligned
     140                 :            :  * requests that are submitted to a block device if the start of a bio is not
     141                 :            :  * aligned to a physical block boundary.
     142                 :            :  */
     143                 :          3 : static inline unsigned get_max_io_size(struct request_queue *q,
     144                 :            :                                        struct bio *bio)
     145                 :            : {
     146                 :          3 :         unsigned sectors = blk_max_size_offset(q, bio->bi_iter.bi_sector);
     147                 :            :         unsigned max_sectors = sectors;
     148                 :          3 :         unsigned pbs = queue_physical_block_size(q) >> SECTOR_SHIFT;
     149                 :          3 :         unsigned lbs = queue_logical_block_size(q) >> SECTOR_SHIFT;
     150                 :          3 :         unsigned start_offset = bio->bi_iter.bi_sector & (pbs - 1);
     151                 :            : 
     152                 :          3 :         max_sectors += start_offset;
     153                 :          3 :         max_sectors &= ~(pbs - 1);
     154                 :          3 :         if (max_sectors > start_offset)
     155                 :          3 :                 return max_sectors - start_offset;
     156                 :            : 
     157                 :          0 :         return sectors & (lbs - 1);
     158                 :            : }
     159                 :            : 
     160                 :            : static inline unsigned get_max_segment_size(const struct request_queue *q,
     161                 :            :                                             struct page *start_page,
     162                 :            :                                             unsigned long offset)
     163                 :            : {
     164                 :            :         unsigned long mask = queue_segment_boundary(q);
     165                 :            : 
     166                 :          3 :         offset = mask & (page_to_phys(start_page) + offset);
     167                 :            : 
     168                 :            :         /*
     169                 :            :          * overflow may be triggered in case of zero page physical address
     170                 :            :          * on 32bit arch, use queue's max segment size when that happens.
     171                 :            :          */
     172                 :          3 :         return min_not_zero(mask - offset + 1,
     173                 :            :                         (unsigned long)queue_max_segment_size(q));
     174                 :            : }
     175                 :            : 
     176                 :            : /**
     177                 :            :  * bvec_split_segs - verify whether or not a bvec should be split in the middle
     178                 :            :  * @q:        [in] request queue associated with the bio associated with @bv
     179                 :            :  * @bv:       [in] bvec to examine
     180                 :            :  * @nsegs:    [in,out] Number of segments in the bio being built. Incremented
     181                 :            :  *            by the number of segments from @bv that may be appended to that
     182                 :            :  *            bio without exceeding @max_segs
     183                 :            :  * @sectors:  [in,out] Number of sectors in the bio being built. Incremented
     184                 :            :  *            by the number of sectors from @bv that may be appended to that
     185                 :            :  *            bio without exceeding @max_sectors
     186                 :            :  * @max_segs: [in] upper bound for *@nsegs
     187                 :            :  * @max_sectors: [in] upper bound for *@sectors
     188                 :            :  *
     189                 :            :  * When splitting a bio, it can happen that a bvec is encountered that is too
     190                 :            :  * big to fit in a single segment and hence that it has to be split in the
     191                 :            :  * middle. This function verifies whether or not that should happen. The value
     192                 :            :  * %true is returned if and only if appending the entire @bv to a bio with
     193                 :            :  * *@nsegs segments and *@sectors sectors would make that bio unacceptable for
     194                 :            :  * the block driver.
     195                 :            :  */
     196                 :          3 : static bool bvec_split_segs(const struct request_queue *q,
     197                 :            :                             const struct bio_vec *bv, unsigned *nsegs,
     198                 :            :                             unsigned *sectors, unsigned max_segs,
     199                 :            :                             unsigned max_sectors)
     200                 :            : {
     201                 :          3 :         unsigned max_len = (min(max_sectors, UINT_MAX >> 9) - *sectors) << 9;
     202                 :          3 :         unsigned len = min(bv->bv_len, max_len);
     203                 :            :         unsigned total_len = 0;
     204                 :            :         unsigned seg_size = 0;
     205                 :            : 
     206                 :          3 :         while (len && *nsegs < max_segs) {
     207                 :          3 :                 seg_size = get_max_segment_size(q, bv->bv_page,
     208                 :          3 :                                                 bv->bv_offset + total_len);
     209                 :          3 :                 seg_size = min(seg_size, len);
     210                 :            : 
     211                 :          3 :                 (*nsegs)++;
     212                 :          3 :                 total_len += seg_size;
     213                 :          3 :                 len -= seg_size;
     214                 :            : 
     215                 :          3 :                 if ((bv->bv_offset + total_len) & queue_virt_boundary(q))
     216                 :            :                         break;
     217                 :            :         }
     218                 :            : 
     219                 :          3 :         *sectors += total_len >> 9;
     220                 :            : 
     221                 :            :         /* tell the caller to split the bvec if it is too big to fit */
     222                 :          3 :         return len > 0 || bv->bv_len > max_len;
     223                 :            : }
     224                 :            : 
     225                 :            : /**
     226                 :            :  * blk_bio_segment_split - split a bio in two bios
     227                 :            :  * @q:    [in] request queue pointer
     228                 :            :  * @bio:  [in] bio to be split
     229                 :            :  * @bs:   [in] bio set to allocate the clone from
     230                 :            :  * @segs: [out] number of segments in the bio with the first half of the sectors
     231                 :            :  *
     232                 :            :  * Clone @bio, update the bi_iter of the clone to represent the first sectors
     233                 :            :  * of @bio and update @bio->bi_iter to represent the remaining sectors. The
     234                 :            :  * following is guaranteed for the cloned bio:
     235                 :            :  * - That it has at most get_max_io_size(@q, @bio) sectors.
     236                 :            :  * - That it has at most queue_max_segments(@q) segments.
     237                 :            :  *
     238                 :            :  * Except for discard requests the cloned bio will point at the bi_io_vec of
     239                 :            :  * the original bio. It is the responsibility of the caller to ensure that the
     240                 :            :  * original bio is not freed before the cloned bio. The caller is also
     241                 :            :  * responsible for ensuring that @bs is only destroyed after processing of the
     242                 :            :  * split bio has finished.
     243                 :            :  */
     244                 :          3 : static struct bio *blk_bio_segment_split(struct request_queue *q,
     245                 :            :                                          struct bio *bio,
     246                 :            :                                          struct bio_set *bs,
     247                 :            :                                          unsigned *segs)
     248                 :            : {
     249                 :            :         struct bio_vec bv, bvprv, *bvprvp = NULL;
     250                 :            :         struct bvec_iter iter;
     251                 :          3 :         unsigned nsegs = 0, sectors = 0;
     252                 :          3 :         const unsigned max_sectors = get_max_io_size(q, bio);
     253                 :          3 :         const unsigned max_segs = queue_max_segments(q);
     254                 :            : 
     255                 :          3 :         bio_for_each_bvec(bv, bio, iter) {
     256                 :            :                 /*
     257                 :            :                  * If the queue doesn't support SG gaps and adding this
     258                 :            :                  * offset would create a gap, disallow it.
     259                 :            :                  */
     260                 :          3 :                 if (bvprvp && bvec_gap_to_prev(q, bvprvp, bv.bv_offset))
     261                 :            :                         goto split;
     262                 :            : 
     263                 :          3 :                 if (nsegs < max_segs &&
     264                 :          3 :                     sectors + (bv.bv_len >> 9) <= max_sectors &&
     265                 :          3 :                     bv.bv_offset + bv.bv_len <= PAGE_SIZE) {
     266                 :          3 :                         nsegs++;
     267                 :          3 :                         sectors += bv.bv_len >> 9;
     268                 :          3 :                 } else if (bvec_split_segs(q, &bv, &nsegs, &sectors, max_segs,
     269                 :            :                                          max_sectors)) {
     270                 :            :                         goto split;
     271                 :            :                 }
     272                 :            : 
     273                 :          3 :                 bvprv = bv;
     274                 :            :                 bvprvp = &bvprv;
     275                 :            :         }
     276                 :            : 
     277                 :          3 :         *segs = nsegs;
     278                 :          3 :         return NULL;
     279                 :            : split:
     280                 :          3 :         *segs = nsegs;
     281                 :          3 :         return bio_split(bio, sectors, GFP_NOIO, bs);
     282                 :            : }
     283                 :            : 
     284                 :            : /**
     285                 :            :  * __blk_queue_split - split a bio and submit the second half
     286                 :            :  * @q:       [in] request queue pointer
     287                 :            :  * @bio:     [in, out] bio to be split
     288                 :            :  * @nr_segs: [out] number of segments in the first bio
     289                 :            :  *
     290                 :            :  * Split a bio into two bios, chain the two bios, submit the second half and
     291                 :            :  * store a pointer to the first half in *@bio. If the second bio is still too
     292                 :            :  * big it will be split by a recursive call to this function. Since this
     293                 :            :  * function may allocate a new bio from @q->bio_split, it is the responsibility
     294                 :            :  * of the caller to ensure that @q is only released after processing of the
     295                 :            :  * split bio has finished.
     296                 :            :  */
     297                 :          3 : void __blk_queue_split(struct request_queue *q, struct bio **bio,
     298                 :            :                 unsigned int *nr_segs)
     299                 :            : {
     300                 :            :         struct bio *split;
     301                 :            : 
     302                 :          3 :         switch (bio_op(*bio)) {
     303                 :            :         case REQ_OP_DISCARD:
     304                 :            :         case REQ_OP_SECURE_ERASE:
     305                 :          0 :                 split = blk_bio_discard_split(q, *bio, &q->bio_split, nr_segs);
     306                 :          0 :                 break;
     307                 :            :         case REQ_OP_WRITE_ZEROES:
     308                 :          0 :                 split = blk_bio_write_zeroes_split(q, *bio, &q->bio_split,
     309                 :            :                                 nr_segs);
     310                 :          0 :                 break;
     311                 :            :         case REQ_OP_WRITE_SAME:
     312                 :          0 :                 split = blk_bio_write_same_split(q, *bio, &q->bio_split,
     313                 :            :                                 nr_segs);
     314                 :          0 :                 break;
     315                 :            :         default:
     316                 :          3 :                 split = blk_bio_segment_split(q, *bio, &q->bio_split, nr_segs);
     317                 :          3 :                 break;
     318                 :            :         }
     319                 :            : 
     320                 :          3 :         if (split) {
     321                 :            :                 /* there isn't chance to merge the splitted bio */
     322                 :          3 :                 split->bi_opf |= REQ_NOMERGE;
     323                 :            : 
     324                 :            :                 /*
     325                 :            :                  * Since we're recursing into make_request here, ensure
     326                 :            :                  * that we mark this bio as already having entered the queue.
     327                 :            :                  * If not, and the queue is going away, we can get stuck
     328                 :            :                  * forever on waiting for the queue reference to drop. But
     329                 :            :                  * that will never happen, as we're already holding a
     330                 :            :                  * reference to it.
     331                 :            :                  */
     332                 :          3 :                 bio_set_flag(*bio, BIO_QUEUE_ENTERED);
     333                 :            : 
     334                 :          3 :                 bio_chain(split, *bio);
     335                 :          3 :                 trace_block_split(q, split, (*bio)->bi_iter.bi_sector);
     336                 :          3 :                 generic_make_request(*bio);
     337                 :          3 :                 *bio = split;
     338                 :            :         }
     339                 :          3 : }
     340                 :            : 
     341                 :            : /**
     342                 :            :  * blk_queue_split - split a bio and submit the second half
     343                 :            :  * @q:   [in] request queue pointer
     344                 :            :  * @bio: [in, out] bio to be split
     345                 :            :  *
     346                 :            :  * Split a bio into two bios, chains the two bios, submit the second half and
     347                 :            :  * store a pointer to the first half in *@bio. Since this function may allocate
     348                 :            :  * a new bio from @q->bio_split, it is the responsibility of the caller to
     349                 :            :  * ensure that @q is only released after processing of the split bio has
     350                 :            :  * finished.
     351                 :            :  */
     352                 :          0 : void blk_queue_split(struct request_queue *q, struct bio **bio)
     353                 :            : {
     354                 :            :         unsigned int nr_segs;
     355                 :            : 
     356                 :          0 :         __blk_queue_split(q, bio, &nr_segs);
     357                 :          0 : }
     358                 :            : EXPORT_SYMBOL(blk_queue_split);
     359                 :            : 
     360                 :          0 : unsigned int blk_recalc_rq_segments(struct request *rq)
     361                 :            : {
     362                 :          0 :         unsigned int nr_phys_segs = 0;
     363                 :          0 :         unsigned int nr_sectors = 0;
     364                 :            :         struct req_iterator iter;
     365                 :            :         struct bio_vec bv;
     366                 :            : 
     367                 :          0 :         if (!rq->bio)
     368                 :            :                 return 0;
     369                 :            : 
     370                 :          0 :         switch (bio_op(rq->bio)) {
     371                 :            :         case REQ_OP_DISCARD:
     372                 :            :         case REQ_OP_SECURE_ERASE:
     373                 :            :         case REQ_OP_WRITE_ZEROES:
     374                 :            :                 return 0;
     375                 :            :         case REQ_OP_WRITE_SAME:
     376                 :          0 :                 return 1;
     377                 :            :         }
     378                 :            : 
     379                 :          0 :         rq_for_each_bvec(bv, rq, iter)
     380                 :          0 :                 bvec_split_segs(rq->q, &bv, &nr_phys_segs, &nr_sectors,
     381                 :            :                                 UINT_MAX, UINT_MAX);
     382                 :          0 :         return nr_phys_segs;
     383                 :            : }
     384                 :            : 
     385                 :            : static inline struct scatterlist *blk_next_sg(struct scatterlist **sg,
     386                 :            :                 struct scatterlist *sglist)
     387                 :            : {
     388                 :          3 :         if (!*sg)
     389                 :            :                 return sglist;
     390                 :            : 
     391                 :            :         /*
     392                 :            :          * If the driver previously mapped a shorter list, we could see a
     393                 :            :          * termination bit prematurely unless it fully inits the sg table
     394                 :            :          * on each mapping. We KNOW that there must be more entries here
     395                 :            :          * or the driver would be buggy, so force clear the termination bit
     396                 :            :          * to avoid doing a full sg_init_table() in drivers for each command.
     397                 :            :          */
     398                 :            :         sg_unmark_end(*sg);
     399                 :          3 :         return sg_next(*sg);
     400                 :            : }
     401                 :            : 
     402                 :          3 : static unsigned blk_bvec_map_sg(struct request_queue *q,
     403                 :            :                 struct bio_vec *bvec, struct scatterlist *sglist,
     404                 :            :                 struct scatterlist **sg)
     405                 :            : {
     406                 :          3 :         unsigned nbytes = bvec->bv_len;
     407                 :            :         unsigned nsegs = 0, total = 0;
     408                 :            : 
     409                 :          3 :         while (nbytes > 0) {
     410                 :          3 :                 unsigned offset = bvec->bv_offset + total;
     411                 :          3 :                 unsigned len = min(get_max_segment_size(q, bvec->bv_page,
     412                 :            :                                         offset), nbytes);
     413                 :            :                 struct page *page = bvec->bv_page;
     414                 :            : 
     415                 :            :                 /*
     416                 :            :                  * Unfortunately a fair number of drivers barf on scatterlists
     417                 :            :                  * that have an offset larger than PAGE_SIZE, despite other
     418                 :            :                  * subsystems dealing with that invariant just fine.  For now
     419                 :            :                  * stick to the legacy format where we never present those from
     420                 :            :                  * the block layer, but the code below should be removed once
     421                 :            :                  * these offenders (mostly MMC/SD drivers) are fixed.
     422                 :            :                  */
     423                 :          3 :                 page += (offset >> PAGE_SHIFT);
     424                 :          3 :                 offset &= ~PAGE_MASK;
     425                 :            : 
     426                 :          3 :                 *sg = blk_next_sg(sg, sglist);
     427                 :            :                 sg_set_page(*sg, page, len, offset);
     428                 :            : 
     429                 :          3 :                 total += len;
     430                 :          3 :                 nbytes -= len;
     431                 :          3 :                 nsegs++;
     432                 :            :         }
     433                 :            : 
     434                 :          3 :         return nsegs;
     435                 :            : }
     436                 :            : 
     437                 :          3 : static inline int __blk_bvec_map_sg(struct bio_vec bv,
     438                 :            :                 struct scatterlist *sglist, struct scatterlist **sg)
     439                 :            : {
     440                 :          3 :         *sg = blk_next_sg(sg, sglist);
     441                 :          3 :         sg_set_page(*sg, bv.bv_page, bv.bv_len, bv.bv_offset);
     442                 :          3 :         return 1;
     443                 :            : }
     444                 :            : 
     445                 :            : /* only try to merge bvecs into one sg if they are from two bios */
     446                 :            : static inline bool
     447                 :          3 : __blk_segment_map_sg_merge(struct request_queue *q, struct bio_vec *bvec,
     448                 :            :                            struct bio_vec *bvprv, struct scatterlist **sg)
     449                 :            : {
     450                 :            : 
     451                 :          3 :         int nbytes = bvec->bv_len;
     452                 :            : 
     453                 :          3 :         if (!*sg)
     454                 :            :                 return false;
     455                 :            : 
     456                 :          3 :         if ((*sg)->length + nbytes > queue_max_segment_size(q))
     457                 :            :                 return false;
     458                 :            : 
     459                 :          3 :         if (!biovec_phys_mergeable(q, bvprv, bvec))
     460                 :            :                 return false;
     461                 :            : 
     462                 :          3 :         (*sg)->length += nbytes;
     463                 :            : 
     464                 :          3 :         return true;
     465                 :            : }
     466                 :            : 
     467                 :          3 : static int __blk_bios_map_sg(struct request_queue *q, struct bio *bio,
     468                 :            :                              struct scatterlist *sglist,
     469                 :            :                              struct scatterlist **sg)
     470                 :            : {
     471                 :          3 :         struct bio_vec uninitialized_var(bvec), bvprv = { NULL };
     472                 :            :         struct bvec_iter iter;
     473                 :            :         int nsegs = 0;
     474                 :            :         bool new_bio = false;
     475                 :            : 
     476                 :          3 :         for_each_bio(bio) {
     477                 :          3 :                 bio_for_each_bvec(bvec, bio, iter) {
     478                 :            :                         /*
     479                 :            :                          * Only try to merge bvecs from two bios given we
     480                 :            :                          * have done bio internal merge when adding pages
     481                 :            :                          * to bio
     482                 :            :                          */
     483                 :          3 :                         if (new_bio &&
     484                 :          3 :                             __blk_segment_map_sg_merge(q, &bvec, &bvprv, sg))
     485                 :            :                                 goto next_bvec;
     486                 :            : 
     487                 :          3 :                         if (bvec.bv_offset + bvec.bv_len <= PAGE_SIZE)
     488                 :          3 :                                 nsegs += __blk_bvec_map_sg(bvec, sglist, sg);
     489                 :            :                         else
     490                 :          3 :                                 nsegs += blk_bvec_map_sg(q, &bvec, sglist, sg);
     491                 :            :  next_bvec:
     492                 :            :                         new_bio = false;
     493                 :            :                 }
     494                 :          3 :                 if (likely(bio->bi_iter.bi_size)) {
     495                 :          3 :                         bvprv = bvec;
     496                 :            :                         new_bio = true;
     497                 :            :                 }
     498                 :            :         }
     499                 :            : 
     500                 :          3 :         return nsegs;
     501                 :            : }
     502                 :            : 
     503                 :            : /*
     504                 :            :  * map a request to scatterlist, return number of sg entries setup. Caller
     505                 :            :  * must make sure sg can hold rq->nr_phys_segments entries
     506                 :            :  */
     507                 :          3 : int blk_rq_map_sg(struct request_queue *q, struct request *rq,
     508                 :            :                   struct scatterlist *sglist)
     509                 :            : {
     510                 :          3 :         struct scatterlist *sg = NULL;
     511                 :            :         int nsegs = 0;
     512                 :            : 
     513                 :          3 :         if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
     514                 :          0 :                 nsegs = __blk_bvec_map_sg(rq->special_vec, sglist, &sg);
     515                 :          3 :         else if (rq->bio && bio_op(rq->bio) == REQ_OP_WRITE_SAME)
     516                 :          0 :                 nsegs = __blk_bvec_map_sg(bio_iovec(rq->bio), sglist, &sg);
     517                 :          3 :         else if (rq->bio)
     518                 :          3 :                 nsegs = __blk_bios_map_sg(q, rq->bio, sglist, &sg);
     519                 :            : 
     520                 :          3 :         if (unlikely(rq->rq_flags & RQF_COPY_USER) &&
     521                 :          0 :             (blk_rq_bytes(rq) & q->dma_pad_mask)) {
     522                 :          0 :                 unsigned int pad_len =
     523                 :          0 :                         (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1;
     524                 :            : 
     525                 :          0 :                 sg->length += pad_len;
     526                 :          0 :                 rq->extra_len += pad_len;
     527                 :            :         }
     528                 :            : 
     529                 :          3 :         if (q->dma_drain_size && q->dma_drain_needed(rq)) {
     530                 :          0 :                 if (op_is_write(req_op(rq)))
     531                 :          0 :                         memset(q->dma_drain_buffer, 0, q->dma_drain_size);
     532                 :            : 
     533                 :          0 :                 sg_unmark_end(sg);
     534                 :          0 :                 sg = sg_next(sg);
     535                 :          0 :                 sg_set_page(sg, virt_to_page(q->dma_drain_buffer),
     536                 :            :                             q->dma_drain_size,
     537                 :            :                             ((unsigned long)q->dma_drain_buffer) &
     538                 :            :                             (PAGE_SIZE - 1));
     539                 :          0 :                 nsegs++;
     540                 :          0 :                 rq->extra_len += q->dma_drain_size;
     541                 :            :         }
     542                 :            : 
     543                 :          3 :         if (sg)
     544                 :            :                 sg_mark_end(sg);
     545                 :            : 
     546                 :            :         /*
     547                 :            :          * Something must have been wrong if the figured number of
     548                 :            :          * segment is bigger than number of req's physical segments
     549                 :            :          */
     550                 :          3 :         WARN_ON(nsegs > blk_rq_nr_phys_segments(rq));
     551                 :            : 
     552                 :          3 :         return nsegs;
     553                 :            : }
     554                 :            : EXPORT_SYMBOL(blk_rq_map_sg);
     555                 :            : 
     556                 :            : static inline int ll_new_hw_segment(struct request *req, struct bio *bio,
     557                 :            :                 unsigned int nr_phys_segs)
     558                 :            : {
     559                 :          3 :         if (req->nr_phys_segments + nr_phys_segs > queue_max_segments(req->q))
     560                 :            :                 goto no_merge;
     561                 :            : 
     562                 :            :         if (blk_integrity_merge_bio(req->q, req, bio) == false)
     563                 :            :                 goto no_merge;
     564                 :            : 
     565                 :            :         /*
     566                 :            :          * This will form the start of a new hw segment.  Bump both
     567                 :            :          * counters.
     568                 :            :          */
     569                 :          3 :         req->nr_phys_segments += nr_phys_segs;
     570                 :            :         return 1;
     571                 :            : 
     572                 :            : no_merge:
     573                 :            :         req_set_nomerge(req->q, req);
     574                 :            :         return 0;
     575                 :            : }
     576                 :            : 
     577                 :          3 : int ll_back_merge_fn(struct request *req, struct bio *bio, unsigned int nr_segs)
     578                 :            : {
     579                 :          3 :         if (req_gap_back_merge(req, bio))
     580                 :            :                 return 0;
     581                 :            :         if (blk_integrity_rq(req) &&
     582                 :            :             integrity_req_gap_back_merge(req, bio))
     583                 :            :                 return 0;
     584                 :          3 :         if (blk_rq_sectors(req) + bio_sectors(bio) >
     585                 :          3 :             blk_rq_get_max_sectors(req, blk_rq_pos(req))) {
     586                 :          3 :                 req_set_nomerge(req->q, req);
     587                 :            :                 return 0;
     588                 :            :         }
     589                 :            : 
     590                 :          3 :         return ll_new_hw_segment(req, bio, nr_segs);
     591                 :            : }
     592                 :            : 
     593                 :          3 : int ll_front_merge_fn(struct request *req, struct bio *bio, unsigned int nr_segs)
     594                 :            : {
     595                 :          3 :         if (req_gap_front_merge(req, bio))
     596                 :            :                 return 0;
     597                 :            :         if (blk_integrity_rq(req) &&
     598                 :            :             integrity_req_gap_front_merge(req, bio))
     599                 :            :                 return 0;
     600                 :          3 :         if (blk_rq_sectors(req) + bio_sectors(bio) >
     601                 :          3 :             blk_rq_get_max_sectors(req, bio->bi_iter.bi_sector)) {
     602                 :          0 :                 req_set_nomerge(req->q, req);
     603                 :            :                 return 0;
     604                 :            :         }
     605                 :            : 
     606                 :          3 :         return ll_new_hw_segment(req, bio, nr_segs);
     607                 :            : }
     608                 :            : 
     609                 :          0 : static bool req_attempt_discard_merge(struct request_queue *q, struct request *req,
     610                 :            :                 struct request *next)
     611                 :            : {
     612                 :            :         unsigned short segments = blk_rq_nr_discard_segments(req);
     613                 :            : 
     614                 :          0 :         if (segments >= queue_max_discard_segments(q))
     615                 :            :                 goto no_merge;
     616                 :          0 :         if (blk_rq_sectors(req) + bio_sectors(next->bio) >
     617                 :          0 :             blk_rq_get_max_sectors(req, blk_rq_pos(req)))
     618                 :            :                 goto no_merge;
     619                 :            : 
     620                 :          0 :         req->nr_phys_segments = segments + blk_rq_nr_discard_segments(next);
     621                 :          0 :         return true;
     622                 :            : no_merge:
     623                 :            :         req_set_nomerge(q, req);
     624                 :            :         return false;
     625                 :            : }
     626                 :            : 
     627                 :          3 : static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
     628                 :            :                                 struct request *next)
     629                 :            : {
     630                 :            :         int total_phys_segments;
     631                 :            : 
     632                 :          3 :         if (req_gap_back_merge(req, next->bio))
     633                 :            :                 return 0;
     634                 :            : 
     635                 :            :         /*
     636                 :            :          * Will it become too large?
     637                 :            :          */
     638                 :          3 :         if ((blk_rq_sectors(req) + blk_rq_sectors(next)) >
     639                 :          3 :             blk_rq_get_max_sectors(req, blk_rq_pos(req)))
     640                 :            :                 return 0;
     641                 :            : 
     642                 :          3 :         total_phys_segments = req->nr_phys_segments + next->nr_phys_segments;
     643                 :          3 :         if (total_phys_segments > queue_max_segments(q))
     644                 :            :                 return 0;
     645                 :            : 
     646                 :            :         if (blk_integrity_merge_rq(q, req, next) == false)
     647                 :            :                 return 0;
     648                 :            : 
     649                 :            :         /* Merge is OK... */
     650                 :          3 :         req->nr_phys_segments = total_phys_segments;
     651                 :          3 :         return 1;
     652                 :            : }
     653                 :            : 
     654                 :            : /**
     655                 :            :  * blk_rq_set_mixed_merge - mark a request as mixed merge
     656                 :            :  * @rq: request to mark as mixed merge
     657                 :            :  *
     658                 :            :  * Description:
     659                 :            :  *     @rq is about to be mixed merged.  Make sure the attributes
     660                 :            :  *     which can be mixed are set in each bio and mark @rq as mixed
     661                 :            :  *     merged.
     662                 :            :  */
     663                 :          3 : void blk_rq_set_mixed_merge(struct request *rq)
     664                 :            : {
     665                 :          3 :         unsigned int ff = rq->cmd_flags & REQ_FAILFAST_MASK;
     666                 :            :         struct bio *bio;
     667                 :            : 
     668                 :          3 :         if (rq->rq_flags & RQF_MIXED_MERGE)
     669                 :          3 :                 return;
     670                 :            : 
     671                 :            :         /*
     672                 :            :          * @rq will no longer represent mixable attributes for all the
     673                 :            :          * contained bios.  It will just track those of the first one.
     674                 :            :          * Distributes the attributs to each bio.
     675                 :            :          */
     676                 :          3 :         for (bio = rq->bio; bio; bio = bio->bi_next) {
     677                 :          3 :                 WARN_ON_ONCE((bio->bi_opf & REQ_FAILFAST_MASK) &&
     678                 :            :                              (bio->bi_opf & REQ_FAILFAST_MASK) != ff);
     679                 :          3 :                 bio->bi_opf |= ff;
     680                 :            :         }
     681                 :          3 :         rq->rq_flags |= RQF_MIXED_MERGE;
     682                 :            : }
     683                 :            : 
     684                 :          3 : static void blk_account_io_merge(struct request *req)
     685                 :            : {
     686                 :          3 :         if (blk_do_io_stat(req)) {
     687                 :            :                 struct hd_struct *part;
     688                 :            : 
     689                 :          3 :                 part_stat_lock();
     690                 :          3 :                 part = req->part;
     691                 :            : 
     692                 :          3 :                 part_dec_in_flight(req->q, part, rq_data_dir(req));
     693                 :            : 
     694                 :            :                 hd_struct_put(part);
     695                 :          3 :                 part_stat_unlock();
     696                 :            :         }
     697                 :          3 : }
     698                 :            : /*
     699                 :            :  * Two cases of handling DISCARD merge:
     700                 :            :  * If max_discard_segments > 1, the driver takes every bio
     701                 :            :  * as a range and send them to controller together. The ranges
     702                 :            :  * needn't to be contiguous.
     703                 :            :  * Otherwise, the bios/requests will be handled as same as
     704                 :            :  * others which should be contiguous.
     705                 :            :  */
     706                 :            : static inline bool blk_discard_mergable(struct request *req)
     707                 :            : {
     708                 :          3 :         if (req_op(req) == REQ_OP_DISCARD &&
     709                 :          0 :             queue_max_discard_segments(req->q) > 1)
     710                 :            :                 return true;
     711                 :            :         return false;
     712                 :            : }
     713                 :            : 
     714                 :          3 : static enum elv_merge blk_try_req_merge(struct request *req,
     715                 :            :                                         struct request *next)
     716                 :            : {
     717                 :          3 :         if (blk_discard_mergable(req))
     718                 :            :                 return ELEVATOR_DISCARD_MERGE;
     719                 :          3 :         else if (blk_rq_pos(req) + blk_rq_sectors(req) == blk_rq_pos(next))
     720                 :            :                 return ELEVATOR_BACK_MERGE;
     721                 :            : 
     722                 :          3 :         return ELEVATOR_NO_MERGE;
     723                 :            : }
     724                 :            : 
     725                 :            : /*
     726                 :            :  * For non-mq, this has to be called with the request spinlock acquired.
     727                 :            :  * For mq with scheduling, the appropriate queue wide lock should be held.
     728                 :            :  */
     729                 :          3 : static struct request *attempt_merge(struct request_queue *q,
     730                 :            :                                      struct request *req, struct request *next)
     731                 :            : {
     732                 :          3 :         if (!rq_mergeable(req) || !rq_mergeable(next))
     733                 :            :                 return NULL;
     734                 :            : 
     735                 :          3 :         if (req_op(req) != req_op(next))
     736                 :            :                 return NULL;
     737                 :            : 
     738                 :          3 :         if (rq_data_dir(req) != rq_data_dir(next)
     739                 :          3 :             || req->rq_disk != next->rq_disk)
     740                 :            :                 return NULL;
     741                 :            : 
     742                 :          3 :         if (req_op(req) == REQ_OP_WRITE_SAME &&
     743                 :          0 :             !blk_write_same_mergeable(req->bio, next->bio))
     744                 :            :                 return NULL;
     745                 :            : 
     746                 :            :         /*
     747                 :            :          * Don't allow merge of different write hints, or for a hint with
     748                 :            :          * non-hint IO.
     749                 :            :          */
     750                 :          3 :         if (req->write_hint != next->write_hint)
     751                 :            :                 return NULL;
     752                 :            : 
     753                 :          3 :         if (req->ioprio != next->ioprio)
     754                 :            :                 return NULL;
     755                 :            : 
     756                 :            :         /*
     757                 :            :          * If we are allowed to merge, then append bio list
     758                 :            :          * from next to rq and release next. merge_requests_fn
     759                 :            :          * will have updated segment counts, update sector
     760                 :            :          * counts here. Handle DISCARDs separately, as they
     761                 :            :          * have separate settings.
     762                 :            :          */
     763                 :            : 
     764                 :          3 :         switch (blk_try_req_merge(req, next)) {
     765                 :            :         case ELEVATOR_DISCARD_MERGE:
     766                 :          0 :                 if (!req_attempt_discard_merge(q, req, next))
     767                 :            :                         return NULL;
     768                 :            :                 break;
     769                 :            :         case ELEVATOR_BACK_MERGE:
     770                 :          3 :                 if (!ll_merge_requests_fn(q, req, next))
     771                 :            :                         return NULL;
     772                 :            :                 break;
     773                 :            :         default:
     774                 :            :                 return NULL;
     775                 :            :         }
     776                 :            : 
     777                 :            :         /*
     778                 :            :          * If failfast settings disagree or any of the two is already
     779                 :            :          * a mixed merge, mark both as mixed before proceeding.  This
     780                 :            :          * makes sure that all involved bios have mixable attributes
     781                 :            :          * set properly.
     782                 :            :          */
     783                 :          3 :         if (((req->rq_flags | next->rq_flags) & RQF_MIXED_MERGE) ||
     784                 :          3 :             (req->cmd_flags & REQ_FAILFAST_MASK) !=
     785                 :          3 :             (next->cmd_flags & REQ_FAILFAST_MASK)) {
     786                 :          3 :                 blk_rq_set_mixed_merge(req);
     787                 :          3 :                 blk_rq_set_mixed_merge(next);
     788                 :            :         }
     789                 :            : 
     790                 :            :         /*
     791                 :            :          * At this point we have either done a back merge or front merge. We
     792                 :            :          * need the smaller start_time_ns of the merged requests to be the
     793                 :            :          * current request for accounting purposes.
     794                 :            :          */
     795                 :          3 :         if (next->start_time_ns < req->start_time_ns)
     796                 :          3 :                 req->start_time_ns = next->start_time_ns;
     797                 :            : 
     798                 :          3 :         req->biotail->bi_next = next->bio;
     799                 :          3 :         req->biotail = next->biotail;
     800                 :            : 
     801                 :          3 :         req->__data_len += blk_rq_bytes(next);
     802                 :            : 
     803                 :          3 :         if (!blk_discard_mergable(req))
     804                 :          3 :                 elv_merge_requests(q, req, next);
     805                 :            : 
     806                 :            :         /*
     807                 :            :          * 'next' is going away, so update stats accordingly
     808                 :            :          */
     809                 :          3 :         blk_account_io_merge(next);
     810                 :            : 
     811                 :            :         /*
     812                 :            :          * ownership of bio passed from next to req, return 'next' for
     813                 :            :          * the caller to free
     814                 :            :          */
     815                 :          3 :         next->bio = NULL;
     816                 :          3 :         return next;
     817                 :            : }
     818                 :            : 
     819                 :          3 : struct request *attempt_back_merge(struct request_queue *q, struct request *rq)
     820                 :            : {
     821                 :          3 :         struct request *next = elv_latter_request(q, rq);
     822                 :            : 
     823                 :          3 :         if (next)
     824                 :          3 :                 return attempt_merge(q, rq, next);
     825                 :            : 
     826                 :            :         return NULL;
     827                 :            : }
     828                 :            : 
     829                 :          3 : struct request *attempt_front_merge(struct request_queue *q, struct request *rq)
     830                 :            : {
     831                 :          3 :         struct request *prev = elv_former_request(q, rq);
     832                 :            : 
     833                 :          3 :         if (prev)
     834                 :          3 :                 return attempt_merge(q, prev, rq);
     835                 :            : 
     836                 :            :         return NULL;
     837                 :            : }
     838                 :            : 
     839                 :          3 : int blk_attempt_req_merge(struct request_queue *q, struct request *rq,
     840                 :            :                           struct request *next)
     841                 :            : {
     842                 :            :         struct request *free;
     843                 :            : 
     844                 :          3 :         free = attempt_merge(q, rq, next);
     845                 :          3 :         if (free) {
     846                 :          3 :                 blk_put_request(free);
     847                 :          3 :                 return 1;
     848                 :            :         }
     849                 :            : 
     850                 :            :         return 0;
     851                 :            : }
     852                 :            : 
     853                 :          3 : bool blk_rq_merge_ok(struct request *rq, struct bio *bio)
     854                 :            : {
     855                 :          3 :         if (!rq_mergeable(rq) || !bio_mergeable(bio))
     856                 :            :                 return false;
     857                 :            : 
     858                 :          3 :         if (req_op(rq) != bio_op(bio))
     859                 :            :                 return false;
     860                 :            : 
     861                 :            :         /* different data direction or already started, don't merge */
     862                 :          3 :         if (bio_data_dir(bio) != rq_data_dir(rq))
     863                 :            :                 return false;
     864                 :            : 
     865                 :            :         /* must be same device */
     866                 :          3 :         if (rq->rq_disk != bio->bi_disk)
     867                 :            :                 return false;
     868                 :            : 
     869                 :            :         /* only merge integrity protected bio into ditto rq */
     870                 :            :         if (blk_integrity_merge_bio(rq->q, rq, bio) == false)
     871                 :            :                 return false;
     872                 :            : 
     873                 :            :         /* must be using the same buffer */
     874                 :          3 :         if (req_op(rq) == REQ_OP_WRITE_SAME &&
     875                 :          0 :             !blk_write_same_mergeable(rq->bio, bio))
     876                 :            :                 return false;
     877                 :            : 
     878                 :            :         /*
     879                 :            :          * Don't allow merge of different write hints, or for a hint with
     880                 :            :          * non-hint IO.
     881                 :            :          */
     882                 :          3 :         if (rq->write_hint != bio->bi_write_hint)
     883                 :            :                 return false;
     884                 :            : 
     885                 :          3 :         if (rq->ioprio != bio_prio(bio))
     886                 :            :                 return false;
     887                 :            : 
     888                 :          3 :         return true;
     889                 :            : }
     890                 :            : 
     891                 :          3 : enum elv_merge blk_try_merge(struct request *rq, struct bio *bio)
     892                 :            : {
     893                 :          3 :         if (blk_discard_mergable(rq))
     894                 :            :                 return ELEVATOR_DISCARD_MERGE;
     895                 :          3 :         else if (blk_rq_pos(rq) + blk_rq_sectors(rq) == bio->bi_iter.bi_sector)
     896                 :            :                 return ELEVATOR_BACK_MERGE;
     897                 :          3 :         else if (blk_rq_pos(rq) - bio_sectors(bio) == bio->bi_iter.bi_sector)
     898                 :            :                 return ELEVATOR_FRONT_MERGE;
     899                 :          3 :         return ELEVATOR_NO_MERGE;
     900                 :            : }
    

Generated by: LCOV version 1.14