- fix unresolved symbols in ipv6 netfilter

[packages/kernel.git] / linux-cluster-dlm.patch

# Add DLM to the build system
diff -urN -p linux-2.6.7/cluster/Kconfig linux/cluster/Kconfig
--- linux-2.6.7/cluster/Kconfig 2004-06-17 15:00:36.000000000 +0800
+++ linux/cluster/Kconfig       2004-06-17 15:00:57.000000000 +0800
@@ -10,4 +10,22 @@ config CLUSTER
        needed by all the other components. It provides membership services
        for those other subsystems.
 
+config CLUSTER_DLM
+       tristate "Distributed Lock Manager"
+       depends on CLUSTER
+       ---help---
+       A fully distributed lock manager, providing cluster-wide locking services
+       and protected lock namespaces for kernel and userland applications.
+
+config CLUSTER_DLM_PROCLOCKS
+       boolean "/proc/locks support for DLM"
+       depends on CLUSTER_DLM
+       depends on PROC_FS
+       ---help---
+       If this option is enabled a file will appear in /proc/cluster/dlm_locks.
+       write into this "file" the name of a lockspace known to the DLM and then
+       read out a list of all the resources and locks in that lockspace that are
+       known to the local node. Note because the DLM is distributed this may not
+       be the full lock picture.
+
 endmenu
diff -urN -p linux-2.6.7/cluster/Makefile linux/cluster/Makefile
--- linux-2.6.7/cluster/Makefile        2004-06-17 15:00:36.000000000 +0800
+++ linux/cluster/Makefile      2004-06-17 15:00:57.000000000 +0800
@@ -1,3 +1,4 @@
 obj-y  := nocluster.o
 
 obj-$(CONFIG_CLUSTER)         += cman/
+obj-$(CONFIG_CLUSTER_DLM)     += dlm/
diff -urN -p linux-2.6.7/cluster/dlm/Makefile linux/cluster/dlm/Makefile
--- linux-2.6.7/cluster/dlm/Makefile    1970-01-01 07:30:00.000000000 +0730
+++ linux/cluster/dlm/Makefile  2004-06-17 15:00:57.000000000 +0800
@@ -0,0 +1,23 @@
+dlm-objs                 :=    ast.o \
+                               config.o \
+                               device.o \
+                               dir.o \
+                               lkb.o \
+                               locking.o \
+                               lockqueue.o \
+                               lockspace.o \
+                               lowcomms.o \
+                               main.o \
+                               memory.o \
+                               midcomms.o \
+                               nodes.o \
+                               proc.o \
+                               queries.o \
+                               rebuild.o \
+                               reccomms.o \
+                               recover.o \
+                               recoverd.o \
+                               rsb.o \
+                               util.o \
+
+obj-$(CONFIG_CLUSTER_DLM) += dlm.o
diff -urN linux-orig/cluster/dlm/ast.c linux-patched/cluster/dlm/ast.c
--- linux-orig/cluster/dlm/ast.c        1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/ast.c     2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,581 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/* 
+ * This delivers ASTs and checks for dead remote requests and deadlocks.
+ */
+
+#include <linux/timer.h>
+
+#include "dlm_internal.h"
+#include "rsb.h"
+#include "lockqueue.h"
+#include "dir.h"
+#include "locking.h"
+#include "lkb.h"
+#include "lowcomms.h"
+#include "midcomms.h"
+#include "ast.h"
+#include "nodes.h"
+#include "config.h"
+
+/* Wake up flags for astd */
+#define GDLMD_WAKE_ASTS  1
+#define GDLMD_WAKE_TIMER 2
+
+static struct list_head _deadlockqueue;
+static struct semaphore _deadlockqueue_lock;
+static struct list_head _lockqueue;
+static struct semaphore _lockqueue_lock;
+static struct timer_list _lockqueue_timer;
+static struct list_head _ast_queue;
+static struct semaphore _ast_queue_lock;
+static wait_queue_head_t _astd_waitchan;
+static atomic_t _astd_running;
+static long _astd_pid;
+static unsigned long _astd_wakeflags;
+static struct completion _astd_done;
+
+void add_to_lockqueue(gd_lkb_t *lkb)
+{
+       /* Time stamp the entry so we know if it's been waiting too long */
+       lkb->lkb_lockqueue_time = jiffies;
+
+       down(&_lockqueue_lock);
+       list_add(&lkb->lkb_lockqueue, &_lockqueue);
+       up(&_lockqueue_lock);
+}
+
+void remove_from_lockqueue(gd_lkb_t *lkb)
+{
+       down(&_lockqueue_lock);
+       list_del(&lkb->lkb_lockqueue);
+       up(&_lockqueue_lock);
+}
+
+void add_to_deadlockqueue(gd_lkb_t *lkb)
+{
+       if (test_bit(LSFL_NOTIMERS, &lkb->lkb_resource->res_ls->ls_flags))
+               return;
+       lkb->lkb_duetime = jiffies;
+       down(&_deadlockqueue_lock);
+       list_add(&lkb->lkb_deadlockq, &_deadlockqueue);
+       up(&_deadlockqueue_lock);
+}
+
+void remove_from_deadlockqueue(gd_lkb_t *lkb)
+{
+       if (test_bit(LSFL_NOTIMERS, &lkb->lkb_resource->res_ls->ls_flags))
+               return;
+
+       down(&_deadlockqueue_lock);
+       list_del(&lkb->lkb_deadlockq);
+       up(&_deadlockqueue_lock);
+
+       /* Invalidate the due time */
+       memset(&lkb->lkb_duetime, 0, sizeof(lkb->lkb_duetime));
+}
+
+void remove_from_astqueue(gd_lkb_t *lkb)
+{
+       down(&_ast_queue_lock);
+       if (lkb->lkb_asts_to_deliver)
+               list_del(&lkb->lkb_astqueue);
+       lkb->lkb_asts_to_deliver = 0;
+       up(&_ast_queue_lock);
+}
+
+/* 
+ * Actually deliver an AST to a user. The caller MUST hold the ast queue lock
+ * and we unlock it for the duration of the user call, otherwise things can
+ * deadlock.
+ */
+
+static void deliver_ast(gd_lkb_t *lkb, gd_ast_type_t astt)
+{
+       void (*cast) (long param) = lkb->lkb_astaddr;
+       void (*bast) (long param, int mode) = lkb->lkb_bastaddr;
+
+       up(&_ast_queue_lock);
+
+       if (cast && (astt == GDLM_QUEUE_COMPAST))
+               cast(lkb->lkb_astparam);
+
+       else if (bast && (astt == GDLM_QUEUE_BLKAST)
+                && (lkb->lkb_status == GDLM_LKSTS_GRANTED))
+               bast(lkb->lkb_astparam, (int) lkb->lkb_bastmode);
+
+       /* 
+        * Remove LKB if requested.  It is up to the caller to remove the LKB
+        * from any resource queue it may be on.
+        *
+        * NOTE: we check lkb_asts_to_deliver here in case an ast for us was
+        * queued during the AST delivery itself (eg a user called dlm_unlock
+        * in the AST routine!
+        */
+
+       if (lkb->lkb_flags & GDLM_LKFLG_DELAST && astt == GDLM_QUEUE_COMPAST &&
+           lkb->lkb_asts_to_deliver == 0) {
+               gd_res_t *rsb = lkb->lkb_resource;
+               struct rw_semaphore *in_recovery = &rsb->res_ls->ls_in_recovery;
+
+               down_read(in_recovery);
+               release_lkb(rsb->res_ls, lkb);
+               release_rsb(rsb);
+               up_read(in_recovery);
+       }
+
+       /* This queue can get very big so we schedule here to give the rest of
+        * the cluster chance to do some work. */
+       schedule();
+
+       down(&_ast_queue_lock);
+}
+
+/* 
+ * Queue an AST for delivery, this will only deal with
+ * kernel ASTs, usermode API will piggyback on top of this.
+ *
+ * This can be called in either the user or DLM context.
+ * ASTs are queued EVEN IF we are already running in gdlm_astd
+ * context as we don't know what other locks are held (eg we could
+ * be being called from a lock operation that was called from
+ * another AST!
+ * If the AST is to be queued remotely then a message is sent to
+ * the target system via midcomms.
+ */
+
+void queue_ast(gd_lkb_t *lkb, gd_ast_type_t astt, uint8_t rqmode)
+{
+       struct gd_remlockrequest req;
+
+       if (lkb->lkb_flags & GDLM_LKFLG_MSTCPY) {
+               /* 
+                * Send a message to have an ast queued remotely.  Note: we do
+                * not send remote completion asts, they are handled as part of
+                * remote lock granting.
+                */
+
+               if (astt == GDLM_QUEUE_BLKAST) {
+                       req.rr_header.rh_cmd = GDLM_REMCMD_SENDBAST;
+                       req.rr_header.rh_length = sizeof(req);
+                       req.rr_header.rh_flags = 0;
+                       req.rr_header.rh_lkid = lkb->lkb_id;
+                       req.rr_header.rh_lockspace =
+                           lkb->lkb_resource->res_ls->ls_global_id;
+                       req.rr_status = lkb->lkb_retstatus;
+                       req.rr_remlkid = lkb->lkb_remid;
+                       req.rr_rqmode = rqmode;
+
+                       midcomms_send_message(lkb->lkb_nodeid, &req.rr_header,
+                                             lkb->lkb_resource->res_ls->ls_allocation);
+
+               } else if (lkb->lkb_retstatus == -EDEADLOCK) {
+                       /* 
+                        * We only queue remote Completion ASTs here for error
+                        * completions that happen out of band.
+                        * DEADLOCK is one such.
+                        */
+
+                       req.rr_header.rh_cmd = GDLM_REMCMD_SENDCAST;
+                       req.rr_header.rh_length = sizeof(req);
+                       req.rr_header.rh_flags = 0;
+                       req.rr_header.rh_lkid = lkb->lkb_id;
+                       req.rr_header.rh_lockspace =
+                           lkb->lkb_resource->res_ls->ls_global_id;
+                       req.rr_status = lkb->lkb_retstatus;
+                       req.rr_remlkid = lkb->lkb_remid;
+                       req.rr_rqmode = rqmode;
+
+                       midcomms_send_message(lkb->lkb_nodeid, &req.rr_header,
+                                             lkb->lkb_resource->res_ls->ls_allocation);
+               }
+       } else {
+               /* 
+                * Prepare info which will be returned in ast/bast.
+                */
+
+               if (astt == GDLM_QUEUE_BLKAST) {
+                       lkb->lkb_bastmode = rqmode;
+               } else {
+                       lkb->lkb_lksb->sb_status = lkb->lkb_retstatus;
+
+                       if (lkb->lkb_flags & GDLM_LKFLG_DEMOTED)
+                               lkb->lkb_lksb->sb_flags = DLM_SBF_DEMOTED;
+                       else
+                               lkb->lkb_lksb->sb_flags = 0;
+               }
+
+               /* 
+                * Queue ast/bast or deliver directly.  astd can deliver ASTs
+                * during deadlock detection or lock timeouts.
+                */
+
+               down(&_ast_queue_lock);
+
+               if (!lkb->lkb_asts_to_deliver)
+                       list_add_tail(&lkb->lkb_astqueue, &_ast_queue);
+               lkb->lkb_asts_to_deliver |= astt;
+
+               up(&_ast_queue_lock);
+
+               /* It is the responsibility of the caller to call wake_astd()
+                * after it has finished other locking operations that request
+                * the ASTs to be delivered after */
+       }
+}
+
+/* 
+ * Process any LKBs on the AST queue.  The were queued in queue_ast().
+ */
+
+static void process_asts(void)
+{
+       gd_lkb_t *lkb, *safe;
+       uint32_t to_deliver;
+
+       down(&_ast_queue_lock);
+
+       list_for_each_entry_safe(lkb, safe, &_ast_queue, lkb_astqueue) {
+
+               /* The lkb can be placed back on _ast_queue as soon as
+                * _ast_queue_lock is released. */
+
+               to_deliver = lkb->lkb_asts_to_deliver;
+               lkb->lkb_asts_to_deliver = 0;
+               list_del(&lkb->lkb_astqueue);
+
+               if ((to_deliver & GDLM_QUEUE_COMPAST))
+                       deliver_ast(lkb, GDLM_QUEUE_COMPAST);
+
+               if ((to_deliver & GDLM_QUEUE_BLKAST))
+                       deliver_ast(lkb, GDLM_QUEUE_BLKAST);
+       }
+       up(&_ast_queue_lock);
+}
+
+void lockqueue_lkb_mark(gd_ls_t *ls)
+{
+       gd_lkb_t *lkb, *safe;
+       int count = 0;
+
+       log_all(ls, "mark waiting requests");
+
+       down(&_lockqueue_lock);
+
+       list_for_each_entry_safe(lkb, safe, &_lockqueue, lkb_lockqueue) {
+
+               if (lkb->lkb_resource->res_ls != ls)
+                       continue;
+
+               /* 
+                * These lkb's are new and the master is being looked up.  Mark
+                * the lkb request to be resent.  Even if the destination node
+                * for the request is still living and has our request, it will
+                * purge all resdir requests in purge_requestqueue.  If there's
+                * a reply to the LOOKUP request in our requestqueue (the reply
+                * arrived after ls_stop), it is invalid and will be discarded
+                * in purge_requestqueue, too.
+                */
+
+               if (lkb->lkb_lockqueue_state == GDLM_LQSTATE_WAIT_RSB) {
+                       GDLM_ASSERT(lkb->lkb_nodeid == -1,
+                                   log_error(ls, "nodeid=%d\n",
+                                             lkb->lkb_nodeid););
+
+                       lkb->lkb_flags |= GDLM_LKFLG_LQRESEND;
+                       count++;
+                       continue;
+               }
+
+               /* 
+                * These lkb's have an outstanding request to a bygone node.
+                * The request will be redirected to the new master node in
+                * resend_cluster_requests().  Don't mark the request for
+                * resending if there's a reply for it saved in the
+                * requestqueue.
+                */
+
+               if (in_nodes_gone(ls, lkb->lkb_nodeid) &&
+                   !reply_in_requestqueue(ls, lkb->lkb_id)) {
+
+                       lkb->lkb_flags |= GDLM_LKFLG_LQRESEND;
+
+                       /* 
+                        * Don't rebuild this lkb on a new rsb in
+                        * rebuild_rsbs_send().
+                        */
+
+                       if (lkb->lkb_lockqueue_state ==
+                           GDLM_LQSTATE_WAIT_CONDGRANT) {
+                               GDLM_ASSERT(lkb->lkb_status ==
+                                           GDLM_LKSTS_WAITING, );
+                               lkb->lkb_flags |= GDLM_LKFLG_NOREBUILD;
+                       }
+
+                       /* 
+                        * This flag indicates to the new master that his lkb
+                        * is in the midst of a convert request and should be
+                        * placed on the granted queue rather than the convert
+                        * queue.  We will resend this convert request to the
+                        * new master.
+                        */
+
+                       else if (lkb->lkb_lockqueue_state ==
+                                GDLM_LQSTATE_WAIT_CONVERT) {
+                               GDLM_ASSERT(lkb->lkb_status ==
+                                           GDLM_LKSTS_CONVERT, );
+                               lkb->lkb_flags |= GDLM_LKFLG_LQCONVERT;
+                       }
+
+                       count++;
+               }
+       }
+       up(&_lockqueue_lock);
+
+       log_all(ls, "marked %d requests", count);
+}
+
+int resend_cluster_requests(gd_ls_t *ls)
+{
+       gd_lkb_t *lkb, *safe;
+       int error = 0, state, count = 0;
+
+       log_all(ls, "resend marked requests");
+
+       down(&_lockqueue_lock);
+
+       list_for_each_entry_safe(lkb, safe, &_lockqueue, lkb_lockqueue) {
+
+               if (!test_bit(LSFL_LS_RUN, &ls->ls_flags)) {
+                       log_debug(ls, "resend_cluster_requests: aborted");
+                       error = -EINTR;
+                       break;
+               }
+
+               if (lkb->lkb_resource->res_ls != ls)
+                       continue;
+
+               log_debug(ls, "resend_cluster_requests id=%x nodeid=%d "
+                         "lqstate=%u flags=%x", lkb->lkb_id, lkb->lkb_nodeid,
+                         lkb->lkb_lockqueue_state, lkb->lkb_flags);
+
+               /* 
+                * Resend/process the lockqueue lkb's (in-progres requests)
+                * that were flagged at the start of recovery in
+                * lockqueue_lkb_mark().
+                */
+
+               if (lkb->lkb_flags & GDLM_LKFLG_LQRESEND) {
+                       lkb->lkb_flags &= ~GDLM_LKFLG_LQRESEND;
+                       lkb->lkb_flags &= ~GDLM_LKFLG_NOREBUILD;
+                       lkb->lkb_flags &= ~GDLM_LKFLG_LQCONVERT;
+
+                       if (lkb->lkb_nodeid == -1) {
+                               /* 
+                                * Send lookup to new resdir node.
+                                */
+                               lkb->lkb_lockqueue_time = jiffies;
+                               send_cluster_request(lkb,
+                                                    lkb->lkb_lockqueue_state);
+                       }
+
+                       else if (lkb->lkb_nodeid != 0) {
+                               /* 
+                                * There's a new RSB master (that's not us.)
+                                */
+                               lkb->lkb_lockqueue_time = jiffies;
+                               send_cluster_request(lkb,
+                                                    lkb->lkb_lockqueue_state);
+                       }
+
+                       else {
+                               /* 
+                                * We are the new RSB master for this lkb
+                                * request.
+                                */
+                               state = lkb->lkb_lockqueue_state;
+                               lkb->lkb_lockqueue_state = 0;
+                               /* list_del equals remove_from_lockqueue() */
+                               list_del(&lkb->lkb_lockqueue);
+                               process_remastered_lkb(lkb, state);
+                       }
+
+                       count++;
+               }
+       }
+       up(&_lockqueue_lock);
+
+       log_all(ls, "resent %d requests", count);
+       return error;
+}
+
+/* 
+ * Process any LKBs on the Lock queue, this
+ * just looks at the entries to see if they have been
+ * on the queue too long and fails the requests if so.
+ */
+
+static void process_lockqueue(void)
+{
+       gd_lkb_t *lkb, *safe;
+       gd_ls_t *ls;
+       int count = 0;
+
+       down(&_lockqueue_lock);
+
+       list_for_each_entry_safe(lkb, safe, &_lockqueue, lkb_lockqueue) {
+               ls = lkb->lkb_resource->res_ls;
+
+               if (test_bit(LSFL_NOTIMERS, &ls->ls_flags))
+                       continue;
+
+               /* Don't time out locks that are in transition */
+               if (!test_bit(LSFL_LS_RUN, &ls->ls_flags))
+                       continue;
+
+               if (check_timeout(lkb->lkb_lockqueue_time,
+                                 dlm_config.lock_timeout)) {
+                       count++;
+                       list_del(&lkb->lkb_lockqueue);
+                       up(&_lockqueue_lock);
+                       cancel_lockop(lkb, -ETIMEDOUT);
+                       down(&_lockqueue_lock);
+               }
+       }
+       up(&_lockqueue_lock);
+
+       if (count)
+               wake_astd();
+
+       if (atomic_read(&_astd_running))
+               mod_timer(&_lockqueue_timer,
+                         jiffies + ((dlm_config.lock_timeout >> 1) * HZ));
+}
+
+/* Look for deadlocks */
+static void process_deadlockqueue(void)
+{
+       gd_lkb_t *lkb, *safe;
+
+       down(&_deadlockqueue_lock);
+
+       list_for_each_entry_safe(lkb, safe, &_deadlockqueue, lkb_deadlockq) {
+               gd_lkb_t *kill_lkb;
+
+               /* Only look at "due" locks */
+               if (!check_timeout(lkb->lkb_duetime, dlm_config.deadlocktime))
+                       break;
+
+               /* Don't look at locks that are in transition */
+               if (!test_bit(LSFL_LS_RUN,
+                             &lkb->lkb_resource->res_ls->ls_flags))
+                       continue;
+
+               up(&_deadlockqueue_lock);
+
+               /* Lock has hit due time, check for conversion deadlock */
+               kill_lkb = conversion_deadlock_check(lkb);
+               if (kill_lkb)
+                       cancel_conversion(kill_lkb, -EDEADLOCK);
+
+               down(&_deadlockqueue_lock);
+       }
+       up(&_deadlockqueue_lock);
+}
+
+static __inline__ int no_asts(void)
+{
+       int ret;
+
+       down(&_ast_queue_lock);
+       ret = list_empty(&_ast_queue);
+       up(&_ast_queue_lock);
+       return ret;
+}
+
+static void lockqueue_timer_fn(unsigned long arg)
+{
+       set_bit(GDLMD_WAKE_TIMER, &_astd_wakeflags);
+       wake_up(&_astd_waitchan);
+}
+
+/* 
+ * DLM daemon which delivers asts.
+ */
+
+static int dlm_astd(void *data)
+{
+       daemonize("dlm_astd");
+
+       INIT_LIST_HEAD(&_lockqueue);
+       init_MUTEX(&_lockqueue_lock);
+       INIT_LIST_HEAD(&_deadlockqueue);
+       init_MUTEX(&_deadlockqueue_lock);
+       INIT_LIST_HEAD(&_ast_queue);
+       init_MUTEX(&_ast_queue_lock);
+       init_waitqueue_head(&_astd_waitchan);
+       complete(&_astd_done);
+
+       /* 
+        * Set a timer to check the lockqueue for dead locks (and deadlocks).
+        */
+
+       init_timer(&_lockqueue_timer);
+       _lockqueue_timer.function = lockqueue_timer_fn;
+       _lockqueue_timer.data = 0;
+       mod_timer(&_lockqueue_timer,
+                 jiffies + ((dlm_config.lock_timeout >> 1) * HZ));
+
+       while (atomic_read(&_astd_running)) {
+               wchan_cond_sleep_intr(_astd_waitchan, no_asts());
+
+               if (test_and_clear_bit(GDLMD_WAKE_ASTS, &_astd_wakeflags))
+                       process_asts();
+
+               if (test_and_clear_bit(GDLMD_WAKE_TIMER, &_astd_wakeflags)) {
+                       process_lockqueue();
+                       if (dlm_config.deadlocktime)
+                               process_deadlockqueue();
+               }
+       }
+
+       if (timer_pending(&_lockqueue_timer))
+               del_timer(&_lockqueue_timer);
+
+       complete(&_astd_done);
+
+       return 0;
+}
+
+void wake_astd(void)
+{
+       set_bit(GDLMD_WAKE_ASTS, &_astd_wakeflags);
+       wake_up(&_astd_waitchan);
+}
+
+int astd_start()
+{
+       init_completion(&_astd_done);
+       atomic_set(&_astd_running, 1);
+       _astd_pid = kernel_thread(dlm_astd, NULL, 0);
+       wait_for_completion(&_astd_done);
+       return 0;
+}
+
+void astd_stop()
+{
+       atomic_set(&_astd_running, 0);
+       wake_astd();
+       wait_for_completion(&_astd_done);
+}
diff -urN linux-orig/cluster/dlm/ast.h linux-patched/cluster/dlm/ast.h
--- linux-orig/cluster/dlm/ast.h        1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/ast.h     2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,29 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __AST_DOT_H__
+#define __AST_DOT_H__
+
+void lockqueue_lkb_mark(gd_ls_t * ls);
+int resend_cluster_requests(gd_ls_t * ls);
+void add_to_lockqueue(gd_lkb_t * lkb);
+void remove_from_lockqueue(gd_lkb_t * lkb);
+void add_to_deadlockqueue(gd_lkb_t * lkb);
+void remove_from_deadlockqueue(gd_lkb_t * lkb);
+void remove_from_astqueue(gd_lkb_t * lkb);
+void queue_ast(gd_lkb_t * lkb, gd_ast_type_t astt, uint8_t rqmode);
+void wake_astd(void);
+int astd_start(void);
+void astd_stop(void);
+
+#endif                         /* __AST_DOT_H__ */
diff -urN linux-orig/cluster/dlm/config.c linux-patched/cluster/dlm/config.c
--- linux-orig/cluster/dlm/config.c     1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/config.c  2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,125 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+
+#include "dlm_internal.h"
+#include "lowcomms.h"
+#include "config.h"
+
+/* Config file defaults */
+#define DEFAULT_TCP_PORT       21064
+#define DEFAULT_LOCK_TIMEOUT      30
+#define DEFAULT_BUFFER_SIZE     4096
+#define DEFAULT_RESHASHTBL       256
+#define DEFAULT_LOCKIDTBL       1024
+#define DEFAULT_MAX_CONNECTIONS  128
+#define DEFAULT_DEADLOCKTIME      10
+
+struct config_info dlm_config = {
+       .tcp_port = DEFAULT_TCP_PORT,
+       .lock_timeout = DEFAULT_LOCK_TIMEOUT,
+       .buffer_size = DEFAULT_BUFFER_SIZE,
+       .reshashtbl = DEFAULT_RESHASHTBL,
+       .lockidtbl = DEFAULT_LOCKIDTBL,
+       .max_connections = DEFAULT_MAX_CONNECTIONS,
+       .deadlocktime = DEFAULT_DEADLOCKTIME,
+};
+
+
+static struct config_proc_info {
+    char *name;
+    int  *value;
+} config_proc[] = {
+    {
+       .name = "tcp_port",
+       .value = &dlm_config.tcp_port,
+    },
+    {
+       .name = "lock_timeout",
+       .value = &dlm_config.lock_timeout,
+    },
+    {
+       .name = "buffer_size",
+       .value = &dlm_config.buffer_size,
+    },
+    {
+       .name = "reshashtbl",
+       .value = &dlm_config.reshashtbl,
+    },
+    {
+       .name = "lockidtbl",
+       .value = &dlm_config.lockidtbl,
+    },
+    {
+       .name = "max_connections",
+       .value = &dlm_config.max_connections,
+    },
+    {
+       .name = "deadlocktime",
+       .value = &dlm_config.deadlocktime,
+    },
+};
+static struct proc_dir_entry *dlm_dir;
+
+static int dlm_config_read_proc(char *page, char **start, off_t off, int count,
+                               int *eof, void *data)
+{
+       struct config_proc_info *cinfo = data;
+       return snprintf(page, count, "%d\n", *cinfo->value);
+}
+
+static int dlm_config_write_proc(struct file *file, const char *buffer,
+                                unsigned long count, void *data)
+{
+       struct config_proc_info *cinfo = data;
+       int value;
+       char *end;
+
+       value = simple_strtoul(buffer, &end, 10);
+       if (*end)
+               *cinfo->value = value;
+       return count;
+}
+
+int dlm_config_init(void)
+{
+       int i;
+       struct proc_dir_entry *pde;
+
+       dlm_dir = proc_mkdir("cluster/config/dlm", 0);
+       if (!dlm_dir)
+               return -1;
+
+       dlm_dir->owner = THIS_MODULE;
+
+       for (i=0; i<sizeof(config_proc)/sizeof(struct config_proc_info); i++) {
+               pde = create_proc_entry(config_proc[i].name, 0660, dlm_dir);
+               if (pde) {
+                       pde->data = &config_proc[i];
+                       pde->write_proc = dlm_config_write_proc;
+                       pde->read_proc = dlm_config_read_proc;
+               }
+       }
+       return 0;
+}
+
+void dlm_config_exit(void)
+{
+       int i;
+
+       for (i=0; i<sizeof(config_proc)/sizeof(struct config_proc_info); i++)
+               remove_proc_entry(config_proc[i].name, dlm_dir);
+       remove_proc_entry("cluster/config/dlm", NULL);
+}
diff -urN linux-orig/cluster/dlm/config.h linux-patched/cluster/dlm/config.h
--- linux-orig/cluster/dlm/config.h     1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/config.h  2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,31 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __CONFIG_DOT_H__
+#define __CONFIG_DOT_H__
+
+struct config_info {
+       int tcp_port;
+       int lock_timeout;
+       int buffer_size;
+       int reshashtbl;
+       int lockidtbl;
+       int max_connections;
+       int deadlocktime;
+};
+
+extern struct config_info dlm_config;
+extern int  dlm_config_init(void);
+extern void dlm_config_exit(void);
+
+#endif                         /* __CONFIG_DOT_H__ */
diff -urN linux-orig/cluster/dlm/device.c linux-patched/cluster/dlm/device.c
--- linux-orig/cluster/dlm/device.c     1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/device.c  2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,1020 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/*
+ * device.c
+ *
+ * This is the userland interface to the DLM.
+ *
+ * The locking is done via a misc char device (find the
+ * registered minor number in /proc/misc).
+ *
+ * User code should not use this interface directly but
+ * call the library routines in libdlm.a instead.
+ *
+ */
+
+#include <linux/miscdevice.h>
+#include <linux/init.h>
+#include <linux/wait.h>
+#include <linux/module.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/poll.h>
+#include <linux/signal.h>
+#include <linux/spinlock.h>
+#include <asm/ioctls.h>
+
+#include "dlm_internal.h"
+#include "device.h"
+
+extern gd_lkb_t *dlm_get_lkb(gd_ls_t *, int);
+static struct file_operations _dlm_fops;
+static const char *name_prefix="dlm";
+static struct list_head user_ls_list;
+
+/* Flags in li_flags */
+#define LI_FLAG_COMPLETE  1
+#define LI_FLAG_FIRSTLOCK 2
+
+struct lock_info {
+       uint8_t li_cmd;
+       struct dlm_lksb li_lksb;
+       wait_queue_head_t li_waitq;
+       unsigned long li_flags;
+       void __user *li_astparam;
+       void __user *li_astaddr;
+       void __user *li_bastaddr;
+       struct file_info *li_file;
+       struct dlm_lksb __user *li_user_lksb;
+       struct semaphore li_firstlock;
+       struct dlm_queryinfo *li_queryinfo;
+       struct dlm_queryinfo __user *li_user_queryinfo;
+};
+
+/* A queued AST no less */
+struct ast_info {
+       struct dlm_lock_result result;
+       struct dlm_queryinfo *queryinfo;
+       struct dlm_queryinfo __user *user_queryinfo;
+       struct list_head list;
+};
+
+/* One of these per userland lockspace */
+struct user_ls {
+       void    *ls_lockspace;
+       atomic_t ls_refcnt;
+       long     ls_flags; /* bit 1 means LS has been deleted */
+
+       /* Passed into misc_register() */
+       struct miscdevice ls_miscinfo;
+       struct list_head  ls_list;
+};
+
+/* misc_device info for the control device */
+static struct miscdevice ctl_device;
+
+/*
+ * Stuff we hang off the file struct.
+ * The first two are to cope with unlocking all the
+ * locks help by a process when it dies.
+ */
+struct file_info {
+       struct list_head    fi_lkb_list;     /* List of active lkbs */
+       spinlock_t          fi_lkb_lock;
+       struct list_head    fi_ast_list;     /* Queue of ASTs to be delivered */
+       spinlock_t          fi_ast_lock;
+       wait_queue_head_t   fi_wait;
+       struct user_ls     *fi_ls;
+       atomic_t            fi_refcnt;       /* Number of users */
+       unsigned long       fi_flags;        /* Bit 1 means the device is open */
+};
+
+
+/* get and put ops for file_info.
+   Actually I don't really like "get" and "put", but everyone
+   else seems to use them and I can't think of anything
+   nicer at the moment */
+static void get_file_info(struct file_info *f)
+{
+       atomic_inc(&f->fi_refcnt);
+}
+
+static void put_file_info(struct file_info *f)
+{
+       if (atomic_dec_and_test(&f->fi_refcnt))
+               kfree(f);
+}
+
+/* Find a lockspace struct given the device minor number */
+static struct user_ls *find_lockspace(int minor)
+{
+       struct user_ls *lsinfo;
+
+       list_for_each_entry(lsinfo, &user_ls_list, ls_list) {
+
+               if (lsinfo->ls_miscinfo.minor == minor)
+                       return lsinfo;
+       }
+       return NULL;
+}
+
+static void add_lockspace_to_list(struct user_ls *lsinfo)
+{
+       list_add(&lsinfo->ls_list, &user_ls_list);
+}
+
+/* Register a lockspace with the DLM and create a misc
+   device for userland to access it */
+static int register_lockspace(char *name, struct user_ls **ls)
+{
+       struct user_ls *newls;
+       int status;
+       int namelen;
+
+       namelen = strlen(name)+strlen(name_prefix)+2;
+
+       newls = kmalloc(sizeof(struct user_ls), GFP_KERNEL);
+       if (!newls)
+               return -ENOMEM;
+       memset(newls, 0, sizeof(struct user_ls));
+
+       newls->ls_miscinfo.name = kmalloc(namelen, GFP_KERNEL);
+       if (!newls->ls_miscinfo.name) {
+               kfree(newls);
+               return -ENOMEM;
+       }
+       snprintf((char*)newls->ls_miscinfo.name, namelen, "%s_%s", name_prefix, name);
+
+       status = dlm_new_lockspace((char *)newls->ls_miscinfo.name+strlen(name_prefix)+1,
+                                   strlen(newls->ls_miscinfo.name) - strlen(name_prefix) - 1,
+                                   &newls->ls_lockspace, 0);
+
+       if (status != 0) {
+               kfree(newls->ls_miscinfo.name);
+               kfree(newls);
+               return status;
+       }
+
+       newls->ls_miscinfo.fops = &_dlm_fops;
+       newls->ls_miscinfo.minor = MISC_DYNAMIC_MINOR;
+
+       status = misc_register(&newls->ls_miscinfo);
+       if (status) {
+               log_print("failed to register misc device for %s", name);
+               dlm_release_lockspace(newls->ls_lockspace, 0);
+               kfree(newls->ls_miscinfo.name);
+               kfree(newls);
+               return status;
+       }
+
+
+       add_lockspace_to_list(newls);
+       *ls = newls;
+       return 0;
+}
+
+static int unregister_lockspace(struct user_ls *lsinfo, int force)
+{
+       int status;
+
+       status = dlm_release_lockspace(lsinfo->ls_lockspace, force);
+       if (status)
+               return status;
+
+       status = misc_deregister(&lsinfo->ls_miscinfo);
+       if (status)
+               return status;
+
+       list_del(&lsinfo->ls_list);
+       kfree(lsinfo->ls_miscinfo.name);
+       kfree(lsinfo);
+
+       return 0;
+}
+
+/* Add it to userland's AST queue */
+static void add_to_astqueue(struct lock_info *li, void *astaddr)
+{
+       struct ast_info *ast = kmalloc(sizeof(struct ast_info), GFP_KERNEL);
+       if (!ast)
+               return;
+
+       ast->result.astparam  = li->li_astparam;
+       ast->result.astaddr   = astaddr;
+       ast->result.user_lksb = li->li_user_lksb;
+       ast->result.cmd       = li->li_cmd;
+       memcpy(&ast->result.lksb, &li->li_lksb, sizeof(struct dlm_lksb));
+
+       /* These two will both be NULL for anything other than queries */
+       ast->queryinfo        = li->li_queryinfo;
+       ast->user_queryinfo   = li->li_user_queryinfo;
+
+       spin_lock(&li->li_file->fi_ast_lock);
+       list_add_tail(&ast->list, &li->li_file->fi_ast_list);
+       spin_unlock(&li->li_file->fi_ast_lock);
+       wake_up_interruptible(&li->li_file->fi_wait);
+}
+
+static void bast_routine(void *param, int mode)
+{
+       struct lock_info *li = param;
+
+       if (param) {
+               add_to_astqueue(li, li->li_bastaddr);
+       }
+}
+
+/*
+ * This is the kernel's AST routine.
+ * All lock, unlock & query operations complete here.
+ * The only syncronous ops are those done during device close.
+ */
+static void ast_routine(void *param)
+{
+       struct lock_info *li = param;
+
+       /* Param may be NULL if a persistent lock is unlocked by someone else */
+       if (!param)
+               return;
+
+       /* If it's an async request then post data to the user's AST queue. */
+       if (li->li_astaddr) {
+
+               /* Only queue AST if the device is still open */
+               if (test_bit(1, &li->li_file->fi_flags))
+                       add_to_astqueue(li, li->li_astaddr);
+
+               /* If it's a new lock operation that failed, then
+                * remove it from the owner queue and free the
+                * lock_info. The DLM will not free the LKB until this
+                * AST has completed.
+                */
+               if (test_and_clear_bit(LI_FLAG_FIRSTLOCK, &li->li_flags) &&
+                   li->li_lksb.sb_status != 0) {
+                       gd_lkb_t *lkb;
+
+                       /* Wait till dlm_lock() has finished */
+                       down(&li->li_firstlock);
+                       lkb = dlm_get_lkb(li->li_file->fi_ls->ls_lockspace, li->li_lksb.sb_lkid);
+                       if (lkb) {
+                               spin_lock(&li->li_file->fi_lkb_lock);
+                               list_del(&lkb->lkb_ownerqueue);
+                               spin_unlock(&li->li_file->fi_lkb_lock);
+                       }
+                       up(&li->li_firstlock);
+                       put_file_info(li->li_file);
+                       kfree(li);
+                       return;
+               }
+               /* Free unlocks & queries */
+               if (li->li_lksb.sb_status == -DLM_EUNLOCK ||
+                   li->li_cmd == DLM_USER_QUERY) {
+                       put_file_info(li->li_file);
+                       kfree(li);
+               }
+       }
+       else {
+               /* Syncronous request, just wake up the caller */
+               set_bit(LI_FLAG_COMPLETE, &li->li_flags);
+               wake_up_interruptible(&li->li_waitq);
+       }
+}
+
+/*
+ * Wait for the lock op to complete and return the status.
+ */
+static int wait_for_ast(struct lock_info *li)
+{
+       /* Wait for the AST routine to complete */
+       set_task_state(current, TASK_INTERRUPTIBLE);
+       while (!test_bit(LI_FLAG_COMPLETE, &li->li_flags))
+               schedule();
+
+       set_task_state(current, TASK_RUNNING);
+
+       return li->li_lksb.sb_status;
+}
+
+
+/* Open on control device */
+static int dlm_ctl_open(struct inode *inode, struct file *file)
+{
+       return 0;
+}
+
+/* Close on control device */
+static int dlm_ctl_close(struct inode *inode, struct file *file)
+{
+       return 0;
+}
+
+/* Open on lockspace device */
+static int dlm_open(struct inode *inode, struct file *file)
+{
+       struct file_info *f;
+       struct user_ls *lsinfo;
+
+       lsinfo = find_lockspace(iminor(inode));
+       if (!lsinfo)
+               return -ENOENT;
+
+       f = kmalloc(sizeof(struct file_info), GFP_KERNEL);
+       if (!f)
+               return -ENOMEM;
+
+       atomic_inc(&lsinfo->ls_refcnt);
+       INIT_LIST_HEAD(&f->fi_lkb_list);
+       INIT_LIST_HEAD(&f->fi_ast_list);
+       spin_lock_init(&f->fi_ast_lock);
+       spin_lock_init(&f->fi_lkb_lock);
+       init_waitqueue_head(&f->fi_wait);
+       f->fi_ls = lsinfo;
+       atomic_set(&f->fi_refcnt, 1);
+       set_bit(1, &f->fi_flags);
+
+       file->private_data = f;
+
+       return 0;
+}
+
+/* Check the user's version matches ours */
+static int check_version(struct dlm_lock_params *params)
+{
+       if (params->version[0] != DLM_DEVICE_VERSION_MAJOR ||
+           (params->version[0] == DLM_DEVICE_VERSION_MAJOR &&
+            params->version[1] > DLM_DEVICE_VERSION_MINOR)) {
+
+               log_print("version mismatch user (%d.%d.%d) kernel (%d.%d.%d)",
+                      params->version[0],
+                      params->version[1],
+                      params->version[2],
+                      DLM_DEVICE_VERSION_MAJOR,
+                      DLM_DEVICE_VERSION_MINOR,
+                      DLM_DEVICE_VERSION_PATCH);
+               return -EINVAL;
+       }
+       return 0;
+}
+
+/* Close on lockspace device */
+static int dlm_close(struct inode *inode, struct file *file)
+{
+       struct file_info *f = file->private_data;
+       struct lock_info li;
+       sigset_t tmpsig;
+       sigset_t allsigs;
+       gd_lkb_t *lkb, *safe;
+       struct user_ls *lsinfo;
+       DECLARE_WAITQUEUE(wq, current);
+
+       lsinfo = find_lockspace(iminor(inode));
+       if (!lsinfo)
+               return -ENOENT;
+
+       /* Mark this closed so that ASTs will not be delivered any more */
+       clear_bit(1, &f->fi_flags);
+
+       /* Block signals while we are doing this */
+       sigfillset(&allsigs);
+       sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
+
+       /* We use our own lock_info struct here, so that any
+        * outstanding "real" ASTs will be delivered with the
+        * corresponding "real" params, thus freeing the lock_info
+        * that belongs the lock. This catches the corner case where
+        * a lock is BUSY when we try to unlock it here
+        */
+       memset(&li, 0, sizeof(li));
+       clear_bit(LI_FLAG_COMPLETE, &li.li_flags);
+       init_waitqueue_head(&li.li_waitq);
+       add_wait_queue(&li.li_waitq, &wq);
+
+       /*
+        * Free any outstanding locks, they are on the
+        * list in LIFO order so there should be no problems
+        * about unlocking parents before children.
+        * Although we don't remove the lkbs from the list here
+        * (what would be the point?), foreach_safe is needed
+        * because the lkbs are freed during dlm_unlock operations
+        */
+       list_for_each_entry_safe(lkb, safe, &f->fi_lkb_list, lkb_ownerqueue) {
+               int status;
+               int lock_status;
+               int flags = 0;
+               struct lock_info *old_li;
+
+               /* Make a copy of this pointer. If all goes well we will
+                * free it later. if not it will be left to the AST routine
+                * to tidy up
+                */
+               old_li = (struct lock_info *)lkb->lkb_astparam;
+
+               /* Don't unlock persistent locks */
+               if (lkb->lkb_flags & GDLM_LKFLG_PERSISTENT) {
+                       list_del(&lkb->lkb_ownerqueue);
+
+                       /* But tidy our references in it */
+                       kfree(old_li);
+                       lkb->lkb_astparam = (long)NULL;
+                       put_file_info(f);
+                       continue;
+               }
+
+               clear_bit(LI_FLAG_COMPLETE, &li.li_flags);
+
+               /* If it's not granted then cancel the request.
+                * If the lock was WAITING then it will be dropped,
+                *    if it was converting then it will be reverted to GRANTED,
+                *    then we will unlock it.
+                */
+               lock_status = lkb->lkb_status;
+
+               if (lock_status != GDLM_LKSTS_GRANTED)
+                       flags = DLM_LKF_CANCEL;
+
+               status = dlm_unlock(f->fi_ls->ls_lockspace, lkb->lkb_id, flags, &li.li_lksb, &li);
+
+               /* Must wait for it to complete as the next lock could be its
+                * parent */
+               if (status == 0)
+                       wait_for_ast(&li);
+
+               /* If it was waiting for a conversion, it will
+                  now be granted so we can unlock it properly */
+               if (lock_status == GDLM_LKSTS_CONVERT) {
+
+                       clear_bit(LI_FLAG_COMPLETE, &li.li_flags);
+                       status = dlm_unlock(f->fi_ls->ls_lockspace, lkb->lkb_id, 0, &li.li_lksb, &li);
+
+                       if (status == 0)
+                               wait_for_ast(&li);
+               }
+               /* Unlock suceeded, free the lock_info struct. */
+               if (status == 0) {
+                       kfree(old_li);
+                       put_file_info(f);
+               }
+       }
+
+       remove_wait_queue(&li.li_waitq, &wq);
+
+       /* If this is the last reference, and the lockspace has been deleted
+          the free the struct */
+       if (atomic_dec_and_test(&lsinfo->ls_refcnt) && !lsinfo->ls_lockspace) {
+               kfree(lsinfo);
+       }
+
+       /* Restore signals */
+       sigprocmask(SIG_SETMASK, &tmpsig, NULL);
+       recalc_sigpending();
+
+       return 0;
+}
+
+/*
+ * ioctls to create/remove lockspaces, and check how many
+ * outstanding ASTs there are against a particular LS.
+ */
+static int dlm_ioctl(struct inode *inode, struct file *file,
+                    uint command, ulong u)
+{
+       struct file_info *fi = file->private_data;
+       int status = -EINVAL;
+       int count;
+       struct list_head *tmp_list;
+
+       switch (command) {
+
+               /* Are there any ASTs for us to read?
+                * Warning, this returns the number of messages (ASTs)
+                * in the queue, NOT the number of bytes to read
+                */
+       case FIONREAD:
+               count = 0;
+               spin_lock(&fi->fi_ast_lock);
+               list_for_each(tmp_list, &fi->fi_ast_list)
+                       count++;
+               spin_unlock(&fi->fi_ast_lock);
+               status = put_user(count, (int *)u);
+               break;
+
+       default:
+               return -ENOTTY;
+       }
+
+       return status;
+}
+
+/*
+ * ioctls to create/remove lockspaces.
+ */
+static int dlm_ctl_ioctl(struct inode *inode, struct file *file,
+                        uint command, ulong u)
+{
+       int status = -EINVAL;
+       char ls_name[MAX_LS_NAME_LEN];
+       struct user_ls *lsinfo;
+       int force = 0;
+
+       switch (command) {
+       case DLM_CREATE_LOCKSPACE:
+               if (!capable(CAP_SYS_ADMIN))
+                       return -EPERM;
+
+               if (strncpy_from_user(ls_name, (char*)u, MAX_LS_NAME_LEN) < 0)
+                       return -EFAULT;
+               status = register_lockspace(ls_name, &lsinfo);
+
+               /* If it succeeded then return the minor number */
+               if (status == 0)
+                       status = lsinfo->ls_miscinfo.minor;
+               break;
+
+       case DLM_FORCE_RELEASE_LOCKSPACE:
+               force = 2;
+
+       case DLM_RELEASE_LOCKSPACE:
+               if (!capable(CAP_SYS_ADMIN))
+                       return -EPERM;
+
+               lsinfo = find_lockspace(u);
+               if (!lsinfo)
+                       return -EINVAL;
+               status = unregister_lockspace(lsinfo, force);
+               break;
+
+       default:
+               return -ENOTTY;
+       }
+
+       return status;
+}
+
+/* Deal with the messy stuff of copying a web of structs
+   from kernel space to userspace */
+static int copy_query_result(struct ast_info *ast)
+{
+       int status = -EFAULT;
+       struct dlm_queryinfo qi;
+
+       /* Get the pointers to userspace structs */
+       if (copy_from_user(&qi, ast->user_queryinfo,
+                          sizeof(struct dlm_queryinfo)))
+               goto copy_out;
+
+       /* TODO: does this deref a user pointer? */
+       if (put_user(ast->queryinfo->gqi_lockcount,
+                    &ast->user_queryinfo->gqi_lockcount))
+               goto copy_out;
+
+       if (qi.gqi_resinfo) {
+               if (copy_to_user(qi.gqi_resinfo, ast->queryinfo->gqi_resinfo,
+                                sizeof(struct dlm_resinfo)))
+                       goto copy_out;
+       }
+
+       if (qi.gqi_lockinfo) {
+               if (copy_to_user(qi.gqi_lockinfo, ast->queryinfo->gqi_lockinfo,
+                                sizeof(struct dlm_lockinfo) * ast->queryinfo->gqi_lockcount))
+                       goto copy_out;
+       }
+
+       status = 0;
+
+       if (ast->queryinfo->gqi_lockinfo)
+               kfree(ast->queryinfo->gqi_lockinfo);
+
+       if (ast->queryinfo->gqi_resinfo)
+               kfree(ast->queryinfo->gqi_resinfo);
+
+       kfree(ast->queryinfo);
+
+ copy_out:
+       return status;
+}
+
+/* Read call, might block if no ASTs are waiting.
+ * It will only ever return one message at a time, regardless
+ * of how many are pending.
+ */
+static ssize_t dlm_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
+{
+       struct file_info *fi = file->private_data;
+       struct ast_info *ast;
+       int ret;
+       DECLARE_WAITQUEUE(wait, current);
+
+       if (count < sizeof(struct dlm_lock_result))
+               return -EINVAL;
+
+       spin_lock(&fi->fi_ast_lock);
+       if (list_empty(&fi->fi_ast_list)) {
+
+               /* No waiting ASTs.
+                * Return EOF if the lockspace been deleted.
+                */
+               if (test_bit(1, &fi->fi_ls->ls_flags))
+                       return 0;
+
+               if (file->f_flags & O_NONBLOCK) {
+                       spin_unlock(&fi->fi_ast_lock);
+                       return -EAGAIN;
+               }
+
+               add_wait_queue(&fi->fi_wait, &wait);
+
+       repeat:
+               set_current_state(TASK_INTERRUPTIBLE);
+               if (list_empty(&fi->fi_ast_list) &&
+                   !signal_pending(current)) {
+
+                       spin_unlock(&fi->fi_ast_lock);
+                       schedule();
+                       spin_lock(&fi->fi_ast_lock);
+                       goto repeat;
+               }
+
+               current->state = TASK_RUNNING;
+               remove_wait_queue(&fi->fi_wait, &wait);
+
+               if (signal_pending(current)) {
+                       spin_unlock(&fi->fi_ast_lock);
+                       return -ERESTARTSYS;
+               }
+       }
+
+       ast = list_entry(fi->fi_ast_list.next, struct ast_info, list);
+       list_del(&ast->list);
+       spin_unlock(&fi->fi_ast_lock);
+
+       ret = sizeof(struct dlm_lock_result);
+       if (copy_to_user(buffer, &ast->result, sizeof(struct dlm_lock_result)))
+               ret = -EFAULT;
+
+       /* If it was a query then copy the result block back here */
+       if (ast->queryinfo) {
+               int status = copy_query_result(ast);
+               if (status)
+                       ret = status;
+       }
+
+       kfree(ast);
+       return ret;
+}
+
+static unsigned int dlm_poll(struct file *file, poll_table *wait)
+{
+       struct file_info *fi = file->private_data;
+
+       poll_wait(file, &fi->fi_wait, wait);
+
+       spin_lock(&fi->fi_ast_lock);
+       if (!list_empty(&fi->fi_ast_list)) {
+               spin_unlock(&fi->fi_ast_lock);
+               return POLLIN | POLLRDNORM;
+       }
+
+       spin_unlock(&fi->fi_ast_lock);
+       return 0;
+}
+
+static int do_user_query(struct file_info *fi, struct dlm_lock_params *kparams)
+{
+       struct lock_info *li;
+       int status;
+
+       li = kmalloc(sizeof(struct lock_info), GFP_KERNEL);
+       if (!li)
+               return -ENOMEM;
+
+       get_file_info(fi);
+       li->li_user_lksb = kparams->lksb;
+       li->li_astparam  = kparams->astparam;
+       li->li_bastaddr  = kparams->bastaddr;
+       li->li_astaddr   = kparams->astaddr;
+       li->li_file      = fi;
+       li->li_flags     = 0;
+       li->li_cmd       = kparams->cmd;
+       clear_bit(LI_FLAG_FIRSTLOCK, &li->li_flags);
+
+       if (copy_from_user(&li->li_lksb, kparams->lksb,
+                          sizeof(struct dlm_lksb))) {
+               kfree(li);
+               return -EFAULT;
+       }
+       li->li_user_queryinfo = (struct dlm_queryinfo *)li->li_lksb.sb_lvbptr;
+
+       /* Allocate query structs */
+       status = -ENOMEM;
+       li->li_queryinfo = kmalloc(sizeof(struct dlm_queryinfo), GFP_KERNEL);
+       if (!li->li_queryinfo)
+               goto out1;
+
+       /* Mainly to get gqi_lock buffer size */
+       if (copy_from_user(li->li_queryinfo, li->li_lksb.sb_lvbptr,
+                          sizeof(struct dlm_queryinfo))) {
+               status = -EFAULT;
+               goto out1;
+       }
+
+       /* Overwrite userspace pointers we just copied with kernel space ones */
+       if (li->li_queryinfo->gqi_resinfo) {
+               li->li_queryinfo->gqi_resinfo = kmalloc(sizeof(struct dlm_resinfo), GFP_KERNEL);
+               if (!li->li_queryinfo->gqi_resinfo)
+                       goto out1;
+       }
+       if (li->li_queryinfo->gqi_lockinfo) {
+               li->li_queryinfo->gqi_lockinfo =
+                       kmalloc(sizeof(struct dlm_lockinfo) * li->li_queryinfo->gqi_locksize,
+                               GFP_KERNEL);
+               if (!li->li_queryinfo->gqi_lockinfo)
+                       goto out2;
+       }
+
+       li->li_lksb.sb_lvbptr = (char *)li->li_queryinfo;
+
+       return dlm_query(fi->fi_ls->ls_lockspace, &li->li_lksb,
+                         kparams->flags, /* query */
+                         li->li_queryinfo,
+                         ast_routine, li);
+
+ out2:
+       kfree(li->li_queryinfo);
+
+ out1:
+       kfree(li);
+       return status;
+}
+
+static int do_user_lock(struct file_info *fi, struct dlm_lock_params *kparams,
+                       const char *buffer)
+{
+       struct lock_info *li;
+       int status;
+       char name[DLM_RESNAME_MAXLEN];
+
+       /*
+        * Validate things that we need to have correct.
+        */
+       if (kparams->namelen > DLM_RESNAME_MAXLEN)
+               return -EINVAL;
+
+       if (!kparams->astaddr)
+               return -EINVAL;
+
+       if (!kparams->lksb)
+               return -EINVAL;
+
+       /* Get the lock name */
+       if (copy_from_user(name, buffer + offsetof(struct dlm_lock_params, name),
+                          kparams->namelen)) {
+               return -EFAULT;
+       }
+
+       /* For conversions, the lock will already have a lock_info
+          block squirelled away in astparam */
+       if (kparams->flags & DLM_LKF_CONVERT) {
+               gd_lkb_t *lkb = dlm_get_lkb(fi->fi_ls->ls_lockspace, kparams->lkid);
+               if (!lkb) {
+                       return -EINVAL;
+               }
+               li = (struct lock_info *)lkb->lkb_astparam;
+
+               /* Only override these if they are provided */
+               if (li->li_user_lksb)
+                       li->li_user_lksb = kparams->lksb;
+               if (li->li_astparam)
+                       li->li_astparam  = kparams->astparam;
+               if (li->li_bastaddr)
+                       li->li_bastaddr  = kparams->bastaddr;
+               if (li->li_bastaddr)
+                       li->li_astaddr   = kparams->astaddr;
+               li->li_flags     = 0;
+       }
+       else {
+               li = kmalloc(sizeof(struct lock_info), GFP_KERNEL);
+               if (!li)
+                       return -ENOMEM;
+
+               li->li_user_lksb = kparams->lksb;
+               li->li_astparam  = kparams->astparam;
+               li->li_bastaddr  = kparams->bastaddr;
+               li->li_astaddr   = kparams->astaddr;
+               li->li_file      = fi;
+               li->li_flags     = 0;
+               li->li_cmd       = kparams->cmd;
+               li->li_queryinfo  = NULL;
+
+               /* semaphore to allow us to complete our work before
+                  the AST routine runs. In fact we only need (and use) this
+                  when the initial lock fails */
+               init_MUTEX_LOCKED(&li->li_firstlock);
+               set_bit(LI_FLAG_FIRSTLOCK, &li->li_flags);
+
+               get_file_info(fi);
+       }
+
+       /* Copy the user's LKSB into kernel space,
+          needed for conversions & value block operations */
+       if (kparams->lksb && copy_from_user(&li->li_lksb, kparams->lksb,
+                                           sizeof(struct dlm_lksb)))
+               return -EFAULT;
+
+       /* Lock it ... */
+       status = dlm_lock(fi->fi_ls->ls_lockspace, kparams->mode, &li->li_lksb,
+                          kparams->flags, name, kparams->namelen,
+                          kparams->parent,
+                          ast_routine,
+                          li,
+                          li->li_bastaddr ? bast_routine : NULL,
+                          kparams->range.ra_end ? &kparams->range : NULL);
+
+       /* If it succeeded (this far) with a new lock then keep track of
+          it on the file's lkb list */
+       if (!status && !(kparams->flags & DLM_LKF_CONVERT)) {
+               gd_lkb_t *lkb;
+               lkb = dlm_get_lkb(fi->fi_ls->ls_lockspace, li->li_lksb.sb_lkid);
+
+               if (lkb) {
+                       spin_lock(&fi->fi_lkb_lock);
+                       list_add(&lkb->lkb_ownerqueue,
+                                &fi->fi_lkb_list);
+                       spin_unlock(&fi->fi_lkb_lock);
+               }
+               else {
+                       log_print("failed to get lkb for new lock");
+               }
+               up(&li->li_firstlock);
+       }
+
+       return status;
+}
+
+static int do_user_unlock(struct file_info *fi, struct dlm_lock_params *kparams)
+{
+       struct lock_info *li;
+       gd_lkb_t *lkb;
+       int status;
+
+       lkb = dlm_get_lkb(fi->fi_ls->ls_lockspace, kparams->lkid);
+       if (!lkb) {
+               return -EINVAL;
+       }
+
+       li = (struct lock_info *)lkb->lkb_astparam;
+
+       li->li_user_lksb = kparams->lksb;
+       li->li_astparam  = kparams->astparam;
+       li->li_cmd       = kparams->cmd;
+
+       /* Have to do it here cos the lkb may not exist after
+        * dlm_unlock() */
+       spin_lock(&fi->fi_lkb_lock);
+       list_del(&lkb->lkb_ownerqueue);
+       spin_unlock(&fi->fi_lkb_lock);
+
+       /* Use existing lksb & astparams */
+       status = dlm_unlock(fi->fi_ls->ls_lockspace,
+                            kparams->lkid,
+                            kparams->flags, NULL, NULL);
+
+       return status;
+}
+
+/* Write call, submit a locking request */
+static ssize_t dlm_write(struct file *file, const char __user *buffer,
+                        size_t count, loff_t *ppos)
+{
+       struct file_info *fi = file->private_data;
+       struct dlm_lock_params kparams;
+       sigset_t tmpsig;
+       sigset_t allsigs;
+       int status;
+
+       if (count < sizeof(kparams))
+               return -EINVAL;
+
+       /* Has the lockspace been deleted */
+       if (test_bit(1, &fi->fi_ls->ls_flags))
+               return -ENOENT;
+
+       /* Get the command info */
+       if (copy_from_user(&kparams, buffer, sizeof(kparams)))
+               return -EFAULT;
+
+       if (check_version(&kparams))
+               return -EINVAL;
+
+       /* Block signals while we are doing this */
+       sigfillset(&allsigs);
+       sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
+
+       switch (kparams.cmd)
+       {
+       case DLM_USER_LOCK:
+               status = do_user_lock(fi, &kparams, buffer);
+               break;
+
+       case DLM_USER_UNLOCK:
+               status = do_user_unlock(fi, &kparams);
+               break;
+
+       case DLM_USER_QUERY:
+               status = do_user_query(fi, &kparams);
+               break;
+
+       default:
+               status = -EINVAL;
+               break;
+       }
+       /* Restore signals */
+       sigprocmask(SIG_SETMASK, &tmpsig, NULL);
+       recalc_sigpending();
+
+       if (status == 0)
+               return count;
+       else
+               return status;
+}
+
+void dlm_device_free_devices()
+{
+       struct user_ls *tmp;
+       struct user_ls *lsinfo;
+
+       list_for_each_entry_safe(lsinfo, tmp, &user_ls_list, ls_list) {
+               misc_deregister(&lsinfo->ls_miscinfo);
+
+               /* Tidy up, but don't delete the lsinfo struct until
+                  all the users have closed their devices */
+               list_del(&lsinfo->ls_list);
+               kfree(lsinfo->ls_miscinfo.name);
+               set_bit(1, &lsinfo->ls_flags); /* LS has been deleted */
+       }
+}
+
+static struct file_operations _dlm_fops = {
+      .open    = dlm_open,
+      .release = dlm_close,
+      .ioctl   = dlm_ioctl,
+      .read    = dlm_read,
+      .write   = dlm_write,
+      .poll    = dlm_poll,
+      .owner   = THIS_MODULE,
+};
+
+static struct file_operations _dlm_ctl_fops = {
+      .open    = dlm_ctl_open,
+      .release = dlm_ctl_close,
+      .ioctl   = dlm_ctl_ioctl,
+      .owner   = THIS_MODULE,
+};
+
+/*
+ * Create control device
+ */
+int dlm_device_init(void)
+{
+       int r;
+
+       INIT_LIST_HEAD(&user_ls_list);
+
+       ctl_device.name = "dlm-control";
+       ctl_device.fops = &_dlm_ctl_fops;
+       ctl_device.minor = MISC_DYNAMIC_MINOR;
+
+       r = misc_register(&ctl_device);
+       if (r) {
+               log_print("misc_register failed for DLM control device");
+               return r;
+       }
+
+       return 0;
+}
+
+void dlm_device_exit(void)
+{
+       misc_deregister(&ctl_device);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff -urN linux-orig/cluster/dlm/device.h linux-patched/cluster/dlm/device.h
--- linux-orig/cluster/dlm/device.h     1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/device.h  2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,19 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __DEVICE_DOT_H__
+#define __DEVICE_DOT_H__
+
+extern void dlm_device_free_devices(void);
+
+#endif                         /* __DEVICE_DOT_H__ */
diff -urN linux-orig/cluster/dlm/dir.c linux-patched/cluster/dlm/dir.c
--- linux-orig/cluster/dlm/dir.c        1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/dir.c     2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,430 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include "dlm_internal.h"
+#include "nodes.h"
+#include "lockspace.h"
+#include "lowcomms.h"
+#include "reccomms.h"
+#include "rsb.h"
+#include "config.h"
+#include "memory.h"
+#include "recover.h"
+#include "util.h"
+
+/* 
+ * We use the upper 16 bits of the hash value to select the directory node.
+ * Low bits are used for distribution of rsb's among hash buckets on each node.
+ *
+ * From the hash value, we are interested in arriving at a final value between
+ * zero and the number of nodes minus one (num_nodes - 1).
+ *
+ * To accomplish this scaling, we take the nearest power of two larger than
+ * num_nodes and subtract one to create a bit mask.  The mask is applied to the
+ * hash, reducing the range to nearer the final range.
+ *
+ * To give the exact range wanted (0 to num_nodes-1), we apply a modulus of
+ * num_nodes to the previously masked hash value.
+ *
+ * This value in the desired range is used as an offset into the sorted list of
+ * nodeid's to give the particular nodeid of the directory node.
+ */
+
+uint32_t name_to_directory_nodeid(gd_ls_t *ls, char *name, int length)
+{
+       struct list_head *tmp;
+       gd_csb_t *csb = NULL;
+       uint32_t hash, node, n = 0, nodeid;
+
+       if (ls->ls_num_nodes == 1) {
+               nodeid = our_nodeid();
+               goto out;
+       }
+
+       hash = gdlm_hash(name, length);
+       node = (hash >> 16) & ls->ls_nodes_mask;
+       node %= ls->ls_num_nodes;
+
+       list_for_each(tmp, &ls->ls_nodes) {
+               if (n++ != node)
+                       continue;
+               csb = list_entry(tmp, gd_csb_t, csb_list);
+               break;
+       }
+
+       GDLM_ASSERT(csb, printk("num_nodes=%u n=%u node=%u mask=%x\n",
+                               ls->ls_num_nodes, n, node, ls->ls_nodes_mask););
+       nodeid = csb->csb_node->gn_nodeid;
+
+      out:
+       return nodeid;
+}
+
+uint32_t get_directory_nodeid(gd_res_t *rsb)
+{
+       return name_to_directory_nodeid(rsb->res_ls, rsb->res_name,
+                                       rsb->res_length);
+}
+
+static inline uint32_t rd_hash(gd_ls_t *ls, char *name, int len)
+{
+       uint32_t val;
+
+       val = gdlm_hash(name, len);
+       val &= RESDIRHASH_MASK;
+
+       return val;
+}
+
+static void add_resdata_to_hash(gd_ls_t *ls, gd_resdata_t *rd)
+{
+       gd_resdir_bucket_t *bucket;
+       uint32_t hashval;
+
+       hashval = rd_hash(ls, rd->rd_name, rd->rd_length);
+       bucket = &ls->ls_resdir_hash[hashval];
+
+       list_add_tail(&rd->rd_list, &bucket->rb_reslist);
+}
+
+static gd_resdata_t *search_rdbucket(gd_ls_t *ls, char *name, int namelen,
+                                    uint32_t bucket)
+{
+       struct list_head *head;
+       gd_resdata_t *rd;
+
+       head = &ls->ls_resdir_hash[bucket].rb_reslist;
+       list_for_each_entry(rd, head, rd_list) {
+               if (rd->rd_length == namelen &&
+                   !memcmp(name, rd->rd_name, namelen))
+                       goto out;
+       }
+       rd = NULL;
+      out:
+       return rd;
+}
+
+void remove_resdata(gd_ls_t *ls, uint32_t nodeid, char *name, int namelen,
+                   uint8_t sequence)
+{
+       gd_resdata_t *rd;
+       uint32_t bucket;
+
+       bucket = rd_hash(ls, name, namelen);
+
+       write_lock(&ls->ls_resdir_hash[bucket].rb_lock);
+
+       rd = search_rdbucket(ls, name, namelen, bucket);
+
+       if (!rd) {
+               log_debug(ls, "remove_resdata not found nodeid=%u", nodeid);
+               goto out;
+       }
+
+       if (rd->rd_master_nodeid != nodeid) {
+               log_debug(ls, "remove_resdata wrong nodeid=%u", nodeid);
+               goto out;
+       }
+
+       if (rd->rd_sequence == sequence) {
+               list_del(&rd->rd_list);
+               free_resdata(rd);
+       } else {
+               /* 
+               log_debug(ls, "remove_resdata mismatch nodeid=%u rd=%u in=%u",
+                         nodeid, rd->rd_sequence, sequence);
+               */
+       }
+
+      out:
+       write_unlock(&ls->ls_resdir_hash[bucket].rb_lock);
+}
+
+void resdir_clear(gd_ls_t *ls)
+{
+       struct list_head *head;
+       gd_resdata_t *rd;
+       int i;
+
+       for (i = 0; i < RESDIRHASH_SIZE; i++) {
+               head = &ls->ls_resdir_hash[i].rb_reslist;
+               while (!list_empty(head)) {
+                       rd = list_entry(head->next, gd_resdata_t, rd_list);
+                       list_del(&rd->rd_list);
+                       free_resdata(rd);
+               }
+       }
+}
+
+static void gdlm_resmov_in(gd_resmov_t *rm, char *buf)
+{
+       gd_resmov_t tmp;
+
+       memcpy(&tmp, buf, sizeof(gd_resmov_t));
+
+       rm->rm_nodeid = be32_to_cpu(tmp.rm_nodeid);
+       rm->rm_length = be16_to_cpu(tmp.rm_length);
+}
+
+int resdir_rebuild_local(gd_ls_t *ls)
+{
+       gd_csb_t *csb;
+       gd_resdata_t *rd;
+       gd_rcom_t *rc;
+       gd_resmov_t mov, last_mov;
+       char *b, *last_name;
+       int error = -ENOMEM, count = 0;
+
+       log_all(ls, "rebuild resource directory");
+
+       resdir_clear(ls);
+
+       rc = allocate_rcom_buffer(ls);
+       if (!rc)
+               goto out;
+
+       last_name = (char *) kmalloc(DLM_RESNAME_MAXLEN, GFP_KERNEL);
+       if (!last_name)
+               goto free_rc;
+
+       list_for_each_entry(csb, &ls->ls_nodes, csb_list) {
+               last_mov.rm_length = 0;
+               for (;;) {
+                       error = gdlm_recovery_stopped(ls);
+                       if (error)
+                               goto free_last;
+
+                       memcpy(rc->rc_buf, last_name, last_mov.rm_length);
+                       rc->rc_datalen = last_mov.rm_length;
+
+                       error = rcom_send_message(ls, csb->csb_node->gn_nodeid,
+                                                 RECCOMM_RECOVERNAMES, rc, 1);
+                       if (error)
+                               goto free_last;
+
+                       schedule();
+
+                       /* 
+                        * pick each res out of buffer
+                        */
+
+                       b = rc->rc_buf;
+
+                       for (;;) {
+                               gdlm_resmov_in(&mov, b);
+                               b += sizeof(gd_resmov_t);
+
+                               /* Length of 0 with a non-zero nodeid marks the 
+                                * end of the list */
+                               if (!mov.rm_length && mov.rm_nodeid)
+                                       goto done;
+
+                               /* This is just the end of the block */
+                               if (!mov.rm_length)
+                                       break;
+
+                               error = -ENOMEM;
+                               rd = allocate_resdata(ls, mov.rm_length);
+                               if (!rd)
+                                       goto free_last;
+
+                               rd->rd_master_nodeid = mov.rm_nodeid;
+                               rd->rd_length = mov.rm_length;
+                               rd->rd_sequence = 1;
+
+                               memcpy(rd->rd_name, b, mov.rm_length);
+                               b += mov.rm_length;
+
+                               add_resdata_to_hash(ls, rd);
+                               count++;
+
+                               last_mov = mov;
+                               memset(last_name, 0, DLM_RESNAME_MAXLEN);
+                               memcpy(last_name, rd->rd_name, rd->rd_length);
+                       }
+               }
+             done:
+               ;
+       }
+
+       set_bit(LSFL_RESDIR_VALID, &ls->ls_flags);
+       error = 0;
+
+       log_all(ls, "rebuilt %d resources", count);
+
+      free_last:
+       kfree(last_name);
+
+      free_rc:
+       free_rcom_buffer(rc);
+
+      out:
+       return error;
+}
+
+/* 
+ * The reply end of resdir_rebuild_local/RECOVERNAMES.  Collect and send as
+ * many resource names as can fit in the buffer.
+ */
+
+int resdir_rebuild_send(gd_ls_t *ls, char *inbuf, int inlen, char *outbuf,
+                       int outlen, uint32_t nodeid)
+{
+       struct list_head *list;
+       gd_res_t *start_rsb = NULL, *rsb;
+       int offset = 0, start_namelen, error;
+       char *start_name;
+       gd_resmov_t tmp;
+       uint32_t dir_nodeid;
+
+       /* 
+        * Find the rsb where we left off (or start again)
+        */
+
+       start_namelen = inlen;
+       start_name = inbuf;
+
+       if (start_namelen > 1) {
+               error = find_or_create_rsb(ls, NULL, start_name,
+                                          start_namelen, 0, &start_rsb);
+               GDLM_ASSERT(!error && start_rsb, printk("error %d\n", error););
+               release_rsb(start_rsb);
+       }
+
+       /* 
+        * Send rsb names for rsb's we're master of and whose directory node
+        * matches the requesting node.
+        */
+
+       down_read(&ls->ls_rec_rsblist);
+       if (start_rsb)
+               list = start_rsb->res_rootlist.next;
+       else
+               list = ls->ls_rootres.next;
+
+       for (offset = 0; list != &ls->ls_rootres; list = list->next) {
+               rsb = list_entry(list, gd_res_t, res_rootlist);
+               if (rsb->res_nodeid)
+                       continue;
+
+               dir_nodeid = get_directory_nodeid(rsb);
+               if (dir_nodeid != nodeid)
+                       continue;
+
+               if (offset + sizeof(gd_resmov_t)*2 + rsb->res_length > outlen) {
+                       /* Write end-of-block record */
+                       memset(&tmp, 0, sizeof(gd_resmov_t));
+                       memcpy(outbuf + offset, &tmp, sizeof(gd_resmov_t));
+                       offset += sizeof(gd_resmov_t);
+                       goto out;
+               }
+
+               memset(&tmp, 0, sizeof(gd_resmov_t));
+               tmp.rm_nodeid = cpu_to_be32(our_nodeid());
+               tmp.rm_length = cpu_to_be16(rsb->res_length);
+
+               memcpy(outbuf + offset, &tmp, sizeof(gd_resmov_t));
+               offset += sizeof(gd_resmov_t);
+
+               memcpy(outbuf + offset, rsb->res_name, rsb->res_length);
+               offset += rsb->res_length;
+       }
+
+       /* 
+        * If we've reached the end of the list (and there's room) write a
+        * terminating record.
+        */
+
+       if ((list == &ls->ls_rootres) &&
+           (offset + sizeof(gd_resmov_t) <= outlen)) {
+
+               memset(&tmp, 0, sizeof(gd_resmov_t));
+               /* This only needs to be non-zero */
+               tmp.rm_nodeid = cpu_to_be32(1);
+               /* and this must be zero */
+               tmp.rm_length = 0;
+               memcpy(outbuf + offset, &tmp, sizeof(gd_resmov_t));
+               offset += sizeof(gd_resmov_t);
+       }
+
+ out:
+       up_read(&ls->ls_rec_rsblist);
+       return offset;
+}
+
+int get_resdata(gd_ls_t *ls, uint32_t nodeid, char *name, int namelen,
+               gd_resdata_t **rdp, int recovery)
+{
+       gd_resdata_t *rd;
+       gd_resdata_t *tmp;
+       uint32_t bucket;
+
+       bucket = rd_hash(ls, name, namelen);
+
+       read_lock(&ls->ls_resdir_hash[bucket].rb_lock);
+       rd = search_rdbucket(ls, name, namelen, bucket);
+       read_unlock(&ls->ls_resdir_hash[bucket].rb_lock);
+
+       if (rd)
+               goto out;
+
+       rd = allocate_resdata(ls, namelen);
+       if (!rd)
+               return -ENOMEM;
+
+       rd->rd_master_nodeid = nodeid;
+       rd->rd_length = namelen;
+       memcpy(rd->rd_name, name, namelen);
+
+       write_lock(&ls->ls_resdir_hash[bucket].rb_lock);
+       tmp = search_rdbucket(ls, name, namelen, bucket);
+       if (!tmp)
+               list_add_tail(&rd->rd_list,
+                             &ls->ls_resdir_hash[bucket].rb_reslist);
+       write_unlock(&ls->ls_resdir_hash[bucket].rb_lock);
+
+       if (tmp) {
+               free_resdata(rd);
+               rd = tmp;
+       }
+
+      out:
+       *rdp = rd;
+
+       if (!recovery) {
+               if (++rd->rd_sequence == 0)
+                       rd->rd_sequence++;
+       } else
+               rd->rd_sequence = 1;
+
+       return 0;
+}
+
+/* 
+ * The node with lowest id queries all nodes to determine when all are done.
+ * All other nodes query the low nodeid for this.
+ */
+
+int resdir_rebuild_wait(gd_ls_t *ls)
+{
+       int error;
+
+       if (ls->ls_low_nodeid == our_nodeid()) {
+               error = gdlm_wait_status_all(ls, RESDIR_VALID);
+               if (!error)
+                       set_bit(LSFL_ALL_RESDIR_VALID, &ls->ls_flags);
+       } else
+               error = gdlm_wait_status_low(ls, RESDIR_ALL_VALID);
+
+       return error;
+}
diff -urN linux-orig/cluster/dlm/dir.h linux-patched/cluster/dlm/dir.h
--- linux-orig/cluster/dlm/dir.h        1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/dir.h     2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,30 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __DIR_DOT_H__
+#define __DIR_DOT_H__
+
+uint32_t name_to_directory_nodeid(gd_ls_t * ls, char *name, int length);
+uint32_t get_directory_nodeid(gd_res_t * rsb);
+void remove_resdata(gd_ls_t * ls, uint32_t nodeid, char *name, int namelen,
+                   uint8_t sequence);
+int resdir_rebuild_local(gd_ls_t * ls);
+int resdir_rebuild_send(gd_ls_t * ls, char *inbuf, int inlen, char *outbuf,
+                       int outlen, uint32_t nodeid);
+int get_resdata(gd_ls_t * ls, uint32_t nodeid, char *name, int namelen,
+               gd_resdata_t ** rdp, int recovery);
+int resdir_rebuild_wait(gd_ls_t * ls);
+void resdir_clear(gd_ls_t * ls);
+void resdir_dump(gd_ls_t * ls);
+
+#endif                         /* __DIR_DOT_H__ */
diff -urN linux-orig/cluster/dlm/dlm_internal.h linux-patched/cluster/dlm/dlm_internal.h
--- linux-orig/cluster/dlm/dlm_internal.h       1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/dlm_internal.h    2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,634 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __DLM_INTERNAL_DOT_H__
+#define __DLM_INTERNAL_DOT_H__
+
+/*
+ * This is the main header file to be included in each DLM source file.
+ */
+
+#define DLM_RELEASE_NAME "<CVS>"
+
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <asm/semaphore.h>
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/vmalloc.h>
+#include <asm/uaccess.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/random.h>
+
+#include <cluster/dlm.h>
+#include <cluster/dlm_device.h>
+#include <cluster/service.h>
+
+#ifndef TRUE
+#define TRUE (1)
+#endif
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+
+#if (BITS_PER_LONG == 64)
+#define PRIu64 "lu"
+#define PRId64 "ld"
+#define PRIo64 "lo"
+#define PRIx64 "lx"
+#define PRIX64 "lX"
+#define SCNu64 "lu"
+#define SCNd64 "ld"
+#define SCNo64 "lo"
+#define SCNx64 "lx"
+#define SCNX64 "lX"
+#else
+#define PRIu64 "Lu"
+#define PRId64 "Ld"
+#define PRIo64 "Lo"
+#define PRIx64 "Lx"
+#define PRIX64 "LX"
+#define SCNu64 "Lu"
+#define SCNd64 "Ld"
+#define SCNo64 "Lo"
+#define SCNx64 "Lx"
+#define SCNX64 "LX"
+#endif
+
+#define wchan_cond_sleep_intr(chan, sleep_cond) \
+do \
+{ \
+  DECLARE_WAITQUEUE(__wait_chan, current); \
+  current->state = TASK_INTERRUPTIBLE; \
+  add_wait_queue(&chan, &__wait_chan); \
+  if ((sleep_cond)) \
+    schedule(); \
+  remove_wait_queue(&chan, &__wait_chan); \
+  current->state = TASK_RUNNING; \
+} \
+while (0)
+
+static inline int check_timeout(unsigned long stamp, unsigned int seconds)
+{
+    return time_after(jiffies, stamp + seconds * HZ);
+}
+
+
+#define log_print(fmt, args...) printk("dlm: "fmt"\n", ##args)
+
+#define log_all(ls, fmt, args...) \
+       do { \
+               printk("dlm: %s: " fmt "\n", (ls)->ls_name, ##args); \
+               dlm_debug_log(ls, fmt, ##args); \
+       } while (0)
+
+#define log_error log_all
+
+
+#define DLM_DEBUG
+#if defined(DLM_DEBUG)
+#define log_debug(ls, fmt, args...) dlm_debug_log(ls, fmt, ##args)
+#else
+#define log_debug(ls, fmt, args...)
+#endif
+
+#if defined(DLM_DEBUG) && defined(DLM_DEBUG_ALL)
+#undef log_debug
+#define log_debug log_all
+#endif
+
+
+#define GDLM_ASSERT(x, do) \
+{ \
+  if (!(x)) \
+  { \
+    dlm_debug_dump(); \
+    printk("\nDLM:  Assertion failed on line %d of file %s\n" \
+               "DLM:  assertion:  \"%s\"\n" \
+               "DLM:  time = %lu\n", \
+               __LINE__, __FILE__, #x, jiffies); \
+    {do} \
+    printk("\n"); \
+    BUG(); \
+    panic("DLM:  Record message above and reboot.\n"); \
+  } \
+}
+
+
+struct gd_ls;
+struct gd_lkb;
+struct gd_res;
+struct gd_csb;
+struct gd_node;
+struct gd_resmov;
+struct gd_resdata;
+struct gd_recover;
+struct gd_recinfo;
+struct gd_resdir_bucket;
+struct gd_remlockreply;
+struct gd_remlockrequest;
+struct gd_rcom;
+
+typedef struct gd_ls gd_ls_t;
+typedef struct gd_lkb gd_lkb_t;
+typedef struct gd_res gd_res_t;
+typedef struct gd_csb gd_csb_t;
+typedef struct gd_node gd_node_t;
+typedef struct gd_resmov gd_resmov_t;
+typedef struct gd_resdata gd_resdata_t;
+typedef struct gd_recover gd_recover_t;
+typedef struct gd_resdir_bucket gd_resdir_bucket_t;
+typedef struct gd_rcom gd_rcom_t;
+
+/*
+ * Resource Data - an entry for a resource in the resdir hash table
+ */
+
+struct gd_resdata {
+       struct list_head rd_list;
+       uint32_t rd_master_nodeid;
+       uint16_t rd_length;
+       uint8_t rd_sequence;
+       char rd_name[1];        /* <rd_length> bytes */
+};
+
+/*
+ * Resource Directory Bucket - a hash bucket of resdata entries in the resdir
+ * hash table
+ */
+
+struct gd_resdir_bucket {
+       struct list_head rb_reslist;
+       rwlock_t rb_lock;
+};
+
+/*
+ * A resource description as moved between nodes
+ */
+
+struct gd_resmov {
+       uint32_t rm_nodeid;
+       uint16_t rm_length;
+       uint16_t rm_pad;
+};
+
+/*
+ * An entry in the lock ID table.  Locks for this bucket are kept on list.
+ * Counter is used to assign an id to locks as they are added to this bucket.
+ */
+
+struct gd_lockidtbl_entry {
+       struct list_head list;
+       uint16_t counter;
+};
+
+/* Elements in the range array */
+
+#define GR_RANGE_START 0
+#define GR_RANGE_END   1
+#define RQ_RANGE_START 2
+#define RQ_RANGE_END   3
+
+/*
+ * Lockspace structure.  The context for GDLM locks.
+ */
+
+#define RESHASHTBL_SIZE     (256)
+
+#define RESDIRHASH_SHIFT    (9)
+#define RESDIRHASH_SIZE     (1 << RESDIRHASH_SHIFT)
+#define RESDIRHASH_MASK     (RESDIRHASH_SIZE - 1)
+
+#define LSFL_WORK               (0)
+#define LSFL_LS_RUN             (1)
+#define LSFL_LS_STOP            (2)
+#define LSFL_LS_START           (3)
+#define LSFL_LS_FINISH          (4)
+#define LSFL_RECCOMM_WAIT       (5)
+#define LSFL_RECCOMM_READY      (6)
+#define LSFL_NOTIMERS           (7)
+#define LSFL_FINISH_RECOVERY    (8)
+#define LSFL_RESDIR_VALID       (9)
+#define LSFL_ALL_RESDIR_VALID   (10)
+#define LSFL_NODES_VALID        (11)
+#define LSFL_ALL_NODES_VALID    (12)
+#define LSFL_REQUEST_WARN       (13)
+
+#define LSST_NONE           (0)
+#define LSST_INIT           (1)
+#define LSST_INIT_DONE      (2)
+#define LSST_CLEAR          (3)
+#define LSST_WAIT_START     (4)
+#define LSST_RECONFIG_DONE  (5)
+
+struct gd_ls {
+       struct list_head ls_list;       /* list of lockspaces */
+       uint32_t ls_local_id;   /* local unique lockspace ID */
+       uint32_t ls_global_id;  /* global unique lockspace ID */
+       int ls_allocation;      /* Memory allocation policy */
+       unsigned long ls_flags; /* LSFL_ */
+
+       struct list_head ls_rootres;    /* List of root resources */
+
+       int ls_hashsize;
+       int ls_hashmask;
+       struct list_head *ls_reshashtbl;        /* Hash table for resources */
+       rwlock_t ls_reshash_lock;       /* Lock for hash table */
+
+       struct gd_lockidtbl_entry *ls_lockidtbl;
+       uint32_t ls_lockidtbl_size;     /* Size of lock id table */
+       rwlock_t ls_lockidtbl_lock;
+
+       struct list_head ls_nodes;      /* current nodes in RC */
+       uint32_t ls_num_nodes;  /* number of nodes in RC */
+       uint32_t ls_nodes_mask;
+       uint32_t ls_low_nodeid;
+
+       int ls_state;           /* state changes for recovery */
+       struct list_head ls_recover;    /* gr_recover_t structs */
+       int ls_last_stop;       /* event ids from sm */
+       int ls_last_start;
+       int ls_last_finish;
+       spinlock_t ls_recover_lock;
+       struct list_head ls_nodes_gone; /* dead node list for recovery */
+
+       wait_queue_head_t ls_wait_general;
+
+       gd_rcom_t *ls_rcom;
+       uint32_t ls_rcom_msgid;
+       struct semaphore ls_rcom_lock;
+
+       struct list_head ls_recover_list;
+       int ls_recover_list_count;
+       spinlock_t ls_recover_list_lock;
+
+       struct rw_semaphore ls_in_recovery;     /* held in write during
+                                                * recovery, read for normal
+                                                * locking ops */
+       struct rw_semaphore ls_unlock_sem;      /* To prevent unlock on a
+                                                * parent lock racing with a
+                                                * new child lock */
+
+       struct rw_semaphore ls_rec_rsblist;     /* To prevent incoming recovery
+                                                * operations happening while
+                                                * we are purging */
+
+       struct rw_semaphore ls_gap_rsblist;     /* To protect rootres list
+                                                * in grant_after_purge() which
+                                                * runs outside recovery */
+
+       struct list_head ls_rebuild_rootrsb_list;       /* Root of lock trees
+                                                        * we are deserialising
+                                                        */
+
+       struct list_head ls_deadlockq;  /* List of locks in conversion ordered
+                                        * by duetime. for deadlock detection */
+
+       struct list_head ls_requestqueue;       /* List of incoming requests
+                                                * held while we are in
+                                                * recovery */
+
+       gd_resdir_bucket_t ls_resdir_hash[RESDIRHASH_SIZE];
+
+       int ls_namelen;
+       char ls_name[1];        /* <namelen> bytes */
+};
+
+/*
+ * Cluster node (per node in cluster)
+ */
+
+struct gd_node {
+       struct list_head gn_list;       /* global list of cluster nodes */
+       uint32_t gn_nodeid;     /* cluster unique nodeid (cman) */
+       uint32_t gn_ipaddr;     /* node's first IP address (cman) */
+       int gn_refcount;        /* number of csb's referencing */
+};
+
+/*
+ * Cluster System Block (per node in a ls)
+ */
+
+struct gd_csb {
+       struct list_head csb_list;      /* per-lockspace list of nodes */
+       gd_node_t *csb_node;    /* global node structure */
+       int csb_gone_event;     /* event id when node was removed */
+
+       uint32_t csb_names_send_count;
+       uint32_t csb_names_send_msgid;
+       uint32_t csb_names_recv_count;
+       uint32_t csb_names_recv_msgid;
+       uint32_t csb_locks_send_count;
+       uint32_t csb_locks_send_msgid;
+       uint32_t csb_locks_recv_count;
+       uint32_t csb_locks_recv_msgid;
+};
+
+/*
+ * Resource block
+ */
+
+/* status */
+
+#define GDLM_RESSTS_DIRENTRY     1     /* This is a directory entry */
+#define GDLM_RESSTS_LVBINVALID   2     /* The LVB is invalid */
+
+#define RESFL_NEW_MASTER         (0)
+#define RESFL_RECOVER_LIST       (1)
+
+struct gd_res {
+       struct list_head res_hashchain; /* Chain of resources in this hash
+                                        * bucket */
+
+       gd_ls_t *res_ls;        /* The owning lockspace */
+
+       struct list_head res_rootlist;  /* List of root resources in lockspace */
+
+       struct list_head res_subreslist;        /* List of all sub-resources
+                                                * for this root res. */
+       /* This is a list head on the root res and holds the whole tree below
+        * it. */
+       uint8_t res_depth;      /* Depth in resource tree */
+       uint16_t res_status;
+       unsigned long res_flags;        /* Flags, RESFL_ */
+
+       struct list_head res_grantqueue;
+       struct list_head res_convertqueue;
+       struct list_head res_waitqueue;
+
+       uint32_t res_nodeid;    /* nodeid of master node */
+
+       gd_res_t *res_root;     /* If a subresource, this is our root */
+       gd_res_t *res_parent;   /* Our parent resource (if any) */
+
+       atomic_t res_ref;       /* No of lkb's */
+       uint16_t res_remasterid;        /* ID used during remaster */
+       struct list_head res_recover_list;      /* General list for use during
+                                                * recovery */
+       int res_recover_msgid;
+       int res_newlkid_expect;
+
+       struct rw_semaphore res_lock;
+
+       char *res_lvbptr;       /* Lock value block */
+
+       uint8_t res_resdir_seq; /* Last directory sequence number */
+
+       uint8_t res_length;
+       char res_name[1];       /* <res_length> bytes */
+};
+
+/*
+ * Lock block. To avoid confusion, where flags mirror the
+ * public flags, they should have the same value.
+ */
+
+#define GDLM_LKSTS_NEW          (0)
+#define GDLM_LKSTS_WAITING      (1)
+#define GDLM_LKSTS_GRANTED      (2)
+#define GDLM_LKSTS_CONVERT      (3)
+
+#define GDLM_LKFLG_VALBLK       (0x00000008)
+#define GDLM_LKFLG_PERSISTENT   (0x00000080)   /* Don't unlock when process exits */
+#define GDLM_LKFLG_NODLCKWT     (0x00000100)       /* Don't do deadlock detection */
+#define GDLM_LKFLG_EXPEDITE     (0x00000400)       /* Move to head of convert queue */
+
+/* Internal flags */
+#define GDLM_LKFLG_RANGE        (0x00001000)   /* Range field is present (remote protocol only) */
+#define GDLM_LKFLG_MSTCPY       (0x00002000)
+#define GDLM_LKFLG_DELETED      (0x00004000)   /* LKB is being deleted */
+#define GDLM_LKFLG_DELAST       (0x00008000)   /* Delete after delivering AST */
+#define GDLM_LKFLG_LQRESEND     (0x00010000)   /* LKB on lockqueue must be resent */
+#define GDLM_LKFLG_DEMOTED      (0x00020000)
+#define GDLM_LKFLG_RESENT       (0x00040000)
+#define GDLM_LKFLG_NOREBUILD    (0x00080000)
+#define GDLM_LKFLG_LQCONVERT    (0x00100000)
+
+struct gd_lkb {
+       void *lkb_astaddr;
+       void *lkb_bastaddr;
+       long lkb_astparam;
+
+       uint32_t lkb_flags;
+       uint16_t lkb_status;    /* LKSTS_ granted, waiting, converting */
+       int8_t lkb_rqmode;      /* Requested lock mode */
+       int8_t lkb_grmode;      /* Granted lock mode */
+       uint8_t lkb_bastmode;   /* Requested mode returned in bast */
+       uint8_t lkb_highbast;   /* Highest mode we have sent a BAST for */
+       uint32_t lkb_retstatus; /* Status to return in lksb */
+
+       uint32_t lkb_id;        /* Our lock ID */
+       struct dlm_lksb *lkb_lksb;      /* Lock status block of caller */
+       struct list_head lkb_idtbl_list;        /* list pointer into the
+                                                * lockidtbl */
+
+       struct list_head lkb_statequeue;        /* List of locks in this state */
+
+       struct list_head lkb_ownerqueue;        /* List of locks owned by a
+                                                * process */
+
+       gd_lkb_t *lkb_parent;   /* Pointer to parent if any */
+
+       atomic_t lkb_childcnt;  /* Number of children */
+
+       struct list_head lkb_lockqueue; /* For when we are on the lock queue */
+       int lkb_lockqueue_state;
+       int lkb_lockqueue_flags;        /* As passed into lock/unlock */
+       unsigned long lkb_lockqueue_time;       /* Time we went on the lock
+                                                * queue */
+
+       gd_res_t *lkb_resource;
+
+       unsigned long lkb_duetime;      /* For deadlock detection */
+
+       uint32_t lkb_remid;     /* Remote partner */
+       uint32_t lkb_nodeid;
+
+       struct list_head lkb_astqueue;  /* For when we are on the AST queue */
+       uint32_t lkb_asts_to_deliver;
+
+       struct gd_remlockrequest *lkb_request;
+
+       struct list_head lkb_deadlockq; /* on ls_deadlockq list */
+
+       char *lkb_lvbptr;       /* Points to lksb on a local lock, allocated
+                                * LVB (if necessary) on a remote lock */
+       uint64_t *lkb_range;    /* Points to an array of 64 bit numbers that
+                                * represent the requested and granted ranges
+                                * of the lock. NULL implies 0-ffffffffffffffff
+                                */
+};
+
+/*
+ * Used to save and manage recovery state for a lockspace.
+ */
+
+struct gd_recover {
+       struct list_head gr_list;
+       uint32_t *gr_nodeids;
+       int gr_node_count;
+       int gr_event_id;
+};
+
+/*
+ * Header part of the mid-level comms system. All packets start with
+ * this header so we can identify them. The comms packet can
+ * contain many of these structs but the are split into individual
+ * work units before being passed to the lockqueue routines.
+ * below this are the structs that this is a header for
+ */
+
+struct gd_req_header {
+       uint8_t rh_cmd;         /* What we are */
+       uint8_t rh_flags;       /* maybe just a pad */
+       uint16_t rh_length;     /* Length of struct (so we can send several in
+                                * one message) */
+       uint32_t rh_lkid;       /* Lock ID tag: ie the local (requesting) lock
+                                * ID */
+       uint32_t rh_lockspace;  /* Lockspace ID */
+};
+
+/*
+ * This is the struct used in a remote lock/unlock/convert request
+ * The mid-level comms API should turn this into native byte order.
+ * Most "normal" lock operations will use these two structs for
+ * communications. Recovery operations use their own structs
+ * but still with the gd_req_header on the front.
+ */
+
+struct gd_remlockrequest {
+       struct gd_req_header rr_header;
+
+       uint32_t rr_remlkid;    /* Remote lock ID */
+       uint32_t rr_remparid;   /* Parent's remote lock ID or 0 */
+       uint32_t rr_flags;      /* Flags from lock/convert request */
+        uint64_t rr_range_start;/* Yes, these are in the right place... */
+       uint64_t rr_range_end;
+       uint32_t rr_status;     /* Status to return if this is an AST request */
+       uint8_t rr_rqmode;      /* Requested lock mode */
+       uint8_t rr_asts;        /* Whether the LKB has ASTs or not */
+       uint8_t rr_resdir_seq;  /* Directory sequence number */
+       char rr_lvb[DLM_LVB_LEN];       /* Value block */
+       char rr_name[1];        /* As long as needs be. Only used for directory
+                                * lookups. The length of this can be worked
+                                * out from the packet length */
+};
+
+/*
+ * This is the struct returned by a remote lock/unlock/convert request
+ * The mid-level comms API should turn this into native byte order.
+ */
+
+struct gd_remlockreply {
+       struct gd_req_header rl_header;
+
+       uint32_t rl_lockstate;  /* Whether request was queued/granted/waiting */
+       uint32_t rl_nodeid;     /* nodeid of lock master */
+       uint32_t rl_status;     /* Status to return to caller */
+       uint32_t rl_lkid;       /* Remote lkid */
+       uint8_t rl_resdir_seq;  /* Returned directory sequence number */
+       char rl_lvb[DLM_LVB_LEN];       /* LVB itself */
+};
+
+/*
+ * Recovery comms message
+ */
+
+struct gd_rcom {
+       struct gd_req_header rc_header; /* 32 byte aligned */
+       uint32_t rc_msgid;
+       uint16_t rc_datalen;
+       uint8_t rc_expanded;
+       uint8_t rc_subcmd;      /* secondary command */
+       char rc_buf[1];         /* first byte of data goes here and extends
+                                * beyond here for another datalen - 1 bytes.
+                                * rh_length is set to sizeof(gd_rcom_t) +
+                                * datalen - 1 */
+};
+
+
+/* A remote query: GDLM_REMCMD_QUERY */
+struct gd_remquery {
+       struct gd_req_header rq_header;
+
+       uint32_t rq_mstlkid;   /* LockID on master node */
+        uint32_t rq_query;     /* query from the user */
+        uint32_t rq_maxlocks;  /* max number of locks we can cope with */
+};
+
+/* First block of a reply query.  cmd = GDLM_REMCMD_QUERY */
+/* There may be subsequent blocks of
+   lock info in GDLM_REMCMD_QUERYCONT messages which just have
+   a normal header. The last of these will have rh_flags set to
+   GDLM_REMFLAG_ENDQUERY
+ */
+struct gd_remqueryreply {
+       struct gd_req_header rq_header;
+
+        uint32_t rq_numlocks;  /* Number of locks in reply */
+        uint32_t rq_startlock; /* Which lock this block starts at (for multiple block replies) */
+        uint32_t rq_status;
+
+        /* Resource information */
+       uint32_t rq_grantcount; /* No. of nodes on grant queue */
+       uint32_t rq_convcount;  /* No. of nodes on convert queue */
+       uint32_t rq_waitcount;  /* No. of nodes on wait queue */
+        char rq_valblk[DLM_LVB_LEN];   /* Master's LVB contents, if applicable */
+};
+
+/*
+ * Lockqueue wait lock states
+ */
+
+#define GDLM_LQSTATE_WAIT_RSB       1
+#define GDLM_LQSTATE_WAIT_CONVERT   2
+#define GDLM_LQSTATE_WAIT_CONDGRANT 3
+#define GDLM_LQSTATE_WAIT_UNLOCK    4
+
+/* Commands sent across the comms link */
+#define GDLM_REMCMD_LOOKUP          1
+#define GDLM_REMCMD_LOCKREQUEST     2
+#define GDLM_REMCMD_UNLOCKREQUEST   3
+#define GDLM_REMCMD_CONVREQUEST     4
+#define GDLM_REMCMD_LOCKREPLY       5
+#define GDLM_REMCMD_LOCKGRANT       6
+#define GDLM_REMCMD_SENDBAST        7
+#define GDLM_REMCMD_SENDCAST        8
+#define GDLM_REMCMD_REM_RESDATA     9
+#define GDLM_REMCMD_RECOVERMESSAGE  20
+#define GDLM_REMCMD_RECOVERREPLY    21
+#define GDLM_REMCMD_QUERY           30
+#define GDLM_REMCMD_QUERYREPLY      31
+
+/* Set in rh_flags when this is the last block of
+   query information. Note this could also be the first
+   block */
+#define GDLM_REMFLAG_ENDQUERY       1
+
+/*
+ * This is a both a parameter to queue_ast and also the bitmap of ASTs in
+ * lkb_asts_to_deliver
+ */
+
+typedef enum { GDLM_QUEUE_COMPAST = 1, GDLM_QUEUE_BLKAST = 2 } gd_ast_type_t;
+
+#ifndef BUG_ON
+#define BUG_ON(x)
+#endif
+
+void dlm_debug_log(gd_ls_t *ls, const char *fmt, ...);
+void dlm_debug_dump(void);
+
+#endif                         /* __DLM_INTERNAL_DOT_H__ */
diff -urN linux-orig/cluster/dlm/lkb.c linux-patched/cluster/dlm/lkb.c
--- linux-orig/cluster/dlm/lkb.c        1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/lkb.c     2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,225 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/* 
+ * lkb.c
+ *
+ * Allocate and free locks on the lock ID table.
+ *
+ * This is slightly naff but I don't really like the
+ * VMS lockidtbl stuff as it uses a realloced array
+ * to hold the locks in. I think this is slightly better
+ * in some ways.
+ *
+ * Any better suggestions gratefully received. Patrick
+ *
+ */
+
+#include "dlm_internal.h"
+#include "lockqueue.h"
+#include "lkb.h"
+#include "config.h"
+#include "rsb.h"
+#include "memory.h"
+#include "lockspace.h"
+#include "util.h"
+
+/* 
+ * Internal find lock by ID. Must be called with the lockidtbl spinlock held.
+ */
+
+static gd_lkb_t *__find_lock_by_id(gd_ls_t *ls, uint32_t lkid)
+{
+       uint16_t entry = lkid & 0xFFFF;
+       gd_lkb_t *lkb;
+
+       if (entry >= ls->ls_lockidtbl_size)
+               goto out;
+
+       list_for_each_entry(lkb, &ls->ls_lockidtbl[entry].list, lkb_idtbl_list){
+               if (lkb->lkb_id == lkid)
+                       return lkb;
+       }
+
+      out:
+       return NULL;
+}
+
+/* 
+ * Should be called at lockspace initialisation time.
+ */
+
+int init_lockidtbl(gd_ls_t *ls, int entries)
+{
+       int i;
+
+       /* Make sure it's a power of two */
+       GDLM_ASSERT(!(entries & (entries - 1)),);
+
+       ls->ls_lockidtbl_size = entries;
+       rwlock_init(&ls->ls_lockidtbl_lock);
+
+       ls->ls_lockidtbl = kmalloc(entries * sizeof(struct gd_lockidtbl_entry),
+                                  GFP_KERNEL);
+       if (!ls->ls_lockidtbl)
+               return -ENOMEM;
+
+       for (i = 0; i < entries; i++) {
+               INIT_LIST_HEAD(&ls->ls_lockidtbl[i].list);
+               ls->ls_lockidtbl[i].counter = 1;
+       }
+
+       return 0;
+}
+
+/* 
+ * Free up the space - returns an error if there are still locks hanging around
+ */
+
+int free_lockidtbl(gd_ls_t *ls)
+{
+       int i;
+
+       write_lock(&ls->ls_lockidtbl_lock);
+
+       for (i = 0; i < ls->ls_lockidtbl_size; i++) {
+               if (!list_empty(&ls->ls_lockidtbl[i].list)) {
+                       write_unlock(&ls->ls_lockidtbl_lock);
+                       return -1;
+               }
+       }
+       kfree(ls->ls_lockidtbl);
+
+       write_unlock(&ls->ls_lockidtbl_lock);
+
+       return 0;
+}
+
+/* 
+ * LKB lkid's are 32 bits and have two 16 bit parts.  The bottom 16 bits are a
+ * random number between 0 and lockidtbl_size-1.  This random number specifies
+ * the "bucket" for the lkb in lockidtbl.  The upper 16 bits are a sequentially
+ * assigned per-bucket id.
+ *
+ * Because the 16 bit id's per bucket can roll over, a new lkid must be checked
+ * against the lkid of all lkb's in the bucket to avoid duplication.
+ *
+ */
+
+gd_lkb_t *create_lkb(gd_ls_t *ls)
+{
+       gd_lkb_t *lkb;
+       uint32_t lkid;
+       uint16_t bucket;
+
+       lkb = allocate_lkb(ls);
+       if (!lkb)
+               goto out;
+
+       write_lock(&ls->ls_lockidtbl_lock);
+       do {
+               get_random_bytes(&bucket, sizeof(bucket));
+               bucket &= (ls->ls_lockidtbl_size - 1);
+               lkid = bucket | (ls->ls_lockidtbl[bucket].counter++ << 16);
+       }
+       while (__find_lock_by_id(ls, lkid));
+
+       lkb->lkb_id = (uint32_t) lkid;
+       list_add(&lkb->lkb_idtbl_list, &ls->ls_lockidtbl[bucket].list);
+       write_unlock(&ls->ls_lockidtbl_lock);
+
+      out:
+       return lkb;
+}
+
+/* 
+ * Free LKB and remove it from the lockidtbl.
+ * NB - this always frees the lkb whereas release_rsb doesn't free an
+ * rsb unless its reference count is zero.
+ */
+
+void release_lkb(gd_ls_t *ls, gd_lkb_t *lkb)
+{
+       if (lkb->lkb_status) {
+               log_error(ls, "release lkb with status %u", lkb->lkb_status);
+               print_lkb(lkb);
+               return;
+       }
+
+       if (lkb->lkb_parent)
+               atomic_dec(&lkb->lkb_parent->lkb_childcnt);
+
+       write_lock(&ls->ls_lockidtbl_lock);
+       list_del(&lkb->lkb_idtbl_list);
+       write_unlock(&ls->ls_lockidtbl_lock);
+
+       /* if this is not a master copy then lvbptr points into the user's
+        * lksb, so don't free it */
+       if (lkb->lkb_lvbptr && lkb->lkb_flags & GDLM_LKFLG_MSTCPY)
+               free_lvb(lkb->lkb_lvbptr);
+
+       if (lkb->lkb_range)
+               free_range(lkb->lkb_range);
+
+       free_lkb(lkb);
+}
+
+gd_lkb_t *find_lock_by_id(gd_ls_t *ls, uint32_t lkid)
+{
+       gd_lkb_t *lkb;
+
+       read_lock(&ls->ls_lockidtbl_lock);
+       lkb = __find_lock_by_id(ls, lkid);
+       read_unlock(&ls->ls_lockidtbl_lock);
+
+       return lkb;
+}
+
+gd_lkb_t *dlm_get_lkb(void *ls, uint32_t lkid)
+{
+        gd_ls_t *lspace = find_lockspace_by_local_id(ls);
+       return find_lock_by_id(lspace, lkid);
+}
+
+/*
+ * Initialise the range parts of an LKB.
+ */
+
+int lkb_set_range(gd_ls_t *lspace, gd_lkb_t *lkb, uint64_t start, uint64_t end)
+{
+       int ret = -ENOMEM;
+
+       /*
+        * if this wasn't already a range lock, make it one
+        */
+       if (!lkb->lkb_range) {
+               lkb->lkb_range = allocate_range(lspace);
+               if (!lkb->lkb_range)
+                       goto out;
+
+               /*
+                * This is needed for conversions that contain ranges where the
+                * original lock didn't but it's harmless for new locks too.
+                */
+               lkb->lkb_range[GR_RANGE_START] = 0LL;
+               lkb->lkb_range[GR_RANGE_END] = 0xffffffffffffffffULL;
+       }
+
+       lkb->lkb_range[RQ_RANGE_START] = start;
+       lkb->lkb_range[RQ_RANGE_END] = end;
+
+       ret = 0;
+
+      out:
+       return ret;
+}
diff -urN linux-orig/cluster/dlm/lkb.h linux-patched/cluster/dlm/lkb.h
--- linux-orig/cluster/dlm/lkb.h        1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/lkb.h     2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,27 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __LKB_DOT_H__
+#define __LKB_DOT_H__
+
+int free_lockidtbl(gd_ls_t * lspace);
+int init_lockidtbl(gd_ls_t * lspace, int entries);
+
+gd_lkb_t *find_lock_by_id(gd_ls_t *ls, uint32_t lkid);
+gd_lkb_t *create_lkb(gd_ls_t *ls);
+void release_lkb(gd_ls_t *ls, gd_lkb_t *lkb);
+gd_lkb_t *dlm_get_lkb(void *ls, uint32_t lkid);
+int verify_lkb_nodeids(gd_ls_t *ls);
+int lkb_set_range(gd_ls_t *lspace, gd_lkb_t *lkb, uint64_t start, uint64_t end);
+
+#endif                         /* __LKB_DOT_H__ */
diff -urN linux-orig/cluster/dlm/locking.c linux-patched/cluster/dlm/locking.c
--- linux-orig/cluster/dlm/locking.c    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/locking.c 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,1225 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/* 
+ * locking.c
+ *
+ * This is where the main work of the DLM goes on
+ *
+ */
+
+#include "dlm_internal.h"
+#include "lockqueue.h"
+#include "locking.h"
+#include "lockspace.h"
+#include "lkb.h"
+#include "nodes.h"
+#include "dir.h"
+#include "ast.h"
+#include "memory.h"
+#include "rsb.h"
+
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+/* 
+ * Lock compatibilty matrix - thanks Steve
+ * UN = Unlocked state. Not really a state, used as a flag
+ * PD = Padding. Used to make the matrix a nice power of two in size
+ * Other states are the same as the VMS DLM.
+ * Usage: matrix[grmode+1][rqmode+1]  (although m[rq+1][gr+1] is the same)
+ */
+
+#define modes_compat(gr, rq) \
+       __dlm_compat_matrix[(gr)->lkb_grmode + 1][(rq)->lkb_rqmode + 1]
+
+const int __dlm_compat_matrix[8][8] = {
+      /* UN NL CR CW PR PW EX PD */
+       {1, 1, 1, 1, 1, 1, 1, 0},       /* UN */
+       {1, 1, 1, 1, 1, 1, 1, 0},       /* NL */
+       {1, 1, 1, 1, 1, 1, 0, 0},       /* CR */
+       {1, 1, 1, 1, 0, 0, 0, 0},       /* CW */
+       {1, 1, 1, 0, 1, 0, 0, 0},       /* PR */
+       {1, 1, 1, 0, 0, 0, 0, 0},       /* PW */
+       {1, 1, 0, 0, 0, 0, 0, 0},       /* EX */
+       {0, 0, 0, 0, 0, 0, 0, 0}        /* PD */
+};
+
+/* 
+ * Compatibility matrix for conversions with QUECVT set.
+ * Granted mode is the row; requested mode is the column.
+ * Usage: matrix[grmode+1][rqmode+1]
+ */
+
+const int __quecvt_compat_matrix[8][8] = {
+      /* UN NL CR CW PR PW EX PD */
+       {0, 0, 0, 0, 0, 0, 0, 0},       /* UN */
+       {0, 0, 1, 1, 1, 1, 1, 0},       /* NL */
+       {0, 0, 0, 1, 1, 1, 1, 0},       /* CR */
+       {0, 0, 0, 0, 1, 1, 1, 0},       /* CW */
+       {0, 0, 0, 1, 0, 1, 1, 0},       /* PR */
+       {0, 0, 0, 0, 0, 0, 1, 0},       /* PW */
+       {0, 0, 0, 0, 0, 0, 0, 0},       /* EX */
+       {0, 0, 0, 0, 0, 0, 0, 0}        /* PD */
+};
+
+/* 
+ * This defines the direction of transfer of LVB data.
+ * Granted mode is the row; requested mode is the column.
+ * Usage: matrix[grmode+1][rqmode+1]
+ * 1 = LVB is returned to the caller
+ * 0 = LVB is written to the resource
+ * -1 = nothing happens to the LVB
+ */
+
+const int __lvb_operations[8][8] = {
+       /* UN   NL  CR  CW  PR  PW  EX  PD*/
+       {  -1,  1,  1,  1,  1,  1,  1, -1 }, /* UN */
+       {  -1,  1,  1,  1,  1,  1,  1,  0 }, /* NL */
+       {  -1, -1,  1,  1,  1,  1,  1,  0 }, /* CR */
+       {  -1, -1, -1,  1,  1,  1,  1,  0 }, /* CW */
+       {  -1, -1, -1, -1,  1,  1,  1,  0 }, /* PR */
+       {  -1,  0,  0,  0,  0,  0,  1,  0 }, /* PW */
+       {  -1,  0,  0,  0,  0,  0,  0,  0 }, /* EX */
+       {  -1,  0,  0,  0,  0,  0,  0,  0 }  /* PD */
+};
+
+static void grant_lock(gd_lkb_t * lkb, int send_remote);
+static void send_blocking_asts(gd_res_t * rsb, gd_lkb_t * lkb);
+static void send_blocking_asts_all(gd_res_t *rsb, gd_lkb_t *lkb);
+static int convert_lock(gd_ls_t * ls, int mode, struct dlm_lksb *lksb,
+                       int flags, void *ast, void *astarg, void *bast,
+                       struct dlm_range *range);
+static int dlm_lock_stage1(gd_ls_t * lspace, gd_lkb_t * lkb, int flags,
+                          char *name, int namelen);
+
+
+static inline int first_in_list(gd_lkb_t *lkb, struct list_head *head)
+{
+       gd_lkb_t *first = list_entry(head->next, gd_lkb_t, lkb_statequeue);
+
+       if (lkb->lkb_id == first->lkb_id)
+               return 1;
+
+       return 0;
+}
+
+/* 
+ * Return 1 if the locks' ranges overlap
+ * If the lkb has no range then it is assumed to cover 0-ffffffff.ffffffff
+ */
+
+static inline int ranges_overlap(gd_lkb_t *lkb1, gd_lkb_t *lkb2)
+{
+       if (!lkb1->lkb_range || !lkb2->lkb_range)
+               return 1;
+
+       if (lkb1->lkb_range[RQ_RANGE_END] < lkb2->lkb_range[GR_RANGE_START] ||
+           lkb1->lkb_range[RQ_RANGE_START] > lkb2->lkb_range[GR_RANGE_END])
+               return 0;
+
+       return 1;
+}
+
+/*
+ * Resolve conversion deadlock by changing to NL the granted mode of deadlocked
+ * locks on the convert queue.  One of the deadlocked locks is allowed to
+ * retain its original granted state (we choose the lkb provided although it
+ * shouldn't matter which.)  We do not change the granted mode on locks without
+ * the CONVDEADLK flag.  If any of these exist (there shouldn't if the app uses
+ * the flag consistently) the false return value is used.
+ */
+
+static int conversion_deadlock_resolve(gd_res_t *rsb, gd_lkb_t *lkb)
+{
+       gd_lkb_t *this;
+       int rv = TRUE;
+
+       list_for_each_entry(this, &rsb->res_convertqueue, lkb_statequeue) {
+               if (this == lkb)
+                       continue;
+
+               if (!ranges_overlap(lkb, this))
+                       continue;
+
+               if (!modes_compat(this, lkb) && !modes_compat(lkb, this)) {
+
+                       if (!(this->lkb_lockqueue_flags & DLM_LKF_CONVDEADLK)){
+                               rv = FALSE;
+                               continue;
+                       }
+                       this->lkb_grmode = DLM_LOCK_NL;
+                       this->lkb_flags |= GDLM_LKFLG_DEMOTED;
+               }
+       }
+       return rv;
+}
+
+/*
+ * "A conversion deadlock arises with a pair of lock requests in the converting
+ * queue for one resource.  The granted mode of each lock blocks the requested
+ * mode of the other lock."
+ */
+
+static int conversion_deadlock_detect(gd_res_t *rsb, gd_lkb_t *lkb)
+{
+       gd_lkb_t *this;
+
+       list_for_each_entry(this, &rsb->res_convertqueue, lkb_statequeue) {
+               if (this == lkb)
+                       continue;
+
+               if (!ranges_overlap(lkb, this))
+                       continue;
+
+               if (!modes_compat(this, lkb) && !modes_compat(lkb, this))
+                       return TRUE;
+       }
+       return FALSE;
+}
+
+/*
+ * Check if the given lkb conflicts with another lkb on the queue.
+ */
+
+static int queue_conflict(struct list_head *head, gd_lkb_t *lkb)
+{
+       gd_lkb_t *this;
+
+       list_for_each_entry(this, head, lkb_statequeue) {
+               if (this == lkb)
+                       continue;
+               if (ranges_overlap(lkb, this) && !modes_compat(this, lkb))
+                       return TRUE;
+       }
+       return FALSE;
+}
+
+/*
+ * Deadlock can arise when using the QUECVT flag if the requested mode of the
+ * first converting lock is incompatible with the granted mode of another
+ * converting lock further down the queue.  To prevent this deadlock, a
+ * requested QUEUECVT lock is granted immediately if adding it to the end of
+ * the queue would prevent a lock ahead of it from being granted.
+ */
+
+static int queuecvt_deadlock_detect(gd_res_t *rsb, gd_lkb_t *lkb)
+{
+       gd_lkb_t *this;
+
+       list_for_each_entry(this, &rsb->res_convertqueue, lkb_statequeue) {
+               if (this == lkb)
+                       break;
+
+               if (ranges_overlap(lkb, this) && !modes_compat(lkb, this))
+                       return TRUE;
+       }
+       return FALSE;
+}
+
+/* 
+ * Return 1 if the lock can be granted, 0 otherwise.
+ * Also detect and resolve conversion deadlocks.
+ */
+
+static int can_be_granted(gd_res_t *rsb, gd_lkb_t *lkb)
+{
+       if (lkb->lkb_rqmode == DLM_LOCK_NL)
+               return TRUE;
+
+       if (lkb->lkb_rqmode == lkb->lkb_grmode)
+               return TRUE;
+
+       if (queue_conflict(&rsb->res_grantqueue, lkb))
+               return FALSE;
+
+       if (!queue_conflict(&rsb->res_convertqueue, lkb)) {
+               if (!(lkb->lkb_lockqueue_flags & DLM_LKF_QUECVT))
+                       return TRUE;
+
+               if (list_empty(&rsb->res_convertqueue) ||
+                   first_in_list(lkb, &rsb->res_convertqueue) ||
+                   queuecvt_deadlock_detect(rsb, lkb))
+                       return TRUE;
+               else
+                       return FALSE;
+       }
+
+       /* there *is* a conflict between this lkb and a converting lock so
+          we return false unless conversion deadlock resolution is permitted
+          (only conversion requests will have the CONVDEADLK flag set) */
+
+       if (!(lkb->lkb_lockqueue_flags & DLM_LKF_CONVDEADLK))
+               return FALSE;
+
+       if (!conversion_deadlock_detect(rsb, lkb))
+               return FALSE;
+
+       if (conversion_deadlock_resolve(rsb, lkb))
+               return TRUE;
+
+       return FALSE;
+}
+
+int dlm_lock(void *lockspace,
+            uint32_t mode,
+            struct dlm_lksb *lksb,
+            uint32_t flags,
+            void *name,
+            unsigned int namelen,
+            uint32_t parent,
+            void (*ast) (void *astarg),
+            void *astarg,
+            void (*bast) (void *astarg, int mode),
+            struct dlm_range *range)
+{
+       gd_ls_t *lspace;
+       gd_lkb_t *lkb = NULL, *parent_lkb = NULL;
+       int ret = -EINVAL;
+
+       lspace = find_lockspace_by_local_id(lockspace);
+       if (!lspace)
+               goto out;
+
+       if (mode < 0 || mode > DLM_LOCK_EX)
+               goto out;
+
+       if (namelen > DLM_RESNAME_MAXLEN)
+               goto out;
+
+       if (flags & DLM_LKF_CANCEL)
+               goto out;
+
+       if (flags & DLM_LKF_QUECVT && !(flags & DLM_LKF_CONVERT))
+               goto out;
+
+       if (flags & DLM_LKF_EXPEDITE && !(flags & DLM_LKF_CONVERT))
+               goto out;
+
+       if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_QUECVT)
+               goto out;
+
+       if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_NOQUEUE)
+               goto out;
+
+       if (!ast || !lksb)
+               goto out;
+
+       if (!lksb->sb_lvbptr && (flags & DLM_LKF_VALBLK))
+               goto out;
+
+       if ((flags & DLM_LKF_VALBLK) && !lksb->sb_lvbptr)
+               goto out;
+
+       /* 
+        * Take conversion path.
+        */
+
+       if (flags & DLM_LKF_CONVERT) {
+               ret = convert_lock(lspace, mode, lksb, flags, ast, astarg,
+                                  bast, range);
+               goto out;
+       }
+
+       /* 
+        * Take new lock path.
+        */
+
+       if (parent) {
+               down_read(&lspace->ls_unlock_sem);
+
+               parent_lkb = find_lock_by_id(lspace, parent);
+
+               if (!parent_lkb ||
+                   parent_lkb->lkb_flags & GDLM_LKFLG_DELETED ||
+                   parent_lkb->lkb_flags & GDLM_LKFLG_MSTCPY ||
+                   parent_lkb->lkb_status != GDLM_LKSTS_GRANTED) {
+                       up_read(&lspace->ls_unlock_sem);
+                       goto out;
+               }
+
+               atomic_inc(&parent_lkb->lkb_childcnt);
+               up_read(&lspace->ls_unlock_sem);
+       }
+
+       down_read(&lspace->ls_in_recovery);
+
+       ret = -ENOMEM;
+
+       lkb = create_lkb(lspace);
+       if (!lkb)
+               goto fail_dec;
+       lkb->lkb_astaddr = ast;
+       lkb->lkb_astparam = (long) astarg;
+       lkb->lkb_bastaddr = bast;
+       lkb->lkb_rqmode = mode;
+       lkb->lkb_grmode = DLM_LOCK_IV;
+       lkb->lkb_lksb = lksb;
+       lkb->lkb_parent = parent_lkb;
+       lkb->lkb_lockqueue_flags = flags;
+       lkb->lkb_lvbptr = lksb->sb_lvbptr;
+
+       /* Copy the range if appropriate */
+       if (range) {
+               if (range->ra_start > range->ra_end) {
+                       ret = -EINVAL;
+                       goto fail_free;
+               }
+
+               if (lkb_set_range(lspace, lkb, range->ra_start, range->ra_end))
+                       goto fail_free;
+       }
+
+       /* Convert relevant flags to internal numbers */
+       if (flags & DLM_LKF_VALBLK)
+               lkb->lkb_flags |= GDLM_LKFLG_VALBLK;
+       if (flags & DLM_LKF_PERSISTENT)
+               lkb->lkb_flags |= GDLM_LKFLG_PERSISTENT;
+       if (flags & DLM_LKF_NODLCKWT)
+               lkb->lkb_flags |= GDLM_LKFLG_NODLCKWT;
+
+       lksb->sb_lkid = lkb->lkb_id;
+
+       ret = dlm_lock_stage1(lspace, lkb, flags, name, namelen);
+       if (ret)
+               goto fail_free;
+
+       up_read(&lspace->ls_in_recovery);
+
+       wake_astd();
+
+       return 0;
+
+      fail_free:
+       release_lkb(lspace, lkb);
+       goto fail_unlock;
+
+      fail_dec:
+       if (parent_lkb)
+               atomic_dec(&parent_lkb->lkb_childcnt);
+
+      fail_unlock:
+       up_read(&lspace->ls_in_recovery);
+
+      out:
+       return ret;
+}
+
+int dlm_lock_stage1(gd_ls_t *ls, gd_lkb_t *lkb, int flags, char *name,
+                   int namelen)
+{
+       gd_res_t *rsb, *parent_rsb = NULL;
+       gd_lkb_t *parent_lkb = lkb->lkb_parent;
+       gd_resdata_t *rd;
+       uint32_t nodeid;
+       int error;
+
+       if (parent_lkb)
+               parent_rsb = parent_lkb->lkb_resource;
+
+       error = find_or_create_rsb(ls, parent_rsb, name, namelen, 1, &rsb);
+       if (error)
+               goto out;
+
+       lkb->lkb_resource = rsb;
+       lkb->lkb_nodeid = rsb->res_nodeid;
+
+       /* 
+        * Next stage, do we need to find the master or can
+        * we get on with the real locking work ?
+        */
+
+       if (rsb->res_nodeid == -1) {
+               if (get_directory_nodeid(rsb) != our_nodeid()) {
+                       error = remote_stage(lkb, GDLM_LQSTATE_WAIT_RSB);
+                       goto out;
+               }
+
+               error = get_resdata(ls, our_nodeid(), rsb->res_name,
+                                   rsb->res_length, &rd, 0);
+               if (error)
+                       goto out;
+
+               nodeid = rd->rd_master_nodeid;
+               if (nodeid == our_nodeid())
+                       nodeid = 0;
+               rsb->res_nodeid = nodeid;
+               lkb->lkb_nodeid = nodeid;
+               rsb->res_resdir_seq = rd->rd_sequence;
+       }
+
+       error = dlm_lock_stage2(ls, lkb, rsb, flags);
+
+      out:
+       if (error)
+               release_rsb(rsb);
+
+       return error;
+}
+
+/* 
+ * Locking routine called after we have an RSB, either a copy of a remote one
+ * or a local one, or perhaps a shiny new one all of our very own
+ */
+
+int dlm_lock_stage2(gd_ls_t *ls, gd_lkb_t *lkb, gd_res_t *rsb, int flags)
+{
+       int error = 0;
+
+       if (rsb->res_nodeid) {
+               res_lkb_enqueue(rsb, lkb, GDLM_LKSTS_WAITING);
+               error = remote_stage(lkb, GDLM_LQSTATE_WAIT_CONDGRANT);
+       } else {
+               dlm_lock_stage3(lkb);
+       }
+
+       return error;
+}
+
+/* 
+ * Called on an RSB's master node to do stage2 locking for a remote lock
+ * request.  Returns a proper lkb with rsb ready for lock processing.
+ * This is analagous to sections of dlm_lock() and dlm_lock_stage1().
+ */
+
+gd_lkb_t *remote_stage2(int remote_nodeid, gd_ls_t *ls,
+                       struct gd_remlockrequest *freq)
+{
+       gd_res_t *rsb = NULL, *parent_rsb = NULL;
+       gd_lkb_t *lkb = NULL, *parent_lkb = NULL;
+       int error, namelen;
+
+       if (freq->rr_remparid) {
+               parent_lkb = find_lock_by_id(ls, freq->rr_remparid);
+               if (!parent_lkb)
+                       goto fail;
+
+               atomic_inc(&parent_lkb->lkb_childcnt);
+               parent_rsb = parent_lkb->lkb_resource;
+       }
+
+       /* 
+        * A new MSTCPY lkb.  Initialize lkb fields including the real lkid and
+        * node actually holding the (non-MSTCPY) lkb.  AST address are just
+        * flags in the master copy.
+        */
+
+       lkb = create_lkb(ls);
+       if (!lkb)
+               goto fail_dec;
+       lkb->lkb_grmode = DLM_LOCK_IV;
+       lkb->lkb_rqmode = freq->rr_rqmode;
+       lkb->lkb_parent = parent_lkb;
+       lkb->lkb_astaddr = (void *) (long) (freq->rr_asts & GDLM_QUEUE_COMPAST);
+       lkb->lkb_bastaddr = (void *) (long) (freq->rr_asts & GDLM_QUEUE_BLKAST);
+       lkb->lkb_nodeid = remote_nodeid;
+       lkb->lkb_remid = freq->rr_header.rh_lkid;
+       lkb->lkb_flags = GDLM_LKFLG_MSTCPY;
+       lkb->lkb_lockqueue_flags = freq->rr_flags;
+
+       if (lkb->lkb_lockqueue_flags & DLM_LKF_VALBLK) {
+               lkb->lkb_flags |= GDLM_LKFLG_VALBLK;
+               allocate_and_copy_lvb(ls, &lkb->lkb_lvbptr, freq->rr_lvb);
+               if (!lkb->lkb_lvbptr)
+                       goto fail_free;
+       }
+
+       if (lkb->lkb_lockqueue_flags & GDLM_LKFLG_RANGE) {
+               error = lkb_set_range(ls, lkb, freq->rr_range_start,
+                                     freq->rr_range_end);
+               if (error)
+                       goto fail_free;
+       }
+
+       /* 
+        * Get the RSB which this lock is for.  Create a new RSB if this is a
+        * new lock on a new resource.  We must be the master of any new rsb.
+        */
+
+       namelen = freq->rr_header.rh_length - sizeof(*freq) + 1;
+
+       error = find_or_create_rsb(ls, parent_rsb, freq->rr_name, namelen, 1,
+                                  &rsb);
+       if (error)
+               goto fail_free;
+
+       lkb->lkb_resource = rsb;
+       if (rsb->res_nodeid == -1)
+               rsb->res_nodeid = 0;
+       if (freq->rr_resdir_seq)
+               rsb->res_resdir_seq = freq->rr_resdir_seq;
+
+       return lkb;
+
+
+      fail_free:
+       /* release_lkb handles parent */
+       release_lkb(ls, lkb);
+       parent_lkb = NULL;
+
+      fail_dec:
+       if (parent_lkb)
+               atomic_dec(&parent_lkb->lkb_childcnt);
+      fail:
+       return NULL;
+}
+
+/* 
+ * The final bit of lock request processing on the master node.  Here the lock
+ * is granted and the completion ast is queued, or the lock is put on the
+ * waitqueue and blocking asts are sent.
+ */
+
+void dlm_lock_stage3(gd_lkb_t *lkb)
+{
+       gd_res_t *rsb = lkb->lkb_resource;
+
+       /* 
+        * This is a locally mastered lock on a resource that already exists,
+        * see if it can be  granted or if it must wait.  When this function is
+        * called for a remote lock request (process_cluster_request,
+        * REMCMD_LOCKREQUEST), the result from grant_lock is returned to the
+        * requesting node at the end of process_cluster_request, not at the
+        * end of grant_lock.
+        */
+
+       down_write(&rsb->res_lock);
+
+       if (can_be_granted(rsb, lkb)) {
+               grant_lock(lkb, 0);
+               goto out;
+       }
+
+       /* 
+        * This request is not a conversion, so the lkb didn't exist other than
+        * for this request and should be freed after EAGAIN is returned in the
+        * ast.
+        */
+
+       if (lkb->lkb_lockqueue_flags & DLM_LKF_NOQUEUE) {
+               lkb->lkb_flags |= GDLM_LKFLG_DELAST;
+               lkb->lkb_retstatus = -EAGAIN;
+               queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+               if (lkb->lkb_lockqueue_flags & DLM_LKF_NOQUEUEBAST)
+                       send_blocking_asts_all(rsb, lkb);
+               goto out;
+       }
+
+       /* 
+        * The requested lkb must wait.  Because the rsb of the requested lkb
+        * is mastered here, send blocking asts for the lkb's blocking the
+        * request.
+        */
+
+       lkb->lkb_retstatus = 0;
+       lkb_enqueue(rsb, lkb, GDLM_LKSTS_WAITING);
+
+       send_blocking_asts(rsb, lkb);
+
+      out:
+       up_write(&rsb->res_lock);
+}
+
+int dlm_unlock(void *lockspace,
+              uint32_t lkid,
+              uint32_t flags,
+              struct dlm_lksb *lksb,
+              void *astarg)
+{
+       gd_ls_t *ls = find_lockspace_by_local_id(lockspace);
+       gd_lkb_t *lkb;
+       gd_res_t *rsb;
+       int ret = -EINVAL;
+
+       if (!ls)
+               goto out;
+
+       lkb = find_lock_by_id(ls, lkid);
+       if (!lkb)
+               goto out;
+
+       /* Can't dequeue a master copy (a remote node's mastered lock) */
+       if (lkb->lkb_flags & GDLM_LKFLG_MSTCPY)
+               goto out;
+
+       /* Already waiting for a remote lock operation */
+       if (lkb->lkb_lockqueue_state) {
+               ret = -EBUSY;
+               goto out;
+       }
+
+       /* Can only cancel WAITING or CONVERTing locks.
+        * This is just a quick check - it is also checked in unlock_stage2()
+        * (which may be on the master) under the semaphore.
+        */
+       if ((flags & DLM_LKF_CANCEL) &&
+           (lkb->lkb_status == GDLM_LKSTS_GRANTED))
+               goto out;
+
+       /* "Normal" unlocks must operate on a granted lock */
+       if (!(flags & DLM_LKF_CANCEL) &&
+           (lkb->lkb_status != GDLM_LKSTS_GRANTED))
+               goto out;
+
+       down_write(&ls->ls_unlock_sem);
+
+       /* Can't dequeue a lock with sublocks */
+       if (atomic_read(&lkb->lkb_childcnt)) {
+               up_write(&ls->ls_unlock_sem);
+               ret = -ENOTEMPTY;
+               goto out;
+       }
+
+       /* Mark it as deleted so we can't use it as a parent in dlm_lock() */
+       if (!(flags & DLM_LKF_CANCEL))
+               lkb->lkb_flags |= GDLM_LKFLG_DELETED;
+       up_write(&ls->ls_unlock_sem);
+
+       /* Save any new params */
+       if (lksb)
+               lkb->lkb_lksb = lksb;
+       if (astarg)
+               lkb->lkb_astparam = (long) astarg;
+
+       lkb->lkb_lockqueue_flags = flags;
+
+       rsb = lkb->lkb_resource;
+
+       down_read(&ls->ls_in_recovery);
+
+       if (rsb->res_nodeid)
+               ret = remote_stage(lkb, GDLM_LQSTATE_WAIT_UNLOCK);
+       else
+               ret = dlm_unlock_stage2(lkb, flags);
+
+       up_read(&ls->ls_in_recovery);
+
+       wake_astd();
+
+      out:
+       return ret;
+}
+
+int dlm_unlock_stage2(gd_lkb_t *lkb, uint32_t flags)
+{
+       gd_res_t *rsb = lkb->lkb_resource;
+       int old_status;
+       int remote = lkb->lkb_flags & GDLM_LKFLG_MSTCPY;
+
+       down_write(&rsb->res_lock);
+
+       /* Can only cancel WAITING or CONVERTing locks */
+       if ((flags & DLM_LKF_CANCEL) &&
+           (lkb->lkb_status == GDLM_LKSTS_GRANTED)) {
+               lkb->lkb_retstatus = -EINVAL;
+               queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+               goto out;
+       }
+
+       old_status = lkb_dequeue(lkb);
+
+       /* 
+        * If was granted grant any converting or waiting locks.
+        */
+
+       if (old_status == GDLM_LKSTS_GRANTED)
+               grant_pending_locks(rsb);
+
+       /* 
+        * Cancelling a conversion
+        */
+
+       if ((old_status == GDLM_LKSTS_CONVERT) && (flags & DLM_LKF_CANCEL)) {
+               /* VMS semantics say we should send blocking ASTs again here */
+               send_blocking_asts(rsb, lkb);
+
+               /* Remove from deadlock detection */
+               if (lkb->lkb_duetime)
+                       remove_from_deadlockqueue(lkb);
+
+               /* Stick it back on the granted queue */
+               lkb_enqueue(rsb, lkb, GDLM_LKSTS_GRANTED);
+               lkb->lkb_rqmode = lkb->lkb_grmode;
+
+               /* Was it blocking any other locks? */
+               if (first_in_list(lkb, &rsb->res_convertqueue))
+                       grant_pending_locks(rsb);
+
+               lkb->lkb_retstatus = -DLM_ECANCEL;
+               queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+               goto out;
+       }
+
+       /* 
+        * The lvb can be saved or cleared on unlock.
+        */
+
+       if (rsb->res_lvbptr && (lkb->lkb_grmode >= DLM_LOCK_PW)) {
+               if ((flags & DLM_LKF_VALBLK) && lkb->lkb_lvbptr)
+                       memcpy(rsb->res_lvbptr, lkb->lkb_lvbptr, DLM_LVB_LEN);
+               if (flags & DLM_LKF_IVVALBLK)
+                       memset(rsb->res_lvbptr, 0, DLM_LVB_LEN);
+       }
+
+       lkb->lkb_flags |= GDLM_LKFLG_DELAST;
+       lkb->lkb_retstatus =
+           (flags & DLM_LKF_CANCEL) ? -DLM_ECANCEL : -DLM_EUNLOCK;
+       queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+
+       /* 
+        * Only free the LKB if we are the master copy.  Otherwise the AST
+        * delivery routine will free it after delivery.  queue_ast for MSTCPY
+        * lkb just sends a message.
+        */
+
+       if (remote) {
+               up_write(&rsb->res_lock);
+               release_lkb(rsb->res_ls, lkb);
+               release_rsb(rsb);
+               goto out2;
+       }
+
+      out:
+       up_write(&rsb->res_lock);
+      out2:
+       wake_astd();
+       return 0;
+}
+
+/* 
+ * Lock conversion
+ */
+
+static int convert_lock(gd_ls_t *ls, int mode, struct dlm_lksb *lksb,
+                       int flags, void *ast, void *astarg, void *bast,
+                       struct dlm_range *range)
+{
+       gd_lkb_t *lkb;
+       gd_res_t *rsb;
+       int ret = -EINVAL;
+
+       lkb = find_lock_by_id(ls, lksb->sb_lkid);
+       if (!lkb) {
+               goto out;
+       }
+
+       if (lkb->lkb_status != GDLM_LKSTS_GRANTED) {
+               ret = -EBUSY;
+               goto out;
+       }
+
+       if (lkb->lkb_flags & GDLM_LKFLG_MSTCPY) {
+               goto out;
+       }
+
+       if ((flags & DLM_LKF_QUECVT) &&
+           !__quecvt_compat_matrix[lkb->lkb_grmode + 1][mode + 1]) {
+               goto out;
+       }
+
+       if (!lksb->sb_lvbptr && (flags & DLM_LKF_VALBLK)) {
+               goto out;
+       }
+
+       if ((flags & DLM_LKF_VALBLK) && !lksb->sb_lvbptr) {
+               goto out;
+       }
+
+       /* Set up the ranges as appropriate */
+       if (range) {
+               if (range->ra_start > range->ra_end)
+                       goto out;
+
+               if (lkb_set_range(ls, lkb, range->ra_start, range->ra_end)) {
+                       ret = -ENOMEM;
+                       goto out;
+               }
+       }
+
+       rsb = lkb->lkb_resource;
+       down_read(&rsb->res_ls->ls_in_recovery);
+
+       lkb->lkb_flags &= ~GDLM_LKFLG_VALBLK;
+       lkb->lkb_flags &= ~GDLM_LKFLG_DEMOTED;
+
+       if (flags & DLM_LKF_NODLCKWT)
+               lkb->lkb_flags |= GDLM_LKFLG_NODLCKWT;
+       if (ast)
+               lkb->lkb_astaddr = ast;
+       if (astarg)
+               lkb->lkb_astparam = (long) astarg;
+       if (bast)
+               lkb->lkb_bastaddr = bast;
+       lkb->lkb_rqmode = mode;
+       lkb->lkb_lockqueue_flags = flags;
+       lkb->lkb_flags |= (flags & DLM_LKF_VALBLK) ? GDLM_LKFLG_VALBLK : 0;
+       lkb->lkb_lvbptr = lksb->sb_lvbptr;
+
+       if (rsb->res_nodeid) {
+               res_lkb_swqueue(rsb, lkb, GDLM_LKSTS_CONVERT);
+               ret = remote_stage(lkb, GDLM_LQSTATE_WAIT_CONVERT);
+       } else {
+               ret = dlm_convert_stage2(lkb, FALSE);
+       }
+
+       up_read(&rsb->res_ls->ls_in_recovery);
+
+       wake_astd();
+
+      out:
+       return ret;
+}
+
+/* 
+ * For local conversion requests on locally mastered locks this is called
+ * directly from dlm_lock/convert_lock.  This function is also called for
+ * remote conversion requests of MSTCPY locks (from process_cluster_request).
+ */
+
+int dlm_convert_stage2(gd_lkb_t *lkb, int do_ast)
+{
+       gd_res_t *rsb = lkb->lkb_resource;
+       int ret = 0;
+
+       down_write(&rsb->res_lock);
+
+       if (can_be_granted(rsb, lkb)) {
+               grant_lock(lkb, 0);
+               grant_pending_locks(rsb);
+               goto out;
+       }
+
+       /* 
+        * Remove lkb from granted queue.
+        */
+
+       lkb_dequeue(lkb);
+
+       /* 
+        * The user won't wait so stick it back on the grant queue
+        */
+
+       if (lkb->lkb_lockqueue_flags & DLM_LKF_NOQUEUE) {
+               lkb_enqueue(rsb, lkb, GDLM_LKSTS_GRANTED);
+               ret = lkb->lkb_retstatus = -EAGAIN;
+               if (do_ast)
+                       queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+               if (lkb->lkb_lockqueue_flags & DLM_LKF_NOQUEUEBAST)
+                       send_blocking_asts_all(rsb, lkb);
+               goto out;
+       }
+
+       /* 
+        * The lkb's status tells which queue it's on.  Put back on convert
+        * queue.  (QUECVT requests added at end of the queue, all others in
+        * order.)
+        */
+
+       lkb->lkb_retstatus = 0;
+       lkb_enqueue(rsb, lkb, GDLM_LKSTS_CONVERT);
+
+       /* 
+        * If the request can't be granted
+        */
+
+       send_blocking_asts(rsb, lkb);
+
+       if (!(lkb->lkb_flags & GDLM_LKFLG_NODLCKWT))
+               add_to_deadlockqueue(lkb);
+
+      out:
+       up_write(&rsb->res_lock);
+       return ret;
+}
+
+/* 
+ * Remove lkb from any queue it's on, add it to the granted queue, and queue a
+ * completion ast.  rsb res_lock must be held in write when this is called.
+ */
+
+static void grant_lock(gd_lkb_t *lkb, int send_remote)
+{
+       gd_res_t *rsb = lkb->lkb_resource;
+
+       if (lkb->lkb_duetime)
+               remove_from_deadlockqueue(lkb);
+
+       if (lkb->lkb_flags & GDLM_LKFLG_VALBLK) {
+               int b;
+               GDLM_ASSERT(lkb->lkb_lvbptr,);
+
+               if (!rsb->res_lvbptr)
+                       rsb->res_lvbptr = allocate_lvb(rsb->res_ls);
+
+               b = __lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
+               if (b)
+                       memcpy(lkb->lkb_lvbptr, rsb->res_lvbptr, DLM_LVB_LEN);
+               else
+                       memcpy(rsb->res_lvbptr, lkb->lkb_lvbptr, DLM_LVB_LEN);
+       }
+
+       if (lkb->lkb_range) {
+               lkb->lkb_range[GR_RANGE_START] = lkb->lkb_range[RQ_RANGE_START];
+               lkb->lkb_range[GR_RANGE_END] = lkb->lkb_range[RQ_RANGE_END];
+       }
+
+       lkb->lkb_grmode = lkb->lkb_rqmode;
+       lkb->lkb_rqmode = DLM_LOCK_IV;
+       lkb_swqueue(rsb, lkb, GDLM_LKSTS_GRANTED);
+
+       lkb->lkb_highbast = 0;
+       lkb->lkb_retstatus = 0;
+       queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+
+       /* 
+        * A remote conversion request has been granted, either immediately
+        * upon being requested or after waiting a bit.  In the former case,
+        * reply_and_grant() is called.  In the later case send_remote is 1 and
+        * remote_grant() is called.
+        *
+        * The "send_remote" flag is set only for locks which are granted "out
+        * of band" - ie by another lock being converted or unlocked.
+        *
+        * The second case occurs when this lkb is granted right away as part
+        * of processing the initial request.  In that case, we send a single
+        * message in reply_and_grant which combines the request reply with the
+        * grant message.
+        */
+
+       if ((lkb->lkb_flags & GDLM_LKFLG_MSTCPY) && lkb->lkb_nodeid) {
+               if (send_remote)
+                       remote_grant(lkb);
+               else if (lkb->lkb_request)
+                       reply_and_grant(lkb);
+       }
+
+}
+
+static void send_bast_queue(struct list_head *head, gd_lkb_t *lkb)
+{
+       gd_lkb_t *gr;
+
+       list_for_each_entry(gr, head, lkb_statequeue) {
+               if (gr->lkb_bastaddr &&
+                   gr->lkb_highbast < lkb->lkb_rqmode &&
+                   ranges_overlap(lkb, gr) && !modes_compat(gr, lkb)) {
+                       queue_ast(gr, GDLM_QUEUE_BLKAST, lkb->lkb_rqmode);
+                       gr->lkb_highbast = lkb->lkb_rqmode;
+               }
+       }
+}
+
+/* 
+ * Notify granted locks if they are blocking a newly forced-to-wait lock.
+ */
+
+static void send_blocking_asts(gd_res_t *rsb, gd_lkb_t *lkb)
+{
+       send_bast_queue(&rsb->res_grantqueue, lkb);
+       /* check if the following improves performance */
+       /* send_bast_queue(&rsb->res_convertqueue, lkb); */
+}
+
+static void send_blocking_asts_all(gd_res_t *rsb, gd_lkb_t *lkb)
+{
+       send_bast_queue(&rsb->res_grantqueue, lkb);
+       send_bast_queue(&rsb->res_convertqueue, lkb);
+}
+
+/* 
+ * Called when a lock has been dequeued. Look for any locks to grant that are
+ * waiting for conversion or waiting to be granted.
+ * The rsb res_lock must be held in write when this function is called.
+ */
+
+int grant_pending_locks(gd_res_t *rsb)
+{
+       gd_lkb_t *lkb;
+       struct list_head *list;
+       struct list_head *temp;
+       int8_t high = DLM_LOCK_IV;
+
+       list_for_each_safe(list, temp, &rsb->res_convertqueue) {
+               lkb = list_entry(list, gd_lkb_t, lkb_statequeue);
+
+               if (can_be_granted(rsb, lkb))
+                       grant_lock(lkb, 1);
+               else
+                       high = MAX(lkb->lkb_rqmode, high);
+       }
+
+       list_for_each_safe(list, temp, &rsb->res_waitqueue) {
+               lkb = list_entry(list, gd_lkb_t, lkb_statequeue);
+
+               if (can_be_granted(rsb, lkb))
+                       grant_lock(lkb, 1);
+               else
+                       high = MAX(lkb->lkb_rqmode, high);
+       }
+
+       /* 
+        * If there are locks left on the wait/convert queue then send blocking
+        * ASTs to granted locks that are blocking
+        *
+        * FIXME: This might generate some spurious blocking ASTs for range
+        * locks.
+        */
+
+       if (high > DLM_LOCK_IV) {
+               list_for_each_safe(list, temp, &rsb->res_grantqueue) {
+                       lkb = list_entry(list, gd_lkb_t, lkb_statequeue);
+
+                       if (lkb->lkb_bastaddr &&
+                           (lkb->lkb_highbast < high) &&
+                           !__dlm_compat_matrix[lkb->lkb_grmode+1][high+1]) {
+
+                               queue_ast(lkb, GDLM_QUEUE_BLKAST, high);
+                               lkb->lkb_highbast = high;
+                       }
+               }
+       }
+
+       return 0;
+}
+
+/* 
+ * Called to cancel a locking operation that failed due to some internal
+ * reason.
+ *
+ * Waiting locks will be removed, converting locks will be reverted to their
+ * granted status, unlocks will be left where they are.
+ *
+ * A completion AST will be delivered to the caller.
+ */
+
+int cancel_lockop(gd_lkb_t *lkb, int status)
+{
+       int state = lkb->lkb_lockqueue_state;
+
+       lkb->lkb_lockqueue_state = 0;
+
+       switch (state) {
+       case GDLM_LQSTATE_WAIT_RSB:
+               lkb->lkb_flags |= GDLM_LKFLG_DELAST;
+               break;
+
+       case GDLM_LQSTATE_WAIT_CONDGRANT:
+               res_lkb_dequeue(lkb);
+               lkb->lkb_flags |= GDLM_LKFLG_DELAST;
+               break;
+
+       case GDLM_LQSTATE_WAIT_CONVERT:
+               res_lkb_swqueue(lkb->lkb_resource, lkb, GDLM_LKSTS_GRANTED);
+
+               /* Remove from deadlock detection */
+               if (lkb->lkb_duetime) {
+                       remove_from_deadlockqueue(lkb);
+               }
+               break;
+
+       case GDLM_LQSTATE_WAIT_UNLOCK:
+               /* We can leave this. I think.... */
+               break;
+       }
+
+       lkb->lkb_retstatus = status;
+       queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+
+       return 0;
+}
+
+/* 
+ * Check for conversion deadlock. If a deadlock was found
+ * return lkb to kill, else return NULL
+ */
+
+gd_lkb_t *conversion_deadlock_check(gd_lkb_t *lkb)
+{
+       gd_res_t *rsb = lkb->lkb_resource;
+       struct list_head *entry;
+
+       GDLM_ASSERT(lkb->lkb_status == GDLM_LKSTS_CONVERT,);
+
+       /* Work our way up to the head of the queue looking for locks that
+        * conflict with us */
+
+       down_read(&rsb->res_lock);
+
+       entry = lkb->lkb_statequeue.prev;
+       while (entry != &rsb->res_convertqueue) {
+               gd_lkb_t *lkb2 = list_entry(entry, gd_lkb_t, lkb_statequeue);
+
+               if (ranges_overlap(lkb, lkb2) && !modes_compat(lkb2, lkb)) {
+                       up_read(&rsb->res_lock);
+                       return lkb;
+               }
+               entry = entry->prev;
+       }
+       up_read(&rsb->res_lock);
+
+       return 0;
+}
+
+/* 
+ * Conversion operation was cancelled by us (not the user).
+ * ret contains the return code to pass onto the user
+ */
+
+void cancel_conversion(gd_lkb_t *lkb, int ret)
+{
+       gd_res_t *rsb = lkb->lkb_resource;
+
+       /* Stick it back on the granted queue */
+       res_lkb_swqueue(rsb, lkb, GDLM_LKSTS_GRANTED);
+       lkb->lkb_rqmode = lkb->lkb_grmode;
+
+       remove_from_deadlockqueue(lkb);
+
+       lkb->lkb_retstatus = ret;
+       queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+       wake_astd();
+}
+
+/* 
+ * As new master of the rsb for this lkb, we need to handle these requests
+ * removed from the lockqueue and originating from local processes:
+ * GDLM_LQSTATE_WAIT_RSB, GDLM_LQSTATE_WAIT_CONDGRANT,
+ * GDLM_LQSTATE_WAIT_UNLOCK, GDLM_LQSTATE_WAIT_CONVERT.
+ */
+
+void process_remastered_lkb(gd_lkb_t *lkb, int state)
+{
+       switch (state) {
+       case GDLM_LQSTATE_WAIT_RSB:
+               dlm_lock_stage1(lkb->lkb_resource->res_ls, lkb,
+                               lkb->lkb_lockqueue_flags,
+                               lkb->lkb_resource->res_name,
+                               lkb->lkb_resource->res_length);
+               break;
+
+       case GDLM_LQSTATE_WAIT_CONDGRANT:
+               res_lkb_dequeue(lkb);
+               dlm_lock_stage3(lkb);
+               break;
+
+       case GDLM_LQSTATE_WAIT_UNLOCK:
+               dlm_unlock_stage2(lkb, lkb->lkb_lockqueue_flags);
+               break;
+
+       case GDLM_LQSTATE_WAIT_CONVERT:
+               dlm_convert_stage2(lkb, TRUE);
+               break;
+
+       default:
+               GDLM_ASSERT(0,);
+       }
+}
diff -urN linux-orig/cluster/dlm/locking.h linux-patched/cluster/dlm/locking.h
--- linux-orig/cluster/dlm/locking.h    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/locking.h 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,33 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __LOCKING_DOT_H__
+#define __LOCKING_DOT_H__
+
+void process_remastered_lkb(gd_lkb_t * lkb, int state);
+void dlm_lock_stage3(gd_lkb_t * lkb);
+int dlm_convert_stage2(gd_lkb_t * lkb, int do_ast);
+int dlm_unlock_stage2(gd_lkb_t * lkb, uint32_t flags);
+int dlm_lock_stage2(gd_ls_t * lspace, gd_lkb_t * lkb, gd_res_t * rsb,
+                   int flags);
+gd_res_t *create_rsb(gd_ls_t * lspace, gd_lkb_t * lkb, char *name, int namelen);
+int free_rsb_if_unused(gd_res_t * rsb);
+gd_lkb_t *remote_stage2(int remote_csid, gd_ls_t * lspace,
+                       struct gd_remlockrequest *freq);
+int cancel_lockop(gd_lkb_t * lkb, int status);
+int dlm_remove_lock(gd_lkb_t * lkb, uint32_t flags);
+int grant_pending_locks(gd_res_t * rsb);
+void cancel_conversion(gd_lkb_t * lkb, int ret);
+gd_lkb_t *conversion_deadlock_check(gd_lkb_t * lkb);
+
+#endif                         /* __LOCKING_DOT_H__ */
diff -urN linux-orig/cluster/dlm/lockqueue.c linux-patched/cluster/dlm/lockqueue.c
--- linux-orig/cluster/dlm/lockqueue.c  1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/lockqueue.c       2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,954 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/*
+ * lockqueue.c
+ *
+ * This controls the lock queue, which is where locks
+ * come when they need to wait for a remote operation
+ * to complete.
+ *
+ * This could also be thought of as the "high-level" comms
+ * layer.
+ *
+ */
+
+#include "dlm_internal.h"
+#include "lockqueue.h"
+#include "dir.h"
+#include "locking.h"
+#include "lkb.h"
+#include "lowcomms.h"
+#include "midcomms.h"
+#include "reccomms.h"
+#include "nodes.h"
+#include "lockspace.h"
+#include "ast.h"
+#include "memory.h"
+#include "rsb.h"
+#include "queries.h"
+
+static void add_reply_lvb(gd_lkb_t * lkb, struct gd_remlockreply *reply);
+static void add_request_lvb(gd_lkb_t * lkb, struct gd_remlockrequest *req);
+
+/*
+ * format of an entry on the request queue
+ */
+struct rq_entry {
+       struct list_head rqe_list;
+       uint32_t rqe_nodeid;
+       char rqe_request[1];
+};
+
+/*
+ * Add a new request (if appropriate) to the request queue and send the remote
+ * request out.  - runs in the context of the locking caller
+ *
+ * Recovery of a remote_stage request if the remote end fails while the lkb
+ * is still on the lockqueue:
+ *
+ * o lkbs on the lockqueue are flagged with GDLM_LKFLG_LQRESEND in
+ *   lockqueue_lkb_mark() at the start of recovery.
+ *
+ * o Some lkb's will be rebuilt on new master rsb's during recovery.
+ *   (depends on the type of request, see below).
+ *
+ * o At the end of recovery, resend_cluster_requests() looks at these
+ *   LQRESEND lkb's and either:
+ *
+ *   i) resends the request to the new master for the rsb where the
+ *      request is processed as usual.  The lkb remains on the lockqueue until
+ *      the new master replies and we run process_lockqueue_reply().
+ *
+ *   ii) if we've become the rsb master, remove the lkb from the lockqueue
+ *       and processes the request locally via process_remastered_lkb().
+ *
+ * GDLM_LQSTATE_WAIT_RSB (1) - these lockqueue lkb's are not on any rsb queue
+ * and the request should be resent if dest node is failed.
+ *
+ * GDLM_LQSTATE_WAIT_CONDGRANT (3) - this lockqueue lkb is on a local rsb's
+ * wait queue.  Don't rebuild this lkb on a new master rsb (the NOREBUILD flag
+ * makes send_lkb_queue() skip it).  Resend this request to the new master.
+ *
+ * GDLM_LQSTATE_WAIT_UNLOCK (4) - this lkb is on a local rsb's queue.  It will
+ * be rebuilt on the rsb on the new master (restbl_lkb_send/send_lkb_queue).
+ * Resend this request to the new master.
+ *
+ * GDLM_LQSTATE_WAIT_CONVERT (2) - this lkb is on a local rsb convert queue.
+ * It will be rebuilt on the new master rsb's granted queue.  Resend this
+ * request to the new master.
+ */
+
+int remote_stage(gd_lkb_t *lkb, int state)
+{
+       int error;
+
+       lkb->lkb_lockqueue_state = state;
+       add_to_lockqueue(lkb);
+
+       error = send_cluster_request(lkb, state);
+       if (error < 0) {
+               log_print("remote_stage error sending request %d", error);
+
+               /* Leave on lockqueue, it will be resent to correct node during
+                * recovery. */
+
+                /*
+                lkb->lkb_lockqueue_state = 0;
+                remove_from_lockqueue(lkb);
+                return -ENOTCONN;
+                */
+       }
+       return 0;
+}
+
+/*
+ * Requests received while the lockspace is in recovery get added to the
+ * request queue and processed when recovery is complete.
+ */
+
+void add_to_requestqueue(gd_ls_t *ls, int nodeid, char *request, int length)
+{
+       struct rq_entry *entry;
+
+       if (in_nodes_gone(ls, nodeid))
+               return;
+
+       entry = kmalloc(sizeof(struct rq_entry) + length, GFP_KERNEL);
+       if (!entry) {
+               // TODO something better
+               printk("dlm: add_to_requestqueue: out of memory\n");
+               return;
+       }
+
+       log_debug(ls, "add_to_requestqueue %d", nodeid);
+       entry->rqe_nodeid = nodeid;
+       memcpy(entry->rqe_request, request, length);
+       list_add_tail(&entry->rqe_list, &ls->ls_requestqueue);
+}
+
+int process_requestqueue(gd_ls_t *ls)
+{
+       int error = 0, count = 0;
+       struct rq_entry *entry, *safe;
+       struct gd_req_header *req;
+
+       log_all(ls, "process held requests");
+
+       list_for_each_entry_safe(entry, safe, &ls->ls_requestqueue, rqe_list) {
+               req = (struct gd_req_header *) entry->rqe_request;
+               log_debug(ls, "process_requestqueue %u", entry->rqe_nodeid);
+
+               if (!test_bit(LSFL_LS_RUN, &ls->ls_flags)) {
+                       log_debug(ls, "process_requestqueue aborted");
+                       error = -EINTR;
+                       break;
+               }
+
+               error = process_cluster_request(entry->rqe_nodeid, req, TRUE);
+               if (error == -EINTR) {
+                       log_debug(ls, "process_requestqueue interrupted");
+                       break;
+               }
+
+               list_del(&entry->rqe_list);
+               kfree(entry);
+               count++;
+               error = 0;
+       }
+
+       log_all(ls, "processed %d requests", count);
+       return error;
+}
+
+void wait_requestqueue(gd_ls_t *ls)
+{
+       while (!list_empty(&ls->ls_requestqueue) &&
+               test_bit(LSFL_LS_RUN, &ls->ls_flags))
+               schedule();
+}
+
+/*
+ * Resdir requests (lookup or remove) and replies from before recovery are
+ * invalid since the resdir was rebuilt.  Clear them.  Requests from nodes now
+ * gone are also invalid.
+ */
+
+void purge_requestqueue(gd_ls_t *ls)
+{
+       int count = 0;
+       struct rq_entry *entry, *safe;
+       struct gd_req_header *req;
+       struct gd_remlockrequest *freq;
+       gd_lkb_t *lkb;
+
+       log_all(ls, "purge requests");
+
+       list_for_each_entry_safe(entry, safe, &ls->ls_requestqueue, rqe_list) {
+               req = (struct gd_req_header *) entry->rqe_request;
+               freq = (struct gd_remlockrequest *) req;
+
+               if (req->rh_cmd == GDLM_REMCMD_REM_RESDATA ||
+                   req->rh_cmd == GDLM_REMCMD_LOOKUP ||
+                   in_nodes_gone(ls, entry->rqe_nodeid)) {
+
+                       list_del(&entry->rqe_list);
+                       kfree(entry);
+                       count++;
+
+               } else if (req->rh_cmd == GDLM_REMCMD_LOCKREPLY) {
+
+                       /*
+                        * Replies to resdir lookups are invalid and must be
+                        * purged.  The lookup requests are marked in
+                        * lockqueue_lkb_mark and will be resent in
+                        * resend_cluster_requests.  The only way to check if
+                        * this is a lookup reply is to look at the
+                        * lockqueue_state of the lkb.
+                        */
+
+                       lkb = find_lock_by_id(ls, freq->rr_header.rh_lkid);
+                       GDLM_ASSERT(lkb,);
+                       if (lkb->lkb_lockqueue_state == GDLM_LQSTATE_WAIT_RSB) {
+                               list_del(&entry->rqe_list);
+                               kfree(entry);
+                               count++;
+                       }
+               }
+       }
+
+       log_all(ls, "purged %d requests", count);
+}
+
+/*
+ * Check if there's a reply for the given lkid in the requestqueue.
+ */
+
+int reply_in_requestqueue(gd_ls_t *ls, int lkid)
+{
+       int rv = FALSE;
+       struct rq_entry *entry, *safe;
+       struct gd_req_header *req;
+       struct gd_remlockrequest *freq;
+
+       list_for_each_entry_safe(entry, safe, &ls->ls_requestqueue, rqe_list) {
+               req = (struct gd_req_header *) entry->rqe_request;
+               freq = (struct gd_remlockrequest *) req;
+
+               if (req->rh_cmd == GDLM_REMCMD_LOCKREPLY &&
+                   freq->rr_header.rh_lkid == lkid) {
+                       rv = TRUE;
+                       break;
+               }
+       }
+
+       return rv;
+}
+
+void allocate_and_copy_lvb(gd_ls_t *ls, char **lvbptr, char *src)
+{
+       if (!*lvbptr)
+               *lvbptr = allocate_lvb(ls);
+       if (*lvbptr)
+               memcpy(*lvbptr, src, DLM_LVB_LEN);
+}
+
+/*
+ * Process a lockqueue LKB after it has had it's remote processing complete and
+ * been pulled from the lockqueue.  Runs in the context of the DLM recvd thread on
+ * the machine that requested the lock.
+ */
+
+static void process_lockqueue_reply(gd_lkb_t *lkb,
+                                   struct gd_remlockreply *reply)
+{
+       int state = lkb->lkb_lockqueue_state;
+       int oldstate;
+       gd_res_t *rsb = lkb->lkb_resource;
+       gd_ls_t *ls = rsb->res_ls;
+
+       lkb->lkb_lockqueue_state = 0;
+       if (state)
+               remove_from_lockqueue(lkb);
+
+       switch (state) {
+       case GDLM_LQSTATE_WAIT_RSB:
+
+               GDLM_ASSERT(reply->rl_status == 0,);
+
+               if (reply->rl_nodeid == our_nodeid())
+                       rsb->res_nodeid = 0;
+               else
+                       rsb->res_nodeid = reply->rl_nodeid;
+
+               rsb->res_resdir_seq = reply->rl_resdir_seq;
+               lkb->lkb_nodeid = rsb->res_nodeid;
+
+               dlm_lock_stage2(rsb->res_ls, lkb, rsb,
+                               lkb->lkb_lockqueue_flags);
+               break;
+
+       case GDLM_LQSTATE_WAIT_CONVERT:
+       case GDLM_LQSTATE_WAIT_CONDGRANT:
+
+               /*
+                * After a remote lock/conversion/grant request we put the lock
+                * on the right queue and send an AST if appropriate.  Any lock
+                * shuffling (eg newly granted locks because this one was
+                * converted downwards) will be dealt with in seperate messages
+                * (which may be in the same network message)
+                */
+
+               if (!lkb->lkb_remid)
+                       lkb->lkb_remid = reply->rl_lkid;
+
+               /*
+                * The remote request failed (we assume because of NOQUEUE).
+                * If this is a new request (non-conv) the lkb was created just
+                * for it so the lkb should be freed.  If this was a
+                * conversion, the lkb already existed so we should put it back
+                * on the grant queue.
+                */
+
+               if (reply->rl_status != 0) {
+                       GDLM_ASSERT(reply->rl_status == -EAGAIN,);
+
+                       if (state == GDLM_LQSTATE_WAIT_CONDGRANT) {
+                               res_lkb_dequeue(lkb);
+                               lkb->lkb_flags |= GDLM_LKFLG_DELAST;
+                       } else
+                               res_lkb_swqueue(rsb, lkb, GDLM_LKSTS_GRANTED);
+
+                       lkb->lkb_retstatus = reply->rl_status;
+                       queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+                       break;
+               }
+
+               /*
+                * The remote request was successful in granting the request or
+                * queuing it to be granted later.  Add the lkb to the
+                * appropriate rsb queue.
+                */
+
+               switch (reply->rl_lockstate) {
+               case GDLM_LKSTS_GRANTED:
+
+                       /* Compact version of grant_lock(). */
+
+                       down_write(&rsb->res_lock);
+                       if (lkb->lkb_flags & GDLM_LKFLG_VALBLK)
+                               memcpy(lkb->lkb_lvbptr, reply->rl_lvb,
+                                      DLM_LVB_LEN);
+
+                       lkb->lkb_grmode = lkb->lkb_rqmode;
+                       lkb->lkb_rqmode = DLM_LOCK_IV;
+                       lkb_swqueue(rsb, lkb, GDLM_LKSTS_GRANTED);
+
+                       if (lkb->lkb_range) {
+                               lkb->lkb_range[GR_RANGE_START] =
+                                   lkb->lkb_range[RQ_RANGE_START];
+                               lkb->lkb_range[GR_RANGE_END] =
+                                   lkb->lkb_range[RQ_RANGE_END];
+                       }
+                       up_write(&rsb->res_lock);
+
+                       lkb->lkb_retstatus = 0;
+                       queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+                       break;
+
+               case GDLM_LKSTS_WAITING:
+
+                       if (lkb->lkb_status != GDLM_LKSTS_GRANTED)
+                               res_lkb_swqueue(rsb, lkb, GDLM_LKSTS_WAITING);
+                       else
+                               log_error(ls, "wait reply for granted %x %u",
+                                         lkb->lkb_id, lkb->lkb_nodeid);
+                       break;
+
+               case GDLM_LKSTS_CONVERT:
+
+                       if (lkb->lkb_status != GDLM_LKSTS_GRANTED)
+                               res_lkb_swqueue(rsb, lkb, GDLM_LKSTS_CONVERT);
+                       else
+                               log_error(ls, "convert reply for granted %x %u",
+                                         lkb->lkb_id, lkb->lkb_nodeid);
+                       break;
+
+               default:
+                       log_error(ls, "process_lockqueue_reply state %d",
+                                 reply->rl_lockstate);
+               }
+
+               break;
+
+       case GDLM_LQSTATE_WAIT_UNLOCK:
+
+               /*
+                * Unlocks should never fail.  Update local lock info.  This
+                * always sends completion AST with status in lksb
+                */
+
+               GDLM_ASSERT(reply->rl_status == 0,);
+               oldstate = res_lkb_dequeue(lkb);
+
+               /* Differentiate between unlocks and conversion cancellations */
+               if (lkb->lkb_lockqueue_flags & DLM_LKF_CANCEL &&
+                   oldstate == GDLM_LKSTS_CONVERT) {
+                       res_lkb_enqueue(lkb->lkb_resource, lkb,
+                                       GDLM_LKSTS_GRANTED);
+                       lkb->lkb_retstatus = -DLM_ECANCEL;
+               } else {
+                       lkb->lkb_flags |= GDLM_LKFLG_DELAST;
+                       lkb->lkb_retstatus = -DLM_EUNLOCK;
+               }
+               queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+               break;
+
+       default:
+               log_error(ls, "process_lockqueue_reply id %x state %d",
+                         lkb->lkb_id, state);
+       }
+}
+
+/*
+ * Tell a remote node to grant a lock.  This happens when we are the master
+ * copy for a lock that is actually held on a remote node.  The remote end is
+ * also responsible for sending the completion AST.
+ */
+
+void remote_grant(gd_lkb_t *lkb)
+{
+       struct writequeue_entry *e;
+       struct gd_remlockrequest *req;
+
+       // TODO Error handling
+       e = lowcomms_get_buffer(lkb->lkb_nodeid,
+                               sizeof(struct gd_remlockrequest),
+                               lkb->lkb_resource->res_ls->ls_allocation,
+                               (char **) &req);
+       if (!e)
+               return;
+
+       req->rr_header.rh_cmd = GDLM_REMCMD_LOCKGRANT;
+       req->rr_header.rh_length = sizeof(struct gd_remlockrequest);
+       req->rr_header.rh_flags = 0;
+       req->rr_header.rh_lkid = lkb->lkb_id;
+       req->rr_header.rh_lockspace = lkb->lkb_resource->res_ls->ls_global_id;
+       req->rr_remlkid = lkb->lkb_remid;
+       req->rr_flags = 0;
+
+       if (lkb->lkb_flags & GDLM_LKFLG_DEMOTED) {
+               /* This is a confusing non-standard use of rr_flags which is
+                * usually used to pass lockqueue_flags. */
+               req->rr_flags |= GDLM_LKFLG_DEMOTED;
+       }
+
+       add_request_lvb(lkb, req);
+       midcomms_send_buffer(&req->rr_header, e);
+}
+
+void reply_and_grant(gd_lkb_t *lkb)
+{
+       struct gd_remlockrequest *req = lkb->lkb_request;
+       struct gd_remlockreply *reply;
+       struct writequeue_entry *e;
+
+       // TODO Error handling
+       e = lowcomms_get_buffer(lkb->lkb_nodeid,
+                               sizeof(struct gd_remlockreply),
+                               lkb->lkb_resource->res_ls->ls_allocation,
+                               (char **) &reply);
+       if (!e)
+               return;
+
+       reply->rl_header.rh_cmd = GDLM_REMCMD_LOCKREPLY;
+       reply->rl_header.rh_flags = 0;
+       reply->rl_header.rh_length = sizeof(struct gd_remlockreply);
+       reply->rl_header.rh_lkid = req->rr_header.rh_lkid;
+       reply->rl_header.rh_lockspace = req->rr_header.rh_lockspace;
+
+       reply->rl_status = lkb->lkb_retstatus;
+       reply->rl_lockstate = lkb->lkb_status;
+       reply->rl_lkid = lkb->lkb_id;
+
+       GDLM_ASSERT(!(lkb->lkb_flags & GDLM_LKFLG_DEMOTED),);
+
+       lkb->lkb_request = NULL;
+
+       add_reply_lvb(lkb, reply);
+       midcomms_send_buffer(&reply->rl_header, e);
+}
+
+/*
+ * Request removal of a dead entry in the resource directory
+ */
+
+void remote_remove_resdata(gd_ls_t *ls, int nodeid, char *name, int namelen,
+                          uint8_t sequence)
+{
+       struct writequeue_entry *e;
+       struct gd_remlockrequest *req;
+
+       if (!test_bit(LSFL_LS_RUN, &ls->ls_flags)) {
+               gd_rcom_t *rc = allocate_rcom_buffer(ls);
+
+               memcpy(rc->rc_buf, name, namelen);
+               rc->rc_datalen = namelen;
+
+               rcom_send_message(ls, nodeid, RECCOMM_REMRESDATA, rc, 0);
+
+               free_rcom_buffer(rc);
+               return;
+       }
+       // TODO Error handling
+       e = lowcomms_get_buffer(nodeid,
+                               sizeof(struct gd_remlockrequest) + namelen - 1,
+                               ls->ls_allocation, (char **) &req);
+       if (!e)
+               return;
+
+       memset(req, 0, sizeof(struct gd_remlockrequest) + namelen - 1);
+       req->rr_header.rh_cmd = GDLM_REMCMD_REM_RESDATA;
+       req->rr_header.rh_length =
+           sizeof(struct gd_remlockrequest) + namelen - 1;
+       req->rr_header.rh_flags = 0;
+       req->rr_header.rh_lkid = 0;
+       req->rr_header.rh_lockspace = ls->ls_global_id;
+       req->rr_remlkid = 0;
+       req->rr_resdir_seq = sequence;
+       memcpy(req->rr_name, name, namelen);
+
+       midcomms_send_buffer(&req->rr_header, e);
+}
+
+/*
+ * Send remote cluster request to directory or master node before the request
+ * is put on the lock queue.  Runs in the context of the locking caller.
+ */
+
+int send_cluster_request(gd_lkb_t *lkb, int state)
+{
+       uint32_t target_nodeid;
+       gd_res_t *rsb = lkb->lkb_resource;
+       gd_ls_t *ls = rsb->res_ls;
+       struct gd_remlockrequest *req;
+       struct writequeue_entry *e;
+
+       /* Need to know the target nodeid before we allocate a send buffer */
+       target_nodeid = lkb->lkb_nodeid;
+       GDLM_ASSERT(target_nodeid != 0,);
+
+       if (state == GDLM_LQSTATE_WAIT_RSB)
+               target_nodeid = get_directory_nodeid(rsb);
+
+       GDLM_ASSERT(target_nodeid,);
+
+       if (!test_bit(LSFL_LS_RUN, &ls->ls_flags)) {
+               /* this may happen when called by resend_cluster_request */
+               log_error(ls, "send_cluster_request to %u state %d recovery",
+                         target_nodeid, state);
+       }
+
+       e = lowcomms_get_buffer(target_nodeid,
+                               sizeof(struct gd_remlockrequest) +
+                               rsb->res_length - 1, ls->ls_allocation,
+                               (char **) &req);
+       if (!e)
+               return -ENOBUFS;
+       memset(req, 0, sizeof(struct gd_remlockrequest) + rsb->res_length - 1);
+
+       /* Common stuff, some are just defaults */
+
+       if (lkb->lkb_bastaddr)
+               req->rr_asts = GDLM_QUEUE_BLKAST;
+       if (lkb->lkb_astaddr)
+               req->rr_asts |= GDLM_QUEUE_COMPAST;
+       if (lkb->lkb_parent)
+               req->rr_remparid = lkb->lkb_parent->lkb_remid;
+
+       req->rr_flags = lkb->lkb_lockqueue_flags;
+       req->rr_rqmode = lkb->lkb_rqmode;
+       req->rr_remlkid = lkb->lkb_remid;
+       req->rr_header.rh_length =
+           sizeof(struct gd_remlockrequest) + rsb->res_length - 1;
+       req->rr_header.rh_flags = 0;
+       req->rr_header.rh_lkid = lkb->lkb_id;
+       req->rr_header.rh_lockspace = ls->ls_global_id;
+
+       switch (state) {
+
+       case GDLM_LQSTATE_WAIT_RSB:
+
+               /* The lock must be a root lock */
+               GDLM_ASSERT(!lkb->lkb_parent,);
+
+               req->rr_header.rh_cmd = GDLM_REMCMD_LOOKUP;
+               memcpy(req->rr_name, rsb->res_name, rsb->res_length);
+               break;
+
+       case GDLM_LQSTATE_WAIT_CONVERT:
+
+               req->rr_header.rh_cmd = GDLM_REMCMD_CONVREQUEST;
+               if (lkb->lkb_range) {
+                       req->rr_flags |= GDLM_LKFLG_RANGE;
+                       req->rr_range_start = lkb->lkb_range[RQ_RANGE_START];
+                       req->rr_range_end = lkb->lkb_range[RQ_RANGE_END];
+               }
+               break;
+
+       case GDLM_LQSTATE_WAIT_CONDGRANT:
+
+               req->rr_header.rh_cmd = GDLM_REMCMD_LOCKREQUEST;
+               req->rr_resdir_seq = rsb->res_resdir_seq;
+               memcpy(req->rr_name, rsb->res_name, rsb->res_length);
+               if (lkb->lkb_range) {
+                       req->rr_flags |= GDLM_LKFLG_RANGE;
+                       req->rr_range_start = lkb->lkb_range[RQ_RANGE_START];
+                       req->rr_range_end = lkb->lkb_range[RQ_RANGE_END];
+               }
+               break;
+
+       case GDLM_LQSTATE_WAIT_UNLOCK:
+
+               req->rr_header.rh_cmd = GDLM_REMCMD_UNLOCKREQUEST;
+               break;
+
+       default:
+               GDLM_ASSERT(!"Unknown cluster request",);
+       }
+
+       add_request_lvb(lkb, req);
+       midcomms_send_buffer(&req->rr_header, e);
+
+       return 0;
+}
+
+/*
+ * We got a request from another cluster node, process it and return an info
+ * structure with the lock state/LVB etc as required.  Executes in the DLM's
+ * recvd thread.
+ */
+
+int process_cluster_request(int nodeid, struct gd_req_header *req, int recovery)
+{
+       gd_ls_t *lspace;
+       gd_lkb_t *lkb = NULL;
+       gd_res_t *rsb;
+       int send_reply = 0, status = 0, namelen;
+       struct gd_remlockrequest *freq = (struct gd_remlockrequest *) req;
+       struct gd_remlockreply reply;
+
+       lspace = find_lockspace_by_global_id(req->rh_lockspace);
+
+       if (!lspace) {
+               log_print("process_cluster_request invalid lockspace %x "
+                         "from %d req %u", req->rh_lockspace, nodeid,
+                         req->rh_cmd);
+               status = -EINVAL;
+               goto out;
+       }
+
+       /* wait for recoverd to drain requestqueue */
+       if (!recovery)
+               wait_requestqueue(lspace);
+
+       /*
+        * If we're in recovery then queue the request for later.  Otherwise,
+        * we still need to get the "in_recovery" lock to make sure the
+        * recovery itself doesn't start until we are done.
+        */
+ retry:
+       if (!test_bit(LSFL_LS_RUN, &lspace->ls_flags)) {
+               if (test_bit(LSFL_REQUEST_WARN, &lspace->ls_flags))
+                       log_error(lspace, "process_cluster_request warning %u",
+                                 nodeid);
+               add_to_requestqueue(lspace, nodeid, (char *) req,
+                                   req->rh_length);
+               log_debug(lspace, "process_cluster_request abort");
+               status = -EINTR;
+               goto out;
+       }
+       if (!down_read_trylock(&lspace->ls_in_recovery)) {
+               schedule();
+               goto retry;
+       }
+
+
+       /*
+        * Process the request.
+        */
+
+       switch (req->rh_cmd) {
+
+       case GDLM_REMCMD_LOOKUP:
+               {
+                       gd_resdata_t *rd;
+                       int status;
+                       uint32_t dir_nodeid;
+
+                       namelen = freq->rr_header.rh_length - sizeof(*freq) + 1;
+
+                       dir_nodeid = name_to_directory_nodeid(lspace,
+                                                             freq->rr_name,
+                                                             namelen);
+                       if (dir_nodeid != our_nodeid())
+                               log_debug(lspace, "ignoring directory lookup");
+
+                       status = get_resdata(lspace, nodeid, freq->rr_name,
+                                            namelen, &rd, 0);
+                       if (status)
+                               status = -ENOMEM;
+
+                       reply.rl_status = status;
+                       reply.rl_lockstate = 0;
+                       reply.rl_nodeid = rd->rd_master_nodeid;
+                       reply.rl_resdir_seq = rd->rd_sequence;
+               }
+               send_reply = 1;
+               break;
+
+       case GDLM_REMCMD_REM_RESDATA:
+
+               namelen = freq->rr_header.rh_length - sizeof(*freq) + 1;
+               remove_resdata(lspace, nodeid, freq->rr_name, namelen,
+                              freq->rr_resdir_seq);
+               break;
+
+       case GDLM_REMCMD_LOCKREQUEST:
+
+               lkb = remote_stage2(nodeid, lspace, freq);
+               if (lkb) {
+                       lkb->lkb_request = freq;
+                       dlm_lock_stage3(lkb);
+
+                       /*
+                        * If the request was granted in lock_stage3, then a
+                        * reply message was already sent in combination with
+                        * the grant message and lkb_request is NULL.
+                        */
+
+                       if (lkb->lkb_request) {
+                               lkb->lkb_request = NULL;
+                               send_reply = 1;
+                               reply.rl_status = lkb->lkb_retstatus;
+                               reply.rl_lockstate = lkb->lkb_status;
+                               reply.rl_lkid = lkb->lkb_id;
+
+                               /*
+                                * If the request could not be granted and the
+                                * user won't wait, then free up the LKB
+                                */
+
+                               if (lkb->lkb_flags & GDLM_LKFLG_DELAST) {
+                                       rsb = lkb->lkb_resource;
+                                       release_lkb(lspace, lkb);
+                                       release_rsb(rsb);
+                                       lkb = NULL;
+                               }
+                       }
+               } else {
+                       reply.rl_status = -ENOMEM;
+                       send_reply = 1;
+               }
+               break;
+
+       case GDLM_REMCMD_CONVREQUEST:
+
+               lkb = find_lock_by_id(lspace, freq->rr_remlkid);
+
+               GDLM_ASSERT(lkb, printk("rr_remlkid=%x rh_lkid=%x from=%u\n",
+                                       freq->rr_remlkid,
+                                       freq->rr_header.rh_lkid, nodeid););
+
+               if (lkb->lkb_status != GDLM_LKSTS_GRANTED)
+                       log_error(lspace, "convrequest: invalid status %d",
+                                 lkb->lkb_status);
+
+               lkb->lkb_rqmode = freq->rr_rqmode;
+               lkb->lkb_lockqueue_flags = freq->rr_flags;
+               lkb->lkb_request = freq;
+               lkb->lkb_flags &= ~GDLM_LKFLG_DEMOTED;
+
+               if (lkb->lkb_flags & GDLM_LKFLG_VALBLK
+                   || freq->rr_flags & DLM_LKF_VALBLK) {
+                       lkb->lkb_flags |= GDLM_LKFLG_VALBLK;
+                       allocate_and_copy_lvb(lspace, &lkb->lkb_lvbptr,
+                                             freq->rr_lvb);
+               }
+
+               if (freq->rr_flags & GDLM_LKFLG_RANGE) {
+                       if (lkb_set_range(lspace, lkb, freq->rr_range_start,
+                                         freq->rr_range_end)) {
+                               reply.rl_status = -ENOMEM;
+                               send_reply = 1;
+                               goto out;
+                       }
+               }
+
+               dlm_convert_stage2(lkb, FALSE);
+
+               /*
+                * If the conv request was granted in stage2, then a reply
+                * message was already sent in combination with the grant
+                * message.
+                */
+
+               if (lkb->lkb_request) {
+                       lkb->lkb_request = NULL;
+                       send_reply = 1;
+                       reply.rl_status = lkb->lkb_retstatus;
+                       reply.rl_lockstate = lkb->lkb_status;
+                       reply.rl_lkid = lkb->lkb_id;
+               }
+               break;
+
+       case GDLM_REMCMD_LOCKREPLY:
+
+               lkb = find_lock_by_id(lspace, freq->rr_header.rh_lkid);
+
+               GDLM_ASSERT(lkb, printk("rr_remlkid=%x rh_lkid=%x from=%u\n",
+                                       freq->rr_remlkid,
+                                       freq->rr_header.rh_lkid, nodeid););
+
+               process_lockqueue_reply(lkb, (struct gd_remlockreply *) req);
+               break;
+
+       case GDLM_REMCMD_LOCKGRANT:
+
+               /*
+                * Remote lock has been granted asynchronously.  Do a compact
+                * version of what grant_lock() does.
+                */
+
+               lkb = find_lock_by_id(lspace, freq->rr_remlkid);
+
+               GDLM_ASSERT(lkb, printk("rr_remlkid=%x rh_lkid=%x from=%u\n",
+                                       freq->rr_remlkid,
+                                       freq->rr_header.rh_lkid, nodeid););
+
+               rsb = lkb->lkb_resource;
+
+               if (lkb->lkb_lockqueue_state)
+                       log_error(rsb->res_ls, "granting lock on lockqueue "
+                                 "id=%x from=%u lqstate=%d flags=%x",
+                                 lkb->lkb_id, nodeid, lkb->lkb_lockqueue_state,
+                                 lkb->lkb_flags);
+
+               down_write(&rsb->res_lock);
+
+               if (lkb->lkb_flags & GDLM_LKFLG_VALBLK)
+                       memcpy(lkb->lkb_lvbptr, freq->rr_lvb, DLM_LVB_LEN);
+
+               lkb->lkb_grmode = lkb->lkb_rqmode;
+               lkb->lkb_rqmode = DLM_LOCK_IV;
+
+               if (lkb->lkb_range) {
+                       lkb->lkb_range[GR_RANGE_START] =
+                           lkb->lkb_range[RQ_RANGE_START];
+                       lkb->lkb_range[GR_RANGE_END] =
+                           lkb->lkb_range[RQ_RANGE_END];
+               }
+
+               lkb_swqueue(rsb, lkb, GDLM_LKSTS_GRANTED);
+               up_write(&rsb->res_lock);
+
+               if (freq->rr_flags & GDLM_LKFLG_DEMOTED)
+                       lkb->lkb_flags |= GDLM_LKFLG_DEMOTED;
+
+               lkb->lkb_retstatus = 0;
+               queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+               break;
+
+       case GDLM_REMCMD_SENDBAST:
+
+               lkb = find_lock_by_id(lspace, freq->rr_remlkid);
+
+               GDLM_ASSERT(lkb, printk("rr_remlkid=%x rh_lkid=%x from=%u\n",
+                                       freq->rr_remlkid,
+                                       freq->rr_header.rh_lkid, nodeid););
+
+               if (lkb->lkb_status == GDLM_LKSTS_GRANTED)
+                       queue_ast(lkb, GDLM_QUEUE_BLKAST, freq->rr_rqmode);
+               break;
+
+       case GDLM_REMCMD_SENDCAST:
+
+               /* This is only used for some error completion ASTs */
+
+               lkb = find_lock_by_id(lspace, freq->rr_remlkid);
+
+               GDLM_ASSERT(lkb, printk("rr_remlkid=%x rh_lkid=%x from=%u\n",
+                                       freq->rr_remlkid,
+                                       freq->rr_header.rh_lkid, nodeid););
+
+               /* Return the lock to granted status */
+               res_lkb_swqueue(lkb->lkb_resource, lkb, GDLM_LKSTS_GRANTED);
+
+               lkb->lkb_retstatus = freq->rr_status;
+               queue_ast(lkb, GDLM_QUEUE_COMPAST, 0);
+               break;
+
+       case GDLM_REMCMD_UNLOCKREQUEST:
+
+               lkb = find_lock_by_id(lspace, freq->rr_remlkid);
+
+               GDLM_ASSERT(lkb, printk("rr_remlkid=%x rh_lkid=%x from=%u\n",
+                                       freq->rr_remlkid,
+                                       freq->rr_header.rh_lkid, nodeid););
+
+               reply.rl_status = dlm_unlock_stage2(lkb, freq->rr_flags);
+               send_reply = 1;
+               break;
+
+       case GDLM_REMCMD_QUERY:
+               remote_query(nodeid, lspace, req);
+               break;
+
+       case GDLM_REMCMD_QUERYREPLY:
+               remote_query_reply(nodeid, lspace, req);
+               break;
+
+       default:
+               log_error(lspace, "process_cluster_request cmd %d",req->rh_cmd);
+       }
+
+       up_read(&lspace->ls_in_recovery);
+
+      out:
+       if (send_reply) {
+               reply.rl_header.rh_cmd = GDLM_REMCMD_LOCKREPLY;
+               reply.rl_header.rh_flags = 0;
+               reply.rl_header.rh_length = sizeof(reply);
+               reply.rl_header.rh_lkid = freq->rr_header.rh_lkid;
+               reply.rl_header.rh_lockspace = freq->rr_header.rh_lockspace;
+
+               status = midcomms_send_message(nodeid, &reply.rl_header,
+                                              GFP_KERNEL);
+       }
+
+       wake_astd();
+
+       return status;
+}
+
+static void add_reply_lvb(gd_lkb_t *lkb, struct gd_remlockreply *reply)
+{
+       if (lkb->lkb_flags & GDLM_LKFLG_VALBLK)
+               memcpy(reply->rl_lvb, lkb->lkb_lvbptr, DLM_LVB_LEN);
+}
+
+static void add_request_lvb(gd_lkb_t *lkb, struct gd_remlockrequest *req)
+{
+       if (lkb->lkb_flags & GDLM_LKFLG_VALBLK)
+               memcpy(req->rr_lvb, lkb->lkb_lvbptr, DLM_LVB_LEN);
+}
diff -urN linux-orig/cluster/dlm/lockqueue.h linux-patched/cluster/dlm/lockqueue.h
--- linux-orig/cluster/dlm/lockqueue.h  1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/lockqueue.h       2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,29 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __LOCKQUEUE_DOT_H__
+#define __LOCKQUEUE_DOT_H__
+
+void remote_grant(gd_lkb_t * lkb);
+void reply_and_grant(gd_lkb_t * lkb);
+int remote_stage(gd_lkb_t * lkb, int state);
+int process_cluster_request(int csid, struct gd_req_header *req, int recovery);
+int send_cluster_request(gd_lkb_t * lkb, int state);
+void purge_requestqueue(gd_ls_t * ls);
+int process_requestqueue(gd_ls_t * ls);
+int reply_in_requestqueue(gd_ls_t * ls, int lkid);
+void remote_remove_resdata(gd_ls_t * ls, int nodeid, char *name, int namelen,
+                          uint8_t sequence);
+void allocate_and_copy_lvb(gd_ls_t * ls, char **lvbptr, char *src);
+
+#endif                         /* __LOCKQUEUE_DOT_H__ */
diff -urN linux-orig/cluster/dlm/lockspace.c linux-patched/cluster/dlm/lockspace.c
--- linux-orig/cluster/dlm/lockspace.c  1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/lockspace.c       2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,706 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include <linux/module.h>
+
+#include "dlm_internal.h"
+#include "recoverd.h"
+#include "ast.h"
+#include "lkb.h"
+#include "nodes.h"
+#include "dir.h"
+#include "lowcomms.h"
+#include "config.h"
+#include "memory.h"
+#include "lockspace.h"
+#include "device.h"
+
+#define GDST_NONE       (0)
+#define GDST_RUNNING    (1)
+
+static int gdlmstate;
+static int gdlmcount;
+static struct semaphore gdlmstate_lock;
+struct list_head lslist;
+spinlock_t lslist_lock;
+struct kcl_service_ops ls_ops;
+
+static int new_lockspace(char *name, int namelen, void **lockspace, int flags);
+
+
+void dlm_lockspace_init(void)
+{
+       gdlmstate = GDST_NONE;
+       gdlmcount = 0;
+       init_MUTEX(&gdlmstate_lock);
+       INIT_LIST_HEAD(&lslist);
+       spin_lock_init(&lslist_lock);
+}
+
+gd_ls_t *find_lockspace_by_global_id(uint32_t id)
+{
+       gd_ls_t *ls;
+
+       spin_lock(&lslist_lock);
+
+       list_for_each_entry(ls, &lslist, ls_list) {
+               if (ls->ls_global_id == id)
+                       goto out;
+       }
+       ls = NULL;
+      out:
+       spin_unlock(&lslist_lock);
+       return ls;
+}
+
+/* TODO: make this more efficient */
+gd_ls_t *find_lockspace_by_local_id(void *id)
+{
+       gd_ls_t *ls;
+
+       spin_lock(&lslist_lock);
+
+       list_for_each_entry(ls, &lslist, ls_list) {
+               if (ls->ls_local_id == (uint32_t)(long)id)
+                       goto out;
+       }
+       ls = NULL;
+      out:
+       spin_unlock(&lslist_lock);
+       return ls;
+}
+
+gd_ls_t *find_lockspace_by_name(char *name, int namelen)
+{
+       gd_ls_t *ls;
+
+       spin_lock(&lslist_lock);
+
+       list_for_each_entry(ls, &lslist, ls_list) {
+               if (ls->ls_namelen == namelen &&
+                   memcmp(ls->ls_name, name, namelen) == 0)
+                       goto out;
+       }
+       ls = NULL;
+      out:
+       spin_unlock(&lslist_lock);
+       return ls;
+}
+
+/*
+ * Called from dlm_init.  These are the general threads which are not
+ * lockspace-specific and work for all gdlm lockspaces.
+ */
+
+static int threads_start(void)
+{
+       int error;
+
+       /* Thread which interacts with cman for all ls's */
+       error = recoverd_start();
+       if (error) {
+               log_print("cannot start recovery thread %d", error);
+               goto fail;
+       }
+
+       /* Thread which process lock requests for all ls's */
+       error = astd_start();
+       if (error) {
+               log_print("cannot start ast thread %d", error);
+               goto recoverd_fail;
+       }
+
+       /* Thread for sending/receiving messages for all ls's */
+       error = lowcomms_start();
+       if (error) {
+               log_print("cannot start lowcomms %d", error);
+               goto astd_fail;
+       }
+
+       return 0;
+
+      astd_fail:
+       astd_stop();
+
+      recoverd_fail:
+       recoverd_stop();
+
+      fail:
+       return error;
+}
+
+static void threads_stop(void)
+{
+       lowcomms_stop();
+       astd_stop();
+       recoverd_stop();
+}
+
+static int init_internal(void)
+{
+       int error = 0;
+
+       if (gdlmstate == GDST_RUNNING)
+               gdlmcount++;
+       else {
+               error = threads_start();
+               if (error)
+                       goto out;
+
+               gdlmstate = GDST_RUNNING;
+               gdlmcount = 1;
+       }
+
+      out:
+       return error;
+}
+
+
+/*
+ * Called after gdlm module is loaded and before any lockspaces are created.
+ * Starts and initializes global threads and structures.  These global entities
+ * are shared by and independent of all lockspaces.
+ *
+ * There should be a gdlm-specific user command which a person can run which
+ * calls this function.  If a user hasn't run that command and something
+ * creates a new lockspace, this is called first.
+ *
+ * This also starts the default lockspace.
+ */
+
+int dlm_init(void)
+{
+       int error;
+
+       down(&gdlmstate_lock);
+       error = init_internal();
+       up(&gdlmstate_lock);
+
+       return error;
+}
+
+int dlm_release(void)
+{
+       int error = 0;
+
+       down(&gdlmstate_lock);
+
+       if (gdlmstate == GDST_NONE)
+               goto out;
+
+       if (gdlmcount)
+               gdlmcount--;
+
+       if (gdlmcount)
+               goto out;
+
+       spin_lock(&lslist_lock);
+       if (!list_empty(&lslist)) {
+               spin_unlock(&lslist_lock);
+               log_print("cannot stop threads, lockspaces still exist");
+               goto out;
+       }
+       spin_unlock(&lslist_lock);
+
+       threads_stop();
+       gdlmstate = GDST_NONE;
+
+      out:
+       up(&gdlmstate_lock);
+
+       return error;
+}
+
+gd_ls_t *allocate_ls(int namelen)
+{
+       gd_ls_t *ls;
+
+       /* FIXME: use appropriate malloc type */
+
+       ls = kmalloc(sizeof(gd_ls_t) + namelen, GFP_KERNEL);
+       if (ls)
+               memset(ls, 0, sizeof(gd_ls_t) + namelen);
+
+       return ls;
+}
+
+void free_ls(gd_ls_t *ls)
+{
+       kfree(ls);
+}
+
+static int new_lockspace(char *name, int namelen, void **lockspace, int flags)
+{
+       gd_ls_t *ls;
+       int i, error = -ENOMEM;
+       uint32_t local_id = 0;
+
+       if (!try_module_get(THIS_MODULE))
+               return -EINVAL;
+
+       if (namelen > MAX_SERVICE_NAME_LEN)
+               return -EINVAL;
+
+       if ((ls = find_lockspace_by_name(name, namelen))) {
+               *lockspace = (void *)ls->ls_local_id;
+               return -EEXIST;
+       }
+
+       /*
+        * Initialize ls fields
+        */
+
+       ls = allocate_ls(namelen);
+       if (!ls)
+               goto out;
+
+       memcpy(ls->ls_name, name, namelen);
+       ls->ls_namelen = namelen;
+
+       ls->ls_allocation = GFP_KERNEL;
+       memset(&ls->ls_flags, 0, sizeof(unsigned long));
+       INIT_LIST_HEAD(&ls->ls_rootres);
+       ls->ls_hashsize = dlm_config.reshashtbl;
+       ls->ls_hashmask = ls->ls_hashsize - 1;
+
+       ls->ls_reshashtbl =
+           kmalloc(sizeof(struct list_head) * ls->ls_hashsize, GFP_KERNEL);
+       if (!ls->ls_reshashtbl)
+               goto out_lsfree;
+
+       for (i = 0; i < ls->ls_hashsize; i++)
+               INIT_LIST_HEAD(&ls->ls_reshashtbl[i]);
+
+       rwlock_init(&ls->ls_reshash_lock);
+
+       if (init_lockidtbl(ls, dlm_config.lockidtbl) == -1)
+               goto out_htfree;
+
+       INIT_LIST_HEAD(&ls->ls_nodes);
+       ls->ls_num_nodes = 0;
+       INIT_LIST_HEAD(&ls->ls_nodes_gone);
+       INIT_LIST_HEAD(&ls->ls_recover);
+       spin_lock_init(&ls->ls_recover_lock);
+       INIT_LIST_HEAD(&ls->ls_recover_list);
+       ls->ls_recover_list_count = 0;
+       spin_lock_init(&ls->ls_recover_list_lock);
+       init_waitqueue_head(&ls->ls_wait_general);
+       INIT_LIST_HEAD(&ls->ls_requestqueue);
+       INIT_LIST_HEAD(&ls->ls_rebuild_rootrsb_list);
+       ls->ls_last_stop = 0;
+       ls->ls_last_start = 0;
+       ls->ls_last_finish = 0;
+       ls->ls_rcom_msgid = 0;
+       init_MUTEX(&ls->ls_rcom_lock);
+       init_rwsem(&ls->ls_in_recovery);
+       init_rwsem(&ls->ls_unlock_sem);
+       init_rwsem(&ls->ls_rec_rsblist);
+       init_rwsem(&ls->ls_gap_rsblist);
+       down_write(&ls->ls_in_recovery);
+
+       for (i = 0; i < RESDIRHASH_SIZE; i++) {
+               INIT_LIST_HEAD(&ls->ls_resdir_hash[i].rb_reslist);
+               rwlock_init(&ls->ls_resdir_hash[i].rb_lock);
+       }
+
+       if (flags & DLM_LSF_NOTIMERS)
+               set_bit(LSFL_NOTIMERS, &ls->ls_flags);
+
+       /*
+        * Connect this lockspace with the cluster manager
+        */
+
+       error = kcl_register_service(name, namelen, SERVICE_LEVEL_GDLM,
+                                    &ls_ops, TRUE, (void *) ls, &local_id);
+       if (error)
+               goto out_idtblfree;
+
+       ls->ls_state = LSST_INIT;
+       ls->ls_local_id = local_id;
+
+       spin_lock(&lslist_lock);
+       list_add(&ls->ls_list, &lslist);
+       spin_unlock(&lslist_lock);
+
+       error = kcl_join_service(local_id);
+       if (error) {
+               log_error(ls, "service manager join error %d", error);
+               goto out_reg;
+       }
+
+       /* The ls isn't actually running until it receives a start() from CMAN.
+        * Neither does it have a global ls id until started. */
+
+
+       /* Return the local ID as the lockspace handle. I've left this
+          cast to a void* as it allows us to replace it with pretty much
+          anything at a future date without breaking clients. But returning
+          the address of the lockspace is a bad idea as it could get
+          forcibly removed, leaving client with a dangling pointer */
+       *lockspace = (void *)local_id;
+
+       return 0;
+
+      out_reg:
+       kcl_unregister_service(ls->ls_local_id);
+
+      out_idtblfree:
+       free_lockidtbl(ls);
+
+      out_htfree:
+       kfree(ls->ls_reshashtbl);
+
+      out_lsfree:
+       free_ls(ls);
+
+      out:
+       return error;
+}
+
+/*
+ * Called by a system like GFS which wants independent lock spaces.
+ */
+
+int dlm_new_lockspace(char *name, int namelen, void **lockspace, int flags)
+{
+       int error = -ENOSYS;
+
+       down(&gdlmstate_lock);
+
+       error = init_internal();
+       if (error)
+               goto out;
+
+       error = new_lockspace(name, namelen, lockspace, flags);
+
+      out:
+       up(&gdlmstate_lock);
+
+       return error;
+}
+
+/* Return 1 if the lockspace still has active remote locks,
+ *        2 if the lockspace still has active local locks.
+ */
+static int lockspace_busy(gd_ls_t *ls)
+{
+    int i;
+    int lkb_found = 0;
+    gd_lkb_t *lkb;
+
+    /* NOTE: We check the lockidtbl here rather than the resource table.
+     * This is because there may be LKBs queued as ASTs that have been unlinked
+     * from their RSBs and are pending deletion once the AST has been delivered
+     */
+    read_lock(&ls->ls_lockidtbl_lock);
+    for (i = 0; i < ls->ls_lockidtbl_size; i++) {
+       if (!list_empty(&ls->ls_lockidtbl[i].list)) {
+           lkb_found = 1;
+           list_for_each_entry(lkb, &ls->ls_lockidtbl[i].list, lkb_idtbl_list) {
+               if (!lkb->lkb_nodeid) {
+                   read_unlock(&ls->ls_lockidtbl_lock);
+                   return 2;
+               }
+           }
+       }
+    }
+    read_unlock(&ls->ls_lockidtbl_lock);
+    return lkb_found;
+}
+
+/* Actually release the lockspace */
+static int release_lockspace(gd_ls_t *ls, int force)
+{
+       gd_lkb_t *lkb;
+       gd_res_t *rsb;
+       gd_recover_t *gr;
+       gd_csb_t *csb;
+       struct list_head *head;
+       int i;
+       int busy = lockspace_busy(ls);
+
+       /* Don't destroy a busy lockspace */
+       if (busy > force)
+               return -EBUSY;
+
+       if (force < 3) {
+               kcl_leave_service(ls->ls_local_id);
+               kcl_unregister_service(ls->ls_local_id);
+       }
+
+       spin_lock(&lslist_lock);
+       list_del(&ls->ls_list);
+       spin_unlock(&lslist_lock);
+
+       /*
+        * Free resdata structs.
+        */
+
+       resdir_clear(ls);
+
+       /*
+        * Free all lkb's on lockidtbl[] lists.
+        */
+
+       for (i = 0; i < ls->ls_lockidtbl_size; i++) {
+               head = &ls->ls_lockidtbl[i].list;
+               while (!list_empty(head)) {
+                       lkb = list_entry(head->next, gd_lkb_t, lkb_idtbl_list);
+                       list_del(&lkb->lkb_idtbl_list);
+
+                       if (lkb->lkb_lockqueue_state)
+                               remove_from_lockqueue(lkb);
+
+                       if (lkb->lkb_asts_to_deliver)
+                               list_del(&lkb->lkb_astqueue);
+
+                       if (lkb->lkb_lvbptr
+                           && lkb->lkb_flags & GDLM_LKFLG_MSTCPY)
+                               free_lvb(lkb->lkb_lvbptr);
+
+                       free_lkb(lkb);
+               }
+       }
+
+       /*
+        * Free lkidtbl[] itself
+        */
+
+       kfree(ls->ls_lockidtbl);
+
+       /*
+        * Free all rsb's on reshashtbl[] lists
+        */
+
+       for (i = 0; i < ls->ls_hashsize; i++) {
+               head = &ls->ls_reshashtbl[i];
+               while (!list_empty(head)) {
+                       rsb = list_entry(head->next, gd_res_t, res_hashchain);
+                       list_del(&rsb->res_hashchain);
+
+                       if (rsb->res_lvbptr)
+                               free_lvb(rsb->res_lvbptr);
+
+                       free_rsb(rsb);
+               }
+       }
+
+       /*
+        * Free reshashtbl[] itself
+        */
+
+       kfree(ls->ls_reshashtbl);
+
+       /*
+        * Free structures on any other lists
+        */
+
+       head = &ls->ls_recover;
+       while (!list_empty(head)) {
+               gr = list_entry(head->next, gd_recover_t, gr_list);
+               list_del(&gr->gr_list);
+               free_dlm_recover(gr);
+       }
+
+       head = &ls->ls_nodes;
+       while (!list_empty(head)) {
+               csb = list_entry(head->next, gd_csb_t, csb_list);
+               list_del(&csb->csb_list);
+               release_csb(csb);
+       }
+
+       head = &ls->ls_nodes_gone;
+       while (!list_empty(head)) {
+               csb = list_entry(head->next, gd_csb_t, csb_list);
+               list_del(&csb->csb_list);
+               release_csb(csb);
+       }
+
+       free_ls(ls);
+
+       dlm_release();
+
+       module_put(THIS_MODULE);
+       return 0;
+}
+
+
+/*
+ * Called when a system has released all its locks and is not going to use the
+ * lockspace any longer.  We blindly free everything we're managing for this
+ * lockspace.  Remaining nodes will go through the recovery process as if we'd
+ * died.  The lockspace must continue to function as usual, participating in
+ * recoveries, until kcl_leave_service returns.
+ *
+ * Force has 4 possible values:
+ * 0 - don't destroy locksapce if it has any LKBs
+ * 1 - destroy lockspace if it has remote LKBs but not if it has local LKBs
+ * 2 - destroy lockspace regardless of LKBs
+ * 3 - destroy lockspace as part of a forced shutdown
+ */
+
+int dlm_release_lockspace(void *lockspace, int force)
+{
+       gd_ls_t *ls;
+
+       ls = find_lockspace_by_local_id(lockspace);
+       if (!ls)
+           return -EINVAL;
+
+       return release_lockspace(ls, force);
+}
+
+
+/* Called when the cluster is being shut down dirtily */
+void dlm_emergency_shutdown()
+{
+       gd_ls_t *ls;
+       gd_ls_t *tmp;
+
+       /* Shut lowcomms down to prevent any socket activity */
+       lowcomms_stop_accept();
+
+       /* Delete the devices that belong the the userland
+          lockspaces to be deleted. */
+       dlm_device_free_devices();
+
+       /* Now try to clean the lockspaces */
+       spin_lock(&lslist_lock);
+
+       list_for_each_entry_safe(ls, tmp, &lslist, ls_list) {
+               spin_unlock(&lslist_lock);
+               release_lockspace(ls, 3);
+               spin_lock(&lslist_lock);
+       }
+
+       spin_unlock(&lslist_lock);
+}
+
+gd_recover_t *allocate_dlm_recover(void)
+{
+       gd_recover_t *gr;
+
+       gr = (gd_recover_t *) kmalloc(sizeof(gd_recover_t), GFP_KERNEL);
+       if (gr)
+               memset(gr, 0, sizeof(gd_recover_t));
+
+       return gr;
+}
+
+void free_dlm_recover(gd_recover_t * gr)
+{
+       kfree(gr);
+}
+
+/*
+ * Called by CMAN on a specific ls.  "stop" means set flag which while set
+ * causes all new requests to ls to be queued and not submitted until flag is
+ * cleared.  stop on a ls also needs to cancel any prior starts on the ls.
+ * The recoverd thread carries out any work called for by this event.
+ */
+
+static int dlm_ls_stop(void *servicedata)
+{
+       gd_ls_t *ls = (gd_ls_t *) servicedata;
+       int new;
+
+       spin_lock(&ls->ls_recover_lock);
+       ls->ls_last_stop = ls->ls_last_start;
+       set_bit(LSFL_LS_STOP, &ls->ls_flags);
+       new = test_and_clear_bit(LSFL_LS_RUN, &ls->ls_flags);
+       spin_unlock(&ls->ls_recover_lock);
+
+       /*
+        * This in_recovery lock does two things:
+        *
+        * 1) Keeps this function from returning until all threads are out
+        *    of locking routines and locking is truely stopped.
+        * 2) Keeps any new requests from being processed until it's unlocked
+        *    when recovery is complete.
+        */
+
+       if (new)
+               down_write(&ls->ls_in_recovery);
+
+       clear_bit(LSFL_RESDIR_VALID, &ls->ls_flags);
+       clear_bit(LSFL_ALL_RESDIR_VALID, &ls->ls_flags);
+       clear_bit(LSFL_NODES_VALID, &ls->ls_flags);
+       clear_bit(LSFL_ALL_NODES_VALID, &ls->ls_flags);
+
+       recoverd_kick(ls);
+
+       return 0;
+}
+
+/*
+ * Called by CMAN on a specific ls.  "start" means enable the lockspace to do
+ * request processing which first requires that the recovery procedure be
+ * stepped through with all nodes sharing the lockspace (nodeids).  The first
+ * start on the ls after it's created is a special case and requires some extra
+ * work like figuring out our own local nodeid.  We can't do all this in the
+ * calling CMAN context, so we must pass this work off to the recoverd thread
+ * which was created in gdlm_init().  The recoverd thread carries out any work
+ * called for by this event.
+ */
+
+static int dlm_ls_start(void *servicedata, uint32_t *nodeids, int count,
+                       int event_id, int type)
+{
+       gd_ls_t *ls = (gd_ls_t *) servicedata;
+       gd_recover_t *gr;
+       int error = -ENOMEM;
+
+       gr = allocate_dlm_recover();
+       if (!gr)
+               goto out;
+
+       gr->gr_nodeids = nodeids;
+       gr->gr_node_count = count;
+       gr->gr_event_id = event_id;
+
+       spin_lock(&ls->ls_recover_lock);
+       ls->ls_last_start = event_id;
+       list_add_tail(&gr->gr_list, &ls->ls_recover);
+       set_bit(LSFL_LS_START, &ls->ls_flags);
+       spin_unlock(&ls->ls_recover_lock);
+
+       recoverd_kick(ls);
+       error = 0;
+
+      out:
+       return error;
+}
+
+/*
+ * Called by CMAN on a specific ls.  "finish" means that all nodes which
+ * received a "start" have completed the start and called kcl_start_done.
+ * The recoverd thread carries out any work called for by this event.
+ */
+
+static void dlm_ls_finish(void *servicedata, int event_id)
+{
+       gd_ls_t *ls = (gd_ls_t *) servicedata;
+
+       spin_lock(&ls->ls_recover_lock);
+       ls->ls_last_finish = event_id;
+       set_bit(LSFL_LS_FINISH, &ls->ls_flags);
+       spin_unlock(&ls->ls_recover_lock);
+
+       recoverd_kick(ls);
+}
+
+struct kcl_service_ops ls_ops = {
+       .stop = dlm_ls_stop,
+       .start = dlm_ls_start,
+       .finish = dlm_ls_finish
+};
diff -urN linux-orig/cluster/dlm/lockspace.h linux-patched/cluster/dlm/lockspace.h
--- linux-orig/cluster/dlm/lockspace.h  1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/lockspace.h       2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,29 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __LOCKSPACE_DOT_H__
+#define __LOCKSPACE_DOT_H__
+
+void dlm_lockspace_init(void);
+int dlm_init(void);
+int dlm_release(void);
+int dlm_new_lockspace(char *name, int namelen, void **ls, int flags);
+int dlm_release_lockspace(void *ls, int force);
+gd_ls_t *find_lockspace_by_global_id(uint32_t id);
+gd_ls_t *find_lockspace_by_local_id(void *id);
+gd_ls_t *find_lockspace_by_name(char *name, int namelen);
+void free_dlm_recover(gd_recover_t *gr);
+int next_move(gd_ls_t *ls, gd_recover_t **gr_out, int *finish_out);
+void dlm_emergency_shutdown(void);
+
+#endif                         /* __LOCKSPACE_DOT_H__ */
diff -urN linux-orig/cluster/dlm/lowcomms.c linux-patched/cluster/dlm/lowcomms.c
--- linux-orig/cluster/dlm/lowcomms.c   1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/lowcomms.c        2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,1354 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/*
+ * lowcomms.c
+ *
+ * This is the "low-level" comms layer.
+ *
+ * It is responsible for sending/receiving messages
+ * from other nodes in the cluster.
+ *
+ * Cluster nodes are referred to by their nodeids. nodeids are
+ * simply 32 bit numbers to the locking module - if they need to
+ * be expanded for the cluster infrastructure then that is it's
+ * responsibility. It is this layer's
+ * responsibility to resolve these into IP address or
+ * whatever it needs for inter-node communication.
+ *
+ * The comms level is two kernel threads that deal mainly with
+ * the receiving of messages from other nodes and passing them
+ * up to the mid-level comms layer (which understands the
+ * message format) for execution by the locking core, and
+ * a send thread which does all the setting up of connections
+ * to remote nodes and the sending of data. Threads are not allowed
+ * to send their own data because it may cause them to wait in times
+ * of high load. Also, this way, the sending thread can collect together
+ * messages bound for one node and send them in one block.
+ *
+ * I don't see any problem with the recv thread executing the locking
+ * code on behalf of remote processes as the locking code is
+ * short, efficient and never waits.
+ *
+ */
+
+
+#include <asm/ioctls.h>
+#include <net/sock.h>
+#include <net/tcp.h>
+#include <linux/pagemap.h>
+#include <cluster/cnxman.h>
+
+#include "dlm_internal.h"
+#include "lowcomms.h"
+#include "midcomms.h"
+#include "config.h"
+
+struct cbuf {
+       unsigned base;
+       unsigned len;
+       unsigned mask;
+};
+
+#define CBUF_INIT(cb, size) do { (cb)->base = (cb)->len = 0; (cb)->mask = ((size)-1); } while(0)
+#define CBUF_ADD(cb, n) do { (cb)->len += n; } while(0)
+#define CBUF_EMPTY(cb) ((cb)->len == 0)
+#define CBUF_MAY_ADD(cb, n) (((cb)->len + (n)) < ((cb)->mask + 1))
+#define CBUF_EAT(cb, n) do { (cb)->len  -= (n); \
+                             (cb)->base += (n); (cb)->base &= (cb)->mask; } while(0)
+#define CBUF_DATA(cb) (((cb)->base + (cb)->len) & (cb)->mask)
+
+struct connection {
+       struct socket *sock;    /* NULL if not connected */
+       uint32_t nodeid;        /* So we know who we are in the list */
+       struct rw_semaphore sock_sem;   /* Stop connect races */
+       struct list_head read_list;     /* On this list when ready for reading */
+       struct list_head write_list;    /* On this list when ready for writing */
+       struct list_head state_list;    /* On this list when ready to connect */
+       unsigned long flags;    /* bit 1,2 = We are on the read/write lists */
+#define CF_READ_PENDING 1
+#define CF_WRITE_PENDING 2
+#define CF_CONNECT_PENDING 3
+#define CF_IS_OTHERSOCK 4
+       struct list_head writequeue;    /* List of outgoing writequeue_entries */
+       struct list_head listenlist;    /* List of allocated listening sockets */
+       spinlock_t writequeue_lock;
+       int (*rx_action) (struct connection *); /* What to do when active */
+       struct page *rx_page;
+       struct cbuf cb;
+       int retries;
+#define MAX_CONNECT_RETRIES 3
+       struct connection *othersock;
+};
+#define sock2con(x) ((struct connection *)(x)->sk_user_data)
+#define nodeid2con(x) (&connections[(x)])
+
+/* An entry waiting to be sent */
+struct writequeue_entry {
+       struct list_head list;
+       struct page *page;
+       int offset;
+       int len;
+       int end;
+       int users;
+       struct connection *con;
+};
+
+/* "Template" structure for IPv4 and IPv6 used to fill
+ * in the missing bits when converting between cman (which knows
+ * nothing about sockaddr structs) and real life where we actually
+ * have to connect to these addresses. Also one of these structs
+ * will hold the cached "us" address.
+ *
+ * It's an in6 sockaddr just so there's enough space for anything
+ * we're likely to see here.
+ */
+static struct sockaddr_in6 local_addr;
+
+/* Manage daemons */
+static struct semaphore thread_lock;
+static struct completion thread_completion;
+static atomic_t send_run;
+static atomic_t recv_run;
+
+/* An array of connections, indexed by NODEID */
+static struct connection *connections;
+static int conn_array_size;
+static atomic_t writequeue_length;
+static atomic_t accepting;
+
+static wait_queue_t lowcomms_send_waitq_head;
+static wait_queue_head_t lowcomms_send_waitq;
+
+static wait_queue_t lowcomms_recv_waitq_head;
+static wait_queue_head_t lowcomms_recv_waitq;
+
+/* List of sockets that have reads pending */
+static struct list_head read_sockets;
+static spinlock_t read_sockets_lock;
+
+/* List of sockets which have writes pending */
+static struct list_head write_sockets;
+static spinlock_t write_sockets_lock;
+
+/* List of sockets which have connects pending */
+static struct list_head state_sockets;
+static spinlock_t state_sockets_lock;
+
+/* List of allocated listen sockets */
+static struct list_head listen_sockets;
+
+static int lowcomms_ipaddr_from_nodeid(int nodeid, struct sockaddr *retaddr);
+static int lowcomms_nodeid_from_ipaddr(struct sockaddr *addr, int addr_len);
+
+
+/* Data available on socket or listen socket received a connect */
+static void lowcomms_data_ready(struct sock *sk, int count_unused)
+{
+       struct connection *con = sock2con(sk);
+
+       if (test_and_set_bit(CF_READ_PENDING, &con->flags))
+               return;
+
+       spin_lock_bh(&read_sockets_lock);
+       list_add_tail(&con->read_list, &read_sockets);
+       spin_unlock_bh(&read_sockets_lock);
+
+       wake_up_interruptible(&lowcomms_recv_waitq);
+}
+
+static void lowcomms_write_space(struct sock *sk)
+{
+       struct connection *con = sock2con(sk);
+
+       if (test_and_set_bit(CF_WRITE_PENDING, &con->flags))
+               return;
+
+       spin_lock_bh(&write_sockets_lock);
+       list_add_tail(&con->write_list, &write_sockets);
+       spin_unlock_bh(&write_sockets_lock);
+
+       wake_up_interruptible(&lowcomms_send_waitq);
+}
+
+static inline void lowcomms_connect_sock(struct connection *con)
+{
+       if (test_and_set_bit(CF_CONNECT_PENDING, &con->flags))
+               return;
+       if (!atomic_read(&accepting))
+               return;
+
+       spin_lock_bh(&state_sockets_lock);
+       list_add_tail(&con->state_list, &state_sockets);
+       spin_unlock_bh(&state_sockets_lock);
+
+       wake_up_interruptible(&lowcomms_send_waitq);
+}
+
+static void lowcomms_state_change(struct sock *sk)
+{
+/*     struct connection *con = sock2con(sk); */
+
+       switch (sk->sk_state) {
+       case TCP_ESTABLISHED:
+               lowcomms_write_space(sk);
+               break;
+
+       case TCP_FIN_WAIT1:
+       case TCP_FIN_WAIT2:
+       case TCP_TIME_WAIT:
+       case TCP_CLOSE:
+       case TCP_CLOSE_WAIT:
+       case TCP_LAST_ACK:
+       case TCP_CLOSING:
+               /* FIXME: I think this causes more trouble than it solves.
+                  lowcomms wil reconnect anyway when there is something to
+                  send. This just attempts reconnection if a node goes down!
+               */
+               /* lowcomms_connect_sock(con); */
+               break;
+
+       default:
+               printk("dlm: lowcomms_state_change: state=%d\n", sk->sk_state);
+               break;
+       }
+}
+
+/* Make a socket active */
+static int add_sock(struct socket *sock, struct connection *con)
+{
+       con->sock = sock;
+
+       /* Install a data_ready callback */
+       con->sock->sk->sk_data_ready = lowcomms_data_ready;
+       con->sock->sk->sk_write_space = lowcomms_write_space;
+       con->sock->sk->sk_state_change = lowcomms_state_change;
+
+       return 0;
+}
+
+/* Add the port number to an IP6 or 4 sockaddr and return the address
+   length */
+static void make_sockaddr(struct sockaddr_in6 *saddr, uint16_t port,
+                         int *addr_len)
+{
+        saddr->sin6_family = local_addr.sin6_family;
+        if (local_addr.sin6_family == AF_INET) {
+           struct sockaddr_in *in4_addr = (struct sockaddr_in *)saddr;
+           in4_addr->sin_port = cpu_to_be16(port);
+           *addr_len = sizeof(struct sockaddr_in);
+       }
+       else {
+           saddr->sin6_port = cpu_to_be16(port);
+           *addr_len = sizeof(struct sockaddr_in6);
+       }
+}
+
+/* Close a remote connection and tidy up */
+static void close_connection(struct connection *con)
+{
+       if (test_bit(CF_IS_OTHERSOCK, &con->flags))
+               return;
+
+       down_write(&con->sock_sem);
+
+       if (con->sock) {
+               sock_release(con->sock);
+               con->sock = NULL;
+               if (con->othersock) {
+                       down_write(&con->othersock->sock_sem);
+                       sock_release(con->othersock->sock);
+                       con->othersock->sock = NULL;
+                       up_write(&con->othersock->sock_sem);
+                       kfree(con->othersock);
+                       con->othersock = NULL;
+               }
+       }
+       if (con->rx_page) {
+               __free_page(con->rx_page);
+               con->rx_page = NULL;
+       }
+       up_write(&con->sock_sem);
+}
+
+/* Data received from remote end */
+static int receive_from_sock(struct connection *con)
+{
+       int ret = 0;
+       struct msghdr msg;
+       struct iovec iov[2];
+       mm_segment_t fs;
+       unsigned len;
+       int r;
+       int call_again_soon = 0;
+
+       down_read(&con->sock_sem);
+
+       if (con->sock == NULL)
+               goto out;
+       if (con->rx_page == NULL) {
+               /*
+                * This doesn't need to be atomic, but I think it should
+                * improve performance if it is.
+                */
+               con->rx_page = alloc_page(GFP_ATOMIC);
+               if (con->rx_page == NULL)
+                       goto out_resched;
+               CBUF_INIT(&con->cb, PAGE_CACHE_SIZE);
+       }
+       /*
+        * To avoid doing too many short reads, we will reschedule for another
+        * another time if there are less than 32 bytes left in the buffer.
+        */
+       if (!CBUF_MAY_ADD(&con->cb, 32))
+               goto out_resched;
+
+       msg.msg_control = NULL;
+       msg.msg_controllen = 0;
+       msg.msg_iovlen = 1;
+       msg.msg_iov = iov;
+       msg.msg_name = NULL;
+       msg.msg_namelen = 0;
+       msg.msg_flags = 0;
+
+       /*
+        * iov[0] is the bit of the circular buffer between the current end
+        * point (cb.base + cb.len) and the end of the buffer.
+        */
+       iov[0].iov_len = con->cb.base - CBUF_DATA(&con->cb);
+       iov[0].iov_base = page_address(con->rx_page) + CBUF_DATA(&con->cb);
+       iov[1].iov_len = 0;
+
+       /*
+        * iov[1] is the bit of the circular buffer between the start of the
+        * buffer and the start of the currently used section (cb.base)
+        */
+       if (CBUF_DATA(&con->cb) >= con->cb.base) {
+               iov[0].iov_len = PAGE_CACHE_SIZE - CBUF_DATA(&con->cb);
+               iov[1].iov_len = con->cb.base;
+               iov[1].iov_base = page_address(con->rx_page);
+               msg.msg_iovlen = 2;
+       }
+       len = iov[0].iov_len + iov[1].iov_len;
+
+       fs = get_fs();
+       set_fs(get_ds());
+       r = ret = sock_recvmsg(con->sock, &msg, len,
+                              MSG_DONTWAIT | MSG_NOSIGNAL);
+       set_fs(fs);
+
+       if (ret <= 0)
+               goto out_close;
+       if (ret == len)
+               call_again_soon = 1;
+       CBUF_ADD(&con->cb, ret);
+       ret = midcomms_process_incoming_buffer(con->nodeid,
+                                              page_address(con->rx_page),
+                                              con->cb.base, con->cb.len,
+                                              PAGE_CACHE_SIZE);
+       if (ret == -EBADMSG) {
+               printk(KERN_INFO "dlm: lowcomms: addr=%p, base=%u, len=%u, "
+                      "iov_len=%u, iov_base[0]=%p, read=%d\n",
+                      page_address(con->rx_page), con->cb.base, con->cb.len,
+                      len, iov[0].iov_base, r);
+       }
+       if (ret < 0)
+               goto out_close;
+       CBUF_EAT(&con->cb, ret);
+
+       if (CBUF_EMPTY(&con->cb) && !call_again_soon) {
+               __free_page(con->rx_page);
+               con->rx_page = NULL;
+       }
+      out:
+       if (call_again_soon)
+               goto out_resched;
+       up_read(&con->sock_sem);
+       ret = 0;
+       goto out_ret;
+
+      out_resched:
+       lowcomms_data_ready(con->sock->sk, 0);
+       up_read(&con->sock_sem);
+       ret = 0;
+       goto out_ret;
+
+      out_close:
+       up_read(&con->sock_sem);
+       if (ret != -EAGAIN && !test_bit(CF_IS_OTHERSOCK, &con->flags)) {
+               close_connection(con);
+               lowcomms_connect_sock(con);
+       }
+
+      out_ret:
+       return ret;
+}
+
+/* Listening socket is busy, accept a connection */
+static int accept_from_sock(struct connection *con)
+{
+       int result;
+       struct sockaddr_in6 peeraddr;
+       struct socket *newsock;
+       int len;
+       int nodeid;
+       struct connection *newcon;
+
+       memset(&peeraddr, 0, sizeof(peeraddr));
+       newsock = sock_alloc();
+       if (!newsock)
+               return -ENOMEM;
+
+       down_read(&con->sock_sem);
+
+       result = -ENOTCONN;
+       if (con->sock == NULL)
+               goto accept_err;
+
+       newsock->type = con->sock->type;
+       newsock->ops = con->sock->ops;
+
+       result = con->sock->ops->accept(con->sock, newsock, O_NONBLOCK);
+       if (result < 0)
+               goto accept_err;
+
+       /* Get the connected socket's peer */
+       if (newsock->ops->getname(newsock, (struct sockaddr *)&peeraddr,
+                                 &len, 2)) {
+               result = -ECONNABORTED;
+               goto accept_err;
+       }
+
+       /* Get the new node's NODEID */
+       nodeid = lowcomms_nodeid_from_ipaddr((struct sockaddr *)&peeraddr, len);
+       if (nodeid == 0) {
+               printk("dlm: connect from non cluster node\n");
+               sock_release(newsock);
+               up_read(&con->sock_sem);
+               return -1;
+       }
+
+       log_print("got connection from %d", nodeid);
+
+       /*  Check to see if we already have a connection to this node. This
+        *  could happen if the two nodes initiate a connection at roughly
+        *  the same time and the connections cross on the wire.
+        * TEMPORARY FIX:
+        *  In this case we store the incoming one in "othersock"
+        */
+       newcon = nodeid2con(nodeid);
+       down_write(&newcon->sock_sem);
+       if (newcon->sock) {
+               struct connection *othercon;
+
+               othercon = kmalloc(sizeof(struct connection), GFP_KERNEL);
+               if (!othercon) {
+                       printk("dlm: failed to allocate incoming socket\n");
+                       sock_release(newsock);
+                       up_write(&newcon->sock_sem);
+                       up_read(&con->sock_sem);
+                       goto accept_out;
+               }
+               memset(othercon, 0, sizeof(*othercon));
+               newcon->othersock = othercon;
+               othercon->nodeid = nodeid;
+               othercon->sock = newsock;
+               othercon->rx_action = receive_from_sock;
+               add_sock(newsock, othercon);
+               init_rwsem(&othercon->sock_sem);
+               set_bit(CF_IS_OTHERSOCK, &othercon->flags);
+               newsock->sk->sk_user_data = othercon;
+
+               up_write(&newcon->sock_sem);
+               lowcomms_data_ready(newsock->sk, 0);
+               up_read(&con->sock_sem);
+               goto accept_out;
+       }
+
+       newsock->sk->sk_user_data = newcon;
+       newcon->rx_action = receive_from_sock;
+       add_sock(newsock, newcon);
+       up_write(&newcon->sock_sem);
+
+       /*
+        * Add it to the active queue in case we got data
+        * beween processing the accept adding the socket
+        * to the read_sockets list
+        */
+       lowcomms_data_ready(newsock->sk, 0);
+
+       up_read(&con->sock_sem);
+
+      accept_out:
+       return 0;
+
+      accept_err:
+       up_read(&con->sock_sem);
+       sock_release(newsock);
+
+       printk("dlm: error accepting connection from node: %d\n", result);
+       return result;
+}
+
+/* Connect a new socket to its peer */
+static int connect_to_sock(struct connection *con)
+{
+       int result = -EHOSTUNREACH;
+       struct sockaddr_in6 saddr;
+       int addr_len;
+       struct socket *sock;
+
+       if (con->nodeid == 0) {
+               log_print("attempt to connect sock 0 foiled");
+               return 0;
+       }
+
+       down_write(&con->sock_sem);
+       if (con->retries++ > MAX_CONNECT_RETRIES)
+               goto out;
+
+       // FIXME not sure this should happen, let alone like this.
+       if (con->sock) {
+               sock_release(con->sock);
+               con->sock = NULL;
+       }
+
+       /* Create a socket to communicate with */
+       result = sock_create_kern(local_addr.sin6_family, SOCK_STREAM, IPPROTO_TCP, &sock);
+       if (result < 0)
+               goto out_err;
+
+       if (lowcomms_ipaddr_from_nodeid(con->nodeid, (struct sockaddr *)&saddr) < 0)
+               goto out_err;
+
+       sock->sk->sk_user_data = con;
+       con->rx_action = receive_from_sock;
+
+       make_sockaddr(&saddr, dlm_config.tcp_port, &addr_len);
+
+       add_sock(sock, con);
+       result =
+           sock->ops->connect(sock, (struct sockaddr *) &saddr, addr_len,
+                              O_NONBLOCK);
+       if (result == -EINPROGRESS)
+               result = 0;
+       if (result != 0)
+               goto out_err;
+
+      out:
+       up_write(&con->sock_sem);
+       /*
+        * Returning an error here means we've given up trying to connect to
+        * a remote node, otherwise we return 0 and reschedule the connetion
+        * attempt
+        */
+       return result;
+
+      out_err:
+       if (con->sock) {
+               sock_release(con->sock);
+               con->sock = NULL;
+       }
+       /*
+        * Some errors are fatal and this list might need adjusting. For other
+        * errors we try again until the max number of retries is reached.
+        */
+       if (result != -EHOSTUNREACH && result != -ENETUNREACH &&
+           result != -ENETDOWN && result != EINVAL
+           && result != -EPROTONOSUPPORT) {
+               lowcomms_connect_sock(con);
+               result = 0;
+       }
+       goto out;
+}
+
+static struct socket *create_listen_sock(struct connection *con, char *addr, int addr_len)
+{
+        struct socket *sock = NULL;
+       mm_segment_t fs;
+       int result = 0;
+       int one = 1;
+       struct sockaddr_in6 *saddr = (struct sockaddr_in6 *)addr;
+
+       /* Create a socket to communicate with */
+       result = sock_create_kern(local_addr.sin6_family, SOCK_STREAM, IPPROTO_TCP, &sock);
+       if (result < 0) {
+               printk("dlm: Can't create listening comms socket\n");
+               goto create_out;
+       }
+
+       fs = get_fs();
+       set_fs(get_ds());
+       result = sock_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));
+       set_fs(fs);
+       if (result < 0) {
+               printk("dlm: Failed to set SO_REUSEADDR on socket: result=%d\n",result);
+       }
+       sock->sk->sk_user_data = con;
+       con->rx_action = accept_from_sock;
+       con->sock = sock;
+
+       /* Bind to our port */
+       make_sockaddr(saddr, dlm_config.tcp_port, &addr_len);
+       result = sock->ops->bind(sock, (struct sockaddr *) saddr, addr_len);
+       if (result < 0) {
+               printk("dlm: Can't bind to port %d\n", dlm_config.tcp_port);
+               sock_release(sock);
+               sock = NULL;
+               goto create_out;
+       }
+
+       fs = get_fs();
+       set_fs(get_ds());
+
+       result = sock_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *)&one, sizeof(one));
+       set_fs(fs);
+       if (result < 0) {
+               printk("dlm: Set keepalive failed: %d\n", result);
+       }
+
+       result = sock->ops->listen(sock, 5);
+       if (result < 0) {
+               printk("dlm: Can't listen on port %d\n", dlm_config.tcp_port);
+               sock_release(sock);
+               sock = NULL;
+               goto create_out;
+       }
+
+      create_out:
+       return sock;
+}
+
+
+/* Listen on all interfaces */
+static int listen_for_all(void)
+{
+       int result = 0;
+       int nodeid;
+       struct socket *sock = NULL;
+       struct list_head *addr_list;
+       struct connection *con = nodeid2con(0);
+       struct cluster_node_addr *node_addr;
+       char local_addr[sizeof(struct sockaddr_in6)];
+
+       /* This will also fill in local_addr */
+       nodeid = lowcomms_our_nodeid();
+
+       addr_list = kcl_get_node_addresses(nodeid);
+       if (!addr_list) {
+               printk("dlm: cannot initialise comms layer\n");
+               result = -ENOTCONN;
+               goto create_out;
+       }
+
+       list_for_each_entry(node_addr, addr_list, list) {
+
+               if (!con) {
+                       con = kmalloc(sizeof(struct connection), GFP_KERNEL);
+                       if (!con) {
+                               printk("dlm: failed to allocate listen socket\n");
+                               goto create_out;
+                       }
+                       memset(con, 0, sizeof(*con));
+                       init_rwsem(&con->sock_sem);
+                       spin_lock_init(&con->writequeue_lock);
+                       INIT_LIST_HEAD(&con->writequeue);
+                       set_bit(CF_IS_OTHERSOCK, &con->flags);
+               }
+
+               memcpy(local_addr, node_addr->addr, node_addr->addr_len);
+               sock = create_listen_sock(con, local_addr,
+                                         node_addr->addr_len);
+               if (sock) {
+                       add_sock(sock, con);
+               }
+               else {
+                       kfree(con);
+               }
+
+               /* Keep a list of dynamically allocated listening sockets
+                  so we can free them at shutdown */
+               if (test_bit(CF_IS_OTHERSOCK, &con->flags)) {
+                       list_add_tail(&con->listenlist, &listen_sockets);
+               }
+               con = NULL;
+       }
+
+      create_out:
+       return result;
+}
+
+
+
+static struct writequeue_entry *new_writequeue_entry(struct connection *con,
+                                                    int allocation)
+{
+       struct writequeue_entry *entry;
+
+       entry = kmalloc(sizeof(struct writequeue_entry), allocation);
+       if (!entry)
+               return NULL;
+
+       entry->page = alloc_page(allocation);
+       if (!entry->page) {
+               kfree(entry);
+               return NULL;
+       }
+
+       entry->offset = 0;
+       entry->len = 0;
+       entry->end = 0;
+       entry->users = 0;
+       entry->con = con;
+
+       return entry;
+}
+
+struct writequeue_entry *lowcomms_get_buffer(int nodeid, int len,
+                                            int allocation, char **ppc)
+{
+       struct connection *con = nodeid2con(nodeid);
+       struct writequeue_entry *e;
+       int offset = 0;
+       int users = 0;
+
+       if (!atomic_read(&accepting))
+               return NULL;
+
+       spin_lock(&con->writequeue_lock);
+       e = list_entry(con->writequeue.prev, struct writequeue_entry, list);
+       if (((struct list_head *) e == &con->writequeue) ||
+           (PAGE_CACHE_SIZE - e->end < len)) {
+               e = NULL;
+       } else {
+               offset = e->end;
+               e->end += len;
+               users = e->users++;
+       }
+       spin_unlock(&con->writequeue_lock);
+
+       if (e) {
+             got_one:
+               if (users == 0)
+                       kmap(e->page);
+               *ppc = page_address(e->page) + offset;
+               return e;
+       }
+
+       e = new_writequeue_entry(con, allocation);
+       if (e) {
+               spin_lock(&con->writequeue_lock);
+               offset = e->end;
+               e->end += len;
+               users = e->users++;
+               list_add_tail(&e->list, &con->writequeue);
+               spin_unlock(&con->writequeue_lock);
+               atomic_inc(&writequeue_length);
+               goto got_one;
+       }
+       return NULL;
+}
+
+void lowcomms_commit_buffer(struct writequeue_entry *e)
+{
+       struct connection *con = e->con;
+       int users;
+
+       if (!atomic_read(&accepting))
+               return;
+
+       spin_lock(&con->writequeue_lock);
+       users = --e->users;
+       if (users)
+               goto out;
+       e->len = e->end - e->offset;
+       kunmap(e->page);
+       spin_unlock(&con->writequeue_lock);
+
+       if (test_and_set_bit(CF_WRITE_PENDING, &con->flags) == 0) {
+               spin_lock_bh(&write_sockets_lock);
+               list_add_tail(&con->write_list, &write_sockets);
+               spin_unlock_bh(&write_sockets_lock);
+
+               wake_up_interruptible(&lowcomms_send_waitq);
+       }
+       return;
+
+      out:
+       spin_unlock(&con->writequeue_lock);
+       return;
+}
+
+static void free_entry(struct writequeue_entry *e)
+{
+       __free_page(e->page);
+       kfree(e);
+       atomic_dec(&writequeue_length);
+}
+
+/* Send a message */
+static int send_to_sock(struct connection *con)
+{
+       int ret = 0;
+       ssize_t(*sendpage) (struct socket *, struct page *, int, size_t, int);
+       const int msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL;
+       struct writequeue_entry *e;
+       int len, offset;
+
+       down_read(&con->sock_sem);
+       if (con->sock == NULL)
+               goto out_connect;
+
+       sendpage = con->sock->ops->sendpage;
+
+       spin_lock(&con->writequeue_lock);
+       for (;;) {
+               e = list_entry(con->writequeue.next, struct writequeue_entry,
+                              list);
+               if ((struct list_head *) e == &con->writequeue)
+                       break;
+
+               len = e->len;
+               offset = e->offset;
+               BUG_ON(len == 0 && e->users == 0);
+               spin_unlock(&con->writequeue_lock);
+
+               ret = 0;
+               if (len) {
+                       ret = sendpage(con->sock, e->page, offset, len,
+                                      msg_flags);
+                       if (ret == -EAGAIN || ret == 0)
+                               goto out;
+                       if (ret <= 0)
+                               goto send_error;
+               }
+
+               spin_lock(&con->writequeue_lock);
+               e->offset += ret;
+               e->len -= ret;
+
+               if (e->len == 0 && e->users == 0) {
+                       list_del(&e->list);
+                       free_entry(e);
+                       continue;
+               }
+       }
+       spin_unlock(&con->writequeue_lock);
+      out:
+       up_read(&con->sock_sem);
+       return ret;
+
+      send_error:
+       up_read(&con->sock_sem);
+       close_connection(con);
+       lowcomms_connect_sock(con);
+       return ret;
+
+      out_connect:
+       up_read(&con->sock_sem);
+       lowcomms_connect_sock(con);
+       return 0;
+}
+
+/* Called from recoverd when it knows that a node has
+   left the cluster */
+int lowcomms_close(int nodeid)
+{
+       struct connection *con;
+
+       if (!connections)
+               goto out;
+
+       con = nodeid2con(nodeid);
+       if (con->sock) {
+               close_connection(con);
+               return 0;
+       }
+
+      out:
+       return -1;
+}
+
+/* API send message call, may queue the request */
+/* N.B. This is the old interface - use the new one for new calls */
+int lowcomms_send_message(int nodeid, char *buf, int len, int allocation)
+{
+       struct writequeue_entry *e;
+       char *b;
+
+       GDLM_ASSERT(nodeid < dlm_config.max_connections,
+                   printk("nodeid=%u\n", nodeid););
+
+       e = lowcomms_get_buffer(nodeid, len, allocation, &b);
+       if (e) {
+               memcpy(b, buf, len);
+               lowcomms_commit_buffer(e);
+               return 0;
+       }
+       return -ENOBUFS;
+}
+
+/* Look for activity on active sockets */
+static void process_sockets(void)
+{
+       struct list_head *list;
+       struct list_head *temp;
+
+       spin_lock_bh(&read_sockets_lock);
+       list_for_each_safe(list, temp, &read_sockets) {
+               struct connection *con =
+                   list_entry(list, struct connection, read_list);
+               list_del(&con->read_list);
+               clear_bit(CF_READ_PENDING, &con->flags);
+
+               spin_unlock_bh(&read_sockets_lock);
+
+               con->rx_action(con);
+
+               /* Don't starve out everyone else */
+               schedule();
+               spin_lock_bh(&read_sockets_lock);
+       }
+       spin_unlock_bh(&read_sockets_lock);
+}
+
+/* Try to send any messages that are pending
+ */
+static void process_output_queue(void)
+{
+       struct list_head *list;
+       struct list_head *temp;
+       int ret;
+
+       spin_lock_bh(&write_sockets_lock);
+       list_for_each_safe(list, temp, &write_sockets) {
+               struct connection *con =
+                   list_entry(list, struct connection, write_list);
+               list_del(&con->write_list);
+               clear_bit(CF_WRITE_PENDING, &con->flags);
+
+               spin_unlock_bh(&write_sockets_lock);
+
+               ret = send_to_sock(con);
+               if (ret < 0) {
+               }
+               spin_lock_bh(&write_sockets_lock);
+       }
+       spin_unlock_bh(&write_sockets_lock);
+}
+
+static void process_state_queue(void)
+{
+       struct list_head *list;
+       struct list_head *temp;
+       int ret;
+
+       spin_lock_bh(&state_sockets_lock);
+       list_for_each_safe(list, temp, &state_sockets) {
+               struct connection *con =
+                   list_entry(list, struct connection, state_list);
+               list_del(&con->state_list);
+               clear_bit(CF_CONNECT_PENDING, &con->flags);
+               spin_unlock_bh(&state_sockets_lock);
+
+               ret = connect_to_sock(con);
+               if (ret < 0) {
+               }
+               spin_lock_bh(&state_sockets_lock);
+       }
+       spin_unlock_bh(&state_sockets_lock);
+}
+
+/* Discard all entries on the write queues */
+static void clean_writequeues(void)
+{
+       struct list_head *list;
+       struct list_head *temp;
+       int nodeid;
+
+       for (nodeid = 1; nodeid < dlm_config.max_connections; nodeid++) {
+               struct connection *con = nodeid2con(nodeid);
+
+               spin_lock(&con->writequeue_lock);
+               list_for_each_safe(list, temp, &con->writequeue) {
+                       struct writequeue_entry *e =
+                           list_entry(list, struct writequeue_entry, list);
+                       list_del(&e->list);
+                       free_entry(e);
+               }
+               spin_unlock(&con->writequeue_lock);
+       }
+}
+
+static int read_list_empty(void)
+{
+       int status;
+
+       spin_lock_bh(&read_sockets_lock);
+       status = list_empty(&read_sockets);
+       spin_unlock_bh(&read_sockets_lock);
+
+       return status;
+}
+
+/* DLM Transport comms receive daemon */
+static int dlm_recvd(void *data)
+{
+       daemonize("dlm_recvd");
+       atomic_set(&recv_run, 1);
+
+       init_waitqueue_head(&lowcomms_recv_waitq);
+       init_waitqueue_entry(&lowcomms_recv_waitq_head, current);
+       add_wait_queue(&lowcomms_recv_waitq, &lowcomms_recv_waitq_head);
+
+       complete(&thread_completion);
+
+       while (atomic_read(&recv_run)) {
+
+               set_task_state(current, TASK_INTERRUPTIBLE);
+
+               if (read_list_empty())
+                       schedule();
+
+               set_task_state(current, TASK_RUNNING);
+
+               process_sockets();
+       }
+
+       down(&thread_lock);
+       up(&thread_lock);
+
+       complete(&thread_completion);
+
+       return 0;
+}
+
+static int write_and_state_lists_empty(void)
+{
+       int status;
+
+       spin_lock_bh(&write_sockets_lock);
+       status = list_empty(&write_sockets);
+       spin_unlock_bh(&write_sockets_lock);
+
+       spin_lock_bh(&state_sockets_lock);
+       if (list_empty(&state_sockets) == 0)
+               status = 0;
+       spin_unlock_bh(&state_sockets_lock);
+
+       return status;
+}
+
+/* DLM Transport send daemon */
+static int dlm_sendd(void *data)
+{
+       daemonize("dlm_sendd");
+       atomic_set(&send_run, 1);
+
+       init_waitqueue_head(&lowcomms_send_waitq);
+       init_waitqueue_entry(&lowcomms_send_waitq_head, current);
+       add_wait_queue(&lowcomms_send_waitq, &lowcomms_send_waitq_head);
+
+       complete(&thread_completion);
+
+       while (atomic_read(&send_run)) {
+
+               set_task_state(current, TASK_INTERRUPTIBLE);
+
+               if (write_and_state_lists_empty())
+                       schedule();
+
+               set_task_state(current, TASK_RUNNING);
+
+               process_state_queue();
+               process_output_queue();
+       }
+
+       down(&thread_lock);
+       up(&thread_lock);
+
+       complete(&thread_completion);
+
+       return 0;
+}
+
+static void daemons_stop(void)
+{
+       if (atomic_read(&recv_run)) {
+               down(&thread_lock);
+               atomic_set(&recv_run, 0);
+               wake_up_interruptible(&lowcomms_recv_waitq);
+               up(&thread_lock);
+               wait_for_completion(&thread_completion);
+       }
+
+       if (atomic_read(&send_run)) {
+               down(&thread_lock);
+               atomic_set(&send_run, 0);
+               wake_up_interruptible(&lowcomms_send_waitq);
+               up(&thread_lock);
+               wait_for_completion(&thread_completion);
+       }
+}
+
+static int daemons_start(void)
+{
+       int error;
+
+       error = kernel_thread(dlm_recvd, NULL, 0);
+       if (error < 0) {
+               log_print("can't start recvd thread: %d", error);
+               goto out;
+       }
+       wait_for_completion(&thread_completion);
+
+       error = kernel_thread(dlm_sendd, NULL, 0);
+       if (error < 0) {
+               log_print("can't start sendd thread: %d", error);
+               daemons_stop();
+               goto out;
+       }
+       wait_for_completion(&thread_completion);
+
+       error = 0;
+ out:
+       return error;
+}
+
+/*
+ * Return the largest buffer size we can cope with.
+ */
+int lowcomms_max_buffer_size(void)
+{
+       return PAGE_CACHE_SIZE;
+}
+
+void lowcomms_stop(void)
+{
+       int i;
+       struct connection *temp;
+       struct connection *lcon;
+
+       atomic_set(&accepting, 0);
+
+       /* Set all the activity flags to prevent any
+          socket activity.
+       */
+       for (i = 0; i < conn_array_size; i++) {
+               connections[i].flags = 0x7;
+       }
+       daemons_stop();
+       clean_writequeues();
+
+       for (i = 0; i < conn_array_size; i++) {
+               close_connection(nodeid2con(i));
+       }
+
+       kfree(connections);
+       connections = NULL;
+
+       /* Free up any dynamically allocated listening sockets */
+       list_for_each_entry_safe(lcon, temp, &listen_sockets, listenlist) {
+               sock_release(lcon->sock);
+               kfree(lcon);
+       }
+
+       kcl_releaseref_cluster();
+}
+
+/* This is quite likely to sleep... */
+int lowcomms_start(void)
+{
+       int error = 0;
+       int i;
+
+       INIT_LIST_HEAD(&read_sockets);
+       INIT_LIST_HEAD(&write_sockets);
+       INIT_LIST_HEAD(&state_sockets);
+       INIT_LIST_HEAD(&listen_sockets);
+
+       spin_lock_init(&read_sockets_lock);
+       spin_lock_init(&write_sockets_lock);
+       spin_lock_init(&state_sockets_lock);
+
+       init_completion(&thread_completion);
+       init_MUTEX(&thread_lock);
+       atomic_set(&send_run, 0);
+       atomic_set(&recv_run, 0);
+
+       error = -ENOTCONN;
+       if (kcl_addref_cluster())
+               goto out;
+
+       /*
+        * Temporarily initialise the waitq head so that lowcomms_send_message
+        * doesn't crash if it gets called before the thread is fully
+        * initialised
+        */
+       init_waitqueue_head(&lowcomms_send_waitq);
+
+       error = -ENOMEM;
+
+       connections = kmalloc(sizeof(struct connection) *
+                             dlm_config.max_connections, GFP_KERNEL);
+       if (!connections)
+               goto out;
+
+       memset(connections, 0,
+              sizeof(struct connection) * dlm_config.max_connections);
+       for (i = 0; i < dlm_config.max_connections; i++) {
+               connections[i].nodeid = i;
+               init_rwsem(&connections[i].sock_sem);
+               INIT_LIST_HEAD(&connections[i].writequeue);
+               spin_lock_init(&connections[i].writequeue_lock);
+       }
+       conn_array_size = dlm_config.max_connections;
+
+       /* Start listening */
+       error = listen_for_all();
+       if (error)
+               goto fail_free_conn;
+
+       error = daemons_start();
+       if (error)
+               goto fail_free_conn;
+
+       atomic_set(&accepting, 1);
+
+       return 0;
+
+      fail_free_conn:
+       kfree(connections);
+
+      out:
+       return error;
+}
+
+/* Don't accept any more outgoing work */
+void lowcomms_stop_accept()
+{
+        atomic_set(&accepting, 0);
+}
+
+/* Cluster Manager interface functions for looking up
+   nodeids and IP addresses by each other
+*/
+
+/* Return the IP address of a node given its NODEID */
+static int lowcomms_ipaddr_from_nodeid(int nodeid, struct sockaddr *retaddr)
+{
+       struct list_head *addrs;
+       struct cluster_node_addr *node_addr;
+       struct cluster_node_addr *current_addr = NULL;
+       struct sockaddr_in6 *saddr;
+       int interface;
+       int i;
+
+       addrs = kcl_get_node_addresses(nodeid);
+       if (!addrs)
+               return -1;
+
+       interface = kcl_get_current_interface();
+
+       /* Look for address number <interface> */
+       i=0; /* i/f numbers start at 1 */
+       list_for_each_entry(node_addr, addrs, list) {
+               if (interface == ++i) {
+                       current_addr = node_addr;
+                       break;
+               }
+       }
+
+       /* If that failed then just use the first one */
+       if (!current_addr)
+               current_addr = (struct cluster_node_addr *)addrs->next;
+
+       saddr = (struct sockaddr_in6 *)current_addr->addr;
+
+       /* Extract the IP address */
+       if (saddr->sin6_family == AF_INET) {
+               struct sockaddr_in *in4  = (struct sockaddr_in *)saddr;
+               struct sockaddr_in *ret4 = (struct sockaddr_in *)retaddr;
+               ret4->sin_addr.s_addr = in4->sin_addr.s_addr;
+       }
+       else {
+               struct sockaddr_in6 *ret6 = (struct sockaddr_in6 *)retaddr;
+               memcpy(&ret6->sin6_addr, &saddr->sin6_addr, sizeof(saddr->sin6_addr));
+       }
+
+       return 0;
+}
+
+/* Return the NODEID for a node given its sockaddr */
+static int lowcomms_nodeid_from_ipaddr(struct sockaddr *addr, int addr_len)
+{
+       struct kcl_cluster_node node;
+       struct sockaddr_in6 ipv6_addr;
+       struct sockaddr_in  ipv4_addr;
+
+       if (addr->sa_family == AF_INET) {
+               struct sockaddr_in *in4 = (struct sockaddr_in *)addr;
+               memcpy(&ipv4_addr, &local_addr, addr_len);
+               memcpy(&ipv4_addr.sin_addr, &in4->sin_addr, sizeof(ipv4_addr.sin_addr));
+
+               addr = (struct sockaddr *)&ipv4_addr;
+       }
+       else {
+               struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
+               memcpy(&ipv6_addr, &local_addr, addr_len);
+               memcpy(&ipv6_addr.sin6_addr, &in6->sin6_addr, sizeof(ipv6_addr.sin6_addr));
+
+               addr = (struct sockaddr *)&ipv6_addr;
+       }
+
+       if (kcl_get_node_by_addr((char *)addr, addr_len, &node) == 0)
+               return node.node_id;
+       else
+               return 0;
+}
+
+int lowcomms_our_nodeid(void)
+{
+       struct kcl_cluster_node node;
+       struct list_head *addrs;
+       struct cluster_node_addr *first_addr;
+       static int our_nodeid = 0;
+
+       if (our_nodeid)
+               return our_nodeid;
+
+       if (kcl_get_node_by_nodeid(0, &node) == -1)
+               return 0;
+
+       our_nodeid = node.node_id;
+
+       /* Fill in the "template" structure */
+       addrs = kcl_get_node_addresses(our_nodeid);
+       if (!addrs)
+               return 0;
+
+       first_addr = (struct cluster_node_addr *) addrs->next;
+       memcpy(&local_addr, &first_addr->addr, first_addr->addr_len);
+
+       return node.node_id;
+}
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff -urN linux-orig/cluster/dlm/lowcomms.h linux-patched/cluster/dlm/lowcomms.h
--- linux-orig/cluster/dlm/lowcomms.h   1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/lowcomms.h        2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,34 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __LOWCOMMS_DOT_H__
+#define __LOWCOMMS_DOT_H__
+
+/* The old interface */
+int lowcomms_send_message(int csid, char *buf, int len, int allocation);
+
+/* The new interface */
+struct writequeue_entry;
+extern struct writequeue_entry *lowcomms_get_buffer(int nodeid, int len,
+                                                   int allocation, char **ppc);
+extern void lowcomms_commit_buffer(struct writequeue_entry *e);
+
+int lowcomms_start(void);
+void lowcomms_stop(void);
+void lowcomms_stop_accept(void);
+int lowcomms_close(int nodeid);
+int lowcomms_max_buffer_size(void);
+
+int lowcomms_our_nodeid(void);
+
+#endif                         /* __LOWCOMMS_DOT_H__ */
diff -urN linux-orig/cluster/dlm/main.c linux-patched/cluster/dlm/main.c
--- linux-orig/cluster/dlm/main.c       1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/main.c    2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,98 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#define EXPORT_SYMTAB
+
+#include <linux/init.h>
+#include <linux/proc_fs.h>
+#include <linux/ctype.h>
+#include <linux/seq_file.h>
+#include <linux/module.h>
+#include <net/sock.h>
+
+#include <cluster/cnxman.h>
+
+#include "dlm_internal.h"
+#include "lockspace.h"
+#include "recoverd.h"
+#include "ast.h"
+#include "lkb.h"
+#include "nodes.h"
+#include "locking.h"
+#include "config.h"
+#include "memory.h"
+#include "recover.h"
+#include "lowcomms.h"
+
+int  dlm_device_init(void);
+void dlm_device_exit(void);
+void dlm_proc_init(void);
+void dlm_proc_exit(void);
+
+
+/* Cluster manager callbacks, we want to know if a node dies
+   N.B. this is independent of lockspace-specific event callbacks from SM */
+
+static void cman_callback(kcl_callback_reason reason, long arg)
+{
+       if (reason == DIED) {
+               lowcomms_close((int) arg);
+       }
+
+       /* This is unconditional. so do what we can to tidy up */
+       if (reason == LEAVING) {
+               dlm_emergency_shutdown();
+       }
+}
+
+int __init init_dlm(void)
+{
+       dlm_proc_init();
+       dlm_lockspace_init();
+       dlm_recoverd_init();
+       dlm_nodes_init();
+       dlm_device_init();
+       dlm_memory_init();
+       dlm_config_init();
+
+       kcl_add_callback(cman_callback);
+
+       printk("DLM %s (built %s %s) installed\n",
+              DLM_RELEASE_NAME, __DATE__, __TIME__);
+
+       return 0;
+}
+
+void __exit exit_dlm(void)
+{
+       kcl_remove_callback(cman_callback);
+
+       dlm_device_exit();
+       dlm_memory_exit();
+       dlm_config_exit();
+       dlm_proc_exit();
+}
+
+MODULE_DESCRIPTION("Distributed Lock Manager " DLM_RELEASE_NAME);
+MODULE_AUTHOR("Red Hat, Inc.");
+MODULE_LICENSE("GPL");
+
+module_init(init_dlm);
+module_exit(exit_dlm);
+
+EXPORT_SYMBOL(dlm_init);
+EXPORT_SYMBOL(dlm_release);
+EXPORT_SYMBOL(dlm_new_lockspace);
+EXPORT_SYMBOL(dlm_release_lockspace);
+EXPORT_SYMBOL(dlm_lock);
+EXPORT_SYMBOL(dlm_unlock);
diff -urN linux-orig/cluster/dlm/memory.c linux-patched/cluster/dlm/memory.c
--- linux-orig/cluster/dlm/memory.c     1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/memory.c  2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,238 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/* memory.c
+ * 
+ * memory allocation routines
+ * 
+ */
+
+#include "dlm_internal.h"
+#include "memory.h"
+#include "config.h"
+
+/* as the man says...Shouldn't this be in a header file somewhere? */
+#define        BYTES_PER_WORD          sizeof(void *)
+
+static kmem_cache_t *rsb_cache_small;
+static kmem_cache_t *rsb_cache_large;
+static kmem_cache_t *lkb_cache;
+static kmem_cache_t *lvb_cache;
+static kmem_cache_t *resdir_cache_large;
+static kmem_cache_t *resdir_cache_small;
+
+/* The thresholds above which we allocate large RSBs/resdatas rather than small 
+ * ones. This must make the resultant structure end on a word boundary */
+#define LARGE_RSB_NAME 28
+#define LARGE_RES_NAME 28
+
+int dlm_memory_init()
+{
+       int ret = -ENOMEM;
+
+
+       rsb_cache_small =
+           kmem_cache_create("dlm_rsb(small)",
+                             (sizeof(gd_res_t) + LARGE_RSB_NAME + BYTES_PER_WORD-1) & ~(BYTES_PER_WORD-1),
+                             __alignof__(gd_res_t), 0, NULL, NULL);
+       if (!rsb_cache_small)
+               goto out;
+
+       rsb_cache_large =
+           kmem_cache_create("dlm_rsb(large)",
+                             sizeof(gd_res_t) + DLM_RESNAME_MAXLEN,
+                             __alignof__(gd_res_t), 0, NULL, NULL);
+       if (!rsb_cache_large)
+               goto out_free_rsbs;
+
+       lkb_cache = kmem_cache_create("dlm_lkb", sizeof(gd_lkb_t),
+                                     __alignof__(gd_lkb_t), 0, NULL, NULL);
+       if (!lkb_cache)
+               goto out_free_rsbl;
+
+       resdir_cache_large =
+           kmem_cache_create("dlm_resdir(l)",
+                             sizeof(gd_resdata_t) + DLM_RESNAME_MAXLEN,
+                             __alignof__(gd_resdata_t), 0, NULL, NULL);
+       if (!resdir_cache_large)
+               goto out_free_lkb;
+
+       resdir_cache_small =
+           kmem_cache_create("dlm_resdir(s)",
+                             (sizeof(gd_resdata_t) + LARGE_RES_NAME + BYTES_PER_WORD-1) & ~(BYTES_PER_WORD-1),
+                             __alignof__(gd_resdata_t), 0, NULL, NULL);
+       if (!resdir_cache_small)
+               goto out_free_resl;
+
+       /* LVB cache also holds ranges, so should be 64bit aligned */
+       lvb_cache = kmem_cache_create("dlm_lvb/range", DLM_LVB_LEN,
+                                     __alignof__(uint64_t), 0, NULL, NULL);
+       if (!lkb_cache)
+               goto out_free_ress;
+
+       ret = 0;
+       goto out;
+
+      out_free_ress:
+       kmem_cache_destroy(resdir_cache_small);
+
+      out_free_resl:
+       kmem_cache_destroy(resdir_cache_large);
+
+      out_free_lkb:
+       kmem_cache_destroy(lkb_cache);
+
+      out_free_rsbl:
+       kmem_cache_destroy(rsb_cache_large);
+
+      out_free_rsbs:
+       kmem_cache_destroy(rsb_cache_small);
+
+      out:
+       return ret;
+}
+
+void dlm_memory_exit()
+{
+       kmem_cache_destroy(rsb_cache_large);
+       kmem_cache_destroy(rsb_cache_small);
+       kmem_cache_destroy(lkb_cache);
+       kmem_cache_destroy(resdir_cache_small);
+       kmem_cache_destroy(resdir_cache_large);
+       kmem_cache_destroy(lvb_cache);
+}
+
+gd_res_t *allocate_rsb(gd_ls_t *ls, int namelen)
+{
+       gd_res_t *r;
+
+       GDLM_ASSERT(namelen <= DLM_RESNAME_MAXLEN,);
+
+       if (namelen >= LARGE_RSB_NAME)
+               r = kmem_cache_alloc(rsb_cache_large, ls->ls_allocation);
+       else
+               r = kmem_cache_alloc(rsb_cache_small, ls->ls_allocation);
+
+       if (r)
+               memset(r, 0, sizeof(gd_res_t) + namelen);
+
+       return r;
+}
+
+void free_rsb(gd_res_t *r)
+{
+       int length = r->res_length;
+
+#ifdef POISON
+       memset(r, 0x55, sizeof(gd_res_t) + r->res_length);
+#endif
+
+       if (length >= LARGE_RSB_NAME)
+               kmem_cache_free(rsb_cache_large, r);
+       else
+               kmem_cache_free(rsb_cache_small, r);
+}
+
+gd_lkb_t *allocate_lkb(gd_ls_t *ls)
+{
+       gd_lkb_t *l;
+
+       l = kmem_cache_alloc(lkb_cache, ls->ls_allocation);
+       if (l)
+               memset(l, 0, sizeof(gd_lkb_t));
+
+       return l;
+}
+
+void free_lkb(gd_lkb_t *l)
+{
+#ifdef POISON
+       memset(l, 0xAA, sizeof(gd_lkb_t));
+#endif
+       kmem_cache_free(lkb_cache, l);
+}
+
+gd_resdata_t *allocate_resdata(gd_ls_t *ls, int namelen)
+{
+       gd_resdata_t *rd;
+
+       GDLM_ASSERT(namelen <= DLM_RESNAME_MAXLEN,);
+
+       if (namelen >= LARGE_RES_NAME)
+               rd = kmem_cache_alloc(resdir_cache_large, ls->ls_allocation);
+       else
+               rd = kmem_cache_alloc(resdir_cache_small, ls->ls_allocation);
+
+       if (rd)
+               memset(rd, 0, sizeof(gd_resdata_t));
+
+       return rd;
+}
+
+void free_resdata(gd_resdata_t *rd)
+{
+       if (rd->rd_length >= LARGE_RES_NAME)
+               kmem_cache_free(resdir_cache_large, rd);
+       else
+               kmem_cache_free(resdir_cache_small, rd);
+}
+
+char *allocate_lvb(gd_ls_t *ls)
+{
+       char *l;
+
+       l = kmem_cache_alloc(lvb_cache, ls->ls_allocation);
+       if (l)
+               memset(l, 0, DLM_LVB_LEN);
+
+       return l;
+}
+
+void free_lvb(char *l)
+{
+       kmem_cache_free(lvb_cache, l);
+}
+
+/* Ranges are allocated from the LVB cache as they are the same size (4x64
+ * bits) */
+uint64_t *allocate_range(gd_ls_t * ls)
+{
+       uint64_t *l;
+
+       l = kmem_cache_alloc(lvb_cache, ls->ls_allocation);
+       if (l)
+               memset(l, 0, DLM_LVB_LEN);
+
+       return l;
+}
+
+void free_range(uint64_t *l)
+{
+       kmem_cache_free(lvb_cache, l);
+}
+
+gd_rcom_t *allocate_rcom_buffer(gd_ls_t *ls)
+{
+       gd_rcom_t *rc;
+
+       rc = kmalloc(dlm_config.buffer_size, ls->ls_allocation);
+       if (rc)
+               memset(rc, 0, dlm_config.buffer_size);
+
+       return rc;
+}
+
+void free_rcom_buffer(gd_rcom_t *rc)
+{
+       kfree(rc);
+}
diff -urN linux-orig/cluster/dlm/memory.h linux-patched/cluster/dlm/memory.h
--- linux-orig/cluster/dlm/memory.h     1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/memory.h  2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,32 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __MEMORY_DOT_H__
+#define __MEMORY_DOT_H__
+
+int dlm_memory_init(void);
+void dlm_memory_exit(void);
+gd_res_t *allocate_rsb(gd_ls_t * ls, int namelen);
+void free_rsb(gd_res_t * r);
+gd_lkb_t *allocate_lkb(gd_ls_t * ls);
+void free_lkb(gd_lkb_t * l);
+gd_resdata_t *allocate_resdata(gd_ls_t * ls, int namelen);
+void free_resdata(gd_resdata_t * rd);
+char *allocate_lvb(gd_ls_t * ls);
+void free_lvb(char *l);
+gd_rcom_t *allocate_rcom_buffer(gd_ls_t * ls);
+void free_rcom_buffer(gd_rcom_t * rc);
+uint64_t *allocate_range(gd_ls_t * ls);
+void free_range(uint64_t * l);
+
+#endif         /* __MEMORY_DOT_H__ */
diff -urN linux-orig/cluster/dlm/midcomms.c linux-patched/cluster/dlm/midcomms.c
--- linux-orig/cluster/dlm/midcomms.c   1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/midcomms.c        2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,351 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/*
+ * midcomms.c
+ *
+ * This is the appallingly named "mid-level" comms layer.
+ *
+ * Its purpose is to take packets from the "real" comms layer,
+ * split them up into packets and pass them to the interested
+ * part of the locking mechanism.
+ *
+ * It also takes messages from the locking layer, formats them
+ * into packets and sends them to the comms layer.
+ *
+ * It knows the format of the mid-level messages used and nodeidss
+ * but it does not know how to resolve a nodeid into an IP address
+ * or any of the comms channel details
+ *
+ */
+
+#include "dlm_internal.h"
+#include "lowcomms.h"
+#include "midcomms.h"
+#include "lockqueue.h"
+#include "nodes.h"
+#include "reccomms.h"
+#include "config.h"
+
+/* Byteorder routines */
+
+static void host_to_network(void *msg)
+{
+       struct gd_req_header *head = msg;
+       struct gd_remlockrequest *req = msg;
+       struct gd_remlockreply *reply = msg;
+       struct gd_remquery *query = msg;
+       struct gd_remqueryreply *queryrep = msg;
+       gd_rcom_t *rc = msg;
+
+       /* Force into network byte order */
+
+       /*
+        * Do the common header first
+        */
+
+       head->rh_length = cpu_to_le16(head->rh_length);
+       head->rh_lockspace = cpu_to_le32(head->rh_lockspace);
+       /* Leave the lkid alone as it is transparent at the remote end */
+
+       /*
+        * Do the fields in the remlockrequest or remlockreply structs
+        */
+
+       switch (req->rr_header.rh_cmd) {
+
+       case GDLM_REMCMD_LOCKREQUEST:
+       case GDLM_REMCMD_CONVREQUEST:
+               req->rr_range_start = cpu_to_le64(req->rr_range_start);
+               req->rr_range_end = cpu_to_le64(req->rr_range_end);
+               /* Deliberate fall through */
+       case GDLM_REMCMD_UNLOCKREQUEST:
+       case GDLM_REMCMD_LOOKUP:
+       case GDLM_REMCMD_LOCKGRANT:
+       case GDLM_REMCMD_SENDBAST:
+       case GDLM_REMCMD_SENDCAST:
+       case GDLM_REMCMD_REM_RESDATA:
+               req->rr_flags = cpu_to_le32(req->rr_flags);
+               req->rr_status = cpu_to_le32(req->rr_status);
+               break;
+
+       case GDLM_REMCMD_LOCKREPLY:
+               reply->rl_lockstate = cpu_to_le32(reply->rl_lockstate);
+               reply->rl_nodeid = cpu_to_le32(reply->rl_nodeid);
+               reply->rl_status = cpu_to_le32(reply->rl_status);
+               break;
+
+       case GDLM_REMCMD_RECOVERMESSAGE:
+       case GDLM_REMCMD_RECOVERREPLY:
+               rc->rc_msgid = cpu_to_le32(rc->rc_msgid);
+               rc->rc_datalen = cpu_to_le16(rc->rc_datalen);
+               break;
+
+       case GDLM_REMCMD_QUERY:
+               query->rq_mstlkid = cpu_to_le32(query->rq_mstlkid);
+               query->rq_query = cpu_to_le32(query->rq_query);
+               query->rq_maxlocks = cpu_to_le32(query->rq_maxlocks);
+               break;
+
+       case GDLM_REMCMD_QUERYREPLY:
+               queryrep->rq_numlocks = cpu_to_le32(queryrep->rq_numlocks);
+               queryrep->rq_status = cpu_to_le32(queryrep->rq_status);
+               queryrep->rq_grantcount = cpu_to_le32(queryrep->rq_grantcount);
+               queryrep->rq_waitcount = cpu_to_le32(queryrep->rq_waitcount);
+               queryrep->rq_convcount = cpu_to_le32(queryrep->rq_convcount);
+               break;
+
+       default:
+               printk("dlm: warning, unknown REMCMD type %u\n",
+                      req->rr_header.rh_cmd);
+       }
+}
+
+static void network_to_host(void *msg)
+{
+       struct gd_req_header *head = msg;
+       struct gd_remlockrequest *req = msg;
+       struct gd_remlockreply *reply = msg;
+       struct gd_remquery *query = msg;
+       struct gd_remqueryreply *queryrep = msg;
+       gd_rcom_t *rc = msg;
+
+       /* Force into host byte order */
+
+       /*
+        * Do the common header first
+        */
+
+       head->rh_length = le16_to_cpu(head->rh_length);
+       head->rh_lockspace = le32_to_cpu(head->rh_lockspace);
+       /* Leave the lkid alone as it is transparent at the remote end */
+
+       /*
+        * Do the fields in the remlockrequest or remlockreply structs
+        */
+
+       switch (req->rr_header.rh_cmd) {
+
+       case GDLM_REMCMD_LOCKREQUEST:
+       case GDLM_REMCMD_CONVREQUEST:
+               req->rr_range_start = le64_to_cpu(req->rr_range_start);
+               req->rr_range_end = le64_to_cpu(req->rr_range_end);
+       case GDLM_REMCMD_LOOKUP:
+       case GDLM_REMCMD_UNLOCKREQUEST:
+       case GDLM_REMCMD_LOCKGRANT:
+       case GDLM_REMCMD_SENDBAST:
+       case GDLM_REMCMD_SENDCAST:
+       case GDLM_REMCMD_REM_RESDATA:
+               /* Actually, not much to do here as the remote lock IDs are
+                * transparent too */
+               req->rr_flags = le32_to_cpu(req->rr_flags);
+               req->rr_status = le32_to_cpu(req->rr_status);
+               break;
+
+       case GDLM_REMCMD_LOCKREPLY:
+               reply->rl_lockstate = le32_to_cpu(reply->rl_lockstate);
+               reply->rl_nodeid = le32_to_cpu(reply->rl_nodeid);
+               reply->rl_status = le32_to_cpu(reply->rl_status);
+               break;
+
+       case GDLM_REMCMD_RECOVERMESSAGE:
+       case GDLM_REMCMD_RECOVERREPLY:
+               rc->rc_msgid = le32_to_cpu(rc->rc_msgid);
+               rc->rc_datalen = le16_to_cpu(rc->rc_datalen);
+               break;
+
+
+       case GDLM_REMCMD_QUERY:
+               query->rq_mstlkid = le32_to_cpu(query->rq_mstlkid);
+               query->rq_query = le32_to_cpu(query->rq_query);
+               query->rq_maxlocks = le32_to_cpu(query->rq_maxlocks);
+               break;
+
+       case GDLM_REMCMD_QUERYREPLY:
+               queryrep->rq_numlocks = le32_to_cpu(queryrep->rq_numlocks);
+               queryrep->rq_status = le32_to_cpu(queryrep->rq_status);
+               queryrep->rq_grantcount = le32_to_cpu(queryrep->rq_grantcount);
+               queryrep->rq_waitcount = le32_to_cpu(queryrep->rq_waitcount);
+               queryrep->rq_convcount = le32_to_cpu(queryrep->rq_convcount);
+               break;
+
+       default:
+               printk("dlm: warning, unknown REMCMD type %u\n",
+                      req->rr_header.rh_cmd);
+       }
+}
+
+static void copy_from_cb(void *dst, const void *base, unsigned offset,
+                        unsigned len, unsigned limit)
+{
+       unsigned copy = len;
+
+       if ((copy + offset) > limit)
+               copy = limit - offset;
+       memcpy(dst, base + offset, copy);
+       len -= copy;
+       if (len)
+               memcpy(dst + copy, base, len);
+}
+
+static void khexdump(const unsigned char *c, int len)
+{
+       while (len > 16) {
+               printk(KERN_INFO
+                      "%02x %02x %02x %02x %02x %02x %02x %02x-%02x %02x %02x %02x %02x %02x %02x %02x\n",
+                      c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8],
+                      c[9], c[10], c[11], c[12], c[13], c[14], c[15]);
+               len -= 16;
+       }
+       while (len > 4) {
+               printk(KERN_INFO "%02x %02x %02x %02x\n", c[0], c[1], c[2],
+                      c[3]);
+               len -= 4;
+       }
+       while (len > 0) {
+               printk(KERN_INFO "%02x\n", c[0]);
+               len--;
+       }
+}
+
+/*
+ * Called from the low-level comms layer to process a buffer of
+ * commands.
+ *
+ * Only complete messages are processed here, any "spare" bytes from
+ * the end of a buffer are saved and tacked onto the front of the next
+ * message that comes in. I doubt this will happen very often but we
+ * need to be able to cope with it and I don't want the task to be waiting
+ * for packets to come in when there is useful work to be done.
+ *
+ */
+int midcomms_process_incoming_buffer(int nodeid, const void *base,
+                                    unsigned offset, unsigned len,
+                                    unsigned limit)
+{
+       unsigned char __tmp[sizeof(struct gd_req_header) + 64];
+       struct gd_req_header *msg = (struct gd_req_header *) __tmp;
+       int ret = 0;
+       int err = 0;
+       unsigned msglen;
+       __u32 id, space;
+
+       while (len > sizeof(struct gd_req_header)) {
+               /* Get message header and check it over */
+               copy_from_cb(msg, base, offset, sizeof(struct gd_req_header),
+                            limit);
+               msglen = le16_to_cpu(msg->rh_length);
+               id = msg->rh_lkid;
+               space = msg->rh_lockspace;
+
+               /* Check message size */
+               err = -EINVAL;
+               if (msglen < sizeof(struct gd_req_header))
+                       break;
+               err = -E2BIG;
+               if (msglen > dlm_config.buffer_size) {
+                       printk("dlm: message size too big %d\n", msglen);
+                       break;
+               }
+               err = 0;
+
+               /* Not enough in buffer yet? wait for some more */
+               if (msglen > len)
+                       break;
+
+               /* Make sure our temp buffer is large enough */
+               if (msglen > sizeof(__tmp) &&
+                   msg == (struct gd_req_header *) __tmp) {
+                       msg = kmalloc(dlm_config.buffer_size, GFP_KERNEL);
+                       if (msg == NULL)
+                               return ret;
+               }
+
+               copy_from_cb(msg, base, offset, msglen, limit);
+               BUG_ON(id != msg->rh_lkid);
+               BUG_ON(space != msg->rh_lockspace);
+               ret += msglen;
+               offset += msglen;
+               offset &= (limit - 1);
+               len -= msglen;
+               network_to_host(msg);
+
+               if ((msg->rh_cmd > 32) ||
+                   (msg->rh_cmd == 0) ||
+                   (msg->rh_length < sizeof(struct gd_req_header)) ||
+                   (msg->rh_length > dlm_config.buffer_size)) {
+
+                       printk("dlm: midcomms: cmd=%u, flags=%u, length=%hu, "
+                              "lkid=%u, lockspace=%u\n",
+                              msg->rh_cmd, msg->rh_flags, msg->rh_length,
+                              msg->rh_lkid, msg->rh_lockspace);
+
+                       printk("dlm: midcomms: base=%p, offset=%u, len=%u, "
+                              "ret=%u, limit=%08x newbuf=%d\n",
+                              base, offset, len, ret, limit,
+                              ((struct gd_req_header *) __tmp == msg));
+
+                       khexdump((const unsigned char *) msg, msg->rh_length);
+
+                       return -EBADMSG;
+               }
+
+               switch (msg->rh_cmd) {
+               case GDLM_REMCMD_RECOVERMESSAGE:
+               case GDLM_REMCMD_RECOVERREPLY:
+                       process_recovery_comm(nodeid, msg);
+                       break;
+               default:
+                       process_cluster_request(nodeid, msg, FALSE);
+               }
+       }
+
+       if (msg != (struct gd_req_header *) __tmp)
+               kfree(msg);
+
+       return err ? err : ret;
+}
+
+/*
+ * Send a lowcomms buffer
+ */
+
+void midcomms_send_buffer(struct gd_req_header *msg, struct writequeue_entry *e)
+{
+       host_to_network(msg);
+       lowcomms_commit_buffer(e);
+}
+
+/*
+ * Make the message into network byte order and send it
+ */
+
+int midcomms_send_message(uint32_t nodeid, struct gd_req_header *msg,
+                         int allocation)
+{
+       int len = msg->rh_length;
+
+       host_to_network(msg);
+
+       /*
+        * Loopback.  In fact, the locking code pretty much prevents this from
+        * being needed but it can happen when the directory node is also the
+        * local node.
+        */
+
+       if (nodeid == our_nodeid())
+               return midcomms_process_incoming_buffer(nodeid, (char *) msg, 0,
+                                                       len, len);
+
+       return lowcomms_send_message(nodeid, (char *) msg, len, allocation);
+}
diff -urN linux-orig/cluster/dlm/midcomms.h linux-patched/cluster/dlm/midcomms.h
--- linux-orig/cluster/dlm/midcomms.h   1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/midcomms.h        2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,24 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __MIDCOMMS_DOT_H__
+#define __MIDCOMMS_DOT_H__
+
+int midcomms_send_message(uint32_t csid, struct gd_req_header *msg,
+                         int allocation);
+int midcomms_process_incoming_buffer(int csid, const void *buf, unsigned offset,
+                                    unsigned len, unsigned limit);
+void midcomms_send_buffer(struct gd_req_header *msg,
+                         struct writequeue_entry *e);
+
+#endif                         /* __MIDCOMMS_DOT_H__ */
diff -urN linux-orig/cluster/dlm/nodes.c linux-patched/cluster/dlm/nodes.c
--- linux-orig/cluster/dlm/nodes.c      1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/nodes.c   2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,325 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include <net/sock.h>
+#include <cluster/cnxman.h>
+
+#include "dlm_internal.h"
+#include "lowcomms.h"
+#include "nodes.h"
+#include "recover.h"
+#include "reccomms.h"
+#include "util.h"
+
+static struct list_head cluster_nodes;
+static spinlock_t node_lock;
+static uint32_t local_nodeid;
+static struct semaphore local_init_lock;
+
+
+void dlm_nodes_init(void)
+{
+       INIT_LIST_HEAD(&cluster_nodes);
+       spin_lock_init(&node_lock);
+       local_nodeid = 0;
+       init_MUTEX(&local_init_lock);
+}
+
+static gd_node_t *search_node(uint32_t nodeid)
+{
+       gd_node_t *node;
+
+       list_for_each_entry(node, &cluster_nodes, gn_list) {
+               if (node->gn_nodeid == nodeid)
+                       goto out;
+       }
+       node = NULL;
+      out:
+       return node;
+}
+
+static void put_node(gd_node_t *node)
+{
+       spin_lock(&node_lock);
+       node->gn_refcount--;
+       if (node->gn_refcount == 0) {
+               list_del(&node->gn_list);
+               spin_unlock(&node_lock);
+               kfree(node);
+               return;
+       }
+       spin_unlock(&node_lock);
+}
+
+static int get_node(uint32_t nodeid, gd_node_t **ndp)
+{
+       gd_node_t *node, *node2;
+       int error = -ENOMEM;
+
+       spin_lock(&node_lock);
+       node = search_node(nodeid);
+       if (node)
+               node->gn_refcount++;
+       spin_unlock(&node_lock);
+
+       if (node)
+               goto out;
+
+       node = (gd_node_t *) kmalloc(sizeof(gd_node_t), GFP_KERNEL);
+       if (!node)
+               goto fail;
+
+       memset(node, 0, sizeof(gd_node_t));
+       node->gn_nodeid = nodeid;
+
+       spin_lock(&node_lock);
+       node2 = search_node(nodeid);
+       if (node2) {
+               node2->gn_refcount++;
+               spin_unlock(&node_lock);
+               kfree(node);
+               node = node2;
+               goto out;
+       }
+
+       node->gn_refcount = 1;
+       list_add_tail(&node->gn_list, &cluster_nodes);
+       spin_unlock(&node_lock);
+
+      out:
+       *ndp = node;
+       return 0;
+
+      fail:
+       return error;
+}
+
+int init_new_csb(uint32_t nodeid, gd_csb_t **ret_csb)
+{
+       gd_csb_t *csb;
+       gd_node_t *node;
+       int error = -ENOMEM;
+
+       csb = (gd_csb_t *) kmalloc(sizeof(gd_csb_t), GFP_KERNEL);
+       if (!csb)
+               goto fail;
+
+       memset(csb, 0, sizeof(gd_csb_t));
+
+       error = get_node(nodeid, &node);
+       if (error)
+               goto fail_free;
+
+       csb->csb_node = node;
+
+       down(&local_init_lock);
+
+       if (!local_nodeid) {
+               if (nodeid == our_nodeid()) {
+                       local_nodeid = node->gn_nodeid;
+               }
+       }
+       up(&local_init_lock);
+
+       *ret_csb = csb;
+       return 0;
+
+      fail_free:
+       kfree(csb);
+      fail:
+       return error;
+}
+
+void release_csb(gd_csb_t *csb)
+{
+       put_node(csb->csb_node);
+       kfree(csb);
+}
+
+uint32_t our_nodeid(void)
+{
+       return lowcomms_our_nodeid();
+}
+
+int nodes_reconfig_wait(gd_ls_t *ls)
+{
+       int error;
+
+       if (ls->ls_low_nodeid == our_nodeid()) {
+               error = gdlm_wait_status_all(ls, NODES_VALID);
+               if (!error)
+                       set_bit(LSFL_ALL_NODES_VALID, &ls->ls_flags);
+
+               /* Experimental: this delay should allow any final messages
+                * from the previous node to be received before beginning
+                * recovery. */
+
+               if (ls->ls_num_nodes == 1) {
+                       current->state = TASK_UNINTERRUPTIBLE;
+                       schedule_timeout((2) * HZ);
+               }
+
+       } else
+               error = gdlm_wait_status_low(ls, NODES_ALL_VALID);
+
+       return error;
+}
+
+static void add_ordered_node(gd_ls_t *ls, gd_csb_t *new)
+{
+       gd_csb_t *csb = NULL;
+       struct list_head *tmp;
+       struct list_head *newlist = &new->csb_list;
+       struct list_head *head = &ls->ls_nodes;
+
+       list_for_each(tmp, head) {
+               csb = list_entry(tmp, gd_csb_t, csb_list);
+
+               if (new->csb_node->gn_nodeid < csb->csb_node->gn_nodeid)
+                       break;
+       }
+
+       if (!csb)
+               list_add_tail(newlist, head);
+       else {
+               /* FIXME: can use list macro here */
+               newlist->prev = tmp->prev;
+               newlist->next = tmp;
+               tmp->prev->next = newlist;
+               tmp->prev = newlist;
+       }
+}
+
+int ls_nodes_reconfig(gd_ls_t *ls, gd_recover_t *gr, int *neg_out)
+{
+       gd_csb_t *csb, *safe;
+       int error, i, found, pos = 0, neg = 0;
+       uint32_t low = (uint32_t) (-1);
+
+       /* 
+        * Remove (and save) departed nodes from lockspace's nodes list
+        */
+
+       list_for_each_entry_safe(csb, safe, &ls->ls_nodes, csb_list) {
+               found = FALSE;
+               for (i = 0; i < gr->gr_node_count; i++) {
+                       if (csb->csb_node->gn_nodeid == gr->gr_nodeids[i]) {
+                               found = TRUE;
+                               break;
+                       }
+               }
+
+               if (!found) {
+                       neg++;
+                       csb->csb_gone_event = gr->gr_event_id;
+                       list_del(&csb->csb_list);
+                       list_add_tail(&csb->csb_list, &ls->ls_nodes_gone);
+                       ls->ls_num_nodes--;
+                       log_all(ls, "remove node %u", csb->csb_node->gn_nodeid);
+               }
+       }
+
+       /* 
+        * Add new nodes to lockspace's nodes list
+        */
+
+       for (i = 0; i < gr->gr_node_count; i++) {
+               found = FALSE;
+               list_for_each_entry(csb, &ls->ls_nodes, csb_list) {
+                       if (csb->csb_node->gn_nodeid == gr->gr_nodeids[i]) {
+                               found = TRUE;
+                               break;
+                       }
+               }
+
+               if (!found) {
+                       pos++;
+
+                       error = init_new_csb(gr->gr_nodeids[i], &csb);
+                       GDLM_ASSERT(!error,);
+
+                       add_ordered_node(ls, csb);
+                       ls->ls_num_nodes++;
+                       log_all(ls, "add node %u", csb->csb_node->gn_nodeid);
+               }
+       }
+
+       list_for_each_entry(csb, &ls->ls_nodes, csb_list) {
+               if (csb->csb_node->gn_nodeid < low)
+                       low = csb->csb_node->gn_nodeid;
+       }
+
+       rcom_log_clear(ls);
+       ls->ls_low_nodeid = low;
+       ls->ls_nodes_mask = gdlm_next_power2(ls->ls_num_nodes) - 1;
+       set_bit(LSFL_NODES_VALID, &ls->ls_flags);
+       *neg_out = neg;
+
+       error = nodes_reconfig_wait(ls);
+
+       log_all(ls, "total nodes %d", ls->ls_num_nodes);
+
+       return error;
+}
+
+int ls_nodes_init(gd_ls_t *ls, gd_recover_t *gr)
+{
+       gd_csb_t *csb;
+       int i, error;
+       uint32_t low = (uint32_t) (-1);
+
+       log_all(ls, "add nodes");
+
+       for (i = 0; i < gr->gr_node_count; i++) {
+               error = init_new_csb(gr->gr_nodeids[i], &csb);
+               if (error)
+                       goto fail;
+
+               add_ordered_node(ls, csb);
+               ls->ls_num_nodes++;
+
+               if (csb->csb_node->gn_nodeid < low)
+                       low = csb->csb_node->gn_nodeid;
+       }
+
+       ls->ls_low_nodeid = low;
+       ls->ls_nodes_mask = gdlm_next_power2(ls->ls_num_nodes) - 1;
+       set_bit(LSFL_NODES_VALID, &ls->ls_flags);
+
+       error = nodes_reconfig_wait(ls);
+
+       log_all(ls, "total nodes %d", ls->ls_num_nodes);
+
+       return error;
+
+      fail:
+       while (!list_empty(&ls->ls_nodes)) {
+               csb = list_entry(ls->ls_nodes.next, gd_csb_t, csb_list);
+               list_del(&csb->csb_list);
+               release_csb(csb);
+       }
+       ls->ls_num_nodes = 0;
+
+       return error;
+}
+
+int in_nodes_gone(gd_ls_t *ls, uint32_t nodeid)
+{
+       gd_csb_t *csb;
+
+       list_for_each_entry(csb, &ls->ls_nodes_gone, csb_list) {
+               if (csb->csb_node->gn_nodeid == nodeid)
+                       return TRUE;
+       }
+       return FALSE;
+}
diff -urN linux-orig/cluster/dlm/nodes.h linux-patched/cluster/dlm/nodes.h
--- linux-orig/cluster/dlm/nodes.h      1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/nodes.h   2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,25 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __NODES_DOT_H__
+#define __NODES_DOT_H__
+
+void dlm_nodes_init(void);
+int init_new_csb(uint32_t nodeid, gd_csb_t ** ret_csb);
+void release_csb(gd_csb_t * csb);
+uint32_t our_nodeid(void);
+int ls_nodes_reconfig(gd_ls_t * ls, gd_recover_t * gr, int *neg);
+int ls_nodes_init(gd_ls_t * ls, gd_recover_t * gr);
+int in_nodes_gone(gd_ls_t * ls, uint32_t nodeid);
+
+#endif                         /* __NODES_DOT_H__ */
diff -urN linux-orig/cluster/dlm/proc.c linux-patched/cluster/dlm/proc.c
--- linux-orig/cluster/dlm/proc.c       1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/proc.c    2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,469 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include <linux/init.h>
+#include <linux/proc_fs.h>
+#include <linux/ctype.h>
+#include <linux/seq_file.h>
+#include <linux/module.h>
+
+#include "dlm_internal.h"
+#include "lockspace.h"
+
+#if defined(DLM_DEBUG)
+#define DLM_DEBUG_SIZE         (1024)
+#define MAX_DEBUG_MSG_LEN      (64)
+#else
+#define DLM_DEBUG_SIZE         (0)
+#define MAX_DEBUG_MSG_LEN      (0)
+#endif
+
+static char *                  debug_buf;
+static unsigned int            debug_size;
+static unsigned int            debug_point;
+static int                     debug_wrap;
+static spinlock_t              debug_lock;
+static struct proc_dir_entry * debug_proc_entry = NULL;
+static struct proc_dir_entry * rcom_proc_entry = NULL;
+static char                    proc_ls_name[255] = "";
+
+#ifdef CONFIG_CLUSTER_DLM_PROCLOCKS
+static struct proc_dir_entry * locks_proc_entry = NULL;
+static struct seq_operations   locks_info_op;
+
+
+static int locks_open(struct inode *inode, struct file *file)
+{
+       return seq_open(file, &locks_info_op);
+}
+
+/* Write simply sets the lockspace to use */
+static ssize_t locks_write(struct file *file, const char *buf,
+                          size_t count, loff_t * ppos)
+{
+       if (count < sizeof(proc_ls_name)) {
+               copy_from_user(proc_ls_name, buf, count);
+               proc_ls_name[count] = '\0';
+
+               /* Remove any trailing LF so that lazy users
+                  can just echo "lsname" > /proc/cluster/dlm_locks */
+               if (proc_ls_name[count - 1] == '\n')
+                       proc_ls_name[count - 1] = '\0';
+
+               return count;
+       }
+       return 0;
+}
+
+static struct file_operations locks_fops = {
+      open:locks_open,
+      write:locks_write,
+      read:seq_read,
+      llseek:seq_lseek,
+      release:seq_release,
+};
+
+struct ls_dumpinfo {
+       int entry;
+       struct list_head *next;
+       gd_ls_t *ls;
+       gd_res_t *rsb;
+};
+
+static int print_resource(gd_res_t * res, struct seq_file *s);
+
+static struct ls_dumpinfo *next_rsb(struct ls_dumpinfo *di)
+{
+       read_lock(&di->ls->ls_reshash_lock);
+       if (!di->next) {
+               /* Find the next non-empty hash bucket */
+               while (list_empty(&di->ls->ls_reshashtbl[di->entry]) &&
+                      di->entry < di->ls->ls_hashsize) {
+                       di->entry++;
+               }
+               if (di->entry >= di->ls->ls_hashsize) {
+                       read_unlock(&di->ls->ls_reshash_lock);
+                       return NULL;    /* End of hash list */
+               }
+
+               di->next = di->ls->ls_reshashtbl[di->entry].next;
+       } else {                /* Find the next entry in the list */
+
+               di->next = di->next->next;
+               if (di->next->next == di->ls->ls_reshashtbl[di->entry].next) {
+                       /* End of list - move to next bucket */
+                       di->next = NULL;
+                       di->entry++;
+                       read_unlock(&di->ls->ls_reshash_lock);
+
+                       return next_rsb(di);    /* do the top half of this conditional */
+               }
+       }
+       di->rsb = list_entry(di->next, gd_res_t, res_hashchain);
+       read_unlock(&di->ls->ls_reshash_lock);
+
+       return di;
+}
+
+static void *s_start(struct seq_file *m, loff_t * pos)
+{
+       struct ls_dumpinfo *di;
+       gd_ls_t *ls;
+       int i;
+
+       ls = find_lockspace_by_name(proc_ls_name, strlen(proc_ls_name));
+       if (!ls)
+               return NULL;
+
+       di = kmalloc(sizeof(struct ls_dumpinfo), GFP_KERNEL);
+       if (!di)
+               return NULL;
+
+       if (*pos == 0)
+               seq_printf(m, "DLM lockspace '%s'\n", proc_ls_name);
+
+       di->entry = 0;
+       di->next = NULL;
+       di->ls = ls;
+
+       for (i = 0; i < *pos; i++)
+               if (next_rsb(di) == NULL)
+                       return NULL;
+
+       return next_rsb(di);
+}
+
+static void *s_next(struct seq_file *m, void *p, loff_t * pos)
+{
+       struct ls_dumpinfo *di = p;
+
+       *pos += 1;
+
+       return next_rsb(di);
+}
+
+static int s_show(struct seq_file *m, void *p)
+{
+       struct ls_dumpinfo *di = p;
+       return print_resource(di->rsb, m);
+}
+
+static void s_stop(struct seq_file *m, void *p)
+{
+       kfree(p);
+}
+
+static struct seq_operations locks_info_op = {
+      start:s_start,
+      next:s_next,
+      stop:s_stop,
+      show:s_show
+};
+
+static char *print_lockmode(int mode)
+{
+       switch (mode) {
+       case DLM_LOCK_IV:
+               return "--";
+       case DLM_LOCK_NL:
+               return "NL";
+       case DLM_LOCK_CR:
+               return "CR";
+       case DLM_LOCK_CW:
+               return "CW";
+       case DLM_LOCK_PR:
+               return "PR";
+       case DLM_LOCK_PW:
+               return "PW";
+       case DLM_LOCK_EX:
+               return "EX";
+       default:
+               return "??";
+       }
+}
+
+static void print_lock(struct seq_file *s, gd_lkb_t * lkb, gd_res_t * res)
+{
+
+       seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));
+
+       if (lkb->lkb_status == GDLM_LKSTS_CONVERT
+           || lkb->lkb_status == GDLM_LKSTS_WAITING)
+               seq_printf(s, " (%s)", print_lockmode(lkb->lkb_rqmode));
+
+       if (lkb->lkb_range) {
+               /* This warns on Alpha. Tough. Only I see it */
+               if (lkb->lkb_status == GDLM_LKSTS_CONVERT
+                   || lkb->lkb_status == GDLM_LKSTS_GRANTED)
+                       seq_printf(s, " %" PRIx64 "-%" PRIx64,
+                                  lkb->lkb_range[GR_RANGE_START],
+                                  lkb->lkb_range[GR_RANGE_END]);
+               if (lkb->lkb_status == GDLM_LKSTS_CONVERT
+                   || lkb->lkb_status == GDLM_LKSTS_WAITING)
+                       seq_printf(s, " (%" PRIx64 "-%" PRIx64 ")",
+                                  lkb->lkb_range[RQ_RANGE_START],
+                                  lkb->lkb_range[RQ_RANGE_END]);
+       }
+
+       if (lkb->lkb_nodeid) {
+               if (lkb->lkb_nodeid != res->res_nodeid)
+                       seq_printf(s, " Remote: %3d %08x", lkb->lkb_nodeid,
+                                  lkb->lkb_remid);
+               else
+                       seq_printf(s, " Master:     %08x", lkb->lkb_remid);
+       }
+
+       if (lkb->lkb_status != GDLM_LKSTS_GRANTED)
+               seq_printf(s, "  LQ: %d", lkb->lkb_lockqueue_state);
+
+       seq_printf(s, "\n");
+}
+
+static int print_resource(gd_res_t *res, struct seq_file *s)
+{
+       int i;
+       struct list_head *locklist;
+
+       seq_printf(s, "\nResource %p (parent %p). Name (len=%d) \"", res,
+                  res->res_parent, res->res_length);
+       for (i = 0; i < res->res_length; i++) {
+               if (isprint(res->res_name[i]))
+                       seq_printf(s, "%c", res->res_name[i]);
+               else
+                       seq_printf(s, "%c", '.');
+       }
+       if (res->res_nodeid)
+               seq_printf(s, "\"  \nLocal Copy, Master is node %d\n",
+                          res->res_nodeid);
+       else
+               seq_printf(s, "\"  \nMaster Copy\n");
+
+       /* Print the LVB: */
+       if (res->res_lvbptr) {
+               seq_printf(s, "LVB: ");
+               for (i = 0; i < DLM_LVB_LEN; i++) {
+                       if (i == DLM_LVB_LEN / 2)
+                               seq_printf(s, "\n     ");
+                       seq_printf(s, "%02x ",
+                                  (unsigned char) res->res_lvbptr[i]);
+               }
+               seq_printf(s, "\n");
+       }
+
+       /* Print the locks attached to this resource */
+       seq_printf(s, "Granted Queue\n");
+       list_for_each(locklist, &res->res_grantqueue) {
+               gd_lkb_t *this_lkb =
+                   list_entry(locklist, gd_lkb_t, lkb_statequeue);
+               print_lock(s, this_lkb, res);
+       }
+
+       seq_printf(s, "Conversion Queue\n");
+       list_for_each(locklist, &res->res_convertqueue) {
+               gd_lkb_t *this_lkb =
+                   list_entry(locklist, gd_lkb_t, lkb_statequeue);
+               print_lock(s, this_lkb, res);
+       }
+
+       seq_printf(s, "Waiting Queue\n");
+       list_for_each(locklist, &res->res_waitqueue) {
+               gd_lkb_t *this_lkb =
+                   list_entry(locklist, gd_lkb_t, lkb_statequeue);
+               print_lock(s, this_lkb, res);
+       }
+       return 0;
+}
+#endif                         /* CONFIG_CLUSTER_DLM_PROCLOCKS */
+
+void dlm_debug_log(gd_ls_t *ls, const char *fmt, ...)
+{
+       va_list va;
+       int i, n, size, len;
+       char buf[MAX_DEBUG_MSG_LEN+1];
+
+       spin_lock(&debug_lock);
+
+       if (!debug_buf)
+               goto out;
+
+       size = MAX_DEBUG_MSG_LEN;
+       memset(buf, 0, size+1);
+
+       n = snprintf(buf, size, "%s ", ls->ls_name);
+       size -= n;
+
+       va_start(va, fmt);
+       vsnprintf(buf+n, size, fmt, va);
+       va_end(va);
+
+       len = strlen(buf);
+       if (len > MAX_DEBUG_MSG_LEN-1)
+               len = MAX_DEBUG_MSG_LEN-1;
+       buf[len] = '\n';
+       buf[len+1] = '\0';
+
+       for (i = 0; i < strlen(buf); i++) {
+               debug_buf[debug_point++] = buf[i];
+
+               if (debug_point == debug_size) {
+                       debug_point = 0;
+                       debug_wrap = 1;
+               }
+       }
+ out:
+       spin_unlock(&debug_lock);
+}
+
+void dlm_debug_dump(void)
+{
+       int i;
+
+       spin_lock(&debug_lock);
+       if (debug_wrap) {
+               for (i = debug_point; i < debug_size; i++)
+                       printk("%c", debug_buf[i]);
+       }
+       for (i = 0; i < debug_point; i++)
+               printk("%c", debug_buf[i]);
+       spin_unlock(&debug_lock);
+}
+
+void dlm_debug_setup(int size)
+{
+       char *b = NULL;
+
+       if (size > PAGE_SIZE)
+               size = PAGE_SIZE;
+       if (size)
+               b = kmalloc(size, GFP_KERNEL);
+
+       spin_lock(&debug_lock);
+       if (debug_buf)
+               kfree(debug_buf);
+       if (!size || !b)
+               goto out;
+       debug_size = size;
+       debug_point = 0;
+       debug_wrap = 0;
+       debug_buf = b;
+       memset(debug_buf, 0, debug_size);
+ out:
+        spin_unlock(&debug_lock);
+}
+
+static void dlm_debug_init(void)
+{
+       debug_buf = NULL;
+        debug_size = 0;
+       debug_point = 0;
+       debug_wrap = 0;
+       spin_lock_init(&debug_lock);
+
+       dlm_debug_setup(DLM_DEBUG_SIZE);
+}
+
+#ifdef CONFIG_PROC_FS
+int dlm_debug_info(char *b, char **start, off_t offset, int length)
+{
+       int i, n = 0;
+
+       spin_lock(&debug_lock);
+
+       if (debug_wrap) {
+               for (i = debug_point; i < debug_size; i++)
+                       n += sprintf(b + n, "%c", debug_buf[i]);
+       }
+       for (i = 0; i < debug_point; i++)
+               n += sprintf(b + n, "%c", debug_buf[i]);
+
+       spin_unlock(&debug_lock);
+
+       return n;
+}
+
+int dlm_rcom_info(char *b, char **start, off_t offset, int length)
+{
+       gd_ls_t *ls;
+       gd_csb_t *csb;
+       int n = 0;
+
+       ls = find_lockspace_by_name(proc_ls_name, strlen(proc_ls_name));
+       if (!ls)
+               return 0;
+
+       n += sprintf(b + n, "nodeid names_send_count names_send_msgid "
+                                  "names_recv_count names_recv_msgid "
+                                  "locks_send_count locks_send_msgid "
+                                  "locks_recv_count locks_recv_msgid\n");
+
+       list_for_each_entry(csb, &ls->ls_nodes, csb_list) {
+               n += sprintf(b + n, "%u %u %u %u %u %u %u %u %u\n",
+                            csb->csb_node->gn_nodeid,
+                            csb->csb_names_send_count,
+                            csb->csb_names_send_msgid,
+                            csb->csb_names_recv_count,
+                            csb->csb_names_recv_msgid,
+                            csb->csb_locks_send_count,
+                            csb->csb_locks_send_msgid,
+                            csb->csb_locks_recv_count,
+                            csb->csb_locks_recv_msgid);
+        }
+       return n;
+}
+#endif
+
+void dlm_proc_init(void)
+{
+#ifdef CONFIG_PROC_FS
+       debug_proc_entry = create_proc_entry("cluster/dlm_debug", S_IRUGO,
+                                            NULL);
+       if (!debug_proc_entry)
+               return;
+
+       debug_proc_entry->get_info = &dlm_debug_info;
+
+       rcom_proc_entry = create_proc_entry("cluster/dlm_rcom", S_IRUGO, NULL);
+       if (!rcom_proc_entry)
+               return;
+
+       rcom_proc_entry->get_info = &dlm_rcom_info;
+#endif
+       dlm_debug_init();
+
+#ifdef CONFIG_CLUSTER_DLM_PROCLOCKS
+       locks_proc_entry = create_proc_read_entry("cluster/dlm_locks",
+                                                 S_IFREG | 0400,
+                                                 NULL, NULL, NULL);
+       if (!locks_proc_entry)
+               return;
+       locks_proc_entry->proc_fops = &locks_fops;
+#endif
+}
+
+void dlm_proc_exit(void)
+{
+#ifdef CONFIG_PROC_FS
+       if (debug_proc_entry) {
+               remove_proc_entry("cluster/dlm_debug", NULL);
+               dlm_debug_setup(0);
+       }
+
+       if (rcom_proc_entry)
+               remove_proc_entry("cluster/dlm_rcom", NULL);
+#endif
+
+#ifdef CONFIG_CLUSTER_DLM_PROCLOCKS
+       if (locks_proc_entry)
+               remove_proc_entry("cluster/dlm_locks", NULL);
+#endif
+}
diff -urN linux-orig/cluster/dlm/queries.c linux-patched/cluster/dlm/queries.c
--- linux-orig/cluster/dlm/queries.c    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/queries.c 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,697 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/*
+ * queries.c
+ *
+ * This file provides the kernel query interface to the DLM.
+ *
+ */
+
+#define EXPORT_SYMTAB
+#include <linux/module.h>
+
+#include "dlm_internal.h"
+#include "lockqueue.h"
+#include "locking.h"
+#include "lkb.h"
+#include "nodes.h"
+#include "dir.h"
+#include "ast.h"
+#include "memory.h"
+#include "lowcomms.h"
+#include "midcomms.h"
+#include "rsb.h"
+
+static int query_resource(gd_res_t *rsb, struct dlm_resinfo *resinfo);
+static int query_locks(int query, gd_lkb_t *lkb, struct dlm_queryinfo *qinfo);
+
+/*
+ * API entry point.
+ */
+int dlm_query(void *lockspace,
+             struct dlm_lksb *lksb,
+             int query,
+             struct dlm_queryinfo *qinfo,
+             void (ast_routine(void *)),
+             void *astarg)
+{
+       int status = -EINVAL;
+       gd_lkb_t *target_lkb;
+       gd_lkb_t *query_lkb = NULL;     /* Our temporary LKB */
+       gd_ls_t  *ls = (gd_ls_t *) find_lockspace_by_local_id(lockspace);
+
+
+       if (!qinfo)
+               goto out;
+       if (!ls)
+               goto out;
+       if (!ast_routine)
+               goto out;
+       if (!lksb)
+               goto out;
+
+       if (!qinfo->gqi_lockinfo)
+               qinfo->gqi_locksize = 0;
+
+        /* Find the lkid */
+       target_lkb = find_lock_by_id(ls, lksb->sb_lkid);
+       if (!target_lkb)
+               goto out;
+
+       /* If the user wants a list of locks that are blocking or
+          not blocking this lock, then it must be waiting
+          for something
+       */
+       if (((query & DLM_QUERY_MASK) == DLM_QUERY_LOCKS_BLOCKING ||
+            (query & DLM_QUERY_MASK) == DLM_QUERY_LOCKS_NOTBLOCK) &&
+           target_lkb->lkb_status == GDLM_LKSTS_GRANTED)
+               return -EINVAL;
+
+       /* We now allocate an LKB for our own use (so we can hang
+        * things like the AST routine and the lksb from it) */
+       lksb->sb_status = -EBUSY;
+       query_lkb = create_lkb(ls);
+       if (!query_lkb) {
+               status = -ENOMEM;
+               goto out;
+       }
+       query_lkb->lkb_astaddr  = ast_routine;
+       query_lkb->lkb_astparam = (long)astarg;
+       query_lkb->lkb_resource = target_lkb->lkb_resource;
+       query_lkb->lkb_lksb     = lksb;
+
+       /* Don't free the resource while we are querying it. This ref
+        * will be dropped when the LKB is freed */
+       hold_rsb(query_lkb->lkb_resource);
+
+       /* Fill in the stuff that's always local */
+       if (qinfo->gqi_resinfo) {
+               if (target_lkb->lkb_resource->res_nodeid)
+                       qinfo->gqi_resinfo->rsi_masternode =
+                               target_lkb->lkb_resource->res_nodeid;
+               else
+                       qinfo->gqi_resinfo->rsi_masternode = our_nodeid();
+               qinfo->gqi_resinfo->rsi_length =
+                       target_lkb->lkb_resource->res_length;
+               memcpy(qinfo->gqi_resinfo->rsi_name,
+                      target_lkb->lkb_resource->res_name,
+                      qinfo->gqi_resinfo->rsi_length);
+       }
+
+       /* If the master is local (or the user doesn't want the overhead of a
+        * remote call) - fill in the details here */
+       if (target_lkb->lkb_resource->res_nodeid == 0 ||
+           (query & DLM_QUERY_LOCAL)) {
+
+               status = 0;
+               /* Resource info */
+               if (qinfo->gqi_resinfo) {
+                       query_resource(target_lkb->lkb_resource,
+                                      qinfo->gqi_resinfo);
+               }
+
+               /* Lock lists */
+               if (qinfo->gqi_lockinfo) {
+                       status = query_locks(query, target_lkb, qinfo);
+               }
+
+               query_lkb->lkb_retstatus = status;
+               query_lkb->lkb_flags |= GDLM_LKFLG_DELAST;
+               queue_ast(query_lkb, GDLM_QUEUE_COMPAST, 0);
+               wake_astd();
+
+               /* An AST will be delivered so we must return success here */
+               status = 0;
+               goto out;
+       }
+
+       /* Remote master */
+       if (target_lkb->lkb_resource->res_nodeid != 0)
+       {
+               struct gd_remquery *remquery;
+               struct writequeue_entry *e;
+
+               /* Clear this cos the receiving end adds to it with
+                  each incoming packet */
+               qinfo->gqi_lockcount = 0;
+
+               /* Squirrel a pointer to the query info struct
+                  somewhere illegal */
+               query_lkb->lkb_request = (struct gd_remlockrequest *) qinfo;
+
+               e = lowcomms_get_buffer(query_lkb->lkb_resource->res_nodeid,
+                                       sizeof(struct gd_remquery),
+                                       ls->ls_allocation,
+                                       (char **) &remquery);
+               if (!e) {
+                       status = -ENOBUFS;
+                       goto out;
+               }
+
+               /* Build remote packet */
+               memset(remquery, 0, sizeof(struct gd_remquery));
+
+               remquery->rq_maxlocks  = qinfo->gqi_locksize;
+               remquery->rq_query     = query;
+               remquery->rq_mstlkid   = target_lkb->lkb_remid;
+               if (qinfo->gqi_lockinfo)
+                       remquery->rq_maxlocks = qinfo->gqi_locksize;
+
+               remquery->rq_header.rh_cmd       = GDLM_REMCMD_QUERY;
+               remquery->rq_header.rh_flags     = 0;
+               remquery->rq_header.rh_length    = sizeof(struct gd_remquery);
+               remquery->rq_header.rh_lkid      = query_lkb->lkb_id;
+               remquery->rq_header.rh_lockspace = ls->ls_global_id;
+
+               midcomms_send_buffer(&remquery->rq_header, e);
+               status = 0;
+       }
+
+      out:
+
+       return status;
+}
+
+static inline int valid_range(struct dlm_range *r)
+{
+    if (r->ra_start != 0ULL ||
+       r->ra_end != 0xFFFFFFFFFFFFFFFFULL)
+       return 1;
+    else
+       return 0;
+}
+
+static void put_int(int x, char *buf, int *offp)
+{
+        x = cpu_to_le32(x);
+        memcpy(buf + *offp, &x, sizeof(int));
+        *offp += sizeof(int);
+}
+
+static void put_int64(uint64_t x, char *buf, int *offp)
+{
+        x = cpu_to_le64(x);
+        memcpy(buf + *offp, &x, sizeof(uint64_t));
+        *offp += sizeof(uint64_t);
+}
+
+static int get_int(char *buf, int *offp)
+{
+        int value;
+        memcpy(&value, buf + *offp, sizeof(int));
+        *offp += sizeof(int);
+        return le32_to_cpu(value);
+}
+
+static uint64_t get_int64(char *buf, int *offp)
+{
+        uint64_t value;
+
+        memcpy(&value, buf + *offp, sizeof(uint64_t));
+        *offp += sizeof(uint64_t);
+        return le64_to_cpu(value);
+}
+
+#define LOCK_LEN (sizeof(int)*4 + sizeof(uint8_t)*4)
+
+/* Called from recvd to get lock info for a remote node */
+int remote_query(int nodeid, gd_ls_t *ls, struct gd_req_header *msg)
+{
+        struct gd_remquery *query = (struct gd_remquery *) msg;
+       struct gd_remqueryreply *reply;
+       struct dlm_resinfo resinfo;
+       struct dlm_queryinfo qinfo;
+       struct writequeue_entry *e;
+       char *buf;
+       gd_lkb_t *lkb;
+       int status = 0;
+       int bufidx;
+       int finished = 0;
+       int cur_lock = 0;
+       int start_lock = 0;
+
+       lkb = find_lock_by_id(ls, query->rq_mstlkid);
+       if (!lkb) {
+               status = -EINVAL;
+               goto send_error;
+       }
+
+       qinfo.gqi_resinfo = &resinfo;
+       qinfo.gqi_locksize = query->rq_maxlocks;
+
+       /* Get the resource bits */
+       query_resource(lkb->lkb_resource, &resinfo);
+
+       /* Now get the locks if wanted */
+       if (query->rq_maxlocks) {
+               qinfo.gqi_lockinfo = kmalloc(sizeof(struct dlm_lockinfo) * query->rq_maxlocks,
+                                            GFP_KERNEL);
+               if (!qinfo.gqi_lockinfo) {
+                       status = -ENOMEM;
+                       goto send_error;
+               }
+
+               status = query_locks(query->rq_query, lkb, &qinfo);
+               if (status && status != -E2BIG) {
+                       kfree(qinfo.gqi_lockinfo);
+                       goto send_error;
+               }
+       }
+       else {
+               qinfo.gqi_lockinfo = NULL;
+               qinfo.gqi_lockcount = 0;
+       }
+
+       /* Send as many blocks as needed for all the locks */
+       do {
+               int i;
+               int msg_len = sizeof(struct gd_remqueryreply);
+               int last_msg_len = msg_len; /* keeps compiler quiet */
+               int last_lock;
+
+               /* First work out how many locks we can fit into a block */
+               for (i=cur_lock; i < qinfo.gqi_lockcount && msg_len < PAGE_SIZE; i++) {
+
+                       last_msg_len = msg_len;
+
+                       msg_len += LOCK_LEN;
+                       if (valid_range(&qinfo.gqi_lockinfo[i].lki_grrange) ||
+                           valid_range(&qinfo.gqi_lockinfo[i].lki_rqrange)) {
+
+                               msg_len += sizeof(uint64_t) * 4;
+                       }
+               }
+
+               /* There must be a neater way of doing this... */
+               if (msg_len > PAGE_SIZE) {
+                       last_lock = i-1;
+                       msg_len = last_msg_len;
+               }
+               else {
+                       last_lock = i;
+               }
+
+               e = lowcomms_get_buffer(nodeid,
+                                       msg_len,
+                                       ls->ls_allocation,
+                                       (char **) &reply);
+               if (!e) {
+                       kfree(qinfo.gqi_lockinfo);
+                       status = -ENOBUFS;
+                       goto out;
+               }
+
+               reply->rq_header.rh_cmd       = GDLM_REMCMD_QUERYREPLY;
+               reply->rq_header.rh_length    = msg_len;
+               reply->rq_header.rh_lkid      = msg->rh_lkid;
+               reply->rq_header.rh_lockspace = msg->rh_lockspace;
+
+               reply->rq_status     = status;
+               reply->rq_startlock  = cur_lock;
+               reply->rq_grantcount = qinfo.gqi_resinfo->rsi_grantcount;
+               reply->rq_convcount  = qinfo.gqi_resinfo->rsi_convcount;
+               reply->rq_waitcount  = qinfo.gqi_resinfo->rsi_waitcount;
+               memcpy(reply->rq_valblk, qinfo.gqi_resinfo->rsi_valblk, DLM_LVB_LEN);
+
+               buf = (char *)reply;
+               bufidx = sizeof(struct gd_remqueryreply);
+
+               for (; cur_lock < last_lock; cur_lock++) {
+
+                       buf[bufidx++] = qinfo.gqi_lockinfo[cur_lock].lki_state;
+                       buf[bufidx++] = qinfo.gqi_lockinfo[cur_lock].lki_grmode;
+                       buf[bufidx++] = qinfo.gqi_lockinfo[cur_lock].lki_rqmode;
+                       put_int(qinfo.gqi_lockinfo[cur_lock].lki_lkid, buf, &bufidx);
+                       put_int(qinfo.gqi_lockinfo[cur_lock].lki_mstlkid, buf, &bufidx);
+                       put_int(qinfo.gqi_lockinfo[cur_lock].lki_parent, buf, &bufidx);
+                       put_int(qinfo.gqi_lockinfo[cur_lock].lki_node, buf, &bufidx);
+
+                       if (valid_range(&qinfo.gqi_lockinfo[cur_lock].lki_grrange) ||
+                           valid_range(&qinfo.gqi_lockinfo[cur_lock].lki_rqrange)) {
+
+                               buf[bufidx++] = 1;
+                               put_int64(qinfo.gqi_lockinfo[cur_lock].lki_grrange.ra_start, buf, &bufidx);
+                               put_int64(qinfo.gqi_lockinfo[cur_lock].lki_grrange.ra_end, buf, &bufidx);
+                               put_int64(qinfo.gqi_lockinfo[cur_lock].lki_rqrange.ra_start, buf, &bufidx);
+                               put_int64(qinfo.gqi_lockinfo[cur_lock].lki_rqrange.ra_end, buf, &bufidx);
+                       }
+                       else {
+                               buf[bufidx++] = 0;
+                       }
+               }
+
+               if (cur_lock == qinfo.gqi_lockcount) {
+                       reply->rq_header.rh_flags = GDLM_REMFLAG_ENDQUERY;
+                       finished = 1;
+               }
+               else {
+                       reply->rq_header.rh_flags = 0;
+               }
+
+               reply->rq_numlocks = cur_lock - start_lock;
+               start_lock = cur_lock;
+
+               midcomms_send_buffer(&reply->rq_header, e);
+       } while (!finished);
+
+       kfree(qinfo.gqi_lockinfo);
+ out:
+       return status;
+
+ send_error:
+       e = lowcomms_get_buffer(nodeid,
+                               sizeof(struct gd_remqueryreply),
+                               ls->ls_allocation,
+                               (char **) &reply);
+       if (!e) {
+               status =  -ENOBUFS;
+               goto out;
+       }
+       reply->rq_header.rh_cmd = GDLM_REMCMD_QUERYREPLY;
+       reply->rq_header.rh_flags = GDLM_REMFLAG_ENDQUERY; /* Don't support multiple blocks yet */
+       reply->rq_header.rh_length = sizeof(struct gd_remqueryreply);
+       reply->rq_header.rh_lkid = msg->rh_lkid;
+       reply->rq_header.rh_lockspace = msg->rh_lockspace;
+       reply->rq_status     = status;
+       reply->rq_numlocks   = 0;
+       reply->rq_startlock  = 0;
+       reply->rq_grantcount = 0;
+       reply->rq_convcount  = 0;
+       reply->rq_waitcount  = 0;
+
+       midcomms_send_buffer(&reply->rq_header, e);
+
+       return status;
+}
+
+/* Reply to a remote query */
+int remote_query_reply(int nodeid, gd_ls_t *ls, struct gd_req_header *msg)
+{
+       gd_lkb_t *query_lkb;
+       struct dlm_queryinfo *qinfo;
+       struct gd_remqueryreply *reply;
+       char *buf;
+       int i;
+       int bufidx;
+
+       query_lkb = find_lock_by_id(ls, msg->rh_lkid);
+       if (!query_lkb)
+               return -EINVAL;
+
+       qinfo = (struct dlm_queryinfo *) query_lkb->lkb_request;
+       reply = (struct gd_remqueryreply *) msg;
+
+       /* Copy the easy bits first */
+       qinfo->gqi_lockcount += reply->rq_numlocks;
+       if (qinfo->gqi_resinfo) {
+               qinfo->gqi_resinfo->rsi_grantcount = reply->rq_grantcount;
+               qinfo->gqi_resinfo->rsi_convcount = reply->rq_convcount;
+               qinfo->gqi_resinfo->rsi_waitcount = reply->rq_waitcount;
+               memcpy(qinfo->gqi_resinfo->rsi_valblk, reply->rq_valblk,
+                       DLM_LVB_LEN);
+       }
+
+       /* Now unpack the locks */
+       bufidx = sizeof(struct gd_remqueryreply);
+       buf = (char *) msg;
+
+       GDLM_ASSERT(reply->rq_startlock + reply->rq_numlocks <= qinfo->gqi_locksize,
+                   printk("start = %d, num + %d. Max=  %d\n",
+                          reply->rq_startlock, reply->rq_numlocks, qinfo->gqi_locksize););
+
+       for (i = reply->rq_startlock;
+            i < reply->rq_startlock + reply->rq_numlocks; i++) {
+               qinfo->gqi_lockinfo[i].lki_state = buf[bufidx++];
+               qinfo->gqi_lockinfo[i].lki_grmode = buf[bufidx++];
+               qinfo->gqi_lockinfo[i].lki_rqmode = buf[bufidx++];
+               qinfo->gqi_lockinfo[i].lki_lkid = get_int(buf, &bufidx);
+               qinfo->gqi_lockinfo[i].lki_mstlkid = get_int(buf, &bufidx);
+               qinfo->gqi_lockinfo[i].lki_parent = get_int(buf, &bufidx);
+               qinfo->gqi_lockinfo[i].lki_node = get_int(buf, &bufidx);
+               if (buf[bufidx++]) {
+                       qinfo->gqi_lockinfo[i].lki_grrange.ra_start = get_int64(buf, &bufidx);
+                       qinfo->gqi_lockinfo[i].lki_grrange.ra_end   = get_int64(buf, &bufidx);
+                       qinfo->gqi_lockinfo[i].lki_rqrange.ra_start = get_int64(buf, &bufidx);
+                       qinfo->gqi_lockinfo[i].lki_rqrange.ra_end   = get_int64(buf, &bufidx);
+               }
+               else {
+                       qinfo->gqi_lockinfo[i].lki_grrange.ra_start = 0ULL;
+                       qinfo->gqi_lockinfo[i].lki_grrange.ra_end   = 0xFFFFFFFFFFFFFFFFULL;
+                       qinfo->gqi_lockinfo[i].lki_rqrange.ra_start = 0ULL;
+                       qinfo->gqi_lockinfo[i].lki_rqrange.ra_end   = 0xFFFFFFFFFFFFFFFFULL;
+               }
+       }
+
+       /* If this was the last block then now tell the user */
+       if (msg->rh_flags & GDLM_REMFLAG_ENDQUERY) {
+               query_lkb->lkb_retstatus = reply->rq_status;
+               query_lkb->lkb_flags |= GDLM_LKFLG_DELAST;
+               queue_ast(query_lkb, GDLM_QUEUE_COMPAST, 0);
+               wake_astd();
+       }
+
+       return 0;
+}
+
+/* Aggregate resource information */
+static int query_resource(gd_res_t *rsb, struct dlm_resinfo *resinfo)
+{
+       struct list_head *tmp;
+
+
+       if (rsb->res_lvbptr)
+               memcpy(resinfo->rsi_valblk, rsb->res_lvbptr, DLM_LVB_LEN);
+
+       resinfo->rsi_grantcount = 0;
+       list_for_each(tmp, &rsb->res_grantqueue) {
+               resinfo->rsi_grantcount++;
+       }
+
+       resinfo->rsi_waitcount = 0;
+       list_for_each(tmp, &rsb->res_waitqueue) {
+               resinfo->rsi_waitcount++;
+       }
+
+       resinfo->rsi_convcount = 0;
+       list_for_each(tmp, &rsb->res_convertqueue) {
+               resinfo->rsi_convcount++;
+       }
+
+       return 0;
+}
+
+static int add_lock(gd_lkb_t *lkb, struct dlm_queryinfo *qinfo)
+{
+       int entry;
+
+       /* Don't fill it in if the buffer is full */
+       if (qinfo->gqi_lockcount == qinfo->gqi_locksize)
+               return -E2BIG;
+
+       /* gqi_lockcount contains the number of locks we have returned */
+       entry = qinfo->gqi_lockcount++;
+
+       /* Fun with master copies */
+       if (lkb->lkb_flags & GDLM_LKFLG_MSTCPY) {
+               qinfo->gqi_lockinfo[entry].lki_lkid = lkb->lkb_remid;
+               qinfo->gqi_lockinfo[entry].lki_mstlkid = lkb->lkb_id;
+       }
+       else {
+               qinfo->gqi_lockinfo[entry].lki_lkid = lkb->lkb_id;
+               qinfo->gqi_lockinfo[entry].lki_mstlkid = lkb->lkb_remid;
+       }
+
+       /* Also make sure we always have a valid nodeid in there, the
+          calling end may not know which node "0" is */
+       if (lkb->lkb_nodeid)
+           qinfo->gqi_lockinfo[entry].lki_node = lkb->lkb_nodeid;
+       else
+           qinfo->gqi_lockinfo[entry].lki_node = our_nodeid();
+
+       if (lkb->lkb_parent)
+               qinfo->gqi_lockinfo[entry].lki_parent = lkb->lkb_parent->lkb_id;
+       else
+               qinfo->gqi_lockinfo[entry].lki_parent = 0;
+
+       qinfo->gqi_lockinfo[entry].lki_state  = lkb->lkb_status;
+       qinfo->gqi_lockinfo[entry].lki_rqmode = lkb->lkb_rqmode;
+       qinfo->gqi_lockinfo[entry].lki_grmode = lkb->lkb_grmode;
+
+       if (lkb->lkb_range) {
+               qinfo->gqi_lockinfo[entry].lki_grrange.ra_start =
+                       lkb->lkb_range[GR_RANGE_START];
+               qinfo->gqi_lockinfo[entry].lki_grrange.ra_end =
+                       lkb->lkb_range[GR_RANGE_END];
+               qinfo->gqi_lockinfo[entry].lki_rqrange.ra_start =
+                       lkb->lkb_range[RQ_RANGE_START];
+               qinfo->gqi_lockinfo[entry].lki_rqrange.ra_end =
+                       lkb->lkb_range[RQ_RANGE_END];
+       } else {
+               qinfo->gqi_lockinfo[entry].lki_grrange.ra_start = 0ULL;
+               qinfo->gqi_lockinfo[entry].lki_grrange.ra_start = 0xffffffffffffffffULL;
+               qinfo->gqi_lockinfo[entry].lki_rqrange.ra_start = 0ULL;
+               qinfo->gqi_lockinfo[entry].lki_rqrange.ra_start = 0xffffffffffffffffULL;
+       }
+       return 0;
+}
+
+static int query_lkb_queue(struct list_head *queue, int query,
+                          struct dlm_queryinfo *qinfo)
+{
+       struct list_head *tmp;
+       int status = 0;
+       int mode = query & DLM_QUERY_MODE_MASK;
+
+       list_for_each(tmp, queue) {
+               gd_lkb_t *lkb = list_entry(tmp, gd_lkb_t, lkb_statequeue);
+               int lkmode;
+
+               if (query & DLM_QUERY_RQMODE)
+                       lkmode = lkb->lkb_rqmode;
+               else
+                       lkmode = lkb->lkb_grmode;
+
+               /* Add the LKB info to the list if it matches the criteria in
+                * the query bitmap */
+               switch (query & DLM_QUERY_MASK) {
+               case DLM_QUERY_LOCKS_ALL:
+                       status = add_lock(lkb, qinfo);
+                       break;
+
+               case DLM_QUERY_LOCKS_HIGHER:
+                       if (lkmode > mode)
+                               status = add_lock(lkb, qinfo);
+                       break;
+
+               case DLM_QUERY_LOCKS_EQUAL:
+                       if (lkmode == mode)
+                               status = add_lock(lkb, qinfo);
+                       break;
+
+               case DLM_QUERY_LOCKS_LOWER:
+                       if (lkmode < mode)
+                               status = add_lock(lkb, qinfo);
+                       break;
+               }
+       }
+       return status;
+}
+
+/*
+ * Return 1 if the locks' ranges overlap
+ * If the lkb has no range then it is assumed to cover 0-ffffffff.ffffffff
+ */
+static inline int ranges_overlap(gd_lkb_t *lkb1, gd_lkb_t *lkb2)
+{
+       if (!lkb1->lkb_range || !lkb2->lkb_range)
+               return 1;
+
+       if (lkb1->lkb_range[RQ_RANGE_END] <= lkb2->lkb_range[GR_RANGE_START] ||
+           lkb1->lkb_range[RQ_RANGE_START] >= lkb2->lkb_range[GR_RANGE_END])
+               return 0;
+
+       return 1;
+}
+extern const int __dlm_compat_matrix[8][8];
+
+
+static int get_blocking_locks(gd_lkb_t *qlkb, struct dlm_queryinfo *qinfo)
+{
+       struct list_head *tmp;
+       int status = 0;
+
+       list_for_each(tmp, &qlkb->lkb_resource->res_grantqueue) {
+               gd_lkb_t *lkb = list_entry(tmp, gd_lkb_t, lkb_statequeue);
+
+               if (ranges_overlap(lkb, qlkb) &&
+                   !__dlm_compat_matrix[lkb->lkb_grmode + 1][qlkb->lkb_rqmode + 1])
+                       status = add_lock(lkb, qinfo);
+       }
+
+       return status;
+}
+
+static int get_nonblocking_locks(gd_lkb_t *qlkb, struct dlm_queryinfo *qinfo)
+{
+       struct list_head *tmp;
+       int status = 0;
+
+       list_for_each(tmp, &qlkb->lkb_resource->res_grantqueue) {
+               gd_lkb_t *lkb = list_entry(tmp, gd_lkb_t, lkb_statequeue);
+
+               if (!(ranges_overlap(lkb, qlkb) &&
+                     !__dlm_compat_matrix[lkb->lkb_grmode + 1][qlkb->lkb_rqmode + 1]))
+                       status = add_lock(lkb, qinfo);
+       }
+
+       return status;
+}
+
+/* Gather a list of appropriate locks */
+static int query_locks(int query, gd_lkb_t *lkb, struct dlm_queryinfo *qinfo)
+{
+       int status = 0;
+
+
+       /* Mask in the actual granted/requsted mode of the lock if LOCK_THIS
+        * was requested as the mode
+        */
+       if ((query & DLM_QUERY_MODE_MASK) == DLM_LOCK_THIS) {
+               query &= ~DLM_QUERY_MODE_MASK;
+               if (query & DLM_QUERY_RQMODE)
+                       query |= lkb->lkb_rqmode;
+               else
+                       query |= lkb->lkb_grmode;
+       }
+
+       qinfo->gqi_lockcount = 0;
+
+       /* BLOCKING/NOTBLOCK only look at the granted queue */
+       if ((query & DLM_QUERY_MASK) == DLM_QUERY_LOCKS_BLOCKING)
+               return get_blocking_locks(lkb, qinfo);
+
+       if ((query & DLM_QUERY_MASK) == DLM_QUERY_LOCKS_NOTBLOCK)
+               return get_nonblocking_locks(lkb, qinfo);
+
+        /* Do the lock queues that were requested */
+       if (query & DLM_QUERY_QUEUE_GRANT) {
+               status = query_lkb_queue(&lkb->lkb_resource->res_grantqueue,
+                                        query, qinfo);
+       }
+
+       if (!status && (query & DLM_QUERY_QUEUE_CONVERT)) {
+               status = query_lkb_queue(&lkb->lkb_resource->res_convertqueue,
+                                        query, qinfo);
+       }
+
+       if (!status && (query & DLM_QUERY_QUEUE_WAIT)) {
+               status = query_lkb_queue(&lkb->lkb_resource->res_waitqueue,
+                                        query, qinfo);
+       }
+
+
+       return status;
+}
+
+EXPORT_SYMBOL(dlm_query);
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */
diff -urN linux-orig/cluster/dlm/queries.h linux-patched/cluster/dlm/queries.h
--- linux-orig/cluster/dlm/queries.h    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/queries.h 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,20 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __QUERIES_DOT_H__
+#define __QUERIES_DOT_H__
+
+extern int remote_query(int nodeid, gd_ls_t *ls, struct gd_req_header *msg);
+extern int remote_query_reply(int nodeid, gd_ls_t *ls, struct gd_req_header *msg);
+
+#endif                          /* __QUERIES_DOT_H__ */
diff -urN linux-orig/cluster/dlm/rebuild.c linux-patched/cluster/dlm/rebuild.c
--- linux-orig/cluster/dlm/rebuild.c    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/rebuild.c 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,1246 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/* 
+ * Rebuild RSB's on new masters.  Functions for transferring locks and
+ * subresources to new RSB masters during recovery.
+ */
+
+#include "dlm_internal.h"
+#include "reccomms.h"
+#include "lkb.h"
+#include "rsb.h"
+#include "nodes.h"
+#include "config.h"
+#include "memory.h"
+#include "recover.h"
+
+
+/* Types of entity serialised in remastering messages */
+#define REMASTER_ROOTRSB 1
+#define REMASTER_RSB     2
+#define REMASTER_LKB     3
+
+struct rcom_fill {
+       char *                  outbuf;         /* Beginning of data */
+       int                     offset;         /* Current offset into outbuf */
+       int                     maxlen;         /* Max value of offset */
+       int                     remasterid;
+       int                     count;
+       gd_res_t *              rsb;
+       gd_res_t *              subrsb;
+       gd_lkb_t *              lkb;
+       struct list_head *      lkbqueue;
+       char                    more;
+};
+typedef struct rcom_fill rcom_fill_t;
+
+
+struct rebuild_node {
+       struct list_head        list;
+       int                     nodeid;
+       gd_res_t *              rootrsb;
+};
+typedef struct rebuild_node rebuild_node_t;
+
+
+/* 
+ * Root rsb passed in for which all lkb's (own and subrsbs) will be sent to new
+ * master.  The rsb will be "done" with recovery when the new master has
+ * replied with all the new remote lockid's for this rsb's lkb's.
+ */
+
+void expect_new_lkids(gd_res_t *rsb)
+{
+       rsb->res_newlkid_expect = 0;
+       recover_list_add(rsb);
+}
+
+/* 
+ * This function is called on root rsb or subrsb when another lkb is being sent
+ * to the new master for which we expect to receive a corresponding remote lkid
+ */
+
+void need_new_lkid(gd_res_t *rsb)
+{
+       gd_res_t *root = rsb;
+
+       if (rsb->res_parent)
+               root = rsb->res_root;
+
+       if (!root->res_newlkid_expect)
+               recover_list_add(root);
+       else
+               GDLM_ASSERT(test_bit(RESFL_RECOVER_LIST, &root->res_flags),);
+
+       root->res_newlkid_expect++;
+}
+
+/* 
+ * This function is called for each lkb for which a new remote lkid is
+ * received.  Decrement the expected number of remote lkids expected for the
+ * root rsb.
+ */
+
+void have_new_lkid(gd_lkb_t *lkb)
+{
+       gd_res_t *root = lkb->lkb_resource;
+
+       if (root->res_parent)
+               root = root->res_root;
+
+       down_write(&root->res_lock);
+
+       GDLM_ASSERT(root->res_newlkid_expect,
+                   printk("newlkid_expect=%d\n", root->res_newlkid_expect););
+
+       root->res_newlkid_expect--;
+
+       if (!root->res_newlkid_expect) {
+               clear_bit(RESFL_NEW_MASTER, &root->res_flags);
+               recover_list_del(root);
+       }
+       up_write(&root->res_lock);
+}
+
+/* 
+ * Return the rebuild struct for a node - will create an entry on the rootrsb
+ * list if necessary.
+ *
+ * Currently no locking is needed here as it all happens in the gdlm_recvd
+ * thread
+ */
+
+static rebuild_node_t *find_rebuild_root(gd_ls_t *ls, int nodeid)
+{
+       rebuild_node_t *node = NULL;
+
+       list_for_each_entry(node, &ls->ls_rebuild_rootrsb_list, list) {
+               if (node->nodeid == nodeid)
+                       return node;
+       }
+
+       /* Not found, add one */
+       node = kmalloc(sizeof(rebuild_node_t), GFP_KERNEL);
+       if (!node)
+               return NULL;
+
+       node->nodeid = nodeid;
+       node->rootrsb = NULL;
+       list_add(&node->list, &ls->ls_rebuild_rootrsb_list);
+
+       return node;
+}
+
+/* 
+ * Tidy up after a rebuild run.  Called when all recovery has finished
+ */
+
+void rebuild_freemem(gd_ls_t *ls)
+{
+       rebuild_node_t *node = NULL, *s;
+
+       list_for_each_entry_safe(node, s, &ls->ls_rebuild_rootrsb_list, list) {
+               list_del(&node->list);
+               kfree(node);
+       }
+}
+
+static void put_int(int x, char *buf, int *offp)
+{
+       x = cpu_to_le32(x);
+       memcpy(buf + *offp, &x, sizeof(int));
+       *offp += sizeof(int);
+}
+
+static void put_int64(uint64_t x, char *buf, int *offp)
+{
+       x = cpu_to_le64(x);
+       memcpy(buf + *offp, &x, sizeof(uint64_t));
+       *offp += sizeof(uint64_t);
+}
+
+static void put_bytes(char *x, int len, char *buf, int *offp)
+{
+       put_int(len, buf, offp);
+       memcpy(buf + *offp, x, len);
+       *offp += len;
+}
+
+static void put_char(char x, char *buf, int *offp)
+{
+       buf[*offp] = x;
+       *offp += 1;
+}
+
+static int get_int(char *buf, int *offp)
+{
+       int value;
+       memcpy(&value, buf + *offp, sizeof(int));
+       *offp += sizeof(int);
+       return le32_to_cpu(value);
+}
+
+static uint64_t get_int64(char *buf, int *offp)
+{
+       uint64_t value;
+
+       memcpy(&value, buf + *offp, sizeof(uint64_t));
+       *offp += sizeof(uint64_t);
+       return le64_to_cpu(value);
+}
+
+static char get_char(char *buf, int *offp)
+{
+       char x = buf[*offp];
+
+       *offp += 1;
+       return x;
+}
+
+static void get_bytes(char *bytes, int *len, char *buf, int *offp)
+{
+       *len = get_int(buf, offp);
+       memcpy(bytes, buf + *offp, *len);
+       *offp += *len;
+}
+
+static int lkb_length(gd_lkb_t *lkb)
+{
+       int len = 0;
+
+       len += sizeof(int);     /* lkb_id */
+       len += sizeof(int);     /* lkb_resource->res_reamasterid */
+       len += sizeof(int);     /* lkb_flags */
+       len += sizeof(int);     /* lkb_status */
+       len += sizeof(char);    /* lkb_rqmode */
+       len += sizeof(char);    /* lkb_grmode */
+       len += sizeof(int);     /* lkb_childcnt */
+       len += sizeof(int);     /* lkb_parent->lkb_id */
+       len += sizeof(int);     /* lkb_bastaddr */
+
+       if (lkb->lkb_flags & GDLM_LKFLG_VALBLK) {
+               len += sizeof(int);     /* number of lvb bytes */
+               len += DLM_LVB_LEN;
+       }
+
+       if (lkb->lkb_range) {
+               len += sizeof(uint64_t);
+               len += sizeof(uint64_t);
+               if (lkb->lkb_status == GDLM_LKSTS_CONVERT) {
+                       len += sizeof(uint64_t);
+                       len += sizeof(uint64_t);
+               }
+       }
+
+       return len;
+}
+
+/* 
+ * It's up to the caller to be sure there's enough space in the buffer.
+ */
+
+static void serialise_lkb(gd_lkb_t *lkb, char *buf, int *offp)
+{
+       int flags;
+
+       /* Need to tell the remote end if we have a range */
+       flags = lkb->lkb_flags;
+       if (lkb->lkb_range)
+               flags |= GDLM_LKFLG_RANGE;
+
+       /* 
+        * See lkb_length()
+        * Total: 30 (no lvb) or 66 (with lvb) bytes
+        */
+
+       put_int(lkb->lkb_id, buf, offp);
+       put_int(lkb->lkb_resource->res_remasterid, buf, offp);
+       put_int(flags, buf, offp);
+       put_int(lkb->lkb_status, buf, offp);
+       put_char(lkb->lkb_rqmode, buf, offp);
+       put_char(lkb->lkb_grmode, buf, offp);
+       put_int(atomic_read(&lkb->lkb_childcnt), buf, offp);
+
+       if (lkb->lkb_parent)
+               put_int(lkb->lkb_parent->lkb_id, buf, offp);
+       else
+               put_int(0, buf, offp);
+
+       if (lkb->lkb_bastaddr)
+               put_int(1, buf, offp);
+       else
+               put_int(0, buf, offp);
+
+       if (lkb->lkb_flags & GDLM_LKFLG_VALBLK) {
+               GDLM_ASSERT(lkb->lkb_lvbptr,);
+               put_bytes(lkb->lkb_lvbptr, DLM_LVB_LEN, buf, offp);
+       }
+
+       /* Only send the range we actually need */
+       if (lkb->lkb_range) {
+               switch (lkb->lkb_status) {
+               case GDLM_LKSTS_CONVERT:
+                       put_int64(lkb->lkb_range[RQ_RANGE_START], buf, offp);
+                       put_int64(lkb->lkb_range[RQ_RANGE_END], buf, offp);
+                       put_int64(lkb->lkb_range[GR_RANGE_START], buf, offp);
+                       put_int64(lkb->lkb_range[GR_RANGE_END], buf, offp);
+                       break;
+               case GDLM_LKSTS_WAITING:
+                       put_int64(lkb->lkb_range[RQ_RANGE_START], buf, offp);
+                       put_int64(lkb->lkb_range[RQ_RANGE_END], buf, offp);
+                       break;
+               case GDLM_LKSTS_GRANTED:
+                       put_int64(lkb->lkb_range[GR_RANGE_START], buf, offp);
+                       put_int64(lkb->lkb_range[GR_RANGE_END], buf, offp);
+                       break;
+               default:
+                       GDLM_ASSERT(0,);
+               }
+       }
+}
+
+static int rsb_length(gd_res_t *rsb)
+{
+       int len = 0;
+
+       len += sizeof(int);     /* number of res_name bytes */
+       len += rsb->res_length; /* res_name */
+       len += sizeof(int);     /* res_remasterid */
+       len += sizeof(int);     /* res_parent->res_remasterid */
+
+       return len;
+}
+
+static inline gd_res_t *next_subrsb(gd_res_t *subrsb)
+{
+       struct list_head *tmp;
+       gd_res_t *r;
+
+       tmp = subrsb->res_subreslist.next;
+       r = list_entry(tmp, gd_res_t, res_subreslist);
+
+       return r;
+}
+
+static inline int last_in_list(gd_res_t *r, struct list_head *head)
+{
+       gd_res_t *last = list_entry(head->prev, gd_res_t, res_subreslist);
+
+       if (last == r)
+               return 1;
+       return 0;
+}
+
+/* 
+ * Used to decide if an rsb should be rebuilt on a new master.  An rsb only
+ * needs to be rebuild if we have lkb's queued on it.  NOREBUILD lkb's on the
+ * wait queue are not rebuilt.
+ */
+
+static int lkbs_to_remaster(gd_res_t *r)
+{
+       gd_lkb_t *lkb;
+       gd_res_t *sub;
+
+       if (!list_empty(&r->res_grantqueue) ||
+           !list_empty(&r->res_convertqueue))
+               return TRUE;
+
+       list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) {
+               if (lkb->lkb_flags & GDLM_LKFLG_NOREBUILD)
+                       continue;
+               return TRUE;
+       }
+
+       list_for_each_entry(sub, &r->res_subreslist, res_subreslist) {
+               if (!list_empty(&sub->res_grantqueue) ||
+                   !list_empty(&sub->res_convertqueue))
+                       return TRUE;
+
+               list_for_each_entry(lkb, &sub->res_waitqueue, lkb_statequeue) {
+                       if (lkb->lkb_flags & GDLM_LKFLG_NOREBUILD)
+                               continue;
+                       return TRUE;
+               }
+       }
+
+       return FALSE;
+}
+
+static void serialise_rsb(gd_res_t *rsb, char *buf, int *offp)
+{
+       /* 
+        * See rsb_length()
+        * Total: 36 bytes (4 + 24 + 4 + 4)
+        */
+
+       put_bytes(rsb->res_name, rsb->res_length, buf, offp);
+       put_int(rsb->res_remasterid, buf, offp);
+
+       if (rsb->res_parent)
+               put_int(rsb->res_parent->res_remasterid, buf, offp);
+       else
+               put_int(0, buf, offp);
+
+       GDLM_ASSERT(!rsb->res_lvbptr,);
+}
+
+/* 
+ * Flatten an LKB into a buffer for sending to the new RSB master.  As a
+ * side-effect the nodeid of the lock is set to the nodeid of the new RSB
+ * master.
+ */
+
+static int pack_one_lkb(gd_res_t *r, gd_lkb_t *lkb, rcom_fill_t *fill)
+{
+       if (fill->offset + 1 + lkb_length(lkb) > fill->maxlen)
+               goto nospace;
+
+       lkb->lkb_nodeid = r->res_nodeid;
+
+       put_char(REMASTER_LKB, fill->outbuf, &fill->offset);
+       serialise_lkb(lkb, fill->outbuf, &fill->offset);
+
+       fill->count++;
+       need_new_lkid(r);
+       return 0;
+
+      nospace:
+       return -ENOSPC;
+}
+
+/* 
+ * Pack all LKB's from a given queue, except for those with the NOREBUILD flag.
+ */
+
+static int pack_lkb_queue(gd_res_t *r, struct list_head *queue,
+                         rcom_fill_t *fill)
+{
+       gd_lkb_t *lkb;
+       int error;
+
+       list_for_each_entry(lkb, queue, lkb_statequeue) {
+               if (lkb->lkb_flags & GDLM_LKFLG_NOREBUILD)
+                       continue;
+
+               error = pack_one_lkb(r, lkb, fill);
+               if (error)
+                       goto nospace;
+       }
+
+       return 0;
+
+      nospace:
+       fill->lkb = lkb;
+       fill->lkbqueue = queue;
+
+       return error;
+}
+
+static int pack_lkb_queues(gd_res_t *r, rcom_fill_t *fill)
+{
+       int error;
+
+       error = pack_lkb_queue(r, &r->res_grantqueue, fill);
+       if (error)
+               goto nospace;
+
+       error = pack_lkb_queue(r, &r->res_convertqueue, fill);
+       if (error)
+               goto nospace;
+
+       error = pack_lkb_queue(r, &r->res_waitqueue, fill);
+
+      nospace:
+       return error;
+}
+
+/* 
+ * Pack remaining lkb's for rsb or subrsb.  This may include a partial lkb
+ * queue and full lkb queues.
+ */
+
+static int pack_lkb_remaining(gd_res_t *r, rcom_fill_t *fill)
+{
+       struct list_head *tmp, *start, *end;
+       gd_lkb_t *lkb;
+       int error;
+
+       /* 
+        * Beginning with fill->lkb, pack remaining lkb's on fill->lkbqueue.
+        */
+
+       error = pack_one_lkb(r, fill->lkb, fill);
+       if (error)
+               goto out;
+
+       start = fill->lkb->lkb_statequeue.next;
+       end = fill->lkbqueue;
+
+       for (tmp = start; tmp != end; tmp = tmp->next) {
+               lkb = list_entry(tmp, gd_lkb_t, lkb_statequeue);
+
+               error = pack_one_lkb(r, lkb, fill);
+               if (error) {
+                       fill->lkb = lkb;
+                       goto out;
+               }
+       }
+
+       /* 
+        * Pack all lkb's on r's queues following fill->lkbqueue.
+        */
+
+       if (fill->lkbqueue == &r->res_waitqueue)
+               goto out;
+       if (fill->lkbqueue == &r->res_convertqueue)
+               goto skip;
+
+       GDLM_ASSERT(fill->lkbqueue == &r->res_grantqueue,);
+
+       error = pack_lkb_queue(r, &r->res_convertqueue, fill);
+       if (error)
+               goto out;
+      skip:
+       error = pack_lkb_queue(r, &r->res_waitqueue, fill);
+
+      out:
+       return error;
+}
+
+static int pack_one_subrsb(gd_res_t *rsb, gd_res_t *subrsb, rcom_fill_t *fill)
+{
+       int error;
+
+       down_write(&subrsb->res_lock);
+
+       if (fill->offset + 1 + rsb_length(subrsb) > fill->maxlen)
+               goto nospace;
+
+       subrsb->res_nodeid = rsb->res_nodeid;
+       subrsb->res_remasterid = ++fill->remasterid;
+
+       put_char(REMASTER_RSB, fill->outbuf, &fill->offset);
+       serialise_rsb(subrsb, fill->outbuf, &fill->offset);
+
+       error = pack_lkb_queues(subrsb, fill);
+       if (error)
+               goto nospace;
+
+       up_write(&subrsb->res_lock);
+
+       return 0;
+
+      nospace:
+       up_write(&subrsb->res_lock);
+       fill->subrsb = subrsb;
+
+       return -ENOSPC;
+}
+
+static int pack_subrsbs(gd_res_t *rsb, gd_res_t *in_subrsb, rcom_fill_t *fill)
+{
+       gd_res_t *subrsb;
+       int error = 0;
+
+       /* 
+        * When an initial subrsb is given, we know it needs to be packed.
+        * When no initial subrsb is given, begin with the first (if any exist).
+        */
+
+       if (!in_subrsb) {
+               if (list_empty(&rsb->res_subreslist))
+                       goto out;
+
+               subrsb = list_entry(rsb->res_subreslist.next, gd_res_t,
+                                   res_subreslist);
+       } else
+               subrsb = in_subrsb;
+
+       for (;;) {
+               error = pack_one_subrsb(rsb, subrsb, fill);
+               if (error)
+                       goto out;
+
+               if (last_in_list(subrsb, &rsb->res_subreslist))
+                       break;
+
+               subrsb = next_subrsb(subrsb);
+       }
+
+      out:
+       return error;
+}
+
+/* 
+ * Finish packing whatever is left in an rsb tree.  If space runs out while
+ * finishing, save subrsb/lkb and this will be called again for the same rsb.
+ *
+ * !subrsb &&  lkb, we left off part way through root rsb's lkbs.
+ *  subrsb && !lkb, we left off just before starting a new subrsb.
+ *  subrsb &&  lkb, we left off part way through a subrsb's lkbs.
+ * !subrsb && !lkb, we shouldn't be in this function, but starting
+ *                  a new rsb in pack_rsb_tree().
+ */
+
+static int pack_rsb_tree_remaining(gd_ls_t *ls, gd_res_t *rsb,
+                                  rcom_fill_t *fill)
+{
+       gd_res_t *subrsb = NULL;
+       int error = 0;
+
+       if (!fill->subrsb && fill->lkb) {
+               error = pack_lkb_remaining(rsb, fill);
+               if (error)
+                       goto out;
+
+               error = pack_subrsbs(rsb, NULL, fill);
+               if (error)
+                       goto out;
+       }
+
+       else if (fill->subrsb && !fill->lkb) {
+               error = pack_subrsbs(rsb, fill->subrsb, fill);
+               if (error)
+                       goto out;
+       }
+
+       else if (fill->subrsb && fill->lkb) {
+               error = pack_lkb_remaining(fill->subrsb, fill);
+               if (error)
+                       goto out;
+
+               if (last_in_list(fill->subrsb, &fill->rsb->res_subreslist))
+                       goto out;
+
+               subrsb = next_subrsb(fill->subrsb);
+
+               error = pack_subrsbs(rsb, subrsb, fill);
+               if (error)
+                       goto out;
+       }
+
+       fill->subrsb = NULL;
+       fill->lkb = NULL;
+
+      out:
+       return error;
+}
+
+/* 
+ * Pack an RSB, all its LKB's, all its subrsb's and all their LKB's into a
+ * buffer.  When the buffer runs out of space, save the place to restart (the
+ * queue+lkb, subrsb, or subrsb+queue+lkb which wouldn't fit).
+ */
+
+static int pack_rsb_tree(gd_ls_t *ls, gd_res_t *rsb, rcom_fill_t *fill)
+{
+       int error = -ENOSPC;
+
+       fill->remasterid = 0;
+
+       /* 
+        * Pack the root rsb itself.  A 1 byte type precedes the serialised
+        * rsb.  Then pack the lkb's for the root rsb.
+        */
+
+       down_write(&rsb->res_lock);
+
+       if (fill->offset + 1 + rsb_length(rsb) > fill->maxlen)
+               goto out;
+
+       rsb->res_remasterid = ++fill->remasterid;
+       put_char(REMASTER_ROOTRSB, fill->outbuf, &fill->offset);
+       serialise_rsb(rsb, fill->outbuf, &fill->offset);
+
+       error = pack_lkb_queues(rsb, fill);
+       if (error)
+               goto out;
+
+       up_write(&rsb->res_lock);
+
+       /* 
+        * Pack subrsb/lkb's under the root rsb.
+        */
+
+       error = pack_subrsbs(rsb, NULL, fill);
+
+       return error;
+
+      out:
+       up_write(&rsb->res_lock);
+       return error;
+}
+
+/* 
+ * Given an RSB, return the next RSB that should be sent to a new master.
+ */
+
+static gd_res_t *next_remastered_rsb(gd_ls_t *ls, gd_res_t *rsb)
+{
+       struct list_head *tmp, *start, *end;
+       gd_res_t *r;
+
+       if (!rsb)
+               start = ls->ls_rootres.next;
+       else
+               start = rsb->res_rootlist.next;
+
+       end = &ls->ls_rootres;
+
+       for (tmp = start; tmp != end; tmp = tmp->next) {
+               r = list_entry(tmp, gd_res_t, res_rootlist);
+
+               if (test_bit(RESFL_NEW_MASTER, &r->res_flags)) {
+                       if (r->res_nodeid && lkbs_to_remaster(r)) {
+                               expect_new_lkids(r);
+                               return r;
+                       } else
+                               clear_bit(RESFL_NEW_MASTER, &r->res_flags);
+               }
+       }
+
+       return NULL;
+}
+
+/* 
+ * Given an rcom buffer, fill it with RSB's that need to be sent to a single
+ * new master node.  In the case where all the data to send to one node
+ * requires multiple messages, this function needs to resume filling each
+ * successive buffer from the point where it left off when the previous buffer
+ * filled up.
+ */
+
+static void fill_rcom_buffer(gd_ls_t *ls, rcom_fill_t *fill, uint32_t *nodeid)
+{
+       gd_res_t *rsb, *prev_rsb = fill->rsb;
+       int error;
+
+       fill->offset = 0;
+
+       if (!prev_rsb) {
+
+               /* 
+                * The first time this function is called.
+                */
+
+               rsb = next_remastered_rsb(ls, NULL);
+               if (!rsb)
+                       goto no_more;
+
+       } else if (fill->subrsb || fill->lkb) {
+
+               /* 
+                * Continue packing an rsb tree that was partially packed last
+                * time (fill->subrsb/lkb indicates where packing of last block
+                * left off)
+                */
+
+               rsb = prev_rsb;
+               *nodeid = rsb->res_nodeid;
+
+               error = pack_rsb_tree_remaining(ls, rsb, fill);
+               if (error == -ENOSPC)
+                       goto more;
+
+               rsb = next_remastered_rsb(ls, prev_rsb);
+               if (!rsb)
+                       goto no_more;
+
+               if (rsb->res_nodeid != prev_rsb->res_nodeid)
+                       goto more;
+       } else {
+               rsb = prev_rsb;
+       }
+
+       /* 
+        * Pack rsb trees into the buffer until we run out of space, run out of
+        * new rsb's or hit a new nodeid.
+        */
+
+       *nodeid = rsb->res_nodeid;
+
+       for (;;) {
+               error = pack_rsb_tree(ls, rsb, fill);
+               if (error == -ENOSPC)
+                       goto more;
+
+               prev_rsb = rsb;
+
+               rsb = next_remastered_rsb(ls, prev_rsb);
+               if (!rsb)
+                       goto no_more;
+
+               if (rsb->res_nodeid != prev_rsb->res_nodeid)
+                       goto more;
+       }
+
+      more:
+       fill->more = 1;
+       fill->rsb = rsb;
+       return;
+
+      no_more:
+       fill->more = 0;
+}
+
+/* 
+ * Send lkb's (and subrsb/lkbs) for remastered root rsbs to new masters.
+ */
+
+int rebuild_rsbs_send(gd_ls_t *ls)
+{
+       gd_rcom_t *rc;
+       rcom_fill_t fill;
+       uint32_t nodeid;
+       int error;
+
+       GDLM_ASSERT(recover_list_empty(ls),);
+
+       log_all(ls, "rebuild locks");
+
+       error = -ENOMEM;
+       rc = allocate_rcom_buffer(ls);
+       if (!rc)
+               goto ret;
+
+       error = 0;
+       memset(&fill, 0, sizeof(rcom_fill_t));
+       fill.outbuf = rc->rc_buf;
+       fill.maxlen = dlm_config.buffer_size - sizeof(gd_rcom_t);
+
+       do {
+               fill_rcom_buffer(ls, &fill, &nodeid);
+               if (!fill.offset)
+                       break;
+
+               rc->rc_datalen = fill.offset;
+               error = rcom_send_message(ls, nodeid, RECCOMM_NEWLOCKS, rc, 0);
+               if (error)
+                       goto out;
+
+               schedule();
+               error = gdlm_recovery_stopped(ls);
+               if (error)
+                       goto out;
+       }
+       while (fill.more);
+
+       error = gdlm_wait_function(ls, &recover_list_empty);
+
+       log_all(ls, "rebuilt %d locks", fill.count);
+
+      out:
+       rebuild_freemem(ls);
+       free_rcom_buffer(rc);
+
+      ret:
+       return error;
+}
+
+static gd_res_t *find_by_remasterid(gd_ls_t *ls, int remasterid,
+                                   gd_res_t *rootrsb)
+{
+       gd_res_t *rsb;
+
+       GDLM_ASSERT(rootrsb,);
+
+       if (rootrsb->res_remasterid == remasterid) {
+               rsb = rootrsb;
+               goto out;
+       }
+
+       list_for_each_entry(rsb, &rootrsb->res_subreslist, res_subreslist) {
+               if (rsb->res_remasterid == remasterid)
+                       goto out;
+       }
+       rsb = NULL;
+
+      out:
+       return rsb;
+}
+
+/* 
+ * Search a queue for the given remote lock id (remlkid).
+ */
+
+static gd_lkb_t *search_remlkid(struct list_head *statequeue, int nodeid,
+                               int remid)
+{
+       gd_lkb_t *lkb;
+
+       list_for_each_entry(lkb, statequeue, lkb_statequeue) {
+               if (lkb->lkb_nodeid == nodeid && lkb->lkb_remid == remid) {
+                       return lkb;
+               }
+       }
+
+       return NULL;
+}
+
+/* 
+ * Given a remote lock ID (and a parent resource), return the local LKB for it
+ * Hopefully we dont need to do this too often on deep lock trees.  This is
+ * VERY suboptimal for anything but the smallest lock trees. It searches the
+ * lock tree for an LKB with the remote id "remid" and the node "nodeid" and
+ * returns the LKB address.  OPTIMISATION: we should keep a list of these while
+ * we are building up the remastered LKBs
+ */
+
+static gd_lkb_t *find_by_remlkid(gd_res_t *rootrsb, int nodeid, int remid)
+{
+       gd_lkb_t *lkb;
+       gd_res_t *rsb;
+
+       lkb = search_remlkid(&rootrsb->res_grantqueue, nodeid, remid);
+       if (lkb)
+               goto out;
+
+       lkb = search_remlkid(&rootrsb->res_convertqueue, nodeid, remid);
+       if (lkb)
+               goto out;
+
+       lkb = search_remlkid(&rootrsb->res_waitqueue, nodeid, remid);
+       if (lkb)
+               goto out;
+
+       list_for_each_entry(rsb, &rootrsb->res_subreslist, res_subreslist) {
+               lkb = search_remlkid(&rsb->res_grantqueue, nodeid, remid);
+               if (lkb)
+                       goto out;
+
+               lkb = search_remlkid(&rsb->res_convertqueue, nodeid, remid);
+               if (lkb)
+                       goto out;
+
+               lkb = search_remlkid(&rsb->res_waitqueue, nodeid, remid);
+               if (lkb)
+                       goto out;
+       }
+       lkb = NULL;
+
+      out:
+       return lkb;
+}
+
+/* 
+ * Unpack an LKB from a remaster operation
+ */
+
+static int deserialise_lkb(gd_ls_t *ls, int rem_nodeid, gd_res_t *rootrsb,
+                          char *buf, int *ptr, char *outbuf, int *outoffp)
+{
+       gd_lkb_t *lkb;
+       gd_res_t *rsb;
+       int error = -ENOMEM, parentid, rsb_rmid, remote_lkid, status, temp;
+
+       remote_lkid = get_int(buf, ptr);
+
+       rsb_rmid = get_int(buf, ptr);
+       rsb = find_by_remasterid(ls, rsb_rmid, rootrsb);
+       GDLM_ASSERT(rsb, printk("no RSB for remasterid %d\n", rsb_rmid););
+
+       /* 
+        * We could have received this lkb already from a previous recovery
+        * that was interrupted.  If so, just return the lkid to the remote
+        * node.
+        */
+       lkb = find_by_remlkid(rsb, rem_nodeid, remote_lkid);
+       if (lkb)
+               goto put_lkid;
+
+       lkb = create_lkb(rsb->res_ls);
+       if (!lkb)
+               goto out;
+
+       lkb->lkb_remid = remote_lkid;
+       lkb->lkb_flags = get_int(buf, ptr);
+       status = get_int(buf, ptr);
+       lkb->lkb_rqmode = get_char(buf, ptr);
+       lkb->lkb_grmode = get_char(buf, ptr);
+       atomic_set(&lkb->lkb_childcnt, get_int(buf, ptr));
+
+       parentid = get_int(buf, ptr);
+       lkb->lkb_bastaddr = (void *) (long) get_int(buf, ptr);
+
+       if (lkb->lkb_flags & GDLM_LKFLG_VALBLK) {
+               lkb->lkb_lvbptr = allocate_lvb(ls);
+               if (!lkb->lkb_lvbptr)
+                       goto out;
+               get_bytes(lkb->lkb_lvbptr, &temp, buf, ptr);
+       }
+
+       if (lkb->lkb_flags & GDLM_LKFLG_RANGE) {
+               uint64_t start, end;
+
+               /* Don't need to keep the range flag, for comms use only */
+               lkb->lkb_flags &= ~GDLM_LKFLG_RANGE;
+               start = get_int64(buf, ptr);
+               end = get_int64(buf, ptr);
+
+               lkb->lkb_range = allocate_range(rsb->res_ls);
+               if (!lkb->lkb_range)
+                       goto out;
+
+               switch (status) {
+               case GDLM_LKSTS_CONVERT:
+                       lkb->lkb_range[RQ_RANGE_START] = start;
+                       lkb->lkb_range[RQ_RANGE_END] = end;
+                       start = get_int64(buf, ptr);
+                       end = get_int64(buf, ptr);
+                       lkb->lkb_range[GR_RANGE_START] = start;
+                       lkb->lkb_range[GR_RANGE_END] = end;
+
+               case GDLM_LKSTS_WAITING:
+                       lkb->lkb_range[RQ_RANGE_START] = start;
+                       lkb->lkb_range[RQ_RANGE_END] = end;
+                       break;
+
+               case GDLM_LKSTS_GRANTED:
+                       lkb->lkb_range[GR_RANGE_START] = start;
+                       lkb->lkb_range[GR_RANGE_END] = end;
+                       break;
+               default:
+                       GDLM_ASSERT(0,);
+               }
+       }
+
+       /* Resolve local lock LKB address from parent ID */
+       if (parentid)
+               lkb->lkb_parent = find_by_remlkid(rootrsb, rem_nodeid,
+                                                 parentid);
+
+       atomic_inc(&rsb->res_ref);
+       lkb->lkb_resource = rsb;
+
+       lkb->lkb_flags |= GDLM_LKFLG_MSTCPY;
+       lkb->lkb_nodeid = rem_nodeid;
+
+       /* 
+        * Put the lkb on an RSB queue.  An lkb that's in the midst of a
+        * conversion request (on the requesting node's lockqueue and has
+        * LQCONVERT set) should be put on the granted queue.  The convert
+        * request will be resent by the requesting node.
+        */
+
+       if (lkb->lkb_flags & GDLM_LKFLG_LQCONVERT) {
+               lkb->lkb_flags &= ~GDLM_LKFLG_LQCONVERT;
+               GDLM_ASSERT(status == GDLM_LKSTS_CONVERT,
+                           printk("status=%d\n", status););
+               lkb->lkb_rqmode = DLM_LOCK_IV;
+               status = GDLM_LKSTS_GRANTED;
+       }
+
+       lkb_enqueue(rsb, lkb, status);
+
+       /* 
+        * Update the rsb lvb if the lkb's lvb is up to date (grmode > NL).
+        */
+
+       if ((lkb->lkb_flags & GDLM_LKFLG_VALBLK)
+           && lkb->lkb_grmode > DLM_LOCK_NL) {
+               if (!rsb->res_lvbptr)
+                       rsb->res_lvbptr = allocate_lvb(rsb->res_ls);
+               if (!rsb->res_lvbptr)
+                       goto out;
+               memcpy(rsb->res_lvbptr, lkb->lkb_lvbptr, DLM_LVB_LEN);
+       }
+
+       /* 
+        * Clear flags that may have been sent over that are only relevant in
+        * the context of the sender.
+        */
+
+       lkb->lkb_flags &= ~(GDLM_LKFLG_DELAST | GDLM_LKFLG_DELETED |
+                           GDLM_LKFLG_LQRESEND | GDLM_LKFLG_NOREBUILD |
+                           GDLM_LKFLG_DEMOTED);
+
+      put_lkid:
+       /* Return the new LKID to the caller's buffer */
+       put_int(lkb->lkb_id, outbuf, outoffp);
+       put_int(lkb->lkb_remid, outbuf, outoffp);
+       error = 0;
+
+      out:
+       return error;
+}
+
+static gd_res_t *deserialise_rsb(gd_ls_t *ls, int nodeid, gd_res_t *rootrsb,
+                                char *buf, int *ptr)
+{
+       int length;
+       int remasterid;
+       int parent_remasterid;
+       char name[DLM_RESNAME_MAXLEN];
+       int error;
+       gd_res_t *parent = NULL;
+       gd_res_t *rsb;
+
+       get_bytes(name, &length, buf, ptr);
+       remasterid = get_int(buf, ptr);
+       parent_remasterid = get_int(buf, ptr);
+
+       if (parent_remasterid)
+               parent = find_by_remasterid(ls, parent_remasterid, rootrsb);
+
+       /* 
+        * The rsb reference from this find_or_create_rsb() will keep the rsb
+        * around while we add new lkb's to it from deserialise_lkb.  Each of
+        * the lkb's will add an rsb reference.  The reference added here is
+        * removed by release_rsb() after all lkb's are added.
+        */
+
+       error = find_or_create_rsb(ls, parent, name, length, 1, &rsb);
+       GDLM_ASSERT(!error,);
+
+       /* There is a case where the above needs to create the RSB. */
+       if (rsb->res_nodeid == -1)
+               rsb->res_nodeid = our_nodeid();
+
+       rsb->res_remasterid = remasterid;
+
+       return rsb;
+}
+
+/* 
+ * Processing at the receiving end of a NEWLOCKS message from a node in
+ * rebuild_rsbs_send().  Rebuild a remastered lock tree.  Nodeid is the remote
+ * node whose locks we are now mastering.  For a reply we need to send back the
+ * new lockids of the remastered locks so that remote ops can find them.
+ */
+
+int rebuild_rsbs_recv(gd_ls_t *ls, int nodeid, char *buf, int len)
+{
+       gd_rcom_t *rc;
+       gd_res_t *rsb = NULL;
+       rebuild_node_t *rnode;
+       char *outbuf;
+       int outptr, ptr = 0, error = -ENOMEM;
+
+       rnode = find_rebuild_root(ls, nodeid);
+       if (!rnode)
+               goto out;
+
+       /* 
+        * Allocate a buffer for the reply message which is a list of remote
+        * lock IDs and their (new) local lock ids.  It will always be big
+        * enough to fit <n> ID pairs if it already fit <n> LKBs.
+        */
+
+       rc = allocate_rcom_buffer(ls);
+       if (!rc)
+               goto out;
+       outbuf = rc->rc_buf;
+       outptr = 0;
+
+       /* 
+        * Unpack RSBs and LKBs, saving new LKB id's in outbuf as they're
+        * created.  Each deserialise_rsb adds an rsb reference that must be
+        * removed with release_rsb once all new lkb's for an rsb have been
+        * added.
+        */
+
+       while (ptr < len) {
+               int type;
+
+               type = get_char(buf, &ptr);
+
+               switch (type) {
+               case REMASTER_ROOTRSB:
+                       if (rsb)
+                               release_rsb(rsb);
+                       rsb = deserialise_rsb(ls, nodeid, rnode->rootrsb, buf,
+                                             &ptr);
+                       rnode->rootrsb = rsb;
+                       break;
+
+               case REMASTER_RSB:
+                       if (rsb)
+                               release_rsb(rsb);
+                       rsb = deserialise_rsb(ls, nodeid, rnode->rootrsb, buf,
+                                             &ptr);
+                       break;
+
+               case REMASTER_LKB:
+                       deserialise_lkb(ls, nodeid, rnode->rootrsb, buf, &ptr,
+                                       outbuf, &outptr);
+                       break;
+
+               default:
+                       GDLM_ASSERT(0, printk("type=%d nodeid=%u ptr=%d "
+                                             "len=%d\n", type, nodeid, ptr,
+                                             len););
+               }
+       }
+
+       if (rsb)
+               release_rsb(rsb);
+
+       /* 
+        * Reply with the new lock IDs.
+        */
+
+       rc->rc_datalen = outptr;
+       error = rcom_send_message(ls, nodeid, RECCOMM_NEWLOCKIDS, rc, 0);
+
+       free_rcom_buffer(rc);
+
+      out:
+       return error;
+}
+
+/* 
+ * Processing for a NEWLOCKIDS message.  Called when we get the reply from the
+ * new master telling us what the new remote lock IDs are for the remastered
+ * locks
+ */
+
+int rebuild_rsbs_lkids_recv(gd_ls_t *ls, int nodeid, char *buf, int len)
+{
+       int offset = 0;
+
+       if (len == 1)
+               len = 0;
+
+       while (offset < len) {
+               int remote_id;
+               int local_id;
+               gd_lkb_t *lkb;
+
+               if (offset + 8 > len) {
+                       log_error(ls, "rebuild_rsbs_lkids_recv: bad data "
+                                 "length nodeid=%d offset=%d len=%d",
+                                 nodeid, offset, len);
+                       break;
+               }
+
+               remote_id = get_int(buf, &offset);
+               local_id = get_int(buf, &offset);
+
+               lkb = find_lock_by_id(ls, local_id);
+               if (lkb) {
+                       lkb->lkb_remid = remote_id;
+                       have_new_lkid(lkb);
+               } else {
+                       log_error(ls, "rebuild_rsbs_lkids_recv: unknown lkid "
+                                 "nodeid=%d id=%x remid=%x offset=%d len=%d",
+                                 nodeid, local_id, remote_id, offset, len);
+               }
+       }
+
+       if (recover_list_empty(ls))
+               wake_up(&ls->ls_wait_general);
+
+       return 0;
+}
diff -urN linux-orig/cluster/dlm/rebuild.h linux-patched/cluster/dlm/rebuild.h
--- linux-orig/cluster/dlm/rebuild.h    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/rebuild.h 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,22 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __REBUILD_DOT_H__
+#define __REBUILD_DOT_H__
+
+int rebuild_rsbs_send(gd_ls_t * ls);
+int rebuild_rsbs_recv(gd_ls_t * ls, int nodeid, char *buf, int len);
+int rebuild_rsbs_lkids_recv(gd_ls_t * ls, int nodeid, char *buf, int len);
+int rebuild_freemem(gd_ls_t * ls);
+
+#endif                         /* __REBUILD_DOT_H__ */
diff -urN linux-orig/cluster/dlm/reccomms.c linux-patched/cluster/dlm/reccomms.c
--- linux-orig/cluster/dlm/reccomms.c   1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/reccomms.c        2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,502 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include "dlm_internal.h"
+#include "lowcomms.h"
+#include "midcomms.h"
+#include "reccomms.h"
+#include "nodes.h"
+#include "lockspace.h"
+#include "recover.h"
+#include "dir.h"
+#include "config.h"
+#include "rebuild.h"
+#include "memory.h"
+
+/* Running on the basis that only a single recovery communication will be done
+ * at a time per lockspace */
+
+static void rcom_process_message(gd_ls_t * ls, uint32_t nodeid, gd_rcom_t * rc);
+
+/*
+ * Track per-node progress/stats during recovery to help debugging.
+ */
+
+void rcom_log(gd_ls_t *ls, int nodeid, gd_rcom_t *rc, int send)
+{
+       gd_csb_t *csb;
+       int found = 0;
+ 
+       list_for_each_entry(csb, &ls->ls_nodes, csb_list) {
+               if (csb->csb_node->gn_nodeid == nodeid) {
+                       found = TRUE;
+                       break;
+               }
+       }
+
+       if (!found)
+               return;
+
+       if (rc->rc_subcmd == RECCOMM_RECOVERNAMES) {
+               if (send) {
+                       csb->csb_names_send_count++;
+                       csb->csb_names_send_msgid = rc->rc_msgid;
+               } else {
+                       csb->csb_names_recv_count++;
+                       csb->csb_names_recv_msgid = rc->rc_msgid;
+               }
+       } else if (rc->rc_subcmd == RECCOMM_NEWLOCKS) {
+               if (send) {
+                       csb->csb_locks_send_count++;
+                       csb->csb_locks_send_msgid = rc->rc_msgid;
+               } else {
+                       csb->csb_locks_recv_count++;
+                       csb->csb_locks_recv_msgid = rc->rc_msgid;
+               }
+       }
+}
+
+void rcom_log_clear(gd_ls_t *ls)
+{
+       gd_csb_t *csb;
+ 
+       list_for_each_entry(csb, &ls->ls_nodes, csb_list) {
+               csb->csb_names_send_count = 0;
+               csb->csb_names_send_msgid = 0;
+               csb->csb_names_recv_count = 0;
+               csb->csb_names_recv_msgid = 0;
+               csb->csb_locks_send_count = 0;
+               csb->csb_locks_send_msgid = 0;
+               csb->csb_locks_recv_count = 0;
+               csb->csb_locks_recv_msgid = 0;
+       }
+}
+
+static int rcom_response(gd_ls_t *ls)
+{
+       return test_bit(LSFL_RECCOMM_READY, &ls->ls_flags);
+}
+
+/**
+ * rcom_send_message - send or request recovery data
+ * @ls: the lockspace
+ * @nodeid: node to which the message is sent
+ * @type: type of recovery message
+ * @rc: the rc buffer to send
+ * @need_reply: wait for reply if this is set
+ *
+ * Using this interface
+ * i)   Allocate an rc buffer:  
+ *          rc = allocate_rcom_buffer(ls);
+ * ii)  Copy data to send beginning at rc->rc_buf:
+ *          memcpy(rc->rc_buf, mybuf, mylen);
+ * iii) Set rc->rc_datalen to the number of bytes copied in (ii): 
+ *          rc->rc_datalen = mylen
+ * iv)  Submit the rc to this function:
+ *          rcom_send_message(rc);
+ *
+ * The max value of "mylen" is dlm_config.buffer_size - sizeof(gd_rcom_t).  If
+ * more data must be passed in one send, use rcom_expand_buffer() which
+ * incrementally increases the size of the rc buffer by dlm_config.buffer_size
+ * bytes.
+ *
+ * Any data returned for the message (when need_reply is set) will saved in
+ * rc->rc_buf when this function returns and rc->rc_datalen will be set to the
+ * number of bytes copied into rc->rc_buf.
+ *
+ * Returns: 0 on success, -EXXX on failure
+ */
+
+int rcom_send_message(gd_ls_t *ls, uint32_t nodeid, int type, gd_rcom_t *rc,
+                     int need_reply)
+{
+       int error = 0;
+
+       if (!rc->rc_datalen)
+               rc->rc_datalen = 1;
+
+       /* 
+        * Fill in the header.
+        */
+
+       rc->rc_header.rh_cmd = GDLM_REMCMD_RECOVERMESSAGE;
+       rc->rc_header.rh_lockspace = ls->ls_global_id;
+       rc->rc_header.rh_length = sizeof(gd_rcom_t) + rc->rc_datalen - 1;
+       rc->rc_subcmd = type;
+       rc->rc_msgid = ++ls->ls_rcom_msgid;
+
+       rcom_log(ls, nodeid, rc, 1);
+
+       /* 
+        * When a reply is received, the reply data goes back into this buffer.
+        * Synchronous rcom requests (need_reply=1) are serialised because of
+        * the single ls_rcom.
+        */
+
+       if (need_reply) {
+               down(&ls->ls_rcom_lock);
+               ls->ls_rcom = rc;
+       }
+
+       /* 
+        * After sending the message we'll wait at the end of this function to
+        * get a reply.  The READY flag will be set when the reply has been
+        * received and requested data has been copied into
+        * ls->ls_rcom->rc_buf;
+        */
+
+       GDLM_ASSERT(!test_bit(LSFL_RECCOMM_READY, &ls->ls_flags),);
+
+       /* 
+        * The WAIT bit indicates that we're waiting for and willing to accept a
+        * reply.  Any replies are ignored unless this bit is set.
+        */
+
+       set_bit(LSFL_RECCOMM_WAIT, &ls->ls_flags);
+
+       /* 
+        * Process the message locally.
+        */
+
+       if (nodeid == our_nodeid()) {
+               rcom_process_message(ls, nodeid, rc);
+               goto out;
+       }
+
+       /* 
+        * Send the message.
+        */
+
+       log_debug(ls, "rcom send %d to %u id %u", type, nodeid, rc->rc_msgid);
+
+       error = midcomms_send_message(nodeid, (struct gd_req_header *) rc,
+                                     GFP_KERNEL);
+       GDLM_ASSERT(error >= 0, printk("error = %d\n", error););
+       error = 0;
+
+       /* 
+        * Wait for a reply.  Once a reply is processed from midcomms, the
+        * READY bit will be set and we'll be awoken (gdlm_wait_function will
+        * return 0).
+        */
+
+       if (need_reply) {
+               error = gdlm_wait_function(ls, &rcom_response);
+               if (error)
+                       log_debug(ls, "rcom wait error %d", error);
+       }
+
+      out:
+       clear_bit(LSFL_RECCOMM_WAIT, &ls->ls_flags);
+       clear_bit(LSFL_RECCOMM_READY, &ls->ls_flags);
+
+       if (need_reply)
+               up(&ls->ls_rcom_lock);
+
+       return error;
+}
+
+/* 
+ * Runs in same context as midcomms.
+ */
+
+static void rcom_process_message(gd_ls_t *ls, uint32_t nodeid, gd_rcom_t *rc)
+{
+       gd_rcom_t rc_stack;
+       gd_rcom_t *reply = NULL;
+       gd_resdata_t *rd;
+       int status, datalen, maxlen;
+       uint32_t be_nodeid;
+
+       if (!ls)
+               return;
+
+       rcom_log(ls, nodeid, rc, 0);
+
+       if (gdlm_recovery_stopped(ls) && (rc->rc_subcmd != RECCOMM_STATUS)) {
+               log_error(ls, "ignoring recovery message %x from %u",
+                         rc->rc_subcmd, nodeid);
+               return;
+       }
+
+       switch (rc->rc_subcmd) {
+
+       case RECCOMM_STATUS:
+
+               memset(&rc_stack, 0, sizeof(gd_rcom_t));
+               reply = &rc_stack;
+
+               reply->rc_header.rh_cmd = GDLM_REMCMD_RECOVERREPLY;
+               reply->rc_header.rh_lockspace = rc->rc_header.rh_lockspace;
+               reply->rc_subcmd = rc->rc_subcmd;
+               reply->rc_msgid = rc->rc_msgid;
+               reply->rc_buf[0] = 0;
+
+               if (test_bit(LSFL_RESDIR_VALID, &ls->ls_flags))
+                       reply->rc_buf[0] |= RESDIR_VALID;
+
+               if (test_bit(LSFL_ALL_RESDIR_VALID, &ls->ls_flags))
+                       reply->rc_buf[0] |= RESDIR_ALL_VALID;
+
+               if (test_bit(LSFL_NODES_VALID, &ls->ls_flags))
+                       reply->rc_buf[0] |= NODES_VALID;
+
+               if (test_bit(LSFL_ALL_NODES_VALID, &ls->ls_flags))
+                       reply->rc_buf[0] |= NODES_ALL_VALID;
+
+               reply->rc_datalen = 1;
+               reply->rc_header.rh_length =
+                       sizeof(gd_rcom_t) + reply->rc_datalen - 1;
+
+               log_debug(ls, "rcom status %x to %u", reply->rc_buf[0], nodeid);
+               break;
+
+       case RECCOMM_RECOVERNAMES:
+
+               reply = allocate_rcom_buffer(ls);
+               GDLM_ASSERT(reply,);
+               maxlen = dlm_config.buffer_size - sizeof(gd_rcom_t);
+
+               reply->rc_header.rh_cmd = GDLM_REMCMD_RECOVERREPLY;
+               reply->rc_header.rh_lockspace = rc->rc_header.rh_lockspace;
+               reply->rc_subcmd = rc->rc_subcmd;
+               reply->rc_msgid = rc->rc_msgid;
+
+               /* 
+                * The other node wants a bunch of resource names.  The name of
+                * the resource to begin with is in rc->rc_buf.
+                */
+
+               datalen = resdir_rebuild_send(ls, rc->rc_buf, rc->rc_datalen,
+                                             reply->rc_buf, maxlen, nodeid);
+
+               reply->rc_datalen = datalen;
+               reply->rc_header.rh_length =
+                   sizeof(gd_rcom_t) + reply->rc_datalen - 1;
+
+               log_debug(ls, "rcom names len %d to %u id %u", datalen, nodeid,
+                         reply->rc_msgid);
+               break;
+
+       case RECCOMM_GETMASTER:
+
+               reply = allocate_rcom_buffer(ls);
+               GDLM_ASSERT(reply,);
+
+               reply->rc_header.rh_cmd = GDLM_REMCMD_RECOVERREPLY;
+               reply->rc_header.rh_lockspace = rc->rc_header.rh_lockspace;
+               reply->rc_subcmd = rc->rc_subcmd;
+               reply->rc_msgid = rc->rc_msgid;
+
+               /* 
+                * The other node wants to know the master of a named resource.
+                */
+
+               status = get_resdata(ls, nodeid, rc->rc_buf, rc->rc_datalen,
+                                    &rd, 1);
+               if (status != 0) {
+                       free_rcom_buffer(reply);
+                       reply = NULL;
+                       return;
+               }
+               be_nodeid = cpu_to_be32(rd->rd_master_nodeid);
+               memcpy(reply->rc_buf, &be_nodeid, sizeof(uint32_t));
+               reply->rc_datalen = sizeof(uint32_t);
+               reply->rc_header.rh_length =
+                   sizeof(gd_rcom_t) + reply->rc_datalen - 1;
+               break;
+
+       case RECCOMM_BULKLOOKUP:
+
+               reply = allocate_rcom_buffer(ls);
+               GDLM_ASSERT(reply,);
+
+               reply->rc_header.rh_cmd = GDLM_REMCMD_RECOVERREPLY;
+               reply->rc_header.rh_lockspace = rc->rc_header.rh_lockspace;
+               reply->rc_subcmd = rc->rc_subcmd;
+               reply->rc_msgid = rc->rc_msgid;
+
+               /* 
+                * This is a bulk version of the above and just returns a
+                * buffer full of node ids to match the resources
+                */
+
+               datalen = bulk_master_lookup(ls, nodeid, rc->rc_buf,
+                                            rc->rc_datalen, reply->rc_buf);
+               if (datalen < 0) {
+                       free_rcom_buffer(reply);
+                       reply = NULL;
+                       return;
+               }
+
+               reply->rc_datalen = datalen;
+               reply->rc_header.rh_length =
+                   sizeof(gd_rcom_t) + reply->rc_datalen - 1;
+               break;
+
+               /* 
+                * These RECCOMM messages don't need replies.
+                */
+
+       case RECCOMM_NEWLOCKS:
+               rebuild_rsbs_recv(ls, nodeid, rc->rc_buf, rc->rc_datalen);
+               break;
+
+       case RECCOMM_NEWLOCKIDS:
+               rebuild_rsbs_lkids_recv(ls, nodeid, rc->rc_buf, rc->rc_datalen);
+               break;
+
+       case RECCOMM_REMRESDATA:
+               remove_resdata(ls, nodeid, rc->rc_buf, rc->rc_datalen, 1);
+               break;
+
+       default:
+               GDLM_ASSERT(0, printk("cmd=%x\n", rc->rc_subcmd););
+       }
+
+       if (reply) {
+               if (nodeid == our_nodeid()) {
+                       GDLM_ASSERT(rc == ls->ls_rcom,);
+                       memcpy(rc->rc_buf, reply->rc_buf, reply->rc_datalen);
+                       rc->rc_datalen = reply->rc_datalen;
+               } else {
+                       midcomms_send_message(nodeid,
+                                             (struct gd_req_header *) reply,
+                                             GFP_KERNEL);
+               }
+
+               if (reply != &rc_stack)
+                       free_rcom_buffer(reply);
+       }
+}
+
+static void process_reply_sync(gd_ls_t *ls, uint32_t nodeid, gd_rcom_t *reply)
+{
+       gd_rcom_t *rc = ls->ls_rcom;
+
+       if (!test_bit(LSFL_RECCOMM_WAIT, &ls->ls_flags)) {
+               log_error(ls, "unexpected rcom reply nodeid=%u", nodeid);
+               return;
+       }
+
+       if (reply->rc_msgid != le32_to_cpu(rc->rc_msgid)) {
+               log_error(ls, "unexpected rcom msgid %x/%x nodeid=%u",
+                         reply->rc_msgid, le32_to_cpu(rc->rc_msgid), nodeid);
+               return;
+       }
+
+       memcpy(rc->rc_buf, reply->rc_buf, reply->rc_datalen);
+       rc->rc_datalen = reply->rc_datalen;
+
+       /* 
+        * Tell the thread waiting in rcom_send_message() that it can go ahead.
+        */
+
+       set_bit(LSFL_RECCOMM_READY, &ls->ls_flags);
+       wake_up(&ls->ls_wait_general);
+}
+
+static void process_reply_async(gd_ls_t *ls, uint32_t nodeid, gd_rcom_t *reply)
+{
+       restbl_rsb_update_recv(ls, nodeid, reply->rc_buf, reply->rc_datalen,
+                              reply->rc_msgid);
+}
+
+/* 
+ * Runs in same context as midcomms.
+ */
+
+static void rcom_process_reply(gd_ls_t *ls, uint32_t nodeid, gd_rcom_t *reply)
+{
+       if (gdlm_recovery_stopped(ls)) {
+               log_error(ls, "ignoring recovery reply %x from %u",
+                         reply->rc_subcmd, nodeid);
+               return;
+       }
+
+       switch (reply->rc_subcmd) {
+       case RECCOMM_GETMASTER:
+               process_reply_async(ls, nodeid, reply);
+               break;
+       case RECCOMM_STATUS:
+       case RECCOMM_NEWLOCKS:
+       case RECCOMM_NEWLOCKIDS:
+       case RECCOMM_RECOVERNAMES:
+               process_reply_sync(ls, nodeid, reply);
+               break;
+       default:
+               log_error(ls, "unknown rcom reply subcmd=%x nodeid=%u",
+                         reply->rc_subcmd, nodeid);
+       }
+}
+
+
+static int send_ls_not_ready(uint32_t nodeid, struct gd_req_header *header)
+{
+       struct writequeue_entry *wq;
+       gd_rcom_t *rc = (gd_rcom_t *) header;
+       gd_rcom_t *reply;
+
+       wq = lowcomms_get_buffer(nodeid, sizeof(gd_rcom_t), GFP_KERNEL,
+                                (char **)&reply);
+       if (!wq)
+               return -ENOMEM;
+
+       reply->rc_header.rh_cmd = GDLM_REMCMD_RECOVERREPLY;
+       reply->rc_header.rh_lockspace = rc->rc_header.rh_lockspace;
+       reply->rc_subcmd = rc->rc_subcmd;
+       reply->rc_msgid = rc->rc_msgid;
+       reply->rc_buf[0] = 0;
+
+       reply->rc_datalen = 1;
+       reply->rc_header.rh_length = sizeof(gd_rcom_t) + reply->rc_datalen - 1;
+
+       midcomms_send_buffer((struct gd_req_header *)reply, wq);
+       return 0;
+}
+
+
+/* 
+ * Runs in same context as midcomms.  Both recovery requests and recovery
+ * replies come through this function.
+ */
+
+void process_recovery_comm(uint32_t nodeid, struct gd_req_header *header)
+{
+       gd_ls_t *ls = find_lockspace_by_global_id(header->rh_lockspace);
+       gd_rcom_t *rc = (gd_rcom_t *) header;
+
+       /* If the lockspace doesn't exist then still send a status message
+          back, it's possible that it just doesn't have it's global_id
+          yet. */
+       if (!ls) {
+             send_ls_not_ready(nodeid, header);
+             return;
+       }
+
+       switch (header->rh_cmd) {
+       case GDLM_REMCMD_RECOVERMESSAGE:
+               down_read(&ls->ls_rec_rsblist);
+               rcom_process_message(ls, nodeid, rc);
+               up_read(&ls->ls_rec_rsblist);
+               break;
+
+       case GDLM_REMCMD_RECOVERREPLY:
+               rcom_process_reply(ls, nodeid, rc);
+               break;
+
+       default:
+               GDLM_ASSERT(0, printk("cmd=%x\n", header->rh_cmd););
+       }
+}
+
diff -urN linux-orig/cluster/dlm/reccomms.h linux-patched/cluster/dlm/reccomms.h
--- linux-orig/cluster/dlm/reccomms.h   1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/reccomms.h        2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,37 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __RECCOMMS_DOT_H__
+#define __RECCOMMS_DOT_H__
+
+/* Bit flags */
+
+#define RESDIR_VALID            (1)
+#define RESDIR_ALL_VALID        (2)
+#define NODES_VALID             (4)
+#define NODES_ALL_VALID         (8)
+
+#define RECCOMM_STATUS          (1)
+#define RECCOMM_RECOVERNAMES    (2)
+#define RECCOMM_GETMASTER       (3)
+#define RECCOMM_BULKLOOKUP      (4)
+#define RECCOMM_NEWLOCKS        (5)
+#define RECCOMM_NEWLOCKIDS      (6)
+#define RECCOMM_REMRESDATA      (7)
+
+int rcom_send_message(gd_ls_t * ls, uint32_t nodeid, int type, gd_rcom_t * rc,
+                     int need_reply);
+void process_recovery_comm(uint32_t nodeid, struct gd_req_header *header);
+void rcom_log_clear(gd_ls_t *ls);
+
+#endif
diff -urN linux-orig/cluster/dlm/recover.c linux-patched/cluster/dlm/recover.c
--- linux-orig/cluster/dlm/recover.c    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/recover.c 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,632 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include "dlm_internal.h"
+#include "reccomms.h"
+#include "dir.h"
+#include "locking.h"
+#include "rsb.h"
+#include "lockspace.h"
+#include "lkb.h"
+#include "nodes.h"
+#include "config.h"
+#include "ast.h"
+#include "memory.h"
+
+/*
+ * Called in recovery routines to check whether the recovery process has been
+ * interrupted/stopped by another transition.  A recovery in-process will abort
+ * if the lockspace is "stopped" so that a new recovery process can start from
+ * the beginning when the lockspace is "started" again.
+ */
+
+int gdlm_recovery_stopped(gd_ls_t *ls)
+{
+       return test_bit(LSFL_LS_STOP, &ls->ls_flags);
+}
+
+static void gdlm_wait_timer_fn(unsigned long data)
+{
+       gd_ls_t *ls = (gd_ls_t *) data;
+
+       wake_up(&ls->ls_wait_general);
+}
+
+/*
+ * Wait until given function returns non-zero or lockspace is stopped (LS_STOP
+ * set due to failure of a node in ls_nodes).  When another function thinks it
+ * could have completed the waited-on task, they should wake up ls_wait_general
+ * to get an immediate response rather than waiting for the timer to detect the
+ * result.  A timer wakes us up periodically while waiting to see if we should
+ * abort due to a node failure.
+ */
+
+int gdlm_wait_function(gd_ls_t *ls, int (*testfn) (gd_ls_t * ls))
+{
+       struct timer_list timer;
+       int error = 0;
+
+       init_timer(&timer);
+       timer.function = gdlm_wait_timer_fn;
+       timer.data = (long) ls;
+
+       for (;;) {
+               mod_timer(&timer, jiffies + (5 * HZ));
+
+               wchan_cond_sleep_intr(ls->ls_wait_general,
+                                     !testfn(ls) &&
+                                     !test_bit(LSFL_LS_STOP, &ls->ls_flags));
+
+               if (timer_pending(&timer))
+                       del_timer(&timer);
+
+               if (testfn(ls))
+                       break;
+
+               if (test_bit(LSFL_LS_STOP, &ls->ls_flags)) {
+                       error = -1;
+                       break;
+               }
+       }
+
+       return error;
+}
+
+int gdlm_wait_status_all(gd_ls_t *ls, unsigned int wait_status)
+{
+       gd_rcom_t rc_stack, *rc;
+       gd_csb_t *csb;
+       int status;
+       int error = 0;
+
+       memset(&rc_stack, 0, sizeof(gd_rcom_t));
+       rc = &rc_stack;
+       rc->rc_datalen = 0;
+
+       list_for_each_entry(csb, &ls->ls_nodes, csb_list) {
+               for (;;) {
+                       error = gdlm_recovery_stopped(ls);
+                       if (error)
+                               goto out;
+
+                       error = rcom_send_message(ls, csb->csb_node->gn_nodeid,
+                                                 RECCOMM_STATUS, rc, 1);
+                       if (error)
+                               goto out;
+
+                       status = rc->rc_buf[0];
+                       if (status & wait_status)
+                               break;
+                       else {
+                               set_current_state(TASK_INTERRUPTIBLE);
+                               schedule_timeout(HZ >> 1);
+                       }
+               }
+       }
+
+      out:
+       return error;
+}
+
+int gdlm_wait_status_low(gd_ls_t *ls, unsigned int wait_status)
+{
+       gd_rcom_t rc_stack, *rc;
+       uint32_t nodeid = ls->ls_low_nodeid;
+       int status;
+       int error = 0;
+
+       memset(&rc_stack, 0, sizeof(gd_rcom_t));
+       rc = &rc_stack;
+       rc->rc_datalen = 0;
+
+       for (;;) {
+               error = gdlm_recovery_stopped(ls);
+               if (error)
+                       goto out;
+
+               error = rcom_send_message(ls, nodeid, RECCOMM_STATUS, rc, 1);
+               if (error)
+                       break;
+
+               status = rc->rc_buf[0];
+               if (status & wait_status)
+                       break;
+               else {
+                       set_current_state(TASK_INTERRUPTIBLE);
+                       schedule_timeout(HZ >> 1);
+               }
+       }
+
+      out:
+       return error;
+}
+
+static int purge_queue(gd_ls_t *ls, struct list_head *queue)
+{
+       gd_lkb_t *lkb, *safe;
+       gd_res_t *rsb;
+       int count = 0;
+
+       list_for_each_entry_safe(lkb, safe, queue, lkb_statequeue) {
+               if (!lkb->lkb_nodeid)
+                       continue;
+
+               GDLM_ASSERT(lkb->lkb_flags & GDLM_LKFLG_MSTCPY,);
+
+               if (in_nodes_gone(ls, lkb->lkb_nodeid)) {
+                       list_del(&lkb->lkb_statequeue);
+
+                       rsb = lkb->lkb_resource;
+                       lkb->lkb_status = 0;
+
+                       if (lkb->lkb_status == GDLM_LKSTS_CONVERT
+                           && &lkb->lkb_duetime)
+                               remove_from_deadlockqueue(lkb);
+
+                       release_lkb(ls, lkb);
+                       release_rsb(rsb);
+                       count++;
+               }
+       }
+
+       return count;
+}
+
+/*
+ * Go through local restbl and for each rsb we're master of, clear out any
+ * lkb's held by departed nodes.
+ */
+
+int restbl_lkb_purge(gd_ls_t *ls)
+{
+       struct list_head *tmp2, *safe2;
+       int count = 0;
+       gd_res_t *rootrsb, *safe, *rsb;
+
+       log_all(ls, "purge locks of departed nodes");
+
+       list_for_each_entry_safe(rootrsb, safe, &ls->ls_rootres, res_rootlist) {
+
+               rootrsb->res_resdir_seq = 1;
+
+               if (rootrsb->res_nodeid)
+                       continue;
+
+               hold_rsb(rootrsb);
+               down_write(&rootrsb->res_lock);
+
+               /* This traverses the subreslist in reverse order so we purge
+                * the children before their parents. */
+
+               for (tmp2 = rootrsb->res_subreslist.prev, safe2 = tmp2->prev;
+                    tmp2 != &rootrsb->res_subreslist;
+                    tmp2 = safe2, safe2 = safe2->prev) {
+                       rsb = list_entry(tmp2, gd_res_t, res_subreslist);
+
+                       hold_rsb(rsb);
+                       purge_queue(ls, &rsb->res_grantqueue);
+                       purge_queue(ls, &rsb->res_convertqueue);
+                       purge_queue(ls, &rsb->res_waitqueue);
+                       release_rsb(rsb);
+               }
+               count += purge_queue(ls, &rootrsb->res_grantqueue);
+               count += purge_queue(ls, &rootrsb->res_convertqueue);
+               count += purge_queue(ls, &rootrsb->res_waitqueue);
+
+               up_write(&rootrsb->res_lock);
+               release_rsb(rootrsb);
+       }
+
+       log_all(ls, "purged %d locks", count);
+
+       return 0;
+}
+
+/*
+ * Grant any locks that have become grantable after a purge
+ */
+
+int restbl_grant_after_purge(gd_ls_t *ls)
+{
+       gd_res_t *root, *rsb, *safe;
+       int error = 0;
+
+       down_write(&ls->ls_gap_rsblist);
+
+       list_for_each_entry_safe(root, safe, &ls->ls_rootres, res_rootlist) {
+               /* only the rsb master grants locks */
+               if (root->res_nodeid)
+                       continue;
+
+               if (!test_bit(LSFL_LS_RUN, &ls->ls_flags)) {
+                       log_debug(ls, "restbl_grant_after_purge aborted");
+                       error = -EINTR;
+                       up_write(&ls->ls_gap_rsblist);
+                       goto out;
+               }
+
+               down_write(&root->res_lock);
+               grant_pending_locks(root);
+               up_write(&root->res_lock);
+
+               list_for_each_entry(rsb, &root->res_subreslist, res_subreslist){
+                       down_write(&rsb->res_lock);
+                       grant_pending_locks(rsb);
+                       up_write(&rsb->res_lock);
+               }
+       }
+       up_write(&ls->ls_gap_rsblist);
+       wake_astd();
+ out:
+       return error;
+}
+
+/*
+ * Set the lock master for all LKBs in a lock queue
+ */
+
+static void set_lock_master(struct list_head *queue, int nodeid)
+{
+       gd_lkb_t *lkb;
+
+       list_for_each_entry(lkb, queue, lkb_statequeue) {
+               /* Don't muck around with pre-exising sublocks */
+               if (!(lkb->lkb_flags & GDLM_LKFLG_MSTCPY))
+                       lkb->lkb_nodeid = nodeid;
+       }
+}
+
+static void set_master_lkbs(gd_res_t *rsb)
+{
+       set_lock_master(&rsb->res_grantqueue, rsb->res_nodeid);
+       set_lock_master(&rsb->res_convertqueue, rsb->res_nodeid);
+       set_lock_master(&rsb->res_waitqueue, rsb->res_nodeid);
+}
+
+/*
+ * This rsb struct is now the master so it is responsible for keeping the
+ * latest rsb.  Find if any current lkb's have an up to date copy of the lvb to
+ * be used as the rsb copy.  An equivalent step occurs as new lkb's arrive for
+ * this rsb in deserialise_lkb.
+ */
+
+static void set_rsb_lvb(gd_res_t *rsb)
+{
+       gd_lkb_t *lkb;
+
+       list_for_each_entry(lkb, &rsb->res_grantqueue, lkb_statequeue) {
+
+               if (!(lkb->lkb_flags & GDLM_LKFLG_DELETED) &&
+                   (lkb->lkb_flags & GDLM_LKFLG_VALBLK) &&
+                   (lkb->lkb_grmode > DLM_LOCK_NL))
+               {
+                       if (!rsb->res_lvbptr)
+                               rsb->res_lvbptr = allocate_lvb(rsb->res_ls);
+
+                       memcpy(rsb->res_lvbptr, lkb->lkb_lvbptr, DLM_LVB_LEN);
+                       return;
+               }
+       }
+
+       list_for_each_entry(lkb, &rsb->res_convertqueue, lkb_statequeue) {
+
+               if (!(lkb->lkb_flags & GDLM_LKFLG_DELETED) &&
+                   (lkb->lkb_flags & GDLM_LKFLG_VALBLK) &&
+                   (lkb->lkb_grmode > DLM_LOCK_NL))
+               {
+                       if (!rsb->res_lvbptr)
+                               rsb->res_lvbptr = allocate_lvb(rsb->res_ls);
+
+                       memcpy(rsb->res_lvbptr, lkb->lkb_lvbptr, DLM_LVB_LEN);
+                       return;
+               }
+       }
+}
+
+/*
+ * Propogate the new master nodeid to locks, subrsbs, sublocks.
+ * The NEW_MASTER flag tells rebuild_rsbs_send() which rsb's to consider.
+ */
+
+static void set_new_master(gd_res_t *rsb)
+{
+       gd_res_t *subrsb;
+
+       down_write(&rsb->res_lock);
+
+       if (rsb->res_nodeid == our_nodeid()) {
+               rsb->res_nodeid = 0;
+               set_rsb_lvb(rsb);
+       }
+
+       set_master_lkbs(rsb);
+
+       list_for_each_entry(subrsb, &rsb->res_subreslist, res_subreslist) {
+               subrsb->res_nodeid = rsb->res_nodeid;
+               set_master_lkbs(subrsb);
+       }
+
+       up_write(&rsb->res_lock);
+
+       set_bit(RESFL_NEW_MASTER, &rsb->res_flags);
+}
+
+/*
+ * The recover_list contains all the rsb's for which we've requested the new
+ * master nodeid.  As replies are returned from the resource directories the
+ * rsb's are removed from the list.  When the list is empty we're done.
+ *
+ * The recover_list is later similarly used for all rsb's for which we've sent
+ * new lkb's and need to receive new corresponding lkid's.
+ */
+
+int recover_list_empty(gd_ls_t *ls)
+{
+       int empty;
+
+       spin_lock(&ls->ls_recover_list_lock);
+       empty = list_empty(&ls->ls_recover_list);
+       spin_unlock(&ls->ls_recover_list_lock);
+
+       return empty;
+}
+
+int recover_list_count(gd_ls_t *ls)
+{
+       int count;
+
+       spin_lock(&ls->ls_recover_list_lock);
+       count = ls->ls_recover_list_count;
+       spin_unlock(&ls->ls_recover_list_lock);
+
+       return count;
+}
+
+void recover_list_add(gd_res_t *rsb)
+{
+       gd_ls_t *ls = rsb->res_ls;
+
+       spin_lock(&ls->ls_recover_list_lock);
+       if (!test_and_set_bit(RESFL_RECOVER_LIST, &rsb->res_flags)) {
+               list_add_tail(&rsb->res_recover_list, &ls->ls_recover_list);
+               ls->ls_recover_list_count++;
+               hold_rsb(rsb);
+       }
+       spin_unlock(&ls->ls_recover_list_lock);
+}
+
+void recover_list_del(gd_res_t *rsb)
+{
+       gd_ls_t *ls = rsb->res_ls;
+
+       spin_lock(&ls->ls_recover_list_lock);
+       clear_bit(RESFL_RECOVER_LIST, &rsb->res_flags);
+       list_del(&rsb->res_recover_list);
+       ls->ls_recover_list_count--;
+       spin_unlock(&ls->ls_recover_list_lock);
+
+       release_rsb(rsb);
+}
+
+static gd_res_t *recover_list_find(gd_ls_t *ls, int msgid)
+{
+       gd_res_t *rsb = NULL;
+
+       spin_lock(&ls->ls_recover_list_lock);
+
+       list_for_each_entry(rsb, &ls->ls_recover_list, res_recover_list) {
+               if (rsb->res_recover_msgid == msgid)
+                       goto rec_found;
+       }
+       rsb = NULL;
+
+ rec_found:
+       spin_unlock(&ls->ls_recover_list_lock);
+       return rsb;
+}
+
+#if 0
+static void recover_list_clear(gd_ls_t *ls)
+{
+       gd_res_t *rsb;
+
+
+       spin_lock(&ls->ls_recover_list_lock);
+
+       while (!list_empty(&ls->ls_recover_list)) {
+               rsb = list_entry(ls->ls_recover_list.next, gd_res_t,
+                                res_recover_list);
+               list_del(&rsb->res_recover_list);
+               ls->ls_recover_list_count--;
+       }
+       spin_unlock(&ls->ls_recover_list_lock);
+
+}
+#endif
+
+#if 0
+void recover_list_dump(gd_ls_t *ls)
+{
+       struct list_head *tmp;
+       gd_res_t *rsb;
+
+       spin_lock(&ls->ls_recover_list_lock);
+
+       printk("recover_list_count=%d\n", ls->ls_recover_list_count);
+
+       list_for_each(tmp, &ls->ls_recover_list) {
+               rsb = list_entry(tmp, gd_res_t, res_recover_list);
+               gdlm_res_dbprint(rsb);
+       }
+       spin_unlock(&ls->ls_recover_list_lock);
+}
+#endif
+
+static int rsb_master_lookup(gd_res_t *rsb, gd_rcom_t *rc)
+{
+       gd_ls_t *ls = rsb->res_ls;
+       gd_resdata_t *rd;
+       uint32_t dir_nodeid;
+       int error;
+
+       dir_nodeid = get_directory_nodeid(rsb);
+
+       if (dir_nodeid == our_nodeid()) {
+               error = get_resdata(ls, dir_nodeid, rsb->res_name,
+                                   rsb->res_length, &rd, 1);
+               if (error)
+                       goto fail;
+
+               rsb->res_nodeid = rd->rd_master_nodeid;
+               set_new_master(rsb);
+       } else {
+               /* As we are the only thread doing recovery this 
+                  should be safe. if not then we need to use a different
+                  ID somehow. We must set it in the RSB before rcom_send_msg
+                  completes cos we may get a reply quite quickly.
+               */
+               rsb->res_recover_msgid = ls->ls_rcom_msgid + 1;
+
+               recover_list_add(rsb);
+
+               memcpy(rc->rc_buf, rsb->res_name, rsb->res_length);
+               rc->rc_datalen = rsb->res_length;
+
+               error = rcom_send_message(ls, dir_nodeid, RECCOMM_GETMASTER,
+                                         rc, 0);
+               if (error)
+                       goto fail;
+       }
+
+      fail:
+       return error;
+}
+
+/*
+ * Go through local root resources and for each rsb which has a master which
+ * has departed, get the new master nodeid from the resdir.  The resdir will
+ * assign mastery to the first node to look up the new master.  That means
+ * we'll discover in this lookup if we're the new master of any rsb's.
+ *
+ * We fire off all the resdir requests individually and asynchronously to the
+ * correct resdir node.  The replies are processed in rsb_master_recv().
+ */
+
+int restbl_rsb_update(gd_ls_t *ls)
+{
+       gd_res_t *rsb, *safe;
+       gd_rcom_t *rc;
+       int error = -ENOMEM;
+       int count = 0;
+
+       log_all(ls, "update remastered resources");
+
+       rc = allocate_rcom_buffer(ls);
+       if (!rc)
+               goto out;
+
+       list_for_each_entry_safe(rsb, safe, &ls->ls_rootres, res_rootlist) {
+               if (!rsb->res_nodeid)
+                       continue;
+
+               error = gdlm_recovery_stopped(ls);
+               if (error)
+                       goto out_free;
+
+               if (in_nodes_gone(ls, rsb->res_nodeid)) {
+                       error = rsb_master_lookup(rsb, rc);
+                       if (error)
+                               goto out_free;
+                       count++;
+               }
+       }
+
+       error = gdlm_wait_function(ls, &recover_list_empty);
+
+       log_all(ls, "updated %d resources", count);
+
+      out_free:
+       free_rcom_buffer(rc);
+
+      out:
+       return error;
+}
+
+int restbl_rsb_update_recv(gd_ls_t *ls, uint32_t nodeid, char *buf, int length,
+                          int msgid)
+{
+       gd_res_t *rsb;
+       uint32_t be_nodeid;
+
+       rsb = recover_list_find(ls, msgid);
+       if (!rsb) {
+               log_error(ls, "restbl_rsb_update_recv rsb not found %d", msgid);
+               goto out;
+       }
+
+       memcpy(&be_nodeid, buf, sizeof(uint32_t));
+       rsb->res_nodeid = be32_to_cpu(be_nodeid);
+       set_new_master(rsb);
+       recover_list_del(rsb);
+
+       if (recover_list_empty(ls))
+               wake_up(&ls->ls_wait_general);
+
+      out:
+       return 0;
+}
+
+/*
+ * This function not used any longer.
+ */
+
+int bulk_master_lookup(gd_ls_t *ls, int nodeid, char *inbuf, int inlen,
+                      char *outbuf)
+{
+       char *inbufptr, *outbufptr;
+
+       /*
+        * The other node wants nodeids matching the resource names in inbuf.
+        * The resource names are packed into inbuf as
+        * [len1][name1][len2][name2]...  where lenX is 1 byte and nameX is
+        * lenX bytes.  Matching nodeids are packed into outbuf in order
+        * [nodeid1][nodeid2]...
+        */
+
+       inbufptr = inbuf;
+       outbufptr = outbuf;
+
+       while (inbufptr < inbuf + inlen) {
+               gd_resdata_t *rd;
+               uint32_t be_nodeid;
+               int status;
+
+               status = get_resdata(ls, nodeid, inbufptr + 1, *inbufptr,
+                                    &rd, 1);
+               if (status != 0)
+                       goto fail;
+
+               inbufptr += *inbufptr + 1;
+
+               be_nodeid = cpu_to_be32(rd->rd_master_nodeid);
+               memcpy(outbufptr, &be_nodeid, sizeof(uint32_t));
+               outbufptr += sizeof(uint32_t);
+
+               /* add assertion that outbufptr - outbuf is not > than ... */
+       }
+
+       return (outbufptr - outbuf);
+
+      fail:
+       return -1;
+}
diff -urN linux-orig/cluster/dlm/recover.h linux-patched/cluster/dlm/recover.h
--- linux-orig/cluster/dlm/recover.h    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/recover.h 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,34 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __RECOVER_DOT_H__
+#define __RECOVER_DOT_H__
+
+int gdlm_wait_function(gd_ls_t * ls, int (*testfn) (gd_ls_t * ls));
+int gdlm_wait_status_all(gd_ls_t * ls, unsigned int wait_status);
+int gdlm_wait_status_low(gd_ls_t * ls, unsigned int wait_status);
+int gdlm_recovery_stopped(gd_ls_t * ls);
+int recover_list_empty(gd_ls_t * ls);
+int recover_list_count(gd_ls_t * ls);
+void recover_list_add(gd_res_t * rsb);
+void recover_list_del(gd_res_t * rsb);
+void recover_list_dump(gd_ls_t * ls);
+int restbl_lkb_purge(gd_ls_t * ls);
+void restbl_grant_after_purge(gd_ls_t * ls);
+int restbl_rsb_update(gd_ls_t * ls);
+int restbl_rsb_update_recv(gd_ls_t * ls, int nodeid, char *buf, int len,
+                          int msgid);
+int bulk_master_lookup(gd_ls_t * ls, int nodeid, char *inbuf, int inlen,
+                      char *outbuf);
+
+#endif                         /* __RECOVER_DOT_H__ */
diff -urN linux-orig/cluster/dlm/recoverd.c linux-patched/cluster/dlm/recoverd.c
--- linux-orig/cluster/dlm/recoverd.c   1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/recoverd.c        2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,692 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include "dlm_internal.h"
+#include "nodes.h"
+#include "dir.h"
+#include "ast.h"
+#include "recover.h"
+#include "lockspace.h"
+#include "lowcomms.h"
+#include "lockqueue.h"
+#include "lkb.h"
+#include "rebuild.h"
+
+/* 
+ * next_move actions
+ */
+
+#define DO_STOP             (1)
+#define DO_START            (2)
+#define DO_FINISH           (3)
+#define DO_FINISH_STOP      (4)
+#define DO_FINISH_START     (5)
+
+/* 
+ * recoverd_flags for thread
+ */
+
+#define THREAD_STOP         (0)
+
+/* 
+ * local thread variables
+ */
+
+static unsigned long recoverd_flags;
+static struct completion recoverd_run;
+static wait_queue_head_t recoverd_wait;
+static struct task_struct *recoverd_task;
+
+/* 
+ * Queue of lockspaces (gr_recover_t structs) which need to be
+ * started/recovered
+ */
+
+static struct list_head recoverd_start_queue;
+static atomic_t recoverd_start_count;
+
+extern struct list_head lslist;
+extern spinlock_t lslist_lock;
+
+void dlm_recoverd_init(void)
+{
+       INIT_LIST_HEAD(&recoverd_start_queue);
+       atomic_set(&recoverd_start_count, 0);
+
+       init_completion(&recoverd_run);
+       init_waitqueue_head(&recoverd_wait);
+       memset(&recoverd_flags, 0, sizeof(unsigned long));
+}
+
+static int enable_locking(gd_ls_t *ls, int event_id)
+{
+       int error = 0;
+
+       spin_lock(&ls->ls_recover_lock);
+       if (ls->ls_last_stop < event_id) {
+               set_bit(LSFL_LS_RUN, &ls->ls_flags);
+               up_write(&ls->ls_in_recovery);
+       } else {
+               error = -EINTR;
+               log_debug(ls, "enable_locking: abort %d", event_id);
+       }
+       spin_unlock(&ls->ls_recover_lock);
+       return error;
+}
+
+static int ls_first_start(gd_ls_t *ls, gd_recover_t *gr)
+{
+       int error;
+
+       log_all(ls, "recover event %u (first)", gr->gr_event_id);
+
+       kcl_global_service_id(ls->ls_local_id, &ls->ls_global_id);
+
+       error = ls_nodes_init(ls, gr);
+       if (error) {
+               log_error(ls, "nodes_init failed %d", error);
+               goto out;
+       }
+
+       error = resdir_rebuild_local(ls);
+       if (error) {
+               log_error(ls, "resdir_rebuild_local failed %d", error);
+               goto out;
+       }
+
+       error = resdir_rebuild_wait(ls);
+       if (error) {
+               log_error(ls, "resdir_rebuild_wait failed %d", error);
+               goto out;
+       }
+
+       log_all(ls, "recover event %u done", gr->gr_event_id);
+       kcl_start_done(ls->ls_local_id, gr->gr_event_id);
+
+      out:
+       return error;
+}
+
+/* 
+ * We are given here a new group of nodes which are in the lockspace.  We first
+ * figure out the differences in ls membership from when we were last running.
+ * If nodes from before are gone, then there will be some lock recovery to do.
+ * If there are only nodes which have joined, then there's no lock recovery.
+ *
+ * note: cman requires an rc to finish starting on an revent (where nodes die)
+ * before it allows an sevent (where nodes join) to be processed.  This means
+ * that we won't get start1 with nodeA gone, stop/cancel, start2 with nodeA
+ * joined.
+ */
+
+static int ls_reconfig(gd_ls_t *ls, gd_recover_t *gr)
+{
+       int error, neg = 0;
+
+       log_all(ls, "recover event %u", gr->gr_event_id);
+
+       /* 
+        * Add or remove nodes from the lockspace's ls_nodes list.
+        */
+
+       error = ls_nodes_reconfig(ls, gr, &neg);
+       if (error) {
+               log_error(ls, "nodes_reconfig failed %d", error);
+               goto fail;
+       }
+
+       /* 
+        * Rebuild our own share of the resdir by collecting from all other
+        * nodes rsb name/master pairs for which the name hashes to us.
+        */
+
+       error = resdir_rebuild_local(ls);
+       if (error) {
+               log_error(ls, "resdir_rebuild_local failed %d", error);
+               goto fail;
+       }
+
+       /* 
+        * Purge resdir-related requests that are being held in requestqueue.
+        * All resdir requests from before recovery started are invalid now due
+        * to the resdir rebuild and will be resent by the requesting nodes.
+        */
+
+       purge_requestqueue(ls);
+       set_bit(LSFL_REQUEST_WARN, &ls->ls_flags);
+
+       /* 
+        * Wait for all nodes to complete resdir rebuild.
+        */
+
+       error = resdir_rebuild_wait(ls);
+       if (error) {
+               log_error(ls, "resdir_rebuild_wait failed %d", error);
+               goto fail;
+       }
+
+       /* 
+        * Mark our own lkb's waiting in the lockqueue for remote replies from
+        * nodes that are now departed.  These will be resent to the new
+        * masters in resend_cluster_requests.  Also mark resdir lookup
+        * requests for resending.
+        */
+
+       lockqueue_lkb_mark(ls);
+
+       error = gdlm_recovery_stopped(ls);
+       if (error)
+               goto fail;
+
+       if (neg) {
+               /* 
+                * Clear lkb's for departed nodes.  This can't fail since it
+                * doesn't involve communicating with other nodes.
+                */
+
+               down_write(&ls->ls_rec_rsblist);
+               restbl_lkb_purge(ls);
+               up_write(&ls->ls_rec_rsblist);
+
+               down_read(&ls->ls_rec_rsblist);
+
+               /* 
+                * Get new master id's for rsb's of departed nodes.  This fails
+                * if we can't communicate with other nodes.
+                */
+
+               error = restbl_rsb_update(ls);
+               if (error) {
+                       log_error(ls, "restbl_rsb_update failed %d", error);
+                       goto fail_up;
+               }
+
+               /* 
+                * Send our lkb info to new masters.  This fails if we can't
+                * communicate with a node.
+                */
+
+               error = rebuild_rsbs_send(ls);
+               if (error) {
+                       log_error(ls, "rebuild_rsbs_send failed %d", error);
+                       goto fail_up;
+               }
+               up_read(&ls->ls_rec_rsblist);
+       }
+
+       clear_bit(LSFL_REQUEST_WARN, &ls->ls_flags);
+
+       log_all(ls, "recover event %u done", gr->gr_event_id);
+       kcl_start_done(ls->ls_local_id, gr->gr_event_id);
+       return 0;
+
+ fail_up:
+       up_read(&ls->ls_rec_rsblist);
+ fail:
+       log_all(ls, "recover event %d error %d", gr->gr_event_id, error);
+       return error;
+}
+
+static void clear_finished_nodes(gd_ls_t *ls, int finish_event)
+{
+       gd_csb_t *csb, *safe;
+
+       list_for_each_entry_safe(csb, safe, &ls->ls_nodes_gone, csb_list) {
+               if (csb->csb_gone_event <= finish_event) {
+                       list_del(&csb->csb_list);
+                       release_csb(csb);
+               }
+       }
+}
+
+/* 
+ * Between calls to this routine for a ls, there can be multiple stop/start
+ * events from cman where every start but the latest is cancelled by stops.
+ * There can only be a single finish from cman because every finish requires us
+ * to call start_done.  A single finish event could be followed by multiple
+ * stop/start events.  This routine takes any combination of events from cman
+ * and boils them down to one course of action.
+ */
+
+int next_move(gd_ls_t *ls, gd_recover_t **gr_out, int *finish_out)
+{
+       LIST_HEAD(events);
+       unsigned int cmd = 0, stop, start, finish;
+       unsigned int last_stop, last_start, last_finish;
+       gd_recover_t *gr = NULL, *start_gr = NULL;
+
+       /* 
+        * Grab the current state of cman/sm events.
+        */
+
+       spin_lock(&ls->ls_recover_lock);
+
+       stop = test_and_clear_bit(LSFL_LS_STOP, &ls->ls_flags) ? 1 : 0;
+       start = test_and_clear_bit(LSFL_LS_START, &ls->ls_flags) ? 1 : 0;
+       finish = test_and_clear_bit(LSFL_LS_FINISH, &ls->ls_flags) ? 1 : 0;
+
+       last_stop = ls->ls_last_stop;
+       last_start = ls->ls_last_start;
+       last_finish = ls->ls_last_finish;
+
+       while (!list_empty(&ls->ls_recover)) {
+               gr = list_entry(ls->ls_recover.next, gd_recover_t, gr_list);
+               list_del(&gr->gr_list);
+               list_add_tail(&gr->gr_list, &events);
+       }
+       spin_unlock(&ls->ls_recover_lock);
+
+       log_debug(ls, "move flags %u,%u,%u ids %u,%u,%u", stop, start, finish,
+                 last_stop, last_start, last_finish);
+
+       /* 
+        * Toss start events which have since been cancelled.
+        */
+
+       while (!list_empty(&events)) {
+               GDLM_ASSERT(start,);
+               gr = list_entry(events.next, gd_recover_t, gr_list);
+               list_del(&gr->gr_list);
+
+               if (gr->gr_event_id <= last_stop) {
+                       log_debug(ls, "move skip event %u", gr->gr_event_id);
+                       kfree(gr->gr_nodeids);
+                       free_dlm_recover(gr);
+                       gr = NULL;
+               } else {
+                       log_debug(ls, "move use event %u", gr->gr_event_id);
+                       GDLM_ASSERT(!start_gr,);
+                       start_gr = gr;
+               }
+       }
+
+       /* 
+        * Eight possible combinations of events.
+        */
+
+       /* 0 */
+       if (!stop && !start && !finish) {
+               GDLM_ASSERT(!start_gr,);
+               cmd = 0;
+               goto out;
+       }
+
+       /* 1 */
+       if (!stop && !start && finish) {
+               GDLM_ASSERT(!start_gr,);
+               GDLM_ASSERT(last_start > last_stop,);
+               GDLM_ASSERT(last_finish == last_start,);
+               cmd = DO_FINISH;
+               *finish_out = last_finish;
+               goto out;
+       }
+
+       /* 2 */
+       if (!stop && start && !finish) {
+               GDLM_ASSERT(start_gr,);
+               GDLM_ASSERT(last_start > last_stop,);
+               cmd = DO_START;
+               *gr_out = start_gr;
+               goto out;
+       }
+
+       /* 3 */
+       if (!stop && start && finish) {
+               GDLM_ASSERT(0, printk("finish and start with no stop\n"););
+       }
+
+       /* 4 */
+       if (stop && !start && !finish) {
+               GDLM_ASSERT(!start_gr,);
+               GDLM_ASSERT(last_start == last_stop,);
+               cmd = DO_STOP;
+               goto out;
+       }
+
+       /* 5 */
+       if (stop && !start && finish) {
+               GDLM_ASSERT(!start_gr,);
+               GDLM_ASSERT(last_finish == last_start,);
+               GDLM_ASSERT(last_stop == last_start,);
+               cmd = DO_FINISH_STOP;
+               *finish_out = last_finish;
+               goto out;
+       }
+
+       /* 6 */
+       if (stop && start && !finish) {
+               if (start_gr) {
+                       GDLM_ASSERT(last_start > last_stop,);
+                       cmd = DO_START;
+                       *gr_out = start_gr;
+               } else {
+                       GDLM_ASSERT(last_stop == last_start,);
+                       cmd = DO_STOP;
+               }
+               goto out;
+       }
+
+       /* 7 */
+       if (stop && start && finish) {
+               if (start_gr) {
+                       GDLM_ASSERT(last_start > last_stop,);
+                       GDLM_ASSERT(last_start > last_finish,);
+                       cmd = DO_FINISH_START;
+                       *finish_out = last_finish;
+                       *gr_out = start_gr;
+               } else {
+                       GDLM_ASSERT(last_start == last_stop,);
+                       GDLM_ASSERT(last_start > last_finish,);
+                       cmd = DO_FINISH_STOP;
+                       *finish_out = last_finish;
+               }
+               goto out;
+       }
+
+      out:
+       return cmd;
+}
+
+/* 
+ * This function decides what to do given every combination of current
+ * lockspace state and next lockspace state.
+ */
+
+static void do_ls_recovery(gd_ls_t *ls)
+{
+       gd_recover_t *gr = NULL;
+       int error, cur_state, next_state = 0, do_now, finish_event = 0;
+
+       do_now = next_move(ls, &gr, &finish_event);
+       if (!do_now)
+               goto out;
+
+       cur_state = ls->ls_state;
+       next_state = 0;
+
+       GDLM_ASSERT(!test_bit(LSFL_LS_RUN, &ls->ls_flags),
+                   log_error(ls, "curstate=%d donow=%d", cur_state, do_now););
+
+       /* 
+        * LSST_CLEAR - we're not in any recovery state.  We can get a stop or
+        * a stop and start which equates with a START.
+        */
+
+       if (cur_state == LSST_CLEAR) {
+               switch (do_now) {
+               case DO_STOP:
+                       next_state = LSST_WAIT_START;
+                       break;
+
+               case DO_START:
+                       error = ls_reconfig(ls, gr);
+                       if (error)
+                               next_state = LSST_WAIT_START;
+                       else
+                               next_state = LSST_RECONFIG_DONE;
+                       break;
+
+               case DO_FINISH: /* invalid */
+               case DO_FINISH_STOP:    /* invalid */
+               case DO_FINISH_START:   /* invalid */
+               default:
+                       GDLM_ASSERT(0,);
+               }
+               goto out;
+       }
+
+       /* 
+        * LSST_WAIT_START - we're not running because of getting a stop or
+        * failing a start.  We wait in this state for another stop/start or
+        * just the next start to begin another reconfig attempt.
+        */
+
+       if (cur_state == LSST_WAIT_START) {
+               switch (do_now) {
+               case DO_STOP:
+                       break;
+
+               case DO_START:
+                       error = ls_reconfig(ls, gr);
+                       if (error)
+                               next_state = LSST_WAIT_START;
+                       else
+                               next_state = LSST_RECONFIG_DONE;
+                       break;
+
+               case DO_FINISH: /* invalid */
+               case DO_FINISH_STOP:    /* invalid */
+               case DO_FINISH_START:   /* invalid */
+               default:
+                       GDLM_ASSERT(0,);
+               }
+               goto out;
+       }
+
+       /* 
+        * LSST_RECONFIG_DONE - we entered this state after successfully
+        * completing ls_reconfig and calling kcl_start_done.  We expect to get
+        * a finish if everything goes ok.  A finish could be followed by stop
+        * or stop/start before we get here to check it.  Or a finish may never
+        * happen, only stop or stop/start.
+        */
+
+       if (cur_state == LSST_RECONFIG_DONE) {
+               switch (do_now) {
+               case DO_FINISH:
+                       clear_finished_nodes(ls, finish_event);
+                       next_state = LSST_CLEAR;
+
+                       error = enable_locking(ls, finish_event);
+                       if (error)
+                               break;
+
+                       error = process_requestqueue(ls);
+                       if (error)
+                               break;
+
+                       error = resend_cluster_requests(ls);
+                       if (error)
+                               break;
+
+                       restbl_grant_after_purge(ls);
+
+                       log_all(ls, "recover event %u finished", finish_event);
+                       break;
+
+               case DO_STOP:
+                       next_state = LSST_WAIT_START;
+                       break;
+
+               case DO_FINISH_STOP:
+                       clear_finished_nodes(ls, finish_event);
+                       next_state = LSST_WAIT_START;
+                       break;
+
+               case DO_FINISH_START:
+                       clear_finished_nodes(ls, finish_event);
+                       /* fall into DO_START */
+
+               case DO_START:
+                       error = ls_reconfig(ls, gr);
+                       if (error)
+                               next_state = LSST_WAIT_START;
+                       else
+                               next_state = LSST_RECONFIG_DONE;
+                       break;
+
+               default:
+                       GDLM_ASSERT(0,);
+               }
+               goto out;
+       }
+
+       /* 
+        * LSST_INIT - state after ls is created and before it has been
+        * started.  A start operation will cause the ls to be started for the
+        * first time.  A failed start will cause to just wait in INIT for
+        * another stop/start.
+        */
+
+       if (cur_state == LSST_INIT) {
+               switch (do_now) {
+               case DO_START:
+                       error = ls_first_start(ls, gr);
+                       if (!error)
+                               next_state = LSST_INIT_DONE;
+                       break;
+
+               case DO_STOP:
+                       break;
+
+               case DO_FINISH: /* invalid */
+               case DO_FINISH_STOP:    /* invalid */
+               case DO_FINISH_START:   /* invalid */
+               default:
+                       GDLM_ASSERT(0,);
+               }
+               goto out;
+       }
+
+       /* 
+        * LSST_INIT_DONE - after the first start operation is completed
+        * successfully and kcl_start_done() called.  If there are no errors, a
+        * finish will arrive next and we'll move to LSST_CLEAR.
+        */
+
+       if (cur_state == LSST_INIT_DONE) {
+               switch (do_now) {
+               case DO_STOP:
+               case DO_FINISH_STOP:
+                       next_state = LSST_WAIT_START;
+                       break;
+
+               case DO_START:
+               case DO_FINISH_START:
+                       error = ls_reconfig(ls, gr);
+                       if (error)
+                               next_state = LSST_WAIT_START;
+                       else
+                               next_state = LSST_RECONFIG_DONE;
+                       break;
+
+               case DO_FINISH:
+                       next_state = LSST_CLEAR;
+                       enable_locking(ls, finish_event);
+                       log_all(ls, "recover event %u finished", finish_event);
+                       break;
+
+               default:
+                       GDLM_ASSERT(0,);
+               }
+               goto out;
+       }
+
+      out:
+       if (next_state)
+               ls->ls_state = next_state;
+
+       if (gr) {
+               kfree(gr->gr_nodeids);
+               free_dlm_recover(gr);
+       }
+}
+
+static __inline__ gd_ls_t *get_work(int clear)
+{
+       gd_ls_t *ls;
+
+       spin_lock(&lslist_lock);
+
+       list_for_each_entry(ls, &lslist, ls_list) {
+               if (clear) {
+                       if (test_and_clear_bit(LSFL_WORK, &ls->ls_flags))
+                               goto got_work;
+
+               } else {
+                       if (test_bit(LSFL_WORK, &ls->ls_flags))
+                               goto got_work;
+               }
+       }
+       ls = NULL;
+
+ got_work:
+       spin_unlock(&lslist_lock);
+
+       return ls;
+}
+
+/* 
+ * Thread which does recovery for all lockspaces.
+ */
+
+static int dlm_recoverd(void *arg)
+{
+       gd_ls_t *ls;
+
+       daemonize("dlm_recoverd");
+       recoverd_task = current;
+       complete(&recoverd_run);
+
+       while (!test_bit(THREAD_STOP, &recoverd_flags)) {
+               wchan_cond_sleep_intr(recoverd_wait, !get_work(0));
+               if ((ls = get_work(1)))
+                       do_ls_recovery(ls);
+       }
+
+       complete(&recoverd_run);
+       return 0;
+}
+
+/* 
+ * Mark a specific lockspace as needing work and wake up the thread to do it.
+ */
+
+void recoverd_kick(gd_ls_t *ls)
+{
+       set_bit(LSFL_WORK, &ls->ls_flags);
+       wake_up(&recoverd_wait);
+}
+
+/* 
+ * Start the recoverd thread when gdlm is started (before any lockspaces).
+ */
+
+int recoverd_start(void)
+{
+       int error;
+
+       clear_bit(THREAD_STOP, &recoverd_flags);
+       error = kernel_thread(dlm_recoverd, NULL, 0);
+       if (error < 0)
+               goto out;
+
+       error = 0;
+       wait_for_completion(&recoverd_run);
+
+      out:
+       return error;
+}
+
+/* 
+ * Stop the recoverd thread when gdlm is shut down (all lockspaces are gone).
+ */
+
+int recoverd_stop(void)
+{
+       set_bit(THREAD_STOP, &recoverd_flags);
+       wake_up(&recoverd_wait);
+       wait_for_completion(&recoverd_run);
+
+       return 0;
+}
diff -urN linux-orig/cluster/dlm/recoverd.h linux-patched/cluster/dlm/recoverd.h
--- linux-orig/cluster/dlm/recoverd.h   1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/recoverd.h        2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,22 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __RECOVERD_DOT_H__
+#define __RECOVERD_DOT_H__
+
+void dlm_recoverd_init(void);
+void recoverd_kick(gd_ls_t * ls);
+int recoverd_start(void);
+int recoverd_stop(void);
+
+#endif                         /* __RECOVERD_DOT_H__ */
diff -urN linux-orig/cluster/dlm/rsb.c linux-patched/cluster/dlm/rsb.c
--- linux-orig/cluster/dlm/rsb.c        1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/rsb.c     2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,307 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include "dlm_internal.h"
+#include "locking.h"
+#include "memory.h"
+#include "lockqueue.h"
+#include "nodes.h"
+#include "dir.h"
+#include "util.h"
+
+static gd_res_t *search_hashchain(struct list_head *head, gd_res_t *parent,
+                                 char *name, int namelen)
+{
+       gd_res_t *r;
+
+       list_for_each_entry(r, head, res_hashchain) {
+               if ((parent == r->res_parent) && (namelen == r->res_length) &&
+                   (memcmp(name, r->res_name, namelen) == 0)) {
+                       atomic_inc(&r->res_ref);
+                       return r;
+               }
+       }
+
+       return NULL;
+}
+
+/*
+ * A way to arbitrarily hold onto an rsb which we already have a reference to
+ * to make sure it doesn't go away.  Opposite of release_rsb().
+ */
+
+void hold_rsb(gd_res_t *r)
+{
+       atomic_inc(&r->res_ref);
+}
+
+/*
+ * release_rsb() - Decrement reference count on rsb struct.  Free the rsb
+ * struct when there are zero references.  Every lkb for the rsb adds a
+ * reference.  When ref is zero there can be no more lkb's for the rsb, on the
+ * queue's or anywhere else.
+ */
+
+void release_rsb(gd_res_t *r)
+{
+       gd_ls_t *ls = r->res_ls;
+       int removed = FALSE;
+
+       write_lock(&ls->ls_reshash_lock);
+       atomic_dec(&r->res_ref);
+
+       if (!atomic_read(&r->res_ref)) {
+               GDLM_ASSERT(list_empty(&r->res_grantqueue),);
+               GDLM_ASSERT(list_empty(&r->res_waitqueue),);
+               GDLM_ASSERT(list_empty(&r->res_convertqueue),);
+               removed = TRUE;
+               list_del(&r->res_hashchain);
+       }
+       write_unlock(&ls->ls_reshash_lock);
+
+       if (removed) {
+               down_read(&ls->ls_gap_rsblist);
+               if (r->res_parent)
+                       list_del(&r->res_subreslist);
+               else
+                       list_del(&r->res_rootlist);
+               up_read(&ls->ls_gap_rsblist);
+
+               /*
+                * Remove resdir entry if this was a locally mastered root rsb.
+                */
+               if (!r->res_parent && !r->res_nodeid) {
+                       if (get_directory_nodeid(r) != our_nodeid())
+                               remote_remove_resdata(r->res_ls,
+                                                     get_directory_nodeid(r),
+                                                     r->res_name,
+                                                     r->res_length,
+                                                     r->res_resdir_seq);
+                       else
+                               remove_resdata(r->res_ls, our_nodeid(),
+                                              r->res_name, r->res_length,
+                                              r->res_resdir_seq);
+               }
+
+               if (r->res_lvbptr)
+                       free_lvb(r->res_lvbptr);
+
+               free_rsb(r);
+       }
+}
+
+/*
+ * find_or_create_rsb() - Get an rsb struct, or create one if it doesn't exist.
+ * If the rsb exists, its ref count is incremented by this function.  If it
+ * doesn't exist, it's created with a ref count of one.
+ */
+
+int find_or_create_rsb(gd_ls_t *ls, gd_res_t *parent, char *name, int namelen,
+                      int create, gd_res_t **rp)
+{
+       uint32_t hash;
+       gd_res_t *r, *tmp;
+       int error = -ENOMEM;
+
+       GDLM_ASSERT(namelen <= DLM_RESNAME_MAXLEN,);
+
+       hash = gdlm_hash(name, namelen);
+       hash &= ls->ls_hashmask;
+
+       read_lock(&ls->ls_reshash_lock);
+       r = search_hashchain(&ls->ls_reshashtbl[hash], parent, name, namelen);
+       read_unlock(&ls->ls_reshash_lock);
+
+       if (r)
+               goto out_set;
+       if (!create) {
+               *rp = NULL;
+               goto out;
+       }
+
+       r = allocate_rsb(ls, namelen);
+       if (!r)
+               goto fail;
+
+       INIT_LIST_HEAD(&r->res_subreslist);
+       INIT_LIST_HEAD(&r->res_grantqueue);
+       INIT_LIST_HEAD(&r->res_convertqueue);
+       INIT_LIST_HEAD(&r->res_waitqueue);
+
+       memcpy(r->res_name, name, namelen);
+       r->res_length = namelen;
+       r->res_ls = ls;
+       init_rwsem(&r->res_lock);
+       atomic_set(&r->res_ref, 1);
+
+       if (parent) {
+               r->res_parent = parent;
+               r->res_depth = parent->res_depth + 1;
+               r->res_root = parent->res_root;
+               r->res_nodeid = parent->res_nodeid;
+       } else {
+               r->res_parent = NULL;
+               r->res_depth = 1;
+               r->res_root = r;
+               r->res_nodeid = -1;
+       }
+
+       write_lock(&ls->ls_reshash_lock);
+       tmp = search_hashchain(&ls->ls_reshashtbl[hash], parent, name, namelen);
+       if (tmp) {
+               write_unlock(&ls->ls_reshash_lock);
+               free_rsb(r);
+               r = tmp;
+       } else {
+               list_add(&r->res_hashchain, &ls->ls_reshashtbl[hash]);
+               write_unlock(&ls->ls_reshash_lock);
+
+               down_read(&ls->ls_gap_rsblist);
+               if (parent)
+                       list_add_tail(&r->res_subreslist,
+                                     &r->res_root->res_subreslist);
+               else
+                       list_add(&r->res_rootlist, &ls->ls_rootres);
+               up_read(&ls->ls_gap_rsblist);
+       }
+
+      out_set:
+       *rp = r;
+
+      out:
+       error = 0;
+
+      fail:
+       return error;
+}
+
+/*
+ * Add a LKB to a resource's grant/convert/wait queue. in order
+ */
+
+void lkb_add_ordered(struct list_head *new, struct list_head *head, int mode)
+{
+       gd_lkb_t *lkb = NULL;
+
+       list_for_each_entry(lkb, head, lkb_statequeue) {
+               if (lkb->lkb_rqmode < mode)
+                       break;
+       }
+
+       if (!lkb) {
+               /* No entries in the queue, we are alone */
+               list_add_tail(new, head);
+       } else {
+               __list_add(new, lkb->lkb_statequeue.prev, &lkb->lkb_statequeue);
+       }
+}
+
+/*
+ * The rsb res_lock must be held in write when this function is called.
+ */
+
+void lkb_enqueue(gd_res_t *r, gd_lkb_t *lkb, int type)
+{
+
+       GDLM_ASSERT(!lkb->lkb_status, printk("status=%u\n", lkb->lkb_status););
+
+       lkb->lkb_status = type;
+
+       switch (type) {
+       case GDLM_LKSTS_WAITING:
+               list_add_tail(&lkb->lkb_statequeue, &r->res_waitqueue);
+               break;
+
+       case GDLM_LKSTS_GRANTED:
+               lkb_add_ordered(&lkb->lkb_statequeue, &r->res_grantqueue,
+                               lkb->lkb_grmode);
+               break;
+
+       case GDLM_LKSTS_CONVERT:
+               if (lkb->lkb_lockqueue_flags & DLM_LKF_EXPEDITE)
+                       list_add(&lkb->lkb_statequeue, &r->res_convertqueue);
+
+               else
+                       if (lkb->lkb_lockqueue_flags & DLM_LKF_QUECVT)
+                               list_add_tail(&lkb->lkb_statequeue,
+                                             &r->res_convertqueue);
+                       else
+                               lkb_add_ordered(&lkb->lkb_statequeue,
+                                               &r->res_convertqueue, lkb->lkb_rqmode);
+               break;
+
+       default:
+               GDLM_ASSERT(0,);
+       }
+}
+
+void res_lkb_enqueue(gd_res_t *r, gd_lkb_t *lkb, int type)
+{
+       down_write(&r->res_lock);
+       lkb_enqueue(r, lkb, type);
+       up_write(&r->res_lock);
+}
+
+/*
+ * The rsb res_lock must be held in write when this function is called.
+ */
+
+int lkb_dequeue(gd_lkb_t *lkb)
+{
+       int status = lkb->lkb_status;
+
+       if (!status)
+               goto out;
+
+       lkb->lkb_status = 0;
+       list_del(&lkb->lkb_statequeue);
+
+      out:
+       return status;
+}
+
+int res_lkb_dequeue(gd_lkb_t *lkb)
+{
+       int status;
+
+       down_write(&lkb->lkb_resource->res_lock);
+       status = lkb_dequeue(lkb);
+       up_write(&lkb->lkb_resource->res_lock);
+
+       return status;
+}
+
+/*
+ * The rsb res_lock must be held in write when this function is called.
+ */
+
+int lkb_swqueue(gd_res_t *r, gd_lkb_t *lkb, int type)
+{
+       int status;
+
+       status = lkb_dequeue(lkb);
+       lkb_enqueue(r, lkb, type);
+
+       return status;
+}
+
+int res_lkb_swqueue(gd_res_t *r, gd_lkb_t *lkb, int type)
+{
+       int status;
+
+       down_write(&r->res_lock);
+       status = lkb_swqueue(r, lkb, type);
+       up_write(&r->res_lock);
+
+       return status;
+}
diff -urN linux-orig/cluster/dlm/rsb.h linux-patched/cluster/dlm/rsb.h
--- linux-orig/cluster/dlm/rsb.h        1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/rsb.h     2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,30 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __RSB_DOT_H__
+#define __RSB_DOT_H__
+
+void lkb_add_ordered(struct list_head *new, struct list_head *head, int mode);
+void _release_rsb(gd_res_t * r);
+void release_rsb(gd_res_t * r);
+void hold_rsb(gd_res_t * r);
+int find_or_create_rsb(gd_ls_t * ls, gd_res_t * parent, char *name, int namelen,
+                      int create, gd_res_t ** rp);
+void lkb_enqueue(gd_res_t * r, gd_lkb_t * lkb, int type);
+void res_lkb_enqueue(gd_res_t * r, gd_lkb_t * lkb, int type);
+int lkb_dequeue(gd_lkb_t * lkb);
+int res_lkb_dequeue(gd_lkb_t * lkb);
+int lkb_swqueue(gd_res_t * r, gd_lkb_t * lkb, int type);
+int res_lkb_swqueue(gd_res_t * r, gd_lkb_t * lkb, int type);
+
+#endif                         /* __RSB_DOT_H__ */
diff -urN linux-orig/cluster/dlm/util.c linux-patched/cluster/dlm/util.c
--- linux-orig/cluster/dlm/util.c       1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/util.c    2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,130 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#include "dlm_internal.h"
+
+static const uint32_t crc_32_tab[] = {
+       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+       0xe963a535, 0x9e6495a3,
+       0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd,
+       0xe7b82d07, 0x90bf1d91,
+       0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb,
+       0xf4d4b551, 0x83d385c7,
+       0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+       0xfa0f3d63, 0x8d080df5,
+       0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447,
+       0xd20d85fd, 0xa50ab56b,
+       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75,
+       0xdcd60dcf, 0xabd13d59,
+       0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+       0xcfba9599, 0xb8bda50f,
+       0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11,
+       0xc1611dab, 0xb6662d3d,
+       0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+       0x9fbfe4a5, 0xe8b8d433,
+       0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+       0x91646c97, 0xe6635c01,
+       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b,
+       0x8208f4c1, 0xf50fc457,
+       0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49,
+       0x8cd37cf3, 0xfbd44c65,
+       0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+       0xa4d1c46d, 0xd3d6f4fb,
+       0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+       0xaa0a4c5f, 0xdd0d7cc9,
+       0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3,
+       0xb966d409, 0xce61e49f,
+       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+       0xb7bd5c3b, 0xc0ba6cad,
+       0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af,
+       0x04db2615, 0x73dc1683,
+       0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d,
+       0x0a00ae27, 0x7d079eb1,
+       0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+       0x196c3671, 0x6e6b06e7,
+       0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9,
+       0x17b7be43, 0x60b08ed5,
+       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767,
+       0x3fb506dd, 0x48b2364b,
+       0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+       0x316e8eef, 0x4669be79,
+       0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703,
+       0x220216b9, 0x5505262f,
+       0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+       0x2cd99e8b, 0x5bdeae1d,
+       0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+       0x72076785, 0x05005713,
+       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d,
+       0x7cdcefb7, 0x0bdbdf21,
+       0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b,
+       0x6fb077e1, 0x18b74777,
+       0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+       0x616bffd3, 0x166ccf45,
+       0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+       0x4969474d, 0x3e6e77db,
+       0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5,
+       0x47b2cf7f, 0x30b5ffe9,
+       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+       0x54de5729, 0x23d967bf,
+       0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1,
+       0x5a05df1b, 0x2d02ef8d
+};
+
+/**
+ * gdlm_hash - hash an array of data
+ * @data: the data to be hashed
+ * @len: the length of data to be hashed
+ *
+ * Copied from GFS.
+ *
+ * Take some data and convert it to a 32-bit hash.
+ *
+ * The hash function is a 32-bit CRC of the data.  The algorithm uses
+ * the crc_32_tab table above.
+ *
+ * This may not be the fastest hash function, but it does a fair bit better
+ * at providing uniform results than the others I've looked at.  That's
+ * really important for efficient directories.
+ *
+ * Returns: the hash
+ */
+
+uint32_t gdlm_hash(const char *data, int len)
+{
+       uint32_t hash = 0xFFFFFFFF;
+
+       for (; len--; data++)
+               hash = crc_32_tab[(hash ^ *data) & 0xFF] ^ (hash >> 8);
+
+       hash = ~hash;
+
+       return hash;
+}
+
+uint32_t gdlm_next_power2(uint32_t val)
+{
+       uint32_t x;
+
+       for (x = 1; x < val; x <<= 1) ;
+
+       return x;
+}
+
+void print_lkb(gd_lkb_t *lkb)
+{
+       printk("dlm: lkb id=%x remid=%x flags=%x status=%x rq=%d gr=%d "
+               "nodeid=%u lqstate=%x lqflags=%x\n",
+               lkb->lkb_id, lkb->lkb_remid, lkb->lkb_flags, lkb->lkb_status,
+               lkb->lkb_rqmode, lkb->lkb_grmode, lkb->lkb_nodeid,
+               lkb->lkb_lockqueue_state, lkb->lkb_lockqueue_flags);
+}
diff -urN linux-orig/cluster/dlm/util.h linux-patched/cluster/dlm/util.h
--- linux-orig/cluster/dlm/util.h       1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/cluster/dlm/util.h    2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,22 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**  
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __UTIL_DOT_H__
+#define __UTIL_DOT_H__
+
+uint32_t gdlm_hash(const char *data, int len);
+uint32_t gdlm_next_power2(uint32_t val);
+
+void print_lkb(gd_lkb_t *lkb);
+
+#endif
diff -urN linux-orig/include/cluster/dlm.h linux-patched/include/cluster/dlm.h
--- linux-orig/include/cluster/dlm.h    1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/include/cluster/dlm.h 2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,404 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __DLM_DOT_H__
+#define __DLM_DOT_H__
+
+/*
+ * Interface to DLM - routines and structures to use DLM lockspaces.
+ */
+
+/*
+ * Lock Modes
+ */
+
+#define DLM_LOCK_IV            (-1)    /* invalid */
+#define DLM_LOCK_NL            (0)     /* null */
+#define DLM_LOCK_CR            (1)     /* concurrent read */
+#define DLM_LOCK_CW            (2)     /* concurrent write */
+#define DLM_LOCK_PR            (3)     /* protected read */
+#define DLM_LOCK_PW            (4)     /* protected write */
+#define DLM_LOCK_EX            (5)     /* exclusive */
+
+/*
+ * Maximum size in bytes of a dlm_lock name
+ */
+
+#define DLM_RESNAME_MAXLEN     (64)
+
+/*
+ * Size in bytes of Lock Value Block
+ */
+
+#define DLM_LVB_LEN            (32)
+
+/*
+ * Flags to dlm_new_lockspace
+ *
+ * DLM_LSF_NOTIMERS
+ *
+ * Do not subject locks in this lockspace to time-outs.
+ *
+ */
+
+#define DLM_LSF_NOTIMERS       (1)
+
+/*
+ * Flags to dlm_lock
+ *
+ * DLM_LKF_NOQUEUE
+ *
+ * Do not queue the lock request on the wait queue if it cannot be granted
+ * immediately.  If the lock cannot be granted because of this flag, DLM will
+ * either return -EAGAIN from the dlm_lock call or will return 0 from
+ * dlm_lock and -EAGAIN in the lock status block when the AST is executed.
+ *
+ * DLM_LKF_CONVERT
+ *
+ * Indicates a lock conversion request.  For conversions the name and namelen
+ * are ignored and the lock ID in the LKSB is used to identify the lock.
+ *
+ * DLM_LKF_VALBLK
+ *
+ * Requests DLM to return the current contents of the lock value block in the
+ * lock status block.  When this flag is set in a lock conversion from PW or EX
+ * modes, DLM assigns the value specified in the lock status block to the lock
+ * value block of the lock resource.  The LVB is a DLM_LVB_LEN size array
+ * containing application-specific information.
+ *
+ * DLM_LKF_QUECVT
+ *
+ * Force a conversion lock request to the back of the convert queue.  All other
+ * conversion requests ahead of it must be granted before it can be granted.
+ * This enforces a FIFO ordering on the convert queue.  When this flag is set,
+ * indefinite postponement is averted.  This flag is allowed only when
+ * converting a lock to a more restrictive mode.
+ *
+ * DLM_LKF_CANCEL
+ *
+ * Used to cancel a pending conversion (with dlm_unlock).  Lock is returned to
+ * previously granted mode.
+ *
+ * DLM_LKF_IVVALBLK
+ *
+ * Invalidate/clear the lock value block.
+ *
+ * DLM_LKF_CONVDEADLK
+ *
+ * The granted mode of a lock being converted (from a non-NL mode) can be
+ * changed to NL in the process of acquiring the requested mode to avoid
+ * conversion deadlock.
+ *
+ * DLM_LKF_PERSISTENT
+ *
+ * Only relevant to locks originating in userspace. Signals to the ioctl.c code
+ * that this lock should not be unlocked when the process exits.
+ *
+ * DLM_LKF_NODLKWT
+ *
+ * This lock is not to be checked for conversion deadlocks.
+ *
+ * DLM_LKF_NODLCKBLK
+ *
+ * not yet implemented
+ *
+ * DLM_LKF_EXPEDITE
+ *
+ * If this lock conversion cannot be granted immediately it is to go to the
+ * head of the conversion queue regardless of its requested lock mode.
+ *
+ * DLM_LKF_NOQUEUEBAST
+ *
+ * Send blocking AST's before returning -EAGAIN to the caller.  It is only
+ * used along with the NOQUEUE flag.  Blocking AST's are not sent for failed
+ * NOQUEUE requests otherwise.
+ *
+ */
+
+#define DLM_LKF_NOQUEUE        (0x00000001)
+#define DLM_LKF_CANCEL         (0x00000002)
+#define DLM_LKF_CONVERT        (0x00000004)
+#define DLM_LKF_VALBLK         (0x00000008)
+#define DLM_LKF_QUECVT         (0x00000010)
+#define DLM_LKF_IVVALBLK       (0x00000020)
+#define DLM_LKF_CONVDEADLK     (0x00000040)
+#define DLM_LKF_PERSISTENT     (0x00000080)
+#define DLM_LKF_NODLCKWT       (0x00000100)
+#define DLM_LKF_NODLCKBLK      (0x00000200)
+#define DLM_LKF_EXPEDITE       (0x00000400)
+#define DLM_LKF_NOQUEUEBAST    (0x00000800)
+
+/*
+ * Some return codes that are not not in errno.h
+ */
+
+#define DLM_ECANCEL            (0x10001)
+#define DLM_EUNLOCK            (0x10002)
+
+typedef void dlm_lockspace_t;
+
+/*
+ * Lock range structure
+ */
+
+struct dlm_range {
+       uint64_t ra_start;
+       uint64_t ra_end;
+};
+
+/*
+ * Lock status block
+ *
+ * Use this structure to specify the contents of the lock value block.  For a
+ * conversion request, this structure is used to specify the lock ID of the
+ * lock.  DLM writes the status of the lock request and the lock ID assigned
+ * to the request in the lock status block.
+ *
+ * sb_lkid: the returned lock ID.  It is set on new (non-conversion) requests.
+ * It is available when dlm_lock returns.
+ *
+ * sb_lvbptr: saves or returns the contents of the lock's LVB according to rules
+ * shown for the DLM_LKF_VALBLK flag.
+ *
+ * sb_flags: DLM_SBF_DEMOTED is returned if in the process of promoting a lock,
+ * it was first demoted to NL to avoid conversion deadlock.
+ *
+ * sb_status: the returned status of the lock request set prior to AST
+ * execution.  Possible return values:
+ *
+ * 0 if lock request was successful
+ * -EAGAIN if request would block and is flagged DLM_LKF_NOQUEUE
+ * -ENOMEM if there is no memory to process request
+ * -EINVAL if there are invalid parameters
+ * -DLM_EUNLOCK if unlock request was successful
+ * -DLM_ECANCEL ?
+ */
+
+#define DLM_SBF_DEMOTED        (0x01)
+
+struct dlm_lksb {
+       int      sb_status;
+       uint32_t sb_lkid;
+       char     sb_flags;
+       char *   sb_lvbptr;
+};
+
+/*
+ * These defines are the bits that make up the
+ * query code.
+ */
+
+/* Bits 0, 1, 2, the lock mode or DLM_LOCK_THIS, see DLM_LOCK_NL etc in
+ * dlm.h Ignored for DLM_QUERY_LOCKS_ALL */
+#define DLM_LOCK_THIS            0x0007
+#define DLM_QUERY_MODE_MASK      0x0007
+
+/* Bits 3, 4, 5  bitmap of queue(s) to query */
+#define DLM_QUERY_QUEUE_WAIT     0x0008
+#define DLM_QUERY_QUEUE_CONVERT  0x0010
+#define DLM_QUERY_QUEUE_GRANT    0x0020
+#define DLM_QUERY_QUEUE_GRANTED  0x0030        /* Shorthand */
+#define DLM_QUERY_QUEUE_ALL      0x0038        /* Shorthand */
+
+/* Bit 6, Return only the information that can be established without a network
+ * round-trip. The caller must be aware of the implications of this. Useful for
+ * just getting the master node id or resource name. */
+#define DLM_QUERY_LOCAL          0x0040
+
+/* Bits 8 up, query type */
+#define DLM_QUERY_LOCKS_HIGHER   0x0100
+#define DLM_QUERY_LOCKS_LOWER    0x0200
+#define DLM_QUERY_LOCKS_EQUAL    0x0300
+#define DLM_QUERY_LOCKS_BLOCKING 0x0400
+#define DLM_QUERY_LOCKS_NOTBLOCK 0x0500
+#define DLM_QUERY_LOCKS_ALL      0x0600
+#define DLM_QUERY_MASK           0x0F00
+
+/* GRMODE is the default for mode comparisons,
+   RQMODE might also be handy */
+#define DLM_QUERY_GRMODE         0x0000
+#define DLM_QUERY_RQMODE         0x1000
+
+/* Structures passed into and out of the query */
+
+struct dlm_lockinfo {
+       int lki_lkid;           /* Lock ID on originating node */
+        int lki_mstlkid;        /* Lock ID on master node */
+       int lki_parent;
+       int lki_node;           /* Originating node (not master) */
+       uint8_t lki_state;      /* Queue the lock is on */
+       uint8_t lki_grmode;     /* Granted mode */
+       uint8_t lki_rqmode;     /* Requested mode */
+       struct dlm_range lki_grrange;   /* Granted range, if applicable */
+       struct dlm_range lki_rqrange;   /* Requested range, if applicable */
+};
+
+struct dlm_resinfo {
+       int rsi_length;
+       int rsi_grantcount;     /* No. of nodes on grant queue */
+       int rsi_convcount;      /* No. of nodes on convert queue */
+       int rsi_waitcount;      /* No. of nodes on wait queue */
+       int rsi_masternode;     /* Master for this resource */
+       char rsi_name[DLM_RESNAME_MAXLEN];      /* Resource name */
+       char rsi_valblk[DLM_LVB_LEN];   /* Master's LVB contents, if applicable
+                                        */
+};
+
+struct dlm_queryinfo {
+       struct dlm_resinfo *gqi_resinfo;
+       struct dlm_lockinfo *gqi_lockinfo;      /* This points to an array
+                                                * of structs */
+       int gqi_locksize;       /* input */
+       int gqi_lockcount;      /* output */
+};
+
+#ifdef __KERNEL__
+/*
+ * dlm_init
+ *
+ * Starts and initializes DLM threads and structures.  Creation of the first
+ * lockspace will call this if it has not been called already.
+ *
+ * Returns: 0 if successful, -EXXX on error
+ */
+
+int dlm_init(void);
+
+/*
+ * dlm_release
+ *
+ * Stops DLM threads.
+ *
+ * Returns: 0 if successful, -EXXX on error
+ */
+
+int dlm_release(void);
+
+/*
+ * dlm_new_lockspace
+ *
+ * Starts a lockspace with the given name.  If the named lockspace exists in
+ * the cluster, the calling node joins it.
+ */
+
+int dlm_new_lockspace(char *name, int namelen, dlm_lockspace_t **lockspace,
+                     int flags);
+
+/*
+ * dlm_release_lockspace
+ *
+ * Stop a lockspace.
+ */
+
+int dlm_release_lockspace(dlm_lockspace_t *lockspace, int force);
+
+/*
+ * dlm_lock
+ *
+ * Make an asyncronous request to acquire or convert a lock on a named
+ * resource.
+ *
+ * lockspace: context for the request
+ * mode: the requested mode of the lock (DLM_LOCK_)
+ * lksb: lock status block for input and async return values
+ * flags: input flags (DLM_LKF_)
+ * name: name of the resource to lock, can be binary
+ * namelen: the length in bytes of the resource name (MAX_RESNAME_LEN)
+ * parent: the lock ID of a parent lock or 0 if none
+ * lockast: function DLM executes when it completes processing the request
+ * astarg: argument passed to lockast and bast functions
+ * bast: function DLM executes when this lock later blocks another request
+ *
+ * Returns:
+ * 0 if request is successfully queued for processing
+ * -EINVAL if any input parameters are invalid
+ * -EAGAIN if request would block and is flagged DLM_LKF_NOQUEUE
+ * -ENOMEM if there is no memory to process request
+ * -ENOTCONN if there is a communication error
+ *
+ * If the call to dlm_lock returns an error then the operation has failed and
+ * the AST routine will not be called.  If dlm_lock returns 0 it is still
+ * possible that the lock operation will fail. The AST routine will be called
+ * when the locking is complete and the status is returned in the lksb.
+ *
+ * If the AST routines or parameter are passed to a conversion operation then
+ * they will overwrite those values that were passed to a previous dlm_lock
+ * call.
+ *
+ * AST routines should not block (at least not for long), but may make
+ * any locking calls they please.
+ */
+
+int dlm_lock(dlm_lockspace_t *lockspace,
+            uint32_t mode,
+            struct dlm_lksb *lksb,
+            uint32_t flags,
+            void *name,
+            unsigned int namelen,
+            uint32_t parent,
+            void (*lockast) (void *astarg),
+            void *astarg,
+            void (*bast) (void *astarg, int mode),
+            struct dlm_range *range);
+
+/*
+ * dlm_unlock
+ *
+ * Asynchronously release a lock on a resource.  The AST routine is called
+ * when the resource is successfully unlocked.
+ *
+ * lockspace: context for the request
+ * lkid: the lock ID as returned in the lksb
+ * flags: input flags (DLM_LKF_)
+ * lksb: if NULL the lksb parameter passed to last lock request is used
+ * astarg: if NULL, astarg in last lock request is used
+ *
+ * Returns:
+ * 0 if request is successfully queued for processing
+ * -EINVAL if any input parameters are invalid
+ * -ENOTEMPTY if the lock still has sublocks
+ * -EBUSY if the lock is waiting for a remote lock operation
+ * -ENOTCONN if there is a communication error
+ */
+
+extern int dlm_unlock(dlm_lockspace_t *lockspace,
+                      uint32_t lkid,
+                      uint32_t flags,
+                      struct dlm_lksb *lksb,
+                      void *astarg);
+
+/* Query interface
+ *
+ * Query the other holders of a resource, given a known lock ID
+ *
+ * lockspace:   context for the request
+ * lksb:        LKSB, sb_lkid contains the lock ID of a valid lock
+ *              on the resource. sb_status will contain the status
+ *             of the request on completion.
+ * query:       query bitmap see DLM_QUERY_* above
+ * qinfo:       pointer to dlm_queryinfo structure
+ * ast_routine: AST routine to call on completion
+ * artarg:      argument to AST routine. It is "traditional"
+ *              to put the qinfo pointer into lksb->sb_lvbptr
+ *              and pass the lksb in here.
+ */
+extern int dlm_query(dlm_lockspace_t *lockspace,
+                     struct dlm_lksb *lksb,
+                     int query,
+                     struct dlm_queryinfo *qinfo,
+                     void (ast_routine(void *)),
+                     void *astarg);
+
+#endif                         /* __KERNEL__ */
+
+#endif                         /* __DLM_DOT_H__ */
diff -urN linux-orig/include/cluster/dlm_device.h linux-patched/include/cluster/dlm_device.h
--- linux-orig/include/cluster/dlm_device.h     1970-01-01 07:30:00.000000000 +0730
+++ linux-patched/include/cluster/dlm_device.h  2004-06-25 18:31:07.000000000 +0800
@@ -0,0 +1,63 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/* This is the device interface for dlm, most users will use a library
+ * interface.
+ */
+
+/* Version of the device interface */
+#define DLM_DEVICE_VERSION_MAJOR 2
+#define DLM_DEVICE_VERSION_MINOR 0
+#define DLM_DEVICE_VERSION_PATCH 0
+
+/* struct passed to the lock write */
+struct dlm_lock_params {
+       uint32_t version[3];
+       uint8_t cmd;
+       uint8_t mode;
+       uint16_t flags;
+       uint32_t lkid;
+       uint32_t parent;
+       struct dlm_range range;
+       uint8_t namelen;
+        void *astparam;
+        void *astaddr;
+        void *bastaddr;
+        struct dlm_lksb *lksb;
+       char name[1];
+};
+
+
+/* struct read from the "device" fd,
+   consists mainly of userspace pointers for the library to use */
+struct dlm_lock_result {
+       uint8_t cmd;
+        void *astparam;
+        void (*astaddr)(void *astparam);
+        struct dlm_lksb *user_lksb;
+        struct dlm_lksb lksb;  /* But this has real data in it */
+        uint8_t bast_mode; /* Not yet used */
+};
+
+/* commands passed to the device */
+#define DLM_USER_LOCK       1
+#define DLM_USER_UNLOCK     2
+#define DLM_USER_QUERY      3
+
+/* Arbitrary length restriction */
+#define MAX_LS_NAME_LEN 64
+
+/* ioctls on the device */
+#define DLM_CREATE_LOCKSPACE         _IOW('D', 0x01, char *)
+#define DLM_RELEASE_LOCKSPACE        _IOW('D', 0x02, char *)
+#define DLM_FORCE_RELEASE_LOCKSPACE  _IOW('D', 0x03, char *)