Linux Audio

Check our new training course

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