brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.02/*3 * fs/f2fs/super.c4 *5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.6 *             http://www.samsung.com/7 */8#include <linux/module.h>9#include <linux/init.h>10#include <linux/fs.h>11#include <linux/fs_context.h>12#include <linux/sched/mm.h>13#include <linux/statfs.h>14#include <linux/kthread.h>15#include <linux/parser.h>16#include <linux/mount.h>17#include <linux/seq_file.h>18#include <linux/proc_fs.h>19#include <linux/random.h>20#include <linux/exportfs.h>21#include <linux/blkdev.h>22#include <linux/quotaops.h>23#include <linux/f2fs_fs.h>24#include <linux/sysfs.h>25#include <linux/quota.h>26#include <linux/unicode.h>27#include <linux/part_stat.h>28#include <linux/zstd.h>29#include <linux/lz4.h>30 31#include "f2fs.h"32#include "node.h"33#include "segment.h"34#include "xattr.h"35#include "gc.h"36#include "iostat.h"37 38#define CREATE_TRACE_POINTS39#include <trace/events/f2fs.h>40 41static struct kmem_cache *f2fs_inode_cachep;42 43#ifdef CONFIG_F2FS_FAULT_INJECTION44 45const char *f2fs_fault_name[FAULT_MAX] = {46	[FAULT_KMALLOC]			= "kmalloc",47	[FAULT_KVMALLOC]		= "kvmalloc",48	[FAULT_PAGE_ALLOC]		= "page alloc",49	[FAULT_PAGE_GET]		= "page get",50	[FAULT_ALLOC_NID]		= "alloc nid",51	[FAULT_ORPHAN]			= "orphan",52	[FAULT_BLOCK]			= "no more block",53	[FAULT_DIR_DEPTH]		= "too big dir depth",54	[FAULT_EVICT_INODE]		= "evict_inode fail",55	[FAULT_TRUNCATE]		= "truncate fail",56	[FAULT_READ_IO]			= "read IO error",57	[FAULT_CHECKPOINT]		= "checkpoint error",58	[FAULT_DISCARD]			= "discard error",59	[FAULT_WRITE_IO]		= "write IO error",60	[FAULT_SLAB_ALLOC]		= "slab alloc",61	[FAULT_DQUOT_INIT]		= "dquot initialize",62	[FAULT_LOCK_OP]			= "lock_op",63	[FAULT_BLKADDR_VALIDITY]	= "invalid blkaddr",64	[FAULT_BLKADDR_CONSISTENCE]	= "inconsistent blkaddr",65	[FAULT_NO_SEGMENT]		= "no free segment",66};67 68int f2fs_build_fault_attr(struct f2fs_sb_info *sbi, unsigned long rate,69							unsigned long type)70{71	struct f2fs_fault_info *ffi = &F2FS_OPTION(sbi).fault_info;72 73	if (rate) {74		if (rate > INT_MAX)75			return -EINVAL;76		atomic_set(&ffi->inject_ops, 0);77		ffi->inject_rate = (int)rate;78	}79 80	if (type) {81		if (type >= BIT(FAULT_MAX))82			return -EINVAL;83		ffi->inject_type = (unsigned int)type;84	}85 86	if (!rate && !type)87		memset(ffi, 0, sizeof(struct f2fs_fault_info));88	else89		f2fs_info(sbi,90			"build fault injection attr: rate: %lu, type: 0x%lx",91								rate, type);92	return 0;93}94#endif95 96/* f2fs-wide shrinker description */97static struct shrinker *f2fs_shrinker_info;98 99static int __init f2fs_init_shrinker(void)100{101	f2fs_shrinker_info = shrinker_alloc(0, "f2fs-shrinker");102	if (!f2fs_shrinker_info)103		return -ENOMEM;104 105	f2fs_shrinker_info->count_objects = f2fs_shrink_count;106	f2fs_shrinker_info->scan_objects = f2fs_shrink_scan;107 108	shrinker_register(f2fs_shrinker_info);109 110	return 0;111}112 113static void f2fs_exit_shrinker(void)114{115	shrinker_free(f2fs_shrinker_info);116}117 118enum {119	Opt_gc_background,120	Opt_disable_roll_forward,121	Opt_norecovery,122	Opt_discard,123	Opt_nodiscard,124	Opt_noheap,125	Opt_heap,126	Opt_user_xattr,127	Opt_nouser_xattr,128	Opt_acl,129	Opt_noacl,130	Opt_active_logs,131	Opt_disable_ext_identify,132	Opt_inline_xattr,133	Opt_noinline_xattr,134	Opt_inline_xattr_size,135	Opt_inline_data,136	Opt_inline_dentry,137	Opt_noinline_dentry,138	Opt_flush_merge,139	Opt_noflush_merge,140	Opt_barrier,141	Opt_nobarrier,142	Opt_fastboot,143	Opt_extent_cache,144	Opt_noextent_cache,145	Opt_noinline_data,146	Opt_data_flush,147	Opt_reserve_root,148	Opt_resgid,149	Opt_resuid,150	Opt_mode,151	Opt_fault_injection,152	Opt_fault_type,153	Opt_quota,154	Opt_noquota,155	Opt_usrquota,156	Opt_grpquota,157	Opt_prjquota,158	Opt_usrjquota,159	Opt_grpjquota,160	Opt_prjjquota,161	Opt_offusrjquota,162	Opt_offgrpjquota,163	Opt_offprjjquota,164	Opt_jqfmt_vfsold,165	Opt_jqfmt_vfsv0,166	Opt_jqfmt_vfsv1,167	Opt_alloc,168	Opt_fsync,169	Opt_test_dummy_encryption,170	Opt_inlinecrypt,171	Opt_checkpoint_disable,172	Opt_checkpoint_disable_cap,173	Opt_checkpoint_disable_cap_perc,174	Opt_checkpoint_enable,175	Opt_checkpoint_merge,176	Opt_nocheckpoint_merge,177	Opt_compress_algorithm,178	Opt_compress_log_size,179	Opt_compress_extension,180	Opt_nocompress_extension,181	Opt_compress_chksum,182	Opt_compress_mode,183	Opt_compress_cache,184	Opt_atgc,185	Opt_gc_merge,186	Opt_nogc_merge,187	Opt_discard_unit,188	Opt_memory_mode,189	Opt_age_extent_cache,190	Opt_errors,191	Opt_err,192};193 194static match_table_t f2fs_tokens = {195	{Opt_gc_background, "background_gc=%s"},196	{Opt_disable_roll_forward, "disable_roll_forward"},197	{Opt_norecovery, "norecovery"},198	{Opt_discard, "discard"},199	{Opt_nodiscard, "nodiscard"},200	{Opt_noheap, "no_heap"},201	{Opt_heap, "heap"},202	{Opt_user_xattr, "user_xattr"},203	{Opt_nouser_xattr, "nouser_xattr"},204	{Opt_acl, "acl"},205	{Opt_noacl, "noacl"},206	{Opt_active_logs, "active_logs=%u"},207	{Opt_disable_ext_identify, "disable_ext_identify"},208	{Opt_inline_xattr, "inline_xattr"},209	{Opt_noinline_xattr, "noinline_xattr"},210	{Opt_inline_xattr_size, "inline_xattr_size=%u"},211	{Opt_inline_data, "inline_data"},212	{Opt_inline_dentry, "inline_dentry"},213	{Opt_noinline_dentry, "noinline_dentry"},214	{Opt_flush_merge, "flush_merge"},215	{Opt_noflush_merge, "noflush_merge"},216	{Opt_barrier, "barrier"},217	{Opt_nobarrier, "nobarrier"},218	{Opt_fastboot, "fastboot"},219	{Opt_extent_cache, "extent_cache"},220	{Opt_noextent_cache, "noextent_cache"},221	{Opt_noinline_data, "noinline_data"},222	{Opt_data_flush, "data_flush"},223	{Opt_reserve_root, "reserve_root=%u"},224	{Opt_resgid, "resgid=%u"},225	{Opt_resuid, "resuid=%u"},226	{Opt_mode, "mode=%s"},227	{Opt_fault_injection, "fault_injection=%u"},228	{Opt_fault_type, "fault_type=%u"},229	{Opt_quota, "quota"},230	{Opt_noquota, "noquota"},231	{Opt_usrquota, "usrquota"},232	{Opt_grpquota, "grpquota"},233	{Opt_prjquota, "prjquota"},234	{Opt_usrjquota, "usrjquota=%s"},235	{Opt_grpjquota, "grpjquota=%s"},236	{Opt_prjjquota, "prjjquota=%s"},237	{Opt_offusrjquota, "usrjquota="},238	{Opt_offgrpjquota, "grpjquota="},239	{Opt_offprjjquota, "prjjquota="},240	{Opt_jqfmt_vfsold, "jqfmt=vfsold"},241	{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},242	{Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},243	{Opt_alloc, "alloc_mode=%s"},244	{Opt_fsync, "fsync_mode=%s"},245	{Opt_test_dummy_encryption, "test_dummy_encryption=%s"},246	{Opt_test_dummy_encryption, "test_dummy_encryption"},247	{Opt_inlinecrypt, "inlinecrypt"},248	{Opt_checkpoint_disable, "checkpoint=disable"},249	{Opt_checkpoint_disable_cap, "checkpoint=disable:%u"},250	{Opt_checkpoint_disable_cap_perc, "checkpoint=disable:%u%%"},251	{Opt_checkpoint_enable, "checkpoint=enable"},252	{Opt_checkpoint_merge, "checkpoint_merge"},253	{Opt_nocheckpoint_merge, "nocheckpoint_merge"},254	{Opt_compress_algorithm, "compress_algorithm=%s"},255	{Opt_compress_log_size, "compress_log_size=%u"},256	{Opt_compress_extension, "compress_extension=%s"},257	{Opt_nocompress_extension, "nocompress_extension=%s"},258	{Opt_compress_chksum, "compress_chksum"},259	{Opt_compress_mode, "compress_mode=%s"},260	{Opt_compress_cache, "compress_cache"},261	{Opt_atgc, "atgc"},262	{Opt_gc_merge, "gc_merge"},263	{Opt_nogc_merge, "nogc_merge"},264	{Opt_discard_unit, "discard_unit=%s"},265	{Opt_memory_mode, "memory=%s"},266	{Opt_age_extent_cache, "age_extent_cache"},267	{Opt_errors, "errors=%s"},268	{Opt_err, NULL},269};270 271void f2fs_printk(struct f2fs_sb_info *sbi, bool limit_rate,272						const char *fmt, ...)273{274	struct va_format vaf;275	va_list args;276	int level;277 278	va_start(args, fmt);279 280	level = printk_get_level(fmt);281	vaf.fmt = printk_skip_level(fmt);282	vaf.va = &args;283	if (limit_rate)284		printk_ratelimited("%c%cF2FS-fs (%s): %pV\n",285			KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);286	else287		printk("%c%cF2FS-fs (%s): %pV\n",288			KERN_SOH_ASCII, level, sbi->sb->s_id, &vaf);289 290	va_end(args);291}292 293#if IS_ENABLED(CONFIG_UNICODE)294static const struct f2fs_sb_encodings {295	__u16 magic;296	char *name;297	unsigned int version;298} f2fs_sb_encoding_map[] = {299	{F2FS_ENC_UTF8_12_1, "utf8", UNICODE_AGE(12, 1, 0)},300};301 302static const struct f2fs_sb_encodings *303f2fs_sb_read_encoding(const struct f2fs_super_block *sb)304{305	__u16 magic = le16_to_cpu(sb->s_encoding);306	int i;307 308	for (i = 0; i < ARRAY_SIZE(f2fs_sb_encoding_map); i++)309		if (magic == f2fs_sb_encoding_map[i].magic)310			return &f2fs_sb_encoding_map[i];311 312	return NULL;313}314 315struct kmem_cache *f2fs_cf_name_slab;316static int __init f2fs_create_casefold_cache(void)317{318	f2fs_cf_name_slab = f2fs_kmem_cache_create("f2fs_casefolded_name",319						   F2FS_NAME_LEN);320	return f2fs_cf_name_slab ? 0 : -ENOMEM;321}322 323static void f2fs_destroy_casefold_cache(void)324{325	kmem_cache_destroy(f2fs_cf_name_slab);326}327#else328static int __init f2fs_create_casefold_cache(void) { return 0; }329static void f2fs_destroy_casefold_cache(void) { }330#endif331 332static inline void limit_reserve_root(struct f2fs_sb_info *sbi)333{334	block_t limit = min((sbi->user_block_count >> 3),335			sbi->user_block_count - sbi->reserved_blocks);336 337	/* limit is 12.5% */338	if (test_opt(sbi, RESERVE_ROOT) &&339			F2FS_OPTION(sbi).root_reserved_blocks > limit) {340		F2FS_OPTION(sbi).root_reserved_blocks = limit;341		f2fs_info(sbi, "Reduce reserved blocks for root = %u",342			  F2FS_OPTION(sbi).root_reserved_blocks);343	}344	if (!test_opt(sbi, RESERVE_ROOT) &&345		(!uid_eq(F2FS_OPTION(sbi).s_resuid,346				make_kuid(&init_user_ns, F2FS_DEF_RESUID)) ||347		!gid_eq(F2FS_OPTION(sbi).s_resgid,348				make_kgid(&init_user_ns, F2FS_DEF_RESGID))))349		f2fs_info(sbi, "Ignore s_resuid=%u, s_resgid=%u w/o reserve_root",350			  from_kuid_munged(&init_user_ns,351					   F2FS_OPTION(sbi).s_resuid),352			  from_kgid_munged(&init_user_ns,353					   F2FS_OPTION(sbi).s_resgid));354}355 356static inline void adjust_unusable_cap_perc(struct f2fs_sb_info *sbi)357{358	if (!F2FS_OPTION(sbi).unusable_cap_perc)359		return;360 361	if (F2FS_OPTION(sbi).unusable_cap_perc == 100)362		F2FS_OPTION(sbi).unusable_cap = sbi->user_block_count;363	else364		F2FS_OPTION(sbi).unusable_cap = (sbi->user_block_count / 100) *365					F2FS_OPTION(sbi).unusable_cap_perc;366 367	f2fs_info(sbi, "Adjust unusable cap for checkpoint=disable = %u / %u%%",368			F2FS_OPTION(sbi).unusable_cap,369			F2FS_OPTION(sbi).unusable_cap_perc);370}371 372static void init_once(void *foo)373{374	struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;375 376	inode_init_once(&fi->vfs_inode);377}378 379#ifdef CONFIG_QUOTA380static const char * const quotatypes[] = INITQFNAMES;381#define QTYPE2NAME(t) (quotatypes[t])382static int f2fs_set_qf_name(struct super_block *sb, int qtype,383							substring_t *args)384{385	struct f2fs_sb_info *sbi = F2FS_SB(sb);386	char *qname;387	int ret = -EINVAL;388 389	if (sb_any_quota_loaded(sb) && !F2FS_OPTION(sbi).s_qf_names[qtype]) {390		f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");391		return -EINVAL;392	}393	if (f2fs_sb_has_quota_ino(sbi)) {394		f2fs_info(sbi, "QUOTA feature is enabled, so ignore qf_name");395		return 0;396	}397 398	qname = match_strdup(args);399	if (!qname) {400		f2fs_err(sbi, "Not enough memory for storing quotafile name");401		return -ENOMEM;402	}403	if (F2FS_OPTION(sbi).s_qf_names[qtype]) {404		if (strcmp(F2FS_OPTION(sbi).s_qf_names[qtype], qname) == 0)405			ret = 0;406		else407			f2fs_err(sbi, "%s quota file already specified",408				 QTYPE2NAME(qtype));409		goto errout;410	}411	if (strchr(qname, '/')) {412		f2fs_err(sbi, "quotafile must be on filesystem root");413		goto errout;414	}415	F2FS_OPTION(sbi).s_qf_names[qtype] = qname;416	set_opt(sbi, QUOTA);417	return 0;418errout:419	kfree(qname);420	return ret;421}422 423static int f2fs_clear_qf_name(struct super_block *sb, int qtype)424{425	struct f2fs_sb_info *sbi = F2FS_SB(sb);426 427	if (sb_any_quota_loaded(sb) && F2FS_OPTION(sbi).s_qf_names[qtype]) {428		f2fs_err(sbi, "Cannot change journaled quota options when quota turned on");429		return -EINVAL;430	}431	kfree(F2FS_OPTION(sbi).s_qf_names[qtype]);432	F2FS_OPTION(sbi).s_qf_names[qtype] = NULL;433	return 0;434}435 436static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)437{438	/*439	 * We do the test below only for project quotas. 'usrquota' and440	 * 'grpquota' mount options are allowed even without quota feature441	 * to support legacy quotas in quota files.442	 */443	if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi)) {444		f2fs_err(sbi, "Project quota feature not enabled. Cannot enable project quota enforcement.");445		return -1;446	}447	if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA] ||448			F2FS_OPTION(sbi).s_qf_names[GRPQUOTA] ||449			F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]) {450		if (test_opt(sbi, USRQUOTA) &&451				F2FS_OPTION(sbi).s_qf_names[USRQUOTA])452			clear_opt(sbi, USRQUOTA);453 454		if (test_opt(sbi, GRPQUOTA) &&455				F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])456			clear_opt(sbi, GRPQUOTA);457 458		if (test_opt(sbi, PRJQUOTA) &&459				F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])460			clear_opt(sbi, PRJQUOTA);461 462		if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||463				test_opt(sbi, PRJQUOTA)) {464			f2fs_err(sbi, "old and new quota format mixing");465			return -1;466		}467 468		if (!F2FS_OPTION(sbi).s_jquota_fmt) {469			f2fs_err(sbi, "journaled quota format not specified");470			return -1;471		}472	}473 474	if (f2fs_sb_has_quota_ino(sbi) && F2FS_OPTION(sbi).s_jquota_fmt) {475		f2fs_info(sbi, "QUOTA feature is enabled, so ignore jquota_fmt");476		F2FS_OPTION(sbi).s_jquota_fmt = 0;477	}478	return 0;479}480#endif481 482static int f2fs_set_test_dummy_encryption(struct super_block *sb,483					  const char *opt,484					  const substring_t *arg,485					  bool is_remount)486{487	struct f2fs_sb_info *sbi = F2FS_SB(sb);488	struct fs_parameter param = {489		.type = fs_value_is_string,490		.string = arg->from ? arg->from : "",491	};492	struct fscrypt_dummy_policy *policy =493		&F2FS_OPTION(sbi).dummy_enc_policy;494	int err;495 496	if (!IS_ENABLED(CONFIG_FS_ENCRYPTION)) {497		f2fs_warn(sbi, "test_dummy_encryption option not supported");498		return -EINVAL;499	}500 501	if (!f2fs_sb_has_encrypt(sbi)) {502		f2fs_err(sbi, "Encrypt feature is off");503		return -EINVAL;504	}505 506	/*507	 * This mount option is just for testing, and it's not worthwhile to508	 * implement the extra complexity (e.g. RCU protection) that would be509	 * needed to allow it to be set or changed during remount.  We do allow510	 * it to be specified during remount, but only if there is no change.511	 */512	if (is_remount && !fscrypt_is_dummy_policy_set(policy)) {513		f2fs_warn(sbi, "Can't set test_dummy_encryption on remount");514		return -EINVAL;515	}516 517	err = fscrypt_parse_test_dummy_encryption(&param, policy);518	if (err) {519		if (err == -EEXIST)520			f2fs_warn(sbi,521				  "Can't change test_dummy_encryption on remount");522		else if (err == -EINVAL)523			f2fs_warn(sbi, "Value of option \"%s\" is unrecognized",524				  opt);525		else526			f2fs_warn(sbi, "Error processing option \"%s\" [%d]",527				  opt, err);528		return -EINVAL;529	}530	f2fs_warn(sbi, "Test dummy encryption mode enabled");531	return 0;532}533 534#ifdef CONFIG_F2FS_FS_COMPRESSION535static bool is_compress_extension_exist(struct f2fs_sb_info *sbi,536					const char *new_ext, bool is_ext)537{538	unsigned char (*ext)[F2FS_EXTENSION_LEN];539	int ext_cnt;540	int i;541 542	if (is_ext) {543		ext = F2FS_OPTION(sbi).extensions;544		ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;545	} else {546		ext = F2FS_OPTION(sbi).noextensions;547		ext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;548	}549 550	for (i = 0; i < ext_cnt; i++) {551		if (!strcasecmp(new_ext, ext[i]))552			return true;553	}554 555	return false;556}557 558/*559 * 1. The same extension name cannot not appear in both compress and non-compress extension560 * at the same time.561 * 2. If the compress extension specifies all files, the types specified by the non-compress562 * extension will be treated as special cases and will not be compressed.563 * 3. Don't allow the non-compress extension specifies all files.564 */565static int f2fs_test_compress_extension(struct f2fs_sb_info *sbi)566{567	unsigned char (*ext)[F2FS_EXTENSION_LEN];568	unsigned char (*noext)[F2FS_EXTENSION_LEN];569	int ext_cnt, noext_cnt, index = 0, no_index = 0;570 571	ext = F2FS_OPTION(sbi).extensions;572	ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;573	noext = F2FS_OPTION(sbi).noextensions;574	noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;575 576	if (!noext_cnt)577		return 0;578 579	for (no_index = 0; no_index < noext_cnt; no_index++) {580		if (!strcasecmp("*", noext[no_index])) {581			f2fs_info(sbi, "Don't allow the nocompress extension specifies all files");582			return -EINVAL;583		}584		for (index = 0; index < ext_cnt; index++) {585			if (!strcasecmp(ext[index], noext[no_index])) {586				f2fs_info(sbi, "Don't allow the same extension %s appear in both compress and nocompress extension",587						ext[index]);588				return -EINVAL;589			}590		}591	}592	return 0;593}594 595#ifdef CONFIG_F2FS_FS_LZ4596static int f2fs_set_lz4hc_level(struct f2fs_sb_info *sbi, const char *str)597{598#ifdef CONFIG_F2FS_FS_LZ4HC599	unsigned int level;600 601	if (strlen(str) == 3) {602		F2FS_OPTION(sbi).compress_level = 0;603		return 0;604	}605 606	str += 3;607 608	if (str[0] != ':') {609		f2fs_info(sbi, "wrong format, e.g. <alg_name>:<compr_level>");610		return -EINVAL;611	}612	if (kstrtouint(str + 1, 10, &level))613		return -EINVAL;614 615	if (!f2fs_is_compress_level_valid(COMPRESS_LZ4, level)) {616		f2fs_info(sbi, "invalid lz4hc compress level: %d", level);617		return -EINVAL;618	}619 620	F2FS_OPTION(sbi).compress_level = level;621	return 0;622#else623	if (strlen(str) == 3) {624		F2FS_OPTION(sbi).compress_level = 0;625		return 0;626	}627	f2fs_info(sbi, "kernel doesn't support lz4hc compression");628	return -EINVAL;629#endif630}631#endif632 633#ifdef CONFIG_F2FS_FS_ZSTD634static int f2fs_set_zstd_level(struct f2fs_sb_info *sbi, const char *str)635{636	int level;637	int len = 4;638 639	if (strlen(str) == len) {640		F2FS_OPTION(sbi).compress_level = F2FS_ZSTD_DEFAULT_CLEVEL;641		return 0;642	}643 644	str += len;645 646	if (str[0] != ':') {647		f2fs_info(sbi, "wrong format, e.g. <alg_name>:<compr_level>");648		return -EINVAL;649	}650	if (kstrtoint(str + 1, 10, &level))651		return -EINVAL;652 653	/* f2fs does not support negative compress level now */654	if (level < 0) {655		f2fs_info(sbi, "do not support negative compress level: %d", level);656		return -ERANGE;657	}658 659	if (!f2fs_is_compress_level_valid(COMPRESS_ZSTD, level)) {660		f2fs_info(sbi, "invalid zstd compress level: %d", level);661		return -EINVAL;662	}663 664	F2FS_OPTION(sbi).compress_level = level;665	return 0;666}667#endif668#endif669 670static int parse_options(struct super_block *sb, char *options, bool is_remount)671{672	struct f2fs_sb_info *sbi = F2FS_SB(sb);673	substring_t args[MAX_OPT_ARGS];674#ifdef CONFIG_F2FS_FS_COMPRESSION675	unsigned char (*ext)[F2FS_EXTENSION_LEN];676	unsigned char (*noext)[F2FS_EXTENSION_LEN];677	int ext_cnt, noext_cnt;678#endif679	char *p, *name;680	int arg = 0;681	kuid_t uid;682	kgid_t gid;683	int ret;684 685	if (!options)686		goto default_check;687 688	while ((p = strsep(&options, ",")) != NULL) {689		int token;690 691		if (!*p)692			continue;693		/*694		 * Initialize args struct so we know whether arg was695		 * found; some options take optional arguments.696		 */697		args[0].to = args[0].from = NULL;698		token = match_token(p, f2fs_tokens, args);699 700		switch (token) {701		case Opt_gc_background:702			name = match_strdup(&args[0]);703 704			if (!name)705				return -ENOMEM;706			if (!strcmp(name, "on")) {707				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;708			} else if (!strcmp(name, "off")) {709				if (f2fs_sb_has_blkzoned(sbi)) {710					f2fs_warn(sbi, "zoned devices need bggc");711					kfree(name);712					return -EINVAL;713				}714				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_OFF;715			} else if (!strcmp(name, "sync")) {716				F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_SYNC;717			} else {718				kfree(name);719				return -EINVAL;720			}721			kfree(name);722			break;723		case Opt_disable_roll_forward:724			set_opt(sbi, DISABLE_ROLL_FORWARD);725			break;726		case Opt_norecovery:727			/* this option mounts f2fs with ro */728			set_opt(sbi, NORECOVERY);729			if (!f2fs_readonly(sb))730				return -EINVAL;731			break;732		case Opt_discard:733			if (!f2fs_hw_support_discard(sbi)) {734				f2fs_warn(sbi, "device does not support discard");735				break;736			}737			set_opt(sbi, DISCARD);738			break;739		case Opt_nodiscard:740			if (f2fs_hw_should_discard(sbi)) {741				f2fs_warn(sbi, "discard is required for zoned block devices");742				return -EINVAL;743			}744			clear_opt(sbi, DISCARD);745			break;746		case Opt_noheap:747		case Opt_heap:748			f2fs_warn(sbi, "heap/no_heap options were deprecated");749			break;750#ifdef CONFIG_F2FS_FS_XATTR751		case Opt_user_xattr:752			set_opt(sbi, XATTR_USER);753			break;754		case Opt_nouser_xattr:755			clear_opt(sbi, XATTR_USER);756			break;757		case Opt_inline_xattr:758			set_opt(sbi, INLINE_XATTR);759			break;760		case Opt_noinline_xattr:761			clear_opt(sbi, INLINE_XATTR);762			break;763		case Opt_inline_xattr_size:764			if (args->from && match_int(args, &arg))765				return -EINVAL;766			set_opt(sbi, INLINE_XATTR_SIZE);767			F2FS_OPTION(sbi).inline_xattr_size = arg;768			break;769#else770		case Opt_user_xattr:771			f2fs_info(sbi, "user_xattr options not supported");772			break;773		case Opt_nouser_xattr:774			f2fs_info(sbi, "nouser_xattr options not supported");775			break;776		case Opt_inline_xattr:777			f2fs_info(sbi, "inline_xattr options not supported");778			break;779		case Opt_noinline_xattr:780			f2fs_info(sbi, "noinline_xattr options not supported");781			break;782#endif783#ifdef CONFIG_F2FS_FS_POSIX_ACL784		case Opt_acl:785			set_opt(sbi, POSIX_ACL);786			break;787		case Opt_noacl:788			clear_opt(sbi, POSIX_ACL);789			break;790#else791		case Opt_acl:792			f2fs_info(sbi, "acl options not supported");793			break;794		case Opt_noacl:795			f2fs_info(sbi, "noacl options not supported");796			break;797#endif798		case Opt_active_logs:799			if (args->from && match_int(args, &arg))800				return -EINVAL;801			if (arg != 2 && arg != 4 &&802				arg != NR_CURSEG_PERSIST_TYPE)803				return -EINVAL;804			F2FS_OPTION(sbi).active_logs = arg;805			break;806		case Opt_disable_ext_identify:807			set_opt(sbi, DISABLE_EXT_IDENTIFY);808			break;809		case Opt_inline_data:810			set_opt(sbi, INLINE_DATA);811			break;812		case Opt_inline_dentry:813			set_opt(sbi, INLINE_DENTRY);814			break;815		case Opt_noinline_dentry:816			clear_opt(sbi, INLINE_DENTRY);817			break;818		case Opt_flush_merge:819			set_opt(sbi, FLUSH_MERGE);820			break;821		case Opt_noflush_merge:822			clear_opt(sbi, FLUSH_MERGE);823			break;824		case Opt_nobarrier:825			set_opt(sbi, NOBARRIER);826			break;827		case Opt_barrier:828			clear_opt(sbi, NOBARRIER);829			break;830		case Opt_fastboot:831			set_opt(sbi, FASTBOOT);832			break;833		case Opt_extent_cache:834			set_opt(sbi, READ_EXTENT_CACHE);835			break;836		case Opt_noextent_cache:837			clear_opt(sbi, READ_EXTENT_CACHE);838			break;839		case Opt_noinline_data:840			clear_opt(sbi, INLINE_DATA);841			break;842		case Opt_data_flush:843			set_opt(sbi, DATA_FLUSH);844			break;845		case Opt_reserve_root:846			if (args->from && match_int(args, &arg))847				return -EINVAL;848			if (test_opt(sbi, RESERVE_ROOT)) {849				f2fs_info(sbi, "Preserve previous reserve_root=%u",850					  F2FS_OPTION(sbi).root_reserved_blocks);851			} else {852				F2FS_OPTION(sbi).root_reserved_blocks = arg;853				set_opt(sbi, RESERVE_ROOT);854			}855			break;856		case Opt_resuid:857			if (args->from && match_int(args, &arg))858				return -EINVAL;859			uid = make_kuid(current_user_ns(), arg);860			if (!uid_valid(uid)) {861				f2fs_err(sbi, "Invalid uid value %d", arg);862				return -EINVAL;863			}864			F2FS_OPTION(sbi).s_resuid = uid;865			break;866		case Opt_resgid:867			if (args->from && match_int(args, &arg))868				return -EINVAL;869			gid = make_kgid(current_user_ns(), arg);870			if (!gid_valid(gid)) {871				f2fs_err(sbi, "Invalid gid value %d", arg);872				return -EINVAL;873			}874			F2FS_OPTION(sbi).s_resgid = gid;875			break;876		case Opt_mode:877			name = match_strdup(&args[0]);878 879			if (!name)880				return -ENOMEM;881			if (!strcmp(name, "adaptive")) {882				F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;883			} else if (!strcmp(name, "lfs")) {884				F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;885			} else if (!strcmp(name, "fragment:segment")) {886				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_SEG;887			} else if (!strcmp(name, "fragment:block")) {888				F2FS_OPTION(sbi).fs_mode = FS_MODE_FRAGMENT_BLK;889			} else {890				kfree(name);891				return -EINVAL;892			}893			kfree(name);894			break;895#ifdef CONFIG_F2FS_FAULT_INJECTION896		case Opt_fault_injection:897			if (args->from && match_int(args, &arg))898				return -EINVAL;899			if (f2fs_build_fault_attr(sbi, arg,900					F2FS_ALL_FAULT_TYPE))901				return -EINVAL;902			set_opt(sbi, FAULT_INJECTION);903			break;904 905		case Opt_fault_type:906			if (args->from && match_int(args, &arg))907				return -EINVAL;908			if (f2fs_build_fault_attr(sbi, 0, arg))909				return -EINVAL;910			set_opt(sbi, FAULT_INJECTION);911			break;912#else913		case Opt_fault_injection:914			f2fs_info(sbi, "fault_injection options not supported");915			break;916 917		case Opt_fault_type:918			f2fs_info(sbi, "fault_type options not supported");919			break;920#endif921#ifdef CONFIG_QUOTA922		case Opt_quota:923		case Opt_usrquota:924			set_opt(sbi, USRQUOTA);925			break;926		case Opt_grpquota:927			set_opt(sbi, GRPQUOTA);928			break;929		case Opt_prjquota:930			set_opt(sbi, PRJQUOTA);931			break;932		case Opt_usrjquota:933			ret = f2fs_set_qf_name(sb, USRQUOTA, &args[0]);934			if (ret)935				return ret;936			break;937		case Opt_grpjquota:938			ret = f2fs_set_qf_name(sb, GRPQUOTA, &args[0]);939			if (ret)940				return ret;941			break;942		case Opt_prjjquota:943			ret = f2fs_set_qf_name(sb, PRJQUOTA, &args[0]);944			if (ret)945				return ret;946			break;947		case Opt_offusrjquota:948			ret = f2fs_clear_qf_name(sb, USRQUOTA);949			if (ret)950				return ret;951			break;952		case Opt_offgrpjquota:953			ret = f2fs_clear_qf_name(sb, GRPQUOTA);954			if (ret)955				return ret;956			break;957		case Opt_offprjjquota:958			ret = f2fs_clear_qf_name(sb, PRJQUOTA);959			if (ret)960				return ret;961			break;962		case Opt_jqfmt_vfsold:963			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_OLD;964			break;965		case Opt_jqfmt_vfsv0:966			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V0;967			break;968		case Opt_jqfmt_vfsv1:969			F2FS_OPTION(sbi).s_jquota_fmt = QFMT_VFS_V1;970			break;971		case Opt_noquota:972			clear_opt(sbi, QUOTA);973			clear_opt(sbi, USRQUOTA);974			clear_opt(sbi, GRPQUOTA);975			clear_opt(sbi, PRJQUOTA);976			break;977#else978		case Opt_quota:979		case Opt_usrquota:980		case Opt_grpquota:981		case Opt_prjquota:982		case Opt_usrjquota:983		case Opt_grpjquota:984		case Opt_prjjquota:985		case Opt_offusrjquota:986		case Opt_offgrpjquota:987		case Opt_offprjjquota:988		case Opt_jqfmt_vfsold:989		case Opt_jqfmt_vfsv0:990		case Opt_jqfmt_vfsv1:991		case Opt_noquota:992			f2fs_info(sbi, "quota operations not supported");993			break;994#endif995		case Opt_alloc:996			name = match_strdup(&args[0]);997			if (!name)998				return -ENOMEM;999 1000			if (!strcmp(name, "default")) {1001				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;1002			} else if (!strcmp(name, "reuse")) {1003				F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;1004			} else {1005				kfree(name);1006				return -EINVAL;1007			}1008			kfree(name);1009			break;1010		case Opt_fsync:1011			name = match_strdup(&args[0]);1012			if (!name)1013				return -ENOMEM;1014			if (!strcmp(name, "posix")) {1015				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;1016			} else if (!strcmp(name, "strict")) {1017				F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_STRICT;1018			} else if (!strcmp(name, "nobarrier")) {1019				F2FS_OPTION(sbi).fsync_mode =1020							FSYNC_MODE_NOBARRIER;1021			} else {1022				kfree(name);1023				return -EINVAL;1024			}1025			kfree(name);1026			break;1027		case Opt_test_dummy_encryption:1028			ret = f2fs_set_test_dummy_encryption(sb, p, &args[0],1029							     is_remount);1030			if (ret)1031				return ret;1032			break;1033		case Opt_inlinecrypt:1034#ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT1035			sb->s_flags |= SB_INLINECRYPT;1036#else1037			f2fs_info(sbi, "inline encryption not supported");1038#endif1039			break;1040		case Opt_checkpoint_disable_cap_perc:1041			if (args->from && match_int(args, &arg))1042				return -EINVAL;1043			if (arg < 0 || arg > 100)1044				return -EINVAL;1045			F2FS_OPTION(sbi).unusable_cap_perc = arg;1046			set_opt(sbi, DISABLE_CHECKPOINT);1047			break;1048		case Opt_checkpoint_disable_cap:1049			if (args->from && match_int(args, &arg))1050				return -EINVAL;1051			F2FS_OPTION(sbi).unusable_cap = arg;1052			set_opt(sbi, DISABLE_CHECKPOINT);1053			break;1054		case Opt_checkpoint_disable:1055			set_opt(sbi, DISABLE_CHECKPOINT);1056			break;1057		case Opt_checkpoint_enable:1058			clear_opt(sbi, DISABLE_CHECKPOINT);1059			break;1060		case Opt_checkpoint_merge:1061			set_opt(sbi, MERGE_CHECKPOINT);1062			break;1063		case Opt_nocheckpoint_merge:1064			clear_opt(sbi, MERGE_CHECKPOINT);1065			break;1066#ifdef CONFIG_F2FS_FS_COMPRESSION1067		case Opt_compress_algorithm:1068			if (!f2fs_sb_has_compression(sbi)) {1069				f2fs_info(sbi, "Image doesn't support compression");1070				break;1071			}1072			name = match_strdup(&args[0]);1073			if (!name)1074				return -ENOMEM;1075			if (!strcmp(name, "lzo")) {1076#ifdef CONFIG_F2FS_FS_LZO1077				F2FS_OPTION(sbi).compress_level = 0;1078				F2FS_OPTION(sbi).compress_algorithm =1079								COMPRESS_LZO;1080#else1081				f2fs_info(sbi, "kernel doesn't support lzo compression");1082#endif1083			} else if (!strncmp(name, "lz4", 3)) {1084#ifdef CONFIG_F2FS_FS_LZ41085				ret = f2fs_set_lz4hc_level(sbi, name);1086				if (ret) {1087					kfree(name);1088					return -EINVAL;1089				}1090				F2FS_OPTION(sbi).compress_algorithm =1091								COMPRESS_LZ4;1092#else1093				f2fs_info(sbi, "kernel doesn't support lz4 compression");1094#endif1095			} else if (!strncmp(name, "zstd", 4)) {1096#ifdef CONFIG_F2FS_FS_ZSTD1097				ret = f2fs_set_zstd_level(sbi, name);1098				if (ret) {1099					kfree(name);1100					return -EINVAL;1101				}1102				F2FS_OPTION(sbi).compress_algorithm =1103								COMPRESS_ZSTD;1104#else1105				f2fs_info(sbi, "kernel doesn't support zstd compression");1106#endif1107			} else if (!strcmp(name, "lzo-rle")) {1108#ifdef CONFIG_F2FS_FS_LZORLE1109				F2FS_OPTION(sbi).compress_level = 0;1110				F2FS_OPTION(sbi).compress_algorithm =1111								COMPRESS_LZORLE;1112#else1113				f2fs_info(sbi, "kernel doesn't support lzorle compression");1114#endif1115			} else {1116				kfree(name);1117				return -EINVAL;1118			}1119			kfree(name);1120			break;1121		case Opt_compress_log_size:1122			if (!f2fs_sb_has_compression(sbi)) {1123				f2fs_info(sbi, "Image doesn't support compression");1124				break;1125			}1126			if (args->from && match_int(args, &arg))1127				return -EINVAL;1128			if (arg < MIN_COMPRESS_LOG_SIZE ||1129				arg > MAX_COMPRESS_LOG_SIZE) {1130				f2fs_err(sbi,1131					"Compress cluster log size is out of range");1132				return -EINVAL;1133			}1134			F2FS_OPTION(sbi).compress_log_size = arg;1135			break;1136		case Opt_compress_extension:1137			if (!f2fs_sb_has_compression(sbi)) {1138				f2fs_info(sbi, "Image doesn't support compression");1139				break;1140			}1141			name = match_strdup(&args[0]);1142			if (!name)1143				return -ENOMEM;1144 1145			ext = F2FS_OPTION(sbi).extensions;1146			ext_cnt = F2FS_OPTION(sbi).compress_ext_cnt;1147 1148			if (strlen(name) >= F2FS_EXTENSION_LEN ||1149				ext_cnt >= COMPRESS_EXT_NUM) {1150				f2fs_err(sbi,1151					"invalid extension length/number");1152				kfree(name);1153				return -EINVAL;1154			}1155 1156			if (is_compress_extension_exist(sbi, name, true)) {1157				kfree(name);1158				break;1159			}1160 1161			strcpy(ext[ext_cnt], name);1162			F2FS_OPTION(sbi).compress_ext_cnt++;1163			kfree(name);1164			break;1165		case Opt_nocompress_extension:1166			if (!f2fs_sb_has_compression(sbi)) {1167				f2fs_info(sbi, "Image doesn't support compression");1168				break;1169			}1170			name = match_strdup(&args[0]);1171			if (!name)1172				return -ENOMEM;1173 1174			noext = F2FS_OPTION(sbi).noextensions;1175			noext_cnt = F2FS_OPTION(sbi).nocompress_ext_cnt;1176 1177			if (strlen(name) >= F2FS_EXTENSION_LEN ||1178				noext_cnt >= COMPRESS_EXT_NUM) {1179				f2fs_err(sbi,1180					"invalid extension length/number");1181				kfree(name);1182				return -EINVAL;1183			}1184 1185			if (is_compress_extension_exist(sbi, name, false)) {1186				kfree(name);1187				break;1188			}1189 1190			strcpy(noext[noext_cnt], name);1191			F2FS_OPTION(sbi).nocompress_ext_cnt++;1192			kfree(name);1193			break;1194		case Opt_compress_chksum:1195			if (!f2fs_sb_has_compression(sbi)) {1196				f2fs_info(sbi, "Image doesn't support compression");1197				break;1198			}1199			F2FS_OPTION(sbi).compress_chksum = true;1200			break;1201		case Opt_compress_mode:1202			if (!f2fs_sb_has_compression(sbi)) {1203				f2fs_info(sbi, "Image doesn't support compression");1204				break;1205			}1206			name = match_strdup(&args[0]);1207			if (!name)1208				return -ENOMEM;1209			if (!strcmp(name, "fs")) {1210				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;1211			} else if (!strcmp(name, "user")) {1212				F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER;1213			} else {1214				kfree(name);1215				return -EINVAL;1216			}1217			kfree(name);1218			break;1219		case Opt_compress_cache:1220			if (!f2fs_sb_has_compression(sbi)) {1221				f2fs_info(sbi, "Image doesn't support compression");1222				break;1223			}1224			set_opt(sbi, COMPRESS_CACHE);1225			break;1226#else1227		case Opt_compress_algorithm:1228		case Opt_compress_log_size:1229		case Opt_compress_extension:1230		case Opt_nocompress_extension:1231		case Opt_compress_chksum:1232		case Opt_compress_mode:1233		case Opt_compress_cache:1234			f2fs_info(sbi, "compression options not supported");1235			break;1236#endif1237		case Opt_atgc:1238			set_opt(sbi, ATGC);1239			break;1240		case Opt_gc_merge:1241			set_opt(sbi, GC_MERGE);1242			break;1243		case Opt_nogc_merge:1244			clear_opt(sbi, GC_MERGE);1245			break;1246		case Opt_discard_unit:1247			name = match_strdup(&args[0]);1248			if (!name)1249				return -ENOMEM;1250			if (!strcmp(name, "block")) {1251				F2FS_OPTION(sbi).discard_unit =1252						DISCARD_UNIT_BLOCK;1253			} else if (!strcmp(name, "segment")) {1254				F2FS_OPTION(sbi).discard_unit =1255						DISCARD_UNIT_SEGMENT;1256			} else if (!strcmp(name, "section")) {1257				F2FS_OPTION(sbi).discard_unit =1258						DISCARD_UNIT_SECTION;1259			} else {1260				kfree(name);1261				return -EINVAL;1262			}1263			kfree(name);1264			break;1265		case Opt_memory_mode:1266			name = match_strdup(&args[0]);1267			if (!name)1268				return -ENOMEM;1269			if (!strcmp(name, "normal")) {1270				F2FS_OPTION(sbi).memory_mode =1271						MEMORY_MODE_NORMAL;1272			} else if (!strcmp(name, "low")) {1273				F2FS_OPTION(sbi).memory_mode =1274						MEMORY_MODE_LOW;1275			} else {1276				kfree(name);1277				return -EINVAL;1278			}1279			kfree(name);1280			break;1281		case Opt_age_extent_cache:1282			set_opt(sbi, AGE_EXTENT_CACHE);1283			break;1284		case Opt_errors:1285			name = match_strdup(&args[0]);1286			if (!name)1287				return -ENOMEM;1288			if (!strcmp(name, "remount-ro")) {1289				F2FS_OPTION(sbi).errors =1290						MOUNT_ERRORS_READONLY;1291			} else if (!strcmp(name, "continue")) {1292				F2FS_OPTION(sbi).errors =1293						MOUNT_ERRORS_CONTINUE;1294			} else if (!strcmp(name, "panic")) {1295				F2FS_OPTION(sbi).errors =1296						MOUNT_ERRORS_PANIC;1297			} else {1298				kfree(name);1299				return -EINVAL;1300			}1301			kfree(name);1302			break;1303		default:1304			f2fs_err(sbi, "Unrecognized mount option \"%s\" or missing value",1305				 p);1306			return -EINVAL;1307		}1308	}1309default_check:1310#ifdef CONFIG_QUOTA1311	if (f2fs_check_quota_options(sbi))1312		return -EINVAL;1313#else1314	if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sbi->sb)) {1315		f2fs_info(sbi, "Filesystem with quota feature cannot be mounted RDWR without CONFIG_QUOTA");1316		return -EINVAL;1317	}1318	if (f2fs_sb_has_project_quota(sbi) && !f2fs_readonly(sbi->sb)) {1319		f2fs_err(sbi, "Filesystem with project quota feature cannot be mounted RDWR without CONFIG_QUOTA");1320		return -EINVAL;1321	}1322#endif1323 1324	if (!IS_ENABLED(CONFIG_UNICODE) && f2fs_sb_has_casefold(sbi)) {1325		f2fs_err(sbi,1326			"Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");1327		return -EINVAL;1328	}1329 1330	/*1331	 * The BLKZONED feature indicates that the drive was formatted with1332	 * zone alignment optimization. This is optional for host-aware1333	 * devices, but mandatory for host-managed zoned block devices.1334	 */1335	if (f2fs_sb_has_blkzoned(sbi)) {1336#ifdef CONFIG_BLK_DEV_ZONED1337		if (F2FS_OPTION(sbi).discard_unit !=1338						DISCARD_UNIT_SECTION) {1339			f2fs_info(sbi, "Zoned block device doesn't need small discard, set discard_unit=section by default");1340			F2FS_OPTION(sbi).discard_unit =1341					DISCARD_UNIT_SECTION;1342		}1343 1344		if (F2FS_OPTION(sbi).fs_mode != FS_MODE_LFS) {1345			f2fs_info(sbi, "Only lfs mode is allowed with zoned block device feature");1346			return -EINVAL;1347		}1348#else1349		f2fs_err(sbi, "Zoned block device support is not enabled");1350		return -EINVAL;1351#endif1352	}1353 1354#ifdef CONFIG_F2FS_FS_COMPRESSION1355	if (f2fs_test_compress_extension(sbi)) {1356		f2fs_err(sbi, "invalid compress or nocompress extension");1357		return -EINVAL;1358	}1359#endif1360 1361	if (test_opt(sbi, INLINE_XATTR_SIZE)) {1362		int min_size, max_size;1363 1364		if (!f2fs_sb_has_extra_attr(sbi) ||1365			!f2fs_sb_has_flexible_inline_xattr(sbi)) {1366			f2fs_err(sbi, "extra_attr or flexible_inline_xattr feature is off");1367			return -EINVAL;1368		}1369		if (!test_opt(sbi, INLINE_XATTR)) {1370			f2fs_err(sbi, "inline_xattr_size option should be set with inline_xattr option");1371			return -EINVAL;1372		}1373 1374		min_size = MIN_INLINE_XATTR_SIZE;1375		max_size = MAX_INLINE_XATTR_SIZE;1376 1377		if (F2FS_OPTION(sbi).inline_xattr_size < min_size ||1378				F2FS_OPTION(sbi).inline_xattr_size > max_size) {1379			f2fs_err(sbi, "inline xattr size is out of range: %d ~ %d",1380				 min_size, max_size);1381			return -EINVAL;1382		}1383	}1384 1385	if (test_opt(sbi, ATGC) && f2fs_lfs_mode(sbi)) {1386		f2fs_err(sbi, "LFS is not compatible with ATGC");1387		return -EINVAL;1388	}1389 1390	if (f2fs_is_readonly(sbi) && test_opt(sbi, FLUSH_MERGE)) {1391		f2fs_err(sbi, "FLUSH_MERGE not compatible with readonly mode");1392		return -EINVAL;1393	}1394 1395	if (f2fs_sb_has_readonly(sbi) && !f2fs_readonly(sbi->sb)) {1396		f2fs_err(sbi, "Allow to mount readonly mode only");1397		return -EROFS;1398	}1399	return 0;1400}1401 1402static struct inode *f2fs_alloc_inode(struct super_block *sb)1403{1404	struct f2fs_inode_info *fi;1405 1406	if (time_to_inject(F2FS_SB(sb), FAULT_SLAB_ALLOC))1407		return NULL;1408 1409	fi = alloc_inode_sb(sb, f2fs_inode_cachep, GFP_F2FS_ZERO);1410	if (!fi)1411		return NULL;1412 1413	init_once((void *) fi);1414 1415	/* Initialize f2fs-specific inode info */1416	atomic_set(&fi->dirty_pages, 0);1417	atomic_set(&fi->i_compr_blocks, 0);1418	init_f2fs_rwsem(&fi->i_sem);1419	spin_lock_init(&fi->i_size_lock);1420	INIT_LIST_HEAD(&fi->dirty_list);1421	INIT_LIST_HEAD(&fi->gdirty_list);1422	init_f2fs_rwsem(&fi->i_gc_rwsem[READ]);1423	init_f2fs_rwsem(&fi->i_gc_rwsem[WRITE]);1424	init_f2fs_rwsem(&fi->i_xattr_sem);1425 1426	/* Will be used by directory only */1427	fi->i_dir_level = F2FS_SB(sb)->dir_level;1428 1429	return &fi->vfs_inode;1430}1431 1432static int f2fs_drop_inode(struct inode *inode)1433{1434	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);1435	int ret;1436 1437	/*1438	 * during filesystem shutdown, if checkpoint is disabled,1439	 * drop useless meta/node dirty pages.1440	 */1441	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {1442		if (inode->i_ino == F2FS_NODE_INO(sbi) ||1443			inode->i_ino == F2FS_META_INO(sbi)) {1444			trace_f2fs_drop_inode(inode, 1);1445			return 1;1446		}1447	}1448 1449	/*1450	 * This is to avoid a deadlock condition like below.1451	 * writeback_single_inode(inode)1452	 *  - f2fs_write_data_page1453	 *    - f2fs_gc -> iput -> evict1454	 *       - inode_wait_for_writeback(inode)1455	 */1456	if ((!inode_unhashed(inode) && inode->i_state & I_SYNC)) {1457		if (!inode->i_nlink && !is_bad_inode(inode)) {1458			/* to avoid evict_inode call simultaneously */1459			atomic_inc(&inode->i_count);1460			spin_unlock(&inode->i_lock);1461 1462			/* should remain fi->extent_tree for writepage */1463			f2fs_destroy_extent_node(inode);1464 1465			sb_start_intwrite(inode->i_sb);1466			f2fs_i_size_write(inode, 0);1467 1468			f2fs_submit_merged_write_cond(F2FS_I_SB(inode),1469					inode, NULL, 0, DATA);1470			truncate_inode_pages_final(inode->i_mapping);1471 1472			if (F2FS_HAS_BLOCKS(inode))1473				f2fs_truncate(inode);1474 1475			sb_end_intwrite(inode->i_sb);1476 1477			spin_lock(&inode->i_lock);1478			atomic_dec(&inode->i_count);1479		}1480		trace_f2fs_drop_inode(inode, 0);1481		return 0;1482	}1483	ret = generic_drop_inode(inode);1484	if (!ret)1485		ret = fscrypt_drop_inode(inode);1486	trace_f2fs_drop_inode(inode, ret);1487	return ret;1488}1489 1490int f2fs_inode_dirtied(struct inode *inode, bool sync)1491{1492	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);1493	int ret = 0;1494 1495	spin_lock(&sbi->inode_lock[DIRTY_META]);1496	if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {1497		ret = 1;1498	} else {1499		set_inode_flag(inode, FI_DIRTY_INODE);1500		stat_inc_dirty_inode(sbi, DIRTY_META);1501	}1502	if (sync && list_empty(&F2FS_I(inode)->gdirty_list)) {1503		list_add_tail(&F2FS_I(inode)->gdirty_list,1504				&sbi->inode_list[DIRTY_META]);1505		inc_page_count(sbi, F2FS_DIRTY_IMETA);1506	}1507	spin_unlock(&sbi->inode_lock[DIRTY_META]);1508	return ret;1509}1510 1511void f2fs_inode_synced(struct inode *inode)1512{1513	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);1514 1515	spin_lock(&sbi->inode_lock[DIRTY_META]);1516	if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) {1517		spin_unlock(&sbi->inode_lock[DIRTY_META]);1518		return;1519	}1520	if (!list_empty(&F2FS_I(inode)->gdirty_list)) {1521		list_del_init(&F2FS_I(inode)->gdirty_list);1522		dec_page_count(sbi, F2FS_DIRTY_IMETA);1523	}1524	clear_inode_flag(inode, FI_DIRTY_INODE);1525	clear_inode_flag(inode, FI_AUTO_RECOVER);1526	stat_dec_dirty_inode(F2FS_I_SB(inode), DIRTY_META);1527	spin_unlock(&sbi->inode_lock[DIRTY_META]);1528}1529 1530/*1531 * f2fs_dirty_inode() is called from __mark_inode_dirty()1532 *1533 * We should call set_dirty_inode to write the dirty inode through write_inode.1534 */1535static void f2fs_dirty_inode(struct inode *inode, int flags)1536{1537	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);1538 1539	if (inode->i_ino == F2FS_NODE_INO(sbi) ||1540			inode->i_ino == F2FS_META_INO(sbi))1541		return;1542 1543	if (is_inode_flag_set(inode, FI_AUTO_RECOVER))1544		clear_inode_flag(inode, FI_AUTO_RECOVER);1545 1546	f2fs_inode_dirtied(inode, false);1547}1548 1549static void f2fs_free_inode(struct inode *inode)1550{1551	fscrypt_free_inode(inode);1552	kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));1553}1554 1555static void destroy_percpu_info(struct f2fs_sb_info *sbi)1556{1557	percpu_counter_destroy(&sbi->total_valid_inode_count);1558	percpu_counter_destroy(&sbi->rf_node_block_count);1559	percpu_counter_destroy(&sbi->alloc_valid_block_count);1560}1561 1562static void destroy_device_list(struct f2fs_sb_info *sbi)1563{1564	int i;1565 1566	for (i = 0; i < sbi->s_ndevs; i++) {1567		if (i > 0)1568			bdev_fput(FDEV(i).bdev_file);1569#ifdef CONFIG_BLK_DEV_ZONED1570		kvfree(FDEV(i).blkz_seq);1571#endif1572	}1573	kvfree(sbi->devs);1574}1575 1576static void f2fs_put_super(struct super_block *sb)1577{1578	struct f2fs_sb_info *sbi = F2FS_SB(sb);1579	int i;1580	int err = 0;1581	bool done;1582 1583	/* unregister procfs/sysfs entries in advance to avoid race case */1584	f2fs_unregister_sysfs(sbi);1585 1586	f2fs_quota_off_umount(sb);1587 1588	/* prevent remaining shrinker jobs */1589	mutex_lock(&sbi->umount_mutex);1590 1591	/*1592	 * flush all issued checkpoints and stop checkpoint issue thread.1593	 * after then, all checkpoints should be done by each process context.1594	 */1595	f2fs_stop_ckpt_thread(sbi);1596 1597	/*1598	 * We don't need to do checkpoint when superblock is clean.1599	 * But, the previous checkpoint was not done by umount, it needs to do1600	 * clean checkpoint again.1601	 */1602	if ((is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||1603			!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG))) {1604		struct cp_control cpc = {1605			.reason = CP_UMOUNT,1606		};1607		stat_inc_cp_call_count(sbi, TOTAL_CALL);1608		err = f2fs_write_checkpoint(sbi, &cpc);1609	}1610 1611	/* be sure to wait for any on-going discard commands */1612	done = f2fs_issue_discard_timeout(sbi);1613	if (f2fs_realtime_discard_enable(sbi) && !sbi->discard_blks && done) {1614		struct cp_control cpc = {1615			.reason = CP_UMOUNT | CP_TRIMMED,1616		};1617		stat_inc_cp_call_count(sbi, TOTAL_CALL);1618		err = f2fs_write_checkpoint(sbi, &cpc);1619	}1620 1621	/*1622	 * normally superblock is clean, so we need to release this.1623	 * In addition, EIO will skip do checkpoint, we need this as well.1624	 */1625	f2fs_release_ino_entry(sbi, true);1626 1627	f2fs_leave_shrinker(sbi);1628	mutex_unlock(&sbi->umount_mutex);1629 1630	/* our cp_error case, we can wait for any writeback page */1631	f2fs_flush_merged_writes(sbi);1632 1633	f2fs_wait_on_all_pages(sbi, F2FS_WB_CP_DATA);1634 1635	if (err || f2fs_cp_error(sbi)) {1636		truncate_inode_pages_final(NODE_MAPPING(sbi));1637		truncate_inode_pages_final(META_MAPPING(sbi));1638	}1639 1640	for (i = 0; i < NR_COUNT_TYPE; i++) {1641		if (!get_pages(sbi, i))1642			continue;1643		f2fs_err(sbi, "detect filesystem reference count leak during "1644			"umount, type: %d, count: %lld", i, get_pages(sbi, i));1645		f2fs_bug_on(sbi, 1);1646	}1647 1648	f2fs_bug_on(sbi, sbi->fsync_node_num);1649 1650	f2fs_destroy_compress_inode(sbi);1651 1652	iput(sbi->node_inode);1653	sbi->node_inode = NULL;1654 1655	iput(sbi->meta_inode);1656	sbi->meta_inode = NULL;1657 1658	/*1659	 * iput() can update stat information, if f2fs_write_checkpoint()1660	 * above failed with error.1661	 */1662	f2fs_destroy_stats(sbi);1663 1664	/* destroy f2fs internal modules */1665	f2fs_destroy_node_manager(sbi);1666	f2fs_destroy_segment_manager(sbi);1667 1668	/* flush s_error_work before sbi destroy */1669	flush_work(&sbi->s_error_work);1670 1671	f2fs_destroy_post_read_wq(sbi);1672 1673	kvfree(sbi->ckpt);1674 1675	if (sbi->s_chksum_driver)1676		crypto_free_shash(sbi->s_chksum_driver);1677	kfree(sbi->raw_super);1678 1679	f2fs_destroy_page_array_cache(sbi);1680	f2fs_destroy_xattr_caches(sbi);1681#ifdef CONFIG_QUOTA1682	for (i = 0; i < MAXQUOTAS; i++)1683		kfree(F2FS_OPTION(sbi).s_qf_names[i]);1684#endif1685	fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);1686	destroy_percpu_info(sbi);1687	f2fs_destroy_iostat(sbi);1688	for (i = 0; i < NR_PAGE_TYPE; i++)1689		kvfree(sbi->write_io[i]);1690#if IS_ENABLED(CONFIG_UNICODE)1691	utf8_unload(sb->s_encoding);1692#endif1693}1694 1695int f2fs_sync_fs(struct super_block *sb, int sync)1696{1697	struct f2fs_sb_info *sbi = F2FS_SB(sb);1698	int err = 0;1699 1700	if (unlikely(f2fs_cp_error(sbi)))1701		return 0;1702	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))1703		return 0;1704 1705	trace_f2fs_sync_fs(sb, sync);1706 1707	if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))1708		return -EAGAIN;1709 1710	if (sync) {1711		stat_inc_cp_call_count(sbi, TOTAL_CALL);1712		err = f2fs_issue_checkpoint(sbi);1713	}1714 1715	return err;1716}1717 1718static int f2fs_freeze(struct super_block *sb)1719{1720	if (f2fs_readonly(sb))1721		return 0;1722 1723	/* IO error happened before */1724	if (unlikely(f2fs_cp_error(F2FS_SB(sb))))1725		return -EIO;1726 1727	/* must be clean, since sync_filesystem() was already called */1728	if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY))1729		return -EINVAL;1730 1731	/* Let's flush checkpoints and stop the thread. */1732	f2fs_flush_ckpt_thread(F2FS_SB(sb));1733 1734	/* to avoid deadlock on f2fs_evict_inode->SB_FREEZE_FS */1735	set_sbi_flag(F2FS_SB(sb), SBI_IS_FREEZING);1736	return 0;1737}1738 1739static int f2fs_unfreeze(struct super_block *sb)1740{1741	clear_sbi_flag(F2FS_SB(sb), SBI_IS_FREEZING);1742	return 0;1743}1744 1745#ifdef CONFIG_QUOTA1746static int f2fs_statfs_project(struct super_block *sb,1747				kprojid_t projid, struct kstatfs *buf)1748{1749	struct kqid qid;1750	struct dquot *dquot;1751	u64 limit;1752	u64 curblock;1753 1754	qid = make_kqid_projid(projid);1755	dquot = dqget(sb, qid);1756	if (IS_ERR(dquot))1757		return PTR_ERR(dquot);1758	spin_lock(&dquot->dq_dqb_lock);1759 1760	limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,1761					dquot->dq_dqb.dqb_bhardlimit);1762	if (limit)1763		limit >>= sb->s_blocksize_bits;1764 1765	if (limit && buf->f_blocks > limit) {1766		curblock = (dquot->dq_dqb.dqb_curspace +1767			    dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;1768		buf->f_blocks = limit;1769		buf->f_bfree = buf->f_bavail =1770			(buf->f_blocks > curblock) ?1771			 (buf->f_blocks - curblock) : 0;1772	}1773 1774	limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,1775					dquot->dq_dqb.dqb_ihardlimit);1776 1777	if (limit && buf->f_files > limit) {1778		buf->f_files = limit;1779		buf->f_ffree =1780			(buf->f_files > dquot->dq_dqb.dqb_curinodes) ?1781			 (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;1782	}1783 1784	spin_unlock(&dquot->dq_dqb_lock);1785	dqput(dquot);1786	return 0;1787}1788#endif1789 1790static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)1791{1792	struct super_block *sb = dentry->d_sb;1793	struct f2fs_sb_info *sbi = F2FS_SB(sb);1794	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);1795	block_t total_count, user_block_count, start_count;1796	u64 avail_node_count;1797	unsigned int total_valid_node_count;1798 1799	total_count = le64_to_cpu(sbi->raw_super->block_count);1800	start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr);1801	buf->f_type = F2FS_SUPER_MAGIC;1802	buf->f_bsize = sbi->blocksize;1803 1804	buf->f_blocks = total_count - start_count;1805 1806	spin_lock(&sbi->stat_lock);1807 1808	user_block_count = sbi->user_block_count;1809	total_valid_node_count = valid_node_count(sbi);1810	avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;1811	buf->f_bfree = user_block_count - valid_user_blocks(sbi) -1812						sbi->current_reserved_blocks;1813 1814	if (unlikely(buf->f_bfree <= sbi->unusable_block_count))1815		buf->f_bfree = 0;1816	else1817		buf->f_bfree -= sbi->unusable_block_count;1818	spin_unlock(&sbi->stat_lock);1819 1820	if (buf->f_bfree > F2FS_OPTION(sbi).root_reserved_blocks)1821		buf->f_bavail = buf->f_bfree -1822				F2FS_OPTION(sbi).root_reserved_blocks;1823	else1824		buf->f_bavail = 0;1825 1826	if (avail_node_count > user_block_count) {1827		buf->f_files = user_block_count;1828		buf->f_ffree = buf->f_bavail;1829	} else {1830		buf->f_files = avail_node_count;1831		buf->f_ffree = min(avail_node_count - total_valid_node_count,1832					buf->f_bavail);1833	}1834 1835	buf->f_namelen = F2FS_NAME_LEN;1836	buf->f_fsid    = u64_to_fsid(id);1837 1838#ifdef CONFIG_QUOTA1839	if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) &&1840			sb_has_quota_limits_enabled(sb, PRJQUOTA)) {1841		f2fs_statfs_project(sb, F2FS_I(dentry->d_inode)->i_projid, buf);1842	}1843#endif1844	return 0;1845}1846 1847static inline void f2fs_show_quota_options(struct seq_file *seq,1848					   struct super_block *sb)1849{1850#ifdef CONFIG_QUOTA1851	struct f2fs_sb_info *sbi = F2FS_SB(sb);1852 1853	if (F2FS_OPTION(sbi).s_jquota_fmt) {1854		char *fmtname = "";1855 1856		switch (F2FS_OPTION(sbi).s_jquota_fmt) {1857		case QFMT_VFS_OLD:1858			fmtname = "vfsold";1859			break;1860		case QFMT_VFS_V0:1861			fmtname = "vfsv0";1862			break;1863		case QFMT_VFS_V1:1864			fmtname = "vfsv1";1865			break;1866		}1867		seq_printf(seq, ",jqfmt=%s", fmtname);1868	}1869 1870	if (F2FS_OPTION(sbi).s_qf_names[USRQUOTA])1871		seq_show_option(seq, "usrjquota",1872			F2FS_OPTION(sbi).s_qf_names[USRQUOTA]);1873 1874	if (F2FS_OPTION(sbi).s_qf_names[GRPQUOTA])1875		seq_show_option(seq, "grpjquota",1876			F2FS_OPTION(sbi).s_qf_names[GRPQUOTA]);1877 1878	if (F2FS_OPTION(sbi).s_qf_names[PRJQUOTA])1879		seq_show_option(seq, "prjjquota",1880			F2FS_OPTION(sbi).s_qf_names[PRJQUOTA]);1881#endif1882}1883 1884#ifdef CONFIG_F2FS_FS_COMPRESSION1885static inline void f2fs_show_compress_options(struct seq_file *seq,1886							struct super_block *sb)1887{1888	struct f2fs_sb_info *sbi = F2FS_SB(sb);1889	char *algtype = "";1890	int i;1891 1892	if (!f2fs_sb_has_compression(sbi))1893		return;1894 1895	switch (F2FS_OPTION(sbi).compress_algorithm) {1896	case COMPRESS_LZO:1897		algtype = "lzo";1898		break;1899	case COMPRESS_LZ4:1900		algtype = "lz4";1901		break;1902	case COMPRESS_ZSTD:1903		algtype = "zstd";1904		break;1905	case COMPRESS_LZORLE:1906		algtype = "lzo-rle";1907		break;1908	}1909	seq_printf(seq, ",compress_algorithm=%s", algtype);1910 1911	if (F2FS_OPTION(sbi).compress_level)1912		seq_printf(seq, ":%d", F2FS_OPTION(sbi).compress_level);1913 1914	seq_printf(seq, ",compress_log_size=%u",1915			F2FS_OPTION(sbi).compress_log_size);1916 1917	for (i = 0; i < F2FS_OPTION(sbi).compress_ext_cnt; i++) {1918		seq_printf(seq, ",compress_extension=%s",1919			F2FS_OPTION(sbi).extensions[i]);1920	}1921 1922	for (i = 0; i < F2FS_OPTION(sbi).nocompress_ext_cnt; i++) {1923		seq_printf(seq, ",nocompress_extension=%s",1924			F2FS_OPTION(sbi).noextensions[i]);1925	}1926 1927	if (F2FS_OPTION(sbi).compress_chksum)1928		seq_puts(seq, ",compress_chksum");1929 1930	if (F2FS_OPTION(sbi).compress_mode == COMPR_MODE_FS)1931		seq_printf(seq, ",compress_mode=%s", "fs");1932	else if (F2FS_OPTION(sbi).compress_mode == COMPR_MODE_USER)1933		seq_printf(seq, ",compress_mode=%s", "user");1934 1935	if (test_opt(sbi, COMPRESS_CACHE))1936		seq_puts(seq, ",compress_cache");1937}1938#endif1939 1940static int f2fs_show_options(struct seq_file *seq, struct dentry *root)1941{1942	struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);1943 1944	if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_SYNC)1945		seq_printf(seq, ",background_gc=%s", "sync");1946	else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_ON)1947		seq_printf(seq, ",background_gc=%s", "on");1948	else if (F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF)1949		seq_printf(seq, ",background_gc=%s", "off");1950 1951	if (test_opt(sbi, GC_MERGE))1952		seq_puts(seq, ",gc_merge");1953	else1954		seq_puts(seq, ",nogc_merge");1955 1956	if (test_opt(sbi, DISABLE_ROLL_FORWARD))1957		seq_puts(seq, ",disable_roll_forward");1958	if (test_opt(sbi, NORECOVERY))1959		seq_puts(seq, ",norecovery");1960	if (test_opt(sbi, DISCARD)) {1961		seq_puts(seq, ",discard");1962		if (F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_BLOCK)1963			seq_printf(seq, ",discard_unit=%s", "block");1964		else if (F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_SEGMENT)1965			seq_printf(seq, ",discard_unit=%s", "segment");1966		else if (F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_SECTION)1967			seq_printf(seq, ",discard_unit=%s", "section");1968	} else {1969		seq_puts(seq, ",nodiscard");1970	}1971#ifdef CONFIG_F2FS_FS_XATTR1972	if (test_opt(sbi, XATTR_USER))1973		seq_puts(seq, ",user_xattr");1974	else1975		seq_puts(seq, ",nouser_xattr");1976	if (test_opt(sbi, INLINE_XATTR))1977		seq_puts(seq, ",inline_xattr");1978	else1979		seq_puts(seq, ",noinline_xattr");1980	if (test_opt(sbi, INLINE_XATTR_SIZE))1981		seq_printf(seq, ",inline_xattr_size=%u",1982					F2FS_OPTION(sbi).inline_xattr_size);1983#endif1984#ifdef CONFIG_F2FS_FS_POSIX_ACL1985	if (test_opt(sbi, POSIX_ACL))1986		seq_puts(seq, ",acl");1987	else1988		seq_puts(seq, ",noacl");1989#endif1990	if (test_opt(sbi, DISABLE_EXT_IDENTIFY))1991		seq_puts(seq, ",disable_ext_identify");1992	if (test_opt(sbi, INLINE_DATA))1993		seq_puts(seq, ",inline_data");1994	else1995		seq_puts(seq, ",noinline_data");1996	if (test_opt(sbi, INLINE_DENTRY))1997		seq_puts(seq, ",inline_dentry");1998	else1999		seq_puts(seq, ",noinline_dentry");2000	if (test_opt(sbi, FLUSH_MERGE))2001		seq_puts(seq, ",flush_merge");2002	else2003		seq_puts(seq, ",noflush_merge");2004	if (test_opt(sbi, NOBARRIER))2005		seq_puts(seq, ",nobarrier");2006	else2007		seq_puts(seq, ",barrier");2008	if (test_opt(sbi, FASTBOOT))2009		seq_puts(seq, ",fastboot");2010	if (test_opt(sbi, READ_EXTENT_CACHE))2011		seq_puts(seq, ",extent_cache");2012	else2013		seq_puts(seq, ",noextent_cache");2014	if (test_opt(sbi, AGE_EXTENT_CACHE))2015		seq_puts(seq, ",age_extent_cache");2016	if (test_opt(sbi, DATA_FLUSH))2017		seq_puts(seq, ",data_flush");2018 2019	seq_puts(seq, ",mode=");2020	if (F2FS_OPTION(sbi).fs_mode == FS_MODE_ADAPTIVE)2021		seq_puts(seq, "adaptive");2022	else if (F2FS_OPTION(sbi).fs_mode == FS_MODE_LFS)2023		seq_puts(seq, "lfs");2024	else if (F2FS_OPTION(sbi).fs_mode == FS_MODE_FRAGMENT_SEG)2025		seq_puts(seq, "fragment:segment");2026	else if (F2FS_OPTION(sbi).fs_mode == FS_MODE_FRAGMENT_BLK)2027		seq_puts(seq, "fragment:block");2028	seq_printf(seq, ",active_logs=%u", F2FS_OPTION(sbi).active_logs);2029	if (test_opt(sbi, RESERVE_ROOT))2030		seq_printf(seq, ",reserve_root=%u,resuid=%u,resgid=%u",2031				F2FS_OPTION(sbi).root_reserved_blocks,2032				from_kuid_munged(&init_user_ns,2033					F2FS_OPTION(sbi).s_resuid),2034				from_kgid_munged(&init_user_ns,2035					F2FS_OPTION(sbi).s_resgid));2036#ifdef CONFIG_F2FS_FAULT_INJECTION2037	if (test_opt(sbi, FAULT_INJECTION)) {2038		seq_printf(seq, ",fault_injection=%u",2039				F2FS_OPTION(sbi).fault_info.inject_rate);2040		seq_printf(seq, ",fault_type=%u",2041				F2FS_OPTION(sbi).fault_info.inject_type);2042	}2043#endif2044#ifdef CONFIG_QUOTA2045	if (test_opt(sbi, QUOTA))2046		seq_puts(seq, ",quota");2047	if (test_opt(sbi, USRQUOTA))2048		seq_puts(seq, ",usrquota");2049	if (test_opt(sbi, GRPQUOTA))2050		seq_puts(seq, ",grpquota");2051	if (test_opt(sbi, PRJQUOTA))2052		seq_puts(seq, ",prjquota");2053#endif2054	f2fs_show_quota_options(seq, sbi->sb);2055 2056	fscrypt_show_test_dummy_encryption(seq, ',', sbi->sb);2057 2058	if (sbi->sb->s_flags & SB_INLINECRYPT)2059		seq_puts(seq, ",inlinecrypt");2060 2061	if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_DEFAULT)2062		seq_printf(seq, ",alloc_mode=%s", "default");2063	else if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_REUSE)2064		seq_printf(seq, ",alloc_mode=%s", "reuse");2065 2066	if (test_opt(sbi, DISABLE_CHECKPOINT))2067		seq_printf(seq, ",checkpoint=disable:%u",2068				F2FS_OPTION(sbi).unusable_cap);2069	if (test_opt(sbi, MERGE_CHECKPOINT))2070		seq_puts(seq, ",checkpoint_merge");2071	else2072		seq_puts(seq, ",nocheckpoint_merge");2073	if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_POSIX)2074		seq_printf(seq, ",fsync_mode=%s", "posix");2075	else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT)2076		seq_printf(seq, ",fsync_mode=%s", "strict");2077	else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_NOBARRIER)2078		seq_printf(seq, ",fsync_mode=%s", "nobarrier");2079 2080#ifdef CONFIG_F2FS_FS_COMPRESSION2081	f2fs_show_compress_options(seq, sbi->sb);2082#endif2083 2084	if (test_opt(sbi, ATGC))2085		seq_puts(seq, ",atgc");2086 2087	if (F2FS_OPTION(sbi).memory_mode == MEMORY_MODE_NORMAL)2088		seq_printf(seq, ",memory=%s", "normal");2089	else if (F2FS_OPTION(sbi).memory_mode == MEMORY_MODE_LOW)2090		seq_printf(seq, ",memory=%s", "low");2091 2092	if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY)2093		seq_printf(seq, ",errors=%s", "remount-ro");2094	else if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_CONTINUE)2095		seq_printf(seq, ",errors=%s", "continue");2096	else if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_PANIC)2097		seq_printf(seq, ",errors=%s", "panic");2098 2099	return 0;2100}2101 2102static void default_options(struct f2fs_sb_info *sbi, bool remount)2103{2104	/* init some FS parameters */2105	if (!remount) {2106		set_opt(sbi, READ_EXTENT_CACHE);2107		clear_opt(sbi, DISABLE_CHECKPOINT);2108 2109		if (f2fs_hw_support_discard(sbi) || f2fs_hw_should_discard(sbi))2110			set_opt(sbi, DISCARD);2111 2112		if (f2fs_sb_has_blkzoned(sbi))2113			F2FS_OPTION(sbi).discard_unit = DISCARD_UNIT_SECTION;2114		else2115			F2FS_OPTION(sbi).discard_unit = DISCARD_UNIT_BLOCK;2116	}2117 2118	if (f2fs_sb_has_readonly(sbi))2119		F2FS_OPTION(sbi).active_logs = NR_CURSEG_RO_TYPE;2120	else2121		F2FS_OPTION(sbi).active_logs = NR_CURSEG_PERSIST_TYPE;2122 2123	F2FS_OPTION(sbi).inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;2124	if (le32_to_cpu(F2FS_RAW_SUPER(sbi)->segment_count_main) <=2125							SMALL_VOLUME_SEGMENTS)2126		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;2127	else2128		F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_DEFAULT;2129	F2FS_OPTION(sbi).fsync_mode = FSYNC_MODE_POSIX;2130	F2FS_OPTION(sbi).s_resuid = make_kuid(&init_user_ns, F2FS_DEF_RESUID);2131	F2FS_OPTION(sbi).s_resgid = make_kgid(&init_user_ns, F2FS_DEF_RESGID);2132	if (f2fs_sb_has_compression(sbi)) {2133		F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4;2134		F2FS_OPTION(sbi).compress_log_size = MIN_COMPRESS_LOG_SIZE;2135		F2FS_OPTION(sbi).compress_ext_cnt = 0;2136		F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS;2137	}2138	F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;2139	F2FS_OPTION(sbi).memory_mode = MEMORY_MODE_NORMAL;2140	F2FS_OPTION(sbi).errors = MOUNT_ERRORS_CONTINUE;2141 2142	set_opt(sbi, INLINE_XATTR);2143	set_opt(sbi, INLINE_DATA);2144	set_opt(sbi, INLINE_DENTRY);2145	set_opt(sbi, MERGE_CHECKPOINT);2146	F2FS_OPTION(sbi).unusable_cap = 0;2147	sbi->sb->s_flags |= SB_LAZYTIME;2148	if (!f2fs_is_readonly(sbi))2149		set_opt(sbi, FLUSH_MERGE);2150	if (f2fs_sb_has_blkzoned(sbi))2151		F2FS_OPTION(sbi).fs_mode = FS_MODE_LFS;2152	else2153		F2FS_OPTION(sbi).fs_mode = FS_MODE_ADAPTIVE;2154 2155#ifdef CONFIG_F2FS_FS_XATTR2156	set_opt(sbi, XATTR_USER);2157#endif2158#ifdef CONFIG_F2FS_FS_POSIX_ACL2159	set_opt(sbi, POSIX_ACL);2160#endif2161 2162	f2fs_build_fault_attr(sbi, 0, 0);2163}2164 2165#ifdef CONFIG_QUOTA2166static int f2fs_enable_quotas(struct super_block *sb);2167#endif2168 2169static int f2fs_disable_checkpoint(struct f2fs_sb_info *sbi)2170{2171	unsigned int s_flags = sbi->sb->s_flags;2172	struct cp_control cpc;2173	unsigned int gc_mode = sbi->gc_mode;2174	int err = 0;2175	int ret;2176	block_t unusable;2177 2178	if (s_flags & SB_RDONLY) {2179		f2fs_err(sbi, "checkpoint=disable on readonly fs");2180		return -EINVAL;2181	}2182	sbi->sb->s_flags |= SB_ACTIVE;2183 2184	/* check if we need more GC first */2185	unusable = f2fs_get_unusable_blocks(sbi);2186	if (!f2fs_disable_cp_again(sbi, unusable))2187		goto skip_gc;2188 2189	f2fs_update_time(sbi, DISABLE_TIME);2190 2191	sbi->gc_mode = GC_URGENT_HIGH;2192 2193	while (!f2fs_time_over(sbi, DISABLE_TIME)) {2194		struct f2fs_gc_control gc_control = {2195			.victim_segno = NULL_SEGNO,2196			.init_gc_type = FG_GC,2197			.should_migrate_blocks = false,2198			.err_gc_skipped = true,2199			.no_bg_gc = true,2200			.nr_free_secs = 1 };2201 2202		f2fs_down_write(&sbi->gc_lock);2203		stat_inc_gc_call_count(sbi, FOREGROUND);2204		err = f2fs_gc(sbi, &gc_control);2205		if (err == -ENODATA) {2206			err = 0;2207			break;2208		}2209		if (err && err != -EAGAIN)2210			break;2211	}2212 2213	ret = sync_filesystem(sbi->sb);2214	if (ret || err) {2215		err = ret ? ret : err;2216		goto restore_flag;2217	}2218 2219	unusable = f2fs_get_unusable_blocks(sbi);2220	if (f2fs_disable_cp_again(sbi, unusable)) {2221		err = -EAGAIN;2222		goto restore_flag;2223	}2224 2225skip_gc:2226	f2fs_down_write(&sbi->gc_lock);2227	cpc.reason = CP_PAUSE;2228	set_sbi_flag(sbi, SBI_CP_DISABLED);2229	stat_inc_cp_call_count(sbi, TOTAL_CALL);2230	err = f2fs_write_checkpoint(sbi, &cpc);2231	if (err)2232		goto out_unlock;2233 2234	spin_lock(&sbi->stat_lock);2235	sbi->unusable_block_count = unusable;2236	spin_unlock(&sbi->stat_lock);2237 2238out_unlock:2239	f2fs_up_write(&sbi->gc_lock);2240restore_flag:2241	sbi->gc_mode = gc_mode;2242	sbi->sb->s_flags = s_flags;	/* Restore SB_RDONLY status */2243	return err;2244}2245 2246static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)2247{2248	int retry = DEFAULT_RETRY_IO_COUNT;2249 2250	/* we should flush all the data to keep data consistency */2251	do {2252		sync_inodes_sb(sbi->sb);2253		f2fs_io_schedule_timeout(DEFAULT_IO_TIMEOUT);2254	} while (get_pages(sbi, F2FS_DIRTY_DATA) && retry--);2255 2256	if (unlikely(retry < 0))2257		f2fs_warn(sbi, "checkpoint=enable has some unwritten data.");2258 2259	f2fs_down_write(&sbi->gc_lock);2260	f2fs_dirty_to_prefree(sbi);2261 2262	clear_sbi_flag(sbi, SBI_CP_DISABLED);2263	set_sbi_flag(sbi, SBI_IS_DIRTY);2264	f2fs_up_write(&sbi->gc_lock);2265 2266	f2fs_sync_fs(sbi->sb, 1);2267 2268	/* Let's ensure there's no pending checkpoint anymore */2269	f2fs_flush_ckpt_thread(sbi);2270}2271 2272static int f2fs_remount(struct super_block *sb, int *flags, char *data)2273{2274	struct f2fs_sb_info *sbi = F2FS_SB(sb);2275	struct f2fs_mount_info org_mount_opt;2276	unsigned long old_sb_flags;2277	int err;2278	bool need_restart_gc = false, need_stop_gc = false;2279	bool need_restart_flush = false, need_stop_flush = false;2280	bool need_restart_discard = false, need_stop_discard = false;2281	bool need_enable_checkpoint = false, need_disable_checkpoint = false;2282	bool no_read_extent_cache = !test_opt(sbi, READ_EXTENT_CACHE);2283	bool no_age_extent_cache = !test_opt(sbi, AGE_EXTENT_CACHE);2284	bool enable_checkpoint = !test_opt(sbi, DISABLE_CHECKPOINT);2285	bool no_atgc = !test_opt(sbi, ATGC);2286	bool no_discard = !test_opt(sbi, DISCARD);2287	bool no_compress_cache = !test_opt(sbi, COMPRESS_CACHE);2288	bool block_unit_discard = f2fs_block_unit_discard(sbi);2289#ifdef CONFIG_QUOTA2290	int i, j;2291#endif2292 2293	/*2294	 * Save the old mount options in case we2295	 * need to restore them.2296	 */2297	org_mount_opt = sbi->mount_opt;2298	old_sb_flags = sb->s_flags;2299 2300#ifdef CONFIG_QUOTA2301	org_mount_opt.s_jquota_fmt = F2FS_OPTION(sbi).s_jquota_fmt;2302	for (i = 0; i < MAXQUOTAS; i++) {2303		if (F2FS_OPTION(sbi).s_qf_names[i]) {2304			org_mount_opt.s_qf_names[i] =2305				kstrdup(F2FS_OPTION(sbi).s_qf_names[i],2306				GFP_KERNEL);2307			if (!org_mount_opt.s_qf_names[i]) {2308				for (j = 0; j < i; j++)2309					kfree(org_mount_opt.s_qf_names[j]);2310				return -ENOMEM;2311			}2312		} else {2313			org_mount_opt.s_qf_names[i] = NULL;2314		}2315	}2316#endif2317 2318	/* recover superblocks we couldn't write due to previous RO mount */2319	if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {2320		err = f2fs_commit_super(sbi, false);2321		f2fs_info(sbi, "Try to recover all the superblocks, ret: %d",2322			  err);2323		if (!err)2324			clear_sbi_flag(sbi, SBI_NEED_SB_WRITE);2325	}2326 2327	default_options(sbi, true);2328 2329	/* parse mount options */2330	err = parse_options(sb, data, true);2331	if (err)2332		goto restore_opts;2333 2334#ifdef CONFIG_BLK_DEV_ZONED2335	if (f2fs_sb_has_blkzoned(sbi) &&2336		sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {2337		f2fs_err(sbi,2338			"zoned: max open zones %u is too small, need at least %u open zones",2339				 sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);2340		err = -EINVAL;2341		goto restore_opts;2342	}2343#endif2344 2345	/* flush outstanding errors before changing fs state */2346	flush_work(&sbi->s_error_work);2347 2348	/*2349	 * Previous and new state of filesystem is RO,2350	 * so skip checking GC and FLUSH_MERGE conditions.2351	 */2352	if (f2fs_readonly(sb) && (*flags & SB_RDONLY))2353		goto skip;2354 2355	if (f2fs_dev_is_readonly(sbi) && !(*flags & SB_RDONLY)) {2356		err = -EROFS;2357		goto restore_opts;2358	}2359 2360#ifdef CONFIG_QUOTA2361	if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {2362		err = dquot_suspend(sb, -1);2363		if (err < 0)2364			goto restore_opts;2365	} else if (f2fs_readonly(sb) && !(*flags & SB_RDONLY)) {2366		/* dquot_resume needs RW */2367		sb->s_flags &= ~SB_RDONLY;2368		if (sb_any_quota_suspended(sb)) {2369			dquot_resume(sb, -1);2370		} else if (f2fs_sb_has_quota_ino(sbi)) {2371			err = f2fs_enable_quotas(sb);2372			if (err)2373				goto restore_opts;2374		}2375	}2376#endif2377	if (f2fs_lfs_mode(sbi) && !IS_F2FS_IPU_DISABLE(sbi)) {2378		err = -EINVAL;2379		f2fs_warn(sbi, "LFS is not compatible with IPU");2380		goto restore_opts;2381	}2382 2383	/* disallow enable atgc dynamically */2384	if (no_atgc == !!test_opt(sbi, ATGC)) {2385		err = -EINVAL;2386		f2fs_warn(sbi, "switch atgc option is not allowed");2387		goto restore_opts;2388	}2389 2390	/* disallow enable/disable extent_cache dynamically */2391	if (no_read_extent_cache == !!test_opt(sbi, READ_EXTENT_CACHE)) {2392		err = -EINVAL;2393		f2fs_warn(sbi, "switch extent_cache option is not allowed");2394		goto restore_opts;2395	}2396	/* disallow enable/disable age extent_cache dynamically */2397	if (no_age_extent_cache == !!test_opt(sbi, AGE_EXTENT_CACHE)) {2398		err = -EINVAL;2399		f2fs_warn(sbi, "switch age_extent_cache option is not allowed");2400		goto restore_opts;2401	}2402 2403	if (no_compress_cache == !!test_opt(sbi, COMPRESS_CACHE)) {2404		err = -EINVAL;2405		f2fs_warn(sbi, "switch compress_cache option is not allowed");2406		goto restore_opts;2407	}2408 2409	if (block_unit_discard != f2fs_block_unit_discard(sbi)) {2410		err = -EINVAL;2411		f2fs_warn(sbi, "switch discard_unit option is not allowed");2412		goto restore_opts;2413	}2414 2415	if ((*flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {2416		err = -EINVAL;2417		f2fs_warn(sbi, "disabling checkpoint not compatible with read-only");2418		goto restore_opts;2419	}2420 2421	/*2422	 * We stop the GC thread if FS is mounted as RO2423	 * or if background_gc = off is passed in mount2424	 * option. Also sync the filesystem.2425	 */2426	if ((*flags & SB_RDONLY) ||2427			(F2FS_OPTION(sbi).bggc_mode == BGGC_MODE_OFF &&2428			!test_opt(sbi, GC_MERGE))) {2429		if (sbi->gc_thread) {2430			f2fs_stop_gc_thread(sbi);2431			need_restart_gc = true;2432		}2433	} else if (!sbi->gc_thread) {2434		err = f2fs_start_gc_thread(sbi);2435		if (err)2436			goto restore_opts;2437		need_stop_gc = true;2438	}2439 2440	if (*flags & SB_RDONLY) {2441		sync_inodes_sb(sb);2442 2443		set_sbi_flag(sbi, SBI_IS_DIRTY);2444		set_sbi_flag(sbi, SBI_IS_CLOSE);2445		f2fs_sync_fs(sb, 1);2446		clear_sbi_flag(sbi, SBI_IS_CLOSE);2447	}2448 2449	/*2450	 * We stop issue flush thread if FS is mounted as RO2451	 * or if flush_merge is not passed in mount option.2452	 */2453	if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {2454		clear_opt(sbi, FLUSH_MERGE);2455		f2fs_destroy_flush_cmd_control(sbi, false);2456		need_restart_flush = true;2457	} else {2458		err = f2fs_create_flush_cmd_control(sbi);2459		if (err)2460			goto restore_gc;2461		need_stop_flush = true;2462	}2463 2464	if (no_discard == !!test_opt(sbi, DISCARD)) {2465		if (test_opt(sbi, DISCARD)) {2466			err = f2fs_start_discard_thread(sbi);2467			if (err)2468				goto restore_flush;2469			need_stop_discard = true;2470		} else {2471			f2fs_stop_discard_thread(sbi);2472			f2fs_issue_discard_timeout(sbi);2473			need_restart_discard = true;2474		}2475	}2476 2477	if (enable_checkpoint == !!test_opt(sbi, DISABLE_CHECKPOINT)) {2478		if (test_opt(sbi, DISABLE_CHECKPOINT)) {2479			err = f2fs_disable_checkpoint(sbi);2480			if (err)2481				goto restore_discard;2482			need_enable_checkpoint = true;2483		} else {2484			f2fs_enable_checkpoint(sbi);2485			need_disable_checkpoint = true;2486		}2487	}2488 2489	/*2490	 * Place this routine at the end, since a new checkpoint would be2491	 * triggered while remount and we need to take care of it before2492	 * returning from remount.2493	 */2494	if ((*flags & SB_RDONLY) || test_opt(sbi, DISABLE_CHECKPOINT) ||2495			!test_opt(sbi, MERGE_CHECKPOINT)) {2496		f2fs_stop_ckpt_thread(sbi);2497	} else {2498		/* Flush if the prevous checkpoint, if exists. */2499		f2fs_flush_ckpt_thread(sbi);2500 2501		err = f2fs_start_ckpt_thread(sbi);2502		if (err) {2503			f2fs_err(sbi,2504			    "Failed to start F2FS issue_checkpoint_thread (%d)",2505			    err);2506			goto restore_checkpoint;2507		}2508	}2509 2510skip:2511#ifdef CONFIG_QUOTA2512	/* Release old quota file names */2513	for (i = 0; i < MAXQUOTAS; i++)2514		kfree(org_mount_opt.s_qf_names[i]);2515#endif2516	/* Update the POSIXACL Flag */2517	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |2518		(test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);2519 2520	limit_reserve_root(sbi);2521	adjust_unusable_cap_perc(sbi);2522	*flags = (*flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);2523	return 0;2524restore_checkpoint:2525	if (need_enable_checkpoint) {2526		f2fs_enable_checkpoint(sbi);2527	} else if (need_disable_checkpoint) {2528		if (f2fs_disable_checkpoint(sbi))2529			f2fs_warn(sbi, "checkpoint has not been disabled");2530	}2531restore_discard:2532	if (need_restart_discard) {2533		if (f2fs_start_discard_thread(sbi))2534			f2fs_warn(sbi, "discard has been stopped");2535	} else if (need_stop_discard) {2536		f2fs_stop_discard_thread(sbi);2537	}2538restore_flush:2539	if (need_restart_flush) {2540		if (f2fs_create_flush_cmd_control(sbi))2541			f2fs_warn(sbi, "background flush thread has stopped");2542	} else if (need_stop_flush) {2543		clear_opt(sbi, FLUSH_MERGE);2544		f2fs_destroy_flush_cmd_control(sbi, false);2545	}2546restore_gc:2547	if (need_restart_gc) {2548		if (f2fs_start_gc_thread(sbi))2549			f2fs_warn(sbi, "background gc thread has stopped");2550	} else if (need_stop_gc) {2551		f2fs_stop_gc_thread(sbi);2552	}2553restore_opts:2554#ifdef CONFIG_QUOTA2555	F2FS_OPTION(sbi).s_jquota_fmt = org_mount_opt.s_jquota_fmt;2556	for (i = 0; i < MAXQUOTAS; i++) {2557		kfree(F2FS_OPTION(sbi).s_qf_names[i]);2558		F2FS_OPTION(sbi).s_qf_names[i] = org_mount_opt.s_qf_names[i];2559	}2560#endif2561	sbi->mount_opt = org_mount_opt;2562	sb->s_flags = old_sb_flags;2563	return err;2564}2565 2566static void f2fs_shutdown(struct super_block *sb)2567{2568	f2fs_do_shutdown(F2FS_SB(sb), F2FS_GOING_DOWN_NOSYNC, false, false);2569}2570 2571#ifdef CONFIG_QUOTA2572static bool f2fs_need_recovery(struct f2fs_sb_info *sbi)2573{2574	/* need to recovery orphan */2575	if (is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))2576		return true;2577	/* need to recovery data */2578	if (test_opt(sbi, DISABLE_ROLL_FORWARD))2579		return false;2580	if (test_opt(sbi, NORECOVERY))2581		return false;2582	return !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG);2583}2584 2585static bool f2fs_recover_quota_begin(struct f2fs_sb_info *sbi)2586{2587	bool readonly = f2fs_readonly(sbi->sb);2588 2589	if (!f2fs_need_recovery(sbi))2590		return false;2591 2592	/* it doesn't need to check f2fs_sb_has_readonly() */2593	if (f2fs_hw_is_readonly(sbi))2594		return false;2595 2596	if (readonly) {2597		sbi->sb->s_flags &= ~SB_RDONLY;2598		set_sbi_flag(sbi, SBI_IS_WRITABLE);2599	}2600 2601	/*2602	 * Turn on quotas which were not enabled for read-only mounts if2603	 * filesystem has quota feature, so that they are updated correctly.2604	 */2605	return f2fs_enable_quota_files(sbi, readonly);2606}2607 2608static void f2fs_recover_quota_end(struct f2fs_sb_info *sbi,2609						bool quota_enabled)2610{2611	if (quota_enabled)2612		f2fs_quota_off_umount(sbi->sb);2613 2614	if (is_sbi_flag_set(sbi, SBI_IS_WRITABLE)) {2615		clear_sbi_flag(sbi, SBI_IS_WRITABLE);2616		sbi->sb->s_flags |= SB_RDONLY;2617	}2618}2619 2620/* Read data from quotafile */2621static ssize_t f2fs_quota_read(struct super_block *sb, int type, char *data,2622			       size_t len, loff_t off)2623{2624	struct inode *inode = sb_dqopt(sb)->files[type];2625	struct address_space *mapping = inode->i_mapping;2626	block_t blkidx = F2FS_BYTES_TO_BLK(off);2627	int offset = off & (sb->s_blocksize - 1);2628	int tocopy;2629	size_t toread;2630	loff_t i_size = i_size_read(inode);2631	struct page *page;2632 2633	if (off > i_size)2634		return 0;2635 2636	if (off + len > i_size)2637		len = i_size - off;2638	toread = len;2639	while (toread > 0) {2640		tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread);2641repeat:2642		page = read_cache_page_gfp(mapping, blkidx, GFP_NOFS);2643		if (IS_ERR(page)) {2644			if (PTR_ERR(page) == -ENOMEM) {2645				memalloc_retry_wait(GFP_NOFS);2646				goto repeat;2647			}2648			set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);2649			return PTR_ERR(page);2650		}2651 2652		lock_page(page);2653 2654		if (unlikely(page->mapping != mapping)) {2655			f2fs_put_page(page, 1);2656			goto repeat;2657		}2658		if (unlikely(!PageUptodate(page))) {2659			f2fs_put_page(page, 1);2660			set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);2661			return -EIO;2662		}2663 2664		memcpy_from_page(data, page, offset, tocopy);2665		f2fs_put_page(page, 1);2666 2667		offset = 0;2668		toread -= tocopy;2669		data += tocopy;2670		blkidx++;2671	}2672	return len;2673}2674 2675/* Write to quotafile */2676static ssize_t f2fs_quota_write(struct super_block *sb, int type,2677				const char *data, size_t len, loff_t off)2678{2679	struct inode *inode = sb_dqopt(sb)->files[type];2680	struct address_space *mapping = inode->i_mapping;2681	const struct address_space_operations *a_ops = mapping->a_ops;2682	int offset = off & (sb->s_blocksize - 1);2683	size_t towrite = len;2684	struct folio *folio;2685	void *fsdata = NULL;2686	int err = 0;2687	int tocopy;2688 2689	while (towrite > 0) {2690		tocopy = min_t(unsigned long, sb->s_blocksize - offset,2691								towrite);2692retry:2693		err = a_ops->write_begin(NULL, mapping, off, tocopy,2694							&folio, &fsdata);2695		if (unlikely(err)) {2696			if (err == -ENOMEM) {2697				f2fs_io_schedule_timeout(DEFAULT_IO_TIMEOUT);2698				goto retry;2699			}2700			set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);2701			break;2702		}2703 2704		memcpy_to_folio(folio, offset_in_folio(folio, off), data, tocopy);2705 2706		a_ops->write_end(NULL, mapping, off, tocopy, tocopy,2707						folio, fsdata);2708		offset = 0;2709		towrite -= tocopy;2710		off += tocopy;2711		data += tocopy;2712		cond_resched();2713	}2714 2715	if (len == towrite)2716		return err;2717	inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));2718	f2fs_mark_inode_dirty_sync(inode, false);2719	return len - towrite;2720}2721 2722int f2fs_dquot_initialize(struct inode *inode)2723{2724	if (time_to_inject(F2FS_I_SB(inode), FAULT_DQUOT_INIT))2725		return -ESRCH;2726 2727	return dquot_initialize(inode);2728}2729 2730static struct dquot __rcu **f2fs_get_dquots(struct inode *inode)2731{2732	return F2FS_I(inode)->i_dquot;2733}2734 2735static qsize_t *f2fs_get_reserved_space(struct inode *inode)2736{2737	return &F2FS_I(inode)->i_reserved_quota;2738}2739 2740static int f2fs_quota_on_mount(struct f2fs_sb_info *sbi, int type)2741{2742	if (is_set_ckpt_flags(sbi, CP_QUOTA_NEED_FSCK_FLAG)) {2743		f2fs_err(sbi, "quota sysfile may be corrupted, skip loading it");2744		return 0;2745	}2746 2747	return dquot_quota_on_mount(sbi->sb, F2FS_OPTION(sbi).s_qf_names[type],2748					F2FS_OPTION(sbi).s_jquota_fmt, type);2749}2750 2751int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly)2752{2753	int enabled = 0;2754	int i, err;2755 2756	if (f2fs_sb_has_quota_ino(sbi) && rdonly) {2757		err = f2fs_enable_quotas(sbi->sb);2758		if (err) {2759			f2fs_err(sbi, "Cannot turn on quota_ino: %d", err);2760			return 0;2761		}2762		return 1;2763	}2764 2765	for (i = 0; i < MAXQUOTAS; i++) {2766		if (F2FS_OPTION(sbi).s_qf_names[i]) {2767			err = f2fs_quota_on_mount(sbi, i);2768			if (!err) {2769				enabled = 1;2770				continue;2771			}2772			f2fs_err(sbi, "Cannot turn on quotas: %d on %d",2773				 err, i);2774		}2775	}2776	return enabled;2777}2778 2779static int f2fs_quota_enable(struct super_block *sb, int type, int format_id,2780			     unsigned int flags)2781{2782	struct inode *qf_inode;2783	unsigned long qf_inum;2784	unsigned long qf_flag = F2FS_QUOTA_DEFAULT_FL;2785	int err;2786 2787	BUG_ON(!f2fs_sb_has_quota_ino(F2FS_SB(sb)));2788 2789	qf_inum = f2fs_qf_ino(sb, type);2790	if (!qf_inum)2791		return -EPERM;2792 2793	qf_inode = f2fs_iget(sb, qf_inum);2794	if (IS_ERR(qf_inode)) {2795		f2fs_err(F2FS_SB(sb), "Bad quota inode %u:%lu", type, qf_inum);2796		return PTR_ERR(qf_inode);2797	}2798 2799	/* Don't account quota for quota files to avoid recursion */2800	inode_lock(qf_inode);2801	qf_inode->i_flags |= S_NOQUOTA;2802 2803	if ((F2FS_I(qf_inode)->i_flags & qf_flag) != qf_flag) {2804		F2FS_I(qf_inode)->i_flags |= qf_flag;2805		f2fs_set_inode_flags(qf_inode);2806	}2807	inode_unlock(qf_inode);2808 2809	err = dquot_load_quota_inode(qf_inode, type, format_id, flags);2810	iput(qf_inode);2811	return err;2812}2813 2814static int f2fs_enable_quotas(struct super_block *sb)2815{2816	struct f2fs_sb_info *sbi = F2FS_SB(sb);2817	int type, err = 0;2818	unsigned long qf_inum;2819	bool quota_mopt[MAXQUOTAS] = {2820		test_opt(sbi, USRQUOTA),2821		test_opt(sbi, GRPQUOTA),2822		test_opt(sbi, PRJQUOTA),2823	};2824 2825	if (is_set_ckpt_flags(F2FS_SB(sb), CP_QUOTA_NEED_FSCK_FLAG)) {2826		f2fs_err(sbi, "quota file may be corrupted, skip loading it");2827		return 0;2828	}2829 2830	sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;2831 2832	for (type = 0; type < MAXQUOTAS; type++) {2833		qf_inum = f2fs_qf_ino(sb, type);2834		if (qf_inum) {2835			err = f2fs_quota_enable(sb, type, QFMT_VFS_V1,2836				DQUOT_USAGE_ENABLED |2837				(quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));2838			if (err) {2839				f2fs_err(sbi, "Failed to enable quota tracking (type=%d, err=%d). Please run fsck to fix.",2840					 type, err);2841				for (type--; type >= 0; type--)2842					dquot_quota_off(sb, type);2843				set_sbi_flag(F2FS_SB(sb),2844						SBI_QUOTA_NEED_REPAIR);2845				return err;2846			}2847		}2848	}2849	return 0;2850}2851 2852static int f2fs_quota_sync_file(struct f2fs_sb_info *sbi, int type)2853{2854	struct quota_info *dqopt = sb_dqopt(sbi->sb);2855	struct address_space *mapping = dqopt->files[type]->i_mapping;2856	int ret = 0;2857 2858	ret = dquot_writeback_dquots(sbi->sb, type);2859	if (ret)2860		goto out;2861 2862	ret = filemap_fdatawrite(mapping);2863	if (ret)2864		goto out;2865 2866	/* if we are using journalled quota */2867	if (is_journalled_quota(sbi))2868		goto out;2869 2870	ret = filemap_fdatawait(mapping);2871 2872	truncate_inode_pages(&dqopt->files[type]->i_data, 0);2873out:2874	if (ret)2875		set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);2876	return ret;2877}2878 2879int f2fs_quota_sync(struct super_block *sb, int type)2880{2881	struct f2fs_sb_info *sbi = F2FS_SB(sb);2882	struct quota_info *dqopt = sb_dqopt(sb);2883	int cnt;2884	int ret = 0;2885 2886	/*2887	 * Now when everything is written we can discard the pagecache so2888	 * that userspace sees the changes.2889	 */2890	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {2891 2892		if (type != -1 && cnt != type)2893			continue;2894 2895		if (!sb_has_quota_active(sb, cnt))2896			continue;2897 2898		if (!f2fs_sb_has_quota_ino(sbi))2899			inode_lock(dqopt->files[cnt]);2900 2901		/*2902		 * do_quotactl2903		 *  f2fs_quota_sync2904		 *  f2fs_down_read(quota_sem)2905		 *  dquot_writeback_dquots()2906		 *  f2fs_dquot_commit2907		 *			      block_operation2908		 *			      f2fs_down_read(quota_sem)2909		 */2910		f2fs_lock_op(sbi);2911		f2fs_down_read(&sbi->quota_sem);2912 2913		ret = f2fs_quota_sync_file(sbi, cnt);2914 2915		f2fs_up_read(&sbi->quota_sem);2916		f2fs_unlock_op(sbi);2917 2918		if (!f2fs_sb_has_quota_ino(sbi))2919			inode_unlock(dqopt->files[cnt]);2920 2921		if (ret)2922			break;2923	}2924	return ret;2925}2926 2927static int f2fs_quota_on(struct super_block *sb, int type, int format_id,2928							const struct path *path)2929{2930	struct inode *inode;2931	int err;2932 2933	/* if quota sysfile exists, deny enabling quota with specific file */2934	if (f2fs_sb_has_quota_ino(F2FS_SB(sb))) {2935		f2fs_err(F2FS_SB(sb), "quota sysfile already exists");2936		return -EBUSY;2937	}2938 2939	if (path->dentry->d_sb != sb)2940		return -EXDEV;2941 2942	err = f2fs_quota_sync(sb, type);2943	if (err)2944		return err;2945 2946	inode = d_inode(path->dentry);2947 2948	err = filemap_fdatawrite(inode->i_mapping);2949	if (err)2950		return err;2951 2952	err = filemap_fdatawait(inode->i_mapping);2953	if (err)2954		return err;2955 2956	err = dquot_quota_on(sb, type, format_id, path);2957	if (err)2958		return err;2959 2960	inode_lock(inode);2961	F2FS_I(inode)->i_flags |= F2FS_QUOTA_DEFAULT_FL;2962	f2fs_set_inode_flags(inode);2963	inode_unlock(inode);2964	f2fs_mark_inode_dirty_sync(inode, false);2965 2966	return 0;2967}2968 2969static int __f2fs_quota_off(struct super_block *sb, int type)2970{2971	struct inode *inode = sb_dqopt(sb)->files[type];2972	int err;2973 2974	if (!inode || !igrab(inode))2975		return dquot_quota_off(sb, type);2976 2977	err = f2fs_quota_sync(sb, type);2978	if (err)2979		goto out_put;2980 2981	err = dquot_quota_off(sb, type);2982	if (err || f2fs_sb_has_quota_ino(F2FS_SB(sb)))2983		goto out_put;2984 2985	inode_lock(inode);2986	F2FS_I(inode)->i_flags &= ~F2FS_QUOTA_DEFAULT_FL;2987	f2fs_set_inode_flags(inode);2988	inode_unlock(inode);2989	f2fs_mark_inode_dirty_sync(inode, false);2990out_put:2991	iput(inode);2992	return err;2993}2994 2995static int f2fs_quota_off(struct super_block *sb, int type)2996{2997	struct f2fs_sb_info *sbi = F2FS_SB(sb);2998	int err;2999 3000	err = __f2fs_quota_off(sb, type);3001 3002	/*3003	 * quotactl can shutdown journalled quota, result in inconsistence3004	 * between quota record and fs data by following updates, tag the3005	 * flag to let fsck be aware of it.3006	 */3007	if (is_journalled_quota(sbi))3008		set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);3009	return err;3010}3011 3012void f2fs_quota_off_umount(struct super_block *sb)3013{3014	int type;3015	int err;3016 3017	for (type = 0; type < MAXQUOTAS; type++) {3018		err = __f2fs_quota_off(sb, type);3019		if (err) {3020			int ret = dquot_quota_off(sb, type);3021 3022			f2fs_err(F2FS_SB(sb), "Fail to turn off disk quota (type: %d, err: %d, ret:%d), Please run fsck to fix it.",3023				 type, err, ret);3024			set_sbi_flag(F2FS_SB(sb), SBI_QUOTA_NEED_REPAIR);3025		}3026	}3027	/*3028	 * In case of checkpoint=disable, we must flush quota blocks.3029	 * This can cause NULL exception for node_inode in end_io, since3030	 * put_super already dropped it.3031	 */3032	sync_filesystem(sb);3033}3034 3035static void f2fs_truncate_quota_inode_pages(struct super_block *sb)3036{3037	struct quota_info *dqopt = sb_dqopt(sb);3038	int type;3039 3040	for (type = 0; type < MAXQUOTAS; type++) {3041		if (!dqopt->files[type])3042			continue;3043		f2fs_inode_synced(dqopt->files[type]);3044	}3045}3046 3047static int f2fs_dquot_commit(struct dquot *dquot)3048{3049	struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);3050	int ret;3051 3052	f2fs_down_read_nested(&sbi->quota_sem, SINGLE_DEPTH_NESTING);3053	ret = dquot_commit(dquot);3054	if (ret < 0)3055		set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);3056	f2fs_up_read(&sbi->quota_sem);3057	return ret;3058}3059 3060static int f2fs_dquot_acquire(struct dquot *dquot)3061{3062	struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);3063	int ret;3064 3065	f2fs_down_read(&sbi->quota_sem);3066	ret = dquot_acquire(dquot);3067	if (ret < 0)3068		set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);3069	f2fs_up_read(&sbi->quota_sem);3070	return ret;3071}3072 3073static int f2fs_dquot_release(struct dquot *dquot)3074{3075	struct f2fs_sb_info *sbi = F2FS_SB(dquot->dq_sb);3076	int ret = dquot_release(dquot);3077 3078	if (ret < 0)3079		set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);3080	return ret;3081}3082 3083static int f2fs_dquot_mark_dquot_dirty(struct dquot *dquot)3084{3085	struct super_block *sb = dquot->dq_sb;3086	struct f2fs_sb_info *sbi = F2FS_SB(sb);3087	int ret = dquot_mark_dquot_dirty(dquot);3088 3089	/* if we are using journalled quota */3090	if (is_journalled_quota(sbi))3091		set_sbi_flag(sbi, SBI_QUOTA_NEED_FLUSH);3092 3093	return ret;3094}3095 3096static int f2fs_dquot_commit_info(struct super_block *sb, int type)3097{3098	struct f2fs_sb_info *sbi = F2FS_SB(sb);3099	int ret = dquot_commit_info(sb, type);3100 3101	if (ret < 0)3102		set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);3103	return ret;3104}3105 3106static int f2fs_get_projid(struct inode *inode, kprojid_t *projid)3107{3108	*projid = F2FS_I(inode)->i_projid;3109	return 0;3110}3111 3112static const struct dquot_operations f2fs_quota_operations = {3113	.get_reserved_space = f2fs_get_reserved_space,3114	.write_dquot	= f2fs_dquot_commit,3115	.acquire_dquot	= f2fs_dquot_acquire,3116	.release_dquot	= f2fs_dquot_release,3117	.mark_dirty	= f2fs_dquot_mark_dquot_dirty,3118	.write_info	= f2fs_dquot_commit_info,3119	.alloc_dquot	= dquot_alloc,3120	.destroy_dquot	= dquot_destroy,3121	.get_projid	= f2fs_get_projid,3122	.get_next_id	= dquot_get_next_id,3123};3124 3125static const struct quotactl_ops f2fs_quotactl_ops = {3126	.quota_on	= f2fs_quota_on,3127	.quota_off	= f2fs_quota_off,3128	.quota_sync	= f2fs_quota_sync,3129	.get_state	= dquot_get_state,3130	.set_info	= dquot_set_dqinfo,3131	.get_dqblk	= dquot_get_dqblk,3132	.set_dqblk	= dquot_set_dqblk,3133	.get_nextdqblk	= dquot_get_next_dqblk,3134};3135#else3136int f2fs_dquot_initialize(struct inode *inode)3137{3138	return 0;3139}3140 3141int f2fs_quota_sync(struct super_block *sb, int type)3142{3143	return 0;3144}3145 3146void f2fs_quota_off_umount(struct super_block *sb)3147{3148}3149#endif3150 3151static const struct super_operations f2fs_sops = {3152	.alloc_inode	= f2fs_alloc_inode,3153	.free_inode	= f2fs_free_inode,3154	.drop_inode	= f2fs_drop_inode,3155	.write_inode	= f2fs_write_inode,3156	.dirty_inode	= f2fs_dirty_inode,3157	.show_options	= f2fs_show_options,3158#ifdef CONFIG_QUOTA3159	.quota_read	= f2fs_quota_read,3160	.quota_write	= f2fs_quota_write,3161	.get_dquots	= f2fs_get_dquots,3162#endif3163	.evict_inode	= f2fs_evict_inode,3164	.put_super	= f2fs_put_super,3165	.sync_fs	= f2fs_sync_fs,3166	.freeze_fs	= f2fs_freeze,3167	.unfreeze_fs	= f2fs_unfreeze,3168	.statfs		= f2fs_statfs,3169	.remount_fs	= f2fs_remount,3170	.shutdown	= f2fs_shutdown,3171};3172 3173#ifdef CONFIG_FS_ENCRYPTION3174static int f2fs_get_context(struct inode *inode, void *ctx, size_t len)3175{3176	return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,3177				F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,3178				ctx, len, NULL);3179}3180 3181static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len,3182							void *fs_data)3183{3184	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);3185 3186	/*3187	 * Encrypting the root directory is not allowed because fsck3188	 * expects lost+found directory to exist and remain unencrypted3189	 * if LOST_FOUND feature is enabled.3190	 *3191	 */3192	if (f2fs_sb_has_lost_found(sbi) &&3193			inode->i_ino == F2FS_ROOT_INO(sbi))3194		return -EPERM;3195 3196	return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,3197				F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,3198				ctx, len, fs_data, XATTR_CREATE);3199}3200 3201static const union fscrypt_policy *f2fs_get_dummy_policy(struct super_block *sb)3202{3203	return F2FS_OPTION(F2FS_SB(sb)).dummy_enc_policy.policy;3204}3205 3206static bool f2fs_has_stable_inodes(struct super_block *sb)3207{3208	return true;3209}3210 3211static struct block_device **f2fs_get_devices(struct super_block *sb,3212					      unsigned int *num_devs)3213{3214	struct f2fs_sb_info *sbi = F2FS_SB(sb);3215	struct block_device **devs;3216	int i;3217 3218	if (!f2fs_is_multi_device(sbi))3219		return NULL;3220 3221	devs = kmalloc_array(sbi->s_ndevs, sizeof(*devs), GFP_KERNEL);3222	if (!devs)3223		return ERR_PTR(-ENOMEM);3224 3225	for (i = 0; i < sbi->s_ndevs; i++)3226		devs[i] = FDEV(i).bdev;3227	*num_devs = sbi->s_ndevs;3228	return devs;3229}3230 3231static const struct fscrypt_operations f2fs_cryptops = {3232	.needs_bounce_pages	= 1,3233	.has_32bit_inodes	= 1,3234	.supports_subblock_data_units = 1,3235	.legacy_key_prefix	= "f2fs:",3236	.get_context		= f2fs_get_context,3237	.set_context		= f2fs_set_context,3238	.get_dummy_policy	= f2fs_get_dummy_policy,3239	.empty_dir		= f2fs_empty_dir,3240	.has_stable_inodes	= f2fs_has_stable_inodes,3241	.get_devices		= f2fs_get_devices,3242};3243#endif3244 3245static struct inode *f2fs_nfs_get_inode(struct super_block *sb,3246		u64 ino, u32 generation)3247{3248	struct f2fs_sb_info *sbi = F2FS_SB(sb);3249	struct inode *inode;3250 3251	if (f2fs_check_nid_range(sbi, ino))3252		return ERR_PTR(-ESTALE);3253 3254	/*3255	 * f2fs_iget isn't quite right if the inode is currently unallocated!3256	 * However f2fs_iget currently does appropriate checks to handle stale3257	 * inodes so everything is OK.3258	 */3259	inode = f2fs_iget(sb, ino);3260	if (IS_ERR(inode))3261		return ERR_CAST(inode);3262	if (unlikely(generation && inode->i_generation != generation)) {3263		/* we didn't find the right inode.. */3264		iput(inode);3265		return ERR_PTR(-ESTALE);3266	}3267	return inode;3268}3269 3270static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid,3271		int fh_len, int fh_type)3272{3273	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,3274				    f2fs_nfs_get_inode);3275}3276 3277static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid,3278		int fh_len, int fh_type)3279{3280	return generic_fh_to_parent(sb, fid, fh_len, fh_type,3281				    f2fs_nfs_get_inode);3282}3283 3284static const struct export_operations f2fs_export_ops = {3285	.encode_fh = generic_encode_ino32_fh,3286	.fh_to_dentry = f2fs_fh_to_dentry,3287	.fh_to_parent = f2fs_fh_to_parent,3288	.get_parent = f2fs_get_parent,3289};3290 3291loff_t max_file_blocks(struct inode *inode)3292{3293	loff_t result = 0;3294	loff_t leaf_count;3295 3296	/*3297	 * note: previously, result is equal to (DEF_ADDRS_PER_INODE -3298	 * DEFAULT_INLINE_XATTR_ADDRS), but now f2fs try to reserve more3299	 * space in inode.i_addr, it will be more safe to reassign3300	 * result as zero.3301	 */3302 3303	if (inode && f2fs_compressed_file(inode))3304		leaf_count = ADDRS_PER_BLOCK(inode);3305	else3306		leaf_count = DEF_ADDRS_PER_BLOCK;3307 3308	/* two direct node blocks */3309	result += (leaf_count * 2);3310 3311	/* two indirect node blocks */3312	leaf_count *= NIDS_PER_BLOCK;3313	result += (leaf_count * 2);3314 3315	/* one double indirect node block */3316	leaf_count *= NIDS_PER_BLOCK;3317	result += leaf_count;3318 3319	/*3320	 * For compatibility with FSCRYPT_POLICY_FLAG_IV_INO_LBLK_{64,32} with3321	 * a 4K crypto data unit, we must restrict the max filesize to what can3322	 * fit within U32_MAX + 1 data units.3323	 */3324 3325	result = min(result, F2FS_BYTES_TO_BLK(((loff_t)U32_MAX + 1) * 4096));3326 3327	return result;3328}3329 3330static int __f2fs_commit_super(struct f2fs_sb_info *sbi, struct folio *folio,3331						pgoff_t index, bool update)3332{3333	struct bio *bio;3334	/* it's rare case, we can do fua all the time */3335	blk_opf_t opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH | REQ_FUA;3336	int ret;3337 3338	folio_lock(folio);3339	folio_wait_writeback(folio);3340	if (update)3341		memcpy(F2FS_SUPER_BLOCK(folio, index), F2FS_RAW_SUPER(sbi),3342					sizeof(struct f2fs_super_block));3343	folio_mark_dirty(folio);3344	folio_clear_dirty_for_io(folio);3345	folio_start_writeback(folio);3346	folio_unlock(folio);3347 3348	bio = bio_alloc(sbi->sb->s_bdev, 1, opf, GFP_NOFS);3349 3350	/* it doesn't need to set crypto context for superblock update */3351	bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(folio_index(folio));3352 3353	if (!bio_add_folio(bio, folio, folio_size(folio), 0))3354		f2fs_bug_on(sbi, 1);3355 3356	ret = submit_bio_wait(bio);3357	folio_end_writeback(folio);3358 3359	return ret;3360}3361 3362static inline bool sanity_check_area_boundary(struct f2fs_sb_info *sbi,3363					struct folio *folio, pgoff_t index)3364{3365	struct f2fs_super_block *raw_super = F2FS_SUPER_BLOCK(folio, index);3366	struct super_block *sb = sbi->sb;3367	u32 segment0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);3368	u32 cp_blkaddr = le32_to_cpu(raw_super->cp_blkaddr);3369	u32 sit_blkaddr = le32_to_cpu(raw_super->sit_blkaddr);3370	u32 nat_blkaddr = le32_to_cpu(raw_super->nat_blkaddr);3371	u32 ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);3372	u32 main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);3373	u32 segment_count_ckpt = le32_to_cpu(raw_super->segment_count_ckpt);3374	u32 segment_count_sit = le32_to_cpu(raw_super->segment_count_sit);3375	u32 segment_count_nat = le32_to_cpu(raw_super->segment_count_nat);3376	u32 segment_count_ssa = le32_to_cpu(raw_super->segment_count_ssa);3377	u32 segment_count_main = le32_to_cpu(raw_super->segment_count_main);3378	u32 segment_count = le32_to_cpu(raw_super->segment_count);3379	u32 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);3380	u64 main_end_blkaddr = main_blkaddr +3381				((u64)segment_count_main << log_blocks_per_seg);3382	u64 seg_end_blkaddr = segment0_blkaddr +3383				((u64)segment_count << log_blocks_per_seg);3384 3385	if (segment0_blkaddr != cp_blkaddr) {3386		f2fs_info(sbi, "Mismatch start address, segment0(%u) cp_blkaddr(%u)",3387			  segment0_blkaddr, cp_blkaddr);3388		return true;3389	}3390 3391	if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) !=3392							sit_blkaddr) {3393		f2fs_info(sbi, "Wrong CP boundary, start(%u) end(%u) blocks(%u)",3394			  cp_blkaddr, sit_blkaddr,3395			  segment_count_ckpt << log_blocks_per_seg);3396		return true;3397	}3398 3399	if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) !=3400							nat_blkaddr) {3401		f2fs_info(sbi, "Wrong SIT boundary, start(%u) end(%u) blocks(%u)",3402			  sit_blkaddr, nat_blkaddr,3403			  segment_count_sit << log_blocks_per_seg);3404		return true;3405	}3406 3407	if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) !=3408							ssa_blkaddr) {3409		f2fs_info(sbi, "Wrong NAT boundary, start(%u) end(%u) blocks(%u)",3410			  nat_blkaddr, ssa_blkaddr,3411			  segment_count_nat << log_blocks_per_seg);3412		return true;3413	}3414 3415	if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) !=3416							main_blkaddr) {3417		f2fs_info(sbi, "Wrong SSA boundary, start(%u) end(%u) blocks(%u)",3418			  ssa_blkaddr, main_blkaddr,3419			  segment_count_ssa << log_blocks_per_seg);3420		return true;3421	}3422 3423	if (main_end_blkaddr > seg_end_blkaddr) {3424		f2fs_info(sbi, "Wrong MAIN_AREA boundary, start(%u) end(%llu) block(%u)",3425			  main_blkaddr, seg_end_blkaddr,3426			  segment_count_main << log_blocks_per_seg);3427		return true;3428	} else if (main_end_blkaddr < seg_end_blkaddr) {3429		int err = 0;3430		char *res;3431 3432		/* fix in-memory information all the time */3433		raw_super->segment_count = cpu_to_le32((main_end_blkaddr -3434				segment0_blkaddr) >> log_blocks_per_seg);3435 3436		if (f2fs_readonly(sb) || f2fs_hw_is_readonly(sbi)) {3437			set_sbi_flag(sbi, SBI_NEED_SB_WRITE);3438			res = "internally";3439		} else {3440			err = __f2fs_commit_super(sbi, folio, index, false);3441			res = err ? "failed" : "done";3442		}3443		f2fs_info(sbi, "Fix alignment : %s, start(%u) end(%llu) block(%u)",3444			  res, main_blkaddr, seg_end_blkaddr,3445			  segment_count_main << log_blocks_per_seg);3446		if (err)3447			return true;3448	}3449	return false;3450}3451 3452static int sanity_check_raw_super(struct f2fs_sb_info *sbi,3453					struct folio *folio, pgoff_t index)3454{3455	block_t segment_count, segs_per_sec, secs_per_zone, segment_count_main;3456	block_t total_sections, blocks_per_seg;3457	struct f2fs_super_block *raw_super = F2FS_SUPER_BLOCK(folio, index);3458	size_t crc_offset = 0;3459	__u32 crc = 0;3460 3461	if (le32_to_cpu(raw_super->magic) != F2FS_SUPER_MAGIC) {3462		f2fs_info(sbi, "Magic Mismatch, valid(0x%x) - read(0x%x)",3463			  F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));3464		return -EINVAL;3465	}3466 3467	/* Check checksum_offset and crc in superblock */3468	if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_SB_CHKSUM)) {3469		crc_offset = le32_to_cpu(raw_super->checksum_offset);3470		if (crc_offset !=3471			offsetof(struct f2fs_super_block, crc)) {3472			f2fs_info(sbi, "Invalid SB checksum offset: %zu",3473				  crc_offset);3474			return -EFSCORRUPTED;3475		}3476		crc = le32_to_cpu(raw_super->crc);3477		if (!f2fs_crc_valid(sbi, crc, raw_super, crc_offset)) {3478			f2fs_info(sbi, "Invalid SB checksum value: %u", crc);3479			return -EFSCORRUPTED;3480		}3481	}3482 3483	/* only support block_size equals to PAGE_SIZE */3484	if (le32_to_cpu(raw_super->log_blocksize) != F2FS_BLKSIZE_BITS) {3485		f2fs_info(sbi, "Invalid log_blocksize (%u), supports only %u",3486			  le32_to_cpu(raw_super->log_blocksize),3487			  F2FS_BLKSIZE_BITS);3488		return -EFSCORRUPTED;3489	}3490 3491	/* check log blocks per segment */3492	if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) {3493		f2fs_info(sbi, "Invalid log blocks per segment (%u)",3494			  le32_to_cpu(raw_super->log_blocks_per_seg));3495		return -EFSCORRUPTED;3496	}3497 3498	/* Currently, support 512/1024/2048/4096/16K bytes sector size */3499	if (le32_to_cpu(raw_super->log_sectorsize) >3500				F2FS_MAX_LOG_SECTOR_SIZE ||3501		le32_to_cpu(raw_super->log_sectorsize) <3502				F2FS_MIN_LOG_SECTOR_SIZE) {3503		f2fs_info(sbi, "Invalid log sectorsize (%u)",3504			  le32_to_cpu(raw_super->log_sectorsize));3505		return -EFSCORRUPTED;3506	}3507	if (le32_to_cpu(raw_super->log_sectors_per_block) +3508		le32_to_cpu(raw_super->log_sectorsize) !=3509			F2FS_MAX_LOG_SECTOR_SIZE) {3510		f2fs_info(sbi, "Invalid log sectors per block(%u) log sectorsize(%u)",3511			  le32_to_cpu(raw_super->log_sectors_per_block),3512			  le32_to_cpu(raw_super->log_sectorsize));3513		return -EFSCORRUPTED;3514	}3515 3516	segment_count = le32_to_cpu(raw_super->segment_count);3517	segment_count_main = le32_to_cpu(raw_super->segment_count_main);3518	segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);3519	secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);3520	total_sections = le32_to_cpu(raw_super->section_count);3521 3522	/* blocks_per_seg should be 512, given the above check */3523	blocks_per_seg = BIT(le32_to_cpu(raw_super->log_blocks_per_seg));3524 3525	if (segment_count > F2FS_MAX_SEGMENT ||3526				segment_count < F2FS_MIN_SEGMENTS) {3527		f2fs_info(sbi, "Invalid segment count (%u)", segment_count);3528		return -EFSCORRUPTED;3529	}3530 3531	if (total_sections > segment_count_main || total_sections < 1 ||3532			segs_per_sec > segment_count || !segs_per_sec) {3533		f2fs_info(sbi, "Invalid segment/section count (%u, %u x %u)",3534			  segment_count, total_sections, segs_per_sec);3535		return -EFSCORRUPTED;3536	}3537 3538	if (segment_count_main != total_sections * segs_per_sec) {3539		f2fs_info(sbi, "Invalid segment/section count (%u != %u * %u)",3540			  segment_count_main, total_sections, segs_per_sec);3541		return -EFSCORRUPTED;3542	}3543 3544	if ((segment_count / segs_per_sec) < total_sections) {3545		f2fs_info(sbi, "Small segment_count (%u < %u * %u)",3546			  segment_count, segs_per_sec, total_sections);3547		return -EFSCORRUPTED;3548	}3549 3550	if (segment_count > (le64_to_cpu(raw_super->block_count) >> 9)) {3551		f2fs_info(sbi, "Wrong segment_count / block_count (%u > %llu)",3552			  segment_count, le64_to_cpu(raw_super->block_count));3553		return -EFSCORRUPTED;3554	}3555 3556	if (RDEV(0).path[0]) {3557		block_t dev_seg_count = le32_to_cpu(RDEV(0).total_segments);3558		int i = 1;3559 3560		while (i < MAX_DEVICES && RDEV(i).path[0]) {3561			dev_seg_count += le32_to_cpu(RDEV(i).total_segments);3562			i++;3563		}3564		if (segment_count != dev_seg_count) {3565			f2fs_info(sbi, "Segment count (%u) mismatch with total segments from devices (%u)",3566					segment_count, dev_seg_count);3567			return -EFSCORRUPTED;3568		}3569	} else {3570		if (__F2FS_HAS_FEATURE(raw_super, F2FS_FEATURE_BLKZONED) &&3571					!bdev_is_zoned(sbi->sb->s_bdev)) {3572			f2fs_info(sbi, "Zoned block device path is missing");3573			return -EFSCORRUPTED;3574		}3575	}3576 3577	if (secs_per_zone > total_sections || !secs_per_zone) {3578		f2fs_info(sbi, "Wrong secs_per_zone / total_sections (%u, %u)",3579			  secs_per_zone, total_sections);3580		return -EFSCORRUPTED;3581	}3582	if (le32_to_cpu(raw_super->extension_count) > F2FS_MAX_EXTENSION ||3583			raw_super->hot_ext_count > F2FS_MAX_EXTENSION ||3584			(le32_to_cpu(raw_super->extension_count) +3585			raw_super->hot_ext_count) > F2FS_MAX_EXTENSION) {3586		f2fs_info(sbi, "Corrupted extension count (%u + %u > %u)",3587			  le32_to_cpu(raw_super->extension_count),3588			  raw_super->hot_ext_count,3589			  F2FS_MAX_EXTENSION);3590		return -EFSCORRUPTED;3591	}3592 3593	if (le32_to_cpu(raw_super->cp_payload) >=3594				(blocks_per_seg - F2FS_CP_PACKS -3595				NR_CURSEG_PERSIST_TYPE)) {3596		f2fs_info(sbi, "Insane cp_payload (%u >= %u)",3597			  le32_to_cpu(raw_super->cp_payload),3598			  blocks_per_seg - F2FS_CP_PACKS -3599			  NR_CURSEG_PERSIST_TYPE);3600		return -EFSCORRUPTED;3601	}3602 3603	/* check reserved ino info */3604	if (le32_to_cpu(raw_super->node_ino) != 1 ||3605		le32_to_cpu(raw_super->meta_ino) != 2 ||3606		le32_to_cpu(raw_super->root_ino) != 3) {3607		f2fs_info(sbi, "Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)",3608			  le32_to_cpu(raw_super->node_ino),3609			  le32_to_cpu(raw_super->meta_ino),3610			  le32_to_cpu(raw_super->root_ino));3611		return -EFSCORRUPTED;3612	}3613 3614	/* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */3615	if (sanity_check_area_boundary(sbi, folio, index))3616		return -EFSCORRUPTED;3617 3618	return 0;3619}3620 3621int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi)3622{3623	unsigned int total, fsmeta;3624	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);3625	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);3626	unsigned int ovp_segments, reserved_segments;3627	unsigned int main_segs, blocks_per_seg;3628	unsigned int sit_segs, nat_segs;3629	unsigned int sit_bitmap_size, nat_bitmap_size;3630	unsigned int log_blocks_per_seg;3631	unsigned int segment_count_main;3632	unsigned int cp_pack_start_sum, cp_payload;3633	block_t user_block_count, valid_user_blocks;3634	block_t avail_node_count, valid_node_count;3635	unsigned int nat_blocks, nat_bits_bytes, nat_bits_blocks;3636	int i, j;3637 3638	total = le32_to_cpu(raw_super->segment_count);3639	fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);3640	sit_segs = le32_to_cpu(raw_super->segment_count_sit);3641	fsmeta += sit_segs;3642	nat_segs = le32_to_cpu(raw_super->segment_count_nat);3643	fsmeta += nat_segs;3644	fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);3645	fsmeta += le32_to_cpu(raw_super->segment_count_ssa);3646 3647	if (unlikely(fsmeta >= total))3648		return 1;3649 3650	ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);3651	reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);3652 3653	if (!f2fs_sb_has_readonly(sbi) &&3654			unlikely(fsmeta < F2FS_MIN_META_SEGMENTS ||3655			ovp_segments == 0 || reserved_segments == 0)) {3656		f2fs_err(sbi, "Wrong layout: check mkfs.f2fs version");3657		return 1;3658	}3659	user_block_count = le64_to_cpu(ckpt->user_block_count);3660	segment_count_main = le32_to_cpu(raw_super->segment_count_main) +3661			(f2fs_sb_has_readonly(sbi) ? 1 : 0);3662	log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);3663	if (!user_block_count || user_block_count >=3664			segment_count_main << log_blocks_per_seg) {3665		f2fs_err(sbi, "Wrong user_block_count: %u",3666			 user_block_count);3667		return 1;3668	}3669 3670	valid_user_blocks = le64_to_cpu(ckpt->valid_block_count);3671	if (valid_user_blocks > user_block_count) {3672		f2fs_err(sbi, "Wrong valid_user_blocks: %u, user_block_count: %u",3673			 valid_user_blocks, user_block_count);3674		return 1;3675	}3676 3677	valid_node_count = le32_to_cpu(ckpt->valid_node_count);3678	avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;3679	if (valid_node_count > avail_node_count) {3680		f2fs_err(sbi, "Wrong valid_node_count: %u, avail_node_count: %u",3681			 valid_node_count, avail_node_count);3682		return 1;3683	}3684 3685	main_segs = le32_to_cpu(raw_super->segment_count_main);3686	blocks_per_seg = BLKS_PER_SEG(sbi);3687 3688	for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {3689		if (le32_to_cpu(ckpt->cur_node_segno[i]) >= main_segs ||3690			le16_to_cpu(ckpt->cur_node_blkoff[i]) >= blocks_per_seg)3691			return 1;3692 3693		if (f2fs_sb_has_readonly(sbi))3694			goto check_data;3695 3696		for (j = i + 1; j < NR_CURSEG_NODE_TYPE; j++) {3697			if (le32_to_cpu(ckpt->cur_node_segno[i]) ==3698				le32_to_cpu(ckpt->cur_node_segno[j])) {3699				f2fs_err(sbi, "Node segment (%u, %u) has the same segno: %u",3700					 i, j,3701					 le32_to_cpu(ckpt->cur_node_segno[i]));3702				return 1;3703			}3704		}3705	}3706check_data:3707	for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {3708		if (le32_to_cpu(ckpt->cur_data_segno[i]) >= main_segs ||3709			le16_to_cpu(ckpt->cur_data_blkoff[i]) >= blocks_per_seg)3710			return 1;3711 3712		if (f2fs_sb_has_readonly(sbi))3713			goto skip_cross;3714 3715		for (j = i + 1; j < NR_CURSEG_DATA_TYPE; j++) {3716			if (le32_to_cpu(ckpt->cur_data_segno[i]) ==3717				le32_to_cpu(ckpt->cur_data_segno[j])) {3718				f2fs_err(sbi, "Data segment (%u, %u) has the same segno: %u",3719					 i, j,3720					 le32_to_cpu(ckpt->cur_data_segno[i]));3721				return 1;3722			}3723		}3724	}3725	for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {3726		for (j = 0; j < NR_CURSEG_DATA_TYPE; j++) {3727			if (le32_to_cpu(ckpt->cur_node_segno[i]) ==3728				le32_to_cpu(ckpt->cur_data_segno[j])) {3729				f2fs_err(sbi, "Node segment (%u) and Data segment (%u) has the same segno: %u",3730					 i, j,3731					 le32_to_cpu(ckpt->cur_node_segno[i]));3732				return 1;3733			}3734		}3735	}3736skip_cross:3737	sit_bitmap_size = le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);3738	nat_bitmap_size = le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);3739 3740	if (sit_bitmap_size != ((sit_segs / 2) << log_blocks_per_seg) / 8 ||3741		nat_bitmap_size != ((nat_segs / 2) << log_blocks_per_seg) / 8) {3742		f2fs_err(sbi, "Wrong bitmap size: sit: %u, nat:%u",3743			 sit_bitmap_size, nat_bitmap_size);3744		return 1;3745	}3746 3747	cp_pack_start_sum = __start_sum_addr(sbi);3748	cp_payload = __cp_payload(sbi);3749	if (cp_pack_start_sum < cp_payload + 1 ||3750		cp_pack_start_sum > blocks_per_seg - 1 -3751			NR_CURSEG_PERSIST_TYPE) {3752		f2fs_err(sbi, "Wrong cp_pack_start_sum: %u",3753			 cp_pack_start_sum);3754		return 1;3755	}3756 3757	if (__is_set_ckpt_flags(ckpt, CP_LARGE_NAT_BITMAP_FLAG) &&3758		le32_to_cpu(ckpt->checksum_offset) != CP_MIN_CHKSUM_OFFSET) {3759		f2fs_warn(sbi, "using deprecated layout of large_nat_bitmap, "3760			  "please run fsck v1.13.0 or higher to repair, chksum_offset: %u, "3761			  "fixed with patch: \"f2fs-tools: relocate chksum_offset for large_nat_bitmap feature\"",3762			  le32_to_cpu(ckpt->checksum_offset));3763		return 1;3764	}3765 3766	nat_blocks = nat_segs << log_blocks_per_seg;3767	nat_bits_bytes = nat_blocks / BITS_PER_BYTE;3768	nat_bits_blocks = F2FS_BLK_ALIGN((nat_bits_bytes << 1) + 8);3769	if (__is_set_ckpt_flags(ckpt, CP_NAT_BITS_FLAG) &&3770		(cp_payload + F2FS_CP_PACKS +3771		NR_CURSEG_PERSIST_TYPE + nat_bits_blocks >= blocks_per_seg)) {3772		f2fs_warn(sbi, "Insane cp_payload: %u, nat_bits_blocks: %u)",3773			  cp_payload, nat_bits_blocks);3774		return 1;3775	}3776 3777	if (unlikely(f2fs_cp_error(sbi))) {3778		f2fs_err(sbi, "A bug case: need to run fsck");3779		return 1;3780	}3781	return 0;3782}3783 3784static void init_sb_info(struct f2fs_sb_info *sbi)3785{3786	struct f2fs_super_block *raw_super = sbi->raw_super;3787	int i;3788 3789	sbi->log_sectors_per_block =3790		le32_to_cpu(raw_super->log_sectors_per_block);3791	sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);3792	sbi->blocksize = BIT(sbi->log_blocksize);3793	sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);3794	sbi->blocks_per_seg = BIT(sbi->log_blocks_per_seg);3795	sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);3796	sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);3797	sbi->total_sections = le32_to_cpu(raw_super->section_count);3798	sbi->total_node_count = SEGS_TO_BLKS(sbi,3799			((le32_to_cpu(raw_super->segment_count_nat) / 2) *3800			NAT_ENTRY_PER_BLOCK));3801	F2FS_ROOT_INO(sbi) = le32_to_cpu(raw_super->root_ino);3802	F2FS_NODE_INO(sbi) = le32_to_cpu(raw_super->node_ino);3803	F2FS_META_INO(sbi) = le32_to_cpu(raw_super->meta_ino);3804	sbi->cur_victim_sec = NULL_SECNO;3805	sbi->gc_mode = GC_NORMAL;3806	sbi->next_victim_seg[BG_GC] = NULL_SEGNO;3807	sbi->next_victim_seg[FG_GC] = NULL_SEGNO;3808	sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;3809	sbi->migration_granularity = SEGS_PER_SEC(sbi);3810	sbi->migration_window_granularity = f2fs_sb_has_blkzoned(sbi) ?3811		DEF_MIGRATION_WINDOW_GRANULARITY_ZONED : SEGS_PER_SEC(sbi);3812	sbi->seq_file_ra_mul = MIN_RA_MUL;3813	sbi->max_fragment_chunk = DEF_FRAGMENT_SIZE;3814	sbi->max_fragment_hole = DEF_FRAGMENT_SIZE;3815	spin_lock_init(&sbi->gc_remaining_trials_lock);3816	atomic64_set(&sbi->current_atomic_write, 0);3817 3818	sbi->dir_level = DEF_DIR_LEVEL;3819	sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;3820	sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;3821	sbi->interval_time[DISCARD_TIME] = DEF_IDLE_INTERVAL;3822	sbi->interval_time[GC_TIME] = DEF_IDLE_INTERVAL;3823	sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_INTERVAL;3824	sbi->interval_time[UMOUNT_DISCARD_TIMEOUT] =3825				DEF_UMOUNT_DISCARD_TIMEOUT;3826	clear_sbi_flag(sbi, SBI_NEED_FSCK);3827 3828	for (i = 0; i < NR_COUNT_TYPE; i++)3829		atomic_set(&sbi->nr_pages[i], 0);3830 3831	for (i = 0; i < META; i++)3832		atomic_set(&sbi->wb_sync_req[i], 0);3833 3834	INIT_LIST_HEAD(&sbi->s_list);3835	mutex_init(&sbi->umount_mutex);3836	init_f2fs_rwsem(&sbi->io_order_lock);3837	spin_lock_init(&sbi->cp_lock);3838 3839	sbi->dirty_device = 0;3840	spin_lock_init(&sbi->dev_lock);3841 3842	init_f2fs_rwsem(&sbi->sb_lock);3843	init_f2fs_rwsem(&sbi->pin_sem);3844}3845 3846static int init_percpu_info(struct f2fs_sb_info *sbi)3847{3848	int err;3849 3850	err = percpu_counter_init(&sbi->alloc_valid_block_count, 0, GFP_KERNEL);3851	if (err)3852		return err;3853 3854	err = percpu_counter_init(&sbi->rf_node_block_count, 0, GFP_KERNEL);3855	if (err)3856		goto err_valid_block;3857 3858	err = percpu_counter_init(&sbi->total_valid_inode_count, 0,3859								GFP_KERNEL);3860	if (err)3861		goto err_node_block;3862	return 0;3863 3864err_node_block:3865	percpu_counter_destroy(&sbi->rf_node_block_count);3866err_valid_block:3867	percpu_counter_destroy(&sbi->alloc_valid_block_count);3868	return err;3869}3870 3871#ifdef CONFIG_BLK_DEV_ZONED3872 3873struct f2fs_report_zones_args {3874	struct f2fs_sb_info *sbi;3875	struct f2fs_dev_info *dev;3876};3877 3878static int f2fs_report_zone_cb(struct blk_zone *zone, unsigned int idx,3879			      void *data)3880{3881	struct f2fs_report_zones_args *rz_args = data;3882	block_t unusable_blocks = (zone->len - zone->capacity) >>3883					F2FS_LOG_SECTORS_PER_BLOCK;3884 3885	if (zone->type == BLK_ZONE_TYPE_CONVENTIONAL)3886		return 0;3887 3888	set_bit(idx, rz_args->dev->blkz_seq);3889	if (!rz_args->sbi->unusable_blocks_per_sec) {3890		rz_args->sbi->unusable_blocks_per_sec = unusable_blocks;3891		return 0;3892	}3893	if (rz_args->sbi->unusable_blocks_per_sec != unusable_blocks) {3894		f2fs_err(rz_args->sbi, "F2FS supports single zone capacity\n");3895		return -EINVAL;3896	}3897	return 0;3898}3899 3900static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)3901{3902	struct block_device *bdev = FDEV(devi).bdev;3903	sector_t nr_sectors = bdev_nr_sectors(bdev);3904	struct f2fs_report_zones_args rep_zone_arg;3905	u64 zone_sectors;3906	unsigned int max_open_zones;3907	int ret;3908 3909	if (!f2fs_sb_has_blkzoned(sbi))3910		return 0;3911 3912	if (bdev_is_zoned(FDEV(devi).bdev)) {3913		max_open_zones = bdev_max_open_zones(bdev);3914		if (max_open_zones && (max_open_zones < sbi->max_open_zones))3915			sbi->max_open_zones = max_open_zones;3916		if (sbi->max_open_zones < F2FS_OPTION(sbi).active_logs) {3917			f2fs_err(sbi,3918				"zoned: max open zones %u is too small, need at least %u open zones",3919				sbi->max_open_zones, F2FS_OPTION(sbi).active_logs);3920			return -EINVAL;3921		}3922	}3923 3924	zone_sectors = bdev_zone_sectors(bdev);3925	if (sbi->blocks_per_blkz && sbi->blocks_per_blkz !=3926				SECTOR_TO_BLOCK(zone_sectors))3927		return -EINVAL;3928	sbi->blocks_per_blkz = SECTOR_TO_BLOCK(zone_sectors);3929	FDEV(devi).nr_blkz = div_u64(SECTOR_TO_BLOCK(nr_sectors),3930					sbi->blocks_per_blkz);3931	if (nr_sectors & (zone_sectors - 1))3932		FDEV(devi).nr_blkz++;3933 3934	FDEV(devi).blkz_seq = f2fs_kvzalloc(sbi,3935					BITS_TO_LONGS(FDEV(devi).nr_blkz)3936					* sizeof(unsigned long),3937					GFP_KERNEL);3938	if (!FDEV(devi).blkz_seq)3939		return -ENOMEM;3940 3941	rep_zone_arg.sbi = sbi;3942	rep_zone_arg.dev = &FDEV(devi);3943 3944	ret = blkdev_report_zones(bdev, 0, BLK_ALL_ZONES, f2fs_report_zone_cb,3945				  &rep_zone_arg);3946	if (ret < 0)3947		return ret;3948	return 0;3949}3950#endif3951 3952/*3953 * Read f2fs raw super block.3954 * Because we have two copies of super block, so read both of them3955 * to get the first valid one. If any one of them is broken, we pass3956 * them recovery flag back to the caller.3957 */3958static int read_raw_super_block(struct f2fs_sb_info *sbi,3959			struct f2fs_super_block **raw_super,3960			int *valid_super_block, int *recovery)3961{3962	struct super_block *sb = sbi->sb;3963	int block;3964	struct folio *folio;3965	struct f2fs_super_block *super;3966	int err = 0;3967 3968	super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);3969	if (!super)3970		return -ENOMEM;3971 3972	for (block = 0; block < 2; block++) {3973		folio = read_mapping_folio(sb->s_bdev->bd_mapping, block, NULL);3974		if (IS_ERR(folio)) {3975			f2fs_err(sbi, "Unable to read %dth superblock",3976				 block + 1);3977			err = PTR_ERR(folio);3978			*recovery = 1;3979			continue;3980		}3981 3982		/* sanity checking of raw super */3983		err = sanity_check_raw_super(sbi, folio, block);3984		if (err) {3985			f2fs_err(sbi, "Can't find valid F2FS filesystem in %dth superblock",3986				 block + 1);3987			folio_put(folio);3988			*recovery = 1;3989			continue;3990		}3991 3992		if (!*raw_super) {3993			memcpy(super, F2FS_SUPER_BLOCK(folio, block),3994							sizeof(*super));3995			*valid_super_block = block;3996			*raw_super = super;3997		}3998		folio_put(folio);3999	}4000 4001	/* No valid superblock */4002	if (!*raw_super)4003		kfree(super);4004	else4005		err = 0;4006 4007	return err;4008}4009 4010int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)4011{4012	struct folio *folio;4013	pgoff_t index;4014	__u32 crc = 0;4015	int err;4016 4017	if ((recover && f2fs_readonly(sbi->sb)) ||4018				f2fs_hw_is_readonly(sbi)) {4019		set_sbi_flag(sbi, SBI_NEED_SB_WRITE);4020		return -EROFS;4021	}4022 4023	/* we should update superblock crc here */4024	if (!recover && f2fs_sb_has_sb_chksum(sbi)) {4025		crc = f2fs_crc32(sbi, F2FS_RAW_SUPER(sbi),4026				offsetof(struct f2fs_super_block, crc));4027		F2FS_RAW_SUPER(sbi)->crc = cpu_to_le32(crc);4028	}4029 4030	/* write back-up superblock first */4031	index = sbi->valid_super_block ? 0 : 1;4032	folio = read_mapping_folio(sbi->sb->s_bdev->bd_mapping, index, NULL);4033	if (IS_ERR(folio))4034		return PTR_ERR(folio);4035	err = __f2fs_commit_super(sbi, folio, index, true);4036	folio_put(folio);4037 4038	/* if we are in recovery path, skip writing valid superblock */4039	if (recover || err)4040		return err;4041 4042	/* write current valid superblock */4043	index = sbi->valid_super_block;4044	folio = read_mapping_folio(sbi->sb->s_bdev->bd_mapping, index, NULL);4045	if (IS_ERR(folio))4046		return PTR_ERR(folio);4047	err = __f2fs_commit_super(sbi, folio, index, true);4048	folio_put(folio);4049	return err;4050}4051 4052static void save_stop_reason(struct f2fs_sb_info *sbi, unsigned char reason)4053{4054	unsigned long flags;4055 4056	spin_lock_irqsave(&sbi->error_lock, flags);4057	if (sbi->stop_reason[reason] < GENMASK(BITS_PER_BYTE - 1, 0))4058		sbi->stop_reason[reason]++;4059	spin_unlock_irqrestore(&sbi->error_lock, flags);4060}4061 4062static void f2fs_record_stop_reason(struct f2fs_sb_info *sbi)4063{4064	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);4065	unsigned long flags;4066	int err;4067 4068	f2fs_down_write(&sbi->sb_lock);4069 4070	spin_lock_irqsave(&sbi->error_lock, flags);4071	if (sbi->error_dirty) {4072		memcpy(F2FS_RAW_SUPER(sbi)->s_errors, sbi->errors,4073							MAX_F2FS_ERRORS);4074		sbi->error_dirty = false;4075	}4076	memcpy(raw_super->s_stop_reason, sbi->stop_reason, MAX_STOP_REASON);4077	spin_unlock_irqrestore(&sbi->error_lock, flags);4078 4079	err = f2fs_commit_super(sbi, false);4080 4081	f2fs_up_write(&sbi->sb_lock);4082	if (err)4083		f2fs_err_ratelimited(sbi,4084			"f2fs_commit_super fails to record stop_reason, err:%d",4085			err);4086}4087 4088void f2fs_save_errors(struct f2fs_sb_info *sbi, unsigned char flag)4089{4090	unsigned long flags;4091 4092	spin_lock_irqsave(&sbi->error_lock, flags);4093	if (!test_bit(flag, (unsigned long *)sbi->errors)) {4094		set_bit(flag, (unsigned long *)sbi->errors);4095		sbi->error_dirty = true;4096	}4097	spin_unlock_irqrestore(&sbi->error_lock, flags);4098}4099 4100static bool f2fs_update_errors(struct f2fs_sb_info *sbi)4101{4102	unsigned long flags;4103	bool need_update = false;4104 4105	spin_lock_irqsave(&sbi->error_lock, flags);4106	if (sbi->error_dirty) {4107		memcpy(F2FS_RAW_SUPER(sbi)->s_errors, sbi->errors,4108							MAX_F2FS_ERRORS);4109		sbi->error_dirty = false;4110		need_update = true;4111	}4112	spin_unlock_irqrestore(&sbi->error_lock, flags);4113 4114	return need_update;4115}4116 4117static void f2fs_record_errors(struct f2fs_sb_info *sbi, unsigned char error)4118{4119	int err;4120 4121	f2fs_down_write(&sbi->sb_lock);4122 4123	if (!f2fs_update_errors(sbi))4124		goto out_unlock;4125 4126	err = f2fs_commit_super(sbi, false);4127	if (err)4128		f2fs_err_ratelimited(sbi,4129			"f2fs_commit_super fails to record errors:%u, err:%d",4130			error, err);4131out_unlock:4132	f2fs_up_write(&sbi->sb_lock);4133}4134 4135void f2fs_handle_error(struct f2fs_sb_info *sbi, unsigned char error)4136{4137	f2fs_save_errors(sbi, error);4138	f2fs_record_errors(sbi, error);4139}4140 4141void f2fs_handle_error_async(struct f2fs_sb_info *sbi, unsigned char error)4142{4143	f2fs_save_errors(sbi, error);4144 4145	if (!sbi->error_dirty)4146		return;4147	if (!test_bit(error, (unsigned long *)sbi->errors))4148		return;4149	schedule_work(&sbi->s_error_work);4150}4151 4152static bool system_going_down(void)4153{4154	return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF4155		|| system_state == SYSTEM_RESTART;4156}4157 4158void f2fs_handle_critical_error(struct f2fs_sb_info *sbi, unsigned char reason,4159							bool irq_context)4160{4161	struct super_block *sb = sbi->sb;4162	bool shutdown = reason == STOP_CP_REASON_SHUTDOWN;4163	bool continue_fs = !shutdown &&4164			F2FS_OPTION(sbi).errors == MOUNT_ERRORS_CONTINUE;4165 4166	set_ckpt_flags(sbi, CP_ERROR_FLAG);4167 4168	if (!f2fs_hw_is_readonly(sbi)) {4169		save_stop_reason(sbi, reason);4170 4171		if (irq_context && !shutdown)4172			schedule_work(&sbi->s_error_work);4173		else4174			f2fs_record_stop_reason(sbi);4175	}4176 4177	/*4178	 * We force ERRORS_RO behavior when system is rebooting. Otherwise we4179	 * could panic during 'reboot -f' as the underlying device got already4180	 * disabled.4181	 */4182	if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_PANIC &&4183				!shutdown && !system_going_down() &&4184				!is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN))4185		panic("F2FS-fs (device %s): panic forced after error\n",4186							sb->s_id);4187 4188	if (shutdown)4189		set_sbi_flag(sbi, SBI_IS_SHUTDOWN);4190 4191	/*4192	 * Continue filesystem operators if errors=continue. Should not set4193	 * RO by shutdown, since RO bypasses thaw_super which can hang the4194	 * system.4195	 */4196	if (continue_fs || f2fs_readonly(sb) || shutdown) {4197		f2fs_warn(sbi, "Stopped filesystem due to reason: %d", reason);4198		return;4199	}4200 4201	f2fs_warn(sbi, "Remounting filesystem read-only");4202 4203	/*4204	 * We have already set CP_ERROR_FLAG flag to stop all updates4205	 * to filesystem, so it doesn't need to set SB_RDONLY flag here4206	 * because the flag should be set covered w/ sb->s_umount semaphore4207	 * via remount procedure, otherwise, it will confuse code like4208	 * freeze_super() which will lead to deadlocks and other problems.4209	 */4210}4211 4212static void f2fs_record_error_work(struct work_struct *work)4213{4214	struct f2fs_sb_info *sbi = container_of(work,4215					struct f2fs_sb_info, s_error_work);4216 4217	f2fs_record_stop_reason(sbi);4218}4219 4220static int f2fs_scan_devices(struct f2fs_sb_info *sbi)4221{4222	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);4223	unsigned int max_devices = MAX_DEVICES;4224	unsigned int logical_blksize;4225	blk_mode_t mode = sb_open_mode(sbi->sb->s_flags);4226	int i;4227 4228	/* Initialize single device information */4229	if (!RDEV(0).path[0]) {4230		if (!bdev_is_zoned(sbi->sb->s_bdev))4231			return 0;4232		max_devices = 1;4233	}4234 4235	/*4236	 * Initialize multiple devices information, or single4237	 * zoned block device information.4238	 */4239	sbi->devs = f2fs_kzalloc(sbi,4240				 array_size(max_devices,4241					    sizeof(struct f2fs_dev_info)),4242				 GFP_KERNEL);4243	if (!sbi->devs)4244		return -ENOMEM;4245 4246	logical_blksize = bdev_logical_block_size(sbi->sb->s_bdev);4247	sbi->aligned_blksize = true;4248#ifdef CONFIG_BLK_DEV_ZONED4249	sbi->max_open_zones = UINT_MAX;4250	sbi->blkzone_alloc_policy = BLKZONE_ALLOC_PRIOR_SEQ;4251#endif4252 4253	for (i = 0; i < max_devices; i++) {4254		if (i == 0)4255			FDEV(0).bdev_file = sbi->sb->s_bdev_file;4256		else if (!RDEV(i).path[0])4257			break;4258 4259		if (max_devices > 1) {4260			/* Multi-device mount */4261			memcpy(FDEV(i).path, RDEV(i).path, MAX_PATH_LEN);4262			FDEV(i).total_segments =4263				le32_to_cpu(RDEV(i).total_segments);4264			if (i == 0) {4265				FDEV(i).start_blk = 0;4266				FDEV(i).end_blk = FDEV(i).start_blk +4267					SEGS_TO_BLKS(sbi,4268					FDEV(i).total_segments) - 1 +4269					le32_to_cpu(raw_super->segment0_blkaddr);4270			} else {4271				FDEV(i).start_blk = FDEV(i - 1).end_blk + 1;4272				FDEV(i).end_blk = FDEV(i).start_blk +4273						SEGS_TO_BLKS(sbi,4274						FDEV(i).total_segments) - 1;4275				FDEV(i).bdev_file = bdev_file_open_by_path(4276					FDEV(i).path, mode, sbi->sb, NULL);4277			}4278		}4279		if (IS_ERR(FDEV(i).bdev_file))4280			return PTR_ERR(FDEV(i).bdev_file);4281 4282		FDEV(i).bdev = file_bdev(FDEV(i).bdev_file);4283		/* to release errored devices */4284		sbi->s_ndevs = i + 1;4285 4286		if (logical_blksize != bdev_logical_block_size(FDEV(i).bdev))4287			sbi->aligned_blksize = false;4288 4289#ifdef CONFIG_BLK_DEV_ZONED4290		if (bdev_is_zoned(FDEV(i).bdev)) {4291			if (!f2fs_sb_has_blkzoned(sbi)) {4292				f2fs_err(sbi, "Zoned block device feature not enabled");4293				return -EINVAL;4294			}4295			if (init_blkz_info(sbi, i)) {4296				f2fs_err(sbi, "Failed to initialize F2FS blkzone information");4297				return -EINVAL;4298			}4299			if (max_devices == 1)4300				break;4301			f2fs_info(sbi, "Mount Device [%2d]: %20s, %8u, %8x - %8x (zone: Host-managed)",4302				  i, FDEV(i).path,4303				  FDEV(i).total_segments,4304				  FDEV(i).start_blk, FDEV(i).end_blk);4305			continue;4306		}4307#endif4308		f2fs_info(sbi, "Mount Device [%2d]: %20s, %8u, %8x - %8x",4309			  i, FDEV(i).path,4310			  FDEV(i).total_segments,4311			  FDEV(i).start_blk, FDEV(i).end_blk);4312	}4313	return 0;4314}4315 4316static int f2fs_setup_casefold(struct f2fs_sb_info *sbi)4317{4318#if IS_ENABLED(CONFIG_UNICODE)4319	if (f2fs_sb_has_casefold(sbi) && !sbi->sb->s_encoding) {4320		const struct f2fs_sb_encodings *encoding_info;4321		struct unicode_map *encoding;4322		__u16 encoding_flags;4323 4324		encoding_info = f2fs_sb_read_encoding(sbi->raw_super);4325		if (!encoding_info) {4326			f2fs_err(sbi,4327				 "Encoding requested by superblock is unknown");4328			return -EINVAL;4329		}4330 4331		encoding_flags = le16_to_cpu(sbi->raw_super->s_encoding_flags);4332		encoding = utf8_load(encoding_info->version);4333		if (IS_ERR(encoding)) {4334			f2fs_err(sbi,4335				 "can't mount with superblock charset: %s-%u.%u.%u "4336				 "not supported by the kernel. flags: 0x%x.",4337				 encoding_info->name,4338				 unicode_major(encoding_info->version),4339				 unicode_minor(encoding_info->version),4340				 unicode_rev(encoding_info->version),4341				 encoding_flags);4342			return PTR_ERR(encoding);4343		}4344		f2fs_info(sbi, "Using encoding defined by superblock: "4345			 "%s-%u.%u.%u with flags 0x%hx", encoding_info->name,4346			 unicode_major(encoding_info->version),4347			 unicode_minor(encoding_info->version),4348			 unicode_rev(encoding_info->version),4349			 encoding_flags);4350 4351		sbi->sb->s_encoding = encoding;4352		sbi->sb->s_encoding_flags = encoding_flags;4353	}4354#else4355	if (f2fs_sb_has_casefold(sbi)) {4356		f2fs_err(sbi, "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");4357		return -EINVAL;4358	}4359#endif4360	return 0;4361}4362 4363static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)4364{4365	/* adjust parameters according to the volume size */4366	if (MAIN_SEGS(sbi) <= SMALL_VOLUME_SEGMENTS) {4367		if (f2fs_block_unit_discard(sbi))4368			SM_I(sbi)->dcc_info->discard_granularity =4369						MIN_DISCARD_GRANULARITY;4370		if (!f2fs_lfs_mode(sbi))4371			SM_I(sbi)->ipu_policy = BIT(F2FS_IPU_FORCE) |4372						BIT(F2FS_IPU_HONOR_OPU_WRITE);4373	}4374 4375	sbi->readdir_ra = true;4376}4377 4378static int f2fs_fill_super(struct super_block *sb, void *data, int silent)4379{4380	struct f2fs_sb_info *sbi;4381	struct f2fs_super_block *raw_super;4382	struct inode *root;4383	int err;4384	bool skip_recovery = false, need_fsck = false;4385	char *options = NULL;4386	int recovery, i, valid_super_block;4387	struct curseg_info *seg_i;4388	int retry_cnt = 1;4389#ifdef CONFIG_QUOTA4390	bool quota_enabled = false;4391#endif4392 4393try_onemore:4394	err = -EINVAL;4395	raw_super = NULL;4396	valid_super_block = -1;4397	recovery = 0;4398 4399	/* allocate memory for f2fs-specific super block info */4400	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);4401	if (!sbi)4402		return -ENOMEM;4403 4404	sbi->sb = sb;4405 4406	/* initialize locks within allocated memory */4407	init_f2fs_rwsem(&sbi->gc_lock);4408	mutex_init(&sbi->writepages);4409	init_f2fs_rwsem(&sbi->cp_global_sem);4410	init_f2fs_rwsem(&sbi->node_write);4411	init_f2fs_rwsem(&sbi->node_change);4412	spin_lock_init(&sbi->stat_lock);4413	init_f2fs_rwsem(&sbi->cp_rwsem);4414	init_f2fs_rwsem(&sbi->quota_sem);4415	init_waitqueue_head(&sbi->cp_wait);4416	spin_lock_init(&sbi->error_lock);4417 4418	for (i = 0; i < NR_INODE_TYPE; i++) {4419		INIT_LIST_HEAD(&sbi->inode_list[i]);4420		spin_lock_init(&sbi->inode_lock[i]);4421	}4422	mutex_init(&sbi->flush_lock);4423 4424	/* Load the checksum driver */4425	sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0);4426	if (IS_ERR(sbi->s_chksum_driver)) {4427		f2fs_err(sbi, "Cannot load crc32 driver.");4428		err = PTR_ERR(sbi->s_chksum_driver);4429		sbi->s_chksum_driver = NULL;4430		goto free_sbi;4431	}4432 4433	/* set a block size */4434	if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {4435		f2fs_err(sbi, "unable to set blocksize");4436		goto free_sbi;4437	}4438 4439	err = read_raw_super_block(sbi, &raw_super, &valid_super_block,4440								&recovery);4441	if (err)4442		goto free_sbi;4443 4444	sb->s_fs_info = sbi;4445	sbi->raw_super = raw_super;4446 4447	INIT_WORK(&sbi->s_error_work, f2fs_record_error_work);4448	memcpy(sbi->errors, raw_super->s_errors, MAX_F2FS_ERRORS);4449	memcpy(sbi->stop_reason, raw_super->s_stop_reason, MAX_STOP_REASON);4450 4451	/* precompute checksum seed for metadata */4452	if (f2fs_sb_has_inode_chksum(sbi))4453		sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid,4454						sizeof(raw_super->uuid));4455 4456	default_options(sbi, false);4457	/* parse mount options */4458	options = kstrdup((const char *)data, GFP_KERNEL);4459	if (data && !options) {4460		err = -ENOMEM;4461		goto free_sb_buf;4462	}4463 4464	err = parse_options(sb, options, false);4465	if (err)4466		goto free_options;4467 4468	sb->s_maxbytes = max_file_blocks(NULL) <<4469				le32_to_cpu(raw_super->log_blocksize);4470	sb->s_max_links = F2FS_LINK_MAX;4471 4472	err = f2fs_setup_casefold(sbi);4473	if (err)4474		goto free_options;4475 4476#ifdef CONFIG_QUOTA4477	sb->dq_op = &f2fs_quota_operations;4478	sb->s_qcop = &f2fs_quotactl_ops;4479	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;4480 4481	if (f2fs_sb_has_quota_ino(sbi)) {4482		for (i = 0; i < MAXQUOTAS; i++) {4483			if (f2fs_qf_ino(sbi->sb, i))4484				sbi->nquota_files++;4485		}4486	}4487#endif4488 4489	sb->s_op = &f2fs_sops;4490#ifdef CONFIG_FS_ENCRYPTION4491	sb->s_cop = &f2fs_cryptops;4492#endif4493#ifdef CONFIG_FS_VERITY4494	sb->s_vop = &f2fs_verityops;4495#endif4496	sb->s_xattr = f2fs_xattr_handlers;4497	sb->s_export_op = &f2fs_export_ops;4498	sb->s_magic = F2FS_SUPER_MAGIC;4499	sb->s_time_gran = 1;4500	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |4501		(test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);4502	super_set_uuid(sb, (void *) raw_super->uuid, sizeof(raw_super->uuid));4503	super_set_sysfs_name_bdev(sb);4504	sb->s_iflags |= SB_I_CGROUPWB;4505 4506	/* init f2fs-specific super block info */4507	sbi->valid_super_block = valid_super_block;4508 4509	/* disallow all the data/node/meta page writes */4510	set_sbi_flag(sbi, SBI_POR_DOING);4511 4512	err = f2fs_init_write_merge_io(sbi);4513	if (err)4514		goto free_bio_info;4515 4516	init_sb_info(sbi);4517 4518	err = f2fs_init_iostat(sbi);4519	if (err)4520		goto free_bio_info;4521 4522	err = init_percpu_info(sbi);4523	if (err)4524		goto free_iostat;4525 4526	/* init per sbi slab cache */4527	err = f2fs_init_xattr_caches(sbi);4528	if (err)4529		goto free_percpu;4530	err = f2fs_init_page_array_cache(sbi);4531	if (err)4532		goto free_xattr_cache;4533 4534	/* get an inode for meta space */4535	sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));4536	if (IS_ERR(sbi->meta_inode)) {4537		f2fs_err(sbi, "Failed to read F2FS meta data inode");4538		err = PTR_ERR(sbi->meta_inode);4539		goto free_page_array_cache;4540	}4541 4542	err = f2fs_get_valid_checkpoint(sbi);4543	if (err) {4544		f2fs_err(sbi, "Failed to get valid F2FS checkpoint");4545		goto free_meta_inode;4546	}4547 4548	if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_QUOTA_NEED_FSCK_FLAG))4549		set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);4550	if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_DISABLED_QUICK_FLAG)) {4551		set_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);4552		sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_QUICK_INTERVAL;4553	}4554 4555	if (__is_set_ckpt_flags(F2FS_CKPT(sbi), CP_FSCK_FLAG))4556		set_sbi_flag(sbi, SBI_NEED_FSCK);4557 4558	/* Initialize device list */4559	err = f2fs_scan_devices(sbi);4560	if (err) {4561		f2fs_err(sbi, "Failed to find devices");4562		goto free_devices;4563	}4564 4565	err = f2fs_init_post_read_wq(sbi);4566	if (err) {4567		f2fs_err(sbi, "Failed to initialize post read workqueue");4568		goto free_devices;4569	}4570 4571	sbi->total_valid_node_count =4572				le32_to_cpu(sbi->ckpt->valid_node_count);4573	percpu_counter_set(&sbi->total_valid_inode_count,4574				le32_to_cpu(sbi->ckpt->valid_inode_count));4575	sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);4576	sbi->total_valid_block_count =4577				le64_to_cpu(sbi->ckpt->valid_block_count);4578	sbi->last_valid_block_count = sbi->total_valid_block_count;4579	sbi->reserved_blocks = 0;4580	sbi->current_reserved_blocks = 0;4581	limit_reserve_root(sbi);4582	adjust_unusable_cap_perc(sbi);4583 4584	f2fs_init_extent_cache_info(sbi);4585 4586	f2fs_init_ino_entry_info(sbi);4587 4588	f2fs_init_fsync_node_info(sbi);4589 4590	/* setup checkpoint request control and start checkpoint issue thread */4591	f2fs_init_ckpt_req_control(sbi);4592	if (!f2fs_readonly(sb) && !test_opt(sbi, DISABLE_CHECKPOINT) &&4593			test_opt(sbi, MERGE_CHECKPOINT)) {4594		err = f2fs_start_ckpt_thread(sbi);4595		if (err) {4596			f2fs_err(sbi,4597			    "Failed to start F2FS issue_checkpoint_thread (%d)",4598			    err);4599			goto stop_ckpt_thread;4600		}4601	}4602 4603	/* setup f2fs internal modules */4604	err = f2fs_build_segment_manager(sbi);4605	if (err) {4606		f2fs_err(sbi, "Failed to initialize F2FS segment manager (%d)",4607			 err);4608		goto free_sm;4609	}4610	err = f2fs_build_node_manager(sbi);4611	if (err) {4612		f2fs_err(sbi, "Failed to initialize F2FS node manager (%d)",4613			 err);4614		goto free_nm;4615	}4616 4617	/* For write statistics */4618	sbi->sectors_written_start = f2fs_get_sectors_written(sbi);4619 4620	/* Read accumulated write IO statistics if exists */4621	seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);4622	if (__exist_node_summaries(sbi))4623		sbi->kbytes_written =4624			le64_to_cpu(seg_i->journal->info.kbytes_written);4625 4626	f2fs_build_gc_manager(sbi);4627 4628	err = f2fs_build_stats(sbi);4629	if (err)4630		goto free_nm;4631 4632	/* get an inode for node space */4633	sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));4634	if (IS_ERR(sbi->node_inode)) {4635		f2fs_err(sbi, "Failed to read node inode");4636		err = PTR_ERR(sbi->node_inode);4637		goto free_stats;4638	}4639 4640	/* read root inode and dentry */4641	root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));4642	if (IS_ERR(root)) {4643		f2fs_err(sbi, "Failed to read root inode");4644		err = PTR_ERR(root);4645		goto free_node_inode;4646	}4647	if (!S_ISDIR(root->i_mode) || !root->i_blocks ||4648			!root->i_size || !root->i_nlink) {4649		iput(root);4650		err = -EINVAL;4651		goto free_node_inode;4652	}4653 4654	generic_set_sb_d_ops(sb);4655	sb->s_root = d_make_root(root); /* allocate root dentry */4656	if (!sb->s_root) {4657		err = -ENOMEM;4658		goto free_node_inode;4659	}4660 4661	err = f2fs_init_compress_inode(sbi);4662	if (err)4663		goto free_root_inode;4664 4665	err = f2fs_register_sysfs(sbi);4666	if (err)4667		goto free_compress_inode;4668 4669#ifdef CONFIG_QUOTA4670	/* Enable quota usage during mount */4671	if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb)) {4672		err = f2fs_enable_quotas(sb);4673		if (err)4674			f2fs_err(sbi, "Cannot turn on quotas: error %d", err);4675	}4676 4677	quota_enabled = f2fs_recover_quota_begin(sbi);4678#endif4679	/* if there are any orphan inodes, free them */4680	err = f2fs_recover_orphan_inodes(sbi);4681	if (err)4682		goto free_meta;4683 4684	if (unlikely(is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)))4685		goto reset_checkpoint;4686 4687	/* recover fsynced data */4688	if (!test_opt(sbi, DISABLE_ROLL_FORWARD) &&4689			!test_opt(sbi, NORECOVERY)) {4690		/*4691		 * mount should be failed, when device has readonly mode, and4692		 * previous checkpoint was not done by clean system shutdown.4693		 */4694		if (f2fs_hw_is_readonly(sbi)) {4695			if (!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {4696				err = f2fs_recover_fsync_data(sbi, true);4697				if (err > 0) {4698					err = -EROFS;4699					f2fs_err(sbi, "Need to recover fsync data, but "4700						"write access unavailable, please try "4701						"mount w/ disable_roll_forward or norecovery");4702				}4703				if (err < 0)4704					goto free_meta;4705			}4706			f2fs_info(sbi, "write access unavailable, skipping recovery");4707			goto reset_checkpoint;4708		}4709 4710		if (need_fsck)4711			set_sbi_flag(sbi, SBI_NEED_FSCK);4712 4713		if (skip_recovery)4714			goto reset_checkpoint;4715 4716		err = f2fs_recover_fsync_data(sbi, false);4717		if (err < 0) {4718			if (err != -ENOMEM)4719				skip_recovery = true;4720			need_fsck = true;4721			f2fs_err(sbi, "Cannot recover all fsync data errno=%d",4722				 err);4723			goto free_meta;4724		}4725	} else {4726		err = f2fs_recover_fsync_data(sbi, true);4727 4728		if (!f2fs_readonly(sb) && err > 0) {4729			err = -EINVAL;4730			f2fs_err(sbi, "Need to recover fsync data");4731			goto free_meta;4732		}4733	}4734 4735#ifdef CONFIG_QUOTA4736	f2fs_recover_quota_end(sbi, quota_enabled);4737#endif4738reset_checkpoint:4739	/*4740	 * If the f2fs is not readonly and fsync data recovery succeeds,4741	 * check zoned block devices' write pointer consistency.4742	 */4743	if (f2fs_sb_has_blkzoned(sbi) && !f2fs_readonly(sb)) {4744		int err2;4745 4746		f2fs_notice(sbi, "Checking entire write pointers");4747		err2 = f2fs_check_write_pointer(sbi);4748		if (err2)4749			err = err2;4750	}4751	if (err)4752		goto free_meta;4753 4754	err = f2fs_init_inmem_curseg(sbi);4755	if (err)4756		goto sync_free_meta;4757 4758	/* f2fs_recover_fsync_data() cleared this already */4759	clear_sbi_flag(sbi, SBI_POR_DOING);4760 4761	if (test_opt(sbi, DISABLE_CHECKPOINT)) {4762		err = f2fs_disable_checkpoint(sbi);4763		if (err)4764			goto sync_free_meta;4765	} else if (is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)) {4766		f2fs_enable_checkpoint(sbi);4767	}4768 4769	/*4770	 * If filesystem is not mounted as read-only then4771	 * do start the gc_thread.4772	 */4773	if ((F2FS_OPTION(sbi).bggc_mode != BGGC_MODE_OFF ||4774		test_opt(sbi, GC_MERGE)) && !f2fs_readonly(sb)) {4775		/* After POR, we can run background GC thread.*/4776		err = f2fs_start_gc_thread(sbi);4777		if (err)4778			goto sync_free_meta;4779	}4780	kvfree(options);4781 4782	/* recover broken superblock */4783	if (recovery) {4784		err = f2fs_commit_super(sbi, true);4785		f2fs_info(sbi, "Try to recover %dth superblock, ret: %d",4786			  sbi->valid_super_block ? 1 : 2, err);4787	}4788 4789	f2fs_join_shrinker(sbi);4790 4791	f2fs_tuning_parameters(sbi);4792 4793	f2fs_notice(sbi, "Mounted with checkpoint version = %llx",4794		    cur_cp_version(F2FS_CKPT(sbi)));4795	f2fs_update_time(sbi, CP_TIME);4796	f2fs_update_time(sbi, REQ_TIME);4797	clear_sbi_flag(sbi, SBI_CP_DISABLED_QUICK);4798	return 0;4799 4800sync_free_meta:4801	/* safe to flush all the data */4802	sync_filesystem(sbi->sb);4803	retry_cnt = 0;4804 4805free_meta:4806#ifdef CONFIG_QUOTA4807	f2fs_truncate_quota_inode_pages(sb);4808	if (f2fs_sb_has_quota_ino(sbi) && !f2fs_readonly(sb))4809		f2fs_quota_off_umount(sbi->sb);4810#endif4811	/*4812	 * Some dirty meta pages can be produced by f2fs_recover_orphan_inodes()4813	 * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg()4814	 * followed by f2fs_write_checkpoint() through f2fs_write_node_pages(), which4815	 * falls into an infinite loop in f2fs_sync_meta_pages().4816	 */4817	truncate_inode_pages_final(META_MAPPING(sbi));4818	/* evict some inodes being cached by GC */4819	evict_inodes(sb);4820	f2fs_unregister_sysfs(sbi);4821free_compress_inode:4822	f2fs_destroy_compress_inode(sbi);4823free_root_inode:4824	dput(sb->s_root);4825	sb->s_root = NULL;4826free_node_inode:4827	f2fs_release_ino_entry(sbi, true);4828	truncate_inode_pages_final(NODE_MAPPING(sbi));4829	iput(sbi->node_inode);4830	sbi->node_inode = NULL;4831free_stats:4832	f2fs_destroy_stats(sbi);4833free_nm:4834	/* stop discard thread before destroying node manager */4835	f2fs_stop_discard_thread(sbi);4836	f2fs_destroy_node_manager(sbi);4837free_sm:4838	f2fs_destroy_segment_manager(sbi);4839stop_ckpt_thread:4840	f2fs_stop_ckpt_thread(sbi);4841	/* flush s_error_work before sbi destroy */4842	flush_work(&sbi->s_error_work);4843	f2fs_destroy_post_read_wq(sbi);4844free_devices:4845	destroy_device_list(sbi);4846	kvfree(sbi->ckpt);4847free_meta_inode:4848	make_bad_inode(sbi->meta_inode);4849	iput(sbi->meta_inode);4850	sbi->meta_inode = NULL;4851free_page_array_cache:4852	f2fs_destroy_page_array_cache(sbi);4853free_xattr_cache:4854	f2fs_destroy_xattr_caches(sbi);4855free_percpu:4856	destroy_percpu_info(sbi);4857free_iostat:4858	f2fs_destroy_iostat(sbi);4859free_bio_info:4860	for (i = 0; i < NR_PAGE_TYPE; i++)4861		kvfree(sbi->write_io[i]);4862 4863#if IS_ENABLED(CONFIG_UNICODE)4864	utf8_unload(sb->s_encoding);4865	sb->s_encoding = NULL;4866#endif4867free_options:4868#ifdef CONFIG_QUOTA4869	for (i = 0; i < MAXQUOTAS; i++)4870		kfree(F2FS_OPTION(sbi).s_qf_names[i]);4871#endif4872	fscrypt_free_dummy_policy(&F2FS_OPTION(sbi).dummy_enc_policy);4873	kvfree(options);4874free_sb_buf:4875	kfree(raw_super);4876free_sbi:4877	if (sbi->s_chksum_driver)4878		crypto_free_shash(sbi->s_chksum_driver);4879	kfree(sbi);4880	sb->s_fs_info = NULL;4881 4882	/* give only one another chance */4883	if (retry_cnt > 0 && skip_recovery) {4884		retry_cnt--;4885		shrink_dcache_sb(sb);4886		goto try_onemore;4887	}4888	return err;4889}4890 4891static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,4892			const char *dev_name, void *data)4893{4894	return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);4895}4896 4897static void kill_f2fs_super(struct super_block *sb)4898{4899	struct f2fs_sb_info *sbi = F2FS_SB(sb);4900 4901	if (sb->s_root) {4902		set_sbi_flag(sbi, SBI_IS_CLOSE);4903		f2fs_stop_gc_thread(sbi);4904		f2fs_stop_discard_thread(sbi);4905 4906#ifdef CONFIG_F2FS_FS_COMPRESSION4907		/*4908		 * latter evict_inode() can bypass checking and invalidating4909		 * compress inode cache.4910		 */4911		if (test_opt(sbi, COMPRESS_CACHE))4912			truncate_inode_pages_final(COMPRESS_MAPPING(sbi));4913#endif4914 4915		if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||4916				!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {4917			struct cp_control cpc = {4918				.reason = CP_UMOUNT,4919			};4920			stat_inc_cp_call_count(sbi, TOTAL_CALL);4921			f2fs_write_checkpoint(sbi, &cpc);4922		}4923 4924		if (is_sbi_flag_set(sbi, SBI_IS_RECOVERED) && f2fs_readonly(sb))4925			sb->s_flags &= ~SB_RDONLY;4926	}4927	kill_block_super(sb);4928	/* Release block devices last, after fscrypt_destroy_keyring(). */4929	if (sbi) {4930		destroy_device_list(sbi);4931		kfree(sbi);4932		sb->s_fs_info = NULL;4933	}4934}4935 4936static struct file_system_type f2fs_fs_type = {4937	.owner		= THIS_MODULE,4938	.name		= "f2fs",4939	.mount		= f2fs_mount,4940	.kill_sb	= kill_f2fs_super,4941	.fs_flags	= FS_REQUIRES_DEV | FS_ALLOW_IDMAP,4942};4943MODULE_ALIAS_FS("f2fs");4944 4945static int __init init_inodecache(void)4946{4947	f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache",4948			sizeof(struct f2fs_inode_info), 0,4949			SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL);4950	return f2fs_inode_cachep ? 0 : -ENOMEM;4951}4952 4953static void destroy_inodecache(void)4954{4955	/*4956	 * Make sure all delayed rcu free inodes are flushed before we4957	 * destroy cache.4958	 */4959	rcu_barrier();4960	kmem_cache_destroy(f2fs_inode_cachep);4961}4962 4963static int __init init_f2fs_fs(void)4964{4965	int err;4966 4967	err = init_inodecache();4968	if (err)4969		goto fail;4970	err = f2fs_create_node_manager_caches();4971	if (err)4972		goto free_inodecache;4973	err = f2fs_create_segment_manager_caches();4974	if (err)4975		goto free_node_manager_caches;4976	err = f2fs_create_checkpoint_caches();4977	if (err)4978		goto free_segment_manager_caches;4979	err = f2fs_create_recovery_cache();4980	if (err)4981		goto free_checkpoint_caches;4982	err = f2fs_create_extent_cache();4983	if (err)4984		goto free_recovery_cache;4985	err = f2fs_create_garbage_collection_cache();4986	if (err)4987		goto free_extent_cache;4988	err = f2fs_init_sysfs();4989	if (err)4990		goto free_garbage_collection_cache;4991	err = f2fs_init_shrinker();4992	if (err)4993		goto free_sysfs;4994	err = register_filesystem(&f2fs_fs_type);4995	if (err)4996		goto free_shrinker;4997	f2fs_create_root_stats();4998	err = f2fs_init_post_read_processing();4999	if (err)5000		goto free_root_stats;5001	err = f2fs_init_iostat_processing();5002	if (err)5003		goto free_post_read;5004	err = f2fs_init_bio_entry_cache();5005	if (err)5006		goto free_iostat;5007	err = f2fs_init_bioset();5008	if (err)5009		goto free_bio_entry_cache;5010	err = f2fs_init_compress_mempool();5011	if (err)5012		goto free_bioset;5013	err = f2fs_init_compress_cache();5014	if (err)5015		goto free_compress_mempool;5016	err = f2fs_create_casefold_cache();5017	if (err)5018		goto free_compress_cache;5019	return 0;5020free_compress_cache:5021	f2fs_destroy_compress_cache();5022free_compress_mempool:5023	f2fs_destroy_compress_mempool();5024free_bioset:5025	f2fs_destroy_bioset();5026free_bio_entry_cache:5027	f2fs_destroy_bio_entry_cache();5028free_iostat:5029	f2fs_destroy_iostat_processing();5030free_post_read:5031	f2fs_destroy_post_read_processing();5032free_root_stats:5033	f2fs_destroy_root_stats();5034	unregister_filesystem(&f2fs_fs_type);5035free_shrinker:5036	f2fs_exit_shrinker();5037free_sysfs:5038	f2fs_exit_sysfs();5039free_garbage_collection_cache:5040	f2fs_destroy_garbage_collection_cache();5041free_extent_cache:5042	f2fs_destroy_extent_cache();5043free_recovery_cache:5044	f2fs_destroy_recovery_cache();5045free_checkpoint_caches:5046	f2fs_destroy_checkpoint_caches();5047free_segment_manager_caches:5048	f2fs_destroy_segment_manager_caches();5049free_node_manager_caches:5050	f2fs_destroy_node_manager_caches();5051free_inodecache:5052	destroy_inodecache();5053fail:5054	return err;5055}5056 5057static void __exit exit_f2fs_fs(void)5058{5059	f2fs_destroy_casefold_cache();5060	f2fs_destroy_compress_cache();5061	f2fs_destroy_compress_mempool();5062	f2fs_destroy_bioset();5063	f2fs_destroy_bio_entry_cache();5064	f2fs_destroy_iostat_processing();5065	f2fs_destroy_post_read_processing();5066	f2fs_destroy_root_stats();5067	unregister_filesystem(&f2fs_fs_type);5068	f2fs_exit_shrinker();5069	f2fs_exit_sysfs();5070	f2fs_destroy_garbage_collection_cache();5071	f2fs_destroy_extent_cache();5072	f2fs_destroy_recovery_cache();5073	f2fs_destroy_checkpoint_caches();5074	f2fs_destroy_segment_manager_caches();5075	f2fs_destroy_node_manager_caches();5076	destroy_inodecache();5077}5078 5079module_init(init_f2fs_fs)5080module_exit(exit_f2fs_fs)5081 5082MODULE_AUTHOR("Samsung Electronics's Praesto Team");5083MODULE_DESCRIPTION("Flash Friendly File System");5084MODULE_LICENSE("GPL");5085MODULE_SOFTDEP("pre: crc32");5086 5087