linux-kernel - Re: [PATCH v4 8/9] blk-merge: Ensure bios aren't split in middle of a crypto data unit

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Date:   Fri, 23 Jul 2021 11:11:27 -0700
From:   Eric Biggers <ebiggers@...nel.org>
To:     Satya Tangirala <satyaprateek2357@...il.com>
Cc:     linux-block@...r.kernel.org, linux-kernel@...r.kernel.org,
        Jens Axboe <axboe@...nel.dk>,
        Satya Tangirala <satyat@...gle.com>
Subject: Re: [PATCH v4 8/9] blk-merge: Ensure bios aren't split in middle of
 a crypto data unit

On Tue, Jul 06, 2021 at 10:29:42PM -0700, Satya Tangirala wrote:
> From: Satya Tangirala <satyat@...gle.com>
> 
> 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@...gle.com>
> ---
>  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