]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - fs/f2fs/f2fs.h
f2fs: declare missing static function
[mirror_ubuntu-jammy-kernel.git] / fs / f2fs / f2fs.h
CommitLineData
0a8165d7 1/*
39a53e0c
JK
2 * fs/f2fs/f2fs.h
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11#ifndef _LINUX_F2FS_H
12#define _LINUX_F2FS_H
13
14#include <linux/types.h>
15#include <linux/page-flags.h>
16#include <linux/buffer_head.h>
39a53e0c
JK
17#include <linux/slab.h>
18#include <linux/crc32.h>
19#include <linux/magic.h>
c2d715d1 20#include <linux/kobject.h>
7bd59381 21#include <linux/sched.h>
39307a8e 22#include <linux/vmalloc.h>
740432f8 23#include <linux/bio.h>
d0239e1b 24#include <linux/blkdev.h>
0b81d077 25#include <linux/fscrypto.h>
43b6573b 26#include <crypto/hash.h>
39a53e0c 27
5d56b671 28#ifdef CONFIG_F2FS_CHECK_FS
9850cf4a 29#define f2fs_bug_on(sbi, condition) BUG_ON(condition)
5d56b671 30#else
9850cf4a
JK
31#define f2fs_bug_on(sbi, condition) \
32 do { \
33 if (unlikely(condition)) { \
34 WARN_ON(1); \
caf0047e 35 set_sbi_flag(sbi, SBI_NEED_FSCK); \
9850cf4a
JK
36 } \
37 } while (0)
5d56b671
JK
38#endif
39
2c63fead
JK
40#ifdef CONFIG_F2FS_FAULT_INJECTION
41enum {
42 FAULT_KMALLOC,
c41f3cc3 43 FAULT_PAGE_ALLOC,
cb78942b
JK
44 FAULT_ALLOC_NID,
45 FAULT_ORPHAN,
46 FAULT_BLOCK,
47 FAULT_DIR_DEPTH,
53aa6bbf 48 FAULT_EVICT_INODE,
8b038c70 49 FAULT_IO,
0f348028 50 FAULT_CHECKPOINT,
2c63fead
JK
51 FAULT_MAX,
52};
53
08796897
SY
54struct f2fs_fault_info {
55 atomic_t inject_ops;
56 unsigned int inject_rate;
57 unsigned int inject_type;
58};
59
2c63fead 60extern char *fault_name[FAULT_MAX];
1ecc0c5c 61#define IS_FAULT_SET(fi, type) (fi->inject_type & (1 << (type)))
2c63fead
JK
62#endif
63
39a53e0c
JK
64/*
65 * For mount options
66 */
67#define F2FS_MOUNT_BG_GC 0x00000001
68#define F2FS_MOUNT_DISABLE_ROLL_FORWARD 0x00000002
69#define F2FS_MOUNT_DISCARD 0x00000004
70#define F2FS_MOUNT_NOHEAP 0x00000008
71#define F2FS_MOUNT_XATTR_USER 0x00000010
72#define F2FS_MOUNT_POSIX_ACL 0x00000020
73#define F2FS_MOUNT_DISABLE_EXT_IDENTIFY 0x00000040
444c580f 74#define F2FS_MOUNT_INLINE_XATTR 0x00000080
1001b347 75#define F2FS_MOUNT_INLINE_DATA 0x00000100
34d67deb
CY
76#define F2FS_MOUNT_INLINE_DENTRY 0x00000200
77#define F2FS_MOUNT_FLUSH_MERGE 0x00000400
78#define F2FS_MOUNT_NOBARRIER 0x00000800
d5053a34 79#define F2FS_MOUNT_FASTBOOT 0x00001000
89672159 80#define F2FS_MOUNT_EXTENT_CACHE 0x00002000
6aefd93b 81#define F2FS_MOUNT_FORCE_FG_GC 0x00004000
343f40f0 82#define F2FS_MOUNT_DATA_FLUSH 0x00008000
73faec4d 83#define F2FS_MOUNT_FAULT_INJECTION 0x00010000
36abef4e
JK
84#define F2FS_MOUNT_ADAPTIVE 0x00020000
85#define F2FS_MOUNT_LFS 0x00040000
39a53e0c
JK
86
87#define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
88#define set_opt(sbi, option) (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
89#define test_opt(sbi, option) (sbi->mount_opt.opt & F2FS_MOUNT_##option)
90
91#define ver_after(a, b) (typecheck(unsigned long long, a) && \
92 typecheck(unsigned long long, b) && \
93 ((long long)((a) - (b)) > 0))
94
a9841c4d
JK
95typedef u32 block_t; /*
96 * should not change u32, since it is the on-disk block
97 * address format, __le32.
98 */
39a53e0c
JK
99typedef u32 nid_t;
100
101struct f2fs_mount_info {
102 unsigned int opt;
103};
104
cde4de12 105#define F2FS_FEATURE_ENCRYPT 0x0001
0bfd7a09 106#define F2FS_FEATURE_BLKZONED 0x0002
cde4de12 107
76f105a2
JK
108#define F2FS_HAS_FEATURE(sb, mask) \
109 ((F2FS_SB(sb)->raw_super->feature & cpu_to_le32(mask)) != 0)
110#define F2FS_SET_FEATURE(sb, mask) \
111 F2FS_SB(sb)->raw_super->feature |= cpu_to_le32(mask)
112#define F2FS_CLEAR_FEATURE(sb, mask) \
113 F2FS_SB(sb)->raw_super->feature &= ~cpu_to_le32(mask)
114
39a53e0c
JK
115/*
116 * For checkpoint manager
117 */
118enum {
119 NAT_BITMAP,
120 SIT_BITMAP
121};
122
75ab4cb8
JK
123enum {
124 CP_UMOUNT,
119ee914 125 CP_FASTBOOT,
75ab4cb8 126 CP_SYNC,
10027551 127 CP_RECOVERY,
4b2fecc8 128 CP_DISCARD,
75ab4cb8
JK
129};
130
2d9e9c32 131#define DEF_BATCHED_TRIM_SECTIONS 2
bba681cb
JK
132#define BATCHED_TRIM_SEGMENTS(sbi) \
133 (SM_I(sbi)->trim_sections * (sbi)->segs_per_sec)
a66cdd98
JK
134#define BATCHED_TRIM_BLOCKS(sbi) \
135 (BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
15469963
JK
136
137#define DISCARD_ISSUE_RATE 8
60b99b48 138#define DEF_CP_INTERVAL 60 /* 60 secs */
dcf25fe8 139#define DEF_IDLE_INTERVAL 5 /* 5 secs */
bba681cb 140
75ab4cb8
JK
141struct cp_control {
142 int reason;
4b2fecc8
JK
143 __u64 trim_start;
144 __u64 trim_end;
145 __u64 trim_minlen;
146 __u64 trimmed;
75ab4cb8
JK
147};
148
662befda 149/*
81c1a0f1 150 * For CP/NAT/SIT/SSA readahead
662befda
CY
151 */
152enum {
153 META_CP,
154 META_NAT,
81c1a0f1 155 META_SIT,
4c521f49
JK
156 META_SSA,
157 META_POR,
662befda
CY
158};
159
6451e041
JK
160/* for the list of ino */
161enum {
162 ORPHAN_INO, /* for orphan ino list */
fff04f90
JK
163 APPEND_INO, /* for append ino list */
164 UPDATE_INO, /* for update ino list */
6451e041
JK
165 MAX_INO_ENTRY, /* max. list */
166};
167
168struct ino_entry {
39a53e0c
JK
169 struct list_head list; /* list head */
170 nid_t ino; /* inode number */
171};
172
2710fd7e 173/* for the list of inodes to be GCed */
06292073 174struct inode_entry {
39a53e0c
JK
175 struct list_head list; /* list head */
176 struct inode *inode; /* vfs inode pointer */
177};
178
7fd9e544
JK
179/* for the list of blockaddresses to be discarded */
180struct discard_entry {
181 struct list_head list; /* list head */
182 block_t blkaddr; /* block address to be discarded */
183 int len; /* # of consecutive blocks of the discard */
184};
185
15469963
JK
186enum {
187 D_PREP,
188 D_SUBMIT,
189 D_DONE,
190};
191
b01a9201
JK
192struct discard_cmd {
193 struct list_head list; /* command list */
194 struct completion wait; /* compleation */
195 block_t lstart; /* logical start address */
196 block_t len; /* length */
197 struct bio *bio; /* bio */
15469963 198 int state; /* state */
275b66b0
CY
199};
200
0b54fb84 201struct discard_cmd_control {
15469963 202 struct task_struct *f2fs_issue_discard; /* discard thread */
0b54fb84
JK
203 struct list_head discard_entry_list; /* 4KB discard entry list */
204 int nr_discards; /* # of discards in the list */
205 struct list_head discard_cmd_list; /* discard cmd list */
15469963
JK
206 wait_queue_head_t discard_wait_queue; /* waiting queue for wake-up */
207 struct mutex cmd_lock;
0b54fb84 208 int max_discards; /* max. discards to be issued */
dcc9165d 209 atomic_t submit_discard; /* # of issued discard */
0b54fb84
JK
210};
211
39a53e0c
JK
212/* for the list of fsync inodes, used only during recovery */
213struct fsync_inode_entry {
214 struct list_head list; /* list head */
215 struct inode *inode; /* vfs inode pointer */
c52e1b10
JK
216 block_t blkaddr; /* block address locating the last fsync */
217 block_t last_dentry; /* block address locating the last dentry */
39a53e0c
JK
218};
219
dfc08a12
CY
220#define nats_in_cursum(jnl) (le16_to_cpu(jnl->n_nats))
221#define sits_in_cursum(jnl) (le16_to_cpu(jnl->n_sits))
39a53e0c 222
dfc08a12
CY
223#define nat_in_journal(jnl, i) (jnl->nat_j.entries[i].ne)
224#define nid_in_journal(jnl, i) (jnl->nat_j.entries[i].nid)
225#define sit_in_journal(jnl, i) (jnl->sit_j.entries[i].se)
226#define segno_in_journal(jnl, i) (jnl->sit_j.entries[i].segno)
39a53e0c 227
dfc08a12
CY
228#define MAX_NAT_JENTRIES(jnl) (NAT_JOURNAL_ENTRIES - nats_in_cursum(jnl))
229#define MAX_SIT_JENTRIES(jnl) (SIT_JOURNAL_ENTRIES - sits_in_cursum(jnl))
309cc2b6 230
dfc08a12 231static inline int update_nats_in_cursum(struct f2fs_journal *journal, int i)
39a53e0c 232{
dfc08a12
CY
233 int before = nats_in_cursum(journal);
234 journal->n_nats = cpu_to_le16(before + i);
39a53e0c
JK
235 return before;
236}
237
dfc08a12 238static inline int update_sits_in_cursum(struct f2fs_journal *journal, int i)
39a53e0c 239{
dfc08a12
CY
240 int before = sits_in_cursum(journal);
241 journal->n_sits = cpu_to_le16(before + i);
39a53e0c
JK
242 return before;
243}
244
dfc08a12
CY
245static inline bool __has_cursum_space(struct f2fs_journal *journal,
246 int size, int type)
184a5cd2
CY
247{
248 if (type == NAT_JOURNAL)
dfc08a12
CY
249 return size <= MAX_NAT_JENTRIES(journal);
250 return size <= MAX_SIT_JENTRIES(journal);
184a5cd2
CY
251}
252
e9750824
NJ
253/*
254 * ioctl commands
255 */
88b88a66
JK
256#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS
257#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS
d49f3e89 258#define F2FS_IOC_GETVERSION FS_IOC_GETVERSION
88b88a66
JK
259
260#define F2FS_IOCTL_MAGIC 0xf5
261#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1)
262#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2)
02a1335f 263#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3)
1e84371f
JK
264#define F2FS_IOC_RELEASE_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 4)
265#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5)
c1c1b583 266#define F2FS_IOC_GARBAGE_COLLECT _IO(F2FS_IOCTL_MAGIC, 6)
456b88e4 267#define F2FS_IOC_WRITE_CHECKPOINT _IO(F2FS_IOCTL_MAGIC, 7)
d323d005 268#define F2FS_IOC_DEFRAGMENT _IO(F2FS_IOCTL_MAGIC, 8)
4dd6f977
JK
269#define F2FS_IOC_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
270 struct f2fs_move_range)
e9750824 271
0b81d077
JK
272#define F2FS_IOC_SET_ENCRYPTION_POLICY FS_IOC_SET_ENCRYPTION_POLICY
273#define F2FS_IOC_GET_ENCRYPTION_POLICY FS_IOC_GET_ENCRYPTION_POLICY
274#define F2FS_IOC_GET_ENCRYPTION_PWSALT FS_IOC_GET_ENCRYPTION_PWSALT
f424f664 275
1abff93d
JK
276/*
277 * should be same as XFS_IOC_GOINGDOWN.
278 * Flags for going down operation used by FS_IOC_GOINGDOWN
279 */
280#define F2FS_IOC_SHUTDOWN _IOR('X', 125, __u32) /* Shutdown */
281#define F2FS_GOING_DOWN_FULLSYNC 0x0 /* going down with full sync */
282#define F2FS_GOING_DOWN_METASYNC 0x1 /* going down with metadata */
283#define F2FS_GOING_DOWN_NOSYNC 0x2 /* going down */
c912a829 284#define F2FS_GOING_DOWN_METAFLUSH 0x3 /* going down with meta flush */
1abff93d 285
e9750824
NJ
286#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
287/*
288 * ioctl commands in 32 bit emulation
289 */
04ef4b62
CY
290#define F2FS_IOC32_GETFLAGS FS_IOC32_GETFLAGS
291#define F2FS_IOC32_SETFLAGS FS_IOC32_SETFLAGS
292#define F2FS_IOC32_GETVERSION FS_IOC32_GETVERSION
e9750824
NJ
293#endif
294
d323d005
CY
295struct f2fs_defragment {
296 u64 start;
297 u64 len;
298};
299
4dd6f977
JK
300struct f2fs_move_range {
301 u32 dst_fd; /* destination fd */
302 u64 pos_in; /* start position in src_fd */
303 u64 pos_out; /* start position in dst_fd */
304 u64 len; /* size to move */
305};
306
39a53e0c
JK
307/*
308 * For INODE and NODE manager
309 */
7b3cd7d6
JK
310/* for directory operations */
311struct f2fs_dentry_ptr {
d8c6822a 312 struct inode *inode;
7b3cd7d6
JK
313 const void *bitmap;
314 struct f2fs_dir_entry *dentry;
315 __u8 (*filename)[F2FS_SLOT_LEN];
316 int max;
317};
318
d8c6822a
JK
319static inline void make_dentry_ptr(struct inode *inode,
320 struct f2fs_dentry_ptr *d, void *src, int type)
7b3cd7d6 321{
d8c6822a
JK
322 d->inode = inode;
323
7b3cd7d6
JK
324 if (type == 1) {
325 struct f2fs_dentry_block *t = (struct f2fs_dentry_block *)src;
326 d->max = NR_DENTRY_IN_BLOCK;
327 d->bitmap = &t->dentry_bitmap;
328 d->dentry = t->dentry;
329 d->filename = t->filename;
330 } else {
331 struct f2fs_inline_dentry *t = (struct f2fs_inline_dentry *)src;
332 d->max = NR_INLINE_DENTRY;
333 d->bitmap = &t->dentry_bitmap;
334 d->dentry = t->dentry;
335 d->filename = t->filename;
336 }
337}
338
dbe6a5ff
JK
339/*
340 * XATTR_NODE_OFFSET stores xattrs to one node block per file keeping -1
341 * as its node offset to distinguish from index node blocks.
342 * But some bits are used to mark the node block.
343 */
344#define XATTR_NODE_OFFSET ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
345 >> OFFSET_BIT_SHIFT)
266e97a8
JK
346enum {
347 ALLOC_NODE, /* allocate a new node page if needed */
348 LOOKUP_NODE, /* look up a node without readahead */
349 LOOKUP_NODE_RA, /*
350 * look up a node with readahead called
4f4124d0 351 * by get_data_block.
39a53e0c 352 */
266e97a8
JK
353};
354
a6db67f0 355#define F2FS_LINK_MAX 0xffffffff /* maximum link count per file */
39a53e0c 356
817202d9
CY
357#define MAX_DIR_RA_PAGES 4 /* maximum ra pages of dir */
358
13054c54
CY
359/* vector size for gang look-up from extent cache that consists of radix tree */
360#define EXT_TREE_VEC_SIZE 64
361
39a53e0c 362/* for in-memory extent cache entry */
13054c54
CY
363#define F2FS_MIN_EXTENT_LEN 64 /* minimum extent length */
364
365/* number of extent info in extent cache we try to shrink */
366#define EXTENT_CACHE_SHRINK_NUMBER 128
c11abd1a 367
39a53e0c 368struct extent_info {
13054c54
CY
369 unsigned int fofs; /* start offset in a file */
370 u32 blk; /* start block address of the extent */
371 unsigned int len; /* length of the extent */
372};
373
374struct extent_node {
375 struct rb_node rb_node; /* rb node located in rb-tree */
376 struct list_head list; /* node in global extent list of sbi */
377 struct extent_info ei; /* extent info */
201ef5e0 378 struct extent_tree *et; /* extent tree pointer */
13054c54
CY
379};
380
381struct extent_tree {
382 nid_t ino; /* inode number */
383 struct rb_root root; /* root of extent info rb-tree */
62c8af65 384 struct extent_node *cached_en; /* recently accessed extent node */
3e72f721 385 struct extent_info largest; /* largested extent info */
137d09f0 386 struct list_head list; /* to be used by sbi->zombie_list */
13054c54 387 rwlock_t lock; /* protect extent info rb-tree */
68e35385 388 atomic_t node_cnt; /* # of extent node in rb-tree*/
39a53e0c
JK
389};
390
003a3e1d
JK
391/*
392 * This structure is taken from ext4_map_blocks.
393 *
394 * Note that, however, f2fs uses NEW and MAPPED flags for f2fs_map_blocks().
395 */
396#define F2FS_MAP_NEW (1 << BH_New)
397#define F2FS_MAP_MAPPED (1 << BH_Mapped)
7f63eb77
JK
398#define F2FS_MAP_UNWRITTEN (1 << BH_Unwritten)
399#define F2FS_MAP_FLAGS (F2FS_MAP_NEW | F2FS_MAP_MAPPED |\
400 F2FS_MAP_UNWRITTEN)
003a3e1d
JK
401
402struct f2fs_map_blocks {
403 block_t m_pblk;
404 block_t m_lblk;
405 unsigned int m_len;
406 unsigned int m_flags;
da85985c 407 pgoff_t *m_next_pgofs; /* point next possible non-hole pgofs */
003a3e1d
JK
408};
409
e2b4e2bc
CY
410/* for flag in get_data_block */
411#define F2FS_GET_BLOCK_READ 0
412#define F2FS_GET_BLOCK_DIO 1
413#define F2FS_GET_BLOCK_FIEMAP 2
414#define F2FS_GET_BLOCK_BMAP 3
b439b103 415#define F2FS_GET_BLOCK_PRE_DIO 4
24b84912 416#define F2FS_GET_BLOCK_PRE_AIO 5
e2b4e2bc 417
39a53e0c
JK
418/*
419 * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
420 */
421#define FADVISE_COLD_BIT 0x01
354a3399 422#define FADVISE_LOST_PINO_BIT 0x02
cde4de12 423#define FADVISE_ENCRYPT_BIT 0x04
e7d55452 424#define FADVISE_ENC_NAME_BIT 0x08
26787236 425#define FADVISE_KEEP_SIZE_BIT 0x10
39a53e0c 426
b5492af7
JK
427#define file_is_cold(inode) is_file(inode, FADVISE_COLD_BIT)
428#define file_wrong_pino(inode) is_file(inode, FADVISE_LOST_PINO_BIT)
429#define file_set_cold(inode) set_file(inode, FADVISE_COLD_BIT)
430#define file_lost_pino(inode) set_file(inode, FADVISE_LOST_PINO_BIT)
431#define file_clear_cold(inode) clear_file(inode, FADVISE_COLD_BIT)
432#define file_got_pino(inode) clear_file(inode, FADVISE_LOST_PINO_BIT)
cde4de12
JK
433#define file_is_encrypt(inode) is_file(inode, FADVISE_ENCRYPT_BIT)
434#define file_set_encrypt(inode) set_file(inode, FADVISE_ENCRYPT_BIT)
435#define file_clear_encrypt(inode) clear_file(inode, FADVISE_ENCRYPT_BIT)
e7d55452
JK
436#define file_enc_name(inode) is_file(inode, FADVISE_ENC_NAME_BIT)
437#define file_set_enc_name(inode) set_file(inode, FADVISE_ENC_NAME_BIT)
26787236
JK
438#define file_keep_isize(inode) is_file(inode, FADVISE_KEEP_SIZE_BIT)
439#define file_set_keep_isize(inode) set_file(inode, FADVISE_KEEP_SIZE_BIT)
cde4de12 440
ab9fa662
JK
441#define DEF_DIR_LEVEL 0
442
39a53e0c
JK
443struct f2fs_inode_info {
444 struct inode vfs_inode; /* serve a vfs inode */
445 unsigned long i_flags; /* keep an inode flags for ioctl */
446 unsigned char i_advise; /* use to give file attribute hints */
38431545 447 unsigned char i_dir_level; /* use for dentry level for large dir */
39a53e0c 448 unsigned int i_current_depth; /* use only in directory structure */
6666e6aa 449 unsigned int i_pino; /* parent inode number */
39a53e0c
JK
450 umode_t i_acl_mode; /* keep file acl mode temporarily */
451
452 /* Use below internally in f2fs*/
453 unsigned long flags; /* use to pass per-file flags */
d928bfbf 454 struct rw_semaphore i_sem; /* protect fi info */
204706c7 455 atomic_t dirty_pages; /* # of dirty pages */
39a53e0c
JK
456 f2fs_hash_t chash; /* hash value of given file name */
457 unsigned int clevel; /* maximum level of given file name */
458 nid_t i_xattr_nid; /* node id that contains xattrs */
e518ff81 459 unsigned long long xattr_ver; /* cp version of xattr modification */
26de9b11 460 loff_t last_disk_size; /* lastly written file size */
88b88a66 461
0f18b462
JK
462 struct list_head dirty_list; /* dirty list for dirs and files */
463 struct list_head gdirty_list; /* linked in global dirty list */
88b88a66
JK
464 struct list_head inmem_pages; /* inmemory pages managed by f2fs */
465 struct mutex inmem_lock; /* lock for inmemory pages */
3e72f721 466 struct extent_tree *extent_tree; /* cached extent_tree entry */
82e0a5aa 467 struct rw_semaphore dio_rwsem[2];/* avoid racing between dio and gc */
39a53e0c
JK
468};
469
470static inline void get_extent_info(struct extent_info *ext,
bd933d4f 471 struct f2fs_extent *i_ext)
39a53e0c 472{
bd933d4f
CY
473 ext->fofs = le32_to_cpu(i_ext->fofs);
474 ext->blk = le32_to_cpu(i_ext->blk);
475 ext->len = le32_to_cpu(i_ext->len);
39a53e0c
JK
476}
477
478static inline void set_raw_extent(struct extent_info *ext,
479 struct f2fs_extent *i_ext)
480{
39a53e0c 481 i_ext->fofs = cpu_to_le32(ext->fofs);
4d0b0bd4 482 i_ext->blk = cpu_to_le32(ext->blk);
39a53e0c 483 i_ext->len = cpu_to_le32(ext->len);
39a53e0c
JK
484}
485
429511cd
CY
486static inline void set_extent_info(struct extent_info *ei, unsigned int fofs,
487 u32 blk, unsigned int len)
488{
489 ei->fofs = fofs;
490 ei->blk = blk;
491 ei->len = len;
492}
493
0bdee482
CY
494static inline bool __is_extent_same(struct extent_info *ei1,
495 struct extent_info *ei2)
496{
497 return (ei1->fofs == ei2->fofs && ei1->blk == ei2->blk &&
498 ei1->len == ei2->len);
499}
500
429511cd
CY
501static inline bool __is_extent_mergeable(struct extent_info *back,
502 struct extent_info *front)
503{
504 return (back->fofs + back->len == front->fofs &&
505 back->blk + back->len == front->blk);
506}
507
508static inline bool __is_back_mergeable(struct extent_info *cur,
509 struct extent_info *back)
510{
511 return __is_extent_mergeable(back, cur);
512}
513
514static inline bool __is_front_mergeable(struct extent_info *cur,
515 struct extent_info *front)
516{
517 return __is_extent_mergeable(cur, front);
518}
519
7c45729a 520extern void f2fs_mark_inode_dirty_sync(struct inode *, bool);
205b9822
JK
521static inline void __try_update_largest_extent(struct inode *inode,
522 struct extent_tree *et, struct extent_node *en)
4abd3f5a 523{
205b9822 524 if (en->ei.len > et->largest.len) {
4abd3f5a 525 et->largest = en->ei;
7c45729a 526 f2fs_mark_inode_dirty_sync(inode, true);
205b9822 527 }
4abd3f5a
CY
528}
529
b8559dc2
CY
530enum nid_list {
531 FREE_NID_LIST,
532 ALLOC_NID_LIST,
533 MAX_NID_LIST,
534};
535
39a53e0c
JK
536struct f2fs_nm_info {
537 block_t nat_blkaddr; /* base disk address of NAT */
538 nid_t max_nid; /* maximum possible node ids */
04d47e67 539 nid_t available_nids; /* # of available node ids */
39a53e0c 540 nid_t next_scan_nid; /* the next nid to be scanned */
cdfc41c1 541 unsigned int ram_thresh; /* control the memory footprint */
ea1a29a0 542 unsigned int ra_nid_pages; /* # of nid pages to be readaheaded */
2304cb0c 543 unsigned int dirty_nats_ratio; /* control dirty nats ratio threshold */
39a53e0c
JK
544
545 /* NAT cache management */
546 struct radix_tree_root nat_root;/* root of the nat entry cache */
309cc2b6 547 struct radix_tree_root nat_set_root;/* root of the nat set cache */
b873b798 548 struct rw_semaphore nat_tree_lock; /* protect nat_tree_lock */
39a53e0c 549 struct list_head nat_entries; /* cached nat entry list (clean) */
309cc2b6 550 unsigned int nat_cnt; /* the # of cached nat entries */
aec71382 551 unsigned int dirty_nat_cnt; /* total num of nat entries in set */
39a53e0c
JK
552
553 /* free node ids management */
8a7ed66a 554 struct radix_tree_root free_nid_root;/* root of the free_nid cache */
b8559dc2
CY
555 struct list_head nid_list[MAX_NID_LIST];/* lists for free nids */
556 unsigned int nid_cnt[MAX_NID_LIST]; /* the number of free node id */
557 spinlock_t nid_list_lock; /* protect nid lists ops */
39a53e0c
JK
558 struct mutex build_lock; /* lock for build free nids */
559
560 /* for checkpoint */
561 char *nat_bitmap; /* NAT bitmap pointer */
599a09b2
CY
562#ifdef CONFIG_F2FS_CHECK_FS
563 char *nat_bitmap_mir; /* NAT bitmap mirror */
564#endif
39a53e0c
JK
565 int bitmap_size; /* bitmap size */
566};
567
568/*
569 * this structure is used as one of function parameters.
570 * all the information are dedicated to a given direct node block determined
571 * by the data offset in a file.
572 */
573struct dnode_of_data {
574 struct inode *inode; /* vfs inode pointer */
575 struct page *inode_page; /* its inode page, NULL is possible */
576 struct page *node_page; /* cached direct node page */
577 nid_t nid; /* node id of the direct node block */
578 unsigned int ofs_in_node; /* data offset in the node page */
579 bool inode_page_locked; /* inode page is locked or not */
93bae099 580 bool node_changed; /* is node block changed */
3cf45747
CY
581 char cur_level; /* level of hole node page */
582 char max_level; /* level of current page located */
39a53e0c
JK
583 block_t data_blkaddr; /* block address of the node block */
584};
585
586static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
587 struct page *ipage, struct page *npage, nid_t nid)
588{
d66d1f76 589 memset(dn, 0, sizeof(*dn));
39a53e0c
JK
590 dn->inode = inode;
591 dn->inode_page = ipage;
592 dn->node_page = npage;
593 dn->nid = nid;
39a53e0c
JK
594}
595
596/*
597 * For SIT manager
598 *
599 * By default, there are 6 active log areas across the whole main area.
600 * When considering hot and cold data separation to reduce cleaning overhead,
601 * we split 3 for data logs and 3 for node logs as hot, warm, and cold types,
602 * respectively.
603 * In the current design, you should not change the numbers intentionally.
604 * Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6
605 * logs individually according to the underlying devices. (default: 6)
606 * Just in case, on-disk layout covers maximum 16 logs that consist of 8 for
607 * data and 8 for node logs.
608 */
609#define NR_CURSEG_DATA_TYPE (3)
610#define NR_CURSEG_NODE_TYPE (3)
611#define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
612
613enum {
614 CURSEG_HOT_DATA = 0, /* directory entry blocks */
615 CURSEG_WARM_DATA, /* data blocks */
616 CURSEG_COLD_DATA, /* multimedia or GCed data blocks */
617 CURSEG_HOT_NODE, /* direct node blocks of directory files */
618 CURSEG_WARM_NODE, /* direct node blocks of normal files */
619 CURSEG_COLD_NODE, /* indirect node blocks */
38aa0889 620 NO_CHECK_TYPE,
39a53e0c
JK
621};
622
6b4afdd7 623struct flush_cmd {
6b4afdd7 624 struct completion wait;
721bd4d5 625 struct llist_node llnode;
6b4afdd7
JK
626 int ret;
627};
628
a688b9d9
GZ
629struct flush_cmd_control {
630 struct task_struct *f2fs_issue_flush; /* flush thread */
631 wait_queue_head_t flush_wait_queue; /* waiting queue for wake-up */
0a87f664 632 atomic_t submit_flush; /* # of issued flushes */
721bd4d5
GZ
633 struct llist_head issue_list; /* list for command issue */
634 struct llist_node *dispatch_list; /* list for command dispatch */
a688b9d9
GZ
635};
636
39a53e0c
JK
637struct f2fs_sm_info {
638 struct sit_info *sit_info; /* whole segment information */
639 struct free_segmap_info *free_info; /* free segment information */
640 struct dirty_seglist_info *dirty_info; /* dirty segment information */
641 struct curseg_info *curseg_array; /* active segment information */
642
39a53e0c
JK
643 block_t seg0_blkaddr; /* block address of 0'th segment */
644 block_t main_blkaddr; /* start block address of main area */
645 block_t ssa_blkaddr; /* start block address of SSA area */
646
647 unsigned int segment_count; /* total # of segments */
648 unsigned int main_segments; /* # of segments in main area */
649 unsigned int reserved_segments; /* # of reserved segments */
650 unsigned int ovp_segments; /* # of overprovision segments */
81eb8d6e
JK
651
652 /* a threshold to reclaim prefree segments */
653 unsigned int rec_prefree_segments;
7fd9e544 654
bba681cb
JK
655 /* for batched trimming */
656 unsigned int trim_sections; /* # of sections to trim */
657
184a5cd2
CY
658 struct list_head sit_entry_set; /* sit entry set list */
659
216fbd64
JK
660 unsigned int ipu_policy; /* in-place-update policy */
661 unsigned int min_ipu_util; /* in-place-update threshold */
c1ce1b02 662 unsigned int min_fsync_blocks; /* threshold for fsync */
6b4afdd7
JK
663
664 /* for flush command control */
b01a9201 665 struct flush_cmd_control *fcc_info;
0b54fb84
JK
666
667 /* for discard command control */
668 struct discard_cmd_control *dcc_info;
39a53e0c
JK
669};
670
39a53e0c
JK
671/*
672 * For superblock
673 */
674/*
675 * COUNT_TYPE for monitoring
676 *
677 * f2fs monitors the number of several block types such as on-writeback,
678 * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
679 */
36951b38 680#define WB_DATA_TYPE(p) (__is_cp_guaranteed(p) ? F2FS_WB_CP_DATA : F2FS_WB_DATA)
39a53e0c 681enum count_type {
39a53e0c 682 F2FS_DIRTY_DENTS,
c227f912 683 F2FS_DIRTY_DATA,
39a53e0c
JK
684 F2FS_DIRTY_NODES,
685 F2FS_DIRTY_META,
8dcf2ff7 686 F2FS_INMEM_PAGES,
0f18b462 687 F2FS_DIRTY_IMETA,
36951b38
CY
688 F2FS_WB_CP_DATA,
689 F2FS_WB_DATA,
39a53e0c
JK
690 NR_COUNT_TYPE,
691};
692
39a53e0c 693/*
e1c42045 694 * The below are the page types of bios used in submit_bio().
39a53e0c
JK
695 * The available types are:
696 * DATA User data pages. It operates as async mode.
697 * NODE Node pages. It operates as async mode.
698 * META FS metadata pages such as SIT, NAT, CP.
699 * NR_PAGE_TYPE The number of page types.
700 * META_FLUSH Make sure the previous pages are written
701 * with waiting the bio's completion
702 * ... Only can be used with META.
703 */
7d5e5109 704#define PAGE_TYPE_OF_BIO(type) ((type) > META ? META : (type))
39a53e0c
JK
705enum page_type {
706 DATA,
707 NODE,
708 META,
709 NR_PAGE_TYPE,
710 META_FLUSH,
8ce67cb0
JK
711 INMEM, /* the below types are used by tracepoints only. */
712 INMEM_DROP,
28bc106b 713 INMEM_REVOKE,
8ce67cb0
JK
714 IPU,
715 OPU,
39a53e0c
JK
716};
717
458e6197 718struct f2fs_io_info {
05ca3632 719 struct f2fs_sb_info *sbi; /* f2fs_sb_info pointer */
7e8f2308 720 enum page_type type; /* contains DATA/NODE/META/META_FLUSH */
04d328de 721 int op; /* contains REQ_OP_ */
ef295ecf 722 int op_flags; /* req_flag_bits */
7a9d7548 723 block_t new_blkaddr; /* new block address to be written */
28bc106b 724 block_t old_blkaddr; /* old block address before Cow */
05ca3632 725 struct page *page; /* page to be written */
4375a336 726 struct page *encrypted_page; /* encrypted page */
458e6197
JK
727};
728
04d328de 729#define is_read_io(rw) (rw == READ)
1ff7bd3b 730struct f2fs_bio_info {
458e6197 731 struct f2fs_sb_info *sbi; /* f2fs superblock */
1ff7bd3b
JK
732 struct bio *bio; /* bios to merge */
733 sector_t last_block_in_bio; /* last block number */
458e6197 734 struct f2fs_io_info fio; /* store buffered io info. */
df0f8dc0 735 struct rw_semaphore io_rwsem; /* blocking op for bio */
1ff7bd3b
JK
736};
737
3c62be17
JK
738#define FDEV(i) (sbi->devs[i])
739#define RDEV(i) (raw_super->devs[i])
740struct f2fs_dev_info {
741 struct block_device *bdev;
742 char path[MAX_PATH_LEN];
743 unsigned int total_segments;
744 block_t start_blk;
745 block_t end_blk;
746#ifdef CONFIG_BLK_DEV_ZONED
747 unsigned int nr_blkz; /* Total number of zones */
748 u8 *blkz_type; /* Array of zones type */
749#endif
750};
751
c227f912
CY
752enum inode_type {
753 DIR_INODE, /* for dirty dir inode */
754 FILE_INODE, /* for dirty regular/symlink inode */
0f18b462 755 DIRTY_META, /* for all dirtied inode metadata */
c227f912
CY
756 NR_INODE_TYPE,
757};
758
67298804
CY
759/* for inner inode cache management */
760struct inode_management {
761 struct radix_tree_root ino_root; /* ino entry array */
762 spinlock_t ino_lock; /* for ino entry lock */
763 struct list_head ino_list; /* inode list head */
764 unsigned long ino_num; /* number of entries */
765};
766
caf0047e
CY
767/* For s_flag in struct f2fs_sb_info */
768enum {
769 SBI_IS_DIRTY, /* dirty flag for checkpoint */
770 SBI_IS_CLOSE, /* specify unmounting */
771 SBI_NEED_FSCK, /* need fsck.f2fs to fix */
772 SBI_POR_DOING, /* recovery is doing or not */
df728b0f 773 SBI_NEED_SB_WRITE, /* need to recover superblock */
bbf156f7 774 SBI_NEED_CP, /* need to checkpoint */
caf0047e
CY
775};
776
6beceb54
JK
777enum {
778 CP_TIME,
d0239e1b 779 REQ_TIME,
6beceb54
JK
780 MAX_TIME,
781};
782
b5a7aef1
JK
783#ifdef CONFIG_F2FS_FS_ENCRYPTION
784#define F2FS_KEY_DESC_PREFIX "f2fs:"
785#define F2FS_KEY_DESC_PREFIX_SIZE 5
786#endif
39a53e0c
JK
787struct f2fs_sb_info {
788 struct super_block *sb; /* pointer to VFS super block */
5e176d54 789 struct proc_dir_entry *s_proc; /* proc entry */
39a53e0c 790 struct f2fs_super_block *raw_super; /* raw super block pointer */
e8240f65 791 int valid_super_block; /* valid super block no */
fadb2fb8 792 unsigned long s_flag; /* flags for sbi */
39a53e0c 793
b5a7aef1
JK
794#ifdef CONFIG_F2FS_FS_ENCRYPTION
795 u8 key_prefix[F2FS_KEY_DESC_PREFIX_SIZE];
796 u8 key_prefix_size;
797#endif
178053e2
DLM
798
799#ifdef CONFIG_BLK_DEV_ZONED
178053e2
DLM
800 unsigned int blocks_per_blkz; /* F2FS blocks per zone */
801 unsigned int log_blocks_per_blkz; /* log2 F2FS blocks per zone */
178053e2
DLM
802#endif
803
39a53e0c
JK
804 /* for node-related operations */
805 struct f2fs_nm_info *nm_info; /* node manager */
806 struct inode *node_inode; /* cache node blocks */
807
808 /* for segment-related operations */
809 struct f2fs_sm_info *sm_info; /* segment manager */
1ff7bd3b
JK
810
811 /* for bio operations */
924b720b 812 struct f2fs_bio_info read_io; /* for read bios */
1ff7bd3b 813 struct f2fs_bio_info write_io[NR_PAGE_TYPE]; /* for write bios */
7dfeaa32 814 struct mutex wio_mutex[NODE + 1]; /* bio ordering for NODE/DATA */
0a595eba
JK
815 int write_io_size_bits; /* Write IO size bits */
816 mempool_t *write_io_dummy; /* Dummy pages */
39a53e0c
JK
817
818 /* for checkpoint */
819 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */
8508e44a 820 int cur_cp_pack; /* remain current cp pack */
aaec2b1d 821 spinlock_t cp_lock; /* for flag in ckpt */
39a53e0c 822 struct inode *meta_inode; /* cache meta blocks */
39936837 823 struct mutex cp_mutex; /* checkpoint procedure lock */
b873b798 824 struct rw_semaphore cp_rwsem; /* blocking FS operations */
b3582c68 825 struct rw_semaphore node_write; /* locking node writes */
fb51b5ef 826 wait_queue_head_t cp_wait;
6beceb54
JK
827 unsigned long last_time[MAX_TIME]; /* to store time in jiffies */
828 long interval_time[MAX_TIME]; /* to store thresholds */
39a53e0c 829
67298804 830 struct inode_management im[MAX_INO_ENTRY]; /* manage inode cache */
6451e041
JK
831
832 /* for orphan inode, use 0'th array */
0d47c1ad 833 unsigned int max_orphans; /* max orphan inodes */
39a53e0c 834
c227f912
CY
835 /* for inode management */
836 struct list_head inode_list[NR_INODE_TYPE]; /* dirty inode list */
837 spinlock_t inode_lock[NR_INODE_TYPE]; /* for dirty inode list lock */
39a53e0c 838
13054c54
CY
839 /* for extent tree cache */
840 struct radix_tree_root extent_tree_root;/* cache extent cache entries */
841 struct rw_semaphore extent_tree_lock; /* locking extent radix tree */
842 struct list_head extent_list; /* lru list for shrinker */
843 spinlock_t extent_lock; /* locking extent lru list */
7441ccef 844 atomic_t total_ext_tree; /* extent tree count */
137d09f0 845 struct list_head zombie_list; /* extent zombie tree list */
74fd8d99 846 atomic_t total_zombie_tree; /* extent zombie tree count */
13054c54
CY
847 atomic_t total_ext_node; /* extent info count */
848
e1c42045 849 /* basic filesystem units */
39a53e0c
JK
850 unsigned int log_sectors_per_block; /* log2 sectors per block */
851 unsigned int log_blocksize; /* log2 block size */
852 unsigned int blocksize; /* block size */
853 unsigned int root_ino_num; /* root inode number*/
854 unsigned int node_ino_num; /* node inode number*/
855 unsigned int meta_ino_num; /* meta inode number*/
856 unsigned int log_blocks_per_seg; /* log2 blocks per segment */
857 unsigned int blocks_per_seg; /* blocks per segment */
858 unsigned int segs_per_sec; /* segments per section */
859 unsigned int secs_per_zone; /* sections per zone */
860 unsigned int total_sections; /* total section count */
861 unsigned int total_node_count; /* total node block count */
862 unsigned int total_valid_node_count; /* valid node block count */
e0afc4d6 863 loff_t max_file_blocks; /* max block index of file */
39a53e0c 864 int active_logs; /* # of active logs */
ab9fa662 865 int dir_level; /* directory level */
39a53e0c
JK
866
867 block_t user_block_count; /* # of user blocks */
868 block_t total_valid_block_count; /* # of valid blocks */
a66cdd98 869 block_t discard_blks; /* discard command candidats */
39a53e0c
JK
870 block_t last_valid_block_count; /* for recovery */
871 u32 s_next_generation; /* for NFS support */
523be8a6
JK
872
873 /* # of pages, see count_type */
35782b23 874 atomic_t nr_pages[NR_COUNT_TYPE];
41382ec4
JK
875 /* # of allocated blocks */
876 struct percpu_counter alloc_valid_block_count;
39a53e0c 877
513c5f37
JK
878 /* valid inode count */
879 struct percpu_counter total_valid_inode_count;
880
39a53e0c
JK
881 struct f2fs_mount_info mount_opt; /* mount options */
882
883 /* for cleaning operations */
884 struct mutex gc_mutex; /* mutex for GC */
885 struct f2fs_gc_kthread *gc_thread; /* GC thread */
5ec4e49f 886 unsigned int cur_victim_sec; /* current victim section num */
39a53e0c 887
b1c57c1c
JK
888 /* maximum # of trials to find a victim segment for SSR and GC */
889 unsigned int max_victim_search;
890
39a53e0c
JK
891 /*
892 * for stat information.
893 * one is for the LFS mode, and the other is for the SSR mode.
894 */
35b09d82 895#ifdef CONFIG_F2FS_STAT_FS
39a53e0c
JK
896 struct f2fs_stat_info *stat_info; /* FS status information */
897 unsigned int segment_count[2]; /* # of allocated segments */
898 unsigned int block_count[2]; /* # of allocated blocks */
b9a2c252 899 atomic_t inplace_count; /* # of inplace update */
5b7ee374
CY
900 atomic64_t total_hit_ext; /* # of lookup extent cache */
901 atomic64_t read_hit_rbtree; /* # of hit rbtree extent node */
902 atomic64_t read_hit_largest; /* # of hit largest extent node */
903 atomic64_t read_hit_cached; /* # of hit cached extent node */
d5e8f6c9 904 atomic_t inline_xattr; /* # of inline_xattr inodes */
03e14d52
CY
905 atomic_t inline_inode; /* # of inline_data inodes */
906 atomic_t inline_dir; /* # of inline_dentry inodes */
26a28a0c
JK
907 atomic_t aw_cnt; /* # of atomic writes */
908 atomic_t max_aw_cnt; /* max # of atomic writes */
39a53e0c 909 int bg_gc; /* background gc calls */
33fbd510 910 unsigned int ndirty_inode[NR_INODE_TYPE]; /* # of dirty inodes */
35b09d82
NJ
911#endif
912 unsigned int last_victim[2]; /* last victim segment # */
39a53e0c 913 spinlock_t stat_lock; /* lock for stat operations */
b59d0bae
NJ
914
915 /* For sysfs suppport */
916 struct kobject s_kobj;
917 struct completion s_kobj_unregister;
2658e50d
JK
918
919 /* For shrinker support */
920 struct list_head s_list;
3c62be17
JK
921 int s_ndevs; /* number of devices */
922 struct f2fs_dev_info *devs; /* for device list */
2658e50d
JK
923 struct mutex umount_mutex;
924 unsigned int shrinker_run_no;
8f1dbbbb
SL
925
926 /* For write statistics */
927 u64 sectors_written_start;
928 u64 kbytes_written;
43b6573b
KM
929
930 /* Reference to checksum algorithm driver via cryptoapi */
931 struct crypto_shash *s_chksum_driver;
1ecc0c5c
CY
932
933 /* For fault injection */
934#ifdef CONFIG_F2FS_FAULT_INJECTION
935 struct f2fs_fault_info fault_info;
936#endif
39a53e0c
JK
937};
938
1ecc0c5c
CY
939#ifdef CONFIG_F2FS_FAULT_INJECTION
940static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
941{
942 struct f2fs_fault_info *ffi = &sbi->fault_info;
943
944 if (!ffi->inject_rate)
945 return false;
946
947 if (!IS_FAULT_SET(ffi, type))
948 return false;
949
950 atomic_inc(&ffi->inject_ops);
951 if (atomic_read(&ffi->inject_ops) >= ffi->inject_rate) {
952 atomic_set(&ffi->inject_ops, 0);
953 printk("%sF2FS-fs : inject %s in %pF\n",
954 KERN_INFO,
955 fault_name[type],
956 __builtin_return_address(0));
957 return true;
958 }
959 return false;
960}
961#endif
962
8f1dbbbb
SL
963/* For write statistics. Suppose sector size is 512 bytes,
964 * and the return value is in kbytes. s is of struct f2fs_sb_info.
965 */
966#define BD_PART_WRITTEN(s) \
967(((u64)part_stat_read(s->sb->s_bdev->bd_part, sectors[1]) - \
968 s->sectors_written_start) >> 1)
969
6beceb54
JK
970static inline void f2fs_update_time(struct f2fs_sb_info *sbi, int type)
971{
972 sbi->last_time[type] = jiffies;
973}
974
975static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)
976{
977 struct timespec ts = {sbi->interval_time[type], 0};
978 unsigned long interval = timespec_to_jiffies(&ts);
979
980 return time_after(jiffies, sbi->last_time[type] + interval);
981}
982
d0239e1b
JK
983static inline bool is_idle(struct f2fs_sb_info *sbi)
984{
985 struct block_device *bdev = sbi->sb->s_bdev;
986 struct request_queue *q = bdev_get_queue(bdev);
987 struct request_list *rl = &q->root_rl;
988
989 if (rl->count[BLK_RW_SYNC] || rl->count[BLK_RW_ASYNC])
990 return 0;
991
992 return f2fs_time_over(sbi, REQ_TIME);
993}
994
39a53e0c
JK
995/*
996 * Inline functions
997 */
43b6573b
KM
998static inline u32 f2fs_crc32(struct f2fs_sb_info *sbi, const void *address,
999 unsigned int length)
1000{
1001 SHASH_DESC_ON_STACK(shash, sbi->s_chksum_driver);
1002 u32 *ctx = (u32 *)shash_desc_ctx(shash);
1003 int err;
1004
1005 shash->tfm = sbi->s_chksum_driver;
1006 shash->flags = 0;
1007 *ctx = F2FS_SUPER_MAGIC;
1008
1009 err = crypto_shash_update(shash, address, length);
1010 BUG_ON(err);
1011
1012 return *ctx;
1013}
1014
1015static inline bool f2fs_crc_valid(struct f2fs_sb_info *sbi, __u32 blk_crc,
1016 void *buf, size_t buf_size)
1017{
1018 return f2fs_crc32(sbi, buf, buf_size) == blk_crc;
1019}
1020
39a53e0c
JK
1021static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
1022{
1023 return container_of(inode, struct f2fs_inode_info, vfs_inode);
1024}
1025
1026static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
1027{
1028 return sb->s_fs_info;
1029}
1030
4081363f
JK
1031static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)
1032{
1033 return F2FS_SB(inode->i_sb);
1034}
1035
1036static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping)
1037{
1038 return F2FS_I_SB(mapping->host);
1039}
1040
1041static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page)
1042{
1043 return F2FS_M_SB(page->mapping);
1044}
1045
39a53e0c
JK
1046static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
1047{
1048 return (struct f2fs_super_block *)(sbi->raw_super);
1049}
1050
1051static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
1052{
1053 return (struct f2fs_checkpoint *)(sbi->ckpt);
1054}
1055
45590710
GZ
1056static inline struct f2fs_node *F2FS_NODE(struct page *page)
1057{
1058 return (struct f2fs_node *)page_address(page);
1059}
1060
58bfaf44
JK
1061static inline struct f2fs_inode *F2FS_INODE(struct page *page)
1062{
1063 return &((struct f2fs_node *)page_address(page))->i;
1064}
1065
39a53e0c
JK
1066static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
1067{
1068 return (struct f2fs_nm_info *)(sbi->nm_info);
1069}
1070
1071static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
1072{
1073 return (struct f2fs_sm_info *)(sbi->sm_info);
1074}
1075
1076static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
1077{
1078 return (struct sit_info *)(SM_I(sbi)->sit_info);
1079}
1080
1081static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
1082{
1083 return (struct free_segmap_info *)(SM_I(sbi)->free_info);
1084}
1085
1086static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
1087{
1088 return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
1089}
1090
9df27d98
GZ
1091static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
1092{
1093 return sbi->meta_inode->i_mapping;
1094}
1095
4ef51a8f
JK
1096static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
1097{
1098 return sbi->node_inode->i_mapping;
1099}
1100
caf0047e
CY
1101static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)
1102{
fadb2fb8 1103 return test_bit(type, &sbi->s_flag);
caf0047e
CY
1104}
1105
1106static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
39a53e0c 1107{
fadb2fb8 1108 set_bit(type, &sbi->s_flag);
39a53e0c
JK
1109}
1110
caf0047e 1111static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
39a53e0c 1112{
fadb2fb8 1113 clear_bit(type, &sbi->s_flag);
39a53e0c
JK
1114}
1115
d71b5564
JK
1116static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
1117{
1118 return le64_to_cpu(cp->checkpoint_ver);
1119}
1120
aaec2b1d 1121static inline bool __is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
25ca923b
JK
1122{
1123 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
aaec2b1d 1124
25ca923b
JK
1125 return ckpt_flags & f;
1126}
1127
aaec2b1d 1128static inline bool is_set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
25ca923b 1129{
aaec2b1d
CY
1130 return __is_set_ckpt_flags(F2FS_CKPT(sbi), f);
1131}
1132
1133static inline void __set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1134{
1135 unsigned int ckpt_flags;
1136
1137 ckpt_flags = le32_to_cpu(cp->ckpt_flags);
25ca923b
JK
1138 ckpt_flags |= f;
1139 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
1140}
1141
aaec2b1d 1142static inline void set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
25ca923b 1143{
aaec2b1d
CY
1144 spin_lock(&sbi->cp_lock);
1145 __set_ckpt_flags(F2FS_CKPT(sbi), f);
1146 spin_unlock(&sbi->cp_lock);
1147}
1148
1149static inline void __clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1150{
1151 unsigned int ckpt_flags;
1152
1153 ckpt_flags = le32_to_cpu(cp->ckpt_flags);
25ca923b
JK
1154 ckpt_flags &= (~f);
1155 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
1156}
1157
aaec2b1d
CY
1158static inline void clear_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
1159{
1160 spin_lock(&sbi->cp_lock);
1161 __clear_ckpt_flags(F2FS_CKPT(sbi), f);
1162 spin_unlock(&sbi->cp_lock);
1163}
1164
e479556b 1165static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
39936837 1166{
b873b798 1167 down_read(&sbi->cp_rwsem);
39936837
JK
1168}
1169
e479556b 1170static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
39a53e0c 1171{
b873b798 1172 up_read(&sbi->cp_rwsem);
39a53e0c
JK
1173}
1174
e479556b 1175static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
39a53e0c 1176{
b873b798 1177 down_write(&sbi->cp_rwsem);
39936837
JK
1178}
1179
e479556b 1180static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
39936837 1181{
b873b798 1182 up_write(&sbi->cp_rwsem);
39a53e0c
JK
1183}
1184
119ee914
JK
1185static inline int __get_cp_reason(struct f2fs_sb_info *sbi)
1186{
1187 int reason = CP_SYNC;
1188
1189 if (test_opt(sbi, FASTBOOT))
1190 reason = CP_FASTBOOT;
1191 if (is_sbi_flag_set(sbi, SBI_IS_CLOSE))
1192 reason = CP_UMOUNT;
1193 return reason;
1194}
1195
1196static inline bool __remain_node_summaries(int reason)
1197{
1198 return (reason == CP_UMOUNT || reason == CP_FASTBOOT);
1199}
1200
1201static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)
1202{
aaec2b1d
CY
1203 return (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG) ||
1204 is_set_ckpt_flags(sbi, CP_FASTBOOT_FLAG));
119ee914
JK
1205}
1206
39a53e0c
JK
1207/*
1208 * Check whether the given nid is within node id range.
1209 */
064e0823 1210static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
39a53e0c 1211{
d6b7d4b3
CY
1212 if (unlikely(nid < F2FS_ROOT_INO(sbi)))
1213 return -EINVAL;
cfb271d4 1214 if (unlikely(nid >= NM_I(sbi)->max_nid))
064e0823
NJ
1215 return -EINVAL;
1216 return 0;
39a53e0c
JK
1217}
1218
1219#define F2FS_DEFAULT_ALLOCATED_BLOCKS 1
1220
1221/*
1222 * Check whether the inode has blocks or not
1223 */
1224static inline int F2FS_HAS_BLOCKS(struct inode *inode)
1225{
1226 if (F2FS_I(inode)->i_xattr_nid)
6c311ec6 1227 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
39a53e0c 1228 else
6c311ec6 1229 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
39a53e0c
JK
1230}
1231
4bc8e9bc
CY
1232static inline bool f2fs_has_xattr_block(unsigned int ofs)
1233{
1234 return ofs == XATTR_NODE_OFFSET;
1235}
1236
8edd03c8 1237static inline void f2fs_i_blocks_write(struct inode *, blkcnt_t, bool);
39a53e0c 1238static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
46008c6d 1239 struct inode *inode, blkcnt_t *count)
39a53e0c 1240{
dd11a5df 1241 blkcnt_t diff;
39a53e0c 1242
cb78942b 1243#ifdef CONFIG_F2FS_FAULT_INJECTION
1ecc0c5c 1244 if (time_to_inject(sbi, FAULT_BLOCK))
cb78942b 1245 return false;
cb78942b 1246#endif
dd11a5df
JK
1247 /*
1248 * let's increase this in prior to actual block count change in order
1249 * for f2fs_sync_file to avoid data races when deciding checkpoint.
1250 */
1251 percpu_counter_add(&sbi->alloc_valid_block_count, (*count));
1252
2555a2d5
JK
1253 spin_lock(&sbi->stat_lock);
1254 sbi->total_valid_block_count += (block_t)(*count);
1255 if (unlikely(sbi->total_valid_block_count > sbi->user_block_count)) {
dd11a5df
JK
1256 diff = sbi->total_valid_block_count - sbi->user_block_count;
1257 *count -= diff;
2555a2d5 1258 sbi->total_valid_block_count = sbi->user_block_count;
46008c6d
CY
1259 if (!*count) {
1260 spin_unlock(&sbi->stat_lock);
dd11a5df 1261 percpu_counter_sub(&sbi->alloc_valid_block_count, diff);
46008c6d
CY
1262 return false;
1263 }
39a53e0c 1264 }
39a53e0c 1265 spin_unlock(&sbi->stat_lock);
41382ec4 1266
2555a2d5 1267 f2fs_i_blocks_write(inode, *count, true);
39a53e0c
JK
1268 return true;
1269}
1270
da19b0dc 1271static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
39a53e0c
JK
1272 struct inode *inode,
1273 blkcnt_t count)
1274{
1275 spin_lock(&sbi->stat_lock);
9850cf4a
JK
1276 f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
1277 f2fs_bug_on(sbi, inode->i_blocks < count);
39a53e0c
JK
1278 sbi->total_valid_block_count -= (block_t)count;
1279 spin_unlock(&sbi->stat_lock);
2555a2d5 1280 f2fs_i_blocks_write(inode, count, false);
39a53e0c
JK
1281}
1282
1283static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
1284{
35782b23 1285 atomic_inc(&sbi->nr_pages[count_type]);
7c4abcbe 1286
36951b38
CY
1287 if (count_type == F2FS_DIRTY_DATA || count_type == F2FS_INMEM_PAGES ||
1288 count_type == F2FS_WB_CP_DATA || count_type == F2FS_WB_DATA)
7c4abcbe
CY
1289 return;
1290
caf0047e 1291 set_sbi_flag(sbi, SBI_IS_DIRTY);
39a53e0c
JK
1292}
1293
a7ffdbe2 1294static inline void inode_inc_dirty_pages(struct inode *inode)
39a53e0c 1295{
204706c7 1296 atomic_inc(&F2FS_I(inode)->dirty_pages);
c227f912
CY
1297 inc_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
1298 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
39a53e0c
JK
1299}
1300
1301static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
1302{
35782b23 1303 atomic_dec(&sbi->nr_pages[count_type]);
39a53e0c
JK
1304}
1305
a7ffdbe2 1306static inline void inode_dec_dirty_pages(struct inode *inode)
39a53e0c 1307{
5ac9f36f
CY
1308 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
1309 !S_ISLNK(inode->i_mode))
1fe54f9d
JK
1310 return;
1311
204706c7 1312 atomic_dec(&F2FS_I(inode)->dirty_pages);
c227f912
CY
1313 dec_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
1314 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
39a53e0c
JK
1315}
1316
523be8a6 1317static inline s64 get_pages(struct f2fs_sb_info *sbi, int count_type)
39a53e0c 1318{
35782b23 1319 return atomic_read(&sbi->nr_pages[count_type]);
39a53e0c
JK
1320}
1321
204706c7 1322static inline int get_dirty_pages(struct inode *inode)
f8b2c1f9 1323{
204706c7 1324 return atomic_read(&F2FS_I(inode)->dirty_pages);
f8b2c1f9
JK
1325}
1326
5ac206cf
NJ
1327static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
1328{
3519e3f9 1329 unsigned int pages_per_sec = sbi->segs_per_sec * sbi->blocks_per_seg;
523be8a6
JK
1330 unsigned int segs = (get_pages(sbi, block_type) + pages_per_sec - 1) >>
1331 sbi->log_blocks_per_seg;
1332
1333 return segs / sbi->segs_per_sec;
5ac206cf
NJ
1334}
1335
39a53e0c
JK
1336static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
1337{
8b8343fa 1338 return sbi->total_valid_block_count;
39a53e0c
JK
1339}
1340
f83a2584
YH
1341static inline block_t discard_blocks(struct f2fs_sb_info *sbi)
1342{
1343 return sbi->discard_blks;
1344}
1345
39a53e0c
JK
1346static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
1347{
1348 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1349
1350 /* return NAT or SIT bitmap */
1351 if (flag == NAT_BITMAP)
1352 return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
1353 else if (flag == SIT_BITMAP)
1354 return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
1355
1356 return 0;
1357}
1358
55141486
WL
1359static inline block_t __cp_payload(struct f2fs_sb_info *sbi)
1360{
1361 return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
1362}
1363
39a53e0c
JK
1364static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
1365{
1366 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1dbe4152
CL
1367 int offset;
1368
55141486 1369 if (__cp_payload(sbi) > 0) {
1dbe4152
CL
1370 if (flag == NAT_BITMAP)
1371 return &ckpt->sit_nat_version_bitmap;
1372 else
65b85ccc 1373 return (unsigned char *)ckpt + F2FS_BLKSIZE;
1dbe4152
CL
1374 } else {
1375 offset = (flag == NAT_BITMAP) ?
25ca923b 1376 le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
1dbe4152
CL
1377 return &ckpt->sit_nat_version_bitmap + offset;
1378 }
39a53e0c
JK
1379}
1380
1381static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
1382{
8508e44a 1383 block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
39a53e0c 1384
8508e44a 1385 if (sbi->cur_cp_pack == 2)
39a53e0c 1386 start_addr += sbi->blocks_per_seg;
8508e44a
JK
1387 return start_addr;
1388}
39a53e0c 1389
8508e44a
JK
1390static inline block_t __start_cp_next_addr(struct f2fs_sb_info *sbi)
1391{
1392 block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
39a53e0c 1393
8508e44a
JK
1394 if (sbi->cur_cp_pack == 1)
1395 start_addr += sbi->blocks_per_seg;
39a53e0c
JK
1396 return start_addr;
1397}
1398
8508e44a
JK
1399static inline void __set_cp_next_pack(struct f2fs_sb_info *sbi)
1400{
1401 sbi->cur_cp_pack = (sbi->cur_cp_pack == 1) ? 2 : 1;
1402}
1403
39a53e0c
JK
1404static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
1405{
1406 return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
1407}
1408
1409static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi,
ef86d709 1410 struct inode *inode)
39a53e0c
JK
1411{
1412 block_t valid_block_count;
1413 unsigned int valid_node_count;
1414
1415 spin_lock(&sbi->stat_lock);
1416
ef86d709 1417 valid_block_count = sbi->total_valid_block_count + 1;
cfb271d4 1418 if (unlikely(valid_block_count > sbi->user_block_count)) {
39a53e0c
JK
1419 spin_unlock(&sbi->stat_lock);
1420 return false;
1421 }
1422
ef86d709 1423 valid_node_count = sbi->total_valid_node_count + 1;
cfb271d4 1424 if (unlikely(valid_node_count > sbi->total_node_count)) {
39a53e0c
JK
1425 spin_unlock(&sbi->stat_lock);
1426 return false;
1427 }
1428
1429 if (inode)
8edd03c8 1430 f2fs_i_blocks_write(inode, 1, true);
ef86d709 1431
ef86d709
GZ
1432 sbi->total_valid_node_count++;
1433 sbi->total_valid_block_count++;
39a53e0c
JK
1434 spin_unlock(&sbi->stat_lock);
1435
41382ec4 1436 percpu_counter_inc(&sbi->alloc_valid_block_count);
39a53e0c
JK
1437 return true;
1438}
1439
1440static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
ef86d709 1441 struct inode *inode)
39a53e0c
JK
1442{
1443 spin_lock(&sbi->stat_lock);
1444
9850cf4a
JK
1445 f2fs_bug_on(sbi, !sbi->total_valid_block_count);
1446 f2fs_bug_on(sbi, !sbi->total_valid_node_count);
1447 f2fs_bug_on(sbi, !inode->i_blocks);
39a53e0c 1448
8edd03c8 1449 f2fs_i_blocks_write(inode, 1, false);
ef86d709
GZ
1450 sbi->total_valid_node_count--;
1451 sbi->total_valid_block_count--;
39a53e0c
JK
1452
1453 spin_unlock(&sbi->stat_lock);
1454}
1455
1456static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
1457{
8b8343fa 1458 return sbi->total_valid_node_count;
39a53e0c
JK
1459}
1460
1461static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
1462{
513c5f37 1463 percpu_counter_inc(&sbi->total_valid_inode_count);
39a53e0c
JK
1464}
1465
0e80220a 1466static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
39a53e0c 1467{
513c5f37 1468 percpu_counter_dec(&sbi->total_valid_inode_count);
39a53e0c
JK
1469}
1470
513c5f37 1471static inline s64 valid_inode_count(struct f2fs_sb_info *sbi)
39a53e0c 1472{
513c5f37 1473 return percpu_counter_sum_positive(&sbi->total_valid_inode_count);
39a53e0c
JK
1474}
1475
a56c7c6f
JK
1476static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
1477 pgoff_t index, bool for_write)
1478{
c41f3cc3
JK
1479#ifdef CONFIG_F2FS_FAULT_INJECTION
1480 struct page *page = find_lock_page(mapping, index);
1481 if (page)
1482 return page;
1483
1ecc0c5c 1484 if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_ALLOC))
c41f3cc3
JK
1485 return NULL;
1486#endif
a56c7c6f
JK
1487 if (!for_write)
1488 return grab_cache_page(mapping, index);
1489 return grab_cache_page_write_begin(mapping, index, AOP_FLAG_NOFS);
1490}
1491
6e2c64ad
JK
1492static inline void f2fs_copy_page(struct page *src, struct page *dst)
1493{
1494 char *src_kaddr = kmap(src);
1495 char *dst_kaddr = kmap(dst);
1496
1497 memcpy(dst_kaddr, src_kaddr, PAGE_SIZE);
1498 kunmap(dst);
1499 kunmap(src);
1500}
1501
39a53e0c
JK
1502static inline void f2fs_put_page(struct page *page, int unlock)
1503{
031fa8cc 1504 if (!page)
39a53e0c
JK
1505 return;
1506
1507 if (unlock) {
9850cf4a 1508 f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page));
39a53e0c
JK
1509 unlock_page(page);
1510 }
09cbfeaf 1511 put_page(page);
39a53e0c
JK
1512}
1513
1514static inline void f2fs_put_dnode(struct dnode_of_data *dn)
1515{
1516 if (dn->node_page)
1517 f2fs_put_page(dn->node_page, 1);
1518 if (dn->inode_page && dn->node_page != dn->inode_page)
1519 f2fs_put_page(dn->inode_page, 0);
1520 dn->node_page = NULL;
1521 dn->inode_page = NULL;
1522}
1523
1524static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
e8512d2e 1525 size_t size)
39a53e0c 1526{
e8512d2e 1527 return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
39a53e0c
JK
1528}
1529
7bd59381
GZ
1530static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep,
1531 gfp_t flags)
1532{
1533 void *entry;
7bd59381 1534
80c54505
JK
1535 entry = kmem_cache_alloc(cachep, flags);
1536 if (!entry)
1537 entry = kmem_cache_alloc(cachep, flags | __GFP_NOFAIL);
7bd59381
GZ
1538 return entry;
1539}
1540
740432f8
JK
1541static inline struct bio *f2fs_bio_alloc(int npages)
1542{
1543 struct bio *bio;
1544
1545 /* No failure on bio allocation */
740432f8 1546 bio = bio_alloc(GFP_NOIO, npages);
80c54505
JK
1547 if (!bio)
1548 bio = bio_alloc(GFP_NOIO | __GFP_NOFAIL, npages);
740432f8
JK
1549 return bio;
1550}
1551
9be32d72
JK
1552static inline void f2fs_radix_tree_insert(struct radix_tree_root *root,
1553 unsigned long index, void *item)
1554{
1555 while (radix_tree_insert(root, index, item))
1556 cond_resched();
1557}
1558
39a53e0c
JK
1559#define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
1560
1561static inline bool IS_INODE(struct page *page)
1562{
45590710 1563 struct f2fs_node *p = F2FS_NODE(page);
39a53e0c
JK
1564 return RAW_IS_INODE(p);
1565}
1566
1567static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
1568{
1569 return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
1570}
1571
1572static inline block_t datablock_addr(struct page *node_page,
1573 unsigned int offset)
1574{
1575 struct f2fs_node *raw_node;
1576 __le32 *addr_array;
45590710 1577 raw_node = F2FS_NODE(node_page);
39a53e0c
JK
1578 addr_array = blkaddr_in_node(raw_node);
1579 return le32_to_cpu(addr_array[offset]);
1580}
1581
1582static inline int f2fs_test_bit(unsigned int nr, char *addr)
1583{
1584 int mask;
1585
1586 addr += (nr >> 3);
1587 mask = 1 << (7 - (nr & 0x07));
1588 return mask & *addr;
1589}
1590
a66cdd98
JK
1591static inline void f2fs_set_bit(unsigned int nr, char *addr)
1592{
1593 int mask;
1594
1595 addr += (nr >> 3);
1596 mask = 1 << (7 - (nr & 0x07));
1597 *addr |= mask;
1598}
1599
1600static inline void f2fs_clear_bit(unsigned int nr, char *addr)
1601{
1602 int mask;
1603
1604 addr += (nr >> 3);
1605 mask = 1 << (7 - (nr & 0x07));
1606 *addr &= ~mask;
1607}
1608
52aca074 1609static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr)
39a53e0c
JK
1610{
1611 int mask;
1612 int ret;
1613
1614 addr += (nr >> 3);
1615 mask = 1 << (7 - (nr & 0x07));
1616 ret = mask & *addr;
1617 *addr |= mask;
1618 return ret;
1619}
1620
52aca074 1621static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr)
39a53e0c
JK
1622{
1623 int mask;
1624 int ret;
1625
1626 addr += (nr >> 3);
1627 mask = 1 << (7 - (nr & 0x07));
1628 ret = mask & *addr;
1629 *addr &= ~mask;
1630 return ret;
1631}
1632
c6ac4c0e
GZ
1633static inline void f2fs_change_bit(unsigned int nr, char *addr)
1634{
1635 int mask;
1636
1637 addr += (nr >> 3);
1638 mask = 1 << (7 - (nr & 0x07));
1639 *addr ^= mask;
1640}
1641
39a53e0c
JK
1642/* used for f2fs_inode_info->flags */
1643enum {
1644 FI_NEW_INODE, /* indicate newly allocated inode */
b3783873 1645 FI_DIRTY_INODE, /* indicate inode is dirty or not */
26de9b11 1646 FI_AUTO_RECOVER, /* indicate inode is recoverable */
ed57c27f 1647 FI_DIRTY_DIR, /* indicate directory has dirty pages */
39a53e0c
JK
1648 FI_INC_LINK, /* need to increment i_nlink */
1649 FI_ACL_MODE, /* indicate acl mode */
1650 FI_NO_ALLOC, /* should not allocate any blocks */
c9b63bd0 1651 FI_FREE_NID, /* free allocated nide */
c11abd1a 1652 FI_NO_EXTENT, /* not to use the extent cache */
444c580f 1653 FI_INLINE_XATTR, /* used for inline xattr */
1001b347 1654 FI_INLINE_DATA, /* used for inline data*/
34d67deb 1655 FI_INLINE_DENTRY, /* used for inline dentry */
fff04f90
JK
1656 FI_APPEND_WRITE, /* inode has appended data */
1657 FI_UPDATE_WRITE, /* inode has in-place-update data */
88b88a66
JK
1658 FI_NEED_IPU, /* used for ipu per file */
1659 FI_ATOMIC_FILE, /* indicate atomic file */
5fe45743 1660 FI_ATOMIC_COMMIT, /* indicate the state of atomical committing */
02a1335f 1661 FI_VOLATILE_FILE, /* indicate volatile file */
3c6c2beb 1662 FI_FIRST_BLOCK_WRITTEN, /* indicate #0 data block was written */
1e84371f 1663 FI_DROP_CACHE, /* drop dirty page cache */
b3d208f9 1664 FI_DATA_EXIST, /* indicate data exists */
510022a8 1665 FI_INLINE_DOTS, /* indicate inline dot dentries */
d323d005 1666 FI_DO_DEFRAG, /* indicate defragment is running */
c227f912 1667 FI_DIRTY_FILE, /* indicate regular/symlink has dirty pages */
dc91de78 1668 FI_NO_PREALLOC, /* indicate skipped preallocated blocks */
39a53e0c
JK
1669};
1670
205b9822
JK
1671static inline void __mark_inode_dirty_flag(struct inode *inode,
1672 int flag, bool set)
1673{
1674 switch (flag) {
1675 case FI_INLINE_XATTR:
1676 case FI_INLINE_DATA:
1677 case FI_INLINE_DENTRY:
1678 if (set)
1679 return;
1680 case FI_DATA_EXIST:
1681 case FI_INLINE_DOTS:
7c45729a 1682 f2fs_mark_inode_dirty_sync(inode, true);
205b9822
JK
1683 }
1684}
1685
91942321 1686static inline void set_inode_flag(struct inode *inode, int flag)
39a53e0c 1687{
91942321
JK
1688 if (!test_bit(flag, &F2FS_I(inode)->flags))
1689 set_bit(flag, &F2FS_I(inode)->flags);
205b9822 1690 __mark_inode_dirty_flag(inode, flag, true);
39a53e0c
JK
1691}
1692
91942321 1693static inline int is_inode_flag_set(struct inode *inode, int flag)
39a53e0c 1694{
91942321 1695 return test_bit(flag, &F2FS_I(inode)->flags);
39a53e0c
JK
1696}
1697
91942321 1698static inline void clear_inode_flag(struct inode *inode, int flag)
39a53e0c 1699{
91942321
JK
1700 if (test_bit(flag, &F2FS_I(inode)->flags))
1701 clear_bit(flag, &F2FS_I(inode)->flags);
205b9822 1702 __mark_inode_dirty_flag(inode, flag, false);
39a53e0c
JK
1703}
1704
91942321 1705static inline void set_acl_inode(struct inode *inode, umode_t mode)
39a53e0c 1706{
91942321
JK
1707 F2FS_I(inode)->i_acl_mode = mode;
1708 set_inode_flag(inode, FI_ACL_MODE);
7c45729a 1709 f2fs_mark_inode_dirty_sync(inode, false);
39a53e0c
JK
1710}
1711
a1961246 1712static inline void f2fs_i_links_write(struct inode *inode, bool inc)
39a53e0c 1713{
a1961246
JK
1714 if (inc)
1715 inc_nlink(inode);
1716 else
1717 drop_nlink(inode);
7c45729a 1718 f2fs_mark_inode_dirty_sync(inode, true);
a1961246
JK
1719}
1720
8edd03c8
JK
1721static inline void f2fs_i_blocks_write(struct inode *inode,
1722 blkcnt_t diff, bool add)
1723{
26de9b11
JK
1724 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
1725 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
1726
8edd03c8
JK
1727 inode->i_blocks = add ? inode->i_blocks + diff :
1728 inode->i_blocks - diff;
7c45729a 1729 f2fs_mark_inode_dirty_sync(inode, true);
26de9b11
JK
1730 if (clean || recover)
1731 set_inode_flag(inode, FI_AUTO_RECOVER);
8edd03c8
JK
1732}
1733
fc9581c8
JK
1734static inline void f2fs_i_size_write(struct inode *inode, loff_t i_size)
1735{
26de9b11
JK
1736 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
1737 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
1738
fc9581c8
JK
1739 if (i_size_read(inode) == i_size)
1740 return;
1741
1742 i_size_write(inode, i_size);
7c45729a 1743 f2fs_mark_inode_dirty_sync(inode, true);
26de9b11
JK
1744 if (clean || recover)
1745 set_inode_flag(inode, FI_AUTO_RECOVER);
39a53e0c
JK
1746}
1747
205b9822 1748static inline void f2fs_i_depth_write(struct inode *inode, unsigned int depth)
39a53e0c 1749{
205b9822 1750 F2FS_I(inode)->i_current_depth = depth;
7c45729a 1751 f2fs_mark_inode_dirty_sync(inode, true);
39a53e0c
JK
1752}
1753
205b9822 1754static inline void f2fs_i_xnid_write(struct inode *inode, nid_t xnid)
444c580f 1755{
205b9822 1756 F2FS_I(inode)->i_xattr_nid = xnid;
7c45729a 1757 f2fs_mark_inode_dirty_sync(inode, true);
205b9822
JK
1758}
1759
1760static inline void f2fs_i_pino_write(struct inode *inode, nid_t pino)
1761{
1762 F2FS_I(inode)->i_pino = pino;
7c45729a 1763 f2fs_mark_inode_dirty_sync(inode, true);
205b9822
JK
1764}
1765
91942321 1766static inline void get_inline_info(struct inode *inode, struct f2fs_inode *ri)
444c580f 1767{
205b9822
JK
1768 struct f2fs_inode_info *fi = F2FS_I(inode);
1769
444c580f 1770 if (ri->i_inline & F2FS_INLINE_XATTR)
205b9822 1771 set_bit(FI_INLINE_XATTR, &fi->flags);
1001b347 1772 if (ri->i_inline & F2FS_INLINE_DATA)
205b9822 1773 set_bit(FI_INLINE_DATA, &fi->flags);
34d67deb 1774 if (ri->i_inline & F2FS_INLINE_DENTRY)
205b9822 1775 set_bit(FI_INLINE_DENTRY, &fi->flags);
b3d208f9 1776 if (ri->i_inline & F2FS_DATA_EXIST)
205b9822 1777 set_bit(FI_DATA_EXIST, &fi->flags);
510022a8 1778 if (ri->i_inline & F2FS_INLINE_DOTS)
205b9822 1779 set_bit(FI_INLINE_DOTS, &fi->flags);
444c580f
JK
1780}
1781
91942321 1782static inline void set_raw_inline(struct inode *inode, struct f2fs_inode *ri)
444c580f
JK
1783{
1784 ri->i_inline = 0;
1785
91942321 1786 if (is_inode_flag_set(inode, FI_INLINE_XATTR))
444c580f 1787 ri->i_inline |= F2FS_INLINE_XATTR;
91942321 1788 if (is_inode_flag_set(inode, FI_INLINE_DATA))
1001b347 1789 ri->i_inline |= F2FS_INLINE_DATA;
91942321 1790 if (is_inode_flag_set(inode, FI_INLINE_DENTRY))
34d67deb 1791 ri->i_inline |= F2FS_INLINE_DENTRY;
91942321 1792 if (is_inode_flag_set(inode, FI_DATA_EXIST))
b3d208f9 1793 ri->i_inline |= F2FS_DATA_EXIST;
91942321 1794 if (is_inode_flag_set(inode, FI_INLINE_DOTS))
510022a8 1795 ri->i_inline |= F2FS_INLINE_DOTS;
444c580f
JK
1796}
1797
987c7c31
CY
1798static inline int f2fs_has_inline_xattr(struct inode *inode)
1799{
91942321 1800 return is_inode_flag_set(inode, FI_INLINE_XATTR);
987c7c31
CY
1801}
1802
81ca7350 1803static inline unsigned int addrs_per_inode(struct inode *inode)
de93653f 1804{
81ca7350 1805 if (f2fs_has_inline_xattr(inode))
de93653f
JK
1806 return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
1807 return DEF_ADDRS_PER_INODE;
1808}
1809
65985d93
JK
1810static inline void *inline_xattr_addr(struct page *page)
1811{
695fd1ed 1812 struct f2fs_inode *ri = F2FS_INODE(page);
65985d93
JK
1813 return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
1814 F2FS_INLINE_XATTR_ADDRS]);
1815}
1816
1817static inline int inline_xattr_size(struct inode *inode)
1818{
987c7c31 1819 if (f2fs_has_inline_xattr(inode))
65985d93
JK
1820 return F2FS_INLINE_XATTR_ADDRS << 2;
1821 else
1822 return 0;
1823}
1824
0dbdc2ae
JK
1825static inline int f2fs_has_inline_data(struct inode *inode)
1826{
91942321 1827 return is_inode_flag_set(inode, FI_INLINE_DATA);
0dbdc2ae
JK
1828}
1829
b3d208f9
JK
1830static inline void f2fs_clear_inline_inode(struct inode *inode)
1831{
91942321
JK
1832 clear_inode_flag(inode, FI_INLINE_DATA);
1833 clear_inode_flag(inode, FI_DATA_EXIST);
b3d208f9
JK
1834}
1835
1836static inline int f2fs_exist_data(struct inode *inode)
1837{
91942321 1838 return is_inode_flag_set(inode, FI_DATA_EXIST);
b3d208f9
JK
1839}
1840
510022a8
JK
1841static inline int f2fs_has_inline_dots(struct inode *inode)
1842{
91942321 1843 return is_inode_flag_set(inode, FI_INLINE_DOTS);
510022a8
JK
1844}
1845
88b88a66
JK
1846static inline bool f2fs_is_atomic_file(struct inode *inode)
1847{
91942321 1848 return is_inode_flag_set(inode, FI_ATOMIC_FILE);
88b88a66
JK
1849}
1850
5fe45743
CY
1851static inline bool f2fs_is_commit_atomic_write(struct inode *inode)
1852{
1853 return is_inode_flag_set(inode, FI_ATOMIC_COMMIT);
1854}
1855
02a1335f
JK
1856static inline bool f2fs_is_volatile_file(struct inode *inode)
1857{
91942321 1858 return is_inode_flag_set(inode, FI_VOLATILE_FILE);
02a1335f
JK
1859}
1860
3c6c2beb
JK
1861static inline bool f2fs_is_first_block_written(struct inode *inode)
1862{
91942321 1863 return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
3c6c2beb
JK
1864}
1865
1e84371f
JK
1866static inline bool f2fs_is_drop_cache(struct inode *inode)
1867{
91942321 1868 return is_inode_flag_set(inode, FI_DROP_CACHE);
1e84371f
JK
1869}
1870
1001b347
HL
1871static inline void *inline_data_addr(struct page *page)
1872{
695fd1ed 1873 struct f2fs_inode *ri = F2FS_INODE(page);
1001b347
HL
1874 return (void *)&(ri->i_addr[1]);
1875}
1876
34d67deb
CY
1877static inline int f2fs_has_inline_dentry(struct inode *inode)
1878{
91942321 1879 return is_inode_flag_set(inode, FI_INLINE_DENTRY);
34d67deb
CY
1880}
1881
9486ba44
JK
1882static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page)
1883{
1884 if (!f2fs_has_inline_dentry(dir))
1885 kunmap(page);
1886}
1887
b5492af7
JK
1888static inline int is_file(struct inode *inode, int type)
1889{
1890 return F2FS_I(inode)->i_advise & type;
1891}
1892
1893static inline void set_file(struct inode *inode, int type)
1894{
1895 F2FS_I(inode)->i_advise |= type;
7c45729a 1896 f2fs_mark_inode_dirty_sync(inode, true);
b5492af7
JK
1897}
1898
1899static inline void clear_file(struct inode *inode, int type)
1900{
1901 F2FS_I(inode)->i_advise &= ~type;
7c45729a 1902 f2fs_mark_inode_dirty_sync(inode, true);
b5492af7
JK
1903}
1904
26787236
JK
1905static inline bool f2fs_skip_inode_update(struct inode *inode, int dsync)
1906{
1907 if (dsync) {
1908 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1909 bool ret;
1910
1911 spin_lock(&sbi->inode_lock[DIRTY_META]);
1912 ret = list_empty(&F2FS_I(inode)->gdirty_list);
1913 spin_unlock(&sbi->inode_lock[DIRTY_META]);
1914 return ret;
1915 }
1916 if (!is_inode_flag_set(inode, FI_AUTO_RECOVER) ||
1917 file_keep_isize(inode) ||
1918 i_size_read(inode) & PAGE_MASK)
1919 return false;
1920 return F2FS_I(inode)->last_disk_size == i_size_read(inode);
b5492af7
JK
1921}
1922
77888c1e
JK
1923static inline int f2fs_readonly(struct super_block *sb)
1924{
1925 return sb->s_flags & MS_RDONLY;
1926}
1927
1e968fdf
JK
1928static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
1929{
aaec2b1d 1930 return is_set_ckpt_flags(sbi, CP_ERROR_FLAG);
1e968fdf
JK
1931}
1932
eaa693f4
JK
1933static inline bool is_dot_dotdot(const struct qstr *str)
1934{
1935 if (str->len == 1 && str->name[0] == '.')
1936 return true;
1937
1938 if (str->len == 2 && str->name[0] == '.' && str->name[1] == '.')
1939 return true;
1940
1941 return false;
1942}
1943
3e72f721
JK
1944static inline bool f2fs_may_extent_tree(struct inode *inode)
1945{
3e72f721 1946 if (!test_opt(F2FS_I_SB(inode), EXTENT_CACHE) ||
91942321 1947 is_inode_flag_set(inode, FI_NO_EXTENT))
3e72f721
JK
1948 return false;
1949
886f56f9 1950 return S_ISREG(inode->i_mode);
3e72f721
JK
1951}
1952
1ecc0c5c
CY
1953static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,
1954 size_t size, gfp_t flags)
0414b004 1955{
2c63fead 1956#ifdef CONFIG_F2FS_FAULT_INJECTION
1ecc0c5c 1957 if (time_to_inject(sbi, FAULT_KMALLOC))
2c63fead
JK
1958 return NULL;
1959#endif
0414b004
JK
1960 return kmalloc(size, flags);
1961}
1962
39307a8e
JK
1963static inline void *f2fs_kvmalloc(size_t size, gfp_t flags)
1964{
1965 void *ret;
1966
1967 ret = kmalloc(size, flags | __GFP_NOWARN);
1968 if (!ret)
1969 ret = __vmalloc(size, flags, PAGE_KERNEL);
1970 return ret;
1971}
1972
1973static inline void *f2fs_kvzalloc(size_t size, gfp_t flags)
1974{
1975 void *ret;
1976
1977 ret = kzalloc(size, flags | __GFP_NOWARN);
1978 if (!ret)
1979 ret = __vmalloc(size, flags | __GFP_ZERO, PAGE_KERNEL);
1980 return ret;
1981}
1982
a6dda0e6 1983#define get_inode_mode(i) \
91942321 1984 ((is_inode_flag_set(i, FI_ACL_MODE)) ? \
a6dda0e6
CH
1985 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
1986
267378d4 1987/* get offset of first page in next direct node */
81ca7350
CY
1988#define PGOFS_OF_NEXT_DNODE(pgofs, inode) \
1989 ((pgofs < ADDRS_PER_INODE(inode)) ? ADDRS_PER_INODE(inode) : \
1990 (pgofs - ADDRS_PER_INODE(inode) + ADDRS_PER_BLOCK) / \
1991 ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(inode))
267378d4 1992
39a53e0c
JK
1993/*
1994 * file.c
1995 */
1996int f2fs_sync_file(struct file *, loff_t, loff_t, int);
1997void truncate_data_blocks(struct dnode_of_data *);
764aa3e9 1998int truncate_blocks(struct inode *, u64, bool);
9a449e9c 1999int f2fs_truncate(struct inode *);
2d4d9fb5 2000int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
39a53e0c
JK
2001int f2fs_setattr(struct dentry *, struct iattr *);
2002int truncate_hole(struct inode *, pgoff_t, pgoff_t);
b292dcab 2003int truncate_data_blocks_range(struct dnode_of_data *, int);
39a53e0c 2004long f2fs_ioctl(struct file *, unsigned int, unsigned long);
e9750824 2005long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
39a53e0c
JK
2006
2007/*
2008 * inode.c
2009 */
2010void f2fs_set_inode_flags(struct inode *);
39a53e0c 2011struct inode *f2fs_iget(struct super_block *, unsigned long);
e8ea9b3d 2012struct inode *f2fs_iget_retry(struct super_block *, unsigned long);
4660f9c0 2013int try_to_free_nats(struct f2fs_sb_info *, int);
12719ae1
JK
2014int update_inode(struct inode *, struct page *);
2015int update_inode_page(struct inode *);
39a53e0c
JK
2016int f2fs_write_inode(struct inode *, struct writeback_control *);
2017void f2fs_evict_inode(struct inode *);
44c16156 2018void handle_failed_inode(struct inode *);
39a53e0c
JK
2019
2020/*
2021 * namei.c
2022 */
2023struct dentry *f2fs_get_parent(struct dentry *child);
2024
2025/*
2026 * dir.c
2027 */
510022a8 2028void set_de_type(struct f2fs_dir_entry *, umode_t);
675f10bd 2029unsigned char get_de_type(struct f2fs_dir_entry *);
0b81d077 2030struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *,
6e22c691 2031 f2fs_hash_t, int *, struct f2fs_dentry_ptr *);
ed6bd4b1 2032int f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *,
0b81d077 2033 unsigned int, struct fscrypt_str *);
062a3e7b
JK
2034void do_make_empty_dir(struct inode *, struct inode *,
2035 struct f2fs_dentry_ptr *);
dbeacf02 2036struct page *init_inode_metadata(struct inode *, struct inode *,
9421d570 2037 const struct qstr *, const struct qstr *, struct page *);
dbeacf02 2038void update_parent_metadata(struct inode *, struct inode *, unsigned int);
a82afa20 2039int room_for_filename(const void *, int, int);
9f7c45cc 2040void f2fs_drop_nlink(struct inode *, struct inode *);
e7ba108a
SL
2041struct f2fs_dir_entry *__f2fs_find_entry(struct inode *, struct fscrypt_name *,
2042 struct page **);
185de68f 2043struct f2fs_dir_entry *f2fs_find_entry(struct inode *, const struct qstr *,
39a53e0c
JK
2044 struct page **);
2045struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
835c92d4 2046ino_t f2fs_inode_by_name(struct inode *, const struct qstr *, struct page **);
39a53e0c
JK
2047void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
2048 struct page *, struct inode *);
e7d55452 2049int update_dent_inode(struct inode *, struct inode *, const struct qstr *);
510022a8 2050void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *,
3b4d732a 2051 const struct qstr *, f2fs_hash_t , unsigned int);
675f10bd 2052int f2fs_add_regular_entry(struct inode *, const struct qstr *,
9421d570 2053 const struct qstr *, struct inode *, nid_t, umode_t);
e7ba108a
SL
2054int __f2fs_do_add_link(struct inode *, struct fscrypt_name*, struct inode *,
2055 nid_t, umode_t);
510022a8
JK
2056int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *, nid_t,
2057 umode_t);
dbeacf02
CY
2058void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *,
2059 struct inode *);
b97a9b5d 2060int f2fs_do_tmpfile(struct inode *, struct inode *);
39a53e0c
JK
2061bool f2fs_empty_dir(struct inode *);
2062
b7f7a5e0
AV
2063static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
2064{
2b0143b5 2065 return __f2fs_add_link(d_inode(dentry->d_parent), &dentry->d_name,
510022a8 2066 inode, inode->i_ino, inode->i_mode);
b7f7a5e0
AV
2067}
2068
39a53e0c
JK
2069/*
2070 * super.c
2071 */
7c45729a 2072int f2fs_inode_dirtied(struct inode *, bool);
0f18b462 2073void f2fs_inode_synced(struct inode *);
c5bda1c8 2074int f2fs_commit_super(struct f2fs_sb_info *, bool);
39a53e0c 2075int f2fs_sync_fs(struct super_block *, int);
a07ef784
NJ
2076extern __printf(3, 4)
2077void f2fs_msg(struct super_block *, const char *, const char *, ...);
984ec63c 2078int sanity_check_ckpt(struct f2fs_sb_info *sbi);
39a53e0c
JK
2079
2080/*
2081 * hash.c
2082 */
eee6160f 2083f2fs_hash_t f2fs_dentry_hash(const struct qstr *);
39a53e0c
JK
2084
2085/*
2086 * node.c
2087 */
2088struct dnode_of_data;
2089struct node_info;
2090
6fb03f3a 2091bool available_free_memory(struct f2fs_sb_info *, int);
2dcf51ab 2092int need_dentry_mark(struct f2fs_sb_info *, nid_t);
88bd02c9 2093bool is_checkpointed_node(struct f2fs_sb_info *, nid_t);
88bd02c9 2094bool need_inode_block_update(struct f2fs_sb_info *, nid_t);
39a53e0c 2095void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
3cf45747 2096pgoff_t get_next_page_offset(struct dnode_of_data *, pgoff_t);
39a53e0c
JK
2097int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int);
2098int truncate_inode_blocks(struct inode *, pgoff_t);
4f16fb0f 2099int truncate_xattr_node(struct inode *, struct page *);
cfe58f9d 2100int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t);
13ec7297 2101int remove_inode_page(struct inode *);
a014e037 2102struct page *new_inode_page(struct inode *);
8ae8f162 2103struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
39a53e0c
JK
2104void ra_node_page(struct f2fs_sb_info *, nid_t);
2105struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
2106struct page *get_node_page_ra(struct page *, int);
da011cc0 2107void move_node_page(struct page *, int);
26de9b11
JK
2108int fsync_node_pages(struct f2fs_sb_info *, struct inode *,
2109 struct writeback_control *, bool);
52681375 2110int sync_node_pages(struct f2fs_sb_info *, struct writeback_control *);
3a2ad567 2111void build_free_nids(struct f2fs_sb_info *, bool);
39a53e0c
JK
2112bool alloc_nid(struct f2fs_sb_info *, nid_t *);
2113void alloc_nid_done(struct f2fs_sb_info *, nid_t);
2114void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
31696580 2115int try_to_free_nids(struct f2fs_sb_info *, int);
70cfed88 2116void recover_inline_xattr(struct inode *, struct page *);
1c35a90e 2117void recover_xattr_data(struct inode *, struct page *, block_t);
39a53e0c
JK
2118int recover_inode_page(struct f2fs_sb_info *, struct page *);
2119int restore_node_summary(struct f2fs_sb_info *, unsigned int,
2120 struct f2fs_summary_block *);
2121void flush_nat_entries(struct f2fs_sb_info *);
2122int build_node_manager(struct f2fs_sb_info *);
2123void destroy_node_manager(struct f2fs_sb_info *);
6e6093a8 2124int __init create_node_manager_caches(void);
39a53e0c
JK
2125void destroy_node_manager_caches(void);
2126
2127/*
2128 * segment.c
2129 */
88b88a66 2130void register_inmem_page(struct inode *, struct page *);
29b96b54
CY
2131void drop_inmem_pages(struct inode *);
2132int commit_inmem_pages(struct inode *);
2c4db1a6 2133void f2fs_balance_fs(struct f2fs_sb_info *, bool);
4660f9c0 2134void f2fs_balance_fs_bg(struct f2fs_sb_info *);
6b4afdd7 2135int f2fs_issue_flush(struct f2fs_sb_info *);
2163d198 2136int create_flush_cmd_control(struct f2fs_sb_info *);
5eba8c5d 2137void destroy_flush_cmd_control(struct f2fs_sb_info *, bool);
39a53e0c 2138void invalidate_blocks(struct f2fs_sb_info *, block_t);
6e2c64ad 2139bool is_checkpointed_data(struct f2fs_sb_info *, block_t);
5e443818 2140void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t);
4e6a8d9b 2141void f2fs_wait_discard_bio(struct f2fs_sb_info *, block_t);
836b5a63 2142void clear_prefree_segments(struct f2fs_sb_info *, struct cp_control *);
4b2fecc8 2143void release_discard_addrs(struct f2fs_sb_info *);
3fa06d7b 2144int npages_for_summary_flush(struct f2fs_sb_info *, bool);
39a53e0c 2145void allocate_new_segments(struct f2fs_sb_info *);
4b2fecc8 2146int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *);
25290fa5 2147bool exist_trim_candidates(struct f2fs_sb_info *, struct cp_control *);
39a53e0c 2148struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
381722d2 2149void update_meta_page(struct f2fs_sb_info *, void *, block_t);
577e3495 2150void write_meta_page(struct f2fs_sb_info *, struct page *);
05ca3632
JK
2151void write_node_page(unsigned int, struct f2fs_io_info *);
2152void write_data_page(struct dnode_of_data *, struct f2fs_io_info *);
2153void rewrite_data_page(struct f2fs_io_info *);
4356e48e
CY
2154void __f2fs_replace_block(struct f2fs_sb_info *, struct f2fs_summary *,
2155 block_t, block_t, bool, bool);
528e3459 2156void f2fs_replace_block(struct f2fs_sb_info *, struct dnode_of_data *,
28bc106b 2157 block_t, block_t, unsigned char, bool, bool);
bfad7c2d
JK
2158void allocate_data_block(struct f2fs_sb_info *, struct page *,
2159 block_t, block_t *, struct f2fs_summary *, int);
fec1d657 2160void f2fs_wait_on_page_writeback(struct page *, enum page_type, bool);
08b39fbd 2161void f2fs_wait_on_encrypted_page_writeback(struct f2fs_sb_info *, block_t);
39a53e0c
JK
2162void write_data_summaries(struct f2fs_sb_info *, block_t);
2163void write_node_summaries(struct f2fs_sb_info *, block_t);
dfc08a12 2164int lookup_journal_in_cursum(struct f2fs_journal *, int, unsigned int, int);
4b2fecc8 2165void flush_sit_entries(struct f2fs_sb_info *, struct cp_control *);
39a53e0c 2166int build_segment_manager(struct f2fs_sb_info *);
39a53e0c 2167void destroy_segment_manager(struct f2fs_sb_info *);
7fd9e544
JK
2168int __init create_segment_manager_caches(void);
2169void destroy_segment_manager_caches(void);
39a53e0c
JK
2170
2171/*
2172 * checkpoint.c
2173 */
38f91ca8 2174void f2fs_stop_checkpoint(struct f2fs_sb_info *, bool);
39a53e0c
JK
2175struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
2176struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
2b947003 2177struct page *get_tmp_page(struct f2fs_sb_info *, pgoff_t);
f0c9cada 2178bool is_valid_blkaddr(struct f2fs_sb_info *, block_t, int);
26879fb1 2179int ra_meta_pages(struct f2fs_sb_info *, block_t, int, int, bool);
635aee1f 2180void ra_meta_pages_cond(struct f2fs_sb_info *, pgoff_t);
39a53e0c 2181long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
a49324f1
CY
2182void add_ino_entry(struct f2fs_sb_info *, nid_t, int type);
2183void remove_ino_entry(struct f2fs_sb_info *, nid_t, int type);
74ef9241 2184void release_ino_entry(struct f2fs_sb_info *, bool);
fff04f90 2185bool exist_written_data(struct f2fs_sb_info *, nid_t, int);
0f18b462 2186int f2fs_sync_inode_meta(struct f2fs_sb_info *);
cbd56e7d
JK
2187int acquire_orphan_inode(struct f2fs_sb_info *);
2188void release_orphan_inode(struct f2fs_sb_info *);
67c3758d 2189void add_orphan_inode(struct inode *);
39a53e0c 2190void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
8c14bfad 2191int recover_orphan_inodes(struct f2fs_sb_info *);
39a53e0c 2192int get_valid_checkpoint(struct f2fs_sb_info *);
a7ffdbe2 2193void update_dirty_page(struct inode *, struct page *);
c227f912 2194void remove_dirty_inode(struct inode *);
6d5a1495 2195int sync_dirty_inodes(struct f2fs_sb_info *, enum inode_type);
c34f42e2 2196int write_checkpoint(struct f2fs_sb_info *, struct cp_control *);
6451e041 2197void init_ino_entry_info(struct f2fs_sb_info *);
6e6093a8 2198int __init create_checkpoint_caches(void);
39a53e0c
JK
2199void destroy_checkpoint_caches(void);
2200
2201/*
2202 * data.c
2203 */
458e6197 2204void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int);
0c3a5797
CY
2205void f2fs_submit_merged_bio_cond(struct f2fs_sb_info *, struct inode *,
2206 struct page *, nid_t, enum page_type, int);
406657dd 2207void f2fs_flush_merged_bios(struct f2fs_sb_info *);
05ca3632 2208int f2fs_submit_page_bio(struct f2fs_io_info *);
0a595eba 2209int f2fs_submit_page_mbio(struct f2fs_io_info *);
3c62be17
JK
2210struct block_device *f2fs_target_device(struct f2fs_sb_info *,
2211 block_t, struct bio *);
2212int f2fs_target_device_index(struct f2fs_sb_info *, block_t);
216a620a 2213void set_data_blkaddr(struct dnode_of_data *);
f28b3434 2214void f2fs_update_data_blkaddr(struct dnode_of_data *, block_t);
46008c6d 2215int reserve_new_blocks(struct dnode_of_data *, blkcnt_t);
39a53e0c 2216int reserve_new_block(struct dnode_of_data *);
759af1c9 2217int f2fs_get_block(struct dnode_of_data *, pgoff_t);
a7de6086 2218int f2fs_preallocate_blocks(struct kiocb *, struct iov_iter *);
b600965c 2219int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
a56c7c6f 2220struct page *get_read_data_page(struct inode *, pgoff_t, int, bool);
43f3eae1 2221struct page *find_data_page(struct inode *, pgoff_t);
a56c7c6f 2222struct page *get_lock_data_page(struct inode *, pgoff_t, bool);
64aa7ed9 2223struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
05ca3632 2224int do_write_data_page(struct f2fs_io_info *);
d323d005 2225int f2fs_map_blocks(struct inode *, struct f2fs_map_blocks *, int, int);
9ab70134 2226int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);
fe76b796 2227void f2fs_set_page_dirty_nobuffers(struct page *);
487261f3
CY
2228void f2fs_invalidate_page(struct page *, unsigned int, unsigned int);
2229int f2fs_release_page(struct page *, gfp_t);
5b7a487c
WG
2230#ifdef CONFIG_MIGRATION
2231int f2fs_migrate_page(struct address_space *, struct page *, struct page *,
2232 enum migrate_mode);
2233#endif
39a53e0c
JK
2234
2235/*
2236 * gc.c
2237 */
2238int start_gc_thread(struct f2fs_sb_info *);
2239void stop_gc_thread(struct f2fs_sb_info *);
81ca7350 2240block_t start_bidx_of_node(unsigned int, struct inode *);
7702bdbe 2241int f2fs_gc(struct f2fs_sb_info *, bool, bool);
39a53e0c 2242void build_gc_manager(struct f2fs_sb_info *);
39a53e0c
JK
2243
2244/*
2245 * recovery.c
2246 */
6781eabb 2247int recover_fsync_data(struct f2fs_sb_info *, bool);
39a53e0c
JK
2248bool space_for_roll_forward(struct f2fs_sb_info *);
2249
2250/*
2251 * debug.c
2252 */
2253#ifdef CONFIG_F2FS_STAT_FS
2254struct f2fs_stat_info {
2255 struct list_head stat_list;
2256 struct f2fs_sb_info *sbi;
39a53e0c
JK
2257 int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
2258 int main_area_segs, main_area_sections, main_area_zones;
5b7ee374
CY
2259 unsigned long long hit_largest, hit_cached, hit_rbtree;
2260 unsigned long long hit_total, total_ext;
c00ba554 2261 int ext_tree, zombie_tree, ext_node;
35782b23
JK
2262 int ndirty_node, ndirty_dent, ndirty_meta, ndirty_data, ndirty_imeta;
2263 int inmem_pages;
0f18b462 2264 unsigned int ndirty_dirs, ndirty_files, ndirty_all;
b8559dc2 2265 int nats, dirty_nats, sits, dirty_sits, free_nids, alloc_nids;
39a53e0c 2266 int total_count, utilization;
dcc9165d 2267 int bg_gc, nr_wb_cp_data, nr_wb_data, nr_flush, nr_discard;
652be551 2268 int inline_xattr, inline_inode, inline_dir, orphans;
26a28a0c 2269 int aw_cnt, max_aw_cnt;
f83a2584 2270 unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
39a53e0c
JK
2271 unsigned int bimodal, avg_vblocks;
2272 int util_free, util_valid, util_invalid;
2273 int rsvd_segs, overp_segs;
2274 int dirty_count, node_pages, meta_pages;
42190d2a 2275 int prefree_count, call_count, cp_count, bg_cp_count;
39a53e0c 2276 int tot_segs, node_segs, data_segs, free_segs, free_secs;
e1235983 2277 int bg_node_segs, bg_data_segs;
39a53e0c 2278 int tot_blks, data_blks, node_blks;
e1235983 2279 int bg_data_blks, bg_node_blks;
39a53e0c
JK
2280 int curseg[NR_CURSEG_TYPE];
2281 int cursec[NR_CURSEG_TYPE];
2282 int curzone[NR_CURSEG_TYPE];
2283
2284 unsigned int segment_count[2];
2285 unsigned int block_count[2];
b9a2c252 2286 unsigned int inplace_count;
9edcdabf 2287 unsigned long long base_mem, cache_mem, page_mem;
39a53e0c
JK
2288};
2289
963d4f7d
GZ
2290static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
2291{
6c311ec6 2292 return (struct f2fs_stat_info *)sbi->stat_info;
963d4f7d
GZ
2293}
2294
942e0be6 2295#define stat_inc_cp_count(si) ((si)->cp_count++)
42190d2a 2296#define stat_inc_bg_cp_count(si) ((si)->bg_cp_count++)
dcdfff65
JK
2297#define stat_inc_call_count(si) ((si)->call_count++)
2298#define stat_inc_bggc_count(sbi) ((sbi)->bg_gc++)
33fbd510
CY
2299#define stat_inc_dirty_inode(sbi, type) ((sbi)->ndirty_inode[type]++)
2300#define stat_dec_dirty_inode(sbi, type) ((sbi)->ndirty_inode[type]--)
5b7ee374
CY
2301#define stat_inc_total_hit(sbi) (atomic64_inc(&(sbi)->total_hit_ext))
2302#define stat_inc_rbtree_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_rbtree))
2303#define stat_inc_largest_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_largest))
2304#define stat_inc_cached_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_cached))
d5e8f6c9
CY
2305#define stat_inc_inline_xattr(inode) \
2306 do { \
2307 if (f2fs_has_inline_xattr(inode)) \
2308 (atomic_inc(&F2FS_I_SB(inode)->inline_xattr)); \
2309 } while (0)
2310#define stat_dec_inline_xattr(inode) \
2311 do { \
2312 if (f2fs_has_inline_xattr(inode)) \
2313 (atomic_dec(&F2FS_I_SB(inode)->inline_xattr)); \
2314 } while (0)
0dbdc2ae
JK
2315#define stat_inc_inline_inode(inode) \
2316 do { \
2317 if (f2fs_has_inline_data(inode)) \
03e14d52 2318 (atomic_inc(&F2FS_I_SB(inode)->inline_inode)); \
0dbdc2ae
JK
2319 } while (0)
2320#define stat_dec_inline_inode(inode) \
2321 do { \
2322 if (f2fs_has_inline_data(inode)) \
03e14d52 2323 (atomic_dec(&F2FS_I_SB(inode)->inline_inode)); \
0dbdc2ae 2324 } while (0)
3289c061
JK
2325#define stat_inc_inline_dir(inode) \
2326 do { \
2327 if (f2fs_has_inline_dentry(inode)) \
03e14d52 2328 (atomic_inc(&F2FS_I_SB(inode)->inline_dir)); \
3289c061
JK
2329 } while (0)
2330#define stat_dec_inline_dir(inode) \
2331 do { \
2332 if (f2fs_has_inline_dentry(inode)) \
03e14d52 2333 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
3289c061 2334 } while (0)
dcdfff65
JK
2335#define stat_inc_seg_type(sbi, curseg) \
2336 ((sbi)->segment_count[(curseg)->alloc_type]++)
2337#define stat_inc_block_count(sbi, curseg) \
2338 ((sbi)->block_count[(curseg)->alloc_type]++)
b9a2c252
CL
2339#define stat_inc_inplace_blocks(sbi) \
2340 (atomic_inc(&(sbi)->inplace_count))
26a28a0c
JK
2341#define stat_inc_atomic_write(inode) \
2342 (atomic_inc(&F2FS_I_SB(inode)->aw_cnt));
2343#define stat_dec_atomic_write(inode) \
2344 (atomic_dec(&F2FS_I_SB(inode)->aw_cnt));
2345#define stat_update_max_atomic_write(inode) \
2346 do { \
2347 int cur = atomic_read(&F2FS_I_SB(inode)->aw_cnt); \
2348 int max = atomic_read(&F2FS_I_SB(inode)->max_aw_cnt); \
2349 if (cur > max) \
2350 atomic_set(&F2FS_I_SB(inode)->max_aw_cnt, cur); \
2351 } while (0)
e1235983 2352#define stat_inc_seg_count(sbi, type, gc_type) \
39a53e0c 2353 do { \
963d4f7d 2354 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
39a53e0c 2355 (si)->tot_segs++; \
e1235983 2356 if (type == SUM_TYPE_DATA) { \
39a53e0c 2357 si->data_segs++; \
e1235983
CL
2358 si->bg_data_segs += (gc_type == BG_GC) ? 1 : 0; \
2359 } else { \
39a53e0c 2360 si->node_segs++; \
e1235983
CL
2361 si->bg_node_segs += (gc_type == BG_GC) ? 1 : 0; \
2362 } \
39a53e0c
JK
2363 } while (0)
2364
2365#define stat_inc_tot_blk_count(si, blks) \
2366 (si->tot_blks += (blks))
2367
e1235983 2368#define stat_inc_data_blk_count(sbi, blks, gc_type) \
39a53e0c 2369 do { \
963d4f7d 2370 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
39a53e0c
JK
2371 stat_inc_tot_blk_count(si, blks); \
2372 si->data_blks += (blks); \
e1235983 2373 si->bg_data_blks += (gc_type == BG_GC) ? (blks) : 0; \
39a53e0c
JK
2374 } while (0)
2375
e1235983 2376#define stat_inc_node_blk_count(sbi, blks, gc_type) \
39a53e0c 2377 do { \
963d4f7d 2378 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
39a53e0c
JK
2379 stat_inc_tot_blk_count(si, blks); \
2380 si->node_blks += (blks); \
e1235983 2381 si->bg_node_blks += (gc_type == BG_GC) ? (blks) : 0; \
39a53e0c
JK
2382 } while (0)
2383
2384int f2fs_build_stats(struct f2fs_sb_info *);
2385void f2fs_destroy_stats(struct f2fs_sb_info *);
787c7b8c 2386int __init f2fs_create_root_stats(void);
4589d25d 2387void f2fs_destroy_root_stats(void);
39a53e0c 2388#else
942e0be6 2389#define stat_inc_cp_count(si)
42190d2a 2390#define stat_inc_bg_cp_count(si)
39a53e0c 2391#define stat_inc_call_count(si)
dcdfff65 2392#define stat_inc_bggc_count(si)
33fbd510
CY
2393#define stat_inc_dirty_inode(sbi, type)
2394#define stat_dec_dirty_inode(sbi, type)
dcdfff65 2395#define stat_inc_total_hit(sb)
029e13cc 2396#define stat_inc_rbtree_node_hit(sb)
91c481ff
CY
2397#define stat_inc_largest_node_hit(sbi)
2398#define stat_inc_cached_node_hit(sbi)
d5e8f6c9
CY
2399#define stat_inc_inline_xattr(inode)
2400#define stat_dec_inline_xattr(inode)
0dbdc2ae
JK
2401#define stat_inc_inline_inode(inode)
2402#define stat_dec_inline_inode(inode)
3289c061
JK
2403#define stat_inc_inline_dir(inode)
2404#define stat_dec_inline_dir(inode)
26a28a0c
JK
2405#define stat_inc_atomic_write(inode)
2406#define stat_dec_atomic_write(inode)
2407#define stat_update_max_atomic_write(inode)
dcdfff65
JK
2408#define stat_inc_seg_type(sbi, curseg)
2409#define stat_inc_block_count(sbi, curseg)
b9a2c252 2410#define stat_inc_inplace_blocks(sbi)
e1235983 2411#define stat_inc_seg_count(sbi, type, gc_type)
39a53e0c 2412#define stat_inc_tot_blk_count(si, blks)
e1235983
CL
2413#define stat_inc_data_blk_count(sbi, blks, gc_type)
2414#define stat_inc_node_blk_count(sbi, blks, gc_type)
39a53e0c
JK
2415
2416static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
2417static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
787c7b8c 2418static inline int __init f2fs_create_root_stats(void) { return 0; }
4589d25d 2419static inline void f2fs_destroy_root_stats(void) { }
39a53e0c
JK
2420#endif
2421
2422extern const struct file_operations f2fs_dir_operations;
2423extern const struct file_operations f2fs_file_operations;
2424extern const struct inode_operations f2fs_file_inode_operations;
2425extern const struct address_space_operations f2fs_dblock_aops;
2426extern const struct address_space_operations f2fs_node_aops;
2427extern const struct address_space_operations f2fs_meta_aops;
2428extern const struct inode_operations f2fs_dir_inode_operations;
2429extern const struct inode_operations f2fs_symlink_inode_operations;
cbaf042a 2430extern const struct inode_operations f2fs_encrypted_symlink_inode_operations;
39a53e0c 2431extern const struct inode_operations f2fs_special_inode_operations;
29e7043f 2432extern struct kmem_cache *inode_entry_slab;
1001b347 2433
e18c65b2
HL
2434/*
2435 * inline.c
2436 */
01b960e9
JK
2437bool f2fs_may_inline_data(struct inode *);
2438bool f2fs_may_inline_dentry(struct inode *);
b3d208f9 2439void read_inline_data(struct page *, struct page *);
0bfcfcca 2440bool truncate_inline_inode(struct page *, u64);
e18c65b2 2441int f2fs_read_inline_data(struct inode *, struct page *);
b3d208f9
JK
2442int f2fs_convert_inline_page(struct dnode_of_data *, struct page *);
2443int f2fs_convert_inline_inode(struct inode *);
2444int f2fs_write_inline_data(struct inode *, struct page *);
0342fd30 2445bool recover_inline_data(struct inode *, struct page *);
6e22c691 2446struct f2fs_dir_entry *find_in_inline_dir(struct inode *,
0b81d077 2447 struct fscrypt_name *, struct page **);
201a05be 2448int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
9421d570
CY
2449int f2fs_add_inline_entry(struct inode *, const struct qstr *,
2450 const struct qstr *, struct inode *, nid_t, umode_t);
201a05be
CY
2451void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *,
2452 struct inode *, struct inode *);
2453bool f2fs_empty_inline_dir(struct inode *);
d8c6822a 2454int f2fs_read_inline_dir(struct file *, struct dir_context *,
0b81d077 2455 struct fscrypt_str *);
67f8cf3c
JK
2456int f2fs_inline_data_fiemap(struct inode *,
2457 struct fiemap_extent_info *, __u64, __u64);
cde4de12 2458
2658e50d
JK
2459/*
2460 * shrinker.c
2461 */
2462unsigned long f2fs_shrink_count(struct shrinker *, struct shrink_control *);
2463unsigned long f2fs_shrink_scan(struct shrinker *, struct shrink_control *);
2464void f2fs_join_shrinker(struct f2fs_sb_info *);
2465void f2fs_leave_shrinker(struct f2fs_sb_info *);
2466
a28ef1f5
CY
2467/*
2468 * extent_cache.c
2469 */
2470unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *, int);
ed3d1256 2471bool f2fs_init_extent_tree(struct inode *, struct f2fs_extent *);
5f281fab 2472void f2fs_drop_extent_tree(struct inode *);
a28ef1f5
CY
2473unsigned int f2fs_destroy_extent_node(struct inode *);
2474void f2fs_destroy_extent_tree(struct inode *);
2475bool f2fs_lookup_extent_cache(struct inode *, pgoff_t, struct extent_info *);
2476void f2fs_update_extent_cache(struct dnode_of_data *);
19b2c30d
CY
2477void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
2478 pgoff_t, block_t, unsigned int);
a28ef1f5
CY
2479void init_extent_cache_info(struct f2fs_sb_info *);
2480int __init create_extent_cache(void);
2481void destroy_extent_cache(void);
2482
cde4de12
JK
2483/*
2484 * crypto support
2485 */
0b81d077 2486static inline bool f2fs_encrypted_inode(struct inode *inode)
cde4de12 2487{
cde4de12 2488 return file_is_encrypt(inode);
cde4de12
JK
2489}
2490
2491static inline void f2fs_set_encrypted_inode(struct inode *inode)
2492{
2493#ifdef CONFIG_F2FS_FS_ENCRYPTION
2494 file_set_encrypt(inode);
2495#endif
2496}
2497
2498static inline bool f2fs_bio_encrypted(struct bio *bio)
2499{
0b81d077 2500 return bio->bi_private != NULL;
cde4de12
JK
2501}
2502
2503static inline int f2fs_sb_has_crypto(struct super_block *sb)
2504{
cde4de12 2505 return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_ENCRYPT);
cde4de12 2506}
f424f664 2507
0bfd7a09 2508static inline int f2fs_sb_mounted_blkzoned(struct super_block *sb)
52763a4b 2509{
0bfd7a09 2510 return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_BLKZONED);
52763a4b
JK
2511}
2512
178053e2
DLM
2513#ifdef CONFIG_BLK_DEV_ZONED
2514static inline int get_blkz_type(struct f2fs_sb_info *sbi,
3c62be17 2515 struct block_device *bdev, block_t blkaddr)
178053e2
DLM
2516{
2517 unsigned int zno = blkaddr >> sbi->log_blocks_per_blkz;
3c62be17 2518 int i;
178053e2 2519
3c62be17
JK
2520 for (i = 0; i < sbi->s_ndevs; i++)
2521 if (FDEV(i).bdev == bdev)
2522 return FDEV(i).blkz_type[zno];
2523 return -EINVAL;
178053e2
DLM
2524}
2525#endif
2526
96ba2dec 2527static inline bool f2fs_discard_en(struct f2fs_sb_info *sbi)
52763a4b 2528{
96ba2dec
DLM
2529 struct request_queue *q = bdev_get_queue(sbi->sb->s_bdev);
2530
2531 return blk_queue_discard(q) || f2fs_sb_mounted_blkzoned(sbi->sb);
52763a4b
JK
2532}
2533
2534static inline void set_opt_mode(struct f2fs_sb_info *sbi, unsigned int mt)
2535{
2536 clear_opt(sbi, ADAPTIVE);
2537 clear_opt(sbi, LFS);
2538
2539 switch (mt) {
2540 case F2FS_MOUNT_ADAPTIVE:
2541 set_opt(sbi, ADAPTIVE);
2542 break;
2543 case F2FS_MOUNT_LFS:
2544 set_opt(sbi, LFS);
2545 break;
2546 }
2547}
2548
fcc85a4d
JK
2549static inline bool f2fs_may_encrypt(struct inode *inode)
2550{
2551#ifdef CONFIG_F2FS_FS_ENCRYPTION
886f56f9 2552 umode_t mode = inode->i_mode;
fcc85a4d
JK
2553
2554 return (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode));
2555#else
2556 return 0;
2557#endif
2558}
2559
0b81d077
JK
2560#ifndef CONFIG_F2FS_FS_ENCRYPTION
2561#define fscrypt_set_d_op(i)
2562#define fscrypt_get_ctx fscrypt_notsupp_get_ctx
2563#define fscrypt_release_ctx fscrypt_notsupp_release_ctx
2564#define fscrypt_encrypt_page fscrypt_notsupp_encrypt_page
2565#define fscrypt_decrypt_page fscrypt_notsupp_decrypt_page
2566#define fscrypt_decrypt_bio_pages fscrypt_notsupp_decrypt_bio_pages
2567#define fscrypt_pullback_bio_page fscrypt_notsupp_pullback_bio_page
2568#define fscrypt_restore_control_page fscrypt_notsupp_restore_control_page
2569#define fscrypt_zeroout_range fscrypt_notsupp_zeroout_range
db717d8e
EB
2570#define fscrypt_ioctl_set_policy fscrypt_notsupp_ioctl_set_policy
2571#define fscrypt_ioctl_get_policy fscrypt_notsupp_ioctl_get_policy
0b81d077
JK
2572#define fscrypt_has_permitted_context fscrypt_notsupp_has_permitted_context
2573#define fscrypt_inherit_context fscrypt_notsupp_inherit_context
2574#define fscrypt_get_encryption_info fscrypt_notsupp_get_encryption_info
2575#define fscrypt_put_encryption_info fscrypt_notsupp_put_encryption_info
2576#define fscrypt_setup_filename fscrypt_notsupp_setup_filename
2577#define fscrypt_free_filename fscrypt_notsupp_free_filename
2578#define fscrypt_fname_encrypted_size fscrypt_notsupp_fname_encrypted_size
2579#define fscrypt_fname_alloc_buffer fscrypt_notsupp_fname_alloc_buffer
2580#define fscrypt_fname_free_buffer fscrypt_notsupp_fname_free_buffer
2581#define fscrypt_fname_disk_to_usr fscrypt_notsupp_fname_disk_to_usr
2582#define fscrypt_fname_usr_to_disk fscrypt_notsupp_fname_usr_to_disk
57e5055b 2583#endif
39a53e0c 2584#endif