aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to 'sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch')
-rw-r--r--sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch1553
1 files changed, 1553 insertions, 0 deletions
diff --git a/sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch b/sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch
new file mode 100644
index 000000000..a6a425b5b
--- /dev/null
+++ b/sys-cluster/lustre/files/0008-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch
@@ -0,0 +1,1553 @@
+From 1013b4b997343de8530c4d4ef5380220d57f155a Mon Sep 17 00:00:00 2001
+From: James Simmons <uja.ornl@gmail.com>
+Date: Sun, 9 Feb 2014 11:04:31 -0500
+Subject: [PATCH 08/12] 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
+---
+ lustre/mdt/mdt_coordinator.c | 259 +++++++--------
+ 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 | 639 ++++++++++++++++++--------------------
+ lustre/mdt/mdt_mds.c | 12 +-
+ 8 files changed, 442 insertions(+), 513 deletions(-)
+
+diff --git a/lustre/mdt/mdt_coordinator.c b/lustre/mdt/mdt_coordinator.c
+index 037bcbd..9bbcbd4 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;
+ }
+@@ -1786,22 +1786,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);
+
+@@ -1810,48 +1805,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;
+
+@@ -1884,18 +1865,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) {
+@@ -1934,25 +1907,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; \
+@@ -1966,7 +1938,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)
+@@ -1984,10 +1956,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;
+@@ -2041,83 +2014,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
+@@ -2137,9 +2098,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;
+@@ -2183,69 +2144,73 @@ 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[] = {
++ { .name = "agents",
++ .fops = &mdt_hsm_agent_fops },
++ { .name = "actions",
++ .fops = &mdt_hsm_actions_fops,
++ .proc_mode = 0444 },
++ { .name = "default_archive_id",
++ .fops = &mdt_hsm_cdt_default_archive_id_fops },
++ { .name = "grace_delay",
++ .fops = &mdt_hsm_cdt_grace_delay_fops },
++ { .name = "loop_period",
++ .fops = &mdt_hsm_cdt_loop_period_fops },
++ { .name = "max_requests",
++ .fops = &mdt_hsm_cdt_max_requests_fops },
++ { .name = "policy",
++ .fops = &mdt_hsm_policy_fops },
++ { .name = "active_request_timeout",
++ .fops = &mdt_hsm_cdt_active_req_timeout_fops },
++ { .name = "active_requests",
++ .fops = &mdt_hsm_active_requests_fops },
++ { .name = "user_request_mask",
++ .fops = &mdt_hsm_user_request_mask_fops, },
++ { .name = "group_request_mask",
++ .fops = &mdt_hsm_group_request_mask_fops, },
++ { .name = "other_request_mask",
++ .fops = &mdt_hsm_other_request_mask_fops, },
+ { 0 }
+ };
+diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c
+index 064fef1..c850356 100644
+--- a/lustre/mdt/mdt_handler.c
++++ b/lustre/mdt/mdt_handler.c
+@@ -4539,7 +4539,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 */
+@@ -4574,14 +4573,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,
+@@ -5762,7 +5760,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") ==
+@@ -5777,10 +5774,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 1300861..3125dcc 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 d548988..e30d78d 100644
+--- a/lustre/mdt/mdt_internal.h
++++ b/lustre/mdt/mdt_internal.h
+@@ -784,9 +784,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);
+
+@@ -919,13 +916,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,
+@@ -1065,8 +1061,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);
+
+diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c
+index 0ee5148..658f00d 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)
++static int mdt_identity_expire_seq_show(struct seq_file *m, void *data)
+ {
+- 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)
+-{
+- 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;
+@@ -415,7 +348,7 @@ static int lprocfs_wr_identity_info(struct file *file, const char *buffer,
+ again:
+ if (count < size) {
+ CERROR("%s: invalid data count = %lu, size = %d\n",
+- mdt_obd_name(mdt), count, size);
++ mdt_obd_name(mdt), (unsigned long) count, size);
+ return -EINVAL;
+ }
+
+@@ -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,72 @@ 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[] = {
++ { .name = "uuid",
++ .fops = &mdt_uuid_fops },
++ { .name = "recovery_status",
++ .fops = &mdt_recovery_status_fops },
++ { .name = "num_exports",
++ .fops = &mdt_num_exports_fops },
++ { .name = "identity_expire",
++ .fops = &mdt_identity_expire_fops },
++ { .name = "identity_acquire_expire",
++ .fops = &mdt_identity_acquire_expire_fops },
++ { .name = "identity_upcall",
++ .fops = &mdt_identity_upcall_fops },
++ { .name = "identity_flush",
++ .fops = &mdt_identity_flush_fops },
++ { .name = "identity_info",
++ .fops = &mdt_identity_info_fops },
++ { .name = "capa",
++ .fops = &mdt_capa_fops },
++ { .name = "capa_timeout",
++ .fops = &mdt_capa_timeout_fops },
++ { .name = "capa_key_timeout",
++ .fops = &mdt_ck_timeout_fops },
++ { .name = "capa_count",
++ .fops = &mdt_capa_count_fops },
++ { .name = "site_stats",
++ .fops = &mdt_site_stats_fops },
++ { .name = "evict_client",
++ .fops = &mdt_mds_evict_client_fops },
++ { .name = "hash_stats",
++ .fops = &mdt_hash_fops },
++ { .name = "sec_level",
++ .fops = &mdt_sec_level_fops },
++ { .name = "commit_on_sharing",
++ .fops = &mdt_cos_fops },
++ { .name = "root_squash",
++ .fops = &mdt_root_squash_fops },
++ { .name = "nosquash_nids",
++ .fops = &mdt_nosquash_nids_fops },
++ { .name = "som",
++ .fops = &mdt_som_fops },
++ { .name = "instance",
++ .fops = &mdt_target_instance_fops },
++ { .name = "ir_factor",
++ .fops = &mdt_ir_factor_fops },
++ { .name = "job_cleanup_interval",
++ .fops = &mdt_job_interval_fops },
++ { .name = "enable_remote_dir",
++ .fops = &mdt_enable_remote_dir_fops },
++ { .name = "enable_remote_dir_gid",
++ .fops = &mdt_enable_remote_dir_gid_fops },
++ { .name = "hsm_control",
++ .fops = &mdt_hsm_cdt_control_fops },
+ { 0 }
+ };
+
+@@ -1085,21 +1002,15 @@ int lprocfs_mdt_open_files_seq_show(struct seq_file *seq, void *v)
+
+ int lprocfs_mdt_open_files_seq_open(struct inode *inode, struct file *file)
+ {
+- struct proc_dir_entry *dp = PDE(inode);
+ struct seq_file *seq;
+- struct nid_stat *tmp;
+ int rc;
+
+- if (LPROCFS_ENTRY_CHECK(dp))
+- return -ENOENT;
+-
+- tmp = dp->data;
+ rc = single_open(file, &lprocfs_mdt_open_files_seq_show, NULL);
+ if (rc != 0)
+ return rc;
+
+ seq = file->private_data;
+- seq->private = tmp;
++ seq->private = PDE_DATA(inode);
+
+ return 0;
+ }
+@@ -1140,3 +1051,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.3
+