Skip to contentSkip to conversation

f2fs: correct i_size change for atomic writes

PATCH Superseded Daeho Jeong 4 participants 10 messages Oct 4, 2022 – Oct 17, 2022

Subsystems (2)

v4 of 6 Superseded Latest is v6 →

lore
Share & tools
lore
#0 lore raw

PATCH v4 1/2 f2fs: correct i_size change for atomic writes

From: Daeho Jeong <[email protected]>

We need to make sure i_size doesn't change until atomic write commit is successful and restore it when commit is failed.

---
v4: move i_size update after clearing atomic file flag in
f2fs_abort_atomic_write()
v3: make sure inode is clean while atomic writing

---
 fs/f2fs/f2fs.h    |  1 +
 fs/f2fs/file.c    | 18 +++++++++++-------
 fs/f2fs/inode.c   |  3 +++
 fs/f2fs/segment.c |  7 +++++--
 4 files changed, 20 insertions(+), 9 deletions(-)
fs/f2fs/f2fs.h +1 -0
index dee7b67a17a6..539da7f12cfc 100644
@@ -821,6 +821,7 @@ struct f2fs_inode_info {
 	unsigned int i_cluster_size;		/* cluster size */
 
 	unsigned int atomic_write_cnt;
+	loff_t original_i_size;		/* original i_size before atomic write */
 };
 
 static inline void get_extent_info(struct extent_info *ext,
fs/f2fs/file.c +11 -7
index 5efe0e4a725a..ce2336d2f688 100644
@@ -1989,6 +1989,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 	struct f2fs_inode_info *fi = F2FS_I(inode);
 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	struct inode *pinode;
+	loff_t isize;
 	int ret;
 
 	if (!inode_owner_or_capable(mnt_userns, inode))
@@ -2047,7 +2048,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 		f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
 		goto out;
 	}
-	f2fs_i_size_write(fi->cow_inode, i_size_read(inode));
+
+	f2fs_write_inode(inode, NULL);
+
+	isize = i_size_read(inode);
+	fi->original_i_size = isize;
+	f2fs_i_size_write(fi->cow_inode, isize);
 
 	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
 	sbi->atomic_files++;
@@ -2087,16 +2093,14 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
 
 	if (f2fs_is_atomic_file(inode)) {
 		ret = f2fs_commit_atomic_write(inode);
-		if (ret)
-			goto unlock_out;
-
-		ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
 		if (!ret)
-			f2fs_abort_atomic_write(inode, false);
+			ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
+
+		f2fs_abort_atomic_write(inode, ret);
 	} else {
 		ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
 	}
-unlock_out:
+
 	inode_unlock(inode);
 	mnt_drop_write_file(filp);
 	return ret;
fs/f2fs/inode.c +3 -0
index cde0a3dc80c3..64d7772b4cd9 100644
@@ -30,6 +30,9 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
 	if (f2fs_inode_dirtied(inode, sync))
 		return;
 
+	if (f2fs_is_atomic_file(inode))
+		return;
+
 	mark_inode_dirty_sync(inode);
 }
 
fs/f2fs/segment.c +5 -2
index 460048f3c850..abb55cd418c1 100644
@@ -193,14 +193,17 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
 	if (!f2fs_is_atomic_file(inode))
 		return;
 
-	if (clean)
-		truncate_inode_pages_final(inode->i_mapping);
 	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_FILE);
 
+	if (clean) {
+		truncate_inode_pages_final(inode->i_mapping);
+		f2fs_i_size_write(inode, fi->original_i_size);
+	}
+
 	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
 	sbi->atomic_files--;
 	spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
Signature · 1 line
2.38.0.rc1.362.ged0d419d3c-goog
#1 lore raw

PATCH v4 2/2 f2fs: introduce F2FS_IOC_START_ATOMIC_REPLACE

From: Daeho Jeong <[email protected]>

introduce a new ioctl to replace the whole content of a file atomically, which means it induces truncate and content update at the same time. We can start it with F2FS_IOC_START_ATOMIC_REPLACE and complete it with F2FS_IOC_COMMIT_ATOMIC_WRITE. Or abort it with F2FS_IOC_ABORT_ATOMIC_WRITE.

---
v3: move i_size change after setting atomic write flag
v2: add undefined ioctl number reported by <[email protected]>

---
 fs/f2fs/data.c            |  3 +++
 fs/f2fs/f2fs.h            |  1 +
 fs/f2fs/file.c            | 20 ++++++++++++++------
 fs/f2fs/segment.c         | 14 +++++++++++++-
 include/uapi/linux/f2fs.h |  1 +
 5 files changed, 32 insertions(+), 7 deletions(-)
fs/f2fs/data.c +3 -0
index 6cd29a575105..d3d32db3a25d 100644
@@ -3438,6 +3438,9 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
 	else if (*blk_addr != NULL_ADDR)
 		return 0;
 
+	if (is_inode_flag_set(inode, FI_ATOMIC_REPLACE))
+		goto reserve_block;
+
 	/* Look for the block in the original inode */
 	err = __find_data_block(inode, index, &ori_blk_addr);
 	if (err)
fs/f2fs/f2fs.h +1 -0
index 539da7f12cfc..2c49da12d6d8 100644
@@ -764,6 +764,7 @@ enum {
 	FI_COMPRESS_RELEASED,	/* compressed blocks were released */
 	FI_ALIGNED_WRITE,	/* enable aligned write */
 	FI_COW_FILE,		/* indicate COW file */
+	FI_ATOMIC_REPLACE,	/* indicate atomic replace */
 	FI_MAX,			/* max flag, never be used */
 };
 
fs/f2fs/file.c +14 -6
index ce2336d2f688..66d62ea42c73 100644
@@ -1982,7 +1982,7 @@ static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
 	return put_user(inode->i_generation, (int __user *)arg);
 }
 
-static int f2fs_ioc_start_atomic_write(struct file *filp)
+static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 {
 	struct inode *inode = file_inode(filp);
 	struct user_namespace *mnt_userns = file_mnt_user_ns(filp);
@@ -2051,10 +2051,6 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 
 	f2fs_write_inode(inode, NULL);
 
-	isize = i_size_read(inode);
-	fi->original_i_size = isize;
-	f2fs_i_size_write(fi->cow_inode, isize);
-
 	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
 	sbi->atomic_files++;
 	spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
@@ -2064,6 +2060,16 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 	clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 	f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
 
+	isize = i_size_read(inode);
+	fi->original_i_size = isize;
+	if (truncate) {
+		set_inode_flag(inode, FI_ATOMIC_REPLACE);
+		truncate_inode_pages_final(inode->i_mapping);
+		f2fs_i_size_write(inode, 0);
+		isize = 0;
+	}
+	f2fs_i_size_write(fi->cow_inode, isize);
+
 	f2fs_update_time(sbi, REQ_TIME);
 	fi->atomic_write_task = current;
 	stat_update_max_atomic_write(inode);
@@ -4082,7 +4088,9 @@ static long __f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 	case FS_IOC_GETVERSION:
 		return f2fs_ioc_getversion(filp, arg);
 	case F2FS_IOC_START_ATOMIC_WRITE:
-		return f2fs_ioc_start_atomic_write(filp);
+		return f2fs_ioc_start_atomic_write(filp, false);
+	case F2FS_IOC_START_ATOMIC_REPLACE:
+		return f2fs_ioc_start_atomic_write(filp, true);
 	case F2FS_IOC_COMMIT_ATOMIC_WRITE:
 		return f2fs_ioc_commit_atomic_write(filp);
 	case F2FS_IOC_ABORT_ATOMIC_WRITE:
fs/f2fs/segment.c +13 -1
index abb55cd418c1..e4f7efbdc027 100644
@@ -264,14 +264,26 @@ static void __complete_revoke_list(struct inode *inode, struct list_head *head,
 					bool revoke)
 {
 	struct revoke_entry *cur, *tmp;
+	pgoff_t start_index = 0;
+	bool truncate = is_inode_flag_set(inode, FI_ATOMIC_REPLACE);
 
 	list_for_each_entry_safe(cur, tmp, head, list) {
-		if (revoke)
+		if (revoke) {
 			__replace_atomic_write_block(inode, cur->index,
 						cur->old_addr, NULL, true);
+		} else if (truncate) {
+			f2fs_truncate_hole(inode, start_index, cur->index);
+			start_index = cur->index + 1;
+		}
+
 		list_del(&cur->list);
 		kmem_cache_free(revoke_entry_slab, cur);
 	}
+
+	if (!revoke && truncate) {
+		f2fs_do_truncate_blocks(inode, start_index * PAGE_SIZE, false);
+		clear_inode_flag(inode, FI_ATOMIC_REPLACE);
+	}
 }
 
 static int __f2fs_commit_atomic_write(struct inode *inode)
include/uapi/linux/f2fs.h +1 -0
index 3121d127d5aa..955d440be104 100644
@@ -42,6 +42,7 @@
 						struct f2fs_comp_option)
 #define F2FS_IOC_DECOMPRESS_FILE	_IO(F2FS_IOCTL_MAGIC, 23)
 #define F2FS_IOC_COMPRESS_FILE		_IO(F2FS_IOCTL_MAGIC, 24)
+#define F2FS_IOC_START_ATOMIC_REPLACE	_IO(F2FS_IOCTL_MAGIC, 25)
 
 /*
  * should be same as XFS_IOC_GOINGDOWN.
Signature · 8 lines
2.38.0.rc1.362.ged0d419d3c-goog



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

Re: [PATCH v4 2/2] f2fs: introduce F2FS_IOC_START_ATOMIC_REPLACE

Quoted 7 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

introduce a new ioctl to replace the whole content of a file atomically, which means it induces truncate and content update at the same time. We can start it with F2FS_IOC_START_ATOMIC_REPLACE and complete it with F2FS_IOC_COMMIT_ATOMIC_WRITE. Or abort it with F2FS_IOC_ABORT_ATOMIC_WRITE.

It would be great to Cc Darrick and linux-fsdevel as there have been attempts to do this properly at the VFS level instead of a completely undocumented ioctl.

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

#3 lore raw

Re: [PATCH v4 2/2] f2fs: introduce F2FS_IOC_START_ATOMIC_REPLACE

Quoted 9 lines · Christoph Hellwig
Quoted 7 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

introduce a new ioctl to replace the whole content of a file atomically, which means it induces truncate and content update at the same time. We can start it with F2FS_IOC_START_ATOMIC_REPLACE and complete it with F2FS_IOC_COMMIT_ATOMIC_WRITE. Or abort it with F2FS_IOC_ABORT_ATOMIC_WRITE.

Quoted 3 lines

It would be great to Cc Darrick and linux-fsdevel as there have been attempts to do this properly at the VFS level instead of a completely undocumented ioctl.

It's been a while since I sent the last RFC, but yes, it's still in my queue as part of the xfs online fsck patchserieses.

https://lore.kernel.org/linux-fsdevel/161723932606.3149451.12366114306150243052.stgit@magnolia/

More recent git branch:
https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux.git/log/?h=atomic-file-updates

--D

#4 lore raw

Re: [PATCH v4 2/2] f2fs: introduce F2FS_IOC_START_ATOMIC_REPLACE

Quoted 15 lines · Darrick J. Wong
Quoted 9 lines · Christoph Hellwig
Quoted 7 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

introduce a new ioctl to replace the whole content of a file atomically, which means it induces truncate and content update at the same time. We can start it with F2FS_IOC_START_ATOMIC_REPLACE and complete it with F2FS_IOC_COMMIT_ATOMIC_WRITE. Or abort it with F2FS_IOC_ABORT_ATOMIC_WRITE.

Quoted 3 lines

It would be great to Cc Darrick and linux-fsdevel as there have been attempts to do this properly at the VFS level instead of a completely undocumented ioctl.

Quoted 7 lines

It's been a while since I sent the last RFC, but yes, it's still in my queue as part of the xfs online fsck patchserieses.

https://lore.kernel.org/linux-fsdevel/161723932606.3149451.12366114306150243052.stgit@magnolia/

More recent git branch:
https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux.git/log/?h=atomic-file-updates

Hi,

It's a very interesting suggestion and we might use this in F2FS someday. However, I think it's not exactly matched for what F2FS_IOC_START_ATOMIC_REPLACE is doing now.

Thanks for bringing my attention to this.

Quoted 2 lines

--D

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

maintainer
#5 lore raw
In reply to Daeho Jeong
Quoted 81 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

We need to make sure i_size doesn't change until atomic write commit is successful and restore it when commit is failed.

---
v4: move i_size update after clearing atomic file flag in
f2fs_abort_atomic_write()
v3: make sure inode is clean while atomic writing

---
  fs/f2fs/f2fs.h    |  1 +
  fs/f2fs/file.c    | 18 +++++++++++-------
  fs/f2fs/inode.c   |  3 +++
  fs/f2fs/segment.c |  7 +++++--
  4 files changed, 20 insertions(+), 9 deletions(-)
fs/f2fs/f2fs.h +1 -0
index dee7b67a17a6..539da7f12cfc 100644
@@ -821,6 +821,7 @@ struct f2fs_inode_info {
  	unsigned int i_cluster_size;		/* cluster size */
 
  	unsigned int atomic_write_cnt;
+	loff_t original_i_size;		/* original i_size before atomic write */
  };
 
  static inline void get_extent_info(struct extent_info *ext,
fs/f2fs/file.c +11 -7
index 5efe0e4a725a..ce2336d2f688 100644
@@ -1989,6 +1989,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
  	struct f2fs_inode_info *fi = F2FS_I(inode);
  	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
  	struct inode *pinode;
+	loff_t isize;
  	int ret;
 
  	if (!inode_owner_or_capable(mnt_userns, inode))
@@ -2047,7 +2048,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
  		f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
  		goto out;
  	}
-	f2fs_i_size_write(fi->cow_inode, i_size_read(inode));
+
+	f2fs_write_inode(inode, NULL);
+
+	isize = i_size_read(inode);
+	fi->original_i_size = isize;
+	f2fs_i_size_write(fi->cow_inode, isize);
 
  	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
  	sbi->atomic_files++;
@@ -2087,16 +2093,14 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
 
  	if (f2fs_is_atomic_file(inode)) {
  		ret = f2fs_commit_atomic_write(inode);
-		if (ret)
-			goto unlock_out;
-
-		ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
  		if (!ret)
-			f2fs_abort_atomic_write(inode, false);
+			ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
+
+		f2fs_abort_atomic_write(inode, ret);
  	} else {
  		ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
  	}
-unlock_out:
+
  	inode_unlock(inode);
  	mnt_drop_write_file(filp);
  	return ret;
fs/f2fs/inode.c +0 -0
index cde0a3dc80c3..64d7772b4cd9 100644

fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 34

Quoted 5 lines
fs/f2fs/inode.c +2 -0
@@ -30,6 +30,9 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
  	if (f2fs_inode_dirtied(inode, sync))
  		return;
 
+	if (f2fs_is_atomic_file(inode))
+		return;

One question, after f2fs_inode_dirtied(), atomic_file is added to inode_list[DIRTY_META], and it will be flushed by checkpoint() triggered in between write() and atomic_commit ioctl, is it not expected that inode w/ new i_size will be persisted?

Should write_end() skip updating atomic_file's i_size and let atomic_commit() update it if there is no error?

Thanks,

Quoted 28 lines
fs/f2fs/inode.c +1 -0
+
  	mark_inode_dirty_sync(inode);
  }
 
fs/f2fs/segment.c +5 -2
index 460048f3c850..abb55cd418c1 100644
@@ -193,14 +193,17 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
  	if (!f2fs_is_atomic_file(inode))
  		return;
 
-	if (clean)
-		truncate_inode_pages_final(inode->i_mapping);
  	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_FILE);
 
+	if (clean) {
+		truncate_inode_pages_final(inode->i_mapping);
+		f2fs_i_size_write(inode, fi->original_i_size);
+	}
+
  	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
  	sbi->atomic_files--;
  	spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
#6 lore raw
Quoted 86 lines · Chao Yu
Quoted 84 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

We need to make sure i_size doesn't change until atomic write commit is successful and restore it when commit is failed.

---
v4: move i_size update after clearing atomic file flag in
f2fs_abort_atomic_write()
v3: make sure inode is clean while atomic writing

---
  fs/f2fs/f2fs.h    |  1 +
  fs/f2fs/file.c    | 18 +++++++++++-------
  fs/f2fs/inode.c   |  3 +++
  fs/f2fs/segment.c |  7 +++++--
  4 files changed, 20 insertions(+), 9 deletions(-)
fs/f2fs/f2fs.h +1 -0
index dee7b67a17a6..539da7f12cfc 100644
@@ -821,6 +821,7 @@ struct f2fs_inode_info {
      unsigned int i_cluster_size;            /* cluster size */
 
      unsigned int atomic_write_cnt;
+     loff_t original_i_size;         /* original i_size before atomic write */
  };
 
  static inline void get_extent_info(struct extent_info *ext,
fs/f2fs/file.c +11 -7
index 5efe0e4a725a..ce2336d2f688 100644
@@ -1989,6 +1989,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
      struct f2fs_inode_info *fi = F2FS_I(inode);
      struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
      struct inode *pinode;
+     loff_t isize;
      int ret;
 
      if (!inode_owner_or_capable(mnt_userns, inode))
@@ -2047,7 +2048,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
              f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
              goto out;
      }
-     f2fs_i_size_write(fi->cow_inode, i_size_read(inode));
+
+     f2fs_write_inode(inode, NULL);
+
+     isize = i_size_read(inode);
+     fi->original_i_size = isize;
+     f2fs_i_size_write(fi->cow_inode, isize);
 
      spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
      sbi->atomic_files++;
@@ -2087,16 +2093,14 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
 
      if (f2fs_is_atomic_file(inode)) {
              ret = f2fs_commit_atomic_write(inode);
-             if (ret)
-                     goto unlock_out;
-
-             ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
              if (!ret)
-                     f2fs_abort_atomic_write(inode, false);
+                     ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
+
+             f2fs_abort_atomic_write(inode, ret);
      } else {
              ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
      }
-unlock_out:
+
      inode_unlock(inode);
      mnt_drop_write_file(filp);
      return ret;
fs/f2fs/inode.c +0 -0
index cde0a3dc80c3..64d7772b4cd9 100644
@@ -30,6 +30,9 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
      if (f2fs_inode_dirtied(inode, sync))
              return;
 
Quoted 7 lines

fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 34

Quoted 2 lines
fs/f2fs/inode.c +2 -0
+     if (f2fs_is_atomic_file(inode))
+             return;

One question, after f2fs_inode_dirtied(), atomic_file is added to inode_list[DIRTY_META], and it will be flushed by checkpoint() triggered in between write() and atomic_commit ioctl, is it not expected that inode w/ new i_size will be persisted?

Isn't it okay if we move f2fs_is_atomic_file() ahead of f2fs_inode_dirtied()?

Quoted 3 lines

Should write_end() skip updating atomic_file's i_size and let atomic_commit() update it if there is no error?

In this case, the user can't see the changed i_size while writing an atomic file.

Quoted 31 lines

Thanks,

Quoted 28 lines
fs/f2fs/inode.c +1 -0
+
      mark_inode_dirty_sync(inode);
  }
 
fs/f2fs/segment.c +5 -2
index 460048f3c850..abb55cd418c1 100644
@@ -193,14 +193,17 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
      if (!f2fs_is_atomic_file(inode))
              return;
 
-     if (clean)
-             truncate_inode_pages_final(inode->i_mapping);
      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_FILE);
 
+     if (clean) {
+             truncate_inode_pages_final(inode->i_mapping);
+             f2fs_i_size_write(inode, fi->original_i_size);
+     }
+
      spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
      sbi->atomic_files--;
      spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
maintainer
#7 lore raw
Quoted 95 lines · Daeho Jeong
Quoted 86 lines · Chao Yu
Quoted 84 lines · Daeho Jeong

From: Daeho Jeong <[email protected]>

We need to make sure i_size doesn't change until atomic write commit is successful and restore it when commit is failed.

---
v4: move i_size update after clearing atomic file flag in
f2fs_abort_atomic_write()
v3: make sure inode is clean while atomic writing

---
   fs/f2fs/f2fs.h    |  1 +
   fs/f2fs/file.c    | 18 +++++++++++-------
   fs/f2fs/inode.c   |  3 +++
   fs/f2fs/segment.c |  7 +++++--
   4 files changed, 20 insertions(+), 9 deletions(-)
fs/f2fs/f2fs.h +1 -0
index dee7b67a17a6..539da7f12cfc 100644
@@ -821,6 +821,7 @@ struct f2fs_inode_info {
       unsigned int i_cluster_size;            /* cluster size */
 
       unsigned int atomic_write_cnt;
+     loff_t original_i_size;         /* original i_size before atomic write */
   };
 
   static inline void get_extent_info(struct extent_info *ext,
fs/f2fs/file.c +11 -7
index 5efe0e4a725a..ce2336d2f688 100644
@@ -1989,6 +1989,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
       struct f2fs_inode_info *fi = F2FS_I(inode);
       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
       struct inode *pinode;
+     loff_t isize;
       int ret;
 
       if (!inode_owner_or_capable(mnt_userns, inode))
@@ -2047,7 +2048,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
               f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
               goto out;
       }
-     f2fs_i_size_write(fi->cow_inode, i_size_read(inode));
+
+     f2fs_write_inode(inode, NULL);
+
+     isize = i_size_read(inode);
+     fi->original_i_size = isize;
+     f2fs_i_size_write(fi->cow_inode, isize);
 
       spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
       sbi->atomic_files++;
@@ -2087,16 +2093,14 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
 
       if (f2fs_is_atomic_file(inode)) {
               ret = f2fs_commit_atomic_write(inode);
-             if (ret)
-                     goto unlock_out;
-
-             ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
               if (!ret)
-                     f2fs_abort_atomic_write(inode, false);
+                     ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
+
+             f2fs_abort_atomic_write(inode, ret);
       } else {
               ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
       }
-unlock_out:
+
       inode_unlock(inode);
       mnt_drop_write_file(filp);
       return ret;
fs/f2fs/inode.c +0 -0
index cde0a3dc80c3..64d7772b4cd9 100644
@@ -30,6 +30,9 @@ void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
       if (f2fs_inode_dirtied(inode, sync))
               return;
 
Quoted 7 lines

fs/f2fs/inode.c void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync) · line 34

Quoted 2 lines
fs/f2fs/inode.c +2 -0
+     if (f2fs_is_atomic_file(inode))
+             return;

One question, after f2fs_inode_dirtied(), atomic_file is added to inode_list[DIRTY_META], and it will be flushed by checkpoint() triggered in between write() and atomic_commit ioctl, is it not expected that inode w/ new i_size will be persisted?

Quoted 1 line

Isn't it okay if we move f2fs_is_atomic_file() ahead of f2fs_inode_dirtied()?

Fine to me.

But another question is, now it allows GC to migrate blocks belong to atomic files, so, during migration, it may update extent cache, once largest extent was updated, it will mark inode dirty, but after this patch, it may lose the extent change? thoughts?

Quoted 7 lines
Quoted 4 lines

Should write_end() skip updating atomic_file's i_size and let atomic_commit() update it if there is no error?

In this case, the user can't see the changed i_size while writing an atomic file.

Oh, right, please ignore this comment...

Thanks,

Quoted 32 lines
Quoted 32 lines

Thanks,

Quoted 28 lines
fs/f2fs/inode.c +1 -0
+
       mark_inode_dirty_sync(inode);
   }
 
fs/f2fs/segment.c +5 -2
index 460048f3c850..abb55cd418c1 100644
@@ -193,14 +193,17 @@ void f2fs_abort_atomic_write(struct inode *inode, bool clean)
       if (!f2fs_is_atomic_file(inode))
               return;
 
-     if (clean)
-             truncate_inode_pages_final(inode->i_mapping);
       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_FILE);
 
+     if (clean) {
+             truncate_inode_pages_final(inode->i_mapping);
+             f2fs_i_size_write(inode, fi->original_i_size);
+     }
+
       spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
       sbi->atomic_files--;
       spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
#8 lore raw
Quoted 8 lines

Fine to me.

But another question is, now it allows GC to migrate blocks belong to atomic files, so, during migration, it may update extent cache, once largest extent was updated, it will mark inode dirty, but after this patch, it may lose the extent change? thoughts?

Oh, I missed that case. Maybe we could prevent updating the i_size of atomic files in f2fs_update_inode() while allowing inode dirtying.

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

maintainer
#9 lore raw
Quoted 11 lines · Daeho Jeong
Quoted 8 lines

Fine to me.

But another question is, now it allows GC to migrate blocks belong to atomic files, so, during migration, it may update extent cache, once largest extent was updated, it will mark inode dirty, but after this patch, it may lose the extent change? thoughts?

Oh, I missed that case. Maybe we could prevent updating the i_size of atomic files in f2fs_update_inode() while allowing inode dirtying.

Agreed. :)

Thanks,