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