[PATCH v4] ext4: reserve inode write access before unlinking entry
From: Alan
Date: Wed Nov 18 2026 - 10:03:25 EST
__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@xxxxxx/
Cc: stable@xxxxxxxxxxxxxxx
Signed-off-by: Alan <3164729207@xxxxxx>
---
fs/ext4/namei.c | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
v4:
- Restore the omitted Signed-off-by trailer. No code changes from v3.
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