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