1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * super.c 5 * 6 * load/unload driver, mount/dismount volumes 7 * 8 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public 12 * License as published by the Free Software Foundation; either 13 * version 2 of the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public 21 * License along with this program; if not, write to the 22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23 * Boston, MA 021110-1307, USA. 24 */ 25 26 #include <linux/module.h> 27 #include <linux/fs.h> 28 #include <linux/types.h> 29 #include <linux/slab.h> 30 #include <linux/highmem.h> 31 #include <linux/utsname.h> 32 #include <linux/init.h> 33 #include <linux/random.h> 34 #include <linux/statfs.h> 35 #include <linux/moduleparam.h> 36 #include <linux/blkdev.h> 37 #include <linux/socket.h> 38 #include <linux/inet.h> 39 #include <linux/parser.h> 40 #include <linux/crc32.h> 41 #include <linux/debugfs.h> 42 #include <linux/mount.h> 43 44 #include <cluster/nodemanager.h> 45 46 #define MLOG_MASK_PREFIX ML_SUPER 47 #include <cluster/masklog.h> 48 49 #include "ocfs2.h" 50 51 /* this should be the only file to include a version 1 header */ 52 #include "ocfs1_fs_compat.h" 53 54 #include "alloc.h" 55 #include "dlmglue.h" 56 #include "export.h" 57 #include "extent_map.h" 58 #include "heartbeat.h" 59 #include "inode.h" 60 #include "journal.h" 61 #include "localalloc.h" 62 #include "namei.h" 63 #include "slot_map.h" 64 #include "super.h" 65 #include "sysfile.h" 66 #include "uptodate.h" 67 #include "ver.h" 68 #include "vote.h" 69 70 #include "buffer_head_io.h" 71 72 static struct kmem_cache *ocfs2_inode_cachep = NULL; 73 74 /* OCFS2 needs to schedule several differnt types of work which 75 * require cluster locking, disk I/O, recovery waits, etc. Since these 76 * types of work tend to be heavy we avoid using the kernel events 77 * workqueue and schedule on our own. */ 78 struct workqueue_struct *ocfs2_wq = NULL; 79 80 static struct dentry *ocfs2_debugfs_root = NULL; 81 82 MODULE_AUTHOR("Oracle"); 83 MODULE_LICENSE("GPL"); 84 85 struct mount_options 86 { 87 unsigned long mount_opt; 88 unsigned int atime_quantum; 89 signed short slot; 90 }; 91 92 static int ocfs2_parse_options(struct super_block *sb, char *options, 93 struct mount_options *mopt, 94 int is_remount); 95 static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt); 96 static void ocfs2_put_super(struct super_block *sb); 97 static int ocfs2_mount_volume(struct super_block *sb); 98 static int ocfs2_remount(struct super_block *sb, int *flags, char *data); 99 static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err); 100 static int ocfs2_initialize_mem_caches(void); 101 static void ocfs2_free_mem_caches(void); 102 static void ocfs2_delete_osb(struct ocfs2_super *osb); 103 104 static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf); 105 106 static int ocfs2_sync_fs(struct super_block *sb, int wait); 107 108 static int ocfs2_init_global_system_inodes(struct ocfs2_super *osb); 109 static int ocfs2_init_local_system_inodes(struct ocfs2_super *osb); 110 static void ocfs2_release_system_inodes(struct ocfs2_super *osb); 111 static int ocfs2_fill_local_node_info(struct ocfs2_super *osb); 112 static int ocfs2_check_volume(struct ocfs2_super *osb); 113 static int ocfs2_verify_volume(struct ocfs2_dinode *di, 114 struct buffer_head *bh, 115 u32 sectsize); 116 static int ocfs2_initialize_super(struct super_block *sb, 117 struct buffer_head *bh, 118 int sector_size); 119 static int ocfs2_get_sector(struct super_block *sb, 120 struct buffer_head **bh, 121 int block, 122 int sect_size); 123 static void ocfs2_write_super(struct super_block *sb); 124 static struct inode *ocfs2_alloc_inode(struct super_block *sb); 125 static void ocfs2_destroy_inode(struct inode *inode); 126 127 static const struct super_operations ocfs2_sops = { 128 .statfs = ocfs2_statfs, 129 .alloc_inode = ocfs2_alloc_inode, 130 .destroy_inode = ocfs2_destroy_inode, 131 .drop_inode = ocfs2_drop_inode, 132 .clear_inode = ocfs2_clear_inode, 133 .delete_inode = ocfs2_delete_inode, 134 .sync_fs = ocfs2_sync_fs, 135 .write_super = ocfs2_write_super, 136 .put_super = ocfs2_put_super, 137 .remount_fs = ocfs2_remount, 138 .show_options = ocfs2_show_options, 139 }; 140 141 enum { 142 Opt_barrier, 143 Opt_err_panic, 144 Opt_err_ro, 145 Opt_intr, 146 Opt_nointr, 147 Opt_hb_none, 148 Opt_hb_local, 149 Opt_data_ordered, 150 Opt_data_writeback, 151 Opt_atime_quantum, 152 Opt_slot, 153 Opt_err, 154 }; 155 156 static match_table_t tokens = { 157 {Opt_barrier, "barrier=%u"}, 158 {Opt_err_panic, "errors=panic"}, 159 {Opt_err_ro, "errors=remount-ro"}, 160 {Opt_intr, "intr"}, 161 {Opt_nointr, "nointr"}, 162 {Opt_hb_none, OCFS2_HB_NONE}, 163 {Opt_hb_local, OCFS2_HB_LOCAL}, 164 {Opt_data_ordered, "data=ordered"}, 165 {Opt_data_writeback, "data=writeback"}, 166 {Opt_atime_quantum, "atime_quantum=%u"}, 167 {Opt_slot, "preferred_slot=%u"}, 168 {Opt_err, NULL} 169 }; 170 171 /* 172 * write_super and sync_fs ripped right out of ext3. 173 */ 174 static void ocfs2_write_super(struct super_block *sb) 175 { 176 if (mutex_trylock(&sb->s_lock) != 0) 177 BUG(); 178 sb->s_dirt = 0; 179 } 180 181 static int ocfs2_sync_fs(struct super_block *sb, int wait) 182 { 183 int status; 184 tid_t target; 185 struct ocfs2_super *osb = OCFS2_SB(sb); 186 187 sb->s_dirt = 0; 188 189 if (ocfs2_is_hard_readonly(osb)) 190 return -EROFS; 191 192 if (wait) { 193 status = ocfs2_flush_truncate_log(osb); 194 if (status < 0) 195 mlog_errno(status); 196 } else { 197 ocfs2_schedule_truncate_log_flush(osb, 0); 198 } 199 200 if (journal_start_commit(OCFS2_SB(sb)->journal->j_journal, &target)) { 201 if (wait) 202 log_wait_commit(OCFS2_SB(sb)->journal->j_journal, 203 target); 204 } 205 return 0; 206 } 207 208 static int ocfs2_init_global_system_inodes(struct ocfs2_super *osb) 209 { 210 struct inode *new = NULL; 211 int status = 0; 212 int i; 213 214 mlog_entry_void(); 215 216 new = ocfs2_iget(osb, osb->root_blkno, OCFS2_FI_FLAG_SYSFILE); 217 if (IS_ERR(new)) { 218 status = PTR_ERR(new); 219 mlog_errno(status); 220 goto bail; 221 } 222 osb->root_inode = new; 223 224 new = ocfs2_iget(osb, osb->system_dir_blkno, OCFS2_FI_FLAG_SYSFILE); 225 if (IS_ERR(new)) { 226 status = PTR_ERR(new); 227 mlog_errno(status); 228 goto bail; 229 } 230 osb->sys_root_inode = new; 231 232 for (i = OCFS2_FIRST_ONLINE_SYSTEM_INODE; 233 i <= OCFS2_LAST_GLOBAL_SYSTEM_INODE; i++) { 234 new = ocfs2_get_system_file_inode(osb, i, osb->slot_num); 235 if (!new) { 236 ocfs2_release_system_inodes(osb); 237 status = -EINVAL; 238 mlog_errno(status); 239 /* FIXME: Should ERROR_RO_FS */ 240 mlog(ML_ERROR, "Unable to load system inode %d, " 241 "possibly corrupt fs?", i); 242 goto bail; 243 } 244 // the array now has one ref, so drop this one 245 iput(new); 246 } 247 248 bail: 249 mlog_exit(status); 250 return status; 251 } 252 253 static int ocfs2_init_local_system_inodes(struct ocfs2_super *osb) 254 { 255 struct inode *new = NULL; 256 int status = 0; 257 int i; 258 259 mlog_entry_void(); 260 261 for (i = OCFS2_LAST_GLOBAL_SYSTEM_INODE + 1; 262 i < NUM_SYSTEM_INODES; 263 i++) { 264 new = ocfs2_get_system_file_inode(osb, i, osb->slot_num); 265 if (!new) { 266 ocfs2_release_system_inodes(osb); 267 status = -EINVAL; 268 mlog(ML_ERROR, "status=%d, sysfile=%d, slot=%d\n", 269 status, i, osb->slot_num); 270 goto bail; 271 } 272 /* the array now has one ref, so drop this one */ 273 iput(new); 274 } 275 276 bail: 277 mlog_exit(status); 278 return status; 279 } 280 281 static void ocfs2_release_system_inodes(struct ocfs2_super *osb) 282 { 283 int i; 284 struct inode *inode; 285 286 mlog_entry_void(); 287 288 for (i = 0; i < NUM_SYSTEM_INODES; i++) { 289 inode = osb->system_inodes[i]; 290 if (inode) { 291 iput(inode); 292 osb->system_inodes[i] = NULL; 293 } 294 } 295 296 inode = osb->sys_root_inode; 297 if (inode) { 298 iput(inode); 299 osb->sys_root_inode = NULL; 300 } 301 302 inode = osb->root_inode; 303 if (inode) { 304 iput(inode); 305 osb->root_inode = NULL; 306 } 307 308 mlog_exit(0); 309 } 310 311 /* We're allocating fs objects, use GFP_NOFS */ 312 static struct inode *ocfs2_alloc_inode(struct super_block *sb) 313 { 314 struct ocfs2_inode_info *oi; 315 316 oi = kmem_cache_alloc(ocfs2_inode_cachep, GFP_NOFS); 317 if (!oi) 318 return NULL; 319 320 return &oi->vfs_inode; 321 } 322 323 static void ocfs2_destroy_inode(struct inode *inode) 324 { 325 kmem_cache_free(ocfs2_inode_cachep, OCFS2_I(inode)); 326 } 327 328 static unsigned long long ocfs2_max_file_offset(unsigned int bbits, 329 unsigned int cbits) 330 { 331 unsigned int bytes = 1 << cbits; 332 unsigned int trim = bytes; 333 unsigned int bitshift = 32; 334 335 /* 336 * i_size and all block offsets in ocfs2 are always 64 bits 337 * wide. i_clusters is 32 bits, in cluster-sized units. So on 338 * 64 bit platforms, cluster size will be the limiting factor. 339 */ 340 341 #if BITS_PER_LONG == 32 342 # if defined(CONFIG_LBD) 343 BUILD_BUG_ON(sizeof(sector_t) != 8); 344 /* 345 * We might be limited by page cache size. 346 */ 347 if (bytes > PAGE_CACHE_SIZE) { 348 bytes = PAGE_CACHE_SIZE; 349 trim = 1; 350 /* 351 * Shift by 31 here so that we don't get larger than 352 * MAX_LFS_FILESIZE 353 */ 354 bitshift = 31; 355 } 356 # else 357 /* 358 * We are limited by the size of sector_t. Use block size, as 359 * that's what we expose to the VFS. 360 */ 361 bytes = 1 << bbits; 362 trim = 1; 363 bitshift = 31; 364 # endif 365 #endif 366 367 /* 368 * Trim by a whole cluster when we can actually approach the 369 * on-disk limits. Otherwise we can overflow i_clusters when 370 * an extent start is at the max offset. 371 */ 372 return (((unsigned long long)bytes) << bitshift) - trim; 373 } 374 375 static int ocfs2_remount(struct super_block *sb, int *flags, char *data) 376 { 377 int incompat_features; 378 int ret = 0; 379 struct mount_options parsed_options; 380 struct ocfs2_super *osb = OCFS2_SB(sb); 381 382 if (!ocfs2_parse_options(sb, data, &parsed_options, 1)) { 383 ret = -EINVAL; 384 goto out; 385 } 386 387 if ((osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) != 388 (parsed_options.mount_opt & OCFS2_MOUNT_HB_LOCAL)) { 389 ret = -EINVAL; 390 mlog(ML_ERROR, "Cannot change heartbeat mode on remount\n"); 391 goto out; 392 } 393 394 if ((osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) != 395 (parsed_options.mount_opt & OCFS2_MOUNT_DATA_WRITEBACK)) { 396 ret = -EINVAL; 397 mlog(ML_ERROR, "Cannot change data mode on remount\n"); 398 goto out; 399 } 400 401 /* We're going to/from readonly mode. */ 402 if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) { 403 /* Lock here so the check of HARD_RO and the potential 404 * setting of SOFT_RO is atomic. */ 405 spin_lock(&osb->osb_lock); 406 if (osb->osb_flags & OCFS2_OSB_HARD_RO) { 407 mlog(ML_ERROR, "Remount on readonly device is forbidden.\n"); 408 ret = -EROFS; 409 goto unlock_osb; 410 } 411 412 if (*flags & MS_RDONLY) { 413 mlog(0, "Going to ro mode.\n"); 414 sb->s_flags |= MS_RDONLY; 415 osb->osb_flags |= OCFS2_OSB_SOFT_RO; 416 } else { 417 mlog(0, "Making ro filesystem writeable.\n"); 418 419 if (osb->osb_flags & OCFS2_OSB_ERROR_FS) { 420 mlog(ML_ERROR, "Cannot remount RDWR " 421 "filesystem due to previous errors.\n"); 422 ret = -EROFS; 423 goto unlock_osb; 424 } 425 incompat_features = OCFS2_HAS_RO_COMPAT_FEATURE(sb, ~OCFS2_FEATURE_RO_COMPAT_SUPP); 426 if (incompat_features) { 427 mlog(ML_ERROR, "Cannot remount RDWR because " 428 "of unsupported optional features " 429 "(%x).\n", incompat_features); 430 ret = -EINVAL; 431 goto unlock_osb; 432 } 433 sb->s_flags &= ~MS_RDONLY; 434 osb->osb_flags &= ~OCFS2_OSB_SOFT_RO; 435 } 436 unlock_osb: 437 spin_unlock(&osb->osb_lock); 438 } 439 440 if (!ret) { 441 if (!ocfs2_is_hard_readonly(osb)) 442 ocfs2_set_journal_params(osb); 443 444 /* Only save off the new mount options in case of a successful 445 * remount. */ 446 osb->s_mount_opt = parsed_options.mount_opt; 447 osb->s_atime_quantum = parsed_options.atime_quantum; 448 osb->preferred_slot = parsed_options.slot; 449 } 450 out: 451 return ret; 452 } 453 454 static int ocfs2_sb_probe(struct super_block *sb, 455 struct buffer_head **bh, 456 int *sector_size) 457 { 458 int status, tmpstat; 459 struct ocfs1_vol_disk_hdr *hdr; 460 struct ocfs2_dinode *di; 461 int blksize; 462 463 *bh = NULL; 464 465 /* may be > 512 */ 466 *sector_size = bdev_hardsect_size(sb->s_bdev); 467 if (*sector_size > OCFS2_MAX_BLOCKSIZE) { 468 mlog(ML_ERROR, "Hardware sector size too large: %d (max=%d)\n", 469 *sector_size, OCFS2_MAX_BLOCKSIZE); 470 status = -EINVAL; 471 goto bail; 472 } 473 474 /* Can this really happen? */ 475 if (*sector_size < OCFS2_MIN_BLOCKSIZE) 476 *sector_size = OCFS2_MIN_BLOCKSIZE; 477 478 /* check block zero for old format */ 479 status = ocfs2_get_sector(sb, bh, 0, *sector_size); 480 if (status < 0) { 481 mlog_errno(status); 482 goto bail; 483 } 484 hdr = (struct ocfs1_vol_disk_hdr *) (*bh)->b_data; 485 if (hdr->major_version == OCFS1_MAJOR_VERSION) { 486 mlog(ML_ERROR, "incompatible version: %u.%u\n", 487 hdr->major_version, hdr->minor_version); 488 status = -EINVAL; 489 } 490 if (memcmp(hdr->signature, OCFS1_VOLUME_SIGNATURE, 491 strlen(OCFS1_VOLUME_SIGNATURE)) == 0) { 492 mlog(ML_ERROR, "incompatible volume signature: %8s\n", 493 hdr->signature); 494 status = -EINVAL; 495 } 496 brelse(*bh); 497 *bh = NULL; 498 if (status < 0) { 499 mlog(ML_ERROR, "This is an ocfs v1 filesystem which must be " 500 "upgraded before mounting with ocfs v2\n"); 501 goto bail; 502 } 503 504 /* 505 * Now check at magic offset for 512, 1024, 2048, 4096 506 * blocksizes. 4096 is the maximum blocksize because it is 507 * the minimum clustersize. 508 */ 509 status = -EINVAL; 510 for (blksize = *sector_size; 511 blksize <= OCFS2_MAX_BLOCKSIZE; 512 blksize <<= 1) { 513 tmpstat = ocfs2_get_sector(sb, bh, 514 OCFS2_SUPER_BLOCK_BLKNO, 515 blksize); 516 if (tmpstat < 0) { 517 status = tmpstat; 518 mlog_errno(status); 519 goto bail; 520 } 521 di = (struct ocfs2_dinode *) (*bh)->b_data; 522 status = ocfs2_verify_volume(di, *bh, blksize); 523 if (status >= 0) 524 goto bail; 525 brelse(*bh); 526 *bh = NULL; 527 if (status != -EAGAIN) 528 break; 529 } 530 531 bail: 532 return status; 533 } 534 535 static int ocfs2_verify_heartbeat(struct ocfs2_super *osb) 536 { 537 if (ocfs2_mount_local(osb)) { 538 if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) { 539 mlog(ML_ERROR, "Cannot heartbeat on a locally " 540 "mounted device.\n"); 541 return -EINVAL; 542 } 543 } 544 545 if (!(osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL)) { 546 if (!ocfs2_mount_local(osb) && !ocfs2_is_hard_readonly(osb)) { 547 mlog(ML_ERROR, "Heartbeat has to be started to mount " 548 "a read-write clustered device.\n"); 549 return -EINVAL; 550 } 551 } 552 553 return 0; 554 } 555 556 static int ocfs2_fill_super(struct super_block *sb, void *data, int silent) 557 { 558 struct dentry *root; 559 int status, sector_size; 560 struct mount_options parsed_options; 561 struct inode *inode = NULL; 562 struct ocfs2_super *osb = NULL; 563 struct buffer_head *bh = NULL; 564 char nodestr[8]; 565 566 mlog_entry("%p, %p, %i", sb, data, silent); 567 568 if (!ocfs2_parse_options(sb, data, &parsed_options, 0)) { 569 status = -EINVAL; 570 goto read_super_error; 571 } 572 573 /* for now we only have one cluster/node, make sure we see it 574 * in the heartbeat universe */ 575 if (parsed_options.mount_opt & OCFS2_MOUNT_HB_LOCAL) { 576 if (!o2hb_check_local_node_heartbeating()) { 577 status = -EINVAL; 578 goto read_super_error; 579 } 580 } 581 582 /* probe for superblock */ 583 status = ocfs2_sb_probe(sb, &bh, §or_size); 584 if (status < 0) { 585 mlog(ML_ERROR, "superblock probe failed!\n"); 586 goto read_super_error; 587 } 588 589 status = ocfs2_initialize_super(sb, bh, sector_size); 590 osb = OCFS2_SB(sb); 591 if (status < 0) { 592 mlog_errno(status); 593 goto read_super_error; 594 } 595 brelse(bh); 596 bh = NULL; 597 osb->s_mount_opt = parsed_options.mount_opt; 598 osb->s_atime_quantum = parsed_options.atime_quantum; 599 osb->preferred_slot = parsed_options.slot; 600 601 sb->s_magic = OCFS2_SUPER_MAGIC; 602 603 /* Hard readonly mode only if: bdev_read_only, MS_RDONLY, 604 * heartbeat=none */ 605 if (bdev_read_only(sb->s_bdev)) { 606 if (!(sb->s_flags & MS_RDONLY)) { 607 status = -EACCES; 608 mlog(ML_ERROR, "Readonly device detected but readonly " 609 "mount was not specified.\n"); 610 goto read_super_error; 611 } 612 613 /* You should not be able to start a local heartbeat 614 * on a readonly device. */ 615 if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) { 616 status = -EROFS; 617 mlog(ML_ERROR, "Local heartbeat specified on readonly " 618 "device.\n"); 619 goto read_super_error; 620 } 621 622 status = ocfs2_check_journals_nolocks(osb); 623 if (status < 0) { 624 if (status == -EROFS) 625 mlog(ML_ERROR, "Recovery required on readonly " 626 "file system, but write access is " 627 "unavailable.\n"); 628 else 629 mlog_errno(status); 630 goto read_super_error; 631 } 632 633 ocfs2_set_ro_flag(osb, 1); 634 635 printk(KERN_NOTICE "Readonly device detected. No cluster " 636 "services will be utilized for this mount. Recovery " 637 "will be skipped.\n"); 638 } 639 640 if (!ocfs2_is_hard_readonly(osb)) { 641 if (sb->s_flags & MS_RDONLY) 642 ocfs2_set_ro_flag(osb, 0); 643 } 644 645 status = ocfs2_verify_heartbeat(osb); 646 if (status < 0) { 647 mlog_errno(status); 648 goto read_super_error; 649 } 650 651 osb->osb_debug_root = debugfs_create_dir(osb->uuid_str, 652 ocfs2_debugfs_root); 653 if (!osb->osb_debug_root) { 654 status = -EINVAL; 655 mlog(ML_ERROR, "Unable to create per-mount debugfs root.\n"); 656 goto read_super_error; 657 } 658 659 status = ocfs2_mount_volume(sb); 660 if (osb->root_inode) 661 inode = igrab(osb->root_inode); 662 663 if (status < 0) 664 goto read_super_error; 665 666 if (!inode) { 667 status = -EIO; 668 mlog_errno(status); 669 goto read_super_error; 670 } 671 672 root = d_alloc_root(inode); 673 if (!root) { 674 status = -ENOMEM; 675 mlog_errno(status); 676 goto read_super_error; 677 } 678 679 sb->s_root = root; 680 681 ocfs2_complete_mount_recovery(osb); 682 683 if (ocfs2_mount_local(osb)) 684 snprintf(nodestr, sizeof(nodestr), "local"); 685 else 686 snprintf(nodestr, sizeof(nodestr), "%d", osb->node_num); 687 688 printk(KERN_INFO "ocfs2: Mounting device (%s) on (node %s, slot %d) " 689 "with %s data mode.\n", 690 osb->dev_str, nodestr, osb->slot_num, 691 osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK ? "writeback" : 692 "ordered"); 693 694 atomic_set(&osb->vol_state, VOLUME_MOUNTED); 695 wake_up(&osb->osb_mount_event); 696 697 mlog_exit(status); 698 return status; 699 700 read_super_error: 701 if (bh != NULL) 702 brelse(bh); 703 704 if (inode) 705 iput(inode); 706 707 if (osb) { 708 atomic_set(&osb->vol_state, VOLUME_DISABLED); 709 wake_up(&osb->osb_mount_event); 710 ocfs2_dismount_volume(sb, 1); 711 } 712 713 mlog_exit(status); 714 return status; 715 } 716 717 static int ocfs2_get_sb(struct file_system_type *fs_type, 718 int flags, 719 const char *dev_name, 720 void *data, 721 struct vfsmount *mnt) 722 { 723 return get_sb_bdev(fs_type, flags, dev_name, data, ocfs2_fill_super, 724 mnt); 725 } 726 727 static struct file_system_type ocfs2_fs_type = { 728 .owner = THIS_MODULE, 729 .name = "ocfs2", 730 .get_sb = ocfs2_get_sb, /* is this called when we mount 731 * the fs? */ 732 .kill_sb = kill_block_super, /* set to the generic one 733 * right now, but do we 734 * need to change that? */ 735 .fs_flags = FS_REQUIRES_DEV|FS_RENAME_DOES_D_MOVE, 736 .next = NULL 737 }; 738 739 static int ocfs2_parse_options(struct super_block *sb, 740 char *options, 741 struct mount_options *mopt, 742 int is_remount) 743 { 744 int status; 745 char *p; 746 747 mlog_entry("remount: %d, options: \"%s\"\n", is_remount, 748 options ? options : "(none)"); 749 750 mopt->mount_opt = 0; 751 mopt->atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM; 752 mopt->slot = OCFS2_INVALID_SLOT; 753 754 if (!options) { 755 status = 1; 756 goto bail; 757 } 758 759 while ((p = strsep(&options, ",")) != NULL) { 760 int token, option; 761 substring_t args[MAX_OPT_ARGS]; 762 763 if (!*p) 764 continue; 765 766 token = match_token(p, tokens, args); 767 switch (token) { 768 case Opt_hb_local: 769 mopt->mount_opt |= OCFS2_MOUNT_HB_LOCAL; 770 break; 771 case Opt_hb_none: 772 mopt->mount_opt &= ~OCFS2_MOUNT_HB_LOCAL; 773 break; 774 case Opt_barrier: 775 if (match_int(&args[0], &option)) { 776 status = 0; 777 goto bail; 778 } 779 if (option) 780 mopt->mount_opt |= OCFS2_MOUNT_BARRIER; 781 else 782 mopt->mount_opt &= ~OCFS2_MOUNT_BARRIER; 783 break; 784 case Opt_intr: 785 mopt->mount_opt &= ~OCFS2_MOUNT_NOINTR; 786 break; 787 case Opt_nointr: 788 mopt->mount_opt |= OCFS2_MOUNT_NOINTR; 789 break; 790 case Opt_err_panic: 791 mopt->mount_opt |= OCFS2_MOUNT_ERRORS_PANIC; 792 break; 793 case Opt_err_ro: 794 mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_PANIC; 795 break; 796 case Opt_data_ordered: 797 mopt->mount_opt &= ~OCFS2_MOUNT_DATA_WRITEBACK; 798 break; 799 case Opt_data_writeback: 800 mopt->mount_opt |= OCFS2_MOUNT_DATA_WRITEBACK; 801 break; 802 case Opt_atime_quantum: 803 if (match_int(&args[0], &option)) { 804 status = 0; 805 goto bail; 806 } 807 if (option >= 0) 808 mopt->atime_quantum = option; 809 break; 810 case Opt_slot: 811 option = 0; 812 if (match_int(&args[0], &option)) { 813 status = 0; 814 goto bail; 815 } 816 if (option) 817 mopt->slot = (s16)option; 818 break; 819 default: 820 mlog(ML_ERROR, 821 "Unrecognized mount option \"%s\" " 822 "or missing value\n", p); 823 status = 0; 824 goto bail; 825 } 826 } 827 828 status = 1; 829 830 bail: 831 mlog_exit(status); 832 return status; 833 } 834 835 static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt) 836 { 837 struct ocfs2_super *osb = OCFS2_SB(mnt->mnt_sb); 838 unsigned long opts = osb->s_mount_opt; 839 840 if (opts & OCFS2_MOUNT_HB_LOCAL) 841 seq_printf(s, ",_netdev,heartbeat=local"); 842 else 843 seq_printf(s, ",heartbeat=none"); 844 845 if (opts & OCFS2_MOUNT_NOINTR) 846 seq_printf(s, ",nointr"); 847 848 if (opts & OCFS2_MOUNT_DATA_WRITEBACK) 849 seq_printf(s, ",data=writeback"); 850 else 851 seq_printf(s, ",data=ordered"); 852 853 if (opts & OCFS2_MOUNT_BARRIER) 854 seq_printf(s, ",barrier=1"); 855 856 if (opts & OCFS2_MOUNT_ERRORS_PANIC) 857 seq_printf(s, ",errors=panic"); 858 else 859 seq_printf(s, ",errors=remount-ro"); 860 861 if (osb->preferred_slot != OCFS2_INVALID_SLOT) 862 seq_printf(s, ",preferred_slot=%d", osb->preferred_slot); 863 864 if (osb->s_atime_quantum != OCFS2_DEFAULT_ATIME_QUANTUM) 865 seq_printf(s, ",atime_quantum=%u", osb->s_atime_quantum); 866 867 return 0; 868 } 869 870 static int __init ocfs2_init(void) 871 { 872 int status; 873 874 mlog_entry_void(); 875 876 ocfs2_print_version(); 877 878 status = init_ocfs2_uptodate_cache(); 879 if (status < 0) { 880 mlog_errno(status); 881 goto leave; 882 } 883 884 status = ocfs2_initialize_mem_caches(); 885 if (status < 0) { 886 mlog_errno(status); 887 goto leave; 888 } 889 890 ocfs2_wq = create_singlethread_workqueue("ocfs2_wq"); 891 if (!ocfs2_wq) { 892 status = -ENOMEM; 893 goto leave; 894 } 895 896 ocfs2_debugfs_root = debugfs_create_dir("ocfs2", NULL); 897 if (!ocfs2_debugfs_root) { 898 status = -EFAULT; 899 mlog(ML_ERROR, "Unable to create ocfs2 debugfs root.\n"); 900 } 901 902 leave: 903 if (status < 0) { 904 ocfs2_free_mem_caches(); 905 exit_ocfs2_uptodate_cache(); 906 } 907 908 mlog_exit(status); 909 910 if (status >= 0) { 911 return register_filesystem(&ocfs2_fs_type); 912 } else 913 return -1; 914 } 915 916 static void __exit ocfs2_exit(void) 917 { 918 mlog_entry_void(); 919 920 if (ocfs2_wq) { 921 flush_workqueue(ocfs2_wq); 922 destroy_workqueue(ocfs2_wq); 923 } 924 925 debugfs_remove(ocfs2_debugfs_root); 926 927 ocfs2_free_mem_caches(); 928 929 unregister_filesystem(&ocfs2_fs_type); 930 931 exit_ocfs2_uptodate_cache(); 932 933 mlog_exit_void(); 934 } 935 936 static void ocfs2_put_super(struct super_block *sb) 937 { 938 mlog_entry("(0x%p)\n", sb); 939 940 ocfs2_sync_blockdev(sb); 941 ocfs2_dismount_volume(sb, 0); 942 943 mlog_exit_void(); 944 } 945 946 static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf) 947 { 948 struct ocfs2_super *osb; 949 u32 numbits, freebits; 950 int status; 951 struct ocfs2_dinode *bm_lock; 952 struct buffer_head *bh = NULL; 953 struct inode *inode = NULL; 954 955 mlog_entry("(%p, %p)\n", dentry->d_sb, buf); 956 957 osb = OCFS2_SB(dentry->d_sb); 958 959 inode = ocfs2_get_system_file_inode(osb, 960 GLOBAL_BITMAP_SYSTEM_INODE, 961 OCFS2_INVALID_SLOT); 962 if (!inode) { 963 mlog(ML_ERROR, "failed to get bitmap inode\n"); 964 status = -EIO; 965 goto bail; 966 } 967 968 status = ocfs2_meta_lock(inode, &bh, 0); 969 if (status < 0) { 970 mlog_errno(status); 971 goto bail; 972 } 973 974 bm_lock = (struct ocfs2_dinode *) bh->b_data; 975 976 numbits = le32_to_cpu(bm_lock->id1.bitmap1.i_total); 977 freebits = numbits - le32_to_cpu(bm_lock->id1.bitmap1.i_used); 978 979 buf->f_type = OCFS2_SUPER_MAGIC; 980 buf->f_bsize = dentry->d_sb->s_blocksize; 981 buf->f_namelen = OCFS2_MAX_FILENAME_LEN; 982 buf->f_blocks = ((sector_t) numbits) * 983 (osb->s_clustersize >> osb->sb->s_blocksize_bits); 984 buf->f_bfree = ((sector_t) freebits) * 985 (osb->s_clustersize >> osb->sb->s_blocksize_bits); 986 buf->f_bavail = buf->f_bfree; 987 buf->f_files = numbits; 988 buf->f_ffree = freebits; 989 990 brelse(bh); 991 992 ocfs2_meta_unlock(inode, 0); 993 status = 0; 994 bail: 995 if (inode) 996 iput(inode); 997 998 mlog_exit(status); 999 1000 return status; 1001 } 1002 1003 static void ocfs2_inode_init_once(void *data, 1004 struct kmem_cache *cachep, 1005 unsigned long flags) 1006 { 1007 struct ocfs2_inode_info *oi = data; 1008 1009 oi->ip_flags = 0; 1010 oi->ip_open_count = 0; 1011 spin_lock_init(&oi->ip_lock); 1012 ocfs2_extent_map_init(&oi->vfs_inode); 1013 INIT_LIST_HEAD(&oi->ip_io_markers); 1014 oi->ip_created_trans = 0; 1015 oi->ip_last_trans = 0; 1016 oi->ip_dir_start_lookup = 0; 1017 1018 init_rwsem(&oi->ip_alloc_sem); 1019 mutex_init(&oi->ip_io_mutex); 1020 1021 oi->ip_blkno = 0ULL; 1022 oi->ip_clusters = 0; 1023 1024 ocfs2_lock_res_init_once(&oi->ip_rw_lockres); 1025 ocfs2_lock_res_init_once(&oi->ip_meta_lockres); 1026 ocfs2_lock_res_init_once(&oi->ip_data_lockres); 1027 ocfs2_lock_res_init_once(&oi->ip_open_lockres); 1028 1029 ocfs2_metadata_cache_init(&oi->vfs_inode); 1030 1031 inode_init_once(&oi->vfs_inode); 1032 } 1033 1034 static int ocfs2_initialize_mem_caches(void) 1035 { 1036 ocfs2_inode_cachep = kmem_cache_create("ocfs2_inode_cache", 1037 sizeof(struct ocfs2_inode_info), 1038 0, 1039 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 1040 SLAB_MEM_SPREAD), 1041 ocfs2_inode_init_once); 1042 if (!ocfs2_inode_cachep) 1043 return -ENOMEM; 1044 1045 return 0; 1046 } 1047 1048 static void ocfs2_free_mem_caches(void) 1049 { 1050 if (ocfs2_inode_cachep) 1051 kmem_cache_destroy(ocfs2_inode_cachep); 1052 1053 ocfs2_inode_cachep = NULL; 1054 } 1055 1056 static int ocfs2_get_sector(struct super_block *sb, 1057 struct buffer_head **bh, 1058 int block, 1059 int sect_size) 1060 { 1061 if (!sb_set_blocksize(sb, sect_size)) { 1062 mlog(ML_ERROR, "unable to set blocksize\n"); 1063 return -EIO; 1064 } 1065 1066 *bh = sb_getblk(sb, block); 1067 if (!*bh) { 1068 mlog_errno(-EIO); 1069 return -EIO; 1070 } 1071 lock_buffer(*bh); 1072 if (!buffer_dirty(*bh)) 1073 clear_buffer_uptodate(*bh); 1074 unlock_buffer(*bh); 1075 ll_rw_block(READ, 1, bh); 1076 wait_on_buffer(*bh); 1077 return 0; 1078 } 1079 1080 /* ocfs2 1.0 only allows one cluster and node identity per kernel image. */ 1081 static int ocfs2_fill_local_node_info(struct ocfs2_super *osb) 1082 { 1083 int status; 1084 1085 /* XXX hold a ref on the node while mounte? easy enough, if 1086 * desirable. */ 1087 if (ocfs2_mount_local(osb)) 1088 osb->node_num = 0; 1089 else 1090 osb->node_num = o2nm_this_node(); 1091 1092 if (osb->node_num == O2NM_MAX_NODES) { 1093 mlog(ML_ERROR, "could not find this host's node number\n"); 1094 status = -ENOENT; 1095 goto bail; 1096 } 1097 1098 mlog(0, "I am node %d\n", osb->node_num); 1099 1100 status = 0; 1101 bail: 1102 return status; 1103 } 1104 1105 static int ocfs2_mount_volume(struct super_block *sb) 1106 { 1107 int status = 0; 1108 int unlock_super = 0; 1109 struct ocfs2_super *osb = OCFS2_SB(sb); 1110 1111 mlog_entry_void(); 1112 1113 if (ocfs2_is_hard_readonly(osb)) 1114 goto leave; 1115 1116 status = ocfs2_fill_local_node_info(osb); 1117 if (status < 0) { 1118 mlog_errno(status); 1119 goto leave; 1120 } 1121 1122 status = ocfs2_register_hb_callbacks(osb); 1123 if (status < 0) { 1124 mlog_errno(status); 1125 goto leave; 1126 } 1127 1128 status = ocfs2_dlm_init(osb); 1129 if (status < 0) { 1130 mlog_errno(status); 1131 goto leave; 1132 } 1133 1134 /* requires vote_thread to be running. */ 1135 status = ocfs2_register_net_handlers(osb); 1136 if (status < 0) { 1137 mlog_errno(status); 1138 goto leave; 1139 } 1140 1141 status = ocfs2_super_lock(osb, 1); 1142 if (status < 0) { 1143 mlog_errno(status); 1144 goto leave; 1145 } 1146 unlock_super = 1; 1147 1148 /* This will load up the node map and add ourselves to it. */ 1149 status = ocfs2_find_slot(osb); 1150 if (status < 0) { 1151 mlog_errno(status); 1152 goto leave; 1153 } 1154 1155 ocfs2_populate_mounted_map(osb); 1156 1157 /* load all node-local system inodes */ 1158 status = ocfs2_init_local_system_inodes(osb); 1159 if (status < 0) { 1160 mlog_errno(status); 1161 goto leave; 1162 } 1163 1164 status = ocfs2_check_volume(osb); 1165 if (status < 0) { 1166 mlog_errno(status); 1167 goto leave; 1168 } 1169 1170 status = ocfs2_truncate_log_init(osb); 1171 if (status < 0) { 1172 mlog_errno(status); 1173 goto leave; 1174 } 1175 1176 if (ocfs2_mount_local(osb)) 1177 goto leave; 1178 1179 /* This should be sent *after* we recovered our journal as it 1180 * will cause other nodes to unmark us as needing 1181 * recovery. However, we need to send it *before* dropping the 1182 * super block lock as otherwise their recovery threads might 1183 * try to clean us up while we're live! */ 1184 status = ocfs2_request_mount_vote(osb); 1185 if (status < 0) 1186 mlog_errno(status); 1187 1188 leave: 1189 if (unlock_super) 1190 ocfs2_super_unlock(osb, 1); 1191 1192 mlog_exit(status); 1193 return status; 1194 } 1195 1196 /* we can't grab the goofy sem lock from inside wait_event, so we use 1197 * memory barriers to make sure that we'll see the null task before 1198 * being woken up */ 1199 static int ocfs2_recovery_thread_running(struct ocfs2_super *osb) 1200 { 1201 mb(); 1202 return osb->recovery_thread_task != NULL; 1203 } 1204 1205 static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err) 1206 { 1207 int tmp; 1208 struct ocfs2_super *osb = NULL; 1209 char nodestr[8]; 1210 1211 mlog_entry("(0x%p)\n", sb); 1212 1213 BUG_ON(!sb); 1214 osb = OCFS2_SB(sb); 1215 BUG_ON(!osb); 1216 1217 ocfs2_shutdown_local_alloc(osb); 1218 1219 ocfs2_truncate_log_shutdown(osb); 1220 1221 /* disable any new recovery threads and wait for any currently 1222 * running ones to exit. Do this before setting the vol_state. */ 1223 mutex_lock(&osb->recovery_lock); 1224 osb->disable_recovery = 1; 1225 mutex_unlock(&osb->recovery_lock); 1226 wait_event(osb->recovery_event, !ocfs2_recovery_thread_running(osb)); 1227 1228 /* At this point, we know that no more recovery threads can be 1229 * launched, so wait for any recovery completion work to 1230 * complete. */ 1231 flush_workqueue(ocfs2_wq); 1232 1233 ocfs2_journal_shutdown(osb); 1234 1235 ocfs2_sync_blockdev(sb); 1236 1237 /* No dlm means we've failed during mount, so skip all the 1238 * steps which depended on that to complete. */ 1239 if (osb->dlm) { 1240 tmp = ocfs2_super_lock(osb, 1); 1241 if (tmp < 0) { 1242 mlog_errno(tmp); 1243 return; 1244 } 1245 1246 tmp = ocfs2_request_umount_vote(osb); 1247 if (tmp < 0) 1248 mlog_errno(tmp); 1249 } 1250 1251 if (osb->slot_num != OCFS2_INVALID_SLOT) 1252 ocfs2_put_slot(osb); 1253 1254 if (osb->dlm) 1255 ocfs2_super_unlock(osb, 1); 1256 1257 ocfs2_release_system_inodes(osb); 1258 1259 if (osb->dlm) { 1260 ocfs2_unregister_net_handlers(osb); 1261 1262 ocfs2_dlm_shutdown(osb); 1263 } 1264 1265 ocfs2_clear_hb_callbacks(osb); 1266 1267 debugfs_remove(osb->osb_debug_root); 1268 1269 if (!mnt_err) 1270 ocfs2_stop_heartbeat(osb); 1271 1272 atomic_set(&osb->vol_state, VOLUME_DISMOUNTED); 1273 1274 if (ocfs2_mount_local(osb)) 1275 snprintf(nodestr, sizeof(nodestr), "local"); 1276 else 1277 snprintf(nodestr, sizeof(nodestr), "%d", osb->node_num); 1278 1279 printk(KERN_INFO "ocfs2: Unmounting device (%s) on (node %s)\n", 1280 osb->dev_str, nodestr); 1281 1282 ocfs2_delete_osb(osb); 1283 kfree(osb); 1284 sb->s_dev = 0; 1285 sb->s_fs_info = NULL; 1286 } 1287 1288 static int ocfs2_setup_osb_uuid(struct ocfs2_super *osb, const unsigned char *uuid, 1289 unsigned uuid_bytes) 1290 { 1291 int i, ret; 1292 char *ptr; 1293 1294 BUG_ON(uuid_bytes != OCFS2_VOL_UUID_LEN); 1295 1296 osb->uuid_str = kzalloc(OCFS2_VOL_UUID_LEN * 2 + 1, GFP_KERNEL); 1297 if (osb->uuid_str == NULL) 1298 return -ENOMEM; 1299 1300 for (i = 0, ptr = osb->uuid_str; i < OCFS2_VOL_UUID_LEN; i++) { 1301 /* print with null */ 1302 ret = snprintf(ptr, 3, "%02X", uuid[i]); 1303 if (ret != 2) /* drop super cleans up */ 1304 return -EINVAL; 1305 /* then only advance past the last char */ 1306 ptr += 2; 1307 } 1308 1309 return 0; 1310 } 1311 1312 static int ocfs2_initialize_super(struct super_block *sb, 1313 struct buffer_head *bh, 1314 int sector_size) 1315 { 1316 int status; 1317 int i, cbits, bbits; 1318 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data; 1319 struct inode *inode = NULL; 1320 struct buffer_head *bitmap_bh = NULL; 1321 struct ocfs2_journal *journal; 1322 __le32 uuid_net_key; 1323 struct ocfs2_super *osb; 1324 1325 mlog_entry_void(); 1326 1327 osb = kzalloc(sizeof(struct ocfs2_super), GFP_KERNEL); 1328 if (!osb) { 1329 status = -ENOMEM; 1330 mlog_errno(status); 1331 goto bail; 1332 } 1333 1334 sb->s_fs_info = osb; 1335 sb->s_op = &ocfs2_sops; 1336 sb->s_export_op = &ocfs2_export_ops; 1337 sb->s_time_gran = 1; 1338 sb->s_flags |= MS_NOATIME; 1339 /* this is needed to support O_LARGEFILE */ 1340 cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits); 1341 bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits); 1342 sb->s_maxbytes = ocfs2_max_file_offset(bbits, cbits); 1343 1344 osb->sb = sb; 1345 /* Save off for ocfs2_rw_direct */ 1346 osb->s_sectsize_bits = blksize_bits(sector_size); 1347 BUG_ON(!osb->s_sectsize_bits); 1348 1349 osb->net_response_ids = 0; 1350 spin_lock_init(&osb->net_response_lock); 1351 INIT_LIST_HEAD(&osb->net_response_list); 1352 1353 INIT_LIST_HEAD(&osb->osb_net_handlers); 1354 init_waitqueue_head(&osb->recovery_event); 1355 spin_lock_init(&osb->vote_task_lock); 1356 init_waitqueue_head(&osb->vote_event); 1357 osb->vote_work_sequence = 0; 1358 osb->vote_wake_sequence = 0; 1359 INIT_LIST_HEAD(&osb->blocked_lock_list); 1360 osb->blocked_lock_count = 0; 1361 INIT_LIST_HEAD(&osb->vote_list); 1362 spin_lock_init(&osb->osb_lock); 1363 1364 atomic_set(&osb->alloc_stats.moves, 0); 1365 atomic_set(&osb->alloc_stats.local_data, 0); 1366 atomic_set(&osb->alloc_stats.bitmap_data, 0); 1367 atomic_set(&osb->alloc_stats.bg_allocs, 0); 1368 atomic_set(&osb->alloc_stats.bg_extends, 0); 1369 1370 ocfs2_init_node_maps(osb); 1371 1372 snprintf(osb->dev_str, sizeof(osb->dev_str), "%u,%u", 1373 MAJOR(osb->sb->s_dev), MINOR(osb->sb->s_dev)); 1374 1375 mutex_init(&osb->recovery_lock); 1376 1377 osb->disable_recovery = 0; 1378 osb->recovery_thread_task = NULL; 1379 1380 init_waitqueue_head(&osb->checkpoint_event); 1381 atomic_set(&osb->needs_checkpoint, 0); 1382 1383 osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM; 1384 1385 osb->node_num = O2NM_INVALID_NODE_NUM; 1386 osb->slot_num = OCFS2_INVALID_SLOT; 1387 1388 osb->local_alloc_state = OCFS2_LA_UNUSED; 1389 osb->local_alloc_bh = NULL; 1390 1391 ocfs2_setup_hb_callbacks(osb); 1392 1393 init_waitqueue_head(&osb->osb_mount_event); 1394 1395 osb->vol_label = kmalloc(OCFS2_MAX_VOL_LABEL_LEN, GFP_KERNEL); 1396 if (!osb->vol_label) { 1397 mlog(ML_ERROR, "unable to alloc vol label\n"); 1398 status = -ENOMEM; 1399 goto bail; 1400 } 1401 1402 osb->max_slots = le16_to_cpu(di->id2.i_super.s_max_slots); 1403 if (osb->max_slots > OCFS2_MAX_SLOTS || osb->max_slots == 0) { 1404 mlog(ML_ERROR, "Invalid number of node slots (%u)\n", 1405 osb->max_slots); 1406 status = -EINVAL; 1407 goto bail; 1408 } 1409 mlog(0, "max_slots for this device: %u\n", osb->max_slots); 1410 1411 init_waitqueue_head(&osb->osb_wipe_event); 1412 osb->osb_orphan_wipes = kcalloc(osb->max_slots, 1413 sizeof(*osb->osb_orphan_wipes), 1414 GFP_KERNEL); 1415 if (!osb->osb_orphan_wipes) { 1416 status = -ENOMEM; 1417 mlog_errno(status); 1418 goto bail; 1419 } 1420 1421 osb->s_feature_compat = 1422 le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_compat); 1423 osb->s_feature_ro_compat = 1424 le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_ro_compat); 1425 osb->s_feature_incompat = 1426 le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_incompat); 1427 1428 if ((i = OCFS2_HAS_INCOMPAT_FEATURE(osb->sb, ~OCFS2_FEATURE_INCOMPAT_SUPP))) { 1429 mlog(ML_ERROR, "couldn't mount because of unsupported " 1430 "optional features (%x).\n", i); 1431 status = -EINVAL; 1432 goto bail; 1433 } 1434 if (!(osb->sb->s_flags & MS_RDONLY) && 1435 (i = OCFS2_HAS_RO_COMPAT_FEATURE(osb->sb, ~OCFS2_FEATURE_RO_COMPAT_SUPP))) { 1436 mlog(ML_ERROR, "couldn't mount RDWR because of " 1437 "unsupported optional features (%x).\n", i); 1438 status = -EINVAL; 1439 goto bail; 1440 } 1441 1442 get_random_bytes(&osb->s_next_generation, sizeof(u32)); 1443 1444 /* FIXME 1445 * This should be done in ocfs2_journal_init(), but unknown 1446 * ordering issues will cause the filesystem to crash. 1447 * If anyone wants to figure out what part of the code 1448 * refers to osb->journal before ocfs2_journal_init() is run, 1449 * be my guest. 1450 */ 1451 /* initialize our journal structure */ 1452 1453 journal = kzalloc(sizeof(struct ocfs2_journal), GFP_KERNEL); 1454 if (!journal) { 1455 mlog(ML_ERROR, "unable to alloc journal\n"); 1456 status = -ENOMEM; 1457 goto bail; 1458 } 1459 osb->journal = journal; 1460 journal->j_osb = osb; 1461 1462 atomic_set(&journal->j_num_trans, 0); 1463 init_rwsem(&journal->j_trans_barrier); 1464 init_waitqueue_head(&journal->j_checkpointed); 1465 spin_lock_init(&journal->j_lock); 1466 journal->j_trans_id = (unsigned long) 1; 1467 INIT_LIST_HEAD(&journal->j_la_cleanups); 1468 INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery); 1469 journal->j_state = OCFS2_JOURNAL_FREE; 1470 1471 /* get some pseudo constants for clustersize bits */ 1472 osb->s_clustersize_bits = 1473 le32_to_cpu(di->id2.i_super.s_clustersize_bits); 1474 osb->s_clustersize = 1 << osb->s_clustersize_bits; 1475 mlog(0, "clusterbits=%d\n", osb->s_clustersize_bits); 1476 1477 if (osb->s_clustersize < OCFS2_MIN_CLUSTERSIZE || 1478 osb->s_clustersize > OCFS2_MAX_CLUSTERSIZE) { 1479 mlog(ML_ERROR, "Volume has invalid cluster size (%d)\n", 1480 osb->s_clustersize); 1481 status = -EINVAL; 1482 goto bail; 1483 } 1484 1485 if (ocfs2_clusters_to_blocks(osb->sb, le32_to_cpu(di->i_clusters) - 1) 1486 > (u32)~0UL) { 1487 mlog(ML_ERROR, "Volume might try to write to blocks beyond " 1488 "what jbd can address in 32 bits.\n"); 1489 status = -EINVAL; 1490 goto bail; 1491 } 1492 1493 if (ocfs2_setup_osb_uuid(osb, di->id2.i_super.s_uuid, 1494 sizeof(di->id2.i_super.s_uuid))) { 1495 mlog(ML_ERROR, "Out of memory trying to setup our uuid.\n"); 1496 status = -ENOMEM; 1497 goto bail; 1498 } 1499 1500 memcpy(&uuid_net_key, di->id2.i_super.s_uuid, sizeof(uuid_net_key)); 1501 osb->net_key = le32_to_cpu(uuid_net_key); 1502 1503 strncpy(osb->vol_label, di->id2.i_super.s_label, 63); 1504 osb->vol_label[63] = '\0'; 1505 osb->root_blkno = le64_to_cpu(di->id2.i_super.s_root_blkno); 1506 osb->system_dir_blkno = le64_to_cpu(di->id2.i_super.s_system_dir_blkno); 1507 osb->first_cluster_group_blkno = 1508 le64_to_cpu(di->id2.i_super.s_first_cluster_group); 1509 osb->fs_generation = le32_to_cpu(di->i_fs_generation); 1510 mlog(0, "vol_label: %s\n", osb->vol_label); 1511 mlog(0, "uuid: %s\n", osb->uuid_str); 1512 mlog(0, "root_blkno=%llu, system_dir_blkno=%llu\n", 1513 (unsigned long long)osb->root_blkno, 1514 (unsigned long long)osb->system_dir_blkno); 1515 1516 osb->osb_dlm_debug = ocfs2_new_dlm_debug(); 1517 if (!osb->osb_dlm_debug) { 1518 status = -ENOMEM; 1519 mlog_errno(status); 1520 goto bail; 1521 } 1522 1523 atomic_set(&osb->vol_state, VOLUME_INIT); 1524 1525 /* load root, system_dir, and all global system inodes */ 1526 status = ocfs2_init_global_system_inodes(osb); 1527 if (status < 0) { 1528 mlog_errno(status); 1529 goto bail; 1530 } 1531 1532 /* 1533 * global bitmap 1534 */ 1535 inode = ocfs2_get_system_file_inode(osb, GLOBAL_BITMAP_SYSTEM_INODE, 1536 OCFS2_INVALID_SLOT); 1537 if (!inode) { 1538 status = -EINVAL; 1539 mlog_errno(status); 1540 goto bail; 1541 } 1542 1543 osb->bitmap_blkno = OCFS2_I(inode)->ip_blkno; 1544 1545 /* We don't have a cluster lock on the bitmap here because 1546 * we're only interested in static information and the extra 1547 * complexity at mount time isn't worht it. Don't pass the 1548 * inode in to the read function though as we don't want it to 1549 * be put in the cache. */ 1550 status = ocfs2_read_block(osb, osb->bitmap_blkno, &bitmap_bh, 0, 1551 NULL); 1552 iput(inode); 1553 if (status < 0) { 1554 mlog_errno(status); 1555 goto bail; 1556 } 1557 1558 di = (struct ocfs2_dinode *) bitmap_bh->b_data; 1559 osb->bitmap_cpg = le16_to_cpu(di->id2.i_chain.cl_cpg); 1560 brelse(bitmap_bh); 1561 mlog(0, "cluster bitmap inode: %llu, clusters per group: %u\n", 1562 (unsigned long long)osb->bitmap_blkno, osb->bitmap_cpg); 1563 1564 status = ocfs2_init_slot_info(osb); 1565 if (status < 0) { 1566 mlog_errno(status); 1567 goto bail; 1568 } 1569 1570 bail: 1571 mlog_exit(status); 1572 return status; 1573 } 1574 1575 /* 1576 * will return: -EAGAIN if it is ok to keep searching for superblocks 1577 * -EINVAL if there is a bad superblock 1578 * 0 on success 1579 */ 1580 static int ocfs2_verify_volume(struct ocfs2_dinode *di, 1581 struct buffer_head *bh, 1582 u32 blksz) 1583 { 1584 int status = -EAGAIN; 1585 1586 mlog_entry_void(); 1587 1588 if (memcmp(di->i_signature, OCFS2_SUPER_BLOCK_SIGNATURE, 1589 strlen(OCFS2_SUPER_BLOCK_SIGNATURE)) == 0) { 1590 status = -EINVAL; 1591 if ((1 << le32_to_cpu(di->id2.i_super.s_blocksize_bits)) != blksz) { 1592 mlog(ML_ERROR, "found superblock with incorrect block " 1593 "size: found %u, should be %u\n", 1594 1 << le32_to_cpu(di->id2.i_super.s_blocksize_bits), 1595 blksz); 1596 } else if (le16_to_cpu(di->id2.i_super.s_major_rev_level) != 1597 OCFS2_MAJOR_REV_LEVEL || 1598 le16_to_cpu(di->id2.i_super.s_minor_rev_level) != 1599 OCFS2_MINOR_REV_LEVEL) { 1600 mlog(ML_ERROR, "found superblock with bad version: " 1601 "found %u.%u, should be %u.%u\n", 1602 le16_to_cpu(di->id2.i_super.s_major_rev_level), 1603 le16_to_cpu(di->id2.i_super.s_minor_rev_level), 1604 OCFS2_MAJOR_REV_LEVEL, 1605 OCFS2_MINOR_REV_LEVEL); 1606 } else if (bh->b_blocknr != le64_to_cpu(di->i_blkno)) { 1607 mlog(ML_ERROR, "bad block number on superblock: " 1608 "found %llu, should be %llu\n", 1609 (unsigned long long)le64_to_cpu(di->i_blkno), 1610 (unsigned long long)bh->b_blocknr); 1611 } else if (le32_to_cpu(di->id2.i_super.s_clustersize_bits) < 12 || 1612 le32_to_cpu(di->id2.i_super.s_clustersize_bits) > 20) { 1613 mlog(ML_ERROR, "bad cluster size found: %u\n", 1614 1 << le32_to_cpu(di->id2.i_super.s_clustersize_bits)); 1615 } else if (!le64_to_cpu(di->id2.i_super.s_root_blkno)) { 1616 mlog(ML_ERROR, "bad root_blkno: 0\n"); 1617 } else if (!le64_to_cpu(di->id2.i_super.s_system_dir_blkno)) { 1618 mlog(ML_ERROR, "bad system_dir_blkno: 0\n"); 1619 } else if (le16_to_cpu(di->id2.i_super.s_max_slots) > OCFS2_MAX_SLOTS) { 1620 mlog(ML_ERROR, 1621 "Superblock slots found greater than file system " 1622 "maximum: found %u, max %u\n", 1623 le16_to_cpu(di->id2.i_super.s_max_slots), 1624 OCFS2_MAX_SLOTS); 1625 } else { 1626 /* found it! */ 1627 status = 0; 1628 } 1629 } 1630 1631 mlog_exit(status); 1632 return status; 1633 } 1634 1635 static int ocfs2_check_volume(struct ocfs2_super *osb) 1636 { 1637 int status; 1638 int dirty; 1639 int local; 1640 struct ocfs2_dinode *local_alloc = NULL; /* only used if we 1641 * recover 1642 * ourselves. */ 1643 1644 mlog_entry_void(); 1645 1646 /* Init our journal object. */ 1647 status = ocfs2_journal_init(osb->journal, &dirty); 1648 if (status < 0) { 1649 mlog(ML_ERROR, "Could not initialize journal!\n"); 1650 goto finally; 1651 } 1652 1653 /* If the journal was unmounted cleanly then we don't want to 1654 * recover anything. Otherwise, journal_load will do that 1655 * dirty work for us :) */ 1656 if (!dirty) { 1657 status = ocfs2_journal_wipe(osb->journal, 0); 1658 if (status < 0) { 1659 mlog_errno(status); 1660 goto finally; 1661 } 1662 } else { 1663 mlog(ML_NOTICE, "File system was not unmounted cleanly, " 1664 "recovering volume.\n"); 1665 } 1666 1667 local = ocfs2_mount_local(osb); 1668 1669 /* will play back anything left in the journal. */ 1670 ocfs2_journal_load(osb->journal, local); 1671 1672 if (dirty) { 1673 /* recover my local alloc if we didn't unmount cleanly. */ 1674 status = ocfs2_begin_local_alloc_recovery(osb, 1675 osb->slot_num, 1676 &local_alloc); 1677 if (status < 0) { 1678 mlog_errno(status); 1679 goto finally; 1680 } 1681 /* we complete the recovery process after we've marked 1682 * ourselves as mounted. */ 1683 } 1684 1685 mlog(0, "Journal loaded.\n"); 1686 1687 status = ocfs2_load_local_alloc(osb); 1688 if (status < 0) { 1689 mlog_errno(status); 1690 goto finally; 1691 } 1692 1693 if (dirty) { 1694 /* Recovery will be completed after we've mounted the 1695 * rest of the volume. */ 1696 osb->dirty = 1; 1697 osb->local_alloc_copy = local_alloc; 1698 local_alloc = NULL; 1699 } 1700 1701 /* go through each journal, trylock it and if you get the 1702 * lock, and it's marked as dirty, set the bit in the recover 1703 * map and launch a recovery thread for it. */ 1704 status = ocfs2_mark_dead_nodes(osb); 1705 if (status < 0) 1706 mlog_errno(status); 1707 1708 finally: 1709 if (local_alloc) 1710 kfree(local_alloc); 1711 1712 mlog_exit(status); 1713 return status; 1714 } 1715 1716 /* 1717 * The routine gets called from dismount or close whenever a dismount on 1718 * volume is requested and the osb open count becomes 1. 1719 * It will remove the osb from the global list and also free up all the 1720 * initialized resources and fileobject. 1721 */ 1722 static void ocfs2_delete_osb(struct ocfs2_super *osb) 1723 { 1724 mlog_entry_void(); 1725 1726 /* This function assumes that the caller has the main osb resource */ 1727 1728 if (osb->slot_info) 1729 ocfs2_free_slot_info(osb->slot_info); 1730 1731 kfree(osb->osb_orphan_wipes); 1732 /* FIXME 1733 * This belongs in journal shutdown, but because we have to 1734 * allocate osb->journal at the start of ocfs2_initalize_osb(), 1735 * we free it here. 1736 */ 1737 kfree(osb->journal); 1738 if (osb->local_alloc_copy) 1739 kfree(osb->local_alloc_copy); 1740 kfree(osb->uuid_str); 1741 ocfs2_put_dlm_debug(osb->osb_dlm_debug); 1742 memset(osb, 0, sizeof(struct ocfs2_super)); 1743 1744 mlog_exit_void(); 1745 } 1746 1747 /* Put OCFS2 into a readonly state, or (if the user specifies it), 1748 * panic(). We do not support continue-on-error operation. */ 1749 static void ocfs2_handle_error(struct super_block *sb) 1750 { 1751 struct ocfs2_super *osb = OCFS2_SB(sb); 1752 1753 if (osb->s_mount_opt & OCFS2_MOUNT_ERRORS_PANIC) 1754 panic("OCFS2: (device %s): panic forced after error\n", 1755 sb->s_id); 1756 1757 ocfs2_set_osb_flag(osb, OCFS2_OSB_ERROR_FS); 1758 1759 if (sb->s_flags & MS_RDONLY && 1760 (ocfs2_is_soft_readonly(osb) || 1761 ocfs2_is_hard_readonly(osb))) 1762 return; 1763 1764 printk(KERN_CRIT "File system is now read-only due to the potential " 1765 "of on-disk corruption. Please run fsck.ocfs2 once the file " 1766 "system is unmounted.\n"); 1767 sb->s_flags |= MS_RDONLY; 1768 ocfs2_set_ro_flag(osb, 0); 1769 } 1770 1771 static char error_buf[1024]; 1772 1773 void __ocfs2_error(struct super_block *sb, 1774 const char *function, 1775 const char *fmt, ...) 1776 { 1777 va_list args; 1778 1779 va_start(args, fmt); 1780 vsnprintf(error_buf, sizeof(error_buf), fmt, args); 1781 va_end(args); 1782 1783 /* Not using mlog here because we want to show the actual 1784 * function the error came from. */ 1785 printk(KERN_CRIT "OCFS2: ERROR (device %s): %s: %s\n", 1786 sb->s_id, function, error_buf); 1787 1788 ocfs2_handle_error(sb); 1789 } 1790 1791 /* Handle critical errors. This is intentionally more drastic than 1792 * ocfs2_handle_error, so we only use for things like journal errors, 1793 * etc. */ 1794 void __ocfs2_abort(struct super_block* sb, 1795 const char *function, 1796 const char *fmt, ...) 1797 { 1798 va_list args; 1799 1800 va_start(args, fmt); 1801 vsnprintf(error_buf, sizeof(error_buf), fmt, args); 1802 va_end(args); 1803 1804 printk(KERN_CRIT "OCFS2: abort (device %s): %s: %s\n", 1805 sb->s_id, function, error_buf); 1806 1807 /* We don't have the cluster support yet to go straight to 1808 * hard readonly in here. Until then, we want to keep 1809 * ocfs2_abort() so that we can at least mark critical 1810 * errors. 1811 * 1812 * TODO: This should abort the journal and alert other nodes 1813 * that our slot needs recovery. */ 1814 1815 /* Force a panic(). This stinks, but it's better than letting 1816 * things continue without having a proper hard readonly 1817 * here. */ 1818 OCFS2_SB(sb)->s_mount_opt |= OCFS2_MOUNT_ERRORS_PANIC; 1819 ocfs2_handle_error(sb); 1820 } 1821 1822 module_init(ocfs2_init); 1823 module_exit(ocfs2_exit); 1824