Commit 7c52b166 authored by Robert Peterson's avatar Robert Peterson Committed by Steven Whitehouse
Browse files

[GFS2] Add gfs2_tool lockdump support to gfs2 (bz 228540) 



The attached patch resolves bz 228540.  This adds the capability
for gfs2 to dump gfs2 locks through the debugfs file system.
This used to exist in gfs1 as "gfs_tool lockdump" but it's missing from
gfs2 because all the ioctls were stripped out.  Please see the bugzilla
for more history about the fix.  This patch is also attached to the bugzilla
record.

The patch is against Steve Whitehouse's latest nmw git tree kernel
(2.6.21-rc1) and has been tested on system trin-10.

Signed-off-by: default avatarRobert Peterson <rpeterso@redhat.com>
Signed-off-by: default avatarSteven Whitehouse <swhiteho@redhat.com>
parent dc87c398

fs/gfs2/glock.c

+251 −63
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ 
#include <linux/module.h>

#include <linux/rwsem.h>

#include <asm/uaccess.h>

#include <linux/seq_file.h>

#include <linux/debugfs.h>



#include "gfs2.h"

#include "incore.h"
@@ -40,14 +42,22 @@ struct gfs2_gl_hash_bucket { 
        struct hlist_head hb_list;

};



struct glock_iter {

	int hash;                     /* hash bucket index         */

	struct gfs2_sbd *sdp;         /* incore superblock         */

	struct gfs2_glock *gl;        /* current glock struct      */

	struct hlist_head *hb_list;   /* current hash bucket ptr   */

	struct seq_file *seq;         /* sequence file for debugfs */

	char string[512];             /* scratch space             */

};



typedef void (*glock_examiner) (struct gfs2_glock * gl);



static int gfs2_dump_lockstate(struct gfs2_sbd *sdp);

static int dump_glock(struct gfs2_glock *gl);

static int dump_inode(struct gfs2_inode *ip);

static void gfs2_glock_xmote_th(struct gfs2_holder *gh);

static void gfs2_glock_drop_th(struct gfs2_glock *gl);

static DECLARE_RWSEM(gfs2_umount_flush_sem);

static struct dentry *gfs2_root;



#define GFS2_GL_HASH_SHIFT      15

#define GFS2_GL_HASH_SIZE       (1 << GFS2_GL_HASH_SHIFT)
@@ -1109,6 +1119,20 @@ find_holder_by_owner(struct list_head *head, struct task_struct *owner) 
	return NULL;

}



static void print_dbg(struct glock_iter *gi, const char *fmt, ...)

{

	va_list args;



	va_start(args, fmt);

	if (gi) {

		vsprintf(gi->string, fmt, args);

		seq_printf(gi->seq, gi->string);

	}

	else

		vprintk(fmt, args);

	va_end(args);

}



/**

 * add_to_queue - Add a holder to the wait queue (but look for recursion)

 * @gh: the holder structure to add
@@ -1849,31 +1873,32 @@ void gfs2_gl_hash_clear(struct gfs2_sbd *sdp, int wait) 
 * Returns: 0 on success, -ENOBUFS when we run out of space

 */



static int dump_holder(char *str, struct gfs2_holder *gh)

static int dump_holder(struct glock_iter *gi, char *str,

		       struct gfs2_holder *gh)

{

	unsigned int x;

	int error = -ENOBUFS;



	printk(KERN_INFO "  %s\n", str);

	printk(KERN_INFO "    owner = %ld\n",

	print_dbg(gi, "  %s\n", str);

	print_dbg(gi, "    owner = %ld\n",

		   (gh->gh_owner) ? (long)gh->gh_owner->pid : -1);

	printk(KERN_INFO "    gh_state = %u\n", gh->gh_state);

	printk(KERN_INFO "    gh_flags =");

	print_dbg(gi, "    gh_state = %u\n", gh->gh_state);

	print_dbg(gi, "    gh_flags =");

	for (x = 0; x < 32; x++)

		if (gh->gh_flags & (1 << x))

			printk(" %u", x);

	printk(" \n");

	printk(KERN_INFO "    error = %d\n", gh->gh_error);

	printk(KERN_INFO "    gh_iflags =");

			print_dbg(gi, " %u", x);

	print_dbg(gi, " \n");

	print_dbg(gi, "    error = %d\n", gh->gh_error);

	print_dbg(gi, "    gh_iflags =");

	for (x = 0; x < 32; x++)

		if (test_bit(x, &gh->gh_iflags))

			printk(" %u", x);

	printk(" \n");

			print_dbg(gi, " %u", x);

	print_dbg(gi, " \n");

	if (gi)

		print_dbg(gi, "    initialized at: 0x%x\n", gh->gh_ip);

	else

		print_symbol(KERN_INFO "    initialized at: %s\n", gh->gh_ip);



	error = 0;



	return error;

	return 0;

}



/**
@@ -1883,25 +1908,20 @@ static int dump_holder(char *str, struct gfs2_holder *gh) 
 * Returns: 0 on success, -ENOBUFS when we run out of space

 */



static int dump_inode(struct gfs2_inode *ip)

static int dump_inode(struct glock_iter *gi, struct gfs2_inode *ip)

{

	unsigned int x;

	int error = -ENOBUFS;



	printk(KERN_INFO "  Inode:\n");

	printk(KERN_INFO "    num = %llu %llu\n",

		    (unsigned long long)ip->i_num.no_formal_ino,

		    (unsigned long long)ip->i_num.no_addr);

	printk(KERN_INFO "    type = %u\n", IF2DT(ip->i_inode.i_mode));

	printk(KERN_INFO "    i_flags =");

	print_dbg(gi, "  Inode:\n");

	print_dbg(gi, "    num = %llu/%llu\n",

		    ip->i_num.no_formal_ino, ip->i_num.no_addr);

	print_dbg(gi, "    type = %u\n", IF2DT(ip->i_inode.i_mode));

	print_dbg(gi, "    i_flags =");

	for (x = 0; x < 32; x++)

		if (test_bit(x, &ip->i_flags))

			printk(" %u", x);

	printk(" \n");



	error = 0;



	return error;

			print_dbg(gi, " %u", x);

	print_dbg(gi, " \n");

	return 0;

}



/**
@@ -1912,7 +1932,7 @@ static int dump_inode(struct gfs2_inode *ip) 
 * Returns: 0 on success, -ENOBUFS when we run out of space

 */



static int dump_glock(struct gfs2_glock *gl)

static int dump_glock(struct glock_iter *gi, struct gfs2_glock *gl)

{

	struct gfs2_holder *gh;

	unsigned int x;
@@ -1920,66 +1940,66 @@ static int dump_glock(struct gfs2_glock *gl) 


	spin_lock(&gl->gl_spin);



	printk(KERN_INFO "Glock 0x%p (%u, %llu)\n", gl, gl->gl_name.ln_type,

	print_dbg(gi, "Glock 0x%p (%u, %llu)\n", gl, gl->gl_name.ln_type,

		   (unsigned long long)gl->gl_name.ln_number);

	printk(KERN_INFO "  gl_flags =");

	print_dbg(gi, "  gl_flags =");

	for (x = 0; x < 32; x++) {

		if (test_bit(x, &gl->gl_flags))

			printk(" %u", x);

	}

	printk(" \n");

	printk(KERN_INFO "  gl_ref = %d\n", atomic_read(&gl->gl_ref));

	printk(KERN_INFO "  gl_state = %u\n", gl->gl_state);

	printk(KERN_INFO "  gl_owner = %s\n", gl->gl_owner->comm);

	print_symbol(KERN_INFO "  gl_ip = %s\n", gl->gl_ip);

	printk(KERN_INFO "  req_gh = %s\n", (gl->gl_req_gh) ? "yes" : "no");

	printk(KERN_INFO "  req_bh = %s\n", (gl->gl_req_bh) ? "yes" : "no");

	printk(KERN_INFO "  lvb_count = %d\n", atomic_read(&gl->gl_lvb_count));

	printk(KERN_INFO "  object = %s\n", (gl->gl_object) ? "yes" : "no");

	printk(KERN_INFO "  le = %s\n",

			print_dbg(gi, " %u", x);

	}

	print_dbg(gi, " \n");

	print_dbg(gi, "  gl_ref = %d\n", atomic_read(&gl->gl_ref));

	print_dbg(gi, "  gl_state = %u\n", gl->gl_state);

	print_dbg(gi, "  gl_owner = %s\n", gl->gl_owner->comm);

	print_dbg(gi, "  gl_ip = %lu\n", gl->gl_ip);

	print_dbg(gi, "  req_gh = %s\n", (gl->gl_req_gh) ? "yes" : "no");

	print_dbg(gi, "  req_bh = %s\n", (gl->gl_req_bh) ? "yes" : "no");

	print_dbg(gi, "  lvb_count = %d\n", atomic_read(&gl->gl_lvb_count));

	print_dbg(gi, "  object = %s\n", (gl->gl_object) ? "yes" : "no");

	print_dbg(gi, "  le = %s\n",

		   (list_empty(&gl->gl_le.le_list)) ? "no" : "yes");

	printk(KERN_INFO "  reclaim = %s\n",

	print_dbg(gi, "  reclaim = %s\n",

		   (list_empty(&gl->gl_reclaim)) ? "no" : "yes");

	if (gl->gl_aspace)

		printk(KERN_INFO "  aspace = 0x%p nrpages = %lu\n", gl->gl_aspace,

		print_dbg(gi, "  aspace = 0x%p nrpages = %lu\n", gl->gl_aspace,

			   gl->gl_aspace->i_mapping->nrpages);

	else

		printk(KERN_INFO "  aspace = no\n");

	printk(KERN_INFO "  ail = %d\n", atomic_read(&gl->gl_ail_count));

		print_dbg(gi, "  aspace = no\n");

	print_dbg(gi, "  ail = %d\n", atomic_read(&gl->gl_ail_count));

	if (gl->gl_req_gh) {

		error = dump_holder("Request", gl->gl_req_gh);

		error = dump_holder(gi, "Request", gl->gl_req_gh);

		if (error)

			goto out;

	}

	list_for_each_entry(gh, &gl->gl_holders, gh_list) {

		error = dump_holder("Holder", gh);

		error = dump_holder(gi, "Holder", gh);

		if (error)

			goto out;

	}

	list_for_each_entry(gh, &gl->gl_waiters1, gh_list) {

		error = dump_holder("Waiter1", gh);

		error = dump_holder(gi, "Waiter1", gh);

		if (error)

			goto out;

	}

	list_for_each_entry(gh, &gl->gl_waiters2, gh_list) {

		error = dump_holder("Waiter2", gh);

		error = dump_holder(gi, "Waiter2", gh);

		if (error)

			goto out;

	}

	list_for_each_entry(gh, &gl->gl_waiters3, gh_list) {

		error = dump_holder("Waiter3", gh);

		error = dump_holder(gi, "Waiter3", gh);

		if (error)

			goto out;

	}

	if (gl->gl_ops == &gfs2_inode_glops && gl->gl_object) {

		if (!test_bit(GLF_LOCK, &gl->gl_flags) &&

			list_empty(&gl->gl_holders)) {

			error = dump_inode(gl->gl_object);

			error = dump_inode(gi, gl->gl_object);

			if (error)

				goto out;

		} else {

			error = -ENOBUFS;

			printk(KERN_INFO "  Inode: busy\n");

			print_dbg(gi, "  Inode: busy\n");

		}

	}
@@ -2014,7 +2034,7 @@ static int gfs2_dump_lockstate(struct gfs2_sbd *sdp) 
			if (gl->gl_sbd != sdp)

				continue;



			error = dump_glock(gl);

			error = dump_glock(NULL, gl);

			if (error)

				break;

		}
@@ -2043,3 +2063,171 @@ int __init gfs2_glock_init(void) 
	return 0;

}



static int gfs2_glock_iter_next(struct glock_iter *gi)

{

	while (1) {

		if (!gi->hb_list) {  /* If we don't have a hash bucket yet */

			gi->hb_list = &gl_hash_table[gi->hash].hb_list;

			if (hlist_empty(gi->hb_list)) {

				gi->hash++;

				gi->hb_list = NULL;

				if (gi->hash >= GFS2_GL_HASH_SIZE)

					return 1;

				else

					continue;

			}

			if (!hlist_empty(gi->hb_list)) {

				gi->gl = list_entry(gi->hb_list->first,

						    struct gfs2_glock,

						    gl_list);

			}

		} else {

			if (gi->gl->gl_list.next == NULL) {

				gi->hash++;

				gi->hb_list = NULL;

				continue;

			}

			gi->gl = list_entry(gi->gl->gl_list.next,

					    struct gfs2_glock, gl_list);

		}

		if (gi->gl)

			break;

	}

	return 0;

}



static void gfs2_glock_iter_free(struct glock_iter *gi)

{

	kfree(gi);

}



static struct glock_iter *gfs2_glock_iter_init(struct gfs2_sbd *sdp)

{

	struct glock_iter *gi;



	gi = kmalloc(sizeof (*gi), GFP_KERNEL);

	if (!gi)

		return NULL;



	gi->sdp = sdp;

	gi->hash = 0;

	gi->gl = NULL;

	gi->hb_list = NULL;

	gi->seq = NULL;

	memset(gi->string, 0, sizeof(gi->string));



	if (gfs2_glock_iter_next(gi)) {

		gfs2_glock_iter_free(gi);

		return NULL;

	}



	return gi;

}



static void *gfs2_glock_seq_start(struct seq_file *file, loff_t *pos)

{

	struct glock_iter *gi;

	loff_t n = *pos;



	gi = gfs2_glock_iter_init(file->private);

	if (!gi)

		return NULL;



	while (n--) {

		if (gfs2_glock_iter_next(gi)) {

			gfs2_glock_iter_free(gi);

			return NULL;

		}

	}



	return gi;

}



static void *gfs2_glock_seq_next(struct seq_file *file, void *iter_ptr,

				 loff_t *pos)

{

	struct glock_iter *gi = iter_ptr;



	(*pos)++;



	if (gfs2_glock_iter_next(gi)) {

		gfs2_glock_iter_free(gi);

		return NULL;

	}



	return gi;

}



static void gfs2_glock_seq_stop(struct seq_file *file, void *iter_ptr)

{

	/* nothing for now */

}



static int gfs2_glock_seq_show(struct seq_file *file, void *iter_ptr)

{

	struct glock_iter *gi = iter_ptr;



	gi->seq = file;

	dump_glock(gi, gi->gl);



	return 0;

}



static struct seq_operations gfs2_glock_seq_ops = {

	.start = gfs2_glock_seq_start,

	.next  = gfs2_glock_seq_next,

	.stop  = gfs2_glock_seq_stop,

	.show  = gfs2_glock_seq_show,

};



static int gfs2_debugfs_open(struct inode *inode, struct file *file)

{

	struct seq_file *seq;

	int ret;



	ret = seq_open(file, &gfs2_glock_seq_ops);

	if (ret)

		return ret;



	seq = file->private_data;

	seq->private = inode->i_private;



	return 0;

}



static const struct file_operations gfs2_debug_fops = {

	.owner   = THIS_MODULE,

	.open    = gfs2_debugfs_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = seq_release

};



int gfs2_create_debugfs_file(struct gfs2_sbd *sdp)

{

	sdp->debugfs_dentry = debugfs_create_file(sdp->sd_table_name,

						  S_IFREG | S_IRUGO,

						  gfs2_root, sdp,

						  &gfs2_debug_fops);

	if (!sdp->debugfs_dentry)

		return -ENOMEM;



	return 0;

}



void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp)

{

	if (sdp->debugfs_dentry)

		debugfs_remove(sdp->debugfs_dentry);

}



int gfs2_register_debugfs(void)

{

	gfs2_root = debugfs_create_dir("gfs2", NULL);

	return gfs2_root ? 0 : -ENOMEM;

}



void gfs2_unregister_debugfs(void)

{

	debugfs_remove(gfs2_root);

}

fs/gfs2/glock.h

+4 −0
Original line number Diff line number Diff line
@@ -135,5 +135,9 @@ void gfs2_scand_internal(struct gfs2_sbd *sdp); 
void gfs2_gl_hash_clear(struct gfs2_sbd *sdp, int wait);



int __init gfs2_glock_init(void);

int gfs2_create_debugfs_file(struct gfs2_sbd *sdp);

void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp);

int gfs2_register_debugfs(void);

void gfs2_unregister_debugfs(void);



#endif /* __GLOCK_DOT_H__ */

fs/gfs2/incore.h

+1 −0
Original line number Diff line number Diff line
@@ -611,6 +611,7 @@ struct gfs2_sbd { 


	unsigned long sd_last_warning;

	struct vfsmount *sd_gfs2mnt;

	struct dentry *debugfs_dentry; /* for debugfs */

};



#endif /* __INCORE_DOT_H__ */

fs/gfs2/main.c

+3 −0
Original line number Diff line number Diff line
@@ -103,6 +103,8 @@ static int __init init_gfs2_fs(void) 
	if (error)

		goto fail_unregister;



	gfs2_register_debugfs();



	printk("GFS2 (built %s %s) installed\n", __DATE__, __TIME__);



	return 0;
@@ -130,6 +132,7 @@ fail: 


static void __exit exit_gfs2_fs(void)

{

	gfs2_unregister_debugfs();

	unregister_filesystem(&gfs2_fs_type);

	unregister_filesystem(&gfs2meta_fs_type);

fs/gfs2/ops_fstype.c

+3 −0
Original line number Diff line number Diff line
@@ -690,6 +690,8 @@ static int fill_super(struct super_block *sb, void *data, int silent) 
	if (error)

		goto fail;



	gfs2_create_debugfs_file(sdp);



	error = gfs2_sys_fs_add(sdp);

	if (error)

		goto fail;
@@ -896,6 +898,7 @@ error: 


static void gfs2_kill_sb(struct super_block *sb)

{

	gfs2_delete_debugfs_file(sb->s_fs_info);

	kill_block_super(sb);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE