add hlist_bl_lock/unlock helpers
[linux-2.6.git] / fs / gfs2 / ops_fstype.c
index 63d5fd2..d3c69eb 100644 (file)
 #include <linux/namei.h>
 #include <linux/mount.h>
 #include <linux/gfs2_ondisk.h>
-#include <linux/lm_interface.h>
+#include <linux/quotaops.h>
 
 #include "gfs2.h"
 #include "incore.h"
 #include "bmap.h"
-#include "daemon.h"
 #include "glock.h"
 #include "glops.h"
 #include "inode.h"
-#include "mount.h"
-#include "ops_fstype.h"
-#include "ops_dentry.h"
-#include "ops_super.h"
 #include "recovery.h"
 #include "rgrp.h"
 #include "super.h"
 #include "sys.h"
 #include "util.h"
 #include "log.h"
+#include "quota.h"
+#include "dir.h"
+#include "trace_gfs2.h"
 
 #define DO 0
 #define UNDO 1
 
+/**
+ * gfs2_tune_init - Fill a gfs2_tune structure with default values
+ * @gt: tune
+ *
+ */
+
+static void gfs2_tune_init(struct gfs2_tune *gt)
+{
+       spin_lock_init(&gt->gt_spin);
+
+       gt->gt_quota_simul_sync = 64;
+       gt->gt_quota_warn_period = 10;
+       gt->gt_quota_scale_num = 1;
+       gt->gt_quota_scale_den = 1;
+       gt->gt_new_files_jdata = 0;
+       gt->gt_max_readahead = 1 << 18;
+       gt->gt_complain_secs = 10;
+}
+
 static struct gfs2_sbd *init_sbd(struct super_block *sb)
 {
        struct gfs2_sbd *sdp;
@@ -50,39 +67,39 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)
 
        sb->s_fs_info = sdp;
        sdp->sd_vfs = sb;
-
+       set_bit(SDF_NOJOURNALID, &sdp->sd_flags);
        gfs2_tune_init(&sdp->sd_tune);
 
-       INIT_LIST_HEAD(&sdp->sd_reclaim_list);
-       spin_lock_init(&sdp->sd_reclaim_lock);
-       init_waitqueue_head(&sdp->sd_reclaim_wq);
-
-       mutex_init(&sdp->sd_inum_mutex);
+       init_waitqueue_head(&sdp->sd_glock_wait);
+       atomic_set(&sdp->sd_glock_disposal, 0);
        spin_lock_init(&sdp->sd_statfs_spin);
 
        spin_lock_init(&sdp->sd_rindex_spin);
        mutex_init(&sdp->sd_rindex_mutex);
        INIT_LIST_HEAD(&sdp->sd_rindex_list);
        INIT_LIST_HEAD(&sdp->sd_rindex_mru_list);
-       INIT_LIST_HEAD(&sdp->sd_rindex_recent_list);
 
        INIT_LIST_HEAD(&sdp->sd_jindex_list);
        spin_lock_init(&sdp->sd_jindex_spin);
        mutex_init(&sdp->sd_jindex_mutex);
 
        INIT_LIST_HEAD(&sdp->sd_quota_list);
-       spin_lock_init(&sdp->sd_quota_spin);
        mutex_init(&sdp->sd_quota_mutex);
+       init_waitqueue_head(&sdp->sd_quota_wait);
+       INIT_LIST_HEAD(&sdp->sd_trunc_list);
+       spin_lock_init(&sdp->sd_trunc_lock);
 
        spin_lock_init(&sdp->sd_log_lock);
-
+       atomic_set(&sdp->sd_log_pinned, 0);
        INIT_LIST_HEAD(&sdp->sd_log_le_buf);
        INIT_LIST_HEAD(&sdp->sd_log_le_revoke);
        INIT_LIST_HEAD(&sdp->sd_log_le_rg);
        INIT_LIST_HEAD(&sdp->sd_log_le_databuf);
        INIT_LIST_HEAD(&sdp->sd_log_le_ordered);
 
-       mutex_init(&sdp->sd_log_reserve_mutex);
+       init_waitqueue_head(&sdp->sd_log_waitq);
+       init_waitqueue_head(&sdp->sd_logd_waitq);
+       spin_lock_init(&sdp->sd_ail_lock);
        INIT_LIST_HEAD(&sdp->sd_ail1_list);
        INIT_LIST_HEAD(&sdp->sd_ail2_list);
 
@@ -97,21 +114,219 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)
        return sdp;
 }
 
-static void init_vfs(struct super_block *sb, unsigned noatime)
+
+/**
+ * gfs2_check_sb - Check superblock
+ * @sdp: the filesystem
+ * @sb: The superblock
+ * @silent: Don't print a message if the check fails
+ *
+ * Checks the version code of the FS is one that we understand how to
+ * read and that the sizes of the various on-disk structures have not
+ * changed.
+ */
+
+static int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb_host *sb, int silent)
 {
-       struct gfs2_sbd *sdp = sb->s_fs_info;
+       if (sb->sb_magic != GFS2_MAGIC ||
+           sb->sb_type != GFS2_METATYPE_SB) {
+               if (!silent)
+                       printk(KERN_WARNING "GFS2: not a GFS2 filesystem\n");
+               return -EINVAL;
+       }
 
-       sb->s_magic = GFS2_MAGIC;
-       sb->s_op = &gfs2_super_ops;
-       sb->s_export_op = &gfs2_export_ops;
-       sb->s_time_gran = 1;
-       sb->s_maxbytes = MAX_LFS_FILESIZE;
+       /*  If format numbers match exactly, we're done.  */
+
+       if (sb->sb_fs_format == GFS2_FORMAT_FS &&
+           sb->sb_multihost_format == GFS2_FORMAT_MULTI)
+               return 0;
+
+       fs_warn(sdp, "Unknown on-disk format, unable to mount\n");
+
+       return -EINVAL;
+}
 
-       if (sb->s_flags & (MS_NOATIME | MS_NODIRATIME))
-               set_bit(noatime, &sdp->sd_flags);
+static void end_bio_io_page(struct bio *bio, int error)
+{
+       struct page *page = bio->bi_private;
 
-       /* Don't let the VFS update atimes.  GFS2 handles this itself. */
-       sb->s_flags |= MS_NOATIME | MS_NODIRATIME;
+       if (!error)
+               SetPageUptodate(page);
+       else
+               printk(KERN_WARNING "gfs2: error %d reading superblock\n", error);
+       unlock_page(page);
+}
+
+static void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)
+{
+       const struct gfs2_sb *str = buf;
+
+       sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
+       sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
+       sb->sb_format = be32_to_cpu(str->sb_header.mh_format);
+       sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
+       sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
+       sb->sb_bsize = be32_to_cpu(str->sb_bsize);
+       sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
+       sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
+       sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
+       sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
+       sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
+
+       memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
+       memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
+       memcpy(sb->sb_uuid, str->sb_uuid, 16);
+}
+
+/**
+ * gfs2_read_super - Read the gfs2 super block from disk
+ * @sdp: The GFS2 super block
+ * @sector: The location of the super block
+ * @error: The error code to return
+ *
+ * This uses the bio functions to read the super block from disk
+ * because we want to be 100% sure that we never read cached data.
+ * A super block is read twice only during each GFS2 mount and is
+ * never written to by the filesystem. The first time its read no
+ * locks are held, and the only details which are looked at are those
+ * relating to the locking protocol. Once locking is up and working,
+ * the sb is read again under the lock to establish the location of
+ * the master directory (contains pointers to journals etc) and the
+ * root directory.
+ *
+ * Returns: 0 on success or error
+ */
+
+static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector)
+{
+       struct super_block *sb = sdp->sd_vfs;
+       struct gfs2_sb *p;
+       struct page *page;
+       struct bio *bio;
+
+       page = alloc_page(GFP_NOFS);
+       if (unlikely(!page))
+               return -ENOBUFS;
+
+       ClearPageUptodate(page);
+       ClearPageDirty(page);
+       lock_page(page);
+
+       bio = bio_alloc(GFP_NOFS, 1);
+       bio->bi_sector = sector * (sb->s_blocksize >> 9);
+       bio->bi_bdev = sb->s_bdev;
+       bio_add_page(bio, page, PAGE_SIZE, 0);
+
+       bio->bi_end_io = end_bio_io_page;
+       bio->bi_private = page;
+       submit_bio(READ_SYNC | REQ_META, bio);
+       wait_on_page_locked(page);
+       bio_put(bio);
+       if (!PageUptodate(page)) {
+               __free_page(page);
+               return -EIO;
+       }
+       p = kmap(page);
+       gfs2_sb_in(&sdp->sd_sb, p);
+       kunmap(page);
+       __free_page(page);
+       return 0;
+}
+
+/**
+ * gfs2_read_sb - Read super block
+ * @sdp: The GFS2 superblock
+ * @silent: Don't print message if mount fails
+ *
+ */
+
+static int gfs2_read_sb(struct gfs2_sbd *sdp, int silent)
+{
+       u32 hash_blocks, ind_blocks, leaf_blocks;
+       u32 tmp_blocks;
+       unsigned int x;
+       int error;
+
+       error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
+       if (error) {
+               if (!silent)
+                       fs_err(sdp, "can't read superblock\n");
+               return error;
+       }
+
+       error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
+       if (error)
+               return error;
+
+       sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
+                              GFS2_BASIC_BLOCK_SHIFT;
+       sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
+       sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
+                         sizeof(struct gfs2_dinode)) / sizeof(u64);
+       sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
+                         sizeof(struct gfs2_meta_header)) / sizeof(u64);
+       sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
+       sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
+       sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
+       sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
+       sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
+                               sizeof(struct gfs2_meta_header)) /
+                               sizeof(struct gfs2_quota_change);
+
+       /* Compute maximum reservation required to add a entry to a directory */
+
+       hash_blocks = DIV_ROUND_UP(sizeof(u64) * (1 << GFS2_DIR_MAX_DEPTH),
+                            sdp->sd_jbsize);
+
+       ind_blocks = 0;
+       for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
+               tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
+               ind_blocks += tmp_blocks;
+       }
+
+       leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
+
+       sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
+
+       sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
+                               sizeof(struct gfs2_dinode);
+       sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
+       for (x = 2;; x++) {
+               u64 space, d;
+               u32 m;
+
+               space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
+               d = space;
+               m = do_div(d, sdp->sd_inptrs);
+
+               if (d != sdp->sd_heightsize[x - 1] || m)
+                       break;
+               sdp->sd_heightsize[x] = space;
+       }
+       sdp->sd_max_height = x;
+       sdp->sd_heightsize[x] = ~0;
+       gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
+
+       sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize -
+                                sizeof(struct gfs2_dinode);
+       sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
+       for (x = 2;; x++) {
+               u64 space, d;
+               u32 m;
+
+               space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
+               d = space;
+               m = do_div(d, sdp->sd_inptrs);
+
+               if (d != sdp->sd_jheightsize[x - 1] || m)
+                       break;
+               sdp->sd_jheightsize[x] = space;
+       }
+       sdp->sd_max_jheight = x;
+       sdp->sd_jheightsize[x] = ~0;
+       gfs2_assert(sdp, sdp->sd_max_jheight <= GFS2_MAX_META_HEIGHT);
+
+       return 0;
 }
 
 static int init_names(struct gfs2_sbd *sdp, int silent)
@@ -142,8 +357,8 @@ static int init_names(struct gfs2_sbd *sdp, int silent)
        if (!table[0])
                table = sdp->sd_vfs->s_id;
 
-       snprintf(sdp->sd_proto_name, GFS2_FSNAME_LEN, "%s", proto);
-       snprintf(sdp->sd_table_name, GFS2_FSNAME_LEN, "%s", table);
+       strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
+       strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
 
        table = sdp->sd_table_name;
        while ((table = strchr(table, '/')))
@@ -156,24 +371,11 @@ out:
 static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
                        int undo)
 {
-       struct task_struct *p;
        int error = 0;
 
        if (undo)
                goto fail_trans;
 
-       for (sdp->sd_glockd_num = 0;
-            sdp->sd_glockd_num < sdp->sd_args.ar_num_glockd;
-            sdp->sd_glockd_num++) {
-               p = kthread_run(gfs2_glockd, sdp, "gfs2_glockd");
-               error = IS_ERR(p);
-               if (error) {
-                       fs_err(sdp, "can't start glockd thread: %d\n", error);
-                       goto fail;
-               }
-               sdp->sd_glockd_process[sdp->sd_glockd_num] = p;
-       }
-
        error = gfs2_glock_nq_num(sdp,
                                  GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
                                  LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
@@ -206,7 +408,6 @@ static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
                fs_err(sdp, "can't create transaction glock: %d\n", error);
                goto fail_rename;
        }
-       set_bit(GLF_STICKY, &sdp->sd_trans_gl->gl_flags);
 
        return 0;
 
@@ -219,57 +420,61 @@ fail_live:
 fail_mount:
        gfs2_glock_dq_uninit(mount_gh);
 fail:
-       while (sdp->sd_glockd_num--)
-               kthread_stop(sdp->sd_glockd_process[sdp->sd_glockd_num]);
-
        return error;
 }
 
-static inline struct inode *gfs2_lookup_root(struct super_block *sb,
-                                            u64 no_addr)
+static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
+                           u64 no_addr, const char *name)
 {
-       return gfs2_inode_lookup(sb, DT_DIR, no_addr, 0, 0);
+       struct gfs2_sbd *sdp = sb->s_fs_info;
+       struct dentry *dentry;
+       struct inode *inode;
+
+       inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0, 0);
+       if (IS_ERR(inode)) {
+               fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
+               return PTR_ERR(inode);
+       }
+       dentry = d_alloc_root(inode);
+       if (!dentry) {
+               fs_err(sdp, "can't alloc %s dentry\n", name);
+               iput(inode);
+               return -ENOMEM;
+       }
+       *dptr = dentry;
+       return 0;
 }
 
-static int init_sb(struct gfs2_sbd *sdp, int silent, int undo)
+static int init_sb(struct gfs2_sbd *sdp, int silent)
 {
        struct super_block *sb = sdp->sd_vfs;
        struct gfs2_holder sb_gh;
        u64 no_addr;
-       struct inode *inode;
-       int error = 0;
+       int ret;
 
-       if (undo) {
-               if (sb->s_root) {
-                       dput(sb->s_root);
-                       sb->s_root = NULL;
-               }
-               return 0;
+       ret = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
+                               LM_ST_SHARED, 0, &sb_gh);
+       if (ret) {
+               fs_err(sdp, "can't acquire superblock glock: %d\n", ret);
+               return ret;
        }
 
-       error = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
-                                LM_ST_SHARED, 0, &sb_gh);
-       if (error) {
-               fs_err(sdp, "can't acquire superblock glock: %d\n", error);
-               return error;
-       }
-
-       error = gfs2_read_sb(sdp, sb_gh.gh_gl, silent);
-       if (error) {
-               fs_err(sdp, "can't read superblock: %d\n", error);
+       ret = gfs2_read_sb(sdp, silent);
+       if (ret) {
+               fs_err(sdp, "can't read superblock: %d\n", ret);
                goto out;
        }
 
        /* Set up the buffer cache and SB for real */
-       if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) {
-               error = -EINVAL;
+       if (sdp->sd_sb.sb_bsize < bdev_logical_block_size(sb->s_bdev)) {
+               ret = -EINVAL;
                fs_err(sdp, "FS block size (%u) is too small for device "
                       "block size (%u)\n",
-                      sdp->sd_sb.sb_bsize, bdev_hardsect_size(sb->s_bdev));
+                      sdp->sd_sb.sb_bsize, bdev_logical_block_size(sb->s_bdev));
                goto out;
        }
        if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
-               error = -EINVAL;
+               ret = -EINVAL;
                fs_err(sdp, "FS block size (%u) is too big for machine "
                       "page size (%u)\n",
                       sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
@@ -279,26 +484,21 @@ static int init_sb(struct gfs2_sbd *sdp, int silent, int undo)
 
        /* Get the root inode */
        no_addr = sdp->sd_sb.sb_root_dir.no_addr;
-       if (sb->s_type == &gfs2meta_fs_type)
-               no_addr = sdp->sd_sb.sb_master_dir.no_addr;
-       inode = gfs2_lookup_root(sb, no_addr);
-       if (IS_ERR(inode)) {
-               error = PTR_ERR(inode);
-               fs_err(sdp, "can't read in root inode: %d\n", error);
+       ret = gfs2_lookup_root(sb, &sdp->sd_root_dir, no_addr, "root");
+       if (ret)
                goto out;
-       }
 
-       sb->s_root = d_alloc_root(inode);
-       if (!sb->s_root) {
-               fs_err(sdp, "can't get root dentry\n");
-               error = -ENOMEM;
-               iput(inode);
-       } else
-               sb->s_root->d_op = &gfs2_dops;
-       
+       /* Get the master inode */
+       no_addr = sdp->sd_sb.sb_master_dir.no_addr;
+       ret = gfs2_lookup_root(sb, &sdp->sd_master_dir, no_addr, "master");
+       if (ret) {
+               dput(sdp->sd_root_dir);
+               goto out;
+       }
+       sb->s_root = dget(sdp->sd_args.ar_meta ? sdp->sd_master_dir : sdp->sd_root_dir);
 out:
        gfs2_glock_dq_uninit(&sb_gh);
-       return error;
+       return ret;
 }
 
 /**
@@ -330,7 +530,7 @@ static int map_journal_extents(struct gfs2_sbd *sdp)
 
        prev_db = 0;
 
-       for (lb = 0; lb < ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift; lb++) {
+       for (lb = 0; lb < i_size_read(jd->jd_inode) >> sdp->sd_sb.sb_bsize_shift; lb++) {
                bh.b_state = 0;
                bh.b_blocknr = 0;
                bh.b_size = 1 << ip->i_inode.i_blkbits;
@@ -362,33 +562,101 @@ static int map_journal_extents(struct gfs2_sbd *sdp)
        return rc;
 }
 
-static void gfs2_lm_others_may_mount(struct gfs2_sbd *sdp)
+static void gfs2_others_may_mount(struct gfs2_sbd *sdp)
+{
+       char *message = "FIRSTMOUNT=Done";
+       char *envp[] = { message, NULL };
+       struct lm_lockstruct *ls = &sdp->sd_lockstruct;
+       ls->ls_first_done = 1;
+       kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
+}
+
+/**
+ * gfs2_jindex_hold - Grab a lock on the jindex
+ * @sdp: The GFS2 superblock
+ * @ji_gh: the holder for the jindex glock
+ *
+ * Returns: errno
+ */
+
+static int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
 {
-       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               sdp->sd_lockstruct.ls_ops->lm_others_may_mount(
-                                       sdp->sd_lockstruct.ls_lockspace);
+       struct gfs2_inode *dip = GFS2_I(sdp->sd_jindex);
+       struct qstr name;
+       char buf[20];
+       struct gfs2_jdesc *jd;
+       int error;
+
+       name.name = buf;
+
+       mutex_lock(&sdp->sd_jindex_mutex);
+
+       for (;;) {
+               error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, ji_gh);
+               if (error)
+                       break;
+
+               name.len = sprintf(buf, "journal%u", sdp->sd_journals);
+               name.hash = gfs2_disk_hash(name.name, name.len);
+
+               error = gfs2_dir_check(sdp->sd_jindex, &name, NULL);
+               if (error == -ENOENT) {
+                       error = 0;
+                       break;
+               }
+
+               gfs2_glock_dq_uninit(ji_gh);
+
+               if (error)
+                       break;
+
+               error = -ENOMEM;
+               jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);
+               if (!jd)
+                       break;
+
+               INIT_LIST_HEAD(&jd->extent_list);
+               INIT_WORK(&jd->jd_work, gfs2_recover_func);
+               jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1);
+               if (!jd->jd_inode || IS_ERR(jd->jd_inode)) {
+                       if (!jd->jd_inode)
+                               error = -ENOENT;
+                       else
+                               error = PTR_ERR(jd->jd_inode);
+                       kfree(jd);
+                       break;
+               }
+
+               spin_lock(&sdp->sd_jindex_spin);
+               jd->jd_jid = sdp->sd_journals++;
+               list_add_tail(&jd->jd_list, &sdp->sd_jindex_list);
+               spin_unlock(&sdp->sd_jindex_spin);
+       }
+
+       mutex_unlock(&sdp->sd_jindex_mutex);
+
+       return error;
 }
 
 static int init_journal(struct gfs2_sbd *sdp, int undo)
 {
+       struct inode *master = sdp->sd_master_dir->d_inode;
        struct gfs2_holder ji_gh;
-       struct task_struct *p;
        struct gfs2_inode *ip;
        int jindex = 1;
        int error = 0;
 
        if (undo) {
                jindex = 0;
-               goto fail_recoverd;
+               goto fail_jinode_gh;
        }
 
-       sdp->sd_jindex = gfs2_lookup_simple(sdp->sd_master_dir, "jindex");
+       sdp->sd_jindex = gfs2_lookup_simple(master, "jindex");
        if (IS_ERR(sdp->sd_jindex)) {
                fs_err(sdp, "can't lookup journal index: %d\n", error);
                return PTR_ERR(sdp->sd_jindex);
        }
        ip = GFS2_I(sdp->sd_jindex);
-       set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 
        /* Load in the journal index special file */
 
@@ -398,7 +666,7 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
                goto fail;
        }
 
-       error = -EINVAL;
+       error = -EUSERS;
        if (!gfs2_jindex_size(sdp)) {
                fs_err(sdp, "no journals!\n");
                goto fail_jindex;
@@ -407,6 +675,8 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
        if (sdp->sd_args.ar_spectator) {
                sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
                atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
+               atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
+               atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
        } else {
                if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
                        fs_err(sdp, "can't mount journal #%u\n",
@@ -444,15 +714,19 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
                        goto fail_jinode_gh;
                }
                atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
+               atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
+               atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
 
                /* Map the extents for this journal's blocks */
                map_journal_extents(sdp);
        }
+       trace_gfs2_log_blocks(sdp, atomic_read(&sdp->sd_log_blks_free));
 
        if (sdp->sd_lockstruct.ls_first) {
                unsigned int x;
                for (x = 0; x < sdp->sd_journals; x++) {
-                       error = gfs2_recover_journal(gfs2_jdesc_find(sdp, x));
+                       error = gfs2_recover_journal(gfs2_jdesc_find(sdp, x),
+                                                    true);
                        if (error) {
                                fs_err(sdp, "error recovering journal %u: %d\n",
                                       x, error);
@@ -460,9 +734,9 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
                        }
                }
 
-               gfs2_lm_others_may_mount(sdp);
+               gfs2_others_may_mount(sdp);
        } else if (!sdp->sd_args.ar_spectator) {
-               error = gfs2_recover_journal(sdp->sd_jdesc);
+               error = gfs2_recover_journal(sdp->sd_jdesc, true);
                if (error) {
                        fs_err(sdp, "error recovering my journal: %d\n", error);
                        goto fail_jinode_gh;
@@ -473,18 +747,8 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
        gfs2_glock_dq_uninit(&ji_gh);
        jindex = 0;
 
-       p = kthread_run(gfs2_recoverd, sdp, "gfs2_recoverd");
-       error = IS_ERR(p);
-       if (error) {
-               fs_err(sdp, "can't start recoverd thread: %d\n", error);
-               goto fail_jinode_gh;
-       }
-       sdp->sd_recoverd_process = p;
-
        return 0;
 
-fail_recoverd:
-       kthread_stop(sdp->sd_recoverd_process);
 fail_jinode_gh:
        if (!sdp->sd_args.ar_spectator)
                gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
@@ -505,53 +769,35 @@ static int init_inodes(struct gfs2_sbd *sdp, int undo)
 {
        int error = 0;
        struct gfs2_inode *ip;
-       struct inode *inode;
+       struct inode *master = sdp->sd_master_dir->d_inode;
 
        if (undo)
                goto fail_qinode;
 
-       inode = gfs2_lookup_root(sdp->sd_vfs, sdp->sd_sb.sb_master_dir.no_addr);
-       if (IS_ERR(inode)) {
-               error = PTR_ERR(inode);
-               fs_err(sdp, "can't read in master directory: %d\n", error);
-               goto fail;
-       }
-       sdp->sd_master_dir = inode;
-
        error = init_journal(sdp, undo);
        if (error)
-               goto fail_master;
-
-       /* Read in the master inode number inode */
-       sdp->sd_inum_inode = gfs2_lookup_simple(sdp->sd_master_dir, "inum");
-       if (IS_ERR(sdp->sd_inum_inode)) {
-               error = PTR_ERR(sdp->sd_inum_inode);
-               fs_err(sdp, "can't read in inum inode: %d\n", error);
-               goto fail_journal;
-       }
-
+               goto fail;
 
        /* Read in the master statfs inode */
-       sdp->sd_statfs_inode = gfs2_lookup_simple(sdp->sd_master_dir, "statfs");
+       sdp->sd_statfs_inode = gfs2_lookup_simple(master, "statfs");
        if (IS_ERR(sdp->sd_statfs_inode)) {
                error = PTR_ERR(sdp->sd_statfs_inode);
                fs_err(sdp, "can't read in statfs inode: %d\n", error);
-               goto fail_inum;
+               goto fail_journal;
        }
 
        /* Read in the resource index inode */
-       sdp->sd_rindex = gfs2_lookup_simple(sdp->sd_master_dir, "rindex");
+       sdp->sd_rindex = gfs2_lookup_simple(master, "rindex");
        if (IS_ERR(sdp->sd_rindex)) {
                error = PTR_ERR(sdp->sd_rindex);
                fs_err(sdp, "can't get resource index inode: %d\n", error);
                goto fail_statfs;
        }
        ip = GFS2_I(sdp->sd_rindex);
-       set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
        sdp->sd_rindex_uptodate = 0;
 
        /* Read in the quota inode */
-       sdp->sd_quota_inode = gfs2_lookup_simple(sdp->sd_master_dir, "quota");
+       sdp->sd_quota_inode = gfs2_lookup_simple(master, "quota");
        if (IS_ERR(sdp->sd_quota_inode)) {
                error = PTR_ERR(sdp->sd_quota_inode);
                fs_err(sdp, "can't get quota file inode: %d\n", error);
@@ -566,12 +812,8 @@ fail_rindex:
        iput(sdp->sd_rindex);
 fail_statfs:
        iput(sdp->sd_statfs_inode);
-fail_inum:
-       iput(sdp->sd_inum_inode);
 fail_journal:
        init_journal(sdp, UNDO);
-fail_master:
-       iput(sdp->sd_master_dir);
 fail:
        return error;
 }
@@ -582,6 +824,7 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
        char buf[30];
        int error = 0;
        struct gfs2_inode *ip;
+       struct inode *master = sdp->sd_master_dir->d_inode;
 
        if (sdp->sd_args.ar_spectator)
                return 0;
@@ -589,27 +832,19 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
        if (undo)
                goto fail_qc_gh;
 
-       pn = gfs2_lookup_simple(sdp->sd_master_dir, "per_node");
+       pn = gfs2_lookup_simple(master, "per_node");
        if (IS_ERR(pn)) {
                error = PTR_ERR(pn);
                fs_err(sdp, "can't find per_node directory: %d\n", error);
                return error;
        }
 
-       sprintf(buf, "inum_range%u", sdp->sd_jdesc->jd_jid);
-       sdp->sd_ir_inode = gfs2_lookup_simple(pn, buf);
-       if (IS_ERR(sdp->sd_ir_inode)) {
-               error = PTR_ERR(sdp->sd_ir_inode);
-               fs_err(sdp, "can't find local \"ir\" file: %d\n", error);
-               goto fail;
-       }
-
        sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
        sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
        if (IS_ERR(sdp->sd_sc_inode)) {
                error = PTR_ERR(sdp->sd_sc_inode);
                fs_err(sdp, "can't find local \"sc\" file: %d\n", error);
-               goto fail_ir_i;
+               goto fail;
        }
 
        sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
@@ -623,27 +858,16 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
        iput(pn);
        pn = NULL;
 
-       ip = GFS2_I(sdp->sd_ir_inode);
-       error = gfs2_glock_nq_init(ip->i_gl,
-                                  LM_ST_EXCLUSIVE, 0,
-                                  &sdp->sd_ir_gh);
-       if (error) {
-               fs_err(sdp, "can't lock local \"ir\" file: %d\n", error);
-               goto fail_qc_i;
-       }
-
        ip = GFS2_I(sdp->sd_sc_inode);
-       error = gfs2_glock_nq_init(ip->i_gl,
-                                  LM_ST_EXCLUSIVE, 0,
+       error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
                                   &sdp->sd_sc_gh);
        if (error) {
                fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
-               goto fail_ir_gh;
+               goto fail_qc_i;
        }
 
        ip = GFS2_I(sdp->sd_qc_inode);
-       error = gfs2_glock_nq_init(ip->i_gl,
-                                  LM_ST_EXCLUSIVE, 0,
+       error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
                                   &sdp->sd_qc_gh);
        if (error) {
                fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
@@ -656,14 +880,10 @@ fail_qc_gh:
        gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
 fail_ut_gh:
        gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
-fail_ir_gh:
-       gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
 fail_qc_i:
        iput(sdp->sd_qc_inode);
 fail_ut_i:
        iput(sdp->sd_sc_inode);
-fail_ir_i:
-       iput(sdp->sd_ir_inode);
 fail:
        if (pn)
                iput(pn);
@@ -678,9 +898,6 @@ static int init_threads(struct gfs2_sbd *sdp, int undo)
        if (undo)
                goto fail_quotad;
 
-       sdp->sd_log_flush_time = jiffies;
-       sdp->sd_jindex_refresh_time = jiffies;
-
        p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
        error = IS_ERR(p);
        if (error) {
@@ -689,9 +906,6 @@ static int init_threads(struct gfs2_sbd *sdp, int undo)
        }
        sdp->sd_logd_process = p;
 
-       sdp->sd_statfs_sync_time = jiffies;
-       sdp->sd_quota_sync_time = jiffies;
-
        p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
        error = IS_ERR(p);
        if (error) {
@@ -710,10 +924,21 @@ fail:
        return error;
 }
 
+static const match_table_t nolock_tokens = {
+       { Opt_jid, "jid=%d\n", },
+       { Opt_err, NULL },
+};
+
+static const struct lm_lockops nolock_ops = {
+       .lm_proto_name = "lock_nolock",
+       .lm_put_lock = gfs2_glock_free,
+       .lm_tokens = &nolock_tokens,
+};
+
 /**
  * gfs2_lm_mount - mount a locking protocol
  * @sdp: the filesystem
- * @args: mount arguements
+ * @args: mount arguments
  * @silent: if 1, don't complain if the FS isn't a GFS2 fs
  *
  * Returns: errno
@@ -721,32 +946,69 @@ fail:
 
 static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
 {
-       char *proto = sdp->sd_proto_name;
-       char *table = sdp->sd_table_name;
-       int flags = 0;
-       int error;
-
-       if (sdp->sd_args.ar_spectator)
-               flags |= LM_MFLAG_SPECTATOR;
+       const struct lm_lockops *lm;
+       struct lm_lockstruct *ls = &sdp->sd_lockstruct;
+       struct gfs2_args *args = &sdp->sd_args;
+       const char *proto = sdp->sd_proto_name;
+       const char *table = sdp->sd_table_name;
+       const char *fsname;
+       char *o, *options;
+       int ret;
+
+       if (!strcmp("lock_nolock", proto)) {
+               lm = &nolock_ops;
+               sdp->sd_args.ar_localflocks = 1;
+#ifdef CONFIG_GFS2_FS_LOCKING_DLM
+       } else if (!strcmp("lock_dlm", proto)) {
+               lm = &gfs2_dlm_ops;
+#endif
+       } else {
+               printk(KERN_INFO "GFS2: can't find protocol %s\n", proto);
+               return -ENOENT;
+       }
 
        fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
 
-       error = gfs2_mount_lockproto(proto, table, sdp->sd_args.ar_hostdata,
-                                    gfs2_glock_cb, sdp,
-                                    GFS2_MIN_LVB_SIZE, flags,
-                                    &sdp->sd_lockstruct, &sdp->sd_kobj);
-       if (error) {
-               fs_info(sdp, "can't mount proto=%s, table=%s, hostdata=%s\n",
-                       proto, table, sdp->sd_args.ar_hostdata);
-               goto out;
-       }
+       ls->ls_ops = lm;
+       ls->ls_first = 1;
 
-       if (gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lockspace) ||
-           gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_ops) ||
-           gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lvb_size >=
-                                 GFS2_MIN_LVB_SIZE)) {
-               gfs2_unmount_lockproto(&sdp->sd_lockstruct);
-               goto out;
+       for (options = args->ar_hostdata; (o = strsep(&options, ":")); ) {
+               substring_t tmp[MAX_OPT_ARGS];
+               int token, option;
+
+               if (!o || !*o)
+                       continue;
+
+               token = match_token(o, *lm->lm_tokens, tmp);
+               switch (token) {
+               case Opt_jid:
+                       ret = match_int(&tmp[0], &option);
+                       if (ret || option < 0) 
+                               goto hostdata_error;
+                       if (test_and_clear_bit(SDF_NOJOURNALID, &sdp->sd_flags))
+                               ls->ls_jid = option;
+                       break;
+               case Opt_id:
+                       /* Obsolete, but left for backward compat purposes */
+                       break;
+               case Opt_first:
+                       ret = match_int(&tmp[0], &option);
+                       if (ret || (option != 0 && option != 1))
+                               goto hostdata_error;
+                       ls->ls_first = option;
+                       break;
+               case Opt_nodir:
+                       ret = match_int(&tmp[0], &option);
+                       if (ret || (option != 0 && option != 1))
+                               goto hostdata_error;
+                       ls->ls_nodir = option;
+                       break;
+               case Opt_err:
+               default:
+hostdata_error:
+                       fs_info(sdp, "unknown hostdata (%s)\n", o);
+                       return -EINVAL;
+               }
        }
 
        if (sdp->sd_args.ar_spectator)
@@ -755,22 +1017,52 @@ static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
                snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.%u", table,
                         sdp->sd_lockstruct.ls_jid);
 
-       fs_info(sdp, "Joined cluster. Now mounting FS...\n");
-
-       if ((sdp->sd_lockstruct.ls_flags & LM_LSFLAG_LOCAL) &&
-           !sdp->sd_args.ar_ignore_local_fs) {
-               sdp->sd_args.ar_localflocks = 1;
-               sdp->sd_args.ar_localcaching = 1;
+       fsname = strchr(table, ':');
+       if (fsname)
+               fsname++;
+       if (lm->lm_mount == NULL) {
+               fs_info(sdp, "Now mounting FS...\n");
+               return 0;
        }
-
-out:
-       return error;
+       ret = lm->lm_mount(sdp, fsname);
+       if (ret == 0)
+               fs_info(sdp, "Joined cluster. Now mounting FS...\n");
+       return ret;
 }
 
 void gfs2_lm_unmount(struct gfs2_sbd *sdp)
 {
-       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
-               gfs2_unmount_lockproto(&sdp->sd_lockstruct);
+       const struct lm_lockops *lm = sdp->sd_lockstruct.ls_ops;
+       if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) &&
+           lm->lm_unmount)
+               lm->lm_unmount(sdp);
+}
+
+static int gfs2_journalid_wait(void *word)
+{
+       if (signal_pending(current))
+               return -EINTR;
+       schedule();
+       return 0;
+}
+
+static int wait_on_journal(struct gfs2_sbd *sdp)
+{
+       if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
+               return 0;
+
+       return wait_on_bit(&sdp->sd_flags, SDF_NOJOURNALID, gfs2_journalid_wait, TASK_INTERRUPTIBLE);
+}
+
+void gfs2_online_uevent(struct gfs2_sbd *sdp)
+{
+       struct super_block *sb = sdp->sd_vfs;
+       char ro[20];
+       char spectator[20];
+       char *envp[] = { ro, spectator, NULL };
+       sprintf(ro, "RDONLY=%d", (sb->s_flags & MS_RDONLY) ? 1 : 0);
+       sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
+       kobject_uevent_env(&sdp->sd_kobj, KOBJ_ONLINE, envp);
 }
 
 /**
@@ -782,7 +1074,7 @@ void gfs2_lm_unmount(struct gfs2_sbd *sdp)
  * Returns: errno
  */
 
-static int fill_super(struct super_block *sb, void *data, int silent)
+static int fill_super(struct super_block *sb, struct gfs2_args *args, int silent)
 {
        struct gfs2_sbd *sdp;
        struct gfs2_holder mount_gh;
@@ -793,14 +1085,26 @@ static int fill_super(struct super_block *sb, void *data, int silent)
                printk(KERN_WARNING "GFS2: can't alloc struct gfs2_sbd\n");
                return -ENOMEM;
        }
+       sdp->sd_args = *args;
 
-       error = gfs2_mount_args(sdp, (char *)data, 0);
-       if (error) {
-               printk(KERN_WARNING "GFS2: can't parse mount arguments\n");
-               goto fail;
+       if (sdp->sd_args.ar_spectator) {
+                sb->s_flags |= MS_RDONLY;
+               set_bit(SDF_NORECOVERY, &sdp->sd_flags);
        }
+       if (sdp->sd_args.ar_posix_acl)
+               sb->s_flags |= MS_POSIXACL;
+       if (sdp->sd_args.ar_nobarrier)
+               set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
 
-       init_vfs(sb, SDF_NOATIME);
+       sb->s_magic = GFS2_MAGIC;
+       sb->s_op = &gfs2_super_ops;
+       sb->s_d_op = &gfs2_dops;
+       sb->s_export_op = &gfs2_export_ops;
+       sb->s_xattr = gfs2_xattr_handlers;
+       sb->s_qcop = &gfs2_quotactl_ops;
+       sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
+       sb->s_time_gran = 1;
+       sb->s_maxbytes = MAX_LFS_FILESIZE;
 
        /* Set up the buffer cache and fill in some fake block size values
           to allow us to read-in the on-disk superblock. */
@@ -810,6 +1114,17 @@ static int fill_super(struct super_block *sb, void *data, int silent)
                                GFS2_BASIC_BLOCK_SHIFT;
        sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
 
+       sdp->sd_tune.gt_logd_secs = sdp->sd_args.ar_commit;
+       sdp->sd_tune.gt_quota_quantum = sdp->sd_args.ar_quota_quantum;
+       if (sdp->sd_args.ar_statfs_quantum) {
+               sdp->sd_tune.gt_statfs_slow = 0;
+               sdp->sd_tune.gt_statfs_quantum = sdp->sd_args.ar_statfs_quantum;
+       }
+       else {
+               sdp->sd_tune.gt_statfs_slow = 1;
+               sdp->sd_tune.gt_statfs_quantum = 30;
+       }
+
        error = init_names(sdp, silent);
        if (error)
                goto fail;
@@ -828,10 +1143,28 @@ static int fill_super(struct super_block *sb, void *data, int silent)
        if (error)
                goto fail_lm;
 
-       error = init_sb(sdp, silent, DO);
+       error = init_sb(sdp, silent);
        if (error)
                goto fail_locking;
 
+       error = wait_on_journal(sdp);
+       if (error)
+               goto fail_sb;
+
+       /*
+        * If user space has failed to join the cluster or some similar
+        * failure has occurred, then the journal id will contain a
+        * negative (error) number. This will then be returned to the
+        * caller (of the mount syscall). We do this even for spectator
+        * mounts (which just write a jid of 0 to indicate "ok" even though
+        * the jid is unused in the spectator case)
+        */
+       if (sdp->sd_lockstruct.ls_jid < 0) {
+               error = sdp->sd_lockstruct.ls_jid;
+               sdp->sd_lockstruct.ls_jid = 0;
+               goto fail_sb;
+       }
+
        error = init_inodes(sdp, DO);
        if (error)
                goto fail_sb;
@@ -859,7 +1192,7 @@ static int fill_super(struct super_block *sb, void *data, int silent)
        }
 
        gfs2_glock_dq_uninit(&mount_gh);
-
+       gfs2_online_uevent(sdp);
        return 0;
 
 fail_threads:
@@ -869,14 +1202,18 @@ fail_per_node:
 fail_inodes:
        init_inodes(sdp, UNDO);
 fail_sb:
-       init_sb(sdp, 0, UNDO);
+       if (sdp->sd_root_dir)
+               dput(sdp->sd_root_dir);
+       if (sdp->sd_master_dir)
+               dput(sdp->sd_master_dir);
+       if (sb->s_root)
+               dput(sb->s_root);
+       sb->s_root = NULL;
 fail_locking:
        init_locking(sdp, &mount_gh, UNDO);
 fail_lm:
-       gfs2_gl_hash_clear(sdp, WAIT);
+       gfs2_gl_hash_clear(sdp);
        gfs2_lm_unmount(sdp);
-       while (invalidate_inodes(sb))
-               yield();
 fail_sys:
        gfs2_sys_fs_del(sdp);
 fail:
@@ -886,159 +1223,180 @@ fail:
        return error;
 }
 
-static int gfs2_get_sb(struct file_system_type *fs_type, int flags,
-               const char *dev_name, void *data, struct vfsmount *mnt)
-{
-       struct super_block *sb;
-       struct gfs2_sbd *sdp;
-       int error = get_sb_bdev(fs_type, flags, dev_name, data, fill_super, mnt);
-       if (error)
-               goto out;
-       sb = mnt->mnt_sb;
-       sdp = sb->s_fs_info;
-       sdp->sd_gfs2mnt = mnt;
-out:
-       return error;
-}
-
-static int fill_super_meta(struct super_block *sb, struct super_block *new,
-                          void *data, int silent)
-{
-       struct gfs2_sbd *sdp = sb->s_fs_info;
-       struct inode *inode;
-       int error = 0;
-
-       new->s_fs_info = sdp;
-       sdp->sd_vfs_meta = sb;
-
-       init_vfs(new, SDF_NOATIME);
-
-        /* Get the master inode */
-       inode = igrab(sdp->sd_master_dir);
-
-       new->s_root = d_alloc_root(inode);
-       if (!new->s_root) {
-               fs_err(sdp, "can't get root dentry\n");
-               error = -ENOMEM;
-               iput(inode);
-       } else
-               new->s_root->d_op = &gfs2_dops;
-
-       return error;
-}
-
-static int set_bdev_super(struct super_block *s, void *data)
+static int set_gfs2_super(struct super_block *s, void *data)
 {
        s->s_bdev = data;
        s->s_dev = s->s_bdev->bd_dev;
+
+       /*
+        * We set the bdi here to the queue backing, file systems can
+        * overwrite this in ->fill_super()
+        */
+       s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info;
        return 0;
 }
 
-static int test_bdev_super(struct super_block *s, void *data)
+static int test_gfs2_super(struct super_block *s, void *ptr)
 {
-       return s->s_bdev == data;
+       struct block_device *bdev = ptr;
+       return (bdev == s->s_bdev);
 }
 
-static struct super_block* get_gfs2_sb(const char *dev_name)
+/**
+ * gfs2_mount - Get the GFS2 superblock
+ * @fs_type: The GFS2 filesystem type
+ * @flags: Mount flags
+ * @dev_name: The name of the device
+ * @data: The mount arguments
+ *
+ * Q. Why not use get_sb_bdev() ?
+ * A. We need to select one of two root directories to mount, independent
+ *    of whether this is the initial, or subsequent, mount of this sb
+ *
+ * Returns: 0 or -ve on error
+ */
+
+static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags,
+                      const char *dev_name, void *data)
 {
-       struct kstat stat;
-       struct nameidata nd;
-       struct super_block *sb = NULL, *s;
+       struct block_device *bdev;
+       struct super_block *s;
+       fmode_t mode = FMODE_READ | FMODE_EXCL;
        int error;
+       struct gfs2_args args;
+       struct gfs2_sbd *sdp;
 
-       error = path_lookup(dev_name, LOOKUP_FOLLOW, &nd);
+       if (!(flags & MS_RDONLY))
+               mode |= FMODE_WRITE;
+
+       bdev = blkdev_get_by_path(dev_name, mode, fs_type);
+       if (IS_ERR(bdev))
+               return ERR_CAST(bdev);
+
+       /*
+        * once the super is inserted into the list by sget, s_umount
+        * will protect the lockfs code from trying to start a snapshot
+        * while we are mounting
+        */
+       mutex_lock(&bdev->bd_fsfreeze_mutex);
+       if (bdev->bd_fsfreeze_count > 0) {
+               mutex_unlock(&bdev->bd_fsfreeze_mutex);
+               error = -EBUSY;
+               goto error_bdev;
+       }
+       s = sget(fs_type, test_gfs2_super, set_gfs2_super, bdev);
+       mutex_unlock(&bdev->bd_fsfreeze_mutex);
+       error = PTR_ERR(s);
+       if (IS_ERR(s))
+               goto error_bdev;
+
+       if (s->s_root)
+               blkdev_put(bdev, mode);
+
+       memset(&args, 0, sizeof(args));
+       args.ar_quota = GFS2_QUOTA_DEFAULT;
+       args.ar_data = GFS2_DATA_DEFAULT;
+       args.ar_commit = 30;
+       args.ar_statfs_quantum = 30;
+       args.ar_quota_quantum = 60;
+       args.ar_errors = GFS2_ERRORS_DEFAULT;
+
+       error = gfs2_mount_args(&args, data);
        if (error) {
-               printk(KERN_WARNING "GFS2: path_lookup on %s returned error\n",
-                      dev_name);
-               goto out;
+               printk(KERN_WARNING "GFS2: can't parse mount arguments\n");
+               goto error_super;
        }
-       error = vfs_getattr(nd.path.mnt, nd.path.dentry, &stat);
-
-       list_for_each_entry(s, &gfs2_fs_type.fs_supers, s_instances) {
-               if ((S_ISBLK(stat.mode) && s->s_dev == stat.rdev) ||
-                   (S_ISDIR(stat.mode) &&
-                    s == nd.path.dentry->d_inode->i_sb)) {
-                       sb = s;
-                       goto free_nd;
-               }
+
+       if (s->s_root) {
+               error = -EBUSY;
+               if ((flags ^ s->s_flags) & MS_RDONLY)
+                       goto error_super;
+       } else {
+               char b[BDEVNAME_SIZE];
+
+               s->s_flags = flags;
+               s->s_mode = mode;
+               strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
+               sb_set_blocksize(s, block_size(bdev));
+               error = fill_super(s, &args, flags & MS_SILENT ? 1 : 0);
+               if (error)
+                       goto error_super;
+               s->s_flags |= MS_ACTIVE;
+               bdev->bd_super = s;
        }
 
-       printk(KERN_WARNING "GFS2: Unrecognized block device or "
-              "mount point %s\n", dev_name);
+       sdp = s->s_fs_info;
+       if (args.ar_meta)
+               return dget(sdp->sd_master_dir);
+       else
+               return dget(sdp->sd_root_dir);
+
+error_super:
+       deactivate_locked_super(s);
+       return ERR_PTR(error);
+error_bdev:
+       blkdev_put(bdev, mode);
+       return ERR_PTR(error);
+}
 
-free_nd:
-       path_put(&nd.path);
-out:
-       return sb;
+static int set_meta_super(struct super_block *s, void *ptr)
+{
+       return -EINVAL;
 }
 
-static int gfs2_get_sb_meta(struct file_system_type *fs_type, int flags,
-                           const char *dev_name, void *data, struct vfsmount *mnt)
+static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
+                       int flags, const char *dev_name, void *data)
 {
-       int error = 0;
-       struct super_block *sb = NULL, *new;
+       struct super_block *s;
        struct gfs2_sbd *sdp;
+       struct path path;
+       int error;
 
-       sb = get_gfs2_sb(dev_name);
-       if (!sb) {
-               printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n");
-               error = -ENOENT;
-               goto error;
+       error = kern_path(dev_name, LOOKUP_FOLLOW, &path);
+       if (error) {
+               printk(KERN_WARNING "GFS2: path_lookup on %s returned error %d\n",
+                      dev_name, error);
+               return ERR_PTR(error);
        }
-       sdp = sb->s_fs_info;
-       if (sdp->sd_vfs_meta) {
-               printk(KERN_WARNING "GFS2: gfs2meta mount already exists\n");
-               error = -EBUSY;
-               goto error;
+       s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super,
+                path.dentry->d_inode->i_sb->s_bdev);
+       path_put(&path);
+       if (IS_ERR(s)) {
+               printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n");
+               return ERR_CAST(s);
        }
-       down(&sb->s_bdev->bd_mount_sem);
-       new = sget(fs_type, test_bdev_super, set_bdev_super, sb->s_bdev);
-       up(&sb->s_bdev->bd_mount_sem);
-       if (IS_ERR(new)) {
-               error = PTR_ERR(new);
-               goto error;
+       if ((flags ^ s->s_flags) & MS_RDONLY) {
+               deactivate_locked_super(s);
+               return ERR_PTR(-EBUSY);
        }
-       module_put(fs_type->owner);
-       new->s_flags = flags;
-       strlcpy(new->s_id, sb->s_id, sizeof(new->s_id));
-       sb_set_blocksize(new, sb->s_blocksize);
-       error = fill_super_meta(sb, new, data, flags & MS_SILENT ? 1 : 0);
-       if (error) {
-               up_write(&new->s_umount);
-               deactivate_super(new);
-               goto error;
-       }
-
-       new->s_flags |= MS_ACTIVE;
-
-       /* Grab a reference to the gfs2 mount point */
-       atomic_inc(&sdp->sd_gfs2mnt->mnt_count);
-       return simple_set_mnt(mnt, new);
-error:
-       return error;
+       sdp = s->s_fs_info;
+       return dget(sdp->sd_master_dir);
 }
 
 static void gfs2_kill_sb(struct super_block *sb)
 {
-       if (sb->s_fs_info) {
-               gfs2_delete_debugfs_file(sb->s_fs_info);
-               gfs2_meta_syncfs(sb->s_fs_info);
+       struct gfs2_sbd *sdp = sb->s_fs_info;
+
+       if (sdp == NULL) {
+               kill_block_super(sb);
+               return;
        }
-       kill_block_super(sb);
-}
 
-static void gfs2_kill_sb_meta(struct super_block *sb)
-{
-       struct gfs2_sbd *sdp = sb->s_fs_info;
-       generic_shutdown_super(sb);
-       sdp->sd_vfs_meta = NULL;
-       atomic_dec(&sdp->sd_gfs2mnt->mnt_count);
+       gfs2_meta_syncfs(sdp);
+       dput(sdp->sd_root_dir);
+       dput(sdp->sd_master_dir);
+       sdp->sd_root_dir = NULL;
+       sdp->sd_master_dir = NULL;
+       shrink_dcache_sb(sb);
+       kill_block_super(sb);
+       gfs2_delete_debugfs_file(sdp);
+       kfree(sdp);
 }
 
 struct file_system_type gfs2_fs_type = {
        .name = "gfs2",
        .fs_flags = FS_REQUIRES_DEV,
-       .get_sb = gfs2_get_sb,
+       .mount = gfs2_mount,
        .kill_sb = gfs2_kill_sb,
        .owner = THIS_MODULE,
 };
@@ -1046,8 +1404,7 @@ struct file_system_type gfs2_fs_type = {
 struct file_system_type gfs2meta_fs_type = {
        .name = "gfs2meta",
        .fs_flags = FS_REQUIRES_DEV,
-       .get_sb = gfs2_get_sb_meta,
-       .kill_sb = gfs2_kill_sb_meta,
+       .mount = gfs2_mount_meta,
        .owner = THIS_MODULE,
 };