* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
{ 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" },
{ 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" },
return ll_eopcode_table[opcode].opname;
}
-#ifdef LPROCFS
+#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)
return;
if (dir) {
- svc_procroot = lprocfs_seq_register(dir, root, NULL, NULL);
+ svc_procroot = lprocfs_register(dir, root, NULL, NULL);
if (IS_ERR(svc_procroot)) {
lprocfs_free_stats(&svc_stats);
return;
ptlrpc_service_for_each_part(svcpt, i, svc)
total += svcpt->scp_hist_nrqbds;
- return seq_printf(m, "%d\n", total);
+ seq_printf(m, "%d\n", total);
+ return 0;
}
LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_req_history_len);
ptlrpc_service_for_each_part(svcpt, i, svc)
total += svc->srv_hist_nrqbds_cpt_max;
- return seq_printf(m, "%d\n", total);
+ seq_printf(m, "%d\n", total);
+ return 0;
}
static ssize_t
const char __user *buffer,
size_t count, loff_t *off)
{
- struct seq_file *m = file->private_data;
- struct ptlrpc_service *svc = m->private;
- 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 > totalram_pages/(2 * bufpages))
- return -ERANGE;
+ 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);
{
struct ptlrpc_service *svc = m->private;
- return seq_printf(m, "%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 ssize_t
const char __user *buffer,
size_t count, loff_t *off)
{
- struct seq_file *m = file->private_data;
- struct ptlrpc_service *svc = m->private;
- 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;
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);
ptlrpc_service_for_each_part(svcpt, i, svc)
total += svcpt->scp_nthrs_running;
- return seq_printf(m, "%d\n", total);
+ seq_printf(m, "%d\n", total);
+ return 0;
}
LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_threads_started);
{
struct ptlrpc_service *svc = m->private;
- return seq_printf(m, "%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 ssize_t
const char __user *buffer,
size_t count, loff_t *off)
{
- struct seq_file *m = file->private_data;
- struct ptlrpc_service *svc = m->private;
- 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;
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);
LASSERT(info != NULL);
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;
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;
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
"high_priority_requests:");
for (pol_idx = 0; pol_idx < num_pols; pol_idx++) {
- 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 (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)) {
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;
struct seq_file *seqf;
int rc;
- LPROCFS_ENTRY_CHECK(PDE(inode));
+ rc = LPROCFS_ENTRY_CHECK(inode);
+ if (rc < 0)
+ return rc;
+
rc = seq_open(file, &sops);
if (rc)
return rc;
DHMS_FMT" ago) ", "service",
cur, worst, worstt, DHMS_VARS(&ts));
- lprocfs_seq_at_hist_helper(m, &svcpt->scp_at_estimate);
+ lprocfs_at_hist_helper(m, &svcpt->scp_at_estimate);
}
return 0;
static int ptlrpc_lprocfs_hp_ratio_seq_show(struct seq_file *m, void *v)
{
struct ptlrpc_service *svc = m->private;
- return seq_printf(m, "%d\n", svc->srv_hpreq_ratio);
+ seq_printf(m, "%d\n", svc->srv_hpreq_ratio);
+ return 0;
}
static ssize_t
ptlrpc_lprocfs_hp_ratio_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
{
- struct seq_file *m = file->private_data;
- struct ptlrpc_service *svc = m->private;
- 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);
void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry,
struct ptlrpc_service *svc)
{
- struct lprocfs_seq_vars lproc_vars[] = {
+ struct lprocfs_vars lproc_vars[] = {
{ .name = "high_priority_ratio",
.fops = &ptlrpc_lprocfs_hp_ratio_fops,
.data = svc },
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);
EXPORT_SYMBOL(ptlrpc_lprocfs_unregister_obd);
ssize_t
-lprocfs_ping_seq_write(struct file *file, const char *buffer,
+lprocfs_ping_seq_write(struct file *file, const char __user *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;
- int rc;
LPROCFS_CLIMP_CHECK(obd);
- rc = seq_printf(m, "%d\n", !imp->imp_no_pinger_recover);
+ seq_printf(m, "%d\n", !imp->imp_no_pinger_recover);
LPROCFS_CLIMP_EXIT(obd);
- return rc;
+ return 0;
}
EXPORT_SYMBOL(lprocfs_pinger_recov_seq_show);
ssize_t
-lprocfs_pinger_recov_seq_write(struct file *file, const char *buffer,
+lprocfs_pinger_recov_seq_write(struct file *file, const char __user *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;
+ 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_write_helper(buffer, count, &val);
+ rc = lprocfs_str_to_s64(buffer, count, &val);
if (rc < 0)
return rc;
}
EXPORT_SYMBOL(lprocfs_pinger_recov_seq_write);
-#endif /* LPROCFS */
+#endif /* CONFIG_PROC_FS */
git://git.whamcloud.com / fs / lustre-release.git / blobdiff