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