dlm: add new debugfs entry (d022509d) · Commits · e / devices / android_kernel_sony_msm8998

fs/dlm/debug_fs.c

+246 −50

Original line number	Original line	Diff line number	Diff line
	/******************************************************************************		/******************************************************************************
	*******************************************************************************		*******************************************************************************
	**		**
	** Copyright (C) 2005 Red Hat, Inc. All rights reserved.		** Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved.
	**		**
	** This copyrighted material is made available to anyone wishing to use,		** This copyrighted material is made available to anyone wishing to use,
	** modify, copy, or redistribute it subject to the terms and conditions		** modify, copy, or redistribute it subject to the terms and conditions
	@@ -27,7 +27,7 @@ static struct dentry *dlm_root;

	struct rsb_iter {		struct rsb_iter {
	int entry;		int entry;
	int locks;		int format;
	int header;		int header;
	struct dlm_ls *ls;		struct dlm_ls *ls;
	struct list_head *next;		struct list_head *next;
	@@ -60,7 +60,7 @@ static char *print_lockmode(int mode)
	}		}
	}		}

	static void print_resource_lock(struct seq_file s, struct dlm_lkb lkb,		static void print_format1_lock(struct seq_file s, struct dlm_lkb lkb,
	struct dlm_rsb *res)		struct dlm_rsb *res)
	{		{
	seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));		seq_printf(s, "%08x %s", lkb->lkb_id, print_lockmode(lkb->lkb_grmode));
	@@ -83,7 +83,7 @@ static void print_resource_lock(struct seq_file s, struct dlm_lkb lkb,
	seq_printf(s, "\n");		seq_printf(s, "\n");
	}		}

	static int print_resource(struct dlm_rsb res, struct seq_file s)		static int print_format1(struct dlm_rsb res, struct seq_file s)
	{		{
	struct dlm_lkb *lkb;		struct dlm_lkb *lkb;
	int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;		int i, lvblen = res->res_ls->ls_lvblen, recover_list, root_list;
	@@ -134,15 +134,15 @@ static int print_resource(struct dlm_rsb res, struct seq_file s)
	/* Print the locks attached to this resource */		/* Print the locks attached to this resource */
	seq_printf(s, "Granted Queue\n");		seq_printf(s, "Granted Queue\n");
	list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue)		list_for_each_entry(lkb, &res->res_grantqueue, lkb_statequeue)
	print_resource_lock(s, lkb, res);		print_format1_lock(s, lkb, res);

	seq_printf(s, "Conversion Queue\n");		seq_printf(s, "Conversion Queue\n");
	list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue)		list_for_each_entry(lkb, &res->res_convertqueue, lkb_statequeue)
	print_resource_lock(s, lkb, res);		print_format1_lock(s, lkb, res);

	seq_printf(s, "Waiting Queue\n");		seq_printf(s, "Waiting Queue\n");
	list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue)		list_for_each_entry(lkb, &res->res_waitqueue, lkb_statequeue)
	print_resource_lock(s, lkb, res);		print_format1_lock(s, lkb, res);

	if (list_empty(&res->res_lookup))		if (list_empty(&res->res_lookup))
	goto out;		goto out;
	@@ -160,7 +160,8 @@ static int print_resource(struct dlm_rsb res, struct seq_file s)
	return 0;		return 0;
	}		}

	static void print_lock(struct seq_file s, struct dlm_lkb lkb, struct dlm_rsb *r)		static void print_format2_lock(struct seq_file s, struct dlm_lkb lkb,
			struct dlm_rsb *r)
	{		{
	u64 xid = 0;		u64 xid = 0;
	u64 us;		u64 us;
	@@ -193,20 +194,108 @@ static void print_lock(struct seq_file s, struct dlm_lkb lkb, struct dlm_rsb *
	r->res_name);		r->res_name);
	}		}

	static int print_locks(struct dlm_rsb r, struct seq_file s)		static int print_format2(struct dlm_rsb r, struct seq_file s)
	{		{
	struct dlm_lkb *lkb;		struct dlm_lkb *lkb;

	lock_rsb(r);		lock_rsb(r);

	list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)		list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
	print_lock(s, lkb, r);		print_format2_lock(s, lkb, r);

	list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)		list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
	print_lock(s, lkb, r);		print_format2_lock(s, lkb, r);

	list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)		list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
	print_lock(s, lkb, r);		print_format2_lock(s, lkb, r);

			unlock_rsb(r);
			return 0;
			}

			static void print_format3_lock(struct seq_file s, struct dlm_lkb lkb,
			int rsb_lookup)
			{
			u64 xid = 0;

			if (lkb->lkb_flags & DLM_IFL_USER) {
			if (lkb->lkb_ua)
			xid = lkb->lkb_ua->xid;
			}

			seq_printf(s, "lkb %x %d %x %u %llu %x %x %d %d %d %d %d %d %u %llu %llu\n",
			lkb->lkb_id,
			lkb->lkb_nodeid,
			lkb->lkb_remid,
			lkb->lkb_ownpid,
			(unsigned long long)xid,
			lkb->lkb_exflags,
			lkb->lkb_flags,
			lkb->lkb_status,
			lkb->lkb_grmode,
			lkb->lkb_rqmode,
			lkb->lkb_highbast,
			rsb_lookup,
			lkb->lkb_wait_type,
			lkb->lkb_lvbseq,
			(unsigned long long)ktime_to_ns(lkb->lkb_timestamp),
			(unsigned long long)ktime_to_ns(lkb->lkb_time_bast));
			}

			static int print_format3(struct dlm_rsb r, struct seq_file s)
			{
			struct dlm_lkb *lkb;
			int i, lvblen = r->res_ls->ls_lvblen;
			int print_name = 1;

			lock_rsb(r);

			seq_printf(s, "rsb %p %d %x %lx %d %d %u %d ",
			r,
			r->res_nodeid,
			r->res_first_lkid,
			r->res_flags,
			!list_empty(&r->res_root_list),
			!list_empty(&r->res_recover_list),
			r->res_recover_locks_count,
			r->res_length);

			for (i = 0; i < r->res_length; i++) {
			if (!isascii(r->res_name[i]) \|\| !isprint(r->res_name[i]))
			print_name = 0;
			}

			seq_printf(s, "%s", print_name ? "str " : "hex");

			for (i = 0; i < r->res_length; i++) {
			if (print_name)
			seq_printf(s, "%c", r->res_name[i]);
			else
			seq_printf(s, " %02x", (unsigned char)r->res_name[i]);
			}
			seq_printf(s, "\n");

			if (!r->res_lvbptr)
			goto do_locks;

			seq_printf(s, "lvb %u %d", r->res_lvbseq, lvblen);

			for (i = 0; i < lvblen; i++)
			seq_printf(s, " %02x", (unsigned char)r->res_lvbptr[i]);
			seq_printf(s, "\n");

			do_locks:
			list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
			print_format3_lock(s, lkb, 0);

			list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
			print_format3_lock(s, lkb, 0);

			list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
			print_format3_lock(s, lkb, 0);

			list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)
			print_format3_lock(s, lkb, 1);

	unlock_rsb(r);		unlock_rsb(r);
	return 0;		return 0;
	@@ -274,6 +363,7 @@ static struct rsb_iter rsb_iter_init(struct dlm_ls ls)
	ri->ls = ls;		ri->ls = ls;
	ri->entry = 0;		ri->entry = 0;
	ri->next = NULL;		ri->next = NULL;
			ri->format = 1;

	if (rsb_iter_next(ri)) {		if (rsb_iter_next(ri)) {
	rsb_iter_free(ri);		rsb_iter_free(ri);
	@@ -325,16 +415,26 @@ static int rsb_seq_show(struct seq_file file, void iter_ptr)
	{		{
	struct rsb_iter *ri = iter_ptr;		struct rsb_iter *ri = iter_ptr;

	if (ri->locks) {		switch (ri->format) {
			case 1:
			print_format1(ri->rsb, file);
			break;
			case 2:
	if (ri->header) {		if (ri->header) {
	seq_printf(file, "id nodeid remid pid xid exflags flags "		seq_printf(file, "id nodeid remid pid xid exflags "
	"sts grmode rqmode time_ms r_nodeid "		"flags sts grmode rqmode time_ms "
	"r_len r_name\n");		"r_nodeid r_len r_name\n");
	ri->header = 0;		ri->header = 0;
	}		}
	print_locks(ri->rsb, file);		print_format2(ri->rsb, file);
	} else {		break;
	print_resource(ri->rsb, file);		case 3:
			if (ri->header) {
			seq_printf(file, "version rsb 1.1 lvb 1.1 lkb 1.1\n");
			ri->header = 0;
			}
			print_format3(ri->rsb, file);
			break;
	}		}

	return 0;		return 0;
	@@ -385,7 +485,7 @@ static struct rsb_iter locks_iter_init(struct dlm_ls ls, loff_t *pos)
	ri->ls = ls;		ri->ls = ls;
	ri->entry = 0;		ri->entry = 0;
	ri->next = NULL;		ri->next = NULL;
	ri->locks = 1;		ri->format = 2;

	if (*pos == 0)		if (*pos == 0)
	ri->header = 1;		ri->header = 1;
	@@ -447,6 +547,84 @@ static const struct file_operations locks_fops = {
	.release = seq_release		.release = seq_release
	};		};

			/*
			* Dump all rsb/lvb/lkb state in compact listing, more complete than _locks
			* This can replace both formats 1 and 2 eventually.
			*/

			static struct rsb_iter all_iter_init(struct dlm_ls ls, loff_t *pos)
			{
			struct rsb_iter *ri;

			ri = kzalloc(sizeof *ri, GFP_KERNEL);
			if (!ri)
			return NULL;

			ri->ls = ls;
			ri->entry = 0;
			ri->next = NULL;
			ri->format = 3;

			if (*pos == 0)
			ri->header = 1;

			if (rsb_iter_next(ri)) {
			rsb_iter_free(ri);
			return NULL;
			}

			return ri;
			}

			static void all_seq_start(struct seq_file file, loff_t *pos)
			{
			struct rsb_iter *ri;
			loff_t n = *pos;

			ri = all_iter_init(file->private, pos);
			if (!ri)
			return NULL;

			while (n--) {
			if (rsb_iter_next(ri)) {
			rsb_iter_free(ri);
			return NULL;
			}
			}

			return ri;
			}

			static struct seq_operations all_seq_ops = {
			.start = all_seq_start,
			.next = rsb_seq_next,
			.stop = rsb_seq_stop,
			.show = rsb_seq_show,
			};

			static int all_open(struct inode inode, struct file file)
			{
			struct seq_file *seq;
			int ret;

			ret = seq_open(file, &all_seq_ops);
			if (ret)
			return ret;

			seq = file->private_data;
			seq->private = inode->i_private;

			return 0;
			}

			static const struct file_operations all_fops = {
			.owner = THIS_MODULE,
			.open = all_open,
			.read = seq_read,
			.llseek = seq_lseek,
			.release = seq_release
			};

	/*		/*
	* dump lkb's on the ls_waiters list		* dump lkb's on the ls_waiters list
	*/		*/
	@@ -489,56 +667,74 @@ static const struct file_operations waiters_fops = {
	.read = waiters_read		.read = waiters_read
	};		};

			void dlm_delete_debug_file(struct dlm_ls *ls)
			{
			if (ls->ls_debug_rsb_dentry)
			debugfs_remove(ls->ls_debug_rsb_dentry);
			if (ls->ls_debug_waiters_dentry)
			debugfs_remove(ls->ls_debug_waiters_dentry);
			if (ls->ls_debug_locks_dentry)
			debugfs_remove(ls->ls_debug_locks_dentry);
			if (ls->ls_debug_all_dentry)
			debugfs_remove(ls->ls_debug_all_dentry);
			}

	int dlm_create_debug_file(struct dlm_ls *ls)		int dlm_create_debug_file(struct dlm_ls *ls)
	{		{
	char name[DLM_LOCKSPACE_LEN+8];		char name[DLM_LOCKSPACE_LEN+8];

			/* format 1 */

	ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,		ls->ls_debug_rsb_dentry = debugfs_create_file(ls->ls_name,
	S_IFREG \| S_IRUGO,		S_IFREG \| S_IRUGO,
	dlm_root,		dlm_root,
	ls,		ls,
	&rsb_fops);		&rsb_fops);
	if (!ls->ls_debug_rsb_dentry)		if (!ls->ls_debug_rsb_dentry)
	return -ENOMEM;		goto fail;

			/* format 2 */

	memset(name, 0, sizeof(name));		memset(name, 0, sizeof(name));
	snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);		snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);

	ls->ls_debug_waiters_dentry = debugfs_create_file(name,		ls->ls_debug_locks_dentry = debugfs_create_file(name,
	S_IFREG \| S_IRUGO,		S_IFREG \| S_IRUGO,
	dlm_root,		dlm_root,
	ls,		ls,
	&waiters_fops);		&locks_fops);
	if (!ls->ls_debug_waiters_dentry) {		if (!ls->ls_debug_locks_dentry)
	debugfs_remove(ls->ls_debug_rsb_dentry);		goto fail;
	return -ENOMEM;
	}		/* format 3 */

	memset(name, 0, sizeof(name));		memset(name, 0, sizeof(name));
	snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_locks", ls->ls_name);		snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_all", ls->ls_name);

	ls->ls_debug_locks_dentry = debugfs_create_file(name,		ls->ls_debug_all_dentry = debugfs_create_file(name,
	S_IFREG \| S_IRUGO,		S_IFREG \| S_IRUGO,
	dlm_root,		dlm_root,
	ls,		ls,
	&locks_fops);		&all_fops);
	if (!ls->ls_debug_locks_dentry) {		if (!ls->ls_debug_all_dentry)
	debugfs_remove(ls->ls_debug_waiters_dentry);		goto fail;
	debugfs_remove(ls->ls_debug_rsb_dentry);
	return -ENOMEM;		memset(name, 0, sizeof(name));
	}		snprintf(name, DLM_LOCKSPACE_LEN+8, "%s_waiters", ls->ls_name);

			ls->ls_debug_waiters_dentry = debugfs_create_file(name,
			S_IFREG \| S_IRUGO,
			dlm_root,
			ls,
			&waiters_fops);
			if (!ls->ls_debug_waiters_dentry)
			goto fail;

	return 0;		return 0;
	}

	void dlm_delete_debug_file(struct dlm_ls *ls)		fail:
	{		dlm_delete_debug_file(ls);
	if (ls->ls_debug_rsb_dentry)		return -ENOMEM;
	debugfs_remove(ls->ls_debug_rsb_dentry);
	if (ls->ls_debug_waiters_dentry)
	debugfs_remove(ls->ls_debug_waiters_dentry);
	if (ls->ls_debug_locks_dentry)
	debugfs_remove(ls->ls_debug_locks_dentry);
	}		}

	int __init dlm_register_debugfs(void)		int __init dlm_register_debugfs(void)

fs/dlm/dlm_internal.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -482,6 +482,7 @@ struct dlm_ls {
	struct dentry ls_debug_rsb_dentry; / debugfs */		struct dentry ls_debug_rsb_dentry; / debugfs */
	struct dentry ls_debug_waiters_dentry; / debugfs */		struct dentry ls_debug_waiters_dentry; / debugfs */
	struct dentry ls_debug_locks_dentry; / debugfs */		struct dentry ls_debug_locks_dentry; / debugfs */
			struct dentry ls_debug_all_dentry; / debugfs */

	wait_queue_head_t ls_uevent_wait; /* user part of join/leave */		wait_queue_head_t ls_uevent_wait; /* user part of join/leave */
	int ls_uevent_result;		int ls_uevent_result;