Change to the new prototype/name for Get/WriteStoredVersions().

src/platform/vboot_reference/vboot_firmware/lib/load_kernel_fw.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 loading a kernel from disk.
  * (Firmware portion)
  */
 
 #include "load_kernel_fw.h"
 
@@ skipping 91 matching lines @@
   uint16_t lowest_kernel_key_version = 0xFFFF;
   uint16_t lowest_kernel_version = 0xFFFF;
   KernelImage *kim = NULL;
 
   /* Read current kernel key index from TPM.  Assumes TPM is already
    * initialized. */
   /* TODO: Is that a safe assumption?  Normally, SetupTPM() would be called
    * when the RW firmware is verified.  Is it harmful to call SetupTPM()
    * again if it's already initialized?  It'd be easier if we could just do
    * that. */
-  tpm_kernel_key_version = GetStoredVersion(KERNEL_KEY_VERSION);
-  tpm_kernel_version = GetStoredVersion(KERNEL_VERSION);
-
+  GetStoredVersions(KERNEL_VERSIONS,
+                    &tpm_kernel_key_version,
+                    &tpm_kernel_version);
   do {
     /* Read GPT data */
     gpt.sector_bytes = blba;
     gpt.drive_sectors = params->ending_lba + 1;
     if (0 != AllocAndReadGptData(&gpt))
       break;
 
     /* Initialize GPT library */
     if (GPT_SUCCESS != GptInit(&gpt))
       break;
@@ skipping 109 matching lines @@
   if (kim)
     Free(kim);
 
   // Write and free GPT data
   WriteAndFreeGptData(&gpt);
 
   // Handle finding a good partition
   if (good_partition >= 0) {
 
     /* See if we need to update the TPM */
-    if (lowest_kernel_key_version > tpm_kernel_key_version) {
-      WriteStoredVersion(KERNEL_KEY_VERSION, lowest_kernel_key_version);
-      WriteStoredVersion(KERNEL_VERSION, lowest_kernel_version);
-    }
-    else if (lowest_kernel_key_version == tpm_kernel_key_version &&
-             lowest_kernel_version > tpm_kernel_version) {
-      WriteStoredVersion(KERNEL_VERSION, lowest_kernel_version);
+    if ((lowest_kernel_key_version > tpm_kernel_key_version) ||
+        (lowest_kernel_key_version == tpm_kernel_key_version &&
+         lowest_kernel_version > tpm_kernel_version)) {
+      WriteStoredVersions(KERNEL_VERSIONS,
+                          lowest_kernel_key_version,
+                          lowest_kernel_version);
     }
 
     if (BOOT_MODE_RECOVERY != params->boot_mode) {
       /* We can lock the TPM now, since we've decided which kernel we
        * like.  If we don't find a good kernel, we leave the TPM
        * unlocked so we can try again on the next boot device.  If no
        * kernels are good, we'll reboot to recovery mode, so it's ok to
        * leave the TPM unlocked in that case too.
        *
        * If we're already in recovery mode, we need to leave PP unlocked,
        * so don't lock the kernel versions. */
       LockKernelVersionsByLockingPP();
     }
 
     /* Success! */
     return LOAD_KERNEL_SUCCESS;
   }
 
   // Handle error cases
   if (found_partition)
     return LOAD_KERNEL_INVALID;
   else
     return LOAD_KERNEL_NOT_FOUND;
   /* TODO: no error code for "internal error", but what would the firmware do
    * with that anyway?  So in the do-while(0) code above, the firmware just
    * does 'break' to indicate an internal error... */
 }