__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