f2fs.h (e98bdb3059cbf2b1cd4261e126b08429f64466c3) f2fs.h (ad4d307fce0909a5f70635826f779321ab95b469)
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

--- 94 unchanged lines hidden (view full) ---

103};
104
105#define F2FS_FEATURE_ENCRYPT 0x0001
106#define F2FS_FEATURE_BLKZONED 0x0002
107
108#define F2FS_HAS_FEATURE(sb, mask) \
109 ((F2FS_SB(sb)->raw_super->feature & cpu_to_le32(mask)) != 0)
110#define F2FS_SET_FEATURE(sb, mask) \
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

--- 94 unchanged lines hidden (view full) ---

103};
104
105#define F2FS_FEATURE_ENCRYPT 0x0001
106#define F2FS_FEATURE_BLKZONED 0x0002
107
108#define F2FS_HAS_FEATURE(sb, mask) \
109 ((F2FS_SB(sb)->raw_super->feature & cpu_to_le32(mask)) != 0)
110#define F2FS_SET_FEATURE(sb, mask) \
111 F2FS_SB(sb)->raw_super->feature |= cpu_to_le32(mask)
111 (F2FS_SB(sb)->raw_super->feature |= cpu_to_le32(mask))
112#define F2FS_CLEAR_FEATURE(sb, mask) \
112#define F2FS_CLEAR_FEATURE(sb, mask) \
113 F2FS_SB(sb)->raw_super->feature &= ~cpu_to_le32(mask)
113 (F2FS_SB(sb)->raw_super->feature &= ~cpu_to_le32(mask))
114
115/*
116 * For checkpoint manager
117 */
118enum {
119 NAT_BITMAP,
120 SIT_BITMAP
121};

--- 6 unchanged lines hidden (view full) ---

128 CP_DISCARD,
129};
130
131#define DEF_BATCHED_TRIM_SECTIONS 2
132#define BATCHED_TRIM_SEGMENTS(sbi) \
133 (SM_I(sbi)->trim_sections * (sbi)->segs_per_sec)
134#define BATCHED_TRIM_BLOCKS(sbi) \
135 (BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
114
115/*
116 * For checkpoint manager
117 */
118enum {
119 NAT_BITMAP,
120 SIT_BITMAP
121};

--- 6 unchanged lines hidden (view full) ---

128 CP_DISCARD,
129};
130
131#define DEF_BATCHED_TRIM_SECTIONS 2
132#define BATCHED_TRIM_SEGMENTS(sbi) \
133 (SM_I(sbi)->trim_sections * (sbi)->segs_per_sec)
134#define BATCHED_TRIM_BLOCKS(sbi) \
135 (BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
136#define MAX_DISCARD_BLOCKS(sbi) \
137 ((1 << (sbi)->log_blocks_per_seg) * (sbi)->segs_per_sec)
138#define DISCARD_ISSUE_RATE 8
136#define DEF_CP_INTERVAL 60 /* 60 secs */
137#define DEF_IDLE_INTERVAL 5 /* 5 secs */
138
139struct cp_control {
140 int reason;
141 __u64 trim_start;
142 __u64 trim_end;
143 __u64 trim_minlen;

--- 32 unchanged lines hidden (view full) ---

176
177/* for the list of blockaddresses to be discarded */
178struct discard_entry {
179 struct list_head list; /* list head */
180 block_t blkaddr; /* block address to be discarded */
181 int len; /* # of consecutive blocks of the discard */
182};
183
139#define DEF_CP_INTERVAL 60 /* 60 secs */
140#define DEF_IDLE_INTERVAL 5 /* 5 secs */
141
142struct cp_control {
143 int reason;
144 __u64 trim_start;
145 __u64 trim_end;
146 __u64 trim_minlen;

--- 32 unchanged lines hidden (view full) ---

179
180/* for the list of blockaddresses to be discarded */
181struct discard_entry {
182 struct list_head list; /* list head */
183 block_t blkaddr; /* block address to be discarded */
184 int len; /* # of consecutive blocks of the discard */
185};
186
184struct bio_entry {
185 struct list_head list;
186 struct bio *bio;
187 struct completion event;
188 int error;
187enum {
188 D_PREP,
189 D_SUBMIT,
190 D_DONE,
189};
190
191};
192
193struct discard_cmd {
194 struct list_head list; /* command list */
195 struct completion wait; /* compleation */
196 block_t lstart; /* logical start address */
197 block_t len; /* length */
198 struct bio *bio; /* bio */
199 int state; /* state */
200};
201
202struct discard_cmd_control {
203 struct task_struct *f2fs_issue_discard; /* discard thread */
204 struct list_head discard_entry_list; /* 4KB discard entry list */
205 int nr_discards; /* # of discards in the list */
206 struct list_head discard_cmd_list; /* discard cmd list */
207 wait_queue_head_t discard_wait_queue; /* waiting queue for wake-up */
208 struct mutex cmd_lock;
209 int max_discards; /* max. discards to be issued */
210 atomic_t submit_discard; /* # of issued discard */
211};
212
191/* for the list of fsync inodes, used only during recovery */
192struct fsync_inode_entry {
193 struct list_head list; /* list head */
194 struct inode *inode; /* vfs inode pointer */
195 block_t blkaddr; /* block address locating the last fsync */
196 block_t last_dentry; /* block address locating the last dentry */
197};
198

--- 6 unchanged lines hidden (view full) ---

205#define segno_in_journal(jnl, i) (jnl->sit_j.entries[i].segno)
206
207#define MAX_NAT_JENTRIES(jnl) (NAT_JOURNAL_ENTRIES - nats_in_cursum(jnl))
208#define MAX_SIT_JENTRIES(jnl) (SIT_JOURNAL_ENTRIES - sits_in_cursum(jnl))
209
210static inline int update_nats_in_cursum(struct f2fs_journal *journal, int i)
211{
212 int before = nats_in_cursum(journal);
213/* for the list of fsync inodes, used only during recovery */
214struct fsync_inode_entry {
215 struct list_head list; /* list head */
216 struct inode *inode; /* vfs inode pointer */
217 block_t blkaddr; /* block address locating the last fsync */
218 block_t last_dentry; /* block address locating the last dentry */
219};
220

--- 6 unchanged lines hidden (view full) ---

227#define segno_in_journal(jnl, i) (jnl->sit_j.entries[i].segno)
228
229#define MAX_NAT_JENTRIES(jnl) (NAT_JOURNAL_ENTRIES - nats_in_cursum(jnl))
230#define MAX_SIT_JENTRIES(jnl) (SIT_JOURNAL_ENTRIES - sits_in_cursum(jnl))
231
232static inline int update_nats_in_cursum(struct f2fs_journal *journal, int i)
233{
234 int before = nats_in_cursum(journal);
235
213 journal->n_nats = cpu_to_le16(before + i);
214 return before;
215}
216
217static inline int update_sits_in_cursum(struct f2fs_journal *journal, int i)
218{
219 int before = sits_in_cursum(journal);
236 journal->n_nats = cpu_to_le16(before + i);
237 return before;
238}
239
240static inline int update_sits_in_cursum(struct f2fs_journal *journal, int i)
241{
242 int before = sits_in_cursum(journal);
243
220 journal->n_sits = cpu_to_le16(before + i);
221 return before;
222}
223
224static inline bool __has_cursum_space(struct f2fs_journal *journal,
225 int size, int type)
226{
227 if (type == NAT_JOURNAL)

--- 69 unchanged lines hidden (view full) ---

297
298static inline void make_dentry_ptr(struct inode *inode,
299 struct f2fs_dentry_ptr *d, void *src, int type)
300{
301 d->inode = inode;
302
303 if (type == 1) {
304 struct f2fs_dentry_block *t = (struct f2fs_dentry_block *)src;
244 journal->n_sits = cpu_to_le16(before + i);
245 return before;
246}
247
248static inline bool __has_cursum_space(struct f2fs_journal *journal,
249 int size, int type)
250{
251 if (type == NAT_JOURNAL)

--- 69 unchanged lines hidden (view full) ---

321
322static inline void make_dentry_ptr(struct inode *inode,
323 struct f2fs_dentry_ptr *d, void *src, int type)
324{
325 d->inode = inode;
326
327 if (type == 1) {
328 struct f2fs_dentry_block *t = (struct f2fs_dentry_block *)src;
329
305 d->max = NR_DENTRY_IN_BLOCK;
306 d->bitmap = &t->dentry_bitmap;
307 d->dentry = t->dentry;
308 d->filename = t->filename;
309 } else {
310 struct f2fs_inline_dentry *t = (struct f2fs_inline_dentry *)src;
330 d->max = NR_DENTRY_IN_BLOCK;
331 d->bitmap = &t->dentry_bitmap;
332 d->dentry = t->dentry;
333 d->filename = t->filename;
334 } else {
335 struct f2fs_inline_dentry *t = (struct f2fs_inline_dentry *)src;
336
311 d->max = NR_INLINE_DENTRY;
312 d->bitmap = &t->dentry_bitmap;
313 d->dentry = t->dentry;
314 d->filename = t->filename;
315 }
316}
317
318/*

--- 110 unchanged lines hidden (view full) ---

429 umode_t i_acl_mode; /* keep file acl mode temporarily */
430
431 /* Use below internally in f2fs*/
432 unsigned long flags; /* use to pass per-file flags */
433 struct rw_semaphore i_sem; /* protect fi info */
434 atomic_t dirty_pages; /* # of dirty pages */
435 f2fs_hash_t chash; /* hash value of given file name */
436 unsigned int clevel; /* maximum level of given file name */
337 d->max = NR_INLINE_DENTRY;
338 d->bitmap = &t->dentry_bitmap;
339 d->dentry = t->dentry;
340 d->filename = t->filename;
341 }
342}
343
344/*

--- 110 unchanged lines hidden (view full) ---

455 umode_t i_acl_mode; /* keep file acl mode temporarily */
456
457 /* Use below internally in f2fs*/
458 unsigned long flags; /* use to pass per-file flags */
459 struct rw_semaphore i_sem; /* protect fi info */
460 atomic_t dirty_pages; /* # of dirty pages */
461 f2fs_hash_t chash; /* hash value of given file name */
462 unsigned int clevel; /* maximum level of given file name */
463 struct task_struct *task; /* lookup and create consistency */
437 nid_t i_xattr_nid; /* node id that contains xattrs */
464 nid_t i_xattr_nid; /* node id that contains xattrs */
438 unsigned long long xattr_ver; /* cp version of xattr modification */
439 loff_t last_disk_size; /* lastly written file size */
440
441 struct list_head dirty_list; /* dirty list for dirs and files */
442 struct list_head gdirty_list; /* linked in global dirty list */
443 struct list_head inmem_pages; /* inmemory pages managed by f2fs */
444 struct mutex inmem_lock; /* lock for inmemory pages */
445 struct extent_tree *extent_tree; /* cached extent_tree entry */
446 struct rw_semaphore dio_rwsem[2];/* avoid racing between dio and gc */

--- 44 unchanged lines hidden (view full) ---

491}
492
493static inline bool __is_front_mergeable(struct extent_info *cur,
494 struct extent_info *front)
495{
496 return __is_extent_mergeable(cur, front);
497}
498
465 loff_t last_disk_size; /* lastly written file size */
466
467 struct list_head dirty_list; /* dirty list for dirs and files */
468 struct list_head gdirty_list; /* linked in global dirty list */
469 struct list_head inmem_pages; /* inmemory pages managed by f2fs */
470 struct mutex inmem_lock; /* lock for inmemory pages */
471 struct extent_tree *extent_tree; /* cached extent_tree entry */
472 struct rw_semaphore dio_rwsem[2];/* avoid racing between dio and gc */

--- 44 unchanged lines hidden (view full) ---

517}
518
519static inline bool __is_front_mergeable(struct extent_info *cur,
520 struct extent_info *front)
521{
522 return __is_extent_mergeable(cur, front);
523}
524
499extern void f2fs_mark_inode_dirty_sync(struct inode *, bool);
525extern void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync);
500static inline void __try_update_largest_extent(struct inode *inode,
501 struct extent_tree *et, struct extent_node *en)
502{
503 if (en->ei.len > et->largest.len) {
504 et->largest = en->ei;
505 f2fs_mark_inode_dirty_sync(inode, true);
506 }
507}

--- 25 unchanged lines hidden (view full) ---

533 struct radix_tree_root free_nid_root;/* root of the free_nid cache */
534 struct list_head nid_list[MAX_NID_LIST];/* lists for free nids */
535 unsigned int nid_cnt[MAX_NID_LIST]; /* the number of free node id */
536 spinlock_t nid_list_lock; /* protect nid lists ops */
537 struct mutex build_lock; /* lock for build free nids */
538
539 /* for checkpoint */
540 char *nat_bitmap; /* NAT bitmap pointer */
526static inline void __try_update_largest_extent(struct inode *inode,
527 struct extent_tree *et, struct extent_node *en)
528{
529 if (en->ei.len > et->largest.len) {
530 et->largest = en->ei;
531 f2fs_mark_inode_dirty_sync(inode, true);
532 }
533}

--- 25 unchanged lines hidden (view full) ---

559 struct radix_tree_root free_nid_root;/* root of the free_nid cache */
560 struct list_head nid_list[MAX_NID_LIST];/* lists for free nids */
561 unsigned int nid_cnt[MAX_NID_LIST]; /* the number of free node id */
562 spinlock_t nid_list_lock; /* protect nid lists ops */
563 struct mutex build_lock; /* lock for build free nids */
564
565 /* for checkpoint */
566 char *nat_bitmap; /* NAT bitmap pointer */
567#ifdef CONFIG_F2FS_CHECK_FS
568 char *nat_bitmap_mir; /* NAT bitmap mirror */
569#endif
541 int bitmap_size; /* bitmap size */
542};
543
544/*
545 * this structure is used as one of function parameters.
546 * all the information are dedicated to a given direct node block determined
547 * by the data offset in a file.
548 */

--- 74 unchanged lines hidden (view full) ---

623 unsigned int segment_count; /* total # of segments */
624 unsigned int main_segments; /* # of segments in main area */
625 unsigned int reserved_segments; /* # of reserved segments */
626 unsigned int ovp_segments; /* # of overprovision segments */
627
628 /* a threshold to reclaim prefree segments */
629 unsigned int rec_prefree_segments;
630
570 int bitmap_size; /* bitmap size */
571};
572
573/*
574 * this structure is used as one of function parameters.
575 * all the information are dedicated to a given direct node block determined
576 * by the data offset in a file.
577 */

--- 74 unchanged lines hidden (view full) ---

652 unsigned int segment_count; /* total # of segments */
653 unsigned int main_segments; /* # of segments in main area */
654 unsigned int reserved_segments; /* # of reserved segments */
655 unsigned int ovp_segments; /* # of overprovision segments */
656
657 /* a threshold to reclaim prefree segments */
658 unsigned int rec_prefree_segments;
659
631 /* for small discard management */
632 struct list_head discard_list; /* 4KB discard list */
633 struct list_head wait_list; /* linked with issued discard bio */
634 int nr_discards; /* # of discards in the list */
635 int max_discards; /* max. discards to be issued */
636
637 /* for batched trimming */
638 unsigned int trim_sections; /* # of sections to trim */
639
640 struct list_head sit_entry_set; /* sit entry set list */
641
642 unsigned int ipu_policy; /* in-place-update policy */
643 unsigned int min_ipu_util; /* in-place-update threshold */
644 unsigned int min_fsync_blocks; /* threshold for fsync */
645
646 /* for flush command control */
660 /* for batched trimming */
661 unsigned int trim_sections; /* # of sections to trim */
662
663 struct list_head sit_entry_set; /* sit entry set list */
664
665 unsigned int ipu_policy; /* in-place-update policy */
666 unsigned int min_ipu_util; /* in-place-update threshold */
667 unsigned int min_fsync_blocks; /* threshold for fsync */
668
669 /* for flush command control */
647 struct flush_cmd_control *cmd_control_info;
670 struct flush_cmd_control *fcc_info;
648
671
672 /* for discard command control */
673 struct discard_cmd_control *dcc_info;
649};
650
651/*
652 * For superblock
653 */
654/*
655 * COUNT_TYPE for monitoring
656 *

--- 42 unchanged lines hidden (view full) ---

699 struct f2fs_sb_info *sbi; /* f2fs_sb_info pointer */
700 enum page_type type; /* contains DATA/NODE/META/META_FLUSH */
701 int op; /* contains REQ_OP_ */
702 int op_flags; /* req_flag_bits */
703 block_t new_blkaddr; /* new block address to be written */
704 block_t old_blkaddr; /* old block address before Cow */
705 struct page *page; /* page to be written */
706 struct page *encrypted_page; /* encrypted page */
674};
675
676/*
677 * For superblock
678 */
679/*
680 * COUNT_TYPE for monitoring
681 *

--- 42 unchanged lines hidden (view full) ---

724 struct f2fs_sb_info *sbi; /* f2fs_sb_info pointer */
725 enum page_type type; /* contains DATA/NODE/META/META_FLUSH */
726 int op; /* contains REQ_OP_ */
727 int op_flags; /* req_flag_bits */
728 block_t new_blkaddr; /* new block address to be written */
729 block_t old_blkaddr; /* old block address before Cow */
730 struct page *page; /* page to be written */
731 struct page *encrypted_page; /* encrypted page */
732 bool submitted; /* indicate IO submission */
707};
708
709#define is_read_io(rw) (rw == READ)
710struct f2fs_bio_info {
711 struct f2fs_sb_info *sbi; /* f2fs superblock */
712 struct bio *bio; /* bios to merge */
713 sector_t last_block_in_bio; /* last block number */
714 struct f2fs_io_info fio; /* store buffered io info. */

--- 72 unchanged lines hidden (view full) ---

787
788 /* for segment-related operations */
789 struct f2fs_sm_info *sm_info; /* segment manager */
790
791 /* for bio operations */
792 struct f2fs_bio_info read_io; /* for read bios */
793 struct f2fs_bio_info write_io[NR_PAGE_TYPE]; /* for write bios */
794 struct mutex wio_mutex[NODE + 1]; /* bio ordering for NODE/DATA */
733};
734
735#define is_read_io(rw) (rw == READ)
736struct f2fs_bio_info {
737 struct f2fs_sb_info *sbi; /* f2fs superblock */
738 struct bio *bio; /* bios to merge */
739 sector_t last_block_in_bio; /* last block number */
740 struct f2fs_io_info fio; /* store buffered io info. */

--- 72 unchanged lines hidden (view full) ---

813
814 /* for segment-related operations */
815 struct f2fs_sm_info *sm_info; /* segment manager */
816
817 /* for bio operations */
818 struct f2fs_bio_info read_io; /* for read bios */
819 struct f2fs_bio_info write_io[NR_PAGE_TYPE]; /* for write bios */
820 struct mutex wio_mutex[NODE + 1]; /* bio ordering for NODE/DATA */
821 int write_io_size_bits; /* Write IO size bits */
822 mempool_t *write_io_dummy; /* Dummy pages */
795
796 /* for checkpoint */
797 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */
798 int cur_cp_pack; /* remain current cp pack */
799 spinlock_t cp_lock; /* for flag in ckpt */
800 struct inode *meta_inode; /* cache meta blocks */
801 struct mutex cp_mutex; /* checkpoint procedure lock */
802 struct rw_semaphore cp_rwsem; /* blocking FS operations */

--- 55 unchanged lines hidden (view full) ---

858
859 struct f2fs_mount_info mount_opt; /* mount options */
860
861 /* for cleaning operations */
862 struct mutex gc_mutex; /* mutex for GC */
863 struct f2fs_gc_kthread *gc_thread; /* GC thread */
864 unsigned int cur_victim_sec; /* current victim section num */
865
823
824 /* for checkpoint */
825 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */
826 int cur_cp_pack; /* remain current cp pack */
827 spinlock_t cp_lock; /* for flag in ckpt */
828 struct inode *meta_inode; /* cache meta blocks */
829 struct mutex cp_mutex; /* checkpoint procedure lock */
830 struct rw_semaphore cp_rwsem; /* blocking FS operations */

--- 55 unchanged lines hidden (view full) ---

886
887 struct f2fs_mount_info mount_opt; /* mount options */
888
889 /* for cleaning operations */
890 struct mutex gc_mutex; /* mutex for GC */
891 struct f2fs_gc_kthread *gc_thread; /* GC thread */
892 unsigned int cur_victim_sec; /* current victim section num */
893
894 /* threshold for converting bg victims for fg */
895 u64 fggc_threshold;
896
866 /* maximum # of trials to find a victim segment for SSR and GC */
867 unsigned int max_victim_search;
868
869 /*
870 * for stat information.
871 * one is for the LFS mode, and the other is for the SSR mode.
872 */
873#ifdef CONFIG_F2FS_STAT_FS
874 struct f2fs_stat_info *stat_info; /* FS status information */
875 unsigned int segment_count[2]; /* # of allocated segments */
876 unsigned int block_count[2]; /* # of allocated blocks */
877 atomic_t inplace_count; /* # of inplace update */
878 atomic64_t total_hit_ext; /* # of lookup extent cache */
879 atomic64_t read_hit_rbtree; /* # of hit rbtree extent node */
880 atomic64_t read_hit_largest; /* # of hit largest extent node */
881 atomic64_t read_hit_cached; /* # of hit cached extent node */
882 atomic_t inline_xattr; /* # of inline_xattr inodes */
883 atomic_t inline_inode; /* # of inline_data inodes */
884 atomic_t inline_dir; /* # of inline_dentry inodes */
897 /* maximum # of trials to find a victim segment for SSR and GC */
898 unsigned int max_victim_search;
899
900 /*
901 * for stat information.
902 * one is for the LFS mode, and the other is for the SSR mode.
903 */
904#ifdef CONFIG_F2FS_STAT_FS
905 struct f2fs_stat_info *stat_info; /* FS status information */
906 unsigned int segment_count[2]; /* # of allocated segments */
907 unsigned int block_count[2]; /* # of allocated blocks */
908 atomic_t inplace_count; /* # of inplace update */
909 atomic64_t total_hit_ext; /* # of lookup extent cache */
910 atomic64_t read_hit_rbtree; /* # of hit rbtree extent node */
911 atomic64_t read_hit_largest; /* # of hit largest extent node */
912 atomic64_t read_hit_cached; /* # of hit cached extent node */
913 atomic_t inline_xattr; /* # of inline_xattr inodes */
914 atomic_t inline_inode; /* # of inline_data inodes */
915 atomic_t inline_dir; /* # of inline_dentry inodes */
916 atomic_t aw_cnt; /* # of atomic writes */
917 atomic_t max_aw_cnt; /* max # of atomic writes */
885 int bg_gc; /* background gc calls */
886 unsigned int ndirty_inode[NR_INODE_TYPE]; /* # of dirty inodes */
887#endif
888 unsigned int last_victim[2]; /* last victim segment # */
889 spinlock_t stat_lock; /* lock for stat operations */
890
891 /* For sysfs suppport */
892 struct kobject s_kobj;

--- 556 unchanged lines hidden (view full) ---

1449 return percpu_counter_sum_positive(&sbi->total_valid_inode_count);
1450}
1451
1452static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
1453 pgoff_t index, bool for_write)
1454{
1455#ifdef CONFIG_F2FS_FAULT_INJECTION
1456 struct page *page = find_lock_page(mapping, index);
918 int bg_gc; /* background gc calls */
919 unsigned int ndirty_inode[NR_INODE_TYPE]; /* # of dirty inodes */
920#endif
921 unsigned int last_victim[2]; /* last victim segment # */
922 spinlock_t stat_lock; /* lock for stat operations */
923
924 /* For sysfs suppport */
925 struct kobject s_kobj;

--- 556 unchanged lines hidden (view full) ---

1482 return percpu_counter_sum_positive(&sbi->total_valid_inode_count);
1483}
1484
1485static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
1486 pgoff_t index, bool for_write)
1487{
1488#ifdef CONFIG_F2FS_FAULT_INJECTION
1489 struct page *page = find_lock_page(mapping, index);
1490
1457 if (page)
1458 return page;
1459
1460 if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_ALLOC))
1461 return NULL;
1462#endif
1463 if (!for_write)
1464 return grab_cache_page(mapping, index);

--- 67 unchanged lines hidden (view full) ---

1532 cond_resched();
1533}
1534
1535#define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
1536
1537static inline bool IS_INODE(struct page *page)
1538{
1539 struct f2fs_node *p = F2FS_NODE(page);
1491 if (page)
1492 return page;
1493
1494 if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_ALLOC))
1495 return NULL;
1496#endif
1497 if (!for_write)
1498 return grab_cache_page(mapping, index);

--- 67 unchanged lines hidden (view full) ---

1566 cond_resched();
1567}
1568
1569#define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
1570
1571static inline bool IS_INODE(struct page *page)
1572{
1573 struct f2fs_node *p = F2FS_NODE(page);
1574
1540 return RAW_IS_INODE(p);
1541}
1542
1543static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
1544{
1545 return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
1546}
1547
1548static inline block_t datablock_addr(struct page *node_page,
1549 unsigned int offset)
1550{
1551 struct f2fs_node *raw_node;
1552 __le32 *addr_array;
1575 return RAW_IS_INODE(p);
1576}
1577
1578static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
1579{
1580 return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
1581}
1582
1583static inline block_t datablock_addr(struct page *node_page,
1584 unsigned int offset)
1585{
1586 struct f2fs_node *raw_node;
1587 __le32 *addr_array;
1588
1553 raw_node = F2FS_NODE(node_page);
1554 addr_array = blkaddr_in_node(raw_node);
1555 return le32_to_cpu(addr_array[offset]);
1556}
1557
1558static inline int f2fs_test_bit(unsigned int nr, char *addr)
1559{
1560 int mask;

--- 67 unchanged lines hidden (view full) ---

1628 FI_NO_EXTENT, /* not to use the extent cache */
1629 FI_INLINE_XATTR, /* used for inline xattr */
1630 FI_INLINE_DATA, /* used for inline data*/
1631 FI_INLINE_DENTRY, /* used for inline dentry */
1632 FI_APPEND_WRITE, /* inode has appended data */
1633 FI_UPDATE_WRITE, /* inode has in-place-update data */
1634 FI_NEED_IPU, /* used for ipu per file */
1635 FI_ATOMIC_FILE, /* indicate atomic file */
1589 raw_node = F2FS_NODE(node_page);
1590 addr_array = blkaddr_in_node(raw_node);
1591 return le32_to_cpu(addr_array[offset]);
1592}
1593
1594static inline int f2fs_test_bit(unsigned int nr, char *addr)
1595{
1596 int mask;

--- 67 unchanged lines hidden (view full) ---

1664 FI_NO_EXTENT, /* not to use the extent cache */
1665 FI_INLINE_XATTR, /* used for inline xattr */
1666 FI_INLINE_DATA, /* used for inline data*/
1667 FI_INLINE_DENTRY, /* used for inline dentry */
1668 FI_APPEND_WRITE, /* inode has appended data */
1669 FI_UPDATE_WRITE, /* inode has in-place-update data */
1670 FI_NEED_IPU, /* used for ipu per file */
1671 FI_ATOMIC_FILE, /* indicate atomic file */
1672 FI_ATOMIC_COMMIT, /* indicate the state of atomical committing */
1636 FI_VOLATILE_FILE, /* indicate volatile file */
1637 FI_FIRST_BLOCK_WRITTEN, /* indicate #0 data block was written */
1638 FI_DROP_CACHE, /* drop dirty page cache */
1639 FI_DATA_EXIST, /* indicate data exists */
1640 FI_INLINE_DOTS, /* indicate inline dot dentries */
1641 FI_DO_DEFRAG, /* indicate defragment is running */
1642 FI_DIRTY_FILE, /* indicate regular/symlink has dirty pages */
1673 FI_VOLATILE_FILE, /* indicate volatile file */
1674 FI_FIRST_BLOCK_WRITTEN, /* indicate #0 data block was written */
1675 FI_DROP_CACHE, /* drop dirty page cache */
1676 FI_DATA_EXIST, /* indicate data exists */
1677 FI_INLINE_DOTS, /* indicate inline dot dentries */
1678 FI_DO_DEFRAG, /* indicate defragment is running */
1679 FI_DIRTY_FILE, /* indicate regular/symlink has dirty pages */
1680 FI_NO_PREALLOC, /* indicate skipped preallocated blocks */
1643};
1644
1645static inline void __mark_inode_dirty_flag(struct inode *inode,
1646 int flag, bool set)
1647{
1648 switch (flag) {
1649 case FI_INLINE_XATTR:
1650 case FI_INLINE_DATA:

--- 128 unchanged lines hidden (view full) ---

1779 if (f2fs_has_inline_xattr(inode))
1780 return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
1781 return DEF_ADDRS_PER_INODE;
1782}
1783
1784static inline void *inline_xattr_addr(struct page *page)
1785{
1786 struct f2fs_inode *ri = F2FS_INODE(page);
1681};
1682
1683static inline void __mark_inode_dirty_flag(struct inode *inode,
1684 int flag, bool set)
1685{
1686 switch (flag) {
1687 case FI_INLINE_XATTR:
1688 case FI_INLINE_DATA:

--- 128 unchanged lines hidden (view full) ---

1817 if (f2fs_has_inline_xattr(inode))
1818 return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
1819 return DEF_ADDRS_PER_INODE;
1820}
1821
1822static inline void *inline_xattr_addr(struct page *page)
1823{
1824 struct f2fs_inode *ri = F2FS_INODE(page);
1825
1787 return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
1788 F2FS_INLINE_XATTR_ADDRS]);
1789}
1790
1791static inline int inline_xattr_size(struct inode *inode)
1792{
1793 if (f2fs_has_inline_xattr(inode))
1794 return F2FS_INLINE_XATTR_ADDRS << 2;

--- 22 unchanged lines hidden (view full) ---

1817 return is_inode_flag_set(inode, FI_INLINE_DOTS);
1818}
1819
1820static inline bool f2fs_is_atomic_file(struct inode *inode)
1821{
1822 return is_inode_flag_set(inode, FI_ATOMIC_FILE);
1823}
1824
1826 return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
1827 F2FS_INLINE_XATTR_ADDRS]);
1828}
1829
1830static inline int inline_xattr_size(struct inode *inode)
1831{
1832 if (f2fs_has_inline_xattr(inode))
1833 return F2FS_INLINE_XATTR_ADDRS << 2;

--- 22 unchanged lines hidden (view full) ---

1856 return is_inode_flag_set(inode, FI_INLINE_DOTS);
1857}
1858
1859static inline bool f2fs_is_atomic_file(struct inode *inode)
1860{
1861 return is_inode_flag_set(inode, FI_ATOMIC_FILE);
1862}
1863
1864static inline bool f2fs_is_commit_atomic_write(struct inode *inode)
1865{
1866 return is_inode_flag_set(inode, FI_ATOMIC_COMMIT);
1867}
1868
1825static inline bool f2fs_is_volatile_file(struct inode *inode)
1826{
1827 return is_inode_flag_set(inode, FI_VOLATILE_FILE);
1828}
1829
1830static inline bool f2fs_is_first_block_written(struct inode *inode)
1831{
1832 return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
1833}
1834
1835static inline bool f2fs_is_drop_cache(struct inode *inode)
1836{
1837 return is_inode_flag_set(inode, FI_DROP_CACHE);
1838}
1839
1840static inline void *inline_data_addr(struct page *page)
1841{
1842 struct f2fs_inode *ri = F2FS_INODE(page);
1869static inline bool f2fs_is_volatile_file(struct inode *inode)
1870{
1871 return is_inode_flag_set(inode, FI_VOLATILE_FILE);
1872}
1873
1874static inline bool f2fs_is_first_block_written(struct inode *inode)
1875{
1876 return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
1877}
1878
1879static inline bool f2fs_is_drop_cache(struct inode *inode)
1880{
1881 return is_inode_flag_set(inode, FI_DROP_CACHE);
1882}
1883
1884static inline void *inline_data_addr(struct page *page)
1885{
1886 struct f2fs_inode *ri = F2FS_INODE(page);
1887
1843 return (void *)&(ri->i_addr[1]);
1844}
1845
1846static inline int f2fs_has_inline_dentry(struct inode *inode)
1847{
1848 return is_inode_flag_set(inode, FI_INLINE_DENTRY);
1849}
1850

--- 106 unchanged lines hidden (view full) ---

1957#define PGOFS_OF_NEXT_DNODE(pgofs, inode) \
1958 ((pgofs < ADDRS_PER_INODE(inode)) ? ADDRS_PER_INODE(inode) : \
1959 (pgofs - ADDRS_PER_INODE(inode) + ADDRS_PER_BLOCK) / \
1960 ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(inode))
1961
1962/*
1963 * file.c
1964 */
1888 return (void *)&(ri->i_addr[1]);
1889}
1890
1891static inline int f2fs_has_inline_dentry(struct inode *inode)
1892{
1893 return is_inode_flag_set(inode, FI_INLINE_DENTRY);
1894}
1895

--- 106 unchanged lines hidden (view full) ---

2002#define PGOFS_OF_NEXT_DNODE(pgofs, inode) \
2003 ((pgofs < ADDRS_PER_INODE(inode)) ? ADDRS_PER_INODE(inode) : \
2004 (pgofs - ADDRS_PER_INODE(inode) + ADDRS_PER_BLOCK) / \
2005 ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(inode))
2006
2007/*
2008 * file.c
2009 */
1965int f2fs_sync_file(struct file *, loff_t, loff_t, int);
1966void truncate_data_blocks(struct dnode_of_data *);
1967int truncate_blocks(struct inode *, u64, bool);
1968int f2fs_truncate(struct inode *);
1969int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
1970int f2fs_setattr(struct dentry *, struct iattr *);
1971int truncate_hole(struct inode *, pgoff_t, pgoff_t);
1972int truncate_data_blocks_range(struct dnode_of_data *, int);
1973long f2fs_ioctl(struct file *, unsigned int, unsigned long);
1974long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
2010int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
2011void truncate_data_blocks(struct dnode_of_data *dn);
2012int truncate_blocks(struct inode *inode, u64 from, bool lock);
2013int f2fs_truncate(struct inode *inode);
2014int f2fs_getattr(struct vfsmount *mnt, struct dentry *dentry,
2015 struct kstat *stat);
2016int f2fs_setattr(struct dentry *dentry, struct iattr *attr);
2017int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end);
2018int truncate_data_blocks_range(struct dnode_of_data *dn, int count);
2019long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
2020long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
1975
1976/*
1977 * inode.c
1978 */
2021
2022/*
2023 * inode.c
2024 */
1979void f2fs_set_inode_flags(struct inode *);
1980struct inode *f2fs_iget(struct super_block *, unsigned long);
1981struct inode *f2fs_iget_retry(struct super_block *, unsigned long);
1982int try_to_free_nats(struct f2fs_sb_info *, int);
1983int update_inode(struct inode *, struct page *);
1984int update_inode_page(struct inode *);
1985int f2fs_write_inode(struct inode *, struct writeback_control *);
1986void f2fs_evict_inode(struct inode *);
1987void handle_failed_inode(struct inode *);
2025void f2fs_set_inode_flags(struct inode *inode);
2026struct inode *f2fs_iget(struct super_block *sb, unsigned long ino);
2027struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino);
2028int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink);
2029int update_inode(struct inode *inode, struct page *node_page);
2030int update_inode_page(struct inode *inode);
2031int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);
2032void f2fs_evict_inode(struct inode *inode);
2033void handle_failed_inode(struct inode *inode);
1988
1989/*
1990 * namei.c
1991 */
1992struct dentry *f2fs_get_parent(struct dentry *child);
1993
1994/*
1995 * dir.c
1996 */
2034
2035/*
2036 * namei.c
2037 */
2038struct dentry *f2fs_get_parent(struct dentry *child);
2039
2040/*
2041 * dir.c
2042 */
1997void set_de_type(struct f2fs_dir_entry *, umode_t);
1998unsigned char get_de_type(struct f2fs_dir_entry *);
1999struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *,
2000 f2fs_hash_t, int *, struct f2fs_dentry_ptr *);
2001int f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *,
2002 unsigned int, struct fscrypt_str *);
2003void do_make_empty_dir(struct inode *, struct inode *,
2004 struct f2fs_dentry_ptr *);
2005struct page *init_inode_metadata(struct inode *, struct inode *,
2006 const struct qstr *, const struct qstr *, struct page *);
2007void update_parent_metadata(struct inode *, struct inode *, unsigned int);
2008int room_for_filename(const void *, int, int);
2009void f2fs_drop_nlink(struct inode *, struct inode *);
2010struct f2fs_dir_entry *__f2fs_find_entry(struct inode *, struct fscrypt_name *,
2011 struct page **);
2012struct f2fs_dir_entry *f2fs_find_entry(struct inode *, const struct qstr *,
2013 struct page **);
2014struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
2015ino_t f2fs_inode_by_name(struct inode *, const struct qstr *, struct page **);
2016void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
2017 struct page *, struct inode *);
2018int update_dent_inode(struct inode *, struct inode *, const struct qstr *);
2019void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *,
2020 const struct qstr *, f2fs_hash_t , unsigned int);
2021int f2fs_add_regular_entry(struct inode *, const struct qstr *,
2022 const struct qstr *, struct inode *, nid_t, umode_t);
2023int __f2fs_do_add_link(struct inode *, struct fscrypt_name*, struct inode *,
2024 nid_t, umode_t);
2025int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *, nid_t,
2026 umode_t);
2027void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *,
2028 struct inode *);
2029int f2fs_do_tmpfile(struct inode *, struct inode *);
2030bool f2fs_empty_dir(struct inode *);
2043void set_de_type(struct f2fs_dir_entry *de, umode_t mode);
2044unsigned char get_de_type(struct f2fs_dir_entry *de);
2045struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname,
2046 f2fs_hash_t namehash, int *max_slots,
2047 struct f2fs_dentry_ptr *d);
2048int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
2049 unsigned int start_pos, struct fscrypt_str *fstr);
2050void do_make_empty_dir(struct inode *inode, struct inode *parent,
2051 struct f2fs_dentry_ptr *d);
2052struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
2053 const struct qstr *new_name,
2054 const struct qstr *orig_name, struct page *dpage);
2055void update_parent_metadata(struct inode *dir, struct inode *inode,
2056 unsigned int current_depth);
2057int room_for_filename(const void *bitmap, int slots, int max_slots);
2058void f2fs_drop_nlink(struct inode *dir, struct inode *inode);
2059struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
2060 struct fscrypt_name *fname, struct page **res_page);
2061struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
2062 const struct qstr *child, struct page **res_page);
2063struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p);
2064ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
2065 struct page **page);
2066void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
2067 struct page *page, struct inode *inode);
2068int update_dent_inode(struct inode *inode, struct inode *to,
2069 const struct qstr *name);
2070void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
2071 const struct qstr *name, f2fs_hash_t name_hash,
2072 unsigned int bit_pos);
2073int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
2074 const struct qstr *orig_name,
2075 struct inode *inode, nid_t ino, umode_t mode);
2076int __f2fs_do_add_link(struct inode *dir, struct fscrypt_name *fname,
2077 struct inode *inode, nid_t ino, umode_t mode);
2078int __f2fs_add_link(struct inode *dir, const struct qstr *name,
2079 struct inode *inode, nid_t ino, umode_t mode);
2080void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
2081 struct inode *dir, struct inode *inode);
2082int f2fs_do_tmpfile(struct inode *inode, struct inode *dir);
2083bool f2fs_empty_dir(struct inode *dir);
2031
2032static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
2033{
2034 return __f2fs_add_link(d_inode(dentry->d_parent), &dentry->d_name,
2035 inode, inode->i_ino, inode->i_mode);
2036}
2037
2038/*
2039 * super.c
2040 */
2084
2085static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
2086{
2087 return __f2fs_add_link(d_inode(dentry->d_parent), &dentry->d_name,
2088 inode, inode->i_ino, inode->i_mode);
2089}
2090
2091/*
2092 * super.c
2093 */
2041int f2fs_inode_dirtied(struct inode *, bool);
2042void f2fs_inode_synced(struct inode *);
2043int f2fs_commit_super(struct f2fs_sb_info *, bool);
2044int f2fs_sync_fs(struct super_block *, int);
2094int f2fs_inode_dirtied(struct inode *inode, bool sync);
2095void f2fs_inode_synced(struct inode *inode);
2096int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover);
2097int f2fs_sync_fs(struct super_block *sb, int sync);
2045extern __printf(3, 4)
2098extern __printf(3, 4)
2046void f2fs_msg(struct super_block *, const char *, const char *, ...);
2099void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...);
2047int sanity_check_ckpt(struct f2fs_sb_info *sbi);
2048
2049/*
2050 * hash.c
2051 */
2100int sanity_check_ckpt(struct f2fs_sb_info *sbi);
2101
2102/*
2103 * hash.c
2104 */
2052f2fs_hash_t f2fs_dentry_hash(const struct qstr *);
2105f2fs_hash_t f2fs_dentry_hash(const struct qstr *name_info);
2053
2054/*
2055 * node.c
2056 */
2057struct dnode_of_data;
2058struct node_info;
2059
2106
2107/*
2108 * node.c
2109 */
2110struct dnode_of_data;
2111struct node_info;
2112
2060bool available_free_memory(struct f2fs_sb_info *, int);
2061int need_dentry_mark(struct f2fs_sb_info *, nid_t);
2062bool is_checkpointed_node(struct f2fs_sb_info *, nid_t);
2063bool need_inode_block_update(struct f2fs_sb_info *, nid_t);
2064void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
2065pgoff_t get_next_page_offset(struct dnode_of_data *, pgoff_t);
2066int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int);
2067int truncate_inode_blocks(struct inode *, pgoff_t);
2068int truncate_xattr_node(struct inode *, struct page *);
2069int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t);
2070int remove_inode_page(struct inode *);
2071struct page *new_inode_page(struct inode *);
2072struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
2073void ra_node_page(struct f2fs_sb_info *, nid_t);
2074struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
2075struct page *get_node_page_ra(struct page *, int);
2076void move_node_page(struct page *, int);
2077int fsync_node_pages(struct f2fs_sb_info *, struct inode *,
2078 struct writeback_control *, bool);
2079int sync_node_pages(struct f2fs_sb_info *, struct writeback_control *);
2080void build_free_nids(struct f2fs_sb_info *, bool);
2081bool alloc_nid(struct f2fs_sb_info *, nid_t *);
2082void alloc_nid_done(struct f2fs_sb_info *, nid_t);
2083void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
2084int try_to_free_nids(struct f2fs_sb_info *, int);
2085void recover_inline_xattr(struct inode *, struct page *);
2086void recover_xattr_data(struct inode *, struct page *, block_t);
2087int recover_inode_page(struct f2fs_sb_info *, struct page *);
2088int restore_node_summary(struct f2fs_sb_info *, unsigned int,
2089 struct f2fs_summary_block *);
2090void flush_nat_entries(struct f2fs_sb_info *);
2091int build_node_manager(struct f2fs_sb_info *);
2092void destroy_node_manager(struct f2fs_sb_info *);
2113bool available_free_memory(struct f2fs_sb_info *sbi, int type);
2114int need_dentry_mark(struct f2fs_sb_info *sbi, nid_t nid);
2115bool is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid);
2116bool need_inode_block_update(struct f2fs_sb_info *sbi, nid_t ino);
2117void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni);
2118pgoff_t get_next_page_offset(struct dnode_of_data *dn, pgoff_t pgofs);
2119int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode);
2120int truncate_inode_blocks(struct inode *inode, pgoff_t from);
2121int truncate_xattr_node(struct inode *inode, struct page *page);
2122int wait_on_node_pages_writeback(struct f2fs_sb_info *sbi, nid_t ino);
2123int remove_inode_page(struct inode *inode);
2124struct page *new_inode_page(struct inode *inode);
2125struct page *new_node_page(struct dnode_of_data *dn,
2126 unsigned int ofs, struct page *ipage);
2127void ra_node_page(struct f2fs_sb_info *sbi, nid_t nid);
2128struct page *get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid);
2129struct page *get_node_page_ra(struct page *parent, int start);
2130void move_node_page(struct page *node_page, int gc_type);
2131int fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
2132 struct writeback_control *wbc, bool atomic);
2133int sync_node_pages(struct f2fs_sb_info *sbi, struct writeback_control *wbc);
2134void build_free_nids(struct f2fs_sb_info *sbi, bool sync);
2135bool alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid);
2136void alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid);
2137void alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid);
2138int try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink);
2139void recover_inline_xattr(struct inode *inode, struct page *page);
2140int recover_xattr_data(struct inode *inode, struct page *page,
2141 block_t blkaddr);
2142int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page);
2143int restore_node_summary(struct f2fs_sb_info *sbi,
2144 unsigned int segno, struct f2fs_summary_block *sum);
2145void flush_nat_entries(struct f2fs_sb_info *sbi);
2146int build_node_manager(struct f2fs_sb_info *sbi);
2147void destroy_node_manager(struct f2fs_sb_info *sbi);
2093int __init create_node_manager_caches(void);
2094void destroy_node_manager_caches(void);
2095
2096/*
2097 * segment.c
2098 */
2148int __init create_node_manager_caches(void);
2149void destroy_node_manager_caches(void);
2150
2151/*
2152 * segment.c
2153 */
2099void register_inmem_page(struct inode *, struct page *);
2100void drop_inmem_pages(struct inode *);
2101int commit_inmem_pages(struct inode *);
2102void f2fs_balance_fs(struct f2fs_sb_info *, bool);
2103void f2fs_balance_fs_bg(struct f2fs_sb_info *);
2104int f2fs_issue_flush(struct f2fs_sb_info *);
2105int create_flush_cmd_control(struct f2fs_sb_info *);
2106void destroy_flush_cmd_control(struct f2fs_sb_info *, bool);
2107void invalidate_blocks(struct f2fs_sb_info *, block_t);
2108bool is_checkpointed_data(struct f2fs_sb_info *, block_t);
2109void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t);
2110void f2fs_wait_all_discard_bio(struct f2fs_sb_info *);
2111void clear_prefree_segments(struct f2fs_sb_info *, struct cp_control *);
2112void release_discard_addrs(struct f2fs_sb_info *);
2113int npages_for_summary_flush(struct f2fs_sb_info *, bool);
2114void allocate_new_segments(struct f2fs_sb_info *);
2115int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *);
2116struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
2117void update_meta_page(struct f2fs_sb_info *, void *, block_t);
2118void write_meta_page(struct f2fs_sb_info *, struct page *);
2119void write_node_page(unsigned int, struct f2fs_io_info *);
2120void write_data_page(struct dnode_of_data *, struct f2fs_io_info *);
2121void rewrite_data_page(struct f2fs_io_info *);
2122void __f2fs_replace_block(struct f2fs_sb_info *, struct f2fs_summary *,
2123 block_t, block_t, bool, bool);
2124void f2fs_replace_block(struct f2fs_sb_info *, struct dnode_of_data *,
2125 block_t, block_t, unsigned char, bool, bool);
2126void allocate_data_block(struct f2fs_sb_info *, struct page *,
2127 block_t, block_t *, struct f2fs_summary *, int);
2128void f2fs_wait_on_page_writeback(struct page *, enum page_type, bool);
2129void f2fs_wait_on_encrypted_page_writeback(struct f2fs_sb_info *, block_t);
2130void write_data_summaries(struct f2fs_sb_info *, block_t);
2131void write_node_summaries(struct f2fs_sb_info *, block_t);
2132int lookup_journal_in_cursum(struct f2fs_journal *, int, unsigned int, int);
2133void flush_sit_entries(struct f2fs_sb_info *, struct cp_control *);
2134int build_segment_manager(struct f2fs_sb_info *);
2135void destroy_segment_manager(struct f2fs_sb_info *);
2154void register_inmem_page(struct inode *inode, struct page *page);
2155void drop_inmem_pages(struct inode *inode);
2156int commit_inmem_pages(struct inode *inode);
2157void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need);
2158void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi);
2159int f2fs_issue_flush(struct f2fs_sb_info *sbi);
2160int create_flush_cmd_control(struct f2fs_sb_info *sbi);
2161void destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free);
2162void invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr);
2163bool is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
2164void refresh_sit_entry(struct f2fs_sb_info *sbi, block_t old, block_t new);
2165void f2fs_wait_discard_bio(struct f2fs_sb_info *sbi, block_t blkaddr);
2166void clear_prefree_segments(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2167void release_discard_addrs(struct f2fs_sb_info *sbi);
2168int npages_for_summary_flush(struct f2fs_sb_info *sbi, bool for_ra);
2169void allocate_new_segments(struct f2fs_sb_info *sbi);
2170int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range);
2171bool exist_trim_candidates(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2172struct page *get_sum_page(struct f2fs_sb_info *sbi, unsigned int segno);
2173void update_meta_page(struct f2fs_sb_info *sbi, void *src, block_t blk_addr);
2174void write_meta_page(struct f2fs_sb_info *sbi, struct page *page);
2175void write_node_page(unsigned int nid, struct f2fs_io_info *fio);
2176void write_data_page(struct dnode_of_data *dn, struct f2fs_io_info *fio);
2177void rewrite_data_page(struct f2fs_io_info *fio);
2178void __f2fs_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
2179 block_t old_blkaddr, block_t new_blkaddr,
2180 bool recover_curseg, bool recover_newaddr);
2181void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
2182 block_t old_addr, block_t new_addr,
2183 unsigned char version, bool recover_curseg,
2184 bool recover_newaddr);
2185void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
2186 block_t old_blkaddr, block_t *new_blkaddr,
2187 struct f2fs_summary *sum, int type);
2188void f2fs_wait_on_page_writeback(struct page *page,
2189 enum page_type type, bool ordered);
2190void f2fs_wait_on_encrypted_page_writeback(struct f2fs_sb_info *sbi,
2191 block_t blkaddr);
2192void write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
2193void write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
2194int lookup_journal_in_cursum(struct f2fs_journal *journal, int type,
2195 unsigned int val, int alloc);
2196void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2197int build_segment_manager(struct f2fs_sb_info *sbi);
2198void destroy_segment_manager(struct f2fs_sb_info *sbi);
2136int __init create_segment_manager_caches(void);
2137void destroy_segment_manager_caches(void);
2138
2139/*
2140 * checkpoint.c
2141 */
2199int __init create_segment_manager_caches(void);
2200void destroy_segment_manager_caches(void);
2201
2202/*
2203 * checkpoint.c
2204 */
2142void f2fs_stop_checkpoint(struct f2fs_sb_info *, bool);
2143struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
2144struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
2145struct page *get_tmp_page(struct f2fs_sb_info *, pgoff_t);
2146bool is_valid_blkaddr(struct f2fs_sb_info *, block_t, int);
2147int ra_meta_pages(struct f2fs_sb_info *, block_t, int, int, bool);
2148void ra_meta_pages_cond(struct f2fs_sb_info *, pgoff_t);
2149long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
2150void add_ino_entry(struct f2fs_sb_info *, nid_t, int type);
2151void remove_ino_entry(struct f2fs_sb_info *, nid_t, int type);
2152void release_ino_entry(struct f2fs_sb_info *, bool);
2153bool exist_written_data(struct f2fs_sb_info *, nid_t, int);
2154int f2fs_sync_inode_meta(struct f2fs_sb_info *);
2155int acquire_orphan_inode(struct f2fs_sb_info *);
2156void release_orphan_inode(struct f2fs_sb_info *);
2157void add_orphan_inode(struct inode *);
2158void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
2159int recover_orphan_inodes(struct f2fs_sb_info *);
2160int get_valid_checkpoint(struct f2fs_sb_info *);
2161void update_dirty_page(struct inode *, struct page *);
2162void remove_dirty_inode(struct inode *);
2163int sync_dirty_inodes(struct f2fs_sb_info *, enum inode_type);
2164int write_checkpoint(struct f2fs_sb_info *, struct cp_control *);
2165void init_ino_entry_info(struct f2fs_sb_info *);
2205void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io);
2206struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
2207struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
2208struct page *get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index);
2209bool is_valid_blkaddr(struct f2fs_sb_info *sbi, block_t blkaddr, int type);
2210int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
2211 int type, bool sync);
2212void ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index);
2213long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
2214 long nr_to_write);
2215void add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
2216void remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
2217void release_ino_entry(struct f2fs_sb_info *sbi, bool all);
2218bool exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode);
2219int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi);
2220int acquire_orphan_inode(struct f2fs_sb_info *sbi);
2221void release_orphan_inode(struct f2fs_sb_info *sbi);
2222void add_orphan_inode(struct inode *inode);
2223void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino);
2224int recover_orphan_inodes(struct f2fs_sb_info *sbi);
2225int get_valid_checkpoint(struct f2fs_sb_info *sbi);
2226void update_dirty_page(struct inode *inode, struct page *page);
2227void remove_dirty_inode(struct inode *inode);
2228int sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type);
2229int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2230void init_ino_entry_info(struct f2fs_sb_info *sbi);
2166int __init create_checkpoint_caches(void);
2167void destroy_checkpoint_caches(void);
2168
2169/*
2170 * data.c
2171 */
2231int __init create_checkpoint_caches(void);
2232void destroy_checkpoint_caches(void);
2233
2234/*
2235 * data.c
2236 */
2172void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int);
2173void f2fs_submit_merged_bio_cond(struct f2fs_sb_info *, struct inode *,
2174 struct page *, nid_t, enum page_type, int);
2175void f2fs_flush_merged_bios(struct f2fs_sb_info *);
2176int f2fs_submit_page_bio(struct f2fs_io_info *);
2177void f2fs_submit_page_mbio(struct f2fs_io_info *);
2178struct block_device *f2fs_target_device(struct f2fs_sb_info *,
2179 block_t, struct bio *);
2180int f2fs_target_device_index(struct f2fs_sb_info *, block_t);
2181void set_data_blkaddr(struct dnode_of_data *);
2182void f2fs_update_data_blkaddr(struct dnode_of_data *, block_t);
2183int reserve_new_blocks(struct dnode_of_data *, blkcnt_t);
2184int reserve_new_block(struct dnode_of_data *);
2185int f2fs_get_block(struct dnode_of_data *, pgoff_t);
2186int f2fs_preallocate_blocks(struct kiocb *, struct iov_iter *);
2187int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
2188struct page *get_read_data_page(struct inode *, pgoff_t, int, bool);
2189struct page *find_data_page(struct inode *, pgoff_t);
2190struct page *get_lock_data_page(struct inode *, pgoff_t, bool);
2191struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
2192int do_write_data_page(struct f2fs_io_info *);
2193int f2fs_map_blocks(struct inode *, struct f2fs_map_blocks *, int, int);
2194int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);
2195void f2fs_set_page_dirty_nobuffers(struct page *);
2196void f2fs_invalidate_page(struct page *, unsigned int, unsigned int);
2197int f2fs_release_page(struct page *, gfp_t);
2237void f2fs_submit_merged_bio(struct f2fs_sb_info *sbi, enum page_type type,
2238 int rw);
2239void f2fs_submit_merged_bio_cond(struct f2fs_sb_info *sbi,
2240 struct inode *inode, nid_t ino, pgoff_t idx,
2241 enum page_type type, int rw);
2242void f2fs_flush_merged_bios(struct f2fs_sb_info *sbi);
2243int f2fs_submit_page_bio(struct f2fs_io_info *fio);
2244int f2fs_submit_page_mbio(struct f2fs_io_info *fio);
2245struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,
2246 block_t blk_addr, struct bio *bio);
2247int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr);
2248void set_data_blkaddr(struct dnode_of_data *dn);
2249void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr);
2250int reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count);
2251int reserve_new_block(struct dnode_of_data *dn);
2252int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index);
2253int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from);
2254int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index);
2255struct page *get_read_data_page(struct inode *inode, pgoff_t index,
2256 int op_flags, bool for_write);
2257struct page *find_data_page(struct inode *inode, pgoff_t index);
2258struct page *get_lock_data_page(struct inode *inode, pgoff_t index,
2259 bool for_write);
2260struct page *get_new_data_page(struct inode *inode,
2261 struct page *ipage, pgoff_t index, bool new_i_size);
2262int do_write_data_page(struct f2fs_io_info *fio);
2263int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
2264 int create, int flag);
2265int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2266 u64 start, u64 len);
2267void f2fs_set_page_dirty_nobuffers(struct page *page);
2268void f2fs_invalidate_page(struct page *page, unsigned int offset,
2269 unsigned int length);
2270int f2fs_release_page(struct page *page, gfp_t wait);
2198#ifdef CONFIG_MIGRATION
2271#ifdef CONFIG_MIGRATION
2199int f2fs_migrate_page(struct address_space *, struct page *, struct page *,
2200 enum migrate_mode);
2272int f2fs_migrate_page(struct address_space *mapping, struct page *newpage,
2273 struct page *page, enum migrate_mode mode);
2201#endif
2202
2203/*
2204 * gc.c
2205 */
2274#endif
2275
2276/*
2277 * gc.c
2278 */
2206int start_gc_thread(struct f2fs_sb_info *);
2207void stop_gc_thread(struct f2fs_sb_info *);
2208block_t start_bidx_of_node(unsigned int, struct inode *);
2209int f2fs_gc(struct f2fs_sb_info *, bool, bool);
2210void build_gc_manager(struct f2fs_sb_info *);
2279int start_gc_thread(struct f2fs_sb_info *sbi);
2280void stop_gc_thread(struct f2fs_sb_info *sbi);
2281block_t start_bidx_of_node(unsigned int node_ofs, struct inode *inode);
2282int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background);
2283void build_gc_manager(struct f2fs_sb_info *sbi);
2211
2212/*
2213 * recovery.c
2214 */
2284
2285/*
2286 * recovery.c
2287 */
2215int recover_fsync_data(struct f2fs_sb_info *, bool);
2216bool space_for_roll_forward(struct f2fs_sb_info *);
2288int recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only);
2289bool space_for_roll_forward(struct f2fs_sb_info *sbi);
2217
2218/*
2219 * debug.c
2220 */
2221#ifdef CONFIG_F2FS_STAT_FS
2222struct f2fs_stat_info {
2223 struct list_head stat_list;
2224 struct f2fs_sb_info *sbi;
2225 int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
2226 int main_area_segs, main_area_sections, main_area_zones;
2227 unsigned long long hit_largest, hit_cached, hit_rbtree;
2228 unsigned long long hit_total, total_ext;
2229 int ext_tree, zombie_tree, ext_node;
2230 int ndirty_node, ndirty_dent, ndirty_meta, ndirty_data, ndirty_imeta;
2231 int inmem_pages;
2232 unsigned int ndirty_dirs, ndirty_files, ndirty_all;
2233 int nats, dirty_nats, sits, dirty_sits, free_nids, alloc_nids;
2234 int total_count, utilization;
2290
2291/*
2292 * debug.c
2293 */
2294#ifdef CONFIG_F2FS_STAT_FS
2295struct f2fs_stat_info {
2296 struct list_head stat_list;
2297 struct f2fs_sb_info *sbi;
2298 int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
2299 int main_area_segs, main_area_sections, main_area_zones;
2300 unsigned long long hit_largest, hit_cached, hit_rbtree;
2301 unsigned long long hit_total, total_ext;
2302 int ext_tree, zombie_tree, ext_node;
2303 int ndirty_node, ndirty_dent, ndirty_meta, ndirty_data, ndirty_imeta;
2304 int inmem_pages;
2305 unsigned int ndirty_dirs, ndirty_files, ndirty_all;
2306 int nats, dirty_nats, sits, dirty_sits, free_nids, alloc_nids;
2307 int total_count, utilization;
2235 int bg_gc, nr_wb_cp_data, nr_wb_data;
2236 int inline_xattr, inline_inode, inline_dir, orphans;
2308 int bg_gc, nr_wb_cp_data, nr_wb_data, nr_flush, nr_discard;
2309 int inline_xattr, inline_inode, inline_dir, append, update, orphans;
2310 int aw_cnt, max_aw_cnt;
2237 unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
2238 unsigned int bimodal, avg_vblocks;
2239 int util_free, util_valid, util_invalid;
2240 int rsvd_segs, overp_segs;
2241 int dirty_count, node_pages, meta_pages;
2242 int prefree_count, call_count, cp_count, bg_cp_count;
2243 int tot_segs, node_segs, data_segs, free_segs, free_secs;
2244 int bg_node_segs, bg_data_segs;

--- 55 unchanged lines hidden (view full) ---

2300 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
2301 } while (0)
2302#define stat_inc_seg_type(sbi, curseg) \
2303 ((sbi)->segment_count[(curseg)->alloc_type]++)
2304#define stat_inc_block_count(sbi, curseg) \
2305 ((sbi)->block_count[(curseg)->alloc_type]++)
2306#define stat_inc_inplace_blocks(sbi) \
2307 (atomic_inc(&(sbi)->inplace_count))
2311 unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
2312 unsigned int bimodal, avg_vblocks;
2313 int util_free, util_valid, util_invalid;
2314 int rsvd_segs, overp_segs;
2315 int dirty_count, node_pages, meta_pages;
2316 int prefree_count, call_count, cp_count, bg_cp_count;
2317 int tot_segs, node_segs, data_segs, free_segs, free_secs;
2318 int bg_node_segs, bg_data_segs;

--- 55 unchanged lines hidden (view full) ---

2374 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
2375 } while (0)
2376#define stat_inc_seg_type(sbi, curseg) \
2377 ((sbi)->segment_count[(curseg)->alloc_type]++)
2378#define stat_inc_block_count(sbi, curseg) \
2379 ((sbi)->block_count[(curseg)->alloc_type]++)
2380#define stat_inc_inplace_blocks(sbi) \
2381 (atomic_inc(&(sbi)->inplace_count))
2382#define stat_inc_atomic_write(inode) \
2383 (atomic_inc(&F2FS_I_SB(inode)->aw_cnt))
2384#define stat_dec_atomic_write(inode) \
2385 (atomic_dec(&F2FS_I_SB(inode)->aw_cnt))
2386#define stat_update_max_atomic_write(inode) \
2387 do { \
2388 int cur = atomic_read(&F2FS_I_SB(inode)->aw_cnt); \
2389 int max = atomic_read(&F2FS_I_SB(inode)->max_aw_cnt); \
2390 if (cur > max) \
2391 atomic_set(&F2FS_I_SB(inode)->max_aw_cnt, cur); \
2392 } while (0)
2308#define stat_inc_seg_count(sbi, type, gc_type) \
2309 do { \
2310 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
2311 (si)->tot_segs++; \
2312 if (type == SUM_TYPE_DATA) { \
2313 si->data_segs++; \
2314 si->bg_data_segs += (gc_type == BG_GC) ? 1 : 0; \
2315 } else { \

--- 16 unchanged lines hidden (view full) ---

2332#define stat_inc_node_blk_count(sbi, blks, gc_type) \
2333 do { \
2334 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
2335 stat_inc_tot_blk_count(si, blks); \
2336 si->node_blks += (blks); \
2337 si->bg_node_blks += (gc_type == BG_GC) ? (blks) : 0; \
2338 } while (0)
2339
2393#define stat_inc_seg_count(sbi, type, gc_type) \
2394 do { \
2395 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
2396 (si)->tot_segs++; \
2397 if (type == SUM_TYPE_DATA) { \
2398 si->data_segs++; \
2399 si->bg_data_segs += (gc_type == BG_GC) ? 1 : 0; \
2400 } else { \

--- 16 unchanged lines hidden (view full) ---

2417#define stat_inc_node_blk_count(sbi, blks, gc_type) \
2418 do { \
2419 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
2420 stat_inc_tot_blk_count(si, blks); \
2421 si->node_blks += (blks); \
2422 si->bg_node_blks += (gc_type == BG_GC) ? (blks) : 0; \
2423 } while (0)
2424
2340int f2fs_build_stats(struct f2fs_sb_info *);
2341void f2fs_destroy_stats(struct f2fs_sb_info *);
2425int f2fs_build_stats(struct f2fs_sb_info *sbi);
2426void f2fs_destroy_stats(struct f2fs_sb_info *sbi);
2342int __init f2fs_create_root_stats(void);
2343void f2fs_destroy_root_stats(void);
2344#else
2345#define stat_inc_cp_count(si)
2346#define stat_inc_bg_cp_count(si)
2347#define stat_inc_call_count(si)
2348#define stat_inc_bggc_count(si)
2349#define stat_inc_dirty_inode(sbi, type)
2350#define stat_dec_dirty_inode(sbi, type)
2351#define stat_inc_total_hit(sb)
2352#define stat_inc_rbtree_node_hit(sb)
2353#define stat_inc_largest_node_hit(sbi)
2354#define stat_inc_cached_node_hit(sbi)
2355#define stat_inc_inline_xattr(inode)
2356#define stat_dec_inline_xattr(inode)
2357#define stat_inc_inline_inode(inode)
2358#define stat_dec_inline_inode(inode)
2359#define stat_inc_inline_dir(inode)
2360#define stat_dec_inline_dir(inode)
2427int __init f2fs_create_root_stats(void);
2428void f2fs_destroy_root_stats(void);
2429#else
2430#define stat_inc_cp_count(si)
2431#define stat_inc_bg_cp_count(si)
2432#define stat_inc_call_count(si)
2433#define stat_inc_bggc_count(si)
2434#define stat_inc_dirty_inode(sbi, type)
2435#define stat_dec_dirty_inode(sbi, type)
2436#define stat_inc_total_hit(sb)
2437#define stat_inc_rbtree_node_hit(sb)
2438#define stat_inc_largest_node_hit(sbi)
2439#define stat_inc_cached_node_hit(sbi)
2440#define stat_inc_inline_xattr(inode)
2441#define stat_dec_inline_xattr(inode)
2442#define stat_inc_inline_inode(inode)
2443#define stat_dec_inline_inode(inode)
2444#define stat_inc_inline_dir(inode)
2445#define stat_dec_inline_dir(inode)
2446#define stat_inc_atomic_write(inode)
2447#define stat_dec_atomic_write(inode)
2448#define stat_update_max_atomic_write(inode)
2361#define stat_inc_seg_type(sbi, curseg)
2362#define stat_inc_block_count(sbi, curseg)
2363#define stat_inc_inplace_blocks(sbi)
2364#define stat_inc_seg_count(sbi, type, gc_type)
2365#define stat_inc_tot_blk_count(si, blks)
2366#define stat_inc_data_blk_count(sbi, blks, gc_type)
2367#define stat_inc_node_blk_count(sbi, blks, gc_type)
2368

--- 13 unchanged lines hidden (view full) ---

2382extern const struct inode_operations f2fs_symlink_inode_operations;
2383extern const struct inode_operations f2fs_encrypted_symlink_inode_operations;
2384extern const struct inode_operations f2fs_special_inode_operations;
2385extern struct kmem_cache *inode_entry_slab;
2386
2387/*
2388 * inline.c
2389 */
2449#define stat_inc_seg_type(sbi, curseg)
2450#define stat_inc_block_count(sbi, curseg)
2451#define stat_inc_inplace_blocks(sbi)
2452#define stat_inc_seg_count(sbi, type, gc_type)
2453#define stat_inc_tot_blk_count(si, blks)
2454#define stat_inc_data_blk_count(sbi, blks, gc_type)
2455#define stat_inc_node_blk_count(sbi, blks, gc_type)
2456

--- 13 unchanged lines hidden (view full) ---

2470extern const struct inode_operations f2fs_symlink_inode_operations;
2471extern const struct inode_operations f2fs_encrypted_symlink_inode_operations;
2472extern const struct inode_operations f2fs_special_inode_operations;
2473extern struct kmem_cache *inode_entry_slab;
2474
2475/*
2476 * inline.c
2477 */
2390bool f2fs_may_inline_data(struct inode *);
2391bool f2fs_may_inline_dentry(struct inode *);
2392void read_inline_data(struct page *, struct page *);
2393bool truncate_inline_inode(struct page *, u64);
2394int f2fs_read_inline_data(struct inode *, struct page *);
2395int f2fs_convert_inline_page(struct dnode_of_data *, struct page *);
2396int f2fs_convert_inline_inode(struct inode *);
2397int f2fs_write_inline_data(struct inode *, struct page *);
2398bool recover_inline_data(struct inode *, struct page *);
2399struct f2fs_dir_entry *find_in_inline_dir(struct inode *,
2400 struct fscrypt_name *, struct page **);
2401int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
2402int f2fs_add_inline_entry(struct inode *, const struct qstr *,
2403 const struct qstr *, struct inode *, nid_t, umode_t);
2404void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *,
2405 struct inode *, struct inode *);
2406bool f2fs_empty_inline_dir(struct inode *);
2407int f2fs_read_inline_dir(struct file *, struct dir_context *,
2408 struct fscrypt_str *);
2409int f2fs_inline_data_fiemap(struct inode *,
2410 struct fiemap_extent_info *, __u64, __u64);
2478bool f2fs_may_inline_data(struct inode *inode);
2479bool f2fs_may_inline_dentry(struct inode *inode);
2480void read_inline_data(struct page *page, struct page *ipage);
2481bool truncate_inline_inode(struct page *ipage, u64 from);
2482int f2fs_read_inline_data(struct inode *inode, struct page *page);
2483int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page);
2484int f2fs_convert_inline_inode(struct inode *inode);
2485int f2fs_write_inline_data(struct inode *inode, struct page *page);
2486bool recover_inline_data(struct inode *inode, struct page *npage);
2487struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
2488 struct fscrypt_name *fname, struct page **res_page);
2489int make_empty_inline_dir(struct inode *inode, struct inode *parent,
2490 struct page *ipage);
2491int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
2492 const struct qstr *orig_name,
2493 struct inode *inode, nid_t ino, umode_t mode);
2494void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
2495 struct inode *dir, struct inode *inode);
2496bool f2fs_empty_inline_dir(struct inode *dir);
2497int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
2498 struct fscrypt_str *fstr);
2499int f2fs_inline_data_fiemap(struct inode *inode,
2500 struct fiemap_extent_info *fieinfo,
2501 __u64 start, __u64 len);
2411
2412/*
2413 * shrinker.c
2414 */
2502
2503/*
2504 * shrinker.c
2505 */
2415unsigned long f2fs_shrink_count(struct shrinker *, struct shrink_control *);
2416unsigned long f2fs_shrink_scan(struct shrinker *, struct shrink_control *);
2417void f2fs_join_shrinker(struct f2fs_sb_info *);
2418void f2fs_leave_shrinker(struct f2fs_sb_info *);
2506unsigned long f2fs_shrink_count(struct shrinker *shrink,
2507 struct shrink_control *sc);
2508unsigned long f2fs_shrink_scan(struct shrinker *shrink,
2509 struct shrink_control *sc);
2510void f2fs_join_shrinker(struct f2fs_sb_info *sbi);
2511void f2fs_leave_shrinker(struct f2fs_sb_info *sbi);
2419
2420/*
2421 * extent_cache.c
2422 */
2512
2513/*
2514 * extent_cache.c
2515 */
2423unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *, int);
2424bool f2fs_init_extent_tree(struct inode *, struct f2fs_extent *);
2425void f2fs_drop_extent_tree(struct inode *);
2426unsigned int f2fs_destroy_extent_node(struct inode *);
2427void f2fs_destroy_extent_tree(struct inode *);
2428bool f2fs_lookup_extent_cache(struct inode *, pgoff_t, struct extent_info *);
2429void f2fs_update_extent_cache(struct dnode_of_data *);
2516unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink);
2517bool f2fs_init_extent_tree(struct inode *inode, struct f2fs_extent *i_ext);
2518void f2fs_drop_extent_tree(struct inode *inode);
2519unsigned int f2fs_destroy_extent_node(struct inode *inode);
2520void f2fs_destroy_extent_tree(struct inode *inode);
2521bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs,
2522 struct extent_info *ei);
2523void f2fs_update_extent_cache(struct dnode_of_data *dn);
2430void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
2524void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
2431 pgoff_t, block_t, unsigned int);
2432void init_extent_cache_info(struct f2fs_sb_info *);
2525 pgoff_t fofs, block_t blkaddr, unsigned int len);
2526void init_extent_cache_info(struct f2fs_sb_info *sbi);
2433int __init create_extent_cache(void);
2434void destroy_extent_cache(void);
2435
2436/*
2437 * crypto support
2438 */
2439static inline bool f2fs_encrypted_inode(struct inode *inode)
2440{

--- 97 unchanged lines hidden --- 		2527int __init create_extent_cache(void);
2528void destroy_extent_cache(void);
2529
2530/*
2531 * crypto support
2532 */
2533static inline bool f2fs_encrypted_inode(struct inode *inode)
2534{

--- 97 unchanged lines hidden ---