projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
task IO accounting: improve code readability
[deliverable/linux.git] / 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 unsigned int waiting = 0;
166 uint64_t xid = 0;
167
168 if (lkb->lkb_flags & DLM_IFL_USER) {
169 if (lkb->lkb_ua)
170 xid = lkb->lkb_ua->xid;
171 }
172
173 if (lkb->lkb_timestamp)
174 waiting = jiffies_to_msecs(jiffies - lkb->lkb_timestamp);
175
176 /* id nodeid remid pid xid exflags flags sts grmode rqmode time_ms
177 r_nodeid r_len r_name */
178
179 seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %u %u %d \"%s\"\n",
180 lkb->lkb_id,
181 lkb->lkb_nodeid,
182 lkb->lkb_remid,
183 lkb->lkb_ownpid,
184 (unsigned long long)xid,
185 lkb->lkb_exflags,
186 lkb->lkb_flags,
187 lkb->lkb_status,
188 lkb->lkb_grmode,
189 lkb->lkb_rqmode,
190 waiting,
191 r->res_nodeid,
192 r->res_length,
193 r->res_name);
194 }
195
196 static int print_locks(struct dlm_rsb *r, struct seq_file *s)
197 {
198 struct dlm_lkb *lkb;
199
200 lock_rsb(r);
201
202 list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
203 print_lock(s, lkb, r);
204
205 list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
206 print_lock(s, lkb, r);
207
208 list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
209 print_lock(s, lkb, r);
210
211 unlock_rsb(r);
212 return 0;
213 }
214
215 static int rsb_iter_next(struct rsb_iter *ri)
216 {
217 struct dlm_ls *ls = ri->ls;
218 int i;
219
220 if (!ri->next) {
221 top:
222 /* Find the next non-empty hash bucket */
223 for (i = ri->entry; i < ls->ls_rsbtbl_size; i++) {
224 read_lock(&ls->ls_rsbtbl[i].lock);
225 if (!list_empty(&ls->ls_rsbtbl[i].list)) {
226 ri->next = ls->ls_rsbtbl[i].list.next;
227 ri->rsb = list_entry(ri->next, struct dlm_rsb,
228 res_hashchain);
229 dlm_hold_rsb(ri->rsb);
230 read_unlock(&ls->ls_rsbtbl[i].lock);
231 break;
232 }
233 read_unlock(&ls->ls_rsbtbl[i].lock);
234 }
235 ri->entry = i;
236
237 if (ri->entry >= ls->ls_rsbtbl_size)
238 return 1;
239 } else {
240 struct dlm_rsb *old = ri->rsb;
241 i = ri->entry;
242 read_lock(&ls->ls_rsbtbl[i].lock);
243 ri->next = ri->next->next;
244 if (ri->next->next == ls->ls_rsbtbl[i].list.next) {
245 /* End of list - move to next bucket */
246 ri->next = NULL;
247 ri->entry++;
248 read_unlock(&ls->ls_rsbtbl[i].lock);
249 dlm_put_rsb(old);
250 goto top;
251 }
252 ri->rsb = list_entry(ri->next, struct dlm_rsb, res_hashchain);
253 dlm_hold_rsb(ri->rsb);
254 read_unlock(&ls->ls_rsbtbl[i].lock);
255 dlm_put_rsb(old);
256 }
257
258 return 0;
259 }
260
261 static void rsb_iter_free(struct rsb_iter *ri)
262 {
263 kfree(ri);
264 }
265
266 static struct rsb_iter *rsb_iter_init(struct dlm_ls *ls)
267 {
268 struct rsb_iter *ri;
269
270 ri = kzalloc(sizeof *ri, GFP_KERNEL);
271 if (!ri)
272 return NULL;
273
274 ri->ls = ls;
275 ri->entry = 0;
276 ri->next = NULL;
277
278 if (rsb_iter_next(ri)) {
279 rsb_iter_free(ri);
280 return NULL;
281 }
282
283 return ri;
284 }
285
286 static void *rsb_seq_start(struct seq_file *file, loff_t *pos)
287 {
288 struct rsb_iter *ri;
289 loff_t n = *pos;
290
291 ri = rsb_iter_init(file->private);
292 if (!ri)
293 return NULL;
294
295 while (n--) {
296 if (rsb_iter_next(ri)) {
297 rsb_iter_free(ri);
298 return NULL;
299 }
300 }
301
302 return ri;
303 }
304
305 static void *rsb_seq_next(struct seq_file *file, void *iter_ptr, loff_t *pos)
306 {
307 struct rsb_iter *ri = iter_ptr;
308
309 (*pos)++;
310
311 if (rsb_iter_next(ri)) {
312 rsb_iter_free(ri);
313 return NULL;
314 }
315
316 return ri;
317 }
318
319 static void rsb_seq_stop(struct seq_file *file, void *iter_ptr)
320 {
321 /* nothing for now */
322 }
323
324 static int rsb_seq_show(struct seq_file *file, void *iter_ptr)
325 {
326 struct rsb_iter *ri = iter_ptr;
327
328 if (ri->locks) {
329 if (ri->header) {
330 seq_printf(file, "id nodeid remid pid xid exflags flags "
331 "sts grmode rqmode time_ms r_nodeid "
332 "r_len r_name\n");
333 ri->header = 0;
334 }
335 print_locks(ri->rsb, file);
336 } else {
337 print_resource(ri->rsb, file);
338 }
339
340 return 0;
341 }
342
343 static struct seq_operations rsb_seq_ops = {
344 .start = rsb_seq_start,
345 .next = rsb_seq_next,
346 .stop = rsb_seq_stop,
347 .show = rsb_seq_show,
348 };
349
350 static int rsb_open(struct inode *inode, struct file *file)
351 {
352 struct seq_file *seq;
353 int ret;
354
355 ret = seq_open(file, &rsb_seq_ops);
356 if (ret)
357 return ret;
358
359 seq = file->private_data;
360 seq->private = inode->i_private;
361
362 return 0;
363 }
364
365 static const struct file_operations rsb_fops = {
366 .owner = THIS_MODULE,
367 .open = rsb_open,
368 .read = seq_read,
369 .llseek = seq_lseek,
370 .release = seq_release
371 };
372
373 /*
374 * Dump state in compact per-lock listing
375 */
376
377 static struct rsb_iter *locks_iter_init(struct dlm_ls *ls, loff_t *pos)
378 {
379 struct rsb_iter *ri;
380
381 ri = kzalloc(sizeof *ri, GFP_KERNEL);
382 if (!ri)
383 return NULL;
384
385 ri->ls = ls;
386 ri->entry = 0;
387 ri->next = NULL;
388 ri->locks = 1;
389
390 if (*pos == 0)
391 ri->header = 1;
392
393 if (rsb_iter_next(ri)) {
394 rsb_iter_free(ri);
395 return NULL;
396 }
397
398 return ri;
399 }
400
401 static void *locks_seq_start(struct seq_file *file, loff_t *pos)
402 {
403 struct rsb_iter *ri;
404 loff_t n = *pos;
405
406 ri = locks_iter_init(file->private, pos);
407 if (!ri)
408 return NULL;
409
410 while (n--) {
411 if (rsb_iter_next(ri)) {
412 rsb_iter_free(ri);
413 return NULL;
414 }
415 }
416
417 return ri;
418 }
419
420 static struct seq_operations locks_seq_ops = {
421 .start = locks_seq_start,
422 .next = rsb_seq_next,
423 .stop = rsb_seq_stop,
424 .show = rsb_seq_show,
425 };
426
427 static int locks_open(struct inode *inode, struct file *file)
428 {
429 struct seq_file *seq;
430 int ret;
431
432 ret = seq_open(file, &locks_seq_ops);
433 if (ret)
434 return ret;
435
436 seq = file->private_data;
437 seq->private = inode->i_private;
438
439 return 0;
440 }
441
442 static const struct file_operations locks_fops = {
443 .owner = THIS_MODULE,
444 .open = locks_open,
445 .read = seq_read,
446 .llseek = seq_lseek,
447 .release = seq_release
448 };
449
450 /*
451 * dump lkb's on the ls_waiters list
452 */
453
454 static int waiters_open(struct inode *inode, struct file *file)
455 {
456 file->private_data = inode->i_private;
457 return 0;
458 }
459
460 static ssize_t waiters_read(struct file *file, char __user *userbuf,
461 size_t count, loff_t *ppos)
462 {
463 struct dlm_ls *ls = file->private_data;
464 struct dlm_lkb *lkb;
465 size_t len = DLM_DEBUG_BUF_LEN, pos = 0, ret, rv;
466
467 mutex_lock(&debug_buf_lock);
468 mutex_lock(&ls->ls_waiters_mutex);
469 memset(debug_buf, 0, sizeof(debug_buf));
470
471 list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
472 ret = snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n",
473 lkb->lkb_id, lkb->lkb_wait_type,
474 lkb->lkb_nodeid, lkb->lkb_resource->res_name);
475 if (ret >= len - pos)
476 break;
477 pos += ret;
478 }
479 mutex_unlock(&ls->ls_waiters_mutex);
480
481 rv = simple_read_from_buffer(userbuf, count, ppos, debug_buf, pos);
482 mutex_unlock(&debug_buf_lock);
483 return rv;
484 }
485
486 static const struct file_operations waiters_fops = {
487 .owner = THIS_MODULE,
488 .open = waiters_open,
489 .read = waiters_read
490 };
491
492 int dlm_create_debug_file(struct dlm_ls *ls)
493 {
494 char name[DLM_LOCKSPACE_LEN+8];
495
496 ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,
497 S_IFREG | S_IRUGO,
498 dlm_root,
499 ls,
500 &rsb_fops);
501 if (!ls->ls_debug_rsb_dentry)
502 return -ENOMEM;
503
504 memset(name, 0, sizeof(name));
505 snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);
506
507 ls->ls_debug_waiters_dentry = debugfs_create_file(name,
508 S_IFREG | S_IRUGO,
509 dlm_root,
510 ls,
511 &waiters_fops);
512 if (!ls->ls_debug_waiters_dentry) {
513 debugfs_remove(ls->ls_debug_rsb_dentry);
514 return -ENOMEM;
515 }
516
517 memset(name, 0, sizeof(name));
518 snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);
519
520 ls->ls_debug_locks_dentry = debugfs_create_file(name,
521 S_IFREG | S_IRUGO,
522 dlm_root,
523 ls,
524 &locks_fops);
525 if (!ls->ls_debug_locks_dentry) {
526 debugfs_remove(ls->ls_debug_waiters_dentry);
527 debugfs_remove(ls->ls_debug_rsb_dentry);
528 return -ENOMEM;
529 }
530
531 return 0;
532 }
533
534 void dlm_delete_debug_file(struct dlm_ls *ls)
535 {
536 if (ls->ls_debug_rsb_dentry)
537 debugfs_remove(ls->ls_debug_rsb_dentry);
538 if (ls->ls_debug_waiters_dentry)
539 debugfs_remove(ls->ls_debug_waiters_dentry);
540 if (ls->ls_debug_locks_dentry)
541 debugfs_remove(ls->ls_debug_locks_dentry);
542 }
543
544 int __init dlm_register_debugfs(void)
545 {
546 mutex_init(&debug_buf_lock);
547 dlm_root = debugfs_create_dir("dlm", NULL);
548 return dlm_root ? 0 : -ENOMEM;
549 }
550
551 void dlm_unregister_debugfs(void)
552 {
553 debugfs_remove(dlm_root);
554 }
555
Linux kernel - Deliverables
This page took 0.05618 seconds and 5 git commands to generate.