From nobody Sat Feb 7 21:30:43 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D9E3C34252C; Fri, 6 Feb 2026 05:02:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770354121; cv=none; b=QFpzwJV5bzs/CQ94ea56LEfPAQGa4isy58rcKYOO/0X8yzAhLY8LQ8ljYhxe068tTRIMvZygpwsEoTaJE8I+/aeEK9rv4/Bzh+/aQpUNonnDANhUIkuRLSl9AHennB5kOjl52ZWTMv1d4tolUL4f/uiZftg5/1shPn9d2SiY+vA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1770354121; c=relaxed/simple; bh=JaFArVCeKak5JqJx5bGIqX4e+QcFezwCPEZlB/x+PKY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=K+pWYcJwg7RkBOyqATzIJ85DG4RWja78+BloBlOeOifbDiNbnrce+nP6PNL2QqyN7ZT2PPJF1og+WUN92UKXAdlCcUwNr+UzEmvg9pPGXQdapy58ZTqOw8zjgqUrZO28QMmib9LBSWz//dgS2mJhuok93qPEcEavurYud7s/uCw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=oL/5vUxK; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="oL/5vUxK" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7F58FC4AF0B; Fri, 6 Feb 2026 05:02:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1770354121; bh=JaFArVCeKak5JqJx5bGIqX4e+QcFezwCPEZlB/x+PKY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=oL/5vUxKyzfSqqFKddcNTDZT3ArfVJcsOg+xzQ5gF+WJctSlAFTb/rmajQXDKC+OT 1RLHYtpyN3xyhzESRChturCmySQDsDCmkgRqm2s4POz168DrP74PH+RxyJKLcTqYB9 vq304NUTQIeCC5MH6068dLvlyJabtKaWg7ktD2CnKl8B8kA2+/smvP4vwKd4vjcMyA IZFIVBwMRuzrQYJD8dr4dgx18iBiO7Q2DrASY/Q6Dl75GNPdoziXGQ9OQ98JazwxVx 9qUL3HWNaJPI7+cwBtrufaWCUc7LCEHdSYH/4y3ccxsnnewnNLXUH/TlpJasfwH/Ys +QVY2OMZ0Gg3w== From: Eric Biggers To: dm-devel@lists.linux.dev, Alasdair Kergon , Mike Snitzer , Mikulas Patocka , Benjamin Marzinski Cc: Sami Tolvanen , linux-kernel@vger.kernel.org, Eric Biggers Subject: [PATCH 19/22] dm-verity-fec: pass down index_in_region instead of rsb Date: Thu, 5 Feb 2026 20:59:38 -0800 Message-ID: <20260206045942.52965-20-ebiggers@kernel.org> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260206045942.52965-1-ebiggers@kernel.org> References: <20260206045942.52965-1-ebiggers@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Replace 'rsb', which is a byte index, with 'index_in_region' which is a block index. The block index is slightly easier to compute, it matches what fec_read_bufs() wants, and it avoids the mismatch between the name and the units of the variable. ('rsb' stood for "Reed-Solomon block", but its units were bytes, not blocks.) fec_decode_bufs() does want it as a byte index when computing parity_block, but that's easily handled locally. As long as the parameters to the log messages are being adjusted, also eliminate the unnecessary casts to 'unsigned long long'. %llu is the correct way to print a u64 in the Linux kernel, as documented in printk-formats.rst. There's no PRIu64 macro like there is in userspace. Signed-off-by: Eric Biggers --- drivers/md/dm-verity-fec.c | 47 +++++++++++++++++++++----------------- 1 file changed, 26 insertions(+), 21 deletions(-) diff --git a/drivers/md/dm-verity-fec.c b/drivers/md/dm-verity-fec.c index 1b5052ba4f5a5..37c4eb6a11dee 100644 --- a/drivers/md/dm-verity-fec.c +++ b/drivers/md/dm-verity-fec.c @@ -47,11 +47,11 @@ static inline u8 *fec_buffer_rs_message(struct dm_verit= y *v, /* * Decode all RS codewords whose message bytes were loaded into fio->bufs.= Copy * the corrected bytes into fio->output starting from out_pos. */ static int fec_decode_bufs(struct dm_verity *v, struct dm_verity_io *io, - struct dm_verity_fec_io *fio, u64 rsb, + struct dm_verity_fec_io *fio, u64 index_in_region, int target_region, unsigned int out_pos, int neras) { int r, corrected =3D 0, res; struct dm_buffer *buf; unsigned int n, i, j, parity_pos, to_copy; @@ -65,18 +65,20 @@ static int fec_decode_bufs(struct dm_verity *v, struct = dm_verity_io *io, * the starting position in that block. Then read that block. * * block_size is always a power of 2, but roots might not be. Note that * when it's not, a codeword's parity bytes can span a block boundary. */ - parity_block =3D (rsb + out_pos) * v->fec->roots; + parity_block =3D ((index_in_region << v->data_dev_block_bits) + out_pos) * + v->fec->roots; parity_pos =3D parity_block & (v->fec->block_size - 1); parity_block >>=3D v->data_dev_block_bits; par =3D dm_bufio_read_with_ioprio(v->fec->bufio, parity_block, &buf, bio->bi_ioprio); if (IS_ERR(par)) { DMERR("%s: FEC %llu: parity read failed (block %llu): %ld", - v->data_dev->name, rsb, parity_block, PTR_ERR(par)); + v->data_dev->name, index_in_region, parity_block, + PTR_ERR(par)); return PTR_ERR(par); } =20 /* * Decode the RS codewords whose message bytes are in bufs. Each RS @@ -101,12 +103,12 @@ static int fec_decode_bufs(struct dm_verity *v, struc= t dm_verity_io *io, par =3D dm_bufio_read_with_ioprio(v->fec->bufio, parity_block, &buf, bio->bi_ioprio); if (IS_ERR(par)) { DMERR("%s: FEC %llu: parity read failed (block %llu): %ld", - v->data_dev->name, rsb, parity_block, - PTR_ERR(par)); + v->data_dev->name, index_in_region, + parity_block, PTR_ERR(par)); return PTR_ERR(par); } for (; j < v->fec->roots; j++) par_buf[j] =3D par[parity_pos++]; } @@ -130,14 +132,14 @@ static int fec_decode_bufs(struct dm_verity *v, struc= t dm_verity_io *io, error: dm_bufio_release(buf); =20 if (r < 0 && neras) DMERR_LIMIT("%s: FEC %llu: failed to correct: %d", - v->data_dev->name, (unsigned long long)rsb, r); + v->data_dev->name, index_in_region, r); else if (r > 0) DMWARN_LIMIT("%s: FEC %llu: corrected %d errors", - v->data_dev->name, (unsigned long long)rsb, r); + v->data_dev->name, index_in_region, r); =20 return r; } =20 /* @@ -156,18 +158,18 @@ static int fec_is_erasure(struct dm_verity *v, struct= dm_verity_io *io, /* * Read data blocks that are part of the RS block and deinterleave as much= as * fits into buffers. Check for erasure locations if @neras is non-NULL. */ static int fec_read_bufs(struct dm_verity *v, struct dm_verity_io *io, - u64 rsb, unsigned int out_pos, int *neras) + u64 index_in_region, unsigned int out_pos, int *neras) { bool is_zero; int i, j; struct dm_buffer *buf; struct dm_bufio_client *bufio; struct dm_verity_fec_io *fio =3D io->fec_io; - u64 block, ileaved; + u64 block; u8 *bbuf; u8 want_digest[HASH_MAX_DIGESTSIZE]; unsigned int n, src_pos; struct bio *bio =3D dm_bio_from_per_bio_data(io, v->ti->per_io_data_size); =20 @@ -180,12 +182,11 @@ static int fec_read_bufs(struct dm_verity *v, struct = dm_verity_io *io, /* * read each of the rs_k data blocks that are part of the RS block, and * interleave contents to available bufs */ for (i =3D 0; i < v->fec->rs_k; i++) { - ileaved =3D rsb + i * (v->fec->region_blocks << v->data_dev_block_bits); - block =3D ileaved >> v->data_dev_block_bits; + block =3D i * v->fec->region_blocks + index_in_region; bufio =3D v->fec->data_bufio; =20 if (block >=3D v->data_blocks) { block -=3D v->data_blocks; =20 @@ -201,13 +202,12 @@ static int fec_read_bufs(struct dm_verity *v, struct = dm_verity_io *io, } =20 bbuf =3D dm_bufio_read_with_ioprio(bufio, block, &buf, bio->bi_ioprio); if (IS_ERR(bbuf)) { DMWARN_LIMIT("%s: FEC %llu: read failed (%llu): %ld", - v->data_dev->name, - (unsigned long long)rsb, - (unsigned long long)block, PTR_ERR(bbuf)); + v->data_dev->name, index_in_region, block, + PTR_ERR(bbuf)); =20 /* assume the block is corrupted */ if (neras && *neras <=3D v->fec->roots) fio->erasures[(*neras)++] =3D i; =20 @@ -310,28 +310,33 @@ static int fec_decode(struct dm_verity *v, struct dm_= verity_io *io, struct dm_verity_fec_io *fio, u64 target_block, const u8 *want_digest, bool use_erasures) { int r, neras =3D 0; unsigned int target_region, out_pos; - u64 rsb; + u64 index_in_region; =20 - target_region =3D div64_u64_rem( - target_block << v->data_dev_block_bits, - v->fec->region_blocks << v->data_dev_block_bits, &rsb); + /* + * Compute 'target_region', the index of the region the target block is + * in; and 'index_in_region', the index of the target block within its + * region. The latter value is also the index within its region of each + * message block that shares its RS codewords with the target block. + */ + target_region =3D div64_u64_rem(target_block, v->fec->region_blocks, + &index_in_region); if (WARN_ON_ONCE(target_region >=3D v->fec->rs_k)) /* target_block is out-of-bounds. Should never happen. */ return -EIO; =20 for (out_pos =3D 0; out_pos < v->fec->block_size;) { fec_init_bufs(v, fio); =20 - r =3D fec_read_bufs(v, io, rsb, out_pos, + r =3D fec_read_bufs(v, io, index_in_region, out_pos, use_erasures ? &neras : NULL); if (unlikely(r < 0)) return r; =20 - r =3D fec_decode_bufs(v, io, fio, rsb, target_region, + r =3D fec_decode_bufs(v, io, fio, index_in_region, target_region, out_pos, neras); if (r < 0) return r; =20 out_pos +=3D fio->nbufs << DM_VERITY_FEC_BUF_RS_BITS; @@ -342,11 +347,11 @@ static int fec_decode(struct dm_verity *v, struct dm_= verity_io *io, if (unlikely(r < 0)) return r; =20 if (memcmp(io->tmp_digest, want_digest, v->digest_size)) { DMERR_LIMIT("%s: FEC %llu: failed to correct (%d erasures)", - v->data_dev->name, (unsigned long long)rsb, neras); + v->data_dev->name, index_in_region, neras); return -EILSEQ; } =20 return 0; } --=20 2.52.0