path: root/sys-cluster/lustre/files/0016-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch

From 2110d1028da0bab44e1b3494ba4642155195a735 Mon Sep 17 00:00:00 2001
From: James Simmons <uja.ornl@gmail.com>
Date: Mon, 2 Dec 2013 12:36:06 -0500
Subject: [PATCH 16/18] LU-3319 procfs: move mdt/mds proc handling to seq_files

With 3.10 linux kernel and above proc handling now only
uses struct seq_files. This patch migrates the mdt/mds
layer proc entries over to using seq_files.

Signed-off-by: James Simmons <uja.ornl@gmail.com>
Change-Id: Icbafdcd2c2fe3959a51dda3f9c715b0ff8d95742
Signed-off-by: Alexey Shvetsov <alexxy@gentoo.org>
---
 lustre/mdt/mdt_coordinator.c      | 246 +++++++---------
 lustre/mdt/mdt_handler.c          |  16 +-
 lustre/mdt/mdt_hsm_cdt_actions.c  |   5 +-
 lustre/mdt/mdt_hsm_cdt_agent.c    |   5 +-
 lustre/mdt/mdt_hsm_cdt_requests.c |   5 +-
 lustre/mdt/mdt_internal.h         |  14 +-
 lustre/mdt/mdt_lproc.c            | 603 ++++++++++++++++++--------------------
 lustre/mdt/mdt_mds.c              |  12 +-
 8 files changed, 401 insertions(+), 505 deletions(-)

diff --git a/lustre/mdt/mdt_coordinator.c b/lustre/mdt/mdt_coordinator.c
index 3915e21..eb05bdf 100644
--- a/lustre/mdt/mdt_coordinator.c
+++ b/lustre/mdt/mdt_coordinator.c
@@ -46,7 +46,7 @@
 #include <lustre_log.h>
 #include "mdt_internal.h"
 
-static struct lprocfs_vars lprocfs_mdt_hsm_vars[];
+static struct lprocfs_seq_vars lprocfs_mdt_hsm_vars[];
 
 /**
  * get obj and HSM attributes on a fid
@@ -393,7 +393,7 @@ int hsm_cdt_procfs_init(struct mdt_device *mdt)
 	ENTRY;
 
 	/* init /proc entries, failure is not critical */
-	cdt->cdt_proc_dir = lprocfs_register("hsm",
+	cdt->cdt_proc_dir = lprocfs_seq_register("hsm",
 					     mdt2obd_dev(mdt)->obd_proc_entry,
 					     lprocfs_mdt_hsm_vars, mdt);
 	if (IS_ERR(cdt->cdt_proc_dir)) {
@@ -425,7 +425,7 @@ void  hsm_cdt_procfs_fini(struct mdt_device *mdt)
  * \param none
  * \retval var vector
  */
-struct lprocfs_vars *hsm_cdt_get_proc_vars(void)
+struct lprocfs_seq_vars *hsm_cdt_get_proc_vars(void)
 {
 	return lprocfs_mdt_hsm_vars;
 }
@@ -1769,22 +1769,17 @@ static __u64 hsm_policy_str2bit(const char *name)
  * \param hexa [IN] print mask before bit names
  * \param buffer [OUT] string
  * \param count [IN] size of buffer
- * \retval size filled in buffer
  */
-static int hsm_policy_bit2str(const __u64 mask, const bool hexa, char *buffer,
-			      int count)
+static void hsm_policy_bit2str(struct seq_file *m, const __u64 mask,
+				const bool hexa)
 {
-	int	 i, j, sz;
-	char	*ptr;
+	int	 i, j;
 	__u64	 bit;
 	ENTRY;
 
-	ptr = buffer;
-	if (hexa) {
-		sz = snprintf(buffer, count, "("LPX64") ", mask);
-		ptr += sz;
-		count -= sz;
-	}
+	if (hexa)
+		seq_printf(m, "("LPX64") ", mask);
+
 	for (i = 0; i < CDT_POLICY_SHIFT_COUNT; i++) {
 		bit = (1ULL << i);
 
@@ -1793,48 +1788,34 @@ static int hsm_policy_bit2str(const __u64 mask, const bool hexa, char *buffer,
 				break;
 		}
 		if (bit & mask)
-			sz = snprintf(ptr, count, "[%s] ",
-				      hsm_policy_names[j].name);
+			seq_printf(m, "[%s] ", hsm_policy_names[j].name);
 		else
-			sz = snprintf(ptr, count, "%s ",
-				      hsm_policy_names[j].name);
-
-		ptr += sz;
-		count -= sz;
+			seq_printf(m, "%s ", hsm_policy_names[j].name);
 	}
-	/* remove last ' ' */
-	*ptr = '\0';
-	ptr--;
-	RETURN(ptr - buffer);
 }
 
 /* methods to read/write HSM policy flags */
-static int lprocfs_rd_hsm_policy(char *page, char **start, off_t off,
-				 int count, int *eof, void *data)
+static int mdt_hsm_policy_seq_show(struct seq_file *m, void *data)
 {
-	struct mdt_device	*mdt = data;
+	struct mdt_device	*mdt = m->private;
 	struct coordinator	*cdt = &mdt->mdt_coordinator;
-	int			 sz;
 	ENTRY;
 
-	sz = hsm_policy_bit2str(cdt->cdt_policy, false, page, count);
-	page[sz] = '\n';
-	sz++;
-	page[sz] = '\0';
-	*eof = 1;
-	RETURN(sz);
+	hsm_policy_bit2str(m, cdt->cdt_policy, false);
+	RETURN(0);
 }
 
-static int lprocfs_wr_hsm_policy(struct file *file, const char *buffer,
-				 unsigned long count, void *data)
+static ssize_t
+mdt_hsm_policy_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-	struct mdt_device	*mdt = data;
+	struct seq_file		*m = file->private_data;
+	struct mdt_device	*mdt = m->private;
 	struct coordinator	*cdt = &mdt->mdt_coordinator;
 	char			*start, *token, sign;
 	char			*buf;
 	__u64			 policy;
 	__u64			 add_mask, remove_mask, set_mask;
-	int			 sz;
 	int			 rc;
 	ENTRY;
 
@@ -1867,18 +1848,10 @@ static int lprocfs_wr_hsm_policy(struct file *file, const char *buffer,
 
 		policy = hsm_policy_str2bit(token);
 		if (policy == 0) {
-			char *msg;
-
-			sz = PAGE_SIZE;
-			OBD_ALLOC(msg, sz);
-			if (!msg)
-				GOTO(out, rc = -ENOMEM);
-
-			hsm_policy_bit2str(0, false, msg, sz);
 			CWARN("%s: '%s' is unknown, "
-			      "supported policies are: %s\n", mdt_obd_name(mdt),
-			      token, msg);
-			OBD_FREE(msg, sz);
+				"supported policies are: \n", mdt_obd_name(mdt),
+				token);
+			hsm_policy_bit2str(m, 0, false);
 			GOTO(out, rc = -EINVAL);
 		}
 		switch (sign) {
@@ -1917,25 +1890,24 @@ out:
 	OBD_FREE(buf, count + 1);
 	RETURN(rc);
 }
+LPROC_SEQ_FOPS(mdt_hsm_policy);
 
 #define GENERATE_PROC_METHOD(VAR)					\
-static int lprocfs_rd_hsm_##VAR(char *page, char **start, off_t off,	\
-				int count, int *eof, void *data)	\
+static int mdt_hsm_##VAR##_seq_show(struct seq_file *m, void *data)	\
 {									\
-	struct mdt_device	*mdt = data;				\
+	struct mdt_device	*mdt = m->private;			\
 	struct coordinator	*cdt = &mdt->mdt_coordinator;		\
-	int			 sz;					\
 	ENTRY;								\
 									\
-	sz = snprintf(page, count, LPU64"\n", (__u64)cdt->VAR);		\
-	*eof = 1;							\
-	RETURN(sz);							\
+	seq_printf(m, LPU64"\n", (__u64)cdt->VAR);			\
+	RETURN(0);							\
 }									\
-static int lprocfs_wr_hsm_##VAR(struct file *file, const char *buffer,	\
-				unsigned long count, void *data)	\
+static ssize_t								\
+mdt_hsm_##VAR##_seq_write(struct file *file, const char *buffer,	\
+			  size_t count, loff_t *off)			\
 									\
 {									\
-	struct mdt_device	*mdt = data;				\
+	struct mdt_device	*mdt = ((struct seq_file *)file->private_data)->private;\
 	struct coordinator	*cdt = &mdt->mdt_coordinator;		\
 	int			 val;					\
 	int			 rc;					\
@@ -1949,7 +1921,7 @@ static int lprocfs_wr_hsm_##VAR(struct file *file, const char *buffer,	\
 		RETURN(count);						\
 	}								\
 	RETURN(-EINVAL);						\
-}
+}									\
 
 GENERATE_PROC_METHOD(cdt_loop_period)
 GENERATE_PROC_METHOD(cdt_grace_delay)
@@ -1967,10 +1939,11 @@ GENERATE_PROC_METHOD(cdt_default_archive_id)
 #define CDT_PURGE_CMD    "purge"
 #define CDT_HELP_CMD     "help"
 
-int lprocfs_wr_hsm_cdt_control(struct file *file, const char *buffer,
-			       unsigned long count, void *data)
+ssize_t
+mdt_hsm_cdt_control_seq_write(struct file *file, const char *buffer,
+			      size_t count, loff_t *off)
 {
-	struct obd_device	*obd = data;
+	struct obd_device	*obd = ((struct seq_file *)file->private_data)->private;
 	struct mdt_device	*mdt = mdt_dev(obd->obd_lu_dev);
 	struct coordinator	*cdt = &(mdt->mdt_coordinator);
 	int			 rc, usage = 0;
@@ -2024,83 +1997,71 @@ int lprocfs_wr_hsm_cdt_control(struct file *file, const char *buffer,
 	RETURN(count);
 }
 
-int lprocfs_rd_hsm_cdt_control(char *page, char **start, off_t off,
-			       int count, int *eof, void *data)
+int mdt_hsm_cdt_control_seq_show(struct seq_file *m, void *data)
 {
-	struct obd_device	*obd = data;
+	struct obd_device	*obd = m->private;
 	struct coordinator	*cdt;
-	int			 sz;
 	ENTRY;
 
 	cdt = &(mdt_dev(obd->obd_lu_dev)->mdt_coordinator);
-	*eof = 1;
 
 	if (cdt->cdt_state == CDT_INIT)
-		sz = snprintf(page, count, "init\n");
+		seq_printf(m, "init\n");
 	else if (cdt->cdt_state == CDT_RUNNING)
-		sz = snprintf(page, count, "enabled\n");
+		seq_printf(m, "enabled\n");
 	else if (cdt->cdt_state == CDT_STOPPING)
-		sz = snprintf(page, count, "stopping\n");
+		seq_printf(m, "stopping\n");
 	else if (cdt->cdt_state == CDT_STOPPED)
-		sz = snprintf(page, count, "stopped\n");
+		seq_printf(m, "stopped\n");
 	else if (cdt->cdt_state == CDT_DISABLE)
-		sz = snprintf(page, count, "disabled\n");
+		seq_printf(m, "disabled\n");
 	else
-		sz = snprintf(page, count, "unknown\n");
+		seq_printf(m, "unknown\n");
 
-	RETURN(sz);
+	RETURN(0);
 }
 
 static int
-lprocfs_rd_hsm_request_mask(char *page, char **start, off_t off,
-			    int count, int *eof, __u64 mask)
+mdt_hsm_request_mask_show(struct seq_file *m, __u64 mask)
 {
 	int i, rc = 0;
 	ENTRY;
 
 	for (i = 0; i < 8 * sizeof(mask); i++) {
 		if (mask & (1UL << i))
-			rc += snprintf(page + rc, count - rc, "%s%s",
-				       rc == 0 ? "" : " ",
-				       hsm_copytool_action2name(i));
+			rc += seq_printf(m, "%s%s", rc == 0 ? "" : " ",
+					hsm_copytool_action2name(i));
 	}
-
-	rc += snprintf(page + rc, count - rc, "\n");
+	rc += seq_printf(m, "\n");
 
 	RETURN(rc);
 }
 
 static int
-lprocfs_rd_hsm_user_request_mask(char *page, char **start, off_t off,
-				 int count, int *eof, void *data)
+mdt_hsm_user_request_mask_seq_show(struct seq_file *m, void *data)
 {
-	struct mdt_device *mdt = data;
+	struct mdt_device *mdt = m->private;
 	struct coordinator *cdt = &mdt->mdt_coordinator;
 
-	return lprocfs_rd_hsm_request_mask(page, start, off, count, eof,
-					   cdt->cdt_user_request_mask);
+	return mdt_hsm_request_mask_show(m, cdt->cdt_user_request_mask);
 }
 
 static int
-lprocfs_rd_hsm_group_request_mask(char *page, char **start, off_t off,
-				  int count, int *eof, void *data)
+mdt_hsm_group_request_mask_seq_show(struct seq_file *m, void *data)
 {
-	struct mdt_device *mdt = data;
+	struct mdt_device *mdt = m->private;
 	struct coordinator *cdt = &mdt->mdt_coordinator;
 
-	return lprocfs_rd_hsm_request_mask(page, start, off, count, eof,
-					   cdt->cdt_group_request_mask);
+	return mdt_hsm_request_mask_show(m, cdt->cdt_group_request_mask);
 }
 
 static int
-lprocfs_rd_hsm_other_request_mask(char *page, char **start, off_t off,
-				  int count, int *eof, void *data)
+mdt_hsm_other_request_mask_seq_show(struct seq_file *m, void *data)
 {
-	struct mdt_device *mdt = data;
+	struct mdt_device *mdt = m->private;
 	struct coordinator *cdt = &mdt->mdt_coordinator;
 
-	return lprocfs_rd_hsm_request_mask(page, start, off, count, eof,
-					   cdt->cdt_other_request_mask);
+	return mdt_hsm_request_mask_show(m, cdt->cdt_other_request_mask);
 }
 
 static inline enum hsm_copytool_action
@@ -2120,9 +2081,9 @@ hsm_copytool_name2action(const char *name)
 		return -1;
 }
 
-static int
-lprocfs_wr_hsm_request_mask(struct file *file, const char __user *user_buf,
-			    unsigned long user_count, __u64 *mask)
+static ssize_t
+mdt_write_hsm_request_mask(struct file *file, const char __user *user_buf,
+			    size_t user_count, __u64 *mask)
 {
 	char *buf, *pos, *name;
 	size_t buf_size;
@@ -2166,69 +2127,60 @@ out:
 	RETURN(rc);
 }
 
-static int
-lprocfs_wr_hsm_user_request_mask(struct file *file, const char __user *buf,
-				 unsigned long count, void *data)
+static ssize_t
+mdt_hsm_user_request_mask_seq_write(struct file *file, const char __user *buf,
+					size_t count, loff_t *off)
 {
-	struct mdt_device *mdt = data;
+	struct mdt_device *mdt = ((struct seq_file *)file->private_data)->private;
 	struct coordinator *cdt = &mdt->mdt_coordinator;
 
-	return lprocfs_wr_hsm_request_mask(file, buf, count,
+	return mdt_write_hsm_request_mask(file, buf, count,
 					   &cdt->cdt_user_request_mask);
 }
 
-static int
-lprocfs_wr_hsm_group_request_mask(struct file *file, const char __user *buf,
-				  unsigned long count, void *data)
+static ssize_t
+mdt_hsm_group_request_mask_seq_write(struct file *file, const char __user *buf,
+					size_t count, loff_t *off)
 {
-	struct mdt_device *mdt = data;
+	struct mdt_device *mdt = ((struct seq_file *)file->private_data)->private;
 	struct coordinator *cdt = &mdt->mdt_coordinator;
 
-	return lprocfs_wr_hsm_request_mask(file, buf, count,
+	return mdt_write_hsm_request_mask(file, buf, count,
 					   &cdt->cdt_group_request_mask);
 }
 
-static int
-lprocfs_wr_hsm_other_request_mask(struct file *file, const char __user *buf,
-				  unsigned long count, void *data)
+static ssize_t
+mdt_hsm_other_request_mask_seq_write(struct file *file, const char __user *buf,
+					size_t count, loff_t *off)
 {
-	struct mdt_device *mdt = data;
+	struct mdt_device *mdt = ((struct seq_file *)file->private_data)->private;
 	struct coordinator *cdt = &mdt->mdt_coordinator;
 
-	return lprocfs_wr_hsm_request_mask(file, buf, count,
+	return mdt_write_hsm_request_mask(file, buf, count,
 					   &cdt->cdt_other_request_mask);
 }
 
-static struct lprocfs_vars lprocfs_mdt_hsm_vars[] = {
-	{ "agents",			NULL, NULL, NULL, &mdt_hsm_agent_fops,
-					0 },
-	{ "actions",			NULL, NULL, NULL, &mdt_hsm_actions_fops,
-					0444 },
-	{ "default_archive_id",		lprocfs_rd_hsm_cdt_default_archive_id,
-					lprocfs_wr_hsm_cdt_default_archive_id,
-					NULL, NULL, 0 },
-	{ "grace_delay",		lprocfs_rd_hsm_cdt_grace_delay,
-					lprocfs_wr_hsm_cdt_grace_delay,
-					NULL, NULL, 0 },
-	{ "loop_period",		lprocfs_rd_hsm_cdt_loop_period,
-					lprocfs_wr_hsm_cdt_loop_period,
-					NULL, NULL, 0 },
-	{ "max_requests",		lprocfs_rd_hsm_cdt_max_requests,
-					lprocfs_wr_hsm_cdt_max_requests,
-					NULL, NULL, 0 },
-	{ "policy",			lprocfs_rd_hsm_policy,
-					lprocfs_wr_hsm_policy,
-					NULL, NULL, 0 },
-	{ "active_request_timeout",	lprocfs_rd_hsm_cdt_active_req_timeout,
-					lprocfs_wr_hsm_cdt_active_req_timeout,
-					NULL, NULL, 0 },
-	{ "active_requests",		NULL, NULL, NULL,
-					&mdt_hsm_active_requests_fops, 0 },
-	{ "user_request_mask",		lprocfs_rd_hsm_user_request_mask,
-					lprocfs_wr_hsm_user_request_mask, },
-	{ "group_request_mask", 	lprocfs_rd_hsm_group_request_mask,
-					lprocfs_wr_hsm_group_request_mask, },
-	{ "other_request_mask",		lprocfs_rd_hsm_other_request_mask,
-					lprocfs_wr_hsm_other_request_mask, },
+LPROC_SEQ_FOPS(mdt_hsm_cdt_loop_period);
+LPROC_SEQ_FOPS(mdt_hsm_cdt_grace_delay);
+LPROC_SEQ_FOPS(mdt_hsm_cdt_active_req_timeout);
+LPROC_SEQ_FOPS(mdt_hsm_cdt_max_requests);
+LPROC_SEQ_FOPS(mdt_hsm_cdt_default_archive_id);
+LPROC_SEQ_FOPS(mdt_hsm_user_request_mask);
+LPROC_SEQ_FOPS(mdt_hsm_group_request_mask);
+LPROC_SEQ_FOPS(mdt_hsm_other_request_mask);
+
+static struct lprocfs_seq_vars lprocfs_mdt_hsm_vars[] = {
+	{ "agents",		&mdt_hsm_agent_fops			},
+	{ "actions",		&mdt_hsm_actions_fops, NULL,	0444	},
+	{ "default_archive_id",	&mdt_hsm_cdt_default_archive_id_fops	},
+	{ "grace_delay",	&mdt_hsm_cdt_grace_delay_fops		},
+	{ "loop_period",	&mdt_hsm_cdt_loop_period_fops		},
+	{ "max_requests",	&mdt_hsm_cdt_max_requests_fops		},
+	{ "policy",		&mdt_hsm_policy_fops			},
+	{ "active_request_timeout",&mdt_hsm_cdt_active_req_timeout_fops	},
+	{ "active_requests",	&mdt_hsm_active_requests_fops		},
+	{ "user_request_mask",	&mdt_hsm_user_request_mask_fops,	},
+	{ "group_request_mask",	&mdt_hsm_group_request_mask_fops,	},
+	{ "other_request_mask",	&mdt_hsm_other_request_mask_fops,	},
 	{ 0 }
 };
diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c
index 8daf7e1..9f7d4ba 100644
--- a/lustre/mdt/mdt_handler.c
+++ b/lustre/mdt/mdt_handler.c
@@ -4508,7 +4508,6 @@ static int mdt_process_config(const struct lu_env *env,
 
 	switch (cfg->lcfg_command) {
 	case LCFG_PARAM: {
-		struct lprocfs_static_vars  lvars;
 		struct obd_device	   *obd = d->ld_obd;
 
 		/* For interoperability */
@@ -4543,14 +4542,13 @@ static int mdt_process_config(const struct lu_env *env,
 			}
 		}
 
-		lprocfs_mdt_init_vars(&lvars);
-		rc = class_process_proc_param(PARAM_MDT, lvars.obd_vars,
-					      cfg, obd);
+		rc = class_process_proc_seq_param(PARAM_MDT, obd->obd_vars,
+							cfg, obd);
 		if (rc > 0 || rc == -ENOSYS) {
 			/* is it an HSM var ? */
-			rc = class_process_proc_param(PARAM_HSM,
-						      hsm_cdt_get_proc_vars(),
-						      cfg, obd);
+			rc = class_process_proc_seq_param(PARAM_HSM,
+							hsm_cdt_get_proc_vars(),
+							cfg, obd);
 			if (rc > 0 || rc == -ENOSYS)
 				/* we don't understand; pass it on */
 				rc = next->ld_ops->ldo_process_config(env, next,
@@ -5725,7 +5723,6 @@ static struct lu_device_type mdt_device_type = {
 
 static int __init mdt_mod_init(void)
 {
-	struct lprocfs_static_vars lvars;
 	int rc;
 
 	CLASSERT(sizeof("0x0123456789ABCDEF:0x01234567:0x01234567") ==
@@ -5740,10 +5737,9 @@ static int __init mdt_mod_init(void)
 	if (rc)
 		GOTO(lu_fini, rc);
 
-	lprocfs_mdt_init_vars(&lvars);
 	rc = class_register_type(&mdt_obd_device_ops, NULL, NULL,
 #ifndef HAVE_ONLY_PROCFS_SEQ
-				lvars.module_vars,
+				NULL,
 #endif
 				LUSTRE_MDT_NAME, &mdt_device_type);
 	if (rc)
diff --git a/lustre/mdt/mdt_hsm_cdt_actions.c b/lustre/mdt/mdt_hsm_cdt_actions.c
index da7f5a9..49c6b8b 100644
--- a/lustre/mdt/mdt_hsm_cdt_actions.c
+++ b/lustre/mdt/mdt_hsm_cdt_actions.c
@@ -513,9 +513,6 @@ static int lprocfs_open_hsm_actions(struct inode *inode, struct file *file)
 	struct mdt_device		*mdt;
 	ENTRY;
 
-	if (LPROCFS_ENTRY_CHECK(PDE(inode)))
-		RETURN(-ENOENT);
-
 	rc = seq_open(file, &mdt_hsm_actions_proc_ops);
 	if (rc)
 		RETURN(rc);
@@ -532,7 +529,7 @@ static int lprocfs_open_hsm_actions(struct inode *inode, struct file *file)
 	/* mdt is saved in proc_dir_entry->data by
 	 * mdt_coordinator_procfs_init() calling lprocfs_register()
 	 */
-	mdt = (struct mdt_device *)PDE(inode)->data;
+	mdt = (struct mdt_device *)PDE_DATA(inode);
 	aai->aai_mdt = mdt;
 	s = file->private_data;
 	s->private = aai;
diff --git a/lustre/mdt/mdt_hsm_cdt_agent.c b/lustre/mdt/mdt_hsm_cdt_agent.c
index 9a9ce6d..158cced 100644
--- a/lustre/mdt/mdt_hsm_cdt_agent.c
+++ b/lustre/mdt/mdt_hsm_cdt_agent.c
@@ -621,15 +621,12 @@ static int lprocfs_open_hsm_agent(struct inode *inode, struct file *file)
 	int		 rc;
 	ENTRY;
 
-	if (LPROCFS_ENTRY_CHECK(PDE(inode)))
-		RETURN(-ENOENT);
-
 	rc = seq_open(file, &mdt_hsm_agent_proc_ops);
 	if (rc)
 		RETURN(rc);
 
 	s = file->private_data;
-	s->private = PDE(inode)->data;
+	s->private = PDE_DATA(inode);
 
 	RETURN(rc);
 }
diff --git a/lustre/mdt/mdt_hsm_cdt_requests.c b/lustre/mdt/mdt_hsm_cdt_requests.c
index 796cbea..7bbc771 100644
--- a/lustre/mdt/mdt_hsm_cdt_requests.c
+++ b/lustre/mdt/mdt_hsm_cdt_requests.c
@@ -569,15 +569,12 @@ static int lprocfs_open_hsm_active_requests(struct inode *inode,
 	int		 rc;
 	ENTRY;
 
-	if (LPROCFS_ENTRY_CHECK(PDE(inode)))
-		RETURN(-ENOENT);
-
 	rc = seq_open(file, &mdt_hsm_active_requests_proc_ops);
 	if (rc) {
 		RETURN(rc);
 	}
 	s = file->private_data;
-	s->private = PDE(inode)->data;
+	s->private = PDE_DATA(inode);
 
 	RETURN(rc);
 }
diff --git a/lustre/mdt/mdt_internal.h b/lustre/mdt/mdt_internal.h
index dd36201..43cf9eb 100644
--- a/lustre/mdt/mdt_internal.h
+++ b/lustre/mdt/mdt_internal.h
@@ -778,9 +778,6 @@ void mdt_thread_info_init(struct ptlrpc_request *req,
 void mdt_thread_info_fini(struct mdt_thread_info *mti);
 struct mdt_thread_info *tsi2mdt_info(struct tgt_session_info *tsi);
 
-extern struct lprocfs_vars lprocfs_mds_module_vars[];
-extern struct lprocfs_vars lprocfs_mds_obd_vars[];
-
 int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj,
 		     const struct md_hsm *mh);
 
@@ -913,13 +910,12 @@ int mdt_hsm_cdt_fini(struct mdt_device *mdt);
 int mdt_hsm_cdt_wakeup(struct mdt_device *mdt);
 
 /* coordinator control /proc interface */
-int lprocfs_wr_hsm_cdt_control(struct file *file, const char *buffer,
-			       unsigned long count, void *data);
-int lprocfs_rd_hsm_cdt_control(char *page, char **start, off_t off,
-			       int count, int *eof, void *data);
+ssize_t mdt_hsm_cdt_control_seq_write(struct file *file, const char *buffer,
+					size_t count, loff_t *off);
+int mdt_hsm_cdt_control_seq_show(struct seq_file *m, void *data);
 int hsm_cdt_procfs_init(struct mdt_device *mdt);
 void hsm_cdt_procfs_fini(struct mdt_device *mdt);
-struct lprocfs_vars *hsm_cdt_get_proc_vars(void);
+struct lprocfs_seq_vars *hsm_cdt_get_proc_vars(void);
 /* md_hsm helpers */
 struct mdt_object *mdt_hsm_get_md_hsm(struct mdt_thread_info *mti,
 				      const struct lu_fid *fid,
@@ -1087,8 +1083,6 @@ enum {
 };
 void mdt_counter_incr(struct ptlrpc_request *req, int opcode);
 void mdt_stats_counter_init(struct lprocfs_stats *stats);
-void lprocfs_mdt_init_vars(struct lprocfs_static_vars *lvars);
-void lprocfs_mds_init_vars(struct lprocfs_static_vars *lvars);
 int mdt_procfs_init(struct mdt_device *mdt, const char *name);
 void mdt_procfs_fini(struct mdt_device *mdt);
 void mdt_rename_counter_tally(struct mdt_thread_info *info,
diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c
index 4abb532..236b6c2 100644
--- a/lustre/mdt/mdt_lproc.c
+++ b/lustre/mdt/mdt_lproc.c
@@ -156,7 +156,6 @@ static ssize_t mdt_rename_stats_seq_write(struct file *file, const char *buf,
 
         return len;
 }
-
 LPROC_SEQ_FOPS(mdt_rename_stats);
 
 static int lproc_mdt_attach_rename_seqstat(struct mdt_device *mdt)
@@ -213,143 +212,73 @@ void mdt_rename_counter_tally(struct mdt_thread_info *info,
                               (unsigned int)ma->ma_attr.la_size);
 }
 
-int mdt_procfs_init(struct mdt_device *mdt, const char *name)
-{
-	struct obd_device		*obd = mdt2obd_dev(mdt);
-	struct lprocfs_static_vars	 lvars;
-	int				 rc;
-	ENTRY;
-
-	LASSERT(name != NULL);
-
-	lprocfs_mdt_init_vars(&lvars);
-	rc = lprocfs_obd_setup(obd, lvars.obd_vars);
-	if (rc) {
-		CERROR("%s: cannot create proc entries: rc = %d\n",
-		       mdt_obd_name(mdt), rc);
-		return rc;
-	}
-
-	rc = hsm_cdt_procfs_init(mdt);
-	if (rc) {
-		CERROR("%s: cannot create hsm proc entries: rc = %d\n",
-		       mdt_obd_name(mdt), rc);
-		return rc;
-	}
-
-	obd->obd_proc_exports_entry = proc_mkdir("exports",
-						 obd->obd_proc_entry);
-	if (obd->obd_proc_exports_entry)
-		lprocfs_add_simple(obd->obd_proc_exports_entry,
-				   "clear", lprocfs_nid_stats_clear_read,
-				   lprocfs_nid_stats_clear_write, obd, NULL);
-	rc = lprocfs_alloc_md_stats(obd, LPROC_MDT_LAST);
-	if (rc)
-		return rc;
-	mdt_stats_counter_init(obd->obd_md_stats);
-
-	rc = lprocfs_job_stats_init(obd, LPROC_MDT_LAST,
-				    mdt_stats_counter_init);
-
-	rc = lproc_mdt_attach_rename_seqstat(mdt);
-	if (rc)
-		CERROR("%s: MDT can not create rename stats rc = %d\n",
-		       mdt_obd_name(mdt), rc);
-
-	RETURN(rc);
-}
-
-void mdt_procfs_fini(struct mdt_device *mdt)
-{
-	struct obd_device *obd = mdt2obd_dev(mdt);
-
-	if (obd->obd_proc_exports_entry != NULL) {
-		lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
-		obd->obd_proc_exports_entry = NULL;
-	}
-
-	lprocfs_free_per_client_stats(obd);
-	hsm_cdt_procfs_fini(mdt);
-	lprocfs_obd_cleanup(obd);
-	lprocfs_free_md_stats(obd);
-	lprocfs_free_obd_stats(obd);
-	lprocfs_job_stats_fini(obd);
-}
-
-static int lprocfs_rd_identity_expire(char *page, char **start, off_t off,
-                                      int count, int *eof, void *data)
+static int mdt_identity_expire_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        *eof = 1;
-        return snprintf(page, count, "%u\n",
-                        mdt->mdt_identity_cache->uc_entry_expire);
+	return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire);
 }
 
-static int lprocfs_wr_identity_expire(struct file *file, const char *buffer,
-                                      unsigned long count, void *data)
+static ssize_t
+mdt_identity_expire_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-        int rc, val;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	int rc, val;
 
-        rc = lprocfs_write_helper(buffer, count, &val);
-        if (rc)
-                return rc;
+	rc = lprocfs_write_helper(buffer, count, &val);
+	if (rc)
+		return rc;
 
-        mdt->mdt_identity_cache->uc_entry_expire = val;
-        return count;
+	mdt->mdt_identity_cache->uc_entry_expire = val;
+	return count;
 }
+LPROC_SEQ_FOPS(mdt_identity_expire);
 
-static int lprocfs_rd_identity_acquire_expire(char *page, char **start,
-                                              off_t off, int count, int *eof,
-                                              void *data)
+static int mdt_identity_acquire_expire_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        *eof = 1;
-        return snprintf(page, count, "%u\n",
-                        mdt->mdt_identity_cache->uc_acquire_expire);
+	return seq_printf(m,"%u\n", mdt->mdt_identity_cache->uc_acquire_expire);
 }
 
-static int lprocfs_wr_identity_acquire_expire(struct file *file,
-                                              const char *buffer,
-                                              unsigned long count,
-                                              void *data)
+static ssize_t
+mdt_identity_acquire_expire_seq_write(struct file *file, const char *buffer,
+					size_t count, loff_t *off)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-        int rc, val;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	int rc, val;
 
-        rc = lprocfs_write_helper(buffer, count, &val);
-        if (rc)
-                return rc;
+	rc = lprocfs_write_helper(buffer, count, &val);
+	if (rc)
+		return rc;
 
-        mdt->mdt_identity_cache->uc_acquire_expire = val;
-        return count;
+	mdt->mdt_identity_cache->uc_acquire_expire = val;
+	return count;
 }
+LPROC_SEQ_FOPS(mdt_identity_acquire_expire);
 
-static int lprocfs_rd_identity_upcall(char *page, char **start, off_t off,
-                                      int count, int *eof, void *data)
+static int mdt_identity_upcall_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-        struct upcall_cache *hash = mdt->mdt_identity_cache;
-        int len;
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct upcall_cache *hash = mdt->mdt_identity_cache;
 
-	*eof = 1;
 	read_lock(&hash->uc_upcall_rwlock);
-	len = snprintf(page, count, "%s\n", hash->uc_upcall);
+	seq_printf(m, "%s\n", hash->uc_upcall);
 	read_unlock(&hash->uc_upcall_rwlock);
-	return len;
+	return 0;
 }
 
-static int lprocfs_wr_identity_upcall(struct file *file, const char *buffer,
-				      unsigned long count, void *data)
+static ssize_t
+mdt_identity_upcall_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-	struct obd_device	*obd = data;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
 	struct mdt_device	*mdt = mdt_dev(obd->obd_lu_dev);
 	struct upcall_cache	*hash = mdt->mdt_identity_cache;
 	int			 rc;
@@ -388,11 +317,13 @@ static int lprocfs_wr_identity_upcall(struct file *file, const char *buffer,
 		OBD_FREE(kernbuf, count + 1);
 	RETURN(rc);
 }
+LPROC_SEQ_FOPS(mdt_identity_upcall);
 
-static int lprocfs_wr_identity_flush(struct file *file, const char *buffer,
-                                     unsigned long count, void *data)
+static ssize_t
+lprocfs_identity_flush_seq_write(struct file *file, const char *buffer,
+				 size_t count, void *data)
 {
-        struct obd_device *obd = data;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
         struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
         int rc, uid;
 
@@ -403,11 +334,13 @@ static int lprocfs_wr_identity_flush(struct file *file, const char *buffer,
         mdt_flush_identity(mdt->mdt_identity_cache, uid);
         return count;
 }
+LPROC_SEQ_FOPS_WO_TYPE(mdt, identity_flush);
 
-static int lprocfs_wr_identity_info(struct file *file, const char *buffer,
-				    unsigned long count, void *data)
+static ssize_t
+lprocfs_identity_info_seq_write(struct file *file, const char *buffer,
+				size_t count, void *data)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	struct identity_downcall_data *param;
 	int size = sizeof(*param), rc, checked = 0;
@@ -468,23 +401,24 @@ out:
 
 	return rc ? rc : count;
 }
+LPROC_SEQ_FOPS_WO_TYPE(mdt, identity_info);
 
 /* for debug only */
-static int lprocfs_rd_capa(char *page, char **start, off_t off,
-                           int count, int *eof, void *data)
+static int mdt_capa_seq_show(struct seq_file *m, void *data)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return snprintf(page, count, "capability on: %s %s\n",
+	return seq_printf(m, "capability on: %s %s\n",
 			mdt->mdt_lut.lut_oss_capa ? "oss" : "",
 			mdt->mdt_lut.lut_mds_capa ? "mds" : "");
 }
 
-static int lprocfs_wr_capa(struct file *file, const char *buffer,
-			   unsigned long count, void *data)
+static ssize_t
+mdt_capa_seq_write(struct file *file, const char *buffer,
+			size_t count, loff_t *off)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	int val, rc;
 
@@ -521,64 +455,65 @@ static int lprocfs_wr_capa(struct file *file, const char *buffer,
 		      mdt->mdt_lut.lut_oss_capa ? "enabled" : "disabled");
 	return count;
 }
+LPROC_SEQ_FOPS(mdt_capa);
 
-static int lprocfs_rd_capa_count(char *page, char **start, off_t off,
-                                 int count, int *eof, void *data)
+static int mdt_capa_count_seq_show(struct seq_file *m, void *data)
 {
-        return snprintf(page, count, "%d %d\n",
-                        capa_count[CAPA_SITE_CLIENT],
-                        capa_count[CAPA_SITE_SERVER]);
+	return seq_printf(m, "%d %d\n", capa_count[CAPA_SITE_CLIENT],
+			  capa_count[CAPA_SITE_SERVER]);
 }
+LPROC_SEQ_FOPS_RO(mdt_capa_count);
 
-static int lprocfs_rd_site_stats(char *page, char **start, off_t off,
-                                 int count, int *eof, void *data)
+static int mdt_site_stats_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        return lu_site_stats_print(mdt_lu_site(mdt), page, count);
+	return lu_site_stats_seq_print(mdt_lu_site(mdt), m);
 }
+LPROC_SEQ_FOPS_RO(mdt_site_stats);
 
-static int lprocfs_rd_capa_timeout(char *page, char **start, off_t off,
-                                   int count, int *eof, void *data)
+static int mdt_capa_timeout_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        return snprintf(page, count, "%lu\n", mdt->mdt_capa_timeout);
+	return seq_printf(m, "%lu\n", mdt->mdt_capa_timeout);
 }
 
-static int lprocfs_wr_capa_timeout(struct file *file, const char *buffer,
-                                   unsigned long count, void *data)
+static ssize_t
+mdt_capa_timeout_seq_write(struct file *file, const char *buffer,
+			   size_t count, loff_t *off)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-        int val, rc;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	int val, rc;
 
-        rc = lprocfs_write_helper(buffer, count, &val);
-        if (rc)
-                return rc;
+	rc = lprocfs_write_helper(buffer, count, &val);
+	if (rc)
+		return rc;
 
-        mdt->mdt_capa_timeout = (unsigned long)val;
-        mdt->mdt_capa_conf = 1;
-        return count;
+	mdt->mdt_capa_timeout = (unsigned long)val;
+	mdt->mdt_capa_conf = 1;
+	return count;
 }
+LPROC_SEQ_FOPS(mdt_capa_timeout);
 
-static int lprocfs_rd_ck_timeout(char *page, char **start, off_t off, int count,
-                                 int *eof, void *data)
+static int mdt_ck_timeout_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        return snprintf(page, count, "%lu\n", mdt->mdt_ck_timeout);
+	return seq_printf(m, "%lu\n", mdt->mdt_ck_timeout);
 }
 
-static int lprocfs_wr_ck_timeout(struct file *file, const char *buffer,
-                                 unsigned long count, void *data)
+static ssize_t
+mdt_ck_timeout_seq_write(struct file *file, const char *buffer,
+			 size_t count, loff_t *off)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-        int val, rc;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	int val, rc;
 
         rc = lprocfs_write_helper(buffer, count, &val);
         if (rc)
@@ -588,11 +523,13 @@ static int lprocfs_wr_ck_timeout(struct file *file, const char *buffer,
         mdt->mdt_capa_conf = 1;
         return count;
 }
+LPROC_SEQ_FOPS(mdt_ck_timeout);
 
 #define BUFLEN (UUID_MAX + 4)
 
-static int lprocfs_mdt_wr_evict_client(struct file *file, const char *buffer,
-                                       unsigned long count, void *data)
+static ssize_t
+lprocfs_mds_evict_client_seq_write(struct file *file, const char *buffer,
+				   size_t count, loff_t *off)
 {
         char *kbuf;
         char *tmpbuf;
@@ -614,7 +551,7 @@ static int lprocfs_mdt_wr_evict_client(struct file *file, const char *buffer,
         tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count));
 
         if (strncmp(tmpbuf, "nid:", 4) != 0) {
-                count = lprocfs_wr_evict_client(file, buffer, count, data);
+		count = lprocfs_evict_client_seq_write(file, buffer, count, off);
                 goto out;
         }
 
@@ -627,21 +564,21 @@ out:
 
 #undef BUFLEN
 
-static int lprocfs_rd_sec_level(char *page, char **start, off_t off,
-                                int count, int *eof, void *data)
+static int mdt_sec_level_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return snprintf(page, count, "%d\n", mdt->mdt_lut.lut_sec_level);
+	return seq_printf(m, "%d\n", mdt->mdt_lut.lut_sec_level);
 }
 
-static int lprocfs_wr_sec_level(struct file *file, const char *buffer,
-                                unsigned long count, void *data)
+static ssize_t
+mdt_sec_level_seq_write(struct file *file, const char *buffer,
+			size_t count, loff_t *off)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-        int val, rc;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	int val, rc;
 
         rc = lprocfs_write_helper(buffer, count, &val);
         if (rc)
@@ -659,22 +596,23 @@ static int lprocfs_wr_sec_level(struct file *file, const char *buffer,
 	mdt->mdt_lut.lut_sec_level = val;
 	return count;
 }
+LPROC_SEQ_FOPS(mdt_sec_level);
 
-static int lprocfs_rd_cos(char *page, char **start, off_t off,
-                              int count, int *eof, void *data)
+static int mdt_cos_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        return snprintf(page, count, "%u\n", mdt_cos_is_enabled(mdt));
+	return seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt));
 }
 
-static int lprocfs_wr_cos(struct file *file, const char *buffer,
-                                  unsigned long count, void *data)
+static ssize_t
+mdt_cos_seq_write(struct file *file, const char *buffer,
+		  size_t count, loff_t *off)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-        int val, rc;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	int val, rc;
 
         rc = lprocfs_write_helper(buffer, count, &val);
         if (rc)
@@ -682,15 +620,15 @@ static int lprocfs_wr_cos(struct file *file, const char *buffer,
         mdt_enable_cos(mdt, val);
         return count;
 }
+LPROC_SEQ_FOPS(mdt_cos);
 
-static int lprocfs_rd_root_squash(char *page, char **start, off_t off,
-                                  int count, int *eof, void *data)
+static int mdt_root_squash_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        return snprintf(page, count, "%u:%u\n", mdt->mdt_squash_uid,
-                        mdt->mdt_squash_gid);
+	return seq_printf(m, "%u:%u\n", mdt->mdt_squash_uid,
+			  mdt->mdt_squash_gid);
 }
 
 static int safe_strtoul(const char *str, char **endp, unsigned long *res)
@@ -708,10 +646,11 @@ static int safe_strtoul(const char *str, char **endp, unsigned long *res)
         return 0;
 }
 
-static int lprocfs_wr_root_squash(struct file *file, const char *buffer,
-				  unsigned long count, void *data)
+static ssize_t
+mdt_root_squash_seq_write(struct file *file, const char *buffer,
+			  size_t count, loff_t *off)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	int rc;
 	char kernbuf[50], *tmp, *end, *errmsg;
@@ -765,22 +704,23 @@ failed:
 	      mdt_obd_name(mdt), buffer, errmsg, rc);
 	RETURN(rc);
 }
+LPROC_SEQ_FOPS(mdt_root_squash);
 
-static int lprocfs_rd_nosquash_nids(char *page, char **start, off_t off,
-                                    int count, int *eof, void *data)
+static int mdt_nosquash_nids_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        if (mdt->mdt_nosquash_str)
-                return snprintf(page, count, "%s\n", mdt->mdt_nosquash_str);
-        return snprintf(page, count, "NONE\n");
+	if (mdt->mdt_nosquash_str)
+		return seq_printf(m, "%s\n", mdt->mdt_nosquash_str);
+	return seq_printf(m, "NONE\n");
 }
 
-static int lprocfs_wr_nosquash_nids(struct file *file, const char *buffer,
-				    unsigned long count, void *data)
+static ssize_t
+mdt_nosquash_nids_seq_write(struct file *file, const char *buffer,
+			    size_t count, loff_t *off)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	int rc;
 	char *kernbuf, *errmsg;
@@ -842,25 +782,26 @@ failed:
 		OBD_FREE(kernbuf, count + 1);
 	RETURN(rc);
 }
+LPROC_SEQ_FOPS(mdt_nosquash_nids);
 
-static int lprocfs_rd_mdt_som(char *page, char **start, off_t off,
-                              int count, int *eof, void *data)
+static int mdt_som_seq_show(struct seq_file *m, void *data)
 {
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_device *obd = m->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-        return snprintf(page, count, "%sabled\n",
-                        mdt->mdt_som_conf ? "en" : "dis");
+	return seq_printf(m, "%sabled\n",
+			  mdt->mdt_som_conf ? "en" : "dis");
 }
 
-static int lprocfs_wr_mdt_som(struct file *file, const char *buffer,
-                              unsigned long count, void *data)
+static ssize_t
+mdt_som_seq_write(struct file *file, const char *buffer,
+		  size_t count, loff_t *off)
 {
-        struct obd_export *exp;
-        struct obd_device *obd = data;
-        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-        char kernbuf[16];
-        unsigned long val = 0;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
+	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
+	struct obd_export *exp;
+	char kernbuf[16];
+	unsigned long val = 0;
 
         if (count > (sizeof(kernbuf) - 1))
                 return -EINVAL;
@@ -902,20 +843,21 @@ static int lprocfs_wr_mdt_som(struct file *file, const char *buffer,
 
         return count;
 }
+LPROC_SEQ_FOPS(mdt_som);
 
-static int lprocfs_rd_enable_remote_dir(char *page, char **start, off_t off,
-					int count, int *eof, void *data)
+static int mdt_enable_remote_dir_seq_show(struct seq_file *m, void *data)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return snprintf(page, count, "%u\n", mdt->mdt_enable_remote_dir);
+	return seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir);
 }
 
-static int lprocfs_wr_enable_remote_dir(struct file *file, const char *buffer,
-					unsigned long count, void *data)
+static ssize_t
+mdt_enable_remote_dir_seq_write(struct file *file, const char *buffer,
+				size_t count, loff_t *off)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	__u32 val;
 	int rc;
@@ -930,22 +872,22 @@ static int lprocfs_wr_enable_remote_dir(struct file *file, const char *buffer,
 	mdt->mdt_enable_remote_dir = val;
 	return count;
 }
+LPROC_SEQ_FOPS(mdt_enable_remote_dir);
 
-static int lprocfs_rd_enable_remote_dir_gid(char *page, char **start, off_t off,
-					    int count, int *eof, void *data)
+static int mdt_enable_remote_dir_gid_seq_show(struct seq_file *m, void *data)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = m->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-	return snprintf(page, count, "%d\n",
-			(int)mdt->mdt_enable_remote_dir_gid);
+	return seq_printf(m, "%d\n",
+			  (int)mdt->mdt_enable_remote_dir_gid);
 }
 
-static int lprocfs_wr_enable_remote_dir_gid(struct file *file,
-					    const char *buffer,
-					    unsigned long count, void *data)
+static ssize_t
+mdt_enable_remote_dir_gid_seq_write(struct file *file, const char *buffer,
+				    size_t count, loff_t *off)
 {
-	struct obd_device *obd = data;
+	struct obd_device *obd = ((struct seq_file *)file->private_data)->private;
 	struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 	__u32 val;
 	int rc;
@@ -957,97 +899,46 @@ static int lprocfs_wr_enable_remote_dir_gid(struct file *file,
 	mdt->mdt_enable_remote_dir_gid = val;
 	return count;
 }
-
-static struct lprocfs_vars lprocfs_mdt_obd_vars[] = {
-	{ "uuid",			lprocfs_rd_uuid, NULL,
-					NULL, NULL, 0 },
-	{ "recovery_status",		lprocfs_obd_rd_recovery_status, NULL,
-					NULL, NULL, 0 },
-	{ "num_exports",		lprocfs_rd_num_exports,	NULL,
-					NULL, NULL, 0 },
-	{ "identity_expire",		lprocfs_rd_identity_expire,
-					lprocfs_wr_identity_expire,
-					NULL, NULL, 0 },
-	{ "identity_acquire_expire",    lprocfs_rd_identity_acquire_expire,
-					lprocfs_wr_identity_acquire_expire,
-					NULL, NULL, 0 },
-	{ "identity_upcall",		lprocfs_rd_identity_upcall,
-					lprocfs_wr_identity_upcall,
-					NULL, NULL, 0 },
-	{ "identity_flush",		NULL, lprocfs_wr_identity_flush,
-					NULL, NULL, 0 },
-	{ "identity_info",		NULL, lprocfs_wr_identity_info,
-					NULL, NULL, 0 },
-	{ "capa",			lprocfs_rd_capa,
-					lprocfs_wr_capa,
-					NULL, NULL, 0 },
-	{ "capa_timeout",		lprocfs_rd_capa_timeout,
-					lprocfs_wr_capa_timeout,
-					NULL, NULL, 0 },
-	{ "capa_key_timeout",		lprocfs_rd_ck_timeout,
-					lprocfs_wr_ck_timeout,
-					NULL, NULL, 0 },
-	{ "capa_count",			lprocfs_rd_capa_count, NULL,
-					NULL, NULL, 0 },
-	{ "site_stats",			lprocfs_rd_site_stats, NULL,
-					NULL, NULL, 0 },
-	{ "evict_client",		NULL, lprocfs_mdt_wr_evict_client,
-					NULL, NULL, 0 },
-	{ "hash_stats",			lprocfs_obd_rd_hash, NULL,
-					NULL, NULL, 0 },
-	{ "sec_level",			lprocfs_rd_sec_level,
-					lprocfs_wr_sec_level,
-					NULL, NULL, 0 },
-	{ "commit_on_sharing",		lprocfs_rd_cos, lprocfs_wr_cos,
-					NULL, NULL, 0 },
-	{ "root_squash",		lprocfs_rd_root_squash,
-					lprocfs_wr_root_squash,
-					NULL, NULL, 0 },
-	{ "nosquash_nids",		lprocfs_rd_nosquash_nids,
-					lprocfs_wr_nosquash_nids,
-					NULL, NULL, 0 },
-	{ "som",			lprocfs_rd_mdt_som,
-					lprocfs_wr_mdt_som,
-					NULL, NULL, 0 },
-	{ "instance",			lprocfs_target_rd_instance, NULL,
-					NULL, NULL, 0},
-	{ "ir_factor",			lprocfs_obd_rd_ir_factor,
-					lprocfs_obd_wr_ir_factor,
-					NULL, NULL, 0 },
-	{ "job_cleanup_interval",       lprocfs_rd_job_interval,
-					lprocfs_wr_job_interval,
-					NULL, NULL, 0 },
-	{ "enable_remote_dir",		lprocfs_rd_enable_remote_dir,
-					lprocfs_wr_enable_remote_dir,
-					NULL, NULL, 0},
-	{ "enable_remote_dir_gid",	lprocfs_rd_enable_remote_dir_gid,
-					lprocfs_wr_enable_remote_dir_gid,
-					NULL, NULL, 0},
-	{ "hsm_control",		lprocfs_rd_hsm_cdt_control,
-					lprocfs_wr_hsm_cdt_control,
-					NULL, NULL, 0 },
-	{ 0 }
-};
-
-static struct lprocfs_vars lprocfs_mdt_module_vars[] = {
-	{ "num_refs",			lprocfs_rd_numrefs, NULL,
-					NULL, NULL, 0 },
-        { 0 }
-};
-
-void lprocfs_mdt_init_vars(struct lprocfs_static_vars *lvars)
-{
-	lvars->module_vars  = lprocfs_mdt_module_vars;
-	lvars->obd_vars     = lprocfs_mdt_obd_vars;
-}
-
-struct lprocfs_vars lprocfs_mds_obd_vars[] = {
-	{ "uuid",	lprocfs_rd_uuid, NULL, NULL, NULL, 0 },
-	{ 0 }
-};
-
-struct lprocfs_vars lprocfs_mds_module_vars[] = {
-	{ "num_refs",	lprocfs_rd_numrefs, NULL, NULL, NULL, 0 },
+LPROC_SEQ_FOPS(mdt_enable_remote_dir_gid);
+
+LPROC_SEQ_FOPS_RO_TYPE(mdt, uuid);
+LPROC_SEQ_FOPS_RO_TYPE(mdt, recovery_status);
+LPROC_SEQ_FOPS_RO_TYPE(mdt, num_exports);
+LPROC_SEQ_FOPS_RO_TYPE(mdt, target_instance);
+LPROC_SEQ_FOPS_RO_TYPE(mdt, hash);
+LPROC_SEQ_FOPS_WO_TYPE(mdt, mds_evict_client);
+LPROC_SEQ_FOPS_RW_TYPE(mdt, job_interval);
+LPROC_SEQ_FOPS_RW_TYPE(mdt, ir_factor);
+LPROC_SEQ_FOPS_RW_TYPE(mdt, nid_stats_clear);
+LPROC_SEQ_FOPS(mdt_hsm_cdt_control);
+
+static struct lprocfs_seq_vars lprocfs_mdt_obd_vars[] = {
+	{ "uuid",			&mdt_uuid_fops			},
+	{ "recovery_status",		&mdt_recovery_status_fops	},
+	{ "num_exports",		&mdt_num_exports_fops		},
+	{ "identity_expire",		&mdt_identity_expire_fops	},
+	{ "identity_acquire_expire",	&mdt_identity_acquire_expire_fops },
+	{ "identity_upcall",		&mdt_identity_upcall_fops	},
+	{ "identity_flush",		&mdt_identity_flush_fops	},
+	{ "identity_info",		&mdt_identity_info_fops		},
+	{ "capa",			&mdt_capa_fops			},
+	{ "capa_timeout",		&mdt_capa_timeout_fops		},
+	{ "capa_key_timeout",		&mdt_ck_timeout_fops		},
+	{ "capa_count",			&mdt_capa_count_fops		},
+	{ "site_stats",			&mdt_site_stats_fops		},
+	{ "evict_client",		&mdt_mds_evict_client_fops	},
+	{ "hash_stats",			&mdt_hash_fops			},
+	{ "sec_level",			&mdt_sec_level_fops		},
+	{ "commit_on_sharing",		&mdt_cos_fops			},
+	{ "root_squash",		&mdt_root_squash_fops		},
+	{ "nosquash_nids",		&mdt_nosquash_nids_fops		},
+	{ "som",			&mdt_som_fops			},
+	{ "instance",			&mdt_target_instance_fops	},
+	{ "ir_factor",			&mdt_ir_factor_fops		},
+	{ "job_cleanup_interval",	&mdt_job_interval_fops		},
+	{ "enable_remote_dir",		&mdt_enable_remote_dir_fops	},
+	{ "enable_remote_dir_gid",	&mdt_enable_remote_dir_gid_fops	},
+	{ "hsm_control",		&mdt_hsm_cdt_control_fops	},
 	{ 0 }
 };
 
@@ -1087,3 +978,67 @@ void mdt_stats_counter_init(struct lprocfs_stats *stats)
         lprocfs_counter_init(stats, LPROC_MDT_CROSSDIR_RENAME, 0,
                              "crossdir_rename", "reqs");
 }
+
+int mdt_procfs_init(struct mdt_device *mdt, const char *name)
+{
+	struct obd_device		*obd = mdt2obd_dev(mdt);
+	int				 rc;
+	ENTRY;
+
+	LASSERT(name != NULL);
+
+	obd->obd_vars = lprocfs_mdt_obd_vars;
+	rc = lprocfs_seq_obd_setup(obd);
+	if (rc) {
+		CERROR("%s: cannot create proc entries: rc = %d\n",
+			mdt_obd_name(mdt), rc);
+		return rc;
+	}
+
+	rc = hsm_cdt_procfs_init(mdt);
+	if (rc) {
+		CERROR("%s: cannot create hsm proc entries: rc = %d\n",
+			mdt_obd_name(mdt), rc);
+		return rc;
+	}
+
+	obd->obd_proc_exports_entry = proc_mkdir("exports",
+						 obd->obd_proc_entry);
+	if (obd->obd_proc_exports_entry)
+		lprocfs_add_simple(obd->obd_proc_exports_entry, "clear",
+#ifndef HAVE_ONLY_PROCFS_SEQ
+				   NULL, NULL,
+#endif
+				   obd, &mdt_nid_stats_clear_fops);
+	rc = lprocfs_alloc_md_stats(obd, LPROC_MDT_LAST);
+	if (rc)
+		return rc;
+	mdt_stats_counter_init(obd->obd_md_stats);
+
+	rc = lprocfs_job_stats_init(obd, LPROC_MDT_LAST,
+				    mdt_stats_counter_init);
+
+	rc = lproc_mdt_attach_rename_seqstat(mdt);
+	if (rc)
+		CERROR("%s: MDT can not create rename stats rc = %d\n",
+		       mdt_obd_name(mdt), rc);
+
+	RETURN(rc);
+}
+
+void mdt_procfs_fini(struct mdt_device *mdt)
+{
+	struct obd_device *obd = mdt2obd_dev(mdt);
+
+	if (obd->obd_proc_exports_entry != NULL) {
+		lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry);
+		obd->obd_proc_exports_entry = NULL;
+	}
+
+	lprocfs_free_per_client_stats(obd);
+	hsm_cdt_procfs_fini(mdt);
+	lprocfs_obd_cleanup(obd);
+	lprocfs_free_md_stats(obd);
+	lprocfs_free_obd_stats(obd);
+	lprocfs_job_stats_fini(obd);
+}
diff --git a/lustre/mdt/mdt_mds.c b/lustre/mdt/mdt_mds.c
index 367f659..4fa66c3 100644
--- a/lustre/mdt/mdt_mds.c
+++ b/lustre/mdt/mdt_mds.c
@@ -464,6 +464,13 @@ static struct lu_device *mds_device_free(const struct lu_env *env,
 	RETURN(NULL);
 }
 
+LPROC_SEQ_FOPS_RO_TYPE(mds, uuid);
+
+static struct lprocfs_seq_vars lprocfs_mds_obd_vars[] = {
+	{ "uuid",	&mds_uuid_fops  },
+	{ 0 }
+};
+
 static struct lu_device *mds_device_alloc(const struct lu_env *env,
 					  struct lu_device_type *t,
 					  struct lustre_cfg *cfg)
@@ -487,7 +494,8 @@ static struct lu_device *mds_device_alloc(const struct lu_env *env,
 	/* set this lu_device to obd, because error handling need it */
 	obd->obd_lu_dev = l;
 
-	rc = lprocfs_obd_setup(obd, lprocfs_mds_obd_vars);
+	obd->obd_vars = lprocfs_mds_obd_vars;
+	rc = lprocfs_seq_obd_setup(obd);
 	if (rc != 0) {
 		mds_device_free(env, l);
 		l = ERR_PTR(rc);
@@ -541,7 +549,7 @@ int mds_mod_init(void)
 
 	return class_register_type(&mds_obd_device_ops, NULL, NULL,
 #ifndef HAVE_ONLY_PROCFS_SEQ
-					lprocfs_mds_module_vars,
+					NULL,
 #endif
 					LUSTRE_MDS_NAME, &mds_device_type);
 }
-- 
1.8.5.1