f2fs: prevent atomic file from being dirtied before commit
PATCH 1/1 f2fs: prevent atomic file from being dirtied before commit
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)
fs/f2fs/f2fs.h +1 -2
@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */
@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }
fs/f2fs/inode.c +6 -4
@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))return ; +if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }
@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);
fs/f2fs/segment.c +8 -2
@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;
@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);
Signature · 1 line
2.46.0.295.g3b9ea8a38a-goog
This patch was applied to jaegeuk/f2fs.git (dev) by Jaegeuk Kim <[email protected]>:
Hello:
This patch was applied to jaegeuk/f2fs.git (dev)
by Jaegeuk Kim <[email protected]>:
Quoted 10 lines · On Mon, 26 Aug 2024 13:23:52 -0700 you wrote:
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>[...]
Here is the summary with links:
- [f2fs-dev] f2fs: prevent atomic file from being dirtied before commit
https://git.kernel.org/jaegeuk/f2fs/c/a433a8f0eb31
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html
Chao Yu
maintainerQuoted 40 lines · Daeho Jeong
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +1
-2@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }fs/f2fs/inode.c +0
-0
fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 35
Quoted 1 line
fs/f2fs/inode.c +0
-0@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))
It will return directly here if inode was dirtied, so it may missed to set FI_ATOMIC_DIRTIED flag?
Thanks,
Quoted 52 lines
fs/f2fs/inode.c +6
-4return ; +if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);fs/f2fs/segment.c +8
-2@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);
Quoted 38 lines · Chao Yu
Quoted 36 lines · Daeho Jeong
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +1
-2@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }fs/f2fs/inode.c +0
-0
Quoted 8 lines
fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 35
Quoted 5 lines
index
1eb250c6b392..5dd3e55d2be2100644fs/f2fs/inode.c +0
-0@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))It will return directly here if inode was dirtied, so it may missed to set
FI_ATOMIC_DIRTIEDflag?
Is it possible for it to be already dirty, since we already made it clean with f2fs_write_inode() when we started the atomic write?
Quoted 56 lines
Thanks,
Quoted 52 lines
fs/f2fs/inode.c +6
-4return ; +if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);fs/f2fs/segment.c +8
-2@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);
Chao Yu
maintainerQuoted 48 lines · Daeho Jeong
Quoted 38 lines · Chao Yu
Quoted 36 lines · Daeho Jeong
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +1
-2@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }fs/f2fs/inode.c +0
-0Quoted 8 lines
fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 35
Quoted 5 lines
index
1eb250c6b392..5dd3e55d2be2100644fs/f2fs/inode.c +0
-0@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))It will return directly here if inode was dirtied, so it may missed to set
FI_ATOMIC_DIRTIEDflag?
Quoted 2 lines
Is it possible for it to be already dirty, since we already made it clean with
f2fs_write_inode()when we started the atomic write?
Some ioctl interfaces may race w/ atomic write? e.g. set_pin_file won't check atomic_file status, and may dirty inode after we started atomic write, so we'd better detect such race condition and break ioctl to avoid ruin atomic write? and maybe we can add f2fs_bug_on() in f2fs_mark_inode_dirty_sync() to detect any other missing cases?
Thanks,
Quoted 57 lines
Quoted 57 lines
Thanks,
Quoted 52 lines
fs/f2fs/inode.c +6
-4return ; +if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);fs/f2fs/segment.c +8
-2@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);
Quoted 50 lines · Chao Yu
Quoted 48 lines · Daeho Jeong
Quoted 46 lines · Chao Yu
Quoted 40 lines · Daeho Jeong
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +1
-2@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }fs/f2fs/inode.c +0
-0fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 35
Quoted 1 line
fs/f2fs/inode.c +0
-0@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))It will return directly here if inode was dirtied, so it may missed to set
FI_ATOMIC_DIRTIEDflag?
Quoted 9 lines
Quoted 2 lines
Is it possible for it to be already dirty, since we already made it clean with
f2fs_write_inode()when we started the atomic write?Some ioctl interfaces may race w/ atomic write? e.g.
set_pin_filewon't checkatomic_filestatus, and may dirty inode after we started atomic write, so we'd better detect such race condition and break ioctl to avoid ruin atomic write? and maybe we can addf2fs_bug_on()inf2fs_mark_inode_dirty_sync()to detect any other missing cases?
How about exchanging the positions of f2fs_write_inode() and set_inode_flag() in f2fs_ioc_start_atomic_write()?
...
f2fs_write_inode(inode, NULL);
stat_inc_atomic_inode(inode);
set_inode_flag(inode, FI_ATOMIC_FILE);...
Quoted 60 lines
Thanks,
Quoted 57 lines
Quoted 57 lines
Thanks,
Quoted 52 lines
return;fs/f2fs/inode.c +6
-4+if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);fs/f2fs/segment.c +8
-2@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);
Chao Yu
maintainerQuoted 64 lines · Daeho Jeong
Quoted 50 lines · Chao Yu
Quoted 48 lines · Daeho Jeong
Quoted 46 lines · Chao Yu
Quoted 40 lines · Daeho Jeong
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +1
-2@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }fs/f2fs/inode.c +0
-0fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 35
Quoted 1 line
fs/f2fs/inode.c +0
-0@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))It will return directly here if inode was dirtied, so it may missed to set
FI_ATOMIC_DIRTIEDflag?Quoted 9 lines
Quoted 2 lines
Is it possible for it to be already dirty, since we already made it clean with
f2fs_write_inode()when we started the atomic write?Some ioctl interfaces may race w/ atomic write? e.g.
set_pin_filewon't checkatomic_filestatus, and may dirty inode after we started atomic write, so we'd better detect such race condition and break ioctl to avoid ruin atomic write? and maybe we can addf2fs_bug_on()inf2fs_mark_inode_dirty_sync()to detect any other missing cases?How about exchanging the positions of
f2fs_write_inode()andset_inode_flag()inf2fs_ioc_start_atomic_write()?
Quoted 7 lines
...
f2fs_write_inode(inode, NULL); stat_inc_atomic_inode(inode); set_inode_flag(inode, FI_ATOMIC_FILE);...
Oh, I'm not sure I've got your point, after exchanging we still may suffer below race condition, right?
- f2fs_ioc_start_atomic_write
- set_inode_flag(inode, FI_ATOMIC_FILE)
- f2fs_write_inode(inode, NULL)
- f2fs_ioc_set_pin_file
- set_inode_flag(inode, FI_PIN_FILE)
- __mark_inode_dirty_flag()
- f2fs_ioc_commit_atomic_write
So that I proposed a fix for this:
https://lore.kernel.org/linux-f2fs-devel/[email protected]
Thanks,
Quoted 61 lines
Quoted 61 lines
Thanks,
Quoted 57 lines
Quoted 57 lines
Thanks,
Quoted 52 lines
return;fs/f2fs/inode.c +6
-4+if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);fs/f2fs/segment.c +8
-2@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);
Quoted 77 lines · Chao Yu
Quoted 64 lines · Daeho Jeong
Quoted 50 lines · Chao Yu
Quoted 48 lines · Daeho Jeong
Quoted 46 lines · Chao Yu
Quoted 40 lines · Daeho Jeong
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +1
-2@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }fs/f2fs/inode.c +0
-0fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 35
Quoted 1 line
fs/f2fs/inode.c +0
-0@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))It will return directly here if inode was dirtied, so it may missed to set
FI_ATOMIC_DIRTIEDflag?Quoted 9 lines
Quoted 2 lines
Is it possible for it to be already dirty, since we already made it clean with
f2fs_write_inode()when we started the atomic write?Some ioctl interfaces may race w/ atomic write? e.g.
set_pin_filewon't checkatomic_filestatus, and may dirty inode after we started atomic write, so we'd better detect such race condition and break ioctl to avoid ruin atomic write? and maybe we can addf2fs_bug_on()inf2fs_mark_inode_dirty_sync()to detect any other missing cases?How about exchanging the positions of
f2fs_write_inode()andset_inode_flag()inf2fs_ioc_start_atomic_write()?Quoted 7 lines
...
f2fs_write_inode(inode, NULL); stat_inc_atomic_inode(inode); set_inode_flag(inode, FI_ATOMIC_FILE);...
Oh, I'm not sure I've got your point, after exchanging we still may suffer below race condition, right?
Quoted 6 lines
-
f2fs_ioc_start_atomic_write
-set_inode_flag(inode, FI_ATOMIC_FILE)
-f2fs_write_inode(inode, NULL)
-f2fs_ioc_set_pin_file
-set_inode_flag(inode, FI_PIN_FILE)
-__mark_inode_dirty_flag()
=> This attempt will
be blocked by the below condition.
+ if (f2fs_is_atomic_file(inode)) {
+ set_inode_flag(inode, FI_ATOMIC_DIRTIED);
+ return;
+ }
Plz, refer to the above comment.
Quoted 69 lines
-
f2fs_ioc_commit_atomic_writeSo that I proposed a fix for this:
https://lore.kernel.org/linux-f2fs-devel/[email protected]Thanks,
Quoted 61 lines
Quoted 61 lines
Thanks,
Quoted 57 lines
Quoted 57 lines
Thanks,
Quoted 52 lines
return;fs/f2fs/inode.c +6
-4+if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);fs/f2fs/segment.c +8
-2@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);
Quoted 93 lines · Daeho Jeong
Quoted 77 lines · Chao Yu
Quoted 64 lines · Daeho Jeong
Quoted 50 lines · Chao Yu
Quoted 48 lines · Daeho Jeong
Quoted 46 lines · Chao Yu
Quoted 40 lines · Daeho Jeong
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +1
-2@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }fs/f2fs/inode.c +0
-0fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 35
Quoted 1 line
fs/f2fs/inode.c +0
-0@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))It will return directly here if inode was dirtied, so it may missed to set
FI_ATOMIC_DIRTIEDflag?Quoted 9 lines
Quoted 2 lines
Is it possible for it to be already dirty, since we already made it clean with
f2fs_write_inode()when we started the atomic write?Some ioctl interfaces may race w/ atomic write? e.g.
set_pin_filewon't checkatomic_filestatus, and may dirty inode after we started atomic write, so we'd better detect such race condition and break ioctl to avoid ruin atomic write? and maybe we can addf2fs_bug_on()inf2fs_mark_inode_dirty_sync()to detect any other missing cases?How about exchanging the positions of
f2fs_write_inode()andset_inode_flag()inf2fs_ioc_start_atomic_write()?Quoted 7 lines
...
f2fs_write_inode(inode, NULL); stat_inc_atomic_inode(inode); set_inode_flag(inode, FI_ATOMIC_FILE);...
Oh, I'm not sure I've got your point, after exchanging we still may suffer below race condition, right?
Quoted 6 lines
-
f2fs_ioc_start_atomic_write
-set_inode_flag(inode, FI_ATOMIC_FILE)
-f2fs_write_inode(inode, NULL)
-f2fs_ioc_set_pin_file
-set_inode_flag(inode, FI_PIN_FILE)
-__mark_inode_dirty_flag()=> This attempt will
be blocked by the below condition.(quoted diff) +4
-0+ if (f2fs_is_atomic_file(inode)) { + set_inode_flag(inode, FI_ATOMIC_DIRTIED); + return; + }
Quoted 1 line
Plz, refer to the above comment.
By the way, I need to change this patch a little bit to prevent a direct inode dirtying case by VFS layer.
Plz, wait for the 2nd one.
Quoted 70 lines
Quoted 70 lines
-
f2fs_ioc_commit_atomic_writeSo that I proposed a fix for this:
https://lore.kernel.org/linux-f2fs-devel/[email protected]Thanks,
Quoted 61 lines
Quoted 61 lines
Thanks,
Quoted 57 lines
Quoted 57 lines
Thanks,
Quoted 52 lines
return;fs/f2fs/inode.c +6
-4+if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);fs/f2fs/segment.c +8
-2@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);
Chao Yu
maintainerQuoted 87 lines · Daeho Jeong
Quoted 77 lines · Chao Yu
Quoted 64 lines · Daeho Jeong
Quoted 50 lines · Chao Yu
Quoted 48 lines · Daeho Jeong
Quoted 46 lines · Chao Yu
Quoted 40 lines · Daeho Jeong
From: Daeho Jeong <[email protected]>
Keep atomic file clean while updating and make it dirtied during commit in order to avoid unnecessary and excessive inode updates in the previous fix.
Fixes 4bf78322346f ("f2fs: mark inode dirty for FI_ATOMIC_COMMITTED flag")Signed-off-by Daeho Jeong <[email protected]>--- fs/f2fs/f2fs.h | 3 +-- fs/f2fs/inode.c | 10 ++++++---- fs/f2fs/segment.c | 10 ++++++++-- 3 files changed, 15 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +1
-2@@ -801,7 +801,7 @@ enum {FI_COMPRESS_RELEASED ,/* compressed blocks were released */ FI_ALIGNED_WRITE ,/* enable aligned write */ FI_COW_FILE ,/* indicate COW file */ -FI_ATOMIC_COMMITTED ,/* indicate atomic commit completed except disk sync */ +FI_ATOMIC_DIRTIED ,/* indicate atomic file is dirtied */ FI_ATOMIC_REPLACE ,/* indicate atomic replace */ FI_OPENED_FILE ,/* indicate file has been opened */ FI_MAX, /* max flag, never be used */@@ -3042,7 +3042,6 @@ static inline void __mark_inode_dirty_flag(struct inode *inode,case FI_INLINE_DOTS :case FI_PIN_FILE :case FI_COMPRESS_RELEASED : -case FI_ATOMIC_COMMITTED :f2fs_mark_inode_dirty_sync (inode, true); } }fs/f2fs/inode.c +0
-0fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 35
Quoted 1 line
fs/f2fs/inode.c +0
-0@@ -35,6 +35,11 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)if (f2fs_inode_dirtied (inode, sync))It will return directly here if inode was dirtied, so it may missed to set
FI_ATOMIC_DIRTIEDflag?Quoted 9 lines
Quoted 2 lines
Is it possible for it to be already dirty, since we already made it clean with
f2fs_write_inode()when we started the atomic write?Some ioctl interfaces may race w/ atomic write? e.g.
set_pin_filewon't checkatomic_filestatus, and may dirty inode after we started atomic write, so we'd better detect such race condition and break ioctl to avoid ruin atomic write? and maybe we can addf2fs_bug_on()inf2fs_mark_inode_dirty_sync()to detect any other missing cases?How about exchanging the positions of
f2fs_write_inode()andset_inode_flag()inf2fs_ioc_start_atomic_write()?Quoted 7 lines
...
f2fs_write_inode(inode, NULL); stat_inc_atomic_inode(inode); set_inode_flag(inode, FI_ATOMIC_FILE);...
Oh, I'm not sure I've got your point, after exchanging we still may suffer below race condition, right?
Quoted 6 lines
-
f2fs_ioc_start_atomic_write
-set_inode_flag(inode, FI_ATOMIC_FILE)
-f2fs_write_inode(inode, NULL)
-f2fs_ioc_set_pin_file
-set_inode_flag(inode, FI_PIN_FILE)
-__mark_inode_dirty_flag()=> This attempt will
be blocked by the below condition.
Review
Quoted 4 lines
(quoted diff) +4
-0+ if (f2fs_is_atomic_file(inode)) { + set_inode_flag(inode, FI_ATOMIC_DIRTIED); + return; + }
Oh, yes, FI_ATOMIC_DIRTIED will be tagged once inode becomes dirty.
Thanks,
Quoted 72 lines
Plz, refer to the above comment.
Quoted 69 lines
-
f2fs_ioc_commit_atomic_writeSo that I proposed a fix for this:
https://lore.kernel.org/linux-f2fs-devel/[email protected]Thanks,
Quoted 61 lines
Quoted 61 lines
Thanks,
Quoted 57 lines
Quoted 57 lines
Thanks,
Quoted 52 lines
return;fs/f2fs/inode.c +6
-4+if (f2fs_is_atomic_file (inode)) { +set_inode_flag (inode,FI_ATOMIC_DIRTIED ); +return ; + } +mark_inode_dirty_sync (inode); }@@ -653,10 +658,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page) ri->i_gid =cpu_to_le32 (i_gid_read (inode)); ri->i_links =cpu_to_le32 (inode->i_nlink); ri->i_blocks =cpu_to_le64 (SECTOR_TO_BLOCK (inode->i_blocks) +1 ); - -if (!f2fs_is_atomic_file (inode) || -is_inode_flag_set (inode,FI_ATOMIC_COMMITTED )) - ri->i_size =cpu_to_le64 (i_size_read (inode)); + ri->i_size =cpu_to_le64 (i_size_read (inode));if (et) {read_lock (&et->lock);fs/f2fs/segment.c +8
-2@@ -196,9 +196,12 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)truncate_inode_pages_final (inode->i_mapping);release_atomic_write_cnt (inode); -clear_inode_flag (inode,FI_ATOMIC_COMMITTED );clear_inode_flag (inode,FI_ATOMIC_REPLACE );clear_inode_flag (inode,FI_ATOMIC_FILE ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + }stat_dec_atomic_inode (inode);F2FS_I (inode)->atomic_write_task =NULL ;@@ -365,7 +368,10 @@ static int __f2fs_commit_atomic_write(struct inode *inode) sbi->revoked_atomic_block += fi->atomic_write_cnt; }else { sbi->committed_atomic_block += fi->atomic_write_cnt; -set_inode_flag (inode,FI_ATOMIC_COMMITTED ); +if (is_inode_flag_set (inode,FI_ATOMIC_DIRTIED )) { +clear_inode_flag (inode,FI_ATOMIC_DIRTIED ); +f2fs_mark_inode_dirty_sync (inode, true); + } }__complete_revoke_list (inode, &revoke_list, ret ? true : false);