hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ext4: trigger the lazy inode table initialization after resize 

After we have finished extending the file system, we need to trigger a
the lazy inode table thread to zero out the inode tables.

Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
This commit is contained in:
Theodore Ts'o 2013-01-13 08:41:45 -05:00
parent 15b49132fc
commit 7f5118629f
4 changed files with 27 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/ext4/ext4.h
View File

@ -2227,6 +2227,8 @@ extern int ext4_group_desc_csum_verify(struct super_block *sb, __u32 group,
struct ext4_group_desc *gdp); struct ext4_group_desc *gdp);
extern void ext4_group_desc_csum_set(struct super_block *sb, __u32 group, extern void ext4_group_desc_csum_set(struct super_block *sb, __u32 group,
struct ext4_group_desc *gdp); struct ext4_group_desc *gdp);
extern int ext4_register_li_request(struct super_block *sb,
ext4_group_t first_not_zeroed);
static inline int ext4_has_group_desc_csum(struct super_block *sb) static inline int ext4_has_group_desc_csum(struct super_block *sb)
{ {

9
fs/ext4/ioctl.c
View File

@ -313,6 +313,9 @@ mext_out:
if (err == 0) if (err == 0)
err = err2; err = err2;
mnt_drop_write_file(filp); mnt_drop_write_file(filp);
if (!err && ext4_has_group_desc_csum(sb) &&
test_opt(sb, INIT_INODE_TABLE))
err = ext4_register_li_request(sb, input.group);
group_add_out: group_add_out:
ext4_resize_end(sb); ext4_resize_end(sb);
return err; return err;
@ -358,6 +361,7 @@ group_add_out:
ext4_fsblk_t n_blocks_count; ext4_fsblk_t n_blocks_count;
struct super_block *sb = inode->i_sb; struct super_block *sb = inode->i_sb;
int err = 0, err2 = 0; int err = 0, err2 = 0;
ext4_group_t o_group = EXT4_SB(sb)->s_groups_count;
if (EXT4_HAS_RO_COMPAT_FEATURE(sb, if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
EXT4_FEATURE_RO_COMPAT_BIGALLOC)) { EXT4_FEATURE_RO_COMPAT_BIGALLOC)) {
@ -388,6 +392,11 @@ group_add_out:
if (err == 0) if (err == 0)
err = err2; err = err2;
mnt_drop_write_file(filp); mnt_drop_write_file(filp);
if (!err && (o_group > EXT4_SB(sb)->s_groups_count) &&
ext4_has_group_desc_csum(sb) &&
test_opt(sb, INIT_INODE_TABLE))
err = ext4_register_li_request(sb, o_group);
resizefs_out: resizefs_out:
ext4_resize_end(sb); ext4_resize_end(sb);
return err; return err;

8
fs/ext4/resize.c
View File

@ -1506,10 +1506,12 @@ static int ext4_setup_next_flex_gd(struct super_block *sb,
group_data[i].blocks_count = blocks_per_group; group_data[i].blocks_count = blocks_per_group;
overhead = ext4_group_overhead_blocks(sb, group + i); overhead = ext4_group_overhead_blocks(sb, group + i);
group_data[i].free_blocks_count = blocks_per_group - overhead; group_data[i].free_blocks_count = blocks_per_group - overhead;
if (ext4_has_group_desc_csum(sb)) if (ext4_has_group_desc_csum(sb)) {
flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT | flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT |
EXT4_BG_INODE_UNINIT; EXT4_BG_INODE_UNINIT;
else if (!test_opt(sb, INIT_INODE_TABLE))
flex_gd->bg_flags[i] |= EXT4_BG_INODE_ZEROED;
} else
flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED; flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED;
} }
@ -1594,7 +1596,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
err = ext4_alloc_flex_bg_array(sb, input->group + 1); err = ext4_alloc_flex_bg_array(sb, input->group + 1);
if (err) if (err)
return err; goto out;
err = ext4_mb_alloc_groupinfo(sb, input->group + 1); err = ext4_mb_alloc_groupinfo(sb, input->group + 1);
if (err) if (err)

21
fs/ext4/super.c
View File

@ -2776,7 +2776,7 @@ static int ext4_run_li_request(struct ext4_li_request *elr)
break; break;
} }
if (group == ngroups) if (group >= ngroups)
ret = 1; ret = 1;
if (!ret) { if (!ret) {
@ -3016,33 +3016,34 @@ static struct ext4_li_request *ext4_li_request_new(struct super_block *sb,
return elr; return elr;
} }
static int ext4_register_li_request(struct super_block *sb, int ext4_register_li_request(struct super_block *sb,
ext4_group_t first_not_zeroed) ext4_group_t first_not_zeroed)
{ {
struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_sb_info *sbi = EXT4_SB(sb);
struct ext4_li_request *elr; struct ext4_li_request *elr = NULL;
ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count; ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
int ret = 0; int ret = 0;
mutex_lock(&ext4_li_mtx);
if (sbi->s_li_request != NULL) { if (sbi->s_li_request != NULL) {
/* /*
* Reset timeout so it can be computed again, because * Reset timeout so it can be computed again, because
* s_li_wait_mult might have changed. * s_li_wait_mult might have changed.
*/ */
sbi->s_li_request->lr_timeout = 0; sbi->s_li_request->lr_timeout = 0;
return 0; goto out;
} }
if (first_not_zeroed == ngroups || if (first_not_zeroed == ngroups ||
(sb->s_flags & MS_RDONLY) || (sb->s_flags & MS_RDONLY) ||
!test_opt(sb, INIT_INODE_TABLE)) !test_opt(sb, INIT_INODE_TABLE))
return 0; goto out;
elr = ext4_li_request_new(sb, first_not_zeroed); elr = ext4_li_request_new(sb, first_not_zeroed);
if (!elr) if (!elr) {
return -ENOMEM; ret = -ENOMEM;
goto out;
mutex_lock(&ext4_li_mtx); }
if (NULL == ext4_li_info) { if (NULL == ext4_li_info) {
ret = ext4_li_info_new(); ret = ext4_li_info_new();