super.c 41.3 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>
J
Jaegeuk Kim 已提交
25
#include <linux/f2fs_fs.h>
26
#include <linux/sysfs.h>
J
Jaegeuk Kim 已提交
27 28 29

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

35 36 37
#define CREATE_TRACE_POINTS
#include <trace/events/f2fs.h>

38
static struct proc_dir_entry *f2fs_proc_root;
J
Jaegeuk Kim 已提交
39
static struct kmem_cache *f2fs_inode_cachep;
40
static struct kset *f2fs_kset;
J
Jaegeuk Kim 已提交
41

42 43 44 45 46 47 48
/* 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 已提交
49
enum {
50
	Opt_gc_background,
J
Jaegeuk Kim 已提交
51
	Opt_disable_roll_forward,
52
	Opt_norecovery,
J
Jaegeuk Kim 已提交
53 54
	Opt_discard,
	Opt_noheap,
55
	Opt_user_xattr,
J
Jaegeuk Kim 已提交
56
	Opt_nouser_xattr,
57
	Opt_acl,
J
Jaegeuk Kim 已提交
58 59 60
	Opt_noacl,
	Opt_active_logs,
	Opt_disable_ext_identify,
J
Jaegeuk Kim 已提交
61
	Opt_inline_xattr,
62
	Opt_inline_data,
63
	Opt_inline_dentry,
64
	Opt_flush_merge,
J
Jaegeuk Kim 已提交
65
	Opt_nobarrier,
66
	Opt_fastboot,
67
	Opt_extent_cache,
68
	Opt_noextent_cache,
W
Wanpeng Li 已提交
69
	Opt_noinline_data,
J
Jaegeuk Kim 已提交
70 71 72 73
	Opt_err,
};

static match_table_t f2fs_tokens = {
74
	{Opt_gc_background, "background_gc=%s"},
J
Jaegeuk Kim 已提交
75
	{Opt_disable_roll_forward, "disable_roll_forward"},
76
	{Opt_norecovery, "norecovery"},
J
Jaegeuk Kim 已提交
77 78
	{Opt_discard, "discard"},
	{Opt_noheap, "no_heap"},
79
	{Opt_user_xattr, "user_xattr"},
J
Jaegeuk Kim 已提交
80
	{Opt_nouser_xattr, "nouser_xattr"},
81
	{Opt_acl, "acl"},
J
Jaegeuk Kim 已提交
82 83 84
	{Opt_noacl, "noacl"},
	{Opt_active_logs, "active_logs=%u"},
	{Opt_disable_ext_identify, "disable_ext_identify"},
J
Jaegeuk Kim 已提交
85
	{Opt_inline_xattr, "inline_xattr"},
86
	{Opt_inline_data, "inline_data"},
87
	{Opt_inline_dentry, "inline_dentry"},
88
	{Opt_flush_merge, "flush_merge"},
J
Jaegeuk Kim 已提交
89
	{Opt_nobarrier, "nobarrier"},
90
	{Opt_fastboot, "fastboot"},
91
	{Opt_extent_cache, "extent_cache"},
92
	{Opt_noextent_cache, "noextent_cache"},
W
Wanpeng Li 已提交
93
	{Opt_noinline_data, "noinline_data"},
J
Jaegeuk Kim 已提交
94 95 96
	{Opt_err, NULL},
};

97
/* Sysfs support for f2fs */
98 99 100
enum {
	GC_THREAD,	/* struct f2fs_gc_thread */
	SM_INFO,	/* struct f2fs_sm_info */
101
	NM_INFO,	/* struct f2fs_nm_info */
102
	F2FS_SBI,	/* struct f2fs_sb_info */
103 104
};

105 106 107 108 109
struct f2fs_attr {
	struct attribute attr;
	ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *);
	ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *,
			 const char *, size_t);
110
	int struct_type;
111 112 113
	int offset;
};

114 115 116 117 118 119
static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type)
{
	if (struct_type == GC_THREAD)
		return (unsigned char *)sbi->gc_thread;
	else if (struct_type == SM_INFO)
		return (unsigned char *)SM_I(sbi);
120 121
	else if (struct_type == NM_INFO)
		return (unsigned char *)NM_I(sbi);
122 123
	else if (struct_type == F2FS_SBI)
		return (unsigned char *)sbi;
124 125 126
	return NULL;
}

127 128 129
static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
			struct f2fs_sb_info *sbi, char *buf)
{
130
	unsigned char *ptr = NULL;
131 132
	unsigned int *ui;

133 134
	ptr = __struct_ptr(sbi, a->struct_type);
	if (!ptr)
135 136
		return -EINVAL;

137
	ui = (unsigned int *)(ptr + a->offset);
138 139 140 141 142 143 144 145

	return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
}

static ssize_t f2fs_sbi_store(struct f2fs_attr *a,
			struct f2fs_sb_info *sbi,
			const char *buf, size_t count)
{
146
	unsigned char *ptr;
147 148 149 150
	unsigned long t;
	unsigned int *ui;
	ssize_t ret;

151 152
	ptr = __struct_ptr(sbi, a->struct_type);
	if (!ptr)
153 154
		return -EINVAL;

155
	ui = (unsigned int *)(ptr + a->offset);
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190

	ret = kstrtoul(skip_spaces(buf), 0, &t);
	if (ret < 0)
		return ret;
	*ui = t;
	return count;
}

static ssize_t f2fs_attr_show(struct kobject *kobj,
				struct attribute *attr, char *buf)
{
	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
								s_kobj);
	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);

	return a->show ? a->show(a, sbi, buf) : 0;
}

static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr,
						const char *buf, size_t len)
{
	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
									s_kobj);
	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);

	return a->store ? a->store(a, sbi, buf, len) : 0;
}

static void f2fs_sb_release(struct kobject *kobj)
{
	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
								s_kobj);
	complete(&sbi->s_kobj_unregister);
}

191
#define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
192 193 194 195
static struct f2fs_attr f2fs_attr_##_name = {			\
	.attr = {.name = __stringify(_name), .mode = _mode },	\
	.show	= _show,					\
	.store	= _store,					\
196 197
	.struct_type = _struct_type,				\
	.offset = _offset					\
198 199
}

200 201 202 203
#define F2FS_RW_ATTR(struct_type, struct_name, name, elname)	\
	F2FS_ATTR_OFFSET(struct_type, name, 0644,		\
		f2fs_sbi_show, f2fs_sbi_store,			\
		offsetof(struct struct_name, elname))
204

205 206 207 208 209
F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time);
F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time);
F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time);
F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_idle, gc_idle);
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments);
210
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, max_small_discards, max_discards);
J
Jaegeuk Kim 已提交
211
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);
212 213
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy);
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
214
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
215
F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
C
Chao Yu 已提交
216
F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
217
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
218
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
219
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, cp_interval);
220 221 222 223 224 225

#define ATTR_LIST(name) (&f2fs_attr_##name.attr)
static struct attribute *f2fs_attrs[] = {
	ATTR_LIST(gc_min_sleep_time),
	ATTR_LIST(gc_max_sleep_time),
	ATTR_LIST(gc_no_gc_sleep_time),
226
	ATTR_LIST(gc_idle),
227
	ATTR_LIST(reclaim_segments),
228
	ATTR_LIST(max_small_discards),
J
Jaegeuk Kim 已提交
229
	ATTR_LIST(batched_trim_sections),
230 231
	ATTR_LIST(ipu_policy),
	ATTR_LIST(min_ipu_util),
232
	ATTR_LIST(min_fsync_blocks),
233
	ATTR_LIST(max_victim_search),
234
	ATTR_LIST(dir_level),
235
	ATTR_LIST(ram_thresh),
C
Chao Yu 已提交
236
	ATTR_LIST(ra_nid_pages),
237
	ATTR_LIST(cp_interval),
238 239 240 241 242 243 244 245 246 247 248 249 250 251
	NULL,
};

static const struct sysfs_ops f2fs_attr_ops = {
	.show	= f2fs_attr_show,
	.store	= f2fs_attr_store,
};

static struct kobj_type f2fs_ktype = {
	.default_attrs	= f2fs_attrs,
	.sysfs_ops	= &f2fs_attr_ops,
	.release	= f2fs_sb_release,
};

252 253 254 255 256 257 258 259 260 261 262 263
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;
	printk("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf);
	va_end(args);
}

J
Jaegeuk Kim 已提交
264 265 266 267 268 269 270
static void init_once(void *foo)
{
	struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;

	inode_init_once(&fi->vfs_inode);
}

271 272 273
static int parse_options(struct super_block *sb, char *options)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
274
	struct request_queue *q;
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
	substring_t args[MAX_OPT_ARGS];
	char *p, *name;
	int arg = 0;

	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;
299
			if (strlen(name) == 2 && !strncmp(name, "on", 2)) {
300
				set_opt(sbi, BG_GC);
301 302
				clear_opt(sbi, FORCE_FG_GC);
			} else if (strlen(name) == 3 && !strncmp(name, "off", 3)) {
303
				clear_opt(sbi, BG_GC);
304 305 306 307 308
				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 {
309 310 311 312 313 314 315 316
				kfree(name);
				return -EINVAL;
			}
			kfree(name);
			break;
		case Opt_disable_roll_forward:
			set_opt(sbi, DISABLE_ROLL_FORWARD);
			break;
317 318 319 320 321 322
		case Opt_norecovery:
			/* this option mounts f2fs with ro */
			set_opt(sbi, DISABLE_ROLL_FORWARD);
			if (!f2fs_readonly(sb))
				return -EINVAL;
			break;
323
		case Opt_discard:
324 325 326 327 328 329 330 331
			q = bdev_get_queue(sb->s_bdev);
			if (blk_queue_discard(q)) {
				set_opt(sbi, DISCARD);
			} else {
				f2fs_msg(sb, KERN_WARNING,
					"mounting with \"discard\" option, but "
					"the device does not support discard");
			}
332 333 334 335 336
			break;
		case Opt_noheap:
			set_opt(sbi, NOHEAP);
			break;
#ifdef CONFIG_F2FS_FS_XATTR
337 338 339
		case Opt_user_xattr:
			set_opt(sbi, XATTR_USER);
			break;
340 341 342
		case Opt_nouser_xattr:
			clear_opt(sbi, XATTR_USER);
			break;
J
Jaegeuk Kim 已提交
343 344 345
		case Opt_inline_xattr:
			set_opt(sbi, INLINE_XATTR);
			break;
346
#else
347 348 349 350
		case Opt_user_xattr:
			f2fs_msg(sb, KERN_INFO,
				"user_xattr options not supported");
			break;
351 352 353 354
		case Opt_nouser_xattr:
			f2fs_msg(sb, KERN_INFO,
				"nouser_xattr options not supported");
			break;
J
Jaegeuk Kim 已提交
355 356 357 358
		case Opt_inline_xattr:
			f2fs_msg(sb, KERN_INFO,
				"inline_xattr options not supported");
			break;
359 360
#endif
#ifdef CONFIG_F2FS_FS_POSIX_ACL
361 362 363
		case Opt_acl:
			set_opt(sbi, POSIX_ACL);
			break;
364 365 366 367
		case Opt_noacl:
			clear_opt(sbi, POSIX_ACL);
			break;
#else
368 369 370
		case Opt_acl:
			f2fs_msg(sb, KERN_INFO, "acl options not supported");
			break;
371 372 373 374 375 376 377 378 379 380 381 382 383 384
		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;
385 386 387
		case Opt_inline_data:
			set_opt(sbi, INLINE_DATA);
			break;
388 389 390
		case Opt_inline_dentry:
			set_opt(sbi, INLINE_DENTRY);
			break;
391 392 393
		case Opt_flush_merge:
			set_opt(sbi, FLUSH_MERGE);
			break;
J
Jaegeuk Kim 已提交
394 395 396
		case Opt_nobarrier:
			set_opt(sbi, NOBARRIER);
			break;
397 398 399
		case Opt_fastboot:
			set_opt(sbi, FASTBOOT);
			break;
400 401 402
		case Opt_extent_cache:
			set_opt(sbi, EXTENT_CACHE);
			break;
403 404 405
		case Opt_noextent_cache:
			clear_opt(sbi, EXTENT_CACHE);
			break;
W
Wanpeng Li 已提交
406 407 408
		case Opt_noinline_data:
			clear_opt(sbi, INLINE_DATA);
			break;
409 410 411 412 413 414 415 416 417 418
		default:
			f2fs_msg(sb, KERN_ERR,
				"Unrecognized mount option \"%s\" or missing value",
				p);
			return -EINVAL;
		}
	}
	return 0;
}

J
Jaegeuk Kim 已提交
419 420 421 422
static struct inode *f2fs_alloc_inode(struct super_block *sb)
{
	struct f2fs_inode_info *fi;

423
	fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
J
Jaegeuk Kim 已提交
424 425 426 427 428
	if (!fi)
		return NULL;

	init_once((void *) fi);

M
Masanari Iida 已提交
429
	/* Initialize f2fs-specific inode info */
J
Jaegeuk Kim 已提交
430
	fi->vfs_inode.i_version = 1;
431
	atomic_set(&fi->dirty_pages, 0);
J
Jaegeuk Kim 已提交
432 433
	fi->i_current_depth = 1;
	fi->i_advise = 0;
434
	init_rwsem(&fi->i_sem);
435
	INIT_LIST_HEAD(&fi->dirty_list);
J
Jaegeuk Kim 已提交
436 437
	INIT_LIST_HEAD(&fi->inmem_pages);
	mutex_init(&fi->inmem_lock);
J
Jaegeuk Kim 已提交
438 439 440

	set_inode_flag(fi, FI_NEW_INODE);

J
Jaegeuk Kim 已提交
441 442 443
	if (test_opt(F2FS_SB(sb), INLINE_XATTR))
		set_inode_flag(fi, FI_INLINE_XATTR);

444 445 446
	/* Will be used by directory only */
	fi->i_dir_level = F2FS_SB(sb)->dir_level;

447 448 449
#ifdef CONFIG_F2FS_FS_ENCRYPTION
	fi->i_crypt_info = NULL;
#endif
J
Jaegeuk Kim 已提交
450 451 452
	return &fi->vfs_inode;
}

453 454 455 456 457 458 459 460 461
static int f2fs_drop_inode(struct inode *inode)
{
	/*
	 * 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)
	 */
462 463
	if (!inode_unhashed(inode) && inode->i_state & I_SYNC) {
		if (!inode->i_nlink && !is_bad_inode(inode)) {
J
Jaegeuk Kim 已提交
464 465
			/* to avoid evict_inode call simultaneously */
			atomic_inc(&inode->i_count);
466 467 468 469 470 471
			spin_unlock(&inode->i_lock);

			/* some remained atomic pages should discarded */
			if (f2fs_is_atomic_file(inode))
				commit_inmem_pages(inode, true);

J
Jaegeuk Kim 已提交
472 473 474
			/* should remain fi->extent_tree for writepage */
			f2fs_destroy_extent_node(inode);

475 476 477 478
			sb_start_intwrite(inode->i_sb);
			i_size_write(inode, 0);

			if (F2FS_HAS_BLOCKS(inode))
479
				f2fs_truncate(inode, true);
480 481 482 483 484

			sb_end_intwrite(inode->i_sb);

#ifdef CONFIG_F2FS_FS_ENCRYPTION
			if (F2FS_I(inode)->i_crypt_info)
485 486
				f2fs_free_encryption_info(inode,
					F2FS_I(inode)->i_crypt_info);
487 488
#endif
			spin_lock(&inode->i_lock);
J
Jaegeuk Kim 已提交
489
			atomic_dec(&inode->i_count);
490
		}
491
		return 0;
492
	}
493 494 495
	return generic_drop_inode(inode);
}

496 497 498 499 500 501 502 503 504 505
/*
 * 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)
{
	set_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
}

J
Jaegeuk Kim 已提交
506 507 508 509 510 511
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));
}

512
static void f2fs_destroy_inode(struct inode *inode)
J
Jaegeuk Kim 已提交
513 514 515 516 517 518 519 520
{
	call_rcu(&inode->i_rcu, f2fs_i_callback);
}

static void f2fs_put_super(struct super_block *sb)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);

521 522 523 524
	if (sbi->s_proc) {
		remove_proc_entry("segment_info", sbi->s_proc);
		remove_proc_entry(sb->s_id, f2fs_proc_root);
	}
525
	kobject_del(&sbi->s_kobj);
526

J
Jaegeuk Kim 已提交
527 528
	stop_gc_thread(sbi);

529 530 531
	/* prevent remaining shrinker jobs */
	mutex_lock(&sbi->umount_mutex);

532 533 534 535 536
	/*
	 * 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.
	 */
537
	if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
538
			!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG)) {
539 540 541 542 543
		struct cp_control cpc = {
			.reason = CP_UMOUNT,
		};
		write_checkpoint(sbi, &cpc);
	}
J
Jaegeuk Kim 已提交
544

J
Jaegeuk Kim 已提交
545 546 547
	/* write_checkpoint can update stat informaion */
	f2fs_destroy_stats(sbi);

548 549 550 551
	/*
	 * normally superblock is clean, so we need to release this.
	 * In addition, EIO will skip do checkpoint, we need this as well.
	 */
552
	release_ino_entry(sbi);
553
	release_discard_addrs(sbi);
554

555 556 557
	f2fs_leave_shrinker(sbi);
	mutex_unlock(&sbi->umount_mutex);

J
Jaegeuk Kim 已提交
558 559 560 561 562 563 564 565
	iput(sbi->node_inode);
	iput(sbi->meta_inode);

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

	kfree(sbi->ckpt);
566 567
	kobject_put(&sbi->s_kobj);
	wait_for_completion(&sbi->s_kobj_unregister);
J
Jaegeuk Kim 已提交
568 569 570

	sb->s_fs_info = NULL;
	brelse(sbi->raw_super_buf);
Y
Yunlei He 已提交
571
	kfree(sbi->raw_super);
J
Jaegeuk Kim 已提交
572 573 574 575 576 577 578
	kfree(sbi);
}

int f2fs_sync_fs(struct super_block *sb, int sync)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);

579 580
	trace_f2fs_sync_fs(sb, sync);

581
	if (sync) {
582 583
		struct cp_control cpc;

584 585
		cpc.reason = __get_cp_reason(sbi);

586
		mutex_lock(&sbi->gc_mutex);
587
		write_checkpoint(sbi, &cpc);
588 589
		mutex_unlock(&sbi->gc_mutex);
	} else {
590
		f2fs_balance_fs(sbi);
591
	}
592
	f2fs_trace_ios(NULL, 1);
J
Jaegeuk Kim 已提交
593

594
	return 0;
J
Jaegeuk Kim 已提交
595 596
}

597 598 599 600
static int f2fs_freeze(struct super_block *sb)
{
	int err;

J
Jaegeuk Kim 已提交
601
	if (f2fs_readonly(sb))
602 603 604 605 606 607 608 609 610 611 612
		return 0;

	err = f2fs_sync_fs(sb, 1);
	return err;
}

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

J
Jaegeuk Kim 已提交
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
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);
	block_t total_count, user_block_count, start_count, ovp_count;

	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);
	ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg;
	buf->f_type = F2FS_SUPER_MAGIC;
	buf->f_bsize = sbi->blocksize;

	buf->f_blocks = total_count - start_count;
	buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count;
	buf->f_bavail = user_block_count - valid_user_blocks(sbi);

631 632
	buf->f_files = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
	buf->f_ffree = buf->f_files - valid_inode_count(sbi);
J
Jaegeuk Kim 已提交
633

634
	buf->f_namelen = F2FS_NAME_LEN;
J
Jaegeuk Kim 已提交
635 636 637 638 639 640 641 642 643 644
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);

	return 0;
}

static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
{
	struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);

645 646 647 648 649 650
	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 {
651
		seq_printf(seq, ",background_gc=%s", "off");
652
	}
J
Jaegeuk Kim 已提交
653 654 655 656 657 658 659 660 661 662 663
	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))
		seq_puts(seq, ",no_heap_alloc");
#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 已提交
664 665
	if (test_opt(sbi, INLINE_XATTR))
		seq_puts(seq, ",inline_xattr");
J
Jaegeuk Kim 已提交
666 667 668 669 670 671 672 673
#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))
674
		seq_puts(seq, ",disable_ext_identify");
675 676
	if (test_opt(sbi, INLINE_DATA))
		seq_puts(seq, ",inline_data");
W
Wanpeng Li 已提交
677 678
	else
		seq_puts(seq, ",noinline_data");
679 680
	if (test_opt(sbi, INLINE_DENTRY))
		seq_puts(seq, ",inline_dentry");
681
	if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
682
		seq_puts(seq, ",flush_merge");
J
Jaegeuk Kim 已提交
683 684
	if (test_opt(sbi, NOBARRIER))
		seq_puts(seq, ",nobarrier");
685 686
	if (test_opt(sbi, FASTBOOT))
		seq_puts(seq, ",fastboot");
687 688
	if (test_opt(sbi, EXTENT_CACHE))
		seq_puts(seq, ",extent_cache");
689 690
	else
		seq_puts(seq, ",noextent_cache");
J
Jaegeuk Kim 已提交
691 692 693 694 695
	seq_printf(seq, ",active_logs=%u", sbi->active_logs);

	return 0;
}

696 697 698 699
static int segment_info_seq_show(struct seq_file *seq, void *offset)
{
	struct super_block *sb = seq->private;
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
C
Chris Fries 已提交
700 701
	unsigned int total_segs =
			le32_to_cpu(sbi->raw_super->segment_count_main);
702 703
	int i;

704 705 706
	seq_puts(seq, "format: segment_type|valid_blocks\n"
		"segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");

707
	for (i = 0; i < total_segs; i++) {
708 709 710
		struct seg_entry *se = get_seg_entry(sbi, i);

		if ((i % 10) == 0)
Y
Yunlei He 已提交
711
			seq_printf(seq, "%-10d", i);
712 713
		seq_printf(seq, "%d|%-3u", se->type,
					get_valid_blocks(sbi, i, 1));
714 715
		if ((i % 10) == 9 || i == (total_segs - 1))
			seq_putc(seq, '\n');
716
		else
717
			seq_putc(seq, ' ');
718
	}
719

720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
	return 0;
}

static int segment_info_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, segment_info_seq_show, PDE_DATA(inode));
}

static const struct file_operations f2fs_seq_segment_info_fops = {
	.owner = THIS_MODULE,
	.open = segment_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

736 737 738 739 740 741 742
static void default_options(struct f2fs_sb_info *sbi)
{
	/* init some FS parameters */
	sbi->active_logs = NR_CURSEG_TYPE;

	set_opt(sbi, BG_GC);
	set_opt(sbi, INLINE_DATA);
J
Jaegeuk Kim 已提交
743
	set_opt(sbi, EXTENT_CACHE);
744 745 746 747 748 749 750 751 752

#ifdef CONFIG_F2FS_FS_XATTR
	set_opt(sbi, XATTR_USER);
#endif
#ifdef CONFIG_F2FS_FS_POSIX_ACL
	set_opt(sbi, POSIX_ACL);
#endif
}

753 754 755 756 757
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;
	int err, active_logs;
758 759
	bool need_restart_gc = false;
	bool need_stop_gc = false;
760
	bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
761

762 763
	sync_filesystem(sb);

764 765 766 767 768 769 770
	/*
	 * Save the old mount options in case we
	 * need to restore them.
	 */
	org_mount_opt = sbi->mount_opt;
	active_logs = sbi->active_logs;

771
	sbi->mount_opt.opt = 0;
772
	default_options(sbi);
773

774 775 776 777 778 779 780
	/* parse mount options */
	err = parse_options(sb, data);
	if (err)
		goto restore_opts;

	/*
	 * Previous and new state of filesystem is RO,
781
	 * so skip checking GC and FLUSH_MERGE conditions.
782
	 */
783
	if (f2fs_readonly(sb) && (*flags & MS_RDONLY))
784 785
		goto skip;

786 787 788 789 790 791 792 793
	/* 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;
	}

794 795 796 797 798 799 800 801 802
	/*
	 * 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.
	 */
	if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) {
		if (sbi->gc_thread) {
			stop_gc_thread(sbi);
			f2fs_sync_fs(sb, 1);
803
			need_restart_gc = true;
804
		}
805
	} else if (!sbi->gc_thread) {
806 807 808
		err = start_gc_thread(sbi);
		if (err)
			goto restore_opts;
809 810 811 812 813 814 815 816
		need_stop_gc = true;
	}

	/*
	 * We stop issue flush thread if FS is mounted as RO
	 * or if flush_merge is not passed in mount option.
	 */
	if ((*flags & MS_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
817
		destroy_flush_cmd_control(sbi);
818
	} else if (!SM_I(sbi)->cmd_control_info) {
819 820
		err = create_flush_cmd_control(sbi);
		if (err)
821
			goto restore_gc;
822 823 824 825 826 827
	}
skip:
	/* Update the POSIXACL Flag */
	 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
		(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
	return 0;
828 829 830 831
restore_gc:
	if (need_restart_gc) {
		if (start_gc_thread(sbi))
			f2fs_msg(sbi->sb, KERN_WARNING,
A
arter97 已提交
832
				"background gc thread has stopped");
833 834 835
	} else if (need_stop_gc) {
		stop_gc_thread(sbi);
	}
836 837 838 839 840 841
restore_opts:
	sbi->mount_opt = org_mount_opt;
	sbi->active_logs = active_logs;
	return err;
}

J
Jaegeuk Kim 已提交
842 843
static struct super_operations f2fs_sops = {
	.alloc_inode	= f2fs_alloc_inode,
844
	.drop_inode	= f2fs_drop_inode,
J
Jaegeuk Kim 已提交
845 846
	.destroy_inode	= f2fs_destroy_inode,
	.write_inode	= f2fs_write_inode,
847
	.dirty_inode	= f2fs_dirty_inode,
J
Jaegeuk Kim 已提交
848 849 850 851
	.show_options	= f2fs_show_options,
	.evict_inode	= f2fs_evict_inode,
	.put_super	= f2fs_put_super,
	.sync_fs	= f2fs_sync_fs,
852 853
	.freeze_fs	= f2fs_freeze,
	.unfreeze_fs	= f2fs_unfreeze,
J
Jaegeuk Kim 已提交
854
	.statfs		= f2fs_statfs,
855
	.remount_fs	= f2fs_remount,
J
Jaegeuk Kim 已提交
856 857 858 859 860 861 862 863
};

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;

864
	if (check_nid_range(sbi, ino))
865
		return ERR_PTR(-ESTALE);
J
Jaegeuk Kim 已提交
866 867 868 869 870 871 872 873 874

	/*
	 * 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);
875
	if (unlikely(generation && inode->i_generation != generation)) {
J
Jaegeuk Kim 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
		/* 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,
};

static loff_t max_file_size(unsigned bits)
{
905
	loff_t result = (DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS);
J
Jaegeuk Kim 已提交
906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
	loff_t leaf_count = ADDRS_PER_BLOCK;

	/* 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;

	result <<= bits;
	return result;
}

923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995
static inline bool sanity_check_area_boundary(struct super_block *sb,
					struct f2fs_super_block *raw_super)
{
	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);

	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;
	}

	if (main_blkaddr + (segment_count_main << log_blocks_per_seg) !=
		segment0_blkaddr + (segment_count << log_blocks_per_seg)) {
		f2fs_msg(sb, KERN_INFO,
			"Wrong MAIN_AREA boundary, start(%u) end(%u) blocks(%u)",
			main_blkaddr,
			segment0_blkaddr + (segment_count << log_blocks_per_seg),
			segment_count_main << log_blocks_per_seg);
		return true;
	}

	return false;
}

996 997
static int sanity_check_raw_super(struct super_block *sb,
			struct f2fs_super_block *raw_super)
J
Jaegeuk Kim 已提交
998 999 1000
{
	unsigned int blocksize;

1001 1002 1003 1004
	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 已提交
1005
		return 1;
1006
	}
J
Jaegeuk Kim 已提交
1007

1008 1009 1010
	/* Currently, support only 4KB page cache size */
	if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) {
		f2fs_msg(sb, KERN_INFO,
1011
			"Invalid page_cache_size (%lu), supports only 4KB\n",
1012 1013 1014 1015
			PAGE_CACHE_SIZE);
		return 1;
	}

J
Jaegeuk Kim 已提交
1016 1017
	/* Currently, support only 4KB block size */
	blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
1018
	if (blocksize != F2FS_BLKSIZE) {
1019 1020 1021
		f2fs_msg(sb, KERN_INFO,
			"Invalid blocksize (%u), supports only 4KB\n",
			blocksize);
J
Jaegeuk Kim 已提交
1022
		return 1;
1023
	}
1024

1025 1026 1027 1028 1029 1030 1031 1032
	/* 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 已提交
1033 1034 1035 1036 1037 1038 1039
	/* 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 已提交
1040
		return 1;
1041
	}
C
Chao Yu 已提交
1042 1043 1044 1045 1046 1047 1048
	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 已提交
1049
		return 1;
1050
	}
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067

	/* 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;
	}

	/* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */
	if (sanity_check_area_boundary(sb, raw_super))
		return 1;

J
Jaegeuk Kim 已提交
1068 1069 1070
	return 0;
}

1071
static int sanity_check_ckpt(struct f2fs_sb_info *sbi)
J
Jaegeuk Kim 已提交
1072 1073
{
	unsigned int total, fsmeta;
1074 1075
	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
J
Jaegeuk Kim 已提交
1076 1077 1078 1079 1080 1081 1082 1083

	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);

1084
	if (unlikely(fsmeta >= total))
J
Jaegeuk Kim 已提交
1085
		return 1;
1086

1087
	if (unlikely(f2fs_cp_error(sbi))) {
1088 1089 1090
		f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
		return 1;
	}
J
Jaegeuk Kim 已提交
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
	return 0;
}

static void init_sb_info(struct f2fs_sb_info *sbi)
{
	struct f2fs_super_block *raw_super = sbi->raw_super;
	int i;

	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);
1114
	sbi->cur_victim_sec = NULL_SECNO;
1115
	sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
J
Jaegeuk Kim 已提交
1116 1117 1118

	for (i = 0; i < NR_COUNT_TYPE; i++)
		atomic_set(&sbi->nr_pages[i], 0);
1119 1120

	sbi->dir_level = DEF_DIR_LEVEL;
1121
	sbi->cp_interval = DEF_CP_INTERVAL;
1122
	clear_sbi_flag(sbi, SBI_NEED_FSCK);
1123 1124 1125

	INIT_LIST_HEAD(&sbi->s_list);
	mutex_init(&sbi->umount_mutex);
J
Jaegeuk Kim 已提交
1126 1127
}

1128 1129 1130 1131 1132 1133 1134
/*
 * Read f2fs raw super block.
 * Because we have two copies of super block, so read the first one at first,
 * if the first one is invalid, move to read the second one.
 */
static int read_raw_super_block(struct super_block *sb,
			struct f2fs_super_block **raw_super,
1135 1136
			struct buffer_head **raw_super_buf,
			int *recovery)
1137
{
1138
	int block = 0;
1139 1140 1141
	struct buffer_head *buffer;
	struct f2fs_super_block *super;
	int err = 0;
1142

Y
Yunlei He 已提交
1143 1144 1145
	super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);
	if (!super)
		return -ENOMEM;
1146
retry:
1147 1148 1149
	buffer = sb_bread(sb, block);
	if (!buffer) {
		*recovery = 1;
1150 1151 1152 1153 1154 1155
		f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
				block + 1);
		if (block == 0) {
			block++;
			goto retry;
		} else {
1156 1157
			err = -EIO;
			goto out;
1158
		}
1159 1160
	}

Y
Yunlei He 已提交
1161
	memcpy(super, buffer->b_data + F2FS_SUPER_OFFSET, sizeof(*super));
1162 1163

	/* sanity checking of raw super */
1164 1165 1166
	if (sanity_check_raw_super(sb, super)) {
		brelse(buffer);
		*recovery = 1;
C
Chris Fries 已提交
1167 1168 1169
		f2fs_msg(sb, KERN_ERR,
			"Can't find valid F2FS filesystem in %dth superblock",
								block + 1);
1170
		if (block == 0) {
1171 1172 1173
			block++;
			goto retry;
		} else {
1174 1175
			err = -EINVAL;
			goto out;
1176 1177
		}
	}
1178

1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
	if (!*raw_super) {
		*raw_super_buf = buffer;
		*raw_super = super;
	} else {
		/* already have a valid superblock */
		brelse(buffer);
	}

	/* check the validity of the second superblock */
	if (block == 0) {
		block++;
		goto retry;
	}

out:
	/* No valid superblock */
Y
Yunlei He 已提交
1195 1196
	if (!*raw_super) {
		kfree(super);
1197
		return err;
Y
Yunlei He 已提交
1198
	}
1199

1200
	return 0;
1201 1202
}

C
Chao Yu 已提交
1203
int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)
J
Jaegeuk Kim 已提交
1204
{
Y
Yunlei He 已提交
1205
	struct f2fs_super_block *super = F2FS_RAW_SUPER(sbi);
J
Jaegeuk Kim 已提交
1206
	struct buffer_head *sbh = sbi->raw_super_buf;
J
Jaegeuk Kim 已提交
1207
	struct buffer_head *bh;
J
Jaegeuk Kim 已提交
1208 1209 1210
	int err;

	/* write back-up superblock first */
J
Jaegeuk Kim 已提交
1211 1212 1213
	bh = sb_getblk(sbi->sb, sbh->b_blocknr ? 0 : 1);
	if (!bh)
		return -EIO;
J
Jaegeuk Kim 已提交
1214

J
Jaegeuk Kim 已提交
1215
	lock_buffer(bh);
Y
Yunlei He 已提交
1216
	memcpy(bh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super));
J
Jaegeuk Kim 已提交
1217 1218 1219 1220 1221 1222 1223 1224
	WARN_ON(sbh->b_size != F2FS_BLKSIZE);
	set_buffer_uptodate(bh);
	set_buffer_dirty(bh);
	unlock_buffer(bh);

	/* it's rare case, we can do fua all the time */
	err = __sync_dirty_buffer(bh, WRITE_FLUSH_FUA);
	brelse(bh);
C
Chao Yu 已提交
1225 1226 1227

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

	/* write current valid superblock */
J
Jaegeuk Kim 已提交
1231
	lock_buffer(sbh);
Y
Yunlei He 已提交
1232 1233 1234 1235
	if (memcmp(sbh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super))) {
		f2fs_msg(sbi->sb, KERN_INFO, "Write modified valid superblock");
		memcpy(sbh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super));
	}
J
Jaegeuk Kim 已提交
1236 1237 1238 1239
	set_buffer_dirty(sbh);
	unlock_buffer(sbh);

	return __sync_dirty_buffer(sbh, WRITE_FLUSH_FUA);
J
Jaegeuk Kim 已提交
1240 1241
}

J
Jaegeuk Kim 已提交
1242 1243 1244
static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct f2fs_sb_info *sbi;
1245
	struct f2fs_super_block *raw_super;
J
Jaegeuk Kim 已提交
1246 1247
	struct buffer_head *raw_super_buf;
	struct inode *root;
1248
	long err;
1249
	bool retry = true, need_fsck = false;
1250
	char *options = NULL;
1251
	int recovery, i;
J
Jaegeuk Kim 已提交
1252

1253
try_onemore:
1254 1255 1256 1257 1258
	err = -EINVAL;
	raw_super = NULL;
	raw_super_buf = NULL;
	recovery = 0;

J
Jaegeuk Kim 已提交
1259 1260 1261 1262 1263
	/* allocate memory for f2fs-specific super block info */
	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;

1264
	/* set a block size */
1265
	if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
1266
		f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
J
Jaegeuk Kim 已提交
1267
		goto free_sbi;
1268
	}
J
Jaegeuk Kim 已提交
1269

1270
	err = read_raw_super_block(sb, &raw_super, &raw_super_buf, &recovery);
1271 1272 1273
	if (err)
		goto free_sbi;

1274
	sb->s_fs_info = sbi;
1275
	default_options(sbi);
J
Jaegeuk Kim 已提交
1276
	/* parse mount options */
1277 1278 1279
	options = kstrdup((const char *)data, GFP_KERNEL);
	if (data && !options) {
		err = -ENOMEM;
J
Jaegeuk Kim 已提交
1280
		goto free_sb_buf;
1281 1282 1283 1284 1285
	}

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

1287
	sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize));
J
Jaegeuk Kim 已提交
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
	sb->s_max_links = F2FS_LINK_MAX;
	get_random_bytes(&sbi->s_next_generation, sizeof(u32));

	sb->s_op = &f2fs_sops;
	sb->s_xattr = f2fs_xattr_handlers;
	sb->s_export_op = &f2fs_export_ops;
	sb->s_magic = F2FS_SUPER_MAGIC;
	sb->s_time_gran = 1;
	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
		(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
	memcpy(sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));

	/* init f2fs-specific super block info */
	sbi->sb = sb;
	sbi->raw_super = raw_super;
	sbi->raw_super_buf = raw_super_buf;
	mutex_init(&sbi->gc_mutex);
1305
	mutex_init(&sbi->writepages);
J
Jaegeuk Kim 已提交
1306
	mutex_init(&sbi->cp_mutex);
1307
	init_rwsem(&sbi->node_write);
1308 1309 1310

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

1313
	init_rwsem(&sbi->read_io.io_rwsem);
J
Jaegeuk Kim 已提交
1314 1315 1316
	sbi->read_io.sbi = sbi;
	sbi->read_io.bio = NULL;
	for (i = 0; i < NR_PAGE_TYPE; i++) {
1317
		init_rwsem(&sbi->write_io[i].io_rwsem);
J
Jaegeuk Kim 已提交
1318 1319 1320
		sbi->write_io[i].sbi = sbi;
		sbi->write_io[i].bio = NULL;
	}
1321

1322
	init_rwsem(&sbi->cp_rwsem);
1323
	init_waitqueue_head(&sbi->cp_wait);
J
Jaegeuk Kim 已提交
1324 1325 1326 1327 1328
	init_sb_info(sbi);

	/* get an inode for meta space */
	sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
	if (IS_ERR(sbi->meta_inode)) {
1329
		f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");
J
Jaegeuk Kim 已提交
1330
		err = PTR_ERR(sbi->meta_inode);
1331
		goto free_options;
J
Jaegeuk Kim 已提交
1332 1333 1334
	}

	err = get_valid_checkpoint(sbi);
1335 1336
	if (err) {
		f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");
J
Jaegeuk Kim 已提交
1337
		goto free_meta_inode;
1338
	}
J
Jaegeuk Kim 已提交
1339 1340 1341

	/* sanity checking of checkpoint */
	err = -EINVAL;
1342
	if (sanity_check_ckpt(sbi)) {
1343
		f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint");
J
Jaegeuk Kim 已提交
1344
		goto free_cp;
1345
	}
J
Jaegeuk Kim 已提交
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358

	sbi->total_valid_node_count =
				le32_to_cpu(sbi->ckpt->valid_node_count);
	sbi->total_valid_inode_count =
				le32_to_cpu(sbi->ckpt->valid_inode_count);
	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;
	sbi->alloc_valid_block_count = 0;
	INIT_LIST_HEAD(&sbi->dir_inode_list);
	spin_lock_init(&sbi->dir_inode_lock);

C
Chao Yu 已提交
1359 1360
	init_extent_cache_info(sbi);

J
Jaegeuk Kim 已提交
1361
	init_ino_entry_info(sbi);
J
Jaegeuk Kim 已提交
1362 1363 1364

	/* setup f2fs internal modules */
	err = build_segment_manager(sbi);
1365 1366 1367
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS segment manager");
J
Jaegeuk Kim 已提交
1368
		goto free_sm;
1369
	}
J
Jaegeuk Kim 已提交
1370
	err = build_node_manager(sbi);
1371 1372 1373
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS node manager");
J
Jaegeuk Kim 已提交
1374
		goto free_nm;
1375
	}
J
Jaegeuk Kim 已提交
1376 1377 1378 1379 1380 1381

	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)) {
1382
		f2fs_msg(sb, KERN_ERR, "Failed to read node inode");
J
Jaegeuk Kim 已提交
1383 1384 1385 1386
		err = PTR_ERR(sbi->node_inode);
		goto free_nm;
	}

1387 1388
	f2fs_join_shrinker(sbi);

J
Jaegeuk Kim 已提交
1389
	/* if there are nt orphan nodes free them */
1390 1391 1392
	err = recover_orphan_inodes(sbi);
	if (err)
		goto free_node_inode;
J
Jaegeuk Kim 已提交
1393 1394 1395 1396

	/* read root inode and dentry */
	root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
	if (IS_ERR(root)) {
1397
		f2fs_msg(sb, KERN_ERR, "Failed to read root inode");
J
Jaegeuk Kim 已提交
1398 1399 1400
		err = PTR_ERR(root);
		goto free_node_inode;
	}
1401
	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
1402
		iput(root);
1403
		err = -EINVAL;
1404
		goto free_node_inode;
1405
	}
J
Jaegeuk Kim 已提交
1406 1407 1408 1409 1410 1411 1412 1413 1414

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

	err = f2fs_build_stats(sbi);
	if (err)
1415
		goto free_root_inode;
J
Jaegeuk Kim 已提交
1416

1417 1418 1419 1420 1421 1422 1423
	if (f2fs_proc_root)
		sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root);

	if (sbi->s_proc)
		proc_create_data("segment_info", S_IRUGO, sbi->s_proc,
				 &f2fs_seq_segment_info_fops, sb);

1424 1425 1426 1427 1428
	sbi->s_kobj.kset = f2fs_kset;
	init_completion(&sbi->s_kobj_unregister);
	err = kobject_init_and_add(&sbi->s_kobj, &f2fs_ktype, NULL,
							"%s", sb->s_id);
	if (err)
1429
		goto free_proc;
1430

1431 1432
	/* recover fsynced data */
	if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
1433 1434 1435 1436 1437 1438 1439 1440 1441
		/*
		 * 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) &&
				!is_set_ckpt_flags(sbi->ckpt, CP_UMOUNT_FLAG)) {
			err = -EROFS;
			goto free_kobj;
		}
1442 1443 1444 1445

		if (need_fsck)
			set_sbi_flag(sbi, SBI_NEED_FSCK);

1446
		err = recover_fsync_data(sbi);
1447
		if (err) {
1448
			need_fsck = true;
1449 1450
			f2fs_msg(sb, KERN_ERR,
				"Cannot recover all fsync data errno=%ld", err);
1451 1452
			goto free_kobj;
		}
1453
	}
1454 1455
	/* recover_fsync_data() cleared this already */
	clear_sbi_flag(sbi, SBI_POR_DOING);
1456

1457 1458 1459 1460
	/*
	 * If filesystem is not mounted as read-only then
	 * do start the gc_thread.
	 */
1461
	if (test_opt(sbi, BG_GC) && !f2fs_readonly(sb)) {
1462 1463 1464 1465 1466
		/* After POR, we can run background GC thread.*/
		err = start_gc_thread(sbi);
		if (err)
			goto free_kobj;
	}
1467
	kfree(options);
1468 1469 1470 1471

	/* recover broken superblock */
	if (recovery && !f2fs_readonly(sb) && !bdev_read_only(sb->s_bdev)) {
		f2fs_msg(sb, KERN_INFO, "Recover invalid superblock");
C
Chao Yu 已提交
1472
		f2fs_commit_super(sbi, true);
1473 1474
	}

1475 1476
	sbi->cp_expires = round_jiffies_up(jiffies);

J
Jaegeuk Kim 已提交
1477
	return 0;
1478 1479 1480

free_kobj:
	kobject_del(&sbi->s_kobj);
1481 1482
	kobject_put(&sbi->s_kobj);
	wait_for_completion(&sbi->s_kobj_unregister);
1483
free_proc:
1484 1485 1486 1487 1488
	if (sbi->s_proc) {
		remove_proc_entry("segment_info", sbi->s_proc);
		remove_proc_entry(sb->s_id, f2fs_proc_root);
	}
	f2fs_destroy_stats(sbi);
J
Jaegeuk Kim 已提交
1489 1490 1491 1492
free_root_inode:
	dput(sb->s_root);
	sb->s_root = NULL;
free_node_inode:
1493 1494
	mutex_lock(&sbi->umount_mutex);
	f2fs_leave_shrinker(sbi);
J
Jaegeuk Kim 已提交
1495
	iput(sbi->node_inode);
1496
	mutex_unlock(&sbi->umount_mutex);
J
Jaegeuk Kim 已提交
1497 1498 1499 1500 1501 1502 1503 1504 1505
free_nm:
	destroy_node_manager(sbi);
free_sm:
	destroy_segment_manager(sbi);
free_cp:
	kfree(sbi->ckpt);
free_meta_inode:
	make_bad_inode(sbi->meta_inode);
	iput(sbi->meta_inode);
1506 1507
free_options:
	kfree(options);
J
Jaegeuk Kim 已提交
1508 1509
free_sb_buf:
	brelse(raw_super_buf);
Y
Yunlei He 已提交
1510
	kfree(raw_super);
J
Jaegeuk Kim 已提交
1511 1512
free_sbi:
	kfree(sbi);
1513 1514 1515

	/* give only one another chance */
	if (retry) {
1516
		retry = false;
1517 1518 1519
		shrink_dcache_sb(sb);
		goto try_onemore;
	}
J
Jaegeuk Kim 已提交
1520 1521 1522 1523 1524 1525 1526 1527 1528
	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);
}

1529 1530 1531
static void kill_f2fs_super(struct super_block *sb)
{
	if (sb->s_root)
1532
		set_sbi_flag(F2FS_SB(sb), SBI_IS_CLOSE);
1533 1534 1535
	kill_block_super(sb);
}

J
Jaegeuk Kim 已提交
1536 1537 1538 1539
static struct file_system_type f2fs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "f2fs",
	.mount		= f2fs_mount,
1540
	.kill_sb	= kill_f2fs_super,
J
Jaegeuk Kim 已提交
1541 1542
	.fs_flags	= FS_REQUIRES_DEV,
};
1543
MODULE_ALIAS_FS("f2fs");
J
Jaegeuk Kim 已提交
1544

1545
static int __init init_inodecache(void)
J
Jaegeuk Kim 已提交
1546 1547
{
	f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache",
1548
			sizeof(struct f2fs_inode_info));
1549
	if (!f2fs_inode_cachep)
J
Jaegeuk Kim 已提交
1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
		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;

1568 1569
	f2fs_build_trace_ios();

J
Jaegeuk Kim 已提交
1570 1571 1572 1573 1574
	err = init_inodecache();
	if (err)
		goto fail;
	err = create_node_manager_caches();
	if (err)
1575
		goto free_inodecache;
1576
	err = create_segment_manager_caches();
J
Jaegeuk Kim 已提交
1577
	if (err)
1578
		goto free_node_manager_caches;
J
Jaegeuk Kim 已提交
1579 1580
	err = create_checkpoint_caches();
	if (err)
1581
		goto free_segment_manager_caches;
C
Chao Yu 已提交
1582 1583 1584
	err = create_extent_cache();
	if (err)
		goto free_checkpoint_caches;
1585
	f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
1586 1587
	if (!f2fs_kset) {
		err = -ENOMEM;
C
Chao Yu 已提交
1588
		goto free_extent_cache;
1589
	}
1590
	err = f2fs_init_crypto();
1591
	if (err)
1592
		goto free_kset;
1593 1594

	err = register_shrinker(&f2fs_shrinker_info);
1595 1596
	if (err)
		goto free_crypto;
1597 1598 1599 1600

	err = register_filesystem(&f2fs_fs_type);
	if (err)
		goto free_shrinker;
1601 1602 1603
	err = f2fs_create_root_stats();
	if (err)
		goto free_filesystem;
1604
	f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
1605 1606
	return 0;

1607 1608
free_filesystem:
	unregister_filesystem(&f2fs_fs_type);
1609 1610
free_shrinker:
	unregister_shrinker(&f2fs_shrinker_info);
1611 1612
free_crypto:
	f2fs_exit_crypto();
1613 1614
free_kset:
	kset_unregister(f2fs_kset);
C
Chao Yu 已提交
1615 1616
free_extent_cache:
	destroy_extent_cache();
1617 1618
free_checkpoint_caches:
	destroy_checkpoint_caches();
1619 1620
free_segment_manager_caches:
	destroy_segment_manager_caches();
1621 1622 1623 1624
free_node_manager_caches:
	destroy_node_manager_caches();
free_inodecache:
	destroy_inodecache();
J
Jaegeuk Kim 已提交
1625 1626 1627 1628 1629 1630
fail:
	return err;
}

static void __exit exit_f2fs_fs(void)
{
1631
	remove_proc_entry("fs/f2fs", NULL);
1632
	f2fs_destroy_root_stats();
1633
	unregister_shrinker(&f2fs_shrinker_info);
J
Jaegeuk Kim 已提交
1634
	unregister_filesystem(&f2fs_fs_type);
1635
	f2fs_exit_crypto();
W
Wanpeng Li 已提交
1636
	destroy_extent_cache();
J
Jaegeuk Kim 已提交
1637
	destroy_checkpoint_caches();
1638
	destroy_segment_manager_caches();
J
Jaegeuk Kim 已提交
1639 1640
	destroy_node_manager_caches();
	destroy_inodecache();
1641
	kset_unregister(f2fs_kset);
1642
	f2fs_destroy_trace_ios();
J
Jaegeuk Kim 已提交
1643 1644 1645 1646 1647 1648 1649 1650
}

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");