f2fs.h 67.1 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
#include <linux/vmalloc.h>
23
#include <linux/bio.h>
24

25
#ifdef CONFIG_F2FS_CHECK_FS
26
#define f2fs_bug_on(sbi, condition)	BUG_ON(condition)
27
#define f2fs_down_write(x, y)	down_write_nest_lock(x, y)
28
#else
29
30
31
32
#define f2fs_bug_on(sbi, condition)					\
	do {								\
		if (unlikely(condition)) {				\
			WARN_ON(1);					\
33
			set_sbi_flag(sbi, SBI_NEED_FSCK);		\
34
35
		}							\
	} while (0)
36
#define f2fs_down_write(x, y)	down_write(x)
37
38
#endif

39
40
41
42
43
44
45
46
47
48
/*
 * 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
49
#define F2FS_MOUNT_INLINE_XATTR		0x00000080
50
#define F2FS_MOUNT_INLINE_DATA		0x00000100
51
52
53
#define F2FS_MOUNT_INLINE_DENTRY	0x00000200
#define F2FS_MOUNT_FLUSH_MERGE		0x00000400
#define F2FS_MOUNT_NOBARRIER		0x00000800
54
#define F2FS_MOUNT_FASTBOOT		0x00001000
55
#define F2FS_MOUNT_EXTENT_CACHE		0x00002000
56
#define F2FS_MOUNT_FORCE_FG_GC		0x00004000
57
58
59
60
61
62
63
64
65

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

66
67
68
69
typedef u32 block_t;	/*
			 * should not change u32, since it is the on-disk block
			 * address format, __le32.
			 */
70
71
72
73
74
75
typedef u32 nid_t;

struct f2fs_mount_info {
	unsigned int	opt;
};

76
77
#define F2FS_FEATURE_ENCRYPT	0x0001

78
79
80
81
82
83
84
#define F2FS_HAS_FEATURE(sb, mask)					\
	((F2FS_SB(sb)->raw_super->feature & cpu_to_le32(mask)) != 0)
#define F2FS_SET_FEATURE(sb, mask)					\
	F2FS_SB(sb)->raw_super->feature |= cpu_to_le32(mask)
#define F2FS_CLEAR_FEATURE(sb, mask)					\
	F2FS_SB(sb)->raw_super->feature &= ~cpu_to_le32(mask)

Jaegeuk Kim's avatar
Jaegeuk Kim committed
85
86
87
#define CRCPOLY_LE 0xedb88320

static inline __u32 f2fs_crc32(void *buf, size_t len)
88
{
Jaegeuk Kim's avatar
Jaegeuk Kim committed
89
90
91
92
93
94
95
96
97
98
	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;
99
100
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
101
static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size)
102
{
Jaegeuk Kim's avatar
Jaegeuk Kim committed
103
	return f2fs_crc32(buf, buf_size) == blk_crc;
104
105
106
107
108
109
110
111
112
113
}

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

114
115
enum {
	CP_UMOUNT,
116
	CP_FASTBOOT,
117
	CP_SYNC,
118
	CP_RECOVERY,
119
	CP_DISCARD,
120
121
};

Jaegeuk Kim's avatar
Jaegeuk Kim committed
122
123
124
#define DEF_BATCHED_TRIM_SECTIONS	32
#define BATCHED_TRIM_SEGMENTS(sbi)	\
		(SM_I(sbi)->trim_sections * (sbi)->segs_per_sec)
125
126
#define BATCHED_TRIM_BLOCKS(sbi)	\
		(BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
127
#define DEF_CP_INTERVAL			60	/* 60 secs */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
128

129
130
struct cp_control {
	int reason;
131
132
133
134
	__u64 trim_start;
	__u64 trim_end;
	__u64 trim_minlen;
	__u64 trimmed;
135
136
};

137
/*
138
 * For CP/NAT/SIT/SSA readahead
139
140
141
142
 */
enum {
	META_CP,
	META_NAT,
143
	META_SIT,
144
145
	META_SSA,
	META_POR,
146
147
};

148
149
150
/* for the list of ino */
enum {
	ORPHAN_INO,		/* for orphan ino list */
151
152
	APPEND_INO,		/* for append ino list */
	UPDATE_INO,		/* for update ino list */
153
154
155
156
	MAX_INO_ENTRY,		/* max. list */
};

struct ino_entry {
157
158
159
160
	struct list_head list;	/* list head */
	nid_t ino;		/* inode number */
};

161
162
163
164
165
166
167
168
/*
 * for the list of directory inodes or gc inodes.
 * NOTE: there are two slab users for this structure, if we add/modify/delete
 * fields in structure for one of slab users, it may affect fields or size of
 * other one, in this condition, it's better to split both of slab and related
 * data structure.
 */
struct inode_entry {
169
170
171
172
	struct list_head list;	/* list head */
	struct inode *inode;	/* vfs inode pointer */
};

173
174
175
176
177
178
179
/* 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 */
};

180
181
182
183
/* 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 */
184
185
186
	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 */
187
188
189
190
191
192
193
194
195
196
};

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

197
198
199
#define MAX_NAT_JENTRIES(sum)	(NAT_JOURNAL_ENTRIES - nats_in_cursum(sum))
#define MAX_SIT_JENTRIES(sum)	(SIT_JOURNAL_ENTRIES - sits_in_cursum(sum))

200
201
202
203
204
205
206
207
208
209
210
211
212
213
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;
}

214
215
216
217
static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,
								int type)
{
	if (type == NAT_JOURNAL)
218
219
		return size <= MAX_NAT_JENTRIES(sum);
	return size <= MAX_SIT_JENTRIES(sum);
220
221
}

222
223
224
/*
 * ioctl commands
 */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
225
226
#define F2FS_IOC_GETFLAGS		FS_IOC_GETFLAGS
#define F2FS_IOC_SETFLAGS		FS_IOC_SETFLAGS
227
#define F2FS_IOC_GETVERSION		FS_IOC_GETVERSION
Jaegeuk Kim's avatar
Jaegeuk Kim committed
228
229
230
231

#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)
232
#define F2FS_IOC_START_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 3)
233
234
#define F2FS_IOC_RELEASE_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 4)
#define F2FS_IOC_ABORT_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 5)
235
#define F2FS_IOC_GARBAGE_COLLECT	_IO(F2FS_IOCTL_MAGIC, 6)
236
#define F2FS_IOC_WRITE_CHECKPOINT	_IO(F2FS_IOCTL_MAGIC, 7)
237

238
239
240
241
242
243
244
#define F2FS_IOC_SET_ENCRYPTION_POLICY					\
		_IOR('f', 19, struct f2fs_encryption_policy)
#define F2FS_IOC_GET_ENCRYPTION_PWSALT					\
		_IOW('f', 20, __u8[16])
#define F2FS_IOC_GET_ENCRYPTION_POLICY					\
		_IOW('f', 21, struct f2fs_encryption_policy)

Jaegeuk Kim's avatar
Jaegeuk Kim committed
245
246
247
248
249
250
251
252
/*
 * should be same as XFS_IOC_GOINGDOWN.
 * Flags for going down operation used by FS_IOC_GOINGDOWN
 */
#define F2FS_IOC_SHUTDOWN	_IOR('X', 125, __u32)	/* Shutdown */
#define F2FS_GOING_DOWN_FULLSYNC	0x0	/* going down with full sync */
#define F2FS_GOING_DOWN_METASYNC	0x1	/* going down with metadata */
#define F2FS_GOING_DOWN_NOSYNC		0x2	/* going down */
253
#define F2FS_GOING_DOWN_METAFLUSH	0x3	/* going down with meta flush */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
254

255
256
257
258
259
260
261
262
#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

263
264
265
/*
 * For INODE and NODE manager
 */
266
/* for directory operations */
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
struct f2fs_str {
	unsigned char *name;
	u32 len;
};

struct f2fs_filename {
	const struct qstr *usr_fname;
	struct f2fs_str disk_name;
	f2fs_hash_t hash;
#ifdef CONFIG_F2FS_FS_ENCRYPTION
	struct f2fs_str crypto_buf;
#endif
};

#define FSTR_INIT(n, l)		{ .name = n, .len = l }
#define FSTR_TO_QSTR(f)		QSTR_INIT((f)->name, (f)->len)
#define fname_name(p)		((p)->disk_name.name)
#define fname_len(p)		((p)->disk_name.len)

286
struct f2fs_dentry_ptr {
287
	struct inode *inode;
288
289
290
291
292
293
	const void *bitmap;
	struct f2fs_dir_entry *dentry;
	__u8 (*filename)[F2FS_SLOT_LEN];
	int max;
};

294
295
static inline void make_dentry_ptr(struct inode *inode,
		struct f2fs_dentry_ptr *d, void *src, int type)
296
{
297
298
	d->inode = inode;

299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
	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;
	}
}

314
315
316
317
318
319
320
/*
 * 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)
321
322
323
324
325
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
326
					 * by get_data_block.
327
					 */
328
329
};

330
#define F2FS_LINK_MAX	0xffffffff	/* maximum link count per file */
331

332
333
#define MAX_DIR_RA_PAGES	4	/* maximum ra pages of dir */

334
335
336
/* vector size for gang look-up from extent cache that consists of radix tree */
#define EXT_TREE_VEC_SIZE	64

337
/* for in-memory extent cache entry */
338
339
340
341
#define F2FS_MIN_EXTENT_LEN	64	/* minimum extent length */

/* number of extent info in extent cache we try to shrink */
#define EXTENT_CACHE_SHRINK_NUMBER	128
342

343
struct extent_info {
344
345
346
347
348
349
350
351
352
353
354
355
356
357
	unsigned int fofs;		/* start offset in a file */
	u32 blk;			/* start block address of the extent */
	unsigned int len;		/* length of the extent */
};

struct extent_node {
	struct rb_node rb_node;		/* rb node located in rb-tree */
	struct list_head list;		/* node in global extent list of sbi */
	struct extent_info ei;		/* extent info */
};

struct extent_tree {
	nid_t ino;			/* inode number */
	struct rb_root root;		/* root of extent info rb-tree */
358
	struct extent_node *cached_en;	/* recently accessed extent node */
359
	struct extent_info largest;	/* largested extent info */
360
361
362
	rwlock_t lock;			/* protect extent info rb-tree */
	atomic_t refcount;		/* reference count of rb-tree */
	unsigned int count;		/* # of extent node in rb-tree*/
363
364
};

Jaegeuk Kim's avatar
Jaegeuk Kim committed
365
366
367
368
369
370
371
/*
 * This structure is taken from ext4_map_blocks.
 *
 * Note that, however, f2fs uses NEW and MAPPED flags for f2fs_map_blocks().
 */
#define F2FS_MAP_NEW		(1 << BH_New)
#define F2FS_MAP_MAPPED		(1 << BH_Mapped)
372
373
374
#define F2FS_MAP_UNWRITTEN	(1 << BH_Unwritten)
#define F2FS_MAP_FLAGS		(F2FS_MAP_NEW | F2FS_MAP_MAPPED |\
				F2FS_MAP_UNWRITTEN)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
375
376
377
378
379
380
381
382

struct f2fs_map_blocks {
	block_t m_pblk;
	block_t m_lblk;
	unsigned int m_len;
	unsigned int m_flags;
};

Chao Yu's avatar
Chao Yu committed
383
384
385
386
387
388
/* for flag in get_data_block */
#define F2FS_GET_BLOCK_READ		0
#define F2FS_GET_BLOCK_DIO		1
#define F2FS_GET_BLOCK_FIEMAP		2
#define F2FS_GET_BLOCK_BMAP		3

389
390
391
392
/*
 * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
 */
#define FADVISE_COLD_BIT	0x01
393
#define FADVISE_LOST_PINO_BIT	0x02
394
#define FADVISE_ENCRYPT_BIT	0x04
395
#define FADVISE_ENC_NAME_BIT	0x08
396

397
398
399
400
401
402
#define file_is_cold(inode)	is_file(inode, FADVISE_COLD_BIT)
#define file_wrong_pino(inode)	is_file(inode, FADVISE_LOST_PINO_BIT)
#define file_set_cold(inode)	set_file(inode, FADVISE_COLD_BIT)
#define file_lost_pino(inode)	set_file(inode, FADVISE_LOST_PINO_BIT)
#define file_clear_cold(inode)	clear_file(inode, FADVISE_COLD_BIT)
#define file_got_pino(inode)	clear_file(inode, FADVISE_LOST_PINO_BIT)
403
404
405
#define file_is_encrypt(inode)	is_file(inode, FADVISE_ENCRYPT_BIT)
#define file_set_encrypt(inode)	set_file(inode, FADVISE_ENCRYPT_BIT)
#define file_clear_encrypt(inode) clear_file(inode, FADVISE_ENCRYPT_BIT)
406
407
#define file_enc_name(inode)	is_file(inode, FADVISE_ENC_NAME_BIT)
#define file_set_enc_name(inode) set_file(inode, FADVISE_ENC_NAME_BIT)
408
409
410
411
412
413
414

/* Encryption algorithms */
#define F2FS_ENCRYPTION_MODE_INVALID		0
#define F2FS_ENCRYPTION_MODE_AES_256_XTS	1
#define F2FS_ENCRYPTION_MODE_AES_256_GCM	2
#define F2FS_ENCRYPTION_MODE_AES_256_CBC	3
#define F2FS_ENCRYPTION_MODE_AES_256_CTS	4
415

416
417
#include "f2fs_crypto.h"

418
419
#define DEF_DIR_LEVEL		0

420
421
422
423
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 */
424
	unsigned char i_dir_level;	/* use for dentry level for large dir */
425
	unsigned int i_current_depth;	/* use only in directory structure */
426
	unsigned int i_pino;		/* parent inode number */
427
428
429
430
	umode_t i_acl_mode;		/* keep file acl mode temporarily */

	/* Use below internally in f2fs*/
	unsigned long flags;		/* use to pass per-file flags */
431
	struct rw_semaphore i_sem;	/* protect fi info */
432
	atomic_t dirty_pages;		/* # of dirty pages */
433
434
435
	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 */
436
	unsigned long long xattr_ver;	/* cp version of xattr modification */
437
	struct inode_entry *dirty_dir;	/* the pointer of dirty dir */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
438
439
440

	struct list_head inmem_pages;	/* inmemory pages managed by f2fs */
	struct mutex inmem_lock;	/* lock for inmemory pages */
441

442
443
	struct extent_tree *extent_tree;	/* cached extent_tree entry */

444
445
446
447
#ifdef CONFIG_F2FS_FS_ENCRYPTION
	/* Encryption params */
	struct f2fs_crypt_info *i_crypt_info;
#endif
448
449
450
451
452
453
};

static inline void get_extent_info(struct extent_info *ext,
					struct f2fs_extent i_ext)
{
	ext->fofs = le32_to_cpu(i_ext.fofs);
454
	ext->blk = le32_to_cpu(i_ext.blk);
455
456
457
458
459
460
461
	ext->len = le32_to_cpu(i_ext.len);
}

static inline void set_raw_extent(struct extent_info *ext,
					struct f2fs_extent *i_ext)
{
	i_ext->fofs = cpu_to_le32(ext->fofs);
462
	i_ext->blk = cpu_to_le32(ext->blk);
463
464
465
	i_ext->len = cpu_to_le32(ext->len);
}

466
467
468
469
470
471
472
473
static inline void set_extent_info(struct extent_info *ei, unsigned int fofs,
						u32 blk, unsigned int len)
{
	ei->fofs = fofs;
	ei->blk = blk;
	ei->len = len;
}

474
475
476
477
478
479
480
static inline bool __is_extent_same(struct extent_info *ei1,
						struct extent_info *ei2)
{
	return (ei1->fofs == ei2->fofs && ei1->blk == ei2->blk &&
						ei1->len == ei2->len);
}

481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
static inline bool __is_extent_mergeable(struct extent_info *back,
						struct extent_info *front)
{
	return (back->fofs + back->len == front->fofs &&
			back->blk + back->len == front->blk);
}

static inline bool __is_back_mergeable(struct extent_info *cur,
						struct extent_info *back)
{
	return __is_extent_mergeable(back, cur);
}

static inline bool __is_front_mergeable(struct extent_info *cur,
						struct extent_info *front)
{
	return __is_extent_mergeable(cur, front);
}

500
501
502
503
504
505
506
static inline void __try_update_largest_extent(struct extent_tree *et,
						struct extent_node *en)
{
	if (en->ei.len > et->largest.len)
		et->largest = en->ei;
}

507
508
509
struct f2fs_nm_info {
	block_t nat_blkaddr;		/* base disk address of NAT */
	nid_t max_nid;			/* maximum possible node ids */
510
	nid_t available_nids;		/* maximum available node ids */
511
	nid_t next_scan_nid;		/* the next nid to be scanned */
512
	unsigned int ram_thresh;	/* control the memory footprint */
Chao Yu's avatar
Chao Yu committed
513
	unsigned int ra_nid_pages;	/* # of nid pages to be readaheaded */
514
515
516

	/* NAT cache management */
	struct radix_tree_root nat_root;/* root of the nat entry cache */
517
	struct radix_tree_root nat_set_root;/* root of the nat set cache */
518
	struct rw_semaphore nat_tree_lock;	/* protect nat_tree_lock */
519
	struct list_head nat_entries;	/* cached nat entry list (clean) */
520
	unsigned int nat_cnt;		/* the # of cached nat entries */
521
	unsigned int dirty_nat_cnt;	/* total num of nat entries in set */
522
523

	/* free node ids management */
524
	struct radix_tree_root free_nid_root;/* root of the free_nid cache */
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
	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)
{
553
	memset(dn, 0, sizeof(*dn));
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
	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 */
584
585
	NO_CHECK_TYPE,
	CURSEG_DIRECT_IO,	/* to use for the direct IO path */
586
587
};

588
589
struct flush_cmd {
	struct completion wait;
590
	struct llist_node llnode;
591
592
593
	int ret;
};

594
595
596
struct flush_cmd_control {
	struct task_struct *f2fs_issue_flush;	/* flush thread */
	wait_queue_head_t flush_wait_queue;	/* waiting queue for wake-up */
597
598
	struct llist_head issue_list;		/* list for command issue */
	struct llist_node *dispatch_list;	/* list for command dispatch */
599
600
};

601
602
603
604
605
606
607
608
609
610
611
612
613
614
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 */
615
616
617

	/* a threshold to reclaim prefree segments */
	unsigned int rec_prefree_segments;
618
619
620
621
622

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

Jaegeuk Kim's avatar
Jaegeuk Kim committed
624
625
626
	/* for batched trimming */
	unsigned int trim_sections;		/* # of sections to trim */

627
628
	struct list_head sit_entry_set;	/* sit entry set list */

629
630
	unsigned int ipu_policy;	/* in-place-update policy */
	unsigned int min_ipu_util;	/* in-place-update threshold */
631
	unsigned int min_fsync_blocks;	/* threshold for fsync */
632
633

	/* for flush command control */
634
635
	struct flush_cmd_control *cmd_control_info;

636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
};

/*
 * 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,
652
	F2FS_INMEM_PAGES,
653
654
655
656
	NR_COUNT_TYPE,
};

/*
arter97's avatar
arter97 committed
657
 * The below are the page types of bios used in submit_bio().
658
659
660
661
662
663
664
665
666
 * 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.
 */
667
#define PAGE_TYPE_OF_BIO(type)	((type) > META ? META : (type))
668
669
670
671
672
673
enum page_type {
	DATA,
	NODE,
	META,
	NR_PAGE_TYPE,
	META_FLUSH,
674
675
676
677
	INMEM,		/* the below types are used by tracepoints only. */
	INMEM_DROP,
	IPU,
	OPU,
678
679
};

Jaegeuk Kim's avatar
Jaegeuk Kim committed
680
struct f2fs_io_info {
681
	struct f2fs_sb_info *sbi;	/* f2fs_sb_info pointer */
682
683
	enum page_type type;	/* contains DATA/NODE/META/META_FLUSH */
	int rw;			/* contains R/RS/W/WS with REQ_META/REQ_PRIO */
684
	block_t blk_addr;	/* block address to be written */
685
	struct page *page;	/* page to be written */
686
	struct page *encrypted_page;	/* encrypted page */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
687
688
};

689
#define is_read_io(rw)	(((rw) & 1) == READ)
690
struct f2fs_bio_info {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
691
	struct f2fs_sb_info *sbi;	/* f2fs superblock */
692
693
	struct bio *bio;		/* bios to merge */
	sector_t last_block_in_bio;	/* last block number */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
694
	struct f2fs_io_info fio;	/* store buffered io info. */
695
	struct rw_semaphore io_rwsem;	/* blocking op for bio */
696
697
};

698
699
700
701
702
703
704
705
/* 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 */
};

706
707
708
709
710
711
712
713
/* For s_flag in struct f2fs_sb_info */
enum {
	SBI_IS_DIRTY,				/* dirty flag for checkpoint */
	SBI_IS_CLOSE,				/* specify unmounting */
	SBI_NEED_FSCK,				/* need fsck.f2fs to fix */
	SBI_POR_DOING,				/* recovery is doing or not */
};

714
715
struct f2fs_sb_info {
	struct super_block *sb;			/* pointer to VFS super block */
716
	struct proc_dir_entry *s_proc;		/* proc entry */
717
718
	struct buffer_head *raw_super_buf;	/* buffer head of raw sb */
	struct f2fs_super_block *raw_super;	/* raw super block pointer */
719
	int s_flag;				/* flags for sbi */
720
721
722
723
724
725
726

	/* 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 */
727
728

	/* for bio operations */
729
	struct f2fs_bio_info read_io;			/* for read bios */
730
	struct f2fs_bio_info write_io[NR_PAGE_TYPE];	/* for write bios */
731
732
733
734

	/* for checkpoint */
	struct f2fs_checkpoint *ckpt;		/* raw checkpoint pointer */
	struct inode *meta_inode;		/* cache meta blocks */
735
	struct mutex cp_mutex;			/* checkpoint procedure lock */
736
	struct rw_semaphore cp_rwsem;		/* blocking FS operations */
737
	struct rw_semaphore node_write;		/* locking node writes */
738
	struct mutex writepages;		/* mutex for writepages() */
739
	wait_queue_head_t cp_wait;
740
	long cp_expires, cp_interval;		/* next expected periodic cp */
741

742
	struct inode_management im[MAX_INO_ENTRY];      /* manage inode cache */
743
744

	/* for orphan inode, use 0'th array */
745
	unsigned int max_orphans;		/* max orphan inodes */
746
747
748
749
750

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

751
752
753
754
755
756
757
758
	/* for extent tree cache */
	struct radix_tree_root extent_tree_root;/* cache extent cache entries */
	struct rw_semaphore extent_tree_lock;	/* locking extent radix tree */
	struct list_head extent_list;		/* lru list for shrinker */
	spinlock_t extent_lock;			/* locking extent lru list */
	int total_ext_tree;			/* extent tree count */
	atomic_t total_ext_node;		/* extent info count */

arter97's avatar
arter97 committed
759
	/* basic filesystem units */
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
	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 */
775
	int dir_level;				/* directory level */
776
777
778
779

	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 */
780
	block_t discard_blks;			/* discard command candidats */
781
782
783
784
785
786
787
788
789
	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 */
790
	unsigned int cur_victim_sec;		/* current victim section num */
791

792
793
794
	/* maximum # of trials to find a victim segment for SSR and GC */
	unsigned int max_victim_search;

795
796
797
798
	/*
	 * for stat information.
	 * one is for the LFS mode, and the other is for the SSR mode.
	 */
799
#ifdef CONFIG_F2FS_STAT_FS
800
801
802
	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 */
803
	atomic_t inplace_count;		/* # of inplace update */
804
805
806
807
	atomic64_t total_hit_ext;		/* # of lookup extent cache */
	atomic64_t read_hit_rbtree;		/* # of hit rbtree extent node */
	atomic64_t read_hit_largest;		/* # of hit largest extent node */
	atomic64_t read_hit_cached;		/* # of hit cached extent node */
Chao Yu's avatar
Chao Yu committed
808
	atomic_t inline_xattr;			/* # of inline_xattr inodes */
809
810
	atomic_t inline_inode;			/* # of inline_data inodes */
	atomic_t inline_dir;			/* # of inline_dentry inodes */
811
	int bg_gc;				/* background gc calls */
812
813
814
	unsigned int n_dirty_dirs;		/* # of dir inodes */
#endif
	unsigned int last_victim[2];		/* last victim segment # */
815
	spinlock_t stat_lock;			/* lock for stat operations */
816
817
818
819

	/* For sysfs suppport */
	struct kobject s_kobj;
	struct completion s_kobj_unregister;
820
821
822
823
824

	/* For shrinker support */
	struct list_head s_list;
	struct mutex umount_mutex;
	unsigned int shrinker_run_no;
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
};

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

840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
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);
}

855
856
857
858
859
860
861
862
863
864
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);
}

865
866
867
868
869
static inline struct f2fs_node *F2FS_NODE(struct page *page)
{
	return (struct f2fs_node *)page_address(page);
}

870
871
872
873
874
static inline struct f2fs_inode *F2FS_INODE(struct page *page)
{
	return &((struct f2fs_node *)page_address(page))->i;
}

875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
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);
}

900
901
902
903
904
static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
{
	return sbi->meta_inode->i_mapping;
}

905
906
907
908
909
static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
{
	return sbi->node_inode->i_mapping;
}

910
911
912
913
914
915
static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)
{
	return sbi->s_flag & (0x01 << type);
}

static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
916
{
917
	sbi->s_flag |= (0x01 << type);
918
919
}

920
static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
921
{
922
	sbi->s_flag &= ~(0x01 << type);
923
924
}

925
926
927
928
929
static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
{
	return le64_to_cpu(cp->checkpoint_ver);
}

930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
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);
}

950
static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
951
{
952
	down_read(&sbi->cp_rwsem);
953
954
}

955
static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
956
{
957
	up_read(&sbi->cp_rwsem);
958
959
}

960
static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
961
{
962
	f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex);
963
964
}

965
static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
966
{
967
	up_write(&sbi->cp_rwsem);
968
969
}

970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
static inline int __get_cp_reason(struct f2fs_sb_info *sbi)
{
	int reason = CP_SYNC;

	if (test_opt(sbi, FASTBOOT))
		reason = CP_FASTBOOT;
	if (is_sbi_flag_set(sbi, SBI_IS_CLOSE))
		reason = CP_UMOUNT;
	return reason;
}

static inline bool __remain_node_summaries(int reason)
{
	return (reason == CP_UMOUNT || reason == CP_FASTBOOT);
}

static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)
{
	return (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG) ||
			is_set_ckpt_flags(F2FS_CKPT(sbi), CP_FASTBOOT_FLAG));
}

992
993
994
/*
 * Check whether the given nid is within node id range.
 */
995
static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
996
{
997
998
	if (unlikely(nid < F2FS_ROOT_INO(sbi)))
		return -EINVAL;
999
	if (unlikely(nid >= NM_I(sbi)->max_nid))
1000
1001
		return -EINVAL;
	return 0;
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
}

#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
1012
		return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
1013
	else
Chris Fries's avatar
Chris Fries committed
1014
		return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
1015
1016
}

1017
1018
1019
1020
1021
static inline bool f2fs_has_xattr_block(unsigned int ofs)
{
	return ofs == XATTR_NODE_OFFSET;
}

1022
1023
1024
1025
1026
1027
1028
1029
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;
1030
	if (unlikely(valid_block_count > sbi->user_block_count)) {
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
		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;
}

1041
static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
1042
1043
1044
1045
						struct inode *inode,
						blkcnt_t count)
{
	spin_lock(&sbi->stat_lock);
1046
1047
	f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
	f2fs_bug_on(sbi, inode->i_blocks < count);
1048
1049
1050
1051
1052
1053
1054
1055
	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]);
1056
	set_sbi_flag(sbi, SBI_IS_DIRTY);
1057
1058
}

1059
static inline void inode_inc_dirty_pages(struct inode *inode)
1060
{
1061
1062
1063
	atomic_inc(&F2FS_I(inode)->dirty_pages);
	if (S_ISDIR(inode->i_mode))
		inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
1064
1065
1066
1067
1068
1069
1070
}

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

1071
static inline void inode_dec_dirty_pages(struct inode *inode)
1072
{
1073
1074
	if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
			!S_ISLNK(inode->i_mode))
1075
1076
		return;

1077
1078
1079
1080
	atomic_dec(&F2FS_I(inode)->dirty_pages);

	if (S_ISDIR(inode->i_mode))
		dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
1081
1082
1083
1084
1085
1086
1087
}

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

1088
static inline int get_dirty_pages(struct inode *inode)
1089
{
1090
	return atomic_read(&F2FS_I(inode)->dirty_pages);
1091
1092
}

1093
1094
1095
1096
1097
1098
1099
1100
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;
}

1101
1102
static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
{
1103
	return sbi->total_valid_block_count;
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
}

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

1119
1120
1121
1122
1123
static inline block_t __cp_payload(struct f2fs_sb_info *sbi)
{
	return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
}

1124
1125
1126
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
1127
1128
	int offset;

1129
	if (__cp_payload(sbi) > 0) {
Changman Lee's avatar
Changman Lee committed
1130
1131
1132
		if (flag == NAT_BITMAP)
			return &ckpt->sit_nat_version_bitmap;
		else
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1133
			return (unsigned char *)ckpt + F2FS_BLKSIZE;
Changman Lee's avatar
Changman Lee committed
1134
1135
	} else {
		offset = (flag == NAT_BITMAP) ?
1136
			le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
Changman Lee's avatar
Changman Lee committed
1137
1138
		return &ckpt->sit_nat_version_bitmap + offset;
	}
1139
1140
1141
1142
1143
1144
}

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

1147
	start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
1148
1149
1150

	/*
	 * odd numbered checkpoint should at cp segment 0
arter97's avatar
arter97 committed
1151
	 * and even segment must be at cp segment 1
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
	 */
	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,
1165
						struct inode *inode)
1166
1167
1168
1169
1170
1171
{
	block_t	valid_block_count;
	unsigned int valid_node_count;

	spin_lock(&sbi->stat_lock);

1172
	valid_block_count = sbi->total_valid_block_count + 1;
1173
	if (unlikely(valid_block_count > sbi->user_block_count)) {
1174
1175
1176
1177
		spin_unlock(&sbi->stat_lock);
		return false;
	}

1178
	valid_node_count = sbi->total_valid_node_count + 1;
1179
	if (unlikely(valid_node_count > sbi->total_node_count)) {
1180
1181
1182
1183
1184
		spin_unlock(&sbi->stat_lock);
		return false;
	}

	if (inode)
1185
1186
1187
1188
1189
		inode->i_blocks++;

	sbi->alloc_valid_block_count++;
	sbi->total_valid_node_count++;
	sbi->total_valid_block_count++;
1190
1191
1192
1193
1194
1195
	spin_unlock(&sbi->stat_lock);

	return true;
}

static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
1196
						struct inode *inode)
1197
1198
1199
{
	spin_lock(&sbi->stat_lock);

1200
1201
1202
	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);
1203

1204
1205
1206
	inode->i_blocks--;
	sbi->total_valid_node_count--;
	sbi->total_valid_block_count--;
1207
1208
1209
1210
1211
1212

	spin_unlock(&sbi->stat_lock);
}

static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
{
1213
	return sbi->total_valid_node_count;
1214
1215
1216
1217
1218
}

static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
{
	spin_lock(&sbi->stat_lock);
1219
	f2fs_bug_on(sbi, sbi->total_valid_inode_count == sbi->total_node_count);
1220
1221
1222
1223
	sbi->total_valid_inode_count++;
	spin_unlock(&sbi->stat_lock);
}

1224
static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
1225
1226
{
	spin_lock(&sbi->stat_lock);
1227
	f2fs_bug_on(sbi, !sbi->total_valid_inode_count);
1228
1229
1230
1231
1232
1233
	sbi->total_valid_inode_count--;
	spin_unlock(&sbi->stat_lock);
}

static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi)
{
1234
	return sbi->total_valid_inode_count;
1235
1236
}

1237
1238
1239
1240
1241
1242
1243
1244
static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
						pgoff_t index, bool for_write)
{
	if (!for_write)
		return grab_cache_page(mapping, index);
	return grab_cache_page_write_begin(mapping, index, AOP_FLAG_NOFS);
}

1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
static inline void f2fs_copy_page(struct page *src, struct page *dst)
{
	char *src_kaddr = kmap(src);
	char *dst_kaddr = kmap(dst);

	memcpy(dst_kaddr, src_kaddr, PAGE_SIZE);
	kunmap(dst);
	kunmap(src);
}

1255
1256
static inline void f2fs_put_page(struct page *page, int unlock)
{
1257
	if (!page)
1258
1259
1260
		return;

	if (unlock) {
1261
		f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page));
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
		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,
1278
					size_t size)
1279
{
1280
	return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
1281
1282
}

1283
1284
1285
1286
1287
static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep,
						gfp_t flags)
{
	void *entry;

1288
1289
1290
	entry = kmem_cache_alloc(cachep, flags);
	if (!entry)
		entry = kmem_cache_alloc(cachep, flags | __GFP_NOFAIL);
1291
1292
1293
	return entry;
}

1294
1295
1296
1297
1298
1299
static inline struct bio *f2fs_bio_alloc(int npages)
{
	struct bio *bio;

	/* No failure on bio allocation */
	bio = bio_alloc(GFP_NOIO, npages);
1300
1301
	if (!bio)
		bio = bio_alloc(GFP_NOIO | __GFP_NOFAIL, npages);
1302
1303
1304
	return bio;
}

1305
1306
1307
1308
1309
1310
1311
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();
}

1312
1313
1314
1315
#define RAW_IS_INODE(p)	((p)->footer.nid == (p)->footer.ino)

static inline bool IS_INODE(struct page *page)
{
1316
	struct f2fs_node *p = F2FS_NODE(page);
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
	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;
1330
	raw_node = F2FS_NODE(node_page);
Jaegeuk Kim's avatar