f2fs.h 49.7 KB
Newer Older
J
Jaegeuk Kim 已提交
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 * fs/f2fs/f2fs.h
 *
 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
 *             http://www.samsung.com/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#ifndef _LINUX_F2FS_H
#define _LINUX_F2FS_H

#include <linux/types.h>
#include <linux/page-flags.h>
#include <linux/buffer_head.h>
#include <linux/slab.h>
#include <linux/crc32.h>
#include <linux/magic.h>
20
#include <linux/kobject.h>
21
#include <linux/sched.h>
22

23
#ifdef CONFIG_F2FS_CHECK_FS
24
#define f2fs_bug_on(sbi, condition)	BUG_ON(condition)
J
Jaegeuk Kim 已提交
25
#define f2fs_down_write(x, y)	down_write_nest_lock(x, y)
26
#else
27 28 29 30 31 32 33
#define f2fs_bug_on(sbi, condition)					\
	do {								\
		if (unlikely(condition)) {				\
			WARN_ON(1);					\
			sbi->need_fsck = true;				\
		}							\
	} while (0)
J
Jaegeuk Kim 已提交
34
#define f2fs_down_write(x, y)	down_write(x)
35 36
#endif

37 38 39 40 41 42 43 44 45 46
/*
 * For mount options
 */
#define F2FS_MOUNT_BG_GC		0x00000001
#define F2FS_MOUNT_DISABLE_ROLL_FORWARD	0x00000002
#define F2FS_MOUNT_DISCARD		0x00000004
#define F2FS_MOUNT_NOHEAP		0x00000008
#define F2FS_MOUNT_XATTR_USER		0x00000010
#define F2FS_MOUNT_POSIX_ACL		0x00000020
#define F2FS_MOUNT_DISABLE_EXT_IDENTIFY	0x00000040
J
Jaegeuk Kim 已提交
47
#define F2FS_MOUNT_INLINE_XATTR		0x00000080
48
#define F2FS_MOUNT_INLINE_DATA		0x00000100
49 50 51
#define F2FS_MOUNT_INLINE_DENTRY	0x00000200
#define F2FS_MOUNT_FLUSH_MERGE		0x00000400
#define F2FS_MOUNT_NOBARRIER		0x00000800
52
#define F2FS_MOUNT_FASTBOOT		0x00001000
53 54 55 56 57 58 59 60 61

#define clear_opt(sbi, option)	(sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
#define set_opt(sbi, option)	(sbi->mount_opt.opt |= F2FS_MOUNT_##option)
#define test_opt(sbi, option)	(sbi->mount_opt.opt & F2FS_MOUNT_##option)

#define ver_after(a, b)	(typecheck(unsigned long long, a) &&		\
		typecheck(unsigned long long, b) &&			\
		((long long)((a) - (b)) > 0))

62 63 64 65
typedef u32 block_t;	/*
			 * should not change u32, since it is the on-disk block
			 * address format, __le32.
			 */
66 67 68 69 70 71
typedef u32 nid_t;

struct f2fs_mount_info {
	unsigned int	opt;
};

J
Jaegeuk Kim 已提交
72 73 74
#define CRCPOLY_LE 0xedb88320

static inline __u32 f2fs_crc32(void *buf, size_t len)
75
{
J
Jaegeuk Kim 已提交
76 77 78 79 80 81 82 83 84 85
	unsigned char *p = (unsigned char *)buf;
	__u32 crc = F2FS_SUPER_MAGIC;
	int i;

	while (len--) {
		crc ^= *p++;
		for (i = 0; i < 8; i++)
			crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
	}
	return crc;
86 87
}

J
Jaegeuk Kim 已提交
88
static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size)
89
{
J
Jaegeuk Kim 已提交
90
	return f2fs_crc32(buf, buf_size) == blk_crc;
91 92 93 94 95 96 97 98 99 100
}

/*
 * For checkpoint manager
 */
enum {
	NAT_BITMAP,
	SIT_BITMAP
};

101 102 103
enum {
	CP_UMOUNT,
	CP_SYNC,
104
	CP_DISCARD,
105 106 107 108
};

struct cp_control {
	int reason;
109 110 111 112
	__u64 trim_start;
	__u64 trim_end;
	__u64 trim_minlen;
	__u64 trimmed;
113 114
};

115
/*
116
 * For CP/NAT/SIT/SSA readahead
117 118 119 120
 */
enum {
	META_CP,
	META_NAT,
121
	META_SIT,
122 123
	META_SSA,
	META_POR,
124 125
};

J
Jaegeuk Kim 已提交
126 127 128
/* for the list of ino */
enum {
	ORPHAN_INO,		/* for orphan ino list */
129 130
	APPEND_INO,		/* for append ino list */
	UPDATE_INO,		/* for update ino list */
J
Jaegeuk Kim 已提交
131 132 133 134
	MAX_INO_ENTRY,		/* max. list */
};

struct ino_entry {
135 136 137 138 139 140 141 142 143 144
	struct list_head list;	/* list head */
	nid_t ino;		/* inode number */
};

/* for the list of directory inodes */
struct dir_inode_entry {
	struct list_head list;	/* list head */
	struct inode *inode;	/* vfs inode pointer */
};

145 146 147 148 149 150 151
/* for the list of blockaddresses to be discarded */
struct discard_entry {
	struct list_head list;	/* list head */
	block_t blkaddr;	/* block address to be discarded */
	int len;		/* # of consecutive blocks of the discard */
};

152 153 154 155
/* for the list of fsync inodes, used only during recovery */
struct fsync_inode_entry {
	struct list_head list;	/* list head */
	struct inode *inode;	/* vfs inode pointer */
156 157 158
	block_t blkaddr;	/* block address locating the last fsync */
	block_t last_dentry;	/* block address locating the last dentry */
	block_t last_inode;	/* block address locating the last inode */
159 160 161 162 163 164 165 166 167 168
};

#define nats_in_cursum(sum)		(le16_to_cpu(sum->n_nats))
#define sits_in_cursum(sum)		(le16_to_cpu(sum->n_sits))

#define nat_in_journal(sum, i)		(sum->nat_j.entries[i].ne)
#define nid_in_journal(sum, i)		(sum->nat_j.entries[i].nid)
#define sit_in_journal(sum, i)		(sum->sit_j.entries[i].se)
#define segno_in_journal(sum, i)	(sum->sit_j.entries[i].segno)

169 170 171
#define MAX_NAT_JENTRIES(sum)	(NAT_JOURNAL_ENTRIES - nats_in_cursum(sum))
#define MAX_SIT_JENTRIES(sum)	(SIT_JOURNAL_ENTRIES - sits_in_cursum(sum))

172 173 174 175 176 177 178 179 180 181 182 183 184 185
static inline int update_nats_in_cursum(struct f2fs_summary_block *rs, int i)
{
	int before = nats_in_cursum(rs);
	rs->n_nats = cpu_to_le16(before + i);
	return before;
}

static inline int update_sits_in_cursum(struct f2fs_summary_block *rs, int i)
{
	int before = sits_in_cursum(rs);
	rs->n_sits = cpu_to_le16(before + i);
	return before;
}

186 187 188 189
static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,
								int type)
{
	if (type == NAT_JOURNAL)
190 191
		return size <= MAX_NAT_JENTRIES(sum);
	return size <= MAX_SIT_JENTRIES(sum);
192 193
}

194 195 196
/*
 * ioctl commands
 */
J
Jaegeuk Kim 已提交
197 198 199 200 201 202
#define F2FS_IOC_GETFLAGS		FS_IOC_GETFLAGS
#define F2FS_IOC_SETFLAGS		FS_IOC_SETFLAGS

#define F2FS_IOCTL_MAGIC		0xf5
#define F2FS_IOC_START_ATOMIC_WRITE	_IO(F2FS_IOCTL_MAGIC, 1)
#define F2FS_IOC_COMMIT_ATOMIC_WRITE	_IO(F2FS_IOCTL_MAGIC, 2)
203
#define F2FS_IOC_START_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 3)
204 205
#define F2FS_IOC_RELEASE_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 4)
#define F2FS_IOC_ABORT_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 5)
206 207 208 209 210 211 212 213 214

#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
/*
 * ioctl commands in 32 bit emulation
 */
#define F2FS_IOC32_GETFLAGS             FS_IOC32_GETFLAGS
#define F2FS_IOC32_SETFLAGS             FS_IOC32_SETFLAGS
#endif

215 216 217
/*
 * For INODE and NODE manager
 */
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
/* for directory operations */
struct f2fs_dentry_ptr {
	const void *bitmap;
	struct f2fs_dir_entry *dentry;
	__u8 (*filename)[F2FS_SLOT_LEN];
	int max;
};

static inline void make_dentry_ptr(struct f2fs_dentry_ptr *d,
					void *src, int type)
{
	if (type == 1) {
		struct f2fs_dentry_block *t = (struct f2fs_dentry_block *)src;
		d->max = NR_DENTRY_IN_BLOCK;
		d->bitmap = &t->dentry_bitmap;
		d->dentry = t->dentry;
		d->filename = t->filename;
	} else {
		struct f2fs_inline_dentry *t = (struct f2fs_inline_dentry *)src;
		d->max = NR_INLINE_DENTRY;
		d->bitmap = &t->dentry_bitmap;
		d->dentry = t->dentry;
		d->filename = t->filename;
	}
}

244 245 246 247 248 249 250
/*
 * XATTR_NODE_OFFSET stores xattrs to one node block per file keeping -1
 * as its node offset to distinguish from index node blocks.
 * But some bits are used to mark the node block.
 */
#define XATTR_NODE_OFFSET	((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
				>> OFFSET_BIT_SHIFT)
251 252 253 254 255
enum {
	ALLOC_NODE,			/* allocate a new node page if needed */
	LOOKUP_NODE,			/* look up a node without readahead */
	LOOKUP_NODE_RA,			/*
					 * look up a node with readahead called
C
Chao Yu 已提交
256
					 * by get_data_block.
257
					 */
258 259
};

260 261
#define F2FS_LINK_MAX		32000	/* maximum link count per file */

262 263
#define MAX_DIR_RA_PAGES	4	/* maximum ra pages of dir */

264
/* for in-memory extent cache entry */
265 266
#define F2FS_MIN_EXTENT_LEN	16	/* minimum extent length */

267 268 269 270
struct extent_info {
	rwlock_t ext_lock;	/* rwlock for consistency */
	unsigned int fofs;	/* start offset in a file */
	u32 blk_addr;		/* start block address of the extent */
M
Masanari Iida 已提交
271
	unsigned int len;	/* length of the extent */
272 273 274 275 276 277
};

/*
 * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
 */
#define FADVISE_COLD_BIT	0x01
278
#define FADVISE_LOST_PINO_BIT	0x02
279

280 281
#define DEF_DIR_LEVEL		0

282 283 284 285
struct f2fs_inode_info {
	struct inode vfs_inode;		/* serve a vfs inode */
	unsigned long i_flags;		/* keep an inode flags for ioctl */
	unsigned char i_advise;		/* use to give file attribute hints */
286
	unsigned char i_dir_level;	/* use for dentry level for large dir */
287
	unsigned int i_current_depth;	/* use only in directory structure */
288
	unsigned int i_pino;		/* parent inode number */
289 290 291 292
	umode_t i_acl_mode;		/* keep file acl mode temporarily */

	/* Use below internally in f2fs*/
	unsigned long flags;		/* use to pass per-file flags */
293
	struct rw_semaphore i_sem;	/* protect fi info */
294
	atomic_t dirty_pages;		/* # of dirty pages */
295 296 297
	f2fs_hash_t chash;		/* hash value of given file name */
	unsigned int clevel;		/* maximum level of given file name */
	nid_t i_xattr_nid;		/* node id that contains xattrs */
298
	unsigned long long xattr_ver;	/* cp version of xattr modification */
299
	struct extent_info ext;		/* in-memory extent cache entry */
300
	struct dir_inode_entry *dirty_dir;	/* the pointer of dirty dir */
J
Jaegeuk Kim 已提交
301

302
	struct radix_tree_root inmem_root;	/* radix tree for inmem pages */
J
Jaegeuk Kim 已提交
303 304
	struct list_head inmem_pages;	/* inmemory pages managed by f2fs */
	struct mutex inmem_lock;	/* lock for inmemory pages */
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
};

static inline void get_extent_info(struct extent_info *ext,
					struct f2fs_extent i_ext)
{
	write_lock(&ext->ext_lock);
	ext->fofs = le32_to_cpu(i_ext.fofs);
	ext->blk_addr = le32_to_cpu(i_ext.blk_addr);
	ext->len = le32_to_cpu(i_ext.len);
	write_unlock(&ext->ext_lock);
}

static inline void set_raw_extent(struct extent_info *ext,
					struct f2fs_extent *i_ext)
{
	read_lock(&ext->ext_lock);
	i_ext->fofs = cpu_to_le32(ext->fofs);
	i_ext->blk_addr = cpu_to_le32(ext->blk_addr);
	i_ext->len = cpu_to_le32(ext->len);
	read_unlock(&ext->ext_lock);
}

struct f2fs_nm_info {
	block_t nat_blkaddr;		/* base disk address of NAT */
	nid_t max_nid;			/* maximum possible node ids */
330
	nid_t available_nids;		/* maximum available node ids */
331
	nid_t next_scan_nid;		/* the next nid to be scanned */
332
	unsigned int ram_thresh;	/* control the memory footprint */
333 334 335

	/* NAT cache management */
	struct radix_tree_root nat_root;/* root of the nat entry cache */
336
	struct radix_tree_root nat_set_root;/* root of the nat set cache */
337
	struct rw_semaphore nat_tree_lock;	/* protect nat_tree_lock */
338
	struct list_head nat_entries;	/* cached nat entry list (clean) */
339
	unsigned int nat_cnt;		/* the # of cached nat entries */
340
	unsigned int dirty_nat_cnt;	/* total num of nat entries in set */
341 342

	/* free node ids management */
343
	struct radix_tree_root free_nid_root;/* root of the free_nid cache */
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
	struct list_head free_nid_list;	/* a list for free nids */
	spinlock_t free_nid_list_lock;	/* protect free nid list */
	unsigned int fcnt;		/* the number of free node id */
	struct mutex build_lock;	/* lock for build free nids */

	/* for checkpoint */
	char *nat_bitmap;		/* NAT bitmap pointer */
	int bitmap_size;		/* bitmap size */
};

/*
 * this structure is used as one of function parameters.
 * all the information are dedicated to a given direct node block determined
 * by the data offset in a file.
 */
struct dnode_of_data {
	struct inode *inode;		/* vfs inode pointer */
	struct page *inode_page;	/* its inode page, NULL is possible */
	struct page *node_page;		/* cached direct node page */
	nid_t nid;			/* node id of the direct node block */
	unsigned int ofs_in_node;	/* data offset in the node page */
	bool inode_page_locked;		/* inode page is locked or not */
	block_t	data_blkaddr;		/* block address of the node block */
};

static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
		struct page *ipage, struct page *npage, nid_t nid)
{
372
	memset(dn, 0, sizeof(*dn));
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
	dn->inode = inode;
	dn->inode_page = ipage;
	dn->node_page = npage;
	dn->nid = nid;
}

/*
 * For SIT manager
 *
 * By default, there are 6 active log areas across the whole main area.
 * When considering hot and cold data separation to reduce cleaning overhead,
 * we split 3 for data logs and 3 for node logs as hot, warm, and cold types,
 * respectively.
 * In the current design, you should not change the numbers intentionally.
 * Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6
 * logs individually according to the underlying devices. (default: 6)
 * Just in case, on-disk layout covers maximum 16 logs that consist of 8 for
 * data and 8 for node logs.
 */
#define	NR_CURSEG_DATA_TYPE	(3)
#define NR_CURSEG_NODE_TYPE	(3)
#define NR_CURSEG_TYPE	(NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)

enum {
	CURSEG_HOT_DATA	= 0,	/* directory entry blocks */
	CURSEG_WARM_DATA,	/* data blocks */
	CURSEG_COLD_DATA,	/* multimedia or GCed data blocks */
	CURSEG_HOT_NODE,	/* direct node blocks of directory files */
	CURSEG_WARM_NODE,	/* direct node blocks of normal files */
	CURSEG_COLD_NODE,	/* indirect node blocks */
	NO_CHECK_TYPE
};

406 407
struct flush_cmd {
	struct completion wait;
408
	struct llist_node llnode;
409 410 411
	int ret;
};

412 413 414
struct flush_cmd_control {
	struct task_struct *f2fs_issue_flush;	/* flush thread */
	wait_queue_head_t flush_wait_queue;	/* waiting queue for wake-up */
415 416
	struct llist_head issue_list;		/* list for command issue */
	struct llist_node *dispatch_list;	/* list for command dispatch */
417 418
};

419 420 421 422 423 424 425 426 427 428 429 430 431 432
struct f2fs_sm_info {
	struct sit_info *sit_info;		/* whole segment information */
	struct free_segmap_info *free_info;	/* free segment information */
	struct dirty_seglist_info *dirty_info;	/* dirty segment information */
	struct curseg_info *curseg_array;	/* active segment information */

	block_t seg0_blkaddr;		/* block address of 0'th segment */
	block_t main_blkaddr;		/* start block address of main area */
	block_t ssa_blkaddr;		/* start block address of SSA area */

	unsigned int segment_count;	/* total # of segments */
	unsigned int main_segments;	/* # of segments in main area */
	unsigned int reserved_segments;	/* # of reserved segments */
	unsigned int ovp_segments;	/* # of overprovision segments */
433 434 435

	/* a threshold to reclaim prefree segments */
	unsigned int rec_prefree_segments;
436 437 438 439 440

	/* for small discard management */
	struct list_head discard_list;		/* 4KB discard list */
	int nr_discards;			/* # of discards in the list */
	int max_discards;			/* max. discards to be issued */
441

442 443
	struct list_head sit_entry_set;	/* sit entry set list */

444 445
	unsigned int ipu_policy;	/* in-place-update policy */
	unsigned int min_ipu_util;	/* in-place-update threshold */
446
	unsigned int min_fsync_blocks;	/* threshold for fsync */
447 448

	/* for flush command control */
449 450
	struct flush_cmd_control *cmd_control_info;

451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
};

/*
 * For superblock
 */
/*
 * COUNT_TYPE for monitoring
 *
 * f2fs monitors the number of several block types such as on-writeback,
 * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
 */
enum count_type {
	F2FS_WRITEBACK,
	F2FS_DIRTY_DENTS,
	F2FS_DIRTY_NODES,
	F2FS_DIRTY_META,
467
	F2FS_INMEM_PAGES,
468 469 470 471
	NR_COUNT_TYPE,
};

/*
A
arter97 已提交
472
 * The below are the page types of bios used in submit_bio().
473 474 475 476 477 478 479 480 481
 * The available types are:
 * DATA			User data pages. It operates as async mode.
 * NODE			Node pages. It operates as async mode.
 * META			FS metadata pages such as SIT, NAT, CP.
 * NR_PAGE_TYPE		The number of page types.
 * META_FLUSH		Make sure the previous pages are written
 *			with waiting the bio's completion
 * ...			Only can be used with META.
 */
482
#define PAGE_TYPE_OF_BIO(type)	((type) > META ? META : (type))
483 484 485 486 487 488 489 490
enum page_type {
	DATA,
	NODE,
	META,
	NR_PAGE_TYPE,
	META_FLUSH,
};

J
Jaegeuk Kim 已提交
491
struct f2fs_io_info {
492 493
	enum page_type type;	/* contains DATA/NODE/META/META_FLUSH */
	int rw;			/* contains R/RS/W/WS with REQ_META/REQ_PRIO */
J
Jaegeuk Kim 已提交
494 495
};

496
#define is_read_io(rw)	(((rw) & 1) == READ)
497
struct f2fs_bio_info {
J
Jaegeuk Kim 已提交
498
	struct f2fs_sb_info *sbi;	/* f2fs superblock */
499 500
	struct bio *bio;		/* bios to merge */
	sector_t last_block_in_bio;	/* last block number */
J
Jaegeuk Kim 已提交
501
	struct f2fs_io_info fio;	/* store buffered io info. */
502
	struct rw_semaphore io_rwsem;	/* blocking op for bio */
503 504
};

505 506 507 508 509 510 511 512
/* for inner inode cache management */
struct inode_management {
	struct radix_tree_root ino_root;	/* ino entry array */
	spinlock_t ino_lock;			/* for ino entry lock */
	struct list_head ino_list;		/* inode list head */
	unsigned long ino_num;			/* number of entries */
};

513 514
struct f2fs_sb_info {
	struct super_block *sb;			/* pointer to VFS super block */
515
	struct proc_dir_entry *s_proc;		/* proc entry */
516 517 518
	struct buffer_head *raw_super_buf;	/* buffer head of raw sb */
	struct f2fs_super_block *raw_super;	/* raw super block pointer */
	int s_dirty;				/* dirty flag for checkpoint */
519
	bool need_fsck;				/* need fsck.f2fs to fix */
520 521 522 523 524 525 526

	/* for node-related operations */
	struct f2fs_nm_info *nm_info;		/* node manager */
	struct inode *node_inode;		/* cache node blocks */

	/* for segment-related operations */
	struct f2fs_sm_info *sm_info;		/* segment manager */
527 528

	/* for bio operations */
529
	struct f2fs_bio_info read_io;			/* for read bios */
530
	struct f2fs_bio_info write_io[NR_PAGE_TYPE];	/* for write bios */
531 532 533 534

	/* for checkpoint */
	struct f2fs_checkpoint *ckpt;		/* raw checkpoint pointer */
	struct inode *meta_inode;		/* cache meta blocks */
535
	struct mutex cp_mutex;			/* checkpoint procedure lock */
536
	struct rw_semaphore cp_rwsem;		/* blocking FS operations */
537
	struct rw_semaphore node_write;		/* locking node writes */
538
	struct mutex writepages;		/* mutex for writepages() */
H
Haicheng Li 已提交
539
	bool por_doing;				/* recovery is doing or not */
540
	wait_queue_head_t cp_wait;
541

542
	struct inode_management im[MAX_INO_ENTRY];      /* manage inode cache */
J
Jaegeuk Kim 已提交
543 544

	/* for orphan inode, use 0'th array */
545
	unsigned int max_orphans;		/* max orphan inodes */
546 547 548 549 550

	/* for directory inode management */
	struct list_head dir_inode_list;	/* dir inode list */
	spinlock_t dir_inode_lock;		/* for dir inode list lock */

A
arter97 已提交
551
	/* basic filesystem units */
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
	unsigned int log_sectors_per_block;	/* log2 sectors per block */
	unsigned int log_blocksize;		/* log2 block size */
	unsigned int blocksize;			/* block size */
	unsigned int root_ino_num;		/* root inode number*/
	unsigned int node_ino_num;		/* node inode number*/
	unsigned int meta_ino_num;		/* meta inode number*/
	unsigned int log_blocks_per_seg;	/* log2 blocks per segment */
	unsigned int blocks_per_seg;		/* blocks per segment */
	unsigned int segs_per_sec;		/* segments per section */
	unsigned int secs_per_zone;		/* sections per zone */
	unsigned int total_sections;		/* total section count */
	unsigned int total_node_count;		/* total node block count */
	unsigned int total_valid_node_count;	/* valid node block count */
	unsigned int total_valid_inode_count;	/* valid inode count */
	int active_logs;			/* # of active logs */
567
	int dir_level;				/* directory level */
568 569 570 571 572 573 574 575 576 577 578 579 580

	block_t user_block_count;		/* # of user blocks */
	block_t total_valid_block_count;	/* # of valid blocks */
	block_t alloc_valid_block_count;	/* # of allocated blocks */
	block_t last_valid_block_count;		/* for recovery */
	u32 s_next_generation;			/* for NFS support */
	atomic_t nr_pages[NR_COUNT_TYPE];	/* # of pages, see count_type */

	struct f2fs_mount_info mount_opt;	/* mount options */

	/* for cleaning operations */
	struct mutex gc_mutex;			/* mutex for GC */
	struct f2fs_gc_kthread	*gc_thread;	/* GC thread */
581
	unsigned int cur_victim_sec;		/* current victim section num */
582

583 584 585
	/* maximum # of trials to find a victim segment for SSR and GC */
	unsigned int max_victim_search;

586 587 588 589
	/*
	 * for stat information.
	 * one is for the LFS mode, and the other is for the SSR mode.
	 */
590
#ifdef CONFIG_F2FS_STAT_FS
591 592 593 594
	struct f2fs_stat_info *stat_info;	/* FS status information */
	unsigned int segment_count[2];		/* # of allocated segments */
	unsigned int block_count[2];		/* # of allocated blocks */
	int total_hit_ext, read_hit_ext;	/* extent cache hit ratio */
595 596
	atomic_t inline_inode;			/* # of inline_data inodes */
	atomic_t inline_dir;			/* # of inline_dentry inodes */
597
	int bg_gc;				/* background gc calls */
598 599 600
	unsigned int n_dirty_dirs;		/* # of dir inodes */
#endif
	unsigned int last_victim[2];		/* last victim segment # */
601
	spinlock_t stat_lock;			/* lock for stat operations */
602 603 604 605

	/* For sysfs suppport */
	struct kobject s_kobj;
	struct completion s_kobj_unregister;
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
};

/*
 * Inline functions
 */
static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
{
	return container_of(inode, struct f2fs_inode_info, vfs_inode);
}

static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
{
	return sb->s_fs_info;
}

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)
{
	return F2FS_SB(inode->i_sb);
}

static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping)
{
	return F2FS_I_SB(mapping->host);
}

static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page)
{
	return F2FS_M_SB(page->mapping);
}

636 637 638 639 640 641 642 643 644 645
static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
{
	return (struct f2fs_super_block *)(sbi->raw_super);
}

static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
{
	return (struct f2fs_checkpoint *)(sbi->ckpt);
}

646 647 648 649 650
static inline struct f2fs_node *F2FS_NODE(struct page *page)
{
	return (struct f2fs_node *)page_address(page);
}

651 652 653 654 655
static inline struct f2fs_inode *F2FS_INODE(struct page *page)
{
	return &((struct f2fs_node *)page_address(page))->i;
}

656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
{
	return (struct f2fs_nm_info *)(sbi->nm_info);
}

static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
{
	return (struct f2fs_sm_info *)(sbi->sm_info);
}

static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
{
	return (struct sit_info *)(SM_I(sbi)->sit_info);
}

static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
{
	return (struct free_segmap_info *)(SM_I(sbi)->free_info);
}

static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
{
	return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
}

G
Gu Zheng 已提交
681 682 683 684 685
static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
{
	return sbi->meta_inode->i_mapping;
}

686 687 688 689 690
static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
{
	return sbi->node_inode->i_mapping;
}

691 692 693 694 695 696 697 698 699 700
static inline void F2FS_SET_SB_DIRT(struct f2fs_sb_info *sbi)
{
	sbi->s_dirty = 1;
}

static inline void F2FS_RESET_SB_DIRT(struct f2fs_sb_info *sbi)
{
	sbi->s_dirty = 0;
}

701 702 703 704 705
static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
{
	return le64_to_cpu(cp->checkpoint_ver);
}

706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
{
	unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
	return ckpt_flags & f;
}

static inline void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
{
	unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
	ckpt_flags |= f;
	cp->ckpt_flags = cpu_to_le32(ckpt_flags);
}

static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
{
	unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
	ckpt_flags &= (~f);
	cp->ckpt_flags = cpu_to_le32(ckpt_flags);
}

726
static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
727
{
728
	down_read(&sbi->cp_rwsem);
729 730
}

731
static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
732
{
733
	up_read(&sbi->cp_rwsem);
734 735
}

736
static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
737
{
J
Jaegeuk Kim 已提交
738
	f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex);
739 740
}

741
static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
742
{
743
	up_write(&sbi->cp_rwsem);
744 745 746 747 748
}

/*
 * Check whether the given nid is within node id range.
 */
749
static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
750
{
751 752
	if (unlikely(nid < F2FS_ROOT_INO(sbi)))
		return -EINVAL;
753
	if (unlikely(nid >= NM_I(sbi)->max_nid))
754 755
		return -EINVAL;
	return 0;
756 757 758 759 760 761 762 763 764 765
}

#define F2FS_DEFAULT_ALLOCATED_BLOCKS	1

/*
 * Check whether the inode has blocks or not
 */
static inline int F2FS_HAS_BLOCKS(struct inode *inode)
{
	if (F2FS_I(inode)->i_xattr_nid)
C
Chris Fries 已提交
766
		return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
767
	else
C
Chris Fries 已提交
768
		return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
769 770
}

771 772 773 774 775
static inline bool f2fs_has_xattr_block(unsigned int ofs)
{
	return ofs == XATTR_NODE_OFFSET;
}

776 777 778 779 780 781 782 783
static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
				 struct inode *inode, blkcnt_t count)
{
	block_t	valid_block_count;

	spin_lock(&sbi->stat_lock);
	valid_block_count =
		sbi->total_valid_block_count + (block_t)count;
784
	if (unlikely(valid_block_count > sbi->user_block_count)) {
785 786 787 788 789 790 791 792 793 794
		spin_unlock(&sbi->stat_lock);
		return false;
	}
	inode->i_blocks += count;
	sbi->total_valid_block_count = valid_block_count;
	sbi->alloc_valid_block_count += (block_t)count;
	spin_unlock(&sbi->stat_lock);
	return true;
}

795
static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
796 797 798 799
						struct inode *inode,
						blkcnt_t count)
{
	spin_lock(&sbi->stat_lock);
800 801
	f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
	f2fs_bug_on(sbi, inode->i_blocks < count);
802 803 804 805 806 807 808 809 810 811 812
	inode->i_blocks -= count;
	sbi->total_valid_block_count -= (block_t)count;
	spin_unlock(&sbi->stat_lock);
}

static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
{
	atomic_inc(&sbi->nr_pages[count_type]);
	F2FS_SET_SB_DIRT(sbi);
}

813
static inline void inode_inc_dirty_pages(struct inode *inode)
814
{
815 816 817
	atomic_inc(&F2FS_I(inode)->dirty_pages);
	if (S_ISDIR(inode->i_mode))
		inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
818 819 820 821 822 823 824
}

static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
{
	atomic_dec(&sbi->nr_pages[count_type]);
}

825
static inline void inode_dec_dirty_pages(struct inode *inode)
826
{
827
	if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode))
828 829
		return;

830 831 832 833
	atomic_dec(&F2FS_I(inode)->dirty_pages);

	if (S_ISDIR(inode->i_mode))
		dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
834 835 836 837 838 839 840
}

static inline int get_pages(struct f2fs_sb_info *sbi, int count_type)
{
	return atomic_read(&sbi->nr_pages[count_type]);
}

841
static inline int get_dirty_pages(struct inode *inode)
842
{
843
	return atomic_read(&F2FS_I(inode)->dirty_pages);
844 845
}

846 847 848 849 850 851 852 853
static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
{
	unsigned int pages_per_sec = sbi->segs_per_sec *
					(1 << sbi->log_blocks_per_seg);
	return ((get_pages(sbi, block_type) + pages_per_sec - 1)
			>> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
}

854 855
static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
{
856
	return sbi->total_valid_block_count;
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
}

static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
{
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);

	/* return NAT or SIT bitmap */
	if (flag == NAT_BITMAP)
		return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
	else if (flag == SIT_BITMAP)
		return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);

	return 0;
}

static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
{
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
C
Changman Lee 已提交
875 876 877 878 879 880
	int offset;

	if (le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload) > 0) {
		if (flag == NAT_BITMAP)
			return &ckpt->sit_nat_version_bitmap;
		else
J
Jaegeuk Kim 已提交
881
			return (unsigned char *)ckpt + F2FS_BLKSIZE;
C
Changman Lee 已提交
882 883
	} else {
		offset = (flag == NAT_BITMAP) ?
884
			le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
C
Changman Lee 已提交
885 886
		return &ckpt->sit_nat_version_bitmap + offset;
	}
887 888 889 890 891 892
}

static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
{
	block_t start_addr;
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
893
	unsigned long long ckpt_version = cur_cp_version(ckpt);
894

895
	start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
896 897 898

	/*
	 * odd numbered checkpoint should at cp segment 0
A
arter97 已提交
899
	 * and even segment must be at cp segment 1
900 901 902 903 904 905 906 907 908 909 910 911 912
	 */
	if (!(ckpt_version & 1))
		start_addr += sbi->blocks_per_seg;

	return start_addr;
}

static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
{
	return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
}

static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi,
913
						struct inode *inode)
914 915 916 917 918 919
{
	block_t	valid_block_count;
	unsigned int valid_node_count;

	spin_lock(&sbi->stat_lock);

920
	valid_block_count = sbi->total_valid_block_count + 1;
921
	if (unlikely(valid_block_count > sbi->user_block_count)) {
922 923 924 925
		spin_unlock(&sbi->stat_lock);
		return false;
	}

926
	valid_node_count = sbi->total_valid_node_count + 1;
927
	if (unlikely(valid_node_count > sbi->total_node_count)) {
928 929 930 931 932
		spin_unlock(&sbi->stat_lock);
		return false;
	}

	if (inode)
933 934 935 936 937
		inode->i_blocks++;

	sbi->alloc_valid_block_count++;
	sbi->total_valid_node_count++;
	sbi->total_valid_block_count++;
938 939 940 941 942 943
	spin_unlock(&sbi->stat_lock);

	return true;
}

static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
944
						struct inode *inode)
945 946 947
{
	spin_lock(&sbi->stat_lock);

948 949 950
	f2fs_bug_on(sbi, !sbi->total_valid_block_count);
	f2fs_bug_on(sbi, !sbi->total_valid_node_count);
	f2fs_bug_on(sbi, !inode->i_blocks);
951

952 953 954
	inode->i_blocks--;
	sbi->total_valid_node_count--;
	sbi->total_valid_block_count--;
955 956 957 958 959 960

	spin_unlock(&sbi->stat_lock);
}

static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
{
961
	return sbi->total_valid_node_count;
962 963 964 965 966
}

static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
{
	spin_lock(&sbi->stat_lock);
967
	f2fs_bug_on(sbi, sbi->total_valid_inode_count == sbi->total_node_count);
968 969 970 971
	sbi->total_valid_inode_count++;
	spin_unlock(&sbi->stat_lock);
}

972
static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
973 974
{
	spin_lock(&sbi->stat_lock);
975
	f2fs_bug_on(sbi, !sbi->total_valid_inode_count);
976 977 978 979 980 981
	sbi->total_valid_inode_count--;
	spin_unlock(&sbi->stat_lock);
}

static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi)
{
982
	return sbi->total_valid_inode_count;
983 984 985 986
}

static inline void f2fs_put_page(struct page *page, int unlock)
{
987
	if (!page)
988 989 990
		return;

	if (unlock) {
991
		f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page));
992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
		unlock_page(page);
	}
	page_cache_release(page);
}

static inline void f2fs_put_dnode(struct dnode_of_data *dn)
{
	if (dn->node_page)
		f2fs_put_page(dn->node_page, 1);
	if (dn->inode_page && dn->node_page != dn->inode_page)
		f2fs_put_page(dn->inode_page, 0);
	dn->node_page = NULL;
	dn->inode_page = NULL;
}

static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
1008
					size_t size)
1009
{
1010
	return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
1011 1012
}

1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep,
						gfp_t flags)
{
	void *entry;
retry:
	entry = kmem_cache_alloc(cachep, flags);
	if (!entry) {
		cond_resched();
		goto retry;
	}

	return entry;
}

1027 1028 1029 1030 1031 1032 1033
static inline void f2fs_radix_tree_insert(struct radix_tree_root *root,
				unsigned long index, void *item)
{
	while (radix_tree_insert(root, index, item))
		cond_resched();
}

1034 1035 1036 1037
#define RAW_IS_INODE(p)	((p)->footer.nid == (p)->footer.ino)

static inline bool IS_INODE(struct page *page)
{
1038
	struct f2fs_node *p = F2FS_NODE(page);
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
	return RAW_IS_INODE(p);
}

static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
{
	return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
}

static inline block_t datablock_addr(struct page *node_page,
		unsigned int offset)
{
	struct f2fs_node *raw_node;
	__le32 *addr_array;
1052
	raw_node = F2FS_NODE(node_page);
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
	addr_array = blkaddr_in_node(raw_node);
	return le32_to_cpu(addr_array[offset]);
}

static inline int f2fs_test_bit(unsigned int nr, char *addr)
{
	int mask;

	addr += (nr >> 3);
	mask = 1 << (7 - (nr & 0x07));
	return mask & *addr;
}

1066
static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr)
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
{
	int mask;
	int ret;

	addr += (nr >> 3);
	mask = 1 << (7 - (nr & 0x07));
	ret = mask & *addr;
	*addr |= mask;
	return ret;
}

1078
static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr)
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
{
	int mask;
	int ret;

	addr += (nr >> 3);
	mask = 1 << (7 - (nr & 0x07));
	ret = mask & *addr;
	*addr &= ~mask;
	return ret;
}

1090 1091 1092 1093 1094 1095 1096 1097 1098
static inline void f2fs_change_bit(unsigned int nr, char *addr)
{
	int mask;

	addr += (nr >> 3);
	mask = 1 << (7 - (nr & 0x07));
	*addr ^= mask;
}

1099 1100 1101
/* used for f2fs_inode_info->flags */
enum {
	FI_NEW_INODE,		/* indicate newly allocated inode */
1102
	FI_DIRTY_INODE,		/* indicate inode is dirty or not */
1103
	FI_DIRTY_DIR,		/* indicate directory has dirty pages */
1104 1105 1106
	FI_INC_LINK,		/* need to increment i_nlink */
	FI_ACL_MODE,		/* indicate acl mode */
	FI_NO_ALLOC,		/* should not allocate any blocks */
1107
	FI_UPDATE_DIR,		/* should update inode block for consistency */
1108
	FI_DELAY_IPUT,		/* used for the recovery */
1109
	FI_NO_EXTENT,		/* not to use the extent cache */
J
Jaegeuk Kim 已提交
1110
	FI_INLINE_XATTR,	/* used for inline xattr */
1111
	FI_INLINE_DATA,		/* used for inline data*/
1112
	FI_INLINE_DENTRY,	/* used for inline dentry */
1113 1114
	FI_APPEND_WRITE,	/* inode has appended data */
	FI_UPDATE_WRITE,	/* inode has in-place-update data */
J
Jaegeuk Kim 已提交
1115 1116
	FI_NEED_IPU,		/* used for ipu per file */
	FI_ATOMIC_FILE,		/* indicate atomic file */
1117
	FI_VOLATILE_FILE,	/* indicate volatile file */
1118
	FI_DROP_CACHE,		/* drop dirty page cache */
1119
	FI_DATA_EXIST,		/* indicate data exists */
1120 1121 1122 1123
};

static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
{
J
Jaegeuk Kim 已提交
1124 1125
	if (!test_bit(flag, &fi->flags))
		set_bit(flag, &fi->flags);
1126 1127 1128 1129 1130 1131 1132 1133 1134
}

static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag)
{
	return test_bit(flag, &fi->flags);
}

static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag)
{
J
Jaegeuk Kim 已提交
1135 1136
	if (test_bit(flag, &fi->flags))
		clear_bit(flag, &fi->flags);
1137 1138 1139 1140 1141 1142 1143 1144
}

static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode)
{
	fi->i_acl_mode = mode;
	set_inode_flag(fi, FI_ACL_MODE);
}

J
Jaegeuk Kim 已提交
1145 1146 1147 1148 1149
static inline void get_inline_info(struct f2fs_inode_info *fi,
					struct f2fs_inode *ri)
{
	if (ri->i_inline & F2FS_INLINE_XATTR)
		set_inode_flag(fi, FI_INLINE_XATTR);
1150 1151
	if (ri->i_inline & F2FS_INLINE_DATA)
		set_inode_flag(fi, FI_INLINE_DATA);
1152 1153
	if (ri->i_inline & F2FS_INLINE_DENTRY)
		set_inode_flag(fi, FI_INLINE_DENTRY);
1154 1155
	if (ri->i_inline & F2FS_DATA_EXIST)
		set_inode_flag(fi, FI_DATA_EXIST);
J
Jaegeuk Kim 已提交
1156 1157 1158 1159 1160 1161 1162 1163 1164
}

static inline void set_raw_inline(struct f2fs_inode_info *fi,
					struct f2fs_inode *ri)
{
	ri->i_inline = 0;

	if (is_inode_flag_set(fi, FI_INLINE_XATTR))
		ri->i_inline |= F2FS_INLINE_XATTR;
1165 1166
	if (is_inode_flag_set(fi, FI_INLINE_DATA))
		ri->i_inline |= F2FS_INLINE_DATA;
1167 1168
	if (is_inode_flag_set(fi, FI_INLINE_DENTRY))
		ri->i_inline |= F2FS_INLINE_DENTRY;
1169 1170
	if (is_inode_flag_set(fi, FI_DATA_EXIST))
		ri->i_inline |= F2FS_DATA_EXIST;
J
Jaegeuk Kim 已提交
1171 1172
}

1173 1174 1175 1176 1177
static inline int f2fs_has_inline_xattr(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR);
}

1178 1179
static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi)
{
1180
	if (f2fs_has_inline_xattr(&fi->vfs_inode))
1181 1182 1183 1184
		return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
	return DEF_ADDRS_PER_INODE;
}

J
Jaegeuk Kim 已提交
1185 1186
static inline void *inline_xattr_addr(struct page *page)
{
1187
	struct f2fs_inode *ri = F2FS_INODE(page);
J
Jaegeuk Kim 已提交
1188 1189 1190 1191 1192 1193
	return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
					F2FS_INLINE_XATTR_ADDRS]);
}

static inline int inline_xattr_size(struct inode *inode)
{
1194
	if (f2fs_has_inline_xattr(inode))
J
Jaegeuk Kim 已提交
1195 1196 1197 1198 1199
		return F2FS_INLINE_XATTR_ADDRS << 2;
	else
		return 0;
}

1200 1201 1202 1203 1204
static inline int f2fs_has_inline_data(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA);
}

1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
static inline void f2fs_clear_inline_inode(struct inode *inode)
{
	clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
	clear_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
}

static inline int f2fs_exist_data(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_DATA_EXIST);
}

J
Jaegeuk Kim 已提交
1216 1217 1218 1219 1220
static inline bool f2fs_is_atomic_file(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_ATOMIC_FILE);
}

1221 1222 1223 1224 1225
static inline bool f2fs_is_volatile_file(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE);
}

1226 1227 1228 1229 1230
static inline bool f2fs_is_drop_cache(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_DROP_CACHE);
}

1231 1232
static inline void *inline_data_addr(struct page *page)
{
1233
	struct f2fs_inode *ri = F2FS_INODE(page);
1234 1235 1236
	return (void *)&(ri->i_addr[1]);
}

1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
static inline int f2fs_has_inline_dentry(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DENTRY);
}

static inline void *inline_dentry_addr(struct page *page)
{
	struct f2fs_inode *ri = F2FS_INODE(page);
	return (void *)&(ri->i_addr[1]);
}

1248 1249 1250 1251 1252 1253
static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page)
{
	if (!f2fs_has_inline_dentry(dir))
		kunmap(page);
}

J
Jaegeuk Kim 已提交
1254 1255 1256 1257 1258
static inline int f2fs_readonly(struct super_block *sb)
{
	return sb->s_flags & MS_RDONLY;
}

1259 1260 1261 1262 1263
static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
{
	return is_set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
}

1264 1265 1266 1267 1268 1269
static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi)
{
	set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
	sbi->sb->s_flags |= MS_RDONLY;
}

1270 1271 1272 1273
#define get_inode_mode(i) \
	((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \
	 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))

1274 1275 1276 1277 1278 1279
/* get offset of first page in next direct node */
#define PGOFS_OF_NEXT_DNODE(pgofs, fi)				\
	((pgofs < ADDRS_PER_INODE(fi)) ? ADDRS_PER_INODE(fi) :	\
	(pgofs - ADDRS_PER_INODE(fi) + ADDRS_PER_BLOCK) /	\
	ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(fi))

1280 1281 1282 1283 1284
/*
 * file.c
 */
int f2fs_sync_file(struct file *, loff_t, loff_t, int);
void truncate_data_blocks(struct dnode_of_data *);
1285
int truncate_blocks(struct inode *, u64, bool);
1286
void f2fs_truncate(struct inode *);
1287
int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
1288 1289
int f2fs_setattr(struct dentry *, struct iattr *);
int truncate_hole(struct inode *, pgoff_t, pgoff_t);
1290
int truncate_data_blocks_range(struct dnode_of_data *, int);
1291
long f2fs_ioctl(struct file *, unsigned int, unsigned long);
1292
long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
1293 1294 1295 1296 1297 1298

/*
 * inode.c
 */
void f2fs_set_inode_flags(struct inode *);
struct inode *f2fs_iget(struct super_block *, unsigned long);
1299
int try_to_free_nats(struct f2fs_sb_info *, int);
1300
void update_inode(struct inode *, struct page *);
1301
void update_inode_page(struct inode *);
1302 1303
int f2fs_write_inode(struct inode *, struct writeback_control *);
void f2fs_evict_inode(struct inode *);
1304
void handle_failed_inode(struct inode *);
1305 1306 1307 1308 1309 1310 1311 1312 1313

/*
 * namei.c
 */
struct dentry *f2fs_get_parent(struct dentry *child);

/*
 * dir.c
 */
1314 1315
extern unsigned char f2fs_filetype_table[F2FS_FT_MAX];
void set_de_type(struct f2fs_dir_entry *, struct inode *);
1316 1317 1318 1319
struct f2fs_dir_entry *find_target_dentry(struct qstr *, int *,
			struct f2fs_dentry_ptr *);
bool f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *,
			unsigned int);
1320 1321
void do_make_empty_dir(struct inode *, struct inode *,
			struct f2fs_dentry_ptr *);
1322
struct page *init_inode_metadata(struct inode *, struct inode *,
1323
			const struct qstr *, struct page *);
1324
void update_parent_metadata(struct inode *, struct inode *, unsigned int);
1325
int room_for_filename(const void *, int, int);
1326
void f2fs_drop_nlink(struct inode *, struct inode *, struct page *);
1327 1328 1329 1330 1331 1332
struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *,
							struct page **);
struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
ino_t f2fs_inode_by_name(struct inode *, struct qstr *);
void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
				struct page *, struct inode *);
1333
int update_dent_inode(struct inode *, const struct qstr *);
1334
int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *);
1335 1336
void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *,
							struct inode *);
1337
int f2fs_do_tmpfile(struct inode *, struct inode *);
1338 1339 1340
int f2fs_make_empty(struct inode *, struct inode *);
bool f2fs_empty_dir(struct inode *);

1341 1342 1343 1344 1345 1346
static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
{
	return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name,
				inode);
}

1347 1348 1349 1350
/*
 * super.c
 */
int f2fs_sync_fs(struct super_block *, int);
1351 1352
extern __printf(3, 4)
void f2fs_msg(struct super_block *, const char *, const char *, ...);
1353 1354 1355 1356

/*
 * hash.c
 */
1357
f2fs_hash_t f2fs_dentry_hash(const struct qstr *);
1358 1359 1360 1361 1362 1363 1364

/*
 * node.c
 */
struct dnode_of_data;
struct node_info;

1365
bool available_free_memory(struct f2fs_sb_info *, int);
1366 1367 1368
bool is_checkpointed_node(struct f2fs_sb_info *, nid_t);
bool has_fsynced_inode(struct f2fs_sb_info *, nid_t);
bool need_inode_block_update(struct f2fs_sb_info *, nid_t);
1369 1370 1371
void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int);
int truncate_inode_blocks(struct inode *, pgoff_t);
1372
int truncate_xattr_node(struct inode *, struct page *);
1373
int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t);
G
Gu Zheng 已提交
1374
void remove_inode_page(struct inode *);
1375
struct page *new_inode_page(struct inode *);
1376
struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
1377 1378 1379 1380 1381 1382 1383 1384
void ra_node_page(struct f2fs_sb_info *, nid_t);
struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
struct page *get_node_page_ra(struct page *, int);
void sync_inode_page(struct dnode_of_data *);
int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *);
bool alloc_nid(struct f2fs_sb_info *, nid_t *);
void alloc_nid_done(struct f2fs_sb_info *, nid_t);
void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
1385
void recover_inline_xattr(struct inode *, struct page *);
1386
void recover_xattr_data(struct inode *, struct page *, block_t);
1387 1388 1389 1390 1391 1392
int recover_inode_page(struct f2fs_sb_info *, struct page *);
int restore_node_summary(struct f2fs_sb_info *, unsigned int,
				struct f2fs_summary_block *);
void flush_nat_entries(struct f2fs_sb_info *);
int build_node_manager(struct f2fs_sb_info *);
void destroy_node_manager(struct f2fs_sb_info *);
1393
int __init create_node_manager_caches(void);
1394 1395 1396 1397 1398
void destroy_node_manager_caches(void);

/*
 * segment.c
 */
J
Jaegeuk Kim 已提交
1399
void register_inmem_page(struct inode *, struct page *);
J
Jaegeuk Kim 已提交
1400
void invalidate_inmem_page(struct inode *, struct page *);
J
Jaegeuk Kim 已提交
1401
void commit_inmem_pages(struct inode *, bool);
1402
void f2fs_balance_fs(struct f2fs_sb_info *);
1403
void f2fs_balance_fs_bg(struct f2fs_sb_info *);
1404
int f2fs_issue_flush(struct f2fs_sb_info *);
1405 1406
int create_flush_cmd_control(struct f2fs_sb_info *);
void destroy_flush_cmd_control(struct f2fs_sb_info *);
1407
void invalidate_blocks(struct f2fs_sb_info *, block_t);
1408
void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t);
1409
void clear_prefree_segments(struct f2fs_sb_info *);
1410
void release_discard_addrs(struct f2fs_sb_info *);
1411
void discard_next_dnode(struct f2fs_sb_info *, block_t);
1412 1413
int npages_for_summary_flush(struct f2fs_sb_info *);
void allocate_new_segments(struct f2fs_sb_info *);
1414
int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *);
1415
struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
1416
void write_meta_page(struct f2fs_sb_info *, struct page *);
1417 1418
void write_node_page(struct f2fs_sb_info *, struct page *,
		struct f2fs_io_info *, unsigned int, block_t, block_t *);
J
Jaegeuk Kim 已提交
1419 1420 1421
void write_data_page(struct page *, struct dnode_of_data *, block_t *,
					struct f2fs_io_info *);
void rewrite_data_page(struct page *, block_t, struct f2fs_io_info *);
1422 1423
void recover_data_page(struct f2fs_sb_info *, struct page *,
				struct f2fs_summary *, block_t, block_t);
1424 1425
void allocate_data_block(struct f2fs_sb_info *, struct page *,
		block_t, block_t *, struct f2fs_summary *, int);
1426
void f2fs_wait_on_page_writeback(struct page *, enum page_type);
1427 1428 1429 1430
void write_data_summaries(struct f2fs_sb_info *, block_t);
void write_node_summaries(struct f2fs_sb_info *, block_t);
int lookup_journal_in_cursum(struct f2fs_summary_block *,
					int, unsigned int, int);
1431
void flush_sit_entries(struct f2fs_sb_info *, struct cp_control *);
1432 1433
int build_segment_manager(struct f2fs_sb_info *);
void destroy_segment_manager(struct f2fs_sb_info *);
1434 1435
int __init create_segment_manager_caches(void);
void destroy_segment_manager_caches(void);
1436 1437 1438 1439 1440 1441

/*
 * checkpoint.c
 */
struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
1442
int ra_meta_pages(struct f2fs_sb_info *, block_t, int, int);
1443
void ra_meta_pages_cond(struct f2fs_sb_info *, pgoff_t);
1444
long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
1445 1446
void add_dirty_inode(struct f2fs_sb_info *, nid_t, int type);
void remove_dirty_inode(struct f2fs_sb_info *, nid_t, int type);
1447
void release_dirty_inode(struct f2fs_sb_info *);
1448
bool exist_written_data(struct f2fs_sb_info *, nid_t, int);
J
Jaegeuk Kim 已提交
1449 1450
int acquire_orphan_inode(struct f2fs_sb_info *);
void release_orphan_inode(struct f2fs_sb_info *);
1451 1452
void add_orphan_inode(struct f2fs_sb_info *, nid_t);
void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
1453
void recover_orphan_inodes(struct f2fs_sb_info *);
1454
int get_valid_checkpoint(struct f2fs_sb_info *);
1455
void update_dirty_page(struct inode *, struct page *);
1456
void add_dirty_dir_inode(struct inode *);
1457 1458
void remove_dirty_dir_inode(struct inode *);
void sync_dirty_dir_inodes(struct f2fs_sb_info *);
1459
void write_checkpoint(struct f2fs_sb_info *, struct cp_control *);
J
Jaegeuk Kim 已提交
1460
void init_ino_entry_info(struct f2fs_sb_info *);
1461
int __init create_checkpoint_caches(void);
1462 1463 1464 1465 1466
void destroy_checkpoint_caches(void);

/*
 * data.c
 */
J
Jaegeuk Kim 已提交
1467
void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int);
1468 1469
int f2fs_submit_page_bio(struct f2fs_sb_info *, struct page *, block_t, int);
void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *, block_t,
J
Jaegeuk Kim 已提交
1470
						struct f2fs_io_info *);
1471
int reserve_new_block(struct dnode_of_data *);
1472
int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
1473
void update_extent_cache(block_t, struct dnode_of_data *);
1474
struct page *find_data_page(struct inode *, pgoff_t, bool);
1475
struct page *get_lock_data_page(struct inode *, pgoff_t);
1476
struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
J
Jaegeuk Kim 已提交
1477
int do_write_data_page(struct page *, struct f2fs_io_info *);
J
Jaegeuk Kim 已提交
1478
int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);
1479 1480 1481 1482 1483 1484

/*
 * gc.c
 */
int start_gc_thread(struct f2fs_sb_info *);
void stop_gc_thread(struct f2fs_sb_info *);
1485
block_t start_bidx_of_node(unsigned int, struct f2fs_inode_info *);
J
Jaegeuk Kim 已提交
1486
int f2fs_gc(struct f2fs_sb_info *);
1487
void build_gc_manager(struct f2fs_sb_info *);
1488
int __init create_gc_caches(void);
1489 1490 1491 1492 1493
void destroy_gc_caches(void);

/*
 * recovery.c
 */
1494
int recover_fsync_data(struct f2fs_sb_info *);
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
bool space_for_roll_forward(struct f2fs_sb_info *);

/*
 * debug.c
 */
#ifdef CONFIG_F2FS_STAT_FS
struct f2fs_stat_info {
	struct list_head stat_list;
	struct f2fs_sb_info *sbi;
	int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
	int main_area_segs, main_area_sections, main_area_zones;
	int hit_ext, total_ext;
	int ndirty_node, ndirty_dent, ndirty_dirs, ndirty_meta;
	int nats, sits, fnids;
	int total_count, utilization;
1510
	int bg_gc, inline_inode, inline_dir, inmem_pages;
1511 1512 1513 1514 1515
	unsigned int valid_count, valid_node_count, valid_inode_count;
	unsigned int bimodal, avg_vblocks;
	int util_free, util_valid, util_invalid;
	int rsvd_segs, overp_segs;
	int dirty_count, node_pages, meta_pages;
1516
	int prefree_count, call_count, cp_count;
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
	int tot_segs, node_segs, data_segs, free_segs, free_secs;
	int tot_blks, data_blks, node_blks;
	int curseg[NR_CURSEG_TYPE];
	int cursec[NR_CURSEG_TYPE];
	int curzone[NR_CURSEG_TYPE];

	unsigned int segment_count[2];
	unsigned int block_count[2];
	unsigned base_mem, cache_mem;
};

1528 1529
static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
{
C
Chris Fries 已提交
1530
	return (struct f2fs_stat_info *)sbi->stat_info;
1531 1532
}

1533
#define stat_inc_cp_count(si)		((si)->cp_count++)
1534 1535 1536 1537 1538 1539
#define stat_inc_call_count(si)		((si)->call_count++)
#define stat_inc_bggc_count(sbi)	((sbi)->bg_gc++)
#define stat_inc_dirty_dir(sbi)		((sbi)->n_dirty_dirs++)
#define stat_dec_dirty_dir(sbi)		((sbi)->n_dirty_dirs--)
#define stat_inc_total_hit(sb)		((F2FS_SB(sb))->total_hit_ext++)
#define stat_inc_read_hit(sb)		((F2FS_SB(sb))->read_hit_ext++)
1540 1541 1542
#define stat_inc_inline_inode(inode)					\
	do {								\
		if (f2fs_has_inline_data(inode))			\
1543
			(atomic_inc(&F2FS_I_SB(inode)->inline_inode));	\
1544 1545 1546 1547
	} while (0)
#define stat_dec_inline_inode(inode)					\
	do {								\
		if (f2fs_has_inline_data(inode))			\
1548
			(atomic_dec(&F2FS_I_SB(inode)->inline_inode));	\
1549
	} while (0)
1550 1551 1552
#define stat_inc_inline_dir(inode)					\
	do {								\
		if (f2fs_has_inline_dentry(inode))			\
1553
			(atomic_inc(&F2FS_I_SB(inode)->inline_dir));	\
1554 1555 1556 1557
	} while (0)
#define stat_dec_inline_dir(inode)					\
	do {								\
		if (f2fs_has_inline_dentry(inode))			\
1558
			(atomic_dec(&F2FS_I_SB(inode)->inline_dir));	\
1559
	} while (0)
1560 1561 1562 1563
#define stat_inc_seg_type(sbi, curseg)					\
		((sbi)->segment_count[(curseg)->alloc_type]++)
#define stat_inc_block_count(sbi, curseg)				\
		((sbi)->block_count[(curseg)->alloc_type]++)
1564 1565 1566

#define stat_inc_seg_count(sbi, type)					\
	do {								\
1567
		struct f2fs_stat_info *si = F2FS_STAT(sbi);		\
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
		(si)->tot_segs++;					\
		if (type == SUM_TYPE_DATA)				\
			si->data_segs++;				\
		else							\
			si->node_segs++;				\
	} while (0)

#define stat_inc_tot_blk_count(si, blks)				\
	(si->tot_blks += (blks))

#define stat_inc_data_blk_count(sbi, blks)				\
	do {								\
1580
		struct f2fs_stat_info *si = F2FS_STAT(sbi);		\
1581 1582 1583 1584 1585 1586
		stat_inc_tot_blk_count(si, blks);			\
		si->data_blks += (blks);				\
	} while (0)

#define stat_inc_node_blk_count(sbi, blks)				\
	do {								\
1587
		struct f2fs_stat_info *si = F2FS_STAT(sbi);		\
1588 1589 1590 1591 1592 1593
		stat_inc_tot_blk_count(si, blks);			\
		si->node_blks += (blks);				\
	} while (0)

int f2fs_build_stats(struct f2fs_sb_info *);
void f2fs_destroy_stats(struct f2fs_sb_info *);
1594
void __init f2fs_create_root_stats(void);
1595
void f2fs_destroy_root_stats(void);
1596
#else
1597
#define stat_inc_cp_count(si)
1598
#define stat_inc_call_count(si)
1599 1600 1601 1602 1603
#define stat_inc_bggc_count(si)
#define stat_inc_dirty_dir(sbi)
#define stat_dec_dirty_dir(sbi)
#define stat_inc_total_hit(sb)
#define stat_inc_read_hit(sb)
1604 1605
#define stat_inc_inline_inode(inode)
#define stat_dec_inline_inode(inode)
1606 1607
#define stat_inc_inline_dir(inode)
#define stat_dec_inline_dir(inode)
1608 1609
#define stat_inc_seg_type(sbi, curseg)
#define stat_inc_block_count(sbi, curseg)
1610 1611 1612 1613 1614 1615 1616
#define stat_inc_seg_count(si, type)
#define stat_inc_tot_blk_count(si, blks)
#define stat_inc_data_blk_count(si, blks)
#define stat_inc_node_blk_count(sbi, blks)

static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
1617
static inline void __init f2fs_create_root_stats(void) { }
1618
static inline void f2fs_destroy_root_stats(void) { }
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
#endif

extern const struct file_operations f2fs_dir_operations;
extern const struct file_operations f2fs_file_operations;
extern const struct inode_operations f2fs_file_inode_operations;
extern const struct address_space_operations f2fs_dblock_aops;
extern const struct address_space_operations f2fs_node_aops;
extern const struct address_space_operations f2fs_meta_aops;
extern const struct inode_operations f2fs_dir_inode_operations;
extern const struct inode_operations f2fs_symlink_inode_operations;
extern const struct inode_operations f2fs_special_inode_operations;
1630

1631 1632 1633 1634
/*
 * inline.c
 */
bool f2fs_may_inline(struct inode *);
1635
void read_inline_data(struct page *, struct page *);
1636
int f2fs_read_inline_data(struct inode *, struct page *);
1637 1638 1639 1640
int f2fs_convert_inline_page(struct dnode_of_data *, struct page *);
int f2fs_convert_inline_inode(struct inode *);
int f2fs_write_inline_data(struct inode *, struct page *);
void truncate_inline_data(struct page *, u64);
1641
bool recover_inline_data(struct inode *, struct page *);
1642 1643 1644 1645 1646 1647 1648 1649 1650
struct f2fs_dir_entry *find_in_inline_dir(struct inode *, struct qstr *,
							struct page **);
struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *, struct page **);
int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *);
void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *,
						struct inode *, struct inode *);
bool f2fs_empty_inline_dir(struct inode *);
int f2fs_read_inline_dir(struct file *, struct dir_context *);
1651
#endif