X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fptlrpc%2Flproc_ptlrpc.c;h=82fe46886ddd344728dd3fab047cd04274142b40;hb=1929bfe81379a9c986bfa4202265f76d201a49bc;hp=e2ba1eeddd9c946b748a9cc6a3ad82ec514de855;hpb=663ef6abd788c3388cae8d5bc5421bad99979c8b;p=fs%2Flustre-release.git diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c index e2ba1ee..82fe468 100644 --- a/lustre/ptlrpc/lproc_ptlrpc.c +++ b/lustre/ptlrpc/lproc_ptlrpc.c @@ -27,7 +27,7 @@ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2013, Intel Corporation. + * Copyright (c) 2011, 2015, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -35,9 +35,6 @@ */ #define DEBUG_SUBSYSTEM S_CLASS -#ifndef __KERNEL__ -# include -#endif #include #include @@ -48,7 +45,7 @@ #include "ptlrpc_internal.h" -struct ll_rpc_opcode { +static struct ll_rpc_opcode { __u32 opcode; const char *opname; } ll_rpc_opcode_table[LUSTRE_MAX_OPCODES] = { @@ -73,6 +70,7 @@ struct ll_rpc_opcode { { OST_QUOTACHECK, "ost_quotacheck" }, { OST_QUOTACTL, "ost_quotactl" }, { OST_QUOTA_ADJUST_QUNIT, "ost_quota_adjust_qunit" }, + { OST_LADVISE, "ost_ladvise" }, { MDS_GETATTR, "mds_getattr" }, { MDS_GETATTR_NAME, "mds_getattr_lock" }, { MDS_CLOSE, "mds_close" }, @@ -80,7 +78,7 @@ struct ll_rpc_opcode { { MDS_READPAGE, "mds_readpage" }, { MDS_CONNECT, "mds_connect" }, { MDS_DISCONNECT, "mds_disconnect" }, - { MDS_GETSTATUS, "mds_getstatus" }, + { MDS_GET_ROOT, "mds_get_root" }, { MDS_STATFS, "mds_statfs" }, { MDS_PIN, "mds_pin" }, { MDS_UNPIN, "mds_unpin" }, @@ -136,10 +134,13 @@ struct ll_rpc_opcode { { SEC_CTX_INIT_CONT,"sec_ctx_init_cont" }, { SEC_CTX_FINI, "sec_ctx_fini" }, { FLD_QUERY, "fld_query" }, - { UPDATE_OBJ, "update_obj" }, + { FLD_READ, "fld_read" }, + { OUT_UPDATE, "out_update" }, + { LFSCK_NOTIFY, "lfsck_notify" }, + { LFSCK_QUERY, "lfsck_query" }, }; -struct ll_eopcode { +static struct ll_eopcode { __u32 opcode; const char *opname; } ll_eopcode_table[EXTRA_LAST_OPC] = { @@ -178,13 +179,14 @@ const char *ll_opcode2str(__u32 opcode) return ll_rpc_opcode_table[offset].opname; } -const char* ll_eopcode2str(__u32 opcode) +static const char *ll_eopcode2str(__u32 opcode) { LASSERT(ll_eopcode_table[opcode].opcode == opcode); return ll_eopcode_table[opcode].opname; } -#ifdef LPROCFS -void ptlrpc_lprocfs_register(struct proc_dir_entry *root, char *dir, + +#ifdef CONFIG_PROC_FS +static void ptlrpc_lprocfs_register(struct proc_dir_entry *root, char *dir, char *name, struct proc_dir_entry **procroot_ret, struct lprocfs_stats **stats_ret) { @@ -202,7 +204,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_register(dir, root, NULL, NULL); if (IS_ERR(svc_procroot)) { lprocfs_free_stats(&svc_stats); return; @@ -257,91 +259,95 @@ 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); + seq_printf(m, "%d\n", total); + return 0; } +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); + seq_printf(m, "%d\n", total); + return 0; } -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 __user *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; + __s64 val; + int rc; - rc = lprocfs_write_helper(buffer, count, &val); - if (rc < 0) - return rc; + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc < 0) + return rc; - if (val < 0) - return -ERANGE; + if (val < 0 || val > INT_MAX) + return -ERANGE; - /* This sanity check is more of an insanity check; we can still - * hose a kernel by allowing the request history to grow too - * far. */ + /* This sanity check is more of an insanity check; we can still + * hose a kernel by allowing the request history to grow too + * far. */ bufpages = (svc->srv_buf_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; - if (val > num_physpages/(2 * bufpages)) - return -ERANGE; + if (val > totalram_pages/(2 * bufpages)) + return -ERANGE; spin_lock(&svc->srv_lock); if (val == 0) svc->srv_hist_nrqbds_cpt_max = 0; else - svc->srv_hist_nrqbds_cpt_max = max(1, (val / svc->srv_ncpts)); + svc->srv_hist_nrqbds_cpt_max = + max(1, ((int)val / svc->srv_ncpts)); spin_unlock(&svc->srv_lock); 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); + seq_printf(m, "%d\n", + svc->srv_nthrs_cpt_init * svc->srv_ncpts); + return 0; } -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 __user *buffer, + size_t count, loff_t *off) { - struct ptlrpc_service *svc = data; - int val; - int rc = lprocfs_write_helper(buffer, count, &val); + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; + __s64 val; + int rc = lprocfs_str_to_s64(buffer, count, &val); if (rc < 0) return rc; @@ -355,45 +361,49 @@ ptlrpc_lprocfs_wr_threads_min(struct file *file, const char *buffer, return -ERANGE; } - svc->srv_nthrs_cpt_init = val / svc->srv_ncpts; + svc->srv_nthrs_cpt_init = (int)val / svc->srv_ncpts; spin_unlock(&svc->srv_lock); 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); + seq_printf(m, "%d\n", total); + return 0; } +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); + seq_printf(m, "%d\n", + svc->srv_nthrs_cpt_limit * svc->srv_ncpts); + return 0; } -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 __user *buffer, + size_t count, loff_t *off) { - struct ptlrpc_service *svc = data; - int val; - int rc = lprocfs_write_helper(buffer, count, &val); + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; + __s64 val; + int rc = lprocfs_str_to_s64(buffer, count, &val); if (rc < 0) return rc; @@ -407,18 +417,13 @@ ptlrpc_lprocfs_wr_threads_max(struct file *file, const char *buffer, return -ERANGE; } - svc->srv_nthrs_cpt_limit = val / svc->srv_ncpts; + svc->srv_nthrs_cpt_limit = (int)val / svc->srv_ncpts; spin_unlock(&svc->srv_lock); return count; } - -/** - * \addtogoup nrs - * @{ - */ -extern struct nrs_core nrs_core; +LPROC_SEQ_FOPS(ptlrpc_lprocfs_threads_max); /** * Translates \e ptlrpc_nrs_pol_state values to human-readable strings. @@ -456,9 +461,11 @@ void nrs_policy_get_info_locked(struct ptlrpc_nrs_policy *policy, { LASSERT(policy != NULL); LASSERT(info != NULL); - LASSERT(spin_is_locked(&policy->pol_nrs->nrs_lock)); + assert_spin_locked(&policy->pol_nrs->nrs_lock); + LASSERT(sizeof(info->pi_arg) == sizeof(policy->pol_arg)); memcpy(info->pi_name, policy->pol_desc->pd_name, NRS_POL_NAME_MAX); + memcpy(info->pi_arg, policy->pol_arg, sizeof(policy->pol_arg)); info->pi_fallback = !!(policy->pol_flags & PTLRPC_NRS_FL_FALLBACK); info->pi_state = policy->pol_state; @@ -474,10 +481,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; @@ -488,7 +494,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; /** @@ -519,8 +524,8 @@ again: pol_idx = 0; - cfs_list_for_each_entry(policy, &nrs->nrs_policy_list, - pol_list) { + list_for_each_entry(policy, &nrs->nrs_policy_list, + pol_list) { LASSERT(pol_idx < num_pols); nrs_policy_get_info_locked(policy, &tmp); @@ -531,6 +536,8 @@ again: if (i == 0) { memcpy(infos[pol_idx].pi_name, tmp.pi_name, NRS_POL_NAME_MAX); + memcpy(infos[pol_idx].pi_arg, tmp.pi_arg, + sizeof(tmp.pi_arg)); memcpy(&infos[pol_idx].pi_state, &tmp.pi_state, sizeof(tmp.pi_state)); infos[pol_idx].pi_fallback = tmp.pi_fallback; @@ -542,6 +549,9 @@ again: LASSERT(strncmp(infos[pol_idx].pi_name, tmp.pi_name, NRS_POL_NAME_MAX) == 0); + LASSERT(strncmp(infos[pol_idx].pi_arg, + tmp.pi_arg, + sizeof(tmp.pi_arg)) == 0); /** * Not asserting ptlrpc_nrs_pol_info::pi_state, * because it may be different between @@ -590,38 +600,27 @@ 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; + if (strlen(infos[pol_idx].pi_arg) > 0) + seq_printf(m, " - name: %s %s\n", + infos[pol_idx].pi_name, + infos[pol_idx].pi_arg); + else + seq_printf(m, " - name: %s\n", + infos[pol_idx].pi_name); + + + seq_printf(m, " state: %s\n" + " fallback: %s\n" + " queued: %-20d\n" + " active: %-20d\n\n", + 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)) { @@ -634,8 +633,6 @@ again: goto again; } - *eof = 1; - out: if (infos) OBD_FREE(infos, num_pols * sizeof(*infos)); @@ -645,11 +642,14 @@ out: RETURN(rc); } + +#define LPROCFS_NRS_WR_MAX_ARG (1024) /** * The longest valid command string is the maxium policy name size, plus the - * length of the " reg" substring + * length of the " reg" substring, plus the lenght of argument */ -#define LPROCFS_NRS_WR_MAX_CMD (NRS_POL_NAME_MAX + sizeof(" reg") - 1) +#define LPROCFS_NRS_WR_MAX_CMD (NRS_POL_NAME_MAX + sizeof(" reg") - 1 \ + + LPROCFS_NRS_WR_MAX_ARG) /** * Starts and stops a given policy on a PTLRPC service. @@ -658,14 +658,17 @@ 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 __user *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; - char *token; + char *policy_name; + char *queue_name; int rc = 0; ENTRY; @@ -685,9 +688,9 @@ static int ptlrpc_lprocfs_wr_nrs(struct file *file, const char *buffer, cmd[count] = '\0'; - token = strsep(&cmd, " "); + policy_name = strsep(&cmd, " "); - if (strlen(token) > NRS_POL_NAME_MAX - 1) + if (strlen(policy_name) > NRS_POL_NAME_MAX - 1) GOTO(out, rc = -EINVAL); /** @@ -696,15 +699,20 @@ static int ptlrpc_lprocfs_wr_nrs(struct file *file, const char *buffer, if (cmd == NULL) goto default_queue; + queue_name = strsep(&cmd, " "); /** - * The second token is either NULL, or an optional [reg|hp] string + * The second token is either an optional [reg|hp] string, + * or arguments */ - if (strcmp(cmd, "reg") == 0) + if (strcmp(queue_name, "reg") == 0) queue = PTLRPC_NRS_QUEUE_REG; - else if (strcmp(cmd, "hp") == 0) + else if (strcmp(queue_name, "hp") == 0) queue = PTLRPC_NRS_QUEUE_HP; - else - GOTO(out, rc = -EINVAL); + else { + if (cmd != NULL) + *(cmd - 1) = ' '; + cmd = queue_name; + } default_queue: @@ -719,8 +727,9 @@ default_queue: */ mutex_lock(&nrs_core.nrs_mutex); - rc = ptlrpc_nrs_policy_control(svc, queue, token, PTLRPC_NRS_CTL_START, - false, NULL); + rc = ptlrpc_nrs_policy_control(svc, queue, policy_name, + PTLRPC_NRS_CTL_START, + false, cmd); mutex_unlock(&nrs_core.nrs_mutex); out: @@ -729,6 +738,7 @@ out: RETURN(rc < 0 ? rc : count); } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs); /** @} nrs */ @@ -738,12 +748,12 @@ struct ptlrpc_srh_iterator { struct ptlrpc_request *srhi_req; }; -int +static int ptlrpc_lprocfs_svc_req_history_seek(struct ptlrpc_service_part *svcpt, struct ptlrpc_srh_iterator *srhi, __u64 seq) { - cfs_list_t *e; + struct list_head *e; struct ptlrpc_request *req; if (srhi->srhi_req != NULL && @@ -759,7 +769,7 @@ ptlrpc_lprocfs_svc_req_history_seek(struct ptlrpc_service_part *svcpt, "%s:%d: seek seq "LPU64", request seq "LPU64"\n", svcpt->scp_service->srv_name, svcpt->scp_cpt, srhi->srhi_seq, srhi->srhi_req->rq_history_seq); - LASSERTF(!cfs_list_empty(&svcpt->scp_hist_reqs), + LASSERTF(!list_empty(&svcpt->scp_hist_reqs), "%s:%d: seek offset "LPU64", request seq "LPU64", " "last culled "LPU64"\n", svcpt->scp_service->srv_name, svcpt->scp_cpt, @@ -771,7 +781,7 @@ ptlrpc_lprocfs_svc_req_history_seek(struct ptlrpc_service_part *svcpt, } while (e != &svcpt->scp_hist_reqs) { - req = cfs_list_entry(e, struct ptlrpc_request, rq_history_list); + req = list_entry(e, struct ptlrpc_request, rq_history_list); if (req->rq_history_seq >= seq) { srhi->srhi_seq = req->rq_history_seq; @@ -953,27 +963,41 @@ static int ptlrpc_lprocfs_svc_req_history_show(struct seq_file *s, void *iter) rc = ptlrpc_lprocfs_svc_req_history_seek(svcpt, srhi, srhi->srhi_seq); - if (rc == 0) { - req = srhi->srhi_req; - - /* Print common req fields. - * CAVEAT EMPTOR: we're racing with the service handler - * here. The request could contain any old crap, so you - * must be just as careful as the service's request - * parser. Currently I only print stuff here I know is OK - * to look at coz it was set up in request_in_callback()!!! */ - seq_printf(s, LPD64":%s:%s:x"LPU64":%d:%s:%ld:%lds(%+lds) ", - req->rq_history_seq, libcfs_nid2str(req->rq_self), - libcfs_id2str(req->rq_peer), req->rq_xid, - req->rq_reqlen, ptlrpc_rqphase2str(req), - req->rq_arrival_time.tv_sec, - req->rq_sent - req->rq_arrival_time.tv_sec, - req->rq_sent - req->rq_deadline); + if (rc == 0) { + struct timespec arrival, sent, arrivaldiff; + char nidstr[LNET_NIDSTR_SIZE]; + + req = srhi->srhi_req; + + libcfs_nid2str_r(req->rq_self, nidstr, sizeof(nidstr)); + arrival.tv_sec = req->rq_arrival_time.tv_sec; + arrival.tv_nsec = + req->rq_arrival_time.tv_usec * NSEC_PER_USEC; + sent.tv_sec = req->rq_sent; + sent.tv_nsec = 0; + arrivaldiff = timespec_sub(sent, arrival); + + /* Print common req fields. + * CAVEAT EMPTOR: we're racing with the service handler + * here. The request could contain any old crap, so you + * must be just as careful as the service's request + * parser. Currently I only print stuff here I know is OK + * to look at coz it was set up in request_in_callback()!!! */ + seq_printf(s, LPD64":%s:%s:x"LPU64":%d:%s:" + "%ld.%06ld:%ld.%06lds(%+ld.0s) ", + req->rq_history_seq, nidstr, + libcfs_id2str(req->rq_peer), req->rq_xid, + req->rq_reqlen, ptlrpc_rqphase2str(req), + req->rq_arrival_time.tv_sec, + req->rq_arrival_time.tv_usec, + arrivaldiff.tv_sec, + arrivaldiff.tv_nsec / NSEC_PER_USEC, + req->rq_sent - req->rq_deadline); if (svc->srv_ops.so_req_printer == NULL) seq_printf(s, "\n"); else svc->srv_ops.so_req_printer(s, srhi->srhi_req); - } + } spin_unlock(&svcpt->scp_lock); return rc; @@ -982,45 +1006,43 @@ 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; + 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; + + rc = LPROCFS_ENTRY_CHECK(inode); + if (rc < 0) + return rc; - LPROCFS_ENTRY_CHECK(dp); - rc = seq_open(file, &sops); + 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) { @@ -1029,54 +1051,38 @@ 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_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; + seq_printf(m, "%d\n", svc->srv_hpreq_ratio); + return 0; } -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 __user *buffer, + size_t count, loff_t *off) { - struct ptlrpc_service *svc = data; - int rc; - int val; + struct seq_file *m = file->private_data; + struct ptlrpc_service *svc = m->private; + int rc; + __s64 val; - rc = lprocfs_write_helper(buffer, count, &val); + rc = lprocfs_str_to_s64(buffer, count, &val); if (rc < 0) return rc; - if (val < 0) + if (val < 0 || val > INT_MAX) return -ERANGE; spin_lock(&svc->srv_lock); @@ -1085,41 +1091,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_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, @@ -1132,18 +1134,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_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) @@ -1215,180 +1216,138 @@ 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, - unsigned long count, void *data) -{ - struct obd_device *obd = data; - char *kbuf; - char *tmpbuf; - - OBD_ALLOC(kbuf, BUFLEN); - if (kbuf == NULL) - return -ENOMEM; - - /* - * OBD_ALLOC() will zero kbuf, but we only copy BUFLEN - 1 - * bytes into kbuf, to ensure that the string is NUL-terminated. - * UUID_MAX should include a trailing NUL already. - */ - if (copy_from_user(kbuf, buffer, - min_t(unsigned long, BUFLEN - 1, count))) { - count = -EFAULT; - goto out; - } - tmpbuf = cfs_firststr(kbuf, min_t(unsigned long, BUFLEN - 1, count)); - class_incref(obd, __FUNCTION__, cfs_current()); - - if (strncmp(tmpbuf, "nid:", 4) == 0) - obd_export_evict_by_nid(obd, tmpbuf + 4); - else if (strncmp(tmpbuf, "uuid:", 5) == 0) - obd_export_evict_by_uuid(obd, tmpbuf + 5); - else - obd_export_evict_by_uuid(obd, tmpbuf); - - class_decref(obd, __FUNCTION__, cfs_current()); - -out: - OBD_FREE(kbuf, BUFLEN); - return count; -} -EXPORT_SYMBOL(lprocfs_wr_evict_client); - -#undef BUFLEN - -int lprocfs_wr_ping(struct file *file, const char *buffer, - unsigned long count, void *data) +ssize_t +lprocfs_ping_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct obd_device *obd = data; - struct ptlrpc_request *req; - int rc; - ENTRY; + 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); + 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; + req->rq_send_state = LUSTRE_IMP_FULL; - rc = ptlrpc_queue_wait(req); + rc = ptlrpc_queue_wait(req); - ptlrpc_req_finished(req); - if (rc >= 0) - RETURN(count); - RETURN(rc); + ptlrpc_req_finished(req); + if (rc >= 0) + RETURN(count); + RETURN(rc); } -EXPORT_SYMBOL(lprocfs_wr_ping); +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". */ -int lprocfs_wr_import(struct file *file, const char *buffer, - unsigned long count, void *data) +ssize_t +lprocfs_import_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct obd_device *obd = data; - 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; + 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; + return -EINVAL; - OBD_ALLOC(kbuf, count + 1); - if (kbuf == NULL) - return -ENOMEM; + 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); - } - } + 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 += 2; /* Skip :: */ + 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); + if (do_reconn) + ptlrpc_recover_import(imp, uuid, 1); out: - OBD_FREE(kbuf, count + 1); - return count; + OBD_FREE(kbuf, count + 1); + return count; } -EXPORT_SYMBOL(lprocfs_wr_import); +EXPORT_SYMBOL(lprocfs_import_seq_write); -int lprocfs_rd_pinger_recov(char *page, char **start, off_t off, - int count, int *eof, void *data) +int lprocfs_pinger_recov_seq_show(struct seq_file *m, void *n) { - struct obd_device *obd = data; - struct obd_import *imp = obd->u.cli.cl_import; - int rc; + struct obd_device *obd = m->private; + struct obd_import *imp = obd->u.cli.cl_import; - LPROCFS_CLIMP_CHECK(obd); - rc = snprintf(page, count, "%d\n", !imp->imp_no_pinger_recover); - LPROCFS_CLIMP_EXIT(obd); - - return rc; + LPROCFS_CLIMP_CHECK(obd); + seq_printf(m, "%d\n", !imp->imp_no_pinger_recover); + LPROCFS_CLIMP_EXIT(obd); + return 0; } -EXPORT_SYMBOL(lprocfs_rd_pinger_recov); +EXPORT_SYMBOL(lprocfs_pinger_recov_seq_show); -int lprocfs_wr_pinger_recov(struct file *file, const char *buffer, - unsigned long count, void *data) +ssize_t +lprocfs_pinger_recov_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { - struct obd_device *obd = data; - 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; + 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; + __s64 val; + + rc = lprocfs_str_to_s64(buffer, count, &val); + if (rc < 0) + return rc; - if (val != 0 && val != 1) - return -ERANGE; + if (val != 0 && val != 1) + return -ERANGE; - LPROCFS_CLIMP_CHECK(obd); + 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_wr_pinger_recov); +EXPORT_SYMBOL(lprocfs_pinger_recov_seq_write); -#endif /* LPROCFS */ +#endif /* CONFIG_PROC_FS */