]>
Commit | Line | Data |
---|---|---|
e7fd4179 DT |
1 | /****************************************************************************** |
2 | ******************************************************************************* | |
3 | ** | |
892c4467 | 4 | ** Copyright (C) 2005-2009 Red Hat, Inc. All rights reserved. |
e7fd4179 DT |
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" | |
916297aa | 20 | #include "lock.h" |
e7fd4179 | 21 | |
5de6319b DT |
22 | #define DLM_DEBUG_BUF_LEN 4096 |
23 | static char debug_buf[DLM_DEBUG_BUF_LEN]; | |
24 | static struct mutex debug_buf_lock; | |
e7fd4179 DT |
25 | |
26 | static struct dentry *dlm_root; | |
27 | ||
e7fd4179 DT |
28 | static char *print_lockmode(int mode) |
29 | { | |
30 | switch (mode) { | |
31 | case DLM_LOCK_IV: | |
32 | return "--"; | |
33 | case DLM_LOCK_NL: | |
34 | return "NL"; | |
35 | case DLM_LOCK_CR: | |
36 | return "CR"; | |
37 | case DLM_LOCK_CW: | |
38 | return "CW"; | |
39 | case DLM_LOCK_PR: | |
40 | return "PR"; | |
41 | case DLM_LOCK_PW: | |
42 | return "PW"; | |
43 | case DLM_LOCK_EX: | |
44 | return "EX"; | |
45 | default: | |
46 | return "??"; | |
47 | } | |
48 | } | |
49 | ||
892c4467 DT |
50 | static int print_format1_lock(struct seq_file *s, struct dlm_lkb *lkb, |
51 | struct dlm_rsb *res) | |
e7fd4179 DT |
52 | { |
53 | seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode)); | |
54 | ||
892c4467 DT |
55 | if (lkb->lkb_status == DLM_LKSTS_CONVERT || |
56 | lkb->lkb_status == DLM_LKSTS_WAITING) | |
e7fd4179 DT |
57 | seq_printf(s, " (%s)", print_lockmode(lkb->lkb_rqmode)); |
58 | ||
e7fd4179 DT |
59 | if (lkb->lkb_nodeid) { |
60 | if (lkb->lkb_nodeid != res->res_nodeid) | |
61 | seq_printf(s, " Remote: %3d %08x", lkb->lkb_nodeid, | |
62 | lkb->lkb_remid); | |
63 | else | |
64 | seq_printf(s, " Master: %08x", lkb->lkb_remid); | |
65 | } | |
66 | ||
67 | if (lkb->lkb_wait_type) | |
68 | seq_printf(s, " wait_type: %d", lkb->lkb_wait_type); | |
69 | ||
892c4467 | 70 | return seq_printf(s, "\n"); |
e7fd4179 DT |
71 | } |
72 | ||
d022509d | 73 | static int print_format1(struct dlm_rsb *res, struct seq_file *s) |
e7fd4179 DT |
74 | { |
75 | struct dlm_lkb *lkb; | |
5de6319b | 76 | int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list; |
892c4467 | 77 | int rv; |
e7fd4179 | 78 | |
9dd592d7 DT |
79 | lock_rsb(res); |
80 | ||
892c4467 DT |
81 | rv = seq_printf(s, "\nResource %p Name (len=%d) \"", |
82 | res, res->res_length); | |
83 | if (rv) | |
84 | goto out; | |
85 | ||
e7fd4179 DT |
86 | for (i = 0; i < res->res_length; i++) { |
87 | if (isprint(res->res_name[i])) | |
88 | seq_printf(s, "%c", res->res_name[i]); | |
89 | else | |
90 | seq_printf(s, "%c", '.'); | |
91 | } | |
892c4467 | 92 | |
e7fd4179 | 93 | if (res->res_nodeid > 0) |
892c4467 DT |
94 | rv = seq_printf(s, "\" \nLocal Copy, Master is node %d\n", |
95 | res->res_nodeid); | |
e7fd4179 | 96 | else if (res->res_nodeid == 0) |
892c4467 | 97 | rv = seq_printf(s, "\" \nMaster Copy\n"); |
e7fd4179 | 98 | else if (res->res_nodeid == -1) |
892c4467 DT |
99 | rv = seq_printf(s, "\" \nLooking up master (lkid %x)\n", |
100 | res->res_first_lkid); | |
e7fd4179 | 101 | else |
892c4467 DT |
102 | rv = seq_printf(s, "\" \nInvalid master %d\n", |
103 | res->res_nodeid); | |
104 | if (rv) | |
105 | goto out; | |
e7fd4179 DT |
106 | |
107 | /* Print the LVB: */ | |
108 | if (res->res_lvbptr) { | |
109 | seq_printf(s, "LVB: "); | |
110 | for (i = 0; i < lvblen; i++) { | |
111 | if (i == lvblen / 2) | |
112 | seq_printf(s, "\n "); | |
113 | seq_printf(s, "%02x ", | |
114 | (unsigned char) res->res_lvbptr[i]); | |
115 | } | |
116 | if (rsb_flag(res, RSB_VALNOTVALID)) | |
117 | seq_printf(s, " (INVALID)"); | |
892c4467 DT |
118 | rv = seq_printf(s, "\n"); |
119 | if (rv) | |
120 | goto out; | |
e7fd4179 DT |
121 | } |
122 | ||
5de6319b DT |
123 | root_list = !list_empty(&res->res_root_list); |
124 | recover_list = !list_empty(&res->res_recover_list); | |
125 | ||
126 | if (root_list || recover_list) { | |
892c4467 DT |
127 | rv = seq_printf(s, "Recovery: root %d recover %d flags %lx " |
128 | "count %d\n", root_list, recover_list, | |
129 | res->res_flags, res->res_recover_locks_count); | |
130 | if (rv) | |
131 | goto out; | |
5de6319b DT |
132 | } |
133 | ||
e7fd4179 DT |
134 | /* Print the locks attached to this resource */ |
135 | seq_printf(s, "Granted Queue\n"); | |
892c4467 DT |
136 | list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue) { |
137 | rv = print_format1_lock(s, lkb, res); | |
138 | if (rv) | |
139 | goto out; | |
140 | } | |
e7fd4179 DT |
141 | |
142 | seq_printf(s, "Conversion Queue\n"); | |
892c4467 DT |
143 | list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue) { |
144 | rv = print_format1_lock(s, lkb, res); | |
145 | if (rv) | |
146 | goto out; | |
147 | } | |
e7fd4179 DT |
148 | |
149 | seq_printf(s, "Waiting Queue\n"); | |
892c4467 DT |
150 | list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue) { |
151 | rv = print_format1_lock(s, lkb, res); | |
152 | if (rv) | |
153 | goto out; | |
154 | } | |
e7fd4179 | 155 | |
5de6319b DT |
156 | if (list_empty(&res->res_lookup)) |
157 | goto out; | |
158 | ||
159 | seq_printf(s, "Lookup Queue\n"); | |
160 | list_for_each_entry(lkb, &res->res_lookup, lkb_rsb_lookup) { | |
892c4467 DT |
161 | rv = seq_printf(s, "%08x %s", lkb->lkb_id, |
162 | print_lockmode(lkb->lkb_rqmode)); | |
5de6319b DT |
163 | if (lkb->lkb_wait_type) |
164 | seq_printf(s, " wait_type: %d", lkb->lkb_wait_type); | |
892c4467 | 165 | rv = seq_printf(s, "\n"); |
5de6319b DT |
166 | } |
167 | out: | |
9dd592d7 | 168 | unlock_rsb(res); |
892c4467 | 169 | return rv; |
9dd592d7 DT |
170 | } |
171 | ||
892c4467 DT |
172 | static int print_format2_lock(struct seq_file *s, struct dlm_lkb *lkb, |
173 | struct dlm_rsb *r) | |
9dd592d7 | 174 | { |
eeda418d DT |
175 | u64 xid = 0; |
176 | u64 us; | |
892c4467 | 177 | int rv; |
9dd592d7 DT |
178 | |
179 | if (lkb->lkb_flags & DLM_IFL_USER) { | |
d292c0cc DT |
180 | if (lkb->lkb_ua) |
181 | xid = lkb->lkb_ua->xid; | |
9dd592d7 DT |
182 | } |
183 | ||
eeda418d DT |
184 | /* microseconds since lkb was added to current queue */ |
185 | us = ktime_to_us(ktime_sub(ktime_get(), lkb->lkb_timestamp)); | |
9dd592d7 | 186 | |
eeda418d | 187 | /* id nodeid remid pid xid exflags flags sts grmode rqmode time_us |
ac90a255 | 188 | r_nodeid r_len r_name */ |
9dd592d7 | 189 | |
892c4467 DT |
190 | rv = seq_printf(s, "%x %d %x %u %llu %x %x %d %d %d %llu %u %d \"%s\"\n", |
191 | lkb->lkb_id, | |
192 | lkb->lkb_nodeid, | |
193 | lkb->lkb_remid, | |
194 | lkb->lkb_ownpid, | |
195 | (unsigned long long)xid, | |
196 | lkb->lkb_exflags, | |
197 | lkb->lkb_flags, | |
198 | lkb->lkb_status, | |
199 | lkb->lkb_grmode, | |
200 | lkb->lkb_rqmode, | |
201 | (unsigned long long)us, | |
202 | r->res_nodeid, | |
203 | r->res_length, | |
204 | r->res_name); | |
205 | return rv; | |
9dd592d7 DT |
206 | } |
207 | ||
d022509d | 208 | static int print_format2(struct dlm_rsb *r, struct seq_file *s) |
9dd592d7 DT |
209 | { |
210 | struct dlm_lkb *lkb; | |
892c4467 | 211 | int rv = 0; |
9dd592d7 DT |
212 | |
213 | lock_rsb(r); | |
214 | ||
892c4467 DT |
215 | list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) { |
216 | rv = print_format2_lock(s, lkb, r); | |
217 | if (rv) | |
218 | goto out; | |
219 | } | |
9dd592d7 | 220 | |
892c4467 DT |
221 | list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) { |
222 | rv = print_format2_lock(s, lkb, r); | |
223 | if (rv) | |
224 | goto out; | |
225 | } | |
d022509d | 226 | |
892c4467 DT |
227 | list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) { |
228 | rv = print_format2_lock(s, lkb, r); | |
229 | if (rv) | |
230 | goto out; | |
231 | } | |
232 | out: | |
d022509d | 233 | unlock_rsb(r); |
892c4467 | 234 | return rv; |
d022509d DT |
235 | } |
236 | ||
892c4467 DT |
237 | static int print_format3_lock(struct seq_file *s, struct dlm_lkb *lkb, |
238 | int rsb_lookup) | |
d022509d DT |
239 | { |
240 | u64 xid = 0; | |
892c4467 | 241 | int rv; |
d022509d DT |
242 | |
243 | if (lkb->lkb_flags & DLM_IFL_USER) { | |
244 | if (lkb->lkb_ua) | |
245 | xid = lkb->lkb_ua->xid; | |
246 | } | |
247 | ||
892c4467 DT |
248 | rv = seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n", |
249 | lkb->lkb_id, | |
250 | lkb->lkb_nodeid, | |
251 | lkb->lkb_remid, | |
252 | lkb->lkb_ownpid, | |
253 | (unsigned long long)xid, | |
254 | lkb->lkb_exflags, | |
255 | lkb->lkb_flags, | |
256 | lkb->lkb_status, | |
257 | lkb->lkb_grmode, | |
258 | lkb->lkb_rqmode, | |
259 | lkb->lkb_highbast, | |
260 | rsb_lookup, | |
261 | lkb->lkb_wait_type, | |
262 | lkb->lkb_lvbseq, | |
263 | (unsigned long long)ktime_to_ns(lkb->lkb_timestamp), | |
264 | (unsigned long long)ktime_to_ns(lkb->lkb_time_bast)); | |
265 | return rv; | |
d022509d DT |
266 | } |
267 | ||
268 | static int print_format3(struct dlm_rsb *r, struct seq_file *s) | |
269 | { | |
270 | struct dlm_lkb *lkb; | |
271 | int i, lvblen = r->res_ls->ls_lvblen; | |
272 | int print_name = 1; | |
892c4467 | 273 | int rv; |
d022509d DT |
274 | |
275 | lock_rsb(r); | |
276 | ||
892c4467 DT |
277 | rv = seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ", |
278 | r, | |
279 | r->res_nodeid, | |
280 | r->res_first_lkid, | |
281 | r->res_flags, | |
282 | !list_empty(&r->res_root_list), | |
283 | !list_empty(&r->res_recover_list), | |
284 | r->res_recover_locks_count, | |
285 | r->res_length); | |
286 | if (rv) | |
287 | goto out; | |
d022509d DT |
288 | |
289 | for (i = 0; i < r->res_length; i++) { | |
290 | if (!isascii(r->res_name[i]) || !isprint(r->res_name[i])) | |
291 | print_name = 0; | |
292 | } | |
293 | ||
294 | seq_printf(s, "%s", print_name ? "str " : "hex"); | |
295 | ||
296 | for (i = 0; i < r->res_length; i++) { | |
297 | if (print_name) | |
298 | seq_printf(s, "%c", r->res_name[i]); | |
299 | else | |
300 | seq_printf(s, " %02x", (unsigned char)r->res_name[i]); | |
301 | } | |
892c4467 DT |
302 | rv = seq_printf(s, "\n"); |
303 | if (rv) | |
304 | goto out; | |
d022509d DT |
305 | |
306 | if (!r->res_lvbptr) | |
307 | goto do_locks; | |
308 | ||
309 | seq_printf(s, "lvb %u %d", r->res_lvbseq, lvblen); | |
310 | ||
311 | for (i = 0; i < lvblen; i++) | |
312 | seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]); | |
892c4467 DT |
313 | rv = seq_printf(s, "\n"); |
314 | if (rv) | |
315 | goto out; | |
d022509d DT |
316 | |
317 | do_locks: | |
892c4467 DT |
318 | list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue) { |
319 | rv = print_format3_lock(s, lkb, 0); | |
320 | if (rv) | |
321 | goto out; | |
e7fd4179 | 322 | } |
e7fd4179 | 323 | |
892c4467 DT |
324 | list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue) { |
325 | rv = print_format3_lock(s, lkb, 0); | |
326 | if (rv) | |
327 | goto out; | |
e7fd4179 DT |
328 | } |
329 | ||
892c4467 DT |
330 | list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue) { |
331 | rv = print_format3_lock(s, lkb, 0); | |
332 | if (rv) | |
333 | goto out; | |
e7fd4179 DT |
334 | } |
335 | ||
892c4467 DT |
336 | list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup) { |
337 | rv = print_format3_lock(s, lkb, 1); | |
338 | if (rv) | |
339 | goto out; | |
e7fd4179 | 340 | } |
892c4467 DT |
341 | out: |
342 | unlock_rsb(r); | |
343 | return rv; | |
e7fd4179 DT |
344 | } |
345 | ||
892c4467 DT |
346 | struct rsbtbl_iter { |
347 | struct dlm_rsb *rsb; | |
348 | unsigned bucket; | |
349 | int format; | |
350 | int header; | |
351 | }; | |
e7fd4179 | 352 | |
892c4467 DT |
353 | /* seq_printf returns -1 if the buffer is full, and 0 otherwise. |
354 | If the buffer is full, seq_printf can be called again, but it | |
355 | does nothing and just returns -1. So, the these printing routines | |
356 | periodically check the return value to avoid wasting too much time | |
357 | trying to print to a full buffer. */ | |
358 | ||
359 | static int table_seq_show(struct seq_file *seq, void *iter_ptr) | |
e7fd4179 | 360 | { |
892c4467 DT |
361 | struct rsbtbl_iter *ri = iter_ptr; |
362 | int rv = 0; | |
e7fd4179 | 363 | |
d022509d DT |
364 | switch (ri->format) { |
365 | case 1: | |
892c4467 | 366 | rv = print_format1(ri->rsb, seq); |
d022509d DT |
367 | break; |
368 | case 2: | |
9dd592d7 | 369 | if (ri->header) { |
892c4467 DT |
370 | seq_printf(seq, "id nodeid remid pid xid exflags " |
371 | "flags sts grmode rqmode time_ms " | |
372 | "r_nodeid r_len r_name\n"); | |
9dd592d7 DT |
373 | ri->header = 0; |
374 | } | |
892c4467 | 375 | rv = print_format2(ri->rsb, seq); |
d022509d DT |
376 | break; |
377 | case 3: | |
378 | if (ri->header) { | |
892c4467 | 379 | seq_printf(seq, "version rsb 1.1 lvb 1.1 lkb 1.1\n"); |
d022509d DT |
380 | ri->header = 0; |
381 | } | |
892c4467 | 382 | rv = print_format3(ri->rsb, seq); |
d022509d | 383 | break; |
9dd592d7 | 384 | } |
e7fd4179 | 385 | |
892c4467 | 386 | return rv; |
e7fd4179 DT |
387 | } |
388 | ||
892c4467 DT |
389 | static struct seq_operations format1_seq_ops; |
390 | static struct seq_operations format2_seq_ops; | |
391 | static struct seq_operations format3_seq_ops; | |
e7fd4179 | 392 | |
892c4467 | 393 | static void *table_seq_start(struct seq_file *seq, loff_t *pos) |
e7fd4179 | 394 | { |
892c4467 DT |
395 | struct dlm_ls *ls = seq->private; |
396 | struct rsbtbl_iter *ri; | |
397 | struct dlm_rsb *r; | |
398 | loff_t n = *pos; | |
399 | unsigned bucket, entry; | |
e7fd4179 | 400 | |
892c4467 DT |
401 | bucket = n >> 32; |
402 | entry = n & ((1LL << 32) - 1); | |
9dd592d7 | 403 | |
892c4467 DT |
404 | if (bucket >= ls->ls_rsbtbl_size) |
405 | return NULL; | |
9dd592d7 | 406 | |
892c4467 | 407 | ri = kzalloc(sizeof(struct rsbtbl_iter), GFP_KERNEL); |
9dd592d7 DT |
408 | if (!ri) |
409 | return NULL; | |
892c4467 | 410 | if (n == 0) |
9dd592d7 | 411 | ri->header = 1; |
892c4467 DT |
412 | if (seq->op == &format1_seq_ops) |
413 | ri->format = 1; | |
414 | if (seq->op == &format2_seq_ops) | |
415 | ri->format = 2; | |
416 | if (seq->op == &format3_seq_ops) | |
417 | ri->format = 3; | |
418 | ||
c7be761a | 419 | spin_lock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 DT |
420 | if (!list_empty(&ls->ls_rsbtbl[bucket].list)) { |
421 | list_for_each_entry(r, &ls->ls_rsbtbl[bucket].list, | |
422 | res_hashchain) { | |
423 | if (!entry--) { | |
424 | dlm_hold_rsb(r); | |
425 | ri->rsb = r; | |
426 | ri->bucket = bucket; | |
c7be761a | 427 | spin_unlock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 DT |
428 | return ri; |
429 | } | |
430 | } | |
9dd592d7 | 431 | } |
c7be761a | 432 | spin_unlock(&ls->ls_rsbtbl[bucket].lock); |
9dd592d7 | 433 | |
892c4467 DT |
434 | /* |
435 | * move to the first rsb in the next non-empty bucket | |
436 | */ | |
9dd592d7 | 437 | |
892c4467 DT |
438 | /* zero the entry */ |
439 | n &= ~((1LL << 32) - 1); | |
9dd592d7 | 440 | |
892c4467 DT |
441 | while (1) { |
442 | bucket++; | |
443 | n += 1LL << 32; | |
9dd592d7 | 444 | |
892c4467 DT |
445 | if (bucket >= ls->ls_rsbtbl_size) { |
446 | kfree(ri); | |
9dd592d7 DT |
447 | return NULL; |
448 | } | |
9dd592d7 | 449 | |
c7be761a | 450 | spin_lock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 DT |
451 | if (!list_empty(&ls->ls_rsbtbl[bucket].list)) { |
452 | r = list_first_entry(&ls->ls_rsbtbl[bucket].list, | |
453 | struct dlm_rsb, res_hashchain); | |
454 | dlm_hold_rsb(r); | |
455 | ri->rsb = r; | |
456 | ri->bucket = bucket; | |
c7be761a | 457 | spin_unlock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 DT |
458 | *pos = n; |
459 | return ri; | |
460 | } | |
c7be761a | 461 | spin_unlock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 | 462 | } |
9dd592d7 DT |
463 | } |
464 | ||
892c4467 | 465 | static void *table_seq_next(struct seq_file *seq, void *iter_ptr, loff_t *pos) |
9dd592d7 | 466 | { |
892c4467 DT |
467 | struct dlm_ls *ls = seq->private; |
468 | struct rsbtbl_iter *ri = iter_ptr; | |
469 | struct list_head *next; | |
470 | struct dlm_rsb *r, *rp; | |
471 | loff_t n = *pos; | |
472 | unsigned bucket; | |
473 | ||
474 | bucket = n >> 32; | |
475 | ||
476 | /* | |
477 | * move to the next rsb in the same bucket | |
478 | */ | |
479 | ||
c7be761a | 480 | spin_lock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 DT |
481 | rp = ri->rsb; |
482 | next = rp->res_hashchain.next; | |
483 | ||
484 | if (next != &ls->ls_rsbtbl[bucket].list) { | |
485 | r = list_entry(next, struct dlm_rsb, res_hashchain); | |
486 | dlm_hold_rsb(r); | |
487 | ri->rsb = r; | |
c7be761a | 488 | spin_unlock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 DT |
489 | dlm_put_rsb(rp); |
490 | ++*pos; | |
491 | return ri; | |
492 | } | |
c7be761a | 493 | spin_unlock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 | 494 | dlm_put_rsb(rp); |
d022509d | 495 | |
892c4467 DT |
496 | /* |
497 | * move to the first rsb in the next non-empty bucket | |
498 | */ | |
d022509d | 499 | |
892c4467 DT |
500 | /* zero the entry */ |
501 | n &= ~((1LL << 32) - 1); | |
d022509d | 502 | |
892c4467 DT |
503 | while (1) { |
504 | bucket++; | |
505 | n += 1LL << 32; | |
d022509d | 506 | |
892c4467 DT |
507 | if (bucket >= ls->ls_rsbtbl_size) { |
508 | kfree(ri); | |
509 | return NULL; | |
510 | } | |
d022509d | 511 | |
c7be761a | 512 | spin_lock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 DT |
513 | if (!list_empty(&ls->ls_rsbtbl[bucket].list)) { |
514 | r = list_first_entry(&ls->ls_rsbtbl[bucket].list, | |
515 | struct dlm_rsb, res_hashchain); | |
516 | dlm_hold_rsb(r); | |
517 | ri->rsb = r; | |
518 | ri->bucket = bucket; | |
c7be761a | 519 | spin_unlock(&ls->ls_rsbtbl[bucket].lock); |
892c4467 DT |
520 | *pos = n; |
521 | return ri; | |
522 | } | |
c7be761a | 523 | spin_unlock(&ls->ls_rsbtbl[bucket].lock); |
d022509d | 524 | } |
d022509d DT |
525 | } |
526 | ||
892c4467 | 527 | static void table_seq_stop(struct seq_file *seq, void *iter_ptr) |
d022509d | 528 | { |
892c4467 | 529 | struct rsbtbl_iter *ri = iter_ptr; |
d022509d | 530 | |
892c4467 DT |
531 | if (ri) { |
532 | dlm_put_rsb(ri->rsb); | |
533 | kfree(ri); | |
d022509d | 534 | } |
d022509d DT |
535 | } |
536 | ||
892c4467 DT |
537 | static struct seq_operations format1_seq_ops = { |
538 | .start = table_seq_start, | |
539 | .next = table_seq_next, | |
540 | .stop = table_seq_stop, | |
541 | .show = table_seq_show, | |
d022509d DT |
542 | }; |
543 | ||
892c4467 DT |
544 | static struct seq_operations format2_seq_ops = { |
545 | .start = table_seq_start, | |
546 | .next = table_seq_next, | |
547 | .stop = table_seq_stop, | |
548 | .show = table_seq_show, | |
549 | }; | |
550 | ||
551 | static struct seq_operations format3_seq_ops = { | |
552 | .start = table_seq_start, | |
553 | .next = table_seq_next, | |
554 | .stop = table_seq_stop, | |
555 | .show = table_seq_show, | |
556 | }; | |
557 | ||
558 | static const struct file_operations format1_fops; | |
559 | static const struct file_operations format2_fops; | |
560 | static const struct file_operations format3_fops; | |
561 | ||
562 | static int table_open(struct inode *inode, struct file *file) | |
d022509d DT |
563 | { |
564 | struct seq_file *seq; | |
892c4467 DT |
565 | int ret = -1; |
566 | ||
567 | if (file->f_op == &format1_fops) | |
568 | ret = seq_open(file, &format1_seq_ops); | |
569 | else if (file->f_op == &format2_fops) | |
570 | ret = seq_open(file, &format2_seq_ops); | |
571 | else if (file->f_op == &format3_fops) | |
572 | ret = seq_open(file, &format3_seq_ops); | |
d022509d | 573 | |
d022509d DT |
574 | if (ret) |
575 | return ret; | |
576 | ||
577 | seq = file->private_data; | |
892c4467 | 578 | seq->private = inode->i_private; /* the dlm_ls */ |
d022509d DT |
579 | return 0; |
580 | } | |
581 | ||
892c4467 DT |
582 | static const struct file_operations format1_fops = { |
583 | .owner = THIS_MODULE, | |
584 | .open = table_open, | |
585 | .read = seq_read, | |
586 | .llseek = seq_lseek, | |
587 | .release = seq_release | |
588 | }; | |
589 | ||
590 | static const struct file_operations format2_fops = { | |
591 | .owner = THIS_MODULE, | |
592 | .open = table_open, | |
593 | .read = seq_read, | |
594 | .llseek = seq_lseek, | |
595 | .release = seq_release | |
596 | }; | |
597 | ||
598 | static const struct file_operations format3_fops = { | |
d022509d | 599 | .owner = THIS_MODULE, |
892c4467 | 600 | .open = table_open, |
d022509d DT |
601 | .read = seq_read, |
602 | .llseek = seq_lseek, | |
603 | .release = seq_release | |
604 | }; | |
605 | ||
5de6319b DT |
606 | /* |
607 | * dump lkb's on the ls_waiters list | |
608 | */ | |
609 | ||
610 | static int waiters_open(struct inode *inode, struct file *file) | |
611 | { | |
bba9dfd8 | 612 | file->private_data = inode->i_private; |
5de6319b DT |
613 | return 0; |
614 | } | |
615 | ||
616 | static ssize_t waiters_read(struct file *file, char __user *userbuf, | |
617 | size_t count, loff_t *ppos) | |
618 | { | |
619 | struct dlm_ls *ls = file->private_data; | |
620 | struct dlm_lkb *lkb; | |
06442440 | 621 | size_t len = DLM_DEBUG_BUF_LEN, pos = 0, ret, rv; |
5de6319b DT |
622 | |
623 | mutex_lock(&debug_buf_lock); | |
624 | mutex_lock(&ls->ls_waiters_mutex); | |
625 | memset(debug_buf, 0, sizeof(debug_buf)); | |
626 | ||
627 | list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) { | |
06442440 DT |
628 | ret = snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n", |
629 | lkb->lkb_id, lkb->lkb_wait_type, | |
630 | lkb->lkb_nodeid, lkb->lkb_resource->res_name); | |
631 | if (ret >= len - pos) | |
632 | break; | |
633 | pos += ret; | |
5de6319b DT |
634 | } |
635 | mutex_unlock(&ls->ls_waiters_mutex); | |
636 | ||
637 | rv = simple_read_from_buffer(userbuf, count, ppos, debug_buf, pos); | |
638 | mutex_unlock(&debug_buf_lock); | |
639 | return rv; | |
640 | } | |
641 | ||
00977a59 | 642 | static const struct file_operations waiters_fops = { |
5de6319b DT |
643 | .owner = THIS_MODULE, |
644 | .open = waiters_open, | |
645 | .read = waiters_read | |
646 | }; | |
647 | ||
d022509d DT |
648 | void dlm_delete_debug_file(struct dlm_ls *ls) |
649 | { | |
650 | if (ls->ls_debug_rsb_dentry) | |
651 | debugfs_remove(ls->ls_debug_rsb_dentry); | |
652 | if (ls->ls_debug_waiters_dentry) | |
653 | debugfs_remove(ls->ls_debug_waiters_dentry); | |
654 | if (ls->ls_debug_locks_dentry) | |
655 | debugfs_remove(ls->ls_debug_locks_dentry); | |
656 | if (ls->ls_debug_all_dentry) | |
657 | debugfs_remove(ls->ls_debug_all_dentry); | |
658 | } | |
659 | ||
e7fd4179 DT |
660 | int dlm_create_debug_file(struct dlm_ls *ls) |
661 | { | |
5de6319b DT |
662 | char name[DLM_LOCKSPACE_LEN+8]; |
663 | ||
d022509d DT |
664 | /* format 1 */ |
665 | ||
5de6319b DT |
666 | ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name, |
667 | S_IFREG | S_IRUGO, | |
668 | dlm_root, | |
669 | ls, | |
892c4467 | 670 | &format1_fops); |
20abf975 | 671 | if (!ls->ls_debug_rsb_dentry) |
d022509d | 672 | goto fail; |
5de6319b | 673 | |
d022509d | 674 | /* format 2 */ |
5de6319b | 675 | |
9dd592d7 | 676 | memset(name, 0, sizeof(name)); |
ac90a255 DT |
677 | snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name); |
678 | ||
679 | ls->ls_debug_locks_dentry = debugfs_create_file(name, | |
680 | S_IFREG | S_IRUGO, | |
681 | dlm_root, | |
682 | ls, | |
892c4467 | 683 | &format2_fops); |
d022509d DT |
684 | if (!ls->ls_debug_locks_dentry) |
685 | goto fail; | |
686 | ||
687 | /* format 3 */ | |
688 | ||
689 | memset(name, 0, sizeof(name)); | |
690 | snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_all", ls->ls_name); | |
691 | ||
692 | ls->ls_debug_all_dentry = debugfs_create_file(name, | |
693 | S_IFREG | S_IRUGO, | |
694 | dlm_root, | |
695 | ls, | |
892c4467 | 696 | &format3_fops); |
d022509d DT |
697 | if (!ls->ls_debug_all_dentry) |
698 | goto fail; | |
699 | ||
700 | memset(name, 0, sizeof(name)); | |
701 | snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name); | |
702 | ||
703 | ls->ls_debug_waiters_dentry = debugfs_create_file(name, | |
704 | S_IFREG | S_IRUGO, | |
705 | dlm_root, | |
706 | ls, | |
707 | &waiters_fops); | |
708 | if (!ls->ls_debug_waiters_dentry) | |
709 | goto fail; | |
9dd592d7 | 710 | |
5de6319b | 711 | return 0; |
e7fd4179 | 712 | |
d022509d DT |
713 | fail: |
714 | dlm_delete_debug_file(ls); | |
715 | return -ENOMEM; | |
e7fd4179 DT |
716 | } |
717 | ||
30727174 | 718 | int __init dlm_register_debugfs(void) |
e7fd4179 | 719 | { |
5de6319b | 720 | mutex_init(&debug_buf_lock); |
e7fd4179 DT |
721 | dlm_root = debugfs_create_dir("dlm", NULL); |
722 | return dlm_root ? 0 : -ENOMEM; | |
723 | } | |
724 | ||
725 | void dlm_unregister_debugfs(void) | |
726 | { | |
727 | debugfs_remove(dlm_root); | |
728 | } | |
729 |