URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [dlm/] [debug_fs.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/******************************************************************************
*******************************************************************************
**
**  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/pagemap.h>
#include <linux/seq_file.h>
#include <linux/module.h>
#include <linux/ctype.h>
#include <linux/debugfs.h>
 
#include "dlm_internal.h"
#include "lock.h"
 
#define DLM_DEBUG_BUF_LEN 4096
static char debug_buf[DLM_DEBUG_BUF_LEN];
static struct mutex debug_buf_lock;
 
static struct dentry *dlm_root;
 
struct rsb_iter {
        int entry;
        int locks;
        int header;
        struct dlm_ls *ls;
        struct list_head *next;
        struct dlm_rsb *rsb;
};
 
/*
 * dump all rsb's in the lockspace hash table
 */
 
static char *print_lockmode(int mode)
{
        switch (mode) {
        case DLM_LOCK_IV:
                return "--";
        case DLM_LOCK_NL:
                return "NL";
        case DLM_LOCK_CR:
                return "CR";
        case DLM_LOCK_CW:
                return "CW";
        case DLM_LOCK_PR:
                return "PR";
        case DLM_LOCK_PW:
                return "PW";
        case DLM_LOCK_EX:
                return "EX";
        default:
                return "??";
        }
}
 
static void print_resource_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));
 
        if (lkb->lkb_status == DLM_LKSTS_CONVERT
            || lkb->lkb_status == DLM_LKSTS_WAITING)
                seq_printf(s, " (%s)", print_lockmode(lkb->lkb_rqmode));
 
        if (lkb->lkb_nodeid) {
                if (lkb->lkb_nodeid != res->res_nodeid)
                        seq_printf(s, " Remote: %3d %08x", lkb->lkb_nodeid,
                                   lkb->lkb_remid);
                else
                        seq_printf(s, " Master:     %08x", lkb->lkb_remid);
        }
 
        if (lkb->lkb_wait_type)
                seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
 
        seq_printf(s, "\n");
}
 
static int print_resource(struct dlm_rsb *res, struct seq_file *s)
{
        struct dlm_lkb *lkb;
        int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
 
        lock_rsb(res);
 
        seq_printf(s, "\nResource %p Name (len=%d) \"", res, res->res_length);
        for (i = 0; i < res->res_length; i++) {
                if (isprint(res->res_name[i]))
                        seq_printf(s, "%c", res->res_name[i]);
                else
                        seq_printf(s, "%c", '.');
        }
        if (res->res_nodeid > 0)
                seq_printf(s, "\"  \nLocal Copy, Master is node %d\n",
                           res->res_nodeid);
        else if (res->res_nodeid == 0)
                seq_printf(s, "\"  \nMaster Copy\n");
        else if (res->res_nodeid == -1)
                seq_printf(s, "\"  \nLooking up master (lkid %x)\n",
                           res->res_first_lkid);
        else
                seq_printf(s, "\"  \nInvalid master %d\n", res->res_nodeid);
 
        /* Print the LVB: */
        if (res->res_lvbptr) {
                seq_printf(s, "LVB: ");
                for (i = 0; i < lvblen; i++) {
                        if (i == lvblen / 2)
                                seq_printf(s, "\n     ");
                        seq_printf(s, "%02x ",
                                   (unsigned char) res->res_lvbptr[i]);
                }
                if (rsb_flag(res, RSB_VALNOTVALID))
                        seq_printf(s, " (INVALID)");
                seq_printf(s, "\n");
        }
 
        root_list = !list_empty(&res->res_root_list);
        recover_list = !list_empty(&res->res_recover_list);
 
        if (root_list || recover_list) {
                seq_printf(s, "Recovery: root %d recover %d flags %lx "
                           "count %d\n", root_list, recover_list,
                           res->res_flags, res->res_recover_locks_count);
        }
 
        /* 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);
 
        seq_printf(s, "Conversion Queue\n");
        list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue)
                print_resource_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);
 
        if (list_empty(&res->res_lookup))
                goto out;
 
        seq_printf(s, "Lookup Queue\n");
        list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {
                seq_printf(s, "%08x %s", lkb->lkb_id,
                           print_lockmode(lkb->lkb_rqmode));
                if (lkb->lkb_wait_type)
                        seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);
                seq_printf(s, "\n");
        }
 out:
        unlock_rsb(res);
        return 0;
}
 
static void print_lock(struct seq_file *s, struct dlm_lkb *lkb, struct dlm_rsb *r)
{
        struct dlm_user_args *ua;
        unsigned int waiting = 0;
        uint64_t xid = 0;
 
        if (lkb->lkb_flags & DLM_IFL_USER) {
                ua = (struct dlm_user_args *) lkb->lkb_astparam;
                if (ua)
                        xid = ua->xid;
        }
 
        if (lkb->lkb_timestamp)
                waiting = jiffies_to_msecs(jiffies - lkb->lkb_timestamp);
 
        /* id nodeid remid pid xid exflags flags sts grmode rqmode time_ms
           r_nodeid r_len r_name */
 
        seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %u %u %d \"%s\"\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,
                   waiting,
                   r->res_nodeid,
                   r->res_length,
                   r->res_name);
}
 
static int print_locks(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);
 
        list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
                print_lock(s, lkb, r);
 
        list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
                print_lock(s, lkb, r);
 
        unlock_rsb(r);
        return 0;
}
 
static int rsb_iter_next(struct rsb_iter *ri)
{
        struct dlm_ls *ls = ri->ls;
        int i;
 
        if (!ri->next) {
 top:
                /* Find the next non-empty hash bucket */
                for (i = ri->entry; i < ls->ls_rsbtbl_size; i++) {
                        read_lock(&ls->ls_rsbtbl[i].lock);
                        if (!list_empty(&ls->ls_rsbtbl[i].list)) {
                                ri->next = ls->ls_rsbtbl[i].list.next;
                                ri->rsb = list_entry(ri->next, struct dlm_rsb,
                                                        res_hashchain);
                                dlm_hold_rsb(ri->rsb);
                                read_unlock(&ls->ls_rsbtbl[i].lock);
                                break;
                        }
                        read_unlock(&ls->ls_rsbtbl[i].lock);
                }
                ri->entry = i;
 
                if (ri->entry >= ls->ls_rsbtbl_size)
                        return 1;
        } else {
                struct dlm_rsb *old = ri->rsb;
                i = ri->entry;
                read_lock(&ls->ls_rsbtbl[i].lock);
                ri->next = ri->next->next;
                if (ri->next->next == ls->ls_rsbtbl[i].list.next) {
                        /* End of list - move to next bucket */
                        ri->next = NULL;
                        ri->entry++;
                        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);
                dlm_put_rsb(old);
        }
 
        return 0;
}
 
static void rsb_iter_free(struct rsb_iter *ri)
{
        kfree(ri);
}
 
static struct rsb_iter *rsb_iter_init(struct dlm_ls *ls)
{
        struct rsb_iter *ri;
 
        ri = kzalloc(sizeof *ri, GFP_KERNEL);
        if (!ri)
                return NULL;
 
        ri->ls = ls;
        ri->entry = 0;
        ri->next = NULL;
 
        if (rsb_iter_next(ri)) {
                rsb_iter_free(ri);
                return NULL;
        }
 
        return ri;
}
 
static void *rsb_seq_start(struct seq_file *file, loff_t *pos)
{
        struct rsb_iter *ri;
        loff_t n = *pos;
 
        ri = rsb_iter_init(file->private);
        if (!ri)
                return NULL;
 
        while (n--) {
                if (rsb_iter_next(ri)) {
                        rsb_iter_free(ri);
                        return NULL;
                }
        }
 
        return ri;
}
 
static void *rsb_seq_next(struct seq_file *file, void *iter_ptr, loff_t *pos)
{
        struct rsb_iter *ri = iter_ptr;
 
        (*pos)++;
 
        if (rsb_iter_next(ri)) {
                rsb_iter_free(ri);
                return NULL;
        }
 
        return ri;
}
 
static void rsb_seq_stop(struct seq_file *file, void *iter_ptr)
{
        /* nothing for now */
}
 
static int rsb_seq_show(struct seq_file *file, void *iter_ptr)
{
        struct rsb_iter *ri = iter_ptr;
 
        if (ri->locks) {
                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");
                        ri->header = 0;
                }
                print_locks(ri->rsb, file);
        } else {
                print_resource(ri->rsb, file);
        }
 
        return 0;
}
 
static struct seq_operations rsb_seq_ops = {
        .start = rsb_seq_start,
        .next  = rsb_seq_next,
        .stop  = rsb_seq_stop,
        .show  = rsb_seq_show,
};
 
static int rsb_open(struct inode *inode, struct file *file)
{
        struct seq_file *seq;
        int ret;
 
        ret = seq_open(file, &rsb_seq_ops);
        if (ret)
                return ret;
 
        seq = file->private_data;
        seq->private = inode->i_private;
 
        return 0;
}
 
static const struct file_operations rsb_fops = {
        .owner   = THIS_MODULE,
        .open    = rsb_open,
        .read    = seq_read,
        .llseek  = seq_lseek,
        .release = seq_release
};
 
/*
 * Dump state in compact per-lock listing
 */
 
static struct rsb_iter *locks_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->locks = 1;
 
        if (*pos == 0)
                ri->header = 1;
 
        if (rsb_iter_next(ri)) {
                rsb_iter_free(ri);
                return NULL;
        }
 
        return ri;
}
 
static void *locks_seq_start(struct seq_file *file, loff_t *pos)
{
        struct rsb_iter *ri;
        loff_t n = *pos;
 
        ri = locks_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 locks_seq_ops = {
        .start = locks_seq_start,
        .next  = rsb_seq_next,
        .stop  = rsb_seq_stop,
        .show  = rsb_seq_show,
};
 
static int locks_open(struct inode *inode, struct file *file)
{
        struct seq_file *seq;
        int ret;
 
        ret = seq_open(file, &locks_seq_ops);
        if (ret)
                return ret;
 
        seq = file->private_data;
        seq->private = inode->i_private;
 
        return 0;
}
 
static const struct file_operations locks_fops = {
        .owner   = THIS_MODULE,
        .open    = locks_open,
        .read    = seq_read,
        .llseek  = seq_lseek,
        .release = seq_release
};
 
/*
 * dump lkb's on the ls_waiters list
 */
 
static int waiters_open(struct inode *inode, struct file *file)
{
        file->private_data = inode->i_private;
        return 0;
}
 
static ssize_t waiters_read(struct file *file, char __user *userbuf,
                            size_t count, loff_t *ppos)
{
        struct dlm_ls *ls = file->private_data;
        struct dlm_lkb *lkb;
        size_t len = DLM_DEBUG_BUF_LEN, pos = 0, ret, rv;
 
        mutex_lock(&debug_buf_lock);
        mutex_lock(&ls->ls_waiters_mutex);
        memset(debug_buf, 0, sizeof(debug_buf));
 
        list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
                ret = snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n",
                               lkb->lkb_id, lkb->lkb_wait_type,
                               lkb->lkb_nodeid, lkb->lkb_resource->res_name);
                if (ret >= len - pos)
                        break;
                pos += ret;
        }
        mutex_unlock(&ls->ls_waiters_mutex);
 
        rv = simple_read_from_buffer(userbuf, count, ppos, debug_buf, pos);
        mutex_unlock(&debug_buf_lock);
        return rv;
}
 
static const struct file_operations waiters_fops = {
        .owner   = THIS_MODULE,
        .open    = waiters_open,
        .read    = waiters_read
};
 
int dlm_create_debug_file(struct dlm_ls *ls)
{
        char name[DLM_LOCKSPACE_LEN+8];
 
        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;
 
        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;
        }
 
        memset(name, 0, sizeof(name));
        snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);
 
        ls->ls_debug_locks_dentry = debugfs_create_file(name,
                                                        S_IFREG | S_IRUGO,
                                                        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;
        }
 
        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);
}
 
int dlm_register_debugfs(void)
{
        mutex_init(&debug_buf_lock);
        dlm_root = debugfs_create_dir("dlm", NULL);
        return dlm_root ? 0 : -ENOMEM;
}
 
void dlm_unregister_debugfs(void)
{
        debugfs_remove(dlm_root);
}
 

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [dlm/] [debug_fs.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/******************************************************************************`
2			`*******************************************************************************`
3			`**`
4			`** Copyright (C) 2005 Red Hat, Inc. All rights reserved.`
5			`**`
6			`** This copyrighted material is made available to anyone wishing to use,`
7			`** modify, copy, or redistribute it subject to the terms and conditions`
8			`** of the GNU General Public License v.2.`
9			`**`
10			`*******************************************************************************`
11			`******************************************************************************/`
12
13			`#include <linux/pagemap.h>`
14			`#include <linux/seq_file.h>`
15			`#include <linux/module.h>`
16			`#include <linux/ctype.h>`
17			`#include <linux/debugfs.h>`
18
19			`#include "dlm_internal.h"`
20			`#include "lock.h"`
21
22			`#define DLM_DEBUG_BUF_LEN 4096`
23			`static char debug_buf[DLM_DEBUG_BUF_LEN];`
24			`static struct mutex debug_buf_lock;`
25
26			`static struct dentry *dlm_root;`
27
28			`struct rsb_iter {`
29			`int entry;`
30			`int locks;`
31			`int header;`
32			`struct dlm_ls *ls;`
33			`struct list_head *next;`
34			`struct dlm_rsb *rsb;`
35			`};`
36
37			`/*`
38			`* dump all rsb's in the lockspace hash table`
39			`*/`
40
41			`static char *print_lockmode(int mode)`
42			`{`
43			`switch (mode) {`
44			`case DLM_LOCK_IV:`
45			`return "--";`
46			`case DLM_LOCK_NL:`
47			`return "NL";`
48			`case DLM_LOCK_CR:`
49			`return "CR";`
50			`case DLM_LOCK_CW:`
51			`return "CW";`
52			`case DLM_LOCK_PR:`
53			`return "PR";`
54			`case DLM_LOCK_PW:`
55			`return "PW";`
56			`case DLM_LOCK_EX:`
57			`return "EX";`
58			`default:`
59			`return "??";`
60			`}`
61			`}`
62
63			`static void print_resource_lock(struct seq_file s, struct dlm_lkb lkb,`
64			`struct dlm_rsb *res)`
65			`{`
66			`seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));`
67
68			`if (lkb->lkb_status == DLM_LKSTS_CONVERT`
69			`\|\| lkb->lkb_status == DLM_LKSTS_WAITING)`
70			`seq_printf(s, " (%s)", print_lockmode(lkb->lkb_rqmode));`
71
72			`if (lkb->lkb_nodeid) {`
73			`if (lkb->lkb_nodeid != res->res_nodeid)`
74			`seq_printf(s, " Remote: %3d %08x", lkb->lkb_nodeid,`
75			`lkb->lkb_remid);`
76			`else`
77			`seq_printf(s, " Master: %08x", lkb->lkb_remid);`
78			`}`
79
80			`if (lkb->lkb_wait_type)`
81			`seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);`
82
83			`seq_printf(s, "\n");`
84			`}`
85
86			`static int print_resource(struct dlm_rsb res, struct seq_file s)`
87			`{`
88			`struct dlm_lkb *lkb;`
89			`int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;`
90
91			`lock_rsb(res);`
92
93			`seq_printf(s, "\nResource %p Name (len=%d) \"", res, res->res_length);`
94			`for (i = 0; i < res->res_length; i++) {`
95			`if (isprint(res->res_name[i]))`
96			`seq_printf(s, "%c", res->res_name[i]);`
97			`else`
98			`seq_printf(s, "%c", '.');`
99			`}`
100			`if (res->res_nodeid > 0)`
101			`seq_printf(s, "\" \nLocal Copy, Master is node %d\n",`
102			`res->res_nodeid);`
103			`else if (res->res_nodeid == 0)`
104			`seq_printf(s, "\" \nMaster Copy\n");`
105			`else if (res->res_nodeid == -1)`
106			`seq_printf(s, "\" \nLooking up master (lkid %x)\n",`
107			`res->res_first_lkid);`
108			`else`
109			`seq_printf(s, "\" \nInvalid master %d\n", res->res_nodeid);`
110
111			`/* Print the LVB: */`
112			`if (res->res_lvbptr) {`
113			`seq_printf(s, "LVB: ");`
114			`for (i = 0; i < lvblen; i++) {`
115			`if (i == lvblen / 2)`
116			`seq_printf(s, "\n ");`
117			`seq_printf(s, "%02x ",`
118			`(unsigned char) res->res_lvbptr[i]);`
119			`}`
120			`if (rsb_flag(res, RSB_VALNOTVALID))`
121			`seq_printf(s, " (INVALID)");`
122			`seq_printf(s, "\n");`
123			`}`
124
125			`root_list = !list_empty(&res->res_root_list);`
126			`recover_list = !list_empty(&res->res_recover_list);`
127
128			`if (root_list \|\| recover_list) {`
129			`seq_printf(s, "Recovery: root %d recover %d flags %lx "`
130			`"count %d\n", root_list, recover_list,`
131			`res->res_flags, res->res_recover_locks_count);`
132			`}`
133
134			`/* Print the locks attached to this resource */`
135			`seq_printf(s, "Granted Queue\n");`
136			`list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue)`
137			`print_resource_lock(s, lkb, res);`
138
139			`seq_printf(s, "Conversion Queue\n");`
140			`list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue)`
141			`print_resource_lock(s, lkb, res);`
142
143			`seq_printf(s, "Waiting Queue\n");`
144			`list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue)`
145			`print_resource_lock(s, lkb, res);`
146
147			`if (list_empty(&res->res_lookup))`
148			`goto out;`
149
150			`seq_printf(s, "Lookup Queue\n");`
151			`list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) {`
152			`seq_printf(s, "%08x %s", lkb->lkb_id,`
153			`print_lockmode(lkb->lkb_rqmode));`
154			`if (lkb->lkb_wait_type)`
155			`seq_printf(s, " wait_type: %d", lkb->lkb_wait_type);`
156			`seq_printf(s, "\n");`
157			`}`
158			`out:`
159			`unlock_rsb(res);`
160			`return 0;`
161			`}`
162
163			`static void print_lock(struct seq_file s, struct dlm_lkb lkb, struct dlm_rsb *r)`
164			`{`
165			`struct dlm_user_args *ua;`
166			`unsigned int waiting = 0;`
167			`uint64_t xid = 0;`
168
169			`if (lkb->lkb_flags & DLM_IFL_USER) {`
170			`ua = (struct dlm_user_args *) lkb->lkb_astparam;`
171			`if (ua)`
172			`xid = ua->xid;`
173			`}`
174
175			`if (lkb->lkb_timestamp)`
176			`waiting = jiffies_to_msecs(jiffies - lkb->lkb_timestamp);`
177
178			`/* id nodeid remid pid xid exflags flags sts grmode rqmode time_ms`
179			`r_nodeid r_len r_name */`
180
181			`seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %u %u %d \"%s\"\n",`
182			`lkb->lkb_id,`
183			`lkb->lkb_nodeid,`
184			`lkb->lkb_remid,`
185			`lkb->lkb_ownpid,`
186			`(unsigned long long)xid,`
187			`lkb->lkb_exflags,`
188			`lkb->lkb_flags,`
189			`lkb->lkb_status,`
190			`lkb->lkb_grmode,`
191			`lkb->lkb_rqmode,`
192			`waiting,`
193			`r->res_nodeid,`
194			`r->res_length,`
195			`r->res_name);`
196			`}`
197
198			`static int print_locks(struct dlm_rsb r, struct seq_file s)`
199			`{`
200			`struct dlm_lkb *lkb;`
201
202			`lock_rsb(r);`
203
204			`list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)`
205			`print_lock(s, lkb, r);`
206
207			`list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)`
208			`print_lock(s, lkb, r);`
209
210			`list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)`
211			`print_lock(s, lkb, r);`
212
213			`unlock_rsb(r);`
214			`return 0;`
215			`}`
216
217			`static int rsb_iter_next(struct rsb_iter *ri)`
218			`{`
219			`struct dlm_ls *ls = ri->ls;`
220			`int i;`
221
222			`if (!ri->next) {`
223			`top:`
224			`/* Find the next non-empty hash bucket */`
225			`for (i = ri->entry; i < ls->ls_rsbtbl_size; i++) {`
226			`read_lock(&ls->ls_rsbtbl[i].lock);`
227			`if (!list_empty(&ls->ls_rsbtbl[i].list)) {`
228			`ri->next = ls->ls_rsbtbl[i].list.next;`
229			`ri->rsb = list_entry(ri->next, struct dlm_rsb,`
230			`res_hashchain);`
231			`dlm_hold_rsb(ri->rsb);`
232			`read_unlock(&ls->ls_rsbtbl[i].lock);`
233			`break;`
234			`}`
235			`read_unlock(&ls->ls_rsbtbl[i].lock);`
236			`}`
237			`ri->entry = i;`
238
239			`if (ri->entry >= ls->ls_rsbtbl_size)`
240			`return 1;`
241			`} else {`
242			`struct dlm_rsb *old = ri->rsb;`
243			`i = ri->entry;`
244			`read_lock(&ls->ls_rsbtbl[i].lock);`
245			`ri->next = ri->next->next;`
246			`if (ri->next->next == ls->ls_rsbtbl[i].list.next) {`
247			`/* End of list - move to next bucket */`
248			`ri->next = NULL;`
249			`ri->entry++;`
250			`read_unlock(&ls->ls_rsbtbl[i].lock);`
251			`dlm_put_rsb(old);`
252			`goto top;`
253			`}`
254			`ri->rsb = list_entry(ri->next, struct dlm_rsb, res_hashchain);`
255			`dlm_hold_rsb(ri->rsb);`
256			`read_unlock(&ls->ls_rsbtbl[i].lock);`
257			`dlm_put_rsb(old);`
258			`}`
259
260			`return 0;`
261			`}`
262
263			`static void rsb_iter_free(struct rsb_iter *ri)`
264			`{`
265			`kfree(ri);`
266			`}`
267
268			`static struct rsb_iter rsb_iter_init(struct dlm_ls ls)`
269			`{`
270			`struct rsb_iter *ri;`
271
272			`ri = kzalloc(sizeof *ri, GFP_KERNEL);`
273			`if (!ri)`
274			`return NULL;`
275
276			`ri->ls = ls;`
277			`ri->entry = 0;`
278			`ri->next = NULL;`
279
280			`if (rsb_iter_next(ri)) {`
281			`rsb_iter_free(ri);`
282			`return NULL;`
283			`}`
284
285			`return ri;`
286			`}`
287
288			`static void rsb_seq_start(struct seq_file file, loff_t *pos)`
289			`{`
290			`struct rsb_iter *ri;`
291			`loff_t n = *pos;`
292
293			`ri = rsb_iter_init(file->private);`
294			`if (!ri)`
295			`return NULL;`
296
297			`while (n--) {`
298			`if (rsb_iter_next(ri)) {`
299			`rsb_iter_free(ri);`
300			`return NULL;`
301			`}`
302			`}`
303
304			`return ri;`
305			`}`
306
307			`static void rsb_seq_next(struct seq_file file, void iter_ptr, loff_t pos)`
308			`{`
309			`struct rsb_iter *ri = iter_ptr;`
310
311			`(*pos)++;`
312
313			`if (rsb_iter_next(ri)) {`
314			`rsb_iter_free(ri);`
315			`return NULL;`
316			`}`
317
318			`return ri;`
319			`}`
320
321			`static void rsb_seq_stop(struct seq_file file, void iter_ptr)`
322			`{`
323			`/* nothing for now */`
324			`}`
325
326			`static int rsb_seq_show(struct seq_file file, void iter_ptr)`
327			`{`
328			`struct rsb_iter *ri = iter_ptr;`
329
330			`if (ri->locks) {`
331			`if (ri->header) {`
332			`seq_printf(file, "id nodeid remid pid xid exflags flags "`
333			`"sts grmode rqmode time_ms r_nodeid "`
334			`"r_len r_name\n");`
335			`ri->header = 0;`
336			`}`
337			`print_locks(ri->rsb, file);`
338			`} else {`
339			`print_resource(ri->rsb, file);`
340			`}`
341
342			`return 0;`
343			`}`
344
345			`static struct seq_operations rsb_seq_ops = {`
346			`.start = rsb_seq_start,`
347			`.next = rsb_seq_next,`
348			`.stop = rsb_seq_stop,`
349			`.show = rsb_seq_show,`
350			`};`
351
352			`static int rsb_open(struct inode inode, struct file file)`
353			`{`
354			`struct seq_file *seq;`
355			`int ret;`
356
357			`ret = seq_open(file, &rsb_seq_ops);`
358			`if (ret)`
359			`return ret;`
360
361			`seq = file->private_data;`
362			`seq->private = inode->i_private;`
363
364			`return 0;`
365			`}`
366
367			`static const struct file_operations rsb_fops = {`
368			`.owner = THIS_MODULE,`
369			`.open = rsb_open,`
370			`.read = seq_read,`
371			`.llseek = seq_lseek,`
372			`.release = seq_release`
373			`};`
374
375			`/*`
376			`* Dump state in compact per-lock listing`
377			`*/`
378
379			`static struct rsb_iter locks_iter_init(struct dlm_ls ls, loff_t *pos)`
380			`{`
381			`struct rsb_iter *ri;`
382
383			`ri = kzalloc(sizeof *ri, GFP_KERNEL);`
384			`if (!ri)`
385			`return NULL;`
386
387			`ri->ls = ls;`
388			`ri->entry = 0;`
389			`ri->next = NULL;`
390			`ri->locks = 1;`
391
392			`if (*pos == 0)`
393			`ri->header = 1;`
394
395			`if (rsb_iter_next(ri)) {`
396			`rsb_iter_free(ri);`
397			`return NULL;`
398			`}`
399
400			`return ri;`
401			`}`
402
403			`static void locks_seq_start(struct seq_file file, loff_t *pos)`
404			`{`
405			`struct rsb_iter *ri;`
406			`loff_t n = *pos;`
407
408			`ri = locks_iter_init(file->private, pos);`
409			`if (!ri)`
410			`return NULL;`
411
412			`while (n--) {`
413			`if (rsb_iter_next(ri)) {`
414			`rsb_iter_free(ri);`
415			`return NULL;`
416			`}`
417			`}`
418
419			`return ri;`
420			`}`
421
422			`static struct seq_operations locks_seq_ops = {`
423			`.start = locks_seq_start,`
424			`.next = rsb_seq_next,`
425			`.stop = rsb_seq_stop,`
426			`.show = rsb_seq_show,`
427			`};`
428
429			`static int locks_open(struct inode inode, struct file file)`
430			`{`
431			`struct seq_file *seq;`
432			`int ret;`
433
434			`ret = seq_open(file, &locks_seq_ops);`
435			`if (ret)`
436			`return ret;`
437
438			`seq = file->private_data;`
439			`seq->private = inode->i_private;`
440
441			`return 0;`
442			`}`
443
444			`static const struct file_operations locks_fops = {`
445			`.owner = THIS_MODULE,`
446			`.open = locks_open,`
447			`.read = seq_read,`
448			`.llseek = seq_lseek,`
449			`.release = seq_release`
450			`};`
451
452			`/*`
453			`* dump lkb's on the ls_waiters list`
454			`*/`
455
456			`static int waiters_open(struct inode inode, struct file file)`
457			`{`
458			`file->private_data = inode->i_private;`
459			`return 0;`
460			`}`
461
462			`static ssize_t waiters_read(struct file file, char __user userbuf,`
463			`size_t count, loff_t *ppos)`
464			`{`
465			`struct dlm_ls *ls = file->private_data;`
466			`struct dlm_lkb *lkb;`
467			`size_t len = DLM_DEBUG_BUF_LEN, pos = 0, ret, rv;`
468
469			`mutex_lock(&debug_buf_lock);`
470			`mutex_lock(&ls->ls_waiters_mutex);`
471			`memset(debug_buf, 0, sizeof(debug_buf));`
472
473			`list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {`
474			`ret = snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n",`
475			`lkb->lkb_id, lkb->lkb_wait_type,`
476			`lkb->lkb_nodeid, lkb->lkb_resource->res_name);`
477			`if (ret >= len - pos)`
478			`break;`
479			`pos += ret;`
480			`}`
481			`mutex_unlock(&ls->ls_waiters_mutex);`
482
483			`rv = simple_read_from_buffer(userbuf, count, ppos, debug_buf, pos);`
484			`mutex_unlock(&debug_buf_lock);`
485			`return rv;`
486			`}`
487
488			`static const struct file_operations waiters_fops = {`
489			`.owner = THIS_MODULE,`
490			`.open = waiters_open,`
491			`.read = waiters_read`
492			`};`
493
494			`int dlm_create_debug_file(struct dlm_ls *ls)`
495			`{`
496			`char name[DLM_LOCKSPACE_LEN+8];`
497
498			`ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,`
499			`S_IFREG \| S_IRUGO,`
500			`dlm_root,`
501			`ls,`
502			`&rsb_fops);`
503			`if (!ls->ls_debug_rsb_dentry)`
504			`return -ENOMEM;`
505
506			`memset(name, 0, sizeof(name));`
507			`snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);`
508
509			`ls->ls_debug_waiters_dentry = debugfs_create_file(name,`
510			`S_IFREG \| S_IRUGO,`
511			`dlm_root,`
512			`ls,`
513			`&waiters_fops);`
514			`if (!ls->ls_debug_waiters_dentry) {`
515			`debugfs_remove(ls->ls_debug_rsb_dentry);`
516			`return -ENOMEM;`
517			`}`
518
519			`memset(name, 0, sizeof(name));`
520			`snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);`
521
522			`ls->ls_debug_locks_dentry = debugfs_create_file(name,`
523			`S_IFREG \| S_IRUGO,`
524			`dlm_root,`
525			`ls,`
526			`&locks_fops);`
527			`if (!ls->ls_debug_locks_dentry) {`
528			`debugfs_remove(ls->ls_debug_waiters_dentry);`
529			`debugfs_remove(ls->ls_debug_rsb_dentry);`
530			`return -ENOMEM;`
531			`}`
532
533			`return 0;`
534			`}`
535
536			`void dlm_delete_debug_file(struct dlm_ls *ls)`
537			`{`
538			`if (ls->ls_debug_rsb_dentry)`
539			`debugfs_remove(ls->ls_debug_rsb_dentry);`
540			`if (ls->ls_debug_waiters_dentry)`
541			`debugfs_remove(ls->ls_debug_waiters_dentry);`
542			`if (ls->ls_debug_locks_dentry)`
543			`debugfs_remove(ls->ls_debug_locks_dentry);`
544			`}`
545
546			`int dlm_register_debugfs(void)`
547			`{`
548			`mutex_init(&debug_buf_lock);`
549			`dlm_root = debugfs_create_dir("dlm", NULL);`
550			`return dlm_root ? 0 : -ENOMEM;`
551			`}`
552
553			`void dlm_unregister_debugfs(void)`
554			`{`
555			`debugfs_remove(dlm_root);`
556			`}`
557