| Message ID | 0517cef1682fc1f344343c494ac769b963f94199.1730437365.git.ritesh.list@gmail.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | ext4: Add atomic writes support for DIO | expand |
On Fri 01-11-24 12:20:51, Ritesh Harjani (IBM) wrote: > This patch adds base support for atomic writes via statx getattr. > On bs < ps systems, we can create FS with say bs of 16k. That means > both atomic write min and max unit can be set to 16k for supporting > atomic writes. > > Co-developed-by: Ojaswin Mujoo <ojaswin@linux.ibm.com> > Signed-off-by: Ojaswin Mujoo <ojaswin@linux.ibm.com> > Signed-off-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com> I guess this is a good start. Feel free to add: Reviewed-by: Jan Kara <jack@suse.cz> Honza > --- > fs/ext4/ext4.h | 10 ++++++++++ > fs/ext4/inode.c | 12 ++++++++++++ > fs/ext4/super.c | 31 +++++++++++++++++++++++++++++++ > 3 files changed, 53 insertions(+) > > diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h > index 44b0d418143c..494d443e9fc9 100644 > --- a/fs/ext4/ext4.h > +++ b/fs/ext4/ext4.h > @@ -1729,6 +1729,10 @@ struct ext4_sb_info { > */ > struct work_struct s_sb_upd_work; > > + /* Atomic write unit values in bytes */ > + unsigned int s_awu_min; > + unsigned int s_awu_max; > + > /* Ext4 fast commit sub transaction ID */ > atomic_t s_fc_subtid; > > @@ -3855,6 +3859,12 @@ static inline int ext4_buffer_uptodate(struct buffer_head *bh) > return buffer_uptodate(bh); > } > > +static inline bool ext4_inode_can_atomic_write(struct inode *inode) > +{ > + > + return S_ISREG(inode->i_mode) && EXT4_SB(inode->i_sb)->s_awu_min > 0; > +} > + > extern int ext4_block_write_begin(handle_t *handle, struct folio *folio, > loff_t pos, unsigned len, > get_block_t *get_block); > diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c > index 54bdd4884fe6..3e827cfa762e 100644 > --- a/fs/ext4/inode.c > +++ b/fs/ext4/inode.c > @@ -5578,6 +5578,18 @@ int ext4_getattr(struct mnt_idmap *idmap, const struct path *path, > } > } > > + if ((request_mask & STATX_WRITE_ATOMIC) && S_ISREG(inode->i_mode)) { > + struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); > + unsigned int awu_min = 0, awu_max = 0; > + > + if (ext4_inode_can_atomic_write(inode)) { > + awu_min = sbi->s_awu_min; > + awu_max = sbi->s_awu_max; > + } > + > + generic_fill_statx_atomic_writes(stat, awu_min, awu_max); > + } > + > flags = ei->i_flags & EXT4_FL_USER_VISIBLE; > if (flags & EXT4_APPEND_FL) > stat->attributes |= STATX_ATTR_APPEND; > diff --git a/fs/ext4/super.c b/fs/ext4/super.c > index 16a4ce704460..ebe1660bd840 100644 > --- a/fs/ext4/super.c > +++ b/fs/ext4/super.c > @@ -4425,6 +4425,36 @@ static int ext4_handle_clustersize(struct super_block *sb) > return 0; > } > > +/* > + * ext4_atomic_write_init: Initializes filesystem min & max atomic write units. > + * @sb: super block > + * TODO: Later add support for bigalloc > + */ > +static void ext4_atomic_write_init(struct super_block *sb) > +{ > + struct ext4_sb_info *sbi = EXT4_SB(sb); > + struct block_device *bdev = sb->s_bdev; > + > + if (!bdev_can_atomic_write(bdev)) > + return; > + > + if (!ext4_has_feature_extents(sb)) > + return; > + > + sbi->s_awu_min = max(sb->s_blocksize, > + bdev_atomic_write_unit_min_bytes(bdev)); > + sbi->s_awu_max = min(sb->s_blocksize, > + bdev_atomic_write_unit_max_bytes(bdev)); > + if (sbi->s_awu_min && sbi->s_awu_max && > + sbi->s_awu_min <= sbi->s_awu_max) { > + ext4_msg(sb, KERN_NOTICE, "Supports (experimental) DIO atomic writes awu_min: %u, awu_max: %u", > + sbi->s_awu_min, sbi->s_awu_max); > + } else { > + sbi->s_awu_min = 0; > + sbi->s_awu_max = 0; > + } > +} > + > static void ext4_fast_commit_init(struct super_block *sb) > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > @@ -5336,6 +5366,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) > > spin_lock_init(&sbi->s_bdev_wb_lock); > > + ext4_atomic_write_init(sb); > ext4_fast_commit_init(sb); > > sb->s_root = NULL; > -- > 2.46.0 >
On Fri, Nov 01, 2024 at 12:20:51PM +0530, Ritesh Harjani (IBM) wrote: > This patch adds base support for atomic writes via statx getattr. > On bs < ps systems, we can create FS with say bs of 16k. That means > both atomic write min and max unit can be set to 16k for supporting > atomic writes. > > Co-developed-by: Ojaswin Mujoo <ojaswin@linux.ibm.com> > Signed-off-by: Ojaswin Mujoo <ojaswin@linux.ibm.com> > Signed-off-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com> Looks good to me, Reviewed-by: Darrick J. Wong <djwong@kernel.org> --D > --- > fs/ext4/ext4.h | 10 ++++++++++ > fs/ext4/inode.c | 12 ++++++++++++ > fs/ext4/super.c | 31 +++++++++++++++++++++++++++++++ > 3 files changed, 53 insertions(+) > > diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h > index 44b0d418143c..494d443e9fc9 100644 > --- a/fs/ext4/ext4.h > +++ b/fs/ext4/ext4.h > @@ -1729,6 +1729,10 @@ struct ext4_sb_info { > */ > struct work_struct s_sb_upd_work; > > + /* Atomic write unit values in bytes */ > + unsigned int s_awu_min; > + unsigned int s_awu_max; > + > /* Ext4 fast commit sub transaction ID */ > atomic_t s_fc_subtid; > > @@ -3855,6 +3859,12 @@ static inline int ext4_buffer_uptodate(struct buffer_head *bh) > return buffer_uptodate(bh); > } > > +static inline bool ext4_inode_can_atomic_write(struct inode *inode) > +{ > + > + return S_ISREG(inode->i_mode) && EXT4_SB(inode->i_sb)->s_awu_min > 0; > +} > + > extern int ext4_block_write_begin(handle_t *handle, struct folio *folio, > loff_t pos, unsigned len, > get_block_t *get_block); > diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c > index 54bdd4884fe6..3e827cfa762e 100644 > --- a/fs/ext4/inode.c > +++ b/fs/ext4/inode.c > @@ -5578,6 +5578,18 @@ int ext4_getattr(struct mnt_idmap *idmap, const struct path *path, > } > } > > + if ((request_mask & STATX_WRITE_ATOMIC) && S_ISREG(inode->i_mode)) { > + struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); > + unsigned int awu_min = 0, awu_max = 0; > + > + if (ext4_inode_can_atomic_write(inode)) { > + awu_min = sbi->s_awu_min; > + awu_max = sbi->s_awu_max; > + } > + > + generic_fill_statx_atomic_writes(stat, awu_min, awu_max); > + } > + > flags = ei->i_flags & EXT4_FL_USER_VISIBLE; > if (flags & EXT4_APPEND_FL) > stat->attributes |= STATX_ATTR_APPEND; > diff --git a/fs/ext4/super.c b/fs/ext4/super.c > index 16a4ce704460..ebe1660bd840 100644 > --- a/fs/ext4/super.c > +++ b/fs/ext4/super.c > @@ -4425,6 +4425,36 @@ static int ext4_handle_clustersize(struct super_block *sb) > return 0; > } > > +/* > + * ext4_atomic_write_init: Initializes filesystem min & max atomic write units. > + * @sb: super block > + * TODO: Later add support for bigalloc > + */ > +static void ext4_atomic_write_init(struct super_block *sb) > +{ > + struct ext4_sb_info *sbi = EXT4_SB(sb); > + struct block_device *bdev = sb->s_bdev; > + > + if (!bdev_can_atomic_write(bdev)) > + return; > + > + if (!ext4_has_feature_extents(sb)) > + return; > + > + sbi->s_awu_min = max(sb->s_blocksize, > + bdev_atomic_write_unit_min_bytes(bdev)); > + sbi->s_awu_max = min(sb->s_blocksize, > + bdev_atomic_write_unit_max_bytes(bdev)); > + if (sbi->s_awu_min && sbi->s_awu_max && > + sbi->s_awu_min <= sbi->s_awu_max) { > + ext4_msg(sb, KERN_NOTICE, "Supports (experimental) DIO atomic writes awu_min: %u, awu_max: %u", > + sbi->s_awu_min, sbi->s_awu_max); > + } else { > + sbi->s_awu_min = 0; > + sbi->s_awu_max = 0; > + } > +} > + > static void ext4_fast_commit_init(struct super_block *sb) > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > @@ -5336,6 +5366,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) > > spin_lock_init(&sbi->s_bdev_wb_lock); > > + ext4_atomic_write_init(sb); > ext4_fast_commit_init(sb); > > sb->s_root = NULL; > -- > 2.46.0 > >
On 01/11/2024 06:50, Ritesh Harjani (IBM) wrote: > This patch adds base support for atomic writes via statx getattr. > On bs < ps systems, we can create FS with say bs of 16k. That means > both atomic write min and max unit can be set to 16k for supporting > atomic writes. > > Co-developed-by: Ojaswin Mujoo <ojaswin@linux.ibm.com> > Signed-off-by: Ojaswin Mujoo <ojaswin@linux.ibm.com> > Signed-off-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com> Regardless of nitpicks: Reviewed-by: John Garry <john.g.garry@oracle.com> > --- > fs/ext4/ext4.h | 10 ++++++++++ > fs/ext4/inode.c | 12 ++++++++++++ > fs/ext4/super.c | 31 +++++++++++++++++++++++++++++++ > 3 files changed, 53 insertions(+) > > diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h > index 44b0d418143c..494d443e9fc9 100644 > --- a/fs/ext4/ext4.h > +++ b/fs/ext4/ext4.h > @@ -1729,6 +1729,10 @@ struct ext4_sb_info { > */ > struct work_struct s_sb_upd_work; > > + /* Atomic write unit values in bytes */ > + unsigned int s_awu_min; > + unsigned int s_awu_max; > + > /* Ext4 fast commit sub transaction ID */ > atomic_t s_fc_subtid; > > @@ -3855,6 +3859,12 @@ static inline int ext4_buffer_uptodate(struct buffer_head *bh) > return buffer_uptodate(bh); > } > > +static inline bool ext4_inode_can_atomic_write(struct inode *inode) > +{ > + nit: superfluous blank line > + return S_ISREG(inode->i_mode) && EXT4_SB(inode->i_sb)->s_awu_min > 0; I am not sure if the S_ISREG() check is required. Other callers also do the check (like ext4_getattr() for when calling ext4_inode_can_atomic_write()) or don't need it (ext4_file_open()). I say ext4_file_open() doesn't need it as ext4_file_open() is only ever called for regular files, right? > +} > + > extern int ext4_block_write_begin(handle_t *handle, struct folio *folio, > loff_t pos, unsigned len, > get_block_t *get_block); > diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c > index 54bdd4884fe6..3e827cfa762e 100644 > --- a/fs/ext4/inode.c > +++ b/fs/ext4/inode.c > @@ -5578,6 +5578,18 @@ int ext4_getattr(struct mnt_idmap *idmap, const struct path *path, > } > } > > + if ((request_mask & STATX_WRITE_ATOMIC) && S_ISREG(inode->i_mode)) { nit: maybe you could have factored out the S_ISREG() check with STATX_DIOALIGN > + struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); > + unsigned int awu_min = 0, awu_max = 0; > + > + if (ext4_inode_can_atomic_write(inode)) { > + awu_min = sbi->s_awu_min; > + awu_max = sbi->s_awu_max; > + } > + > + generic_fill_statx_atomic_writes(stat, awu_min, awu_max); > + } > + > flags = ei->i_flags & EXT4_FL_USER_VISIBLE; > if (flags & EXT4_APPEND_FL) > stat->attributes |= STATX_ATTR_APPEND; > diff --git a/fs/ext4/super.c b/fs/ext4/super.c > index 16a4ce704460..ebe1660bd840 100644 > --- a/fs/ext4/super.c > +++ b/fs/ext4/super.c > @@ -4425,6 +4425,36 @@ static int ext4_handle_clustersize(struct super_block *sb) > return 0; > } > > +/* > + * ext4_atomic_write_init: Initializes filesystem min & max atomic write units. > + * @sb: super block > + * TODO: Later add support for bigalloc > + */ > +static void ext4_atomic_write_init(struct super_block *sb) > +{ > + struct ext4_sb_info *sbi = EXT4_SB(sb); > + struct block_device *bdev = sb->s_bdev; > + > + if (!bdev_can_atomic_write(bdev)) > + return; > + > + if (!ext4_has_feature_extents(sb)) > + return; > + > + sbi->s_awu_min = max(sb->s_blocksize, > + bdev_atomic_write_unit_min_bytes(bdev)); > + sbi->s_awu_max = min(sb->s_blocksize, > + bdev_atomic_write_unit_max_bytes(bdev)); > + if (sbi->s_awu_min && sbi->s_awu_max && > + sbi->s_awu_min <= sbi->s_awu_max) { > + ext4_msg(sb, KERN_NOTICE, "Supports (experimental) DIO atomic writes awu_min: %u, awu_max: %u", > + sbi->s_awu_min, sbi->s_awu_max); > + } else { > + sbi->s_awu_min = 0; > + sbi->s_awu_max = 0; > + } > +} > + > static void ext4_fast_commit_init(struct super_block *sb) > { > struct ext4_sb_info *sbi = EXT4_SB(sb); > @@ -5336,6 +5366,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) > > spin_lock_init(&sbi->s_bdev_wb_lock); > > + ext4_atomic_write_init(sb); > ext4_fast_commit_init(sb); > > sb->s_root = NULL;
John Garry <john.g.garry@oracle.com> writes: > On 01/11/2024 06:50, Ritesh Harjani (IBM) wrote: >> This patch adds base support for atomic writes via statx getattr. >> On bs < ps systems, we can create FS with say bs of 16k. That means >> both atomic write min and max unit can be set to 16k for supporting >> atomic writes. >> >> Co-developed-by: Ojaswin Mujoo <ojaswin@linux.ibm.com> >> Signed-off-by: Ojaswin Mujoo <ojaswin@linux.ibm.com> >> Signed-off-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com> > > Regardless of nitpicks: > > Reviewed-by: John Garry <john.g.garry@oracle.com> > Thanks John for the review! Since as you too mentioned the remaining points are minor and not critical review comments, I will address them next time in the multi-fsblock variant. With all other aspects now finalized in this v4 version, this looks ready to be picked up for the merge window. -ritesh >> --- >> fs/ext4/ext4.h | 10 ++++++++++ >> fs/ext4/inode.c | 12 ++++++++++++ >> fs/ext4/super.c | 31 +++++++++++++++++++++++++++++++ >> 3 files changed, 53 insertions(+) >> >> diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h >> index 44b0d418143c..494d443e9fc9 100644 >> --- a/fs/ext4/ext4.h >> +++ b/fs/ext4/ext4.h >> @@ -1729,6 +1729,10 @@ struct ext4_sb_info { >> */ >> struct work_struct s_sb_upd_work; >> >> + /* Atomic write unit values in bytes */ >> + unsigned int s_awu_min; >> + unsigned int s_awu_max; >> + >> /* Ext4 fast commit sub transaction ID */ >> atomic_t s_fc_subtid; >> >> @@ -3855,6 +3859,12 @@ static inline int ext4_buffer_uptodate(struct buffer_head *bh) >> return buffer_uptodate(bh); >> } >> >> +static inline bool ext4_inode_can_atomic_write(struct inode *inode) >> +{ >> + > > nit: superfluous blank line > Sure. >> + return S_ISREG(inode->i_mode) && EXT4_SB(inode->i_sb)->s_awu_min > 0; > > I am not sure if the S_ISREG() check is required. Other callers also do > the check (like ext4_getattr() for when calling > ext4_inode_can_atomic_write()) or don't need it (ext4_file_open()). I > say ext4_file_open() doesn't need it as ext4_file_open() is only ever > called for regular files, right? > Yes. However I believe we might end up using this from other places when we add support of extsize. So we might need S_ISREG check. But sure let me re-think on that during the multi-fsblock variant time. >> +} >> + >> extern int ext4_block_write_begin(handle_t *handle, struct folio *folio, >> loff_t pos, unsigned len, >> get_block_t *get_block); >> diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c >> index 54bdd4884fe6..3e827cfa762e 100644 >> --- a/fs/ext4/inode.c >> +++ b/fs/ext4/inode.c >> @@ -5578,6 +5578,18 @@ int ext4_getattr(struct mnt_idmap *idmap, const struct path *path, >> } >> } >> >> + if ((request_mask & STATX_WRITE_ATOMIC) && S_ISREG(inode->i_mode)) { > > nit: maybe you could have factored out the S_ISREG() check with > STATX_DIOALIGN > Sure. >> + struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); >> + unsigned int awu_min = 0, awu_max = 0; >> + >> + if (ext4_inode_can_atomic_write(inode)) { >> + awu_min = sbi->s_awu_min; >> + awu_max = sbi->s_awu_max; >> + } >> + >> + generic_fill_statx_atomic_writes(stat, awu_min, awu_max); >> + } >> + >> flags = ei->i_flags & EXT4_FL_USER_VISIBLE; >> if (flags & EXT4_APPEND_FL) >> stat->attributes |= STATX_ATTR_APPEND; >> diff --git a/fs/ext4/super.c b/fs/ext4/super.c >> index 16a4ce704460..ebe1660bd840 100644 >> --- a/fs/ext4/super.c >> +++ b/fs/ext4/super.c >> @@ -4425,6 +4425,36 @@ static int ext4_handle_clustersize(struct super_block *sb) >> return 0; >> } >> >> +/* >> + * ext4_atomic_write_init: Initializes filesystem min & max atomic write units. >> + * @sb: super block >> + * TODO: Later add support for bigalloc >> + */ >> +static void ext4_atomic_write_init(struct super_block *sb) >> +{ >> + struct ext4_sb_info *sbi = EXT4_SB(sb); >> + struct block_device *bdev = sb->s_bdev; >> + >> + if (!bdev_can_atomic_write(bdev)) >> + return; >> + >> + if (!ext4_has_feature_extents(sb)) >> + return; >> + >> + sbi->s_awu_min = max(sb->s_blocksize, >> + bdev_atomic_write_unit_min_bytes(bdev)); >> + sbi->s_awu_max = min(sb->s_blocksize, >> + bdev_atomic_write_unit_max_bytes(bdev)); >> + if (sbi->s_awu_min && sbi->s_awu_max && >> + sbi->s_awu_min <= sbi->s_awu_max) { >> + ext4_msg(sb, KERN_NOTICE, "Supports (experimental) DIO atomic writes awu_min: %u, awu_max: %u", >> + sbi->s_awu_min, sbi->s_awu_max); >> + } else { >> + sbi->s_awu_min = 0; >> + sbi->s_awu_max = 0; >> + } >> +} >> + >> static void ext4_fast_commit_init(struct super_block *sb) >> { >> struct ext4_sb_info *sbi = EXT4_SB(sb); >> @@ -5336,6 +5366,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) >> >> spin_lock_init(&sbi->s_bdev_wb_lock); >> >> + ext4_atomic_write_init(sb); >> ext4_fast_commit_init(sb); >> >> sb->s_root = NULL;
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h index 44b0d418143c..494d443e9fc9 100644 --- a/fs/ext4/ext4.h +++ b/fs/ext4/ext4.h @@ -1729,6 +1729,10 @@ struct ext4_sb_info { */ struct work_struct s_sb_upd_work; + /* Atomic write unit values in bytes */ + unsigned int s_awu_min; + unsigned int s_awu_max; + /* Ext4 fast commit sub transaction ID */ atomic_t s_fc_subtid; @@ -3855,6 +3859,12 @@ static inline int ext4_buffer_uptodate(struct buffer_head *bh) return buffer_uptodate(bh); } +static inline bool ext4_inode_can_atomic_write(struct inode *inode) +{ + + return S_ISREG(inode->i_mode) && EXT4_SB(inode->i_sb)->s_awu_min > 0; +} + extern int ext4_block_write_begin(handle_t *handle, struct folio *folio, loff_t pos, unsigned len, get_block_t *get_block); diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index 54bdd4884fe6..3e827cfa762e 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@ -5578,6 +5578,18 @@ int ext4_getattr(struct mnt_idmap *idmap, const struct path *path, } } + if ((request_mask & STATX_WRITE_ATOMIC) && S_ISREG(inode->i_mode)) { + struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); + unsigned int awu_min = 0, awu_max = 0; + + if (ext4_inode_can_atomic_write(inode)) { + awu_min = sbi->s_awu_min; + awu_max = sbi->s_awu_max; + } + + generic_fill_statx_atomic_writes(stat, awu_min, awu_max); + } + flags = ei->i_flags & EXT4_FL_USER_VISIBLE; if (flags & EXT4_APPEND_FL) stat->attributes |= STATX_ATTR_APPEND; diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 16a4ce704460..ebe1660bd840 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -4425,6 +4425,36 @@ static int ext4_handle_clustersize(struct super_block *sb) return 0; } +/* + * ext4_atomic_write_init: Initializes filesystem min & max atomic write units. + * @sb: super block + * TODO: Later add support for bigalloc + */ +static void ext4_atomic_write_init(struct super_block *sb) +{ + struct ext4_sb_info *sbi = EXT4_SB(sb); + struct block_device *bdev = sb->s_bdev; + + if (!bdev_can_atomic_write(bdev)) + return; + + if (!ext4_has_feature_extents(sb)) + return; + + sbi->s_awu_min = max(sb->s_blocksize, + bdev_atomic_write_unit_min_bytes(bdev)); + sbi->s_awu_max = min(sb->s_blocksize, + bdev_atomic_write_unit_max_bytes(bdev)); + if (sbi->s_awu_min && sbi->s_awu_max && + sbi->s_awu_min <= sbi->s_awu_max) { + ext4_msg(sb, KERN_NOTICE, "Supports (experimental) DIO atomic writes awu_min: %u, awu_max: %u", + sbi->s_awu_min, sbi->s_awu_max); + } else { + sbi->s_awu_min = 0; + sbi->s_awu_max = 0; + } +} + static void ext4_fast_commit_init(struct super_block *sb) { struct ext4_sb_info *sbi = EXT4_SB(sb); @@ -5336,6 +5366,7 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) spin_lock_init(&sbi->s_bdev_wb_lock); + ext4_atomic_write_init(sb); ext4_fast_commit_init(sb); sb->s_root = NULL;