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