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

Pull f2fs updates from Jaegeuk Kim:
 "This series adds two ioctls to control cached data and fragmented
  files.  Most of the rest fixes missing error cases and bugs that we
  have not covered so far.  Summary:

  Enhancements:
   - support an ioctl to execute online file defragmentation
   - support an ioctl to flush cached data
   - speed up shrinking of extent_cache entries
   - handle broken superblock
   - refector dirty inode management infra
   - revisit f2fs_map_blocks to handle more cases
   - reduce global lock coverage
   - add detecting user's idle time

  Major bug fixes:
   - fix data race condition on cached nat entries
   - fix error cases of volatile and atomic writes"

* tag 'for-f2fs-4.5' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (87 commits)
  f2fs: should unset atomic flag after successful commit
  f2fs: fix wrong memory condition check
  f2fs: monitor the number of background checkpoint
  f2fs: detect idle time depending on user behavior
  f2fs: introduce time and interval facility
  f2fs: skip releasing nodes in chindless extent tree
  f2fs: use atomic type for node count in extent tree
  f2fs: recognize encrypted data in f2fs_fiemap
  f2fs: clean up f2fs_balance_fs
  f2fs: remove redundant calls
  f2fs: avoid unnecessary f2fs_balance_fs calls
  f2fs: check the page status filled from disk
  f2fs: introduce __get_node_page to reuse common code
  f2fs: check node id earily when readaheading node page
  f2fs: read isize while holding i_mutex in fiemap
  Revert "f2fs: check the node block address of newly allocated nid"
  f2fs: cover more area with nat_tree_lock
  f2fs: introduce max_file_blocks in sbi
  f2fs crypto: check CONFIG_F2FS_FS_XATTR for encrypted symlink
  f2fs: introduce zombie list for fast shrinking extent trees
  ...

1 files changed, 19 insertions, 10 deletions

diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index ad1b18a7705b..4fb6ef88a34f 100644
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -38,12 +38,15 @@ static void update_general_status(struct f2fs_sb_info *sbi)
         si->hit_rbtree = atomic64_read(&sbi->read_hit_rbtree);
         si->hit_total = si->hit_largest + si->hit_cached + si->hit_rbtree;
         si->total_ext = atomic64_read(&sbi->total_hit_ext);
-        si->ext_tree = sbi->total_ext_tree;
+        si->ext_tree = atomic_read(&sbi->total_ext_tree);
+        si->zombie_tree = atomic_read(&sbi->total_zombie_tree);
         si->ext_node = atomic_read(&sbi->total_ext_node);
         si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES);
         si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS);
-        si->ndirty_dirs = sbi->n_dirty_dirs;
         si->ndirty_meta = get_pages(sbi, F2FS_DIRTY_META);
+        si->ndirty_data = get_pages(sbi, F2FS_DIRTY_DATA);
+        si->ndirty_dirs = sbi->ndirty_inode[DIR_INODE];
+        si->ndirty_files = sbi->ndirty_inode[FILE_INODE];
         si->inmem_pages = get_pages(sbi, F2FS_INMEM_PAGES);
         si->wb_pages = get_pages(sbi, F2FS_WRITEBACK);
         si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;
@@ -105,7 +108,7 @@ static void update_sit_info(struct f2fs_sb_info *sbi)
 
         bimodal = 0;
         total_vblocks = 0;
-        blks_per_sec = sbi->segs_per_sec * (1 << sbi->log_blocks_per_seg);
+        blks_per_sec = sbi->segs_per_sec * sbi->blocks_per_seg;
         hblks_per_sec = blks_per_sec / 2;
         for (segno = 0; segno < MAIN_SEGS(sbi); segno += sbi->segs_per_sec) {
                 vblocks = get_valid_blocks(sbi, segno, sbi->segs_per_sec);
@@ -189,10 +192,10 @@ get_cache:
         si->cache_mem += NM_I(sbi)->dirty_nat_cnt *
                                         sizeof(struct nat_entry_set);
         si->cache_mem += si->inmem_pages * sizeof(struct inmem_pages);
-        si->cache_mem += sbi->n_dirty_dirs * sizeof(struct inode_entry);
         for (i = 0; i <= UPDATE_INO; i++)
                 si->cache_mem += sbi->im[i].ino_num * sizeof(struct ino_entry);
-        si->cache_mem += sbi->total_ext_tree * sizeof(struct extent_tree);
+        si->cache_mem += atomic_read(&sbi->total_ext_tree) *
+                                                sizeof(struct extent_tree);
         si->cache_mem += atomic_read(&sbi->total_ext_node) *
                                                 sizeof(struct extent_node);
 
@@ -267,7 +270,8 @@ static int stat_show(struct seq_file *s, void *v)
                            si->dirty_count);
                 seq_printf(s, "  - Prefree: %d\n  - Free: %d (%d)\n\n",
                            si->prefree_count, si->free_segs, si->free_secs);
-                seq_printf(s, "CP calls: %d\n", si->cp_count);
+                seq_printf(s, "CP calls: %d (BG: %d)\n",
+                                si->cp_count, si->bg_cp_count);
                 seq_printf(s, "GC calls: %d (BG: %d)\n",
                            si->call_count, si->bg_gc);
                 seq_printf(s, "  - data segments : %d (%d)\n",
@@ -288,8 +292,8 @@ static int stat_show(struct seq_file *s, void *v)
                                 !si->total_ext ? 0 :
                                 div64_u64(si->hit_total * 100, si->total_ext),
                                 si->hit_total, si->total_ext);
-                seq_printf(s, "  - Inner Struct Count: tree: %d, node: %d\n",
-                                si->ext_tree, si->ext_node);
+                seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",
+                                si->ext_tree, si->zombie_tree, si->ext_node);
                 seq_puts(s, "\nBalancing F2FS Async:\n");
                 seq_printf(s, "  - inmem: %4d, wb: %4d\n",
                            si->inmem_pages, si->wb_pages);
@@ -297,6 +301,8 @@ static int stat_show(struct seq_file *s, void *v)
                            si->ndirty_node, si->node_pages);
                 seq_printf(s, "  - dents: %4d in dirs:%4d\n",
                            si->ndirty_dent, si->ndirty_dirs);
+                seq_printf(s, "  - datas: %4d in files:%4d\n",
+                           si->ndirty_data, si->ndirty_files);
                 seq_printf(s, "  - meta: %4d in %4d\n",
                            si->ndirty_meta, si->meta_pages);
                 seq_printf(s, "  - NATs: %9d/%9d\n  - SITs: %9d/%9d\n",
@@ -404,20 +410,23 @@ void f2fs_destroy_stats(struct f2fs_sb_info *sbi)
         kfree(si);
 }
 
-void __init f2fs_create_root_stats(void)
+int __init f2fs_create_root_stats(void)
 {
         struct dentry *file;
 
         f2fs_debugfs_root = debugfs_create_dir("f2fs", NULL);
         if (!f2fs_debugfs_root)
-                return;
+                return -ENOMEM;
 
         file = debugfs_create_file("status", S_IRUGO, f2fs_debugfs_root,
                         NULL, &stat_fops);
         if (!file) {
                 debugfs_remove(f2fs_debugfs_root);
                 f2fs_debugfs_root = NULL;
+                return -ENOMEM;
         }
+
+        return 0;
 }
 
 void f2fs_destroy_root_stats(void)