LU-3319 procfs: move FLD proc handling over to seq_file

In order to support 3.10+ kernels for clients we adapt
the FLD proc handling to using seq_files.

Signed-off-by: James Simmons <uja.ornl@gmail.com>
Change-Id: I056d4dcc15b82263880949a0928fc04bd6b2f0b7
Reviewed-on: http://review.whamcloud.com/7140
Tested-by: Jenkins
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Bob Glossman <bob.glossman@intel.com>
Reviewed-by: Yang Sheng <yang.sheng@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>

diff --git a/lustre/fld/fld_handler.c b/lustre/fld/fld_handler.c
index a651f02..e40b61a 100644 (file)
--- a/lustre/fld/fld_handler.c
+++ b/lustre/fld/fld_handler.c
@@ -402,13 +402,13 @@ static int fld_server_proc_init(struct lu_server_fld *fld)
         int rc = 0;
         ENTRY;
 
-        fld->lsf_proc_dir = lprocfs_register(fld->lsf_name,
-                                             fld_type_proc_dir,
-                                             fld_server_proc_list, fld);
-        if (IS_ERR(fld->lsf_proc_dir)) {
-                rc = PTR_ERR(fld->lsf_proc_dir);
-                RETURN(rc);
-        }
+       fld->lsf_proc_dir = lprocfs_seq_register(fld->lsf_name,
+                                                fld_type_proc_dir,
+                                                fld_server_proc_list, fld);
+       if (IS_ERR(fld->lsf_proc_dir)) {
+               rc = PTR_ERR(fld->lsf_proc_dir);
+               RETURN(rc);
+       }
 
        rc = lprocfs_seq_create(fld->lsf_proc_dir, "fldb", 0444,
                                &fld_proc_seq_fops, fld);

diff --git a/lustre/fld/fld_internal.h b/lustre/fld/fld_internal.h
index aab457b..554b49f 100644 (file)
--- a/lustre/fld/fld_internal.h
+++ b/lustre/fld/fld_internal.h
@@ -132,10 +132,10 @@ extern struct lu_fld_hash fld_hash[];
 
 #ifdef __KERNEL__
 
-# ifdef LPROCFS
+#ifdef LPROCFS
 extern struct proc_dir_entry *fld_type_proc_dir;
-extern struct lprocfs_vars fld_client_proc_list[];
-# endif
+extern struct lprocfs_seq_vars fld_client_proc_list[];
+#endif
 
 # ifdef HAVE_SERVER_SUPPORT
 struct fld_thread_info {
@@ -170,10 +170,10 @@ void fld_server_mod_exit(void);
 
 int fld_server_read(const struct lu_env *env, struct lu_server_fld *fld,
                    struct lu_seq_range *range, void *data, int data_len);
-# ifdef LPROCFS
+#ifdef LPROCFS
 extern const struct file_operations fld_proc_seq_fops;
-extern struct lprocfs_vars fld_server_proc_list[];
-# endif
+extern struct lprocfs_seq_vars fld_server_proc_list[];
+#endif
 
 # endif /* HAVE_SERVER_SUPPORT */
 

diff --git a/lustre/fld/fld_request.c b/lustre/fld/fld_request.c
index 6a656be..8d7539d 100644 (file)
--- a/lustre/fld/fld_request.c
+++ b/lustre/fld/fld_request.c
@@ -282,33 +282,32 @@ EXPORT_SYMBOL(fld_client_del_target);
 #ifdef LPROCFS
 static int fld_client_proc_init(struct lu_client_fld *fld)
 {
-        int rc;
-        ENTRY;
-
-        fld->lcf_proc_dir = lprocfs_register(fld->lcf_name,
-                                             fld_type_proc_dir,
-                                             NULL, NULL);
+       int rc;
+       ENTRY;
 
-        if (IS_ERR(fld->lcf_proc_dir)) {
-                CERROR("%s: LProcFS failed in fld-init\n",
-                       fld->lcf_name);
-                rc = PTR_ERR(fld->lcf_proc_dir);
-                RETURN(rc);
-        }
+       fld->lcf_proc_dir = lprocfs_seq_register(fld->lcf_name,
+                                                fld_type_proc_dir,
+                                                NULL, NULL);
+       if (IS_ERR(fld->lcf_proc_dir)) {
+               CERROR("%s: LProcFS failed in fld-init\n",
+                      fld->lcf_name);
+               rc = PTR_ERR(fld->lcf_proc_dir);
+               RETURN(rc);
+       }
 
-        rc = lprocfs_add_vars(fld->lcf_proc_dir,
-                              fld_client_proc_list, fld);
-        if (rc) {
-                CERROR("%s: Can't init FLD proc, rc %d\n",
-                       fld->lcf_name, rc);
-                GOTO(out_cleanup, rc);
-        }
+       rc = lprocfs_seq_add_vars(fld->lcf_proc_dir,
+                                 fld_client_proc_list, fld);
+       if (rc) {
+               CERROR("%s: Can't init FLD proc, rc %d\n",
+                      fld->lcf_name, rc);
+               GOTO(out_cleanup, rc);
+       }
 
-        RETURN(0);
+       RETURN(0);
 
 out_cleanup:
-        fld_client_proc_fini(fld);
-        return rc;
+       fld_client_proc_fini(fld);
+       return rc;
 }
 
 void fld_client_proc_fini(struct lu_client_fld *fld)
@@ -556,9 +555,9 @@ struct proc_dir_entry *fld_type_proc_dir;
 
 static int __init fld_mod_init(void)
 {
-       fld_type_proc_dir = lprocfs_register(LUSTRE_FLD_NAME,
-                                            proc_lustre_root,
-                                            NULL, NULL);
+       fld_type_proc_dir = lprocfs_seq_register(LUSTRE_FLD_NAME,
+                                                proc_lustre_root,
+                                                NULL, NULL);
        if (IS_ERR(fld_type_proc_dir))
                return PTR_ERR(fld_type_proc_dir);
 

diff --git a/lustre/fld/lproc_fld.c b/lustre/fld/lproc_fld.c
index 80710f6..ccfb258 100644 (file)
--- a/lustre/fld/lproc_fld.c
+++ b/lustre/fld/lproc_fld.c
@@ -59,12 +59,10 @@
 
 #ifdef LPROCFS
 static int
-fld_proc_read_targets(char *page, char **start, off_t off,
-                      int count, int *eof, void *data)
+fld_proc_targets_seq_show(struct seq_file *m, void *unused)
 {
-        struct lu_client_fld *fld = (struct lu_client_fld *)data;
+       struct lu_client_fld *fld = (struct lu_client_fld *)m->private;
         struct lu_fld_target *target;
-       int total = 0, rc;
        ENTRY;
 
        LASSERT(fld != NULL);
@@ -72,41 +70,31 @@ fld_proc_read_targets(char *page, char **start, off_t off,
        spin_lock(&fld->lcf_lock);
         cfs_list_for_each_entry(target,
                                 &fld->lcf_targets, ft_chain)
-        {
-                rc = snprintf(page, count, "%s\n",
-                              fld_target_name(target));
-                page += rc;
-                count -= rc;
-                total += rc;
-                if (count == 0)
-                        break;
-        }
+               seq_printf(m, "%s\n", fld_target_name(target));
        spin_unlock(&fld->lcf_lock);
-       RETURN(total);
+       RETURN(0);
 }
 
 static int
-fld_proc_read_hash(char *page, char **start, off_t off,
-                   int count, int *eof, void *data)
+fld_proc_hash_seq_show(struct seq_file *m, void *unused)
 {
-        struct lu_client_fld *fld = (struct lu_client_fld *)data;
-       int rc;
+       struct lu_client_fld *fld = (struct lu_client_fld *)m->private;
        ENTRY;
 
        LASSERT(fld != NULL);
 
        spin_lock(&fld->lcf_lock);
-       rc = snprintf(page, count, "%s\n", fld->lcf_hash->fh_name);
+       seq_printf(m, "%s\n", fld->lcf_hash->fh_name);
        spin_unlock(&fld->lcf_lock);
 
-       RETURN(rc);
+       RETURN(0);
 }
 
-static int
-fld_proc_write_hash(struct file *file, const char *buffer,
-                    unsigned long count, void *data)
+static ssize_t
+fld_proc_hash_seq_write(struct file *file, const char *buffer,
+                       size_t count, loff_t *off)
 {
-        struct lu_client_fld *fld = (struct lu_client_fld *)data;
+       struct lu_client_fld *fld = ((struct seq_file *)file->private_data)->private;
         struct lu_fld_hash *hash = NULL;
         int i;
        ENTRY;
@@ -135,11 +123,11 @@ fld_proc_write_hash(struct file *file, const char *buffer,
        RETURN(count);
 }
 
-static int
-fld_proc_write_cache_flush(struct file *file, const char *buffer,
-                           unsigned long count, void *data)
+static ssize_t
+lprocfs_cache_flush_seq_write(struct file *file, const char *buffer,
+                              size_t count, loff_t *pos)
 {
-        struct lu_client_fld *fld = (struct lu_client_fld *)data;
+       struct lu_client_fld *fld = ((struct seq_file *)file->private_data)->private;
        ENTRY;
 
         LASSERT(fld != NULL);
@@ -151,6 +139,21 @@ fld_proc_write_cache_flush(struct file *file, const char *buffer,
         RETURN(count);
 }
 
+LPROC_SEQ_FOPS_RO(fld_proc_targets);
+LPROC_SEQ_FOPS(fld_proc_hash);
+LPROC_SEQ_FOPS_WO_TYPE(fld, cache_flush);
+
+struct lprocfs_seq_vars fld_client_proc_list[] = {
+       { .name =       "targets",
+         .fops =       &fld_proc_targets_fops  },
+       { .name =       "hash",
+         .fops =       &fld_proc_hash_fops     },
+       { .name =       "cache_flush",
+         .fops =       &fld_cache_flush_fops   },
+       { NULL }
+};
+
+#ifdef HAVE_SERVER_SUPPORT
 struct fld_seq_param {
        struct lu_env           fsp_env;
        struct dt_it            *fsp_it;
@@ -158,14 +161,6 @@ struct fld_seq_param {
        unsigned int            fsp_stop:1;
 };
 
-struct lprocfs_vars fld_client_proc_list[] = {
-       { "targets", fld_proc_read_targets, NULL, NULL },
-       { "hash", fld_proc_read_hash, fld_proc_write_hash, NULL },
-       { "cache_flush", NULL, fld_proc_write_cache_flush, NULL },
-       { NULL }
-};
-
-# ifdef HAVE_SERVER_SUPPORT
 static void *fldb_seq_start(struct seq_file *p, loff_t *pos)
 {
        struct fld_seq_param    *param = p->private;
@@ -274,16 +269,15 @@ struct seq_operations fldb_sops = {
 
 static int fldb_seq_open(struct inode *inode, struct file *file)
 {
-       struct proc_dir_entry   *dp = PDE(inode);
        struct seq_file         *seq;
-       struct lu_server_fld    *fld = (struct lu_server_fld *)dp->data;
+       struct lu_server_fld    *fld = (struct lu_server_fld *)PDE_DATA(inode);
        struct dt_object        *obj;
        const struct dt_it_ops  *iops;
        struct fld_seq_param    *param = NULL;
        int                     env_init = 0;
        int                     rc;
 
-       LPROCFS_ENTRY_CHECK(dp);
+       LPROCFS_ENTRY_CHECK(PDE(inode));
        rc = seq_open(file, &fldb_sops);
        if (rc)
                GOTO(out, rc);
@@ -360,7 +354,7 @@ const struct file_operations fld_proc_seq_fops = {
        .release = fldb_seq_release,
 };
 
-struct lprocfs_vars fld_server_proc_list[] = {
+struct lprocfs_seq_vars fld_server_proc_list[] = {
        { NULL }
 };