From fee90a75e11d68f348decd00f698849d085069f2 Mon Sep 17 00:00:00 2001 From: James Simmons Date: Fri, 6 Dec 2013 09:45:52 -0500 Subject: [PATCH] LU-3319 procfs: move ptlrpc proc handling over to seq_file In order to support 3.10+ kernels for clients we adapt the ptlrpc proc handling to using seq_files. Signed-off-by: James Simmons Change-Id: Ib0bf475d62fd632f6eaaad2d2efbcdedc49df3b8 Reviewed-on: http://review.whamcloud.com/7296 Tested-by: Jenkins Tested-by: Maloo Reviewed-by: Bob Glossman Reviewed-by: Yang Sheng Reviewed-by: Oleg Drokin --- lustre/ptlrpc/gss/lproc_gss.c | 59 +++--- lustre/ptlrpc/lproc_ptlrpc.c | 454 ++++++++++++++++++++++++---------------- lustre/ptlrpc/nrs_crr.c | 46 ++-- lustre/ptlrpc/nrs_orr.c | 129 +++++------- lustre/ptlrpc/ptlrpc_internal.h | 3 +- lustre/ptlrpc/sec_bulk.c | 5 +- lustre/ptlrpc/sec_lproc.c | 32 +-- lustre/ptlrpc/service.c | 2 +- 8 files changed, 396 insertions(+), 334 deletions(-) diff --git a/lustre/ptlrpc/gss/lproc_gss.c b/lustre/ptlrpc/gss/lproc_gss.c index 3c5d4ab..f524c23 100644 --- a/lustre/ptlrpc/gss/lproc_gss.c +++ b/lustre/ptlrpc/gss/lproc_gss.c @@ -98,12 +98,9 @@ void gss_stat_oos_record_svc(int phase, int replay) cfs_atomic_inc(&gss_stat_oos.oos_svc_pass[phase]); } -static int gss_proc_read_oos(char *page, char **start, off_t off, int count, - int *eof, void *data) +static int gss_proc_oos_seq_show(struct seq_file *m, void *v) { - int written; - - written = snprintf(page, count, + return seq_printf(m, "seqwin: %u\n" "backwin: %u\n" "client fall behind seqwin\n" @@ -123,12 +120,12 @@ static int gss_proc_read_oos(char *page, char **start, off_t off, int count, cfs_atomic_read(&gss_stat_oos.oos_svc_replay[1]), cfs_atomic_read(&gss_stat_oos.oos_svc_replay[2]), cfs_atomic_read(&gss_stat_oos.oos_svc_pass[2])); - - return written; } +LPROC_SEQ_FOPS_RO(gss_proc_oos); -static int gss_proc_write_secinit(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +gss_proc_write_secinit(struct file *file, const char *buffer, + size_t count, loff_t *off) { int rc; @@ -137,14 +134,20 @@ static int gss_proc_write_secinit(struct file *file, const char *buffer, LASSERT(rc < 0); return rc; } - - return ((int) count); + return count; } -static struct lprocfs_vars gss_lprocfs_vars[] = { - { "replays", gss_proc_read_oos, NULL }, - { "init_channel", NULL, gss_proc_write_secinit, NULL, NULL, 0222 }, - { NULL } +static const struct file_operations gss_proc_secinit = { + .write = gss_proc_write_secinit, +}; + +static struct lprocfs_seq_vars gss_lprocfs_vars[] = { + { .name = "replays", + .fops = &gss_proc_oos_fops }, + { .name = "init_channel", + .fops = &gss_proc_secinit, + .proc_mode = 0222 }, + { NULL } }; /* @@ -154,14 +157,14 @@ static struct lprocfs_vars gss_lprocfs_vars[] = { */ static int gss_lk_debug_level = 1; -static int gss_lk_proc_read_dl(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int gss_lk_proc_dl_seq_show(struct seq_file *m, void *v) { - return snprintf(page, count, "%u\n", gss_lk_debug_level); + return seq_printf(m, "%u\n", gss_lk_debug_level); } -static int gss_lk_proc_write_dl(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +gss_lk_proc_dl_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { int val, rc; @@ -175,10 +178,12 @@ static int gss_lk_proc_write_dl(struct file *file, const char *buffer, gss_lk_debug_level = val; return count; } +LPROC_SEQ_FOPS(gss_lk_proc_dl); -static struct lprocfs_vars gss_lk_lprocfs_vars[] = { - { "debug_level", gss_lk_proc_read_dl, gss_lk_proc_write_dl, NULL }, - { NULL } +static struct lprocfs_seq_vars gss_lk_lprocfs_vars[] = { + { .name = "debug_level", + .fops = &gss_lk_proc_dl_fops }, + { NULL } }; void gss_exit_lproc(void) @@ -200,16 +205,16 @@ int gss_init_lproc(void) spin_lock_init(&gss_stat_oos.oos_lock); - gss_proc_root = lprocfs_register("gss", sptlrpc_proc_root, - gss_lprocfs_vars, NULL); + gss_proc_root = lprocfs_seq_register("gss", sptlrpc_proc_root, + gss_lprocfs_vars, NULL); if (IS_ERR(gss_proc_root)) { rc = PTR_ERR(gss_proc_root); gss_proc_root = NULL; GOTO(out, rc); } - gss_proc_lk = lprocfs_register("lgss_keyring", gss_proc_root, - gss_lk_lprocfs_vars, NULL); + gss_proc_lk = lprocfs_seq_register("lgss_keyring", gss_proc_root, + gss_lk_lprocfs_vars, NULL); if (IS_ERR(gss_proc_lk)) { rc = PTR_ERR(gss_proc_lk); gss_proc_lk = NULL; diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c index ec3bb01..024169e 100644 --- a/lustre/ptlrpc/lproc_ptlrpc.c +++ b/lustre/ptlrpc/lproc_ptlrpc.c @@ -203,7 +203,7 @@ void ptlrpc_lprocfs_register(struct proc_dir_entry *root, char *dir, return; if (dir) { - svc_procroot = lprocfs_register(dir, root, NULL, NULL); + svc_procroot = lprocfs_seq_register(dir, root, NULL, NULL); if (IS_ERR(svc_procroot)) { lprocfs_free_stats(&svc_stats); return; @@ -258,46 +258,43 @@ void ptlrpc_lprocfs_register(struct proc_dir_entry *root, char *dir, } static int -ptlrpc_lprocfs_read_req_history_len(char *page, char **start, off_t off, - int count, int *eof, void *data) +ptlrpc_lprocfs_req_history_len_seq_show(struct seq_file *m, void *v) { - struct ptlrpc_service *svc = data; + struct ptlrpc_service *svc = m->private; struct ptlrpc_service_part *svcpt; int total = 0; int i; - *eof = 1; - ptlrpc_service_for_each_part(svcpt, i, svc) total += svcpt->scp_hist_nrqbds; - return snprintf(page, count, "%d\n", total); + return seq_printf(m, "%d\n", total); } +LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_req_history_len); static int -ptlrpc_lprocfs_read_req_history_max(char *page, char **start, off_t off, - int count, int *eof, void *data) +ptlrpc_lprocfs_req_history_max_seq_show(struct seq_file *m, void *n) { - struct ptlrpc_service *svc = data; + struct ptlrpc_service *svc = m->private; struct ptlrpc_service_part *svcpt; int total = 0; int i; - *eof = 1; ptlrpc_service_for_each_part(svcpt, i, svc) total += svc->srv_hist_nrqbds_cpt_max; - return snprintf(page, count, "%d\n", total); + return seq_printf(m, "%d\n", total); } -static int -ptlrpc_lprocfs_write_req_history_max(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_req_history_max_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct ptlrpc_service *svc = data; - int bufpages; - int val; - int rc; + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; + int bufpages; + int val; + int rc; rc = lprocfs_write_helper(buffer, count, &val); if (rc < 0) @@ -325,22 +322,23 @@ ptlrpc_lprocfs_write_req_history_max(struct file *file, const char *buffer, return count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_req_history_max); static int -ptlrpc_lprocfs_rd_threads_min(char *page, char **start, off_t off, - int count, int *eof, void *data) +ptlrpc_lprocfs_threads_min_seq_show(struct seq_file *m, void *n) { - struct ptlrpc_service *svc = data; + struct ptlrpc_service *svc = m->private; - return snprintf(page, count, "%d\n", - svc->srv_nthrs_cpt_init * svc->srv_ncpts); + return seq_printf(m, "%d\n", + svc->srv_nthrs_cpt_init * svc->srv_ncpts); } -static int -ptlrpc_lprocfs_wr_threads_min(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_threads_min_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct ptlrpc_service *svc = data; + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; int val; int rc = lprocfs_write_helper(buffer, count, &val); @@ -362,37 +360,38 @@ ptlrpc_lprocfs_wr_threads_min(struct file *file, const char *buffer, return count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_threads_min); static int -ptlrpc_lprocfs_rd_threads_started(char *page, char **start, off_t off, - int count, int *eof, void *data) +ptlrpc_lprocfs_threads_started_seq_show(struct seq_file *m, void *n) { - struct ptlrpc_service *svc = data; - struct ptlrpc_service_part *svcpt; + struct ptlrpc_service *svc = m->private; + struct ptlrpc_service_part *svcpt; int total = 0; int i; ptlrpc_service_for_each_part(svcpt, i, svc) total += svcpt->scp_nthrs_running; - return snprintf(page, count, "%d\n", total); + return seq_printf(m, "%d\n", total); } +LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_threads_started); static int -ptlrpc_lprocfs_rd_threads_max(char *page, char **start, off_t off, - int count, int *eof, void *data) +ptlrpc_lprocfs_threads_max_seq_show(struct seq_file *m, void *n) { - struct ptlrpc_service *svc = data; + struct ptlrpc_service *svc = m->private; - return snprintf(page, count, "%d\n", - svc->srv_nthrs_cpt_limit * svc->srv_ncpts); + return seq_printf(m, "%d\n", + svc->srv_nthrs_cpt_limit * svc->srv_ncpts); } -static int -ptlrpc_lprocfs_wr_threads_max(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_threads_max_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct ptlrpc_service *svc = data; + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; int val; int rc = lprocfs_write_helper(buffer, count, &val); @@ -414,6 +413,7 @@ ptlrpc_lprocfs_wr_threads_max(struct file *file, const char *buffer, return count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_threads_max); /** * \addtogoup nrs @@ -475,10 +475,9 @@ void nrs_policy_get_info_locked(struct ptlrpc_nrs_policy *policy, * Reads and prints policy status information for all policies of a PTLRPC * service. */ -static int ptlrpc_lprocfs_rd_nrs(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int ptlrpc_lprocfs_nrs_seq_show(struct seq_file *m, void *n) { - struct ptlrpc_service *svc = data; + struct ptlrpc_service *svc = m->private; struct ptlrpc_service_part *svcpt; struct ptlrpc_nrs *nrs; struct ptlrpc_nrs_policy *policy; @@ -489,7 +488,6 @@ static int ptlrpc_lprocfs_rd_nrs(char *page, char **start, off_t off, bool hp = false; int i; int rc = 0; - int rc2 = 0; ENTRY; /** @@ -591,38 +589,20 @@ again: * queued: 0 * active: 0 */ - rc2 = snprintf(page + rc, count - rc, - "%s\n", !hp ? - "\nregular_requests:" : - "high_priority_requests:"); - - if (rc2 >= count - rc) { - /** Output was truncated */ - GOTO(out, rc = -EFBIG); - } - - rc += rc2; + seq_printf(m, "%s\n", !hp ? "\nregular_requests:" : + "high_priority_requests:"); for (pol_idx = 0; pol_idx < num_pols; pol_idx++) { - rc2 = snprintf(page + rc, count - rc, - " - name: %s\n" - " state: %s\n" - " fallback: %s\n" - " queued: %-20d\n" - " active: %-20d\n\n", - infos[pol_idx].pi_name, - nrs_state2str(infos[pol_idx].pi_state), - infos[pol_idx].pi_fallback ? "yes" : "no", - (int)infos[pol_idx].pi_req_queued, - (int)infos[pol_idx].pi_req_started); - - - if (rc2 >= count - rc) { - /** Output was truncated */ - GOTO(out, rc = -EFBIG); - } - - rc += rc2; + seq_printf(m, " - name: %s\n" + " state: %s\n" + " fallback: %s\n" + " queued: %-20d\n" + " active: %-20d\n\n", + infos[pol_idx].pi_name, + nrs_state2str(infos[pol_idx].pi_state), + infos[pol_idx].pi_fallback ? "yes" : "no", + (int)infos[pol_idx].pi_req_queued, + (int)infos[pol_idx].pi_req_started); } if (!hp && nrs_svc_has_hp(svc)) { @@ -635,8 +615,6 @@ again: goto again; } - *eof = 1; - out: if (infos) OBD_FREE(infos, num_pols * sizeof(*infos)); @@ -659,10 +637,12 @@ out: * if the optional token is omitted, the operation is performed on both the * regular and high-priority (if the service has one) NRS head. */ -static int ptlrpc_lprocfs_wr_nrs(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_nrs_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct ptlrpc_service *svc = data; + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; enum ptlrpc_nrs_queue_type queue = PTLRPC_NRS_QUEUE_BOTH; char *cmd; char *cmd_copy = NULL; @@ -730,6 +710,7 @@ out: RETURN(rc < 0 ? rc : count); } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs); /** @} nrs */ @@ -983,45 +964,40 @@ static int ptlrpc_lprocfs_svc_req_history_show(struct seq_file *s, void *iter) static int ptlrpc_lprocfs_svc_req_history_open(struct inode *inode, struct file *file) { - static struct seq_operations sops = { - .start = ptlrpc_lprocfs_svc_req_history_start, - .stop = ptlrpc_lprocfs_svc_req_history_stop, - .next = ptlrpc_lprocfs_svc_req_history_next, - .show = ptlrpc_lprocfs_svc_req_history_show, - }; - struct proc_dir_entry *dp = PDE(inode); - struct seq_file *seqf; - int rc; - - LPROCFS_ENTRY_CHECK(dp); - rc = seq_open(file, &sops); + static struct seq_operations sops = { + .start = ptlrpc_lprocfs_svc_req_history_start, + .stop = ptlrpc_lprocfs_svc_req_history_stop, + .next = ptlrpc_lprocfs_svc_req_history_next, + .show = ptlrpc_lprocfs_svc_req_history_show, + }; + struct seq_file *seqf; + int rc; + + LPROCFS_ENTRY_CHECK(PDE(inode)); + rc = seq_open(file, &sops); if (rc) - return rc; + return rc; - seqf = file->private_data; - seqf->private = dp->data; - return 0; + seqf = file->private_data; + seqf->private = PDE_DATA(inode); + return 0; } /* See also lprocfs_rd_timeouts */ -static int ptlrpc_lprocfs_rd_timeouts(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int ptlrpc_lprocfs_timeouts_seq_show(struct seq_file *m, void *n) { - struct ptlrpc_service *svc = data; + struct ptlrpc_service *svc = m->private; struct ptlrpc_service_part *svcpt; struct dhms ts; time_t worstt; unsigned int cur; unsigned int worst; - int nob = 0; - int rc = 0; int i; if (AT_OFF) { - rc += snprintf(page + rc, count - rc, - "adaptive timeouts off, using obd_timeout %u\n", - obd_timeout); - return rc; + seq_printf(m, "adaptive timeouts off, using obd_timeout %u\n", + obd_timeout); + return 0; } ptlrpc_service_for_each_part(svcpt, i, svc) { @@ -1030,46 +1006,29 @@ static int ptlrpc_lprocfs_rd_timeouts(char *page, char **start, off_t off, worstt = svcpt->scp_at_estimate.at_worst_time; s2dhms(&ts, cfs_time_current_sec() - worstt); - nob = snprintf(page, count, - "%10s : cur %3u worst %3u (at %ld, " - DHMS_FMT" ago) ", "service", - cur, worst, worstt, DHMS_VARS(&ts)); - - nob = lprocfs_at_hist_helper(page, count, nob, - &svcpt->scp_at_estimate); - rc += nob; - page += nob; - count -= nob; - - /* - * NB: for lustre proc read, the read count must be less - * than PAGE_SIZE, please see details in lprocfs_fops_read. - * It's unlikely that we exceed PAGE_SIZE at here because - * it means the service has more than 50 partitions. - */ - if (count <= 0) { - CWARN("Can't fit AT information of %s in one page, " - "please contact with developer to fix this.\n", - svc->srv_name); - break; - } + seq_printf(m, "%10s : cur %3u worst %3u (at %ld, " + DHMS_FMT" ago) ", "service", + cur, worst, worstt, DHMS_VARS(&ts)); + + lprocfs_seq_at_hist_helper(m, &svcpt->scp_at_estimate); } - return rc; + return 0; } +LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_timeouts); -static int ptlrpc_lprocfs_rd_hp_ratio(char *page, char **start, off_t off, - int count, int *eof, void *data) +static int ptlrpc_lprocfs_hp_ratio_seq_show(struct seq_file *m, void *v) { - struct ptlrpc_service *svc = data; - int rc = snprintf(page, count, "%d", svc->srv_hpreq_ratio); - return rc; + struct ptlrpc_service *svc = m->private; + return seq_printf(m, "%d\n", svc->srv_hpreq_ratio); } -static int ptlrpc_lprocfs_wr_hp_ratio(struct file *file, const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_hp_ratio_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct ptlrpc_service *svc = data; + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; int rc; int val; @@ -1086,41 +1045,37 @@ static int ptlrpc_lprocfs_wr_hp_ratio(struct file *file, const char *buffer, return count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_hp_ratio); void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry, struct ptlrpc_service *svc) { - struct lprocfs_vars lproc_vars[] = { - {.name = "high_priority_ratio", - .read_fptr = ptlrpc_lprocfs_rd_hp_ratio, - .write_fptr = ptlrpc_lprocfs_wr_hp_ratio, - .data = svc}, - {.name = "req_buffer_history_len", - .read_fptr = ptlrpc_lprocfs_read_req_history_len, - .data = svc}, - {.name = "req_buffer_history_max", - .write_fptr = ptlrpc_lprocfs_write_req_history_max, - .read_fptr = ptlrpc_lprocfs_read_req_history_max, - .data = svc}, - {.name = "threads_min", - .read_fptr = ptlrpc_lprocfs_rd_threads_min, - .write_fptr = ptlrpc_lprocfs_wr_threads_min, - .data = svc}, - {.name = "threads_max", - .read_fptr = ptlrpc_lprocfs_rd_threads_max, - .write_fptr = ptlrpc_lprocfs_wr_threads_max, - .data = svc}, - {.name = "threads_started", - .read_fptr = ptlrpc_lprocfs_rd_threads_started, - .data = svc}, - {.name = "timeouts", - .read_fptr = ptlrpc_lprocfs_rd_timeouts, - .data = svc}, - {.name = "nrs_policies", - .read_fptr = ptlrpc_lprocfs_rd_nrs, - .write_fptr = ptlrpc_lprocfs_wr_nrs, - .data = svc}, - {NULL} + struct lprocfs_seq_vars lproc_vars[] = { + { .name = "high_priority_ratio", + .fops = &ptlrpc_lprocfs_hp_ratio_fops, + .data = svc }, + { .name = "req_buffer_history_len", + .fops = &ptlrpc_lprocfs_req_history_len_fops, + .data = svc }, + { .name = "req_buffer_history_max", + .fops = &ptlrpc_lprocfs_req_history_max_fops, + .data = svc }, + { .name = "threads_min", + .fops = &ptlrpc_lprocfs_threads_min_fops, + .data = svc }, + { .name = "threads_max", + .fops = &ptlrpc_lprocfs_threads_max_fops, + .data = svc }, + { .name = "threads_started", + .fops = &ptlrpc_lprocfs_threads_started_fops, + .data = svc }, + { .name = "timeouts", + .fops = &ptlrpc_lprocfs_timeouts_fops, + .data = svc }, + { .name = "nrs_policies", + .fops = &ptlrpc_lprocfs_nrs_fops, + .data = svc }, + { NULL } }; static struct file_operations req_history_fops = { .owner = THIS_MODULE, @@ -1133,18 +1088,17 @@ void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry, int rc; ptlrpc_lprocfs_register(entry, svc->srv_name, - "stats", &svc->srv_procroot, - &svc->srv_stats); + "stats", &svc->srv_procroot, + &svc->srv_stats); + if (svc->srv_procroot == NULL) + return; - if (svc->srv_procroot == NULL) - return; + lprocfs_seq_add_vars(svc->srv_procroot, lproc_vars, NULL); - lprocfs_add_vars(svc->srv_procroot, lproc_vars, NULL); - - rc = lprocfs_seq_create(svc->srv_procroot, "req_history", - 0400, &req_history_fops, svc); - if (rc) - CWARN("Error adding the req_history file\n"); + rc = lprocfs_seq_create(svc->srv_procroot, "req_history", + 0400, &req_history_fops, svc); + if (rc) + CWARN("Error adding the req_history file\n"); } void ptlrpc_lprocfs_register_obd(struct obd_device *obddev) @@ -1216,7 +1170,6 @@ void ptlrpc_lprocfs_unregister_obd(struct obd_device *obd) } EXPORT_SYMBOL(ptlrpc_lprocfs_unregister_obd); - #define BUFLEN (UUID_MAX + 5) int lprocfs_wr_evict_client(struct file *file, const char *buffer, @@ -1260,6 +1213,7 @@ EXPORT_SYMBOL(lprocfs_wr_evict_client); #undef BUFLEN +#ifndef HAVE_ONLY_PROCFS_SEQ int lprocfs_wr_ping(struct file *file, const char *buffer, unsigned long count, void *data) { @@ -1285,10 +1239,6 @@ int lprocfs_wr_ping(struct file *file, const char *buffer, } EXPORT_SYMBOL(lprocfs_wr_ping); -/* Write the connection UUID to this file to attempt to connect to that node. - * The connection UUID is a node's primary NID. For example, - * "echo connection=192.168.0.1@tcp0::instance > .../import". - */ int lprocfs_wr_import(struct file *file, const char *buffer, unsigned long count, void *data) { @@ -1392,4 +1342,140 @@ int lprocfs_wr_pinger_recov(struct file *file, const char *buffer, } EXPORT_SYMBOL(lprocfs_wr_pinger_recov); +#endif /* HAVE_ONLY_PROCFS_SEQ */ + +ssize_t +lprocfs_ping_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct obd_device *obd = m->private; + struct ptlrpc_request *req; + int rc; + ENTRY; + + LPROCFS_CLIMP_CHECK(obd); + req = ptlrpc_prep_ping(obd->u.cli.cl_import); + LPROCFS_CLIMP_EXIT(obd); + if (req == NULL) + RETURN(-ENOMEM); + + req->rq_send_state = LUSTRE_IMP_FULL; + + rc = ptlrpc_queue_wait(req); + + ptlrpc_req_finished(req); + if (rc >= 0) + RETURN(count); + RETURN(rc); +} +EXPORT_SYMBOL(lprocfs_ping_seq_write); + +/* Write the connection UUID to this file to attempt to connect to that node. + * The connection UUID is a node's primary NID. For example, + * "echo connection=192.168.0.1@tcp0::instance > .../import". + */ +ssize_t +lprocfs_import_seq_write(struct file *file, const char *buffer, size_t count, + loff_t *off) +{ + struct seq_file *m = file->private_data; + struct obd_device *obd = m->private; + struct obd_import *imp = obd->u.cli.cl_import; + char *kbuf = NULL; + char *uuid; + char *ptr; + int do_reconn = 1; + const char prefix[] = "connection="; + const int prefix_len = sizeof(prefix) - 1; + + if (count > PAGE_CACHE_SIZE - 1 || count <= prefix_len) + return -EINVAL; + + OBD_ALLOC(kbuf, count + 1); + if (kbuf == NULL) + return -ENOMEM; + + if (copy_from_user(kbuf, buffer, count)) + GOTO(out, count = -EFAULT); + + kbuf[count] = 0; + + /* only support connection=uuid::instance now */ + if (strncmp(prefix, kbuf, prefix_len) != 0) + GOTO(out, count = -EINVAL); + + uuid = kbuf + prefix_len; + ptr = strstr(uuid, "::"); + if (ptr) { + __u32 inst; + char *endptr; + + *ptr = 0; + do_reconn = 0; + ptr += strlen("::"); + inst = simple_strtol(ptr, &endptr, 10); + if (*endptr) { + CERROR("config: wrong instance # %s\n", ptr); + } else if (inst != imp->imp_connect_data.ocd_instance) { + CDEBUG(D_INFO, "IR: %s is connecting to an obsoleted " + "target(%u/%u), reconnecting...\n", + imp->imp_obd->obd_name, + imp->imp_connect_data.ocd_instance, inst); + do_reconn = 1; + } else { + CDEBUG(D_INFO, "IR: %s has already been connecting to " + "new target(%u)\n", + imp->imp_obd->obd_name, inst); + } + } + + if (do_reconn) + ptlrpc_recover_import(imp, uuid, 1); + +out: + OBD_FREE(kbuf, count + 1); + return count; +} +EXPORT_SYMBOL(lprocfs_import_seq_write); + +int lprocfs_pinger_recov_seq_show(struct seq_file *m, void *n) +{ + struct obd_device *obd = m->private; + struct obd_import *imp = obd->u.cli.cl_import; + int rc; + + LPROCFS_CLIMP_CHECK(obd); + rc = seq_printf(m, "%d\n", !imp->imp_no_pinger_recover); + LPROCFS_CLIMP_EXIT(obd); + return rc; +} +EXPORT_SYMBOL(lprocfs_pinger_recov_seq_show); + +ssize_t +lprocfs_pinger_recov_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) +{ + struct seq_file *m = file->private_data; + struct obd_device *obd = m->private; + struct client_obd *cli = &obd->u.cli; + struct obd_import *imp = cli->cl_import; + int rc, val; + + rc = lprocfs_write_helper(buffer, count, &val); + if (rc < 0) + return rc; + + if (val != 0 && val != 1) + return -ERANGE; + + LPROCFS_CLIMP_CHECK(obd); + spin_lock(&imp->imp_lock); + imp->imp_no_pinger_recover = !val; + spin_unlock(&imp->imp_lock); + LPROCFS_CLIMP_EXIT(obd); + return count; +} +EXPORT_SYMBOL(lprocfs_pinger_recov_seq_write); + #endif /* LPROCFS */ diff --git a/lustre/ptlrpc/nrs_crr.c b/lustre/ptlrpc/nrs_crr.c index 134b88e..9b11547 100644 --- a/lustre/ptlrpc/nrs_crr.c +++ b/lustre/ptlrpc/nrs_crr.c @@ -633,14 +633,12 @@ static void nrs_crrn_req_stop(struct ptlrpc_nrs_policy *policy, * reg_quantum:8 * hp_quantum:4 */ -static int ptlrpc_lprocfs_rd_nrs_crrn_quantum(char *page, char **start, - off_t off, int count, int *eof, - void *data) +static int +ptlrpc_lprocfs_nrs_crrn_quantum_seq_show(struct seq_file *m, void *data) { - struct ptlrpc_service *svc = data; - __u16 quantum; - int rc; - int rc2 = 0; + struct ptlrpc_service *svc = m->private; + __u16 quantum; + int rc; /** * Perform two separate calls to this as only one of the NRS heads' @@ -652,9 +650,8 @@ static int ptlrpc_lprocfs_rd_nrs_crrn_quantum(char *page, char **start, NRS_CTL_CRRN_RD_QUANTUM, true, &quantum); if (rc == 0) { - *eof = 1; - rc2 = snprintf(page, count, NRS_LPROCFS_QUANTUM_NAME_REG - "%-5d\n", quantum); + seq_printf(m, NRS_LPROCFS_QUANTUM_NAME_REG + "%-5d\n", quantum); /** * Ignore -ENODEV as the regular NRS head's policy may be in the * ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -671,9 +668,7 @@ static int ptlrpc_lprocfs_rd_nrs_crrn_quantum(char *page, char **start, NRS_CTL_CRRN_RD_QUANTUM, true, &quantum); if (rc == 0) { - *eof = 1; - rc2 += snprintf(page + rc2, count - rc2, - NRS_LPROCFS_QUANTUM_NAME_HP"%-5d\n", quantum); + seq_printf(m, NRS_LPROCFS_QUANTUM_NAME_HP"%-5d\n", quantum); /** * Ignore -ENODEV as the high priority NRS head's policy may be * in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -683,8 +678,7 @@ static int ptlrpc_lprocfs_rd_nrs_crrn_quantum(char *page, char **start, } no_hp: - - return rc2 ? : rc; + return rc; } /** @@ -707,11 +701,12 @@ no_hp: * policy instances in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state * are skipped later by nrs_crrn_ctl(). */ -static int ptlrpc_lprocfs_wr_nrs_crrn_quantum(struct file *file, - const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_nrs_crrn_quantum_seq_write(struct file *file, + const char *buffer, size_t count, + loff_t *off) { - struct ptlrpc_service *svc = data; + struct ptlrpc_service *svc = ((struct seq_file *)file->private_data)->private; enum ptlrpc_nrs_queue_type queue = 0; char kernbuf[LPROCFS_NRS_WR_QUANTUM_MAX_CMD]; char *val; @@ -815,6 +810,7 @@ static int ptlrpc_lprocfs_wr_nrs_crrn_quantum(struct file *file, return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_crrn_quantum); /** * Initializes a CRR-N policy's lprocfs interface for service \a svc @@ -826,12 +822,9 @@ static int ptlrpc_lprocfs_wr_nrs_crrn_quantum(struct file *file, */ int nrs_crrn_lprocfs_init(struct ptlrpc_service *svc) { - int rc; - - struct lprocfs_vars nrs_crrn_lprocfs_vars[] = { + struct lprocfs_seq_vars nrs_crrn_lprocfs_vars[] = { { .name = "nrs_crrn_quantum", - .read_fptr = ptlrpc_lprocfs_rd_nrs_crrn_quantum, - .write_fptr = ptlrpc_lprocfs_wr_nrs_crrn_quantum, + .fops = &ptlrpc_lprocfs_nrs_crrn_quantum_fops, .data = svc }, { NULL } }; @@ -839,9 +832,8 @@ int nrs_crrn_lprocfs_init(struct ptlrpc_service *svc) if (svc->srv_procroot == NULL) return 0; - rc = lprocfs_add_vars(svc->srv_procroot, nrs_crrn_lprocfs_vars, NULL); - - return rc; + return lprocfs_seq_add_vars(svc->srv_procroot, nrs_crrn_lprocfs_vars, + NULL); } /** diff --git a/lustre/ptlrpc/nrs_orr.c b/lustre/ptlrpc/nrs_orr.c index 3753fb9..17577b6 100644 --- a/lustre/ptlrpc/nrs_orr.c +++ b/lustre/ptlrpc/nrs_orr.c @@ -1194,15 +1194,13 @@ struct nrs_lprocfs_orr_data { * XXX: the CRR-N version of this, ptlrpc_lprocfs_rd_nrs_crrn_quantum() is * almost identical; it can be reworked and then reused for ORR/TRR. */ -static int ptlrpc_lprocfs_rd_nrs_orr_quantum(char *page, char **start, - off_t off, int count, int *eof, - void *data) +static int +ptlrpc_lprocfs_nrs_orr_quantum_seq_show(struct seq_file *m, void *data) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; __u16 quantum; int rc; - int rc2 = 0; /** * Perform two separate calls to this as only one of the NRS heads' @@ -1214,9 +1212,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_quantum(char *page, char **start, NRS_CTL_ORR_RD_QUANTUM, true, &quantum); if (rc == 0) { - *eof = 1; - rc2 = snprintf(page, count, NRS_LPROCFS_QUANTUM_NAME_REG - "%-5d\n", quantum); + seq_printf(m, NRS_LPROCFS_QUANTUM_NAME_REG "%-5d\n", quantum); /** * Ignore -ENODEV as the regular NRS head's policy may be in the * ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1237,9 +1233,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_quantum(char *page, char **start, orr_data->name, NRS_CTL_ORR_RD_QUANTUM, true, &quantum); if (rc == 0) { - *eof = 1; - rc2 += snprintf(page + rc2, count - rc2, - NRS_LPROCFS_QUANTUM_NAME_HP"%-5d\n", quantum); + seq_printf(m, NRS_LPROCFS_QUANTUM_NAME_HP"%-5d\n", quantum); /** * Ignore -ENODEV as the high priority NRS head's policy may be * in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1250,7 +1244,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_quantum(char *page, char **start, no_hp: - return rc2 ? : rc; + return rc; } /** @@ -1279,11 +1273,12 @@ no_hp: * XXX: the CRR-N version of this, ptlrpc_lprocfs_wr_nrs_crrn_quantum() is * almost identical; it can be reworked and then reused for ORR/TRR. */ -static int ptlrpc_lprocfs_wr_nrs_orr_quantum(struct file *file, - const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_nrs_orr_quantum_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct seq_file *m = file->private_data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; enum ptlrpc_nrs_queue_type queue = 0; char kernbuf[LPROCFS_NRS_WR_QUANTUM_MAX_CMD]; @@ -1388,6 +1383,7 @@ static int ptlrpc_lprocfs_wr_nrs_orr_quantum(struct file *file, return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_quantum); #define LPROCFS_NRS_OFF_NAME_REG "reg_offset_type:" #define LPROCFS_NRS_OFF_NAME_HP "hp_offset_type:" @@ -1409,15 +1405,13 @@ static int ptlrpc_lprocfs_wr_nrs_orr_quantum(struct file *file, * reg_offset_type:physical * hp_offset_type:logical */ -static int ptlrpc_lprocfs_rd_nrs_orr_offset_type(char *page, char **start, - off_t off, int count, int *eof, - void *data) +static int +ptlrpc_lprocfs_nrs_orr_offset_type_seq_show(struct seq_file *m, void *data) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; bool physical; int rc; - int rc2 = 0; /** * Perform two separate calls to this as only one of the NRS heads' @@ -1428,11 +1422,9 @@ static int ptlrpc_lprocfs_rd_nrs_orr_offset_type(char *page, char **start, orr_data->name, NRS_CTL_ORR_RD_OFF_TYPE, true, &physical); if (rc == 0) { - *eof = 1; - rc2 = snprintf(page, count, - LPROCFS_NRS_OFF_NAME_REG"%s\n", - physical ? LPROCFS_NRS_OFF_NAME_PHYSICAL : - LPROCFS_NRS_OFF_NAME_LOGICAL); + seq_printf(m, LPROCFS_NRS_OFF_NAME_REG"%s\n", + physical ? LPROCFS_NRS_OFF_NAME_PHYSICAL : + LPROCFS_NRS_OFF_NAME_LOGICAL); /** * Ignore -ENODEV as the regular NRS head's policy may be in the * ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1453,11 +1445,9 @@ static int ptlrpc_lprocfs_rd_nrs_orr_offset_type(char *page, char **start, orr_data->name, NRS_CTL_ORR_RD_OFF_TYPE, true, &physical); if (rc == 0) { - *eof = 1; - rc2 += snprintf(page + rc2, count - rc2, - LPROCFS_NRS_OFF_NAME_HP"%s\n", - physical ? LPROCFS_NRS_OFF_NAME_PHYSICAL : - LPROCFS_NRS_OFF_NAME_LOGICAL); + seq_printf(m, LPROCFS_NRS_OFF_NAME_HP"%s\n", + physical ? LPROCFS_NRS_OFF_NAME_PHYSICAL : + LPROCFS_NRS_OFF_NAME_LOGICAL); /** * Ignore -ENODEV as the high priority NRS head's policy may be * in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1467,8 +1457,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_offset_type(char *page, char **start, } no_hp: - - return rc2 ? : rc; + return rc; } /** @@ -1497,12 +1486,13 @@ no_hp: * policy instances in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state are * are skipped later by nrs_orr_ctl(). */ -static int ptlrpc_lprocfs_wr_nrs_orr_offset_type(struct file *file, - const char *buffer, - unsigned long count, - void *data) +static ssize_t +ptlrpc_lprocfs_nrs_orr_offset_type_seq_write(struct file *file, + const char *buffer, size_t count, + loff_t *off) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct seq_file *m = file->private_data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; enum ptlrpc_nrs_queue_type queue = 0; char kernbuf[LPROCFS_NRS_WR_OFF_TYPE_MAX_CMD]; @@ -1612,6 +1602,7 @@ static int ptlrpc_lprocfs_wr_nrs_orr_offset_type(struct file *file, return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_offset_type); #define NRS_LPROCFS_REQ_SUPP_NAME_REG "reg_supported:" #define NRS_LPROCFS_REQ_SUPP_NAME_HP "hp_supported:" @@ -1670,15 +1661,13 @@ static enum nrs_orr_supp nrs_orr_str2supp(const char *val) * reg_supported:reads * hp_supported:reads_and_writes */ -static int ptlrpc_lprocfs_rd_nrs_orr_supported(char *page, char **start, - off_t off, int count, int *eof, - void *data) +static int +ptlrpc_lprocfs_nrs_orr_supported_seq_show(struct seq_file *m, void *data) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; enum nrs_orr_supp supported; int rc; - int rc2 = 0; /** * Perform two separate calls to this as only one of the NRS heads' @@ -1691,10 +1680,8 @@ static int ptlrpc_lprocfs_rd_nrs_orr_supported(char *page, char **start, &supported); if (rc == 0) { - *eof = 1; - rc2 = snprintf(page, count, - NRS_LPROCFS_REQ_SUPP_NAME_REG"%s\n", - nrs_orr_supp2str(supported)); + seq_printf(m, NRS_LPROCFS_REQ_SUPP_NAME_REG"%s\n", + nrs_orr_supp2str(supported)); /** * Ignore -ENODEV as the regular NRS head's policy may be in the * ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1716,10 +1703,8 @@ static int ptlrpc_lprocfs_rd_nrs_orr_supported(char *page, char **start, NRS_CTL_ORR_RD_SUPP_REQ, true, &supported); if (rc == 0) { - *eof = 1; - rc2 += snprintf(page + rc2, count - rc2, - NRS_LPROCFS_REQ_SUPP_NAME_HP"%s\n", - nrs_orr_supp2str(supported)); + seq_printf(m, NRS_LPROCFS_REQ_SUPP_NAME_HP"%s\n", + nrs_orr_supp2str(supported)); /** * Ignore -ENODEV as the high priority NRS head's policy may be * in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1730,7 +1715,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_supported(char *page, char **start, no_hp: - return rc2 ? : rc; + return rc; } /** @@ -1760,11 +1745,13 @@ no_hp: * policy instances in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state are * are skipped later by nrs_orr_ctl(). */ -static int ptlrpc_lprocfs_wr_nrs_orr_supported(struct file *file, - const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_nrs_orr_supported_seq_write(struct file *file, + const char *buffer, size_t count, + loff_t *off) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct seq_file *m = file->private_data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; enum ptlrpc_nrs_queue_type queue = 0; char kernbuf[LPROCFS_NRS_WR_REQ_SUPP_MAX_CMD]; @@ -1865,22 +1852,19 @@ static int ptlrpc_lprocfs_wr_nrs_orr_supported(struct file *file, return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_supported); int nrs_orr_lprocfs_init(struct ptlrpc_service *svc) { - int rc; int i; - struct lprocfs_vars nrs_orr_lprocfs_vars[] = { + struct lprocfs_seq_vars nrs_orr_lprocfs_vars[] = { { .name = "nrs_orr_quantum", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_quantum, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_quantum }, + .fops = &ptlrpc_lprocfs_nrs_orr_quantum_fops }, { .name = "nrs_orr_offset_type", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_offset_type, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_offset_type }, + .fops = &ptlrpc_lprocfs_nrs_orr_offset_type_fops }, { .name = "nrs_orr_supported", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_supported, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_supported }, + .fops = &ptlrpc_lprocfs_nrs_orr_supported_fops }, { NULL } }; @@ -1892,9 +1876,7 @@ int nrs_orr_lprocfs_init(struct ptlrpc_service *svc) for (i = 0; i < ARRAY_SIZE(nrs_orr_lprocfs_vars); i++) nrs_orr_lprocfs_vars[i].data = &lprocfs_orr_data; - rc = lprocfs_add_vars(svc->srv_procroot, nrs_orr_lprocfs_vars, NULL); - - return rc; + return lprocfs_seq_add_vars(svc->srv_procroot, nrs_orr_lprocfs_vars, NULL); } void nrs_orr_lprocfs_fini(struct ptlrpc_service *svc) @@ -1946,16 +1928,13 @@ int nrs_trr_lprocfs_init(struct ptlrpc_service *svc) int rc; int i; - struct lprocfs_vars nrs_trr_lprocfs_vars[] = { + struct lprocfs_seq_vars nrs_trr_lprocfs_vars[] = { { .name = "nrs_trr_quantum", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_quantum, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_quantum }, + .fops = &ptlrpc_lprocfs_nrs_orr_quantum_fops }, { .name = "nrs_trr_offset_type", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_offset_type, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_offset_type }, + .fops = &ptlrpc_lprocfs_nrs_orr_offset_type_fops }, { .name = "nrs_trr_supported", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_supported, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_supported }, + .fops = &ptlrpc_lprocfs_nrs_orr_supported_fops }, { NULL } }; @@ -1967,7 +1946,7 @@ int nrs_trr_lprocfs_init(struct ptlrpc_service *svc) for (i = 0; i < ARRAY_SIZE(nrs_trr_lprocfs_vars); i++) nrs_trr_lprocfs_vars[i].data = &lprocfs_trr_data; - rc = lprocfs_add_vars(svc->srv_procroot, nrs_trr_lprocfs_vars, NULL); + rc = lprocfs_seq_add_vars(svc->srv_procroot, nrs_trr_lprocfs_vars, NULL); return rc; } diff --git a/lustre/ptlrpc/ptlrpc_internal.h b/lustre/ptlrpc/ptlrpc_internal.h index f3cb1d5..5a2b2d9 100644 --- a/lustre/ptlrpc/ptlrpc_internal.h +++ b/lustre/ptlrpc/ptlrpc_internal.h @@ -261,8 +261,7 @@ void sptlrpc_plain_fini(void); /* sec_bulk.c */ int sptlrpc_enc_pool_init(void); void sptlrpc_enc_pool_fini(void); -int sptlrpc_proc_read_enc_pool(char *page, char **start, off_t off, int count, - int *eof, void *data); +int sptlrpc_proc_enc_pool_seq_show(struct seq_file *m, void *v); /* sec_lproc.c */ int sptlrpc_lproc_init(void); diff --git a/lustre/ptlrpc/sec_bulk.c b/lustre/ptlrpc/sec_bulk.c index 32637d7..488ed8a 100644 --- a/lustre/ptlrpc/sec_bulk.c +++ b/lustre/ptlrpc/sec_bulk.c @@ -136,14 +136,13 @@ static struct shrinker *pools_shrinker; /* * /proc/fs/lustre/sptlrpc/encrypt_page_pools */ -int sptlrpc_proc_read_enc_pool(char *page, char **start, off_t off, int count, - int *eof, void *data) +int sptlrpc_proc_enc_pool_seq_show(struct seq_file *m, void *v) { int rc; spin_lock(&page_pools.epp_lock); - rc = snprintf(page, count, + rc = seq_printf(m, "physical pages: %lu\n" "pages per pool: %lu\n" "max pages: %lu\n" diff --git a/lustre/ptlrpc/sec_lproc.c b/lustre/ptlrpc/sec_lproc.c index 0506d27..009c0f0 100644 --- a/lustre/ptlrpc/sec_lproc.c +++ b/lustre/ptlrpc/sec_lproc.c @@ -174,25 +174,27 @@ int sptlrpc_lprocfs_cliobd_attach(struct obd_device *dev) } EXPORT_SYMBOL(sptlrpc_lprocfs_cliobd_attach); -static struct lprocfs_vars sptlrpc_lprocfs_vars[] = { - { "encrypt_page_pools", sptlrpc_proc_read_enc_pool, NULL, NULL }, - { NULL } +LPROC_SEQ_FOPS_RO(sptlrpc_proc_enc_pool); +static struct lprocfs_seq_vars sptlrpc_lprocfs_vars[] = { + { .name = "encrypt_page_pools", + .fops = &sptlrpc_proc_enc_pool_fops }, + { NULL } }; int sptlrpc_lproc_init(void) { - int rc; - - LASSERT(sptlrpc_proc_root == NULL); - - sptlrpc_proc_root = lprocfs_register("sptlrpc", proc_lustre_root, - sptlrpc_lprocfs_vars, NULL); - if (IS_ERR(sptlrpc_proc_root)) { - rc = PTR_ERR(sptlrpc_proc_root); - sptlrpc_proc_root = NULL; - return rc; - } - return 0; + int rc; + + LASSERT(sptlrpc_proc_root == NULL); + + sptlrpc_proc_root = lprocfs_seq_register("sptlrpc", proc_lustre_root, + sptlrpc_lprocfs_vars, NULL); + if (IS_ERR(sptlrpc_proc_root)) { + rc = PTR_ERR(sptlrpc_proc_root); + sptlrpc_proc_root = NULL; + return rc; + } + return 0; } void sptlrpc_lproc_fini(void) diff --git a/lustre/ptlrpc/service.c b/lustre/ptlrpc/service.c index 08827eb..40b65bf 100644 --- a/lustre/ptlrpc/service.c +++ b/lustre/ptlrpc/service.c @@ -710,7 +710,7 @@ ptlrpc_service_part_init(struct ptlrpc_service *svc, */ struct ptlrpc_service * ptlrpc_register_service(struct ptlrpc_service_conf *conf, - cfs_proc_dir_entry_t *proc_entry) + struct proc_dir_entry *proc_entry) { struct ptlrpc_service_cpt_conf *cconf = &conf->psc_cpt; struct ptlrpc_service *service; -- 1.8.3.1