SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/ocfs2/super.c

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