* Re: [PATCH v3 3/4] ocfs2: use jbd2 jinode dirty range accessor
From: Jan Kara @ 2026-03-02 18:07 UTC (permalink / raw)
To: Li Chen
Cc: Theodore Ts'o, Jan Kara, Mark Fasheh, linux-ext4, ocfs2-devel,
Joel Becker, Joseph Qi, linux-kernel
In-Reply-To: <20260224092434.202122-4-me@linux.beauty>
On Tue 24-02-26 17:24:32, Li Chen wrote:
> ocfs2 journal commit callback reads jbd2_inode dirty range fields without
> holding journal->j_list_lock.
> Use jbd2_jinode_get_dirty_range() to get the range in bytes.
>
> Suggested-by: Jan Kara <jack@suse.cz>
> Signed-off-by: Li Chen <me@linux.beauty>
Looks good. Feel free to add:
Reviewed-by: Jan Kara <jack@suse.cz>
Honza
> ---
> Changes since v2:
> - Use jbd2_jinode_get_dirty_range() instead of direct i_dirty_* reads.
> - Drop per-caller page->byte conversion (now handled by the accessor).
>
> fs/ocfs2/journal.c | 9 +++++++--
> 1 file changed, 7 insertions(+), 2 deletions(-)
>
> diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
> index 85239807dec78..68c2f567e6e1b 100644
> --- a/fs/ocfs2/journal.c
> +++ b/fs/ocfs2/journal.c
> @@ -902,8 +902,13 @@ int ocfs2_journal_alloc(struct ocfs2_super *osb)
>
> static int ocfs2_journal_submit_inode_data_buffers(struct jbd2_inode *jinode)
> {
> - return filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping,
> - jinode->i_dirty_start, jinode->i_dirty_end);
> + struct address_space *mapping = jinode->i_vfs_inode->i_mapping;
> + loff_t range_start, range_end;
> +
> + if (!jbd2_jinode_get_dirty_range(jinode, &range_start, &range_end))
> + return 0;
> +
> + return filemap_fdatawrite_range(mapping, range_start, range_end);
> }
>
> int ocfs2_journal_init(struct ocfs2_super *osb, int *dirty)
> --
> 2.52.0
--
Jan Kara <jack@suse.com>
SUSE Labs, CR
^ permalink raw reply
* Re: [PATCH] ext4: kunit: extents-test: Fix percpu_counters list corruption
From: Ojaswin Mujoo @ 2026-03-02 17:22 UTC (permalink / raw)
To: Ritesh Harjani (IBM); +Cc: linux-ext4
In-Reply-To: <5bb9041471dab8ce870c191c19cbe4df57473be8.1772381213.git.ritesh.list@gmail.com>
On Sun, Mar 01, 2026 at 09:44:26PM +0530, Ritesh Harjani (IBM) wrote:
> commit 82f80e2e3b23 ("ext4: add extent status cache support to kunit tests"),
> added ext4_es_register_shrinker() in extents_kunit_init() function but
> failed to add the unregister shrinker routine in extents_kunit_exit().
>
> This could cause the following percpu_counters list corruption bug.
>
> ok 1 split unwrit extent to 2 extents and convert 1st half writ
> slab kmalloc-4k start c0000002007ff000 pointer offset 1448 size 4096
> list_add corruption. next->prev should be prev (c000000004bc9e60), but was 0000000000000000. (next=c0000002007ff5a8).
> ------------[ cut here ]------------
> kernel BUG at lib/list_debug.c:29!
> cpu 0x2: Vector: 700 (Program Check) at [c000000241927a30]
> pc: c000000000f26ed0: __list_add_valid_or_report+0x120/0x164
> lr: c000000000f26ecc: __list_add_valid_or_report+0x11c/0x164
> sp: c000000241927cd0
> msr: 800000000282b033
> current = 0xc000000241215200
> paca = 0xc0000003fffff300 irqmask: 0x03 irq_happened: 0x09
> pid = 258, comm = kunit_try_catch
> kernel BUG at lib/list_debug.c:29!
> enter ? for help
> __percpu_counter_init_many+0x148/0x184
> ext4_es_register_shrinker+0x74/0x23c
> extents_kunit_init+0x100/0x308
> kunit_try_run_case+0x78/0x1f8
> kunit_generic_run_threadfn_adapter+0x40/0x70
> kthread+0x190/0x1a0
> start_kernel_thread+0x14/0x18
> 2:mon>
>
> This happens because:
>
> extents_kunit_init(test N):
> ext4_es_register_shrinker(sbi)
> percpu_counters_init() x 4; // this adds 4 list nodes to global percpu_counters list
> list_add(&fbc->list, &percpu_counters);
> shrinker_register();
>
> extents_kunit_exit(test N):
> kfree(sbi); // frees sbi w/o removing those 4 list nodes.
> // So, those list node now becomes dangling pointers
>
> extents_kunit_init(test N+1):
> kzalloc_obj(ext4_sb_info) // allocator returns same page, but zeroed.
> ext4_es_register_shrinker(sbi)
> percpu_counters_init()
> list_add(&fbc->list, &percpu_counters);
> __list_add_valid(new, prev, next);
> next->prev != prev // list corruption bug detected, since next->prev = NULL
>
> Fixes: 82f80e2e3b23 ("ext4: add extent status cache support to kunit tests")
> Signed-off-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com>
> ---
Hey Ritesh,
I can confirm that the patch fixes the issue. Thanks for looking into
this. Feel free to add:
Reviewed-by: Ojaswin Mujoo <ojaswin@linux.ibm.com>
Regards,
ojaswin
> fs/ext4/extents-test.c | 4 +++-
> 1 file changed, 3 insertions(+), 1 deletion(-)
>
> diff --git a/fs/ext4/extents-test.c b/fs/ext4/extents-test.c
> index 7c4690eb7dad..a6b3e6b592a5 100644
> --- a/fs/ext4/extents-test.c
> +++ b/fs/ext4/extents-test.c
> @@ -142,8 +142,10 @@ static struct file_system_type ext_fs_type = {
>
> static void extents_kunit_exit(struct kunit *test)
> {
> - struct ext4_sb_info *sbi = k_ctx.k_ei->vfs_inode.i_sb->s_fs_info;
> + struct super_block *sb = k_ctx.k_ei->vfs_inode.i_sb;
> + struct ext4_sb_info *sbi = sb->s_fs_info;
>
> + ext4_es_unregister_shrinker(sbi);
> kfree(sbi);
> kfree(k_ctx.k_ei);
> kfree(k_ctx.k_data);
> --
> 2.53.0
>
^ permalink raw reply
* Re: [PATCH] ext4: avoid allocate block from corrupted group in ext4_mb_find_by_goal()
From: Jan Kara @ 2026-03-02 16:27 UTC (permalink / raw)
To: Ye Bin; +Cc: tytso, adilger.kernel, linux-ext4, jack
In-Reply-To: <20260302134619.3145520-1-yebin@huaweicloud.com>
On Mon 02-03-26 21:46:19, Ye Bin wrote:
> From: Ye Bin <yebin10@huawei.com>
>
> There's issue as follows:
> ...
> EXT4-fs (mmcblk0p1): Delayed block allocation failed for inode 206 at logical offset 0 with max blocks 1 with error 117
> EXT4-fs (mmcblk0p1): This should not happen!! Data will be lost
>
> EXT4-fs (mmcblk0p1): Delayed block allocation failed for inode 206 at logical offset 0 with max blocks 1 with error 117
> EXT4-fs (mmcblk0p1): This should not happen!! Data will be lost
>
> EXT4-fs (mmcblk0p1): Delayed block allocation failed for inode 206 at logical offset 0 with max blocks 1 with error 117
> EXT4-fs (mmcblk0p1): This should not happen!! Data will be lost
>
> EXT4-fs (mmcblk0p1): Delayed block allocation failed for inode 206 at logical offset 0 with max blocks 1 with error 117
> EXT4-fs (mmcblk0p1): This should not happen!! Data will be lost
>
> EXT4-fs (mmcblk0p1): Delayed block allocation failed for inode 2243 at logical offset 0 with max blocks 1 with error 117
> EXT4-fs (mmcblk0p1): This should not happen!! Data will be lost
>
> EXT4-fs (mmcblk0p1): Delayed block allocation failed for inode 2239 at logical offset 0 with max blocks 1 with error 117
> EXT4-fs (mmcblk0p1): This should not happen!! Data will be lost
>
> EXT4-fs (mmcblk0p1): error count since last fsck: 1
> EXT4-fs (mmcblk0p1): initial error at time 1765597433: ext4_mb_generate_buddy:760
> EXT4-fs (mmcblk0p1): last error at time 1765597433: ext4_mb_generate_buddy:760
> ...
>
> According to the log analysis, blocks are always requested from the
> corrupted block group. This may happen as follows:
> ext4_mb_find_by_goal
> ext4_mb_load_buddy
> ext4_mb_load_buddy_gfp
> ext4_mb_init_cache
> ext4_read_block_bitmap_nowait
> ext4_wait_block_bitmap
> ext4_validate_block_bitmap
> if (!grp || EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
> return -EFSCORRUPTED; // There's no logs.
> if (err)
> return err; // Will return error
> ext4_lock_group(ac->ac_sb, group);
> if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info))) // Unreachable
> goto out;
>
> After commit 9008a58e5dce ("ext4: make the bitmap read routines return
> real error codes") merged, Commit 163a203ddb36 ("ext4: mark block group
> as corrupt on block bitmap error") is no real solution for allocating
> blocks from corrupted block groups. This is because if
> 'EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info)' is true, then
> 'ext4_mb_load_buddy()' may return an error. This means that the block
> allocation will fail.
> Therefore, check block group if corrupted when ext4_mb_load_buddy()
> returns error.
>
> Fixes: 163a203ddb36 ("ext4: mark block group as corrupt on block bitmap error")
> Fixes: 9008a58e5dce ("ext4: make the bitmap read routines return real error codes")
> Signed-off-by: Ye Bin <yebin10@huawei.com>
Looks good. Feel free to add:
Reviewed-by: Jan Kara <jack@suse.cz>
Honza
> ---
> fs/ext4/mballoc.c | 6 +++++-
> 1 file changed, 5 insertions(+), 1 deletion(-)
>
> diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
> index e2341489f4d0..ffa6886de8a3 100644
> --- a/fs/ext4/mballoc.c
> +++ b/fs/ext4/mballoc.c
> @@ -2443,8 +2443,12 @@ int ext4_mb_find_by_goal(struct ext4_allocation_context *ac,
> return 0;
>
> err = ext4_mb_load_buddy(ac->ac_sb, group, e4b);
> - if (err)
> + if (err) {
> + if (EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info) &&
> + !(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
> + return 0;
> return err;
> + }
>
> ext4_lock_group(ac->ac_sb, group);
> if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info)))
> --
> 2.34.1
>
--
Jan Kara <jack@suse.com>
SUSE Labs, CR
^ permalink raw reply
* Re: [PATCH] jbd2: gracefully abort instead of panicking on unlocked buffer
From: Milos Nikic @ 2026-03-02 16:21 UTC (permalink / raw)
To: jack; +Cc: jack, linux-ext4, linux-kernel, nikic.milos, tytso, yi.zhang
In-Reply-To: <u4zbebo5va2oxs3ggr5caspz5mklufrfx2rjjg4sw3vhm5d3pw@a5vd7a2ufarh>
Hi Jan,
No, I didn't trigger this in the wild. I have been auditing jbd2 for J_ASSERT usage to see where we could proactively swap hard panics for graceful journal aborts.
You are right that there are many similar asserts, but I focused on this one because it belongs to a specific, easily-actionable group: it resides in a function that already returns an error code (int).
Some of the other J_ASSERTs are buried inside void functions. Converting those to return errors would require cascading API changes and rewriting caller error-handling paths across the subsystem, which is a much bigger and riskier lift.
My goal was just to target the "low-hanging fruit" - the asserts where the function signature already supports returning an error (-EINVAL/-EIO) and aborting the journal safely without changing the API.
If you are open to it, I can audit the codebase for the rest of the asserts that fit this exact profile and submit them. Would you prefer them grouped into a single patch, or a short series?
Thanks,
Milos
^ permalink raw reply
* Re: [PATCH] jbd2: gracefully abort instead of panicking on unlocked buffer
From: Jan Kara @ 2026-03-02 16:20 UTC (permalink / raw)
To: Milos Nikic; +Cc: Jan Kara, jack, tytso, linux-ext4, linux-kernel, yi.zhang
In-Reply-To: <CAOeJtk_JmASoSZQ_Y=qY155vQCXGnpqtXy8EPc3HA5yj4QFsJQ@mail.gmail.com>
On Mon 02-03-26 07:58:41, Milos Nikic wrote:
> Hi Jan,
>
> No, I didn't trigger this in the wild. I have been auditing jbd2 for
> J_ASSERT usage to see where we could proactively swap hard panics for
> graceful journal aborts.
> You are right that there are many similar asserts, but I focused on this
> one because it belongs to a specific, easily-actionable group: it resides
> in a function that already returns an error code (int).
>
> Many of the other J_ASSERTs are buried inside void functions. Converting
> those to return errors would require cascading API changes and rewriting
> caller error-handling paths across the subsystem, which is a much bigger
> and riskier lift.
> My goal was just to target the "low-hanging fruit"—the asserts where the
> function signature already supports returning an error (-EINVAL/-EIO) and
> aborting the journal safely without changing the API.
>
> If you are open to it, I can audit the codebase for the rest of the asserts
> that fit this exact profile and submit them.
> Would you prefer them grouped into a single patch, or a short series?
OK, thanks for explanation. So if you can submit a patch addressing these
easy cases (possibly split to one patch per file in case the patch would be
too big) that would be good. For this patch feel free to add:
Reviewed-by: Jan Kara <jack@suse.cz>
Honza
>
> Thanks,
> Milos
>
> On Mon, Mar 2, 2026 at 5:08 AM Jan Kara <jack@suse.cz> wrote:
>
> > On Sun 01-03-26 16:31:35, Milos Nikic wrote:
> > > In jbd2_journal_get_create_access(), if the caller passes an unlocked
> > > buffer, the code currently triggers a fatal J_ASSERT.
> > >
> > > While an unlocked buffer here is a clear API violation and a bug in the
> > > caller, crashing the entire system is an overly severe response. It
> > brings
> > > down the whole machine for a localized filesystem inconsistency.
> > >
> > > Replace the J_ASSERT with a WARN_ON_ONCE to capture the offending
> > caller's
> > > stack trace, and return an error (-EINVAL). This allows the journal to
> > > gracefully abort the transaction, protecting data integrity without
> > > causing a kernel panic.
> > >
> > > Signed-off-by: Milos Nikic <nikic.milos@gmail.com>
> >
> > In principle I'm fine with this however we have lots of similar asserts in
> > the code. So how is this one special? Did you somehow trigger it?
> >
> > Honza
> >
> > > ---
> > > fs/jbd2/transaction.c | 7 ++++++-
> > > 1 file changed, 6 insertions(+), 1 deletion(-)
> > >
> > > diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
> > > index dca4b5d8aaaa..04d17a5f2a82 100644
> > > --- a/fs/jbd2/transaction.c
> > > +++ b/fs/jbd2/transaction.c
> > > @@ -1302,7 +1302,12 @@ int jbd2_journal_get_create_access(handle_t
> > *handle, struct buffer_head *bh)
> > > goto out;
> > > }
> > >
> > > - J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
> > > + if (WARN_ON_ONCE(!buffer_locked(jh2bh(jh)))) {
> > > + err = -EINVAL;
> > > + spin_unlock(&jh->b_state_lock);
> > > + jbd2_journal_abort(journal, err);
> > > + goto out;
> > > + }
> > >
> > > if (jh->b_transaction == NULL) {
> > > /*
> > > --
> > > 2.53.0
> > >
> > --
> > Jan Kara <jack@suse.com>
> > SUSE Labs, CR
> >
--
Jan Kara <jack@suse.com>
SUSE Labs, CR
^ permalink raw reply
* Re: [PATCH v4] ext4: simplify mballoc preallocation size rounding for small files
From: Ojaswin Mujoo @ 2026-03-02 15:22 UTC (permalink / raw)
To: Weixie Cui
Cc: dilger.kernel, linux-ext4, linux-kernel, Weixie Cui,
Andreas Dilger
In-Reply-To: <tencent_E9C5F1B2E9939B3037501FD04A7E9CF0C407@qq.com>
On Wed, Feb 25, 2026 at 01:02:31PM +0800, Weixie Cui wrote:
> From: Weixie Cui <cuiweixie@gmail.com>
>
> The if-else ladder in ext4_mb_normalize_request() manually rounds up
> the preallocation size to the next power of two for files up to 1MB,
> enumerating each step from 16KB to 1MB individually. Replace this with
> a single roundup_pow_of_two() call clamped to a 16KB minimum, which
> is functionally equivalent but much more concise.
>
> Also replace raw byte constants with SZ_1M and SZ_16K from
> <linux/sizes.h> for clarity, and remove the stale "XXX: should this
> table be tunable?" comment that has been there since the original
> mballoc code.
>
> No functional change.
>
> Reviewed-by: Andreas Dilger <adilger@dilger.ca>
> Signed-off-by: Weixie Cui <cuiweixie@gmail.com>
>
> ---
> v4:
> - Drop unnecessary braces around single-line if/else as suggested
> by Andreas Dilger
>
> v3:
> - Replace raw constants with SZ_1M/SZ_16K
> - Remove stale XXX comment
> ---
> fs/ext4/mballoc.c | 24 +++++++++---------------
> 1 file changed, 9 insertions(+), 15 deletions(-)
>
> diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
> index 20e9fdaf4301..1d6efba97835 100644
> --- a/fs/ext4/mballoc.c
> +++ b/fs/ext4/mballoc.c
> @@ -4561,22 +4561,16 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac,
> (req <= (size) || max <= (chunk_size))
>
> /* first, try to predict filesize */
> - /* XXX: should this table be tunable? */
> start_off = 0;
> - if (size <= 16 * 1024) {
> - size = 16 * 1024;
> - } else if (size <= 32 * 1024) {
> - size = 32 * 1024;
> - } else if (size <= 64 * 1024) {
> - size = 64 * 1024;
> - } else if (size <= 128 * 1024) {
> - size = 128 * 1024;
> - } else if (size <= 256 * 1024) {
> - size = 256 * 1024;
> - } else if (size <= 512 * 1024) {
> - size = 512 * 1024;
> - } else if (size <= 1024 * 1024) {
> - size = 1024 * 1024;
> + if (size <= SZ_1M) {
> + /*
> + * For files up to 1MB, round up the preallocation size to
> + * the next power of two, with a minimum of 16KB.
> + */
> + if (size <= (unsigned long)SZ_16K)
> + size = SZ_16K;
> + else
> + size = roundup_pow_of_two(size);
Hi Weixie,
This if else ladder was long due a cleanup so thanks for taking this up.
I have one suggestion since you are already looking into this, do you
mind also cleaning up the NRL_CHECK_SIZE() logic because its pretty
messy
Essentially, the max contiguous blocks the buddy allocator can allocate
in one go is (bs * 2) no. of blocks so 4k bs can support 8192 blocks (ie
32MB) and 1024 bs can support 2048 blocks (ie 2MB) in one go. The
NRL_CHECK_SIZE() macro logic just makes sure that we dont set size as,
for example, 8MB for a 1kb bs ext4 which can only support upro 2MB
continuous allocations via buddy.
We should be able to refactor the above logic in much simpler way and
get rid of NRL_CHECK_SIZE.
Regards,
Ojaswin
> } else if (NRL_CHECK_SIZE(size, 4 * 1024 * 1024, max, 2 * 1024)) {
> start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
> (21 - bsbits)) << 21;
> --
> 2.39.5 (Apple Git-154)
>
^ permalink raw reply
* Re: [PATCH v2] generic/108: fix test hand upon failure to create LV
From: Ojaswin Mujoo @ 2026-03-02 14:43 UTC (permalink / raw)
To: linux-ext4, Theodore Ts'o; +Cc: Disha Goel
In-Reply-To: <98f8ef5ff92632a0be336a563ebda36cfe898348.1767782181.git.ojaswin@linux.ibm.com>
On Mon, Mar 02, 2026 at 08:07:24PM +0530, Ojaswin Mujoo wrote:
> In case the lvcreate operation fails, we don't catch the error and
> proceed as usual. The test then tries to wait for the LV to come up
> but it never does, causing a hang.
>
> To fix this:
> 1. Add a check to ensure SCSI_DEBUG dev is of required size
> 2. Additionally, fail if there are errors while creating the LV.
>
> Context for completeness:
>
> This was noticed when we accidentally used CONFIG_SCSI_DEBUG=y instead
> of =m, causing it to create an 8MB SCSI debug device. This led to the
> lvcreate operation to fail with:
>
> Insufficient suitable allocatable extents for logical volume lv_108: 68 more required
>
> However the test never caught this resulting in a hang.
Hey sorry I accidentally sent the wrong patch via git send-mail. Please
ignore :/
Regards,
Ojaswin
^ permalink raw reply
* [PATCH v2] ext4: Minor fix for ext4_split_extent_zeroout()
From: Ojaswin Mujoo @ 2026-03-02 14:38 UTC (permalink / raw)
To: linux-ext4, Theodore Ts'o; +Cc: Dan Carpenter, Ritesh Harjani (IBM)
We missed storing the error which triggerd smatch warning:
fs/ext4/extents.c:3369 ext4_split_extent_zeroout()
warn: duplicate zero check 'err' (previous on line 3363)
fs/ext4/extents.c
3361
3362 err = ext4_ext_get_access(handle, inode, path + depth);
3363 if (err)
3364 return err;
3365
3366 ext4_ext_mark_initialized(ex);
3367
3368 ext4_ext_dirty(handle, inode, path + depth);
--> 3369 if (err)
3370 return err;
3371
3372 return 0;
3373 }
Fix it by correctly storing the err value from ext4_ext_dirty().
Link: https://lore.kernel.org/all/aYXvVgPnKltX79KE@stanley.mountain/
Reported-by: Dan Carpenter <dan.carpenter@linaro.org>
Fixes: a985e07c26455 ("ext4: refactor zeroout path and handle all cases")
Reviewed-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com>
Signed-off-by: Ojaswin Mujoo <ojaswin@linux.ibm.com>
---
fs/ext4/extents.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 3630b27e4fd7..5579e0e68c0f 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -3365,7 +3365,7 @@ static int ext4_split_extent_zeroout(handle_t *handle, struct inode *inode,
ext4_ext_mark_initialized(ex);
- ext4_ext_dirty(handle, inode, path + depth);
+ err = ext4_ext_dirty(handle, inode, path + depth);
if (err)
return err;
--
2.52.0
^ permalink raw reply related
* [PATCH v2] generic/108: fix test hand upon failure to create LV
From: Ojaswin Mujoo @ 2026-03-02 14:37 UTC (permalink / raw)
To: linux-ext4, Theodore Ts'o; +Cc: Disha Goel
In case the lvcreate operation fails, we don't catch the error and
proceed as usual. The test then tries to wait for the LV to come up
but it never does, causing a hang.
To fix this:
1. Add a check to ensure SCSI_DEBUG dev is of required size
2. Additionally, fail if there are errors while creating the LV.
Context for completeness:
This was noticed when we accidentally used CONFIG_SCSI_DEBUG=y instead
of =m, causing it to create an 8MB SCSI debug device. This led to the
lvcreate operation to fail with:
Insufficient suitable allocatable extents for logical volume lv_108: 68 more required
However the test never caught this resulting in a hang.
Signed-off-by: Ojaswin Mujoo <ojaswin@linux.ibm.com>
Reported-by: Disha Goel <disgoel@linux.ibm.com>
---
tests/generic/108 | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/tests/generic/108 b/tests/generic/108
index 4f86ec94..05d743a9 100755
--- a/tests/generic/108
+++ b/tests/generic/108
@@ -50,6 +50,11 @@ SCSI_DEBUG_DEV=`_get_scsi_debug_dev ${physical:-512} ${logical:-512} 0 $size`
test -b "$SCSI_DEBUG_DEV" || _notrun "Failed to initialize scsi debug device"
echo "SCSI debug device $SCSI_DEBUG_DEV" >>$seqres.full
+got_size_kb=$(_get_device_size $SCSI_DEBUG_DEV)
+
+[[ $got_size_kb -lt $((size * 1024)) ]] &&
+ _notrun "Need SCSI debug device of size $(( size * 1024 )) KB. Got $got_size_kb KB"
+
# create striped volume with 4MB stripe size
#
# lvm has a hardcoded list of valid devices and fails with
@@ -60,7 +65,7 @@ $LVM_PROG vgcreate -f $vgname $SCSI_DEBUG_DEV $SCRATCH_DEV >>$seqres.full 2>&1
# We use yes pipe instead of 'lvcreate --yes' because old version of lvm
# (like 2.02.95 in RHEL6) don't support --yes option
yes | $LVM_PROG lvcreate -i 2 -I 4m -L ${lvsize}m -n $lvname $vgname \
- >>$seqres.full 2>&1
+ >>$seqres.full 2>&1 || _fail "Failed to create LVM lv"
_udev_wait /dev/mapper/$vgname-$lvname
# _mkfs_dev exits the test on failure, this makes sure test lv is created by
--
2.51.0
^ permalink raw reply related
* Re: [PATCH] ext4: Minor fix for ext4_split_extent_zeroout()
From: Ojaswin Mujoo @ 2026-03-02 14:30 UTC (permalink / raw)
To: Ritesh Harjani; +Cc: linux-ext4, Theodore Ts'o, Dan Carpenter
In-Reply-To: <87tsvg7x32.ritesh.list@gmail.com>
On Tue, Feb 17, 2026 at 11:03:53AM +0530, Ritesh Harjani wrote:
> Ojaswin Mujoo <ojaswin@linux.ibm.com> writes:
>
> > We missed storing the error which triggerd smatch warning:
> >
> > fs/ext4/extents.c:3369 ext4_split_extent_zeroout()
> > warn: duplicate zero check 'err' (previous on line 3363)
> >
> > fs/ext4/extents.c
> > 3361
> > 3362 err = ext4_ext_get_access(handle, inode, path + depth);
> > 3363 if (err)
> > 3364 return err;
> > 3365
> > 3366 ext4_ext_mark_initialized(ex);
> > 3367
> > 3368 ext4_ext_dirty(handle, inode, path + depth);
> > --> 3369 if (err)
> > 3370 return err;
> > 3371
> > 3372 return 0;
> > 3373 }
> >
> > Fix it by correctly storing the err value from ext4_ext_dirty().
> >
>
>
> Looks straight forward.
>
>
> > Link: https://lore.kernel.org/all/aYXvVgPnKltX79KE@stanley.mountain/
> > Reported-by: Dan Carpenter <dan.carpenter@linaro.org>
> > Signed-off-by: Ojaswin Mujoo <ojaswin@linux.ibm.com>
>
> Fixes: a985e07c26455 ("ext4: refactor zeroout path and handle all cases")
>
> Reviewed-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com>
Thanks Ritesh, I'll add the fixes tag and resend.
Regards,
ojaswin
>
>
> > ---
> > fs/ext4/extents.c | 2 +-
> > 1 file changed, 1 insertion(+), 1 deletion(-)
> >
> > diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
> > index 3630b27e4fd7..5579e0e68c0f 100644
> > --- a/fs/ext4/extents.c
> > +++ b/fs/ext4/extents.c
> > @@ -3365,7 +3365,7 @@ static int ext4_split_extent_zeroout(handle_t *handle, struct inode *inode,
> >
> > ext4_ext_mark_initialized(ex);
> >
> > - ext4_ext_dirty(handle, inode, path + depth);
> > + err = ext4_ext_dirty(handle, inode, path + depth);
> > if (err)
> > return err;
> >
> > --
> > 2.52.0
^ permalink raw reply
* [PATCH 14/14] ext4: use a byte granularity cursor in ext4_mpage_readpages
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Replace the next_block variable that is in units of file system blocks
and incorretly uses the sector_t type with a byte offset, as that is
what both users want.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/ext4/readpage.c | 11 +++++------
1 file changed, 5 insertions(+), 6 deletions(-)
diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index fbfa4d830d9a..6ec503bde00b 100644
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -215,11 +215,11 @@ static int ext4_mpage_readpages(struct inode *inode, struct fsverity_info *vi,
sector_t last_block_in_bio = 0;
const unsigned blkbits = inode->i_blkbits;
const unsigned blocksize = 1 << blkbits;
- sector_t next_block;
sector_t block_in_file;
sector_t last_block;
sector_t last_block_in_file;
sector_t first_block;
+ loff_t pos;
unsigned page_block;
struct block_device *bdev = inode->i_sb->s_bdev;
int length;
@@ -249,7 +249,8 @@ static int ext4_mpage_readpages(struct inode *inode, struct fsverity_info *vi,
blocks_per_folio = folio_size(folio) >> blkbits;
first_hole = blocks_per_folio;
- block_in_file = next_block = EXT4_PG_TO_LBLK(inode, folio->index);
+ pos = folio_pos(folio);
+ block_in_file = pos >> blkbits;
last_block = EXT4_PG_TO_LBLK(inode, folio->index + nr_pages);
last_block_in_file = (ext4_readpage_limit(inode) +
blocksize - 1) >> blkbits;
@@ -342,8 +343,7 @@ static int ext4_mpage_readpages(struct inode *inode, struct fsverity_info *vi,
* BIO off first?
*/
if (bio && (last_block_in_bio != first_block - 1 ||
- !fscrypt_mergeable_bio(bio, inode,
- (loff_t)next_block << blkbits))) {
+ !fscrypt_mergeable_bio(bio, inode, pos))) {
submit_and_realloc:
blk_crypto_submit_bio(bio);
bio = NULL;
@@ -355,8 +355,7 @@ static int ext4_mpage_readpages(struct inode *inode, struct fsverity_info *vi,
*/
bio = bio_alloc(bdev, bio_max_segs(nr_pages),
REQ_OP_READ, GFP_KERNEL);
- fscrypt_set_bio_crypt_ctx(bio, inode,
- (loff_t)next_block << blkbits, GFP_KERNEL);
+ fscrypt_set_bio_crypt_ctx(bio, inode, pos, GFP_KERNEL);
ext4_set_bio_post_read_ctx(bio, inode, vi);
bio->bi_iter.bi_sector = first_block << (blkbits - 9);
bio->bi_end_io = mpage_end_io;
--
2.47.3
^ permalink raw reply related
* [PATCH 13/14] fscrypt: pass a real sector_t to fscrypt_zeroout_range
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
While the pblk argument to fscrypt_zeroout_range is declared as a
sector_t, it actually is interpreted as a logical block size unit, which
is highly unusual. Switch to passing the 512 byte units that sector_t is
defined for.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/crypto/bio.c | 5 ++---
fs/ext4/inode.c | 3 ++-
fs/f2fs/file.c | 2 +-
include/linux/fscrypt.h | 6 +++---
4 files changed, 8 insertions(+), 8 deletions(-)
diff --git a/fs/crypto/bio.c b/fs/crypto/bio.c
index 93087635d987..9bf0abebde82 100644
--- a/fs/crypto/bio.c
+++ b/fs/crypto/bio.c
@@ -114,7 +114,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
* fscrypt_zeroout_range() - zero out a range of blocks in an encrypted file
* @inode: the file's inode
* @pos: the first file position (in bytes) to zero out
- * @pblk: the first filesystem physical block to zero out
+ * @sector: the first sector to zero out
* @len: bytes to zero out
*
* Zero out filesystem blocks in an encrypted regular file on-disk, i.e. write
@@ -129,7 +129,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
* Return: 0 on success; -errno on failure.
*/
int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
- sector_t pblk, u64 len)
+ sector_t sector, u64 len)
{
const struct fscrypt_inode_info *ci = fscrypt_get_inode_info_raw(inode);
const unsigned int du_bits = ci->ci_data_unit_bits;
@@ -138,7 +138,6 @@ int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
const unsigned int du_per_page = 1U << du_per_page_bits;
u64 du_index = pos >> du_bits;
u64 du_remaining = len >> du_bits;
- sector_t sector = pblk << (inode->i_blkbits - SECTOR_SHIFT);
struct page *pages[16]; /* write up to 16 pages at a time */
unsigned int nr_pages;
unsigned int i;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 8ef61198e14c..fe258ffd4840 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -406,7 +406,8 @@ int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
if (IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode))
return fscrypt_zeroout_range(inode,
- (loff_t)lblk << inode->i_blkbits, pblk,
+ (loff_t)lblk << inode->i_blkbits,
+ pblk << (inode->i_blkbits - SECTOR_SHIFT),
(u64)len << inode->i_blkbits);
ret = sb_issue_zeroout(inode->i_sb, pblk, len, GFP_NOFS);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 8785f7c13657..a264771cfbc2 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -4163,7 +4163,7 @@ static int f2fs_secure_erase(struct block_device *bdev, struct inode *inode,
if (!ret && (flags & F2FS_TRIM_FILE_ZEROOUT)) {
if (IS_ENCRYPTED(inode))
ret = fscrypt_zeroout_range(inode,
- (loff_t)off << inode->i_blkbits, block,
+ (loff_t)off << inode->i_blkbits, sector,
(u64)len << inode->i_blkbits);
else
ret = blkdev_issue_zeroout(bdev, sector, nr_sects,
diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h
index 90ac62fda926..54712ec61ffb 100644
--- a/include/linux/fscrypt.h
+++ b/include/linux/fscrypt.h
@@ -450,8 +450,8 @@ u64 fscrypt_fname_siphash(const struct inode *dir, const struct qstr *name);
/* bio.c */
bool fscrypt_decrypt_bio(struct bio *bio);
-int fscrypt_zeroout_range(const struct inode *inode, loff_t pos, sector_t pblk,
- u64 len);
+int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
+ sector_t sector, u64 len);
/* hooks.c */
int fscrypt_file_open(struct inode *inode, struct file *filp);
@@ -756,7 +756,7 @@ static inline bool fscrypt_decrypt_bio(struct bio *bio)
}
static inline int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
- sector_t pblk, u64 len)
+ sector_t sector, u64 len)
{
return -EOPNOTSUPP;
}
--
2.47.3
^ permalink raw reply related
* [PATCH 12/14] fscrypt: pass a byte length to fscrypt_zeroout_range
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Range lengths are usually expressed as bytes in the VFS, switch
fscrypt_zeroout_range to this convention.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/crypto/bio.c | 11 ++++++-----
fs/ext4/inode.c | 3 ++-
fs/f2fs/file.c | 2 +-
include/linux/fscrypt.h | 6 +++---
4 files changed, 12 insertions(+), 10 deletions(-)
diff --git a/fs/crypto/bio.c b/fs/crypto/bio.c
index a07ac8dcf851..93087635d987 100644
--- a/fs/crypto/bio.c
+++ b/fs/crypto/bio.c
@@ -115,12 +115,13 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
* @inode: the file's inode
* @pos: the first file position (in bytes) to zero out
* @pblk: the first filesystem physical block to zero out
- * @len: number of blocks to zero out
+ * @len: bytes to zero out
*
* Zero out filesystem blocks in an encrypted regular file on-disk, i.e. write
* ciphertext blocks which decrypt to the all-zeroes block. The blocks must be
* both logically and physically contiguous. It's also assumed that the
- * filesystem only uses a single block device, ->s_bdev.
+ * filesystem only uses a single block device, ->s_bdev. @len must be a
+ * multiple of the file system logical block size.
*
* Note that since each block uses a different IV, this involves writing a
* different ciphertext to each block; we can't simply reuse the same one.
@@ -128,7 +129,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
* Return: 0 on success; -errno on failure.
*/
int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
- sector_t pblk, unsigned int len)
+ sector_t pblk, u64 len)
{
const struct fscrypt_inode_info *ci = fscrypt_get_inode_info_raw(inode);
const unsigned int du_bits = ci->ci_data_unit_bits;
@@ -136,7 +137,7 @@ int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
const unsigned int du_per_page_bits = PAGE_SHIFT - du_bits;
const unsigned int du_per_page = 1U << du_per_page_bits;
u64 du_index = pos >> du_bits;
- u64 du_remaining = (u64)len << (inode->i_blkbits - du_bits);
+ u64 du_remaining = len >> du_bits;
sector_t sector = pblk << (inode->i_blkbits - SECTOR_SHIFT);
struct page *pages[16]; /* write up to 16 pages at a time */
unsigned int nr_pages;
@@ -150,7 +151,7 @@ int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
if (fscrypt_inode_uses_inline_crypto(inode))
return fscrypt_zeroout_range_inline_crypt(inode, pos, sector,
- (u64)len << inode->i_blkbits);
+ len);
BUILD_BUG_ON(ARRAY_SIZE(pages) > BIO_MAX_VECS);
nr_pages = min_t(u64, ARRAY_SIZE(pages),
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 945613c95ffa..8ef61198e14c 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -406,7 +406,8 @@ int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
if (IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode))
return fscrypt_zeroout_range(inode,
- (loff_t)lblk << inode->i_blkbits, pblk, len);
+ (loff_t)lblk << inode->i_blkbits, pblk,
+ (u64)len << inode->i_blkbits);
ret = sb_issue_zeroout(inode->i_sb, pblk, len, GFP_NOFS);
if (ret > 0)
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 239c2666ceb5..8785f7c13657 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -4164,7 +4164,7 @@ static int f2fs_secure_erase(struct block_device *bdev, struct inode *inode,
if (IS_ENCRYPTED(inode))
ret = fscrypt_zeroout_range(inode,
(loff_t)off << inode->i_blkbits, block,
- len);
+ (u64)len << inode->i_blkbits);
else
ret = blkdev_issue_zeroout(bdev, sector, nr_sects,
GFP_NOFS, 0);
diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h
index 9fc15e1fbe57..90ac62fda926 100644
--- a/include/linux/fscrypt.h
+++ b/include/linux/fscrypt.h
@@ -450,8 +450,8 @@ u64 fscrypt_fname_siphash(const struct inode *dir, const struct qstr *name);
/* bio.c */
bool fscrypt_decrypt_bio(struct bio *bio);
-int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
- sector_t pblk, unsigned int len);
+int fscrypt_zeroout_range(const struct inode *inode, loff_t pos, sector_t pblk,
+ u64 len);
/* hooks.c */
int fscrypt_file_open(struct inode *inode, struct file *filp);
@@ -756,7 +756,7 @@ static inline bool fscrypt_decrypt_bio(struct bio *bio)
}
static inline int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
- sector_t pblk, unsigned int len)
+ sector_t pblk, u64 len)
{
return -EOPNOTSUPP;
}
--
2.47.3
^ permalink raw reply related
* [PATCH 11/14] fscrypt: pass a byte offset to fscrypt_zeroout_range
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Logical offsets into an inode are usually expressed as bytes in the VFS.
Switch fscrypt_zeroout_range to that convention.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/crypto/bio.c | 7 +++----
fs/ext4/inode.c | 3 ++-
fs/f2fs/file.c | 4 +++-
include/linux/fscrypt.h | 4 ++--
4 files changed, 10 insertions(+), 8 deletions(-)
diff --git a/fs/crypto/bio.c b/fs/crypto/bio.c
index 303b5acc66a9..a07ac8dcf851 100644
--- a/fs/crypto/bio.c
+++ b/fs/crypto/bio.c
@@ -113,7 +113,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
/**
* fscrypt_zeroout_range() - zero out a range of blocks in an encrypted file
* @inode: the file's inode
- * @lblk: the first file logical block to zero out
+ * @pos: the first file position (in bytes) to zero out
* @pblk: the first filesystem physical block to zero out
* @len: number of blocks to zero out
*
@@ -127,7 +127,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
*
* Return: 0 on success; -errno on failure.
*/
-int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
+int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
sector_t pblk, unsigned int len)
{
const struct fscrypt_inode_info *ci = fscrypt_get_inode_info_raw(inode);
@@ -135,9 +135,8 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
const unsigned int du_size = 1U << du_bits;
const unsigned int du_per_page_bits = PAGE_SHIFT - du_bits;
const unsigned int du_per_page = 1U << du_per_page_bits;
- u64 du_index = (u64)lblk << (inode->i_blkbits - du_bits);
+ u64 du_index = pos >> du_bits;
u64 du_remaining = (u64)len << (inode->i_blkbits - du_bits);
- loff_t pos = (loff_t)lblk << inode->i_blkbits;
sector_t sector = pblk << (inode->i_blkbits - SECTOR_SHIFT);
struct page *pages[16]; /* write up to 16 pages at a time */
unsigned int nr_pages;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 396dc3a5d16b..945613c95ffa 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -405,7 +405,8 @@ int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
KUNIT_STATIC_STUB_REDIRECT(ext4_issue_zeroout, inode, lblk, pblk, len);
if (IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode))
- return fscrypt_zeroout_range(inode, lblk, pblk, len);
+ return fscrypt_zeroout_range(inode,
+ (loff_t)lblk << inode->i_blkbits, pblk, len);
ret = sb_issue_zeroout(inode->i_sb, pblk, len, GFP_NOFS);
if (ret > 0)
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index c8a2f17a8f11..239c2666ceb5 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -4162,7 +4162,9 @@ static int f2fs_secure_erase(struct block_device *bdev, struct inode *inode,
if (!ret && (flags & F2FS_TRIM_FILE_ZEROOUT)) {
if (IS_ENCRYPTED(inode))
- ret = fscrypt_zeroout_range(inode, off, block, len);
+ ret = fscrypt_zeroout_range(inode,
+ (loff_t)off << inode->i_blkbits, block,
+ len);
else
ret = blkdev_issue_zeroout(bdev, sector, nr_sects,
GFP_NOFS, 0);
diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h
index 90f75fe0e1c9..9fc15e1fbe57 100644
--- a/include/linux/fscrypt.h
+++ b/include/linux/fscrypt.h
@@ -450,7 +450,7 @@ u64 fscrypt_fname_siphash(const struct inode *dir, const struct qstr *name);
/* bio.c */
bool fscrypt_decrypt_bio(struct bio *bio);
-int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
+int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
sector_t pblk, unsigned int len);
/* hooks.c */
@@ -755,7 +755,7 @@ static inline bool fscrypt_decrypt_bio(struct bio *bio)
return true;
}
-static inline int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
+static inline int fscrypt_zeroout_range(const struct inode *inode, loff_t pos,
sector_t pblk, unsigned int len)
{
return -EOPNOTSUPP;
--
2.47.3
^ permalink raw reply related
* [PATCH 10/14] fscrypt: pass a byte length to fscrypt_zeroout_range_inline_crypt
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Range lengths are usually expressed as bytes in the VFS, switch
fscrypt_zeroout_range_inline_crypt to this convention.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/crypto/bio.c | 12 ++++--------
1 file changed, 4 insertions(+), 8 deletions(-)
diff --git a/fs/crypto/bio.c b/fs/crypto/bio.c
index 7558b3e69701..303b5acc66a9 100644
--- a/fs/crypto/bio.c
+++ b/fs/crypto/bio.c
@@ -71,10 +71,8 @@ static void fscrypt_zeroout_range_end_io(struct bio *bio)
static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
loff_t pos, sector_t sector,
- unsigned int len)
+ u64 len)
{
- const unsigned int blockbits = inode->i_blkbits;
- const unsigned int blocks_per_page = 1 << (PAGE_SHIFT - blockbits);
struct fscrypt_zero_done done = {
.pending = ATOMIC_INIT(1),
.done = COMPLETION_INITIALIZER_ONSTACK(done.done),
@@ -92,12 +90,10 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
fscrypt_set_bio_crypt_ctx(bio, inode, pos, GFP_NOFS);
for (n = 0; n < BIO_MAX_VECS; n++) {
- unsigned int blocks_this_page =
- min(len, blocks_per_page);
- unsigned int bytes_this_page = blocks_this_page << blockbits;
+ unsigned int bytes_this_page = min(len, PAGE_SIZE);
__bio_add_page(bio, ZERO_PAGE(0), bytes_this_page, 0);
- len -= blocks_this_page;
+ len -= bytes_this_page;
pos += bytes_this_page;
sector += (bytes_this_page >> SECTOR_SHIFT);
if (!len || !fscrypt_mergeable_bio(bio, inode, pos))
@@ -155,7 +151,7 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
if (fscrypt_inode_uses_inline_crypto(inode))
return fscrypt_zeroout_range_inline_crypt(inode, pos, sector,
- len);
+ (u64)len << inode->i_blkbits);
BUILD_BUG_ON(ARRAY_SIZE(pages) > BIO_MAX_VECS);
nr_pages = min_t(u64, ARRAY_SIZE(pages),
--
2.47.3
^ permalink raw reply related
* [PATCH 09/14] fscrypt: pass a byte offset to fscrypt_zeroout_range_inline_crypt
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Logical offsets into an inode are usually expressed as bytes in the VFS.
Switch fscrypt_zeroout_range_inline_crypt to that convention.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/crypto/bio.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/fs/crypto/bio.c b/fs/crypto/bio.c
index e7fb2fdd9728..7558b3e69701 100644
--- a/fs/crypto/bio.c
+++ b/fs/crypto/bio.c
@@ -70,12 +70,11 @@ static void fscrypt_zeroout_range_end_io(struct bio *bio)
}
static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
- pgoff_t lblk, sector_t sector,
+ loff_t pos, sector_t sector,
unsigned int len)
{
const unsigned int blockbits = inode->i_blkbits;
const unsigned int blocks_per_page = 1 << (PAGE_SHIFT - blockbits);
- loff_t pos = (loff_t)lblk << blockbits;
struct fscrypt_zero_done done = {
.pending = ATOMIC_INIT(1),
.done = COMPLETION_INITIALIZER_ONSTACK(done.done),
@@ -142,6 +141,7 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
const unsigned int du_per_page = 1U << du_per_page_bits;
u64 du_index = (u64)lblk << (inode->i_blkbits - du_bits);
u64 du_remaining = (u64)len << (inode->i_blkbits - du_bits);
+ loff_t pos = (loff_t)lblk << inode->i_blkbits;
sector_t sector = pblk << (inode->i_blkbits - SECTOR_SHIFT);
struct page *pages[16]; /* write up to 16 pages at a time */
unsigned int nr_pages;
@@ -154,7 +154,7 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
return 0;
if (fscrypt_inode_uses_inline_crypto(inode))
- return fscrypt_zeroout_range_inline_crypt(inode, lblk, sector,
+ return fscrypt_zeroout_range_inline_crypt(inode, pos, sector,
len);
BUILD_BUG_ON(ARRAY_SIZE(pages) > BIO_MAX_VECS);
--
2.47.3
^ permalink raw reply related
* [PATCH 08/14] fscrypt: pass a byte offset to fscrypt_set_bio_crypt_ctx
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Logical offsets into an inode are usually expressed as bytes in the VFS.
Switch fscrypt_set_bio_crypt_ctx to that convention.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/buffer.c | 7 ++-----
fs/crypto/bio.c | 8 ++++----
fs/crypto/inline_crypt.c | 6 +++---
fs/ext4/page-io.c | 5 ++---
fs/ext4/readpage.c | 4 ++--
fs/f2fs/data.c | 4 +++-
fs/iomap/direct-io.c | 6 ++----
include/linux/fscrypt.h | 7 +++----
8 files changed, 21 insertions(+), 26 deletions(-)
diff --git a/fs/buffer.c b/fs/buffer.c
index b6504ec7fa4c..1c8ee5a59f88 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2778,8 +2778,6 @@ static void buffer_set_crypto_ctx(struct bio *bio, const struct buffer_head *bh,
gfp_t gfp_mask)
{
const struct address_space *mapping = folio_mapping(bh->b_folio);
- const struct inode *inode;
- u64 lblk;
/*
* The ext4 journal (jbd2) can submit a buffer_head it directly created
@@ -2787,9 +2785,8 @@ static void buffer_set_crypto_ctx(struct bio *bio, const struct buffer_head *bh,
*/
if (!mapping)
return;
- inode = mapping->host;
- lblk = (folio_pos(bh->b_folio) + bh_offset(bh)) >> inode->i_blkbits;
- fscrypt_set_bio_crypt_ctx(bio, inode, lblk, gfp_mask);
+ fscrypt_set_bio_crypt_ctx(bio, mapping->host,
+ folio_pos(bh->b_folio) + bh_offset(bh), gfp_mask);
}
static void submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,
diff --git a/fs/crypto/bio.c b/fs/crypto/bio.c
index 0a701d4a17ef..e7fb2fdd9728 100644
--- a/fs/crypto/bio.c
+++ b/fs/crypto/bio.c
@@ -75,6 +75,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
{
const unsigned int blockbits = inode->i_blkbits;
const unsigned int blocks_per_page = 1 << (PAGE_SHIFT - blockbits);
+ loff_t pos = (loff_t)lblk << blockbits;
struct fscrypt_zero_done done = {
.pending = ATOMIC_INIT(1),
.done = COMPLETION_INITIALIZER_ONSTACK(done.done),
@@ -89,7 +90,7 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
bio->bi_iter.bi_sector = sector;
bio->bi_private = &done;
bio->bi_end_io = fscrypt_zeroout_range_end_io;
- fscrypt_set_bio_crypt_ctx(bio, inode, lblk, GFP_NOFS);
+ fscrypt_set_bio_crypt_ctx(bio, inode, pos, GFP_NOFS);
for (n = 0; n < BIO_MAX_VECS; n++) {
unsigned int blocks_this_page =
@@ -98,10 +99,9 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
__bio_add_page(bio, ZERO_PAGE(0), bytes_this_page, 0);
len -= blocks_this_page;
- lblk += blocks_this_page;
+ pos += bytes_this_page;
sector += (bytes_this_page >> SECTOR_SHIFT);
- if (!len || !fscrypt_mergeable_bio(bio, inode,
- (loff_t)lblk << blockbits))
+ if (!len || !fscrypt_mergeable_bio(bio, inode, pos))
break;
}
diff --git a/fs/crypto/inline_crypt.c b/fs/crypto/inline_crypt.c
index b0954d17904b..37d42d357925 100644
--- a/fs/crypto/inline_crypt.c
+++ b/fs/crypto/inline_crypt.c
@@ -285,7 +285,7 @@ static void fscrypt_generate_dun(const struct fscrypt_inode_info *ci,
* fscrypt_set_bio_crypt_ctx() - prepare a file contents bio for inline crypto
* @bio: a bio which will eventually be submitted to the file
* @inode: the file's inode
- * @first_lblk: the first file logical block number in the I/O
+ * @pos: the first file position (in bytes) in the I/O
* @gfp_mask: memory allocation flags - these must be a waiting mask so that
* bio_crypt_set_ctx can't fail.
*
@@ -298,7 +298,7 @@ static void fscrypt_generate_dun(const struct fscrypt_inode_info *ci,
* The encryption context will be freed automatically when the bio is freed.
*/
void fscrypt_set_bio_crypt_ctx(struct bio *bio, const struct inode *inode,
- u64 first_lblk, gfp_t gfp_mask)
+ loff_t pos, gfp_t gfp_mask)
{
const struct fscrypt_inode_info *ci;
u64 dun[BLK_CRYPTO_DUN_ARRAY_SIZE];
@@ -307,7 +307,7 @@ void fscrypt_set_bio_crypt_ctx(struct bio *bio, const struct inode *inode,
return;
ci = fscrypt_get_inode_info_raw(inode);
- fscrypt_generate_dun(ci, first_lblk << inode->i_blkbits, dun);
+ fscrypt_generate_dun(ci, pos, dun);
bio_crypt_set_ctx(bio, ci->ci_enc_key.blk_key, dun, gfp_mask);
}
EXPORT_SYMBOL_GPL(fscrypt_set_bio_crypt_ctx);
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index 50f507bab82c..181cda58d387 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -427,9 +427,8 @@ static void io_submit_init_bio(struct ext4_io_submit *io,
* __GFP_DIRECT_RECLAIM is set, see comments for bio_alloc_bioset().
*/
bio = bio_alloc(bh->b_bdev, BIO_MAX_VECS, REQ_OP_WRITE, GFP_NOIO);
- fscrypt_set_bio_crypt_ctx(bio, inode,
- (folio_pos(folio) + bh_offset(bh)) >> inode->i_blkbits,
- GFP_NOIO);
+ fscrypt_set_bio_crypt_ctx(bio, inode, folio_pos(folio) + bh_offset(bh),
+ GFP_NOIO);
bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
bio->bi_end_io = ext4_end_bio;
bio->bi_private = ext4_get_io_end(io->io_end);
diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index ba7cfddd6038..fbfa4d830d9a 100644
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -355,8 +355,8 @@ static int ext4_mpage_readpages(struct inode *inode, struct fsverity_info *vi,
*/
bio = bio_alloc(bdev, bio_max_segs(nr_pages),
REQ_OP_READ, GFP_KERNEL);
- fscrypt_set_bio_crypt_ctx(bio, inode, next_block,
- GFP_KERNEL);
+ fscrypt_set_bio_crypt_ctx(bio, inode,
+ (loff_t)next_block << blkbits, GFP_KERNEL);
ext4_set_bio_post_read_ctx(bio, inode, vi);
bio->bi_iter.bi_sector = first_block << (blkbits - 9);
bio->bi_end_io = mpage_end_io;
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index dca273fedfde..07b4ed6bb0cc 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -527,7 +527,9 @@ static void f2fs_set_bio_crypt_ctx(struct bio *bio, const struct inode *inode,
* read/write raw data without encryption.
*/
if (!fio || !fio->encrypted_page)
- fscrypt_set_bio_crypt_ctx(bio, inode, first_idx, gfp_mask);
+ fscrypt_set_bio_crypt_ctx(bio, inode,
+ (loff_t)first_idx << inode->i_blkbits,
+ gfp_mask);
}
static bool f2fs_crypt_mergeable_bio(struct bio *bio, const struct inode *inode,
diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
index 95254aa1b654..b4ee4465f4db 100644
--- a/fs/iomap/direct-io.c
+++ b/fs/iomap/direct-io.c
@@ -298,8 +298,7 @@ static int iomap_dio_zero(const struct iomap_iter *iter, struct iomap_dio *dio,
bio = iomap_dio_alloc_bio(iter, dio, nr_vecs,
REQ_OP_WRITE | REQ_SYNC | REQ_IDLE);
- fscrypt_set_bio_crypt_ctx(bio, inode, pos >> inode->i_blkbits,
- GFP_KERNEL);
+ fscrypt_set_bio_crypt_ctx(bio, inode, pos, GFP_KERNEL);
bio->bi_iter.bi_sector = iomap_sector(&iter->iomap, pos);
bio->bi_private = dio;
bio->bi_end_io = iomap_dio_bio_end_io;
@@ -329,8 +328,7 @@ static ssize_t iomap_dio_bio_iter_one(struct iomap_iter *iter,
nr_vecs = bio_iov_vecs_to_alloc(dio->submit.iter, BIO_MAX_VECS);
bio = iomap_dio_alloc_bio(iter, dio, nr_vecs, op);
- fscrypt_set_bio_crypt_ctx(bio, iter->inode,
- pos >> iter->inode->i_blkbits, GFP_KERNEL);
+ fscrypt_set_bio_crypt_ctx(bio, iter->inode, pos, GFP_KERNEL);
bio->bi_iter.bi_sector = iomap_sector(&iter->iomap, pos);
bio->bi_write_hint = iter->inode->i_write_hint;
bio->bi_ioprio = dio->iocb->ki_ioprio;
diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h
index 98fb14660d40..90f75fe0e1c9 100644
--- a/include/linux/fscrypt.h
+++ b/include/linux/fscrypt.h
@@ -865,9 +865,8 @@ static inline void fscrypt_set_ops(struct super_block *sb,
bool __fscrypt_inode_uses_inline_crypto(const struct inode *inode);
-void fscrypt_set_bio_crypt_ctx(struct bio *bio,
- const struct inode *inode, u64 first_lblk,
- gfp_t gfp_mask);
+void fscrypt_set_bio_crypt_ctx(struct bio *bio, const struct inode *inode,
+ loff_t pos, gfp_t gfp_mask);
bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
loff_t pos);
@@ -885,7 +884,7 @@ static inline bool __fscrypt_inode_uses_inline_crypto(const struct inode *inode)
static inline void fscrypt_set_bio_crypt_ctx(struct bio *bio,
const struct inode *inode,
- u64 first_lblk, gfp_t gfp_mask) { }
+ loff_t pos, gfp_t gfp_mask) { }
static inline bool fscrypt_mergeable_bio(struct bio *bio,
const struct inode *inode,
--
2.47.3
^ permalink raw reply related
* [PATCH 07/14] fscrypt: pass a byte offset to fscrypt_mergeable_bio
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Logical offsets into an inode are usually expressed as bytes in the VFS.
Switch fscrypt_mergeable_bio to that convention.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/crypto/bio.c | 3 ++-
fs/crypto/inline_crypt.c | 6 +++---
fs/ext4/page-io.c | 2 +-
fs/ext4/readpage.c | 3 ++-
fs/f2fs/data.c | 3 ++-
include/linux/fscrypt.h | 4 ++--
6 files changed, 12 insertions(+), 9 deletions(-)
diff --git a/fs/crypto/bio.c b/fs/crypto/bio.c
index 6da683ea69dc..0a701d4a17ef 100644
--- a/fs/crypto/bio.c
+++ b/fs/crypto/bio.c
@@ -100,7 +100,8 @@ static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
len -= blocks_this_page;
lblk += blocks_this_page;
sector += (bytes_this_page >> SECTOR_SHIFT);
- if (!len || !fscrypt_mergeable_bio(bio, inode, lblk))
+ if (!len || !fscrypt_mergeable_bio(bio, inode,
+ (loff_t)lblk << blockbits))
break;
}
diff --git a/fs/crypto/inline_crypt.c b/fs/crypto/inline_crypt.c
index 5279565e9846..b0954d17904b 100644
--- a/fs/crypto/inline_crypt.c
+++ b/fs/crypto/inline_crypt.c
@@ -316,7 +316,7 @@ EXPORT_SYMBOL_GPL(fscrypt_set_bio_crypt_ctx);
* fscrypt_mergeable_bio() - test whether data can be added to a bio
* @bio: the bio being built up
* @inode: the inode for the next part of the I/O
- * @next_lblk: the next file logical block number in the I/O
+ * @pos: the next file position (in bytes) in the I/O
*
* When building a bio which may contain data which should undergo inline
* encryption (or decryption) via fscrypt, filesystems should call this function
@@ -334,7 +334,7 @@ EXPORT_SYMBOL_GPL(fscrypt_set_bio_crypt_ctx);
* Return: true iff the I/O is mergeable
*/
bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
- u64 next_lblk)
+ loff_t pos)
{
const struct bio_crypt_ctx *bc = bio->bi_crypt_context;
const struct fscrypt_inode_info *ci;
@@ -354,7 +354,7 @@ bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
if (bc->bc_key != ci->ci_enc_key.blk_key)
return false;
- fscrypt_generate_dun(ci, next_lblk << inode->i_blkbits, next_dun);
+ fscrypt_generate_dun(ci, pos, next_dun);
return bio_crypt_dun_is_contiguous(bc, bio->bi_iter.bi_size, next_dun);
}
EXPORT_SYMBOL_GPL(fscrypt_mergeable_bio);
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index 293314d7f236..50f507bab82c 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -447,7 +447,7 @@ static bool io_submit_need_new_bio(struct ext4_io_submit *io,
if (bh->b_blocknr != io->io_next_block)
return true;
if (!fscrypt_mergeable_bio(io->io_bio, inode,
- (folio_pos(folio) + bh_offset(bh)) >> inode->i_blkbits))
+ folio_pos(folio) + bh_offset(bh)))
return true;
return false;
}
diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index 830f3b8a321f..ba7cfddd6038 100644
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -342,7 +342,8 @@ static int ext4_mpage_readpages(struct inode *inode, struct fsverity_info *vi,
* BIO off first?
*/
if (bio && (last_block_in_bio != first_block - 1 ||
- !fscrypt_mergeable_bio(bio, inode, next_block))) {
+ !fscrypt_mergeable_bio(bio, inode,
+ (loff_t)next_block << blkbits))) {
submit_and_realloc:
blk_crypto_submit_bio(bio);
bio = NULL;
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 338df7a2aea6..dca273fedfde 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -541,7 +541,8 @@ static bool f2fs_crypt_mergeable_bio(struct bio *bio, const struct inode *inode,
if (fio && fio->encrypted_page)
return !bio_has_crypt_ctx(bio);
- return fscrypt_mergeable_bio(bio, inode, next_idx);
+ return fscrypt_mergeable_bio(bio, inode,
+ (loff_t)next_idx << inode->i_blkbits);
}
void f2fs_submit_read_bio(struct f2fs_sb_info *sbi, struct bio *bio,
diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h
index 26561b7994e0..98fb14660d40 100644
--- a/include/linux/fscrypt.h
+++ b/include/linux/fscrypt.h
@@ -870,7 +870,7 @@ void fscrypt_set_bio_crypt_ctx(struct bio *bio,
gfp_t gfp_mask);
bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
- u64 next_lblk);
+ loff_t pos);
bool fscrypt_dio_supported(struct inode *inode);
@@ -889,7 +889,7 @@ static inline void fscrypt_set_bio_crypt_ctx(struct bio *bio,
static inline bool fscrypt_mergeable_bio(struct bio *bio,
const struct inode *inode,
- u64 next_lblk)
+ loff_t pos)
{
return true;
}
--
2.47.3
^ permalink raw reply related
* [PATCH 06/14] fscrypt: pass a byte offset to fscrypt_generate_dun
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Logical offsets into an inode are usually expressed as bytes in the VFS.
Switch fscrypt_generate_dun to that convention and remove the
ci_data_units_per_block_bits member in struct fscrypt_inode_info that
was only used to cache the DUN shift based on the logical block size
granularity.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/crypto/fscrypt_private.h | 3 ---
fs/crypto/inline_crypt.c | 10 ++++------
fs/crypto/keysetup.c | 2 --
3 files changed, 4 insertions(+), 11 deletions(-)
diff --git a/fs/crypto/fscrypt_private.h b/fs/crypto/fscrypt_private.h
index 4e8e82a9ccf9..8d3c278a7591 100644
--- a/fs/crypto/fscrypt_private.h
+++ b/fs/crypto/fscrypt_private.h
@@ -278,9 +278,6 @@ struct fscrypt_inode_info {
*/
u8 ci_data_unit_bits;
- /* Cached value: log2 of number of data units per FS block */
- u8 ci_data_units_per_block_bits;
-
/* Hashed inode number. Only set for IV_INO_LBLK_32 */
u32 ci_hashed_ino;
diff --git a/fs/crypto/inline_crypt.c b/fs/crypto/inline_crypt.c
index 702d13d138aa..5279565e9846 100644
--- a/fs/crypto/inline_crypt.c
+++ b/fs/crypto/inline_crypt.c
@@ -268,14 +268,12 @@ bool __fscrypt_inode_uses_inline_crypto(const struct inode *inode)
EXPORT_SYMBOL_GPL(__fscrypt_inode_uses_inline_crypto);
static void fscrypt_generate_dun(const struct fscrypt_inode_info *ci,
- u64 lblk_num,
- u64 dun[BLK_CRYPTO_DUN_ARRAY_SIZE])
+ loff_t pos, u64 dun[BLK_CRYPTO_DUN_ARRAY_SIZE])
{
- u64 index = lblk_num << ci->ci_data_units_per_block_bits;
union fscrypt_iv iv;
int i;
- fscrypt_generate_iv(&iv, index, ci);
+ fscrypt_generate_iv(&iv, pos >> ci->ci_data_unit_bits, ci);
BUILD_BUG_ON(FSCRYPT_MAX_IV_SIZE > BLK_CRYPTO_MAX_IV_SIZE);
memset(dun, 0, BLK_CRYPTO_MAX_IV_SIZE);
@@ -309,7 +307,7 @@ void fscrypt_set_bio_crypt_ctx(struct bio *bio, const struct inode *inode,
return;
ci = fscrypt_get_inode_info_raw(inode);
- fscrypt_generate_dun(ci, first_lblk, dun);
+ fscrypt_generate_dun(ci, first_lblk << inode->i_blkbits, dun);
bio_crypt_set_ctx(bio, ci->ci_enc_key.blk_key, dun, gfp_mask);
}
EXPORT_SYMBOL_GPL(fscrypt_set_bio_crypt_ctx);
@@ -356,7 +354,7 @@ bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
if (bc->bc_key != ci->ci_enc_key.blk_key)
return false;
- fscrypt_generate_dun(ci, next_lblk, next_dun);
+ fscrypt_generate_dun(ci, next_lblk << inode->i_blkbits, next_dun);
return bio_crypt_dun_is_contiguous(bc, bio->bi_iter.bi_size, next_dun);
}
EXPORT_SYMBOL_GPL(fscrypt_mergeable_bio);
diff --git a/fs/crypto/keysetup.c b/fs/crypto/keysetup.c
index 40fa05688d3a..d83257e9945e 100644
--- a/fs/crypto/keysetup.c
+++ b/fs/crypto/keysetup.c
@@ -609,8 +609,6 @@ fscrypt_setup_encryption_info(struct inode *inode,
crypt_info->ci_data_unit_bits =
fscrypt_policy_du_bits(&crypt_info->ci_policy, inode);
- crypt_info->ci_data_units_per_block_bits =
- inode->i_blkbits - crypt_info->ci_data_unit_bits;
res = setup_file_encryption_key(crypt_info, need_dirhash_key, &mk);
if (res)
--
2.47.3
^ permalink raw reply related
* [PATCH 05/14] fscrypt: move fscrypt_set_bio_crypt_ctx_bh to buffer.c
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
fscrypt_set_bio_crypt_ctx_bh is only used by submit_bh_wbc now. Move it
there and merge bh_get_inode_and_lblk_num into it.
Note that this does not add ifdefs for fscrypt as the compiler will
optimize away the dead code if it is not built in.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/buffer.c | 21 ++++++++++++++++++-
fs/crypto/inline_crypt.c | 45 ----------------------------------------
include/linux/fscrypt.h | 9 --------
3 files changed, 20 insertions(+), 55 deletions(-)
diff --git a/fs/buffer.c b/fs/buffer.c
index 22b43642ba57..b6504ec7fa4c 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2774,6 +2774,24 @@ static void end_bio_bh_io_sync(struct bio *bio)
bio_put(bio);
}
+static void buffer_set_crypto_ctx(struct bio *bio, const struct buffer_head *bh,
+ gfp_t gfp_mask)
+{
+ const struct address_space *mapping = folio_mapping(bh->b_folio);
+ const struct inode *inode;
+ u64 lblk;
+
+ /*
+ * The ext4 journal (jbd2) can submit a buffer_head it directly created
+ * for a non-pagecache page. fscrypt doesn't care about these.
+ */
+ if (!mapping)
+ return;
+ inode = mapping->host;
+ lblk = (folio_pos(bh->b_folio) + bh_offset(bh)) >> inode->i_blkbits;
+ fscrypt_set_bio_crypt_ctx(bio, inode, lblk, gfp_mask);
+}
+
static void submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,
enum rw_hint write_hint,
struct writeback_control *wbc)
@@ -2800,7 +2818,8 @@ static void submit_bh_wbc(blk_opf_t opf, struct buffer_head *bh,
bio = bio_alloc(bh->b_bdev, 1, opf, GFP_NOIO);
- fscrypt_set_bio_crypt_ctx_bh(bio, bh, GFP_NOIO);
+ if (IS_ENABLED(CONFIG_FS_ENCRYPTION))
+ buffer_set_crypto_ctx(bio, bh, GFP_NOIO);
bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
bio->bi_write_hint = write_hint;
diff --git a/fs/crypto/inline_crypt.c b/fs/crypto/inline_crypt.c
index 0da53956a9b1..702d13d138aa 100644
--- a/fs/crypto/inline_crypt.c
+++ b/fs/crypto/inline_crypt.c
@@ -314,51 +314,6 @@ void fscrypt_set_bio_crypt_ctx(struct bio *bio, const struct inode *inode,
}
EXPORT_SYMBOL_GPL(fscrypt_set_bio_crypt_ctx);
-/* Extract the inode and logical block number from a buffer_head. */
-static bool bh_get_inode_and_lblk_num(const struct buffer_head *bh,
- const struct inode **inode_ret,
- u64 *lblk_num_ret)
-{
- struct folio *folio = bh->b_folio;
- const struct address_space *mapping;
- const struct inode *inode;
-
- /*
- * The ext4 journal (jbd2) can submit a buffer_head it directly created
- * for a non-pagecache page. fscrypt doesn't care about these.
- */
- mapping = folio_mapping(folio);
- if (!mapping)
- return false;
- inode = mapping->host;
-
- *inode_ret = inode;
- *lblk_num_ret = (folio_pos(folio) + bh_offset(bh)) >> inode->i_blkbits;
- return true;
-}
-
-/**
- * fscrypt_set_bio_crypt_ctx_bh() - prepare a file contents bio for inline
- * crypto
- * @bio: a bio which will eventually be submitted to the file
- * @first_bh: the first buffer_head for which I/O will be submitted
- * @gfp_mask: memory allocation flags
- *
- * Same as fscrypt_set_bio_crypt_ctx(), except this takes a buffer_head instead
- * of an inode and block number directly.
- */
-void fscrypt_set_bio_crypt_ctx_bh(struct bio *bio,
- const struct buffer_head *first_bh,
- gfp_t gfp_mask)
-{
- const struct inode *inode;
- u64 first_lblk;
-
- if (bh_get_inode_and_lblk_num(first_bh, &inode, &first_lblk))
- fscrypt_set_bio_crypt_ctx(bio, inode, first_lblk, gfp_mask);
-}
-EXPORT_SYMBOL_GPL(fscrypt_set_bio_crypt_ctx_bh);
-
/**
* fscrypt_mergeable_bio() - test whether data can be added to a bio
* @bio: the bio being built up
diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h
index 6af3c1907adc..26561b7994e0 100644
--- a/include/linux/fscrypt.h
+++ b/include/linux/fscrypt.h
@@ -869,10 +869,6 @@ void fscrypt_set_bio_crypt_ctx(struct bio *bio,
const struct inode *inode, u64 first_lblk,
gfp_t gfp_mask);
-void fscrypt_set_bio_crypt_ctx_bh(struct bio *bio,
- const struct buffer_head *first_bh,
- gfp_t gfp_mask);
-
bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
u64 next_lblk);
@@ -891,11 +887,6 @@ static inline void fscrypt_set_bio_crypt_ctx(struct bio *bio,
const struct inode *inode,
u64 first_lblk, gfp_t gfp_mask) { }
-static inline void fscrypt_set_bio_crypt_ctx_bh(
- struct bio *bio,
- const struct buffer_head *first_bh,
- gfp_t gfp_mask) { }
-
static inline bool fscrypt_mergeable_bio(struct bio *bio,
const struct inode *inode,
u64 next_lblk)
--
2.47.3
^ permalink raw reply related
* [PATCH 04/14] ext4, fscrypt: merge fscrypt_mergeable_bio_bh into io_submit_need_new_bio
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
ext4 already has the inode and folio and can't have a NULL
folio->mapping in this path. Open code fscrypt_mergeable_bio_bh in
io_submit_need_new_bio based on these simplifying assumptions.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/crypto/inline_crypt.c | 23 -----------------------
fs/ext4/page-io.c | 7 +++++--
include/linux/fscrypt.h | 9 ---------
3 files changed, 5 insertions(+), 34 deletions(-)
diff --git a/fs/crypto/inline_crypt.c b/fs/crypto/inline_crypt.c
index c0852b920dbc..0da53956a9b1 100644
--- a/fs/crypto/inline_crypt.c
+++ b/fs/crypto/inline_crypt.c
@@ -406,29 +406,6 @@ bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
}
EXPORT_SYMBOL_GPL(fscrypt_mergeable_bio);
-/**
- * fscrypt_mergeable_bio_bh() - test whether data can be added to a bio
- * @bio: the bio being built up
- * @next_bh: the next buffer_head for which I/O will be submitted
- *
- * Same as fscrypt_mergeable_bio(), except this takes a buffer_head instead of
- * an inode and block number directly.
- *
- * Return: true iff the I/O is mergeable
- */
-bool fscrypt_mergeable_bio_bh(struct bio *bio,
- const struct buffer_head *next_bh)
-{
- const struct inode *inode;
- u64 next_lblk;
-
- if (!bh_get_inode_and_lblk_num(next_bh, &inode, &next_lblk))
- return !bio->bi_crypt_context;
-
- return fscrypt_mergeable_bio(bio, inode, next_lblk);
-}
-EXPORT_SYMBOL_GPL(fscrypt_mergeable_bio_bh);
-
/**
* fscrypt_dio_supported() - check whether DIO (direct I/O) is supported on an
* inode, as far as encryption is concerned
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index 58cdbd836fd6..293314d7f236 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -440,11 +440,14 @@ static void io_submit_init_bio(struct ext4_io_submit *io,
}
static bool io_submit_need_new_bio(struct ext4_io_submit *io,
+ struct inode *inode,
+ struct folio *folio,
struct buffer_head *bh)
{
if (bh->b_blocknr != io->io_next_block)
return true;
- if (!fscrypt_mergeable_bio_bh(io->io_bio, bh))
+ if (!fscrypt_mergeable_bio(io->io_bio, inode,
+ (folio_pos(folio) + bh_offset(bh)) >> inode->i_blkbits))
return true;
return false;
}
@@ -455,7 +458,7 @@ static void io_submit_add_bh(struct ext4_io_submit *io,
struct folio *io_folio,
struct buffer_head *bh)
{
- if (io->io_bio && io_submit_need_new_bio(io, bh)) {
+ if (io->io_bio && io_submit_need_new_bio(io, inode, folio, bh)) {
submit_and_retry:
ext4_io_submit(io);
}
diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h
index 516aba5b858b..6af3c1907adc 100644
--- a/include/linux/fscrypt.h
+++ b/include/linux/fscrypt.h
@@ -876,9 +876,6 @@ void fscrypt_set_bio_crypt_ctx_bh(struct bio *bio,
bool fscrypt_mergeable_bio(struct bio *bio, const struct inode *inode,
u64 next_lblk);
-bool fscrypt_mergeable_bio_bh(struct bio *bio,
- const struct buffer_head *next_bh);
-
bool fscrypt_dio_supported(struct inode *inode);
u64 fscrypt_limit_io_blocks(const struct inode *inode, u64 lblk, u64 nr_blocks);
@@ -906,12 +903,6 @@ static inline bool fscrypt_mergeable_bio(struct bio *bio,
return true;
}
-static inline bool fscrypt_mergeable_bio_bh(struct bio *bio,
- const struct buffer_head *next_bh)
-{
- return true;
-}
-
static inline bool fscrypt_dio_supported(struct inode *inode)
{
return !fscrypt_needs_contents_encryption(inode);
--
2.47.3
^ permalink raw reply related
* [PATCH 03/14] ext4: factor out a io_submit_need_new_bio helper
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Factor out a helper to prepare for making this logic a bit more
complex in the next commit.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/ext4/page-io.c | 13 +++++++++++--
1 file changed, 11 insertions(+), 2 deletions(-)
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index c5ca99b33c26..58cdbd836fd6 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -439,14 +439,23 @@ static void io_submit_init_bio(struct ext4_io_submit *io,
wbc_init_bio(io->io_wbc, bio);
}
+static bool io_submit_need_new_bio(struct ext4_io_submit *io,
+ struct buffer_head *bh)
+{
+ if (bh->b_blocknr != io->io_next_block)
+ return true;
+ if (!fscrypt_mergeable_bio_bh(io->io_bio, bh))
+ return true;
+ return false;
+}
+
static void io_submit_add_bh(struct ext4_io_submit *io,
struct inode *inode,
struct folio *folio,
struct folio *io_folio,
struct buffer_head *bh)
{
- if (io->io_bio && (bh->b_blocknr != io->io_next_block ||
- !fscrypt_mergeable_bio_bh(io->io_bio, bh))) {
+ if (io->io_bio && io_submit_need_new_bio(io, bh)) {
submit_and_retry:
ext4_io_submit(io);
}
--
2.47.3
^ permalink raw reply related
* fscrypt API cleanups v3
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
Hi all,
this series cleans up various fscrypt APIs to pass logical offsets in
and lengths in bytes, and on-disk sectors as 512-byte sector units,
like most of the VFS and block code.
Changes since v2:
- use the local bio variable in io_submit_init_bio
- use folio instead of io_folio (and actually test the noinline mode,
which should have cought this for the last round)
- add an extra IS_ENABLED(CONFIG_FS_ENCRYPTION) to safeguard
against potentially stupid compilers
- document the byte length needs to be a multiple of the block
size
- case to u64 when passing the byte length
- move a hunk to an earlier patch
Changes since v1:
- remove all buffer_head helpers, and do that before the API cleanups
to simplify the series
- fix a bisection hazard
- spelling fixes in the commit logs
- use "file position" to describe the byte offset into an inode
- add another small ext4 cleanup at the end
Diffstat:
fs/buffer.c | 18 ++++++++-
fs/crypto/bio.c | 40 +++++++++-----------
fs/crypto/fscrypt_private.h | 3 -
fs/crypto/inline_crypt.c | 86 ++++----------------------------------------
fs/crypto/keysetup.c | 2 -
fs/ext4/inode.c | 5 ++
fs/ext4/page-io.c | 28 ++++++++++----
fs/ext4/readpage.c | 10 ++---
fs/f2fs/data.c | 7 ++-
fs/f2fs/file.c | 4 +-
fs/iomap/direct-io.c | 6 +--
include/linux/fscrypt.h | 37 ++++--------------
12 files changed, 92 insertions(+), 154 deletions(-)
^ permalink raw reply
* [PATCH 02/14] ext4: open code fscrypt_set_bio_crypt_ctx_bh
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
io_submit_init_bio already has or can easily get at most information
needed to set the crypto context. Open code fscrypt_set_bio_crypt_ctx_bh
based on that.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/ext4/page-io.c | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index b8cf9f6f9e0b..c5ca99b33c26 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -417,6 +417,7 @@ void ext4_io_submit_init(struct ext4_io_submit *io,
static void io_submit_init_bio(struct ext4_io_submit *io,
struct inode *inode,
+ struct folio *folio,
struct buffer_head *bh)
{
struct bio *bio;
@@ -426,7 +427,9 @@ static void io_submit_init_bio(struct ext4_io_submit *io,
* __GFP_DIRECT_RECLAIM is set, see comments for bio_alloc_bioset().
*/
bio = bio_alloc(bh->b_bdev, BIO_MAX_VECS, REQ_OP_WRITE, GFP_NOIO);
- fscrypt_set_bio_crypt_ctx_bh(bio, bh, GFP_NOIO);
+ fscrypt_set_bio_crypt_ctx(bio, inode,
+ (folio_pos(folio) + bh_offset(bh)) >> inode->i_blkbits,
+ GFP_NOIO);
bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
bio->bi_end_io = ext4_end_bio;
bio->bi_private = ext4_get_io_end(io->io_end);
@@ -448,7 +451,7 @@ static void io_submit_add_bh(struct ext4_io_submit *io,
ext4_io_submit(io);
}
if (io->io_bio == NULL)
- io_submit_init_bio(io, inode, bh);
+ io_submit_init_bio(io, inode, folio, bh);
if (!bio_add_folio(io->io_bio, io_folio, bh->b_size, bh_offset(bh)))
goto submit_and_retry;
wbc_account_cgroup_owner(io->io_wbc, folio, bh->b_size);
--
2.47.3
^ permalink raw reply related
* [PATCH 01/14] ext4: initialize the write hint in io_submit_init_bio
From: Christoph Hellwig @ 2026-03-02 14:18 UTC (permalink / raw)
To: Eric Biggers
Cc: Theodore Y. Ts'o, Jaegeuk Kim, Andreas Dilger, Chao Yu,
Christian Brauner, Darrick J. Wong, linux-fscrypt, linux-ext4,
linux-f2fs-devel, linux-fsdevel
In-Reply-To: <20260302141922.370070-1-hch@lst.de>
Make io_submit_init_bio complete by also initializing the write hint.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/ext4/page-io.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index a8c95eee91b7..b8cf9f6f9e0b 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -416,6 +416,7 @@ void ext4_io_submit_init(struct ext4_io_submit *io,
}
static void io_submit_init_bio(struct ext4_io_submit *io,
+ struct inode *inode,
struct buffer_head *bh)
{
struct bio *bio;
@@ -429,6 +430,7 @@ static void io_submit_init_bio(struct ext4_io_submit *io,
bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
bio->bi_end_io = ext4_end_bio;
bio->bi_private = ext4_get_io_end(io->io_end);
+ bio->bi_write_hint = inode->i_write_hint;
io->io_bio = bio;
io->io_next_block = bh->b_blocknr;
wbc_init_bio(io->io_wbc, bio);
@@ -445,10 +447,8 @@ static void io_submit_add_bh(struct ext4_io_submit *io,
submit_and_retry:
ext4_io_submit(io);
}
- if (io->io_bio == NULL) {
- io_submit_init_bio(io, bh);
- io->io_bio->bi_write_hint = inode->i_write_hint;
- }
+ if (io->io_bio == NULL)
+ io_submit_init_bio(io, inode, bh);
if (!bio_add_folio(io->io_bio, io_folio, bh->b_size, bh_offset(bh)))
goto submit_and_retry;
wbc_account_cgroup_owner(io->io_wbc, folio, bh->b_size);
--
2.47.3
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox