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/init.h> 32 #include <linux/random.h> 33 #include <linux/statfs.h> 34 #include <linux/moduleparam.h> 35 #include <linux/blkdev.h> 36 #include <linux/socket.h> 37 #include <linux/inet.h> 38 #include <linux/parser.h> 39 #include <linux/crc32.h> 40 #include <linux/debugfs.h> 41 #include <linux/mount.h> 42 #include <linux/seq_file.h> 43 #include <linux/quotaops.h> 44 #include <linux/smp_lock.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 "blockcheck.h" 56 #include "dlmglue.h" 57 #include "export.h" 58 #include "extent_map.h" 59 #include "heartbeat.h" 60 #include "inode.h" 61 #include "journal.h" 62 #include "localalloc.h" 63 #include "namei.h" 64 #include "slot_map.h" 65 #include "super.h" 66 #include "sysfile.h" 67 #include "uptodate.h" 68 #include "ver.h" 69 #include "xattr.h" 70 #include "quota.h" 71 #include "refcounttree.h" 72 73 #include "buffer_head_io.h" 74 75 static struct kmem_cache *ocfs2_inode_cachep = NULL; 76 struct kmem_cache *ocfs2_dquot_cachep; 77 struct kmem_cache *ocfs2_qf_chunk_cachep; 78 79 /* OCFS2 needs to schedule several differnt types of work which 80 * require cluster locking, disk I/O, recovery waits, etc. Since these 81 * types of work tend to be heavy we avoid using the kernel events 82 * workqueue and schedule on our own. */ 83 struct workqueue_struct *ocfs2_wq = NULL; 84 85 static struct dentry *ocfs2_debugfs_root = NULL; 86 87 MODULE_AUTHOR("Oracle"); 88 MODULE_LICENSE("GPL"); 89 90 struct mount_options 91 { 92 unsigned long commit_interval; 93 unsigned long mount_opt; 94 unsigned int atime_quantum; 95 signed short slot; 96 unsigned int localalloc_opt; 97 char cluster_stack[OCFS2_STACK_LABEL_LEN + 1]; 98 }; 99 100 static int ocfs2_parse_options(struct super_block *sb, char *options, 101 struct mount_options *mopt, 102 int is_remount); 103 static int ocfs2_check_set_options(struct super_block *sb, 104 struct mount_options *options); 105 static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt); 106 static void ocfs2_put_super(struct super_block *sb); 107 static int ocfs2_mount_volume(struct super_block *sb); 108 static int ocfs2_remount(struct super_block *sb, int *flags, char *data); 109 static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err); 110 static int ocfs2_initialize_mem_caches(void); 111 static void ocfs2_free_mem_caches(void); 112 static void ocfs2_delete_osb(struct ocfs2_super *osb); 113 114 static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf); 115 116 static int ocfs2_sync_fs(struct super_block *sb, int wait); 117 118 static int ocfs2_init_global_system_inodes(struct ocfs2_super *osb); 119 static int ocfs2_init_local_system_inodes(struct ocfs2_super *osb); 120 static void ocfs2_release_system_inodes(struct ocfs2_super *osb); 121 static int ocfs2_check_volume(struct ocfs2_super *osb); 122 static int ocfs2_verify_volume(struct ocfs2_dinode *di, 123 struct buffer_head *bh, 124 u32 sectsize, 125 struct ocfs2_blockcheck_stats *stats); 126 static int ocfs2_initialize_super(struct super_block *sb, 127 struct buffer_head *bh, 128 int sector_size, 129 struct ocfs2_blockcheck_stats *stats); 130 static int ocfs2_get_sector(struct super_block *sb, 131 struct buffer_head **bh, 132 int block, 133 int sect_size); 134 static struct inode *ocfs2_alloc_inode(struct super_block *sb); 135 static void ocfs2_destroy_inode(struct inode *inode); 136 static int ocfs2_susp_quotas(struct ocfs2_super *osb, int unsuspend); 137 static int ocfs2_enable_quotas(struct ocfs2_super *osb); 138 static void ocfs2_disable_quotas(struct ocfs2_super *osb); 139 140 static const struct super_operations ocfs2_sops = { 141 .statfs = ocfs2_statfs, 142 .alloc_inode = ocfs2_alloc_inode, 143 .destroy_inode = ocfs2_destroy_inode, 144 .drop_inode = ocfs2_drop_inode, 145 .clear_inode = ocfs2_clear_inode, 146 .delete_inode = ocfs2_delete_inode, 147 .sync_fs = ocfs2_sync_fs, 148 .put_super = ocfs2_put_super, 149 .remount_fs = ocfs2_remount, 150 .show_options = ocfs2_show_options, 151 .quota_read = ocfs2_quota_read, 152 .quota_write = ocfs2_quota_write, 153 }; 154 155 enum { 156 Opt_barrier, 157 Opt_err_panic, 158 Opt_err_ro, 159 Opt_intr, 160 Opt_nointr, 161 Opt_hb_none, 162 Opt_hb_local, 163 Opt_data_ordered, 164 Opt_data_writeback, 165 Opt_atime_quantum, 166 Opt_slot, 167 Opt_commit, 168 Opt_localalloc, 169 Opt_localflocks, 170 Opt_stack, 171 Opt_user_xattr, 172 Opt_nouser_xattr, 173 Opt_inode64, 174 Opt_acl, 175 Opt_noacl, 176 Opt_usrquota, 177 Opt_grpquota, 178 Opt_err, 179 }; 180 181 static const match_table_t tokens = { 182 {Opt_barrier, "barrier=%u"}, 183 {Opt_err_panic, "errors=panic"}, 184 {Opt_err_ro, "errors=remount-ro"}, 185 {Opt_intr, "intr"}, 186 {Opt_nointr, "nointr"}, 187 {Opt_hb_none, OCFS2_HB_NONE}, 188 {Opt_hb_local, OCFS2_HB_LOCAL}, 189 {Opt_data_ordered, "data=ordered"}, 190 {Opt_data_writeback, "data=writeback"}, 191 {Opt_atime_quantum, "atime_quantum=%u"}, 192 {Opt_slot, "preferred_slot=%u"}, 193 {Opt_commit, "commit=%u"}, 194 {Opt_localalloc, "localalloc=%d"}, 195 {Opt_localflocks, "localflocks"}, 196 {Opt_stack, "cluster_stack=%s"}, 197 {Opt_user_xattr, "user_xattr"}, 198 {Opt_nouser_xattr, "nouser_xattr"}, 199 {Opt_inode64, "inode64"}, 200 {Opt_acl, "acl"}, 201 {Opt_noacl, "noacl"}, 202 {Opt_usrquota, "usrquota"}, 203 {Opt_grpquota, "grpquota"}, 204 {Opt_err, NULL} 205 }; 206 207 #ifdef CONFIG_DEBUG_FS 208 static int ocfs2_osb_dump(struct ocfs2_super *osb, char *buf, int len) 209 { 210 struct ocfs2_cluster_connection *cconn = osb->cconn; 211 struct ocfs2_recovery_map *rm = osb->recovery_map; 212 struct ocfs2_orphan_scan *os = &osb->osb_orphan_scan; 213 int i, out = 0; 214 215 out += snprintf(buf + out, len - out, 216 "%10s => Id: %-s Uuid: %-s Gen: 0x%X Label: %-s\n", 217 "Device", osb->dev_str, osb->uuid_str, 218 osb->fs_generation, osb->vol_label); 219 220 out += snprintf(buf + out, len - out, 221 "%10s => State: %d Flags: 0x%lX\n", "Volume", 222 atomic_read(&osb->vol_state), osb->osb_flags); 223 224 out += snprintf(buf + out, len - out, 225 "%10s => Block: %lu Cluster: %d\n", "Sizes", 226 osb->sb->s_blocksize, osb->s_clustersize); 227 228 out += snprintf(buf + out, len - out, 229 "%10s => Compat: 0x%X Incompat: 0x%X " 230 "ROcompat: 0x%X\n", 231 "Features", osb->s_feature_compat, 232 osb->s_feature_incompat, osb->s_feature_ro_compat); 233 234 out += snprintf(buf + out, len - out, 235 "%10s => Opts: 0x%lX AtimeQuanta: %u\n", "Mount", 236 osb->s_mount_opt, osb->s_atime_quantum); 237 238 if (cconn) { 239 out += snprintf(buf + out, len - out, 240 "%10s => Stack: %s Name: %*s " 241 "Version: %d.%d\n", "Cluster", 242 (*osb->osb_cluster_stack == '\0' ? 243 "o2cb" : osb->osb_cluster_stack), 244 cconn->cc_namelen, cconn->cc_name, 245 cconn->cc_version.pv_major, 246 cconn->cc_version.pv_minor); 247 } 248 249 spin_lock(&osb->dc_task_lock); 250 out += snprintf(buf + out, len - out, 251 "%10s => Pid: %d Count: %lu WakeSeq: %lu " 252 "WorkSeq: %lu\n", "DownCnvt", 253 (osb->dc_task ? task_pid_nr(osb->dc_task) : -1), 254 osb->blocked_lock_count, osb->dc_wake_sequence, 255 osb->dc_work_sequence); 256 spin_unlock(&osb->dc_task_lock); 257 258 spin_lock(&osb->osb_lock); 259 out += snprintf(buf + out, len - out, "%10s => Pid: %d Nodes:", 260 "Recovery", 261 (osb->recovery_thread_task ? 262 task_pid_nr(osb->recovery_thread_task) : -1)); 263 if (rm->rm_used == 0) 264 out += snprintf(buf + out, len - out, " None\n"); 265 else { 266 for (i = 0; i < rm->rm_used; i++) 267 out += snprintf(buf + out, len - out, " %d", 268 rm->rm_entries[i]); 269 out += snprintf(buf + out, len - out, "\n"); 270 } 271 spin_unlock(&osb->osb_lock); 272 273 out += snprintf(buf + out, len - out, 274 "%10s => Pid: %d Interval: %lu Needs: %d\n", "Commit", 275 (osb->commit_task ? task_pid_nr(osb->commit_task) : -1), 276 osb->osb_commit_interval, 277 atomic_read(&osb->needs_checkpoint)); 278 279 out += snprintf(buf + out, len - out, 280 "%10s => State: %d TxnId: %lu NumTxns: %d\n", 281 "Journal", osb->journal->j_state, 282 osb->journal->j_trans_id, 283 atomic_read(&osb->journal->j_num_trans)); 284 285 out += snprintf(buf + out, len - out, 286 "%10s => GlobalAllocs: %d LocalAllocs: %d " 287 "SubAllocs: %d LAWinMoves: %d SAExtends: %d\n", 288 "Stats", 289 atomic_read(&osb->alloc_stats.bitmap_data), 290 atomic_read(&osb->alloc_stats.local_data), 291 atomic_read(&osb->alloc_stats.bg_allocs), 292 atomic_read(&osb->alloc_stats.moves), 293 atomic_read(&osb->alloc_stats.bg_extends)); 294 295 out += snprintf(buf + out, len - out, 296 "%10s => State: %u Descriptor: %llu Size: %u bits " 297 "Default: %u bits\n", 298 "LocalAlloc", osb->local_alloc_state, 299 (unsigned long long)osb->la_last_gd, 300 osb->local_alloc_bits, osb->local_alloc_default_bits); 301 302 spin_lock(&osb->osb_lock); 303 out += snprintf(buf + out, len - out, 304 "%10s => Slot: %d NumStolen: %d\n", "Steal", 305 osb->s_inode_steal_slot, 306 atomic_read(&osb->s_num_inodes_stolen)); 307 spin_unlock(&osb->osb_lock); 308 309 out += snprintf(buf + out, len - out, "OrphanScan => "); 310 out += snprintf(buf + out, len - out, "Local: %u Global: %u ", 311 os->os_count, os->os_seqno); 312 out += snprintf(buf + out, len - out, " Last Scan: "); 313 if (atomic_read(&os->os_state) == ORPHAN_SCAN_INACTIVE) 314 out += snprintf(buf + out, len - out, "Disabled\n"); 315 else 316 out += snprintf(buf + out, len - out, "%lu seconds ago\n", 317 (get_seconds() - os->os_scantime.tv_sec)); 318 319 out += snprintf(buf + out, len - out, "%10s => %3s %10s\n", 320 "Slots", "Num", "RecoGen"); 321 for (i = 0; i < osb->max_slots; ++i) { 322 out += snprintf(buf + out, len - out, 323 "%10s %c %3d %10d\n", 324 " ", 325 (i == osb->slot_num ? '*' : ' '), 326 i, osb->slot_recovery_generations[i]); 327 } 328 329 return out; 330 } 331 332 static int ocfs2_osb_debug_open(struct inode *inode, struct file *file) 333 { 334 struct ocfs2_super *osb = inode->i_private; 335 char *buf = NULL; 336 337 buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 338 if (!buf) 339 goto bail; 340 341 i_size_write(inode, ocfs2_osb_dump(osb, buf, PAGE_SIZE)); 342 343 file->private_data = buf; 344 345 return 0; 346 bail: 347 return -ENOMEM; 348 } 349 350 static int ocfs2_debug_release(struct inode *inode, struct file *file) 351 { 352 kfree(file->private_data); 353 return 0; 354 } 355 356 static ssize_t ocfs2_debug_read(struct file *file, char __user *buf, 357 size_t nbytes, loff_t *ppos) 358 { 359 return simple_read_from_buffer(buf, nbytes, ppos, file->private_data, 360 i_size_read(file->f_mapping->host)); 361 } 362 #else 363 static int ocfs2_osb_debug_open(struct inode *inode, struct file *file) 364 { 365 return 0; 366 } 367 static int ocfs2_debug_release(struct inode *inode, struct file *file) 368 { 369 return 0; 370 } 371 static ssize_t ocfs2_debug_read(struct file *file, char __user *buf, 372 size_t nbytes, loff_t *ppos) 373 { 374 return 0; 375 } 376 #endif /* CONFIG_DEBUG_FS */ 377 378 static const struct file_operations ocfs2_osb_debug_fops = { 379 .open = ocfs2_osb_debug_open, 380 .release = ocfs2_debug_release, 381 .read = ocfs2_debug_read, 382 .llseek = generic_file_llseek, 383 }; 384 385 static int ocfs2_sync_fs(struct super_block *sb, int wait) 386 { 387 int status; 388 tid_t target; 389 struct ocfs2_super *osb = OCFS2_SB(sb); 390 391 if (ocfs2_is_hard_readonly(osb)) 392 return -EROFS; 393 394 if (wait) { 395 status = ocfs2_flush_truncate_log(osb); 396 if (status < 0) 397 mlog_errno(status); 398 } else { 399 ocfs2_schedule_truncate_log_flush(osb, 0); 400 } 401 402 if (jbd2_journal_start_commit(OCFS2_SB(sb)->journal->j_journal, 403 &target)) { 404 if (wait) 405 jbd2_log_wait_commit(OCFS2_SB(sb)->journal->j_journal, 406 target); 407 } 408 return 0; 409 } 410 411 static int ocfs2_need_system_inode(struct ocfs2_super *osb, int ino) 412 { 413 if (!OCFS2_HAS_RO_COMPAT_FEATURE(osb->sb, OCFS2_FEATURE_RO_COMPAT_USRQUOTA) 414 && (ino == USER_QUOTA_SYSTEM_INODE 415 || ino == LOCAL_USER_QUOTA_SYSTEM_INODE)) 416 return 0; 417 if (!OCFS2_HAS_RO_COMPAT_FEATURE(osb->sb, OCFS2_FEATURE_RO_COMPAT_GRPQUOTA) 418 && (ino == GROUP_QUOTA_SYSTEM_INODE 419 || ino == LOCAL_GROUP_QUOTA_SYSTEM_INODE)) 420 return 0; 421 return 1; 422 } 423 424 static int ocfs2_init_global_system_inodes(struct ocfs2_super *osb) 425 { 426 struct inode *new = NULL; 427 int status = 0; 428 int i; 429 430 mlog_entry_void(); 431 432 new = ocfs2_iget(osb, osb->root_blkno, OCFS2_FI_FLAG_SYSFILE, 0); 433 if (IS_ERR(new)) { 434 status = PTR_ERR(new); 435 mlog_errno(status); 436 goto bail; 437 } 438 osb->root_inode = new; 439 440 new = ocfs2_iget(osb, osb->system_dir_blkno, OCFS2_FI_FLAG_SYSFILE, 0); 441 if (IS_ERR(new)) { 442 status = PTR_ERR(new); 443 mlog_errno(status); 444 goto bail; 445 } 446 osb->sys_root_inode = new; 447 448 for (i = OCFS2_FIRST_ONLINE_SYSTEM_INODE; 449 i <= OCFS2_LAST_GLOBAL_SYSTEM_INODE; i++) { 450 if (!ocfs2_need_system_inode(osb, i)) 451 continue; 452 new = ocfs2_get_system_file_inode(osb, i, osb->slot_num); 453 if (!new) { 454 ocfs2_release_system_inodes(osb); 455 status = -EINVAL; 456 mlog_errno(status); 457 /* FIXME: Should ERROR_RO_FS */ 458 mlog(ML_ERROR, "Unable to load system inode %d, " 459 "possibly corrupt fs?", i); 460 goto bail; 461 } 462 // the array now has one ref, so drop this one 463 iput(new); 464 } 465 466 bail: 467 mlog_exit(status); 468 return status; 469 } 470 471 static int ocfs2_init_local_system_inodes(struct ocfs2_super *osb) 472 { 473 struct inode *new = NULL; 474 int status = 0; 475 int i; 476 477 mlog_entry_void(); 478 479 for (i = OCFS2_LAST_GLOBAL_SYSTEM_INODE + 1; 480 i < NUM_SYSTEM_INODES; 481 i++) { 482 if (!ocfs2_need_system_inode(osb, i)) 483 continue; 484 new = ocfs2_get_system_file_inode(osb, i, osb->slot_num); 485 if (!new) { 486 ocfs2_release_system_inodes(osb); 487 status = -EINVAL; 488 mlog(ML_ERROR, "status=%d, sysfile=%d, slot=%d\n", 489 status, i, osb->slot_num); 490 goto bail; 491 } 492 /* the array now has one ref, so drop this one */ 493 iput(new); 494 } 495 496 bail: 497 mlog_exit(status); 498 return status; 499 } 500 501 static void ocfs2_release_system_inodes(struct ocfs2_super *osb) 502 { 503 int i; 504 struct inode *inode; 505 506 mlog_entry_void(); 507 508 for (i = 0; i < NUM_SYSTEM_INODES; i++) { 509 inode = osb->system_inodes[i]; 510 if (inode) { 511 iput(inode); 512 osb->system_inodes[i] = NULL; 513 } 514 } 515 516 inode = osb->sys_root_inode; 517 if (inode) { 518 iput(inode); 519 osb->sys_root_inode = NULL; 520 } 521 522 inode = osb->root_inode; 523 if (inode) { 524 iput(inode); 525 osb->root_inode = NULL; 526 } 527 528 mlog_exit(0); 529 } 530 531 /* We're allocating fs objects, use GFP_NOFS */ 532 static struct inode *ocfs2_alloc_inode(struct super_block *sb) 533 { 534 struct ocfs2_inode_info *oi; 535 536 oi = kmem_cache_alloc(ocfs2_inode_cachep, GFP_NOFS); 537 if (!oi) 538 return NULL; 539 540 jbd2_journal_init_jbd_inode(&oi->ip_jinode, &oi->vfs_inode); 541 return &oi->vfs_inode; 542 } 543 544 static void ocfs2_destroy_inode(struct inode *inode) 545 { 546 kmem_cache_free(ocfs2_inode_cachep, OCFS2_I(inode)); 547 } 548 549 static unsigned long long ocfs2_max_file_offset(unsigned int bbits, 550 unsigned int cbits) 551 { 552 unsigned int bytes = 1 << cbits; 553 unsigned int trim = bytes; 554 unsigned int bitshift = 32; 555 556 /* 557 * i_size and all block offsets in ocfs2 are always 64 bits 558 * wide. i_clusters is 32 bits, in cluster-sized units. So on 559 * 64 bit platforms, cluster size will be the limiting factor. 560 */ 561 562 #if BITS_PER_LONG == 32 563 # if defined(CONFIG_LBDAF) 564 BUILD_BUG_ON(sizeof(sector_t) != 8); 565 /* 566 * We might be limited by page cache size. 567 */ 568 if (bytes > PAGE_CACHE_SIZE) { 569 bytes = PAGE_CACHE_SIZE; 570 trim = 1; 571 /* 572 * Shift by 31 here so that we don't get larger than 573 * MAX_LFS_FILESIZE 574 */ 575 bitshift = 31; 576 } 577 # else 578 /* 579 * We are limited by the size of sector_t. Use block size, as 580 * that's what we expose to the VFS. 581 */ 582 bytes = 1 << bbits; 583 trim = 1; 584 bitshift = 31; 585 # endif 586 #endif 587 588 /* 589 * Trim by a whole cluster when we can actually approach the 590 * on-disk limits. Otherwise we can overflow i_clusters when 591 * an extent start is at the max offset. 592 */ 593 return (((unsigned long long)bytes) << bitshift) - trim; 594 } 595 596 static int ocfs2_remount(struct super_block *sb, int *flags, char *data) 597 { 598 int incompat_features; 599 int ret = 0; 600 struct mount_options parsed_options; 601 struct ocfs2_super *osb = OCFS2_SB(sb); 602 603 lock_kernel(); 604 605 if (!ocfs2_parse_options(sb, data, &parsed_options, 1) || 606 !ocfs2_check_set_options(sb, &parsed_options)) { 607 ret = -EINVAL; 608 goto out; 609 } 610 611 if ((osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) != 612 (parsed_options.mount_opt & OCFS2_MOUNT_HB_LOCAL)) { 613 ret = -EINVAL; 614 mlog(ML_ERROR, "Cannot change heartbeat mode on remount\n"); 615 goto out; 616 } 617 618 if ((osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) != 619 (parsed_options.mount_opt & OCFS2_MOUNT_DATA_WRITEBACK)) { 620 ret = -EINVAL; 621 mlog(ML_ERROR, "Cannot change data mode on remount\n"); 622 goto out; 623 } 624 625 /* Probably don't want this on remount; it might 626 * mess with other nodes */ 627 if (!(osb->s_mount_opt & OCFS2_MOUNT_INODE64) && 628 (parsed_options.mount_opt & OCFS2_MOUNT_INODE64)) { 629 ret = -EINVAL; 630 mlog(ML_ERROR, "Cannot enable inode64 on remount\n"); 631 goto out; 632 } 633 634 /* We're going to/from readonly mode. */ 635 if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) { 636 /* Disable quota accounting before remounting RO */ 637 if (*flags & MS_RDONLY) { 638 ret = ocfs2_susp_quotas(osb, 0); 639 if (ret < 0) 640 goto out; 641 } 642 /* Lock here so the check of HARD_RO and the potential 643 * setting of SOFT_RO is atomic. */ 644 spin_lock(&osb->osb_lock); 645 if (osb->osb_flags & OCFS2_OSB_HARD_RO) { 646 mlog(ML_ERROR, "Remount on readonly device is forbidden.\n"); 647 ret = -EROFS; 648 goto unlock_osb; 649 } 650 651 if (*flags & MS_RDONLY) { 652 mlog(0, "Going to ro mode.\n"); 653 sb->s_flags |= MS_RDONLY; 654 osb->osb_flags |= OCFS2_OSB_SOFT_RO; 655 } else { 656 mlog(0, "Making ro filesystem writeable.\n"); 657 658 if (osb->osb_flags & OCFS2_OSB_ERROR_FS) { 659 mlog(ML_ERROR, "Cannot remount RDWR " 660 "filesystem due to previous errors.\n"); 661 ret = -EROFS; 662 goto unlock_osb; 663 } 664 incompat_features = OCFS2_HAS_RO_COMPAT_FEATURE(sb, ~OCFS2_FEATURE_RO_COMPAT_SUPP); 665 if (incompat_features) { 666 mlog(ML_ERROR, "Cannot remount RDWR because " 667 "of unsupported optional features " 668 "(%x).\n", incompat_features); 669 ret = -EINVAL; 670 goto unlock_osb; 671 } 672 sb->s_flags &= ~MS_RDONLY; 673 osb->osb_flags &= ~OCFS2_OSB_SOFT_RO; 674 } 675 unlock_osb: 676 spin_unlock(&osb->osb_lock); 677 /* Enable quota accounting after remounting RW */ 678 if (!ret && !(*flags & MS_RDONLY)) { 679 if (sb_any_quota_suspended(sb)) 680 ret = ocfs2_susp_quotas(osb, 1); 681 else 682 ret = ocfs2_enable_quotas(osb); 683 if (ret < 0) { 684 /* Return back changes... */ 685 spin_lock(&osb->osb_lock); 686 sb->s_flags |= MS_RDONLY; 687 osb->osb_flags |= OCFS2_OSB_SOFT_RO; 688 spin_unlock(&osb->osb_lock); 689 goto out; 690 } 691 } 692 } 693 694 if (!ret) { 695 /* Only save off the new mount options in case of a successful 696 * remount. */ 697 osb->s_mount_opt = parsed_options.mount_opt; 698 osb->s_atime_quantum = parsed_options.atime_quantum; 699 osb->preferred_slot = parsed_options.slot; 700 if (parsed_options.commit_interval) 701 osb->osb_commit_interval = parsed_options.commit_interval; 702 703 if (!ocfs2_is_hard_readonly(osb)) 704 ocfs2_set_journal_params(osb); 705 706 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 707 ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? 708 MS_POSIXACL : 0); 709 } 710 out: 711 unlock_kernel(); 712 return ret; 713 } 714 715 static int ocfs2_sb_probe(struct super_block *sb, 716 struct buffer_head **bh, 717 int *sector_size, 718 struct ocfs2_blockcheck_stats *stats) 719 { 720 int status, tmpstat; 721 struct ocfs1_vol_disk_hdr *hdr; 722 struct ocfs2_dinode *di; 723 int blksize; 724 725 *bh = NULL; 726 727 /* may be > 512 */ 728 *sector_size = bdev_logical_block_size(sb->s_bdev); 729 if (*sector_size > OCFS2_MAX_BLOCKSIZE) { 730 mlog(ML_ERROR, "Hardware sector size too large: %d (max=%d)\n", 731 *sector_size, OCFS2_MAX_BLOCKSIZE); 732 status = -EINVAL; 733 goto bail; 734 } 735 736 /* Can this really happen? */ 737 if (*sector_size < OCFS2_MIN_BLOCKSIZE) 738 *sector_size = OCFS2_MIN_BLOCKSIZE; 739 740 /* check block zero for old format */ 741 status = ocfs2_get_sector(sb, bh, 0, *sector_size); 742 if (status < 0) { 743 mlog_errno(status); 744 goto bail; 745 } 746 hdr = (struct ocfs1_vol_disk_hdr *) (*bh)->b_data; 747 if (hdr->major_version == OCFS1_MAJOR_VERSION) { 748 mlog(ML_ERROR, "incompatible version: %u.%u\n", 749 hdr->major_version, hdr->minor_version); 750 status = -EINVAL; 751 } 752 if (memcmp(hdr->signature, OCFS1_VOLUME_SIGNATURE, 753 strlen(OCFS1_VOLUME_SIGNATURE)) == 0) { 754 mlog(ML_ERROR, "incompatible volume signature: %8s\n", 755 hdr->signature); 756 status = -EINVAL; 757 } 758 brelse(*bh); 759 *bh = NULL; 760 if (status < 0) { 761 mlog(ML_ERROR, "This is an ocfs v1 filesystem which must be " 762 "upgraded before mounting with ocfs v2\n"); 763 goto bail; 764 } 765 766 /* 767 * Now check at magic offset for 512, 1024, 2048, 4096 768 * blocksizes. 4096 is the maximum blocksize because it is 769 * the minimum clustersize. 770 */ 771 status = -EINVAL; 772 for (blksize = *sector_size; 773 blksize <= OCFS2_MAX_BLOCKSIZE; 774 blksize <<= 1) { 775 tmpstat = ocfs2_get_sector(sb, bh, 776 OCFS2_SUPER_BLOCK_BLKNO, 777 blksize); 778 if (tmpstat < 0) { 779 status = tmpstat; 780 mlog_errno(status); 781 break; 782 } 783 di = (struct ocfs2_dinode *) (*bh)->b_data; 784 memset(stats, 0, sizeof(struct ocfs2_blockcheck_stats)); 785 spin_lock_init(&stats->b_lock); 786 tmpstat = ocfs2_verify_volume(di, *bh, blksize, stats); 787 if (tmpstat < 0) { 788 brelse(*bh); 789 *bh = NULL; 790 } 791 if (tmpstat != -EAGAIN) { 792 status = tmpstat; 793 break; 794 } 795 } 796 797 bail: 798 return status; 799 } 800 801 static int ocfs2_verify_heartbeat(struct ocfs2_super *osb) 802 { 803 if (ocfs2_mount_local(osb)) { 804 if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) { 805 mlog(ML_ERROR, "Cannot heartbeat on a locally " 806 "mounted device.\n"); 807 return -EINVAL; 808 } 809 } 810 811 if (ocfs2_userspace_stack(osb)) { 812 if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) { 813 mlog(ML_ERROR, "Userspace stack expected, but " 814 "o2cb heartbeat arguments passed to mount\n"); 815 return -EINVAL; 816 } 817 } 818 819 if (!(osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL)) { 820 if (!ocfs2_mount_local(osb) && !ocfs2_is_hard_readonly(osb) && 821 !ocfs2_userspace_stack(osb)) { 822 mlog(ML_ERROR, "Heartbeat has to be started to mount " 823 "a read-write clustered device.\n"); 824 return -EINVAL; 825 } 826 } 827 828 return 0; 829 } 830 831 /* 832 * If we're using a userspace stack, mount should have passed 833 * a name that matches the disk. If not, mount should not 834 * have passed a stack. 835 */ 836 static int ocfs2_verify_userspace_stack(struct ocfs2_super *osb, 837 struct mount_options *mopt) 838 { 839 if (!ocfs2_userspace_stack(osb) && mopt->cluster_stack[0]) { 840 mlog(ML_ERROR, 841 "cluster stack passed to mount, but this filesystem " 842 "does not support it\n"); 843 return -EINVAL; 844 } 845 846 if (ocfs2_userspace_stack(osb) && 847 strncmp(osb->osb_cluster_stack, mopt->cluster_stack, 848 OCFS2_STACK_LABEL_LEN)) { 849 mlog(ML_ERROR, 850 "cluster stack passed to mount (\"%s\") does not " 851 "match the filesystem (\"%s\")\n", 852 mopt->cluster_stack, 853 osb->osb_cluster_stack); 854 return -EINVAL; 855 } 856 857 return 0; 858 } 859 860 static int ocfs2_susp_quotas(struct ocfs2_super *osb, int unsuspend) 861 { 862 int type; 863 struct super_block *sb = osb->sb; 864 unsigned int feature[MAXQUOTAS] = { OCFS2_FEATURE_RO_COMPAT_USRQUOTA, 865 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA}; 866 int status = 0; 867 868 for (type = 0; type < MAXQUOTAS; type++) { 869 if (!OCFS2_HAS_RO_COMPAT_FEATURE(sb, feature[type])) 870 continue; 871 if (unsuspend) 872 status = vfs_quota_enable( 873 sb_dqopt(sb)->files[type], 874 type, QFMT_OCFS2, 875 DQUOT_SUSPENDED); 876 else 877 status = vfs_quota_disable(sb, type, 878 DQUOT_SUSPENDED); 879 if (status < 0) 880 break; 881 } 882 if (status < 0) 883 mlog(ML_ERROR, "Failed to suspend/unsuspend quotas on " 884 "remount (error = %d).\n", status); 885 return status; 886 } 887 888 static int ocfs2_enable_quotas(struct ocfs2_super *osb) 889 { 890 struct inode *inode[MAXQUOTAS] = { NULL, NULL }; 891 struct super_block *sb = osb->sb; 892 unsigned int feature[MAXQUOTAS] = { OCFS2_FEATURE_RO_COMPAT_USRQUOTA, 893 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA}; 894 unsigned int ino[MAXQUOTAS] = { LOCAL_USER_QUOTA_SYSTEM_INODE, 895 LOCAL_GROUP_QUOTA_SYSTEM_INODE }; 896 int status; 897 int type; 898 899 sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE | DQUOT_NEGATIVE_USAGE; 900 for (type = 0; type < MAXQUOTAS; type++) { 901 if (!OCFS2_HAS_RO_COMPAT_FEATURE(sb, feature[type])) 902 continue; 903 inode[type] = ocfs2_get_system_file_inode(osb, ino[type], 904 osb->slot_num); 905 if (!inode[type]) { 906 status = -ENOENT; 907 goto out_quota_off; 908 } 909 status = vfs_quota_enable(inode[type], type, QFMT_OCFS2, 910 DQUOT_USAGE_ENABLED); 911 if (status < 0) 912 goto out_quota_off; 913 } 914 915 for (type = 0; type < MAXQUOTAS; type++) 916 iput(inode[type]); 917 return 0; 918 out_quota_off: 919 ocfs2_disable_quotas(osb); 920 for (type = 0; type < MAXQUOTAS; type++) 921 iput(inode[type]); 922 mlog_errno(status); 923 return status; 924 } 925 926 static void ocfs2_disable_quotas(struct ocfs2_super *osb) 927 { 928 int type; 929 struct inode *inode; 930 struct super_block *sb = osb->sb; 931 932 /* We mostly ignore errors in this function because there's not much 933 * we can do when we see them */ 934 for (type = 0; type < MAXQUOTAS; type++) { 935 if (!sb_has_quota_loaded(sb, type)) 936 continue; 937 inode = igrab(sb->s_dquot.files[type]); 938 /* Turn off quotas. This will remove all dquot structures from 939 * memory and so they will be automatically synced to global 940 * quota files */ 941 vfs_quota_disable(sb, type, DQUOT_USAGE_ENABLED | 942 DQUOT_LIMITS_ENABLED); 943 if (!inode) 944 continue; 945 iput(inode); 946 } 947 } 948 949 /* Handle quota on quotactl */ 950 static int ocfs2_quota_on(struct super_block *sb, int type, int format_id, 951 char *path, int remount) 952 { 953 unsigned int feature[MAXQUOTAS] = { OCFS2_FEATURE_RO_COMPAT_USRQUOTA, 954 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA}; 955 956 if (!OCFS2_HAS_RO_COMPAT_FEATURE(sb, feature[type])) 957 return -EINVAL; 958 959 if (remount) 960 return 0; /* Just ignore it has been handled in 961 * ocfs2_remount() */ 962 return vfs_quota_enable(sb_dqopt(sb)->files[type], type, 963 format_id, DQUOT_LIMITS_ENABLED); 964 } 965 966 /* Handle quota off quotactl */ 967 static int ocfs2_quota_off(struct super_block *sb, int type, int remount) 968 { 969 if (remount) 970 return 0; /* Ignore now and handle later in 971 * ocfs2_remount() */ 972 return vfs_quota_disable(sb, type, DQUOT_LIMITS_ENABLED); 973 } 974 975 static const struct quotactl_ops ocfs2_quotactl_ops = { 976 .quota_on = ocfs2_quota_on, 977 .quota_off = ocfs2_quota_off, 978 .quota_sync = vfs_quota_sync, 979 .get_info = vfs_get_dqinfo, 980 .set_info = vfs_set_dqinfo, 981 .get_dqblk = vfs_get_dqblk, 982 .set_dqblk = vfs_set_dqblk, 983 }; 984 985 static int ocfs2_fill_super(struct super_block *sb, void *data, int silent) 986 { 987 struct dentry *root; 988 int status, sector_size; 989 struct mount_options parsed_options; 990 struct inode *inode = NULL; 991 struct ocfs2_super *osb = NULL; 992 struct buffer_head *bh = NULL; 993 char nodestr[8]; 994 struct ocfs2_blockcheck_stats stats; 995 996 mlog_entry("%p, %p, %i", sb, data, silent); 997 998 if (!ocfs2_parse_options(sb, data, &parsed_options, 0)) { 999 status = -EINVAL; 1000 goto read_super_error; 1001 } 1002 1003 /* probe for superblock */ 1004 status = ocfs2_sb_probe(sb, &bh, §or_size, &stats); 1005 if (status < 0) { 1006 mlog(ML_ERROR, "superblock probe failed!\n"); 1007 goto read_super_error; 1008 } 1009 1010 status = ocfs2_initialize_super(sb, bh, sector_size, &stats); 1011 osb = OCFS2_SB(sb); 1012 if (status < 0) { 1013 mlog_errno(status); 1014 goto read_super_error; 1015 } 1016 brelse(bh); 1017 bh = NULL; 1018 1019 if (!ocfs2_check_set_options(sb, &parsed_options)) { 1020 status = -EINVAL; 1021 goto read_super_error; 1022 } 1023 osb->s_mount_opt = parsed_options.mount_opt; 1024 osb->s_atime_quantum = parsed_options.atime_quantum; 1025 osb->preferred_slot = parsed_options.slot; 1026 osb->osb_commit_interval = parsed_options.commit_interval; 1027 osb->local_alloc_default_bits = ocfs2_megabytes_to_clusters(sb, parsed_options.localalloc_opt); 1028 osb->local_alloc_bits = osb->local_alloc_default_bits; 1029 1030 status = ocfs2_verify_userspace_stack(osb, &parsed_options); 1031 if (status) 1032 goto read_super_error; 1033 1034 sb->s_magic = OCFS2_SUPER_MAGIC; 1035 1036 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 1037 ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0); 1038 1039 /* Hard readonly mode only if: bdev_read_only, MS_RDONLY, 1040 * heartbeat=none */ 1041 if (bdev_read_only(sb->s_bdev)) { 1042 if (!(sb->s_flags & MS_RDONLY)) { 1043 status = -EACCES; 1044 mlog(ML_ERROR, "Readonly device detected but readonly " 1045 "mount was not specified.\n"); 1046 goto read_super_error; 1047 } 1048 1049 /* You should not be able to start a local heartbeat 1050 * on a readonly device. */ 1051 if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) { 1052 status = -EROFS; 1053 mlog(ML_ERROR, "Local heartbeat specified on readonly " 1054 "device.\n"); 1055 goto read_super_error; 1056 } 1057 1058 status = ocfs2_check_journals_nolocks(osb); 1059 if (status < 0) { 1060 if (status == -EROFS) 1061 mlog(ML_ERROR, "Recovery required on readonly " 1062 "file system, but write access is " 1063 "unavailable.\n"); 1064 else 1065 mlog_errno(status); 1066 goto read_super_error; 1067 } 1068 1069 ocfs2_set_ro_flag(osb, 1); 1070 1071 printk(KERN_NOTICE "Readonly device detected. No cluster " 1072 "services will be utilized for this mount. Recovery " 1073 "will be skipped.\n"); 1074 } 1075 1076 if (!ocfs2_is_hard_readonly(osb)) { 1077 if (sb->s_flags & MS_RDONLY) 1078 ocfs2_set_ro_flag(osb, 0); 1079 } 1080 1081 status = ocfs2_verify_heartbeat(osb); 1082 if (status < 0) { 1083 mlog_errno(status); 1084 goto read_super_error; 1085 } 1086 1087 osb->osb_debug_root = debugfs_create_dir(osb->uuid_str, 1088 ocfs2_debugfs_root); 1089 if (!osb->osb_debug_root) { 1090 status = -EINVAL; 1091 mlog(ML_ERROR, "Unable to create per-mount debugfs root.\n"); 1092 goto read_super_error; 1093 } 1094 1095 osb->osb_ctxt = debugfs_create_file("fs_state", S_IFREG|S_IRUSR, 1096 osb->osb_debug_root, 1097 osb, 1098 &ocfs2_osb_debug_fops); 1099 if (!osb->osb_ctxt) { 1100 status = -EINVAL; 1101 mlog_errno(status); 1102 goto read_super_error; 1103 } 1104 1105 if (ocfs2_meta_ecc(osb)) { 1106 status = ocfs2_blockcheck_stats_debugfs_install( 1107 &osb->osb_ecc_stats, 1108 osb->osb_debug_root); 1109 if (status) { 1110 mlog(ML_ERROR, 1111 "Unable to create blockcheck statistics " 1112 "files\n"); 1113 goto read_super_error; 1114 } 1115 } 1116 1117 status = ocfs2_mount_volume(sb); 1118 if (osb->root_inode) 1119 inode = igrab(osb->root_inode); 1120 1121 if (status < 0) 1122 goto read_super_error; 1123 1124 if (!inode) { 1125 status = -EIO; 1126 mlog_errno(status); 1127 goto read_super_error; 1128 } 1129 1130 root = d_alloc_root(inode); 1131 if (!root) { 1132 status = -ENOMEM; 1133 mlog_errno(status); 1134 goto read_super_error; 1135 } 1136 1137 sb->s_root = root; 1138 1139 ocfs2_complete_mount_recovery(osb); 1140 1141 if (ocfs2_mount_local(osb)) 1142 snprintf(nodestr, sizeof(nodestr), "local"); 1143 else 1144 snprintf(nodestr, sizeof(nodestr), "%u", osb->node_num); 1145 1146 printk(KERN_INFO "ocfs2: Mounting device (%s) on (node %s, slot %d) " 1147 "with %s data mode.\n", 1148 osb->dev_str, nodestr, osb->slot_num, 1149 osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK ? "writeback" : 1150 "ordered"); 1151 1152 atomic_set(&osb->vol_state, VOLUME_MOUNTED); 1153 wake_up(&osb->osb_mount_event); 1154 1155 /* Now we can initialize quotas because we can afford to wait 1156 * for cluster locks recovery now. That also means that truncation 1157 * log recovery can happen but that waits for proper quota setup */ 1158 if (!(sb->s_flags & MS_RDONLY)) { 1159 status = ocfs2_enable_quotas(osb); 1160 if (status < 0) { 1161 /* We have to err-out specially here because 1162 * s_root is already set */ 1163 mlog_errno(status); 1164 atomic_set(&osb->vol_state, VOLUME_DISABLED); 1165 wake_up(&osb->osb_mount_event); 1166 mlog_exit(status); 1167 return status; 1168 } 1169 } 1170 1171 ocfs2_complete_quota_recovery(osb); 1172 1173 /* Now we wake up again for processes waiting for quotas */ 1174 atomic_set(&osb->vol_state, VOLUME_MOUNTED_QUOTAS); 1175 wake_up(&osb->osb_mount_event); 1176 1177 /* Start this when the mount is almost sure of being successful */ 1178 ocfs2_orphan_scan_start(osb); 1179 1180 mlog_exit(status); 1181 return status; 1182 1183 read_super_error: 1184 brelse(bh); 1185 1186 if (inode) 1187 iput(inode); 1188 1189 if (osb) { 1190 atomic_set(&osb->vol_state, VOLUME_DISABLED); 1191 wake_up(&osb->osb_mount_event); 1192 ocfs2_dismount_volume(sb, 1); 1193 } 1194 1195 mlog_exit(status); 1196 return status; 1197 } 1198 1199 static int ocfs2_get_sb(struct file_system_type *fs_type, 1200 int flags, 1201 const char *dev_name, 1202 void *data, 1203 struct vfsmount *mnt) 1204 { 1205 return get_sb_bdev(fs_type, flags, dev_name, data, ocfs2_fill_super, 1206 mnt); 1207 } 1208 1209 static void ocfs2_kill_sb(struct super_block *sb) 1210 { 1211 struct ocfs2_super *osb = OCFS2_SB(sb); 1212 1213 /* Failed mount? */ 1214 if (!osb || atomic_read(&osb->vol_state) == VOLUME_DISABLED) 1215 goto out; 1216 1217 /* Prevent further queueing of inode drop events */ 1218 spin_lock(&dentry_list_lock); 1219 ocfs2_set_osb_flag(osb, OCFS2_OSB_DROP_DENTRY_LOCK_IMMED); 1220 spin_unlock(&dentry_list_lock); 1221 /* Wait for work to finish and/or remove it */ 1222 cancel_work_sync(&osb->dentry_lock_work); 1223 out: 1224 kill_block_super(sb); 1225 } 1226 1227 static struct file_system_type ocfs2_fs_type = { 1228 .owner = THIS_MODULE, 1229 .name = "ocfs2", 1230 .get_sb = ocfs2_get_sb, /* is this called when we mount 1231 * the fs? */ 1232 .kill_sb = ocfs2_kill_sb, 1233 1234 .fs_flags = FS_REQUIRES_DEV|FS_RENAME_DOES_D_MOVE, 1235 .next = NULL 1236 }; 1237 1238 static int ocfs2_check_set_options(struct super_block *sb, 1239 struct mount_options *options) 1240 { 1241 if (options->mount_opt & OCFS2_MOUNT_USRQUOTA && 1242 !OCFS2_HAS_RO_COMPAT_FEATURE(sb, 1243 OCFS2_FEATURE_RO_COMPAT_USRQUOTA)) { 1244 mlog(ML_ERROR, "User quotas were requested, but this " 1245 "filesystem does not have the feature enabled.\n"); 1246 return 0; 1247 } 1248 if (options->mount_opt & OCFS2_MOUNT_GRPQUOTA && 1249 !OCFS2_HAS_RO_COMPAT_FEATURE(sb, 1250 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA)) { 1251 mlog(ML_ERROR, "Group quotas were requested, but this " 1252 "filesystem does not have the feature enabled.\n"); 1253 return 0; 1254 } 1255 if (options->mount_opt & OCFS2_MOUNT_POSIX_ACL && 1256 !OCFS2_HAS_INCOMPAT_FEATURE(sb, OCFS2_FEATURE_INCOMPAT_XATTR)) { 1257 mlog(ML_ERROR, "ACL support requested but extended attributes " 1258 "feature is not enabled\n"); 1259 return 0; 1260 } 1261 /* No ACL setting specified? Use XATTR feature... */ 1262 if (!(options->mount_opt & (OCFS2_MOUNT_POSIX_ACL | 1263 OCFS2_MOUNT_NO_POSIX_ACL))) { 1264 if (OCFS2_HAS_INCOMPAT_FEATURE(sb, OCFS2_FEATURE_INCOMPAT_XATTR)) 1265 options->mount_opt |= OCFS2_MOUNT_POSIX_ACL; 1266 else 1267 options->mount_opt |= OCFS2_MOUNT_NO_POSIX_ACL; 1268 } 1269 return 1; 1270 } 1271 1272 static int ocfs2_parse_options(struct super_block *sb, 1273 char *options, 1274 struct mount_options *mopt, 1275 int is_remount) 1276 { 1277 int status; 1278 char *p; 1279 1280 mlog_entry("remount: %d, options: \"%s\"\n", is_remount, 1281 options ? options : "(none)"); 1282 1283 mopt->commit_interval = 0; 1284 mopt->mount_opt = 0; 1285 mopt->atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM; 1286 mopt->slot = OCFS2_INVALID_SLOT; 1287 mopt->localalloc_opt = OCFS2_DEFAULT_LOCAL_ALLOC_SIZE; 1288 mopt->cluster_stack[0] = '\0'; 1289 1290 if (!options) { 1291 status = 1; 1292 goto bail; 1293 } 1294 1295 while ((p = strsep(&options, ",")) != NULL) { 1296 int token, option; 1297 substring_t args[MAX_OPT_ARGS]; 1298 1299 if (!*p) 1300 continue; 1301 1302 token = match_token(p, tokens, args); 1303 switch (token) { 1304 case Opt_hb_local: 1305 mopt->mount_opt |= OCFS2_MOUNT_HB_LOCAL; 1306 break; 1307 case Opt_hb_none: 1308 mopt->mount_opt &= ~OCFS2_MOUNT_HB_LOCAL; 1309 break; 1310 case Opt_barrier: 1311 if (match_int(&args[0], &option)) { 1312 status = 0; 1313 goto bail; 1314 } 1315 if (option) 1316 mopt->mount_opt |= OCFS2_MOUNT_BARRIER; 1317 else 1318 mopt->mount_opt &= ~OCFS2_MOUNT_BARRIER; 1319 break; 1320 case Opt_intr: 1321 mopt->mount_opt &= ~OCFS2_MOUNT_NOINTR; 1322 break; 1323 case Opt_nointr: 1324 mopt->mount_opt |= OCFS2_MOUNT_NOINTR; 1325 break; 1326 case Opt_err_panic: 1327 mopt->mount_opt |= OCFS2_MOUNT_ERRORS_PANIC; 1328 break; 1329 case Opt_err_ro: 1330 mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_PANIC; 1331 break; 1332 case Opt_data_ordered: 1333 mopt->mount_opt &= ~OCFS2_MOUNT_DATA_WRITEBACK; 1334 break; 1335 case Opt_data_writeback: 1336 mopt->mount_opt |= OCFS2_MOUNT_DATA_WRITEBACK; 1337 break; 1338 case Opt_user_xattr: 1339 mopt->mount_opt &= ~OCFS2_MOUNT_NOUSERXATTR; 1340 break; 1341 case Opt_nouser_xattr: 1342 mopt->mount_opt |= OCFS2_MOUNT_NOUSERXATTR; 1343 break; 1344 case Opt_atime_quantum: 1345 if (match_int(&args[0], &option)) { 1346 status = 0; 1347 goto bail; 1348 } 1349 if (option >= 0) 1350 mopt->atime_quantum = option; 1351 break; 1352 case Opt_slot: 1353 option = 0; 1354 if (match_int(&args[0], &option)) { 1355 status = 0; 1356 goto bail; 1357 } 1358 if (option) 1359 mopt->slot = (s16)option; 1360 break; 1361 case Opt_commit: 1362 option = 0; 1363 if (match_int(&args[0], &option)) { 1364 status = 0; 1365 goto bail; 1366 } 1367 if (option < 0) 1368 return 0; 1369 if (option == 0) 1370 option = JBD2_DEFAULT_MAX_COMMIT_AGE; 1371 mopt->commit_interval = HZ * option; 1372 break; 1373 case Opt_localalloc: 1374 option = 0; 1375 if (match_int(&args[0], &option)) { 1376 status = 0; 1377 goto bail; 1378 } 1379 if (option >= 0 && (option <= ocfs2_local_alloc_size(sb) * 8)) 1380 mopt->localalloc_opt = option; 1381 break; 1382 case Opt_localflocks: 1383 /* 1384 * Changing this during remount could race 1385 * flock() requests, or "unbalance" existing 1386 * ones (e.g., a lock is taken in one mode but 1387 * dropped in the other). If users care enough 1388 * to flip locking modes during remount, we 1389 * could add a "local" flag to individual 1390 * flock structures for proper tracking of 1391 * state. 1392 */ 1393 if (!is_remount) 1394 mopt->mount_opt |= OCFS2_MOUNT_LOCALFLOCKS; 1395 break; 1396 case Opt_stack: 1397 /* Check both that the option we were passed 1398 * is of the right length and that it is a proper 1399 * string of the right length. 1400 */ 1401 if (((args[0].to - args[0].from) != 1402 OCFS2_STACK_LABEL_LEN) || 1403 (strnlen(args[0].from, 1404 OCFS2_STACK_LABEL_LEN) != 1405 OCFS2_STACK_LABEL_LEN)) { 1406 mlog(ML_ERROR, 1407 "Invalid cluster_stack option\n"); 1408 status = 0; 1409 goto bail; 1410 } 1411 memcpy(mopt->cluster_stack, args[0].from, 1412 OCFS2_STACK_LABEL_LEN); 1413 mopt->cluster_stack[OCFS2_STACK_LABEL_LEN] = '\0'; 1414 break; 1415 case Opt_inode64: 1416 mopt->mount_opt |= OCFS2_MOUNT_INODE64; 1417 break; 1418 case Opt_usrquota: 1419 mopt->mount_opt |= OCFS2_MOUNT_USRQUOTA; 1420 break; 1421 case Opt_grpquota: 1422 mopt->mount_opt |= OCFS2_MOUNT_GRPQUOTA; 1423 break; 1424 case Opt_acl: 1425 mopt->mount_opt |= OCFS2_MOUNT_POSIX_ACL; 1426 mopt->mount_opt &= ~OCFS2_MOUNT_NO_POSIX_ACL; 1427 break; 1428 case Opt_noacl: 1429 mopt->mount_opt |= OCFS2_MOUNT_NO_POSIX_ACL; 1430 mopt->mount_opt &= ~OCFS2_MOUNT_POSIX_ACL; 1431 break; 1432 default: 1433 mlog(ML_ERROR, 1434 "Unrecognized mount option \"%s\" " 1435 "or missing value\n", p); 1436 status = 0; 1437 goto bail; 1438 } 1439 } 1440 1441 status = 1; 1442 1443 bail: 1444 mlog_exit(status); 1445 return status; 1446 } 1447 1448 static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt) 1449 { 1450 struct ocfs2_super *osb = OCFS2_SB(mnt->mnt_sb); 1451 unsigned long opts = osb->s_mount_opt; 1452 unsigned int local_alloc_megs; 1453 1454 if (opts & OCFS2_MOUNT_HB_LOCAL) 1455 seq_printf(s, ",_netdev,heartbeat=local"); 1456 else 1457 seq_printf(s, ",heartbeat=none"); 1458 1459 if (opts & OCFS2_MOUNT_NOINTR) 1460 seq_printf(s, ",nointr"); 1461 1462 if (opts & OCFS2_MOUNT_DATA_WRITEBACK) 1463 seq_printf(s, ",data=writeback"); 1464 else 1465 seq_printf(s, ",data=ordered"); 1466 1467 if (opts & OCFS2_MOUNT_BARRIER) 1468 seq_printf(s, ",barrier=1"); 1469 1470 if (opts & OCFS2_MOUNT_ERRORS_PANIC) 1471 seq_printf(s, ",errors=panic"); 1472 else 1473 seq_printf(s, ",errors=remount-ro"); 1474 1475 if (osb->preferred_slot != OCFS2_INVALID_SLOT) 1476 seq_printf(s, ",preferred_slot=%d", osb->preferred_slot); 1477 1478 if (osb->s_atime_quantum != OCFS2_DEFAULT_ATIME_QUANTUM) 1479 seq_printf(s, ",atime_quantum=%u", osb->s_atime_quantum); 1480 1481 if (osb->osb_commit_interval) 1482 seq_printf(s, ",commit=%u", 1483 (unsigned) (osb->osb_commit_interval / HZ)); 1484 1485 local_alloc_megs = osb->local_alloc_bits >> (20 - osb->s_clustersize_bits); 1486 if (local_alloc_megs != OCFS2_DEFAULT_LOCAL_ALLOC_SIZE) 1487 seq_printf(s, ",localalloc=%d", local_alloc_megs); 1488 1489 if (opts & OCFS2_MOUNT_LOCALFLOCKS) 1490 seq_printf(s, ",localflocks,"); 1491 1492 if (osb->osb_cluster_stack[0]) 1493 seq_printf(s, ",cluster_stack=%.*s", OCFS2_STACK_LABEL_LEN, 1494 osb->osb_cluster_stack); 1495 if (opts & OCFS2_MOUNT_USRQUOTA) 1496 seq_printf(s, ",usrquota"); 1497 if (opts & OCFS2_MOUNT_GRPQUOTA) 1498 seq_printf(s, ",grpquota"); 1499 1500 if (opts & OCFS2_MOUNT_NOUSERXATTR) 1501 seq_printf(s, ",nouser_xattr"); 1502 else 1503 seq_printf(s, ",user_xattr"); 1504 1505 if (opts & OCFS2_MOUNT_INODE64) 1506 seq_printf(s, ",inode64"); 1507 1508 if (opts & OCFS2_MOUNT_POSIX_ACL) 1509 seq_printf(s, ",acl"); 1510 else 1511 seq_printf(s, ",noacl"); 1512 1513 return 0; 1514 } 1515 1516 static int __init ocfs2_init(void) 1517 { 1518 int status; 1519 1520 mlog_entry_void(); 1521 1522 ocfs2_print_version(); 1523 1524 status = init_ocfs2_uptodate_cache(); 1525 if (status < 0) { 1526 mlog_errno(status); 1527 goto leave; 1528 } 1529 1530 status = ocfs2_initialize_mem_caches(); 1531 if (status < 0) { 1532 mlog_errno(status); 1533 goto leave; 1534 } 1535 1536 ocfs2_wq = create_singlethread_workqueue("ocfs2_wq"); 1537 if (!ocfs2_wq) { 1538 status = -ENOMEM; 1539 goto leave; 1540 } 1541 1542 ocfs2_debugfs_root = debugfs_create_dir("ocfs2", NULL); 1543 if (!ocfs2_debugfs_root) { 1544 status = -EFAULT; 1545 mlog(ML_ERROR, "Unable to create ocfs2 debugfs root.\n"); 1546 } 1547 1548 status = ocfs2_quota_setup(); 1549 if (status) 1550 goto leave; 1551 1552 ocfs2_set_locking_protocol(); 1553 1554 status = register_quota_format(&ocfs2_quota_format); 1555 leave: 1556 if (status < 0) { 1557 ocfs2_quota_shutdown(); 1558 ocfs2_free_mem_caches(); 1559 exit_ocfs2_uptodate_cache(); 1560 } 1561 1562 mlog_exit(status); 1563 1564 if (status >= 0) { 1565 return register_filesystem(&ocfs2_fs_type); 1566 } else 1567 return -1; 1568 } 1569 1570 static void __exit ocfs2_exit(void) 1571 { 1572 mlog_entry_void(); 1573 1574 ocfs2_quota_shutdown(); 1575 1576 if (ocfs2_wq) { 1577 flush_workqueue(ocfs2_wq); 1578 destroy_workqueue(ocfs2_wq); 1579 } 1580 1581 unregister_quota_format(&ocfs2_quota_format); 1582 1583 debugfs_remove(ocfs2_debugfs_root); 1584 1585 ocfs2_free_mem_caches(); 1586 1587 unregister_filesystem(&ocfs2_fs_type); 1588 1589 exit_ocfs2_uptodate_cache(); 1590 1591 mlog_exit_void(); 1592 } 1593 1594 static void ocfs2_put_super(struct super_block *sb) 1595 { 1596 mlog_entry("(0x%p)\n", sb); 1597 1598 lock_kernel(); 1599 1600 ocfs2_sync_blockdev(sb); 1601 ocfs2_dismount_volume(sb, 0); 1602 1603 unlock_kernel(); 1604 1605 mlog_exit_void(); 1606 } 1607 1608 static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf) 1609 { 1610 struct ocfs2_super *osb; 1611 u32 numbits, freebits; 1612 int status; 1613 struct ocfs2_dinode *bm_lock; 1614 struct buffer_head *bh = NULL; 1615 struct inode *inode = NULL; 1616 1617 mlog_entry("(%p, %p)\n", dentry->d_sb, buf); 1618 1619 osb = OCFS2_SB(dentry->d_sb); 1620 1621 inode = ocfs2_get_system_file_inode(osb, 1622 GLOBAL_BITMAP_SYSTEM_INODE, 1623 OCFS2_INVALID_SLOT); 1624 if (!inode) { 1625 mlog(ML_ERROR, "failed to get bitmap inode\n"); 1626 status = -EIO; 1627 goto bail; 1628 } 1629 1630 status = ocfs2_inode_lock(inode, &bh, 0); 1631 if (status < 0) { 1632 mlog_errno(status); 1633 goto bail; 1634 } 1635 1636 bm_lock = (struct ocfs2_dinode *) bh->b_data; 1637 1638 numbits = le32_to_cpu(bm_lock->id1.bitmap1.i_total); 1639 freebits = numbits - le32_to_cpu(bm_lock->id1.bitmap1.i_used); 1640 1641 buf->f_type = OCFS2_SUPER_MAGIC; 1642 buf->f_bsize = dentry->d_sb->s_blocksize; 1643 buf->f_namelen = OCFS2_MAX_FILENAME_LEN; 1644 buf->f_blocks = ((sector_t) numbits) * 1645 (osb->s_clustersize >> osb->sb->s_blocksize_bits); 1646 buf->f_bfree = ((sector_t) freebits) * 1647 (osb->s_clustersize >> osb->sb->s_blocksize_bits); 1648 buf->f_bavail = buf->f_bfree; 1649 buf->f_files = numbits; 1650 buf->f_ffree = freebits; 1651 buf->f_fsid.val[0] = crc32_le(0, osb->uuid_str, OCFS2_VOL_UUID_LEN) 1652 & 0xFFFFFFFFUL; 1653 buf->f_fsid.val[1] = crc32_le(0, osb->uuid_str + OCFS2_VOL_UUID_LEN, 1654 OCFS2_VOL_UUID_LEN) & 0xFFFFFFFFUL; 1655 1656 brelse(bh); 1657 1658 ocfs2_inode_unlock(inode, 0); 1659 status = 0; 1660 bail: 1661 if (inode) 1662 iput(inode); 1663 1664 mlog_exit(status); 1665 1666 return status; 1667 } 1668 1669 static void ocfs2_inode_init_once(void *data) 1670 { 1671 struct ocfs2_inode_info *oi = data; 1672 1673 oi->ip_flags = 0; 1674 oi->ip_open_count = 0; 1675 spin_lock_init(&oi->ip_lock); 1676 ocfs2_extent_map_init(&oi->vfs_inode); 1677 INIT_LIST_HEAD(&oi->ip_io_markers); 1678 oi->ip_dir_start_lookup = 0; 1679 1680 init_rwsem(&oi->ip_alloc_sem); 1681 init_rwsem(&oi->ip_xattr_sem); 1682 mutex_init(&oi->ip_io_mutex); 1683 1684 oi->ip_blkno = 0ULL; 1685 oi->ip_clusters = 0; 1686 1687 ocfs2_lock_res_init_once(&oi->ip_rw_lockres); 1688 ocfs2_lock_res_init_once(&oi->ip_inode_lockres); 1689 ocfs2_lock_res_init_once(&oi->ip_open_lockres); 1690 1691 ocfs2_metadata_cache_init(INODE_CACHE(&oi->vfs_inode), 1692 &ocfs2_inode_caching_ops); 1693 1694 inode_init_once(&oi->vfs_inode); 1695 } 1696 1697 static int ocfs2_initialize_mem_caches(void) 1698 { 1699 ocfs2_inode_cachep = kmem_cache_create("ocfs2_inode_cache", 1700 sizeof(struct ocfs2_inode_info), 1701 0, 1702 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 1703 SLAB_MEM_SPREAD), 1704 ocfs2_inode_init_once); 1705 ocfs2_dquot_cachep = kmem_cache_create("ocfs2_dquot_cache", 1706 sizeof(struct ocfs2_dquot), 1707 0, 1708 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 1709 SLAB_MEM_SPREAD), 1710 NULL); 1711 ocfs2_qf_chunk_cachep = kmem_cache_create("ocfs2_qf_chunk_cache", 1712 sizeof(struct ocfs2_quota_chunk), 1713 0, 1714 (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD), 1715 NULL); 1716 if (!ocfs2_inode_cachep || !ocfs2_dquot_cachep || 1717 !ocfs2_qf_chunk_cachep) { 1718 if (ocfs2_inode_cachep) 1719 kmem_cache_destroy(ocfs2_inode_cachep); 1720 if (ocfs2_dquot_cachep) 1721 kmem_cache_destroy(ocfs2_dquot_cachep); 1722 if (ocfs2_qf_chunk_cachep) 1723 kmem_cache_destroy(ocfs2_qf_chunk_cachep); 1724 return -ENOMEM; 1725 } 1726 1727 return 0; 1728 } 1729 1730 static void ocfs2_free_mem_caches(void) 1731 { 1732 if (ocfs2_inode_cachep) 1733 kmem_cache_destroy(ocfs2_inode_cachep); 1734 ocfs2_inode_cachep = NULL; 1735 1736 if (ocfs2_dquot_cachep) 1737 kmem_cache_destroy(ocfs2_dquot_cachep); 1738 ocfs2_dquot_cachep = NULL; 1739 1740 if (ocfs2_qf_chunk_cachep) 1741 kmem_cache_destroy(ocfs2_qf_chunk_cachep); 1742 ocfs2_qf_chunk_cachep = NULL; 1743 } 1744 1745 static int ocfs2_get_sector(struct super_block *sb, 1746 struct buffer_head **bh, 1747 int block, 1748 int sect_size) 1749 { 1750 if (!sb_set_blocksize(sb, sect_size)) { 1751 mlog(ML_ERROR, "unable to set blocksize\n"); 1752 return -EIO; 1753 } 1754 1755 *bh = sb_getblk(sb, block); 1756 if (!*bh) { 1757 mlog_errno(-EIO); 1758 return -EIO; 1759 } 1760 lock_buffer(*bh); 1761 if (!buffer_dirty(*bh)) 1762 clear_buffer_uptodate(*bh); 1763 unlock_buffer(*bh); 1764 ll_rw_block(READ, 1, bh); 1765 wait_on_buffer(*bh); 1766 if (!buffer_uptodate(*bh)) { 1767 mlog_errno(-EIO); 1768 brelse(*bh); 1769 *bh = NULL; 1770 return -EIO; 1771 } 1772 1773 return 0; 1774 } 1775 1776 static int ocfs2_mount_volume(struct super_block *sb) 1777 { 1778 int status = 0; 1779 int unlock_super = 0; 1780 struct ocfs2_super *osb = OCFS2_SB(sb); 1781 1782 mlog_entry_void(); 1783 1784 if (ocfs2_is_hard_readonly(osb)) 1785 goto leave; 1786 1787 status = ocfs2_dlm_init(osb); 1788 if (status < 0) { 1789 mlog_errno(status); 1790 goto leave; 1791 } 1792 1793 status = ocfs2_super_lock(osb, 1); 1794 if (status < 0) { 1795 mlog_errno(status); 1796 goto leave; 1797 } 1798 unlock_super = 1; 1799 1800 /* This will load up the node map and add ourselves to it. */ 1801 status = ocfs2_find_slot(osb); 1802 if (status < 0) { 1803 mlog_errno(status); 1804 goto leave; 1805 } 1806 1807 /* load all node-local system inodes */ 1808 status = ocfs2_init_local_system_inodes(osb); 1809 if (status < 0) { 1810 mlog_errno(status); 1811 goto leave; 1812 } 1813 1814 status = ocfs2_check_volume(osb); 1815 if (status < 0) { 1816 mlog_errno(status); 1817 goto leave; 1818 } 1819 1820 status = ocfs2_truncate_log_init(osb); 1821 if (status < 0) 1822 mlog_errno(status); 1823 1824 leave: 1825 if (unlock_super) 1826 ocfs2_super_unlock(osb, 1); 1827 1828 mlog_exit(status); 1829 return status; 1830 } 1831 1832 static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err) 1833 { 1834 int tmp, hangup_needed = 0; 1835 struct ocfs2_super *osb = NULL; 1836 char nodestr[8]; 1837 1838 mlog_entry("(0x%p)\n", sb); 1839 1840 BUG_ON(!sb); 1841 osb = OCFS2_SB(sb); 1842 BUG_ON(!osb); 1843 1844 debugfs_remove(osb->osb_ctxt); 1845 1846 /* 1847 * Flush inode dropping work queue so that deletes are 1848 * performed while the filesystem is still working 1849 */ 1850 ocfs2_drop_all_dl_inodes(osb); 1851 1852 /* Orphan scan should be stopped as early as possible */ 1853 ocfs2_orphan_scan_stop(osb); 1854 1855 ocfs2_disable_quotas(osb); 1856 1857 ocfs2_shutdown_local_alloc(osb); 1858 1859 ocfs2_truncate_log_shutdown(osb); 1860 1861 /* This will disable recovery and flush any recovery work. */ 1862 ocfs2_recovery_exit(osb); 1863 1864 ocfs2_journal_shutdown(osb); 1865 1866 ocfs2_sync_blockdev(sb); 1867 1868 ocfs2_purge_refcount_trees(osb); 1869 1870 /* No cluster connection means we've failed during mount, so skip 1871 * all the steps which depended on that to complete. */ 1872 if (osb->cconn) { 1873 tmp = ocfs2_super_lock(osb, 1); 1874 if (tmp < 0) { 1875 mlog_errno(tmp); 1876 return; 1877 } 1878 } 1879 1880 if (osb->slot_num != OCFS2_INVALID_SLOT) 1881 ocfs2_put_slot(osb); 1882 1883 if (osb->cconn) 1884 ocfs2_super_unlock(osb, 1); 1885 1886 ocfs2_release_system_inodes(osb); 1887 1888 /* 1889 * If we're dismounting due to mount error, mount.ocfs2 will clean 1890 * up heartbeat. If we're a local mount, there is no heartbeat. 1891 * If we failed before we got a uuid_str yet, we can't stop 1892 * heartbeat. Otherwise, do it. 1893 */ 1894 if (!mnt_err && !ocfs2_mount_local(osb) && osb->uuid_str) 1895 hangup_needed = 1; 1896 1897 if (osb->cconn) 1898 ocfs2_dlm_shutdown(osb, hangup_needed); 1899 1900 ocfs2_blockcheck_stats_debugfs_remove(&osb->osb_ecc_stats); 1901 debugfs_remove(osb->osb_debug_root); 1902 1903 if (hangup_needed) 1904 ocfs2_cluster_hangup(osb->uuid_str, strlen(osb->uuid_str)); 1905 1906 atomic_set(&osb->vol_state, VOLUME_DISMOUNTED); 1907 1908 if (ocfs2_mount_local(osb)) 1909 snprintf(nodestr, sizeof(nodestr), "local"); 1910 else 1911 snprintf(nodestr, sizeof(nodestr), "%u", osb->node_num); 1912 1913 printk(KERN_INFO "ocfs2: Unmounting device (%s) on (node %s)\n", 1914 osb->dev_str, nodestr); 1915 1916 ocfs2_delete_osb(osb); 1917 kfree(osb); 1918 sb->s_dev = 0; 1919 sb->s_fs_info = NULL; 1920 } 1921 1922 static int ocfs2_setup_osb_uuid(struct ocfs2_super *osb, const unsigned char *uuid, 1923 unsigned uuid_bytes) 1924 { 1925 int i, ret; 1926 char *ptr; 1927 1928 BUG_ON(uuid_bytes != OCFS2_VOL_UUID_LEN); 1929 1930 osb->uuid_str = kzalloc(OCFS2_VOL_UUID_LEN * 2 + 1, GFP_KERNEL); 1931 if (osb->uuid_str == NULL) 1932 return -ENOMEM; 1933 1934 for (i = 0, ptr = osb->uuid_str; i < OCFS2_VOL_UUID_LEN; i++) { 1935 /* print with null */ 1936 ret = snprintf(ptr, 3, "%02X", uuid[i]); 1937 if (ret != 2) /* drop super cleans up */ 1938 return -EINVAL; 1939 /* then only advance past the last char */ 1940 ptr += 2; 1941 } 1942 1943 return 0; 1944 } 1945 1946 static int ocfs2_initialize_super(struct super_block *sb, 1947 struct buffer_head *bh, 1948 int sector_size, 1949 struct ocfs2_blockcheck_stats *stats) 1950 { 1951 int status; 1952 int i, cbits, bbits; 1953 struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data; 1954 struct inode *inode = NULL; 1955 struct ocfs2_journal *journal; 1956 __le32 uuid_net_key; 1957 struct ocfs2_super *osb; 1958 1959 mlog_entry_void(); 1960 1961 osb = kzalloc(sizeof(struct ocfs2_super), GFP_KERNEL); 1962 if (!osb) { 1963 status = -ENOMEM; 1964 mlog_errno(status); 1965 goto bail; 1966 } 1967 1968 sb->s_fs_info = osb; 1969 sb->s_op = &ocfs2_sops; 1970 sb->s_export_op = &ocfs2_export_ops; 1971 sb->s_qcop = &ocfs2_quotactl_ops; 1972 sb->dq_op = &ocfs2_quota_operations; 1973 sb->s_xattr = ocfs2_xattr_handlers; 1974 sb->s_time_gran = 1; 1975 sb->s_flags |= MS_NOATIME; 1976 /* this is needed to support O_LARGEFILE */ 1977 cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits); 1978 bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits); 1979 sb->s_maxbytes = ocfs2_max_file_offset(bbits, cbits); 1980 1981 osb->osb_dx_mask = (1 << (cbits - bbits)) - 1; 1982 1983 for (i = 0; i < 3; i++) 1984 osb->osb_dx_seed[i] = le32_to_cpu(di->id2.i_super.s_dx_seed[i]); 1985 osb->osb_dx_seed[3] = le32_to_cpu(di->id2.i_super.s_uuid_hash); 1986 1987 osb->sb = sb; 1988 /* Save off for ocfs2_rw_direct */ 1989 osb->s_sectsize_bits = blksize_bits(sector_size); 1990 BUG_ON(!osb->s_sectsize_bits); 1991 1992 spin_lock_init(&osb->dc_task_lock); 1993 init_waitqueue_head(&osb->dc_event); 1994 osb->dc_work_sequence = 0; 1995 osb->dc_wake_sequence = 0; 1996 INIT_LIST_HEAD(&osb->blocked_lock_list); 1997 osb->blocked_lock_count = 0; 1998 spin_lock_init(&osb->osb_lock); 1999 spin_lock_init(&osb->osb_xattr_lock); 2000 ocfs2_init_inode_steal_slot(osb); 2001 2002 atomic_set(&osb->alloc_stats.moves, 0); 2003 atomic_set(&osb->alloc_stats.local_data, 0); 2004 atomic_set(&osb->alloc_stats.bitmap_data, 0); 2005 atomic_set(&osb->alloc_stats.bg_allocs, 0); 2006 atomic_set(&osb->alloc_stats.bg_extends, 0); 2007 2008 /* Copy the blockcheck stats from the superblock probe */ 2009 osb->osb_ecc_stats = *stats; 2010 2011 ocfs2_init_node_maps(osb); 2012 2013 snprintf(osb->dev_str, sizeof(osb->dev_str), "%u,%u", 2014 MAJOR(osb->sb->s_dev), MINOR(osb->sb->s_dev)); 2015 2016 ocfs2_orphan_scan_init(osb); 2017 2018 status = ocfs2_recovery_init(osb); 2019 if (status) { 2020 mlog(ML_ERROR, "Unable to initialize recovery state\n"); 2021 mlog_errno(status); 2022 goto bail; 2023 } 2024 2025 init_waitqueue_head(&osb->checkpoint_event); 2026 atomic_set(&osb->needs_checkpoint, 0); 2027 2028 osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM; 2029 2030 osb->slot_num = OCFS2_INVALID_SLOT; 2031 2032 osb->s_xattr_inline_size = le16_to_cpu( 2033 di->id2.i_super.s_xattr_inline_size); 2034 2035 osb->local_alloc_state = OCFS2_LA_UNUSED; 2036 osb->local_alloc_bh = NULL; 2037 INIT_DELAYED_WORK(&osb->la_enable_wq, ocfs2_la_enable_worker); 2038 2039 init_waitqueue_head(&osb->osb_mount_event); 2040 2041 osb->vol_label = kmalloc(OCFS2_MAX_VOL_LABEL_LEN, GFP_KERNEL); 2042 if (!osb->vol_label) { 2043 mlog(ML_ERROR, "unable to alloc vol label\n"); 2044 status = -ENOMEM; 2045 goto bail; 2046 } 2047 2048 osb->max_slots = le16_to_cpu(di->id2.i_super.s_max_slots); 2049 if (osb->max_slots > OCFS2_MAX_SLOTS || osb->max_slots == 0) { 2050 mlog(ML_ERROR, "Invalid number of node slots (%u)\n", 2051 osb->max_slots); 2052 status = -EINVAL; 2053 goto bail; 2054 } 2055 mlog(0, "max_slots for this device: %u\n", osb->max_slots); 2056 2057 osb->slot_recovery_generations = 2058 kcalloc(osb->max_slots, sizeof(*osb->slot_recovery_generations), 2059 GFP_KERNEL); 2060 if (!osb->slot_recovery_generations) { 2061 status = -ENOMEM; 2062 mlog_errno(status); 2063 goto bail; 2064 } 2065 2066 init_waitqueue_head(&osb->osb_wipe_event); 2067 osb->osb_orphan_wipes = kcalloc(osb->max_slots, 2068 sizeof(*osb->osb_orphan_wipes), 2069 GFP_KERNEL); 2070 if (!osb->osb_orphan_wipes) { 2071 status = -ENOMEM; 2072 mlog_errno(status); 2073 goto bail; 2074 } 2075 2076 osb->osb_rf_lock_tree = RB_ROOT; 2077 2078 osb->s_feature_compat = 2079 le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_compat); 2080 osb->s_feature_ro_compat = 2081 le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_ro_compat); 2082 osb->s_feature_incompat = 2083 le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_incompat); 2084 2085 if ((i = OCFS2_HAS_INCOMPAT_FEATURE(osb->sb, ~OCFS2_FEATURE_INCOMPAT_SUPP))) { 2086 mlog(ML_ERROR, "couldn't mount because of unsupported " 2087 "optional features (%x).\n", i); 2088 status = -EINVAL; 2089 goto bail; 2090 } 2091 if (!(osb->sb->s_flags & MS_RDONLY) && 2092 (i = OCFS2_HAS_RO_COMPAT_FEATURE(osb->sb, ~OCFS2_FEATURE_RO_COMPAT_SUPP))) { 2093 mlog(ML_ERROR, "couldn't mount RDWR because of " 2094 "unsupported optional features (%x).\n", i); 2095 status = -EINVAL; 2096 goto bail; 2097 } 2098 2099 if (ocfs2_userspace_stack(osb)) { 2100 memcpy(osb->osb_cluster_stack, 2101 OCFS2_RAW_SB(di)->s_cluster_info.ci_stack, 2102 OCFS2_STACK_LABEL_LEN); 2103 osb->osb_cluster_stack[OCFS2_STACK_LABEL_LEN] = '\0'; 2104 if (strlen(osb->osb_cluster_stack) != OCFS2_STACK_LABEL_LEN) { 2105 mlog(ML_ERROR, 2106 "couldn't mount because of an invalid " 2107 "cluster stack label (%s) \n", 2108 osb->osb_cluster_stack); 2109 status = -EINVAL; 2110 goto bail; 2111 } 2112 } else { 2113 /* The empty string is identical with classic tools that 2114 * don't know about s_cluster_info. */ 2115 osb->osb_cluster_stack[0] = '\0'; 2116 } 2117 2118 get_random_bytes(&osb->s_next_generation, sizeof(u32)); 2119 2120 /* FIXME 2121 * This should be done in ocfs2_journal_init(), but unknown 2122 * ordering issues will cause the filesystem to crash. 2123 * If anyone wants to figure out what part of the code 2124 * refers to osb->journal before ocfs2_journal_init() is run, 2125 * be my guest. 2126 */ 2127 /* initialize our journal structure */ 2128 2129 journal = kzalloc(sizeof(struct ocfs2_journal), GFP_KERNEL); 2130 if (!journal) { 2131 mlog(ML_ERROR, "unable to alloc journal\n"); 2132 status = -ENOMEM; 2133 goto bail; 2134 } 2135 osb->journal = journal; 2136 journal->j_osb = osb; 2137 2138 atomic_set(&journal->j_num_trans, 0); 2139 init_rwsem(&journal->j_trans_barrier); 2140 init_waitqueue_head(&journal->j_checkpointed); 2141 spin_lock_init(&journal->j_lock); 2142 journal->j_trans_id = (unsigned long) 1; 2143 INIT_LIST_HEAD(&journal->j_la_cleanups); 2144 INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery); 2145 journal->j_state = OCFS2_JOURNAL_FREE; 2146 2147 INIT_WORK(&osb->dentry_lock_work, ocfs2_drop_dl_inodes); 2148 osb->dentry_lock_list = NULL; 2149 2150 /* get some pseudo constants for clustersize bits */ 2151 osb->s_clustersize_bits = 2152 le32_to_cpu(di->id2.i_super.s_clustersize_bits); 2153 osb->s_clustersize = 1 << osb->s_clustersize_bits; 2154 mlog(0, "clusterbits=%d\n", osb->s_clustersize_bits); 2155 2156 if (osb->s_clustersize < OCFS2_MIN_CLUSTERSIZE || 2157 osb->s_clustersize > OCFS2_MAX_CLUSTERSIZE) { 2158 mlog(ML_ERROR, "Volume has invalid cluster size (%d)\n", 2159 osb->s_clustersize); 2160 status = -EINVAL; 2161 goto bail; 2162 } 2163 2164 if (ocfs2_clusters_to_blocks(osb->sb, le32_to_cpu(di->i_clusters) - 1) 2165 > (u32)~0UL) { 2166 mlog(ML_ERROR, "Volume might try to write to blocks beyond " 2167 "what jbd can address in 32 bits.\n"); 2168 status = -EINVAL; 2169 goto bail; 2170 } 2171 2172 if (ocfs2_setup_osb_uuid(osb, di->id2.i_super.s_uuid, 2173 sizeof(di->id2.i_super.s_uuid))) { 2174 mlog(ML_ERROR, "Out of memory trying to setup our uuid.\n"); 2175 status = -ENOMEM; 2176 goto bail; 2177 } 2178 2179 memcpy(&uuid_net_key, di->id2.i_super.s_uuid, sizeof(uuid_net_key)); 2180 2181 strncpy(osb->vol_label, di->id2.i_super.s_label, 63); 2182 osb->vol_label[63] = '\0'; 2183 osb->root_blkno = le64_to_cpu(di->id2.i_super.s_root_blkno); 2184 osb->system_dir_blkno = le64_to_cpu(di->id2.i_super.s_system_dir_blkno); 2185 osb->first_cluster_group_blkno = 2186 le64_to_cpu(di->id2.i_super.s_first_cluster_group); 2187 osb->fs_generation = le32_to_cpu(di->i_fs_generation); 2188 osb->uuid_hash = le32_to_cpu(di->id2.i_super.s_uuid_hash); 2189 mlog(0, "vol_label: %s\n", osb->vol_label); 2190 mlog(0, "uuid: %s\n", osb->uuid_str); 2191 mlog(0, "root_blkno=%llu, system_dir_blkno=%llu\n", 2192 (unsigned long long)osb->root_blkno, 2193 (unsigned long long)osb->system_dir_blkno); 2194 2195 osb->osb_dlm_debug = ocfs2_new_dlm_debug(); 2196 if (!osb->osb_dlm_debug) { 2197 status = -ENOMEM; 2198 mlog_errno(status); 2199 goto bail; 2200 } 2201 2202 atomic_set(&osb->vol_state, VOLUME_INIT); 2203 2204 /* load root, system_dir, and all global system inodes */ 2205 status = ocfs2_init_global_system_inodes(osb); 2206 if (status < 0) { 2207 mlog_errno(status); 2208 goto bail; 2209 } 2210 2211 /* 2212 * global bitmap 2213 */ 2214 inode = ocfs2_get_system_file_inode(osb, GLOBAL_BITMAP_SYSTEM_INODE, 2215 OCFS2_INVALID_SLOT); 2216 if (!inode) { 2217 status = -EINVAL; 2218 mlog_errno(status); 2219 goto bail; 2220 } 2221 2222 osb->bitmap_blkno = OCFS2_I(inode)->ip_blkno; 2223 iput(inode); 2224 2225 osb->bitmap_cpg = ocfs2_group_bitmap_size(sb) * 8; 2226 2227 status = ocfs2_init_slot_info(osb); 2228 if (status < 0) { 2229 mlog_errno(status); 2230 goto bail; 2231 } 2232 2233 bail: 2234 mlog_exit(status); 2235 return status; 2236 } 2237 2238 /* 2239 * will return: -EAGAIN if it is ok to keep searching for superblocks 2240 * -EINVAL if there is a bad superblock 2241 * 0 on success 2242 */ 2243 static int ocfs2_verify_volume(struct ocfs2_dinode *di, 2244 struct buffer_head *bh, 2245 u32 blksz, 2246 struct ocfs2_blockcheck_stats *stats) 2247 { 2248 int status = -EAGAIN; 2249 2250 mlog_entry_void(); 2251 2252 if (memcmp(di->i_signature, OCFS2_SUPER_BLOCK_SIGNATURE, 2253 strlen(OCFS2_SUPER_BLOCK_SIGNATURE)) == 0) { 2254 /* We have to do a raw check of the feature here */ 2255 if (le32_to_cpu(di->id2.i_super.s_feature_incompat) & 2256 OCFS2_FEATURE_INCOMPAT_META_ECC) { 2257 status = ocfs2_block_check_validate(bh->b_data, 2258 bh->b_size, 2259 &di->i_check, 2260 stats); 2261 if (status) 2262 goto out; 2263 } 2264 status = -EINVAL; 2265 if ((1 << le32_to_cpu(di->id2.i_super.s_blocksize_bits)) != blksz) { 2266 mlog(ML_ERROR, "found superblock with incorrect block " 2267 "size: found %u, should be %u\n", 2268 1 << le32_to_cpu(di->id2.i_super.s_blocksize_bits), 2269 blksz); 2270 } else if (le16_to_cpu(di->id2.i_super.s_major_rev_level) != 2271 OCFS2_MAJOR_REV_LEVEL || 2272 le16_to_cpu(di->id2.i_super.s_minor_rev_level) != 2273 OCFS2_MINOR_REV_LEVEL) { 2274 mlog(ML_ERROR, "found superblock with bad version: " 2275 "found %u.%u, should be %u.%u\n", 2276 le16_to_cpu(di->id2.i_super.s_major_rev_level), 2277 le16_to_cpu(di->id2.i_super.s_minor_rev_level), 2278 OCFS2_MAJOR_REV_LEVEL, 2279 OCFS2_MINOR_REV_LEVEL); 2280 } else if (bh->b_blocknr != le64_to_cpu(di->i_blkno)) { 2281 mlog(ML_ERROR, "bad block number on superblock: " 2282 "found %llu, should be %llu\n", 2283 (unsigned long long)le64_to_cpu(di->i_blkno), 2284 (unsigned long long)bh->b_blocknr); 2285 } else if (le32_to_cpu(di->id2.i_super.s_clustersize_bits) < 12 || 2286 le32_to_cpu(di->id2.i_super.s_clustersize_bits) > 20) { 2287 mlog(ML_ERROR, "bad cluster size found: %u\n", 2288 1 << le32_to_cpu(di->id2.i_super.s_clustersize_bits)); 2289 } else if (!le64_to_cpu(di->id2.i_super.s_root_blkno)) { 2290 mlog(ML_ERROR, "bad root_blkno: 0\n"); 2291 } else if (!le64_to_cpu(di->id2.i_super.s_system_dir_blkno)) { 2292 mlog(ML_ERROR, "bad system_dir_blkno: 0\n"); 2293 } else if (le16_to_cpu(di->id2.i_super.s_max_slots) > OCFS2_MAX_SLOTS) { 2294 mlog(ML_ERROR, 2295 "Superblock slots found greater than file system " 2296 "maximum: found %u, max %u\n", 2297 le16_to_cpu(di->id2.i_super.s_max_slots), 2298 OCFS2_MAX_SLOTS); 2299 } else { 2300 /* found it! */ 2301 status = 0; 2302 } 2303 } 2304 2305 out: 2306 mlog_exit(status); 2307 return status; 2308 } 2309 2310 static int ocfs2_check_volume(struct ocfs2_super *osb) 2311 { 2312 int status; 2313 int dirty; 2314 int local; 2315 struct ocfs2_dinode *local_alloc = NULL; /* only used if we 2316 * recover 2317 * ourselves. */ 2318 2319 mlog_entry_void(); 2320 2321 /* Init our journal object. */ 2322 status = ocfs2_journal_init(osb->journal, &dirty); 2323 if (status < 0) { 2324 mlog(ML_ERROR, "Could not initialize journal!\n"); 2325 goto finally; 2326 } 2327 2328 /* If the journal was unmounted cleanly then we don't want to 2329 * recover anything. Otherwise, journal_load will do that 2330 * dirty work for us :) */ 2331 if (!dirty) { 2332 status = ocfs2_journal_wipe(osb->journal, 0); 2333 if (status < 0) { 2334 mlog_errno(status); 2335 goto finally; 2336 } 2337 } else { 2338 mlog(ML_NOTICE, "File system was not unmounted cleanly, " 2339 "recovering volume.\n"); 2340 } 2341 2342 local = ocfs2_mount_local(osb); 2343 2344 /* will play back anything left in the journal. */ 2345 status = ocfs2_journal_load(osb->journal, local, dirty); 2346 if (status < 0) { 2347 mlog(ML_ERROR, "ocfs2 journal load failed! %d\n", status); 2348 goto finally; 2349 } 2350 2351 if (dirty) { 2352 /* recover my local alloc if we didn't unmount cleanly. */ 2353 status = ocfs2_begin_local_alloc_recovery(osb, 2354 osb->slot_num, 2355 &local_alloc); 2356 if (status < 0) { 2357 mlog_errno(status); 2358 goto finally; 2359 } 2360 /* we complete the recovery process after we've marked 2361 * ourselves as mounted. */ 2362 } 2363 2364 mlog(0, "Journal loaded.\n"); 2365 2366 status = ocfs2_load_local_alloc(osb); 2367 if (status < 0) { 2368 mlog_errno(status); 2369 goto finally; 2370 } 2371 2372 if (dirty) { 2373 /* Recovery will be completed after we've mounted the 2374 * rest of the volume. */ 2375 osb->dirty = 1; 2376 osb->local_alloc_copy = local_alloc; 2377 local_alloc = NULL; 2378 } 2379 2380 /* go through each journal, trylock it and if you get the 2381 * lock, and it's marked as dirty, set the bit in the recover 2382 * map and launch a recovery thread for it. */ 2383 status = ocfs2_mark_dead_nodes(osb); 2384 if (status < 0) { 2385 mlog_errno(status); 2386 goto finally; 2387 } 2388 2389 status = ocfs2_compute_replay_slots(osb); 2390 if (status < 0) 2391 mlog_errno(status); 2392 2393 finally: 2394 if (local_alloc) 2395 kfree(local_alloc); 2396 2397 mlog_exit(status); 2398 return status; 2399 } 2400 2401 /* 2402 * The routine gets called from dismount or close whenever a dismount on 2403 * volume is requested and the osb open count becomes 1. 2404 * It will remove the osb from the global list and also free up all the 2405 * initialized resources and fileobject. 2406 */ 2407 static void ocfs2_delete_osb(struct ocfs2_super *osb) 2408 { 2409 mlog_entry_void(); 2410 2411 /* This function assumes that the caller has the main osb resource */ 2412 2413 ocfs2_free_slot_info(osb); 2414 2415 kfree(osb->osb_orphan_wipes); 2416 kfree(osb->slot_recovery_generations); 2417 /* FIXME 2418 * This belongs in journal shutdown, but because we have to 2419 * allocate osb->journal at the start of ocfs2_initalize_osb(), 2420 * we free it here. 2421 */ 2422 kfree(osb->journal); 2423 if (osb->local_alloc_copy) 2424 kfree(osb->local_alloc_copy); 2425 kfree(osb->uuid_str); 2426 ocfs2_put_dlm_debug(osb->osb_dlm_debug); 2427 memset(osb, 0, sizeof(struct ocfs2_super)); 2428 2429 mlog_exit_void(); 2430 } 2431 2432 /* Put OCFS2 into a readonly state, or (if the user specifies it), 2433 * panic(). We do not support continue-on-error operation. */ 2434 static void ocfs2_handle_error(struct super_block *sb) 2435 { 2436 struct ocfs2_super *osb = OCFS2_SB(sb); 2437 2438 if (osb->s_mount_opt & OCFS2_MOUNT_ERRORS_PANIC) 2439 panic("OCFS2: (device %s): panic forced after error\n", 2440 sb->s_id); 2441 2442 ocfs2_set_osb_flag(osb, OCFS2_OSB_ERROR_FS); 2443 2444 if (sb->s_flags & MS_RDONLY && 2445 (ocfs2_is_soft_readonly(osb) || 2446 ocfs2_is_hard_readonly(osb))) 2447 return; 2448 2449 printk(KERN_CRIT "File system is now read-only due to the potential " 2450 "of on-disk corruption. Please run fsck.ocfs2 once the file " 2451 "system is unmounted.\n"); 2452 sb->s_flags |= MS_RDONLY; 2453 ocfs2_set_ro_flag(osb, 0); 2454 } 2455 2456 static char error_buf[1024]; 2457 2458 void __ocfs2_error(struct super_block *sb, 2459 const char *function, 2460 const char *fmt, ...) 2461 { 2462 va_list args; 2463 2464 va_start(args, fmt); 2465 vsnprintf(error_buf, sizeof(error_buf), fmt, args); 2466 va_end(args); 2467 2468 /* Not using mlog here because we want to show the actual 2469 * function the error came from. */ 2470 printk(KERN_CRIT "OCFS2: ERROR (device %s): %s: %s\n", 2471 sb->s_id, function, error_buf); 2472 2473 ocfs2_handle_error(sb); 2474 } 2475 2476 /* Handle critical errors. This is intentionally more drastic than 2477 * ocfs2_handle_error, so we only use for things like journal errors, 2478 * etc. */ 2479 void __ocfs2_abort(struct super_block* sb, 2480 const char *function, 2481 const char *fmt, ...) 2482 { 2483 va_list args; 2484 2485 va_start(args, fmt); 2486 vsnprintf(error_buf, sizeof(error_buf), fmt, args); 2487 va_end(args); 2488 2489 printk(KERN_CRIT "OCFS2: abort (device %s): %s: %s\n", 2490 sb->s_id, function, error_buf); 2491 2492 /* We don't have the cluster support yet to go straight to 2493 * hard readonly in here. Until then, we want to keep 2494 * ocfs2_abort() so that we can at least mark critical 2495 * errors. 2496 * 2497 * TODO: This should abort the journal and alert other nodes 2498 * that our slot needs recovery. */ 2499 2500 /* Force a panic(). This stinks, but it's better than letting 2501 * things continue without having a proper hard readonly 2502 * here. */ 2503 if (!ocfs2_mount_local(OCFS2_SB(sb))) 2504 OCFS2_SB(sb)->s_mount_opt |= OCFS2_MOUNT_ERRORS_PANIC; 2505 ocfs2_handle_error(sb); 2506 } 2507 2508 module_init(ocfs2_init); 2509 module_exit(ocfs2_exit); 2510