1 files changed, 86 insertions, 15 deletions

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 3c27e0ecb3bc..98dac27bc3f7 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -26,6 +26,7 @@
 #include "segment.h"
 #include "xattr.h"
 #include "acl.h"
+#include "trace.h"
 #include <trace/events/f2fs.h>
 
 static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
@@ -92,7 +93,6 @@ static const struct vm_operations_struct f2fs_file_vm_ops = {
         .fault          = filemap_fault,
         .map_pages      = filemap_map_pages,
         .page_mkwrite   = f2fs_vm_page_mkwrite,
-        .remap_pages    = generic_file_remap_pages,
 };
 
 static int get_parent_ino(struct inode *inode, nid_t *pino)
@@ -246,6 +246,10 @@ go_write:
 sync_nodes:
         sync_node_pages(sbi, ino, &wbc);
 
+        /* if cp_error was enabled, we should avoid infinite loop */
+        if (unlikely(f2fs_cp_error(sbi)))
+                goto out;
+
         if (need_inode_block_update(sbi, ino)) {
                 mark_inode_dirty_sync(inode);
                 f2fs_write_inode(inode, NULL);
@@ -265,6 +269,7 @@ flush_out:
         ret = f2fs_issue_flush(sbi);
 out:
         trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
+        f2fs_trace_ios(NULL, NULL, 1);
         return ret;
 }
 
@@ -351,7 +356,7 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
                 /* find data/hole in dnode block */
                 for (; dn.ofs_in_node < end_offset;
                                 dn.ofs_in_node++, pgofs++,
-                                data_ofs = pgofs << PAGE_CACHE_SHIFT) {
+                                data_ofs = (loff_t)pgofs << PAGE_CACHE_SHIFT) {
                         block_t blkaddr;
                         blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
 
@@ -427,7 +432,8 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
                 if (blkaddr == NULL_ADDR)
                         continue;
 
-                update_extent_cache(NULL_ADDR, dn);
+                dn->data_blkaddr = NULL_ADDR;
+                update_extent_cache(dn);
                 invalidate_blocks(sbi, blkaddr);
                 nr_free++;
         }
@@ -484,8 +490,7 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock)
 
         trace_f2fs_truncate_blocks_enter(inode, from);
 
-        free_from = (pgoff_t)
-                ((from + blocksize - 1) >> (sbi->log_blocksize));
+        free_from = (pgoff_t)F2FS_BYTES_TO_BLK(from + blocksize - 1);
 
         if (lock)
                 f2fs_lock_op(sbi);
@@ -836,6 +841,19 @@ static long f2fs_fallocate(struct file *file, int mode,
         return ret;
 }
 
+static int f2fs_release_file(struct inode *inode, struct file *filp)
+{
+        /* some remained atomic pages should discarded */
+        if (f2fs_is_atomic_file(inode))
+                commit_inmem_pages(inode, true);
+        if (f2fs_is_volatile_file(inode)) {
+                set_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
+                filemap_fdatawrite(inode->i_mapping);
+                clear_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
+        }
+        return 0;
+}
+
 #define F2FS_REG_FLMASK         (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
 #define F2FS_OTHER_FLMASK       (FS_NODUMP_FL | FS_NOATIME_FL)
 
@@ -906,29 +924,30 @@ out:
         return ret;
 }
 
+static int f2fs_ioc_getversion(struct file *filp, unsigned long arg)
+{
+        struct inode *inode = file_inode(filp);
+
+        return put_user(inode->i_generation, (int __user *)arg);
+}
+
 static int f2fs_ioc_start_atomic_write(struct file *filp)
 {
         struct inode *inode = file_inode(filp);
-        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 
         if (!inode_owner_or_capable(inode))
                 return -EACCES;
 
-        f2fs_balance_fs(sbi);
+        f2fs_balance_fs(F2FS_I_SB(inode));
+
+        if (f2fs_is_atomic_file(inode))
+                return 0;
 
         set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
 
         return f2fs_convert_inline_inode(inode);
 }
 
-static int f2fs_release_file(struct inode *inode, struct file *filp)
-{
-        /* some remained atomic pages should discarded */
-        if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode))
-                commit_inmem_pages(inode, true);
-        return 0;
-}
-
 static int f2fs_ioc_commit_atomic_write(struct file *filp)
 {
         struct inode *inode = file_inode(filp);
@@ -949,6 +968,7 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
 
         ret = f2fs_sync_file(filp, 0, LONG_MAX, 0);
         mnt_drop_write_file(filp);
+        clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
         return ret;
 }
 
@@ -959,11 +979,56 @@ static int f2fs_ioc_start_volatile_write(struct file *filp)
         if (!inode_owner_or_capable(inode))
                 return -EACCES;
 
+        if (f2fs_is_volatile_file(inode))
+                return 0;
+
         set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
 
         return f2fs_convert_inline_inode(inode);
 }
 
+static int f2fs_ioc_release_volatile_write(struct file *filp)
+{
+        struct inode *inode = file_inode(filp);
+
+        if (!inode_owner_or_capable(inode))
+                return -EACCES;
+
+        if (!f2fs_is_volatile_file(inode))
+                return 0;
+
+        punch_hole(inode, 0, F2FS_BLKSIZE);
+        return 0;
+}
+
+static int f2fs_ioc_abort_volatile_write(struct file *filp)
+{
+        struct inode *inode = file_inode(filp);
+        int ret;
+
+        if (!inode_owner_or_capable(inode))
+                return -EACCES;
+
+        ret = mnt_want_write_file(filp);
+        if (ret)
+                return ret;
+
+        f2fs_balance_fs(F2FS_I_SB(inode));
+
+        if (f2fs_is_atomic_file(inode)) {
+                commit_inmem_pages(inode, false);
+                clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
+        }
+
+        if (f2fs_is_volatile_file(inode)) {
+                clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
+                filemap_fdatawrite(inode->i_mapping);
+                set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
+        }
+        mnt_drop_write_file(filp);
+        return ret;
+}
+
 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
 {
         struct inode *inode = file_inode(filp);
@@ -1001,12 +1066,18 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 return f2fs_ioc_getflags(filp, arg);
         case F2FS_IOC_SETFLAGS:
                 return f2fs_ioc_setflags(filp, arg);
+        case F2FS_IOC_GETVERSION:
+                return f2fs_ioc_getversion(filp, arg);
         case F2FS_IOC_START_ATOMIC_WRITE:
                 return f2fs_ioc_start_atomic_write(filp);
         case F2FS_IOC_COMMIT_ATOMIC_WRITE:
                 return f2fs_ioc_commit_atomic_write(filp);
         case F2FS_IOC_START_VOLATILE_WRITE:
                 return f2fs_ioc_start_volatile_write(filp);
+        case F2FS_IOC_RELEASE_VOLATILE_WRITE:
+                return f2fs_ioc_release_volatile_write(filp);
+        case F2FS_IOC_ABORT_VOLATILE_WRITE:
+                return f2fs_ioc_abort_volatile_write(filp);
         case FITRIM:
                 return f2fs_ioc_fitrim(filp, arg);
         default: