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 <dmiter4ever@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: https://review.whamcloud.com/28366
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Dmitry Eremin <dmitry.eremin@intel.com>
Reviewed-by: Fan Yong <fan.yong@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>

diff --git a/lustre/fid/fid_handler.c b/lustre/fid/fid_handler.c
index a681117..8676ec2 100644 (file)
--- a/lustre/fid/fid_handler.c
+++ b/lustre/fid/fid_handler.c
@@ -48,8 +48,6 @@
 #include <lustre_fid.h>
 #include "fid_internal.h"
 
 #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)
 /* 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);
 
 /* 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;
 
        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);
        }
 
                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) {
        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) {
                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) {
                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);
                }
        }
                        GOTO(out_cleanup, rc);
                }
        }


@@ -494,24 +500,8 @@ static int seq_server_proc_init(struct lu_server_seq *seq)
        RETURN(0);
 
 out_cleanup:
        RETURN(0);
 
 out_cleanup:

-       seq_server_proc_fini(seq);
+       seq_server_debugfs_fini(seq);

        return rc;
        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,
 }
 
 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));
        }
 
                        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);
 
         if (rc)
                 GOTO(out, rc);
 


@@ -609,7 +599,7 @@ void seq_server_fini(struct lu_server_seq *seq,
 {
         ENTRY;
 
 {
         ENTRY;
 

-        seq_server_proc_fini(seq);
+       seq_server_debugfs_fini(seq);

         seq_store_fini(seq, env);
 
         EXIT;
         seq_store_fini(seq, env);
 
         EXIT;

diff --git a/lustre/fid/fid_internal.h b/lustre/fid/fid_internal.h
index f006d81..2783dd0 100644 (file)
--- 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;
 
 
 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;
 
 /* 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);
 
 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 */
 
 #endif /* __FID_INTERNAL_H */

diff --git a/lustre/fid/fid_request.c b/lustre/fid/fid_request.c
index 30709a8..93f6402 100644 (file)
--- a/lustre/fid/fid_request.c
+++ b/lustre/fid/fid_request.c
@@ -38,6 +38,7 @@
 
 #define DEBUG_SUBSYSTEM S_FID
 
 
 #define DEBUG_SUBSYSTEM S_FID
 

+#include <linux/err.h>

 #include <linux/module.h>
 #include <obd.h>
 #include <obd_class.h>
 #include <linux/module.h>
 #include <obd.h>
 #include <obd_class.h>


@@ -47,6 +48,8 @@
 #include <lustre_mdc.h>
 #include "fid_internal.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)
 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);
 
 }
 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;
         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:
                 GOTO(out_cleanup, rc);
         }
 
         RETURN(0);
 
 out_cleanup:

-        seq_client_proc_fini(seq);
+       seq_client_debugfs_fini(seq);

         return rc;
         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,
 
 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);
 
        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);
 
        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)
 {
 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);
 
 }
 EXPORT_SYMBOL(client_fid_fini);
 

-struct proc_dir_entry *seq_type_proc_dir;
-

 static int __init fid_init(void)
 {
 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)
 }
 
 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
 # 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/>");
 }
 
 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");

diff --git a/lustre/fid/lproc_fid.c b/lustre/fid/lproc_fid.c
index 15a5c74..1df0ac8 100644 (file)
--- a/lustre/fid/lproc_fid.c
+++ b/lustre/fid/lproc_fid.c
@@ -47,8 +47,6 @@
 #include <lprocfs_status.h>
 #include "fid_internal.h"
 
 #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))
 /**
 /* 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
  * 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,
        };
        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 >= 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));
 
        if (count == 5 && strcmp(kernbuf, "clear") == 0) {
                memset(range, 0, sizeof(*range));

-               RETURN(0);
+               RETURN(count);

        }
 
        /* of the form "[0x0000000240000400 - 0x000000028000400]" */
        }
 
        /* 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);
        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
 /*
 
 #ifdef HAVE_SERVER_SUPPORT
 /*

- * Server side procfs stuff.
+ * Server side debugfs stuff.

  */
 static ssize_t
  */
 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;
        int rc;

-       ENTRY;

 
 

-       LASSERT(seq != NULL);
+       ENTRY;
+       seq = ((struct seq_file *)file->private_data)->private;

 
        mutex_lock(&seq->lss_mutex);
 
        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) {
        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);
 
        }
        mutex_unlock(&seq->lss_mutex);
 


@@ -121,13 +123,11 @@ lprocfs_server_fid_space_seq_write(struct file *file, const char __user *buffer,
 }
 
 static int
 }
 
 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;
 
 {
        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);
        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
 }
 
 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;
 
 {
        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;
        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);
 }
 
        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;
 {
        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);
        mutex_lock(&seq->lss_mutex);
 
        rc = kstrtoull_from_user(buffer, count, 0, &seq->lss_width);


@@ -187,13 +183,11 @@ out_unlock:
 }
 
 static int
 }
 
 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;
 {
        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);
        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);
 }
 
        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",
        { .name =       "space",

-         .fops =       &lprocfs_server_fid_space_fops  },
+         .fops =       &ldebugfs_server_fid_space_fops },

        { .name =       "width",
        { .name =       "width",

-         .fops =       &lprocfs_server_fid_width_fops  },
+         .fops =       &ldebugfs_server_fid_width_fops },

        { .name =       "server",
        { .name =       "server",

-         .fops =       &lprocfs_server_fid_server_fops },
+         .fops =       &ldebugfs_server_fid_server_fops},

        { NULL }
 };
 
        { 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;
 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;
        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);
 
        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;
        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) {
 
        param = seq->private;
        if (param == NULL) {

-               lprocfs_seq_release(inode, file);
+               seq_release(inode, file);

                return 0;
        }
 
                return 0;
        }
 


@@ -422,7 +412,7 @@ static int fldb_seq_release(struct inode *inode, struct file *file)
        iops->fini(&param->fsp_env, param->fsp_it);
        lu_env_fini(&param->fsp_env);
        OBD_FREE_PTR(param);
        iops->fini(&param->fsp_env, param->fsp_it);
        lu_env_fini(&param->fsp_env);
        OBD_FREE_PTR(param);

-       lprocfs_seq_release(inode, file);
+       seq_release(inode, file);

 
        return 0;
 }
 
        return 0;
 }


@@ -488,7 +478,7 @@ out:
        RETURN(rc < 0 ? rc : len);
 }
 
        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,
        .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 */
 
 
 #endif /* HAVE_SERVER_SUPPORT */
 

-/* Client side procfs stuff */
+/* Client side debugfs stuff */

 static ssize_t
 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;
        int rc;

-       ENTRY;

 
 

-       LASSERT(seq != NULL);
+       ENTRY;
+       seq = ((struct seq_file *)file->private_data)->private;

 
        mutex_lock(&seq->lcs_mutex);
 
        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) {
        if (rc == 0) {

-               CDEBUG(D_INFO, "%s: Space: "DRANGE"\n",
+               CDEBUG(D_INFO, "%s: Space: " DRANGE "\n",

                        seq->lcs_name, PRANGE(&seq->lcs_space));
        }
 
                        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);
 }
 
        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;
 {
        struct lu_client_seq *seq = (struct lu_client_seq *)m->private;

-       ENTRY;
-
-       LASSERT(seq != NULL);

 
 

+       ENTRY;

        mutex_lock(&seq->lcs_mutex);
        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);
 }
 
        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;
 {
        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;
        int rc;
 
        ENTRY;

-       LASSERT(seq != NULL);
-
-       mutex_lock(&seq->lcs_mutex);
-

        rc = kstrtoull_from_user(buffer, count, 0, &val);
        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 (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;
 
        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 {
        } else {

-               GOTO(out_unlock, count = -ERANGE);
+               count = -ERANGE;

        }
 
        }
 

-out_unlock:

        mutex_unlock(&seq->lcs_mutex);
        RETURN(count);
 }
 
 static int
        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;
 {
        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);
        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
 }
 
 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;
 {
        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);
        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
 }
 
 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;
 
 {
        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);
                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);
        } else {
                seq_printf(m, "%s\n", seq->lcs_srv->lss_name);

+#endif /* HAVE_SERVER_SUPPORT */

        }
        }

+

        RETURN(0);
 }
 
        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",
        { .name =       "space",

-         .fops =       &lprocfs_client_fid_space_fops  },
+         .fops =       &ldebugfs_client_fid_space_fops },

        { .name =       "width",
        { .name =       "width",

-         .fops =       &lprocfs_client_fid_width_fops  },
+         .fops =       &ldebugfs_client_fid_width_fops },

        { .name =       "server",
        { .name =       "server",

-         .fops =       &lprocfs_client_fid_server_fops },
+         .fops =       &ldebugfs_client_fid_server_fops},

        { .name =       "fid",
        { .name =       "fid",

-         .fops =       &lprocfs_client_fid_fid_fops    },
+         .fops =       &ldebugfs_client_fid_fid_fops   },

        { NULL }
 };
        { NULL }
 };

-
-#endif /* CONFIG_PROC_FS */

diff --git a/lustre/include/lustre_fid.h b/lustre/include/lustre_fid.h
index e798a12..cbf3868 100644 (file)
--- 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;
 
          */
         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;
 
         /* 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
 
         /*
          * 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];
 
          */
         char                    lcs_name[80];
 


@@ -464,8 +464,8 @@ struct lu_server_seq {
         /* /seq file object device */
         struct dt_object       *lss_obj;
 
         /* /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;
 
         /* 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
 
         /*
          * 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];
 
          */
         char                    lss_name[80];