Major refactoring of structures, with unit tests.

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 146 matching lines @@
   uint64_t part_start, part_size;
   uint64_t blba = params->bytes_per_lba;
   uint8_t* kbuf = NULL;
   uint64_t kbuf_sectors;
   int found_partition = 0;
   int good_partition = -1;
   uint16_t tpm_kernel_key_version, tpm_kernel_version;
   uint16_t lowest_kernel_key_version = 0xFFFF;
   uint16_t lowest_kernel_version = 0xFFFF;
   KernelImage *kim = NULL;
+  int is_dev = ((BOOT_FLAG_DEVELOPER & params->boot_flags) &&
+                !(BOOT_FLAG_RECOVERY & params->boot_flags));
+  int is_normal = (!(BOOT_FLAG_DEVELOPER & params->boot_flags) &&
+                !(BOOT_FLAG_RECOVERY & params->boot_flags));
 
   /* Clear output params in case we fail */
   params->partition_number = 0;
   params->bootloader_address = 0;
   params->bootloader_size = 0;
 
-  if (BOOT_MODE_NORMAL == params->boot_mode) {
+  if (is_normal) {
     /* Read current kernel key index from TPM.  Assumes TPM is already
      * initialized. */
    if (0 != GetStoredVersions(KERNEL_VERSIONS,
                                &tpm_kernel_key_version,
                                &tpm_kernel_version))
       return LOAD_KERNEL_RECOVERY;
   }
 
   do {
     /* Read GPT data */
@@ skipping 31 matching lines @@
       if (part_size < kbuf_sectors)
         continue;
       if (0 != BootDeviceReadLBA(part_start, kbuf_sectors, kbuf))
         continue;
 
       /* Verify the kernel header and preamble */
       if (VERIFY_KERNEL_SUCCESS != VerifyKernelHeader(
               params->header_sign_key_blob,
               kbuf,
               KBUF_SIZE,
-              (BOOT_MODE_DEVELOPER == params->boot_mode ? 1 : 0),
+              (is_dev ? 1 : 0),
               kim,
               &kernel_sign_key)) {
         continue;
       }
 
 #ifdef PRINT_DEBUG_INFO
       printf("Kernel header:\n");
       printf("header version:     %d\n", kim->header_version);
       printf("header len:         %d\n", kim->header_len);
       printf("firmware sign alg:  %d\n", kim->firmware_sign_algorithm);
@@ skipping 22 matching lines @@
       /* Check for lowest key version from a valid header. */
       if (lowest_kernel_key_version > kim->kernel_key_version) {
         lowest_kernel_key_version = kim->kernel_key_version;
         lowest_kernel_version = kim->kernel_version;
       }
       else if (lowest_kernel_key_version == kim->kernel_key_version &&
                lowest_kernel_version > kim->kernel_version) {
         lowest_kernel_version = kim->kernel_version;
       }
 
+      /* If we already have a good kernel, no need to read another
+       * one; we only needed to look at the versions to check for
+       * rollback. */
+      if (-1 != good_partition)
+        continue;
+
       /* Verify kernel padding is a multiple of sector size. */
       if (0 != kim->padded_header_size % blba) {
         RSAPublicKeyFree(kernel_sign_key);
         continue;
       }
 
       kernel_start = part_start + (kim->padded_header_size / blba);
       kernel_sectors = (kim->kernel_len + blba - 1) / blba;
 
       /* Read the kernel data */
@@ skipping 19 matching lines @@
       /* If we're still here, the kernel is valid. */
       /* Save the first good partition we find; that's the one we'll boot */
       if (-1 == good_partition) {
         good_partition = gpt.current_kernel;
         params->partition_number = gpt.current_kernel;
         params->bootloader_address = kim->bootloader_offset;
         params->bootloader_size = kim->bootloader_size;
 
         /* If we're in developer or recovery mode, there's no rollback
          * protection, so we can stop at the first valid kernel. */
-        if (BOOT_MODE_NORMAL != params->boot_mode)
+        if (!is_normal)
           break;
 
         /* Otherwise, we're in normal boot mode, so we do care about
          * the key index in the TPM.  If the good partition's key
          * version is the same as the tpm, then the TPM doesn't need
          * updating; we can stop now.  Otherwise, we'll check all the
          * other headers to see if they contain a newer key. */
         if (kim->kernel_key_version == tpm_kernel_key_version &&
             kim->kernel_version == tpm_kernel_version)
           break;
       }
     } /* while(GptNextKernelEntry) */
   } while(0);
 
   /* Free kernel work and image buffers */
   if (kbuf)
     Free(kbuf);
   if (kim)
     Free(kim);
 
   /* Write and free GPT data */
   WriteAndFreeGptData(&gpt);
 
   /* Handle finding a good partition */
   if (good_partition >= 0) {
 
-    if (BOOT_MODE_NORMAL == params->boot_mode) {
+    if (is_normal) {
       /* See if we need to update the TPM, for normal boot mode only. */
       if ((lowest_kernel_key_version > tpm_kernel_key_version) ||
           (lowest_kernel_key_version == tpm_kernel_key_version &&
            lowest_kernel_version > tpm_kernel_version)) {
         if (0 != WriteStoredVersions(KERNEL_VERSIONS,
                                      lowest_kernel_key_version,
                                      lowest_kernel_version))
           return LOAD_KERNEL_RECOVERY;
       }
     }
 
-    if (BOOT_MODE_RECOVERY != params->boot_mode) {
+    if (!(BOOT_FLAG_RECOVERY & params->boot_flags)) {
       /* 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. */
       if (0 != LockKernelVersionsByLockingPP())
         return LOAD_KERNEL_RECOVERY;
     }
 
     /* Success! */
     return LOAD_KERNEL_SUCCESS;
   }
 
   /* Handle error cases */
   if (found_partition)
     return LOAD_KERNEL_INVALID;
   else
     return LOAD_KERNEL_NOT_FOUND;
 }