fs/f2fs/f2fs.h

   1 /*
   2  * fs/f2fs/f2fs.h
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   5  *             http://www.samsung.com/
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #ifndef _LINUX_F2FS_H
  12 #define _LINUX_F2FS_H
  13
  14 #include <linux/types.h>
  15 #include <linux/page-flags.h>
  16 #include <linux/buffer_head.h>
  17 #include <linux/slab.h>
  18 #include <linux/crc32.h>
  19 #include <linux/magic.h>
  20 #include <linux/kobject.h>
  21 #include <linux/sched.h>
  22
  23 #ifdef CONFIG_F2FS_CHECK_FS
  24 #define f2fs_bug_on(sbi, condition)     BUG_ON(condition)
  25 #define f2fs_down_write(x, y)   down_write_nest_lock(x, y)
  26 #else
  27 #define f2fs_bug_on(sbi, condition)                                     \
  28         do {                                                            \
  29                 if (unlikely(condition)) {                              \
  30                         WARN_ON(1);                                     \
  31                         set_sbi_flag(sbi, SBI_NEED_FSCK);               \
  32                 }                                                       \
  33         } while (0)
  34 #define f2fs_down_write(x, y)   down_write(x)
  35 #endif
  36
  37 /*
  38  * For mount options
  39  */
  40 #define F2FS_MOUNT_BG_GC                0x00000001
  41 #define F2FS_MOUNT_DISABLE_ROLL_FORWARD 0x00000002
  42 #define F2FS_MOUNT_DISCARD              0x00000004
  43 #define F2FS_MOUNT_NOHEAP               0x00000008
  44 #define F2FS_MOUNT_XATTR_USER           0x00000010
  45 #define F2FS_MOUNT_POSIX_ACL            0x00000020
  46 #define F2FS_MOUNT_DISABLE_EXT_IDENTIFY 0x00000040
  47 #define F2FS_MOUNT_INLINE_XATTR         0x00000080
  48 #define F2FS_MOUNT_INLINE_DATA          0x00000100
  49 #define F2FS_MOUNT_INLINE_DENTRY        0x00000200
  50 #define F2FS_MOUNT_FLUSH_MERGE          0x00000400
  51 #define F2FS_MOUNT_NOBARRIER            0x00000800
  52 #define F2FS_MOUNT_FASTBOOT             0x00001000
  53 #define F2FS_MOUNT_EXTENT_CACHE         0x00002000
  54
  55 #define clear_opt(sbi, option)  (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
  56 #define set_opt(sbi, option)    (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
  57 #define test_opt(sbi, option)   (sbi->mount_opt.opt & F2FS_MOUNT_##option)
  58
  59 #define ver_after(a, b) (typecheck(unsigned long long, a) &&            \
  60                 typecheck(unsigned long long, b) &&                     \
  61                 ((long long)((a) - (b)) > 0))
  62
  63 typedef u32 block_t;    /*
  64                          * should not change u32, since it is the on-disk block
  65                          * address format, __le32.
  66                          */
  67 typedef u32 nid_t;
  68
  69 struct f2fs_mount_info {
  70         unsigned int    opt;
  71 };
  72
  73 #define CRCPOLY_LE 0xedb88320
  74
  75 static inline __u32 f2fs_crc32(void *buf, size_t len)
  76 {
  77         unsigned char *p = (unsigned char *)buf;
  78         __u32 crc = F2FS_SUPER_MAGIC;
  79         int i;
  80
  81         while (len--) {
  82                 crc ^= *p++;
  83                 for (i = 0; i < 8; i++)
  84                         crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
  85         }
  86         return crc;
  87 }
  88
  89 static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size)
  90 {
  91         return f2fs_crc32(buf, buf_size) == blk_crc;
  92 }
  93
  94 /*
  95  * For checkpoint manager
  96  */
  97 enum {
  98         NAT_BITMAP,
  99         SIT_BITMAP
 100 };
 101
 102 enum {
 103         CP_UMOUNT,
 104         CP_FASTBOOT,
 105         CP_SYNC,
 106         CP_RECOVERY,
 107         CP_DISCARD,
 108 };
 109
 110 #define DEF_BATCHED_TRIM_SECTIONS       32
 111 #define BATCHED_TRIM_SEGMENTS(sbi)      \
 112                 (SM_I(sbi)->trim_sections * (sbi)->segs_per_sec)
 113
 114 struct cp_control {
 115         int reason;
 116         __u64 trim_start;
 117         __u64 trim_end;
 118         __u64 trim_minlen;
 119         __u64 trimmed;
 120 };
 121
 122 /*
 123  * For CP/NAT/SIT/SSA readahead
 124  */
 125 enum {
 126         META_CP,
 127         META_NAT,
 128         META_SIT,
 129         META_SSA,
 130         META_POR,
 131 };
 132
 133 /* for the list of ino */
 134 enum {
 135         ORPHAN_INO,             /* for orphan ino list */
 136         APPEND_INO,             /* for append ino list */
 137         UPDATE_INO,             /* for update ino list */
 138         MAX_INO_ENTRY,          /* max. list */
 139 };
 140
 141 struct ino_entry {
 142         struct list_head list;  /* list head */
 143         nid_t ino;              /* inode number */
 144 };
 145
 146 /*
 147  * for the list of directory inodes or gc inodes.
 148  * NOTE: there are two slab users for this structure, if we add/modify/delete
 149  * fields in structure for one of slab users, it may affect fields or size of
 150  * other one, in this condition, it's better to split both of slab and related
 151  * data structure.
 152  */
 153 struct inode_entry {
 154         struct list_head list;  /* list head */
 155         struct inode *inode;    /* vfs inode pointer */
 156 };
 157
 158 /* for the list of blockaddresses to be discarded */
 159 struct discard_entry {
 160         struct list_head list;  /* list head */
 161         block_t blkaddr;        /* block address to be discarded */
 162         int len;                /* # of consecutive blocks of the discard */
 163 };
 164
 165 /* for the list of fsync inodes, used only during recovery */
 166 struct fsync_inode_entry {
 167         struct list_head list;  /* list head */
 168         struct inode *inode;    /* vfs inode pointer */
 169         block_t blkaddr;        /* block address locating the last fsync */
 170         block_t last_dentry;    /* block address locating the last dentry */
 171         block_t last_inode;     /* block address locating the last inode */
 172 };
 173
 174 #define nats_in_cursum(sum)             (le16_to_cpu(sum->n_nats))
 175 #define sits_in_cursum(sum)             (le16_to_cpu(sum->n_sits))
 176
 177 #define nat_in_journal(sum, i)          (sum->nat_j.entries[i].ne)
 178 #define nid_in_journal(sum, i)          (sum->nat_j.entries[i].nid)
 179 #define sit_in_journal(sum, i)          (sum->sit_j.entries[i].se)
 180 #define segno_in_journal(sum, i)        (sum->sit_j.entries[i].segno)
 181
 182 #define MAX_NAT_JENTRIES(sum)   (NAT_JOURNAL_ENTRIES - nats_in_cursum(sum))
 183 #define MAX_SIT_JENTRIES(sum)   (SIT_JOURNAL_ENTRIES - sits_in_cursum(sum))
 184
 185 static inline int update_nats_in_cursum(struct f2fs_summary_block *rs, int i)
 186 {
 187         int before = nats_in_cursum(rs);
 188         rs->n_nats = cpu_to_le16(before + i);
 189         return before;
 190 }
 191
 192 static inline int update_sits_in_cursum(struct f2fs_summary_block *rs, int i)
 193 {
 194         int before = sits_in_cursum(rs);
 195         rs->n_sits = cpu_to_le16(before + i);
 196         return before;
 197 }
 198
 199 static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,
 200                                                                 int type)
 201 {
 202         if (type == NAT_JOURNAL)
 203                 return size <= MAX_NAT_JENTRIES(sum);
 204         return size <= MAX_SIT_JENTRIES(sum);
 205 }
 206
 207 /*
 208  * ioctl commands
 209  */
 210 #define F2FS_IOC_GETFLAGS               FS_IOC_GETFLAGS
 211 #define F2FS_IOC_SETFLAGS               FS_IOC_SETFLAGS
 212 #define F2FS_IOC_GETVERSION             FS_IOC_GETVERSION
 213
 214 #define F2FS_IOCTL_MAGIC                0xf5
 215 #define F2FS_IOC_START_ATOMIC_WRITE     _IO(F2FS_IOCTL_MAGIC, 1)
 216 #define F2FS_IOC_COMMIT_ATOMIC_WRITE    _IO(F2FS_IOCTL_MAGIC, 2)
 217 #define F2FS_IOC_START_VOLATILE_WRITE   _IO(F2FS_IOCTL_MAGIC, 3)
 218 #define F2FS_IOC_RELEASE_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 4)
 219 #define F2FS_IOC_ABORT_VOLATILE_WRITE   _IO(F2FS_IOCTL_MAGIC, 5)
 220
 221 /*
 222  * should be same as XFS_IOC_GOINGDOWN.
 223  * Flags for going down operation used by FS_IOC_GOINGDOWN
 224  */
 225 #define F2FS_IOC_SHUTDOWN       _IOR('X', 125, __u32)   /* Shutdown */
 226 #define F2FS_GOING_DOWN_FULLSYNC        0x0     /* going down with full sync */
 227 #define F2FS_GOING_DOWN_METASYNC        0x1     /* going down with metadata */
 228 #define F2FS_GOING_DOWN_NOSYNC          0x2     /* going down */
 229
 230 #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
 231 /*
 232  * ioctl commands in 32 bit emulation
 233  */
 234 #define F2FS_IOC32_GETFLAGS             FS_IOC32_GETFLAGS
 235 #define F2FS_IOC32_SETFLAGS             FS_IOC32_SETFLAGS
 236 #endif
 237
 238 /*
 239  * For INODE and NODE manager
 240  */
 241 /* for directory operations */
 242 struct f2fs_dentry_ptr {
 243         const void *bitmap;
 244         struct f2fs_dir_entry *dentry;
 245         __u8 (*filename)[F2FS_SLOT_LEN];
 246         int max;
 247 };
 248
 249 static inline void make_dentry_ptr(struct f2fs_dentry_ptr *d,
 250                                         void *src, int type)
 251 {
 252         if (type == 1) {
 253                 struct f2fs_dentry_block *t = (struct f2fs_dentry_block *)src;
 254                 d->max = NR_DENTRY_IN_BLOCK;
 255                 d->bitmap = &t->dentry_bitmap;
 256                 d->dentry = t->dentry;
 257                 d->filename = t->filename;
 258         } else {
 259                 struct f2fs_inline_dentry *t = (struct f2fs_inline_dentry *)src;
 260                 d->max = NR_INLINE_DENTRY;
 261                 d->bitmap = &t->dentry_bitmap;
 262                 d->dentry = t->dentry;
 263                 d->filename = t->filename;
 264         }
 265 }
 266
 267 /*
 268  * XATTR_NODE_OFFSET stores xattrs to one node block per file keeping -1
 269  * as its node offset to distinguish from index node blocks.
 270  * But some bits are used to mark the node block.
 271  */
 272 #define XATTR_NODE_OFFSET       ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
 273                                 >> OFFSET_BIT_SHIFT)
 274 enum {
 275         ALLOC_NODE,                     /* allocate a new node page if needed */
 276         LOOKUP_NODE,                    /* look up a node without readahead */
 277         LOOKUP_NODE_RA,                 /*
 278                                          * look up a node with readahead called
 279                                          * by get_data_block.
 280                                          */
 281 };
 282
 283 #define F2FS_LINK_MAX           32000   /* maximum link count per file */
 284
 285 #define MAX_DIR_RA_PAGES        4       /* maximum ra pages of dir */
 286
 287 /* vector size for gang look-up from extent cache that consists of radix tree */
 288 #define EXT_TREE_VEC_SIZE       64
 289
 290 /* for in-memory extent cache entry */
 291 #define F2FS_MIN_EXTENT_LEN     64      /* minimum extent length */
 292
 293 /* number of extent info in extent cache we try to shrink */
 294 #define EXTENT_CACHE_SHRINK_NUMBER      128
 295
 296 struct extent_info {
 297         unsigned int fofs;              /* start offset in a file */
 298         u32 blk;                        /* start block address of the extent */
 299         unsigned int len;               /* length of the extent */
 300 };
 301
 302 struct extent_node {
 303         struct rb_node rb_node;         /* rb node located in rb-tree */
 304         struct list_head list;          /* node in global extent list of sbi */
 305         struct extent_info ei;          /* extent info */
 306 };
 307
 308 struct extent_tree {
 309         nid_t ino;                      /* inode number */
 310         struct rb_root root;            /* root of extent info rb-tree */
 311         struct extent_node *cached_en;  /* recently accessed extent node */
 312         rwlock_t lock;                  /* protect extent info rb-tree */
 313         atomic_t refcount;              /* reference count of rb-tree */
 314         unsigned int count;             /* # of extent node in rb-tree*/
 315 };
 316
 317 /*
 318  * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
 319  */
 320 #define FADVISE_COLD_BIT        0x01
 321 #define FADVISE_LOST_PINO_BIT   0x02
 322
 323 #define DEF_DIR_LEVEL           0
 324
 325 struct f2fs_inode_info {
 326         struct inode vfs_inode;         /* serve a vfs inode */
 327         unsigned long i_flags;          /* keep an inode flags for ioctl */
 328         unsigned char i_advise;         /* use to give file attribute hints */
 329         unsigned char i_dir_level;      /* use for dentry level for large dir */
 330         unsigned int i_current_depth;   /* use only in directory structure */
 331         unsigned int i_pino;            /* parent inode number */
 332         umode_t i_acl_mode;             /* keep file acl mode temporarily */
 333
 334         /* Use below internally in f2fs*/
 335         unsigned long flags;            /* use to pass per-file flags */
 336         struct rw_semaphore i_sem;      /* protect fi info */
 337         atomic_t dirty_pages;           /* # of dirty pages */
 338         f2fs_hash_t chash;              /* hash value of given file name */
 339         unsigned int clevel;            /* maximum level of given file name */
 340         nid_t i_xattr_nid;              /* node id that contains xattrs */
 341         unsigned long long xattr_ver;   /* cp version of xattr modification */
 342         struct extent_info ext;         /* in-memory extent cache entry */
 343         rwlock_t ext_lock;              /* rwlock for single extent cache */
 344         struct inode_entry *dirty_dir;  /* the pointer of dirty dir */
 345
 346         struct radix_tree_root inmem_root;      /* radix tree for inmem pages */
 347         struct list_head inmem_pages;   /* inmemory pages managed by f2fs */
 348         struct mutex inmem_lock;        /* lock for inmemory pages */
 349 };
 350
 351 static inline void get_extent_info(struct extent_info *ext,
 352                                         struct f2fs_extent i_ext)
 353 {
 354         ext->fofs = le32_to_cpu(i_ext.fofs);
 355         ext->blk = le32_to_cpu(i_ext.blk);
 356         ext->len = le32_to_cpu(i_ext.len);
 357 }
 358
 359 static inline void set_raw_extent(struct extent_info *ext,
 360                                         struct f2fs_extent *i_ext)
 361 {
 362         i_ext->fofs = cpu_to_le32(ext->fofs);
 363         i_ext->blk = cpu_to_le32(ext->blk);
 364         i_ext->len = cpu_to_le32(ext->len);
 365 }
 366
 367 static inline void set_extent_info(struct extent_info *ei, unsigned int fofs,
 368                                                 u32 blk, unsigned int len)
 369 {
 370         ei->fofs = fofs;
 371         ei->blk = blk;
 372         ei->len = len;
 373 }
 374
 375 static inline bool __is_extent_same(struct extent_info *ei1,
 376                                                 struct extent_info *ei2)
 377 {
 378         return (ei1->fofs == ei2->fofs && ei1->blk == ei2->blk &&
 379                                                 ei1->len == ei2->len);
 380 }
 381
 382 static inline bool __is_extent_mergeable(struct extent_info *back,
 383                                                 struct extent_info *front)
 384 {
 385         return (back->fofs + back->len == front->fofs &&
 386                         back->blk + back->len == front->blk);
 387 }
 388
 389 static inline bool __is_back_mergeable(struct extent_info *cur,
 390                                                 struct extent_info *back)
 391 {
 392         return __is_extent_mergeable(back, cur);
 393 }
 394
 395 static inline bool __is_front_mergeable(struct extent_info *cur,
 396                                                 struct extent_info *front)
 397 {
 398         return __is_extent_mergeable(cur, front);
 399 }
 400
 401 struct f2fs_nm_info {
 402         block_t nat_blkaddr;            /* base disk address of NAT */
 403         nid_t max_nid;                  /* maximum possible node ids */
 404         nid_t available_nids;           /* maximum available node ids */
 405         nid_t next_scan_nid;            /* the next nid to be scanned */
 406         unsigned int ram_thresh;        /* control the memory footprint */
 407
 408         /* NAT cache management */
 409         struct radix_tree_root nat_root;/* root of the nat entry cache */
 410         struct radix_tree_root nat_set_root;/* root of the nat set cache */
 411         struct rw_semaphore nat_tree_lock;      /* protect nat_tree_lock */
 412         struct list_head nat_entries;   /* cached nat entry list (clean) */
 413         unsigned int nat_cnt;           /* the # of cached nat entries */
 414         unsigned int dirty_nat_cnt;     /* total num of nat entries in set */
 415
 416         /* free node ids management */
 417         struct radix_tree_root free_nid_root;/* root of the free_nid cache */
 418         struct list_head free_nid_list; /* a list for free nids */
 419         spinlock_t free_nid_list_lock;  /* protect free nid list */
 420         unsigned int fcnt;              /* the number of free node id */
 421         struct mutex build_lock;        /* lock for build free nids */
 422
 423         /* for checkpoint */
 424         char *nat_bitmap;               /* NAT bitmap pointer */
 425         int bitmap_size;                /* bitmap size */
 426 };
 427
 428 /*
 429  * this structure is used as one of function parameters.
 430  * all the information are dedicated to a given direct node block determined
 431  * by the data offset in a file.
 432  */
 433 struct dnode_of_data {
 434         struct inode *inode;            /* vfs inode pointer */
 435         struct page *inode_page;        /* its inode page, NULL is possible */
 436         struct page *node_page;         /* cached direct node page */
 437         nid_t nid;                      /* node id of the direct node block */
 438         unsigned int ofs_in_node;       /* data offset in the node page */
 439         bool inode_page_locked;         /* inode page is locked or not */
 440         block_t data_blkaddr;           /* block address of the node block */
 441 };
 442
 443 static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
 444                 struct page *ipage, struct page *npage, nid_t nid)
 445 {
 446         memset(dn, 0, sizeof(*dn));
 447         dn->inode = inode;
 448         dn->inode_page = ipage;
 449         dn->node_page = npage;
 450         dn->nid = nid;
 451 }
 452
 453 /*
 454  * For SIT manager
 455  *
 456  * By default, there are 6 active log areas across the whole main area.
 457  * When considering hot and cold data separation to reduce cleaning overhead,
 458  * we split 3 for data logs and 3 for node logs as hot, warm, and cold types,
 459  * respectively.
 460  * In the current design, you should not change the numbers intentionally.
 461  * Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6
 462  * logs individually according to the underlying devices. (default: 6)
 463  * Just in case, on-disk layout covers maximum 16 logs that consist of 8 for
 464  * data and 8 for node logs.
 465  */
 466 #define NR_CURSEG_DATA_TYPE     (3)
 467 #define NR_CURSEG_NODE_TYPE     (3)
 468 #define NR_CURSEG_TYPE  (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
 469
 470 enum {
 471         CURSEG_HOT_DATA = 0,    /* directory entry blocks */
 472         CURSEG_WARM_DATA,       /* data blocks */
 473         CURSEG_COLD_DATA,       /* multimedia or GCed data blocks */
 474         CURSEG_HOT_NODE,        /* direct node blocks of directory files */
 475         CURSEG_WARM_NODE,       /* direct node blocks of normal files */
 476         CURSEG_COLD_NODE,       /* indirect node blocks */
 477         NO_CHECK_TYPE,
 478         CURSEG_DIRECT_IO,       /* to use for the direct IO path */
 479 };
 480
 481 struct flush_cmd {
 482         struct completion wait;
 483         struct llist_node llnode;
 484         int ret;
 485 };
 486
 487 struct flush_cmd_control {
 488         struct task_struct *f2fs_issue_flush;   /* flush thread */
 489         wait_queue_head_t flush_wait_queue;     /* waiting queue for wake-up */
 490         struct llist_head issue_list;           /* list for command issue */
 491         struct llist_node *dispatch_list;       /* list for command dispatch */
 492 };
 493
 494 struct f2fs_sm_info {
 495         struct sit_info *sit_info;              /* whole segment information */
 496         struct free_segmap_info *free_info;     /* free segment information */
 497         struct dirty_seglist_info *dirty_info;  /* dirty segment information */
 498         struct curseg_info *curseg_array;       /* active segment information */
 499
 500         block_t seg0_blkaddr;           /* block address of 0'th segment */
 501         block_t main_blkaddr;           /* start block address of main area */
 502         block_t ssa_blkaddr;            /* start block address of SSA area */
 503
 504         unsigned int segment_count;     /* total # of segments */
 505         unsigned int main_segments;     /* # of segments in main area */
 506         unsigned int reserved_segments; /* # of reserved segments */
 507         unsigned int ovp_segments;      /* # of overprovision segments */
 508
 509         /* a threshold to reclaim prefree segments */
 510         unsigned int rec_prefree_segments;
 511
 512         /* for small discard management */
 513         struct list_head discard_list;          /* 4KB discard list */
 514         int nr_discards;                        /* # of discards in the list */
 515         int max_discards;                       /* max. discards to be issued */
 516
 517         /* for batched trimming */
 518         unsigned int trim_sections;             /* # of sections to trim */
 519
 520         struct list_head sit_entry_set; /* sit entry set list */
 521
 522         unsigned int ipu_policy;        /* in-place-update policy */
 523         unsigned int min_ipu_util;      /* in-place-update threshold */
 524         unsigned int min_fsync_blocks;  /* threshold for fsync */
 525
 526         /* for flush command control */
 527         struct flush_cmd_control *cmd_control_info;
 528
 529 };
 530
 531 /*
 532  * For superblock
 533  */
 534 /*
 535  * COUNT_TYPE for monitoring
 536  *
 537  * f2fs monitors the number of several block types such as on-writeback,
 538  * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
 539  */
 540 enum count_type {
 541         F2FS_WRITEBACK,
 542         F2FS_DIRTY_DENTS,
 543         F2FS_DIRTY_NODES,
 544         F2FS_DIRTY_META,
 545         F2FS_INMEM_PAGES,
 546         NR_COUNT_TYPE,
 547 };
 548
 549 /*
 550  * The below are the page types of bios used in submit_bio().
 551  * The available types are:
 552  * DATA                 User data pages. It operates as async mode.
 553  * NODE                 Node pages. It operates as async mode.
 554  * META                 FS metadata pages such as SIT, NAT, CP.
 555  * NR_PAGE_TYPE         The number of page types.
 556  * META_FLUSH           Make sure the previous pages are written
 557  *                      with waiting the bio's completion
 558  * ...                  Only can be used with META.
 559  */
 560 #define PAGE_TYPE_OF_BIO(type)  ((type) > META ? META : (type))
 561 enum page_type {
 562         DATA,
 563         NODE,
 564         META,
 565         NR_PAGE_TYPE,
 566         META_FLUSH,
 567         INMEM,          /* the below types are used by tracepoints only. */
 568         INMEM_DROP,
 569         IPU,
 570         OPU,
 571 };
 572
 573 struct f2fs_io_info {
 574         enum page_type type;    /* contains DATA/NODE/META/META_FLUSH */
 575         int rw;                 /* contains R/RS/W/WS with REQ_META/REQ_PRIO */
 576         block_t blk_addr;       /* block address to be written */
 577 };
 578
 579 #define is_read_io(rw)  (((rw) & 1) == READ)
 580 struct f2fs_bio_info {
 581         struct f2fs_sb_info *sbi;       /* f2fs superblock */
 582         struct bio *bio;                /* bios to merge */
 583         sector_t last_block_in_bio;     /* last block number */
 584         struct f2fs_io_info fio;        /* store buffered io info. */
 585         struct rw_semaphore io_rwsem;   /* blocking op for bio */
 586 };
 587
 588 /* for inner inode cache management */
 589 struct inode_management {
 590         struct radix_tree_root ino_root;        /* ino entry array */
 591         spinlock_t ino_lock;                    /* for ino entry lock */
 592         struct list_head ino_list;              /* inode list head */
 593         unsigned long ino_num;                  /* number of entries */
 594 };
 595
 596 /* For s_flag in struct f2fs_sb_info */
 597 enum {
 598         SBI_IS_DIRTY,                           /* dirty flag for checkpoint */
 599         SBI_IS_CLOSE,                           /* specify unmounting */
 600         SBI_NEED_FSCK,                          /* need fsck.f2fs to fix */
 601         SBI_POR_DOING,                          /* recovery is doing or not */
 602 };
 603
 604 struct f2fs_sb_info {
 605         struct super_block *sb;                 /* pointer to VFS super block */
 606         struct proc_dir_entry *s_proc;          /* proc entry */
 607         struct buffer_head *raw_super_buf;      /* buffer head of raw sb */
 608         struct f2fs_super_block *raw_super;     /* raw super block pointer */
 609         int s_flag;                             /* flags for sbi */
 610
 611         /* for node-related operations */
 612         struct f2fs_nm_info *nm_info;           /* node manager */
 613         struct inode *node_inode;               /* cache node blocks */
 614
 615         /* for segment-related operations */
 616         struct f2fs_sm_info *sm_info;           /* segment manager */
 617
 618         /* for bio operations */
 619         struct f2fs_bio_info read_io;                   /* for read bios */
 620         struct f2fs_bio_info write_io[NR_PAGE_TYPE];    /* for write bios */
 621
 622         /* for checkpoint */
 623         struct f2fs_checkpoint *ckpt;           /* raw checkpoint pointer */
 624         struct inode *meta_inode;               /* cache meta blocks */
 625         struct mutex cp_mutex;                  /* checkpoint procedure lock */
 626         struct rw_semaphore cp_rwsem;           /* blocking FS operations */
 627         struct rw_semaphore node_write;         /* locking node writes */
 628         wait_queue_head_t cp_wait;
 629
 630         struct inode_management im[MAX_INO_ENTRY];      /* manage inode cache */
 631
 632         /* for orphan inode, use 0'th array */
 633         unsigned int max_orphans;               /* max orphan inodes */
 634
 635         /* for directory inode management */
 636         struct list_head dir_inode_list;        /* dir inode list */
 637         spinlock_t dir_inode_lock;              /* for dir inode list lock */
 638
 639         /* for extent tree cache */
 640         struct radix_tree_root extent_tree_root;/* cache extent cache entries */
 641         struct rw_semaphore extent_tree_lock;   /* locking extent radix tree */
 642         struct list_head extent_list;           /* lru list for shrinker */
 643         spinlock_t extent_lock;                 /* locking extent lru list */
 644         int total_ext_tree;                     /* extent tree count */
 645         atomic_t total_ext_node;                /* extent info count */
 646
 647         /* basic filesystem units */
 648         unsigned int log_sectors_per_block;     /* log2 sectors per block */
 649         unsigned int log_blocksize;             /* log2 block size */
 650         unsigned int blocksize;                 /* block size */
 651         unsigned int root_ino_num;              /* root inode number*/
 652         unsigned int node_ino_num;              /* node inode number*/
 653         unsigned int meta_ino_num;              /* meta inode number*/
 654         unsigned int log_blocks_per_seg;        /* log2 blocks per segment */
 655         unsigned int blocks_per_seg;            /* blocks per segment */
 656         unsigned int segs_per_sec;              /* segments per section */
 657         unsigned int secs_per_zone;             /* sections per zone */
 658         unsigned int total_sections;            /* total section count */
 659         unsigned int total_node_count;          /* total node block count */
 660         unsigned int total_valid_node_count;    /* valid node block count */
 661         unsigned int total_valid_inode_count;   /* valid inode count */
 662         int active_logs;                        /* # of active logs */
 663         int dir_level;                          /* directory level */
 664
 665         block_t user_block_count;               /* # of user blocks */
 666         block_t total_valid_block_count;        /* # of valid blocks */
 667         block_t alloc_valid_block_count;        /* # of allocated blocks */
 668         block_t last_valid_block_count;         /* for recovery */
 669         u32 s_next_generation;                  /* for NFS support */
 670         atomic_t nr_pages[NR_COUNT_TYPE];       /* # of pages, see count_type */
 671
 672         struct f2fs_mount_info mount_opt;       /* mount options */
 673
 674         /* for cleaning operations */
 675         struct mutex gc_mutex;                  /* mutex for GC */
 676         struct f2fs_gc_kthread  *gc_thread;     /* GC thread */
 677         unsigned int cur_victim_sec;            /* current victim section num */
 678
 679         /* maximum # of trials to find a victim segment for SSR and GC */
 680         unsigned int max_victim_search;
 681
 682         /*
 683          * for stat information.
 684          * one is for the LFS mode, and the other is for the SSR mode.
 685          */
 686 #ifdef CONFIG_F2FS_STAT_FS
 687         struct f2fs_stat_info *stat_info;       /* FS status information */
 688         unsigned int segment_count[2];          /* # of allocated segments */
 689         unsigned int block_count[2];            /* # of allocated blocks */
 690         atomic_t inplace_count;         /* # of inplace update */
 691         int total_hit_ext, read_hit_ext;        /* extent cache hit ratio */
 692         atomic_t inline_inode;                  /* # of inline_data inodes */
 693         atomic_t inline_dir;                    /* # of inline_dentry inodes */
 694         int bg_gc;                              /* background gc calls */
 695         unsigned int n_dirty_dirs;              /* # of dir inodes */
 696 #endif
 697         unsigned int last_victim[2];            /* last victim segment # */
 698         spinlock_t stat_lock;                   /* lock for stat operations */
 699
 700         /* For sysfs suppport */
 701         struct kobject s_kobj;
 702         struct completion s_kobj_unregister;
 703 };
 704
 705 /*
 706  * Inline functions
 707  */
 708 static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
 709 {
 710         return container_of(inode, struct f2fs_inode_info, vfs_inode);
 711 }
 712
 713 static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
 714 {
 715         return sb->s_fs_info;
 716 }
 717
 718 static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)
 719 {
 720         return F2FS_SB(inode->i_sb);
 721 }
 722
 723 static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping)
 724 {
 725         return F2FS_I_SB(mapping->host);
 726 }
 727
 728 static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page)
 729 {
 730         return F2FS_M_SB(page->mapping);
 731 }
 732
 733 static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
 734 {
 735         return (struct f2fs_super_block *)(sbi->raw_super);
 736 }
 737
 738 static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
 739 {
 740         return (struct f2fs_checkpoint *)(sbi->ckpt);
 741 }
 742
 743 static inline struct f2fs_node *F2FS_NODE(struct page *page)
 744 {
 745         return (struct f2fs_node *)page_address(page);
 746 }
 747
 748 static inline struct f2fs_inode *F2FS_INODE(struct page *page)
 749 {
 750         return &((struct f2fs_node *)page_address(page))->i;
 751 }
 752
 753 static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
 754 {
 755         return (struct f2fs_nm_info *)(sbi->nm_info);
 756 }
 757
 758 static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
 759 {
 760         return (struct f2fs_sm_info *)(sbi->sm_info);
 761 }
 762
 763 static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
 764 {
 765         return (struct sit_info *)(SM_I(sbi)->sit_info);
 766 }
 767
 768 static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
 769 {
 770         return (struct free_segmap_info *)(SM_I(sbi)->free_info);
 771 }
 772
 773 static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
 774 {
 775         return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
 776 }
 777
 778 static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
 779 {
 780         return sbi->meta_inode->i_mapping;
 781 }
 782
 783 static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
 784 {
 785         return sbi->node_inode->i_mapping;
 786 }
 787
 788 static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)
 789 {
 790         return sbi->s_flag & (0x01 << type);
 791 }
 792
 793 static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
 794 {
 795         sbi->s_flag |= (0x01 << type);
 796 }
 797
 798 static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
 799 {
 800         sbi->s_flag &= ~(0x01 << type);
 801 }
 802
 803 static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
 804 {
 805         return le64_to_cpu(cp->checkpoint_ver);
 806 }
 807
 808 static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
 809 {
 810         unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
 811         return ckpt_flags & f;
 812 }
 813
 814 static inline void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
 815 {
 816         unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
 817         ckpt_flags |= f;
 818         cp->ckpt_flags = cpu_to_le32(ckpt_flags);
 819 }
 820
 821 static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
 822 {
 823         unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
 824         ckpt_flags &= (~f);
 825         cp->ckpt_flags = cpu_to_le32(ckpt_flags);
 826 }
 827
 828 static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
 829 {
 830         down_read(&sbi->cp_rwsem);
 831 }
 832
 833 static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
 834 {
 835         up_read(&sbi->cp_rwsem);
 836 }
 837
 838 static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
 839 {
 840         f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex);
 841 }
 842
 843 static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
 844 {
 845         up_write(&sbi->cp_rwsem);
 846 }
 847
 848 static inline int __get_cp_reason(struct f2fs_sb_info *sbi)
 849 {
 850         int reason = CP_SYNC;
 851
 852         if (test_opt(sbi, FASTBOOT))
 853                 reason = CP_FASTBOOT;
 854         if (is_sbi_flag_set(sbi, SBI_IS_CLOSE))
 855                 reason = CP_UMOUNT;
 856         return reason;
 857 }
 858
 859 static inline bool __remain_node_summaries(int reason)
 860 {
 861         return (reason == CP_UMOUNT || reason == CP_FASTBOOT);
 862 }
 863
 864 static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)
 865 {
 866         return (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG) ||
 867                         is_set_ckpt_flags(F2FS_CKPT(sbi), CP_FASTBOOT_FLAG));
 868 }
 869
 870 /*
 871  * Check whether the given nid is within node id range.
 872  */
 873 static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
 874 {
 875         if (unlikely(nid < F2FS_ROOT_INO(sbi)))
 876                 return -EINVAL;
 877         if (unlikely(nid >= NM_I(sbi)->max_nid))
 878                 return -EINVAL;
 879         return 0;
 880 }
 881
 882 #define F2FS_DEFAULT_ALLOCATED_BLOCKS   1
 883
 884 /*
 885  * Check whether the inode has blocks or not
 886  */
 887 static inline int F2FS_HAS_BLOCKS(struct inode *inode)
 888 {
 889         if (F2FS_I(inode)->i_xattr_nid)
 890                 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
 891         else
 892                 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
 893 }
 894
 895 static inline bool f2fs_has_xattr_block(unsigned int ofs)
 896 {
 897         return ofs == XATTR_NODE_OFFSET;
 898 }
 899
 900 static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
 901                                  struct inode *inode, blkcnt_t count)
 902 {
 903         block_t valid_block_count;
 904
 905         spin_lock(&sbi->stat_lock);
 906         valid_block_count =
 907                 sbi->total_valid_block_count + (block_t)count;
 908         if (unlikely(valid_block_count > sbi->user_block_count)) {
 909                 spin_unlock(&sbi->stat_lock);
 910                 return false;
 911         }
 912         inode->i_blocks += count;
 913         sbi->total_valid_block_count = valid_block_count;
 914         sbi->alloc_valid_block_count += (block_t)count;
 915         spin_unlock(&sbi->stat_lock);
 916         return true;
 917 }
 918
 919 static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
 920                                                 struct inode *inode,
 921                                                 blkcnt_t count)
 922 {
 923         spin_lock(&sbi->stat_lock);
 924         f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
 925         f2fs_bug_on(sbi, inode->i_blocks < count);
 926         inode->i_blocks -= count;
 927         sbi->total_valid_block_count -= (block_t)count;
 928         spin_unlock(&sbi->stat_lock);
 929 }
 930
 931 static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
 932 {
 933         atomic_inc(&sbi->nr_pages[count_type]);
 934         set_sbi_flag(sbi, SBI_IS_DIRTY);
 935 }
 936
 937 static inline void inode_inc_dirty_pages(struct inode *inode)
 938 {
 939         atomic_inc(&F2FS_I(inode)->dirty_pages);
 940         if (S_ISDIR(inode->i_mode))
 941                 inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
 942 }
 943
 944 static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
 945 {
 946         atomic_dec(&sbi->nr_pages[count_type]);
 947 }
 948
 949 static inline void inode_dec_dirty_pages(struct inode *inode)
 950 {
 951         if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode))
 952                 return;
 953
 954         atomic_dec(&F2FS_I(inode)->dirty_pages);
 955
 956         if (S_ISDIR(inode->i_mode))
 957                 dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
 958 }
 959
 960 static inline int get_pages(struct f2fs_sb_info *sbi, int count_type)
 961 {
 962         return atomic_read(&sbi->nr_pages[count_type]);
 963 }
 964
 965 static inline int get_dirty_pages(struct inode *inode)
 966 {
 967         return atomic_read(&F2FS_I(inode)->dirty_pages);
 968 }
 969
 970 static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
 971 {
 972         unsigned int pages_per_sec = sbi->segs_per_sec *
 973                                         (1 << sbi->log_blocks_per_seg);
 974         return ((get_pages(sbi, block_type) + pages_per_sec - 1)
 975                         >> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
 976 }
 977
 978 static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
 979 {
 980         return sbi->total_valid_block_count;
 981 }
 982
 983 static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
 984 {
 985         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
 986
 987         /* return NAT or SIT bitmap */
 988         if (flag == NAT_BITMAP)
 989                 return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
 990         else if (flag == SIT_BITMAP)
 991                 return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
 992
 993         return 0;
 994 }
 995
 996 static inline block_t __cp_payload(struct f2fs_sb_info *sbi)
 997 {
 998         return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
 999 }
1000
1001 static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
1002 {
1003         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1004         int offset;
1005
1006         if (__cp_payload(sbi) > 0) {
1007                 if (flag == NAT_BITMAP)
1008                         return &ckpt->sit_nat_version_bitmap;
1009                 else
1010                         return (unsigned char *)ckpt + F2FS_BLKSIZE;
1011         } else {
1012                 offset = (flag == NAT_BITMAP) ?
1013                         le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
1014                 return &ckpt->sit_nat_version_bitmap + offset;
1015         }
1016 }
1017
1018 static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
1019 {
1020         block_t start_addr;
1021         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1022         unsigned long long ckpt_version = cur_cp_version(ckpt);
1023
1024         start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
1025
1026         /*
1027          * odd numbered checkpoint should at cp segment 0
1028          * and even segment must be at cp segment 1
1029          */
1030         if (!(ckpt_version & 1))
1031                 start_addr += sbi->blocks_per_seg;
1032
1033         return start_addr;
1034 }
1035
1036 static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
1037 {
1038         return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
1039 }
1040
1041 static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi,
1042                                                 struct inode *inode)
1043 {
1044         block_t valid_block_count;
1045         unsigned int valid_node_count;
1046
1047         spin_lock(&sbi->stat_lock);
1048
1049         valid_block_count = sbi->total_valid_block_count + 1;
1050         if (unlikely(valid_block_count > sbi->user_block_count)) {
1051                 spin_unlock(&sbi->stat_lock);
1052                 return false;
1053         }
1054
1055         valid_node_count = sbi->total_valid_node_count + 1;
1056         if (unlikely(valid_node_count > sbi->total_node_count)) {
1057                 spin_unlock(&sbi->stat_lock);
1058                 return false;
1059         }
1060
1061         if (inode)
1062                 inode->i_blocks++;
1063
1064         sbi->alloc_valid_block_count++;
1065         sbi->total_valid_node_count++;
1066         sbi->total_valid_block_count++;
1067         spin_unlock(&sbi->stat_lock);
1068
1069         return true;
1070 }
1071
1072 static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
1073                                                 struct inode *inode)
1074 {
1075         spin_lock(&sbi->stat_lock);
1076
1077         f2fs_bug_on(sbi, !sbi->total_valid_block_count);
1078         f2fs_bug_on(sbi, !sbi->total_valid_node_count);
1079         f2fs_bug_on(sbi, !inode->i_blocks);
1080
1081         inode->i_blocks--;
1082         sbi->total_valid_node_count--;
1083         sbi->total_valid_block_count--;
1084
1085         spin_unlock(&sbi->stat_lock);
1086 }
1087
1088 static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
1089 {
1090         return sbi->total_valid_node_count;
1091 }
1092
1093 static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
1094 {
1095         spin_lock(&sbi->stat_lock);
1096         f2fs_bug_on(sbi, sbi->total_valid_inode_count == sbi->total_node_count);
1097         sbi->total_valid_inode_count++;
1098         spin_unlock(&sbi->stat_lock);
1099 }
1100
1101 static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
1102 {
1103         spin_lock(&sbi->stat_lock);
1104         f2fs_bug_on(sbi, !sbi->total_valid_inode_count);
1105         sbi->total_valid_inode_count--;
1106         spin_unlock(&sbi->stat_lock);
1107 }
1108
1109 static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi)
1110 {
1111         return sbi->total_valid_inode_count;
1112 }
1113
1114 static inline void f2fs_put_page(struct page *page, int unlock)
1115 {
1116         if (!page)
1117                 return;
1118
1119         if (unlock) {
1120                 f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page));
1121                 unlock_page(page);
1122         }
1123         page_cache_release(page);
1124 }
1125
1126 static inline void f2fs_put_dnode(struct dnode_of_data *dn)
1127 {
1128         if (dn->node_page)
1129                 f2fs_put_page(dn->node_page, 1);
1130         if (dn->inode_page && dn->node_page != dn->inode_page)
1131                 f2fs_put_page(dn->inode_page, 0);
1132         dn->node_page = NULL;
1133         dn->inode_page = NULL;
1134 }
1135
1136 static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
1137                                         size_t size)
1138 {
1139         return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
1140 }
1141
1142 static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep,
1143                                                 gfp_t flags)
1144 {
1145         void *entry;
1146 retry:
1147         entry = kmem_cache_alloc(cachep, flags);
1148         if (!entry) {
1149                 cond_resched();
1150                 goto retry;
1151         }
1152
1153         return entry;
1154 }
1155
1156 static inline void f2fs_radix_tree_insert(struct radix_tree_root *root,
1157                                 unsigned long index, void *item)
1158 {
1159         while (radix_tree_insert(root, index, item))
1160                 cond_resched();
1161 }
1162
1163 #define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
1164
1165 static inline bool IS_INODE(struct page *page)
1166 {
1167         struct f2fs_node *p = F2FS_NODE(page);
1168         return RAW_IS_INODE(p);
1169 }
1170
1171 static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
1172 {
1173         return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
1174 }
1175
1176 static inline block_t datablock_addr(struct page *node_page,
1177                 unsigned int offset)
1178 {
1179         struct f2fs_node *raw_node;
1180         __le32 *addr_array;
1181         raw_node = F2FS_NODE(node_page);
1182         addr_array = blkaddr_in_node(raw_node);
1183         return le32_to_cpu(addr_array[offset]);
1184 }
1185
1186 static inline int f2fs_test_bit(unsigned int nr, char *addr)
1187 {
1188         int mask;
1189
1190         addr += (nr >> 3);
1191         mask = 1 << (7 - (nr & 0x07));
1192         return mask & *addr;
1193 }
1194
1195 static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr)
1196 {
1197         int mask;
1198         int ret;
1199
1200         addr += (nr >> 3);
1201         mask = 1 << (7 - (nr & 0x07));
1202         ret = mask & *addr;
1203         *addr |= mask;
1204         return ret;
1205 }
1206
1207 static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr)
1208 {
1209         int mask;
1210         int ret;
1211
1212         addr += (nr >> 3);
1213         mask = 1 << (7 - (nr & 0x07));
1214         ret = mask & *addr;
1215         *addr &= ~mask;
1216         return ret;
1217 }
1218
1219 static inline void f2fs_change_bit(unsigned int nr, char *addr)
1220 {
1221         int mask;
1222
1223         addr += (nr >> 3);
1224         mask = 1 << (7 - (nr & 0x07));
1225         *addr ^= mask;
1226 }
1227
1228 /* used for f2fs_inode_info->flags */
1229 enum {
1230         FI_NEW_INODE,           /* indicate newly allocated inode */
1231         FI_DIRTY_INODE,         /* indicate inode is dirty or not */
1232         FI_DIRTY_DIR,           /* indicate directory has dirty pages */
1233         FI_INC_LINK,            /* need to increment i_nlink */
1234         FI_ACL_MODE,            /* indicate acl mode */
1235         FI_NO_ALLOC,            /* should not allocate any blocks */
1236         FI_UPDATE_DIR,          /* should update inode block for consistency */
1237         FI_DELAY_IPUT,          /* used for the recovery */
1238         FI_NO_EXTENT,           /* not to use the extent cache */
1239         FI_INLINE_XATTR,        /* used for inline xattr */
1240         FI_INLINE_DATA,         /* used for inline data*/
1241         FI_INLINE_DENTRY,       /* used for inline dentry */
1242         FI_APPEND_WRITE,        /* inode has appended data */
1243         FI_UPDATE_WRITE,        /* inode has in-place-update data */
1244         FI_NEED_IPU,            /* used for ipu per file */
1245         FI_ATOMIC_FILE,         /* indicate atomic file */
1246         FI_VOLATILE_FILE,       /* indicate volatile file */
1247         FI_FIRST_BLOCK_WRITTEN, /* indicate #0 data block was written */
1248         FI_DROP_CACHE,          /* drop dirty page cache */
1249         FI_DATA_EXIST,          /* indicate data exists */
1250         FI_INLINE_DOTS,         /* indicate inline dot dentries */
1251 };
1252
1253 static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
1254 {
1255         if (!test_bit(flag, &fi->flags))
1256                 set_bit(flag, &fi->flags);
1257 }
1258
1259 static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag)
1260 {
1261         return test_bit(flag, &fi->flags);
1262 }
1263
1264 static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag)
1265 {
1266         if (test_bit(flag, &fi->flags))
1267                 clear_bit(flag, &fi->flags);
1268 }
1269
1270 static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode)
1271 {
1272         fi->i_acl_mode = mode;
1273         set_inode_flag(fi, FI_ACL_MODE);
1274 }
1275
1276 static inline void get_inline_info(struct f2fs_inode_info *fi,
1277                                         struct f2fs_inode *ri)
1278 {
1279         if (ri->i_inline & F2FS_INLINE_XATTR)
1280                 set_inode_flag(fi, FI_INLINE_XATTR);
1281         if (ri->i_inline & F2FS_INLINE_DATA)
1282                 set_inode_flag(fi, FI_INLINE_DATA);
1283         if (ri->i_inline & F2FS_INLINE_DENTRY)
1284                 set_inode_flag(fi, FI_INLINE_DENTRY);
1285         if (ri->i_inline & F2FS_DATA_EXIST)
1286                 set_inode_flag(fi, FI_DATA_EXIST);
1287         if (ri->i_inline & F2FS_INLINE_DOTS)
1288                 set_inode_flag(fi, FI_INLINE_DOTS);
1289 }
1290
1291 static inline void set_raw_inline(struct f2fs_inode_info *fi,
1292                                         struct f2fs_inode *ri)
1293 {
1294         ri->i_inline = 0;
1295
1296         if (is_inode_flag_set(fi, FI_INLINE_XATTR))
1297                 ri->i_inline |= F2FS_INLINE_XATTR;
1298         if (is_inode_flag_set(fi, FI_INLINE_DATA))
1299                 ri->i_inline |= F2FS_INLINE_DATA;
1300         if (is_inode_flag_set(fi, FI_INLINE_DENTRY))
1301                 ri->i_inline |= F2FS_INLINE_DENTRY;
1302         if (is_inode_flag_set(fi, FI_DATA_EXIST))
1303                 ri->i_inline |= F2FS_DATA_EXIST;
1304         if (is_inode_flag_set(fi, FI_INLINE_DOTS))
1305                 ri->i_inline |= F2FS_INLINE_DOTS;
1306 }
1307
1308 static inline int f2fs_has_inline_xattr(struct inode *inode)
1309 {
1310         return is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR);
1311 }
1312
1313 static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi)
1314 {
1315         if (f2fs_has_inline_xattr(&fi->vfs_inode))
1316                 return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
1317         return DEF_ADDRS_PER_INODE;
1318 }
1319
1320 static inline void *inline_xattr_addr(struct page *page)
1321 {
1322         struct f2fs_inode *ri = F2FS_INODE(page);
1323         return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
1324                                         F2FS_INLINE_XATTR_ADDRS]);
1325 }
1326
1327 static inline int inline_xattr_size(struct inode *inode)
1328 {
1329         if (f2fs_has_inline_xattr(inode))
1330                 return F2FS_INLINE_XATTR_ADDRS << 2;
1331         else
1332                 return 0;
1333 }
1334
1335 static inline int f2fs_has_inline_data(struct inode *inode)
1336 {
1337         return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA);
1338 }
1339
1340 static inline void f2fs_clear_inline_inode(struct inode *inode)
1341 {
1342         clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
1343         clear_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
1344 }
1345
1346 static inline int f2fs_exist_data(struct inode *inode)
1347 {
1348         return is_inode_flag_set(F2FS_I(inode), FI_DATA_EXIST);
1349 }
1350
1351 static inline int f2fs_has_inline_dots(struct inode *inode)
1352 {
1353         return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DOTS);
1354 }
1355
1356 static inline bool f2fs_is_atomic_file(struct inode *inode)
1357 {
1358         return is_inode_flag_set(F2FS_I(inode), FI_ATOMIC_FILE);
1359 }
1360
1361 static inline bool f2fs_is_volatile_file(struct inode *inode)
1362 {
1363         return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE);
1364 }
1365
1366 static inline bool f2fs_is_first_block_written(struct inode *inode)
1367 {
1368         return is_inode_flag_set(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);
1369 }
1370
1371 static inline bool f2fs_is_drop_cache(struct inode *inode)
1372 {
1373         return is_inode_flag_set(F2FS_I(inode), FI_DROP_CACHE);
1374 }
1375
1376 static inline void *inline_data_addr(struct page *page)
1377 {
1378         struct f2fs_inode *ri = F2FS_INODE(page);
1379         return (void *)&(ri->i_addr[1]);
1380 }
1381
1382 static inline int f2fs_has_inline_dentry(struct inode *inode)
1383 {
1384         return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DENTRY);
1385 }
1386
1387 static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page)
1388 {
1389         if (!f2fs_has_inline_dentry(dir))
1390                 kunmap(page);
1391 }
1392
1393 static inline int f2fs_readonly(struct super_block *sb)
1394 {
1395         return sb->s_flags & MS_RDONLY;
1396 }
1397
1398 static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
1399 {
1400         return is_set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
1401 }
1402
1403 static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi)
1404 {
1405         set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
1406         sbi->sb->s_flags |= MS_RDONLY;
1407 }
1408
1409 #define get_inode_mode(i) \
1410         ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \
1411          (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
1412
1413 /* get offset of first page in next direct node */
1414 #define PGOFS_OF_NEXT_DNODE(pgofs, fi)                          \
1415         ((pgofs < ADDRS_PER_INODE(fi)) ? ADDRS_PER_INODE(fi) :  \
1416         (pgofs - ADDRS_PER_INODE(fi) + ADDRS_PER_BLOCK) /       \
1417         ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(fi))
1418
1419 /*
1420  * file.c
1421  */
1422 int f2fs_sync_file(struct file *, loff_t, loff_t, int);
1423 void truncate_data_blocks(struct dnode_of_data *);
1424 int truncate_blocks(struct inode *, u64, bool);
1425 void f2fs_truncate(struct inode *);
1426 int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
1427 int f2fs_setattr(struct dentry *, struct iattr *);
1428 int truncate_hole(struct inode *, pgoff_t, pgoff_t);
1429 int truncate_data_blocks_range(struct dnode_of_data *, int);
1430 long f2fs_ioctl(struct file *, unsigned int, unsigned long);
1431 long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
1432
1433 /*
1434  * inode.c
1435  */
1436 void f2fs_set_inode_flags(struct inode *);
1437 struct inode *f2fs_iget(struct super_block *, unsigned long);
1438 int try_to_free_nats(struct f2fs_sb_info *, int);
1439 void update_inode(struct inode *, struct page *);
1440 void update_inode_page(struct inode *);
1441 int f2fs_write_inode(struct inode *, struct writeback_control *);
1442 void f2fs_evict_inode(struct inode *);
1443 void handle_failed_inode(struct inode *);
1444
1445 /*
1446  * namei.c
1447  */
1448 struct dentry *f2fs_get_parent(struct dentry *child);
1449
1450 /*
1451  * dir.c
1452  */
1453 extern unsigned char f2fs_filetype_table[F2FS_FT_MAX];
1454 void set_de_type(struct f2fs_dir_entry *, umode_t);
1455 struct f2fs_dir_entry *find_target_dentry(struct qstr *, int *,
1456                         struct f2fs_dentry_ptr *);
1457 bool f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *,
1458                         unsigned int);
1459 void do_make_empty_dir(struct inode *, struct inode *,
1460                         struct f2fs_dentry_ptr *);
1461 struct page *init_inode_metadata(struct inode *, struct inode *,
1462                         const struct qstr *, struct page *);
1463 void update_parent_metadata(struct inode *, struct inode *, unsigned int);
1464 int room_for_filename(const void *, int, int);
1465 void f2fs_drop_nlink(struct inode *, struct inode *, struct page *);
1466 struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *,
1467                                                         struct page **);
1468 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
1469 ino_t f2fs_inode_by_name(struct inode *, struct qstr *);
1470 void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
1471                                 struct page *, struct inode *);
1472 int update_dent_inode(struct inode *, const struct qstr *);
1473 void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *,
1474                         const struct qstr *, f2fs_hash_t , unsigned int);
1475 int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *, nid_t,
1476                         umode_t);
1477 void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *,
1478                                                         struct inode *);
1479 int f2fs_do_tmpfile(struct inode *, struct inode *);
1480 int f2fs_make_empty(struct inode *, struct inode *);
1481 bool f2fs_empty_dir(struct inode *);
1482
1483 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
1484 {
1485         return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name,
1486                                 inode, inode->i_ino, inode->i_mode);
1487 }
1488
1489 /*
1490  * super.c
1491  */
1492 int f2fs_sync_fs(struct super_block *, int);
1493 extern __printf(3, 4)
1494 void f2fs_msg(struct super_block *, const char *, const char *, ...);
1495
1496 /*
1497  * hash.c
1498  */
1499 f2fs_hash_t f2fs_dentry_hash(const struct qstr *);
1500
1501 /*
1502  * node.c
1503  */
1504 struct dnode_of_data;
1505 struct node_info;
1506
1507 bool available_free_memory(struct f2fs_sb_info *, int);
1508 bool is_checkpointed_node(struct f2fs_sb_info *, nid_t);
1509 bool has_fsynced_inode(struct f2fs_sb_info *, nid_t);
1510 bool need_inode_block_update(struct f2fs_sb_info *, nid_t);
1511 void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
1512 int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int);
1513 int truncate_inode_blocks(struct inode *, pgoff_t);
1514 int truncate_xattr_node(struct inode *, struct page *);
1515 int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t);
1516 void remove_inode_page(struct inode *);
1517 struct page *new_inode_page(struct inode *);
1518 struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
1519 void ra_node_page(struct f2fs_sb_info *, nid_t);
1520 struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
1521 struct page *get_node_page_ra(struct page *, int);
1522 void sync_inode_page(struct dnode_of_data *);
1523 int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *);
1524 bool alloc_nid(struct f2fs_sb_info *, nid_t *);
1525 void alloc_nid_done(struct f2fs_sb_info *, nid_t);
1526 void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
1527 void recover_inline_xattr(struct inode *, struct page *);
1528 void recover_xattr_data(struct inode *, struct page *, block_t);
1529 int recover_inode_page(struct f2fs_sb_info *, struct page *);
1530 int restore_node_summary(struct f2fs_sb_info *, unsigned int,
1531                                 struct f2fs_summary_block *);
1532 void flush_nat_entries(struct f2fs_sb_info *);
1533 int build_node_manager(struct f2fs_sb_info *);
1534 void destroy_node_manager(struct f2fs_sb_info *);
1535 int __init create_node_manager_caches(void);
1536 void destroy_node_manager_caches(void);
1537
1538 /*
1539  * segment.c
1540  */
1541 void register_inmem_page(struct inode *, struct page *);
1542 void commit_inmem_pages(struct inode *, bool);
1543 void f2fs_balance_fs(struct f2fs_sb_info *);
1544 void f2fs_balance_fs_bg(struct f2fs_sb_info *);
1545 int f2fs_issue_flush(struct f2fs_sb_info *);
1546 int create_flush_cmd_control(struct f2fs_sb_info *);
1547 void destroy_flush_cmd_control(struct f2fs_sb_info *);
1548 void invalidate_blocks(struct f2fs_sb_info *, block_t);
1549 void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t);
1550 void clear_prefree_segments(struct f2fs_sb_info *);
1551 void release_discard_addrs(struct f2fs_sb_info *);
1552 void discard_next_dnode(struct f2fs_sb_info *, block_t);
1553 int npages_for_summary_flush(struct f2fs_sb_info *, bool);
1554 void allocate_new_segments(struct f2fs_sb_info *);
1555 int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *);
1556 struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
1557 void write_meta_page(struct f2fs_sb_info *, struct page *);
1558 void write_node_page(struct f2fs_sb_info *, struct page *,
1559                                 unsigned int, struct f2fs_io_info *);
1560 void write_data_page(struct page *, struct dnode_of_data *,
1561                         struct f2fs_io_info *);
1562 void rewrite_data_page(struct page *, struct f2fs_io_info *);
1563 void recover_data_page(struct f2fs_sb_info *, struct page *,
1564                                 struct f2fs_summary *, block_t, block_t);
1565 void allocate_data_block(struct f2fs_sb_info *, struct page *,
1566                 block_t, block_t *, struct f2fs_summary *, int);
1567 void f2fs_wait_on_page_writeback(struct page *, enum page_type);
1568 void write_data_summaries(struct f2fs_sb_info *, block_t);
1569 void write_node_summaries(struct f2fs_sb_info *, block_t);
1570 int lookup_journal_in_cursum(struct f2fs_summary_block *,
1571                                         int, unsigned int, int);
1572 void flush_sit_entries(struct f2fs_sb_info *, struct cp_control *);
1573 int build_segment_manager(struct f2fs_sb_info *);
1574 void destroy_segment_manager(struct f2fs_sb_info *);
1575 int __init create_segment_manager_caches(void);
1576 void destroy_segment_manager_caches(void);
1577
1578 /*
1579  * checkpoint.c
1580  */
1581 struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
1582 struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
1583 int ra_meta_pages(struct f2fs_sb_info *, block_t, int, int);
1584 void ra_meta_pages_cond(struct f2fs_sb_info *, pgoff_t);
1585 long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
1586 void add_dirty_inode(struct f2fs_sb_info *, nid_t, int type);
1587 void remove_dirty_inode(struct f2fs_sb_info *, nid_t, int type);
1588 void release_dirty_inode(struct f2fs_sb_info *);
1589 bool exist_written_data(struct f2fs_sb_info *, nid_t, int);
1590 int acquire_orphan_inode(struct f2fs_sb_info *);
1591 void release_orphan_inode(struct f2fs_sb_info *);
1592 void add_orphan_inode(struct f2fs_sb_info *, nid_t);
1593 void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
1594 void recover_orphan_inodes(struct f2fs_sb_info *);
1595 int get_valid_checkpoint(struct f2fs_sb_info *);
1596 void update_dirty_page(struct inode *, struct page *);
1597 void add_dirty_dir_inode(struct inode *);
1598 void remove_dirty_dir_inode(struct inode *);
1599 void sync_dirty_dir_inodes(struct f2fs_sb_info *);
1600 void write_checkpoint(struct f2fs_sb_info *, struct cp_control *);
1601 void init_ino_entry_info(struct f2fs_sb_info *);
1602 int __init create_checkpoint_caches(void);
1603 void destroy_checkpoint_caches(void);
1604
1605 /*
1606  * data.c
1607  */
1608 void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int);
1609 int f2fs_submit_page_bio(struct f2fs_sb_info *, struct page *,
1610                                                 struct f2fs_io_info *);
1611 void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *,
1612                                                 struct f2fs_io_info *);
1613 void set_data_blkaddr(struct dnode_of_data *);
1614 int reserve_new_block(struct dnode_of_data *);
1615 int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
1616 void f2fs_shrink_extent_tree(struct f2fs_sb_info *, int);
1617 void f2fs_destroy_extent_tree(struct inode *);
1618 void f2fs_init_extent_cache(struct inode *, struct f2fs_extent *);
1619 void f2fs_update_extent_cache(struct dnode_of_data *);
1620 void f2fs_preserve_extent_tree(struct inode *);
1621 struct page *find_data_page(struct inode *, pgoff_t, bool);
1622 struct page *get_lock_data_page(struct inode *, pgoff_t);
1623 struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
1624 int do_write_data_page(struct page *, struct f2fs_io_info *);
1625 int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);
1626 void init_extent_cache_info(struct f2fs_sb_info *);
1627 int __init create_extent_cache(void);
1628 void destroy_extent_cache(void);
1629 void f2fs_invalidate_page(struct page *, unsigned int, unsigned int);
1630 int f2fs_release_page(struct page *, gfp_t);
1631
1632 /*
1633  * gc.c
1634  */
1635 int start_gc_thread(struct f2fs_sb_info *);
1636 void stop_gc_thread(struct f2fs_sb_info *);
1637 block_t start_bidx_of_node(unsigned int, struct f2fs_inode_info *);
1638 int f2fs_gc(struct f2fs_sb_info *);
1639 void build_gc_manager(struct f2fs_sb_info *);
1640
1641 /*
1642  * recovery.c
1643  */
1644 int recover_fsync_data(struct f2fs_sb_info *);
1645 bool space_for_roll_forward(struct f2fs_sb_info *);
1646
1647 /*
1648  * debug.c
1649  */
1650 #ifdef CONFIG_F2FS_STAT_FS
1651 struct f2fs_stat_info {
1652         struct list_head stat_list;
1653         struct f2fs_sb_info *sbi;
1654         int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
1655         int main_area_segs, main_area_sections, main_area_zones;
1656         int hit_ext, total_ext, ext_tree, ext_node;
1657         int ndirty_node, ndirty_dent, ndirty_dirs, ndirty_meta;
1658         int nats, dirty_nats, sits, dirty_sits, fnids;
1659         int total_count, utilization;
1660         int bg_gc, inline_inode, inline_dir, inmem_pages, wb_pages;
1661         unsigned int valid_count, valid_node_count, valid_inode_count;
1662         unsigned int bimodal, avg_vblocks;
1663         int util_free, util_valid, util_invalid;
1664         int rsvd_segs, overp_segs;
1665         int dirty_count, node_pages, meta_pages;
1666         int prefree_count, call_count, cp_count;
1667         int tot_segs, node_segs, data_segs, free_segs, free_secs;
1668         int bg_node_segs, bg_data_segs;
1669         int tot_blks, data_blks, node_blks;
1670         int bg_data_blks, bg_node_blks;
1671         int curseg[NR_CURSEG_TYPE];
1672         int cursec[NR_CURSEG_TYPE];
1673         int curzone[NR_CURSEG_TYPE];
1674
1675         unsigned int segment_count[2];
1676         unsigned int block_count[2];
1677         unsigned int inplace_count;
1678         unsigned base_mem, cache_mem, page_mem;
1679 };
1680
1681 static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
1682 {
1683         return (struct f2fs_stat_info *)sbi->stat_info;
1684 }
1685
1686 #define stat_inc_cp_count(si)           ((si)->cp_count++)
1687 #define stat_inc_call_count(si)         ((si)->call_count++)
1688 #define stat_inc_bggc_count(sbi)        ((sbi)->bg_gc++)
1689 #define stat_inc_dirty_dir(sbi)         ((sbi)->n_dirty_dirs++)
1690 #define stat_dec_dirty_dir(sbi)         ((sbi)->n_dirty_dirs--)
1691 #define stat_inc_total_hit(sb)          ((F2FS_SB(sb))->total_hit_ext++)
1692 #define stat_inc_read_hit(sb)           ((F2FS_SB(sb))->read_hit_ext++)
1693 #define stat_inc_inline_inode(inode)                                    \
1694         do {                                                            \
1695                 if (f2fs_has_inline_data(inode))                        \
1696                         (atomic_inc(&F2FS_I_SB(inode)->inline_inode));  \
1697         } while (0)
1698 #define stat_dec_inline_inode(inode)                                    \
1699         do {                                                            \
1700                 if (f2fs_has_inline_data(inode))                        \
1701                         (atomic_dec(&F2FS_I_SB(inode)->inline_inode));  \
1702         } while (0)
1703 #define stat_inc_inline_dir(inode)                                      \
1704         do {                                                            \
1705                 if (f2fs_has_inline_dentry(inode))                      \
1706                         (atomic_inc(&F2FS_I_SB(inode)->inline_dir));    \
1707         } while (0)
1708 #define stat_dec_inline_dir(inode)                                      \
1709         do {                                                            \
1710                 if (f2fs_has_inline_dentry(inode))                      \
1711                         (atomic_dec(&F2FS_I_SB(inode)->inline_dir));    \
1712         } while (0)
1713 #define stat_inc_seg_type(sbi, curseg)                                  \
1714                 ((sbi)->segment_count[(curseg)->alloc_type]++)
1715 #define stat_inc_block_count(sbi, curseg)                               \
1716                 ((sbi)->block_count[(curseg)->alloc_type]++)
1717 #define stat_inc_inplace_blocks(sbi)                                    \
1718                 (atomic_inc(&(sbi)->inplace_count))
1719 #define stat_inc_seg_count(sbi, type, gc_type)                          \
1720         do {                                                            \
1721                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
1722                 (si)->tot_segs++;                                       \
1723                 if (type == SUM_TYPE_DATA) {                            \
1724                         si->data_segs++;                                \
1725                         si->bg_data_segs += (gc_type == BG_GC) ? 1 : 0; \
1726                 } else {                                                \
1727                         si->node_segs++;                                \
1728                         si->bg_node_segs += (gc_type == BG_GC) ? 1 : 0; \
1729                 }                                                       \
1730         } while (0)
1731
1732 #define stat_inc_tot_blk_count(si, blks)                                \
1733         (si->tot_blks += (blks))
1734
1735 #define stat_inc_data_blk_count(sbi, blks, gc_type)                     \
1736         do {                                                            \
1737                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
1738                 stat_inc_tot_blk_count(si, blks);                       \
1739                 si->data_blks += (blks);                                \
1740                 si->bg_data_blks += (gc_type == BG_GC) ? (blks) : 0;    \
1741         } while (0)
1742
1743 #define stat_inc_node_blk_count(sbi, blks, gc_type)                     \
1744         do {                                                            \
1745                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
1746                 stat_inc_tot_blk_count(si, blks);                       \
1747                 si->node_blks += (blks);                                \
1748                 si->bg_node_blks += (gc_type == BG_GC) ? (blks) : 0;    \
1749         } while (0)
1750
1751 int f2fs_build_stats(struct f2fs_sb_info *);
1752 void f2fs_destroy_stats(struct f2fs_sb_info *);
1753 void __init f2fs_create_root_stats(void);
1754 void f2fs_destroy_root_stats(void);
1755 #else
1756 #define stat_inc_cp_count(si)
1757 #define stat_inc_call_count(si)
1758 #define stat_inc_bggc_count(si)
1759 #define stat_inc_dirty_dir(sbi)
1760 #define stat_dec_dirty_dir(sbi)
1761 #define stat_inc_total_hit(sb)
1762 #define stat_inc_read_hit(sb)
1763 #define stat_inc_inline_inode(inode)
1764 #define stat_dec_inline_inode(inode)
1765 #define stat_inc_inline_dir(inode)
1766 #define stat_dec_inline_dir(inode)
1767 #define stat_inc_seg_type(sbi, curseg)
1768 #define stat_inc_block_count(sbi, curseg)
1769 #define stat_inc_inplace_blocks(sbi)
1770 #define stat_inc_seg_count(sbi, type, gc_type)
1771 #define stat_inc_tot_blk_count(si, blks)
1772 #define stat_inc_data_blk_count(sbi, blks, gc_type)
1773 #define stat_inc_node_blk_count(sbi, blks, gc_type)
1774
1775 static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
1776 static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
1777 static inline void __init f2fs_create_root_stats(void) { }
1778 static inline void f2fs_destroy_root_stats(void) { }
1779 #endif
1780
1781 extern const struct file_operations f2fs_dir_operations;
1782 extern const struct file_operations f2fs_file_operations;
1783 extern const struct inode_operations f2fs_file_inode_operations;
1784 extern const struct address_space_operations f2fs_dblock_aops;
1785 extern const struct address_space_operations f2fs_node_aops;
1786 extern const struct address_space_operations f2fs_meta_aops;
1787 extern const struct inode_operations f2fs_dir_inode_operations;
1788 extern const struct inode_operations f2fs_symlink_inode_operations;
1789 extern const struct inode_operations f2fs_special_inode_operations;
1790 extern struct kmem_cache *inode_entry_slab;
1791
1792 /*
1793  * inline.c
1794  */
1795 bool f2fs_may_inline(struct inode *);
1796 void read_inline_data(struct page *, struct page *);
1797 bool truncate_inline_inode(struct page *, u64);
1798 int f2fs_read_inline_data(struct inode *, struct page *);
1799 int f2fs_convert_inline_page(struct dnode_of_data *, struct page *);
1800 int f2fs_convert_inline_inode(struct inode *);
1801 int f2fs_write_inline_data(struct inode *, struct page *);
1802 bool recover_inline_data(struct inode *, struct page *);
1803 struct f2fs_dir_entry *find_in_inline_dir(struct inode *, struct qstr *,
1804                                                         struct page **);
1805 struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *, struct page **);
1806 int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
1807 int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *,
1808                                                 nid_t, umode_t);
1809 void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *,
1810                                                 struct inode *, struct inode *);
1811 bool f2fs_empty_inline_dir(struct inode *);
1812 int f2fs_read_inline_dir(struct file *, struct dir_context *);
1813 #endif