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