* Re: [PATCH] ext4: reserve inode write access before unlinking entry [not found] <tencent_D60E766CE07D3A1847B81DE9BC37B4466908@qq.com> @ 2026-11-16 7:35 ` Alan 2026-11-16 12:48 ` Jan Kara 0 siblings, 1 reply; 5+ messages in thread From: Alan @ 2026-11-16 7:35 UTC (permalink / raw) To: tytso Cc: adilger.kernel, libaokun, jack, ojaswin, ritesh.list, yi.zhang, harshadshirwadkar, linux-ext4, linux-kernel, stable Hi Ted, Jan and ext4 reviewers, A gentle ping on this patch from October 27. Are there any comments on the approach? I have additional validation from November 2 using QEMU blkdebug to fail an actual guest block READ. These results supplement the source-derived fault injection described in the original mail. On the unpatched Linux 6.12.1 test kernel, with errors=continue, the failed read was at sector 2312, in the parent inode-table block (block 289, parent inode 13). The kernel reported: I/O error, dev vda, sector 2312 op 0x0:(READ) ext4_get_inode_loc:4554: inode #13: block 289: unable to read itable block __ext4_unlink:3469: inode #13: mark_inode_dirty error unlink returned EIO. After normal unmount, /p/file was absent, but raw inode 2064 still had Links: 1. e2fsck -fn reported: Unattached inode 2064 In this case the inode-table read fails in ext4_get_inode_loc(), before the journal write-access call. A separate run of the same block-read failure traced JBD2 through unlink, sync and normal unmount: jbd2_journal_abort() probe hits: 0 unlink handle at jbd2_journal_stop(): TID 7, T_RUNNING h_err=0, h_aborted=0, j_errno=0, journal JBD2_ABORT flag clear jbd2_journal_stop() return value: 0 jbd2_start_commit: transaction 7 jbd2_end_commit: transaction 7 The offline filesystem check still reported the unattached inode. This demonstrates that this read-error path can commit the directory change without a journal abort when mounted with errors=continue. With the fix, the same clean input and block-read error failed before the directory entry was removed. After normal unmount, /p/file remained present, inode 2064 still had Links: 1, and e2fsck -fn completed without diagnostics. Thanks, Alan ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] ext4: reserve inode write access before unlinking entry 2026-11-16 7:35 ` [PATCH] ext4: reserve inode write access before unlinking entry Alan @ 2026-11-16 12:48 ` Jan Kara 2026-11-17 3:39 ` [PATCH v2] " Alan 0 siblings, 1 reply; 5+ messages in thread From: Jan Kara @ 2026-11-16 12:48 UTC (permalink / raw) To: Alan Cc: tytso, adilger.kernel, libaokun, jack, ojaswin, ritesh.list, yi.zhang, harshadshirwadkar, linux-ext4, linux-kernel, stable Hi! On Mon 16-11-26 15:35:19, Alan wrote: > Hi Ted, Jan and ext4 reviewers, > > A gentle ping on this patch from October 27. Are there any comments on the > approach? So for me it is unclear whether this needs addressing at all. Because realistically the only reason why getting write access to inode bh can fail is due to aborted journal in which case no transaction will get committed anyway. So this looks mostly like a problem specific to this error injection testing... Honza > > I have additional validation from November 2 using QEMU blkdebug to fail an > actual guest block READ. These results supplement the source-derived fault > injection described in the original mail. > > On the unpatched Linux 6.12.1 test kernel, with errors=continue, the failed > read was at sector 2312, in the parent inode-table block (block 289, parent > inode 13). The kernel reported: > > I/O error, dev vda, sector 2312 op 0x0:(READ) > ext4_get_inode_loc:4554: inode #13: block 289: unable to read itable block > __ext4_unlink:3469: inode #13: mark_inode_dirty error > > unlink returned EIO. After normal unmount, /p/file was absent, but raw > inode 2064 still had Links: 1. e2fsck -fn reported: > > Unattached inode 2064 > > In this case the inode-table read fails in ext4_get_inode_loc(), before the > journal write-access call. A separate run of the same block-read failure > traced JBD2 through unlink, sync and normal unmount: > > jbd2_journal_abort() probe hits: 0 > unlink handle at jbd2_journal_stop(): TID 7, T_RUNNING > h_err=0, h_aborted=0, j_errno=0, journal JBD2_ABORT flag clear > jbd2_journal_stop() return value: 0 > jbd2_start_commit: transaction 7 > jbd2_end_commit: transaction 7 > > The offline filesystem check still reported the unattached inode. This > demonstrates that this read-error path can commit the directory change > without a journal abort when mounted with errors=continue. > > With the fix, the same clean input and block-read error failed before the > directory entry was removed. After normal unmount, /p/file remained present, > inode 2064 still had Links: 1, and e2fsck -fn completed without diagnostics. > > Thanks, > Alan > -- Jan Kara <jack@suse.com> SUSE Labs, CR ^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v2] ext4: reserve inode write access before unlinking entry 2026-11-16 12:48 ` Jan Kara @ 2026-11-17 3:39 ` Alan 2026-11-18 12:02 ` Jan Kara 0 siblings, 1 reply; 5+ messages in thread From: Alan @ 2026-11-17 3:39 UTC (permalink / raw) To: tytso Cc: adilger.kernel, libaokun, jack, ojaswin, ritesh.list, yi.zhang, harshadshirwadkar, linux-ext4, linux-kernel, stable __ext4_unlink() removes the directory entry before decrementing the target inode's link count. It then dirties the parent inode. If the parent inode-table block cannot be read, parent inode dirtying fails after the entry has been removed, and unlink returns without dropping the target inode's link count. With errors=continue, this read error need not abort the journal transaction, so the directory update can be committed without the corresponding link-count update. Reserve the inode locations and journal write access for the parent and target inodes before removing the directory entry. This makes inode-table read and access errors fail before the namespace is changed. Keep the existing namespace and link-count update order, and release the inode location references on every exit path. Fast-commit replay can skip the parent update when the directory entry does not match the target inode, so reserve only the target inode in that case. The original source-derived injection at the journal write-access boundary is not evidence for a committed inconsistency: an error after the journal has already aborted cannot establish a committed transaction. The relevant failure is an actual inode-table READ EIO before journal write access. Tested on Linux 7.4-rc3 (torvalds/linux commit aebb7274476403040d582c61478df8f4a7bf9cd3) with QEMU blkdebug and errors=continue. On the unpatched kernel, the READ EIO leaves the directory entry removed with Links: 1 after normal unmount; the JBD2 trace shows no journal abort and records the transaction commit, and e2fsck -fn reports an unattached inode. With this patch, the same error is returned before the directory entry is removed; the file remains present with Links: 1 and e2fsck -fn passes. No-fault controls pass on both kernels. Also built fs/ext4/namei.o with W=1. Fixes: 4209ae12b122 ("ext4: handle ext4_mark_inode_dirty errors") Link: https://lore.kernel.org/linux-ext4/tencent_D60E766CE07D3A1847B81DE9BC37B4466908@qq.com/ Cc: stable@vger.kernel.org Signed-off-by: Alan <3164729207@qq.com> --- fs/ext4/namei.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) v2: - Clarify that the committed inconsistency is reproduced by an inode-table READ EIO before journal write access, not by an already-aborted journal. - Revalidate the unmodified and fixed paths on current Linux 7.4-rc3 mainline. diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c index 354fc2d22df1aa..4c16aa9ad78176 100644 --- a/fs/ext4/namei.c +++ b/fs/ext4/namei.c @@ -3233,6 +3233,7 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name, int retval = -ENOENT; struct buffer_head *bh; struct ext4_dir_entry_2 *de = NULL; + struct ext4_iloc dir_iloc, inode_iloc; handle_t *handle; int skip_remove_dentry = 0; @@ -3269,6 +3270,22 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name, if (IS_DIRSYNC(dir)) ext4_handle_sync(handle); + /* + * Read the inode-table blocks and get journal write access before + * removing the directory entry. Otherwise, a read error while updating + * either inode can leave the name removed but the link count unchanged. + */ + dir_iloc.bh = NULL; + inode_iloc.bh = NULL; + if (!skip_remove_dentry) { + retval = ext4_reserve_inode_write(handle, dir, &dir_iloc); + if (retval) + goto out_handle; + } + retval = ext4_reserve_inode_write(handle, inode, &inode_iloc); + if (retval) + goto out_handle; + if (!skip_remove_dentry) { retval = ext4_delete_entry(handle, dir, de, bh); if (retval) @@ -3293,6 +3310,10 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name, if (dentry && !retval) ext4_fc_track_unlink(handle, dentry); out_handle: + if (dir_iloc.bh) + brelse(dir_iloc.bh); + if (inode_iloc.bh) + brelse(inode_iloc.bh); ext4_journal_stop(handle); out_bh: brelse(bh); base-commit: d135ab453a7400a34930bdda1ef4bdc8acfac80e -- 2.53.0 ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH v2] ext4: reserve inode write access before unlinking entry 2026-11-17 3:39 ` [PATCH v2] " Alan @ 2026-11-18 12:02 ` Jan Kara 2026-11-18 14:19 ` [PATCH v3] " Alan 0 siblings, 1 reply; 5+ messages in thread From: Jan Kara @ 2026-11-18 12:02 UTC (permalink / raw) To: Alan Cc: tytso, adilger.kernel, libaokun, jack, ojaswin, ritesh.list, yi.zhang, harshadshirwadkar, linux-ext4, linux-kernel, stable On Tue 17-11-26 11:39:38, Alan wrote: > __ext4_unlink() removes the directory entry before decrementing the target > inode's link count. It then dirties the parent inode. If the parent > inode-table block cannot be read, parent inode dirtying fails after the > entry has been removed, and unlink returns without dropping the target > inode's link count. With errors=continue, this read error need not abort > the journal transaction, so the directory update can be committed without > the corresponding link-count update. > > Reserve the inode locations and journal write access for the parent and > target inodes before removing the directory entry. This makes inode-table > read and access errors fail before the namespace is changed. Keep the > existing namespace and link-count update order, and release the inode > location references on every exit path. Fast-commit replay can skip the > parent update when the directory entry does not match the target inode, so > reserve only the target inode in that case. > > The original source-derived injection at the journal write-access boundary > is not evidence for a committed inconsistency: an error after the journal > has already aborted cannot establish a committed transaction. The relevant > failure is an actual inode-table READ EIO before journal write access. > > Tested on Linux 7.4-rc3 (torvalds/linux commit > aebb7274476403040d582c61478df8f4a7bf9cd3) with QEMU blkdebug and > errors=continue. On the unpatched kernel, the READ EIO leaves the directory > entry removed with Links: 1 after normal unmount; the JBD2 trace shows no > journal abort and records the transaction commit, and e2fsck -fn reports > an unattached inode. With this patch, the same error is returned before the > directory entry is removed; the file remains present with Links: 1 and > e2fsck -fn passes. No-fault controls pass on both kernels. Also built > fs/ext4/namei.o with W=1. > > Fixes: 4209ae12b122 ("ext4: handle ext4_mark_inode_dirty errors") > Link: https://lore.kernel.org/linux-ext4/tencent_D60E766CE07D3A1847B81DE9BC37B4466908@qq.com/ > Cc: stable@vger.kernel.org > Signed-off-by: Alan <3164729207@qq.com> > --- > fs/ext4/namei.c | 21 +++++++++++++++++++++ > 1 file changed, 21 insertions(+) > > v2: > - Clarify that the committed inconsistency is reproduced by an inode-table > READ EIO before journal write access, not by an already-aborted journal. > - Revalidate the unmodified and fixed paths on current Linux 7.4-rc3 mainline. Ah, OK, now it makes more sense. Thanks! One nit below: > @@ -3269,6 +3270,22 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name, > if (IS_DIRSYNC(dir)) > ext4_handle_sync(handle); > > + /* > + * Read the inode-table blocks and get journal write access before > + * removing the directory entry. Otherwise, a read error while updating > + * either inode can leave the name removed but the link count unchanged. > + */ > + dir_iloc.bh = NULL; > + inode_iloc.bh = NULL; > + if (!skip_remove_dentry) { > + retval = ext4_reserve_inode_write(handle, dir, &dir_iloc); > + if (retval) > + goto out_handle; > + } > + retval = ext4_reserve_inode_write(handle, inode, &inode_iloc); > + if (retval) > + goto out_handle; Let's first grab inode_iloc and move grabbing of dir_iloc into the if (!skip_remove_dentry) { branch below so that we don't test for it twice. Otherwise the patch looks good. Honza > + > if (!skip_remove_dentry) { > retval = ext4_delete_entry(handle, dir, de, bh); > if (retval) > @@ -3293,6 +3310,10 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name, > if (dentry && !retval) > ext4_fc_track_unlink(handle, dentry); > out_handle: > + if (dir_iloc.bh) > + brelse(dir_iloc.bh); > + if (inode_iloc.bh) > + brelse(inode_iloc.bh); > ext4_journal_stop(handle); > out_bh: > brelse(bh); > > base-commit: d135ab453a7400a34930bdda1ef4bdc8acfac80e > -- > 2.53.0 > -- Jan Kara <jack@suse.com> SUSE Labs, CR ^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v3] ext4: reserve inode write access before unlinking entry 2026-11-18 12:02 ` Jan Kara @ 2026-11-18 14:19 ` Alan 0 siblings, 0 replies; 5+ messages in thread From: Alan @ 2026-11-18 14:19 UTC (permalink / raw) To: tytso Cc: adilger.kernel, libaokun, jack, ojaswin, ritesh.list, yi.zhang, harshadshirwadkar, linux-ext4, linux-kernel, stable __ext4_unlink() removes the directory entry before decrementing the target inode's link count. It then dirties the parent inode. If the parent inode-table block cannot be read, parent inode dirtying fails after the entry has been removed, and unlink returns without dropping the target inode's link count. With errors=continue, this read error need not abort the journal transaction, so the directory update can be committed without the corresponding link-count update. Reserve the target inode location and journal write access first. When the directory entry is being removed, reserve the parent inode in the existing branch before deleting the entry. This makes inode-table read and access errors fail before the namespace is changed. Keep the existing namespace and link-count update order, and release inode location references on every exit path. Fast-commit replay can skip the parent update when the directory entry does not match the target inode, so only the target inode is reserved in that case. The original source-derived injection at the journal write-access boundary is not evidence for a committed inconsistency: an error after the journal has already aborted cannot establish a committed transaction. The relevant failure is an actual inode-table READ EIO before journal write access. Tested on Linux 7.4-rc3 (torvalds/linux commit aebb7274476403040d582c61478df8f4a7bf9cd3) with QEMU blkdebug and errors=continue. On the unpatched kernel, the READ EIO leaves the directory entry removed with Links: 1 after normal unmount; the JBD2 trace shows no journal abort and records the transaction commit, and e2fsck -fn reports an unattached inode. With this patch, the same error is returned before the directory entry is removed; the file remains present with Links: 1 and e2fsck -fn passes. No-fault controls pass on both kernels. Also built fs/ext4/namei.o with W=1. Fixes: 4209ae12b122 ("ext4: handle ext4_mark_inode_dirty errors") Link: https://lore.kernel.org/linux-ext4/tencent_D60E766CE07D3A1847B81DE9BC37B4466908@qq.com/ Cc: stable@vger.kernel.org --- fs/ext4/namei.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) v3: - Follow Jan Kara's suggestion: reserve the target inode first and move the parent-inode reservation into the existing !skip_remove_dentry branch. diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c index 354fc2d22df1aa..27fe5e82d6e12b 100644 --- a/fs/ext4/namei.c +++ b/fs/ext4/namei.c @@ -3233,6 +3233,7 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name, int retval = -ENOENT; struct buffer_head *bh; struct ext4_dir_entry_2 *de = NULL; + struct ext4_iloc dir_iloc, inode_iloc; handle_t *handle; int skip_remove_dentry = 0; @@ -3269,7 +3270,21 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name, if (IS_DIRSYNC(dir)) ext4_handle_sync(handle); + /* + * Read the inode-table blocks and get journal write access before + * removing the directory entry. Otherwise, a read error while updating + * either inode can leave the name removed but the link count unchanged. + */ + dir_iloc.bh = NULL; + inode_iloc.bh = NULL; + retval = ext4_reserve_inode_write(handle, inode, &inode_iloc); + if (retval) + goto out_handle; + if (!skip_remove_dentry) { + retval = ext4_reserve_inode_write(handle, dir, &dir_iloc); + if (retval) + goto out_handle; retval = ext4_delete_entry(handle, dir, de, bh); if (retval) goto out_handle; @@ -3293,6 +3308,10 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name, if (dentry && !retval) ext4_fc_track_unlink(handle, dentry); out_handle: + if (dir_iloc.bh) + brelse(dir_iloc.bh); + if (inode_iloc.bh) + brelse(inode_iloc.bh); ext4_journal_stop(handle); out_bh: brelse(bh); base-commit: d135ab453a7400a34930bdda1ef4bdc8acfac80e ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2026-11-18 14:19 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <tencent_D60E766CE07D3A1847B81DE9BC37B4466908@qq.com>
2026-11-16 7:35 ` [PATCH] ext4: reserve inode write access before unlinking entry Alan
2026-11-16 12:48 ` Jan Kara
2026-11-17 3:39 ` [PATCH v2] " Alan
2026-11-18 12:02 ` Jan Kara
2026-11-18 14:19 ` [PATCH v3] " Alan
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®