blob: d8302a3b4fb8254371c8070bf96007ea4265da8e [file] [log] [blame]
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09001/*
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002 * 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>
Jaegeuk Kim39a53e02012-11-28 13:37:31 +090017#include <linux/slab.h>
18#include <linux/crc32.h>
19#include <linux/magic.h>
Jaegeuk Kimc2d715d2013-08-08 15:56:49 +090020#include <linux/kobject.h>
Gu Zheng7bd59382013-10-22 14:52:26 +080021#include <linux/sched.h>
Jaegeuk Kime6b120d2017-07-10 12:55:09 -070022#include <linux/writeback.h>
Jaegeuk Kim462d7622018-01-04 21:36:09 -080023#include <linux/cred.h>
Jaegeuk Kim39307a82015-09-22 13:50:47 -070024#include <linux/vmalloc.h>
Jaegeuk Kim740432f2015-08-14 11:43:56 -070025#include <linux/bio.h>
Jaegeuk Kimd0239e12016-01-08 16:57:48 -080026#include <linux/blkdev.h>
Chao Yu09c3a722017-07-09 00:13:07 +080027#include <linux/quotaops.h>
Keith Mok43b65732016-03-02 12:04:24 -080028#include <crypto/hash.h>
Jaegeuk Kim39a53e02012-11-28 13:37:31 +090029
Dave Chinner16179292017-10-09 12:15:34 -070030#define __FS_HAS_ENCRYPTION IS_ENABLED(CONFIG_F2FS_FS_ENCRYPTION)
31#include <linux/fscrypt.h>
32
Jaegeuk Kim5d56b672013-10-29 15:14:54 +090033#ifdef CONFIG_F2FS_CHECK_FS
Jaegeuk Kim9850cf42014-09-02 15:52:58 -070034#define f2fs_bug_on(sbi, condition) BUG_ON(condition)
Jaegeuk Kim5d56b672013-10-29 15:14:54 +090035#else
Jaegeuk Kim9850cf42014-09-02 15:52:58 -070036#define f2fs_bug_on(sbi, condition) \
37 do { \
38 if (unlikely(condition)) { \
39 WARN_ON(1); \
Chao Yucaf00472015-01-28 17:48:42 +080040 set_sbi_flag(sbi, SBI_NEED_FSCK); \
Jaegeuk Kim9850cf42014-09-02 15:52:58 -070041 } \
42 } while (0)
Jaegeuk Kim5d56b672013-10-29 15:14:54 +090043#endif
44
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070045#ifdef CONFIG_F2FS_FAULT_INJECTION
46enum {
47 FAULT_KMALLOC,
Chao Yuead52592017-11-30 19:28:18 +080048 FAULT_KVMALLOC,
Jaegeuk Kimc41f3cc32016-04-29 16:17:09 -070049 FAULT_PAGE_ALLOC,
Chao Yu58ddec82017-10-28 16:52:30 +080050 FAULT_PAGE_GET,
Chao Yub5db2de2017-10-28 16:52:31 +080051 FAULT_ALLOC_BIO,
Jaegeuk Kimcb789422016-04-29 16:29:22 -070052 FAULT_ALLOC_NID,
53 FAULT_ORPHAN,
54 FAULT_BLOCK,
55 FAULT_DIR_DEPTH,
Jaegeuk Kim53aa6bb2016-05-25 15:24:18 -070056 FAULT_EVICT_INODE,
Jaegeuk Kime6b120d2017-07-10 12:55:09 -070057 FAULT_TRUNCATE,
Chao Yu8b038c72016-09-18 23:30:07 +080058 FAULT_IO,
Chao Yu0f348022016-09-26 19:45:55 +080059 FAULT_CHECKPOINT,
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070060 FAULT_MAX,
61};
62
Sheng Yong08796892016-05-16 12:38:50 +080063struct f2fs_fault_info {
64 atomic_t inject_ops;
65 unsigned int inject_rate;
66 unsigned int inject_type;
67};
68
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070069extern char *fault_name[FAULT_MAX];
Jaegeuk Kime6b120d2017-07-10 12:55:09 -070070#define IS_FAULT_SET(fi, type) ((fi)->inject_type & (1 << (type)))
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -070071#endif
72
Jaegeuk Kim39a53e02012-11-28 13:37:31 +090073/*
74 * For mount options
75 */
76#define F2FS_MOUNT_BG_GC 0x00000001
77#define F2FS_MOUNT_DISABLE_ROLL_FORWARD 0x00000002
78#define F2FS_MOUNT_DISCARD 0x00000004
79#define F2FS_MOUNT_NOHEAP 0x00000008
80#define F2FS_MOUNT_XATTR_USER 0x00000010
81#define F2FS_MOUNT_POSIX_ACL 0x00000020
82#define F2FS_MOUNT_DISABLE_EXT_IDENTIFY 0x00000040
Jaegeuk Kim444c5802013-08-08 15:16:22 +090083#define F2FS_MOUNT_INLINE_XATTR 0x00000080
Huajun Li1001b342013-11-10 23:13:16 +080084#define F2FS_MOUNT_INLINE_DATA 0x00000100
Chao Yu34d67de2014-09-24 18:15:19 +080085#define F2FS_MOUNT_INLINE_DENTRY 0x00000200
86#define F2FS_MOUNT_FLUSH_MERGE 0x00000400
87#define F2FS_MOUNT_NOBARRIER 0x00000800
Jaegeuk Kimd5053a342014-10-30 22:47:03 -070088#define F2FS_MOUNT_FASTBOOT 0x00001000
Chao Yu89672152015-02-05 17:55:51 +080089#define F2FS_MOUNT_EXTENT_CACHE 0x00002000
Jaegeuk Kim6aefd932015-10-05 11:02:54 -070090#define F2FS_MOUNT_FORCE_FG_GC 0x00004000
Chao Yu343f40f2015-12-16 13:12:16 +080091#define F2FS_MOUNT_DATA_FLUSH 0x00008000
Jaegeuk Kim73faec42016-04-29 15:34:32 -070092#define F2FS_MOUNT_FAULT_INJECTION 0x00010000
Jaegeuk Kim36abef42016-06-03 19:29:38 -070093#define F2FS_MOUNT_ADAPTIVE 0x00020000
94#define F2FS_MOUNT_LFS 0x00040000
Chao Yu09c3a722017-07-09 00:13:07 +080095#define F2FS_MOUNT_USRQUOTA 0x00080000
96#define F2FS_MOUNT_GRPQUOTA 0x00100000
Chao Yu5647b302017-07-26 00:01:41 +080097#define F2FS_MOUNT_PRJQUOTA 0x00200000
Chao Yu41ad73f2017-08-08 10:54:31 +080098#define F2FS_MOUNT_QUOTA 0x00400000
Chao Yu50ffaa92017-09-06 21:59:50 +080099#define F2FS_MOUNT_INLINE_XATTR_SIZE 0x00800000
Jaegeuk Kim5fee5402017-12-27 15:05:52 -0800100#define F2FS_MOUNT_RESERVE_ROOT 0x01000000
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900101
Chao Yue9a50e62018-03-08 14:22:56 +0800102#define F2FS_OPTION(sbi) ((sbi)->mount_opt)
103#define clear_opt(sbi, option) (F2FS_OPTION(sbi).opt &= ~F2FS_MOUNT_##option)
104#define set_opt(sbi, option) (F2FS_OPTION(sbi).opt |= F2FS_MOUNT_##option)
105#define test_opt(sbi, option) (F2FS_OPTION(sbi).opt & F2FS_MOUNT_##option)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900106
107#define ver_after(a, b) (typecheck(unsigned long long, a) && \
108 typecheck(unsigned long long, b) && \
109 ((long long)((a) - (b)) > 0))
110
Jaegeuk Kima9841c42013-05-24 12:41:04 +0900111typedef u32 block_t; /*
112 * should not change u32, since it is the on-disk block
113 * address format, __le32.
114 */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900115typedef u32 nid_t;
116
117struct f2fs_mount_info {
Chao Yue9a50e62018-03-08 14:22:56 +0800118 unsigned int opt;
119 int write_io_size_bits; /* Write IO size bits */
120 block_t root_reserved_blocks; /* root reserved blocks */
121 kuid_t s_resuid; /* reserved blocks for uid */
122 kgid_t s_resgid; /* reserved blocks for gid */
123 int active_logs; /* # of active logs */
124 int inline_xattr_size; /* inline xattr size */
125#ifdef CONFIG_F2FS_FAULT_INJECTION
126 struct f2fs_fault_info fault_info; /* For fault injection */
127#endif
128#ifdef CONFIG_QUOTA
129 /* Names of quota files with journalled quota */
130 char *s_qf_names[MAXQUOTAS];
131 int s_jquota_fmt; /* Format of quota to use */
132#endif
133 /* For which write hints are passed down to block layer */
134 int whint_mode;
135 int alloc_mode; /* segment allocation policy */
136 int fsync_mode; /* fsync policy */
Sheng Yongaa5bcfd2018-03-15 18:51:42 +0800137 bool test_dummy_encryption; /* test dummy encryption */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900138};
139
Chao Yufbcf9312017-07-19 00:19:06 +0800140#define F2FS_FEATURE_ENCRYPT 0x0001
141#define F2FS_FEATURE_BLKZONED 0x0002
142#define F2FS_FEATURE_ATOMIC_WRITE 0x0004
143#define F2FS_FEATURE_EXTRA_ATTR 0x0008
Chao Yu5647b302017-07-26 00:01:41 +0800144#define F2FS_FEATURE_PRJQUOTA 0x0010
Chao Yu43101252017-07-31 20:19:09 +0800145#define F2FS_FEATURE_INODE_CHKSUM 0x0020
Chao Yu50ffaa92017-09-06 21:59:50 +0800146#define F2FS_FEATURE_FLEXIBLE_INLINE_XATTR 0x0040
Jaegeuk Kimd4c292d2017-10-05 21:03:06 -0700147#define F2FS_FEATURE_QUOTA_INO 0x0080
Chao Yu71f8f042018-01-25 14:54:42 +0800148#define F2FS_FEATURE_INODE_CRTIME 0x0100
Sheng Yong9b880fe2018-03-15 18:51:41 +0800149#define F2FS_FEATURE_LOST_FOUND 0x0200
Eric Biggers29cead52018-03-28 11:15:09 -0700150#define F2FS_FEATURE_VERITY 0x0400 /* reserved */
Jaegeuk Kimcde4de12015-04-20 13:57:51 -0700151
Jaegeuk Kim76f105a2015-04-13 15:10:36 -0700152#define F2FS_HAS_FEATURE(sb, mask) \
153 ((F2FS_SB(sb)->raw_super->feature & cpu_to_le32(mask)) != 0)
154#define F2FS_SET_FEATURE(sb, mask) \
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700155 (F2FS_SB(sb)->raw_super->feature |= cpu_to_le32(mask))
Jaegeuk Kim76f105a2015-04-13 15:10:36 -0700156#define F2FS_CLEAR_FEATURE(sb, mask) \
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700157 (F2FS_SB(sb)->raw_super->feature &= ~cpu_to_le32(mask))
Jaegeuk Kim76f105a2015-04-13 15:10:36 -0700158
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900159/*
Jaegeuk Kim462d7622018-01-04 21:36:09 -0800160 * Default values for user and/or group using reserved blocks
161 */
162#define F2FS_DEF_RESUID 0
163#define F2FS_DEF_RESGID 0
164
165/*
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900166 * For checkpoint manager
167 */
168enum {
169 NAT_BITMAP,
170 SIT_BITMAP
171};
172
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700173#define CP_UMOUNT 0x00000001
174#define CP_FASTBOOT 0x00000002
175#define CP_SYNC 0x00000004
176#define CP_RECOVERY 0x00000008
177#define CP_DISCARD 0x00000010
178#define CP_TRIMMED 0x00000020
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700179
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700180#define MAX_DISCARD_BLOCKS(sbi) BLKS_PER_SEC(sbi)
Chao Yu69a59672017-10-04 09:08:33 +0800181#define DEF_MAX_DISCARD_REQUEST 8 /* issue 8 discards per round */
Jaegeuk Kim8f6a2e72018-05-24 13:57:26 -0700182#define DEF_MAX_DISCARD_LEN 512 /* Max. 2MB per discard */
Chao Yuefe24da2017-08-07 23:09:56 +0800183#define DEF_MIN_DISCARD_ISSUE_TIME 50 /* 50 ms, if exists */
184#define DEF_MAX_DISCARD_ISSUE_TIME 60000 /* 60 s, if no candidates */
Jaegeuk Kim41059092018-05-29 09:58:42 -0700185#define DEF_DISCARD_URGENT_UTIL 80 /* do more discard over 80% */
Jaegeuk Kim60b99b42015-10-05 14:49:57 -0700186#define DEF_CP_INTERVAL 60 /* 60 secs */
Chao Yudcf25fe2016-07-15 19:25:47 +0800187#define DEF_IDLE_INTERVAL 5 /* 5 secs */
Jaegeuk Kimbba681c2015-01-26 17:41:23 -0800188
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700189struct cp_control {
190 int reason;
Jaegeuk Kim4b2fecc2014-09-20 22:06:39 -0700191 __u64 trim_start;
192 __u64 trim_end;
193 __u64 trim_minlen;
Jaegeuk Kim75ab4cb2014-09-20 21:57:51 -0700194};
195
Chao Yu662befd2014-02-07 16:11:53 +0800196/*
Chao Yu81c1a0f12014-02-27 19:12:24 +0800197 * For CP/NAT/SIT/SSA readahead
Chao Yu662befd2014-02-07 16:11:53 +0800198 */
199enum {
200 META_CP,
201 META_NAT,
Chao Yu81c1a0f12014-02-27 19:12:24 +0800202 META_SIT,
Jaegeuk Kim4c521f492014-09-11 13:49:55 -0700203 META_SSA,
204 META_POR,
Chao Yu662befd2014-02-07 16:11:53 +0800205};
206
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700207/* for the list of ino */
208enum {
209 ORPHAN_INO, /* for orphan ino list */
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700210 APPEND_INO, /* for append ino list */
211 UPDATE_INO, /* for update ino list */
Jaegeuk Kim211cb7b2017-12-28 08:09:44 -0800212 TRANS_DIR_INO, /* for trasactions dir ino list */
Chao Yuf014be82017-09-29 13:59:38 +0800213 FLUSH_INO, /* for multiple device flushing */
Jaegeuk Kim6451e042014-07-25 15:47:17 -0700214 MAX_INO_ENTRY, /* max. list */
215};
216
217struct ino_entry {
Chao Yuf014be82017-09-29 13:59:38 +0800218 struct list_head list; /* list head */
219 nid_t ino; /* inode number */
220 unsigned int dirty_device; /* dirty device bitmap */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900221};
222
Chao Yu2710fd72015-12-15 13:30:45 +0800223/* for the list of inodes to be GCed */
Chao Yu06292072014-12-29 15:56:18 +0800224struct inode_entry {
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900225 struct list_head list; /* list head */
226 struct inode *inode; /* vfs inode pointer */
227};
228
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700229/* for the bitmap indicate blocks to be discarded */
Jaegeuk Kim7fd9e542013-11-15 13:55:58 +0900230struct discard_entry {
231 struct list_head list; /* list head */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700232 block_t start_blkaddr; /* start blockaddr of current segment */
233 unsigned char discard_map[SIT_VBLOCK_MAP_SIZE]; /* segment discard bitmap */
Jaegeuk Kim7fd9e542013-11-15 13:55:58 +0900234};
235
Chao Yuefe24da2017-08-07 23:09:56 +0800236/* default discard granularity of inner discard thread, unit: block count */
237#define DEFAULT_DISCARD_GRANULARITY 16
238
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700239/* max discard pend list number */
240#define MAX_PLIST_NUM 512
241#define plist_idx(blk_num) ((blk_num) >= MAX_PLIST_NUM ? \
242 (MAX_PLIST_NUM - 1) : (blk_num - 1))
243
244enum {
245 D_PREP,
246 D_SUBMIT,
247 D_DONE,
248};
249
250struct discard_info {
251 block_t lstart; /* logical start address */
252 block_t len; /* length */
253 block_t start; /* actual start address in dev */
254};
255
256struct discard_cmd {
257 struct rb_node rb_node; /* rb node located in rb-tree */
258 union {
259 struct {
260 block_t lstart; /* logical start address */
261 block_t len; /* length */
262 block_t start; /* actual start address in dev */
263 };
264 struct discard_info di; /* discard info */
265
266 };
267 struct list_head list; /* command list */
268 struct completion wait; /* compleation */
269 struct block_device *bdev; /* bdev */
270 unsigned short ref; /* reference count */
271 unsigned char state; /* state */
272 int error; /* bio error */
273};
274
Chao Yudaf437d2017-10-04 09:08:34 +0800275enum {
276 DPOLICY_BG,
277 DPOLICY_FORCE,
278 DPOLICY_FSTRIM,
279 DPOLICY_UMOUNT,
280 MAX_DPOLICY,
281};
282
Chao Yu69a59672017-10-04 09:08:33 +0800283struct discard_policy {
Chao Yudaf437d2017-10-04 09:08:34 +0800284 int type; /* type of discard */
Chao Yu69a59672017-10-04 09:08:33 +0800285 unsigned int min_interval; /* used for candidates exist */
286 unsigned int max_interval; /* used for candidates not exist */
287 unsigned int max_requests; /* # of discards issued per round */
288 unsigned int io_aware_gran; /* minimum granularity discard not be aware of I/O */
289 bool io_aware; /* issue discard in idle time */
290 bool sync; /* submit discard with REQ_SYNC flag */
Chao Yudaf437d2017-10-04 09:08:34 +0800291 unsigned int granularity; /* discard granularity */
Chao Yu69a59672017-10-04 09:08:33 +0800292};
293
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700294struct discard_cmd_control {
295 struct task_struct *f2fs_issue_discard; /* discard thread */
296 struct list_head entry_list; /* 4KB discard entry list */
297 struct list_head pend_list[MAX_PLIST_NUM];/* store pending entries */
298 struct list_head wait_list; /* store on-flushing entries */
Chao Yu28e10232017-10-04 09:08:32 +0800299 struct list_head fstrim_list; /* in-flight discard from fstrim */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700300 wait_queue_head_t discard_wait_queue; /* waiting queue for wake-up */
Chao Yuefe24da2017-08-07 23:09:56 +0800301 unsigned int discard_wake; /* to wake up discard thread */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700302 struct mutex cmd_lock;
303 unsigned int nr_discards; /* # of discards in the list */
304 unsigned int max_discards; /* max. discards to be issued */
Chao Yuefe24da2017-08-07 23:09:56 +0800305 unsigned int discard_granularity; /* discard granularity */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700306 unsigned int undiscard_blks; /* # of undiscard blocks */
307 atomic_t issued_discard; /* # of issued discard */
308 atomic_t issing_discard; /* # of issing discard */
309 atomic_t discard_cmd_cnt; /* # of cached cmd count */
310 struct rb_root root; /* root of discard rb-tree */
Chao Yu275b66b2016-08-29 23:58:34 +0800311};
312
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900313/* for the list of fsync inodes, used only during recovery */
314struct fsync_inode_entry {
315 struct list_head list; /* list head */
316 struct inode *inode; /* vfs inode pointer */
Jaegeuk Kimc52e1b12014-09-11 14:29:06 -0700317 block_t blkaddr; /* block address locating the last fsync */
318 block_t last_dentry; /* block address locating the last dentry */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900319};
320
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700321#define nats_in_cursum(jnl) (le16_to_cpu((jnl)->n_nats))
322#define sits_in_cursum(jnl) (le16_to_cpu((jnl)->n_sits))
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900323
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700324#define nat_in_journal(jnl, i) ((jnl)->nat_j.entries[i].ne)
325#define nid_in_journal(jnl, i) ((jnl)->nat_j.entries[i].nid)
326#define sit_in_journal(jnl, i) ((jnl)->sit_j.entries[i].se)
327#define segno_in_journal(jnl, i) ((jnl)->sit_j.entries[i].segno)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900328
Chao Yudfc08a12016-02-14 18:50:40 +0800329#define MAX_NAT_JENTRIES(jnl) (NAT_JOURNAL_ENTRIES - nats_in_cursum(jnl))
330#define MAX_SIT_JENTRIES(jnl) (SIT_JOURNAL_ENTRIES - sits_in_cursum(jnl))
Jaegeuk Kim309cc2b2014-09-22 11:40:48 -0700331
Chao Yudfc08a12016-02-14 18:50:40 +0800332static inline int update_nats_in_cursum(struct f2fs_journal *journal, int i)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900333{
Chao Yudfc08a12016-02-14 18:50:40 +0800334 int before = nats_in_cursum(journal);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700335
Chao Yudfc08a12016-02-14 18:50:40 +0800336 journal->n_nats = cpu_to_le16(before + i);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900337 return before;
338}
339
Chao Yudfc08a12016-02-14 18:50:40 +0800340static inline int update_sits_in_cursum(struct f2fs_journal *journal, int i)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900341{
Chao Yudfc08a12016-02-14 18:50:40 +0800342 int before = sits_in_cursum(journal);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700343
Chao Yudfc08a12016-02-14 18:50:40 +0800344 journal->n_sits = cpu_to_le16(before + i);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900345 return before;
346}
347
Chao Yudfc08a12016-02-14 18:50:40 +0800348static inline bool __has_cursum_space(struct f2fs_journal *journal,
349 int size, int type)
Chao Yu184a5cd2014-09-04 18:13:01 +0800350{
351 if (type == NAT_JOURNAL)
Chao Yudfc08a12016-02-14 18:50:40 +0800352 return size <= MAX_NAT_JENTRIES(journal);
353 return size <= MAX_SIT_JENTRIES(journal);
Chao Yu184a5cd2014-09-04 18:13:01 +0800354}
355
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900356/*
Namjae Jeone9750822013-02-04 23:41:41 +0900357 * ioctl commands
358 */
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700359#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS
360#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS
Chao Yud49f3e82015-01-23 20:36:04 +0800361#define F2FS_IOC_GETVERSION FS_IOC_GETVERSION
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700362
363#define F2FS_IOCTL_MAGIC 0xf5
364#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1)
365#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2)
Jaegeuk Kim02a13352014-10-06 16:11:16 -0700366#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3)
Jaegeuk Kim1e843712014-12-09 06:08:59 -0800367#define F2FS_IOC_RELEASE_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 4)
368#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5)
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700369#define F2FS_IOC_GARBAGE_COLLECT _IOW(F2FS_IOCTL_MAGIC, 6, __u32)
Chao Yu456b88e2015-10-05 22:24:19 +0800370#define F2FS_IOC_WRITE_CHECKPOINT _IO(F2FS_IOCTL_MAGIC, 7)
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700371#define F2FS_IOC_DEFRAGMENT _IOWR(F2FS_IOCTL_MAGIC, 8, \
372 struct f2fs_defragment)
Jaegeuk Kim4dd6f972016-07-08 15:16:47 -0700373#define F2FS_IOC_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
374 struct f2fs_move_range)
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700375#define F2FS_IOC_FLUSH_DEVICE _IOW(F2FS_IOCTL_MAGIC, 10, \
376 struct f2fs_flush_device)
Jaegeuk Kim0bb53062017-06-15 16:44:42 -0700377#define F2FS_IOC_GARBAGE_COLLECT_RANGE _IOW(F2FS_IOCTL_MAGIC, 11, \
378 struct f2fs_gc_range)
Jaegeuk Kim82925bb2017-07-21 12:58:59 -0700379#define F2FS_IOC_GET_FEATURES _IOR(F2FS_IOCTL_MAGIC, 12, __u32)
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -0800380#define F2FS_IOC_SET_PIN_FILE _IOW(F2FS_IOCTL_MAGIC, 13, __u32)
381#define F2FS_IOC_GET_PIN_FILE _IOR(F2FS_IOCTL_MAGIC, 14, __u32)
Chao Yu6bce9632018-01-11 14:42:30 +0800382#define F2FS_IOC_PRECACHE_EXTENTS _IO(F2FS_IOCTL_MAGIC, 15)
Namjae Jeone9750822013-02-04 23:41:41 +0900383
Jaegeuk Kim0b81d072015-05-15 16:26:10 -0700384#define F2FS_IOC_SET_ENCRYPTION_POLICY FS_IOC_SET_ENCRYPTION_POLICY
385#define F2FS_IOC_GET_ENCRYPTION_POLICY FS_IOC_GET_ENCRYPTION_POLICY
386#define F2FS_IOC_GET_ENCRYPTION_PWSALT FS_IOC_GET_ENCRYPTION_PWSALT
Jaegeuk Kimf424f662015-04-20 15:19:06 -0700387
Jaegeuk Kim1abff932015-01-08 19:15:53 -0800388/*
389 * should be same as XFS_IOC_GOINGDOWN.
390 * Flags for going down operation used by FS_IOC_GOINGDOWN
391 */
392#define F2FS_IOC_SHUTDOWN _IOR('X', 125, __u32) /* Shutdown */
393#define F2FS_GOING_DOWN_FULLSYNC 0x0 /* going down with full sync */
394#define F2FS_GOING_DOWN_METASYNC 0x1 /* going down with metadata */
395#define F2FS_GOING_DOWN_NOSYNC 0x2 /* going down */
Jaegeuk Kimc912a822015-10-07 09:46:37 -0700396#define F2FS_GOING_DOWN_METAFLUSH 0x3 /* going down with meta flush */
Jaegeuk Kim1abff932015-01-08 19:15:53 -0800397
Namjae Jeone9750822013-02-04 23:41:41 +0900398#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
399/*
400 * ioctl commands in 32 bit emulation
401 */
Chao Yu04ef4b62015-11-10 18:44:20 +0800402#define F2FS_IOC32_GETFLAGS FS_IOC32_GETFLAGS
403#define F2FS_IOC32_SETFLAGS FS_IOC32_SETFLAGS
404#define F2FS_IOC32_GETVERSION FS_IOC32_GETVERSION
Namjae Jeone9750822013-02-04 23:41:41 +0900405#endif
406
Jaegeuk Kim0bb53062017-06-15 16:44:42 -0700407struct f2fs_gc_range {
408 u32 sync;
409 u64 start;
410 u64 len;
411};
412
Chao Yud323d002015-10-27 09:53:45 +0800413struct f2fs_defragment {
414 u64 start;
415 u64 len;
416};
417
Jaegeuk Kim4dd6f972016-07-08 15:16:47 -0700418struct f2fs_move_range {
419 u32 dst_fd; /* destination fd */
420 u64 pos_in; /* start position in src_fd */
421 u64 pos_out; /* start position in dst_fd */
422 u64 len; /* size to move */
423};
424
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700425struct f2fs_flush_device {
426 u32 dev_num; /* device number to flush */
427 u32 segments; /* # of segments to flush */
428};
429
Chao Yue84f88e2017-07-19 00:19:05 +0800430/* for inline stuff */
431#define DEF_INLINE_RESERVED_SIZE 1
Chao Yu50ffaa92017-09-06 21:59:50 +0800432#define DEF_MIN_INLINE_SIZE 1
Chao Yufbcf9312017-07-19 00:19:06 +0800433static inline int get_extra_isize(struct inode *inode);
Chao Yu50ffaa92017-09-06 21:59:50 +0800434static inline int get_inline_xattr_addrs(struct inode *inode);
Chao Yu50ffaa92017-09-06 21:59:50 +0800435#define MAX_INLINE_DATA(inode) (sizeof(__le32) * \
436 (CUR_ADDRS_PER_INODE(inode) - \
Chao Yu3aa46e22018-01-17 16:31:36 +0800437 get_inline_xattr_addrs(inode) - \
Chao Yu50ffaa92017-09-06 21:59:50 +0800438 DEF_INLINE_RESERVED_SIZE))
Chao Yue84f88e2017-07-19 00:19:05 +0800439
440/* for inline dir */
441#define NR_INLINE_DENTRY(inode) (MAX_INLINE_DATA(inode) * BITS_PER_BYTE / \
442 ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
443 BITS_PER_BYTE + 1))
444#define INLINE_DENTRY_BITMAP_SIZE(inode) ((NR_INLINE_DENTRY(inode) + \
445 BITS_PER_BYTE - 1) / BITS_PER_BYTE)
446#define INLINE_RESERVED_SIZE(inode) (MAX_INLINE_DATA(inode) - \
447 ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
448 NR_INLINE_DENTRY(inode) + \
449 INLINE_DENTRY_BITMAP_SIZE(inode)))
450
Namjae Jeone9750822013-02-04 23:41:41 +0900451/*
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900452 * For INODE and NODE manager
453 */
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700454/* for directory operations */
455struct f2fs_dentry_ptr {
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700456 struct inode *inode;
Chao Yub75c5f62017-07-16 15:08:54 +0800457 void *bitmap;
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700458 struct f2fs_dir_entry *dentry;
459 __u8 (*filename)[F2FS_SLOT_LEN];
460 int max;
Chao Yub75c5f62017-07-16 15:08:54 +0800461 int nr_bitmap;
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700462};
463
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700464static inline void make_dentry_ptr_block(struct inode *inode,
465 struct f2fs_dentry_ptr *d, struct f2fs_dentry_block *t)
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700466{
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700467 d->inode = inode;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700468 d->max = NR_DENTRY_IN_BLOCK;
Chao Yub75c5f62017-07-16 15:08:54 +0800469 d->nr_bitmap = SIZE_OF_DENTRY_BITMAP;
Yunlong Song270deeb2018-04-02 20:22:20 +0800470 d->bitmap = t->dentry_bitmap;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700471 d->dentry = t->dentry;
472 d->filename = t->filename;
473}
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700474
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700475static inline void make_dentry_ptr_inline(struct inode *inode,
Chao Yue84f88e2017-07-19 00:19:05 +0800476 struct f2fs_dentry_ptr *d, void *t)
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700477{
Chao Yue84f88e2017-07-19 00:19:05 +0800478 int entry_cnt = NR_INLINE_DENTRY(inode);
479 int bitmap_size = INLINE_DENTRY_BITMAP_SIZE(inode);
480 int reserved_size = INLINE_RESERVED_SIZE(inode);
481
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700482 d->inode = inode;
Chao Yue84f88e2017-07-19 00:19:05 +0800483 d->max = entry_cnt;
484 d->nr_bitmap = bitmap_size;
485 d->bitmap = t;
486 d->dentry = t + bitmap_size + reserved_size;
487 d->filename = t + bitmap_size + reserved_size +
488 SIZE_OF_DIR_ENTRY * entry_cnt;
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700489}
490
Jaegeuk Kimdbe6a5f2013-08-09 08:14:06 +0900491/*
492 * XATTR_NODE_OFFSET stores xattrs to one node block per file keeping -1
493 * as its node offset to distinguish from index node blocks.
494 * But some bits are used to mark the node block.
495 */
496#define XATTR_NODE_OFFSET ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
497 >> OFFSET_BIT_SHIFT)
Jaegeuk Kim266e97a2013-02-26 13:10:46 +0900498enum {
499 ALLOC_NODE, /* allocate a new node page if needed */
500 LOOKUP_NODE, /* look up a node without readahead */
501 LOOKUP_NODE_RA, /*
502 * look up a node with readahead called
Chao Yu4f4124d2013-12-21 18:02:14 +0800503 * by get_data_block.
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900504 */
Jaegeuk Kim266e97a2013-02-26 13:10:46 +0900505};
506
Jaegeuk Kima6db67f2015-08-10 15:01:12 -0700507#define F2FS_LINK_MAX 0xffffffff /* maximum link count per file */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900508
Chao Yu817202d92014-04-28 17:59:43 +0800509#define MAX_DIR_RA_PAGES 4 /* maximum ra pages of dir */
510
Chao Yu13054c52015-02-05 17:52:58 +0800511/* vector size for gang look-up from extent cache that consists of radix tree */
512#define EXT_TREE_VEC_SIZE 64
513
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900514/* for in-memory extent cache entry */
Chao Yu13054c52015-02-05 17:52:58 +0800515#define F2FS_MIN_EXTENT_LEN 64 /* minimum extent length */
516
517/* number of extent info in extent cache we try to shrink */
518#define EXTENT_CACHE_SHRINK_NUMBER 128
Jaegeuk Kimc11abd12013-11-19 10:41:54 +0900519
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700520struct rb_entry {
521 struct rb_node rb_node; /* rb node located in rb-tree */
522 unsigned int ofs; /* start offset of the entry */
523 unsigned int len; /* length of the entry */
524};
525
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900526struct extent_info {
Chao Yu13054c52015-02-05 17:52:58 +0800527 unsigned int fofs; /* start offset in a file */
Chao Yu13054c52015-02-05 17:52:58 +0800528 unsigned int len; /* length of the extent */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700529 u32 blk; /* start block address of the extent */
Chao Yu13054c52015-02-05 17:52:58 +0800530};
531
532struct extent_node {
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700533 struct rb_node rb_node;
534 union {
535 struct {
536 unsigned int fofs;
537 unsigned int len;
538 u32 blk;
539 };
540 struct extent_info ei; /* extent info */
541
542 };
Chao Yu13054c52015-02-05 17:52:58 +0800543 struct list_head list; /* node in global extent list of sbi */
Hou Pengyang201ef5e2016-01-26 12:56:26 +0000544 struct extent_tree *et; /* extent tree pointer */
Chao Yu13054c52015-02-05 17:52:58 +0800545};
546
547struct extent_tree {
548 nid_t ino; /* inode number */
549 struct rb_root root; /* root of extent info rb-tree */
Chao Yu62c8af62015-02-05 18:01:39 +0800550 struct extent_node *cached_en; /* recently accessed extent node */
Jaegeuk Kim3e72f722015-06-19 17:53:26 -0700551 struct extent_info largest; /* largested extent info */
Jaegeuk Kim137d09f2015-12-31 15:02:16 -0800552 struct list_head list; /* to be used by sbi->zombie_list */
Chao Yu13054c52015-02-05 17:52:58 +0800553 rwlock_t lock; /* protect extent info rb-tree */
Chao Yu68e35382016-01-08 20:22:52 +0800554 atomic_t node_cnt; /* # of extent node in rb-tree*/
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900555};
556
557/*
Jaegeuk Kim003a3e12015-04-06 19:55:34 -0700558 * This structure is taken from ext4_map_blocks.
559 *
560 * Note that, however, f2fs uses NEW and MAPPED flags for f2fs_map_blocks().
561 */
562#define F2FS_MAP_NEW (1 << BH_New)
563#define F2FS_MAP_MAPPED (1 << BH_Mapped)
Jaegeuk Kim7f63eb72015-05-08 19:30:32 -0700564#define F2FS_MAP_UNWRITTEN (1 << BH_Unwritten)
565#define F2FS_MAP_FLAGS (F2FS_MAP_NEW | F2FS_MAP_MAPPED |\
566 F2FS_MAP_UNWRITTEN)
Jaegeuk Kim003a3e12015-04-06 19:55:34 -0700567
568struct f2fs_map_blocks {
569 block_t m_pblk;
570 block_t m_lblk;
571 unsigned int m_len;
572 unsigned int m_flags;
Chao Yuda859852016-01-26 15:42:58 +0800573 pgoff_t *m_next_pgofs; /* point next possible non-hole pgofs */
Chao Yu6bce9632018-01-11 14:42:30 +0800574 pgoff_t *m_next_extent; /* point to next possible extent */
Hyunchul Lee1a9d6a92017-11-28 09:23:00 +0900575 int m_seg_type;
Jaegeuk Kim003a3e12015-04-06 19:55:34 -0700576};
577
Chao Yue2b4e2b2015-08-19 19:11:19 +0800578/* for flag in get_data_block */
Qiuyang Sun9afa1592017-08-09 17:27:30 +0800579enum {
580 F2FS_GET_BLOCK_DEFAULT,
581 F2FS_GET_BLOCK_FIEMAP,
582 F2FS_GET_BLOCK_BMAP,
583 F2FS_GET_BLOCK_PRE_DIO,
584 F2FS_GET_BLOCK_PRE_AIO,
Chao Yu6bce9632018-01-11 14:42:30 +0800585 F2FS_GET_BLOCK_PRECACHE,
Qiuyang Sun9afa1592017-08-09 17:27:30 +0800586};
Chao Yue2b4e2b2015-08-19 19:11:19 +0800587
Jaegeuk Kim003a3e12015-04-06 19:55:34 -0700588/*
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900589 * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
590 */
591#define FADVISE_COLD_BIT 0x01
Jaegeuk Kim354a3392013-06-14 08:52:35 +0900592#define FADVISE_LOST_PINO_BIT 0x02
Jaegeuk Kimcde4de12015-04-20 13:57:51 -0700593#define FADVISE_ENCRYPT_BIT 0x04
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700594#define FADVISE_ENC_NAME_BIT 0x08
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700595#define FADVISE_KEEP_SIZE_BIT 0x10
Chao Yuac734c42018-02-28 17:07:27 +0800596#define FADVISE_HOT_BIT 0x20
Eric Biggers29cead52018-03-28 11:15:09 -0700597#define FADVISE_VERITY_BIT 0x40 /* reserved */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900598
Jaegeuk Kimb5492af72015-04-20 13:44:41 -0700599#define file_is_cold(inode) is_file(inode, FADVISE_COLD_BIT)
600#define file_wrong_pino(inode) is_file(inode, FADVISE_LOST_PINO_BIT)
601#define file_set_cold(inode) set_file(inode, FADVISE_COLD_BIT)
602#define file_lost_pino(inode) set_file(inode, FADVISE_LOST_PINO_BIT)
603#define file_clear_cold(inode) clear_file(inode, FADVISE_COLD_BIT)
604#define file_got_pino(inode) clear_file(inode, FADVISE_LOST_PINO_BIT)
Jaegeuk Kimcde4de12015-04-20 13:57:51 -0700605#define file_is_encrypt(inode) is_file(inode, FADVISE_ENCRYPT_BIT)
606#define file_set_encrypt(inode) set_file(inode, FADVISE_ENCRYPT_BIT)
607#define file_clear_encrypt(inode) clear_file(inode, FADVISE_ENCRYPT_BIT)
Jaegeuk Kime7d55452015-04-29 17:02:18 -0700608#define file_enc_name(inode) is_file(inode, FADVISE_ENC_NAME_BIT)
609#define file_set_enc_name(inode) set_file(inode, FADVISE_ENC_NAME_BIT)
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700610#define file_keep_isize(inode) is_file(inode, FADVISE_KEEP_SIZE_BIT)
611#define file_set_keep_isize(inode) set_file(inode, FADVISE_KEEP_SIZE_BIT)
Chao Yuac734c42018-02-28 17:07:27 +0800612#define file_is_hot(inode) is_file(inode, FADVISE_HOT_BIT)
613#define file_set_hot(inode) set_file(inode, FADVISE_HOT_BIT)
614#define file_clear_hot(inode) clear_file(inode, FADVISE_HOT_BIT)
Jaegeuk Kimcde4de12015-04-20 13:57:51 -0700615
Jaegeuk Kimab9fa662014-02-27 20:09:05 +0900616#define DEF_DIR_LEVEL 0
617
Chao Yucaf10c62018-05-07 20:28:54 +0800618enum {
619 GC_FAILURE_PIN,
620 GC_FAILURE_ATOMIC,
621 MAX_GC_FAILURE
622};
623
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900624struct f2fs_inode_info {
625 struct inode vfs_inode; /* serve a vfs inode */
626 unsigned long i_flags; /* keep an inode flags for ioctl */
627 unsigned char i_advise; /* use to give file attribute hints */
Jaegeuk Kim38431542014-02-27 18:20:00 +0900628 unsigned char i_dir_level; /* use for dentry level for large dir */
Chao Yucaf10c62018-05-07 20:28:54 +0800629 unsigned int i_current_depth; /* only for directory depth */
630 /* for gc failure statistic */
631 unsigned int i_gc_failures[MAX_GC_FAILURE];
Jaegeuk Kim6666e6a2012-12-10 17:52:48 +0900632 unsigned int i_pino; /* parent inode number */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900633 umode_t i_acl_mode; /* keep file acl mode temporarily */
634
635 /* Use below internally in f2fs*/
636 unsigned long flags; /* use to pass per-file flags */
Jaegeuk Kimd928bfb2014-03-20 19:10:08 +0900637 struct rw_semaphore i_sem; /* protect fi info */
Jaegeuk Kima43e1c42016-12-02 15:11:32 -0800638 atomic_t dirty_pages; /* # of dirty pages */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900639 f2fs_hash_t chash; /* hash value of given file name */
640 unsigned int clevel; /* maximum level of given file name */
Jaegeuk Kimd00d1b72017-02-14 09:54:37 -0800641 struct task_struct *task; /* lookup and create consistency */
Chao Yuc0fe4882017-08-02 23:21:48 +0800642 struct task_struct *cp_task; /* separate cp/wb IO stats*/
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900643 nid_t i_xattr_nid; /* node id that contains xattrs */
Jaegeuk Kim26de9b12016-05-20 20:42:37 -0700644 loff_t last_disk_size; /* lastly written file size */
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700645
Chao Yu09c3a722017-07-09 00:13:07 +0800646#ifdef CONFIG_QUOTA
647 struct dquot *i_dquot[MAXQUOTAS];
648
649 /* quota space reservation, managed internally by quota code */
650 qsize_t i_reserved_quota;
651#endif
Jaegeuk Kim0f18b462016-05-20 11:10:10 -0700652 struct list_head dirty_list; /* dirty list for dirs and files */
653 struct list_head gdirty_list; /* linked in global dirty list */
Jaegeuk Kim35e13ca2017-10-18 19:05:57 -0700654 struct list_head inmem_ilist; /* list for inmem inodes */
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700655 struct list_head inmem_pages; /* inmemory pages managed by f2fs */
Jaegeuk Kima778c4c2017-07-24 19:46:29 -0700656 struct task_struct *inmem_task; /* store inmemory task */
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700657 struct mutex inmem_lock; /* lock for inmemory pages */
Jaegeuk Kim3e72f722015-06-19 17:53:26 -0700658 struct extent_tree *extent_tree; /* cached extent_tree entry */
Chao Yuf6bd7d42018-04-24 10:55:28 +0800659
660 /* avoid racing between foreground op and gc */
661 struct rw_semaphore i_gc_rwsem[2];
Qiuyang Sun7b23ea12017-05-18 11:06:45 +0800662 struct rw_semaphore i_mmap_sem;
Yunlei He5dd3add2017-09-07 10:40:54 +0800663 struct rw_semaphore i_xattr_sem; /* avoid racing between reading and changing EAs */
Chao Yue84f88e2017-07-19 00:19:05 +0800664
Chao Yufbcf9312017-07-19 00:19:06 +0800665 int i_extra_isize; /* size of extra space located in i_addr */
Chao Yu5647b302017-07-26 00:01:41 +0800666 kprojid_t i_projid; /* id for project quota */
Chao Yu50ffaa92017-09-06 21:59:50 +0800667 int i_inline_xattr_size; /* inline xattr size */
Chao Yu71f8f042018-01-25 14:54:42 +0800668 struct timespec i_crtime; /* inode creation time */
Jaegeuk Kimac389af2018-03-29 22:50:41 -0700669 struct timespec i_disk_time[4]; /* inode disk times */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900670};
671
672static inline void get_extent_info(struct extent_info *ext,
Chao Yubd933d42016-05-04 23:19:47 +0800673 struct f2fs_extent *i_ext)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900674{
Chao Yubd933d42016-05-04 23:19:47 +0800675 ext->fofs = le32_to_cpu(i_ext->fofs);
676 ext->blk = le32_to_cpu(i_ext->blk);
677 ext->len = le32_to_cpu(i_ext->len);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900678}
679
680static inline void set_raw_extent(struct extent_info *ext,
681 struct f2fs_extent *i_ext)
682{
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900683 i_ext->fofs = cpu_to_le32(ext->fofs);
Chao Yu4d0b0bd2015-02-05 17:47:25 +0800684 i_ext->blk = cpu_to_le32(ext->blk);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900685 i_ext->len = cpu_to_le32(ext->len);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900686}
687
Chao Yu429511c2015-02-05 17:54:31 +0800688static inline void set_extent_info(struct extent_info *ei, unsigned int fofs,
689 u32 blk, unsigned int len)
690{
691 ei->fofs = fofs;
692 ei->blk = blk;
693 ei->len = len;
694}
695
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700696static inline bool __is_discard_mergeable(struct discard_info *back,
697 struct discard_info *front)
Chao Yu0bdee482015-03-19 19:27:51 +0800698{
Jaegeuk Kim8f6a2e72018-05-24 13:57:26 -0700699 return (back->lstart + back->len == front->lstart) &&
700 (back->len + front->len < DEF_MAX_DISCARD_LEN);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700701}
702
703static inline bool __is_discard_back_mergeable(struct discard_info *cur,
704 struct discard_info *back)
705{
706 return __is_discard_mergeable(back, cur);
707}
708
709static inline bool __is_discard_front_mergeable(struct discard_info *cur,
710 struct discard_info *front)
711{
712 return __is_discard_mergeable(cur, front);
Chao Yu0bdee482015-03-19 19:27:51 +0800713}
714
Chao Yu429511c2015-02-05 17:54:31 +0800715static inline bool __is_extent_mergeable(struct extent_info *back,
716 struct extent_info *front)
717{
718 return (back->fofs + back->len == front->fofs &&
719 back->blk + back->len == front->blk);
720}
721
722static inline bool __is_back_mergeable(struct extent_info *cur,
723 struct extent_info *back)
724{
725 return __is_extent_mergeable(back, cur);
726}
727
728static inline bool __is_front_mergeable(struct extent_info *cur,
729 struct extent_info *front)
730{
731 return __is_extent_mergeable(cur, front);
732}
733
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700734extern void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync);
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700735static inline void __try_update_largest_extent(struct inode *inode,
736 struct extent_tree *et, struct extent_node *en)
Chao Yu4abd3f52015-09-22 21:07:47 +0800737{
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700738 if (en->ei.len > et->largest.len) {
Chao Yu4abd3f52015-09-22 21:07:47 +0800739 et->largest = en->ei;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700740 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700741 }
Chao Yu4abd3f52015-09-22 21:07:47 +0800742}
743
Chao Yu84af6ae2017-09-29 13:59:35 +0800744/*
745 * For free nid management
746 */
747enum nid_state {
748 FREE_NID, /* newly added to free nid list */
749 PREALLOC_NID, /* it is preallocated */
750 MAX_NID_STATE,
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700751};
752
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900753struct f2fs_nm_info {
754 block_t nat_blkaddr; /* base disk address of NAT */
755 nid_t max_nid; /* maximum possible node ids */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700756 nid_t available_nids; /* # of available node ids */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900757 nid_t next_scan_nid; /* the next nid to be scanned */
Jaegeuk Kimcdfc41c2014-03-19 13:31:37 +0900758 unsigned int ram_thresh; /* control the memory footprint */
Chao Yuea1a29a02015-10-12 17:08:48 +0800759 unsigned int ra_nid_pages; /* # of nid pages to be readaheaded */
Chao Yu2304cb02016-01-18 18:32:58 +0800760 unsigned int dirty_nats_ratio; /* control dirty nats ratio threshold */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900761
762 /* NAT cache management */
763 struct radix_tree_root nat_root;/* root of the nat entry cache */
Jaegeuk Kim309cc2b2014-09-22 11:40:48 -0700764 struct radix_tree_root nat_set_root;/* root of the nat set cache */
Jaegeuk Kimb873b792016-08-04 11:38:25 -0700765 struct rw_semaphore nat_tree_lock; /* protect nat_tree_lock */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900766 struct list_head nat_entries; /* cached nat entry list (clean) */
Jaegeuk Kim309cc2b2014-09-22 11:40:48 -0700767 unsigned int nat_cnt; /* the # of cached nat entries */
Chao Yuaec71382014-06-24 09:18:20 +0800768 unsigned int dirty_nat_cnt; /* total num of nat entries in set */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700769 unsigned int nat_blocks; /* # of nat blocks */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900770
771 /* free node ids management */
Jaegeuk Kim8a7ed662014-02-21 14:29:35 +0900772 struct radix_tree_root free_nid_root;/* root of the free_nid cache */
Chao Yu84af6ae2017-09-29 13:59:35 +0800773 struct list_head free_nid_list; /* list for free nids excluding preallocated nids */
774 unsigned int nid_cnt[MAX_NID_STATE]; /* the number of free node id */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700775 spinlock_t nid_list_lock; /* protect nid lists ops */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900776 struct mutex build_lock; /* lock for build free nids */
Jaegeuk Kim9f1896c2018-03-09 17:42:28 -0800777 unsigned char **free_nid_bitmap;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700778 unsigned char *nat_block_bitmap;
779 unsigned short *free_nid_count; /* free nid count of NAT block */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900780
781 /* for checkpoint */
782 char *nat_bitmap; /* NAT bitmap pointer */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700783
784 unsigned int nat_bits_blocks; /* # of nat bits blocks */
785 unsigned char *nat_bits; /* NAT bits blocks */
786 unsigned char *full_nat_bits; /* full NAT pages */
787 unsigned char *empty_nat_bits; /* empty NAT pages */
788#ifdef CONFIG_F2FS_CHECK_FS
789 char *nat_bitmap_mir; /* NAT bitmap mirror */
790#endif
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900791 int bitmap_size; /* bitmap size */
792};
793
794/*
795 * this structure is used as one of function parameters.
796 * all the information are dedicated to a given direct node block determined
797 * by the data offset in a file.
798 */
799struct dnode_of_data {
800 struct inode *inode; /* vfs inode pointer */
801 struct page *inode_page; /* its inode page, NULL is possible */
802 struct page *node_page; /* cached direct node page */
803 nid_t nid; /* node id of the direct node block */
804 unsigned int ofs_in_node; /* data offset in the node page */
805 bool inode_page_locked; /* inode page is locked or not */
Jaegeuk Kim93bae092015-12-22 12:59:54 -0800806 bool node_changed; /* is node block changed */
Chao Yu3cf45742016-01-26 15:40:44 +0800807 char cur_level; /* level of hole node page */
808 char max_level; /* level of current page located */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900809 block_t data_blkaddr; /* block address of the node block */
810};
811
812static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
813 struct page *ipage, struct page *npage, nid_t nid)
814{
Jaegeuk Kimd66d1f72013-01-03 08:57:21 +0900815 memset(dn, 0, sizeof(*dn));
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900816 dn->inode = inode;
817 dn->inode_page = ipage;
818 dn->node_page = npage;
819 dn->nid = nid;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900820}
821
822/*
823 * For SIT manager
824 *
825 * By default, there are 6 active log areas across the whole main area.
826 * When considering hot and cold data separation to reduce cleaning overhead,
827 * we split 3 for data logs and 3 for node logs as hot, warm, and cold types,
828 * respectively.
829 * In the current design, you should not change the numbers intentionally.
830 * Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6
831 * logs individually according to the underlying devices. (default: 6)
832 * Just in case, on-disk layout covers maximum 16 logs that consist of 8 for
833 * data and 8 for node logs.
834 */
835#define NR_CURSEG_DATA_TYPE (3)
836#define NR_CURSEG_NODE_TYPE (3)
837#define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
838
839enum {
840 CURSEG_HOT_DATA = 0, /* directory entry blocks */
841 CURSEG_WARM_DATA, /* data blocks */
842 CURSEG_COLD_DATA, /* multimedia or GCed data blocks */
843 CURSEG_HOT_NODE, /* direct node blocks of directory files */
844 CURSEG_WARM_NODE, /* direct node blocks of normal files */
845 CURSEG_COLD_NODE, /* indirect node blocks */
Jaegeuk Kim38aa0882015-01-05 16:02:20 -0800846 NO_CHECK_TYPE,
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900847};
848
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900849struct flush_cmd {
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900850 struct completion wait;
Gu Zheng721bd4d2014-09-05 18:31:00 +0800851 struct llist_node llnode;
Chao Yuf014be82017-09-29 13:59:38 +0800852 nid_t ino;
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900853 int ret;
854};
855
Gu Zhenga688b9d9e2014-04-27 14:21:21 +0800856struct flush_cmd_control {
857 struct task_struct *f2fs_issue_flush; /* flush thread */
858 wait_queue_head_t flush_wait_queue; /* waiting queue for wake-up */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700859 atomic_t issued_flush; /* # of issued flushes */
860 atomic_t issing_flush; /* # of issing flushes */
Gu Zheng721bd4d2014-09-05 18:31:00 +0800861 struct llist_head issue_list; /* list for command issue */
862 struct llist_node *dispatch_list; /* list for command dispatch */
Gu Zhenga688b9d9e2014-04-27 14:21:21 +0800863};
864
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900865struct f2fs_sm_info {
866 struct sit_info *sit_info; /* whole segment information */
867 struct free_segmap_info *free_info; /* free segment information */
868 struct dirty_seglist_info *dirty_info; /* dirty segment information */
869 struct curseg_info *curseg_array; /* active segment information */
870
Chao Yu7f41aab2017-11-02 20:41:03 +0800871 struct rw_semaphore curseg_lock; /* for preventing curseg change */
872
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900873 block_t seg0_blkaddr; /* block address of 0'th segment */
874 block_t main_blkaddr; /* start block address of main area */
875 block_t ssa_blkaddr; /* start block address of SSA area */
876
877 unsigned int segment_count; /* total # of segments */
878 unsigned int main_segments; /* # of segments in main area */
879 unsigned int reserved_segments; /* # of reserved segments */
880 unsigned int ovp_segments; /* # of overprovision segments */
Jaegeuk Kim81eb8d62013-10-24 13:31:34 +0900881
882 /* a threshold to reclaim prefree segments */
883 unsigned int rec_prefree_segments;
Jaegeuk Kim7fd9e542013-11-15 13:55:58 +0900884
Jaegeuk Kimbba681c2015-01-26 17:41:23 -0800885 /* for batched trimming */
886 unsigned int trim_sections; /* # of sections to trim */
887
Chao Yu184a5cd2014-09-04 18:13:01 +0800888 struct list_head sit_entry_set; /* sit entry set list */
889
Jaegeuk Kim216fbd62013-11-07 13:13:42 +0900890 unsigned int ipu_policy; /* in-place-update policy */
891 unsigned int min_ipu_util; /* in-place-update threshold */
Jaegeuk Kimc1ce1b02014-09-10 16:53:02 -0700892 unsigned int min_fsync_blocks; /* threshold for fsync */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700893 unsigned int min_hot_blocks; /* threshold for hot block allocation */
Chao Yub9f73872017-10-28 16:52:33 +0800894 unsigned int min_ssr_sections; /* threshold to trigger SSR allocation */
Jaegeuk Kim6b4afdd2014-04-02 15:34:36 +0900895
896 /* for flush command control */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700897 struct flush_cmd_control *fcc_info;
Gu Zhenga688b9d9e2014-04-27 14:21:21 +0800898
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700899 /* for discard command control */
900 struct discard_cmd_control *dcc_info;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900901};
902
903/*
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900904 * For superblock
905 */
906/*
907 * COUNT_TYPE for monitoring
908 *
909 * f2fs monitors the number of several block types such as on-writeback,
910 * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
911 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700912#define WB_DATA_TYPE(p) (__is_cp_guaranteed(p) ? F2FS_WB_CP_DATA : F2FS_WB_DATA)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900913enum count_type {
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900914 F2FS_DIRTY_DENTS,
Chao Yuc227f912015-12-16 13:09:20 +0800915 F2FS_DIRTY_DATA,
Jaegeuk Kim931ecc22017-11-13 17:46:38 -0800916 F2FS_DIRTY_QDATA,
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900917 F2FS_DIRTY_NODES,
918 F2FS_DIRTY_META,
Jaegeuk Kim8dcf2ff72014-12-05 17:18:15 -0800919 F2FS_INMEM_PAGES,
Jaegeuk Kim0f18b462016-05-20 11:10:10 -0700920 F2FS_DIRTY_IMETA,
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700921 F2FS_WB_CP_DATA,
922 F2FS_WB_DATA,
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900923 NR_COUNT_TYPE,
924};
925
926/*
arter97e1c42042014-08-06 23:22:50 +0900927 * The below are the page types of bios used in submit_bio().
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900928 * The available types are:
929 * DATA User data pages. It operates as async mode.
930 * NODE Node pages. It operates as async mode.
931 * META FS metadata pages such as SIT, NAT, CP.
932 * NR_PAGE_TYPE The number of page types.
933 * META_FLUSH Make sure the previous pages are written
934 * with waiting the bio's completion
935 * ... Only can be used with META.
936 */
Jaegeuk Kim7d5e5102013-11-18 17:13:35 +0900937#define PAGE_TYPE_OF_BIO(type) ((type) > META ? META : (type))
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900938enum page_type {
939 DATA,
940 NODE,
941 META,
942 NR_PAGE_TYPE,
943 META_FLUSH,
Jaegeuk Kim8ce67cb2015-03-17 17:58:08 -0700944 INMEM, /* the below types are used by tracepoints only. */
945 INMEM_DROP,
Jaegeuk Kime6b120d2017-07-10 12:55:09 -0700946 INMEM_INVALIDATE,
Chao Yu28bc1062016-02-06 14:40:34 +0800947 INMEM_REVOKE,
Jaegeuk Kim8ce67cb2015-03-17 17:58:08 -0700948 IPU,
949 OPU,
Jaegeuk Kim39a53e02012-11-28 13:37:31 +0900950};
951
Jaegeuk Kimc4127262017-05-10 11:18:25 -0700952enum temp_type {
953 HOT = 0, /* must be zero for meta bio */
954 WARM,
955 COLD,
956 NR_TEMP_TYPE,
957};
958
Jaegeuk Kim1b48ed62017-05-12 13:51:34 -0700959enum need_lock_type {
960 LOCK_REQ = 0,
961 LOCK_DONE,
962 LOCK_RETRY,
963};
964
Chao Yud75eb8d2017-11-06 22:51:45 +0800965enum cp_reason_type {
966 CP_NO_NEEDED,
967 CP_NON_REGULAR,
968 CP_HARDLINK,
969 CP_SB_NEED_CP,
970 CP_WRONG_PINO,
971 CP_NO_SPC_ROLL,
972 CP_NODE_NEED_CP,
973 CP_FASTBOOT_MODE,
974 CP_SPEC_LOG_NUM,
Jaegeuk Kim211cb7b2017-12-28 08:09:44 -0800975 CP_RECOVER_DIR,
Chao Yud75eb8d2017-11-06 22:51:45 +0800976};
977
Chao Yuc0fe4882017-08-02 23:21:48 +0800978enum iostat_type {
979 APP_DIRECT_IO, /* app direct IOs */
980 APP_BUFFERED_IO, /* app buffered IOs */
981 APP_WRITE_IO, /* app write IOs */
982 APP_MAPPED_IO, /* app mapped IOs */
983 FS_DATA_IO, /* data IOs from kworker/fsync/reclaimer */
984 FS_NODE_IO, /* node IOs from kworker/fsync/reclaimer */
985 FS_META_IO, /* meta IOs from kworker/reclaimer */
986 FS_GC_DATA_IO, /* data IOs from forground gc */
987 FS_GC_NODE_IO, /* node IOs from forground gc */
988 FS_CP_DATA_IO, /* data IOs from checkpoint */
989 FS_CP_NODE_IO, /* node IOs from checkpoint */
990 FS_CP_META_IO, /* meta IOs from checkpoint */
991 FS_DISCARD, /* discard */
992 NR_IO_TYPE,
993};
994
Jaegeuk Kim458e6192013-12-11 13:54:01 +0900995struct f2fs_io_info {
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700996 struct f2fs_sb_info *sbi; /* f2fs_sb_info pointer */
Chao Yuf014be82017-09-29 13:59:38 +0800997 nid_t ino; /* inode number */
Gu Zheng7e8f2302013-12-20 18:17:49 +0800998 enum page_type type; /* contains DATA/NODE/META/META_FLUSH */
Jaegeuk Kimc4127262017-05-10 11:18:25 -0700999 enum temp_type temp; /* contains HOT/WARM/COLD */
Mike Christie04d328d2016-06-05 14:31:55 -05001000 int op; /* contains REQ_OP_ */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001001 int op_flags; /* req_flag_bits */
Chao Yu7a9d7542016-02-22 18:36:38 +08001002 block_t new_blkaddr; /* new block address to be written */
Chao Yu28bc1062016-02-06 14:40:34 +08001003 block_t old_blkaddr; /* old block address before Cow */
Jaegeuk Kim05ca3632015-04-23 14:38:15 -07001004 struct page *page; /* page to be written */
Jaegeuk Kim4375a332015-04-23 12:04:33 -07001005 struct page *encrypted_page; /* encrypted page */
Chao Yuc52dc0f2017-05-19 23:37:01 +08001006 struct list_head list; /* serialize IOs */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001007 bool submitted; /* indicate IO submission */
Jaegeuk Kim1b48ed62017-05-12 13:51:34 -07001008 int need_lock; /* indicate we need to lock cp_rwsem */
Chao Yuc52dc0f2017-05-19 23:37:01 +08001009 bool in_list; /* indicate fio is in io_list */
Yunlei Hea3f8ec82018-03-08 16:29:13 +08001010 bool is_meta; /* indicate borrow meta inode mapping or not */
Chao Yuc0fe4882017-08-02 23:21:48 +08001011 enum iostat_type io_type; /* io type */
Yufen Yucbd5e5a2018-01-09 19:33:39 +08001012 struct writeback_control *io_wbc; /* writeback control */
Jaegeuk Kim458e6192013-12-11 13:54:01 +09001013};
1014
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001015#define is_read_io(rw) ((rw) == READ)
Jaegeuk Kim1ff7bd32013-11-19 12:47:22 +09001016struct f2fs_bio_info {
Jaegeuk Kim458e6192013-12-11 13:54:01 +09001017 struct f2fs_sb_info *sbi; /* f2fs superblock */
Jaegeuk Kim1ff7bd32013-11-19 12:47:22 +09001018 struct bio *bio; /* bios to merge */
1019 sector_t last_block_in_bio; /* last block number */
Jaegeuk Kim458e6192013-12-11 13:54:01 +09001020 struct f2fs_io_info fio; /* store buffered io info. */
Chao Yudf0f8dc2014-03-22 14:57:23 +08001021 struct rw_semaphore io_rwsem; /* blocking op for bio */
Chao Yuc52dc0f2017-05-19 23:37:01 +08001022 spinlock_t io_lock; /* serialize DATA/NODE IOs */
1023 struct list_head io_list; /* track fios */
Jaegeuk Kim1ff7bd32013-11-19 12:47:22 +09001024};
1025
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001026#define FDEV(i) (sbi->devs[i])
1027#define RDEV(i) (raw_super->devs[i])
1028struct f2fs_dev_info {
1029 struct block_device *bdev;
1030 char path[MAX_PATH_LEN];
1031 unsigned int total_segments;
1032 block_t start_blk;
1033 block_t end_blk;
1034#ifdef CONFIG_BLK_DEV_ZONED
1035 unsigned int nr_blkz; /* Total number of zones */
1036 u8 *blkz_type; /* Array of zones type */
1037#endif
1038};
1039
Chao Yuc227f912015-12-16 13:09:20 +08001040enum inode_type {
1041 DIR_INODE, /* for dirty dir inode */
1042 FILE_INODE, /* for dirty regular/symlink inode */
Jaegeuk Kim0f18b462016-05-20 11:10:10 -07001043 DIRTY_META, /* for all dirtied inode metadata */
Jaegeuk Kim35e13ca2017-10-18 19:05:57 -07001044 ATOMIC_FILE, /* for all atomic files */
Chao Yuc227f912015-12-16 13:09:20 +08001045 NR_INODE_TYPE,
1046};
1047
Chao Yu67298802014-11-18 11:18:36 +08001048/* for inner inode cache management */
1049struct inode_management {
1050 struct radix_tree_root ino_root; /* ino entry array */
1051 spinlock_t ino_lock; /* for ino entry lock */
1052 struct list_head ino_list; /* inode list head */
1053 unsigned long ino_num; /* number of entries */
1054};
1055
Chao Yucaf00472015-01-28 17:48:42 +08001056/* For s_flag in struct f2fs_sb_info */
1057enum {
1058 SBI_IS_DIRTY, /* dirty flag for checkpoint */
1059 SBI_IS_CLOSE, /* specify unmounting */
1060 SBI_NEED_FSCK, /* need fsck.f2fs to fix */
1061 SBI_POR_DOING, /* recovery is doing or not */
Jaegeuk Kimdf728b02016-03-23 17:05:27 -07001062 SBI_NEED_SB_WRITE, /* need to recover superblock */
Jaegeuk Kimbbf156f2016-08-29 18:23:45 -07001063 SBI_NEED_CP, /* need to checkpoint */
Chao Yucaf00472015-01-28 17:48:42 +08001064};
1065
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08001066enum {
1067 CP_TIME,
Jaegeuk Kimd0239e12016-01-08 16:57:48 -08001068 REQ_TIME,
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08001069 MAX_TIME,
1070};
1071
Hyunchul Leebcdc5712018-01-31 11:36:57 +09001072enum {
Jaegeuk Kim0390d832018-05-07 14:22:40 -07001073 GC_NORMAL,
1074 GC_IDLE_CB,
1075 GC_IDLE_GREEDY,
1076 GC_URGENT,
1077};
1078
1079enum {
Hyunchul Leebcdc5712018-01-31 11:36:57 +09001080 WHINT_MODE_OFF, /* not pass down write hints */
1081 WHINT_MODE_USER, /* try to pass down hints given by users */
Hyunchul Lee87c18062018-01-31 11:36:58 +09001082 WHINT_MODE_FS, /* pass down hints with F2FS policy */
Hyunchul Leebcdc5712018-01-31 11:36:57 +09001083};
1084
Jaegeuk Kim78c1fc22018-02-18 08:50:49 -08001085enum {
1086 ALLOC_MODE_DEFAULT, /* stay default */
1087 ALLOC_MODE_REUSE, /* reuse segments as much as possible */
1088};
1089
Junling Zheng9a954812018-03-07 12:07:49 +08001090enum fsync_mode {
1091 FSYNC_MODE_POSIX, /* fsync follows posix semantics */
1092 FSYNC_MODE_STRICT, /* fsync behaves in line with ext4 */
Jaegeuk Kim3a38cf12018-05-25 18:02:58 -07001093 FSYNC_MODE_NOBARRIER, /* fsync behaves nobarrier based on posix */
Junling Zheng9a954812018-03-07 12:07:49 +08001094};
1095
Sheng Yongaa5bcfd2018-03-15 18:51:42 +08001096#ifdef CONFIG_F2FS_FS_ENCRYPTION
1097#define DUMMY_ENCRYPTION_ENABLED(sbi) \
1098 (unlikely(F2FS_OPTION(sbi).test_dummy_encryption))
1099#else
1100#define DUMMY_ENCRYPTION_ENABLED(sbi) (0)
1101#endif
1102
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001103struct f2fs_sb_info {
1104 struct super_block *sb; /* pointer to VFS super block */
Jaegeuk Kim5e176d52013-06-28 12:47:01 +09001105 struct proc_dir_entry *s_proc; /* proc entry */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001106 struct f2fs_super_block *raw_super; /* raw super block pointer */
Chao Yu1e72cb22018-02-26 22:04:13 +08001107 struct rw_semaphore sb_lock; /* lock for raw super block */
Chao Yue8240f62015-12-15 17:19:26 +08001108 int valid_super_block; /* valid super block no */
Chao Yufadb2fb2016-09-20 10:29:47 +08001109 unsigned long s_flag; /* flags for sbi */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001110
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001111#ifdef CONFIG_BLK_DEV_ZONED
1112 unsigned int blocks_per_blkz; /* F2FS blocks per zone */
1113 unsigned int log_blocks_per_blkz; /* log2 F2FS blocks per zone */
Jaegeuk Kimb5a7aef2016-05-04 22:05:01 -07001114#endif
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001115
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001116 /* for node-related operations */
1117 struct f2fs_nm_info *nm_info; /* node manager */
1118 struct inode *node_inode; /* cache node blocks */
1119
1120 /* for segment-related operations */
1121 struct f2fs_sm_info *sm_info; /* segment manager */
Jaegeuk Kim1ff7bd32013-11-19 12:47:22 +09001122
1123 /* for bio operations */
Jaegeuk Kimc4127262017-05-10 11:18:25 -07001124 struct f2fs_bio_info *write_io[NR_PAGE_TYPE]; /* for write bios */
Chao Yu06504682017-05-19 23:37:00 +08001125 struct mutex wio_mutex[NR_PAGE_TYPE - 1][NR_TEMP_TYPE];
1126 /* bio ordering for NODE/DATA */
Chao Yubbab2dc2018-05-26 09:00:13 +08001127 /* keep migration IO order for LFS mode */
1128 struct rw_semaphore io_order_lock;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001129 mempool_t *write_io_dummy; /* Dummy pages */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001130
1131 /* for checkpoint */
1132 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */
Jaegeuk Kim01e15b32016-11-24 12:45:15 -08001133 int cur_cp_pack; /* remain current cp pack */
Chao Yuaaec2b12016-09-20 11:04:18 +08001134 spinlock_t cp_lock; /* for flag in ckpt */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001135 struct inode *meta_inode; /* cache meta blocks */
Jaegeuk Kim39936832012-11-22 16:21:29 +09001136 struct mutex cp_mutex; /* checkpoint procedure lock */
Jaegeuk Kimb873b792016-08-04 11:38:25 -07001137 struct rw_semaphore cp_rwsem; /* blocking FS operations */
Chao Yub3582c62014-07-03 18:58:39 +08001138 struct rw_semaphore node_write; /* locking node writes */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001139 struct rw_semaphore node_change; /* locking node change */
Changman Leefb51b5e2013-11-07 12:48:25 +09001140 wait_queue_head_t cp_wait;
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08001141 unsigned long last_time[MAX_TIME]; /* to store time in jiffies */
1142 long interval_time[MAX_TIME]; /* to store thresholds */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001143
Chao Yu67298802014-11-18 11:18:36 +08001144 struct inode_management im[MAX_INO_ENTRY]; /* manage inode cache */
Jaegeuk Kim6451e042014-07-25 15:47:17 -07001145
1146 /* for orphan inode, use 0'th array */
Gu Zheng0d47c1a2013-12-26 18:24:19 +08001147 unsigned int max_orphans; /* max orphan inodes */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001148
Chao Yuc227f912015-12-16 13:09:20 +08001149 /* for inode management */
1150 struct list_head inode_list[NR_INODE_TYPE]; /* dirty inode list */
1151 spinlock_t inode_lock[NR_INODE_TYPE]; /* for dirty inode list lock */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001152
Chao Yu13054c52015-02-05 17:52:58 +08001153 /* for extent tree cache */
1154 struct radix_tree_root extent_tree_root;/* cache extent cache entries */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001155 struct mutex extent_tree_lock; /* locking extent radix tree */
Chao Yu13054c52015-02-05 17:52:58 +08001156 struct list_head extent_list; /* lru list for shrinker */
1157 spinlock_t extent_lock; /* locking extent lru list */
Jaegeuk Kim7441cce2015-12-21 19:20:15 -08001158 atomic_t total_ext_tree; /* extent tree count */
Jaegeuk Kim137d09f2015-12-31 15:02:16 -08001159 struct list_head zombie_list; /* extent zombie tree list */
Jaegeuk Kim74fd8d92015-12-21 19:25:50 -08001160 atomic_t total_zombie_tree; /* extent zombie tree count */
Chao Yu13054c52015-02-05 17:52:58 +08001161 atomic_t total_ext_node; /* extent info count */
1162
arter97e1c42042014-08-06 23:22:50 +09001163 /* basic filesystem units */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001164 unsigned int log_sectors_per_block; /* log2 sectors per block */
1165 unsigned int log_blocksize; /* log2 block size */
1166 unsigned int blocksize; /* block size */
1167 unsigned int root_ino_num; /* root inode number*/
1168 unsigned int node_ino_num; /* node inode number*/
1169 unsigned int meta_ino_num; /* meta inode number*/
1170 unsigned int log_blocks_per_seg; /* log2 blocks per segment */
1171 unsigned int blocks_per_seg; /* blocks per segment */
1172 unsigned int segs_per_sec; /* segments per section */
1173 unsigned int secs_per_zone; /* sections per zone */
1174 unsigned int total_sections; /* total section count */
1175 unsigned int total_node_count; /* total node block count */
1176 unsigned int total_valid_node_count; /* valid node block count */
Chao Yue0afc4d2015-12-31 14:35:37 +08001177 loff_t max_file_blocks; /* max block index of file */
Jaegeuk Kimab9fa662014-02-27 20:09:05 +09001178 int dir_level; /* directory level */
Chao Yub9f73872017-10-28 16:52:33 +08001179 unsigned int trigger_ssr_threshold; /* threshold to trigger ssr */
Sheng Yong1ed75332017-11-22 18:23:38 +08001180 int readdir_ra; /* readahead inode in readdir */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001181
1182 block_t user_block_count; /* # of user blocks */
1183 block_t total_valid_block_count; /* # of valid blocks */
Jaegeuk Kima66cdd92015-04-30 22:37:50 -07001184 block_t discard_blks; /* discard command candidats */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001185 block_t last_valid_block_count; /* for recovery */
Chao Yu026bd9d2017-06-26 16:24:41 +08001186 block_t reserved_blocks; /* configurable reserved blocks */
Yunlong Song68ab6f82017-10-27 20:45:05 +08001187 block_t current_reserved_blocks; /* current reserved blocks */
Chao Yu026bd9d2017-06-26 16:24:41 +08001188
Chao Yu09234be2017-11-16 16:59:14 +08001189 unsigned int nquota_files; /* # of quota sysfile */
1190
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001191 u32 s_next_generation; /* for NFS support */
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001192
1193 /* # of pages, see count_type */
Jaegeuk Kim725ba1a2016-10-20 19:09:57 -07001194 atomic_t nr_pages[NR_COUNT_TYPE];
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07001195 /* # of allocated blocks */
1196 struct percpu_counter alloc_valid_block_count;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001197
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001198 /* writeback control */
1199 atomic_t wb_sync_req; /* count # of WB_SYNC threads */
1200
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07001201 /* valid inode count */
1202 struct percpu_counter total_valid_inode_count;
1203
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001204 struct f2fs_mount_info mount_opt; /* mount options */
1205
1206 /* for cleaning operations */
1207 struct mutex gc_mutex; /* mutex for GC */
1208 struct f2fs_gc_kthread *gc_thread; /* GC thread */
Jaegeuk Kim5ec4e492013-03-31 13:26:03 +09001209 unsigned int cur_victim_sec; /* current victim section num */
Jaegeuk Kim0390d832018-05-07 14:22:40 -07001210 unsigned int gc_mode; /* current GC state */
Chao Yucaf10c62018-05-07 20:28:54 +08001211 /* for skip statistic */
1212 unsigned long long skipped_atomic_files[2]; /* FG_GC and BG_GC */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001213
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08001214 /* threshold for gc trials on pinned files */
1215 u64 gc_pin_file_threshold;
1216
Jaegeuk Kimb1c57c12014-01-08 13:45:08 +09001217 /* maximum # of trials to find a victim segment for SSR and GC */
1218 unsigned int max_victim_search;
1219
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001220 /*
1221 * for stat information.
1222 * one is for the LFS mode, and the other is for the SSR mode.
1223 */
Namjae Jeon35b09d82013-05-23 22:57:53 +09001224#ifdef CONFIG_F2FS_STAT_FS
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001225 struct f2fs_stat_info *stat_info; /* FS status information */
1226 unsigned int segment_count[2]; /* # of allocated segments */
1227 unsigned int block_count[2]; /* # of allocated blocks */
Changman Leeb9a2c252014-12-24 02:16:54 +09001228 atomic_t inplace_count; /* # of inplace update */
Chao Yu5b7ee372015-09-30 17:38:48 +08001229 atomic64_t total_hit_ext; /* # of lookup extent cache */
1230 atomic64_t read_hit_rbtree; /* # of hit rbtree extent node */
1231 atomic64_t read_hit_largest; /* # of hit largest extent node */
1232 atomic64_t read_hit_cached; /* # of hit cached extent node */
Chao Yud5e8f6c2015-07-15 17:28:53 +08001233 atomic_t inline_xattr; /* # of inline_xattr inodes */
Chao Yu03e14d52014-12-08 19:08:20 +08001234 atomic_t inline_inode; /* # of inline_data inodes */
1235 atomic_t inline_dir; /* # of inline_dentry inodes */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001236 atomic_t aw_cnt; /* # of atomic writes */
1237 atomic_t vw_cnt; /* # of volatile writes */
1238 atomic_t max_aw_cnt; /* max # of atomic writes */
1239 atomic_t max_vw_cnt; /* max # of volatile writes */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001240 int bg_gc; /* background gc calls */
Chao Yu33fbd512015-12-17 17:14:44 +08001241 unsigned int ndirty_inode[NR_INODE_TYPE]; /* # of dirty inodes */
Namjae Jeon35b09d82013-05-23 22:57:53 +09001242#endif
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001243 spinlock_t stat_lock; /* lock for stat operations */
Namjae Jeonb59d0ba2013-08-04 23:09:40 +09001244
Chao Yuc0fe4882017-08-02 23:21:48 +08001245 /* For app/fs IO statistics */
1246 spinlock_t iostat_lock;
1247 unsigned long long write_iostat[NR_IO_TYPE];
1248 bool iostat_enable;
1249
Namjae Jeonb59d0ba2013-08-04 23:09:40 +09001250 /* For sysfs suppport */
1251 struct kobject s_kobj;
1252 struct completion s_kobj_unregister;
Jaegeuk Kim2658e502015-06-19 12:01:21 -07001253
1254 /* For shrinker support */
1255 struct list_head s_list;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001256 int s_ndevs; /* number of devices */
1257 struct f2fs_dev_info *devs; /* for device list */
Chao Yufd6422e2017-09-29 13:59:39 +08001258 unsigned int dirty_device; /* for checkpoint data flush */
1259 spinlock_t dev_lock; /* protect dirty_device */
Jaegeuk Kim2658e502015-06-19 12:01:21 -07001260 struct mutex umount_mutex;
1261 unsigned int shrinker_run_no;
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001262
1263 /* For write statistics */
1264 u64 sectors_written_start;
1265 u64 kbytes_written;
Keith Mok43b65732016-03-02 12:04:24 -08001266
1267 /* Reference to checksum algorithm driver via cryptoapi */
1268 struct crypto_shash *s_chksum_driver;
Chao Yu1ecc0c52016-09-23 21:30:09 +08001269
Chao Yu43101252017-07-31 20:19:09 +08001270 /* Precomputed FS UUID checksum for seeding other checksums */
1271 __u32 s_chksum_seed;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001272};
1273
Chao Yu1ecc0c52016-09-23 21:30:09 +08001274#ifdef CONFIG_F2FS_FAULT_INJECTION
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001275#define f2fs_show_injection_info(type) \
1276 printk("%sF2FS-fs : inject %s in %s of %pF\n", \
1277 KERN_INFO, fault_name[type], \
1278 __func__, __builtin_return_address(0))
Chao Yu1ecc0c52016-09-23 21:30:09 +08001279static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
1280{
Chao Yue9a50e62018-03-08 14:22:56 +08001281 struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;
Chao Yu1ecc0c52016-09-23 21:30:09 +08001282
1283 if (!ffi->inject_rate)
1284 return false;
1285
1286 if (!IS_FAULT_SET(ffi, type))
1287 return false;
1288
1289 atomic_inc(&ffi->inject_ops);
1290 if (atomic_read(&ffi->inject_ops) >= ffi->inject_rate) {
1291 atomic_set(&ffi->inject_ops, 0);
Chao Yu1ecc0c52016-09-23 21:30:09 +08001292 return true;
1293 }
1294 return false;
1295}
1296#endif
1297
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001298/* For write statistics. Suppose sector size is 512 bytes,
1299 * and the return value is in kbytes. s is of struct f2fs_sb_info.
1300 */
1301#define BD_PART_WRITTEN(s) \
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001302(((u64)part_stat_read((s)->sb->s_bdev->bd_part, sectors[1]) - \
1303 (s)->sectors_written_start) >> 1)
Shuoran Liu8f1dbbb2016-01-27 09:57:30 +08001304
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08001305static inline void f2fs_update_time(struct f2fs_sb_info *sbi, int type)
1306{
1307 sbi->last_time[type] = jiffies;
1308}
1309
1310static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)
1311{
Arnd Bergmannbf823c82017-10-19 11:52:47 +02001312 unsigned long interval = sbi->interval_time[type] * HZ;
Jaegeuk Kim6beceb52016-01-08 15:51:50 -08001313
1314 return time_after(jiffies, sbi->last_time[type] + interval);
1315}
1316
Jaegeuk Kimd0239e12016-01-08 16:57:48 -08001317static inline bool is_idle(struct f2fs_sb_info *sbi)
1318{
1319 struct block_device *bdev = sbi->sb->s_bdev;
1320 struct request_queue *q = bdev_get_queue(bdev);
1321 struct request_list *rl = &q->root_rl;
1322
1323 if (rl->count[BLK_RW_SYNC] || rl->count[BLK_RW_ASYNC])
1324 return 0;
1325
1326 return f2fs_time_over(sbi, REQ_TIME);
1327}
1328
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001329/*
1330 * Inline functions
1331 */
Chao Yud7714cb2017-11-30 19:28:21 +08001332static inline u32 __f2fs_crc32(struct f2fs_sb_info *sbi, u32 crc,
Chao Yu43101252017-07-31 20:19:09 +08001333 const void *address, unsigned int length)
1334{
1335 struct {
1336 struct shash_desc shash;
1337 char ctx[4];
1338 } desc;
1339 int err;
1340
1341 BUG_ON(crypto_shash_descsize(sbi->s_chksum_driver) != sizeof(desc.ctx));
1342
1343 desc.shash.tfm = sbi->s_chksum_driver;
1344 desc.shash.flags = 0;
1345 *(u32 *)desc.ctx = crc;
1346
1347 err = crypto_shash_update(&desc.shash, address, length);
1348 BUG_ON(err);
1349
1350 return *(u32 *)desc.ctx;
1351}
1352
Chao Yud7714cb2017-11-30 19:28:21 +08001353static inline u32 f2fs_crc32(struct f2fs_sb_info *sbi, const void *address,
1354 unsigned int length)
1355{
1356 return __f2fs_crc32(sbi, F2FS_SUPER_MAGIC, address, length);
1357}
1358
1359static inline bool f2fs_crc_valid(struct f2fs_sb_info *sbi, __u32 blk_crc,
1360 void *buf, size_t buf_size)
1361{
1362 return f2fs_crc32(sbi, buf, buf_size) == blk_crc;
1363}
1364
1365static inline u32 f2fs_chksum(struct f2fs_sb_info *sbi, u32 crc,
1366 const void *address, unsigned int length)
1367{
1368 return __f2fs_crc32(sbi, crc, address, length);
1369}
1370
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001371static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
1372{
1373 return container_of(inode, struct f2fs_inode_info, vfs_inode);
1374}
1375
1376static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
1377{
1378 return sb->s_fs_info;
1379}
1380
Jaegeuk Kim40813632014-09-02 15:31:18 -07001381static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)
1382{
1383 return F2FS_SB(inode->i_sb);
1384}
1385
1386static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping)
1387{
1388 return F2FS_I_SB(mapping->host);
1389}
1390
1391static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page)
1392{
1393 return F2FS_M_SB(page->mapping);
1394}
1395
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001396static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
1397{
1398 return (struct f2fs_super_block *)(sbi->raw_super);
1399}
1400
1401static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
1402{
1403 return (struct f2fs_checkpoint *)(sbi->ckpt);
1404}
1405
Gu Zheng45590712013-07-15 17:57:38 +08001406static inline struct f2fs_node *F2FS_NODE(struct page *page)
1407{
1408 return (struct f2fs_node *)page_address(page);
1409}
1410
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +09001411static inline struct f2fs_inode *F2FS_INODE(struct page *page)
1412{
1413 return &((struct f2fs_node *)page_address(page))->i;
1414}
1415
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001416static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
1417{
1418 return (struct f2fs_nm_info *)(sbi->nm_info);
1419}
1420
1421static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
1422{
1423 return (struct f2fs_sm_info *)(sbi->sm_info);
1424}
1425
1426static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
1427{
1428 return (struct sit_info *)(SM_I(sbi)->sit_info);
1429}
1430
1431static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
1432{
1433 return (struct free_segmap_info *)(SM_I(sbi)->free_info);
1434}
1435
1436static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
1437{
1438 return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
1439}
1440
Gu Zheng9df27d92014-01-20 18:37:04 +08001441static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
1442{
1443 return sbi->meta_inode->i_mapping;
1444}
1445
Jaegeuk Kim4ef51a82014-01-21 18:51:16 +09001446static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
1447{
1448 return sbi->node_inode->i_mapping;
1449}
1450
Chao Yucaf00472015-01-28 17:48:42 +08001451static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001452{
Chao Yufadb2fb2016-09-20 10:29:47 +08001453 return test_bit(type, &sbi->s_flag);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001454}
1455
Chao Yucaf00472015-01-28 17:48:42 +08001456static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001457{
Chao Yufadb2fb2016-09-20 10:29:47 +08001458 set_bit(type, &sbi->s_flag);
Chao Yucaf00472015-01-28 17:48:42 +08001459}
1460
1461static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
1462{
Chao Yufadb2fb2016-09-20 10:29:47 +08001463 clear_bit(type, &sbi->s_flag);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001464}
1465
Jaegeuk Kimd71b5562013-08-09 15:03:21 +09001466static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
1467{
1468 return le64_to_cpu(cp->checkpoint_ver);
1469}
1470
Jaegeuk Kim0108c482017-10-06 09:14:28 -07001471static inline unsigned long f2fs_qf_ino(struct super_block *sb, int type)
1472{
1473 if (type < F2FS_MAX_QUOTAS)
1474 return le32_to_cpu(F2FS_SB(sb)->raw_super->qf_ino[type]);
1475 return 0;
1476}
1477
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001478static inline __u64 cur_cp_crc(struct f2fs_checkpoint *cp)
1479{
1480 size_t crc_offset = le32_to_cpu(cp->checksum_offset);
1481 return le32_to_cpu(*((__le32 *)((unsigned char *)cp + crc_offset)));
1482}
1483
Chao Yuaaec2b12016-09-20 11:04:18 +08001484static inline bool __is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
Jaegeuk Kim25ca9232012-11-28 16:12:41 +09001485{
1486 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
Chao Yuaaec2b12016-09-20 11:04:18 +08001487
Jaegeuk Kim25ca9232012-11-28 16:12:41 +09001488 return ckpt_flags & f;
1489}
1490
Chao Yuaaec2b12016-09-20 11:04:18 +08001491static inline bool is_set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
Jaegeuk Kim25ca9232012-11-28 16:12:41 +09001492{
Chao Yuaaec2b12016-09-20 11:04:18 +08001493 return __is_set_ckpt_flags(F2FS_CKPT(sbi), f);
1494}
1495
1496static inline void __set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1497{
1498 unsigned int ckpt_flags;
1499
1500 ckpt_flags = le32_to_cpu(cp->ckpt_flags);
Jaegeuk Kim25ca9232012-11-28 16:12:41 +09001501 ckpt_flags |= f;
1502 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
1503}
1504
Chao Yuaaec2b12016-09-20 11:04:18 +08001505static inline void set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
Jaegeuk Kim25ca9232012-11-28 16:12:41 +09001506{
Chao Yu67295cd2017-07-07 14:10:15 +08001507 unsigned long flags;
1508
1509 spin_lock_irqsave(&sbi->cp_lock, flags);
Chao Yuaaec2b12016-09-20 11:04:18 +08001510 __set_ckpt_flags(F2FS_CKPT(sbi), f);
Chao Yu67295cd2017-07-07 14:10:15 +08001511 spin_unlock_irqrestore(&sbi->cp_lock, flags);
Chao Yuaaec2b12016-09-20 11:04:18 +08001512}
1513
1514static inline void __clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1515{
1516 unsigned int ckpt_flags;
1517
1518 ckpt_flags = le32_to_cpu(cp->ckpt_flags);
Jaegeuk Kim25ca9232012-11-28 16:12:41 +09001519 ckpt_flags &= (~f);
1520 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
1521}
1522
Chao Yuaaec2b12016-09-20 11:04:18 +08001523static inline void clear_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
1524{
Chao Yu67295cd2017-07-07 14:10:15 +08001525 unsigned long flags;
1526
1527 spin_lock_irqsave(&sbi->cp_lock, flags);
Chao Yuaaec2b12016-09-20 11:04:18 +08001528 __clear_ckpt_flags(F2FS_CKPT(sbi), f);
Chao Yu67295cd2017-07-07 14:10:15 +08001529 spin_unlock_irqrestore(&sbi->cp_lock, flags);
Chao Yuaaec2b12016-09-20 11:04:18 +08001530}
1531
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001532static inline void disable_nat_bits(struct f2fs_sb_info *sbi, bool lock)
Jaegeuk Kim3e025742016-08-02 10:56:40 -07001533{
Chao Yu67295cd2017-07-07 14:10:15 +08001534 unsigned long flags;
1535
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001536 set_sbi_flag(sbi, SBI_NEED_FSCK);
Jaegeuk Kim3e025742016-08-02 10:56:40 -07001537
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001538 if (lock)
Chao Yu67295cd2017-07-07 14:10:15 +08001539 spin_lock_irqsave(&sbi->cp_lock, flags);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001540 __clear_ckpt_flags(F2FS_CKPT(sbi), CP_NAT_BITS_FLAG);
1541 kfree(NM_I(sbi)->nat_bits);
1542 NM_I(sbi)->nat_bits = NULL;
1543 if (lock)
Chao Yu67295cd2017-07-07 14:10:15 +08001544 spin_unlock_irqrestore(&sbi->cp_lock, flags);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001545}
1546
1547static inline bool enabled_nat_bits(struct f2fs_sb_info *sbi,
1548 struct cp_control *cpc)
1549{
1550 bool set = is_set_ckpt_flags(sbi, CP_NAT_BITS_FLAG);
1551
1552 return (cpc) ? (cpc->reason & CP_UMOUNT) && set : set;
Jaegeuk Kim3e025742016-08-02 10:56:40 -07001553}
1554
Gu Zhenge4795562013-09-27 18:08:30 +08001555static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001556{
Jaegeuk Kimb873b792016-08-04 11:38:25 -07001557 down_read(&sbi->cp_rwsem);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001558}
1559
Jaegeuk Kim1b48ed62017-05-12 13:51:34 -07001560static inline int f2fs_trylock_op(struct f2fs_sb_info *sbi)
1561{
1562 return down_read_trylock(&sbi->cp_rwsem);
1563}
1564
Gu Zhenge4795562013-09-27 18:08:30 +08001565static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001566{
Jaegeuk Kimb873b792016-08-04 11:38:25 -07001567 up_read(&sbi->cp_rwsem);
Jaegeuk Kim39936832012-11-22 16:21:29 +09001568}
1569
Gu Zhenge4795562013-09-27 18:08:30 +08001570static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
Jaegeuk Kim39936832012-11-22 16:21:29 +09001571{
Jaegeuk Kimb873b792016-08-04 11:38:25 -07001572 down_write(&sbi->cp_rwsem);
Jaegeuk Kim39936832012-11-22 16:21:29 +09001573}
1574
Gu Zhenge4795562013-09-27 18:08:30 +08001575static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
Jaegeuk Kim39936832012-11-22 16:21:29 +09001576{
Jaegeuk Kimb873b792016-08-04 11:38:25 -07001577 up_write(&sbi->cp_rwsem);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001578}
1579
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001580static inline int __get_cp_reason(struct f2fs_sb_info *sbi)
1581{
1582 int reason = CP_SYNC;
1583
1584 if (test_opt(sbi, FASTBOOT))
1585 reason = CP_FASTBOOT;
1586 if (is_sbi_flag_set(sbi, SBI_IS_CLOSE))
1587 reason = CP_UMOUNT;
1588 return reason;
1589}
1590
1591static inline bool __remain_node_summaries(int reason)
1592{
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001593 return (reason & (CP_UMOUNT | CP_FASTBOOT));
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001594}
1595
1596static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)
1597{
Chao Yuaaec2b12016-09-20 11:04:18 +08001598 return (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG) ||
1599 is_set_ckpt_flags(sbi, CP_FASTBOOT_FLAG));
Jaegeuk Kim119ee912015-01-29 11:45:33 -08001600}
1601
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001602/*
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001603 * Check whether the inode has blocks or not
1604 */
1605static inline int F2FS_HAS_BLOCKS(struct inode *inode)
1606{
Chao Yu56a0d932017-06-14 23:00:56 +08001607 block_t xattr_block = F2FS_I(inode)->i_xattr_nid ? 1 : 0;
1608
Chao Yud9bfbbb2017-07-06 01:11:31 +08001609 return (inode->i_blocks >> F2FS_LOG_SECTORS_PER_BLOCK) > xattr_block;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001610}
1611
Chao Yu4bc8e9b2014-03-17 16:35:06 +08001612static inline bool f2fs_has_xattr_block(unsigned int ofs)
1613{
1614 return ofs == XATTR_NODE_OFFSET;
1615}
1616
Jaegeuk Kim4be98c92018-01-05 16:02:36 -08001617static inline bool __allow_reserved_blocks(struct f2fs_sb_info *sbi,
Jaegeuk Kimc8fb2452018-04-20 23:44:59 -07001618 struct inode *inode, bool cap)
Jaegeuk Kim462d7622018-01-04 21:36:09 -08001619{
Jaegeuk Kim4be98c92018-01-05 16:02:36 -08001620 if (!inode)
1621 return true;
Jaegeuk Kim462d7622018-01-04 21:36:09 -08001622 if (!test_opt(sbi, RESERVE_ROOT))
1623 return false;
Jaegeuk Kim4be98c92018-01-05 16:02:36 -08001624 if (IS_NOQUOTA(inode))
1625 return true;
Chao Yue9a50e62018-03-08 14:22:56 +08001626 if (uid_eq(F2FS_OPTION(sbi).s_resuid, current_fsuid()))
Jaegeuk Kim462d7622018-01-04 21:36:09 -08001627 return true;
Chao Yue9a50e62018-03-08 14:22:56 +08001628 if (!gid_eq(F2FS_OPTION(sbi).s_resgid, GLOBAL_ROOT_GID) &&
1629 in_group_p(F2FS_OPTION(sbi).s_resgid))
Jaegeuk Kim462d7622018-01-04 21:36:09 -08001630 return true;
Jaegeuk Kimc8fb2452018-04-20 23:44:59 -07001631 if (cap && capable(CAP_SYS_RESOURCE))
Jaegeuk Kimc07478e2018-03-08 20:47:33 -08001632 return true;
Jaegeuk Kim462d7622018-01-04 21:36:09 -08001633 return false;
1634}
1635
Chao Yu09c3a722017-07-09 00:13:07 +08001636static inline void f2fs_i_blocks_write(struct inode *, block_t, bool, bool);
1637static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,
Chao Yu46008c62016-05-09 19:56:30 +08001638 struct inode *inode, blkcnt_t *count)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001639{
Chao Yu09c3a722017-07-09 00:13:07 +08001640 blkcnt_t diff = 0, release = 0;
Chao Yu026bd9d2017-06-26 16:24:41 +08001641 block_t avail_user_block_count;
Chao Yu09c3a722017-07-09 00:13:07 +08001642 int ret;
1643
1644 ret = dquot_reserve_block(inode, *count);
1645 if (ret)
1646 return ret;
Jaegeuk Kimdd11a5d2016-07-19 19:20:11 -07001647
Jaegeuk Kimcb789422016-04-29 16:29:22 -07001648#ifdef CONFIG_F2FS_FAULT_INJECTION
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001649 if (time_to_inject(sbi, FAULT_BLOCK)) {
1650 f2fs_show_injection_info(FAULT_BLOCK);
Chao Yu09c3a722017-07-09 00:13:07 +08001651 release = *count;
1652 goto enospc;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001653 }
Jaegeuk Kimcb789422016-04-29 16:29:22 -07001654#endif
Jaegeuk Kimdd11a5d2016-07-19 19:20:11 -07001655 /*
1656 * let's increase this in prior to actual block count change in order
1657 * for f2fs_sync_file to avoid data races when deciding checkpoint.
1658 */
1659 percpu_counter_add(&sbi->alloc_valid_block_count, (*count));
Chao Yucfb271d2013-12-05 17:15:22 +08001660
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001661 spin_lock(&sbi->stat_lock);
Jaegeuk Kim2555a2d2016-06-30 19:02:06 -07001662 sbi->total_valid_block_count += (block_t)(*count);
Yunlong Song68ab6f82017-10-27 20:45:05 +08001663 avail_user_block_count = sbi->user_block_count -
1664 sbi->current_reserved_blocks;
Jaegeuk Kim5fee5402017-12-27 15:05:52 -08001665
Jaegeuk Kimc8fb2452018-04-20 23:44:59 -07001666 if (!__allow_reserved_blocks(sbi, inode, true))
Chao Yue9a50e62018-03-08 14:22:56 +08001667 avail_user_block_count -= F2FS_OPTION(sbi).root_reserved_blocks;
Jaegeuk Kim5fee5402017-12-27 15:05:52 -08001668
Chao Yu026bd9d2017-06-26 16:24:41 +08001669 if (unlikely(sbi->total_valid_block_count > avail_user_block_count)) {
1670 diff = sbi->total_valid_block_count - avail_user_block_count;
Jaegeuk Kim5fee5402017-12-27 15:05:52 -08001671 if (diff > *count)
1672 diff = *count;
Jaegeuk Kimdd11a5d2016-07-19 19:20:11 -07001673 *count -= diff;
Chao Yu09c3a722017-07-09 00:13:07 +08001674 release = diff;
Jaegeuk Kim5fee5402017-12-27 15:05:52 -08001675 sbi->total_valid_block_count -= diff;
Chao Yu46008c62016-05-09 19:56:30 +08001676 if (!*count) {
1677 spin_unlock(&sbi->stat_lock);
Jaegeuk Kimdd11a5d2016-07-19 19:20:11 -07001678 percpu_counter_sub(&sbi->alloc_valid_block_count, diff);
Chao Yu09c3a722017-07-09 00:13:07 +08001679 goto enospc;
Chao Yu46008c62016-05-09 19:56:30 +08001680 }
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001681 }
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001682 spin_unlock(&sbi->stat_lock);
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07001683
LiFanfdd41a82017-12-05 16:38:01 +08001684 if (unlikely(release))
Chao Yu09c3a722017-07-09 00:13:07 +08001685 dquot_release_reservation_block(inode, release);
1686 f2fs_i_blocks_write(inode, *count, true, true);
1687 return 0;
1688
1689enospc:
1690 dquot_release_reservation_block(inode, release);
1691 return -ENOSPC;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001692}
1693
Gu Zhengda19b0d2013-11-19 18:03:27 +08001694static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001695 struct inode *inode,
Chao Yu56a0d932017-06-14 23:00:56 +08001696 block_t count)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001697{
Chao Yu56a0d932017-06-14 23:00:56 +08001698 blkcnt_t sectors = count << F2FS_LOG_SECTORS_PER_BLOCK;
1699
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001700 spin_lock(&sbi->stat_lock);
Jaegeuk Kim9850cf42014-09-02 15:52:58 -07001701 f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
Chao Yu56a0d932017-06-14 23:00:56 +08001702 f2fs_bug_on(sbi, inode->i_blocks < sectors);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001703 sbi->total_valid_block_count -= (block_t)count;
Yunlong Song68ab6f82017-10-27 20:45:05 +08001704 if (sbi->reserved_blocks &&
1705 sbi->current_reserved_blocks < sbi->reserved_blocks)
1706 sbi->current_reserved_blocks = min(sbi->reserved_blocks,
1707 sbi->current_reserved_blocks + count);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001708 spin_unlock(&sbi->stat_lock);
Chao Yu09c3a722017-07-09 00:13:07 +08001709 f2fs_i_blocks_write(inode, count, false, true);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001710}
1711
1712static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
1713{
Jaegeuk Kim725ba1a2016-10-20 19:09:57 -07001714 atomic_inc(&sbi->nr_pages[count_type]);
Chao Yu7c4abcb2016-08-18 17:46:14 +08001715
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001716 if (count_type == F2FS_DIRTY_DATA || count_type == F2FS_INMEM_PAGES ||
1717 count_type == F2FS_WB_CP_DATA || count_type == F2FS_WB_DATA)
Chao Yu7c4abcb2016-08-18 17:46:14 +08001718 return;
1719
Chao Yucaf00472015-01-28 17:48:42 +08001720 set_sbi_flag(sbi, SBI_IS_DIRTY);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001721}
1722
Jaegeuk Kima7ffdbe2014-09-12 15:53:45 -07001723static inline void inode_inc_dirty_pages(struct inode *inode)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001724{
Jaegeuk Kima43e1c42016-12-02 15:11:32 -08001725 atomic_inc(&F2FS_I(inode)->dirty_pages);
Chao Yuc227f912015-12-16 13:09:20 +08001726 inc_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
1727 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
Jaegeuk Kim931ecc22017-11-13 17:46:38 -08001728 if (IS_NOQUOTA(inode))
1729 inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001730}
1731
1732static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
1733{
Jaegeuk Kim725ba1a2016-10-20 19:09:57 -07001734 atomic_dec(&sbi->nr_pages[count_type]);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001735}
1736
Jaegeuk Kima7ffdbe2014-09-12 15:53:45 -07001737static inline void inode_dec_dirty_pages(struct inode *inode)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001738{
Chao Yu5ac9f362015-06-29 18:14:10 +08001739 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
1740 !S_ISLNK(inode->i_mode))
Jaegeuk Kim1fe54f92014-02-07 10:00:06 +09001741 return;
1742
Jaegeuk Kima43e1c42016-12-02 15:11:32 -08001743 atomic_dec(&F2FS_I(inode)->dirty_pages);
Chao Yuc227f912015-12-16 13:09:20 +08001744 dec_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
1745 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
Jaegeuk Kim931ecc22017-11-13 17:46:38 -08001746 if (IS_NOQUOTA(inode))
1747 dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001748}
1749
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001750static inline s64 get_pages(struct f2fs_sb_info *sbi, int count_type)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001751{
Jaegeuk Kim725ba1a2016-10-20 19:09:57 -07001752 return atomic_read(&sbi->nr_pages[count_type]);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001753}
1754
Jaegeuk Kima43e1c42016-12-02 15:11:32 -08001755static inline int get_dirty_pages(struct inode *inode)
Jaegeuk Kimf8b2c1f2014-03-18 12:33:06 +09001756{
Jaegeuk Kima43e1c42016-12-02 15:11:32 -08001757 return atomic_read(&F2FS_I(inode)->dirty_pages);
Jaegeuk Kimf8b2c1f2014-03-18 12:33:06 +09001758}
1759
Namjae Jeon5ac206c2013-02-02 23:52:59 +09001760static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
1761{
Chao Yu3519e3f2015-12-01 11:56:52 +08001762 unsigned int pages_per_sec = sbi->segs_per_sec * sbi->blocks_per_seg;
Jaegeuk Kim523be8a2016-05-13 12:36:58 -07001763 unsigned int segs = (get_pages(sbi, block_type) + pages_per_sec - 1) >>
1764 sbi->log_blocks_per_seg;
1765
1766 return segs / sbi->segs_per_sec;
Namjae Jeon5ac206c2013-02-02 23:52:59 +09001767}
1768
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001769static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
1770{
Jaegeuk Kim8b8343f2014-02-24 13:00:13 +09001771 return sbi->total_valid_block_count;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001772}
1773
Yunlei Hef83a2582016-08-18 21:01:18 +08001774static inline block_t discard_blocks(struct f2fs_sb_info *sbi)
1775{
1776 return sbi->discard_blks;
1777}
1778
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001779static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
1780{
1781 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1782
1783 /* return NAT or SIT bitmap */
1784 if (flag == NAT_BITMAP)
1785 return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
1786 else if (flag == SIT_BITMAP)
1787 return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
1788
1789 return 0;
1790}
1791
Wanpeng Li55141482015-02-26 07:57:20 +08001792static inline block_t __cp_payload(struct f2fs_sb_info *sbi)
1793{
1794 return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
1795}
1796
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001797static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
1798{
1799 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Changman Lee1dbe4152014-05-12 12:27:43 +09001800 int offset;
1801
Chao Yua1afb552018-01-25 19:40:08 +08001802 if (is_set_ckpt_flags(sbi, CP_LARGE_NAT_BITMAP_FLAG)) {
1803 offset = (flag == SIT_BITMAP) ?
1804 le32_to_cpu(ckpt->nat_ver_bitmap_bytesize) : 0;
1805 return &ckpt->sit_nat_version_bitmap + offset;
1806 }
1807
Wanpeng Li55141482015-02-26 07:57:20 +08001808 if (__cp_payload(sbi) > 0) {
Changman Lee1dbe4152014-05-12 12:27:43 +09001809 if (flag == NAT_BITMAP)
1810 return &ckpt->sit_nat_version_bitmap;
1811 else
Jaegeuk Kim65b85cc2014-07-30 17:25:54 -07001812 return (unsigned char *)ckpt + F2FS_BLKSIZE;
Changman Lee1dbe4152014-05-12 12:27:43 +09001813 } else {
1814 offset = (flag == NAT_BITMAP) ?
Jaegeuk Kim25ca9232012-11-28 16:12:41 +09001815 le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
Changman Lee1dbe4152014-05-12 12:27:43 +09001816 return &ckpt->sit_nat_version_bitmap + offset;
1817 }
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001818}
1819
1820static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
1821{
Jaegeuk Kim01e15b32016-11-24 12:45:15 -08001822 block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001823
Jaegeuk Kim01e15b32016-11-24 12:45:15 -08001824 if (sbi->cur_cp_pack == 2)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001825 start_addr += sbi->blocks_per_seg;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001826 return start_addr;
1827}
1828
Jaegeuk Kim01e15b32016-11-24 12:45:15 -08001829static inline block_t __start_cp_next_addr(struct f2fs_sb_info *sbi)
1830{
1831 block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
1832
1833 if (sbi->cur_cp_pack == 1)
1834 start_addr += sbi->blocks_per_seg;
1835 return start_addr;
1836}
1837
1838static inline void __set_cp_next_pack(struct f2fs_sb_info *sbi)
1839{
1840 sbi->cur_cp_pack = (sbi->cur_cp_pack == 1) ? 2 : 1;
1841}
1842
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001843static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
1844{
1845 return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
1846}
1847
Chao Yu09c3a722017-07-09 00:13:07 +08001848static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,
Chao Yud9bfbbb2017-07-06 01:11:31 +08001849 struct inode *inode, bool is_inode)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001850{
1851 block_t valid_block_count;
1852 unsigned int valid_node_count;
Chao Yu09c3a722017-07-09 00:13:07 +08001853 bool quota = inode && !is_inode;
1854
1855 if (quota) {
1856 int ret = dquot_reserve_block(inode, 1);
1857 if (ret)
1858 return ret;
1859 }
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001860
Chao Yu05dac2e2017-11-13 17:32:40 +08001861#ifdef CONFIG_F2FS_FAULT_INJECTION
1862 if (time_to_inject(sbi, FAULT_BLOCK)) {
1863 f2fs_show_injection_info(FAULT_BLOCK);
1864 goto enospc;
1865 }
1866#endif
1867
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001868 spin_lock(&sbi->stat_lock);
1869
Jaegeuk Kim5fee5402017-12-27 15:05:52 -08001870 valid_block_count = sbi->total_valid_block_count +
1871 sbi->current_reserved_blocks + 1;
1872
Jaegeuk Kimc8fb2452018-04-20 23:44:59 -07001873 if (!__allow_reserved_blocks(sbi, inode, false))
Chao Yue9a50e62018-03-08 14:22:56 +08001874 valid_block_count += F2FS_OPTION(sbi).root_reserved_blocks;
Jaegeuk Kim5fee5402017-12-27 15:05:52 -08001875
1876 if (unlikely(valid_block_count > sbi->user_block_count)) {
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001877 spin_unlock(&sbi->stat_lock);
Chao Yu09c3a722017-07-09 00:13:07 +08001878 goto enospc;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001879 }
1880
Gu Zhengef86d702013-11-19 18:03:38 +08001881 valid_node_count = sbi->total_valid_node_count + 1;
Chao Yucfb271d2013-12-05 17:15:22 +08001882 if (unlikely(valid_node_count > sbi->total_node_count)) {
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001883 spin_unlock(&sbi->stat_lock);
Chao Yu09c3a722017-07-09 00:13:07 +08001884 goto enospc;
Chao Yud9bfbbb2017-07-06 01:11:31 +08001885 }
Gu Zhengef86d702013-11-19 18:03:38 +08001886
Gu Zhengef86d702013-11-19 18:03:38 +08001887 sbi->total_valid_node_count++;
1888 sbi->total_valid_block_count++;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001889 spin_unlock(&sbi->stat_lock);
1890
Chao Yu09c3a722017-07-09 00:13:07 +08001891 if (inode) {
1892 if (is_inode)
1893 f2fs_mark_inode_dirty_sync(inode, true);
1894 else
1895 f2fs_i_blocks_write(inode, 1, true, true);
1896 }
1897
Jaegeuk Kim41382ec2016-05-16 11:06:50 -07001898 percpu_counter_inc(&sbi->alloc_valid_block_count);
Chao Yu09c3a722017-07-09 00:13:07 +08001899 return 0;
1900
1901enospc:
1902 if (quota)
1903 dquot_release_reservation_block(inode, 1);
1904 return -ENOSPC;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001905}
1906
1907static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
Chao Yud9bfbbb2017-07-06 01:11:31 +08001908 struct inode *inode, bool is_inode)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001909{
1910 spin_lock(&sbi->stat_lock);
1911
Jaegeuk Kim9850cf42014-09-02 15:52:58 -07001912 f2fs_bug_on(sbi, !sbi->total_valid_block_count);
1913 f2fs_bug_on(sbi, !sbi->total_valid_node_count);
Chao Yud9bfbbb2017-07-06 01:11:31 +08001914 f2fs_bug_on(sbi, !is_inode && !inode->i_blocks);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001915
Gu Zhengef86d702013-11-19 18:03:38 +08001916 sbi->total_valid_node_count--;
1917 sbi->total_valid_block_count--;
Yunlong Song68ab6f82017-10-27 20:45:05 +08001918 if (sbi->reserved_blocks &&
1919 sbi->current_reserved_blocks < sbi->reserved_blocks)
1920 sbi->current_reserved_blocks++;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001921
1922 spin_unlock(&sbi->stat_lock);
Chao Yu09c3a722017-07-09 00:13:07 +08001923
1924 if (!is_inode)
1925 f2fs_i_blocks_write(inode, 1, false, true);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001926}
1927
1928static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
1929{
Jaegeuk Kim8b8343f2014-02-24 13:00:13 +09001930 return sbi->total_valid_node_count;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001931}
1932
1933static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
1934{
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07001935 percpu_counter_inc(&sbi->total_valid_inode_count);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001936}
1937
Jaegeuk Kim0e802202013-11-26 16:36:20 +09001938static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001939{
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07001940 percpu_counter_dec(&sbi->total_valid_inode_count);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001941}
1942
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07001943static inline s64 valid_inode_count(struct f2fs_sb_info *sbi)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001944{
Jaegeuk Kim513c5f32016-05-16 11:42:32 -07001945 return percpu_counter_sum_positive(&sbi->total_valid_inode_count);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001946}
1947
Jaegeuk Kima56c7c62015-10-09 15:11:38 -07001948static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
1949 pgoff_t index, bool for_write)
1950{
Jaegeuk Kimc41f3cc32016-04-29 16:17:09 -07001951#ifdef CONFIG_F2FS_FAULT_INJECTION
1952 struct page *page = find_lock_page(mapping, index);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001953
Jaegeuk Kimc41f3cc32016-04-29 16:17:09 -07001954 if (page)
1955 return page;
1956
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001957 if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_ALLOC)) {
1958 f2fs_show_injection_info(FAULT_PAGE_ALLOC);
Jaegeuk Kimc41f3cc32016-04-29 16:17:09 -07001959 return NULL;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07001960 }
Jaegeuk Kimc41f3cc32016-04-29 16:17:09 -07001961#endif
Jaegeuk Kima56c7c62015-10-09 15:11:38 -07001962 if (!for_write)
1963 return grab_cache_page(mapping, index);
1964 return grab_cache_page_write_begin(mapping, index, AOP_FLAG_NOFS);
1965}
1966
Chao Yu58ddec82017-10-28 16:52:30 +08001967static inline struct page *f2fs_pagecache_get_page(
1968 struct address_space *mapping, pgoff_t index,
1969 int fgp_flags, gfp_t gfp_mask)
1970{
1971#ifdef CONFIG_F2FS_FAULT_INJECTION
1972 if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_GET)) {
1973 f2fs_show_injection_info(FAULT_PAGE_GET);
1974 return NULL;
1975 }
1976#endif
1977 return pagecache_get_page(mapping, index, fgp_flags, gfp_mask);
1978}
1979
Jaegeuk Kim6e2c64a2015-10-07 12:28:41 -07001980static inline void f2fs_copy_page(struct page *src, struct page *dst)
1981{
1982 char *src_kaddr = kmap(src);
1983 char *dst_kaddr = kmap(dst);
1984
1985 memcpy(dst_kaddr, src_kaddr, PAGE_SIZE);
1986 kunmap(dst);
1987 kunmap(src);
1988}
1989
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001990static inline void f2fs_put_page(struct page *page, int unlock)
1991{
Jaegeuk Kim031fa8c2013-11-28 12:55:13 +09001992 if (!page)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001993 return;
1994
1995 if (unlock) {
Jaegeuk Kim9850cf42014-09-02 15:52:58 -07001996 f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page));
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09001997 unlock_page(page);
1998 }
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001999 put_page(page);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002000}
2001
2002static inline void f2fs_put_dnode(struct dnode_of_data *dn)
2003{
2004 if (dn->node_page)
2005 f2fs_put_page(dn->node_page, 1);
2006 if (dn->inode_page && dn->node_page != dn->inode_page)
2007 f2fs_put_page(dn->inode_page, 0);
2008 dn->node_page = NULL;
2009 dn->inode_page = NULL;
2010}
2011
2012static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
Gu Zhenge8512d22014-03-07 18:43:28 +08002013 size_t size)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002014{
Gu Zhenge8512d22014-03-07 18:43:28 +08002015 return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002016}
2017
Gu Zheng7bd59382013-10-22 14:52:26 +08002018static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep,
2019 gfp_t flags)
2020{
2021 void *entry;
Gu Zheng7bd59382013-10-22 14:52:26 +08002022
Jaegeuk Kim80c54502015-08-20 08:51:56 -07002023 entry = kmem_cache_alloc(cachep, flags);
2024 if (!entry)
2025 entry = kmem_cache_alloc(cachep, flags | __GFP_NOFAIL);
Gu Zheng7bd59382013-10-22 14:52:26 +08002026 return entry;
2027}
2028
Chao Yub5db2de2017-10-28 16:52:31 +08002029static inline struct bio *f2fs_bio_alloc(struct f2fs_sb_info *sbi,
2030 int npages, bool no_fail)
Jaegeuk Kim740432f2015-08-14 11:43:56 -07002031{
2032 struct bio *bio;
2033
Chao Yub5db2de2017-10-28 16:52:31 +08002034 if (no_fail) {
2035 /* No failure on bio allocation */
2036 bio = bio_alloc(GFP_NOIO, npages);
2037 if (!bio)
2038 bio = bio_alloc(GFP_NOIO | __GFP_NOFAIL, npages);
2039 return bio;
2040 }
2041#ifdef CONFIG_F2FS_FAULT_INJECTION
2042 if (time_to_inject(sbi, FAULT_ALLOC_BIO)) {
2043 f2fs_show_injection_info(FAULT_ALLOC_BIO);
2044 return NULL;
2045 }
2046#endif
2047 return bio_alloc(GFP_KERNEL, npages);
Jaegeuk Kim740432f2015-08-14 11:43:56 -07002048}
2049
Jaegeuk Kim9be32d72014-12-05 10:39:49 -08002050static inline void f2fs_radix_tree_insert(struct radix_tree_root *root,
2051 unsigned long index, void *item)
2052{
2053 while (radix_tree_insert(root, index, item))
2054 cond_resched();
2055}
2056
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002057#define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
2058
2059static inline bool IS_INODE(struct page *page)
2060{
Gu Zheng45590712013-07-15 17:57:38 +08002061 struct f2fs_node *p = F2FS_NODE(page);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002062
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002063 return RAW_IS_INODE(p);
2064}
2065
Chao Yufbcf9312017-07-19 00:19:06 +08002066static inline int offset_in_addr(struct f2fs_inode *i)
2067{
2068 return (i->i_inline & F2FS_EXTRA_ATTR) ?
2069 (le16_to_cpu(i->i_extra_isize) / sizeof(__le32)) : 0;
2070}
2071
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002072static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
2073{
2074 return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
2075}
2076
Chao Yufbcf9312017-07-19 00:19:06 +08002077static inline int f2fs_has_extra_attr(struct inode *inode);
2078static inline block_t datablock_addr(struct inode *inode,
2079 struct page *node_page, unsigned int offset)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002080{
2081 struct f2fs_node *raw_node;
2082 __le32 *addr_array;
Chao Yufbcf9312017-07-19 00:19:06 +08002083 int base = 0;
2084 bool is_inode = IS_INODE(node_page);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002085
Gu Zheng45590712013-07-15 17:57:38 +08002086 raw_node = F2FS_NODE(node_page);
Chao Yufbcf9312017-07-19 00:19:06 +08002087
2088 /* from GC path only */
LiFan8234ed52017-11-28 20:17:41 +08002089 if (is_inode) {
2090 if (!inode)
Chao Yufbcf9312017-07-19 00:19:06 +08002091 base = offset_in_addr(&raw_node->i);
LiFan8234ed52017-11-28 20:17:41 +08002092 else if (f2fs_has_extra_attr(inode))
2093 base = get_extra_isize(inode);
Chao Yufbcf9312017-07-19 00:19:06 +08002094 }
2095
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002096 addr_array = blkaddr_in_node(raw_node);
Chao Yufbcf9312017-07-19 00:19:06 +08002097 return le32_to_cpu(addr_array[base + offset]);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002098}
2099
2100static inline int f2fs_test_bit(unsigned int nr, char *addr)
2101{
2102 int mask;
2103
2104 addr += (nr >> 3);
2105 mask = 1 << (7 - (nr & 0x07));
2106 return mask & *addr;
2107}
2108
Jaegeuk Kima66cdd92015-04-30 22:37:50 -07002109static inline void f2fs_set_bit(unsigned int nr, char *addr)
2110{
2111 int mask;
2112
2113 addr += (nr >> 3);
2114 mask = 1 << (7 - (nr & 0x07));
2115 *addr |= mask;
2116}
2117
2118static inline void f2fs_clear_bit(unsigned int nr, char *addr)
2119{
2120 int mask;
2121
2122 addr += (nr >> 3);
2123 mask = 1 << (7 - (nr & 0x07));
2124 *addr &= ~mask;
2125}
2126
Gu Zheng52aca072014-10-20 17:45:51 +08002127static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002128{
2129 int mask;
2130 int ret;
2131
2132 addr += (nr >> 3);
2133 mask = 1 << (7 - (nr & 0x07));
2134 ret = mask & *addr;
2135 *addr |= mask;
2136 return ret;
2137}
2138
Gu Zheng52aca072014-10-20 17:45:51 +08002139static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002140{
2141 int mask;
2142 int ret;
2143
2144 addr += (nr >> 3);
2145 mask = 1 << (7 - (nr & 0x07));
2146 ret = mask & *addr;
2147 *addr &= ~mask;
2148 return ret;
2149}
2150
Gu Zhengc6ac4c02014-10-20 17:45:50 +08002151static inline void f2fs_change_bit(unsigned int nr, char *addr)
2152{
2153 int mask;
2154
2155 addr += (nr >> 3);
2156 mask = 1 << (7 - (nr & 0x07));
2157 *addr ^= mask;
2158}
2159
Chao Yu9bafde62018-04-03 15:08:17 +08002160/*
2161 * Inode flags
2162 */
2163#define F2FS_SECRM_FL 0x00000001 /* Secure deletion */
2164#define F2FS_UNRM_FL 0x00000002 /* Undelete */
2165#define F2FS_COMPR_FL 0x00000004 /* Compress file */
2166#define F2FS_SYNC_FL 0x00000008 /* Synchronous updates */
2167#define F2FS_IMMUTABLE_FL 0x00000010 /* Immutable file */
2168#define F2FS_APPEND_FL 0x00000020 /* writes to file may only append */
2169#define F2FS_NODUMP_FL 0x00000040 /* do not dump file */
2170#define F2FS_NOATIME_FL 0x00000080 /* do not update atime */
2171/* Reserved for compression usage... */
2172#define F2FS_DIRTY_FL 0x00000100
2173#define F2FS_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
2174#define F2FS_NOCOMPR_FL 0x00000400 /* Don't compress */
2175#define F2FS_ENCRYPT_FL 0x00000800 /* encrypted file */
2176/* End compression flags --- maybe not all used */
2177#define F2FS_INDEX_FL 0x00001000 /* hash-indexed directory */
2178#define F2FS_IMAGIC_FL 0x00002000 /* AFS directory */
2179#define F2FS_JOURNAL_DATA_FL 0x00004000 /* file data should be journaled */
2180#define F2FS_NOTAIL_FL 0x00008000 /* file tail should not be merged */
2181#define F2FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
2182#define F2FS_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
2183#define F2FS_HUGE_FILE_FL 0x00040000 /* Set to each huge file */
2184#define F2FS_EXTENTS_FL 0x00080000 /* Inode uses extents */
2185#define F2FS_EA_INODE_FL 0x00200000 /* Inode used for large EA */
2186#define F2FS_EOFBLOCKS_FL 0x00400000 /* Blocks allocated beyond EOF */
2187#define F2FS_INLINE_DATA_FL 0x10000000 /* Inode has inline data. */
2188#define F2FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
2189#define F2FS_RESERVED_FL 0x80000000 /* reserved for ext4 lib */
2190
2191#define F2FS_FL_USER_VISIBLE 0x304BDFFF /* User visible flags */
2192#define F2FS_FL_USER_MODIFIABLE 0x204BC0FF /* User modifiable flags */
2193
2194/* Flags we can manipulate with through F2FS_IOC_FSSETXATTR */
2195#define F2FS_FL_XFLAG_VISIBLE (F2FS_SYNC_FL | \
2196 F2FS_IMMUTABLE_FL | \
2197 F2FS_APPEND_FL | \
2198 F2FS_NODUMP_FL | \
2199 F2FS_NOATIME_FL | \
2200 F2FS_PROJINHERIT_FL)
2201
2202/* Flags that should be inherited by new inodes from their parent. */
2203#define F2FS_FL_INHERITED (F2FS_SECRM_FL | F2FS_UNRM_FL | F2FS_COMPR_FL |\
2204 F2FS_SYNC_FL | F2FS_NODUMP_FL | F2FS_NOATIME_FL |\
2205 F2FS_NOCOMPR_FL | F2FS_JOURNAL_DATA_FL |\
2206 F2FS_NOTAIL_FL | F2FS_DIRSYNC_FL |\
2207 F2FS_PROJINHERIT_FL)
2208
2209/* Flags that are appropriate for regular files (all but dir-specific ones). */
2210#define F2FS_REG_FLMASK (~(F2FS_DIRSYNC_FL | F2FS_TOPDIR_FL))
2211
2212/* Flags that are appropriate for non-directories/regular files. */
2213#define F2FS_OTHER_FLMASK (F2FS_NODUMP_FL | F2FS_NOATIME_FL)
Chao Yu5647b302017-07-26 00:01:41 +08002214
2215static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
2216{
2217 if (S_ISDIR(mode))
2218 return flags;
2219 else if (S_ISREG(mode))
2220 return flags & F2FS_REG_FLMASK;
2221 else
2222 return flags & F2FS_OTHER_FLMASK;
2223}
2224
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002225/* used for f2fs_inode_info->flags */
2226enum {
2227 FI_NEW_INODE, /* indicate newly allocated inode */
Jaegeuk Kimb3783872013-06-10 09:17:01 +09002228 FI_DIRTY_INODE, /* indicate inode is dirty or not */
Jaegeuk Kim26de9b12016-05-20 20:42:37 -07002229 FI_AUTO_RECOVER, /* indicate inode is recoverable */
Jaegeuk Kimed57c272014-04-15 11:19:28 +09002230 FI_DIRTY_DIR, /* indicate directory has dirty pages */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002231 FI_INC_LINK, /* need to increment i_nlink */
2232 FI_ACL_MODE, /* indicate acl mode */
2233 FI_NO_ALLOC, /* should not allocate any blocks */
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -07002234 FI_FREE_NID, /* free allocated nide */
Jaegeuk Kimc11abd12013-11-19 10:41:54 +09002235 FI_NO_EXTENT, /* not to use the extent cache */
Jaegeuk Kim444c5802013-08-08 15:16:22 +09002236 FI_INLINE_XATTR, /* used for inline xattr */
Huajun Li1001b342013-11-10 23:13:16 +08002237 FI_INLINE_DATA, /* used for inline data*/
Chao Yu34d67de2014-09-24 18:15:19 +08002238 FI_INLINE_DENTRY, /* used for inline dentry */
Jaegeuk Kimfff04f92014-07-25 07:40:59 -07002239 FI_APPEND_WRITE, /* inode has appended data */
2240 FI_UPDATE_WRITE, /* inode has in-place-update data */
Jaegeuk Kim88b88a62014-10-06 17:39:50 -07002241 FI_NEED_IPU, /* used for ipu per file */
2242 FI_ATOMIC_FILE, /* indicate atomic file */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002243 FI_ATOMIC_COMMIT, /* indicate the state of atomical committing */
Jaegeuk Kim02a13352014-10-06 16:11:16 -07002244 FI_VOLATILE_FILE, /* indicate volatile file */
Jaegeuk Kim3c6c2be2015-03-17 17:16:35 -07002245 FI_FIRST_BLOCK_WRITTEN, /* indicate #0 data block was written */
Jaegeuk Kim1e843712014-12-09 06:08:59 -08002246 FI_DROP_CACHE, /* drop dirty page cache */
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -07002247 FI_DATA_EXIST, /* indicate data exists */
Jaegeuk Kim510022a2015-03-30 15:07:16 -07002248 FI_INLINE_DOTS, /* indicate inline dot dentries */
Chao Yud323d002015-10-27 09:53:45 +08002249 FI_DO_DEFRAG, /* indicate defragment is running */
Chao Yuc227f912015-12-16 13:09:20 +08002250 FI_DIRTY_FILE, /* indicate regular/symlink has dirty pages */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002251 FI_NO_PREALLOC, /* indicate skipped preallocated blocks */
2252 FI_HOT_DATA, /* indicate file is hot */
Chao Yufbcf9312017-07-19 00:19:06 +08002253 FI_EXTRA_ATTR, /* indicate file has extra attribute */
Chao Yu5647b302017-07-26 00:01:41 +08002254 FI_PROJ_INHERIT, /* indicate file inherits projectid */
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08002255 FI_PIN_FILE, /* indicate file should not be gced */
Chao Yucaf10c62018-05-07 20:28:54 +08002256 FI_ATOMIC_REVOKE_REQUEST, /* request to drop atomic data */
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002257};
2258
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002259static inline void __mark_inode_dirty_flag(struct inode *inode,
2260 int flag, bool set)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002261{
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002262 switch (flag) {
2263 case FI_INLINE_XATTR:
2264 case FI_INLINE_DATA:
2265 case FI_INLINE_DENTRY:
Daeho Jeong9ef5e652018-01-11 11:26:19 +09002266 case FI_NEW_INODE:
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002267 if (set)
2268 return;
2269 case FI_DATA_EXIST:
2270 case FI_INLINE_DOTS:
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08002271 case FI_PIN_FILE:
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002272 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002273 }
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002274}
2275
Jaegeuk Kim91942322016-05-20 10:13:22 -07002276static inline void set_inode_flag(struct inode *inode, int flag)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002277{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002278 if (!test_bit(flag, &F2FS_I(inode)->flags))
2279 set_bit(flag, &F2FS_I(inode)->flags);
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002280 __mark_inode_dirty_flag(inode, flag, true);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002281}
2282
Jaegeuk Kim91942322016-05-20 10:13:22 -07002283static inline int is_inode_flag_set(struct inode *inode, int flag)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002284{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002285 return test_bit(flag, &F2FS_I(inode)->flags);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002286}
2287
Jaegeuk Kim91942322016-05-20 10:13:22 -07002288static inline void clear_inode_flag(struct inode *inode, int flag)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002289{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002290 if (test_bit(flag, &F2FS_I(inode)->flags))
2291 clear_bit(flag, &F2FS_I(inode)->flags);
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002292 __mark_inode_dirty_flag(inode, flag, false);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002293}
2294
Jaegeuk Kim91942322016-05-20 10:13:22 -07002295static inline void set_acl_inode(struct inode *inode, umode_t mode)
Jaegeuk Kim444c5802013-08-08 15:16:22 +09002296{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002297 F2FS_I(inode)->i_acl_mode = mode;
2298 set_inode_flag(inode, FI_ACL_MODE);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002299 f2fs_mark_inode_dirty_sync(inode, false);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002300}
2301
Jaegeuk Kima1961242016-05-20 09:43:20 -07002302static inline void f2fs_i_links_write(struct inode *inode, bool inc)
2303{
2304 if (inc)
2305 inc_nlink(inode);
2306 else
2307 drop_nlink(inode);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002308 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kima1961242016-05-20 09:43:20 -07002309}
2310
Jaegeuk Kim8edd03c2016-05-20 09:26:06 -07002311static inline void f2fs_i_blocks_write(struct inode *inode,
Chao Yu09c3a722017-07-09 00:13:07 +08002312 block_t diff, bool add, bool claim)
Jaegeuk Kim8edd03c2016-05-20 09:26:06 -07002313{
Jaegeuk Kim26de9b12016-05-20 20:42:37 -07002314 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
2315 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
2316
Chao Yu09c3a722017-07-09 00:13:07 +08002317 /* add = 1, claim = 1 should be dquot_reserve_block in pair */
2318 if (add) {
2319 if (claim)
2320 dquot_claim_block(inode, diff);
2321 else
2322 dquot_alloc_block_nofail(inode, diff);
2323 } else {
2324 dquot_free_block(inode, diff);
2325 }
2326
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002327 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kim26de9b12016-05-20 20:42:37 -07002328 if (clean || recover)
2329 set_inode_flag(inode, FI_AUTO_RECOVER);
Jaegeuk Kim8edd03c2016-05-20 09:26:06 -07002330}
2331
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -07002332static inline void f2fs_i_size_write(struct inode *inode, loff_t i_size)
2333{
Jaegeuk Kim26de9b12016-05-20 20:42:37 -07002334 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
2335 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
2336
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -07002337 if (i_size_read(inode) == i_size)
2338 return;
2339
2340 i_size_write(inode, i_size);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002341 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kim26de9b12016-05-20 20:42:37 -07002342 if (clean || recover)
2343 set_inode_flag(inode, FI_AUTO_RECOVER);
2344}
2345
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002346static inline void f2fs_i_depth_write(struct inode *inode, unsigned int depth)
2347{
2348 F2FS_I(inode)->i_current_depth = depth;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002349 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002350}
2351
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08002352static inline void f2fs_i_gc_failures_write(struct inode *inode,
2353 unsigned int count)
2354{
Chao Yucaf10c62018-05-07 20:28:54 +08002355 F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN] = count;
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08002356 f2fs_mark_inode_dirty_sync(inode, true);
2357}
2358
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002359static inline void f2fs_i_xnid_write(struct inode *inode, nid_t xnid)
2360{
2361 F2FS_I(inode)->i_xattr_nid = xnid;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002362 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002363}
2364
2365static inline void f2fs_i_pino_write(struct inode *inode, nid_t pino)
2366{
2367 F2FS_I(inode)->i_pino = pino;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002368 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002369}
2370
Jaegeuk Kim91942322016-05-20 10:13:22 -07002371static inline void get_inline_info(struct inode *inode, struct f2fs_inode *ri)
Jaegeuk Kim444c5802013-08-08 15:16:22 +09002372{
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002373 struct f2fs_inode_info *fi = F2FS_I(inode);
2374
Jaegeuk Kim444c5802013-08-08 15:16:22 +09002375 if (ri->i_inline & F2FS_INLINE_XATTR)
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002376 set_bit(FI_INLINE_XATTR, &fi->flags);
Huajun Li1001b342013-11-10 23:13:16 +08002377 if (ri->i_inline & F2FS_INLINE_DATA)
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002378 set_bit(FI_INLINE_DATA, &fi->flags);
Chao Yu34d67de2014-09-24 18:15:19 +08002379 if (ri->i_inline & F2FS_INLINE_DENTRY)
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002380 set_bit(FI_INLINE_DENTRY, &fi->flags);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -07002381 if (ri->i_inline & F2FS_DATA_EXIST)
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002382 set_bit(FI_DATA_EXIST, &fi->flags);
Jaegeuk Kim510022a2015-03-30 15:07:16 -07002383 if (ri->i_inline & F2FS_INLINE_DOTS)
Jaegeuk Kim205b9822016-05-20 09:52:20 -07002384 set_bit(FI_INLINE_DOTS, &fi->flags);
Chao Yufbcf9312017-07-19 00:19:06 +08002385 if (ri->i_inline & F2FS_EXTRA_ATTR)
2386 set_bit(FI_EXTRA_ATTR, &fi->flags);
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08002387 if (ri->i_inline & F2FS_PIN_FILE)
2388 set_bit(FI_PIN_FILE, &fi->flags);
Jaegeuk Kim444c5802013-08-08 15:16:22 +09002389}
2390
Jaegeuk Kim91942322016-05-20 10:13:22 -07002391static inline void set_raw_inline(struct inode *inode, struct f2fs_inode *ri)
Jaegeuk Kim444c5802013-08-08 15:16:22 +09002392{
2393 ri->i_inline = 0;
2394
Jaegeuk Kim91942322016-05-20 10:13:22 -07002395 if (is_inode_flag_set(inode, FI_INLINE_XATTR))
Jaegeuk Kim444c5802013-08-08 15:16:22 +09002396 ri->i_inline |= F2FS_INLINE_XATTR;
Jaegeuk Kim91942322016-05-20 10:13:22 -07002397 if (is_inode_flag_set(inode, FI_INLINE_DATA))
Huajun Li1001b342013-11-10 23:13:16 +08002398 ri->i_inline |= F2FS_INLINE_DATA;
Jaegeuk Kim91942322016-05-20 10:13:22 -07002399 if (is_inode_flag_set(inode, FI_INLINE_DENTRY))
Chao Yu34d67de2014-09-24 18:15:19 +08002400 ri->i_inline |= F2FS_INLINE_DENTRY;
Jaegeuk Kim91942322016-05-20 10:13:22 -07002401 if (is_inode_flag_set(inode, FI_DATA_EXIST))
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -07002402 ri->i_inline |= F2FS_DATA_EXIST;
Jaegeuk Kim91942322016-05-20 10:13:22 -07002403 if (is_inode_flag_set(inode, FI_INLINE_DOTS))
Jaegeuk Kim510022a2015-03-30 15:07:16 -07002404 ri->i_inline |= F2FS_INLINE_DOTS;
Chao Yufbcf9312017-07-19 00:19:06 +08002405 if (is_inode_flag_set(inode, FI_EXTRA_ATTR))
2406 ri->i_inline |= F2FS_EXTRA_ATTR;
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08002407 if (is_inode_flag_set(inode, FI_PIN_FILE))
2408 ri->i_inline |= F2FS_PIN_FILE;
Chao Yufbcf9312017-07-19 00:19:06 +08002409}
2410
2411static inline int f2fs_has_extra_attr(struct inode *inode)
2412{
2413 return is_inode_flag_set(inode, FI_EXTRA_ATTR);
Jaegeuk Kim444c5802013-08-08 15:16:22 +09002414}
2415
Chao Yu987c7c32014-03-12 15:59:03 +08002416static inline int f2fs_has_inline_xattr(struct inode *inode)
2417{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002418 return is_inode_flag_set(inode, FI_INLINE_XATTR);
Chao Yu987c7c32014-03-12 15:59:03 +08002419}
2420
Chao Yu81ca7352016-01-26 15:39:35 +08002421static inline unsigned int addrs_per_inode(struct inode *inode)
Jaegeuk Kimde936532013-08-12 21:08:03 +09002422{
Chao Yu3aa46e22018-01-17 16:31:36 +08002423 return CUR_ADDRS_PER_INODE(inode) - get_inline_xattr_addrs(inode);
Jaegeuk Kimde936532013-08-12 21:08:03 +09002424}
2425
Chao Yu50ffaa92017-09-06 21:59:50 +08002426static inline void *inline_xattr_addr(struct inode *inode, struct page *page)
Jaegeuk Kim65985d92013-08-14 21:57:27 +09002427{
Chao Yu695fd1e2014-02-27 19:52:21 +08002428 struct f2fs_inode *ri = F2FS_INODE(page);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002429
Jaegeuk Kim65985d92013-08-14 21:57:27 +09002430 return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
Chao Yu3aa46e22018-01-17 16:31:36 +08002431 get_inline_xattr_addrs(inode)]);
Jaegeuk Kim65985d92013-08-14 21:57:27 +09002432}
2433
2434static inline int inline_xattr_size(struct inode *inode)
2435{
Chao Yu50ffaa92017-09-06 21:59:50 +08002436 return get_inline_xattr_addrs(inode) * sizeof(__le32);
Jaegeuk Kim65985d92013-08-14 21:57:27 +09002437}
2438
Jaegeuk Kim0dbdc2a2013-11-26 11:08:57 +09002439static inline int f2fs_has_inline_data(struct inode *inode)
2440{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002441 return is_inode_flag_set(inode, FI_INLINE_DATA);
Jaegeuk Kim0dbdc2a2013-11-26 11:08:57 +09002442}
2443
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -07002444static inline int f2fs_exist_data(struct inode *inode)
2445{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002446 return is_inode_flag_set(inode, FI_DATA_EXIST);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -07002447}
2448
Jaegeuk Kim510022a2015-03-30 15:07:16 -07002449static inline int f2fs_has_inline_dots(struct inode *inode)
2450{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002451 return is_inode_flag_set(inode, FI_INLINE_DOTS);
Jaegeuk Kim510022a2015-03-30 15:07:16 -07002452}
2453
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08002454static inline bool f2fs_is_pinned_file(struct inode *inode)
2455{
2456 return is_inode_flag_set(inode, FI_PIN_FILE);
2457}
2458
Jaegeuk Kim88b88a62014-10-06 17:39:50 -07002459static inline bool f2fs_is_atomic_file(struct inode *inode)
2460{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002461 return is_inode_flag_set(inode, FI_ATOMIC_FILE);
Jaegeuk Kim88b88a62014-10-06 17:39:50 -07002462}
2463
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002464static inline bool f2fs_is_commit_atomic_write(struct inode *inode)
2465{
2466 return is_inode_flag_set(inode, FI_ATOMIC_COMMIT);
2467}
2468
Jaegeuk Kim02a13352014-10-06 16:11:16 -07002469static inline bool f2fs_is_volatile_file(struct inode *inode)
2470{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002471 return is_inode_flag_set(inode, FI_VOLATILE_FILE);
Jaegeuk Kim02a13352014-10-06 16:11:16 -07002472}
2473
Jaegeuk Kim3c6c2be2015-03-17 17:16:35 -07002474static inline bool f2fs_is_first_block_written(struct inode *inode)
2475{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002476 return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
Jaegeuk Kim3c6c2be2015-03-17 17:16:35 -07002477}
2478
Jaegeuk Kim1e843712014-12-09 06:08:59 -08002479static inline bool f2fs_is_drop_cache(struct inode *inode)
2480{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002481 return is_inode_flag_set(inode, FI_DROP_CACHE);
Jaegeuk Kim1e843712014-12-09 06:08:59 -08002482}
2483
Chao Yue84f88e2017-07-19 00:19:05 +08002484static inline void *inline_data_addr(struct inode *inode, struct page *page)
Huajun Li1001b342013-11-10 23:13:16 +08002485{
Chao Yu695fd1e2014-02-27 19:52:21 +08002486 struct f2fs_inode *ri = F2FS_INODE(page);
Chao Yufbcf9312017-07-19 00:19:06 +08002487 int extra_size = get_extra_isize(inode);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002488
Chao Yufbcf9312017-07-19 00:19:06 +08002489 return (void *)&(ri->i_addr[extra_size + DEF_INLINE_RESERVED_SIZE]);
Huajun Li1001b342013-11-10 23:13:16 +08002490}
2491
Chao Yu34d67de2014-09-24 18:15:19 +08002492static inline int f2fs_has_inline_dentry(struct inode *inode)
2493{
Jaegeuk Kim91942322016-05-20 10:13:22 -07002494 return is_inode_flag_set(inode, FI_INLINE_DENTRY);
Chao Yu34d67de2014-09-24 18:15:19 +08002495}
2496
Jaegeuk Kimb5492af72015-04-20 13:44:41 -07002497static inline int is_file(struct inode *inode, int type)
2498{
2499 return F2FS_I(inode)->i_advise & type;
2500}
2501
2502static inline void set_file(struct inode *inode, int type)
2503{
2504 F2FS_I(inode)->i_advise |= type;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002505 f2fs_mark_inode_dirty_sync(inode, true);
Jaegeuk Kimb5492af72015-04-20 13:44:41 -07002506}
2507
2508static inline void clear_file(struct inode *inode, int type)
2509{
2510 F2FS_I(inode)->i_advise &= ~type;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002511 f2fs_mark_inode_dirty_sync(inode, true);
2512}
2513
2514static inline bool f2fs_skip_inode_update(struct inode *inode, int dsync)
2515{
Chao Yu33fdebb2017-10-09 17:55:19 +08002516 bool ret;
2517
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002518 if (dsync) {
2519 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002520
2521 spin_lock(&sbi->inode_lock[DIRTY_META]);
2522 ret = list_empty(&F2FS_I(inode)->gdirty_list);
2523 spin_unlock(&sbi->inode_lock[DIRTY_META]);
2524 return ret;
2525 }
2526 if (!is_inode_flag_set(inode, FI_AUTO_RECOVER) ||
2527 file_keep_isize(inode) ||
Junling Zheng44789702018-03-29 19:27:12 +08002528 i_size_read(inode) & ~PAGE_MASK)
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002529 return false;
Chao Yu33fdebb2017-10-09 17:55:19 +08002530
Jaegeuk Kimac389af2018-03-29 22:50:41 -07002531 if (!timespec_equal(F2FS_I(inode)->i_disk_time, &inode->i_atime))
2532 return false;
2533 if (!timespec_equal(F2FS_I(inode)->i_disk_time + 1, &inode->i_ctime))
2534 return false;
2535 if (!timespec_equal(F2FS_I(inode)->i_disk_time + 2, &inode->i_mtime))
2536 return false;
2537 if (!timespec_equal(F2FS_I(inode)->i_disk_time + 3,
2538 &F2FS_I(inode)->i_crtime))
2539 return false;
2540
Chao Yu33fdebb2017-10-09 17:55:19 +08002541 down_read(&F2FS_I(inode)->i_sem);
2542 ret = F2FS_I(inode)->last_disk_size == i_size_read(inode);
2543 up_read(&F2FS_I(inode)->i_sem);
2544
2545 return ret;
Jaegeuk Kimb5492af72015-04-20 13:44:41 -07002546}
2547
Chao Yu8f711c32018-03-01 23:40:31 +08002548static inline bool f2fs_readonly(struct super_block *sb)
Jaegeuk Kim77888c12013-05-20 20:28:47 +09002549{
2550 return sb->s_flags & MS_RDONLY;
2551}
2552
Jaegeuk Kim1e968fd2014-08-11 16:49:25 -07002553static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
2554{
Chao Yuaaec2b12016-09-20 11:04:18 +08002555 return is_set_ckpt_flags(sbi, CP_ERROR_FLAG);
Jaegeuk Kim1e968fd2014-08-11 16:49:25 -07002556}
2557
Jaegeuk Kimeaa693f2015-04-26 00:15:29 -07002558static inline bool is_dot_dotdot(const struct qstr *str)
2559{
2560 if (str->len == 1 && str->name[0] == '.')
2561 return true;
2562
2563 if (str->len == 2 && str->name[0] == '.' && str->name[1] == '.')
2564 return true;
2565
2566 return false;
2567}
2568
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07002569static inline bool f2fs_may_extent_tree(struct inode *inode)
2570{
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07002571 if (!test_opt(F2FS_I_SB(inode), EXTENT_CACHE) ||
Jaegeuk Kim91942322016-05-20 10:13:22 -07002572 is_inode_flag_set(inode, FI_NO_EXTENT))
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07002573 return false;
2574
Al Viro886f56f2015-12-05 03:56:06 -05002575 return S_ISREG(inode->i_mode);
Jaegeuk Kim3e72f722015-06-19 17:53:26 -07002576}
2577
Chao Yu1ecc0c52016-09-23 21:30:09 +08002578static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,
2579 size_t size, gfp_t flags)
Jaegeuk Kim0414b002016-04-29 15:16:42 -07002580{
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -07002581#ifdef CONFIG_F2FS_FAULT_INJECTION
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002582 if (time_to_inject(sbi, FAULT_KMALLOC)) {
2583 f2fs_show_injection_info(FAULT_KMALLOC);
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -07002584 return NULL;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002585 }
Jaegeuk Kim2c63fea2016-04-29 15:49:56 -07002586#endif
Jaegeuk Kim0414b002016-04-29 15:16:42 -07002587 return kmalloc(size, flags);
2588}
2589
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002590static inline void *kvmalloc(size_t size, gfp_t flags)
Jaegeuk Kim39307a82015-09-22 13:50:47 -07002591{
2592 void *ret;
2593
2594 ret = kmalloc(size, flags | __GFP_NOWARN);
2595 if (!ret)
2596 ret = __vmalloc(size, flags, PAGE_KERNEL);
2597 return ret;
2598}
2599
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002600static inline void *kvzalloc(size_t size, gfp_t flags)
Jaegeuk Kim39307a82015-09-22 13:50:47 -07002601{
2602 void *ret;
2603
2604 ret = kzalloc(size, flags | __GFP_NOWARN);
2605 if (!ret)
2606 ret = __vmalloc(size, flags | __GFP_ZERO, PAGE_KERNEL);
2607 return ret;
2608}
2609
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002610static inline int wbc_to_write_flags(struct writeback_control *wbc)
2611{
2612 if (wbc->sync_mode == WB_SYNC_ALL)
2613 return REQ_SYNC;
2614 else if (wbc->for_kupdate || wbc->for_background)
2615 return 0;
2616
2617 return 0;
2618}
2619
Chao Yue585ca22017-11-30 19:28:17 +08002620static inline void *f2fs_kzalloc(struct f2fs_sb_info *sbi,
2621 size_t size, gfp_t flags)
2622{
2623 return f2fs_kmalloc(sbi, size, flags | __GFP_ZERO);
2624}
2625
Chao Yuead52592017-11-30 19:28:18 +08002626static inline void *f2fs_kvmalloc(struct f2fs_sb_info *sbi,
2627 size_t size, gfp_t flags)
2628{
2629#ifdef CONFIG_F2FS_FAULT_INJECTION
2630 if (time_to_inject(sbi, FAULT_KVMALLOC)) {
2631 f2fs_show_injection_info(FAULT_KVMALLOC);
2632 return NULL;
2633 }
2634#endif
2635 return kvmalloc(size, flags);
2636}
2637
2638static inline void *f2fs_kvzalloc(struct f2fs_sb_info *sbi,
2639 size_t size, gfp_t flags)
2640{
2641 return f2fs_kvmalloc(sbi, size, flags | __GFP_ZERO);
2642}
2643
Chao Yufbcf9312017-07-19 00:19:06 +08002644static inline int get_extra_isize(struct inode *inode)
Chao Yue84f88e2017-07-19 00:19:05 +08002645{
Chao Yufbcf9312017-07-19 00:19:06 +08002646 return F2FS_I(inode)->i_extra_isize / sizeof(__le32);
Chao Yue84f88e2017-07-19 00:19:05 +08002647}
2648
Chao Yu50ffaa92017-09-06 21:59:50 +08002649static inline int get_inline_xattr_addrs(struct inode *inode)
2650{
2651 return F2FS_I(inode)->i_inline_xattr_size;
2652}
2653
Christoph Hellwiga6dda0e2013-12-20 05:16:45 -08002654#define get_inode_mode(i) \
Jaegeuk Kim91942322016-05-20 10:13:22 -07002655 ((is_inode_flag_set(i, FI_ACL_MODE)) ? \
Christoph Hellwiga6dda0e2013-12-20 05:16:45 -08002656 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
2657
Chao Yufbcf9312017-07-19 00:19:06 +08002658#define F2FS_TOTAL_EXTRA_ATTR_SIZE \
2659 (offsetof(struct f2fs_inode, i_extra_end) - \
2660 offsetof(struct f2fs_inode, i_extra_isize)) \
2661
Chao Yu5647b302017-07-26 00:01:41 +08002662#define F2FS_OLD_ATTRIBUTE_SIZE (offsetof(struct f2fs_inode, i_addr))
2663#define F2FS_FITS_IN_INODE(f2fs_inode, extra_isize, field) \
2664 ((offsetof(typeof(*f2fs_inode), field) + \
2665 sizeof((f2fs_inode)->field)) \
2666 <= (F2FS_OLD_ATTRIBUTE_SIZE + extra_isize)) \
2667
Chao Yuc0fe4882017-08-02 23:21:48 +08002668static inline void f2fs_reset_iostat(struct f2fs_sb_info *sbi)
2669{
2670 int i;
2671
2672 spin_lock(&sbi->iostat_lock);
2673 for (i = 0; i < NR_IO_TYPE; i++)
2674 sbi->write_iostat[i] = 0;
2675 spin_unlock(&sbi->iostat_lock);
2676}
2677
2678static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi,
2679 enum iostat_type type, unsigned long long io_bytes)
2680{
2681 if (!sbi->iostat_enable)
2682 return;
2683 spin_lock(&sbi->iostat_lock);
2684 sbi->write_iostat[type] += io_bytes;
2685
2686 if (type == APP_WRITE_IO || type == APP_DIRECT_IO)
2687 sbi->write_iostat[APP_BUFFERED_IO] =
2688 sbi->write_iostat[APP_WRITE_IO] -
2689 sbi->write_iostat[APP_DIRECT_IO];
2690 spin_unlock(&sbi->iostat_lock);
2691}
2692
Chao Yu158d9bb2018-05-23 22:25:08 +08002693static inline bool is_valid_blkaddr(block_t blkaddr)
2694{
2695 if (blkaddr == NEW_ADDR || blkaddr == NULL_ADDR)
2696 return false;
2697 return true;
2698}
2699
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002700/*
2701 * file.c
2702 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002703int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
2704void truncate_data_blocks(struct dnode_of_data *dn);
2705int truncate_blocks(struct inode *inode, u64 from, bool lock);
2706int f2fs_truncate(struct inode *inode);
2707int f2fs_getattr(struct vfsmount *mnt, struct dentry *dentry,
2708 struct kstat *stat);
2709int f2fs_setattr(struct dentry *dentry, struct iattr *attr);
2710int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end);
Chao Yua74690b2017-11-30 19:28:23 +08002711void truncate_data_blocks_range(struct dnode_of_data *dn, int count);
Chao Yu6bce9632018-01-11 14:42:30 +08002712int f2fs_precache_extents(struct inode *inode);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002713long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
2714long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Jaegeuk Kim9ce3d6b2017-12-07 16:25:39 -08002715int f2fs_pin_file_control(struct inode *inode, bool inc);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002716
2717/*
2718 * inode.c
2719 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002720void f2fs_set_inode_flags(struct inode *inode);
Chao Yu43101252017-07-31 20:19:09 +08002721bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct page *page);
2722void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct page *page);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002723struct inode *f2fs_iget(struct super_block *sb, unsigned long ino);
2724struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino);
2725int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink);
Yunlei Hee2a05182017-12-05 12:07:47 +08002726void update_inode(struct inode *inode, struct page *node_page);
2727void update_inode_page(struct inode *inode);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002728int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);
2729void f2fs_evict_inode(struct inode *inode);
2730void handle_failed_inode(struct inode *inode);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002731
2732/*
2733 * namei.c
2734 */
Chao Yu1e72cb22018-02-26 22:04:13 +08002735int update_extension_list(struct f2fs_sb_info *sbi, const char *name,
Chao Yuac734c42018-02-28 17:07:27 +08002736 bool hot, bool set);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002737struct dentry *f2fs_get_parent(struct dentry *child);
2738
2739/*
2740 * dir.c
2741 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002742void set_de_type(struct f2fs_dir_entry *de, umode_t mode);
2743unsigned char get_de_type(struct f2fs_dir_entry *de);
2744struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname,
2745 f2fs_hash_t namehash, int *max_slots,
2746 struct f2fs_dentry_ptr *d);
2747int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
2748 unsigned int start_pos, struct fscrypt_str *fstr);
2749void do_make_empty_dir(struct inode *inode, struct inode *parent,
2750 struct f2fs_dentry_ptr *d);
2751struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
2752 const struct qstr *new_name,
2753 const struct qstr *orig_name, struct page *dpage);
2754void update_parent_metadata(struct inode *dir, struct inode *inode,
2755 unsigned int current_depth);
2756int room_for_filename(const void *bitmap, int slots, int max_slots);
2757void f2fs_drop_nlink(struct inode *dir, struct inode *inode);
2758struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
2759 struct fscrypt_name *fname, struct page **res_page);
2760struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
2761 const struct qstr *child, struct page **res_page);
2762struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p);
2763ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
2764 struct page **page);
2765void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
2766 struct page *page, struct inode *inode);
2767void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
2768 const struct qstr *name, f2fs_hash_t name_hash,
2769 unsigned int bit_pos);
2770int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
2771 const struct qstr *orig_name,
2772 struct inode *inode, nid_t ino, umode_t mode);
2773int __f2fs_do_add_link(struct inode *dir, struct fscrypt_name *fname,
2774 struct inode *inode, nid_t ino, umode_t mode);
2775int __f2fs_add_link(struct inode *dir, const struct qstr *name,
2776 struct inode *inode, nid_t ino, umode_t mode);
2777void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
2778 struct inode *dir, struct inode *inode);
2779int f2fs_do_tmpfile(struct inode *inode, struct inode *dir);
2780bool f2fs_empty_dir(struct inode *dir);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002781
Al Virob7f7a5e2013-01-25 16:15:43 -05002782static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
2783{
David Howells2b0143b2015-03-17 22:25:59 +00002784 return __f2fs_add_link(d_inode(dentry->d_parent), &dentry->d_name,
Jaegeuk Kim510022a2015-03-30 15:07:16 -07002785 inode, inode->i_ino, inode->i_mode);
Al Virob7f7a5e2013-01-25 16:15:43 -05002786}
2787
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002788/*
2789 * super.c
2790 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002791int f2fs_inode_dirtied(struct inode *inode, bool sync);
2792void f2fs_inode_synced(struct inode *inode);
Jaegeuk Kim0108c482017-10-06 09:14:28 -07002793int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly);
Chao Yu41ad73f2017-08-08 10:54:31 +08002794void f2fs_quota_off_umount(struct super_block *sb);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002795int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover);
2796int f2fs_sync_fs(struct super_block *sb, int sync);
Namjae Jeona07ef782012-12-30 14:52:05 +09002797extern __printf(3, 4)
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002798void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...);
Shawn Lin984ec632016-02-17 11:26:32 +08002799int sanity_check_ckpt(struct f2fs_sb_info *sbi);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002800
2801/*
2802 * hash.c
2803 */
Jaegeuk Kim8daed212017-04-24 10:00:08 -07002804f2fs_hash_t f2fs_dentry_hash(const struct qstr *name_info,
2805 struct fscrypt_name *fname);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002806
2807/*
2808 * node.c
2809 */
2810struct dnode_of_data;
2811struct node_info;
2812
Jaegeuk Kimb733d012018-04-23 23:02:31 -06002813int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002814bool available_free_memory(struct f2fs_sb_info *sbi, int type);
2815int need_dentry_mark(struct f2fs_sb_info *sbi, nid_t nid);
2816bool is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid);
2817bool need_inode_block_update(struct f2fs_sb_info *sbi, nid_t ino);
2818void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni);
2819pgoff_t get_next_page_offset(struct dnode_of_data *dn, pgoff_t pgofs);
2820int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode);
2821int truncate_inode_blocks(struct inode *inode, pgoff_t from);
Jaegeuk Kim41d59232017-10-19 11:48:57 -07002822int truncate_xattr_node(struct inode *inode);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002823int wait_on_node_pages_writeback(struct f2fs_sb_info *sbi, nid_t ino);
2824int remove_inode_page(struct inode *inode);
2825struct page *new_inode_page(struct inode *inode);
Yunlei He40df1362017-07-17 19:16:11 +08002826struct page *new_node_page(struct dnode_of_data *dn, unsigned int ofs);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002827void ra_node_page(struct f2fs_sb_info *sbi, nid_t nid);
2828struct page *get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid);
2829struct page *get_node_page_ra(struct page *parent, int start);
2830void move_node_page(struct page *node_page, int gc_type);
2831int fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
2832 struct writeback_control *wbc, bool atomic);
Yunlong Song0c535c52017-07-27 20:11:00 +08002833int sync_node_pages(struct f2fs_sb_info *sbi, struct writeback_control *wbc,
Chao Yuc0fe4882017-08-02 23:21:48 +08002834 bool do_balance, enum iostat_type io_type);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002835void build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool mount);
2836bool alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid);
2837void alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid);
2838void alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid);
2839int try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink);
2840void recover_inline_xattr(struct inode *inode, struct page *page);
Sheng Yong89339082017-11-22 18:23:40 +08002841int recover_xattr_data(struct inode *inode, struct page *page);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002842int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page);
Yunlei Hec804fcf2017-12-06 11:31:29 +08002843void restore_node_summary(struct f2fs_sb_info *sbi,
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002844 unsigned int segno, struct f2fs_summary_block *sum);
2845void flush_nat_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2846int build_node_manager(struct f2fs_sb_info *sbi);
2847void destroy_node_manager(struct f2fs_sb_info *sbi);
Namjae Jeon6e6093a2013-01-17 00:08:30 +09002848int __init create_node_manager_caches(void);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002849void destroy_node_manager_caches(void);
2850
2851/*
2852 * segment.c
2853 */
Jaegeuk Kim2b170fc2017-09-09 11:11:04 -07002854bool need_SSR(struct f2fs_sb_info *sbi);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002855void register_inmem_page(struct inode *inode, struct page *page);
Chao Yucaf10c62018-05-07 20:28:54 +08002856void drop_inmem_pages_all(struct f2fs_sb_info *sbi, bool gc_failure);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002857void drop_inmem_pages(struct inode *inode);
2858void drop_inmem_page(struct inode *inode, struct page *page);
2859int commit_inmem_pages(struct inode *inode);
2860void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need);
2861void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi);
Chao Yuf014be82017-09-29 13:59:38 +08002862int f2fs_issue_flush(struct f2fs_sb_info *sbi, nid_t ino);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002863int create_flush_cmd_control(struct f2fs_sb_info *sbi);
Chao Yufd6422e2017-09-29 13:59:39 +08002864int f2fs_flush_device_cache(struct f2fs_sb_info *sbi);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002865void destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free);
2866void invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr);
2867bool is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
Chao Yu1a3b0042018-01-18 17:23:29 +08002868void drop_discard_cmd(struct f2fs_sb_info *sbi);
Chao Yud9d85cc2017-06-29 23:17:45 +08002869void stop_discard_thread(struct f2fs_sb_info *sbi);
Chao Yu1e5305a2017-10-04 09:08:37 +08002870bool f2fs_wait_discard_bios(struct f2fs_sb_info *sbi);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002871void clear_prefree_segments(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2872void release_discard_addrs(struct f2fs_sb_info *sbi);
2873int npages_for_summary_flush(struct f2fs_sb_info *sbi, bool for_ra);
2874void allocate_new_segments(struct f2fs_sb_info *sbi);
2875int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range);
2876bool exist_trim_candidates(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2877struct page *get_sum_page(struct f2fs_sb_info *sbi, unsigned int segno);
2878void update_meta_page(struct f2fs_sb_info *sbi, void *src, block_t blk_addr);
Chao Yuc0fe4882017-08-02 23:21:48 +08002879void write_meta_page(struct f2fs_sb_info *sbi, struct page *page,
2880 enum iostat_type io_type);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002881void write_node_page(unsigned int nid, struct f2fs_io_info *fio);
2882void write_data_page(struct dnode_of_data *dn, struct f2fs_io_info *fio);
2883int rewrite_data_page(struct f2fs_io_info *fio);
2884void __f2fs_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
2885 block_t old_blkaddr, block_t new_blkaddr,
2886 bool recover_curseg, bool recover_newaddr);
2887void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
2888 block_t old_addr, block_t new_addr,
2889 unsigned char version, bool recover_curseg,
2890 bool recover_newaddr);
2891void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
2892 block_t old_blkaddr, block_t *new_blkaddr,
Chao Yuc52dc0f2017-05-19 23:37:01 +08002893 struct f2fs_summary *sum, int type,
2894 struct f2fs_io_info *fio, bool add_list);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002895void f2fs_wait_on_page_writeback(struct page *page,
2896 enum page_type type, bool ordered);
Jaegeuk Kimfb605d02017-09-05 17:04:35 -07002897void f2fs_wait_on_block_writeback(struct f2fs_sb_info *sbi, block_t blkaddr);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002898void write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
2899void write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
2900int lookup_journal_in_cursum(struct f2fs_journal *journal, int type,
2901 unsigned int val, int alloc);
2902void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2903int build_segment_manager(struct f2fs_sb_info *sbi);
2904void destroy_segment_manager(struct f2fs_sb_info *sbi);
Jaegeuk Kim7fd9e542013-11-15 13:55:58 +09002905int __init create_segment_manager_caches(void);
2906void destroy_segment_manager_caches(void);
Hyunchul Lee1a9d6a92017-11-28 09:23:00 +09002907int rw_hint_to_seg_type(enum rw_hint hint);
Hyunchul Leebcdc5712018-01-31 11:36:57 +09002908enum rw_hint io_type_to_rw_hint(struct f2fs_sb_info *sbi, enum page_type type,
2909 enum temp_type temp);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002910
2911/*
2912 * checkpoint.c
2913 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002914void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io);
2915struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
2916struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
2917struct page *get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index);
Chao Yu158d9bb2018-05-23 22:25:08 +08002918bool is_valid_meta_blkaddr(struct f2fs_sb_info *sbi, block_t blkaddr, int type);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002919int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
2920 int type, bool sync);
2921void ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index);
2922long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
Chao Yuc0fe4882017-08-02 23:21:48 +08002923 long nr_to_write, enum iostat_type io_type);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002924void add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
2925void remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
2926void release_ino_entry(struct f2fs_sb_info *sbi, bool all);
2927bool exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode);
Chao Yuf014be82017-09-29 13:59:38 +08002928void set_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
2929 unsigned int devidx, int type);
2930bool is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
2931 unsigned int devidx, int type);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002932int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi);
2933int acquire_orphan_inode(struct f2fs_sb_info *sbi);
2934void release_orphan_inode(struct f2fs_sb_info *sbi);
2935void add_orphan_inode(struct inode *inode);
2936void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino);
2937int recover_orphan_inodes(struct f2fs_sb_info *sbi);
2938int get_valid_checkpoint(struct f2fs_sb_info *sbi);
2939void update_dirty_page(struct inode *inode, struct page *page);
2940void remove_dirty_inode(struct inode *inode);
2941int sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type);
2942int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc);
2943void init_ino_entry_info(struct f2fs_sb_info *sbi);
Namjae Jeon6e6093a2013-01-17 00:08:30 +09002944int __init create_checkpoint_caches(void);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002945void destroy_checkpoint_caches(void);
2946
2947/*
2948 * data.c
2949 */
Eric Biggersf69e8142018-04-18 11:09:48 -07002950int f2fs_init_post_read_processing(void);
2951void f2fs_destroy_post_read_processing(void);
Jaegeuk Kim9bc576a2017-05-10 11:28:38 -07002952void f2fs_submit_merged_write(struct f2fs_sb_info *sbi, enum page_type type);
2953void f2fs_submit_merged_write_cond(struct f2fs_sb_info *sbi,
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002954 struct inode *inode, nid_t ino, pgoff_t idx,
Jaegeuk Kim9bc576a2017-05-10 11:28:38 -07002955 enum page_type type);
2956void f2fs_flush_merged_writes(struct f2fs_sb_info *sbi);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002957int f2fs_submit_page_bio(struct f2fs_io_info *fio);
Jaegeuk Kim9bc576a2017-05-10 11:28:38 -07002958int f2fs_submit_page_write(struct f2fs_io_info *fio);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002959struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,
2960 block_t blk_addr, struct bio *bio);
2961int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr);
2962void set_data_blkaddr(struct dnode_of_data *dn);
2963void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr);
2964int reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count);
2965int reserve_new_block(struct dnode_of_data *dn);
2966int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index);
2967int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from);
2968int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index);
2969struct page *get_read_data_page(struct inode *inode, pgoff_t index,
2970 int op_flags, bool for_write);
2971struct page *find_data_page(struct inode *inode, pgoff_t index);
2972struct page *get_lock_data_page(struct inode *inode, pgoff_t index,
2973 bool for_write);
2974struct page *get_new_data_page(struct inode *inode,
2975 struct page *ipage, pgoff_t index, bool new_i_size);
2976int do_write_data_page(struct f2fs_io_info *fio);
2977int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
2978 int create, int flag);
2979int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2980 u64 start, u64 len);
Chao Yu66356ee2018-01-17 16:31:38 +08002981bool should_update_inplace(struct inode *inode, struct f2fs_io_info *fio);
2982bool should_update_outplace(struct inode *inode, struct f2fs_io_info *fio);
Chao Yuc0fe4882017-08-02 23:21:48 +08002983int __f2fs_write_data_pages(struct address_space *mapping,
2984 struct writeback_control *wbc,
2985 enum iostat_type io_type);
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002986void f2fs_invalidate_page(struct page *page, unsigned int offset,
2987 unsigned int length);
2988int f2fs_release_page(struct page *page, gfp_t wait);
Weichao Guo5b7a4872016-09-20 05:03:27 +08002989#ifdef CONFIG_MIGRATION
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002990int f2fs_migrate_page(struct address_space *mapping, struct page *newpage,
2991 struct page *page, enum migrate_mode mode);
Weichao Guo5b7a4872016-09-20 05:03:27 +08002992#endif
Hyunchul Lee355d2342018-03-08 19:34:38 +09002993bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09002994
2995/*
2996 * gc.c
2997 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07002998int start_gc_thread(struct f2fs_sb_info *sbi);
2999void stop_gc_thread(struct f2fs_sb_info *sbi);
3000block_t start_bidx_of_node(unsigned int node_ofs, struct inode *inode);
3001int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background,
3002 unsigned int segno);
3003void build_gc_manager(struct f2fs_sb_info *sbi);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003004
3005/*
3006 * recovery.c
3007 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003008int recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only);
3009bool space_for_roll_forward(struct f2fs_sb_info *sbi);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003010
3011/*
3012 * debug.c
3013 */
3014#ifdef CONFIG_F2FS_STAT_FS
3015struct f2fs_stat_info {
3016 struct list_head stat_list;
3017 struct f2fs_sb_info *sbi;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003018 int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
3019 int main_area_segs, main_area_sections, main_area_zones;
Chao Yu5b7ee372015-09-30 17:38:48 +08003020 unsigned long long hit_largest, hit_cached, hit_rbtree;
3021 unsigned long long hit_total, total_ext;
Jaegeuk Kimc00ba552015-12-31 15:24:14 -08003022 int ext_tree, zombie_tree, ext_node;
Jaegeuk Kim931ecc22017-11-13 17:46:38 -08003023 int ndirty_node, ndirty_dent, ndirty_meta, ndirty_imeta;
3024 int ndirty_data, ndirty_qdata;
Jaegeuk Kim725ba1a2016-10-20 19:09:57 -07003025 int inmem_pages;
Jaegeuk Kim931ecc22017-11-13 17:46:38 -08003026 unsigned int ndirty_dirs, ndirty_files, nquota_files, ndirty_all;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003027 int nats, dirty_nats, sits, dirty_sits;
3028 int free_nids, avail_nids, alloc_nids;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003029 int total_count, utilization;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003030 int bg_gc, nr_wb_cp_data, nr_wb_data;
Chao Yu2f0df252017-09-14 10:18:01 +08003031 int nr_flushing, nr_flushed, flush_list_empty;
3032 int nr_discarding, nr_discarded;
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003033 int nr_discard_cmd;
3034 unsigned int undiscard_blks;
3035 int inline_xattr, inline_inode, inline_dir, append, update, orphans;
3036 int aw_cnt, max_aw_cnt, vw_cnt, max_vw_cnt;
Yunlei Hef83a2582016-08-18 21:01:18 +08003037 unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003038 unsigned int bimodal, avg_vblocks;
3039 int util_free, util_valid, util_invalid;
3040 int rsvd_segs, overp_segs;
3041 int dirty_count, node_pages, meta_pages;
Jaegeuk Kim42190d22016-01-09 13:45:17 -08003042 int prefree_count, call_count, cp_count, bg_cp_count;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003043 int tot_segs, node_segs, data_segs, free_segs, free_secs;
Changman Leee1235982014-12-23 08:37:39 +09003044 int bg_node_segs, bg_data_segs;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003045 int tot_blks, data_blks, node_blks;
Changman Leee1235982014-12-23 08:37:39 +09003046 int bg_data_blks, bg_node_blks;
Chao Yucaf10c62018-05-07 20:28:54 +08003047 unsigned long long skipped_atomic_files[2];
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003048 int curseg[NR_CURSEG_TYPE];
3049 int cursec[NR_CURSEG_TYPE];
3050 int curzone[NR_CURSEG_TYPE];
3051
3052 unsigned int segment_count[2];
3053 unsigned int block_count[2];
Changman Leeb9a2c252014-12-24 02:16:54 +09003054 unsigned int inplace_count;
Chao Yu9edcdab2015-09-11 14:43:52 +08003055 unsigned long long base_mem, cache_mem, page_mem;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003056};
3057
Gu Zheng963d4f72013-07-12 14:47:11 +08003058static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
3059{
Chris Fries6c311ec2014-01-17 14:44:39 -06003060 return (struct f2fs_stat_info *)sbi->stat_info;
Gu Zheng963d4f72013-07-12 14:47:11 +08003061}
3062
Changman Lee942e0be2014-02-13 15:12:29 +09003063#define stat_inc_cp_count(si) ((si)->cp_count++)
Jaegeuk Kim42190d22016-01-09 13:45:17 -08003064#define stat_inc_bg_cp_count(si) ((si)->bg_cp_count++)
Jaegeuk Kimdcdfff62013-10-22 20:56:10 +09003065#define stat_inc_call_count(si) ((si)->call_count++)
3066#define stat_inc_bggc_count(sbi) ((sbi)->bg_gc++)
Chao Yu33fbd512015-12-17 17:14:44 +08003067#define stat_inc_dirty_inode(sbi, type) ((sbi)->ndirty_inode[type]++)
3068#define stat_dec_dirty_inode(sbi, type) ((sbi)->ndirty_inode[type]--)
Chao Yu5b7ee372015-09-30 17:38:48 +08003069#define stat_inc_total_hit(sbi) (atomic64_inc(&(sbi)->total_hit_ext))
3070#define stat_inc_rbtree_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_rbtree))
3071#define stat_inc_largest_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_largest))
3072#define stat_inc_cached_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_cached))
Chao Yud5e8f6c2015-07-15 17:28:53 +08003073#define stat_inc_inline_xattr(inode) \
3074 do { \
3075 if (f2fs_has_inline_xattr(inode)) \
3076 (atomic_inc(&F2FS_I_SB(inode)->inline_xattr)); \
3077 } while (0)
3078#define stat_dec_inline_xattr(inode) \
3079 do { \
3080 if (f2fs_has_inline_xattr(inode)) \
3081 (atomic_dec(&F2FS_I_SB(inode)->inline_xattr)); \
3082 } while (0)
Jaegeuk Kim0dbdc2a2013-11-26 11:08:57 +09003083#define stat_inc_inline_inode(inode) \
3084 do { \
3085 if (f2fs_has_inline_data(inode)) \
Chao Yu03e14d52014-12-08 19:08:20 +08003086 (atomic_inc(&F2FS_I_SB(inode)->inline_inode)); \
Jaegeuk Kim0dbdc2a2013-11-26 11:08:57 +09003087 } while (0)
3088#define stat_dec_inline_inode(inode) \
3089 do { \
3090 if (f2fs_has_inline_data(inode)) \
Chao Yu03e14d52014-12-08 19:08:20 +08003091 (atomic_dec(&F2FS_I_SB(inode)->inline_inode)); \
Jaegeuk Kim0dbdc2a2013-11-26 11:08:57 +09003092 } while (0)
Jaegeuk Kim3289c062014-10-13 20:00:16 -07003093#define stat_inc_inline_dir(inode) \
3094 do { \
3095 if (f2fs_has_inline_dentry(inode)) \
Chao Yu03e14d52014-12-08 19:08:20 +08003096 (atomic_inc(&F2FS_I_SB(inode)->inline_dir)); \
Jaegeuk Kim3289c062014-10-13 20:00:16 -07003097 } while (0)
3098#define stat_dec_inline_dir(inode) \
3099 do { \
3100 if (f2fs_has_inline_dentry(inode)) \
Chao Yu03e14d52014-12-08 19:08:20 +08003101 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
Jaegeuk Kim3289c062014-10-13 20:00:16 -07003102 } while (0)
Jaegeuk Kimdcdfff62013-10-22 20:56:10 +09003103#define stat_inc_seg_type(sbi, curseg) \
3104 ((sbi)->segment_count[(curseg)->alloc_type]++)
3105#define stat_inc_block_count(sbi, curseg) \
3106 ((sbi)->block_count[(curseg)->alloc_type]++)
Changman Leeb9a2c252014-12-24 02:16:54 +09003107#define stat_inc_inplace_blocks(sbi) \
3108 (atomic_inc(&(sbi)->inplace_count))
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003109#define stat_inc_atomic_write(inode) \
3110 (atomic_inc(&F2FS_I_SB(inode)->aw_cnt))
3111#define stat_dec_atomic_write(inode) \
3112 (atomic_dec(&F2FS_I_SB(inode)->aw_cnt))
3113#define stat_update_max_atomic_write(inode) \
3114 do { \
3115 int cur = atomic_read(&F2FS_I_SB(inode)->aw_cnt); \
3116 int max = atomic_read(&F2FS_I_SB(inode)->max_aw_cnt); \
3117 if (cur > max) \
3118 atomic_set(&F2FS_I_SB(inode)->max_aw_cnt, cur); \
3119 } while (0)
3120#define stat_inc_volatile_write(inode) \
3121 (atomic_inc(&F2FS_I_SB(inode)->vw_cnt))
3122#define stat_dec_volatile_write(inode) \
3123 (atomic_dec(&F2FS_I_SB(inode)->vw_cnt))
3124#define stat_update_max_volatile_write(inode) \
3125 do { \
3126 int cur = atomic_read(&F2FS_I_SB(inode)->vw_cnt); \
3127 int max = atomic_read(&F2FS_I_SB(inode)->max_vw_cnt); \
3128 if (cur > max) \
3129 atomic_set(&F2FS_I_SB(inode)->max_vw_cnt, cur); \
3130 } while (0)
Changman Leee1235982014-12-23 08:37:39 +09003131#define stat_inc_seg_count(sbi, type, gc_type) \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003132 do { \
Gu Zheng963d4f72013-07-12 14:47:11 +08003133 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003134 si->tot_segs++; \
3135 if ((type) == SUM_TYPE_DATA) { \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003136 si->data_segs++; \
Changman Leee1235982014-12-23 08:37:39 +09003137 si->bg_data_segs += (gc_type == BG_GC) ? 1 : 0; \
3138 } else { \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003139 si->node_segs++; \
Changman Leee1235982014-12-23 08:37:39 +09003140 si->bg_node_segs += (gc_type == BG_GC) ? 1 : 0; \
3141 } \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003142 } while (0)
3143
3144#define stat_inc_tot_blk_count(si, blks) \
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003145 ((si)->tot_blks += (blks))
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003146
Changman Leee1235982014-12-23 08:37:39 +09003147#define stat_inc_data_blk_count(sbi, blks, gc_type) \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003148 do { \
Gu Zheng963d4f72013-07-12 14:47:11 +08003149 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003150 stat_inc_tot_blk_count(si, blks); \
3151 si->data_blks += (blks); \
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003152 si->bg_data_blks += ((gc_type) == BG_GC) ? (blks) : 0; \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003153 } while (0)
3154
Changman Leee1235982014-12-23 08:37:39 +09003155#define stat_inc_node_blk_count(sbi, blks, gc_type) \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003156 do { \
Gu Zheng963d4f72013-07-12 14:47:11 +08003157 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003158 stat_inc_tot_blk_count(si, blks); \
3159 si->node_blks += (blks); \
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003160 si->bg_node_blks += ((gc_type) == BG_GC) ? (blks) : 0; \
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003161 } while (0)
3162
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003163int f2fs_build_stats(struct f2fs_sb_info *sbi);
3164void f2fs_destroy_stats(struct f2fs_sb_info *sbi);
Chao Yu787c7b8c2015-10-29 09:13:04 +08003165int __init f2fs_create_root_stats(void);
Namjae Jeon4589d252013-01-15 19:58:47 +09003166void f2fs_destroy_root_stats(void);
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003167#else
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003168#define stat_inc_cp_count(si) do { } while (0)
3169#define stat_inc_bg_cp_count(si) do { } while (0)
3170#define stat_inc_call_count(si) do { } while (0)
3171#define stat_inc_bggc_count(si) do { } while (0)
3172#define stat_inc_dirty_inode(sbi, type) do { } while (0)
3173#define stat_dec_dirty_inode(sbi, type) do { } while (0)
3174#define stat_inc_total_hit(sb) do { } while (0)
3175#define stat_inc_rbtree_node_hit(sb) do { } while (0)
3176#define stat_inc_largest_node_hit(sbi) do { } while (0)
3177#define stat_inc_cached_node_hit(sbi) do { } while (0)
3178#define stat_inc_inline_xattr(inode) do { } while (0)
3179#define stat_dec_inline_xattr(inode) do { } while (0)
3180#define stat_inc_inline_inode(inode) do { } while (0)
3181#define stat_dec_inline_inode(inode) do { } while (0)
3182#define stat_inc_inline_dir(inode) do { } while (0)
3183#define stat_dec_inline_dir(inode) do { } while (0)
3184#define stat_inc_atomic_write(inode) do { } while (0)
3185#define stat_dec_atomic_write(inode) do { } while (0)
3186#define stat_update_max_atomic_write(inode) do { } while (0)
3187#define stat_inc_volatile_write(inode) do { } while (0)
3188#define stat_dec_volatile_write(inode) do { } while (0)
3189#define stat_update_max_volatile_write(inode) do { } while (0)
3190#define stat_inc_seg_type(sbi, curseg) do { } while (0)
3191#define stat_inc_block_count(sbi, curseg) do { } while (0)
3192#define stat_inc_inplace_blocks(sbi) do { } while (0)
3193#define stat_inc_seg_count(sbi, type, gc_type) do { } while (0)
3194#define stat_inc_tot_blk_count(si, blks) do { } while (0)
3195#define stat_inc_data_blk_count(sbi, blks, gc_type) do { } while (0)
3196#define stat_inc_node_blk_count(sbi, blks, gc_type) do { } while (0)
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003197
3198static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
3199static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
Chao Yu787c7b8c2015-10-29 09:13:04 +08003200static inline int __init f2fs_create_root_stats(void) { return 0; }
Namjae Jeon4589d252013-01-15 19:58:47 +09003201static inline void f2fs_destroy_root_stats(void) { }
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003202#endif
3203
3204extern const struct file_operations f2fs_dir_operations;
3205extern const struct file_operations f2fs_file_operations;
3206extern const struct inode_operations f2fs_file_inode_operations;
3207extern const struct address_space_operations f2fs_dblock_aops;
3208extern const struct address_space_operations f2fs_node_aops;
3209extern const struct address_space_operations f2fs_meta_aops;
3210extern const struct inode_operations f2fs_dir_inode_operations;
3211extern const struct inode_operations f2fs_symlink_inode_operations;
Jaegeuk Kimcbaf0422015-04-29 15:10:53 -07003212extern const struct inode_operations f2fs_encrypted_symlink_inode_operations;
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003213extern const struct inode_operations f2fs_special_inode_operations;
Jaegeuk Kim29e70432015-02-10 16:23:12 -08003214extern struct kmem_cache *inode_entry_slab;
Huajun Li1001b342013-11-10 23:13:16 +08003215
Huajun Lie18c65b2013-11-10 23:13:19 +08003216/*
3217 * inline.c
3218 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003219bool f2fs_may_inline_data(struct inode *inode);
3220bool f2fs_may_inline_dentry(struct inode *inode);
3221void read_inline_data(struct page *page, struct page *ipage);
3222void truncate_inline_inode(struct inode *inode, struct page *ipage, u64 from);
3223int f2fs_read_inline_data(struct inode *inode, struct page *page);
3224int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page);
3225int f2fs_convert_inline_inode(struct inode *inode);
3226int f2fs_write_inline_data(struct inode *inode, struct page *page);
3227bool recover_inline_data(struct inode *inode, struct page *npage);
3228struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
3229 struct fscrypt_name *fname, struct page **res_page);
3230int make_empty_inline_dir(struct inode *inode, struct inode *parent,
3231 struct page *ipage);
3232int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
3233 const struct qstr *orig_name,
3234 struct inode *inode, nid_t ino, umode_t mode);
3235void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
3236 struct inode *dir, struct inode *inode);
3237bool f2fs_empty_inline_dir(struct inode *dir);
3238int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
3239 struct fscrypt_str *fstr);
3240int f2fs_inline_data_fiemap(struct inode *inode,
3241 struct fiemap_extent_info *fieinfo,
3242 __u64 start, __u64 len);
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003243
3244/*
Jaegeuk Kim2658e502015-06-19 12:01:21 -07003245 * shrinker.c
3246 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003247unsigned long f2fs_shrink_count(struct shrinker *shrink,
3248 struct shrink_control *sc);
3249unsigned long f2fs_shrink_scan(struct shrinker *shrink,
3250 struct shrink_control *sc);
3251void f2fs_join_shrinker(struct f2fs_sb_info *sbi);
3252void f2fs_leave_shrinker(struct f2fs_sb_info *sbi);
Jaegeuk Kim2658e502015-06-19 12:01:21 -07003253
3254/*
Chao Yua28ef1f2015-07-08 17:59:36 +08003255 * extent_cache.c
3256 */
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003257struct rb_entry *__lookup_rb_tree(struct rb_root *root,
3258 struct rb_entry *cached_re, unsigned int ofs);
3259struct rb_node **__lookup_rb_tree_for_insert(struct f2fs_sb_info *sbi,
3260 struct rb_root *root, struct rb_node **parent,
3261 unsigned int ofs);
3262struct rb_entry *__lookup_rb_tree_ret(struct rb_root *root,
3263 struct rb_entry *cached_re, unsigned int ofs,
3264 struct rb_entry **prev_entry, struct rb_entry **next_entry,
3265 struct rb_node ***insert_p, struct rb_node **insert_parent,
3266 bool force);
3267bool __check_rb_tree_consistence(struct f2fs_sb_info *sbi,
3268 struct rb_root *root);
3269unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink);
3270bool f2fs_init_extent_tree(struct inode *inode, struct f2fs_extent *i_ext);
3271void f2fs_drop_extent_tree(struct inode *inode);
3272unsigned int f2fs_destroy_extent_node(struct inode *inode);
3273void f2fs_destroy_extent_tree(struct inode *inode);
3274bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs,
3275 struct extent_info *ei);
3276void f2fs_update_extent_cache(struct dnode_of_data *dn);
Chao Yu19b2c302015-08-26 20:34:48 +08003277void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003278 pgoff_t fofs, block_t blkaddr, unsigned int len);
3279void init_extent_cache_info(struct f2fs_sb_info *sbi);
Chao Yua28ef1f2015-07-08 17:59:36 +08003280int __init create_extent_cache(void);
3281void destroy_extent_cache(void);
3282
3283/*
Chao Yu57fb30c2017-06-14 17:39:47 +08003284 * sysfs.c
3285 */
Jaegeuk Kim883d5532017-07-26 11:24:13 -07003286int __init f2fs_init_sysfs(void);
3287void f2fs_exit_sysfs(void);
3288int f2fs_register_sysfs(struct f2fs_sb_info *sbi);
3289void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi);
Chao Yu57fb30c2017-06-14 17:39:47 +08003290
3291/*
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003292 * crypto support
3293 */
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07003294static inline bool f2fs_encrypted_inode(struct inode *inode)
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003295{
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003296 return file_is_encrypt(inode);
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003297}
3298
Jaegeuk Kima4fb1892017-09-05 16:54:24 -07003299static inline bool f2fs_encrypted_file(struct inode *inode)
3300{
3301 return f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode);
3302}
3303
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003304static inline void f2fs_set_encrypted_inode(struct inode *inode)
3305{
3306#ifdef CONFIG_F2FS_FS_ENCRYPTION
3307 file_set_encrypt(inode);
Eric Biggers685285b2017-10-09 12:15:35 -07003308 inode->i_flags |= S_ENCRYPTED;
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003309#endif
3310}
3311
Eric Biggersf69e8142018-04-18 11:09:48 -07003312/*
3313 * Returns true if the reads of the inode's data need to undergo some
3314 * postprocessing step, like decryption or authenticity verification.
3315 */
3316static inline bool f2fs_post_read_required(struct inode *inode)
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003317{
Eric Biggersf69e8142018-04-18 11:09:48 -07003318 return f2fs_encrypted_file(inode);
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003319}
3320
Sheng Yong770611e2018-02-06 12:31:17 +08003321#define F2FS_FEATURE_FUNCS(name, flagname) \
3322static inline int f2fs_sb_has_##name(struct super_block *sb) \
3323{ \
3324 return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_##flagname); \
Jaegeuk Kimcde4de12015-04-20 13:57:51 -07003325}
Jaegeuk Kimf424f662015-04-20 15:19:06 -07003326
Sheng Yong770611e2018-02-06 12:31:17 +08003327F2FS_FEATURE_FUNCS(encrypt, ENCRYPT);
3328F2FS_FEATURE_FUNCS(blkzoned, BLKZONED);
3329F2FS_FEATURE_FUNCS(extra_attr, EXTRA_ATTR);
3330F2FS_FEATURE_FUNCS(project_quota, PRJQUOTA);
3331F2FS_FEATURE_FUNCS(inode_chksum, INODE_CHKSUM);
3332F2FS_FEATURE_FUNCS(flexible_inline_xattr, FLEXIBLE_INLINE_XATTR);
3333F2FS_FEATURE_FUNCS(quota_ino, QUOTA_INO);
3334F2FS_FEATURE_FUNCS(inode_crtime, INODE_CRTIME);
Sheng Yong9b880fe2018-03-15 18:51:41 +08003335F2FS_FEATURE_FUNCS(lost_found, LOST_FOUND);
Chao Yu71f8f042018-01-25 14:54:42 +08003336
Jaegeuk Kime6b120d2017-07-10 12:55:09 -07003337#ifdef CONFIG_BLK_DEV_ZONED
3338static inline int get_blkz_type(struct f2fs_sb_info *sbi,
3339 struct block_device *bdev, block_t blkaddr)
3340{
3341 unsigned int zno = blkaddr >> sbi->log_blocks_per_blkz;
3342 int i;
3343
3344 for (i = 0; i < sbi->s_ndevs; i++)
3345 if (FDEV(i).bdev == bdev)
3346 return FDEV(i).blkz_type[zno];
3347 return -EINVAL;
3348}
3349#endif
3350
3351static inline bool f2fs_discard_en(struct f2fs_sb_info *sbi)
3352{
3353 struct request_queue *q = bdev_get_queue(sbi->sb->s_bdev);
3354
Sheng Yong770611e2018-02-06 12:31:17 +08003355 return blk_queue_discard(q) || f2fs_sb_has_blkzoned(sbi->sb);
Jaegeuk Kim52763a42016-06-13 09:47:48 -07003356}
3357
3358static inline void set_opt_mode(struct f2fs_sb_info *sbi, unsigned int mt)
3359{
3360 clear_opt(sbi, ADAPTIVE);
3361 clear_opt(sbi, LFS);
3362
3363 switch (mt) {
3364 case F2FS_MOUNT_ADAPTIVE:
3365 set_opt(sbi, ADAPTIVE);
3366 break;
3367 case F2FS_MOUNT_LFS:
3368 set_opt(sbi, LFS);
3369 break;
3370 }
3371}
3372
Jaegeuk Kimfcc85a42015-04-21 20:39:58 -07003373static inline bool f2fs_may_encrypt(struct inode *inode)
3374{
3375#ifdef CONFIG_F2FS_FS_ENCRYPTION
Al Viro886f56f2015-12-05 03:56:06 -05003376 umode_t mode = inode->i_mode;
Jaegeuk Kimfcc85a42015-04-21 20:39:58 -07003377
3378 return (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode));
3379#else
3380 return 0;
3381#endif
3382}
3383
Hyunchul Lee355d2342018-03-08 19:34:38 +09003384static inline bool f2fs_force_buffered_io(struct inode *inode, int rw)
3385{
Eric Biggersf69e8142018-04-18 11:09:48 -07003386 return (f2fs_post_read_required(inode) ||
Hyunchul Lee355d2342018-03-08 19:34:38 +09003387 (rw == WRITE && test_opt(F2FS_I_SB(inode), LFS)) ||
3388 F2FS_I_SB(inode)->s_ndevs);
3389}
3390
Jaegeuk Kim39a53e02012-11-28 13:37:31 +09003391#endif