Commit e589db7a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4 

Pull ext4 fixes from Ted Ts'o:
 "Various bug fixes for ext4.  The most serious of them fixes a security
  bug (CVE-2012-4508) which leads to stale data exposure when we have
  fallocate racing against writes to files undergoing delayed
  allocation.  We also have two fixes for the metadata checksum feature,
  the most serious of which can cause the superblock to have a invalid
  checksum after a power failure."

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4:
  ext4: Avoid underflow in ext4_trim_fs()
  ext4: Checksum the block bitmap properly with bigalloc enabled
  ext4: fix undefined bit shift result in ext4_fill_flex_info
  ext4: fix metadata checksum calculation for the superblock
  ext4: race-condition protection for ext4_convert_unwritten_extents_endio
  ext4: serialize fallocate with ext4_convert_unwritten_extents
parents 344ba37b 5de35e8d

fs/ext4/balloc.c

+3 −5
Original line number Diff line number Diff line
@@ -174,8 +174,7 @@ void ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh, 
		ext4_free_inodes_set(sb, gdp, 0);

		ext4_itable_unused_set(sb, gdp, 0);

		memset(bh->b_data, 0xff, sb->s_blocksize);

		ext4_block_bitmap_csum_set(sb, block_group, gdp, bh,

					   EXT4_BLOCKS_PER_GROUP(sb) / 8);

		ext4_block_bitmap_csum_set(sb, block_group, gdp, bh);

		return;

	}

	memset(bh->b_data, 0, sb->s_blocksize);
@@ -212,8 +211,7 @@ void ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh, 
	 */

	ext4_mark_bitmap_end(num_clusters_in_group(sb, block_group),

			     sb->s_blocksize * 8, bh->b_data);

	ext4_block_bitmap_csum_set(sb, block_group, gdp, bh,

				   EXT4_BLOCKS_PER_GROUP(sb) / 8);

	ext4_block_bitmap_csum_set(sb, block_group, gdp, bh);

	ext4_group_desc_csum_set(sb, block_group, gdp);

}
@@ -350,7 +348,7 @@ void ext4_validate_block_bitmap(struct super_block *sb, 
		return;

	}

	if (unlikely(!ext4_block_bitmap_csum_verify(sb, block_group,

			desc, bh, EXT4_BLOCKS_PER_GROUP(sb) / 8))) {

			desc, bh))) {

		ext4_unlock_group(sb, block_group);

		ext4_error(sb, "bg %u: bad block bitmap checksum", block_group);

		return;

fs/ext4/bitmap.c

+4 −2
Original line number Diff line number Diff line
@@ -58,11 +58,12 @@ void ext4_inode_bitmap_csum_set(struct super_block *sb, ext4_group_t group, 


int ext4_block_bitmap_csum_verify(struct super_block *sb, ext4_group_t group,

				  struct ext4_group_desc *gdp,

				  struct buffer_head *bh, int sz)

				  struct buffer_head *bh)

{

	__u32 hi;

	__u32 provided, calculated;

	struct ext4_sb_info *sbi = EXT4_SB(sb);

	int sz = EXT4_CLUSTERS_PER_GROUP(sb) / 8;



	if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,

					EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
@@ -84,8 +85,9 @@ int ext4_block_bitmap_csum_verify(struct super_block *sb, ext4_group_t group, 


void ext4_block_bitmap_csum_set(struct super_block *sb, ext4_group_t group,

				struct ext4_group_desc *gdp,

				struct buffer_head *bh, int sz)

				struct buffer_head *bh)

{

	int sz = EXT4_CLUSTERS_PER_GROUP(sb) / 8;

	__u32 csum;

	struct ext4_sb_info *sbi = EXT4_SB(sb);

fs/ext4/ext4.h

+3 −4
Original line number Diff line number Diff line
@@ -1882,10 +1882,10 @@ int ext4_inode_bitmap_csum_verify(struct super_block *sb, ext4_group_t group, 
				  struct buffer_head *bh, int sz);

void ext4_block_bitmap_csum_set(struct super_block *sb, ext4_group_t group,

				struct ext4_group_desc *gdp,

				struct buffer_head *bh, int sz);

				struct buffer_head *bh);

int ext4_block_bitmap_csum_verify(struct super_block *sb, ext4_group_t group,

				  struct ext4_group_desc *gdp,

				  struct buffer_head *bh, int sz);

				  struct buffer_head *bh);



/* balloc.c */

extern void ext4_validate_block_bitmap(struct super_block *sb,
@@ -2063,8 +2063,7 @@ extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count); 
extern int ext4_calculate_overhead(struct super_block *sb);

extern int ext4_superblock_csum_verify(struct super_block *sb,

				       struct ext4_super_block *es);

extern void ext4_superblock_csum_set(struct super_block *sb,

				     struct ext4_super_block *es);

extern void ext4_superblock_csum_set(struct super_block *sb);

extern void *ext4_kvmalloc(size_t size, gfp_t flags);

extern void *ext4_kvzalloc(size_t size, gfp_t flags);

extern void ext4_kvfree(void *ptr);

fs/ext4/ext4_jbd2.c

+2 −6
Original line number Diff line number Diff line
@@ -143,17 +143,13 @@ int __ext4_handle_dirty_super(const char *where, unsigned int line, 
	struct buffer_head *bh = EXT4_SB(sb)->s_sbh;

	int err = 0;



	ext4_superblock_csum_set(sb);

	if (ext4_handle_valid(handle)) {

		ext4_superblock_csum_set(sb,

				(struct ext4_super_block *)bh->b_data);

		err = jbd2_journal_dirty_metadata(handle, bh);

		if (err)

			ext4_journal_abort_handle(where, line, __func__,

						  bh, handle, err);

	} else {

		ext4_superblock_csum_set(sb,

				(struct ext4_super_block *)bh->b_data);

	} else

		mark_buffer_dirty(bh);

	}

	return err;

}

fs/ext4/extents.c

+49 −11
Original line number Diff line number Diff line
@@ -52,6 +52,9 @@ 
#define EXT4_EXT_MARK_UNINIT1	0x2  /* mark first half uninitialized */

#define EXT4_EXT_MARK_UNINIT2	0x4  /* mark second half uninitialized */



#define EXT4_EXT_DATA_VALID1	0x8  /* first half contains valid data */

#define EXT4_EXT_DATA_VALID2	0x10 /* second half contains valid data */



static __le32 ext4_extent_block_csum(struct inode *inode,

				     struct ext4_extent_header *eh)

{
@@ -2914,6 +2917,9 @@ static int ext4_split_extent_at(handle_t *handle, 
	unsigned int ee_len, depth;

	int err = 0;



	BUG_ON((split_flag & (EXT4_EXT_DATA_VALID1 | EXT4_EXT_DATA_VALID2)) ==

	       (EXT4_EXT_DATA_VALID1 | EXT4_EXT_DATA_VALID2));



	ext_debug("ext4_split_extents_at: inode %lu, logical"

		"block %llu\n", inode->i_ino, (unsigned long long)split);
@@ -2972,7 +2978,14 @@ static int ext4_split_extent_at(handle_t *handle, 


	err = ext4_ext_insert_extent(handle, inode, path, &newex, flags);

	if (err == -ENOSPC && (EXT4_EXT_MAY_ZEROOUT & split_flag)) {

		if (split_flag & (EXT4_EXT_DATA_VALID1|EXT4_EXT_DATA_VALID2)) {

			if (split_flag & EXT4_EXT_DATA_VALID1)

				err = ext4_ext_zeroout(inode, ex2);

			else

				err = ext4_ext_zeroout(inode, ex);

		} else

			err = ext4_ext_zeroout(inode, &orig_ex);



		if (err)

			goto fix_extent_len;

		/* update the extent length and mark as initialized */
@@ -3025,12 +3038,13 @@ static int ext4_split_extent(handle_t *handle, 
	uninitialized = ext4_ext_is_uninitialized(ex);



	if (map->m_lblk + map->m_len < ee_block + ee_len) {

		split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT ?

			      EXT4_EXT_MAY_ZEROOUT : 0;

		split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT;

		flags1 = flags | EXT4_GET_BLOCKS_PRE_IO;

		if (uninitialized)

			split_flag1 |= EXT4_EXT_MARK_UNINIT1 |

				       EXT4_EXT_MARK_UNINIT2;

		if (split_flag & EXT4_EXT_DATA_VALID2)

			split_flag1 |= EXT4_EXT_DATA_VALID1;

		err = ext4_split_extent_at(handle, inode, path,

				map->m_lblk + map->m_len, split_flag1, flags1);

		if (err)
@@ -3043,8 +3057,8 @@ static int ext4_split_extent(handle_t *handle, 
		return PTR_ERR(path);



	if (map->m_lblk >= ee_block) {

		split_flag1 = split_flag & EXT4_EXT_MAY_ZEROOUT ?

			      EXT4_EXT_MAY_ZEROOUT : 0;

		split_flag1 = split_flag & (EXT4_EXT_MAY_ZEROOUT |

					    EXT4_EXT_DATA_VALID2);

		if (uninitialized)

			split_flag1 |= EXT4_EXT_MARK_UNINIT1;

		if (split_flag & EXT4_EXT_MARK_UNINIT2)
@@ -3323,26 +3337,47 @@ static int ext4_split_unwritten_extents(handle_t *handle, 


	split_flag |= ee_block + ee_len <= eof_block ? EXT4_EXT_MAY_ZEROOUT : 0;

	split_flag |= EXT4_EXT_MARK_UNINIT2;



	if (flags & EXT4_GET_BLOCKS_CONVERT)

		split_flag |= EXT4_EXT_DATA_VALID2;

	flags |= EXT4_GET_BLOCKS_PRE_IO;

	return ext4_split_extent(handle, inode, path, map, split_flag, flags);

}



static int ext4_convert_unwritten_extents_endio(handle_t *handle,

						struct inode *inode,

						struct ext4_map_blocks *map,

						struct ext4_ext_path *path)

{

	struct ext4_extent *ex;

	ext4_lblk_t ee_block;

	unsigned int ee_len;

	int depth;

	int err = 0;



	depth = ext_depth(inode);

	ex = path[depth].p_ext;

	ee_block = le32_to_cpu(ex->ee_block);

	ee_len = ext4_ext_get_actual_len(ex);



	ext_debug("ext4_convert_unwritten_extents_endio: inode %lu, logical"

		"block %llu, max_blocks %u\n", inode->i_ino,

		(unsigned long long)le32_to_cpu(ex->ee_block),

		ext4_ext_get_actual_len(ex));

		  (unsigned long long)ee_block, ee_len);



	/* If extent is larger than requested then split is required */

	if (ee_block != map->m_lblk || ee_len > map->m_len) {

		err = ext4_split_unwritten_extents(handle, inode, map, path,

						   EXT4_GET_BLOCKS_CONVERT);

		if (err < 0)

			goto out;

		ext4_ext_drop_refs(path);

		path = ext4_ext_find_extent(inode, map->m_lblk, path);

		if (IS_ERR(path)) {

			err = PTR_ERR(path);

			goto out;

		}

		depth = ext_depth(inode);

		ex = path[depth].p_ext;

	}



	err = ext4_ext_get_access(handle, inode, path + depth);

	if (err)
@@ -3652,7 +3687,7 @@ ext4_ext_handle_uninitialized_extents(handle_t *handle, struct inode *inode, 
	}

	/* IO end_io complete, convert the filled extent to written */

	if ((flags & EXT4_GET_BLOCKS_CONVERT)) {

		ret = ext4_convert_unwritten_extents_endio(handle, inode,

		ret = ext4_convert_unwritten_extents_endio(handle, inode, map,

							path);

		if (ret >= 0) {

			ext4_update_inode_fsync_trans(handle, inode, 1);
@@ -4428,6 +4463,9 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len) 
	 */

	if (len <= EXT_UNINIT_MAX_LEN << blkbits)

		flags |= EXT4_GET_BLOCKS_NO_NORMALIZE;



	/* Prevent race condition between unwritten */

	ext4_flush_unwritten_io(inode);

retry:

	while (ret >= 0 && ret < max_blocks) {

		map.m_lblk = map.m_lblk + ret;

CRA Git | Maintained and supported by SUSTech CRA and CCSE