[GFS2] Clean up the glock core

This patch implements a number of cleanups to the core of the
GFS2 glock code. As a result a lot of code is removed. It looks
like a really big change, but actually a large part of this patch
is either removing or moving existing code.

There are some new bits too though, such as the new run_queue()
function which is considerably streamlined. Highlights of this
patch include:

 o Fixes a cluster coherency bug during SH -> EX lock conversions
 o Removes the "glmutex" code in favour of a single bit lock
 o Removes the ->go_xmote_bh() for inodes since it was duplicating
   ->go_lock()
 o We now only use the ->lm_lock() function for both locks and
   unlocks (i.e. unlock is a lock with target mode LM_ST_UNLOCKED)
 o The fast path is considerably shortly, giving performance gains
   especially with lock_nolock
 o The glock_workqueue is now used for all the callbacks from the DLM
   which allows us to simplify the lock_dlm module (see following patch)
 o The way is now open to make further changes such as eliminating the two
   threads (gfs2_glockd and gfs2_scand) in favour of a more efficient
   scheme.

This patch has undergone extensive testing with various test suites
so it should be pretty stable by now.

Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Cc: Bob Peterson <rpeterso@redhat.com>

1 files changed, 15 insertions, 20 deletions

diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index eabe5eac41da..4b734c6e34f0 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -128,20 +128,20 @@ struct gfs2_bufdata {
 
 struct gfs2_glock_operations {
         void (*go_xmote_th) (struct gfs2_glock *gl);
-        void (*go_xmote_bh) (struct gfs2_glock *gl);
+        int (*go_xmote_bh) (struct gfs2_glock *gl, struct gfs2_holder *gh);
         void (*go_inval) (struct gfs2_glock *gl, int flags);
         int (*go_demote_ok) (struct gfs2_glock *gl);
         int (*go_lock) (struct gfs2_holder *gh);
         void (*go_unlock) (struct gfs2_holder *gh);
+        int (*go_dump)(struct seq_file *seq, const struct gfs2_glock *gl);
         const int go_type;
         const unsigned long go_min_hold_time;
 };
 
 enum {
         /* States */
-        HIF_HOLDER              = 6,
+        HIF_HOLDER              = 6,  /* Set for gh that "holds" the glock */
         HIF_FIRST               = 7,
-        HIF_ABORTED             = 9,
         HIF_WAIT                = 10,
 };
 
@@ -154,20 +154,20 @@ struct gfs2_holder {
         unsigned gh_flags;
 
         int gh_error;
-        unsigned long gh_iflags;
+        unsigned long gh_iflags; /* HIF_... */
         unsigned long gh_ip;
 };
 
 enum {
-        GLF_LOCK                = 1,
-        GLF_STICKY              = 2,
-        GLF_DEMOTE              = 3,
-        GLF_PENDING_DEMOTE      = 4,
-        GLF_DIRTY               = 5,
-        GLF_DEMOTE_IN_PROGRESS  = 6,
-        GLF_LFLUSH              = 7,
-        GLF_WAITERS2            = 8,
-        GLF_CONV_DEADLK         = 9,
+        GLF_LOCK                        = 1,
+        GLF_STICKY                      = 2,
+        GLF_DEMOTE                      = 3,
+        GLF_PENDING_DEMOTE              = 4,
+        GLF_DEMOTE_IN_PROGRESS          = 5,
+        GLF_DIRTY                       = 6,
+        GLF_LFLUSH                      = 7,
+        GLF_INVALIDATE_IN_PROGRESS      = 8,
+        GLF_REPLY_PENDING               = 9,
 };
 
 struct gfs2_glock {
@@ -179,19 +179,14 @@ struct gfs2_glock {
         spinlock_t gl_spin;
 
         unsigned int gl_state;
+        unsigned int gl_target;
+        unsigned int gl_reply;
         unsigned int gl_hash;
         unsigned int gl_demote_state; /* state requested by remote node */
         unsigned long gl_demote_time; /* time of first demote request */
-        struct pid *gl_owner_pid;
-        unsigned long gl_ip;
         struct list_head gl_holders;
-        struct list_head gl_waiters1;   /* HIF_MUTEX */
-        struct list_head gl_waiters3;   /* HIF_PROMOTE */
 
         const struct gfs2_glock_operations *gl_ops;
-
-        struct gfs2_holder *gl_req_gh;
-
         void *gl_lock;
         char *gl_lvb;
         atomic_t gl_lvb_count;