From 90636ff53d8d2d714a7591c4bb9a75a7c69f997f Mon Sep 17 00:00:00 2001 From: James Simmons Date: Fri, 9 May 2014 16:30:46 -0400 Subject: [PATCH] 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 Change-Id: Icbafdcd2c2fe3959a51dda3f9c715b0ff8d95742 Reviewed-on: http://review.whamcloud.com/8036 Tested-by: Jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: Yang Sheng Reviewed-by: Bob Glossman --- 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 | 713 +++++++++++++++++++------------------- lustre/mdt/mdt_mds.c | 12 +- 8 files changed, 495 insertions(+), 544 deletions(-) diff --git a/lustre/mdt/mdt_coordinator.c b/lustre/mdt/mdt_coordinator.c index 651ed7a..1617eeb 100644 --- a/lustre/mdt/mdt_coordinator.c +++ b/lustre/mdt/mdt_coordinator.c @@ -45,7 +45,7 @@ #include #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 __user *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 __user *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) @@ -1984,10 +1960,12 @@ GENERATE_PROC_METHOD(cdt_default_archive_id) #define CDT_HELP_CMD "help" #define CDT_MAX_CMD_LEN 10 -int lprocfs_wr_hsm_cdt_control(struct file *file, const char __user *buffer, - unsigned long count, void *data) +ssize_t +mdt_hsm_cdt_control_seq_write(struct file *file, const char __user *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; @@ -2051,83 +2029,71 @@ int lprocfs_wr_hsm_cdt_control(struct file *file, const char __user *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 @@ -2147,9 +2113,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; @@ -2193,69 +2159,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 b49e4ae..298e9d8d 100644 --- a/lustre/mdt/mdt_handler.c +++ b/lustre/mdt/mdt_handler.c @@ -4666,7 +4666,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 */ @@ -4701,14 +4700,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, @@ -5932,7 +5930,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") == @@ -5947,10 +5944,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 0f5e0fe..6b1acf0 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 116d98f..d1a3b66 100644 --- a/lustre/mdt/mdt_internal.h +++ b/lustre/mdt/mdt_internal.h @@ -756,9 +756,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); @@ -896,13 +893,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, @@ -1042,8 +1038,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 70eba85..ff7a260 100644 --- a/lustre/mdt/mdt_lproc.c +++ b/lustre/mdt/mdt_lproc.c @@ -144,8 +144,9 @@ static int mdt_rename_stats_seq_show(struct seq_file *seq, void *v) return 0; } -static ssize_t mdt_rename_stats_seq_write(struct file *file, const char *buf, - size_t len, loff_t *off) +static ssize_t +mdt_rename_stats_seq_write(struct file *file, const char __user *buf, + size_t len, loff_t *off) { struct seq_file *seq = file->private_data; struct mdt_device *mdt = seq->private; @@ -156,7 +157,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,145 +213,77 @@ 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); + struct obd_device *obd = m->private; + struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - RETURN(rc); + return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire); } -void mdt_procfs_fini(struct mdt_device *mdt) +static ssize_t +mdt_identity_expire_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct obd_device *obd = mdt2obd_dev(mdt); + 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; - if (obd->obd_proc_exports_entry != NULL) { - lprocfs_remove_proc_entry("clear", obd->obd_proc_exports_entry); - obd->obd_proc_exports_entry = NULL; - } + rc = lprocfs_write_helper(buffer, count, &val); + if (rc) + return rc; - 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); + mdt->mdt_identity_cache->uc_entry_expire = val; + return count; } +LPROC_SEQ_FOPS(mdt_identity_expire); -static int lprocfs_rd_identity_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_entry_expire); + return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire); } -static int lprocfs_wr_identity_expire(struct file *file, +static ssize_t +mdt_identity_acquire_expire_seq_write(struct file *file, const char __user *buffer, - unsigned long count, void *data) -{ - struct obd_device *obd = data; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int rc, val; - - rc = lprocfs_write_helper(buffer, count, &val); - if (rc) - return rc; - - mdt->mdt_identity_cache->uc_entry_expire = val; - return count; -} - -static int lprocfs_rd_identity_acquire_expire(char *page, char **start, - off_t off, int count, int *eof, - void *data) + size_t count, loff_t *off) { - struct obd_device *obd = data; - 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); -} - -static int lprocfs_wr_identity_acquire_expire(struct file *file, - const char __user *buffer, - unsigned long count, - void *data) -{ - 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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_identity_upcall_seq_write(struct file *file, const char __user *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; @@ -390,28 +322,32 @@ static int lprocfs_wr_identity_upcall(struct file *file, OBD_FREE(kernbuf, count + 1); RETURN(rc); } +LPROC_SEQ_FOPS(mdt_identity_upcall); -static int lprocfs_wr_identity_flush(struct file *file, - const char __user *buffer, - unsigned long count, void *data) +static ssize_t +lprocfs_identity_flush_seq_write(struct file *file, const char __user *buffer, + size_t count, void *data) { - struct obd_device *obd = data; - struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); - int rc, uid; + 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; - rc = lprocfs_write_helper(buffer, count, &uid); - if (rc) - return rc; + rc = lprocfs_write_helper(buffer, count, &uid); + if (rc) + return rc; - mdt_flush_identity(mdt->mdt_identity_cache, uid); - return count; + 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 __user *buffer, - unsigned long count, void *data) +static ssize_t +lprocfs_identity_info_seq_write(struct file *file, const char __user *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; @@ -419,7 +355,7 @@ static int lprocfs_wr_identity_info(struct file *file, 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; } @@ -472,23 +408,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", - mdt->mdt_lut.lut_oss_capa ? "oss" : "", - mdt->mdt_lut.lut_mds_capa ? "mds" : ""); + 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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_capa_seq_write(struct file *file, const char __user *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; @@ -525,82 +463,87 @@ static int lprocfs_wr_capa(struct file *file, const char __user *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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_capa_timeout_seq_write(struct file *file, const char __user *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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_ck_timeout_seq_write(struct file *file, const char __user *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_ck_timeout = (unsigned long)val; - mdt->mdt_capa_conf = 1; - return count; + mdt->mdt_ck_timeout = (unsigned long)val; + 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 __user *buffer, - unsigned long count, void *data) +static ssize_t +lprocfs_mds_evict_client_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) { - char *kbuf; - char *tmpbuf; + char *kbuf; + char *tmpbuf; OBD_ALLOC(kbuf, BUFLEN); if (kbuf == NULL) @@ -619,7 +562,8 @@ static int lprocfs_mdt_wr_evict_client(struct file *file, 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; } @@ -632,21 +576,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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_sec_level_seq_write(struct file *file, const char __user *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) @@ -664,102 +609,110 @@ static int lprocfs_wr_sec_level(struct file *file, const char __user *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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_cos_seq_write(struct file *file, const char __user *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; - mdt_enable_cos(mdt, val); - return count; + rc = lprocfs_write_helper(buffer, count, &val); + if (rc) + return rc; + mdt_enable_cos(mdt, val); + return count; } +LPROC_SEQ_FOPS(mdt_cos); -static int lprocfs_rd_mdt_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 obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); struct root_squash_info *squash = &mdt->mdt_squash; - return snprintf(page, count, "%u:%u\n", squash->rsi_uid, - squash->rsi_gid); + return seq_printf(m, "%u:%u\n", squash->rsi_uid, + squash->rsi_gid); } -static int lprocfs_wr_mdt_root_squash(struct file *file, - const char __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_root_squash_seq_write(struct file *file, const char __user *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 root_squash_info *squash = &mdt->mdt_squash; return lprocfs_wr_root_squash(buffer, count, squash, mdt_obd_name(mdt)); } +LPROC_SEQ_FOPS(mdt_root_squash); -static int lprocfs_rd_mdt_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 obd_device *obd = m->private; struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev); struct root_squash_info *squash = &mdt->mdt_squash; - int rc; + int len = 0, rc; down_read(&squash->rsi_sem); if (!list_empty(&squash->rsi_nosquash_nids)) { - rc = cfs_print_nidlist(page, count, &squash->rsi_nosquash_nids); - rc += snprintf(page + rc, count - rc, "\n"); + len = cfs_print_nidlist(m->buf + m->count, m->size - m->count, + &squash->rsi_nosquash_nids); + m->count += len; + rc = seq_printf(m, "\n"); } else - rc = snprintf(page, count, "NONE\n"); + rc = seq_printf(m, "NONE\n"); up_read(&squash->rsi_sem); return rc; } -static int lprocfs_wr_mdt_nosquash_nids(struct file *file, - const char __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_nosquash_nids_seq_write(struct file *file, const char __user *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 root_squash_info *squash = &mdt->mdt_squash; return lprocfs_wr_nosquash_nids(buffer, count, squash, mdt_obd_name(mdt)); } +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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_som_seq_write(struct file *file, const char __user *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; @@ -801,21 +754,22 @@ static int lprocfs_wr_mdt_som(struct file *file, const char __user *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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_enable_remote_dir_seq_write(struct file *file, const char __user *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; @@ -830,22 +784,24 @@ static int lprocfs_wr_enable_remote_dir(struct file *file, 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 __user *buffer, - unsigned long count, void *data) +static ssize_t +mdt_enable_remote_dir_gid_seq_write(struct file *file, + const char __user *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; @@ -857,97 +813,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_mdt_root_squash, - lprocfs_wr_mdt_root_squash, - NULL, NULL, 0 }, - { "nosquash_nids", lprocfs_rd_mdt_nosquash_nids, - lprocfs_wr_mdt_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 } }; @@ -985,21 +916,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; } @@ -1040,3 +965,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.8.3.1