Add 'prioritize' command to cgpt tool.

cgpt/cgpt_common.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.
  *
  * Utility for ChromeOS-specific GPT partitions, Please see corresponding .c
  * files for more details.
  */
 
 #include "cgpt.h"
 
@@ skipping 539 matching lines @@
 
   /* A null-terminator shows up before the UTF8 sequence ends. */
   if (expected_units != decoded_units) {
     retval = CGPT_FAILED;
   }
 
   utf16[s16idx++] = 0;
   return retval;
 }
 
-struct {
-  Guid type;
+/* global types to compare against */
+const Guid guid_chromeos_kernel =   GPT_ENT_TYPE_CHROMEOS_KERNEL;
+const Guid guid_chromeos_rootfs =   GPT_ENT_TYPE_CHROMEOS_ROOTFS;
+const Guid guid_linux_data =        GPT_ENT_TYPE_LINUX_DATA;
+const Guid guid_chromeos_reserved = GPT_ENT_TYPE_CHROMEOS_RESERVED;
+const Guid guid_efi =               GPT_ENT_TYPE_EFI;
+const Guid guid_unused =            GPT_ENT_TYPE_UNUSED;
+
+static struct {
+  const Guid *type;
   char *name;
   char *description;
 } supported_types[] = {
-  {GPT_ENT_TYPE_CHROMEOS_KERNEL, "kernel", "ChromeOS kernel"},
-  {GPT_ENT_TYPE_CHROMEOS_ROOTFS, "rootfs", "ChromeOS rootfs"},
-  {GPT_ENT_TYPE_LINUX_DATA, "data", "Linux data"},
-  {GPT_ENT_TYPE_CHROMEOS_RESERVED, "reserved", "ChromeOS reserved"},
-  {GPT_ENT_TYPE_EFI, "efi", "EFI System Partition"},
-  {GPT_ENT_TYPE_UNUSED, "unused", "Unused (nonexistent) partition"},
+  {&guid_chromeos_kernel, "kernel", "ChromeOS kernel"},
+  {&guid_chromeos_rootfs, "rootfs", "ChromeOS rootfs"},
+  {&guid_linux_data, "data", "Linux data"},
+  {&guid_chromeos_reserved, "reserved", "ChromeOS reserved"},
+  {&guid_efi, "efi", "EFI System Partition"},
+  {&guid_unused, "unused", "Unused (nonexistent) partition"},
 };
 
 /* Resolves human-readable GPT type.
  * Returns CGPT_OK if found.
  * Returns CGPT_FAILED if no known type found. */
 int ResolveType(const Guid *type, char *buf) {
   int i;
   for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
-    if (!memcmp(type, &supported_types[i].type, sizeof(Guid))) {
+    if (!memcmp(type, supported_types[i].type, sizeof(Guid))) {
       strcpy(buf, supported_types[i].description);
       return CGPT_OK;
     }
   }
   return CGPT_FAILED;
 }
 
 int SupportedType(const char *name, Guid *type) {
   int i;
   for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
     if (!strcmp(name, supported_types[i].name)) {
-      memcpy(type, &supported_types[i].type, sizeof(Guid));
+      memcpy(type, supported_types[i].type, sizeof(Guid));
       return CGPT_OK;
     }
   }
   return CGPT_FAILED;
 }
 
 void PrintTypes(void) {
   int i;
   printf("The partition type may also be given as one of these aliases:\n\n");
   for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
@@ skipping 233 matching lines @@
     memcpy(primary_header, secondary_header, sizeof(GptHeader));
     primary_header->my_lba = GPT_PMBR_SECTOR;  /* the second sector on drive */
     primary_header->alternate_lba = secondary_header->my_lba;
     primary_header->entries_lba = primary_header->my_lba + GPT_HEADER_SECTOR;
     return GPT_MODIFIED_HEADER1;
   }
 
   return 0;
 }
 
+int GuidEqual(const Guid *guid1, const Guid *guid2) {
+  return (0 == memcmp(guid1, guid2, sizeof(Guid)));
+}
 
 int IsZero(const Guid *gp) {
-  return (0 == memcmp(gp, &guid_unused, sizeof(Guid)));
+  return GuidEqual(gp, &guid_unused);
 }
 
 void PMBRToStr(struct pmbr *pmbr, char *str, unsigned int buflen) {
   char buf[GUID_STRLEN];
   if (IsZero(&pmbr->boot_guid)) {
     require(snprintf(str, buflen, "PMBR") < buflen);
   } else {
     GuidToStr(&pmbr->boot_guid, buf, sizeof(buf));
     require(snprintf(str, buflen, "PMBR (Boot GUID: %s)", buf) < buflen);
   }
 }