1/* 2 * super.c - NILFS module and super block management. 3 * 4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Written by Ryusuke Konishi <ryusuke@osrg.net> 21 */ 22/* 23 * linux/fs/ext2/super.c 24 * 25 * Copyright (C) 1992, 1993, 1994, 1995 26 * Remy Card (card@masi.ibp.fr) 27 * Laboratoire MASI - Institut Blaise Pascal 28 * Universite Pierre et Marie Curie (Paris VI) 29 * 30 * from 31 * 32 * linux/fs/minix/inode.c 33 * 34 * Copyright (C) 1991, 1992 Linus Torvalds 35 * 36 * Big-endian to little-endian byte-swapping/bitmaps by 37 * David S. Miller (davem@caip.rutgers.edu), 1995 38 */ 39 40#include <linux/module.h> 41#include <linux/string.h> 42#include <linux/slab.h> 43#include <linux/init.h> 44#include <linux/blkdev.h> 45#include <linux/parser.h> 46#include <linux/random.h> 47#include <linux/crc32.h> 48#include <linux/smp_lock.h> 49#include <linux/vfs.h> 50#include <linux/writeback.h> 51#include <linux/kobject.h> 52#include <linux/exportfs.h> 53#include <linux/seq_file.h> 54#include <linux/mount.h> 55#include "nilfs.h" 56#include "mdt.h" 57#include "alloc.h" 58#include "btree.h" 59#include "btnode.h" 60#include "page.h" 61#include "cpfile.h" 62#include "ifile.h" 63#include "dat.h" 64#include "segment.h" 65#include "segbuf.h" 66 67MODULE_AUTHOR("NTT Corp."); 68MODULE_DESCRIPTION("A New Implementation of the Log-structured Filesystem " 69 "(NILFS)"); 70MODULE_LICENSE("GPL"); 71 72struct kmem_cache *nilfs_inode_cachep; 73struct kmem_cache *nilfs_transaction_cachep; 74struct kmem_cache *nilfs_segbuf_cachep; 75struct kmem_cache *nilfs_btree_path_cache; 76 77static int nilfs_remount(struct super_block *sb, int *flags, char *data); 78 79static void nilfs_set_error(struct nilfs_sb_info *sbi) 80{ 81 struct the_nilfs *nilfs = sbi->s_nilfs; 82 struct nilfs_super_block **sbp; 83 84 down_write(&nilfs->ns_sem); 85 if (!(nilfs->ns_mount_state & NILFS_ERROR_FS)) { 86 nilfs->ns_mount_state |= NILFS_ERROR_FS; 87 sbp = nilfs_prepare_super(sbi, 0); 88 if (likely(sbp)) { 89 sbp[0]->s_state |= cpu_to_le16(NILFS_ERROR_FS); 90 if (sbp[1]) 91 sbp[1]->s_state |= cpu_to_le16(NILFS_ERROR_FS); 92 nilfs_commit_super(sbi, NILFS_SB_COMMIT_ALL); 93 } 94 } 95 up_write(&nilfs->ns_sem); 96} 97 98/** 99 * nilfs_error() - report failure condition on a filesystem 100 * 101 * nilfs_error() sets an ERROR_FS flag on the superblock as well as 102 * reporting an error message. It should be called when NILFS detects 103 * incoherences or defects of meta data on disk. As for sustainable 104 * errors such as a single-shot I/O error, nilfs_warning() or the printk() 105 * function should be used instead. 106 * 107 * The segment constructor must not call this function because it can 108 * kill itself. 109 */ 110void nilfs_error(struct super_block *sb, const char *function, 111 const char *fmt, ...) 112{ 113 struct nilfs_sb_info *sbi = NILFS_SB(sb); 114 va_list args; 115 116 va_start(args, fmt); 117 printk(KERN_CRIT "NILFS error (device %s): %s: ", sb->s_id, function); 118 vprintk(fmt, args); 119 printk("\n"); 120 va_end(args); 121 122 if (!(sb->s_flags & MS_RDONLY)) { 123 nilfs_set_error(sbi); 124 125 if (nilfs_test_opt(sbi, ERRORS_RO)) { 126 printk(KERN_CRIT "Remounting filesystem read-only\n"); 127 sb->s_flags |= MS_RDONLY; 128 } 129 } 130 131 if (nilfs_test_opt(sbi, ERRORS_PANIC)) 132 panic("NILFS (device %s): panic forced after error\n", 133 sb->s_id); 134} 135 136void nilfs_warning(struct super_block *sb, const char *function, 137 const char *fmt, ...) 138{ 139 va_list args; 140 141 va_start(args, fmt); 142 printk(KERN_WARNING "NILFS warning (device %s): %s: ", 143 sb->s_id, function); 144 vprintk(fmt, args); 145 printk("\n"); 146 va_end(args); 147} 148 149 150struct inode *nilfs_alloc_inode_common(struct the_nilfs *nilfs) 151{ 152 struct nilfs_inode_info *ii; 153 154 ii = kmem_cache_alloc(nilfs_inode_cachep, GFP_NOFS); 155 if (!ii) 156 return NULL; 157 ii->i_bh = NULL; 158 ii->i_state = 0; 159 ii->vfs_inode.i_version = 1; 160 nilfs_btnode_cache_init(&ii->i_btnode_cache, nilfs->ns_bdi); 161 return &ii->vfs_inode; 162} 163 164struct inode *nilfs_alloc_inode(struct super_block *sb) 165{ 166 return nilfs_alloc_inode_common(NILFS_SB(sb)->s_nilfs); 167} 168 169void nilfs_destroy_inode(struct inode *inode) 170{ 171 kmem_cache_free(nilfs_inode_cachep, NILFS_I(inode)); 172} 173 174static int nilfs_sync_super(struct nilfs_sb_info *sbi, int flag) 175{ 176 struct the_nilfs *nilfs = sbi->s_nilfs; 177 int err; 178 179 retry: 180 set_buffer_dirty(nilfs->ns_sbh[0]); 181 182 if (nilfs_test_opt(sbi, BARRIER)) { 183 err = __sync_dirty_buffer(nilfs->ns_sbh[0], 184 WRITE_SYNC | WRITE_BARRIER); 185 if (err == -EOPNOTSUPP) { 186 nilfs_warning(sbi->s_super, __func__, 187 "barrier-based sync failed. " 188 "disabling barriers\n"); 189 nilfs_clear_opt(sbi, BARRIER); 190 goto retry; 191 } 192 } else { 193 err = sync_dirty_buffer(nilfs->ns_sbh[0]); 194 } 195 196 if (unlikely(err)) { 197 printk(KERN_ERR 198 "NILFS: unable to write superblock (err=%d)\n", err); 199 if (err == -EIO && nilfs->ns_sbh[1]) { 200 /* 201 * sbp[0] points to newer log than sbp[1], 202 * so copy sbp[0] to sbp[1] to take over sbp[0]. 203 */ 204 memcpy(nilfs->ns_sbp[1], nilfs->ns_sbp[0], 205 nilfs->ns_sbsize); 206 nilfs_fall_back_super_block(nilfs); 207 goto retry; 208 } 209 } else { 210 struct nilfs_super_block *sbp = nilfs->ns_sbp[0]; 211 212 nilfs->ns_sbwcount++; 213 214 /* 215 * The latest segment becomes trailable from the position 216 * written in superblock. 217 */ 218 clear_nilfs_discontinued(nilfs); 219 220 /* update GC protection for recent segments */ 221 if (nilfs->ns_sbh[1]) { 222 if (flag == NILFS_SB_COMMIT_ALL) { 223 set_buffer_dirty(nilfs->ns_sbh[1]); 224 if (sync_dirty_buffer(nilfs->ns_sbh[1]) < 0) 225 goto out; 226 } 227 if (le64_to_cpu(nilfs->ns_sbp[1]->s_last_cno) < 228 le64_to_cpu(nilfs->ns_sbp[0]->s_last_cno)) 229 sbp = nilfs->ns_sbp[1]; 230 } 231 232 spin_lock(&nilfs->ns_last_segment_lock); 233 nilfs->ns_prot_seq = le64_to_cpu(sbp->s_last_seq); 234 spin_unlock(&nilfs->ns_last_segment_lock); 235 } 236 out: 237 return err; 238} 239 240void nilfs_set_log_cursor(struct nilfs_super_block *sbp, 241 struct the_nilfs *nilfs) 242{ 243 sector_t nfreeblocks; 244 245 /* nilfs->ns_sem must be locked by the caller. */ 246 nilfs_count_free_blocks(nilfs, &nfreeblocks); 247 sbp->s_free_blocks_count = cpu_to_le64(nfreeblocks); 248 249 spin_lock(&nilfs->ns_last_segment_lock); 250 sbp->s_last_seq = cpu_to_le64(nilfs->ns_last_seq); 251 sbp->s_last_pseg = cpu_to_le64(nilfs->ns_last_pseg); 252 sbp->s_last_cno = cpu_to_le64(nilfs->ns_last_cno); 253 spin_unlock(&nilfs->ns_last_segment_lock); 254} 255 256struct nilfs_super_block **nilfs_prepare_super(struct nilfs_sb_info *sbi, 257 int flip) 258{ 259 struct the_nilfs *nilfs = sbi->s_nilfs; 260 struct nilfs_super_block **sbp = nilfs->ns_sbp; 261 262 /* nilfs->ns_sem must be locked by the caller. */ 263 if (sbp[0]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) { 264 if (sbp[1] && 265 sbp[1]->s_magic == cpu_to_le16(NILFS_SUPER_MAGIC)) { 266 memcpy(sbp[0], sbp[1], nilfs->ns_sbsize); 267 } else { 268 printk(KERN_CRIT "NILFS: superblock broke on dev %s\n", 269 sbi->s_super->s_id); 270 return NULL; 271 } 272 } else if (sbp[1] && 273 sbp[1]->s_magic != cpu_to_le16(NILFS_SUPER_MAGIC)) { 274 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 275 } 276 277 if (flip && sbp[1]) 278 nilfs_swap_super_block(nilfs); 279 280 return sbp; 281} 282 283int nilfs_commit_super(struct nilfs_sb_info *sbi, int flag) 284{ 285 struct the_nilfs *nilfs = sbi->s_nilfs; 286 struct nilfs_super_block **sbp = nilfs->ns_sbp; 287 time_t t; 288 289 /* nilfs->ns_sem must be locked by the caller. */ 290 t = get_seconds(); 291 nilfs->ns_sbwtime = t; 292 sbp[0]->s_wtime = cpu_to_le64(t); 293 sbp[0]->s_sum = 0; 294 sbp[0]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 295 (unsigned char *)sbp[0], 296 nilfs->ns_sbsize)); 297 if (flag == NILFS_SB_COMMIT_ALL && sbp[1]) { 298 sbp[1]->s_wtime = sbp[0]->s_wtime; 299 sbp[1]->s_sum = 0; 300 sbp[1]->s_sum = cpu_to_le32(crc32_le(nilfs->ns_crc_seed, 301 (unsigned char *)sbp[1], 302 nilfs->ns_sbsize)); 303 } 304 clear_nilfs_sb_dirty(nilfs); 305 return nilfs_sync_super(sbi, flag); 306} 307 308/** 309 * nilfs_cleanup_super() - write filesystem state for cleanup 310 * @sbi: nilfs_sb_info to be unmounted or degraded to read-only 311 * 312 * This function restores state flags in the on-disk super block. 313 * This will set "clean" flag (i.e. NILFS_VALID_FS) unless the 314 * filesystem was not clean previously. 315 */ 316int nilfs_cleanup_super(struct nilfs_sb_info *sbi) 317{ 318 struct nilfs_super_block **sbp; 319 int flag = NILFS_SB_COMMIT; 320 int ret = -EIO; 321 322 sbp = nilfs_prepare_super(sbi, 0); 323 if (sbp) { 324 sbp[0]->s_state = cpu_to_le16(sbi->s_nilfs->ns_mount_state); 325 nilfs_set_log_cursor(sbp[0], sbi->s_nilfs); 326 if (sbp[1] && sbp[0]->s_last_cno == sbp[1]->s_last_cno) { 327 /* 328 * make the "clean" flag also to the opposite 329 * super block if both super blocks point to 330 * the same checkpoint. 331 */ 332 sbp[1]->s_state = sbp[0]->s_state; 333 flag = NILFS_SB_COMMIT_ALL; 334 } 335 ret = nilfs_commit_super(sbi, flag); 336 } 337 return ret; 338} 339 340static void nilfs_put_super(struct super_block *sb) 341{ 342 struct nilfs_sb_info *sbi = NILFS_SB(sb); 343 struct the_nilfs *nilfs = sbi->s_nilfs; 344 345 lock_kernel(); 346 347 nilfs_detach_segment_constructor(sbi); 348 349 if (!(sb->s_flags & MS_RDONLY)) { 350 down_write(&nilfs->ns_sem); 351 nilfs_cleanup_super(sbi); 352 up_write(&nilfs->ns_sem); 353 } 354 down_write(&nilfs->ns_super_sem); 355 if (nilfs->ns_current == sbi) 356 nilfs->ns_current = NULL; 357 up_write(&nilfs->ns_super_sem); 358 359 nilfs_detach_checkpoint(sbi); 360 put_nilfs(sbi->s_nilfs); 361 sbi->s_super = NULL; 362 sb->s_fs_info = NULL; 363 nilfs_put_sbinfo(sbi); 364 365 unlock_kernel(); 366} 367 368static int nilfs_sync_fs(struct super_block *sb, int wait) 369{ 370 struct nilfs_sb_info *sbi = NILFS_SB(sb); 371 struct the_nilfs *nilfs = sbi->s_nilfs; 372 struct nilfs_super_block **sbp; 373 int err = 0; 374 375 /* This function is called when super block should be written back */ 376 if (wait) 377 err = nilfs_construct_segment(sb); 378 379 down_write(&nilfs->ns_sem); 380 if (nilfs_sb_dirty(nilfs)) { 381 sbp = nilfs_prepare_super(sbi, nilfs_sb_will_flip(nilfs)); 382 if (likely(sbp)) { 383 nilfs_set_log_cursor(sbp[0], nilfs); 384 nilfs_commit_super(sbi, NILFS_SB_COMMIT); 385 } 386 } 387 up_write(&nilfs->ns_sem); 388 389 return err; 390} 391 392int nilfs_attach_checkpoint(struct nilfs_sb_info *sbi, __u64 cno) 393{ 394 struct the_nilfs *nilfs = sbi->s_nilfs; 395 struct nilfs_checkpoint *raw_cp; 396 struct buffer_head *bh_cp; 397 int err; 398 399 down_write(&nilfs->ns_super_sem); 400 list_add(&sbi->s_list, &nilfs->ns_supers); 401 up_write(&nilfs->ns_super_sem); 402 403 err = -ENOMEM; 404 sbi->s_ifile = nilfs_ifile_new(sbi, nilfs->ns_inode_size); 405 if (!sbi->s_ifile) 406 goto delist; 407 408 down_read(&nilfs->ns_segctor_sem); 409 err = nilfs_cpfile_get_checkpoint(nilfs->ns_cpfile, cno, 0, &raw_cp, 410 &bh_cp); 411 up_read(&nilfs->ns_segctor_sem); 412 if (unlikely(err)) { 413 if (err == -ENOENT || err == -EINVAL) { 414 printk(KERN_ERR 415 "NILFS: Invalid checkpoint " 416 "(checkpoint number=%llu)\n", 417 (unsigned long long)cno); 418 err = -EINVAL; 419 } 420 goto failed; 421 } 422 err = nilfs_read_inode_common(sbi->s_ifile, &raw_cp->cp_ifile_inode); 423 if (unlikely(err)) 424 goto failed_bh; 425 atomic_set(&sbi->s_inodes_count, le64_to_cpu(raw_cp->cp_inodes_count)); 426 atomic_set(&sbi->s_blocks_count, le64_to_cpu(raw_cp->cp_blocks_count)); 427 428 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 429 return 0; 430 431 failed_bh: 432 nilfs_cpfile_put_checkpoint(nilfs->ns_cpfile, cno, bh_cp); 433 failed: 434 nilfs_mdt_destroy(sbi->s_ifile); 435 sbi->s_ifile = NULL; 436 437 delist: 438 down_write(&nilfs->ns_super_sem); 439 list_del_init(&sbi->s_list); 440 up_write(&nilfs->ns_super_sem); 441 442 return err; 443} 444 445void nilfs_detach_checkpoint(struct nilfs_sb_info *sbi) 446{ 447 struct the_nilfs *nilfs = sbi->s_nilfs; 448 449 nilfs_mdt_destroy(sbi->s_ifile); 450 sbi->s_ifile = NULL; 451 down_write(&nilfs->ns_super_sem); 452 list_del_init(&sbi->s_list); 453 up_write(&nilfs->ns_super_sem); 454} 455 456static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf) 457{ 458 struct super_block *sb = dentry->d_sb; 459 struct nilfs_sb_info *sbi = NILFS_SB(sb); 460 struct the_nilfs *nilfs = sbi->s_nilfs; 461 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 462 unsigned long long blocks; 463 unsigned long overhead; 464 unsigned long nrsvblocks; 465 sector_t nfreeblocks; 466 int err; 467 468 /* 469 * Compute all of the segment blocks 470 * 471 * The blocks before first segment and after last segment 472 * are excluded. 473 */ 474 blocks = nilfs->ns_blocks_per_segment * nilfs->ns_nsegments 475 - nilfs->ns_first_data_block; 476 nrsvblocks = nilfs->ns_nrsvsegs * nilfs->ns_blocks_per_segment; 477 478 /* 479 * Compute the overhead 480 * 481 * When distributing meta data blocks outside segment structure, 482 * We must count them as the overhead. 483 */ 484 overhead = 0; 485 486 err = nilfs_count_free_blocks(nilfs, &nfreeblocks); 487 if (unlikely(err)) 488 return err; 489 490 buf->f_type = NILFS_SUPER_MAGIC; 491 buf->f_bsize = sb->s_blocksize; 492 buf->f_blocks = blocks - overhead; 493 buf->f_bfree = nfreeblocks; 494 buf->f_bavail = (buf->f_bfree >= nrsvblocks) ? 495 (buf->f_bfree - nrsvblocks) : 0; 496 buf->f_files = atomic_read(&sbi->s_inodes_count); 497 buf->f_ffree = 0; /* nilfs_count_free_inodes(sb); */ 498 buf->f_namelen = NILFS_NAME_LEN; 499 buf->f_fsid.val[0] = (u32)id; 500 buf->f_fsid.val[1] = (u32)(id >> 32); 501 502 return 0; 503} 504 505static int nilfs_show_options(struct seq_file *seq, struct vfsmount *vfs) 506{ 507 struct super_block *sb = vfs->mnt_sb; 508 struct nilfs_sb_info *sbi = NILFS_SB(sb); 509 510 if (!nilfs_test_opt(sbi, BARRIER)) 511 seq_puts(seq, ",nobarrier"); 512 if (nilfs_test_opt(sbi, SNAPSHOT)) 513 seq_printf(seq, ",cp=%llu", 514 (unsigned long long int)sbi->s_snapshot_cno); 515 if (nilfs_test_opt(sbi, ERRORS_PANIC)) 516 seq_puts(seq, ",errors=panic"); 517 if (nilfs_test_opt(sbi, ERRORS_CONT)) 518 seq_puts(seq, ",errors=continue"); 519 if (nilfs_test_opt(sbi, STRICT_ORDER)) 520 seq_puts(seq, ",order=strict"); 521 if (nilfs_test_opt(sbi, NORECOVERY)) 522 seq_puts(seq, ",norecovery"); 523 if (nilfs_test_opt(sbi, DISCARD)) 524 seq_puts(seq, ",discard"); 525 526 return 0; 527} 528 529static const struct super_operations nilfs_sops = { 530 .alloc_inode = nilfs_alloc_inode, 531 .destroy_inode = nilfs_destroy_inode, 532 .dirty_inode = nilfs_dirty_inode, 533 /* .write_inode = nilfs_write_inode, */ 534 /* .put_inode = nilfs_put_inode, */ 535 /* .drop_inode = nilfs_drop_inode, */ 536 .evict_inode = nilfs_evict_inode, 537 .put_super = nilfs_put_super, 538 /* .write_super = nilfs_write_super, */ 539 .sync_fs = nilfs_sync_fs, 540 /* .write_super_lockfs */ 541 /* .unlockfs */ 542 .statfs = nilfs_statfs, 543 .remount_fs = nilfs_remount, 544 /* .umount_begin */ 545 .show_options = nilfs_show_options 546}; 547 548static struct inode * 549nilfs_nfs_get_inode(struct super_block *sb, u64 ino, u32 generation) 550{ 551 struct inode *inode; 552 553 if (ino < NILFS_FIRST_INO(sb) && ino != NILFS_ROOT_INO && 554 ino != NILFS_SKETCH_INO) 555 return ERR_PTR(-ESTALE); 556 557 inode = nilfs_iget(sb, ino); 558 if (IS_ERR(inode)) 559 return ERR_CAST(inode); 560 if (generation && inode->i_generation != generation) { 561 iput(inode); 562 return ERR_PTR(-ESTALE); 563 } 564 565 return inode; 566} 567 568static struct dentry * 569nilfs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, 570 int fh_type) 571{ 572 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 573 nilfs_nfs_get_inode); 574} 575 576static struct dentry * 577nilfs_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, 578 int fh_type) 579{ 580 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 581 nilfs_nfs_get_inode); 582} 583 584static const struct export_operations nilfs_export_ops = { 585 .fh_to_dentry = nilfs_fh_to_dentry, 586 .fh_to_parent = nilfs_fh_to_parent, 587 .get_parent = nilfs_get_parent, 588}; 589 590enum { 591 Opt_err_cont, Opt_err_panic, Opt_err_ro, 592 Opt_barrier, Opt_nobarrier, Opt_snapshot, Opt_order, Opt_norecovery, 593 Opt_discard, Opt_nodiscard, Opt_err, 594}; 595 596static match_table_t tokens = { 597 {Opt_err_cont, "errors=continue"}, 598 {Opt_err_panic, "errors=panic"}, 599 {Opt_err_ro, "errors=remount-ro"}, 600 {Opt_barrier, "barrier"}, 601 {Opt_nobarrier, "nobarrier"}, 602 {Opt_snapshot, "cp=%u"}, 603 {Opt_order, "order=%s"}, 604 {Opt_norecovery, "norecovery"}, 605 {Opt_discard, "discard"}, 606 {Opt_nodiscard, "nodiscard"}, 607 {Opt_err, NULL} 608}; 609 610static int parse_options(char *options, struct super_block *sb, int is_remount) 611{ 612 struct nilfs_sb_info *sbi = NILFS_SB(sb); 613 char *p; 614 substring_t args[MAX_OPT_ARGS]; 615 int option; 616 617 if (!options) 618 return 1; 619 620 while ((p = strsep(&options, ",")) != NULL) { 621 int token; 622 if (!*p) 623 continue; 624 625 token = match_token(p, tokens, args); 626 switch (token) { 627 case Opt_barrier: 628 nilfs_set_opt(sbi, BARRIER); 629 break; 630 case Opt_nobarrier: 631 nilfs_clear_opt(sbi, BARRIER); 632 break; 633 case Opt_order: 634 if (strcmp(args[0].from, "relaxed") == 0) 635 /* Ordered data semantics */ 636 nilfs_clear_opt(sbi, STRICT_ORDER); 637 else if (strcmp(args[0].from, "strict") == 0) 638 /* Strict in-order semantics */ 639 nilfs_set_opt(sbi, STRICT_ORDER); 640 else 641 return 0; 642 break; 643 case Opt_err_panic: 644 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_PANIC); 645 break; 646 case Opt_err_ro: 647 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_RO); 648 break; 649 case Opt_err_cont: 650 nilfs_write_opt(sbi, ERROR_MODE, ERRORS_CONT); 651 break; 652 case Opt_snapshot: 653 if (match_int(&args[0], &option) || option <= 0) 654 return 0; 655 if (is_remount) { 656 if (!nilfs_test_opt(sbi, SNAPSHOT)) { 657 printk(KERN_ERR 658 "NILFS: cannot change regular " 659 "mount to snapshot.\n"); 660 return 0; 661 } else if (option != sbi->s_snapshot_cno) { 662 printk(KERN_ERR 663 "NILFS: cannot remount to a " 664 "different snapshot.\n"); 665 return 0; 666 } 667 break; 668 } 669 if (!(sb->s_flags & MS_RDONLY)) { 670 printk(KERN_ERR "NILFS: cannot mount snapshot " 671 "read/write. A read-only option is " 672 "required.\n"); 673 return 0; 674 } 675 sbi->s_snapshot_cno = option; 676 nilfs_set_opt(sbi, SNAPSHOT); 677 break; 678 case Opt_norecovery: 679 nilfs_set_opt(sbi, NORECOVERY); 680 break; 681 case Opt_discard: 682 nilfs_set_opt(sbi, DISCARD); 683 break; 684 case Opt_nodiscard: 685 nilfs_clear_opt(sbi, DISCARD); 686 break; 687 default: 688 printk(KERN_ERR 689 "NILFS: Unrecognized mount option \"%s\"\n", p); 690 return 0; 691 } 692 } 693 return 1; 694} 695 696static inline void 697nilfs_set_default_options(struct nilfs_sb_info *sbi, 698 struct nilfs_super_block *sbp) 699{ 700 sbi->s_mount_opt = 701 NILFS_MOUNT_ERRORS_RO | NILFS_MOUNT_BARRIER; 702} 703 704static int nilfs_setup_super(struct nilfs_sb_info *sbi) 705{ 706 struct the_nilfs *nilfs = sbi->s_nilfs; 707 struct nilfs_super_block **sbp; 708 int max_mnt_count; 709 int mnt_count; 710 711 /* nilfs->ns_sem must be locked by the caller. */ 712 sbp = nilfs_prepare_super(sbi, 0); 713 if (!sbp) 714 return -EIO; 715 716 max_mnt_count = le16_to_cpu(sbp[0]->s_max_mnt_count); 717 mnt_count = le16_to_cpu(sbp[0]->s_mnt_count); 718 719 if (nilfs->ns_mount_state & NILFS_ERROR_FS) { 720 printk(KERN_WARNING 721 "NILFS warning: mounting fs with errors\n"); 722 } 723 if (!max_mnt_count) 724 sbp[0]->s_max_mnt_count = cpu_to_le16(NILFS_DFL_MAX_MNT_COUNT); 725 726 sbp[0]->s_mnt_count = cpu_to_le16(mnt_count + 1); 727 sbp[0]->s_state = 728 cpu_to_le16(le16_to_cpu(sbp[0]->s_state) & ~NILFS_VALID_FS); 729 sbp[0]->s_mtime = cpu_to_le64(get_seconds()); 730 /* synchronize sbp[1] with sbp[0] */ 731 if (sbp[1]) 732 memcpy(sbp[1], sbp[0], nilfs->ns_sbsize); 733 return nilfs_commit_super(sbi, NILFS_SB_COMMIT_ALL); 734} 735 736struct nilfs_super_block *nilfs_read_super_block(struct super_block *sb, 737 u64 pos, int blocksize, 738 struct buffer_head **pbh) 739{ 740 unsigned long long sb_index = pos; 741 unsigned long offset; 742 743 offset = do_div(sb_index, blocksize); 744 *pbh = sb_bread(sb, sb_index); 745 if (!*pbh) 746 return NULL; 747 return (struct nilfs_super_block *)((char *)(*pbh)->b_data + offset); 748} 749 750int nilfs_store_magic_and_option(struct super_block *sb, 751 struct nilfs_super_block *sbp, 752 char *data) 753{ 754 struct nilfs_sb_info *sbi = NILFS_SB(sb); 755 756 sb->s_magic = le16_to_cpu(sbp->s_magic); 757 758 /* FS independent flags */ 759#ifdef NILFS_ATIME_DISABLE 760 sb->s_flags |= MS_NOATIME; 761#endif 762 763 nilfs_set_default_options(sbi, sbp); 764 765 sbi->s_resuid = le16_to_cpu(sbp->s_def_resuid); 766 sbi->s_resgid = le16_to_cpu(sbp->s_def_resgid); 767 sbi->s_interval = le32_to_cpu(sbp->s_c_interval); 768 sbi->s_watermark = le32_to_cpu(sbp->s_c_block_max); 769 770 return !parse_options(data, sb, 0) ? -EINVAL : 0 ; 771} 772 773int nilfs_check_feature_compatibility(struct super_block *sb, 774 struct nilfs_super_block *sbp) 775{ 776 __u64 features; 777 778 features = le64_to_cpu(sbp->s_feature_incompat) & 779 ~NILFS_FEATURE_INCOMPAT_SUPP; 780 if (features) { 781 printk(KERN_ERR "NILFS: couldn't mount because of unsupported " 782 "optional features (%llx)\n", 783 (unsigned long long)features); 784 return -EINVAL; 785 } 786 features = le64_to_cpu(sbp->s_feature_compat_ro) & 787 ~NILFS_FEATURE_COMPAT_RO_SUPP; 788 if (!(sb->s_flags & MS_RDONLY) && features) { 789 printk(KERN_ERR "NILFS: couldn't mount RDWR because of " 790 "unsupported optional features (%llx)\n", 791 (unsigned long long)features); 792 return -EINVAL; 793 } 794 return 0; 795} 796 797/** 798 * nilfs_fill_super() - initialize a super block instance 799 * @sb: super_block 800 * @data: mount options 801 * @silent: silent mode flag 802 * @nilfs: the_nilfs struct 803 * 804 * This function is called exclusively by nilfs->ns_mount_mutex. 805 * So, the recovery process is protected from other simultaneous mounts. 806 */ 807static int 808nilfs_fill_super(struct super_block *sb, void *data, int silent, 809 struct the_nilfs *nilfs) 810{ 811 struct nilfs_sb_info *sbi; 812 struct inode *root; 813 __u64 cno; 814 int err; 815 816 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); 817 if (!sbi) 818 return -ENOMEM; 819 820 sb->s_fs_info = sbi; 821 822 get_nilfs(nilfs); 823 sbi->s_nilfs = nilfs; 824 sbi->s_super = sb; 825 atomic_set(&sbi->s_count, 1); 826 827 err = init_nilfs(nilfs, sbi, (char *)data); 828 if (err) 829 goto failed_sbi; 830 831 spin_lock_init(&sbi->s_inode_lock); 832 INIT_LIST_HEAD(&sbi->s_dirty_files); 833 INIT_LIST_HEAD(&sbi->s_list); 834 835 /* 836 * Following initialization is overlapped because 837 * nilfs_sb_info structure has been cleared at the beginning. 838 * But we reserve them to keep our interest and make ready 839 * for the future change. 840 */ 841 get_random_bytes(&sbi->s_next_generation, 842 sizeof(sbi->s_next_generation)); 843 spin_lock_init(&sbi->s_next_gen_lock); 844 845 sb->s_op = &nilfs_sops; 846 sb->s_export_op = &nilfs_export_ops; 847 sb->s_root = NULL; 848 sb->s_time_gran = 1; 849 sb->s_bdi = nilfs->ns_bdi; 850 851 err = load_nilfs(nilfs, sbi); 852 if (err) 853 goto failed_sbi; 854 855 cno = nilfs_last_cno(nilfs); 856 857 if (sb->s_flags & MS_RDONLY) { 858 if (nilfs_test_opt(sbi, SNAPSHOT)) { 859 down_read(&nilfs->ns_segctor_sem); 860 err = nilfs_cpfile_is_snapshot(nilfs->ns_cpfile, 861 sbi->s_snapshot_cno); 862 up_read(&nilfs->ns_segctor_sem); 863 if (err < 0) { 864 if (err == -ENOENT) 865 err = -EINVAL; 866 goto failed_sbi; 867 } 868 if (!err) { 869 printk(KERN_ERR 870 "NILFS: The specified checkpoint is " 871 "not a snapshot " 872 "(checkpoint number=%llu).\n", 873 (unsigned long long)sbi->s_snapshot_cno); 874 err = -EINVAL; 875 goto failed_sbi; 876 } 877 cno = sbi->s_snapshot_cno; 878 } 879 } 880 881 err = nilfs_attach_checkpoint(sbi, cno); 882 if (err) { 883 printk(KERN_ERR "NILFS: error loading a checkpoint" 884 " (checkpoint number=%llu).\n", (unsigned long long)cno); 885 goto failed_sbi; 886 } 887 888 if (!(sb->s_flags & MS_RDONLY)) { 889 err = nilfs_attach_segment_constructor(sbi); 890 if (err) 891 goto failed_checkpoint; 892 } 893 894 root = nilfs_iget(sb, NILFS_ROOT_INO); 895 if (IS_ERR(root)) { 896 printk(KERN_ERR "NILFS: get root inode failed\n"); 897 err = PTR_ERR(root); 898 goto failed_segctor; 899 } 900 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) { 901 iput(root); 902 printk(KERN_ERR "NILFS: corrupt root inode.\n"); 903 err = -EINVAL; 904 goto failed_segctor; 905 } 906 sb->s_root = d_alloc_root(root); 907 if (!sb->s_root) { 908 iput(root); 909 printk(KERN_ERR "NILFS: get root dentry failed\n"); 910 err = -ENOMEM; 911 goto failed_segctor; 912 } 913 914 if (!(sb->s_flags & MS_RDONLY)) { 915 down_write(&nilfs->ns_sem); 916 nilfs_setup_super(sbi); 917 up_write(&nilfs->ns_sem); 918 } 919 920 down_write(&nilfs->ns_super_sem); 921 if (!nilfs_test_opt(sbi, SNAPSHOT)) 922 nilfs->ns_current = sbi; 923 up_write(&nilfs->ns_super_sem); 924 925 return 0; 926 927 failed_segctor: 928 nilfs_detach_segment_constructor(sbi); 929 930 failed_checkpoint: 931 nilfs_detach_checkpoint(sbi); 932 933 failed_sbi: 934 put_nilfs(nilfs); 935 sb->s_fs_info = NULL; 936 nilfs_put_sbinfo(sbi); 937 return err; 938} 939 940static int nilfs_remount(struct super_block *sb, int *flags, char *data) 941{ 942 struct nilfs_sb_info *sbi = NILFS_SB(sb); 943 struct the_nilfs *nilfs = sbi->s_nilfs; 944 unsigned long old_sb_flags; 945 struct nilfs_mount_options old_opts; 946 int was_snapshot, err; 947 948 lock_kernel(); 949 950 down_write(&nilfs->ns_super_sem); 951 old_sb_flags = sb->s_flags; 952 old_opts.mount_opt = sbi->s_mount_opt; 953 old_opts.snapshot_cno = sbi->s_snapshot_cno; 954 was_snapshot = nilfs_test_opt(sbi, SNAPSHOT); 955 956 if (!parse_options(data, sb, 1)) { 957 err = -EINVAL; 958 goto restore_opts; 959 } 960 sb->s_flags = (sb->s_flags & ~MS_POSIXACL); 961 962 err = -EINVAL; 963 if (was_snapshot && !(*flags & MS_RDONLY)) { 964 printk(KERN_ERR "NILFS (device %s): cannot remount snapshot " 965 "read/write.\n", sb->s_id); 966 goto restore_opts; 967 } 968 969 if (!nilfs_valid_fs(nilfs)) { 970 printk(KERN_WARNING "NILFS (device %s): couldn't " 971 "remount because the filesystem is in an " 972 "incomplete recovery state.\n", sb->s_id); 973 goto restore_opts; 974 } 975 976 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) 977 goto out; 978 if (*flags & MS_RDONLY) { 979 /* Shutting down the segment constructor */ 980 nilfs_detach_segment_constructor(sbi); 981 sb->s_flags |= MS_RDONLY; 982 983 /* 984 * Remounting a valid RW partition RDONLY, so set 985 * the RDONLY flag and then mark the partition as valid again. 986 */ 987 down_write(&nilfs->ns_sem); 988 nilfs_cleanup_super(sbi); 989 up_write(&nilfs->ns_sem); 990 } else { 991 __u64 features; 992 993 /* 994 * Mounting a RDONLY partition read-write, so reread and 995 * store the current valid flag. (It may have been changed 996 * by fsck since we originally mounted the partition.) 997 */ 998 down_read(&nilfs->ns_sem); 999 features = le64_to_cpu(nilfs->ns_sbp[0]->s_feature_compat_ro) & 1000 ~NILFS_FEATURE_COMPAT_RO_SUPP; 1001 up_read(&nilfs->ns_sem); 1002 if (features) { 1003 printk(KERN_WARNING "NILFS (device %s): couldn't " 1004 "remount RDWR because of unsupported optional " 1005 "features (%llx)\n", 1006 sb->s_id, (unsigned long long)features); 1007 err = -EROFS; 1008 goto restore_opts; 1009 } 1010 1011 sb->s_flags &= ~MS_RDONLY; 1012 1013 err = nilfs_attach_segment_constructor(sbi); 1014 if (err) 1015 goto restore_opts; 1016 1017 down_write(&nilfs->ns_sem); 1018 nilfs_setup_super(sbi); 1019 up_write(&nilfs->ns_sem); 1020 } 1021 out: 1022 up_write(&nilfs->ns_super_sem); 1023 unlock_kernel(); 1024 return 0; 1025 1026 restore_opts: 1027 sb->s_flags = old_sb_flags; 1028 sbi->s_mount_opt = old_opts.mount_opt; 1029 sbi->s_snapshot_cno = old_opts.snapshot_cno; 1030 up_write(&nilfs->ns_super_sem); 1031 unlock_kernel(); 1032 return err; 1033} 1034 1035struct nilfs_super_data { 1036 struct block_device *bdev; 1037 struct nilfs_sb_info *sbi; 1038 __u64 cno; 1039 int flags; 1040}; 1041 1042/** 1043 * nilfs_identify - pre-read mount options needed to identify mount instance 1044 * @data: mount options 1045 * @sd: nilfs_super_data 1046 */ 1047static int nilfs_identify(char *data, struct nilfs_super_data *sd) 1048{ 1049 char *p, *options = data; 1050 substring_t args[MAX_OPT_ARGS]; 1051 int option, token; 1052 int ret = 0; 1053 1054 do { 1055 p = strsep(&options, ","); 1056 if (p != NULL && *p) { 1057 token = match_token(p, tokens, args); 1058 if (token == Opt_snapshot) { 1059 if (!(sd->flags & MS_RDONLY)) 1060 ret++; 1061 else { 1062 ret = match_int(&args[0], &option); 1063 if (!ret) { 1064 if (option > 0) 1065 sd->cno = option; 1066 else 1067 ret++; 1068 } 1069 } 1070 } 1071 if (ret) 1072 printk(KERN_ERR 1073 "NILFS: invalid mount option: %s\n", p); 1074 } 1075 if (!options) 1076 break; 1077 BUG_ON(options == data); 1078 *(options - 1) = ','; 1079 } while (!ret); 1080 return ret; 1081} 1082 1083static int nilfs_set_bdev_super(struct super_block *s, void *data) 1084{ 1085 struct nilfs_super_data *sd = data; 1086 1087 s->s_bdev = sd->bdev; 1088 s->s_dev = s->s_bdev->bd_dev; 1089 return 0; 1090} 1091 1092static int nilfs_test_bdev_super(struct super_block *s, void *data) 1093{ 1094 struct nilfs_super_data *sd = data; 1095 1096 return sd->sbi && s->s_fs_info == (void *)sd->sbi; 1097} 1098 1099static int 1100nilfs_get_sb(struct file_system_type *fs_type, int flags, 1101 const char *dev_name, void *data, struct vfsmount *mnt) 1102{ 1103 struct nilfs_super_data sd; 1104 struct super_block *s; 1105 fmode_t mode = FMODE_READ; 1106 struct the_nilfs *nilfs; 1107 int err, need_to_close = 1; 1108 1109 if (!(flags & MS_RDONLY)) 1110 mode |= FMODE_WRITE; 1111 1112 sd.bdev = open_bdev_exclusive(dev_name, mode, fs_type); 1113 if (IS_ERR(sd.bdev)) 1114 return PTR_ERR(sd.bdev); 1115 1116 /* 1117 * To get mount instance using sget() vfs-routine, NILFS needs 1118 * much more information than normal filesystems to identify mount 1119 * instance. For snapshot mounts, not only a mount type (ro-mount 1120 * or rw-mount) but also a checkpoint number is required. 1121 */ 1122 sd.cno = 0; 1123 sd.flags = flags; 1124 if (nilfs_identify((char *)data, &sd)) { 1125 err = -EINVAL; 1126 goto failed; 1127 } 1128 1129 nilfs = find_or_create_nilfs(sd.bdev); 1130 if (!nilfs) { 1131 err = -ENOMEM; 1132 goto failed; 1133 } 1134 1135 mutex_lock(&nilfs->ns_mount_mutex); 1136 1137 if (!sd.cno) { 1138 /* 1139 * Check if an exclusive mount exists or not. 1140 * Snapshot mounts coexist with a current mount 1141 * (i.e. rw-mount or ro-mount), whereas rw-mount and 1142 * ro-mount are mutually exclusive. 1143 */ 1144 down_read(&nilfs->ns_super_sem); 1145 if (nilfs->ns_current && 1146 ((nilfs->ns_current->s_super->s_flags ^ flags) 1147 & MS_RDONLY)) { 1148 up_read(&nilfs->ns_super_sem); 1149 err = -EBUSY; 1150 goto failed_unlock; 1151 } 1152 up_read(&nilfs->ns_super_sem); 1153 } 1154 1155 /* 1156 * Find existing nilfs_sb_info struct 1157 */ 1158 sd.sbi = nilfs_find_sbinfo(nilfs, !(flags & MS_RDONLY), sd.cno); 1159 1160 /* 1161 * Get super block instance holding the nilfs_sb_info struct. 1162 * A new instance is allocated if no existing mount is present or 1163 * existing instance has been unmounted. 1164 */ 1165 s = sget(fs_type, nilfs_test_bdev_super, nilfs_set_bdev_super, &sd); 1166 if (sd.sbi) 1167 nilfs_put_sbinfo(sd.sbi); 1168 1169 if (IS_ERR(s)) { 1170 err = PTR_ERR(s); 1171 goto failed_unlock; 1172 } 1173 1174 if (!s->s_root) { 1175 char b[BDEVNAME_SIZE]; 1176 1177 /* New superblock instance created */ 1178 s->s_flags = flags; 1179 s->s_mode = mode; 1180 strlcpy(s->s_id, bdevname(sd.bdev, b), sizeof(s->s_id)); 1181 sb_set_blocksize(s, block_size(sd.bdev)); 1182 1183 err = nilfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0, 1184 nilfs); 1185 if (err) 1186 goto cancel_new; 1187 1188 s->s_flags |= MS_ACTIVE; 1189 need_to_close = 0; 1190 } 1191 1192 mutex_unlock(&nilfs->ns_mount_mutex); 1193 put_nilfs(nilfs); 1194 if (need_to_close) 1195 close_bdev_exclusive(sd.bdev, mode); 1196 simple_set_mnt(mnt, s); 1197 return 0; 1198 1199 failed_unlock: 1200 mutex_unlock(&nilfs->ns_mount_mutex); 1201 put_nilfs(nilfs); 1202 failed: 1203 close_bdev_exclusive(sd.bdev, mode); 1204 1205 return err; 1206 1207 cancel_new: 1208 /* Abandoning the newly allocated superblock */ 1209 mutex_unlock(&nilfs->ns_mount_mutex); 1210 put_nilfs(nilfs); 1211 deactivate_locked_super(s); 1212 /* 1213 * deactivate_locked_super() invokes close_bdev_exclusive(). 1214 * We must finish all post-cleaning before this call; 1215 * put_nilfs() needs the block device. 1216 */ 1217 return err; 1218} 1219 1220struct file_system_type nilfs_fs_type = { 1221 .owner = THIS_MODULE, 1222 .name = "nilfs2", 1223 .get_sb = nilfs_get_sb, 1224 .kill_sb = kill_block_super, 1225 .fs_flags = FS_REQUIRES_DEV, 1226}; 1227 1228static void nilfs_inode_init_once(void *obj) 1229{ 1230 struct nilfs_inode_info *ii = obj; 1231 1232 INIT_LIST_HEAD(&ii->i_dirty); 1233#ifdef CONFIG_NILFS_XATTR 1234 init_rwsem(&ii->xattr_sem); 1235#endif 1236 nilfs_btnode_cache_init_once(&ii->i_btnode_cache); 1237 ii->i_bmap = &ii->i_bmap_data; 1238 inode_init_once(&ii->vfs_inode); 1239} 1240 1241static void nilfs_segbuf_init_once(void *obj) 1242{ 1243 memset(obj, 0, sizeof(struct nilfs_segment_buffer)); 1244} 1245 1246static void nilfs_destroy_cachep(void) 1247{ 1248 if (nilfs_inode_cachep) 1249 kmem_cache_destroy(nilfs_inode_cachep); 1250 if (nilfs_transaction_cachep) 1251 kmem_cache_destroy(nilfs_transaction_cachep); 1252 if (nilfs_segbuf_cachep) 1253 kmem_cache_destroy(nilfs_segbuf_cachep); 1254 if (nilfs_btree_path_cache) 1255 kmem_cache_destroy(nilfs_btree_path_cache); 1256} 1257 1258static int __init nilfs_init_cachep(void) 1259{ 1260 nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache", 1261 sizeof(struct nilfs_inode_info), 0, 1262 SLAB_RECLAIM_ACCOUNT, nilfs_inode_init_once); 1263 if (!nilfs_inode_cachep) 1264 goto fail; 1265 1266 nilfs_transaction_cachep = kmem_cache_create("nilfs2_transaction_cache", 1267 sizeof(struct nilfs_transaction_info), 0, 1268 SLAB_RECLAIM_ACCOUNT, NULL); 1269 if (!nilfs_transaction_cachep) 1270 goto fail; 1271 1272 nilfs_segbuf_cachep = kmem_cache_create("nilfs2_segbuf_cache", 1273 sizeof(struct nilfs_segment_buffer), 0, 1274 SLAB_RECLAIM_ACCOUNT, nilfs_segbuf_init_once); 1275 if (!nilfs_segbuf_cachep) 1276 goto fail; 1277 1278 nilfs_btree_path_cache = kmem_cache_create("nilfs2_btree_path_cache", 1279 sizeof(struct nilfs_btree_path) * NILFS_BTREE_LEVEL_MAX, 1280 0, 0, NULL); 1281 if (!nilfs_btree_path_cache) 1282 goto fail; 1283 1284 return 0; 1285 1286fail: 1287 nilfs_destroy_cachep(); 1288 return -ENOMEM; 1289} 1290 1291static int __init init_nilfs_fs(void) 1292{ 1293 int err; 1294 1295 err = nilfs_init_cachep(); 1296 if (err) 1297 goto fail; 1298 1299 err = register_filesystem(&nilfs_fs_type); 1300 if (err) 1301 goto free_cachep; 1302 1303 printk(KERN_INFO "NILFS version 2 loaded\n"); 1304 return 0; 1305 1306free_cachep: 1307 nilfs_destroy_cachep(); 1308fail: 1309 return err; 1310} 1311 1312static void __exit exit_nilfs_fs(void) 1313{ 1314 nilfs_destroy_cachep(); 1315 unregister_filesystem(&nilfs_fs_type); 1316} 1317 1318module_init(init_nilfs_fs) 1319module_exit(exit_nilfs_fs) 1320