f2fs.h 48.2 KB
Newer Older
Jaegeuk Kim's avatar
Jaegeuk Kim committed
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)
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)
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
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
53
54
55
56
57
58
59
60

#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))

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

struct f2fs_mount_info {
	unsigned int	opt;
};

Jaegeuk Kim's avatar
Jaegeuk Kim committed
71
72
73
#define CRCPOLY_LE 0xedb88320

static inline __u32 f2fs_crc32(void *buf, size_t len)
74
{
Jaegeuk Kim's avatar
Jaegeuk Kim committed
75
76
77
78
79
80
81
82
83
84
	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;
85
86
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
87
static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size)
88
{
Jaegeuk Kim's avatar
Jaegeuk Kim committed
89
	return f2fs_crc32(buf, buf_size) == blk_crc;
90
91
92
93
94
95
96
97
98
99
}

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

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

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

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

125
126
127
/* for the list of ino */
enum {
	ORPHAN_INO,		/* for orphan ino list */
128
129
	APPEND_INO,		/* for append ino list */
	UPDATE_INO,		/* for update ino list */
130
131
132
133
	MAX_INO_ENTRY,		/* max. list */
};

struct ino_entry {
134
135
136
137
138
139
140
141
142
143
	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 */
};

144
145
146
147
148
149
150
/* 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 */
};

151
152
153
154
/* 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 */
155
156
157
	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 */
158
159
160
161
162
163
164
165
166
167
};

#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)

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

171
172
173
174
175
176
177
178
179
180
181
182
183
184
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;
}

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

193
194
195
/*
 * ioctl commands
 */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
196
197
198
199
200
201
#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)
202
#define F2FS_IOC_START_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 3)
203
204
205
206
207
208
209
210
211

#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

212
213
214
/*
 * For INODE and NODE manager
 */
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
/* 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;
	}
}

241
242
243
244
245
246
247
/*
 * 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)
248
249
250
251
252
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
Chao Yu's avatar
Chao Yu committed
253
					 * by get_data_block.
254
					 */
255
256
};

257
258
#define F2FS_LINK_MAX		32000	/* maximum link count per file */

259
260
#define MAX_DIR_RA_PAGES	4	/* maximum ra pages of dir */

261
/* for in-memory extent cache entry */
262
263
#define F2FS_MIN_EXTENT_LEN	16	/* minimum extent length */

264
265
266
267
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 */
Masanari Iida's avatar
Masanari Iida committed
268
	unsigned int len;	/* length of the extent */
269
270
271
272
273
274
};

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

277
278
#define DEF_DIR_LEVEL		0

279
280
281
282
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 */
283
	unsigned char i_dir_level;	/* use for dentry level for large dir */
284
	unsigned int i_current_depth;	/* use only in directory structure */
285
	unsigned int i_pino;		/* parent inode number */
286
287
288
289
	umode_t i_acl_mode;		/* keep file acl mode temporarily */

	/* Use below internally in f2fs*/
	unsigned long flags;		/* use to pass per-file flags */
290
	struct rw_semaphore i_sem;	/* protect fi info */
291
	atomic_t dirty_pages;		/* # of dirty pages */
292
293
294
	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 */
295
	unsigned long long xattr_ver;	/* cp version of xattr modification */
296
	struct extent_info ext;		/* in-memory extent cache entry */
297
	struct dir_inode_entry *dirty_dir;	/* the pointer of dirty dir */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
298

299
	struct radix_tree_root inmem_root;	/* radix tree for inmem pages */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
300
301
	struct list_head inmem_pages;	/* inmemory pages managed by f2fs */
	struct mutex inmem_lock;	/* lock for inmemory pages */
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
};

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 */
327
	nid_t available_nids;		/* maximum available node ids */
328
	nid_t next_scan_nid;		/* the next nid to be scanned */
329
	unsigned int ram_thresh;	/* control the memory footprint */
330
331
332

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

	/* free node ids management */
340
	struct radix_tree_root free_nid_root;/* root of the free_nid cache */
341
342
343
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
	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)
{
369
	memset(dn, 0, sizeof(*dn));
370
371
372
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
	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
};

403
404
struct flush_cmd {
	struct completion wait;
405
	struct llist_node llnode;
406
407
408
	int ret;
};

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

416
417
418
419
420
421
422
423
424
425
426
427
428
429
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 */
430
431
432

	/* a threshold to reclaim prefree segments */
	unsigned int rec_prefree_segments;
433
434
435
436
437

	/* 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 */
438

439
440
	struct list_head sit_entry_set;	/* sit entry set list */

441
442
	unsigned int ipu_policy;	/* in-place-update policy */
	unsigned int min_ipu_util;	/* in-place-update threshold */
443
	unsigned int min_fsync_blocks;	/* threshold for fsync */
444
445

	/* for flush command control */
446
447
	struct flush_cmd_control *cmd_control_info;

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

/*
 * 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,
	NR_COUNT_TYPE,
};

/*
arter97's avatar
arter97 committed
468
 * The below are the page types of bios used in submit_bio().
469
470
471
472
473
474
475
476
477
 * 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.
 */
478
#define PAGE_TYPE_OF_BIO(type)	((type) > META ? META : (type))
479
480
481
482
483
484
485
486
enum page_type {
	DATA,
	NODE,
	META,
	NR_PAGE_TYPE,
	META_FLUSH,
};

Jaegeuk Kim's avatar
Jaegeuk Kim committed
487
struct f2fs_io_info {
488
489
	enum page_type type;	/* contains DATA/NODE/META/META_FLUSH */
	int rw;			/* contains R/RS/W/WS with REQ_META/REQ_PRIO */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
490
491
};

492
#define is_read_io(rw)	(((rw) & 1) == READ)
493
struct f2fs_bio_info {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
494
	struct f2fs_sb_info *sbi;	/* f2fs superblock */
495
496
	struct bio *bio;		/* bios to merge */
	sector_t last_block_in_bio;	/* last block number */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
497
	struct f2fs_io_info fio;	/* store buffered io info. */
498
	struct rw_semaphore io_rwsem;	/* blocking op for bio */
499
500
};

501
502
struct f2fs_sb_info {
	struct super_block *sb;			/* pointer to VFS super block */
503
	struct proc_dir_entry *s_proc;		/* proc entry */
504
505
506
	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 */
507
	bool need_fsck;				/* need fsck.f2fs to fix */
508
509
510
511
512
513
514

	/* 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 */
515
516

	/* for bio operations */
517
	struct f2fs_bio_info read_io;			/* for read bios */
518
	struct f2fs_bio_info write_io[NR_PAGE_TYPE];	/* for write bios */
519
	struct completion *wait_io;		/* for completion bios */
520
521
522
523

	/* for checkpoint */
	struct f2fs_checkpoint *ckpt;		/* raw checkpoint pointer */
	struct inode *meta_inode;		/* cache meta blocks */
524
	struct mutex cp_mutex;			/* checkpoint procedure lock */
525
	struct rw_semaphore cp_rwsem;		/* blocking FS operations */
526
	struct rw_semaphore node_write;		/* locking node writes */
527
	struct mutex writepages;		/* mutex for writepages() */
Haicheng Li's avatar
Haicheng Li committed
528
	bool por_doing;				/* recovery is doing or not */
529
	wait_queue_head_t cp_wait;
530

531
	/* for inode management */
532
	struct radix_tree_root ino_root[MAX_INO_ENTRY];	/* ino entry array */
533
534
535
536
	spinlock_t ino_lock[MAX_INO_ENTRY];		/* for ino entry lock */
	struct list_head ino_list[MAX_INO_ENTRY];	/* inode list head */

	/* for orphan inode, use 0'th array */
537
	unsigned int n_orphans;			/* # of orphan inodes */
538
	unsigned int max_orphans;		/* max orphan inodes */
539
540
541
542
543

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

arter97's avatar
arter97 committed
544
	/* basic filesystem units */
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
	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 */
560
	int dir_level;				/* directory level */
561
562
563
564
565
566
567
568
569
570
571
572
573

	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 */
574
	unsigned int cur_victim_sec;		/* current victim section num */
575

576
577
578
	/* maximum # of trials to find a victim segment for SSR and GC */
	unsigned int max_victim_search;

579
580
581
582
	/*
	 * for stat information.
	 * one is for the LFS mode, and the other is for the SSR mode.
	 */
583
#ifdef CONFIG_F2FS_STAT_FS
584
585
586
587
	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 */
588
	int inline_inode;			/* # of inline_data inodes */
589
	int inline_dir;				/* # of inline_dentry inodes */
590
	int bg_gc;				/* background gc calls */
591
592
593
	unsigned int n_dirty_dirs;		/* # of dir inodes */
#endif
	unsigned int last_victim[2];		/* last victim segment # */
594
	spinlock_t stat_lock;			/* lock for stat operations */
595
596
597
598

	/* For sysfs suppport */
	struct kobject s_kobj;
	struct completion s_kobj_unregister;
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
};

/*
 * 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;
}

614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
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);
}

629
630
631
632
633
634
635
636
637
638
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);
}

639
640
641
642
643
static inline struct f2fs_node *F2FS_NODE(struct page *page)
{
	return (struct f2fs_node *)page_address(page);
}

644
645
646
647
648
static inline struct f2fs_inode *F2FS_INODE(struct page *page)
{
	return &((struct f2fs_node *)page_address(page))->i;
}

649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
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);
}

674
675
676
677
678
static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
{
	return sbi->meta_inode->i_mapping;
}

679
680
681
682
683
static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
{
	return sbi->node_inode->i_mapping;
}

684
685
686
687
688
689
690
691
692
693
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;
}

694
695
696
697
698
static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
{
	return le64_to_cpu(cp->checkpoint_ver);
}

699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
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);
}

719
static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
720
{
721
	down_read(&sbi->cp_rwsem);
722
723
}

724
static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
725
{
726
	up_read(&sbi->cp_rwsem);
727
728
}

729
static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
730
{
731
	f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex);
732
733
}

734
static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
735
{
736
	up_write(&sbi->cp_rwsem);
737
738
739
740
741
}

/*
 * Check whether the given nid is within node id range.
 */
742
static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
743
{
744
745
	if (unlikely(nid < F2FS_ROOT_INO(sbi)))
		return -EINVAL;
746
	if (unlikely(nid >= NM_I(sbi)->max_nid))
747
748
		return -EINVAL;
	return 0;
749
750
751
752
753
754
755
756
757
758
}

#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)
Chris Fries's avatar
Chris Fries committed
759
		return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
760
	else
Chris Fries's avatar
Chris Fries committed
761
		return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
762
763
}

764
765
766
767
768
static inline bool f2fs_has_xattr_block(unsigned int ofs)
{
	return ofs == XATTR_NODE_OFFSET;
}

769
770
771
772
773
774
775
776
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;
777
	if (unlikely(valid_block_count > sbi->user_block_count)) {
778
779
780
781
782
783
784
785
786
787
		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;
}

788
static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
789
790
791
792
						struct inode *inode,
						blkcnt_t count)
{
	spin_lock(&sbi->stat_lock);
793
794
	f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
	f2fs_bug_on(sbi, inode->i_blocks < count);
795
796
797
798
799
800
801
802
803
804
805
	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);
}

806
static inline void inode_inc_dirty_pages(struct inode *inode)
807
{
808
809
810
	atomic_inc(&F2FS_I(inode)->dirty_pages);
	if (S_ISDIR(inode->i_mode))
		inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
811
812
813
814
815
816
817
}

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

818
static inline void inode_dec_dirty_pages(struct inode *inode)
819
{
820
	if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode))
821
822
		return;

823
824
825
826
	atomic_dec(&F2FS_I(inode)->dirty_pages);

	if (S_ISDIR(inode->i_mode))
		dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
827
828
829
830
831
832
833
}

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

834
static inline int get_dirty_pages(struct inode *inode)
835
{
836
	return atomic_read(&F2FS_I(inode)->dirty_pages);
837
838
}

839
840
841
842
843
844
845
846
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;
}

847
848
static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
{
849
	return sbi->total_valid_block_count;
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
}

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);
Changman Lee's avatar
Changman Lee committed
868
869
870
871
872
873
	int offset;

	if (le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload) > 0) {
		if (flag == NAT_BITMAP)
			return &ckpt->sit_nat_version_bitmap;
		else
Jaegeuk Kim's avatar
Jaegeuk Kim committed
874
			return (unsigned char *)ckpt + F2FS_BLKSIZE;
Changman Lee's avatar
Changman Lee committed
875
876
	} else {
		offset = (flag == NAT_BITMAP) ?
877
			le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
Changman Lee's avatar
Changman Lee committed
878
879
		return &ckpt->sit_nat_version_bitmap + offset;
	}
880
881
882
883
884
885
}

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

888
	start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
889
890
891

	/*
	 * odd numbered checkpoint should at cp segment 0
arter97's avatar
arter97 committed
892
	 * and even segment must be at cp segment 1
893
894
895
896
897
898
899
900
901
902
903
904
905
	 */
	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,
906
						struct inode *inode)
907
908
909
910
911
912
{
	block_t	valid_block_count;
	unsigned int valid_node_count;

	spin_lock(&sbi->stat_lock);

913
	valid_block_count = sbi->total_valid_block_count + 1;
914
	if (unlikely(valid_block_count > sbi->user_block_count)) {
915
916
917
918
		spin_unlock(&sbi->stat_lock);
		return false;
	}

919
	valid_node_count = sbi->total_valid_node_count + 1;
920
	if (unlikely(valid_node_count > sbi->total_node_count)) {
921
922
923
924
925
		spin_unlock(&sbi->stat_lock);
		return false;
	}

	if (inode)
926
927
928
929
930
		inode->i_blocks++;

	sbi->alloc_valid_block_count++;
	sbi->total_valid_node_count++;
	sbi->total_valid_block_count++;
931
932
933
934
935
936
	spin_unlock(&sbi->stat_lock);

	return true;
}

static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
937
						struct inode *inode)
938
939
940
{
	spin_lock(&sbi->stat_lock);

941
942
943
	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);
944

945
946
947
	inode->i_blocks--;
	sbi->total_valid_node_count--;
	sbi->total_valid_block_count--;
948
949
950
951
952
953

	spin_unlock(&sbi->stat_lock);
}

static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
{
954
	return sbi->total_valid_node_count;
955
956
957
958
959
}

static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
{
	spin_lock(&sbi->stat_lock);
960
	f2fs_bug_on(sbi, sbi->total_valid_inode_count == sbi->total_node_count);
961
962
963
964
	sbi->total_valid_inode_count++;
	spin_unlock(&sbi->stat_lock);
}

965
static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
966
967
{
	spin_lock(&sbi->stat_lock);
968
	f2fs_bug_on(sbi, !sbi->total_valid_inode_count);
969
970
971
972
973
974
	sbi->total_valid_inode_count--;
	spin_unlock(&sbi->stat_lock);
}

static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi)
{
975
	return sbi->total_valid_inode_count;
976
977
978
979
}

static inline void f2fs_put_page(struct page *page, int unlock)
{
980
	if (!page)
981
982
983
		return;

	if (unlock) {
984
		f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page));
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
		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,
1001
					size_t size)
1002
{
1003
	return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
1004
1005
}

1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
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;
}

1020
1021
1022
1023
#define RAW_IS_INODE(p)	((p)->footer.nid == (p)->footer.ino)

static inline bool IS_INODE(struct page *page)
{
1024
	struct f2fs_node *p = F2FS_NODE(page);
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
	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;
1038
	raw_node = F2FS_NODE(node_page);
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
	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;
}

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

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

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

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

/* used for f2fs_inode_info->flags */
enum {
	FI_NEW_INODE,		/* indicate newly allocated inode */
1079
	FI_DIRTY_INODE,		/* indicate inode is dirty or not */
1080
	FI_DIRTY_DIR,		/* indicate directory has dirty pages */
1081
1082
1083
	FI_INC_LINK,		/* need to increment i_nlink */
	FI_ACL_MODE,		/* indicate acl mode */
	FI_NO_ALLOC,		/* should not allocate any blocks */
1084
	FI_UPDATE_DIR,		/* should update inode block for consistency */
1085
	FI_DELAY_IPUT,		/* used for the recovery */
1086
	FI_NO_EXTENT,		/* not to use the extent cache */
1087
	FI_INLINE_XATTR,	/* used for inline xattr */
1088
	FI_INLINE_DATA,		/* used for inline data*/
1089
	FI_INLINE_DENTRY,	/* used for inline dentry */
1090
1091
	FI_APPEND_WRITE,	/* inode has appended data */
	FI_UPDATE_WRITE,	/* inode has in-place-update data */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1092
1093
	FI_NEED_IPU,		/* used for ipu per file */
	FI_ATOMIC_FILE,		/* indicate atomic file */
1094
	FI_VOLATILE_FILE,	/* indicate volatile file */
1095
1096
1097
1098
};

static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
{
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1099
1100
	if (!test_bit(flag, &fi->flags))
		set_bit(flag, &fi->flags);
1101
1102
1103
1104
1105
1106
1107
1108
1109
}

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)
{
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1110
1111
	if (test_bit(flag, &fi->flags))
		clear_bit(flag, &fi->flags);
1112
1113
1114
1115
1116
1117
1118
1119
}

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);
}

1120
1121
1122
1123
1124
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);
1125
1126
	if (ri->i_inline & F2FS_INLINE_DATA)
		set_inode_flag(fi, FI_INLINE_DATA);
1127
1128
	if (ri->i_inline & F2FS_INLINE_DENTRY)
		set_inode_flag(fi, FI_INLINE_DENTRY);
1129
1130
1131
1132
1133
1134
1135
1136
1137
}

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;
1138
1139
	if (is_inode_flag_set(fi, FI_INLINE_DATA))
		ri->i_inline |= F2FS_INLINE_DATA;
1140
1141
	if (is_inode_flag_set(fi, FI_INLINE_DENTRY))
		ri->i_inline |= F2FS_INLINE_DENTRY;
1142
1143
}

1144
1145
1146
1147
1148
static inline int f2fs_has_inline_xattr(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR);
}

1149
1150
static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi)
{
1151
	if (f2fs_has_inline_xattr(&fi->vfs_inode))
1152
1153
1154
1155
		return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
	return DEF_ADDRS_PER_INODE;
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
1156
1157
static inline void *inline_xattr_addr(struct page *page)
{
1158
	struct f2fs_inode *ri = F2FS_INODE(page);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1159
1160
1161
1162
1163
1164
	return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
					F2FS_INLINE_XATTR_ADDRS]);
}

static inline int inline_xattr_size(struct inode *inode)
{
1165
	if (f2fs_has_inline_xattr(inode))
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1166
1167
1168
1169
1170
		return F2FS_INLINE_XATTR_ADDRS << 2;
	else
		return 0;
}

1171
1172
1173
1174
1175
static inline int f2fs_has_inline_data(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA);
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
1176
1177
1178
1179
1180
static inline bool f2fs_is_atomic_file(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_ATOMIC_FILE);
}

1181
1182
1183
1184
1185
static inline bool f2fs_is_volatile_file(struct inode *inode)
{
	return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE);
}

1186
1187
static inline void *inline_data_addr(struct page *page)
{
1188
	struct f2fs_inode *ri = F2FS_INODE(page);
1189
1190
1191
	return (void *)&(ri->i_addr[1]);
}

1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
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]);
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
1203
1204
1205
1206
1207
static inline int f2fs_readonly(struct super_block *sb)
{
	return sb->s_flags & MS_RDONLY;
}

1208
1209
1210
1211
1212
static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
{
	return is_set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
}

1213
1214
1215
1216
1217
1218
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;
}

1219
1220
1221
1222
#define get_inode_mode(i) \
	((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \
	 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))

1223
1224
1225
1226
1227
1228
/* 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))

1229
1230
1231
1232
1233
/*
 * file.c
 */
int f2fs_sync_file(struct file *, loff_t, loff_t, int);
void truncate_data_blocks(struct dnode_of_data *);
1234
int truncate_blocks(struct inode *, u64, bool);
1235
void f2fs_truncate(struct inode *);
1236
int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
1237
1238
int f2fs_setattr(struct dentry *, struct iattr *);
int truncate_hole(struct inode *, pgoff_t, pgoff_t);
1239
int truncate_data_blocks_range(struct dnode_of_data *, int);
1240
long f2fs_ioctl(struct file *, unsigned int, unsigned long);
1241
long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
1242
1243
1244
1245
1246
1247

/*
 * inode.c
 */
void f2fs_set_inode_flags(struct inode *);
struct inode *f2fs_iget(struct super_block *, unsigned long);
1248
int try_to_free_nats(struct f2fs_sb_info *, int);
1249
void update_inode(struct inode *, struct page *);
1250
void update_inode_page(struct inode *);
1251
1252
int f2fs_write_inode(struct inode *, struct writeback_control *);
void f2fs_evict_inode(struct inode *);
1253
void handle_failed_inode(struct inode *);
1254
1255
1256
1257
1258
1259
1260
1261
1262

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

/*
 * dir.c
 */
1263
1264
extern unsigned char f2fs_filetype_table[F2FS_FT_MAX];
void set_de_type(struct f2fs_dir_entry *, struct inode *);
1265
1266
1267
1268
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);
1269
1270
void do_make_empty_dir(struct inode *, struct inode *,
			struct f2fs_dentry_ptr *);
1271
struct page *init_inode_metadata(struct inode *, struct inode *,
1272
			const struct qstr *, struct page *);
1273
void update_parent_metadata(struct inode *, struct inode *, unsigned int);
1274
int room_for_filename(const void *, int, int);
1275
void f2fs_drop_nlink(struct inode *, struct inode *, struct page *);
1276
1277
1278
1279
1280
1281
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 *);
1282
int update_dent_inode(struct inode *, const struct qstr *);
1283
int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *);
1284
1285
void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *,
							struct inode *);
1286
int f2fs_do_tmpfile(struct inode *, struct inode *);
1287
1288
1289
int f2fs_make_empty(struct inode *, struct inode *);
bool f2fs_empty_dir(struct inode *);

1290
1291
1292
1293
1294
1295
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);
}

1296
1297
1298
1299
/*
 * super.c
 */
int f2fs_sync_fs(struct super_block *, int);
1300
1301
extern __printf(3, 4)
void f2fs_msg(struct super_block *, const char *, const char *, ...);
1302
1303
1304
1305

/*
 * hash.c
 */
1306
f2fs_hash_t f2fs_dentry_hash(const struct qstr *);
1307
1308
1309
1310
1311
1312
1313

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

1314
bool available_free_memory(struct f2fs_sb_info *, int);
1315
1316
1317
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);
1318
1319
1320
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);
1321
int truncate_xattr_node(struct inode *, struct page *);
1322
int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t);
1323
void remove_inode_page(struct inode *);
1324
struct page *new_inode_page(struct inode *);
1325
struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
1326
1327
1328
1329
1330
1331
1332
1333
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);
1334
void recover_inline_xattr(struct inode *, struct page *);
1335
void recover_xattr_data(struct inode *, struct page *, block_t);
1336
1337
1338
1339
1340
1341
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 *);
1342
int __init create_node_manager_caches(void);
1343
1344