super.c 29.7 KB
Newer Older
R
Ryusuke Konishi 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
/*
 * super.c - NILFS module and super block management.
 *
 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Written by Ryusuke Konishi <ryusuke@osrg.net>
 */
/*
 *  linux/fs/ext2/super.c
 *
 * Copyright (C) 1992, 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *
 *  from
 *
 *  linux/fs/minix/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  Big-endian to little-endian byte-swapping/bitmaps by
 *        David S. Miller (davem@caip.rutgers.edu), 1995
 */

#include <linux/module.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/parser.h>
#include <linux/random.h>
#include <linux/crc32.h>
#include <linux/smp_lock.h>
#include <linux/vfs.h>
#include <linux/writeback.h>
#include <linux/kobject.h>
#include <linux/exportfs.h>
53 54
#include <linux/seq_file.h>
#include <linux/mount.h>
R
Ryusuke Konishi 已提交
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
#include "nilfs.h"
#include "mdt.h"
#include "alloc.h"
#include "page.h"
#include "cpfile.h"
#include "ifile.h"
#include "dat.h"
#include "segment.h"
#include "segbuf.h"

MODULE_AUTHOR("NTT Corp.");
MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem "
		   "(NILFS)");
MODULE_LICENSE("GPL");

70 71 72 73 74
struct kmem_cache *nilfs_inode_cachep;
struct kmem_cache *nilfs_transaction_cachep;
struct kmem_cache *nilfs_segbuf_cachep;
struct kmem_cache *nilfs_btree_path_cache;

R
Ryusuke Konishi 已提交
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
static int nilfs_remount(struct super_block *sb, int *flags, char *data);

/**
 * nilfs_error() - report failure condition on a filesystem
 *
 * nilfs_error() sets an ERROR_FS flag on the superblock as well as
 * reporting an error message.  It should be called when NILFS detects
 * incoherences or defects of meta data on disk.  As for sustainable
 * errors such as a single-shot I/O error, nilfs_warning() or the printk()
 * function should be used instead.
 *
 * The segment constructor must not call this function because it can
 * kill itself.
 */
void nilfs_error(struct super_block *sb, const char *function,
		 const char *fmt, ...)
{
	struct nilfs_sb_info *sbi = NILFS_SB(sb);
	va_list args;

	va_start(args, fmt);
	printk(KERN_CRIT "NILFS error (device %s): %s: ", sb->s_id, function);
	vprintk(fmt, args);
	printk("\n");
	va_end(args);

	if (!(sb->s_flags & MS_RDONLY)) {
		struct the_nilfs *nilfs = sbi->s_nilfs;

		down_write(&nilfs->ns_sem);
		if (!(nilfs->ns_mount_state & NILFS_ERROR_FS)) {
			nilfs->ns_mount_state |= NILFS_ERROR_FS;
107 108 109
			nilfs->ns_sbp[0]->s_state |=
				cpu_to_le16(NILFS_ERROR_FS);
			nilfs_commit_super(sbi, 1);
R
Ryusuke Konishi 已提交
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
		}
		up_write(&nilfs->ns_sem);

		if (nilfs_test_opt(sbi, ERRORS_RO)) {
			printk(KERN_CRIT "Remounting filesystem read-only\n");
			sb->s_flags |= MS_RDONLY;
		}
	}

	if (nilfs_test_opt(sbi, ERRORS_PANIC))
		panic("NILFS (device %s): panic forced after error\n",
		      sb->s_id);
}

void nilfs_warning(struct super_block *sb, const char *function,
		   const char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	printk(KERN_WARNING "NILFS warning (device %s): %s: ",
	       sb->s_id, function);
	vprintk(fmt, args);
	printk("\n");
	va_end(args);
}


138
struct inode *nilfs_alloc_inode_common(struct the_nilfs *nilfs)
R
Ryusuke Konishi 已提交
139 140 141 142 143 144 145 146 147
{
	struct nilfs_inode_info *ii;

	ii = kmem_cache_alloc(nilfs_inode_cachep, GFP_NOFS);
	if (!ii)
		return NULL;
	ii->i_bh = NULL;
	ii->i_state = 0;
	ii->vfs_inode.i_version = 1;
148
	nilfs_btnode_cache_init(&ii->i_btnode_cache, nilfs->ns_bdi);
R
Ryusuke Konishi 已提交
149 150 151
	return &ii->vfs_inode;
}

152 153 154 155 156
struct inode *nilfs_alloc_inode(struct super_block *sb)
{
	return nilfs_alloc_inode_common(NILFS_SB(sb)->s_nilfs);
}

R
Ryusuke Konishi 已提交
157 158 159 160 161 162 163 164 165 166 167 168
void nilfs_destroy_inode(struct inode *inode)
{
	kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode));
}

static void nilfs_clear_inode(struct inode *inode)
{
	struct nilfs_inode_info *ii = NILFS_I(inode);

	/*
	 * Free resources allocated in nilfs_read_inode(), here.
	 */
169
	BUG_ON(!list_empty(&ii->i_dirty));
R
Ryusuke Konishi 已提交
170 171 172 173 174 175 176 177 178
	brelse(ii->i_bh);
	ii->i_bh = NULL;

	if (test_bit(NILFS_I_BMAP, &ii->i_state))
		nilfs_bmap_clear(ii->i_bmap);

	nilfs_btnode_cache_clear(&ii->i_btnode_cache);
}

179
static int nilfs_sync_super(struct nilfs_sb_info *sbi, int dupsb)
R
Ryusuke Konishi 已提交
180 181 182 183 184 185
{
	struct the_nilfs *nilfs = sbi->s_nilfs;
	int err;
	int barrier_done = 0;

	if (nilfs_test_opt(sbi, BARRIER)) {
186
		set_buffer_ordered(nilfs->ns_sbh[0]);
R
Ryusuke Konishi 已提交
187 188 189
		barrier_done = 1;
	}
 retry:
190 191
	set_buffer_dirty(nilfs->ns_sbh[0]);
	err = sync_dirty_buffer(nilfs->ns_sbh[0]);
R
Ryusuke Konishi 已提交
192 193 194 195 196 197
	if (err == -EOPNOTSUPP && barrier_done) {
		nilfs_warning(sbi->s_super, __func__,
			      "barrier-based sync failed. "
			      "disabling barriers\n");
		nilfs_clear_opt(sbi, BARRIER);
		barrier_done = 0;
198
		clear_buffer_ordered(nilfs->ns_sbh[0]);
R
Ryusuke Konishi 已提交
199 200
		goto retry;
	}
201
	if (unlikely(err)) {
R
Ryusuke Konishi 已提交
202 203
		printk(KERN_ERR
		       "NILFS: unable to write superblock (err=%d)\n", err);
204 205 206 207 208 209 210 211 212 213 214
		if (err == -EIO && nilfs->ns_sbh[1]) {
			nilfs_fall_back_super_block(nilfs);
			goto retry;
		}
	} else {
		struct nilfs_super_block *sbp = nilfs->ns_sbp[0];

		/*
		 * The latest segment becomes trailable from the position
		 * written in superblock.
		 */
R
Ryusuke Konishi 已提交
215
		clear_nilfs_discontinued(nilfs);
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

		/* update GC protection for recent segments */
		if (nilfs->ns_sbh[1]) {
			sbp = NULL;
			if (dupsb) {
				set_buffer_dirty(nilfs->ns_sbh[1]);
				if (!sync_dirty_buffer(nilfs->ns_sbh[1]))
					sbp = nilfs->ns_sbp[1];
			}
		}
		if (sbp) {
			spin_lock(&nilfs->ns_last_segment_lock);
			nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq);
			spin_unlock(&nilfs->ns_last_segment_lock);
		}
R
Ryusuke Konishi 已提交
231 232 233 234 235
	}

	return err;
}

236
int nilfs_commit_super(struct nilfs_sb_info *sbi, int dupsb)
R
Ryusuke Konishi 已提交
237 238
{
	struct the_nilfs *nilfs = sbi->s_nilfs;
239
	struct nilfs_super_block **sbp = nilfs->ns_sbp;
R
Ryusuke Konishi 已提交
240
	sector_t nfreeblocks;
241
	time_t t;
R
Ryusuke Konishi 已提交
242 243 244
	int err;

	/* nilfs->sem must be locked by the caller. */
245 246
	if (sbp[0]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) {
		if (sbp[1] && sbp[1]->s_magic == cpu_to_le16(NILFS_SUPER_MAGIC))
247 248 249 250 251 252 253
			nilfs_swap_super_block(nilfs);
		else {
			printk(KERN_CRIT "NILFS: superblock broke on dev %s\n",
			       sbi->s_super->s_id);
			return -EIO;
		}
	}
R
Ryusuke Konishi 已提交
254 255 256 257 258
	err = nilfs_count_free_blocks(nilfs, &nfreeblocks);
	if (unlikely(err)) {
		printk(KERN_ERR "NILFS: failed to count free blocks\n");
		return err;
	}
259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
	spin_lock(&nilfs->ns_last_segment_lock);
	sbp[0]->s_last_seq = cpu_to_le64(nilfs->ns_last_seq);
	sbp[0]->s_last_pseg = cpu_to_le64(nilfs->ns_last_pseg);
	sbp[0]->s_last_cno = cpu_to_le64(nilfs->ns_last_cno);
	spin_unlock(&nilfs->ns_last_segment_lock);

	t = get_seconds();
	nilfs->ns_sbwtime[0] = t;
	sbp[0]->s_free_blocks_count = cpu_to_le64(nfreeblocks);
	sbp[0]->s_wtime = cpu_to_le64(t);
	sbp[0]->s_sum = 0;
	sbp[0]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed,
					     (unsigned char *)sbp[0],
					     nilfs->ns_sbsize));
	if (dupsb && sbp[1]) {
		memcpy(sbp[1], sbp[0], nilfs->ns_sbsize);
		nilfs->ns_sbwtime[1] = t;
	}
277
	clear_nilfs_sb_dirty(nilfs);
278
	return nilfs_sync_super(sbi, dupsb);
R
Ryusuke Konishi 已提交
279 280 281 282 283 284 285
}

static void nilfs_put_super(struct super_block *sb)
{
	struct nilfs_sb_info *sbi = NILFS_SB(sb);
	struct the_nilfs *nilfs = sbi->s_nilfs;

286 287
	lock_kernel();

R
Ryusuke Konishi 已提交
288 289 290 291
	nilfs_detach_segment_constructor(sbi);

	if (!(sb->s_flags & MS_RDONLY)) {
		down_write(&nilfs->ns_sem);
292 293
		nilfs->ns_sbp[0]->s_state = cpu_to_le16(nilfs->ns_mount_state);
		nilfs_commit_super(sbi, 1);
R
Ryusuke Konishi 已提交
294 295
		up_write(&nilfs->ns_sem);
	}
296
	down_write(&nilfs->ns_super_sem);
297 298
	if (nilfs->ns_current == sbi)
		nilfs->ns_current = NULL;
299
	up_write(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
300 301 302 303 304

	nilfs_detach_checkpoint(sbi);
	put_nilfs(sbi->s_nilfs);
	sbi->s_super = NULL;
	sb->s_fs_info = NULL;
305
	nilfs_put_sbinfo(sbi);
306 307

	unlock_kernel();
R
Ryusuke Konishi 已提交
308 309 310 311
}

static int nilfs_sync_fs(struct super_block *sb, int wait)
{
312 313
	struct nilfs_sb_info *sbi = NILFS_SB(sb);
	struct the_nilfs *nilfs = sbi->s_nilfs;
R
Ryusuke Konishi 已提交
314 315 316 317 318
	int err = 0;

	/* This function is called when super block should be written back */
	if (wait)
		err = nilfs_construct_segment(sb);
319 320

	down_write(&nilfs->ns_sem);
321
	if (nilfs_sb_dirty(nilfs))
322 323 324
		nilfs_commit_super(sbi, 1);
	up_write(&nilfs->ns_sem);

R
Ryusuke Konishi 已提交
325 326 327 328 329 330 331 332 333 334
	return err;
}

int nilfs_attach_checkpoint(struct nilfs_sb_info *sbi, __u64 cno)
{
	struct the_nilfs *nilfs = sbi->s_nilfs;
	struct nilfs_checkpoint *raw_cp;
	struct buffer_head *bh_cp;
	int err;

335
	down_write(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
336
	list_add(&sbi->s_list, &nilfs->ns_supers);
337
	up_write(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
338

339
	sbi->s_ifile = nilfs_ifile_new(sbi, nilfs->ns_inode_size);
R
Ryusuke Konishi 已提交
340 341 342
	if (!sbi->s_ifile)
		return -ENOMEM;

343
	down_read(&nilfs->ns_segctor_sem);
R
Ryusuke Konishi 已提交
344 345
	err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, cno, 0, &raw_cp,
					  &bh_cp);
346
	up_read(&nilfs->ns_segctor_sem);
R
Ryusuke Konishi 已提交
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
	if (unlikely(err)) {
		if (err == -ENOENT || err == -EINVAL) {
			printk(KERN_ERR
			       "NILFS: Invalid checkpoint "
			       "(checkpoint number=%llu)\n",
			       (unsigned long long)cno);
			err = -EINVAL;
		}
		goto failed;
	}
	err = nilfs_read_inode_common(sbi->s_ifile, &raw_cp->cp_ifile_inode);
	if (unlikely(err))
		goto failed_bh;
	atomic_set(&sbi->s_inodes_count, le64_to_cpu(raw_cp->cp_inodes_count));
	atomic_set(&sbi->s_blocks_count, le64_to_cpu(raw_cp->cp_blocks_count));

	nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp);
	return 0;

 failed_bh:
	nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp);
 failed:
	nilfs_mdt_destroy(sbi->s_ifile);
	sbi->s_ifile = NULL;

372
	down_write(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
373
	list_del_init(&sbi->s_list);
374
	up_write(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
375 376 377 378 379 380 381 382 383 384

	return err;
}

void nilfs_detach_checkpoint(struct nilfs_sb_info *sbi)
{
	struct the_nilfs *nilfs = sbi->s_nilfs;

	nilfs_mdt_destroy(sbi->s_ifile);
	sbi->s_ifile = NULL;
385
	down_write(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
386
	list_del_init(&sbi->s_list);
387
	up_write(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
388 389 390 391 392 393
}

static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct super_block *sb = dentry->d_sb;
	struct nilfs_sb_info *sbi = NILFS_SB(sb);
394 395
	struct the_nilfs *nilfs = sbi->s_nilfs;
	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
R
Ryusuke Konishi 已提交
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
	unsigned long long blocks;
	unsigned long overhead;
	unsigned long nrsvblocks;
	sector_t nfreeblocks;
	int err;

	/*
	 * Compute all of the segment blocks
	 *
	 * The blocks before first segment and after last segment
	 * are excluded.
	 */
	blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments
		- nilfs->ns_first_data_block;
	nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment;

	/*
	 * Compute the overhead
	 *
415
	 * When distributing meta data blocks outside segment structure,
R
Ryusuke Konishi 已提交
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
	 * We must count them as the overhead.
	 */
	overhead = 0;

	err = nilfs_count_free_blocks(nilfs, &nfreeblocks);
	if (unlikely(err))
		return err;

	buf->f_type = NILFS_SUPER_MAGIC;
	buf->f_bsize = sb->s_blocksize;
	buf->f_blocks = blocks - overhead;
	buf->f_bfree = nfreeblocks;
	buf->f_bavail = (buf->f_bfree >= nrsvblocks) ?
		(buf->f_bfree - nrsvblocks) : 0;
	buf->f_files = atomic_read(&sbi->s_inodes_count);
	buf->f_ffree = 0; /* nilfs_count_free_inodes(sb); */
	buf->f_namelen = NILFS_NAME_LEN;
433 434 435
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);

R
Ryusuke Konishi 已提交
436 437 438
	return 0;
}

439 440 441 442 443 444
static int nilfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
{
	struct super_block *sb = vfs->mnt_sb;
	struct nilfs_sb_info *sbi = NILFS_SB(sb);

	if (!nilfs_test_opt(sbi, BARRIER))
445
		seq_printf(seq, ",nobarrier");
446 447 448 449 450
	if (nilfs_test_opt(sbi, SNAPSHOT))
		seq_printf(seq, ",cp=%llu",
			   (unsigned long long int)sbi->s_snapshot_cno);
	if (nilfs_test_opt(sbi, ERRORS_PANIC))
		seq_printf(seq, ",errors=panic");
451 452
	if (nilfs_test_opt(sbi, ERRORS_CONT))
		seq_printf(seq, ",errors=continue");
453 454
	if (nilfs_test_opt(sbi, STRICT_ORDER))
		seq_printf(seq, ",order=strict");
455 456
	if (nilfs_test_opt(sbi, NORECOVERY))
		seq_printf(seq, ",norecovery");
457 458
	if (nilfs_test_opt(sbi, DISCARD))
		seq_printf(seq, ",discard");
459 460 461 462

	return 0;
}

463
static const struct super_operations nilfs_sops = {
R
Ryusuke Konishi 已提交
464 465 466 467 468 469 470 471
	.alloc_inode    = nilfs_alloc_inode,
	.destroy_inode  = nilfs_destroy_inode,
	.dirty_inode    = nilfs_dirty_inode,
	/* .write_inode    = nilfs_write_inode, */
	/* .put_inode      = nilfs_put_inode, */
	/* .drop_inode	  = nilfs_drop_inode, */
	.delete_inode   = nilfs_delete_inode,
	.put_super      = nilfs_put_super,
472
	/* .write_super    = nilfs_write_super, */
R
Ryusuke Konishi 已提交
473 474 475 476 477 478 479
	.sync_fs        = nilfs_sync_fs,
	/* .write_super_lockfs */
	/* .unlockfs */
	.statfs         = nilfs_statfs,
	.remount_fs     = nilfs_remount,
	.clear_inode    = nilfs_clear_inode,
	/* .umount_begin */
480
	.show_options = nilfs_show_options
R
Ryusuke Konishi 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
};

static struct inode *
nilfs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation)
{
	struct inode *inode;

	if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO &&
	    ino != NILFS_SKETCH_INO)
		return ERR_PTR(-ESTALE);

	inode = nilfs_iget(sb, ino);
	if (IS_ERR(inode))
		return ERR_CAST(inode);
	if (generation && inode->i_generation != generation) {
		iput(inode);
		return ERR_PTR(-ESTALE);
	}

	return inode;
}

static struct dentry *
nilfs_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,
				    nilfs_nfs_get_inode);
}

static struct dentry *
nilfs_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,
				    nilfs_nfs_get_inode);
}

519
static const struct export_operations nilfs_export_ops = {
R
Ryusuke Konishi 已提交
520 521 522 523 524 525 526
	.fh_to_dentry = nilfs_fh_to_dentry,
	.fh_to_parent = nilfs_fh_to_parent,
	.get_parent = nilfs_get_parent,
};

enum {
	Opt_err_cont, Opt_err_panic, Opt_err_ro,
527
	Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery,
528
	Opt_discard, Opt_err,
R
Ryusuke Konishi 已提交
529 530 531 532 533 534
};

static match_table_t tokens = {
	{Opt_err_cont, "errors=continue"},
	{Opt_err_panic, "errors=panic"},
	{Opt_err_ro, "errors=remount-ro"},
535
	{Opt_nobarrier, "nobarrier"},
R
Ryusuke Konishi 已提交
536 537
	{Opt_snapshot, "cp=%u"},
	{Opt_order, "order=%s"},
538
	{Opt_norecovery, "norecovery"},
539
	{Opt_discard, "discard"},
R
Ryusuke Konishi 已提交
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
	{Opt_err, NULL}
};

static int parse_options(char *options, struct super_block *sb)
{
	struct nilfs_sb_info *sbi = NILFS_SB(sb);
	char *p;
	substring_t args[MAX_OPT_ARGS];
	int option;

	if (!options)
		return 1;

	while ((p = strsep(&options, ",")) != NULL) {
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
560 561
		case Opt_nobarrier:
			nilfs_clear_opt(sbi, BARRIER);
R
Ryusuke Konishi 已提交
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
			break;
		case Opt_order:
			if (strcmp(args[0].from, "relaxed") == 0)
				/* Ordered data semantics */
				nilfs_clear_opt(sbi, STRICT_ORDER);
			else if (strcmp(args[0].from, "strict") == 0)
				/* Strict in-order semantics */
				nilfs_set_opt(sbi, STRICT_ORDER);
			else
				return 0;
			break;
		case Opt_err_panic:
			nilfs_write_opt(sbi, ERROR_MODE, ERRORS_PANIC);
			break;
		case Opt_err_ro:
			nilfs_write_opt(sbi, ERROR_MODE, ERRORS_RO);
			break;
		case Opt_err_cont:
			nilfs_write_opt(sbi, ERROR_MODE, ERRORS_CONT);
			break;
		case Opt_snapshot:
			if (match_int(&args[0], &option) || option <= 0)
				return 0;
			if (!(sb->s_flags & MS_RDONLY))
				return 0;
			sbi->s_snapshot_cno = option;
			nilfs_set_opt(sbi, SNAPSHOT);
			break;
590 591 592
		case Opt_norecovery:
			nilfs_set_opt(sbi, NORECOVERY);
			break;
593 594 595
		case Opt_discard:
			nilfs_set_opt(sbi, DISCARD);
			break;
R
Ryusuke Konishi 已提交
596 597 598 599 600 601 602 603 604 605 606 607 608 609
		default:
			printk(KERN_ERR
			       "NILFS: Unrecognized mount option \"%s\"\n", p);
			return 0;
		}
	}
	return 1;
}

static inline void
nilfs_set_default_options(struct nilfs_sb_info *sbi,
			  struct nilfs_super_block *sbp)
{
	sbi->s_mount_opt =
610
		NILFS_MOUNT_ERRORS_RO | NILFS_MOUNT_BARRIER;
R
Ryusuke Konishi 已提交
611 612 613 614 615
}

static int nilfs_setup_super(struct nilfs_sb_info *sbi)
{
	struct the_nilfs *nilfs = sbi->s_nilfs;
616
	struct nilfs_super_block *sbp = nilfs->ns_sbp[0];
R
Ryusuke Konishi 已提交
617 618 619 620
	int max_mnt_count = le16_to_cpu(sbp->s_max_mnt_count);
	int mnt_count = le16_to_cpu(sbp->s_mnt_count);

	/* nilfs->sem must be locked by the caller. */
621
	if (nilfs->ns_mount_state & NILFS_ERROR_FS) {
R
Ryusuke Konishi 已提交
622 623 624 625 626 627 628 629 630 631 632 633 634 635
		printk(KERN_WARNING
		       "NILFS warning: mounting fs with errors\n");
#if 0
	} else if (max_mnt_count >= 0 && mnt_count >= max_mnt_count) {
		printk(KERN_WARNING
		       "NILFS warning: maximal mount count reached\n");
#endif
	}
	if (!max_mnt_count)
		sbp->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT);

	sbp->s_mnt_count = cpu_to_le16(mnt_count + 1);
	sbp->s_state = cpu_to_le16(le16_to_cpu(sbp->s_state) & ~NILFS_VALID_FS);
	sbp->s_mtime = cpu_to_le64(get_seconds());
636
	return nilfs_commit_super(sbi, 1);
R
Ryusuke Konishi 已提交
637 638
}

639 640 641
struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb,
						 u64 pos, int blocksize,
						 struct buffer_head **pbh)
R
Ryusuke Konishi 已提交
642
{
643 644
	unsigned long long sb_index = pos;
	unsigned long offset;
R
Ryusuke Konishi 已提交
645

646
	offset = do_div(sb_index, blocksize);
R
Ryusuke Konishi 已提交
647
	*pbh = sb_bread(sb, sb_index);
648
	if (!*pbh)
R
Ryusuke Konishi 已提交
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
		return NULL;
	return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset);
}

int nilfs_store_magic_and_option(struct super_block *sb,
				 struct nilfs_super_block *sbp,
				 char *data)
{
	struct nilfs_sb_info *sbi = NILFS_SB(sb);

	sb->s_magic = le16_to_cpu(sbp->s_magic);

	/* FS independent flags */
#ifdef NILFS_ATIME_DISABLE
	sb->s_flags |= MS_NOATIME;
#endif

	nilfs_set_default_options(sbi, sbp);

	sbi->s_resuid = le16_to_cpu(sbp->s_def_resuid);
	sbi->s_resgid = le16_to_cpu(sbp->s_def_resgid);
	sbi->s_interval = le32_to_cpu(sbp->s_c_interval);
	sbi->s_watermark = le32_to_cpu(sbp->s_c_block_max);

673
	return !parse_options(data, sb) ? -EINVAL : 0 ;
R
Ryusuke Konishi 已提交
674 675 676 677 678 679 680 681 682
}

/**
 * nilfs_fill_super() - initialize a super block instance
 * @sb: super_block
 * @data: mount options
 * @silent: silent mode flag
 * @nilfs: the_nilfs struct
 *
683
 * This function is called exclusively by nilfs->ns_mount_mutex.
R
Ryusuke Konishi 已提交
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
 * So, the recovery process is protected from other simultaneous mounts.
 */
static int
nilfs_fill_super(struct super_block *sb, void *data, int silent,
		 struct the_nilfs *nilfs)
{
	struct nilfs_sb_info *sbi;
	struct inode *root;
	__u64 cno;
	int err;

	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
	if (!sbi)
		return -ENOMEM;

	sb->s_fs_info = sbi;

	get_nilfs(nilfs);
	sbi->s_nilfs = nilfs;
	sbi->s_super = sb;
704
	atomic_set(&sbi->s_count, 1);
R
Ryusuke Konishi 已提交
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726

	err = init_nilfs(nilfs, sbi, (char *)data);
	if (err)
		goto failed_sbi;

	spin_lock_init(&sbi->s_inode_lock);
	INIT_LIST_HEAD(&sbi->s_dirty_files);
	INIT_LIST_HEAD(&sbi->s_list);

	/*
	 * Following initialization is overlapped because
	 * nilfs_sb_info structure has been cleared at the beginning.
	 * But we reserve them to keep our interest and make ready
	 * for the future change.
	 */
	get_random_bytes(&sbi->s_next_generation,
			 sizeof(sbi->s_next_generation));
	spin_lock_init(&sbi->s_next_gen_lock);

	sb->s_op = &nilfs_sops;
	sb->s_export_op = &nilfs_export_ops;
	sb->s_root = NULL;
727
	sb->s_time_gran = 1;
728
	sb->s_bdi = nilfs->ns_bdi;
R
Ryusuke Konishi 已提交
729

730 731 732 733
	err = load_nilfs(nilfs, sbi);
	if (err)
		goto failed_sbi;

R
Ryusuke Konishi 已提交
734 735 736 737
	cno = nilfs_last_cno(nilfs);

	if (sb->s_flags & MS_RDONLY) {
		if (nilfs_test_opt(sbi, SNAPSHOT)) {
738
			down_read(&nilfs->ns_segctor_sem);
739 740
			err = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile,
						       sbi->s_snapshot_cno);
741 742 743 744
			up_read(&nilfs->ns_segctor_sem);
			if (err < 0) {
				if (err == -ENOENT)
					err = -EINVAL;
745
				goto failed_sbi;
746
			}
747
			if (!err) {
R
Ryusuke Konishi 已提交
748 749 750 751 752 753 754 755 756
				printk(KERN_ERR
				       "NILFS: The specified checkpoint is "
				       "not a snapshot "
				       "(checkpoint number=%llu).\n",
				       (unsigned long long)sbi->s_snapshot_cno);
				err = -EINVAL;
				goto failed_sbi;
			}
			cno = sbi->s_snapshot_cno;
757
		}
R
Ryusuke Konishi 已提交
758 759 760 761 762 763 764 765 766 767
	}

	err = nilfs_attach_checkpoint(sbi, cno);
	if (err) {
		printk(KERN_ERR "NILFS: error loading a checkpoint"
		       " (checkpoint number=%llu).\n", (unsigned long long)cno);
		goto failed_sbi;
	}

	if (!(sb->s_flags & MS_RDONLY)) {
768
		err = nilfs_attach_segment_constructor(sbi);
R
Ryusuke Konishi 已提交
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
		if (err)
			goto failed_checkpoint;
	}

	root = nilfs_iget(sb, NILFS_ROOT_INO);
	if (IS_ERR(root)) {
		printk(KERN_ERR "NILFS: get root inode failed\n");
		err = PTR_ERR(root);
		goto failed_segctor;
	}
	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
		iput(root);
		printk(KERN_ERR "NILFS: corrupt root inode.\n");
		err = -EINVAL;
		goto failed_segctor;
	}
	sb->s_root = d_alloc_root(root);
	if (!sb->s_root) {
		iput(root);
		printk(KERN_ERR "NILFS: get root dentry failed\n");
		err = -ENOMEM;
		goto failed_segctor;
	}

	if (!(sb->s_flags & MS_RDONLY)) {
		down_write(&nilfs->ns_sem);
		nilfs_setup_super(sbi);
		up_write(&nilfs->ns_sem);
	}

799
	down_write(&nilfs->ns_super_sem);
800 801
	if (!nilfs_test_opt(sbi, SNAPSHOT))
		nilfs->ns_current = sbi;
802
	up_write(&nilfs->ns_super_sem);
803

R
Ryusuke Konishi 已提交
804 805 806 807 808 809 810 811 812 813 814
	return 0;

 failed_segctor:
	nilfs_detach_segment_constructor(sbi);

 failed_checkpoint:
	nilfs_detach_checkpoint(sbi);

 failed_sbi:
	put_nilfs(nilfs);
	sb->s_fs_info = NULL;
815
	nilfs_put_sbinfo(sbi);
R
Ryusuke Konishi 已提交
816 817 818 819 820 821 822 823 824 825
	return err;
}

static int nilfs_remount(struct super_block *sb, int *flags, char *data)
{
	struct nilfs_sb_info *sbi = NILFS_SB(sb);
	struct nilfs_super_block *sbp;
	struct the_nilfs *nilfs = sbi->s_nilfs;
	unsigned long old_sb_flags;
	struct nilfs_mount_options old_opts;
826
	int was_snapshot, err;
R
Ryusuke Konishi 已提交
827

828 829
	lock_kernel();

830
	down_write(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
831 832 833
	old_sb_flags = sb->s_flags;
	old_opts.mount_opt = sbi->s_mount_opt;
	old_opts.snapshot_cno = sbi->s_snapshot_cno;
834
	was_snapshot = nilfs_test_opt(sbi, SNAPSHOT);
R
Ryusuke Konishi 已提交
835 836 837 838 839 840 841

	if (!parse_options(data, sb)) {
		err = -EINVAL;
		goto restore_opts;
	}
	sb->s_flags = (sb->s_flags & ~MS_POSIXACL);

842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861
	err = -EINVAL;
	if (was_snapshot) {
		if (!(*flags & MS_RDONLY)) {
			printk(KERN_ERR "NILFS (device %s): cannot remount "
			       "snapshot read/write.\n",
			       sb->s_id);
			goto restore_opts;
		} else if (sbi->s_snapshot_cno != old_opts.snapshot_cno) {
			printk(KERN_ERR "NILFS (device %s): cannot "
			       "remount to a different snapshot.\n",
			       sb->s_id);
			goto restore_opts;
		}
	} else {
		if (nilfs_test_opt(sbi, SNAPSHOT)) {
			printk(KERN_ERR "NILFS (device %s): cannot change "
			       "a regular mount to a snapshot.\n",
			       sb->s_id);
			goto restore_opts;
		}
R
Ryusuke Konishi 已提交
862 863
	}

864 865 866 867 868 869 870
	if (!nilfs_valid_fs(nilfs)) {
		printk(KERN_WARNING "NILFS (device %s): couldn't "
		       "remount because the filesystem is in an "
		       "incomplete recovery state.\n", sb->s_id);
		goto restore_opts;
	}

R
Ryusuke Konishi 已提交
871 872 873 874 875 876 877 878 879 880 881 882
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
		goto out;
	if (*flags & MS_RDONLY) {
		/* Shutting down the segment constructor */
		nilfs_detach_segment_constructor(sbi);
		sb->s_flags |= MS_RDONLY;

		/*
		 * Remounting a valid RW partition RDONLY, so set
		 * the RDONLY flag and then mark the partition as valid again.
		 */
		down_write(&nilfs->ns_sem);
883
		sbp = nilfs->ns_sbp[0];
R
Ryusuke Konishi 已提交
884 885 886 887
		if (!(sbp->s_state & le16_to_cpu(NILFS_VALID_FS)) &&
		    (nilfs->ns_mount_state & NILFS_VALID_FS))
			sbp->s_state = cpu_to_le16(nilfs->ns_mount_state);
		sbp->s_mtime = cpu_to_le64(get_seconds());
888
		nilfs_commit_super(sbi, 1);
R
Ryusuke Konishi 已提交
889 890 891 892 893 894 895 896 897
		up_write(&nilfs->ns_sem);
	} else {
		/*
		 * Mounting a RDONLY partition read-write, so reread and
		 * store the current valid flag.  (It may have been changed
		 * by fsck since we originally mounted the partition.)
		 */
		sb->s_flags &= ~MS_RDONLY;

898
		err = nilfs_attach_segment_constructor(sbi);
R
Ryusuke Konishi 已提交
899
		if (err)
900
			goto restore_opts;
R
Ryusuke Konishi 已提交
901 902 903 904 905 906

		down_write(&nilfs->ns_sem);
		nilfs_setup_super(sbi);
		up_write(&nilfs->ns_sem);
	}
 out:
907
	up_write(&nilfs->ns_super_sem);
908
	unlock_kernel();
R
Ryusuke Konishi 已提交
909 910 911 912 913 914
	return 0;

 restore_opts:
	sb->s_flags = old_sb_flags;
	sbi->s_mount_opt = old_opts.mount_opt;
	sbi->s_snapshot_cno = old_opts.snapshot_cno;
915
	up_write(&nilfs->ns_super_sem);
916
	unlock_kernel();
R
Ryusuke Konishi 已提交
917 918 919 920 921
	return err;
}

struct nilfs_super_data {
	struct block_device *bdev;
922
	struct nilfs_sb_info *sbi;
R
Ryusuke Konishi 已提交
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
	__u64 cno;
	int flags;
};

/**
 * nilfs_identify - pre-read mount options needed to identify mount instance
 * @data: mount options
 * @sd: nilfs_super_data
 */
static int nilfs_identify(char *data, struct nilfs_super_data *sd)
{
	char *p, *options = data;
	substring_t args[MAX_OPT_ARGS];
	int option, token;
	int ret = 0;

	do {
		p = strsep(&options, ",");
		if (p != NULL && *p) {
			token = match_token(p, tokens, args);
			if (token == Opt_snapshot) {
				if (!(sd->flags & MS_RDONLY))
					ret++;
				else {
					ret = match_int(&args[0], &option);
					if (!ret) {
						if (option > 0)
							sd->cno = option;
						else
							ret++;
					}
				}
			}
			if (ret)
				printk(KERN_ERR
				       "NILFS: invalid mount option: %s\n", p);
		}
		if (!options)
			break;
		BUG_ON(options == data);
		*(options - 1) = ',';
	} while (!ret);
	return ret;
}

static int nilfs_set_bdev_super(struct super_block *s, void *data)
{
	struct nilfs_super_data *sd = data;

	s->s_bdev = sd->bdev;
	s->s_dev = s->s_bdev->bd_dev;
	return 0;
}

static int nilfs_test_bdev_super(struct super_block *s, void *data)
{
	struct nilfs_super_data *sd = data;
980 981

	return sd->sbi && s->s_fs_info == (void *)sd->sbi;
R
Ryusuke Konishi 已提交
982 983 984 985 986 987 988
}

static int
nilfs_get_sb(struct file_system_type *fs_type, int flags,
	     const char *dev_name, void *data, struct vfsmount *mnt)
{
	struct nilfs_super_data sd;
989
	struct super_block *s;
990
	fmode_t mode = FMODE_READ;
991
	struct the_nilfs *nilfs;
R
Ryusuke Konishi 已提交
992 993
	int err, need_to_close = 1;

994 995 996 997
	if (!(flags & MS_RDONLY))
		mode |= FMODE_WRITE;

	sd.bdev = open_bdev_exclusive(dev_name, mode, fs_type);
R
Ryusuke Konishi 已提交
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
	if (IS_ERR(sd.bdev))
		return PTR_ERR(sd.bdev);

	/*
	 * To get mount instance using sget() vfs-routine, NILFS needs
	 * much more information than normal filesystems to identify mount
	 * instance.  For snapshot mounts, not only a mount type (ro-mount
	 * or rw-mount) but also a checkpoint number is required.
	 */
	sd.cno = 0;
	sd.flags = flags;
	if (nilfs_identify((char *)data, &sd)) {
		err = -EINVAL;
		goto failed;
	}

1014 1015 1016 1017 1018 1019
	nilfs = find_or_create_nilfs(sd.bdev);
	if (!nilfs) {
		err = -ENOMEM;
		goto failed;
	}

1020
	mutex_lock(&nilfs->ns_mount_mutex);
1021 1022 1023 1024 1025 1026 1027 1028

	if (!sd.cno) {
		/*
		 * Check if an exclusive mount exists or not.
		 * Snapshot mounts coexist with a current mount
		 * (i.e. rw-mount or ro-mount), whereas rw-mount and
		 * ro-mount are mutually exclusive.
		 */
1029
		down_read(&nilfs->ns_super_sem);
1030 1031 1032
		if (nilfs->ns_current &&
		    ((nilfs->ns_current->s_super->s_flags ^ flags)
		     & MS_RDONLY)) {
1033
			up_read(&nilfs->ns_super_sem);
1034 1035 1036
			err = -EBUSY;
			goto failed_unlock;
		}
1037
		up_read(&nilfs->ns_super_sem);
R
Ryusuke Konishi 已提交
1038 1039 1040
	}

	/*
1041
	 * Find existing nilfs_sb_info struct
R
Ryusuke Konishi 已提交
1042
	 */
1043 1044 1045 1046 1047 1048 1049
	sd.sbi = nilfs_find_sbinfo(nilfs, !(flags & MS_RDONLY), sd.cno);

	/*
	 * Get super block instance holding the nilfs_sb_info struct.
	 * A new instance is allocated if no existing mount is present or
	 * existing instance has been unmounted.
	 */
1050
	s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, &sd);
1051 1052 1053
	if (sd.sbi)
		nilfs_put_sbinfo(sd.sbi);

1054 1055 1056
	if (IS_ERR(s)) {
		err = PTR_ERR(s);
		goto failed_unlock;
R
Ryusuke Konishi 已提交
1057 1058 1059 1060 1061
	}

	if (!s->s_root) {
		char b[BDEVNAME_SIZE];

1062
		/* New superblock instance created */
R
Ryusuke Konishi 已提交
1063
		s->s_flags = flags;
1064
		s->s_mode = mode;
R
Ryusuke Konishi 已提交
1065 1066 1067
		strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id));
		sb_set_blocksize(s, block_size(sd.bdev));

1068 1069
		err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0,
				       nilfs);
R
Ryusuke Konishi 已提交
1070 1071 1072 1073 1074 1075 1076
		if (err)
			goto cancel_new;

		s->s_flags |= MS_ACTIVE;
		need_to_close = 0;
	}

1077
	mutex_unlock(&nilfs->ns_mount_mutex);
R
Ryusuke Konishi 已提交
1078 1079
	put_nilfs(nilfs);
	if (need_to_close)
1080
		close_bdev_exclusive(sd.bdev, mode);
R
Ryusuke Konishi 已提交
1081 1082 1083 1084
	simple_set_mnt(mnt, s);
	return 0;

 failed_unlock:
1085
	mutex_unlock(&nilfs->ns_mount_mutex);
1086
	put_nilfs(nilfs);
R
Ryusuke Konishi 已提交
1087
 failed:
1088
	close_bdev_exclusive(sd.bdev, mode);
R
Ryusuke Konishi 已提交
1089 1090 1091 1092 1093

	return err;

 cancel_new:
	/* Abandoning the newly allocated superblock */
1094
	mutex_unlock(&nilfs->ns_mount_mutex);
1095
	put_nilfs(nilfs);
1096
	deactivate_locked_super(s);
R
Ryusuke Konishi 已提交
1097
	/*
1098
	 * deactivate_locked_super() invokes close_bdev_exclusive().
R
Ryusuke Konishi 已提交
1099
	 * We must finish all post-cleaning before this call;
1100
	 * put_nilfs() needs the block device.
R
Ryusuke Konishi 已提交
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
	 */
	return err;
}

struct file_system_type nilfs_fs_type = {
	.owner    = THIS_MODULE,
	.name     = "nilfs2",
	.get_sb   = nilfs_get_sb,
	.kill_sb  = kill_block_super,
	.fs_flags = FS_REQUIRES_DEV,
};

1113
static void nilfs_inode_init_once(void *obj)
R
Ryusuke Konishi 已提交
1114
{
1115
	struct nilfs_inode_info *ii = obj;
R
Ryusuke Konishi 已提交
1116

1117 1118 1119 1120 1121 1122 1123 1124
	INIT_LIST_HEAD(&ii->i_dirty);
#ifdef CONFIG_NILFS_XATTR
	init_rwsem(&ii->xattr_sem);
#endif
	nilfs_btnode_cache_init_once(&ii->i_btnode_cache);
	ii->i_bmap = (struct nilfs_bmap *)&ii->i_bmap_union;
	inode_init_once(&ii->vfs_inode);
}
R
Ryusuke Konishi 已提交
1125

1126 1127 1128 1129
static void nilfs_segbuf_init_once(void *obj)
{
	memset(obj, 0, sizeof(struct nilfs_segment_buffer));
}
R
Ryusuke Konishi 已提交
1130

1131 1132
static void nilfs_destroy_cachep(void)
{
1133
	if (nilfs_inode_cachep)
1134
		kmem_cache_destroy(nilfs_inode_cachep);
1135
	if (nilfs_transaction_cachep)
1136
		kmem_cache_destroy(nilfs_transaction_cachep);
1137
	if (nilfs_segbuf_cachep)
1138
		kmem_cache_destroy(nilfs_segbuf_cachep);
1139
	if (nilfs_btree_path_cache)
1140 1141
		kmem_cache_destroy(nilfs_btree_path_cache);
}
R
Ryusuke Konishi 已提交
1142

1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
static int __init nilfs_init_cachep(void)
{
	nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache",
			sizeof(struct nilfs_inode_info), 0,
			SLAB_RECLAIM_ACCOUNT, nilfs_inode_init_once);
	if (!nilfs_inode_cachep)
		goto fail;

	nilfs_transaction_cachep = kmem_cache_create("nilfs2_transaction_cache",
			sizeof(struct nilfs_transaction_info), 0,
			SLAB_RECLAIM_ACCOUNT, NULL);
	if (!nilfs_transaction_cachep)
		goto fail;

	nilfs_segbuf_cachep = kmem_cache_create("nilfs2_segbuf_cache",
			sizeof(struct nilfs_segment_buffer), 0,
			SLAB_RECLAIM_ACCOUNT, nilfs_segbuf_init_once);
	if (!nilfs_segbuf_cachep)
		goto fail;

	nilfs_btree_path_cache = kmem_cache_create("nilfs2_btree_path_cache",
			sizeof(struct nilfs_btree_path) * NILFS_BTREE_LEVEL_MAX,
			0, 0, NULL);
	if (!nilfs_btree_path_cache)
		goto fail;
R
Ryusuke Konishi 已提交
1168 1169 1170

	return 0;

1171 1172 1173 1174 1175 1176 1177 1178
fail:
	nilfs_destroy_cachep();
	return -ENOMEM;
}

static int __init init_nilfs_fs(void)
{
	int err;
R
Ryusuke Konishi 已提交
1179

1180 1181 1182
	err = nilfs_init_cachep();
	if (err)
		goto fail;
R
Ryusuke Konishi 已提交
1183

1184 1185 1186
	err = register_filesystem(&nilfs_fs_type);
	if (err)
		goto free_cachep;
R
Ryusuke Konishi 已提交
1187

1188
	printk(KERN_INFO "NILFS version 2 loaded\n");
1189
	return 0;
R
Ryusuke Konishi 已提交
1190

1191 1192 1193
free_cachep:
	nilfs_destroy_cachep();
fail:
R
Ryusuke Konishi 已提交
1194 1195 1196 1197 1198
	return err;
}

static void __exit exit_nilfs_fs(void)
{
1199
	nilfs_destroy_cachep();
R
Ryusuke Konishi 已提交
1200 1201 1202 1203 1204
	unregister_filesystem(&nilfs_fs_type);
}

module_init(init_nilfs_fs)
module_exit(exit_nilfs_fs)