[GFS2] An update of the GFS2 lock modules

This brings the lock modules uptodate and removes the stray
.mod.c file which accidently got included in the last check in.

Signed-off-by: David Teigland <teigland@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

10 files changed, 752 insertions, 490 deletions

diff --git a/fs/gfs2/locking/dlm/Makefile b/fs/gfs2/locking/dlm/Makefile
index d3bca02f7b3e..a9733ff80371 100644
--- a/fs/gfs2/locking/dlm/Makefile
+++ b/fs/gfs2/locking/dlm/Makefile
@@ -1,3 +1,3 @@
 obj-$(CONFIG_GFS2_FS) += lock_dlm.o
-lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o
+lock_dlm-y := lock.o main.o mount.o sysfs.o thread.o plock.o
 
diff --git a/fs/gfs2/locking/dlm/lock.c b/fs/gfs2/locking/dlm/lock.c
index daf59d504e29..d799865b64a4 100644
--- a/fs/gfs2/locking/dlm/lock.c
+++ b/fs/gfs2/locking/dlm/lock.c
@@ -1,15 +1,11 @@
-/******************************************************************************
-*******************************************************************************
-**
-**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
-**  Copyright (C) 2004-2005 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.
-**
-*******************************************************************************
-******************************************************************************/
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2005 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 "lock_dlm.h"
 
@@ -38,7 +34,7 @@ static inline void gdlm_bast(void *astarg, int mode)
         struct gdlm_ls *ls = lp->ls;
 
         if (!mode) {
-                printk("lock_dlm: bast mode zero %x,%"PRIx64"\n",
+                printk("lock_dlm: bast mode zero %x,%llx\n",
                         lp->lockname.ln_type, lp->lockname.ln_number);
                 return;
         }
@@ -75,9 +71,9 @@ static int16_t make_mode(int16_t lmstate)
                 return DLM_LOCK_CW;
         case LM_ST_SHARED:
                 return DLM_LOCK_PR;
-        default:
-                GDLM_ASSERT(0, printk("unknown LM state %d\n", lmstate););
         }
+        gdlm_assert(0, "unknown LM state %d", lmstate);
+        return -1;
 }
 
 /* convert dlm lock-mode to gfs lock-state */
@@ -94,9 +90,9 @@ int16_t gdlm_make_lmstate(int16_t dlmmode)
                 return LM_ST_DEFERRED;
         case DLM_LOCK_PR:
                 return LM_ST_SHARED;
-        default:
-                GDLM_ASSERT(0, printk("unknown DLM mode %d\n", dlmmode););
         }
+        gdlm_assert(0, "unknown DLM mode %d", dlmmode);
+        return -1;
 }
 
 /* verify agreement with GFS on the current lock state, NB: DLM_LOCK_NL and
@@ -106,7 +102,7 @@ static void check_cur_state(struct gdlm_lock *lp, unsigned int cur_state)
 {
         int16_t cur = make_mode(cur_state);
         if (lp->cur != DLM_LOCK_IV)
-                GDLM_ASSERT(lp->cur == cur, printk("%d, %d\n", lp->cur, cur););
+                gdlm_assert(lp->cur == cur, "%d, %d", lp->cur, cur);
 }
 
 static inline unsigned int make_flags(struct gdlm_lock *lp,
@@ -157,7 +153,7 @@ static inline unsigned int make_flags(struct gdlm_lock *lp,
 static inline void make_strname(struct lm_lockname *lockname,
                                 struct gdlm_strname *str)
 {
-        sprintf(str->name, "%8x%16"PRIx64, lockname->ln_type,
+        sprintf(str->name, "%8x%16llx", lockname->ln_type,
                 lockname->ln_number);
         str->namelen = GDLM_STRNAME_BYTES;
 }
@@ -167,11 +163,10 @@ int gdlm_create_lp(struct gdlm_ls *ls, struct lm_lockname *name,
 {
         struct gdlm_lock *lp;
 
-        lp = kmalloc(sizeof(struct gdlm_lock), GFP_KERNEL);
+        lp = kzalloc(sizeof(struct gdlm_lock), GFP_KERNEL);
         if (!lp)
                 return -ENOMEM;
 
-        memset(lp, 0, sizeof(struct gdlm_lock));
         lp->lockname = *name;
         lp->ls = ls;
         lp->cur = DLM_LOCK_IV;
@@ -202,7 +197,8 @@ void gdlm_delete_lp(struct gdlm_lock *lp)
                 list_del_init(&lp->blist);
         if (!list_empty(&lp->delay_list))
                 list_del_init(&lp->delay_list);
-        GDLM_ASSERT(!list_empty(&lp->all_list),);
+        gdlm_assert(!list_empty(&lp->all_list),
+                    "%x,%llx", lp->lockname.ln_type, lp->lockname.ln_number);
         list_del_init(&lp->all_list);
         ls->all_locks_count--;
         spin_unlock(&ls->async_lock);
@@ -227,7 +223,7 @@ void gdlm_put_lock(lm_lock_t *lock)
         gdlm_delete_lp((struct gdlm_lock *) lock);
 }
 
-void gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
+unsigned int gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
 {
         struct gdlm_ls *ls = lp->ls;
         struct gdlm_strname str;
@@ -242,7 +238,7 @@ void gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
         if (test_bit(DFL_BLOCK_LOCKS, &ls->flags) &&
             !test_bit(LFL_NOBLOCK, &lp->flags) && lp->req != DLM_LOCK_NL) {
                 gdlm_queue_delayed(lp);
-                return;
+                return LM_OUT_ASYNC;
         }
 
         /*
@@ -256,7 +252,7 @@ void gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
 
         set_bit(LFL_ACTIVE, &lp->flags);
 
-        log_debug("lk %x,%"PRIx64" id %x %d,%d %x", lp->lockname.ln_type,
+        log_debug("lk %x,%llx id %x %d,%d %x", lp->lockname.ln_type,
                   lp->lockname.ln_number, lp->lksb.sb_lkid,
                   lp->cur, lp->req, lp->lkf);
 
@@ -270,15 +266,19 @@ void gdlm_do_lock(struct gdlm_lock *lp, struct dlm_range *range)
                 error = 0;
         }
 
-        GDLM_ASSERT(!error,
-                   printk("%s: num=%x,%"PRIx64" err=%d cur=%d req=%d lkf=%x\n",
-                          ls->fsname, lp->lockname.ln_type,
+        if (error) {
+                log_debug("%s: gdlm_lock %x,%llx err=%d cur=%d req=%d lkf=%x "
+                          "flags=%lx", ls->fsname, lp->lockname.ln_type,
                           lp->lockname.ln_number, error, lp->cur, lp->req,
-                          lp->lkf););
+                          lp->lkf, lp->flags);
+                return LM_OUT_ERROR;
+        }
+        return LM_OUT_ASYNC;
 }
 
-void gdlm_do_unlock(struct gdlm_lock *lp)
+unsigned int gdlm_do_unlock(struct gdlm_lock *lp)
 {
+        struct gdlm_ls *ls = lp->ls;
         unsigned int lkf = 0;
         int error;
 
@@ -288,16 +288,19 @@ void gdlm_do_unlock(struct gdlm_lock *lp)
         if (lp->lvb)
                 lkf = DLM_LKF_VALBLK;
 
-        log_debug("un %x,%"PRIx64" %x %d %x", lp->lockname.ln_type,
+        log_debug("un %x,%llx %x %d %x", lp->lockname.ln_type,
                   lp->lockname.ln_number, lp->lksb.sb_lkid, lp->cur, lkf);
 
-        error = dlm_unlock(lp->ls->dlm_lockspace, lp->lksb.sb_lkid, lkf,
-                           NULL, lp);
+        error = dlm_unlock(ls->dlm_lockspace, lp->lksb.sb_lkid, lkf, NULL, lp);
 
-        GDLM_ASSERT(!error,
-                   printk("%s: error=%d num=%x,%"PRIx64" lkf=%x flags=%lx\n",
-                          lp->ls->fsname, error, lp->lockname.ln_type,
-                          lp->lockname.ln_number, lkf, lp->flags););
+        if (error) {
+                log_debug("%s: gdlm_unlock %x,%llx err=%d cur=%d req=%d lkf=%x "
+                          "flags=%lx", ls->fsname, lp->lockname.ln_type,
+                          lp->lockname.ln_number, error, lp->cur, lp->req,
+                          lp->lkf, lp->flags);
+                return LM_OUT_ERROR;
+        }
+        return LM_OUT_ASYNC;
 }
 
 unsigned int gdlm_lock(lm_lock_t *lock, unsigned int cur_state,
@@ -313,8 +316,7 @@ unsigned int gdlm_lock(lm_lock_t *lock, unsigned int cur_state,
         lp->req = make_mode(req_state);
         lp->lkf = make_flags(lp, flags, lp->cur, lp->req);
 
-        gdlm_do_lock(lp, NULL);
-        return LM_OUT_ASYNC;
+        return gdlm_do_lock(lp, NULL);
 }
 
 unsigned int gdlm_unlock(lm_lock_t *lock, unsigned int cur_state)
@@ -324,8 +326,7 @@ unsigned int gdlm_unlock(lm_lock_t *lock, unsigned int cur_state)
         clear_bit(LFL_DLM_CANCEL, &lp->flags);
         if (lp->cur == DLM_LOCK_IV)
                 return 0;
-        gdlm_do_unlock(lp);
-        return LM_OUT_ASYNC;
+        return gdlm_do_unlock(lp);
 }
 
 void gdlm_cancel(lm_lock_t *lock)
@@ -337,8 +338,8 @@ void gdlm_cancel(lm_lock_t *lock)
         if (test_bit(LFL_DLM_CANCEL, &lp->flags))
                 return;
 
-        log_all("gdlm_cancel %x,%"PRIx64" flags %lx",
-                lp->lockname.ln_type, lp->lockname.ln_number, lp->flags);
+        log_info("gdlm_cancel %x,%llx flags %lx",
+                 lp->lockname.ln_type, lp->lockname.ln_number, lp->flags);
 
         spin_lock(&ls->async_lock);
         if (!list_empty(&lp->delay_list)) {
@@ -356,9 +357,9 @@ void gdlm_cancel(lm_lock_t *lock)
 
         if (!test_bit(LFL_ACTIVE, &lp->flags) ||
             test_bit(LFL_DLM_UNLOCK, &lp->flags))       {
-                log_all("gdlm_cancel skip %x,%"PRIx64" flags %lx",
-                        lp->lockname.ln_type, lp->lockname.ln_number,
-                        lp->flags);
+                log_info("gdlm_cancel skip %x,%llx flags %lx",
+                         lp->lockname.ln_type, lp->lockname.ln_number,
+                         lp->flags);
                 return;
         }
 
@@ -370,8 +371,8 @@ void gdlm_cancel(lm_lock_t *lock)
         error = dlm_unlock(ls->dlm_lockspace, lp->lksb.sb_lkid, DLM_LKF_CANCEL,
                            NULL, lp);
 
-        log_all("gdlm_cancel rv %d %x,%"PRIx64" flags %lx", error,
-                lp->lockname.ln_type, lp->lockname.ln_number, lp->flags);
+        log_info("gdlm_cancel rv %d %x,%llx flags %lx", error,
+                 lp->lockname.ln_type, lp->lockname.ln_number, lp->flags);
 
         if (error == -EBUSY)
                 clear_bit(LFL_DLM_CANCEL, &lp->flags);
@@ -381,12 +382,10 @@ int gdlm_add_lvb(struct gdlm_lock *lp)
 {
         char *lvb;
 
-        lvb = kmalloc(GDLM_LVB_SIZE, GFP_KERNEL);
+        lvb = kzalloc(GDLM_LVB_SIZE, GFP_KERNEL);
         if (!lvb)
                 return -ENOMEM;
 
-        memset(lvb, 0, GDLM_LVB_SIZE);
-
         lp->lksb.sb_lvbptr = lvb;
         lp->lvb = lvb;
         return 0;
@@ -448,7 +447,8 @@ static void unhold_null_lock(struct gdlm_lock *lp)
 {
         struct gdlm_lock *lpn = lp->hold_null;
 
-        GDLM_ASSERT(lpn,);
+        gdlm_assert(lpn, "%x,%llx",
+                    lp->lockname.ln_type, lp->lockname.ln_number);
         lpn->lksb.sb_lvbptr = NULL;
         lpn->lvb = NULL;
         set_bit(LFL_UNLOCK_DELETE, &lpn->flags);
diff --git a/fs/gfs2/locking/dlm/lock_dlm.h b/fs/gfs2/locking/dlm/lock_dlm.h
new file mode 100644
index 000000000000..fa545f7872e8
--- /dev/null
+++ b/fs/gfs2/locking/dlm/lock_dlm.h
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2005 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 LOCK_DLM_DOT_H
+#define LOCK_DLM_DOT_H
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/list.h>
+#include <linux/socket.h>
+#include <linux/delay.h>
+#include <linux/kthread.h>
+#include <linux/kobject.h>
+#include <linux/fcntl.h>
+#include <linux/wait.h>
+#include <net/sock.h>
+
+#include <linux/dlm.h>
+#include "../../lm_interface.h"
+
+/*
+ * Internally, we prefix things with gdlm_ and GDLM_ (for gfs-dlm) since a
+ * prefix of lock_dlm_ gets awkward.  Externally, GFS refers to this module
+ * as "lock_dlm".
+ */
+
+#define GDLM_STRNAME_BYTES      24
+#define GDLM_LVB_SIZE           32
+#define GDLM_DROP_COUNT         50000
+#define GDLM_DROP_PERIOD        60
+#define GDLM_NAME_LEN           128
+
+/* GFS uses 12 bytes to identify a resource (32 bit type + 64 bit number).
+   We sprintf these numbers into a 24 byte string of hex values to make them
+   human-readable (to make debugging simpler.) */
+
+struct gdlm_strname {
+        unsigned char           name[GDLM_STRNAME_BYTES];
+        unsigned short          namelen;
+};
+
+enum {
+        DFL_BLOCK_LOCKS         = 0,
+        DFL_SPECTATOR           = 1,
+        DFL_WITHDRAW            = 2,
+};
+
+struct gdlm_ls {
+        uint32_t                id;
+        int                     jid;
+        int                     first;
+        int                     first_done;
+        unsigned long           flags;
+        struct kobject          kobj;
+        char                    clustername[GDLM_NAME_LEN];
+        char                    fsname[GDLM_NAME_LEN];
+        int                     fsflags;
+        dlm_lockspace_t         *dlm_lockspace;
+        lm_callback_t           fscb;
+        lm_fsdata_t             *fsdata;
+        int                     recover_jid;
+        int                     recover_jid_done;
+        spinlock_t              async_lock;
+        struct list_head        complete;
+        struct list_head        blocking;
+        struct list_head        delayed;
+        struct list_head        submit;
+        struct list_head        all_locks;
+        uint32_t                all_locks_count;
+        wait_queue_head_t       wait_control;
+        struct task_struct      *thread1;
+        struct task_struct      *thread2;
+        wait_queue_head_t       thread_wait;
+        unsigned long           drop_time;
+        int                     drop_locks_count;
+        int                     drop_locks_period;
+};
+
+enum {
+        LFL_NOBLOCK             = 0,
+        LFL_NOCACHE             = 1,
+        LFL_DLM_UNLOCK          = 2,
+        LFL_DLM_CANCEL          = 3,
+        LFL_SYNC_LVB            = 4,
+        LFL_FORCE_PROMOTE       = 5,
+        LFL_REREQUEST           = 6,
+        LFL_ACTIVE              = 7,
+        LFL_INLOCK              = 8,
+        LFL_CANCEL              = 9,
+        LFL_NOBAST              = 10,
+        LFL_HEADQUE             = 11,
+        LFL_UNLOCK_DELETE       = 12,
+};
+
+struct gdlm_lock {
+        struct gdlm_ls          *ls;
+        struct lm_lockname      lockname;
+        char                    *lvb;
+        struct dlm_lksb         lksb;
+
+        int16_t                 cur;
+        int16_t                 req;
+        int16_t                 prev_req;
+        uint32_t                lkf;            /* dlm flags DLM_LKF_ */
+        unsigned long           flags;          /* lock_dlm flags LFL_ */
+
+        int                     bast_mode;      /* protected by async_lock */
+        struct completion       ast_wait;
+
+        struct list_head        clist;          /* complete */
+        struct list_head        blist;          /* blocking */
+        struct list_head        delay_list;     /* delayed */
+        struct list_head        all_list;       /* all locks for the fs */
+        struct gdlm_lock        *hold_null;     /* NL lock for hold_lvb */
+};
+
+#define gdlm_assert(assertion, fmt, args...)                                  \
+do {                                                                          \
+        if (unlikely(!(assertion))) {                                         \
+                printk(KERN_EMERG "lock_dlm: fatal assertion failed \"%s\"\n" \
+                                  "lock_dlm:  " fmt "\n",                     \
+                                  #assertion, ##args);                        \
+                BUG();                                                        \
+        }                                                                     \
+} while (0)
+
+#define log_print(lev, fmt, arg...) printk(lev "lock_dlm: " fmt "\n" , ## arg)
+#define log_info(fmt, arg...)  log_print(KERN_INFO , fmt , ## arg)
+#define log_error(fmt, arg...) log_print(KERN_ERR , fmt , ## arg)
+#ifdef LOCK_DLM_LOG_DEBUG
+#define log_debug(fmt, arg...) log_print(KERN_DEBUG , fmt , ## arg)
+#else
+#define log_debug(fmt, arg...)
+#endif
+
+/* sysfs.c */
+
+int gdlm_sysfs_init(void);
+void gdlm_sysfs_exit(void);
+int gdlm_kobject_setup(struct gdlm_ls *, struct kobject *);
+void gdlm_kobject_release(struct gdlm_ls *);
+
+/* thread.c */
+
+int gdlm_init_threads(struct gdlm_ls *);
+void gdlm_release_threads(struct gdlm_ls *);
+
+/* lock.c */
+
+int16_t gdlm_make_lmstate(int16_t);
+void gdlm_queue_delayed(struct gdlm_lock *);
+void gdlm_submit_delayed(struct gdlm_ls *);
+int gdlm_release_all_locks(struct gdlm_ls *);
+int gdlm_create_lp(struct gdlm_ls *, struct lm_lockname *, struct gdlm_lock **);
+void gdlm_delete_lp(struct gdlm_lock *);
+int gdlm_add_lvb(struct gdlm_lock *);
+void gdlm_del_lvb(struct gdlm_lock *);
+unsigned int gdlm_do_lock(struct gdlm_lock *, struct dlm_range *);
+unsigned int gdlm_do_unlock(struct gdlm_lock *);
+
+int gdlm_get_lock(lm_lockspace_t *, struct lm_lockname *, lm_lock_t **);
+void gdlm_put_lock(lm_lock_t *);
+unsigned int gdlm_lock(lm_lock_t *, unsigned int, unsigned int, unsigned int);
+unsigned int gdlm_unlock(lm_lock_t *, unsigned int);
+void gdlm_cancel(lm_lock_t *);
+int gdlm_hold_lvb(lm_lock_t *, char **);
+void gdlm_unhold_lvb(lm_lock_t *, char *);
+void gdlm_sync_lvb(lm_lock_t *, char *);
+
+/* plock.c */
+
+int gdlm_plock_init(void);
+void gdlm_plock_exit(void);
+int gdlm_plock(lm_lockspace_t *, struct lm_lockname *, struct file *, int,
+                struct file_lock *);
+int gdlm_plock_get(lm_lockspace_t *, struct lm_lockname *, struct file *,
+                struct file_lock *);
+int gdlm_punlock(lm_lockspace_t *, struct lm_lockname *, struct file *,
+                struct file_lock *);
+#endif
+
diff --git a/fs/gfs2/locking/dlm/main.c b/fs/gfs2/locking/dlm/main.c
index 3ced92ef1b19..2c13c916a352 100644
--- a/fs/gfs2/locking/dlm/main.c
+++ b/fs/gfs2/locking/dlm/main.c
@@ -1,15 +1,11 @@
-/******************************************************************************
-*******************************************************************************
-**
-**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
-**  Copyright (C) 2004-2005 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.
-**
-*******************************************************************************
-******************************************************************************/
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2005 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>
 
@@ -24,7 +20,7 @@ int __init init_lock_dlm(void)
 {
         int error;
 
-        error = lm_register_proto(&gdlm_ops);
+        error = gfs_register_lockproto(&gdlm_ops);
         if (error) {
                 printk("lock_dlm:  can't register protocol: %d\n", error);
                 return error;
@@ -32,7 +28,14 @@ int __init init_lock_dlm(void)
 
         error = gdlm_sysfs_init();
         if (error) {
-                lm_unregister_proto(&gdlm_ops);
+                gfs_unregister_lockproto(&gdlm_ops);
+                return error;
+        }
+
+        error = gdlm_plock_init();
+        if (error) {
+                gdlm_sysfs_exit();
+                gfs_unregister_lockproto(&gdlm_ops);
                 return error;
         }
 
@@ -45,8 +48,9 @@ int __init init_lock_dlm(void)
 
 void __exit exit_lock_dlm(void)
 {
-        lm_unregister_proto(&gdlm_ops);
+        gdlm_plock_exit();
         gdlm_sysfs_exit();
+        gfs_unregister_lockproto(&gdlm_ops);
 }
 
 module_init(init_lock_dlm);
diff --git a/fs/gfs2/locking/dlm/mount.c b/fs/gfs2/locking/dlm/mount.c
index 92b1789deb89..bfb224638f2d 100644
--- a/fs/gfs2/locking/dlm/mount.c
+++ b/fs/gfs2/locking/dlm/mount.c
@@ -1,15 +1,11 @@
-/******************************************************************************
-*******************************************************************************
-**
-**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
-**  Copyright (C) 2004-2005 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.
-**
-*******************************************************************************
-******************************************************************************/
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2005 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 "lock_dlm.h"
 
@@ -24,27 +20,21 @@ static struct gdlm_ls *init_gdlm(lm_callback_t cb, lm_fsdata_t *fsdata,
         struct gdlm_ls *ls;
         char buf[256], *p;
 
-        ls = kmalloc(sizeof(struct gdlm_ls), GFP_KERNEL);
+        ls = kzalloc(sizeof(struct gdlm_ls), GFP_KERNEL);
         if (!ls)
                 return NULL;
 
-        memset(ls, 0, sizeof(struct gdlm_ls));
-
         ls->drop_locks_count = gdlm_drop_count;
         ls->drop_locks_period = gdlm_drop_period;
-
         ls->fscb = cb;
         ls->fsdata = fsdata;
         ls->fsflags = flags;
-
         spin_lock_init(&ls->async_lock);
-
         INIT_LIST_HEAD(&ls->complete);
         INIT_LIST_HEAD(&ls->blocking);
         INIT_LIST_HEAD(&ls->delayed);
         INIT_LIST_HEAD(&ls->submit);
         INIT_LIST_HEAD(&ls->all_locks);
-
         init_waitqueue_head(&ls->thread_wait);
         init_waitqueue_head(&ls->wait_control);
         ls->thread1 = NULL;
@@ -57,23 +47,75 @@ static struct gdlm_ls *init_gdlm(lm_callback_t cb, lm_fsdata_t *fsdata,
 
         p = strstr(buf, ":");
         if (!p) {
-                printk("lock_dlm: invalid table_name \"%s\"\n", table_name);
+                log_info("invalid table_name \"%s\"", table_name);
                 kfree(ls);
                 return NULL;
         }
         *p = '\0';
         p++;
 
-        strncpy(ls->clustername, buf, 128);
-        strncpy(ls->fsname, p, 128);
+        strncpy(ls->clustername, buf, GDLM_NAME_LEN);
+        strncpy(ls->fsname, p, GDLM_NAME_LEN);
 
         return ls;
 }
 
+static int make_args(struct gdlm_ls *ls, char *data_arg)
+{
+        char data[256];
+        char *options, *x, *y;
+        int error = 0;
+
+        memset(data, 0, 256);
+        strncpy(data, data_arg, 255);
+
+        for (options = data; (x = strsep(&options, ":")); ) {
+                if (!*x)
+                        continue;
+
+                y = strchr(x, '=');
+                if (y)
+                        *y++ = 0;
+
+                if (!strcmp(x, "jid")) {
+                        if (!y) {
+                                log_error("need argument to jid");
+                                error = -EINVAL;
+                                break;
+                        }
+                        sscanf(y, "%u", &ls->jid);
+
+                } else if (!strcmp(x, "first")) {
+                        if (!y) {
+                                log_error("need argument to first");
+                                error = -EINVAL;
+                                break;
+                        }
+                        sscanf(y, "%u", &ls->first);
+
+                } else if (!strcmp(x, "id")) {
+                        if (!y) {
+                                log_error("need argument to id");
+                                error = -EINVAL;
+                                break;
+                        }
+                        sscanf(y, "%u", &ls->id);
+
+                } else {
+                        log_error("unkonwn option: %s", x);
+                        error = -EINVAL;
+                        break;
+                }
+        }
+
+        return error;
+}
+
 static int gdlm_mount(char *table_name, char *host_data,
                         lm_callback_t cb, lm_fsdata_t *fsdata,
                         unsigned int min_lvb_size, int flags,
-                        struct lm_lockstruct *lockstruct)
+                        struct lm_lockstruct *lockstruct,
+                        struct kobject *fskobj)
 {
         struct gdlm_ls *ls;
         int error = -ENOMEM;
@@ -92,30 +134,18 @@ static int gdlm_mount(char *table_name, char *host_data,
         error = dlm_new_lockspace(ls->fsname, strlen(ls->fsname),
                                   &ls->dlm_lockspace, 0, GDLM_LVB_SIZE);
         if (error) {
-                printk("lock_dlm: dlm_new_lockspace error %d\n", error);
+                log_error("dlm_new_lockspace error %d", error);
                 goto out_thread;
         }
 
-        error = gdlm_kobject_setup(ls);
+        error = gdlm_kobject_setup(ls, fskobj);
         if (error)
                 goto out_dlm;
-        kobject_uevent(&ls->kobj, KOBJ_MOUNT, NULL);
 
-        /* Now we depend on userspace to notice the new mount,
-           join the appropriate group, and do a write to our sysfs
-           "mounted" or "terminate" file.  Before the start, userspace
-           must set "jid" and "first". */
-
-        error = wait_event_interruptible(ls->wait_control,
-                        test_bit(DFL_JOIN_DONE, &ls->flags));
+        error = make_args(ls, host_data);
         if (error)
                 goto out_sysfs;
 
-        if (test_bit(DFL_TERMINATE, &ls->flags)) {
-                error = -ERESTARTSYS;
-                goto out_sysfs;
-        }
-
         lockstruct->ls_jid = ls->jid;
         lockstruct->ls_first = ls->first;
         lockstruct->ls_lockspace = ls;
@@ -143,22 +173,19 @@ static void gdlm_unmount(lm_lockspace_t *lockspace)
 
         log_debug("unmount flags %lx", ls->flags);
 
-        if (test_bit(DFL_WITHDRAW, &ls->flags)) {
-                gdlm_kobject_release(ls);
-                goto out;
-        }
-
-        kobject_uevent(&ls->kobj, KOBJ_UMOUNT, NULL);
+        /* FIXME: serialize unmount and withdraw in case they
+           happen at once.  Also, if unmount follows withdraw,
+           wait for withdraw to finish. */
 
-        wait_event_interruptible(ls->wait_control,
-                                 test_bit(DFL_LEAVE_DONE, &ls->flags));
+        if (test_bit(DFL_WITHDRAW, &ls->flags))
+                goto out;
 
         gdlm_kobject_release(ls);
         dlm_release_lockspace(ls->dlm_lockspace, 2);
         gdlm_release_threads(ls);
         rv = gdlm_release_all_locks(ls);
         if (rv)
-                log_all("lm_dlm_unmount: %d stray locks freed", rv);
+                log_info("gdlm_unmount: %d stray locks freed", rv);
  out:
         kfree(ls);
 }
@@ -167,7 +194,7 @@ static void gdlm_recovery_done(lm_lockspace_t *lockspace, unsigned int jid,
                                unsigned int message)
 {
         struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;
-        ls->recover_done = jid;
+        ls->recover_jid_done = jid;
         kobject_uevent(&ls->kobj, KOBJ_CHANGE, NULL);
 }
 
@@ -178,12 +205,14 @@ static void gdlm_others_may_mount(lm_lockspace_t *lockspace)
         kobject_uevent(&ls->kobj, KOBJ_CHANGE, NULL);
 }
 
+/* Userspace gets the offline uevent, blocks new gfs locks on
+   other mounters, and lets us know (sets WITHDRAW flag).  Then,
+   userspace leaves the mount group while we leave the lockspace. */
+
 static void gdlm_withdraw(lm_lockspace_t *lockspace)
 {
         struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;
 
-        /* userspace suspends locking on all other members */
-
         kobject_uevent(&ls->kobj, KOBJ_OFFLINE, NULL);
 
         wait_event_interruptible(ls->wait_control,
@@ -192,49 +221,27 @@ static void gdlm_withdraw(lm_lockspace_t *lockspace)
         dlm_release_lockspace(ls->dlm_lockspace, 2);
         gdlm_release_threads(ls);
         gdlm_release_all_locks(ls);
-
-        kobject_uevent(&ls->kobj, KOBJ_UMOUNT, NULL);
-
-        /* userspace leaves the mount group, we don't need to wait for
-           that to complete */
-}
-
-int gdlm_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name,
-                   struct file *file, struct file_lock *fl)
-{
-        return -ENOSYS;
-}
-
-int gdlm_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name,
-                   struct file *file, struct file_lock *fl)
-{
-        return -ENOSYS;
-}
-
-int gdlm_plock(lm_lockspace_t *lockspace, struct lm_lockname *name,
-               struct file *file, int cmd, struct file_lock *fl)
-{
-        return -ENOSYS;
+        gdlm_kobject_release(ls);
 }
 
 struct lm_lockops gdlm_ops = {
-        lm_proto_name:"lock_dlm",
-        lm_mount:gdlm_mount,
-        lm_others_may_mount:gdlm_others_may_mount,
-        lm_unmount:gdlm_unmount,
-        lm_withdraw:gdlm_withdraw,
-        lm_get_lock:gdlm_get_lock,
-        lm_put_lock:gdlm_put_lock,
-        lm_lock:gdlm_lock,
-        lm_unlock:gdlm_unlock,
-        lm_plock:gdlm_plock,
-        lm_punlock:gdlm_punlock,
-        lm_plock_get:gdlm_plock_get,
-        lm_cancel:gdlm_cancel,
-        lm_hold_lvb:gdlm_hold_lvb,
-        lm_unhold_lvb:gdlm_unhold_lvb,
-        lm_sync_lvb:gdlm_sync_lvb,
-        lm_recovery_done:gdlm_recovery_done,
-        lm_owner:THIS_MODULE,
+        .lm_proto_name = "lock_dlm",
+        .lm_mount = gdlm_mount,
+        .lm_others_may_mount = gdlm_others_may_mount,
+        .lm_unmount = gdlm_unmount,
+        .lm_withdraw = gdlm_withdraw,
+        .lm_get_lock = gdlm_get_lock,
+        .lm_put_lock = gdlm_put_lock,
+        .lm_lock = gdlm_lock,
+        .lm_unlock = gdlm_unlock,
+        .lm_plock = gdlm_plock,
+        .lm_punlock = gdlm_punlock,
+        .lm_plock_get = gdlm_plock_get,
+        .lm_cancel = gdlm_cancel,
+        .lm_hold_lvb = gdlm_hold_lvb,
+        .lm_unhold_lvb = gdlm_unhold_lvb,
+        .lm_sync_lvb = gdlm_sync_lvb,
+        .lm_recovery_done = gdlm_recovery_done,
+        .lm_owner = THIS_MODULE,
 };
 
diff --git a/fs/gfs2/locking/dlm/plock.c b/fs/gfs2/locking/dlm/plock.c
new file mode 100644
index 000000000000..382847205bc1
--- /dev/null
+++ b/fs/gfs2/locking/dlm/plock.c
@@ -0,0 +1,297 @@
+/*
+ * Copyright (C) 2005 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/miscdevice.h>
+#include <linux/lock_dlm_plock.h>
+
+#include "lock_dlm.h"
+
+
+static spinlock_t ops_lock;
+static struct list_head send_list;
+static struct list_head recv_list;
+static wait_queue_head_t send_wq;
+static wait_queue_head_t recv_wq;
+
+struct plock_op {
+        struct list_head list;
+        int done;
+        struct gdlm_plock_info info;
+};
+
+static inline void set_version(struct gdlm_plock_info *info)
+{
+        info->version[0] = GDLM_PLOCK_VERSION_MAJOR;
+        info->version[1] = GDLM_PLOCK_VERSION_MINOR;
+        info->version[2] = GDLM_PLOCK_VERSION_PATCH;
+}
+
+static int check_version(struct gdlm_plock_info *info)
+{
+        if ((GDLM_PLOCK_VERSION_MAJOR != info->version[0]) ||
+            (GDLM_PLOCK_VERSION_MINOR < info->version[1])) {
+                log_error("plock device version mismatch: "
+                          "kernel (%u.%u.%u), user (%u.%u.%u)",
+                          GDLM_PLOCK_VERSION_MAJOR,
+                          GDLM_PLOCK_VERSION_MINOR,
+                          GDLM_PLOCK_VERSION_PATCH,
+                          info->version[0],
+                          info->version[1],
+                          info->version[2]);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static void send_op(struct plock_op *op)
+{
+        set_version(&op->info);
+        INIT_LIST_HEAD(&op->list);
+        spin_lock(&ops_lock);
+        list_add_tail(&op->list, &send_list);
+        spin_unlock(&ops_lock);
+        wake_up(&send_wq);
+}
+
+int gdlm_plock(lm_lockspace_t *lockspace, struct lm_lockname *name,
+               struct file *file, int cmd, struct file_lock *fl)
+{
+        struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;
+        struct plock_op *op;
+        int rv;
+
+        op = kzalloc(sizeof(*op), GFP_KERNEL);
+        if (!op)
+                return -ENOMEM;
+
+        op->info.optype         = GDLM_PLOCK_OP_LOCK;
+        op->info.pid            = (uint32_t) fl->fl_owner;
+        op->info.ex             = (fl->fl_type == F_WRLCK);
+        op->info.wait           = IS_SETLKW(cmd);
+        op->info.fsid           = ls->id;
+        op->info.number         = name->ln_number;
+        op->info.start          = fl->fl_start;
+        op->info.end            = fl->fl_end;
+
+        send_op(op);
+        wait_event(recv_wq, (op->done != 0));
+
+        spin_lock(&ops_lock);
+        if (!list_empty(&op->list)) {
+                printk("plock op on list\n");
+                list_del(&op->list);
+        }
+        spin_unlock(&ops_lock);
+
+        rv = op->info.rv;
+
+        if (!rv) {
+                if (posix_lock_file_wait(file, fl) < 0)
+                        log_error("gdlm_plock: vfs lock error %x,%llx",
+                                  name->ln_type, name->ln_number);
+        }
+
+        kfree(op);
+        return rv;
+}
+
+int gdlm_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name,
+                 struct file *file, struct file_lock *fl)
+{
+        struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;
+        struct plock_op *op;
+        int rv;
+
+        op = kzalloc(sizeof(*op), GFP_KERNEL);
+        if (!op)
+                return -ENOMEM;
+
+        if (posix_lock_file_wait(file, fl) < 0)
+                log_error("gdlm_punlock: vfs unlock error %x,%llx",
+                          name->ln_type, name->ln_number);
+
+        op->info.optype         = GDLM_PLOCK_OP_UNLOCK;
+        op->info.pid            = (uint32_t) fl->fl_owner;
+        op->info.fsid           = ls->id;
+        op->info.number         = name->ln_number;
+        op->info.start          = fl->fl_start;
+        op->info.end            = fl->fl_end;
+
+        send_op(op);
+        wait_event(recv_wq, (op->done != 0));
+
+        spin_lock(&ops_lock);
+        if (!list_empty(&op->list)) {
+                printk("punlock op on list\n");
+                list_del(&op->list);
+        }
+        spin_unlock(&ops_lock);
+
+        rv = op->info.rv;
+
+        kfree(op);
+        return rv;
+}
+
+int gdlm_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name,
+                   struct file *file, struct file_lock *fl)
+{
+        struct gdlm_ls *ls = (struct gdlm_ls *) lockspace;
+        struct plock_op *op;
+        int rv;
+
+        op = kzalloc(sizeof(*op), GFP_KERNEL);
+        if (!op)
+                return -ENOMEM;
+
+        op->info.optype         = GDLM_PLOCK_OP_GET;
+        op->info.pid            = (uint32_t) fl->fl_owner;
+        op->info.ex             = (fl->fl_type == F_WRLCK);
+        op->info.fsid           = ls->id;
+        op->info.number         = name->ln_number;
+        op->info.start          = fl->fl_start;
+        op->info.end            = fl->fl_end;
+
+        send_op(op);
+        wait_event(recv_wq, (op->done != 0));
+
+        spin_lock(&ops_lock);
+        if (!list_empty(&op->list)) {
+                printk("plock_get op on list\n");
+                list_del(&op->list);
+        }
+        spin_unlock(&ops_lock);
+
+        rv = op->info.rv;
+
+        if (rv == 0)
+                fl->fl_type = F_UNLCK;
+        else if (rv > 0) {
+                fl->fl_type = (op->info.ex) ? F_WRLCK : F_RDLCK;
+                fl->fl_pid = op->info.pid;
+                fl->fl_start = op->info.start;
+                fl->fl_end = op->info.end;
+        }
+
+        kfree(op);
+        return rv;
+}
+
+/* a read copies out one plock request from the send list */
+static ssize_t dev_read(struct file *file, char __user *u, size_t count,
+                        loff_t *ppos)
+{
+        struct gdlm_plock_info info;
+        struct plock_op *op = NULL;
+
+        if (count < sizeof(info))
+                return -EINVAL;
+
+        spin_lock(&ops_lock);
+        if (!list_empty(&send_list)) {
+                op = list_entry(send_list.next, struct plock_op, list);
+                list_move(&op->list, &recv_list);
+                memcpy(&info, &op->info, sizeof(info));
+        }
+        spin_unlock(&ops_lock);
+
+        if (!op)
+                return -EAGAIN;
+
+        if (copy_to_user(u, &info, sizeof(info)))
+                return -EFAULT;
+        return sizeof(info);
+}
+
+/* a write copies in one plock result that should match a plock_op
+   on the recv list */
+static ssize_t dev_write(struct file *file, const char __user *u, size_t count,
+                         loff_t *ppos)
+{
+        struct gdlm_plock_info info;
+        struct plock_op *op;
+        int found = 0;
+
+        if (count != sizeof(info))
+                return -EINVAL;
+
+        if (copy_from_user(&info, u, sizeof(info)))
+                return -EFAULT;
+
+        if (check_version(&info))
+                return -EINVAL;
+
+        spin_lock(&ops_lock);
+        list_for_each_entry(op, &recv_list, list) {
+                if (op->info.fsid == info.fsid &&
+                    op->info.number == info.number) {
+                        list_del_init(&op->list);
+                        found = 1;
+                        op->done = 1;
+                        memcpy(&op->info, &info, sizeof(info));
+                        break;
+                }
+        }
+        spin_unlock(&ops_lock);
+
+        if (found)
+                wake_up(&recv_wq);
+        else
+                printk("gdlm dev_write no op %x %llx\n", info.fsid,
+                        info.number);
+        return count;
+}
+
+static unsigned int dev_poll(struct file *file, poll_table *wait)
+{
+        poll_wait(file, &send_wq, wait);
+
+        spin_lock(&ops_lock);
+        if (!list_empty(&send_list)) {
+                spin_unlock(&ops_lock);
+                return POLLIN | POLLRDNORM;
+        }
+        spin_unlock(&ops_lock);
+        return 0;
+}
+
+static struct file_operations dev_fops = {
+        .read    = dev_read,
+        .write   = dev_write,
+        .poll    = dev_poll,
+        .owner   = THIS_MODULE
+};
+
+static struct miscdevice plock_dev_misc = {
+        .minor = MISC_DYNAMIC_MINOR,
+        .name = GDLM_PLOCK_MISC_NAME,
+        .fops = &dev_fops
+};
+
+int gdlm_plock_init(void)
+{
+        int rv;
+
+        spin_lock_init(&ops_lock);
+        INIT_LIST_HEAD(&send_list);
+        INIT_LIST_HEAD(&recv_list);
+        init_waitqueue_head(&send_wq);
+        init_waitqueue_head(&recv_wq);
+
+        rv = misc_register(&plock_dev_misc);
+        if (rv)
+                printk("gdlm_plock_init: misc_register failed %d", rv);
+        return rv;
+}
+
+void gdlm_plock_exit(void)
+{
+        if (misc_deregister(&plock_dev_misc) < 0)
+                printk("gdlm_plock_exit: misc_deregister failed");
+}
+
diff --git a/fs/gfs2/locking/dlm/sysfs.c b/fs/gfs2/locking/dlm/sysfs.c
index 8964733f55e4..e1e5186c97c9 100644
--- a/fs/gfs2/locking/dlm/sysfs.c
+++ b/fs/gfs2/locking/dlm/sysfs.c
@@ -1,21 +1,25 @@
-/******************************************************************************
-*******************************************************************************
-**
-**  Copyright (C) 2005 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.
-**
-*******************************************************************************
-******************************************************************************/
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2005 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/ctype.h>
 #include <linux/stat.h>
 
 #include "lock_dlm.h"
 
-static ssize_t gdlm_block_show(struct gdlm_ls *ls, char *buf)
+extern struct lm_lockops gdlm_ops;
+
+static ssize_t proto_name_show(struct gdlm_ls *ls, char *buf)
+{
+        return sprintf(buf, "%s\n", gdlm_ops.lm_proto_name);
+}
+
+static ssize_t block_show(struct gdlm_ls *ls, char *buf)
 {
         ssize_t ret;
         int val = 0;
@@ -26,7 +30,7 @@ static ssize_t gdlm_block_show(struct gdlm_ls *ls, char *buf)
         return ret;
 }
 
-static ssize_t gdlm_block_store(struct gdlm_ls *ls, const char *buf, size_t len)
+static ssize_t block_store(struct gdlm_ls *ls, const char *buf, size_t len)
 {
         ssize_t ret = len;
         int val;
@@ -43,43 +47,7 @@ static ssize_t gdlm_block_store(struct gdlm_ls *ls, const char *buf, size_t len)
         return ret;
 }
 
-static ssize_t gdlm_mounted_show(struct gdlm_ls *ls, char *buf)
-{
-        ssize_t ret;
-        int val = -2;
-
-        if (test_bit(DFL_TERMINATE, &ls->flags))
-                val = -1;
-        else if (test_bit(DFL_LEAVE_DONE, &ls->flags))
-                val = 0;
-        else if (test_bit(DFL_JOIN_DONE, &ls->flags))
-                val = 1;
-        ret = sprintf(buf, "%d\n", val);
-        return ret;
-}
-
-static ssize_t gdlm_mounted_store(struct gdlm_ls *ls, const char *buf, size_t len)
-{
-        ssize_t ret = len;
-        int val;
-
-        val = simple_strtol(buf, NULL, 0);
-
-        if (val == 1)
-                set_bit(DFL_JOIN_DONE, &ls->flags);
-        else if (val == 0)
-                set_bit(DFL_LEAVE_DONE, &ls->flags);
-        else if (val == -1) {
-                set_bit(DFL_TERMINATE, &ls->flags);
-                set_bit(DFL_JOIN_DONE, &ls->flags);
-                set_bit(DFL_LEAVE_DONE, &ls->flags);
-        } else
-                ret = -EINVAL;
-        wake_up(&ls->wait_control);
-        return ret;
-}
-
-static ssize_t gdlm_withdraw_show(struct gdlm_ls *ls, char *buf)
+static ssize_t withdraw_show(struct gdlm_ls *ls, char *buf)
 {
         ssize_t ret;
         int val = 0;
@@ -90,7 +58,7 @@ static ssize_t gdlm_withdraw_show(struct gdlm_ls *ls, char *buf)
         return ret;
 }
 
-static ssize_t gdlm_withdraw_store(struct gdlm_ls *ls, const char *buf, size_t len)
+static ssize_t withdraw_store(struct gdlm_ls *ls, const char *buf, size_t len)
 {
         ssize_t ret = len;
         int val;
@@ -105,67 +73,41 @@ static ssize_t gdlm_withdraw_store(struct gdlm_ls *ls, const char *buf, size_t l
         return ret;
 }
 
-static ssize_t gdlm_jid_show(struct gdlm_ls *ls, char *buf)
-{
-        return sprintf(buf, "%u\n", ls->jid);
-}
-
-static ssize_t gdlm_jid_store(struct gdlm_ls *ls, const char *buf, size_t len)
+static ssize_t id_show(struct gdlm_ls *ls, char *buf)
 {
-        ls->jid = simple_strtol(buf, NULL, 0);
-        return len;
+        return sprintf(buf, "%u\n", ls->id);
 }
 
-static ssize_t gdlm_first_show(struct gdlm_ls *ls, char *buf)
+static ssize_t jid_show(struct gdlm_ls *ls, char *buf)
 {
-        return sprintf(buf, "%u\n", ls->first);
+        return sprintf(buf, "%d\n", ls->jid);
 }
 
-static ssize_t gdlm_first_store(struct gdlm_ls *ls, const char *buf, size_t len)
+static ssize_t first_show(struct gdlm_ls *ls, char *buf)
 {
-        ls->first = simple_strtol(buf, NULL, 0);
-        return len;
+        return sprintf(buf, "%d\n", ls->first);
 }
 
-static ssize_t gdlm_first_done_show(struct gdlm_ls *ls, char *buf)
+static ssize_t first_done_show(struct gdlm_ls *ls, char *buf)
 {
         return sprintf(buf, "%d\n", ls->first_done);
 }
 
-static ssize_t gdlm_recover_show(struct gdlm_ls *ls, char *buf)
+static ssize_t recover_show(struct gdlm_ls *ls, char *buf)
 {
-        return sprintf(buf, "%u\n", ls->recover_jid);
+        return sprintf(buf, "%d\n", ls->recover_jid);
 }
 
-static ssize_t gdlm_recover_store(struct gdlm_ls *ls, const char *buf, size_t len)
+static ssize_t recover_store(struct gdlm_ls *ls, const char *buf, size_t len)
 {
         ls->recover_jid = simple_strtol(buf, NULL, 0);
         ls->fscb(ls->fsdata, LM_CB_NEED_RECOVERY, &ls->recover_jid);
         return len;
 }
 
-static ssize_t gdlm_recover_done_show(struct gdlm_ls *ls, char *buf)
-{
-        ssize_t ret;
-        ret = sprintf(buf, "%d\n", ls->recover_done);
-        return ret;
-}
-
-static ssize_t gdlm_cluster_show(struct gdlm_ls *ls, char *buf)
-{
-        ssize_t ret;
-        ret = sprintf(buf, "%s\n", ls->clustername);
-        return ret;
-}
-
-static ssize_t gdlm_options_show(struct gdlm_ls *ls, char *buf)
+static ssize_t recover_done_show(struct gdlm_ls *ls, char *buf)
 {
-        ssize_t ret = 0;
-
-        if (ls->fsflags & LM_MFLAG_SPECTATOR)
-                ret += sprintf(buf, "spectator ");
-
-        return ret;
+        return sprintf(buf, "%d\n", ls->recover_jid_done);
 }
 
 struct gdlm_attr {
@@ -174,73 +116,29 @@ struct gdlm_attr {
         ssize_t (*store)(struct gdlm_ls *, const char *, size_t);
 };
 
-static struct gdlm_attr gdlm_attr_block = {
-        .attr  = {.name = "block", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_block_show,
-        .store = gdlm_block_store
-};
-
-static struct gdlm_attr gdlm_attr_mounted = {
-        .attr  = {.name = "mounted", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_mounted_show,
-        .store = gdlm_mounted_store
-};
-
-static struct gdlm_attr gdlm_attr_withdraw = {
-        .attr  = {.name = "withdraw", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_withdraw_show,
-        .store = gdlm_withdraw_store
-};
-
-static struct gdlm_attr gdlm_attr_jid = {
-        .attr  = {.name = "jid", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_jid_show,
-        .store = gdlm_jid_store
-};
-
-static struct gdlm_attr gdlm_attr_first = {
-        .attr  = {.name = "first", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_first_show,
-        .store = gdlm_first_store
-};
-
-static struct gdlm_attr gdlm_attr_first_done = {
-        .attr  = {.name = "first_done", .mode = S_IRUGO},
-        .show  = gdlm_first_done_show,
-};
-
-static struct gdlm_attr gdlm_attr_recover = {
-        .attr  = {.name = "recover", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_recover_show,
-        .store = gdlm_recover_store
-};
-
-static struct gdlm_attr gdlm_attr_recover_done = {
-        .attr  = {.name = "recover_done", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_recover_done_show,
-};
-
-static struct gdlm_attr gdlm_attr_cluster = {
-        .attr  = {.name = "cluster", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_cluster_show,
-};
+#define GDLM_ATTR(_name,_mode,_show,_store) \
+static struct gdlm_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)
 
-static struct gdlm_attr gdlm_attr_options = {
-        .attr  = {.name = "options", .mode = S_IRUGO | S_IWUSR},
-        .show  = gdlm_options_show,
-};
+GDLM_ATTR(proto_name,   0444, proto_name_show,   NULL);
+GDLM_ATTR(block,        0644, block_show,        block_store);
+GDLM_ATTR(withdraw,     0644, withdraw_show,     withdraw_store);
+GDLM_ATTR(id,           0444, id_show,           NULL);
+GDLM_ATTR(jid,          0444, jid_show,          NULL);
+GDLM_ATTR(first,        0444, first_show,        NULL);
+GDLM_ATTR(first_done,   0444, first_done_show,   NULL);
+GDLM_ATTR(recover,      0644, recover_show,      recover_store);
+GDLM_ATTR(recover_done, 0444, recover_done_show, NULL);
 
 static struct attribute *gdlm_attrs[] = {
+        &gdlm_attr_proto_name.attr,
         &gdlm_attr_block.attr,
-        &gdlm_attr_mounted.attr,
         &gdlm_attr_withdraw.attr,
+        &gdlm_attr_id.attr,
         &gdlm_attr_jid.attr,
         &gdlm_attr_first.attr,
         &gdlm_attr_first_done.attr,
         &gdlm_attr_recover.attr,
         &gdlm_attr_recover_done.attr,
-        &gdlm_attr_cluster.attr,
-        &gdlm_attr_options.attr,
         NULL,
 };
 
@@ -276,20 +174,25 @@ static struct kset gdlm_kset = {
         .ktype  = &gdlm_ktype,
 };
 
-int gdlm_kobject_setup(struct gdlm_ls *ls)
+int gdlm_kobject_setup(struct gdlm_ls *ls, struct kobject *fskobj)
 {
         int error;
 
-        error = kobject_set_name(&ls->kobj, "%s", ls->fsname);
-        if (error)
+        error = kobject_set_name(&ls->kobj, "%s", "lock_module");
+        if (error) {
+                log_error("can't set kobj name %d", error);
                 return error;
+        }
 
         ls->kobj.kset = &gdlm_kset;
         ls->kobj.ktype = &gdlm_ktype;
+        ls->kobj.parent = fskobj;
 
         error = kobject_register(&ls->kobj);
+        if (error)
+                log_error("can't register kobj %d", error);
 
-        return 0;
+        return error;
 }
 
 void gdlm_kobject_release(struct gdlm_ls *ls)
diff --git a/fs/gfs2/locking/dlm/thread.c b/fs/gfs2/locking/dlm/thread.c
index 22bbe6d3a5ae..6fe669cd334b 100644
--- a/fs/gfs2/locking/dlm/thread.c
+++ b/fs/gfs2/locking/dlm/thread.c
@@ -1,15 +1,11 @@
-/******************************************************************************
-*******************************************************************************
-**
-**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
-**  Copyright (C) 2004-2005 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.
-**
-*******************************************************************************
-******************************************************************************/
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2005 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 "lock_dlm.h"
 
@@ -26,15 +22,10 @@ static void queue_submit(struct gdlm_lock *lp)
         wake_up(&ls->thread_wait);
 }
 
-static void process_submit(struct gdlm_lock *lp)
-{
-        gdlm_do_lock(lp, NULL);
-}
-
 static void process_blocking(struct gdlm_lock *lp, int bast_mode)
 {
         struct gdlm_ls *ls = lp->ls;
-        unsigned int cb;
+        unsigned int cb = 0;
 
         switch (gdlm_make_lmstate(bast_mode)) {
         case LM_ST_EXCLUSIVE:
@@ -47,7 +38,7 @@ static void process_blocking(struct gdlm_lock *lp, int bast_mode)
                 cb = LM_CB_NEED_S;
                 break;
         default:
-                GDLM_ASSERT(0, printk("unknown bast mode %u\n",lp->bast_mode););
+                gdlm_assert(0, "unknown bast mode %u", lp->bast_mode);
         }
 
         ls->fscb(ls->fsdata, cb, &lp->lockname);
@@ -62,9 +53,9 @@ static void process_complete(struct gdlm_lock *lp)
         memset(&acb, 0, sizeof(acb));
 
         if (lp->lksb.sb_status == -DLM_ECANCEL) {
-                log_all("complete dlm cancel %x,%"PRIx64" flags %lx",
-                        lp->lockname.ln_type, lp->lockname.ln_number,
-                        lp->flags);
+                log_info("complete dlm cancel %x,%llx flags %lx",
+                         lp->lockname.ln_type, lp->lockname.ln_number,
+                         lp->flags);
 
                 lp->req = lp->cur;
                 acb.lc_ret |= LM_OUT_CANCELED;
@@ -75,9 +66,9 @@ static void process_complete(struct gdlm_lock *lp)
 
         if (test_and_clear_bit(LFL_DLM_UNLOCK, &lp->flags)) {
                 if (lp->lksb.sb_status != -DLM_EUNLOCK) {
-                        log_all("unlock sb_status %d %x,%"PRIx64" flags %lx",
-                                lp->lksb.sb_status, lp->lockname.ln_type,
-                                lp->lockname.ln_number, lp->flags);
+                        log_info("unlock sb_status %d %x,%llx flags %lx",
+                                 lp->lksb.sb_status, lp->lockname.ln_type,
+                                 lp->lockname.ln_number, lp->flags);
                         return;
                 }
 
@@ -108,8 +99,8 @@ static void process_complete(struct gdlm_lock *lp)
          */
 
         if (test_and_clear_bit(LFL_CANCEL, &lp->flags)) {
-                log_all("complete internal cancel %x,%"PRIx64"",
-                        lp->lockname.ln_type, lp->lockname.ln_number);
+                log_info("complete internal cancel %x,%llx",
+                         lp->lockname.ln_type, lp->lockname.ln_number);
                 lp->req = lp->cur;
                 acb.lc_ret |= LM_OUT_CANCELED;
                 goto out;
@@ -130,9 +121,9 @@ static void process_complete(struct gdlm_lock *lp)
                 }
 
                 /* this could only happen with cancels I think */
-                log_all("ast sb_status %d %x,%"PRIx64" flags %lx",
-                        lp->lksb.sb_status, lp->lockname.ln_type,
-                        lp->lockname.ln_number, lp->flags);
+                log_info("ast sb_status %d %x,%llx flags %lx",
+                         lp->lksb.sb_status, lp->lockname.ln_type,
+                         lp->lockname.ln_number, lp->flags);
                 return;
         }
 
@@ -152,8 +143,10 @@ static void process_complete(struct gdlm_lock *lp)
          */
 
         if (test_and_clear_bit(LFL_REREQUEST, &lp->flags)) {
-                GDLM_ASSERT(lp->req == DLM_LOCK_NL,);
-                GDLM_ASSERT(lp->prev_req > DLM_LOCK_NL,);
+                gdlm_assert(lp->req == DLM_LOCK_NL, "%x,%llx",
+                            lp->lockname.ln_type, lp->lockname.ln_number);
+                gdlm_assert(lp->prev_req > DLM_LOCK_NL, "%x,%llx",
+                            lp->lockname.ln_type, lp->lockname.ln_number);
 
                 lp->cur = DLM_LOCK_NL;
                 lp->req = lp->prev_req;
@@ -189,7 +182,7 @@ static void process_complete(struct gdlm_lock *lp)
                 lp->lkf |= DLM_LKF_CONVERT;
                 lp->lkf &= ~DLM_LKF_CONVDEADLK;
 
-                log_debug("rereq %x,%"PRIx64" id %x %d,%d",
+                log_debug("rereq %x,%llx id %x %d,%d",
                           lp->lockname.ln_type, lp->lockname.ln_number,
                           lp->lksb.sb_lkid, lp->cur, lp->req);
 
@@ -315,7 +308,7 @@ static int gdlm_thread(void *data)
                         process_blocking(lp, blocking);
 
                 else if (submit)
-                        process_submit(lp);
+                        gdlm_do_lock(lp, NULL);
 
                 if (drop)
                         ls->fscb(ls->fsdata, LM_CB_DROPLOCKS, NULL);
@@ -334,7 +327,7 @@ int gdlm_init_threads(struct gdlm_ls *ls)
         p = kthread_run(gdlm_thread, ls, "lock_dlm1");
         error = IS_ERR(p);
         if (error) {
-                log_all("can't start lock_dlm1 thread %d", error);
+                log_error("can't start lock_dlm1 thread %d", error);
                 return error;
         }
         ls->thread1 = p;
@@ -342,7 +335,7 @@ int gdlm_init_threads(struct gdlm_ls *ls)
         p = kthread_run(gdlm_thread, ls, "lock_dlm2");
         error = IS_ERR(p);
         if (error) {
-                log_all("can't start lock_dlm2 thread %d", error);
+                log_error("can't start lock_dlm2 thread %d", error);
                 kthread_stop(ls->thread1);
                 return error;
         }
diff --git a/fs/gfs2/locking/nolock/lock_nolock.mod.c b/fs/gfs2/locking/nolock/lock_nolock.mod.c
deleted file mode 100644
index ae92522b2182..000000000000
--- a/fs/gfs2/locking/nolock/lock_nolock.mod.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#include <linux/module.h>
-#include <linux/vermagic.h>
-#include <linux/compiler.h>
-
-MODULE_INFO(vermagic, VERMAGIC_STRING);
-
-#undef unix
-struct module __this_module
-__attribute__((section(".gnu.linkonce.this_module"))) = {
- .name = __stringify(KBUILD_MODNAME),
- .init = init_module,
-#ifdef CONFIG_MODULE_UNLOAD
- .exit = cleanup_module,
-#endif
-};
-
-static const struct modversion_info ____versions[]
-__attribute_used__
-__attribute__((section("__versions"))) = {
-        { 0x316962fc, "struct_module" },
-        { 0x5a34a45c, "__kmalloc" },
-        { 0x724beef2, "malloc_sizes" },
-        { 0x3fa03a97, "memset" },
-        { 0xc16fe12d, "__memcpy" },
-        { 0xdd132261, "printk" },
-        { 0x859204af, "sscanf" },
-        { 0x3656bf5a, "lock_kernel" },
-        { 0x1e6d26a8, "strstr" },
-        { 0x41ede9df, "lm_register_proto" },
-        { 0xb1f975aa, "unlock_kernel" },
-        { 0x87b0b01f, "posix_lock_file_wait" },
-        { 0x75f29cfd, "kmem_cache_alloc" },
-        { 0x69384280, "lm_unregister_proto" },
-        { 0x37a0cba, "kfree" },
-        { 0x5d16bfe6, "posix_test_lock" },
-};
-
-static const char __module_depends[]
-__attribute_used__
-__attribute__((section(".modinfo"))) =
-"depends=gfs2";
-
-
-MODULE_INFO(srcversion, "123E446F965A386A0C017C4");
diff --git a/fs/gfs2/locking/nolock/main.c b/fs/gfs2/locking/nolock/main.c
index d3919e471163..b716e336c073 100644
--- a/fs/gfs2/locking/nolock/main.c
+++ b/fs/gfs2/locking/nolock/main.c
@@ -1,15 +1,11 @@
-/******************************************************************************
-*******************************************************************************
-**
-**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
-**  Copyright (C) 2004-2005 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.
-**
-*******************************************************************************
-******************************************************************************/
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2005 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/slab.h>
@@ -27,23 +23,11 @@ struct nolock_lockspace {
 
 struct lm_lockops nolock_ops;
 
-/**
- * nolock_mount - mount a nolock lockspace
- * @table_name: the name of the space to mount
- * @host_data: host specific data
- * @cb: the callback
- * @fsdata:
- * @min_lvb_size:
- * @flags:
- * @lockstruct: the structure of crap to fill in
- *
- * Returns: 0 on success, -EXXX on failure
- */
-
 static int nolock_mount(char *table_name, char *host_data,
                         lm_callback_t cb, lm_fsdata_t *fsdata,
                         unsigned int min_lvb_size, int flags,
-                        struct lm_lockstruct *lockstruct)
+                        struct lm_lockstruct *lockstruct,
+                        struct kobject *fskobj)
 {
         char *c;
         unsigned int jid;
@@ -77,34 +61,16 @@ static int nolock_mount(char *table_name, char *host_data,
         return 0;
 }
 
-/**
- * nolock_others_may_mount - unmount a lock space
- * @lockspace: the lockspace to unmount
- *
- */
-
 static void nolock_others_may_mount(lm_lockspace_t *lockspace)
 {
 }
 
-/**
- * nolock_unmount - unmount a lock space
- * @lockspace: the lockspace to unmount
- *
- */
-
 static void nolock_unmount(lm_lockspace_t *lockspace)
 {
         struct nolock_lockspace *nl = (struct nolock_lockspace *)lockspace;
         kfree(nl);
 }
 
-/**
- * nolock_withdraw - withdraw from a lock space
- * @lockspace: the lockspace
- *
- */
-
 static void nolock_withdraw(lm_lockspace_t *lockspace)
 {
 }
@@ -164,12 +130,6 @@ static unsigned int nolock_unlock(lm_lock_t *lock, unsigned int cur_state)
         return 0;
 }
 
-/**
- * nolock_cancel - cancel a request on a lock
- * @lock: the lock to cancel request for
- *
- */
-
 static void nolock_cancel(lm_lock_t *lock)
 {
 }
@@ -219,16 +179,6 @@ static void nolock_sync_lvb(lm_lock_t *lock, char *lvb)
 {
 }
 
-/**
- * nolock_plock_get -
- * @lockspace: the lockspace
- * @name:
- * @file:
- * @fl:
- *
- * Returns: errno
- */
-
 static int nolock_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name,
                             struct file *file, struct file_lock *fl)
 {
@@ -244,17 +194,6 @@ static int nolock_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name,
         return 0;
 }
 
-/**
- * nolock_plock -
- * @lockspace: the lockspace
- * @name:
- * @file:
- * @cmd:
- * @fl:
- *
- * Returns: errno
- */
-
 static int nolock_plock(lm_lockspace_t *lockspace, struct lm_lockname *name,
                         struct file *file, int cmd, struct file_lock *fl)
 {
@@ -265,16 +204,6 @@ static int nolock_plock(lm_lockspace_t *lockspace, struct lm_lockname *name,
         return error;
 }
 
-/**
- * nolock_punlock -
- * @lockspace: the lockspace
- * @name:
- * @file:
- * @fl:
- *
- * Returns: errno
- */
-
 static int nolock_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name,
                           struct file *file, struct file_lock *fl)
 {
@@ -285,13 +214,6 @@ static int nolock_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name,
         return error;
 }
 
-/**
- * nolock_recovery_done - reset the expired locks for a given jid
- * @lockspace: the lockspace
- * @jid: the jid
- *
- */
-
 static void nolock_recovery_done(lm_lockspace_t *lockspace, unsigned int jid,
                                  unsigned int message)
 {
@@ -318,17 +240,11 @@ struct lm_lockops nolock_ops = {
         .lm_owner = THIS_MODULE,
 };
 
-/**
- * init_nolock - Initialize the nolock module
- *
- * Returns: 0 on success, -EXXX on failure
- */
-
 int __init init_nolock(void)
 {
         int error;
 
-        error = lm_register_proto(&nolock_ops);
+        error = gfs_register_lockproto(&nolock_ops);
         if (error) {
                 printk("lock_nolock: can't register protocol: %d\n", error);
                 return error;
@@ -338,14 +254,9 @@ int __init init_nolock(void)
         return 0;
 }
 
-/**
- * exit_nolock - cleanup the nolock module
- *
- */
-
 void __exit exit_nolock(void)
 {
-        lm_unregister_proto(&nolock_ops);
+        gfs_unregister_lockproto(&nolock_ops);
 }
 
 module_init(init_nolock);