1 files changed, 808 insertions, 0 deletions

diff --git a/sys-cluster/lustre/files/0010-LU-3319-procfs-update-ldiskfs-proc-handling-to-seq_f.patch b/sys-cluster/lustre/files/0010-LU-3319-procfs-update-ldiskfs-proc-handling-to-seq_f.patch
new file mode 100644
index 000000000..acfa04f0f
--- /dev/null
+++ b/sys-cluster/lustre/files/0010-LU-3319-procfs-update-ldiskfs-proc-handling-to-seq_f.patch
@@ -0,0 +1,808 @@
+From 5a0b800373ce5e05f6ac64686e6381f7d2706044 Mon Sep 17 00:00:00 2001
+From: James Simmons <uja.ornl@gmail.com>
+Date: Fri, 31 Jan 2014 10:38:14 -0500
+Subject: [PATCH 10/13] LU-3319 procfs: update ldiskfs proc handling to
+ seq_files
+
+Migrate all ldiskfs proc handling to using strictly
+seq_files.
+
+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    | 338 ++++++++++++++++++++------------------
+ lustre/osd-ldiskfs/osd_scrub.c    |  73 +++-----
+ 5 files changed, 222 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..67f3423 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,104 @@ 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);
++		osd->od_proc_entry = NULL;
++	}
++	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
+