Skip site navigation (1)Skip section navigation (2)
Date:      Fri, 13 Jul 2012 16:14:37 +0000
From:      gpf@FreeBSD.org
To:        svn-soc-all@FreeBSD.org
Subject:   socsvn commit: r239346 - in soc2012/gpf/pefs_kmod: sbin/pefs sys/fs/pefs
Message-ID:  <20120713161437.B24E01065675@hub.freebsd.org>

next in thread | raw e-mail | index | archive | help
Author: gpf
Date: Fri Jul 13 16:14:37 2012
New Revision: 239346
URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=239346

Log:
  - code refactoring/cleanup for kernel land
  
  also change pxnc_filename's size to MAXNAMLEN
  

Modified:
  soc2012/gpf/pefs_kmod/sbin/pefs/pefs_checksum.c
  soc2012/gpf/pefs_kmod/sbin/pefs/pefs_ctl.c
  soc2012/gpf/pefs_kmod/sbin/pefs/pefs_key.c
  soc2012/gpf/pefs_kmod/sbin/pefs/pefs_keychain.c
  soc2012/gpf/pefs_kmod/sbin/pefs/pefs_subr.c
  soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs.h
  soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_checksum.c
  soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_checksum.h
  soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_vfsops.c
  soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_vnops.c
  soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_xbase64.c

Modified: soc2012/gpf/pefs_kmod/sbin/pefs/pefs_checksum.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sbin/pefs/pefs_checksum.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sbin/pefs/pefs_checksum.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -221,13 +221,13 @@
 			return (PEFS_ERR_IO);
 		}
 
-		dprintf(("read %d bytes from kernel\n\n", xsl.pxsl_slink_len));
+		dprintf(("read %d bytes from kernel\n\n", xsl.pxsl_target_len));
 		dprintf(("printing contents of buf:"));
-		for (i=0; i < (int)xsl.pxsl_slink_len; i++)
-			dprintf(("%c", xsl.pxsl_slink[i]));
+		for (i=0; i < (int)xsl.pxsl_target_len; i++)
+			dprintf(("%c", xsl.pxsl_target[i]));
 		dprintf(("!\n"));
-		buf = xsl.pxsl_slink;
-		buf_len = xsl.pxsl_slink_len;
+		buf = xsl.pxsl_target;
+		buf_len = xsl.pxsl_target_len;
 	}
 	EVP_MD_CTX_init(&mdctx);
 	EVP_DigestInit_ex(&mdctx, md, NULL);

Modified: soc2012/gpf/pefs_kmod/sbin/pefs/pefs_ctl.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sbin/pefs/pefs_ctl.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sbin/pefs/pefs_ctl.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -33,6 +33,7 @@
 #include <sys/module.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
+#include <sys/dirent.h>
 
 #include <assert.h>
 #include <ctype.h>

Modified: soc2012/gpf/pefs_kmod/sbin/pefs/pefs_key.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sbin/pefs/pefs_key.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sbin/pefs/pefs_key.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -31,6 +31,7 @@
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/errno.h>
+#include <sys/dirent.h>
 #include <assert.h>
 #include <inttypes.h>
 #include <stdio.h>

Modified: soc2012/gpf/pefs_kmod/sbin/pefs/pefs_keychain.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sbin/pefs/pefs_keychain.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sbin/pefs/pefs_keychain.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -30,6 +30,7 @@
 #include <sys/param.h>
 #include <sys/endian.h>
 #include <sys/stat.h>
+#include <sys/dirent.h>
 #include <assert.h>
 #include <inttypes.h>
 #include <stdio.h>

Modified: soc2012/gpf/pefs_kmod/sbin/pefs/pefs_subr.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sbin/pefs/pefs_subr.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sbin/pefs/pefs_subr.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -32,6 +32,7 @@
 #include <sys/ioccom.h>
 #include <sys/module.h>
 #include <sys/mount.h>
+#include <sys/dirent.h>
 
 #include <assert.h>
 #include <ctype.h>

Modified: soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs.h
==============================================================================
--- soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs.h	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs.h	Fri Jul 13 16:14:37 2012	(r239346)
@@ -51,8 +51,7 @@
 struct pefs_xnamecsum {
 	uint32_t		pxnc_namelen;
 	char			pxnc_csum[PEFS_NAME_CSUM_SIZE];
-	/* XXXgpf: should probably be MAXNAMLEN */
-	char			pxnc_filename[MAXPATHLEN];
+	char			pxnc_filename[MAXNAMLEN];
 };
 
 struct pefs_xsector_ctext {
@@ -63,10 +62,9 @@
 
 struct pefs_xslink_ctext {
 	uint32_t		pxsl_namelen;
-	uint32_t		pxsl_slink_len;
+	uint32_t		pxsl_target_len;
 	char			pxsl_filename[MAXPATHLEN];
-	/* XXXgpf: rename to target */
-	char			pxsl_slink[PEFS_SECTOR_SIZE];
+	char			pxsl_target[PEFS_SECTOR_SIZE];
 };
 
 #ifdef _IO

Modified: soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_checksum.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_checksum.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_checksum.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -48,6 +48,68 @@
 const char *pefs_checksum_supported_digests[] = {"sha256","sha512"};
 uint8_t pefs_checksum_supported_hash_lengths[] = {32, 64};
 
+/* XXXgpf: tmp 4 dbg purposes */
+//static void
+//pefs_dbg_checksum_file(struct pefs_checksum *pcs)
+//{
+	//char *p;
+	//int i;
+	//uint32_t nhashes;
+	//uint32_t offset;
+	//uint64_t file_id;
+
+	///* print .pefs.checksum file header info */
+	//printf("\n+++CHECKSUM FILE HEADER INFO+++\n");
+	//printf("version = %x\nreserved = %d\nhash len = %d\noffset = %d\nsize = %d\nalgo = %s\n\n",
+		//pcs->pcs_version, pcs->pcs_reserved, pcs->pcs_hash_len, pcs->pcs_offset_to_hash_table,
+		//pcs->pcs_hash_table_size, pcs->pcs_hash_algo_name);
+
+	///* print table1 */
+	//printf("+++HASH TABLE 1+++\n\n");
+	//for (i = 0; i < pcs->pcs_hash_table_size; i++) {
+		//p = &(pcs->pcs_table1[i * PEFS_HT_CELL_SIZE]);
+
+		//memcpy(&nhashes, p, sizeof(nhashes));
+		//nhashes = le32toh(nhashes);
+		//if (nhashes != 0) {
+			//p+=sizeof(nhashes);
+			//memcpy(&offset, p, sizeof(offset));
+			//offset = le32toh(offset);
+			//p+=sizeof(offset);
+			//memcpy(&file_id, p, sizeof(file_id));
+			//file_id = le64toh(file_id);
+			//printf("cell %d:\n", i);
+			//printf("\thashes = %d\n\toffset = %d\n\tfile id = %llu\n",
+				//nhashes, offset, file_id);
+		//}
+		//else
+			//printf("cell %d: empty\n", i);
+	//}
+
+	///* print table2 */
+	//printf("\n+++HASH TABLE 2+++\n\n");
+	//for (i = 0; i < pcs->pcs_hash_table_size; i++) {
+		//p = &(pcs->pcs_table2[i * PEFS_HT_CELL_SIZE]);
+
+		//memcpy(&nhashes, p, sizeof(nhashes));
+		//nhashes = le32toh(nhashes);
+		//if (nhashes != 0) {
+			//p+=sizeof(nhashes);
+			//memcpy(&offset, p, sizeof(offset));
+			//offset = le32toh(offset);
+			//p+=sizeof(offset);
+			//memcpy(&file_id, p, sizeof(file_id));
+			//file_id = le64toh(file_id);
+			//printf("cell %d:\n", i);
+			//printf("\thashes = %d\n\toffset = %d\n\tfile id = %llu\n",
+				//nhashes, offset, file_id);
+		//}
+		//else
+			//printf("cell %d: empty\n", i);
+	//}
+//}
+
+/* sanitize .pefs.checkum's global file header that's read during VFS_MOUNT() */
 int
 pefs_sanitize_checksum_header(struct pefs_checksum *pcs)
 {
@@ -64,14 +126,14 @@
 	/* FALLTHROUGH */
 	case (PEFS_SHA256):
 	case (PEFS_SHA512):
-		printf("digest: %s\n", pcs->pcs_hash_algo_name);
+		dprintf(("digest: %s\n", pcs->pcs_hash_algo_name));
 		if (pcs->pcs_hash_len != pefs_checksum_supported_hash_lengths[i]) {
-			printf("pefs_sanitize invalid algo len %u\n", pcs->pcs_hash_len);
+			dprintf(("pefs_sanitize invalid algo len %u\n", pcs->pcs_hash_len));
 			error = EINVAL;
 		}
 		break;
 	default:
-		printf("pefs_sanitize invalid algo %s\n", pcs->pcs_hash_algo_name);
+		dprintf(("pefs_sanitize invalid algo %s\n", pcs->pcs_hash_algo_name));
 		error = ENODEV;
 		break;
 	}
@@ -80,23 +142,25 @@
 }
 
 static uint32_t
-pefs_checksum_hash1(struct pefs_checksum *pc, struct pefs_checksum_index_entry *pcie)
+pefs_checksum_hash1(struct pefs_checksum *pc,
+	struct pefs_checksum_index_entry *pcie)
 {
 	uint32_t nbucket;
 
 	nbucket = pcie->pcie_file_id % pc->pcs_hash_table_size;
-	printf("hash1: goto bucket %d\n", nbucket);
+	dprintf(("hash1: goto bucket %d\n", nbucket));
 	return (nbucket);
 }
 
 static uint32_t
-pefs_checksum_hash2(struct pefs_checksum *pc, struct pefs_checksum_index_entry *pcie)
+pefs_checksum_hash2(struct pefs_checksum *pc,
+	struct pefs_checksum_index_entry *pcie)
 {
 	uint32_t nbucket;
 
-	nbucket = fnv_64_buf(&(pcie->pcie_file_id), sizeof(pcie->pcie_file_id), FNV1_64_INIT)
-			% pc->pcs_hash_table_size;
-	printf("hash2: goto bucket %d\n", nbucket);
+	nbucket = fnv_64_buf(&(pcie->pcie_file_id), sizeof(pcie->pcie_file_id),
+		FNV1_64_INIT) % pc->pcs_hash_table_size;
+	dprintf(("hash2: goto bucket %d\n", nbucket));
 
 	return (nbucket);
 }
@@ -122,7 +186,8 @@
 }
 
 static int
-pefs_checksum_index_lookup(struct pefs_checksum_index_entry *pcie, struct vnode *vp)
+pefs_checksum_index_lookup(struct pefs_checksum_index_entry *pcie,
+	struct vnode *vp)
 {
 	struct pefs_checksum_index_entry target_pcie;
 	struct pefs_mount *pm = VFS_TO_PEFS(vp->v_mount);
@@ -136,13 +201,14 @@
 	pefs_get_index_entry(start, &target_pcie);
 
 	if (!PEFS_EMPTY_INDEX_ENTRY(&target_pcie)) {
-		printf("cell %d:\n", pos);
-		printf("\thashes = %d\n\toffset = %d\n\tfile id = %llu\n",
-			target_pcie.pcie_nhashes, target_pcie.pcie_offset, target_pcie.pcie_file_id);
+		dprintf(("cell %d:\n", pos));
+		dprintf(("\thashes = %d\n\toffset = %d\n\tfile id = %llu\n",
+			target_pcie.pcie_nhashes, target_pcie.pcie_offset,
+			target_pcie.pcie_file_id));
 
 		if (target_pcie.pcie_file_id == pcie->pcie_file_id) {
 			pn->pn_checksum_index_entry = start;
-			printf("checksum lookup: found1!\n");
+			dprintf(("checksum lookup: found1!\n"));
 			return (0);
 		}
 	}
@@ -152,19 +218,20 @@
 	pefs_get_index_entry(start, &target_pcie);
 
 	if (!PEFS_EMPTY_INDEX_ENTRY(&target_pcie)) {
-		printf("cell %d:\n", pos);
-		printf("\thashes = %d\n\toffset = %d\n\tfile id = %llu\n",
-			target_pcie.pcie_nhashes, target_pcie.pcie_offset, target_pcie.pcie_file_id);
+		dprintf(("cell %d:\n", pos));
+		dprintf(("\thashes = %d\n\toffset = %d\n\tfile id = %llu\n",
+			target_pcie.pcie_nhashes, target_pcie.pcie_offset,
+			target_pcie.pcie_file_id));
 
 		if (target_pcie.pcie_file_id == pcie->pcie_file_id) {
 			pn->pn_checksum_index_entry = start;
-			printf("checksum lookup: found2!\n");
+			dprintf(("checksum lookup: found2!\n"));
 			return (0);
 		}
 	}
 
 	pn->pn_checksum_index_entry = NULL;
-	printf("checksum lookup: not found!\n");
+	dprintf(("checksum lookup: not found!\n"));
 	return (ENOENT);
 }
 
@@ -178,14 +245,13 @@
 	size_t buf_len;
 	int error, r;
 
-	printf("gpf: checksum code @ lookup\n");
+	dprintf(("gpf: checksum code @ lookup\n"));
 	if ((cnp != NULL && cnp->cn_nameiop != LOOKUP) || (vp->v_type != VREG &&
 		vp->v_type != VLNK)
 		|| ((pn->pn_flags & PN_NO_CHECKSUM) != 0))
 		goto not_found;
 
 	/* XXXgpf: What if user wants integrity checking for .pefs.db or .conf? */
-	/* XXXgpf: [TODO] move this check to a mini function */
 	if (strncmp(enc_name, ".pefs.db", enc_name_len) == 0 ||
 		strncmp(enc_name, ".pefs.conf", enc_name_len) == 0 ||
 		strncmp(enc_name, ".pefs.checksum", enc_name_len) == 0)
@@ -200,12 +266,12 @@
 	if (r <= 0) {
 		/* XXXgpf: I sincerely doubt an error can occur here */
 		error = EINVAL;
-		printf("name_pton error: %d\n", error);
+		dprintf(("name_pton error: %d\n", error));
 	}
 	else {
 		memcpy(&(pcie.pcie_file_id), buf, sizeof(pcie.pcie_file_id));
 		pcie.pcie_file_id = be64toh(pcie.pcie_file_id);
-		printf("id to lookup: %llu\n", pcie.pcie_file_id);
+		dprintf(("id to lookup: %llu\n", pcie.pcie_file_id));
 		error = pefs_checksum_index_lookup(&pcie, vp);
 		if (error != 0) {
 			free(buf, M_TEMP);
@@ -234,9 +300,10 @@
 		dig = malloc(*digest_len, M_TEMP, M_WAITOK);
 		/*
 		 * XXXgpf: Does this interface work for any length input?
-		 * Also, I should either use a different interface or store the checksums
-		 * in hex during .pefs.checksum creation because turning them to hex
-		 * at this point every single time we have a read is just silly.
+		 * Also, I should either use a different interface or store the
+		 * checksums in hex during .pefs.checksum creation because turning
+		 * them to hex at this point every single time we have a read is
+		 * just silly.
 		 */
 		SHA256_Data(data, data_len, dig);
 		break;
@@ -246,7 +313,7 @@
 		SHA512_Data(data, data_len, dig);
 		break;
 	default:
-		printf("pefs_sanitize invalid algo %s\n", pcs->pcs_hash_algo_name);
+		dprintf(("pefs_sanitize invalid algo %s\n", pcs->pcs_hash_algo_name));
 		return (ENODEV);
 	}
 
@@ -275,7 +342,7 @@
 	/* XXXgpf: gleb says  I should use vn_rdwr instead of VOP_READ */
 	error = VOP_READ(pcs->pcs_checksumvp, puio, IO_UNIT, cred);
 	if (error != 0) {
-		printf("pefs_retrieve_checksum read error %d\n", error);
+		dprintf(("pefs_retrieve_checksum read error %d\n", error));
 		return (error);
 	}
 
@@ -296,12 +363,12 @@
 {
 	int error;
 
-	printf("compare dig1: %s\n", digest1);
-	printf("compare dig2: %s\n", digest2);
+	dprintf(("compare dig1: %s\n", digest1));
+	dprintf(("compare dig2: %s\n", digest2));
 
 	error = memcmp(digest1, digest2, digest_len);
 	if (error != 0) {
-		printf("checksum mismatch!\n");
+		dprintf(("checksum mismatch!\n"));
 		error = EAUTH;
 	}
 
@@ -320,21 +387,21 @@
 	long *p;
 	int error;
 
-	printf("integrity checking!\noffset %llu\n", offset);
+	dprintf(("integrity checking!\noffset %llu\n", offset));
 
 	if ((pn->pn_flags & PN_WRONG_CHECKSUM) != 0)
 		return (EAUTH);
 
 	pefs_get_index_entry(pn->pn_checksum_index_entry, &pcie);
 
-	printf("id: %llu\n", pcie.pcie_file_id);
+	dprintf(("id: %llu\n", pcie.pcie_file_id));
 
 	buf = (char *)pc->pc_base;
 	end = buf + pc->pc_size;
 
 	if ((fsize > pcie.pcie_nhashes * PEFS_SECTOR_SIZE) ||
 		(fsize < (pcie.pcie_nhashes - 1) * PEFS_SECTOR_SIZE)) {
-		printf("file size differs from the one in .pefs.checksum\n");
+		dprintf(("file size differs from the one in .pefs.checksum\n"));
 		pn->pn_flags|= PN_WRONG_CHECKSUM;
 		return (EAUTH);
 	}

Modified: soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_checksum.h
==============================================================================
--- soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_checksum.h	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_checksum.h	Fri Jul 13 16:14:37 2012	(r239346)
@@ -36,8 +36,16 @@
 #define PEFS_SHA256 0
 #define PEFS_SHA512 1
 
-//#define PEFS_EMPTY_INDEX_ENTRY(a)	(((struct pefs_checksum_index_entry *)a->pcie_nhashes == 0) ? 1 : 0)
-//#define PEFS_NEEDS_CHECKING(a)		(((struct pefs_node *)a->pn_checksum_index_entry != NULL) ? 1 : 0)
+/*
+ * XXXgpf: use this instead of PEFS_DEBUG so as to lower the number of debugging
+ * messages during code development.
+ */
+//#define PEFS_INTEGRITY_DEBUG
+#if defined (PEFS_INTEGRITY_DEBUG)
+#define dprintf(a)		printf a
+#else
+#define dprintf(a)      (void)0
+#endif
 
 struct pefs_checksum_index_entry {
 	uint32_t pcie_nhashes;

Modified: soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_vfsops.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_vfsops.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_vfsops.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -45,6 +45,7 @@
 #include <sys/namei.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
+#include <sys/dirent.h>
 
 #include <fs/pefs/pefs.h>
 #include <fs/pefs/pefs_checksum.h>
@@ -129,74 +130,12 @@
 {
 	if (vp == NULL)
 		return;
-	printf("%s is locked: %d\n", str, VOP_ISLOCKED(vp));
-	printf("%s usecount: %d\n", str, vp->v_usecount);
-	printf("%s holdcnt: %d\n", str, vp->v_holdcnt);
-	printf("%s writecount: %d\n", str, vp->v_writecount);
+	dprintf(("%s is locked: %d\n", str, VOP_ISLOCKED(vp)));
+	dprintf(("%s usecount: %d\n", str, vp->v_usecount));
+	dprintf(("%s holdcnt: %d\n", str, vp->v_holdcnt));
+	dprintf(("%s writecount: %d\n", str, vp->v_writecount));
 }
 
-/* XXXgpf: tmp 4 dbg purposes */
-static void
-pefs_dbg_checksum_file(struct pefs_checksum *pcs)
-{
-	char *p;
-	int i;
-	uint32_t nhashes;
-	uint32_t offset;
-	uint64_t file_id;
-
-	/* print .pefs.checksum file header info */
-	printf("\n+++CHECKSUM FILE HEADER INFO+++\n");
-	printf("version = %x\nreserved = %d\nhash len = %d\noffset = %d\nsize = %d\nalgo = %s\n\n",
-		pcs->pcs_version, pcs->pcs_reserved, pcs->pcs_hash_len, pcs->pcs_offset_to_hash_table,
-		pcs->pcs_hash_table_size, pcs->pcs_hash_algo_name);
-
-	/* print table1 */
-	printf("+++HASH TABLE 1+++\n\n");
-	for (i = 0; i < pcs->pcs_hash_table_size; i++) {
-		p = &(pcs->pcs_table1[i * PEFS_HT_CELL_SIZE]);
-
-		memcpy(&nhashes, p, sizeof(nhashes));
-		nhashes = le32toh(nhashes);
-		if (nhashes != 0) {
-			p+=sizeof(nhashes);
-			memcpy(&offset, p, sizeof(offset));
-			offset = le32toh(offset);
-			p+=sizeof(offset);
-			memcpy(&file_id, p, sizeof(file_id));
-			file_id = le64toh(file_id);
-			printf("cell %d:\n", i);
-			printf("\thashes = %d\n\toffset = %d\n\tfile id = %llu\n",
-				nhashes, offset, file_id);
-		}
-		else
-			printf("cell %d: empty\n", i);
-	}
-
-	/* print table2 */
-	printf("\n+++HASH TABLE 2+++\n\n");
-	for (i = 0; i < pcs->pcs_hash_table_size; i++) {
-		p = &(pcs->pcs_table2[i * PEFS_HT_CELL_SIZE]);
-
-		memcpy(&nhashes, p, sizeof(nhashes));
-		nhashes = le32toh(nhashes);
-		if (nhashes != 0) {
-			p+=sizeof(nhashes);
-			memcpy(&offset, p, sizeof(offset));
-			offset = le32toh(offset);
-			p+=sizeof(offset);
-			memcpy(&file_id, p, sizeof(file_id));
-			file_id = le64toh(file_id);
-			printf("cell %d:\n", i);
-			printf("\thashes = %d\n\toffset = %d\n\tfile id = %llu\n",
-				nhashes, offset, file_id);
-		}
-		else
-			printf("cell %d: empty\n", i);
-	}
-}
-
-/* XXXgpf: [TODO] move this to pefs_checksum.c */
 static int
 pefs_checksum_load(struct mount *mp)
 {
@@ -217,14 +156,15 @@
 
 	pathlen = MAXPATHLEN + 1;
 	path = malloc(pathlen, M_TEMP, M_WAITOK);
-	snprintf(path, pathlen, "%s/%s", mp->mnt_stat.f_mntfromname, PEFS_FILE_CHECKSUM);
+	snprintf(path, pathlen, "%s/%s", mp->mnt_stat.f_mntfromname,
+		PEFS_FILE_CHECKSUM);
 
 	/* grab a vp for our checksum file */
 	NDINIT(ndp, LOOKUP, LOCKLEAF, UIO_SYSSPACE, path, curthread);
 	error = namei(ndp);
 	free(path, M_TEMP);
 	if (error != 0) {
-		printf("pefs_checksum_load: namei error %d\n", error);
+		dprintf(("pefs_checksum_load: namei error %d\n", error));
 		return (error);
 	}
 
@@ -239,7 +179,7 @@
 	/* XXXgpf: gleb says  I should use vn_rdwr instead of VOP_READ */
 	error = VOP_READ(checksumvp, puio, IO_UNIT, cred);
 	if (error != 0) {
-		printf("pefs_checksum_load: vop_read1 error %d\n", error);
+		dprintf(("pefs_checksum_load: vop_read1 error %d\n", error));
 		pefs_chunk_free(&pc, NULL);
 		vput(checksumvp);
 		return (error);
@@ -254,14 +194,15 @@
 	bufp+=sizeof(pcs->pcs_hash_len);
 	memcpy(&(pcs->pcs_hash_algo_name), bufp, sizeof(pcs->pcs_hash_algo_name));
 	bufp+=sizeof(pcs->pcs_hash_algo_name);
-	memcpy(&(pcs->pcs_offset_to_hash_table), bufp, sizeof(pcs->pcs_offset_to_hash_table));
+	memcpy(&(pcs->pcs_offset_to_hash_table), bufp,
+		sizeof(pcs->pcs_offset_to_hash_table));
 	bufp+=sizeof(pcs->pcs_offset_to_hash_table);
 	memcpy(&(pcs->pcs_hash_table_size), bufp, sizeof(pcs->pcs_hash_table_size));
 	pcs->pcs_hash_table_size = le32toh(pcs->pcs_hash_table_size);
 
 	error = pefs_sanitize_checksum_header(pcs);
 	if (error != 0) {
-		printf("pefs_checksum_load: sanitize error %d\n", error);
+		dprintf(("pefs_checksum_load: sanitize error %d\n", error));
 		pefs_chunk_free(&pc, NULL);
 		vput(checksumvp);
 		return (error);
@@ -276,7 +217,7 @@
 
 	error = VOP_READ(checksumvp, puio, IO_UNIT, cred);
 	if (error != 0) {
-		printf("pefs_checksum_load: vop_read2 error %d\n", error);
+		dprintf(("pefs_checksum_load: vop_read2 error %d\n", error));
 		pefs_chunk_free(&pc, NULL);
 		vput(checksumvp);
 		return (error);
@@ -287,11 +228,12 @@
 	pefs_chunk_free(&pc, NULL);
 
 	pefs_chunk_create(&pc, NULL, buflen);
-	puio = pefs_chunk_uio(&pc, pcs->pcs_offset_to_hash_table + buflen, UIO_READ);
+	puio = pefs_chunk_uio(&pc, pcs->pcs_offset_to_hash_table +
+		buflen, UIO_READ);
 
 	error = VOP_READ(checksumvp, puio, IO_UNIT, cred);
 	if (error != 0) {
-		printf("pefs_checksum_load: vop_read3 error %d\n", error);
+		dprintf(("pefs_checksum_load: vop_read3 error %d\n", error));
 		pefs_chunk_free(&pc, NULL);
 		free(pcs->pcs_table1, M_PEFSCSTABLE);
 		vput(checksumvp);
@@ -302,9 +244,6 @@
 	memcpy(pcs->pcs_table2, pc.pc_base, buflen);
 	pefs_chunk_free(&pc, NULL);
 
-	/* print everything */
-	pefs_dbg_checksum_file(pcs);
-
 	pefs_dbg_vnode(checksumvp, "before VOP_UNLOCK checksumvp");
 	/* keep the reference for checksumvp */
 	VOP_UNLOCK(checksumvp, 0);
@@ -353,7 +292,7 @@
 	opt_checksum = -1;
 	if (vfs_flagopt(mp->mnt_optnew, "checksum", NULL, 0)) {
 		vfs_deleteopt(mp->mnt_optnew, "checksum");
-		printf("checksum!\n");
+		dprintf(("checksum!\n"));
 		opt_checksum = 1;
 	}
 

Modified: soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_vnops.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_vnops.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_vnops.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -486,9 +486,8 @@
 	int nokey_lookup, skip_lookup;
 	int error;
 
-	/* XXXgpf: [TODO] PEFSDEBUGs instead of printfs */
-	printf("pefs_lookup: op=%lx, name=%.*s\n",
-	    cnp->cn_nameiop, (int)cnp->cn_namelen, cnp->cn_nameptr);
+	dprintf(("pefs_lookup: op=%lx, name=%.*s\n",
+	    cnp->cn_nameiop, (int)cnp->cn_namelen, cnp->cn_nameptr));
 
 	pefs_enccn_init(&enccn);
 
@@ -566,12 +565,17 @@
 				pm = VFS_TO_PEFS(vp->v_mount);
 				if ((pm->pm_flags & PM_CHECKSUM) != 0) {
 					if (nokey_lookup) {
-						printf("cnp name=%.*s\n",(int)cnp->cn_namelen, cnp->cn_nameptr);
-						pefs_checksum_lookup(cnp->cn_nameptr, cnp->cn_namelen, cnp, vp);
+						dprintf(("cnp name=%.*s\n",(int)cnp->cn_namelen,
+							cnp->cn_nameptr));
+						pefs_checksum_lookup(cnp->cn_nameptr,
+							cnp->cn_namelen, cnp, vp);
 					}
 					else {
-						printf("enccnp name=%.*s\n",(int)enccn.pec_cn.cn_namelen, enccn.pec_cn.cn_nameptr);
-						pefs_checksum_lookup(enccn.pec_cn.cn_nameptr, enccn.pec_cn.cn_namelen, cnp, vp);
+						dprintf(("enccnp name=%.*s\n",
+							(int)enccn.pec_cn.cn_namelen,
+							enccn.pec_cn.cn_nameptr));
+						pefs_checksum_lookup(enccn.pec_cn.cn_nameptr,
+							enccn.pec_cn.cn_namelen, cnp, vp);
 					}
 				}
 				*ap->a_vpp = vp;
@@ -2503,7 +2507,7 @@
 		vn_lock(vp, LK_EXCLUSIVE);
 
 		if (vp->v_type != VREG) {
-			printf("pefs_ioctl: PEFS_GETSECTORCTEXT vp is not a reg file\n");
+			dprintf(("pefs_ioctl: PEFS_GETSECTORCTEXT vp is not a reg file\n"));
 			VOP_UNLOCK(vp, 0);
 			return (EOPNOTSUPP);
 		}
@@ -2514,17 +2518,18 @@
 			return (error);
 		}
 
-		if (xsct->pxsct_ctext_len > PEFS_SECTOR_SIZE || xsct->pxsct_ctext_len == 0
-			|| xsct->pxsct_ctext_len > fsize) {
-			printf("pefs_ioctl: PEFS_GETSECTORCTEXT invalid len: %d\n",
-						xsct->pxsct_ctext_len);
+		if (xsct->pxsct_ctext_len > PEFS_SECTOR_SIZE ||
+			xsct->pxsct_ctext_len == 0 ||
+			xsct->pxsct_ctext_len > fsize) {
+			dprintf(("pefs_ioctl: PEFS_GETSECTORCTEXT invalid len: %d\n",
+						xsct->pxsct_ctext_len));
 			VOP_UNLOCK(vp, 0);
 			return (EINVAL);
 		}
 
 		if (xsct->pxsct_offset > (fsize - xsct->pxsct_ctext_len)) {
-			printf("pefs_ioctl: PEFS_GETSECTORCTEXT invalid offset: %llu\n",
-						xsct->pxsct_offset);
+			dprintf(("pefs_ioctl: PEFS_GETSECTORCTEXT invalid offset: %llu\n",
+						xsct->pxsct_offset));
 			VOP_UNLOCK(vp, 0);
 			return (EINVAL);
 		}
@@ -2543,23 +2548,23 @@
 		break;
 	case PEFS_GETNAMECSUM:
 		vn_lock(vp, LK_EXCLUSIVE);
-		/* XXXgpf: should I change printf to something else? e.g. PEFSDEBUG */
 		if (vp->v_type != VDIR) {
-			printf("pefs_ioctl: PEFS_GETNAMEMAC vp is not a directory\n");
+			dprintf(("pefs_ioctl: PEFS_GETNAMEMAC vp is not a directory\n"));
 			VOP_UNLOCK(vp, 0);
 			return (ENOTDIR);
 		}
 
 		if (strnlen(xncs->pxnc_filename, sizeof(xncs->pxnc_filename)) !=
 			xncs->pxnc_namelen) {
-			printf("pefs_ioctl: PEFS_GETNAMEMAC incorrect pxnc_namelen %d\n", xncs->pxnc_namelen);
+			dprintf(("pefs_ioctl: PEFS_GETNAMEMAC incorrect pxnc_namelen %d\n",
+				xncs->pxnc_namelen));
 			VOP_UNLOCK(vp, 0);
 			return (EINVAL);
 		}
 
 		if (strchr(xncs->pxnc_filename, '/') != NULL) {
-			printf("pefs_ioctl: PEFS_GETNAMEMAC pxnc_filename contains '/'\n");
-			VOP_UNLOCK(vp, 0);
+			dprintf(("pefs_ioctl: PEFS_GETNAMEMAC pxnc_filename contains '/'\n");
+			VOP_UNLOCK(vp, 0));
 			return (EINVAL);
 		}
 
@@ -2610,43 +2615,45 @@
 		break;
 	case PEFS_GETSLINKCTEXT:
 		if (vp->v_type != VDIR) {
-			printf("pefs_ioctl: PEFS_GETSLINKCTEXT vp is not a directory\n");
+			dprintf(("pefs_ioctl: PEFS_GETSLINKCTEXT vp is not a directory\n"));
 			VOP_UNLOCK(vp, 0);
 			return (ENOTDIR);
 		}
 
 		if (strnlen(xsl->pxsl_filename, sizeof(xsl->pxsl_filename)) !=
 			xsl->pxsl_namelen) {
-			printf("pefs_ioctl: PEFS_GETSLINKCTEXT incorrect namelen %d\n", xsl->pxsl_namelen);
+			dprintf(("pefs_ioctl: PEFS_GETSLINKCTEXT incorrect namelen %d\n",
+				xsl->pxsl_namelen));
 			VOP_UNLOCK(vp, 0);
 			return (EINVAL);
 		}
 
 		if (strchr(xsl->pxsl_filename, '/') != NULL) {
-			printf("pefs_ioctl: PEFS_GETSLINKCTEXT filename contains '/'\n");
+			dprintf(("pefs_ioctl: PEFS_GETSLINKCTEXT filename contains '/'\n"));
 			VOP_UNLOCK(vp, 0);
 			return (EINVAL);
 		}
 
 		/* grab a vnodep for our symlink */
-		NDINIT_ATVP(ndp, LOOKUP, MPSAFE | LOCKPARENT | LOCKLEAF | NOFOLLOW, UIO_SYSSPACE, xsl->pxsl_filename, vp, td);
+		NDINIT_ATVP(ndp, LOOKUP, MPSAFE | LOCKPARENT | LOCKLEAF | NOFOLLOW,
+			UIO_SYSSPACE, xsl->pxsl_filename, vp, td);
 		error = namei(ndp);
 		if (error != 0) {
-			printf("pefs_ioctl: PEFS_GETSLINKCTEXT namei error %d\n", error);
+			dprintf(("pefs_ioctl: PEFS_GETSLINKCTEXT namei error %d\n", error));
 			return (error);
 		}
 		NDFREE(ndp, NDF_ONLY_PNBUF);
 		svp = ndp->ni_vp;
 
 		if (ndp->ni_dvp != vp) {
-			printf("pefs_ioctl: PEFS_GETSLINKCTEXT namei returned wrong parent\n");
+			dprintf(("pefs_ioctl: PEFS_GETSLINKCTEXT namei wrong parent\n"));
 			vput(svp);
 			VOP_UNLOCK(vp, 0);
 			return (ENOENT);
 		}
 
 		if (svp->v_type != VLNK) {
-			printf("pefs_ioctl: PEFS_GETSLINKCTEXT svp is not a symlink\n");
+			dprintf(("pefs_ioctl: PEFS_GETSLINKCTEXT svp is not a symlink\n"));
 			vput(svp);
 			VOP_UNLOCK(vp, 0);
 			return (EFTYPE);
@@ -2661,9 +2668,9 @@
 
 		error = VOP_READLINK(slvp, puio, cred);
 
-		xsl->pxsl_slink_len = pc.pc_size - pc.pc_uio.uio_resid;
+		xsl->pxsl_target_len = pc.pc_size - pc.pc_uio.uio_resid;
 		if (error == 0)
-			memcpy(xsl->pxsl_slink, pc.pc_base, xsl->pxsl_slink_len);
+			memcpy(xsl->pxsl_target, pc.pc_base, xsl->pxsl_target_len);
 
 		pefs_chunk_free(&pc, pn);
 		vput(svp);

Modified: soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_xbase64.c
==============================================================================
--- soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_xbase64.c	Fri Jul 13 15:25:10 2012	(r239345)
+++ soc2012/gpf/pefs_kmod/sys/fs/pefs/pefs_xbase64.c	Fri Jul 13 16:14:37 2012	(r239346)
@@ -48,6 +48,7 @@
 #include <sys/libkern.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
+#include <sys/dirent.h>
 
 #include <fs/pefs/pefs.h>
 



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?20120713161437.B24E01065675>