Skip to contentSkip to conversation

f2fs: introduce F2FS_IOC_START_ATOMIC_REPLACE

PATCH Superseded Daeho Jeong 2 participants 10 messages Sep 20, 2022 – Oct 3, 2022 F2FS file system

v2 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 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.

---
v2: add undefined ioctl number reported by <[email protected]>

---
 fs/f2fs/data.c            |  3 +++
 fs/f2fs/f2fs.h            |  1 +
 fs/f2fs/file.c            | 12 ++++++++++--
 fs/f2fs/segment.c         | 14 +++++++++++++-
 include/uapi/linux/f2fs.h |  1 +
 5 files changed, 28 insertions(+), 3 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 +10 -2
index 4f9b80c41b1e..4abd9d2a55b3 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,6 +2051,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 
 	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);
 
 	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
@@ -4080,7 +4086,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 143b7ea0fb8e..c524538a9013 100644
@@ -263,14 +263,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.37.3.968.ga6b4b080e4-goog



_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
maintainer
#1 lore raw
Quoted 59 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.

---
v2: add undefined ioctl number reported by <[email protected]>

---
  fs/f2fs/data.c            |  3 +++
  fs/f2fs/f2fs.h            |  1 +
  fs/f2fs/file.c            | 12 ++++++++++--
  fs/f2fs/segment.c         | 14 +++++++++++++-
  include/uapi/linux/f2fs.h |  1 +
  5 files changed, 28 insertions(+), 3 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 +1 -1
index 4f9b80c41b1e..4abd9d2a55b3 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);

fs/f2fs/file.c static int f2fs_ioc_start_atomic_write(struct file *filp) · line 2059

Quoted 9 lines
fs/f2fs/file.c +6 -0
@@ -2051,6 +2051,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 
  	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;
+	}

Hi Daeho,

isize should be updated after tagging inode as atomic_write one? otherwise f2fs_mark_inode_dirty_sync() may update isize to inode page, latter checkpoint may persist that change? IIUC...

Thanks,

Quoted 58 lines
fs/f2fs/file.c +3 -1
  	f2fs_i_size_write(fi->cow_inode, isize);
 
  	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
@@ -4080,7 +4086,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 143b7ea0fb8e..c524538a9013 100644
@@ -263,14 +263,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.
#2 lore raw
Quoted 73 lines · Chao Yu
Quoted 59 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.

---
v2: add undefined ioctl number reported by <[email protected]>

---
  fs/f2fs/data.c            |  3 +++
  fs/f2fs/f2fs.h            |  1 +
  fs/f2fs/file.c            | 12 ++++++++++--
  fs/f2fs/segment.c         | 14 +++++++++++++-
  include/uapi/linux/f2fs.h |  1 +
  5 files changed, 28 insertions(+), 3 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 +1 -1
index 4f9b80c41b1e..4abd9d2a55b3 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);

fs/f2fs/file.c static int f2fs_ioc_start_atomic_write(struct file *filp) · line 2059

Quoted 9 lines
fs/f2fs/file.c +6 -0
@@ -2051,6 +2051,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 
      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;
+     }

Hi Daeho,

Quoted 5 lines

isize should be updated after tagging inode as atomic_write one? otherwise f2fs_mark_inode_dirty_sync() may update isize to inode page, latter checkpoint may persist that change? IIUC...

Thanks,

Hi Chao,

The first patch of this patchset prevents the inode page from being updated as dirty for atomic file cases.
Is there any other chances for the inode page to be marked as dirty?

Thanks,

Quoted 59 lines
Quoted 59 lines
fs/f2fs/file.c +3 -1
      f2fs_i_size_write(fi->cow_inode, isize);
 
      spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
@@ -4080,7 +4086,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 143b7ea0fb8e..c524538a9013 100644
@@ -263,14 +263,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.
maintainer
#3 lore raw
Quoted 78 lines · Daeho Jeong
Quoted 77 lines · Chao Yu
Quoted 59 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.

---
v2: add undefined ioctl number reported by <[email protected]>

---
   fs/f2fs/data.c            |  3 +++
   fs/f2fs/f2fs.h            |  1 +
   fs/f2fs/file.c            | 12 ++++++++++--
   fs/f2fs/segment.c         | 14 +++++++++++++-
   include/uapi/linux/f2fs.h |  1 +
   5 files changed, 28 insertions(+), 3 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 +1 -1
index 4f9b80c41b1e..4abd9d2a55b3 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);

fs/f2fs/file.c static int f2fs_ioc_start_atomic_write(struct file *filp) · line 2059

Quoted 9 lines
fs/f2fs/file.c +6 -0
@@ -2051,6 +2051,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 
       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;
+     }

Hi Daeho,

isize should be updated after tagging inode as atomic_write one? otherwise f2fs_mark_inode_dirty_sync() may update isize to inode page, latter checkpoint may persist that change? IIUC...

Quoted 7 lines
Quoted 1 line

Thanks,

Hi Chao,

The first patch of this patchset prevents the inode page from being updated as dirty for atomic file cases.
Is there any other chances for the inode page to be marked as dirty?

I mean:

Thread A Thread B
- f2fs_ioc_start_atomic_write
- f2fs_i_size_write(inode, 0)
- f2fs_mark_inode_dirty_sync
- checkpoint
- persist inode with incorrect zero isize

- set_inode_flag(inode, FI_ATOMIC_FILE)

Am I missing something?

Thanks,

Quoted 62 lines

Thanks,

Quoted 59 lines
Quoted 59 lines
fs/f2fs/file.c +3 -1
       f2fs_i_size_write(fi->cow_inode, isize);
 
       spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
@@ -4080,7 +4086,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 143b7ea0fb8e..c524538a9013 100644
@@ -263,14 +263,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.
#4 lore raw
Quoted 97 lines · Chao Yu
Quoted 78 lines · Daeho Jeong
Quoted 77 lines · Chao Yu
Quoted 59 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.

---
v2: add undefined ioctl number reported by <[email protected]>

---
   fs/f2fs/data.c            |  3 +++
   fs/f2fs/f2fs.h            |  1 +
   fs/f2fs/file.c            | 12 ++++++++++--
   fs/f2fs/segment.c         | 14 +++++++++++++-
   include/uapi/linux/f2fs.h |  1 +
   5 files changed, 28 insertions(+), 3 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 +1 -1
index 4f9b80c41b1e..4abd9d2a55b3 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);

fs/f2fs/file.c static int f2fs_ioc_start_atomic_write(struct file *filp) · line 2059

Quoted 9 lines
fs/f2fs/file.c +6 -0
@@ -2051,6 +2051,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 
       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;
+     }

Hi Daeho,

isize should be updated after tagging inode as atomic_write one? otherwise f2fs_mark_inode_dirty_sync() may update isize to inode page, latter checkpoint may persist that change? IIUC...

Quoted 7 lines
Quoted 1 line

Thanks,

Hi Chao,

The first patch of this patchset prevents the inode page from being updated as dirty for atomic file cases.
Is there any other chances for the inode page to be marked as dirty?

I mean:

Thread A Thread B
- f2fs_ioc_start_atomic_write
- f2fs_i_size_write(inode, 0)
- f2fs_mark_inode_dirty_sync
- checkpoint
- persist inode with incorrect zero isize

Quoted 4 lines

- set_inode_flag(inode, FI_ATOMIC_FILE)

Am I missing something?

So, f2fs_mark_inode_dirty_sync() will not work for atomic files anymore, which means it doesn't make the inode dirty.
Plz, refer to the first patch of this patchset. Or I might be confused with something. :(

@@ -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);

}

Quoted 64 lines

Thanks,

Quoted 62 lines

Thanks,

Quoted 59 lines
Quoted 59 lines
fs/f2fs/file.c +3 -1
       f2fs_i_size_write(fi->cow_inode, isize);
 
       spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
@@ -4080,7 +4086,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 143b7ea0fb8e..c524538a9013 100644
@@ -263,14 +263,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.
maintainer
#5 lore raw
Quoted 100 lines · Daeho Jeong
Quoted 99 lines · Chao Yu
Quoted 78 lines · Daeho Jeong
Quoted 77 lines · Chao Yu
Quoted 59 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.

---
v2: add undefined ioctl number reported by <[email protected]>

---
    fs/f2fs/data.c            |  3 +++
    fs/f2fs/f2fs.h            |  1 +
    fs/f2fs/file.c            | 12 ++++++++++--
    fs/f2fs/segment.c         | 14 +++++++++++++-
    include/uapi/linux/f2fs.h |  1 +
    5 files changed, 28 insertions(+), 3 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 +1 -1
index 4f9b80c41b1e..4abd9d2a55b3 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);

fs/f2fs/file.c static int f2fs_ioc_start_atomic_write(struct file *filp) · line 2059

Quoted 9 lines
fs/f2fs/file.c +6 -0
@@ -2051,6 +2051,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
 
        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;
+     }

Hi Daeho,

isize should be updated after tagging inode as atomic_write one? otherwise f2fs_mark_inode_dirty_sync() may update isize to inode page, latter checkpoint may persist that change? IIUC...

Quoted 7 lines
Quoted 1 line

Thanks,

Hi Chao,

The first patch of this patchset prevents the inode page from being updated as dirty for atomic file cases.
Is there any other chances for the inode page to be marked as dirty?

I mean:

Thread A Thread B
- f2fs_ioc_start_atomic_write
- f2fs_i_size_write(inode, 0)
- f2fs_mark_inode_dirty_sync
- checkpoint
- persist inode with incorrect zero isize

- set_inode_flag(inode, FI_ATOMIC_FILE)

Quoted 7 lines
Quoted 2 lines

Am I missing something?

So, f2fs_mark_inode_dirty_sync() will not work for atomic files anymore, which means it doesn't make the inode dirty.
Plz, refer to the first patch of this patchset. Or I might be confused with something. :(

I mean FI_ATOMIC_FILE was set after f2fs_i_size_write(), so inode will be set as dirty.

Thanks,

Quoted 80 lines
(quoted diff) +3 -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;
+
         mark_inode_dirty_sync(inode);
  }
Quoted 69 lines

Thanks,

Quoted 62 lines

Thanks,

Quoted 59 lines
Quoted 59 lines
fs/f2fs/file.c +3 -1
        f2fs_i_size_write(fi->cow_inode, isize);
 
        spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
@@ -4080,7 +4086,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 143b7ea0fb8e..c524538a9013 100644
@@ -263,14 +263,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.
#6 lore raw
Quoted 34 lines
Quoted 26 lines
Quoted 26 lines
Quoted 7 lines
Quoted 7 lines

Hi Daeho,

isize should be updated after tagging inode as atomic_write one? otherwise f2fs_mark_inode_dirty_sync() may update isize to inode page, latter checkpoint may persist that change? IIUC...

Quoted 7 lines
Quoted 1 line

Thanks,

Hi Chao,

The first patch of this patchset prevents the inode page from being updated as dirty for atomic file cases.
Is there any other chances for the inode page to be marked as dirty?

I mean:

Thread A Thread B
- f2fs_ioc_start_atomic_write
- f2fs_i_size_write(inode, 0)
- f2fs_mark_inode_dirty_sync
- checkpoint
- persist inode with incorrect zero isize

- set_inode_flag(inode, FI_ATOMIC_FILE)

Quoted 7 lines
Quoted 2 lines

Am I missing something?

So, f2fs_mark_inode_dirty_sync() will not work for atomic files anymore, which means it doesn't make the inode dirty.
Plz, refer to the first patch of this patchset. Or I might be confused with something. :(

Quoted 5 lines

I mean FI_ATOMIC_FILE was set after f2fs_i_size_write(), so inode will be set as dirty.

Thanks,

Oh, I was confused that f2fs_update_inode() is called in f2fs_mark_inode_dirty_sync().
That is called in f2fs_write_inode(). Let me fix this.

Thanks,

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

#7 lore raw
Quoted 38 lines · Daeho Jeong
Quoted 38 lines
Quoted 27 lines
Quoted 27 lines
Quoted 8 lines
Quoted 8 lines

Hi Daeho,

isize should be updated after tagging inode as atomic_write one? otherwise f2fs_mark_inode_dirty_sync() may update isize to inode page, latter checkpoint may persist that change? IIUC...

Quoted 7 lines
Quoted 1 line

Thanks,

Hi Chao,

The first patch of this patchset prevents the inode page from being updated as dirty for atomic file cases.
Is there any other chances for the inode page to be marked as dirty?

I mean:

Thread A Thread B
- f2fs_ioc_start_atomic_write
- f2fs_i_size_write(inode, 0)
- f2fs_mark_inode_dirty_sync
- checkpoint
- persist inode with incorrect zero isize

- set_inode_flag(inode, FI_ATOMIC_FILE)

Quoted 7 lines
Quoted 2 lines

Am I missing something?

So, f2fs_mark_inode_dirty_sync() will not work for atomic files anymore, which means it doesn't make the inode dirty.
Plz, refer to the first patch of this patchset. Or I might be confused with something. :(

I mean FI_ATOMIC_FILE was set after f2fs_i_size_write(), so inode will be set as dirty.

Quoted 6 lines
Quoted 2 lines

Thanks,

Oh, I was confused that f2fs_update_inode() is called in f2fs_mark_inode_dirty_sync().
That is called in f2fs_write_inode(). Let me fix this.

Hmm, I think the issue was already there before my patch. So, how about making the inode flushed and clean if the inode is already dirty when starting atomic write?

Quoted 2 lines

Thanks,

maintainer
#8 lore raw
Quoted 42 lines · Daeho Jeong
Quoted 41 lines · Daeho Jeong
Quoted 40 lines
Quoted 27 lines
Quoted 27 lines
Quoted 8 lines
Quoted 8 lines

Hi Daeho,

isize should be updated after tagging inode as atomic_write one? otherwise f2fs_mark_inode_dirty_sync() may update isize to inode page, latter checkpoint may persist that change? IIUC...

Quoted 7 lines
Quoted 1 line

Thanks,

Hi Chao,

The first patch of this patchset prevents the inode page from being updated as dirty for atomic file cases.
Is there any other chances for the inode page to be marked as dirty?

I mean:

Thread A Thread B
- f2fs_ioc_start_atomic_write
- f2fs_i_size_write(inode, 0)
- f2fs_mark_inode_dirty_sync
- checkpoint
- persist inode with incorrect zero isize

- set_inode_flag(inode, FI_ATOMIC_FILE)

Quoted 7 lines
Quoted 2 lines

Am I missing something?

So, f2fs_mark_inode_dirty_sync() will not work for atomic files anymore, which means it doesn't make the inode dirty.
Plz, refer to the first patch of this patchset. Or I might be confused with something. :(

I mean FI_ATOMIC_FILE was set after f2fs_i_size_write(), so inode will be set as dirty.

Thanks,

Quoted 7 lines
Quoted 3 lines

Oh, I was confused that f2fs_update_inode() is called in f2fs_mark_inode_dirty_sync().
That is called in f2fs_write_inode(). Let me fix this.

Hmm, I think the issue was already there before my patch. So, how about making the inode flushed and clean if the inode is already dirty when starting atomic write?

What I mean is:

---
 fs/f2fs/file.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)
fs/f2fs/file.c +3 -1
index e4b6e51086a3..31b229678b1d 100644
@@ -2053,6 +2053,9 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 
 	isize = i_size_read(inode);
 	fi->original_i_size = isize;
+
+	set_inode_flag(inode, FI_ATOMIC_FILE);
+
 	if (truncate) {
 		set_inode_flag(inode, FI_ATOMIC_REPLACE);
 		truncate_inode_pages_final(inode->i_mapping);
@@ -2063,7 +2066,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);
 	f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
Signature · 9 lines
Let's set FI_ATOMIC_FILE flag before f2fs_i_size_write(inode, 0), so
- f2fs_ioc_start_atomic_write
 - f2fs_i_size_write(, 0)
  - f2fs_mark_inode_dirty_sync
   check f2fs_is_atomic_file() and return correctly.

And for the case the inode is dirty before f2fs_i_size_write(, 0), we
can call f2fs_write_inode() to flush dirty feilds into inode page, and
make inode clean.
Quoted 3 lines
Quoted 3 lines

Thanks,

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

#9 lore raw
Quoted 31 lines

What I mean is:

---
  fs/f2fs/file.c | 4 +++-
  1 file changed, 3 insertions(+), 1 deletion(-)
fs/f2fs/file.c +3 -2
index e4b6e51086a3..31b229678b1d 100644
@@ -2053,6 +2053,9 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 
        isize = i_size_read(inode);
        fi->original_i_size = isize;
+
+       set_inode_flag(inode, FI_ATOMIC_FILE);
+
        if (truncate) {
                set_inode_flag(inode, FI_ATOMIC_REPLACE);
                truncate_inode_pages_final(inode->i_mapping);
@@ -2063,7 +2066,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);
        f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
--
Quoted 6 lines

Let's set FI_ATOMIC_FILE flag before f2fs_i_size_write(inode, 0), so
- f2fs_ioc_start_atomic_write
- f2fs_i_size_write(, 0)
- f2fs_mark_inode_dirty_sync
check f2fs_is_atomic_file() and return correctly.

Ah, I got it.

Quoted 4 lines

And for the case the inode is dirty before f2fs_i_size_write(, 0), we can call f2fs_write_inode() to flush dirty feilds into inode page, and make inode clean.

Thanks for the tips~

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

Thanks,

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