Adding upstream version 0.9.2.upstream/0.9.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1679 insertions, 0 deletions

diff --git a/src/tpm2/NVDynamic.c b/src/tpm2/NVDynamic.c
new file mode 100644
index 0000000..c7c6a3b
--- /dev/null
+++ b/src/tpm2/NVDynamic.c
@@ -0,0 +1,1679 @@
+/********************************************************************************/
+/*										*/
+/*		Dynamic space for user defined NV      				*/
+/*			     Written by Ken Goldman				*/
+/*		       IBM Thomas J. Watson Research Center			*/
+/*            $Id: NVDynamic.c 1658 2021-01-22 23:14:01Z kgoldman $		*/
+/*										*/
+/*  Licenses and Notices							*/
+/*										*/
+/*  1. Copyright Licenses:							*/
+/*										*/
+/*  - Trusted Computing Group (TCG) grants to the user of the source code in	*/
+/*    this specification (the "Source Code") a worldwide, irrevocable, 		*/
+/*    nonexclusive, royalty free, copyright license to reproduce, create 	*/
+/*    derivative works, distribute, display and perform the Source Code and	*/
+/*    derivative works thereof, and to grant others the rights granted herein.	*/
+/*										*/
+/*  - The TCG grants to the user of the other parts of the specification 	*/
+/*    (other than the Source Code) the rights to reproduce, distribute, 	*/
+/*    display, and perform the specification solely for the purpose of 		*/
+/*    developing products based on such documents.				*/
+/*										*/
+/*  2. Source Code Distribution Conditions:					*/
+/*										*/
+/*  - Redistributions of Source Code must retain the above copyright licenses, 	*/
+/*    this list of conditions and the following disclaimers.			*/
+/*										*/
+/*  - Redistributions in binary form must reproduce the above copyright 	*/
+/*    licenses, this list of conditions	and the following disclaimers in the 	*/
+/*    documentation and/or other materials provided with the distribution.	*/
+/*										*/
+/*  3. Disclaimers:								*/
+/*										*/
+/*  - THE COPYRIGHT LICENSES SET FORTH ABOVE DO NOT REPRESENT ANY FORM OF	*/
+/*  LICENSE OR WAIVER, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, WITH	*/
+/*  RESPECT TO PATENT RIGHTS HELD BY TCG MEMBERS (OR OTHER THIRD PARTIES)	*/
+/*  THAT MAY BE NECESSARY TO IMPLEMENT THIS SPECIFICATION OR OTHERWISE.		*/
+/*  Contact TCG Administration (admin@trustedcomputinggroup.org) for 		*/
+/*  information on specification licensing rights available through TCG 	*/
+/*  membership agreements.							*/
+/*										*/
+/*  - THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED 	*/
+/*    WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY OR 	*/
+/*    FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OR 		*/
+/*    NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS, OR ANY WARRANTY 		*/
+/*    OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE.		*/
+/*										*/
+/*  - Without limitation, TCG and its members and licensors disclaim all 	*/
+/*    liability, including liability for infringement of any proprietary 	*/
+/*    rights, relating to use of information in this specification and to the	*/
+/*    implementation of this specification, and TCG disclaims all liability for	*/
+/*    cost of procurement of substitute goods or services, lost profits, loss 	*/
+/*    of use, loss of data or any incidental, consequential, direct, indirect, 	*/
+/*    or special damages, whether under contract, tort, warranty or otherwise, 	*/
+/*    arising in any way out of use or reliance upon this specification or any 	*/
+/*    information herein.							*/
+/*										*/
+/*  (c) Copyright IBM Corp. and others, 2016 - 2021				*/
+/*										*/
+/********************************************************************************/
+
+/* 8.4 NVDynamic.c */
+/* 8.4.2 Includes, Defines and Data Definitions */
+#define NV_C
+#include "Tpm.h"
+
+/* 8.4.3 Local Functions */
+/* 8.4.3.1 NvNext() */
+/* This function provides a method to traverse every data entry in NV dynamic area. */
+/* To begin with, parameter iter should be initialized to NV_REF_INIT indicating the first element.
+   Every time this function is called, the value in iter would be adjusted pointing to the next
+   element in traversal.  If there is no next element, iter value would be 0. This function returns
+   the address of the 'data entry' pointed by the iter.  If there is no more elements in the set, a 0
+   value is returned indicating the end of traversal. */
+static NV_REF
+NvNext(
+       NV_REF          *iter,          // IN/OUT: the list iterator
+       TPM_HANDLE      *handle         // OUT: the handle of the next item.
+       )
+{
+    NV_REF               currentAddr;
+    NV_ENTRY_HEADER      header;
+    //
+    // If iterator is at the beginning of list
+    if(*iter == NV_REF_INIT)
+	{
+	    // Initialize iterator
+	    *iter = NV_USER_DYNAMIC;
+	}
+    // Step over the size field and point to the handle
+    currentAddr = *iter + sizeof(UINT32);
+    // read the header of the next entry
+    NvRead(&header, *iter, sizeof(NV_ENTRY_HEADER));
+    // if the size field is zero, then we have hit the end of the list
+    if(header.size == 0)
+	// leave the *iter pointing at the end of the list
+	return 0;
+    // advance the header by the size of the entry
+    *iter += header.size;
+    if(handle != NULL)
+	*handle = header.handle;
+    return currentAddr;
+}
+/* 8.4.3.2 NvNextByType() */
+/* This function returns a reference to the next NV entry of the desired type */
+/* Return Values Meaning */
+/* 0 end of list */
+/* != 0 the next entry of the indicated type */
+static NV_REF
+NvNextByType(
+	     TPM_HANDLE      *handle,        // OUT: the handle of the found type or 0
+	     NV_REF          *iter,          // IN: the iterator
+	     TPM_HT           type           // IN: the handle type to look for
+	     )
+{
+    NV_REF           addr;
+    TPM_HANDLE       nvHandle = 0;
+    while((addr = NvNext(iter, &nvHandle)) != 0)
+	{
+	    // addr: the address of the location containing the handle of the value
+	    // iter: the next location.
+	    if(HandleGetType(nvHandle) == type)
+		break;
+	}
+    if(handle != NULL)
+	*handle = nvHandle;
+    return addr;
+}
+/* 8.4.3.3 NvNextIndex() */
+/* This function returns the reference to the next NV Index entry.  A value of 0 indicates the end
+   of the list. */
+/* Return Values Meaning */
+/* 0 end of list */
+/* != 0 the next */
+#define NvNextIndex(handle, iter)		\
+    NvNextByType(handle, iter, TPM_HT_NV_INDEX)
+/*     8.4.3.4 NvNextEvict() */
+/* This function returns the offset in NV of the next evict object entry.  A value of 0 indicates
+   the end of the list. */
+#define NvNextEvict(handle, iter)			\
+    NvNextByType(handle, iter, TPM_HT_PERSISTENT)
+/*     8.4.3.5 NvGetEnd() */
+/* Function to find the end of the NV dynamic data list */
+static NV_REF
+NvGetEnd(
+	 void
+	 )
+{
+    NV_REF          iter = NV_REF_INIT;
+    NV_REF          currentAddr;
+    // Scan until the next address is 0
+    while((currentAddr = NvNext(&iter, NULL)) != 0);
+    return iter;
+}
+/* 8.4.3.6 NvGetFreeBytes */
+/* This function returns the number of free octets in NV space. */
+static UINT32
+NvGetFreeBytes(
+	       void
+	       )
+{
+    // This does not have an overflow issue because NvGetEnd() cannot return a value
+    // that is larger than s_evictNvEnd. This is because there is always a 'stop'
+    // word in the NV memory that terminates the search for the end before the
+    // value can go past s_evictNvEnd.
+    return s_evictNvEnd - NvGetEnd();
+}
+/* 8.4.3.7 NvTestSpace() */
+/* This function will test if there is enough space to add a new entity. */
+/* Return Values Meaning */
+/* TRUE space available */
+/* FALSE no enough space */
+static BOOL
+NvTestSpace(
+	    UINT32           size,          // IN: size of the entity to be added
+	    BOOL             isIndex,       // IN: TRUE if the entity is an index
+	    BOOL             isCounter      // IN: TRUE if the index is a counter
+	    )
+{
+    UINT32      remainBytes = NvGetFreeBytes();
+    UINT32      reserved = sizeof(UINT32)       // size of the forward pointer
+			   + sizeof(NV_LIST_TERMINATOR);
+    // Do a compile time sanity check on the setting for NV_MEMORY_SIZE
+#if NV_MEMORY_SIZE < 1024
+#error "NV_MEMORY_SIZE probably isn't large enough"
+#endif
+    // For NV Index, need to make sure that we do not allocate an Index if this
+    // would mean that the TPM cannot allocate the minimum number of evict
+    // objects.
+    if(isIndex)
+	{
+	    // Get the number of persistent objects allocated
+	    UINT32      persistentNum = NvCapGetPersistentNumber();
+	    // If we have not allocated the requisite number of evict objects, then we
+	    // need to reserve space for them.
+	    // NOTE: some of this is not written as simply as it might seem because
+	    // the values are all unsigned and subtracting needs to be done carefully
+	    // so that an underflow doesn't cause problems.
+	    if(persistentNum < MIN_EVICT_OBJECTS)
+		reserved += (MIN_EVICT_OBJECTS - persistentNum) * NV_EVICT_OBJECT_SIZE;
+	}
+    // If this is not an index or is not a counter, reserve space for the
+    // required number of counter indexes
+    if(!isIndex || !isCounter)
+	{
+	    // Get the number of counters
+	    UINT32      counterNum = NvCapGetCounterNumber();
+	    // If the required number of counters have not been allocated, reserved
+	    // space for the extra needed counters
+	    if(counterNum < MIN_COUNTER_INDICES)
+		reserved += (MIN_COUNTER_INDICES - counterNum) * NV_INDEX_COUNTER_SIZE;
+	}
+    // Check that the requested allocation will fit after making sure that there
+    // will be no chance of overflow
+    return ((reserved < remainBytes)
+	    && (size <= remainBytes)
+	    && (size + reserved <= remainBytes));
+}
+/* 8.4.3.8 NvWriteNvListEnd() */
+/* Function to write the list terminator. */
+NV_REF
+NvWriteNvListEnd(
+		 NV_REF           end
+		 )
+{
+    // Marker is initialized with zeros
+    BYTE        listEndMarker[sizeof(NV_LIST_TERMINATOR)] = {0};
+    UINT64      maxCount = NvReadMaxCount();
+    //
+    // This is a constant check that can be resolved at compile time.
+    cAssert(sizeof(UINT64) <= sizeof(NV_LIST_TERMINATOR) - sizeof(UINT32));
+    // Copy the maxCount value to the marker buffer
+    MemoryCopy(&listEndMarker[sizeof(UINT32)], &maxCount, sizeof(UINT64));
+    pAssert(end + sizeof(NV_LIST_TERMINATOR) <= s_evictNvEnd);
+    // Write it to memory
+    NvWrite(end, sizeof(NV_LIST_TERMINATOR), &listEndMarker);
+    return end + sizeof(NV_LIST_TERMINATOR);
+}
+/* 8.4.3.9 NvAdd() */
+/* This function adds a new entity to NV. */
+/* This function requires that there is enough space to add a new entity (i.e., that NvTestSpace()
+   has been called and the available space is at least as large as the required space). */
+/* The totalSize will be the size of entity. If a handle is added, this function will increase the
+   size accordingly. */
+static TPM_RC
+NvAdd(
+      UINT32           totalSize,     // IN: total size needed for this entity For
+      //     evict object, totalSize is the same as
+      //     bufferSize.  For NV Index, totalSize is
+      //     bufferSize plus index data size
+      UINT32           bufferSize,    // IN: size of initial buffer
+      TPM_HANDLE       handle,        // IN: optional handle
+      BYTE            *entity         // IN: initial buffer
+      )
+{
+    NV_REF          newAddr;        // IN: where the new entity will start
+    NV_REF          nextAddr;
+    RETURN_IF_NV_IS_NOT_AVAILABLE;
+    // Get the end of data list
+    newAddr = NvGetEnd();
+    // Step over the forward pointer
+    nextAddr = newAddr + sizeof(UINT32);
+    // Optionally write the handle. For indexes, the handle is TPM_RH_UNASSIGNED
+    // so that the handle in the nvIndex is used instead of writing this value
+    if(handle != TPM_RH_UNASSIGNED)
+	{
+	    NvWrite((UINT32)nextAddr, sizeof(TPM_HANDLE), &handle);
+	    nextAddr += sizeof(TPM_HANDLE);
+	}
+    // Write entity data
+    NvWrite((UINT32)nextAddr, bufferSize, entity);
+    // Advance the pointer by the amount of the total
+    nextAddr += totalSize;
+    // Finish by writing the link value
+    // Write the next offset (relative addressing)
+    totalSize = nextAddr - newAddr;
+    // Write link value
+    NvWrite((UINT32)newAddr, sizeof(UINT32), &totalSize);
+    // Write the list terminator
+    NvWriteNvListEnd(nextAddr);
+    return TPM_RC_SUCCESS;
+}
+/* 8.4.3.10 NvDelete() */
+/* This function is used to delete an NV Index or persistent object from NV memory. */
+static TPM_RC
+NvDelete(
+	 NV_REF           entityRef      // IN: reference to entity to be deleted
+	 )
+{
+    UINT32          entrySize;
+    // adjust entityAddr to back up and point to the forward pointer
+    NV_REF          entryRef = entityRef - sizeof(UINT32);
+    NV_REF          endRef = NvGetEnd();
+    NV_REF          nextAddr; // address of the next entry
+    RETURN_IF_NV_IS_NOT_AVAILABLE;
+    // Get the offset of the next entry. That is, back up and point to the size
+    // field of the entry
+    NvRead(&entrySize, entryRef, sizeof(UINT32));
+    // The next entry after the one being deleted is at a relative offset
+    // from the current entry
+    nextAddr = entryRef + entrySize;
+    // If this is not the last entry, move everything up
+    if(nextAddr < endRef)
+	{
+	    pAssert(nextAddr > entryRef);
+	    _plat__NvMemoryMove(nextAddr,
+				entryRef,
+				(endRef - nextAddr));
+	}
+    // The end of the used space is now moved up by the amount of space we just
+    // reclaimed
+    endRef -= entrySize;
+    // Write the end marker, and make the new end equal to the first byte after
+    // the just added end value. This will automatically update the NV value for
+    // maxCounter
+    // NOTE: This is the call that sets flag to cause NV to be updated
+    endRef = NvWriteNvListEnd(endRef);
+    // Clear the reclaimed memory
+    _plat__NvMemoryClear(endRef, entrySize);
+    return TPM_RC_SUCCESS;
+}
+/* 8.4.4 RAM-based NV Index Data Access Functions */
+/* 8.4.4.1 Introduction */
+/* The data layout in ram buffer is {size of(NV_handle() + attributes + data NV_handle(),
+   attributes, data} for each NV Index data stored in RAM. */
+/* NV storage associated with orderly data is updated when a NV Index is added but NOT when the data
+   or attributes are changed. Orderly data is only updated to NV on an orderly shutdown
+   (TPM2_Shutdown()) */
+/* 8.4.4.2	NvRamNext() */
+/* This function is used to iterate trough the list of Ram Index values. *iter needs to be
+   initialized by calling */
+static NV_RAM_REF
+NvRamNext(
+	  NV_RAM_REF      *iter,          // IN/OUT: the list iterator
+	  TPM_HANDLE      *handle         // OUT: the handle of the next item.
+	  )
+{
+    NV_RAM_REF           currentAddr;
+    NV_RAM_HEADER        header;
+    //
+    // If iterator is at the beginning of list
+    if(*iter == NV_RAM_REF_INIT)
+	{
+	    // Initialize iterator
+	    *iter = &s_indexOrderlyRam[0];
+	}
+    // if we are going to return what the iter is currently pointing to...
+    currentAddr = *iter;
+    // If iterator reaches the end of NV space, then don't advance and return
+    // that we are at the end of the list. The end of the list occurs when
+    // we don't have space for a size and a handle
+    if(currentAddr + sizeof(NV_RAM_HEADER) > RAM_ORDERLY_END)
+	return NULL;
+    // read the header of the next entry
+    memcpy(&header, currentAddr, sizeof(NV_RAM_HEADER)); // libtpms: do not use MemoryCopy to avoid gcc warning
+    // if the size field is zero, then we have hit the end of the list
+    if(header.size == 0)
+	// leave the *iter pointing at the end of the list
+	return NULL;
+    // advance the header by the size of the entry
+    *iter = currentAddr + header.size;
+    //    pAssert(*iter <= RAM_ORDERLY_END);
+    if(handle != NULL)
+	*handle = header.handle;
+    return currentAddr;
+}
+/*     8.4.4.2 NvRamGetEnd() */
+/* This routine performs the same function as NvGetEnd() but for the RAM data. */
+static NV_RAM_REF
+NvRamGetEnd(
+	    void
+	    )
+{
+    NV_RAM_REF           iter = NV_RAM_REF_INIT;
+    NV_RAM_REF           currentAddr;
+    // Scan until the next address is 0
+    while((currentAddr = NvRamNext(&iter, NULL)) != 0);
+    return iter;
+}
+/*     8.4.4.3 NvRamTestSpaceIndex() */
+/* This function indicates if there is enough RAM space to add a data for a new NV Index. */
+/* Return Values Meaning */
+/* TRUE space available */
+/* FALSE no enough space */
+static BOOL
+NvRamTestSpaceIndex(
+		    UINT32           size           // IN: size of the data to be added to RAM
+		    )
+{
+    UINT32          remaining = (UINT32)(RAM_ORDERLY_END - NvRamGetEnd());
+    UINT32          needed = sizeof(NV_RAM_HEADER) + size;
+    // NvRamGetEnd points to the next available byte.
+    return remaining >= needed;
+}
+/*     8.4.4.4 NvRamGetIndex() */
+/* This function returns the offset of NV data in the RAM buffer */
+/* This function requires that NV Index is in RAM. That is, the index must be known to exist. */
+static NV_RAM_REF
+NvRamGetIndex(
+	      TPMI_RH_NV_INDEX     handle         // IN: NV handle
+	      )
+{
+    NV_RAM_REF          iter = NV_RAM_REF_INIT;
+    NV_RAM_REF          currentAddr;
+    TPM_HANDLE          foundHandle;
+    while((currentAddr = NvRamNext(&iter, &foundHandle)) != 0)
+	{
+	    if(handle == foundHandle)
+		break;
+	}
+    return currentAddr;
+}
+/* 8.4.4.5 NvUpdateIndexOrderlyData() */
+/* This function is used to cause an update of the orderly data to the NV backing store. */
+void
+NvUpdateIndexOrderlyData(
+			 void
+			 )
+{
+    // Write reserved RAM space to NV
+    NvWrite(NV_INDEX_RAM_DATA, sizeof(s_indexOrderlyRam), s_indexOrderlyRam);
+}
+/* 8.4.4.6 NvAddRAM() */
+/* This function adds a new data area to RAM. */
+/* This function requires that enough free RAM space is available to add the new data. */
+/* This function should be called after the NV Index space has been updated and the index
+   removed. This insures that NV is available so that checking for NV availability is not required
+   during this function. */
+static void
+NvAddRAM(
+	 TPMS_NV_PUBLIC  *index          // IN: the index descriptor
+	 )
+{
+    NV_RAM_HEADER       header;
+    NV_RAM_REF          end = NvRamGetEnd();
+    header.size = sizeof(NV_RAM_HEADER) + index->dataSize;
+    header.handle = index->nvIndex;
+    MemoryCopy(&header.attributes, &index->attributes, sizeof(TPMA_NV));
+    pAssert(ORDERLY_RAM_ADDRESS_OK(end, header.size));
+    // Copy the header to the memory
+    MemoryCopy(end, &header, sizeof(NV_RAM_HEADER));
+    // Clear the data area (just in case)
+    MemorySet(end + sizeof(NV_RAM_HEADER), 0, index->dataSize);
+    // Step over this new entry
+    end += header.size;
+    // If the end marker will fit, add it
+    if(end + sizeof(UINT32) < RAM_ORDERLY_END)
+	MemorySet(end, 0, sizeof(UINT32));
+    // Write reserved RAM space to NV to reflect the newly added NV Index
+    SET_NV_UPDATE(UT_ORDERLY);
+    return;
+}
+/* 8.4.4.7 NvDeleteRAM() */
+/* This function is used to delete a RAM-backed NV Index data area. The space used by the entry are
+   overwritten by the contents of the Index data that comes after (the data is moved up to fill the
+   hole left by removing this index. The reclaimed space is cleared to zeros. This function assumes
+   the data of NV Index exists in RAM. */
+/* This function should be called after the NV Index space has been updated and the index
+   removed. This insures that NV is available so that checking for NV availability is not required
+   during this function. */
+static void
+NvDeleteRAM(
+	    TPMI_RH_NV_INDEX     handle         // IN: NV handle
+	    )
+{
+    NV_RAM_REF           nodeAddress;
+    NV_RAM_REF           nextNode;
+    UINT32               size;
+    NV_RAM_REF           lastUsed = NvRamGetEnd();
+    nodeAddress = NvRamGetIndex(handle);
+    pAssert(nodeAddress != 0);
+    // Get node size
+    MemoryCopy(&size, nodeAddress, sizeof(size));
+    // Get the offset of next node
+    nextNode = nodeAddress + size;
+    // Copy the data
+    MemoryCopy(nodeAddress, nextNode, (int)(lastUsed - nextNode));
+    // Clear out the reclaimed space
+    MemorySet(lastUsed - size, 0, size);
+    // Write reserved RAM space to NV to reflect the newly delete NV Index
+    SET_NV_UPDATE(UT_ORDERLY);
+    return;
+}
+/* 8.4.4.9 NvReadIndex() */
+/* This function is used to read the NV Index NV_INDEX. This is used so that the index information
+   can be compressed and only this function would be needed to decompress it. Mostly, compression
+   would only be able to save the space needed by the policy. */
+void
+NvReadNvIndexInfo(
+		  NV_REF           ref,           // IN: points to NV where index is located
+		  NV_INDEX        *nvIndex        // OUT: place to receive index data
+		  )
+{
+    pAssert(nvIndex != NULL);
+    NvRead(nvIndex, ref, sizeof(NV_INDEX));
+    return;
+}
+/* 8.4.4.9 NvReadObject() */
+/* This function is used to read a persistent object. This is used so that the object information
+   can be compressed and only this function would be needed to uncompress it. */
+void
+NvReadObject(
+	     NV_REF           ref,           // IN: points to NV where index is located
+	     OBJECT          *object         // OUT: place to receive the object data
+	     )
+{
+    NvRead(object, (ref + sizeof(TPM_HANDLE)), sizeof(OBJECT));
+    return;
+}
+/* 8.4.4.10 NvFindEvict() */
+/* This function will return the NV offset of an evict object */
+/* Return Values Meaning */
+/* 0 evict object not found */
+/* != 0 offset of evict object */
+static NV_REF
+NvFindEvict(
+	    TPM_HANDLE       nvHandle,
+	    OBJECT          *object
+	    )
+{
+    NV_REF          found = NvFindHandle(nvHandle);
+    // If we found the handle and the request included an object pointer, fill it in
+    if(found != 0 && object != NULL)
+	NvReadObject(found, object);
+    return found;
+}
+/* 8.4.4.11 NvIndexIsDefined() */
+/* See if an index is already defined */
+BOOL
+NvIndexIsDefined(
+		 TPM_HANDLE       nvHandle       // IN: Index to look for
+		 )
+{
+    return (NvFindHandle(nvHandle) != 0);
+}
+/* 8.4.4.12 NvConditionallyWrite() */
+/* Function to check if the data to be written has changed and write it if it has */
+/* Error Returns Meaning */
+/* TPM_RC_NV_RATE NV is unavailable because of rate limit */
+/* TPM_RC_NV_UNAVAILABLE NV is inaccessible */
+static TPM_RC
+NvConditionallyWrite(
+		     NV_REF           entryAddr,     // IN: stating address
+		     UINT32           size,          // IN: size of the data to write
+		     void            *data           // IN: the data to write
+		     )
+{
+    // If the index data is actually changed, then a write to NV is required
+    if(_plat__NvIsDifferent(entryAddr, size, data))
+	{
+	    // Write the data if NV is available
+	    if(g_NvStatus == TPM_RC_SUCCESS)
+		{
+		    NvWrite(entryAddr, size, data);
+		}
+	    return g_NvStatus;
+	}
+    return TPM_RC_SUCCESS;
+}
+/* 8.4.4.13 NvReadNvIndexAttributes() */
+/* This function returns the attributes of an NV Index. */
+static TPMA_NV
+NvReadNvIndexAttributes(
+			NV_REF           locator        // IN: reference to an NV index
+			)
+{
+    TPMA_NV                 attributes;
+    NvRead(&attributes,
+	   locator + offsetof(NV_INDEX, publicArea.attributes),
+	   sizeof(TPMA_NV));
+    return attributes;
+}
+/* 8.4.4.14 NvReadRamIndexAttributes() */
+/* This function returns the attributes from the RAM header structure. This function is used to deal
+   with the fact that the header structure is only byte aligned. */
+static TPMA_NV
+NvReadRamIndexAttributes(
+			 NV_RAM_REF       ref            // IN: pointer to a NV_RAM_HEADER
+			 )
+{
+    TPMA_NV         attributes;
+    MemoryCopy(&attributes, ref + offsetof(NV_RAM_HEADER, attributes),
+	       sizeof(TPMA_NV));
+    return attributes;
+}
+/* 8.4.4.15 NvWriteNvIndexAttributes() */
+/* This function is used to write just the attributes of an index to NV. */
+/* Error Returns Meaning */
+/* TPM_RC_NV_RATE NV is rate limiting so retry */
+/* TPM_RC_NV_UNAVAILABLE NV is not available */
+static TPM_RC
+NvWriteNvIndexAttributes(
+			 NV_REF           locator,       // IN: location of the index
+			 TPMA_NV          attributes     // IN: attributes to write
+			 )
+{
+    return NvConditionallyWrite(
+				locator + offsetof(NV_INDEX, publicArea.attributes),
+				sizeof(TPMA_NV),
+				&attributes);
+}
+/* 8.4.4.16 NvWriteRamIndexAttributes() */
+/* This function is used to write the index attributes into an unaligned structure */
+static void
+NvWriteRamIndexAttributes(
+			  NV_RAM_REF       ref,           // IN: address of the header
+			  TPMA_NV          attributes     // IN: the attributes to write
+			  )
+{
+    MemoryCopy(ref + offsetof(NV_RAM_HEADER, attributes), &attributes,
+	       sizeof(TPMA_NV));
+    return;
+}
+/* 8.4.5 Externally Accessible Functions */
+/* 8.4.5.1 NvIsPlatformPersistentHandle() */
+/* This function indicates if a handle references a persistent object in the range belonging to the
+   platform. */
+/* Return Values Meaning */
+/* TRUE handle references a platform persistent object */
+/* FALSE handle does not reference platform persistent object */
+BOOL
+NvIsPlatformPersistentHandle(
+			     TPM_HANDLE       handle         // IN: handle
+			     )
+{
+    return (handle >= PLATFORM_PERSISTENT && handle <= PERSISTENT_LAST);
+}
+/* 8.4.5.2 NvIsOwnerPersistentHandle() */
+/* This function indicates if a handle references a persistent object in the range belonging to the
+   owner. */
+/* Return Values Meaning */
+/* TRUE handle is owner persistent handle */
+/* FALSE handle is not owner persistent handle and may not be a persistent handle at all */
+BOOL
+NvIsOwnerPersistentHandle(
+			  TPM_HANDLE       handle         // IN: handle
+			  )
+{
+    return (handle >= PERSISTENT_FIRST && handle < PLATFORM_PERSISTENT);
+}
+/* 8.4.5.3 NvIndexIsAccessible() */
+/* This function validates that a handle references a defined NV Index and that the Index is
+   currently accessible. */
+/* Error Returns Meaning */
+/* TPM_RC_HANDLE the handle points to an undefined NV Index If shEnable is CLEAR, this would include
+   an index created using ownerAuth. If phEnableNV is CLEAR, this would include and index created
+   using platformAuth */
+/* TPM_RC_NV_READLOCKED Index is present but locked for reading and command does not write to the
+   index */
+/* TPM_RC_NV_WRITELOCKED Index is present but locked for writing and command writes to the index */
+TPM_RC
+NvIndexIsAccessible(
+		    TPMI_RH_NV_INDEX     handle        // IN: handle
+		    )
+{
+    NV_INDEX            *nvIndex = NvGetIndexInfo(handle, NULL);
+    //
+    if(nvIndex == NULL)
+	// If index is not found, return TPM_RC_HANDLE
+	return TPM_RC_HANDLE;
+    if(gc.shEnable == FALSE || gc.phEnableNV == FALSE)
+	{
+	    // if shEnable is CLEAR, an ownerCreate NV Index should not be
+	    // indicated as present
+	    if(!IS_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, PLATFORMCREATE))
+		{
+		    if(gc.shEnable == FALSE)
+			return TPM_RC_HANDLE;
+		}
+	    // if phEnableNV is CLEAR, a platform created Index should not
+	    // be visible
+	    else if(gc.phEnableNV == FALSE)
+		return TPM_RC_HANDLE;
+	}
+#if 0 // Writelock test for debug
+    // If the Index is write locked and this is an NV Write operation...
+    if(IS_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, WRITELOCKED)
+       &&  IsWriteOperation(commandIndex))
+	{
+	    // then return a locked indication unless the command is TPM2_NV_WriteLock
+	    if(GetCommandCode(commandIndex) != TPM_CC_NV_WriteLock)
+		return TPM_RC_NV_LOCKED;
+	    return TPM_RC_SUCCESS;
+	}
+#endif
+#if 0   // Readlock Test for debug
+    // If the Index is read locked and this is an NV Read operation...
+    if(IS_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, READLOCKED)
+       && IsReadOperation(commandIndex))
+	{
+	    // then return a locked indication unless the command is TPM2_NV_ReadLock
+	    if(GetCommandCode(commandIndex) != TPM_CC_NV_ReadLock)
+		return TPM_RC_NV_LOCKED;
+	}
+#endif
+    // NV Index is accessible
+    return TPM_RC_SUCCESS;
+}
+/* 8.4.5.4 NvGetEvictObject() */
+/* This function is used to dereference an evict object handle and get a pointer to the object. */
+/* Error Returns Meaning */
+/* TPM_RC_HANDLE the handle does not point to an existing persistent object */
+TPM_RC
+NvGetEvictObject(
+		 TPM_HANDLE       handle,        // IN: handle
+		 OBJECT          *object         // OUT: object data
+		 )
+{
+    NV_REF          entityAddr;         // offset points to the entity
+    // Find the address of evict object and copy to object
+    entityAddr = NvFindEvict(handle, object);
+    // whether there is an error or not, make sure that the evict
+    // status of the object is set so that the slot will get freed on exit
+    // Must do this after NvFindEvict loads the object
+    object->attributes.evict = SET;
+    // If handle is not found, return an error
+    if(entityAddr == 0)
+	return TPM_RC_HANDLE;
+    return TPM_RC_SUCCESS;
+}
+/* 8.4.5.5 NvIndexCacheInit() */
+/* Function to initialize the Index cache */
+void
+NvIndexCacheInit(
+		 void
+		 )
+{
+    s_cachedNvRef = NV_REF_INIT;
+    s_cachedNvRamRef = NV_RAM_REF_INIT;
+    s_cachedNvIndex.publicArea.nvIndex = TPM_RH_UNASSIGNED;
+    return;
+}
+/* 8.4.5.6 NvGetIndexData() */
+/* This function is used to access the data in an NV Index. The data is returned as a byte
+   sequence. */
+/* This function requires that the NV Index be defined, and that the required data is within the
+   data range.  It also requires that TPMA_NV_WRITTEN of the Index is SET. */
+void
+NvGetIndexData(
+	       NV_INDEX        *nvIndex,       // IN: the in RAM index descriptor
+	       NV_REF           locator,       // IN: where the data is located
+	       UINT32           offset,        // IN: offset of NV data
+	       UINT16           size,          // IN: size of NV data
+	       void            *data           // OUT: data buffer
+	       )
+{
+    TPMA_NV             nvAttributes;
+    //
+    pAssert(nvIndex != NULL);
+    nvAttributes = nvIndex->publicArea.attributes;
+    pAssert(IS_ATTRIBUTE(nvAttributes, TPMA_NV, WRITTEN));
+    if(IS_ATTRIBUTE(nvAttributes, TPMA_NV, ORDERLY))
+	{
+	    // Get data from RAM buffer
+	    NV_RAM_REF           ramAddr = NvRamGetIndex(nvIndex->publicArea.nvIndex);
+	    pAssert(ramAddr != 0 && (size <=
+				     ((NV_RAM_HEADER *)ramAddr)->size -
+				     sizeof(NV_RAM_HEADER) - offset));
+	    MemoryCopy(data, ramAddr + sizeof(NV_RAM_HEADER) + offset, size);
+	}
+    else
+	{
+	    // Validate that read falls within range of the index
+	    pAssert(offset <= nvIndex->publicArea.dataSize
+		    &&  size <= (nvIndex->publicArea.dataSize - offset));
+	    NvRead(data, locator + sizeof(NV_INDEX) + offset, size);
+	}
+    return;
+}
+/* 8.4.5.7	NvHashIndexData() */
+/* This function adds Index data to a hash. It does this in parts to avoid large stack buffers. */
+void
+NvHashIndexData(
+		HASH_STATE          *hashState,     // IN: Initialized hash state
+		NV_INDEX            *nvIndex,       // IN: Index
+		NV_REF               locator,       // IN: where the data is located
+		UINT32               offset,        // IN: starting offset
+		UINT16               size           // IN: amount to hash
+		)
+{
+#define BUFFER_SIZE     64
+    BYTE                 buffer[BUFFER_SIZE];
+    if (offset > nvIndex->publicArea.dataSize)
+	return;
+    // Make sure that we don't try to read off the end.
+    if ((offset + size) > nvIndex->publicArea.dataSize)
+	size = nvIndex->publicArea.dataSize - (UINT16)offset;
+#if BUFFER_SIZE >= MAX_NV_INDEX_SIZE
+    NvGetIndexData(nvIndex, locator, offset, size, buffer);
+    CryptDigestUpdate(hashState, size, buffer);
+#else
+    {
+	INT16                i;
+	UINT16               readSize;
+	//
+	for (i = size; i > 0; offset += readSize, i -= readSize)
+	    {
+		readSize = (i < BUFFER_SIZE) ? i : BUFFER_SIZE;
+		NvGetIndexData(nvIndex, locator, offset, readSize, buffer);
+		CryptDigestUpdate(hashState, readSize, buffer);
+	    }
+    }
+#endif // BUFFER_SIZE >= MAX_NV_INDEX_SIZE
+#undef  BUFFER_SIZE
+}
+/* 8.4.5.7 NvGetUINT64Data() */
+/* Get data in integer format of a bit or counter NV Index. */
+/* This function requires that the NV Index is defined and that the NV Index previously has been
+   written. */
+UINT64
+NvGetUINT64Data(
+		NV_INDEX        *nvIndex,       // IN: the in RAM index descriptor
+		NV_REF           locator        // IN: where index exists in NV
+		)
+{
+    UINT64                intVal;
+    // Read the value and convert it to internal format
+    NvGetIndexData(nvIndex, locator, 0, 8, &intVal);
+    return BYTE_ARRAY_TO_UINT64(((BYTE *)&intVal));
+}
+/* 8.4.5.8 NvWriteIndexAttributes() */
+/* This function is used to write just the attributes of an index. */
+/* Error Returns Meaning */
+/* TPM_RC_NV_RATE NV is rate limiting so retry */
+/* TPM_RC_NV_UNAVAILABLE NV is not available */
+TPM_RC
+NvWriteIndexAttributes(
+		       TPM_HANDLE       handle,
+		       NV_REF           locator,       // IN: location of the index
+		       TPMA_NV          attributes     // IN: attributes to write
+		       )
+{
+    TPM_RC              result;
+    //
+    if(IS_ATTRIBUTE(attributes, TPMA_NV, ORDERLY))
+	{
+	    NV_RAM_REF      ram = NvRamGetIndex(handle);
+	    NvWriteRamIndexAttributes(ram, attributes);
+	    result = TPM_RC_SUCCESS;
+	}
+    else
+	{
+	    result = NvWriteNvIndexAttributes(locator, attributes);
+	}
+    return result;
+}
+/* 8.4.5.9 NvWriteIndexAuth() */
+/* This function is used to write the authValue of an index. It is used by TPM2_NV_ChangeAuth() */
+/* Error Returns Meaning */
+/* TPM_RC_NV_RATE NV is rate limiting so retry */
+/* TPM_RC_NV_UNAVAILABLE NV is not available */
+TPM_RC
+NvWriteIndexAuth(
+		 NV_REF           locator,       // IN: location of the index
+		 TPM2B_AUTH      *authValue      // IN: the authValue to write
+		 )
+{
+    {
+	TPM_RC              result;
+	//
+	// If the locator is pointing to the cached index value...
+	if(locator == s_cachedNvRef)
+	    {
+		// copy the authValue to the cached index so it will be there if we
+		// look for it. This is a safety thing.
+		MemoryCopy2B(&s_cachedNvIndex.authValue.b, &authValue->b,
+			     sizeof(s_cachedNvIndex.authValue.t.buffer));
+	    }
+	result = NvConditionallyWrite(
+				      locator + offsetof(NV_INDEX, authValue),
+				      sizeof(UINT16) + authValue->t.size,
+				      authValue);
+	return result;
+    }
+}
+/* 8.4.5.10 NvGetIndexInfo() */
+/* This function loads the nvIndex Info into the NV cache and returns a pointer to the NV_INDEX. If
+   the returned value is zero, the index was not found. The locator parameter, if not NULL, will be
+   set to the offset in NV of the Index (the location of the handle of the Index). */
+/* This function will set the index cache. If the index is orderly, the attributes from RAM are
+   substituted for the attributes in the cached index */
+NV_INDEX *
+NvGetIndexInfo(
+	       TPM_HANDLE       nvHandle,      // IN: the index handle
+	       NV_REF          *locator        // OUT: location of the index
+	       )
+{
+    if(s_cachedNvIndex.publicArea.nvIndex != nvHandle)
+	{
+	    s_cachedNvIndex.publicArea.nvIndex = TPM_RH_UNASSIGNED;
+	    s_cachedNvRamRef = 0;
+	    s_cachedNvRef = NvFindHandle(nvHandle);
+	    if(s_cachedNvRef == 0)
+		return NULL;
+	    NvReadNvIndexInfo(s_cachedNvRef, &s_cachedNvIndex);
+	    if(IS_ATTRIBUTE(s_cachedNvIndex.publicArea.attributes, TPMA_NV, ORDERLY))
+		{
+		    s_cachedNvRamRef = NvRamGetIndex(nvHandle);
+		    s_cachedNvIndex.publicArea.attributes =
+			NvReadRamIndexAttributes(s_cachedNvRamRef);
+		}
+	}
+    if(locator != NULL)
+	*locator = s_cachedNvRef;
+    return &s_cachedNvIndex;
+}
+/* 8.4.5.11 NvWriteIndexData() */
+/* This function is used to write NV index data. It is intended to be used to update the data
+   associated with the default index. */
+/* This function requires that the NV Index is defined, and the data is within the defined data
+   range for the index. */
+/* Index data is only written due to a command that modifies the data in a single index. There is no
+   case where changes are made to multiple indexes data at the same time. Multiple attributes may be
+   change but not multiple index data. This is important because we will normally be handling the
+   index for which we have the cached pointer values. */
+/* Error Returns Meaning */
+/* TPM_RC_NV_RATE NV is rate limiting so retry */
+/* TPM_RC_NV_UNAVAILABLE NV is not available */
+TPM_RC
+NvWriteIndexData(
+		 NV_INDEX        *nvIndex,       // IN: the description of the index
+		 UINT32           offset,        // IN: offset of NV data
+		 UINT32           size,          // IN: size of NV data
+		 void            *data           // IN: data buffer
+		 )
+{
+    TPM_RC               result = TPM_RC_SUCCESS;
+    //
+    pAssert(nvIndex != NULL);
+    // Make sure that this is dealing with the 'default' index.
+    // Note: it is tempting to change the calling sequence so that the 'default' is
+    // presumed.
+    pAssert(nvIndex->publicArea.nvIndex == s_cachedNvIndex.publicArea.nvIndex);
+    // Validate that write falls within range of the index
+    pAssert(offset <= nvIndex->publicArea.dataSize
+	    &&  size <= (nvIndex->publicArea.dataSize - offset));
+    // Update TPMA_NV_WRITTEN bit if necessary
+    if(!IS_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, WRITTEN))
+	{
+	    // Update the in memory version of the attributes
+	    SET_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, WRITTEN);
+	    // If this is not orderly, then update the NV version of
+	    // the attributes
+	    if(!IS_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, ORDERLY))
+		{
+		    result = NvWriteNvIndexAttributes(s_cachedNvRef,
+						      nvIndex->publicArea.attributes);
+		    if(result != TPM_RC_SUCCESS)
+			return result;
+		    // If this is a partial write of an ordinary index, clear the whole
+		    // index.
+		    if(IsNvOrdinaryIndex(nvIndex->publicArea.attributes)
+		       && (nvIndex->publicArea.dataSize > size))
+			_plat__NvMemoryClear(s_cachedNvRef + sizeof(NV_INDEX),
+					     nvIndex->publicArea.dataSize);
+		}
+	    else
+		{
+		    // This is orderly so update the RAM version
+		    MemoryCopy(s_cachedNvRamRef + offsetof(NV_RAM_HEADER, attributes),
+			       &nvIndex->publicArea.attributes, sizeof(TPMA_NV));
+		    // If setting WRITTEN for an orderly counter, make sure that the
+		    // state saved version of the counter is saved
+		    if(IsNvCounterIndex(nvIndex->publicArea.attributes))
+			SET_NV_UPDATE(UT_ORDERLY);
+		    // If setting the written attribute on an ordinary index, make sure that
+		    // the data is all cleared out in case there is a partial write. This
+		    // is only necessary for ordinary indexes because all of the other types
+		    // are always written in total.
+		    else if(IsNvOrdinaryIndex(nvIndex->publicArea.attributes))
+			MemorySet(s_cachedNvRamRef + sizeof(NV_RAM_HEADER),
+				  0, nvIndex->publicArea.dataSize);
+		}
+	}
+    // If this is orderly data, write it to RAM
+    if(IS_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, ORDERLY))
+	{
+	    // Note: if this is the first write to a counter, the code above will queue
+	    // the write to NV of the RAM data in order to update TPMA_NV_WRITTEN. In
+	    // process of doing that write, it will also write the initial counter value
+	    // Update RAM
+	    MemoryCopy(s_cachedNvRamRef + sizeof(NV_RAM_HEADER) + offset, data, size);
+	    // And indicate that the TPM is no longer orderly
+	    g_clearOrderly = TRUE;
+	}
+    else
+	{
+	    // Offset into the index to the first byte of the data to be written to NV
+	    result = NvConditionallyWrite(s_cachedNvRef + sizeof(NV_INDEX) + offset,
+					  size, data);
+	}
+    return result;
+}
+/* 8.4.5.12 NvWriteUINT64Data() */
+/* This function to write back a UINT64 value. The various UINT64 values (bits, counters, and
+   PINs()) are kept in canonical format but manipulate in native format. This takes a native format
+   value converts it and saves it back as in canonical format. */
+/* This function will return the value from NV or RAM depending on the type of the index (orderly or
+   not) */
+TPM_RC
+NvWriteUINT64Data(
+		  NV_INDEX        *nvIndex,       // IN: the description of the index
+		  UINT64           intValue       // IN: the value to write
+		  )
+{
+    BYTE            bytes[8];
+    UINT64_TO_BYTE_ARRAY(intValue, bytes);
+    return NvWriteIndexData(nvIndex, 0, 8, &bytes);
+}
+/* 8.4.5.13 NvGetIndexName() */
+/* This function computes the Name of an index The name buffer receives the bytes of the Name and
+   the return value is the number of octets in the Name. */
+/* This function requires that the NV Index is defined. */
+TPM2B_NAME *
+NvGetIndexName(
+	       NV_INDEX        *nvIndex,       // IN: the index over which the name is to be
+	       //     computed
+	       TPM2B_NAME      *name           // OUT: name of the index
+	       )
+{
+    UINT16               dataSize, digestSize;
+    BYTE                 marshalBuffer[sizeof(TPMS_NV_PUBLIC)];
+    BYTE                *buffer;
+    HASH_STATE           hashState;
+    // Marshal public area
+    buffer = marshalBuffer;
+    dataSize = TPMS_NV_PUBLIC_Marshal(&nvIndex->publicArea, &buffer, NULL);
+    // hash public area
+    digestSize = CryptHashStart(&hashState, nvIndex->publicArea.nameAlg);
+    CryptDigestUpdate(&hashState, dataSize, marshalBuffer);
+    // Complete digest leaving room for the nameAlg
+    CryptHashEnd(&hashState, digestSize, &name->b.buffer[2]);
+    // Include the nameAlg
+    UINT16_TO_BYTE_ARRAY(nvIndex->publicArea.nameAlg, name->b.buffer);
+    name->t.size = digestSize + 2;
+    return name;
+}
+/* 8.4.5.14 NvGetNameByIndexHandle() */
+/* This function is used to compute the Name of an NV Index referenced by handle. */
+/* The name buffer receives the bytes of the Name and the return value is the number of octets in
+   the Name. */
+/* This function requires that the NV Index is defined. */
+TPM2B_NAME *
+NvGetNameByIndexHandle(
+		       TPMI_RH_NV_INDEX     handle,        // IN: handle of the index
+		       TPM2B_NAME          *name           // OUT: name of the index
+		       )
+{
+    NV_INDEX             *nvIndex = NvGetIndexInfo(handle, NULL);
+    return NvGetIndexName(nvIndex, name);
+}
+/* 8.4.5.15 NvDefineIndex() */
+/* This function is used to assign NV memory to an NV Index. */
+/* Error Returns Meaning */
+/* TPM_RC_NV_SPACE insufficient NV space */
+TPM_RC
+NvDefineIndex(
+	      TPMS_NV_PUBLIC  *publicArea,    // IN: A template for an area to create.
+	      TPM2B_AUTH      *authValue      // IN: The initial authorization value
+	      )
+{
+ 
+    // The buffer to be written to NV memory
+    NV_INDEX        nvIndex;            // the index data
+    UINT16          entrySize;          // size of entry
+    TPM_RC          result;
+    //
+    entrySize = sizeof(NV_INDEX);
+    // only allocate data space for indexes that are going to be written to NV.
+    // Orderly indexes don't need space.
+    if(!IS_ATTRIBUTE(publicArea->attributes, TPMA_NV, ORDERLY))
+	entrySize += publicArea->dataSize;
+    // Check if we have enough space to create the NV Index
+    // In this implementation, the only resource limitation is the available NV
+    // space (and possibly RAM space.)  Other implementation may have other
+    // limitation on counter or on NV slots
+    if(!NvTestSpace(entrySize, TRUE, IsNvCounterIndex(publicArea->attributes)))
+	return TPM_RC_NV_SPACE;
+    // if the index to be defined is RAM backed, check RAM space availability
+    // as well
+    if(IS_ATTRIBUTE(publicArea->attributes, TPMA_NV, ORDERLY)
+       &&  !NvRamTestSpaceIndex(publicArea->dataSize))
+	return TPM_RC_NV_SPACE;
+    // Copy input value to nvBuffer
+    nvIndex.publicArea = *publicArea;
+    // Copy the authValue
+    nvIndex.authValue = *authValue;
+    // Add index to NV memory
+    result = NvAdd(entrySize, sizeof(NV_INDEX), TPM_RH_UNASSIGNED,
+		   (BYTE *)&nvIndex);
+    if(result == TPM_RC_SUCCESS)
+	{
+	    // If the data of NV Index is RAM backed, add the data area in RAM as well
+	    if(IS_ATTRIBUTE(publicArea->attributes, TPMA_NV, ORDERLY))
+		NvAddRAM(publicArea);
+	}
+    return result;
+}
+/* 8.4.5.16 NvAddEvictObject() */
+/* This function is used to assign NV memory to a persistent object. */
+/* Error Returns Meaning */
+/* TPM_RC_NV_HANDLE the requested handle is already in use */
+/* TPM_RC_NV_SPACE insufficient NV space */
+TPM_RC
+NvAddEvictObject(
+		 TPMI_DH_OBJECT   evictHandle,   // IN: new evict handle
+		 OBJECT          *object         // IN: object to be added
+		 )
+{
+    TPM_HANDLE       temp = object->evictHandle;
+    TPM_RC           result;
+    // Check if we have enough space to add the evict object
+    // An evict object needs 8 bytes in index table + sizeof OBJECT
+    // In this implementation, the only resource limitation is the available NV
+    // space.  Other implementation may have other limitation on evict object
+    // handle space
+    if(!NvTestSpace(sizeof(OBJECT) + sizeof(TPM_HANDLE), FALSE, FALSE))
+	return TPM_RC_NV_SPACE;
+    // Set evict attribute and handle
+    object->attributes.evict = SET;
+    object->evictHandle = evictHandle;
+    // Now put this in NV
+    result = NvAdd(sizeof(OBJECT), sizeof(OBJECT), evictHandle, (BYTE *)object);
+    // Put things back the way they were
+    object->attributes.evict = CLEAR;
+    object->evictHandle = temp;
+    return result;
+}
+/* 8.4.5.17 NvDeleteIndex() */
+/* This function is used to delete an NV Index. */
+/* Error Returns Meaning */
+/* TPM_RC_NV_UNAVAILABLE NV is not accessible */
+/* TPM_RC_NV_RATE NV is rate limiting */
+TPM_RC
+NvDeleteIndex(
+	      NV_INDEX        *nvIndex,       // IN: an in RAM index descriptor
+	      NV_REF           entityAddr     // IN: location in NV
+	      )
+{
+    TPM_RC           result;
+    //
+    if(nvIndex != NULL)
+	{
+	    // Whenever a counter is deleted, make sure that the MaxCounter value is
+	    // updated to reflect the value
+	    if(IsNvCounterIndex(nvIndex->publicArea.attributes)
+	       && IS_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, WRITTEN))
+		NvUpdateMaxCount(NvGetUINT64Data(nvIndex, entityAddr));
+	    result = NvDelete(entityAddr);
+	    if(result != TPM_RC_SUCCESS)
+		return result;
+	    // If the NV Index is RAM backed, delete the RAM data as well
+	    if(IS_ATTRIBUTE(nvIndex->publicArea.attributes, TPMA_NV, ORDERLY))
+		NvDeleteRAM(nvIndex->publicArea.nvIndex);
+	    NvIndexCacheInit();
+	}
+    return TPM_RC_SUCCESS;
+}
+/* 8.4.5.18 NvDeleteEvict() */
+/* This function will delete a NV evict object. Will return success if object deleted or if it does
+   not exist */
+TPM_RC
+NvDeleteEvict(
+	      TPM_HANDLE       handle         // IN: handle of entity to be deleted
+	      )
+{
+    NV_REF      entityAddr = NvFindEvict(handle, NULL);     // pointer to entity
+    TPM_RC      result = TPM_RC_SUCCESS;
+    if(entityAddr != 0)
+	result = NvDelete(entityAddr);
+    return result;
+}
+/* 8.4.5.19 NvFlushHierarchy() */
+/* This function will delete persistent objects belonging to the indicated hierarchy.  If the
+   storage hierarchy is selected, the function will also delete any NV Index defined using
+   ownerAuth. */
+/* Error Returns Meaning */
+/* TPM_RC_NV_RATE NV is unavailable because of rate limit */
+/* TPM_RC_NV_UNAVAILABLE NV is inaccessible */
+TPM_RC
+NvFlushHierarchy(
+		 TPMI_RH_HIERARCHY    hierarchy      // IN: hierarchy to be flushed.
+		 )
+{
+    NV_REF           iter = NV_REF_INIT;
+    NV_REF           currentAddr;
+    TPM_HANDLE       entityHandle;
+    TPM_RC           result = TPM_RC_SUCCESS;
+    //
+    while((currentAddr = NvNext(&iter, &entityHandle)) != 0)
+	{
+	    if(HandleGetType(entityHandle) == TPM_HT_NV_INDEX)
+		{
+		    NV_INDEX        nvIndex;
+		    //
+		    // If flush endorsement or platform hierarchy, no NV Index would be
+		    // flushed
+		    if(hierarchy == TPM_RH_ENDORSEMENT || hierarchy == TPM_RH_PLATFORM)
+			continue;
+		    // Get the index information
+		    NvReadNvIndexInfo(currentAddr, &nvIndex);
+		    // For storage hierarchy, flush OwnerCreated index
+		    if(!IS_ATTRIBUTE(nvIndex.publicArea.attributes, TPMA_NV,
+				     PLATFORMCREATE))
+			{
+			    // Delete the index (including RAM for orderly)
+			    result = NvDeleteIndex(&nvIndex, currentAddr);
+			    if(result != TPM_RC_SUCCESS)
+				break;
+			    // Re-iterate from beginning after a delete
+			    iter = NV_REF_INIT;
+			}
+		}
+	    else if(HandleGetType(entityHandle) == TPM_HT_PERSISTENT)
+		{
+		    OBJECT_ATTRIBUTES           attributes;
+		    //
+		    NvRead(&attributes,
+			   (UINT32)(currentAddr
+				    + sizeof(TPM_HANDLE)
+				    + offsetof(OBJECT, attributes)),
+			   sizeof(OBJECT_ATTRIBUTES));
+		    // If the evict object belongs to the hierarchy to be flushed...
+		    if((hierarchy == TPM_RH_PLATFORM && attributes.ppsHierarchy == SET)
+		       || (hierarchy == TPM_RH_OWNER && attributes.spsHierarchy == SET)
+		       || (hierarchy == TPM_RH_ENDORSEMENT
+			   &&  attributes.epsHierarchy == SET))
+			{
+			    // ...then delete the evict object
+			    result = NvDelete(currentAddr);
+			    if(result != TPM_RC_SUCCESS)
+				break;
+			    // Re-iterate from beginning after a delete
+			    iter = NV_REF_INIT;
+			}
+		}
+	    else
+		{
+		    FAIL(FATAL_ERROR_INTERNAL);
+		}
+	}
+    return result;
+}
+/* 8.4.5.20 NvSetGlobalLock() */
+/* This function is used to SET the TPMA_NV_WRITELOCKED attribute for all NV Indexes that have
+   TPMA_NV_GLOBALLOCK SET. This function is use by TPM2_NV_GlobalWriteLock(). */
+/* Error Returns Meaning */
+/* TPM_RC_NV_RATE NV is unavailable because of rate limit */
+/* TPM_RC_NV_UNAVAILABLE NV is inaccessible */
+TPM_RC
+NvSetGlobalLock(
+		void
+		)
+{
+    NV_REF           iter = NV_REF_INIT;
+    NV_RAM_REF       ramIter = NV_RAM_REF_INIT;
+    NV_REF           currentAddr;
+    NV_RAM_REF       currentRamAddr;
+    TPM_RC           result = TPM_RC_SUCCESS;
+    //
+    // Check all normal indexes
+    while((currentAddr = NvNextIndex(NULL, &iter)) != 0)
+	{
+	    TPMA_NV         attributes = NvReadNvIndexAttributes(currentAddr);
+	    //
+	    // See if it should be locked
+	    if(!IS_ATTRIBUTE(attributes, TPMA_NV, ORDERLY)
+	       &&  IS_ATTRIBUTE(attributes, TPMA_NV, GLOBALLOCK))
+		{
+		    SET_ATTRIBUTE(attributes, TPMA_NV, WRITELOCKED);
+		    result = NvWriteNvIndexAttributes(currentAddr, attributes);
+		    if(result != TPM_RC_SUCCESS)
+			return result;
+		}
+	}
+    // Now search all the orderly attributes
+    while((currentRamAddr = NvRamNext(&ramIter, NULL)) != 0)
+	{
+	    // See if it should be locked
+	    TPMA_NV         attributes = NvReadRamIndexAttributes(currentRamAddr);
+	    if(IS_ATTRIBUTE(attributes, TPMA_NV, GLOBALLOCK))
+		{
+		    SET_ATTRIBUTE(attributes, TPMA_NV, WRITELOCKED);
+		    NvWriteRamIndexAttributes(currentRamAddr, attributes);
+		}
+	}
+    return result;
+}
+/* 8.4.5.21 InsertSort() */
+/* Sort a handle into handle list in ascending order.  The total handle number in the list should
+   not exceed MAX_CAP_HANDLES */
+static void
+InsertSort(
+	   TPML_HANDLE     *handleList,    // IN/OUT: sorted handle list
+	   UINT32           count,         // IN: maximum count in the handle list
+	   TPM_HANDLE       entityHandle   // IN: handle to be inserted
+	   )
+{
+    UINT32          i, j;
+    UINT32          originalCount;
+    // For a corner case that the maximum count is 0, do nothing
+    if(count == 0)
+	return;
+    // For empty list, add the handle at the beginning and return
+    if(handleList->count == 0)
+	{
+	    handleList->handle[0] = entityHandle;
+	    handleList->count++;
+	    return;
+	}
+    // Check if the maximum of the list has been reached
+    originalCount = handleList->count;
+    if(originalCount < count)
+	handleList->count++;
+    // Insert the handle to the list
+    for(i = 0; i < originalCount; i++)
+	{
+	    if(handleList->handle[i] > entityHandle)
+		{
+		    for(j = handleList->count - 1; j > i; j--)
+			{
+			    handleList->handle[j] = handleList->handle[j - 1];
+			}
+		    break;
+		}
+	}
+    // If a slot was found, insert the handle in this position
+    if(i < originalCount || handleList->count > originalCount)
+	handleList->handle[i] = entityHandle;
+    return;
+}
+/* 8.4.5.22 NvCapGetPersistent() */
+/* This function is used to get a list of handles of the persistent objects, starting at handle. */
+/* Handle must be in valid persistent object handle range, but does not have to reference an
+   existing persistent object. */
+/* Return Values Meaning */
+/* YES if there are more handles available */
+/* NO all the available handles has been returned */
+TPMI_YES_NO
+NvCapGetPersistent(
+		   TPMI_DH_OBJECT   handle,        // IN: start handle
+		   UINT32           count,         // IN: maximum number of returned handles
+		   TPML_HANDLE     *handleList     // OUT: list of handle
+		   )
+{
+    TPMI_YES_NO              more = NO;
+    NV_REF                   iter = NV_REF_INIT;
+    NV_REF                   currentAddr;
+    TPM_HANDLE               entityHandle;
+    pAssert(HandleGetType(handle) == TPM_HT_PERSISTENT);
+    // Initialize output handle list
+    handleList->count = 0;
+    // The maximum count of handles we may return is MAX_CAP_HANDLES
+    if(count > MAX_CAP_HANDLES) count = MAX_CAP_HANDLES;
+    while((currentAddr = NvNextEvict(&entityHandle, &iter)) != 0)
+	{
+	    // Ignore persistent handles that have values less than the input handle
+	    if(entityHandle < handle)
+		continue;
+	    // if the handles in the list have reached the requested count, and there
+	    // are still handles need to be inserted, indicate that there are more.
+	    if(handleList->count == count)
+		more = YES;
+	    // A handle with a value larger than start handle is a candidate
+	    // for return. Insert sort it to the return list.  Insert sort algorithm
+	    // is chosen here for simplicity based on the assumption that the total
+	    // number of NV Indexes is small.  For an implementation that may allow
+	    // large number of NV Indexes, a more efficient sorting algorithm may be
+	    // used here.
+	    InsertSort(handleList, count, entityHandle);
+	}
+    return more;
+}
+/* 8.4.5.23 NvCapGetIndex() */
+/* This function returns a list of handles of NV Indexes, starting from handle. Handle must be in
+   the range of NV Indexes, but does not have to reference an existing NV Index. */
+/* Return Values Meaning */
+/* YES if there are more handles to report */
+/* NO all the available handles has been reported */
+TPMI_YES_NO
+NvCapGetIndex(
+	      TPMI_DH_OBJECT   handle,        // IN: start handle
+	      UINT32           count,         // IN: max number of returned handles
+	      TPML_HANDLE     *handleList     // OUT: list of handle
+	      )
+{
+    TPMI_YES_NO              more = NO;
+    NV_REF                   iter = NV_REF_INIT;
+    NV_REF                   currentAddr;
+    TPM_HANDLE               nvHandle;
+    pAssert(HandleGetType(handle) == TPM_HT_NV_INDEX);
+    // Initialize output handle list
+    handleList->count = 0;
+    // The maximum count of handles we may return is MAX_CAP_HANDLES
+    if(count > MAX_CAP_HANDLES) count = MAX_CAP_HANDLES;
+    while((currentAddr = NvNextIndex(&nvHandle, &iter)) != 0)
+	{
+	    // Ignore index handles that have values less than the 'handle'
+	    if(nvHandle < handle)
+		continue;
+	    // if the count of handles in the list has reached the requested count,
+	    // and there are still handles to report, set more.
+	    if(handleList->count == count)
+		more = YES;
+	    // A handle with a value larger than start handle is a candidate
+	    // for return. Insert sort it to the return list.  Insert sort algorithm
+	    // is chosen here for simplicity based on the assumption that the total
+	    // number of NV Indexes is small.  For an implementation that may allow
+	    // large number of NV Indexes, a more efficient sorting algorithm may be
+	    // used here.
+	    InsertSort(handleList, count, nvHandle);
+	}
+    return more;
+}
+/* 8.4.5.24 NvCapGetIndexNumber() */
+/* This function returns the count of NV Indexes currently defined. */
+UINT32
+NvCapGetIndexNumber(
+		    void
+		    )
+{
+    UINT32          num = 0;
+    NV_REF         iter = NV_REF_INIT;
+    while(NvNextIndex(NULL, &iter) != 0)
+	num++;
+    return num;
+}
+/* 8.4.5.25 NvCapGetPersistentNumber() */
+/* Function returns the count of persistent objects currently in NV memory. */
+UINT32
+NvCapGetPersistentNumber(
+			 void
+			 )
+{
+    UINT32          num = 0;
+    NV_REF         iter = NV_REF_INIT;
+    TPM_HANDLE      handle;
+    while(NvNextEvict(&handle, &iter) != 0)
+	num++;
+    return num;
+}
+/* 8.4.5.26 NvCapGetPersistentAvail() */
+/* This function returns an estimate of the number of additional persistent objects that could be
+   loaded into NV memory. */
+UINT32
+NvCapGetPersistentAvail(
+			void
+			)
+{
+    UINT32          availNVSpace;
+    UINT32          counterNum = NvCapGetCounterNumber();
+    UINT32          reserved = sizeof(NV_LIST_TERMINATOR);
+    // Get the available space in NV storage
+    availNVSpace = NvGetFreeBytes();
+    if(counterNum < MIN_COUNTER_INDICES)
+	{
+	    // Some space has to be reserved for counter objects.
+	    reserved += (MIN_COUNTER_INDICES - counterNum) * NV_INDEX_COUNTER_SIZE;
+	    if(reserved > availNVSpace)
+		availNVSpace = 0;
+	    else
+		availNVSpace -= reserved;
+	}
+    return availNVSpace / NV_EVICT_OBJECT_SIZE;
+}
+/* 8.4.5.27 NvCapGetCounterNumber() */
+/* Get the number of defined NV Indexes that are counter indexes. */
+UINT32
+NvCapGetCounterNumber(
+		      void
+		      )
+{
+    NV_REF           iter = NV_REF_INIT;
+    NV_REF           currentAddr;
+    UINT32           num = 0;
+    while((currentAddr = NvNextIndex(NULL, &iter)) != 0)
+	{
+	    TPMA_NV             attributes = NvReadNvIndexAttributes(currentAddr);
+	    if(IsNvCounterIndex(attributes))
+		num++;
+	}
+    return num;
+}
+/* 8.4.5.28 NvSetStartupAttributes() */
+/* Local function to set the attributes of an Index at TPM Reset and TPM Restart. */
+static TPMA_NV
+NvSetStartupAttributes(
+		       TPMA_NV         attributes,         // IN: attributes to change
+		       STARTUP_TYPE     type           // IN: start up type
+		       )
+{
+    // Clear read lock
+    CLEAR_ATTRIBUTE(attributes, TPMA_NV, READLOCKED);
+    // Will change a non counter index to the unwritten state if:
+    // a) TPMA_NV_CLEAR_STCLEAR is SET
+    // b) orderly and TPM Reset
+    if(!IsNvCounterIndex(attributes))
+	{
+	    if(IS_ATTRIBUTE(attributes, TPMA_NV, CLEAR_STCLEAR)
+	       || (IS_ATTRIBUTE(attributes, TPMA_NV, ORDERLY)
+		   && (type == SU_RESET)))
+		CLEAR_ATTRIBUTE(attributes, TPMA_NV, WRITTEN);
+	}
+    // Unlock any index that is not written or that does not have
+    // TPMA_NV_WRITEDEFINE SET.
+    if(!IS_ATTRIBUTE(attributes, TPMA_NV, WRITTEN)
+       || !IS_ATTRIBUTE(attributes, TPMA_NV, WRITEDEFINE))
+	CLEAR_ATTRIBUTE(attributes, TPMA_NV, WRITELOCKED);
+    return attributes;
+}
+/* 8.4.5.29 NvEntityStartup() */
+/* This function is called at TPM_Startup(). If the startup completes a TPM Resume cycle, no action
+   is taken. If the startup is a TPM Reset or a TPM Restart, then this function will: */
+/* a) clear read/write lock; */
+/* b) reset NV Index data that has TPMA_NV_CLEAR_STCLEAR SET; and */
+/* c) set the lower bits in orderly counters to 1 for a non-orderly startup */
+/* It is a prerequisite that NV be available for writing before this function is called. */
+BOOL
+NvEntityStartup(
+		STARTUP_TYPE     type           // IN: start up type
+		)
+{
+    NV_REF               iter = NV_REF_INIT;
+    NV_RAM_REF           ramIter = NV_RAM_REF_INIT;
+    NV_REF               currentAddr;        // offset points to the current entity
+    NV_RAM_REF           currentRamAddr;
+    TPM_HANDLE           nvHandle;
+    TPMA_NV              attributes;
+    // Restore RAM index data
+    NvRead(s_indexOrderlyRam, NV_INDEX_RAM_DATA, sizeof(s_indexOrderlyRam));
+    // Initialize the max NV counter value
+    NvSetMaxCount(NvGetMaxCount());
+    // If recovering from state save, do nothing else
+    if(type == SU_RESUME)
+	return TRUE;
+    // Iterate all the NV Index to clear the locks
+    while((currentAddr = NvNextIndex(&nvHandle, &iter)) != 0)
+	{
+	    attributes = NvReadNvIndexAttributes(currentAddr);
+	    // If this is an orderly index, defer processing until loop below
+	    if(IS_ATTRIBUTE(attributes, TPMA_NV, ORDERLY))
+		continue;
+	    // Set the attributes appropriate for this startup type
+	    attributes = NvSetStartupAttributes(attributes, type);
+	    NvWriteNvIndexAttributes(currentAddr, attributes);
+	}
+    // Iterate all the orderly indexes to clear the locks and initialize counters
+    while((currentRamAddr = NvRamNext(&ramIter, NULL)) != 0)
+	{
+	    attributes = NvReadRamIndexAttributes(currentRamAddr);
+	    attributes = NvSetStartupAttributes(attributes, type);
+	    // update attributes in RAM
+	    NvWriteRamIndexAttributes(currentRamAddr, attributes);
+	    // Set the lower bits in an orderly counter to 1 for a non-orderly startup
+	    if(IsNvCounterIndex(attributes)
+	       && (g_prevOrderlyState == SU_NONE_VALUE))
+		{
+		    UINT64      counter;
+		    // Read the counter value last saved to NV.
+		    counter = BYTE_ARRAY_TO_UINT64(currentRamAddr + sizeof(NV_RAM_HEADER));
+		    // Set the lower bits of counter to 1's
+		    counter |= MAX_ORDERLY_COUNT;
+		    // Write back to RAM
+		    // NOTE: Do not want to force a write to NV here. The counter value will
+		    // stay in RAM until the next shutdown or rollover.
+		    UINT64_TO_BYTE_ARRAY(counter, currentRamAddr + sizeof(NV_RAM_HEADER));
+		}
+	}
+    return TRUE;
+}
+/* 8.4.5.30 NvCapGetCounterAvail() */
+/* This function returns an estimate of the number of additional counter type NV Indexes that can be
+   defined. */
+UINT32
+NvCapGetCounterAvail(
+		     void
+		     )
+{
+    UINT32          availNVSpace;
+    UINT32          availRAMSpace;
+    UINT32          persistentNum = NvCapGetPersistentNumber();
+    UINT32          reserved = sizeof(NV_LIST_TERMINATOR);
+    // Get the available space in NV storage
+    availNVSpace = NvGetFreeBytes();
+    if(persistentNum < MIN_EVICT_OBJECTS)
+	{
+	    // Some space has to be reserved for evict object. Adjust availNVSpace.
+	    reserved += (MIN_EVICT_OBJECTS - persistentNum) * NV_EVICT_OBJECT_SIZE;
+	    if(reserved > availNVSpace)
+		availNVSpace = 0;
+	    else
+		availNVSpace -= reserved;
+	}
+    // Compute the available space in RAM
+    availRAMSpace = (RAM_ORDERLY_END - NvRamGetEnd());	/* kgold - removed cast */
+    // Return the min of counter number in NV and in RAM
+    if(availNVSpace / NV_INDEX_COUNTER_SIZE
+       > availRAMSpace / NV_RAM_INDEX_COUNTER_SIZE)
+	return availRAMSpace / NV_RAM_INDEX_COUNTER_SIZE;
+    else
+	return availNVSpace / NV_INDEX_COUNTER_SIZE;
+}
+/* 8.4.5.31 NvFindHandle() */
+/* this function returns the offset in NV memory of the entity associated with the input handle.  A
+   value of zero indicates that handle does not exist reference an existing persistent object or
+   defined NV Index. */
+NV_REF
+NvFindHandle(
+	     TPM_HANDLE       handle
+	     )
+{
+    NV_REF           addr;
+    NV_REF           iter = NV_REF_INIT;
+    TPM_HANDLE       nextHandle;
+    while((addr = NvNext(&iter, &nextHandle)) != 0)
+	{
+	    if(nextHandle == handle)
+		break;
+	}
+    return addr;
+}
+/* 8.4.6 NV Max Counter */
+/* 8.4.6.1 Introduction */
+/* The TPM keeps track of the highest value of a deleted counter index. When an index is deleted,
+   this value is updated if the deleted counter index is greater than the previous value. When a new
+   index is created and first incremented, it will get a value that is at least one greater than any
+   other index than any previously deleted index. This ensures that it is not possible to roll back
+   an index. */
+/* The highest counter value is kept in NV in a special end-of-list marker. This marker is only
+   updated when an index is deleted. Otherwise it just moves. */
+/* When the TPM starts up, it searches NV for the end of list marker and initializes an in memory
+   value (s_maxCounter). */
+/* 8.4.6.2 NvReadMaxCount() */
+/* This function returns the max NV counter value. */
+UINT64
+NvReadMaxCount(
+	       void
+	       )
+{
+    return s_maxCounter;
+}
+/* 8.4.6.3 NvUpdateMaxCount() */
+/* This function updates the max counter value to NV memory. This is just staging for the actual
+   write that will occur when the NV index memory is modified. */
+void
+NvUpdateMaxCount(
+		 UINT64           count
+		 )
+{
+    if(count > s_maxCounter)
+	s_maxCounter = count;
+}
+/* 8.4.6.4 NvSetMaxCount() */
+/* This function is used at NV initialization time to set the initial value of the maximum
+   counter. */
+void
+NvSetMaxCount(
+	      UINT64          value
+	      )
+{
+    s_maxCounter = value;
+}
+/* 8.4.6.5 NvGetMaxCount() */
+/* Function to get the NV max counter value from the end-of-list marker */
+UINT64
+NvGetMaxCount(
+	      void
+	      )
+{
+    NV_REF               iter = NV_REF_INIT;
+    NV_REF               currentAddr;
+    UINT64               maxCount;
+    // Find the end of list marker and initialize the NV Max Counter value.
+    while((currentAddr = NvNext(&iter, NULL )) != 0);
+    // 'iter' should be pointing at the end of list marker so read in the current
+    // value of the s_maxCounter.
+    NvRead(&maxCount, iter + sizeof(UINT32), sizeof(maxCount));
+    return maxCount;
+}