From 4b4d8596dbc60400bead631b52b118e4a401e900 Mon Sep 17 00:00:00 2001 From: James Simmons Date: Sun, 21 Jan 2018 11:55:10 -0500 Subject: [PATCH] LU-8066 fid: move all files from procfs to debugfs Linux-commit: f3aa79fbef7942971825fb2084a88e9527c6b04c Besides the client port form upstream also port the server side proc entires to debugfs. Change-Id: I934fc5a39c8c407799abd0d6154240d3a579c93e Signed-off-by: Dmitry Eremin Signed-off-by: Greg Kroah-Hartman Signed-off-by: James Simmons Reviewed-on: https://review.whamcloud.com/28366 Tested-by: Jenkins Tested-by: Maloo Reviewed-by: Dmitry Eremin Reviewed-by: Fan Yong Reviewed-by: Oleg Drokin --- lustre/fid/fid_handler.c | 62 +++++++-------- lustre/fid/fid_internal.h | 10 +-- lustre/fid/fid_request.c | 111 ++++++++++++--------------- lustre/fid/lproc_fid.c | 183 +++++++++++++++++++------------------------- lustre/include/lustre_fid.h | 12 +-- 5 files changed, 164 insertions(+), 214 deletions(-) diff --git a/lustre/fid/fid_handler.c b/lustre/fid/fid_handler.c index a681117..8676ec2 100644 --- a/lustre/fid/fid_handler.c +++ b/lustre/fid/fid_handler.c @@ -48,8 +48,6 @@ #include #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) @@ -458,35 +456,43 @@ LU_KEY_INIT_FINI(seq, struct seq_thread_info); /* 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); } } @@ -494,24 +500,8 @@ static int seq_server_proc_init(struct lu_server_seq *seq) 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, @@ -592,7 +582,7 @@ 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); @@ -609,7 +599,7 @@ void seq_server_fini(struct lu_server_seq *seq, { ENTRY; - seq_server_proc_fini(seq); + seq_server_debugfs_fini(seq); seq_store_fini(seq, env); EXIT; diff --git a/lustre/fid/fid_internal.h b/lustre/fid/fid_internal.h index f006d81..2783dd0 100644 --- a/lustre/fid/fid_internal.h +++ b/lustre/fid/fid_internal.h @@ -55,9 +55,7 @@ enum { extern struct lu_context_key seq_thread_key; -# ifdef CONFIG_PROC_FS -extern struct lprocfs_vars seq_server_proc_list[]; -# endif +extern struct lprocfs_vars seq_server_debugfs_list[]; /* Store API functions. */ struct dt_device; @@ -89,10 +87,8 @@ void fid_server_mod_exit(void); int seq_client_alloc_super(struct lu_client_seq *seq, const struct lu_env *env); -# ifdef CONFIG_PROC_FS -extern struct lprocfs_vars seq_client_proc_list[]; -# endif +extern struct dentry *seq_debugfs_dir; -extern struct proc_dir_entry *seq_type_proc_dir; +extern struct lprocfs_vars seq_client_debugfs_list[]; #endif /* __FID_INTERNAL_H */ diff --git a/lustre/fid/fid_request.c b/lustre/fid/fid_request.c index 30709a8..93f6402 100644 --- a/lustre/fid/fid_request.c +++ b/lustre/fid/fid_request.c @@ -38,6 +38,7 @@ #define DEBUG_SUBSYSTEM S_FID +#include #include #include #include @@ -47,6 +48,8 @@ #include #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) @@ -437,51 +440,57 @@ void seq_client_flush(struct lu_client_seq *seq) } 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, @@ -514,29 +523,13 @@ int seq_client_init(struct lu_client_seq *seq, 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) { @@ -590,21 +583,18 @@ int client_fid_fini(struct obd_device *obd) } 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) @@ -612,11 +602,8 @@ 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. "); diff --git a/lustre/fid/lproc_fid.c b/lustre/fid/lproc_fid.c index 15a5c74..1df0ac8 100644 --- a/lustre/fid/lproc_fid.c +++ b/lustre/fid/lproc_fid.c @@ -47,8 +47,6 @@ #include #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)) /** @@ -60,16 +58,17 @@ * 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); @@ -81,13 +80,15 @@ lprocfs_fid_write_common(const char __user *buffer, size_t count, 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); @@ -97,23 +98,24 @@ lprocfs_fid_write_common(const char __user *buffer, size_t count, #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); @@ -121,13 +123,11 @@ lprocfs_server_fid_space_seq_write(struct file *file, const char __user *buffer, } 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); @@ -136,14 +136,12 @@ lprocfs_server_fid_space_seq_show(struct seq_file *m, void *unused) } 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; @@ -158,17 +156,15 @@ lprocfs_server_fid_server_seq_show(struct seq_file *m, void *unused) 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); @@ -187,13 +183,11 @@ out_unlock: } 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); @@ -201,17 +195,17 @@ lprocfs_server_fid_width_seq_show(struct seq_file *m, void *unused) 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 } }; @@ -342,7 +336,7 @@ struct seq_operations fldb_sops = { 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; @@ -353,10 +347,6 @@ static int fldb_seq_open(struct inode *inode, struct file *file) 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; @@ -408,7 +398,7 @@ static int fldb_seq_release(struct inode *inode, struct file *file) param = seq->private; if (param == NULL) { - lprocfs_seq_release(inode, file); + seq_release(inode, file); return 0; } @@ -422,7 +412,7 @@ static int fldb_seq_release(struct inode *inode, struct file *file) 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; } @@ -488,7 +478,7 @@ out: 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, @@ -498,21 +488,22 @@ const struct file_operations seq_fld_proc_seq_fops = { #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)); } @@ -521,25 +512,21 @@ lprocfs_client_fid_space_seq_write(struct file *file, const char __user *buffer, 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; @@ -548,15 +535,11 @@ lprocfs_client_fid_width_seq_write(struct file *file, const char __user *buffer, 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 @@ -565,25 +548,22 @@ lprocfs_client_fid_width_seq_write(struct file *file, const char __user *buffer, 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); @@ -592,13 +572,11 @@ lprocfs_client_fid_width_seq_show(struct seq_file *m, void *unused) } 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); @@ -607,38 +585,37 @@ lprocfs_client_fid_fid_seq_show(struct seq_file *m, void *unused) } 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 */ diff --git a/lustre/include/lustre_fid.h b/lustre/include/lustre_fid.h index e798a12..cbf3868 100644 --- a/lustre/include/lustre_fid.h +++ b/lustre/include/lustre_fid.h @@ -417,8 +417,8 @@ struct lu_client_seq { */ struct lu_seq_range lcs_space; - /* Seq related proc */ - struct proc_dir_entry *lcs_proc_dir; + /* Seq related debugfs */ + struct dentry *lcs_debugfs_entry; /* This holds last allocated fid in last obtained seq */ struct lu_fid lcs_fid; @@ -428,7 +428,7 @@ struct lu_client_seq { /* * Service uuid, passed from MDT + seq name to form unique seq name to - * use it with procfs. + * use it with debugfs. */ char lcs_name[80]; @@ -464,8 +464,8 @@ struct lu_server_seq { /* /seq file object device */ struct dt_object *lss_obj; - /* Seq related proc */ - struct proc_dir_entry *lss_proc_dir; + /* Seq related debugfs */ + struct dentry *lss_debugfs_entry; /* LUSTRE_SEQ_SERVER or LUSTRE_SEQ_CONTROLLER */ enum lu_mgr_type lss_type; @@ -478,7 +478,7 @@ struct lu_server_seq { /* * Service uuid, passed from MDT + seq name to form unique seq name to - * use it with procfs. + * use it with debugfs. */ char lss_name[80]; -- 1.8.3.1