Enable attributes to display and set properly.

src/platform/vboot_reference/utility/cgpt/cgpt_show.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.
  *
  * Show GPT details.
  */
 #include <getopt.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "cgpt.h"
@@ skipping 70 matching lines @@
   buf[outlen++] = '\0';
 }
 
 /* Outpur formatters */
 #define TITLE_FMT      "%10s%10s%8s  %s\n"
 #define GPT_FMT        "%10d%10d%8s  %s\n"
 #define GPT_MORE       "%10s%10s%8s  ", "", "", ""
 #define PARTITION_FMT  "%10d%10d%8d  %s\n"
 #define PARTITION_MORE "%10s%10s%8s  %s%s\n", "", "", ""
 
-static void HeaderDetails(GptHeader *header, const char *indent) {
+static void HeaderDetails(GptHeader *header, const char *indent, int raw) {
   int i;
 
   printf("%sSig: ", indent);
-  if (number == NOT_INITED) {
+  if (raw == NOT_INITED) {
     printf("[");
     for (i = 0; i < sizeof(header->signature); ++i)
       printf("%c", header->signature[i]);
     printf("]");
   } else {
     char buf[BUFFER_SIZE(sizeof(header->signature))];
     RawDump((uint8_t *)header->signature, sizeof(header->signature), buf, 1);
     printf("%s", buf);
   }
   printf("\n");
@@ skipping 10 matching lines @@
     GuidToStr(&header->disk_uuid, buf);
     printf("%sDisk UUID: %s\n", indent, buf);
   }
 
   printf("%sEntries LBA: %lld\n", indent, (long long)header->entries_lba);
   printf("%sNumber of entries: %d\n", indent, header->number_of_entries);
   printf("%sSize of entry: %d\n", indent, header->size_of_entry);
   printf("%sEntries CRC: 0x%08x\n", indent, header->entries_crc32);
 }
 
-void EntriesDetails(GptData *gpt, const int secondary) {
+void EntryDetails(GptEntry *entry, int index, int raw) {
+  char contents[256];
+
+  if (raw == NOT_INITED) {
+    uint8_t label[sizeof(entry->name) * 3 / 2];
+    char type[GUID_STRLEN], unique[GUID_STRLEN];;
+
+    UTF16ToUTF8(entry->name, label);
+    snprintf(contents, sizeof(contents), "Label: \"%s\"", label);
+    printf(PARTITION_FMT, (int)entry->starting_lba,
+           (int)(entry->ending_lba - entry->starting_lba + 1),
+           index+1, contents);
+    if (CGPT_OK == ResolveType(&entry->type, type)) {
+      printf(PARTITION_MORE, "Type: ", type);
+    } else {
+      GuidToStr(&entry->type, type);
+      printf(PARTITION_MORE, "Type: ", type);
+    }
+    GuidToStr(&entry->unique, unique);
+    printf(PARTITION_MORE, "UUID: ", unique);
+    if (!Memcmp(&guid_chromeos_kernel, &entry->type, sizeof(Guid))) {
+      int tries = (entry->attributes & CGPT_ATTRIBUTE_TRIES_MASK) >>
+        CGPT_ATTRIBUTE_TRIES_OFFSET;

[Randall Spangler, 2010/06/03 22:29:50]

Should these line up with the ( above?

+      int successful = (entry->attributes & CGPT_ATTRIBUTE_SUCCESSFUL_MASK) >>
+        CGPT_ATTRIBUTE_SUCCESSFUL_OFFSET;
+      int priority = (entry->attributes & CGPT_ATTRIBUTE_PRIORITY_MASK) >>
+        CGPT_ATTRIBUTE_PRIORITY_OFFSET;
+      snprintf(contents, sizeof(contents),
+               "priority=%d tries=%d successful=%d",
+               priority, tries, successful);
+      printf(PARTITION_MORE, "Attr: ", contents);
+    }
+  } else {
+    char label[BUFFER_SIZE(sizeof(entry->name))];
+    char type[GUID_STRLEN], unique[GUID_STRLEN];
+
+    RawDump((void*)entry->name, sizeof(entry->name), label, 2);
+    snprintf(contents, sizeof(contents), "Label: %s", label);
+    printf(PARTITION_FMT, (int)entry->starting_lba,
+           (int)(entry->ending_lba - entry->starting_lba + 1),
+           index+1, contents);
+    GuidToStr(&entry->type, type);
+    printf(PARTITION_MORE, "Type: ", type);
+    GuidToStr(&entry->unique, unique);
+    printf(PARTITION_MORE, "UUID: ", unique);
+    snprintf(contents, sizeof(contents), "[%016lx]", entry->attributes);
+    printf(PARTITION_MORE, "Attr: ", contents);
+  }
+}
+
+void EntriesDetails(GptData *gpt, const int secondary, int raw) {
   int i;
 
   for (i = 0; i < GetNumberOfEntries(gpt); ++i) {
-    static Guid unused = GPT_ENT_TYPE_UNUSED;
-    char contents[256];
-
     GptEntry *entry;
     entry = GetEntry(gpt, secondary, i);
 
-    if (!Memcmp(&unused, &entry->type, sizeof(unused))) continue;
+    if (!Memcmp(&guid_unused, &entry->type, sizeof(Guid))) continue;
 
-    if (number == NOT_INITED) {
-      uint8_t label[sizeof(entry->name) * 3 / 2];
-      char type[GUID_STRLEN], unique[GUID_STRLEN];;
-
-      UTF16ToUTF8(entry->name, label);
-      snprintf(contents, sizeof(contents), "Label: \"%s\"", label);
-      printf(PARTITION_FMT, (int)entry->starting_lba,
-             (int)(entry->ending_lba - entry->starting_lba + 1),
-             i, contents);
-      if (CGPT_OK == ResolveType(&entry->type, type)) {
-        printf(PARTITION_MORE, "Type: ", type);
-      } else {
-        GuidToStr(&entry->type, type);
-        printf(PARTITION_MORE, "Type: ", type);
-      }
-      GuidToStr(&entry->unique, unique);
-      printf(PARTITION_MORE, "UUID: ", unique);
-    } else {
-      char label[BUFFER_SIZE(sizeof(entry->name))];
-      char type[GUID_STRLEN], unique[GUID_STRLEN],
-           attributes[BUFFER_SIZE(sizeof(uint64_t))];
-
-      RawDump((void*)entry->name, sizeof(entry->name), label, 2);
-      snprintf(contents, sizeof(contents), "Label: %s", label);
-      printf(PARTITION_FMT, (int)entry->starting_lba,
-             (int)(entry->ending_lba - entry->starting_lba + 1),
-             i, contents);
-      GuidToStr(&entry->type, type);
-      printf(PARTITION_MORE, "Type: ", type);
-      GuidToStr(&entry->unique, unique);
-      printf(PARTITION_MORE, "UUID: ", unique);
-      RawDump((uint8_t*)&entry->attributes, 8, attributes, 4);
-      printf(PARTITION_MORE, "Attr: ", attributes);
-    }
+    EntryDetails(entry, i, raw);
   }
 }
 
 /* Parses all options (and validates them), then opens the drive.
  * Show GPT information in following order:
  *
  *   Primary header sector
  *     details (if -v applied)
  *
  *   Primary table sectors
@@ skipping 27 matching lines @@
                      show_options_details))
     return CGPT_FAILED;
   if (help != NOT_INITED) {
     ShowHelp();
     return CGPT_FAILED;
   }
 
   if (CGPT_OK != OpenDriveInLastArgument(argc, argv, &drive))
     return CGPT_FAILED;
 
-  printf(TITLE_FMT, "start", "size", "index", "contents");
+  printf(TITLE_FMT, "start", "size", "part", "contents");
   printf(GPT_FMT, 0, GPT_PMBR_SECTOR, "", "PMBR");
 
   if (drive.gpt.valid_headers & MASK_PRIMARY) {
     printf(GPT_FMT, (int)GPT_PMBR_SECTOR,
            (int)GPT_HEADER_SECTOR, "", "Pri GPT header");
     if (verbose) {
       GptHeader *header;
       char indent[64];
 
       snprintf(indent, sizeof(indent), GPT_MORE);
       header = (GptHeader*)drive.gpt.primary_header;
-      HeaderDetails(header, indent);
+      HeaderDetails(header, indent, number);
     }
   } else {
     printf(GPT_FMT, (int)GPT_PMBR_SECTOR,
            (int)GPT_HEADER_SECTOR, "INVALID", "Pri GPT header");
   }
 
   printf(GPT_FMT, (int)(GPT_PMBR_SECTOR + GPT_HEADER_SECTOR),
          (int)GPT_ENTRIES_SECTORS,
          drive.gpt.valid_entries & MASK_PRIMARY ? "" : "INVALID",
          "Pri GPT table");
 
   if (drive.gpt.valid_entries & MASK_PRIMARY)
-    EntriesDetails(&drive.gpt, PRIMARY);
+    EntriesDetails(&drive.gpt, PRIMARY, number);
 
   printf(GPT_FMT, (int)(drive.gpt.drive_sectors - GPT_HEADER_SECTOR -
                         GPT_ENTRIES_SECTORS),
          (int)GPT_ENTRIES_SECTORS,
          drive.gpt.valid_entries & MASK_SECONDARY ? "" : "INVALID",
          "Sec GPT table");
   /* We show secondary table details if any of following is true.
    *   1. only secondary is valid.
    *   2. secondary is not identical to promary.
    */
   if ((drive.gpt.valid_entries & MASK_SECONDARY) &&
       (!(drive.gpt.valid_entries & MASK_PRIMARY) ||
        Memcmp(drive.gpt.primary_entries, drive.gpt.secondary_entries,
               TOTAL_ENTRIES_SIZE))) {
-    EntriesDetails(&drive.gpt, SECONDARY);
+    EntriesDetails(&drive.gpt, SECONDARY, number);
   }
 
   if (drive.gpt.valid_headers & MASK_SECONDARY)
     printf(GPT_FMT, (int)(drive.gpt.drive_sectors - GPT_HEADER_SECTOR),
            (int)GPT_HEADER_SECTOR, "", "Sec GPT header");
   else
     printf(GPT_FMT, (int)GPT_PMBR_SECTOR,
            (int)GPT_HEADER_SECTOR, "INVALID", "Sec GPT header");
   /* We show secondary header if any of following is true:
    *   1. only secondary is valid.
    *   2. secondary is not synonymous to primary.
    */
   if ((drive.gpt.valid_headers & MASK_SECONDARY) &&
       (!(drive.gpt.valid_headers & MASK_PRIMARY) ||
        !IsSynonymous((GptHeader*)drive.gpt.primary_header,
                      (GptHeader*)drive.gpt.secondary_header))) {
     if (verbose) {
       GptHeader *header;
       char indent[64];
 
       snprintf(indent, sizeof(indent), GPT_MORE);
       header = (GptHeader*)drive.gpt.secondary_header;
-      HeaderDetails(header, indent);
+      HeaderDetails(header, indent, number);
     }
   }
 
   CheckValid(&drive);
   DriveClose(&drive);
 
   return CGPT_OK;
 }