kernel BUG in ext4_update_inline_data
Subsystems (2)
#syz test
From 4c910ac989e7a6d97565a67677a1ee88e2d1a9ad Mon Sep 17 00:00:00 2001
From: Moon Hee Lee <[email protected]>
Date: Thu, 10 Jul 2025 00:36:59 -0700
Subject: [PATCH] ext4: bail out when INLINE_DATA_FL lacks system.data xattr
A syzbot fuzzed image triggered a BUG_ON in ext4_update_inline_data() when an inode had the INLINE_DATA_FL flag set but was missing the system.data extended attribute.
ext4_prepare_inline_data() now checks for the presence of that xattr and returns -EFSCORRUPTED if it is missing, preventing corrupted inodes from reaching the update path and triggering a crash.
Proof from e2fsck on the fuzzed image:
$ e2fsck -fn mount_0
e2fsck 1.47.0 (5-Feb-2023)
One or more block group descriptor checksums are invalid. Fix? no Group descriptor 0 checksum is 0x8245, should be 0x353a. IGNORED. Pass 1: Checking inodes, blocks, and sizes
Inode 12 has INLINE_DATA_FL flag but extended attribute not found. Truncate? no
Inode 16, i_blocks is 3298534883346, should be 18. Fix? no
Inode 17, i_blocks is 17592186044416, should be 0. Fix? no
Pass 2: Checking directory structure
Symlink /file0/file1 (inode #14) is invalid.
Clear? no
Entry 'file1' in /file0 (12) has an incorrect filetype (was 7, should be 0). Fix? no
Directory inode 11, block #5, offset 0: directory corrupted Salvage? no
e2fsck: aborted
syzkaller: ********** WARNING: Filesystem still has errors **********
--- fs/ext4/inline.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+)
fs/ext4/inline.c +22 -0
@@ -399,6 +399,13 @@ static int ext4_update_inline_data(handle_t *handle, struct inode *inode,static int ext4_prepare_inline_data (handle_t *handle,struct inode *inode,loff_t len) { +struct ext4_xattr_ibody_find is = { + .s = { .not_found = -ENODATA , }, + }; +struct ext4_xattr_info i = { + .name_index =EXT4_XATTR_INDEX_SYSTEM , + .name =EXT4_XATTR_SYSTEM_DATA , + };int ret, size, no_expand;struct ext4_inode_info *ei =EXT4_I (inode);
@@ -409,6 +416,19 @@ static int ext4_prepare_inline_data(handle_t *handle, struct inode *inode,if (size < len)return -ENOSPC ; + ret =ext4_get_inode_loc (inode, &is.iloc); +if (ret) + goto out; + + ret =ext4_xattr_ibody_find (inode, &i, &is); +if (ret) + goto out; + +if (is.s.not_found) { + ret = -EFSCORRUPTED ; + goto out; + } +ext4_write_lock_xattr (inode, &no_expand);if (ei->i_inline_off)
@@ -417,6 +437,8 @@ static int ext4_prepare_inline_data(handle_t *handle, struct inode *inode, ret =ext4_create_inline_data (handle, inode, len);ext4_write_unlock_xattr (inode, &no_expand); +out: +brelse (is.iloc.bh);return ret; }
Signature · 1 line
2.43.0
syzbot has tested the proposed patch and the reproducer did not trigger any issue:
Hello,
syzbot has tested the proposed patch and the reproducer did not trigger any issue:
Tested on:
commit: 8c2e52eb eventpoll: don't decrement ep refcount while .. git tree: upstream console output: https://syzkaller.appspot.com/x/log.txt?x=14ff7582580000 kernel config: https://syzkaller.appspot.com/x/.config?x=b309c907eaab29da dashboard link: https://syzkaller.appspot.com/bug?extid=544248a761451c0df72f compiler: Debian clang version 20.1.7 (++20250616065708+6146a88f6049-1~exp1~20250616065826.132), Debian LLD 20.1.7 patch: https://syzkaller.appspot.com/x/patch.diff?x=15ef7582580000
Note: testing is done by a robot and is best-effort only.
Theodore Ts'o
maintainerPATCH 1/1 ext4: do not BUG when INLINE_DATA_FL lacks system.data xattr
In reply to Moon Hee LeeQuoted 5 lines · Moon Hee Lee
From
4c910ac989e7a6d97565a67677a1ee88e2d1a9adMon Sep 17 00:00:00 2001
From: Moon Hee Lee <[email protected]>
Date: Thu, 10 Jul 2025 00:36:59 -0700
Subject: [PATCH] ext4: bail out whenINLINE_DATA_FLlacks system.data xattr
Quoted 7 lines
A syzbot fuzzed image triggered a
BUG_ONinext4_update_inline_data()when an inode had theINLINE_DATA_FLflag set but was missing the system.data extended attribute.
ext4_prepare_inline_data()now checks for the presence of that xattr and returns-EFSCORRUPTEDif it is missing, preventing corrupted inodes from reaching the update path and triggering a crash.
Thanks ofor the patch! However, instead of doing an xattr lookup in ext4_prepare_inline_data(), we can more simply and more efficiently just not BUG in ext4_update_inline_data, like this:
From eedfada9eb51541fe72f19350503890da522212d Mon Sep 17 00:00:00 2001
From: Theodore Ts'o <[email protected]>
Date: Thu, 17 Jul 2025 10:54:34 -0400
Subject: [PATCH] ext4: do not BUG when INLINE_DATA_FL lacks system.data xattr
A syzbot fuzzed image triggered a BUG_ON in ext4_update_inline_data() when an inode had the INLINE_DATA_FL flag set but was missing the system.data extended attribute.
Since this can happen due to a maiciouly fuzzed file system, we shouldn't BUG, but rather, report it as a corrupted file system.
--- fs/ext4/inline.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/ext4/inline.c +6 -0
@@ -354,6 +354,12 @@ static int ext4_update_inline_data(handle_t *handle, struct inode *inode,if (error) goto out; +if (is.s.not_found) { +EXT4_ERROR_INODE (inode,"missing inline data xattr" ); + error = -EFSCORRUPTED ; + goto out; + } +BUG_ON (is.s.not_found); len -=EXT4_MIN_INLINE_DATA_SIZE ;
Signature · 1 line
2.47.2
Re: [PATCH] ext4: do not BUG when INLINE_DATA_FL lacks system.data xattr
Quoted 4 lines
Thanks ofor the patch! However, instead of doing an xattr lookup in
ext4_prepare_inline_data(), we can more simply and more efficiently just not BUG inext4_update_inline_data, like this:
Thanks for the response and for taking the time to address the issue.
Just to clarify the intent behind the earlier patch [1]: it was meant to catch the missing system.data xattr early in ext4_prepare_inline_data(), before branching into paths that assume the xattr is present.
fs/ext4/inline.c static int ext4_update_inline_data(handle_t *handle, struct inode *inode, · line 363
Quoted 11 lines
fs/ext4/inline.c +6
-0@@ -354,6 +354,12 @@ static int ext4_update_inline_data(handle_t *handle, struct inode *inode,if (error) goto out; +if (is.s.not_found) { +EXT4_ERROR_INODE (inode,"missing inline data xattr" ); + error = -EFSCORRUPTED ; + goto out; + } +BUG_ON (is.s.not_found);
The current patch addresses ext4_update_inline_data() directly, but the same condition also leads to a BUG_ON in ext4_create_inline_data() [2], which the earlier approach intended to prevent as well.
Later, a third instance was found in ext4_inline_data_truncate() [3], which also contains a similar BUG_ON and might need the same kind of check.
Reducing duplicated checks across these sites would be beneficial, though fixing each case directly also looks reasonable and straightforward.
[1] https://lore.kernel.org/all/[email protected]/
[2] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/inline.c?h=v6.16-rc6#n306
[3] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/fs/ext4/inline.c?h=v6.16-rc6#n1906
Re: [PATCH] ext4: do not BUG when INLINE_DATA_FL lacks system.data xattr
On Thu, Jul 17, 2025 at 9:59 AM Moon Hee Lee <[email protected]> wrote:
Just a quick follow-up to close the loop:
Quoted 4 lines
The current patch addresses
ext4_update_inline_data()directly, but the same condition also leads to aBUG_ONinext4_create_inline_data()[2], which the earlier approach intended to prevent as well.
I missed that ext4_create_inline_data expects the xattr to be absent at that point, since it's about to create it. The BUG_ON(!is.s.not_found) enforces that expectation.
The patch I sent earlier didn’t account for this correctly. Returning an error when the xattr was not found would have broken valid behavior in the create path.
Thanks again for resolving this with a simple and correct fix. Per-site handling makes sense here, as each path has different expectations about the xattr state.
Best regards,
Moonhee
Theodore Ts'o
maintainerRe: [PATCH] ext4: do not BUG when INLINE_DATA_FL lacks system.data xattr
In reply to Moon Hee LeeQuoted 3 lines · Moon Hee Lee
The current patch addresses
ext4_update_inline_data()directly, but the same condition also leads to aBUG_ONinext4_create_inline_data()[2], which the earlier approach intended to prevent as well.
Actually, the two conditions are opposite to each other. The one in ext4_update_inline_data() was:
BUG_ON(is.s.not_found);
while te one in ext4_create_inline_data() was:
BUG_ON(!is.s.not_found);
So your patch would not only cause an extra xattr lookup in ext4_prepare_inline_data(), but it would actually cause problems by causing spurious failures when first writing to an inline data file. (Which makes me suspect that you hadn't run other test on your patich other than just vaidating that the syzkaller reproduce was no longer reproducing.)
Also, having taking a closer look at te code paths, I became suspicious that there is something about the syzkaller reproducer is doing which might be a bit sus. That's because whether we call ext4_update_inline_data() or ext4_create_inline_data() is based on whether i_inline off is set or not:
if (ei->i_inline_off) ret = ext4_update_inline_data(handle, inode, len); else ret = ext4_create_inline_data(handle, inode, len);
But how is ei->i_inline_off set? It's set from a former call to ext4_xattr_ibody_find():
error = ext4_xattr_ibody_find(inode, &i, &is);
if (error)
goto out;
if (!is.s.not_found) {
if (is.s.here->e_value_inum) {
EXT4_ERROR_INODE(inode, "inline data xattr refers "
"to an external xattr inode");
error = -EFSCORRUPTED;
goto out;
}
EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here -
(void *)ext4_raw_inode(&is.iloc));
EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
le32_to_cpu(is.s.here->e_value_size);
}So the whole *reason* why i_inline_off exists is because we're caching the result of calling ext4_xattr_ibody_find(). So if i_inline_off is non-zero, and then when we call ext4_ibody_find() later on, and we find that xattr has suddenly disappeared, there is something weird
going on. That's why the BUG_ON was added orginally.
When I took a look at the reproduer, I found that indeed, it is calling LOOP_CLR_FD and LOOP_SET_STATUS64 to reconfigure the loop device out from under the mounted file system. This is smashing the file system, and is therefore corrupting the block device. As it turns out, Jan Kara recently sent out a patch, and it has been accepted in the block tree, to prevent a similar Syzkaller issue using LOOP_SET_BLOCK_SIZE[1].
[1] https://lore.kernel.org/r/[email protected]
We need to do something similar for LOOP_CLR_FD, LOOP_SET_STATUS, LOOP_SET_STATUS64, LOOP_CHANGE_FD, and LOOP_SET_CAPACITY ioctls.
Cheers,
- Ted
Jan Kara
reviewerRe: [PATCH] ext4: do not BUG when INLINE_DATA_FL lacks system.data xattr
Quoted 67 lines · Theodore Ts'o
Quoted 3 lines · Moon Hee Lee
The current patch addresses
ext4_update_inline_data()directly, but the same condition also leads to aBUG_ONinext4_create_inline_data()[2], which the earlier approach intended to prevent as well.Actually, the two conditions are opposite to each other. The one in
ext4_update_inline_data()was:BUG_ON(is.s.not_found);while te one in
ext4_create_inline_data()was:BUG_ON(!is.s.not_found);So your patch would not only cause an extra xattr lookup in
ext4_prepare_inline_data(), but it would actually cause problems by causing spurious failures when first writing to an inline data file. (Which makes me suspect that you hadn't run other test on your patich other than just vaidating that the syzkaller reproduce was no longer reproducing.)Also, having taking a closer look at te code paths, I became suspicious that there is something about the syzkaller reproducer is doing which might be a bit sus. That's because whether we call
ext4_update_inline_data()orext4_create_inline_data()is based on whetheri_inlineoff is set or not:if (ei->i_inline_off) ret = ext4_update_inline_data(handle, inode, len); else ret = ext4_create_inline_data(handle, inode, len);But how is
ei->i_inline_offset? It's set from a former call toext4_xattr_ibody_find():error = ext4_xattr_ibody_find(inode, &i, &is); if (error) goto out; if (!is.s.not_found) { if (is.s.here->e_value_inum) { EXT4_ERROR_INODE(inode, "inline data xattr refers " "to an external xattr inode"); error = -EFSCORRUPTED; goto out; } EXT4_I(inode)->i_inline_off = (u16)((void *)is.s.here - (void *)ext4_raw_inode(&is.iloc)); EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE + le32_to_cpu(is.s.here->e_value_size); }So the whole *reason* why
i_inline_offexists is because we're caching the result of callingext4_xattr_ibody_find(). So ifi_inline_offis non-zero, and then when we callext4_ibody_find()later on, and we find that xattr has suddenly disappeared, there is something weird
going on. That's why theBUG_ONwas added orginally.When I took a look at the reproduer, I found that indeed, it is calling
LOOP_CLR_FDandLOOP_SET_STATUS64to reconfigure the loop device out from under the mounted file system. This is smashing the file system, and is therefore corrupting the block device. As it turns out, Jan Kara recently sent out a patch, and it has been accepted in the block tree, to prevent a similar Syzkaller issue using LOOP_SET_BLOCK_SIZE[1].
Quoted 4 lines
[1] https://lore.kernel.org/r/[email protected]
We need to do something similar for
LOOP_CLR_FD,LOOP_SET_STATUS,LOOP_SET_STATUS64,LOOP_CHANGE_FD, andLOOP_SET_CAPACITYioctls.
Well, careful here. Changing loop device underneath mounted filesystem is a valid usecase in active use (similarly as changing DM device underneath a filesystem). So don't think we can play similar tricks as with LOOP_SET_BLOCK_SIZE where changing block device block size just doesn't make sense while the device is in use. Similarly LOOP_CLR_FD is an equivalent of device going away. LOOP_CHANGE_FD is a legacy of the past but it was *designed* to be used to swap backing file under a life filesystem (old days of Wild West :)) during boot. We may get away with dropping that these days but so far I'm not convinced it's worth the risk. So in this case I don't see anything here that couldn't happen with say DM device and thus I wouldn't really restrict the loop device functionality...
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Theodore Ts'o
maintainerRe: [PATCH] ext4: do not BUG when INLINE_DATA_FL lacks system.data xattr
Quoted 14 lines · Jan Kara
Quoted 2 lines
We need to do something similar for
LOOP_CLR_FD,LOOP_SET_STATUS,LOOP_SET_STATUS64,LOOP_CHANGE_FD, andLOOP_SET_CAPACITYioctls.Well, careful here. Changing loop device underneath mounted filesystem is a valid usecase in active use (similarly as changing DM device underneath a filesystem). So don't think we can play similar tricks as with
LOOP_SET_BLOCK_SIZEwhere changing block device block size just doesn't make sense while the device is in use. SimilarlyLOOP_CLR_FDis an equivalent of device going away.LOOP_CHANGE_FDis a legacy of the past but it was *designed* to be used to swap backing file under a life filesystem (old days of Wild West :)) during boot. We may get away with dropping that these days but so far I'm not convinced it's worth the risk. So in this case I don't see anything here that couldn't happen with say DM device and thus I wouldn't really restrict the loop device functionality...
Sure, and LOOP_SET_CAPACITY might be used to grow a file system image which the file system could then grow into. Fair.
This is related to BLK_DEV_WRITE_MOUNTED=n which the syzkaller folks have agreed to use to prevent noisy syzkaller reports. We're seeing a bunch of syzkaller reports now that syzkaller has been taught how to use these loop ioctls and so we're seeing loop device hijinks. Which is fine; I can just start filtering any syzkaller report that uses loop device ioctls as false positive noise and call it a day. Unfortunately, that won't help deal with researchers that are taking the syzkaller code and then sending reports without any dashboards or reproducers. :-(
However, I do think that if the file system has advertised that they don't support random underlying block device hijinks, such as XFS for example, we should honor this and disallow those "wild west" loop device operations. And perhaps we should similarly disallow them if BLK_DEV_WRITE_MOUNTED=n.
- Ted
Theodore Ts'o
maintainerPATCH 1/1 ext4: do not BUG when INLINE_DATA_FL lacks system.data xattr
In reply to Moon Hee LeeA syzbot fuzzed image triggered a BUG_ON in ext4_update_inline_data() when an inode had the INLINE_DATA_FL flag set but was missing the system.data extended attribute.
Since this can happen due to a maiciouly fuzzed file system, we shouldn't BUG, but rather, report it as a corrupted file system.
Add similar replacements of BUG_ON with EXT4_ERROR_INODE() ii ext4_create_inline_data() and ext4_inline_data_truncate().
--- fs/ext4/inline.c | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-)
fs/ext4/inline.c +16 -3
@@ -303,7 +303,11 @@ static int ext4_create_inline_data(handle_t *handle,if (error) goto out; -BUG_ON (!is.s.not_found); +if (!is.s.not_found) { +EXT4_ERROR_INODE (inode,"unexpected inline data xattr" ); + error = -EFSCORRUPTED ; + goto out; + } error =ext4_xattr_ibody_set (handle, inode, &i, &is);if (error) {
@@ -354,7 +358,11 @@ static int ext4_update_inline_data(handle_t *handle, struct inode *inode,if (error) goto out; -BUG_ON (is.s.not_found); +if (is.s.not_found) { +EXT4_ERROR_INODE (inode,"missing inline data xattr" ); + error = -EFSCORRUPTED ; + goto out; + } len -=EXT4_MIN_INLINE_DATA_SIZE ; value =kzalloc (len,GFP_NOFS );
@@ -1867,7 +1875,12 @@ int ext4_inline_data_truncate(struct inode *inode, int *has_inline)if ((err =ext4_xattr_ibody_find (inode, &i, &is)) !=0 ) goto out_error; -BUG_ON (is.s.not_found); +if (is.s.not_found) { +EXT4_ERROR_INODE (inode, +"missing inline data xattr" ); + err = -EFSCORRUPTED ; + goto out_error; + } value_len =le32_to_cpu (is.s.here->e_value_size); value =kmalloc (value_len,GFP_NOFS );
Signature · 1 line
2.47.2