Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw

Pull GFS2 updates from Steven Whitehouse:
 "There are a few bug fixes for various, mostly very minor corner cases,
  plus some interesting new features.

  The new features include atomic_open whose main benefit will be the
  reduction in locking overhead in case of combined lookup/create and
  open operations, sorting the log buffer lists by block number to
  improve the efficiency of AIL writeback, and aggressively issuing
  revokes in gfs2_log_flush to reduce overhead when dropping glocks."

* git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw:
  GFS2: Reserve journal space for quota change in do_grow
  GFS2: Fix fstrim boundary conditions
  GFS2: fix warning message
  GFS2: aggressively issue revokes in gfs2_log_flush
  GFS2: fix regression in dir_double_exhash
  GFS2: Add atomic_open support
  GFS2: Only do one directory search on create
  GFS2: fix error propagation in init_threads()
  GFS2: Remove no-op wrapper function
  GFS2: Cocci spatch "ptr_ret.spatch"
  GFS2: Eliminate gfs2_rg_lops
  GFS2: Sort buffer lists by inplace block number

17 files changed, 291 insertions, 126 deletions

diff --git a/fs/dcache.c b/fs/dcache.c
index f09b9085f7d8..5a23073138df 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1612,6 +1612,10 @@ EXPORT_SYMBOL(d_obtain_alias);
  * If a dentry was found and moved, then it is returned.  Otherwise NULL
  * is returned.  This matches the expected return value of ->lookup.
  *
+ * Cluster filesystems may call this function with a negative, hashed dentry.
+ * In that case, we know that the inode will be a regular file, and also this
+ * will only occur during atomic_open. So we need to check for the dentry
+ * being already hashed only in the final case.
  */
 struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
 {
@@ -1636,8 +1640,11 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
                         security_d_instantiate(dentry, inode);
                         d_rehash(dentry);
                 }
-        } else
-                d_add(dentry, inode);
+        } else {
+                d_instantiate(dentry, inode);
+                if (d_unhashed(dentry))
+                        d_rehash(dentry);
+        }
         return new;
 }
 EXPORT_SYMBOL(d_splice_alias);
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index 93b5809c20bb..5e2f56fccf6b 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -1232,7 +1232,9 @@ static int do_grow(struct inode *inode, u64 size)
                 unstuff = 1;
         }
 
-        error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT, 0);
+        error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT +
+                                 (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ?
+                                  0 : RES_QUOTA), 0);
         if (error)
                 goto do_grow_release;
 
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index e0449c10286a..0cb4c1557f20 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -1125,13 +1125,14 @@ static int dir_double_exhash(struct gfs2_inode *dip)
         if (IS_ERR(hc))
                 return PTR_ERR(hc);
 
-        h = hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS | __GFP_NOWARN);
+        hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS | __GFP_NOWARN);
         if (hc2 == NULL)
                 hc2 = __vmalloc(hsize_bytes * 2, GFP_NOFS, PAGE_KERNEL);
 
         if (!hc2)
                 return -ENOMEM;
 
+        h = hc2;
         error = gfs2_meta_inode_buffer(dip, &dibh);
         if (error)
                 goto out_kfree;
@@ -1547,9 +1548,9 @@ out:
 
 /**
  * gfs2_dir_search - Search a directory
- * @dip: The GFS2 inode
- * @filename:
- * @inode:
+ * @dip: The GFS2 dir inode
+ * @name: The name we are looking up
+ * @fail_on_exist: Fail if the name exists rather than looking it up
  *
  * This routine searches a directory for a file or another directory.
  * Assumes a glock is held on dip.
@@ -1557,22 +1558,25 @@ out:
  * Returns: errno
  */
 
-struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name)
+struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name,
+                              bool fail_on_exist)
 {
         struct buffer_head *bh;
         struct gfs2_dirent *dent;
-        struct inode *inode;
+        u64 addr, formal_ino;
+        u16 dtype;
 
         dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
         if (dent) {
                 if (IS_ERR(dent))
                         return ERR_CAST(dent);
-                inode = gfs2_inode_lookup(dir->i_sb, 
-                                be16_to_cpu(dent->de_type),
-                                be64_to_cpu(dent->de_inum.no_addr),
-                                be64_to_cpu(dent->de_inum.no_formal_ino), 0);
+                dtype = be16_to_cpu(dent->de_type);
+                addr = be64_to_cpu(dent->de_inum.no_addr);
+                formal_ino = be64_to_cpu(dent->de_inum.no_formal_ino);
                 brelse(bh);
-                return inode;
+                if (fail_on_exist)
+                        return ERR_PTR(-EEXIST);
+                return gfs2_inode_lookup(dir->i_sb, dtype, addr, formal_ino, 0);
         }
         return ERR_PTR(-ENOENT);
 }
diff --git a/fs/gfs2/dir.h b/fs/gfs2/dir.h
index ba9000bc1397..4f03bbd1873f 100644
--- a/fs/gfs2/dir.h
+++ b/fs/gfs2/dir.h
@@ -18,7 +18,8 @@ struct gfs2_inode;
 struct gfs2_inum;
 
 extern struct inode *gfs2_dir_search(struct inode *dir,
-                                     const struct qstr *filename);
+                                     const struct qstr *filename,
+                                     bool fail_on_exist);
 extern int gfs2_dir_check(struct inode *dir, const struct qstr *filename,
                           const struct gfs2_inode *ip);
 extern int gfs2_dir_add(struct inode *inode, const struct qstr *filename,
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index b3333371aebb..f99f9e8a325f 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -531,21 +531,30 @@ static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
 }
 
 /**
- * gfs2_open - open a file
- * @inode: the inode to open
- * @file: the struct file for this opening
+ * gfs2_open_common - This is common to open and atomic_open
+ * @inode: The inode being opened
+ * @file: The file being opened
  *
- * Returns: errno
+ * This maybe called under a glock or not depending upon how it has
+ * been called. We must always be called under a glock for regular
+ * files, however. For other file types, it does not matter whether
+ * we hold the glock or not.
+ *
+ * Returns: Error code or 0 for success
  */
 
-static int gfs2_open(struct inode *inode, struct file *file)
+int gfs2_open_common(struct inode *inode, struct file *file)
 {
-        struct gfs2_inode *ip = GFS2_I(inode);
-        struct gfs2_holder i_gh;
         struct gfs2_file *fp;
-        int error;
+        int ret;
 
-        fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
+        if (S_ISREG(inode->i_mode)) {
+                ret = generic_file_open(inode, file);
+                if (ret)
+                        return ret;
+        }
+
+        fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS);
         if (!fp)
                 return -ENOMEM;
 
@@ -553,29 +562,43 @@ static int gfs2_open(struct inode *inode, struct file *file)
 
         gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
         file->private_data = fp;
+        return 0;
+}
+
+/**
+ * gfs2_open - open a file
+ * @inode: the inode to open
+ * @file: the struct file for this opening
+ *
+ * After atomic_open, this function is only used for opening files
+ * which are already cached. We must still get the glock for regular
+ * files to ensure that we have the file size uptodate for the large
+ * file check which is in the common code. That is only an issue for
+ * regular files though.
+ *
+ * Returns: errno
+ */
+
+static int gfs2_open(struct inode *inode, struct file *file)
+{
+        struct gfs2_inode *ip = GFS2_I(inode);
+        struct gfs2_holder i_gh;
+        int error;
+        bool need_unlock = false;
 
         if (S_ISREG(ip->i_inode.i_mode)) {
                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
                                            &i_gh);
                 if (error)
-                        goto fail;
+                        return error;
+                need_unlock = true;
+        }
 
-                if (!(file->f_flags & O_LARGEFILE) &&
-                    i_size_read(inode) > MAX_NON_LFS) {
-                        error = -EOVERFLOW;
-                        goto fail_gunlock;
-                }
+        error = gfs2_open_common(inode, file);
 
+        if (need_unlock)
                 gfs2_glock_dq_uninit(&i_gh);
-        }
-
-        return 0;
 
-fail_gunlock:
-        gfs2_glock_dq_uninit(&i_gh);
-fail:
-        file->private_data = NULL;
-        kfree(fp);
         return error;
 }
 
diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index c66e99c97571..5f2e5224c51c 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -54,7 +54,6 @@ static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
         struct gfs2_bufdata *bd, *tmp;
         struct buffer_head *bh;
         const unsigned long b_state = (1UL << BH_Dirty)|(1UL << BH_Pinned)|(1UL << BH_Lock);
-        sector_t blocknr;
 
         gfs2_log_lock(sdp);
         spin_lock(&sdp->sd_ail_lock);
@@ -65,13 +64,6 @@ static void __gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
                                 continue;
                         gfs2_ail_error(gl, bh);
                 }
-                blocknr = bh->b_blocknr;
-                bh->b_private = NULL;
-                gfs2_remove_from_ail(bd); /* drops ref on bh */
-
-                bd->bd_bh = NULL;
-                bd->bd_blkno = blocknr;
-
                 gfs2_trans_add_revoke(sdp, bd);
         }
         GLOCK_BUG_ON(gl, !fsync && atomic_read(&gl->gl_ail_count));
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 62b484e4a9e4..bbb2715171cd 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -313,7 +313,7 @@ struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
                         goto out;
         }
 
-        inode = gfs2_dir_search(dir, name);
+        inode = gfs2_dir_search(dir, name, false);
         if (IS_ERR(inode))
                 error = PTR_ERR(inode);
 out:
@@ -346,17 +346,6 @@ static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
         if (!dip->i_inode.i_nlink)
                 return -ENOENT;
 
-        error = gfs2_dir_check(&dip->i_inode, name, NULL);
-        switch (error) {
-        case -ENOENT:
-                error = 0;
-                break;
-        case 0:
-                return -EEXIST;
-        default:
-                return error;
-        }
-
         if (dip->i_entries == (u32)-1)
                 return -EFBIG;
         if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
@@ -546,6 +535,7 @@ static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
  * gfs2_create_inode - Create a new inode
  * @dir: The parent directory
  * @dentry: The new dentry
+ * @file: If non-NULL, the file which is being opened
  * @mode: The permissions on the new inode
  * @dev: For device nodes, this is the device number
  * @symname: For symlinks, this is the link destination
@@ -555,8 +545,9 @@ static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
  */
 
 static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
+                             struct file *file,
                              umode_t mode, dev_t dev, const char *symname,
-                             unsigned int size, int excl)
+                             unsigned int size, int excl, int *opened)
 {
         const struct qstr *name = &dentry->d_name;
         struct gfs2_holder ghs[2];
@@ -564,6 +555,7 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
         struct gfs2_inode *dip = GFS2_I(dir), *ip;
         struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
         struct gfs2_glock *io_gl;
+        struct dentry *d;
         int error;
         u32 aflags = 0;
         int arq;
@@ -584,15 +576,30 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
                 goto fail;
 
         error = create_ok(dip, name, mode);
-        if ((error == -EEXIST) && S_ISREG(mode) && !excl) {
-                inode = gfs2_lookupi(dir, &dentry->d_name, 0);
-                gfs2_glock_dq_uninit(ghs);
-                d_instantiate(dentry, inode);
-                return IS_ERR(inode) ? PTR_ERR(inode) : 0;
-        }
         if (error)
                 goto fail_gunlock;
 
+        inode = gfs2_dir_search(dir, &dentry->d_name, !S_ISREG(mode) || excl);
+        error = PTR_ERR(inode);
+        if (!IS_ERR(inode)) {
+                d = d_splice_alias(inode, dentry);
+                error = 0;
+                if (file && !IS_ERR(d)) {
+                        if (d == NULL)
+                                d = dentry;
+                        if (S_ISREG(inode->i_mode))
+                                error = finish_open(file, d, gfs2_open_common, opened);
+                        else
+                                error = finish_no_open(file, d);
+                }
+                gfs2_glock_dq_uninit(ghs);
+                if (IS_ERR(d))
+                        return PTR_RET(d);
+                return error;
+        } else if (error != -ENOENT) {
+                goto fail_gunlock;
+        }
+
         arq = error = gfs2_diradd_alloc_required(dir, name);
         if (error < 0)
                 goto fail_gunlock;
@@ -686,10 +693,12 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
                 goto fail_gunlock3;
 
         mark_inode_dirty(inode);
+        d_instantiate(dentry, inode);
+        if (file)
+                error = finish_open(file, dentry, gfs2_open_common, opened);
         gfs2_glock_dq_uninit(ghs);
         gfs2_glock_dq_uninit(ghs + 1);
-        d_instantiate(dentry, inode);
-        return 0;
+        return error;
 
 fail_gunlock3:
         gfs2_glock_dq_uninit(ghs + 1);
@@ -729,36 +738,56 @@ fail:
 static int gfs2_create(struct inode *dir, struct dentry *dentry,
                        umode_t mode, bool excl)
 {
-        return gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0, excl);
+        return gfs2_create_inode(dir, dentry, NULL, S_IFREG | mode, 0, NULL, 0, excl, NULL);
 }
 
 /**
- * gfs2_lookup - Look up a filename in a directory and return its inode
+ * __gfs2_lookup - Look up a filename in a directory and return its inode
  * @dir: The directory inode
  * @dentry: The dentry of the new inode
- * @nd: passed from Linux VFS, ignored by us
+ * @file: File to be opened
+ * @opened: atomic_open flags
  *
- * Called by the VFS layer. Lock dir and call gfs2_lookupi()
  *
  * Returns: errno
  */
 
-static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
-                                  unsigned int flags)
+static struct dentry *__gfs2_lookup(struct inode *dir, struct dentry *dentry,
+                                    struct file *file, int *opened)
 {
-        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;
-                error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
-                if (error) {
-                        iput(inode);
-                        return ERR_PTR(error);
-                }
-                gfs2_glock_dq_uninit(&gh);
+        struct inode *inode;
+        struct dentry *d;
+        struct gfs2_holder gh;
+        struct gfs2_glock *gl;
+        int error;
+
+        inode = gfs2_lookupi(dir, &dentry->d_name, 0);
+        if (!inode)
+                return NULL;
+        if (IS_ERR(inode))
+                return ERR_CAST(inode);
+
+        gl = GFS2_I(inode)->i_gl;
+        error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
+        if (error) {
+                iput(inode);
+                return ERR_PTR(error);
         }
-        return d_splice_alias(inode, dentry);
+
+        d = d_splice_alias(inode, dentry);
+        if (file && S_ISREG(inode->i_mode))
+                error = finish_open(file, dentry, gfs2_open_common, opened);
+
+        gfs2_glock_dq_uninit(&gh);
+        if (error)
+                return ERR_PTR(error);
+        return d;
+}
+
+static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
+                                  unsigned flags)
+{
+        return __gfs2_lookup(dir, dentry, NULL, NULL);
 }
 
 /**
@@ -1076,7 +1105,7 @@ static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
         if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
                 return -ENAMETOOLONG;
 
-        return gfs2_create_inode(dir, dentry, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
+        return gfs2_create_inode(dir, dentry, NULL, S_IFLNK | S_IRWXUGO, 0, symname, size, 0, NULL);
 }
 
 /**
@@ -1092,7 +1121,7 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
         struct gfs2_sbd *sdp = GFS2_SB(dir);
         unsigned dsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
-        return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, dsize, 0);
+        return gfs2_create_inode(dir, dentry, NULL, S_IFDIR | mode, 0, NULL, dsize, 0, NULL);
 }
 
 /**
@@ -1107,7 +1136,43 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
                       dev_t dev)
 {
-        return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0, 0);
+        return gfs2_create_inode(dir, dentry, NULL, mode, dev, NULL, 0, 0, NULL);
+}
+
+/**
+ * gfs2_atomic_open - Atomically open a file
+ * @dir: The directory
+ * @dentry: The proposed new entry
+ * @file: The proposed new struct file
+ * @flags: open flags
+ * @mode: File mode
+ * @opened: Flag to say whether the file has been opened or not
+ *
+ * Returns: error code or 0 for success
+ */
+
+static int gfs2_atomic_open(struct inode *dir, struct dentry *dentry,
+                            struct file *file, unsigned flags,
+                            umode_t mode, int *opened)
+{
+        struct dentry *d;
+        bool excl = !!(flags & O_EXCL);
+
+        d = __gfs2_lookup(dir, dentry, file, opened);
+        if (IS_ERR(d))
+                return PTR_ERR(d);
+        if (d == NULL)
+                d = dentry;
+        if (d->d_inode) {
+                if (!(*opened & FILE_OPENED))
+                        return finish_no_open(file, d);
+                return 0;
+        }
+
+        if (!(flags & O_CREAT))
+                return -ENOENT;
+
+        return gfs2_create_inode(dir, dentry, file, S_IFREG | mode, 0, NULL, 0, excl, opened);
 }
 
 /*
@@ -1787,6 +1852,7 @@ const struct inode_operations gfs2_dir_iops = {
         .removexattr = gfs2_removexattr,
         .fiemap = gfs2_fiemap,
         .get_acl = gfs2_get_acl,
+        .atomic_open = gfs2_atomic_open,
 };
 
 const struct inode_operations gfs2_symlink_iops = {
diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
index c53c7477f6da..ba4d9492d422 100644
--- a/fs/gfs2/inode.h
+++ b/fs/gfs2/inode.h
@@ -109,6 +109,7 @@ extern int gfs2_permission(struct inode *inode, int mask);
 extern int gfs2_setattr_simple(struct inode *inode, 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);
+extern int gfs2_open_common(struct inode *inode, struct file *file);
 
 extern const struct inode_operations gfs2_file_iops;
 extern const struct inode_operations gfs2_dir_iops;
diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
index b404f4853034..610613fb65b5 100644
--- a/fs/gfs2/log.c
+++ b/fs/gfs2/log.c
@@ -211,15 +211,16 @@ static void gfs2_ail1_empty_one(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
 static int gfs2_ail1_empty(struct gfs2_sbd *sdp)
 {
         struct gfs2_trans *tr, *s;
+        int oldest_tr = 1;
         int ret;
 
         spin_lock(&sdp->sd_ail_lock);
         list_for_each_entry_safe_reverse(tr, s, &sdp->sd_ail1_list, tr_list) {
                 gfs2_ail1_empty_one(sdp, tr);
-                if (list_empty(&tr->tr_ail1_list))
+                if (list_empty(&tr->tr_ail1_list) && oldest_tr)
                         list_move(&tr->tr_list, &sdp->sd_ail2_list);
                 else
-                        break;
+                        oldest_tr = 0;
         }
         ret = list_empty(&sdp->sd_ail1_list);
         spin_unlock(&sdp->sd_ail_lock);
@@ -317,7 +318,7 @@ static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
 
 int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks)
 {
-        unsigned reserved_blks = 6 * (4096 / sdp->sd_vfs->s_blocksize);
+        unsigned reserved_blks = 7 * (4096 / sdp->sd_vfs->s_blocksize);
         unsigned wanted = blks + reserved_blks;
         DEFINE_WAIT(wait);
         int did_wait = 0;
@@ -545,6 +546,76 @@ void gfs2_ordered_del_inode(struct gfs2_inode *ip)
         spin_unlock(&sdp->sd_ordered_lock);
 }
 
+void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
+{
+        struct buffer_head *bh = bd->bd_bh;
+        struct gfs2_glock *gl = bd->bd_gl;
+
+        gfs2_remove_from_ail(bd);
+        bd->bd_bh = NULL;
+        bh->b_private = NULL;
+        bd->bd_blkno = bh->b_blocknr;
+        bd->bd_ops = &gfs2_revoke_lops;
+        sdp->sd_log_num_revoke++;
+        atomic_inc(&gl->gl_revokes);
+        set_bit(GLF_LFLUSH, &gl->gl_flags);
+        list_add(&bd->bd_list, &sdp->sd_log_le_revoke);
+}
+
+void gfs2_write_revokes(struct gfs2_sbd *sdp)
+{
+        struct gfs2_trans *tr;
+        struct gfs2_bufdata *bd, *tmp;
+        int have_revokes = 0;
+        int max_revokes = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_log_descriptor)) / sizeof(u64);
+
+        gfs2_ail1_empty(sdp);
+        spin_lock(&sdp->sd_ail_lock);
+        list_for_each_entry(tr, &sdp->sd_ail1_list, tr_list) {
+                list_for_each_entry(bd, &tr->tr_ail2_list, bd_ail_st_list) {
+                        if (list_empty(&bd->bd_list)) {
+                                have_revokes = 1;
+                                goto done;
+                        }
+                }
+        }
+done:
+        spin_unlock(&sdp->sd_ail_lock);
+        if (have_revokes == 0)
+                return;
+        while (sdp->sd_log_num_revoke > max_revokes)
+                max_revokes += (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header)) / sizeof(u64);
+        max_revokes -= sdp->sd_log_num_revoke;
+        if (!sdp->sd_log_num_revoke) {
+                atomic_dec(&sdp->sd_log_blks_free);
+                /* If no blocks have been reserved, we need to also
+                 * reserve a block for the header */
+                if (!sdp->sd_log_blks_reserved)
+                        atomic_dec(&sdp->sd_log_blks_free);
+        }
+        gfs2_log_lock(sdp);
+        spin_lock(&sdp->sd_ail_lock);
+        list_for_each_entry(tr, &sdp->sd_ail1_list, tr_list) {
+                list_for_each_entry_safe(bd, tmp, &tr->tr_ail2_list, bd_ail_st_list) {
+                        if (max_revokes == 0)
+                                goto out_of_blocks;
+                        if (!list_empty(&bd->bd_list))
+                                continue;
+                        gfs2_add_revoke(sdp, bd);
+                        max_revokes--;
+                }
+        }
+out_of_blocks:
+        spin_unlock(&sdp->sd_ail_lock);
+        gfs2_log_unlock(sdp);
+
+        if (!sdp->sd_log_num_revoke) {
+                atomic_inc(&sdp->sd_log_blks_free);
+                if (!sdp->sd_log_blks_reserved)
+                        atomic_inc(&sdp->sd_log_blks_free);
+        }
+}
+
 /**
  * log_write_header - Get and initialize a journal header buffer
  * @sdp: The GFS2 superblock
@@ -562,7 +633,6 @@ static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
         lh = page_address(page);
         clear_page(lh);
 
-        gfs2_ail1_empty(sdp);
         tail = current_tail(sdp);
 
         lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
diff --git a/fs/gfs2/log.h b/fs/gfs2/log.h
index 3566f35915e0..37216634f0aa 100644
--- a/fs/gfs2/log.h
+++ b/fs/gfs2/log.h
@@ -72,5 +72,7 @@ extern void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc)
 extern void gfs2_log_shutdown(struct gfs2_sbd *sdp);
 extern void gfs2_meta_syncfs(struct gfs2_sbd *sdp);
 extern int gfs2_logd(void *data);
+extern void gfs2_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd);
+extern void gfs2_write_revokes(struct gfs2_sbd *sdp);
 
 #endif /* __LOG_DOT_H__ */
diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index 6c33d7b6e0c4..17c5b5d7dc88 100644
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -16,6 +16,7 @@
 #include <linux/gfs2_ondisk.h>
 #include <linux/bio.h>
 #include <linux/fs.h>
+#include <linux/list_sort.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -401,6 +402,20 @@ static void gfs2_check_magic(struct buffer_head *bh)
         kunmap_atomic(kaddr);
 }
 
+static int blocknr_cmp(void *priv, struct list_head *a, struct list_head *b)
+{
+        struct gfs2_bufdata *bda, *bdb;
+
+        bda = list_entry(a, struct gfs2_bufdata, bd_list);
+        bdb = list_entry(b, struct gfs2_bufdata, bd_list);
+
+        if (bda->bd_bh->b_blocknr < bdb->bd_bh->b_blocknr)
+                return -1;
+        if (bda->bd_bh->b_blocknr > bdb->bd_bh->b_blocknr)
+                return 1;
+        return 0;
+}
+
 static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
                                 unsigned int total, struct list_head *blist,
                                 bool is_databuf)
@@ -413,6 +428,7 @@ static void gfs2_before_commit(struct gfs2_sbd *sdp, unsigned int limit,
         __be64 *ptr;
 
         gfs2_log_lock(sdp);
+        list_sort(NULL, blist, blocknr_cmp);
         bd1 = bd2 = list_prepare_entry(bd1, blist, bd_list);
         while(total) {
                 num = total;
@@ -590,6 +606,7 @@ static void revoke_lo_before_commit(struct gfs2_sbd *sdp)
         struct page *page;
         unsigned int length;
 
+        gfs2_write_revokes(sdp);
         if (!sdp->sd_log_num_revoke)
                 return;
 
@@ -836,10 +853,6 @@ const struct gfs2_log_operations gfs2_revoke_lops = {
         .lo_name = "revoke",
 };
 
-const struct gfs2_log_operations gfs2_rg_lops = {
-        .lo_name = "rg",
-};
-
 const struct gfs2_log_operations gfs2_databuf_lops = {
         .lo_before_commit = databuf_lo_before_commit,
         .lo_after_commit = databuf_lo_after_commit,
@@ -851,7 +864,6 @@ const struct gfs2_log_operations gfs2_databuf_lops = {
 const struct gfs2_log_operations *gfs2_log_ops[] = {
         &gfs2_databuf_lops,
         &gfs2_buf_lops,
-        &gfs2_rg_lops,
         &gfs2_revoke_lops,
         NULL,
 };
diff --git a/fs/gfs2/lops.h b/fs/gfs2/lops.h
index 87e062e05c92..9ca2e6438419 100644
--- a/fs/gfs2/lops.h
+++ b/fs/gfs2/lops.h
@@ -23,7 +23,6 @@
 extern const struct gfs2_log_operations gfs2_glock_lops;
 extern const struct gfs2_log_operations gfs2_buf_lops;
 extern const struct gfs2_log_operations gfs2_revoke_lops;
-extern const struct gfs2_log_operations gfs2_rg_lops;
 extern const struct gfs2_log_operations gfs2_databuf_lops;
 
 extern const struct gfs2_log_operations *gfs2_log_ops[];
diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 1a89afb68472..0da390686c08 100644
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -296,10 +296,6 @@ void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int
         if (bd) {
                 spin_lock(&sdp->sd_ail_lock);
                 if (bd->bd_tr) {
-                        gfs2_remove_from_ail(bd);
-                        bh->b_private = NULL;
-                        bd->bd_bh = NULL;
-                        bd->bd_blkno = bh->b_blocknr;
                         gfs2_trans_add_revoke(sdp, bd);
                 }
                 spin_unlock(&sdp->sd_ail_lock);
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 60ede2a0f43f..0262c190b6f9 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -916,16 +916,16 @@ static int init_threads(struct gfs2_sbd *sdp, int undo)
                 goto fail_quotad;
 
         p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
-        error = IS_ERR(p);
-        if (error) {
+        if (IS_ERR(p)) {
+                error = PTR_ERR(p);
                 fs_err(sdp, "can't start logd thread: %d\n", error);
                 return error;
         }
         sdp->sd_logd_process = p;
 
         p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
-        error = IS_ERR(p);
-        if (error) {
+        if (IS_ERR(p)) {
+                error = PTR_ERR(p);
                 fs_err(sdp, "can't start quotad thread: %d\n", error);
                 goto fail;
         }
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index c253b13722e8..3768c2f40e43 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -1154,11 +1154,6 @@ int gfs2_quota_sync(struct super_block *sb, int type)
         return error;
 }
 
-static int gfs2_quota_sync_timeo(struct super_block *sb, int type)
-{
-        return gfs2_quota_sync(sb, type);
-}
-
 int gfs2_quota_refresh(struct gfs2_sbd *sdp, struct kqid qid)
 {
         struct gfs2_quota_data *qd;
@@ -1414,7 +1409,7 @@ int gfs2_quotad(void *data)
                                            &tune->gt_statfs_quantum);
 
                 /* Update quota file */
-                quotad_check_timeo(sdp, "sync", gfs2_quota_sync_timeo, t,
+                quotad_check_timeo(sdp, "sync", gfs2_quota_sync, t,
                                    &quotad_timeo, &tune->gt_quota_quantum);
 
                 /* Check for & recover partially truncated inodes */
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 9809156e3d04..69317435faa7 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -1288,13 +1288,15 @@ int gfs2_fitrim(struct file *filp, void __user *argp)
         minlen = max_t(u64, r.minlen,
                        q->limits.discard_granularity) >> bs_shift;
 
+        if (end <= start || minlen > sdp->sd_max_rg_data)
+                return -EINVAL;
+
         rgd = gfs2_blk2rgrpd(sdp, start, 0);
-        rgd_end = gfs2_blk2rgrpd(sdp, end - 1, 0);
+        rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
 
-        if (end <= start ||
-            minlen > sdp->sd_max_rg_data ||
-            start > rgd_end->rd_data0 + rgd_end->rd_data)
-                return -EINVAL;
+        if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
+            && (start > rgd_end->rd_data0 + rgd_end->rd_data))
+                return -EINVAL; /* start is beyond the end of the fs */
 
         while (1) {
 
@@ -1336,7 +1338,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp)
         }
 
 out:
-        r.len = trimmed << 9;
+        r.len = trimmed << bs_shift;
         if (copy_to_user(argp, &r, sizeof(r)))
                 return -EFAULT;
 
diff --git a/fs/gfs2/trans.c b/fs/gfs2/trans.c
index 7374907742a8..2b20d7046bf3 100644
--- a/fs/gfs2/trans.c
+++ b/fs/gfs2/trans.c
@@ -270,19 +270,12 @@ void gfs2_trans_add_meta(struct gfs2_glock *gl, struct buffer_head *bh)
 
 void gfs2_trans_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
 {
-        struct gfs2_glock *gl = bd->bd_gl;
         struct gfs2_trans *tr = current->journal_info;
 
         BUG_ON(!list_empty(&bd->bd_list));
-        BUG_ON(!list_empty(&bd->bd_ail_st_list));
-        BUG_ON(!list_empty(&bd->bd_ail_gl_list));
-        bd->bd_ops = &gfs2_revoke_lops;
+        gfs2_add_revoke(sdp, bd);
         tr->tr_touched = 1;
         tr->tr_num_revoke++;
-        sdp->sd_log_num_revoke++;
-        atomic_inc(&gl->gl_revokes);
-        set_bit(GLF_LFLUSH, &gl->gl_flags);
-        list_add(&bd->bd_list, &sdp->sd_log_le_revoke);
 }
 
 void gfs2_trans_add_unrevoke(struct gfs2_sbd *sdp, u64 blkno, unsigned int len)