Skip to contentSkip to conversation

ext4: use mb_optimize_scan regardless of inode format

PATCH Superseded Jan Kara 4 participants 9 messages Jan 9 – Jan 14 ext4 file system

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Jan Kara

author reviewer
#0 lore raw

v2 cover ext4: use mb_optimize_scan regardless of inode format

Hello,

this patch series enables use of mballoc optimizations regardless of the inode format. See patch 2 for details.

Changes since v1:
* Added patch to make sure mballoc doesn't select group with block numbers greater than 2^32 for indirect block based inodes

Previous versions:
v1: https://lore.kernel.org/all/[email protected]/

Honza

author reviewer
#1 lore raw

PATCH v2 1/2 ext4: always allocate blocks only from groups inode can use

For filesystems with more than 2^32 blocks inodes using indirect block based format cannot use blocks beyond the 32-bit limit. ext4_mb_scan_groups_linear() takes care to not select these unsupported groups for such inodes however other functions selecting groups for allocation don't. So far this is harmless because the other selection functions are used only with mb_optimize_scan and this is currently disabled for inodes with indirect blocks however in the following patch we want to enable mb_optimize_scan regardless of inode format.

---
 fs/ext4/mballoc.c | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)
fs/ext4/mballoc.c +17 -9
index 56d50fd3310b..f0e07bf11a93 100644
@@ -892,6 +892,18 @@ mb_update_avg_fragment_size(struct super_block *sb, struct ext4_group_info *grp)
 	}
 }
 
+static ext4_group_t ext4_get_allocation_groups_count(
+				struct ext4_allocation_context *ac)
+{
+	ext4_group_t ngroups = ext4_get_groups_count(ac->ac_sb);
+
+	/* non-extent files are limited to low blocks/groups */
+	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
+		ngroups = EXT4_SB(ac->ac_sb)->s_blockfile_groups;
+
+	return ngroups;
+}
+
 static int ext4_mb_scan_groups_xa_range(struct ext4_allocation_context *ac,
 					struct xarray *xa,
 					ext4_group_t start, ext4_group_t end)
@@ -899,7 +911,7 @@ static int ext4_mb_scan_groups_xa_range(struct ext4_allocation_context *ac,
 	struct super_block *sb = ac->ac_sb;
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
 	enum criteria cr = ac->ac_criteria;
-	ext4_group_t ngroups = ext4_get_groups_count(sb);
+	ext4_group_t ngroups = ext4_get_allocation_groups_count(ac);
 	unsigned long group = start;
 	struct ext4_group_info *grp;
 
@@ -951,7 +963,7 @@ static int ext4_mb_scan_groups_p2_aligned(struct ext4_allocation_context *ac,
 	ext4_group_t start, end;
 
 	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
 wrap_around:
 	for (i = ac->ac_2order; i < MB_NUM_ORDERS(ac->ac_sb); i++) {
 		ret = ext4_mb_scan_groups_largest_free_order_range(ac, i,
@@ -1001,7 +1013,7 @@ static int ext4_mb_scan_groups_goal_fast(struct ext4_allocation_context *ac,
 	ext4_group_t start, end;
 
 	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
 wrap_around:
 	i = mb_avg_fragment_size_order(ac->ac_sb, ac->ac_g_ex.fe_len);
 	for (; i < MB_NUM_ORDERS(ac->ac_sb); i++) {
@@ -1083,7 +1095,7 @@ static int ext4_mb_scan_groups_best_avail(struct ext4_allocation_context *ac,
 		min_order = fls(ac->ac_o_ex.fe_len);
 
 	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
 wrap_around:
 	for (i = order; i >= min_order; i--) {
 		int frag_order;
@@ -1182,11 +1194,7 @@ static int ext4_mb_scan_groups(struct ext4_allocation_context *ac)
 	int ret = 0;
 	ext4_group_t start;
 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
-	ext4_group_t ngroups = ext4_get_groups_count(ac->ac_sb);
-
-	/* non-extent files are limited to low blocks/groups */
-	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
-		ngroups = sbi->s_blockfile_groups;
+	ext4_group_t ngroups = ext4_get_allocation_groups_count(ac);
 
 	/* searching for the right group start from the goal value specified */
 	start = ac->ac_g_ex.fe_group;
Signature · 1 line
2.51.0
Reviewed-by on v2 1/2
#2 lore raw

Re: [PATCH 1/2] ext4: always allocate blocks only from groups inode can use

Quoted 10 lines · Jan Kara

For filesystems with more than 2^32 blocks inodes using indirect block based format cannot use blocks beyond the 32-bit limit. ext4_mb_scan_groups_linear() takes care to not select these unsupported groups for such inodes however other functions selecting groups for allocation don't. So far this is harmless because the other selection functions are used only with mb_optimize_scan and this is currently disabled for inodes with indirect blocks however in the following patch we want to enable mb_optimize_scan regardless of inode format.

Looks good, thanks for the patch!

Quoted 76 lines
---
 fs/ext4/mballoc.c | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)
fs/ext4/mballoc.c +17 -9
index 56d50fd3310b..f0e07bf11a93 100644
@@ -892,6 +892,18 @@ mb_update_avg_fragment_size(struct super_block *sb, struct ext4_group_info *grp)
 	}
 }
 
+static ext4_group_t ext4_get_allocation_groups_count(
+				struct ext4_allocation_context *ac)
+{
+	ext4_group_t ngroups = ext4_get_groups_count(ac->ac_sb);
+
+	/* non-extent files are limited to low blocks/groups */
+	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
+		ngroups = EXT4_SB(ac->ac_sb)->s_blockfile_groups;
+
+	return ngroups;
+}
+
 static int ext4_mb_scan_groups_xa_range(struct ext4_allocation_context *ac,
 					struct xarray *xa,
 					ext4_group_t start, ext4_group_t end)
@@ -899,7 +911,7 @@ static int ext4_mb_scan_groups_xa_range(struct ext4_allocation_context *ac,
 	struct super_block *sb = ac->ac_sb;
 	struct ext4_sb_info *sbi = EXT4_SB(sb);
 	enum criteria cr = ac->ac_criteria;
-	ext4_group_t ngroups = ext4_get_groups_count(sb);
+	ext4_group_t ngroups = ext4_get_allocation_groups_count(ac);
 	unsigned long group = start;
 	struct ext4_group_info *grp;
 
@@ -951,7 +963,7 @@ static int ext4_mb_scan_groups_p2_aligned(struct ext4_allocation_context *ac,
 	ext4_group_t start, end;
 
 	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
 wrap_around:
 	for (i = ac->ac_2order; i < MB_NUM_ORDERS(ac->ac_sb); i++) {
 		ret = ext4_mb_scan_groups_largest_free_order_range(ac, i,
@@ -1001,7 +1013,7 @@ static int ext4_mb_scan_groups_goal_fast(struct ext4_allocation_context *ac,
 	ext4_group_t start, end;
 
 	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
 wrap_around:
 	i = mb_avg_fragment_size_order(ac->ac_sb, ac->ac_g_ex.fe_len);
 	for (; i < MB_NUM_ORDERS(ac->ac_sb); i++) {
@@ -1083,7 +1095,7 @@ static int ext4_mb_scan_groups_best_avail(struct ext4_allocation_context *ac,
 		min_order = fls(ac->ac_o_ex.fe_len);
 
 	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
 wrap_around:
 	for (i = order; i >= min_order; i--) {
 		int frag_order;
@@ -1182,11 +1194,7 @@ static int ext4_mb_scan_groups(struct ext4_allocation_context *ac)
 	int ret = 0;
 	ext4_group_t start;
 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
-	ext4_group_t ngroups = ext4_get_groups_count(ac->ac_sb);
-
-	/* non-extent files are limited to low blocks/groups */
-	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
-		ngroups = sbi->s_blockfile_groups;
+	ext4_group_t ngroups = ext4_get_allocation_groups_count(ac);
 
 	/* searching for the right group start from the goal value specified */
 	start = ac->ac_g_ex.fe_group;
Reviewed-by on v2 1/2
#3 lore raw

Re: [PATCH 1/2] ext4: always allocate blocks only from groups inode can use

In reply to Jan Kara
Quoted 10 lines · Jan Kara

For filesystems with more than 2^32 blocks inodes using indirect block based format cannot use blocks beyond the 32-bit limit. ext4_mb_scan_groups_linear() takes care to not select these unsupported groups for such inodes however other functions selecting groups for allocation don't. So far this is harmless because the other selection functions are used only with mb_optimize_scan and this is currently disabled for inodes with indirect blocks however in the following patch we want to enable mb_optimize_scan regardless of inode format.

Looks good to me.

Quoted 76 lines
---
  fs/ext4/mballoc.c | 26 +++++++++++++++++---------
  1 file changed, 17 insertions(+), 9 deletions(-)
fs/ext4/mballoc.c +17 -9
index 56d50fd3310b..f0e07bf11a93 100644
@@ -892,6 +892,18 @@ mb_update_avg_fragment_size(struct super_block *sb, struct ext4_group_info *grp)
  	}
  }
 
+static ext4_group_t ext4_get_allocation_groups_count(
+				struct ext4_allocation_context *ac)
+{
+	ext4_group_t ngroups = ext4_get_groups_count(ac->ac_sb);
+
+	/* non-extent files are limited to low blocks/groups */
+	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
+		ngroups = EXT4_SB(ac->ac_sb)->s_blockfile_groups;
+
+	return ngroups;
+}
+
  static int ext4_mb_scan_groups_xa_range(struct ext4_allocation_context *ac,
  					struct xarray *xa,
  					ext4_group_t start, ext4_group_t end)
@@ -899,7 +911,7 @@ static int ext4_mb_scan_groups_xa_range(struct ext4_allocation_context *ac,
  	struct super_block *sb = ac->ac_sb;
  	struct ext4_sb_info *sbi = EXT4_SB(sb);
  	enum criteria cr = ac->ac_criteria;
-	ext4_group_t ngroups = ext4_get_groups_count(sb);
+	ext4_group_t ngroups = ext4_get_allocation_groups_count(ac);
  	unsigned long group = start;
  	struct ext4_group_info *grp;
 
@@ -951,7 +963,7 @@ static int ext4_mb_scan_groups_p2_aligned(struct ext4_allocation_context *ac,
  	ext4_group_t start, end;
 
  	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
  wrap_around:
  	for (i = ac->ac_2order; i < MB_NUM_ORDERS(ac->ac_sb); i++) {
  		ret = ext4_mb_scan_groups_largest_free_order_range(ac, i,
@@ -1001,7 +1013,7 @@ static int ext4_mb_scan_groups_goal_fast(struct ext4_allocation_context *ac,
  	ext4_group_t start, end;
 
  	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
  wrap_around:
  	i = mb_avg_fragment_size_order(ac->ac_sb, ac->ac_g_ex.fe_len);
  	for (; i < MB_NUM_ORDERS(ac->ac_sb); i++) {
@@ -1083,7 +1095,7 @@ static int ext4_mb_scan_groups_best_avail(struct ext4_allocation_context *ac,
  		min_order = fls(ac->ac_o_ex.fe_len);
 
  	start = group;
-	end = ext4_get_groups_count(ac->ac_sb);
+	end = ext4_get_allocation_groups_count(ac);
  wrap_around:
  	for (i = order; i >= min_order; i--) {
  		int frag_order;
@@ -1182,11 +1194,7 @@ static int ext4_mb_scan_groups(struct ext4_allocation_context *ac)
  	int ret = 0;
  	ext4_group_t start;
  	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
-	ext4_group_t ngroups = ext4_get_groups_count(ac->ac_sb);
-
-	/* non-extent files are limited to low blocks/groups */
-	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
-		ngroups = sbi->s_blockfile_groups;
+	ext4_group_t ngroups = ext4_get_allocation_groups_count(ac);
 
  	/* searching for the right group start from the goal value specified */
  	start = ac->ac_g_ex.fe_group;
#4 lore raw

Re: [PATCH 1/2] ext4: always allocate blocks only from groups inode can use

In reply to Jan Kara
Quoted 23 lines · Jan Kara

For filesystems with more than 2^32 blocks inodes using indirect block based format cannot use blocks beyond the 32-bit limit. ext4_mb_scan_groups_linear() takes care to not select these unsupported groups for such inodes however other functions selecting groups for allocation don't. So far this is harmless because the other selection functions are used only with mb_optimize_scan and this is currently disabled for inodes with indirect blocks however in the following patch we want to enable mb_optimize_scan regardless of inode format.

---
 fs/ext4/mballoc.c | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)
fs/ext4/mballoc.c +1 -0
index 56d50fd3310b..f0e07bf11a93 100644
@@ -892,6 +892,18 @@ mb_update_avg_fragment_size(struct super_block *sb, struct ext4_group_info *grp)
 	}
 }
 
+static ext4_group_t ext4_get_allocation_groups_count(

fs/ext4/mballoc.c mb_update_avg_fragment_size(struct super_block *sb, struct ext4_group_info *grp) · line 905

Quoted 10 lines
fs/ext4/mballoc.c +10 -0
+				struct ext4_allocation_context *ac)
+{
+	ext4_group_t ngroups = ext4_get_groups_count(ac->ac_sb);
+
+	/* non-extent files are limited to low blocks/groups */
+	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
+		ngroups = EXT4_SB(ac->ac_sb)->s_blockfile_groups;
+
+	return ngroups;
+}

I know you're mostly only moving code around, but I think I see a problem here. Namely, we (probably?) need an smp_rmb() right after the s_blockfile_groups read to pair with the one in ext4_update_super(). The pre-existing smp_rmb() in ext4_get_groups_acount() after the s_groups_count load perhaps *incidentally* works here, but it seems to me like we need a new barrier. So fundamentally something like:

static ext4_group_t ext4_get_allocation_groups_count(...)

{
	struct ext4_sb_info *sb = EXT4_SB(ac->ac_sb);
	ext4_group_t ngroups;

	ngroups = sb->s_groups_count;
	if (!ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS))
		ngroups = sb->s_blockfile_groups;
	/* pairs with ext4_group_add() logic */
	smp_rmb();
	return ngroups;
}

and to be even more technically correct, we probably want READ_ONCE() and WRITE_ONCE() here as well.

Does this make sense?

Signature · 1 line
Pedro
author reviewer
#5 lore raw

Re: [PATCH 1/2] ext4: always allocate blocks only from groups inode can use

Quoted 55 lines · Pedro Falcato
Quoted 23 lines · Jan Kara

For filesystems with more than 2^32 blocks inodes using indirect block based format cannot use blocks beyond the 32-bit limit. ext4_mb_scan_groups_linear() takes care to not select these unsupported groups for such inodes however other functions selecting groups for allocation don't. So far this is harmless because the other selection functions are used only with mb_optimize_scan and this is currently disabled for inodes with indirect blocks however in the following patch we want to enable mb_optimize_scan regardless of inode format.

---
 fs/ext4/mballoc.c | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)
fs/ext4/mballoc.c +1 -0
index 56d50fd3310b..f0e07bf11a93 100644
@@ -892,6 +892,18 @@ mb_update_avg_fragment_size(struct super_block *sb, struct ext4_group_info *grp)
 	}
 }
 
+static ext4_group_t ext4_get_allocation_groups_count(

fs/ext4/mballoc.c mb_update_avg_fragment_size(struct super_block *sb, struct ext4_group_info *grp) · line 905

Quoted 10 lines
fs/ext4/mballoc.c +10 -0
+				struct ext4_allocation_context *ac)
+{
+	ext4_group_t ngroups = ext4_get_groups_count(ac->ac_sb);
+
+	/* non-extent files are limited to low blocks/groups */
+	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
+		ngroups = EXT4_SB(ac->ac_sb)->s_blockfile_groups;
+
+	return ngroups;
+}

I know you're mostly only moving code around, but I think I see a problem here. Namely, we (probably?) need an smp_rmb() right after the s_blockfile_groups read to pair with the one in ext4_update_super(). The pre-existing smp_rmb() in ext4_get_groups_acount() after the s_groups_count load perhaps *incidentally* works here, but it seems to me like we need a new barrier. So fundamentally something like:

static ext4_group_t ext4_get_allocation_groups_count(...)

{
	struct ext4_sb_info *sb = EXT4_SB(ac->ac_sb);
	ext4_group_t ngroups;

	ngroups = sb->s_groups_count;
	if (!ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS))
		ngroups = sb->s_blockfile_groups;
	/* pairs with ext4_group_add() logic */
	smp_rmb();
	return ngroups;
}
Quoted 4 lines

and to be even more technically correct, we probably want READ_ONCE() and WRITE_ONCE() here as well.

Does this make sense?

I agree with both although I'd note this isn't strictly related to this patch as the problem is already preexisting in the code. I think smp_rmb() is good to add when we are touching the code, regarding READ_ONCE / WRITE_ONCE, that will require modifying all the places touching s_blockfile_groups / s_groups_count so I'd leave that for a separate series as that's going to be more intrusive.

Honza

Signature · 2 lines
Jan Kara <[email protected]>
SUSE Labs, CR
author reviewer
#6 lore raw

PATCH v2 2/2 ext4: use optimized mballoc scanning regardless of inode format

In reply to Jan Kara

Currently we don't used mballoc optimized scanning (using max free extent order and avg free extent order group lists) for inodes with indirect block based format. This is confusing for users and I don't see a good reason for that. Even with indirect block based inode format we can spend big amount of time searching for free blocks for large filesystems with fragmented free space. To add to the confusion before commit 077d0c2c78df ("ext4: make mb_optimize_scan performance mount option work with extents") optimized scanning was applied *only* to indirect block based inodes so that commit appears as a performance regression to some users. Just use optimized scanning whenever it is enabled by mount options.

---
 fs/ext4/mballoc.c | 2 --
 1 file changed, 2 deletions(-)
fs/ext4/mballoc.c +0 -2
index f0e07bf11a93..cd98c472631e 100644
@@ -1145,8 +1145,6 @@ static inline int should_optimize_scan(struct ext4_allocation_context *ac)
 		return 0;
 	if (ac->ac_criteria >= CR_GOAL_LEN_SLOW)
 		return 0;
-	if (!ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS))
-		return 0;
 	return 1;
 }
 
Signature · 1 line
2.51.0
Reviewed-by on v2 2/2
#7 lore raw

Re: [PATCH 2/2] ext4: use optimized mballoc scanning regardless of inode format

Quoted 12 lines · Jan Kara

Currently we don't used mballoc optimized scanning (using max free extent order and avg free extent order group lists) for inodes with indirect block based format. This is confusing for users and I don't see a good reason for that. Even with indirect block based inode format we can spend big amount of time searching for free blocks for large filesystems with fragmented free space. To add to the confusion before commit 077d0c2c78df ("ext4: make mb_optimize_scan performance mount option work with extents") optimized scanning was applied *only* to indirect block based inodes so that commit appears as a performance regression to some users. Just use optimized scanning whenever it is enabled by mount options.

Quoted 1 line

Makes sense. Feel free to add:

Quoted 17 lines
---
 fs/ext4/mballoc.c | 2 --
 1 file changed, 2 deletions(-)
fs/ext4/mballoc.c +0 -2
index f0e07bf11a93..cd98c472631e 100644
@@ -1145,8 +1145,6 @@ static inline int should_optimize_scan(struct ext4_allocation_context *ac)
 		return 0;
 	if (ac->ac_criteria >= CR_GOAL_LEN_SLOW)
 		return 0;
-	if (!ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS))
-		return 0;
 	return 1;
 }
 
Reviewed-by on v2 2/2
#8 lore raw

Re: [PATCH 2/2] ext4: use optimized mballoc scanning regardless of inode format

In reply to Jan Kara
Quoted 12 lines · Jan Kara

Currently we don't used mballoc optimized scanning (using max free extent order and avg free extent order group lists) for inodes with indirect block based format. This is confusing for users and I don't see a good reason for that. Even with indirect block based inode format we can spend big amount of time searching for free blocks for large filesystems with fragmented free space. To add to the confusion before commit 077d0c2c78df ("ext4: make mb_optimize_scan performance mount option work with extents") optimized scanning was applied *only* to indirect block based inodes so that commit appears as a performance regression to some users. Just use optimized scanning whenever it is enabled by mount options.

Quoted 1 line

Makes sense to me.

Quoted 17 lines
---
  fs/ext4/mballoc.c | 2 --
  1 file changed, 2 deletions(-)
fs/ext4/mballoc.c +0 -2
index f0e07bf11a93..cd98c472631e 100644
@@ -1145,8 +1145,6 @@ static inline int should_optimize_scan(struct ext4_allocation_context *ac)
  		return 0;
  	if (ac->ac_criteria >= CR_GOAL_LEN_SLOW)
  		return 0;
-	if (!ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS))
-		return 0;
  	return 1;
  }