Add --arch flag to pack mode of vbutil_kernel

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 <errno.h>
 #include <getopt.h>
 #include <inttypes.h>  /* For PRIu64 */
@@ skipping 15 matching lines @@
 /* Global opt */
 static int opt_debug = 0;
 
 static const int DEFAULT_PADDING = 65536;
 
 /* Command line options */
 enum {
   OPT_MODE_PACK = 1000,
   OPT_MODE_REPACK,
   OPT_MODE_VERIFY,
+  OPT_ARCH,
   OPT_OLDBLOB,
   OPT_KEYBLOCK,
   OPT_SIGNPUBKEY,
   OPT_SIGNPRIVATE,
   OPT_VERSION,
   OPT_VMLINUZ,
   OPT_BOOTLOADER,
   OPT_CONFIG,
   OPT_VBLOCKONLY,
   OPT_PAD,
   OPT_VERBOSE,
 };
 
+enum {
+  ARCH_NO_SUCH_ARCHITECTURE = -1,
+  ARCH_ARM,
+  ARCH_X86
+};
+
 static struct option long_opts[] = {
   {"pack", 1, 0,                      OPT_MODE_PACK               },
   {"repack", 1, 0,                    OPT_MODE_REPACK             },
   {"verify", 1, 0,                    OPT_MODE_VERIFY             },
+  {"arch", 1, 0,                      OPT_ARCH                    },
   {"oldblob", 1, 0,                   OPT_OLDBLOB                 },
   {"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                  },
   {"vblockonly", 0, 0,                OPT_VBLOCKONLY              },
   {"pad", 1, 0,                       OPT_PAD                     },
@@ skipping 12 matching lines @@
           "Usage:  %s --pack <file> [PARAMETERS]\n"
           "\n"
           "  Required parameters:\n"
           "    --keyblock <file>         Key block in .keyblock format\n"
           "    --signprivate <file>"
           "      Private key to sign kernel data, in .vbprivk format\n"
           "    --version <number>        Kernel version\n"
           "    --vmlinuz <file>          Linux kernel bzImage file\n"
           "    --bootloader <file>       Bootloader stub\n"
           "    --config <file>           Command line file\n"
+          "    --arch <arch>             Cpu architecture\n"
           "\n"
           "  Optional:\n"
           "    --pad <number>            Verification padding size in bytes\n"
           "    --vblockonly              Emit just the verification blob\n",
           progname);
   fprintf(stderr,
           "\nOR\n\n"
           "Usage:  %s --repack <file> [PARAMETERS]\n"
           "\n"
           "  Required parameters (of --keyblock, --config, and --version \n"
@@ skipping 138 matching lines @@
       config_buf[ii] = ' ';
     }
   }
   return config_buf;
 }
 
 /* Create a blob from its components */
 static blob_t *NewBlob(uint64_t version,
                        const char* vmlinuz,
                        const char* bootloader_file,
-                       const char* config_file) {
-  blob_t *bp;
-  struct linux_kernel_header *lh = 0;
-  struct linux_kernel_params *params = 0;
+                       const char* config_file,
+                       int arch) {
+  blob_t* bp;
+  struct linux_kernel_header* lh = 0;
+  struct linux_kernel_params* params = 0;
   uint8_t* config_buf;
   uint64_t config_size;
   uint8_t* bootloader_buf;
   uint64_t bootloader_size;
   uint8_t* kernel_buf;
   uint64_t kernel_size;
   uint64_t kernel32_start = 0;
   uint64_t kernel32_size = 0;
   uint32_t cmdline_addr;
   uint8_t* blob = NULL;
@@ skipping 30 matching lines @@
   Debug("Reading %s\n", vmlinuz);
   kernel_buf = ReadFile(vmlinuz, &kernel_size);
   if (!kernel_buf)
     return 0;
   Debug(" kernel file size=0x%" PRIx64 "\n", kernel_size);
   if (!kernel_size) {
     error("Empty kernel file\n");
     return 0;
   }
 
-  /* 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 0;
-  }
+  if (arch == ARCH_X86) {
+    /* 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 0;
+    }
+  } else
+    kernel32_start = 0;
   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. */
   bp->blob_size = roundup(kernel32_size, CROS_ALIGN) +
       CROS_CONFIG_SIZE +
       CROS_PARAMS_SIZE +
       roundup(bootloader_size, CROS_ALIGN);
   blob = (uint8_t *)Malloc(bp->blob_size);
@@ skipping 19 matching lines @@
 
   /* 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));
+  if (arch == ARCH_X86)
+    Memcpy(&(params->setup_sects), &(lh->setup_sects),
+           sizeof(*lh) - offsetof(struct linux_kernel_header, setup_sects));
+  else
+    Memset(&(params->setup_sects), 0,
+           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;
   /* A fake e820 memory map with 2 entries */
   params->n_e820_entry = 2;
   params->e820_entries[0].start_addr = 0x00000000;
   params->e820_entries[0].segment_size = 0x00001000;
   params->e820_entries[0].segment_type = E820_TYPE_RAM;
@@ skipping 408 matching lines @@
 int main(int argc, char* argv[]) {
   char* filename = NULL;
   char* oldfile = NULL;
   char* key_block_file = NULL;
   char* signpubkey = NULL;
   char* signprivate = NULL;
   int version = -1;
   char* vmlinuz = NULL;
   char* bootloader = NULL;
   char* config_file = NULL;
+  int arch = ARCH_NO_SUCH_ARCHITECTURE;
   int vblockonly = 0;
   int verbose = 0;
   uint64_t pad = DEFAULT_PADDING;
   int mode = 0;
   int parse_error = 0;
   char* e;
   int i,r;
   blob_t *bp;
 
 
@@ skipping 21 matching lines @@
       case OPT_MODE_VERIFY:
         if (mode && (mode != i)) {
           fprintf(stderr, "Only single mode can be specified\n");
           parse_error = 1;
           break;
         }
         mode = i;
         filename = optarg;
         break;
 
+      case OPT_ARCH:
+        if (!strcasecmp(optarg, "x86"))
+          arch = ARCH_X86;
+        else if (!strcasecmp(optarg, "arm"))
+          arch = ARCH_ARM;
+        else {
+          fprintf(stderr, "Unknown architecture string: %s\n", optarg);
+          parse_error = 1;
+        }
+        break;
+
       case OPT_OLDBLOB:
         oldfile = optarg;
         break;
 
       case OPT_KEYBLOCK:
         key_block_file = optarg;
         break;
 
       case OPT_SIGNPUBKEY:
         signpubkey = optarg;
@@ skipping 39 matching lines @@
         verbose = 1;
         break;
     }
   }
 
   if (parse_error)
     return PrintHelp(progname);
 
   switch(mode) {
     case OPT_MODE_PACK:
-      bp = NewBlob(version, vmlinuz, bootloader, config_file);
+      if (arch == ARCH_NO_SUCH_ARCHITECTURE) {
+        fprintf(stderr, "You must specify --arch\n");
+        return 1;
+      }
+      bp = NewBlob(version, vmlinuz, bootloader, config_file, arch);
       if (!bp)
         return 1;
       r = Pack(filename, key_block_file, signprivate, bp, pad, vblockonly);
       FreeBlob(bp);
       return r;
 
     case OPT_MODE_REPACK:
       if (!config_file && !key_block_file && (version<0)) {
         fprintf(stderr,
                 "You must supply at least one of "
                 "--config, --keyblock or --version\n");
         return 1;
       }
 
       bp = OldBlob(oldfile);
       if (!bp)
         return 1;
       r = ReplaceConfig(bp, config_file);
       if (!r) {
         if (version >= 0) {
-                bp->kernel_version = (uint64_t) version;
+          bp->kernel_version = (uint64_t) version;
         }
         r = Pack(filename, key_block_file, signprivate, bp, pad, vblockonly);
       }
       FreeBlob(bp);
       return r;
 
     case OPT_MODE_VERIFY:
       return Verify(filename, signpubkey, verbose, key_block_file);
 
     default:
       fprintf(stderr,
               "You must specify a mode: --pack, --repack or --verify\n");
       return PrintHelp(progname);
   }
 }