f2fs: correct i_size change for atomic writes

[ Upstream commit 02fd88ebbcae838d10cb12adff480eed3cb21b14 ]

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

Signed-off-by: Daeho Jeong <daehojeong@google.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Stable-dep-of: a2665a1af8c3 ("f2fs: clear atomic_write_task in f2fs_abort_atomic_write()")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 8b9f0b3c772325a3067d3af3d2781e6fc4384d1f..87664c309b3c8daa59b595df368cef70058ed8df 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -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_COMMITTED,    /* indicate atomic commit completed except disk sync */
        FI_MAX,                 /* max flag, never be used */
 };
 
@@ -822,6 +823,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,
@@ -3072,6 +3074,8 @@ static inline void f2fs_i_blocks_write(struct inode *inode,
                set_inode_flag(inode, FI_AUTO_RECOVER);
 }
 
+static inline bool f2fs_is_atomic_file(struct inode *inode);
+
 static inline void f2fs_i_size_write(struct inode *inode, loff_t i_size)
 {
        bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
@@ -3081,6 +3085,10 @@ static inline void f2fs_i_size_write(struct inode *inode, loff_t i_size)
                return;
 
        i_size_write(inode, i_size);
+
+       if (f2fs_is_atomic_file(inode))
+               return;
+
        f2fs_mark_inode_dirty_sync(inode, true);
        if (clean || recover)
                set_inode_flag(inode, FI_AUTO_RECOVER);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index a03c61bd70165345e54f81a793cd6e9ab988b03a..7bb0c05e943cf7409f43c295ebce87f109349624 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -2041,6 +2041,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))
@@ -2099,7 +2100,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);
 
        stat_inc_atomic_inode(inode);
 
@@ -2137,16 +2143,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;

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 5d6fd824f74f2295ec8d534690c3014a78ca29f4..e8413b080e0a7d674a25f104fb0204f378cdee61 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -621,9 +621,12 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page)
        ri->i_uid = cpu_to_le32(i_uid_read(inode));
        ri->i_gid = cpu_to_le32(i_gid_read(inode));
        ri->i_links = cpu_to_le32(inode->i_nlink);
-       ri->i_size = cpu_to_le64(i_size_read(inode));
        ri->i_blocks = cpu_to_le64(SECTOR_TO_BLOCK(inode->i_blocks) + 1);
 
+       if (!f2fs_is_atomic_file(inode) ||
+                       is_inode_flag_set(inode, FI_ATOMIC_COMMITTED))
+               ri->i_size = cpu_to_le64(i_size_read(inode));
+
        if (et) {
                read_lock(&et->lock);
                set_raw_extent(&et->largest, &ri->i_ext);

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index af9a3b7996b4d61a4ec6ad5f6cd9ed7e3c73e7dd..60d79e427f9887df788420d1979ec9df4e4306b3 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -192,14 +192,18 @@ 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_COMMITTED);
        clear_inode_flag(inode, FI_ATOMIC_FILE);
        stat_dec_atomic_inode(inode);
+
+       if (clean) {
+               truncate_inode_pages_final(inode->i_mapping);
+               f2fs_i_size_write(inode, fi->original_i_size);
+       }
 }
 
 static int __replace_atomic_write_block(struct inode *inode, pgoff_t index,
@@ -338,10 +342,12 @@ next:
        }
 
 out:
-       if (ret)
+       if (ret) {
                sbi->revoked_atomic_block += fi->atomic_write_cnt;
-       else
+       } else {
                sbi->committed_atomic_block += fi->atomic_write_cnt;
+               set_inode_flag(inode, FI_ATOMIC_COMMITTED);
+       }
 
        __complete_revoke_list(inode, &revoke_list, ret ? true : false);