SLUB slab validation: Move tracking information alloc outside of lock
[linux-2.6] / fs / dlm / debug_fs.c
1 /******************************************************************************
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