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