super.c 29.4 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 56 57 58
	Opt_err,
};

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

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

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

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

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

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

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

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

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

133
	ui = (unsigned int *)(ptr + a->offset);
134 135 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

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

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

178 179 180 181
#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))
182

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

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

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

	inode_init_once(&fi->vfs_inode);
}

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

J
Jaegeuk Kim 已提交
352 353 354 355
static struct inode *f2fs_alloc_inode(struct super_block *sb)
{
	struct f2fs_inode_info *fi;

356
	fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
J
Jaegeuk Kim 已提交
357 358 359 360 361
	if (!fi)
		return NULL;

	init_once((void *) fi);

M
Masanari Iida 已提交
362
	/* Initialize f2fs-specific inode info */
J
Jaegeuk Kim 已提交
363 364 365 366 367
	fi->vfs_inode.i_version = 1;
	atomic_set(&fi->dirty_dents, 0);
	fi->i_current_depth = 1;
	fi->i_advise = 0;
	rwlock_init(&fi->ext.ext_lock);
368
	init_rwsem(&fi->i_sem);
J
Jaegeuk Kim 已提交
369 370 371

	set_inode_flag(fi, FI_NEW_INODE);

J
Jaegeuk Kim 已提交
372 373 374
	if (test_opt(F2FS_SB(sb), INLINE_XATTR))
		set_inode_flag(fi, FI_INLINE_XATTR);

375 376 377
	/* Will be used by directory only */
	fi->i_dir_level = F2FS_SB(sb)->dir_level;

J
Jaegeuk Kim 已提交
378 379 380
	return &fi->vfs_inode;
}

381 382 383 384 385 386 387 388 389 390 391 392 393 394
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);
}

395 396 397 398 399 400 401 402 403 404
/*
 * 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 已提交
405 406 407 408 409 410
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));
}

411
static void f2fs_destroy_inode(struct inode *inode)
J
Jaegeuk Kim 已提交
412 413 414 415 416 417 418 419
{
	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);

420 421 422 423
	if (sbi->s_proc) {
		remove_proc_entry("segment_info", sbi->s_proc);
		remove_proc_entry(sb->s_id, f2fs_proc_root);
	}
424
	kobject_del(&sbi->s_kobj);
425

J
Jaegeuk Kim 已提交
426 427 428
	f2fs_destroy_stats(sbi);
	stop_gc_thread(sbi);

J
Jaegeuk Kim 已提交
429 430 431
	/* We don't need to do checkpoint when it's clean */
	if (sbi->s_dirty && get_pages(sbi, F2FS_DIRTY_NODES))
		write_checkpoint(sbi, true);
J
Jaegeuk Kim 已提交
432 433 434 435 436 437 438 439 440

	iput(sbi->node_inode);
	iput(sbi->meta_inode);

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

	kfree(sbi->ckpt);
441 442
	kobject_put(&sbi->s_kobj);
	wait_for_completion(&sbi->s_kobj_unregister);
J
Jaegeuk Kim 已提交
443 444 445 446 447 448 449 450 451 452

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

453 454
	trace_f2fs_sync_fs(sb, sync);

J
Jaegeuk Kim 已提交
455 456 457
	if (!sbi->s_dirty && !get_pages(sbi, F2FS_DIRTY_NODES))
		return 0;

458 459
	if (sync) {
		mutex_lock(&sbi->gc_mutex);
460
		write_checkpoint(sbi, false);
461 462
		mutex_unlock(&sbi->gc_mutex);
	} else {
463
		f2fs_balance_fs(sbi);
464
	}
J
Jaegeuk Kim 已提交
465

466
	return 0;
J
Jaegeuk Kim 已提交
467 468
}

469 470 471 472
static int f2fs_freeze(struct super_block *sb)
{
	int err;

J
Jaegeuk Kim 已提交
473
	if (f2fs_readonly(sb))
474 475 476 477 478 479 480 481 482 483 484
		return 0;

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

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

J
Jaegeuk Kim 已提交
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
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);

503 504
	buf->f_files = sbi->total_node_count;
	buf->f_ffree = sbi->total_node_count - valid_inode_count(sbi);
J
Jaegeuk Kim 已提交
505

506
	buf->f_namelen = F2FS_NAME_LEN;
J
Jaegeuk Kim 已提交
507 508 509 510 511 512 513 514 515 516
	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);

517 518
	if (!(root->d_sb->s_flags & MS_RDONLY) && test_opt(sbi, BG_GC))
		seq_printf(seq, ",background_gc=%s", "on");
J
Jaegeuk Kim 已提交
519
	else
520
		seq_printf(seq, ",background_gc=%s", "off");
J
Jaegeuk Kim 已提交
521 522 523 524 525 526 527 528 529 530 531
	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 已提交
532 533
	if (test_opt(sbi, INLINE_XATTR))
		seq_puts(seq, ",inline_xattr");
J
Jaegeuk Kim 已提交
534 535 536 537 538 539 540 541
#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))
542
		seq_puts(seq, ",disable_ext_identify");
543 544
	if (test_opt(sbi, INLINE_DATA))
		seq_puts(seq, ",inline_data");
545 546
	if (test_opt(sbi, FLUSH_MERGE))
		seq_puts(seq, ",flush_merge");
J
Jaegeuk Kim 已提交
547 548 549 550 551
	seq_printf(seq, ",active_logs=%u", sbi->active_logs);

	return 0;
}

552 553 554 555
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 已提交
556 557
	unsigned int total_segs =
			le32_to_cpu(sbi->raw_super->segment_count_main);
558 559
	int i;

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

563
	for (i = 0; i < total_segs; i++) {
564 565 566 567 568 569
		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));
570 571
		if ((i % 10) == 9 || i == (total_segs - 1))
			seq_putc(seq, '\n');
572
		else
573
			seq_putc(seq, ' ');
574
	}
575

576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
	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,
};

592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 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
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;

	/*
	 * 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,
	 * so no point in checking GC conditions.
	 */
	if ((sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY))
		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);
		}
	} else if (test_opt(sbi, BG_GC) && !sbi->gc_thread) {
		err = start_gc_thread(sbi);
		if (err)
			goto restore_opts;
	}
skip:
	/* Update the POSIXACL Flag */
	 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
		(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
	return 0;

restore_opts:
	sbi->mount_opt = org_mount_opt;
	sbi->active_logs = active_logs;
	return err;
}

J
Jaegeuk Kim 已提交
644 645
static struct super_operations f2fs_sops = {
	.alloc_inode	= f2fs_alloc_inode,
646
	.drop_inode	= f2fs_drop_inode,
J
Jaegeuk Kim 已提交
647 648
	.destroy_inode	= f2fs_destroy_inode,
	.write_inode	= f2fs_write_inode,
649
	.dirty_inode	= f2fs_dirty_inode,
J
Jaegeuk Kim 已提交
650 651 652 653
	.show_options	= f2fs_show_options,
	.evict_inode	= f2fs_evict_inode,
	.put_super	= f2fs_put_super,
	.sync_fs	= f2fs_sync_fs,
654 655
	.freeze_fs	= f2fs_freeze,
	.unfreeze_fs	= f2fs_unfreeze,
J
Jaegeuk Kim 已提交
656
	.statfs		= f2fs_statfs,
657
	.remount_fs	= f2fs_remount,
J
Jaegeuk Kim 已提交
658 659 660 661 662 663 664 665
};

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;

666
	if (unlikely(ino < F2FS_ROOT_INO(sbi)))
J
Jaegeuk Kim 已提交
667
		return ERR_PTR(-ESTALE);
668 669
	if (unlikely(ino >= NM_I(sbi)->max_nid))
		return ERR_PTR(-ESTALE);
J
Jaegeuk Kim 已提交
670 671 672 673 674 675 676 677 678

	/*
	 * 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);
679
	if (unlikely(generation && inode->i_generation != generation)) {
J
Jaegeuk Kim 已提交
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
		/* 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)
{
709
	loff_t result = (DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS);
J
Jaegeuk Kim 已提交
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
	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;
}

727 728
static int sanity_check_raw_super(struct super_block *sb,
			struct f2fs_super_block *raw_super)
J
Jaegeuk Kim 已提交
729 730 731
{
	unsigned int blocksize;

732 733 734 735
	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 已提交
736
		return 1;
737
	}
J
Jaegeuk Kim 已提交
738

739 740 741
	/* Currently, support only 4KB page cache size */
	if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) {
		f2fs_msg(sb, KERN_INFO,
742
			"Invalid page_cache_size (%lu), supports only 4KB\n",
743 744 745 746
			PAGE_CACHE_SIZE);
		return 1;
	}

J
Jaegeuk Kim 已提交
747 748
	/* Currently, support only 4KB block size */
	blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
749
	if (blocksize != F2FS_BLKSIZE) {
750 751 752
		f2fs_msg(sb, KERN_INFO,
			"Invalid blocksize (%u), supports only 4KB\n",
			blocksize);
J
Jaegeuk Kim 已提交
753
		return 1;
754
	}
755

J
Jaegeuk Kim 已提交
756
	if (le32_to_cpu(raw_super->log_sectorsize) !=
757 758
					F2FS_LOG_SECTOR_SIZE) {
		f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize");
J
Jaegeuk Kim 已提交
759
		return 1;
760
	}
J
Jaegeuk Kim 已提交
761
	if (le32_to_cpu(raw_super->log_sectors_per_block) !=
762 763
					F2FS_LOG_SECTORS_PER_BLOCK) {
		f2fs_msg(sb, KERN_INFO, "Invalid log sectors per block");
J
Jaegeuk Kim 已提交
764
		return 1;
765
	}
J
Jaegeuk Kim 已提交
766 767 768
	return 0;
}

769
static int sanity_check_ckpt(struct f2fs_sb_info *sbi)
J
Jaegeuk Kim 已提交
770 771
{
	unsigned int total, fsmeta;
772 773
	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
J
Jaegeuk Kim 已提交
774 775 776 777 778 779 780 781

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

782
	if (unlikely(fsmeta >= total))
J
Jaegeuk Kim 已提交
783
		return 1;
784

785
	if (unlikely(is_set_ckpt_flags(ckpt, CP_ERROR_FLAG))) {
786 787 788
		f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
		return 1;
	}
J
Jaegeuk Kim 已提交
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
	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);
812
	sbi->cur_victim_sec = NULL_SECNO;
813
	sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
J
Jaegeuk Kim 已提交
814 815 816

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

	sbi->dir_level = DEF_DIR_LEVEL;
J
Jaegeuk Kim 已提交
819 820
}

821 822 823 824 825 826 827 828
/*
 * 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)
829
{
830
	int block = 0;
831

832
retry:
833 834
	*raw_super_buf = sb_bread(sb, block);
	if (!*raw_super_buf) {
835 836 837 838 839 840 841 842
		f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
				block + 1);
		if (block == 0) {
			block++;
			goto retry;
		} else {
			return -EIO;
		}
843 844 845 846 847 848
	}

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

	/* sanity checking of raw super */
849 850
	if (sanity_check_raw_super(sb, *raw_super)) {
		brelse(*raw_super_buf);
C
Chris Fries 已提交
851 852 853
		f2fs_msg(sb, KERN_ERR,
			"Can't find valid F2FS filesystem in %dth superblock",
								block + 1);
854
		if (block == 0) {
855 856 857 858 859 860
			block++;
			goto retry;
		} else {
			return -EINVAL;
		}
	}
861

862
	return 0;
863 864
}

J
Jaegeuk Kim 已提交
865 866 867 868 869 870 871
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;
872
	int i;
J
Jaegeuk Kim 已提交
873 874 875 876 877 878

	/* allocate memory for f2fs-specific super block info */
	sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;

879
	/* set a block size */
880
	if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
881
		f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
J
Jaegeuk Kim 已提交
882
		goto free_sbi;
883
	}
J
Jaegeuk Kim 已提交
884

885 886 887 888
	err = read_raw_super_block(sb, &raw_super, &raw_super_buf);
	if (err)
		goto free_sbi;

889
	sb->s_fs_info = sbi;
J
Jaegeuk Kim 已提交
890 891 892 893 894 895 896 897 898 899 900 901
	/* 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 */
902
	err = parse_options(sb, (char *)data);
903
	if (err)
J
Jaegeuk Kim 已提交
904 905
		goto free_sb_buf;

906
	sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize));
J
Jaegeuk Kim 已提交
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
	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);
926
	mutex_init(&sbi->node_write);
H
Haicheng Li 已提交
927
	sbi->por_doing = false;
J
Jaegeuk Kim 已提交
928
	spin_lock_init(&sbi->stat_lock);
929

930
	init_rwsem(&sbi->read_io.io_rwsem);
J
Jaegeuk Kim 已提交
931 932 933
	sbi->read_io.sbi = sbi;
	sbi->read_io.bio = NULL;
	for (i = 0; i < NR_PAGE_TYPE; i++) {
934
		init_rwsem(&sbi->write_io[i].io_rwsem);
J
Jaegeuk Kim 已提交
935 936 937
		sbi->write_io[i].sbi = sbi;
		sbi->write_io[i].bio = NULL;
	}
938

939
	init_rwsem(&sbi->cp_rwsem);
940
	init_waitqueue_head(&sbi->cp_wait);
J
Jaegeuk Kim 已提交
941 942 943 944 945
	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)) {
946
		f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");
J
Jaegeuk Kim 已提交
947 948 949 950 951
		err = PTR_ERR(sbi->meta_inode);
		goto free_sb_buf;
	}

	err = get_valid_checkpoint(sbi);
952 953
	if (err) {
		f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");
J
Jaegeuk Kim 已提交
954
		goto free_meta_inode;
955
	}
J
Jaegeuk Kim 已提交
956 957 958

	/* sanity checking of checkpoint */
	err = -EINVAL;
959
	if (sanity_check_ckpt(sbi)) {
960
		f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint");
J
Jaegeuk Kim 已提交
961
		goto free_cp;
962
	}
J
Jaegeuk Kim 已提交
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979

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

	init_orphan_info(sbi);

	/* setup f2fs internal modules */
	err = build_segment_manager(sbi);
980 981 982
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS segment manager");
J
Jaegeuk Kim 已提交
983
		goto free_sm;
984
	}
J
Jaegeuk Kim 已提交
985
	err = build_node_manager(sbi);
986 987 988
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS node manager");
J
Jaegeuk Kim 已提交
989
		goto free_nm;
990
	}
J
Jaegeuk Kim 已提交
991 992 993 994 995 996

	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)) {
997
		f2fs_msg(sb, KERN_ERR, "Failed to read node inode");
J
Jaegeuk Kim 已提交
998 999 1000 1001 1002
		err = PTR_ERR(sbi->node_inode);
		goto free_nm;
	}

	/* if there are nt orphan nodes free them */
1003
	recover_orphan_inodes(sbi);
J
Jaegeuk Kim 已提交
1004 1005 1006 1007

	/* read root inode and dentry */
	root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
	if (IS_ERR(root)) {
1008
		f2fs_msg(sb, KERN_ERR, "Failed to read root inode");
J
Jaegeuk Kim 已提交
1009 1010 1011
		err = PTR_ERR(root);
		goto free_node_inode;
	}
1012 1013
	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
		err = -EINVAL;
J
Jaegeuk Kim 已提交
1014
		goto free_root_inode;
1015
	}
J
Jaegeuk Kim 已提交
1016 1017 1018 1019 1020 1021 1022 1023 1024

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

1027 1028 1029 1030 1031 1032 1033
	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);

1034 1035 1036 1037 1038 1039 1040 1041
	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");
	}

1042 1043 1044 1045 1046
	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)
1047
		goto free_proc;
1048

1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
	/* recover fsynced data */
	if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
		err = recover_fsync_data(sbi);
		if (err)
			f2fs_msg(sb, KERN_ERR,
				"Cannot recover all fsync data errno=%ld", err);
	}

	/*
	 * If filesystem is not mounted as read-only then
	 * do start the gc_thread.
	 */
	if (!(sb->s_flags & MS_RDONLY)) {
		/* After POR, we can run background GC thread.*/
		err = start_gc_thread(sbi);
		if (err)
			goto free_kobj;
	}
J
Jaegeuk Kim 已提交
1067
	return 0;
1068 1069 1070 1071

free_kobj:
	kobject_del(&sbi->s_kobj);
free_proc:
1072 1073 1074 1075 1076
	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 已提交
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
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);
	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,
};
1111
MODULE_ALIAS_FS("f2fs");
J
Jaegeuk Kim 已提交
1112

1113
static int __init init_inodecache(void)
J
Jaegeuk Kim 已提交
1114 1115
{
	f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache",
1116
			sizeof(struct f2fs_inode_info));
1117
	if (!f2fs_inode_cachep)
J
Jaegeuk Kim 已提交
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
		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)
1141
		goto free_inodecache;
1142
	err = create_segment_manager_caches();
J
Jaegeuk Kim 已提交
1143
	if (err)
1144
		goto free_node_manager_caches;
1145 1146 1147
	err = create_gc_caches();
	if (err)
		goto free_segment_manager_caches;
J
Jaegeuk Kim 已提交
1148 1149
	err = create_checkpoint_caches();
	if (err)
1150
		goto free_gc_caches;
1151
	f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
1152 1153
	if (!f2fs_kset) {
		err = -ENOMEM;
1154
		goto free_checkpoint_caches;
1155
	}
1156 1157
	err = register_filesystem(&f2fs_fs_type);
	if (err)
1158
		goto free_kset;
1159
	f2fs_create_root_stats();
1160
	f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
1161 1162 1163 1164 1165 1166 1167 1168
	return 0;

free_kset:
	kset_unregister(f2fs_kset);
free_checkpoint_caches:
	destroy_checkpoint_caches();
free_gc_caches:
	destroy_gc_caches();
1169 1170
free_segment_manager_caches:
	destroy_segment_manager_caches();
1171 1172 1173 1174
free_node_manager_caches:
	destroy_node_manager_caches();
free_inodecache:
	destroy_inodecache();
J
Jaegeuk Kim 已提交
1175 1176 1177 1178 1179 1180
fail:
	return err;
}

static void __exit exit_f2fs_fs(void)
{
1181
	remove_proc_entry("fs/f2fs", NULL);
1182
	f2fs_destroy_root_stats();
J
Jaegeuk Kim 已提交
1183 1184 1185
	unregister_filesystem(&f2fs_fs_type);
	destroy_checkpoint_caches();
	destroy_gc_caches();
1186
	destroy_segment_manager_caches();
J
Jaegeuk Kim 已提交
1187 1188
	destroy_node_manager_caches();
	destroy_inodecache();
1189
	kset_unregister(f2fs_kset);
J
Jaegeuk Kim 已提交
1190 1191 1192 1193 1194 1195 1196 1197
}

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