From owner-svn-soc-all@FreeBSD.ORG Fri Jul 13 16:14:39 2012 Return-Path: Delivered-To: svn-soc-all@FreeBSD.org Received: from socsvn.FreeBSD.org (unknown [IPv6:2001:4f8:fff6::2f]) by hub.freebsd.org (Postfix) with SMTP id B24E01065675 for ; Fri, 13 Jul 2012 16:14:37 +0000 (UTC) (envelope-from gpf@FreeBSD.org) Received: by socsvn.FreeBSD.org (sSMTP sendmail emulation); Fri, 13 Jul 2012 16:14:37 +0000 Date: Fri, 13 Jul 2012 16:14:37 +0000 From: gpf@FreeBSD.org To: svn-soc-all@FreeBSD.org MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Message-Id: <20120713161437.B24E01065675@hub.freebsd.org> Cc: Subject: socsvn commit: r239346 - in soc2012/gpf/pefs_kmod: sbin/pefs sys/fs/pefs X-BeenThere: svn-soc-all@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: SVN commit messages for the entire Summer of Code repository List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 13 Jul 2012 16:14:39 -0000 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 #include #include +#include #include #include 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 #include #include +#include #include #include #include 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 #include #include +#include #include #include #include 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 #include #include +#include #include #include 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 #include #include +#include #include #include @@ -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 #include #include +#include #include