X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Ffid%2Flproc_fid.c;h=0f460f91c665e5818075642c8e70afa094456219;hb=refs%2Fchanges%2F15%2F35815%2F2;hp=9ce5a45b07d737f7bbd74cfba9c77f00c317b06d;hpb=b1ff338ede34421acfc2cdbfe0dbe7b293ebd3b2;p=fs%2Flustre-release.git

diff --git a/lustre/fid/lproc_fid.c b/lustre/fid/lproc_fid.c
index 9ce5a45..0f460f9 100644
--- a/lustre/fid/lproc_fid.c
+++ b/lustre/fid/lproc_fid.c
@@ -47,8 +47,6 @@
 #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))
 /**
@@ -60,14 +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, };
 	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);
@@ -79,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);
@@ -95,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);
 
@@ -119,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);
@@ -134,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;
@@ -156,34 +156,24 @@ 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 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;
-	__s64 val;
-	ENTRY;
-
-	LASSERT(seq != NULL);
 
+	ENTRY;
 	mutex_lock(&seq->lss_mutex);
 
-	rc = lprocfs_str_to_s64(buffer, count, &val);
+	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);
 	}
 
-	if (val < 0) {
-		CERROR("%s: invalid FID sequence width: rc = %d\n",
-		       seq->lss_name, -ERANGE);
-		GOTO(out_unlock, count = -ERANGE);
-	}
-
-	seq->lss_width = val;
-
 	CDEBUG(D_INFO, "%s: Width: %llu\n",
 	       seq->lss_name, seq->lss_width);
 out_unlock:
@@ -193,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);
@@ -207,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);
+LDEBUGFS_SEQ_FOPS(ldebugfs_server_fid_space);
+LDEBUGFS_SEQ_FOPS(ldebugfs_server_fid_width);
+LDEBUGFS_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 }
 };
 
@@ -348,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;
@@ -359,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;
@@ -414,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;
 	}
 
@@ -428,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;
 }
@@ -494,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,
@@ -504,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));
 	}
 
@@ -527,68 +512,58 @@ 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 lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
-	__u64 max;
+	struct seq_file *m = file->private_data;
+	struct lu_client_seq *seq = m->private;
+	u64 val;
+	u64 max;
 	int rc;
-	__s64 val;
-	ENTRY;
 
-	LASSERT(seq != NULL);
+	ENTRY;
+	rc = kstrtoull_from_user(buffer, count, 0, &val);
+	if (rc)
+		return rc;
 
 	mutex_lock(&seq->lcs_mutex);
-
-	rc = lprocfs_str_to_s64(buffer, count, &val);
-	if (rc) {
-		GOTO(out_unlock, count = 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;
 
-		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);
@@ -597,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);
@@ -612,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);
+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_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 */