Linux 3.12.28
[linux/fpc-iii.git] / fs / f2fs / f2fs.h
blob608f0df5b9190f8e8b301dd61e085fa70c66c5db
1 /*
2 * fs/f2fs/f2fs.h
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
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.
11 #ifndef _LINUX_F2FS_H
12 #define _LINUX_F2FS_H
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>
23 * For mount options
25 #define F2FS_MOUNT_BG_GC 0x00000001
26 #define F2FS_MOUNT_DISABLE_ROLL_FORWARD 0x00000002
27 #define F2FS_MOUNT_DISCARD 0x00000004
28 #define F2FS_MOUNT_NOHEAP 0x00000008
29 #define F2FS_MOUNT_XATTR_USER 0x00000010
30 #define F2FS_MOUNT_POSIX_ACL 0x00000020
31 #define F2FS_MOUNT_DISABLE_EXT_IDENTIFY 0x00000040
32 #define F2FS_MOUNT_INLINE_XATTR 0x00000080
34 #define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
35 #define set_opt(sbi, option) (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
36 #define test_opt(sbi, option) (sbi->mount_opt.opt & F2FS_MOUNT_##option)
38 #define ver_after(a, b) (typecheck(unsigned long long, a) && \
39 typecheck(unsigned long long, b) && \
40 ((long long)((a) - (b)) > 0))
42 typedef u32 block_t; /*
43 * should not change u32, since it is the on-disk block
44 * address format, __le32.
46 typedef u32 nid_t;
48 struct f2fs_mount_info {
49 unsigned int opt;
52 #define CRCPOLY_LE 0xedb88320
54 static inline __u32 f2fs_crc32(void *buf, size_t len)
56 unsigned char *p = (unsigned char *)buf;
57 __u32 crc = F2FS_SUPER_MAGIC;
58 int i;
60 while (len--) {
61 crc ^= *p++;
62 for (i = 0; i < 8; i++)
63 crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
65 return crc;
68 static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size)
70 return f2fs_crc32(buf, buf_size) == blk_crc;
74 * For checkpoint manager
76 enum {
77 NAT_BITMAP,
78 SIT_BITMAP
81 /* for the list of orphan inodes */
82 struct orphan_inode_entry {
83 struct list_head list; /* list head */
84 nid_t ino; /* inode number */
87 /* for the list of directory inodes */
88 struct dir_inode_entry {
89 struct list_head list; /* list head */
90 struct inode *inode; /* vfs inode pointer */
93 /* for the list of fsync inodes, used only during recovery */
94 struct fsync_inode_entry {
95 struct list_head list; /* list head */
96 struct inode *inode; /* vfs inode pointer */
97 block_t blkaddr; /* block address locating the last inode */
100 #define nats_in_cursum(sum) (le16_to_cpu(sum->n_nats))
101 #define sits_in_cursum(sum) (le16_to_cpu(sum->n_sits))
103 #define nat_in_journal(sum, i) (sum->nat_j.entries[i].ne)
104 #define nid_in_journal(sum, i) (sum->nat_j.entries[i].nid)
105 #define sit_in_journal(sum, i) (sum->sit_j.entries[i].se)
106 #define segno_in_journal(sum, i) (sum->sit_j.entries[i].segno)
108 static inline int update_nats_in_cursum(struct f2fs_summary_block *rs, int i)
110 int before = nats_in_cursum(rs);
111 rs->n_nats = cpu_to_le16(before + i);
112 return before;
115 static inline int update_sits_in_cursum(struct f2fs_summary_block *rs, int i)
117 int before = sits_in_cursum(rs);
118 rs->n_sits = cpu_to_le16(before + i);
119 return before;
123 * ioctl commands
125 #define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS
126 #define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS
128 #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
130 * ioctl commands in 32 bit emulation
132 #define F2FS_IOC32_GETFLAGS FS_IOC32_GETFLAGS
133 #define F2FS_IOC32_SETFLAGS FS_IOC32_SETFLAGS
134 #endif
137 * For INODE and NODE manager
140 * XATTR_NODE_OFFSET stores xattrs to one node block per file keeping -1
141 * as its node offset to distinguish from index node blocks.
142 * But some bits are used to mark the node block.
144 #define XATTR_NODE_OFFSET ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
145 >> OFFSET_BIT_SHIFT)
146 enum {
147 ALLOC_NODE, /* allocate a new node page if needed */
148 LOOKUP_NODE, /* look up a node without readahead */
149 LOOKUP_NODE_RA, /*
150 * look up a node with readahead called
151 * by get_datablock_ro.
155 #define F2FS_LINK_MAX 32000 /* maximum link count per file */
157 /* for in-memory extent cache entry */
158 struct extent_info {
159 rwlock_t ext_lock; /* rwlock for consistency */
160 unsigned int fofs; /* start offset in a file */
161 u32 blk_addr; /* start block address of the extent */
162 unsigned int len; /* length of the extent */
166 * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
168 #define FADVISE_COLD_BIT 0x01
169 #define FADVISE_LOST_PINO_BIT 0x02
171 struct f2fs_inode_info {
172 struct inode vfs_inode; /* serve a vfs inode */
173 unsigned long i_flags; /* keep an inode flags for ioctl */
174 unsigned char i_advise; /* use to give file attribute hints */
175 unsigned int i_current_depth; /* use only in directory structure */
176 unsigned int i_pino; /* parent inode number */
177 umode_t i_acl_mode; /* keep file acl mode temporarily */
179 /* Use below internally in f2fs*/
180 unsigned long flags; /* use to pass per-file flags */
181 atomic_t dirty_dents; /* # of dirty dentry pages */
182 f2fs_hash_t chash; /* hash value of given file name */
183 unsigned int clevel; /* maximum level of given file name */
184 nid_t i_xattr_nid; /* node id that contains xattrs */
185 unsigned long long xattr_ver; /* cp version of xattr modification */
186 struct extent_info ext; /* in-memory extent cache entry */
189 static inline void get_extent_info(struct extent_info *ext,
190 struct f2fs_extent i_ext)
192 write_lock(&ext->ext_lock);
193 ext->fofs = le32_to_cpu(i_ext.fofs);
194 ext->blk_addr = le32_to_cpu(i_ext.blk_addr);
195 ext->len = le32_to_cpu(i_ext.len);
196 write_unlock(&ext->ext_lock);
199 static inline void set_raw_extent(struct extent_info *ext,
200 struct f2fs_extent *i_ext)
202 read_lock(&ext->ext_lock);
203 i_ext->fofs = cpu_to_le32(ext->fofs);
204 i_ext->blk_addr = cpu_to_le32(ext->blk_addr);
205 i_ext->len = cpu_to_le32(ext->len);
206 read_unlock(&ext->ext_lock);
209 struct f2fs_nm_info {
210 block_t nat_blkaddr; /* base disk address of NAT */
211 nid_t max_nid; /* maximum possible node ids */
212 nid_t next_scan_nid; /* the next nid to be scanned */
214 /* NAT cache management */
215 struct radix_tree_root nat_root;/* root of the nat entry cache */
216 rwlock_t nat_tree_lock; /* protect nat_tree_lock */
217 unsigned int nat_cnt; /* the # of cached nat entries */
218 struct list_head nat_entries; /* cached nat entry list (clean) */
219 struct list_head dirty_nat_entries; /* cached nat entry list (dirty) */
221 /* free node ids management */
222 struct list_head free_nid_list; /* a list for free nids */
223 spinlock_t free_nid_list_lock; /* protect free nid list */
224 unsigned int fcnt; /* the number of free node id */
225 struct mutex build_lock; /* lock for build free nids */
227 /* for checkpoint */
228 char *nat_bitmap; /* NAT bitmap pointer */
229 int bitmap_size; /* bitmap size */
233 * this structure is used as one of function parameters.
234 * all the information are dedicated to a given direct node block determined
235 * by the data offset in a file.
237 struct dnode_of_data {
238 struct inode *inode; /* vfs inode pointer */
239 struct page *inode_page; /* its inode page, NULL is possible */
240 struct page *node_page; /* cached direct node page */
241 nid_t nid; /* node id of the direct node block */
242 unsigned int ofs_in_node; /* data offset in the node page */
243 bool inode_page_locked; /* inode page is locked or not */
244 block_t data_blkaddr; /* block address of the node block */
247 static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
248 struct page *ipage, struct page *npage, nid_t nid)
250 memset(dn, 0, sizeof(*dn));
251 dn->inode = inode;
252 dn->inode_page = ipage;
253 dn->node_page = npage;
254 dn->nid = nid;
258 * For SIT manager
260 * By default, there are 6 active log areas across the whole main area.
261 * When considering hot and cold data separation to reduce cleaning overhead,
262 * we split 3 for data logs and 3 for node logs as hot, warm, and cold types,
263 * respectively.
264 * In the current design, you should not change the numbers intentionally.
265 * Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6
266 * logs individually according to the underlying devices. (default: 6)
267 * Just in case, on-disk layout covers maximum 16 logs that consist of 8 for
268 * data and 8 for node logs.
270 #define NR_CURSEG_DATA_TYPE (3)
271 #define NR_CURSEG_NODE_TYPE (3)
272 #define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
274 enum {
275 CURSEG_HOT_DATA = 0, /* directory entry blocks */
276 CURSEG_WARM_DATA, /* data blocks */
277 CURSEG_COLD_DATA, /* multimedia or GCed data blocks */
278 CURSEG_HOT_NODE, /* direct node blocks of directory files */
279 CURSEG_WARM_NODE, /* direct node blocks of normal files */
280 CURSEG_COLD_NODE, /* indirect node blocks */
281 NO_CHECK_TYPE
284 struct f2fs_sm_info {
285 struct sit_info *sit_info; /* whole segment information */
286 struct free_segmap_info *free_info; /* free segment information */
287 struct dirty_seglist_info *dirty_info; /* dirty segment information */
288 struct curseg_info *curseg_array; /* active segment information */
290 struct list_head wblist_head; /* list of under-writeback pages */
291 spinlock_t wblist_lock; /* lock for checkpoint */
293 block_t seg0_blkaddr; /* block address of 0'th segment */
294 block_t main_blkaddr; /* start block address of main area */
295 block_t ssa_blkaddr; /* start block address of SSA area */
297 unsigned int segment_count; /* total # of segments */
298 unsigned int main_segments; /* # of segments in main area */
299 unsigned int reserved_segments; /* # of reserved segments */
300 unsigned int ovp_segments; /* # of overprovision segments */
304 * For superblock
307 * COUNT_TYPE for monitoring
309 * f2fs monitors the number of several block types such as on-writeback,
310 * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
312 enum count_type {
313 F2FS_WRITEBACK,
314 F2FS_DIRTY_DENTS,
315 F2FS_DIRTY_NODES,
316 F2FS_DIRTY_META,
317 NR_COUNT_TYPE,
321 * Uses as sbi->fs_lock[NR_GLOBAL_LOCKS].
322 * The checkpoint procedure blocks all the locks in this fs_lock array.
323 * Some FS operations grab free locks, and if there is no free lock,
324 * then wait to grab a lock in a round-robin manner.
326 #define NR_GLOBAL_LOCKS 8
329 * The below are the page types of bios used in submti_bio().
330 * The available types are:
331 * DATA User data pages. It operates as async mode.
332 * NODE Node pages. It operates as async mode.
333 * META FS metadata pages such as SIT, NAT, CP.
334 * NR_PAGE_TYPE The number of page types.
335 * META_FLUSH Make sure the previous pages are written
336 * with waiting the bio's completion
337 * ... Only can be used with META.
339 enum page_type {
340 DATA,
341 NODE,
342 META,
343 NR_PAGE_TYPE,
344 META_FLUSH,
347 struct f2fs_sb_info {
348 struct super_block *sb; /* pointer to VFS super block */
349 struct proc_dir_entry *s_proc; /* proc entry */
350 struct buffer_head *raw_super_buf; /* buffer head of raw sb */
351 struct f2fs_super_block *raw_super; /* raw super block pointer */
352 int s_dirty; /* dirty flag for checkpoint */
354 /* for node-related operations */
355 struct f2fs_nm_info *nm_info; /* node manager */
356 struct inode *node_inode; /* cache node blocks */
358 /* for segment-related operations */
359 struct f2fs_sm_info *sm_info; /* segment manager */
360 struct bio *bio[NR_PAGE_TYPE]; /* bios to merge */
361 sector_t last_block_in_bio[NR_PAGE_TYPE]; /* last block number */
362 struct rw_semaphore bio_sem; /* IO semaphore */
364 /* for checkpoint */
365 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */
366 struct inode *meta_inode; /* cache meta blocks */
367 struct mutex cp_mutex; /* checkpoint procedure lock */
368 struct mutex fs_lock[NR_GLOBAL_LOCKS]; /* blocking FS operations */
369 struct mutex node_write; /* locking node writes */
370 struct mutex writepages; /* mutex for writepages() */
371 unsigned char next_lock_num; /* round-robin global locks */
372 int por_doing; /* recovery is doing or not */
373 int on_build_free_nids; /* build_free_nids is doing */
375 /* for orphan inode management */
376 struct list_head orphan_inode_list; /* orphan inode list */
377 struct mutex orphan_inode_mutex; /* for orphan inode list */
378 unsigned int n_orphans; /* # of orphan inodes */
380 /* for directory inode management */
381 struct list_head dir_inode_list; /* dir inode list */
382 spinlock_t dir_inode_lock; /* for dir inode list lock */
384 /* basic file system units */
385 unsigned int log_sectors_per_block; /* log2 sectors per block */
386 unsigned int log_blocksize; /* log2 block size */
387 unsigned int blocksize; /* block size */
388 unsigned int root_ino_num; /* root inode number*/
389 unsigned int node_ino_num; /* node inode number*/
390 unsigned int meta_ino_num; /* meta inode number*/
391 unsigned int log_blocks_per_seg; /* log2 blocks per segment */
392 unsigned int blocks_per_seg; /* blocks per segment */
393 unsigned int segs_per_sec; /* segments per section */
394 unsigned int secs_per_zone; /* sections per zone */
395 unsigned int total_sections; /* total section count */
396 unsigned int total_node_count; /* total node block count */
397 unsigned int total_valid_node_count; /* valid node block count */
398 unsigned int total_valid_inode_count; /* valid inode count */
399 int active_logs; /* # of active logs */
401 block_t user_block_count; /* # of user blocks */
402 block_t total_valid_block_count; /* # of valid blocks */
403 block_t alloc_valid_block_count; /* # of allocated blocks */
404 block_t last_valid_block_count; /* for recovery */
405 u32 s_next_generation; /* for NFS support */
406 atomic_t nr_pages[NR_COUNT_TYPE]; /* # of pages, see count_type */
408 struct f2fs_mount_info mount_opt; /* mount options */
410 /* for cleaning operations */
411 struct mutex gc_mutex; /* mutex for GC */
412 struct f2fs_gc_kthread *gc_thread; /* GC thread */
413 unsigned int cur_victim_sec; /* current victim section num */
416 * for stat information.
417 * one is for the LFS mode, and the other is for the SSR mode.
419 #ifdef CONFIG_F2FS_STAT_FS
420 struct f2fs_stat_info *stat_info; /* FS status information */
421 unsigned int segment_count[2]; /* # of allocated segments */
422 unsigned int block_count[2]; /* # of allocated blocks */
423 int total_hit_ext, read_hit_ext; /* extent cache hit ratio */
424 int bg_gc; /* background gc calls */
425 unsigned int n_dirty_dirs; /* # of dir inodes */
426 #endif
427 unsigned int last_victim[2]; /* last victim segment # */
428 spinlock_t stat_lock; /* lock for stat operations */
430 /* For sysfs suppport */
431 struct kobject s_kobj;
432 struct completion s_kobj_unregister;
436 * Inline functions
438 static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
440 return container_of(inode, struct f2fs_inode_info, vfs_inode);
443 static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
445 return sb->s_fs_info;
448 static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
450 return (struct f2fs_super_block *)(sbi->raw_super);
453 static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
455 return (struct f2fs_checkpoint *)(sbi->ckpt);
458 static inline struct f2fs_node *F2FS_NODE(struct page *page)
460 return (struct f2fs_node *)page_address(page);
463 static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
465 return (struct f2fs_nm_info *)(sbi->nm_info);
468 static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
470 return (struct f2fs_sm_info *)(sbi->sm_info);
473 static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
475 return (struct sit_info *)(SM_I(sbi)->sit_info);
478 static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
480 return (struct free_segmap_info *)(SM_I(sbi)->free_info);
483 static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
485 return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
488 static inline void F2FS_SET_SB_DIRT(struct f2fs_sb_info *sbi)
490 sbi->s_dirty = 1;
493 static inline void F2FS_RESET_SB_DIRT(struct f2fs_sb_info *sbi)
495 sbi->s_dirty = 0;
498 static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
500 return le64_to_cpu(cp->checkpoint_ver);
503 static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
505 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
506 return ckpt_flags & f;
509 static inline void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
511 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
512 ckpt_flags |= f;
513 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
516 static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
518 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
519 ckpt_flags &= (~f);
520 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
523 static inline void mutex_lock_all(struct f2fs_sb_info *sbi)
525 int i;
527 for (i = 0; i < NR_GLOBAL_LOCKS; i++) {
529 * This is the only time we take multiple fs_lock[]
530 * instances; the order is immaterial since we
531 * always hold cp_mutex, which serializes multiple
532 * such operations.
534 mutex_lock_nest_lock(&sbi->fs_lock[i], &sbi->cp_mutex);
538 static inline void mutex_unlock_all(struct f2fs_sb_info *sbi)
540 int i = 0;
541 for (; i < NR_GLOBAL_LOCKS; i++)
542 mutex_unlock(&sbi->fs_lock[i]);
545 static inline int mutex_lock_op(struct f2fs_sb_info *sbi)
547 unsigned char next_lock = sbi->next_lock_num % NR_GLOBAL_LOCKS;
548 int i = 0;
550 for (; i < NR_GLOBAL_LOCKS; i++)
551 if (mutex_trylock(&sbi->fs_lock[i]))
552 return i;
554 mutex_lock(&sbi->fs_lock[next_lock]);
555 sbi->next_lock_num++;
556 return next_lock;
559 static inline void mutex_unlock_op(struct f2fs_sb_info *sbi, int ilock)
561 if (ilock < 0)
562 return;
563 BUG_ON(ilock >= NR_GLOBAL_LOCKS);
564 mutex_unlock(&sbi->fs_lock[ilock]);
568 * Check whether the given nid is within node id range.
570 static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
572 WARN_ON((nid >= NM_I(sbi)->max_nid));
573 if (nid >= NM_I(sbi)->max_nid)
574 return -EINVAL;
575 return 0;
578 #define F2FS_DEFAULT_ALLOCATED_BLOCKS 1
581 * Check whether the inode has blocks or not
583 static inline int F2FS_HAS_BLOCKS(struct inode *inode)
585 if (F2FS_I(inode)->i_xattr_nid)
586 return (inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1);
587 else
588 return (inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS);
591 static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
592 struct inode *inode, blkcnt_t count)
594 block_t valid_block_count;
596 spin_lock(&sbi->stat_lock);
597 valid_block_count =
598 sbi->total_valid_block_count + (block_t)count;
599 if (valid_block_count > sbi->user_block_count) {
600 spin_unlock(&sbi->stat_lock);
601 return false;
603 inode->i_blocks += count;
604 sbi->total_valid_block_count = valid_block_count;
605 sbi->alloc_valid_block_count += (block_t)count;
606 spin_unlock(&sbi->stat_lock);
607 return true;
610 static inline int dec_valid_block_count(struct f2fs_sb_info *sbi,
611 struct inode *inode,
612 blkcnt_t count)
614 spin_lock(&sbi->stat_lock);
615 BUG_ON(sbi->total_valid_block_count < (block_t) count);
616 BUG_ON(inode->i_blocks < count);
617 inode->i_blocks -= count;
618 sbi->total_valid_block_count -= (block_t)count;
619 spin_unlock(&sbi->stat_lock);
620 return 0;
623 static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
625 atomic_inc(&sbi->nr_pages[count_type]);
626 F2FS_SET_SB_DIRT(sbi);
629 static inline void inode_inc_dirty_dents(struct inode *inode)
631 atomic_inc(&F2FS_I(inode)->dirty_dents);
634 static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
636 atomic_dec(&sbi->nr_pages[count_type]);
639 static inline void inode_dec_dirty_dents(struct inode *inode)
641 atomic_dec(&F2FS_I(inode)->dirty_dents);
644 static inline int get_pages(struct f2fs_sb_info *sbi, int count_type)
646 return atomic_read(&sbi->nr_pages[count_type]);
649 static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
651 unsigned int pages_per_sec = sbi->segs_per_sec *
652 (1 << sbi->log_blocks_per_seg);
653 return ((get_pages(sbi, block_type) + pages_per_sec - 1)
654 >> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
657 static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
659 block_t ret;
660 spin_lock(&sbi->stat_lock);
661 ret = sbi->total_valid_block_count;
662 spin_unlock(&sbi->stat_lock);
663 return ret;
666 static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
668 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
670 /* return NAT or SIT bitmap */
671 if (flag == NAT_BITMAP)
672 return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
673 else if (flag == SIT_BITMAP)
674 return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
676 return 0;
679 static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
681 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
682 int offset = (flag == NAT_BITMAP) ?
683 le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
684 return &ckpt->sit_nat_version_bitmap + offset;
687 static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
689 block_t start_addr;
690 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
691 unsigned long long ckpt_version = cur_cp_version(ckpt);
693 start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
696 * odd numbered checkpoint should at cp segment 0
697 * and even segent must be at cp segment 1
699 if (!(ckpt_version & 1))
700 start_addr += sbi->blocks_per_seg;
702 return start_addr;
705 static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
707 return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
710 static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi,
711 struct inode *inode,
712 unsigned int count)
714 block_t valid_block_count;
715 unsigned int valid_node_count;
717 spin_lock(&sbi->stat_lock);
719 valid_block_count = sbi->total_valid_block_count + (block_t)count;
720 sbi->alloc_valid_block_count += (block_t)count;
721 valid_node_count = sbi->total_valid_node_count + count;
723 if (valid_block_count > sbi->user_block_count) {
724 spin_unlock(&sbi->stat_lock);
725 return false;
728 if (valid_node_count > sbi->total_node_count) {
729 spin_unlock(&sbi->stat_lock);
730 return false;
733 if (inode)
734 inode->i_blocks += count;
735 sbi->total_valid_node_count = valid_node_count;
736 sbi->total_valid_block_count = valid_block_count;
737 spin_unlock(&sbi->stat_lock);
739 return true;
742 static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
743 struct inode *inode,
744 unsigned int count)
746 spin_lock(&sbi->stat_lock);
748 BUG_ON(sbi->total_valid_block_count < count);
749 BUG_ON(sbi->total_valid_node_count < count);
750 BUG_ON(inode->i_blocks < count);
752 inode->i_blocks -= count;
753 sbi->total_valid_node_count -= count;
754 sbi->total_valid_block_count -= (block_t)count;
756 spin_unlock(&sbi->stat_lock);
759 static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
761 unsigned int ret;
762 spin_lock(&sbi->stat_lock);
763 ret = sbi->total_valid_node_count;
764 spin_unlock(&sbi->stat_lock);
765 return ret;
768 static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
770 spin_lock(&sbi->stat_lock);
771 BUG_ON(sbi->total_valid_inode_count == sbi->total_node_count);
772 sbi->total_valid_inode_count++;
773 spin_unlock(&sbi->stat_lock);
776 static inline int dec_valid_inode_count(struct f2fs_sb_info *sbi)
778 spin_lock(&sbi->stat_lock);
779 BUG_ON(!sbi->total_valid_inode_count);
780 sbi->total_valid_inode_count--;
781 spin_unlock(&sbi->stat_lock);
782 return 0;
785 static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi)
787 unsigned int ret;
788 spin_lock(&sbi->stat_lock);
789 ret = sbi->total_valid_inode_count;
790 spin_unlock(&sbi->stat_lock);
791 return ret;
794 static inline void f2fs_put_page(struct page *page, int unlock)
796 if (!page || IS_ERR(page))
797 return;
799 if (unlock) {
800 BUG_ON(!PageLocked(page));
801 unlock_page(page);
803 page_cache_release(page);
806 static inline void f2fs_put_dnode(struct dnode_of_data *dn)
808 if (dn->node_page)
809 f2fs_put_page(dn->node_page, 1);
810 if (dn->inode_page && dn->node_page != dn->inode_page)
811 f2fs_put_page(dn->inode_page, 0);
812 dn->node_page = NULL;
813 dn->inode_page = NULL;
816 static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
817 size_t size, void (*ctor)(void *))
819 return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, ctor);
822 #define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
824 static inline bool IS_INODE(struct page *page)
826 struct f2fs_node *p = F2FS_NODE(page);
827 return RAW_IS_INODE(p);
830 static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
832 return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
835 static inline block_t datablock_addr(struct page *node_page,
836 unsigned int offset)
838 struct f2fs_node *raw_node;
839 __le32 *addr_array;
840 raw_node = F2FS_NODE(node_page);
841 addr_array = blkaddr_in_node(raw_node);
842 return le32_to_cpu(addr_array[offset]);
845 static inline int f2fs_test_bit(unsigned int nr, char *addr)
847 int mask;
849 addr += (nr >> 3);
850 mask = 1 << (7 - (nr & 0x07));
851 return mask & *addr;
854 static inline int f2fs_set_bit(unsigned int nr, char *addr)
856 int mask;
857 int ret;
859 addr += (nr >> 3);
860 mask = 1 << (7 - (nr & 0x07));
861 ret = mask & *addr;
862 *addr |= mask;
863 return ret;
866 static inline int f2fs_clear_bit(unsigned int nr, char *addr)
868 int mask;
869 int ret;
871 addr += (nr >> 3);
872 mask = 1 << (7 - (nr & 0x07));
873 ret = mask & *addr;
874 *addr &= ~mask;
875 return ret;
878 /* used for f2fs_inode_info->flags */
879 enum {
880 FI_NEW_INODE, /* indicate newly allocated inode */
881 FI_DIRTY_INODE, /* indicate inode is dirty or not */
882 FI_INC_LINK, /* need to increment i_nlink */
883 FI_ACL_MODE, /* indicate acl mode */
884 FI_NO_ALLOC, /* should not allocate any blocks */
885 FI_UPDATE_DIR, /* should update inode block for consistency */
886 FI_DELAY_IPUT, /* used for the recovery */
887 FI_INLINE_XATTR, /* used for inline xattr */
890 static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
892 set_bit(flag, &fi->flags);
895 static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag)
897 return test_bit(flag, &fi->flags);
900 static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag)
902 clear_bit(flag, &fi->flags);
905 static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode)
907 fi->i_acl_mode = mode;
908 set_inode_flag(fi, FI_ACL_MODE);
911 static inline int cond_clear_inode_flag(struct f2fs_inode_info *fi, int flag)
913 if (is_inode_flag_set(fi, FI_ACL_MODE)) {
914 clear_inode_flag(fi, FI_ACL_MODE);
915 return 1;
917 return 0;
920 static inline void get_inline_info(struct f2fs_inode_info *fi,
921 struct f2fs_inode *ri)
923 if (ri->i_inline & F2FS_INLINE_XATTR)
924 set_inode_flag(fi, FI_INLINE_XATTR);
927 static inline void set_raw_inline(struct f2fs_inode_info *fi,
928 struct f2fs_inode *ri)
930 ri->i_inline = 0;
932 if (is_inode_flag_set(fi, FI_INLINE_XATTR))
933 ri->i_inline |= F2FS_INLINE_XATTR;
936 static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi)
938 if (is_inode_flag_set(fi, FI_INLINE_XATTR))
939 return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
940 return DEF_ADDRS_PER_INODE;
943 static inline void *inline_xattr_addr(struct page *page)
945 struct f2fs_inode *ri;
946 ri = (struct f2fs_inode *)page_address(page);
947 return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
948 F2FS_INLINE_XATTR_ADDRS]);
951 static inline int inline_xattr_size(struct inode *inode)
953 if (is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR))
954 return F2FS_INLINE_XATTR_ADDRS << 2;
955 else
956 return 0;
959 static inline int f2fs_readonly(struct super_block *sb)
961 return sb->s_flags & MS_RDONLY;
965 * file.c
967 int f2fs_sync_file(struct file *, loff_t, loff_t, int);
968 void truncate_data_blocks(struct dnode_of_data *);
969 void f2fs_truncate(struct inode *);
970 int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
971 int f2fs_setattr(struct dentry *, struct iattr *);
972 int truncate_hole(struct inode *, pgoff_t, pgoff_t);
973 int truncate_data_blocks_range(struct dnode_of_data *, int);
974 long f2fs_ioctl(struct file *, unsigned int, unsigned long);
975 long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
978 * inode.c
980 void f2fs_set_inode_flags(struct inode *);
981 struct inode *f2fs_iget(struct super_block *, unsigned long);
982 void update_inode(struct inode *, struct page *);
983 int update_inode_page(struct inode *);
984 int f2fs_write_inode(struct inode *, struct writeback_control *);
985 void f2fs_evict_inode(struct inode *);
988 * namei.c
990 struct dentry *f2fs_get_parent(struct dentry *child);
993 * dir.c
995 struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *,
996 struct page **);
997 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
998 ino_t f2fs_inode_by_name(struct inode *, struct qstr *);
999 void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
1000 struct page *, struct inode *);
1001 int update_dent_inode(struct inode *, const struct qstr *);
1002 int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *);
1003 void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *);
1004 int f2fs_make_empty(struct inode *, struct inode *);
1005 bool f2fs_empty_dir(struct inode *);
1007 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
1009 return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name,
1010 inode);
1014 * super.c
1016 int f2fs_sync_fs(struct super_block *, int);
1017 extern __printf(3, 4)
1018 void f2fs_msg(struct super_block *, const char *, const char *, ...);
1021 * hash.c
1023 f2fs_hash_t f2fs_dentry_hash(const char *, size_t);
1026 * node.c
1028 struct dnode_of_data;
1029 struct node_info;
1031 int is_checkpointed_node(struct f2fs_sb_info *, nid_t);
1032 void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
1033 int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int);
1034 int truncate_inode_blocks(struct inode *, pgoff_t);
1035 int truncate_xattr_node(struct inode *, struct page *);
1036 int remove_inode_page(struct inode *);
1037 struct page *new_inode_page(struct inode *, const struct qstr *);
1038 struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
1039 void ra_node_page(struct f2fs_sb_info *, nid_t);
1040 struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
1041 struct page *get_node_page_ra(struct page *, int);
1042 void sync_inode_page(struct dnode_of_data *);
1043 int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *);
1044 bool alloc_nid(struct f2fs_sb_info *, nid_t *);
1045 void alloc_nid_done(struct f2fs_sb_info *, nid_t);
1046 void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
1047 void recover_node_page(struct f2fs_sb_info *, struct page *,
1048 struct f2fs_summary *, struct node_info *, block_t);
1049 int recover_inode_page(struct f2fs_sb_info *, struct page *);
1050 int restore_node_summary(struct f2fs_sb_info *, unsigned int,
1051 struct f2fs_summary_block *);
1052 void flush_nat_entries(struct f2fs_sb_info *);
1053 int build_node_manager(struct f2fs_sb_info *);
1054 void destroy_node_manager(struct f2fs_sb_info *);
1055 int __init create_node_manager_caches(void);
1056 void destroy_node_manager_caches(void);
1059 * segment.c
1061 void f2fs_balance_fs(struct f2fs_sb_info *);
1062 void invalidate_blocks(struct f2fs_sb_info *, block_t);
1063 void clear_prefree_segments(struct f2fs_sb_info *);
1064 int npages_for_summary_flush(struct f2fs_sb_info *);
1065 void allocate_new_segments(struct f2fs_sb_info *);
1066 struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
1067 struct bio *f2fs_bio_alloc(struct block_device *, int);
1068 void f2fs_submit_bio(struct f2fs_sb_info *, enum page_type, bool);
1069 void f2fs_wait_on_page_writeback(struct page *, enum page_type, bool);
1070 void write_meta_page(struct f2fs_sb_info *, struct page *);
1071 void write_node_page(struct f2fs_sb_info *, struct page *, unsigned int,
1072 block_t, block_t *);
1073 void write_data_page(struct inode *, struct page *, struct dnode_of_data*,
1074 block_t, block_t *);
1075 void rewrite_data_page(struct f2fs_sb_info *, struct page *, block_t);
1076 void recover_data_page(struct f2fs_sb_info *, struct page *,
1077 struct f2fs_summary *, block_t, block_t);
1078 void rewrite_node_page(struct f2fs_sb_info *, struct page *,
1079 struct f2fs_summary *, block_t, block_t);
1080 void write_data_summaries(struct f2fs_sb_info *, block_t);
1081 void write_node_summaries(struct f2fs_sb_info *, block_t);
1082 int lookup_journal_in_cursum(struct f2fs_summary_block *,
1083 int, unsigned int, int);
1084 void flush_sit_entries(struct f2fs_sb_info *);
1085 int build_segment_manager(struct f2fs_sb_info *);
1086 void destroy_segment_manager(struct f2fs_sb_info *);
1089 * checkpoint.c
1091 struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
1092 struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
1093 long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
1094 int acquire_orphan_inode(struct f2fs_sb_info *);
1095 void release_orphan_inode(struct f2fs_sb_info *);
1096 void add_orphan_inode(struct f2fs_sb_info *, nid_t);
1097 void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
1098 int recover_orphan_inodes(struct f2fs_sb_info *);
1099 int get_valid_checkpoint(struct f2fs_sb_info *);
1100 void set_dirty_dir_page(struct inode *, struct page *);
1101 void add_dirty_dir_inode(struct inode *);
1102 void remove_dirty_dir_inode(struct inode *);
1103 struct inode *check_dirty_dir_inode(struct f2fs_sb_info *, nid_t);
1104 void sync_dirty_dir_inodes(struct f2fs_sb_info *);
1105 void write_checkpoint(struct f2fs_sb_info *, bool);
1106 void init_orphan_info(struct f2fs_sb_info *);
1107 int __init create_checkpoint_caches(void);
1108 void destroy_checkpoint_caches(void);
1111 * data.c
1113 int reserve_new_block(struct dnode_of_data *);
1114 void update_extent_cache(block_t, struct dnode_of_data *);
1115 struct page *find_data_page(struct inode *, pgoff_t, bool);
1116 struct page *get_lock_data_page(struct inode *, pgoff_t);
1117 struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
1118 int f2fs_readpage(struct f2fs_sb_info *, struct page *, block_t, int);
1119 int do_write_data_page(struct page *);
1122 * gc.c
1124 int start_gc_thread(struct f2fs_sb_info *);
1125 void stop_gc_thread(struct f2fs_sb_info *);
1126 block_t start_bidx_of_node(unsigned int, struct f2fs_inode_info *);
1127 int f2fs_gc(struct f2fs_sb_info *);
1128 void build_gc_manager(struct f2fs_sb_info *);
1129 int __init create_gc_caches(void);
1130 void destroy_gc_caches(void);
1133 * recovery.c
1135 int recover_fsync_data(struct f2fs_sb_info *);
1136 bool space_for_roll_forward(struct f2fs_sb_info *);
1139 * debug.c
1141 #ifdef CONFIG_F2FS_STAT_FS
1142 struct f2fs_stat_info {
1143 struct list_head stat_list;
1144 struct f2fs_sb_info *sbi;
1145 struct mutex stat_lock;
1146 int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
1147 int main_area_segs, main_area_sections, main_area_zones;
1148 int hit_ext, total_ext;
1149 int ndirty_node, ndirty_dent, ndirty_dirs, ndirty_meta;
1150 int nats, sits, fnids;
1151 int total_count, utilization;
1152 int bg_gc;
1153 unsigned int valid_count, valid_node_count, valid_inode_count;
1154 unsigned int bimodal, avg_vblocks;
1155 int util_free, util_valid, util_invalid;
1156 int rsvd_segs, overp_segs;
1157 int dirty_count, node_pages, meta_pages;
1158 int prefree_count, call_count;
1159 int tot_segs, node_segs, data_segs, free_segs, free_secs;
1160 int tot_blks, data_blks, node_blks;
1161 int curseg[NR_CURSEG_TYPE];
1162 int cursec[NR_CURSEG_TYPE];
1163 int curzone[NR_CURSEG_TYPE];
1165 unsigned int segment_count[2];
1166 unsigned int block_count[2];
1167 unsigned base_mem, cache_mem;
1170 static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
1172 return (struct f2fs_stat_info*)sbi->stat_info;
1175 #define stat_inc_call_count(si) ((si)->call_count++)
1177 #define stat_inc_seg_count(sbi, type) \
1178 do { \
1179 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
1180 (si)->tot_segs++; \
1181 if (type == SUM_TYPE_DATA) \
1182 si->data_segs++; \
1183 else \
1184 si->node_segs++; \
1185 } while (0)
1187 #define stat_inc_tot_blk_count(si, blks) \
1188 (si->tot_blks += (blks))
1190 #define stat_inc_data_blk_count(sbi, blks) \
1191 do { \
1192 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
1193 stat_inc_tot_blk_count(si, blks); \
1194 si->data_blks += (blks); \
1195 } while (0)
1197 #define stat_inc_node_blk_count(sbi, blks) \
1198 do { \
1199 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
1200 stat_inc_tot_blk_count(si, blks); \
1201 si->node_blks += (blks); \
1202 } while (0)
1204 int f2fs_build_stats(struct f2fs_sb_info *);
1205 void f2fs_destroy_stats(struct f2fs_sb_info *);
1206 void __init f2fs_create_root_stats(void);
1207 void f2fs_destroy_root_stats(void);
1208 #else
1209 #define stat_inc_call_count(si)
1210 #define stat_inc_seg_count(si, type)
1211 #define stat_inc_tot_blk_count(si, blks)
1212 #define stat_inc_data_blk_count(si, blks)
1213 #define stat_inc_node_blk_count(sbi, blks)
1215 static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
1216 static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
1217 static inline void __init f2fs_create_root_stats(void) { }
1218 static inline void f2fs_destroy_root_stats(void) { }
1219 #endif
1221 extern const struct file_operations f2fs_dir_operations;
1222 extern const struct file_operations f2fs_file_operations;
1223 extern const struct inode_operations f2fs_file_inode_operations;
1224 extern const struct address_space_operations f2fs_dblock_aops;
1225 extern const struct address_space_operations f2fs_node_aops;
1226 extern const struct address_space_operations f2fs_meta_aops;
1227 extern const struct inode_operations f2fs_dir_inode_operations;
1228 extern const struct inode_operations f2fs_symlink_inode_operations;
1229 extern const struct inode_operations f2fs_special_inode_operations;
1230 #endif