X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Ffid%2Flproc_fid.c;h=688082e09bd4ca7cccb5a20f9af3bd8d14a55d84;hp=5adbf62918986c2aaa6df2abd672b262e0017770;hb=f07508d17b49574c7ea47a855c6e8af2b23c3add;hpb=245c6d39387bf85b18ea8c4db161f693739fca26

diff --git a/lustre/fid/lproc_fid.c b/lustre/fid/lproc_fid.c
index 5adbf62..688082e 100644
--- a/lustre/fid/lproc_fid.c
+++ b/lustre/fid/lproc_fid.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -27,7 +23,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -51,8 +47,6 @@
 #include <lprocfs_status.h>
 #include "fid_internal.h"
 
-#ifdef LPROCFS
-
 /* Format: [0x64BIT_INT - 0x64BIT_INT] + 32 bytes just in case */
 #define MAX_FID_RANGE_STRLEN (32 + 2 * 2 * sizeof(__u64))
 /**
@@ -64,15 +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)
 {
-	struct lu_seq_range tmp = { 0, };
-	int rc;
 	char kernbuf[MAX_FID_RANGE_STRLEN];
-	ENTRY;
+	struct lu_seq_range tmp = {
+		.lsr_start = 0,
+	};
+	int rc;
 
-	LASSERT(range != NULL);
+	ENTRY;
+	LASSERT(range);
 
 	if (count >= sizeof(kernbuf))
 		RETURN(-EINVAL);
@@ -84,14 +80,16 @@ 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]" */
 	rc = sscanf(kernbuf, "[%llx - %llx]\n",
-		    (long long unsigned *)&tmp.lsr_start,
-		    (long long unsigned *)&tmp.lsr_end);
-	if (!range_is_sane(&tmp) || range_is_zero(&tmp) ||
+		    (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);
 	*range = tmp;
@@ -100,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 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 = 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);
 
@@ -124,68 +123,58 @@ 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;
-	int rc;
 	ENTRY;
 
-	LASSERT(seq != NULL);
-
 	mutex_lock(&seq->lss_mutex);
-	rc = seq_printf(m, "["LPX64" - "LPX64"]:%x:%s\n",
-			PRANGE(&seq->lss_space));
+	seq_printf(m, "[%#llx - %#llx]:%x:%s\n", PRANGE(&seq->lss_space));
 	mutex_unlock(&seq->lss_mutex);
 
-	RETURN(rc);
+	RETURN(0);
 }
 
 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;
-	int rc;
 	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;
-			rc = seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
+			seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
 		} else {
-			rc = seq_printf(m, "%s\n",
-					seq->lss_cli->lcs_srv->lss_name);
+			seq_printf(m, "%s\n", seq->lss_cli->lcs_srv->lss_name);
                 }
 	} else {
-		rc = seq_printf(m, "<none>\n");
+		seq_puts(m, "<none>\n");
 	}
 
-	RETURN(rc);
+	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 lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
-	int rc, val;
-	ENTRY;
-
-	LASSERT(seq != NULL);
+	struct seq_file *m = file->private_data;
+	struct lu_server_seq *seq = m->private;
+	int rc;
 
+	ENTRY;
 	mutex_lock(&seq->lss_mutex);
 
-	rc = lprocfs_write_helper(buffer, count, &val);
-	if (rc != 0) {
-		CERROR("%s: invalid width.\n", seq->lss_name);
+	rc = kstrtoull_from_user(buffer, count, 0, &seq->lss_width);
+	if (rc) {
+		CERROR("%s: invalid FID sequence width: rc = %d\n",
+		       seq->lss_name, rc);
 		GOTO(out_unlock, count = rc);
 	}
 
-	seq->lss_width = val;
-
-	CDEBUG(D_INFO, "%s: Width: "LPU64"\n",
+	CDEBUG(D_INFO, "%s: Width: %llu\n",
 	       seq->lss_name, seq->lss_width);
 out_unlock:
 	mutex_unlock(&seq->lss_mutex);
@@ -194,32 +183,29 @@ 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;
-	int rc;
-	ENTRY;
-
-	LASSERT(seq != NULL);
 
+	ENTRY;
 	mutex_lock(&seq->lss_mutex);
-	rc = seq_printf(m, LPU64"\n", seq->lss_width);
+	seq_printf(m, "%llu\n", seq->lss_width);
 	mutex_unlock(&seq->lss_mutex);
 
-	RETURN(rc);
+	RETURN(0);
 }
 
-LPROC_SEQ_FOPS(lprocfs_server_fid_space);
-LPROC_SEQ_FOPS(lprocfs_server_fid_width);
-LPROC_SEQ_FOPS_RO(lprocfs_server_fid_server);
+LDEBUGFS_SEQ_FOPS(ldebugfs_server_fid_space);
+LDEBUGFS_SEQ_FOPS(ldebugfs_server_fid_width);
+LDEBUGFS_SEQ_FOPS_RO(ldebugfs_server_fid_server);
 
-struct lprocfs_seq_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 }
 };
 
@@ -334,7 +320,7 @@ static int fldb_seq_show(struct seq_file *p, void *v)
 		       fld->lsf_name, rc);
 	} else if (fld_rec.lsr_start != 0) {
 		range_be_to_cpu(&fld_rec, &fld_rec);
-		rc = seq_printf(p, DRANGE"\n", PRANGE(&fld_rec));
+		seq_printf(p, DRANGE"\n", PRANGE(&fld_rec));
 	}
 
 	return rc;
@@ -350,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;
@@ -361,7 +347,6 @@ static int fldb_seq_open(struct inode *inode, struct file *file)
 	fld = ss->lss_site->ss_server_fld;
 	LASSERT(fld != NULL);
 
-	LPROCFS_ENTRY_CHECK(PDE(inode));
 	rc = seq_open(file, &fldb_sops);
 	if (rc)
 		return rc;
@@ -383,7 +368,7 @@ static int fldb_seq_open(struct inode *inode, struct file *file)
 
 	env_init = 1;
 	iops = &obj->do_index_ops->dio_it;
-	param->fsp_it = iops->init(&param->fsp_env, obj, 0, NULL);
+	param->fsp_it = iops->init(&param->fsp_env, obj, 0);
 	if (IS_ERR(param->fsp_it))
 		GOTO(out, rc = PTR_ERR(param->fsp_it));
 
@@ -413,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;
 	}
 
@@ -427,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);
-	lprocfs_seq_release(inode, file);
+	seq_release(inode, file);
 
 	return 0;
 }
@@ -493,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,
@@ -503,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 seq_file *m = file->private_data;
+	struct lu_client_seq *seq = m->private;
 	int rc;
-	ENTRY;
 
-	LASSERT(seq != NULL);
+	ENTRY;
 
 	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));
 	}
 
@@ -526,125 +512,110 @@ 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;
-	int rc;
-	ENTRY;
-
-	LASSERT(seq != NULL);
 
+	ENTRY;
 	mutex_lock(&seq->lcs_mutex);
-	rc = seq_printf(m, "["LPX64" - "LPX64"]:%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(rc);
+	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 lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
-	__u64  max;
-	int rc, val;
-	ENTRY;
+	struct seq_file *m = file->private_data;
+	struct lu_client_seq *seq = m->private;
+	u64 val;
+	u64 max;
+	int rc;
 
-	LASSERT(seq != NULL);
+	ENTRY;
+	rc = kstrtoull_from_user(buffer, count, 0, &val);
+	if (rc)
+		return rc;
 
 	mutex_lock(&seq->lcs_mutex);
-
-	rc = lprocfs_write_helper(buffer, count, &val);
-	if (rc) {
-		mutex_unlock(&seq->lcs_mutex);
-		RETURN(rc);
-	}
-
 	if (seq->lcs_type == LUSTRE_SEQ_DATA)
 		max = LUSTRE_DATA_SEQ_MAX_WIDTH;
 	else
 		max = LUSTRE_METADATA_SEQ_MAX_WIDTH;
 
-	if (val <= max && val > 0) {
+	if (val <= max) {
 		seq->lcs_width = val;
 
-		if (rc == 0) {
-			CDEBUG(D_INFO, "%s: Sequence size: "LPU64"\n",
-			       seq->lcs_name, seq->lcs_width);
-		}
+		CDEBUG(D_INFO, "%s: Sequence size: %llu\n", seq->lcs_name,
+		       seq->lcs_width);
+	} else {
+		count = -ERANGE;
 	}
-	mutex_unlock(&seq->lcs_mutex);
 
+	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;
-	int rc;
-	ENTRY;
-
-	LASSERT(seq != NULL);
 
+	ENTRY;
 	mutex_lock(&seq->lcs_mutex);
-	rc = seq_printf(m, LPU64"\n", seq->lcs_width);
+	seq_printf(m, "%llu\n", seq->lcs_width);
 	mutex_unlock(&seq->lcs_mutex);
 
-	RETURN(rc);
+	RETURN(0);
 }
 
 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;
-	int rc;
-	ENTRY;
-
-	LASSERT(seq != NULL);
 
+	ENTRY;
 	mutex_lock(&seq->lcs_mutex);
-	rc = seq_printf(m, DFID"\n", PFID(&seq->lcs_fid));
+	seq_printf(m, DFID"\n", PFID(&seq->lcs_fid));
 	mutex_unlock(&seq->lcs_mutex);
 
-	RETURN(rc);
+	RETURN(0);
 }
 
 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;
-	int rc;
 	ENTRY;
 
-	LASSERT(seq != NULL);
-
-	if (seq->lcs_exp != NULL) {
+	if (seq->lcs_exp) {
 		cli = &seq->lcs_exp->exp_obd->u.cli;
-		rc = seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
+		seq_printf(m, "%s\n", cli->cl_target_uuid.uuid);
+#ifdef HAVE_SERVER_SUPPORT
 	} else {
-		rc = seq_printf(m, "%s\n", seq->lcs_srv->lss_name);
+		seq_printf(m, "%s\n", seq->lcs_srv->lss_name);
+#endif /* HAVE_SERVER_SUPPORT */
 	}
-	RETURN(rc);
+
+	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);
+LDEBUGFS_SEQ_FOPS(ldebugfs_client_fid_space);
+LDEBUGFS_SEQ_FOPS(ldebugfs_client_fid_width);
+LDEBUGFS_SEQ_FOPS_RO(ldebugfs_client_fid_server);
+LDEBUGFS_SEQ_FOPS_RO(ldebugfs_client_fid_fid);
 
-struct lprocfs_seq_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