super.c 35.3 KB
Newer Older
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1
/*
Jaegeuk Kim's avatar
Jaegeuk Kim committed
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>
Jaegeuk Kim's avatar
Jaegeuk Kim committed
22 23
#include <linux/random.h>
#include <linux/exportfs.h>
24
#include <linux/blkdev.h>
Jaegeuk Kim's avatar
Jaegeuk Kim committed
25
#include <linux/f2fs_fs.h>
26
#include <linux/sysfs.h>
Jaegeuk Kim's avatar
Jaegeuk Kim committed
27 28 29

#include "f2fs.h"
#include "node.h"
30
#include "segment.h"
Jaegeuk Kim's avatar
Jaegeuk Kim committed
31
#include "xattr.h"
32
#include "gc.h"
Jaegeuk Kim's avatar
Jaegeuk Kim committed
33
#include "trace.h"
Jaegeuk Kim's avatar
Jaegeuk Kim committed
34

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

38
static struct proc_dir_entry *f2fs_proc_root;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
39
static struct kmem_cache *f2fs_inode_cachep;
40
static struct kset *f2fs_kset;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
41 42

enum {
43
	Opt_gc_background,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
44
	Opt_disable_roll_forward,
45
	Opt_norecovery,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
46 47
	Opt_discard,
	Opt_noheap,
48
	Opt_user_xattr,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
49
	Opt_nouser_xattr,
50
	Opt_acl,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
51 52 53
	Opt_noacl,
	Opt_active_logs,
	Opt_disable_ext_identify,
54
	Opt_inline_xattr,
55
	Opt_inline_data,
56
	Opt_inline_dentry,
57
	Opt_flush_merge,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
58
	Opt_nobarrier,
59
	Opt_fastboot,
60
	Opt_extent_cache,
61
	Opt_noinline_data,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
62 63 64 65
	Opt_err,
};

static match_table_t f2fs_tokens = {
66
	{Opt_gc_background, "background_gc=%s"},
Jaegeuk Kim's avatar
Jaegeuk Kim committed
67
	{Opt_disable_roll_forward, "disable_roll_forward"},
68
	{Opt_norecovery, "norecovery"},
Jaegeuk Kim's avatar
Jaegeuk Kim committed
69 70
	{Opt_discard, "discard"},
	{Opt_noheap, "no_heap"},
71
	{Opt_user_xattr, "user_xattr"},
Jaegeuk Kim's avatar
Jaegeuk Kim committed
72
	{Opt_nouser_xattr, "nouser_xattr"},
73
	{Opt_acl, "acl"},
Jaegeuk Kim's avatar
Jaegeuk Kim committed
74 75 76
	{Opt_noacl, "noacl"},
	{Opt_active_logs, "active_logs=%u"},
	{Opt_disable_ext_identify, "disable_ext_identify"},
77
	{Opt_inline_xattr, "inline_xattr"},
78
	{Opt_inline_data, "inline_data"},
79
	{Opt_inline_dentry, "inline_dentry"},
80
	{Opt_flush_merge, "flush_merge"},
Jaegeuk Kim's avatar
Jaegeuk Kim committed
81
	{Opt_nobarrier, "nobarrier"},
82
	{Opt_fastboot, "fastboot"},
83
	{Opt_extent_cache, "extent_cache"},
84
	{Opt_noinline_data, "noinline_data"},
Jaegeuk Kim's avatar
Jaegeuk Kim committed
85 86 87
	{Opt_err, NULL},
};

88
/* Sysfs support for f2fs */
89 90 91
enum {
	GC_THREAD,	/* struct f2fs_gc_thread */
	SM_INFO,	/* struct f2fs_sm_info */
92
	NM_INFO,	/* struct f2fs_nm_info */
93
	F2FS_SBI,	/* struct f2fs_sb_info */
94 95
};

96 97 98 99 100
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);
101
	int struct_type;
102 103 104
	int offset;
};

105 106 107 108 109 110
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);
111 112
	else if (struct_type == NM_INFO)
		return (unsigned char *)NM_I(sbi);
113 114
	else if (struct_type == F2FS_SBI)
		return (unsigned char *)sbi;
115 116 117
	return NULL;
}

118 119 120
static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
			struct f2fs_sb_info *sbi, char *buf)
{
121
	unsigned char *ptr = NULL;
122 123
	unsigned int *ui;

124 125
	ptr = __struct_ptr(sbi, a->struct_type);
	if (!ptr)
126 127
		return -EINVAL;

128
	ui = (unsigned int *)(ptr + a->offset);
129 130 131 132 133 134 135 136

	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)
{
137
	unsigned char *ptr;
138 139 140 141
	unsigned long t;
	unsigned int *ui;
	ssize_t ret;

142 143
	ptr = __struct_ptr(sbi, a->struct_type);
	if (!ptr)
144 145
		return -EINVAL;

146
	ui = (unsigned int *)(ptr + a->offset);
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181

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

182
#define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
183 184 185 186
static struct f2fs_attr f2fs_attr_##_name = {			\
	.attr = {.name = __stringify(_name), .mode = _mode },	\
	.show	= _show,					\
	.store	= _store,					\
187 188
	.struct_type = _struct_type,				\
	.offset = _offset					\
189 190
}

191 192 193 194
#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))
195

196 197 198 199 200
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);
201
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, max_small_discards, max_discards);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
202
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);
203 204
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);
205
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
206
F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
207
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
208
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
209 210 211 212 213 214

#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),
215
	ATTR_LIST(gc_idle),
216
	ATTR_LIST(reclaim_segments),
217
	ATTR_LIST(max_small_discards),
Jaegeuk Kim's avatar
Jaegeuk Kim committed
218
	ATTR_LIST(batched_trim_sections),
219 220
	ATTR_LIST(ipu_policy),
	ATTR_LIST(min_ipu_util),
221
	ATTR_LIST(min_fsync_blocks),
222
	ATTR_LIST(max_victim_search),
223
	ATTR_LIST(dir_level),
224
	ATTR_LIST(ram_thresh),
225 226 227 228 229 230 231 232 233 234 235 236 237 238
	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,
};

239 240 241 242 243 244 245 246 247 248 249 250
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);
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
251 252 253 254 255 256 257
static void init_once(void *foo)
{
	struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;

	inode_init_once(&fi->vfs_inode);
}

258 259 260
static int parse_options(struct super_block *sb, char *options)
{
	struct f2fs_sb_info *sbi = F2FS_SB(sb);
261
	struct request_queue *q;
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
	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;
286
			if (strlen(name) == 2 && !strncmp(name, "on", 2))
287
				set_opt(sbi, BG_GC);
288
			else if (strlen(name) == 3 && !strncmp(name, "off", 3))
289 290 291 292 293 294 295 296 297 298
				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;
299 300 301 302 303 304
		case Opt_norecovery:
			/* this option mounts f2fs with ro */
			set_opt(sbi, DISABLE_ROLL_FORWARD);
			if (!f2fs_readonly(sb))
				return -EINVAL;
			break;
305
		case Opt_discard:
306 307 308 309 310 311 312 313
			q = bdev_get_queue(sb->s_bdev);
			if (blk_queue_discard(q)) {
				set_opt(sbi, DISCARD);
			} else {
				f2fs_msg(sb, KERN_WARNING,
					"mounting with \"discard\" option, but "
					"the device does not support discard");
			}
314 315 316 317 318
			break;
		case Opt_noheap:
			set_opt(sbi, NOHEAP);
			break;
#ifdef CONFIG_F2FS_FS_XATTR
319 320 321
		case Opt_user_xattr:
			set_opt(sbi, XATTR_USER);
			break;
322 323 324
		case Opt_nouser_xattr:
			clear_opt(sbi, XATTR_USER);
			break;
325 326 327
		case Opt_inline_xattr:
			set_opt(sbi, INLINE_XATTR);
			break;
328
#else
329 330 331 332
		case Opt_user_xattr:
			f2fs_msg(sb, KERN_INFO,
				"user_xattr options not supported");
			break;
333 334 335 336
		case Opt_nouser_xattr:
			f2fs_msg(sb, KERN_INFO,
				"nouser_xattr options not supported");
			break;
337 338 339 340
		case Opt_inline_xattr:
			f2fs_msg(sb, KERN_INFO,
				"inline_xattr options not supported");
			break;
341 342
#endif
#ifdef CONFIG_F2FS_FS_POSIX_ACL
343 344 345
		case Opt_acl:
			set_opt(sbi, POSIX_ACL);
			break;
346 347 348 349
		case Opt_noacl:
			clear_opt(sbi, POSIX_ACL);
			break;
#else
350 351 352
		case Opt_acl:
			f2fs_msg(sb, KERN_INFO, "acl options not supported");
			break;
353 354 355 356 357 358 359 360 361 362 363 364 365 366
		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;
367 368 369
		case Opt_inline_data:
			set_opt(sbi, INLINE_DATA);
			break;
370 371 372
		case Opt_inline_dentry:
			set_opt(sbi, INLINE_DENTRY);
			break;
373 374 375
		case Opt_flush_merge:
			set_opt(sbi, FLUSH_MERGE);
			break;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
376 377 378
		case Opt_nobarrier:
			set_opt(sbi, NOBARRIER);
			break;
379 380 381
		case Opt_fastboot:
			set_opt(sbi, FASTBOOT);
			break;
382 383 384
		case Opt_extent_cache:
			set_opt(sbi, EXTENT_CACHE);
			break;
385 386 387
		case Opt_noinline_data:
			clear_opt(sbi, INLINE_DATA);
			break;
388 389 390 391 392 393 394 395 396 397
		default:
			f2fs_msg(sb, KERN_ERR,
				"Unrecognized mount option \"%s\" or missing value",
				p);
			return -EINVAL;
		}
	}
	return 0;
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
398 399 400 401
static struct inode *f2fs_alloc_inode(struct super_block *sb)
{
	struct f2fs_inode_info *fi;

402
	fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
403 404 405 406 407
	if (!fi)
		return NULL;

	init_once((void *) fi);

Masanari Iida's avatar
Masanari Iida committed
408
	/* Initialize f2fs-specific inode info */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
409
	fi->vfs_inode.i_version = 1;
410
	atomic_set(&fi->dirty_pages, 0);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
411 412
	fi->i_current_depth = 1;
	fi->i_advise = 0;
413
	rwlock_init(&fi->ext_lock);
414
	init_rwsem(&fi->i_sem);
415
	INIT_RADIX_TREE(&fi->inmem_root, GFP_NOFS);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
416 417
	INIT_LIST_HEAD(&fi->inmem_pages);
	mutex_init(&fi->inmem_lock);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
418 419 420

	set_inode_flag(fi, FI_NEW_INODE);

421 422 423
	if (test_opt(F2FS_SB(sb), INLINE_XATTR))
		set_inode_flag(fi, FI_INLINE_XATTR);

424 425 426
	/* Will be used by directory only */
	fi->i_dir_level = F2FS_SB(sb)->dir_level;

427 428 429
#ifdef CONFIG_F2FS_FS_ENCRYPTION
	fi->i_crypt_info = NULL;
#endif
Jaegeuk Kim's avatar
Jaegeuk Kim committed
430 431 432
	return &fi->vfs_inode;
}

433 434 435 436 437 438 439 440 441
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)
	 */
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
	if (!inode_unhashed(inode) && inode->i_state & I_SYNC) {
		if (!inode->i_nlink && !is_bad_inode(inode)) {
			spin_unlock(&inode->i_lock);

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

			sb_start_intwrite(inode->i_sb);
			i_size_write(inode, 0);

			if (F2FS_HAS_BLOCKS(inode))
				f2fs_truncate(inode);

			sb_end_intwrite(inode->i_sb);

#ifdef CONFIG_F2FS_FS_ENCRYPTION
			if (F2FS_I(inode)->i_crypt_info)
460 461
				f2fs_free_encryption_info(inode,
					F2FS_I(inode)->i_crypt_info);
462 463 464
#endif
			spin_lock(&inode->i_lock);
		}
465
		return 0;
466
	}
467 468 469
	return generic_drop_inode(inode);
}

470 471 472 473 474 475 476 477 478 479
/*
 * 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);
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
480 481 482 483 484 485
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));
}

486
static void f2fs_destroy_inode(struct inode *inode)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
487 488 489 490 491 492 493 494
{
	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);

495 496 497 498
	if (sbi->s_proc) {
		remove_proc_entry("segment_info", sbi->s_proc);
		remove_proc_entry(sb->s_id, f2fs_proc_root);
	}
499
	kobject_del(&sbi->s_kobj);
500

Jaegeuk Kim's avatar
Jaegeuk Kim committed
501 502 503
	f2fs_destroy_stats(sbi);
	stop_gc_thread(sbi);

504 505 506 507 508
	/*
	 * We don't need to do checkpoint when superblock is clean.
	 * But, the previous checkpoint was not done by umount, it needs to do
	 * clean checkpoint again.
	 */
509
	if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
510
			!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG)) {
511 512 513 514 515
		struct cp_control cpc = {
			.reason = CP_UMOUNT,
		};
		write_checkpoint(sbi, &cpc);
	}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
516

517 518 519 520
	/*
	 * normally superblock is clean, so we need to release this.
	 * In addition, EIO will skip do checkpoint, we need this as well.
	 */
521
	release_dirty_inode(sbi);
522
	release_discard_addrs(sbi);
523

Jaegeuk Kim's avatar
Jaegeuk Kim committed
524 525 526 527 528 529 530 531
	iput(sbi->node_inode);
	iput(sbi->meta_inode);

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

	kfree(sbi->ckpt);
532 533
	kobject_put(&sbi->s_kobj);
	wait_for_completion(&sbi->s_kobj_unregister);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
534 535 536 537 538 539 540 541 542 543

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

544 545
	trace_f2fs_sync_fs(sb, sync);

546
	if (sync) {
547 548
		struct cp_control cpc;

549 550
		cpc.reason = __get_cp_reason(sbi);

551
		mutex_lock(&sbi->gc_mutex);
552
		write_checkpoint(sbi, &cpc);
553 554
		mutex_unlock(&sbi->gc_mutex);
	} else {
555
		f2fs_balance_fs(sbi);
556
	}
557
	f2fs_trace_ios(NULL, 1);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
558

559
	return 0;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
560 561
}

562 563 564 565
static int f2fs_freeze(struct super_block *sb)
{
	int err;

Jaegeuk Kim's avatar
Jaegeuk Kim committed
566
	if (f2fs_readonly(sb))
567 568 569 570 571 572 573 574 575 576 577
		return 0;

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

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

Jaegeuk Kim's avatar
Jaegeuk Kim committed
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
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);

596 597
	buf->f_files = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
	buf->f_ffree = buf->f_files - valid_inode_count(sbi);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
598

599
	buf->f_namelen = F2FS_NAME_LEN;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
600 601 602 603 604 605 606 607 608 609
	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);

610
	if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC))
611
		seq_printf(seq, ",background_gc=%s", "on");
Jaegeuk Kim's avatar
Jaegeuk Kim committed
612
	else
613
		seq_printf(seq, ",background_gc=%s", "off");
Jaegeuk Kim's avatar
Jaegeuk Kim committed
614 615 616 617 618 619 620 621 622 623 624
	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");
625 626
	if (test_opt(sbi, INLINE_XATTR))
		seq_puts(seq, ",inline_xattr");
Jaegeuk Kim's avatar
Jaegeuk Kim committed
627 628 629 630 631 632 633 634
#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))
635
		seq_puts(seq, ",disable_ext_identify");
636 637
	if (test_opt(sbi, INLINE_DATA))
		seq_puts(seq, ",inline_data");
638 639
	else
		seq_puts(seq, ",noinline_data");
640 641
	if (test_opt(sbi, INLINE_DENTRY))
		seq_puts(seq, ",inline_dentry");
642
	if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
643
		seq_puts(seq, ",flush_merge");
Jaegeuk Kim's avatar
Jaegeuk Kim committed
644 645
	if (test_opt(sbi, NOBARRIER))
		seq_puts(seq, ",nobarrier");
646 647
	if (test_opt(sbi, FASTBOOT))
		seq_puts(seq, ",fastboot");
648 649
	if (test_opt(sbi, EXTENT_CACHE))
		seq_puts(seq, ",extent_cache");
Jaegeuk Kim's avatar
Jaegeuk Kim committed
650 651 652 653 654
	seq_printf(seq, ",active_logs=%u", sbi->active_logs);

	return 0;
}

655 656 657 658
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);
Chris Fries's avatar
Chris Fries committed
659 660
	unsigned int total_segs =
			le32_to_cpu(sbi->raw_super->segment_count_main);
661 662
	int i;

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

666
	for (i = 0; i < total_segs; i++) {
667 668 669 670 671 672
		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));
673 674
		if ((i % 10) == 9 || i == (total_segs - 1))
			seq_putc(seq, '\n');
675
		else
676
			seq_putc(seq, ' ');
677
	}
678

679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
	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,
};

695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
static void default_options(struct f2fs_sb_info *sbi)
{
	/* init some FS parameters */
	sbi->active_logs = NR_CURSEG_TYPE;

	set_opt(sbi, BG_GC);
	set_opt(sbi, INLINE_DATA);

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

711 712 713 714 715
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;
716 717
	bool need_restart_gc = false;
	bool need_stop_gc = false;
718

719 720
	sync_filesystem(sb);

721 722 723 724 725 726 727
	/*
	 * Save the old mount options in case we
	 * need to restore them.
	 */
	org_mount_opt = sbi->mount_opt;
	active_logs = sbi->active_logs;

728
	sbi->mount_opt.opt = 0;
729
	default_options(sbi);
730

731 732 733 734 735 736 737
	/* parse mount options */
	err = parse_options(sb, data);
	if (err)
		goto restore_opts;

	/*
	 * Previous and new state of filesystem is RO,
738
	 * so skip checking GC and FLUSH_MERGE conditions.
739
	 */
740
	if (f2fs_readonly(sb) && (*flags & MS_RDONLY))
741 742 743 744 745 746 747 748 749 750 751
		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);
752
			need_restart_gc = true;
753
		}
754
	} else if (!sbi->gc_thread) {
755 756 757
		err = start_gc_thread(sbi);
		if (err)
			goto restore_opts;
758 759 760 761 762 763 764 765
		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)) {
766
		destroy_flush_cmd_control(sbi);
767
	} else if (!SM_I(sbi)->cmd_control_info) {
768 769
		err = create_flush_cmd_control(sbi);
		if (err)
770
			goto restore_gc;
771 772 773 774 775 776
	}
skip:
	/* Update the POSIXACL Flag */
	 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
		(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
	return 0;
777 778 779 780
restore_gc:
	if (need_restart_gc) {
		if (start_gc_thread(sbi))
			f2fs_msg(sbi->sb, KERN_WARNING,
arter97's avatar
arter97 committed
781
				"background gc thread has stopped");
782 783 784
	} else if (need_stop_gc) {
		stop_gc_thread(sbi);
	}
785 786 787 788 789 790
restore_opts:
	sbi->mount_opt = org_mount_opt;
	sbi->active_logs = active_logs;
	return err;
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
791 792
static struct super_operations f2fs_sops = {
	.alloc_inode	= f2fs_alloc_inode,
793
	.drop_inode	= f2fs_drop_inode,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
794 795
	.destroy_inode	= f2fs_destroy_inode,
	.write_inode	= f2fs_write_inode,
796
	.dirty_inode	= f2fs_dirty_inode,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
797 798 799 800
	.show_options	= f2fs_show_options,
	.evict_inode	= f2fs_evict_inode,
	.put_super	= f2fs_put_super,
	.sync_fs	= f2fs_sync_fs,
801 802
	.freeze_fs	= f2fs_freeze,
	.unfreeze_fs	= f2fs_unfreeze,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
803
	.statfs		= f2fs_statfs,
804
	.remount_fs	= f2fs_remount,
Jaegeuk Kim's avatar
Jaegeuk Kim committed
805 806 807 808 809 810 811 812
};

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;

813
	if (check_nid_range(sbi, ino))
814
		return ERR_PTR(-ESTALE);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
815 816 817 818 819 820 821 822 823

	/*
	 * 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);
824
	if (unlikely(generation && inode->i_generation != generation)) {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853
		/* 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)
{
854
	loff_t result = (DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
	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;
}

872 873
static int sanity_check_raw_super(struct super_block *sb,
			struct f2fs_super_block *raw_super)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
874 875 876
{
	unsigned int blocksize;

877 878 879 880
	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));
Jaegeuk Kim's avatar
Jaegeuk Kim committed
881
		return 1;
882
	}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
883

884 885 886
	/* Currently, support only 4KB page cache size */
	if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) {
		f2fs_msg(sb, KERN_INFO,
887
			"Invalid page_cache_size (%lu), supports only 4KB\n",
888 889 890 891
			PAGE_CACHE_SIZE);
		return 1;
	}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
892 893
	/* Currently, support only 4KB block size */
	blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
894
	if (blocksize != F2FS_BLKSIZE) {
895 896 897
		f2fs_msg(sb, KERN_INFO,
			"Invalid blocksize (%u), supports only 4KB\n",
			blocksize);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
898
		return 1;
899
	}
900

Chao Yu's avatar
Chao Yu committed
901 902 903 904 905 906 907
	/* 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));
Jaegeuk Kim's avatar
Jaegeuk Kim committed
908
		return 1;
909
	}
Chao Yu's avatar
Chao Yu committed
910 911 912 913 914 915 916
	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));
Jaegeuk Kim's avatar
Jaegeuk Kim committed
917
		return 1;
918
	}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
919 920 921
	return 0;
}

922
static int sanity_check_ckpt(struct f2fs_sb_info *sbi)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
923 924
{
	unsigned int total, fsmeta;
925 926
	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
927 928 929 930 931 932 933 934

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

935
	if (unlikely(fsmeta >= total))
Jaegeuk Kim's avatar
Jaegeuk Kim committed
936
		return 1;
937

938
	if (unlikely(f2fs_cp_error(sbi))) {
939 940 941
		f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
		return 1;
	}
Jaegeuk Kim's avatar
Jaegeuk Kim committed
942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
	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);
965
	sbi->cur_victim_sec = NULL_SECNO;
966
	sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
Jaegeuk Kim's avatar
Jaegeuk Kim committed
967 968 969

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

	sbi->dir_level = DEF_DIR_LEVEL;
972
	clear_sbi_flag(sbi, SBI_NEED_FSCK);
Jaegeuk Kim's avatar
Jaegeuk Kim committed
973 974
}

975 976 977 978 979 980 981
/*
 * 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,
982 983
			struct buffer_head **raw_super_buf,
			int *recovery)
984
{
985
	int block = 0;
986 987 988
	struct buffer_head *buffer;
	struct f2fs_super_block *super;
	int err = 0;
989

990
retry:
991 992 993
	buffer = sb_bread(sb, block);
	if (!buffer) {
		*recovery = 1;
994 995 996 997 998 999
		f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
				block + 1);
		if (block == 0) {
			block++;
			goto retry;
		} else {
1000 1001
			err = -EIO;
			goto out;
1002
		}
1003 1004
	}

1005 1006
	super = (struct f2fs_super_block *)
		((char *)(buffer)->b_data + F2FS_SUPER_OFFSET);
1007 1008

	/* sanity checking of raw super */
1009 1010 1011
	if (sanity_check_raw_super(sb, super)) {
		brelse(buffer);
		*recovery = 1;
Chris Fries's avatar
Chris Fries committed
1012 1013 1014
		f2fs_msg(sb, KERN_ERR,
			"Can't find valid F2FS filesystem in %dth superblock",
								block + 1);
1015
		if (block == 0) {
1016 1017 1018
			block++;
			goto retry;
		} else {
1019 1020
			err = -EINVAL;
			goto out;
1021 1022
		}
	}
1023

1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
	if (!*raw_super) {
		*raw_super_buf = buffer;
		*raw_super = super;
	} else {
		/* already have a valid superblock */
		brelse(buffer);
	}

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

out:
	/* No valid superblock */
	if (!*raw_super)
		return err;

1043
	return 0;
1044 1045
}

1046
int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
{
	struct buffer_head *sbh = sbi->raw_super_buf;
	sector_t block = sbh->b_blocknr;
	int err;

	/* write b