Add some debug output to vbutil_kernel, display values in hex.

utility/vbutil_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.
  *
  * Verified boot kernel utility
  */
 
 #include <getopt.h>
 #include <inttypes.h>  /* For PRIu64 */
+#include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #include "cryptolib.h"
 #include "host_common.h"
 #include "kernel_blob.h"
 #include "vboot_common.h"
 
 
+/* Global opt */
+static int opt_debug = 0;
+
+
 /* Command line options */
 enum {
   OPT_MODE_PACK = 1000,
   OPT_MODE_VERIFY,
   OPT_KEYBLOCK,
   OPT_SIGNPUBKEY,
   OPT_SIGNPRIVATE,
   OPT_VERSION,
   OPT_VMLINUZ,
   OPT_BOOTLOADER,
   OPT_CONFIG,
   OPT_PAD,
 };
 
 static struct option long_opts[] = {
   {"pack", 1, 0,                      OPT_MODE_PACK               },
   {"verify", 1, 0,                    OPT_MODE_VERIFY             },
   {"keyblock", 1, 0,                  OPT_KEYBLOCK                },
   {"signpubkey", 1, 0,                OPT_SIGNPUBKEY              },
   {"signprivate", 1, 0,               OPT_SIGNPRIVATE             },
   {"version", 1, 0,                   OPT_VERSION                 },
   {"vmlinuz", 1, 0,                   OPT_VMLINUZ                 },
   {"bootloader", 1, 0,                OPT_BOOTLOADER              },
   {"config", 1, 0,                    OPT_CONFIG                  },
   {"pad", 1, 0,                       OPT_PAD                     },
+  {"debug", 0, &opt_debug, 1                                      },
   {NULL, 0, 0, 0}
 };
 
 
 /* Print help and return error */
 static int PrintHelp(void) {
 
   puts("vbutil_kernel - Verified boot key block utility\n"
        "\n"
        "Usage:  vbutil_kernel <--pack|--verify> <file> [OPTIONS]\n"
        "\n"
        "For '--pack <file>', required OPTIONS are:\n"
        "  --keyblock <file>           Key block in .keyblock format\n"
        "  --signprivate <file>        Signing private key in .pem format\n"
        "  --version <number>          Kernel version\n"
        "  --vmlinuz <file>            Linux kernel image\n"
        "  --bootloader <file>         Bootloader stub\n"
        "  --config <file>             Config file\n"
        "Optional OPTIONS are:\n"
        "  --pad <number>              Padding size in bytes\n"
        "\n"
        "For '--verify <file>', required OPTIONS are:\n"
        "  --signpubkey <file>         Signing public key in .vbpubk format\n"
        "");
   return 1;
 }
 
+static void Debug(const char *format, ...) {
+  if (!opt_debug)
+    return;
+
+  va_list ap;
+  va_start(ap, format);
+  fprintf(stderr, "DEBUG: ");
+  vfprintf(stderr, format, ap);
+  va_end(ap);
+}
+
 
 /* Return the smallest integral multiple of [alignment] that is equal
  * to or greater than [val]. Used to determine the number of
  * pages/sectors/blocks/whatever needed to contain [val]
  * items/bytes/etc. */
 static uint64_t roundup(uint64_t val, uint64_t alignment) {
   uint64_t rem = val % alignment;
   if ( rem )
     return val + (alignment - rem);
   return val;
@@ skipping 75 matching lines @@
     return 1;
   }
 
   signing_key = PrivateKeyRead(signprivate, key_block->data_key.algorithm);
   if (!signing_key) {
     error("Error reading signing key.\n");
     return 1;
   }
 
   /* Read the config file */
+  Debug("Reading %s\n", config_file);
   config_buf = ReadFile(config_file, &config_size);
   if (!config_buf)
     return 1;
+  Debug(" config file size=0x%" PRIx64 "\n", config_size);
   if (CROS_CONFIG_SIZE <= config_size) {  /* need room for trailing '\0' */
     error("Config file %s is too large (>= %d bytes)\n",
           config_file, CROS_CONFIG_SIZE);
     return 1;
   }
   /* Replace newlines with spaces */
   for (i = 0; i < config_size; i++)
     if ('\n' == config_buf[i])
       config_buf[i] = ' ';
 
   /* Read the bootloader */
+  Debug("Reading %s\n", bootloader_file);
   bootloader_buf = ReadFile(bootloader_file, &bootloader_size);
   if (!bootloader_buf)
     return 1;
+  Debug(" bootloader file size=0x%" PRIx64 "\n", bootloader_size);
 
   /* Read the kernel */
+  Debug("Reading %s\n", vmlinuz);
   kernel_buf = ReadFile(vmlinuz, &kernel_size);
   if (!kernel_buf)
     return 1;
+  Debug(" kernel file size=0x%" PRIx64 "\n", kernel_size);
   if (!kernel_size) {
     error("Empty kernel file\n");
     return 1;
   }
 
   /* The first part of vmlinuz is a header, followed by a real-mode
    * boot stub.  We only want the 32-bit part. */
   lh = (struct linux_kernel_header *)kernel_buf;
   kernel32_start = (lh->setup_sects + 1) << 9;
   if (kernel32_start >= kernel_size) {
     error("Malformed kernel\n");
     return 1;
   }
   kernel32_size = kernel_size - kernel32_start;
+  Debug(" kernel32_start=0x%" PRIx64 "\n", kernel32_start);
+  Debug(" kernel32_size=0x%" PRIx64 "\n", kernel32_size);
 
   /* Allocate and zero the blob we need. */
   blob_size = roundup(kernel32_size, CROS_ALIGN) +
       CROS_CONFIG_SIZE +
       CROS_PARAMS_SIZE +
       roundup(bootloader_size, CROS_ALIGN);
   blob = (uint8_t *)Malloc(blob_size);
+  Debug("blob_size=0x%" PRIx64 "\n", blob_size);
   if (!blob) {
     error("Couldn't allocate %ld bytes.\n", blob_size);
     return 1;
   }
   Memset(blob, 0, blob_size);
 
   /* Copy the 32-bit kernel. */
+  Debug("kernel goes at blob+=0x%" PRIx64 "\n", now);
   if (kernel32_size)
     Memcpy(blob + now, kernel_buf + kernel32_start, kernel32_size);
   now += roundup(now + kernel32_size, CROS_ALIGN);
 
+  Debug("config goes at blob+0x%" PRIx64 "\n", now);
   /* Find the load address of the commandline. We'll need it later. */
   cmdline_addr = CROS_32BIT_ENTRY_ADDR + now +
       find_cmdline_start((char *)config_buf, config_size);
+  Debug(" cmdline_addr=0x%" PRIx64 "\n", cmdline_addr);
 
   /* Copy the config. */
   if (config_size)
     Memcpy(blob + now, config_buf, config_size);
   now += CROS_CONFIG_SIZE;
 
   /* The zeropage data is next. Overlay the linux_kernel_header onto it, and
    * tweak a few fields. */
+  Debug("params goes at blob+=0x%" PRIx64 "\n", now);
   params = (struct linux_kernel_params *)(blob + now);
   Memcpy(&(params->setup_sects), &(lh->setup_sects),
          sizeof(*lh) - offsetof(struct linux_kernel_header, setup_sects));
   params->boot_flag = 0;
   params->ramdisk_image = 0;             /* we don't support initrd */
   params->ramdisk_size = 0;
   params->type_of_loader = 0xff;
   params->cmd_line_ptr = cmdline_addr;
   now += CROS_PARAMS_SIZE;
 
   /* Finally, append the bootloader. Remember where it will load in
    * memory, too. */
+  Debug("bootloader goes at blob+=0x%" PRIx64 "\n", now);
   bootloader_mem_start = CROS_32BIT_ENTRY_ADDR + now;
   bootloader_mem_size = roundup(bootloader_size, CROS_ALIGN);
+  Debug(" bootloader_mem_start=0x%" PRIx64 "\n", bootloader_mem_start);
+  Debug(" bootloader_mem_size=0x%" PRIx64 "\n", bootloader_mem_size);
   if (bootloader_size)
     Memcpy(blob + now, bootloader_buf, bootloader_size);
   now += bootloader_mem_size;
+  Debug("end of blob is 0x%" PRIx64 "\n", now);
 
   /* Free input buffers */
   Free(kernel_buf);
   Free(config_buf);
   Free(bootloader_buf);
 
   /* Sign the kernel data */
   body_sig = CalculateSignature(blob, blob_size, signing_key);
   if (!body_sig) {
     error("Error calculating body signature\n");
     return 1;
   }
 
   /* Create preamble */
   preamble = CreateKernelPreamble(version,
                                   CROS_32BIT_ENTRY_ADDR,
                                   bootloader_mem_start,
                                   bootloader_mem_size,
                                   body_sig,
                                   pad - key_block_size,
                                   signing_key);
   if (!preamble) {
     error("Error creating preamble.\n");
     return 1;
   }
 
   /* Write the output file */
+  Debug("writing %s...\n", outfile);
   f = fopen(outfile, "wb");
   if (!f) {
     error("Can't open output file %s\n", outfile);
     return 1;
   }
+  Debug("0x%" PRIx64 " bytes of key_block\n", key_block_size);
+  Debug("0x%" PRIx64 " bytes of preamble\n", preamble->preamble_size);
+  Debug("0x%" PRIx64 " bytes of blob\n", blob_size);
   i = ((1 != fwrite(key_block, key_block_size, 1, f)) ||
        (1 != fwrite(preamble, preamble->preamble_size, 1, f)) ||
        (1 != fwrite(blob, blob_size, 1, f)));
   fclose(f);
   if (i) {
     error("Can't write output file %s\n", outfile);
     unlink(outfile);
     return 1;
   }
 
@@ skipping 62 matching lines @@
     error("Error verifying preamble.\n");
     return 1;
   }
   now += preamble->preamble_size;
 
   printf("Preamble:\n");
   printf("  Size:                %" PRIu64 "\n", preamble->preamble_size);
   printf("  Header version:      %" PRIu32 ".%" PRIu32"\n",
          preamble->header_version_major, preamble->header_version_minor);
   printf("  Kernel version:      %" PRIu64 "\n", preamble->kernel_version);
-  printf("  Body load address:   %" PRIu64 "\n", preamble->body_load_address);
-  printf("  Body size:           %" PRIu64 "\n",
+  printf("  Body load address:   0x%" PRIx64 "\n", preamble->body_load_address);
+  printf("  Body size:           0x%" PRIx64 "\n",
          preamble->body_signature.data_size);
-  printf("  Bootloader address:  %" PRIu64 "\n", preamble->bootloader_address);
-  printf("  Bootloader size:     %" PRIu64 "\n", preamble->bootloader_size);
+  printf("  Bootloader address:  0x%" PRIx64 "\n", preamble->bootloader_address);
+  printf("  Bootloader size:     0x%" PRIx64 "\n", preamble->bootloader_size);
 
   /* Verify body */
   if (0 != VerifyData(blob + now, &preamble->body_signature, rsa)) {
     error("Error verifying kernel body.\n");
     return 1;
   }
   printf("Body verification succeeded.\n");
   return 0;
 }
 
@@ skipping 77 matching lines @@
     case OPT_MODE_PACK:
       return Pack(filename, key_block_file, signprivate, version, vmlinuz,
                   bootloader, config_file, pad);
     case OPT_MODE_VERIFY:
       return Verify(filename, signpubkey);
     default:
       printf("Must specify a mode.\n");
       return PrintHelp();
   }
 }