return ll_eopcode_table[opcode].opname;
}
-#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)
+static void
+ptlrpc_ldebugfs_register(struct dentry *root, char *dir, char *name,
+ struct dentry **debugfs_root_ret,
+ struct lprocfs_stats **stats_ret)
{
- struct proc_dir_entry *svc_procroot;
+ struct dentry *svc_debugfs_entry;
struct lprocfs_stats *svc_stats;
int i, rc;
unsigned int svc_counter_config = LPROCFS_CNTR_AVGMINMAX |
LPROCFS_CNTR_STDDEV;
- LASSERT(*procroot_ret == NULL);
- LASSERT(*stats_ret == NULL);
+ LASSERT(!*debugfs_root_ret);
+ LASSERT(!*stats_ret);
- svc_stats = lprocfs_alloc_stats(EXTRA_MAX_OPCODES+LUSTRE_MAX_OPCODES,0);
- if (svc_stats == NULL)
+ svc_stats = lprocfs_alloc_stats(EXTRA_MAX_OPCODES + LUSTRE_MAX_OPCODES,
+ 0);
+ if (!svc_stats)
return;
if (dir) {
- svc_procroot = lprocfs_register(dir, root, NULL, NULL);
- if (IS_ERR(svc_procroot)) {
+ svc_debugfs_entry = ldebugfs_register(dir, root, NULL, NULL);
+ if (IS_ERR(svc_debugfs_entry)) {
lprocfs_free_stats(&svc_stats);
return;
}
} else {
- svc_procroot = root;
+ svc_debugfs_entry = root;
}
lprocfs_counter_init(svc_stats, PTLRPC_REQWAIT_CNTR,
for (i = 0; i < EXTRA_LAST_OPC; i++) {
char *units;
- switch(i) {
+ switch (i) {
case BRW_WRITE_BYTES:
case BRW_READ_BYTES:
units = "bytes";
ll_opcode2str(opcode), "usec");
}
- rc = lprocfs_register_stats(svc_procroot, name, svc_stats);
+ rc = ldebugfs_register_stats(svc_debugfs_entry, name, svc_stats);
if (rc < 0) {
if (dir)
- lprocfs_remove(&svc_procroot);
+ ldebugfs_remove(&svc_debugfs_entry);
lprocfs_free_stats(&svc_stats);
} else {
if (dir)
- *procroot_ret = svc_procroot;
+ *debugfs_root_ret = svc_debugfs_entry;
*stats_ret = svc_stats;
}
}
seq_printf(m, "%d\n", total);
return 0;
}
-LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_req_history_len);
+
+
+LDEBUGFS_SEQ_FOPS_RO(ptlrpc_lprocfs_req_history_len);
static int
ptlrpc_lprocfs_req_history_max_seq_show(struct seq_file *m, void *n)
{
struct seq_file *m = file->private_data;
struct ptlrpc_service *svc = m->private;
+ unsigned long long val;
int bufpages;
- __s64 val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoull_from_user(buffer, count, 0, &val);
if (rc < 0)
return rc;
bufpages = (roundup_pow_of_two(svc->srv_buf_size) + PAGE_SIZE - 1) >>
PAGE_SHIFT;
/* do not allow history to consume more than half max number of rqbds */
- if ((svc->srv_nrqbds_max == 0 && val > totalram_pages/(2 * bufpages)) ||
- val > svc->srv_nrqbds_max/2)
+ if ((svc->srv_nrqbds_max == 0 && val > totalram_pages / (2 * bufpages)) ||
+ (svc->srv_nrqbds_max != 0 && val > svc->srv_nrqbds_max / 2))
return -ERANGE;
spin_lock(&svc->srv_lock);
return count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_req_history_max);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_req_history_max);
static int
ptlrpc_lprocfs_req_buffers_max_seq_show(struct seq_file *m, void *n)
{
struct seq_file *m = file->private_data;
struct ptlrpc_service *svc = m->private;
- __s64 val;
+ int val;
int rc;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtoint_from_user(buffer, count, 0, &val);
if (rc < 0)
return rc;
- if (val < 0 || val > INT_MAX)
- return -ERANGE;
-
- if (val < svc->srv_nbuf_per_group)
+ if (val < svc->srv_nbuf_per_group && val != 0)
return -ERANGE;
spin_lock(&svc->srv_lock);
return count;
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_req_buffers_max);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_req_buffers_max);
static ssize_t threads_min_show(struct kobject *kobj, struct attribute *attr,
char *buf)
RETURN(rc < 0 ? rc : count);
}
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs);
/** @} nrs */
return rc;
seqf = file->private_data;
- seqf->private = PDE_DATA(inode);
+ seqf->private = inode->i_private;
return 0;
}
return 0;
}
-LPROC_SEQ_FOPS_RO(ptlrpc_lprocfs_timeouts);
+
+LDEBUGFS_SEQ_FOPS_RO(ptlrpc_lprocfs_timeouts);
static ssize_t high_priority_ratio_show(struct kobject *kobj,
struct attribute *attr,
&parent->kobj, "%s", svc->srv_name);
}
-void ptlrpc_lprocfs_register_service(struct proc_dir_entry *entry,
- struct ptlrpc_service *svc)
+void ptlrpc_ldebugfs_register_service(struct dentry *entry,
+ struct ptlrpc_service *svc)
{
struct lprocfs_vars lproc_vars[] = {
{ .name = "req_buffer_history_len",
int rc;
- ptlrpc_lprocfs_register(entry, svc->srv_name,
- "stats", &svc->srv_procroot,
- &svc->srv_stats);
- if (svc->srv_procroot == NULL)
+ ptlrpc_ldebugfs_register(entry, svc->srv_name, "stats",
+ &svc->srv_debugfs_entry, &svc->srv_stats);
+ if (IS_ERR_OR_NULL(svc->srv_debugfs_entry))
return;
- lprocfs_add_vars(svc->srv_procroot, lproc_vars, NULL);
+ ldebugfs_add_vars(svc->srv_debugfs_entry, lproc_vars, NULL);
- rc = lprocfs_seq_create(svc->srv_procroot, "req_history",
- 0400, &req_history_fops, svc);
+ rc = ldebugfs_seq_create(svc->srv_debugfs_entry, "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)
{
- ptlrpc_lprocfs_register(obddev->obd_proc_entry, NULL, "stats",
- &obddev->obd_svc_procroot,
- &obddev->obd_svc_stats);
+ ptlrpc_ldebugfs_register(obddev->obd_debugfs_entry, NULL, "stats",
+ &obddev->obd_svc_debugfs_entry,
+ &obddev->obd_svc_stats);
}
EXPORT_SYMBOL(ptlrpc_lprocfs_register_obd);
void ptlrpc_lprocfs_unregister_service(struct ptlrpc_service *svc)
{
- if (svc->srv_procroot != NULL)
- lprocfs_remove(&svc->srv_procroot);
+ if (!IS_ERR_OR_NULL(svc->srv_debugfs_entry))
+ ldebugfs_remove(&svc->srv_debugfs_entry);
if (svc->srv_stats)
lprocfs_free_stats(&svc->srv_stats);
*/
lprocfs_obd_cleanup(obd);
- if (obd->obd_svc_procroot)
- lprocfs_remove(&obd->obd_svc_procroot);
+ if (!IS_ERR_OR_NULL(obd->obd_svc_debugfs_entry))
+ ldebugfs_remove(&obd->obd_svc_debugfs_entry);
if (obd->obd_svc_stats)
lprocfs_free_stats(&obd->obd_svc_stats);
}
EXPORT_SYMBOL(ptlrpc_lprocfs_unregister_obd);
+ssize_t ping_store(struct kobject *kobj, struct attribute *attr,
+ const char *buffer, size_t count)
+{
+ struct obd_device *obd = container_of(kobj, struct obd_device,
+ obd_kset.kobj);
+ 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)
+ RETURN(-ENOMEM);
+
+ req->rq_send_state = LUSTRE_IMP_FULL;
+
+ rc = ptlrpc_queue_wait(req);
+ ptlrpc_req_finished(req);
+
+ RETURN(rc >= 0 ? count : rc);
+}
+EXPORT_SYMBOL(ping_store);
+
ssize_t
lprocfs_ping_seq_write(struct file *file, const char __user *buffer,
size_t count, loff_t *off)
struct obd_device *obd = m->private;
struct client_obd *cli = &obd->u.cli;
struct obd_import *imp = cli->cl_import;
+ bool val;
int rc;
- __s64 val;
- rc = lprocfs_str_to_s64(buffer, count, &val);
+ rc = kstrtobool_from_user(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;
return count;
}
EXPORT_SYMBOL(lprocfs_pinger_recov_seq_write);
-
-#endif /* CONFIG_PROC_FS */