gfs2: Allow node-wide exclusive glock sharing

Introduce a new LM_FLAG_NODE_SCOPE glock holder flag: when taking a
glock in LM_ST_EXCLUSIVE (EX) mode and with the LM_FLAG_NODE_SCOPE flag
set, the exclusive lock is shared among all local processes who are
holding the glock in EX mode and have the LM_FLAG_NODE_SCOPE flag set.
From the point of view of other nodes, the lock is still held
exclusively.

A future patch will start using this flag to improve performance with
rgrp sharing.

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

diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index d87a5bc..9567520 100644 (file)
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -313,9 +313,23 @@ void gfs2_glock_put(struct gfs2_glock *gl)
 static inline int may_grant(const struct gfs2_glock *gl, const struct gfs2_holder *gh)
 {
        const struct gfs2_holder *gh_head = list_first_entry(&gl->gl_holders, const struct gfs2_holder, gh_list);
-       if ((gh->gh_state == LM_ST_EXCLUSIVE ||
-            gh_head->gh_state == LM_ST_EXCLUSIVE) && gh != gh_head)
-               return 0;
+
+       if (gh != gh_head) {
+               /**
+                * Here we make a special exception to grant holders who agree
+                * to share the EX lock with other holders who also have the
+                * bit set. If the original holder has the LM_FLAG_NODE_SCOPE bit
+                * is set, we grant more holders with the bit set.
+                */
+               if (gh_head->gh_state == LM_ST_EXCLUSIVE &&
+                   (gh_head->gh_flags & LM_FLAG_NODE_SCOPE) &&
+                   gh->gh_state == LM_ST_EXCLUSIVE &&
+                   (gh->gh_flags & LM_FLAG_NODE_SCOPE))
+                       return 1;
+               if ((gh->gh_state == LM_ST_EXCLUSIVE ||
+                    gh_head->gh_state == LM_ST_EXCLUSIVE))
+                       return 0;
+       }
        if (gl->gl_state == gh->gh_state)
                return 1;
        if (gh->gh_flags & GL_EXACT)
@@ -2030,6 +2044,8 @@ static const char *hflags2str(char *buf, u16 flags, unsigned long iflags)
                *p++ = 'A';
        if (flags & LM_FLAG_PRIORITY)
                *p++ = 'p';
+       if (flags & LM_FLAG_NODE_SCOPE)
+               *p++ = 'n';
        if (flags & GL_ASYNC)
                *p++ = 'a';
        if (flags & GL_EXACT)

diff --git a/fs/gfs2/glock.h b/fs/gfs2/glock.h
index 5381336..31a8f2f 100644 (file)
--- a/fs/gfs2/glock.h
+++ b/fs/gfs2/glock.h
@@ -75,6 +75,11 @@ enum {
  * request and directly join the other shared lock.  A shared lock request
  * without the priority flag might be forced to wait until the deferred
  * requested had acquired and released the lock.
+ *
+ * LM_FLAG_NODE_SCOPE
+ * This holder agrees to share the lock within this node. In other words,
+ * the glock is held in EX mode according to DLM, but local holders on the
+ * same node can share it.
  */
 
 #define LM_FLAG_TRY            0x0001
@@ -82,6 +87,7 @@ enum {
 #define LM_FLAG_NOEXP          0x0004
 #define LM_FLAG_ANY            0x0008
 #define LM_FLAG_PRIORITY       0x0010
+#define LM_FLAG_NODE_SCOPE     0x0020
 #define GL_ASYNC               0x0040
 #define GL_EXACT               0x0080
 #define GL_SKIP                        0x0100