super.c 74.0 KB
Newer Older
J
Jaegeuk Kim 已提交
1
/*
J
Jaegeuk Kim 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 * fs/f2fs/super.c
 *
 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
 *             http://www.samsung.com/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/statfs.h>
#include <linux/buffer_head.h>
#include <linux/backing-dev.h>
#include <linux/kthread.h>
#include <linux/parser.h>
#include <linux/mount.h>
#include <linux/seq_file.h>
21
#include <linux/proc_fs.h>
J
Jaegeuk Kim 已提交
22 23
#include <linux/random.h>
#include <linux/exportfs.h>
24
#include <linux/blkdev.h>
C
Chao Yu 已提交
25
#include <linux/quotaops.h>
J
Jaegeuk Kim 已提交
26
#include <linux/f2fs_fs.h>
27
#include <linux/sysfs.h>
C
Chao Yu 已提交
28
#include <linux/quota.h>
J
Jaegeuk Kim 已提交
29 30 31

#include "f2fs.h"
#include "node.h"
32
#include "segment.h"
J
Jaegeuk Kim 已提交
33
#include "xattr.h"
34
#include "gc.h"
J
Jaegeuk Kim 已提交
35
#include "trace.h"
J
Jaegeuk Kim 已提交
36

37 38 39
#define CREATE_TRACE_POINTS
#include <trace/events/f2fs.h>

J
Jaegeuk Kim 已提交
40 41
static struct kmem_cache *f2fs_inode_cachep;

42
#ifdef CONFIG_F2FS_FAULT_INJECTION
J
Jaegeuk Kim 已提交
43 44 45

char *fault_name[FAULT_MAX] = {
	[FAULT_KMALLOC]		= "kmalloc",
C
Chao Yu 已提交
46
	[FAULT_KVMALLOC]	= "kvmalloc",
47
	[FAULT_PAGE_ALLOC]	= "page alloc",
C
Chao Yu 已提交
48
	[FAULT_PAGE_GET]	= "page get",
49
	[FAULT_ALLOC_BIO]	= "alloc bio",
J
Jaegeuk Kim 已提交
50 51 52 53
	[FAULT_ALLOC_NID]	= "alloc nid",
	[FAULT_ORPHAN]		= "orphan",
	[FAULT_BLOCK]		= "no more block",
	[FAULT_DIR_DEPTH]	= "too big dir depth",
54
	[FAULT_EVICT_INODE]	= "evict_inode fail",
55
	[FAULT_TRUNCATE]	= "truncate fail",
C
Chao Yu 已提交
56
	[FAULT_IO]		= "IO error",
57
	[FAULT_CHECKPOINT]	= "checkpoint error",
J
Jaegeuk Kim 已提交
58
};
S
Sheng Yong 已提交
59

60 61
static void f2fs_build_fault_attr(struct f2fs_sb_info *sbi,
						unsigned int rate)
S
Sheng Yong 已提交
62
{
63 64
	struct f2fs_fault_info *ffi = &sbi->fault_info;

S
Sheng Yong 已提交
65
	if (rate) {
66 67 68
		atomic_set(&ffi->inject_ops, 0);
		ffi->inject_rate = rate;
		ffi->inject_type = (1 << FAULT_MAX) - 1;
S
Sheng Yong 已提交
69
	} else {
70
		memset(ffi, 0, sizeof(struct f2fs_fault_info));
S
Sheng Yong 已提交
71 72
	}
}
73 74
#endif

75 76 77 78 79 80 81
/* f2fs-wide shrinker description */
static struct shrinker f2fs_shrinker_info = {
	.scan_objects = f2fs_shrink_scan,
	.count_objects = f2fs_shrink_count,
	.seeks = DEFAULT_SEEKS,
};

J
Jaegeuk Kim 已提交
82
enum {
83
	Opt_gc_background,
J
Jaegeuk Kim 已提交
84
	Opt_disable_roll_forward,
85
	Opt_norecovery,
J
Jaegeuk Kim 已提交
86
	Opt_discard,
C
Chao Yu 已提交
87
	Opt_nodiscard,
J
Jaegeuk Kim 已提交
88
	Opt_noheap,
89
	Opt_heap,
90
	Opt_user_xattr,
J
Jaegeuk Kim 已提交
91
	Opt_nouser_xattr,
92
	Opt_acl,
J
Jaegeuk Kim 已提交
93 94 95
	Opt_noacl,
	Opt_active_logs,
	Opt_disable_ext_identify,
J
Jaegeuk Kim 已提交
96
	Opt_inline_xattr,
97
	Opt_noinline_xattr,
C
Chao Yu 已提交
98
	Opt_inline_xattr_size,
99
	Opt_inline_data,
100
	Opt_inline_dentry,
101
	Opt_noinline_dentry,
102
	Opt_flush_merge,
J
Jaegeuk Kim 已提交
103
	Opt_noflush_merge,
J
Jaegeuk Kim 已提交
104
	Opt_nobarrier,
105
	Opt_fastboot,
106
	Opt_extent_cache,
107
	Opt_noextent_cache,
W
Wanpeng Li 已提交
108
	Opt_noinline_data,
109
	Opt_data_flush,
110
	Opt_reserve_root,
111 112
	Opt_resgid,
	Opt_resuid,
113
	Opt_mode,
114
	Opt_io_size_bits,
115
	Opt_fault_injection,
J
Jaegeuk Kim 已提交
116 117
	Opt_lazytime,
	Opt_nolazytime,
C
Chao Yu 已提交
118 119
	Opt_quota,
	Opt_noquota,
C
Chao Yu 已提交
120 121
	Opt_usrquota,
	Opt_grpquota,
C
Chao Yu 已提交
122
	Opt_prjquota,
C
Chao Yu 已提交
123 124 125 126 127 128 129 130 131
	Opt_usrjquota,
	Opt_grpjquota,
	Opt_prjjquota,
	Opt_offusrjquota,
	Opt_offgrpjquota,
	Opt_offprjjquota,
	Opt_jqfmt_vfsold,
	Opt_jqfmt_vfsv0,
	Opt_jqfmt_vfsv1,
J
Jaegeuk Kim 已提交
132 133 134 135
	Opt_err,
};

static match_table_t f2fs_tokens = {
136
	{Opt_gc_background, "background_gc=%s"},
J
Jaegeuk Kim 已提交
137
	{Opt_disable_roll_forward, "disable_roll_forward"},
138
	{Opt_norecovery, "norecovery"},
J
Jaegeuk Kim 已提交
139
	{Opt_discard, "discard"},
C
Chao Yu 已提交
140
	{Opt_nodiscard, "nodiscard"},
J
Jaegeuk Kim 已提交
141
	{Opt_noheap, "no_heap"},
142
	{Opt_heap, "heap"},
143
	{Opt_user_xattr, "user_xattr"},
J
Jaegeuk Kim 已提交
144
	{Opt_nouser_xattr, "nouser_xattr"},
145
	{Opt_acl, "acl"},
J
Jaegeuk Kim 已提交
146 147 148
	{Opt_noacl, "noacl"},
	{Opt_active_logs, "active_logs=%u"},
	{Opt_disable_ext_identify, "disable_ext_identify"},
J
Jaegeuk Kim 已提交
149
	{Opt_inline_xattr, "inline_xattr"},
150
	{Opt_noinline_xattr, "noinline_xattr"},
C
Chao Yu 已提交
151
	{Opt_inline_xattr_size, "inline_xattr_size=%u"},
152
	{Opt_inline_data, "inline_data"},
153
	{Opt_inline_dentry, "inline_dentry"},
154
	{Opt_noinline_dentry, "noinline_dentry"},
155
	{Opt_flush_merge, "flush_merge"},
J
Jaegeuk Kim 已提交
156
	{Opt_noflush_merge, "noflush_merge"},
J
Jaegeuk Kim 已提交
157
	{Opt_nobarrier, "nobarrier"},
158
	{Opt_fastboot, "fastboot"},
159
	{Opt_extent_cache, "extent_cache"},
160
	{Opt_noextent_cache, "noextent_cache"},
W
Wanpeng Li 已提交
161
	{Opt_noinline_data, "noinline_data"},
162
	{Opt_data_flush, "data_flush"},
163
	{Opt_reserve_root, "reserve_root=%u"},
164 165
	{Opt_resgid, "resgid=%u"},
	{Opt_resuid, "resuid=%u"},
166
	{Opt_mode, "mode=%s"},
167
	{Opt_io_size_bits, "io_bits=%u"},
168
	{Opt_fault_injection, "fault_injection=%u"},
J
Jaegeuk Kim 已提交
169 170
	{Opt_lazytime, "lazytime"},
	{Opt_nolazytime, "nolazytime"},
C
Chao Yu 已提交
171 172
	{Opt_quota, "quota"},
	{Opt_noquota, "noquota"},
C
Chao Yu 已提交
173 174
	{Opt_usrquota, "usrquota"},
	{Opt_grpquota, "grpquota"},
C
Chao Yu 已提交
175
	{Opt_prjquota, "prjquota"},
C
Chao Yu 已提交
176 177 178 179 180 181 182 183 184
	{Opt_usrjquota, "usrjquota=%s"},
	{Opt_grpjquota, "grpjquota=%s"},
	{Opt_prjjquota, "prjjquota=%s"},
	{Opt_offusrjquota, "usrjquota="},
	{Opt_offgrpjquota, "grpjquota="},
	{Opt_offprjjquota, "prjjquota="},
	{Opt_jqfmt_vfsold, "jqfmt=vfsold"},
	{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
	{Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
J
Jaegeuk Kim 已提交
185 186 187
	{Opt_err, NULL},
};

188 189 190 191 192 193 194 195
void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...)
{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);
	vaf.fmt = fmt;
	vaf.va = &args;
196
	printk_ratelimited("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf);
197 198 199
	va_end(args);
}

200 201 202 203 204 205 206 207 208 209 210
static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
{
	block_t limit = (sbi->user_block_count << 1) / 1000;

	/* limit is 0.2% */
	if (test_opt(sbi, RESERVE_ROOT) && sbi->root_reserved_blocks > limit) {
		sbi->root_reserved_blocks = limit;
		f2fs_msg(sbi->sb, KERN_INFO,
			"Reduce reserved blocks for root = %u",
				sbi->root_reserved_blocks);
	}
211 212 213 214 215 216 217 218 219
	if (!test_opt(sbi, RESERVE_ROOT) &&
		(!uid_eq(sbi->s_resuid,
				make_kuid(&init_user_ns, F2FS_DEF_RESUID)) ||
		!gid_eq(sbi->s_resgid,
				make_kgid(&init_user_ns, F2FS_DEF_RESGID))))
		f2fs_msg(sbi->sb, KERN_INFO,
			"Ignore s_resuid=%u, s_resgid=%u w/o reserve_root",
				from_kuid_munged(&init_user_ns, sbi->s_resuid),
				from_kgid_munged(&init_user_ns, sbi->s_resgid));
220 221
}

J
Jaegeuk Kim 已提交
222 223 224 225 226 227 228
static void init_once(void *foo)
{
	struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;

	inode_init_once(&fi->vfs_inode);
}

C
Chao Yu 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
#ifdef CONFIG_QUOTA
static const char * const quotatypes[] = INITQFNAMES;
#define QTYPE2NAME(t) (quotatypes[t])
static int f2fs_set_qf_name(struct super_block *sb, int qtype,
							substring_t *args)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
	char *qname;
	int ret = -EINVAL;

	if (sb_any_quota_loaded(sb) && !sbi->s_qf_names[qtype]) {
		f2fs_msg(sb, KERN_ERR,
			"Cannot change journaled "
			"quota options when quota turned on");
		return -EINVAL;
	}
J
Jaegeuk Kim 已提交
245 246 247 248 249 250
	if (f2fs_sb_has_quota_ino(sb)) {
		f2fs_msg(sb, KERN_INFO,
			"QUOTA feature is enabled, so ignore qf_name");
		return 0;
	}

C
Chao Yu 已提交
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
	qname = match_strdup(args);
	if (!qname) {
		f2fs_msg(sb, KERN_ERR,
			"Not enough memory for storing quotafile name");
		return -EINVAL;
	}
	if (sbi->s_qf_names[qtype]) {
		if (strcmp(sbi->s_qf_names[qtype], qname) == 0)
			ret = 0;
		else
			f2fs_msg(sb, KERN_ERR,
				 "%s quota file already specified",
				 QTYPE2NAME(qtype));
		goto errout;
	}
	if (strchr(qname, '/')) {
		f2fs_msg(sb, KERN_ERR,
			"quotafile must be on filesystem root");
		goto errout;
	}
	sbi->s_qf_names[qtype] = qname;
	set_opt(sbi, QUOTA);
	return 0;
errout:
	kfree(qname);
	return ret;
}

static int f2fs_clear_qf_name(struct super_block *sb, int qtype)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);

	if (sb_any_quota_loaded(sb) && sbi->s_qf_names[qtype]) {
		f2fs_msg(sb, KERN_ERR, "Cannot change journaled quota options"
			" when quota turned on");
		return -EINVAL;
	}
	kfree(sbi->s_qf_names[qtype]);
	sbi->s_qf_names[qtype] = NULL;
	return 0;
}

static int f2fs_check_quota_options(struct f2fs_sb_info *sbi)
{
	/*
	 * We do the test below only for project quotas. 'usrquota' and
	 * 'grpquota' mount options are allowed even without quota feature
	 * to support legacy quotas in quota files.
	 */
	if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi->sb)) {
		f2fs_msg(sbi->sb, KERN_ERR, "Project quota feature not enabled. "
			 "Cannot enable project quota enforcement.");
		return -1;
	}
	if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA] ||
			sbi->s_qf_names[PRJQUOTA]) {
		if (test_opt(sbi, USRQUOTA) && sbi->s_qf_names[USRQUOTA])
			clear_opt(sbi, USRQUOTA);

		if (test_opt(sbi, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA])
			clear_opt(sbi, GRPQUOTA);

		if (test_opt(sbi, PRJQUOTA) && sbi->s_qf_names[PRJQUOTA])
			clear_opt(sbi, PRJQUOTA);

		if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) ||
				test_opt(sbi, PRJQUOTA)) {
			f2fs_msg(sbi->sb, KERN_ERR, "old and new quota "
					"format mixing");
			return -1;
		}

		if (!sbi->s_jquota_fmt) {
			f2fs_msg(sbi->sb, KERN_ERR, "journaled quota format "
					"not specified");
			return -1;
		}
	}
J
Jaegeuk Kim 已提交
329 330 331 332 333 334 335 336 337 338 339 340

	if (f2fs_sb_has_quota_ino(sbi->sb) && sbi->s_jquota_fmt) {
		f2fs_msg(sbi->sb, KERN_INFO,
			"QUOTA feature is enabled, so ignore jquota_fmt");
		sbi->s_jquota_fmt = 0;
	}
	if (f2fs_sb_has_quota_ino(sbi->sb) && sb_rdonly(sbi->sb)) {
		f2fs_msg(sbi->sb, KERN_INFO,
			 "Filesystem with quota feature cannot be mounted RDWR "
			 "without CONFIG_QUOTA");
		return -1;
	}
C
Chao Yu 已提交
341 342 343 344
	return 0;
}
#endif

345 346 347
static int parse_options(struct super_block *sb, char *options)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
348
	struct request_queue *q;
349 350 351
	substring_t args[MAX_OPT_ARGS];
	char *p, *name;
	int arg = 0;
352 353
	kuid_t uid;
	kgid_t gid;
C
Chao Yu 已提交
354 355 356
#ifdef CONFIG_QUOTA
	int ret;
#endif
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377

	if (!options)
		return 0;

	while ((p = strsep(&options, ",")) != NULL) {
		int token;
		if (!*p)
			continue;
		/*
		 * Initialize args struct so we know whether arg was
		 * found; some options take optional arguments.
		 */
		args[0].to = args[0].from = NULL;
		token = match_token(p, f2fs_tokens, args);

		switch (token) {
		case Opt_gc_background:
			name = match_strdup(&args[0]);

			if (!name)
				return -ENOMEM;
378
			if (strlen(name) == 2 && !strncmp(name, "on", 2)) {
379
				set_opt(sbi, BG_GC);
380 381
				clear_opt(sbi, FORCE_FG_GC);
			} else if (strlen(name) == 3 && !strncmp(name, "off", 3)) {
382
				clear_opt(sbi, BG_GC);
383 384 385 386 387
				clear_opt(sbi, FORCE_FG_GC);
			} else if (strlen(name) == 4 && !strncmp(name, "sync", 4)) {
				set_opt(sbi, BG_GC);
				set_opt(sbi, FORCE_FG_GC);
			} else {
388 389 390 391 392 393 394 395
				kfree(name);
				return -EINVAL;
			}
			kfree(name);
			break;
		case Opt_disable_roll_forward:
			set_opt(sbi, DISABLE_ROLL_FORWARD);
			break;
396 397 398 399 400 401
		case Opt_norecovery:
			/* this option mounts f2fs with ro */
			set_opt(sbi, DISABLE_ROLL_FORWARD);
			if (!f2fs_readonly(sb))
				return -EINVAL;
			break;
402
		case Opt_discard:
403 404 405
			q = bdev_get_queue(sb->s_bdev);
			if (blk_queue_discard(q)) {
				set_opt(sbi, DISCARD);
406
			} else if (!f2fs_sb_mounted_blkzoned(sb)) {
407 408 409 410
				f2fs_msg(sb, KERN_WARNING,
					"mounting with \"discard\" option, but "
					"the device does not support discard");
			}
411
			break;
C
Chao Yu 已提交
412
		case Opt_nodiscard:
413 414 415 416 417
			if (f2fs_sb_mounted_blkzoned(sb)) {
				f2fs_msg(sb, KERN_WARNING,
					"discard is required for zoned block devices");
				return -EINVAL;
			}
C
Chao Yu 已提交
418
			clear_opt(sbi, DISCARD);
419
			break;
420 421 422
		case Opt_noheap:
			set_opt(sbi, NOHEAP);
			break;
423 424 425
		case Opt_heap:
			clear_opt(sbi, NOHEAP);
			break;
426
#ifdef CONFIG_F2FS_FS_XATTR
427 428 429
		case Opt_user_xattr:
			set_opt(sbi, XATTR_USER);
			break;
430 431 432
		case Opt_nouser_xattr:
			clear_opt(sbi, XATTR_USER);
			break;
J
Jaegeuk Kim 已提交
433 434 435
		case Opt_inline_xattr:
			set_opt(sbi, INLINE_XATTR);
			break;
436 437 438
		case Opt_noinline_xattr:
			clear_opt(sbi, INLINE_XATTR);
			break;
C
Chao Yu 已提交
439 440 441 442 443 444
		case Opt_inline_xattr_size:
			if (args->from && match_int(args, &arg))
				return -EINVAL;
			set_opt(sbi, INLINE_XATTR_SIZE);
			sbi->inline_xattr_size = arg;
			break;
445
#else
446 447 448 449
		case Opt_user_xattr:
			f2fs_msg(sb, KERN_INFO,
				"user_xattr options not supported");
			break;
450 451 452 453
		case Opt_nouser_xattr:
			f2fs_msg(sb, KERN_INFO,
				"nouser_xattr options not supported");
			break;
J
Jaegeuk Kim 已提交
454 455 456 457
		case Opt_inline_xattr:
			f2fs_msg(sb, KERN_INFO,
				"inline_xattr options not supported");
			break;
458 459 460 461
		case Opt_noinline_xattr:
			f2fs_msg(sb, KERN_INFO,
				"noinline_xattr options not supported");
			break;
462 463
#endif
#ifdef CONFIG_F2FS_FS_POSIX_ACL
464 465 466
		case Opt_acl:
			set_opt(sbi, POSIX_ACL);
			break;
467 468 469 470
		case Opt_noacl:
			clear_opt(sbi, POSIX_ACL);
			break;
#else
471 472 473
		case Opt_acl:
			f2fs_msg(sb, KERN_INFO, "acl options not supported");
			break;
474 475 476 477 478 479 480 481 482 483 484 485 486 487
		case Opt_noacl:
			f2fs_msg(sb, KERN_INFO, "noacl options not supported");
			break;
#endif
		case Opt_active_logs:
			if (args->from && match_int(args, &arg))
				return -EINVAL;
			if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE)
				return -EINVAL;
			sbi->active_logs = arg;
			break;
		case Opt_disable_ext_identify:
			set_opt(sbi, DISABLE_EXT_IDENTIFY);
			break;
488 489 490
		case Opt_inline_data:
			set_opt(sbi, INLINE_DATA);
			break;
491 492 493
		case Opt_inline_dentry:
			set_opt(sbi, INLINE_DENTRY);
			break;
494 495 496
		case Opt_noinline_dentry:
			clear_opt(sbi, INLINE_DENTRY);
			break;
497 498 499
		case Opt_flush_merge:
			set_opt(sbi, FLUSH_MERGE);
			break;
J
Jaegeuk Kim 已提交
500 501 502
		case Opt_noflush_merge:
			clear_opt(sbi, FLUSH_MERGE);
			break;
J
Jaegeuk Kim 已提交
503 504 505
		case Opt_nobarrier:
			set_opt(sbi, NOBARRIER);
			break;
506 507 508
		case Opt_fastboot:
			set_opt(sbi, FASTBOOT);
			break;
509 510 511
		case Opt_extent_cache:
			set_opt(sbi, EXTENT_CACHE);
			break;
512 513 514
		case Opt_noextent_cache:
			clear_opt(sbi, EXTENT_CACHE);
			break;
W
Wanpeng Li 已提交
515 516 517
		case Opt_noinline_data:
			clear_opt(sbi, INLINE_DATA);
			break;
518 519 520
		case Opt_data_flush:
			set_opt(sbi, DATA_FLUSH);
			break;
521 522 523 524 525 526 527 528 529 530 531 532
		case Opt_reserve_root:
			if (args->from && match_int(args, &arg))
				return -EINVAL;
			if (test_opt(sbi, RESERVE_ROOT)) {
				f2fs_msg(sb, KERN_INFO,
					"Preserve previous reserve_root=%u",
					sbi->root_reserved_blocks);
			} else {
				sbi->root_reserved_blocks = arg;
				set_opt(sbi, RESERVE_ROOT);
			}
			break;
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
		case Opt_resuid:
			if (args->from && match_int(args, &arg))
				return -EINVAL;
			uid = make_kuid(current_user_ns(), arg);
			if (!uid_valid(uid)) {
				f2fs_msg(sb, KERN_ERR,
					"Invalid uid value %d", arg);
				return -EINVAL;
			}
			sbi->s_resuid = uid;
			break;
		case Opt_resgid:
			if (args->from && match_int(args, &arg))
				return -EINVAL;
			gid = make_kgid(current_user_ns(), arg);
			if (!gid_valid(gid)) {
				f2fs_msg(sb, KERN_ERR,
					"Invalid gid value %d", arg);
				return -EINVAL;
			}
			sbi->s_resgid = gid;
			break;
555 556 557 558 559 560 561
		case Opt_mode:
			name = match_strdup(&args[0]);

			if (!name)
				return -ENOMEM;
			if (strlen(name) == 8 &&
					!strncmp(name, "adaptive", 8)) {
562 563 564 565 566 567 568
				if (f2fs_sb_mounted_blkzoned(sb)) {
					f2fs_msg(sb, KERN_WARNING,
						 "adaptive mode is not allowed with "
						 "zoned block device feature");
					kfree(name);
					return -EINVAL;
				}
569
				set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE);
570 571
			} else if (strlen(name) == 3 &&
					!strncmp(name, "lfs", 3)) {
572
				set_opt_mode(sbi, F2FS_MOUNT_LFS);
573 574 575 576 577 578
			} else {
				kfree(name);
				return -EINVAL;
			}
			kfree(name);
			break;
579 580 581 582 583 584 585 586 587 588 589
		case Opt_io_size_bits:
			if (args->from && match_int(args, &arg))
				return -EINVAL;
			if (arg > __ilog2_u32(BIO_MAX_PAGES)) {
				f2fs_msg(sb, KERN_WARNING,
					"Not support %d, larger than %d",
					1 << arg, BIO_MAX_PAGES);
				return -EINVAL;
			}
			sbi->write_io_size_bits = arg;
			break;
590 591 592 593
		case Opt_fault_injection:
			if (args->from && match_int(args, &arg))
				return -EINVAL;
#ifdef CONFIG_F2FS_FAULT_INJECTION
594
			f2fs_build_fault_attr(sbi, arg);
595
			set_opt(sbi, FAULT_INJECTION);
596 597 598 599 600
#else
			f2fs_msg(sb, KERN_INFO,
				"FAULT_INJECTION was not selected");
#endif
			break;
J
Jaegeuk Kim 已提交
601
		case Opt_lazytime:
602
			sb->s_flags |= SB_LAZYTIME;
J
Jaegeuk Kim 已提交
603 604
			break;
		case Opt_nolazytime:
605
			sb->s_flags &= ~SB_LAZYTIME;
J
Jaegeuk Kim 已提交
606
			break;
C
Chao Yu 已提交
607
#ifdef CONFIG_QUOTA
C
Chao Yu 已提交
608
		case Opt_quota:
C
Chao Yu 已提交
609 610 611 612 613 614
		case Opt_usrquota:
			set_opt(sbi, USRQUOTA);
			break;
		case Opt_grpquota:
			set_opt(sbi, GRPQUOTA);
			break;
C
Chao Yu 已提交
615 616 617
		case Opt_prjquota:
			set_opt(sbi, PRJQUOTA);
			break;
C
Chao Yu 已提交
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
		case Opt_usrjquota:
			ret = f2fs_set_qf_name(sb, USRQUOTA, &args[0]);
			if (ret)
				return ret;
			break;
		case Opt_grpjquota:
			ret = f2fs_set_qf_name(sb, GRPQUOTA, &args[0]);
			if (ret)
				return ret;
			break;
		case Opt_prjjquota:
			ret = f2fs_set_qf_name(sb, PRJQUOTA, &args[0]);
			if (ret)
				return ret;
			break;
		case Opt_offusrjquota:
			ret = f2fs_clear_qf_name(sb, USRQUOTA);
			if (ret)
				return ret;
			break;
		case Opt_offgrpjquota:
			ret = f2fs_clear_qf_name(sb, GRPQUOTA);
			if (ret)
				return ret;
			break;
		case Opt_offprjjquota:
			ret = f2fs_clear_qf_name(sb, PRJQUOTA);
			if (ret)
				return ret;
			break;
		case Opt_jqfmt_vfsold:
			sbi->s_jquota_fmt = QFMT_VFS_OLD;
			break;
		case Opt_jqfmt_vfsv0:
			sbi->s_jquota_fmt = QFMT_VFS_V0;
			break;
		case Opt_jqfmt_vfsv1:
			sbi->s_jquota_fmt = QFMT_VFS_V1;
			break;
		case Opt_noquota:
			clear_opt(sbi, QUOTA);
			clear_opt(sbi, USRQUOTA);
			clear_opt(sbi, GRPQUOTA);
			clear_opt(sbi, PRJQUOTA);
			break;
C
Chao Yu 已提交
663
#else
C
Chao Yu 已提交
664
		case Opt_quota:
C
Chao Yu 已提交
665 666
		case Opt_usrquota:
		case Opt_grpquota:
C
Chao Yu 已提交
667
		case Opt_prjquota:
C
Chao Yu 已提交
668 669 670 671 672 673 674 675 676 677
		case Opt_usrjquota:
		case Opt_grpjquota:
		case Opt_prjjquota:
		case Opt_offusrjquota:
		case Opt_offgrpjquota:
		case Opt_offprjjquota:
		case Opt_jqfmt_vfsold:
		case Opt_jqfmt_vfsv0:
		case Opt_jqfmt_vfsv1:
		case Opt_noquota:
C
Chao Yu 已提交
678 679 680 681
			f2fs_msg(sb, KERN_INFO,
					"quota operations not supported");
			break;
#endif
682 683 684 685 686 687 688
		default:
			f2fs_msg(sb, KERN_ERR,
				"Unrecognized mount option \"%s\" or missing value",
				p);
			return -EINVAL;
		}
	}
C
Chao Yu 已提交
689 690 691 692
#ifdef CONFIG_QUOTA
	if (f2fs_check_quota_options(sbi))
		return -EINVAL;
#endif
693 694 695 696 697 698 699

	if (F2FS_IO_SIZE_BITS(sbi) && !test_opt(sbi, LFS)) {
		f2fs_msg(sb, KERN_ERR,
				"Should set mode=lfs with %uKB-sized IO",
				F2FS_IO_SIZE_KB(sbi));
		return -EINVAL;
	}
C
Chao Yu 已提交
700 701

	if (test_opt(sbi, INLINE_XATTR_SIZE)) {
702 703 704 705 706 707 708
		if (!f2fs_sb_has_extra_attr(sb) ||
			!f2fs_sb_has_flexible_inline_xattr(sb)) {
			f2fs_msg(sb, KERN_ERR,
					"extra_attr or flexible_inline_xattr "
					"feature is off");
			return -EINVAL;
		}
C
Chao Yu 已提交
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
		if (!test_opt(sbi, INLINE_XATTR)) {
			f2fs_msg(sb, KERN_ERR,
					"inline_xattr_size option should be "
					"set with inline_xattr option");
			return -EINVAL;
		}
		if (!sbi->inline_xattr_size ||
			sbi->inline_xattr_size >= DEF_ADDRS_PER_INODE -
					F2FS_TOTAL_EXTRA_ATTR_SIZE -
					DEF_INLINE_RESERVED_SIZE -
					DEF_MIN_INLINE_SIZE) {
			f2fs_msg(sb, KERN_ERR,
					"inline xattr size is out of range");
			return -EINVAL;
		}
	}
725 726 727
	return 0;
}

J
Jaegeuk Kim 已提交
728 729 730 731
static struct inode *f2fs_alloc_inode(struct super_block *sb)
{
	struct f2fs_inode_info *fi;

732
	fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
J
Jaegeuk Kim 已提交
733 734 735 736 737
	if (!fi)
		return NULL;

	init_once((void *) fi);

M
Masanari Iida 已提交
738
	/* Initialize f2fs-specific inode info */
739
	atomic_set(&fi->dirty_pages, 0);
J
Jaegeuk Kim 已提交
740 741
	fi->i_current_depth = 1;
	fi->i_advise = 0;
742
	init_rwsem(&fi->i_sem);
743
	INIT_LIST_HEAD(&fi->dirty_list);
744
	INIT_LIST_HEAD(&fi->gdirty_list);
J
Jaegeuk Kim 已提交
745
	INIT_LIST_HEAD(&fi->inmem_ilist);
J
Jaegeuk Kim 已提交
746 747
	INIT_LIST_HEAD(&fi->inmem_pages);
	mutex_init(&fi->inmem_lock);
748 749
	init_rwsem(&fi->dio_rwsem[READ]);
	init_rwsem(&fi->dio_rwsem[WRITE]);
750
	init_rwsem(&fi->i_mmap_sem);
751
	init_rwsem(&fi->i_xattr_sem);
J
Jaegeuk Kim 已提交
752

C
Chao Yu 已提交
753 754 755 756
#ifdef CONFIG_QUOTA
	memset(&fi->i_dquot, 0, sizeof(fi->i_dquot));
	fi->i_reserved_quota = 0;
#endif
757 758
	/* Will be used by directory only */
	fi->i_dir_level = F2FS_SB(sb)->dir_level;
C
Chao Yu 已提交
759

J
Jaegeuk Kim 已提交
760 761 762
	return &fi->vfs_inode;
}

763 764
static int f2fs_drop_inode(struct inode *inode)
{
765
	int ret;
766 767 768 769 770 771 772
	/*
	 * This is to avoid a deadlock condition like below.
	 * writeback_single_inode(inode)
	 *  - f2fs_write_data_page
	 *    - f2fs_gc -> iput -> evict
	 *       - inode_wait_for_writeback(inode)
	 */
773
	if ((!inode_unhashed(inode) && inode->i_state & I_SYNC)) {
774
		if (!inode->i_nlink && !is_bad_inode(inode)) {
J
Jaegeuk Kim 已提交
775 776
			/* to avoid evict_inode call simultaneously */
			atomic_inc(&inode->i_count);
777 778 779 780
			spin_unlock(&inode->i_lock);

			/* some remained atomic pages should discarded */
			if (f2fs_is_atomic_file(inode))
781
				drop_inmem_pages(inode);
782

J
Jaegeuk Kim 已提交
783 784 785
			/* should remain fi->extent_tree for writepage */
			f2fs_destroy_extent_node(inode);

786
			sb_start_intwrite(inode->i_sb);
787
			f2fs_i_size_write(inode, 0);
788 789

			if (F2FS_HAS_BLOCKS(inode))
790
				f2fs_truncate(inode);
791 792 793 794

			sb_end_intwrite(inode->i_sb);

			spin_lock(&inode->i_lock);
J
Jaegeuk Kim 已提交
795
			atomic_dec(&inode->i_count);
796
		}
797
		trace_f2fs_drop_inode(inode, 0);
798
		return 0;
799
	}
800 801 802
	ret = generic_drop_inode(inode);
	trace_f2fs_drop_inode(inode, ret);
	return ret;
803 804
}

805
int f2fs_inode_dirtied(struct inode *inode, bool sync)
806
{
807
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
808
	int ret = 0;
809 810 811

	spin_lock(&sbi->inode_lock[DIRTY_META]);
	if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
812 813 814 815
		ret = 1;
	} else {
		set_inode_flag(inode, FI_DIRTY_INODE);
		stat_inc_dirty_inode(sbi, DIRTY_META);
816
	}
817 818
	if (sync && list_empty(&F2FS_I(inode)->gdirty_list)) {
		list_add_tail(&F2FS_I(inode)->gdirty_list,
819
				&sbi->inode_list[DIRTY_META]);
820 821
		inc_page_count(sbi, F2FS_DIRTY_IMETA);
	}
822
	spin_unlock(&sbi->inode_lock[DIRTY_META]);
823
	return ret;
824 825 826 827 828 829 830 831 832 833 834
}

void f2fs_inode_synced(struct inode *inode)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	spin_lock(&sbi->inode_lock[DIRTY_META]);
	if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) {
		spin_unlock(&sbi->inode_lock[DIRTY_META]);
		return;
	}
835 836 837 838
	if (!list_empty(&F2FS_I(inode)->gdirty_list)) {
		list_del_init(&F2FS_I(inode)->gdirty_list);
		dec_page_count(sbi, F2FS_DIRTY_IMETA);
	}
839
	clear_inode_flag(inode, FI_DIRTY_INODE);
840
	clear_inode_flag(inode, FI_AUTO_RECOVER);
841
	stat_dec_dirty_inode(F2FS_I_SB(inode), DIRTY_META);
842
	spin_unlock(&sbi->inode_lock[DIRTY_META]);
843 844
}

J
Jaegeuk Kim 已提交
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
/*
 * f2fs_dirty_inode() is called from __mark_inode_dirty()
 *
 * We should call set_dirty_inode to write the dirty inode through write_inode.
 */
static void f2fs_dirty_inode(struct inode *inode, int flags)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	if (inode->i_ino == F2FS_NODE_INO(sbi) ||
			inode->i_ino == F2FS_META_INO(sbi))
		return;

	if (flags == I_DIRTY_TIME)
		return;

	if (is_inode_flag_set(inode, FI_AUTO_RECOVER))
		clear_inode_flag(inode, FI_AUTO_RECOVER);

864
	f2fs_inode_dirtied(inode, false);
J
Jaegeuk Kim 已提交
865 866
}

J
Jaegeuk Kim 已提交
867 868 869 870 871 872
static void f2fs_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
}

873
static void f2fs_destroy_inode(struct inode *inode)
J
Jaegeuk Kim 已提交
874 875 876 877
{
	call_rcu(&inode->i_rcu, f2fs_i_callback);
}

878 879
static void destroy_percpu_info(struct f2fs_sb_info *sbi)
{
880
	percpu_counter_destroy(&sbi->alloc_valid_block_count);
881
	percpu_counter_destroy(&sbi->total_valid_inode_count);
882 883
}

J
Jaegeuk Kim 已提交
884 885 886 887 888 889 890 891 892 893 894 895 896
static void destroy_device_list(struct f2fs_sb_info *sbi)
{
	int i;

	for (i = 0; i < sbi->s_ndevs; i++) {
		blkdev_put(FDEV(i).bdev, FMODE_EXCL);
#ifdef CONFIG_BLK_DEV_ZONED
		kfree(FDEV(i).blkz_type);
#endif
	}
	kfree(sbi->devs);
}

J
Jaegeuk Kim 已提交
897 898 899
static void f2fs_put_super(struct super_block *sb)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
C
Chao Yu 已提交
900
	int i;
901
	bool dropped;
J
Jaegeuk Kim 已提交
902

C
Chao Yu 已提交
903
	f2fs_quota_off_umount(sb);
J
Jaegeuk Kim 已提交
904

905 906 907
	/* prevent remaining shrinker jobs */
	mutex_lock(&sbi->umount_mutex);

908 909 910 911 912
	/*
	 * We don't need to do checkpoint when superblock is clean.
	 * But, the previous checkpoint was not done by umount, it needs to do
	 * clean checkpoint again.
	 */
913
	if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
914
			!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
915 916 917 918 919
		struct cp_control cpc = {
			.reason = CP_UMOUNT,
		};
		write_checkpoint(sbi, &cpc);
	}
J
Jaegeuk Kim 已提交
920

921
	/* be sure to wait for any on-going discard commands */
922
	dropped = f2fs_wait_discard_bios(sbi);
923

924
	if (f2fs_discard_en(sbi) && !sbi->discard_blks && !dropped) {
925 926 927 928 929 930
		struct cp_control cpc = {
			.reason = CP_UMOUNT | CP_TRIMMED,
		};
		write_checkpoint(sbi, &cpc);
	}

J
Jaegeuk Kim 已提交
931 932 933
	/* write_checkpoint can update stat informaion */
	f2fs_destroy_stats(sbi);

934 935 936 937
	/*
	 * normally superblock is clean, so we need to release this.
	 * In addition, EIO will skip do checkpoint, we need this as well.
	 */
938
	release_ino_entry(sbi, true);
939

940 941 942
	f2fs_leave_shrinker(sbi);
	mutex_unlock(&sbi->umount_mutex);

943
	/* our cp_error case, we can wait for any writeback page */
944
	f2fs_flush_merged_writes(sbi);
945

J
Jaegeuk Kim 已提交
946 947 948 949 950 951 952 953
	iput(sbi->node_inode);
	iput(sbi->meta_inode);

	/* destroy f2fs internal modules */
	destroy_node_manager(sbi);
	destroy_segment_manager(sbi);

	kfree(sbi->ckpt);
C
Chao Yu 已提交
954

955
	f2fs_unregister_sysfs(sbi);
J
Jaegeuk Kim 已提交
956 957

	sb->s_fs_info = NULL;
K
Keith Mok 已提交
958 959
	if (sbi->s_chksum_driver)
		crypto_free_shash(sbi->s_chksum_driver);
Y
Yunlei He 已提交
960
	kfree(sbi->raw_super);
961

J
Jaegeuk Kim 已提交
962
	destroy_device_list(sbi);
963
	mempool_destroy(sbi->write_io_dummy);
C
Chao Yu 已提交
964 965 966 967
#ifdef CONFIG_QUOTA
	for (i = 0; i < MAXQUOTAS; i++)
		kfree(sbi->s_qf_names[i]);
#endif
968
	destroy_percpu_info(sbi);
J
Jaegeuk Kim 已提交
969 970
	for (i = 0; i < NR_PAGE_TYPE; i++)
		kfree(sbi->write_io[i]);
J
Jaegeuk Kim 已提交
971 972 973 974 975 976
	kfree(sbi);
}

int f2fs_sync_fs(struct super_block *sb, int sync)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
C
Chao Yu 已提交
977
	int err = 0;
J
Jaegeuk Kim 已提交
978

979 980 981
	if (unlikely(f2fs_cp_error(sbi)))
		return 0;

982 983
	trace_f2fs_sync_fs(sb, sync);

C
Chao Yu 已提交
984 985 986
	if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
		return -EAGAIN;

987
	if (sync) {
988 989
		struct cp_control cpc;

990 991
		cpc.reason = __get_cp_reason(sbi);

992
		mutex_lock(&sbi->gc_mutex);
C
Chao Yu 已提交
993
		err = write_checkpoint(sbi, &cpc);
994 995
		mutex_unlock(&sbi->gc_mutex);
	}
996
	f2fs_trace_ios(NULL, 1);
J
Jaegeuk Kim 已提交
997

C
Chao Yu 已提交
998
	return err;
J
Jaegeuk Kim 已提交
999 1000
}

1001 1002
static int f2fs_freeze(struct super_block *sb)
{
J
Jaegeuk Kim 已提交
1003
	if (f2fs_readonly(sb))
1004 1005
		return 0;

1006 1007 1008 1009 1010 1011 1012 1013
	/* IO error happened before */
	if (unlikely(f2fs_cp_error(F2FS_SB(sb))))
		return -EIO;

	/* must be clean, since sync_filesystem() was already called */
	if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY))
		return -EINVAL;
	return 0;
1014 1015 1016 1017 1018 1019 1020
}

static int f2fs_unfreeze(struct super_block *sb)
{
	return 0;
}

C
Chao Yu 已提交
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
#ifdef CONFIG_QUOTA
static int f2fs_statfs_project(struct super_block *sb,
				kprojid_t projid, struct kstatfs *buf)
{
	struct kqid qid;
	struct dquot *dquot;
	u64 limit;
	u64 curblock;

	qid = make_kqid_projid(projid);
	dquot = dqget(sb, qid);
	if (IS_ERR(dquot))
		return PTR_ERR(dquot);
	spin_lock(&dq_data_lock);

	limit = (dquot->dq_dqb.dqb_bsoftlimit ?
		 dquot->dq_dqb.dqb_bsoftlimit :
		 dquot->dq_dqb.dqb_bhardlimit) >> sb->s_blocksize_bits;
	if (limit && buf->f_blocks > limit) {
		curblock = dquot->dq_dqb.dqb_curspace >> sb->s_blocksize_bits;
		buf->f_blocks = limit;
		buf->f_bfree = buf->f_bavail =
			(buf->f_blocks > curblock) ?
			 (buf->f_blocks - curblock) : 0;
	}

	limit = dquot->dq_dqb.dqb_isoftlimit ?
		dquot->dq_dqb.dqb_isoftlimit :
		dquot->dq_dqb.dqb_ihardlimit;
	if (limit && buf->f_files > limit) {
		buf->f_files = limit;
		buf->f_ffree =
			(buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
			 (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
	}

	spin_unlock(&dq_data_lock);
	dqput(dquot);
	return 0;
}
#endif

J
Jaegeuk Kim 已提交
1063 1064 1065 1066 1067
static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct super_block *sb = dentry->d_sb;
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
1068
	block_t total_count, user_block_count, start_count;
1069
	u64 avail_node_count;
J
Jaegeuk Kim 已提交
1070 1071 1072 1073 1074 1075 1076 1077

	total_count = le64_to_cpu(sbi->raw_super->block_count);
	user_block_count = sbi->user_block_count;
	start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr);
	buf->f_type = F2FS_SUPER_MAGIC;
	buf->f_bsize = sbi->blocksize;

	buf->f_blocks = total_count - start_count;
1078
	buf->f_bfree = user_block_count - valid_user_blocks(sbi) -
1079
						sbi->current_reserved_blocks;
1080 1081 1082 1083
	if (buf->f_bfree > sbi->root_reserved_blocks)
		buf->f_bavail = buf->f_bfree - sbi->root_reserved_blocks;
	else
		buf->f_bavail = 0;
J
Jaegeuk Kim 已提交
1084

1085 1086
	avail_node_count = sbi->total_node_count - sbi->nquota_files -
						F2FS_RESERVED_NODE_NUM;
1087 1088 1089 1090 1091 1092 1093 1094 1095

	if (avail_node_count > user_block_count) {
		buf->f_files = user_block_count;
		buf->f_ffree = buf->f_bavail;
	} else {
		buf->f_files = avail_node_count;
		buf->f_ffree = min(avail_node_count - valid_node_count(sbi),
					buf->f_bavail);
	}
J
Jaegeuk Kim 已提交
1096

1097
	buf->f_namelen = F2FS_NAME_LEN;
J
Jaegeuk Kim 已提交
1098 1099 1100
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);

C
Chao Yu 已提交
1101 1102 1103 1104 1105 1106
#ifdef CONFIG_QUOTA
	if (is_inode_flag_set(dentry->d_inode, FI_PROJ_INHERIT) &&
			sb_has_quota_limits_enabled(sb, PRJQUOTA)) {
		f2fs_statfs_project(sb, F2FS_I(dentry->d_inode)->i_projid, buf);
	}
#endif
J
Jaegeuk Kim 已提交
1107 1108 1109
	return 0;
}

C
Chao Yu 已提交
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
static inline void f2fs_show_quota_options(struct seq_file *seq,
					   struct super_block *sb)
{
#ifdef CONFIG_QUOTA
	struct f2fs_sb_info *sbi = F2FS_SB(sb);

	if (sbi->s_jquota_fmt) {
		char *fmtname = "";

		switch (sbi->s_jquota_fmt) {
		case QFMT_VFS_OLD:
			fmtname = "vfsold";
			break;
		case QFMT_VFS_V0:
			fmtname = "vfsv0";
			break;
		case QFMT_VFS_V1:
			fmtname = "vfsv1";
			break;
		}
		seq_printf(seq, ",jqfmt=%s", fmtname);
	}

	if (sbi->s_qf_names[USRQUOTA])
		seq_show_option(seq, "usrjquota", sbi->s_qf_names[USRQUOTA]);

	if (sbi->s_qf_names[GRPQUOTA])
		seq_show_option(seq, "grpjquota", sbi->s_qf_names[GRPQUOTA]);

	if (sbi->s_qf_names[PRJQUOTA])
		seq_show_option(seq, "prjjquota", sbi->s_qf_names[PRJQUOTA]);
#endif
}

J
Jaegeuk Kim 已提交
1144 1145 1146 1147
static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
{
	struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);

1148 1149 1150 1151 1152 1153
	if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC)) {
		if (test_opt(sbi, FORCE_FG_GC))
			seq_printf(seq, ",background_gc=%s", "sync");
		else
			seq_printf(seq, ",background_gc=%s", "on");
	} else {
1154
		seq_printf(seq, ",background_gc=%s", "off");
1155
	}
J
Jaegeuk Kim 已提交
1156 1157 1158 1159 1160
	if (test_opt(sbi, DISABLE_ROLL_FORWARD))
		seq_puts(seq, ",disable_roll_forward");
	if (test_opt(sbi, DISCARD))
		seq_puts(seq, ",discard");
	if (test_opt(sbi, NOHEAP))
1161 1162 1163
		seq_puts(seq, ",no_heap");
	else
		seq_puts(seq, ",heap");
J
Jaegeuk Kim 已提交
1164 1165 1166 1167 1168
#ifdef CONFIG_F2FS_FS_XATTR
	if (test_opt(sbi, XATTR_USER))
		seq_puts(seq, ",user_xattr");
	else
		seq_puts(seq, ",nouser_xattr");
J
Jaegeuk Kim 已提交
1169 1170
	if (test_opt(sbi, INLINE_XATTR))
		seq_puts(seq, ",inline_xattr");
1171 1172
	else
		seq_puts(seq, ",noinline_xattr");
C
Chao Yu 已提交
1173 1174 1175
	if (test_opt(sbi, INLINE_XATTR_SIZE))
		seq_printf(seq, ",inline_xattr_size=%u",
					sbi->inline_xattr_size);
J
Jaegeuk Kim 已提交
1176 1177 1178 1179 1180 1181 1182 1183
#endif
#ifdef CONFIG_F2FS_FS_POSIX_ACL
	if (test_opt(sbi, POSIX_ACL))
		seq_puts(seq, ",acl");
	else
		seq_puts(seq, ",noacl");
#endif
	if (test_opt(sbi, DISABLE_EXT_IDENTIFY))
1184
		seq_puts(seq, ",disable_ext_identify");
1185 1186
	if (test_opt(sbi, INLINE_DATA))
		seq_puts(seq, ",inline_data");
W
Wanpeng Li 已提交
1187 1188
	else
		seq_puts(seq, ",noinline_data");
1189 1190
	if (test_opt(sbi, INLINE_DENTRY))
		seq_puts(seq, ",inline_dentry");
1191 1192
	else
		seq_puts(seq, ",noinline_dentry");
1193
	if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
1194
		seq_puts(seq, ",flush_merge");
J
Jaegeuk Kim 已提交
1195 1196
	if (test_opt(sbi, NOBARRIER))
		seq_puts(seq, ",nobarrier");
1197 1198
	if (test_opt(sbi, FASTBOOT))
		seq_puts(seq, ",fastboot");
1199 1200
	if (test_opt(sbi, EXTENT_CACHE))
		seq_puts(seq, ",extent_cache");
1201 1202
	else
		seq_puts(seq, ",noextent_cache");
1203 1204
	if (test_opt(sbi, DATA_FLUSH))
		seq_puts(seq, ",data_flush");
1205 1206 1207 1208 1209 1210

	seq_puts(seq, ",mode=");
	if (test_opt(sbi, ADAPTIVE))
		seq_puts(seq, "adaptive");
	else if (test_opt(sbi, LFS))
		seq_puts(seq, "lfs");
J
Jaegeuk Kim 已提交
1211
	seq_printf(seq, ",active_logs=%u", sbi->active_logs);
1212
	if (test_opt(sbi, RESERVE_ROOT))
1213 1214 1215 1216
		seq_printf(seq, ",reserve_root=%u,resuid=%u,resgid=%u",
				sbi->root_reserved_blocks,
				from_kuid_munged(&init_user_ns, sbi->s_resuid),
				from_kgid_munged(&init_user_ns, sbi->s_resgid));
1217 1218
	if (F2FS_IO_SIZE_BITS(sbi))
		seq_printf(seq, ",io_size=%uKB", F2FS_IO_SIZE_KB(sbi));
1219 1220
#ifdef CONFIG_F2FS_FAULT_INJECTION
	if (test_opt(sbi, FAULT_INJECTION))
1221 1222
		seq_printf(seq, ",fault_injection=%u",
				sbi->fault_info.inject_rate);
1223
#endif
C
Chao Yu 已提交
1224
#ifdef CONFIG_QUOTA
C
Chao Yu 已提交
1225 1226
	if (test_opt(sbi, QUOTA))
		seq_puts(seq, ",quota");
C
Chao Yu 已提交
1227 1228 1229 1230
	if (test_opt(sbi, USRQUOTA))
		seq_puts(seq, ",usrquota");
	if (test_opt(sbi, GRPQUOTA))
		seq_puts(seq, ",grpquota");
C
Chao Yu 已提交
1231 1232
	if (test_opt(sbi, PRJQUOTA))
		seq_puts(seq, ",prjquota");
1233
#endif
C
Chao Yu 已提交
1234
	f2fs_show_quota_options(seq, sbi->sb);
J
Jaegeuk Kim 已提交
1235 1236 1237 1238

	return 0;
}

1239 1240 1241 1242
static void default_options(struct f2fs_sb_info *sbi)
{
	/* init some FS parameters */
	sbi->active_logs = NR_CURSEG_TYPE;
C
Chao Yu 已提交
1243
	sbi->inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
1244 1245

	set_opt(sbi, BG_GC);
C
Chao Yu 已提交
1246
	set_opt(sbi, INLINE_XATTR);
1247
	set_opt(sbi, INLINE_DATA);
1248
	set_opt(sbi, INLINE_DENTRY);
J
Jaegeuk Kim 已提交
1249
	set_opt(sbi, EXTENT_CACHE);
1250
	set_opt(sbi, NOHEAP);
1251
	sbi->sb->s_flags |= SB_LAZYTIME;
J
Jaegeuk Kim 已提交
1252
	set_opt(sbi, FLUSH_MERGE);
1253
	if (f2fs_sb_mounted_blkzoned(sbi->sb)) {
1254 1255 1256 1257 1258
		set_opt_mode(sbi, F2FS_MOUNT_LFS);
		set_opt(sbi, DISCARD);
	} else {
		set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE);
	}
1259 1260 1261 1262 1263 1264 1265

#ifdef CONFIG_F2FS_FS_XATTR
	set_opt(sbi, XATTR_USER);
#endif
#ifdef CONFIG_F2FS_FS_POSIX_ACL
	set_opt(sbi, POSIX_ACL);
#endif
1266 1267 1268 1269

#ifdef CONFIG_F2FS_FAULT_INJECTION
	f2fs_build_fault_attr(sbi, 0);
#endif
1270 1271
}

J
Jaegeuk Kim 已提交
1272 1273 1274
#ifdef CONFIG_QUOTA
static int f2fs_enable_quotas(struct super_block *sb);
#endif
1275 1276 1277 1278
static int f2fs_remount(struct super_block *sb, int *flags, char *data)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
	struct f2fs_mount_info org_mount_opt;
C
Chao Yu 已提交
1279
	unsigned long old_sb_flags;
1280
	int err, active_logs;
1281 1282
	bool need_restart_gc = false;
	bool need_stop_gc = false;
1283
	bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
1284 1285 1286
#ifdef CONFIG_F2FS_FAULT_INJECTION
	struct f2fs_fault_info ffi = sbi->fault_info;
#endif
C
Chao Yu 已提交
1287 1288 1289 1290 1291
#ifdef CONFIG_QUOTA
	int s_jquota_fmt;
	char *s_qf_names[MAXQUOTAS];
	int i, j;
#endif
1292 1293 1294 1295 1296 1297

	/*
	 * Save the old mount options in case we
	 * need to restore them.
	 */
	org_mount_opt = sbi->mount_opt;
C
Chao Yu 已提交
1298
	old_sb_flags = sb->s_flags;
1299 1300
	active_logs = sbi->active_logs;

C
Chao Yu 已提交
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
#ifdef CONFIG_QUOTA
	s_jquota_fmt = sbi->s_jquota_fmt;
	for (i = 0; i < MAXQUOTAS; i++) {
		if (sbi->s_qf_names[i]) {
			s_qf_names[i] = kstrdup(sbi->s_qf_names[i],
							 GFP_KERNEL);
			if (!s_qf_names[i]) {
				for (j = 0; j < i; j++)
					kfree(s_qf_names[j]);
				return -ENOMEM;
			}
		} else {
			s_qf_names[i] = NULL;
		}
	}
#endif

1318
	/* recover superblocks we couldn't write due to previous RO mount */
1319
	if (!(*flags & SB_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) {
1320 1321 1322 1323 1324 1325 1326
		err = f2fs_commit_super(sbi, false);
		f2fs_msg(sb, KERN_INFO,
			"Try to recover all the superblocks, ret: %d", err);
		if (!err)
			clear_sbi_flag(sbi, SBI_NEED_SB_WRITE);
	}

1327
	default_options(sbi);
1328

1329 1330 1331 1332 1333 1334 1335
	/* parse mount options */
	err = parse_options(sb, data);
	if (err)
		goto restore_opts;

	/*
	 * Previous and new state of filesystem is RO,
1336
	 * so skip checking GC and FLUSH_MERGE conditions.
1337
	 */
1338
	if (f2fs_readonly(sb) && (*flags & SB_RDONLY))
1339 1340
		goto skip;

J
Jaegeuk Kim 已提交
1341
#ifdef CONFIG_QUOTA
1342
	if (!f2fs_readonly(sb) && (*flags & SB_RDONLY)) {
C
Chao Yu 已提交
1343 1344 1345
		err = dquot_suspend(sb, -1);
		if (err < 0)
			goto restore_opts;
1346
	} else if (f2fs_readonly(sb) && !(*flags & MS_RDONLY)) {
C
Chao Yu 已提交
1347
		/* dquot_resume needs RW */
1348
		sb->s_flags &= ~SB_RDONLY;
J
Jaegeuk Kim 已提交
1349 1350 1351 1352 1353 1354 1355
		if (sb_any_quota_suspended(sb)) {
			dquot_resume(sb, -1);
		} else if (f2fs_sb_has_quota_ino(sb)) {
			err = f2fs_enable_quotas(sb);
			if (err)
				goto restore_opts;
		}
C
Chao Yu 已提交
1356
	}
J
Jaegeuk Kim 已提交
1357
#endif
1358 1359 1360 1361 1362 1363 1364 1365
	/* disallow enable/disable extent_cache dynamically */
	if (no_extent_cache == !!test_opt(sbi, EXTENT_CACHE)) {
		err = -EINVAL;
		f2fs_msg(sbi->sb, KERN_WARNING,
				"switch extent_cache option is not allowed");
		goto restore_opts;
	}

1366 1367 1368 1369 1370
	/*
	 * We stop the GC thread if FS is mounted as RO
	 * or if background_gc = off is passed in mount
	 * option. Also sync the filesystem.
	 */
1371
	if ((*flags & SB_RDONLY) || !test_opt(sbi, BG_GC)) {
1372 1373
		if (sbi->gc_thread) {
			stop_gc_thread(sbi);
1374
			need_restart_gc = true;
1375
		}
1376
	} else if (!sbi->gc_thread) {
1377 1378 1379
		err = start_gc_thread(sbi);
		if (err)
			goto restore_opts;
1380 1381 1382
		need_stop_gc = true;
	}

1383
	if (*flags & SB_RDONLY) {
1384 1385 1386 1387 1388 1389 1390 1391 1392
		writeback_inodes_sb(sb, WB_REASON_SYNC);
		sync_inodes_sb(sb);

		set_sbi_flag(sbi, SBI_IS_DIRTY);
		set_sbi_flag(sbi, SBI_IS_CLOSE);
		f2fs_sync_fs(sb, 1);
		clear_sbi_flag(sbi, SBI_IS_CLOSE);
	}

1393 1394 1395 1396
	/*
	 * We stop issue flush thread if FS is mounted as RO
	 * or if flush_merge is not passed in mount option.
	 */
1397
	if ((*flags & SB_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
1398 1399 1400
		clear_opt(sbi, FLUSH_MERGE);
		destroy_flush_cmd_control(sbi, false);
	} else {
1401 1402
		err = create_flush_cmd_control(sbi);
		if (err)
1403
			goto restore_gc;
1404 1405
	}
skip:
C
Chao Yu 已提交
1406 1407 1408 1409 1410
#ifdef CONFIG_QUOTA
	/* Release old quota file names */
	for (i = 0; i < MAXQUOTAS; i++)
		kfree(s_qf_names[i]);
#endif
1411
	/* Update the POSIXACL Flag */
1412 1413
	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
		(test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
1414

1415
	limit_reserve_root(sbi);
1416
	return 0;
1417 1418 1419 1420
restore_gc:
	if (need_restart_gc) {
		if (start_gc_thread(sbi))
			f2fs_msg(sbi->sb, KERN_WARNING,
A
arter97 已提交
1421
				"background gc thread has stopped");
1422 1423 1424
	} else if (need_stop_gc) {
		stop_gc_thread(sbi);
	}
1425
restore_opts:
C
Chao Yu 已提交
1426 1427 1428 1429 1430 1431 1432
#ifdef CONFIG_QUOTA
	sbi->s_jquota_fmt = s_jquota_fmt;
	for (i = 0; i < MAXQUOTAS; i++) {
		kfree(sbi->s_qf_names[i]);
		sbi->s_qf_names[i] = s_qf_names[i];
	}
#endif
1433 1434
	sbi->mount_opt = org_mount_opt;
	sbi->active_logs = active_logs;
C
Chao Yu 已提交
1435
	sb->s_flags = old_sb_flags;
1436 1437 1438
#ifdef CONFIG_F2FS_FAULT_INJECTION
	sbi->fault_info = ffi;
#endif
1439 1440 1441
	return err;
}

C
Chao Yu 已提交
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
#ifdef CONFIG_QUOTA
/* Read data from quotafile */
static ssize_t f2fs_quota_read(struct super_block *sb, int type, char *data,
			       size_t len, loff_t off)
{
	struct inode *inode = sb_dqopt(sb)->files[type];
	struct address_space *mapping = inode->i_mapping;
	block_t blkidx = F2FS_BYTES_TO_BLK(off);
	int offset = off & (sb->s_blocksize - 1);
	int tocopy;
	size_t toread;
	loff_t i_size = i_size_read(inode);
	struct page *page;
	char *kaddr;

	if (off > i_size)
		return 0;

	if (off + len > i_size)
		len = i_size - off;
	toread = len;
	while (toread > 0) {
		tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread);
repeat:
		page = read_mapping_page(mapping, blkidx, NULL);
1467 1468 1469 1470 1471
		if (IS_ERR(page)) {
			if (PTR_ERR(page) == -ENOMEM) {
				congestion_wait(BLK_RW_ASYNC, HZ/50);
				goto repeat;
			}
C
Chao Yu 已提交
1472
			return PTR_ERR(page);
1473
		}
C
Chao Yu 已提交
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515

		lock_page(page);

		if (unlikely(page->mapping != mapping)) {
			f2fs_put_page(page, 1);
			goto repeat;
		}
		if (unlikely(!PageUptodate(page))) {
			f2fs_put_page(page, 1);
			return -EIO;
		}

		kaddr = kmap_atomic(page);
		memcpy(data, kaddr + offset, tocopy);
		kunmap_atomic(kaddr);
		f2fs_put_page(page, 1);

		offset = 0;
		toread -= tocopy;
		data += tocopy;
		blkidx++;
	}
	return len;
}

/* Write to quotafile */
static ssize_t f2fs_quota_write(struct super_block *sb, int type,
				const char *data, size_t len, loff_t off)
{
	struct inode *inode = sb_dqopt(sb)->files[type];
	struct address_space *mapping = inode->i_mapping;
	const struct address_space_operations *a_ops = mapping->a_ops;
	int offset = off & (sb->s_blocksize - 1);
	size_t towrite = len;
	struct page *page;
	char *kaddr;
	int err = 0;
	int tocopy;

	while (towrite > 0) {
		tocopy = min_t(unsigned long, sb->s_blocksize - offset,
								towrite);
1516
retry:
C
Chao Yu 已提交
1517 1518
		err = a_ops->write_begin(NULL, mapping, off, tocopy, 0,
							&page, NULL);
1519 1520 1521 1522 1523
		if (unlikely(err)) {
			if (err == -ENOMEM) {
				congestion_wait(BLK_RW_ASYNC, HZ/50);
				goto retry;
			}
C
Chao Yu 已提交
1524
			break;
1525
		}
C
Chao Yu 已提交
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541

		kaddr = kmap_atomic(page);
		memcpy(kaddr + offset, data, tocopy);
		kunmap_atomic(kaddr);
		flush_dcache_page(page);

		a_ops->write_end(NULL, mapping, off, tocopy, tocopy,
						page, NULL);
		offset = 0;
		towrite -= tocopy;
		off += tocopy;
		data += tocopy;
		cond_resched();
	}

	if (len == towrite)
1542
		return err;
C
Chao Yu 已提交
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
	inode->i_mtime = inode->i_ctime = current_time(inode);
	f2fs_mark_inode_dirty_sync(inode, false);
	return len - towrite;
}

static struct dquot **f2fs_get_dquots(struct inode *inode)
{
	return F2FS_I(inode)->i_dquot;
}

static qsize_t *f2fs_get_reserved_space(struct inode *inode)
{
	return &F2FS_I(inode)->i_reserved_quota;
}

C
Chao Yu 已提交
1558 1559 1560 1561 1562 1563
static int f2fs_quota_on_mount(struct f2fs_sb_info *sbi, int type)
{
	return dquot_quota_on_mount(sbi->sb, sbi->s_qf_names[type],
						sbi->s_jquota_fmt, type);
}

J
Jaegeuk Kim 已提交
1564
int f2fs_enable_quota_files(struct f2fs_sb_info *sbi, bool rdonly)
C
Chao Yu 已提交
1565
{
J
Jaegeuk Kim 已提交
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
	int enabled = 0;
	int i, err;

	if (f2fs_sb_has_quota_ino(sbi->sb) && rdonly) {
		err = f2fs_enable_quotas(sbi->sb);
		if (err) {
			f2fs_msg(sbi->sb, KERN_ERR,
					"Cannot turn on quota_ino: %d", err);
			return 0;
		}
		return 1;
	}
C
Chao Yu 已提交
1578 1579 1580

	for (i = 0; i < MAXQUOTAS; i++) {
		if (sbi->s_qf_names[i]) {
J
Jaegeuk Kim 已提交
1581 1582 1583 1584 1585 1586 1587
			err = f2fs_quota_on_mount(sbi, i);
			if (!err) {
				enabled = 1;
				continue;
			}
			f2fs_msg(sbi->sb, KERN_ERR,
				"Cannot turn on quotas: %d on %d", err, i);
C
Chao Yu 已提交
1588 1589
		}
	}
J
Jaegeuk Kim 已提交
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
	return enabled;
}

static int f2fs_quota_enable(struct super_block *sb, int type, int format_id,
			     unsigned int flags)
{
	struct inode *qf_inode;
	unsigned long qf_inum;
	int err;

	BUG_ON(!f2fs_sb_has_quota_ino(sb));

	qf_inum = f2fs_qf_ino(sb, type);
	if (!qf_inum)
		return -EPERM;

	qf_inode = f2fs_iget(sb, qf_inum);
	if (IS_ERR(qf_inode)) {
		f2fs_msg(sb, KERN_ERR,
			"Bad quota inode %u:%lu", type, qf_inum);
		return PTR_ERR(qf_inode);
	}

	/* Don't account quota for quota files to avoid recursion */
	qf_inode->i_flags |= S_NOQUOTA;
	err = dquot_enable(qf_inode, type, format_id, flags);
	iput(qf_inode);
	return err;
}

static int f2fs_enable_quotas(struct super_block *sb)
{
	int type, err = 0;
	unsigned long qf_inum;
	bool quota_mopt[MAXQUOTAS] = {
		test_opt(F2FS_SB(sb), USRQUOTA),
		test_opt(F2FS_SB(sb), GRPQUOTA),
		test_opt(F2FS_SB(sb), PRJQUOTA),
	};

	sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE | DQUOT_NOLIST_DIRTY;
	for (type = 0; type < MAXQUOTAS; type++) {
		qf_inum = f2fs_qf_ino(sb, type);
		if (qf_inum) {
			err = f2fs_quota_enable(sb, type, QFMT_VFS_V1,
				DQUOT_USAGE_ENABLED |
				(quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
			if (err) {
				f2fs_msg(sb, KERN_ERR,
					"Failed to enable quota tracking "
					"(type=%d, err=%d). Please run "
					"fsck to fix.", type, err);
				for (type--; type >= 0; type--)
					dquot_quota_off(sb, type);
				return err;
			}
C
Chao Yu 已提交
1646 1647
		}
	}
J
Jaegeuk Kim 已提交
1648
	return 0;
C
Chao Yu 已提交
1649 1650
}

C
Chao Yu 已提交
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
static int f2fs_quota_sync(struct super_block *sb, int type)
{
	struct quota_info *dqopt = sb_dqopt(sb);
	int cnt;
	int ret;

	ret = dquot_writeback_dquots(sb, type);
	if (ret)
		return ret;

	/*
	 * Now when everything is written we can discard the pagecache so
	 * that userspace sees the changes.
	 */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
		if (!sb_has_quota_active(sb, cnt))
			continue;

		ret = filemap_write_and_wait(dqopt->files[cnt]->i_mapping);
		if (ret)
			return ret;

		inode_lock(dqopt->files[cnt]);
		truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
		inode_unlock(dqopt->files[cnt]);
	}
	return 0;
}

static int f2fs_quota_on(struct super_block *sb, int type, int format_id,
							const struct path *path)
{
	struct inode *inode;
	int err;

1688
	err = f2fs_quota_sync(sb, type);
C
Chao Yu 已提交
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
	if (err)
		return err;

	err = dquot_quota_on(sb, type, format_id, path);
	if (err)
		return err;

	inode = d_inode(path->dentry);

	inode_lock(inode);
	F2FS_I(inode)->i_flags |= FS_NOATIME_FL | FS_IMMUTABLE_FL;
	inode_set_flags(inode, S_NOATIME | S_IMMUTABLE,
					S_NOATIME | S_IMMUTABLE);
	inode_unlock(inode);
	f2fs_mark_inode_dirty_sync(inode, false);

	return 0;
}

static int f2fs_quota_off(struct super_block *sb, int type)
{
	struct inode *inode = sb_dqopt(sb)->files[type];
	int err;

	if (!inode || !igrab(inode))
		return dquot_quota_off(sb, type);

1716
	f2fs_quota_sync(sb, type);
C
Chao Yu 已提交
1717 1718

	err = dquot_quota_off(sb, type);
J
Jaegeuk Kim 已提交
1719
	if (err || f2fs_sb_has_quota_ino(sb))
C
Chao Yu 已提交
1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
		goto out_put;

	inode_lock(inode);
	F2FS_I(inode)->i_flags &= ~(FS_NOATIME_FL | FS_IMMUTABLE_FL);
	inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
	inode_unlock(inode);
	f2fs_mark_inode_dirty_sync(inode, false);
out_put:
	iput(inode);
	return err;
}

C
Chao Yu 已提交
1732
void f2fs_quota_off_umount(struct super_block *sb)
C
Chao Yu 已提交
1733 1734 1735 1736 1737 1738 1739
{
	int type;

	for (type = 0; type < MAXQUOTAS; type++)
		f2fs_quota_off(sb, type);
}

W
Wei Yongjun 已提交
1740
static int f2fs_get_projid(struct inode *inode, kprojid_t *projid)
C
Chao Yu 已提交
1741 1742 1743 1744 1745
{
	*projid = F2FS_I(inode)->i_projid;
	return 0;
}

C
Chao Yu 已提交
1746 1747 1748 1749 1750 1751 1752 1753 1754
static const struct dquot_operations f2fs_quota_operations = {
	.get_reserved_space = f2fs_get_reserved_space,
	.write_dquot	= dquot_commit,
	.acquire_dquot	= dquot_acquire,
	.release_dquot	= dquot_release,
	.mark_dirty	= dquot_mark_dquot_dirty,
	.write_info	= dquot_commit_info,
	.alloc_dquot	= dquot_alloc,
	.destroy_dquot	= dquot_destroy,
C
Chao Yu 已提交
1755
	.get_projid	= f2fs_get_projid,
C
Chao Yu 已提交
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	.get_next_id	= dquot_get_next_id,
};

static const struct quotactl_ops f2fs_quotactl_ops = {
	.quota_on	= f2fs_quota_on,
	.quota_off	= f2fs_quota_off,
	.quota_sync	= f2fs_quota_sync,
	.get_state	= dquot_get_state,
	.set_info	= dquot_set_dqinfo,
	.get_dqblk	= dquot_get_dqblk,
	.set_dqblk	= dquot_set_dqblk,
	.get_nextdqblk	= dquot_get_next_dqblk,
};
#else
C
Chao Yu 已提交
1770
void f2fs_quota_off_umount(struct super_block *sb)
C
Chao Yu 已提交
1771 1772 1773 1774
{
}
#endif

A
Arvind Yadav 已提交
1775
static const struct super_operations f2fs_sops = {
J
Jaegeuk Kim 已提交
1776
	.alloc_inode	= f2fs_alloc_inode,
1777
	.drop_inode	= f2fs_drop_inode,
J
Jaegeuk Kim 已提交
1778 1779
	.destroy_inode	= f2fs_destroy_inode,
	.write_inode	= f2fs_write_inode,
1780
	.dirty_inode	= f2fs_dirty_inode,
J
Jaegeuk Kim 已提交
1781
	.show_options	= f2fs_show_options,
C
Chao Yu 已提交
1782 1783 1784 1785 1786
#ifdef CONFIG_QUOTA
	.quota_read	= f2fs_quota_read,
	.quota_write	= f2fs_quota_write,
	.get_dquots	= f2fs_get_dquots,
#endif
J
Jaegeuk Kim 已提交
1787 1788 1789
	.evict_inode	= f2fs_evict_inode,
	.put_super	= f2fs_put_super,
	.sync_fs	= f2fs_sync_fs,
1790 1791
	.freeze_fs	= f2fs_freeze,
	.unfreeze_fs	= f2fs_unfreeze,
J
Jaegeuk Kim 已提交
1792
	.statfs		= f2fs_statfs,
1793
	.remount_fs	= f2fs_remount,
J
Jaegeuk Kim 已提交
1794 1795
};

1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817
#ifdef CONFIG_F2FS_FS_ENCRYPTION
static int f2fs_get_context(struct inode *inode, void *ctx, size_t len)
{
	return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
				F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
				ctx, len, NULL);
}

static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len,
							void *fs_data)
{
	return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
				F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
				ctx, len, fs_data, XATTR_CREATE);
}

static unsigned f2fs_max_namelen(struct inode *inode)
{
	return S_ISLNK(inode->i_mode) ?
			inode->i_sb->s_blocksize : F2FS_NAME_LEN;
}

1818
static const struct fscrypt_operations f2fs_cryptops = {
1819
	.key_prefix	= "f2fs:",
1820 1821 1822 1823 1824 1825 1826
	.get_context	= f2fs_get_context,
	.set_context	= f2fs_set_context,
	.empty_dir	= f2fs_empty_dir,
	.max_namelen	= f2fs_max_namelen,
};
#endif

J
Jaegeuk Kim 已提交
1827 1828 1829 1830 1831 1832
static struct inode *f2fs_nfs_get_inode(struct super_block *sb,
		u64 ino, u32 generation)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
	struct inode *inode;

1833
	if (check_nid_range(sbi, ino))
1834
		return ERR_PTR(-ESTALE);
J
Jaegeuk Kim 已提交
1835 1836 1837 1838 1839 1840 1841 1842 1843

	/*
	 * f2fs_iget isn't quite right if the inode is currently unallocated!
	 * However f2fs_iget currently does appropriate checks to handle stale
	 * inodes so everything is OK.
	 */
	inode = f2fs_iget(sb, ino);
	if (IS_ERR(inode))
		return ERR_CAST(inode);
1844
	if (unlikely(generation && inode->i_generation != generation)) {
J
Jaegeuk Kim 已提交
1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
		/* we didn't find the right inode.. */
		iput(inode);
		return ERR_PTR(-ESTALE);
	}
	return inode;
}

static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid,
		int fh_len, int fh_type)
{
	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
				    f2fs_nfs_get_inode);
}

static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid,
		int fh_len, int fh_type)
{
	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
				    f2fs_nfs_get_inode);
}

static const struct export_operations f2fs_export_ops = {
	.fh_to_dentry = f2fs_fh_to_dentry,
	.fh_to_parent = f2fs_fh_to_parent,
	.get_parent = f2fs_get_parent,
};

C
Chao Yu 已提交
1872
static loff_t max_file_blocks(void)
J
Jaegeuk Kim 已提交
1873
{
1874
	loff_t result = 0;
J
Jaegeuk Kim 已提交
1875 1876
	loff_t leaf_count = ADDRS_PER_BLOCK;

1877 1878
	/*
	 * note: previously, result is equal to (DEF_ADDRS_PER_INODE -
C
Chao Yu 已提交
1879
	 * DEFAULT_INLINE_XATTR_ADDRS), but now f2fs try to reserve more
1880 1881 1882 1883
	 * space in inode.i_addr, it will be more safe to reassign
	 * result as zero.
	 */

J
Jaegeuk Kim 已提交
1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
	/* two direct node blocks */
	result += (leaf_count * 2);

	/* two indirect node blocks */
	leaf_count *= NIDS_PER_BLOCK;
	result += (leaf_count * 2);

	/* one double indirect node block */
	leaf_count *= NIDS_PER_BLOCK;
	result += leaf_count;

	return result;
}

1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
static int __f2fs_commit_super(struct buffer_head *bh,
			struct f2fs_super_block *super)
{
	lock_buffer(bh);
	if (super)
		memcpy(bh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super));
	set_buffer_dirty(bh);
	unlock_buffer(bh);

	/* it's rare case, we can do fua all the time */
1908
	return __sync_dirty_buffer(bh, REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
1909 1910
}

1911
static inline bool sanity_check_area_boundary(struct f2fs_sb_info *sbi,
1912
					struct buffer_head *bh)
1913
{
1914 1915
	struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
					(bh->b_data + F2FS_SUPER_OFFSET);
1916
	struct super_block *sb = sbi->sb;
1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929
	u32 segment0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);
	u32 cp_blkaddr = le32_to_cpu(raw_super->cp_blkaddr);
	u32 sit_blkaddr = le32_to_cpu(raw_super->sit_blkaddr);
	u32 nat_blkaddr = le32_to_cpu(raw_super->nat_blkaddr);
	u32 ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
	u32 main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);
	u32 segment_count_ckpt = le32_to_cpu(raw_super->segment_count_ckpt);
	u32 segment_count_sit = le32_to_cpu(raw_super->segment_count_sit);
	u32 segment_count_nat = le32_to_cpu(raw_super->segment_count_nat);
	u32 segment_count_ssa = le32_to_cpu(raw_super->segment_count_ssa);
	u32 segment_count_main = le32_to_cpu(raw_super->segment_count_main);
	u32 segment_count = le32_to_cpu(raw_super->segment_count);
	u32 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
1930 1931 1932 1933
	u64 main_end_blkaddr = main_blkaddr +
				(segment_count_main << log_blocks_per_seg);
	u64 seg_end_blkaddr = segment0_blkaddr +
				(segment_count << log_blocks_per_seg);
1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977

	if (segment0_blkaddr != cp_blkaddr) {
		f2fs_msg(sb, KERN_INFO,
			"Mismatch start address, segment0(%u) cp_blkaddr(%u)",
			segment0_blkaddr, cp_blkaddr);
		return true;
	}

	if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) !=
							sit_blkaddr) {
		f2fs_msg(sb, KERN_INFO,
			"Wrong CP boundary, start(%u) end(%u) blocks(%u)",
			cp_blkaddr, sit_blkaddr,
			segment_count_ckpt << log_blocks_per_seg);
		return true;
	}

	if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) !=
							nat_blkaddr) {
		f2fs_msg(sb, KERN_INFO,
			"Wrong SIT boundary, start(%u) end(%u) blocks(%u)",
			sit_blkaddr, nat_blkaddr,
			segment_count_sit << log_blocks_per_seg);
		return true;
	}

	if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) !=
							ssa_blkaddr) {
		f2fs_msg(sb, KERN_INFO,
			"Wrong NAT boundary, start(%u) end(%u) blocks(%u)",
			nat_blkaddr, ssa_blkaddr,
			segment_count_nat << log_blocks_per_seg);
		return true;
	}

	if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) !=
							main_blkaddr) {
		f2fs_msg(sb, KERN_INFO,
			"Wrong SSA boundary, start(%u) end(%u) blocks(%u)",
			ssa_blkaddr, main_blkaddr,
			segment_count_ssa << log_blocks_per_seg);
		return true;
	}

1978
	if (main_end_blkaddr > seg_end_blkaddr) {
1979
		f2fs_msg(sb, KERN_INFO,
1980
			"Wrong MAIN_AREA boundary, start(%u) end(%u) block(%u)",
1981
			main_blkaddr,
1982 1983
			segment0_blkaddr +
				(segment_count << log_blocks_per_seg),
1984 1985
			segment_count_main << log_blocks_per_seg);
		return true;
1986 1987 1988 1989 1990 1991 1992 1993 1994
	} else if (main_end_blkaddr < seg_end_blkaddr) {
		int err = 0;
		char *res;

		/* fix in-memory information all the time */
		raw_super->segment_count = cpu_to_le32((main_end_blkaddr -
				segment0_blkaddr) >> log_blocks_per_seg);

		if (f2fs_readonly(sb) || bdev_read_only(sb->s_bdev)) {
1995
			set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008
			res = "internally";
		} else {
			err = __f2fs_commit_super(bh, NULL);
			res = err ? "failed" : "done";
		}
		f2fs_msg(sb, KERN_INFO,
			"Fix alignment : %s, start(%u) end(%u) block(%u)",
			res, main_blkaddr,
			segment0_blkaddr +
				(segment_count << log_blocks_per_seg),
			segment_count_main << log_blocks_per_seg);
		if (err)
			return true;
2009 2010 2011 2012
	}
	return false;
}

2013
static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
2014
				struct buffer_head *bh)
J
Jaegeuk Kim 已提交
2015
{
2016 2017
	struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
					(bh->b_data + F2FS_SUPER_OFFSET);
2018
	struct super_block *sb = sbi->sb;
J
Jaegeuk Kim 已提交
2019 2020
	unsigned int blocksize;

2021 2022 2023 2024
	if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) {
		f2fs_msg(sb, KERN_INFO,
			"Magic Mismatch, valid(0x%x) - read(0x%x)",
			F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));
J
Jaegeuk Kim 已提交
2025
		return 1;
2026
	}
J
Jaegeuk Kim 已提交
2027

2028
	/* Currently, support only 4KB page cache size */
2029
	if (F2FS_BLKSIZE != PAGE_SIZE) {
2030
		f2fs_msg(sb, KERN_INFO,
2031
			"Invalid page_cache_size (%lu), supports only 4KB\n",
2032
			PAGE_SIZE);
2033 2034 2035
		return 1;
	}

J
Jaegeuk Kim 已提交
2036 2037
	/* Currently, support only 4KB block size */
	blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
2038
	if (blocksize != F2FS_BLKSIZE) {
2039 2040 2041
		f2fs_msg(sb, KERN_INFO,
			"Invalid blocksize (%u), supports only 4KB\n",
			blocksize);
J
Jaegeuk Kim 已提交
2042
		return 1;
2043
	}
2044

2045 2046 2047 2048 2049 2050 2051 2052
	/* check log blocks per segment */
	if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) {
		f2fs_msg(sb, KERN_INFO,
			"Invalid log blocks per segment (%u)\n",
			le32_to_cpu(raw_super->log_blocks_per_seg));
		return 1;
	}

C
Chao Yu 已提交
2053 2054 2055 2056 2057 2058 2059
	/* Currently, support 512/1024/2048/4096 bytes sector size */
	if (le32_to_cpu(raw_super->log_sectorsize) >
				F2FS_MAX_LOG_SECTOR_SIZE ||
		le32_to_cpu(raw_super->log_sectorsize) <
				F2FS_MIN_LOG_SECTOR_SIZE) {
		f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize (%u)",
			le32_to_cpu(raw_super->log_sectorsize));
J
Jaegeuk Kim 已提交
2060
		return 1;
2061
	}
C
Chao Yu 已提交
2062 2063 2064 2065 2066 2067 2068
	if (le32_to_cpu(raw_super->log_sectors_per_block) +
		le32_to_cpu(raw_super->log_sectorsize) !=
			F2FS_MAX_LOG_SECTOR_SIZE) {
		f2fs_msg(sb, KERN_INFO,
			"Invalid log sectors per block(%u) log sectorsize(%u)",
			le32_to_cpu(raw_super->log_sectors_per_block),
			le32_to_cpu(raw_super->log_sectorsize));
J
Jaegeuk Kim 已提交
2069
		return 1;
2070
	}
2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083

	/* check reserved ino info */
	if (le32_to_cpu(raw_super->node_ino) != 1 ||
		le32_to_cpu(raw_super->meta_ino) != 2 ||
		le32_to_cpu(raw_super->root_ino) != 3) {
		f2fs_msg(sb, KERN_INFO,
			"Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)",
			le32_to_cpu(raw_super->node_ino),
			le32_to_cpu(raw_super->meta_ino),
			le32_to_cpu(raw_super->root_ino));
		return 1;
	}

J
Jin Qian 已提交
2084 2085 2086 2087 2088 2089 2090
	if (le32_to_cpu(raw_super->segment_count) > F2FS_MAX_SEGMENT) {
		f2fs_msg(sb, KERN_INFO,
			"Invalid segment count (%u)",
			le32_to_cpu(raw_super->segment_count));
		return 1;
	}

2091
	/* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */
2092
	if (sanity_check_area_boundary(sbi, bh))
2093 2094
		return 1;

J
Jaegeuk Kim 已提交
2095 2096 2097
	return 0;
}

2098
int sanity_check_ckpt(struct f2fs_sb_info *sbi)
J
Jaegeuk Kim 已提交
2099 2100
{
	unsigned int total, fsmeta;
2101 2102
	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
J
Jaegeuk Kim 已提交
2103
	unsigned int ovp_segments, reserved_segments;
2104 2105
	unsigned int main_segs, blocks_per_seg;
	int i;
J
Jaegeuk Kim 已提交
2106 2107 2108 2109 2110 2111 2112 2113

	total = le32_to_cpu(raw_super->segment_count);
	fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
	fsmeta += le32_to_cpu(raw_super->segment_count_sit);
	fsmeta += le32_to_cpu(raw_super->segment_count_nat);
	fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
	fsmeta += le32_to_cpu(raw_super->segment_count_ssa);

2114
	if (unlikely(fsmeta >= total))
J
Jaegeuk Kim 已提交
2115
		return 1;
2116

J
Jaegeuk Kim 已提交
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
	ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);
	reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);

	if (unlikely(fsmeta < F2FS_MIN_SEGMENTS ||
			ovp_segments == 0 || reserved_segments == 0)) {
		f2fs_msg(sbi->sb, KERN_ERR,
			"Wrong layout: check mkfs.f2fs version");
		return 1;
	}

2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
	main_segs = le32_to_cpu(raw_super->segment_count_main);
	blocks_per_seg = sbi->blocks_per_seg;

	for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
		if (le32_to_cpu(ckpt->cur_node_segno[i]) >= main_segs ||
			le16_to_cpu(ckpt->cur_node_blkoff[i]) >= blocks_per_seg)
			return 1;
	}
	for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {
		if (le32_to_cpu(ckpt->cur_data_segno[i]) >= main_segs ||
			le16_to_cpu(ckpt->cur_data_blkoff[i]) >= blocks_per_seg)
			return 1;
	}

2141
	if (unlikely(f2fs_cp_error(sbi))) {
2142 2143 2144
		f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
		return 1;
	}
J
Jaegeuk Kim 已提交
2145 2146 2147 2148 2149 2150
	return 0;
}

static void init_sb_info(struct f2fs_sb_info *sbi)
{
	struct f2fs_super_block *raw_super = sbi->raw_super;
C
Chao Yu 已提交
2151
	int i, j;
J
Jaegeuk Kim 已提交
2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167

	sbi->log_sectors_per_block =
		le32_to_cpu(raw_super->log_sectors_per_block);
	sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
	sbi->blocksize = 1 << sbi->log_blocksize;
	sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
	sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
	sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
	sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
	sbi->total_sections = le32_to_cpu(raw_super->section_count);
	sbi->total_node_count =
		(le32_to_cpu(raw_super->segment_count_nat) / 2)
			* sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
	sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
	sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
	sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
2168
	sbi->cur_victim_sec = NULL_SECNO;
2169
	sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
J
Jaegeuk Kim 已提交
2170

2171
	sbi->dir_level = DEF_DIR_LEVEL;
2172
	sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
2173
	sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
2174
	clear_sbi_flag(sbi, SBI_NEED_FSCK);
2175

2176 2177 2178
	for (i = 0; i < NR_COUNT_TYPE; i++)
		atomic_set(&sbi->nr_pages[i], 0);

2179 2180
	atomic_set(&sbi->wb_sync_req, 0);

2181 2182
	INIT_LIST_HEAD(&sbi->s_list);
	mutex_init(&sbi->umount_mutex);
C
Chao Yu 已提交
2183 2184 2185
	for (i = 0; i < NR_PAGE_TYPE - 1; i++)
		for (j = HOT; j < NR_TEMP_TYPE; j++)
			mutex_init(&sbi->wio_mutex[i][j]);
2186
	spin_lock_init(&sbi->cp_lock);
2187 2188 2189

	sbi->dirty_device = 0;
	spin_lock_init(&sbi->dev_lock);
J
Jaegeuk Kim 已提交
2190 2191
}

2192 2193
static int init_percpu_info(struct f2fs_sb_info *sbi)
{
2194
	int err;
2195

2196 2197 2198 2199 2200
	err = percpu_counter_init(&sbi->alloc_valid_block_count, 0, GFP_KERNEL);
	if (err)
		return err;

	return percpu_counter_init(&sbi->total_valid_inode_count, 0,
2201
								GFP_KERNEL);
2202 2203
}

2204
#ifdef CONFIG_BLK_DEV_ZONED
J
Jaegeuk Kim 已提交
2205
static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)
2206
{
J
Jaegeuk Kim 已提交
2207
	struct block_device *bdev = FDEV(devi).bdev;
2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
	sector_t nr_sectors = bdev->bd_part->nr_sects;
	sector_t sector = 0;
	struct blk_zone *zones;
	unsigned int i, nr_zones;
	unsigned int n = 0;
	int err = -EIO;

	if (!f2fs_sb_mounted_blkzoned(sbi->sb))
		return 0;

J
Jaegeuk Kim 已提交
2218
	if (sbi->blocks_per_blkz && sbi->blocks_per_blkz !=
2219
				SECTOR_TO_BLOCK(bdev_zone_sectors(bdev)))
J
Jaegeuk Kim 已提交
2220
		return -EINVAL;
2221
	sbi->blocks_per_blkz = SECTOR_TO_BLOCK(bdev_zone_sectors(bdev));
J
Jaegeuk Kim 已提交
2222 2223 2224
	if (sbi->log_blocks_per_blkz && sbi->log_blocks_per_blkz !=
				__ilog2_u32(sbi->blocks_per_blkz))
		return -EINVAL;
2225
	sbi->log_blocks_per_blkz = __ilog2_u32(sbi->blocks_per_blkz);
J
Jaegeuk Kim 已提交
2226 2227
	FDEV(devi).nr_blkz = SECTOR_TO_BLOCK(nr_sectors) >>
					sbi->log_blocks_per_blkz;
2228
	if (nr_sectors & (bdev_zone_sectors(bdev) - 1))
J
Jaegeuk Kim 已提交
2229
		FDEV(devi).nr_blkz++;
2230

C
Chao Yu 已提交
2231 2232
	FDEV(devi).blkz_type = f2fs_kmalloc(sbi, FDEV(devi).nr_blkz,
								GFP_KERNEL);
J
Jaegeuk Kim 已提交
2233
	if (!FDEV(devi).blkz_type)
2234 2235 2236 2237
		return -ENOMEM;

#define F2FS_REPORT_NR_ZONES   4096

C
Chao Yu 已提交
2238 2239
	zones = f2fs_kzalloc(sbi, sizeof(struct blk_zone) *
				F2FS_REPORT_NR_ZONES, GFP_KERNEL);
2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
	if (!zones)
		return -ENOMEM;

	/* Get block zones type */
	while (zones && sector < nr_sectors) {

		nr_zones = F2FS_REPORT_NR_ZONES;
		err = blkdev_report_zones(bdev, sector,
					  zones, &nr_zones,
					  GFP_KERNEL);
		if (err)
			break;
		if (!nr_zones) {
			err = -EIO;
			break;
		}

		for (i = 0; i < nr_zones; i++) {
J
Jaegeuk Kim 已提交
2258
			FDEV(devi).blkz_type[n] = zones[i].type;
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269
			sector += zones[i].len;
			n++;
		}
	}

	kfree(zones);

	return err;
}
#endif

2270 2271
/*
 * Read f2fs raw super block.
2272 2273 2274
 * Because we have two copies of super block, so read both of them
 * to get the first valid one. If any one of them is broken, we pass
 * them recovery flag back to the caller.
2275
 */
2276
static int read_raw_super_block(struct f2fs_sb_info *sbi,
2277
			struct f2fs_super_block **raw_super,
2278
			int *valid_super_block, int *recovery)
2279
{
2280
	struct super_block *sb = sbi->sb;
2281
	int block;
2282
	struct buffer_head *bh;
2283
	struct f2fs_super_block *super;
2284
	int err = 0;
2285

Y
Yunlei He 已提交
2286 2287 2288
	super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);
	if (!super)
		return -ENOMEM;
2289 2290 2291 2292 2293

	for (block = 0; block < 2; block++) {
		bh = sb_bread(sb, block);
		if (!bh) {
			f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
2294
				block + 1);
2295 2296 2297
			err = -EIO;
			continue;
		}
2298

2299
		/* sanity checking of raw super */
2300
		if (sanity_check_raw_super(sbi, bh)) {
2301 2302 2303 2304 2305 2306 2307
			f2fs_msg(sb, KERN_ERR,
				"Can't find valid F2FS filesystem in %dth superblock",
				block + 1);
			err = -EINVAL;
			brelse(bh);
			continue;
		}
2308

2309
		if (!*raw_super) {
2310 2311
			memcpy(super, bh->b_data + F2FS_SUPER_OFFSET,
							sizeof(*super));
2312 2313 2314 2315
			*valid_super_block = block;
			*raw_super = super;
		}
		brelse(bh);
2316 2317
	}

2318 2319 2320
	/* Fail to read any one of the superblocks*/
	if (err < 0)
		*recovery = 1;
2321 2322

	/* No valid superblock */
2323
	if (!*raw_super)
Y
Yunlei He 已提交
2324
		kfree(super);
2325 2326
	else
		err = 0;
2327

2328
	return err;
2329 2330
}

2331
int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)
J
Jaegeuk Kim 已提交
2332
{
J
Jaegeuk Kim 已提交
2333
	struct buffer_head *bh;
J
Jaegeuk Kim 已提交
2334 2335
	int err;

2336 2337 2338
	if ((recover && f2fs_readonly(sbi->sb)) ||
				bdev_read_only(sbi->sb->s_bdev)) {
		set_sbi_flag(sbi, SBI_NEED_SB_WRITE);
2339
		return -EROFS;
2340
	}
2341

2342
	/* write back-up superblock first */
2343
	bh = sb_bread(sbi->sb, sbi->valid_super_block ? 0 : 1);
J
Jaegeuk Kim 已提交
2344 2345
	if (!bh)
		return -EIO;
2346
	err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
J
Jaegeuk Kim 已提交
2347
	brelse(bh);
C
Chao Yu 已提交
2348 2349 2350

	/* if we are in recovery path, skip writing valid superblock */
	if (recover || err)
J
Jaegeuk Kim 已提交
2351
		return err;
J
Jaegeuk Kim 已提交
2352 2353

	/* write current valid superblock */
2354
	bh = sb_bread(sbi->sb, sbi->valid_super_block);
2355 2356 2357 2358 2359
	if (!bh)
		return -EIO;
	err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
	brelse(bh);
	return err;
J
Jaegeuk Kim 已提交
2360 2361
}

J
Jaegeuk Kim 已提交
2362 2363 2364
static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
{
	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
2365
	unsigned int max_devices = MAX_DEVICES;
J
Jaegeuk Kim 已提交
2366 2367
	int i;

2368 2369 2370
	/* Initialize single device information */
	if (!RDEV(0).path[0]) {
		if (!bdev_is_zoned(sbi->sb->s_bdev))
J
Jaegeuk Kim 已提交
2371
			return 0;
2372 2373
		max_devices = 1;
	}
J
Jaegeuk Kim 已提交
2374

2375 2376 2377 2378
	/*
	 * Initialize multiple devices information, or single
	 * zoned block device information.
	 */
C
Chao Yu 已提交
2379 2380
	sbi->devs = f2fs_kzalloc(sbi, sizeof(struct f2fs_dev_info) *
						max_devices, GFP_KERNEL);
2381 2382
	if (!sbi->devs)
		return -ENOMEM;
J
Jaegeuk Kim 已提交
2383

2384
	for (i = 0; i < max_devices; i++) {
J
Jaegeuk Kim 已提交
2385

2386 2387 2388 2389 2390 2391 2392
		if (i > 0 && !RDEV(i).path[0])
			break;

		if (max_devices == 1) {
			/* Single zoned block device mount */
			FDEV(0).bdev =
				blkdev_get_by_dev(sbi->sb->s_bdev->bd_dev,
J
Jaegeuk Kim 已提交
2393
					sbi->sb->s_mode, sbi->sb->s_type);
2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411
		} else {
			/* Multi-device mount */
			memcpy(FDEV(i).path, RDEV(i).path, MAX_PATH_LEN);
			FDEV(i).total_segments =
				le32_to_cpu(RDEV(i).total_segments);
			if (i == 0) {
				FDEV(i).start_blk = 0;
				FDEV(i).end_blk = FDEV(i).start_blk +
				    (FDEV(i).total_segments <<
				    sbi->log_blocks_per_seg) - 1 +
				    le32_to_cpu(raw_super->segment0_blkaddr);
			} else {
				FDEV(i).start_blk = FDEV(i - 1).end_blk + 1;
				FDEV(i).end_blk = FDEV(i).start_blk +
					(FDEV(i).total_segments <<
					sbi->log_blocks_per_seg) - 1;
			}
			FDEV(i).bdev = blkdev_get_by_path(FDEV(i).path,
J
Jaegeuk Kim 已提交
2412
					sbi->sb->s_mode, sbi->sb->s_type);
2413
		}
J
Jaegeuk Kim 已提交
2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432
		if (IS_ERR(FDEV(i).bdev))
			return PTR_ERR(FDEV(i).bdev);

		/* to release errored devices */
		sbi->s_ndevs = i + 1;

#ifdef CONFIG_BLK_DEV_ZONED
		if (bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HM &&
				!f2fs_sb_mounted_blkzoned(sbi->sb)) {
			f2fs_msg(sbi->sb, KERN_ERR,
				"Zoned block device feature not enabled\n");
			return -EINVAL;
		}
		if (bdev_zoned_model(FDEV(i).bdev) != BLK_ZONED_NONE) {
			if (init_blkz_info(sbi, i)) {
				f2fs_msg(sbi->sb, KERN_ERR,
					"Failed to initialize F2FS blkzone information");
				return -EINVAL;
			}
2433 2434
			if (max_devices == 1)
				break;
J
Jaegeuk Kim 已提交
2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450
			f2fs_msg(sbi->sb, KERN_INFO,
				"Mount Device [%2d]: %20s, %8u, %8x - %8x (zone: %s)",
				i, FDEV(i).path,
				FDEV(i).total_segments,
				FDEV(i).start_blk, FDEV(i).end_blk,
				bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HA ?
				"Host-aware" : "Host-managed");
			continue;
		}
#endif
		f2fs_msg(sbi->sb, KERN_INFO,
			"Mount Device [%2d]: %20s, %8u, %8x - %8x",
				i, FDEV(i).path,
				FDEV(i).total_segments,
				FDEV(i).start_blk, FDEV(i).end_blk);
	}
2451 2452
	f2fs_msg(sbi->sb, KERN_INFO,
			"IO Block Size: %8d KB", F2FS_IO_SIZE_KB(sbi));
J
Jaegeuk Kim 已提交
2453 2454 2455
	return 0;
}

J
Jaegeuk Kim 已提交
2456 2457 2458
static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct f2fs_sb_info *sbi;
2459
	struct f2fs_super_block *raw_super;
J
Jaegeuk Kim 已提交
2460
	struct inode *root;
2461
	int err;
2462
	bool retry = true, need_fsck = false;
2463
	char *options = NULL;
2464
	int recovery, i, valid_super_block;
2465
	struct curseg_info *seg_i;
J
Jaegeuk Kim 已提交
2466

2467
try_onemore:
2468 2469
	err = -EINVAL;
	raw_super = NULL;
2470
	valid_super_block = -1;
2471 2472
	recovery = 0;

J
Jaegeuk Kim 已提交
2473 2474 2475 2476 2477
	/* allocate memory for f2fs-specific super block info */
	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;

2478 2479
	sbi->sb = sb;

K
Keith Mok 已提交
2480 2481 2482 2483 2484 2485 2486 2487 2488
	/* Load the checksum driver */
	sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0);
	if (IS_ERR(sbi->s_chksum_driver)) {
		f2fs_msg(sb, KERN_ERR, "Cannot load crc32 driver.");
		err = PTR_ERR(sbi->s_chksum_driver);
		sbi->s_chksum_driver = NULL;
		goto free_sbi;
	}

2489
	/* set a block size */
2490
	if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
2491
		f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
J
Jaegeuk Kim 已提交
2492
		goto free_sbi;
2493
	}
J
Jaegeuk Kim 已提交
2494

2495
	err = read_raw_super_block(sbi, &raw_super, &valid_super_block,
2496
								&recovery);
2497 2498 2499
	if (err)
		goto free_sbi;

2500
	sb->s_fs_info = sbi;
2501 2502
	sbi->raw_super = raw_super;

2503 2504 2505
	sbi->s_resuid = make_kuid(&init_user_ns, F2FS_DEF_RESUID);
	sbi->s_resgid = make_kgid(&init_user_ns, F2FS_DEF_RESGID);

C
Chao Yu 已提交
2506 2507 2508 2509 2510
	/* precompute checksum seed for metadata */
	if (f2fs_sb_has_inode_chksum(sb))
		sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid,
						sizeof(raw_super->uuid));

2511 2512 2513 2514 2515 2516 2517 2518 2519
	/*
	 * The BLKZONED feature indicates that the drive was formatted with
	 * zone alignment optimization. This is optional for host-aware
	 * devices, but mandatory for host-managed zoned block devices.
	 */
#ifndef CONFIG_BLK_DEV_ZONED
	if (f2fs_sb_mounted_blkzoned(sb)) {
		f2fs_msg(sb, KERN_ERR,
			 "Zoned block device support is not enabled\n");
2520
		err = -EOPNOTSUPP;
2521 2522 2523
		goto free_sb_buf;
	}
#endif
2524
	default_options(sbi);
J
Jaegeuk Kim 已提交
2525
	/* parse mount options */
2526 2527 2528
	options = kstrdup((const char *)data, GFP_KERNEL);
	if (data && !options) {
		err = -ENOMEM;
J
Jaegeuk Kim 已提交
2529
		goto free_sb_buf;
2530 2531 2532 2533 2534
	}

	err = parse_options(sb, options);
	if (err)
		goto free_options;
J
Jaegeuk Kim 已提交
2535

C
Chao Yu 已提交
2536 2537 2538
	sbi->max_file_blocks = max_file_blocks();
	sb->s_maxbytes = sbi->max_file_blocks <<
				le32_to_cpu(raw_super->log_blocksize);
J
Jaegeuk Kim 已提交
2539 2540 2541
	sb->s_max_links = F2FS_LINK_MAX;
	get_random_bytes(&sbi->s_next_generation, sizeof(u32));

C
Chao Yu 已提交
2542 2543
#ifdef CONFIG_QUOTA
	sb->dq_op = &f2fs_quota_operations;
J
Jaegeuk Kim 已提交
2544 2545 2546 2547
	if (f2fs_sb_has_quota_ino(sb))
		sb->s_qcop = &dquot_quotactl_sysfile_ops;
	else
		sb->s_qcop = &f2fs_quotactl_ops;
C
Chao Yu 已提交
2548
	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
2549 2550 2551 2552 2553 2554 2555

	if (f2fs_sb_has_quota_ino(sbi->sb)) {
		for (i = 0; i < MAXQUOTAS; i++) {
			if (f2fs_qf_ino(sbi->sb, i))
				sbi->nquota_files++;
		}
	}
C
Chao Yu 已提交
2556 2557
#endif

J
Jaegeuk Kim 已提交
2558
	sb->s_op = &f2fs_sops;
2559
#ifdef CONFIG_F2FS_FS_ENCRYPTION
2560
	sb->s_cop = &f2fs_cryptops;
2561
#endif
J
Jaegeuk Kim 已提交
2562 2563 2564 2565
	sb->s_xattr = f2fs_xattr_handlers;
	sb->s_export_op = &f2fs_export_ops;
	sb->s_magic = F2FS_SUPER_MAGIC;
	sb->s_time_gran = 1;
2566 2567
	sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
		(test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
2568
	memcpy(&sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
2569
	sb->s_iflags |= SB_I_CGROUPWB;
J
Jaegeuk Kim 已提交
2570 2571

	/* init f2fs-specific super block info */
2572
	sbi->valid_super_block = valid_super_block;
J
Jaegeuk Kim 已提交
2573 2574
	mutex_init(&sbi->gc_mutex);
	mutex_init(&sbi->cp_mutex);
2575
	init_rwsem(&sbi->node_write);
2576
	init_rwsem(&sbi->node_change);
2577 2578 2579

	/* disallow all the data/node/meta page writes */
	set_sbi_flag(sbi, SBI_POR_DOING);
J
Jaegeuk Kim 已提交
2580
	spin_lock_init(&sbi->stat_lock);
2581

C
Chao Yu 已提交
2582 2583 2584 2585
	/* init iostat info */
	spin_lock_init(&sbi->iostat_lock);
	sbi->iostat_enable = false;

J
Jaegeuk Kim 已提交
2586
	for (i = 0; i < NR_PAGE_TYPE; i++) {
J
Jaegeuk Kim 已提交
2587 2588 2589
		int n = (i == META) ? 1: NR_TEMP_TYPE;
		int j;

C
Chao Yu 已提交
2590 2591 2592
		sbi->write_io[i] = f2fs_kmalloc(sbi,
					n * sizeof(struct f2fs_bio_info),
					GFP_KERNEL);
2593 2594
		if (!sbi->write_io[i]) {
			err = -ENOMEM;
J
Jaegeuk Kim 已提交
2595
			goto free_options;
2596
		}
J
Jaegeuk Kim 已提交
2597 2598 2599 2600 2601

		for (j = HOT; j < n; j++) {
			init_rwsem(&sbi->write_io[i][j].io_rwsem);
			sbi->write_io[i][j].sbi = sbi;
			sbi->write_io[i][j].bio = NULL;
2602 2603
			spin_lock_init(&sbi->write_io[i][j].io_lock);
			INIT_LIST_HEAD(&sbi->write_io[i][j].io_list);
J
Jaegeuk Kim 已提交
2604
		}
J
Jaegeuk Kim 已提交
2605
	}
2606

2607
	init_rwsem(&sbi->cp_rwsem);
2608
	init_waitqueue_head(&sbi->cp_wait);
J
Jaegeuk Kim 已提交
2609 2610
	init_sb_info(sbi);

2611 2612
	err = init_percpu_info(sbi);
	if (err)
2613
		goto free_bio_info;
2614

2615 2616
	if (F2FS_IO_SIZE(sbi) > 1) {
		sbi->write_io_dummy =
2617
			mempool_create_page_pool(2 * (F2FS_IO_SIZE(sbi) - 1), 0);
2618 2619
		if (!sbi->write_io_dummy) {
			err = -ENOMEM;
2620
			goto free_percpu;
2621
		}
2622 2623
	}

J
Jaegeuk Kim 已提交
2624 2625 2626
	/* get an inode for meta space */
	sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
	if (IS_ERR(sbi->meta_inode)) {
2627
		f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");
J
Jaegeuk Kim 已提交
2628
		err = PTR_ERR(sbi->meta_inode);
2629
		goto free_io_dummy;
J
Jaegeuk Kim 已提交
2630 2631 2632
	}

	err = get_valid_checkpoint(sbi);
2633 2634
	if (err) {
		f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");
J
Jaegeuk Kim 已提交
2635
		goto free_meta_inode;
2636
	}
J
Jaegeuk Kim 已提交
2637

J
Jaegeuk Kim 已提交
2638 2639 2640 2641 2642 2643 2644
	/* Initialize device list */
	err = f2fs_scan_devices(sbi);
	if (err) {
		f2fs_msg(sb, KERN_ERR, "Failed to find devices");
		goto free_devices;
	}

J
Jaegeuk Kim 已提交
2645 2646
	sbi->total_valid_node_count =
				le32_to_cpu(sbi->ckpt->valid_node_count);
2647 2648
	percpu_counter_set(&sbi->total_valid_inode_count,
				le32_to_cpu(sbi->ckpt->valid_inode_count));
J
Jaegeuk Kim 已提交
2649 2650 2651 2652
	sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
	sbi->total_valid_block_count =
				le64_to_cpu(sbi->ckpt->valid_block_count);
	sbi->last_valid_block_count = sbi->total_valid_block_count;
2653
	sbi->reserved_blocks = 0;
2654
	sbi->current_reserved_blocks = 0;
2655
	limit_reserve_root(sbi);
2656

2657 2658 2659 2660
	for (i = 0; i < NR_INODE_TYPE; i++) {
		INIT_LIST_HEAD(&sbi->inode_list[i]);
		spin_lock_init(&sbi->inode_lock[i]);
	}
J
Jaegeuk Kim 已提交
2661

C
Chao Yu 已提交
2662 2663
	init_extent_cache_info(sbi);

J
Jaegeuk Kim 已提交
2664
	init_ino_entry_info(sbi);
J
Jaegeuk Kim 已提交
2665 2666 2667

	/* setup f2fs internal modules */
	err = build_segment_manager(sbi);
2668 2669 2670
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS segment manager");
J
Jaegeuk Kim 已提交
2671
		goto free_sm;
2672
	}
J
Jaegeuk Kim 已提交
2673
	err = build_node_manager(sbi);
2674 2675 2676
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS node manager");
J
Jaegeuk Kim 已提交
2677
		goto free_nm;
2678
	}
J
Jaegeuk Kim 已提交
2679

2680 2681 2682 2683 2684 2685 2686 2687 2688
	/* For write statistics */
	if (sb->s_bdev->bd_part)
		sbi->sectors_written_start =
			(u64)part_stat_read(sb->s_bdev->bd_part, sectors[1]);

	/* Read accumulated write IO statistics if exists */
	seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
	if (__exist_node_summaries(sbi))
		sbi->kbytes_written =
2689
			le64_to_cpu(seg_i->journal->info.kbytes_written);
2690

J
Jaegeuk Kim 已提交
2691 2692 2693 2694 2695
	build_gc_manager(sbi);

	/* get an inode for node space */
	sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));
	if (IS_ERR(sbi->node_inode)) {
2696
		f2fs_msg(sb, KERN_ERR, "Failed to read node inode");
J
Jaegeuk Kim 已提交
2697 2698 2699 2700
		err = PTR_ERR(sbi->node_inode);
		goto free_nm;
	}

2701 2702
	err = f2fs_build_stats(sbi);
	if (err)
C
Chao Yu 已提交
2703
		goto free_node_inode;
2704

J
Jaegeuk Kim 已提交
2705 2706 2707
	/* read root inode and dentry */
	root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
	if (IS_ERR(root)) {
2708
		f2fs_msg(sb, KERN_ERR, "Failed to read root inode");
J
Jaegeuk Kim 已提交
2709
		err = PTR_ERR(root);
C
Chao Yu 已提交
2710
		goto free_stats;
J
Jaegeuk Kim 已提交
2711
	}
2712
	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
2713
		iput(root);
2714
		err = -EINVAL;
2715
		goto free_node_inode;
2716
	}
J
Jaegeuk Kim 已提交
2717 2718 2719 2720 2721 2722 2723

	sb->s_root = d_make_root(root); /* allocate root dentry */
	if (!sb->s_root) {
		err = -ENOMEM;
		goto free_root_inode;
	}

2724
	err = f2fs_register_sysfs(sbi);
2725
	if (err)
C
Chao Yu 已提交
2726
		goto free_root_inode;
2727

J
Jaegeuk Kim 已提交
2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741
#ifdef CONFIG_QUOTA
	/*
	 * Turn on quotas which were not enabled for read-only mounts if
	 * filesystem has quota feature, so that they are updated correctly.
	 */
	if (f2fs_sb_has_quota_ino(sb) && !sb_rdonly(sb)) {
		err = f2fs_enable_quotas(sb);
		if (err) {
			f2fs_msg(sb, KERN_ERR,
				"Cannot turn on quotas: error %d", err);
			goto free_sysfs;
		}
	}
#endif
C
Chao Yu 已提交
2742 2743 2744
	/* if there are nt orphan nodes free them */
	err = recover_orphan_inodes(sbi);
	if (err)
J
Jaegeuk Kim 已提交
2745
		goto free_meta;
C
Chao Yu 已提交
2746

2747 2748
	/* recover fsynced data */
	if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
2749 2750 2751 2752 2753
		/*
		 * mount should be failed, when device has readonly mode, and
		 * previous checkpoint was not done by clean system shutdown.
		 */
		if (bdev_read_only(sb->s_bdev) &&
2754
				!is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
2755
			err = -EROFS;
C
Chao Yu 已提交
2756
			goto free_meta;
2757
		}
2758 2759 2760 2761

		if (need_fsck)
			set_sbi_flag(sbi, SBI_NEED_FSCK);

2762 2763 2764
		if (!retry)
			goto skip_recovery;

2765 2766
		err = recover_fsync_data(sbi, false);
		if (err < 0) {
2767
			need_fsck = true;
2768
			f2fs_msg(sb, KERN_ERR,
2769
				"Cannot recover all fsync data errno=%d", err);
C
Chao Yu 已提交
2770
			goto free_meta;
2771
		}
2772 2773 2774 2775 2776 2777 2778
	} else {
		err = recover_fsync_data(sbi, true);

		if (!f2fs_readonly(sb) && err > 0) {
			err = -EINVAL;
			f2fs_msg(sb, KERN_ERR,
				"Need to recover fsync data");
J
Jaegeuk Kim 已提交
2779
			goto free_meta;
2780
		}
2781
	}
2782
skip_recovery:
2783 2784
	/* recover_fsync_data() cleared this already */
	clear_sbi_flag(sbi, SBI_POR_DOING);
2785

2786 2787 2788 2789
	/*
	 * If filesystem is not mounted as read-only then
	 * do start the gc_thread.
	 */
2790
	if (test_opt(sbi, BG_GC) && !f2fs_readonly(sb)) {
2791 2792 2793
		/* After POR, we can run background GC thread.*/
		err = start_gc_thread(sbi);
		if (err)
C
Chao Yu 已提交
2794
			goto free_meta;
2795
	}
2796
	kfree(options);
2797 2798

	/* recover broken superblock */
2799
	if (recovery) {
2800 2801
		err = f2fs_commit_super(sbi, true);
		f2fs_msg(sb, KERN_INFO,
2802
			"Try to recover %dth superblock, ret: %d",
2803
			sbi->valid_super_block ? 1 : 2, err);
2804 2805
	}

C
Chao Yu 已提交
2806 2807
	f2fs_join_shrinker(sbi);

2808 2809
	f2fs_msg(sbi->sb, KERN_NOTICE, "Mounted with checkpoint version = %llx",
				cur_cp_version(F2FS_CKPT(sbi)));
2810
	f2fs_update_time(sbi, CP_TIME);
2811
	f2fs_update_time(sbi, REQ_TIME);
J
Jaegeuk Kim 已提交
2812
	return 0;
2813

C
Chao Yu 已提交
2814
free_meta:
J
Jaegeuk Kim 已提交
2815 2816 2817 2818
#ifdef CONFIG_QUOTA
	if (f2fs_sb_has_quota_ino(sb) && !sb_rdonly(sb))
		f2fs_quota_off_umount(sbi->sb);
#endif
2819
	f2fs_sync_inode_meta(sbi);
C
Chao Yu 已提交
2820 2821 2822 2823 2824 2825 2826
	/*
	 * Some dirty meta pages can be produced by recover_orphan_inodes()
	 * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg()
	 * followed by write_checkpoint() through f2fs_write_node_pages(), which
	 * falls into an infinite loop in sync_meta_pages().
	 */
	truncate_inode_pages_final(META_MAPPING(sbi));
J
Jaegeuk Kim 已提交
2827
#ifdef CONFIG_QUOTA
C
Chao Yu 已提交
2828
free_sysfs:
J
Jaegeuk Kim 已提交
2829
#endif
2830
	f2fs_unregister_sysfs(sbi);
J
Jaegeuk Kim 已提交
2831 2832 2833
free_root_inode:
	dput(sb->s_root);
	sb->s_root = NULL;
C
Chao Yu 已提交
2834 2835
free_stats:
	f2fs_destroy_stats(sbi);
J
Jaegeuk Kim 已提交
2836
free_node_inode:
2837
	release_ino_entry(sbi, true);
C
Chao Yu 已提交
2838
	truncate_inode_pages_final(NODE_MAPPING(sbi));
J
Jaegeuk Kim 已提交
2839 2840 2841 2842 2843
	iput(sbi->node_inode);
free_nm:
	destroy_node_manager(sbi);
free_sm:
	destroy_segment_manager(sbi);
J
Jaegeuk Kim 已提交
2844 2845
free_devices:
	destroy_device_list(sbi);
J
Jaegeuk Kim 已提交
2846 2847 2848 2849
	kfree(sbi->ckpt);
free_meta_inode:
	make_bad_inode(sbi->meta_inode);
	iput(sbi->meta_inode);
2850 2851
free_io_dummy:
	mempool_destroy(sbi->write_io_dummy);
2852 2853 2854
free_percpu:
	destroy_percpu_info(sbi);
free_bio_info:
J
Jaegeuk Kim 已提交
2855 2856
	for (i = 0; i < NR_PAGE_TYPE; i++)
		kfree(sbi->write_io[i]);
2857
free_options:
C
Chao Yu 已提交
2858 2859 2860 2861
#ifdef CONFIG_QUOTA
	for (i = 0; i < MAXQUOTAS; i++)
		kfree(sbi->s_qf_names[i]);
#endif
2862
	kfree(options);
J
Jaegeuk Kim 已提交
2863
free_sb_buf:
Y
Yunlei He 已提交
2864
	kfree(raw_super);
J
Jaegeuk Kim 已提交
2865
free_sbi:
K
Keith Mok 已提交
2866 2867
	if (sbi->s_chksum_driver)
		crypto_free_shash(sbi->s_chksum_driver);
J
Jaegeuk Kim 已提交
2868
	kfree(sbi);
2869 2870 2871

	/* give only one another chance */
	if (retry) {
2872
		retry = false;
2873 2874 2875
		shrink_dcache_sb(sb);
		goto try_onemore;
	}
J
Jaegeuk Kim 已提交
2876 2877 2878 2879 2880 2881 2882 2883 2884
	return err;
}

static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
			const char *dev_name, void *data)
{
	return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
}

2885 2886
static void kill_f2fs_super(struct super_block *sb)
{
2887
	if (sb->s_root) {
2888
		set_sbi_flag(F2FS_SB(sb), SBI_IS_CLOSE);
2889 2890 2891
		stop_gc_thread(F2FS_SB(sb));
		stop_discard_thread(F2FS_SB(sb));
	}
2892 2893 2894
	kill_block_super(sb);
}

J
Jaegeuk Kim 已提交
2895 2896 2897 2898
static struct file_system_type f2fs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "f2fs",
	.mount		= f2fs_mount,
2899
	.kill_sb	= kill_f2fs_super,
J
Jaegeuk Kim 已提交
2900 2901
	.fs_flags	= FS_REQUIRES_DEV,
};
2902
MODULE_ALIAS_FS("f2fs");
J
Jaegeuk Kim 已提交
2903

2904
static int __init init_inodecache(void)
J
Jaegeuk Kim 已提交
2905
{
2906 2907 2908
	f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache",
			sizeof(struct f2fs_inode_info), 0,
			SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL);
2909
	if (!f2fs_inode_cachep)
J
Jaegeuk Kim 已提交
2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927
		return -ENOMEM;
	return 0;
}

static void destroy_inodecache(void)
{
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
	kmem_cache_destroy(f2fs_inode_cachep);
}

static int __init init_f2fs_fs(void)
{
	int err;

2928 2929
	f2fs_build_trace_ios();

J
Jaegeuk Kim 已提交
2930 2931 2932 2933 2934
	err = init_inodecache();
	if (err)
		goto fail;
	err = create_node_manager_caches();
	if (err)
2935
		goto free_inodecache;
2936
	err = create_segment_manager_caches();
J
Jaegeuk Kim 已提交
2937
	if (err)
2938
		goto free_node_manager_caches;
J
Jaegeuk Kim 已提交
2939 2940
	err = create_checkpoint_caches();
	if (err)
2941
		goto free_segment_manager_caches;
C
Chao Yu 已提交
2942 2943 2944
	err = create_extent_cache();
	if (err)
		goto free_checkpoint_caches;
2945
	err = f2fs_init_sysfs();
C
Chao Yu 已提交
2946
	if (err)
C
Chao Yu 已提交
2947
		goto free_extent_cache;
2948
	err = register_shrinker(&f2fs_shrinker_info);
2949
	if (err)
C
Chao Yu 已提交
2950
		goto free_sysfs;
2951 2952 2953
	err = register_filesystem(&f2fs_fs_type);
	if (err)
		goto free_shrinker;
2954 2955 2956
	err = f2fs_create_root_stats();
	if (err)
		goto free_filesystem;
2957 2958
	return 0;

2959 2960
free_filesystem:
	unregister_filesystem(&f2fs_fs_type);
2961 2962
free_shrinker:
	unregister_shrinker(&f2fs_shrinker_info);
C
Chao Yu 已提交
2963
free_sysfs:
2964
	f2fs_exit_sysfs();
C
Chao Yu 已提交
2965 2966
free_extent_cache:
	destroy_extent_cache();
2967 2968
free_checkpoint_caches:
	destroy_checkpoint_caches();
2969 2970
free_segment_manager_caches:
	destroy_segment_manager_caches();
2971 2972 2973 2974
free_node_manager_caches:
	destroy_node_manager_caches();
free_inodecache:
	destroy_inodecache();
J
Jaegeuk Kim 已提交
2975 2976 2977 2978 2979 2980
fail:
	return err;
}

static void __exit exit_f2fs_fs(void)
{
2981
	f2fs_destroy_root_stats();
J
Jaegeuk Kim 已提交
2982
	unregister_filesystem(&f2fs_fs_type);
T
Tiezhu Yang 已提交
2983
	unregister_shrinker(&f2fs_shrinker_info);
2984
	f2fs_exit_sysfs();
W
Wanpeng Li 已提交
2985
	destroy_extent_cache();
J
Jaegeuk Kim 已提交
2986
	destroy_checkpoint_caches();
2987
	destroy_segment_manager_caches();
J
Jaegeuk Kim 已提交
2988 2989
	destroy_node_manager_caches();
	destroy_inodecache();
2990
	f2fs_destroy_trace_ios();
J
Jaegeuk Kim 已提交
2991 2992 2993 2994 2995 2996 2997 2998
}

module_init(init_f2fs_fs)
module_exit(exit_f2fs_fs)

MODULE_AUTHOR("Samsung Electronics's Praesto Team");
MODULE_DESCRIPTION("Flash Friendly File System");
MODULE_LICENSE("GPL");
2999