1 files changed, 141 insertions, 33 deletions

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 7fa3313ab0e2..c06a25e5cec3 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -50,6 +50,7 @@
 #define F2FS_MOUNT_FLUSH_MERGE          0x00000400
 #define F2FS_MOUNT_NOBARRIER            0x00000800
 #define F2FS_MOUNT_FASTBOOT             0x00001000
+#define F2FS_MOUNT_EXTENT_CACHE         0x00002000
 
 #define clear_opt(sbi, option)  (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
 #define set_opt(sbi, option)    (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
@@ -102,6 +103,7 @@ enum {
         CP_UMOUNT,
         CP_FASTBOOT,
         CP_SYNC,
+        CP_RECOVERY,
         CP_DISCARD,
 };
 
@@ -216,6 +218,15 @@ static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,
 #define F2FS_IOC_RELEASE_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 4)
 #define F2FS_IOC_ABORT_VOLATILE_WRITE   _IO(F2FS_IOCTL_MAGIC, 5)
 
+/*
+ * should be same as XFS_IOC_GOINGDOWN.
+ * Flags for going down operation used by FS_IOC_GOINGDOWN
+ */
+#define F2FS_IOC_SHUTDOWN       _IOR('X', 125, __u32)   /* Shutdown */
+#define F2FS_GOING_DOWN_FULLSYNC        0x0     /* going down with full sync */
+#define F2FS_GOING_DOWN_METASYNC        0x1     /* going down with metadata */
+#define F2FS_GOING_DOWN_NOSYNC          0x2     /* going down */
+
 #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
 /*
  * ioctl commands in 32 bit emulation
@@ -273,14 +284,34 @@ enum {
 
 #define MAX_DIR_RA_PAGES        4       /* maximum ra pages of dir */
 
+/* vector size for gang look-up from extent cache that consists of radix tree */
+#define EXT_TREE_VEC_SIZE       64
+
 /* for in-memory extent cache entry */
-#define F2FS_MIN_EXTENT_LEN     16      /* minimum extent length */
+#define F2FS_MIN_EXTENT_LEN     64      /* minimum extent length */
+
+/* number of extent info in extent cache we try to shrink */
+#define EXTENT_CACHE_SHRINK_NUMBER      128
 
 struct extent_info {
-        rwlock_t ext_lock;      /* rwlock for consistency */
-        unsigned int fofs;      /* start offset in a file */
-        u32 blk_addr;           /* start block address of the extent */
-        unsigned int len;       /* length of the extent */
+        unsigned int fofs;              /* start offset in a file */
+        u32 blk;                        /* start block address of the extent */
+        unsigned int len;               /* length of the extent */
+};
+
+struct extent_node {
+        struct rb_node rb_node;         /* rb node located in rb-tree */
+        struct list_head list;          /* node in global extent list of sbi */
+        struct extent_info ei;          /* extent info */
+};
+
+struct extent_tree {
+        nid_t ino;                      /* inode number */
+        struct rb_root root;            /* root of extent info rb-tree */
+        struct extent_node *cached_en;  /* recently accessed extent node */
+        rwlock_t lock;                  /* protect extent info rb-tree */
+        atomic_t refcount;              /* reference count of rb-tree */
+        unsigned int count;             /* # of extent node in rb-tree*/
 };
 
 /*
@@ -309,6 +340,7 @@ struct f2fs_inode_info {
         nid_t i_xattr_nid;              /* node id that contains xattrs */
         unsigned long long xattr_ver;   /* cp version of xattr modification */
         struct extent_info ext;         /* in-memory extent cache entry */
+        rwlock_t ext_lock;              /* rwlock for single extent cache */
         struct inode_entry *dirty_dir;  /* the pointer of dirty dir */
 
         struct radix_tree_root inmem_root;      /* radix tree for inmem pages */
@@ -319,21 +351,51 @@ struct f2fs_inode_info {
 static inline void get_extent_info(struct extent_info *ext,
                                         struct f2fs_extent i_ext)
 {
-        write_lock(&ext->ext_lock);
         ext->fofs = le32_to_cpu(i_ext.fofs);
-        ext->blk_addr = le32_to_cpu(i_ext.blk_addr);
+        ext->blk = le32_to_cpu(i_ext.blk);
         ext->len = le32_to_cpu(i_ext.len);
-        write_unlock(&ext->ext_lock);
 }
 
 static inline void set_raw_extent(struct extent_info *ext,
                                         struct f2fs_extent *i_ext)
 {
-        read_lock(&ext->ext_lock);
         i_ext->fofs = cpu_to_le32(ext->fofs);
-        i_ext->blk_addr = cpu_to_le32(ext->blk_addr);
+        i_ext->blk = cpu_to_le32(ext->blk);
         i_ext->len = cpu_to_le32(ext->len);
-        read_unlock(&ext->ext_lock);
+}
+
+static inline void set_extent_info(struct extent_info *ei, unsigned int fofs,
+                                                u32 blk, unsigned int len)
+{
+        ei->fofs = fofs;
+        ei->blk = blk;
+        ei->len = len;
+}
+
+static inline bool __is_extent_same(struct extent_info *ei1,
+                                                struct extent_info *ei2)
+{
+        return (ei1->fofs == ei2->fofs && ei1->blk == ei2->blk &&
+                                                ei1->len == ei2->len);
+}
+
+static inline bool __is_extent_mergeable(struct extent_info *back,
+                                                struct extent_info *front)
+{
+        return (back->fofs + back->len == front->fofs &&
+                        back->blk + back->len == front->blk);
+}
+
+static inline bool __is_back_mergeable(struct extent_info *cur,
+                                                struct extent_info *back)
+{
+        return __is_extent_mergeable(back, cur);
+}
+
+static inline bool __is_front_mergeable(struct extent_info *cur,
+                                                struct extent_info *front)
+{
+        return __is_extent_mergeable(cur, front);
 }
 
 struct f2fs_nm_info {
@@ -502,6 +564,10 @@ enum page_type {
         META,
         NR_PAGE_TYPE,
         META_FLUSH,
+        INMEM,          /* the below types are used by tracepoints only. */
+        INMEM_DROP,
+        IPU,
+        OPU,
 };
 
 struct f2fs_io_info {
@@ -559,7 +625,6 @@ struct f2fs_sb_info {
         struct mutex cp_mutex;                  /* checkpoint procedure lock */
         struct rw_semaphore cp_rwsem;           /* blocking FS operations */
         struct rw_semaphore node_write;         /* locking node writes */
-        struct mutex writepages;                /* mutex for writepages() */
         wait_queue_head_t cp_wait;
 
         struct inode_management im[MAX_INO_ENTRY];      /* manage inode cache */
@@ -571,6 +636,14 @@ struct f2fs_sb_info {
         struct list_head dir_inode_list;        /* dir inode list */
         spinlock_t dir_inode_lock;              /* for dir inode list lock */
 
+        /* for extent tree cache */
+        struct radix_tree_root extent_tree_root;/* cache extent cache entries */
+        struct rw_semaphore extent_tree_lock;   /* locking extent radix tree */
+        struct list_head extent_list;           /* lru list for shrinker */
+        spinlock_t extent_lock;                 /* locking extent lru list */
+        int total_ext_tree;                     /* extent tree count */
+        atomic_t total_ext_node;                /* extent info count */
+
         /* basic filesystem units */
         unsigned int log_sectors_per_block;     /* log2 sectors per block */
         unsigned int log_blocksize;             /* log2 block size */
@@ -920,12 +993,17 @@ static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
         return 0;
 }
 
+static inline block_t __cp_payload(struct f2fs_sb_info *sbi)
+{
+        return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
+}
+
 static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
 {
         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
         int offset;
 
-        if (le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload) > 0) {
+        if (__cp_payload(sbi) > 0) {
                 if (flag == NAT_BITMAP)
                         return &ckpt->sit_nat_version_bitmap;
                 else
@@ -1166,8 +1244,10 @@ enum {
         FI_NEED_IPU,            /* used for ipu per file */
         FI_ATOMIC_FILE,         /* indicate atomic file */
         FI_VOLATILE_FILE,       /* indicate volatile file */
+        FI_FIRST_BLOCK_WRITTEN, /* indicate #0 data block was written */
         FI_DROP_CACHE,          /* drop dirty page cache */
         FI_DATA_EXIST,          /* indicate data exists */
+        FI_INLINE_DOTS,         /* indicate inline dot dentries */
 };
 
 static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
@@ -1204,6 +1284,8 @@ static inline void get_inline_info(struct f2fs_inode_info *fi,
                 set_inode_flag(fi, FI_INLINE_DENTRY);
         if (ri->i_inline & F2FS_DATA_EXIST)
                 set_inode_flag(fi, FI_DATA_EXIST);
+        if (ri->i_inline & F2FS_INLINE_DOTS)
+                set_inode_flag(fi, FI_INLINE_DOTS);
 }
 
 static inline void set_raw_inline(struct f2fs_inode_info *fi,
@@ -1219,6 +1301,8 @@ static inline void set_raw_inline(struct f2fs_inode_info *fi,
                 ri->i_inline |= F2FS_INLINE_DENTRY;
         if (is_inode_flag_set(fi, FI_DATA_EXIST))
                 ri->i_inline |= F2FS_DATA_EXIST;
+        if (is_inode_flag_set(fi, FI_INLINE_DOTS))
+                ri->i_inline |= F2FS_INLINE_DOTS;
 }
 
 static inline int f2fs_has_inline_xattr(struct inode *inode)
@@ -1264,6 +1348,11 @@ static inline int f2fs_exist_data(struct inode *inode)
         return is_inode_flag_set(F2FS_I(inode), FI_DATA_EXIST);
 }
 
+static inline int f2fs_has_inline_dots(struct inode *inode)
+{
+        return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DOTS);
+}
+
 static inline bool f2fs_is_atomic_file(struct inode *inode)
 {
         return is_inode_flag_set(F2FS_I(inode), FI_ATOMIC_FILE);
@@ -1274,6 +1363,11 @@ static inline bool f2fs_is_volatile_file(struct inode *inode)
         return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE);
 }
 
+static inline bool f2fs_is_first_block_written(struct inode *inode)
+{
+        return is_inode_flag_set(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);
+}
+
 static inline bool f2fs_is_drop_cache(struct inode *inode)
 {
         return is_inode_flag_set(F2FS_I(inode), FI_DROP_CACHE);
@@ -1290,12 +1384,6 @@ static inline int f2fs_has_inline_dentry(struct inode *inode)
         return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DENTRY);
 }
 
-static inline void *inline_dentry_addr(struct page *page)
-{
-        struct f2fs_inode *ri = F2FS_INODE(page);
-        return (void *)&(ri->i_addr[1]);
-}
-
 static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page)
 {
         if (!f2fs_has_inline_dentry(dir))
@@ -1363,7 +1451,7 @@ struct dentry *f2fs_get_parent(struct dentry *child);
  * dir.c
  */
 extern unsigned char f2fs_filetype_table[F2FS_FT_MAX];
-void set_de_type(struct f2fs_dir_entry *, struct inode *);
+void set_de_type(struct f2fs_dir_entry *, umode_t);
 struct f2fs_dir_entry *find_target_dentry(struct qstr *, int *,
                         struct f2fs_dentry_ptr *);
 bool f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *,
@@ -1382,7 +1470,10 @@ ino_t f2fs_inode_by_name(struct inode *, struct qstr *);
 void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
                                 struct page *, struct inode *);
 int update_dent_inode(struct inode *, const struct qstr *);
-int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *);
+void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *,
+                        const struct qstr *, f2fs_hash_t , unsigned int);
+int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *, nid_t,
+                        umode_t);
 void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *,
                                                         struct inode *);
 int f2fs_do_tmpfile(struct inode *, struct inode *);
@@ -1392,7 +1483,7 @@ bool f2fs_empty_dir(struct inode *);
 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
 {
         return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name,
-                                inode);
+                                inode, inode->i_ino, inode->i_mode);
 }
 
 /*
@@ -1519,14 +1610,22 @@ int f2fs_submit_page_bio(struct f2fs_sb_info *, struct page *,
                                                 struct f2fs_io_info *);
 void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *,
                                                 struct f2fs_io_info *);
+void set_data_blkaddr(struct dnode_of_data *);
 int reserve_new_block(struct dnode_of_data *);
 int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
-void update_extent_cache(struct dnode_of_data *);
+void f2fs_shrink_extent_tree(struct f2fs_sb_info *, int);
+void f2fs_destroy_extent_tree(struct inode *);
+void f2fs_init_extent_cache(struct inode *, struct f2fs_extent *);
+void f2fs_update_extent_cache(struct dnode_of_data *);
+void f2fs_preserve_extent_tree(struct inode *);
 struct page *find_data_page(struct inode *, pgoff_t, bool);
 struct page *get_lock_data_page(struct inode *, pgoff_t);
 struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
 int do_write_data_page(struct page *, struct f2fs_io_info *);
 int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);
+void init_extent_cache_info(struct f2fs_sb_info *);
+int __init create_extent_cache(void);
+void destroy_extent_cache(void);
 void f2fs_invalidate_page(struct page *, unsigned int, unsigned int);
 int f2fs_release_page(struct page *, gfp_t);
 
@@ -1554,7 +1653,7 @@ struct f2fs_stat_info {
         struct f2fs_sb_info *sbi;
         int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
         int main_area_segs, main_area_sections, main_area_zones;
-        int hit_ext, total_ext;
+        int hit_ext, total_ext, ext_tree, ext_node;
         int ndirty_node, ndirty_dent, ndirty_dirs, ndirty_meta;
         int nats, dirty_nats, sits, dirty_sits, fnids;
         int total_count, utilization;
@@ -1566,7 +1665,9 @@ struct f2fs_stat_info {
         int dirty_count, node_pages, meta_pages;
         int prefree_count, call_count, cp_count;
         int tot_segs, node_segs, data_segs, free_segs, free_secs;
+        int bg_node_segs, bg_data_segs;
         int tot_blks, data_blks, node_blks;
+        int bg_data_blks, bg_node_blks;
         int curseg[NR_CURSEG_TYPE];
         int cursec[NR_CURSEG_TYPE];
         int curzone[NR_CURSEG_TYPE];
@@ -1615,31 +1716,36 @@ static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
                 ((sbi)->block_count[(curseg)->alloc_type]++)
 #define stat_inc_inplace_blocks(sbi)                                    \
                 (atomic_inc(&(sbi)->inplace_count))
-#define stat_inc_seg_count(sbi, type)                                   \
+#define stat_inc_seg_count(sbi, type, gc_type)                          \
         do {                                                            \
                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
                 (si)->tot_segs++;                                       \
-                if (type == SUM_TYPE_DATA)                              \
+                if (type == SUM_TYPE_DATA) {                            \
                         si->data_segs++;                                \
-                else                                                    \
+                        si->bg_data_segs += (gc_type == BG_GC) ? 1 : 0; \
+                } else {                                                \
                         si->node_segs++;                                \
+                        si->bg_node_segs += (gc_type == BG_GC) ? 1 : 0; \
+                }                                                       \
         } while (0)
 
 #define stat_inc_tot_blk_count(si, blks)                                \
         (si->tot_blks += (blks))
 
-#define stat_inc_data_blk_count(sbi, blks)                              \
+#define stat_inc_data_blk_count(sbi, blks, gc_type)                     \
         do {                                                            \
                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
                 stat_inc_tot_blk_count(si, blks);                       \
                 si->data_blks += (blks);                                \
+                si->bg_data_blks += (gc_type == BG_GC) ? (blks) : 0;    \
         } while (0)
 
-#define stat_inc_node_blk_count(sbi, blks)                              \
+#define stat_inc_node_blk_count(sbi, blks, gc_type)                     \
         do {                                                            \
                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
                 stat_inc_tot_blk_count(si, blks);                       \
                 si->node_blks += (blks);                                \
+                si->bg_node_blks += (gc_type == BG_GC) ? (blks) : 0;    \
         } while (0)
 
 int f2fs_build_stats(struct f2fs_sb_info *);
@@ -1661,10 +1767,10 @@ void f2fs_destroy_root_stats(void);
 #define stat_inc_seg_type(sbi, curseg)
 #define stat_inc_block_count(sbi, curseg)
 #define stat_inc_inplace_blocks(sbi)
-#define stat_inc_seg_count(si, type)
+#define stat_inc_seg_count(sbi, type, gc_type)
 #define stat_inc_tot_blk_count(si, blks)
-#define stat_inc_data_blk_count(si, blks)
-#define stat_inc_node_blk_count(sbi, blks)
+#define stat_inc_data_blk_count(sbi, blks, gc_type)
+#define stat_inc_node_blk_count(sbi, blks, gc_type)
 
 static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
 static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
@@ -1688,6 +1794,7 @@ extern struct kmem_cache *inode_entry_slab;
  */
 bool f2fs_may_inline(struct inode *);
 void read_inline_data(struct page *, struct page *);
+bool truncate_inline_inode(struct page *, u64);
 int f2fs_read_inline_data(struct inode *, struct page *);
 int f2fs_convert_inline_page(struct dnode_of_data *, struct page *);
 int f2fs_convert_inline_inode(struct inode *);
@@ -1697,7 +1804,8 @@ struct f2fs_dir_entry *find_in_inline_dir(struct inode *, struct qstr *,
                                                         struct page **);
 struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *, struct page **);
 int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
-int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *);
+int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *,
+                                                nid_t, umode_t);
 void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *,
                                                 struct inode *, struct inode *);
 bool f2fs_empty_inline_dir(struct inode *);