git.oblomov.eu Git - linux-2.6/blob - fs/gfs2/ops_fstype.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
   4  *
   5  * This copyrighted material is made available to anyone wishing to use,
   6  * modify, copy, or redistribute it subject to the terms and conditions
   7  * of the GNU General Public License version 2.
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/slab.h>
  12 #include <linux/spinlock.h>
  13 #include <linux/completion.h>
  14 #include <linux/buffer_head.h>
  15 #include <linux/blkdev.h>
  16 #include <linux/kthread.h>
  17 #include <linux/namei.h>
  18 #include <linux/mount.h>
  19 #include <linux/gfs2_ondisk.h>
  20 #include <linux/lm_interface.h>
  21
  22 #include "gfs2.h"
  23 #include "incore.h"
  24 #include "bmap.h"
  25 #include "daemon.h"
  26 #include "glock.h"
  27 #include "glops.h"
  28 #include "inode.h"
  29 #include "mount.h"
  30 #include "recovery.h"
  31 #include "rgrp.h"
  32 #include "super.h"
  33 #include "sys.h"
  34 #include "util.h"
  35 #include "log.h"
  36
  37 #define DO 0
  38 #define UNDO 1
  39
  40 static const u32 gfs2_old_fs_formats[] = {
  41         0
  42 };
  43
  44 static const u32 gfs2_old_multihost_formats[] = {
  45         0
  46 };
  47
  48 /**
  49  * gfs2_tune_init - Fill a gfs2_tune structure with default values
  50  * @gt: tune
  51  *
  52  */
  53
  54 static void gfs2_tune_init(struct gfs2_tune *gt)
  55 {
  56         spin_lock_init(&gt->gt_spin);
  57
  58         gt->gt_demote_secs = 300;
  59         gt->gt_incore_log_blocks = 1024;
  60         gt->gt_log_flush_secs = 60;
  61         gt->gt_recoverd_secs = 60;
  62         gt->gt_logd_secs = 1;
  63         gt->gt_quota_simul_sync = 64;
  64         gt->gt_quota_warn_period = 10;
  65         gt->gt_quota_scale_num = 1;
  66         gt->gt_quota_scale_den = 1;
  67         gt->gt_quota_cache_secs = 300;
  68         gt->gt_quota_quantum = 60;
  69         gt->gt_new_files_jdata = 0;
  70         gt->gt_max_readahead = 1 << 18;
  71         gt->gt_stall_secs = 600;
  72         gt->gt_complain_secs = 10;
  73         gt->gt_statfs_quantum = 30;
  74         gt->gt_statfs_slow = 0;
  75 }
  76
  77 static struct gfs2_sbd *init_sbd(struct super_block *sb)
  78 {
  79         struct gfs2_sbd *sdp;
  80
  81         sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
  82         if (!sdp)
  83                 return NULL;
  84
  85         sb->s_fs_info = sdp;
  86         sdp->sd_vfs = sb;
  87
  88         gfs2_tune_init(&sdp->sd_tune);
  89
  90         INIT_LIST_HEAD(&sdp->sd_reclaim_list);
  91         spin_lock_init(&sdp->sd_reclaim_lock);
  92         init_waitqueue_head(&sdp->sd_reclaim_wq);
  93
  94         mutex_init(&sdp->sd_inum_mutex);
  95         spin_lock_init(&sdp->sd_statfs_spin);
  96
  97         spin_lock_init(&sdp->sd_rindex_spin);
  98         mutex_init(&sdp->sd_rindex_mutex);
  99         INIT_LIST_HEAD(&sdp->sd_rindex_list);
 100         INIT_LIST_HEAD(&sdp->sd_rindex_mru_list);
 101
 102         INIT_LIST_HEAD(&sdp->sd_jindex_list);
 103         spin_lock_init(&sdp->sd_jindex_spin);
 104         mutex_init(&sdp->sd_jindex_mutex);
 105
 106         INIT_LIST_HEAD(&sdp->sd_quota_list);
 107         spin_lock_init(&sdp->sd_quota_spin);
 108         mutex_init(&sdp->sd_quota_mutex);
 109         init_waitqueue_head(&sdp->sd_quota_wait);
 110
 111         spin_lock_init(&sdp->sd_log_lock);
 112
 113         INIT_LIST_HEAD(&sdp->sd_log_le_buf);
 114         INIT_LIST_HEAD(&sdp->sd_log_le_revoke);
 115         INIT_LIST_HEAD(&sdp->sd_log_le_rg);
 116         INIT_LIST_HEAD(&sdp->sd_log_le_databuf);
 117         INIT_LIST_HEAD(&sdp->sd_log_le_ordered);
 118
 119         mutex_init(&sdp->sd_log_reserve_mutex);
 120         INIT_LIST_HEAD(&sdp->sd_ail1_list);
 121         INIT_LIST_HEAD(&sdp->sd_ail2_list);
 122
 123         init_rwsem(&sdp->sd_log_flush_lock);
 124         atomic_set(&sdp->sd_log_in_flight, 0);
 125         init_waitqueue_head(&sdp->sd_log_flush_wait);
 126
 127         INIT_LIST_HEAD(&sdp->sd_revoke_list);
 128
 129         mutex_init(&sdp->sd_freeze_lock);
 130
 131         return sdp;
 132 }
 133
 134
 135 /**
 136  * gfs2_check_sb - Check superblock
 137  * @sdp: the filesystem
 138  * @sb: The superblock
 139  * @silent: Don't print a message if the check fails
 140  *
 141  * Checks the version code of the FS is one that we understand how to
 142  * read and that the sizes of the various on-disk structures have not
 143  * changed.
 144  */
 145
 146 static int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb_host *sb, int silent)
 147 {
 148         unsigned int x;
 149
 150         if (sb->sb_magic != GFS2_MAGIC ||
 151             sb->sb_type != GFS2_METATYPE_SB) {
 152                 if (!silent)
 153                         printk(KERN_WARNING "GFS2: not a GFS2 filesystem\n");
 154                 return -EINVAL;
 155         }
 156
 157         /*  If format numbers match exactly, we're done.  */
 158
 159         if (sb->sb_fs_format == GFS2_FORMAT_FS &&
 160             sb->sb_multihost_format == GFS2_FORMAT_MULTI)
 161                 return 0;
 162
 163         if (sb->sb_fs_format != GFS2_FORMAT_FS) {
 164                 for (x = 0; gfs2_old_fs_formats[x]; x++)
 165                         if (gfs2_old_fs_formats[x] == sb->sb_fs_format)
 166                                 break;
 167
 168                 if (!gfs2_old_fs_formats[x]) {
 169                         printk(KERN_WARNING
 170                                "GFS2: code version (%u, %u) is incompatible "
 171                                "with ondisk format (%u, %u)\n",
 172                                GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
 173                                sb->sb_fs_format, sb->sb_multihost_format);
 174                         printk(KERN_WARNING
 175                                "GFS2: I don't know how to upgrade this FS\n");
 176                         return -EINVAL;
 177                 }
 178         }
 179
 180         if (sb->sb_multihost_format != GFS2_FORMAT_MULTI) {
 181                 for (x = 0; gfs2_old_multihost_formats[x]; x++)
 182                         if (gfs2_old_multihost_formats[x] ==
 183                             sb->sb_multihost_format)
 184                                 break;
 185
 186                 if (!gfs2_old_multihost_formats[x]) {
 187                         printk(KERN_WARNING
 188                                "GFS2: code version (%u, %u) is incompatible "
 189                                "with ondisk format (%u, %u)\n",
 190                                GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
 191                                sb->sb_fs_format, sb->sb_multihost_format);
 192                         printk(KERN_WARNING
 193                                "GFS2: I don't know how to upgrade this FS\n");
 194                         return -EINVAL;
 195                 }
 196         }
 197
 198         if (!sdp->sd_args.ar_upgrade) {
 199                 printk(KERN_WARNING
 200                        "GFS2: code version (%u, %u) is incompatible "
 201                        "with ondisk format (%u, %u)\n",
 202                        GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
 203                        sb->sb_fs_format, sb->sb_multihost_format);
 204                 printk(KERN_INFO
 205                        "GFS2: Use the \"upgrade\" mount option to upgrade "
 206                        "the FS\n");
 207                 printk(KERN_INFO "GFS2: See the manual for more details\n");
 208                 return -EINVAL;
 209         }
 210
 211         return 0;
 212 }
 213
 214 static void end_bio_io_page(struct bio *bio, int error)
 215 {
 216         struct page *page = bio->bi_private;
 217
 218         if (!error)
 219                 SetPageUptodate(page);
 220         else
 221                 printk(KERN_WARNING "gfs2: error %d reading superblock\n", error);
 222         unlock_page(page);
 223 }
 224
 225 static void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)
 226 {
 227         const struct gfs2_sb *str = buf;
 228
 229         sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
 230         sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
 231         sb->sb_format = be32_to_cpu(str->sb_header.mh_format);
 232         sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
 233         sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
 234         sb->sb_bsize = be32_to_cpu(str->sb_bsize);
 235         sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
 236         sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
 237         sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
 238         sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
 239         sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
 240
 241         memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
 242         memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
 243 }
 244
 245 /**
 246  * gfs2_read_super - Read the gfs2 super block from disk
 247  * @sdp: The GFS2 super block
 248  * @sector: The location of the super block
 249  * @error: The error code to return
 250  *
 251  * This uses the bio functions to read the super block from disk
 252  * because we want to be 100% sure that we never read cached data.
 253  * A super block is read twice only during each GFS2 mount and is
 254  * never written to by the filesystem. The first time its read no
 255  * locks are held, and the only details which are looked at are those
 256  * relating to the locking protocol. Once locking is up and working,
 257  * the sb is read again under the lock to establish the location of
 258  * the master directory (contains pointers to journals etc) and the
 259  * root directory.
 260  *
 261  * Returns: 0 on success or error
 262  */
 263
 264 static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector)
 265 {
 266         struct super_block *sb = sdp->sd_vfs;
 267         struct gfs2_sb *p;
 268         struct page *page;
 269         struct bio *bio;
 270
 271         page = alloc_page(GFP_NOFS);
 272         if (unlikely(!page))
 273                 return -ENOBUFS;
 274
 275         ClearPageUptodate(page);
 276         ClearPageDirty(page);
 277         lock_page(page);
 278
 279         bio = bio_alloc(GFP_NOFS, 1);
 280         if (unlikely(!bio)) {
 281                 __free_page(page);
 282                 return -ENOBUFS;
 283         }
 284
 285         bio->bi_sector = sector * (sb->s_blocksize >> 9);
 286         bio->bi_bdev = sb->s_bdev;
 287         bio_add_page(bio, page, PAGE_SIZE, 0);
 288
 289         bio->bi_end_io = end_bio_io_page;
 290         bio->bi_private = page;
 291         submit_bio(READ_SYNC | (1 << BIO_RW_META), bio);
 292         wait_on_page_locked(page);
 293         bio_put(bio);
 294         if (!PageUptodate(page)) {
 295                 __free_page(page);
 296                 return -EIO;
 297         }
 298         p = kmap(page);
 299         gfs2_sb_in(&sdp->sd_sb, p);
 300         kunmap(page);
 301         __free_page(page);
 302         return 0;
 303 }
 304 /**
 305  * gfs2_read_sb - Read super block
 306  * @sdp: The GFS2 superblock
 307  * @gl: the glock for the superblock (assumed to be held)
 308  * @silent: Don't print message if mount fails
 309  *
 310  */
 311
 312 static int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent)
 313 {
 314         u32 hash_blocks, ind_blocks, leaf_blocks;
 315         u32 tmp_blocks;
 316         unsigned int x;
 317         int error;
 318
 319         error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
 320         if (error) {
 321                 if (!silent)
 322                         fs_err(sdp, "can't read superblock\n");
 323                 return error;
 324         }
 325
 326         error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
 327         if (error)
 328                 return error;
 329
 330         sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
 331                                GFS2_BASIC_BLOCK_SHIFT;
 332         sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
 333         sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
 334                           sizeof(struct gfs2_dinode)) / sizeof(u64);
 335         sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
 336                           sizeof(struct gfs2_meta_header)) / sizeof(u64);
 337         sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
 338         sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
 339         sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
 340         sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
 341         sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
 342                                 sizeof(struct gfs2_meta_header)) /
 343                                 sizeof(struct gfs2_quota_change);
 344
 345         /* Compute maximum reservation required to add a entry to a directory */
 346
 347         hash_blocks = DIV_ROUND_UP(sizeof(u64) * (1 << GFS2_DIR_MAX_DEPTH),
 348                              sdp->sd_jbsize);
 349
 350         ind_blocks = 0;
 351         for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
 352                 tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
 353                 ind_blocks += tmp_blocks;
 354         }
 355
 356         leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
 357
 358         sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
 359
 360         sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
 361                                 sizeof(struct gfs2_dinode);
 362         sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
 363         for (x = 2;; x++) {
 364                 u64 space, d;
 365                 u32 m;
 366
 367                 space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
 368                 d = space;
 369                 m = do_div(d, sdp->sd_inptrs);
 370
 371                 if (d != sdp->sd_heightsize[x - 1] || m)
 372                         break;
 373                 sdp->sd_heightsize[x] = space;
 374         }
 375         sdp->sd_max_height = x;
 376         sdp->sd_heightsize[x] = ~0;
 377         gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
 378
 379         sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize -
 380                                  sizeof(struct gfs2_dinode);
 381         sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
 382         for (x = 2;; x++) {
 383                 u64 space, d;
 384                 u32 m;
 385
 386                 space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
 387                 d = space;
 388                 m = do_div(d, sdp->sd_inptrs);
 389
 390                 if (d != sdp->sd_jheightsize[x - 1] || m)
 391                         break;
 392                 sdp->sd_jheightsize[x] = space;
 393         }
 394         sdp->sd_max_jheight = x;
 395         sdp->sd_jheightsize[x] = ~0;
 396         gfs2_assert(sdp, sdp->sd_max_jheight <= GFS2_MAX_META_HEIGHT);
 397
 398         return 0;
 399 }
 400
 401 static int init_names(struct gfs2_sbd *sdp, int silent)
 402 {
 403         char *proto, *table;
 404         int error = 0;
 405
 406         proto = sdp->sd_args.ar_lockproto;
 407         table = sdp->sd_args.ar_locktable;
 408
 409         /*  Try to autodetect  */
 410
 411         if (!proto[0] || !table[0]) {
 412                 error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
 413                 if (error)
 414                         return error;
 415
 416                 error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
 417                 if (error)
 418                         goto out;
 419
 420                 if (!proto[0])
 421                         proto = sdp->sd_sb.sb_lockproto;
 422                 if (!table[0])
 423                         table = sdp->sd_sb.sb_locktable;
 424         }
 425
 426         if (!table[0])
 427                 table = sdp->sd_vfs->s_id;
 428
 429         strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
 430         strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
 431
 432         table = sdp->sd_table_name;
 433         while ((table = strchr(table, '/')))
 434                 *table = '_';
 435
 436 out:
 437         return error;
 438 }
 439
 440 static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
 441                         int undo)
 442 {
 443         struct task_struct *p;
 444         int error = 0;
 445
 446         if (undo)
 447                 goto fail_trans;
 448
 449         for (sdp->sd_glockd_num = 0;
 450              sdp->sd_glockd_num < sdp->sd_args.ar_num_glockd;
 451              sdp->sd_glockd_num++) {
 452                 p = kthread_run(gfs2_glockd, sdp, "gfs2_glockd");
 453                 error = IS_ERR(p);
 454                 if (error) {
 455                         fs_err(sdp, "can't start glockd thread: %d\n", error);
 456                         goto fail;
 457                 }
 458                 sdp->sd_glockd_process[sdp->sd_glockd_num] = p;
 459         }
 460
 461         error = gfs2_glock_nq_num(sdp,
 462                                   GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
 463                                   LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
 464                                   mount_gh);
 465         if (error) {
 466                 fs_err(sdp, "can't acquire mount glock: %d\n", error);
 467                 goto fail;
 468         }
 469
 470         error = gfs2_glock_nq_num(sdp,
 471                                   GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
 472                                   LM_ST_SHARED,
 473                                   LM_FLAG_NOEXP | GL_EXACT,
 474                                   &sdp->sd_live_gh);
 475         if (error) {
 476                 fs_err(sdp, "can't acquire live glock: %d\n", error);
 477                 goto fail_mount;
 478         }
 479
 480         error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
 481                                CREATE, &sdp->sd_rename_gl);
 482         if (error) {
 483                 fs_err(sdp, "can't create rename glock: %d\n", error);
 484                 goto fail_live;
 485         }
 486
 487         error = gfs2_glock_get(sdp, GFS2_TRANS_LOCK, &gfs2_trans_glops,
 488                                CREATE, &sdp->sd_trans_gl);
 489         if (error) {
 490                 fs_err(sdp, "can't create transaction glock: %d\n", error);
 491                 goto fail_rename;
 492         }
 493         set_bit(GLF_STICKY, &sdp->sd_trans_gl->gl_flags);
 494
 495         return 0;
 496
 497 fail_trans:
 498         gfs2_glock_put(sdp->sd_trans_gl);
 499 fail_rename:
 500         gfs2_glock_put(sdp->sd_rename_gl);
 501 fail_live:
 502         gfs2_glock_dq_uninit(&sdp->sd_live_gh);
 503 fail_mount:
 504         gfs2_glock_dq_uninit(mount_gh);
 505 fail:
 506         while (sdp->sd_glockd_num--)
 507                 kthread_stop(sdp->sd_glockd_process[sdp->sd_glockd_num]);
 508
 509         return error;
 510 }
 511
 512 static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
 513                             u64 no_addr, const char *name)
 514 {
 515         struct gfs2_sbd *sdp = sb->s_fs_info;
 516         struct dentry *dentry;
 517         struct inode *inode;
 518
 519         inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0, 0);
 520         if (IS_ERR(inode)) {
 521                 fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
 522                 return PTR_ERR(inode);
 523         }
 524         dentry = d_alloc_root(inode);
 525         if (!dentry) {
 526                 fs_err(sdp, "can't alloc %s dentry\n", name);
 527                 iput(inode);
 528                 return -ENOMEM;
 529         }
 530         dentry->d_op = &gfs2_dops;
 531         *dptr = dentry;
 532         return 0;
 533 }
 534
 535 static int init_sb(struct gfs2_sbd *sdp, int silent)
 536 {
 537         struct super_block *sb = sdp->sd_vfs;
 538         struct gfs2_holder sb_gh;
 539         u64 no_addr;
 540         int ret;
 541
 542         ret = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
 543                                 LM_ST_SHARED, 0, &sb_gh);
 544         if (ret) {
 545                 fs_err(sdp, "can't acquire superblock glock: %d\n", ret);
 546                 return ret;
 547         }
 548
 549         ret = gfs2_read_sb(sdp, sb_gh.gh_gl, silent);
 550         if (ret) {
 551                 fs_err(sdp, "can't read superblock: %d\n", ret);
 552                 goto out;
 553         }
 554
 555         /* Set up the buffer cache and SB for real */
 556         if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) {
 557                 ret = -EINVAL;
 558                 fs_err(sdp, "FS block size (%u) is too small for device "
 559                        "block size (%u)\n",
 560                        sdp->sd_sb.sb_bsize, bdev_hardsect_size(sb->s_bdev));
 561                 goto out;
 562         }
 563         if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
 564                 ret = -EINVAL;
 565                 fs_err(sdp, "FS block size (%u) is too big for machine "
 566                        "page size (%u)\n",
 567                        sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
 568                 goto out;
 569         }
 570         sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
 571
 572         /* Get the root inode */
 573         no_addr = sdp->sd_sb.sb_root_dir.no_addr;
 574         ret = gfs2_lookup_root(sb, &sdp->sd_root_dir, no_addr, "root");
 575         if (ret)
 576                 goto out;
 577
 578         /* Get the master inode */
 579         no_addr = sdp->sd_sb.sb_master_dir.no_addr;
 580         ret = gfs2_lookup_root(sb, &sdp->sd_master_dir, no_addr, "master");
 581         if (ret) {
 582                 dput(sdp->sd_root_dir);
 583                 goto out;
 584         }
 585         sb->s_root = dget(sdp->sd_args.ar_meta ? sdp->sd_master_dir : sdp->sd_root_dir);
 586 out:
 587         gfs2_glock_dq_uninit(&sb_gh);
 588         return ret;
 589 }
 590
 591 /**
 592  * map_journal_extents - create a reusable "extent" mapping from all logical
 593  * blocks to all physical blocks for the given journal.  This will save
 594  * us time when writing journal blocks.  Most journals will have only one
 595  * extent that maps all their logical blocks.  That's because gfs2.mkfs
 596  * arranges the journal blocks sequentially to maximize performance.
 597  * So the extent would map the first block for the entire file length.
 598  * However, gfs2_jadd can happen while file activity is happening, so
 599  * those journals may not be sequential.  Less likely is the case where
 600  * the users created their own journals by mounting the metafs and
 601  * laying it out.  But it's still possible.  These journals might have
 602  * several extents.
 603  *
 604  * TODO: This should be done in bigger chunks rather than one block at a time,
 605  *       but since it's only done at mount time, I'm not worried about the
 606  *       time it takes.
 607  */
 608 static int map_journal_extents(struct gfs2_sbd *sdp)
 609 {
 610         struct gfs2_jdesc *jd = sdp->sd_jdesc;
 611         unsigned int lb;
 612         u64 db, prev_db; /* logical block, disk block, prev disk block */
 613         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
 614         struct gfs2_journal_extent *jext = NULL;
 615         struct buffer_head bh;
 616         int rc = 0;
 617
 618         prev_db = 0;
 619
 620         for (lb = 0; lb < ip->i_disksize >> sdp->sd_sb.sb_bsize_shift; lb++) {
 621                 bh.b_state = 0;
 622                 bh.b_blocknr = 0;
 623                 bh.b_size = 1 << ip->i_inode.i_blkbits;
 624                 rc = gfs2_block_map(jd->jd_inode, lb, &bh, 0);
 625                 db = bh.b_blocknr;
 626                 if (rc || !db) {
 627                         printk(KERN_INFO "GFS2 journal mapping error %d: lb="
 628                                "%u db=%llu\n", rc, lb, (unsigned long long)db);
 629                         break;
 630                 }
 631                 if (!prev_db || db != prev_db + 1) {
 632                         jext = kzalloc(sizeof(struct gfs2_journal_extent),
 633                                        GFP_KERNEL);
 634                         if (!jext) {
 635                                 printk(KERN_INFO "GFS2 error: out of memory "
 636                                        "mapping journal extents.\n");
 637                                 rc = -ENOMEM;
 638                                 break;
 639                         }
 640                         jext->dblock = db;
 641                         jext->lblock = lb;
 642                         jext->blocks = 1;
 643                         list_add_tail(&jext->extent_list, &jd->extent_list);
 644                 } else {
 645                         jext->blocks++;
 646                 }
 647                 prev_db = db;
 648         }
 649         return rc;
 650 }
 651
 652 static void gfs2_lm_others_may_mount(struct gfs2_sbd *sdp)
 653 {
 654         if (!sdp->sd_lockstruct.ls_ops->lm_others_may_mount)
 655                 return;
 656         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 657                 sdp->sd_lockstruct.ls_ops->lm_others_may_mount(
 658                                         sdp->sd_lockstruct.ls_lockspace);
 659 }
 660
 661 static int init_journal(struct gfs2_sbd *sdp, int undo)
 662 {
 663         struct inode *master = sdp->sd_master_dir->d_inode;
 664         struct gfs2_holder ji_gh;
 665         struct task_struct *p;
 666         struct gfs2_inode *ip;
 667         int jindex = 1;
 668         int error = 0;
 669
 670         if (undo) {
 671                 jindex = 0;
 672                 goto fail_recoverd;
 673         }
 674
 675         sdp->sd_jindex = gfs2_lookup_simple(master, "jindex");
 676         if (IS_ERR(sdp->sd_jindex)) {
 677                 fs_err(sdp, "can't lookup journal index: %d\n", error);
 678                 return PTR_ERR(sdp->sd_jindex);
 679         }
 680         ip = GFS2_I(sdp->sd_jindex);
 681         set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 682
 683         /* Load in the journal index special file */
 684
 685         error = gfs2_jindex_hold(sdp, &ji_gh);
 686         if (error) {
 687                 fs_err(sdp, "can't read journal index: %d\n", error);
 688                 goto fail;
 689         }
 690
 691         error = -EINVAL;
 692         if (!gfs2_jindex_size(sdp)) {
 693                 fs_err(sdp, "no journals!\n");
 694                 goto fail_jindex;
 695         }
 696
 697         if (sdp->sd_args.ar_spectator) {
 698                 sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
 699                 atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
 700         } else {
 701                 if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
 702                         fs_err(sdp, "can't mount journal #%u\n",
 703                                sdp->sd_lockstruct.ls_jid);
 704                         fs_err(sdp, "there are only %u journals (0 - %u)\n",
 705                                gfs2_jindex_size(sdp),
 706                                gfs2_jindex_size(sdp) - 1);
 707                         goto fail_jindex;
 708                 }
 709                 sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
 710
 711                 error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
 712                                           &gfs2_journal_glops,
 713                                           LM_ST_EXCLUSIVE, LM_FLAG_NOEXP,
 714                                           &sdp->sd_journal_gh);
 715                 if (error) {
 716                         fs_err(sdp, "can't acquire journal glock: %d\n", error);
 717                         goto fail_jindex;
 718                 }
 719
 720                 ip = GFS2_I(sdp->sd_jdesc->jd_inode);
 721                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
 722                                            LM_FLAG_NOEXP | GL_EXACT | GL_NOCACHE,
 723                                            &sdp->sd_jinode_gh);
 724                 if (error) {
 725                         fs_err(sdp, "can't acquire journal inode glock: %d\n",
 726                                error);
 727                         goto fail_journal_gh;
 728                 }
 729
 730                 error = gfs2_jdesc_check(sdp->sd_jdesc);
 731                 if (error) {
 732                         fs_err(sdp, "my journal (%u) is bad: %d\n",
 733                                sdp->sd_jdesc->jd_jid, error);
 734                         goto fail_jinode_gh;
 735                 }
 736                 atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
 737
 738                 /* Map the extents for this journal's blocks */
 739                 map_journal_extents(sdp);
 740         }
 741
 742         if (sdp->sd_lockstruct.ls_first) {
 743                 unsigned int x;
 744                 for (x = 0; x < sdp->sd_journals; x++) {
 745                         error = gfs2_recover_journal(gfs2_jdesc_find(sdp, x));
 746                         if (error) {
 747                                 fs_err(sdp, "error recovering journal %u: %d\n",
 748                                        x, error);
 749                                 goto fail_jinode_gh;
 750                         }
 751                 }
 752
 753                 gfs2_lm_others_may_mount(sdp);
 754         } else if (!sdp->sd_args.ar_spectator) {
 755                 error = gfs2_recover_journal(sdp->sd_jdesc);
 756                 if (error) {
 757                         fs_err(sdp, "error recovering my journal: %d\n", error);
 758                         goto fail_jinode_gh;
 759                 }
 760         }
 761
 762         set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
 763         gfs2_glock_dq_uninit(&ji_gh);
 764         jindex = 0;
 765
 766         p = kthread_run(gfs2_recoverd, sdp, "gfs2_recoverd");
 767         error = IS_ERR(p);
 768         if (error) {
 769                 fs_err(sdp, "can't start recoverd thread: %d\n", error);
 770                 goto fail_jinode_gh;
 771         }
 772         sdp->sd_recoverd_process = p;
 773
 774         return 0;
 775
 776 fail_recoverd:
 777         kthread_stop(sdp->sd_recoverd_process);
 778 fail_jinode_gh:
 779         if (!sdp->sd_args.ar_spectator)
 780                 gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
 781 fail_journal_gh:
 782         if (!sdp->sd_args.ar_spectator)
 783                 gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
 784 fail_jindex:
 785         gfs2_jindex_free(sdp);
 786         if (jindex)
 787                 gfs2_glock_dq_uninit(&ji_gh);
 788 fail:
 789         iput(sdp->sd_jindex);
 790         return error;
 791 }
 792
 793
 794 static int init_inodes(struct gfs2_sbd *sdp, int undo)
 795 {
 796         int error = 0;
 797         struct gfs2_inode *ip;
 798         struct inode *master = sdp->sd_master_dir->d_inode;
 799
 800         if (undo)
 801                 goto fail_qinode;
 802
 803         error = init_journal(sdp, undo);
 804         if (error)
 805                 goto fail;
 806
 807         /* Read in the master inode number inode */
 808         sdp->sd_inum_inode = gfs2_lookup_simple(master, "inum");
 809         if (IS_ERR(sdp->sd_inum_inode)) {
 810                 error = PTR_ERR(sdp->sd_inum_inode);
 811                 fs_err(sdp, "can't read in inum inode: %d\n", error);
 812                 goto fail_journal;
 813         }
 814
 815
 816         /* Read in the master statfs inode */
 817         sdp->sd_statfs_inode = gfs2_lookup_simple(master, "statfs");
 818         if (IS_ERR(sdp->sd_statfs_inode)) {
 819                 error = PTR_ERR(sdp->sd_statfs_inode);
 820                 fs_err(sdp, "can't read in statfs inode: %d\n", error);
 821                 goto fail_inum;
 822         }
 823
 824         /* Read in the resource index inode */
 825         sdp->sd_rindex = gfs2_lookup_simple(master, "rindex");
 826         if (IS_ERR(sdp->sd_rindex)) {
 827                 error = PTR_ERR(sdp->sd_rindex);
 828                 fs_err(sdp, "can't get resource index inode: %d\n", error);
 829                 goto fail_statfs;
 830         }
 831         ip = GFS2_I(sdp->sd_rindex);
 832         set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 833         sdp->sd_rindex_uptodate = 0;
 834
 835         /* Read in the quota inode */
 836         sdp->sd_quota_inode = gfs2_lookup_simple(master, "quota");
 837         if (IS_ERR(sdp->sd_quota_inode)) {
 838                 error = PTR_ERR(sdp->sd_quota_inode);
 839                 fs_err(sdp, "can't get quota file inode: %d\n", error);
 840                 goto fail_rindex;
 841         }
 842         return 0;
 843
 844 fail_qinode:
 845         iput(sdp->sd_quota_inode);
 846 fail_rindex:
 847         gfs2_clear_rgrpd(sdp);
 848         iput(sdp->sd_rindex);
 849 fail_statfs:
 850         iput(sdp->sd_statfs_inode);
 851 fail_inum:
 852         iput(sdp->sd_inum_inode);
 853 fail_journal:
 854         init_journal(sdp, UNDO);
 855 fail:
 856         return error;
 857 }
 858
 859 static int init_per_node(struct gfs2_sbd *sdp, int undo)
 860 {
 861         struct inode *pn = NULL;
 862         char buf[30];
 863         int error = 0;
 864         struct gfs2_inode *ip;
 865         struct inode *master = sdp->sd_master_dir->d_inode;
 866
 867         if (sdp->sd_args.ar_spectator)
 868                 return 0;
 869
 870         if (undo)
 871                 goto fail_qc_gh;
 872
 873         pn = gfs2_lookup_simple(master, "per_node");
 874         if (IS_ERR(pn)) {
 875                 error = PTR_ERR(pn);
 876                 fs_err(sdp, "can't find per_node directory: %d\n", error);
 877                 return error;
 878         }
 879
 880         sprintf(buf, "inum_range%u", sdp->sd_jdesc->jd_jid);
 881         sdp->sd_ir_inode = gfs2_lookup_simple(pn, buf);
 882         if (IS_ERR(sdp->sd_ir_inode)) {
 883                 error = PTR_ERR(sdp->sd_ir_inode);
 884                 fs_err(sdp, "can't find local \"ir\" file: %d\n", error);
 885                 goto fail;
 886         }
 887
 888         sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
 889         sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
 890         if (IS_ERR(sdp->sd_sc_inode)) {
 891                 error = PTR_ERR(sdp->sd_sc_inode);
 892                 fs_err(sdp, "can't find local \"sc\" file: %d\n", error);
 893                 goto fail_ir_i;
 894         }
 895
 896         sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
 897         sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
 898         if (IS_ERR(sdp->sd_qc_inode)) {
 899                 error = PTR_ERR(sdp->sd_qc_inode);
 900                 fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
 901                 goto fail_ut_i;
 902         }
 903
 904         iput(pn);
 905         pn = NULL;
 906
 907         ip = GFS2_I(sdp->sd_ir_inode);
 908         error = gfs2_glock_nq_init(ip->i_gl,
 909                                    LM_ST_EXCLUSIVE, 0,
 910                                    &sdp->sd_ir_gh);
 911         if (error) {
 912                 fs_err(sdp, "can't lock local \"ir\" file: %d\n", error);
 913                 goto fail_qc_i;
 914         }
 915
 916         ip = GFS2_I(sdp->sd_sc_inode);
 917         error = gfs2_glock_nq_init(ip->i_gl,
 918                                    LM_ST_EXCLUSIVE, 0,
 919                                    &sdp->sd_sc_gh);
 920         if (error) {
 921                 fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
 922                 goto fail_ir_gh;
 923         }
 924
 925         ip = GFS2_I(sdp->sd_qc_inode);
 926         error = gfs2_glock_nq_init(ip->i_gl,
 927                                    LM_ST_EXCLUSIVE, 0,
 928                                    &sdp->sd_qc_gh);
 929         if (error) {
 930                 fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
 931                 goto fail_ut_gh;
 932         }
 933
 934         return 0;
 935
 936 fail_qc_gh:
 937         gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
 938 fail_ut_gh:
 939         gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
 940 fail_ir_gh:
 941         gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
 942 fail_qc_i:
 943         iput(sdp->sd_qc_inode);
 944 fail_ut_i:
 945         iput(sdp->sd_sc_inode);
 946 fail_ir_i:
 947         iput(sdp->sd_ir_inode);
 948 fail:
 949         if (pn)
 950                 iput(pn);
 951         return error;
 952 }
 953
 954 static int init_threads(struct gfs2_sbd *sdp, int undo)
 955 {
 956         struct task_struct *p;
 957         int error = 0;
 958
 959         if (undo)
 960                 goto fail_quotad;
 961
 962         sdp->sd_log_flush_time = jiffies;
 963         sdp->sd_jindex_refresh_time = jiffies;
 964
 965         p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
 966         error = IS_ERR(p);
 967         if (error) {
 968                 fs_err(sdp, "can't start logd thread: %d\n", error);
 969                 return error;
 970         }
 971         sdp->sd_logd_process = p;
 972
 973         p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
 974         error = IS_ERR(p);
 975         if (error) {
 976                 fs_err(sdp, "can't start quotad thread: %d\n", error);
 977                 goto fail;
 978         }
 979         sdp->sd_quotad_process = p;
 980
 981         return 0;
 982
 983
 984 fail_quotad:
 985         kthread_stop(sdp->sd_quotad_process);
 986 fail:
 987         kthread_stop(sdp->sd_logd_process);
 988         return error;
 989 }
 990
 991 /**
 992  * gfs2_lm_mount - mount a locking protocol
 993  * @sdp: the filesystem
 994  * @args: mount arguements
 995  * @silent: if 1, don't complain if the FS isn't a GFS2 fs
 996  *
 997  * Returns: errno
 998  */
 999
1000 static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
1001 {
1002         char *proto = sdp->sd_proto_name;
1003         char *table = sdp->sd_table_name;
1004         int flags = LM_MFLAG_CONV_NODROP;
1005         int error;
1006
1007         if (sdp->sd_args.ar_spectator)
1008                 flags |= LM_MFLAG_SPECTATOR;
1009
1010         fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
1011
1012         error = gfs2_mount_lockproto(proto, table, sdp->sd_args.ar_hostdata,
1013                                      gfs2_glock_cb, sdp,
1014                                      GFS2_MIN_LVB_SIZE, flags,
1015                                      &sdp->sd_lockstruct, &sdp->sd_kobj);
1016         if (error) {
1017                 fs_info(sdp, "can't mount proto=%s, table=%s, hostdata=%s\n",
1018                         proto, table, sdp->sd_args.ar_hostdata);
1019                 goto out;
1020         }
1021
1022         if (gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_ops) ||
1023             gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lvb_size >=
1024                                   GFS2_MIN_LVB_SIZE)) {
1025                 gfs2_unmount_lockproto(&sdp->sd_lockstruct);
1026                 goto out;
1027         }
1028
1029         if (sdp->sd_args.ar_spectator)
1030                 snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.s", table);
1031         else
1032                 snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.%u", table,
1033                          sdp->sd_lockstruct.ls_jid);
1034
1035         fs_info(sdp, "Joined cluster. Now mounting FS...\n");
1036
1037         if ((sdp->sd_lockstruct.ls_flags & LM_LSFLAG_LOCAL) &&
1038             !sdp->sd_args.ar_ignore_local_fs) {
1039                 sdp->sd_args.ar_localflocks = 1;
1040                 sdp->sd_args.ar_localcaching = 1;
1041         }
1042
1043 out:
1044         return error;
1045 }
1046
1047 void gfs2_lm_unmount(struct gfs2_sbd *sdp)
1048 {
1049         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
1050                 gfs2_unmount_lockproto(&sdp->sd_lockstruct);
1051 }
1052
1053 /**
1054  * fill_super - Read in superblock
1055  * @sb: The VFS superblock
1056  * @data: Mount options
1057  * @silent: Don't complain if it's not a GFS2 filesystem
1058  *
1059  * Returns: errno
1060  */
1061
1062 static int fill_super(struct super_block *sb, void *data, int silent)
1063 {
1064         struct gfs2_sbd *sdp;
1065         struct gfs2_holder mount_gh;
1066         int error;
1067
1068         sdp = init_sbd(sb);
1069         if (!sdp) {
1070                 printk(KERN_WARNING "GFS2: can't alloc struct gfs2_sbd\n");
1071                 return -ENOMEM;
1072         }
1073
1074         error = gfs2_mount_args(sdp, (char *)data, 0);
1075         if (error) {
1076                 printk(KERN_WARNING "GFS2: can't parse mount arguments\n");
1077                 goto fail;
1078         }
1079
1080         sb->s_magic = GFS2_MAGIC;
1081         sb->s_op = &gfs2_super_ops;
1082         sb->s_export_op = &gfs2_export_ops;
1083         sb->s_time_gran = 1;
1084         sb->s_maxbytes = MAX_LFS_FILESIZE;
1085
1086         /* Set up the buffer cache and fill in some fake block size values
1087            to allow us to read-in the on-disk superblock. */
1088         sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
1089         sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
1090         sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
1091                                GFS2_BASIC_BLOCK_SHIFT;
1092         sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
1093
1094         error = init_names(sdp, silent);
1095         if (error)
1096                 goto fail;
1097
1098         gfs2_create_debugfs_file(sdp);
1099
1100         error = gfs2_sys_fs_add(sdp);
1101         if (error)
1102                 goto fail;
1103
1104         error = gfs2_lm_mount(sdp, silent);
1105         if (error)
1106                 goto fail_sys;
1107
1108         error = init_locking(sdp, &mount_gh, DO);
1109         if (error)
1110                 goto fail_lm;
1111
1112         error = init_sb(sdp, silent);
1113         if (error)
1114                 goto fail_locking;
1115
1116         error = init_inodes(sdp, DO);
1117         if (error)
1118                 goto fail_sb;
1119
1120         error = init_per_node(sdp, DO);
1121         if (error)
1122                 goto fail_inodes;
1123
1124         error = gfs2_statfs_init(sdp);
1125         if (error) {
1126                 fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
1127                 goto fail_per_node;
1128         }
1129
1130         error = init_threads(sdp, DO);
1131         if (error)
1132                 goto fail_per_node;
1133
1134         if (!(sb->s_flags & MS_RDONLY)) {
1135                 error = gfs2_make_fs_rw(sdp);
1136                 if (error) {
1137                         fs_err(sdp, "can't make FS RW: %d\n", error);
1138                         goto fail_threads;
1139                 }
1140         }
1141
1142         gfs2_glock_dq_uninit(&mount_gh);
1143
1144         return 0;
1145
1146 fail_threads:
1147         init_threads(sdp, UNDO);
1148 fail_per_node:
1149         init_per_node(sdp, UNDO);
1150 fail_inodes:
1151         init_inodes(sdp, UNDO);
1152 fail_sb:
1153         if (sdp->sd_root_dir)
1154                 dput(sdp->sd_root_dir);
1155         if (sdp->sd_master_dir)
1156                 dput(sdp->sd_master_dir);
1157         sb->s_root = NULL;
1158 fail_locking:
1159         init_locking(sdp, &mount_gh, UNDO);
1160 fail_lm:
1161         gfs2_gl_hash_clear(sdp);
1162         gfs2_lm_unmount(sdp);
1163         while (invalidate_inodes(sb))
1164                 yield();
1165 fail_sys:
1166         gfs2_sys_fs_del(sdp);
1167 fail:
1168         gfs2_delete_debugfs_file(sdp);
1169         kfree(sdp);
1170         sb->s_fs_info = NULL;
1171         return error;
1172 }
1173
1174 static int gfs2_get_sb(struct file_system_type *fs_type, int flags,
1175                        const char *dev_name, void *data, struct vfsmount *mnt)
1176 {
1177         return get_sb_bdev(fs_type, flags, dev_name, data, fill_super, mnt);
1178 }
1179
1180 static struct super_block *get_gfs2_sb(const char *dev_name)
1181 {
1182         struct super_block *sb;
1183         struct nameidata nd;
1184         int error;
1185
1186         error = path_lookup(dev_name, LOOKUP_FOLLOW, &nd);
1187         if (error) {
1188                 printk(KERN_WARNING "GFS2: path_lookup on %s returned error %d\n",
1189                        dev_name, error);
1190                 return NULL;
1191         }
1192         sb = nd.path.dentry->d_inode->i_sb;
1193         if (sb && (sb->s_type == &gfs2_fs_type))
1194                 atomic_inc(&sb->s_active);
1195         else
1196                 sb = NULL;
1197         path_put(&nd.path);
1198         return sb;
1199 }
1200
1201 static int gfs2_get_sb_meta(struct file_system_type *fs_type, int flags,
1202                             const char *dev_name, void *data, struct vfsmount *mnt)
1203 {
1204         struct super_block *sb = NULL;
1205         struct gfs2_sbd *sdp;
1206
1207         sb = get_gfs2_sb(dev_name);
1208         if (!sb) {
1209                 printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n");
1210                 return -ENOENT;
1211         }
1212         sdp = sb->s_fs_info;
1213         mnt->mnt_sb = sb;
1214         mnt->mnt_root = dget(sdp->sd_master_dir);
1215         return 0;
1216 }
1217
1218 static void gfs2_kill_sb(struct super_block *sb)
1219 {
1220         struct gfs2_sbd *sdp = sb->s_fs_info;
1221         if (sdp) {
1222                 gfs2_meta_syncfs(sdp);
1223                 dput(sdp->sd_root_dir);
1224                 dput(sdp->sd_master_dir);
1225                 sdp->sd_root_dir = NULL;
1226                 sdp->sd_master_dir = NULL;
1227         }
1228         shrink_dcache_sb(sb);
1229         kill_block_super(sb);
1230         if (sdp)
1231                 gfs2_delete_debugfs_file(sdp);
1232 }
1233
1234 struct file_system_type gfs2_fs_type = {
1235         .name = "gfs2",
1236         .fs_flags = FS_REQUIRES_DEV,
1237         .get_sb = gfs2_get_sb,
1238         .kill_sb = gfs2_kill_sb,
1239         .owner = THIS_MODULE,
1240 };
1241
1242 struct file_system_type gfs2meta_fs_type = {
1243         .name = "gfs2meta",
1244         .fs_flags = FS_REQUIRES_DEV,
1245         .get_sb = gfs2_get_sb_meta,
1246         .owner = THIS_MODULE,
1247 };
1248