Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/dlm

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/dlm:
  dlm: fs/dlm/ast.c: fix warning
  dlm: add new debugfs entry
  dlm: add time stamp of blocking callback
  dlm: change lock time stamping
  dlm: improve how bast mode handling
  dlm: remove extra blocking callback check
  dlm: replace schedule with cond_resched
  dlm: remove kmap/kunmap
  dlm: trivial annotation of be16 value
  dlm: fix up memory allocation flags

12 files changed, 316 insertions, 130 deletions

diff --git a/fs/dlm/ast.c b/fs/dlm/ast.c
index 8bf31e3fbf01..dc2ad6008b2d 100644
--- a/fs/dlm/ast.c
+++ b/fs/dlm/ast.c
@@ -2,7 +2,7 @@
 *******************************************************************************
 **
 **  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
-**  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
+**  Copyright (C) 2004-2008 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
@@ -33,10 +33,10 @@ void dlm_del_ast(struct dlm_lkb *lkb)
         spin_unlock(&ast_queue_lock);
 }
 
-void dlm_add_ast(struct dlm_lkb *lkb, int type)
+void dlm_add_ast(struct dlm_lkb *lkb, int type, int bastmode)
 {
         if (lkb->lkb_flags & DLM_IFL_USER) {
-                dlm_user_add_ast(lkb, type);
+                dlm_user_add_ast(lkb, type, bastmode);
                 return;
         }
 
@@ -46,6 +46,8 @@ void dlm_add_ast(struct dlm_lkb *lkb, int type)
                 list_add_tail(&lkb->lkb_astqueue, &ast_queue);
         }
         lkb->lkb_ast_type |= type;
+        if (bastmode)
+                lkb->lkb_bastmode = bastmode;
         spin_unlock(&ast_queue_lock);
 
         set_bit(WAKE_ASTS, &astd_wakeflags);
@@ -59,50 +61,40 @@ static void process_asts(void)
         struct dlm_lkb *lkb;
         void (*cast) (void *astparam);
         void (*bast) (void *astparam, int mode);
-        int type = 0, found, bmode;
-
-        for (;;) {
-                found = 0;
-                spin_lock(&ast_queue_lock);
-                list_for_each_entry(lkb, &ast_queue, lkb_astqueue) {
-                        r = lkb->lkb_resource;
-                        ls = r->res_ls;
-
-                        if (dlm_locking_stopped(ls))
-                                continue;
-
-                        list_del(&lkb->lkb_astqueue);
-                        type = lkb->lkb_ast_type;
-                        lkb->lkb_ast_type = 0;
-                        found = 1;
-                        break;
-                }
-                spin_unlock(&ast_queue_lock);
+        int type = 0, bastmode;
+
+repeat:
+        spin_lock(&ast_queue_lock);
+        list_for_each_entry(lkb, &ast_queue, lkb_astqueue) {
+                r = lkb->lkb_resource;
+                ls = r->res_ls;
+
+                if (dlm_locking_stopped(ls))
+                        continue;
 
-                if (!found)
-                        break;
+                list_del(&lkb->lkb_astqueue);
+                type = lkb->lkb_ast_type;
+                lkb->lkb_ast_type = 0;
+                bastmode = lkb->lkb_bastmode;
 
+                spin_unlock(&ast_queue_lock);
                 cast = lkb->lkb_astfn;
                 bast = lkb->lkb_bastfn;
-                bmode = lkb->lkb_bastmode;
 
                 if ((type & AST_COMP) && cast)
                         cast(lkb->lkb_astparam);
 
-                /* FIXME: Is it safe to look at lkb_grmode here
-                   without doing a lock_rsb() ?
-                   Look at other checks in v1 to avoid basts. */
-
                 if ((type & AST_BAST) && bast)
-                        if (!dlm_modes_compat(lkb->lkb_grmode, bmode))
-                                bast(lkb->lkb_astparam, bmode);
+                        bast(lkb->lkb_astparam, bastmode);
 
                 /* this removes the reference added by dlm_add_ast
                    and may result in the lkb being freed */
                 dlm_put_lkb(lkb);
 
-                schedule();
+                cond_resched();
+                goto repeat;
         }
+        spin_unlock(&ast_queue_lock);
 }
 
 static inline int no_asts(void)
diff --git a/fs/dlm/ast.h b/fs/dlm/ast.h
index 6ee276c74c52..1b5fc5f428fd 100644
--- a/fs/dlm/ast.h
+++ b/fs/dlm/ast.h
@@ -1,7 +1,7 @@
 /******************************************************************************
 *******************************************************************************
 **
-**  Copyright (C) 2005 Red Hat, Inc.  All rights reserved.
+**  Copyright (C) 2005-2008 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
@@ -13,7 +13,7 @@
 #ifndef __ASTD_DOT_H__
 #define __ASTD_DOT_H__
 
-void dlm_add_ast(struct dlm_lkb *lkb, int type);
+void dlm_add_ast(struct dlm_lkb *lkb, int type, int bastmode);
 void dlm_del_ast(struct dlm_lkb *lkb);
 
 void dlm_astd_wake(void);
diff --git a/fs/dlm/debug_fs.c b/fs/dlm/debug_fs.c
index 8fc24f4507a3..2f107d1a6a45 100644
--- a/fs/dlm/debug_fs.c
+++ b/fs/dlm/debug_fs.c
@@ -1,7 +1,7 @@
 /******************************************************************************
 *******************************************************************************
 **
-**  Copyright (C) 2005 Red Hat, Inc.  All rights reserved.
+**  Copyright (C) 2005-2008 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
@@ -27,7 +27,7 @@ static struct dentry *dlm_root;
 
 struct rsb_iter {
         int entry;
-        int locks;
+        int format;
         int header;
         struct dlm_ls *ls;
         struct list_head *next;
@@ -60,8 +60,8 @@ static char *print_lockmode(int mode)
         }
 }
 
-static void print_resource_lock(struct seq_file *s, struct dlm_lkb *lkb,
-                                struct dlm_rsb *res)
+static void print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb,
+                               struct dlm_rsb *res)
 {
         seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));
 
@@ -83,7 +83,7 @@ static void print_resource_lock(struct seq_file *s, struct dlm_lkb *lkb,
         seq_printf(s, "\n");
 }
 
-static int print_resource(struct dlm_rsb *res, struct seq_file *s)
+static int print_format1(struct dlm_rsb *res, struct seq_file *s)
 {
         struct dlm_lkb *lkb;
         int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
@@ -134,15 +134,15 @@ static int print_resource(struct dlm_rsb *res, struct seq_file *s)
         /* Print the locks attached to this resource */
         seq_printf(s, "Granted Queue\n");
         list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue)
-                print_resource_lock(s, lkb, res);
+                print_format1_lock(s, lkb, res);
 
         seq_printf(s, "Conversion Queue\n");
         list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue)
-                print_resource_lock(s, lkb, res);
+                print_format1_lock(s, lkb, res);
 
         seq_printf(s, "Waiting Queue\n");
         list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue)
-                print_resource_lock(s, lkb, res);
+                print_format1_lock(s, lkb, res);
 
         if (list_empty(&res->res_lookup))
                 goto out;
@@ -160,23 +160,24 @@ static int print_resource(struct dlm_rsb *res, struct seq_file *s)
         return 0;
 }
 
-static void print_lock(struct seq_file *s, struct dlm_lkb *lkb, struct dlm_rsb *r)
+static void print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
+                               struct dlm_rsb *r)
 {
-        unsigned int waiting = 0;
-        uint64_t xid = 0;
+        u64 xid = 0;
+        u64 us;
 
         if (lkb->lkb_flags & DLM_IFL_USER) {
                 if (lkb->lkb_ua)
                         xid = lkb->lkb_ua->xid;
         }
 
-        if (lkb->lkb_timestamp)
-                waiting = jiffies_to_msecs(jiffies - lkb->lkb_timestamp);
+        /* microseconds since lkb was added to current queue */
+        us = ktime_to_us(ktime_sub(ktime_get(), lkb->lkb_timestamp));
 
-        /* id nodeid remid pid xid exflags flags sts grmode rqmode time_ms
+        /* id nodeid remid pid xid exflags flags sts grmode rqmode time_us
            r_nodeid r_len r_name */
 
-        seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %u %u %d \"%s\"\n",
+        seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n",
                    lkb->lkb_id,
                    lkb->lkb_nodeid,
                    lkb->lkb_remid,
@@ -187,26 +188,114 @@ static void print_lock(struct seq_file *s, struct dlm_lkb *lkb, struct dlm_rsb *
                    lkb->lkb_status,
                    lkb->lkb_grmode,
                    lkb->lkb_rqmode,
-                   waiting,
+                   (unsigned long long)us,
                    r->res_nodeid,
                    r->res_length,
                    r->res_name);
 }
 
-static int print_locks(struct dlm_rsb *r, struct seq_file *s)
+static int print_format2(struct dlm_rsb *r, struct seq_file *s)
 {
         struct dlm_lkb *lkb;
 
         lock_rsb(r);
 
         list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
-                print_lock(s, lkb, r);
+                print_format2_lock(s, lkb, r);
 
         list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
-                print_lock(s, lkb, r);
+                print_format2_lock(s, lkb, r);
 
         list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
-                print_lock(s, lkb, r);
+                print_format2_lock(s, lkb, r);
+
+        unlock_rsb(r);
+        return 0;
+}
+
+static void print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb,
+                               int rsb_lookup)
+{
+        u64 xid = 0;
+
+        if (lkb->lkb_flags & DLM_IFL_USER) {
+                if (lkb->lkb_ua)
+                        xid = lkb->lkb_ua->xid;
+        }
+
+        seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n",
+                   lkb->lkb_id,
+                   lkb->lkb_nodeid,
+                   lkb->lkb_remid,
+                   lkb->lkb_ownpid,
+                   (unsigned long long)xid,
+                   lkb->lkb_exflags,
+                   lkb->lkb_flags,
+                   lkb->lkb_status,
+                   lkb->lkb_grmode,
+                   lkb->lkb_rqmode,
+                   lkb->lkb_highbast,
+                   rsb_lookup,
+                   lkb->lkb_wait_type,
+                   lkb->lkb_lvbseq,
+                   (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
+                   (unsigned long long)ktime_to_ns(lkb->lkb_time_bast));
+}
+
+static int print_format3(struct dlm_rsb *r, struct seq_file *s)
+{
+        struct dlm_lkb *lkb;
+        int i, lvblen = r->res_ls->ls_lvblen;
+        int print_name = 1;
+
+        lock_rsb(r);
+
+        seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
+                   r,
+                   r->res_nodeid,
+                   r->res_first_lkid,
+                   r->res_flags,
+                   !list_empty(&r->res_root_list),
+                   !list_empty(&r->res_recover_list),
+                   r->res_recover_locks_count,
+                   r->res_length);
+
+        for (i = 0; i < r->res_length; i++) {
+                if (!isascii(r->res_name[i]) || !isprint(r->res_name[i]))
+                        print_name = 0;
+        }
+
+        seq_printf(s, "%s", print_name ? "str " : "hex");
+
+        for (i = 0; i < r->res_length; i++) {
+                if (print_name)
+                        seq_printf(s, "%c", r->res_name[i]);
+                else
+                        seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
+        }
+        seq_printf(s, "\n");
+
+        if (!r->res_lvbptr)
+                goto do_locks;
+
+        seq_printf(s, "lvb %u %d", r->res_lvbseq, lvblen);
+
+        for (i = 0; i < lvblen; i++)
+                seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
+        seq_printf(s, "\n");
+
+ do_locks:
+        list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
+                print_format3_lock(s, lkb, 0);
+
+        list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
+                print_format3_lock(s, lkb, 0);
+
+        list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
+                print_format3_lock(s, lkb, 0);
+
+        list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)
+                print_format3_lock(s, lkb, 1);
 
         unlock_rsb(r);
         return 0;
@@ -231,7 +320,7 @@ static int rsb_iter_next(struct rsb_iter *ri)
                                 break;
                         }
                         read_unlock(&ls->ls_rsbtbl[i].lock);
-                }
+                }
                 ri->entry = i;
 
                 if (ri->entry >= ls->ls_rsbtbl_size)
@@ -248,7 +337,7 @@ static int rsb_iter_next(struct rsb_iter *ri)
                         read_unlock(&ls->ls_rsbtbl[i].lock);
                         dlm_put_rsb(old);
                         goto top;
-                }
+                }
                 ri->rsb = list_entry(ri->next, struct dlm_rsb, res_hashchain);
                 dlm_hold_rsb(ri->rsb);
                 read_unlock(&ls->ls_rsbtbl[i].lock);
@@ -274,6 +363,7 @@ static struct rsb_iter *rsb_iter_init(struct dlm_ls *ls)
         ri->ls = ls;
         ri->entry = 0;
         ri->next = NULL;
+        ri->format = 1;
 
         if (rsb_iter_next(ri)) {
                 rsb_iter_free(ri);
@@ -325,16 +415,26 @@ static int rsb_seq_show(struct seq_file *file, void *iter_ptr)
 {
         struct rsb_iter *ri = iter_ptr;
 
-        if (ri->locks) {
+        switch (ri->format) {
+        case 1:
+                print_format1(ri->rsb, file);
+                break;
+        case 2:
                 if (ri->header) {
-                        seq_printf(file, "id nodeid remid pid xid exflags flags "
-                                         "sts grmode rqmode time_ms r_nodeid "
-                                         "r_len r_name\n");
+                        seq_printf(file, "id nodeid remid pid xid exflags "
+                                         "flags sts grmode rqmode time_ms "
+                                         "r_nodeid r_len r_name\n");
                         ri->header = 0;
                 }
-                print_locks(ri->rsb, file);
-        } else {
-                print_resource(ri->rsb, file);
+                print_format2(ri->rsb, file);
+                break;
+        case 3:
+                if (ri->header) {
+                        seq_printf(file, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
+                        ri->header = 0;
+                }
+                print_format3(ri->rsb, file);
+                break;
         }
 
         return 0;
@@ -385,7 +485,7 @@ static struct rsb_iter *locks_iter_init(struct dlm_ls *ls, loff_t *pos)
         ri->ls = ls;
         ri->entry = 0;
         ri->next = NULL;
-        ri->locks = 1;
+        ri->format = 2;
 
         if (*pos == 0)
                 ri->header = 1;
@@ -448,6 +548,84 @@ static const struct file_operations locks_fops = {
 };
 
 /*
+ * Dump all rsb/lvb/lkb state in compact listing, more complete than _locks
+ * This can replace both formats 1 and 2 eventually.
+ */
+
+static struct rsb_iter *all_iter_init(struct dlm_ls *ls, loff_t *pos)
+{
+        struct rsb_iter *ri;
+
+        ri = kzalloc(sizeof *ri, GFP_KERNEL);
+        if (!ri)
+                return NULL;
+
+        ri->ls = ls;
+        ri->entry = 0;
+        ri->next = NULL;
+        ri->format = 3;
+
+        if (*pos == 0)
+                ri->header = 1;
+
+        if (rsb_iter_next(ri)) {
+                rsb_iter_free(ri);
+                return NULL;
+        }
+
+        return ri;
+}
+
+static void *all_seq_start(struct seq_file *file, loff_t *pos)
+{
+        struct rsb_iter *ri;
+        loff_t n = *pos;
+
+        ri = all_iter_init(file->private, pos);
+        if (!ri)
+                return NULL;
+
+        while (n--) {
+                if (rsb_iter_next(ri)) {
+                        rsb_iter_free(ri);
+                        return NULL;
+                }
+        }
+
+        return ri;
+}
+
+static struct seq_operations all_seq_ops = {
+        .start = all_seq_start,
+        .next  = rsb_seq_next,
+        .stop  = rsb_seq_stop,
+        .show  = rsb_seq_show,
+};
+
+static int all_open(struct inode *inode, struct file *file)
+{
+        struct seq_file *seq;
+        int ret;
+
+        ret = seq_open(file, &all_seq_ops);
+        if (ret)
+                return ret;
+
+        seq = file->private_data;
+        seq->private = inode->i_private;
+
+        return 0;
+}
+
+static const struct file_operations all_fops = {
+        .owner   = THIS_MODULE,
+        .open    = all_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release
+};
+
+/*
  * dump lkb's on the ls_waiters list
  */
 
@@ -489,30 +667,33 @@ static const struct file_operations waiters_fops = {
         .read    = waiters_read
 };
 
+void dlm_delete_debug_file(struct dlm_ls *ls)
+{
+        if (ls->ls_debug_rsb_dentry)
+                debugfs_remove(ls->ls_debug_rsb_dentry);
+        if (ls->ls_debug_waiters_dentry)
+                debugfs_remove(ls->ls_debug_waiters_dentry);
+        if (ls->ls_debug_locks_dentry)
+                debugfs_remove(ls->ls_debug_locks_dentry);
+        if (ls->ls_debug_all_dentry)
+                debugfs_remove(ls->ls_debug_all_dentry);
+}
+
 int dlm_create_debug_file(struct dlm_ls *ls)
 {
         char name[DLM_LOCKSPACE_LEN+8];
 
+        /* format 1 */
+
         ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,
                                                       S_IFREG | S_IRUGO,
                                                       dlm_root,
                                                       ls,
                                                       &rsb_fops);
         if (!ls->ls_debug_rsb_dentry)
-                return -ENOMEM;
+                goto fail;
 
-        memset(name, 0, sizeof(name));
-        snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);
-
-        ls->ls_debug_waiters_dentry = debugfs_create_file(name,
-                                                          S_IFREG | S_IRUGO,
-                                                          dlm_root,
-                                                          ls,
-                                                          &waiters_fops);
-        if (!ls->ls_debug_waiters_dentry) {
-                debugfs_remove(ls->ls_debug_rsb_dentry);
-                return -ENOMEM;
-        }
+        /* format 2 */
 
         memset(name, 0, sizeof(name));
         snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);
@@ -522,23 +703,38 @@ int dlm_create_debug_file(struct dlm_ls *ls)
                                                         dlm_root,
                                                         ls,
                                                         &locks_fops);
-        if (!ls->ls_debug_locks_dentry) {
-                debugfs_remove(ls->ls_debug_waiters_dentry);
-                debugfs_remove(ls->ls_debug_rsb_dentry);
-                return -ENOMEM;
-        }
+        if (!ls->ls_debug_locks_dentry)
+                goto fail;
+
+        /* format 3 */
+
+        memset(name, 0, sizeof(name));
+        snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_all", ls->ls_name);
+
+        ls->ls_debug_all_dentry = debugfs_create_file(name,
+                                                      S_IFREG | S_IRUGO,
+                                                      dlm_root,
+                                                      ls,
+                                                      &all_fops);
+        if (!ls->ls_debug_all_dentry)
+                goto fail;
+
+        memset(name, 0, sizeof(name));
+        snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);
+
+        ls->ls_debug_waiters_dentry = debugfs_create_file(name,
+                                                          S_IFREG | S_IRUGO,
+                                                          dlm_root,
+                                                          ls,
+                                                          &waiters_fops);
+        if (!ls->ls_debug_waiters_dentry)
+                goto fail;
 
         return 0;
-}
 
-void dlm_delete_debug_file(struct dlm_ls *ls)
-{
-        if (ls->ls_debug_rsb_dentry)
-                debugfs_remove(ls->ls_debug_rsb_dentry);
-        if (ls->ls_debug_waiters_dentry)
-                debugfs_remove(ls->ls_debug_waiters_dentry);
-        if (ls->ls_debug_locks_dentry)
-                debugfs_remove(ls->ls_debug_locks_dentry);
+ fail:
+        dlm_delete_debug_file(ls);
+        return -ENOMEM;
 }
 
 int __init dlm_register_debugfs(void)
diff --git a/fs/dlm/dir.c b/fs/dlm/dir.c
index 85defeb64df4..92969f879a17 100644
--- a/fs/dlm/dir.c
+++ b/fs/dlm/dir.c
@@ -374,7 +374,7 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,
         struct list_head *list;
         struct dlm_rsb *r;
         int offset = 0, dir_nodeid;
-        uint16_t be_namelen;
+        __be16 be_namelen;
 
         down_read(&ls->ls_root_sem);
 
@@ -410,15 +410,15 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,
 
                 if (offset + sizeof(uint16_t)*2 + r->res_length > outlen) {
                         /* Write end-of-block record */
-                        be_namelen = 0;
-                        memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
-                        offset += sizeof(uint16_t);
+                        be_namelen = cpu_to_be16(0);
+                        memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+                        offset += sizeof(__be16);
                         goto out;
                 }
 
                 be_namelen = cpu_to_be16(r->res_length);
-                memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
-                offset += sizeof(uint16_t);
+                memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+                offset += sizeof(__be16);
                 memcpy(outbuf + offset, r->res_name, r->res_length);
                 offset += r->res_length;
         }
@@ -430,9 +430,9 @@ void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,
 
         if ((list == &ls->ls_root_list) &&
             (offset + sizeof(uint16_t) <= outlen)) {
-                be_namelen = 0xFFFF;
-                memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
-                offset += sizeof(uint16_t);
+                be_namelen = cpu_to_be16(0xFFFF);
+                memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
+                offset += sizeof(__be16);
         }
 
  out:
diff --git a/fs/dlm/dlm_internal.h b/fs/dlm/dlm_internal.h
index 868e4c9ef127..ef2f1e353966 100644
--- a/fs/dlm/dlm_internal.h
+++ b/fs/dlm/dlm_internal.h
@@ -245,7 +245,8 @@ struct dlm_lkb {
         struct list_head        lkb_astqueue;   /* need ast to be sent */
         struct list_head        lkb_ownqueue;   /* list of locks for a process */
         struct list_head        lkb_time_list;
-        unsigned long           lkb_timestamp;
+        ktime_t                 lkb_time_bast;  /* for debugging */
+        ktime_t                 lkb_timestamp;
         unsigned long           lkb_timeout_cs;
 
         char                    *lkb_lvbptr;
@@ -481,6 +482,7 @@ struct dlm_ls {
         struct dentry           *ls_debug_rsb_dentry; /* debugfs */
         struct dentry           *ls_debug_waiters_dentry; /* debugfs */
         struct dentry           *ls_debug_locks_dentry; /* debugfs */
+        struct dentry           *ls_debug_all_dentry; /* debugfs */
 
         wait_queue_head_t       ls_uevent_wait; /* user part of join/leave */
         int                     ls_uevent_result;
diff --git a/fs/dlm/lock.c b/fs/dlm/lock.c
index 724ddac91538..6cfe65bbf4a2 100644
--- a/fs/dlm/lock.c
+++ b/fs/dlm/lock.c
@@ -307,7 +307,7 @@ static void queue_cast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
         lkb->lkb_lksb->sb_status = rv;
         lkb->lkb_lksb->sb_flags = lkb->lkb_sbflags;
 
-        dlm_add_ast(lkb, AST_COMP);
+        dlm_add_ast(lkb, AST_COMP, 0);
 }
 
 static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
@@ -318,12 +318,12 @@ static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
 
 static void queue_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rqmode)
 {
+        lkb->lkb_time_bast = ktime_get();
+
         if (is_master_copy(lkb))
                 send_bast(r, lkb, rqmode);
-        else {
-                lkb->lkb_bastmode = rqmode;
-                dlm_add_ast(lkb, AST_BAST);
-        }
+        else
+                dlm_add_ast(lkb, AST_BAST, rqmode);
 }
 
 /*
@@ -744,6 +744,8 @@ static void add_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int status)
 
         DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
 
+        lkb->lkb_timestamp = ktime_get();
+
         lkb->lkb_status = status;
 
         switch (status) {
@@ -1013,10 +1015,8 @@ static void add_timeout(struct dlm_lkb *lkb)
 {
         struct dlm_ls *ls = lkb->lkb_resource->res_ls;
 
-        if (is_master_copy(lkb)) {
-                lkb->lkb_timestamp = jiffies;
+        if (is_master_copy(lkb))
                 return;
-        }
 
         if (test_bit(LSFL_TIMEWARN, &ls->ls_flags) &&
             !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
@@ -1031,7 +1031,6 @@ static void add_timeout(struct dlm_lkb *lkb)
         DLM_ASSERT(list_empty(&lkb->lkb_time_list), dlm_print_lkb(lkb););
         mutex_lock(&ls->ls_timeout_mutex);
         hold_lkb(lkb);
-        lkb->lkb_timestamp = jiffies;
         list_add_tail(&lkb->lkb_time_list, &ls->ls_timeout);
         mutex_unlock(&ls->ls_timeout_mutex);
 }
@@ -1059,6 +1058,7 @@ void dlm_scan_timeout(struct dlm_ls *ls)
         struct dlm_rsb *r;
         struct dlm_lkb *lkb;
         int do_cancel, do_warn;
+        s64 wait_us;
 
         for (;;) {
                 if (dlm_locking_stopped(ls))
@@ -1069,14 +1069,15 @@ void dlm_scan_timeout(struct dlm_ls *ls)
                 mutex_lock(&ls->ls_timeout_mutex);
                 list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list) {
 
+                        wait_us = ktime_to_us(ktime_sub(ktime_get(),
+                                                        lkb->lkb_timestamp));
+
                         if ((lkb->lkb_exflags & DLM_LKF_TIMEOUT) &&
-                            time_after_eq(jiffies, lkb->lkb_timestamp +
-                                          lkb->lkb_timeout_cs * HZ/100))
+                            wait_us >= (lkb->lkb_timeout_cs * 10000))
                                 do_cancel = 1;
 
                         if ((lkb->lkb_flags & DLM_IFL_WATCH_TIMEWARN) &&
-                            time_after_eq(jiffies, lkb->lkb_timestamp +
-                                           dlm_config.ci_timewarn_cs * HZ/100))
+                            wait_us >= dlm_config.ci_timewarn_cs * 10000)
                                 do_warn = 1;
 
                         if (!do_cancel && !do_warn)
@@ -1122,12 +1123,12 @@ void dlm_scan_timeout(struct dlm_ls *ls)
 void dlm_adjust_timeouts(struct dlm_ls *ls)
 {
         struct dlm_lkb *lkb;
-        long adj = jiffies - ls->ls_recover_begin;
+        u64 adj_us = jiffies_to_usecs(jiffies - ls->ls_recover_begin);
 
         ls->ls_recover_begin = 0;
         mutex_lock(&ls->ls_timeout_mutex);
         list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list)
-                lkb->lkb_timestamp += adj;
+                lkb->lkb_timestamp = ktime_add_us(lkb->lkb_timestamp, adj_us);
         mutex_unlock(&ls->ls_timeout_mutex);
 }
 
diff --git a/fs/dlm/lowcomms.c b/fs/dlm/lowcomms.c
index 3962262f991a..103a5ebd1371 100644
--- a/fs/dlm/lowcomms.c
+++ b/fs/dlm/lowcomms.c
@@ -295,6 +295,7 @@ static int add_sock(struct socket *sock, struct connection *con)
         con->sock->sk->sk_write_space = lowcomms_write_space;
         con->sock->sk->sk_state_change = lowcomms_state_change;
         con->sock->sk->sk_user_data = con;
+        con->sock->sk->sk_allocation = GFP_NOFS;
         return 0;
 }
 
@@ -823,7 +824,6 @@ static void sctp_init_assoc(struct connection *con)
         len = e->len;
         offset = e->offset;
         spin_unlock(&con->writequeue_lock);
-        kmap(e->page);
 
         /* Send the first block off the write queue */
         iov[0].iov_base = page_address(e->page)+offset;
@@ -854,7 +854,6 @@ static void sctp_init_assoc(struct connection *con)
 
                 if (e->len == 0 && e->users == 0) {
                         list_del(&e->list);
-                        kunmap(e->page);
                         free_entry(e);
                 }
                 spin_unlock(&con->writequeue_lock);
@@ -1203,8 +1202,6 @@ void *dlm_lowcomms_get_buffer(int nodeid, int len, gfp_t allocation, char **ppc)
 
         if (e) {
         got_one:
-                if (users == 0)
-                        kmap(e->page);
                 *ppc = page_address(e->page) + offset;
                 return e;
         }
@@ -1233,7 +1230,6 @@ void dlm_lowcomms_commit_buffer(void *mh)
         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)) {
@@ -1272,7 +1268,6 @@ static void send_to_sock(struct connection *con)
                 offset = e->offset;
                 BUG_ON(len == 0 && e->users == 0);
                 spin_unlock(&con->writequeue_lock);
-                kmap(e->page);
 
                 ret = 0;
                 if (len) {
@@ -1294,7 +1289,6 @@ static void send_to_sock(struct connection *con)
 
                 if (e->len == 0 && e->users == 0) {
                         list_del(&e->list);
-                        kunmap(e->page);
                         free_entry(e);
                         continue;
                 }
diff --git a/fs/dlm/memory.c b/fs/dlm/memory.c
index 54c14c6d06cb..c1775b84ebab 100644
--- a/fs/dlm/memory.c
+++ b/fs/dlm/memory.c
@@ -39,7 +39,7 @@ char *dlm_allocate_lvb(struct dlm_ls *ls)
 {
         char *p;
 
-        p = kzalloc(ls->ls_lvblen, GFP_KERNEL);
+        p = kzalloc(ls->ls_lvblen, ls->ls_allocation);
         return p;
 }
 
@@ -57,7 +57,7 @@ struct dlm_rsb *dlm_allocate_rsb(struct dlm_ls *ls, int namelen)
 
         DLM_ASSERT(namelen <= DLM_RESNAME_MAXLEN,);
 
-        r = kzalloc(sizeof(*r) + namelen, GFP_KERNEL);
+        r = kzalloc(sizeof(*r) + namelen, ls->ls_allocation);
         return r;
 }
 
@@ -72,7 +72,7 @@ struct dlm_lkb *dlm_allocate_lkb(struct dlm_ls *ls)
 {
         struct dlm_lkb *lkb;
 
-        lkb = kmem_cache_zalloc(lkb_cache, GFP_KERNEL);
+        lkb = kmem_cache_zalloc(lkb_cache, ls->ls_allocation);
         return lkb;
 }
 
diff --git a/fs/dlm/midcomms.c b/fs/dlm/midcomms.c
index 07ac709f3ed7..f3396c622aec 100644
--- a/fs/dlm/midcomms.c
+++ b/fs/dlm/midcomms.c
@@ -112,7 +112,7 @@ int dlm_process_incoming_buffer(int nodeid, const void *base,
                    ordinary messages). */
 
                 if (msglen > sizeof(__tmp) && p == &__tmp.p) {
-                        p = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL);
+                        p = kmalloc(dlm_config.ci_buffer_size, GFP_NOFS);
                         if (p == NULL)
                                 return ret;
                 }
diff --git a/fs/dlm/netlink.c b/fs/dlm/netlink.c
index aa2a5775a027..ccc9d62c462d 100644
--- a/fs/dlm/netlink.c
+++ b/fs/dlm/netlink.c
@@ -115,7 +115,6 @@ static void fill_data(struct dlm_lock_data *data, struct dlm_lkb *lkb)
         data->status = lkb->lkb_status;
         data->grmode = lkb->lkb_grmode;
         data->rqmode = lkb->lkb_rqmode;
-        data->timestamp = lkb->lkb_timestamp;
         if (lkb->lkb_ua)
                 data->xid = lkb->lkb_ua->xid;
         if (r) {
diff --git a/fs/dlm/user.c b/fs/dlm/user.c
index b3832c67194a..065149e84f42 100644
--- a/fs/dlm/user.c
+++ b/fs/dlm/user.c
@@ -175,7 +175,7 @@ static int lkb_is_endoflife(struct dlm_lkb *lkb, int sb_status, int type)
 /* we could possibly check if the cancel of an orphan has resulted in the lkb
    being removed and then remove that lkb from the orphans list and free it */
 
-void dlm_user_add_ast(struct dlm_lkb *lkb, int type)
+void dlm_user_add_ast(struct dlm_lkb *lkb, int type, int bastmode)
 {
         struct dlm_ls *ls;
         struct dlm_user_args *ua;
@@ -208,6 +208,8 @@ void dlm_user_add_ast(struct dlm_lkb *lkb, int type)
 
         ast_type = lkb->lkb_ast_type;
         lkb->lkb_ast_type |= type;
+        if (bastmode)
+                lkb->lkb_bastmode = bastmode;
 
         if (!ast_type) {
                 kref_get(&lkb->lkb_ref);
diff --git a/fs/dlm/user.h b/fs/dlm/user.h
index 35eb6a13d616..1c9686492286 100644
--- a/fs/dlm/user.h
+++ b/fs/dlm/user.h
@@ -9,7 +9,7 @@
 #ifndef __USER_DOT_H__
 #define __USER_DOT_H__
 
-void dlm_user_add_ast(struct dlm_lkb *lkb, int type);
+void dlm_user_add_ast(struct dlm_lkb *lkb, int type, int bastmode);
 int dlm_user_init(void);
 void dlm_user_exit(void);
 int dlm_device_deregister(struct dlm_ls *ls);