f2fs: don't give partially written atomic data from process crash

This patch resolves the below scenario.

== Process 1 ==     == Process 2 ==
open(w)             open(rw)
begin
write(new_#1)
process_crash
  f_op->flush
  locks_remove_posix
  f_op>release
                    read (new_#1)

In order to avoid corrupted database caused by new_#1, we must do roll-back
at process_crash time. In order to check that, this patch keeps task which
triggers transaction begin, and does roll-back in f_op->flush before removing
file locks.

Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 70777a889e12c3036b41714b82aff96b66e3927a..859ff4265c346d58f8385a5d55863e13757088e2 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -536,6 +536,7 @@ struct f2fs_inode_info {
        struct list_head dirty_list;    /* dirty list for dirs and files */
        struct list_head gdirty_list;   /* linked in global dirty list */
        struct list_head inmem_pages;   /* inmemory pages managed by f2fs */
+       struct task_struct *inmem_task; /* store inmemory task */
        struct mutex inmem_lock;        /* lock for inmemory pages */
        struct extent_tree *extent_tree;        /* cached extent_tree entry */
        struct rw_semaphore dio_rwsem[2];/* avoid racing between dio and gc */

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 2706130c261b060f46cb526b8e7ac501789808a7..75b3fda99e550cf6b0f417c71e8a7782976446ff 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1495,6 +1495,22 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
        return 0;
 }
 
+static int f2fs_file_flush(struct file *file, fl_owner_t id)
+{
+       struct inode *inode = file_inode(file);
+
+       /*
+        * If the process doing a transaction is crashed, we should do
+        * roll-back. Otherwise, other reader/write can see corrupted database
+        * until all the writers close its file. Since this should be done
+        * before dropping file lock, it needs to do in ->flush.
+        */
+       if (f2fs_is_atomic_file(inode) &&
+                       F2FS_I(inode)->inmem_task == current)
+               drop_inmem_pages(inode);
+       return 0;
+}
+
 #define F2FS_REG_FLMASK                (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
 #define F2FS_OTHER_FLMASK      (FS_NODUMP_FL | FS_NOATIME_FL)
 
@@ -1614,6 +1630,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
        }
 
 inc_stat:
+       F2FS_I(inode)->inmem_task = current;
        stat_inc_atomic_write(inode);
        stat_update_max_atomic_write(inode);
 out:
@@ -2506,6 +2523,7 @@ const struct file_operations f2fs_file_operations = {
        .open           = f2fs_file_open,
        .release        = f2fs_release_file,
        .mmap           = f2fs_file_mmap,
+       .flush          = f2fs_file_flush,
        .fsync          = f2fs_sync_file,
        .fallocate      = f2fs_fallocate,
        .unlocked_ioctl = f2fs_ioctl,