Merge tag 'for-f2fs-4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs

Pull f2fs updates from Jaegeuk Kim:
 "New features:
   - in-memory extent_cache
   - fs_shutdown to test power-off-recovery
   - use inline_data to store symlink path
   - show f2fs as a non-misc filesystem

  Major fixes:
   - avoid CPU stalls on sync_dirty_dir_inodes
   - fix some power-off-recovery procedure
   - fix handling of broken symlink correctly
   - fix missing dot and dotdot made by sudden power cuts
   - handle wrong data index during roll-forward recovery
   - preallocate data blocks for direct_io

  ... and a bunch of minor bug fixes and cleanups"

* tag 'for-f2fs-4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (71 commits)
  f2fs: pass checkpoint reason on roll-forward recovery
  f2fs: avoid abnormal behavior on broken symlink
  f2fs: flush symlink path to avoid broken symlink after POR
  f2fs: change 0 to false for bool type
  f2fs: do not recover wrong data index
  f2fs: do not increase link count during recovery
  f2fs: assign parent's i_mode for empty dir
  f2fs: add F2FS_INLINE_DOTS to recover missing dot dentries
  f2fs: fix mismatching lock and unlock pages for roll-forward recovery
  f2fs: fix sparse warnings
  f2fs: limit b_size of mapped bh in f2fs_map_bh
  f2fs: persist system.advise into on-disk inode
  f2fs: avoid NULL pointer dereference in f2fs_xattr_advise_get
  f2fs: preallocate fallocated blocks for direct IO
  f2fs: enable inline data by default
  f2fs: preserve extent info for extent cache
  f2fs: initialize extent tree with on-disk extent info of inode
  f2fs: introduce __{find,grab}_extent_tree
  f2fs: split set_data_blkaddr from f2fs_update_extent_cache
  f2fs: enable fast symlink by utilizing inline data
  ...

1 files changed, 58 insertions, 6 deletions

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index df6a0596eccf..a6f3f6186588 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -241,6 +241,8 @@ go_write:
                  * will be used only for fsynced inodes after checkpoint.
                  */
                 try_to_fix_pino(inode);
+                clear_inode_flag(fi, FI_APPEND_WRITE);
+                clear_inode_flag(fi, FI_UPDATE_WRITE);
                 goto out;
         }
 sync_nodes:
@@ -433,8 +435,12 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
                         continue;
 
                 dn->data_blkaddr = NULL_ADDR;
-                update_extent_cache(dn);
+                set_data_blkaddr(dn);
+                f2fs_update_extent_cache(dn);
                 invalidate_blocks(sbi, blkaddr);
+                if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
+                        clear_inode_flag(F2FS_I(dn->inode),
+                                                FI_FIRST_BLOCK_WRITTEN);
                 nr_free++;
         }
         if (nr_free) {
@@ -454,15 +460,16 @@ void truncate_data_blocks(struct dnode_of_data *dn)
         truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
 }
 
-static int truncate_partial_data_page(struct inode *inode, u64 from)
+static int truncate_partial_data_page(struct inode *inode, u64 from,
+                                                                bool force)
 {
         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
         struct page *page;
 
-        if (!offset)
+        if (!offset && !force)
                 return 0;
 
-        page = find_data_page(inode, from >> PAGE_CACHE_SHIFT, false);
+        page = find_data_page(inode, from >> PAGE_CACHE_SHIFT, force);
         if (IS_ERR(page))
                 return 0;
 
@@ -473,7 +480,8 @@ static int truncate_partial_data_page(struct inode *inode, u64 from)
 
         f2fs_wait_on_page_writeback(page, DATA);
         zero_user(page, offset, PAGE_CACHE_SIZE - offset);
-        set_page_dirty(page);
+        if (!force)
+                set_page_dirty(page);
 out:
         f2fs_put_page(page, 1);
         return 0;
@@ -487,6 +495,7 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock)
         pgoff_t free_from;
         int count = 0, err = 0;
         struct page *ipage;
+        bool truncate_page = false;
 
         trace_f2fs_truncate_blocks_enter(inode, from);
 
@@ -502,7 +511,10 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock)
         }
 
         if (f2fs_has_inline_data(inode)) {
+                if (truncate_inline_inode(ipage, from))
+                        set_page_dirty(ipage);
                 f2fs_put_page(ipage, 1);
+                truncate_page = true;
                 goto out;
         }
 
@@ -533,7 +545,7 @@ out:
 
         /* lastly zero out the first data page */
         if (!err)
-                err = truncate_partial_data_page(inode, from);
+                err = truncate_partial_data_page(inode, from, truncate_page);
 
         trace_f2fs_truncate_blocks_exit(inode, err);
         return err;
@@ -997,6 +1009,9 @@ static int f2fs_ioc_release_volatile_write(struct file *filp)
         if (!f2fs_is_volatile_file(inode))
                 return 0;
 
+        if (!f2fs_is_first_block_written(inode))
+                return truncate_partial_data_page(inode, 0, true);
+
         punch_hole(inode, 0, F2FS_BLKSIZE);
         return 0;
 }
@@ -1029,6 +1044,41 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
         return ret;
 }
 
+static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
+{
+        struct inode *inode = file_inode(filp);
+        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+        struct super_block *sb = sbi->sb;
+        __u32 in;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        if (get_user(in, (__u32 __user *)arg))
+                return -EFAULT;
+
+        switch (in) {
+        case F2FS_GOING_DOWN_FULLSYNC:
+                sb = freeze_bdev(sb->s_bdev);
+                if (sb && !IS_ERR(sb)) {
+                        f2fs_stop_checkpoint(sbi);
+                        thaw_bdev(sb->s_bdev, sb);
+                }
+                break;
+        case F2FS_GOING_DOWN_METASYNC:
+                /* do checkpoint only */
+                f2fs_sync_fs(sb, 1);
+                f2fs_stop_checkpoint(sbi);
+                break;
+        case F2FS_GOING_DOWN_NOSYNC:
+                f2fs_stop_checkpoint(sbi);
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
 {
         struct inode *inode = file_inode(filp);
@@ -1078,6 +1128,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 return f2fs_ioc_release_volatile_write(filp);
         case F2FS_IOC_ABORT_VOLATILE_WRITE:
                 return f2fs_ioc_abort_volatile_write(filp);
+        case F2FS_IOC_SHUTDOWN:
+                return f2fs_ioc_shutdown(filp, arg);
         case FITRIM:
                 return f2fs_ioc_fitrim(filp, arg);
         default: