Pass VbSharedData between LoadFirmware() and LoadKernel()

firmware/lib/vboot_kernel.c

-/* Copyright (c) 2010-2011 The Chromium OS Authors. All rights reserved.
+/* Copyright (c) 2011 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 "vboot_kernel.h"
 
 #include "boot_device.h"
 #include "cgptlib.h"
 #include "cgptlib_internal.h"
+#include "gbb_header.h"
 #include "load_kernel_fw.h"
 #include "rollback_index.h"
 #include "utility.h"
 #include "vboot_common.h"
 
 #define KBUF_SIZE 65536  /* Bytes to read at start of kernel partition */
 
 typedef enum BootMode {
   kBootNormal,   /* Normal firmware */
   kBootDev,      /* Dev firmware AND dev switch is on */
@@ skipping 87 matching lines @@
   }
 
   /* Success */
   return 0;
 }
 
 /* disable MSVC warning on const logical expression (as in } while(0);) */
 __pragma(warning(disable: 4127))
 
 int LoadKernel(LoadKernelParams* params) {
+  VbSharedDataHeader* shared = (VbSharedDataHeader*)params->shared_data_blob;
   VbNvContext* vnc = params->nv_context;
+  GoogleBinaryBlockHeader* gbb = (GoogleBinaryBlockHeader*)params->gbb_data;
   VbPublicKey* kernel_subkey;
   GptData gpt;
   uint64_t part_start, part_size;
   uint64_t blba;
   uint64_t kbuf_sectors;
   uint8_t* kbuf = NULL;
   int found_partitions = 0;
   int good_partition = -1;
   int good_partition_key_block_valid = 0;
   uint32_t tpm_version = 0;
@@ skipping 15 matching lines @@
   if (!params ||
       !params->bytes_per_lba ||
       !params->ending_lba ||
       !params->kernel_buffer ||
       !params->kernel_buffer_size) {
     VBDEBUG(("LoadKernel() called with invalid params\n"));
     goto LoadKernelExit;
   }
 
   /* Initialization */
-  kernel_subkey = (VbPublicKey*)params->header_sign_key_blob;
   blba = params->bytes_per_lba;
   kbuf_sectors = KBUF_SIZE / blba;
   if (0 == kbuf_sectors) {
     VBDEBUG(("LoadKernel() called with sector size > KBUF_SIZE\n"));
     goto LoadKernelExit;
   }
 
   rec_switch = (BOOT_FLAG_RECOVERY & params->boot_flags ? 1 : 0);
   dev_switch = (BOOT_FLAG_DEVELOPER & params->boot_flags ? 1 : 0);
 
@@ skipping 12 matching lines @@
     /* Normal firmware */
     boot_mode = kBootNormal;
     dev_switch = 0;  /* Always do a fully verified boot */
   }
 
   /* Clear output params in case we fail */
   params->partition_number = 0;
   params->bootloader_address = 0;
   params->bootloader_size = 0;
 
-  /* Let the TPM know if we're in recovery mode */
   if (kBootRecovery == boot_mode) {
+    /* Initialize the shared data structure, since LoadFirmware() didn't do it
+     * for us. */
+    if (0 != VbSharedDataInit(shared, params->shared_data_size)) {
+      /* Error initializing the shared data, but we can keep going.  We just
+       * can't use the shared data. */
+      VBDEBUG(("Shared data init error\n"));
+      params->shared_data_size = 0;
+      shared = NULL;
+    }
+
+    /* Use the recovery key to verify the kernel */
+    kernel_subkey = (VbPublicKey*)((uint8_t*)gbb + gbb->recovery_key_offset);
+
+    /* Let the TPM know if we're in recovery mode */
     if (0 != RollbackKernelRecovery(dev_switch)) {
       VBDEBUG(("Error setting up TPM for recovery kernel\n"));
       /* Ignore return code, since we need to boot recovery mode to
        * fix the TPM. */
     }
   } else {
+    /* Use the kernel subkey passed from LoadFirmware(). */
+    kernel_subkey = &shared->kernel_subkey;
+
     /* Read current kernel key index from TPM.  Assumes TPM is already
      * initialized. */
     status = RollbackKernelRead(&tpm_version);
     if (0 != status) {
       VBDEBUG(("Unable to get kernel versions from TPM\n"));
       if (status == TPM_E_MUST_REBOOT)
         retval = LOAD_KERNEL_REBOOT;
       else
         recovery = VBNV_RECOVERY_RW_TPM_ERROR;
       goto LoadKernelExit;
@@ skipping 290 matching lines @@
 LoadKernelExit:
 
   /* Save whether the good partition's key block was fully verified */
   VbNvSet(vnc, VBNV_FW_VERIFIED_KERNEL_KEY, good_partition_key_block_valid);
 
   /* Store recovery request, if any, then tear down non-volatile storage */
   VbNvSet(vnc, VBNV_RECOVERY_REQUEST, LOAD_KERNEL_RECOVERY == retval ?
           recovery : VBNV_RECOVERY_NOT_REQUESTED);
   VbNvTeardown(vnc);
 
+  /* Store how much shared data we used, if any */
+  if (shared)
+    params->shared_data_size = shared->data_used;
+
   return retval;
 }