34 #define f2fs_bug_on(sbi, condition)	BUG_ON(condition)  argument
36 #define f2fs_bug_on(sbi, condition)					\  argument
39 			set_sbi_flag(sbi, SBI_NEED_FSCK);		\
118 #define F2FS_OPTION(sbi)	((sbi)->mount_opt)  argument
119 #define clear_opt(sbi, option)	(F2FS_OPTION(sbi).opt &= ~F2FS_MOUNT_##option)  argument
120 #define set_opt(sbi, option)	(F2FS_OPTION(sbi).opt |= F2FS_MOUNT_##option)  argument
121 #define test_opt(sbi, option)	(F2FS_OPTION(sbi).opt & F2FS_MOUNT_##option)  argument
219 #define F2FS_HAS_FEATURE(sbi, mask)	__F2FS_HAS_FEATURE(sbi->raw_super, mask)  argument
673 	struct list_head list;		/* node in global extent list of sbi */
682 	struct list_head list;		/* to be used by sbi->zombie_list */
1208 	struct f2fs_sb_info *sbi;	/* f2fs_sb_info pointer */  member
1241 	struct f2fs_sb_info *sbi;	/* f2fs superblock */  member
1257 #define FDEV(i)				(sbi->devs[i])
1568 	unsigned long s_flag;				/* flags for sbi */
1837 #define SEGS_TO_BLKS(sbi, segs)					\  argument
1838 		((segs) << (sbi)->log_blocks_per_seg)
1839 #define BLKS_TO_SEGS(sbi, blks)					\  argument
1840 		((blks) >> (sbi)->log_blocks_per_seg)
1842 #define BLKS_PER_SEG(sbi)	((sbi)->blocks_per_seg)  argument
1843 #define BLKS_PER_SEC(sbi)	(SEGS_TO_BLKS(sbi, (sbi)->segs_per_sec))  argument
1844 #define SEGS_PER_SEC(sbi)	((sbi)->segs_per_sec)  argument
1847 void f2fs_printk(struct f2fs_sb_info *sbi, bool limit_rate, const char *fmt, ...);
1849 #define f2fs_err(sbi, fmt, ...)						\  argument
1850 	f2fs_printk(sbi, false, KERN_ERR fmt, ##__VA_ARGS__)
1851 #define f2fs_warn(sbi, fmt, ...)					\  argument
1852 	f2fs_printk(sbi, false, KERN_WARNING fmt, ##__VA_ARGS__)
1853 #define f2fs_notice(sbi, fmt, ...)					\  argument
1854 	f2fs_printk(sbi, false, KERN_NOTICE fmt, ##__VA_ARGS__)
1855 #define f2fs_info(sbi, fmt, ...)					\  argument
1856 	f2fs_printk(sbi, false, KERN_INFO fmt, ##__VA_ARGS__)
1857 #define f2fs_debug(sbi, fmt, ...)					\  argument
1858 	f2fs_printk(sbi, false, KERN_DEBUG fmt, ##__VA_ARGS__)
1860 #define f2fs_err_ratelimited(sbi, fmt, ...)				\  argument
1861 	f2fs_printk(sbi, true, KERN_ERR fmt, ##__VA_ARGS__)
1862 #define f2fs_warn_ratelimited(sbi, fmt, ...)				\  argument
1863 	f2fs_printk(sbi, true, KERN_WARNING fmt, ##__VA_ARGS__)
1864 #define f2fs_info_ratelimited(sbi, fmt, ...)				\  argument
1865 	f2fs_printk(sbi, true, KERN_INFO fmt, ##__VA_ARGS__)
1868 #define time_to_inject(sbi, type) __time_to_inject(sbi, type, __func__,	\  argument
1870 static inline bool __time_to_inject(struct f2fs_sb_info *sbi, int type,  in __time_to_inject()  argument
1873 	struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;  in __time_to_inject()
1884 		f2fs_info_ratelimited(sbi, "inject %s in %s of %pS",  in __time_to_inject()
1891 static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)  in time_to_inject()  argument
1899  *   - For a single regular disk volume, sbi->s_ndevs is 0.
1900  *   - For a single zoned disk volume, sbi->s_ndevs is 1.
1901  *   - For a multi-device volume, sbi->s_ndevs is always 2 or more.
1903 static inline bool f2fs_is_multi_device(struct f2fs_sb_info *sbi)  in f2fs_is_multi_device()  argument
1905 	return sbi->s_ndevs > 1;  in f2fs_is_multi_device()
1908 static inline void f2fs_update_time(struct f2fs_sb_info *sbi, int type)  in f2fs_update_time()  argument
1912 	sbi->last_time[type] = now;  in f2fs_update_time()
1916 		sbi->last_time[DISCARD_TIME] = now;  in f2fs_update_time()
1917 		sbi->last_time[GC_TIME] = now;  in f2fs_update_time()
1921 static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)  in f2fs_time_over()  argument
1923 	unsigned long interval = sbi->interval_time[type] * HZ;  in f2fs_time_over()
1925 	return time_after(jiffies, sbi->last_time[type] + interval);  in f2fs_time_over()
1928 static inline unsigned int f2fs_time_to_wait(struct f2fs_sb_info *sbi,  in f2fs_time_to_wait()  argument
1931 	unsigned long interval = sbi->interval_time[type] * HZ;  in f2fs_time_to_wait()
1935 	delta = (sbi->last_time[type] + interval) - jiffies;  in f2fs_time_to_wait()
1945 static inline u32 __f2fs_crc32(struct f2fs_sb_info *sbi, u32 crc,  in __f2fs_crc32()  argument
1951 static inline u32 f2fs_crc32(struct f2fs_sb_info *sbi, const void *address,  in f2fs_crc32()  argument
1954 	return __f2fs_crc32(sbi, F2FS_SUPER_MAGIC, address, length);  in f2fs_crc32()
1957 static inline bool f2fs_crc_valid(struct f2fs_sb_info *sbi, __u32 blk_crc,  in f2fs_crc_valid()  argument
1960 	return f2fs_crc32(sbi, buf, buf_size) == blk_crc;  in f2fs_crc_valid()
1963 static inline u32 f2fs_chksum(struct f2fs_sb_info *sbi, u32 crc,  in f2fs_chksum()  argument
1966 	return __f2fs_crc32(sbi, crc, address, length);  in f2fs_chksum()
1999 static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)  in F2FS_RAW_SUPER()  argument
2001 	return (struct f2fs_super_block *)(sbi->raw_super);  in F2FS_RAW_SUPER()
2014 static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)  in F2FS_CKPT()  argument
2016 	return (struct f2fs_checkpoint *)(sbi->ckpt);  in F2FS_CKPT()
2029 static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)  in NM_I()  argument
2031 	return (struct f2fs_nm_info *)(sbi->nm_info);  in NM_I()
2034 static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)  in SM_I()  argument
2036 	return (struct f2fs_sm_info *)(sbi->sm_info);  in SM_I()
2039 static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)  in SIT_I()  argument
2041 	return (struct sit_info *)(SM_I(sbi)->sit_info);  in SIT_I()
2044 static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)  in FREE_I()  argument
2046 	return (struct free_segmap_info *)(SM_I(sbi)->free_info);  in FREE_I()
2049 static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)  in DIRTY_I()  argument
2051 	return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);  in DIRTY_I()
2054 static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)  in META_MAPPING()  argument
2056 	return sbi->meta_inode->i_mapping;  in META_MAPPING()
2059 static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)  in NODE_MAPPING()  argument
2061 	return sbi->node_inode->i_mapping;  in NODE_MAPPING()
2064 static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)  in is_sbi_flag_set()  argument
2066 	return test_bit(type, &sbi->s_flag);  in is_sbi_flag_set()
2069 static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)  in set_sbi_flag()  argument
2071 	set_bit(type, &sbi->s_flag);  in set_sbi_flag()
2074 static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)  in clear_sbi_flag()  argument
2076 	clear_bit(type, &sbi->s_flag);  in clear_sbi_flag()
2104 static inline bool is_set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)  in is_set_ckpt_flags()  argument
2106 	return __is_set_ckpt_flags(F2FS_CKPT(sbi), f);  in is_set_ckpt_flags()
2118 static inline void set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)  in set_ckpt_flags()  argument
2122 	spin_lock_irqsave(&sbi->cp_lock, flags);  in set_ckpt_flags()
2123 	__set_ckpt_flags(F2FS_CKPT(sbi), f);  in set_ckpt_flags()
2124 	spin_unlock_irqrestore(&sbi->cp_lock, flags);  in set_ckpt_flags()
2136 static inline void clear_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)  in clear_ckpt_flags()  argument
2140 	spin_lock_irqsave(&sbi->cp_lock, flags);  in clear_ckpt_flags()
2141 	__clear_ckpt_flags(F2FS_CKPT(sbi), f);  in clear_ckpt_flags()
2142 	spin_unlock_irqrestore(&sbi->cp_lock, flags);  in clear_ckpt_flags()
2223 static inline void disable_nat_bits(struct f2fs_sb_info *sbi, bool lock)  in disable_nat_bits()  argument
2230 	 * set_sbi_flag(sbi, SBI_NEED_FSCK). But it may give huge cost,  in disable_nat_bits()
2235 		spin_lock_irqsave(&sbi->cp_lock, flags);  in disable_nat_bits()
2236 	__clear_ckpt_flags(F2FS_CKPT(sbi), CP_NAT_BITS_FLAG);  in disable_nat_bits()
2237 	nat_bits = NM_I(sbi)->nat_bits;  in disable_nat_bits()
2238 	NM_I(sbi)->nat_bits = NULL;  in disable_nat_bits()
2240 		spin_unlock_irqrestore(&sbi->cp_lock, flags);  in disable_nat_bits()
2245 static inline bool enabled_nat_bits(struct f2fs_sb_info *sbi,  in enabled_nat_bits()  argument
2248 	bool set = is_set_ckpt_flags(sbi, CP_NAT_BITS_FLAG);  in enabled_nat_bits()
2253 static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)  in f2fs_lock_op()  argument
2255 	f2fs_down_read(&sbi->cp_rwsem);  in f2fs_lock_op()
2258 static inline int f2fs_trylock_op(struct f2fs_sb_info *sbi)  in f2fs_trylock_op()  argument
2260 	if (time_to_inject(sbi, FAULT_LOCK_OP))  in f2fs_trylock_op()
2262 	return f2fs_down_read_trylock(&sbi->cp_rwsem);  in f2fs_trylock_op()
2265 static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)  in f2fs_unlock_op()  argument
2267 	f2fs_up_read(&sbi->cp_rwsem);  in f2fs_unlock_op()
2270 static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)  in f2fs_lock_all()  argument
2272 	f2fs_down_write(&sbi->cp_rwsem);  in f2fs_lock_all()
2275 static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)  in f2fs_unlock_all()  argument
2277 	f2fs_up_write(&sbi->cp_rwsem);  in f2fs_unlock_all()
2280 static inline int __get_cp_reason(struct f2fs_sb_info *sbi)  in __get_cp_reason()  argument
2284 	if (test_opt(sbi, FASTBOOT))  in __get_cp_reason()
2286 	if (is_sbi_flag_set(sbi, SBI_IS_CLOSE))  in __get_cp_reason()
2296 static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)  in __exist_node_summaries()  argument
2298 	return (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG) ||  in __exist_node_summaries()
2299 			is_set_ckpt_flags(sbi, CP_FASTBOOT_FLAG));  in __exist_node_summaries()
2317 static inline bool __allow_reserved_blocks(struct f2fs_sb_info *sbi,  in __allow_reserved_blocks()  argument
2322 	if (!test_opt(sbi, RESERVE_ROOT))  in __allow_reserved_blocks()
2326 	if (uid_eq(F2FS_OPTION(sbi).s_resuid, current_fsuid()))  in __allow_reserved_blocks()
2328 	if (!gid_eq(F2FS_OPTION(sbi).s_resgid, GLOBAL_ROOT_GID) &&  in __allow_reserved_blocks()
2329 					in_group_p(F2FS_OPTION(sbi).s_resgid))  in __allow_reserved_blocks()
2336 static inline unsigned int get_available_block_count(struct f2fs_sb_info *sbi,  in get_available_block_count()  argument
2341 	avail_user_block_count = sbi->user_block_count -  in get_available_block_count()
2342 					sbi->current_reserved_blocks;  in get_available_block_count()
2344 	if (!__allow_reserved_blocks(sbi, inode, cap))  in get_available_block_count()
2345 		avail_user_block_count -= F2FS_OPTION(sbi).root_reserved_blocks;  in get_available_block_count()
2347 	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {  in get_available_block_count()
2348 		if (avail_user_block_count > sbi->unusable_block_count)  in get_available_block_count()
2349 			avail_user_block_count -= sbi->unusable_block_count;  in get_available_block_count()
2358 static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,  in inc_valid_block_count()  argument
2369 	if (time_to_inject(sbi, FAULT_BLOCK)) {  in inc_valid_block_count()
2378 	percpu_counter_add(&sbi->alloc_valid_block_count, (*count));  in inc_valid_block_count()
2380 	spin_lock(&sbi->stat_lock);  in inc_valid_block_count()
2382 	avail_user_block_count = get_available_block_count(sbi, inode, true);  in inc_valid_block_count()
2383 	diff = (long long)sbi->total_valid_block_count + *count -  in inc_valid_block_count()
2387 			spin_unlock(&sbi->stat_lock);  in inc_valid_block_count()
2396 			spin_unlock(&sbi->stat_lock);  in inc_valid_block_count()
2400 	sbi->total_valid_block_count += (block_t)(*count);  in inc_valid_block_count()
2402 	spin_unlock(&sbi->stat_lock);  in inc_valid_block_count()
2405 		percpu_counter_sub(&sbi->alloc_valid_block_count, release);  in inc_valid_block_count()
2412 	percpu_counter_sub(&sbi->alloc_valid_block_count, release);  in inc_valid_block_count()
2493 static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,  in dec_valid_block_count()  argument
2499 	spin_lock(&sbi->stat_lock);  in dec_valid_block_count()
2500 	f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);  in dec_valid_block_count()
2501 	sbi->total_valid_block_count -= (block_t)count;  in dec_valid_block_count()
2502 	if (sbi->reserved_blocks &&  in dec_valid_block_count()
2503 		sbi->current_reserved_blocks < sbi->reserved_blocks)  in dec_valid_block_count()
2504 		sbi->current_reserved_blocks = min(sbi->reserved_blocks,  in dec_valid_block_count()
2505 					sbi->current_reserved_blocks + count);  in dec_valid_block_count()
2506 	spin_unlock(&sbi->stat_lock);  in dec_valid_block_count()
2508 		f2fs_warn(sbi, "Inconsistent i_blocks, ino:%lu, iblocks:%llu, sectors:%llu",  in dec_valid_block_count()
2512 		set_sbi_flag(sbi, SBI_NEED_FSCK);  in dec_valid_block_count()
2518 static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)  in inc_page_count()  argument
2520 	atomic_inc(&sbi->nr_pages[count_type]);  in inc_page_count()
2527 		set_sbi_flag(sbi, SBI_IS_DIRTY);  in inc_page_count()
2539 static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)  in dec_page_count()  argument
2541 	atomic_dec(&sbi->nr_pages[count_type]);  in dec_page_count()
2559 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);  in inc_atomic_write_cnt()  local
2564 	atomic64_inc(&sbi->current_atomic_write);  in inc_atomic_write_cnt()
2565 	current_write = atomic64_read(&sbi->current_atomic_write);  in inc_atomic_write_cnt()
2566 	if (current_write > sbi->peak_atomic_write)  in inc_atomic_write_cnt()
2567 		sbi->peak_atomic_write = current_write;  in inc_atomic_write_cnt()
2572 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);  in release_atomic_write_cnt()  local
2575 	atomic64_sub(fi->atomic_write_cnt, &sbi->current_atomic_write);  in release_atomic_write_cnt()
2579 static inline s64 get_pages(struct f2fs_sb_info *sbi, int count_type)  in get_pages()  argument
2581 	return atomic_read(&sbi->nr_pages[count_type]);  in get_pages()
2589 static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)  in get_blocktype_secs()  argument
2591 	return div_u64(get_pages(sbi, block_type) + BLKS_PER_SEC(sbi) - 1,  in get_blocktype_secs()
2592 							BLKS_PER_SEC(sbi));  in get_blocktype_secs()
2595 static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)  in valid_user_blocks()  argument
2597 	return sbi->total_valid_block_count;  in valid_user_blocks()
2600 static inline block_t discard_blocks(struct f2fs_sb_info *sbi)  in discard_blocks()  argument
2602 	return sbi->discard_blks;  in discard_blocks()
2605 static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)  in __bitmap_size()  argument
2607 	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);  in __bitmap_size()
2618 static inline block_t __cp_payload(struct f2fs_sb_info *sbi)  in __cp_payload()  argument
2620 	return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);  in __cp_payload()
2623 static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)  in __bitmap_ptr()  argument
2625 	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);  in __bitmap_ptr()
2629 	if (is_set_ckpt_flags(sbi, CP_LARGE_NAT_BITMAP_FLAG)) {  in __bitmap_ptr()
2639 	if (__cp_payload(sbi) > 0) {  in __bitmap_ptr()
2651 static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)  in __start_cp_addr()  argument
2653 	block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);  in __start_cp_addr()
2655 	if (sbi->cur_cp_pack == 2)  in __start_cp_addr()
2656 		start_addr += BLKS_PER_SEG(sbi);  in __start_cp_addr()
2660 static inline block_t __start_cp_next_addr(struct f2fs_sb_info *sbi)  in __start_cp_next_addr()  argument
2662 	block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);  in __start_cp_next_addr()
2664 	if (sbi->cur_cp_pack == 1)  in __start_cp_next_addr()
2665 		start_addr += BLKS_PER_SEG(sbi);  in __start_cp_next_addr()
2669 static inline void __set_cp_next_pack(struct f2fs_sb_info *sbi)  in __set_cp_next_pack()  argument
2671 	sbi->cur_cp_pack = (sbi->cur_cp_pack == 1) ? 2 : 1;  in __set_cp_next_pack()
2674 static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)  in __start_sum_addr()  argument
2676 	return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);  in __start_sum_addr()
2680 static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,  in inc_valid_node_count()  argument
2700 	if (time_to_inject(sbi, FAULT_BLOCK))  in inc_valid_node_count()
2703 	spin_lock(&sbi->stat_lock);  in inc_valid_node_count()
2705 	valid_block_count = sbi->total_valid_block_count + 1;  in inc_valid_node_count()
2706 	avail_user_block_count = get_available_block_count(sbi, inode, false);  in inc_valid_node_count()
2709 		spin_unlock(&sbi->stat_lock);  in inc_valid_node_count()
2713 	valid_node_count = sbi->total_valid_node_count + 1;  in inc_valid_node_count()
2714 	if (unlikely(valid_node_count > sbi->total_node_count)) {  in inc_valid_node_count()
2715 		spin_unlock(&sbi->stat_lock);  in inc_valid_node_count()
2719 	sbi->total_valid_node_count++;  in inc_valid_node_count()
2720 	sbi->total_valid_block_count++;  in inc_valid_node_count()
2721 	spin_unlock(&sbi->stat_lock);  in inc_valid_node_count()
2730 	percpu_counter_inc(&sbi->alloc_valid_block_count);  in inc_valid_node_count()
2743 static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,  in dec_valid_node_count()  argument
2746 	spin_lock(&sbi->stat_lock);  in dec_valid_node_count()
2748 	if (unlikely(!sbi->total_valid_block_count ||  in dec_valid_node_count()
2749 			!sbi->total_valid_node_count)) {  in dec_valid_node_count()
2750 …f2fs_warn(sbi, "dec_valid_node_count: inconsistent block counts, total_valid_block:%u, total_valid…  in dec_valid_node_count()
2751 			  sbi->total_valid_block_count,  in dec_valid_node_count()
2752 			  sbi->total_valid_node_count);  in dec_valid_node_count()
2753 		set_sbi_flag(sbi, SBI_NEED_FSCK);  in dec_valid_node_count()
2755 		sbi->total_valid_block_count--;  in dec_valid_node_count()
2756 		sbi->total_valid_node_count--;  in dec_valid_node_count()
2759 	if (sbi->reserved_blocks &&  in dec_valid_node_count()
2760 		sbi->current_reserved_blocks < sbi->reserved_blocks)  in dec_valid_node_count()
2761 		sbi->current_reserved_blocks++;  in dec_valid_node_count()
2763 	spin_unlock(&sbi->stat_lock);  in dec_valid_node_count()
2769 			f2fs_warn(sbi, "dec_valid_node_count: inconsistent i_blocks, ino:%lu, iblocks:%llu",  in dec_valid_node_count()
2772 			set_sbi_flag(sbi, SBI_NEED_FSCK);  in dec_valid_node_count()
2779 static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)  in valid_node_count()  argument
2781 	return sbi->total_valid_node_count;  in valid_node_count()
2784 static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)  in inc_valid_inode_count()  argument
2786 	percpu_counter_inc(&sbi->total_valid_inode_count);  in inc_valid_inode_count()
2789 static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)  in dec_valid_inode_count()  argument
2791 	percpu_counter_dec(&sbi->total_valid_inode_count);  in dec_valid_inode_count()
2794 static inline s64 valid_inode_count(struct f2fs_sb_info *sbi)  in valid_inode_count()  argument
2796 	return percpu_counter_sum_positive(&sbi->total_valid_inode_count);  in valid_inode_count()
2878 			gfp_t flags, bool nofail, struct f2fs_sb_info *sbi)  in f2fs_kmem_cache_alloc()  argument
2883 	if (time_to_inject(sbi, FAULT_SLAB_ALLOC))  in f2fs_kmem_cache_alloc()
2889 static inline bool is_inflight_io(struct f2fs_sb_info *sbi, int type)  in is_inflight_io()  argument
2891 	if (get_pages(sbi, F2FS_RD_DATA) || get_pages(sbi, F2FS_RD_NODE) ||  in is_inflight_io()
2892 		get_pages(sbi, F2FS_RD_META) || get_pages(sbi, F2FS_WB_DATA) ||  in is_inflight_io()
2893 		get_pages(sbi, F2FS_WB_CP_DATA) ||  in is_inflight_io()
2894 		get_pages(sbi, F2FS_DIO_READ) ||  in is_inflight_io()
2895 		get_pages(sbi, F2FS_DIO_WRITE))  in is_inflight_io()
2898 	if (type != DISCARD_TIME && SM_I(sbi) && SM_I(sbi)->dcc_info &&  in is_inflight_io()
2899 			atomic_read(&SM_I(sbi)->dcc_info->queued_discard))  in is_inflight_io()
2902 	if (SM_I(sbi) && SM_I(sbi)->fcc_info &&  in is_inflight_io()
2903 			atomic_read(&SM_I(sbi)->fcc_info->queued_flush))  in is_inflight_io()
2908 static inline bool is_inflight_read_io(struct f2fs_sb_info *sbi)  in is_inflight_read_io()  argument
2910 	return get_pages(sbi, F2FS_RD_DATA) || get_pages(sbi, F2FS_DIO_READ);  in is_inflight_read_io()
2913 static inline bool is_idle(struct f2fs_sb_info *sbi, int type)  in is_idle()  argument
2916 			F2FS_HAS_FEATURE(sbi, F2FS_FEATURE_BLKZONED));  in is_idle()
2918 	if (sbi->gc_mode == GC_URGENT_HIGH)  in is_idle()
2922 		if (is_inflight_read_io(sbi))  in is_idle()
2925 		if (is_inflight_io(sbi, type))  in is_idle()
2929 	if (sbi->gc_mode == GC_URGENT_MID)  in is_idle()
2932 	if (sbi->gc_mode == GC_URGENT_LOW &&  in is_idle()
2939 	return f2fs_time_over(sbi, type);  in is_idle()
3408 		struct f2fs_sb_info *sbi = F2FS_I_SB(inode);  in f2fs_skip_inode_update()  local
3410 		spin_lock(&sbi->inode_lock[DIRTY_META]);  in f2fs_skip_inode_update()
3412 		spin_unlock(&sbi->inode_lock[DIRTY_META]);  in f2fs_skip_inode_update()
3435 static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)  in f2fs_cp_error()  argument
3437 	return is_set_ckpt_flags(sbi, CP_ERROR_FLAG);  in f2fs_cp_error()
3440 static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,  in f2fs_kmalloc()  argument
3443 	if (time_to_inject(sbi, FAULT_KMALLOC))  in f2fs_kmalloc()
3449 static inline void *f2fs_getname(struct f2fs_sb_info *sbi)  in f2fs_getname()  argument
3451 	if (time_to_inject(sbi, FAULT_KMALLOC))  in f2fs_getname()
3462 static inline void *f2fs_kzalloc(struct f2fs_sb_info *sbi,  in f2fs_kzalloc()  argument
3465 	return f2fs_kmalloc(sbi, size, flags | __GFP_ZERO);  in f2fs_kzalloc()
3468 static inline void *f2fs_kvmalloc(struct f2fs_sb_info *sbi,  in f2fs_kvmalloc()  argument
3471 	if (time_to_inject(sbi, FAULT_KVMALLOC))  in f2fs_kvmalloc()
3477 static inline void *f2fs_kvzalloc(struct f2fs_sb_info *sbi,  in f2fs_kvzalloc()  argument
3480 	return f2fs_kvmalloc(sbi, size, flags | __GFP_ZERO);  in f2fs_kvzalloc()
3509 #define __is_large_section(sbi)		(SEGS_PER_SEC(sbi) > 1)  argument
3513 bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
3515 static inline void verify_blkaddr(struct f2fs_sb_info *sbi,  in verify_blkaddr()  argument
3518 	if (!f2fs_is_valid_blkaddr(sbi, blkaddr, type))  in verify_blkaddr()
3519 		f2fs_err(sbi, "invalid blkaddr: %u, type: %d, run fsck to fix.",  in verify_blkaddr()
3544 int f2fs_do_shutdown(struct f2fs_sb_info *sbi, unsigned int flag,
3559 bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct page *page);
3560 void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct page *page);
3563 int f2fs_try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink);
3573 int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
3657 int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly);
3661 void f2fs_save_errors(struct f2fs_sb_info *sbi, unsigned char flag);
3662 void f2fs_handle_critical_error(struct f2fs_sb_info *sbi, unsigned char reason);
3663 void f2fs_handle_error(struct f2fs_sb_info *sbi, unsigned char error);
3664 void f2fs_handle_error_async(struct f2fs_sb_info *sbi, unsigned char error);
3665 int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover);
3667 int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi);
3679 int f2fs_check_nid_range(struct f2fs_sb_info *sbi, nid_t nid);
3680 bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type);
3681 bool f2fs_in_warm_node_list(struct f2fs_sb_info *sbi, struct page *page);
3682 void f2fs_init_fsync_node_info(struct f2fs_sb_info *sbi);
3683 void f2fs_del_fsync_node_entry(struct f2fs_sb_info *sbi, struct page *page);
3684 void f2fs_reset_fsync_node_info(struct f2fs_sb_info *sbi);
3685 int f2fs_need_dentry_mark(struct f2fs_sb_info *sbi, nid_t nid);
3686 bool f2fs_is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid);
3687 bool f2fs_need_inode_block_update(struct f2fs_sb_info *sbi, nid_t ino);
3688 int f2fs_get_node_info(struct f2fs_sb_info *sbi, nid_t nid,
3694 int f2fs_wait_on_node_pages_writeback(struct f2fs_sb_info *sbi,
3699 void f2fs_ra_node_page(struct f2fs_sb_info *sbi, nid_t nid);
3700 struct page *f2fs_get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid);
3703 void f2fs_flush_inline_data(struct f2fs_sb_info *sbi);
3704 int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
3707 int f2fs_sync_node_pages(struct f2fs_sb_info *sbi,
3710 int f2fs_build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool mount);
3711 bool f2fs_alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid);
3712 void f2fs_alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid);
3713 void f2fs_alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid);
3714 int f2fs_try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink);
3717 int f2fs_recover_inode_page(struct f2fs_sb_info *sbi, struct page *page);
3718 int f2fs_restore_node_summary(struct f2fs_sb_info *sbi,
3720 int f2fs_flush_nat_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3721 int f2fs_build_node_manager(struct f2fs_sb_info *sbi);
3722 void f2fs_destroy_node_manager(struct f2fs_sb_info *sbi);
3729 bool f2fs_need_SSR(struct f2fs_sb_info *sbi);
3732 void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need);
3733 void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi, bool from_bg);
3734 int f2fs_issue_flush(struct f2fs_sb_info *sbi, nid_t ino);
3735 int f2fs_create_flush_cmd_control(struct f2fs_sb_info *sbi);
3736 int f2fs_flush_device_cache(struct f2fs_sb_info *sbi);
3737 void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free);
3738 void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr,
3740 bool f2fs_is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
3741 int f2fs_start_discard_thread(struct f2fs_sb_info *sbi);
3742 void f2fs_drop_discard_cmd(struct f2fs_sb_info *sbi);
3743 void f2fs_stop_discard_thread(struct f2fs_sb_info *sbi);
3744 bool f2fs_issue_discard_timeout(struct f2fs_sb_info *sbi);
3745 void f2fs_clear_prefree_segments(struct f2fs_sb_info *sbi,
3747 void f2fs_dirty_to_prefree(struct f2fs_sb_info *sbi);
3748 block_t f2fs_get_unusable_blocks(struct f2fs_sb_info *sbi);
3749 int f2fs_disable_cp_again(struct f2fs_sb_info *sbi, block_t unusable);
3750 void f2fs_release_discard_addrs(struct f2fs_sb_info *sbi);
3751 int f2fs_npages_for_summary_flush(struct f2fs_sb_info *sbi, bool for_ra);
3752 bool f2fs_segment_has_free_slot(struct f2fs_sb_info *sbi, int segno);
3753 int f2fs_init_inmem_curseg(struct f2fs_sb_info *sbi);
3754 int f2fs_reinit_atgc_curseg(struct f2fs_sb_info *sbi);
3755 void f2fs_save_inmem_curseg(struct f2fs_sb_info *sbi);
3756 void f2fs_restore_inmem_curseg(struct f2fs_sb_info *sbi);
3757 int f2fs_allocate_segment_for_resize(struct f2fs_sb_info *sbi, int type,
3759 int f2fs_allocate_new_section(struct f2fs_sb_info *sbi, int type, bool force);
3760 int f2fs_allocate_pinning_section(struct f2fs_sb_info *sbi);
3761 int f2fs_allocate_new_segments(struct f2fs_sb_info *sbi);
3762 int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range);
3763 bool f2fs_exist_trim_candidates(struct f2fs_sb_info *sbi,
3765 struct page *f2fs_get_sum_page(struct f2fs_sb_info *sbi, unsigned int segno);
3766 void f2fs_update_meta_page(struct f2fs_sb_info *sbi, void *src,
3768 void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct folio *folio,
3774 void f2fs_do_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
3778 void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
3782 enum temp_type f2fs_get_segment_temp(struct f2fs_sb_info *sbi,
3784 int f2fs_allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
3788 void f2fs_update_device_state(struct f2fs_sb_info *sbi, nid_t ino,
3795 void f2fs_write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
3796 void f2fs_write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
3799 void f2fs_flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3800 int f2fs_check_and_fix_write_pointer(struct f2fs_sb_info *sbi);
3801 int f2fs_build_segment_manager(struct f2fs_sb_info *sbi);
3802 void f2fs_destroy_segment_manager(struct f2fs_sb_info *sbi);
3805 int f2fs_rw_hint_to_seg_type(struct f2fs_sb_info *sbi, enum rw_hint hint);
3806 enum rw_hint f2fs_io_type_to_rw_hint(struct f2fs_sb_info *sbi,
3808 unsigned int f2fs_usable_segs_in_sec(struct f2fs_sb_info *sbi);
3809 unsigned int f2fs_usable_blks_in_seg(struct f2fs_sb_info *sbi,
3811 unsigned long long f2fs_get_section_mtime(struct f2fs_sb_info *sbi,
3818 static inline bool f2fs_need_rand_seg(struct f2fs_sb_info *sbi)  in f2fs_need_rand_seg()  argument
3820 	return F2FS_OPTION(sbi).fs_mode == FS_MODE_FRAGMENT_SEG ||  in f2fs_need_rand_seg()
3821 		F2FS_OPTION(sbi).fs_mode == FS_MODE_FRAGMENT_BLK;  in f2fs_need_rand_seg()
3827 void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io,
3829 void f2fs_flush_ckpt_thread(struct f2fs_sb_info *sbi);
3830 struct page *f2fs_grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
3831 struct page *f2fs_get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
3832 struct page *f2fs_get_meta_page_retry(struct f2fs_sb_info *sbi, pgoff_t index);
3833 struct page *f2fs_get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index);
3834 bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
3836 bool f2fs_is_valid_blkaddr_raw(struct f2fs_sb_info *sbi,
3838 int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
3840 void f2fs_ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index,
3842 long f2fs_sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
3844 void f2fs_add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
3845 void f2fs_remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
3846 void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all);
3847 bool f2fs_exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode);
3848 void f2fs_set_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
3850 bool f2fs_is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
3852 int f2fs_acquire_orphan_inode(struct f2fs_sb_info *sbi);
3853 void f2fs_release_orphan_inode(struct f2fs_sb_info *sbi);
3855 void f2fs_remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino);
3856 int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi);
3857 int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi);
3860 int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type,
3862 void f2fs_wait_on_all_pages(struct f2fs_sb_info *sbi, int type);
3863 u64 f2fs_get_sectors_written(struct f2fs_sb_info *sbi);
3864 int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3865 void f2fs_init_ino_entry_info(struct f2fs_sb_info *sbi);
3868 int f2fs_issue_checkpoint(struct f2fs_sb_info *sbi);
3869 int f2fs_start_ckpt_thread(struct f2fs_sb_info *sbi);
3870 void f2fs_stop_ckpt_thread(struct f2fs_sb_info *sbi);
3871 void f2fs_init_ckpt_req_control(struct f2fs_sb_info *sbi);
3881 void f2fs_submit_read_bio(struct f2fs_sb_info *sbi, struct bio *bio,
3883 int f2fs_init_write_merge_io(struct f2fs_sb_info *sbi);
3884 void f2fs_submit_merged_write(struct f2fs_sb_info *sbi, enum page_type type);
3885 void f2fs_submit_merged_write_cond(struct f2fs_sb_info *sbi,
3888 void f2fs_submit_merged_ipu_write(struct f2fs_sb_info *sbi,
3890 void f2fs_flush_merged_writes(struct f2fs_sb_info *sbi);
3894 struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,
3896 int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr);
3930 int f2fs_init_post_read_wq(struct f2fs_sb_info *sbi);
3931 void f2fs_destroy_post_read_wq(struct f2fs_sb_info *sbi);
3937 int f2fs_start_gc_thread(struct f2fs_sb_info *sbi);
3938 void f2fs_stop_gc_thread(struct f2fs_sb_info *sbi);
3940 int f2fs_gc(struct f2fs_sb_info *sbi, struct f2fs_gc_control *gc_control);
3941 void f2fs_build_gc_manager(struct f2fs_sb_info *sbi);
3942 int f2fs_gc_range(struct f2fs_sb_info *sbi,
3949 int f2fs_get_victim(struct f2fs_sb_info *sbi, unsigned int *result,
3956 int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only);
3957 bool f2fs_space_for_roll_forward(struct f2fs_sb_info *sbi);
3980 	struct f2fs_sb_info *sbi;  member
4044 static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)  in F2FS_STAT()  argument
4046 	return (struct f2fs_stat_info *)sbi->stat_info;  in F2FS_STAT()
4049 #define stat_inc_cp_call_count(sbi, foreground)				\  argument
4050 		atomic_inc(&sbi->cp_call_count[(foreground)])
4051 #define stat_inc_cp_count(sbi)		(F2FS_STAT(sbi)->cp_count++)  argument
4052 #define stat_io_skip_bggc_count(sbi)	((sbi)->io_skip_bggc++)  argument
4053 #define stat_other_skip_bggc_count(sbi)	((sbi)->other_skip_bggc++)  argument
4054 #define stat_inc_dirty_inode(sbi, type)	((sbi)->ndirty_inode[type]++)  argument
4055 #define stat_dec_dirty_inode(sbi, type)	((sbi)->ndirty_inode[type]--)  argument
4056 #define stat_inc_total_hit(sbi, type)		(atomic64_inc(&(sbi)->total_hit_ext[type]))  argument
4057 #define stat_inc_rbtree_node_hit(sbi, type)	(atomic64_inc(&(sbi)->read_hit_rbtree[type]))  argument
4058 #define stat_inc_largest_node_hit(sbi)	(atomic64_inc(&(sbi)->read_hit_largest))  argument
4059 #define stat_inc_cached_node_hit(sbi, type)	(atomic64_inc(&(sbi)->read_hit_cached[type]))  argument
4112 #define stat_inc_meta_count(sbi, blkaddr)				\  argument
4114 		if (blkaddr < SIT_I(sbi)->sit_base_addr)		\
4115 			atomic_inc(&(sbi)->meta_count[META_CP]);	\
4116 		else if (blkaddr < NM_I(sbi)->nat_blkaddr)		\
4117 			atomic_inc(&(sbi)->meta_count[META_SIT]);	\
4118 		else if (blkaddr < SM_I(sbi)->ssa_blkaddr)		\
4119 			atomic_inc(&(sbi)->meta_count[META_NAT]);	\
4120 		else if (blkaddr < SM_I(sbi)->main_blkaddr)		\
4121 			atomic_inc(&(sbi)->meta_count[META_SSA]);	\
4123 #define stat_inc_seg_type(sbi, curseg)					\  argument
4124 		((sbi)->segment_count[(curseg)->alloc_type]++)
4125 #define stat_inc_block_count(sbi, curseg)				\  argument
4126 		((sbi)->block_count[(curseg)->alloc_type]++)
4127 #define stat_inc_inplace_blocks(sbi)					\  argument
4128 		(atomic_inc(&(sbi)->inplace_count))
4136 #define stat_inc_gc_call_count(sbi, foreground)				\  argument
4137 		(F2FS_STAT(sbi)->gc_call_count[(foreground)]++)
4138 #define stat_inc_gc_sec_count(sbi, type, gc_type)			\  argument
4139 		(F2FS_STAT(sbi)->gc_secs[(type)][(gc_type)]++)
4140 #define stat_inc_gc_seg_count(sbi, type, gc_type)			\  argument
4141 		(F2FS_STAT(sbi)->gc_segs[(type)][(gc_type)]++)
4146 #define stat_inc_data_blk_count(sbi, blks, gc_type)			\  argument
4148 		struct f2fs_stat_info *si = F2FS_STAT(sbi);		\
4154 #define stat_inc_node_blk_count(sbi, blks, gc_type)			\  argument
4156 		struct f2fs_stat_info *si = F2FS_STAT(sbi);		\
4162 int f2fs_build_stats(struct f2fs_sb_info *sbi);
4163 void f2fs_destroy_stats(struct f2fs_sb_info *sbi);
4166 void f2fs_update_sit_info(struct f2fs_sb_info *sbi);
4168 #define stat_inc_cp_call_count(sbi, foreground)		do { } while (0)  argument
4169 #define stat_inc_cp_count(sbi)				do { } while (0)  argument
4170 #define stat_io_skip_bggc_count(sbi)			do { } while (0)  argument
4171 #define stat_other_skip_bggc_count(sbi)			do { } while (0)  argument
4172 #define stat_inc_dirty_inode(sbi, type)			do { } while (0)  argument
4173 #define stat_dec_dirty_inode(sbi, type)			do { } while (0)  argument
4174 #define stat_inc_total_hit(sbi, type)			do { } while (0)  argument
4175 #define stat_inc_rbtree_node_hit(sbi, type)		do { } while (0)  argument
4176 #define stat_inc_largest_node_hit(sbi)			do { } while (0)  argument
4177 #define stat_inc_cached_node_hit(sbi, type)		do { } while (0)  argument
4193 #define stat_inc_meta_count(sbi, blkaddr)		do { } while (0)  argument
4194 #define stat_inc_seg_type(sbi, curseg)			do { } while (0)  argument
4195 #define stat_inc_block_count(sbi, curseg)		do { } while (0)  argument
4196 #define stat_inc_inplace_blocks(sbi)			do { } while (0)  argument
4197 #define stat_inc_gc_call_count(sbi, foreground)		do { } while (0)  argument
4198 #define stat_inc_gc_sec_count(sbi, type, gc_type)	do { } while (0)  argument
4199 #define stat_inc_gc_seg_count(sbi, type, gc_type)	do { } while (0)  argument
4201 #define stat_inc_data_blk_count(sbi, blks, gc_type)	do { } while (0)  argument
4202 #define stat_inc_node_blk_count(sbi, blks, gc_type)	do { } while (0)  argument
4204 static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }  in f2fs_build_stats()  argument
4205 static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }  in f2fs_destroy_stats()  argument
4208 static inline void f2fs_update_sit_info(struct f2fs_sb_info *sbi) {}  in f2fs_update_sit_info()  argument
4263 void f2fs_join_shrinker(struct f2fs_sb_info *sbi);
4264 void f2fs_leave_shrinker(struct f2fs_sb_info *sbi);
4274 void f2fs_init_extent_cache_info(struct f2fs_sb_info *sbi);
4287 unsigned int f2fs_shrink_read_extent_tree(struct f2fs_sb_info *sbi,
4297 unsigned int f2fs_shrink_age_extent_tree(struct f2fs_sb_info *sbi,
4308 int f2fs_register_sysfs(struct f2fs_sb_info *sbi);
4309 void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi);
4400 void f2fs_init_compress_info(struct f2fs_sb_info *sbi);
4401 int f2fs_init_compress_inode(struct f2fs_sb_info *sbi);
4402 void f2fs_destroy_compress_inode(struct f2fs_sb_info *sbi);
4403 int f2fs_init_page_array_cache(struct f2fs_sb_info *sbi);
4404 void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi);
4407 struct address_space *COMPRESS_MAPPING(struct f2fs_sb_info *sbi);
4408 void f2fs_invalidate_compress_pages_range(struct f2fs_sb_info *sbi,
4410 void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
4412 bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
4414 void f2fs_invalidate_compress_pages(struct f2fs_sb_info *sbi, nid_t ino);
4417 		struct f2fs_sb_info *sbi = F2FS_I_SB(inode);		\
4418 		sbi->compr_new_inode++;					\
4422 		struct f2fs_sb_info *sbi = F2FS_I_SB(inode);		\
4424 		sbi->compr_written_block += blocks;			\
4425 		sbi->compr_saved_block += diff;				\
4458 static inline int f2fs_init_compress_inode(struct f2fs_sb_info *sbi) { return 0; }  in f2fs_init_compress_inode()  argument
4459 static inline void f2fs_destroy_compress_inode(struct f2fs_sb_info *sbi) { }  in f2fs_destroy_compress_inode()  argument
4460 static inline int f2fs_init_page_array_cache(struct f2fs_sb_info *sbi) { return 0; }  in f2fs_init_page_array_cache()  argument
4461 static inline void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi) { }  in f2fs_destroy_page_array_cache()  argument
4464 static inline void f2fs_invalidate_compress_pages_range(struct f2fs_sb_info *sbi,  in f2fs_invalidate_compress_pages_range()  argument
4466 static inline void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi,  in f2fs_cache_compressed_page()  argument
4468 static inline bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi,  in f2fs_load_compressed_page()  argument
4470 static inline void f2fs_invalidate_compress_pages(struct f2fs_sb_info *sbi,  in f2fs_invalidate_compress_pages()  argument
4488 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);  in set_compress_context()  local
4491 	fi->i_compress_algorithm = F2FS_OPTION(sbi).compress_algorithm;  in set_compress_context()
4492 	fi->i_log_cluster_size = F2FS_OPTION(sbi).compress_log_size;  in set_compress_context()
4493 	fi->i_compress_flag = F2FS_OPTION(sbi).compress_chksum ?  in set_compress_context()
4498 			F2FS_OPTION(sbi).compress_level)  in set_compress_context()
4499 		fi->i_compress_level = F2FS_OPTION(sbi).compress_level;  in set_compress_context()
4537 static inline bool f2fs_sb_has_##name(struct f2fs_sb_info *sbi) \
4539 	return F2FS_HAS_FEATURE(sbi, F2FS_FEATURE_##flagname); \
4559 static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,  in f2fs_blkz_is_seq()  argument
4562 	unsigned int zno = blkaddr / sbi->blocks_per_blkz;  in f2fs_blkz_is_seq()
4568 static inline int f2fs_bdev_index(struct f2fs_sb_info *sbi,  in f2fs_bdev_index()  argument
4573 	if (!f2fs_is_multi_device(sbi))  in f2fs_bdev_index()
4576 	for (i = 0; i < sbi->s_ndevs; i++)  in f2fs_bdev_index()
4584 static inline bool f2fs_hw_should_discard(struct f2fs_sb_info *sbi)  in f2fs_hw_should_discard()  argument
4586 	return f2fs_sb_has_blkzoned(sbi);  in f2fs_hw_should_discard()
4594 static inline bool f2fs_hw_support_discard(struct f2fs_sb_info *sbi)  in f2fs_hw_support_discard()  argument
4598 	if (!f2fs_is_multi_device(sbi))  in f2fs_hw_support_discard()
4599 		return f2fs_bdev_support_discard(sbi->sb->s_bdev);  in f2fs_hw_support_discard()
4601 	for (i = 0; i < sbi->s_ndevs; i++)  in f2fs_hw_support_discard()
4607 static inline bool f2fs_realtime_discard_enable(struct f2fs_sb_info *sbi)  in f2fs_realtime_discard_enable()  argument
4609 	return (test_opt(sbi, DISCARD) && f2fs_hw_support_discard(sbi)) ||  in f2fs_realtime_discard_enable()
4610 					f2fs_hw_should_discard(sbi);  in f2fs_realtime_discard_enable()
4613 static inline bool f2fs_hw_is_readonly(struct f2fs_sb_info *sbi)  in f2fs_hw_is_readonly()  argument
4617 	if (!f2fs_is_multi_device(sbi))  in f2fs_hw_is_readonly()
4618 		return bdev_read_only(sbi->sb->s_bdev);  in f2fs_hw_is_readonly()
4620 	for (i = 0; i < sbi->s_ndevs; i++)  in f2fs_hw_is_readonly()
4626 static inline bool f2fs_dev_is_readonly(struct f2fs_sb_info *sbi)  in f2fs_dev_is_readonly()  argument
4628 	return f2fs_sb_has_readonly(sbi) || f2fs_hw_is_readonly(sbi);  in f2fs_dev_is_readonly()
4631 static inline bool f2fs_lfs_mode(struct f2fs_sb_info *sbi)  in f2fs_lfs_mode()  argument
4633 	return F2FS_OPTION(sbi).fs_mode == FS_MODE_LFS;  in f2fs_lfs_mode()
4636 static inline bool f2fs_valid_pinned_area(struct f2fs_sb_info *sbi,  in f2fs_valid_pinned_area()  argument
4639 	if (f2fs_sb_has_blkzoned(sbi)) {  in f2fs_valid_pinned_area()
4640 		int devi = f2fs_target_device_index(sbi, blkaddr);  in f2fs_valid_pinned_area()
4647 static inline bool f2fs_low_mem_mode(struct f2fs_sb_info *sbi)  in f2fs_low_mem_mode()  argument
4649 	return F2FS_OPTION(sbi).memory_mode == MEMORY_MODE_LOW;  in f2fs_low_mem_mode()
4681 static inline bool f2fs_allow_multi_device_dio(struct f2fs_sb_info *sbi,  in f2fs_allow_multi_device_dio()  argument
4684 	if (!f2fs_is_multi_device(sbi))  in f2fs_allow_multi_device_dio()
4688 	return sbi->aligned_blksize;  in f2fs_allow_multi_device_dio()
4698 extern int f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned long rate,
4701 static inline int f2fs_build_fault_attr(struct f2fs_sb_info *sbi,  in f2fs_build_fault_attr()  argument
4708 static inline bool is_journalled_quota(struct f2fs_sb_info *sbi)  in is_journalled_quota()  argument
4711 	if (f2fs_sb_has_quota_ino(sbi))  in is_journalled_quota()
4713 	if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||  in is_journalled_quota()
4714 		F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||  in is_journalled_quota()
4715 		F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])  in is_journalled_quota()
4721 static inline bool f2fs_block_unit_discard(struct f2fs_sb_info *sbi)  in f2fs_block_unit_discard()  argument
4723 	return F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_BLOCK;  in f2fs_block_unit_discard()
4732 static inline void f2fs_handle_page_eio(struct f2fs_sb_info *sbi,  in f2fs_handle_page_eio()  argument
4737 	if (unlikely(f2fs_cp_error(sbi)))  in f2fs_handle_page_eio()
4740 	if (ofs == sbi->page_eio_ofs[type]) {  in f2fs_handle_page_eio()
4741 		if (sbi->page_eio_cnt[type]++ == MAX_RETRY_PAGE_EIO)  in f2fs_handle_page_eio()
4742 			set_ckpt_flags(sbi, CP_ERROR_FLAG);  in f2fs_handle_page_eio()
4744 		sbi->page_eio_ofs[type] = ofs;  in f2fs_handle_page_eio()
4745 		sbi->page_eio_cnt[type] = 0;  in f2fs_handle_page_eio()
4749 static inline bool f2fs_is_readonly(struct f2fs_sb_info *sbi)  in f2fs_is_readonly()  argument
4751 	return f2fs_sb_has_readonly(sbi) || f2fs_readonly(sbi->sb);  in f2fs_is_readonly()
4754 static inline void f2fs_truncate_meta_inode_pages(struct f2fs_sb_info *sbi,  in f2fs_truncate_meta_inode_pages()  argument
4763 		page = find_get_page(META_MAPPING(sbi), blkaddr + i);  in f2fs_truncate_meta_inode_pages()
4772 		f2fs_submit_merged_write_cond(sbi, sbi->meta_inode,  in f2fs_truncate_meta_inode_pages()
4775 	truncate_inode_pages_range(META_MAPPING(sbi),  in f2fs_truncate_meta_inode_pages()
4780 static inline void f2fs_invalidate_internal_cache(struct f2fs_sb_info *sbi,  in f2fs_invalidate_internal_cache()  argument
4783 	f2fs_truncate_meta_inode_pages(sbi, blkaddr, len);  in f2fs_invalidate_internal_cache()
4784 	f2fs_invalidate_compress_pages_range(sbi, blkaddr, len);  in f2fs_invalidate_internal_cache()