super.c 30.9 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

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

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

enum {
42
	Opt_gc_background,
J
Jaegeuk Kim 已提交
43 44 45
	Opt_disable_roll_forward,
	Opt_discard,
	Opt_noheap,
46
	Opt_user_xattr,
J
Jaegeuk Kim 已提交
47
	Opt_nouser_xattr,
48
	Opt_acl,
J
Jaegeuk Kim 已提交
49 50 51
	Opt_noacl,
	Opt_active_logs,
	Opt_disable_ext_identify,
J
Jaegeuk Kim 已提交
52
	Opt_inline_xattr,
53
	Opt_inline_data,
54
	Opt_flush_merge,
J
Jaegeuk Kim 已提交
55
	Opt_nobarrier,
J
Jaegeuk Kim 已提交
56 57 58 59
	Opt_err,
};

static match_table_t f2fs_tokens = {
60
	{Opt_gc_background, "background_gc=%s"},
J
Jaegeuk Kim 已提交
61 62 63
	{Opt_disable_roll_forward, "disable_roll_forward"},
	{Opt_discard, "discard"},
	{Opt_noheap, "no_heap"},
64
	{Opt_user_xattr, "user_xattr"},
J
Jaegeuk Kim 已提交
65
	{Opt_nouser_xattr, "nouser_xattr"},
66
	{Opt_acl, "acl"},
J
Jaegeuk Kim 已提交
67 68 69
	{Opt_noacl, "noacl"},
	{Opt_active_logs, "active_logs=%u"},
	{Opt_disable_ext_identify, "disable_ext_identify"},
J
Jaegeuk Kim 已提交
70
	{Opt_inline_xattr, "inline_xattr"},
71
	{Opt_inline_data, "inline_data"},
72
	{Opt_flush_merge, "flush_merge"},
J
Jaegeuk Kim 已提交
73
	{Opt_nobarrier, "nobarrier"},
J
Jaegeuk Kim 已提交
74 75 76
	{Opt_err, NULL},
};

77
/* Sysfs support for f2fs */
78 79 80
enum {
	GC_THREAD,	/* struct f2fs_gc_thread */
	SM_INFO,	/* struct f2fs_sm_info */
81
	NM_INFO,	/* struct f2fs_nm_info */
82
	F2FS_SBI,	/* struct f2fs_sb_info */
83 84
};

85 86 87 88 89
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);
90
	int struct_type;
91 92 93
	int offset;
};

94 95 96 97 98 99
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);
100 101
	else if (struct_type == NM_INFO)
		return (unsigned char *)NM_I(sbi);
102 103
	else if (struct_type == F2FS_SBI)
		return (unsigned char *)sbi;
104 105 106
	return NULL;
}

107 108 109
static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
			struct f2fs_sb_info *sbi, char *buf)
{
110
	unsigned char *ptr = NULL;
111 112
	unsigned int *ui;

113 114
	ptr = __struct_ptr(sbi, a->struct_type);
	if (!ptr)
115 116
		return -EINVAL;

117
	ui = (unsigned int *)(ptr + a->offset);
118 119 120 121 122 123 124 125

	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)
{
126
	unsigned char *ptr;
127 128 129 130
	unsigned long t;
	unsigned int *ui;
	ssize_t ret;

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

135
	ui = (unsigned int *)(ptr + a->offset);
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170

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

171
#define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
172 173 174 175
static struct f2fs_attr f2fs_attr_##_name = {			\
	.attr = {.name = __stringify(_name), .mode = _mode },	\
	.show	= _show,					\
	.store	= _store,					\
176 177
	.struct_type = _struct_type,				\
	.offset = _offset					\
178 179
}

180 181 182 183
#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))
184

185 186 187 188 189
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);
190
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, max_small_discards, max_discards);
191 192
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);
193
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
194
F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
195
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
196
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
197 198 199 200 201 202

#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),
203
	ATTR_LIST(gc_idle),
204
	ATTR_LIST(reclaim_segments),
205
	ATTR_LIST(max_small_discards),
206 207
	ATTR_LIST(ipu_policy),
	ATTR_LIST(min_ipu_util),
208
	ATTR_LIST(min_fsync_blocks),
209
	ATTR_LIST(max_victim_search),
210
	ATTR_LIST(dir_level),
211
	ATTR_LIST(ram_thresh),
212 213 214 215 216 217 218 219 220 221 222 223 224 225
	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,
};

226 227 228 229 230 231 232 233 234 235 236 237
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 已提交
238 239 240 241 242 243 244
static void init_once(void *foo)
{
	struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;

	inode_init_once(&fi->vfs_inode);
}

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
static int parse_options(struct super_block *sb, char *options)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
	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;
272
			if (strlen(name) == 2 && !strncmp(name, "on", 2))
273
				set_opt(sbi, BG_GC);
274
			else if (strlen(name) == 3 && !strncmp(name, "off", 3))
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
				clear_opt(sbi, BG_GC);
			else {
				kfree(name);
				return -EINVAL;
			}
			kfree(name);
			break;
		case Opt_disable_roll_forward:
			set_opt(sbi, DISABLE_ROLL_FORWARD);
			break;
		case Opt_discard:
			set_opt(sbi, DISCARD);
			break;
		case Opt_noheap:
			set_opt(sbi, NOHEAP);
			break;
#ifdef CONFIG_F2FS_FS_XATTR
292 293 294
		case Opt_user_xattr:
			set_opt(sbi, XATTR_USER);
			break;
295 296 297
		case Opt_nouser_xattr:
			clear_opt(sbi, XATTR_USER);
			break;
J
Jaegeuk Kim 已提交
298 299 300
		case Opt_inline_xattr:
			set_opt(sbi, INLINE_XATTR);
			break;
301
#else
302 303 304 305
		case Opt_user_xattr:
			f2fs_msg(sb, KERN_INFO,
				"user_xattr options not supported");
			break;
306 307 308 309
		case Opt_nouser_xattr:
			f2fs_msg(sb, KERN_INFO,
				"nouser_xattr options not supported");
			break;
J
Jaegeuk Kim 已提交
310 311 312 313
		case Opt_inline_xattr:
			f2fs_msg(sb, KERN_INFO,
				"inline_xattr options not supported");
			break;
314 315
#endif
#ifdef CONFIG_F2FS_FS_POSIX_ACL
316 317 318
		case Opt_acl:
			set_opt(sbi, POSIX_ACL);
			break;
319 320 321 322
		case Opt_noacl:
			clear_opt(sbi, POSIX_ACL);
			break;
#else
323 324 325
		case Opt_acl:
			f2fs_msg(sb, KERN_INFO, "acl options not supported");
			break;
326 327 328 329 330 331 332 333 334 335 336 337 338 339
		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;
340 341 342
		case Opt_inline_data:
			set_opt(sbi, INLINE_DATA);
			break;
343 344 345
		case Opt_flush_merge:
			set_opt(sbi, FLUSH_MERGE);
			break;
J
Jaegeuk Kim 已提交
346 347 348
		case Opt_nobarrier:
			set_opt(sbi, NOBARRIER);
			break;
349 350 351 352 353 354 355 356 357 358
		default:
			f2fs_msg(sb, KERN_ERR,
				"Unrecognized mount option \"%s\" or missing value",
				p);
			return -EINVAL;
		}
	}
	return 0;
}

J
Jaegeuk Kim 已提交
359 360 361 362
static struct inode *f2fs_alloc_inode(struct super_block *sb)
{
	struct f2fs_inode_info *fi;

363
	fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
J
Jaegeuk Kim 已提交
364 365 366 367 368
	if (!fi)
		return NULL;

	init_once((void *) fi);

M
Masanari Iida 已提交
369
	/* Initialize f2fs-specific inode info */
J
Jaegeuk Kim 已提交
370
	fi->vfs_inode.i_version = 1;
371
	atomic_set(&fi->dirty_pages, 0);
J
Jaegeuk Kim 已提交
372 373 374
	fi->i_current_depth = 1;
	fi->i_advise = 0;
	rwlock_init(&fi->ext.ext_lock);
375
	init_rwsem(&fi->i_sem);
J
Jaegeuk Kim 已提交
376 377 378

	set_inode_flag(fi, FI_NEW_INODE);

J
Jaegeuk Kim 已提交
379 380 381
	if (test_opt(F2FS_SB(sb), INLINE_XATTR))
		set_inode_flag(fi, FI_INLINE_XATTR);

382 383 384
	/* Will be used by directory only */
	fi->i_dir_level = F2FS_SB(sb)->dir_level;

J
Jaegeuk Kim 已提交
385 386 387
	return &fi->vfs_inode;
}

388 389 390 391 392 393 394 395 396 397 398 399 400 401
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)
	 */
	if (!inode_unhashed(inode) && inode->i_state & I_SYNC)
		return 0;
	return generic_drop_inode(inode);
}

402 403 404 405 406 407 408 409 410 411
/*
 * 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 已提交
412 413 414 415 416 417
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));
}

418
static void f2fs_destroy_inode(struct inode *inode)
J
Jaegeuk Kim 已提交
419 420 421 422 423 424 425 426
{
	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);

427 428 429 430
	if (sbi->s_proc) {
		remove_proc_entry("segment_info", sbi->s_proc);
		remove_proc_entry(sb->s_id, f2fs_proc_root);
	}
431
	kobject_del(&sbi->s_kobj);
432

J
Jaegeuk Kim 已提交
433 434 435
	f2fs_destroy_stats(sbi);
	stop_gc_thread(sbi);

J
Jaegeuk Kim 已提交
436
	/* We don't need to do checkpoint when it's clean */
437
	if (sbi->s_dirty)
J
Jaegeuk Kim 已提交
438
		write_checkpoint(sbi, true);
J
Jaegeuk Kim 已提交
439

440 441 442 443
	/*
	 * normally superblock is clean, so we need to release this.
	 * In addition, EIO will skip do checkpoint, we need this as well.
	 */
444 445
	release_dirty_inode(sbi);

J
Jaegeuk Kim 已提交
446 447 448 449 450 451 452 453
	iput(sbi->node_inode);
	iput(sbi->meta_inode);

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

	kfree(sbi->ckpt);
454 455
	kobject_put(&sbi->s_kobj);
	wait_for_completion(&sbi->s_kobj_unregister);
J
Jaegeuk Kim 已提交
456 457 458 459 460 461 462 463 464 465

	sb->s_fs_info = NULL;
	brelse(sbi->raw_super_buf);
	kfree(sbi);
}

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

466 467
	trace_f2fs_sync_fs(sb, sync);

468 469
	if (sync) {
		mutex_lock(&sbi->gc_mutex);
470
		write_checkpoint(sbi, false);
471 472
		mutex_unlock(&sbi->gc_mutex);
	} else {
473
		f2fs_balance_fs(sbi);
474
	}
J
Jaegeuk Kim 已提交
475

476
	return 0;
J
Jaegeuk Kim 已提交
477 478
}

479 480 481 482
static int f2fs_freeze(struct super_block *sb)
{
	int err;

J
Jaegeuk Kim 已提交
483
	if (f2fs_readonly(sb))
484 485 486 487 488 489 490 491 492 493 494
		return 0;

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

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

J
Jaegeuk Kim 已提交
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
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);

513 514
	buf->f_files = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
	buf->f_ffree = buf->f_files - valid_inode_count(sbi);
J
Jaegeuk Kim 已提交
515

516
	buf->f_namelen = F2FS_NAME_LEN;
J
Jaegeuk Kim 已提交
517 518 519 520 521 522 523 524 525 526
	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);

527
	if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC))
528
		seq_printf(seq, ",background_gc=%s", "on");
J
Jaegeuk Kim 已提交
529
	else
530
		seq_printf(seq, ",background_gc=%s", "off");
J
Jaegeuk Kim 已提交
531 532 533 534 535 536 537 538 539 540 541
	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 已提交
542 543
	if (test_opt(sbi, INLINE_XATTR))
		seq_puts(seq, ",inline_xattr");
J
Jaegeuk Kim 已提交
544 545 546 547 548 549 550 551
#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))
552
		seq_puts(seq, ",disable_ext_identify");
553 554
	if (test_opt(sbi, INLINE_DATA))
		seq_puts(seq, ",inline_data");
555
	if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
556
		seq_puts(seq, ",flush_merge");
J
Jaegeuk Kim 已提交
557 558
	if (test_opt(sbi, NOBARRIER))
		seq_puts(seq, ",nobarrier");
J
Jaegeuk Kim 已提交
559 560 561 562 563
	seq_printf(seq, ",active_logs=%u", sbi->active_logs);

	return 0;
}

564 565 566 567
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 已提交
568 569
	unsigned int total_segs =
			le32_to_cpu(sbi->raw_super->segment_count_main);
570 571
	int i;

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

575
	for (i = 0; i < total_segs; i++) {
576 577 578 579 580 581
		struct seg_entry *se = get_seg_entry(sbi, i);

		if ((i % 10) == 0)
			seq_printf(seq, "%-5d", i);
		seq_printf(seq, "%d|%-3u", se->type,
					get_valid_blocks(sbi, i, 1));
582 583
		if ((i % 10) == 9 || i == (total_segs - 1))
			seq_putc(seq, '\n');
584
		else
585
			seq_putc(seq, ' ');
586
	}
587

588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
	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,
};

604 605 606 607 608
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;
609 610
	bool need_restart_gc = false;
	bool need_stop_gc = false;
611

612 613
	sync_filesystem(sb);

614 615 616 617 618 619 620 621 622 623 624 625 626 627
	/*
	 * Save the old mount options in case we
	 * need to restore them.
	 */
	org_mount_opt = sbi->mount_opt;
	active_logs = sbi->active_logs;

	/* parse mount options */
	err = parse_options(sb, data);
	if (err)
		goto restore_opts;

	/*
	 * Previous and new state of filesystem is RO,
628
	 * so skip checking GC and FLUSH_MERGE conditions.
629
	 */
630
	if (f2fs_readonly(sb) && (*flags & MS_RDONLY))
631 632 633 634 635 636 637 638 639 640 641
		goto skip;

	/*
	 * 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);
642
			need_restart_gc = true;
643 644 645 646 647
		}
	} else if (test_opt(sbi, BG_GC) && !sbi->gc_thread) {
		err = start_gc_thread(sbi);
		if (err)
			goto restore_opts;
648 649 650 651 652 653 654 655
		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)) {
656
		destroy_flush_cmd_control(sbi);
657
	} else if (test_opt(sbi, FLUSH_MERGE) && !SM_I(sbi)->cmd_control_info) {
658 659
		err = create_flush_cmd_control(sbi);
		if (err)
660
			goto restore_gc;
661 662 663 664 665 666
	}
skip:
	/* Update the POSIXACL Flag */
	 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
		(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
	return 0;
667 668 669 670
restore_gc:
	if (need_restart_gc) {
		if (start_gc_thread(sbi))
			f2fs_msg(sbi->sb, KERN_WARNING,
A
arter97 已提交
671
				"background gc thread has stopped");
672 673 674
	} else if (need_stop_gc) {
		stop_gc_thread(sbi);
	}
675 676 677 678 679 680
restore_opts:
	sbi->mount_opt = org_mount_opt;
	sbi->active_logs = active_logs;
	return err;
}

J
Jaegeuk Kim 已提交
681 682
static struct super_operations f2fs_sops = {
	.alloc_inode	= f2fs_alloc_inode,
683
	.drop_inode	= f2fs_drop_inode,
J
Jaegeuk Kim 已提交
684 685
	.destroy_inode	= f2fs_destroy_inode,
	.write_inode	= f2fs_write_inode,
686
	.dirty_inode	= f2fs_dirty_inode,
J
Jaegeuk Kim 已提交
687 688 689 690
	.show_options	= f2fs_show_options,
	.evict_inode	= f2fs_evict_inode,
	.put_super	= f2fs_put_super,
	.sync_fs	= f2fs_sync_fs,
691 692
	.freeze_fs	= f2fs_freeze,
	.unfreeze_fs	= f2fs_unfreeze,
J
Jaegeuk Kim 已提交
693
	.statfs		= f2fs_statfs,
694
	.remount_fs	= f2fs_remount,
J
Jaegeuk Kim 已提交
695 696 697 698 699 700 701 702
};

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;

703
	if (check_nid_range(sbi, ino))
704
		return ERR_PTR(-ESTALE);
J
Jaegeuk Kim 已提交
705 706 707 708 709 710 711 712 713

	/*
	 * 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);
714
	if (unlikely(generation && inode->i_generation != generation)) {
J
Jaegeuk Kim 已提交
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
		/* 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)
{
744
	loff_t result = (DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS);
J
Jaegeuk Kim 已提交
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
	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;
}

762 763
static int sanity_check_raw_super(struct super_block *sb,
			struct f2fs_super_block *raw_super)
J
Jaegeuk Kim 已提交
764 765 766
{
	unsigned int blocksize;

767 768 769 770
	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 已提交
771
		return 1;
772
	}
J
Jaegeuk Kim 已提交
773

774 775 776
	/* Currently, support only 4KB page cache size */
	if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) {
		f2fs_msg(sb, KERN_INFO,
777
			"Invalid page_cache_size (%lu), supports only 4KB\n",
778 779 780 781
			PAGE_CACHE_SIZE);
		return 1;
	}

J
Jaegeuk Kim 已提交
782 783
	/* Currently, support only 4KB block size */
	blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
784
	if (blocksize != F2FS_BLKSIZE) {
785 786 787
		f2fs_msg(sb, KERN_INFO,
			"Invalid blocksize (%u), supports only 4KB\n",
			blocksize);
J
Jaegeuk Kim 已提交
788
		return 1;
789
	}
790

C
Chao Yu 已提交
791 792 793 794 795 796 797
	/* 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 已提交
798
		return 1;
799
	}
C
Chao Yu 已提交
800 801 802 803 804 805 806
	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 已提交
807
		return 1;
808
	}
J
Jaegeuk Kim 已提交
809 810 811
	return 0;
}

812
static int sanity_check_ckpt(struct f2fs_sb_info *sbi)
J
Jaegeuk Kim 已提交
813 814
{
	unsigned int total, fsmeta;
815 816
	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
J
Jaegeuk Kim 已提交
817 818 819 820 821 822 823 824

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

825
	if (unlikely(fsmeta >= total))
J
Jaegeuk Kim 已提交
826
		return 1;
827

828
	if (unlikely(f2fs_cp_error(sbi))) {
829 830 831
		f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
		return 1;
	}
J
Jaegeuk Kim 已提交
832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
	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);
855
	sbi->cur_victim_sec = NULL_SECNO;
856
	sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
J
Jaegeuk Kim 已提交
857 858 859

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

	sbi->dir_level = DEF_DIR_LEVEL;
862
	sbi->need_fsck = false;
J
Jaegeuk Kim 已提交
863 864
}

865 866 867 868 869 870 871 872
/*
 * 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,
			struct buffer_head **raw_super_buf)
873
{
874
	int block = 0;
875

876
retry:
877 878
	*raw_super_buf = sb_bread(sb, block);
	if (!*raw_super_buf) {
879 880 881 882 883 884 885 886
		f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
				block + 1);
		if (block == 0) {
			block++;
			goto retry;
		} else {
			return -EIO;
		}
887 888 889 890 891 892
	}

	*raw_super = (struct f2fs_super_block *)
		((char *)(*raw_super_buf)->b_data + F2FS_SUPER_OFFSET);

	/* sanity checking of raw super */
893 894
	if (sanity_check_raw_super(sb, *raw_super)) {
		brelse(*raw_super_buf);
C
Chris Fries 已提交
895 896 897
		f2fs_msg(sb, KERN_ERR,
			"Can't find valid F2FS filesystem in %dth superblock",
								block + 1);
898
		if (block == 0) {
899 900 901 902 903 904
			block++;
			goto retry;
		} else {
			return -EINVAL;
		}
	}
905

906
	return 0;
907 908
}

J
Jaegeuk Kim 已提交
909 910 911 912 913 914 915
static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
{
	struct f2fs_sb_info *sbi;
	struct f2fs_super_block *raw_super;
	struct buffer_head *raw_super_buf;
	struct inode *root;
	long err = -EINVAL;
916
	bool retry = true;
917
	int i;
J
Jaegeuk Kim 已提交
918

919
try_onemore:
J
Jaegeuk Kim 已提交
920 921 922 923 924
	/* allocate memory for f2fs-specific super block info */
	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;

925
	/* set a block size */
926
	if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
927
		f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
J
Jaegeuk Kim 已提交
928
		goto free_sbi;
929
	}
J
Jaegeuk Kim 已提交
930

931 932 933 934
	err = read_raw_super_block(sb, &raw_super, &raw_super_buf);
	if (err)
		goto free_sbi;

935
	sb->s_fs_info = sbi;
J
Jaegeuk Kim 已提交
936 937 938 939 940 941 942 943 944 945 946 947
	/* init some FS parameters */
	sbi->active_logs = NR_CURSEG_TYPE;

	set_opt(sbi, BG_GC);

#ifdef CONFIG_F2FS_FS_XATTR
	set_opt(sbi, XATTR_USER);
#endif
#ifdef CONFIG_F2FS_FS_POSIX_ACL
	set_opt(sbi, POSIX_ACL);
#endif
	/* parse mount options */
948
	err = parse_options(sb, (char *)data);
949
	if (err)
J
Jaegeuk Kim 已提交
950 951
		goto free_sb_buf;

952
	sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize));
J
Jaegeuk Kim 已提交
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
	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);
	mutex_init(&sbi->writepages);
	mutex_init(&sbi->cp_mutex);
972
	init_rwsem(&sbi->node_write);
H
Haicheng Li 已提交
973
	sbi->por_doing = false;
J
Jaegeuk Kim 已提交
974
	spin_lock_init(&sbi->stat_lock);
975

976
	init_rwsem(&sbi->read_io.io_rwsem);
J
Jaegeuk Kim 已提交
977 978 979
	sbi->read_io.sbi = sbi;
	sbi->read_io.bio = NULL;
	for (i = 0; i < NR_PAGE_TYPE; i++) {
980
		init_rwsem(&sbi->write_io[i].io_rwsem);
J
Jaegeuk Kim 已提交
981 982 983
		sbi->write_io[i].sbi = sbi;
		sbi->write_io[i].bio = NULL;
	}
984

985
	init_rwsem(&sbi->cp_rwsem);
986
	init_waitqueue_head(&sbi->cp_wait);
J
Jaegeuk Kim 已提交
987 988 989 990 991
	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)) {
992
		f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");
J
Jaegeuk Kim 已提交
993 994 995 996 997
		err = PTR_ERR(sbi->meta_inode);
		goto free_sb_buf;
	}

	err = get_valid_checkpoint(sbi);
998 999
	if (err) {
		f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");
J
Jaegeuk Kim 已提交
1000
		goto free_meta_inode;
1001
	}
J
Jaegeuk Kim 已提交
1002 1003 1004

	/* sanity checking of checkpoint */
	err = -EINVAL;
1005
	if (sanity_check_ckpt(sbi)) {
1006
		f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint");
J
Jaegeuk Kim 已提交
1007
		goto free_cp;
1008
	}
J
Jaegeuk Kim 已提交
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021

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

J
Jaegeuk Kim 已提交
1022
	init_ino_entry_info(sbi);
J
Jaegeuk Kim 已提交
1023 1024 1025

	/* setup f2fs internal modules */
	err = build_segment_manager(sbi);
1026 1027 1028
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS segment manager");
J
Jaegeuk Kim 已提交
1029
		goto free_sm;
1030
	}
J
Jaegeuk Kim 已提交
1031
	err = build_node_manager(sbi);
1032 1033 1034
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS node manager");
J
Jaegeuk Kim 已提交
1035
		goto free_nm;
1036
	}
J
Jaegeuk Kim 已提交
1037 1038 1039 1040 1041 1042

	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)) {
1043
		f2fs_msg(sb, KERN_ERR, "Failed to read node inode");
J
Jaegeuk Kim 已提交
1044 1045 1046 1047 1048
		err = PTR_ERR(sbi->node_inode);
		goto free_nm;
	}

	/* if there are nt orphan nodes free them */
1049
	recover_orphan_inodes(sbi);
J
Jaegeuk Kim 已提交
1050 1051 1052 1053

	/* read root inode and dentry */
	root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
	if (IS_ERR(root)) {
1054
		f2fs_msg(sb, KERN_ERR, "Failed to read root inode");
J
Jaegeuk Kim 已提交
1055 1056 1057
		err = PTR_ERR(root);
		goto free_node_inode;
	}
1058
	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
1059
		iput(root);
1060
		err = -EINVAL;
1061
		goto free_node_inode;
1062
	}
J
Jaegeuk Kim 已提交
1063 1064 1065 1066 1067 1068 1069 1070 1071

	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)
1072
		goto free_root_inode;
J
Jaegeuk Kim 已提交
1073

1074 1075 1076 1077 1078 1079 1080
	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);

1081 1082 1083 1084 1085 1086 1087 1088
	if (test_opt(sbi, DISCARD)) {
		struct request_queue *q = bdev_get_queue(sb->s_bdev);
		if (!blk_queue_discard(q))
			f2fs_msg(sb, KERN_WARNING,
					"mounting with \"discard\" option, but "
					"the device does not support discard");
	}

1089 1090 1091 1092 1093
	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)
1094
		goto free_proc;
1095

1096 1097 1098
	if (!retry)
		sbi->need_fsck = true;

1099 1100 1101
	/* recover fsynced data */
	if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
		err = recover_fsync_data(sbi);
1102
		if (err) {
1103 1104
			f2fs_msg(sb, KERN_ERR,
				"Cannot recover all fsync data errno=%ld", err);
1105 1106
			goto free_kobj;
		}
1107
	}
1108

1109 1110 1111 1112
	/*
	 * If filesystem is not mounted as read-only then
	 * do start the gc_thread.
	 */
1113
	if (!f2fs_readonly(sb)) {
1114 1115 1116 1117 1118
		/* After POR, we can run background GC thread.*/
		err = start_gc_thread(sbi);
		if (err)
			goto free_kobj;
	}
J
Jaegeuk Kim 已提交
1119
	return 0;
1120 1121 1122 1123

free_kobj:
	kobject_del(&sbi->s_kobj);
free_proc:
1124 1125 1126 1127 1128
	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 已提交
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
free_root_inode:
	dput(sb->s_root);
	sb->s_root = NULL;
free_node_inode:
	iput(sbi->node_inode);
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);
free_sb_buf:
	brelse(raw_super_buf);
free_sbi:
	kfree(sbi);
1147 1148 1149

	/* give only one another chance */
	if (retry) {
1150
		retry = 0;
1151 1152 1153
		shrink_dcache_sb(sb);
		goto try_onemore;
	}
J
Jaegeuk Kim 已提交
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
	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);
}

static struct file_system_type f2fs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "f2fs",
	.mount		= f2fs_mount,
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
};
1170
MODULE_ALIAS_FS("f2fs");
J
Jaegeuk Kim 已提交
1171

1172
static int __init init_inodecache(void)
J
Jaegeuk Kim 已提交
1173 1174
{
	f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache",
1175
			sizeof(struct f2fs_inode_info));
1176
	if (!f2fs_inode_cachep)
J
Jaegeuk Kim 已提交
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
		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;

	err = init_inodecache();
	if (err)
		goto fail;
	err = create_node_manager_caches();
	if (err)
1200
		goto free_inodecache;
1201
	err = create_segment_manager_caches();
J
Jaegeuk Kim 已提交
1202
	if (err)
1203
		goto free_node_manager_caches;
1204 1205 1206
	err = create_gc_caches();
	if (err)
		goto free_segment_manager_caches;
J
Jaegeuk Kim 已提交
1207 1208
	err = create_checkpoint_caches();
	if (err)
1209
		goto free_gc_caches;
1210
	f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
1211 1212
	if (!f2fs_kset) {
		err = -ENOMEM;
1213
		goto free_checkpoint_caches;
1214
	}
1215 1216
	err = register_filesystem(&f2fs_fs_type);
	if (err)
1217
		goto free_kset;
1218
	f2fs_create_root_stats();
1219
	f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
1220 1221 1222 1223 1224 1225 1226 1227
	return 0;

free_kset:
	kset_unregister(f2fs_kset);
free_checkpoint_caches:
	destroy_checkpoint_caches();
free_gc_caches:
	destroy_gc_caches();
1228 1229
free_segment_manager_caches:
	destroy_segment_manager_caches();
1230 1231 1232 1233
free_node_manager_caches:
	destroy_node_manager_caches();
free_inodecache:
	destroy_inodecache();
J
Jaegeuk Kim 已提交
1234 1235 1236 1237 1238 1239
fail:
	return err;
}

static void __exit exit_f2fs_fs(void)
{
1240
	remove_proc_entry("fs/f2fs", NULL);
1241
	f2fs_destroy_root_stats();
J
Jaegeuk Kim 已提交
1242 1243 1244
	unregister_filesystem(&f2fs_fs_type);
	destroy_checkpoint_caches();
	destroy_gc_caches();
1245
	destroy_segment_manager_caches();
J
Jaegeuk Kim 已提交
1246 1247
	destroy_node_manager_caches();
	destroy_inodecache();
1248
	kset_unregister(f2fs_kset);
J
Jaegeuk Kim 已提交
1249 1250 1251 1252 1253 1254 1255 1256
}

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