super.c 30.2 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(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
194
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
195
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
196 197 198 199 200 201

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

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

	inode_init_once(&fi->vfs_inode);
}

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

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

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

	init_once((void *) fi);

M
Masanari Iida 已提交
367
	/* Initialize f2fs-specific inode info */
J
Jaegeuk Kim 已提交
368 369 370 371 372
	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);
373
	init_rwsem(&fi->i_sem);
J
Jaegeuk Kim 已提交
374 375 376

	set_inode_flag(fi, FI_NEW_INODE);

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

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

J
Jaegeuk Kim 已提交
383 384 385
	return &fi->vfs_inode;
}

386 387 388 389 390 391 392 393 394 395 396 397 398 399
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);
}

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

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

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

J
Jaegeuk Kim 已提交
431 432 433
	f2fs_destroy_stats(sbi);
	stop_gc_thread(sbi);

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

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

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

	kfree(sbi->ckpt);
446 447
	kobject_put(&sbi->s_kobj);
	wait_for_completion(&sbi->s_kobj_unregister);
J
Jaegeuk Kim 已提交
448 449 450 451 452 453 454 455 456 457

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

458 459
	trace_f2fs_sync_fs(sb, sync);

J
Jaegeuk Kim 已提交
460 461 462
	if (!sbi->s_dirty && !get_pages(sbi, F2FS_DIRTY_NODES))
		return 0;

463 464
	if (sync) {
		mutex_lock(&sbi->gc_mutex);
465
		write_checkpoint(sbi, false);
466 467
		mutex_unlock(&sbi->gc_mutex);
	} else {
468
		f2fs_balance_fs(sbi);
469
	}
J
Jaegeuk Kim 已提交
470

471
	return 0;
J
Jaegeuk Kim 已提交
472 473
}

474 475 476 477
static int f2fs_freeze(struct super_block *sb)
{
	int err;

J
Jaegeuk Kim 已提交
478
	if (f2fs_readonly(sb))
479 480 481 482 483 484 485 486 487 488 489
		return 0;

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

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

J
Jaegeuk Kim 已提交
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
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);

508 509
	buf->f_files = sbi->total_node_count;
	buf->f_ffree = sbi->total_node_count - valid_inode_count(sbi);
J
Jaegeuk Kim 已提交
510

511
	buf->f_namelen = F2FS_NAME_LEN;
J
Jaegeuk Kim 已提交
512 513 514 515 516 517 518 519 520 521
	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);

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

	return 0;
}

559 560 561 562
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 已提交
563 564
	unsigned int total_segs =
			le32_to_cpu(sbi->raw_super->segment_count_main);
565 566
	int i;

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

570
	for (i = 0; i < total_segs; i++) {
571 572 573 574 575 576
		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));
577 578
		if ((i % 10) == 9 || i == (total_segs - 1))
			seq_putc(seq, '\n');
579
		else
580
			seq_putc(seq, ' ');
581
	}
582

583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
	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,
};

599 600 601 602 603
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;
604 605
	bool need_restart_gc = false;
	bool need_stop_gc = false;
606

607 608
	sync_filesystem(sb);

609 610 611 612 613 614 615 616 617 618 619 620 621 622
	/*
	 * 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,
623
	 * so skip checking GC and FLUSH_MERGE conditions.
624
	 */
625
	if (f2fs_readonly(sb) && (*flags & MS_RDONLY))
626 627 628 629 630 631 632 633 634 635 636
		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);
637
			need_restart_gc = true;
638 639 640 641 642
		}
	} else if (test_opt(sbi, BG_GC) && !sbi->gc_thread) {
		err = start_gc_thread(sbi);
		if (err)
			goto restore_opts;
643 644 645 646 647 648 649 650
		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)) {
651
		destroy_flush_cmd_control(sbi);
652
	} else if (test_opt(sbi, FLUSH_MERGE) && !SM_I(sbi)->cmd_control_info) {
653 654
		err = create_flush_cmd_control(sbi);
		if (err)
655
			goto restore_gc;
656 657 658 659 660 661
	}
skip:
	/* Update the POSIXACL Flag */
	 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
		(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
	return 0;
662 663 664 665
restore_gc:
	if (need_restart_gc) {
		if (start_gc_thread(sbi))
			f2fs_msg(sbi->sb, KERN_WARNING,
A
arter97 已提交
666
				"background gc thread has stopped");
667 668 669
	} else if (need_stop_gc) {
		stop_gc_thread(sbi);
	}
670 671 672 673 674 675
restore_opts:
	sbi->mount_opt = org_mount_opt;
	sbi->active_logs = active_logs;
	return err;
}

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

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;

698
	if (check_nid_range(sbi, ino))
699
		return ERR_PTR(-ESTALE);
J
Jaegeuk Kim 已提交
700 701 702 703 704 705 706 707 708

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

757 758
static int sanity_check_raw_super(struct super_block *sb,
			struct f2fs_super_block *raw_super)
J
Jaegeuk Kim 已提交
759 760 761
{
	unsigned int blocksize;

762 763 764 765
	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 已提交
766
		return 1;
767
	}
J
Jaegeuk Kim 已提交
768

769 770 771
	/* Currently, support only 4KB page cache size */
	if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) {
		f2fs_msg(sb, KERN_INFO,
772
			"Invalid page_cache_size (%lu), supports only 4KB\n",
773 774 775 776
			PAGE_CACHE_SIZE);
		return 1;
	}

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

J
Jaegeuk Kim 已提交
786
	if (le32_to_cpu(raw_super->log_sectorsize) !=
787 788
					F2FS_LOG_SECTOR_SIZE) {
		f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize");
J
Jaegeuk Kim 已提交
789
		return 1;
790
	}
J
Jaegeuk Kim 已提交
791
	if (le32_to_cpu(raw_super->log_sectors_per_block) !=
792 793
					F2FS_LOG_SECTORS_PER_BLOCK) {
		f2fs_msg(sb, KERN_INFO, "Invalid log sectors per block");
J
Jaegeuk Kim 已提交
794
		return 1;
795
	}
J
Jaegeuk Kim 已提交
796 797 798
	return 0;
}

799
static int sanity_check_ckpt(struct f2fs_sb_info *sbi)
J
Jaegeuk Kim 已提交
800 801
{
	unsigned int total, fsmeta;
802 803
	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
J
Jaegeuk Kim 已提交
804 805 806 807 808 809 810 811

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

812
	if (unlikely(fsmeta >= total))
J
Jaegeuk Kim 已提交
813
		return 1;
814

815
	if (unlikely(is_set_ckpt_flags(ckpt, CP_ERROR_FLAG))) {
816 817 818
		f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
		return 1;
	}
J
Jaegeuk Kim 已提交
819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841
	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);
842
	sbi->cur_victim_sec = NULL_SECNO;
843
	sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
J
Jaegeuk Kim 已提交
844 845 846

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

	sbi->dir_level = DEF_DIR_LEVEL;
J
Jaegeuk Kim 已提交
849 850
}

851 852 853 854 855 856 857 858
/*
 * 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)
859
{
860
	int block = 0;
861

862
retry:
863 864
	*raw_super_buf = sb_bread(sb, block);
	if (!*raw_super_buf) {
865 866 867 868 869 870 871 872
		f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
				block + 1);
		if (block == 0) {
			block++;
			goto retry;
		} else {
			return -EIO;
		}
873 874 875 876 877 878
	}

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

	/* sanity checking of raw super */
879 880
	if (sanity_check_raw_super(sb, *raw_super)) {
		brelse(*raw_super_buf);
C
Chris Fries 已提交
881 882 883
		f2fs_msg(sb, KERN_ERR,
			"Can't find valid F2FS filesystem in %dth superblock",
								block + 1);
884
		if (block == 0) {
885 886 887 888 889 890
			block++;
			goto retry;
		} else {
			return -EINVAL;
		}
	}
891

892
	return 0;
893 894
}

J
Jaegeuk Kim 已提交
895 896 897 898 899 900 901
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;
902
	int i;
J
Jaegeuk Kim 已提交
903 904 905 906 907 908

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

909
	/* set a block size */
910
	if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
911
		f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
J
Jaegeuk Kim 已提交
912
		goto free_sbi;
913
	}
J
Jaegeuk Kim 已提交
914

915 916 917 918
	err = read_raw_super_block(sb, &raw_super, &raw_super_buf);
	if (err)
		goto free_sbi;

919
	sb->s_fs_info = sbi;
J
Jaegeuk Kim 已提交
920 921 922 923 924 925 926 927 928 929 930 931
	/* 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 */
932
	err = parse_options(sb, (char *)data);
933
	if (err)
J
Jaegeuk Kim 已提交
934 935
		goto free_sb_buf;

936
	sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize));
J
Jaegeuk Kim 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
	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);
956
	init_rwsem(&sbi->node_write);
H
Haicheng Li 已提交
957
	sbi->por_doing = false;
J
Jaegeuk Kim 已提交
958
	spin_lock_init(&sbi->stat_lock);
959

960
	init_rwsem(&sbi->read_io.io_rwsem);
J
Jaegeuk Kim 已提交
961 962 963
	sbi->read_io.sbi = sbi;
	sbi->read_io.bio = NULL;
	for (i = 0; i < NR_PAGE_TYPE; i++) {
964
		init_rwsem(&sbi->write_io[i].io_rwsem);
J
Jaegeuk Kim 已提交
965 966 967
		sbi->write_io[i].sbi = sbi;
		sbi->write_io[i].bio = NULL;
	}
968

969
	init_rwsem(&sbi->cp_rwsem);
970
	init_waitqueue_head(&sbi->cp_wait);
J
Jaegeuk Kim 已提交
971 972 973 974 975
	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)) {
976
		f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");
J
Jaegeuk Kim 已提交
977 978 979 980 981
		err = PTR_ERR(sbi->meta_inode);
		goto free_sb_buf;
	}

	err = get_valid_checkpoint(sbi);
982 983
	if (err) {
		f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");
J
Jaegeuk Kim 已提交
984
		goto free_meta_inode;
985
	}
J
Jaegeuk Kim 已提交
986 987 988

	/* sanity checking of checkpoint */
	err = -EINVAL;
989
	if (sanity_check_ckpt(sbi)) {
990
		f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint");
J
Jaegeuk Kim 已提交
991
		goto free_cp;
992
	}
J
Jaegeuk Kim 已提交
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005

	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 已提交
1006
	init_ino_entry_info(sbi);
J
Jaegeuk Kim 已提交
1007 1008 1009

	/* setup f2fs internal modules */
	err = build_segment_manager(sbi);
1010 1011 1012
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS segment manager");
J
Jaegeuk Kim 已提交
1013
		goto free_sm;
1014
	}
J
Jaegeuk Kim 已提交
1015
	err = build_node_manager(sbi);
1016 1017 1018
	if (err) {
		f2fs_msg(sb, KERN_ERR,
			"Failed to initialize F2FS node manager");
J
Jaegeuk Kim 已提交
1019
		goto free_nm;
1020
	}
J
Jaegeuk Kim 已提交
1021 1022 1023 1024 1025 1026

	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)) {
1027
		f2fs_msg(sb, KERN_ERR, "Failed to read node inode");
J
Jaegeuk Kim 已提交
1028 1029 1030 1031 1032
		err = PTR_ERR(sbi->node_inode);
		goto free_nm;
	}

	/* if there are nt orphan nodes free them */
1033
	recover_orphan_inodes(sbi);
J
Jaegeuk Kim 已提交
1034 1035 1036 1037

	/* read root inode and dentry */
	root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
	if (IS_ERR(root)) {
1038
		f2fs_msg(sb, KERN_ERR, "Failed to read root inode");
J
Jaegeuk Kim 已提交
1039 1040 1041
		err = PTR_ERR(root);
		goto free_node_inode;
	}
1042
	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
1043
		iput(root);
1044
		err = -EINVAL;
1045
		goto free_node_inode;
1046
	}
J
Jaegeuk Kim 已提交
1047 1048 1049 1050 1051 1052 1053 1054 1055

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

1058 1059 1060 1061 1062 1063 1064
	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);

1065 1066 1067 1068 1069 1070 1071 1072
	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");
	}

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

1080 1081 1082 1083 1084 1085 1086
	/* 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);
	}
1087

1088 1089 1090 1091
	/*
	 * If filesystem is not mounted as read-only then
	 * do start the gc_thread.
	 */
1092
	if (!f2fs_readonly(sb)) {
1093 1094 1095 1096 1097
		/* After POR, we can run background GC thread.*/
		err = start_gc_thread(sbi);
		if (err)
			goto free_kobj;
	}
J
Jaegeuk Kim 已提交
1098
	return 0;
1099 1100 1101 1102

free_kobj:
	kobject_del(&sbi->s_kobj);
free_proc:
1103 1104 1105 1106 1107
	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 已提交
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
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,
};
1142
MODULE_ALIAS_FS("f2fs");
J
Jaegeuk Kim 已提交
1143

1144
static int __init init_inodecache(void)
J
Jaegeuk Kim 已提交
1145 1146
{
	f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache",
1147
			sizeof(struct f2fs_inode_info));
1148
	if (!f2fs_inode_cachep)
J
Jaegeuk Kim 已提交
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
		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)
1172
		goto free_inodecache;
1173
	err = create_segment_manager_caches();
J
Jaegeuk Kim 已提交
1174
	if (err)
1175
		goto free_node_manager_caches;
1176 1177 1178
	err = create_gc_caches();
	if (err)
		goto free_segment_manager_caches;
J
Jaegeuk Kim 已提交
1179 1180
	err = create_checkpoint_caches();
	if (err)
1181
		goto free_gc_caches;
1182
	f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
1183 1184
	if (!f2fs_kset) {
		err = -ENOMEM;
1185
		goto free_checkpoint_caches;
1186
	}
1187 1188
	err = register_filesystem(&f2fs_fs_type);
	if (err)
1189
		goto free_kset;
1190
	f2fs_create_root_stats();
1191
	f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
1192 1193 1194 1195 1196 1197 1198 1199
	return 0;

free_kset:
	kset_unregister(f2fs_kset);
free_checkpoint_caches:
	destroy_checkpoint_caches();
free_gc_caches:
	destroy_gc_caches();
1200 1201
free_segment_manager_caches:
	destroy_segment_manager_caches();
1202 1203 1204 1205
free_node_manager_caches:
	destroy_node_manager_caches();
free_inodecache:
	destroy_inodecache();
J
Jaegeuk Kim 已提交
1206 1207 1208 1209 1210 1211
fail:
	return err;
}

static void __exit exit_f2fs_fs(void)
{
1212
	remove_proc_entry("fs/f2fs", NULL);
1213
	f2fs_destroy_root_stats();
J
Jaegeuk Kim 已提交
1214 1215 1216
	unregister_filesystem(&f2fs_fs_type);
	destroy_checkpoint_caches();
	destroy_gc_caches();
1217
	destroy_segment_manager_caches();
J
Jaegeuk Kim 已提交
1218 1219
	destroy_node_manager_caches();
	destroy_inodecache();
1220
	kset_unregister(f2fs_kset);
J
Jaegeuk Kim 已提交
1221 1222 1223 1224 1225 1226 1227 1228
}

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