diff options
Diffstat (limited to 'sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch')
| -rw-r--r-- | sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch | 1582 |
1 files changed, 1582 insertions, 0 deletions
diff --git a/sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch b/sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch new file mode 100644 index 000000000..5c1c9cd8e --- /dev/null +++ b/sys-cluster/lustre/files/0007-LU-3319-procfs-move-mdt-mds-proc-handling-to-seq_fil.patch @@ -0,0 +1,1582 @@ +From 039e3e44e07b59923d94bea976173d9e3cbd0ba9 Mon Sep 17 00:00:00 2001 +From: James Simmons <uja.ornl@gmail.com> +Date: Tue, 25 Mar 2014 11:10:33 -0400 +Subject: [PATCH 7/9] 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 | 269 +++++++--------- + 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 | 659 +++++++++++++++++++------------------- + lustre/mdt/mdt_mds.c | 12 +- + 8 files changed, 469 insertions(+), 516 deletions(-) + +diff --git a/lustre/mdt/mdt_coordinator.c b/lustre/mdt/mdt_coordinator.c +index a9ee560..062f6cc 100644 +--- a/lustre/mdt/mdt_coordinator.c ++++ b/lustre/mdt/mdt_coordinator.c +@@ -45,7 +45,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 +@@ -392,7 +392,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)) { +@@ -424,7 +424,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; + } +@@ -1785,22 +1785,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); + +@@ -1809,48 +1804,37 @@ 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); ++ m->count--; ++ seq_putc(m, '\0'); + } + + /* 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; + +@@ -1883,18 +1867,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) { +@@ -1933,25 +1909,25 @@ 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 seq_file *m = file->private_data; \ ++ struct mdt_device *mdt = m->private; \ + struct coordinator *cdt = &mdt->mdt_coordinator; \ + int val; \ + int rc; \ +@@ -1965,7 +1941,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) +@@ -1983,10 +1959,12 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + struct coordinator *cdt = &(mdt->mdt_coordinator); + int rc, usage = 0; +@@ -2040,83 +2018,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 +@@ -2136,9 +2102,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; +@@ -2182,69 +2148,76 @@ 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 seq_file *m = file->private_data; ++ struct mdt_device *mdt = m->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 coordinator *cdt = &mdt->mdt_coordinator; ++ struct seq_file *m = file->private_data; ++ struct mdt_device *mdt = m->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 coordinator *cdt = &mdt->mdt_coordinator; ++ struct seq_file *m = file->private_data; ++ struct mdt_device *mdt = m->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 69b1c30..8b4634f 100644 +--- a/lustre/mdt/mdt_handler.c ++++ b/lustre/mdt/mdt_handler.c +@@ -4644,7 +4644,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 */ +@@ -4679,14 +4678,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, +@@ -5885,7 +5883,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") == +@@ -5900,10 +5897,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, true, 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 7970b86..8fb96c8 100644 +--- a/lustre/mdt/mdt_internal.h ++++ b/lustre/mdt/mdt_internal.h +@@ -785,9 +785,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); + +@@ -925,13 +922,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, +@@ -1071,8 +1067,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..a895d57 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,76 @@ 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) ++static int mdt_identity_expire_seq_show(struct seq_file *m, void *data) + { +- 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + struct upcall_cache *hash = mdt->mdt_identity_cache; + int rc; +@@ -388,11 +320,14 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int rc, uid; + +@@ -403,11 +338,14 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->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 +353,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 +406,25 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int val, rc; + +@@ -521,64 +461,67 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->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 +531,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 +559,8 @@ 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 +573,22 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->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 +606,24 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->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 +631,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,11 +657,13 @@ 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 mdt_device *mdt = mdt_dev(obd->obd_lu_dev); ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; ++ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int rc; + char kernbuf[50], *tmp, *end, *errmsg; + unsigned long uid, gid; +@@ -765,23 +716,25 @@ 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 mdt_device *mdt = mdt_dev(obd->obd_lu_dev); ++ struct seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; ++ struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + int rc; + char *kernbuf, *errmsg; + cfs_list_t tmp; +@@ -842,25 +795,27 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->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 +857,22 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + __u32 val; + int rc; +@@ -930,22 +887,23 @@ 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 seq_file *m = file->private_data; ++ struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); + __u32 val; + int rc; +@@ -957,97 +915,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 +1018,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 +1067,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 390164f..424ddf5 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, true, NULL, + #ifndef HAVE_ONLY_PROCFS_SEQ +- lprocfs_mds_module_vars, ++ NULL, + #endif + LUSTRE_MDS_NAME, &mds_device_type); + } +-- +1.9.1 + |