On Tue, Jul 06, 2021 at 10:29:42PM -0700, Satya Tangirala wrote:
> From: Satya Tangirala <satyat@xxxxxxxxxx>
>
> Update get_max_io_size() to return a value aligned to
> bio_required_sector_alignment(). With this change, and the changes
> to blk_ksm_register() that restrict the supported data unit sizes
> based on the queue's limits, blk_bio_segment_split() won't split bios in
> the middle of a data unit anymore
>
> Signed-off-by: Satya Tangirala <satyat@xxxxxxxxxx>
> ---
> block/blk-merge.c | 49 ++++++++++++++++++++++++++++++-----------------
> 1 file changed, 31 insertions(+), 18 deletions(-)
>
> diff --git a/block/blk-merge.c b/block/blk-merge.c
> index a11b3b53717e..68c96dec5680 100644
> --- a/block/blk-merge.c
> +++ b/block/blk-merge.c
> @@ -135,27 +135,39 @@ static struct bio *blk_bio_write_same_split(struct request_queue *q,
>
> /*
> * Return the maximum number of sectors from the start of a bio that may be
> - * submitted as a single request to a block device. If enough sectors remain,
> - * align the end to the physical block size. Otherwise align the end to the
> - * logical block size. This approach minimizes the number of non-aligned
> - * requests that are submitted to a block device if the start of a bio is not
> - * aligned to a physical block boundary.
> + * submitted as a single request to a block device. Tries to align the end to
> + * the physical block size, while also aligning the returned number of sectors
> + * to bio_required_sector_alignment(). This approach minimizes the number of
> + * non-aligned requests that are submitted to a block device if the start of a
> + * bio is not aligned to a physical block boundary.
> + *
> + * More clearly, there are two conditions we're interested in satisfying.
> + *
> + * Condition 1) We absolutely must have @return divisible by the
> + * bio_required_sector_alignment(bio).
> + *
> + * Condition 2) *If possible*, while still satisfying Condition 1, we would like
> + * to have start_offset + @return divisible by physical block size in sectors
> + * (pbs).
> */
This comment is basically saying the same thing in two different ways. Could we
just say it once clearly? Maybe:
/*
* Return the maximum number of sectors from the start of a bio that may be
* submitted as a single request to a block device. The returned value will be
* a multiple of bio_required_sector_alignment(). If possible, the returned
* value will also make the request end on a physical block boundary; this
* minimizes the number of non-aligned requests that are submitted to a block
* device when a bio doesn't start on a physical block boundary.
*/
> static inline unsigned get_max_io_size(struct request_queue *q,
> struct bio *bio)
> {
> - unsigned sectors = blk_max_size_offset(q, bio->bi_iter.bi_sector, 0);
> - unsigned max_sectors = sectors;
> - unsigned pbs = queue_physical_block_size(q) >> SECTOR_SHIFT;
> - unsigned lbs = queue_logical_block_size(q) >> SECTOR_SHIFT;
> - unsigned start_offset = bio->bi_iter.bi_sector & (pbs - 1);
> -
> - max_sectors += start_offset;
> - max_sectors &= ~(pbs - 1);
> - if (max_sectors > start_offset)
> - return max_sectors - start_offset;
> -
> - return sectors & ~(lbs - 1);
> + unsigned int start_offset = bio->bi_iter.bi_sector;
> + unsigned int sectors = blk_max_size_offset(q, start_offset, 0);
> + unsigned int pbs = queue_physical_block_size(q) >> SECTOR_SHIFT;
> + unsigned int req_sector_align = bio_required_sector_alignment(bio);
> + unsigned int pbs_aligned_sector = round_down(start_offset + sectors, pbs);
> +
> + /*
> + * If we can return a pbs aligned endpoint while satisfying Condition 1,
> + * then do so.
> + */
> + if (pbs_aligned_sector > start_offset &&
> + IS_ALIGNED(pbs_aligned_sector - start_offset, req_sector_align))
> + return pbs_aligned_sector - start_offset;
> +
> + return round_down(sectors, req_sector_align);
> }
'start_offset' and 'pbs_aligned_sector' need to be 'sector_t', not 'unsigned
int'. Also 'start_offset' probably should be called 'start_sector'. And
'req_sector_align' could be shortened to just 'align'.
- Eric
