20 files changed, 271 insertions, 285 deletions

diff --git a/fs/gfs2/acl.c b/fs/gfs2/acl.c
index cbc07155b1a0..34501b64bc47 100644
--- a/fs/gfs2/acl.c
+++ b/fs/gfs2/acl.c
@@ -67,39 +67,12 @@ static struct posix_acl *gfs2_acl_get(struct gfs2_inode *ip, int type)
         return acl;
 }
 
-/**
- * gfs2_check_acl - Check an ACL to see if we're allowed to do something
- * @inode: the file we want to do something to
- * @mask: what we want to do
- *
- * Returns: errno
- */
-
-int gfs2_check_acl(struct inode *inode, int mask, unsigned int flags)
+struct posix_acl *gfs2_get_acl(struct inode *inode, int type)
 {
-        struct posix_acl *acl;
-        int error;
-
-        if (flags & IPERM_FLAG_RCU) {
-                if (!negative_cached_acl(inode, ACL_TYPE_ACCESS))
-                        return -ECHILD;
-                return -EAGAIN;
-        }
-
-        acl = gfs2_acl_get(GFS2_I(inode), ACL_TYPE_ACCESS);
-        if (IS_ERR(acl))
-                return PTR_ERR(acl);
-
-        if (acl) {
-                error = posix_acl_permission(inode, acl, mask);
-                posix_acl_release(acl);
-                return error;
-        }
-
-        return -EAGAIN;
+        return gfs2_acl_get(GFS2_I(inode), type);
 }
 
-static int gfs2_set_mode(struct inode *inode, mode_t mode)
+static int gfs2_set_mode(struct inode *inode, umode_t mode)
 {
         int error = 0;
 
@@ -143,8 +116,8 @@ out:
 int gfs2_acl_create(struct gfs2_inode *dip, struct inode *inode)
 {
         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
-        struct posix_acl *acl, *clone;
-        mode_t mode = inode->i_mode;
+        struct posix_acl *acl;
+        umode_t mode = inode->i_mode;
         int error = 0;
 
         if (!sdp->sd_args.ar_posix_acl)
@@ -168,16 +141,10 @@ int gfs2_acl_create(struct gfs2_inode *dip, struct inode *inode)
                         goto out;
         }
 
-        clone = posix_acl_clone(acl, GFP_NOFS);
-        error = -ENOMEM;
-        if (!clone)
-                goto out;
-        posix_acl_release(acl);
-        acl = clone;
-
-        error = posix_acl_create_masq(acl, &mode);
+        error = posix_acl_create(&acl, GFP_NOFS, &mode);
         if (error < 0)
-                goto out;
+                return error;
+
         if (error == 0)
                 goto munge;
 
@@ -193,7 +160,7 @@ out:
 
 int gfs2_acl_chmod(struct gfs2_inode *ip, struct iattr *attr)
 {
-        struct posix_acl *acl, *clone;
+        struct posix_acl *acl;
         char *data;
         unsigned int len;
         int error;
@@ -204,25 +171,19 @@ int gfs2_acl_chmod(struct gfs2_inode *ip, struct iattr *attr)
         if (!acl)
                 return gfs2_setattr_simple(ip, attr);
 
-        clone = posix_acl_clone(acl, GFP_NOFS);
+        error = posix_acl_chmod(&acl, GFP_NOFS, attr->ia_mode);
+        if (error)
+                return error;
+
+        len = posix_acl_to_xattr(acl, NULL, 0);
+        data = kmalloc(len, GFP_NOFS);
         error = -ENOMEM;
-        if (!clone)
+        if (data == NULL)
                 goto out;
-        posix_acl_release(acl);
-        acl = clone;
-
-        error = posix_acl_chmod_masq(acl, attr->ia_mode);
-        if (!error) {
-                len = posix_acl_to_xattr(acl, NULL, 0);
-                data = kmalloc(len, GFP_NOFS);
-                error = -ENOMEM;
-                if (data == NULL)
-                        goto out;
-                posix_acl_to_xattr(acl, data, len);
-                error = gfs2_xattr_acl_chmod(ip, attr, data);
-                kfree(data);
-                set_cached_acl(&ip->i_inode, ACL_TYPE_ACCESS, acl);
-        }
+        posix_acl_to_xattr(acl, data, len);
+        error = gfs2_xattr_acl_chmod(ip, attr, data);
+        kfree(data);
+        set_cached_acl(&ip->i_inode, ACL_TYPE_ACCESS, acl);
 
 out:
         posix_acl_release(acl);
@@ -315,7 +276,7 @@ static int gfs2_xattr_system_set(struct dentry *dentry, const char *name,
                 goto out_release;
 
         if (type == ACL_TYPE_ACCESS) {
-                mode_t mode = inode->i_mode;
+                umode_t mode = inode->i_mode;
                 error = posix_acl_equiv_mode(acl, &mode);
 
                 if (error <= 0) {
diff --git a/fs/gfs2/acl.h b/fs/gfs2/acl.h
index a93907c8159b..0da38dc7efec 100644
--- a/fs/gfs2/acl.h
+++ b/fs/gfs2/acl.h
@@ -16,7 +16,7 @@
 #define GFS2_POSIX_ACL_DEFAULT          "posix_acl_default"
 #define GFS2_ACL_MAX_ENTRIES            25
 
-extern int gfs2_check_acl(struct inode *inode, int mask, unsigned int);
+extern struct posix_acl *gfs2_get_acl(struct inode *inode, int type);
 extern int gfs2_acl_create(struct gfs2_inode *dip, struct inode *inode);
 extern int gfs2_acl_chmod(struct gfs2_inode *ip, struct iattr *attr);
 extern const struct xattr_handler gfs2_xattr_system_handler;
diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index 802ac5eeba28..f9fbbe96c222 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
@@ -1069,6 +1069,7 @@ int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
                 return 0;
 
         gfs2_log_lock(sdp);
+        spin_lock(&sdp->sd_ail_lock);
         head = bh = page_buffers(page);
         do {
                 if (atomic_read(&bh->b_count))
@@ -1080,6 +1081,7 @@ int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
                         goto not_possible;
                 bh = bh->b_this_page;
         } while(bh != head);
+        spin_unlock(&sdp->sd_ail_lock);
         gfs2_log_unlock(sdp);
 
         head = bh = page_buffers(page);
@@ -1112,6 +1114,7 @@ not_possible: /* Should never happen */
         WARN_ON(buffer_dirty(bh));
         WARN_ON(buffer_pinned(bh));
 cannot_release:
+        spin_unlock(&sdp->sd_ail_lock);
         gfs2_log_unlock(sdp);
         return 0;
 }
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index e65493a8ac00..7878c473ae62 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -854,11 +854,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
                         blen++;
                 else {
                         if (bstart) {
-                                if (metadata)
-                                        __gfs2_free_meta(ip, bstart, blen);
-                                else
-                                        __gfs2_free_data(ip, bstart, blen);
-
+                                __gfs2_free_blocks(ip, bstart, blen, metadata);
                                 btotal += blen;
                         }
 
@@ -870,11 +866,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
                 gfs2_add_inode_blocks(&ip->i_inode, -1);
         }
         if (bstart) {
-                if (metadata)
-                        __gfs2_free_meta(ip, bstart, blen);
-                else
-                        __gfs2_free_data(ip, bstart, blen);
-
+                __gfs2_free_blocks(ip, bstart, blen, metadata);
                 btotal += blen;
         }
 
@@ -1224,6 +1216,8 @@ int gfs2_setattr_size(struct inode *inode, u64 newsize)
         if (ret)
                 return ret;
 
+        inode_dio_wait(inode);
+
         oldsize = inode->i_size;
         if (newsize >= oldsize)
                 return do_grow(inode, newsize);
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index 091ee4779538..1cc2f8ec52a2 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -339,6 +339,67 @@ fail:
         return (copied) ? copied : error;
 }
 
+/**
+ * gfs2_dir_get_hash_table - Get pointer to the dir hash table
+ * @ip: The inode in question
+ *
+ * Returns: The hash table or an error
+ */
+
+static __be64 *gfs2_dir_get_hash_table(struct gfs2_inode *ip)
+{
+        struct inode *inode = &ip->i_inode;
+        int ret;
+        u32 hsize;
+        __be64 *hc;
+
+        BUG_ON(!(ip->i_diskflags & GFS2_DIF_EXHASH));
+
+        hc = ip->i_hash_cache;
+        if (hc)
+                return hc;
+
+        hsize = 1 << ip->i_depth;
+        hsize *= sizeof(__be64);
+        if (hsize != i_size_read(&ip->i_inode)) {
+                gfs2_consist_inode(ip);
+                return ERR_PTR(-EIO);
+        }
+
+        hc = kmalloc(hsize, GFP_NOFS);
+        ret = -ENOMEM;
+        if (hc == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        ret = gfs2_dir_read_data(ip, (char *)hc, 0, hsize, 1);
+        if (ret < 0) {
+                kfree(hc);
+                return ERR_PTR(ret);
+        }
+
+        spin_lock(&inode->i_lock);
+        if (ip->i_hash_cache)
+                kfree(hc);
+        else
+                ip->i_hash_cache = hc;
+        spin_unlock(&inode->i_lock);
+
+        return ip->i_hash_cache;
+}
+
+/**
+ * gfs2_dir_hash_inval - Invalidate dir hash
+ * @ip: The directory inode
+ *
+ * Must be called with an exclusive glock, or during glock invalidation.
+ */
+void gfs2_dir_hash_inval(struct gfs2_inode *ip)
+{
+        __be64 *hc = ip->i_hash_cache;
+        ip->i_hash_cache = NULL;
+        kfree(hc);
+}
+
 static inline int gfs2_dirent_sentinel(const struct gfs2_dirent *dent)
 {
         return dent->de_inum.no_addr == 0 || dent->de_inum.no_formal_ino == 0;
@@ -686,17 +747,12 @@ static int get_leaf(struct gfs2_inode *dip, u64 leaf_no,
 static int get_leaf_nr(struct gfs2_inode *dip, u32 index,
                        u64 *leaf_out)
 {
-        __be64 leaf_no;
-        int error;
-
-        error = gfs2_dir_read_data(dip, (char *)&leaf_no,
-                                    index * sizeof(__be64),
-                                    sizeof(__be64), 0);
-        if (error != sizeof(u64))
-                return (error < 0) ? error : -EIO;
-
-        *leaf_out = be64_to_cpu(leaf_no);
+        __be64 *hash;
 
+        hash = gfs2_dir_get_hash_table(dip);
+        if (IS_ERR(hash))
+                return PTR_ERR(hash);
+        *leaf_out = be64_to_cpu(*(hash + index));
         return 0;
 }
 
@@ -966,6 +1022,8 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name)
         for (x = 0; x < half_len; x++)
                 lp[x] = cpu_to_be64(bn);
 
+        gfs2_dir_hash_inval(dip);
+
         error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),
                                     half_len * sizeof(u64));
         if (error != half_len * sizeof(u64)) {
@@ -1052,70 +1110,54 @@ fail_brelse:
 
 static int dir_double_exhash(struct gfs2_inode *dip)
 {
-        struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
         struct buffer_head *dibh;
         u32 hsize;
-        u64 *buf;
-        u64 *from, *to;
-        u64 block;
-        u64 disksize = i_size_read(&dip->i_inode);
+        u32 hsize_bytes;
+        __be64 *hc;
+        __be64 *hc2, *h;
         int x;
         int error = 0;
 
         hsize = 1 << dip->i_depth;
-        if (hsize * sizeof(u64) != disksize) {
-                gfs2_consist_inode(dip);
-                return -EIO;
-        }
+        hsize_bytes = hsize * sizeof(__be64);
 
-        /*  Allocate both the "from" and "to" buffers in one big chunk  */
+        hc = gfs2_dir_get_hash_table(dip);
+        if (IS_ERR(hc))
+                return PTR_ERR(hc);
 
-        buf = kcalloc(3, sdp->sd_hash_bsize, GFP_NOFS);
-        if (!buf)
+        h = hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS);
+        if (!hc2)
                 return -ENOMEM;
 
-        for (block = disksize >> sdp->sd_hash_bsize_shift; block--;) {
-                error = gfs2_dir_read_data(dip, (char *)buf,
-                                            block * sdp->sd_hash_bsize,
-                                            sdp->sd_hash_bsize, 1);
-                if (error != sdp->sd_hash_bsize) {
-                        if (error >= 0)
-                                error = -EIO;
-                        goto fail;
-                }
-
-                from = buf;
-                to = (u64 *)((char *)buf + sdp->sd_hash_bsize);
-
-                for (x = sdp->sd_hash_ptrs; x--; from++) {
-                        *to++ = *from;  /*  No endianess worries  */
-                        *to++ = *from;
-                }
+        error = gfs2_meta_inode_buffer(dip, &dibh);
+        if (error)
+                goto out_kfree;
 
-                error = gfs2_dir_write_data(dip,
-                                             (char *)buf + sdp->sd_hash_bsize,
-                                             block * sdp->sd_sb.sb_bsize,
-                                             sdp->sd_sb.sb_bsize);
-                if (error != sdp->sd_sb.sb_bsize) {
-                        if (error >= 0)
-                                error = -EIO;
-                        goto fail;
-                }
+        for (x = 0; x < hsize; x++) {
+                *h++ = *hc;
+                *h++ = *hc;
+                hc++;
         }
 
-        kfree(buf);
-
-        error = gfs2_meta_inode_buffer(dip, &dibh);
-        if (!gfs2_assert_withdraw(sdp, !error)) {
-                dip->i_depth++;
-                gfs2_dinode_out(dip, dibh->b_data);
-                brelse(dibh);
-        }
+        error = gfs2_dir_write_data(dip, (char *)hc2, 0, hsize_bytes * 2);
+        if (error != (hsize_bytes * 2))
+                goto fail;
 
-        return error;
+        gfs2_dir_hash_inval(dip);
+        dip->i_hash_cache = hc2;
+        dip->i_depth++;
+        gfs2_dinode_out(dip, dibh->b_data);
+        brelse(dibh);
+        return 0;
 
 fail:
-        kfree(buf);
+        /* Replace original hash table & size */
+        gfs2_dir_write_data(dip, (char *)hc, 0, hsize_bytes);
+        i_size_write(&dip->i_inode, hsize_bytes);
+        gfs2_dinode_out(dip, dibh->b_data);
+        brelse(dibh);
+out_kfree:
+        kfree(hc2);
         return error;
 }
 
@@ -1348,6 +1390,7 @@ out:
         return error;
 }
 
+
 /**
  * dir_e_read - Reads the entries from a directory into a filldir buffer
  * @dip: dinode pointer
@@ -1362,9 +1405,7 @@ static int dir_e_read(struct inode *inode, u64 *offset, void *opaque,
                       filldir_t filldir)
 {
         struct gfs2_inode *dip = GFS2_I(inode);
-        struct gfs2_sbd *sdp = GFS2_SB(inode);
         u32 hsize, len = 0;
-        u32 ht_offset, lp_offset, ht_offset_cur = -1;
         u32 hash, index;
         __be64 *lp;
         int copied = 0;
@@ -1372,37 +1413,17 @@ static int dir_e_read(struct inode *inode, u64 *offset, void *opaque,
         unsigned depth = 0;
 
         hsize = 1 << dip->i_depth;
-        if (hsize * sizeof(u64) != i_size_read(inode)) {
-                gfs2_consist_inode(dip);
-                return -EIO;
-        }
-
         hash = gfs2_dir_offset2hash(*offset);
         index = hash >> (32 - dip->i_depth);
 
-        lp = kmalloc(sdp->sd_hash_bsize, GFP_NOFS);
-        if (!lp)
-                return -ENOMEM;
+        lp = gfs2_dir_get_hash_table(dip);
+        if (IS_ERR(lp))
+                return PTR_ERR(lp);
 
         while (index < hsize) {
-                lp_offset = index & (sdp->sd_hash_ptrs - 1);
-                ht_offset = index - lp_offset;
-
-                if (ht_offset_cur != ht_offset) {
-                        error = gfs2_dir_read_data(dip, (char *)lp,
-                                                ht_offset * sizeof(__be64),
-                                                sdp->sd_hash_bsize, 1);
-                        if (error != sdp->sd_hash_bsize) {
-                                if (error >= 0)
-                                        error = -EIO;
-                                goto out;
-                        }
-                        ht_offset_cur = ht_offset;
-                }
-
                 error = gfs2_dir_read_leaf(inode, offset, opaque, filldir,
                                            &copied, &depth,
-                                           be64_to_cpu(lp[lp_offset]));
+                                           be64_to_cpu(lp[index]));
                 if (error)
                         break;
 
@@ -1410,8 +1431,6 @@ static int dir_e_read(struct inode *inode, u64 *offset, void *opaque,
                 index = (index & ~(len - 1)) + len;
         }
 
-out:
-        kfree(lp);
         if (error > 0)
                 error = 0;
         return error;
@@ -1914,43 +1933,22 @@ out:
 
 int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)
 {
-        struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
         struct buffer_head *bh;
         struct gfs2_leaf *leaf;
         u32 hsize, len;
-        u32 ht_offset, lp_offset, ht_offset_cur = -1;
         u32 index = 0, next_index;
         __be64 *lp;
         u64 leaf_no;
         int error = 0, last;
 
         hsize = 1 << dip->i_depth;
-        if (hsize * sizeof(u64) != i_size_read(&dip->i_inode)) {
-                gfs2_consist_inode(dip);
-                return -EIO;
-        }
 
-        lp = kmalloc(sdp->sd_hash_bsize, GFP_NOFS);
-        if (!lp)
-                return -ENOMEM;
+        lp = gfs2_dir_get_hash_table(dip);
+        if (IS_ERR(lp))
+                return PTR_ERR(lp);
 
         while (index < hsize) {
-                lp_offset = index & (sdp->sd_hash_ptrs - 1);
-                ht_offset = index - lp_offset;
-
-                if (ht_offset_cur != ht_offset) {
-                        error = gfs2_dir_read_data(dip, (char *)lp,
-                                                ht_offset * sizeof(__be64),
-                                                sdp->sd_hash_bsize, 1);
-                        if (error != sdp->sd_hash_bsize) {
-                                if (error >= 0)
-                                        error = -EIO;
-                                goto out;
-                        }
-                        ht_offset_cur = ht_offset;
-                }
-
-                leaf_no = be64_to_cpu(lp[lp_offset]);
+                leaf_no = be64_to_cpu(lp[index]);
                 if (leaf_no) {
                         error = get_leaf(dip, leaf_no, &bh);
                         if (error)
@@ -1976,7 +1974,6 @@ int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)
         }
 
 out:
-        kfree(lp);
 
         return error;
 }
diff --git a/fs/gfs2/dir.h b/fs/gfs2/dir.h
index e686af11becd..ff5772fbf024 100644
--- a/fs/gfs2/dir.h
+++ b/fs/gfs2/dir.h
@@ -35,6 +35,7 @@ extern int gfs2_diradd_alloc_required(struct inode *dir,
                                       const struct qstr *filename);
 extern int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block,
                                    struct buffer_head **bhp);
+extern void gfs2_dir_hash_inval(struct gfs2_inode *ip);
 
 static inline u32 gfs2_disk_hash(const char *data, int len)
 {
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index a9f5cbe45cd9..edeb9e802903 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -174,7 +174,9 @@ void gfs2_set_inode_flags(struct inode *inode)
         struct gfs2_inode *ip = GFS2_I(inode);
         unsigned int flags = inode->i_flags;
 
-        flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
+        flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_NOSEC);
+        if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))
+                inode->i_flags |= S_NOSEC;
         if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)
                 flags |= S_IMMUTABLE;
         if (ip->i_diskflags & GFS2_DIF_APPENDONLY)
@@ -243,7 +245,7 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
             !capable(CAP_LINUX_IMMUTABLE))
                 goto out;
         if (!IS_IMMUTABLE(inode)) {
-                error = gfs2_permission(inode, MAY_WRITE, 0);
+                error = gfs2_permission(inode, MAY_WRITE);
                 if (error)
                         goto out;
         }
@@ -544,7 +546,9 @@ static int gfs2_close(struct inode *inode, struct file *file)
 
 /**
  * gfs2_fsync - sync the dirty data for a file (across the cluster)
- * @file: the file that points to the dentry (we ignore this)
+ * @file: the file that points to the dentry
+ * @start: the start position in the file to sync
+ * @end: the end position in the file to sync
  * @datasync: set if we can ignore timestamp changes
  *
  * The VFS will flush data for us. We only need to worry
@@ -553,23 +557,32 @@ static int gfs2_close(struct inode *inode, struct file *file)
  * Returns: errno
  */
 
-static int gfs2_fsync(struct file *file, int datasync)
+static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
+                      int datasync)
 {
         struct inode *inode = file->f_mapping->host;
         int sync_state = inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC);
         struct gfs2_inode *ip = GFS2_I(inode);
         int ret;
 
+        ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (ret)
+                return ret;
+        mutex_lock(&inode->i_mutex);
+
         if (datasync)
                 sync_state &= ~I_DIRTY_SYNC;
 
         if (sync_state) {
                 ret = sync_inode_metadata(inode, 1);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&inode->i_mutex);
                         return ret;
+                }
                 gfs2_ail_flush(ip->i_gl);
         }
 
+        mutex_unlock(&inode->i_mutex);
         return 0;
 }
 
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index 1c1336e7b3b2..88e8a23d0026 100644
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -409,6 +409,10 @@ static void state_change(struct gfs2_glock *gl, unsigned int new_state)
         if (held1 && held2 && list_empty(&gl->gl_holders))
                 clear_bit(GLF_QUEUED, &gl->gl_flags);
 
+        if (new_state != gl->gl_target)
+                /* shorten our minimum hold time */
+                gl->gl_hold_time = max(gl->gl_hold_time - GL_GLOCK_HOLD_DECR,
+                                       GL_GLOCK_MIN_HOLD);
         gl->gl_state = new_state;
         gl->gl_tchange = jiffies;
 }
@@ -668,7 +672,7 @@ static void glock_work_func(struct work_struct *work)
             gl->gl_demote_state != LM_ST_EXCLUSIVE) {
                 unsigned long holdtime, now = jiffies;
 
-                holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time;
+                holdtime = gl->gl_tchange + gl->gl_hold_time;
                 if (time_before(now, holdtime))
                         delay = holdtime - now;
 
@@ -679,9 +683,14 @@ static void glock_work_func(struct work_struct *work)
         }
         run_queue(gl, 0);
         spin_unlock(&gl->gl_spin);
-        if (!delay ||
-            queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
+        if (!delay)
                 gfs2_glock_put(gl);
+        else {
+                if (gl->gl_name.ln_type != LM_TYPE_INODE)
+                        delay = 0;
+                if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
+                        gfs2_glock_put(gl);
+        }
         if (drop_ref)
                 gfs2_glock_put(gl);
 }
@@ -743,6 +752,7 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
         gl->gl_tchange = jiffies;
         gl->gl_object = NULL;
         gl->gl_sbd = sdp;
+        gl->gl_hold_time = GL_GLOCK_DFT_HOLD;
         INIT_DELAYED_WORK(&gl->gl_work, glock_work_func);
         INIT_WORK(&gl->gl_delete, delete_work_func);
 
@@ -855,8 +865,15 @@ static int gfs2_glock_demote_wait(void *word)
 
 static void wait_on_holder(struct gfs2_holder *gh)
 {
+        unsigned long time1 = jiffies;
+
         might_sleep();
         wait_on_bit(&gh->gh_iflags, HIF_WAIT, gfs2_glock_holder_wait, TASK_UNINTERRUPTIBLE);
+        if (time_after(jiffies, time1 + HZ)) /* have we waited > a second? */
+                /* Lengthen the minimum hold time. */
+                gh->gh_gl->gl_hold_time = min(gh->gh_gl->gl_hold_time +
+                                              GL_GLOCK_HOLD_INCR,
+                                              GL_GLOCK_MAX_HOLD);
 }
 
 static void wait_on_demote(struct gfs2_glock *gl)
@@ -1093,8 +1110,9 @@ void gfs2_glock_dq(struct gfs2_holder *gh)
 
         gfs2_glock_hold(gl);
         if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
-            !test_bit(GLF_DEMOTE, &gl->gl_flags))
-                delay = gl->gl_ops->go_min_hold_time;
+            !test_bit(GLF_DEMOTE, &gl->gl_flags) &&
+            gl->gl_name.ln_type == LM_TYPE_INODE)
+                delay = gl->gl_hold_time;
         if (queue_delayed_work(glock_workqueue, &gl->gl_work, delay) == 0)
                 gfs2_glock_put(gl);
 }
@@ -1273,12 +1291,13 @@ void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state)
         unsigned long now = jiffies;
 
         gfs2_glock_hold(gl);
-        holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time;
-        if (test_bit(GLF_QUEUED, &gl->gl_flags)) {
+        holdtime = gl->gl_tchange + gl->gl_hold_time;
+        if (test_bit(GLF_QUEUED, &gl->gl_flags) &&
+            gl->gl_name.ln_type == LM_TYPE_INODE) {
                 if (time_before(now, holdtime))
                         delay = holdtime - now;
                 if (test_bit(GLF_REPLY_PENDING, &gl->gl_flags))
-                        delay = gl->gl_ops->go_min_hold_time;
+                        delay = gl->gl_hold_time;
         }
 
         spin_lock(&gl->gl_spin);
@@ -1667,7 +1686,7 @@ static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl)
         dtime *= 1000000/HZ; /* demote time in uSec */
         if (!test_bit(GLF_DEMOTE, &gl->gl_flags))
                 dtime = 0;
-        gfs2_print_dbg(seq, "G:  s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d v:%d r:%d\n",
+        gfs2_print_dbg(seq, "G:  s:%s n:%u/%llx f:%s t:%s d:%s/%llu a:%d v:%d r:%d m:%ld\n",
                   state2str(gl->gl_state),
                   gl->gl_name.ln_type,
                   (unsigned long long)gl->gl_name.ln_number,
@@ -1676,7 +1695,7 @@ static int __dump_glock(struct seq_file *seq, const struct gfs2_glock *gl)
                   state2str(gl->gl_demote_state), dtime,
                   atomic_read(&gl->gl_ail_count),
                   atomic_read(&gl->gl_revokes),
-                  atomic_read(&gl->gl_ref));
+                  atomic_read(&gl->gl_ref), gl->gl_hold_time);
 
         list_for_each_entry(gh, &gl->gl_holders, gh_list) {
                 error = dump_holder(seq, gh);
diff --git a/fs/gfs2/glock.h b/fs/gfs2/glock.h
index 6b2f757b9281..66707118af25 100644
--- a/fs/gfs2/glock.h
+++ b/fs/gfs2/glock.h
@@ -113,6 +113,12 @@ enum {
 
 #define GLR_TRYFAILED           13
 
+#define GL_GLOCK_MAX_HOLD        (long)(HZ / 5)
+#define GL_GLOCK_DFT_HOLD        (long)(HZ / 5)
+#define GL_GLOCK_MIN_HOLD        (long)(10)
+#define GL_GLOCK_HOLD_INCR       (long)(HZ / 20)
+#define GL_GLOCK_HOLD_DECR       (long)(HZ / 40)
+
 struct lm_lockops {
         const char *lm_proto_name;
         int (*lm_mount) (struct gfs2_sbd *sdp, const char *fsname);
diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index 8ef70f464731..da21ecaafcc2 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -26,6 +26,7 @@
 #include "rgrp.h"
 #include "util.h"
 #include "trans.h"
+#include "dir.h"
 
 /**
  * __gfs2_ail_flush - remove all buffers for a given lock from the AIL
@@ -47,10 +48,10 @@ static void __gfs2_ail_flush(struct gfs2_glock *gl)
                                 bd_ail_gl_list);
                 bh = bd->bd_bh;
                 gfs2_remove_from_ail(bd);
-                spin_unlock(&sdp->sd_ail_lock);
-
                 bd->bd_bh = NULL;
                 bh->b_private = NULL;
+                spin_unlock(&sdp->sd_ail_lock);
+
                 bd->bd_blkno = bh->b_blocknr;
                 gfs2_log_lock(sdp);
                 gfs2_assert_withdraw(sdp, !buffer_busy(bh));
@@ -218,11 +219,14 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags)
                 if (ip) {
                         set_bit(GIF_INVALID, &ip->i_flags);
                         forget_all_cached_acls(&ip->i_inode);
+                        gfs2_dir_hash_inval(ip);
                 }
         }
 
-        if (ip == GFS2_I(gl->gl_sbd->sd_rindex))
+        if (ip == GFS2_I(gl->gl_sbd->sd_rindex)) {
+                gfs2_log_flush(gl->gl_sbd, NULL);
                 gl->gl_sbd->sd_rindex_uptodate = 0;
+        }
         if (ip && S_ISREG(ip->i_inode.i_mode))
                 truncate_inode_pages(ip->i_inode.i_mapping, 0);
 }
@@ -314,6 +318,8 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
         ip->i_generation = be64_to_cpu(str->di_generation);
 
         ip->i_diskflags = be32_to_cpu(str->di_flags);
+        ip->i_eattr = be64_to_cpu(str->di_eattr);
+        /* i_diskflags and i_eattr must be set before gfs2_set_inode_flags() */
         gfs2_set_inode_flags(&ip->i_inode);
         height = be16_to_cpu(str->di_height);
         if (unlikely(height > GFS2_MAX_META_HEIGHT))
@@ -326,7 +332,6 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
         ip->i_depth = (u8)depth;
         ip->i_entries = be32_to_cpu(str->di_entries);
 
-        ip->i_eattr = be64_to_cpu(str->di_eattr);
         if (S_ISREG(ip->i_inode.i_mode))
                 gfs2_set_aops(&ip->i_inode);
 
@@ -547,7 +552,6 @@ const struct gfs2_glock_operations gfs2_inode_glops = {
         .go_lock = inode_go_lock,
         .go_dump = inode_go_dump,
         .go_type = LM_TYPE_INODE,
-        .go_min_hold_time = HZ / 5,
         .go_flags = GLOF_ASPACE,
 };
 
@@ -558,7 +562,6 @@ const struct gfs2_glock_operations gfs2_rgrp_glops = {
         .go_unlock = rgrp_go_unlock,
         .go_dump = gfs2_rgrp_dump,
         .go_type = LM_TYPE_RGRP,
-        .go_min_hold_time = HZ / 5,
         .go_flags = GLOF_ASPACE,
 };
 
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 0a064e91ac70..892ac37de8ae 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -17,6 +17,7 @@
 #include <linux/buffer_head.h>
 #include <linux/rcupdate.h>
 #include <linux/rculist_bl.h>
+#include <linux/completion.h>
 
 #define DIO_WAIT        0x00000010
 #define DIO_METADATA    0x00000020
@@ -162,7 +163,6 @@ struct gfs2_glock_operations {
         int (*go_dump)(struct seq_file *seq, const struct gfs2_glock *gl);
         void (*go_callback) (struct gfs2_glock *gl);
         const int go_type;
-        const unsigned long go_min_hold_time;
         const unsigned long go_flags;
 #define GLOF_ASPACE 1
 };
@@ -220,6 +220,7 @@ struct gfs2_glock {
 
         unsigned int gl_hash;
         unsigned long gl_demote_time; /* time of first demote request */
+        long gl_hold_time;
         struct list_head gl_holders;
 
         const struct gfs2_glock_operations *gl_ops;
@@ -284,6 +285,7 @@ struct gfs2_inode {
         u64 i_goal;     /* goal block for allocations */
         struct rw_semaphore i_rw_mutex;
         struct list_head i_trunc_list;
+        __be64 *i_hash_cache;
         u32 i_entries;
         u32 i_diskflags;
         u8 i_height;
@@ -546,6 +548,7 @@ struct gfs2_sbd {
         struct gfs2_glock *sd_trans_gl;
         wait_queue_head_t sd_glock_wait;
         atomic_t sd_glock_disposal;
+        struct completion sd_locking_init;
 
         /* Inode Stuff */
 
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 1d3a1a651721..6525b804d5ec 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -307,7 +307,7 @@ struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
         }
 
         if (!is_root) {
-                error = gfs2_permission(dir, MAY_EXEC, 0);
+                error = gfs2_permission(dir, MAY_EXEC);
                 if (error)
                         goto out;
         }
@@ -337,7 +337,7 @@ static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 {
         int error;
 
-        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, 0);
+        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
         if (error)
                 return error;
 
@@ -790,13 +790,8 @@ static int gfs2_create(struct inode *dir, struct dentry *dentry,
 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
                                   struct nameidata *nd)
 {
-        struct inode *inode = NULL;
-
-        inode = gfs2_lookupi(dir, &dentry->d_name, 0);
-        if (inode && IS_ERR(inode))
-                return ERR_CAST(inode);
-
-        if (inode) {
+        struct inode *inode = gfs2_lookupi(dir, &dentry->d_name, 0);
+        if (inode && !IS_ERR(inode)) {
                 struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
                 struct gfs2_holder gh;
                 int error;
@@ -806,11 +801,8 @@ static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
                         return ERR_PTR(error);
                 }
                 gfs2_glock_dq_uninit(&gh);
-                return d_splice_alias(inode, dentry);
         }
-        d_add(dentry, inode);
-
-        return NULL;
+        return d_splice_alias(inode, dentry);
 }
 
 /**
@@ -855,7 +847,7 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
         if (inode->i_nlink == 0)
                 goto out_gunlock;
 
-        error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC, 0);
+        error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
         if (error)
                 goto out_gunlock;
 
@@ -988,7 +980,7 @@ static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
         if (IS_APPEND(&dip->i_inode))
                 return -EPERM;
 
-        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC, 0);
+        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
         if (error)
                 return error;
 
@@ -1334,7 +1326,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
                         }
                 }
         } else {
-                error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC, 0);
+                error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
                 if (error)
                         goto out_gunlock;
 
@@ -1369,7 +1361,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
         /* Check out the dir to be renamed */
 
         if (dir_rename) {
-                error = gfs2_permission(odentry->d_inode, MAY_WRITE, 0);
+                error = gfs2_permission(odentry->d_inode, MAY_WRITE);
                 if (error)
                         goto out_gunlock;
         }
@@ -1541,7 +1533,7 @@ static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
  * Returns: errno
  */
 
-int gfs2_permission(struct inode *inode, int mask, unsigned int flags)
+int gfs2_permission(struct inode *inode, int mask)
 {
         struct gfs2_inode *ip;
         struct gfs2_holder i_gh;
@@ -1551,7 +1543,7 @@ int gfs2_permission(struct inode *inode, int mask, unsigned int flags)
 
         ip = GFS2_I(inode);
         if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
-                if (flags & IPERM_FLAG_RCU)
+                if (mask & MAY_NOT_BLOCK)
                         return -ECHILD;
                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
                 if (error)
@@ -1562,7 +1554,7 @@ int gfs2_permission(struct inode *inode, int mask, unsigned int flags)
         if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
                 error = -EACCES;
         else
-                error = generic_permission(inode, mask, flags, gfs2_check_acl);
+                error = generic_permission(inode, mask);
         if (unlock)
                 gfs2_glock_dq_uninit(&i_gh);
 
@@ -1852,6 +1844,7 @@ const struct inode_operations gfs2_file_iops = {
         .listxattr = gfs2_listxattr,
         .removexattr = gfs2_removexattr,
         .fiemap = gfs2_fiemap,
+        .get_acl = gfs2_get_acl,
 };
 
 const struct inode_operations gfs2_dir_iops = {
@@ -1872,6 +1865,7 @@ const struct inode_operations gfs2_dir_iops = {
         .listxattr = gfs2_listxattr,
         .removexattr = gfs2_removexattr,
         .fiemap = gfs2_fiemap,
+        .get_acl = gfs2_get_acl,
 };
 
 const struct inode_operations gfs2_symlink_iops = {
@@ -1886,5 +1880,6 @@ const struct inode_operations gfs2_symlink_iops = {
         .listxattr = gfs2_listxattr,
         .removexattr = gfs2_removexattr,
         .fiemap = gfs2_fiemap,
+        .get_acl = gfs2_get_acl,
 };
 
diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
index 31606076f701..8d90e0c07672 100644
--- a/fs/gfs2/inode.h
+++ b/fs/gfs2/inode.h
@@ -108,7 +108,7 @@ extern int gfs2_inode_refresh(struct gfs2_inode *ip);
 
 extern struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
                                   int is_root);
-extern int gfs2_permission(struct inode *inode, int mask, unsigned int flags);
+extern int gfs2_permission(struct inode *inode, int mask);
 extern int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr);
 extern struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
 extern void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf);
diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
index 903115f2bb34..85c62923ee29 100644
--- a/fs/gfs2/log.c
+++ b/fs/gfs2/log.c
@@ -903,6 +903,7 @@ void gfs2_meta_syncfs(struct gfs2_sbd *sdp)
                 if (gfs2_ail1_empty(sdp))
                         break;
         }
+        gfs2_log_flush(sdp, NULL);
 }
 
 static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp)
diff --git a/fs/gfs2/main.c b/fs/gfs2/main.c
index c2b34cd2abe0..8a139ff1919f 100644
--- a/fs/gfs2/main.c
+++ b/fs/gfs2/main.c
@@ -16,7 +16,7 @@
 #include <linux/gfs2_ondisk.h>
 #include <linux/rcupdate.h>
 #include <linux/rculist_bl.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -41,6 +41,7 @@ static void gfs2_init_inode_once(void *foo)
         init_rwsem(&ip->i_rw_mutex);
         INIT_LIST_HEAD(&ip->i_trunc_list);
         ip->i_alloc = NULL;
+        ip->i_hash_cache = NULL;
 }
 
 static void gfs2_init_glock_once(void *foo)
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 8ac9ae189b53..3bc073a4cf82 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -72,6 +72,7 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)
 
         init_waitqueue_head(&sdp->sd_glock_wait);
         atomic_set(&sdp->sd_glock_disposal, 0);
+        init_completion(&sdp->sd_locking_init);
         spin_lock_init(&sdp->sd_statfs_spin);
 
         spin_lock_init(&sdp->sd_rindex_spin);
@@ -1017,11 +1018,13 @@ hostdata_error:
                 fsname++;
         if (lm->lm_mount == NULL) {
                 fs_info(sdp, "Now mounting FS...\n");
+                complete_all(&sdp->sd_locking_init);
                 return 0;
         }
         ret = lm->lm_mount(sdp, fsname);
         if (ret == 0)
                 fs_info(sdp, "Joined cluster. Now mounting FS...\n");
+        complete_all(&sdp->sd_locking_init);
         return ret;
 }
 
@@ -1091,6 +1094,7 @@ static int fill_super(struct super_block *sb, struct gfs2_args *args, int silent
         if (sdp->sd_args.ar_nobarrier)
                 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
 
+        sb->s_flags |= MS_NOSEC;
         sb->s_magic = GFS2_MAGIC;
         sb->s_op = &gfs2_super_ops;
         sb->s_d_op = &gfs2_dops;
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 9b780df3fd54..7f8af1eb02de 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -1607,14 +1607,15 @@ rgrp_error:
 }
 
 /**
- * gfs2_free_data - free a contiguous run of data block(s)
+ * __gfs2_free_blocks - free a contiguous run of block(s)
  * @ip: the inode these blocks are being freed from
  * @bstart: first block of a run of contiguous blocks
  * @blen: the length of the block run
+ * @meta: 1 if the blocks represent metadata
  *
  */
 
-void __gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen)
+void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
 {
         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
         struct gfs2_rgrpd *rgd;
@@ -1631,54 +1632,11 @@ void __gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen)
         gfs2_trans_add_rg(rgd);
 
         /* Directories keep their data in the metadata address space */
-        if (ip->i_depth)
+        if (meta || ip->i_depth)
                 gfs2_meta_wipe(ip, bstart, blen);
 }
 
 /**
- * gfs2_free_data - free a contiguous run of data block(s)
- * @ip: the inode these blocks are being freed from
- * @bstart: first block of a run of contiguous blocks
- * @blen: the length of the block run
- *
- */
-
-void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen)
-{
-        struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
-
-        __gfs2_free_data(ip, bstart, blen);
-        gfs2_statfs_change(sdp, 0, +blen, 0);
-        gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
-}
-
-/**
- * gfs2_free_meta - free a contiguous run of data block(s)
- * @ip: the inode these blocks are being freed from
- * @bstart: first block of a run of contiguous blocks
- * @blen: the length of the block run
- *
- */
-
-void __gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
-{
-        struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
-        struct gfs2_rgrpd *rgd;
-
-        rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
-        if (!rgd)
-                return;
-        trace_gfs2_block_alloc(ip, bstart, blen, GFS2_BLKST_FREE);
-        rgd->rd_free += blen;
-
-        gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
-        gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
-
-        gfs2_trans_add_rg(rgd);
-        gfs2_meta_wipe(ip, bstart, blen);
-}
-
-/**
  * gfs2_free_meta - free a contiguous run of data block(s)
  * @ip: the inode these blocks are being freed from
  * @bstart: first block of a run of contiguous blocks
@@ -1690,7 +1648,7 @@ void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
 {
         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 
-        __gfs2_free_meta(ip, bstart, blen);
+        __gfs2_free_blocks(ip, bstart, blen, 1);
         gfs2_statfs_change(sdp, 0, +blen, 0);
         gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
 }
diff --git a/fs/gfs2/rgrp.h b/fs/gfs2/rgrp.h
index a80e3034ac47..d253f9a8c70e 100644
--- a/fs/gfs2/rgrp.h
+++ b/fs/gfs2/rgrp.h
@@ -52,9 +52,7 @@ extern int gfs2_ri_update(struct gfs2_inode *ip);
 extern int gfs2_alloc_block(struct gfs2_inode *ip, u64 *bn, unsigned int *n);
 extern int gfs2_alloc_di(struct gfs2_inode *ip, u64 *bn, u64 *generation);
 
-extern void __gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen);
-extern void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen);
-extern void __gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen);
+extern void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta);
 extern void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen);
 extern void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip);
 extern void gfs2_unlink_di(struct inode *inode);
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index ed540e7018be..b7beadd9ba4c 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -757,13 +757,17 @@ static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc)
         struct timespec atime;
         struct gfs2_dinode *di;
         int ret = -EAGAIN;
+        int unlock_required = 0;
 
         /* Skip timestamp update, if this is from a memalloc */
         if (current->flags & PF_MEMALLOC)
                 goto do_flush;
-        ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
-        if (ret)
-                goto do_flush;
+        if (!gfs2_glock_is_locked_by_me(ip->i_gl)) {
+                ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
+                if (ret)
+                        goto do_flush;
+                unlock_required = 1;
+        }
         ret = gfs2_trans_begin(sdp, RES_DINODE, 0);
         if (ret)
                 goto do_unlock;
@@ -780,7 +784,8 @@ static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc)
         }
         gfs2_trans_end(sdp);
 do_unlock:
-        gfs2_glock_dq_uninit(&gh);
+        if (unlock_required)
+                gfs2_glock_dq_uninit(&gh);
 do_flush:
         if (wbc->sync_mode == WB_SYNC_ALL)
                 gfs2_log_flush(GFS2_SB(inode), ip->i_gl);
@@ -1427,7 +1432,20 @@ out:
         return error;
 }
 
-/*
+/**
+ * gfs2_evict_inode - Remove an inode from cache
+ * @inode: The inode to evict
+ *
+ * There are three cases to consider:
+ * 1. i_nlink == 0, we are final opener (and must deallocate)
+ * 2. i_nlink == 0, we are not the final opener (and cannot deallocate)
+ * 3. i_nlink > 0
+ *
+ * If the fs is read only, then we have to treat all cases as per #3
+ * since we are unable to do any deallocation. The inode will be
+ * deallocated by the next read/write node to attempt an allocation
+ * in the same resource group
+ *
  * We have to (at the moment) hold the inodes main lock to cover
  * the gap between unlocking the shared lock on the iopen lock and
  * taking the exclusive lock. I'd rather do a shared -> exclusive
@@ -1470,6 +1488,8 @@ static void gfs2_evict_inode(struct inode *inode)
         if (error)
                 goto out_truncate;
 
+        /* Case 1 starts here */
+
         if (S_ISDIR(inode->i_mode) &&
             (ip->i_diskflags & GFS2_DIF_EXHASH)) {
                 error = gfs2_dir_exhash_dealloc(ip);
@@ -1493,13 +1513,16 @@ static void gfs2_evict_inode(struct inode *inode)
         goto out_unlock;
 
 out_truncate:
+        /* Case 2 starts here */
         error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks);
         if (error)
                 goto out_unlock;
-        gfs2_final_release_pages(ip);
+        /* Needs to be done before glock release & also in a transaction */
+        truncate_inode_pages(&inode->i_data, 0);
         gfs2_trans_end(sdp);
 
 out_unlock:
+        /* Error path for case 1 */
         if (test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags))
                 gfs2_glock_dq(&ip->i_iopen_gh);
         gfs2_holder_uninit(&ip->i_iopen_gh);
@@ -1507,9 +1530,10 @@ out_unlock:
         if (error && error != GLR_TRYFAILED && error != -EROFS)
                 fs_warn(sdp, "gfs2_evict_inode: %d\n", error);
 out:
+        /* Case 3 starts here */
         truncate_inode_pages(&inode->i_data, 0);
         end_writeback(inode);
-
+        gfs2_dir_hash_inval(ip);
         ip->i_gl->gl_object = NULL;
         gfs2_glock_add_to_lru(ip->i_gl);
         gfs2_glock_put(ip->i_gl);
diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
index e20eab37bc80..443cabcfcd23 100644
--- a/fs/gfs2/sys.c
+++ b/fs/gfs2/sys.c
@@ -338,6 +338,9 @@ static ssize_t lkfirst_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
         rv = sscanf(buf, "%u", &first);
         if (rv != 1 || first > 1)
                 return -EINVAL;
+        rv = wait_for_completion_killable(&sdp->sd_locking_init);
+        if (rv)
+                return rv;
         spin_lock(&sdp->sd_jindex_spin);
         rv = -EBUSY;
         if (test_bit(SDF_NOJOURNALID, &sdp->sd_flags) == 0)
@@ -414,7 +417,9 @@ static ssize_t jid_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
         rv = sscanf(buf, "%d", &jid);
         if (rv != 1)
                 return -EINVAL;
-
+        rv = wait_for_completion_killable(&sdp->sd_locking_init);
+        if (rv)
+                return rv;
         spin_lock(&sdp->sd_jindex_spin);
         rv = -EINVAL;
         if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)