Add VBDEBUG macro for debug output.

firmware/lib/vboot_kernel.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 "vboot_kernel.h"
 
@@ skipping 49 matching lines @@
 /* Writes any changes for the GPT data back to the drive, then frees
  * the buffers.
  *
  * Returns 0 if successful, 1 if error. */
 int WriteAndFreeGptData(GptData* gptdata) {
 
   uint64_t entries_sectors = TOTAL_ENTRIES_SIZE / gptdata->sector_bytes;
 
   if (gptdata->primary_header) {
     if (gptdata->modified & GPT_MODIFIED_HEADER1) {
-      debug("Updating GPT header 1\n");
+      VBDEBUG(("Updating GPT header 1\n"));
       if (0 != BootDeviceWriteLBA(1, 1, gptdata->primary_header))
         return 1;
     }
     Free(gptdata->primary_header);
   }
 
   if (gptdata->primary_entries) {
     if (gptdata->modified & GPT_MODIFIED_ENTRIES1) {
-      debug("Updating GPT entries 1\n");
+      VBDEBUG(("Updating GPT entries 1\n"));
       if (0 != BootDeviceWriteLBA(2, entries_sectors,
                                   gptdata->primary_entries))
         return 1;
     }
     Free(gptdata->primary_entries);
   }
 
   if (gptdata->secondary_entries) {
     if (gptdata->modified & GPT_MODIFIED_ENTRIES2) {
-      debug("Updating GPT header 2\n");
+      VBDEBUG(("Updating GPT header 2\n"));
       if (0 != BootDeviceWriteLBA(gptdata->drive_sectors - entries_sectors - 1,
                                   entries_sectors, gptdata->secondary_entries))
         return 1;
     }
     Free(gptdata->secondary_entries);
   }
 
   if (gptdata->secondary_header) {
     if (gptdata->modified & GPT_MODIFIED_HEADER2) {
-      debug("Updating GPT entries 2\n");
+      VBDEBUG(("Updating GPT entries 2\n"));
       if (0 != BootDeviceWriteLBA(gptdata->drive_sectors - 1, 1,
                                   gptdata->secondary_header))
         return 1;
     }
     Free(gptdata->secondary_header);
   }
 
   /* Success */
   return 0;
 }
@@ skipping 21 matching lines @@
 
   /* 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 (BOOT_FLAG_RECOVERY & params->boot_flags) {
     if (0 != RollbackKernelRecovery(BOOT_FLAG_DEVELOPER & params->boot_flags
                                     ? 1 : 0)) {
-      debug("Error setting up TPM for recovery kernel\n");
+      VBDEBUG(("Error setting up TPM for recovery kernel\n"));
       return LOAD_KERNEL_RECOVERY;
     }
   }
 
   if (is_normal) {
     /* Read current kernel key index from TPM.  Assumes TPM is already
      * initialized. */
     if (0 != RollbackKernelRead(&tpm_key_version, &tpm_kernel_version)) {
-      debug("Unable to get kernel versions from TPM\n");
+      VBDEBUG(("Unable to get kernel versions from TPM\n"));
       return LOAD_KERNEL_RECOVERY;
     }
   } else if (is_dev) {
     /* In developer mode, we ignore the kernel subkey, and just use
      * the SHA-512 hash to verify the key block. */
     kernel_subkey = NULL;
   }
 
   do {
     /* Read GPT data */
     gpt.sector_bytes = (uint32_t)blba;
     gpt.drive_sectors = params->ending_lba + 1;
     if (0 != AllocAndReadGptData(&gpt)) {
-      debug("Unable to read GPT data\n");
+      VBDEBUG(("Unable to read GPT data\n"));
       break;
     }
 
     /* Initialize GPT library */
     if (GPT_SUCCESS != GptInit(&gpt)) {
-      debug("Error parsing GPT\n");
+      VBDEBUG(("Error parsing GPT\n"));
       break;
     }
 
     /* Allocate kernel header buffers */
     kbuf = (uint8_t*)Malloc(KBUF_SIZE);
     if (!kbuf)
       break;
 
     /* Loop over candidate kernel partitions */
     while (GPT_SUCCESS == GptNextKernelEntry(&gpt, &part_start, &part_size)) {
       VbKeyBlockHeader* key_block;
       VbKernelPreambleHeader* preamble;
       RSAPublicKey* data_key;
       uint64_t key_version;
       uint64_t body_offset;
 
-      debug("Found kernel entry at %" PRIu64 " size %" PRIu64 "\n",
-            part_start, part_size);
+      VBDEBUG(("Found kernel entry at %" PRIu64 " size %" PRIu64 "\n",
+              part_start, part_size));
 
       /* Found at least one kernel partition. */
       found_partitions++;
 
       /* Read the first part of the kernel partition  */
       if (part_size < kbuf_sectors)
         continue;
       if (0 != BootDeviceReadLBA(part_start, kbuf_sectors, kbuf))
         continue;
 
       /* Verify the key block */
       key_block = (VbKeyBlockHeader*)kbuf;
       if ((0 != KeyBlockVerify(key_block, KBUF_SIZE, kernel_subkey))) {
-        debug("Verifying key block failed.\n");
+        VBDEBUG(("Verifying key block failed.\n"));
         continue;
       }
 
       /* Check the key block flags against the current boot mode */
       if (!(key_block->key_block_flags &&
             ((BOOT_FLAG_DEVELOPER & params->boot_flags) ?
              KEY_BLOCK_FLAG_DEVELOPER_1 : KEY_BLOCK_FLAG_DEVELOPER_0))) {
-        debug("Developer flag mismatch.\n");
+        VBDEBUG(("Developer flag mismatch.\n"));
         continue;
       }
       if (!(key_block->key_block_flags &&
             ((BOOT_FLAG_RECOVERY & params->boot_flags) ?
              KEY_BLOCK_FLAG_RECOVERY_1 : KEY_BLOCK_FLAG_RECOVERY_0))) {
-        debug("Recovery flag mismatch.\n");
+        VBDEBUG(("Recovery flag mismatch.\n"));
         continue;
       }
 
       /* Check for rollback of key version.  Note this is implicitly
        * skipped in recovery and developer modes because those set
        * key_version=0 above. */
       key_version = key_block->data_key.key_version;
       if (key_version < tpm_key_version) {
-        debug("Key version too old.\n");
+        VBDEBUG(("Key version too old.\n"));
         continue;
       }
 
       /* Get the key for preamble/data verification from the key block */
       data_key = PublicKeyToRSA(&key_block->data_key);
       if (!data_key)
         continue;
 
       /* Verify the preamble, which follows the key block */
       preamble = (VbKernelPreambleHeader*)(kbuf + key_block->key_block_size);
       if ((0 != VerifyKernelPreamble2(preamble,
                                      KBUF_SIZE - key_block->key_block_size,
                                      data_key))) {
-        debug("Preamble verification failed.\n");
+        VBDEBUG(("Preamble verification failed.\n"));
         RSAPublicKeyFree(data_key);
         continue;
       }
 
       /* Check for rollback of kernel version.  Note this is implicitly
        * skipped in recovery and developer modes because those set
        * key_version=0 and kernel_version=0 above. */
       if (key_version == tpm_key_version &&
           preamble->kernel_version < tpm_kernel_version) {
-        debug("Kernel version too low.\n");
+        VBDEBUG(("Kernel version too low.\n"));
         RSAPublicKeyFree(data_key);
         continue;
       }
 
-      debug("Kernel preamble is good.\n");
+      VBDEBUG(("Kernel preamble is good.\n"));
 
       /* Check for lowest key version from a valid header. */
       if (lowest_key_version > key_version) {
         lowest_key_version = key_version;
         lowest_kernel_version = preamble->kernel_version;
       }
       else if (lowest_key_version == key_version &&
                lowest_kernel_version > preamble->kernel_version) {
         lowest_kernel_version = preamble->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 body load address matches what we expect */
       if ((preamble->body_load_address != (size_t)params->kernel_buffer) &&
           !(params->boot_flags & BOOT_FLAG_SKIP_ADDR_CHECK)) {
-        debug("Wrong body load address.\n");
+        VBDEBUG(("Wrong body load address.\n"));
         RSAPublicKeyFree(data_key);
         continue;
       }
 
       /* Verify kernel body starts at a multiple of the sector size. */
       body_offset = key_block->key_block_size + preamble->preamble_size;
       if (0 != body_offset % blba) {
-        debug("Kernel body not at multiple of sector size.\n");
+        VBDEBUG(("Kernel body not at multiple of sector size.\n"));
         RSAPublicKeyFree(data_key);
         continue;
       }
 
       /* Verify kernel body fits in the partition */
       if (body_offset + preamble->body_signature.data_size >
           part_size * blba) {
-        debug("Kernel body doesn't fit in partition.\n");
+        VBDEBUG(("Kernel body doesn't fit in partition.\n"));
         RSAPublicKeyFree(data_key);
         continue;
       }
 
       /* Read the kernel data */
       if (0 != BootDeviceReadLBA(
               part_start + (body_offset / blba),
               (preamble->body_signature.data_size + blba - 1) / blba,
               params->kernel_buffer)) {
-        debug("Unable to read kernel data.\n");
+        VBDEBUG(("Unable to read kernel data.\n"));
         RSAPublicKeyFree(data_key);
         continue;
       }
 
       /* Verify kernel data */
       if (0 != VerifyData((const uint8_t*)params->kernel_buffer,
                           &preamble->body_signature, data_key)) {
-        debug("Kernel data verification failed.\n");
+        VBDEBUG(("Kernel data verification failed.\n"));
         RSAPublicKeyFree(data_key);
         continue;
       }
 
       /* Done with the kernel signing key, so can free it now */
       RSAPublicKeyFree(data_key);
 
       /* If we're still here, the kernel is valid. */
       /* Save the first good partition we find; that's the one we'll boot */
-      debug("Partiton is good.\n");
+      VBDEBUG(("Partiton is good.\n"));
       /* TODO: GPT partitions start at 1, but cgptlib starts them at 0.
        * Adjust here, until cgptlib is fixed. */
       good_partition = gpt.current_kernel + 1;
       params->partition_number = gpt.current_kernel + 1;
       params->bootloader_address = preamble->bootloader_address;
       params->bootloader_size = preamble->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 (!is_normal) {
-        debug("Boot_flags = !is_normal\n");
+        VBDEBUG(("Boot_flags = !is_normal\n"));
         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 (key_version == tpm_key_version &&
           preamble->kernel_version == tpm_kernel_version) {
-        debug("Same key version\n");
+        VBDEBUG(("Same key version\n"));
         break;
       }
     } /* while(GptNextKernelEntry) */
   } while(0);
 
   /* Free kernel buffer */
   if (kbuf)
     Free(kbuf);
 
   /* Write and free GPT data */
   WriteAndFreeGptData(&gpt);
 
   /* Handle finding a good partition */
   if (good_partition >= 0) {
-    debug("Good_partition >= 0\n");
+    VBDEBUG(("Good_partition >= 0\n"));
 
     /* See if we need to update the TPM */
     if (is_normal) {
       /* We only update the TPM in normal boot mode.  In developer
        * mode, the kernel is self-signed by the developer, so we can't
        * trust the key version and wouldn't want to roll the TPM
        * forward.  In recovery mode, the TPM stays PP-unlocked, so
        * anything we write gets blown away by the firmware when we go
        * back to normal mode. */
-      debug("Boot_flags = is_normal\n");
+      VBDEBUG(("Boot_flags = is_normal\n"));
       if ((lowest_key_version > tpm_key_version) ||
           (lowest_key_version == tpm_key_version &&
            lowest_kernel_version > tpm_kernel_version)) {
         if (0 != RollbackKernelWrite((uint16_t)lowest_key_version,
                                      (uint16_t)lowest_kernel_version)) {
-          debug("Error writing kernel versions to TPM.\n");
+          VBDEBUG(("Error writing kernel versions to TPM.\n"));
           return LOAD_KERNEL_RECOVERY;
         }
       }
     }
 
     /* Lock the kernel versions, since we're about to boot the kernel */
     if (0 != RollbackKernelLock()) {
-      debug("Error locking kernel versions.\n");
+      VBDEBUG(("Error locking kernel versions.\n"));
       return LOAD_KERNEL_RECOVERY;
     }
 
     /* Success! */
     return LOAD_KERNEL_SUCCESS;
   }
 
   // Handle error cases
   if (found_partitions)
     return LOAD_KERNEL_INVALID;
   else
     return LOAD_KERNEL_NOT_FOUND;
 }