Skip to contentSkip to conversation

f2fs: synchronize atomic write aborts

PATCH In review Daeho Jeong 2 participants 10 messages Jan 13, 2023 – Feb 1, 2023 F2FS file system

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 f2fs: synchronize atomic write aborts

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
 fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
 fs/f2fs/inode.c   | 11 +++++++++--
 fs/f2fs/segment.c |  3 ---
 fs/f2fs/super.c   |  2 --
 4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
 			atomic_read(&inode->i_writecount) != 1)
 		return 0;
 
+	inode_lock(inode);
 	f2fs_abort_atomic_write(inode, true);
+	inode_unlock(inode);
+
 	return 0;
 }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
 	 * until all the writers close its file. Since this should be done
 	 * before dropping file lock, it needs to do in ->flush.
 	 */
-	if (F2FS_I(inode)->atomic_write_task == current)
+	if (F2FS_I(inode)->atomic_write_task == current) {
+		inode_lock(inode);
 		f2fs_abort_atomic_write(inode, true);
+		inode_unlock(inode);
+	}
 	return 0;
 }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 		goto out;
 	}
 
-	/* Create a COW inode for atomic write */
-	pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-	if (IS_ERR(pinode)) {
-		f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-		ret = PTR_ERR(pinode);
-		goto out;
-	}
+	/* Check if the inode already has a COW inode */
+	if (fi->cow_inode == NULL) {
+		/* Create a COW inode for atomic write */
+		pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+		if (IS_ERR(pinode)) {
+			f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+			ret = PTR_ERR(pinode);
+			goto out;
+		}
 
-	ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-	iput(pinode);
-	if (ret) {
-		f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-		goto out;
+		ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+		iput(pinode);
+		if (ret) {
+			f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+			goto out;
+		}
+
+		set_inode_flag(fi->cow_inode, FI_COW_FILE);
+		clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+	} else {
+		/* Reuse the already created COW inode */
+		f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
 	}
 
 	f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 	stat_inc_atomic_inode(inode);
 
 	set_inode_flag(inode, FI_ATOMIC_FILE);
-	set_inode_flag(fi->cow_inode, FI_COW_FILE);
-	clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
 	isize = i_size_read(inode);
 	fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
 void f2fs_evict_inode(struct inode *inode)
 {
 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-	nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+	struct f2fs_inode_info *fi = F2FS_I(inode);
+	nid_t xnid = fi->i_xattr_nid;
 	int err = 0;
 
 	f2fs_abort_atomic_write(inode, true);
 
+	if (fi->cow_inode) {
+		clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+		iput(fi->cow_inode);
+		fi->cow_inode = NULL;
+	}
+
 	trace_f2fs_evict_inode(inode);
 	truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
 	stat_dec_inline_inode(inode);
 	stat_dec_compr_inode(inode);
 	stat_sub_compr_blocks(inode,
-			atomic_read(&F2FS_I(inode)->i_compr_blocks));
+			atomic_read(&fi->i_compr_blocks));
 
 	if (likely(!f2fs_cp_error(sbi) &&
 				!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
 	if (!f2fs_is_atomic_file(inode))
 		return;
 
-	clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-	iput(fi->cow_inode);
-	fi->cow_inode = NULL;
 	release_atomic_write_cnt(inode);
 	clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
 	clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -2
index 1f812b9ce985..10463f084d30 100644
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
 			atomic_inc(&inode->i_count);
 			spin_unlock(&inode->i_lock);
 
-			f2fs_abort_atomic_write(inode, true);
-
 			/* should remain fi->extent_tree for writepage */
 			f2fs_destroy_extent_node(inode);
 
Signature · 8 lines
2.39.0.246.g2a6d74b583-goog



_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
maintainer
#1 lore raw

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
  fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
  fs/f2fs/inode.c   | 11 +++++++++--
  fs/f2fs/segment.c |  3 ---
  fs/f2fs/super.c   |  2 --
  4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
  			atomic_read(&inode->i_writecount) != 1)
  		return 0;
 
+	inode_lock(inode);
  	f2fs_abort_atomic_write(inode, true);
+	inode_unlock(inode);
+
  	return 0;
  }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
  	 * until all the writers close its file. Since this should be done
  	 * before dropping file lock, it needs to do in ->flush.
  	 */
-	if (F2FS_I(inode)->atomic_write_task == current)
+	if (F2FS_I(inode)->atomic_write_task == current) {
+		inode_lock(inode);
  		f2fs_abort_atomic_write(inode, true);
+		inode_unlock(inode);
+	}
  	return 0;
  }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
  		goto out;
  	}
 
-	/* Create a COW inode for atomic write */
-	pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-	if (IS_ERR(pinode)) {
-		f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-		ret = PTR_ERR(pinode);
-		goto out;
-	}
+	/* Check if the inode already has a COW inode */
+	if (fi->cow_inode == NULL) {
+		/* Create a COW inode for atomic write */
+		pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+		if (IS_ERR(pinode)) {
+			f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+			ret = PTR_ERR(pinode);
+			goto out;
+		}
 
-	ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-	iput(pinode);
-	if (ret) {
-		f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-		goto out;
+		ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+		iput(pinode);
+		if (ret) {
+			f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+			goto out;
+		}
+
+		set_inode_flag(fi->cow_inode, FI_COW_FILE);
+		clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+	} else {
+		/* Reuse the already created COW inode */
+		f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
  	}
 
  	f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
  	stat_inc_atomic_inode(inode);
 
  	set_inode_flag(inode, FI_ATOMIC_FILE);
-	set_inode_flag(fi->cow_inode, FI_COW_FILE);
-	clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
  	isize = i_size_read(inode);
  	fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
  void f2fs_evict_inode(struct inode *inode)
  {
  	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-	nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+	struct f2fs_inode_info *fi = F2FS_I(inode);
+	nid_t xnid = fi->i_xattr_nid;
  	int err = 0;
 
  	f2fs_abort_atomic_write(inode, true);
 
+	if (fi->cow_inode) {
+		clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+		iput(fi->cow_inode);
+		fi->cow_inode = NULL;
+	}
+
  	trace_f2fs_evict_inode(inode);
  	truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
  	stat_dec_inline_inode(inode);
  	stat_dec_compr_inode(inode);
  	stat_sub_compr_blocks(inode,
-			atomic_read(&F2FS_I(inode)->i_compr_blocks));
+			atomic_read(&fi->i_compr_blocks));
 
  	if (likely(!f2fs_cp_error(sbi) &&
  				!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
  	if (!f2fs_is_atomic_file(inode))
  		return;
 
-	clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-	iput(fi->cow_inode);
-	fi->cow_inode = NULL;
  	release_atomic_write_cnt(inode);
  	clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
  	clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
  			atomic_inc(&inode->i_count);
  			spin_unlock(&inode->i_lock);
 
-			f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

if (f2fs_is_atomic_file() && cow_inode)

	truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
  			/* should remain fi->extent_tree for writepage */
  			f2fs_destroy_extent_node(inode);
 
#2 lore raw

Hi Chao,

I read your patch series now and I like it.
However, how about a race condition between start_atomic_write and abort_atomic_write?
abort_atomic_write is called without inode_lock in closing filp scenarios. What do you think about this?

Thanks,

Quoted 167 lines · Chao Yu

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
  fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
  fs/f2fs/inode.c   | 11 +++++++++--
  fs/f2fs/segment.c |  3 ---
  fs/f2fs/super.c   |  2 --
  4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
                      atomic_read(&inode->i_writecount) != 1)
              return 0;
 
+     inode_lock(inode);
      f2fs_abort_atomic_write(inode, true);
+     inode_unlock(inode);
+
      return 0;
  }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
       * until all the writers close its file. Since this should be done
       * before dropping file lock, it needs to do in ->flush.
       */
-     if (F2FS_I(inode)->atomic_write_task == current)
+     if (F2FS_I(inode)->atomic_write_task == current) {
+             inode_lock(inode);
              f2fs_abort_atomic_write(inode, true);
+             inode_unlock(inode);
+     }
      return 0;
  }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
              goto out;
      }
 
-     /* Create a COW inode for atomic write */
-     pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-     if (IS_ERR(pinode)) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             ret = PTR_ERR(pinode);
-             goto out;
-     }
+     /* Check if the inode already has a COW inode */
+     if (fi->cow_inode == NULL) {
+             /* Create a COW inode for atomic write */
+             pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+             if (IS_ERR(pinode)) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     ret = PTR_ERR(pinode);
+                     goto out;
+             }
 
-     ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-     iput(pinode);
-     if (ret) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             goto out;
+             ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+             iput(pinode);
+             if (ret) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     goto out;
+             }
+
+             set_inode_flag(fi->cow_inode, FI_COW_FILE);
+             clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+     } else {
+             /* Reuse the already created COW inode */
+             f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
      }
 
      f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
      stat_inc_atomic_inode(inode);
 
      set_inode_flag(inode, FI_ATOMIC_FILE);
-     set_inode_flag(fi->cow_inode, FI_COW_FILE);
-     clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
      isize = i_size_read(inode);
      fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
  void f2fs_evict_inode(struct inode *inode)
  {
      struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-     nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+     struct f2fs_inode_info *fi = F2FS_I(inode);
+     nid_t xnid = fi->i_xattr_nid;
      int err = 0;
 
      f2fs_abort_atomic_write(inode, true);
 
+     if (fi->cow_inode) {
+             clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+             iput(fi->cow_inode);
+             fi->cow_inode = NULL;
+     }
+
      trace_f2fs_evict_inode(inode);
      truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
      stat_dec_inline_inode(inode);
      stat_dec_compr_inode(inode);
      stat_sub_compr_blocks(inode,
-                     atomic_read(&F2FS_I(inode)->i_compr_blocks));
+                     atomic_read(&fi->i_compr_blocks));
 
      if (likely(!f2fs_cp_error(sbi) &&
                              !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
      if (!f2fs_is_atomic_file(inode))
              return;
 
-     clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-     iput(fi->cow_inode);
-     fi->cow_inode = NULL;
      release_atomic_write_cnt(inode);
      clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
      clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
                      atomic_inc(&inode->i_count);
                      spin_unlock(&inode->i_lock);
 
-                     f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

Quoted 9 lines

if (f2fs_is_atomic_file() && cow_inode)

        truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
                      /* should remain fi->extent_tree for writepage */
                      f2fs_destroy_extent_node(inode);
 

_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel

maintainer
#3 lore raw

Hi Daeho,

Quoted 3 lines · Daeho Jeong

Hi Chao,

I read your patch series now and I like it.

Thank you for checking the patches. :)

Quoted 2 lines

However, how about a race condition between start_atomic_write and abort_atomic_write?

Yup, I noticed that issue, I guess we can avoid this race condition by covering these two flows w/ i_atomic_sem.

Quoted 2 lines

abort_atomic_write is called without inode_lock in closing filp scenarios. What do you think about this?

I'm fine w/ your change as it's more clean, but it's better to drop cow_inode's page cache if atomic_write is committed or aborted to avoid caching obsolete page?

Thanks,

Quoted 181 lines

Thanks,

Quoted 176 lines · Chao Yu

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
   fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
   fs/f2fs/inode.c   | 11 +++++++++--
   fs/f2fs/segment.c |  3 ---
   fs/f2fs/super.c   |  2 --
   4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
                       atomic_read(&inode->i_writecount) != 1)
               return 0;
 
+     inode_lock(inode);
       f2fs_abort_atomic_write(inode, true);
+     inode_unlock(inode);
+
       return 0;
   }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
        * until all the writers close its file. Since this should be done
        * before dropping file lock, it needs to do in ->flush.
        */
-     if (F2FS_I(inode)->atomic_write_task == current)
+     if (F2FS_I(inode)->atomic_write_task == current) {
+             inode_lock(inode);
               f2fs_abort_atomic_write(inode, true);
+             inode_unlock(inode);
+     }
       return 0;
   }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
               goto out;
       }
 
-     /* Create a COW inode for atomic write */
-     pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-     if (IS_ERR(pinode)) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             ret = PTR_ERR(pinode);
-             goto out;
-     }
+     /* Check if the inode already has a COW inode */
+     if (fi->cow_inode == NULL) {
+             /* Create a COW inode for atomic write */
+             pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+             if (IS_ERR(pinode)) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     ret = PTR_ERR(pinode);
+                     goto out;
+             }
 
-     ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-     iput(pinode);
-     if (ret) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             goto out;
+             ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+             iput(pinode);
+             if (ret) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     goto out;
+             }
+
+             set_inode_flag(fi->cow_inode, FI_COW_FILE);
+             clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+     } else {
+             /* Reuse the already created COW inode */
+             f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
       }
 
       f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
       stat_inc_atomic_inode(inode);
 
       set_inode_flag(inode, FI_ATOMIC_FILE);
-     set_inode_flag(fi->cow_inode, FI_COW_FILE);
-     clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
       isize = i_size_read(inode);
       fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
   void f2fs_evict_inode(struct inode *inode)
   {
       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-     nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+     struct f2fs_inode_info *fi = F2FS_I(inode);
+     nid_t xnid = fi->i_xattr_nid;
       int err = 0;
 
       f2fs_abort_atomic_write(inode, true);
 
+     if (fi->cow_inode) {
+             clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+             iput(fi->cow_inode);
+             fi->cow_inode = NULL;
+     }
+
       trace_f2fs_evict_inode(inode);
       truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
       stat_dec_inline_inode(inode);
       stat_dec_compr_inode(inode);
       stat_sub_compr_blocks(inode,
-                     atomic_read(&F2FS_I(inode)->i_compr_blocks));
+                     atomic_read(&fi->i_compr_blocks));
 
       if (likely(!f2fs_cp_error(sbi) &&
                               !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
       if (!f2fs_is_atomic_file(inode))
               return;
 
-     clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-     iput(fi->cow_inode);
-     fi->cow_inode = NULL;
       release_atomic_write_cnt(inode);
       clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
       clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
                       atomic_inc(&inode->i_count);
                       spin_unlock(&inode->i_lock);
 
-                     f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

if (f2fs_is_atomic_file() && cow_inode)

         truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
                       /* should remain fi->extent_tree for writepage */
                       f2fs_destroy_extent_node(inode);
 
#4 lore raw

Hi Chao,

Quoted 13 lines · Chao Yu

Hi Daeho,

Quoted 3 lines · Daeho Jeong

Hi Chao,

I read your patch series now and I like it.

Thank you for checking the patches. :)

Quoted 2 lines

However, how about a race condition between start_atomic_write and abort_atomic_write?

Quoted 8 lines

Yup, I noticed that issue, I guess we can avoid this race condition by covering these two flows w/ i_atomic_sem.

Quoted 2 lines

abort_atomic_write is called without inode_lock in closing filp scenarios. What do you think about this?

I'm fine w/ your change as it's more clean, but it's better to drop cow_inode's page cache if atomic_write is committed or aborted to avoid caching obsolete page?

It's better to put that part in f2fs_abort_atomic_write(). On top of that, maybe, we should move f2fs_do_truncate_blocks(fi->cow_inode, 0, true) part from f2fs_ioc_start_atomic_write() to f2fs_abort_atomic_write(), too.

Thanks,

Quoted 184 lines

Thanks,

Quoted 181 lines

Thanks,

Quoted 176 lines · Chao Yu

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
   fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
   fs/f2fs/inode.c   | 11 +++++++++--
   fs/f2fs/segment.c |  3 ---
   fs/f2fs/super.c   |  2 --
   4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
                       atomic_read(&inode->i_writecount) != 1)
               return 0;
 
+     inode_lock(inode);
       f2fs_abort_atomic_write(inode, true);
+     inode_unlock(inode);
+
       return 0;
   }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
        * until all the writers close its file. Since this should be done
        * before dropping file lock, it needs to do in ->flush.
        */
-     if (F2FS_I(inode)->atomic_write_task == current)
+     if (F2FS_I(inode)->atomic_write_task == current) {
+             inode_lock(inode);
               f2fs_abort_atomic_write(inode, true);
+             inode_unlock(inode);
+     }
       return 0;
   }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
               goto out;
       }
 
-     /* Create a COW inode for atomic write */
-     pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-     if (IS_ERR(pinode)) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             ret = PTR_ERR(pinode);
-             goto out;
-     }
+     /* Check if the inode already has a COW inode */
+     if (fi->cow_inode == NULL) {
+             /* Create a COW inode for atomic write */
+             pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+             if (IS_ERR(pinode)) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     ret = PTR_ERR(pinode);
+                     goto out;
+             }
 
-     ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-     iput(pinode);
-     if (ret) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             goto out;
+             ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+             iput(pinode);
+             if (ret) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     goto out;
+             }
+
+             set_inode_flag(fi->cow_inode, FI_COW_FILE);
+             clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+     } else {
+             /* Reuse the already created COW inode */
+             f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
       }
 
       f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
       stat_inc_atomic_inode(inode);
 
       set_inode_flag(inode, FI_ATOMIC_FILE);
-     set_inode_flag(fi->cow_inode, FI_COW_FILE);
-     clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
       isize = i_size_read(inode);
       fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
   void f2fs_evict_inode(struct inode *inode)
   {
       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-     nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+     struct f2fs_inode_info *fi = F2FS_I(inode);
+     nid_t xnid = fi->i_xattr_nid;
       int err = 0;
 
       f2fs_abort_atomic_write(inode, true);
 
+     if (fi->cow_inode) {
+             clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+             iput(fi->cow_inode);
+             fi->cow_inode = NULL;
+     }
+
       trace_f2fs_evict_inode(inode);
       truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
       stat_dec_inline_inode(inode);
       stat_dec_compr_inode(inode);
       stat_sub_compr_blocks(inode,
-                     atomic_read(&F2FS_I(inode)->i_compr_blocks));
+                     atomic_read(&fi->i_compr_blocks));
 
       if (likely(!f2fs_cp_error(sbi) &&
                               !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
       if (!f2fs_is_atomic_file(inode))
               return;
 
-     clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-     iput(fi->cow_inode);
-     fi->cow_inode = NULL;
       release_atomic_write_cnt(inode);
       clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
       clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
                       atomic_inc(&inode->i_count);
                       spin_unlock(&inode->i_lock);
 
-                     f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

if (f2fs_is_atomic_file() && cow_inode)

         truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
                       /* should remain fi->extent_tree for writepage */
                       f2fs_destroy_extent_node(inode);
 
#5 lore raw
Quoted 23 lines · Daeho Jeong

Hi Chao,

Quoted 19 lines · Chao Yu

Hi Daeho,

Quoted 3 lines · Daeho Jeong

Hi Chao,

I read your patch series now and I like it.

Thank you for checking the patches. :)

Quoted 2 lines

However, how about a race condition between start_atomic_write and abort_atomic_write?

Yup, I noticed that issue, I guess we can avoid this race condition by covering these two flows w/ i_atomic_sem.

Quoted 2 lines

abort_atomic_write is called without inode_lock in closing filp scenarios. What do you think about this?

Quoted 7 lines
Quoted 2 lines

I'm fine w/ your change as it's more clean, but it's better to drop cow_inode's page cache if atomic_write is committed or aborted to avoid caching obsolete page?

It's better to put that part in f2fs_abort_atomic_write(). On top of that, maybe, we should move f2fs_do_truncate_blocks(fi->cow_inode, 0, true) part from f2fs_ioc_start_atomic_write() to f2fs_abort_atomic_write(), too.

Oh, we shouldn't touch the f2fs_do_truncate_blocks() part, since there might be some left writeback after aborting atomic write.
Plz. review it related to the timing of calling truncate_inode_pages_final().

Quoted 187 lines

Thanks,

Quoted 184 lines

Thanks,

Quoted 181 lines

Thanks,

Quoted 176 lines · Chao Yu

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
   fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
   fs/f2fs/inode.c   | 11 +++++++++--
   fs/f2fs/segment.c |  3 ---
   fs/f2fs/super.c   |  2 --
   4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
                       atomic_read(&inode->i_writecount) != 1)
               return 0;
 
+     inode_lock(inode);
       f2fs_abort_atomic_write(inode, true);
+     inode_unlock(inode);
+
       return 0;
   }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
        * until all the writers close its file. Since this should be done
        * before dropping file lock, it needs to do in ->flush.
        */
-     if (F2FS_I(inode)->atomic_write_task == current)
+     if (F2FS_I(inode)->atomic_write_task == current) {
+             inode_lock(inode);
               f2fs_abort_atomic_write(inode, true);
+             inode_unlock(inode);
+     }
       return 0;
   }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
               goto out;
       }
 
-     /* Create a COW inode for atomic write */
-     pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-     if (IS_ERR(pinode)) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             ret = PTR_ERR(pinode);
-             goto out;
-     }
+     /* Check if the inode already has a COW inode */
+     if (fi->cow_inode == NULL) {
+             /* Create a COW inode for atomic write */
+             pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+             if (IS_ERR(pinode)) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     ret = PTR_ERR(pinode);
+                     goto out;
+             }
 
-     ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-     iput(pinode);
-     if (ret) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             goto out;
+             ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+             iput(pinode);
+             if (ret) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     goto out;
+             }
+
+             set_inode_flag(fi->cow_inode, FI_COW_FILE);
+             clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+     } else {
+             /* Reuse the already created COW inode */
+             f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
       }
 
       f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
       stat_inc_atomic_inode(inode);
 
       set_inode_flag(inode, FI_ATOMIC_FILE);
-     set_inode_flag(fi->cow_inode, FI_COW_FILE);
-     clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
       isize = i_size_read(inode);
       fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
   void f2fs_evict_inode(struct inode *inode)
   {
       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-     nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+     struct f2fs_inode_info *fi = F2FS_I(inode);
+     nid_t xnid = fi->i_xattr_nid;
       int err = 0;
 
       f2fs_abort_atomic_write(inode, true);
 
+     if (fi->cow_inode) {
+             clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+             iput(fi->cow_inode);
+             fi->cow_inode = NULL;
+     }
+
       trace_f2fs_evict_inode(inode);
       truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
       stat_dec_inline_inode(inode);
       stat_dec_compr_inode(inode);
       stat_sub_compr_blocks(inode,
-                     atomic_read(&F2FS_I(inode)->i_compr_blocks));
+                     atomic_read(&fi->i_compr_blocks));
 
       if (likely(!f2fs_cp_error(sbi) &&
                               !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
       if (!f2fs_is_atomic_file(inode))
               return;
 
-     clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-     iput(fi->cow_inode);
-     fi->cow_inode = NULL;
       release_atomic_write_cnt(inode);
       clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
       clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
                       atomic_inc(&inode->i_count);
                       spin_unlock(&inode->i_lock);
 
-                     f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

if (f2fs_is_atomic_file() && cow_inode)

         truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
                       /* should remain fi->extent_tree for writepage */
                       f2fs_destroy_extent_node(inode);
 
#6 lore raw
Quoted 28 lines · Daeho Jeong
Quoted 26 lines · Daeho Jeong

Hi Chao,

Quoted 21 lines · Chao Yu

Hi Daeho,

Quoted 3 lines · Daeho Jeong

Hi Chao,

I read your patch series now and I like it.

Thank you for checking the patches. :)

Quoted 2 lines

However, how about a race condition between start_atomic_write and abort_atomic_write?

Yup, I noticed that issue, I guess we can avoid this race condition by covering these two flows w/ i_atomic_sem.

Quoted 2 lines

abort_atomic_write is called without inode_lock in closing filp scenarios. What do you think about this?

I'm fine w/ your change as it's more clean, but it's better to drop cow_inode's page cache if atomic_write is committed or aborted to avoid caching obsolete page?

Quoted 8 lines
Quoted 4 lines

It's better to put that part in f2fs_abort_atomic_write(). On top of that, maybe, we should move f2fs_do_truncate_blocks(fi->cow_inode, 0, true) part from f2fs_ioc_start_atomic_write() to f2fs_abort_atomic_write(), too.

Oh, we shouldn't touch the f2fs_do_truncate_blocks() part, since there might be some left writeback after aborting atomic write.
Plz. review it related to the timing of calling truncate_inode_pages_final().

Looks like the scenario becomes too complicated if I think about more than one writer's scenario.
How about we check writecount in commit_atomic_write ioctl and return EBUSY when it's not only one writer?
In that case, we can make the scenario simple and effective, and we can release all the resources in abort_atomic_write().

Quoted 188 lines
Quoted 188 lines

Thanks,

Quoted 184 lines

Thanks,

Quoted 181 lines

Thanks,

Quoted 176 lines · Chao Yu

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
   fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
   fs/f2fs/inode.c   | 11 +++++++++--
   fs/f2fs/segment.c |  3 ---
   fs/f2fs/super.c   |  2 --
   4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
                       atomic_read(&inode->i_writecount) != 1)
               return 0;
 
+     inode_lock(inode);
       f2fs_abort_atomic_write(inode, true);
+     inode_unlock(inode);
+
       return 0;
   }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
        * until all the writers close its file. Since this should be done
        * before dropping file lock, it needs to do in ->flush.
        */
-     if (F2FS_I(inode)->atomic_write_task == current)
+     if (F2FS_I(inode)->atomic_write_task == current) {
+             inode_lock(inode);
               f2fs_abort_atomic_write(inode, true);
+             inode_unlock(inode);
+     }
       return 0;
   }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
               goto out;
       }
 
-     /* Create a COW inode for atomic write */
-     pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-     if (IS_ERR(pinode)) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             ret = PTR_ERR(pinode);
-             goto out;
-     }
+     /* Check if the inode already has a COW inode */
+     if (fi->cow_inode == NULL) {
+             /* Create a COW inode for atomic write */
+             pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+             if (IS_ERR(pinode)) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     ret = PTR_ERR(pinode);
+                     goto out;
+             }
 
-     ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-     iput(pinode);
-     if (ret) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             goto out;
+             ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+             iput(pinode);
+             if (ret) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     goto out;
+             }
+
+             set_inode_flag(fi->cow_inode, FI_COW_FILE);
+             clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+     } else {
+             /* Reuse the already created COW inode */
+             f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
       }
 
       f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
       stat_inc_atomic_inode(inode);
 
       set_inode_flag(inode, FI_ATOMIC_FILE);
-     set_inode_flag(fi->cow_inode, FI_COW_FILE);
-     clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
       isize = i_size_read(inode);
       fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
   void f2fs_evict_inode(struct inode *inode)
   {
       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-     nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+     struct f2fs_inode_info *fi = F2FS_I(inode);
+     nid_t xnid = fi->i_xattr_nid;
       int err = 0;
 
       f2fs_abort_atomic_write(inode, true);
 
+     if (fi->cow_inode) {
+             clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+             iput(fi->cow_inode);
+             fi->cow_inode = NULL;
+     }
+
       trace_f2fs_evict_inode(inode);
       truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
       stat_dec_inline_inode(inode);
       stat_dec_compr_inode(inode);
       stat_sub_compr_blocks(inode,
-                     atomic_read(&F2FS_I(inode)->i_compr_blocks));
+                     atomic_read(&fi->i_compr_blocks));
 
       if (likely(!f2fs_cp_error(sbi) &&
                               !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
       if (!f2fs_is_atomic_file(inode))
               return;
 
-     clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-     iput(fi->cow_inode);
-     fi->cow_inode = NULL;
       release_atomic_write_cnt(inode);
       clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
       clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
                       atomic_inc(&inode->i_count);
                       spin_unlock(&inode->i_lock);
 
-                     f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

if (f2fs_is_atomic_file() && cow_inode)

         truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
                       /* should remain fi->extent_tree for writepage */
                       f2fs_destroy_extent_node(inode);
 
#7 lore raw
Quoted 39 lines · Daeho Jeong
Quoted 28 lines · Daeho Jeong
Quoted 26 lines · Daeho Jeong

Hi Chao,

Quoted 21 lines · Chao Yu

Hi Daeho,

Quoted 3 lines · Daeho Jeong

Hi Chao,

I read your patch series now and I like it.

Thank you for checking the patches. :)

Quoted 2 lines

However, how about a race condition between start_atomic_write and abort_atomic_write?

Yup, I noticed that issue, I guess we can avoid this race condition by covering these two flows w/ i_atomic_sem.

Quoted 2 lines

abort_atomic_write is called without inode_lock in closing filp scenarios. What do you think about this?

I'm fine w/ your change as it's more clean, but it's better to drop cow_inode's page cache if atomic_write is committed or aborted to avoid caching obsolete page?

Quoted 8 lines
Quoted 4 lines

It's better to put that part in f2fs_abort_atomic_write(). On top of that, maybe, we should move f2fs_do_truncate_blocks(fi->cow_inode, 0, true) part from f2fs_ioc_start_atomic_write() to f2fs_abort_atomic_write(), too.

Oh, we shouldn't touch the f2fs_do_truncate_blocks() part, since there might be some left writeback after aborting atomic write.
Plz. review it related to the timing of calling truncate_inode_pages_final().

Quoted 6 lines

Looks like the scenario becomes too complicated if I think about more than one writer's scenario.
How about we check writecount in commit_atomic_write ioctl and return EBUSY when it's not only one writer?
In that case, we can make the scenario simple and effective, and we can release all the resources in abort_atomic_write().

Oh, I totally forgot this. We don't use pages of COW inode. So, we don't need to clean them up.

Quoted 189 lines
Quoted 189 lines
Quoted 189 lines

Thanks,

Quoted 184 lines

Thanks,

Quoted 181 lines

Thanks,

Quoted 176 lines · Chao Yu

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
   fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
   fs/f2fs/inode.c   | 11 +++++++++--
   fs/f2fs/segment.c |  3 ---
   fs/f2fs/super.c   |  2 --
   4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
                       atomic_read(&inode->i_writecount) != 1)
               return 0;
 
+     inode_lock(inode);
       f2fs_abort_atomic_write(inode, true);
+     inode_unlock(inode);
+
       return 0;
   }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
        * until all the writers close its file. Since this should be done
        * before dropping file lock, it needs to do in ->flush.
        */
-     if (F2FS_I(inode)->atomic_write_task == current)
+     if (F2FS_I(inode)->atomic_write_task == current) {
+             inode_lock(inode);
               f2fs_abort_atomic_write(inode, true);
+             inode_unlock(inode);
+     }
       return 0;
   }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
               goto out;
       }
 
-     /* Create a COW inode for atomic write */
-     pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-     if (IS_ERR(pinode)) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             ret = PTR_ERR(pinode);
-             goto out;
-     }
+     /* Check if the inode already has a COW inode */
+     if (fi->cow_inode == NULL) {
+             /* Create a COW inode for atomic write */
+             pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+             if (IS_ERR(pinode)) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     ret = PTR_ERR(pinode);
+                     goto out;
+             }
 
-     ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-     iput(pinode);
-     if (ret) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             goto out;
+             ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+             iput(pinode);
+             if (ret) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     goto out;
+             }
+
+             set_inode_flag(fi->cow_inode, FI_COW_FILE);
+             clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+     } else {
+             /* Reuse the already created COW inode */
+             f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
       }
 
       f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
       stat_inc_atomic_inode(inode);
 
       set_inode_flag(inode, FI_ATOMIC_FILE);
-     set_inode_flag(fi->cow_inode, FI_COW_FILE);
-     clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
       isize = i_size_read(inode);
       fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
   void f2fs_evict_inode(struct inode *inode)
   {
       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-     nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+     struct f2fs_inode_info *fi = F2FS_I(inode);
+     nid_t xnid = fi->i_xattr_nid;
       int err = 0;
 
       f2fs_abort_atomic_write(inode, true);
 
+     if (fi->cow_inode) {
+             clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+             iput(fi->cow_inode);
+             fi->cow_inode = NULL;
+     }
+
       trace_f2fs_evict_inode(inode);
       truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
       stat_dec_inline_inode(inode);
       stat_dec_compr_inode(inode);
       stat_sub_compr_blocks(inode,
-                     atomic_read(&F2FS_I(inode)->i_compr_blocks));
+                     atomic_read(&fi->i_compr_blocks));
 
       if (likely(!f2fs_cp_error(sbi) &&
                               !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
       if (!f2fs_is_atomic_file(inode))
               return;
 
-     clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-     iput(fi->cow_inode);
-     fi->cow_inode = NULL;
       release_atomic_write_cnt(inode);
       clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
       clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
                       atomic_inc(&inode->i_count);
                       spin_unlock(&inode->i_lock);
 
-                     f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

if (f2fs_is_atomic_file() && cow_inode)

         truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
                       /* should remain fi->extent_tree for writepage */
                       f2fs_destroy_extent_node(inode);
 
maintainer
#8 lore raw

Hi Daeho,

Quoted 40 lines · Daeho Jeong
Quoted 39 lines · Daeho Jeong
Quoted 36 lines · Daeho Jeong
Quoted 23 lines · Daeho Jeong

Hi Chao,

Quoted 19 lines · Chao Yu

Hi Daeho,

Quoted 3 lines · Daeho Jeong

Hi Chao,

I read your patch series now and I like it.

Thank you for checking the patches. :)

Quoted 2 lines

However, how about a race condition between start_atomic_write and abort_atomic_write?

Yup, I noticed that issue, I guess we can avoid this race condition by covering these two flows w/ i_atomic_sem.

Quoted 2 lines

abort_atomic_write is called without inode_lock in closing filp scenarios. What do you think about this?

Quoted 7 lines
Quoted 2 lines

I'm fine w/ your change as it's more clean, but it's better to drop cow_inode's page cache if atomic_write is committed or aborted to avoid caching obsolete page?

It's better to put that part in f2fs_abort_atomic_write(). On top of that, maybe, we should move f2fs_do_truncate_blocks(fi->cow_inode, 0, true) part from f2fs_ioc_start_atomic_write() to f2fs_abort_atomic_write(), too.

Oh, we shouldn't touch the f2fs_do_truncate_blocks() part, since there might be some left writeback after aborting atomic write.
Plz. review it related to the timing of calling truncate_inode_pages_final().

Quoted 8 lines
Quoted 6 lines

Looks like the scenario becomes too complicated if I think about more than one writer's scenario.
How about we check writecount in commit_atomic_write ioctl and return EBUSY when it's not only one writer?
In that case, we can make the scenario simple and effective, and we can release all the resources in abort_atomic_write().

Oh, I totally forgot this. We don't use pages of COW inode. So, we

Yes, after atomic_write is committed or aborted, we don't use pages of cow_inode, so they are obsolete, IMO, we'd better to reclaim them immediately to avoid unnecessary memory use.

The implementation may be:

- f2fs_ioc_abort_atomic_write
- f2fs_abort_atomic_write
- truncate_inode_pages_final(cow_inode)

- f2fs_ioc_commit_atomic_write
- f2fs_abort_atomic_write
- truncate_inode_pages_final(cow_inode)

Thanks,

Quoted 191 lines

don't need to clean them up.

Quoted 189 lines
Quoted 189 lines
Quoted 189 lines

Thanks,

Quoted 184 lines

Thanks,

Quoted 181 lines

Thanks,

Quoted 176 lines · Chao Yu

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
    fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
    fs/f2fs/inode.c   | 11 +++++++++--
    fs/f2fs/segment.c |  3 ---
    fs/f2fs/super.c   |  2 --
    4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
                        atomic_read(&inode->i_writecount) != 1)
                return 0;
 
+     inode_lock(inode);
        f2fs_abort_atomic_write(inode, true);
+     inode_unlock(inode);
+
        return 0;
    }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
         * until all the writers close its file. Since this should be done
         * before dropping file lock, it needs to do in ->flush.
         */
-     if (F2FS_I(inode)->atomic_write_task == current)
+     if (F2FS_I(inode)->atomic_write_task == current) {
+             inode_lock(inode);
                f2fs_abort_atomic_write(inode, true);
+             inode_unlock(inode);
+     }
        return 0;
    }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
                goto out;
        }
 
-     /* Create a COW inode for atomic write */
-     pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-     if (IS_ERR(pinode)) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             ret = PTR_ERR(pinode);
-             goto out;
-     }
+     /* Check if the inode already has a COW inode */
+     if (fi->cow_inode == NULL) {
+             /* Create a COW inode for atomic write */
+             pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+             if (IS_ERR(pinode)) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     ret = PTR_ERR(pinode);
+                     goto out;
+             }
 
-     ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-     iput(pinode);
-     if (ret) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             goto out;
+             ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+             iput(pinode);
+             if (ret) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     goto out;
+             }
+
+             set_inode_flag(fi->cow_inode, FI_COW_FILE);
+             clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+     } else {
+             /* Reuse the already created COW inode */
+             f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
        }
 
        f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
        stat_inc_atomic_inode(inode);
 
        set_inode_flag(inode, FI_ATOMIC_FILE);
-     set_inode_flag(fi->cow_inode, FI_COW_FILE);
-     clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
        isize = i_size_read(inode);
        fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
    void f2fs_evict_inode(struct inode *inode)
    {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-     nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+     struct f2fs_inode_info *fi = F2FS_I(inode);
+     nid_t xnid = fi->i_xattr_nid;
        int err = 0;
 
        f2fs_abort_atomic_write(inode, true);
 
+     if (fi->cow_inode) {
+             clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+             iput(fi->cow_inode);
+             fi->cow_inode = NULL;
+     }
+
        trace_f2fs_evict_inode(inode);
        truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
        stat_dec_inline_inode(inode);
        stat_dec_compr_inode(inode);
        stat_sub_compr_blocks(inode,
-                     atomic_read(&F2FS_I(inode)->i_compr_blocks));
+                     atomic_read(&fi->i_compr_blocks));
 
        if (likely(!f2fs_cp_error(sbi) &&
                                !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
        if (!f2fs_is_atomic_file(inode))
                return;
 
-     clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-     iput(fi->cow_inode);
-     fi->cow_inode = NULL;
        release_atomic_write_cnt(inode);
        clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
        clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
                        atomic_inc(&inode->i_count);
                        spin_unlock(&inode->i_lock);
 
-                     f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

if (f2fs_is_atomic_file() && cow_inode)

          truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
                        /* should remain fi->extent_tree for writepage */
                        f2fs_destroy_extent_node(inode);
 
#9 lore raw
Quoted 51 lines · Chao Yu

Hi Daeho,

Quoted 47 lines · Daeho Jeong
Quoted 45 lines · Daeho Jeong
Quoted 28 lines · Daeho Jeong
Quoted 26 lines · Daeho Jeong

Hi Chao,

Quoted 21 lines · Chao Yu

Hi Daeho,

Quoted 3 lines · Daeho Jeong

Hi Chao,

I read your patch series now and I like it.

Thank you for checking the patches. :)

Quoted 2 lines

However, how about a race condition between start_atomic_write and abort_atomic_write?

Yup, I noticed that issue, I guess we can avoid this race condition by covering these two flows w/ i_atomic_sem.

Quoted 2 lines

abort_atomic_write is called without inode_lock in closing filp scenarios. What do you think about this?

I'm fine w/ your change as it's more clean, but it's better to drop cow_inode's page cache if atomic_write is committed or aborted to avoid caching obsolete page?

Quoted 8 lines
Quoted 4 lines

It's better to put that part in f2fs_abort_atomic_write(). On top of that, maybe, we should move f2fs_do_truncate_blocks(fi->cow_inode, 0, true) part from f2fs_ioc_start_atomic_write() to f2fs_abort_atomic_write(), too.

Oh, we shouldn't touch the f2fs_do_truncate_blocks() part, since there might be some left writeback after aborting atomic write.
Plz. review it related to the timing of calling truncate_inode_pages_final().

Looks like the scenario becomes too complicated if I think about more than one writer's scenario.
How about we check writecount in commit_atomic_write ioctl and return EBUSY when it's not only one writer?
In that case, we can make the scenario simple and effective, and we can release all the resources in abort_atomic_write().

Quoted 5 lines
Quoted 1 line

Oh, I totally forgot this. We don't use pages of COW inode. So, we

Yes, after atomic_write is committed or aborted, we don't use pages of cow_inode, so they are obsolete, IMO, we'd better to reclaim them immediately to avoid unnecessary memory use.

I mean we don't use page cache of the COW inode at all during the whole atomic write procedure.
We only use the page cache of the original file.

Quoted 204 lines

The implementation may be:

- f2fs_ioc_abort_atomic_write
- f2fs_abort_atomic_write
- truncate_inode_pages_final(cow_inode)

- f2fs_ioc_commit_atomic_write
- f2fs_abort_atomic_write
- truncate_inode_pages_final(cow_inode)

Thanks,

Quoted 191 lines

don't need to clean them up.

Quoted 189 lines
Quoted 189 lines
Quoted 189 lines

Thanks,

Quoted 184 lines

Thanks,

Quoted 181 lines

Thanks,

Quoted 176 lines · Chao Yu

Hi Daeho, Jaegeuk,

Please take a look at patchset in below link:

https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t

In PATCH 4/5, I'm trying to fix the same issue w/ alternative way, let me know your preference. :)

One comment as below.

Quoted 146 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

To fix a race condition between atomic write aborts, I use the inode lock and make COW inode to be re-usable thoroughout the whole atomic file inode lifetime.

Reported-by [email protected]
Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
---
    fs/f2fs/file.c    | 43 ++++++++++++++++++++++++++++---------------
    fs/f2fs/inode.c   | 11 +++++++++--
    fs/f2fs/segment.c |  3 ---
    fs/f2fs/super.c   |  2 --
    4 files changed, 37 insertions(+), 22 deletions(-)
fs/f2fs/file.c +28 -15
index ecbc8c135b49..ff072a9ed258 100644
@@ -1866,7 +1866,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
                        atomic_read(&inode->i_writecount) != 1)
                return 0;
 
+     inode_lock(inode);
        f2fs_abort_atomic_write(inode, true);
+     inode_unlock(inode);
+
        return 0;
    }
 
@@ -1880,8 +1883,11 @@ static int f2fs_file_flush(struct file *file, fl_owner_t id)
         * until all the writers close its file. Since this should be done
         * before dropping file lock, it needs to do in ->flush.
         */
-     if (F2FS_I(inode)->atomic_write_task == current)
+     if (F2FS_I(inode)->atomic_write_task == current) {
+             inode_lock(inode);
                f2fs_abort_atomic_write(inode, true);
+             inode_unlock(inode);
+     }
        return 0;
    }
 
@@ -2087,19 +2093,28 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
                goto out;
        }
 
-     /* Create a COW inode for atomic write */
-     pinode = f2fs_iget(inode->i_sb, fi->i_pino);
-     if (IS_ERR(pinode)) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             ret = PTR_ERR(pinode);
-             goto out;
-     }
+     /* Check if the inode already has a COW inode */
+     if (fi->cow_inode == NULL) {
+             /* Create a COW inode for atomic write */
+             pinode = f2fs_iget(inode->i_sb, fi->i_pino);
+             if (IS_ERR(pinode)) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     ret = PTR_ERR(pinode);
+                     goto out;
+             }
 
-     ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
-     iput(pinode);
-     if (ret) {
-             f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
-             goto out;
+             ret = f2fs_get_tmpfile(mnt_userns, pinode, &fi->cow_inode);
+             iput(pinode);
+             if (ret) {
+                     f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
+                     goto out;
+             }
+
+             set_inode_flag(fi->cow_inode, FI_COW_FILE);
+             clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
+     } else {
+             /* Reuse the already created COW inode */
+             f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
        }
 
        f2fs_write_inode(inode, NULL);
@@ -2107,8 +2122,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
        stat_inc_atomic_inode(inode);
 
        set_inode_flag(inode, FI_ATOMIC_FILE);
-     set_inode_flag(fi->cow_inode, FI_COW_FILE);
-     clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 
        isize = i_size_read(inode);
        fi->original_i_size = isize;
fs/f2fs/inode.c +9 -2
index ff6cf66ed46b..4921f7209e28 100644
@@ -766,11 +766,18 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
    void f2fs_evict_inode(struct inode *inode)
    {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-     nid_t xnid = F2FS_I(inode)->i_xattr_nid;
+     struct f2fs_inode_info *fi = F2FS_I(inode);
+     nid_t xnid = fi->i_xattr_nid;
        int err = 0;
 
        f2fs_abort_atomic_write(inode, true);
 
+     if (fi->cow_inode) {
+             clear_inode_flag(fi->cow_inode, FI_COW_FILE);
+             iput(fi->cow_inode);
+             fi->cow_inode = NULL;
+     }
+
        trace_f2fs_evict_inode(inode);
        truncate_inode_pages_final(&inode->i_data);
 
@@ -857,7 +864,7 @@ void f2fs_evict_inode(struct inode *inode)
        stat_dec_inline_inode(inode);
        stat_dec_compr_inode(inode);
        stat_sub_compr_blocks(inode,
-                     atomic_read(&F2FS_I(inode)->i_compr_blocks));
+                     atomic_read(&fi->i_compr_blocks));
 
        if (likely(!f2fs_cp_error(sbi) &&
                                !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
fs/f2fs/segment.c +0 -3
index ae3c4e5474ef..536d7c674b04 100644
@@ -192,9 +192,6 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
        if (!f2fs_is_atomic_file(inode))
                return;
 
-     clear_inode_flag(fi->cow_inode, FI_COW_FILE);
-     iput(fi->cow_inode);
-     fi->cow_inode = NULL;
        release_atomic_write_cnt(inode);
        clear_inode_flag(inode, FI_ATOMIC_COMMITTED);
        clear_inode_flag(inode, FI_ATOMIC_REPLACE);
fs/f2fs/super.c +0 -0
index 1f812b9ce985..10463f084d30 100644

fs/f2fs/super.c static int f2fs_drop_inode(struct inode *inode) · line 1433

Quoted 4 lines
fs/f2fs/super.c +0 -1
@@ -1430,8 +1430,6 @@ static int f2fs_drop_inode(struct inode *inode)
                        atomic_inc(&inode->i_count);
                        spin_unlock(&inode->i_lock);
 
-                     f2fs_abort_atomic_write(inode, true);

In order to avoid caching obsolete page of cow_inode, how about truncating them here?

if (f2fs_is_atomic_file() && cow_inode)

          truncate_inode_pages_final(&cow_inode->i_data);

Thanks,

Quoted 4 lines
fs/f2fs/super.c +0 -1
-
                        /* should remain fi->extent_tree for writepage */
                        f2fs_destroy_extent_node(inode);