Linux Audio

Check our new training course

Embedded Linux training

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