?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PCI: allow pci driver to support only dynids
[linux-2.6/mini2440.git] / fs / dlm / debug_fs.c
blob2f107d1a6a45937efe327eebf31b8cf0bc1c5aa5
1 /******************************************************************************
2 *******************************************************************************
3 **
4 ** Copyright (C) 2005-2008 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 format;
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_format1_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_format1(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_format1_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_format1_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_format1_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_format2_lock(struct seq_file *s, struct dlm_lkb *lkb,
164 struct dlm_rsb *r)
165 {
166 u64 xid = 0;
167 u64 us;
168
169 if (lkb->lkb_flags & DLM_IFL_USER) {
170 if (lkb->lkb_ua)
171 xid = lkb->lkb_ua->xid;
172 }
173
174 /* microseconds since lkb was added to current queue */
175 us = ktime_to_us(ktime_sub(ktime_get(), lkb->lkb_timestamp));
176
177 /* id nodeid remid pid xid exflags flags sts grmode rqmode time_us
178 r_nodeid r_len r_name */
179
180 seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n",
181 lkb->lkb_id,
182 lkb->lkb_nodeid,
183 lkb->lkb_remid,
184 lkb->lkb_ownpid,
185 (unsigned long long)xid,
186 lkb->lkb_exflags,
187 lkb->lkb_flags,
188 lkb->lkb_status,
189 lkb->lkb_grmode,
190 lkb->lkb_rqmode,
191 (unsigned long long)us,
192 r->res_nodeid,
193 r->res_length,
194 r->res_name);
195 }
196
197 static int print_format2(struct dlm_rsb *r, struct seq_file *s)
198 {
199 struct dlm_lkb *lkb;
200
201 lock_rsb(r);
202
203 list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
204 print_format2_lock(s, lkb, r);
205
206 list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
207 print_format2_lock(s, lkb, r);
208
209 list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
210 print_format2_lock(s, lkb, r);
211
212 unlock_rsb(r);
213 return 0;
214 }
215
216 static void print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb,
217 int rsb_lookup)
218 {
219 u64 xid = 0;
220
221 if (lkb->lkb_flags & DLM_IFL_USER) {
222 if (lkb->lkb_ua)
223 xid = lkb->lkb_ua->xid;
224 }
225
226 seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n",
227 lkb->lkb_id,
228 lkb->lkb_nodeid,
229 lkb->lkb_remid,
230 lkb->lkb_ownpid,
231 (unsigned long long)xid,
232 lkb->lkb_exflags,
233 lkb->lkb_flags,
234 lkb->lkb_status,
235 lkb->lkb_grmode,
236 lkb->lkb_rqmode,
237 lkb->lkb_highbast,
238 rsb_lookup,
239 lkb->lkb_wait_type,
240 lkb->lkb_lvbseq,
241 (unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
242 (unsigned long long)ktime_to_ns(lkb->lkb_time_bast));
243 }
244
245 static int print_format3(struct dlm_rsb *r, struct seq_file *s)
246 {
247 struct dlm_lkb *lkb;
248 int i, lvblen = r->res_ls->ls_lvblen;
249 int print_name = 1;
250
251 lock_rsb(r);
252
253 seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
254 r,
255 r->res_nodeid,
256 r->res_first_lkid,
257 r->res_flags,
258 !list_empty(&r->res_root_list),
259 !list_empty(&r->res_recover_list),
260 r->res_recover_locks_count,
261 r->res_length);
262
263 for (i = 0; i < r->res_length; i++) {
264 if (!isascii(r->res_name[i]) || !isprint(r->res_name[i]))
265 print_name = 0;
266 }
267
268 seq_printf(s, "%s", print_name ? "str " : "hex");
269
270 for (i = 0; i < r->res_length; i++) {
271 if (print_name)
272 seq_printf(s, "%c", r->res_name[i]);
273 else
274 seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
275 }
276 seq_printf(s, "\n");
277
278 if (!r->res_lvbptr)
279 goto do_locks;
280
281 seq_printf(s, "lvb %u %d", r->res_lvbseq, lvblen);
282
283 for (i = 0; i < lvblen; i++)
284 seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
285 seq_printf(s, "\n");
286
287 do_locks:
288 list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
289 print_format3_lock(s, lkb, 0);
290
291 list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
292 print_format3_lock(s, lkb, 0);
293
294 list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
295 print_format3_lock(s, lkb, 0);
296
297 list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)
298 print_format3_lock(s, lkb, 1);
299
300 unlock_rsb(r);
301 return 0;
302 }
303
304 static int rsb_iter_next(struct rsb_iter *ri)
305 {
306 struct dlm_ls *ls = ri->ls;
307 int i;
308
309 if (!ri->next) {
310 top:
311 /* Find the next non-empty hash bucket */
312 for (i = ri->entry; i < ls->ls_rsbtbl_size; i++) {
313 read_lock(&ls->ls_rsbtbl[i].lock);
314 if (!list_empty(&ls->ls_rsbtbl[i].list)) {
315 ri->next = ls->ls_rsbtbl[i].list.next;
316 ri->rsb = list_entry(ri->next, struct dlm_rsb,
317 res_hashchain);
318 dlm_hold_rsb(ri->rsb);
319 read_unlock(&ls->ls_rsbtbl[i].lock);
320 break;
321 }
322 read_unlock(&ls->ls_rsbtbl[i].lock);
323 }
324 ri->entry = i;
325
326 if (ri->entry >= ls->ls_rsbtbl_size)
327 return 1;
328 } else {
329 struct dlm_rsb *old = ri->rsb;
330 i = ri->entry;
331 read_lock(&ls->ls_rsbtbl[i].lock);
332 ri->next = ri->next->next;
333 if (ri->next->next == ls->ls_rsbtbl[i].list.next) {
334 /* End of list - move to next bucket */
335 ri->next = NULL;
336 ri->entry++;
337 read_unlock(&ls->ls_rsbtbl[i].lock);
338 dlm_put_rsb(old);
339 goto top;
340 }
341 ri->rsb = list_entry(ri->next, struct dlm_rsb, res_hashchain);
342 dlm_hold_rsb(ri->rsb);
343 read_unlock(&ls->ls_rsbtbl[i].lock);
344 dlm_put_rsb(old);
345 }
346
347 return 0;
348 }
349
350 static void rsb_iter_free(struct rsb_iter *ri)
351 {
352 kfree(ri);
353 }
354
355 static struct rsb_iter *rsb_iter_init(struct dlm_ls *ls)
356 {
357 struct rsb_iter *ri;
358
359 ri = kzalloc(sizeof *ri, GFP_KERNEL);
360 if (!ri)
361 return NULL;
362
363 ri->ls = ls;
364 ri->entry = 0;
365 ri->next = NULL;
366 ri->format = 1;
367
368 if (rsb_iter_next(ri)) {
369 rsb_iter_free(ri);
370 return NULL;
371 }
372
373 return ri;
374 }
375
376 static void *rsb_seq_start(struct seq_file *file, loff_t *pos)
377 {
378 struct rsb_iter *ri;
379 loff_t n = *pos;
380
381 ri = rsb_iter_init(file->private);
382 if (!ri)
383 return NULL;
384
385 while (n--) {
386 if (rsb_iter_next(ri)) {
387 rsb_iter_free(ri);
388 return NULL;
389 }
390 }
391
392 return ri;
393 }
394
395 static void *rsb_seq_next(struct seq_file *file, void *iter_ptr, loff_t *pos)
396 {
397 struct rsb_iter *ri = iter_ptr;
398
399 (*pos)++;
400
401 if (rsb_iter_next(ri)) {
402 rsb_iter_free(ri);
403 return NULL;
404 }
405
406 return ri;
407 }
408
409 static void rsb_seq_stop(struct seq_file *file, void *iter_ptr)
410 {
411 /* nothing for now */
412 }
413
414 static int rsb_seq_show(struct seq_file *file, void *iter_ptr)
415 {
416 struct rsb_iter *ri = iter_ptr;
417
418 switch (ri->format) {
419 case 1:
420 print_format1(ri->rsb, file);
421 break;
422 case 2:
423 if (ri->header) {
424 seq_printf(file, "id nodeid remid pid xid exflags "
425 "flags sts grmode rqmode time_ms "
426 "r_nodeid r_len r_name\n");
427 ri->header = 0;
428 }
429 print_format2(ri->rsb, file);
430 break;
431 case 3:
432 if (ri->header) {
433 seq_printf(file, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
434 ri->header = 0;
435 }
436 print_format3(ri->rsb, file);
437 break;
438 }
439
440 return 0;
441 }
442
443 static struct seq_operations rsb_seq_ops = {
444 .start = rsb_seq_start,
445 .next = rsb_seq_next,
446 .stop = rsb_seq_stop,
447 .show = rsb_seq_show,
448 };
449
450 static int rsb_open(struct inode *inode, struct file *file)
451 {
452 struct seq_file *seq;
453 int ret;
454
455 ret = seq_open(file, &rsb_seq_ops);
456 if (ret)
457 return ret;
458
459 seq = file->private_data;
460 seq->private = inode->i_private;
461
462 return 0;
463 }
464
465 static const struct file_operations rsb_fops = {
466 .owner = THIS_MODULE,
467 .open = rsb_open,
468 .read = seq_read,
469 .llseek = seq_lseek,
470 .release = seq_release
471 };
472
473 /*
474 * Dump state in compact per-lock listing
475 */
476
477 static struct rsb_iter *locks_iter_init(struct dlm_ls *ls, loff_t *pos)
478 {
479 struct rsb_iter *ri;
480
481 ri = kzalloc(sizeof *ri, GFP_KERNEL);
482 if (!ri)
483 return NULL;
484
485 ri->ls = ls;
486 ri->entry = 0;
487 ri->next = NULL;
488 ri->format = 2;
489
490 if (*pos == 0)
491 ri->header = 1;
492
493 if (rsb_iter_next(ri)) {
494 rsb_iter_free(ri);
495 return NULL;
496 }
497
498 return ri;
499 }
500
501 static void *locks_seq_start(struct seq_file *file, loff_t *pos)
502 {
503 struct rsb_iter *ri;
504 loff_t n = *pos;
505
506 ri = locks_iter_init(file->private, pos);
507 if (!ri)
508 return NULL;
509
510 while (n--) {
511 if (rsb_iter_next(ri)) {
512 rsb_iter_free(ri);
513 return NULL;
514 }
515 }
516
517 return ri;
518 }
519
520 static struct seq_operations locks_seq_ops = {
521 .start = locks_seq_start,
522 .next = rsb_seq_next,
523 .stop = rsb_seq_stop,
524 .show = rsb_seq_show,
525 };
526
527 static int locks_open(struct inode *inode, struct file *file)
528 {
529 struct seq_file *seq;
530 int ret;
531
532 ret = seq_open(file, &locks_seq_ops);
533 if (ret)
534 return ret;
535
536 seq = file->private_data;
537 seq->private = inode->i_private;
538
539 return 0;
540 }
541
542 static const struct file_operations locks_fops = {
543 .owner = THIS_MODULE,
544 .open = locks_open,
545 .read = seq_read,
546 .llseek = seq_lseek,
547 .release = seq_release
548 };
549
550 /*
551 * Dump all rsb/lvb/lkb state in compact listing, more complete than _locks
552 * This can replace both formats 1 and 2 eventually.
553 */
554
555 static struct rsb_iter *all_iter_init(struct dlm_ls *ls, loff_t *pos)
556 {
557 struct rsb_iter *ri;
558
559 ri = kzalloc(sizeof *ri, GFP_KERNEL);
560 if (!ri)
561 return NULL;
562
563 ri->ls = ls;
564 ri->entry = 0;
565 ri->next = NULL;
566 ri->format = 3;
567
568 if (*pos == 0)
569 ri->header = 1;
570
571 if (rsb_iter_next(ri)) {
572 rsb_iter_free(ri);
573 return NULL;
574 }
575
576 return ri;
577 }
578
579 static void *all_seq_start(struct seq_file *file, loff_t *pos)
580 {
581 struct rsb_iter *ri;
582 loff_t n = *pos;
583
584 ri = all_iter_init(file->private, pos);
585 if (!ri)
586 return NULL;
587
588 while (n--) {
589 if (rsb_iter_next(ri)) {
590 rsb_iter_free(ri);
591 return NULL;
592 }
593 }
594
595 return ri;
596 }
597
598 static struct seq_operations all_seq_ops = {
599 .start = all_seq_start,
600 .next = rsb_seq_next,
601 .stop = rsb_seq_stop,
602 .show = rsb_seq_show,
603 };
604
605 static int all_open(struct inode *inode, struct file *file)
606 {
607 struct seq_file *seq;
608 int ret;
609
610 ret = seq_open(file, &all_seq_ops);
611 if (ret)
612 return ret;
613
614 seq = file->private_data;
615 seq->private = inode->i_private;
616
617 return 0;
618 }
619
620 static const struct file_operations all_fops = {
621 .owner = THIS_MODULE,
622 .open = all_open,
623 .read = seq_read,
624 .llseek = seq_lseek,
625 .release = seq_release
626 };
627
628 /*
629 * dump lkb's on the ls_waiters list
630 */
631
632 static int waiters_open(struct inode *inode, struct file *file)
633 {
634 file->private_data = inode->i_private;
635 return 0;
636 }
637
638 static ssize_t waiters_read(struct file *file, char __user *userbuf,
639 size_t count, loff_t *ppos)
640 {
641 struct dlm_ls *ls = file->private_data;
642 struct dlm_lkb *lkb;
643 size_t len = DLM_DEBUG_BUF_LEN, pos = 0, ret, rv;
644
645 mutex_lock(&debug_buf_lock);
646 mutex_lock(&ls->ls_waiters_mutex);
647 memset(debug_buf, 0, sizeof(debug_buf));
648
649 list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
650 ret = snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n",
651 lkb->lkb_id, lkb->lkb_wait_type,
652 lkb->lkb_nodeid, lkb->lkb_resource->res_name);
653 if (ret >= len - pos)
654 break;
655 pos += ret;
656 }
657 mutex_unlock(&ls->ls_waiters_mutex);
658
659 rv = simple_read_from_buffer(userbuf, count, ppos, debug_buf, pos);
660 mutex_unlock(&debug_buf_lock);
661 return rv;
662 }
663
664 static const struct file_operations waiters_fops = {
665 .owner = THIS_MODULE,
666 .open = waiters_open,
667 .read = waiters_read
668 };
669
670 void dlm_delete_debug_file(struct dlm_ls *ls)
671 {
672 if (ls->ls_debug_rsb_dentry)
673 debugfs_remove(ls->ls_debug_rsb_dentry);
674 if (ls->ls_debug_waiters_dentry)
675 debugfs_remove(ls->ls_debug_waiters_dentry);
676 if (ls->ls_debug_locks_dentry)
677 debugfs_remove(ls->ls_debug_locks_dentry);
678 if (ls->ls_debug_all_dentry)
679 debugfs_remove(ls->ls_debug_all_dentry);
680 }
681
682 int dlm_create_debug_file(struct dlm_ls *ls)
683 {
684 char name[DLM_LOCKSPACE_LEN+8];
685
686 /* format 1 */
687
688 ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,
689 S_IFREG | S_IRUGO,
690 dlm_root,
691 ls,
692 &rsb_fops);
693 if (!ls->ls_debug_rsb_dentry)
694 goto fail;
695
696 /* format 2 */
697
698 memset(name, 0, sizeof(name));
699 snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);
700
701 ls->ls_debug_locks_dentry = debugfs_create_file(name,
702 S_IFREG | S_IRUGO,
703 dlm_root,
704 ls,
705 &locks_fops);
706 if (!ls->ls_debug_locks_dentry)
707 goto fail;
708
709 /* format 3 */
710
711 memset(name, 0, sizeof(name));
712 snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_all", ls->ls_name);
713
714 ls->ls_debug_all_dentry = debugfs_create_file(name,
715 S_IFREG | S_IRUGO,
716 dlm_root,
717 ls,
718 &all_fops);
719 if (!ls->ls_debug_all_dentry)
720 goto fail;
721
722 memset(name, 0, sizeof(name));
723 snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);
724
725 ls->ls_debug_waiters_dentry = debugfs_create_file(name,
726 S_IFREG | S_IRUGO,
727 dlm_root,
728 ls,
729 &waiters_fops);
730 if (!ls->ls_debug_waiters_dentry)
731 goto fail;
732
733 return 0;
734
735 fail:
736 dlm_delete_debug_file(ls);
737 return -ENOMEM;
738 }
739
740 int __init dlm_register_debugfs(void)
741 {
742 mutex_init(&debug_buf_lock);
743 dlm_root = debugfs_create_dir("dlm", NULL);
744 return dlm_root ? 0 : -ENOMEM;
745 }
746
747 void dlm_unregister_debugfs(void)
748 {
749 debugfs_remove(dlm_root);
750 }
751
Support for the Chinese Samsung S3C2440 based development boards