Change rollback interface so kernel/firmware version numbers are

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 253 matching lines @@
 }
 
 /* disable MSVC warnings on unused arguments */
 __pragma(warning (disable: 4100))
 
 
 #ifdef DISABLE_ROLLBACK_TPM
 
 /* Dummy implementations which don't support TPM rollback protection */
 
-uint32_t RollbackFirmwareSetup(int developer_mode,
-                               uint16_t* key_version, uint16_t* version) {
+uint32_t RollbackFirmwareSetup(int developer_mode, uint32_t* version) {
 #ifndef CHROMEOS_ENVIRONMENT
   /* Initialize the TPM, but ignore return codes.  In ChromeOS
    * environment, don't even talk to the TPM. */
   TlclLibInit();
   TlclStartup();
   TlclSelfTestFull();
 #endif
 
-  *key_version = *version = 0;
+  *version = 0;
   return TPM_SUCCESS;
 }
 
-uint32_t RollbackFirmwareWrite(uint16_t key_version, uint16_t version) {
+uint32_t RollbackFirmwareWrite(uint32_t version) {
   return TPM_SUCCESS;
 }
 
 uint32_t RollbackFirmwareLock(void) {
   return TPM_SUCCESS;
 }
 
 uint32_t RollbackKernelRecovery(int developer_mode) {
 #ifndef CHROMEOS_ENVIRONMENT
   /* Initialize the TPM, but ignore return codes.  In ChromeOS
    * environment, don't even talk to the TPM. */
   TlclLibInit();
   TlclStartup();
   TlclSelfTestFull();
 #endif
   return TPM_SUCCESS;
 }
 
-uint32_t RollbackKernelRead(uint16_t* key_version, uint16_t* version) {
-  *key_version = *version = 0;
+uint32_t RollbackKernelRead(uint32_t* version) {
+  *version = 0;
   return TPM_SUCCESS;
 }
 
-uint32_t RollbackKernelWrite(uint16_t key_version, uint16_t version) {
+uint32_t RollbackKernelWrite(uint32_t version) {
   return TPM_SUCCESS;
 }
 
 uint32_t RollbackKernelLock(void) {
   return TPM_SUCCESS;
 }
 
 #else
 
-uint32_t RollbackFirmwareSetup(int developer_mode, uint16_t* key_version,
-                               uint16_t* version) {
+uint32_t RollbackFirmwareSetup(int developer_mode, uint32_t* version) {
   RollbackSpaceFirmware rsf;
 
   RETURN_ON_FAILURE(SetupTPM(0, developer_mode, &rsf));
-  *key_version = (uint16_t)(rsf.fw_versions >> 16);
-  *version = (uint16_t)(rsf.fw_versions & 0xffff);
-
-  VBDEBUG(("TPM: RollbackFirmwareSetup %x %x %x\n", (int)rsf.fw_versions, (int)*key_version, (int)*version));
-
+  *version = rsf.fw_versions;
+  VBDEBUG(("TPM: RollbackFirmwareSetup %x %x %x\n", (int)rsf.fw_versions));
   return TPM_SUCCESS;
 }
 
-uint32_t RollbackFirmwareWrite(uint16_t key_version, uint16_t version) {
+uint32_t RollbackFirmwareWrite(uint32_t version) {
   RollbackSpaceFirmware rsf;
-  uint32_t new_versions = ((uint32_t)key_version << 16) | version;
-
-  VBDEBUG(("TPM: RollbackFirmwareWrite(%d, %d)\n", (int)key_version, (int)version));
 
   RETURN_ON_FAILURE(ReadSpaceFirmware(&rsf));
-  VBDEBUG(("TPM: RollbackFirmwareWrite %x --> %x\n", (int)rsf.fw_versions, (int)new_versions));
-  rsf.fw_versions = new_versions;
+  VBDEBUG(("TPM: RollbackFirmwareWrite %x --> %x\n", (int)rsf.fw_versions,
+           (int)version));
+  rsf.fw_versions = version;
   return WriteSpaceFirmware(&rsf);
 }
 
 uint32_t RollbackFirmwareLock(void) {
   return TlclSetGlobalLock();
 }
 
 uint32_t RollbackKernelRecovery(int developer_mode) {
   RollbackSpaceFirmware rsf;
   uint32_t result = SetupTPM(1, developer_mode, &rsf);
   /* In recovery mode we ignore TPM malfunctions or corruptions, and leave the
    * TPM completely unlocked if and only if the dev mode switch is ON.  The
    * recovery kernel will fix the TPM (if needed) and lock it ASAP.  We leave
    * Physical Presence on in either case. */
   if (!developer_mode) {
     RETURN_ON_FAILURE(TlclSetGlobalLock());
   }
   /* We still return the result of SetupTPM even though we expect the caller to
    * ignore it.  It's useful in unit testing. */
   return result;
 }
 
-uint32_t RollbackKernelRead(uint16_t* key_version, uint16_t* version) {
+uint32_t RollbackKernelRead(uint32_t* version) {
   if (g_rollback_recovery_mode) {
-    *key_version = 0;
     *version = 0;
   } else {
     RollbackSpaceKernel rsk;
     RETURN_ON_FAILURE(ReadSpaceKernel(&rsk));
-    *key_version = (uint16_t)(rsk.kernel_versions >> 16);
-    *version = (uint16_t)(rsk.kernel_versions & 0xffff);
-    VBDEBUG(("TPM: RollbackKernelRead %x %x %x\n", (int)rsk.kernel_versions,
-             (int)*key_version, (int)*version));
+    *version = rsk.kernel_versions;
+    VBDEBUG(("TPM: RollbackKernelRead %x\n", (int)rsk.kernel_versions));
   }
   return TPM_SUCCESS;
 }
 
-uint32_t RollbackKernelWrite(uint16_t key_version, uint16_t version) {
-
-  VBDEBUG(("TPM: RollbackKernelWrite(%d, %d)\n", (int)key_version,
-           (int)version));
-
+uint32_t RollbackKernelWrite(uint32_t version) {
   if (g_rollback_recovery_mode) {
     return TPM_SUCCESS;
   } else {
     RollbackSpaceKernel rsk;
-    uint32_t new_versions = ((uint32_t)key_version << 16) | version;
-
     RETURN_ON_FAILURE(ReadSpaceKernel(&rsk));
     VBDEBUG(("TPM: RollbackKernelWrite %x --> %x\n", (int)rsk.kernel_versions,
-             (int)new_versions));
-    rsk.kernel_versions = new_versions;
+             (int)version));
+    rsk.kernel_versions = version;
     return WriteSpaceKernel(&rsk);
   }
 }
 
 uint32_t RollbackKernelLock(void) {
   if (g_rollback_recovery_mode) {
     return TPM_SUCCESS;
   } else {
     return TlclLockPhysicalPresence();
   }
 }
 
 #endif // DISABLE_ROLLBACK_TPM