File xen.c4ba064d53ef89cc06466349c1e987d8e91020b3.patch of Package xen

Overview Repositories Revisions Requests Users Attributes Meta

File xen.c4ba064d53ef89cc06466349c1e987d8e91020b3.patch of Package xen (Revision 4be291ecfb509bfdf12b658489a12c04)

Currently displaying revision 4be291ecfb509bfdf12b658489a12c04 , Show latest

From: Olaf Hering <olaf@aepfle.de>
Date: Fri, 23 Jun 2017 19:35:04 +0200
Subject: c4ba064d53ef89cc06466349c1e987d8e91020b3

vtpmmgr: make inline functions static

gcc7 is more strict with functions marked as inline. They are not
automatically inlined. Instead a function call is generated, but the
actual code is not visible by the linker.

Do a mechanical change and mark every 'inline' as 'static inline'. For
simpler review the static goes into an extra line.

Signed-off-by: Olaf Hering <olaf@aepfle.de>
Tested-by: Wei Liu <wei.liu2@citrix.com>
Acked-by: Wei Liu <wei.liu2@citrix.com>
---
 stubdom/vtpmmgr/marshal.h      | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 stubdom/vtpmmgr/tcg.h          | 14 ++++++++++++++
 stubdom/vtpmmgr/tpm2_marshal.h | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 stubdom/vtpmmgr/tpmrsa.h       |  1 +
 4 files changed, 149 insertions(+)

--- a/stubdom/vtpmmgr/marshal.h
+++ b/stubdom/vtpmmgr/marshal.h
@@ -38,82 +38,91 @@
 #define MARSHAL_H
 
 #include <stdlib.h>
 #include <mini-os/byteorder.h>
 #include <mini-os/endian.h>
 #include "tcg.h"
 
 typedef enum UnpackPtr {
 	UNPACK_ALIAS,
 	UNPACK_ALLOC
 } UnpackPtr;
 
+static
 inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) {
 	ptr[0] = t;
 	return ++ptr;
 }
 
+static
 inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) {
 	t[0] = ptr[0];
 	return ++ptr;
 }
 
+static
 inline int unpack3_BYTE(BYTE* ptr, UINT32* pos, UINT32 max, BYTE *t)
 {
 	if (*pos + 1 > max)
 		return TPM_SIZE;
 	unpack_BYTE(ptr + *pos, t);
 	*pos += 1;
 	return 0;
 }
 
 
 #define pack_BOOL(p, t) pack_BYTE(p, t)
 #define unpack_BOOL(p, t) unpack_BYTE(p, t)
 #define unpack3_BOOL(p, x, m, t) unpack3_BYTE(p, x, m, t)
 #define sizeof_BOOL(t) 1
 
+static
 inline BYTE* pack_UINT16(void* ptr, UINT16 t) {
 	UINT16* p = ptr;
 	*p = cpu_to_be16(t);
 	return ptr + sizeof(UINT16);
 }
 
+static
 inline BYTE* unpack_UINT16(void* ptr, UINT16* t) {
 	UINT16* p = ptr;
 	*t = be16_to_cpu(*p);
 	return ptr + sizeof(UINT16);
 }
 
+static
 inline int unpack3_UINT16(BYTE* ptr, UINT32* pos, UINT32 max, UINT16 *t)
 {
 	if (*pos + 2 > max)
 		return TPM_SIZE;
 	unpack_UINT16(ptr + *pos, t);
 	*pos += 2;
 	return 0;
 }
 
+static
 inline BYTE* pack_UINT32(void* ptr, UINT32 t) {
 	UINT32* p = ptr;
 	*p = cpu_to_be32(t);
 	return ptr + sizeof(UINT32);
 }
 
+static
 inline BYTE* unpack_UINT32(void* ptr, UINT32* t) {
 	UINT32* p = ptr;
 	*t = be32_to_cpu(*p);
 	return ptr + sizeof(UINT32);
 }
 
+static
 inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t)
 {
 	if (*pos + 4 > max)
 		return TPM_SIZE;
 	unpack_UINT32(ptr + *pos, t);
 	*pos += 4;
 	return 0;
 }
 
 #define sizeof_BYTE(x) 1
 #define sizeof_UINT16(x) 2
 #define sizeof_UINT32(x) 4
@@ -227,88 +236,98 @@ inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t)
 #define pack_TCS_CONTEXT_HANDLE(p, t) pack_UINT32(p, t)
 #define pack_TCS_KEY_HANDLE(p, t) pack_UINT32(p, t)
 
 #define unpack_TPM_AUTH_HANDLE(p, t) unpack_UINT32(p, t)
 #define unpack_TCS_CONTEXT_HANDLE(p, t) unpack_UINT32(p, t)
 #define unpack_TCS_KEY_HANDLE(p, t) unpack_UINT32(p, t)
 
 #define sizeof_TPM_AUTH_HANDLE(t) sizeof_UINT32(t)
 #define sizeof_TCS_CONTEXT_HANDLE(t) sizeof_UINT32(t)
 #define sizeof_TCS_KEY_HANDLE(t) sizeof_UINT32(t)
 
 
+static
 inline BYTE* pack_BUFFER(BYTE* ptr, const BYTE* buf, UINT32 size) {
 	memcpy(ptr, buf, size);
 	return ptr + size;
 }
 
+static
 inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) {
 	memcpy(buf, ptr, size);
 	return ptr + size;
 }
 
+static
 inline int unpack3_BUFFER(BYTE* ptr, UINT32* pos, UINT32 max, BYTE* buf, UINT32 size) {
 	if (*pos + size > max)
 		return TPM_SIZE;
 	memcpy(buf, ptr + *pos, size);
 	*pos += size;
 	return 0;
 }
 
 #define sizeof_BUFFER(b, s) s
 
+static
 inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 size) {
 	*buf = ptr;
 	return ptr + size;
 }
 
+static
 inline BYTE* unpack_ALLOC(BYTE* ptr, BYTE** buf, UINT32 size) {
 	if(size) {
 		*buf = malloc(size);
 		memcpy(*buf, ptr, size);
 	} else {
 		*buf = NULL;
 	}
 	return ptr + size;
 }
 
+static
 inline BYTE* unpack_PTR(BYTE* ptr, BYTE** buf, UINT32 size, UnpackPtr alloc) {
 	if(alloc == UNPACK_ALLOC) {
 		return unpack_ALLOC(ptr, buf, size);
 	} else {
 		return unpack_ALIAS(ptr, buf, size);
 	}
 }
 
+static
 inline int unpack3_PTR(BYTE* ptr, UINT32* pos, UINT32 max, BYTE** buf, UINT32 size, UnpackPtr alloc) {
 	if (size > max || *pos + size > max)
 		return TPM_SIZE;
 	if (alloc == UNPACK_ALLOC) {
 		unpack_ALLOC(ptr + *pos, buf, size);
 	} else {
 		unpack_ALIAS(ptr + *pos, buf, size);
 	}
 	*pos += size;
 	return 0;
 }
 #define unpack3_VPTR(ptr, pos, max, buf, size, alloc) unpack3_PTR(ptr, pos, max, (void*)(buf), size, alloc)
 
+static
 inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) {
 	return pack_BUFFER(ptr, *d, TPM_DIGEST_SIZE);
 }
 
+static
 inline BYTE* unpack_TPM_AUTHDATA(BYTE* ptr, TPM_AUTHDATA* d) {
 	return unpack_BUFFER(ptr, *d, TPM_DIGEST_SIZE);
 }
 
+static
 inline int unpack3_TPM_AUTHDATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTHDATA* d) {
 	return unpack3_BUFFER(ptr, pos, len, *d, TPM_DIGEST_SIZE);
 }
 
 #define sizeof_TPM_AUTHDATA(d) TPM_DIGEST_SIZE
 
 #define pack_TPM_SECRET(p, t) pack_TPM_AUTHDATA(p, t)
 #define pack_TPM_ENCAUTH(p, t) pack_TPM_AUTHDATA(p, t)
 #define pack_TPM_PAYLOAD_TYPE(p, t) pack_BYTE(p, t)
 #define pack_TPM_TAG(p, t) pack_UINT16(p, t)
 #define pack_TPM_STRUCTURE_TAG(p, t) pack_UINT16(p, t)
 
@@ -316,535 +335,592 @@ inline int unpack3_TPM_AUTHDATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTHDATA
 #define unpack_TPM_ENCAUTH(p, t) unpack_TPM_AUTHDATA(p, t)
 #define unpack_TPM_PAYLOAD_TYPE(p, t) unpack_BYTE(p, t)
 #define unpack_TPM_TAG(p, t) unpack_UINT16(p, t)
 #define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, t)
 #define unpack3_TPM_STRUCTURE_TAG(p, l, m, t) unpack3_UINT16(p, l, m, t)
 
 #define sizeof_TPM_SECRET(t) sizeof_TPM_AUTHDATA(t)
 #define sizeof_TPM_ENCAUTH(t) sizeof_TPM_AUTHDATA(t)
 #define sizeof_TPM_PAYLOAD_TYPE(t) sizeof_BYTE(t)
 #define sizeof_TPM_TAG(t) sizeof_UINT16(t)
 #define sizeof_TPM_STRUCTURE_TAG(t) sizeof_UINT16(t)
 
+static
 inline BYTE* pack_TPM_VERSION(BYTE* ptr, const TPM_VERSION* t) {
 	ptr[0] = t->major;
 	ptr[1] = t->minor;
 	ptr[2] = t->revMajor;
 	ptr[3] = t->revMinor;
 	return ptr + 4;
 }
 
+static
 inline BYTE* unpack_TPM_VERSION(BYTE* ptr, TPM_VERSION* t) {
 	t->major = ptr[0];
 	t->minor = ptr[1];
 	t->revMajor = ptr[2];
 	t->revMinor = ptr[3];
 	return ptr + 4;
 }
 
+static
 inline int unpack3_TPM_VERSION(BYTE* ptr, UINT32 *pos, UINT32 max, TPM_VERSION* t) {
 	if (*pos + 4 > max)
 		return TPM_SIZE;
 	ptr += *pos;
 	t->major = ptr[0];
 	t->minor = ptr[1];
 	t->revMajor = ptr[2];
 	t->revMinor = ptr[3];
 	*pos += 4;
 	return 0;
 }
 
 #define sizeof_TPM_VERSION(x) 4
 
+static
 inline BYTE* pack_TPM_CAP_VERSION_INFO(BYTE* ptr, const TPM_CAP_VERSION_INFO* v) {
 	ptr = pack_TPM_STRUCTURE_TAG(ptr, v->tag);
 	ptr = pack_TPM_VERSION(ptr, &v->version);
 	ptr = pack_UINT16(ptr, v->specLevel);
 	ptr = pack_BYTE(ptr, v->errataRev);
 	ptr = pack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID));
 	ptr = pack_UINT16(ptr, v->vendorSpecificSize);
 	ptr = pack_BUFFER(ptr, v->vendorSpecific, v->vendorSpecificSize);
 	return ptr;
 }
 
+static
 inline BYTE* unpack_TPM_CAP_VERSION_INFO(BYTE* ptr, TPM_CAP_VERSION_INFO* v, UnpackPtr alloc) {
 	ptr = unpack_TPM_STRUCTURE_TAG(ptr, &v->tag);
 	ptr = unpack_TPM_VERSION(ptr, &v->version);
 	ptr = unpack_UINT16(ptr, &v->specLevel);
 	ptr = unpack_BYTE(ptr, &v->errataRev);
 	ptr = unpack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID));
 	ptr = unpack_UINT16(ptr, &v->vendorSpecificSize);
 	ptr = unpack_PTR(ptr, &v->vendorSpecific, v->vendorSpecificSize, alloc);
 	return ptr;
 }
 
+static
 inline BYTE* pack_TPM_DIGEST(BYTE* ptr, const TPM_DIGEST* d) {
 	return pack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE);
 }
 
+static
 inline BYTE* unpack_TPM_DIGEST(BYTE* ptr, TPM_DIGEST* d) {
 	return unpack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE);
 }
 
+static
 inline int unpack3_TPM_DIGEST(BYTE* ptr, UINT32* pos, UINT32 max, TPM_DIGEST* d) {
 	return unpack3_BUFFER(ptr, pos, max, d->digest, TPM_DIGEST_SIZE);
 }
 
 #define sizeof_TPM_DIGEST(d) TPM_DIGEST_SIZE
 
 #define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d)
 #define unpack_TPM_PCRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d)
 #define unpack3_TPM_PCRVALUE(p...) unpack3_TPM_DIGEST(p)
 
 #define pack_TPM_COMPOSITE_HASH(ptr, d) pack_TPM_DIGEST(ptr, d)
 #define unpack_TPM_COMPOSITE_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d)
 #define unpack3_TPM_COMPOSITE_HASH(ptr, p, m, d) unpack3_TPM_DIGEST(ptr, p, m, d)
 #define sizeof_TPM_COMPOSITE_HASH(d) TPM_DIGEST_SIZE
 
 #define pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d)
 #define unpack_TPM_DIRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d)
 
 #define pack_TPM_HMAC(ptr, d) pack_TPM_DIGEST(ptr, d)
 #define unpack_TPM_HMAC(ptr, d) unpack_TPM_DIGEST(ptr, d)
 
 #define pack_TPM_CHOSENID_HASH(ptr, d) pack_TPM_DIGEST(ptr, d)
 #define unpack_TPM_CHOSENID_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d)
 
+static
 inline BYTE* pack_TPM_NONCE(BYTE* ptr, const TPM_NONCE* n) {
 	return pack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE);
 }
 
+static
 inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) {
 	return unpack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE);
 }
 
 #define sizeof_TPM_NONCE(x) TPM_DIGEST_SIZE
 
+static
 inline int unpack3_TPM_NONCE(BYTE* ptr, UINT32* pos, UINT32 max, TPM_NONCE* n) {
 	return unpack3_BUFFER(ptr, pos, max, n->nonce, TPM_DIGEST_SIZE);
 }
 
+static
 inline BYTE* pack_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, const TPM_SYMMETRIC_KEY_PARMS* k) {
 	ptr = pack_UINT32(ptr, k->keyLength);
 	ptr = pack_UINT32(ptr, k->blockSize);
 	ptr = pack_UINT32(ptr, k->ivSize);
 	return pack_BUFFER(ptr, k->IV, k->ivSize);
 }
 
+static
 inline BYTE* pack_TPM_SYMMETRIC_KEY(BYTE* ptr, const TPM_SYMMETRIC_KEY* k) {
 	ptr = pack_UINT32(ptr, k->algId);
 	ptr = pack_UINT16(ptr, k->encScheme);
 	ptr = pack_UINT16(ptr, k->size);
 	return pack_BUFFER(ptr, k->data, k->size);
 }
 
+static
 inline int unpack3_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 max, TPM_SYMMETRIC_KEY_PARMS* k, UnpackPtr alloc) {
 	return unpack3_UINT32(ptr, pos, max, &k->keyLength) ||
 		unpack3_UINT32(ptr, pos, max, &k->blockSize) ||
 		unpack3_UINT32(ptr, pos, max, &k->ivSize) ||
 		unpack3_PTR(ptr, pos, max, &k->IV, k->ivSize, alloc);
 }
 
+static
 inline int sizeof_TPM_SYMMETRIC_KEY_PARMS(const TPM_SYMMETRIC_KEY_PARMS* k) {
 	return 12 + k->ivSize;
 }
 
+static
 inline int unpack3_TPM_SYMMETRIC_KEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_SYMMETRIC_KEY* k, UnpackPtr alloc) {
 	return unpack3_UINT32(ptr, pos, max, &k->algId) ||
 		unpack3_UINT16(ptr, pos, max, &k->encScheme) ||
 		unpack3_UINT16(ptr, pos, max, &k->size) ||
 		unpack3_PTR(ptr, pos, max, &k->data, k->size, alloc);
 }
 
+static
 inline BYTE* pack_TPM_RSA_KEY_PARMS(BYTE* ptr, const TPM_RSA_KEY_PARMS* k) {
 	ptr = pack_UINT32(ptr, k->keyLength);
 	ptr = pack_UINT32(ptr, k->numPrimes);
 	ptr = pack_UINT32(ptr, k->exponentSize);
 	return pack_BUFFER(ptr, k->exponent, k->exponentSize);
 }
 
+static
 inline int unpack3_TPM_RSA_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 max, TPM_RSA_KEY_PARMS* k, UnpackPtr alloc) {
 	return unpack3_UINT32(ptr, pos, max, &k->keyLength) ||
 		unpack3_UINT32(ptr, pos, max, &k->numPrimes) ||
 		unpack3_UINT32(ptr, pos, max, &k->exponentSize) ||
 		unpack3_PTR(ptr, pos, max, &k->exponent, k->exponentSize, alloc);
 }
 
+static
 inline int sizeof_TPM_RSA_KEY_PARMS(const TPM_RSA_KEY_PARMS* k) {
 	return 12 + k->exponentSize;
 }
 
 
+static
 inline BYTE* pack_TPM_KEY_PARMS(BYTE* ptr, const TPM_KEY_PARMS* k) {
 	ptr = pack_TPM_ALGORITHM_ID(ptr, k->algorithmID);
 	ptr = pack_TPM_ENC_SCHEME(ptr, k->encScheme);
 	ptr = pack_TPM_SIG_SCHEME(ptr, k->sigScheme);
 	ptr = pack_UINT32(ptr, k->parmSize);
 
 	if(k->parmSize) {
 		switch(k->algorithmID) {
 			case TPM_ALG_RSA:
 				return pack_TPM_RSA_KEY_PARMS(ptr, &k->parms.rsa);
 			case TPM_ALG_AES128:
 			case TPM_ALG_AES192:
 			case TPM_ALG_AES256:
 				return pack_TPM_SYMMETRIC_KEY_PARMS(ptr, &k->parms.sym);
 		}
 	}
 	return ptr;
 }
 
+static
 inline int unpack3_TPM_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 len, TPM_KEY_PARMS* k, UnpackPtr alloc) {
 	int rc = unpack3_TPM_ALGORITHM_ID(ptr, pos, len, &k->algorithmID) ||
 		unpack3_TPM_ENC_SCHEME(ptr, pos, len, &k->encScheme) ||
 		unpack3_TPM_SIG_SCHEME(ptr, pos, len, &k->sigScheme) ||
 		unpack3_UINT32(ptr, pos, len, &k->parmSize);
 	if (rc || k->parmSize == 0)
 		return rc;
 	switch(k->algorithmID) {
 	case TPM_ALG_RSA:
 		return unpack3_TPM_RSA_KEY_PARMS(ptr, pos, len, &k->parms.rsa, alloc);
 	case TPM_ALG_AES128:
 	case TPM_ALG_AES192:
 	case TPM_ALG_AES256:
 		return unpack3_TPM_SYMMETRIC_KEY_PARMS(ptr, pos, len, &k->parms.sym, alloc);
 	}
 	return TPM_FAIL;
 }
 
+static
 inline int sizeof_TPM_KEY_PARMS(const TPM_KEY_PARMS* k) {
 	int rc = 0;
 	rc += sizeof_TPM_ALGORITHM_ID(&k->algorithmID);
 	rc += sizeof_TPM_ENC_SCHEME(&k->encScheme);
 	rc += sizeof_TPM_SIG_SCHEME(&k->sigScheme);
 	rc += sizeof_UINT32(&k->parmSize);
 	if (!k->parmSize)
 		return rc;
 	switch(k->algorithmID) {
 	case TPM_ALG_RSA:
 		rc += sizeof_TPM_RSA_KEY_PARMS(&k->parms.rsa);
 		break;
 	case TPM_ALG_AES128:
 	case TPM_ALG_AES192:
 	case TPM_ALG_AES256:
 		rc += sizeof_TPM_SYMMETRIC_KEY_PARMS(&k->parms.sym);
 		break;
 	}
 	return rc;
 }
 
+static
 inline BYTE* pack_TPM_STORE_PUBKEY(BYTE* ptr, const TPM_STORE_PUBKEY* k) {
 	ptr = pack_UINT32(ptr, k->keyLength);
 	ptr = pack_BUFFER(ptr, k->key, k->keyLength);
 	return ptr;
 }
 
+static
 inline int unpack3_TPM_STORE_PUBKEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_STORE_PUBKEY* k, UnpackPtr alloc) {
 	return unpack3_UINT32(ptr, pos, max, &k->keyLength) ||
 		unpack3_PTR(ptr, pos, max, &k->key, k->keyLength, alloc);
 }
 
+static
 inline int sizeof_TPM_STORE_PUBKEY(const TPM_STORE_PUBKEY* k) {
 	return 4 + k->keyLength;
 }
 
+static
 inline BYTE* pack_TPM_PUBKEY(BYTE* ptr, const TPM_PUBKEY* k) {
 	ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms);
 	return pack_TPM_STORE_PUBKEY(ptr, &k->pubKey);
 }
 
+static
 inline int unpack3_TPM_PUBKEY(BYTE* ptr, UINT32* pos, UINT32 len, TPM_PUBKEY* k, UnpackPtr alloc) {
 	return unpack3_TPM_KEY_PARMS(ptr, pos, len, &k->algorithmParms, alloc) ||
 		unpack3_TPM_STORE_PUBKEY(ptr, pos, len, &k->pubKey, alloc);
 }
 
+static
 inline BYTE* pack_TPM_PCR_SELECTION(BYTE* ptr, const TPM_PCR_SELECTION* p) {
 	ptr = pack_UINT16(ptr, p->sizeOfSelect);
 	ptr = pack_BUFFER(ptr, p->pcrSelect, p->sizeOfSelect);
 	return ptr;
 }
 
+static
 inline BYTE* unpack_TPM_PCR_SELECTION(BYTE* ptr, TPM_PCR_SELECTION* p, UnpackPtr alloc) {
 	ptr = unpack_UINT16(ptr, &p->sizeOfSelect);
 	ptr = unpack_PTR(ptr, &p->pcrSelect, p->sizeOfSelect, alloc);
 	return ptr;
 }
 
+static
 inline int unpack3_TPM_PCR_SELECTION(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_SELECTION* p, UnpackPtr alloc) {
 	return unpack3_UINT16(ptr, pos, max, &p->sizeOfSelect) ||
 		unpack3_PTR(ptr, pos, max, &p->pcrSelect, p->sizeOfSelect, alloc);
 }
 
+static
 inline int sizeof_TPM_PCR_SELECTION(const TPM_PCR_SELECTION* p) {
 	return 2 + p->sizeOfSelect;
 }
 
+static
 inline BYTE* pack_TPM_PCR_INFO(BYTE* ptr, const TPM_PCR_INFO* p) {
 	ptr = pack_TPM_PCR_SELECTION(ptr, &p->pcrSelection);
 	ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease);
 	ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation);
 	return ptr;
 }
 
+static
 inline int unpack3_TPM_PCR_INFO(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_INFO* p, UnpackPtr alloc) {
 	return unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->pcrSelection, alloc) ||
 		unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtRelease) ||
 		unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtCreation);
 }
 
+static
 inline int sizeof_TPM_PCR_INFO(const TPM_PCR_INFO* p) {
 	int rc = 0;
 	rc += sizeof_TPM_PCR_SELECTION(&p->pcrSelection);
 	rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtRelease);
 	rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtCreation);
 	return rc;
 }
 
+static
 inline BYTE* pack_TPM_PCR_INFO_LONG(BYTE* ptr, const TPM_PCR_INFO_LONG* p) {
 	ptr = pack_TPM_STRUCTURE_TAG(ptr, p->tag);
 	ptr = pack_TPM_LOCALITY_SELECTION(ptr, p->localityAtCreation);
 	ptr = pack_TPM_LOCALITY_SELECTION(ptr, p->localityAtRelease);
 	ptr = pack_TPM_PCR_SELECTION(ptr, &p->creationPCRSelection);
 	ptr = pack_TPM_PCR_SELECTION(ptr, &p->releasePCRSelection);
 	ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation);
 	ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease);
 	return ptr;
 }
 
+static
 inline int sizeof_TPM_PCR_INFO_LONG(const TPM_PCR_INFO_LONG* p) {
 	int rc = 0;
 	rc += sizeof_TPM_STRUCTURE_TAG(p->tag);
 	rc += sizeof_TPM_LOCALITY_SELECTION(p->localityAtCreation);
 	rc += sizeof_TPM_LOCALITY_SELECTION(p->localityAtRelease);
 	rc += sizeof_TPM_PCR_SELECTION(&p->creationPCRSelection);
 	rc += sizeof_TPM_PCR_SELECTION(&p->releasePCRSelection);
 	rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtCreation);
 	rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtRelease);
 	return rc;
 }
 
+static
 inline int unpack3_TPM_PCR_INFO_LONG(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_INFO_LONG* p, UnpackPtr alloc) {
 	return unpack3_TPM_STRUCTURE_TAG(ptr, pos, max, &p->tag) ||
 		unpack3_TPM_LOCALITY_SELECTION(ptr, pos, max,
 					       &p->localityAtCreation) ||
 		unpack3_TPM_LOCALITY_SELECTION(ptr, pos, max,
 					       &p->localityAtRelease) ||
 		unpack3_TPM_PCR_SELECTION(ptr, pos, max,
 					  &p->creationPCRSelection, alloc) ||
 		unpack3_TPM_PCR_SELECTION(ptr, pos, max,
 					  &p->releasePCRSelection, alloc) ||
 		unpack3_TPM_COMPOSITE_HASH(ptr, pos, max,
 					  &p->digestAtCreation) ||
 		unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtRelease);
 }
 
+static
 inline BYTE* pack_TPM_PCR_COMPOSITE(BYTE* ptr, const TPM_PCR_COMPOSITE* p) {
 	ptr = pack_TPM_PCR_SELECTION(ptr, &p->select);
 	ptr = pack_UINT32(ptr, p->valueSize);
 	ptr = pack_BUFFER(ptr, (const BYTE*)p->pcrValue, p->valueSize);
 	return ptr;
 }
 
+static
 inline int unpack3_TPM_PCR_COMPOSITE(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_COMPOSITE* p, UnpackPtr alloc) {
 	return unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->select, alloc) ||
 		unpack3_UINT32(ptr, pos, max, &p->valueSize) ||
 		unpack3_PTR(ptr, pos, max, (BYTE**)&p->pcrValue, p->valueSize, alloc);
 }
 
+static
 inline BYTE* pack_TPM_KEY(BYTE* ptr, const TPM_KEY* k) {
 	ptr = pack_TPM_VERSION(ptr, &k->ver);
 	ptr = pack_TPM_KEY_USAGE(ptr, k->keyUsage);
 	ptr = pack_TPM_KEY_FLAGS(ptr, k->keyFlags);
 	ptr = pack_TPM_AUTH_DATA_USAGE(ptr, k->authDataUsage);
 	ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms);
 	ptr = pack_UINT32(ptr, k->PCRInfoSize);
 	if(k->PCRInfoSize) {
 		ptr = pack_TPM_PCR_INFO(ptr, &k->PCRInfo);
 	}
 	ptr = pack_TPM_STORE_PUBKEY(ptr, &k->pubKey);
 	ptr = pack_UINT32(ptr, k->encDataSize);
 	return pack_BUFFER(ptr, k->encData, k->encDataSize);
 }
 
+static
 inline int unpack3_TPM_KEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_KEY* k, UnpackPtr alloc) {
 	int rc = unpack3_TPM_VERSION(ptr, pos, max, &k->ver) ||
 		unpack3_TPM_KEY_USAGE(ptr, pos, max, &k->keyUsage) ||
 		unpack3_TPM_KEY_FLAGS(ptr, pos, max, &k->keyFlags) ||
 		unpack3_TPM_AUTH_DATA_USAGE(ptr, pos, max, &k->authDataUsage) ||
 		unpack3_TPM_KEY_PARMS(ptr, pos, max, &k->algorithmParms, alloc) ||
 		unpack3_UINT32(ptr, pos, max, &k->PCRInfoSize);
 	if (rc) return rc;
 	if(k->PCRInfoSize) {
 		rc = unpack3_TPM_PCR_INFO(ptr, pos, max, &k->PCRInfo, alloc);
 	}
 	if (rc) return rc;
 	return unpack3_TPM_STORE_PUBKEY(ptr, pos, max, &k->pubKey, alloc) ||
 		unpack3_UINT32(ptr, pos, max, &k->encDataSize) ||
 		unpack3_PTR(ptr, pos, max, &k->encData, k->encDataSize, alloc);
 }
 
+static
 inline int sizeof_TPM_KEY(const TPM_KEY* k) {
 	int rc = 0;
 	rc += sizeof_TPM_VERSION(&k->ver);
 	rc += sizeof_TPM_KEY_USAGE(k->keyUsage);
 	rc += sizeof_TPM_KEY_FLAGS(k->keyFlags);
 	rc += sizeof_TPM_AUTH_DATA_USAGE(k->authDataUsage);
 	rc += sizeof_TPM_KEY_PARMS(&k->algorithmParms);
 	rc += sizeof_UINT32(k->PCRInfoSize);
 	if(k->PCRInfoSize) {
 		rc += sizeof_TPM_PCR_INFO(&k->PCRInfo);
 	}
 	rc += sizeof_TPM_STORE_PUBKEY(&k->pubKey);
 	rc += sizeof_UINT32(k->encDataSize);
 	rc += k->encDataSize;
 	return rc;
 }
 
+static
 inline BYTE* pack_TPM_BOUND_DATA(BYTE* ptr, const TPM_BOUND_DATA* b, UINT32 payloadSize) {
 	ptr = pack_TPM_VERSION(ptr, &b->ver);
 	ptr = pack_TPM_PAYLOAD_TYPE(ptr, b->payload);
 	return pack_BUFFER(ptr, b->payloadData, payloadSize);
 }
 
+static
 inline BYTE* unpack_TPM_BOUND_DATA(BYTE* ptr, TPM_BOUND_DATA* b, UINT32 payloadSize, UnpackPtr alloc) {
 	ptr = unpack_TPM_VERSION(ptr, &b->ver);
 	ptr = unpack_TPM_PAYLOAD_TYPE(ptr, &b->payload);
 	return unpack_PTR(ptr, &b->payloadData, payloadSize, alloc);
 }
 
+static
 inline BYTE* pack_TPM_STORED_DATA(BYTE* ptr, const TPM_STORED_DATA* d) {
 	ptr = pack_TPM_VERSION(ptr, &d->ver);
 	ptr = pack_UINT32(ptr, d->sealInfoSize);
 	if(d->sealInfoSize) {
 		ptr = pack_TPM_PCR_INFO(ptr, &d->sealInfo);
 	}
 	ptr = pack_UINT32(ptr, d->encDataSize);
 	ptr = pack_BUFFER(ptr, d->encData, d->encDataSize);
 	return ptr;
 }
 
+static
 inline int sizeof_TPM_STORED_DATA(const TPM_STORED_DATA* d) {
 	int rv = sizeof_TPM_VERSION(&d->ver) + sizeof_UINT32(d->sealInfoSize);
 	if (d->sealInfoSize) {
 		rv += sizeof_TPM_PCR_INFO(&d->sealInfo);
 	}
 	rv += sizeof_UINT32(d->encDataSize);
 	rv += sizeof_BUFFER(d->encData, d->encDataSize);
 	return rv;
 }
 
+static
 inline int unpack3_TPM_STORED_DATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_STORED_DATA* d, UnpackPtr alloc) {
 	int rc = unpack3_TPM_VERSION(ptr, pos, len, &d->ver) ||
 		unpack3_UINT32(ptr, pos, len, &d->sealInfoSize);
 	if (rc)
 		return rc;
 	if (d->sealInfoSize)
 		rc = unpack3_TPM_PCR_INFO(ptr, pos, len, &d->sealInfo, alloc);
 	if (rc)
 		return rc;
 	rc = unpack3_UINT32(ptr, pos, len, &d->encDataSize) ||
 		unpack3_PTR(ptr, pos, len, &d->encData, d->encDataSize, alloc);
 	return rc;
 }
 
+static
 inline BYTE* pack_TPM_STORED_DATA12(BYTE* ptr, const TPM_STORED_DATA12* d) {
 	ptr = pack_TPM_STRUCTURE_TAG(ptr, d->tag);
 	ptr = pack_TPM_ENTITY_TYPE(ptr, d->et);
 	ptr = pack_UINT32(ptr, d->sealInfoLongSize);
 	if(d->sealInfoLongSize) {
 		ptr = pack_TPM_PCR_INFO_LONG(ptr, &d->sealInfoLong);
 	}
 	ptr = pack_UINT32(ptr, d->encDataSize);
 	ptr = pack_BUFFER(ptr, d->encData, d->encDataSize);
 	return ptr;
 }
 
+static
 inline int sizeof_TPM_STORED_DATA12(const TPM_STORED_DATA12* d) {
 	int rv = sizeof_TPM_STRUCTURE_TAG(&d->ver) +
 		 sizeof_TPM_ENTITY_TYPE(&d->et) +
 		 sizeof_UINT32(d->sealInfoLongSize);
 	if (d->sealInfoLongSize) {
 		rv += sizeof_TPM_PCR_INFO_LONG(&d->sealInfoLong);
 	}
 	rv += sizeof_UINT32(d->encDataSize);
 	rv += sizeof_BUFFER(d->encData, d->encDataSize);
 	return rv;
 }
 
+static
 inline int unpack3_TPM_STORED_DATA12(BYTE* ptr, UINT32* pos, UINT32 len, TPM_STORED_DATA12* d, UnpackPtr alloc) {
 	int rc = unpack3_TPM_STRUCTURE_TAG(ptr, pos, len, &d->tag) ||
 		unpack3_TPM_ENTITY_TYPE(ptr, pos, len, &d->et) ||
 		unpack3_UINT32(ptr, pos, len, &d->sealInfoLongSize);
 	if (rc)
 		return rc;
 	if (d->sealInfoLongSize)
 		rc = unpack3_TPM_PCR_INFO_LONG(ptr, pos, len, &d->sealInfoLong,
 					       alloc);
 	if (rc)
 		return rc;
 	rc = unpack3_UINT32(ptr, pos, len, &d->encDataSize) ||
 		unpack3_PTR(ptr, pos, len, &d->encData, d->encDataSize, alloc);
 	return rc;
 }
 
+static
 inline BYTE* pack_TPM_AUTH_SESSION(BYTE* ptr, const TPM_AUTH_SESSION* auth) {
 	ptr = pack_TPM_AUTH_HANDLE(ptr, auth->AuthHandle);
 	ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd);
 	ptr = pack_BOOL(ptr, auth->fContinueAuthSession);
 	ptr = pack_TPM_AUTHDATA(ptr, &auth->HMAC);
 	return ptr;
 }
 
+static
 inline BYTE* unpack_TPM_AUTH_SESSION(BYTE* ptr, TPM_AUTH_SESSION* auth) {
 	ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven);
 	ptr = unpack_BOOL(ptr, &auth->fContinueAuthSession);
 	ptr = unpack_TPM_AUTHDATA(ptr, &auth->HMAC);
 	return ptr;
 }
 
+static
 inline int unpack3_TPM_AUTH_SESSION(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTH_SESSION* auth) {
 	return unpack3_TPM_NONCE(ptr, pos, len, &auth->NonceEven) ||
 		unpack3_BOOL(ptr, pos, len, &auth->fContinueAuthSession) ||
 		unpack3_TPM_AUTHDATA(ptr, pos, len, &auth->HMAC);
 }
 
 
+static
 inline int sizeof_TPM_AUTH_SESSION(const TPM_AUTH_SESSION* auth) {
 	int rv = 0;
 	rv += sizeof_TPM_AUTH_HANDLE(auth->AuthHandle);
 	rv += sizeof_TPM_NONCE(&auth->NonceOdd);
 	rv += sizeof_BOOL(auth->fContinueAuthSession);
 	rv += sizeof_TPM_AUTHDATA(&auth->HMAC);
 	return rv;
 }
 
+static
 inline BYTE* pack_TPM_RQU_HEADER(BYTE* ptr,
 		TPM_TAG tag,
 		UINT32 size,
 		TPM_COMMAND_CODE ord) {
 	ptr = pack_UINT16(ptr, tag);
 	ptr = pack_UINT32(ptr, size);
 	return pack_UINT32(ptr, ord);
 }
 
+static
 inline BYTE* unpack_TPM_RQU_HEADER(BYTE* ptr,
 		TPM_TAG* tag,
 		UINT32* size,
 		TPM_COMMAND_CODE* ord) {
 	ptr = unpack_UINT16(ptr, tag);
 	ptr = unpack_UINT32(ptr, size);
 	ptr = unpack_UINT32(ptr, ord);
 	return ptr;
 }
 
+static
 inline int unpack3_TPM_RQU_HEADER(BYTE* ptr, UINT32* pos, UINT32 max,
 		TPM_TAG* tag, UINT32* size, TPM_COMMAND_CODE* ord) {
 	return
 		unpack3_UINT16(ptr, pos, max, tag) ||
 		unpack3_UINT32(ptr, pos, max, size) ||
 		unpack3_UINT32(ptr, pos, max, ord);
 }
 
 #define pack_TPM_RSP_HEADER(p, t, s, r) pack_TPM_RQU_HEADER(p, t, s, r)
 #define unpack_TPM_RSP_HEADER(p, t, s, r) unpack_TPM_RQU_HEADER(p, t, s, r)
 #define unpack3_TPM_RSP_HEADER(p, l, m, t, s, r) unpack3_TPM_RQU_HEADER(p, l, m, t, s, r)
 
--- a/stubdom/vtpmmgr/tcg.h
+++ b/stubdom/vtpmmgr/tcg.h
@@ -452,24 +452,25 @@ typedef struct TPM_VERSION {
 static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 };
 
 typedef struct TPM_CAP_VERSION_INFO {
    TPM_STRUCTURE_TAG tag;
    TPM_VERSION version;
    UINT16 specLevel;
    BYTE errataRev;
    BYTE tpmVendorID[4];
    UINT16 vendorSpecificSize;
    BYTE* vendorSpecific;
 } TPM_CAP_VERSION_INFO;
 
+static
 inline void free_TPM_CAP_VERSION_INFO(TPM_CAP_VERSION_INFO* v) {
    free(v->vendorSpecific);
    v->vendorSpecific = NULL;
 }
 
 typedef struct TPM_DIGEST {
   BYTE digest[TPM_DIGEST_SIZE];
 } TPM_DIGEST;
 
 typedef TPM_DIGEST TPM_PCRVALUE;
 typedef TPM_DIGEST TPM_COMPOSITE_HASH;
 typedef TPM_DIGEST TPM_DIRVALUE;
@@ -485,226 +486,239 @@ typedef struct TPM_SYMMETRIC_KEY_PARMS {
    UINT32 blockSize;
    UINT32 ivSize;
    BYTE* IV;
 } TPM_SYMMETRIC_KEY_PARMS;
 
 typedef struct TPM_SYMMETRIC_KEY {
    UINT32 algId;
    UINT16 encScheme;
    UINT16 size;
    BYTE* data;
 } TPM_SYMMETRIC_KEY;
 
+static
 inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) {
    free(p->IV);
    p->IV = NULL;
 }
 
 #define TPM_SYMMETRIC_KEY_PARMS_INIT { 0, 0, 0, NULL }
 
 typedef struct TPM_RSA_KEY_PARMS {
   UINT32 keyLength;
   UINT32 numPrimes;
   UINT32 exponentSize;
   BYTE* exponent;
 } TPM_RSA_KEY_PARMS;
 
 #define TPM_RSA_KEY_PARMS_INIT { 0, 0, 0, NULL }
 
+static
 inline void free_TPM_RSA_KEY_PARMS(TPM_RSA_KEY_PARMS* p) {
    free(p->exponent);
    p->exponent = NULL;
 }
 
 typedef struct TPM_KEY_PARMS {
   TPM_ALGORITHM_ID algorithmID;
   TPM_ENC_SCHEME encScheme;
   TPM_SIG_SCHEME sigScheme;
   UINT32 parmSize;
   union {
      TPM_SYMMETRIC_KEY_PARMS sym;
      TPM_RSA_KEY_PARMS rsa;
   } parms;
 } TPM_KEY_PARMS;
 
 #define TPM_KEY_PARMS_INIT { 0, 0, 0, 0 }
 
+static
 inline void free_TPM_KEY_PARMS(TPM_KEY_PARMS* p) {
    if(p->parmSize) {
       switch(p->algorithmID) {
          case TPM_ALG_RSA:
             free_TPM_RSA_KEY_PARMS(&p->parms.rsa);
             break;
          case TPM_ALG_AES128:
          case TPM_ALG_AES192:
          case TPM_ALG_AES256:
             free_TPM_SYMMETRIC_KEY_PARMS(&p->parms.sym);
             break;
       }
    }
 }
 
 typedef struct TPM_STORE_PUBKEY {
   UINT32 keyLength;
   BYTE* key;
 } TPM_STORE_PUBKEY;
 
 #define TPM_STORE_PUBKEY_INIT { 0, NULL }
 
+static
 inline void free_TPM_STORE_PUBKEY(TPM_STORE_PUBKEY* p) {
    free(p->key);
    p->key = NULL;
 }
 
 typedef struct TPM_PUBKEY {
   TPM_KEY_PARMS algorithmParms;
   TPM_STORE_PUBKEY pubKey;
 } TPM_PUBKEY;
 
 #define TPM_PUBKEY_INIT { TPM_KEY_PARMS_INIT, TPM_STORE_PUBKEY_INIT }
 
+static
 inline void free_TPM_PUBKEY(TPM_PUBKEY* k) {
    free_TPM_KEY_PARMS(&k->algorithmParms);
    free_TPM_STORE_PUBKEY(&k->pubKey);
 }
 
 typedef struct TPM_PCR_SELECTION {
    UINT16 sizeOfSelect;
    BYTE* pcrSelect;
 } TPM_PCR_SELECTION;
 
 #define TPM_PCR_SELECTION_INIT { 0, NULL }
 
+static
 inline void free_TPM_PCR_SELECTION(TPM_PCR_SELECTION* p) {
    free(p->pcrSelect);
    p->pcrSelect = NULL;
 }
 
 #define TPM_LOCALITY_SELECTION BYTE
 
 typedef struct TPM_PCR_INFO_LONG {
    TPM_STRUCTURE_TAG tag;
    TPM_LOCALITY_SELECTION localityAtCreation;
    TPM_LOCALITY_SELECTION localityAtRelease;
    TPM_PCR_SELECTION creationPCRSelection;
    TPM_PCR_SELECTION releasePCRSelection;
    TPM_COMPOSITE_HASH digestAtCreation;
    TPM_COMPOSITE_HASH digestAtRelease;
 } TPM_PCR_INFO_LONG;
 
 #define TPM_PCR_INFO_LONG_INIT { 0, 0, 0, TPM_PCR_SELECTION_INIT, \
                                  TPM_PCR_SELECTION_INIT }
 
+static
 inline void free_TPM_PCR_INFO_LONG(TPM_PCR_INFO_LONG* p) {
    free_TPM_PCR_SELECTION(&p->creationPCRSelection);
    free_TPM_PCR_SELECTION(&p->releasePCRSelection);
 }
 
 typedef struct TPM_PCR_INFO {
    TPM_PCR_SELECTION pcrSelection;
    TPM_COMPOSITE_HASH digestAtRelease;
    TPM_COMPOSITE_HASH digestAtCreation;
 } TPM_PCR_INFO;
 
 #define TPM_PCR_INFO_INIT { TPM_PCR_SELECTION_INIT }
 
+static
 inline void free_TPM_PCR_INFO(TPM_PCR_INFO* p) {
    free_TPM_PCR_SELECTION(&p->pcrSelection);
 }
 
 typedef struct TPM_PCR_COMPOSITE {
   TPM_PCR_SELECTION select;
   UINT32 valueSize;
   TPM_PCRVALUE* pcrValue;
 } TPM_PCR_COMPOSITE;
 
 #define TPM_PCR_COMPOSITE_INIT { TPM_PCR_SELECTION_INIT, 0, NULL }
 
+static
 inline void free_TPM_PCR_COMPOSITE(TPM_PCR_COMPOSITE* p) {
    free_TPM_PCR_SELECTION(&p->select);
    free(p->pcrValue);
    p->pcrValue = NULL;
 }
 
 typedef struct TPM_KEY {
   TPM_VERSION         ver;
   TPM_KEY_USAGE       keyUsage;
   TPM_KEY_FLAGS       keyFlags;
   TPM_AUTH_DATA_USAGE authDataUsage;
   TPM_KEY_PARMS       algorithmParms;
   UINT32              PCRInfoSize;
   TPM_PCR_INFO        PCRInfo;
   TPM_STORE_PUBKEY    pubKey;
   UINT32              encDataSize;
   BYTE*               encData;
 } TPM_KEY;
 
 #define TPM_KEY_INIT { .algorithmParms = TPM_KEY_PARMS_INIT,\
    .PCRInfoSize = 0, .PCRInfo = TPM_PCR_INFO_INIT, \
    .pubKey = TPM_STORE_PUBKEY_INIT, \
    .encDataSize = 0, .encData = NULL }
 
+static
 inline void free_TPM_KEY(TPM_KEY* k) {
    if(k->PCRInfoSize) {
       free_TPM_PCR_INFO(&k->PCRInfo);
    }
    free_TPM_STORE_PUBKEY(&k->pubKey);
    free(k->encData);
    k->encData = NULL;
 }
 
 typedef struct TPM_BOUND_DATA {
   TPM_VERSION ver;
   TPM_PAYLOAD_TYPE payload;
   BYTE* payloadData;
 } TPM_BOUND_DATA;
 
 #define TPM_BOUND_DATA_INIT { .payloadData = NULL }
 
+static
 inline void free_TPM_BOUND_DATA(TPM_BOUND_DATA* d) {
    free(d->payloadData);
    d->payloadData = NULL;
 }
 
 typedef struct TPM_STORED_DATA {
   TPM_VERSION ver;
   UINT32 sealInfoSize;
   TPM_PCR_INFO sealInfo;
   UINT32 encDataSize;
   BYTE* encData;
 } TPM_STORED_DATA;
 
 #define TPM_STORED_DATA_INIT { .sealInfoSize = 0, sealInfo = TPM_PCR_INFO_INIT,\
    .encDataSize = 0, .encData = NULL }
 
+static
 inline void free_TPM_STORED_DATA(TPM_STORED_DATA* d) {
    if(d->sealInfoSize) {
       free_TPM_PCR_INFO(&d->sealInfo);
    }
    free(d->encData);
    d->encData = NULL;
 }
 
 typedef struct TPM_STORED_DATA12 {
   TPM_STRUCTURE_TAG tag;
   TPM_ENTITY_TYPE et;
   UINT32 sealInfoLongSize;
   TPM_PCR_INFO_LONG sealInfoLong;
   UINT32 encDataSize;
   BYTE* encData;
 } TPM_STORED_DATA12;
 
 #define TPM_STORED_DATA12_INIT { .sealInfoLongSize = 0, \
    sealInfoLong = TPM_PCR_INFO_INIT, .encDataSize = 0, .encData = NULL }
 
+static
 inline void free_TPM_STORED_DATA12(TPM_STORED_DATA12* d) {
    if(d->sealInfoLongSize) {
       free_TPM_PCR_INFO_LONG(&d->sealInfoLong);
    }
    free(d->encData);
    d->encData = NULL;
 }
 
 typedef struct TPM_AUTH_SESSION {
   TPM_AUTHHANDLE  AuthHandle;
   TPM_NONCE   NonceOdd;   // system
   TPM_NONCE   NonceEven;   // TPM
--- a/stubdom/vtpmmgr/tpm2_marshal.h
+++ b/stubdom/vtpmmgr/tpm2_marshal.h
@@ -43,47 +43,52 @@
 #define TPM2_MARSHAL_H
 
 #include <stdlib.h>
 #include <mini-os/byteorder.h>
 #include <mini-os/endian.h>
 #include "tcg.h"
 #include "tpm2_types.h"
 #include <assert.h>
 
 #define pack_TPM_BUFFER(ptr, buf, size) pack_BUFFER(ptr, buf, size)
 #define unpack_TPM_BUFFER(ptr, buf, size) unpack_BUFFER(ptr, buf, size)
 
+static
 inline BYTE* pack_BYTE_ARRAY(BYTE* ptr, const BYTE* array, UINT32 size)
 {
     int i;
     for (i = 0; i < size; i++)
          ptr = pack_BYTE(ptr, array[i]);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMA_SESSION(BYTE* ptr, const TPMA_SESSION *attr)
 {
     return pack_BYTE(ptr, (BYTE)(*attr));
 }
 
+static
 inline BYTE* unpack_TPMA_SESSION(BYTE* ptr, TPMA_SESSION *attr)
 {
     return unpack_BYTE(ptr, (BYTE *)attr);
 }
 
+static
 inline BYTE* pack_TPMI_ALG_HASH(BYTE* ptr, const TPMI_ALG_HASH *hash)
 {
     return pack_UINT16(ptr, *hash);
 }
 
+static
 inline BYTE* unpack_TPMI_ALG_HASH(BYTE *ptr, TPMI_ALG_HASH *hash)
 {
     return unpack_UINT16(ptr, hash);
 }
 
 #define pack_TPMA_OBJECT(ptr, t)                pack_UINT32(ptr, (UINT32)(*t))
 #define unpack_TPMA_OBJECT(ptr, t)              unpack_UINT32(ptr, (UINT32 *)(t))
 #define pack_TPM_RH(ptr, t)                     pack_UINT32(ptr, (UINT32)(*t))
 #define unpack_TPM_RH(ptr, t)                   unpack_UINT32(ptr, (UINT32 *)(t))
 #define pack_TPMA_LOCALITY(ptr, locality)       pack_BYTE(ptr, (BYTE)*locality)
 #define unpack_TPMA_LOCALITY(ptr, locality)     unpack_BYTE(ptr, (BYTE *)locality)
 #define pack_TPM_ST(ptr, tag)                   pack_UINT16(ptr, *tag)
@@ -116,558 +121,611 @@ inline BYTE* unpack_TPMI_ALG_HASH(BYTE *ptr, TPMI_ALG_HASH *hash)
 #define unpack_TPMI_DH_OBJECT(PTR, O)           unpack_TPM2_HANDLE(ptr, o)
 #define pack_TPMI_RH_HIERACHY(ptr, h)           pack_TPM2_HANDLE(ptr, h)
 #define unpack_TPMI_RH_HIERACHY(ptr, h)         unpack_TPM2_HANDLE(ptr, h)
 #define pack_TPMI_RH_PLATFORM(ptr, p)           pack_TPM2_HANDLE(ptr, p)
 #define unpack_TPMI_RH_PLATFORM(ptr, p)         unpack_TPM2_HANDLE(ptr, p)
 #define pack_TPMI_RH_OWNER(ptr, o)              pack_TPM2_HANDLE(ptr, o)
 #define unpack_TPMI_RH_OWNER(ptr, o)            unpack_TPM2_HANDLE(ptr, o)
 #define pack_TPMI_RH_ENDORSEMENT(ptr, e)        pack_TPM2_HANDLE(ptr, e)
 #define unpack_TPMI_RH_ENDORSEMENT(ptr, e)      unpack_TPM2_HANDLE(ptr, e)
 #define pack_TPMI_RH_LOCKOUT(ptr, l)            pack_TPM2_HANDLE(ptr, l)
 #define unpack_TPMI_RH_LOCKOUT(ptr, l)          unpack_TPM2_HANDLE(ptr, l)
 
+static
 inline BYTE* pack_TPM2B_DIGEST(BYTE* ptr, const TPM2B_DIGEST *digest)
 {
     ptr = pack_UINT16(ptr, digest->size);
     ptr = pack_BUFFER(ptr, digest->buffer, digest->size);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPM2B_DIGEST(BYTE* ptr, TPM2B_DIGEST *digest)
 {
     ptr = unpack_UINT16(ptr, &digest->size);
     ptr = unpack_BUFFER(ptr, digest->buffer, digest->size);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMT_TK_CREATION(BYTE* ptr,const TPMT_TK_CREATION *ticket )
 {
     ptr = pack_TPM_ST(ptr , &ticket->tag);
     ptr = pack_TPMI_RH_HIERACHY(ptr , &ticket->hierarchy);
     ptr = pack_TPM2B_DIGEST(ptr, &ticket->digest);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMT_TK_CREATION(BYTE* ptr, TPMT_TK_CREATION *ticket )
 {
     ptr = unpack_TPM_ST(ptr, &ticket->tag);
     ptr = unpack_TPMI_RH_HIERACHY(ptr, &ticket->hierarchy);
     ptr = unpack_TPM2B_DIGEST(ptr, &ticket->digest);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPM2B_NAME(BYTE* ptr,const TPM2B_NAME *name )
 {
     ptr = pack_UINT16(ptr, name->size);
     ptr = pack_TPM_BUFFER(ptr, name->name, name->size);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPM2B_NAME(BYTE* ptr, TPM2B_NAME *name)
 {
     ptr = unpack_UINT16(ptr, &name->size);
     ptr = unpack_TPM_BUFFER(ptr, name->name, name->size);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPM2B_NONCE(BYTE* ptr, const TPM2B_NONCE *nonce)
 {
     return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)nonce);
 }
 
 #define unpack_TPM2B_NONCE(ptr, nonce)  unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)nonce)
 
+static
 inline BYTE* pack_TPM2B_AUTH(BYTE* ptr, const TPM2B_AUTH *auth)
 {
     return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)auth);
 }
 
 #define unpack_TPM2B_AUTH(ptr, auth)    unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)auth)
 
+static
 inline BYTE* pack_TPM2B_DATA(BYTE* ptr, const TPM2B_DATA *data)
 {
     return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)data);
 }
 
 #define unpack_TPM2B_DATA(ptr, data)    unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)data)
 
+static
 inline BYTE* pack_TPM2B_SENSITIVE_DATA(BYTE* ptr, const TPM2B_SENSITIVE_DATA *data)
 {
     return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)data);
 }
 
 #define unpack_TPM2B_SENSITIVE_DATA(ptr, data)  unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)data)
 
+static
 inline BYTE* pack_TPM2B_PUBLIC_KEY_RSA(BYTE* ptr, const TPM2B_PUBLIC_KEY_RSA *rsa)
 {
     return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)rsa);
 }
 
 #define unpack_TPM2B_PUBLIC_KEY_RSA(ptr, rsa)   unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)rsa)
 
+static
 inline BYTE* pack_TPM2B_PRIVATE(BYTE* ptr, const TPM2B_PRIVATE *Private)
 {
     ptr = pack_UINT16(ptr, Private->size);
     ptr = pack_TPM_BUFFER(ptr, Private->buffer, Private->size);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPM2B_PRIVATE(BYTE* ptr, TPM2B_PRIVATE *Private)
 {
     ptr = unpack_UINT16(ptr, &Private->size);
     ptr = unpack_BUFFER(ptr, Private->buffer, Private->size);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMS_PCR_SELECTION_ARRAY(BYTE* ptr, const TPMS_PCR_SELECTION *sel, UINT32 count)
 {
     int i;
     for (i = 0; i < count; i++) {
         ptr = pack_TPMI_ALG_HASH(ptr, &sel[i].hash);
         ptr = pack_BYTE(ptr, sel[i].sizeofSelect);
         ptr = pack_BUFFER(ptr, sel[i].pcrSelect, sel[i].sizeofSelect);
     }
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMS_PCR_SELECTION_ARRAY(BYTE* ptr, TPMS_PCR_SELECTION *sel, UINT32 count)
 {
     int i;
     for (i = 0; i < count; i++) {
         ptr = unpack_TPMI_ALG_HASH(ptr, &sel[i].hash);
         ptr = unpack_BYTE(ptr, &sel[i].sizeofSelect);
         ptr = unpack_BUFFER(ptr, sel[i].pcrSelect, sel[i].sizeofSelect);
     }
     return ptr;
 }
 
+static
 inline BYTE* pack_TPML_PCR_SELECTION(BYTE* ptr, const TPML_PCR_SELECTION *sel)
 {
     ptr = pack_UINT32(ptr, sel->count);
     ptr = pack_TPMS_PCR_SELECTION_ARRAY(ptr, sel->pcrSelections, sel->count);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPML_PCR_SELECTION(BYTE* ptr, TPML_PCR_SELECTION *sel)
 {
     ptr = unpack_UINT32(ptr, &sel->count);
     ptr = unpack_TPMS_PCR_SELECTION_ARRAY(ptr, sel->pcrSelections, sel->count);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPML_DIGEST(BYTE* ptr,TPML_DIGEST *digest)
 {
     int i;
     ptr = unpack_UINT32(ptr, &digest->count);
     for (i=0;i<digest->count;i++)
     {
         ptr = unpack_TPM2B_DIGEST(ptr, &digest->digests[i]);
     }
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMS_CREATION_DATA(BYTE* ptr,const TPMS_CREATION_DATA *data)
 {
     ptr = pack_TPML_PCR_SELECTION(ptr, &data->pcrSelect);
     ptr = pack_TPM2B_DIGEST(ptr, &data->pcrDigest);
     ptr = pack_TPMA_LOCALITY(ptr, &data->locality);
     ptr = pack_TPM_ALG_ID(ptr, &data->parentNameAlg);
     ptr = pack_TPM2B_NAME(ptr, &data->parentQualifiedName);
     ptr = pack_TPM2B_DATA(ptr, &data->outsideInfo);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMS_CREATION_DATA(BYTE* ptr, TPMS_CREATION_DATA *data)
 {
     ptr = unpack_TPML_PCR_SELECTION(ptr, &data->pcrSelect);
     ptr = unpack_TPM2B_DIGEST(ptr, &data->pcrDigest);
     ptr = unpack_TPMA_LOCALITY(ptr, &data->locality);
     ptr = unpack_TPM_ALG_ID(ptr, &data->parentNameAlg);
     ptr = unpack_TPM2B_NAME(ptr, &data->parentName);
     ptr = unpack_TPM2B_NAME(ptr, &data->parentQualifiedName);
     ptr = unpack_TPM2B_DATA(ptr, &data->outsideInfo);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPM2B_CREATION_DATA(BYTE* ptr, const TPM2B_CREATION_DATA *data )
 {
     ptr = pack_UINT16(ptr, data->size);
     ptr = pack_TPMS_CREATION_DATA(ptr, &data->creationData);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPM2B_CREATION_DATA(BYTE* ptr, TPM2B_CREATION_DATA * data)
 {
     ptr = unpack_UINT16(ptr, &data->size);
     ptr = unpack_TPMS_CREATION_DATA(ptr, &data->creationData);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMS_SENSITIVE_CREATE(BYTE* ptr, const TPMS_SENSITIVE_CREATE *create)
 {
     ptr = pack_TPM2B_AUTH(ptr, &create->userAuth);
     ptr = pack_TPM2B_SENSITIVE_DATA(ptr, &create->data);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPM2B_SENSITIVE_CREATE(BYTE* ptr, const TPM2B_SENSITIVE_CREATE *create)
 {
     BYTE* sizePtr = ptr;
     ptr += 2;
     ptr = pack_TPMS_SENSITIVE_CREATE(ptr, &create->sensitive);
     pack_UINT16(sizePtr, (UINT16)(ptr - sizePtr - 2));
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMU_SYM_MODE(BYTE* ptr, const TPMU_SYM_MODE *p,
                                 const TPMI_ALG_SYM_OBJECT *sel)
 {
     switch(*sel) {
     case TPM2_ALG_AES:
         ptr = pack_TPMI_ALG_SYM_MODE(ptr, &p->aes);
         break;
     case TPM2_ALG_SM4:
         assert(false);
         break;
     case TPM2_ALG_NULL:
         case TPM2_ALG_XOR:
         break;
     default:
         ptr = pack_TPMI_ALG_SYM_MODE(ptr, &p->sym);
     }
     return ptr;
 }
+static
 inline BYTE* unpack_TPMU_SYM_MODE(BYTE* ptr, TPMU_SYM_MODE *p,
                                   const TPMI_ALG_SYM_OBJECT *sel)
 {
     switch(*sel) {
     case TPM2_ALG_AES:
         ptr = unpack_TPMI_ALG_SYM_MODE(ptr, &p->aes);
         break;
     case TPM2_ALG_SM4:
         assert(false);
         break;
     case TPM2_ALG_NULL:
     case TPM2_ALG_XOR:
         break;
     default:
         ptr = unpack_TPMI_ALG_SYM_MODE(ptr, &p->sym);
     }
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMU_SYM_KEY_BITS(BYTE* ptr, const TPMU_SYM_KEY_BITS *p,
                                     const TPMI_ALG_SYM_OBJECT *sel)
 {
     switch(*sel) {
     case TPM2_ALG_AES:
         ptr = pack_TPMI_AES_KEY_BITS(ptr, &p->aes);
         break;
     case TPM2_ALG_SM4:
         assert(false);
         break;
     case TPM2_ALG_XOR:
         assert(false);
         break;
     case TPM2_ALG_NULL:
         break;
     default:
         ptr = pack_TPM_KEY_BITS(ptr, &p->sym);
     }
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMU_SYM_KEY_BITS(BYTE* ptr, TPMU_SYM_KEY_BITS *p,
                                       const TPMI_ALG_SYM_OBJECT *sel)
 {
     switch(*sel) {
     case TPM2_ALG_AES:
         ptr = unpack_TPMI_AES_KEY_BITS(ptr, &p->aes);
         break;
     case TPM2_ALG_SM4:
         assert(false);
         break;
     case TPM2_ALG_XOR:
         assert(false);
         break;
     case TPM2_ALG_NULL:
         break;
     default:
         ptr = unpack_TPM_KEY_BITS(ptr, &p->sym);
     }
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMT_SYM_DEF_OBJECT(BYTE* ptr, const TPMT_SYM_DEF_OBJECT *p)
 {
     ptr = pack_TPMI_ALG_SYM_OBJECT(ptr, &p->algorithm);
     ptr = pack_TPMU_SYM_KEY_BITS(ptr, &p->keyBits, &p->algorithm);
     ptr = pack_TPMU_SYM_MODE(ptr, &p->mode, &p->algorithm);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMT_SYM_DEF_OBJECT(BYTE *ptr, TPMT_SYM_DEF_OBJECT *p)
 {
     ptr = unpack_TPMI_ALG_SYM_OBJECT(ptr, &p->algorithm);
     ptr = unpack_TPMU_SYM_KEY_BITS(ptr, &p->keyBits, &p->algorithm);
     ptr = unpack_TPMU_SYM_MODE(ptr, &p->mode, &p->algorithm);
     return ptr;
 }
 
 #define pack_TPMS_SCHEME_OAEP(p, t)     pack_TPMI_ALG_HASH(p, &((t)->hashAlg))
 #define unpack_TPMS_SCHEME_OAEP(p, t)   unpack_TPMI_ALG_HASH(p, &((t)->hashAlg))
 
+static
 inline BYTE* pack_TPMU_ASYM_SCHEME(BYTE *ptr, const TPMU_ASYM_SCHEME *p,
                                    const TPMI_ALG_RSA_SCHEME *s)
 {
     switch(*s) {
 #ifdef TPM2_ALG_RSASSA
     case TPM2_ALG_RSASSA:
         assert(false || "TPM2_ALG_RSASSA");
         break;
 #endif
 #ifdef TPM2_ALG_OAEP
     case TPM2_ALG_OAEP:
         ptr = pack_TPMS_SCHEME_OAEP(ptr, &p->oaep);
         break;
 #endif
     case TPM2_ALG_NULL:
         break;
     default:
         assert(false || "DEFAULT");
     }
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMU_ASYM_SCHEME(BYTE *ptr, TPMU_ASYM_SCHEME *p,
                                      const TPMI_ALG_RSA_SCHEME *s)
 {
     switch(*s) {
     #ifdef TPM2_ALG_RSASSA
     case TPM2_ALG_RSASSA:
         printf("not support TPM_ALG_RSASSA\n");
         assert(false);
         break;
     #endif
     #ifdef TPM2_ALG_OAEP
     case TPM2_ALG_OAEP:
         ptr = unpack_TPMS_SCHEME_OAEP(ptr, &p->oaep);
         break;
     #endif
     case TPM2_ALG_NULL:
         break;
     default:
         printf("default TPMI_ALG_RSA_SCHEME 0x%X\n", (UINT32)*s);
         ptr = unpack_TPMI_ALG_HASH(ptr, &p->anySig.hashAlg);
     }
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMT_RSA_SCHEME(BYTE* ptr, const TPMT_RSA_SCHEME *p)
 {
     ptr = pack_TPMI_ALG_RSA_SCHEME(ptr, &p->scheme);
     ptr = pack_TPMU_ASYM_SCHEME(ptr, &p->details, &p->scheme);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMT_RSA_SCHEME(BYTE* ptr, TPMT_RSA_SCHEME *p)
 {
     ptr = unpack_TPMI_ALG_RSA_SCHEME(ptr, &p->scheme);
     ptr = unpack_TPMU_ASYM_SCHEME(ptr, &p->details, &p->scheme);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMT_RSA_DECRYPT(BYTE* ptr, const TPMT_RSA_DECRYPT *p)
 {
     ptr = pack_TPMI_ALG_RSA_SCHEME(ptr, &p->scheme);
     ptr = pack_TPMU_ASYM_SCHEME(ptr, &p->details, &p->scheme);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMS_RSA_PARMS(BYTE* ptr, const TPMS_RSA_PARMS *p)
 {
     ptr = pack_TPMT_SYM_DEF_OBJECT(ptr, &p->symmetric);
     ptr = pack_TPMT_RSA_SCHEME(ptr, &p->scheme);
     ptr = pack_TPMI_RSA_KEY_BITS(ptr, &p->keyBits);
     ptr = pack_UINT32(ptr, p->exponent);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMS_RSA_PARMS(BYTE *ptr, TPMS_RSA_PARMS *p)
 {
     ptr = unpack_TPMT_SYM_DEF_OBJECT(ptr, &p->symmetric);
     ptr = unpack_TPMT_RSA_SCHEME(ptr, &p->scheme);
     ptr = unpack_TPMI_RSA_KEY_BITS(ptr, &p->keyBits);
     ptr = unpack_UINT32(ptr, &p->exponent);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMU_PUBLIC_PARMS(BYTE* ptr, const TPMU_PUBLIC_PARMS *param,
                                     const TPMI_ALG_PUBLIC *selector)
 {
     switch(*selector) {
     case TPM2_ALG_KEYEDHASH:
         assert(false);
     case TPM2_ALG_SYMCIPHER:
         assert(false);
     case TPM2_ALG_RSA:
         return pack_TPMS_RSA_PARMS(ptr, &param->rsaDetail);
     case TPM2_ALG_ECC:
         assert(false);
     }
     assert(false);
     return NULL;
 }
 
+static
 inline BYTE* unpack_TPMU_PUBLIC_PARMS(BYTE* ptr, TPMU_PUBLIC_PARMS *param,
                                       const TPMI_ALG_PUBLIC *selector)
 {
     switch(*selector) {
     case TPM2_ALG_KEYEDHASH:
         assert(false);
     case TPM2_ALG_SYMCIPHER:
         assert(false);
     case TPM2_ALG_RSA:
         return unpack_TPMS_RSA_PARMS(ptr, &param->rsaDetail);
     case TPM2_ALG_ECC:
         assert(false);
     }
     assert(false);
     return NULL;
 }
 
+static
 inline BYTE* pack_TPMS_ECC_POINT(BYTE* ptr, const TPMS_ECC_POINT *point)
 {
     assert(false);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMS_ECC_POINT(BYTE* ptr, TPMS_ECC_POINT *point)
 {
     assert(false);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMU_PUBLIC_ID(BYTE* ptr, const TPMU_PUBLIC_ID *id,
                                  const TPMI_ALG_PUBLIC *selector)
 {
     switch (*selector) {
     case TPM2_ALG_KEYEDHASH:
         return pack_TPM2B_DIGEST(ptr, &id->keyedHash);
     case TPM2_ALG_SYMCIPHER:
         return pack_TPM2B_DIGEST(ptr, &id->sym);
     case TPM2_ALG_RSA:
         return pack_TPM2B_PUBLIC_KEY_RSA(ptr, &id->rsa);
     case TPM2_ALG_ECC:
         return pack_TPMS_ECC_POINT(ptr, &id->ecc);
     }
     assert(false);
     return NULL;
 }
 
+static
 inline BYTE* unpack_TPMU_PUBLIC_ID(BYTE* ptr, TPMU_PUBLIC_ID *id, TPMI_ALG_PUBLIC *selector)
 {
     switch (*selector) {
     case TPM2_ALG_KEYEDHASH:
         return unpack_TPM2B_DIGEST(ptr, &id->keyedHash);
     case TPM2_ALG_SYMCIPHER:
         return unpack_TPM2B_DIGEST(ptr, &id->sym);
     case TPM2_ALG_RSA:
         return unpack_TPM2B_PUBLIC_KEY_RSA(ptr, &id->rsa);
     case TPM2_ALG_ECC:
         return unpack_TPMS_ECC_POINT(ptr, &id->ecc);
     }
     assert(false);
     return NULL;
 }
 
+static
 inline BYTE* pack_TPMT_PUBLIC(BYTE* ptr, const TPMT_PUBLIC *public)
 {
     ptr = pack_TPMI_ALG_PUBLIC(ptr, &public->type);
     ptr = pack_TPMI_ALG_HASH(ptr, &public->nameAlg);
     ptr = pack_TPMA_OBJECT(ptr, &public->objectAttributes);
     ptr = pack_TPM2B_DIGEST(ptr, &public->authPolicy);
     ptr = pack_TPMU_PUBLIC_PARMS(ptr, &public->parameters, &public->type);
     ptr = pack_TPMU_PUBLIC_ID(ptr, &public->unique, &public->type);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPMT_PUBLIC(BYTE* ptr, TPMT_PUBLIC *public)
 {
     ptr = unpack_TPMI_ALG_PUBLIC(ptr, &public->type);
     ptr = unpack_TPMI_ALG_HASH(ptr, &public->nameAlg);
     ptr = unpack_TPMA_OBJECT(ptr, &public->objectAttributes);
     ptr = unpack_TPM2B_DIGEST(ptr, &public->authPolicy);
     ptr = unpack_TPMU_PUBLIC_PARMS(ptr, &public->parameters, &public->type);
     ptr = unpack_TPMU_PUBLIC_ID(ptr, &public->unique, &public->type);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPM2B_PUBLIC(BYTE* ptr, const TPM2B_PUBLIC *public)
 {
     BYTE *sizePtr = ptr;
     ptr += 2;
     ptr = pack_TPMT_PUBLIC(ptr, &public->publicArea);
     pack_UINT16(sizePtr, (UINT16)(ptr - sizePtr - 2));
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPM2B_PUBLIC(BYTE* ptr, TPM2B_PUBLIC *public)
 {
     ptr = unpack_UINT16(ptr, &public->size);
     ptr = unpack_TPMT_PUBLIC(ptr, &public->publicArea);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMS_PCR_SELECTION(BYTE* ptr, const TPMS_PCR_SELECTION *selection)
 {
     ptr = pack_TPMI_ALG_HASH(ptr, &selection->hash);
     ptr = pack_BYTE(ptr, selection->sizeofSelect);
     ptr = pack_BYTE_ARRAY(ptr, selection->pcrSelect, selection->sizeofSelect);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPMS_PCR_SELECTION_Array(BYTE* ptr, const TPMS_PCR_SELECTION *selections,
                                            const UINT32 cnt)
 {
     int i;
     for (i = 0; i < cnt; i++)
         ptr = pack_TPMS_PCR_SELECTION(ptr, selections + i);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPM_AuthArea(BYTE* ptr, const TPM_AuthArea *auth)
 {
     BYTE* sizePtr = ptr;
     ptr += sizeof(UINT32);
     ptr = pack_TPM_RH(ptr, &auth->sessionHandle);
     ptr = pack_TPM2B_NONCE(ptr, &auth->nonce);
     ptr = pack_TPMA_SESSION(ptr, &auth->sessionAttributes);
     ptr = pack_TPM2B_AUTH(ptr, &auth->auth);
     pack_UINT32(sizePtr, ptr - sizePtr - sizeof(UINT32));
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPM_AuthArea(BYTE* ptr, TPM_AuthArea *auth)
 {
     ptr = unpack_UINT32(ptr, &auth->size);
     ptr = unpack_TPM_RH(ptr, &auth->sessionHandle);
     ptr = unpack_TPM2B_NONCE(ptr, &auth->nonce);
     ptr = unpack_TPMA_SESSION(ptr, &auth->sessionAttributes);
     ptr = unpack_TPM2B_AUTH(ptr, &auth->auth);
     return ptr;
 }
 
+static
 inline BYTE* pack_TPM2_RSA_KEY(BYTE* ptr, const TPM2_RSA_KEY *key)
 {
     ptr = pack_TPM2B_PRIVATE(ptr, &key->Private);
     ptr = pack_TPM2B_PUBLIC(ptr, &key->Public);
     return ptr;
 }
 
+static
 inline BYTE* unpack_TPM2_RSA_KEY(BYTE* ptr, TPM2_RSA_KEY *key)
 {
     ptr = unpack_TPM2B_PRIVATE(ptr, &key->Private);
     ptr = unpack_TPM2B_PUBLIC(ptr, &key->Public);
     return ptr;
 }
 #endif
--- a/stubdom/vtpmmgr/tpmrsa.h
+++ b/stubdom/vtpmmgr/tpmrsa.h
@@ -53,17 +53,18 @@ void tpmrsa_set_pubkey(tpmrsa_context* ctx,
 /* Check an RSA signature */
 TPM_RESULT tpmrsa_sigcheck(tpmrsa_context *ctx, const unsigned char *input, const unsigned char *sha1);
 
 /* Do rsa public crypto */
 TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx,
       int (*f_rng)(void *, unsigned char *, size_t),
       void *p_rng,
       size_t ilen,
       const unsigned char *input,
       unsigned char *output );
 
 /* free tpmrsa key */
+static
 inline void tpmrsa_free( tpmrsa_context *ctx ) {
    mpi_free( &ctx->RN ); mpi_free( &ctx->E  ); mpi_free( &ctx->N  );
 }
 
 #endif /* tpmrsa.h */

Places

File xen.c4ba064d53ef89cc06466349c1e987d8e91020b3.patch of Package xen (Revision 4be291ecfb509bfdf12b658489a12c04)

Places