Skip to contentSkip to conversation

f2fs: atomic: fix to avoid racing w/ GC

PATCH In review Chao Yu 4 participants 8 messages Jun 25, 2024 – Aug 5, 2024 F2FS file system

lore
Share & tools
lore

Chao Yu

author maintainer
#0 lore raw

PATCH 1/4 f2fs: atomic: fix to avoid racing w/ GC

Case #1:
SQLite App GC Thread Kworker Shrinker
- f2fs_ioc_start_atomic_write

- f2fs_ioc_commit_atomic_write
- f2fs_commit_atomic_write
- filemap_write_and_wait_range
: write atomic_file's data to cow_inode
echo 3 > drop_caches to drop atomic_file's cache.
- f2fs_gc
- gc_data_segment
- move_data_page
- set_page_dirty

- writepages
- f2fs_do_write_data_page : overwrite atomic_file's data to cow_inode
- f2fs_down_write(&fi->i_gc_rwsem[WRITE])
- __f2fs_commit_atomic_write
- f2fs_up_write(&fi->i_gc_rwsem[WRITE])

Case #2:
SQLite App GC Thread Kworker
- f2fs_ioc_start_atomic_write

- __writeback_single_inode
- do_writepages
- f2fs_write_cache_pages
- f2fs_write_single_data_page
- f2fs_do_write_data_page : write atomic_file's data to cow_inode
- f2fs_gc
- gc_data_segment
- move_data_page
- set_page_dirty

- writepages
- f2fs_do_write_data_page
: overwrite atomic_file's data to cow_inode
- f2fs_ioc_commit_atomic_write

In above cases racing in between atomic_write and GC, previous data in atomic_file may be overwrited to cow_file, result in data corruption.

This patch introduces PAGE_PRIVATE_ATOMIC_WRITE bit flag in page.private, and use it to indicate that there is last dirty data in atomic file, and the data should be writebacked into cow_file, if the flag is not tagged in page, we should never write data across files.

Fixes 3db1de0e582c ("f2fs: change the current atomic write way")
Cc Daeho Jeong <[email protected]>

---
v1:
- this patch can fix on-disk data consistency issue caused by f2fs/003

 fs/f2fs/data.c | 10 +++++++++-
 fs/f2fs/f2fs.h |  8 +++++++-
 2 files changed, 16 insertions(+), 2 deletions(-)
fs/f2fs/data.c +9 -1
index 0b4f563f2361..22031b9b507c 100644
@@ -2647,10 +2647,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
 	struct dnode_of_data dn;
 	struct node_info ni;
 	bool ipu_force = false;
+	bool atomic_commit;
 	int err = 0;
 
 	/* Use COW inode to make dnode_of_data for atomic write */
-	if (f2fs_is_atomic_file(inode))
+	atomic_commit = f2fs_is_atomic_file(inode) &&
+				page_private_atomic(fio->page);
+	if (atomic_commit)
 		set_new_dnode(&dn, F2FS_I(inode)->cow_inode, NULL, NULL, 0);
 	else
 		set_new_dnode(&dn, inode, NULL, NULL, 0);
@@ -2749,6 +2752,8 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
 	f2fs_outplace_write_data(&dn, fio);
 	trace_f2fs_do_write_data_page(page_folio(page), OPU);
 	set_inode_flag(inode, FI_APPEND_WRITE);
+	if (atomic_commit)
+		clear_page_private_atomic(page);
 out_writepage:
 	f2fs_put_dnode(&dn);
 out:
@@ -3718,6 +3723,9 @@ static int f2fs_write_end(struct file *file,
 
 	set_page_dirty(page);
 
+	if (f2fs_is_atomic_file(inode))
+		set_page_private_atomic(page);
+
 	if (pos + copied > i_size_read(inode) &&
 	    !f2fs_verity_in_progress(inode)) {
 		f2fs_i_size_write(inode, pos + copied);
fs/f2fs/f2fs.h +7 -1
index eacf0b0e6b2e..f1d65ee3addf 100644
@@ -1413,7 +1413,8 @@ static inline void f2fs_clear_bit(unsigned int nr, char *addr);
  * bit 1	PAGE_PRIVATE_ONGOING_MIGRATION
  * bit 2	PAGE_PRIVATE_INLINE_INODE
  * bit 3	PAGE_PRIVATE_REF_RESOURCE
- * bit 4-	f2fs private data
+ * bit 4	PAGE_PRIVATE_ATOMIC_WRITE
+ * bit 5-	f2fs private data
  *
  * Layout B: lowest bit should be 0
  * page.private is a wrapped pointer.
@@ -1423,6 +1424,7 @@ enum {
 	PAGE_PRIVATE_ONGOING_MIGRATION,		/* data page which is on-going migrating */
 	PAGE_PRIVATE_INLINE_INODE,		/* inode page contains inline data */
 	PAGE_PRIVATE_REF_RESOURCE,		/* dirty page has referenced resources */
+	PAGE_PRIVATE_ATOMIC_WRITE,		/* data page from atomic write path */
 	PAGE_PRIVATE_MAX
 };
 
@@ -2401,14 +2403,17 @@ static inline void clear_page_private_##name(struct page *page) \
 PAGE_PRIVATE_GET_FUNC(nonpointer, NOT_POINTER);
 PAGE_PRIVATE_GET_FUNC(inline, INLINE_INODE);
 PAGE_PRIVATE_GET_FUNC(gcing, ONGOING_MIGRATION);
+PAGE_PRIVATE_GET_FUNC(atomic, ATOMIC_WRITE);
 
 PAGE_PRIVATE_SET_FUNC(reference, REF_RESOURCE);
 PAGE_PRIVATE_SET_FUNC(inline, INLINE_INODE);
 PAGE_PRIVATE_SET_FUNC(gcing, ONGOING_MIGRATION);
+PAGE_PRIVATE_SET_FUNC(atomic, ATOMIC_WRITE);
 
 PAGE_PRIVATE_CLEAR_FUNC(reference, REF_RESOURCE);
 PAGE_PRIVATE_CLEAR_FUNC(inline, INLINE_INODE);
 PAGE_PRIVATE_CLEAR_FUNC(gcing, ONGOING_MIGRATION);
+PAGE_PRIVATE_CLEAR_FUNC(atomic, ATOMIC_WRITE);
 
 static inline unsigned long get_page_private_data(struct page *page)
 {
@@ -2440,6 +2445,7 @@ static inline void clear_page_private_all(struct page *page)
 	clear_page_private_reference(page);
 	clear_page_private_gcing(page);
 	clear_page_private_inline(page);
+	clear_page_private_atomic(page);
 
 	f2fs_bug_on(F2FS_P_SB(page), page_private(page));
 }
Signature · 1 line
2.40.1
author maintainer
#1 lore raw

PATCH 2/4 f2fs: atomic: fix to not allow GC to pollute atomic_file

SQLite App GC Thread Shrinker
- f2fs_ioc_start_atomic_write

- f2fs_ioc_commit_atomic_write
- f2fs_commit_atomic_write
- filemap_write_and_wait_range
: write atomic_file's data to cow_inode
echo 3 > drop_caches
- f2fs_gc
- gc_data_segment
- move_data_page
- set_page_dirty
: it may load data of previous
transaction into pagecache.
- f2fs_down_write(&fi->i_gc_rwsem[WRITE])
- __f2fs_commit_atomic_write
- f2fs_up_write(&fi->i_gc_rwsem[WRITE])

During committing atomic_file, GC may be triggered to migrate atomic_file's block, so it may contain data of previous transaction in page cache, we should drop atomic_file's cache once it was migrated by GC.

And also, we should writeback atomic_file and cow_file's data w/ i_gc_rwsem lock held, in order to avoid block address change during __f2fs_commit_atomic_write().

Meahwhile, this patch adds f2fs_wait_on_block_writeback_range() to wait completion of block migration.

Fixes 3db1de0e582c ("f2fs: change the current atomic write way")

---
v1:
- this patch can fix in-memory data consistency issue caused by f2fs/003

 fs/f2fs/segment.c | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)
fs/f2fs/segment.c +21 -3
index 4db1add43e36..914a13bfc2ab 100644
@@ -236,6 +236,9 @@ static int __replace_atomic_write_block(struct inode *inode, pgoff_t index,
 		return err;
 	}
 
+	if (__is_valid_data_blkaddr(dn.data_blkaddr))
+		f2fs_wait_on_block_writeback_range(inode, dn.data_blkaddr, 1);
+
 	if (recover) {
 		/* dn.data_blkaddr is always valid */
 		if (!__is_valid_data_blkaddr(new_addr)) {
@@ -339,6 +342,9 @@ static int __f2fs_commit_atomic_write(struct inode *inode)
 				goto out;
 			}
 
+			f2fs_wait_on_block_writeback_range(cow_inode,
+								blkaddr, 1);
+
 			new = f2fs_kmem_cache_alloc(revoke_entry_slab, GFP_NOFS,
 							true, NULL);
 
@@ -379,16 +385,28 @@ int f2fs_commit_atomic_write(struct inode *inode)
 	struct f2fs_inode_info *fi = F2FS_I(inode);
 	int err;
 
+	f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
+
 	err = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
 	if (err)
 		return err;
 
-	f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
-	f2fs_lock_op(sbi);
+	/* writeback GCing page of cow_inode */
+	err = filemap_write_and_wait_range(fi->cow_inode->i_mapping,
+							0, LLONG_MAX);
+	if (err)
+		return err;
 
-	err = __f2fs_commit_atomic_write(inode);
+	filemap_invalidate_lock(inode->i_mapping);
+
+	/* don't allow clean page loaded by GC to pollute atomic_file */
+	truncate_pagecache(inode, 0);
 
+	f2fs_lock_op(sbi);
+	err = __f2fs_commit_atomic_write(inode);
 	f2fs_unlock_op(sbi);
+
+	filemap_invalidate_unlock(inode->i_mapping);
 	f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
 
 	return err;
Signature · 1 line
2.40.1
author maintainer
#2 lore raw

PATCH 3/4 f2fs: atomic: fix to truncate pagecache before on-disk metadata truncation

In reply to Chao Yu

We should always truncate pagecache while truncating on-disk data.

Fixes a46bebd502fe ("f2fs: synchronize atomic write aborts")
---
 fs/f2fs/file.c | 1 +
 1 file changed, 1 insertion(+)
fs/f2fs/file.c +1 -0
index 2203904383a6..0355cb054521 100644
@@ -2185,6 +2185,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 		clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 	} else {
 		/* Reuse the already created COW inode */
+		truncate_setsize(inode, 0);
 		ret = f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
 		if (ret) {
 			f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
Signature · 1 line
2.40.1
maintainer
#3 lore raw

Re: [PATCH 3/4] f2fs: atomic: fix to truncate pagecache before on-disk metadata truncation

Quoted 13 lines · Chao Yu

We should always truncate pagecache while truncating on-disk data.

Fixes a46bebd502fe ("f2fs: synchronize atomic write aborts")
---
 fs/f2fs/file.c | 1 +
 1 file changed, 1 insertion(+)
fs/f2fs/file.c +0 -0
index 2203904383a6..0355cb054521 100644

fs/f2fs/file.c static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate) · line 2188

Quoted 4 lines
fs/f2fs/file.c +1 -0
@@ -2185,6 +2185,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 		clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
 	} else {
 		/* Reuse the already created COW inode */
+		truncate_setsize(inode, 0);
		fi->cow_inode?
Quoted 5 lines
fs/f2fs/file.c +0 -0
 		ret = f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
 		if (ret) {
 			f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
Signature · 1 line
2.40.1
author maintainer
#4 lore raw

Re: [PATCH 3/4] f2fs: atomic: fix to truncate pagecache before on-disk metadata truncation

Quoted 9 lines · Jaegeuk Kim
Quoted 8 lines · Chao Yu

We should always truncate pagecache while truncating on-disk data.

Fixes a46bebd502fe ("f2fs: synchronize atomic write aborts")
---
  fs/f2fs/file.c | 1 +
  1 file changed, 1 insertion(+)
Quoted 11 lines

fs/f2fs/file.c static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate) · line 2188

Quoted 9 lines
fs/f2fs/file.c +1 -0
index 2203904383a6..0355cb054521 100644
@@ -2185,6 +2185,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
  		clear_inode_flag(fi->cow_inode, FI_INLINE_DATA);
  	} else {
  		/* Reuse the already created COW inode */
+		truncate_setsize(inode, 0);
		fi->cow_inode?

Oh, yes, let me fix this.

Thanks,

Quoted 6 lines
Quoted 6 lines
fs/f2fs/file.c +0 -0
  		ret = f2fs_do_truncate_blocks(fi->cow_inode, 0, true);
  		if (ret) {
  			f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
Signature · 1 line
2.40.1
author maintainer
#5 lore raw

PATCH 4/4 f2fs: atomic: fix to forbid dio in atomic_file

In reply to Chao Yu

atomic write can only be used via buffered IO, let's fail direct IO on atomic_file and return -EOPNOTSUPP.

---
 fs/f2fs/file.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
fs/f2fs/file.c +15 -0
index 0355cb054521..a527de1e7a2f 100644
@@ -2150,6 +2150,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 		goto out;
 
 	f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
+	f2fs_down_write(&fi->i_gc_rwsem[READ]);
 
 	/*
 	 * Should wait end_io to count F2FS_WB_CP_DATA correctly by
@@ -2209,6 +2210,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp, bool truncate)
 	}
 	f2fs_i_size_write(fi->cow_inode, isize);
 
+	f2fs_up_write(&fi->i_gc_rwsem[READ]);
 	f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
 
 	f2fs_update_time(sbi, REQ_TIME);
@@ -4537,6 +4539,13 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
 		f2fs_down_read(&fi->i_gc_rwsem[READ]);
 	}
 
+	/* dio is not compatible w/ atomic file */
+	if (f2fs_is_atomic_file(inode)) {
+		f2fs_up_read(&fi->i_gc_rwsem[READ]);
+		ret = -EOPNOTSUPP;
+		goto out;
+	}
+
 	/*
 	 * We have to use __iomap_dio_rw() and iomap_dio_complete() instead of
 	 * the higher-level function iomap_dio_rw() in order to ensure that the
@@ -4948,6 +4957,12 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 	/* Determine whether we will do a direct write or a buffered write. */
 	dio = f2fs_should_use_dio(inode, iocb, from);
 
+	/* dio is not compatible w/ atomic write */
+	if (dio && f2fs_is_atomic_file(inode)) {
+		ret = -EOPNOTSUPP;
+		goto out_unlock;
+	}
+
 	/* Possibly preallocate the blocks for the write. */
 	target_size = iocb->ki_pos + iov_iter_count(from);
 	preallocated = f2fs_preallocate_blocks(iocb, from, dio);
Signature · 1 line
2.40.1
#6 lore raw

RE: [f2fs-dev] [PATCH 4/4] f2fs: atomic: fix to forbid dio in atomic_file

Hello

I also have been thinking about the GC of the atomic file these days. I read your patches for atomic write, but I think there are some corner cases that can't be resolved with them.

First is when the GC of the atomic file occurs right after the writeback of newly updated page. Since the atomic page flag is cleared at the end of f2fs_do_write_data_page, the GC thread will set the page dirty and let it be written to the atomic file, which will cause the data corruption of the original inode.

Second is the foreground GC of atomic file. Although your patch can distinguish whether pages should be written to the original inode or cow inode, it can't handle the case when the atomic page needs to be migrated but updated page already exists in the page cache as below.

// atomic file's 1st old block is a and new block is b. // b is in the page cache
GC thread(FG_GC)
- select A as a victim segment do_garbage_collect
- iget atomic file's inode for block a move_data_page
f2fs_do_write_data_page
- use dn of cow inode since b has atomic flag
- seg_freed is 0 since block a is still valid
- goto gc_more and A is selected as victim again

Third is a race condition between GC of cow file and writeback thread of atomic file. Since there are two page caches for one dnode, I think we need to consider the race condition between them such as the case between the file inode and the meta inode.

I submitted a patch set for atomic write, so could you review it? The patch links are as below.
https://sourceforge.net/p/linux-f2fs/mailman/message/58790988/
https://sourceforge.net/p/linux-f2fs/mailman/message/58790989/

Thanks

Quoted 20 lines

atomic write can only be used via buffered IO, let's fail direct IO on atomic_file and return -EOPNOTSUPP.

---
 fs/f2fs/file.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
fs/f2fs/file.c index renamed from fs/f2fs/file.c +0 -0

0355cb054521..a527de1e7a2f 100644

fs/f2fs/file.c +1 -0
@@ -2150,6 +2150,7 @@ static int f2fs_ioc_start_atomic_write(struct file
 *filp, bool truncate)
 		goto out;
 
 	f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
+	f2fs_down_write(&fi->i_gc_rwsem[READ]);
 
 	/*
Quoted 2 lines

* Should wait end_io to count F2FS_WB_CP_DATA correctly by @@ -
2209,6 +2210,7 @@ static int f2fs_ioc_start_atomic_write(struct file

*filp,

Quoted 48 lines

bool truncate)

fs/f2fs/file.c +8 -0
 	}
 	f2fs_i_size_write(fi->cow_inode, isize);
 
+	f2fs_up_write(&fi->i_gc_rwsem[READ]);
 	f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
 
 	f2fs_update_time(sbi, REQ_TIME);
@@ -4537,6 +4539,13 @@ static ssize_t f2fs_dio_read_iter(struct kiocb
 *iocb, struct iov_iter *to)
 		f2fs_down_read(&fi->i_gc_rwsem[READ]);
 	}
 
+	/* dio is not compatible w/ atomic file */
+	if (f2fs_is_atomic_file(inode)) {
+		f2fs_up_read(&fi->i_gc_rwsem[READ]);
+		ret = -EOPNOTSUPP;
+		goto out;
+	}
+
 	/*
 	 * We have to use __iomap_dio_rw() and iomap_dio_complete() instead

of
* the higher-level function iomap_dio_rw() in order to ensure that
the @@ -4948,6 +4957,12 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
/* Determine whether we will do a direct write or a buffered write.
*/

fs/f2fs/file.c +6 -1
 	dio = f2fs_should_use_dio(inode, iocb, from);
 
+	/* dio is not compatible w/ atomic write */
+	if (dio && f2fs_is_atomic_file(inode)) {
+		ret = -EOPNOTSUPP;
+		goto out_unlock;
+	}
+
 	/* Possibly preallocate the blocks for the write. */
 	target_size = iocb->ki_pos + iov_iter_count(from);
 	preallocated = f2fs_preallocate_blocks(iocb, from, dio);
--

2.40.1

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

#7 lore raw
In reply to Chao Yu
This series was applied to jaegeuk/f2fs.git (dev) by Jaegeuk Kim <[email protected]>:

Hello:

This series was applied to jaegeuk/f2fs.git (dev)
by Jaegeuk Kim <[email protected]>:

Quoted 16 lines · On Tue, 25 Jun 2024 11:13:48 +0800 you wrote:

Case #1:
SQLite App GC Thread Kworker Shrinker
- f2fs_ioc_start_atomic_write

- f2fs_ioc_commit_atomic_write
- f2fs_commit_atomic_write
- filemap_write_and_wait_range
: write atomic_file's data to cow_inode
echo 3 > drop_caches to drop atomic_file's cache.
- f2fs_gc
- gc_data_segment
- move_data_page
- set_page_dirty

Quoted 1 line

[...]

Here is the summary with links:
- [f2fs-dev,1/4] f2fs: atomic: fix to avoid racing w/ GC

    https://git.kernel.org/jaegeuk/f2fs/c/1a0bd289a5db
  - [f2fs-dev,2/4] f2fs: atomic: fix to not allow GC to pollute atomic_file
    https://git.kernel.org/jaegeuk/f2fs/c/7566a155c666
  - [f2fs-dev,3/4] f2fs: atomic: fix to truncate pagecache before on-disk metadata truncation
    (no matching commit)
  - [f2fs-dev,4/4] f2fs: atomic: fix to forbid dio in atomic_file
    https://git.kernel.org/jaegeuk/f2fs/c/374a8881ce4c

You are awesome, thank you!

Signature · 2 lines
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html