1
2
3
4
5
6
7
8#ifndef _LINUX_F2FS_H
9#define _LINUX_F2FS_H
10
11#include <linux/uio.h>
12#include <linux/types.h>
13#include <linux/page-flags.h>
14#include <linux/buffer_head.h>
15#include <linux/slab.h>
16#include <linux/crc32.h>
17#include <linux/magic.h>
18#include <linux/kobject.h>
19#include <linux/sched.h>
20#include <linux/cred.h>
21#include <linux/vmalloc.h>
22#include <linux/bio.h>
23#include <linux/blkdev.h>
24#include <linux/quotaops.h>
25#include <crypto/hash.h>
26
27#include <linux/fscrypt.h>
28
29#ifdef CONFIG_F2FS_CHECK_FS
30#define f2fs_bug_on(sbi, condition) BUG_ON(condition)
31#else
32#define f2fs_bug_on(sbi, condition) \
33 do { \
34 if (unlikely(condition)) { \
35 WARN_ON(1); \
36 set_sbi_flag(sbi, SBI_NEED_FSCK); \
37 } \
38 } while (0)
39#endif
40
41enum {
42 FAULT_KMALLOC,
43 FAULT_KVMALLOC,
44 FAULT_PAGE_ALLOC,
45 FAULT_PAGE_GET,
46 FAULT_ALLOC_BIO,
47 FAULT_ALLOC_NID,
48 FAULT_ORPHAN,
49 FAULT_BLOCK,
50 FAULT_DIR_DEPTH,
51 FAULT_EVICT_INODE,
52 FAULT_TRUNCATE,
53 FAULT_READ_IO,
54 FAULT_CHECKPOINT,
55 FAULT_DISCARD,
56 FAULT_WRITE_IO,
57 FAULT_MAX,
58};
59
60#ifdef CONFIG_F2FS_FAULT_INJECTION
61#define F2FS_ALL_FAULT_TYPE ((1 << FAULT_MAX) - 1)
62
63struct f2fs_fault_info {
64 atomic_t inject_ops;
65 unsigned int inject_rate;
66 unsigned int inject_type;
67};
68
69extern const char *f2fs_fault_name[FAULT_MAX];
70#define IS_FAULT_SET(fi, type) ((fi)->inject_type & (1 << (type)))
71#endif
72
73
74
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
83#define F2FS_MOUNT_INLINE_XATTR 0x00000080
84#define F2FS_MOUNT_INLINE_DATA 0x00000100
85#define F2FS_MOUNT_INLINE_DENTRY 0x00000200
86#define F2FS_MOUNT_FLUSH_MERGE 0x00000400
87#define F2FS_MOUNT_NOBARRIER 0x00000800
88#define F2FS_MOUNT_FASTBOOT 0x00001000
89#define F2FS_MOUNT_EXTENT_CACHE 0x00002000
90#define F2FS_MOUNT_FORCE_FG_GC 0x00004000
91#define F2FS_MOUNT_DATA_FLUSH 0x00008000
92#define F2FS_MOUNT_FAULT_INJECTION 0x00010000
93#define F2FS_MOUNT_ADAPTIVE 0x00020000
94#define F2FS_MOUNT_LFS 0x00040000
95#define F2FS_MOUNT_USRQUOTA 0x00080000
96#define F2FS_MOUNT_GRPQUOTA 0x00100000
97#define F2FS_MOUNT_PRJQUOTA 0x00200000
98#define F2FS_MOUNT_QUOTA 0x00400000
99#define F2FS_MOUNT_INLINE_XATTR_SIZE 0x00800000
100#define F2FS_MOUNT_RESERVE_ROOT 0x01000000
101#define F2FS_MOUNT_DISABLE_CHECKPOINT 0x02000000
102
103#define F2FS_OPTION(sbi) ((sbi)->mount_opt)
104#define clear_opt(sbi, option) (F2FS_OPTION(sbi).opt &= ~F2FS_MOUNT_##option)
105#define set_opt(sbi, option) (F2FS_OPTION(sbi).opt |= F2FS_MOUNT_##option)
106#define test_opt(sbi, option) (F2FS_OPTION(sbi).opt & F2FS_MOUNT_##option)
107
108#define ver_after(a, b) (typecheck(unsigned long long, a) && \
109 typecheck(unsigned long long, b) && \
110 ((long long)((a) - (b)) > 0))
111
112typedef u32 block_t;
113
114
115
116typedef u32 nid_t;
117
118struct f2fs_mount_info {
119 unsigned int opt;
120 int write_io_size_bits;
121 block_t root_reserved_blocks;
122 kuid_t s_resuid;
123 kgid_t s_resgid;
124 int active_logs;
125 int inline_xattr_size;
126#ifdef CONFIG_F2FS_FAULT_INJECTION
127 struct f2fs_fault_info fault_info;
128#endif
129#ifdef CONFIG_QUOTA
130
131 char *s_qf_names[MAXQUOTAS];
132 int s_jquota_fmt;
133#endif
134
135 int whint_mode;
136 int alloc_mode;
137 int fsync_mode;
138 bool test_dummy_encryption;
139 block_t unusable_cap;
140
141
142};
143
144#define F2FS_FEATURE_ENCRYPT 0x0001
145#define F2FS_FEATURE_BLKZONED 0x0002
146#define F2FS_FEATURE_ATOMIC_WRITE 0x0004
147#define F2FS_FEATURE_EXTRA_ATTR 0x0008
148#define F2FS_FEATURE_PRJQUOTA 0x0010
149#define F2FS_FEATURE_INODE_CHKSUM 0x0020
150#define F2FS_FEATURE_FLEXIBLE_INLINE_XATTR 0x0040
151#define F2FS_FEATURE_QUOTA_INO 0x0080
152#define F2FS_FEATURE_INODE_CRTIME 0x0100
153#define F2FS_FEATURE_LOST_FOUND 0x0200
154#define F2FS_FEATURE_VERITY 0x0400
155#define F2FS_FEATURE_SB_CHKSUM 0x0800
156
157#define __F2FS_HAS_FEATURE(raw_super, mask) \
158 ((raw_super->feature & cpu_to_le32(mask)) != 0)
159#define F2FS_HAS_FEATURE(sbi, mask) __F2FS_HAS_FEATURE(sbi->raw_super, mask)
160#define F2FS_SET_FEATURE(sbi, mask) \
161 (sbi->raw_super->feature |= cpu_to_le32(mask))
162#define F2FS_CLEAR_FEATURE(sbi, mask) \
163 (sbi->raw_super->feature &= ~cpu_to_le32(mask))
164
165
166
167
168#define F2FS_DEF_RESUID 0
169#define F2FS_DEF_RESGID 0
170
171
172
173
174enum {
175 NAT_BITMAP,
176 SIT_BITMAP
177};
178
179#define CP_UMOUNT 0x00000001
180#define CP_FASTBOOT 0x00000002
181#define CP_SYNC 0x00000004
182#define CP_RECOVERY 0x00000008
183#define CP_DISCARD 0x00000010
184#define CP_TRIMMED 0x00000020
185#define CP_PAUSE 0x00000040
186
187#define MAX_DISCARD_BLOCKS(sbi) BLKS_PER_SEC(sbi)
188#define DEF_MAX_DISCARD_REQUEST 8
189#define DEF_MIN_DISCARD_ISSUE_TIME 50
190#define DEF_MID_DISCARD_ISSUE_TIME 500
191#define DEF_MAX_DISCARD_ISSUE_TIME 60000
192#define DEF_DISCARD_URGENT_UTIL 80
193#define DEF_CP_INTERVAL 60
194#define DEF_IDLE_INTERVAL 5
195#define DEF_DISABLE_INTERVAL 5
196#define DEF_DISABLE_QUICK_INTERVAL 1
197#define DEF_UMOUNT_DISCARD_TIMEOUT 5
198
199struct cp_control {
200 int reason;
201 __u64 trim_start;
202 __u64 trim_end;
203 __u64 trim_minlen;
204};
205
206
207
208
209enum {
210 META_CP,
211 META_NAT,
212 META_SIT,
213 META_SSA,
214 META_MAX,
215 META_POR,
216 DATA_GENERIC,
217 DATA_GENERIC_ENHANCE,
218 DATA_GENERIC_ENHANCE_READ,
219
220
221
222
223
224 META_GENERIC,
225};
226
227
228enum {
229 ORPHAN_INO,
230 APPEND_INO,
231 UPDATE_INO,
232 TRANS_DIR_INO,
233 FLUSH_INO,
234 MAX_INO_ENTRY,
235};
236
237struct ino_entry {
238 struct list_head list;
239 nid_t ino;
240 unsigned int dirty_device;
241};
242
243
244struct inode_entry {
245 struct list_head list;
246 struct inode *inode;
247};
248
249struct fsync_node_entry {
250 struct list_head list;
251 struct page *page;
252 unsigned int seq_id;
253};
254
255
256struct discard_entry {
257 struct list_head list;
258 block_t start_blkaddr;
259 unsigned char discard_map[SIT_VBLOCK_MAP_SIZE];
260};
261
262
263#define DEFAULT_DISCARD_GRANULARITY 16
264
265
266#define MAX_PLIST_NUM 512
267#define plist_idx(blk_num) ((blk_num) >= MAX_PLIST_NUM ? \
268 (MAX_PLIST_NUM - 1) : ((blk_num) - 1))
269
270enum {
271 D_PREP,
272 D_PARTIAL,
273 D_SUBMIT,
274 D_DONE,
275};
276
277struct discard_info {
278 block_t lstart;
279 block_t len;
280 block_t start;
281};
282
283struct discard_cmd {
284 struct rb_node rb_node;
285 union {
286 struct {
287 block_t lstart;
288 block_t len;
289 block_t start;
290 };
291 struct discard_info di;
292
293 };
294 struct list_head list;
295 struct completion wait;
296 struct block_device *bdev;
297 unsigned short ref;
298 unsigned char state;
299 unsigned char queued;
300 int error;
301 spinlock_t lock;
302 unsigned short bio_ref;
303};
304
305enum {
306 DPOLICY_BG,
307 DPOLICY_FORCE,
308 DPOLICY_FSTRIM,
309 DPOLICY_UMOUNT,
310 MAX_DPOLICY,
311};
312
313struct discard_policy {
314 int type;
315 unsigned int min_interval;
316 unsigned int mid_interval;
317 unsigned int max_interval;
318 unsigned int max_requests;
319 unsigned int io_aware_gran;
320 bool io_aware;
321 bool sync;
322 bool ordered;
323 unsigned int granularity;
324 int timeout;
325};
326
327struct discard_cmd_control {
328 struct task_struct *f2fs_issue_discard;
329 struct list_head entry_list;
330 struct list_head pend_list[MAX_PLIST_NUM];
331 struct list_head wait_list;
332 struct list_head fstrim_list;
333 wait_queue_head_t discard_wait_queue;
334 unsigned int discard_wake;
335 struct mutex cmd_lock;
336 unsigned int nr_discards;
337 unsigned int max_discards;
338 unsigned int discard_granularity;
339 unsigned int undiscard_blks;
340 unsigned int next_pos;
341 atomic_t issued_discard;
342 atomic_t queued_discard;
343 atomic_t discard_cmd_cnt;
344 struct rb_root_cached root;
345 bool rbtree_check;
346};
347
348
349struct fsync_inode_entry {
350 struct list_head list;
351 struct inode *inode;
352 block_t blkaddr;
353 block_t last_dentry;
354};
355
356#define nats_in_cursum(jnl) (le16_to_cpu((jnl)->n_nats))
357#define sits_in_cursum(jnl) (le16_to_cpu((jnl)->n_sits))
358
359#define nat_in_journal(jnl, i) ((jnl)->nat_j.entries[i].ne)
360#define nid_in_journal(jnl, i) ((jnl)->nat_j.entries[i].nid)
361#define sit_in_journal(jnl, i) ((jnl)->sit_j.entries[i].se)
362#define segno_in_journal(jnl, i) ((jnl)->sit_j.entries[i].segno)
363
364#define MAX_NAT_JENTRIES(jnl) (NAT_JOURNAL_ENTRIES - nats_in_cursum(jnl))
365#define MAX_SIT_JENTRIES(jnl) (SIT_JOURNAL_ENTRIES - sits_in_cursum(jnl))
366
367static inline int update_nats_in_cursum(struct f2fs_journal *journal, int i)
368{
369 int before = nats_in_cursum(journal);
370
371 journal->n_nats = cpu_to_le16(before + i);
372 return before;
373}
374
375static inline int update_sits_in_cursum(struct f2fs_journal *journal, int i)
376{
377 int before = sits_in_cursum(journal);
378
379 journal->n_sits = cpu_to_le16(before + i);
380 return before;
381}
382
383static inline bool __has_cursum_space(struct f2fs_journal *journal,
384 int size, int type)
385{
386 if (type == NAT_JOURNAL)
387 return size <= MAX_NAT_JENTRIES(journal);
388 return size <= MAX_SIT_JENTRIES(journal);
389}
390
391
392
393
394#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS
395#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS
396#define F2FS_IOC_GETVERSION FS_IOC_GETVERSION
397
398#define F2FS_IOCTL_MAGIC 0xf5
399#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1)
400#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2)
401#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3)
402#define F2FS_IOC_RELEASE_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 4)
403#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5)
404#define F2FS_IOC_GARBAGE_COLLECT _IOW(F2FS_IOCTL_MAGIC, 6, __u32)
405#define F2FS_IOC_WRITE_CHECKPOINT _IO(F2FS_IOCTL_MAGIC, 7)
406#define F2FS_IOC_DEFRAGMENT _IOWR(F2FS_IOCTL_MAGIC, 8, \
407 struct f2fs_defragment)
408#define F2FS_IOC_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
409 struct f2fs_move_range)
410#define F2FS_IOC_FLUSH_DEVICE _IOW(F2FS_IOCTL_MAGIC, 10, \
411 struct f2fs_flush_device)
412#define F2FS_IOC_GARBAGE_COLLECT_RANGE _IOW(F2FS_IOCTL_MAGIC, 11, \
413 struct f2fs_gc_range)
414#define F2FS_IOC_GET_FEATURES _IOR(F2FS_IOCTL_MAGIC, 12, __u32)
415#define F2FS_IOC_SET_PIN_FILE _IOW(F2FS_IOCTL_MAGIC, 13, __u32)
416#define F2FS_IOC_GET_PIN_FILE _IOR(F2FS_IOCTL_MAGIC, 14, __u32)
417#define F2FS_IOC_PRECACHE_EXTENTS _IO(F2FS_IOCTL_MAGIC, 15)
418#define F2FS_IOC_RESIZE_FS _IOW(F2FS_IOCTL_MAGIC, 16, __u64)
419
420#define F2FS_IOC_SET_ENCRYPTION_POLICY FS_IOC_SET_ENCRYPTION_POLICY
421#define F2FS_IOC_GET_ENCRYPTION_POLICY FS_IOC_GET_ENCRYPTION_POLICY
422#define F2FS_IOC_GET_ENCRYPTION_PWSALT FS_IOC_GET_ENCRYPTION_PWSALT
423
424
425
426
427
428#define F2FS_IOC_SHUTDOWN _IOR('X', 125, __u32)
429#define F2FS_GOING_DOWN_FULLSYNC 0x0
430#define F2FS_GOING_DOWN_METASYNC 0x1
431#define F2FS_GOING_DOWN_NOSYNC 0x2
432#define F2FS_GOING_DOWN_METAFLUSH 0x3
433#define F2FS_GOING_DOWN_NEED_FSCK 0x4
434
435#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
436
437
438
439#define F2FS_IOC32_GETFLAGS FS_IOC32_GETFLAGS
440#define F2FS_IOC32_SETFLAGS FS_IOC32_SETFLAGS
441#define F2FS_IOC32_GETVERSION FS_IOC32_GETVERSION
442#endif
443
444#define F2FS_IOC_FSGETXATTR FS_IOC_FSGETXATTR
445#define F2FS_IOC_FSSETXATTR FS_IOC_FSSETXATTR
446
447struct f2fs_gc_range {
448 u32 sync;
449 u64 start;
450 u64 len;
451};
452
453struct f2fs_defragment {
454 u64 start;
455 u64 len;
456};
457
458struct f2fs_move_range {
459 u32 dst_fd;
460 u64 pos_in;
461 u64 pos_out;
462 u64 len;
463};
464
465struct f2fs_flush_device {
466 u32 dev_num;
467 u32 segments;
468};
469
470
471#define DEF_INLINE_RESERVED_SIZE 1
472static inline int get_extra_isize(struct inode *inode);
473static inline int get_inline_xattr_addrs(struct inode *inode);
474#define MAX_INLINE_DATA(inode) (sizeof(__le32) * \
475 (CUR_ADDRS_PER_INODE(inode) - \
476 get_inline_xattr_addrs(inode) - \
477 DEF_INLINE_RESERVED_SIZE))
478
479
480#define NR_INLINE_DENTRY(inode) (MAX_INLINE_DATA(inode) * BITS_PER_BYTE / \
481 ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
482 BITS_PER_BYTE + 1))
483#define INLINE_DENTRY_BITMAP_SIZE(inode) \
484 DIV_ROUND_UP(NR_INLINE_DENTRY(inode), BITS_PER_BYTE)
485#define INLINE_RESERVED_SIZE(inode) (MAX_INLINE_DATA(inode) - \
486 ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
487 NR_INLINE_DENTRY(inode) + \
488 INLINE_DENTRY_BITMAP_SIZE(inode)))
489
490
491
492
493
494struct f2fs_dentry_ptr {
495 struct inode *inode;
496 void *bitmap;
497 struct f2fs_dir_entry *dentry;
498 __u8 (*filename)[F2FS_SLOT_LEN];
499 int max;
500 int nr_bitmap;
501};
502
503static inline void make_dentry_ptr_block(struct inode *inode,
504 struct f2fs_dentry_ptr *d, struct f2fs_dentry_block *t)
505{
506 d->inode = inode;
507 d->max = NR_DENTRY_IN_BLOCK;
508 d->nr_bitmap = SIZE_OF_DENTRY_BITMAP;
509 d->bitmap = t->dentry_bitmap;
510 d->dentry = t->dentry;
511 d->filename = t->filename;
512}
513
514static inline void make_dentry_ptr_inline(struct inode *inode,
515 struct f2fs_dentry_ptr *d, void *t)
516{
517 int entry_cnt = NR_INLINE_DENTRY(inode);
518 int bitmap_size = INLINE_DENTRY_BITMAP_SIZE(inode);
519 int reserved_size = INLINE_RESERVED_SIZE(inode);
520
521 d->inode = inode;
522 d->max = entry_cnt;
523 d->nr_bitmap = bitmap_size;
524 d->bitmap = t;
525 d->dentry = t + bitmap_size + reserved_size;
526 d->filename = t + bitmap_size + reserved_size +
527 SIZE_OF_DIR_ENTRY * entry_cnt;
528}
529
530
531
532
533
534
535#define XATTR_NODE_OFFSET ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
536 >> OFFSET_BIT_SHIFT)
537enum {
538 ALLOC_NODE,
539 LOOKUP_NODE,
540 LOOKUP_NODE_RA,
541
542
543
544};
545
546#define DEFAULT_RETRY_IO_COUNT 8
547
548
549#define DEFAULT_RETRY_QUOTA_FLUSH_COUNT 8
550
551#define F2FS_LINK_MAX 0xffffffff
552
553#define MAX_DIR_RA_PAGES 4
554
555
556#define F2FS_MIN_EXTENT_LEN 64
557
558
559#define EXTENT_CACHE_SHRINK_NUMBER 128
560
561struct rb_entry {
562 struct rb_node rb_node;
563 unsigned int ofs;
564 unsigned int len;
565};
566
567struct extent_info {
568 unsigned int fofs;
569 unsigned int len;
570 u32 blk;
571};
572
573struct extent_node {
574 struct rb_node rb_node;
575 struct extent_info ei;
576 struct list_head list;
577 struct extent_tree *et;
578};
579
580struct extent_tree {
581 nid_t ino;
582 struct rb_root_cached root;
583 struct extent_node *cached_en;
584 struct extent_info largest;
585 struct list_head list;
586 rwlock_t lock;
587 atomic_t node_cnt;
588 bool largest_updated;
589};
590
591
592
593
594
595
596#define F2FS_MAP_NEW (1 << BH_New)
597#define F2FS_MAP_MAPPED (1 << BH_Mapped)
598#define F2FS_MAP_UNWRITTEN (1 << BH_Unwritten)
599#define F2FS_MAP_FLAGS (F2FS_MAP_NEW | F2FS_MAP_MAPPED |\
600 F2FS_MAP_UNWRITTEN)
601
602struct f2fs_map_blocks {
603 block_t m_pblk;
604 block_t m_lblk;
605 unsigned int m_len;
606 unsigned int m_flags;
607 pgoff_t *m_next_pgofs;
608 pgoff_t *m_next_extent;
609 int m_seg_type;
610 bool m_may_create;
611};
612
613
614enum {
615 F2FS_GET_BLOCK_DEFAULT,
616 F2FS_GET_BLOCK_FIEMAP,
617 F2FS_GET_BLOCK_BMAP,
618 F2FS_GET_BLOCK_DIO,
619 F2FS_GET_BLOCK_PRE_DIO,
620 F2FS_GET_BLOCK_PRE_AIO,
621 F2FS_GET_BLOCK_PRECACHE,
622};
623
624
625
626
627#define FADVISE_COLD_BIT 0x01
628#define FADVISE_LOST_PINO_BIT 0x02
629#define FADVISE_ENCRYPT_BIT 0x04
630#define FADVISE_ENC_NAME_BIT 0x08
631#define FADVISE_KEEP_SIZE_BIT 0x10
632#define FADVISE_HOT_BIT 0x20
633#define FADVISE_VERITY_BIT 0x40
634
635#define FADVISE_MODIFIABLE_BITS (FADVISE_COLD_BIT | FADVISE_HOT_BIT)
636
637#define file_is_cold(inode) is_file(inode, FADVISE_COLD_BIT)
638#define file_wrong_pino(inode) is_file(inode, FADVISE_LOST_PINO_BIT)
639#define file_set_cold(inode) set_file(inode, FADVISE_COLD_BIT)
640#define file_lost_pino(inode) set_file(inode, FADVISE_LOST_PINO_BIT)
641#define file_clear_cold(inode) clear_file(inode, FADVISE_COLD_BIT)
642#define file_got_pino(inode) clear_file(inode, FADVISE_LOST_PINO_BIT)
643#define file_is_encrypt(inode) is_file(inode, FADVISE_ENCRYPT_BIT)
644#define file_set_encrypt(inode) set_file(inode, FADVISE_ENCRYPT_BIT)
645#define file_clear_encrypt(inode) clear_file(inode, FADVISE_ENCRYPT_BIT)
646#define file_enc_name(inode) is_file(inode, FADVISE_ENC_NAME_BIT)
647#define file_set_enc_name(inode) set_file(inode, FADVISE_ENC_NAME_BIT)
648#define file_keep_isize(inode) is_file(inode, FADVISE_KEEP_SIZE_BIT)
649#define file_set_keep_isize(inode) set_file(inode, FADVISE_KEEP_SIZE_BIT)
650#define file_is_hot(inode) is_file(inode, FADVISE_HOT_BIT)
651#define file_set_hot(inode) set_file(inode, FADVISE_HOT_BIT)
652#define file_clear_hot(inode) clear_file(inode, FADVISE_HOT_BIT)
653
654#define DEF_DIR_LEVEL 0
655
656enum {
657 GC_FAILURE_PIN,
658 GC_FAILURE_ATOMIC,
659 MAX_GC_FAILURE
660};
661
662struct f2fs_inode_info {
663 struct inode vfs_inode;
664 unsigned long i_flags;
665 unsigned char i_advise;
666 unsigned char i_dir_level;
667 unsigned int i_current_depth;
668
669 unsigned int i_gc_failures[MAX_GC_FAILURE];
670 unsigned int i_pino;
671 umode_t i_acl_mode;
672
673
674 unsigned long flags;
675 struct rw_semaphore i_sem;
676 atomic_t dirty_pages;
677 f2fs_hash_t chash;
678 unsigned int clevel;
679 struct task_struct *task;
680 struct task_struct *cp_task;
681 nid_t i_xattr_nid;
682 loff_t last_disk_size;
683
684#ifdef CONFIG_QUOTA
685 struct dquot *i_dquot[MAXQUOTAS];
686
687
688 qsize_t i_reserved_quota;
689#endif
690 struct list_head dirty_list;
691 struct list_head gdirty_list;
692 struct list_head inmem_ilist;
693 struct list_head inmem_pages;
694 struct task_struct *inmem_task;
695 struct mutex inmem_lock;
696 struct extent_tree *extent_tree;
697
698
699 struct rw_semaphore i_gc_rwsem[2];
700 struct rw_semaphore i_mmap_sem;
701 struct rw_semaphore i_xattr_sem;
702
703 int i_extra_isize;
704 kprojid_t i_projid;
705 int i_inline_xattr_size;
706 struct timespec64 i_crtime;
707 struct timespec64 i_disk_time[4];
708};
709
710static inline void get_extent_info(struct extent_info *ext,
711 struct f2fs_extent *i_ext)
712{
713 ext->fofs = le32_to_cpu(i_ext->fofs);
714 ext->blk = le32_to_cpu(i_ext->blk);
715 ext->len = le32_to_cpu(i_ext->len);
716}
717
718static inline void set_raw_extent(struct extent_info *ext,
719 struct f2fs_extent *i_ext)
720{
721 i_ext->fofs = cpu_to_le32(ext->fofs);
722 i_ext->blk = cpu_to_le32(ext->blk);
723 i_ext->len = cpu_to_le32(ext->len);
724}
725
726static inline void set_extent_info(struct extent_info *ei, unsigned int fofs,
727 u32 blk, unsigned int len)
728{
729 ei->fofs = fofs;
730 ei->blk = blk;
731 ei->len = len;
732}
733
734static inline bool __is_discard_mergeable(struct discard_info *back,
735 struct discard_info *front, unsigned int max_len)
736{
737 return (back->lstart + back->len == front->lstart) &&
738 (back->len + front->len <= max_len);
739}
740
741static inline bool __is_discard_back_mergeable(struct discard_info *cur,
742 struct discard_info *back, unsigned int max_len)
743{
744 return __is_discard_mergeable(back, cur, max_len);
745}
746
747static inline bool __is_discard_front_mergeable(struct discard_info *cur,
748 struct discard_info *front, unsigned int max_len)
749{
750 return __is_discard_mergeable(cur, front, max_len);
751}
752
753static inline bool __is_extent_mergeable(struct extent_info *back,
754 struct extent_info *front)
755{
756 return (back->fofs + back->len == front->fofs &&
757 back->blk + back->len == front->blk);
758}
759
760static inline bool __is_back_mergeable(struct extent_info *cur,
761 struct extent_info *back)
762{
763 return __is_extent_mergeable(back, cur);
764}
765
766static inline bool __is_front_mergeable(struct extent_info *cur,
767 struct extent_info *front)
768{
769 return __is_extent_mergeable(cur, front);
770}
771
772extern void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync);
773static inline void __try_update_largest_extent(struct extent_tree *et,
774 struct extent_node *en)
775{
776 if (en->ei.len > et->largest.len) {
777 et->largest = en->ei;
778 et->largest_updated = true;
779 }
780}
781
782
783
784
785enum nid_state {
786 FREE_NID,
787 PREALLOC_NID,
788 MAX_NID_STATE,
789};
790
791struct f2fs_nm_info {
792 block_t nat_blkaddr;
793 nid_t max_nid;
794 nid_t available_nids;
795 nid_t next_scan_nid;
796 unsigned int ram_thresh;
797 unsigned int ra_nid_pages;
798 unsigned int dirty_nats_ratio;
799
800
801 struct radix_tree_root nat_root;
802 struct radix_tree_root nat_set_root;
803 struct rw_semaphore nat_tree_lock;
804 struct list_head nat_entries;
805 spinlock_t nat_list_lock;
806 unsigned int nat_cnt;
807 unsigned int dirty_nat_cnt;
808 unsigned int nat_blocks;
809
810
811 struct radix_tree_root free_nid_root;
812 struct list_head free_nid_list;
813 unsigned int nid_cnt[MAX_NID_STATE];
814 spinlock_t nid_list_lock;
815 struct mutex build_lock;
816 unsigned char **free_nid_bitmap;
817 unsigned char *nat_block_bitmap;
818 unsigned short *free_nid_count;
819
820
821 char *nat_bitmap;
822
823 unsigned int nat_bits_blocks;
824 unsigned char *nat_bits;
825 unsigned char *full_nat_bits;
826 unsigned char *empty_nat_bits;
827#ifdef CONFIG_F2FS_CHECK_FS
828 char *nat_bitmap_mir;
829#endif
830 int bitmap_size;
831};
832
833
834
835
836
837
838struct dnode_of_data {
839 struct inode *inode;
840 struct page *inode_page;
841 struct page *node_page;
842 nid_t nid;
843 unsigned int ofs_in_node;
844 bool inode_page_locked;
845 bool node_changed;
846 char cur_level;
847 char max_level;
848 block_t data_blkaddr;
849};
850
851static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
852 struct page *ipage, struct page *npage, nid_t nid)
853{
854 memset(dn, 0, sizeof(*dn));
855 dn->inode = inode;
856 dn->inode_page = ipage;
857 dn->node_page = npage;
858 dn->nid = nid;
859}
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874#define NR_CURSEG_DATA_TYPE (3)
875#define NR_CURSEG_NODE_TYPE (3)
876#define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
877
878enum {
879 CURSEG_HOT_DATA = 0,
880 CURSEG_WARM_DATA,
881 CURSEG_COLD_DATA,
882 CURSEG_HOT_NODE,
883 CURSEG_WARM_NODE,
884 CURSEG_COLD_NODE,
885 NO_CHECK_TYPE,
886};
887
888struct flush_cmd {
889 struct completion wait;
890 struct llist_node llnode;
891 nid_t ino;
892 int ret;
893};
894
895struct flush_cmd_control {
896 struct task_struct *f2fs_issue_flush;
897 wait_queue_head_t flush_wait_queue;
898 atomic_t issued_flush;
899 atomic_t queued_flush;
900 struct llist_head issue_list;
901 struct llist_node *dispatch_list;
902};
903
904struct f2fs_sm_info {
905 struct sit_info *sit_info;
906 struct free_segmap_info *free_info;
907 struct dirty_seglist_info *dirty_info;
908 struct curseg_info *curseg_array;
909
910 struct rw_semaphore curseg_lock;
911
912 block_t seg0_blkaddr;
913 block_t main_blkaddr;
914 block_t ssa_blkaddr;
915
916 unsigned int segment_count;
917 unsigned int main_segments;
918 unsigned int reserved_segments;
919 unsigned int ovp_segments;
920
921
922 unsigned int rec_prefree_segments;
923
924
925 unsigned int trim_sections;
926
927 struct list_head sit_entry_set;
928
929 unsigned int ipu_policy;
930 unsigned int min_ipu_util;
931 unsigned int min_fsync_blocks;
932 unsigned int min_seq_blocks;
933 unsigned int min_hot_blocks;
934 unsigned int min_ssr_sections;
935
936
937 struct flush_cmd_control *fcc_info;
938
939
940 struct discard_cmd_control *dcc_info;
941};
942
943
944
945
946
947
948
949
950
951
952#define WB_DATA_TYPE(p) (__is_cp_guaranteed(p) ? F2FS_WB_CP_DATA : F2FS_WB_DATA)
953enum count_type {
954 F2FS_DIRTY_DENTS,
955 F2FS_DIRTY_DATA,
956 F2FS_DIRTY_QDATA,
957 F2FS_DIRTY_NODES,
958 F2FS_DIRTY_META,
959 F2FS_INMEM_PAGES,
960 F2FS_DIRTY_IMETA,
961 F2FS_WB_CP_DATA,
962 F2FS_WB_DATA,
963 F2FS_RD_DATA,
964 F2FS_RD_NODE,
965 F2FS_RD_META,
966 F2FS_DIO_WRITE,
967 F2FS_DIO_READ,
968 NR_COUNT_TYPE,
969};
970
971
972
973
974
975
976
977
978
979
980
981
982#define PAGE_TYPE_OF_BIO(type) ((type) > META ? META : (type))
983enum page_type {
984 DATA,
985 NODE,
986 META,
987 NR_PAGE_TYPE,
988 META_FLUSH,
989 INMEM,
990 INMEM_DROP,
991 INMEM_INVALIDATE,
992 INMEM_REVOKE,
993 IPU,
994 OPU,
995};
996
997enum temp_type {
998 HOT = 0,
999 WARM,
1000 COLD,
1001 NR_TEMP_TYPE,
1002};
1003
1004enum need_lock_type {
1005 LOCK_REQ = 0,
1006 LOCK_DONE,
1007 LOCK_RETRY,
1008};
1009
1010enum cp_reason_type {
1011 CP_NO_NEEDED,
1012 CP_NON_REGULAR,
1013 CP_HARDLINK,
1014 CP_SB_NEED_CP,
1015 CP_WRONG_PINO,
1016 CP_NO_SPC_ROLL,
1017 CP_NODE_NEED_CP,
1018 CP_FASTBOOT_MODE,
1019 CP_SPEC_LOG_NUM,
1020 CP_RECOVER_DIR,
1021};
1022
1023enum iostat_type {
1024 APP_DIRECT_IO,
1025 APP_BUFFERED_IO,
1026 APP_WRITE_IO,
1027 APP_MAPPED_IO,
1028 FS_DATA_IO,
1029 FS_NODE_IO,
1030 FS_META_IO,
1031 FS_GC_DATA_IO,
1032 FS_GC_NODE_IO,
1033 FS_CP_DATA_IO,
1034 FS_CP_NODE_IO,
1035 FS_CP_META_IO,
1036 FS_DISCARD,
1037 NR_IO_TYPE,
1038};
1039
1040struct f2fs_io_info {
1041 struct f2fs_sb_info *sbi;
1042 nid_t ino;
1043 enum page_type type;
1044 enum temp_type temp;
1045 int op;
1046 int op_flags;
1047 block_t new_blkaddr;
1048 block_t old_blkaddr;
1049 struct page *page;
1050 struct page *encrypted_page;
1051 struct list_head list;
1052 bool submitted;
1053 int need_lock;
1054 bool in_list;
1055 bool is_por;
1056 bool retry;
1057 enum iostat_type io_type;
1058 struct writeback_control *io_wbc;
1059 struct bio **bio;
1060 sector_t *last_block;
1061 unsigned char version;
1062};
1063
1064#define is_read_io(rw) ((rw) == READ)
1065struct f2fs_bio_info {
1066 struct f2fs_sb_info *sbi;
1067 struct bio *bio;
1068 sector_t last_block_in_bio;
1069 struct f2fs_io_info fio;
1070 struct rw_semaphore io_rwsem;
1071 spinlock_t io_lock;
1072 struct list_head io_list;
1073};
1074
1075#define FDEV(i) (sbi->devs[i])
1076#define RDEV(i) (raw_super->devs[i])
1077struct f2fs_dev_info {
1078 struct block_device *bdev;
1079 char path[MAX_PATH_LEN];
1080 unsigned int total_segments;
1081 block_t start_blk;
1082 block_t end_blk;
1083#ifdef CONFIG_BLK_DEV_ZONED
1084 unsigned int nr_blkz;
1085 unsigned long *blkz_seq;
1086#endif
1087};
1088
1089enum inode_type {
1090 DIR_INODE,
1091 FILE_INODE,
1092 DIRTY_META,
1093 ATOMIC_FILE,
1094 NR_INODE_TYPE,
1095};
1096
1097
1098struct inode_management {
1099 struct radix_tree_root ino_root;
1100 spinlock_t ino_lock;
1101 struct list_head ino_list;
1102 unsigned long ino_num;
1103};
1104
1105
1106enum {
1107 SBI_IS_DIRTY,
1108 SBI_IS_CLOSE,
1109 SBI_NEED_FSCK,
1110 SBI_POR_DOING,
1111 SBI_NEED_SB_WRITE,
1112 SBI_NEED_CP,
1113 SBI_IS_SHUTDOWN,
1114 SBI_IS_RECOVERED,
1115 SBI_CP_DISABLED,
1116 SBI_CP_DISABLED_QUICK,
1117 SBI_QUOTA_NEED_FLUSH,
1118 SBI_QUOTA_SKIP_FLUSH,
1119 SBI_QUOTA_NEED_REPAIR,
1120 SBI_IS_RESIZEFS,
1121};
1122
1123enum {
1124 CP_TIME,
1125 REQ_TIME,
1126 DISCARD_TIME,
1127 GC_TIME,
1128 DISABLE_TIME,
1129 UMOUNT_DISCARD_TIMEOUT,
1130 MAX_TIME,
1131};
1132
1133enum {
1134 GC_NORMAL,
1135 GC_IDLE_CB,
1136 GC_IDLE_GREEDY,
1137 GC_URGENT,
1138};
1139
1140enum {
1141 WHINT_MODE_OFF,
1142 WHINT_MODE_USER,
1143 WHINT_MODE_FS,
1144};
1145
1146enum {
1147 ALLOC_MODE_DEFAULT,
1148 ALLOC_MODE_REUSE,
1149};
1150
1151enum fsync_mode {
1152 FSYNC_MODE_POSIX,
1153 FSYNC_MODE_STRICT,
1154 FSYNC_MODE_NOBARRIER,
1155};
1156
1157#ifdef CONFIG_FS_ENCRYPTION
1158#define DUMMY_ENCRYPTION_ENABLED(sbi) \
1159 (unlikely(F2FS_OPTION(sbi).test_dummy_encryption))
1160#else
1161#define DUMMY_ENCRYPTION_ENABLED(sbi) (0)
1162#endif
1163
1164struct f2fs_sb_info {
1165 struct super_block *sb;
1166 struct proc_dir_entry *s_proc;
1167 struct f2fs_super_block *raw_super;
1168 struct rw_semaphore sb_lock;
1169 int valid_super_block;
1170 unsigned long s_flag;
1171 struct mutex writepages;
1172
1173#ifdef CONFIG_BLK_DEV_ZONED
1174 unsigned int blocks_per_blkz;
1175 unsigned int log_blocks_per_blkz;
1176#endif
1177
1178
1179 struct f2fs_nm_info *nm_info;
1180 struct inode *node_inode;
1181
1182
1183 struct f2fs_sm_info *sm_info;
1184
1185
1186 struct f2fs_bio_info *write_io[NR_PAGE_TYPE];
1187
1188 struct rw_semaphore io_order_lock;
1189 mempool_t *write_io_dummy;
1190
1191
1192 struct f2fs_checkpoint *ckpt;
1193 int cur_cp_pack;
1194 spinlock_t cp_lock;
1195 struct inode *meta_inode;
1196 struct mutex cp_mutex;
1197 struct rw_semaphore cp_rwsem;
1198 struct rw_semaphore node_write;
1199 struct rw_semaphore node_change;
1200 wait_queue_head_t cp_wait;
1201 unsigned long last_time[MAX_TIME];
1202 long interval_time[MAX_TIME];
1203
1204 struct inode_management im[MAX_INO_ENTRY];
1205
1206 spinlock_t fsync_node_lock;
1207 struct list_head fsync_node_list;
1208 unsigned int fsync_seg_id;
1209 unsigned int fsync_node_num;
1210
1211
1212 unsigned int max_orphans;
1213
1214
1215 struct list_head inode_list[NR_INODE_TYPE];
1216 spinlock_t inode_lock[NR_INODE_TYPE];
1217 struct mutex flush_lock;
1218
1219
1220 struct radix_tree_root extent_tree_root;
1221 struct mutex extent_tree_lock;
1222 struct list_head extent_list;
1223 spinlock_t extent_lock;
1224 atomic_t total_ext_tree;
1225 struct list_head zombie_list;
1226 atomic_t total_zombie_tree;
1227 atomic_t total_ext_node;
1228
1229
1230 unsigned int log_sectors_per_block;
1231 unsigned int log_blocksize;
1232 unsigned int blocksize;
1233 unsigned int root_ino_num;
1234 unsigned int node_ino_num;
1235 unsigned int meta_ino_num;
1236 unsigned int log_blocks_per_seg;
1237 unsigned int blocks_per_seg;
1238 unsigned int segs_per_sec;
1239 unsigned int secs_per_zone;
1240 unsigned int total_sections;
1241 struct mutex resize_mutex;
1242 unsigned int total_node_count;
1243 unsigned int total_valid_node_count;
1244 loff_t max_file_blocks;
1245 int dir_level;
1246 int readdir_ra;
1247
1248 block_t user_block_count;
1249 block_t total_valid_block_count;
1250 block_t discard_blks;
1251 block_t last_valid_block_count;
1252 block_t reserved_blocks;
1253 block_t current_reserved_blocks;
1254
1255
1256 block_t unusable_block_count;
1257
1258 unsigned int nquota_files;
1259 struct rw_semaphore quota_sem;
1260
1261
1262 atomic_t nr_pages[NR_COUNT_TYPE];
1263
1264 struct percpu_counter alloc_valid_block_count;
1265
1266
1267 atomic_t wb_sync_req[META];
1268
1269
1270 struct percpu_counter total_valid_inode_count;
1271
1272 struct f2fs_mount_info mount_opt;
1273
1274
1275 struct mutex gc_mutex;
1276 struct f2fs_gc_kthread *gc_thread;
1277 unsigned int cur_victim_sec;
1278 unsigned int gc_mode;
1279 unsigned int next_victim_seg[2];
1280
1281 unsigned long long skipped_atomic_files[2];
1282 unsigned long long skipped_gc_rwsem;
1283
1284
1285 u64 gc_pin_file_threshold;
1286
1287
1288 unsigned int max_victim_search;
1289
1290 unsigned int migration_granularity;
1291
1292
1293
1294
1295
1296#ifdef CONFIG_F2FS_STAT_FS
1297 struct f2fs_stat_info *stat_info;
1298 atomic_t meta_count[META_MAX];
1299 unsigned int segment_count[2];
1300 unsigned int block_count[2];
1301 atomic_t inplace_count;
1302 atomic64_t total_hit_ext;
1303 atomic64_t read_hit_rbtree;
1304 atomic64_t read_hit_largest;
1305 atomic64_t read_hit_cached;
1306 atomic_t inline_xattr;
1307 atomic_t inline_inode;
1308 atomic_t inline_dir;
1309 atomic_t aw_cnt;
1310 atomic_t vw_cnt;
1311 atomic_t max_aw_cnt;
1312 atomic_t max_vw_cnt;
1313 int bg_gc;
1314 unsigned int io_skip_bggc;
1315 unsigned int other_skip_bggc;
1316 unsigned int ndirty_inode[NR_INODE_TYPE];
1317#endif
1318 spinlock_t stat_lock;
1319
1320
1321 spinlock_t iostat_lock;
1322 unsigned long long write_iostat[NR_IO_TYPE];
1323 bool iostat_enable;
1324
1325
1326 struct kobject s_kobj;
1327 struct completion s_kobj_unregister;
1328
1329
1330 struct list_head s_list;
1331 int s_ndevs;
1332 struct f2fs_dev_info *devs;
1333 unsigned int dirty_device;
1334 spinlock_t dev_lock;
1335 struct mutex umount_mutex;
1336 unsigned int shrinker_run_no;
1337
1338
1339 u64 sectors_written_start;
1340 u64 kbytes_written;
1341
1342
1343 struct crypto_shash *s_chksum_driver;
1344
1345
1346 __u32 s_chksum_seed;
1347};
1348
1349struct f2fs_private_dio {
1350 struct inode *inode;
1351 void *orig_private;
1352 bio_end_io_t *orig_end_io;
1353 bool write;
1354};
1355
1356#ifdef CONFIG_F2FS_FAULT_INJECTION
1357#define f2fs_show_injection_info(type) \
1358 printk_ratelimited("%sF2FS-fs : inject %s in %s of %pS\n", \
1359 KERN_INFO, f2fs_fault_name[type], \
1360 __func__, __builtin_return_address(0))
1361static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
1362{
1363 struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;
1364
1365 if (!ffi->inject_rate)
1366 return false;
1367
1368 if (!IS_FAULT_SET(ffi, type))
1369 return false;
1370
1371 atomic_inc(&ffi->inject_ops);
1372 if (atomic_read(&ffi->inject_ops) >= ffi->inject_rate) {
1373 atomic_set(&ffi->inject_ops, 0);
1374 return true;
1375 }
1376 return false;
1377}
1378#else
1379#define f2fs_show_injection_info(type) do { } while (0)
1380static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
1381{
1382 return false;
1383}
1384#endif
1385
1386
1387
1388
1389
1390
1391
1392static inline bool f2fs_is_multi_device(struct f2fs_sb_info *sbi)
1393{
1394 return sbi->s_ndevs > 1;
1395}
1396
1397
1398
1399
1400#define BD_PART_WRITTEN(s) \
1401(((u64)part_stat_read((s)->sb->s_bdev->bd_part, sectors[STAT_WRITE]) - \
1402 (s)->sectors_written_start) >> 1)
1403
1404static inline void f2fs_update_time(struct f2fs_sb_info *sbi, int type)
1405{
1406 unsigned long now = jiffies;
1407
1408 sbi->last_time[type] = now;
1409
1410
1411 if (type == REQ_TIME) {
1412 sbi->last_time[DISCARD_TIME] = now;
1413 sbi->last_time[GC_TIME] = now;
1414 }
1415}
1416
1417static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)
1418{
1419 unsigned long interval = sbi->interval_time[type] * HZ;
1420
1421 return time_after(jiffies, sbi->last_time[type] + interval);
1422}
1423
1424static inline unsigned int f2fs_time_to_wait(struct f2fs_sb_info *sbi,
1425 int type)
1426{
1427 unsigned long interval = sbi->interval_time[type] * HZ;
1428 unsigned int wait_ms = 0;
1429 long delta;
1430
1431 delta = (sbi->last_time[type] + interval) - jiffies;
1432 if (delta > 0)
1433 wait_ms = jiffies_to_msecs(delta);
1434
1435 return wait_ms;
1436}
1437
1438
1439
1440
1441static inline u32 __f2fs_crc32(struct f2fs_sb_info *sbi, u32 crc,
1442 const void *address, unsigned int length)
1443{
1444 struct {
1445 struct shash_desc shash;
1446 char ctx[4];
1447 } desc;
1448 int err;
1449
1450 BUG_ON(crypto_shash_descsize(sbi->s_chksum_driver) != sizeof(desc.ctx));
1451
1452 desc.shash.tfm = sbi->s_chksum_driver;
1453 *(u32 *)desc.ctx = crc;
1454
1455 err = crypto_shash_update(&desc.shash, address, length);
1456 BUG_ON(err);
1457
1458 return *(u32 *)desc.ctx;
1459}
1460
1461static inline u32 f2fs_crc32(struct f2fs_sb_info *sbi, const void *address,
1462 unsigned int length)
1463{
1464 return __f2fs_crc32(sbi, F2FS_SUPER_MAGIC, address, length);
1465}
1466
1467static inline bool f2fs_crc_valid(struct f2fs_sb_info *sbi, __u32 blk_crc,
1468 void *buf, size_t buf_size)
1469{
1470 return f2fs_crc32(sbi, buf, buf_size) == blk_crc;
1471}
1472
1473static inline u32 f2fs_chksum(struct f2fs_sb_info *sbi, u32 crc,
1474 const void *address, unsigned int length)
1475{
1476 return __f2fs_crc32(sbi, crc, address, length);
1477}
1478
1479static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
1480{
1481 return container_of(inode, struct f2fs_inode_info, vfs_inode);
1482}
1483
1484static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
1485{
1486 return sb->s_fs_info;
1487}
1488
1489static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)
1490{
1491 return F2FS_SB(inode->i_sb);
1492}
1493
1494static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping)
1495{
1496 return F2FS_I_SB(mapping->host);
1497}
1498
1499static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page)
1500{
1501 return F2FS_M_SB(page_file_mapping(page));
1502}
1503
1504static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
1505{
1506 return (struct f2fs_super_block *)(sbi->raw_super);
1507}
1508
1509static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
1510{
1511 return (struct f2fs_checkpoint *)(sbi->ckpt);
1512}
1513
1514static inline struct f2fs_node *F2FS_NODE(struct page *page)
1515{
1516 return (struct f2fs_node *)page_address(page);
1517}
1518
1519static inline struct f2fs_inode *F2FS_INODE(struct page *page)
1520{
1521 return &((struct f2fs_node *)page_address(page))->i;
1522}
1523
1524static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
1525{
1526 return (struct f2fs_nm_info *)(sbi->nm_info);
1527}
1528
1529static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
1530{
1531 return (struct f2fs_sm_info *)(sbi->sm_info);
1532}
1533
1534static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
1535{
1536 return (struct sit_info *)(SM_I(sbi)->sit_info);
1537}
1538
1539static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
1540{
1541 return (struct free_segmap_info *)(SM_I(sbi)->free_info);
1542}
1543
1544static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
1545{
1546 return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
1547}
1548
1549static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
1550{
1551 return sbi->meta_inode->i_mapping;
1552}
1553
1554static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
1555{
1556 return sbi->node_inode->i_mapping;
1557}
1558
1559static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)
1560{
1561 return test_bit(type, &sbi->s_flag);
1562}
1563
1564static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
1565{
1566 set_bit(type, &sbi->s_flag);
1567}
1568
1569static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
1570{
1571 clear_bit(type, &sbi->s_flag);
1572}
1573
1574static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
1575{
1576 return le64_to_cpu(cp->checkpoint_ver);
1577}
1578
1579static inline unsigned long f2fs_qf_ino(struct super_block *sb, int type)
1580{
1581 if (type < F2FS_MAX_QUOTAS)
1582 return le32_to_cpu(F2FS_SB(sb)->raw_super->qf_ino[type]);
1583 return 0;
1584}
1585
1586static inline __u64 cur_cp_crc(struct f2fs_checkpoint *cp)
1587{
1588 size_t crc_offset = le32_to_cpu(cp->checksum_offset);
1589 return le32_to_cpu(*((__le32 *)((unsigned char *)cp + crc_offset)));
1590}
1591
1592static inline bool __is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1593{
1594 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
1595
1596 return ckpt_flags & f;
1597}
1598
1599static inline bool is_set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
1600{
1601 return __is_set_ckpt_flags(F2FS_CKPT(sbi), f);
1602}
1603
1604static inline void __set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1605{
1606 unsigned int ckpt_flags;
1607
1608 ckpt_flags = le32_to_cpu(cp->ckpt_flags);
1609 ckpt_flags |= f;
1610 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
1611}
1612
1613static inline void set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
1614{
1615 unsigned long flags;
1616
1617 spin_lock_irqsave(&sbi->cp_lock, flags);
1618 __set_ckpt_flags(F2FS_CKPT(sbi), f);
1619 spin_unlock_irqrestore(&sbi->cp_lock, flags);
1620}
1621
1622static inline void __clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1623{
1624 unsigned int ckpt_flags;
1625
1626 ckpt_flags = le32_to_cpu(cp->ckpt_flags);
1627 ckpt_flags &= (~f);
1628 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
1629}
1630
1631static inline void clear_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
1632{
1633 unsigned long flags;
1634
1635 spin_lock_irqsave(&sbi->cp_lock, flags);
1636 __clear_ckpt_flags(F2FS_CKPT(sbi), f);
1637 spin_unlock_irqrestore(&sbi->cp_lock, flags);
1638}
1639
1640static inline void disable_nat_bits(struct f2fs_sb_info *sbi, bool lock)
1641{
1642 unsigned long flags;
1643
1644
1645
1646
1647
1648
1649
1650 if (lock)
1651 spin_lock_irqsave(&sbi->cp_lock, flags);
1652 __clear_ckpt_flags(F2FS_CKPT(sbi), CP_NAT_BITS_FLAG);
1653 kvfree(NM_I(sbi)->nat_bits);
1654 NM_I(sbi)->nat_bits = NULL;
1655 if (lock)
1656 spin_unlock_irqrestore(&sbi->cp_lock, flags);
1657}
1658
1659static inline bool enabled_nat_bits(struct f2fs_sb_info *sbi,
1660 struct cp_control *cpc)
1661{
1662 bool set = is_set_ckpt_flags(sbi, CP_NAT_BITS_FLAG);
1663
1664 return (cpc) ? (cpc->reason & CP_UMOUNT) && set : set;
1665}
1666
1667static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
1668{
1669 down_read(&sbi->cp_rwsem);
1670}
1671
1672static inline int f2fs_trylock_op(struct f2fs_sb_info *sbi)
1673{
1674 return down_read_trylock(&sbi->cp_rwsem);
1675}
1676
1677static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
1678{
1679 up_read(&sbi->cp_rwsem);
1680}
1681
1682static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
1683{
1684 down_write(&sbi->cp_rwsem);
1685}
1686
1687static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
1688{
1689 up_write(&sbi->cp_rwsem);
1690}
1691
1692static inline int __get_cp_reason(struct f2fs_sb_info *sbi)
1693{
1694 int reason = CP_SYNC;
1695
1696 if (test_opt(sbi, FASTBOOT))
1697 reason = CP_FASTBOOT;
1698 if (is_sbi_flag_set(sbi, SBI_IS_CLOSE))
1699 reason = CP_UMOUNT;
1700 return reason;
1701}
1702
1703static inline bool __remain_node_summaries(int reason)
1704{
1705 return (reason & (CP_UMOUNT | CP_FASTBOOT));
1706}
1707
1708static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)
1709{
1710 return (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG) ||
1711 is_set_ckpt_flags(sbi, CP_FASTBOOT_FLAG));
1712}
1713
1714
1715
1716
1717static inline int F2FS_HAS_BLOCKS(struct inode *inode)
1718{
1719 block_t xattr_block = F2FS_I(inode)->i_xattr_nid ? 1 : 0;
1720
1721 return (inode->i_blocks >> F2FS_LOG_SECTORS_PER_BLOCK) > xattr_block;
1722}
1723
1724static inline bool f2fs_has_xattr_block(unsigned int ofs)
1725{
1726 return ofs == XATTR_NODE_OFFSET;
1727}
1728
1729static inline bool __allow_reserved_blocks(struct f2fs_sb_info *sbi,
1730 struct inode *inode, bool cap)
1731{
1732 if (!inode)
1733 return true;
1734 if (!test_opt(sbi, RESERVE_ROOT))
1735 return false;
1736 if (IS_NOQUOTA(inode))
1737 return true;
1738 if (uid_eq(F2FS_OPTION(sbi).s_resuid, current_fsuid()))
1739 return true;
1740 if (!gid_eq(F2FS_OPTION(sbi).s_resgid, GLOBAL_ROOT_GID) &&
1741 in_group_p(F2FS_OPTION(sbi).s_resgid))
1742 return true;
1743 if (cap && capable(CAP_SYS_RESOURCE))
1744 return true;
1745 return false;
1746}
1747
1748static inline void f2fs_i_blocks_write(struct inode *, block_t, bool, bool);
1749static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,
1750 struct inode *inode, blkcnt_t *count)
1751{
1752 blkcnt_t diff = 0, release = 0;
1753 block_t avail_user_block_count;
1754 int ret;
1755
1756 ret = dquot_reserve_block(inode, *count);
1757 if (ret)
1758 return ret;
1759
1760 if (time_to_inject(sbi, FAULT_BLOCK)) {
1761 f2fs_show_injection_info(FAULT_BLOCK);
1762 release = *count;
1763 goto enospc;
1764 }
1765
1766
1767
1768
1769
1770 percpu_counter_add(&sbi->alloc_valid_block_count, (*count));
1771
1772 spin_lock(&sbi->stat_lock);
1773 sbi->total_valid_block_count += (block_t)(*count);
1774 avail_user_block_count = sbi->user_block_count -
1775 sbi->current_reserved_blocks;
1776
1777 if (!__allow_reserved_blocks(sbi, inode, true))
1778 avail_user_block_count -= F2FS_OPTION(sbi).root_reserved_blocks;
1779 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
1780 if (avail_user_block_count > sbi->unusable_block_count)
1781 avail_user_block_count -= sbi->unusable_block_count;
1782 else
1783 avail_user_block_count = 0;
1784 }
1785 if (unlikely(sbi->total_valid_block_count > avail_user_block_count)) {
1786 diff = sbi->total_valid_block_count - avail_user_block_count;
1787 if (diff > *count)
1788 diff = *count;
1789 *count -= diff;
1790 release = diff;
1791 sbi->total_valid_block_count -= diff;
1792 if (!*count) {
1793 spin_unlock(&sbi->stat_lock);
1794 goto enospc;
1795 }
1796 }
1797 spin_unlock(&sbi->stat_lock);
1798
1799 if (unlikely(release)) {
1800 percpu_counter_sub(&sbi->alloc_valid_block_count, release);
1801 dquot_release_reservation_block(inode, release);
1802 }
1803 f2fs_i_blocks_write(inode, *count, true, true);
1804 return 0;
1805
1806enospc:
1807 percpu_counter_sub(&sbi->alloc_valid_block_count, release);
1808 dquot_release_reservation_block(inode, release);
1809 return -ENOSPC;
1810}
1811
1812__printf(2, 3)
1813void f2fs_printk(struct f2fs_sb_info *sbi, const char *fmt, ...);
1814
1815#define f2fs_err(sbi, fmt, ...) \
1816 f2fs_printk(sbi, KERN_ERR fmt, ##__VA_ARGS__)
1817#define f2fs_warn(sbi, fmt, ...) \
1818 f2fs_printk(sbi, KERN_WARNING fmt, ##__VA_ARGS__)
1819#define f2fs_notice(sbi, fmt, ...) \
1820 f2fs_printk(sbi, KERN_NOTICE fmt, ##__VA_ARGS__)
1821#define f2fs_info(sbi, fmt, ...) \
1822 f2fs_printk(sbi, KERN_INFO fmt, ##__VA_ARGS__)
1823#define f2fs_debug(sbi, fmt, ...) \
1824 f2fs_printk(sbi, KERN_DEBUG fmt, ##__VA_ARGS__)
1825
1826static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
1827 struct inode *inode,
1828 block_t count)
1829{
1830 blkcnt_t sectors = count << F2FS_LOG_SECTORS_PER_BLOCK;
1831
1832 spin_lock(&sbi->stat_lock);
1833 f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
1834 sbi->total_valid_block_count -= (block_t)count;
1835 if (sbi->reserved_blocks &&
1836 sbi->current_reserved_blocks < sbi->reserved_blocks)
1837 sbi->current_reserved_blocks = min(sbi->reserved_blocks,
1838 sbi->current_reserved_blocks + count);
1839 spin_unlock(&sbi->stat_lock);
1840 if (unlikely(inode->i_blocks < sectors)) {
1841 f2fs_warn(sbi, "Inconsistent i_blocks, ino:%lu, iblocks:%llu, sectors:%llu",
1842 inode->i_ino,
1843 (unsigned long long)inode->i_blocks,
1844 (unsigned long long)sectors);
1845 set_sbi_flag(sbi, SBI_NEED_FSCK);
1846 return;
1847 }
1848 f2fs_i_blocks_write(inode, count, false, true);
1849}
1850
1851static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
1852{
1853 atomic_inc(&sbi->nr_pages[count_type]);
1854
1855 if (count_type == F2FS_DIRTY_DENTS ||
1856 count_type == F2FS_DIRTY_NODES ||
1857 count_type == F2FS_DIRTY_META ||
1858 count_type == F2FS_DIRTY_QDATA ||
1859 count_type == F2FS_DIRTY_IMETA)
1860 set_sbi_flag(sbi, SBI_IS_DIRTY);
1861}
1862
1863static inline void inode_inc_dirty_pages(struct inode *inode)
1864{
1865 atomic_inc(&F2FS_I(inode)->dirty_pages);
1866 inc_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
1867 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
1868 if (IS_NOQUOTA(inode))
1869 inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
1870}
1871
1872static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
1873{
1874 atomic_dec(&sbi->nr_pages[count_type]);
1875}
1876
1877static inline void inode_dec_dirty_pages(struct inode *inode)
1878{
1879 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
1880 !S_ISLNK(inode->i_mode))
1881 return;
1882
1883 atomic_dec(&F2FS_I(inode)->dirty_pages);
1884 dec_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
1885 F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
1886 if (IS_NOQUOTA(inode))
1887 dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
1888}
1889
1890static inline s64 get_pages(struct f2fs_sb_info *sbi, int count_type)
1891{
1892 return atomic_read(&sbi->nr_pages[count_type]);
1893}
1894
1895static inline int get_dirty_pages(struct inode *inode)
1896{
1897 return atomic_read(&F2FS_I(inode)->dirty_pages);
1898}
1899
1900static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
1901{
1902 unsigned int pages_per_sec = sbi->segs_per_sec * sbi->blocks_per_seg;
1903 unsigned int segs = (get_pages(sbi, block_type) + pages_per_sec - 1) >>
1904 sbi->log_blocks_per_seg;
1905
1906 return segs / sbi->segs_per_sec;
1907}
1908
1909static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
1910{
1911 return sbi->total_valid_block_count;
1912}
1913
1914static inline block_t discard_blocks(struct f2fs_sb_info *sbi)
1915{
1916 return sbi->discard_blks;
1917}
1918
1919static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
1920{
1921 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1922
1923
1924 if (flag == NAT_BITMAP)
1925 return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
1926 else if (flag == SIT_BITMAP)
1927 return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
1928
1929 return 0;
1930}
1931
1932static inline block_t __cp_payload(struct f2fs_sb_info *sbi)
1933{
1934 return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
1935}
1936
1937static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
1938{
1939 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1940 int offset;
1941
1942 if (is_set_ckpt_flags(sbi, CP_LARGE_NAT_BITMAP_FLAG)) {
1943 offset = (flag == SIT_BITMAP) ?
1944 le32_to_cpu(ckpt->nat_ver_bitmap_bytesize) : 0;
1945
1946
1947
1948
1949 return &ckpt->sit_nat_version_bitmap + offset + sizeof(__le32);
1950 }
1951
1952 if (__cp_payload(sbi) > 0) {
1953 if (flag == NAT_BITMAP)
1954 return &ckpt->sit_nat_version_bitmap;
1955 else
1956 return (unsigned char *)ckpt + F2FS_BLKSIZE;
1957 } else {
1958 offset = (flag == NAT_BITMAP) ?
1959 le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
1960 return &ckpt->sit_nat_version_bitmap + offset;
1961 }
1962}
1963
1964static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
1965{
1966 block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
1967
1968 if (sbi->cur_cp_pack == 2)
1969 start_addr += sbi->blocks_per_seg;
1970 return start_addr;
1971}
1972
1973static inline block_t __start_cp_next_addr(struct f2fs_sb_info *sbi)
1974{
1975 block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
1976
1977 if (sbi->cur_cp_pack == 1)
1978 start_addr += sbi->blocks_per_seg;
1979 return start_addr;
1980}
1981
1982static inline void __set_cp_next_pack(struct f2fs_sb_info *sbi)
1983{
1984 sbi->cur_cp_pack = (sbi->cur_cp_pack == 1) ? 2 : 1;
1985}
1986
1987static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
1988{
1989 return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
1990}
1991
1992static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,
1993 struct inode *inode, bool is_inode)
1994{
1995 block_t valid_block_count;
1996 unsigned int valid_node_count, user_block_count;
1997 int err;
1998
1999 if (is_inode) {
2000 if (inode) {
2001 err = dquot_alloc_inode(inode);
2002 if (err)
2003 return err;
2004 }
2005 } else {
2006 err = dquot_reserve_block(inode, 1);
2007 if (err)
2008 return err;
2009 }
2010
2011 if (time_to_inject(sbi, FAULT_BLOCK)) {
2012 f2fs_show_injection_info(FAULT_BLOCK);
2013 goto enospc;
2014 }
2015
2016 spin_lock(&sbi->stat_lock);
2017
2018 valid_block_count = sbi->total_valid_block_count +
2019 sbi->current_reserved_blocks + 1;
2020
2021 if (!__allow_reserved_blocks(sbi, inode, false))
2022 valid_block_count += F2FS_OPTION(sbi).root_reserved_blocks;
2023 user_block_count = sbi->user_block_count;
2024 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
2025 user_block_count -= sbi->unusable_block_count;
2026
2027 if (unlikely(valid_block_count > user_block_count)) {
2028 spin_unlock(&sbi->stat_lock);
2029 goto enospc;
2030 }
2031
2032 valid_node_count = sbi->total_valid_node_count + 1;
2033 if (unlikely(valid_node_count > sbi->total_node_count)) {
2034 spin_unlock(&sbi->stat_lock);
2035 goto enospc;
2036 }
2037
2038 sbi->total_valid_node_count++;
2039 sbi->total_valid_block_count++;
2040 spin_unlock(&sbi->stat_lock);
2041
2042 if (inode) {
2043 if (is_inode)
2044 f2fs_mark_inode_dirty_sync(inode, true);
2045 else
2046 f2fs_i_blocks_write(inode, 1, true, true);
2047 }
2048
2049 percpu_counter_inc(&sbi->alloc_valid_block_count);
2050 return 0;
2051
2052enospc:
2053 if (is_inode) {
2054 if (inode)
2055 dquot_free_inode(inode);
2056 } else {
2057 dquot_release_reservation_block(inode, 1);
2058 }
2059 return -ENOSPC;
2060}
2061
2062static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
2063 struct inode *inode, bool is_inode)
2064{
2065 spin_lock(&sbi->stat_lock);
2066
2067 f2fs_bug_on(sbi, !sbi->total_valid_block_count);
2068 f2fs_bug_on(sbi, !sbi->total_valid_node_count);
2069
2070 sbi->total_valid_node_count--;
2071 sbi->total_valid_block_count--;
2072 if (sbi->reserved_blocks &&
2073 sbi->current_reserved_blocks < sbi->reserved_blocks)
2074 sbi->current_reserved_blocks++;
2075
2076 spin_unlock(&sbi->stat_lock);
2077
2078 if (is_inode) {
2079 dquot_free_inode(inode);
2080 } else {
2081 if (unlikely(inode->i_blocks == 0)) {
2082 f2fs_warn(sbi, "Inconsistent i_blocks, ino:%lu, iblocks:%llu",
2083 inode->i_ino,
2084 (unsigned long long)inode->i_blocks);
2085 set_sbi_flag(sbi, SBI_NEED_FSCK);
2086 return;
2087 }
2088 f2fs_i_blocks_write(inode, 1, false, true);
2089 }
2090}
2091
2092static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
2093{
2094 return sbi->total_valid_node_count;
2095}
2096
2097static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
2098{
2099 percpu_counter_inc(&sbi->total_valid_inode_count);
2100}
2101
2102static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
2103{
2104 percpu_counter_dec(&sbi->total_valid_inode_count);
2105}
2106
2107static inline s64 valid_inode_count(struct f2fs_sb_info *sbi)
2108{
2109 return percpu_counter_sum_positive(&sbi->total_valid_inode_count);
2110}
2111
2112static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
2113 pgoff_t index, bool for_write)
2114{
2115 struct page *page;
2116
2117 if (IS_ENABLED(CONFIG_F2FS_FAULT_INJECTION)) {
2118 if (!for_write)
2119 page = find_get_page_flags(mapping, index,
2120 FGP_LOCK | FGP_ACCESSED);
2121 else
2122 page = find_lock_page(mapping, index);
2123 if (page)
2124 return page;
2125
2126 if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_ALLOC)) {
2127 f2fs_show_injection_info(FAULT_PAGE_ALLOC);
2128 return NULL;
2129 }
2130 }
2131
2132 if (!for_write)
2133 return grab_cache_page(mapping, index);
2134 return grab_cache_page_write_begin(mapping, index, AOP_FLAG_NOFS);
2135}
2136
2137static inline struct page *f2fs_pagecache_get_page(
2138 struct address_space *mapping, pgoff_t index,
2139 int fgp_flags, gfp_t gfp_mask)
2140{
2141 if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_GET)) {
2142 f2fs_show_injection_info(FAULT_PAGE_GET);
2143 return NULL;
2144 }
2145
2146 return pagecache_get_page(mapping, index, fgp_flags, gfp_mask);
2147}
2148
2149static inline void f2fs_copy_page(struct page *src, struct page *dst)
2150{
2151 char *src_kaddr = kmap(src);
2152 char *dst_kaddr = kmap(dst);
2153
2154 memcpy(dst_kaddr, src_kaddr, PAGE_SIZE);
2155 kunmap(dst);
2156 kunmap(src);
2157}
2158
2159static inline void f2fs_put_page(struct page *page, int unlock)
2160{
2161 if (!page)
2162 return;
2163
2164 if (unlock) {
2165 f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page));
2166 unlock_page(page);
2167 }
2168 put_page(page);
2169}
2170
2171static inline void f2fs_put_dnode(struct dnode_of_data *dn)
2172{
2173 if (dn->node_page)
2174 f2fs_put_page(dn->node_page, 1);
2175 if (dn->inode_page && dn->node_page != dn->inode_page)
2176 f2fs_put_page(dn->inode_page, 0);
2177 dn->node_page = NULL;
2178 dn->inode_page = NULL;
2179}
2180
2181static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
2182 size_t size)
2183{
2184 return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
2185}
2186
2187static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep,
2188 gfp_t flags)
2189{
2190 void *entry;
2191
2192 entry = kmem_cache_alloc(cachep, flags);
2193 if (!entry)
2194 entry = kmem_cache_alloc(cachep, flags | __GFP_NOFAIL);
2195 return entry;
2196}
2197
2198static inline struct bio *f2fs_bio_alloc(struct f2fs_sb_info *sbi,
2199 int npages, bool no_fail)
2200{
2201 struct bio *bio;
2202
2203 if (no_fail) {
2204
2205 bio = bio_alloc(GFP_NOIO, npages);
2206 if (!bio)
2207 bio = bio_alloc(GFP_NOIO | __GFP_NOFAIL, npages);
2208 return bio;
2209 }
2210 if (time_to_inject(sbi, FAULT_ALLOC_BIO)) {
2211 f2fs_show_injection_info(FAULT_ALLOC_BIO);
2212 return NULL;
2213 }
2214
2215 return bio_alloc(GFP_KERNEL, npages);
2216}
2217
2218static inline bool is_idle(struct f2fs_sb_info *sbi, int type)
2219{
2220 if (sbi->gc_mode == GC_URGENT)
2221 return true;
2222
2223 if (get_pages(sbi, F2FS_RD_DATA) || get_pages(sbi, F2FS_RD_NODE) ||
2224 get_pages(sbi, F2FS_RD_META) || get_pages(sbi, F2FS_WB_DATA) ||
2225 get_pages(sbi, F2FS_WB_CP_DATA) ||
2226 get_pages(sbi, F2FS_DIO_READ) ||
2227 get_pages(sbi, F2FS_DIO_WRITE))
2228 return false;
2229
2230 if (type != DISCARD_TIME && SM_I(sbi) && SM_I(sbi)->dcc_info &&
2231 atomic_read(&SM_I(sbi)->dcc_info->queued_discard))
2232 return false;
2233
2234 if (SM_I(sbi) && SM_I(sbi)->fcc_info &&
2235 atomic_read(&SM_I(sbi)->fcc_info->queued_flush))
2236 return false;
2237
2238 return f2fs_time_over(sbi, type);
2239}
2240
2241static inline void f2fs_radix_tree_insert(struct radix_tree_root *root,
2242 unsigned long index, void *item)
2243{
2244 while (radix_tree_insert(root, index, item))
2245 cond_resched();
2246}
2247
2248#define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
2249
2250static inline bool IS_INODE(struct page *page)
2251{
2252 struct f2fs_node *p = F2FS_NODE(page);
2253
2254 return RAW_IS_INODE(p);
2255}
2256
2257static inline int offset_in_addr(struct f2fs_inode *i)
2258{
2259 return (i->i_inline & F2FS_EXTRA_ATTR) ?
2260 (le16_to_cpu(i->i_extra_isize) / sizeof(__le32)) : 0;
2261}
2262
2263static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
2264{
2265 return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
2266}
2267
2268static inline int f2fs_has_extra_attr(struct inode *inode);
2269static inline block_t datablock_addr(struct inode *inode,
2270 struct page *node_page, unsigned int offset)
2271{
2272 struct f2fs_node *raw_node;
2273 __le32 *addr_array;
2274 int base = 0;
2275 bool is_inode = IS_INODE(node_page);
2276
2277 raw_node = F2FS_NODE(node_page);
2278
2279
2280 if (is_inode) {
2281 if (!inode)
2282 base = offset_in_addr(&raw_node->i);
2283 else if (f2fs_has_extra_attr(inode))
2284 base = get_extra_isize(inode);
2285 }
2286
2287 addr_array = blkaddr_in_node(raw_node);
2288 return le32_to_cpu(addr_array[base + offset]);
2289}
2290
2291static inline int f2fs_test_bit(unsigned int nr, char *addr)
2292{
2293 int mask;
2294
2295 addr += (nr >> 3);
2296 mask = 1 << (7 - (nr & 0x07));
2297 return mask & *addr;
2298}
2299
2300static inline void f2fs_set_bit(unsigned int nr, char *addr)
2301{
2302 int mask;
2303
2304 addr += (nr >> 3);
2305 mask = 1 << (7 - (nr & 0x07));
2306 *addr |= mask;
2307}
2308
2309static inline void f2fs_clear_bit(unsigned int nr, char *addr)
2310{
2311 int mask;
2312
2313 addr += (nr >> 3);
2314 mask = 1 << (7 - (nr & 0x07));
2315 *addr &= ~mask;
2316}
2317
2318static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr)
2319{
2320 int mask;
2321 int ret;
2322
2323 addr += (nr >> 3);
2324 mask = 1 << (7 - (nr & 0x07));
2325 ret = mask & *addr;
2326 *addr |= mask;
2327 return ret;
2328}
2329
2330static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr)
2331{
2332 int mask;
2333 int ret;
2334
2335 addr += (nr >> 3);
2336 mask = 1 << (7 - (nr & 0x07));
2337 ret = mask & *addr;
2338 *addr &= ~mask;
2339 return ret;
2340}
2341
2342static inline void f2fs_change_bit(unsigned int nr, char *addr)
2343{
2344 int mask;
2345
2346 addr += (nr >> 3);
2347 mask = 1 << (7 - (nr & 0x07));
2348 *addr ^= mask;
2349}
2350
2351
2352
2353
2354#define F2FS_SYNC_FL 0x00000008
2355#define F2FS_IMMUTABLE_FL 0x00000010
2356#define F2FS_APPEND_FL 0x00000020
2357#define F2FS_NODUMP_FL 0x00000040
2358#define F2FS_NOATIME_FL 0x00000080
2359#define F2FS_INDEX_FL 0x00001000
2360#define F2FS_DIRSYNC_FL 0x00010000
2361#define F2FS_PROJINHERIT_FL 0x20000000
2362
2363
2364#define F2FS_FL_INHERITED (F2FS_SYNC_FL | F2FS_NODUMP_FL | F2FS_NOATIME_FL | \
2365 F2FS_DIRSYNC_FL | F2FS_PROJINHERIT_FL)
2366
2367
2368#define F2FS_REG_FLMASK (~(F2FS_DIRSYNC_FL | F2FS_PROJINHERIT_FL))
2369
2370
2371#define F2FS_OTHER_FLMASK (F2FS_NODUMP_FL | F2FS_NOATIME_FL)
2372
2373static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
2374{
2375 if (S_ISDIR(mode))
2376 return flags;
2377 else if (S_ISREG(mode))
2378 return flags & F2FS_REG_FLMASK;
2379 else
2380 return flags & F2FS_OTHER_FLMASK;
2381}
2382
2383
2384enum {
2385 FI_NEW_INODE,
2386 FI_DIRTY_INODE,
2387 FI_AUTO_RECOVER,
2388 FI_DIRTY_DIR,
2389 FI_INC_LINK,
2390 FI_ACL_MODE,
2391 FI_NO_ALLOC,
2392 FI_FREE_NID,
2393 FI_NO_EXTENT,
2394 FI_INLINE_XATTR,
2395 FI_INLINE_DATA,
2396 FI_INLINE_DENTRY,
2397 FI_APPEND_WRITE,
2398 FI_UPDATE_WRITE,
2399 FI_NEED_IPU,
2400 FI_ATOMIC_FILE,
2401 FI_ATOMIC_COMMIT,
2402 FI_VOLATILE_FILE,
2403 FI_FIRST_BLOCK_WRITTEN,
2404 FI_DROP_CACHE,
2405 FI_DATA_EXIST,
2406 FI_INLINE_DOTS,
2407 FI_DO_DEFRAG,
2408 FI_DIRTY_FILE,
2409 FI_NO_PREALLOC,
2410 FI_HOT_DATA,
2411 FI_EXTRA_ATTR,
2412 FI_PROJ_INHERIT,
2413 FI_PIN_FILE,
2414 FI_ATOMIC_REVOKE_REQUEST,
2415};
2416
2417static inline void __mark_inode_dirty_flag(struct inode *inode,
2418 int flag, bool set)
2419{
2420 switch (flag) {
2421 case FI_INLINE_XATTR:
2422 case FI_INLINE_DATA:
2423 case FI_INLINE_DENTRY:
2424 case FI_NEW_INODE:
2425 if (set)
2426 return;
2427
2428 case FI_DATA_EXIST:
2429 case FI_INLINE_DOTS:
2430 case FI_PIN_FILE:
2431 f2fs_mark_inode_dirty_sync(inode, true);
2432 }
2433}
2434
2435static inline void set_inode_flag(struct inode *inode, int flag)
2436{
2437 if (!test_bit(flag, &F2FS_I(inode)->flags))
2438 set_bit(flag, &F2FS_I(inode)->flags);
2439 __mark_inode_dirty_flag(inode, flag, true);
2440}
2441
2442static inline int is_inode_flag_set(struct inode *inode, int flag)
2443{
2444 return test_bit(flag, &F2FS_I(inode)->flags);
2445}
2446
2447static inline void clear_inode_flag(struct inode *inode, int flag)
2448{
2449 if (test_bit(flag, &F2FS_I(inode)->flags))
2450 clear_bit(flag, &F2FS_I(inode)->flags);
2451 __mark_inode_dirty_flag(inode, flag, false);
2452}
2453
2454static inline void set_acl_inode(struct inode *inode, umode_t mode)
2455{
2456 F2FS_I(inode)->i_acl_mode = mode;
2457 set_inode_flag(inode, FI_ACL_MODE);
2458 f2fs_mark_inode_dirty_sync(inode, false);
2459}
2460
2461static inline void f2fs_i_links_write(struct inode *inode, bool inc)
2462{
2463 if (inc)
2464 inc_nlink(inode);
2465 else
2466 drop_nlink(inode);
2467 f2fs_mark_inode_dirty_sync(inode, true);
2468}
2469
2470static inline void f2fs_i_blocks_write(struct inode *inode,
2471 block_t diff, bool add, bool claim)
2472{
2473 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
2474 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
2475
2476
2477 if (add) {
2478 if (claim)
2479 dquot_claim_block(inode, diff);
2480 else
2481 dquot_alloc_block_nofail(inode, diff);
2482 } else {
2483 dquot_free_block(inode, diff);
2484 }
2485
2486 f2fs_mark_inode_dirty_sync(inode, true);
2487 if (clean || recover)
2488 set_inode_flag(inode, FI_AUTO_RECOVER);
2489}
2490
2491static inline void f2fs_i_size_write(struct inode *inode, loff_t i_size)
2492{
2493 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
2494 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
2495
2496 if (i_size_read(inode) == i_size)
2497 return;
2498
2499 i_size_write(inode, i_size);
2500 f2fs_mark_inode_dirty_sync(inode, true);
2501 if (clean || recover)
2502 set_inode_flag(inode, FI_AUTO_RECOVER);
2503}
2504
2505static inline void f2fs_i_depth_write(struct inode *inode, unsigned int depth)
2506{
2507 F2FS_I(inode)->i_current_depth = depth;
2508 f2fs_mark_inode_dirty_sync(inode, true);
2509}
2510
2511static inline void f2fs_i_gc_failures_write(struct inode *inode,
2512 unsigned int count)
2513{
2514 F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN] = count;
2515 f2fs_mark_inode_dirty_sync(inode, true);
2516}
2517
2518static inline void f2fs_i_xnid_write(struct inode *inode, nid_t xnid)
2519{
2520 F2FS_I(inode)->i_xattr_nid = xnid;
2521 f2fs_mark_inode_dirty_sync(inode, true);
2522}
2523
2524static inline void f2fs_i_pino_write(struct inode *inode, nid_t pino)
2525{
2526 F2FS_I(inode)->i_pino = pino;
2527 f2fs_mark_inode_dirty_sync(inode, true);
2528}
2529
2530static inline void get_inline_info(struct inode *inode, struct f2fs_inode *ri)
2531{
2532 struct f2fs_inode_info *fi = F2FS_I(inode);
2533
2534 if (ri->i_inline & F2FS_INLINE_XATTR)
2535 set_bit(FI_INLINE_XATTR, &fi->flags);
2536 if (ri->i_inline & F2FS_INLINE_DATA)
2537 set_bit(FI_INLINE_DATA, &fi->flags);
2538 if (ri->i_inline & F2FS_INLINE_DENTRY)
2539 set_bit(FI_INLINE_DENTRY, &fi->flags);
2540 if (ri->i_inline & F2FS_DATA_EXIST)
2541 set_bit(FI_DATA_EXIST, &fi->flags);
2542 if (ri->i_inline & F2FS_INLINE_DOTS)
2543 set_bit(FI_INLINE_DOTS, &fi->flags);
2544 if (ri->i_inline & F2FS_EXTRA_ATTR)
2545 set_bit(FI_EXTRA_ATTR, &fi->flags);
2546 if (ri->i_inline & F2FS_PIN_FILE)
2547 set_bit(FI_PIN_FILE, &fi->flags);
2548}
2549
2550static inline void set_raw_inline(struct inode *inode, struct f2fs_inode *ri)
2551{
2552 ri->i_inline = 0;
2553
2554 if (is_inode_flag_set(inode, FI_INLINE_XATTR))
2555 ri->i_inline |= F2FS_INLINE_XATTR;
2556 if (is_inode_flag_set(inode, FI_INLINE_DATA))
2557 ri->i_inline |= F2FS_INLINE_DATA;
2558 if (is_inode_flag_set(inode, FI_INLINE_DENTRY))
2559 ri->i_inline |= F2FS_INLINE_DENTRY;
2560 if (is_inode_flag_set(inode, FI_DATA_EXIST))
2561 ri->i_inline |= F2FS_DATA_EXIST;
2562 if (is_inode_flag_set(inode, FI_INLINE_DOTS))
2563 ri->i_inline |= F2FS_INLINE_DOTS;
2564 if (is_inode_flag_set(inode, FI_EXTRA_ATTR))
2565 ri->i_inline |= F2FS_EXTRA_ATTR;
2566 if (is_inode_flag_set(inode, FI_PIN_FILE))
2567 ri->i_inline |= F2FS_PIN_FILE;
2568}
2569
2570static inline int f2fs_has_extra_attr(struct inode *inode)
2571{
2572 return is_inode_flag_set(inode, FI_EXTRA_ATTR);
2573}
2574
2575static inline int f2fs_has_inline_xattr(struct inode *inode)
2576{
2577 return is_inode_flag_set(inode, FI_INLINE_XATTR);
2578}
2579
2580static inline unsigned int addrs_per_inode(struct inode *inode)
2581{
2582 unsigned int addrs = CUR_ADDRS_PER_INODE(inode) -
2583 get_inline_xattr_addrs(inode);
2584 return ALIGN_DOWN(addrs, 1);
2585}
2586
2587static inline unsigned int addrs_per_block(struct inode *inode)
2588{
2589 return ALIGN_DOWN(DEF_ADDRS_PER_BLOCK, 1);
2590}
2591
2592static inline void *inline_xattr_addr(struct inode *inode, struct page *page)
2593{
2594 struct f2fs_inode *ri = F2FS_INODE(page);
2595
2596 return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
2597 get_inline_xattr_addrs(inode)]);
2598}
2599
2600static inline int inline_xattr_size(struct inode *inode)
2601{
2602 if (f2fs_has_inline_xattr(inode))
2603 return get_inline_xattr_addrs(inode) * sizeof(__le32);
2604 return 0;
2605}
2606
2607static inline int f2fs_has_inline_data(struct inode *inode)
2608{
2609 return is_inode_flag_set(inode, FI_INLINE_DATA);
2610}
2611
2612static inline int f2fs_exist_data(struct inode *inode)
2613{
2614 return is_inode_flag_set(inode, FI_DATA_EXIST);
2615}
2616
2617static inline int f2fs_has_inline_dots(struct inode *inode)
2618{
2619 return is_inode_flag_set(inode, FI_INLINE_DOTS);
2620}
2621
2622static inline bool f2fs_is_pinned_file(struct inode *inode)
2623{
2624 return is_inode_flag_set(inode, FI_PIN_FILE);
2625}
2626
2627static inline bool f2fs_is_atomic_file(struct inode *inode)
2628{
2629 return is_inode_flag_set(inode, FI_ATOMIC_FILE);
2630}
2631
2632static inline bool f2fs_is_commit_atomic_write(struct inode *inode)
2633{
2634 return is_inode_flag_set(inode, FI_ATOMIC_COMMIT);
2635}
2636
2637static inline bool f2fs_is_volatile_file(struct inode *inode)
2638{
2639 return is_inode_flag_set(inode, FI_VOLATILE_FILE);
2640}
2641
2642static inline bool f2fs_is_first_block_written(struct inode *inode)
2643{
2644 return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
2645}
2646
2647static inline bool f2fs_is_drop_cache(struct inode *inode)
2648{
2649 return is_inode_flag_set(inode, FI_DROP_CACHE);
2650}
2651
2652static inline void *inline_data_addr(struct inode *inode, struct page *page)
2653{
2654 struct f2fs_inode *ri = F2FS_INODE(page);
2655 int extra_size = get_extra_isize(inode);
2656
2657 return (void *)&(ri->i_addr[extra_size + DEF_INLINE_RESERVED_SIZE]);
2658}
2659
2660static inline int f2fs_has_inline_dentry(struct inode *inode)
2661{
2662 return is_inode_flag_set(inode, FI_INLINE_DENTRY);
2663}
2664
2665static inline int is_file(struct inode *inode, int type)
2666{
2667 return F2FS_I(inode)->i_advise & type;
2668}
2669
2670static inline void set_file(struct inode *inode, int type)
2671{
2672 F2FS_I(inode)->i_advise |= type;
2673 f2fs_mark_inode_dirty_sync(inode, true);
2674}
2675
2676static inline void clear_file(struct inode *inode, int type)
2677{
2678 F2FS_I(inode)->i_advise &= ~type;
2679 f2fs_mark_inode_dirty_sync(inode, true);
2680}
2681
2682static inline bool f2fs_skip_inode_update(struct inode *inode, int dsync)
2683{
2684 bool ret;
2685
2686 if (dsync) {
2687 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2688
2689 spin_lock(&sbi->inode_lock[DIRTY_META]);
2690 ret = list_empty(&F2FS_I(inode)->gdirty_list);
2691 spin_unlock(&sbi->inode_lock[DIRTY_META]);
2692 return ret;
2693 }
2694 if (!is_inode_flag_set(inode, FI_AUTO_RECOVER) ||
2695 file_keep_isize(inode) ||
2696 i_size_read(inode) & ~PAGE_MASK)
2697 return false;
2698
2699 if (!timespec64_equal(F2FS_I(inode)->i_disk_time, &inode->i_atime))
2700 return false;
2701 if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 1, &inode->i_ctime))
2702 return false;
2703 if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 2, &inode->i_mtime))
2704 return false;
2705 if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 3,
2706 &F2FS_I(inode)->i_crtime))
2707 return false;
2708
2709 down_read(&F2FS_I(inode)->i_sem);
2710 ret = F2FS_I(inode)->last_disk_size == i_size_read(inode);
2711 up_read(&F2FS_I(inode)->i_sem);
2712
2713 return ret;
2714}
2715
2716static inline bool f2fs_readonly(struct super_block *sb)
2717{
2718 return sb_rdonly(sb);
2719}
2720
2721static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
2722{
2723 return is_set_ckpt_flags(sbi, CP_ERROR_FLAG);
2724}
2725
2726static inline bool is_dot_dotdot(const struct qstr *str)
2727{
2728 if (str->len == 1 && str->name[0] == '.')
2729 return true;
2730
2731 if (str->len == 2 && str->name[0] == '.' && str->name[1] == '.')
2732 return true;
2733
2734 return false;
2735}
2736
2737static inline bool f2fs_may_extent_tree(struct inode *inode)
2738{
2739 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2740
2741 if (!test_opt(sbi, EXTENT_CACHE) ||
2742 is_inode_flag_set(inode, FI_NO_EXTENT))
2743 return false;
2744
2745
2746
2747
2748
2749 if (list_empty(&sbi->s_list))
2750 return false;
2751
2752 return S_ISREG(inode->i_mode);
2753}
2754
2755static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,
2756 size_t size, gfp_t flags)
2757{
2758 void *ret;
2759
2760 if (time_to_inject(sbi, FAULT_KMALLOC)) {
2761 f2fs_show_injection_info(FAULT_KMALLOC);
2762 return NULL;
2763 }
2764
2765 ret = kmalloc(size, flags);
2766 if (ret)
2767 return ret;
2768
2769 return kvmalloc(size, flags);
2770}
2771
2772static inline void *f2fs_kzalloc(struct f2fs_sb_info *sbi,
2773 size_t size, gfp_t flags)
2774{
2775 return f2fs_kmalloc(sbi, size, flags | __GFP_ZERO);
2776}
2777
2778static inline void *f2fs_kvmalloc(struct f2fs_sb_info *sbi,
2779 size_t size, gfp_t flags)
2780{
2781 if (time_to_inject(sbi, FAULT_KVMALLOC)) {
2782 f2fs_show_injection_info(FAULT_KVMALLOC);
2783 return NULL;
2784 }
2785
2786 return kvmalloc(size, flags);
2787}
2788
2789static inline void *f2fs_kvzalloc(struct f2fs_sb_info *sbi,
2790 size_t size, gfp_t flags)
2791{
2792 return f2fs_kvmalloc(sbi, size, flags | __GFP_ZERO);
2793}
2794
2795static inline int get_extra_isize(struct inode *inode)
2796{
2797 return F2FS_I(inode)->i_extra_isize / sizeof(__le32);
2798}
2799
2800static inline int get_inline_xattr_addrs(struct inode *inode)
2801{
2802 return F2FS_I(inode)->i_inline_xattr_size;
2803}
2804
2805#define f2fs_get_inode_mode(i) \
2806 ((is_inode_flag_set(i, FI_ACL_MODE)) ? \
2807 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
2808
2809#define F2FS_TOTAL_EXTRA_ATTR_SIZE \
2810 (offsetof(struct f2fs_inode, i_extra_end) - \
2811 offsetof(struct f2fs_inode, i_extra_isize)) \
2812
2813#define F2FS_OLD_ATTRIBUTE_SIZE (offsetof(struct f2fs_inode, i_addr))
2814#define F2FS_FITS_IN_INODE(f2fs_inode, extra_isize, field) \
2815 ((offsetof(typeof(*(f2fs_inode)), field) + \
2816 sizeof((f2fs_inode)->field)) \
2817 <= (F2FS_OLD_ATTRIBUTE_SIZE + (extra_isize))) \
2818
2819static inline void f2fs_reset_iostat(struct f2fs_sb_info *sbi)
2820{
2821 int i;
2822
2823 spin_lock(&sbi->iostat_lock);
2824 for (i = 0; i < NR_IO_TYPE; i++)
2825 sbi->write_iostat[i] = 0;
2826 spin_unlock(&sbi->iostat_lock);
2827}
2828
2829static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi,
2830 enum iostat_type type, unsigned long long io_bytes)
2831{
2832 if (!sbi->iostat_enable)
2833 return;
2834 spin_lock(&sbi->iostat_lock);
2835 sbi->write_iostat[type] += io_bytes;
2836
2837 if (type == APP_WRITE_IO || type == APP_DIRECT_IO)
2838 sbi->write_iostat[APP_BUFFERED_IO] =
2839 sbi->write_iostat[APP_WRITE_IO] -
2840 sbi->write_iostat[APP_DIRECT_IO];
2841 spin_unlock(&sbi->iostat_lock);
2842}
2843
2844#define __is_large_section(sbi) ((sbi)->segs_per_sec > 1)
2845
2846#define __is_meta_io(fio) (PAGE_TYPE_OF_BIO((fio)->type) == META)
2847
2848bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
2849 block_t blkaddr, int type);
2850static inline void verify_blkaddr(struct f2fs_sb_info *sbi,
2851 block_t blkaddr, int type)
2852{
2853 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, type)) {
2854 f2fs_err(sbi, "invalid blkaddr: %u, type: %d, run fsck to fix.",
2855 blkaddr, type);
2856 f2fs_bug_on(sbi, 1);
2857 }
2858}
2859
2860static inline bool __is_valid_data_blkaddr(block_t blkaddr)
2861{
2862 if (blkaddr == NEW_ADDR || blkaddr == NULL_ADDR)
2863 return false;
2864 return true;
2865}
2866
2867static inline void f2fs_set_page_private(struct page *page,
2868 unsigned long data)
2869{
2870 if (PagePrivate(page))
2871 return;
2872
2873 get_page(page);
2874 SetPagePrivate(page);
2875 set_page_private(page, data);
2876}
2877
2878static inline void f2fs_clear_page_private(struct page *page)
2879{
2880 if (!PagePrivate(page))
2881 return;
2882
2883 set_page_private(page, 0);
2884 ClearPagePrivate(page);
2885 f2fs_put_page(page, 0);
2886}
2887
2888
2889
2890
2891int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
2892void f2fs_truncate_data_blocks(struct dnode_of_data *dn);
2893int f2fs_truncate_blocks(struct inode *inode, u64 from, bool lock);
2894int f2fs_truncate(struct inode *inode);
2895int f2fs_getattr(const struct path *path, struct kstat *stat,
2896 u32 request_mask, unsigned int flags);
2897int f2fs_setattr(struct dentry *dentry, struct iattr *attr);
2898int f2fs_truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end);
2899void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count);
2900int f2fs_precache_extents(struct inode *inode);
2901long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
2902long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
2903int f2fs_transfer_project_quota(struct inode *inode, kprojid_t kprojid);
2904int f2fs_pin_file_control(struct inode *inode, bool inc);
2905
2906
2907
2908
2909void f2fs_set_inode_flags(struct inode *inode);
2910bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct page *page);
2911void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct page *page);
2912struct inode *f2fs_iget(struct super_block *sb, unsigned long ino);
2913struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino);
2914int f2fs_try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink);
2915void f2fs_update_inode(struct inode *inode, struct page *node_page);
2916void f2fs_update_inode_page(struct inode *inode);
2917int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);
2918void f2fs_evict_inode(struct inode *inode);
2919void f2fs_handle_failed_inode(struct inode *inode);
2920
2921
2922
2923
2924int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
2925 bool hot, bool set);
2926struct dentry *f2fs_get_parent(struct dentry *child);
2927
2928
2929
2930
2931unsigned char f2fs_get_de_type(struct f2fs_dir_entry *de);
2932struct f2fs_dir_entry *f2fs_find_target_dentry(struct fscrypt_name *fname,
2933 f2fs_hash_t namehash, int *max_slots,
2934 struct f2fs_dentry_ptr *d);
2935int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
2936 unsigned int start_pos, struct fscrypt_str *fstr);
2937void f2fs_do_make_empty_dir(struct inode *inode, struct inode *parent,
2938 struct f2fs_dentry_ptr *d);
2939struct page *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,
2940 const struct qstr *new_name,
2941 const struct qstr *orig_name, struct page *dpage);
2942void f2fs_update_parent_metadata(struct inode *dir, struct inode *inode,
2943 unsigned int current_depth);
2944int f2fs_room_for_filename(const void *bitmap, int slots, int max_slots);
2945void f2fs_drop_nlink(struct inode *dir, struct inode *inode);
2946struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
2947 struct fscrypt_name *fname, struct page **res_page);
2948struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
2949 const struct qstr *child, struct page **res_page);
2950struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p);
2951ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
2952 struct page **page);
2953void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
2954 struct page *page, struct inode *inode);
2955void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
2956 const struct qstr *name, f2fs_hash_t name_hash,
2957 unsigned int bit_pos);
2958int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
2959 const struct qstr *orig_name,
2960 struct inode *inode, nid_t ino, umode_t mode);
2961int f2fs_add_dentry(struct inode *dir, struct fscrypt_name *fname,
2962 struct inode *inode, nid_t ino, umode_t mode);
2963int f2fs_do_add_link(struct inode *dir, const struct qstr *name,
2964 struct inode *inode, nid_t ino, umode_t mode);
2965void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
2966 struct inode *dir, struct inode *inode);
2967int f2fs_do_tmpfile(struct inode *inode, struct inode *dir);
2968bool f2fs_empty_dir(struct inode *dir);
2969
2970static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
2971{
2972 return f2fs_do_add_link(d_inode(dentry->d_parent), &dentry->d_name,
2973 inode, inode->i_ino, inode->i_mode);
2974}
2975
2976
2977
2978
2979int f2fs_inode_dirtied(struct inode *inode, bool sync);
2980void f2fs_inode_synced(struct inode *inode);
2981int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly);
2982int f2fs_quota_sync(struct super_block *sb, int type);
2983void f2fs_quota_off_umount(struct super_block *sb);
2984int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover);
2985int f2fs_sync_fs(struct super_block *sb, int sync);
2986int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi);
2987
2988
2989
2990
2991f2fs_hash_t f2fs_dentry_hash(const struct qstr *name_info,
2992 struct fscrypt_name *fname);
2993
2994
2995
2996
2997struct dnode_of_data;
2998struct node_info;
2999
3000int f2fs_check_nid_range(struct f2fs_sb_info *sbi, nid_t nid);
3001bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type);
3002bool f2fs_in_warm_node_list(struct f2fs_sb_info *sbi, struct page *page);
3003void f2fs_init_fsync_node_info(struct f2fs_sb_info *sbi);
3004void f2fs_del_fsync_node_entry(struct f2fs_sb_info *sbi, struct page *page);
3005void f2fs_reset_fsync_node_info(struct f2fs_sb_info *sbi);
3006int f2fs_need_dentry_mark(struct f2fs_sb_info *sbi, nid_t nid);
3007bool f2fs_is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid);
3008bool f2fs_need_inode_block_update(struct f2fs_sb_info *sbi, nid_t ino);
3009int f2fs_get_node_info(struct f2fs_sb_info *sbi, nid_t nid,
3010 struct node_info *ni);
3011pgoff_t f2fs_get_next_page_offset(struct dnode_of_data *dn, pgoff_t pgofs);
3012int f2fs_get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode);
3013int f2fs_truncate_inode_blocks(struct inode *inode, pgoff_t from);
3014int f2fs_truncate_xattr_node(struct inode *inode);
3015int f2fs_wait_on_node_pages_writeback(struct f2fs_sb_info *sbi,
3016 unsigned int seq_id);
3017int f2fs_remove_inode_page(struct inode *inode);
3018struct page *f2fs_new_inode_page(struct inode *inode);
3019struct page *f2fs_new_node_page(struct dnode_of_data *dn, unsigned int ofs);
3020void f2fs_ra_node_page(struct f2fs_sb_info *sbi, nid_t nid);
3021struct page *f2fs_get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid);
3022struct page *f2fs_get_node_page_ra(struct page *parent, int start);
3023int f2fs_move_node_page(struct page *node_page, int gc_type);
3024int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
3025 struct writeback_control *wbc, bool atomic,
3026 unsigned int *seq_id);
3027int f2fs_sync_node_pages(struct f2fs_sb_info *sbi,
3028 struct writeback_control *wbc,
3029 bool do_balance, enum iostat_type io_type);
3030int f2fs_build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool mount);
3031bool f2fs_alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid);
3032void f2fs_alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid);
3033void f2fs_alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid);
3034int f2fs_try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink);
3035void f2fs_recover_inline_xattr(struct inode *inode, struct page *page);
3036int f2fs_recover_xattr_data(struct inode *inode, struct page *page);
3037int f2fs_recover_inode_page(struct f2fs_sb_info *sbi, struct page *page);
3038int f2fs_restore_node_summary(struct f2fs_sb_info *sbi,
3039 unsigned int segno, struct f2fs_summary_block *sum);
3040int f2fs_flush_nat_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3041int f2fs_build_node_manager(struct f2fs_sb_info *sbi);
3042void f2fs_destroy_node_manager(struct f2fs_sb_info *sbi);
3043int __init f2fs_create_node_manager_caches(void);
3044void f2fs_destroy_node_manager_caches(void);
3045
3046
3047
3048
3049bool f2fs_need_SSR(struct f2fs_sb_info *sbi);
3050void f2fs_register_inmem_page(struct inode *inode, struct page *page);
3051void f2fs_drop_inmem_pages_all(struct f2fs_sb_info *sbi, bool gc_failure);
3052void f2fs_drop_inmem_pages(struct inode *inode);
3053void f2fs_drop_inmem_page(struct inode *inode, struct page *page);
3054int f2fs_commit_inmem_pages(struct inode *inode);
3055void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need);
3056void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi);
3057int f2fs_issue_flush(struct f2fs_sb_info *sbi, nid_t ino);
3058int f2fs_create_flush_cmd_control(struct f2fs_sb_info *sbi);
3059int f2fs_flush_device_cache(struct f2fs_sb_info *sbi);
3060void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free);
3061void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr);
3062bool f2fs_is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
3063void f2fs_drop_discard_cmd(struct f2fs_sb_info *sbi);
3064void f2fs_stop_discard_thread(struct f2fs_sb_info *sbi);
3065bool f2fs_issue_discard_timeout(struct f2fs_sb_info *sbi);
3066void f2fs_clear_prefree_segments(struct f2fs_sb_info *sbi,
3067 struct cp_control *cpc);
3068void f2fs_dirty_to_prefree(struct f2fs_sb_info *sbi);
3069block_t f2fs_get_unusable_blocks(struct f2fs_sb_info *sbi);
3070int f2fs_disable_cp_again(struct f2fs_sb_info *sbi, block_t unusable);
3071void f2fs_release_discard_addrs(struct f2fs_sb_info *sbi);
3072int f2fs_npages_for_summary_flush(struct f2fs_sb_info *sbi, bool for_ra);
3073void allocate_segment_for_resize(struct f2fs_sb_info *sbi, int type,
3074 unsigned int start, unsigned int end);
3075void f2fs_allocate_new_segments(struct f2fs_sb_info *sbi);
3076int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range);
3077bool f2fs_exist_trim_candidates(struct f2fs_sb_info *sbi,
3078 struct cp_control *cpc);
3079struct page *f2fs_get_sum_page(struct f2fs_sb_info *sbi, unsigned int segno);
3080void f2fs_update_meta_page(struct f2fs_sb_info *sbi, void *src,
3081 block_t blk_addr);
3082void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct page *page,
3083 enum iostat_type io_type);
3084void f2fs_do_write_node_page(unsigned int nid, struct f2fs_io_info *fio);
3085void f2fs_outplace_write_data(struct dnode_of_data *dn,
3086 struct f2fs_io_info *fio);
3087int f2fs_inplace_write_data(struct f2fs_io_info *fio);
3088void f2fs_do_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
3089 block_t old_blkaddr, block_t new_blkaddr,
3090 bool recover_curseg, bool recover_newaddr);
3091void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
3092 block_t old_addr, block_t new_addr,
3093 unsigned char version, bool recover_curseg,
3094 bool recover_newaddr);
3095void f2fs_allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
3096 block_t old_blkaddr, block_t *new_blkaddr,
3097 struct f2fs_summary *sum, int type,
3098 struct f2fs_io_info *fio, bool add_list);
3099void f2fs_wait_on_page_writeback(struct page *page,
3100 enum page_type type, bool ordered, bool locked);
3101void f2fs_wait_on_block_writeback(struct inode *inode, block_t blkaddr);
3102void f2fs_wait_on_block_writeback_range(struct inode *inode, block_t blkaddr,
3103 block_t len);
3104void f2fs_write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
3105void f2fs_write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
3106int f2fs_lookup_journal_in_cursum(struct f2fs_journal *journal, int type,
3107 unsigned int val, int alloc);
3108void f2fs_flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3109int f2fs_build_segment_manager(struct f2fs_sb_info *sbi);
3110void f2fs_destroy_segment_manager(struct f2fs_sb_info *sbi);
3111int __init f2fs_create_segment_manager_caches(void);
3112void f2fs_destroy_segment_manager_caches(void);
3113int f2fs_rw_hint_to_seg_type(enum rw_hint hint);
3114enum rw_hint f2fs_io_type_to_rw_hint(struct f2fs_sb_info *sbi,
3115 enum page_type type, enum temp_type temp);
3116
3117
3118
3119
3120void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io);
3121struct page *f2fs_grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
3122struct page *f2fs_get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
3123struct page *f2fs_get_meta_page_nofail(struct f2fs_sb_info *sbi, pgoff_t index);
3124struct page *f2fs_get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index);
3125bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
3126 block_t blkaddr, int type);
3127int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
3128 int type, bool sync);
3129void f2fs_ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index);
3130long f2fs_sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
3131 long nr_to_write, enum iostat_type io_type);
3132void f2fs_add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
3133void f2fs_remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
3134void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all);
3135bool f2fs_exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode);
3136void f2fs_set_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
3137 unsigned int devidx, int type);
3138bool f2fs_is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
3139 unsigned int devidx, int type);
3140int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi);
3141int f2fs_acquire_orphan_inode(struct f2fs_sb_info *sbi);
3142void f2fs_release_orphan_inode(struct f2fs_sb_info *sbi);
3143void f2fs_add_orphan_inode(struct inode *inode);
3144void f2fs_remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino);
3145int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi);
3146int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi);
3147void f2fs_update_dirty_page(struct inode *inode, struct page *page);
3148void f2fs_remove_dirty_inode(struct inode *inode);
3149int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type);
3150void f2fs_wait_on_all_pages_writeback(struct f2fs_sb_info *sbi);
3151int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3152void f2fs_init_ino_entry_info(struct f2fs_sb_info *sbi);
3153int __init f2fs_create_checkpoint_caches(void);
3154void f2fs_destroy_checkpoint_caches(void);
3155
3156
3157
3158
3159int f2fs_init_post_read_processing(void);
3160void f2fs_destroy_post_read_processing(void);
3161void f2fs_submit_merged_write(struct f2fs_sb_info *sbi, enum page_type type);
3162void f2fs_submit_merged_write_cond(struct f2fs_sb_info *sbi,
3163 struct inode *inode, struct page *page,
3164 nid_t ino, enum page_type type);
3165void f2fs_flush_merged_writes(struct f2fs_sb_info *sbi);
3166int f2fs_submit_page_bio(struct f2fs_io_info *fio);
3167int f2fs_merge_page_bio(struct f2fs_io_info *fio);
3168void f2fs_submit_page_write(struct f2fs_io_info *fio);
3169struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,
3170 block_t blk_addr, struct bio *bio);
3171int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr);
3172void f2fs_set_data_blkaddr(struct dnode_of_data *dn);
3173void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr);
3174int f2fs_reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count);
3175int f2fs_reserve_new_block(struct dnode_of_data *dn);
3176int f2fs_get_block(struct dnode_of_data *dn, pgoff_t index);
3177int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from);
3178int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index);
3179struct page *f2fs_get_read_data_page(struct inode *inode, pgoff_t index,
3180 int op_flags, bool for_write);
3181struct page *f2fs_find_data_page(struct inode *inode, pgoff_t index);
3182struct page *f2fs_get_lock_data_page(struct inode *inode, pgoff_t index,
3183 bool for_write);
3184struct page *f2fs_get_new_data_page(struct inode *inode,
3185 struct page *ipage, pgoff_t index, bool new_i_size);
3186int f2fs_do_write_data_page(struct f2fs_io_info *fio);
3187void __do_map_lock(struct f2fs_sb_info *sbi, int flag, bool lock);
3188int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
3189 int create, int flag);
3190int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
3191 u64 start, u64 len);
3192bool f2fs_should_update_inplace(struct inode *inode, struct f2fs_io_info *fio);
3193bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio);
3194void f2fs_invalidate_page(struct page *page, unsigned int offset,
3195 unsigned int length);
3196int f2fs_release_page(struct page *page, gfp_t wait);
3197#ifdef CONFIG_MIGRATION
3198int f2fs_migrate_page(struct address_space *mapping, struct page *newpage,
3199 struct page *page, enum migrate_mode mode);
3200#endif
3201bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len);
3202void f2fs_clear_page_cache_dirty_tag(struct page *page);
3203
3204
3205
3206
3207int f2fs_start_gc_thread(struct f2fs_sb_info *sbi);
3208void f2fs_stop_gc_thread(struct f2fs_sb_info *sbi);
3209block_t f2fs_start_bidx_of_node(unsigned int node_ofs, struct inode *inode);
3210int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background,
3211 unsigned int segno);
3212void f2fs_build_gc_manager(struct f2fs_sb_info *sbi);
3213int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count);
3214
3215
3216
3217
3218int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only);
3219bool f2fs_space_for_roll_forward(struct f2fs_sb_info *sbi);
3220
3221
3222
3223
3224#ifdef CONFIG_F2FS_STAT_FS
3225struct f2fs_stat_info {
3226 struct list_head stat_list;
3227 struct f2fs_sb_info *sbi;
3228 int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
3229 int main_area_segs, main_area_sections, main_area_zones;
3230 unsigned long long hit_largest, hit_cached, hit_rbtree;
3231 unsigned long long hit_total, total_ext;
3232 int ext_tree, zombie_tree, ext_node;
3233 int ndirty_node, ndirty_dent, ndirty_meta, ndirty_imeta;
3234 int ndirty_data, ndirty_qdata;
3235 int inmem_pages;
3236 unsigned int ndirty_dirs, ndirty_files, nquota_files, ndirty_all;
3237 int nats, dirty_nats, sits, dirty_sits;
3238 int free_nids, avail_nids, alloc_nids;
3239 int total_count, utilization;
3240 int bg_gc, nr_wb_cp_data, nr_wb_data;
3241 int nr_rd_data, nr_rd_node, nr_rd_meta;
3242 int nr_dio_read, nr_dio_write;
3243 unsigned int io_skip_bggc, other_skip_bggc;
3244 int nr_flushing, nr_flushed, flush_list_empty;
3245 int nr_discarding, nr_discarded;
3246 int nr_discard_cmd;
3247 unsigned int undiscard_blks;
3248 int inline_xattr, inline_inode, inline_dir, append, update, orphans;
3249 int aw_cnt, max_aw_cnt, vw_cnt, max_vw_cnt;
3250 unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
3251 unsigned int bimodal, avg_vblocks;
3252 int util_free, util_valid, util_invalid;
3253 int rsvd_segs, overp_segs;
3254 int dirty_count, node_pages, meta_pages;
3255 int prefree_count, call_count, cp_count, bg_cp_count;
3256 int tot_segs, node_segs, data_segs, free_segs, free_secs;
3257 int bg_node_segs, bg_data_segs;
3258 int tot_blks, data_blks, node_blks;
3259 int bg_data_blks, bg_node_blks;
3260 unsigned long long skipped_atomic_files[2];
3261 int curseg[NR_CURSEG_TYPE];
3262 int cursec[NR_CURSEG_TYPE];
3263 int curzone[NR_CURSEG_TYPE];
3264
3265 unsigned int meta_count[META_MAX];
3266 unsigned int segment_count[2];
3267 unsigned int block_count[2];
3268 unsigned int inplace_count;
3269 unsigned long long base_mem, cache_mem, page_mem;
3270};
3271
3272static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
3273{
3274 return (struct f2fs_stat_info *)sbi->stat_info;
3275}
3276
3277#define stat_inc_cp_count(si) ((si)->cp_count++)
3278#define stat_inc_bg_cp_count(si) ((si)->bg_cp_count++)
3279#define stat_inc_call_count(si) ((si)->call_count++)
3280#define stat_inc_bggc_count(sbi) ((sbi)->bg_gc++)
3281#define stat_io_skip_bggc_count(sbi) ((sbi)->io_skip_bggc++)
3282#define stat_other_skip_bggc_count(sbi) ((sbi)->other_skip_bggc++)
3283#define stat_inc_dirty_inode(sbi, type) ((sbi)->ndirty_inode[type]++)
3284#define stat_dec_dirty_inode(sbi, type) ((sbi)->ndirty_inode[type]--)
3285#define stat_inc_total_hit(sbi) (atomic64_inc(&(sbi)->total_hit_ext))
3286#define stat_inc_rbtree_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_rbtree))
3287#define stat_inc_largest_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_largest))
3288#define stat_inc_cached_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_cached))
3289#define stat_inc_inline_xattr(inode) \
3290 do { \
3291 if (f2fs_has_inline_xattr(inode)) \
3292 (atomic_inc(&F2FS_I_SB(inode)->inline_xattr)); \
3293 } while (0)
3294#define stat_dec_inline_xattr(inode) \
3295 do { \
3296 if (f2fs_has_inline_xattr(inode)) \
3297 (atomic_dec(&F2FS_I_SB(inode)->inline_xattr)); \
3298 } while (0)
3299#define stat_inc_inline_inode(inode) \
3300 do { \
3301 if (f2fs_has_inline_data(inode)) \
3302 (atomic_inc(&F2FS_I_SB(inode)->inline_inode)); \
3303 } while (0)
3304#define stat_dec_inline_inode(inode) \
3305 do { \
3306 if (f2fs_has_inline_data(inode)) \
3307 (atomic_dec(&F2FS_I_SB(inode)->inline_inode)); \
3308 } while (0)
3309#define stat_inc_inline_dir(inode) \
3310 do { \
3311 if (f2fs_has_inline_dentry(inode)) \
3312 (atomic_inc(&F2FS_I_SB(inode)->inline_dir)); \
3313 } while (0)
3314#define stat_dec_inline_dir(inode) \
3315 do { \
3316 if (f2fs_has_inline_dentry(inode)) \
3317 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
3318 } while (0)
3319#define stat_inc_meta_count(sbi, blkaddr) \
3320 do { \
3321 if (blkaddr < SIT_I(sbi)->sit_base_addr) \
3322 atomic_inc(&(sbi)->meta_count[META_CP]); \
3323 else if (blkaddr < NM_I(sbi)->nat_blkaddr) \
3324 atomic_inc(&(sbi)->meta_count[META_SIT]); \
3325 else if (blkaddr < SM_I(sbi)->ssa_blkaddr) \
3326 atomic_inc(&(sbi)->meta_count[META_NAT]); \
3327 else if (blkaddr < SM_I(sbi)->main_blkaddr) \
3328 atomic_inc(&(sbi)->meta_count[META_SSA]); \
3329 } while (0)
3330#define stat_inc_seg_type(sbi, curseg) \
3331 ((sbi)->segment_count[(curseg)->alloc_type]++)
3332#define stat_inc_block_count(sbi, curseg) \
3333 ((sbi)->block_count[(curseg)->alloc_type]++)
3334#define stat_inc_inplace_blocks(sbi) \
3335 (atomic_inc(&(sbi)->inplace_count))
3336#define stat_inc_atomic_write(inode) \
3337 (atomic_inc(&F2FS_I_SB(inode)->aw_cnt))
3338#define stat_dec_atomic_write(inode) \
3339 (atomic_dec(&F2FS_I_SB(inode)->aw_cnt))
3340#define stat_update_max_atomic_write(inode) \
3341 do { \
3342 int cur = atomic_read(&F2FS_I_SB(inode)->aw_cnt); \
3343 int max = atomic_read(&F2FS_I_SB(inode)->max_aw_cnt); \
3344 if (cur > max) \
3345 atomic_set(&F2FS_I_SB(inode)->max_aw_cnt, cur); \
3346 } while (0)
3347#define stat_inc_volatile_write(inode) \
3348 (atomic_inc(&F2FS_I_SB(inode)->vw_cnt))
3349#define stat_dec_volatile_write(inode) \
3350 (atomic_dec(&F2FS_I_SB(inode)->vw_cnt))
3351#define stat_update_max_volatile_write(inode) \
3352 do { \
3353 int cur = atomic_read(&F2FS_I_SB(inode)->vw_cnt); \
3354 int max = atomic_read(&F2FS_I_SB(inode)->max_vw_cnt); \
3355 if (cur > max) \
3356 atomic_set(&F2FS_I_SB(inode)->max_vw_cnt, cur); \
3357 } while (0)
3358#define stat_inc_seg_count(sbi, type, gc_type) \
3359 do { \
3360 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
3361 si->tot_segs++; \
3362 if ((type) == SUM_TYPE_DATA) { \
3363 si->data_segs++; \
3364 si->bg_data_segs += (gc_type == BG_GC) ? 1 : 0; \
3365 } else { \
3366 si->node_segs++; \
3367 si->bg_node_segs += (gc_type == BG_GC) ? 1 : 0; \
3368 } \
3369 } while (0)
3370
3371#define stat_inc_tot_blk_count(si, blks) \
3372 ((si)->tot_blks += (blks))
3373
3374#define stat_inc_data_blk_count(sbi, blks, gc_type) \
3375 do { \
3376 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
3377 stat_inc_tot_blk_count(si, blks); \
3378 si->data_blks += (blks); \
3379 si->bg_data_blks += ((gc_type) == BG_GC) ? (blks) : 0; \
3380 } while (0)
3381
3382#define stat_inc_node_blk_count(sbi, blks, gc_type) \
3383 do { \
3384 struct f2fs_stat_info *si = F2FS_STAT(sbi); \
3385 stat_inc_tot_blk_count(si, blks); \
3386 si->node_blks += (blks); \
3387 si->bg_node_blks += ((gc_type) == BG_GC) ? (blks) : 0; \
3388 } while (0)
3389
3390int f2fs_build_stats(struct f2fs_sb_info *sbi);
3391void f2fs_destroy_stats(struct f2fs_sb_info *sbi);
3392void __init f2fs_create_root_stats(void);
3393void f2fs_destroy_root_stats(void);
3394#else
3395#define stat_inc_cp_count(si) do { } while (0)
3396#define stat_inc_bg_cp_count(si) do { } while (0)
3397#define stat_inc_call_count(si) do { } while (0)
3398#define stat_inc_bggc_count(si) do { } while (0)
3399#define stat_io_skip_bggc_count(sbi) do { } while (0)
3400#define stat_other_skip_bggc_count(sbi) do { } while (0)
3401#define stat_inc_dirty_inode(sbi, type) do { } while (0)
3402#define stat_dec_dirty_inode(sbi, type) do { } while (0)
3403#define stat_inc_total_hit(sb) do { } while (0)
3404#define stat_inc_rbtree_node_hit(sb) do { } while (0)
3405#define stat_inc_largest_node_hit(sbi) do { } while (0)
3406#define stat_inc_cached_node_hit(sbi) do { } while (0)
3407#define stat_inc_inline_xattr(inode) do { } while (0)
3408#define stat_dec_inline_xattr(inode) do { } while (0)
3409#define stat_inc_inline_inode(inode) do { } while (0)
3410#define stat_dec_inline_inode(inode) do { } while (0)
3411#define stat_inc_inline_dir(inode) do { } while (0)
3412#define stat_dec_inline_dir(inode) do { } while (0)
3413#define stat_inc_atomic_write(inode) do { } while (0)
3414#define stat_dec_atomic_write(inode) do { } while (0)
3415#define stat_update_max_atomic_write(inode) do { } while (0)
3416#define stat_inc_volatile_write(inode) do { } while (0)
3417#define stat_dec_volatile_write(inode) do { } while (0)
3418#define stat_update_max_volatile_write(inode) do { } while (0)
3419#define stat_inc_meta_count(sbi, blkaddr) do { } while (0)
3420#define stat_inc_seg_type(sbi, curseg) do { } while (0)
3421#define stat_inc_block_count(sbi, curseg) do { } while (0)
3422#define stat_inc_inplace_blocks(sbi) do { } while (0)
3423#define stat_inc_seg_count(sbi, type, gc_type) do { } while (0)
3424#define stat_inc_tot_blk_count(si, blks) do { } while (0)
3425#define stat_inc_data_blk_count(sbi, blks, gc_type) do { } while (0)
3426#define stat_inc_node_blk_count(sbi, blks, gc_type) do { } while (0)
3427
3428static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
3429static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
3430static inline void __init f2fs_create_root_stats(void) { }
3431static inline void f2fs_destroy_root_stats(void) { }
3432#endif
3433
3434extern const struct file_operations f2fs_dir_operations;
3435extern const struct file_operations f2fs_file_operations;
3436extern const struct inode_operations f2fs_file_inode_operations;
3437extern const struct address_space_operations f2fs_dblock_aops;
3438extern const struct address_space_operations f2fs_node_aops;
3439extern const struct address_space_operations f2fs_meta_aops;
3440extern const struct inode_operations f2fs_dir_inode_operations;
3441extern const struct inode_operations f2fs_symlink_inode_operations;
3442extern const struct inode_operations f2fs_encrypted_symlink_inode_operations;
3443extern const struct inode_operations f2fs_special_inode_operations;
3444extern struct kmem_cache *f2fs_inode_entry_slab;
3445
3446
3447
3448
3449bool f2fs_may_inline_data(struct inode *inode);
3450bool f2fs_may_inline_dentry(struct inode *inode);
3451void f2fs_do_read_inline_data(struct page *page, struct page *ipage);
3452void f2fs_truncate_inline_inode(struct inode *inode,
3453 struct page *ipage, u64 from);
3454int f2fs_read_inline_data(struct inode *inode, struct page *page);
3455int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page);
3456int f2fs_convert_inline_inode(struct inode *inode);
3457int f2fs_write_inline_data(struct inode *inode, struct page *page);
3458bool f2fs_recover_inline_data(struct inode *inode, struct page *npage);
3459struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir,
3460 struct fscrypt_name *fname, struct page **res_page);
3461int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent,
3462 struct page *ipage);
3463int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
3464 const struct qstr *orig_name,
3465 struct inode *inode, nid_t ino, umode_t mode);
3466void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry,
3467 struct page *page, struct inode *dir,
3468 struct inode *inode);
3469bool f2fs_empty_inline_dir(struct inode *dir);
3470int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
3471 struct fscrypt_str *fstr);
3472int f2fs_inline_data_fiemap(struct inode *inode,
3473 struct fiemap_extent_info *fieinfo,
3474 __u64 start, __u64 len);
3475
3476
3477
3478
3479unsigned long f2fs_shrink_count(struct shrinker *shrink,
3480 struct shrink_control *sc);
3481unsigned long f2fs_shrink_scan(struct shrinker *shrink,
3482 struct shrink_control *sc);
3483void f2fs_join_shrinker(struct f2fs_sb_info *sbi);
3484void f2fs_leave_shrinker(struct f2fs_sb_info *sbi);
3485
3486
3487
3488
3489struct rb_entry *f2fs_lookup_rb_tree(struct rb_root_cached *root,
3490 struct rb_entry *cached_re, unsigned int ofs);
3491struct rb_node **f2fs_lookup_rb_tree_for_insert(struct f2fs_sb_info *sbi,
3492 struct rb_root_cached *root,
3493 struct rb_node **parent,
3494 unsigned int ofs, bool *leftmost);
3495struct rb_entry *f2fs_lookup_rb_tree_ret(struct rb_root_cached *root,
3496 struct rb_entry *cached_re, unsigned int ofs,
3497 struct rb_entry **prev_entry, struct rb_entry **next_entry,
3498 struct rb_node ***insert_p, struct rb_node **insert_parent,
3499 bool force, bool *leftmost);
3500bool f2fs_check_rb_tree_consistence(struct f2fs_sb_info *sbi,
3501 struct rb_root_cached *root);
3502unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink);
3503bool f2fs_init_extent_tree(struct inode *inode, struct f2fs_extent *i_ext);
3504void f2fs_drop_extent_tree(struct inode *inode);
3505unsigned int f2fs_destroy_extent_node(struct inode *inode);
3506void f2fs_destroy_extent_tree(struct inode *inode);
3507bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs,
3508 struct extent_info *ei);
3509void f2fs_update_extent_cache(struct dnode_of_data *dn);
3510void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
3511 pgoff_t fofs, block_t blkaddr, unsigned int len);
3512void f2fs_init_extent_cache_info(struct f2fs_sb_info *sbi);
3513int __init f2fs_create_extent_cache(void);
3514void f2fs_destroy_extent_cache(void);
3515
3516
3517
3518
3519int __init f2fs_init_sysfs(void);
3520void f2fs_exit_sysfs(void);
3521int f2fs_register_sysfs(struct f2fs_sb_info *sbi);
3522void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi);
3523
3524
3525
3526
3527static inline bool f2fs_encrypted_file(struct inode *inode)
3528{
3529 return IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode);
3530}
3531
3532static inline void f2fs_set_encrypted_inode(struct inode *inode)
3533{
3534#ifdef CONFIG_FS_ENCRYPTION
3535 file_set_encrypt(inode);
3536 f2fs_set_inode_flags(inode);
3537#endif
3538}
3539
3540
3541
3542
3543
3544static inline bool f2fs_post_read_required(struct inode *inode)
3545{
3546 return f2fs_encrypted_file(inode);
3547}
3548
3549#define F2FS_FEATURE_FUNCS(name, flagname) \
3550static inline int f2fs_sb_has_##name(struct f2fs_sb_info *sbi) \
3551{ \
3552 return F2FS_HAS_FEATURE(sbi, F2FS_FEATURE_##flagname); \
3553}
3554
3555F2FS_FEATURE_FUNCS(encrypt, ENCRYPT);
3556F2FS_FEATURE_FUNCS(blkzoned, BLKZONED);
3557F2FS_FEATURE_FUNCS(extra_attr, EXTRA_ATTR);
3558F2FS_FEATURE_FUNCS(project_quota, PRJQUOTA);
3559F2FS_FEATURE_FUNCS(inode_chksum, INODE_CHKSUM);
3560F2FS_FEATURE_FUNCS(flexible_inline_xattr, FLEXIBLE_INLINE_XATTR);
3561F2FS_FEATURE_FUNCS(quota_ino, QUOTA_INO);
3562F2FS_FEATURE_FUNCS(inode_crtime, INODE_CRTIME);
3563F2FS_FEATURE_FUNCS(lost_found, LOST_FOUND);
3564F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
3565
3566#ifdef CONFIG_BLK_DEV_ZONED
3567static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
3568 block_t blkaddr)
3569{
3570 unsigned int zno = blkaddr >> sbi->log_blocks_per_blkz;
3571
3572 return test_bit(zno, FDEV(devi).blkz_seq);
3573}
3574#endif
3575
3576static inline bool f2fs_hw_should_discard(struct f2fs_sb_info *sbi)
3577{
3578 return f2fs_sb_has_blkzoned(sbi);
3579}
3580
3581static inline bool f2fs_bdev_support_discard(struct block_device *bdev)
3582{
3583 return blk_queue_discard(bdev_get_queue(bdev)) ||
3584 bdev_is_zoned(bdev);
3585}
3586
3587static inline bool f2fs_hw_support_discard(struct f2fs_sb_info *sbi)
3588{
3589 int i;
3590
3591 if (!f2fs_is_multi_device(sbi))
3592 return f2fs_bdev_support_discard(sbi->sb->s_bdev);
3593
3594 for (i = 0; i < sbi->s_ndevs; i++)
3595 if (f2fs_bdev_support_discard(FDEV(i).bdev))
3596 return true;
3597 return false;
3598}
3599
3600static inline bool f2fs_realtime_discard_enable(struct f2fs_sb_info *sbi)
3601{
3602 return (test_opt(sbi, DISCARD) && f2fs_hw_support_discard(sbi)) ||
3603 f2fs_hw_should_discard(sbi);
3604}
3605
3606static inline bool f2fs_hw_is_readonly(struct f2fs_sb_info *sbi)
3607{
3608 int i;
3609
3610 if (!f2fs_is_multi_device(sbi))
3611 return bdev_read_only(sbi->sb->s_bdev);
3612
3613 for (i = 0; i < sbi->s_ndevs; i++)
3614 if (bdev_read_only(FDEV(i).bdev))
3615 return true;
3616 return false;
3617}
3618
3619
3620static inline void set_opt_mode(struct f2fs_sb_info *sbi, unsigned int mt)
3621{
3622 clear_opt(sbi, ADAPTIVE);
3623 clear_opt(sbi, LFS);
3624
3625 switch (mt) {
3626 case F2FS_MOUNT_ADAPTIVE:
3627 set_opt(sbi, ADAPTIVE);
3628 break;
3629 case F2FS_MOUNT_LFS:
3630 set_opt(sbi, LFS);
3631 break;
3632 }
3633}
3634
3635static inline bool f2fs_may_encrypt(struct inode *inode)
3636{
3637#ifdef CONFIG_FS_ENCRYPTION
3638 umode_t mode = inode->i_mode;
3639
3640 return (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode));
3641#else
3642 return false;
3643#endif
3644}
3645
3646static inline int block_unaligned_IO(struct inode *inode,
3647 struct kiocb *iocb, struct iov_iter *iter)
3648{
3649 unsigned int i_blkbits = READ_ONCE(inode->i_blkbits);
3650 unsigned int blocksize_mask = (1 << i_blkbits) - 1;
3651 loff_t offset = iocb->ki_pos;
3652 unsigned long align = offset | iov_iter_alignment(iter);
3653
3654 return align & blocksize_mask;
3655}
3656
3657static inline int allow_outplace_dio(struct inode *inode,
3658 struct kiocb *iocb, struct iov_iter *iter)
3659{
3660 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3661 int rw = iov_iter_rw(iter);
3662
3663 return (test_opt(sbi, LFS) && (rw == WRITE) &&
3664 !block_unaligned_IO(inode, iocb, iter));
3665}
3666
3667static inline bool f2fs_force_buffered_io(struct inode *inode,
3668 struct kiocb *iocb, struct iov_iter *iter)
3669{
3670 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
3671 int rw = iov_iter_rw(iter);
3672
3673 if (f2fs_post_read_required(inode))
3674 return true;
3675 if (f2fs_is_multi_device(sbi))
3676 return true;
3677
3678
3679
3680
3681 if (f2fs_sb_has_blkzoned(sbi))
3682 return true;
3683 if (test_opt(sbi, LFS) && (rw == WRITE) &&
3684 block_unaligned_IO(inode, iocb, iter))
3685 return true;
3686 if (is_sbi_flag_set(F2FS_I_SB(inode), SBI_CP_DISABLED) &&
3687 !(inode->i_flags & S_SWAPFILE))
3688 return true;
3689
3690 return false;
3691}
3692
3693#ifdef CONFIG_F2FS_FAULT_INJECTION
3694extern void f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned int rate,
3695 unsigned int type);
3696#else
3697#define f2fs_build_fault_attr(sbi, rate, type) do { } while (0)
3698#endif
3699
3700static inline bool is_journalled_quota(struct f2fs_sb_info *sbi)
3701{
3702#ifdef CONFIG_QUOTA
3703 if (f2fs_sb_has_quota_ino(sbi))
3704 return true;
3705 if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||
3706 F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||
3707 F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])
3708 return true;
3709#endif
3710 return false;
3711}
3712
3713#define EFSBADCRC EBADMSG
3714#define EFSCORRUPTED EUCLEAN
3715
3716#endif
3717