#include <lustre_fid.h>
#include "fid_internal.h"
-static void seq_server_proc_fini(struct lu_server_seq *seq);
-
/* Assigns client to sequence controller node. */
int seq_server_set_cli(const struct lu_env *env, struct lu_server_seq *seq,
struct lu_client_seq *cli)
/* context key: seq_thread_key */
LU_CONTEXT_KEY_DEFINE(seq, LCT_MD_THREAD | LCT_DT_THREAD);
-extern const struct file_operations seq_fld_proc_seq_fops;
+extern const struct file_operations seq_fld_debugfs_seq_fops;
+
+static void seq_server_debugfs_fini(struct lu_server_seq *seq)
+{
+ if (!IS_ERR_OR_NULL(seq->lss_debugfs_entry))
+ ldebugfs_remove(&seq->lss_debugfs_entry);
+}
-static int seq_server_proc_init(struct lu_server_seq *seq)
+static int seq_server_debugfs_init(struct lu_server_seq *seq)
{
-#ifdef CONFIG_PROC_FS
int rc;
ENTRY;
- seq->lss_proc_dir = lprocfs_register(seq->lss_name,
- seq_type_proc_dir,
- NULL, NULL);
- if (IS_ERR(seq->lss_proc_dir)) {
- rc = PTR_ERR(seq->lss_proc_dir);
+ seq->lss_debugfs_entry = ldebugfs_register(seq->lss_name,
+ seq_debugfs_dir,
+ NULL, NULL);
+ if (IS_ERR_OR_NULL(seq->lss_debugfs_entry)) {
+ rc = seq->lss_debugfs_entry ? PTR_ERR(seq->lss_debugfs_entry)
+ : -ENOMEM;
+ seq->lss_debugfs_entry = NULL;
RETURN(rc);
}
- rc = lprocfs_add_vars(seq->lss_proc_dir, seq_server_proc_list, seq);
+ rc = ldebugfs_add_vars(seq->lss_debugfs_entry,
+ seq_server_debugfs_list, seq);
if (rc) {
- CERROR("%s: Can't init sequence manager "
- "proc, rc %d\n", seq->lss_name, rc);
+ CERROR("%s: Can't init sequence manager debugfs, rc %d\n",
+ seq->lss_name, rc);
GOTO(out_cleanup, rc);
}
if (seq->lss_type == LUSTRE_SEQ_CONTROLLER) {
- rc = lprocfs_seq_create(seq->lss_proc_dir, "fldb", 0644,
- &seq_fld_proc_seq_fops, seq);
+ rc = ldebugfs_seq_create(seq->lss_debugfs_entry, "fldb", 0644,
+ &seq_fld_debugfs_seq_fops, seq);
if (rc) {
- CERROR("%s: Can't create fldb for sequence manager "
- "proc: rc = %d\n", seq->lss_name, rc);
+ CERROR("%s: Can't create fldb for sequence manager debugfs: rc = %d\n",
+ seq->lss_name, rc);
GOTO(out_cleanup, rc);
}
}
RETURN(0);
out_cleanup:
- seq_server_proc_fini(seq);
+ seq_server_debugfs_fini(seq);
return rc;
-#else /* !CONFIG_PROC_FS */
- return 0;
-#endif /* CONFIG_PROC_FS */
-}
-
-static void seq_server_proc_fini(struct lu_server_seq *seq)
-{
-#ifdef CONFIG_PROC_FS
- ENTRY;
- if (seq->lss_proc_dir != NULL) {
- if (!IS_ERR(seq->lss_proc_dir))
- lprocfs_remove(&seq->lss_proc_dir);
- seq->lss_proc_dir = NULL;
- }
- EXIT;
-#endif /* CONFIG_PROC_FS */
}
int seq_server_init(const struct lu_env *env,
lu_seq_range_is_sane(&seq->lss_space));
}
- rc = seq_server_proc_init(seq);
+ rc = seq_server_debugfs_init(seq);
if (rc)
GOTO(out, rc);
{
ENTRY;
- seq_server_proc_fini(seq);
+ seq_server_debugfs_fini(seq);
seq_store_fini(seq, env);
EXIT;
#define DEBUG_SUBSYSTEM S_FID
+#include <linux/err.h>
#include <linux/module.h>
#include <obd.h>
#include <obd_class.h>
#include <lustre_mdc.h>
#include "fid_internal.h"
+struct dentry *seq_debugfs_dir;
+
static int seq_client_rpc(struct lu_client_seq *seq,
struct lu_seq_range *output, __u32 opc,
const char *opcname)
}
EXPORT_SYMBOL(seq_client_flush);
-static void seq_client_proc_fini(struct lu_client_seq *seq)
+static void seq_client_debugfs_fini(struct lu_client_seq *seq)
{
-#ifdef CONFIG_PROC_FS
- ENTRY;
- if (seq->lcs_proc_dir) {
- if (!IS_ERR(seq->lcs_proc_dir))
- lprocfs_remove(&seq->lcs_proc_dir);
- seq->lcs_proc_dir = NULL;
- }
- EXIT;
-#endif /* CONFIG_PROC_FS */
+ if (!IS_ERR_OR_NULL(seq->lcs_debugfs_entry))
+ ldebugfs_remove(&seq->lcs_debugfs_entry);
}
-static int seq_client_proc_init(struct lu_client_seq *seq)
+static int seq_client_debugfs_init(struct lu_client_seq *seq)
{
-#ifdef CONFIG_PROC_FS
int rc;
- ENTRY;
- seq->lcs_proc_dir = lprocfs_register(seq->lcs_name, seq_type_proc_dir,
- NULL, NULL);
- if (IS_ERR(seq->lcs_proc_dir)) {
- CERROR("%s: LProcFS failed in seq-init\n",
- seq->lcs_name);
- rc = PTR_ERR(seq->lcs_proc_dir);
- RETURN(rc);
+ seq->lcs_debugfs_entry = ldebugfs_register(seq->lcs_name,
+ seq_debugfs_dir,
+ NULL, NULL);
+ if (IS_ERR_OR_NULL(seq->lcs_debugfs_entry)) {
+ CERROR("%s: LdebugFS failed in seq-init\n", seq->lcs_name);
+ rc = seq->lcs_debugfs_entry ? PTR_ERR(seq->lcs_debugfs_entry)
+ : -ENOMEM;
+ seq->lcs_debugfs_entry = NULL;
+ RETURN(rc);
}
- rc = lprocfs_add_vars(seq->lcs_proc_dir, seq_client_proc_list, seq);
- if (rc) {
- CERROR("%s: Can't init sequence manager "
- "proc, rc %d\n", seq->lcs_name, rc);
+ rc = ldebugfs_add_vars(seq->lcs_debugfs_entry,
+ seq_client_debugfs_list, seq);
+ if (rc) {
+ CERROR("%s: Can't init sequence manager debugfs, rc %d\n",
+ seq->lcs_name, rc);
GOTO(out_cleanup, rc);
}
RETURN(0);
out_cleanup:
- seq_client_proc_fini(seq);
+ seq_client_debugfs_fini(seq);
return rc;
+}
-#else /* !CONFIG_PROC_FS */
- return 0;
-#endif /* CONFIG_PROC_FS */
+void seq_client_fini(struct lu_client_seq *seq)
+{
+ ENTRY;
+
+ seq_client_debugfs_fini(seq);
+
+ if (seq->lcs_exp != NULL) {
+ class_export_put(seq->lcs_exp);
+ seq->lcs_exp = NULL;
+ }
+
+ seq->lcs_srv = NULL;
+ EXIT;
}
+EXPORT_SYMBOL(seq_client_fini);
int seq_client_init(struct lu_client_seq *seq,
struct obd_export *exp,
snprintf(seq->lcs_name, sizeof(seq->lcs_name),
"cli-%s", prefix);
- rc = seq_client_proc_init(seq);
+ rc = seq_client_debugfs_init(seq);
if (rc)
seq_client_fini(seq);
RETURN(rc);
}
EXPORT_SYMBOL(seq_client_init);
-void seq_client_fini(struct lu_client_seq *seq)
-{
- ENTRY;
-
- seq_client_proc_fini(seq);
-
- if (seq->lcs_exp != NULL) {
- class_export_put(seq->lcs_exp);
- seq->lcs_exp = NULL;
- }
-
- seq->lcs_srv = NULL;
- EXIT;
-}
-EXPORT_SYMBOL(seq_client_fini);
-
int client_fid_init(struct obd_device *obd,
struct obd_export *exp, enum lu_cli_type type)
{
}
EXPORT_SYMBOL(client_fid_fini);
-struct proc_dir_entry *seq_type_proc_dir;
-
static int __init fid_init(void)
{
- seq_type_proc_dir = lprocfs_register(LUSTRE_SEQ_NAME,
- proc_lustre_root,
- NULL, NULL);
- if (IS_ERR(seq_type_proc_dir))
- return PTR_ERR(seq_type_proc_dir);
+#ifdef HAVE_SERVER_SUPPORT
+ int rc = fid_server_mod_init();
-# ifdef HAVE_SERVER_SUPPORT
- fid_server_mod_init();
-# endif
-
- return 0;
+ if (rc)
+ return rc;
+#endif
+ seq_debugfs_dir = ldebugfs_register(LUSTRE_SEQ_NAME,
+ debugfs_lustre_root,
+ NULL, NULL);
+ return PTR_ERR_OR_ZERO(seq_debugfs_dir);
}
static void __exit fid_exit(void)
# ifdef HAVE_SERVER_SUPPORT
fid_server_mod_exit();
# endif
-
- if (seq_type_proc_dir != NULL && !IS_ERR(seq_type_proc_dir)) {
- lprocfs_remove(&seq_type_proc_dir);
- seq_type_proc_dir = NULL;
- }
+ if (!IS_ERR_OR_NULL(seq_debugfs_dir))
+ ldebugfs_remove(&seq_debugfs_dir);
}
MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
#include <lprocfs_status.h>
#include "fid_internal.h"
-#ifdef CONFIG_PROC_FS
-
/* Format: [0x64BIT_INT - 0x64BIT_INT] + 32 bytes just in case */
#define MAX_FID_RANGE_STRLEN (32 + 2 * 2 * sizeof(__u64))
/**
* safe for production use.
*/
static int
-lprocfs_fid_write_common(const char __user *buffer, size_t count,
- struct lu_seq_range *range)
+ldebugfs_fid_write_common(const char __user *buffer, size_t count,
+ struct lu_seq_range *range)
{
+ char kernbuf[MAX_FID_RANGE_STRLEN];
struct lu_seq_range tmp = {
.lsr_start = 0,
};
- char kernbuf[MAX_FID_RANGE_STRLEN];
- ENTRY;
+ int rc;
- LASSERT(range != NULL);
+ ENTRY;
+ LASSERT(range);
if (count >= sizeof(kernbuf))
RETURN(-EINVAL);
if (count == 5 && strcmp(kernbuf, "clear") == 0) {
memset(range, 0, sizeof(*range));
- RETURN(0);
+ RETURN(count);
}
/* of the form "[0x0000000240000400 - 0x000000028000400]" */
- sscanf(kernbuf, "[%llx - %llx]\n",
- (long long unsigned *)&tmp.lsr_start,
- (long long unsigned *)&tmp.lsr_end);
+ rc = sscanf(kernbuf, "[%llx - %llx]\n",
+ (unsigned long long *)&tmp.lsr_start,
+ (unsigned long long *)&tmp.lsr_end);
+ if (rc != 2)
+ RETURN(-EINVAL);
if (!lu_seq_range_is_sane(&tmp) || lu_seq_range_is_zero(&tmp) ||
tmp.lsr_start < range->lsr_start || tmp.lsr_end > range->lsr_end)
RETURN(-EINVAL);
#ifdef HAVE_SERVER_SUPPORT
/*
- * Server side procfs stuff.
+ * Server side debugfs stuff.
*/
static ssize_t
-lprocfs_server_fid_space_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+ldebugfs_server_fid_space_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
+ struct lu_server_seq *seq;
int rc;
- ENTRY;
- LASSERT(seq != NULL);
+ ENTRY;
+ seq = ((struct seq_file *)file->private_data)->private;
mutex_lock(&seq->lss_mutex);
- rc = lprocfs_fid_write_common(buffer, count, &seq->lss_space);
+ rc = ldebugfs_fid_write_common(buffer, count, &seq->lss_space);
if (rc == 0) {
- CDEBUG(D_INFO, "%s: Space: "DRANGE"\n",
- seq->lss_name, PRANGE(&seq->lss_space));
+ CDEBUG(D_INFO, "%s: Space: " DRANGE "\n",
+ seq->lss_name, PRANGE(&seq->lss_space));
}
mutex_unlock(&seq->lss_mutex);
}
static int
-lprocfs_server_fid_space_seq_show(struct seq_file *m, void *unused)
+ldebugfs_server_fid_space_seq_show(struct seq_file *m, void *unused)
{
struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
ENTRY;
- LASSERT(seq != NULL);
-
mutex_lock(&seq->lss_mutex);
seq_printf(m, "[%#llx - %#llx]:%x:%s\n", PRANGE(&seq->lss_space));
mutex_unlock(&seq->lss_mutex);
}
static int
-lprocfs_server_fid_server_seq_show(struct seq_file *m, void *unused)
+ldebugfs_server_fid_server_seq_show(struct seq_file *m, void *unused)
{
struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
struct client_obd *cli;
ENTRY;
- LASSERT(seq != NULL);
-
if (seq->lss_cli) {
if (seq->lss_cli->lcs_exp != NULL) {
cli = &seq->lss_cli->lcs_exp->exp_obd->u.cli;
RETURN(0);
}
-static ssize_t
-lprocfs_server_fid_width_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t ldebugfs_server_fid_width_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct lu_server_seq *seq = m->private;
int rc;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lss_mutex);
rc = kstrtoull_from_user(buffer, count, 0, &seq->lss_width);
}
static int
-lprocfs_server_fid_width_seq_show(struct seq_file *m, void *unused)
+ldebugfs_server_fid_width_seq_show(struct seq_file *m, void *unused)
{
struct lu_server_seq *seq = (struct lu_server_seq *)m->private;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lss_mutex);
seq_printf(m, "%llu\n", seq->lss_width);
mutex_unlock(&seq->lss_mutex);
RETURN(0);
}
-LPROC_SEQ_FOPS(lprocfs_server_fid_space);
-LPROC_SEQ_FOPS(lprocfs_server_fid_width);
-LPROC_SEQ_FOPS_RO(lprocfs_server_fid_server);
+LPROC_SEQ_FOPS(ldebugfs_server_fid_space);
+LPROC_SEQ_FOPS(ldebugfs_server_fid_width);
+LPROC_SEQ_FOPS_RO(ldebugfs_server_fid_server);
-struct lprocfs_vars seq_server_proc_list[] = {
+struct lprocfs_vars seq_server_debugfs_list[] = {
{ .name = "space",
- .fops = &lprocfs_server_fid_space_fops },
+ .fops = &ldebugfs_server_fid_space_fops },
{ .name = "width",
- .fops = &lprocfs_server_fid_width_fops },
+ .fops = &ldebugfs_server_fid_width_fops },
{ .name = "server",
- .fops = &lprocfs_server_fid_server_fops },
+ .fops = &ldebugfs_server_fid_server_fops},
{ NULL }
};
static int fldb_seq_open(struct inode *inode, struct file *file)
{
struct seq_file *seq;
- struct lu_server_seq *ss = (struct lu_server_seq *) PDE_DATA(inode);
+ struct lu_server_seq *ss = inode->i_private;
struct lu_server_fld *fld;
struct dt_object *obj;
const struct dt_it_ops *iops;
fld = ss->lss_site->ss_server_fld;
LASSERT(fld != NULL);
- rc = LPROCFS_ENTRY_CHECK(inode);
- if (rc < 0)
- return rc;
-
rc = seq_open(file, &fldb_sops);
if (rc)
return rc;
param = seq->private;
if (param == NULL) {
- lprocfs_seq_release(inode, file);
+ seq_release(inode, file);
return 0;
}
iops->fini(¶m->fsp_env, param->fsp_it);
lu_env_fini(¶m->fsp_env);
OBD_FREE_PTR(param);
- lprocfs_seq_release(inode, file);
+ seq_release(inode, file);
return 0;
}
RETURN(rc < 0 ? rc : len);
}
-const struct file_operations seq_fld_proc_seq_fops = {
+const struct file_operations seq_fld_debugfs_seq_fops = {
.owner = THIS_MODULE,
.open = fldb_seq_open,
.read = seq_read,
#endif /* HAVE_SERVER_SUPPORT */
-/* Client side procfs stuff */
+/* Client side debugfs stuff */
static ssize_t
-lprocfs_client_fid_space_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+ldebugfs_client_fid_space_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
- struct lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
+ struct lu_client_seq *seq;
int rc;
- ENTRY;
- LASSERT(seq != NULL);
+ ENTRY;
+ seq = ((struct seq_file *)file->private_data)->private;
mutex_lock(&seq->lcs_mutex);
- rc = lprocfs_fid_write_common(buffer, count, &seq->lcs_space);
+ rc = ldebugfs_fid_write_common(buffer, count, &seq->lcs_space);
if (rc == 0) {
- CDEBUG(D_INFO, "%s: Space: "DRANGE"\n",
+ CDEBUG(D_INFO, "%s: Space: " DRANGE "\n",
seq->lcs_name, PRANGE(&seq->lcs_space));
}
RETURN(count);
}
-static int
-lprocfs_client_fid_space_seq_show(struct seq_file *m, void *unused)
+static int ldebugfs_client_fid_space_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lcs_mutex);
- seq_printf(m, "[%#llx - %#llx]:%x:%s\n",
- PRANGE(&seq->lcs_space));
+ seq_printf(m, "[%#llx - %#llx]:%x:%s\n", PRANGE(&seq->lcs_space));
mutex_unlock(&seq->lcs_mutex);
RETURN(0);
}
-static ssize_t
-lprocfs_client_fid_width_seq_write(struct file *file, const char __user *buffer,
- size_t count, loff_t *off)
+static ssize_t ldebugfs_client_fid_width_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
{
struct seq_file *m = file->private_data;
struct lu_client_seq *seq = m->private;
int rc;
ENTRY;
- LASSERT(seq != NULL);
-
- mutex_lock(&seq->lcs_mutex);
-
rc = kstrtoull_from_user(buffer, count, 0, &val);
- if (rc) {
- GOTO(out_unlock, count = rc);
- }
+ if (rc)
+ return rc;
+ mutex_lock(&seq->lcs_mutex);
if (seq->lcs_type == LUSTRE_SEQ_DATA)
max = LUSTRE_DATA_SEQ_MAX_WIDTH;
else
if (val <= max) {
seq->lcs_width = val;
- CDEBUG(D_INFO, "%s: Sequence size: %llu\n",
- seq->lcs_name, seq->lcs_width);
+ CDEBUG(D_INFO, "%s: Sequence size: %llu\n", seq->lcs_name,
+ seq->lcs_width);
} else {
- GOTO(out_unlock, count = -ERANGE);
+ count = -ERANGE;
}
-out_unlock:
mutex_unlock(&seq->lcs_mutex);
RETURN(count);
}
static int
-lprocfs_client_fid_width_seq_show(struct seq_file *m, void *unused)
+ldebugfs_client_fid_width_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lcs_mutex);
seq_printf(m, "%llu\n", seq->lcs_width);
mutex_unlock(&seq->lcs_mutex);
}
static int
-lprocfs_client_fid_fid_seq_show(struct seq_file *m, void *unused)
+ldebugfs_client_fid_fid_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
- ENTRY;
-
- LASSERT(seq != NULL);
+ ENTRY;
mutex_lock(&seq->lcs_mutex);
seq_printf(m, DFID"\n", PFID(&seq->lcs_fid));
mutex_unlock(&seq->lcs_mutex);
}
static int
-lprocfs_client_fid_server_seq_show(struct seq_file *m, void *unused)
+ldebugfs_client_fid_server_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
struct client_obd *cli;
ENTRY;
- LASSERT(seq != NULL);
-
- if (seq->lcs_exp != NULL) {
+ if (seq->lcs_exp) {
cli = &seq->lcs_exp->exp_obd->u.cli;
seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
+#ifdef HAVE_SERVER_SUPPORT
} else {
seq_printf(m, "%s\n", seq->lcs_srv->lss_name);
+#endif /* HAVE_SERVER_SUPPORT */
}
+
RETURN(0);
}
-LPROC_SEQ_FOPS(lprocfs_client_fid_space);
-LPROC_SEQ_FOPS(lprocfs_client_fid_width);
-LPROC_SEQ_FOPS_RO(lprocfs_client_fid_server);
-LPROC_SEQ_FOPS_RO(lprocfs_client_fid_fid);
+LPROC_SEQ_FOPS(ldebugfs_client_fid_space);
+LPROC_SEQ_FOPS(ldebugfs_client_fid_width);
+LPROC_SEQ_FOPS_RO(ldebugfs_client_fid_server);
+LPROC_SEQ_FOPS_RO(ldebugfs_client_fid_fid);
-struct lprocfs_vars seq_client_proc_list[] = {
+struct lprocfs_vars seq_client_debugfs_list[] = {
{ .name = "space",
- .fops = &lprocfs_client_fid_space_fops },
+ .fops = &ldebugfs_client_fid_space_fops },
{ .name = "width",
- .fops = &lprocfs_client_fid_width_fops },
+ .fops = &ldebugfs_client_fid_width_fops },
{ .name = "server",
- .fops = &lprocfs_client_fid_server_fops },
+ .fops = &ldebugfs_client_fid_server_fops},
{ .name = "fid",
- .fops = &lprocfs_client_fid_fid_fops },
+ .fops = &ldebugfs_client_fid_fid_fops },
{ NULL }
};
-
-#endif /* CONFIG_PROC_FS */