Attachment 148091 Details for Bug 228540 – First go at a fix

[patch] First go at a fix

228540.patch.try1 (text/plain), 19.68 KB, created by Robert Peterson on 2007-02-14 23:17:36 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Robert Peterson

Created: 2007-02-14 23:17:36 UTC

Size: 19.68 KB

patch

obsolete

>diff --git a/fs/gfs2/acl.c b/fs/gfs2/acl.c
>diff --git a/fs/gfs2/acl.h b/fs/gfs2/acl.h
>diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
>diff --git a/fs/gfs2/bmap.h b/fs/gfs2/bmap.h
>diff --git a/fs/gfs2/daemon.c b/fs/gfs2/daemon.c
>diff --git a/fs/gfs2/daemon.h b/fs/gfs2/daemon.h
>diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
>diff --git a/fs/gfs2/dir.h b/fs/gfs2/dir.h
>diff --git a/fs/gfs2/eaops.c b/fs/gfs2/eaops.c
>diff --git a/fs/gfs2/eaops.h b/fs/gfs2/eaops.h
>diff --git a/fs/gfs2/eattr.c b/fs/gfs2/eattr.c
>diff --git a/fs/gfs2/eattr.h b/fs/gfs2/eattr.h
>diff --git a/fs/gfs2/gfs2.h b/fs/gfs2/gfs2.h
>diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
>index 6618c11..83d562d 100644
>--- a/fs/gfs2/glock.c
>+++ b/fs/gfs2/glock.c
>@@ -22,6 +22,9 @@
> #include <linux/wait.h>
> #include <linux/rwsem.h>
> #include <asm/uaccess.h>
>+#include <linux/seq_file.h>
>+#include <linux/debugfs.h>
>+#include <linux/module.h>
> 
> #include "gfs2.h"
> #include "incore.h"
>@@ -39,14 +42,20 @@ 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  */
>+};
>+
> 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)
>@@ -1843,78 +1852,88 @@ void gfs2_gl_hash_clear(struct gfs2_sbd *sdp, int wait)
>  *  Diagnostic routines to help debug distributed deadlock
>  */
> 
>+void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...)
>+{
>+	va_list args;
>+
>+	va_start(args, fmt);
>+
>+	if (seq) {
>+		char vstring[256]; /* There's no vseq_printf */
>+
>+		vsprintf(vstring, fmt, args);
>+		seq_printf(seq, vstring);
>+	}
>+	else
>+		vprintk(fmt, args);
>+	va_end(args);
>+}
>+
> /**
>- * dump_holder - print information about a glock holder
>+ * gfs2_dump_holder - print information about a glock holder
>  * @str: a string naming the type of holder
>  * @gh: the glock holder
>  *
>  * Returns: 0 on success, -ENOBUFS when we run out of space
>  */
> 
>-static int dump_holder(char *str, struct gfs2_holder *gh)
>+static int gfs2_dump_holder(struct seq_file *s, char *str,
>+			    struct gfs2_holder *gh)
> {
> 	unsigned int x;
>-	int error = -ENOBUFS;
> 
>-	printk(KERN_INFO "  %s\n", str);
>-	printk(KERN_INFO "    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 =");
>+	gfs2_print_dbg(s, "  %s\n", str);
>+	gfs2_print_dbg(s, "    owner = %ld\n",
>+		       (gh->gh_owner) ? (long)gh->gh_owner->pid : -1);
>+	gfs2_print_dbg(s, "    gh_state = %u\n", gh->gh_state);
>+	gfs2_print_dbg(s, "    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 =");
>+			gfs2_print_dbg(s, " %u", x);
>+	gfs2_print_dbg(s, " \n");
>+	gfs2_print_dbg(s, "    error = %d\n", gh->gh_error);
>+	gfs2_print_dbg(s, "    gh_iflags =");
> 	for (x = 0; x < 32; x++)
> 		if (test_bit(x, &gh->gh_iflags))
>-			printk(" %u", x);
>-	printk(" \n");
>+			gfs2_print_dbg(s, " %u", x);
>+	gfs2_print_dbg(s, " \n");
> 	print_symbol(KERN_INFO "    initialized at: %s\n", gh->gh_ip);
> 
>-	error = 0;
>-
>-	return error;
>+	return 0;
> }
> 
> /**
>- * dump_inode - print information about an inode
>+ * gfs2_dump_inode - print information about an inode
>  * @ip: the inode
>  *
>  * Returns: 0 on success, -ENOBUFS when we run out of space
>  */
> 
>-static int dump_inode(struct gfs2_inode *ip)
>+static int gfs2_dump_inode(struct seq_file *s, 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 =");
>+	gfs2_print_dbg(s, "  Inode:\n");
>+	gfs2_print_dbg(s, "    num = %llu/%llu\n",
>+		       ip->i_num.no_formal_ino, ip->i_num.no_addr);
>+	gfs2_print_dbg(s, "    type = %u\n", IF2DT(ip->i_inode.i_mode));
>+	gfs2_print_dbg(s, "    i_flags =");
> 	for (x = 0; x < 32; x++)
> 		if (test_bit(x, &ip->i_flags))
>-			printk(" %u", x);
>-	printk(" \n");
>-
>-	error = 0;
>-
>-	return error;
>+			gfs2_print_dbg(s, " %u", x);
>+	gfs2_print_dbg(s, " \n");
>+	return 0;
> }
> 
> /**
>- * dump_glock - print information about a glock
>+ * gfs2_dump_glock - print information about a glock
>  * @gl: the glock
>  * @count: where we are in the buffer
>  *
>  * Returns: 0 on success, -ENOBUFS when we run out of space
>  */
> 
>-static int dump_glock(struct gfs2_glock *gl)
>+static int gfs2_dump_glock(struct seq_file *s, struct gfs2_glock *gl)
> {
> 	struct gfs2_holder *gh;
> 	unsigned int x;
>@@ -1922,71 +1941,71 @@ 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,
>-	       (unsigned long long)gl->gl_name.ln_number);
>-	printk(KERN_INFO "  gl_flags =");
>+	gfs2_print_dbg(s, "Glock 0x%p (%u, %llu)\n", gl, gl->gl_name.ln_type,
>+		   (unsigned long long)gl->gl_name.ln_number);
>+	gfs2_print_dbg(s, "  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",
>+			gfs2_print_dbg(s, " %u", x);
>+	}
>+	gfs2_print_dbg(s, " \n");
>+	gfs2_print_dbg(s, "  gl_ref = %d\n", atomic_read(&gl->gl_ref));
>+	gfs2_print_dbg(s, "  gl_state = %u\n", gl->gl_state);
>+	gfs2_print_dbg(s, "  gl_owner = %s\n", gl->gl_owner->comm);
>+	gfs2_print_dbg(s, "  gl_ip = %lu\n", gl->gl_ip);
>+	gfs2_print_dbg(s, "  req_gh = %s\n", (gl->gl_req_gh) ? "yes" : "no");
>+	gfs2_print_dbg(s, "  req_bh = %s\n", (gl->gl_req_bh) ? "yes" : "no");
>+	gfs2_print_dbg(s, "  lvb_count = %d\n", atomic_read(&gl->gl_lvb_count));
>+	gfs2_print_dbg(s, "  object = %s\n", (gl->gl_object) ? "yes" : "no");
>+	gfs2_print_dbg(s, "  le = %s\n",
> 		   (list_empty(&gl->gl_le.le_list)) ? "no" : "yes");
>-	printk(KERN_INFO "  reclaim = %s\n",
>-		    (list_empty(&gl->gl_reclaim)) ? "no" : "yes");
>+	gfs2_print_dbg(s, "  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,
>-		       gl->gl_aspace->i_mapping->nrpages);
>+		gfs2_print_dbg(s, "  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));
>+		gfs2_print_dbg(s, "  aspace = no\n");
>+	gfs2_print_dbg(s, "  ail = %d\n", atomic_read(&gl->gl_ail_count));
> 	if (gl->gl_req_gh) {
>-		error = dump_holder("Request", gl->gl_req_gh);
>+		error = gfs2_dump_holder(s, "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 = gfs2_dump_holder(s, "Holder", gh);
> 		if (error)
> 			goto out;
> 	}
> 	list_for_each_entry(gh, &gl->gl_waiters1, gh_list) {
>-		error = dump_holder("Waiter1", gh);
>+		error = gfs2_dump_holder(s, "Waiter1", gh);
> 		if (error)
> 			goto out;
> 	}
> 	list_for_each_entry(gh, &gl->gl_waiters2, gh_list) {
>-		error = dump_holder("Waiter2", gh);
>+		error = gfs2_dump_holder(s, "Waiter2", gh);
> 		if (error)
> 			goto out;
> 	}
> 	list_for_each_entry(gh, &gl->gl_waiters3, gh_list) {
>-		error = dump_holder("Waiter3", gh);
>+		error = gfs2_dump_holder(s, "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);
>+			list_empty(&gl->gl_holders)) {
>+			error = gfs2_dump_inode(s, gl->gl_object);
> 			if (error)
> 				goto out;
> 		} else {
> 			error = -ENOBUFS;
>-			printk(KERN_INFO "  Inode: busy\n");
>+			gfs2_print_dbg(s, "  Inode: busy\n");
> 		}
> 	}
>-
>+	
> 	error = 0;
>-
>+	
> out:
> 	spin_unlock(&gl->gl_spin);
> 	return error;
>@@ -2012,11 +2031,12 @@ static int gfs2_dump_lockstate(struct gfs2_sbd *sdp)
> 
> 		read_lock(gl_lock_addr(x));
> 
>-		hlist_for_each_entry(gl, h, &gl_hash_table[x].hb_list, gl_list) {
>+		hlist_for_each_entry(gl, h, &gl_hash_table[x].hb_list,
>+				     gl_list) {
> 			if (gl->gl_sbd != sdp)
> 				continue;
> 
>-			error = dump_glock(gl);
>+			error = gfs2_dump_glock(NULL, gl);
> 			if (error)
> 				break;
> 		}
>@@ -2045,3 +2065,169 @@ 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;
>+
>+	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;
>+
>+	gfs2_dump_glock(file, 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);
>+}
>diff --git a/fs/gfs2/glock.h b/fs/gfs2/glock.h
>index f50e40c..d7cef74 100644
>--- a/fs/gfs2/glock.h
>+++ b/fs/gfs2/glock.h
>@@ -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__ */
>diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
>diff --git a/fs/gfs2/glops.h b/fs/gfs2/glops.h
>diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
>index 12c80fd..3459061 100644
>--- a/fs/gfs2/incore.h
>+++ b/fs/gfs2/incore.h
>@@ -613,6 +613,7 @@ struct gfs2_sbd {
> 
> 	unsigned long sd_last_warning;
> 	struct vfsmount *sd_gfs2mnt;
>+	struct dentry *debugfs_dentry; /* for debugfs */
> };
> 
> #endif /* __INCORE_DOT_H__ */
>diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
>diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
>diff --git a/fs/gfs2/lm.c b/fs/gfs2/lm.c
>diff --git a/fs/gfs2/lm.h b/fs/gfs2/lm.h
>diff --git a/fs/gfs2/locking.c b/fs/gfs2/locking.c
>index 663fee7..8116ca9 100644
>--- a/fs/gfs2/locking.c
>+++ b/fs/gfs2/locking.c
>@@ -182,3 +182,6 @@ void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct)
> EXPORT_SYMBOL_GPL(gfs2_register_lockproto);
> EXPORT_SYMBOL_GPL(gfs2_unregister_lockproto);
> 
>+EXPORT_SYMBOL_GPL(gfs2_mount_lockproto);
>+EXPORT_SYMBOL_GPL(gfs2_unmount_lockproto);
>+EXPORT_SYMBOL_GPL(gfs2_withdraw_lockproto);
>diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
>diff --git a/fs/gfs2/log.h b/fs/gfs2/log.h
>diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
>diff --git a/fs/gfs2/lops.h b/fs/gfs2/lops.h
>diff --git a/fs/gfs2/main.c b/fs/gfs2/main.c
>index 7c1a9e2..d7b7ad3 100644
>--- a/fs/gfs2/main.c
>+++ b/fs/gfs2/main.c
>@@ -104,6 +104,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;
>@@ -131,6 +133,7 @@ fail:
> 
> static void __exit exit_gfs2_fs(void)
> {
>+	gfs2_unregister_debugfs();
> 	unregister_filesystem(&gfs2_fs_type);
> 	unregister_filesystem(&gfs2meta_fs_type);
> 
>diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
>index 0e34d99..e62d4f6 100644
>--- a/fs/gfs2/meta_io.c
>+++ b/fs/gfs2/meta_io.c
>@@ -282,8 +282,7 @@ void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
> 		return;
> 	}
> 
>-	bd = kmem_cache_alloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL),
>-	memset(bd, 0, sizeof(struct gfs2_bufdata));
>+	bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL),
> 	bd->bd_bh = bh;
> 	bd->bd_gl = gl;
> 
>diff --git a/fs/gfs2/meta_io.h b/fs/gfs2/meta_io.h
>diff --git a/fs/gfs2/mount.c b/fs/gfs2/mount.c
>diff --git a/fs/gfs2/mount.h b/fs/gfs2/mount.h
>diff --git a/fs/gfs2/ondisk.c b/fs/gfs2/ondisk.c
>diff --git a/fs/gfs2/ops_address.c b/fs/gfs2/ops_address.c
>diff --git a/fs/gfs2/ops_address.h b/fs/gfs2/ops_address.h
>diff --git a/fs/gfs2/ops_dentry.c b/fs/gfs2/ops_dentry.c
>diff --git a/fs/gfs2/ops_dentry.h b/fs/gfs2/ops_dentry.h
>diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c
>diff --git a/fs/gfs2/ops_export.h b/fs/gfs2/ops_export.h
>diff --git a/fs/gfs2/ops_file.c b/fs/gfs2/ops_file.c
>diff --git a/fs/gfs2/ops_file.h b/fs/gfs2/ops_file.h
>diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
>index ee80b8a..276e7e8 100644
>--- a/fs/gfs2/ops_fstype.c
>+++ b/fs/gfs2/ops_fstype.c
>@@ -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);
> }
> 
>diff --git a/fs/gfs2/ops_fstype.h b/fs/gfs2/ops_fstype.h
>diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c
>index f40a848..60f47bf 100644
>--- a/fs/gfs2/ops_inode.c
>+++ b/fs/gfs2/ops_inode.c
>@@ -1115,7 +1115,7 @@ static int gfs2_removexattr(struct dentry *dentry, const char *name)
> 	return gfs2_ea_remove(GFS2_I(dentry->d_inode), &er);
> }
> 
>-struct inode_operations gfs2_file_iops = {
>+const struct inode_operations gfs2_file_iops = {
> 	.permission = gfs2_permission,
> 	.setattr = gfs2_setattr,
> 	.getattr = gfs2_getattr,
>@@ -1125,7 +1125,7 @@ struct inode_operations gfs2_file_iops = {
> 	.removexattr = gfs2_removexattr,
> };
> 
>-struct inode_operations gfs2_dev_iops = {
>+const struct inode_operations gfs2_dev_iops = {
> 	.permission = gfs2_permission,
> 	.setattr = gfs2_setattr,
> 	.getattr = gfs2_getattr,
>@@ -1135,7 +1135,7 @@ struct inode_operations gfs2_dev_iops = {
> 	.removexattr = gfs2_removexattr,
> };
> 
>-struct inode_operations gfs2_dir_iops = {
>+const struct inode_operations gfs2_dir_iops = {
> 	.create = gfs2_create,
> 	.lookup = gfs2_lookup,
> 	.link = gfs2_link,
>@@ -1154,7 +1154,7 @@ struct inode_operations gfs2_dir_iops = {
> 	.removexattr = gfs2_removexattr,
> };
> 
>-struct inode_operations gfs2_symlink_iops = {
>+const struct inode_operations gfs2_symlink_iops = {
> 	.readlink = gfs2_readlink,
> 	.follow_link = gfs2_follow_link,
> 	.permission = gfs2_permission,
>diff --git a/fs/gfs2/ops_inode.h b/fs/gfs2/ops_inode.h
>index b15acb4..34f0caa 100644
>--- a/fs/gfs2/ops_inode.h
>+++ b/fs/gfs2/ops_inode.h
>@@ -12,9 +12,9 @@
> 
> #include <linux/fs.h>
> 
>-extern struct inode_operations gfs2_file_iops;
>-extern struct inode_operations gfs2_dir_iops;
>-extern struct inode_operations gfs2_symlink_iops;
>-extern struct inode_operations gfs2_dev_iops;
>+extern const struct inode_operations gfs2_file_iops;
>+extern const struct inode_operations gfs2_dir_iops;
>+extern const struct inode_operations gfs2_symlink_iops;
>+extern const struct inode_operations gfs2_dev_iops;
> 
> #endif /* __OPS_INODE_DOT_H__ */
>diff --git a/fs/gfs2/ops_super.c b/fs/gfs2/ops_super.c
>index 47369d0..b89999d 100644
>--- a/fs/gfs2/ops_super.c
>+++ b/fs/gfs2/ops_super.c
>@@ -468,7 +468,7 @@ static void gfs2_destroy_inode(struct inode *inode)
> 	kmem_cache_free(gfs2_inode_cachep, inode);
> }
> 
>-struct super_operations gfs2_super_ops = {
>+const struct super_operations gfs2_super_ops = {
> 	.alloc_inode		= gfs2_alloc_inode,
> 	.destroy_inode		= gfs2_destroy_inode,
> 	.write_inode		= gfs2_write_inode,
>diff --git a/fs/gfs2/ops_super.h b/fs/gfs2/ops_super.h
>index 9de73f0..442a274 100644
>--- a/fs/gfs2/ops_super.h
>+++ b/fs/gfs2/ops_super.h
>@@ -12,6 +12,6 @@
> 
> #include <linux/fs.h>
> 
>-extern struct super_operations gfs2_super_ops;
>+extern const struct super_operations gfs2_super_ops;
> 
> #endif /* __OPS_SUPER_DOT_H__ */
>diff --git a/fs/gfs2/ops_vm.c b/fs/gfs2/ops_vm.c
>diff --git a/fs/gfs2/ops_vm.h b/fs/gfs2/ops_vm.h
>diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
>diff --git a/fs/gfs2/quota.h b/fs/gfs2/quota.h
>diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
>diff --git a/fs/gfs2/recovery.h b/fs/gfs2/recovery.h
>diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
>diff --git a/fs/gfs2/rgrp.h b/fs/gfs2/rgrp.h
>diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
>diff --git a/fs/gfs2/super.h b/fs/gfs2/super.h
>diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
>diff --git a/fs/gfs2/sys.h b/fs/gfs2/sys.h
>diff --git a/fs/gfs2/trans.c b/fs/gfs2/trans.c
>diff --git a/fs/gfs2/trans.h b/fs/gfs2/trans.h
>diff --git a/fs/gfs2/util.c b/fs/gfs2/util.c
>diff --git a/fs/gfs2/util.h b/fs/gfs2/util.h

Actions: View | Diff

Attachments on bug 228540: 148091 | 148880 | 149026 | 149854 | 150918 | 150925 | 150936 | 152978