X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Ffld%2Flproc_fld.c;h=3378956ba2e7ab844b60f3ae1f24e26d7a193b2a;hb=refs%2Fchanges%2F99%2F13299%2F3;hp=7b784eb0f6f179f49753a6ae61a3d68c425aa052;hpb=cd291db3a1d26b6fdd7fd163cb86ae2939ce9414;p=fs%2Flustre-release.git

diff --git a/lustre/fld/lproc_fld.c b/lustre/fld/lproc_fld.c
index 7b784eb..3378956 100644
--- a/lustre/fld/lproc_fld.c
+++ b/lustre/fld/lproc_fld.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2012, Whamcloud, Inc.
+ * Copyright (c) 2012, 2014, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -43,74 +43,51 @@
 
 #define DEBUG_SUBSYSTEM S_FLD
 
-#ifdef __KERNEL__
-# include <libcfs/libcfs.h>
-# include <linux/module.h>
-#else /* __KERNEL__ */
-# include <liblustre.h>
-#endif
-
-#include <obd.h>
-#include <obd_class.h>
+#include <libcfs/libcfs.h>
+#include <linux/module.h>
 #include <dt_object.h>
-#include <md_object.h>
 #include <obd_support.h>
-#include <lustre_req_layout.h>
 #include <lustre_fld.h>
 #include <lustre_fid.h>
 #include "fld_internal.h"
 
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
 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);
+	LASSERT(fld != NULL);
 
-        cfs_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;
-        }
-        cfs_spin_unlock(&fld->lcf_lock);
-	RETURN(total);
+	spin_lock(&fld->lcf_lock);
+	list_for_each_entry(target, &fld->lcf_targets, ft_chain)
+	seq_printf(m, "%s\n", fld_target_name(target));
+	spin_unlock(&fld->lcf_lock);
+	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);
+	LASSERT(fld != NULL);
 
-        cfs_spin_lock(&fld->lcf_lock);
-        rc = snprintf(page, count, "%s\n",
-                      fld->lcf_hash->fh_name);
-        cfs_spin_unlock(&fld->lcf_lock);
+	spin_lock(&fld->lcf_lock);
+	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 __user *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;
@@ -127,23 +104,23 @@ fld_proc_write_hash(struct file *file, const char *buffer,
                 }
         }
 
-        if (hash != NULL) {
-                cfs_spin_lock(&fld->lcf_lock);
-                fld->lcf_hash = hash;
-                cfs_spin_unlock(&fld->lcf_lock);
+	if (hash != NULL) {
+		spin_lock(&fld->lcf_lock);
+		fld->lcf_hash = hash;
+		spin_unlock(&fld->lcf_lock);
 
-                CDEBUG(D_INFO, "%s: Changed hash to \"%s\"\n",
-                       fld->lcf_name, hash->fh_name);
-        }
+		CDEBUG(D_INFO, "%s: Changed hash to \"%s\"\n",
+		       fld->lcf_name, hash->fh_name);
+	}
 
-        RETURN(count);
+	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 __user *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);
@@ -155,107 +132,118 @@ 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;
+	struct lu_env		fsp_env;
+	struct dt_it		*fsp_it;
+	struct lu_server_fld	*fsp_fld;
+	unsigned int		fsp_stop:1;
 };
 
 static void *fldb_seq_start(struct seq_file *p, loff_t *pos)
 {
-	struct lu_server_fld	*fld = p->private;
-	struct dt_object	*obj;
-	const struct dt_it_ops	*iops;
-	struct fld_seq_param	*param;
-	struct fld_thread_info	*info;
+	struct fld_seq_param    *param = p->private;
+	struct lu_server_fld    *fld;
+	struct dt_object        *obj;
+	const struct dt_it_ops  *iops;
+	struct dt_key		*key;
+	int			rc;
 
-	if (fld->lsf_obj == NULL)
+	if (param == NULL || param->fsp_stop)
 		return NULL;
 
+	fld = param->fsp_fld;
 	obj = fld->lsf_obj;
+	LASSERT(obj != NULL);
 	iops = &obj->do_index_ops->dio_it;
 
-	OBD_ALLOC_PTR(param);
-	if (param == NULL)
-		return ERR_PTR(-ENOMEM);
+	rc = iops->load(&param->fsp_env, param->fsp_it, *pos);
+	if (rc <= 0)
+		return NULL;
 
-	lu_env_init(&param->fsp_env, LCT_MD_THREAD);
-	param->fsp_it = iops->init(&param->fsp_env, obj, 0, NULL);
-	info = lu_context_key_get(&param->fsp_env.le_ctx,
-				  &fld_thread_key);
+	key = iops->key(&param->fsp_env, param->fsp_it);
+	if (IS_ERR(key))
+		return NULL;
 
-	iops->load(&param->fsp_env, param->fsp_it, *pos);
+	*pos = be64_to_cpu(*(__u64 *)key);
 
 	return param;
 }
 
 static void fldb_seq_stop(struct seq_file *p, void *v)
 {
-	struct lu_server_fld	*fld = p->private;
-	struct dt_object	*obj;
+	struct fld_seq_param    *param = p->private;
 	const struct dt_it_ops	*iops;
-	struct fld_seq_param	*param = (struct fld_seq_param *)v;
+	struct lu_server_fld	*fld;
+	struct dt_object	*obj;
 
-	if (fld->lsf_obj == NULL)
+	if (param == NULL)
 		return;
 
+	fld = param->fsp_fld;
 	obj = fld->lsf_obj;
+	LASSERT(obj != NULL);
 	iops = &obj->do_index_ops->dio_it;
-	if (IS_ERR(param) || param == NULL)
-		return;
 
 	iops->put(&param->fsp_env, param->fsp_it);
-	iops->fini(&param->fsp_env, param->fsp_it);
-	lu_env_fini(&param->fsp_env);
-	OBD_FREE_PTR(param);
-
-	return;
 }
 
 static void *fldb_seq_next(struct seq_file *p, void *v, loff_t *pos)
 {
-	struct lu_server_fld	*fld = p->private;
+	struct fld_seq_param    *param = p->private;
+	struct lu_server_fld	*fld;
 	struct dt_object	*obj;
 	const struct dt_it_ops	*iops;
-	struct fld_seq_param	*param = (struct fld_seq_param *)v;
 	int			rc;
 
-	if (fld->lsf_obj == NULL)
+	if (param == NULL || param->fsp_stop)
 		return NULL;
 
+	fld = param->fsp_fld;
 	obj = fld->lsf_obj;
+	LASSERT(obj != NULL);
 	iops = &obj->do_index_ops->dio_it;
 
-	iops->get(&param->fsp_env, param->fsp_it,
-		  (const struct dt_key *)pos);
-
 	rc = iops->next(&param->fsp_env, param->fsp_it);
 	if (rc > 0) {
-		iops->put(&param->fsp_env, param->fsp_it);
-		iops->fini(&param->fsp_env, param->fsp_it);
-		lu_env_fini(&param->fsp_env);
-		OBD_FREE_PTR(param);
+		param->fsp_stop = 1;
 		return NULL;
 	}
 
-	*pos = *(loff_t *)iops->key(&param->fsp_env, param->fsp_it);
-
+	*pos = be64_to_cpu(*(__u64 *)iops->key(&param->fsp_env, param->fsp_it));
 	return param;
 }
 
 static int fldb_seq_show(struct seq_file *p, void *v)
 {
-	struct lu_server_fld	*fld = p->private;
-	struct dt_object	*obj = fld->lsf_obj;
-	struct fld_seq_param	*param = (struct fld_seq_param *)v;
+	struct fld_seq_param    *param = p->private;
+	struct lu_server_fld	*fld;
+	struct dt_object	*obj;
 	const struct dt_it_ops	*iops;
 	struct fld_thread_info	*info;
 	struct lu_seq_range	*fld_rec;
 	int			rc;
 
-	if (fld->lsf_obj == NULL)
+	if (param == NULL || param->fsp_stop)
 		return 0;
 
+	fld = param->fsp_fld;
 	obj = fld->lsf_obj;
+	LASSERT(obj != NULL);
 	iops = &obj->do_index_ops->dio_it;
 
 	info = lu_context_key_get(&param->fsp_env.le_ctx,
@@ -271,8 +259,6 @@ static int fldb_seq_show(struct seq_file *p, void *v)
 		rc = seq_printf(p, DRANGE"\n", PRANGE(fld_rec));
 	}
 
-	iops->put(&param->fsp_env, param->fsp_it);
-
 	return rc;
 }
 
@@ -285,37 +271,98 @@ 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;
-	int rc;
+	struct seq_file		*seq;
+	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_AND_CHECK(dp);
-	rc = seq_open(file, &fldb_sops);
-	if (rc) {
-		LPROCFS_EXIT();
+	rc = LPROCFS_ENTRY_CHECK(inode);
+	if (rc < 0)
 		return rc;
+
+	rc = seq_open(file, &fldb_sops);
+	if (rc)
+		GOTO(out, rc);
+
+	obj = fld->lsf_obj;
+	if (obj == NULL) {
+		seq = file->private_data;
+		seq->private = NULL;
+		return 0;
 	}
 
+	OBD_ALLOC_PTR(param);
+	if (param == NULL)
+		GOTO(out, rc = -ENOMEM);
+
+	rc = lu_env_init(&param->fsp_env, LCT_MD_THREAD);
+	if (rc != 0)
+		GOTO(out, rc);
+
+	env_init = 1;
+	iops = &obj->do_index_ops->dio_it;
+	param->fsp_it = iops->init(&param->fsp_env, obj, 0, NULL);
+	if (IS_ERR(param->fsp_it))
+		GOTO(out, rc = PTR_ERR(param->fsp_it));
+
+	param->fsp_fld = fld;
+	param->fsp_stop = 0;
+
 	seq = file->private_data;
-	seq->private = dp->data;
-	return 0;
+	seq->private = param;
+out:
+	if (rc != 0) {
+		if (env_init == 1)
+			lu_env_fini(&param->fsp_env);
+		if (param != NULL)
+			OBD_FREE_PTR(param);
+	}
+	return rc;
 }
 
-struct lprocfs_vars fld_server_proc_list[] = {
-	{ NULL }};
+static int fldb_seq_release(struct inode *inode, struct file *file)
+{
+	struct seq_file		*seq = file->private_data;
+	struct fld_seq_param	*param;
+	struct lu_server_fld	*fld;
+	struct dt_object	*obj;
+	const struct dt_it_ops	*iops;
+
+	param = seq->private;
+	if (param == NULL) {
+		lprocfs_seq_release(inode, file);
+		return 0;
+	}
 
-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 }};
+	fld = param->fsp_fld;
+	obj = fld->lsf_obj;
+	LASSERT(obj != NULL);
+	iops = &obj->do_index_ops->dio_it;
 
-struct file_operations fld_proc_seq_fops = {
+	LASSERT(iops != NULL);
+	LASSERT(param->fsp_it != NULL);
+	iops->fini(&param->fsp_env, param->fsp_it);
+	lu_env_fini(&param->fsp_env);
+	OBD_FREE_PTR(param);
+	lprocfs_seq_release(inode, file);
+
+	return 0;
+}
+
+const struct file_operations fld_proc_seq_fops = {
 	.owner   = THIS_MODULE,
 	.open    = fldb_seq_open,
 	.read    = seq_read,
-	.llseek  = seq_lseek,
-	.release = lprocfs_seq_release,
+	.release = fldb_seq_release,
+};
+
+struct lprocfs_seq_vars fld_server_proc_list[] = {
+	{ NULL }
 };
 
-#endif
+# endif /* HAVE_SERVER_SUPPORT */
+
+#endif /* CONFIG_PROC_FS */