32 #define f2fs_bug_on(sbi, condition)	BUG_ON(condition)  argument
34 #define f2fs_bug_on(sbi, condition)					\  argument
37 			set_sbi_flag(sbi, SBI_NEED_FSCK);		\
105 #define F2FS_OPTION(sbi)	((sbi)->mount_opt)  argument
106 #define clear_opt(sbi, option)	(F2FS_OPTION(sbi).opt &= ~F2FS_MOUNT_##option)  argument
107 #define set_opt(sbi, option)	(F2FS_OPTION(sbi).opt |= F2FS_MOUNT_##option)  argument
108 #define test_opt(sbi, option)	(F2FS_OPTION(sbi).opt & F2FS_MOUNT_##option)  argument
185 #define F2FS_HAS_FEATURE(sbi, mask)	__F2FS_HAS_FEATURE(sbi->raw_super, mask)  argument
186 #define F2FS_SET_FEATURE(sbi, mask)					\  argument
187 	(sbi->raw_super->feature |= cpu_to_le32(mask))
188 #define F2FS_CLEAR_FEATURE(sbi, mask)					\  argument
189 	(sbi->raw_super->feature &= ~cpu_to_le32(mask))
214 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)  argument
593 	struct list_head list;		/* node in global extent list of sbi */
602 	struct list_head list;		/* to be used by sbi->zombie_list */
1152 	struct f2fs_sb_info *sbi;	/* f2fs_sb_info pointer */  member
1185 	struct f2fs_sb_info *sbi;	/* f2fs superblock */  member
1196 #define FDEV(i)				(sbi->devs[i])
1558 	unsigned long s_flag;				/* flags for sbi */
1798 #define f2fs_show_injection_info(sbi, type)					\  argument
1800 		KERN_INFO, sbi->sb->s_id,				\
1803 static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)  in time_to_inject()  argument
1805 	struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;  in time_to_inject()
1821 #define f2fs_show_injection_info(sbi, type) do { } while (0)  argument
1822 static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)  in time_to_inject()  argument
1830  *   - For a single regular disk volume, sbi->s_ndevs is 0.
1831  *   - For a single zoned disk volume, sbi->s_ndevs is 1.
1832  *   - For a multi-device volume, sbi->s_ndevs is always 2 or more.
1834 static inline bool f2fs_is_multi_device(struct f2fs_sb_info *sbi)  in f2fs_is_multi_device()  argument
1836 	return sbi->s_ndevs > 1;  in f2fs_is_multi_device()
1839 static inline void f2fs_update_time(struct f2fs_sb_info *sbi, int type)  in f2fs_update_time()  argument
1843 	sbi->last_time[type] = now;  in f2fs_update_time()
1847 		sbi->last_time[DISCARD_TIME] = now;  in f2fs_update_time()
1848 		sbi->last_time[GC_TIME] = now;  in f2fs_update_time()
1852 static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)  in f2fs_time_over()  argument
1854 	unsigned long interval = sbi->interval_time[type] * HZ;  in f2fs_time_over()
1856 	return time_after(jiffies, sbi->last_time[type] + interval);  in f2fs_time_over()
1859 static inline unsigned int f2fs_time_to_wait(struct f2fs_sb_info *sbi,  in f2fs_time_to_wait()  argument
1862 	unsigned long interval = sbi->interval_time[type] * HZ;  in f2fs_time_to_wait()
1866 	delta = (sbi->last_time[type] + interval) - jiffies;  in f2fs_time_to_wait()
1876 static inline u32 __f2fs_crc32(struct f2fs_sb_info *sbi, u32 crc,  in __f2fs_crc32()  argument
1885 	BUG_ON(crypto_shash_descsize(sbi->s_chksum_driver) != sizeof(desc.ctx));  in __f2fs_crc32()
1887 	desc.shash.tfm = sbi->s_chksum_driver;  in __f2fs_crc32()
1896 static inline u32 f2fs_crc32(struct f2fs_sb_info *sbi, const void *address,  in f2fs_crc32()  argument
1899 	return __f2fs_crc32(sbi, F2FS_SUPER_MAGIC, address, length);  in f2fs_crc32()
1902 static inline bool f2fs_crc_valid(struct f2fs_sb_info *sbi, __u32 blk_crc,  in f2fs_crc_valid()  argument
1905 	return f2fs_crc32(sbi, buf, buf_size) == blk_crc;  in f2fs_crc_valid()
1908 static inline u32 f2fs_chksum(struct f2fs_sb_info *sbi, u32 crc,  in f2fs_chksum()  argument
1911 	return __f2fs_crc32(sbi, crc, address, length);  in f2fs_chksum()
1939 static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)  in F2FS_RAW_SUPER()  argument
1941 	return (struct f2fs_super_block *)(sbi->raw_super);  in F2FS_RAW_SUPER()
1944 static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)  in F2FS_CKPT()  argument
1946 	return (struct f2fs_checkpoint *)(sbi->ckpt);  in F2FS_CKPT()
1959 static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)  in NM_I()  argument
1961 	return (struct f2fs_nm_info *)(sbi->nm_info);  in NM_I()
1964 static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)  in SM_I()  argument
1966 	return (struct f2fs_sm_info *)(sbi->sm_info);  in SM_I()
1969 static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)  in SIT_I()  argument
1971 	return (struct sit_info *)(SM_I(sbi)->sit_info);  in SIT_I()
1974 static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)  in FREE_I()  argument
1976 	return (struct free_segmap_info *)(SM_I(sbi)->free_info);  in FREE_I()
1979 static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)  in DIRTY_I()  argument
1981 	return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);  in DIRTY_I()
1984 static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)  in META_MAPPING()  argument
1986 	return sbi->meta_inode->i_mapping;  in META_MAPPING()
1989 static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)  in NODE_MAPPING()  argument
1991 	return sbi->node_inode->i_mapping;  in NODE_MAPPING()
1994 static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)  in is_sbi_flag_set()  argument
1996 	return test_bit(type, &sbi->s_flag);  in is_sbi_flag_set()
1999 static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)  in set_sbi_flag()  argument
2001 	set_bit(type, &sbi->s_flag);  in set_sbi_flag()
2004 static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)  in clear_sbi_flag()  argument
2006 	clear_bit(type, &sbi->s_flag);  in clear_sbi_flag()
2034 static inline bool is_set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)  in is_set_ckpt_flags()  argument
2036 	return __is_set_ckpt_flags(F2FS_CKPT(sbi), f);  in is_set_ckpt_flags()
2048 static inline void set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)  in set_ckpt_flags()  argument
2052 	spin_lock_irqsave(&sbi->cp_lock, flags);  in set_ckpt_flags()
2053 	__set_ckpt_flags(F2FS_CKPT(sbi), f);  in set_ckpt_flags()
2054 	spin_unlock_irqrestore(&sbi->cp_lock, flags);  in set_ckpt_flags()
2066 static inline void clear_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)  in clear_ckpt_flags()  argument
2070 	spin_lock_irqsave(&sbi->cp_lock, flags);  in clear_ckpt_flags()
2071 	__clear_ckpt_flags(F2FS_CKPT(sbi), f);  in clear_ckpt_flags()
2072 	spin_unlock_irqrestore(&sbi->cp_lock, flags);  in clear_ckpt_flags()
2075 static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)  in f2fs_lock_op()  argument
2077 	down_read(&sbi->cp_rwsem);  in f2fs_lock_op()
2080 static inline int f2fs_trylock_op(struct f2fs_sb_info *sbi)  in f2fs_trylock_op()  argument
2082 	return down_read_trylock(&sbi->cp_rwsem);  in f2fs_trylock_op()
2085 static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)  in f2fs_unlock_op()  argument
2087 	up_read(&sbi->cp_rwsem);  in f2fs_unlock_op()
2090 static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)  in f2fs_lock_all()  argument
2092 	down_write(&sbi->cp_rwsem);  in f2fs_lock_all()
2095 static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)  in f2fs_unlock_all()  argument
2097 	up_write(&sbi->cp_rwsem);  in f2fs_unlock_all()
2100 static inline int __get_cp_reason(struct f2fs_sb_info *sbi)  in __get_cp_reason()  argument
2104 	if (test_opt(sbi, FASTBOOT))  in __get_cp_reason()
2106 	if (is_sbi_flag_set(sbi, SBI_IS_CLOSE))  in __get_cp_reason()
2116 static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)  in __exist_node_summaries()  argument
2118 	return (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG) ||  in __exist_node_summaries()
2119 			is_set_ckpt_flags(sbi, CP_FASTBOOT_FLAG));  in __exist_node_summaries()
2137 static inline bool __allow_reserved_blocks(struct f2fs_sb_info *sbi,  in __allow_reserved_blocks()  argument
2142 	if (!test_opt(sbi, RESERVE_ROOT))  in __allow_reserved_blocks()
2146 	if (uid_eq(F2FS_OPTION(sbi).s_resuid, current_fsuid()))  in __allow_reserved_blocks()
2148 	if (!gid_eq(F2FS_OPTION(sbi).s_resgid, GLOBAL_ROOT_GID) &&  in __allow_reserved_blocks()
2149 					in_group_p(F2FS_OPTION(sbi).s_resgid))  in __allow_reserved_blocks()
2157 static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,  in inc_valid_block_count()  argument
2168 	if (time_to_inject(sbi, FAULT_BLOCK)) {  in inc_valid_block_count()
2169 		f2fs_show_injection_info(sbi, FAULT_BLOCK);  in inc_valid_block_count()
2178 	percpu_counter_add(&sbi->alloc_valid_block_count, (*count));  in inc_valid_block_count()
2180 	spin_lock(&sbi->stat_lock);  in inc_valid_block_count()
2181 	sbi->total_valid_block_count += (block_t)(*count);  in inc_valid_block_count()
2182 	avail_user_block_count = sbi->user_block_count -  in inc_valid_block_count()
2183 					sbi->current_reserved_blocks;  in inc_valid_block_count()
2185 	if (!__allow_reserved_blocks(sbi, inode, true))  in inc_valid_block_count()
2186 		avail_user_block_count -= F2FS_OPTION(sbi).root_reserved_blocks;  in inc_valid_block_count()
2187 	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {  in inc_valid_block_count()
2188 		if (avail_user_block_count > sbi->unusable_block_count)  in inc_valid_block_count()
2189 			avail_user_block_count -= sbi->unusable_block_count;  in inc_valid_block_count()
2193 	if (unlikely(sbi->total_valid_block_count > avail_user_block_count)) {  in inc_valid_block_count()
2194 		diff = sbi->total_valid_block_count - avail_user_block_count;  in inc_valid_block_count()
2199 		sbi->total_valid_block_count -= diff;  in inc_valid_block_count()
2201 			spin_unlock(&sbi->stat_lock);  in inc_valid_block_count()
2205 	spin_unlock(&sbi->stat_lock);  in inc_valid_block_count()
2208 		percpu_counter_sub(&sbi->alloc_valid_block_count, release);  in inc_valid_block_count()
2215 	percpu_counter_sub(&sbi->alloc_valid_block_count, release);  in inc_valid_block_count()
2222 void f2fs_printk(struct f2fs_sb_info *sbi, const char *fmt, ...);
2224 #define f2fs_err(sbi, fmt, ...)						\  argument
2225 	f2fs_printk(sbi, KERN_ERR fmt, ##__VA_ARGS__)
2226 #define f2fs_warn(sbi, fmt, ...)					\  argument
2227 	f2fs_printk(sbi, KERN_WARNING fmt, ##__VA_ARGS__)
2228 #define f2fs_notice(sbi, fmt, ...)					\  argument
2229 	f2fs_printk(sbi, KERN_NOTICE fmt, ##__VA_ARGS__)
2230 #define f2fs_info(sbi, fmt, ...)					\  argument
2231 	f2fs_printk(sbi, KERN_INFO fmt, ##__VA_ARGS__)
2232 #define f2fs_debug(sbi, fmt, ...)					\  argument
2233 	f2fs_printk(sbi, KERN_DEBUG fmt, ##__VA_ARGS__)
2235 static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,  in dec_valid_block_count()  argument
2241 	spin_lock(&sbi->stat_lock);  in dec_valid_block_count()
2242 	f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);  in dec_valid_block_count()
2243 	sbi->total_valid_block_count -= (block_t)count;  in dec_valid_block_count()
2244 	if (sbi->reserved_blocks &&  in dec_valid_block_count()
2245 		sbi->current_reserved_blocks < sbi->reserved_blocks)  in dec_valid_block_count()
2246 		sbi->current_reserved_blocks = min(sbi->reserved_blocks,  in dec_valid_block_count()
2247 					sbi->current_reserved_blocks + count);  in dec_valid_block_count()
2248 	spin_unlock(&sbi->stat_lock);  in dec_valid_block_count()
2250 		f2fs_warn(sbi, "Inconsistent i_blocks, ino:%lu, iblocks:%llu, sectors:%llu",  in dec_valid_block_count()
2254 		set_sbi_flag(sbi, SBI_NEED_FSCK);  in dec_valid_block_count()
2260 static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)  in inc_page_count()  argument
2262 	atomic_inc(&sbi->nr_pages[count_type]);  in inc_page_count()
2269 		set_sbi_flag(sbi, SBI_IS_DIRTY);  in inc_page_count()
2281 static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)  in dec_page_count()  argument
2283 	atomic_dec(&sbi->nr_pages[count_type]);  in dec_page_count()
2299 static inline s64 get_pages(struct f2fs_sb_info *sbi, int count_type)  in get_pages()  argument
2301 	return atomic_read(&sbi->nr_pages[count_type]);  in get_pages()
2309 static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)  in get_blocktype_secs()  argument
2311 	unsigned int pages_per_sec = sbi->segs_per_sec * sbi->blocks_per_seg;  in get_blocktype_secs()
2312 	unsigned int segs = (get_pages(sbi, block_type) + pages_per_sec - 1) >>  in get_blocktype_secs()
2313 						sbi->log_blocks_per_seg;  in get_blocktype_secs()
2315 	return segs / sbi->segs_per_sec;  in get_blocktype_secs()
2318 static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)  in valid_user_blocks()  argument
2320 	return sbi->total_valid_block_count;  in valid_user_blocks()
2323 static inline block_t discard_blocks(struct f2fs_sb_info *sbi)  in discard_blocks()  argument
2325 	return sbi->discard_blks;  in discard_blocks()
2328 static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)  in __bitmap_size()  argument
2330 	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);  in __bitmap_size()
2341 static inline block_t __cp_payload(struct f2fs_sb_info *sbi)  in __cp_payload()  argument
2343 	return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);  in __cp_payload()
2346 static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)  in __bitmap_ptr()  argument
2348 	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);  in __bitmap_ptr()
2352 	if (is_set_ckpt_flags(sbi, CP_LARGE_NAT_BITMAP_FLAG)) {  in __bitmap_ptr()
2362 	if (__cp_payload(sbi) > 0) {  in __bitmap_ptr()
2374 static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)  in __start_cp_addr()  argument
2376 	block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);  in __start_cp_addr()
2378 	if (sbi->cur_cp_pack == 2)  in __start_cp_addr()
2379 		start_addr += sbi->blocks_per_seg;  in __start_cp_addr()
2383 static inline block_t __start_cp_next_addr(struct f2fs_sb_info *sbi)  in __start_cp_next_addr()  argument
2385 	block_t start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);  in __start_cp_next_addr()
2387 	if (sbi->cur_cp_pack == 1)  in __start_cp_next_addr()
2388 		start_addr += sbi->blocks_per_seg;  in __start_cp_next_addr()
2392 static inline void __set_cp_next_pack(struct f2fs_sb_info *sbi)  in __set_cp_next_pack()  argument
2394 	sbi->cur_cp_pack = (sbi->cur_cp_pack == 1) ? 2 : 1;  in __set_cp_next_pack()
2397 static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)  in __start_sum_addr()  argument
2399 	return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);  in __start_sum_addr()
2402 static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,  in inc_valid_node_count()  argument
2421 	if (time_to_inject(sbi, FAULT_BLOCK)) {  in inc_valid_node_count()
2422 		f2fs_show_injection_info(sbi, FAULT_BLOCK);  in inc_valid_node_count()
2426 	spin_lock(&sbi->stat_lock);  in inc_valid_node_count()
2428 	valid_block_count = sbi->total_valid_block_count +  in inc_valid_node_count()
2429 					sbi->current_reserved_blocks + 1;  in inc_valid_node_count()
2431 	if (!__allow_reserved_blocks(sbi, inode, false))  in inc_valid_node_count()
2432 		valid_block_count += F2FS_OPTION(sbi).root_reserved_blocks;  in inc_valid_node_count()
2433 	user_block_count = sbi->user_block_count;  in inc_valid_node_count()
2434 	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))  in inc_valid_node_count()
2435 		user_block_count -= sbi->unusable_block_count;  in inc_valid_node_count()
2438 		spin_unlock(&sbi->stat_lock);  in inc_valid_node_count()
2442 	valid_node_count = sbi->total_valid_node_count + 1;  in inc_valid_node_count()
2443 	if (unlikely(valid_node_count > sbi->total_node_count)) {  in inc_valid_node_count()
2444 		spin_unlock(&sbi->stat_lock);  in inc_valid_node_count()
2448 	sbi->total_valid_node_count++;  in inc_valid_node_count()
2449 	sbi->total_valid_block_count++;  in inc_valid_node_count()
2450 	spin_unlock(&sbi->stat_lock);  in inc_valid_node_count()
2459 	percpu_counter_inc(&sbi->alloc_valid_block_count);  in inc_valid_node_count()
2472 static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,  in dec_valid_node_count()  argument
2475 	spin_lock(&sbi->stat_lock);  in dec_valid_node_count()
2477 	f2fs_bug_on(sbi, !sbi->total_valid_block_count);  in dec_valid_node_count()
2478 	f2fs_bug_on(sbi, !sbi->total_valid_node_count);  in dec_valid_node_count()
2480 	sbi->total_valid_node_count--;  in dec_valid_node_count()
2481 	sbi->total_valid_block_count--;  in dec_valid_node_count()
2482 	if (sbi->reserved_blocks &&  in dec_valid_node_count()
2483 		sbi->current_reserved_blocks < sbi->reserved_blocks)  in dec_valid_node_count()
2484 		sbi->current_reserved_blocks++;  in dec_valid_node_count()
2486 	spin_unlock(&sbi->stat_lock);  in dec_valid_node_count()
2492 			f2fs_warn(sbi, "dec_valid_node_count: inconsistent i_blocks, ino:%lu, iblocks:%llu",  in dec_valid_node_count()
2495 			set_sbi_flag(sbi, SBI_NEED_FSCK);  in dec_valid_node_count()
2502 static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)  in valid_node_count()  argument
2504 	return sbi->total_valid_node_count;  in valid_node_count()
2507 static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)  in inc_valid_inode_count()  argument
2509 	percpu_counter_inc(&sbi->total_valid_inode_count);  in inc_valid_inode_count()
2512 static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)  in dec_valid_inode_count()  argument
2514 	percpu_counter_dec(&sbi->total_valid_inode_count);  in dec_valid_inode_count()
2517 static inline s64 valid_inode_count(struct f2fs_sb_info *sbi)  in valid_inode_count()  argument
2519 	return percpu_counter_sum_positive(&sbi->total_valid_inode_count);  in valid_inode_count()
2610 			gfp_t flags, bool nofail, struct f2fs_sb_info *sbi)  in f2fs_kmem_cache_alloc()  argument
2615 	if (time_to_inject(sbi, FAULT_SLAB_ALLOC)) {  in f2fs_kmem_cache_alloc()
2616 		f2fs_show_injection_info(sbi, FAULT_SLAB_ALLOC);  in f2fs_kmem_cache_alloc()
2623 static inline bool is_inflight_io(struct f2fs_sb_info *sbi, int type)  in is_inflight_io()  argument
2625 	if (get_pages(sbi, F2FS_RD_DATA) || get_pages(sbi, F2FS_RD_NODE) ||  in is_inflight_io()
2626 		get_pages(sbi, F2FS_RD_META) || get_pages(sbi, F2FS_WB_DATA) ||  in is_inflight_io()
2627 		get_pages(sbi, F2FS_WB_CP_DATA) ||  in is_inflight_io()
2628 		get_pages(sbi, F2FS_DIO_READ) ||  in is_inflight_io()
2629 		get_pages(sbi, F2FS_DIO_WRITE))  in is_inflight_io()
2632 	if (type != DISCARD_TIME && SM_I(sbi) && SM_I(sbi)->dcc_info &&  in is_inflight_io()
2633 			atomic_read(&SM_I(sbi)->dcc_info->queued_discard))  in is_inflight_io()
2636 	if (SM_I(sbi) && SM_I(sbi)->fcc_info &&  in is_inflight_io()
2637 			atomic_read(&SM_I(sbi)->fcc_info->queued_flush))  in is_inflight_io()
2642 static inline bool is_idle(struct f2fs_sb_info *sbi, int type)  in is_idle()  argument
2644 	if (sbi->gc_mode == GC_URGENT_HIGH)  in is_idle()
2647 	if (is_inflight_io(sbi, type))  in is_idle()
2650 	if (sbi->gc_mode == GC_URGENT_LOW &&  in is_idle()
2654 	return f2fs_time_over(sbi, type);  in is_idle()
3134 		struct f2fs_sb_info *sbi = F2FS_I_SB(inode);  in f2fs_skip_inode_update()  local
3136 		spin_lock(&sbi->inode_lock[DIRTY_META]);  in f2fs_skip_inode_update()
3138 		spin_unlock(&sbi->inode_lock[DIRTY_META]);  in f2fs_skip_inode_update()
3161 static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)  in f2fs_cp_error()  argument
3163 	return is_set_ckpt_flags(sbi, CP_ERROR_FLAG);  in f2fs_cp_error()
3177 static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,  in f2fs_kmalloc()  argument
3180 	if (time_to_inject(sbi, FAULT_KMALLOC)) {  in f2fs_kmalloc()
3181 		f2fs_show_injection_info(sbi, FAULT_KMALLOC);  in f2fs_kmalloc()
3188 static inline void *f2fs_kzalloc(struct f2fs_sb_info *sbi,  in f2fs_kzalloc()  argument
3191 	return f2fs_kmalloc(sbi, size, flags | __GFP_ZERO);  in f2fs_kzalloc()
3194 static inline void *f2fs_kvmalloc(struct f2fs_sb_info *sbi,  in f2fs_kvmalloc()  argument
3197 	if (time_to_inject(sbi, FAULT_KVMALLOC)) {  in f2fs_kvmalloc()
3198 		f2fs_show_injection_info(sbi, FAULT_KVMALLOC);  in f2fs_kvmalloc()
3205 static inline void *f2fs_kvzalloc(struct f2fs_sb_info *sbi,  in f2fs_kvzalloc()  argument
3208 	return f2fs_kvmalloc(sbi, size, flags | __GFP_ZERO);  in f2fs_kvzalloc()
3235 #define __is_large_section(sbi)		((sbi)->segs_per_sec > 1)  argument
3239 bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
3241 static inline void verify_blkaddr(struct f2fs_sb_info *sbi,  in verify_blkaddr()  argument
3244 	if (!f2fs_is_valid_blkaddr(sbi, blkaddr, type)) {  in verify_blkaddr()
3245 		f2fs_err(sbi, "invalid blkaddr: %u, type: %d, run fsck to fix.",  in verify_blkaddr()
3247 		f2fs_bug_on(sbi, 1);  in verify_blkaddr()
3286 bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct page *page);
3287 void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct page *page);
3290 int f2fs_try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink);
3300 int f2fs_update_extension_list(struct f2fs_sb_info *sbi, const char *name,
3366 int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly);
3370 int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover);
3372 int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi);
3384 int f2fs_check_nid_range(struct f2fs_sb_info *sbi, nid_t nid);
3385 bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type);
3386 bool f2fs_in_warm_node_list(struct f2fs_sb_info *sbi, struct page *page);
3387 void f2fs_init_fsync_node_info(struct f2fs_sb_info *sbi);
3388 void f2fs_del_fsync_node_entry(struct f2fs_sb_info *sbi, struct page *page);
3389 void f2fs_reset_fsync_node_info(struct f2fs_sb_info *sbi);
3390 int f2fs_need_dentry_mark(struct f2fs_sb_info *sbi, nid_t nid);
3391 bool f2fs_is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid);
3392 bool f2fs_need_inode_block_update(struct f2fs_sb_info *sbi, nid_t ino);
3393 int f2fs_get_node_info(struct f2fs_sb_info *sbi, nid_t nid,
3399 int f2fs_wait_on_node_pages_writeback(struct f2fs_sb_info *sbi,
3401 bool f2fs_nat_bitmap_enabled(struct f2fs_sb_info *sbi);
3405 void f2fs_ra_node_page(struct f2fs_sb_info *sbi, nid_t nid);
3406 struct page *f2fs_get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid);
3409 void f2fs_flush_inline_data(struct f2fs_sb_info *sbi);
3410 int f2fs_fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
3413 int f2fs_sync_node_pages(struct f2fs_sb_info *sbi,
3416 int f2fs_build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool mount);
3417 bool f2fs_alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid);
3418 void f2fs_alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid);
3419 void f2fs_alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid);
3420 int f2fs_try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink);
3423 int f2fs_recover_inode_page(struct f2fs_sb_info *sbi, struct page *page);
3424 int f2fs_restore_node_summary(struct f2fs_sb_info *sbi,
3426 void f2fs_enable_nat_bits(struct f2fs_sb_info *sbi);
3427 int f2fs_flush_nat_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3428 int f2fs_build_node_manager(struct f2fs_sb_info *sbi);
3429 void f2fs_destroy_node_manager(struct f2fs_sb_info *sbi);
3436 bool f2fs_need_SSR(struct f2fs_sb_info *sbi);
3438 void f2fs_drop_inmem_pages_all(struct f2fs_sb_info *sbi, bool gc_failure);
3442 void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need);
3443 void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi, bool from_bg);
3444 int f2fs_issue_flush(struct f2fs_sb_info *sbi, nid_t ino);
3445 int f2fs_create_flush_cmd_control(struct f2fs_sb_info *sbi);
3446 int f2fs_flush_device_cache(struct f2fs_sb_info *sbi);
3447 void f2fs_destroy_flush_cmd_control(struct f2fs_sb_info *sbi, bool free);
3448 void f2fs_invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr);
3449 bool f2fs_is_checkpointed_data(struct f2fs_sb_info *sbi, block_t blkaddr);
3450 int f2fs_start_discard_thread(struct f2fs_sb_info *sbi);
3451 void f2fs_drop_discard_cmd(struct f2fs_sb_info *sbi);
3452 void f2fs_stop_discard_thread(struct f2fs_sb_info *sbi);
3453 bool f2fs_issue_discard_timeout(struct f2fs_sb_info *sbi);
3454 void f2fs_clear_prefree_segments(struct f2fs_sb_info *sbi,
3456 void f2fs_dirty_to_prefree(struct f2fs_sb_info *sbi);
3457 block_t f2fs_get_unusable_blocks(struct f2fs_sb_info *sbi);
3458 int f2fs_disable_cp_again(struct f2fs_sb_info *sbi, block_t unusable);
3459 void f2fs_release_discard_addrs(struct f2fs_sb_info *sbi);
3460 int f2fs_npages_for_summary_flush(struct f2fs_sb_info *sbi, bool for_ra);
3461 bool f2fs_segment_has_free_slot(struct f2fs_sb_info *sbi, int segno);
3462 void f2fs_init_inmem_curseg(struct f2fs_sb_info *sbi);
3463 void f2fs_save_inmem_curseg(struct f2fs_sb_info *sbi);
3464 void f2fs_restore_inmem_curseg(struct f2fs_sb_info *sbi);
3465 void f2fs_get_new_segment(struct f2fs_sb_info *sbi,
3467 void f2fs_allocate_segment_for_resize(struct f2fs_sb_info *sbi, int type,
3469 void f2fs_allocate_new_section(struct f2fs_sb_info *sbi, int type, bool force);
3470 void f2fs_allocate_new_segments(struct f2fs_sb_info *sbi);
3471 int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range);
3472 bool f2fs_exist_trim_candidates(struct f2fs_sb_info *sbi,
3474 struct page *f2fs_get_sum_page(struct f2fs_sb_info *sbi, unsigned int segno);
3475 void f2fs_update_meta_page(struct f2fs_sb_info *sbi, void *src,
3477 void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct page *page,
3483 void f2fs_do_replace_block(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
3487 void f2fs_replace_block(struct f2fs_sb_info *sbi, struct dnode_of_data *dn,
3491 void f2fs_allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
3500 void f2fs_write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
3501 void f2fs_write_node_summaries(struct f2fs_sb_info *sbi, block_t start_blk);
3504 void f2fs_flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3505 int f2fs_fix_curseg_write_pointer(struct f2fs_sb_info *sbi);
3506 int f2fs_check_write_pointer(struct f2fs_sb_info *sbi);
3507 int f2fs_build_segment_manager(struct f2fs_sb_info *sbi);
3508 void f2fs_destroy_segment_manager(struct f2fs_sb_info *sbi);
3512 enum rw_hint f2fs_io_type_to_rw_hint(struct f2fs_sb_info *sbi,
3514 unsigned int f2fs_usable_segs_in_sec(struct f2fs_sb_info *sbi,
3516 unsigned int f2fs_usable_blks_in_seg(struct f2fs_sb_info *sbi,
3522 void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io);
3523 struct page *f2fs_grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
3524 struct page *f2fs_get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index);
3525 struct page *f2fs_get_meta_page_retry(struct f2fs_sb_info *sbi, pgoff_t index);
3526 struct page *f2fs_get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index);
3527 bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
3529 int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
3531 void f2fs_ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index);
3532 long f2fs_sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
3534 void f2fs_add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
3535 void f2fs_remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type);
3536 void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all);
3537 bool f2fs_exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode);
3538 void f2fs_set_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
3540 bool f2fs_is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,
3542 int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi);
3543 int f2fs_acquire_orphan_inode(struct f2fs_sb_info *sbi);
3544 void f2fs_release_orphan_inode(struct f2fs_sb_info *sbi);
3546 void f2fs_remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino);
3547 int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi);
3548 int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi);
3551 int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type);
3552 void f2fs_wait_on_all_pages(struct f2fs_sb_info *sbi, int type);
3553 u64 f2fs_get_sectors_written(struct f2fs_sb_info *sbi);
3554 int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc);
3555 void f2fs_init_ino_entry_info(struct f2fs_sb_info *sbi);
3558 int f2fs_issue_checkpoint(struct f2fs_sb_info *sbi);
3559 int f2fs_start_ckpt_thread(struct f2fs_sb_info *sbi);
3560 void f2fs_stop_ckpt_thread(struct f2fs_sb_info *sbi);
3561 void f2fs_init_ckpt_req_control(struct f2fs_sb_info *sbi);
3570 void f2fs_submit_bio(struct f2fs_sb_info *sbi,
3572 void f2fs_submit_merged_write(struct f2fs_sb_info *sbi, enum page_type type);
3573 void f2fs_submit_merged_write_cond(struct f2fs_sb_info *sbi,
3576 void f2fs_submit_merged_ipu_write(struct f2fs_sb_info *sbi,
3578 void f2fs_flush_merged_writes(struct f2fs_sb_info *sbi);
3582 struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,
3584 int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr);
3600 void f2fs_do_map_lock(struct f2fs_sb_info *sbi, int flag, bool lock);
3624 int f2fs_init_post_read_wq(struct f2fs_sb_info *sbi);
3625 void f2fs_destroy_post_read_wq(struct f2fs_sb_info *sbi);
3630 int f2fs_start_gc_thread(struct f2fs_sb_info *sbi);
3631 void f2fs_stop_gc_thread(struct f2fs_sb_info *sbi);
3633 int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background, bool force,
3635 void f2fs_build_gc_manager(struct f2fs_sb_info *sbi);
3636 int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count);
3643 int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only);
3644 bool f2fs_space_for_roll_forward(struct f2fs_sb_info *sbi);
3654 	struct f2fs_sb_info *sbi;  member
3707 static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)  in F2FS_STAT()  argument
3709 	return (struct f2fs_stat_info *)sbi->stat_info;  in F2FS_STAT()
3716 #define stat_io_skip_bggc_count(sbi)	((sbi)->io_skip_bggc++)  argument
3717 #define stat_other_skip_bggc_count(sbi)	((sbi)->other_skip_bggc++)  argument
3718 #define stat_inc_dirty_inode(sbi, type)	((sbi)->ndirty_inode[type]++)  argument
3719 #define stat_dec_dirty_inode(sbi, type)	((sbi)->ndirty_inode[type]--)  argument
3720 #define stat_inc_total_hit(sbi)		(atomic64_inc(&(sbi)->total_hit_ext))  argument
3721 #define stat_inc_rbtree_node_hit(sbi)	(atomic64_inc(&(sbi)->read_hit_rbtree))  argument
3722 #define stat_inc_largest_node_hit(sbi)	(atomic64_inc(&(sbi)->read_hit_largest))  argument
3723 #define stat_inc_cached_node_hit(sbi)	(atomic64_inc(&(sbi)->read_hit_cached))  argument
3768 #define stat_inc_meta_count(sbi, blkaddr)				\  argument
3770 		if (blkaddr < SIT_I(sbi)->sit_base_addr)		\
3771 			atomic_inc(&(sbi)->meta_count[META_CP]);	\
3772 		else if (blkaddr < NM_I(sbi)->nat_blkaddr)		\
3773 			atomic_inc(&(sbi)->meta_count[META_SIT]);	\
3774 		else if (blkaddr < SM_I(sbi)->ssa_blkaddr)		\
3775 			atomic_inc(&(sbi)->meta_count[META_NAT]);	\
3776 		else if (blkaddr < SM_I(sbi)->main_blkaddr)		\
3777 			atomic_inc(&(sbi)->meta_count[META_SSA]);	\
3779 #define stat_inc_seg_type(sbi, curseg)					\  argument
3780 		((sbi)->segment_count[(curseg)->alloc_type]++)
3781 #define stat_inc_block_count(sbi, curseg)				\  argument
3782 		((sbi)->block_count[(curseg)->alloc_type]++)
3783 #define stat_inc_inplace_blocks(sbi)					\  argument
3784 		(atomic_inc(&(sbi)->inplace_count))
3803 #define stat_inc_seg_count(sbi, type, gc_type)				\  argument
3805 		struct f2fs_stat_info *si = F2FS_STAT(sbi);		\
3819 #define stat_inc_data_blk_count(sbi, blks, gc_type)			\  argument
3821 		struct f2fs_stat_info *si = F2FS_STAT(sbi);		\
3827 #define stat_inc_node_blk_count(sbi, blks, gc_type)			\  argument
3829 		struct f2fs_stat_info *si = F2FS_STAT(sbi);		\
3835 int f2fs_build_stats(struct f2fs_sb_info *sbi);
3836 void f2fs_destroy_stats(struct f2fs_sb_info *sbi);
3839 void f2fs_update_sit_info(struct f2fs_sb_info *sbi);
3845 #define stat_io_skip_bggc_count(sbi)			do { } while (0)  argument
3846 #define stat_other_skip_bggc_count(sbi)			do { } while (0)  argument
3847 #define stat_inc_dirty_inode(sbi, type)			do { } while (0)  argument
3848 #define stat_dec_dirty_inode(sbi, type)			do { } while (0)  argument
3849 #define stat_inc_total_hit(sbi)				do { } while (0)  argument
3850 #define stat_inc_rbtree_node_hit(sbi)			do { } while (0)  argument
3851 #define stat_inc_largest_node_hit(sbi)			do { } while (0)  argument
3852 #define stat_inc_cached_node_hit(sbi)			do { } while (0)  argument
3867 #define stat_inc_meta_count(sbi, blkaddr)		do { } while (0)  argument
3868 #define stat_inc_seg_type(sbi, curseg)			do { } while (0)  argument
3869 #define stat_inc_block_count(sbi, curseg)		do { } while (0)  argument
3870 #define stat_inc_inplace_blocks(sbi)			do { } while (0)  argument
3871 #define stat_inc_seg_count(sbi, type, gc_type)		do { } while (0)  argument
3873 #define stat_inc_data_blk_count(sbi, blks, gc_type)	do { } while (0)  argument
3874 #define stat_inc_node_blk_count(sbi, blks, gc_type)	do { } while (0)  argument
3876 static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }  in f2fs_build_stats()  argument
3877 static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }  in f2fs_destroy_stats()  argument
3880 static inline void f2fs_update_sit_info(struct f2fs_sb_info *sbi) {}  in f2fs_update_sit_info()  argument
3933 void f2fs_join_shrinker(struct f2fs_sb_info *sbi);
3934 void f2fs_leave_shrinker(struct f2fs_sb_info *sbi);
3941 struct rb_node **f2fs_lookup_rb_tree_ext(struct f2fs_sb_info *sbi,
3945 struct rb_node **f2fs_lookup_rb_tree_for_insert(struct f2fs_sb_info *sbi,
3954 bool f2fs_check_rb_tree_consistence(struct f2fs_sb_info *sbi,
3956 unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink);
3966 void f2fs_init_extent_cache_info(struct f2fs_sb_info *sbi);
3978 int f2fs_register_sysfs(struct f2fs_sb_info *sbi);
3979 void f2fs_unregister_sysfs(struct f2fs_sb_info *sbi);
4049 void f2fs_init_compress_info(struct f2fs_sb_info *sbi);
4050 int f2fs_init_compress_inode(struct f2fs_sb_info *sbi);
4051 void f2fs_destroy_compress_inode(struct f2fs_sb_info *sbi);
4052 int f2fs_init_page_array_cache(struct f2fs_sb_info *sbi);
4053 void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi);
4056 struct address_space *COMPRESS_MAPPING(struct f2fs_sb_info *sbi);
4057 void f2fs_invalidate_compress_page(struct f2fs_sb_info *sbi, block_t blkaddr);
4058 void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
4060 bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi, struct page *page,
4062 void f2fs_invalidate_compress_pages(struct f2fs_sb_info *sbi, nid_t ino);
4065 		struct f2fs_sb_info *sbi = F2FS_I_SB(inode);		\
4066 		sbi->compr_new_inode++;					\
4070 		struct f2fs_sb_info *sbi = F2FS_I_SB(inode);		\
4072 		sbi->compr_written_block += blocks;			\
4073 		sbi->compr_saved_block += diff;				\
4103 static inline int f2fs_init_compress_inode(struct f2fs_sb_info *sbi) { return 0; }  in f2fs_init_compress_inode()  argument
4104 static inline void f2fs_destroy_compress_inode(struct f2fs_sb_info *sbi) { }  in f2fs_destroy_compress_inode()  argument
4105 static inline int f2fs_init_page_array_cache(struct f2fs_sb_info *sbi) { return 0; }  in f2fs_init_page_array_cache()  argument
4106 static inline void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi) { }  in f2fs_destroy_page_array_cache()  argument
4109 static inline void f2fs_invalidate_compress_page(struct f2fs_sb_info *sbi,  in f2fs_invalidate_compress_page()  argument
4111 static inline void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi,  in f2fs_cache_compressed_page()  argument
4113 static inline bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi,  in f2fs_load_compressed_page()  argument
4115 static inline void f2fs_invalidate_compress_pages(struct f2fs_sb_info *sbi,  in f2fs_invalidate_compress_pages()  argument
4125 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);  in set_compress_context()  local
4128 			F2FS_OPTION(sbi).compress_algorithm;  in set_compress_context()
4130 			F2FS_OPTION(sbi).compress_log_size;  in set_compress_context()
4132 			F2FS_OPTION(sbi).compress_chksum ?  in set_compress_context()
4138 			F2FS_OPTION(sbi).compress_level)  in set_compress_context()
4140 				F2FS_OPTION(sbi).compress_level <<  in set_compress_context()
4167 static inline int f2fs_sb_has_##name(struct f2fs_sb_info *sbi) \
4169 	return F2FS_HAS_FEATURE(sbi, F2FS_FEATURE_##flagname); \
4189 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);  in f2fs_may_extent_tree()  local
4191 	if (!test_opt(sbi, EXTENT_CACHE) ||  in f2fs_may_extent_tree()
4194 			 !f2fs_sb_has_readonly(sbi)))  in f2fs_may_extent_tree()
4201 	if (list_empty(&sbi->s_list))  in f2fs_may_extent_tree()
4208 static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,  in f2fs_blkz_is_seq()  argument
4211 	unsigned int zno = blkaddr >> sbi->log_blocks_per_blkz;  in f2fs_blkz_is_seq()
4217 static inline bool f2fs_hw_should_discard(struct f2fs_sb_info *sbi)  in f2fs_hw_should_discard()  argument
4219 	return f2fs_sb_has_blkzoned(sbi);  in f2fs_hw_should_discard()
4228 static inline bool f2fs_hw_support_discard(struct f2fs_sb_info *sbi)  in f2fs_hw_support_discard()  argument
4232 	if (!f2fs_is_multi_device(sbi))  in f2fs_hw_support_discard()
4233 		return f2fs_bdev_support_discard(sbi->sb->s_bdev);  in f2fs_hw_support_discard()
4235 	for (i = 0; i < sbi->s_ndevs; i++)  in f2fs_hw_support_discard()
4241 static inline bool f2fs_realtime_discard_enable(struct f2fs_sb_info *sbi)  in f2fs_realtime_discard_enable()  argument
4243 	return (test_opt(sbi, DISCARD) && f2fs_hw_support_discard(sbi)) ||  in f2fs_realtime_discard_enable()
4244 					f2fs_hw_should_discard(sbi);  in f2fs_realtime_discard_enable()
4247 static inline bool f2fs_hw_is_readonly(struct f2fs_sb_info *sbi)  in f2fs_hw_is_readonly()  argument
4251 	if (!f2fs_is_multi_device(sbi))  in f2fs_hw_is_readonly()
4252 		return bdev_read_only(sbi->sb->s_bdev);  in f2fs_hw_is_readonly()
4254 	for (i = 0; i < sbi->s_ndevs; i++)  in f2fs_hw_is_readonly()
4260 static inline bool f2fs_lfs_mode(struct f2fs_sb_info *sbi)  in f2fs_lfs_mode()  argument
4262 	return F2FS_OPTION(sbi).fs_mode == FS_MODE_LFS;  in f2fs_lfs_mode()
4308 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);  in f2fs_force_buffered_io()  local
4313 	if (f2fs_is_multi_device(sbi))  in f2fs_force_buffered_io()
4319 	if (f2fs_sb_has_blkzoned(sbi))  in f2fs_force_buffered_io()
4321 	if (f2fs_lfs_mode(sbi) && (rw == WRITE)) {  in f2fs_force_buffered_io()
4324 		if (F2FS_IO_ALIGNED(sbi))  in f2fs_force_buffered_io()
4340 extern void f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned int rate,
4343 #define f2fs_build_fault_attr(sbi, rate, type)		do { } while (0)  argument
4346 static inline bool is_journalled_quota(struct f2fs_sb_info *sbi)  in is_journalled_quota()  argument
4349 	if (f2fs_sb_has_quota_ino(sbi))  in is_journalled_quota()
4351 	if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||  in is_journalled_quota()
4352 		F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||  in is_journalled_quota()
4353 		F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])  in is_journalled_quota()
4359 static inline bool f2fs_block_unit_discard(struct f2fs_sb_info *sbi)  in f2fs_block_unit_discard()  argument
4361 	return F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_BLOCK;  in f2fs_block_unit_discard()