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

Pull ext4 fixes from Ted Ts'o: "Bug fixes and regressions for ext4, the most serious of which is a potential deadlock during directory renames that was introduced during the merge window discovered by a combination of syzbot and lockdep" * tag 'ext4_for_linus_stable' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: ext4: zero i_disksize when initializing the bootloader inode ext4: make sure fs error flag setted before clear journal error ext4: commit super block if fs record error when journal record without error ext4, jbd2: add an optimized bmap for the journal inode ext4: fix WARNING in ext4_update_inline_data ext4: move where set the MAY_INLINE_DATA flag is set ext4: Fix deadlock during directory rename ext4: Fix comment about the 64BIT feature docs: ext4: modify the group desc size to 64 ext4: fix another off-by-one fsmap error on 1k block filesystems ext4: fix RENAME_WHITEOUT handling for inline directories ext4: make kobj_type structures constant ext4: fix cgroup writeback accounting with fs-layer encryption

Linus Torvalds committed 3 years ago

Commit 40d0c092 parents e730408 f5361da13 files · +98 −33Browse files

Unified · Split

13 files

Documentation/filesystems/ext4/blockgroup.rst +3 −3
fs/ext4/ext4.h +1 −1
fs/ext4/fsmap.c +2 −0
fs/ext4/inline.c +0 −1
fs/ext4/inode.c +6 −1
fs/ext4/ioctl.c +1 −0
fs/ext4/namei.c +24 −15
fs/ext4/page-io.c +6 −5
fs/ext4/super.c +36 −2
fs/ext4/sysfs.c +2 −2
fs/ext4/xattr.c +3 −0
fs/jbd2/journal.c +6 −3
include/linux/jbd2.h +8 −0

Documentation/filesystems/ext4/blockgroup.rst+3−3

@@ -105,9 +105,9 @@ descriptors. Instead, the superblock and a single block group descriptor · 104 unmodified lines
105	block is placed at the beginning of the first, second, and last block	105	block is placed at the beginning of the first, second, and last block
106	groups in a meta-block group. A meta-block group is a collection of	106	groups in a meta-block group. A meta-block group is a collection of
107	block groups which can be described by a single block group descriptor	107	block groups which can be described by a single block group descriptor
108	block. Since the size of the block group descriptor structure is 32	108	block. Since the size of the block group descriptor structure is 64
109	bytes, a meta-block group contains 32 block groups for filesystems with	109	bytes, a meta-block group contains 16 block groups for filesystems with
110	a 1KB block size, and 128 block groups for filesystems with a 4KB	110	a 1KB block size, and 64 block groups for filesystems with a 4KB
111	blocksize. Filesystems can either be created using this new block group	111	blocksize. Filesystems can either be created using this new block group
112	descriptor layout, or existing filesystems can be resized on-line, and	112	descriptor layout, or existing filesystems can be resized on-line, and
113	the field s_first_meta_bg in the superblock will indicate the first	113	the field s_first_meta_bg in the superblock will indicate the first

fs/ext4/ext4.h+1−1

@@ -1387,7 +1387,7 @@ struct ext4_super_block { · 1386 unmodified lines
1387	__le32 s_first_meta_bg; /* First metablock block group */	1387	__le32 s_first_meta_bg; /* First metablock block group */
1388	__le32 s_mkfs_time; /* When the filesystem was created */	1388	__le32 s_mkfs_time; /* When the filesystem was created */
1389	__le32 s_jnl_blocks[17]; /* Backup of the journal inode */	1389	__le32 s_jnl_blocks[17]; /* Backup of the journal inode */
1390	/* 64bit support valid if EXT4_FEATURE_COMPAT_64BIT */	1390	/* 64bit support valid if EXT4_FEATURE_INCOMPAT_64BIT */
1391	/150/ __le32 s_blocks_count_hi; /* Blocks count */	1391	/150/ __le32 s_blocks_count_hi; /* Blocks count */
1392	__le32 s_r_blocks_count_hi; /* Reserved blocks count */	1392	__le32 s_r_blocks_count_hi; /* Reserved blocks count */
1393	__le32 s_free_blocks_count_hi; /* Free blocks count */	1393	__le32 s_free_blocks_count_hi; /* Free blocks count */

fs/ext4/fsmap.c+2−0

@@ -486,6 +486,8 @@ static int ext4_getfsmap_datadev(struct super_block *sb, · 485 unmodified lines
486	keys[0].fmr_physical = bofs;	486	keys[0].fmr_physical = bofs;
487	if (keys[1].fmr_physical >= eofs)	487	if (keys[1].fmr_physical >= eofs)
488	keys[1].fmr_physical = eofs - 1;	488	keys[1].fmr_physical = eofs - 1;
		489	if (keys[1].fmr_physical < keys[0].fmr_physical)
		490	return 0;
489	start_fsb = keys[0].fmr_physical;	491	start_fsb = keys[0].fmr_physical;
490	end_fsb = keys[1].fmr_physical;	492	end_fsb = keys[1].fmr_physical;
491		493

fs/ext4/inline.c+0−1

@@ -159,7 +159,6 @@ int ext4_find_inline_data_nolock(struct inode *inode) · 158 unmodified lines
159	(void *)ext4_raw_inode(&is.iloc));	159	(void *)ext4_raw_inode(&is.iloc));
160	EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +	160	EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
161	le32_to_cpu(is.s.here->e_value_size);	161	le32_to_cpu(is.s.here->e_value_size);
162	ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
163	}	162	}
164	out:	163	out:
165	brelse(is.iloc.bh);	164	brelse(is.iloc.bh);

fs/ext4/inode.c+6−1

 	if (EXT4_INODE_HAS_XATTR_SPACE(inode)  &&
 	    *magic == cpu_to_le32(EXT4_XATTR_MAGIC)) {
+		int err;
 		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
-		return ext4_find_inline_data_nolock(inode);
+		err = ext4_find_inline_data_nolock(inode);
+		if (!err && ext4_has_inline_data(inode))
+			ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
+		return err;
 	} else
 		EXT4_I(inode)->i_inline_off = 0;
 	return 0;

fs/ext4/ioctl.c+1−0

@@ -431,6 +431,7 @@ static long swap_inode_boot_loader(struct super_block *sb, · 430 unmodified lines
431	ei_bl->i_flags = 0;	431	ei_bl->i_flags = 0;
432	inode_set_iversion(inode_bl, 1);	432	inode_set_iversion(inode_bl, 1);
433	i_size_write(inode_bl, 0);	433	i_size_write(inode_bl, 0);
		434	EXT4_I(inode_bl)->i_disksize = inode_bl->i_size;
434	inode_bl->i_mode = S_IFREG;	435	inode_bl->i_mode = S_IFREG;
435	if (ext4_has_feature_extents(sb)) {	436	if (ext4_has_feature_extents(sb)) {
436	ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);	437	ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);

fs/ext4/namei.c+24−15

 		int has_inline_data = 1;
 		ret = ext4_find_inline_entry(dir, fname, res_dir,
 					     &has_inline_data);
-		if (has_inline_data) {
+		if (inlined)
-			if (inlined)
+			*inlined = has_inline_data;
-				*inlined = 1;
+		if (has_inline_data)
 			goto cleanup_and_exit;
-		}
 	}
 	if ((namelen <= 2) && (name[0] == '.') &&
 	 * so the old->de may no longer valid and need to find it again
 	 * before reset old inode info.
 	 */
-	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
+	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
+				 &old.inlined);
 	if (IS_ERR(old.bh))
 		retval = PTR_ERR(old.bh);
 	if (!old.bh)
 			return retval;
 	}
-	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
+	/*
-	if (IS_ERR(old.bh))
+	 * We need to protect against old.inode directory getting converted
-		return PTR_ERR(old.bh);
+	 * from inline directory format into a normal one.
+	 */
+	if (S_ISDIR(old.inode->i_mode))
+		inode_lock_nested(old.inode, I_MUTEX_NONDIR2);
+	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
+				 &old.inlined);
+	if (IS_ERR(old.bh)) {
+		retval = PTR_ERR(old.bh);
+		goto unlock_moved_dir;
+	}
 	/*
 	 *  Check for inode number is _not_ due to possible IO errors.
 	 *  We might rmdir the source, keep it as pwd of some process
 			if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
 				goto end_rename;
 		}
-		/*
-		 * We need to protect against old.inode directory getting
-		 * converted from inline directory format into a normal one.
-		 */
-		inode_lock_nested(old.inode, I_MUTEX_NONDIR2);
 		retval = ext4_rename_dir_prepare(handle, &old);
 		if (retval) {
 			inode_unlock(old.inode);
 	} else {
 		ext4_journal_stop(handle);
 	}
-	if (old.dir_bh)
-		inode_unlock(old.inode);
 release_bh:
 	brelse(old.dir_bh);
 	brelse(old.bh);
 	brelse(new.bh);
+unlock_moved_dir:
+	if (S_ISDIR(old.inode->i_mode))
+		inode_unlock(old.inode);
 	return retval;
 }

fs/ext4/page-io.c+6−5

 static void io_submit_add_bh(struct ext4_io_submit *io,
 			     struct inode *inode,
-			     struct page *page,
+			     struct page *pagecache_page,
+			     struct page *bounce_page,
 			     struct buffer_head *bh)
 {
 	int ret;
 	}
 	if (io->io_bio == NULL)
 		io_submit_init_bio(io, bh);
-	ret = bio_add_page(io->io_bio, page, bh->b_size, bh_offset(bh));
+	ret = bio_add_page(io->io_bio, bounce_page ?: pagecache_page,
+			   bh->b_size, bh_offset(bh));
 	if (ret != bh->b_size)
 		goto submit_and_retry;
-	wbc_account_cgroup_owner(io->io_wbc, page, bh->b_size);
+	wbc_account_cgroup_owner(io->io_wbc, pagecache_page, bh->b_size);
 	io->io_next_block++;
 }
 	do {
 		if (!buffer_async_write(bh))
 			continue;
-		io_submit_add_bh(io, inode,
+		io_submit_add_bh(io, inode, page, bounce_page, bh);
-				 bounce_page ? bounce_page : page, bh);
 	} while ((bh = bh->b_this_page) != head);
 unlock:
 	unlock_page(page);

fs/ext4/super.c+36−2

 	return journal_inode;
 }
+static int ext4_journal_bmap(journal_t *journal, sector_t *block)
+{
+	struct ext4_map_blocks map;
+	int ret;
+	if (journal->j_inode == NULL)
+		return 0;
+	map.m_lblk = *block;
+	map.m_len = 1;
+	ret = ext4_map_blocks(NULL, journal->j_inode, &map, 0);
+	if (ret <= 0) {
+		ext4_msg(journal->j_inode->i_sb, KERN_CRIT,
+			 "journal bmap failed: block %llu ret %d\n",
+			 *block, ret);
+		jbd2_journal_abort(journal, ret ? ret : -EIO);
+		return ret;
+	}
+	*block = map.m_pblk;
+	return 0;
+}
 static journal_t *ext4_get_journal(struct super_block *sb,
 				   unsigned int journal_inum)
 {
 		return NULL;
 	}
 	journal->j_private = sb;
+	journal->j_bmap = ext4_journal_bmap;
 	ext4_init_journal_params(sb, journal);
 	return journal;
 }
 		err = jbd2_journal_wipe(journal, !really_read_only);
 	if (!err) {
 		char *save = kmalloc(EXT4_S_ERR_LEN, GFP_KERNEL);
 		if (save)
 			memcpy(save, ((char *) es) +
 			       EXT4_S_ERR_START, EXT4_S_ERR_LEN);
 			memcpy(((char *) es) + EXT4_S_ERR_START,
 			       save, EXT4_S_ERR_LEN);
 		kfree(save);
+		es->s_state |= cpu_to_le16(EXT4_SB(sb)->s_mount_state &
+					   EXT4_ERROR_FS);
+		/* Write out restored error information to the superblock */
+		if (!bdev_read_only(sb->s_bdev)) {
+			int err2;
+			err2 = ext4_commit_super(sb);
+			err = err ? : err2;
+		}
 	}
 	if (err) {
 		errstr = ext4_decode_error(sb, j_errno, nbuf);
 		ext4_warning(sb, "Filesystem error recorded "
 			     "from previous mount: %s", errstr);
-		ext4_warning(sb, "Marking fs in need of filesystem check.");
 		EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
 		es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
-		ext4_commit_super(sb);
+		j_errno = ext4_commit_super(sb);
+		if (j_errno)
+			return j_errno;
+		ext4_warning(sb, "Marked fs in need of filesystem check.");
 		jbd2_journal_clear_err(journal);
 		jbd2_journal_update_sb_errno(journal);

fs/ext4/sysfs.c+2−2

@@ -501,13 +501,13 @@ static const struct sysfs_ops ext4_attr_ops = { · 500 unmodified lines
501	.store = ext4_attr_store,	501	.store = ext4_attr_store,
502	};	502	};
503		503
504	static struct kobj_type ext4_sb_ktype = {	504	static const struct kobj_type ext4_sb_ktype = {
505	.default_groups = ext4_groups,	505	.default_groups = ext4_groups,
506	.sysfs_ops = &ext4_attr_ops,	506	.sysfs_ops = &ext4_attr_ops,
507	.release = ext4_sb_release,	507	.release = ext4_sb_release,
508	};	508	};
509		509
510	static struct kobj_type ext4_feat_ktype = {	510	static const struct kobj_type ext4_feat_ktype = {
511	.default_groups = ext4_feat_groups,	511	.default_groups = ext4_feat_groups,
512	.sysfs_ops = &ext4_attr_ops,	512	.sysfs_ops = &ext4_attr_ops,
513	.release = ext4_feat_release,	513	.release = ext4_feat_release,

fs/ext4/xattr.c+3−0

@@ -2852,6 +2852,9 @@ shift: · 2851 unmodified lines
2852	(void *)header, total_ino);	2852	(void *)header, total_ino);
2853	EXT4_I(inode)->i_extra_isize = new_extra_isize;	2853	EXT4_I(inode)->i_extra_isize = new_extra_isize;
2854		2854
		2855	if (ext4_has_inline_data(inode))
		2856	error = ext4_find_inline_data_nolock(inode);
		2857
2855	cleanup:	2858	cleanup:
2856	if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) {	2859	if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) {
2857	ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",	2860	ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",

fs/jbd2/journal.c+6−3

 {
 	int err = 0;
 	unsigned long long ret;
-	sector_t block = 0;
+	sector_t block = blocknr;
-	if (journal->j_inode) {
+	if (journal->j_bmap) {
-		block = blocknr;
+		err = journal->j_bmap(journal, &block);
+		if (err == 0)
+			*retp = block;
+	} else if (journal->j_inode) {
 		ret = bmap(journal->j_inode, &block);
 		if (ret || !block) {

include/linux/jbd2.h+8−0

@@ -1308,6 +1308,14 @@ struct journal_s · 1307 unmodified lines
1308	struct buffer_head *bh,	1308	struct buffer_head *bh,
1309	enum passtype pass, int off,	1309	enum passtype pass, int off,
1310	tid_t expected_commit_id);	1310	tid_t expected_commit_id);
		1311
		1312	/**
		1313	* @j_bmap:
		1314	*
		1315	* Bmap function that should be used instead of the generic
		1316	* VFS bmap function.
		1317	*/
		1318	int (j_bmap)(struct journal_s journal, sector_t *block);
1311	};	1319	};
1312		1320
1313	#define jbd2_might_wait_for_commit(j) \	1321	#define jbd2_might_wait_for_commit(j) \