18 files changed, 246 insertions, 163 deletions

diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index ce62dcac90b6..5a49b037da81 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
@@ -431,7 +431,7 @@ static int gfs2_jdata_writepages(struct address_space *mapping,
 
         ret = gfs2_write_cache_jdata(mapping, wbc);
         if (ret == 0 && wbc->sync_mode == WB_SYNC_ALL) {
-                gfs2_log_flush(sdp, ip->i_gl);
+                gfs2_log_flush(sdp, ip->i_gl, NORMAL_FLUSH);
                 ret = gfs2_write_cache_jdata(mapping, wbc);
         }
         return ret;
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index c62d4b9f51dc..e6ee5b6e8d99 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -707,7 +707,7 @@ int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsi
  * @top: The first pointer in the buffer
  * @bottom: One more than the last pointer
  * @height: the height this buffer is at
- * @data: a pointer to a struct strip_mine
+ * @sm: a pointer to a struct strip_mine
  *
  * Returns: errno
  */
@@ -992,6 +992,8 @@ unlock:
         return err;
 }
 
+#define GFS2_JTRUNC_REVOKES 8192
+
 /**
  * gfs2_journaled_truncate - Wrapper for truncate_pagecache for jdata files
  * @inode: The inode being truncated
@@ -1003,8 +1005,6 @@ unlock:
  * if the number of pages being truncated gets too large.
  */
 
-#define GFS2_JTRUNC_REVOKES 8192
-
 static int gfs2_journaled_truncate(struct inode *inode, u64 oldsize, u64 newsize)
 {
         struct gfs2_sbd *sdp = GFS2_SB(inode);
@@ -1348,7 +1348,7 @@ void gfs2_free_journal_extents(struct gfs2_jdesc *jd)
  * gfs2_add_jextent - Add or merge a new extent to extent cache
  * @jd: The journal descriptor
  * @lblock: The logical block at start of new extent
- * @pblock: The physical block at start of new extent
+ * @dblock: The physical block at start of new extent
  * @blocks: Size of extent in fs blocks
  *
  * Returns: 0 on success or -ENOMEM
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index 80d67253623c..6ab0cfb2e891 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -203,9 +203,9 @@ void gfs2_set_inode_flags(struct inode *inode)
                              GFS2_DIF_INHERIT_JDATA)
 
 /**
- * gfs2_set_flags - set flags on an inode
- * @inode: The inode
- * @flags: The flags to set
+ * do_gfs2_set_flags - set flags on an inode
+ * @filp: file pointer
+ * @reqflags: The flags to set
  * @mask: Indicates which flags are valid
  *
  */
@@ -256,7 +256,7 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
         }
         if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
                 if (flags & GFS2_DIF_JDATA)
-                        gfs2_log_flush(sdp, ip->i_gl);
+                        gfs2_log_flush(sdp, ip->i_gl, NORMAL_FLUSH);
                 error = filemap_fdatawrite(inode->i_mapping);
                 if (error)
                         goto out;
@@ -318,7 +318,7 @@ static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
 /**
  * gfs2_size_hint - Give a hint to the size of a write request
- * @file: The struct file
+ * @filep: The struct file
  * @offset: The file offset of the write
  * @size: The length of the write
  *
@@ -371,7 +371,7 @@ static int gfs2_allocate_page_backing(struct page *page)
 /**
  * gfs2_page_mkwrite - Make a shared, mmap()ed, page writable
  * @vma: The virtual memory area
- * @page: The page which is about to become writable
+ * @vmf: The virtual memory fault containing the page to become writable
  *
  * When the page becomes writable, we need to ensure that we have
  * blocks allocated on disk to back that page.
diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index 74d9a3dbf16f..fc1100781bbc 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -89,18 +89,23 @@ static void gfs2_ail_empty_gl(struct gfs2_glock *gl)
         if (!tr.tr_revokes)
                 return;
 
-        /* A shortened, inline version of gfs2_trans_begin() */
+        /* A shortened, inline version of gfs2_trans_begin()
+         * tr->alloced is not set since the transaction structure is
+         * on the stack */
         tr.tr_reserved = 1 + gfs2_struct2blk(sdp, tr.tr_revokes, sizeof(u64));
         tr.tr_ip = (unsigned long)__builtin_return_address(0);
         sb_start_intwrite(sdp->sd_vfs);
-        gfs2_log_reserve(sdp, tr.tr_reserved);
+        if (gfs2_log_reserve(sdp, tr.tr_reserved) < 0) {
+                sb_end_intwrite(sdp->sd_vfs);
+                return;
+        }
         WARN_ON_ONCE(current->journal_info);
         current->journal_info = &tr;
 
         __gfs2_ail_flush(gl, 0, tr.tr_revokes);
 
         gfs2_trans_end(sdp);
-        gfs2_log_flush(sdp, NULL);
+        gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
 }
 
 void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
@@ -121,7 +126,7 @@ void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
                 return;
         __gfs2_ail_flush(gl, fsync, max_revokes);
         gfs2_trans_end(sdp);
-        gfs2_log_flush(sdp, NULL);
+        gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
 }
 
 /**
@@ -144,7 +149,7 @@ static void rgrp_go_sync(struct gfs2_glock *gl)
                 return;
         GLOCK_BUG_ON(gl, gl->gl_state != LM_ST_EXCLUSIVE);
 
-        gfs2_log_flush(sdp, gl);
+        gfs2_log_flush(sdp, gl, NORMAL_FLUSH);
         filemap_fdatawrite_range(mapping, gl->gl_vm.start, gl->gl_vm.end);
         error = filemap_fdatawait_range(mapping, gl->gl_vm.start, gl->gl_vm.end);
         mapping_set_error(mapping, error);
@@ -206,7 +211,7 @@ static void inode_go_sync(struct gfs2_glock *gl)
 
         GLOCK_BUG_ON(gl, gl->gl_state != LM_ST_EXCLUSIVE);
 
-        gfs2_log_flush(gl->gl_sbd, gl);
+        gfs2_log_flush(gl->gl_sbd, gl, NORMAL_FLUSH);
         filemap_fdatawrite(metamapping);
         if (ip) {
                 struct address_space *mapping = ip->i_inode.i_mapping;
@@ -253,7 +258,7 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags)
         }
 
         if (ip == GFS2_I(gl->gl_sbd->sd_rindex)) {
-                gfs2_log_flush(gl->gl_sbd, NULL);
+                gfs2_log_flush(gl->gl_sbd, NULL, NORMAL_FLUSH);
                 gl->gl_sbd->sd_rindex_uptodate = 0;
         }
         if (ip && S_ISREG(ip->i_inode.i_mode))
@@ -455,31 +460,39 @@ static void inode_go_dump(struct seq_file *seq, const struct gfs2_glock *gl)
 }
 
 /**
- * trans_go_sync - promote/demote the transaction glock
+ * freeze_go_sync - promote/demote the freeze glock
  * @gl: the glock
  * @state: the requested state
  * @flags:
  *
  */
 
-static void trans_go_sync(struct gfs2_glock *gl)
+static void freeze_go_sync(struct gfs2_glock *gl)
 {
         struct gfs2_sbd *sdp = gl->gl_sbd;
+        DEFINE_WAIT(wait);
 
-        if (gl->gl_state != LM_ST_UNLOCKED &&
+        if (gl->gl_state == LM_ST_SHARED &&
             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
-                gfs2_meta_syncfs(sdp);
-                gfs2_log_shutdown(sdp);
+                atomic_set(&sdp->sd_log_freeze, 1);
+                wake_up(&sdp->sd_logd_waitq);
+                do {
+                        prepare_to_wait(&sdp->sd_log_frozen_wait, &wait,
+                                        TASK_UNINTERRUPTIBLE);
+                        if (atomic_read(&sdp->sd_log_freeze))
+                                io_schedule();
+                } while(atomic_read(&sdp->sd_log_freeze));
+                finish_wait(&sdp->sd_log_frozen_wait, &wait);
         }
 }
 
 /**
- * trans_go_xmote_bh - After promoting/demoting the transaction glock
+ * freeze_go_xmote_bh - After promoting/demoting the freeze glock
  * @gl: the glock
  *
  */
 
-static int trans_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh)
+static int freeze_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh)
 {
         struct gfs2_sbd *sdp = gl->gl_sbd;
         struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
@@ -512,7 +525,7 @@ static int trans_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh)
  * Always returns 0
  */
 
-static int trans_go_demote_ok(const struct gfs2_glock *gl)
+static int freeze_go_demote_ok(const struct gfs2_glock *gl)
 {
         return 0;
 }
@@ -563,10 +576,10 @@ const struct gfs2_glock_operations gfs2_rgrp_glops = {
         .go_flags = GLOF_LVB,
 };
 
-const struct gfs2_glock_operations gfs2_trans_glops = {
-        .go_sync = trans_go_sync,
-        .go_xmote_bh = trans_go_xmote_bh,
-        .go_demote_ok = trans_go_demote_ok,
+const struct gfs2_glock_operations gfs2_freeze_glops = {
+        .go_sync = freeze_go_sync,
+        .go_xmote_bh = freeze_go_xmote_bh,
+        .go_demote_ok = freeze_go_demote_ok,
         .go_type = LM_TYPE_NONDISK,
 };
 
diff --git a/fs/gfs2/glops.h b/fs/gfs2/glops.h
index bf95a2dc1662..7455d2629bcb 100644
--- a/fs/gfs2/glops.h
+++ b/fs/gfs2/glops.h
@@ -15,7 +15,7 @@
 extern const struct gfs2_glock_operations gfs2_meta_glops;
 extern const struct gfs2_glock_operations gfs2_inode_glops;
 extern const struct gfs2_glock_operations gfs2_rgrp_glops;
-extern const struct gfs2_glock_operations gfs2_trans_glops;
+extern const struct gfs2_glock_operations gfs2_freeze_glops;
 extern const struct gfs2_glock_operations gfs2_iopen_glops;
 extern const struct gfs2_glock_operations gfs2_flock_glops;
 extern const struct gfs2_glock_operations gfs2_nondisk_glops;
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index bdf70c18610c..67d310c9ada3 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -465,9 +465,7 @@ struct gfs2_trans {
         unsigned int tr_reserved;
         unsigned int tr_touched:1;
         unsigned int tr_attached:1;
-
-        struct gfs2_holder tr_t_gh;
-
+        unsigned int tr_alloced:1;
 
         unsigned int tr_num_buf_new;
         unsigned int tr_num_databuf_new;
@@ -682,7 +680,7 @@ struct gfs2_sbd {
         struct lm_lockstruct sd_lockstruct;
         struct gfs2_holder sd_live_gh;
         struct gfs2_glock *sd_rename_gl;
-        struct gfs2_glock *sd_trans_gl;
+        struct gfs2_glock *sd_freeze_gl;
         wait_queue_head_t sd_glock_wait;
         atomic_t sd_glock_disposal;
         struct completion sd_locking_init;
@@ -730,6 +728,8 @@ struct gfs2_sbd {
         struct gfs2_holder sd_sc_gh;
         struct gfs2_holder sd_qc_gh;
 
+        struct completion sd_journal_ready;
+
         /* Daemon stuff */
 
         struct task_struct *sd_logd_process;
@@ -794,6 +794,12 @@ struct gfs2_sbd {
 
         /* For quiescing the filesystem */
         struct gfs2_holder sd_freeze_gh;
+        struct gfs2_holder sd_freeze_root_gh;
+        struct gfs2_holder sd_thaw_gh;
+        atomic_t sd_log_freeze;
+        atomic_t sd_frozen_root;
+        wait_queue_head_t sd_frozen_root_wait;
+        wait_queue_head_t sd_log_frozen_wait;
 
         char sd_fsname[GFS2_FSNAME_LEN];
         char sd_table_name[GFS2_FSNAME_LEN];
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 28cc7bf6575a..e62e59477884 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -1613,18 +1613,26 @@ int gfs2_permission(struct inode *inode, int mask)
 {
         struct gfs2_inode *ip;
         struct gfs2_holder i_gh;
+        struct gfs2_sbd *sdp = GFS2_SB(inode);
         int error;
         int unlock = 0;
+        int frozen_root = 0;
 
 
         ip = GFS2_I(inode);
         if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
-                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)
-                        return error;
-                unlock = 1;
+                if (unlikely(gfs2_glock_is_held_excl(sdp->sd_freeze_gl) &&
+                             inode == sdp->sd_root_dir->d_inode &&
+                             atomic_inc_not_zero(&sdp->sd_frozen_root)))
+                        frozen_root = 1;
+                else {
+                        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)
+                                return error;
+                        unlock = 1;
+                }
         }
 
         if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
@@ -1633,6 +1641,8 @@ int gfs2_permission(struct inode *inode, int mask)
                 error = generic_permission(inode, mask);
         if (unlock)
                 gfs2_glock_dq_uninit(&i_gh);
+        else if (frozen_root && atomic_dec_and_test(&sdp->sd_frozen_root))
+                wake_up(&sdp->sd_frozen_root_wait);
 
         return error;
 }
@@ -1805,19 +1815,29 @@ static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
         struct inode *inode = dentry->d_inode;
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_holder gh;
+        struct gfs2_sbd *sdp = GFS2_SB(inode);
         int error;
         int unlock = 0;
+        int frozen_root = 0;
 
         if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
-                error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
-                if (error)
-                        return error;
-                unlock = 1;
+                if (unlikely(gfs2_glock_is_held_excl(sdp->sd_freeze_gl) &&
+                             inode == sdp->sd_root_dir->d_inode &&
+                             atomic_inc_not_zero(&sdp->sd_frozen_root)))
+                        frozen_root = 1;
+                else {
+                        error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
+                        if (error)
+                                return error;
+                        unlock = 1;
+                }
         }
 
         generic_fillattr(inode, stat);
         if (unlock)
                 gfs2_glock_dq_uninit(&gh);
+        else if (frozen_root && atomic_dec_and_test(&sdp->sd_frozen_root))
+                wake_up(&sdp->sd_frozen_root_wait);
 
         return 0;
 }
diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
index 4a14d504ef83..3966fadbcebd 100644
--- a/fs/gfs2/log.c
+++ b/fs/gfs2/log.c
@@ -301,6 +301,23 @@ static void ail2_empty(struct gfs2_sbd *sdp, unsigned int new_tail)
 }
 
 /**
+ * gfs2_log_release - Release a given number of log blocks
+ * @sdp: The GFS2 superblock
+ * @blks: The number of blocks
+ *
+ */
+
+void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
+{
+
+        atomic_add(blks, &sdp->sd_log_blks_free);
+        trace_gfs2_log_blocks(sdp, blks);
+        gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
+                                  sdp->sd_jdesc->jd_blocks);
+        up_read(&sdp->sd_log_flush_lock);
+}
+
+/**
  * gfs2_log_reserve - Make a log reservation
  * @sdp: The GFS2 superblock
  * @blks: The number of blocks to reserve
@@ -358,7 +375,10 @@ retry:
                 wake_up(&sdp->sd_log_waitq);
 
         down_read(&sdp->sd_log_flush_lock);
-
+        if (unlikely(!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))) {
+                gfs2_log_release(sdp, blks);
+                return -EROFS;
+        }
         return 0;
 }
 
@@ -671,7 +691,8 @@ static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
  *
  */
 
-void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl)
+void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
+                    enum gfs2_flush_type type)
 {
         struct gfs2_trans *tr;
 
@@ -723,6 +744,42 @@ void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl)
         }
         spin_unlock(&sdp->sd_ail_lock);
         gfs2_log_unlock(sdp);
+
+        if (atomic_read(&sdp->sd_log_freeze))
+                type = FREEZE_FLUSH;
+        if (type != NORMAL_FLUSH) {
+                if (!sdp->sd_log_idle) {
+                        for (;;) {
+                                gfs2_ail1_start(sdp);
+                                gfs2_ail1_wait(sdp);
+                                if (gfs2_ail1_empty(sdp))
+                                        break;
+                        }
+                        atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
+                        trace_gfs2_log_blocks(sdp, -1);
+                        sdp->sd_log_flush_wrapped = 0;
+                        log_write_header(sdp, 0);
+                        sdp->sd_log_head = sdp->sd_log_flush_head;
+                }
+                if (type == SHUTDOWN_FLUSH || type == FREEZE_FLUSH)
+                        gfs2_log_shutdown(sdp);
+                if (type == FREEZE_FLUSH) {
+                        int error;
+
+                        atomic_set(&sdp->sd_log_freeze, 0);
+                        wake_up(&sdp->sd_log_frozen_wait);
+                        error = gfs2_glock_nq_init(sdp->sd_freeze_gl,
+                                                   LM_ST_SHARED, 0,
+                                                   &sdp->sd_thaw_gh);
+                        if (error) {
+                                printk(KERN_INFO "GFS2: couln't get freeze lock : %d\n", error);
+                                gfs2_assert_withdraw(sdp, 0);
+                        }
+                        else
+                                gfs2_glock_dq_uninit(&sdp->sd_thaw_gh);
+                }
+        }
+
         trace_gfs2_log_flush(sdp, 0);
         up_write(&sdp->sd_log_flush_lock);
 
@@ -761,7 +818,7 @@ static void log_refund(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
         if (sdp->sd_log_tr) {
                 gfs2_merge_trans(sdp->sd_log_tr, tr);
         } else if (tr->tr_num_buf_new || tr->tr_num_databuf_new) {
-                gfs2_assert_withdraw(sdp, tr->tr_t_gh.gh_gl);
+                gfs2_assert_withdraw(sdp, tr->tr_alloced);
                 sdp->sd_log_tr = tr;
                 tr->tr_attached = 1;
         }
@@ -813,8 +870,6 @@ void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *tr)
 
 void gfs2_log_shutdown(struct gfs2_sbd *sdp)
 {
-        down_write(&sdp->sd_log_flush_lock);
-
         gfs2_assert_withdraw(sdp, !sdp->sd_log_blks_reserved);
         gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
         gfs2_assert_withdraw(sdp, list_empty(&sdp->sd_ail1_list));
@@ -824,38 +879,16 @@ void gfs2_log_shutdown(struct gfs2_sbd *sdp)
 
         log_write_header(sdp, GFS2_LOG_HEAD_UNMOUNT);
 
-        gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks);
         gfs2_assert_warn(sdp, sdp->sd_log_head == sdp->sd_log_tail);
         gfs2_assert_warn(sdp, list_empty(&sdp->sd_ail2_list));
 
         sdp->sd_log_head = sdp->sd_log_flush_head;
         sdp->sd_log_tail = sdp->sd_log_head;
-
-        up_write(&sdp->sd_log_flush_lock);
-}
-
-
-/**
- * gfs2_meta_syncfs - sync all the buffers in a filesystem
- * @sdp: the filesystem
- *
- */
-
-void gfs2_meta_syncfs(struct gfs2_sbd *sdp)
-{
-        gfs2_log_flush(sdp, NULL);
-        for (;;) {
-                gfs2_ail1_start(sdp);
-                gfs2_ail1_wait(sdp);
-                if (gfs2_ail1_empty(sdp))
-                        break;
-        }
-        gfs2_log_flush(sdp, NULL);
 }
 
 static inline int gfs2_jrnl_flush_reqd(struct gfs2_sbd *sdp)
 {
-        return (atomic_read(&sdp->sd_log_pinned) >= atomic_read(&sdp->sd_log_thresh1));
+        return (atomic_read(&sdp->sd_log_pinned) >= atomic_read(&sdp->sd_log_thresh1) || atomic_read(&sdp->sd_log_freeze));
 }
 
 static inline int gfs2_ail_flush_reqd(struct gfs2_sbd *sdp)
@@ -882,14 +915,14 @@ int gfs2_logd(void *data)
 
                 if (gfs2_jrnl_flush_reqd(sdp) || t == 0) {
                         gfs2_ail1_empty(sdp);
-                        gfs2_log_flush(sdp, NULL);
+                        gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
                 }
 
                 if (gfs2_ail_flush_reqd(sdp)) {
                         gfs2_ail1_start(sdp);
                         gfs2_ail1_wait(sdp);
                         gfs2_ail1_empty(sdp);
-                        gfs2_log_flush(sdp, NULL);
+                        gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
                 }
 
                 if (!gfs2_ail_flush_reqd(sdp))
diff --git a/fs/gfs2/log.h b/fs/gfs2/log.h
index 37216634f0aa..9499a6049212 100644
--- a/fs/gfs2/log.h
+++ b/fs/gfs2/log.h
@@ -63,14 +63,21 @@ extern void gfs2_ordered_del_inode(struct gfs2_inode *ip);
 extern unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,
                             unsigned int ssize);
 
+extern void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks);
 extern int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks);
-extern void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl);
+enum gfs2_flush_type {
+        NORMAL_FLUSH = 0,
+        SYNC_FLUSH,
+        SHUTDOWN_FLUSH,
+        FREEZE_FLUSH
+};
+extern void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
+                           enum gfs2_flush_type type);
 extern void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *trans);
 extern void gfs2_remove_from_ail(struct gfs2_bufdata *bd);
 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);
diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index a294d8d8bcd4..2c1ae861dc94 100644
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -75,7 +75,7 @@ static void maybe_release_space(struct gfs2_bufdata *bd)
         unsigned int index = bd->bd_bh->b_blocknr - gl->gl_name.ln_number;
         struct gfs2_bitmap *bi = rgd->rd_bits + index;
 
-        if (bi->bi_clone == 0)
+        if (bi->bi_clone == NULL)
                 return;
         if (sdp->sd_args.ar_discard)
                 gfs2_rgrp_send_discards(sdp, rgd->rd_data0, bd->bd_bh, bi, 1, NULL);
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 22f954051bb8..bc564c0d6d16 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -94,6 +94,7 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)
         INIT_LIST_HEAD(&sdp->sd_jindex_list);
         spin_lock_init(&sdp->sd_jindex_spin);
         mutex_init(&sdp->sd_jindex_mutex);
+        init_completion(&sdp->sd_journal_ready);
 
         INIT_LIST_HEAD(&sdp->sd_quota_list);
         mutex_init(&sdp->sd_quota_mutex);
@@ -129,6 +130,10 @@ static struct gfs2_sbd *init_sbd(struct super_block *sb)
         init_rwsem(&sdp->sd_log_flush_lock);
         atomic_set(&sdp->sd_log_in_flight, 0);
         init_waitqueue_head(&sdp->sd_log_flush_wait);
+        init_waitqueue_head(&sdp->sd_log_frozen_wait);
+        atomic_set(&sdp->sd_log_freeze, 0);
+        atomic_set(&sdp->sd_frozen_root, 0);
+        init_waitqueue_head(&sdp->sd_frozen_root_wait);
 
         return sdp;
 }
@@ -419,8 +424,8 @@ static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
                 goto fail_live;
         }
 
-        error = gfs2_glock_get(sdp, GFS2_TRANS_LOCK, &gfs2_trans_glops,
-                               CREATE, &sdp->sd_trans_gl);
+        error = gfs2_glock_get(sdp, GFS2_FREEZE_LOCK, &gfs2_freeze_glops,
+                               CREATE, &sdp->sd_freeze_gl);
         if (error) {
                 fs_err(sdp, "can't create transaction glock: %d\n", error);
                 goto fail_rename;
@@ -429,7 +434,7 @@ static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
         return 0;
 
 fail_trans:
-        gfs2_glock_put(sdp->sd_trans_gl);
+        gfs2_glock_put(sdp->sd_freeze_gl);
 fail_rename:
         gfs2_glock_put(sdp->sd_rename_gl);
 fail_live:
@@ -755,7 +760,15 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
         set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
         gfs2_glock_dq_uninit(&ji_gh);
         jindex = 0;
-
+        if (!sdp->sd_args.ar_spectator) {
+                error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 0,
+                                           &sdp->sd_thaw_gh);
+                if (error) {
+                        fs_err(sdp, "can't acquire freeze glock: %d\n", error);
+                        goto fail_jinode_gh;
+                }
+        }
+        gfs2_glock_dq_uninit(&sdp->sd_thaw_gh);
         return 0;
 
 fail_jinode_gh:
@@ -784,6 +797,7 @@ static int init_inodes(struct gfs2_sbd *sdp, int undo)
                 goto fail_qinode;
 
         error = init_journal(sdp, undo);
+        complete_all(&sdp->sd_journal_ready);
         if (error)
                 goto fail;
 
@@ -1200,6 +1214,7 @@ fail_sb:
 fail_locking:
         init_locking(sdp, &mount_gh, UNDO);
 fail_lm:
+        complete_all(&sdp->sd_journal_ready);
         gfs2_gl_hash_clear(sdp);
         gfs2_lm_unmount(sdp);
 fail_debug:
@@ -1380,7 +1395,7 @@ static void gfs2_kill_sb(struct super_block *sb)
                 return;
         }
 
-        gfs2_meta_syncfs(sdp);
+        gfs2_log_flush(sdp, NULL, SYNC_FLUSH);
         dput(sdp->sd_root_dir);
         dput(sdp->sd_master_dir);
         sdp->sd_root_dir = NULL;
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index c4effff7cf55..64b29f7f6b4c 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -778,6 +778,7 @@ get_a_page:
                 i_size_write(inode, size);
         inode->i_mtime = inode->i_atime = CURRENT_TIME;
         mark_inode_dirty(inode);
+        set_bit(QDF_REFRESH, &qd->qd_flags);
         return 0;
 
 unlock_out:
@@ -879,7 +880,7 @@ out:
                 gfs2_glock_dq_uninit(&ghs[qx]);
         mutex_unlock(&ip->i_inode.i_mutex);
         kfree(ghs);
-        gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);
+        gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl, NORMAL_FLUSH);
         return error;
 }
 
diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
index fe7a56fb6084..94555d4c5698 100644
--- a/fs/gfs2/recovery.c
+++ b/fs/gfs2/recovery.c
@@ -454,7 +454,7 @@ void gfs2_recover_func(struct work_struct *work)
         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
         struct gfs2_log_header_host head;
-        struct gfs2_holder j_gh, ji_gh, t_gh;
+        struct gfs2_holder j_gh, ji_gh, thaw_gh;
         unsigned long t;
         int ro = 0;
         unsigned int pass;
@@ -508,11 +508,11 @@ void gfs2_recover_func(struct work_struct *work)
 
                 t = jiffies;
 
-                /* Acquire a shared hold on the transaction lock */
+                /* Acquire a shared hold on the freeze lock */
 
-                error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
-                                           LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
-                                           GL_NOCACHE, &t_gh);
+                error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED,
+                                           LM_FLAG_NOEXP | LM_FLAG_PRIORITY,
+                                           &thaw_gh);
                 if (error)
                         goto fail_gunlock_ji;
 
@@ -538,7 +538,7 @@ void gfs2_recover_func(struct work_struct *work)
                         fs_warn(sdp, "jid=%u: Can't replay: read-only block "
                                 "device\n", jd->jd_jid);
                         error = -EROFS;
-                        goto fail_gunlock_tr;
+                        goto fail_gunlock_thaw;
                 }
 
                 fs_info(sdp, "jid=%u: Replaying journal...\n", jd->jd_jid);
@@ -549,14 +549,14 @@ void gfs2_recover_func(struct work_struct *work)
                                                    head.lh_blkno, pass);
                         lops_after_scan(jd, error, pass);
                         if (error)
-                                goto fail_gunlock_tr;
+                                goto fail_gunlock_thaw;
                 }
 
                 error = clean_journal(jd, &head);
                 if (error)
-                        goto fail_gunlock_tr;
+                        goto fail_gunlock_thaw;
 
-                gfs2_glock_dq_uninit(&t_gh);
+                gfs2_glock_dq_uninit(&thaw_gh);
                 t = DIV_ROUND_UP(jiffies - t, HZ);
                 fs_info(sdp, "jid=%u: Journal replayed in %lus\n",
                         jd->jd_jid, t);
@@ -572,8 +572,8 @@ void gfs2_recover_func(struct work_struct *work)
         fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
         goto done;
 
-fail_gunlock_tr:
-        gfs2_glock_dq_uninit(&t_gh);
+fail_gunlock_thaw:
+        gfs2_glock_dq_uninit(&thaw_gh);
 fail_gunlock_ji:
         if (jlocked) {
                 gfs2_glock_dq_uninit(&ji_gh);
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 281a7716e3f3..db629d1bd1bd 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -2001,7 +2001,7 @@ next_rgrp:
                 }
                 /* Flushing the log may release space */
                 if (loops == 2)
-                        gfs2_log_flush(sdp, NULL);
+                        gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
         }
 
         return -ENOSPC;
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index de8afad89e51..1319b5c4ec68 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -399,7 +399,7 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
 {
         struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
         struct gfs2_glock *j_gl = ip->i_gl;
-        struct gfs2_holder t_gh;
+        struct gfs2_holder thaw_gh;
         struct gfs2_log_header_host head;
         int error;
 
@@ -407,7 +407,8 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
         if (error)
                 return error;
 
-        error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, 0, &t_gh);
+        error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 0,
+                                   &thaw_gh);
         if (error)
                 goto fail_threads;
 
@@ -433,13 +434,13 @@ int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
 
         set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 
-        gfs2_glock_dq_uninit(&t_gh);
+        gfs2_glock_dq_uninit(&thaw_gh);
 
         return 0;
 
 fail:
-        t_gh.gh_flags |= GL_NOCACHE;
-        gfs2_glock_dq_uninit(&t_gh);
+        thaw_gh.gh_flags |= GL_NOCACHE;
+        gfs2_glock_dq_uninit(&thaw_gh);
 fail_threads:
         kthread_stop(sdp->sd_quotad_process);
         kthread_stop(sdp->sd_logd_process);
@@ -635,15 +636,21 @@ struct lfcc {
  */
 
 static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,
-                                    struct gfs2_holder *t_gh)
+                                    struct gfs2_holder *freeze_gh)
 {
         struct gfs2_inode *ip;
         struct gfs2_jdesc *jd;
         struct lfcc *lfcc;
         LIST_HEAD(list);
         struct gfs2_log_header_host lh;
+        struct gfs2_inode *dip = GFS2_I(sdp->sd_root_dir->d_inode);
         int error;
 
+        error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0,
+                                   &sdp->sd_freeze_root_gh);
+        if (error)
+                return error;
+        atomic_set(&sdp->sd_frozen_root, 1);
         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
                 lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL);
                 if (!lfcc) {
@@ -659,8 +666,8 @@ static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,
                 list_add(&lfcc->list, &list);
         }
 
-        error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_DEFERRED,
-                                   GL_NOCACHE, t_gh);
+        error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_EXCLUSIVE,
+                                   GL_NOCACHE, freeze_gh);
 
         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
                 error = gfs2_jdesc_check(jd);
@@ -676,7 +683,7 @@ static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,
         }
 
         if (error)
-                gfs2_glock_dq_uninit(t_gh);
+                gfs2_glock_dq_uninit(freeze_gh);
 
 out:
         while (!list_empty(&list)) {
@@ -685,6 +692,11 @@ out:
                 gfs2_glock_dq_uninit(&lfcc->gh);
                 kfree(lfcc);
         }
+        if (error) {
+                atomic_dec(&sdp->sd_frozen_root);
+                wait_event(sdp->sd_frozen_root_wait, atomic_read(&sdp->sd_frozen_root) == 0);
+                gfs2_glock_dq_uninit(&sdp->sd_freeze_root_gh);
+        }
         return error;
 }
 
@@ -742,7 +754,7 @@ static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc)
         int ret = 0;
 
         if (wbc->sync_mode == WB_SYNC_ALL)
-                gfs2_log_flush(GFS2_SB(inode), ip->i_gl);
+                gfs2_log_flush(GFS2_SB(inode), ip->i_gl, NORMAL_FLUSH);
         if (bdi->dirty_exceeded)
                 gfs2_ail1_flush(sdp, wbc);
         else
@@ -822,9 +834,18 @@ out:
 
 static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
 {
-        struct gfs2_holder t_gh;
+        struct gfs2_holder thaw_gh;
         int error;
 
+        error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, GL_NOCACHE,
+                                   &thaw_gh);
+        if (error && !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
+                return error;
+
+        down_write(&sdp->sd_log_flush_lock);
+        clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+        up_write(&sdp->sd_log_flush_lock);
+
         kthread_stop(sdp->sd_quotad_process);
         kthread_stop(sdp->sd_logd_process);
 
@@ -832,18 +853,11 @@ static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
         gfs2_quota_sync(sdp->sd_vfs, 0);
         gfs2_statfs_sync(sdp->sd_vfs, 0);
 
-        error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, GL_NOCACHE,
-                                   &t_gh);
-        if (error && !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
-                return error;
-
-        gfs2_meta_syncfs(sdp);
-        gfs2_log_shutdown(sdp);
-
-        clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+        gfs2_log_flush(sdp, NULL, SHUTDOWN_FLUSH);
+        gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks);
 
-        if (t_gh.gh_gl)
-                gfs2_glock_dq_uninit(&t_gh);
+        if (thaw_gh.gh_gl)
+                gfs2_glock_dq_uninit(&thaw_gh);
 
         gfs2_quota_cleanup(sdp);
 
@@ -900,7 +914,7 @@ restart:
         iput(sdp->sd_quota_inode);
 
         gfs2_glock_put(sdp->sd_rename_gl);
-        gfs2_glock_put(sdp->sd_trans_gl);
+        gfs2_glock_put(sdp->sd_freeze_gl);
 
         if (!sdp->sd_args.ar_spectator) {
                 gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
@@ -935,8 +949,8 @@ static int gfs2_sync_fs(struct super_block *sb, int wait)
         struct gfs2_sbd *sdp = sb->s_fs_info;
 
         gfs2_quota_sync(sb, -1);
-        if (wait && sdp)
-                gfs2_log_flush(sdp, NULL);
+        if (wait && sdp && !atomic_read(&sdp->sd_log_freeze))
+                gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
         return 0;
 }
 
@@ -986,6 +1000,9 @@ static int gfs2_unfreeze(struct super_block *sb)
         struct gfs2_sbd *sdp = sb->s_fs_info;
 
         gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
+        atomic_dec(&sdp->sd_frozen_root);
+        wait_event(sdp->sd_frozen_root_wait, atomic_read(&sdp->sd_frozen_root) == 0);
+        gfs2_glock_dq_uninit(&sdp->sd_freeze_root_gh);
         return 0;
 }
 
@@ -1525,7 +1542,7 @@ static void gfs2_evict_inode(struct inode *inode)
         goto out_unlock;
 
 out_truncate:
-        gfs2_log_flush(sdp, ip->i_gl);
+        gfs2_log_flush(sdp, ip->i_gl, NORMAL_FLUSH);
         if (test_bit(GLF_DIRTY, &ip->i_gl->gl_flags)) {
                 struct address_space *metamapping = gfs2_glock2aspace(ip->i_gl);
                 filemap_fdatawrite(metamapping);
diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
index 529d9a9eb897..3ab566ba5696 100644
--- a/fs/gfs2/sys.c
+++ b/fs/gfs2/sys.c
@@ -240,8 +240,8 @@ static ssize_t demote_rq_store(struct gfs2_sbd *sdp, const char *buf, size_t len
 
         if (gltype > LM_TYPE_JOURNAL)
                 return -EINVAL;
-        if (gltype == LM_TYPE_NONDISK && glnum == GFS2_TRANS_LOCK)
-                glops = &gfs2_trans_glops;
+        if (gltype == LM_TYPE_NONDISK && glnum == GFS2_FREEZE_LOCK)
+                glops = &gfs2_freeze_glops;
         else
                 glops = gfs2_glops_list[gltype];
         if (glops == NULL)
@@ -407,6 +407,9 @@ int gfs2_recover_set(struct gfs2_sbd *sdp, unsigned jid)
         struct gfs2_jdesc *jd;
         int rv;
 
+        /* Wait for our primary journal to be initialized */
+        wait_for_completion(&sdp->sd_journal_ready);
+
         spin_lock(&sdp->sd_jindex_spin);
         rv = -EBUSY;
         if (sdp->sd_jdesc->jd_jid == jid)
diff --git a/fs/gfs2/trans.c b/fs/gfs2/trans.c
index bead90d27bad..0546ab4e28e8 100644
--- a/fs/gfs2/trans.c
+++ b/fs/gfs2/trans.c
@@ -48,6 +48,7 @@ int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
         tr->tr_blocks = blocks;
         tr->tr_revokes = revokes;
         tr->tr_reserved = 1;
+        tr->tr_alloced = 1;
         if (blocks)
                 tr->tr_reserved += 6 + blocks;
         if (revokes)
@@ -57,48 +58,22 @@ int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
         INIT_LIST_HEAD(&tr->tr_buf);
 
         sb_start_intwrite(sdp->sd_vfs);
-        gfs2_holder_init(sdp->sd_trans_gl, LM_ST_SHARED, 0, &tr->tr_t_gh);
-
-        error = gfs2_glock_nq(&tr->tr_t_gh);
-        if (error)
-                goto fail_holder_uninit;
 
         error = gfs2_log_reserve(sdp, tr->tr_reserved);
         if (error)
-                goto fail_gunlock;
+                goto fail;
 
         current->journal_info = tr;
 
         return 0;
 
-fail_gunlock:
-        gfs2_glock_dq(&tr->tr_t_gh);
-
-fail_holder_uninit:
+fail:
         sb_end_intwrite(sdp->sd_vfs);
-        gfs2_holder_uninit(&tr->tr_t_gh);
         kfree(tr);
 
         return error;
 }
 
-/**
- * gfs2_log_release - Release a given number of log blocks
- * @sdp: The GFS2 superblock
- * @blks: The number of blocks
- *
- */
-
-static void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
-{
-
-        atomic_add(blks, &sdp->sd_log_blks_free);
-        trace_gfs2_log_blocks(sdp, blks);
-        gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
-                                  sdp->sd_jdesc->jd_blocks);
-        up_read(&sdp->sd_log_flush_lock);
-}
-
 static void gfs2_print_trans(const struct gfs2_trans *tr)
 {
         pr_warn("Transaction created at: %pSR\n", (void *)tr->tr_ip);
@@ -119,11 +94,8 @@ void gfs2_trans_end(struct gfs2_sbd *sdp)
 
         if (!tr->tr_touched) {
                 gfs2_log_release(sdp, tr->tr_reserved);
-                if (tr->tr_t_gh.gh_gl) {
-                        gfs2_glock_dq(&tr->tr_t_gh);
-                        gfs2_holder_uninit(&tr->tr_t_gh);
+                if (tr->tr_alloced)
                         kfree(tr);
-                }
                 sb_end_intwrite(sdp->sd_vfs);
                 return;
         }
@@ -137,16 +109,12 @@ void gfs2_trans_end(struct gfs2_sbd *sdp)
                 gfs2_print_trans(tr);
 
         gfs2_log_commit(sdp, tr);
-        if (tr->tr_t_gh.gh_gl) {
-                gfs2_glock_dq(&tr->tr_t_gh);
-                gfs2_holder_uninit(&tr->tr_t_gh);
-                if (!tr->tr_attached)
+        if (tr->tr_alloced && !tr->tr_attached)
                         kfree(tr);
-        }
         up_read(&sdp->sd_log_flush_lock);
 
         if (sdp->sd_vfs->s_flags & MS_SYNCHRONOUS)
-                gfs2_log_flush(sdp, NULL);
+                gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
         sb_end_intwrite(sdp->sd_vfs);
 }
 
diff --git a/include/uapi/linux/gfs2_ondisk.h b/include/uapi/linux/gfs2_ondisk.h
index db3fdd083882..1a763eaae0bb 100644
--- a/include/uapi/linux/gfs2_ondisk.h
+++ b/include/uapi/linux/gfs2_ondisk.h
@@ -20,7 +20,7 @@
 
 #define GFS2_MOUNT_LOCK         0
 #define GFS2_LIVE_LOCK          1
-#define GFS2_TRANS_LOCK         2
+#define GFS2_FREEZE_LOCK        2
 #define GFS2_RENAME_LOCK        3
 #define GFS2_CONTROL_LOCK       4
 #define GFS2_MOUNTED_LOCK       5