Uses TPM return codes.

vboot_firmware/lib/rollback_index.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  * Functions for querying, manipulating and locking rollback indices
  * stored in the TPM NVRAM.
  */
 
 #include "rollback_index.h"
 
@@ skipping 154 matching lines @@
 
   g_firmware_key_version = firmware_versions >> 16;
   g_firmware_version = firmware_versions && 0xffff;
   g_kernel_key_version = kernel_versions >> 16;
   g_kernel_version = kernel_versions && 0xffff;
 
   return 1;
 }
 
 
-void SetupTPM(void) {
+int SetupTPM(void) {
   uint8_t disable;
   uint8_t deactivated;
   TlclLibinit();
   TlclStartup();
   /* TODO(gauravsh): The call to self test  should probably be deferred.
    * As per semenzato@chromium.org -
    * TlclStartup should be called before the firmware initializes the memory
    * controller, so the selftest can run in parallel with that. Here we should
    * just call TlclSelftestFull to make sure the self test has
    * completed---unless we want to rely on the NVRAM operations being available
    * before the selftest completes. */
   TlclSelftestfull();
   TlclAssertPhysicalPresence();
   /* Check that the TPM is enabled and activated. */
   if(TlclGetFlags(&disable, &deactivated) != TPM_SUCCESS) {
     debug("failed to get TPM flags");
-    EnterRecovery(1);
+    return 1;
   }
   if (disable || deactivated) {
     TlclSetEnable();
     if (TlclSetDeactivated(0) != TPM_SUCCESS) {
       debug("failed to activate TPM");
-      EnterRecovery(1);
+      return 1;
     }
   }
   /* We expect this to fail the first time we run on a device, indicating that
    * the TPM has not been initialized yet. */
   if (!GetTPMRollbackIndices()) {
     debug("failed to get rollback indices");
     if (!InitializeSpaces()) {
       /* If InitializeSpaces() fails (possibly because it had been executed
        * already), something is wrong. */
-      EnterRecovery(1);
+      return 1;
     }
   }
+
+  return 0;
 }
 
-void GetStoredVersions(int type, uint16_t* key_version, uint16_t* version) {
+int GetStoredVersions(int type, uint16_t* key_version, uint16_t* version) {
+
+  /* TODO: should verify that SetupTPM() has been called.  Note that
+   * SetupTPM() does hardware setup AND sets global variables.  When we
+   * get down into kernel verification, the hardware setup persists, but
+   * we don't have access to the global variables.  So I guess we DO need
+   * to call SetupTPM() there, and have it be smart enough not to redo the
+   * hardware init, but it still needs to re-read the flags... */
+
   switch (type) {
     case FIRMWARE_VERSIONS:
       *key_version = g_firmware_key_version;
       *version = g_firmware_version;
       break;
     case KERNEL_VERSIONS:
       *key_version = g_kernel_key_version;
       *version = g_kernel_version;
       break;
   }
+
+  return 0;
 }
 
 int WriteStoredVersions(int type, uint16_t key_version, uint16_t version) {
   uint32_t combined_version = (key_version << 16) & version;
   switch (type) {
     case FIRMWARE_VERSIONS:
-      return (TPM_SUCCESS == TlclWrite(FIRMWARE_VERSIONS_NV_INDEX,
+      return (TPM_SUCCESS != TlclWrite(FIRMWARE_VERSIONS_NV_INDEX,
                                        (uint8_t*) &combined_version,
                                        sizeof(uint32_t)));
-      break;
+
     case KERNEL_VERSIONS:
-      return (TPM_SUCCESS == TlclWrite(KERNEL_VERSIONS_NV_INDEX,
+      return (TPM_SUCCESS != TlclWrite(KERNEL_VERSIONS_NV_INDEX,
                                        (uint8_t*) &combined_version,
                                        sizeof(uint32_t)));
-      break;
   }
   /* TODO(nelson): ForceClear and reboot if unowned. */
 
+  return 1;
+}
+
+int LockFirmwareVersions() {
+  if (TlclSetGlobalLock() != TPM_SUCCESS) {
+    debug("failed to set global lock");
+    return 1;
+  }
   return 0;
 }
 
-void LockFirmwareVersions() {
-  if (TlclSetGlobalLock() != TPM_SUCCESS) {
-    debug("failed to set global lock");
-    EnterRecovery(1);
-  }
-}
-
-void LockKernelVersionsByLockingPP() {
+int LockKernelVersionsByLockingPP() {
   if (TlclLockPhysicalPresence() != TPM_SUCCESS) {
     debug("failed to turn off PP");
-    EnterRecovery(1);
+    return 1;
   }
+  return 0;
 }