Add VbSharedData field parsing

host/lib/crossystem.c

 /* 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.
  */
 
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <ctype.h>
 
 #include "host_common.h"
 
 #include "crossystem.h"
 #include "utility.h"
 #include "vboot_common.h"
 #include "vboot_nvstorage.h"
+#include "vboot_struct.h"
 
 /* ACPI constants from Chrome OS Main Processor Firmware Spec */
 /* GPIO signal types */
 #define GPIO_SIGNAL_TYPE_RECOVERY 1
 #define GPIO_SIGNAL_TYPE_DEV 2
 #define GPIO_SIGNAL_TYPE_WP 3
 /* CHSW bitflags */
 #define CHSW_RECOVERY_BOOT     0x00000002
 #define CHSW_RECOVERY_EC_BOOT  0x00000004
 #define CHSW_DEV_BOOT          0x00000020
@@ skipping 51 matching lines @@
 
 /* Filename for NVRAM file */
 #define NVRAM_PATH "/dev/nvram"
 
 /* Filename for kernel command line */
 #define KERNEL_CMDLINE_PATH "/proc/cmdline"
 
 /* A structure to contain buffer data retrieved from the ACPI. */
 typedef struct {
   int buffer_size;
-  void* buffer;
+  uint8_t* buffer;
 } AcpiBuffer;
 
 
+/* Fields that GetVdatString() can get */
+typedef enum VdatStringField {
+  VDAT_STRING_TIMERS = 0,          /* Timer values */
+  VDAT_STRING_LOAD_FIRMWARE_DEBUG  /* LoadFirmware() debug information */
+} VdatStringField;
+
+
+/* Fields that GetVdatInt() can get */
+typedef enum VdatIntField {
+  VDAT_INT_FLAGS = 0  /* Flags */
+} VdatIntField;
+
+
 /* Copy up to dest_size-1 characters from src to dest, ensuring null
    termination (which strncpy() doesn't do).  Returns the destination
    string. */
 char* StrCopy(char* dest, const char* src, int dest_size) {
   strncpy(dest, src, dest_size);
   dest[dest_size - 1] = '\0';
   return dest;
 }
 
 
@@ skipping 208 matching lines @@
 
 AcpiBuffer* VbGetBuffer(const char* filename)
 {
   FILE* f = NULL;
   char* file_buffer = NULL;
   AcpiBuffer* acpi_buffer = NULL;
   AcpiBuffer* return_value = NULL;
 
   do {
     struct stat fs;
-    unsigned char* output_ptr;
+    uint8_t* output_ptr;
     int rv, i, real_size;
 
     rv = stat(filename, &fs);
     if (rv || !S_ISREG(fs.st_mode))
       break;
 
     f = fopen(filename, "r");
     if (!f)
       break;
 
     file_buffer = Malloc(fs.st_size + 1);
     if (!file_buffer)
       break;
 
-
     real_size = fread(file_buffer, 1, fs.st_size, f);
     if (!real_size)
       break;
+    file_buffer[real_size] = '\0';
 
-    /* each byte in the output will replace two characters and a space in the
-     *  input, so the output size does not exceed input side/3 (a little less
-     *  if account for newline characters).
-     */
+    /* Each byte in the output will replace two characters and a space
+     * in the input, so the output size does not exceed input side/3
+     * (a little less if account for newline characters). */
     acpi_buffer = Malloc(sizeof(AcpiBuffer) + real_size/3);
-
     if (!acpi_buffer)
       break;
-
-    file_buffer[real_size] = '\0';
-
-    acpi_buffer->buffer = acpi_buffer + 1;
+    acpi_buffer->buffer = (uint8_t*)(acpi_buffer + 1);
     acpi_buffer->buffer_size = 0;
     output_ptr = acpi_buffer->buffer;
 
     /* process the file contents */
     for (i = 0; i < real_size; i++) {
       char* base, *end;
 
       base = file_buffer + i;
 
       if (!isxdigit(*base))
@@ skipping 233 matching lines @@
   /* Normal new firmware or older Chrome OS firmware allows debug if the
    * dev switch is on. */
   if (1 == ReadFileBit(ACPI_CHSW_PATH, CHSW_DEV_BOOT))
     return 1;
 
   /* All other cases disallow debug. */
   return 0;
 }
 
 
+char* GetVdatString(char* dest, int size, VdatStringField field)
+{
+  VbSharedDataHeader* sh;
+  AcpiBuffer* ab = VbGetBuffer(ACPI_VDAT_PATH);
+  if (!ab)
+    return NULL;
+
+  sh = (VbSharedDataHeader*)ab->buffer;
+
+  switch (field) {
+    case VDAT_STRING_TIMERS:
+      snprintf(dest, size,
+               "LFS=%" PRIu64 ",%" PRIu64
+               " LF=%" PRIu64 ",%" PRIu64
+               " LK=%" PRIu64 ",%" PRIu64,
+               sh->timer_load_firmware_start_enter,
+               sh->timer_load_firmware_start_exit,
+               sh->timer_load_firmware_enter,
+               sh->timer_load_firmware_exit,
+               sh->timer_load_kernel_enter,
+               sh->timer_load_kernel_exit);
+      break;
+
+    case VDAT_STRING_LOAD_FIRMWARE_DEBUG:
+      snprintf(dest, size,
+               "check=%d,%d index=0x%02x tpmver=0x%x lowestver=0x%x",
+               sh->check_fw_a_result,
+               sh->check_fw_b_result,
+               sh->firmware_index,
+               sh->fw_version_tpm_start,
+               sh->fw_version_lowest);
+      break;
+
+    default:
+      Free(ab);
+      return NULL;
+  }
+
+  Free(ab);
+  return dest;
+}
+
+
+int GetVdatInt(VdatIntField field) {
+  VbSharedDataHeader* sh;
+  AcpiBuffer* ab = VbGetBuffer(ACPI_VDAT_PATH);
+  int value = -1;
+
+  if (!ab)
+    return -1;
+
+  sh = (VbSharedDataHeader*)ab->buffer;
+
+  switch (field) {
+    case VDAT_INT_FLAGS:
+      value = (int)sh->flags;
+      break;
+
+  }
+
+  Free(ab);
+  return value;
+}
+
+
 /* Read a system property integer.
  *
  * Returns the property value, or -1 if error. */
 int VbGetSystemPropertyInt(const char* name) {
   int value = -1;
 
   /* Switch positions */
   if (!strcasecmp(name,"devsw_cur")) {
     value = ReadGpio(GPIO_SIGNAL_TYPE_DEV);
   } else if (!strcasecmp(name,"devsw_boot")) {
@@ skipping 47 matching lines @@
     if (-1 == value)
       value = VbGetCmosRebootField(CMOSRF_TRY_B);
   }
   /* Other parameters */
   else if (!strcasecmp(name,"recovery_reason")) {
     return VbGetRecoveryReason();
   } else if (!strcasecmp(name,"fmap_base")) {
     value = ReadFileInt(ACPI_FMAP_PATH);
   } else if (!strcasecmp(name,"cros_debug")) {
     value = VbGetCrosDebug();
+  } else if (!strcasecmp(name,"vdat_flags")) {
+    value = GetVdatInt(VDAT_INT_FLAGS);
   }
 
   return value;
 }
 
-/* This function is just an example illustrating the use of VbGetBuffer(). It
- * converts the binary contents of the buffer into a space delimetered hex
- * string. It is expected to be replaced with a function which has knowledge
- * of the buffer data structure.
- */
-char* GetVdatBuffer(void)
-{
-  char* buffer, *src, *p;
-  int i;
-
-  AcpiBuffer* ab = VbGetBuffer(ACPI_VDAT_PATH);
-  if (!ab)
-    return NULL;
-
-  buffer = Malloc(ab->buffer_size * 3 + 2);
-  p = buffer;
-  src = ab->buffer;
-  for (i = 0; i < ab->buffer_size; i++) {
-    snprintf(p, 4, " %2.2x", *src++);
-    p += 3;
-  }
-  *p = '\0';
-  Free(ab);
-  return buffer;
-}
-
 /* Read a system property string into a destination buffer of the specified
  * size.
  *
  * Returns the passed buffer, or NULL if error. */
 const char* VbGetSystemPropertyString(const char* name, char* dest, int size) {
 
   if (!strcasecmp(name,"hwid")) {
     return ReadFileString(dest, size, ACPI_BASE_PATH "/HWID");
   } else if (!strcasecmp(name,"fwid")) {
     return ReadFileString(dest, size, ACPI_BASE_PATH "/FWID");
@@ skipping 23 matching lines @@
     }
   } else if (!strcasecmp(name,"kernkey_vfy")) {
     switch(VbGetNvStorage(VBNV_FW_VERIFIED_KERNEL_KEY)) {
       case 0:
         return "hash";
       case 1:
         return "sig";
       default:
         return NULL;
     }
-  } else if (!strcasecmp(name, "vdat")) {
-    return GetVdatBuffer();
+  } else if (!strcasecmp(name, "vdat_timers")) {
+    return GetVdatString(dest, size, VDAT_STRING_TIMERS);
+  } else if (!strcasecmp(name, "vdat_lfdebug")) {
+    return GetVdatString(dest, size, VDAT_STRING_LOAD_FIRMWARE_DEBUG);
   } else
     return NULL;
 }
 
 
 /* Set a system property integer.
  *
  * Returns 0 if success, -1 if error. */
 int VbSetSystemPropertyInt(const char* name, int value) {
 
@@ skipping 29 matching lines @@
 
 
 /* Set a system property string.
  *
  * Returns 0 if success, -1 if error. */
 int VbSetSystemPropertyString(const char* name, const char* value) {
 
   /* TODO: support setting */
   return -1;
 }