path: root/sys-cluster/lustre/files/0009-LU-3319-procfs-update-ldiskfs-proc-handling-to-seq_f.patch

From adf3be9fe382564c4760b83a5843b7d5502bbe48 Mon Sep 17 00:00:00 2001
From: James Simmons <uja.ornl@gmail.com>
Date: Sun, 9 Feb 2014 10:45:37 -0500
Subject: [PATCH 09/12] LU-3319 procfs: update ldiskfs proc handling to
 seq_files

Migrate all ldiskfs proc handling to using strictly
seq_files. Also include a fix with newer gcc complaining
certain variables are initialized.

Signed-off-by: James Simmons <uja.ornl@gmail.com>
Change-Id: Ia296a4682e2feda02bcfbe0100de8a89404cd731
---
 lustre/osd-ldiskfs/osd_compat.c   |   6 +-
 lustre/osd-ldiskfs/osd_handler.c  |  16 +-
 lustre/osd-ldiskfs/osd_internal.h |   6 +-
 lustre/osd-ldiskfs/osd_lproc.c    | 336 ++++++++++++++++++++------------------
 lustre/osd-ldiskfs/osd_scrub.c    |  73 +++------
 5 files changed, 220 insertions(+), 217 deletions(-)

diff --git a/lustre/osd-ldiskfs/osd_compat.c b/lustre/osd-ldiskfs/osd_compat.c
index b4a018c..6ca1304 100644
--- a/lustre/osd-ldiskfs/osd_compat.c
+++ b/lustre/osd-ldiskfs/osd_compat.c
@@ -1168,7 +1168,7 @@ int osd_obj_spec_update(struct osd_thread_info *info, struct osd_device *osd,
 			handle_t *th)
 {
 	struct dentry	*root;
-	char		*name;
+	char		*name = NULL;
 	int		 rc;
 	ENTRY;
 
@@ -1189,7 +1189,7 @@ int osd_obj_spec_insert(struct osd_thread_info *info, struct osd_device *osd,
 			handle_t *th)
 {
 	struct dentry	*root;
-	char		*name;
+	char		*name = NULL;
 	int		 rc;
 	ENTRY;
 
@@ -1211,7 +1211,7 @@ int osd_obj_spec_lookup(struct osd_thread_info *info, struct osd_device *osd,
 	struct dentry	*root;
 	struct dentry	*dentry;
 	struct inode	*inode;
-	char		*name;
+	char		*name = NULL;
 	int		rc = -ENOENT;
 	ENTRY;
 
diff --git a/lustre/osd-ldiskfs/osd_handler.c b/lustre/osd-ldiskfs/osd_handler.c
index 9027533..dfaa542 100644
--- a/lustre/osd-ldiskfs/osd_handler.c
+++ b/lustre/osd-ldiskfs/osd_handler.c
@@ -5814,6 +5814,7 @@ static struct lu_device *osd_device_free(const struct lu_env *env,
 static int osd_process_config(const struct lu_env *env,
                               struct lu_device *d, struct lustre_cfg *cfg)
 {
+	struct obd_device		*obd = d->ld_obd;
 	struct osd_device		*o = osd_dev(d);
 	int				rc;
 	ENTRY;
@@ -5828,12 +5829,12 @@ static int osd_process_config(const struct lu_env *env,
 		break;
 	case LCFG_PARAM:
 		LASSERT(&o->od_dt_dev);
-		rc = class_process_proc_param(PARAM_OSD, lprocfs_osd_obd_vars,
-					      cfg, &o->od_dt_dev);
+		rc = class_process_proc_seq_param(PARAM_OSD, obd->obd_vars,
+						  cfg, &o->od_dt_dev);
 		if (rc > 0 || rc == -ENOSYS)
-			rc = class_process_proc_param(PARAM_OST,
-						      lprocfs_osd_obd_vars,
-						      cfg, &o->od_dt_dev);
+			rc = class_process_proc_seq_param(PARAM_OST,
+							  obd->obd_vars, cfg,
+							  &o->od_dt_dev);
 		break;
 	default:
 		rc = -ENOSYS;
@@ -5981,9 +5982,10 @@ static int __init osd_mod_init(void)
 	if (rc)
 		return rc;
 
-	rc = class_register_type(&osd_obd_device_ops, NULL, NULL,
-#ifndef HAVE_ONLY_PROCFS_SEQ
+	rc = class_register_type(&osd_obd_device_ops, NULL,
 				lprocfs_osd_module_vars,
+#ifndef HAVE_ONLY_PROCFS_SEQ
+				NULL,
 #endif
 				LUSTRE_OSD_LDISKFS_NAME, &osd_device_type);
 	if (rc)
diff --git a/lustre/osd-ldiskfs/osd_internal.h b/lustre/osd-ldiskfs/osd_internal.h
index 8436d1f..c90147f 100644
--- a/lustre/osd-ldiskfs/osd_internal.h
+++ b/lustre/osd-ldiskfs/osd_internal.h
@@ -623,8 +623,8 @@ static inline int __osd_xattr_set(struct osd_thread_info *info,
 
 #ifdef LPROCFS
 /* osd_lproc.c */
-extern struct lprocfs_vars lprocfs_osd_obd_vars[];
-extern struct lprocfs_vars lprocfs_osd_module_vars[];
+extern struct lprocfs_seq_vars lprocfs_osd_obd_vars[];
+extern struct lprocfs_seq_vars lprocfs_osd_module_vars[];
 int osd_procfs_init(struct osd_device *osd, const char *name);
 int osd_procfs_fini(struct osd_device *osd);
 void osd_brw_stats_update(struct osd_device *osd, struct osd_iobuf *iobuf);
@@ -679,7 +679,7 @@ int osd_oii_insert(struct osd_device *dev, struct osd_idmap_cache *oic,
 		   int insert);
 int osd_oii_lookup(struct osd_device *dev, const struct lu_fid *fid,
 		   struct osd_inode_id *id);
-int osd_scrub_dump(struct osd_device *dev, char *buf, int len);
+int osd_scrub_dump(struct seq_file *m, struct osd_device *dev);
 
 int osd_fld_lookup(const struct lu_env *env, struct osd_device *osd,
 		   obd_seq seq, struct lu_seq_range *range);
diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c
index b9b4e3d..947a4b9 100644
--- a/lustre/osd-ldiskfs/osd_lproc.c
+++ b/lustre/osd-ldiskfs/osd_lproc.c
@@ -237,92 +237,46 @@ out:
         RETURN(result);
 }
 
-int osd_procfs_init(struct osd_device *osd, const char *name)
-{
-        struct obd_type     *type;
-        int                  rc;
-        ENTRY;
-
-	/* at the moment there is no linkage between lu_type
-	 * and obd_type, so we lookup obd_type this way */
-	type = class_search_type(LUSTRE_OSD_LDISKFS_NAME);
-
-        LASSERT(name != NULL);
-        LASSERT(type != NULL);
-
-        /* Find the type procroot and add the proc entry for this device */
-        osd->od_proc_entry = lprocfs_register(name, type->typ_procroot,
-					      lprocfs_osd_obd_vars,
-					      &osd->od_dt_dev);
-        if (IS_ERR(osd->od_proc_entry)) {
-                rc = PTR_ERR(osd->od_proc_entry);
-                CERROR("Error %d setting up lprocfs for %s\n",
-                       rc, name);
-                osd->od_proc_entry = NULL;
-                GOTO(out, rc);
-        }
-
-        rc = osd_stats_init(osd);
-
-        EXIT;
-out:
-        if (rc)
-               osd_procfs_fini(osd);
-	return rc;
-}
-
-int osd_procfs_fini(struct osd_device *osd)
-{
-	if (osd->od_stats)
-		lprocfs_free_stats(&osd->od_stats);
-
-        if (osd->od_proc_entry) {
-                 lprocfs_remove(&osd->od_proc_entry);
-                 osd->od_proc_entry = NULL;
-        }
-        RETURN(0);
-}
-
-static int lprocfs_osd_rd_fstype(char *page, char **start, off_t off, int count,
-				 int *eof, void *data)
+static int ldiskfs_osd_fstype_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *osd = osd_dt_dev(data);
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
-        LASSERT(osd != NULL);
-        return snprintf(page, count, "ldiskfs\n");
+	LASSERT(osd != NULL);
+	return seq_printf(m, "ldiskfs\n");
 }
+LPROC_SEQ_FOPS_RO(ldiskfs_osd_fstype);
 
-static int lprocfs_osd_rd_mntdev(char *page, char **start, off_t off, int count,
-                                 int *eof, void *data)
+static int ldiskfs_osd_mntdev_seq_show(struct seq_file *m, void *data)
 {
-        struct osd_device *osd = osd_dt_dev(data);
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
-        LASSERT(osd != NULL);
+	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
-                return -EINPROGRESS;
-
-	*eof = 1;
+		return -EINPROGRESS;
 
-	return snprintf(page, count, "%s\n", osd->od_mntdev);
+	return seq_printf(m, "%u\n", osd->od_read_cache);
 }
+LPROC_SEQ_FOPS_RO(ldiskfs_osd_mntdev);
 
-static int lprocfs_osd_rd_cache(char *page, char **start, off_t off,
-				int count, int *eof, void *data)
+static int ldiskfs_osd_cache_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *osd = osd_dt_dev(data);
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	return snprintf(page, count, "%u\n", osd->od_read_cache);
+	return seq_printf(m, "%u\n", osd->od_read_cache);
 }
 
-static int lprocfs_osd_wr_cache(struct file *file, const char *buffer,
-				unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_cache_seq_write(struct file *file, const char *buffer,
+			    size_t count, loff_t *off)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
-	int			 val, rc;
+	struct seq_file *m = file->private_data;
+	struct dt_device  *dt = m->private;
+	struct osd_device *osd = osd_dt_dev(dt);
+	int		   val, rc;
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
@@ -335,24 +289,26 @@ static int lprocfs_osd_wr_cache(struct file *file, const char *buffer,
 	osd->od_read_cache = !!val;
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_cache);
 
-static int lprocfs_osd_rd_wcache(char *page, char **start, off_t off,
-				 int count, int *eof, void *data)
+static int ldiskfs_osd_wcache_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *osd = osd_dt_dev(data);
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	return snprintf(page, count, "%u\n", osd->od_writethrough_cache);
+	return seq_printf(m, "%u\n", osd->od_writethrough_cache);
 }
 
-static int lprocfs_osd_wr_wcache(struct file *file, const char *buffer,
-				 unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_wcache_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
-	int			 val, rc;
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device *osd = osd_dt_dev(dt);
+	int		   val, rc;
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
@@ -365,14 +321,16 @@ static int lprocfs_osd_wr_wcache(struct file *file, const char *buffer,
 	osd->od_writethrough_cache = !!val;
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_wcache);
 
-static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer,
-				     unsigned long count, void *data)
+static ssize_t
+lprocfs_osd_force_sync_seq_write(struct file *file, const char *buffer,
+					size_t count, loff_t *off)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
-	struct dt_device	*dt = data;
-	struct lu_env		 env;
-	int			 rc;
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device *osd = osd_dt_dev(dt);
+	struct lu_env	   env;
+	int		   rc;
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
@@ -386,20 +344,18 @@ static int lprocfs_osd_wr_force_sync(struct file *file, const char *buffer,
 
 	return rc == 0 ? count : rc;
 }
+LPROC_SEQ_FOPS_WO_TYPE(ldiskfs, osd_force_sync);
 
-static int lprocfs_osd_rd_pdo(char *page, char **start, off_t off, int count,
-                              int *eof, void *data)
+static int ldiskfs_osd_pdo_seq_show(struct seq_file *m, void *data)
 {
-        *eof = 1;
-
-        return snprintf(page, count, "%s\n", ldiskfs_pdo ? "ON" : "OFF");
+	return seq_printf(m, "%s\n", ldiskfs_pdo ? "ON" : "OFF");
 }
 
-static int lprocfs_osd_wr_pdo(struct file *file, const char *buffer,
-                              unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_pdo_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-        int     pdo;
-        int     rc;
+	int pdo, rc;
 
         rc = lprocfs_write_helper(buffer, count, &pdo);
         if (rc != 0)
@@ -409,24 +365,25 @@ static int lprocfs_osd_wr_pdo(struct file *file, const char *buffer,
 
         return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_pdo);
 
-static int lprocfs_osd_rd_auto_scrub(char *page, char **start, off_t off,
-				     int count, int *eof, void *data)
+static int ldiskfs_osd_auto_scrub_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(dev != NULL);
 	if (unlikely(dev->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	*eof = 1;
-	return snprintf(page, count, "%d\n", !dev->od_noscrub);
+	return seq_printf(m, "%d\n", !dev->od_noscrub);
 }
 
-static int lprocfs_osd_wr_auto_scrub(struct file *file, const char *buffer,
-				     unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_auto_scrub_seq_write(struct file *file, const char *buffer,
+					size_t count, loff_t *off)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device *dev = osd_dt_dev(dt);
 	int val, rc;
 
 	LASSERT(dev != NULL);
@@ -440,19 +397,18 @@ static int lprocfs_osd_wr_auto_scrub(struct file *file, const char *buffer,
 	dev->od_noscrub = !val;
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_auto_scrub);
 
-static int lprocfs_osd_rd_track_declares_assert(char *page, char **start,
-						off_t off, int count,
-						int *eof, void *data)
+static int
+ldiskfs_osd_track_declares_assert_seq_show(struct seq_file *m, void *data)
 {
-	*eof = 1;
-
-	return snprintf(page, count, "%d\n", ldiskfs_track_declares_assert);
+	return seq_printf(m, "%d\n", ldiskfs_track_declares_assert);
 }
 
-static int lprocfs_osd_wr_track_declares_assert(struct file *file,
+static ssize_t
+ldiskfs_osd_track_declares_assert_seq_write(struct file *file,
 						const char *buffer,
-						unsigned long count, void *data)
+						size_t count, loff_t *off)
 {
 	int     track_declares_assert;
 	int     rc;
@@ -465,38 +421,39 @@ static int lprocfs_osd_wr_track_declares_assert(struct file *file,
 
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_track_declares_assert);
+
+extern int osd_scrub_dump(struct seq_file *m, struct osd_device *dev);
 
-static int lprocfs_osd_rd_oi_scrub(char *page, char **start, off_t off,
-				   int count, int *eof, void *data)
+static int ldiskfs_osd_oi_scrub_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(dev != NULL);
 	if (unlikely(dev->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	*eof = 1;
-	return osd_scrub_dump(dev, page, count);
+	return osd_scrub_dump(m, dev);
 }
+LPROC_SEQ_FOPS_RO(ldiskfs_osd_oi_scrub);
 
-int lprocfs_osd_rd_readcache(char *page, char **start, off_t off, int count,
-			     int *eof, void *data)
+int ldiskfs_osd_readcache_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
-	int			 rc;
+	struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(osd != NULL);
 	if (unlikely(osd->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	rc = snprintf(page, count, LPU64"\n", osd->od_readcache_max_filesize);
-	return rc;
+	return seq_printf(m, LPU64"\n", osd->od_readcache_max_filesize);
 }
 
-int lprocfs_osd_wr_readcache(struct file *file, const char *buffer,
-			     unsigned long count, void *data)
+ssize_t
+ldiskfs_osd_readcache_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-	struct osd_device	*osd = osd_dt_dev(data);
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device	*osd = osd_dt_dev(dt);
 	__u64			 val;
 	int			 rc;
 
@@ -512,24 +469,25 @@ int lprocfs_osd_wr_readcache(struct file *file, const char *buffer,
 					 OSD_MAX_CACHE_SIZE : val;
 	return count;
 }
+LPROC_SEQ_FOPS(ldiskfs_osd_readcache);
 
-static int lprocfs_osd_rd_lma_self_repair(char *page, char **start, off_t off,
-					  int count, int *eof, void *data)
+static int ldiskfs_osd_lma_self_repair_seq_show(struct seq_file *m, void *data)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct osd_device *dev = osd_dt_dev((struct dt_device *)m->private);
 
 	LASSERT(dev != NULL);
 	if (unlikely(dev->od_mnt == NULL))
 		return -EINPROGRESS;
 
-	*eof = 1;
-	return snprintf(page, count, "%d\n", !!dev->od_lma_self_repair);
+	return seq_printf(m, "%d\n", !!dev->od_lma_self_repair);
 }
 
-static int lprocfs_osd_wr_lma_self_repair(struct file *file, const char *buffer,
-					  unsigned long count, void *data)
+static ssize_t
+ldiskfs_osd_lma_self_repair_seq_write(struct file *file, const char *buffer,
+					size_t count, loff_t *off)
 {
-	struct osd_device *dev = osd_dt_dev(data);
+	struct dt_device  *dt = ((struct seq_file *)file->private_data)->private;
+	struct osd_device *dev = osd_dt_dev(dt);
 	int		   val;
 	int		   rc;
 
@@ -544,38 +502,102 @@ static int lprocfs_osd_wr_lma_self_repair(struct file *file, const char *buffer,
 	dev->od_lma_self_repair = !!val;
 	return count;
 }
-
-struct lprocfs_vars lprocfs_osd_obd_vars[] = {
-	{ "blocksize",		lprocfs_dt_rd_blksize,	0, 0 },
-	{ "kbytestotal",	lprocfs_dt_rd_kbytestotal,	0, 0 },
-	{ "kbytesfree",		lprocfs_dt_rd_kbytesfree,	0, 0 },
-	{ "kbytesavail",	lprocfs_dt_rd_kbytesavail,	0, 0 },
-	{ "filestotal",		lprocfs_dt_rd_filestotal,	0, 0 },
-	{ "filesfree",		lprocfs_dt_rd_filesfree,	0, 0 },
-        { "fstype",          lprocfs_osd_rd_fstype,      0, 0 },
-        { "mntdev",          lprocfs_osd_rd_mntdev,      0, 0 },
-	{ "force_sync",      0, lprocfs_osd_wr_force_sync     },
-        { "pdo",             lprocfs_osd_rd_pdo, lprocfs_osd_wr_pdo, 0 },
-	{ "auto_scrub",      lprocfs_osd_rd_auto_scrub,
-			     lprocfs_osd_wr_auto_scrub,  0 },
-	{ "oi_scrub",	     lprocfs_osd_rd_oi_scrub,    0, 0 },
-	{ "force_sync",		0, lprocfs_osd_wr_force_sync },
-	{ "read_cache_enable",	lprocfs_osd_rd_cache, lprocfs_osd_wr_cache, 0 },
-	{ "writethrough_cache_enable",	lprocfs_osd_rd_wcache,
-					lprocfs_osd_wr_wcache, 0 },
-	{ "readcache_max_filesize",	lprocfs_osd_rd_readcache,
-					lprocfs_osd_wr_readcache, 0 },
-	{ "lma_self_repair",	lprocfs_osd_rd_lma_self_repair,
-				lprocfs_osd_wr_lma_self_repair, 0, 0 },
+LPROC_SEQ_FOPS(ldiskfs_osd_lma_self_repair);
+
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_blksize);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytestotal);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytesfree);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_kbytesavail);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_filestotal);
+LPROC_SEQ_FOPS_RO_TYPE(ldiskfs, dt_filesfree);
+
+struct lprocfs_seq_vars lprocfs_osd_obd_vars[] = {
+	{ .name	=	"blocksize",
+	  .fops	=	&ldiskfs_dt_blksize_fops	},
+	{ .name	=	"kbytestotal",
+	  .fops	=	&ldiskfs_dt_kbytestotal_fops	},
+	{ .name	=	"kbytesfree",
+	  .fops	=	&ldiskfs_dt_kbytesfree_fops	},
+	{ .name	=	"kbytesavail",
+	  .fops	=	&ldiskfs_dt_kbytesavail_fops	},
+	{ .name	=	"filestotal",
+	  .fops	=	&ldiskfs_dt_filestotal_fops	},
+	{ .name	=	"filesfree",
+	  .fops	=	&ldiskfs_dt_filesfree_fops	},
+	{ .name	=	"fstype",
+	  .fops	=	&ldiskfs_osd_fstype_fops	},
+	{ .name	=	"mntdev",
+	  .fops	=	&ldiskfs_osd_mntdev_fops	},
+	{ .name	=	"force_sync",
+	  .fops	=	&ldiskfs_osd_force_sync_fops	},
+	{ .name	=	"pdo",
+	  .fops	=	&ldiskfs_osd_pdo_fops		},
+	{ .name	=	"auto_scrub",
+	  .fops	=	&ldiskfs_osd_auto_scrub_fops	},
+	{ .name	=	"oi_scrub",
+	  .fops	=	&ldiskfs_osd_oi_scrub_fops	},
+	{ .name	=	"read_cache_enable",
+	  .fops	=	&ldiskfs_osd_cache_fops		},
+	{ .name	=	"writethrough_cache_enable",
+	  .fops	=	&ldiskfs_osd_wcache_fops	},
+	{ .name	=	"readcache_max_filesize",
+	  .fops	=	&ldiskfs_osd_readcache_fops	},
+	{ .name	=	"lma_self_repair",
+	  .fops	=	&ldiskfs_osd_lma_self_repair_fops	},
 	{ 0 }
 };
 
-struct lprocfs_vars lprocfs_osd_module_vars[] = {
-        { "num_refs",        lprocfs_rd_numrefs,     0, 0 },
-	{ "track_declares_assert",	lprocfs_osd_rd_track_declares_assert,
-					lprocfs_osd_wr_track_declares_assert,
-					0 },
-        { 0 }
+struct lprocfs_seq_vars lprocfs_osd_module_vars[] = {
+	{ .name	=	"track_declares_assert",
+	  .fops	=	&ldiskfs_osd_track_declares_assert_fops		},
+	{ 0 }
 };
 
+
+int osd_procfs_init(struct osd_device *osd, const char *name)
+{
+	struct obd_type	*type;
+	int		rc;
+	ENTRY;
+
+	if (osd->od_proc_entry)
+		RETURN(0);
+
+	/* at the moment there is no linkage between lu_type
+	 * and obd_type, so we lookup obd_type this way */
+	type = class_search_type(LUSTRE_OSD_LDISKFS_NAME);
+
+	LASSERT(name != NULL);
+	LASSERT(type != NULL);
+
+	/* Find the type procroot and add the proc entry for this device */
+	osd->od_proc_entry = lprocfs_seq_register(name, type->typ_procroot,
+						  lprocfs_osd_obd_vars,
+						  &osd->od_dt_dev);
+	if (IS_ERR(osd->od_proc_entry)) {
+		rc = PTR_ERR(osd->od_proc_entry);
+		CERROR("Error %d setting up lprocfs for %s\n",
+		       rc, name);
+		osd->od_proc_entry = NULL;
+		GOTO(out, rc);
+	}
+
+	rc = osd_stats_init(osd);
+
+	EXIT;
+out:
+	if (rc)
+		osd_procfs_fini(osd);
+	return rc;
+}
+
+int osd_procfs_fini(struct osd_device *osd)
+{
+	if (osd->od_stats)
+		lprocfs_free_stats(&osd->od_stats);
+
+	if (osd->od_proc_entry)
+		lprocfs_remove(&osd->od_proc_entry);
+	RETURN(0);
+}
 #endif
diff --git a/lustre/osd-ldiskfs/osd_scrub.c b/lustre/osd-ldiskfs/osd_scrub.c
index cce33af..1002913 100644
--- a/lustre/osd-ldiskfs/osd_scrub.c
+++ b/lustre/osd-ldiskfs/osd_scrub.c
@@ -2578,80 +2578,69 @@ static const char *scrub_param_names[] = {
 	NULL
 };
 
-static int scrub_bits_dump(char **buf, int *len, int bits, const char *names[],
+static int scrub_bits_dump(struct seq_file *m, int bits, const char *names[],
 			   const char *prefix)
 {
-	int save = *len;
 	int flag;
 	int rc;
 	int i;
 
-	rc = snprintf(*buf, *len, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
+	rc = seq_printf(m, "%s:%c", prefix, bits != 0 ? ' ' : '\n');
 	if (rc <= 0)
 		return -ENOSPC;
 
-	*buf += rc;
-	*len -= rc;
 	for (i = 0, flag = 1; bits != 0; i++, flag = 1 << i) {
 		if (flag & bits) {
 			bits &= ~flag;
-			rc = snprintf(*buf, *len, "%s%c", names[i],
-				      bits != 0 ? ',' : '\n');
+			rc = seq_printf(m, "%s%c", names[i],
+					bits != 0 ? ',' : '\n');
 			if (rc <= 0)
 				return -ENOSPC;
-
-			*buf += rc;
-			*len -= rc;
 		}
 	}
-	return save - *len;
+	return 0;
 }
 
-static int scrub_time_dump(char **buf, int *len, __u64 time, const char *prefix)
+static int scrub_time_dump(struct seq_file *m, __u64 time, const char *prefix)
 {
 	int rc;
 
 	if (time != 0)
-		rc = snprintf(*buf, *len, "%s: "LPU64" seconds\n", prefix,
+		rc = seq_printf(m, "%s: "LPU64" seconds\n", prefix,
 			      cfs_time_current_sec() - time);
 	else
-		rc = snprintf(*buf, *len, "%s: N/A\n", prefix);
+		rc = seq_printf(m, "%s: N/A\n", prefix);
 	if (rc <= 0)
 		return -ENOSPC;
 
-	*buf += rc;
-	*len -= rc;
-	return rc;
+	return 0;
 }
 
-static int scrub_pos_dump(char **buf, int *len, __u64 pos, const char *prefix)
+static int scrub_pos_dump(struct seq_file *m, __u64 pos, const char *prefix)
 {
 	int rc;
 
 	if (pos != 0)
-		rc = snprintf(*buf, *len, "%s: "LPU64"\n", prefix, pos);
+		rc = seq_printf(m, "%s: "LPU64"\n", prefix, pos);
 	else
-		rc = snprintf(*buf, *len, "%s: N/A\n", prefix);
+		rc = seq_printf(m, "%s: N/A\n", prefix);
 	if (rc <= 0)
 		return -ENOSPC;
 
-	*buf += rc;
-	*len -= rc;
 	return rc;
 }
 
-int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
+int osd_scrub_dump(struct seq_file *m,struct osd_device *dev)
 {
 	struct osd_scrub  *scrub   = &dev->od_scrub;
 	struct scrub_file *sf      = &scrub->os_file;
 	__u64		   checked;
 	__u64		   speed;
-	int		   save    = len;
 	int		   ret     = -ENOSPC;
 	int		   rc;
 
 	down_read(&scrub->os_rwsem);
-	rc = snprintf(buf, len,
+	rc = seq_printf(m,
 		      "name: OI_scrub\n"
 		      "magic: 0x%x\n"
 		      "oi_files: %d\n"
@@ -2661,51 +2650,48 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 	if (rc <= 0)
 		goto out;
 
-	buf += rc;
-	len -= rc;
-	rc = scrub_bits_dump(&buf, &len, sf->sf_flags, scrub_flags_names,
+	rc = scrub_bits_dump(m, sf->sf_flags, scrub_flags_names,
 			     "flags");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_bits_dump(&buf, &len, sf->sf_param, scrub_param_names,
+	rc = scrub_bits_dump(m, sf->sf_param, scrub_param_names,
 			     "param");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_time_dump(&buf, &len, sf->sf_time_last_complete,
+	rc = scrub_time_dump(m, sf->sf_time_last_complete,
 			     "time_since_last_completed");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_time_dump(&buf, &len, sf->sf_time_latest_start,
+	rc = scrub_time_dump(m, sf->sf_time_latest_start,
 			     "time_since_latest_start");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_time_dump(&buf, &len, sf->sf_time_last_checkpoint,
+	rc = scrub_time_dump(m, sf->sf_time_last_checkpoint,
 			     "time_since_last_checkpoint");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_pos_dump(&buf, &len, sf->sf_pos_latest_start,
+	rc = scrub_pos_dump(m, sf->sf_pos_latest_start,
 			    "latest_start_position");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_pos_dump(&buf, &len, sf->sf_pos_last_checkpoint,
+	rc = scrub_pos_dump(m, sf->sf_pos_last_checkpoint,
 			    "last_checkpoint_position");
 	if (rc < 0)
 		goto out;
 
-	rc = scrub_pos_dump(&buf, &len, sf->sf_pos_first_inconsistent,
+	rc = scrub_pos_dump(m, sf->sf_pos_first_inconsistent,
 			    "first_failure_position");
 	if (rc < 0)
 		goto out;
 
 	checked = sf->sf_items_checked + scrub->os_new_checked;
-	rc = snprintf(buf, len,
-		      "checked: "LPU64"\n"
+	rc = seq_printf(m, "checked: "LPU64"\n"
 		      "updated: "LPU64"\n"
 		      "failed: "LPU64"\n"
 		      "prior_updated: "LPU64"\n"
@@ -2718,8 +2704,6 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 	if (rc <= 0)
 		goto out;
 
-	buf += rc;
-	len -= rc;
 	speed = checked;
 	if (thread_is_running(&scrub->os_thread)) {
 		cfs_duration_t duration = cfs_time_current() -
@@ -2732,8 +2716,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 			do_div(new_checked, duration);
 		if (rtime != 0)
 			do_div(speed, rtime);
-		rc = snprintf(buf, len,
-			      "run_time: %u seconds\n"
+		rc = seq_printf(m, "run_time: %u seconds\n"
 			      "average_speed: "LPU64" objects/sec\n"
 			      "real-time_speed: "LPU64" objects/sec\n"
 			      "current_position: %u\n"
@@ -2746,8 +2729,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 	} else {
 		if (sf->sf_run_time != 0)
 			do_div(speed, sf->sf_run_time);
-		rc = snprintf(buf, len,
-			      "run_time: %u seconds\n"
+		rc = seq_printf(m, "run_time: %u seconds\n"
 			      "average_speed: "LPU64" objects/sec\n"
 			      "real-time_speed: N/A\n"
 			      "current_position: N/A\n"
@@ -2759,10 +2741,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
 	}
 	if (rc <= 0)
 		goto out;
-
-	buf += rc;
-	len -= rc;
-	ret = save - len;
+	ret = 0;
 
 out:
 	up_read(&scrub->os_rwsem);
-- 
1.8.5.3