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