f2fs: adjust free mem size to flush dentry blocks
[linux-3.10.git] / 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(condition)  BUG_ON(condition)
25 #define f2fs_down_write(x, y)   down_write_nest_lock(x, y)
26 #else
27 #define f2fs_bug_on(condition)
28 #define f2fs_down_write(x, y)   down_write(x)
29 #endif
30
31 /*
32  * For mount options
33  */
34 #define F2FS_MOUNT_BG_GC                0x00000001
35 #define F2FS_MOUNT_DISABLE_ROLL_FORWARD 0x00000002
36 #define F2FS_MOUNT_DISCARD              0x00000004
37 #define F2FS_MOUNT_NOHEAP               0x00000008
38 #define F2FS_MOUNT_XATTR_USER           0x00000010
39 #define F2FS_MOUNT_POSIX_ACL            0x00000020
40 #define F2FS_MOUNT_DISABLE_EXT_IDENTIFY 0x00000040
41 #define F2FS_MOUNT_INLINE_XATTR         0x00000080
42 #define F2FS_MOUNT_INLINE_DATA          0x00000100
43 #define F2FS_MOUNT_FLUSH_MERGE          0x00000200
44 #define F2FS_MOUNT_ANDROID_EMU          0x00001000
45 #define F2FS_MOUNT_ERRORS_PANIC         0x00002000
46 #define F2FS_MOUNT_ERRORS_RECOVER       0x00004000
47
48 #define clear_opt(sbi, option)  (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
49 #define set_opt(sbi, option)    (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
50 #define test_opt(sbi, option)   (sbi->mount_opt.opt & F2FS_MOUNT_##option)
51
52 #define ver_after(a, b) (typecheck(unsigned long long, a) &&            \
53                 typecheck(unsigned long long, b) &&                     \
54                 ((long long)((a) - (b)) > 0))
55
56 typedef u32 block_t;    /*
57                          * should not change u32, since it is the on-disk block
58                          * address format, __le32.
59                          */
60 typedef u32 nid_t;
61
62 struct f2fs_mount_info {
63         unsigned int    opt;
64 };
65
66 #define CRCPOLY_LE 0xedb88320
67
68 static inline __u32 f2fs_crc32(void *buf, size_t len)
69 {
70         unsigned char *p = (unsigned char *)buf;
71         __u32 crc = F2FS_SUPER_MAGIC;
72         int i;
73
74         while (len--) {
75                 crc ^= *p++;
76                 for (i = 0; i < 8; i++)
77                         crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
78         }
79         return crc;
80 }
81
82 static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size)
83 {
84         return f2fs_crc32(buf, buf_size) == blk_crc;
85 }
86
87 /*
88  * For checkpoint manager
89  */
90 enum {
91         NAT_BITMAP,
92         SIT_BITMAP
93 };
94
95 /*
96  * For CP/NAT/SIT/SSA readahead
97  */
98 enum {
99         META_CP,
100         META_NAT,
101         META_SIT,
102         META_SSA
103 };
104
105 /* for the list of orphan inodes */
106 struct orphan_inode_entry {
107         struct list_head list;  /* list head */
108         nid_t ino;              /* inode number */
109 };
110
111 /* for the list of directory inodes */
112 struct dir_inode_entry {
113         struct list_head list;  /* list head */
114         struct inode *inode;    /* vfs inode pointer */
115 };
116
117 /* for the list of blockaddresses to be discarded */
118 struct discard_entry {
119         struct list_head list;  /* list head */
120         block_t blkaddr;        /* block address to be discarded */
121         int len;                /* # of consecutive blocks of the discard */
122 };
123
124 /* for the list of fsync inodes, used only during recovery */
125 struct fsync_inode_entry {
126         struct list_head list;  /* list head */
127         struct inode *inode;    /* vfs inode pointer */
128         block_t blkaddr;        /* block address locating the last inode */
129 };
130
131 #define nats_in_cursum(sum)             (le16_to_cpu(sum->n_nats))
132 #define sits_in_cursum(sum)             (le16_to_cpu(sum->n_sits))
133
134 #define nat_in_journal(sum, i)          (sum->nat_j.entries[i].ne)
135 #define nid_in_journal(sum, i)          (sum->nat_j.entries[i].nid)
136 #define sit_in_journal(sum, i)          (sum->sit_j.entries[i].se)
137 #define segno_in_journal(sum, i)        (sum->sit_j.entries[i].segno)
138
139 static inline int update_nats_in_cursum(struct f2fs_summary_block *rs, int i)
140 {
141         int before = nats_in_cursum(rs);
142         rs->n_nats = cpu_to_le16(before + i);
143         return before;
144 }
145
146 static inline int update_sits_in_cursum(struct f2fs_summary_block *rs, int i)
147 {
148         int before = sits_in_cursum(rs);
149         rs->n_sits = cpu_to_le16(before + i);
150         return before;
151 }
152
153 /*
154  * ioctl commands
155  */
156 #define F2FS_IOC_GETFLAGS               FS_IOC_GETFLAGS
157 #define F2FS_IOC_SETFLAGS               FS_IOC_SETFLAGS
158
159 #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
160 /*
161  * ioctl commands in 32 bit emulation
162  */
163 #define F2FS_IOC32_GETFLAGS             FS_IOC32_GETFLAGS
164 #define F2FS_IOC32_SETFLAGS             FS_IOC32_SETFLAGS
165 #endif
166
167 /*
168  * For INODE and NODE manager
169  */
170 /*
171  * XATTR_NODE_OFFSET stores xattrs to one node block per file keeping -1
172  * as its node offset to distinguish from index node blocks.
173  * But some bits are used to mark the node block.
174  */
175 #define XATTR_NODE_OFFSET       ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
176                                 >> OFFSET_BIT_SHIFT)
177 enum {
178         ALLOC_NODE,                     /* allocate a new node page if needed */
179         LOOKUP_NODE,                    /* look up a node without readahead */
180         LOOKUP_NODE_RA,                 /*
181                                          * look up a node with readahead called
182                                          * by get_data_block.
183                                          */
184 };
185
186 #define F2FS_LINK_MAX           32000   /* maximum link count per file */
187
188 /* for in-memory extent cache entry */
189 #define F2FS_MIN_EXTENT_LEN     16      /* minimum extent length */
190
191 struct extent_info {
192         rwlock_t ext_lock;      /* rwlock for consistency */
193         unsigned int fofs;      /* start offset in a file */
194         u32 blk_addr;           /* start block address of the extent */
195         unsigned int len;       /* length of the extent */
196 };
197
198 /*
199  * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
200  */
201 #define FADVISE_COLD_BIT        0x01
202 #define FADVISE_LOST_PINO_BIT   0x02
203 #define FADVISE_ANDROID_EMU     0x10
204 #define FADVISE_ANDROID_EMU_ROOT 0x20
205
206 #define DEF_DIR_LEVEL           0
207
208 struct f2fs_inode_info {
209         struct inode vfs_inode;         /* serve a vfs inode */
210         unsigned long i_flags;          /* keep an inode flags for ioctl */
211         unsigned char i_advise;         /* use to give file attribute hints */
212         unsigned char i_dir_level;      /* use for dentry level for large dir */
213         unsigned int i_current_depth;   /* use only in directory structure */
214         unsigned int i_pino;            /* parent inode number */
215         umode_t i_acl_mode;             /* keep file acl mode temporarily */
216
217         /* Use below internally in f2fs*/
218         unsigned long flags;            /* use to pass per-file flags */
219         struct rw_semaphore i_sem;      /* protect fi info */
220         atomic_t dirty_dents;           /* # of dirty dentry pages */
221         f2fs_hash_t chash;              /* hash value of given file name */
222         unsigned int clevel;            /* maximum level of given file name */
223         nid_t i_xattr_nid;              /* node id that contains xattrs */
224         unsigned long long xattr_ver;   /* cp version of xattr modification */
225         struct extent_info ext;         /* in-memory extent cache entry */
226         struct dir_inode_entry *dirty_dir;      /* the pointer of dirty dir */
227 };
228
229 static inline void get_extent_info(struct extent_info *ext,
230                                         struct f2fs_extent i_ext)
231 {
232         write_lock(&ext->ext_lock);
233         ext->fofs = le32_to_cpu(i_ext.fofs);
234         ext->blk_addr = le32_to_cpu(i_ext.blk_addr);
235         ext->len = le32_to_cpu(i_ext.len);
236         write_unlock(&ext->ext_lock);
237 }
238
239 static inline void set_raw_extent(struct extent_info *ext,
240                                         struct f2fs_extent *i_ext)
241 {
242         read_lock(&ext->ext_lock);
243         i_ext->fofs = cpu_to_le32(ext->fofs);
244         i_ext->blk_addr = cpu_to_le32(ext->blk_addr);
245         i_ext->len = cpu_to_le32(ext->len);
246         read_unlock(&ext->ext_lock);
247 }
248
249 struct f2fs_nm_info {
250         block_t nat_blkaddr;            /* base disk address of NAT */
251         nid_t max_nid;                  /* maximum possible node ids */
252         nid_t available_nids;           /* maximum available node ids */
253         nid_t next_scan_nid;            /* the next nid to be scanned */
254         unsigned int ram_thresh;        /* control the memory footprint */
255
256         /* NAT cache management */
257         struct radix_tree_root nat_root;/* root of the nat entry cache */
258         rwlock_t nat_tree_lock;         /* protect nat_tree_lock */
259         unsigned int nat_cnt;           /* the # of cached nat entries */
260         struct list_head nat_entries;   /* cached nat entry list (clean) */
261         struct list_head dirty_nat_entries; /* cached nat entry list (dirty) */
262
263         /* free node ids management */
264         struct radix_tree_root free_nid_root;/* root of the free_nid cache */
265         struct list_head free_nid_list; /* a list for free nids */
266         spinlock_t free_nid_list_lock;  /* protect free nid list */
267         unsigned int fcnt;              /* the number of free node id */
268         struct mutex build_lock;        /* lock for build free nids */
269
270         /* for checkpoint */
271         char *nat_bitmap;               /* NAT bitmap pointer */
272         int bitmap_size;                /* bitmap size */
273 };
274
275 /*
276  * this structure is used as one of function parameters.
277  * all the information are dedicated to a given direct node block determined
278  * by the data offset in a file.
279  */
280 struct dnode_of_data {
281         struct inode *inode;            /* vfs inode pointer */
282         struct page *inode_page;        /* its inode page, NULL is possible */
283         struct page *node_page;         /* cached direct node page */
284         nid_t nid;                      /* node id of the direct node block */
285         unsigned int ofs_in_node;       /* data offset in the node page */
286         bool inode_page_locked;         /* inode page is locked or not */
287         block_t data_blkaddr;           /* block address of the node block */
288 };
289
290 static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
291                 struct page *ipage, struct page *npage, nid_t nid)
292 {
293         memset(dn, 0, sizeof(*dn));
294         dn->inode = inode;
295         dn->inode_page = ipage;
296         dn->node_page = npage;
297         dn->nid = nid;
298 }
299
300 /*
301  * For SIT manager
302  *
303  * By default, there are 6 active log areas across the whole main area.
304  * When considering hot and cold data separation to reduce cleaning overhead,
305  * we split 3 for data logs and 3 for node logs as hot, warm, and cold types,
306  * respectively.
307  * In the current design, you should not change the numbers intentionally.
308  * Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6
309  * logs individually according to the underlying devices. (default: 6)
310  * Just in case, on-disk layout covers maximum 16 logs that consist of 8 for
311  * data and 8 for node logs.
312  */
313 #define NR_CURSEG_DATA_TYPE     (3)
314 #define NR_CURSEG_NODE_TYPE     (3)
315 #define NR_CURSEG_TYPE  (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
316
317 enum {
318         CURSEG_HOT_DATA = 0,    /* directory entry blocks */
319         CURSEG_WARM_DATA,       /* data blocks */
320         CURSEG_COLD_DATA,       /* multimedia or GCed data blocks */
321         CURSEG_HOT_NODE,        /* direct node blocks of directory files */
322         CURSEG_WARM_NODE,       /* direct node blocks of normal files */
323         CURSEG_COLD_NODE,       /* indirect node blocks */
324         NO_CHECK_TYPE
325 };
326
327 struct flush_cmd {
328         struct flush_cmd *next;
329         struct completion wait;
330         int ret;
331 };
332
333 struct f2fs_sm_info {
334         struct sit_info *sit_info;              /* whole segment information */
335         struct free_segmap_info *free_info;     /* free segment information */
336         struct dirty_seglist_info *dirty_info;  /* dirty segment information */
337         struct curseg_info *curseg_array;       /* active segment information */
338
339         struct list_head wblist_head;   /* list of under-writeback pages */
340         spinlock_t wblist_lock;         /* lock for checkpoint */
341
342         block_t seg0_blkaddr;           /* block address of 0'th segment */
343         block_t main_blkaddr;           /* start block address of main area */
344         block_t ssa_blkaddr;            /* start block address of SSA area */
345
346         unsigned int segment_count;     /* total # of segments */
347         unsigned int main_segments;     /* # of segments in main area */
348         unsigned int reserved_segments; /* # of reserved segments */
349         unsigned int ovp_segments;      /* # of overprovision segments */
350
351         /* a threshold to reclaim prefree segments */
352         unsigned int rec_prefree_segments;
353
354         /* for small discard management */
355         struct list_head discard_list;          /* 4KB discard list */
356         int nr_discards;                        /* # of discards in the list */
357         int max_discards;                       /* max. discards to be issued */
358
359         unsigned int ipu_policy;        /* in-place-update policy */
360         unsigned int min_ipu_util;      /* in-place-update threshold */
361
362         /* for flush command control */
363         struct task_struct *f2fs_issue_flush;   /* flush thread */
364         wait_queue_head_t flush_wait_queue;     /* waiting queue for wake-up */
365         struct flush_cmd *issue_list;           /* list for command issue */
366         struct flush_cmd *dispatch_list;        /* list for command dispatch */
367         spinlock_t issue_lock;                  /* for issue list lock */
368         struct flush_cmd *issue_tail;           /* list tail of issue list */
369 };
370
371 /*
372  * For superblock
373  */
374 /*
375  * COUNT_TYPE for monitoring
376  *
377  * f2fs monitors the number of several block types such as on-writeback,
378  * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
379  */
380 enum count_type {
381         F2FS_WRITEBACK,
382         F2FS_DIRTY_DENTS,
383         F2FS_DIRTY_NODES,
384         F2FS_DIRTY_META,
385         NR_COUNT_TYPE,
386 };
387
388 /*
389  * The below are the page types of bios used in submti_bio().
390  * The available types are:
391  * DATA                 User data pages. It operates as async mode.
392  * NODE                 Node pages. It operates as async mode.
393  * META                 FS metadata pages such as SIT, NAT, CP.
394  * NR_PAGE_TYPE         The number of page types.
395  * META_FLUSH           Make sure the previous pages are written
396  *                      with waiting the bio's completion
397  * ...                  Only can be used with META.
398  */
399 #define PAGE_TYPE_OF_BIO(type)  ((type) > META ? META : (type))
400 enum page_type {
401         DATA,
402         NODE,
403         META,
404         NR_PAGE_TYPE,
405         META_FLUSH,
406 };
407
408 /*
409  * Android sdcard emulation flags
410  */
411 #define F2FS_ANDROID_EMU_NOCASE         0x00000001
412
413 struct f2fs_io_info {
414         enum page_type type;    /* contains DATA/NODE/META/META_FLUSH */
415         int rw;                 /* contains R/RS/W/WS with REQ_META/REQ_PRIO */
416 };
417
418 #define is_read_io(rw)  (((rw) & 1) == READ)
419 struct f2fs_bio_info {
420         struct f2fs_sb_info *sbi;       /* f2fs superblock */
421         struct bio *bio;                /* bios to merge */
422         sector_t last_block_in_bio;     /* last block number */
423         struct f2fs_io_info fio;        /* store buffered io info. */
424         struct rw_semaphore io_rwsem;   /* blocking op for bio */
425 };
426
427 struct f2fs_sb_info {
428         struct super_block *sb;                 /* pointer to VFS super block */
429         struct proc_dir_entry *s_proc;          /* proc entry */
430         struct buffer_head *raw_super_buf;      /* buffer head of raw sb */
431         struct f2fs_super_block *raw_super;     /* raw super block pointer */
432         int s_dirty;                            /* dirty flag for checkpoint */
433
434         /* for node-related operations */
435         struct f2fs_nm_info *nm_info;           /* node manager */
436         struct inode *node_inode;               /* cache node blocks */
437
438         /* for segment-related operations */
439         struct f2fs_sm_info *sm_info;           /* segment manager */
440
441         /* for bio operations */
442         struct f2fs_bio_info read_io;                   /* for read bios */
443         struct f2fs_bio_info write_io[NR_PAGE_TYPE];    /* for write bios */
444         struct completion *wait_io;             /* for completion bios */
445
446         /* for checkpoint */
447         struct f2fs_checkpoint *ckpt;           /* raw checkpoint pointer */
448         struct inode *meta_inode;               /* cache meta blocks */
449         struct mutex cp_mutex;                  /* checkpoint procedure lock */
450         struct rw_semaphore cp_rwsem;           /* blocking FS operations */
451         struct mutex node_write;                /* locking node writes */
452         struct mutex writepages;                /* mutex for writepages() */
453         bool por_doing;                         /* recovery is doing or not */
454         wait_queue_head_t cp_wait;
455
456         /* for orphan inode management */
457         struct list_head orphan_inode_list;     /* orphan inode list */
458         spinlock_t orphan_inode_lock;           /* for orphan inode list */
459         unsigned int n_orphans;                 /* # of orphan inodes */
460         unsigned int max_orphans;               /* max orphan inodes */
461
462         /* for directory inode management */
463         struct list_head dir_inode_list;        /* dir inode list */
464         spinlock_t dir_inode_lock;              /* for dir inode list lock */
465
466         /* basic file system units */
467         unsigned int log_sectors_per_block;     /* log2 sectors per block */
468         unsigned int log_blocksize;             /* log2 block size */
469         unsigned int blocksize;                 /* block size */
470         unsigned int root_ino_num;              /* root inode number*/
471         unsigned int node_ino_num;              /* node inode number*/
472         unsigned int meta_ino_num;              /* meta inode number*/
473         unsigned int log_blocks_per_seg;        /* log2 blocks per segment */
474         unsigned int blocks_per_seg;            /* blocks per segment */
475         unsigned int segs_per_sec;              /* segments per section */
476         unsigned int secs_per_zone;             /* sections per zone */
477         unsigned int total_sections;            /* total section count */
478         unsigned int total_node_count;          /* total node block count */
479         unsigned int total_valid_node_count;    /* valid node block count */
480         unsigned int total_valid_inode_count;   /* valid inode count */
481         int active_logs;                        /* # of active logs */
482         int dir_level;                          /* directory level */
483
484         block_t user_block_count;               /* # of user blocks */
485         block_t total_valid_block_count;        /* # of valid blocks */
486         block_t alloc_valid_block_count;        /* # of allocated blocks */
487         block_t last_valid_block_count;         /* for recovery */
488         u32 s_next_generation;                  /* for NFS support */
489         atomic_t nr_pages[NR_COUNT_TYPE];       /* # of pages, see count_type */
490
491         struct f2fs_mount_info mount_opt;       /* mount options */
492
493         /* for cleaning operations */
494         struct mutex gc_mutex;                  /* mutex for GC */
495         struct f2fs_gc_kthread  *gc_thread;     /* GC thread */
496         unsigned int cur_victim_sec;            /* current victim section num */
497
498         /* maximum # of trials to find a victim segment for SSR and GC */
499         unsigned int max_victim_search;
500
501         /*
502          * for stat information.
503          * one is for the LFS mode, and the other is for the SSR mode.
504          */
505 #ifdef CONFIG_F2FS_STAT_FS
506         struct f2fs_stat_info *stat_info;       /* FS status information */
507         unsigned int segment_count[2];          /* # of allocated segments */
508         unsigned int block_count[2];            /* # of allocated blocks */
509         int total_hit_ext, read_hit_ext;        /* extent cache hit ratio */
510         int inline_inode;                       /* # of inline_data inodes */
511         int bg_gc;                              /* background gc calls */
512         unsigned int n_dirty_dirs;              /* # of dir inodes */
513 #endif
514         unsigned int last_victim[2];            /* last victim segment # */
515         spinlock_t stat_lock;                   /* lock for stat operations */
516
517         /* For sysfs suppport */
518         struct kobject s_kobj;
519         struct completion s_kobj_unregister;
520
521         /* For Android sdcard emulation */
522         u32 android_emu_uid;
523         u32 android_emu_gid;
524         umode_t android_emu_mode;
525         int android_emu_flags;
526 };
527
528 /*
529  * Inline functions
530  */
531 static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
532 {
533         return container_of(inode, struct f2fs_inode_info, vfs_inode);
534 }
535
536 static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
537 {
538         return sb->s_fs_info;
539 }
540
541 static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
542 {
543         return (struct f2fs_super_block *)(sbi->raw_super);
544 }
545
546 static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
547 {
548         return (struct f2fs_checkpoint *)(sbi->ckpt);
549 }
550
551 static inline struct f2fs_node *F2FS_NODE(struct page *page)
552 {
553         return (struct f2fs_node *)page_address(page);
554 }
555
556 static inline struct f2fs_inode *F2FS_INODE(struct page *page)
557 {
558         return &((struct f2fs_node *)page_address(page))->i;
559 }
560
561 static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
562 {
563         return (struct f2fs_nm_info *)(sbi->nm_info);
564 }
565
566 static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
567 {
568         return (struct f2fs_sm_info *)(sbi->sm_info);
569 }
570
571 static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
572 {
573         return (struct sit_info *)(SM_I(sbi)->sit_info);
574 }
575
576 static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
577 {
578         return (struct free_segmap_info *)(SM_I(sbi)->free_info);
579 }
580
581 static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
582 {
583         return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
584 }
585
586 static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
587 {
588         return sbi->meta_inode->i_mapping;
589 }
590
591 static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
592 {
593         return sbi->node_inode->i_mapping;
594 }
595
596 static inline void F2FS_SET_SB_DIRT(struct f2fs_sb_info *sbi)
597 {
598         sbi->s_dirty = 1;
599 }
600
601 static inline void F2FS_RESET_SB_DIRT(struct f2fs_sb_info *sbi)
602 {
603         sbi->s_dirty = 0;
604 }
605
606 static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
607 {
608         return le64_to_cpu(cp->checkpoint_ver);
609 }
610
611 static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
612 {
613         unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
614         return ckpt_flags & f;
615 }
616
617 static inline void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
618 {
619         unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
620         ckpt_flags |= f;
621         cp->ckpt_flags = cpu_to_le32(ckpt_flags);
622 }
623
624 static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
625 {
626         unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
627         ckpt_flags &= (~f);
628         cp->ckpt_flags = cpu_to_le32(ckpt_flags);
629 }
630
631 static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
632 {
633         down_read(&sbi->cp_rwsem);
634 }
635
636 static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
637 {
638         up_read(&sbi->cp_rwsem);
639 }
640
641 static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
642 {
643         f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex);
644 }
645
646 static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
647 {
648         up_write(&sbi->cp_rwsem);
649 }
650
651 /*
652  * Check whether the given nid is within node id range.
653  */
654 static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
655 {
656         WARN_ON((nid >= NM_I(sbi)->max_nid));
657         if (unlikely(nid >= NM_I(sbi)->max_nid))
658                 return -EINVAL;
659         return 0;
660 }
661
662 #define F2FS_DEFAULT_ALLOCATED_BLOCKS   1
663
664 /*
665  * Check whether the inode has blocks or not
666  */
667 static inline int F2FS_HAS_BLOCKS(struct inode *inode)
668 {
669         if (F2FS_I(inode)->i_xattr_nid)
670                 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
671         else
672                 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
673 }
674
675 static inline int f2fs_handle_error(struct f2fs_sb_info *sbi)
676 {
677         if (test_opt(sbi, ERRORS_PANIC))
678                 BUG();
679         if (test_opt(sbi, ERRORS_RECOVER))
680                 return 1;
681         return 0;
682 }
683
684 static inline bool f2fs_has_xattr_block(unsigned int ofs)
685 {
686         return ofs == XATTR_NODE_OFFSET;
687 }
688
689 static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
690                                  struct inode *inode, blkcnt_t count)
691 {
692         block_t valid_block_count;
693
694         spin_lock(&sbi->stat_lock);
695         valid_block_count =
696                 sbi->total_valid_block_count + (block_t)count;
697         if (unlikely(valid_block_count > sbi->user_block_count)) {
698                 spin_unlock(&sbi->stat_lock);
699                 return false;
700         }
701         inode->i_blocks += count;
702         sbi->total_valid_block_count = valid_block_count;
703         sbi->alloc_valid_block_count += (block_t)count;
704         spin_unlock(&sbi->stat_lock);
705         return true;
706 }
707
708 static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
709                                                 struct inode *inode,
710                                                 blkcnt_t count)
711 {
712         spin_lock(&sbi->stat_lock);
713
714         if (sbi->total_valid_block_count < (block_t)count) {
715                 pr_crit("F2FS-fs (%s): block accounting error: %u < %llu\n",
716                         sbi->sb->s_id, sbi->total_valid_block_count,
717                         (unsigned long long)count);
718                 f2fs_handle_error(sbi);
719                 sbi->total_valid_block_count = count;
720         }
721         if (inode->i_blocks < count) {
722                 pr_crit("F2FS-fs (%s): inode accounting error: %llu < %llu\n",
723                         sbi->sb->s_id, (unsigned long long)inode->i_blocks,
724                         (unsigned long long)count);
725                 f2fs_handle_error(sbi);
726                 inode->i_blocks = count;
727         }
728
729         inode->i_blocks -= count;
730         sbi->total_valid_block_count -= (block_t)count;
731         spin_unlock(&sbi->stat_lock);
732 }
733
734 static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
735 {
736         atomic_inc(&sbi->nr_pages[count_type]);
737         F2FS_SET_SB_DIRT(sbi);
738 }
739
740 static inline void inode_inc_dirty_dents(struct inode *inode)
741 {
742         inc_page_count(F2FS_SB(inode->i_sb), F2FS_DIRTY_DENTS);
743         atomic_inc(&F2FS_I(inode)->dirty_dents);
744 }
745
746 static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
747 {
748         atomic_dec(&sbi->nr_pages[count_type]);
749 }
750
751 static inline void inode_dec_dirty_dents(struct inode *inode)
752 {
753         if (!S_ISDIR(inode->i_mode))
754                 return;
755
756         dec_page_count(F2FS_SB(inode->i_sb), F2FS_DIRTY_DENTS);
757         atomic_dec(&F2FS_I(inode)->dirty_dents);
758 }
759
760 static inline int get_pages(struct f2fs_sb_info *sbi, int count_type)
761 {
762         return atomic_read(&sbi->nr_pages[count_type]);
763 }
764
765 static inline int get_dirty_dents(struct inode *inode)
766 {
767         return atomic_read(&F2FS_I(inode)->dirty_dents);
768 }
769
770 static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
771 {
772         unsigned int pages_per_sec = sbi->segs_per_sec *
773                                         (1 << sbi->log_blocks_per_seg);
774         return ((get_pages(sbi, block_type) + pages_per_sec - 1)
775                         >> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
776 }
777
778 static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
779 {
780         return sbi->total_valid_block_count;
781 }
782
783 static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
784 {
785         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
786
787         /* return NAT or SIT bitmap */
788         if (flag == NAT_BITMAP)
789                 return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
790         else if (flag == SIT_BITMAP)
791                 return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
792
793         return 0;
794 }
795
796 static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
797 {
798         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
799         int offset = (flag == NAT_BITMAP) ?
800                         le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
801         return &ckpt->sit_nat_version_bitmap + offset;
802 }
803
804 static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
805 {
806         block_t start_addr;
807         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
808         unsigned long long ckpt_version = cur_cp_version(ckpt);
809
810         start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
811
812         /*
813          * odd numbered checkpoint should at cp segment 0
814          * and even segent must be at cp segment 1
815          */
816         if (!(ckpt_version & 1))
817                 start_addr += sbi->blocks_per_seg;
818
819         return start_addr;
820 }
821
822 static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
823 {
824         return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
825 }
826
827 static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi,
828                                                 struct inode *inode)
829 {
830         block_t valid_block_count;
831         unsigned int valid_node_count;
832
833         spin_lock(&sbi->stat_lock);
834
835         valid_block_count = sbi->total_valid_block_count + 1;
836         if (unlikely(valid_block_count > sbi->user_block_count)) {
837                 spin_unlock(&sbi->stat_lock);
838                 return false;
839         }
840
841         valid_node_count = sbi->total_valid_node_count + 1;
842         if (unlikely(valid_node_count > sbi->total_node_count)) {
843                 spin_unlock(&sbi->stat_lock);
844                 return false;
845         }
846
847         if (inode)
848                 inode->i_blocks++;
849
850         sbi->alloc_valid_block_count++;
851         sbi->total_valid_node_count++;
852         sbi->total_valid_block_count++;
853         spin_unlock(&sbi->stat_lock);
854
855         return true;
856 }
857
858 static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
859                                                 struct inode *inode)
860 {
861         spin_lock(&sbi->stat_lock);
862
863         if (sbi->total_valid_block_count < 1) {
864                 pr_crit("F2FS-fs (%s): block accounting error: %llu < 1\n",
865                         sbi->sb->s_id,
866                         (unsigned long long)sbi->total_valid_block_count);
867                 f2fs_handle_error(sbi);
868                 sbi->total_valid_block_count = 1;
869         }
870         if (sbi->total_valid_node_count < 1) {
871                 pr_crit("F2FS-fs (%s): node accounting error: %u < 1\n",
872                         sbi->sb->s_id, sbi->total_valid_node_count);
873                 f2fs_handle_error(sbi);
874                 sbi->total_valid_node_count = 1;
875         }
876         if (inode->i_blocks < 1) {
877                 pr_crit("F2FS-fs (%s): inode accounting error: %llu < 1\n",
878                         sbi->sb->s_id, (unsigned long long)inode->i_blocks);
879                 f2fs_handle_error(sbi);
880                 inode->i_blocks = 1;
881         }
882
883         inode->i_blocks--;
884         sbi->total_valid_node_count--;
885         sbi->total_valid_block_count--;
886
887         spin_unlock(&sbi->stat_lock);
888 }
889
890 static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
891 {
892         return sbi->total_valid_node_count;
893 }
894
895 static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
896 {
897         spin_lock(&sbi->stat_lock);
898         f2fs_bug_on(sbi->total_valid_inode_count == sbi->total_node_count);
899         sbi->total_valid_inode_count++;
900         spin_unlock(&sbi->stat_lock);
901 }
902
903 static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
904 {
905         spin_lock(&sbi->stat_lock);
906         f2fs_bug_on(!sbi->total_valid_inode_count);
907         sbi->total_valid_inode_count--;
908         spin_unlock(&sbi->stat_lock);
909 }
910
911 static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi)
912 {
913         return sbi->total_valid_inode_count;
914 }
915
916 static inline void f2fs_put_page(struct page *page, int unlock)
917 {
918         if (!page)
919                 return;
920
921         if (unlock) {
922                 f2fs_bug_on(!PageLocked(page));
923                 unlock_page(page);
924         }
925         page_cache_release(page);
926 }
927
928 static inline void f2fs_put_dnode(struct dnode_of_data *dn)
929 {
930         if (dn->node_page)
931                 f2fs_put_page(dn->node_page, 1);
932         if (dn->inode_page && dn->node_page != dn->inode_page)
933                 f2fs_put_page(dn->inode_page, 0);
934         dn->node_page = NULL;
935         dn->inode_page = NULL;
936 }
937
938 static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
939                                         size_t size)
940 {
941         return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
942 }
943
944 static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep,
945                                                 gfp_t flags)
946 {
947         void *entry;
948 retry:
949         entry = kmem_cache_alloc(cachep, flags);
950         if (!entry) {
951                 cond_resched();
952                 goto retry;
953         }
954
955         return entry;
956 }
957
958 #define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
959
960 static inline bool IS_INODE(struct page *page)
961 {
962         struct f2fs_node *p = F2FS_NODE(page);
963         return RAW_IS_INODE(p);
964 }
965
966 static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
967 {
968         return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
969 }
970
971 static inline block_t datablock_addr(struct page *node_page,
972                 unsigned int offset)
973 {
974         struct f2fs_node *raw_node;
975         __le32 *addr_array;
976         raw_node = F2FS_NODE(node_page);
977         addr_array = blkaddr_in_node(raw_node);
978         return le32_to_cpu(addr_array[offset]);
979 }
980
981 static inline int f2fs_test_bit(unsigned int nr, char *addr)
982 {
983         int mask;
984
985         addr += (nr >> 3);
986         mask = 1 << (7 - (nr & 0x07));
987         return mask & *addr;
988 }
989
990 static inline int f2fs_set_bit(unsigned int nr, char *addr)
991 {
992         int mask;
993         int ret;
994
995         addr += (nr >> 3);
996         mask = 1 << (7 - (nr & 0x07));
997         ret = mask & *addr;
998         *addr |= mask;
999         return ret;
1000 }
1001
1002 static inline int f2fs_clear_bit(unsigned int nr, char *addr)
1003 {
1004         int mask;
1005         int ret;
1006
1007         addr += (nr >> 3);
1008         mask = 1 << (7 - (nr & 0x07));
1009         ret = mask & *addr;
1010         *addr &= ~mask;
1011         return ret;
1012 }
1013
1014 /* used for f2fs_inode_info->flags */
1015 enum {
1016         FI_NEW_INODE,           /* indicate newly allocated inode */
1017         FI_DIRTY_INODE,         /* indicate inode is dirty or not */
1018         FI_DIRTY_DIR,           /* indicate directory has dirty pages */
1019         FI_INC_LINK,            /* need to increment i_nlink */
1020         FI_ACL_MODE,            /* indicate acl mode */
1021         FI_NO_ALLOC,            /* should not allocate any blocks */
1022         FI_UPDATE_DIR,          /* should update inode block for consistency */
1023         FI_DELAY_IPUT,          /* used for the recovery */
1024         FI_NO_EXTENT,           /* not to use the extent cache */
1025         FI_INLINE_XATTR,        /* used for inline xattr */
1026         FI_INLINE_DATA,         /* used for inline data*/
1027 };
1028
1029 static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
1030 {
1031         set_bit(flag, &fi->flags);
1032 }
1033
1034 static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag)
1035 {
1036         return test_bit(flag, &fi->flags);
1037 }
1038
1039 static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag)
1040 {
1041         clear_bit(flag, &fi->flags);
1042 }
1043
1044 static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode)
1045 {
1046         fi->i_acl_mode = mode;
1047         set_inode_flag(fi, FI_ACL_MODE);
1048 }
1049
1050 static inline int cond_clear_inode_flag(struct f2fs_inode_info *fi, int flag)
1051 {
1052         if (is_inode_flag_set(fi, FI_ACL_MODE)) {
1053                 clear_inode_flag(fi, FI_ACL_MODE);
1054                 return 1;
1055         }
1056         return 0;
1057 }
1058
1059 int f2fs_android_emu(struct f2fs_sb_info *, struct inode *, u32 *, u32 *,
1060                 umode_t *);
1061
1062 #define IS_ANDROID_EMU(sbi, fi, pfi)                                    \
1063         (test_opt((sbi), ANDROID_EMU) &&                                \
1064          (((fi)->i_advise & FADVISE_ANDROID_EMU) ||                     \
1065           ((pfi)->i_advise & FADVISE_ANDROID_EMU)))
1066
1067 static inline void get_inline_info(struct f2fs_inode_info *fi,
1068                                         struct f2fs_inode *ri)
1069 {
1070         if (ri->i_inline & F2FS_INLINE_XATTR)
1071                 set_inode_flag(fi, FI_INLINE_XATTR);
1072         if (ri->i_inline & F2FS_INLINE_DATA)
1073                 set_inode_flag(fi, FI_INLINE_DATA);
1074 }
1075
1076 static inline void set_raw_inline(struct f2fs_inode_info *fi,
1077                                         struct f2fs_inode *ri)
1078 {
1079         ri->i_inline = 0;
1080
1081         if (is_inode_flag_set(fi, FI_INLINE_XATTR))
1082                 ri->i_inline |= F2FS_INLINE_XATTR;
1083         if (is_inode_flag_set(fi, FI_INLINE_DATA))
1084                 ri->i_inline |= F2FS_INLINE_DATA;
1085 }
1086
1087 static inline int f2fs_has_inline_xattr(struct inode *inode)
1088 {
1089         return is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR);
1090 }
1091
1092 static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi)
1093 {
1094         if (f2fs_has_inline_xattr(&fi->vfs_inode))
1095                 return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
1096         return DEF_ADDRS_PER_INODE;
1097 }
1098
1099 static inline void *inline_xattr_addr(struct page *page)
1100 {
1101         struct f2fs_inode *ri = F2FS_INODE(page);
1102         return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
1103                                         F2FS_INLINE_XATTR_ADDRS]);
1104 }
1105
1106 static inline int inline_xattr_size(struct inode *inode)
1107 {
1108         if (f2fs_has_inline_xattr(inode))
1109                 return F2FS_INLINE_XATTR_ADDRS << 2;
1110         else
1111                 return 0;
1112 }
1113
1114 static inline int f2fs_has_inline_data(struct inode *inode)
1115 {
1116         return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA);
1117 }
1118
1119 static inline void *inline_data_addr(struct page *page)
1120 {
1121         struct f2fs_inode *ri = F2FS_INODE(page);
1122         return (void *)&(ri->i_addr[1]);
1123 }
1124
1125 static inline int f2fs_readonly(struct super_block *sb)
1126 {
1127         return sb->s_flags & MS_RDONLY;
1128 }
1129
1130 static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi)
1131 {
1132         set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
1133         sbi->sb->s_flags |= MS_RDONLY;
1134 }
1135
1136 #define get_inode_mode(i) \
1137         ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \
1138          (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
1139
1140 /*
1141  * file.c
1142  */
1143 int f2fs_sync_file(struct file *, loff_t, loff_t, int);
1144 void truncate_data_blocks(struct dnode_of_data *);
1145 int truncate_blocks(struct inode *, u64);
1146 void f2fs_truncate(struct inode *);
1147 int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
1148 int f2fs_setattr(struct dentry *, struct iattr *);
1149 int truncate_hole(struct inode *, pgoff_t, pgoff_t);
1150 int truncate_data_blocks_range(struct dnode_of_data *, int);
1151 long f2fs_ioctl(struct file *, unsigned int, unsigned long);
1152 long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
1153
1154 /*
1155  * inode.c
1156  */
1157 void f2fs_set_inode_flags(struct inode *);
1158 struct inode *f2fs_iget(struct super_block *, unsigned long);
1159 int try_to_free_nats(struct f2fs_sb_info *, int);
1160 void update_inode(struct inode *, struct page *);
1161 void update_inode_page(struct inode *);
1162 int f2fs_write_inode(struct inode *, struct writeback_control *);
1163 void f2fs_evict_inode(struct inode *);
1164
1165 /*
1166  * namei.c
1167  */
1168 struct dentry *f2fs_get_parent(struct dentry *child);
1169
1170 /*
1171  * dir.c
1172  */
1173 struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *,
1174                                                         struct page **);
1175 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
1176 ino_t f2fs_inode_by_name(struct inode *, struct qstr *);
1177 void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
1178                                 struct page *, struct inode *);
1179 int update_dent_inode(struct inode *, const struct qstr *);
1180 int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *);
1181 void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *);
1182 int f2fs_make_empty(struct inode *, struct inode *);
1183 bool f2fs_empty_dir(struct inode *);
1184
1185 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
1186 {
1187         return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name,
1188                                 inode);
1189 }
1190
1191 /*
1192  * super.c
1193  */
1194 int f2fs_sync_fs(struct super_block *, int);
1195 extern __printf(3, 4)
1196 void f2fs_msg(struct super_block *, const char *, const char *, ...);
1197
1198 /*
1199  * hash.c
1200  */
1201 f2fs_hash_t f2fs_dentry_hash(const char *, size_t);
1202
1203 /*
1204  * node.c
1205  */
1206 struct dnode_of_data;
1207 struct node_info;
1208
1209 bool available_free_memory(struct f2fs_sb_info *, int);
1210 int is_checkpointed_node(struct f2fs_sb_info *, nid_t);
1211 bool fsync_mark_done(struct f2fs_sb_info *, nid_t);
1212 void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
1213 int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int);
1214 int truncate_inode_blocks(struct inode *, pgoff_t);
1215 int truncate_xattr_node(struct inode *, struct page *);
1216 int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t);
1217 void remove_inode_page(struct inode *);
1218 struct page *new_inode_page(struct inode *, const struct qstr *);
1219 struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
1220 void ra_node_page(struct f2fs_sb_info *, nid_t);
1221 struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
1222 struct page *get_node_page_ra(struct page *, int);
1223 void sync_inode_page(struct dnode_of_data *);
1224 int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *);
1225 bool alloc_nid(struct f2fs_sb_info *, nid_t *);
1226 void alloc_nid_done(struct f2fs_sb_info *, nid_t);
1227 void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
1228 void recover_node_page(struct f2fs_sb_info *, struct page *,
1229                 struct f2fs_summary *, struct node_info *, block_t);
1230 bool recover_xattr_data(struct inode *, struct page *, block_t);
1231 int recover_inode_page(struct f2fs_sb_info *, struct page *);
1232 int restore_node_summary(struct f2fs_sb_info *, unsigned int,
1233                                 struct f2fs_summary_block *);
1234 void flush_nat_entries(struct f2fs_sb_info *);
1235 int build_node_manager(struct f2fs_sb_info *);
1236 void destroy_node_manager(struct f2fs_sb_info *);
1237 int __init create_node_manager_caches(void);
1238 void destroy_node_manager_caches(void);
1239
1240 /*
1241  * segment.c
1242  */
1243 void f2fs_balance_fs(struct f2fs_sb_info *);
1244 void f2fs_balance_fs_bg(struct f2fs_sb_info *);
1245 int issue_flush_thread(void *);
1246 int f2fs_issue_flush(struct f2fs_sb_info *);
1247 void invalidate_blocks(struct f2fs_sb_info *, block_t);
1248 void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t);
1249 void clear_prefree_segments(struct f2fs_sb_info *);
1250 void discard_next_dnode(struct f2fs_sb_info *);
1251 int npages_for_summary_flush(struct f2fs_sb_info *);
1252 void allocate_new_segments(struct f2fs_sb_info *);
1253 struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
1254 void write_meta_page(struct f2fs_sb_info *, struct page *);
1255 void write_node_page(struct f2fs_sb_info *, struct page *,
1256                 struct f2fs_io_info *, unsigned int, block_t, block_t *);
1257 void write_data_page(struct page *, struct dnode_of_data *, block_t *,
1258                                         struct f2fs_io_info *);
1259 void rewrite_data_page(struct page *, block_t, struct f2fs_io_info *);
1260 void recover_data_page(struct f2fs_sb_info *, struct page *,
1261                                 struct f2fs_summary *, block_t, block_t);
1262 void rewrite_node_page(struct f2fs_sb_info *, struct page *,
1263                                 struct f2fs_summary *, block_t, block_t);
1264 void allocate_data_block(struct f2fs_sb_info *, struct page *,
1265                 block_t, block_t *, struct f2fs_summary *, int);
1266 void f2fs_wait_on_page_writeback(struct page *, enum page_type);
1267 void write_data_summaries(struct f2fs_sb_info *, block_t);
1268 void write_node_summaries(struct f2fs_sb_info *, block_t);
1269 int lookup_journal_in_cursum(struct f2fs_summary_block *,
1270                                         int, unsigned int, int);
1271 void flush_sit_entries(struct f2fs_sb_info *);
1272 int build_segment_manager(struct f2fs_sb_info *);
1273 void destroy_segment_manager(struct f2fs_sb_info *);
1274 int __init create_segment_manager_caches(void);
1275 void destroy_segment_manager_caches(void);
1276
1277 /*
1278  * checkpoint.c
1279  */
1280 struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
1281 struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
1282 int ra_meta_pages(struct f2fs_sb_info *, int, int, int);
1283 long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
1284 int acquire_orphan_inode(struct f2fs_sb_info *);
1285 void release_orphan_inode(struct f2fs_sb_info *);
1286 void add_orphan_inode(struct f2fs_sb_info *, nid_t);
1287 void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
1288 void recover_orphan_inodes(struct f2fs_sb_info *);
1289 int get_valid_checkpoint(struct f2fs_sb_info *);
1290 void set_dirty_dir_page(struct inode *, struct page *);
1291 void add_dirty_dir_inode(struct inode *);
1292 void remove_dirty_dir_inode(struct inode *);
1293 void sync_dirty_dir_inodes(struct f2fs_sb_info *);
1294 void write_checkpoint(struct f2fs_sb_info *, bool);
1295 void init_orphan_info(struct f2fs_sb_info *);
1296 int __init create_checkpoint_caches(void);
1297 void destroy_checkpoint_caches(void);
1298
1299 /*
1300  * data.c
1301  */
1302 void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int);
1303 int f2fs_submit_page_bio(struct f2fs_sb_info *, struct page *, block_t, int);
1304 void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *, block_t,
1305                                                 struct f2fs_io_info *);
1306 int reserve_new_block(struct dnode_of_data *);
1307 int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
1308 void update_extent_cache(block_t, struct dnode_of_data *);
1309 struct page *find_data_page(struct inode *, pgoff_t, bool);
1310 struct page *get_lock_data_page(struct inode *, pgoff_t);
1311 struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
1312 int do_write_data_page(struct page *, struct f2fs_io_info *);
1313
1314 /*
1315  * gc.c
1316  */
1317 int start_gc_thread(struct f2fs_sb_info *);
1318 void stop_gc_thread(struct f2fs_sb_info *);
1319 block_t start_bidx_of_node(unsigned int, struct f2fs_inode_info *);
1320 int f2fs_gc(struct f2fs_sb_info *);
1321 void build_gc_manager(struct f2fs_sb_info *);
1322 int __init create_gc_caches(void);
1323 void destroy_gc_caches(void);
1324
1325 /*
1326  * recovery.c
1327  */
1328 int recover_fsync_data(struct f2fs_sb_info *);
1329 bool space_for_roll_forward(struct f2fs_sb_info *);
1330
1331 /*
1332  * debug.c
1333  */
1334 #ifdef CONFIG_F2FS_STAT_FS
1335 struct f2fs_stat_info {
1336         struct list_head stat_list;
1337         struct f2fs_sb_info *sbi;
1338         struct mutex stat_lock;
1339         int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
1340         int main_area_segs, main_area_sections, main_area_zones;
1341         int hit_ext, total_ext;
1342         int ndirty_node, ndirty_dent, ndirty_dirs, ndirty_meta;
1343         int nats, sits, fnids;
1344         int total_count, utilization;
1345         int bg_gc, inline_inode;
1346         unsigned int valid_count, valid_node_count, valid_inode_count;
1347         unsigned int bimodal, avg_vblocks;
1348         int util_free, util_valid, util_invalid;
1349         int rsvd_segs, overp_segs;
1350         int dirty_count, node_pages, meta_pages;
1351         int prefree_count, call_count, cp_count;
1352         int tot_segs, node_segs, data_segs, free_segs, free_secs;
1353         int tot_blks, data_blks, node_blks;
1354         int curseg[NR_CURSEG_TYPE];
1355         int cursec[NR_CURSEG_TYPE];
1356         int curzone[NR_CURSEG_TYPE];
1357
1358         unsigned int segment_count[2];
1359         unsigned int block_count[2];
1360         unsigned base_mem, cache_mem;
1361 };
1362
1363 static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
1364 {
1365         return (struct f2fs_stat_info *)sbi->stat_info;
1366 }
1367
1368 #define stat_inc_cp_count(si)           ((si)->cp_count++)
1369 #define stat_inc_call_count(si)         ((si)->call_count++)
1370 #define stat_inc_bggc_count(sbi)        ((sbi)->bg_gc++)
1371 #define stat_inc_dirty_dir(sbi)         ((sbi)->n_dirty_dirs++)
1372 #define stat_dec_dirty_dir(sbi)         ((sbi)->n_dirty_dirs--)
1373 #define stat_inc_total_hit(sb)          ((F2FS_SB(sb))->total_hit_ext++)
1374 #define stat_inc_read_hit(sb)           ((F2FS_SB(sb))->read_hit_ext++)
1375 #define stat_inc_inline_inode(inode)                                    \
1376         do {                                                            \
1377                 if (f2fs_has_inline_data(inode))                        \
1378                         ((F2FS_SB(inode->i_sb))->inline_inode++);       \
1379         } while (0)
1380 #define stat_dec_inline_inode(inode)                                    \
1381         do {                                                            \
1382                 if (f2fs_has_inline_data(inode))                        \
1383                         ((F2FS_SB(inode->i_sb))->inline_inode--);       \
1384         } while (0)
1385
1386 #define stat_inc_seg_type(sbi, curseg)                                  \
1387                 ((sbi)->segment_count[(curseg)->alloc_type]++)
1388 #define stat_inc_block_count(sbi, curseg)                               \
1389                 ((sbi)->block_count[(curseg)->alloc_type]++)
1390
1391 #define stat_inc_seg_count(sbi, type)                                   \
1392         do {                                                            \
1393                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
1394                 (si)->tot_segs++;                                       \
1395                 if (type == SUM_TYPE_DATA)                              \
1396                         si->data_segs++;                                \
1397                 else                                                    \
1398                         si->node_segs++;                                \
1399         } while (0)
1400
1401 #define stat_inc_tot_blk_count(si, blks)                                \
1402         (si->tot_blks += (blks))
1403
1404 #define stat_inc_data_blk_count(sbi, blks)                              \
1405         do {                                                            \
1406                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
1407                 stat_inc_tot_blk_count(si, blks);                       \
1408                 si->data_blks += (blks);                                \
1409         } while (0)
1410
1411 #define stat_inc_node_blk_count(sbi, blks)                              \
1412         do {                                                            \
1413                 struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
1414                 stat_inc_tot_blk_count(si, blks);                       \
1415                 si->node_blks += (blks);                                \
1416         } while (0)
1417
1418 int f2fs_build_stats(struct f2fs_sb_info *);
1419 void f2fs_destroy_stats(struct f2fs_sb_info *);
1420 void __init f2fs_create_root_stats(void);
1421 void f2fs_destroy_root_stats(void);
1422 #else
1423 #define stat_inc_cp_count(si)
1424 #define stat_inc_call_count(si)
1425 #define stat_inc_bggc_count(si)
1426 #define stat_inc_dirty_dir(sbi)
1427 #define stat_dec_dirty_dir(sbi)
1428 #define stat_inc_total_hit(sb)
1429 #define stat_inc_read_hit(sb)
1430 #define stat_inc_inline_inode(inode)
1431 #define stat_dec_inline_inode(inode)
1432 #define stat_inc_seg_type(sbi, curseg)
1433 #define stat_inc_block_count(sbi, curseg)
1434 #define stat_inc_seg_count(si, type)
1435 #define stat_inc_tot_blk_count(si, blks)
1436 #define stat_inc_data_blk_count(si, blks)
1437 #define stat_inc_node_blk_count(sbi, blks)
1438
1439 static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
1440 static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
1441 static inline void __init f2fs_create_root_stats(void) { }
1442 static inline void f2fs_destroy_root_stats(void) { }
1443 #endif
1444
1445 extern const struct file_operations f2fs_dir_operations;
1446 extern const struct file_operations f2fs_file_operations;
1447 extern const struct inode_operations f2fs_file_inode_operations;
1448 extern const struct address_space_operations f2fs_dblock_aops;
1449 extern const struct address_space_operations f2fs_node_aops;
1450 extern const struct address_space_operations f2fs_meta_aops;
1451 extern const struct inode_operations f2fs_dir_inode_operations;
1452 extern const struct inode_operations f2fs_symlink_inode_operations;
1453 extern const struct inode_operations f2fs_special_inode_operations;
1454
1455 /*
1456  * inline.c
1457  */
1458 bool f2fs_may_inline(struct inode *);
1459 int f2fs_read_inline_data(struct inode *, struct page *);
1460 int f2fs_convert_inline_data(struct inode *, pgoff_t);
1461 int f2fs_write_inline_data(struct inode *, struct page *, unsigned int);
1462 int recover_inline_data(struct inode *, struct page *);
1463 #endif