gfs2: Rename GLF_FREEING to GLF_UNLOCKED

Rename the GLF_FREEING flag to GLF_UNLOCKED, and the ->go_free glock
operation to ->go_unlocked.  This mechanism is used to wait for the
underlying DLM lock to be unlocked; being able to free the glock is a
consequence of the DLM lock being unlocked.

Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>

diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index d1fb0b2b56497a5d87519772eca531a7041e77d9..959668e22c9da10321d7f1f4fd1e6b989a55ae39 100644 (file)
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -2378,7 +2378,7 @@ static const char *gflags2str(char *buf, const struct gfs2_glock *gl)
                *p++ = 'o';
        if (test_bit(GLF_BLOCKING, gflags))
                *p++ = 'b';
-       if (test_bit(GLF_FREEING, gflags))
+       if (test_bit(GLF_UNLOCKED, gflags))
                *p++ = 'x';
        if (test_bit(GLF_INSTANTIATE_NEEDED, gflags))
                *p++ = 'n';

diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index 68677fb69a73f379001d5452a8a9ccc3af2ae4ba..39bb6758a2a09259f5bc5bae41d44ffb39aef1ba 100644 (file)
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -648,21 +648,21 @@ static void iopen_go_callback(struct gfs2_glock *gl, bool remote)
 }
 
 /**
- * inode_go_free - wake up anyone waiting for dlm's unlock ast to free it
- * @gl: glock being freed
+ * inode_go_unlocked - wake up anyone waiting for dlm's unlock ast
+ * @gl: glock being unlocked
  *
  * For now, this is only used for the journal inode glock. In withdraw
- * situations, we need to wait for the glock to be freed so that we know
+ * situations, we need to wait for the glock to be unlocked so that we know
  * other nodes may proceed with recovery / journal replay.
  */
-static void inode_go_free(struct gfs2_glock *gl)
+static void inode_go_unlocked(struct gfs2_glock *gl)
 {
        /* Note that we cannot reference gl_object because it's already set
         * to NULL by this point in its lifecycle. */
-       if (!test_bit(GLF_FREEING, &gl->gl_flags))
+       if (!test_bit(GLF_UNLOCKED, &gl->gl_flags))
                return;
-       clear_bit_unlock(GLF_FREEING, &gl->gl_flags);
-       wake_up_bit(&gl->gl_flags, GLF_FREEING);
+       clear_bit_unlock(GLF_UNLOCKED, &gl->gl_flags);
+       wake_up_bit(&gl->gl_flags, GLF_UNLOCKED);
 }
 
 /**
@@ -728,7 +728,7 @@ const struct gfs2_glock_operations gfs2_inode_glops = {
        .go_dump = inode_go_dump,
        .go_type = LM_TYPE_INODE,
        .go_flags = GLOF_ASPACE | GLOF_LRU | GLOF_LVB,
-       .go_free = inode_go_free,
+       .go_unlocked = inode_go_unlocked,
 };
 
 const struct gfs2_glock_operations gfs2_rgrp_glops = {

diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 60abd7050c9983cd29bb80565a9c1dcb74add4bd..aa6dbde9cd19f4af69ebbe1e3fcfb9982d5a9a6b 100644 (file)
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -224,7 +224,7 @@ struct gfs2_glock_operations {
        void (*go_dump)(struct seq_file *seq, const struct gfs2_glock *gl,
                        const char *fs_id_buf);
        void (*go_callback)(struct gfs2_glock *gl, bool remote);
-       void (*go_free)(struct gfs2_glock *gl);
+       void (*go_unlocked)(struct gfs2_glock *gl);
        const int go_subclass;
        const int go_type;
        const unsigned long go_flags;
@@ -329,7 +329,7 @@ enum {
        GLF_LRU                         = 13,
        GLF_OBJECT                      = 14, /* Used only for tracing */
        GLF_BLOCKING                    = 15,
-       GLF_FREEING                     = 16, /* Wait for glock to be freed */
+       GLF_UNLOCKED                    = 16, /* Wait for glock to be unlocked */
        GLF_TRY_TO_EVICT                = 17, /* iopen glocks only */
        GLF_VERIFY_EVICT                = 18, /* iopen glocks only */
 };

diff --git a/fs/gfs2/lock_dlm.c b/fs/gfs2/lock_dlm.c
index 49059274a5288be6038cdf7387c539508dbb080e..cb2ad0031f9e9f889dcbe65d8b97231a84a3028d 100644 (file)
--- a/fs/gfs2/lock_dlm.c
+++ b/fs/gfs2/lock_dlm.c
@@ -134,8 +134,8 @@ static void gdlm_ast(void *arg)
 
        switch (gl->gl_lksb.sb_status) {
        case -DLM_EUNLOCK: /* Unlocked, so glock can be freed */
-               if (gl->gl_ops->go_free)
-                       gl->gl_ops->go_free(gl);
+               if (gl->gl_ops->go_unlocked)
+                       gl->gl_ops->go_unlocked(gl);
                gfs2_glock_free(gl);
                return;
        case -DLM_ECANCEL: /* Cancel while getting lock */

diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
index af4758d8d894cd30c29fa3d558c5955e4db30ac9..7e79b1a9e35f135a3ba51bbc67df1146bd35748c 100644 (file)
--- a/fs/gfs2/util.c
+++ b/fs/gfs2/util.c
@@ -206,9 +206,9 @@ static void signal_our_withdraw(struct gfs2_sbd *sdp)
         * on other nodes to be successful, otherwise we remain the owner of
         * the glock as far as dlm is concerned.
         */
-       if (i_gl->gl_ops->go_free) {
-               set_bit(GLF_FREEING, &i_gl->gl_flags);
-               wait_on_bit(&i_gl->gl_flags, GLF_FREEING, TASK_UNINTERRUPTIBLE);
+       if (i_gl->gl_ops->go_unlocked) {
+               set_bit(GLF_UNLOCKED, &i_gl->gl_flags);
+               wait_on_bit(&i_gl->gl_flags, GLF_UNLOCKED, TASK_UNINTERRUPTIBLE);
        }
 
        /*