Backport to 4.9- ext4: protect journal inode's blocks using block_validity
cover Backport to 4.9- ext4: protect journal inode's blocks using block_validity
[PATCH 1/5] ext4: avoid declaring fs inconsistent due to invalid file handles
This patch is backported as functionality in this commit is used by Patch 2 in this patchset.
[PATCH 2/5] ext4: protect journal inode's blocks using block_validity Backport to 4.9
[PATCH 3/5] ext4: don't perform block validity checks on the journal [PATCH 4/5] ext4: fix block validity checks for journal inodes using [PATCH 5/5] ext4: unsigned int compared against zero Fixes issues found in Patch 2 in this patchset.
These patches addresses CVE-2019-19319
Colin Ian King (1):
ext4: unsigned int compared against zero
Theodore Ts'o (4):
ext4: avoid declaring fs inconsistent due to invalid file handles
ext4: protect journal inode's blocks using block_validity
ext4: don't perform block validity checks on the journal inode
ext4: fix block validity checks for journal inodes using indirect
blocks
fs/ext4/block_validity.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/ext4/ext4.h | 15 ++++++++++++-- fs/ext4/extents.c | 12 +++++++---- fs/ext4/ialloc.c | 2 +- fs/ext4/inode.c | 48 ++++++++++++++++++++++++++++++------------ fs/ext4/ioctl.c | 2 +- fs/ext4/namei.c | 4 ++-- fs/ext4/resize.c | 5 +++-- fs/ext4/super.c | 19 +++++------------ 9 files changed, 122 insertions(+), 39 deletions(-)
Signature · 1 line
2.7.4
PATCH 1/5 ext4: avoid declaring fs inconsistent due to invalid file handles
From: Theodore Ts'o <[email protected]>
commit 8a363970d1dc38c4ec4ad575c862f776f468d057 upstream.
If we receive a file handle, either from NFS or open_by_handle_at(2), and it points at an inode which has not been initialized, and the file system has metadata checksums enabled, we shouldn't try to get the inode, discover the checksum is invalid, and then declare the file system as being inconsistent.
This can be reproduced by creating a test file system via "mke2fs -t ext4 -O metadata_csum /tmp/foo.img 8M", mounting it, cd'ing into that directory, and then running the following program.
struct handle {
struct file_handle fh;
unsigned char fid[MAX_HANDLE_SZ];
};int main(int argc, char **argv)
{
struct handle h = {{8, 1 }, { 12, }};
open_by_handle_at(AT_FDCWD, &h.fh, O_RDONLY);
return 0;
}Google-Bug-Id: 120690101
--- fs/ext4/ext4.h | 15 +++++++++++++-- fs/ext4/ialloc.c | 2 +- fs/ext4/inode.c | 44 +++++++++++++++++++++++++++++++------------- fs/ext4/ioctl.c | 2 +- fs/ext4/namei.c | 4 ++-- fs/ext4/resize.c | 5 +++-- fs/ext4/super.c | 19 +++++-------------- 7 files changed, 56 insertions(+), 35 deletions(-)
fs/ext4/ext4.h +13 -2
@@ -2496,8 +2496,19 @@ int do_journal_get_write_access(handle_t *handle,#define FALL_BACK_TO_NONDELALLOC 1#define CONVERT_INLINE_DATA 2 -extern struct inode *ext4_iget (struct super_block *,unsigned long ); -extern struct inode *ext4_iget_normal (struct super_block *,unsigned long ); +typedef enum { +EXT4_IGET_NORMAL =0 , +EXT4_IGET_SPECIAL =0x0001 ,/* OK to iget a system inode */ +EXT4_IGET_HANDLE =0x0002 /* Inode # is from a handle */ +}ext4_iget_flags ; + +extern struct inode *__ext4_iget (struct super_block *sb,unsigned long ino, +ext4_iget_flags flags,const char *function, +unsigned int line); + +#define ext4_iget (sb, ino, flags) \ + __ext4_iget((sb), (ino), (flags), __func__, __LINE__) +extern int ext4_write_inode (struct inode *,struct writeback_control *);extern int ext4_setattr (struct dentry *,struct iattr *); extern int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
fs/ext4/ialloc.c +1 -1
@@ -1158,7 +1158,7 @@ struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)if (!ext4_test_bit (bit, bitmap_bh->b_data)) goto bad_orphan; - inode =ext4_iget (sb, ino); + inode =ext4_iget (sb, ino,EXT4_IGET_NORMAL );if (IS_ERR (inode)) { err =PTR_ERR (inode); ext4_error(sb, "couldn't read orphan inode %lu (err %d)",
fs/ext4/inode.c +31 -13
96 lines not on this page · raw message
fs/ext4/ioctl.c +1 -1
@@ -104,7 +104,7 @@ static long swap_inode_boot_loader(struct super_block *sb,if (!inode_owner_or_capable (inode) || !capable (CAP_SYS_ADMIN ))return -EPERM ; - inode_bl =ext4_iget (sb,EXT4_BOOT_LOADER_INO ); + inode_bl =ext4_iget (sb,EXT4_BOOT_LOADER_INO ,EXT4_IGET_SPECIAL );if (IS_ERR (inode_bl))return PTR_ERR (inode_bl); ei_bl =EXT4_I (inode_bl);
fs/ext4/namei.c +2 -2
@@ -1626,7 +1626,7 @@ static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsi dentry);return ERR_PTR (-EFSCORRUPTED ); } - inode =ext4_iget_normal (dir->i_sb, ino); + inode =ext4_iget (dir->i_sb, ino,EXT4_IGET_NORMAL );if (inode ==ERR_PTR (-ESTALE )) { EXT4_ERROR_INODE(dir, "deleted inode referenced: %u",
@@ -1675,7 +1675,7 @@ struct dentry *ext4_get_parent(struct dentry *child)return ERR_PTR (-EFSCORRUPTED ); } -return d_obtain_alias (ext4_iget_normal (child->d_sb, ino)); +return d_obtain_alias (ext4_iget (child->d_sb, ino,EXT4_IGET_NORMAL )); }/*
fs/ext4/resize.c +3 -2
@@ -1649,7 +1649,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input) "No reserved GDT blocks, can't resize");return -EPERM ; } - inode =ext4_iget (sb,EXT4_RESIZE_INO ); + inode =ext4_iget (sb,EXT4_RESIZE_INO ,EXT4_IGET_SPECIAL );if (IS_ERR (inode)) {ext4_warning (sb,"Error opening resize inode" );return PTR_ERR (inode);
@@ -1977,7 +1977,8 @@ int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count) }if (!resize_inode) - resize_inode =ext4_iget (sb,EXT4_RESIZE_INO ); + resize_inode =ext4_iget (sb,EXT4_RESIZE_INO , +EXT4_IGET_SPECIAL );if (IS_ERR (resize_inode)) {ext4_warning (sb,"Error opening resize inode" );return PTR_ERR (resize_inode);
fs/ext4/super.c +5 -14
@@ -1048,20 +1048,11 @@ static struct inode *ext4_nfs_get_inode(struct super_block *sb, {struct inode *inode; -if (ino <EXT4_FIRST_INO (sb) && ino !=EXT4_ROOT_INO ) -return ERR_PTR (-ESTALE ); -if (ino >le32_to_cpu (EXT4_SB (sb)->s_es->s_inodes_count)) -return ERR_PTR (-ESTALE ); - -/* iget isn't really right if the inode is currently unallocated!! -* -* ext4_read_inode will return a bad_inode if the inode had been -* deleted, so we should be safe. -* +/* * Currently we don't know the generation for parent directory, so * a generation of 0 means "accept any" */ - inode =ext4_iget_normal (sb, ino); + inode =ext4_iget (sb, ino,EXT4_IGET_HANDLE );if (IS_ERR (inode))return ERR_CAST (inode);if (generation && inode->i_generation != generation) {
@@ -4194,7 +4185,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)* so we can safely mount the rest of the filesystem now. */ - root =ext4_iget (sb,EXT4_ROOT_INO ); + root =ext4_iget (sb,EXT4_ROOT_INO ,EXT4_IGET_SPECIAL );if (IS_ERR (root)) {ext4_msg (sb,KERN_ERR ,"get root inode failed" ); ret =PTR_ERR (root);
@@ -4446,7 +4437,7 @@ static struct inode *ext4_get_journal_inode(struct super_block *sb,* happen if we iget() an unused inode, as the subsequent iput() * will try to delete it. */ - journal_inode =ext4_iget (sb, journal_inum); + journal_inode =ext4_iget (sb, journal_inum,EXT4_IGET_SPECIAL );if (IS_ERR (journal_inode)) {ext4_msg (sb,KERN_ERR ,"no journal found" );return NULL ;
@@ -5475,7 +5466,7 @@ static int ext4_quota_enable(struct super_block *sb, int type, int format_id,if (!qf_inums[type])return -EPERM ; - qf_inode =ext4_iget (sb, qf_inums[type]); + qf_inode =ext4_iget (sb, qf_inums[type],EXT4_IGET_SPECIAL );if (IS_ERR (qf_inode)) {ext4_error (sb,"Bad quota inode # %lu" , qf_inums[type]);return PTR_ERR (qf_inode);
Signature · 1 line
2.7.4
PATCH 2/5 ext4: protect journal inode's blocks using block_validity
In reply to ashwin-hFrom: Theodore Ts'o <[email protected]>
commit 345c0dbf3a30872d9b204db96b5857cd00808cae upstream.
Add the blocks which belong to the journal inode to block_validity's system zone so attempts to deallocate or overwrite the journal due a corrupted file system where the journal blocks are also claimed by another inode.
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=202879
--- fs/ext4/block_validity.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/ext4/inode.c | 4 ++++ 2 files changed, 52 insertions(+)
fs/ext4/block_validity.c +48 -0
@@ -136,6 +136,48 @@ static void debug_print_tree(struct ext4_sb_info *sbi)printk (KERN_CONT "\n" ); } +static int ext4_protect_reserved_inode (struct super_block *sb,u32 ino) +{ +struct inode *inode; +struct ext4_sb_info *sbi =EXT4_SB (sb); +struct ext4_map_blocks map; +u32 i =0 , err =0 , num, n; + +if ((ino <EXT4_ROOT_INO ) || + (ino >le32_to_cpu (sbi->s_es->s_inodes_count))) +return -EINVAL ; + inode =ext4_iget (sb, ino,EXT4_IGET_SPECIAL ); +if (IS_ERR (inode)) +return PTR_ERR (inode); + num = (inode->i_size + sb->s_blocksize -1 ) >> sb->s_blocksize_bits; +while (i < num) { + map.m_lblk = i; + map.m_len = num - i; + n =ext4_map_blocks (NULL , inode, &map,0 ); +if (n <0 ) { + err = n; +break ; + } +if (n ==0 ) { + i++; + }else { +if (!ext4_data_block_valid (sbi, map.m_pblk, n)) { +ext4_error (sb,"blocks %llu-%llu from inode %u " +"overlap system zone" , map.m_pblk, + map.m_pblk + map.m_len -1 , ino); + err = -EFSCORRUPTED ; +break ; + } + err =add_system_zone (sbi, map.m_pblk, n); +if (err <0 ) +break ; + i += n; + } + } +iput (inode); +return err; +} +int ext4_setup_system_zone (struct super_block *sb) {ext4_group_t ngroups =ext4_get_groups_count (sb);
@@ -170,6 +212,12 @@ int ext4_setup_system_zone(struct super_block *sb)if (ret)return ret; } +if (ext4_has_feature_journal (sb) && sbi->s_es->s_journal_inum) { + ret =ext4_protect_reserved_inode (sb, +le32_to_cpu (sbi->s_es->s_journal_inum)); +if (ret) +return ret; + }if (test_opt (sb,DEBUG ))debug_print_tree (EXT4_SB (sb));
fs/ext4/inode.c +4 -0
@@ -374,6 +374,10 @@ static int __check_block_validity(struct inode *inode, const char *func, unsigned int line, struct ext4_map_blocks *map) { + if (ext4_has_feature_journal(inode->i_sb) && + (inode->i_ino == + le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum))) + return 0; if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk, map->m_len)) { ext4_error_inode(inode, func, line, map->m_pblk,
Signature · 1 line
2.7.4
PATCH 3/5 ext4: don't perform block validity checks on the journal inode
In reply to ashwin-hFrom: Theodore Ts'o <[email protected]>
commit 0a944e8a6c66ca04c7afbaa17e22bf208a8b37f0 upstream.
Since the journal inode is already checked when we added it to the block validity's system zone, if we check it again, we'll just trigger a failure.
This was causing failures like this:
[ 53.897001] EXT4-fs error (device sda): ext4_find_extent:909: inode #8: comm jbd2/sda-8: pblk 121667583 bad header/extent: invalid extent entries - magic f30a, entries 8, max 340(340), depth 0(0) [ 53.931430] jbd2_journal_bmap: journal block not found at offset 49 on sda-8 [ 53.938480] Aborting journal on device sda-8.
... but only if the system was under enough memory pressure that logical->physical mapping for the journal inode gets pushed out of the extent cache. (This is why it wasn't noticed earlier.)
--- fs/ext4/extents.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
fs/ext4/extents.c +8 -4
@@ -530,10 +530,14 @@ __read_extent_tree_block(const char *function, unsigned int line, }if (buffer_verified (bh) && !(flags &EXT4_EX_FORCE_CACHE ))return bh; - err =__ext4_ext_check (function, line, inode, -ext_block_hdr (bh), depth, pblk); -if (err) - goto errout; +if (!ext4_has_feature_journal (inode->i_sb) || + (inode->i_ino != +le32_to_cpu (EXT4_SB (inode->i_sb)->s_es->s_journal_inum))) { + err =__ext4_ext_check (function, line, inode, +ext_block_hdr (bh), depth, pblk); +if (err) + goto errout; + }set_buffer_verified (bh);/* * If this is a leaf block, cache all of its entries
Signature · 1 line
2.7.4
PATCH 4/5 ext4: fix block validity checks for journal inodes using indirect blocks
In reply to ashwin-hFrom: Theodore Ts'o <[email protected]>
commit 170417c8c7bb2cbbdd949bf5c443c0c8f24a203b upstream.
Commit 345c0dbf3a30 ("ext4: protect journal inode's blocks using block_validity") failed to add an exception for the journal inode in ext4_check_blockref(), which is the function used by ext4_get_branch() for indirect blocks. This caused attempts to read from the ext3-style journals to fail with:
[ 848.968550] EXT4-fs error (device sdb7): ext4_get_branch:171: inode #8: block 30343695: comm jbd2/sdb7-8: invalid block
Fix this by adding the missing exception check.
--- fs/ext4/block_validity.c | 5 +++++ 1 file changed, 5 insertions(+)
fs/ext4/block_validity.c +5 -0
@@ -274,6 +274,11 @@ int ext4_check_blockref(const char *function, unsigned int line,__le32 *bref = p;unsigned int blk; +if (ext4_has_feature_journal (inode->i_sb) && + (inode->i_ino == +le32_to_cpu (EXT4_SB (inode->i_sb)->s_es->s_journal_inum))) +return 0 ; +while (bref < p+max) { blk =le32_to_cpu (*bref++); if (blk &&
Signature · 1 line
2.7.4
PATCH 5/5 ext4: unsigned int compared against zero
In reply to ashwin-hFrom: Colin Ian King <[email protected]>
commit fbbbbd2f28aec991f3fbc248df211550fbdfd58c upstream.
There are two cases where u32 variables n and err are being checked for less than zero error values, the checks is always false because the variables are not signed. Fix this by making the variables ints.
Addresses-Coverity: ("Unsigned compared against 0")
--- fs/ext4/block_validity.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/ext4/block_validity.c +2 -1
@@ -141,7 +141,8 @@ static int ext4_protect_reserved_inode(struct super_block *sb, u32 ino)struct inode *inode;struct ext4_sb_info *sbi =EXT4_SB (sb);struct ext4_map_blocks map; -u32 i =0 , err =0 , num, n; +u32 i =0 , num; +int err =0 , n;if ((ino <EXT4_ROOT_INO ) || (ino >le32_to_cpu (sbi->s_es->s_inodes_count)))
Signature · 1 line
2.7.4
Quoted 8 lines · ashwin-h
[PATCH 1/5] ext4: avoid declaring fs inconsistent due to invalid file handles
This patch is backported as functionality in this commit is used by Patch 2 in this patchset.[PATCH 2/5] ext4: protect journal inode's blocks using
block_validityBackport to 4.9
Quoted 6 lines
[PATCH 3/5] ext4: don't perform block validity checks on the journal [PATCH 4/5] ext4: fix block validity checks for journal inodes using [PATCH 5/5] ext4: unsigned int compared against zero Fixes issues found in Patch 2 in this patchset.
These patches addresses CVE-2019-19319
I can't take patches for 4.9 that are not also in 4.14, for the obvious reason that you never want to upgrade to a newer kernel and get regressions.
So can you provide a backported series for the 4.14 tree too? Then I can take these.
thanks,
greg k-h
I have sent patches for 4.14 tree
Thanks,
Ashwin
On 29/04/20, 6:29 PM, "Greg KH" <[email protected]> wrote:
On Thu, Apr 30, 2020 at 12:51:34AM +0530, ashwin-h wrote:
> [PATCH 1/5] ext4: avoid declaring fs inconsistent due to invalid file > handles
> This patch is backported as functionality in this commit is used by > Patch 2 in this patchset.
>
> [PATCH 2/5] ext4: protect journal inode's blocks using block_validity > Backport to 4.9
>
> [PATCH 3/5] ext4: don't perform block validity checks on the journal > [PATCH 4/5] ext4: fix block validity checks for journal inodes using > [PATCH 5/5] ext4: unsigned int compared against zero
> Fixes issues found in Patch 2 in this patchset.
>
> These patches addresses CVE-2019-19319
I can't take patches for 4.9 that are not also in 4.14, for the obvious reason that you never want to upgrade to a newer kernel and get regressions.
So can you provide a backported series for the 4.14 tree too? Then I can take these.
thanks,
greg k-h
Quoted 1 line · Ashwin H
I have sent patches for 4.14 tree
Thank you, all of these are now queued up.
greg k-h