cgpt supports dev and add/delete/modify commands.

src/platform/vboot_reference/cgptlib/cgptlib.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.
  */
 
 #include "cgptlib.h"
 #include <string.h>
 #include "cgptlib_internal.h"
 #include "crc32.h"
 #include "gpt.h"
@@ skipping 40 matching lines @@
   if (gpt->drive_sectors < (GPT_PMBR_SECTOR +
                             GPT_HEADER_SECTOR * 2 +
                             GPT_ENTRIES_SECTORS * 2))
     return GPT_ERROR_INVALID_SECTOR_NUMBER;
 
   return GPT_SUCCESS;
 }
 
 /* Expects header signature should be GPT_HEADER_SIGNATURE. */
 uint32_t CheckHeaderSignature(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   int i;
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     if (Memcmp(headers[i]->signature,
                GPT_HEADER_SIGNATURE,
                GPT_HEADER_SIGNATURE_SIZE)) {
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
     }
   }
-  return valid_headers;
+  return gpt->valid_headers;
 }
 
 /* The header revision should be GPT_HEADER_REVISION. */
 uint32_t CheckRevision(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   int i;
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     if (headers[i]->revision != GPT_HEADER_REVISION)
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
   }
-  return valid_headers;
+  return gpt->valid_headers;
 }
 
 /* A valid header size should be between MIN_SIZE_OF_HEADER and
  * MAX_SIZE_OF_HEADER. */
 uint32_t CheckSize(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   int i;
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     if ((headers[i]->size < MIN_SIZE_OF_HEADER) ||
         (headers[i]->size > MAX_SIZE_OF_HEADER))
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
   }
-  return valid_headers;
+  return gpt->valid_headers;
 }
 
 /* Reserved and padding fields should be zero. */
 uint32_t CheckReservedFields(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   int i;
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     if (headers[i]->reserved || headers[i]->padding)
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
   }
-  return valid_headers;
+  return gpt->valid_headers;
 }
 
 /* my_lba field points to the header itself.
  * So that the my_lba of primary header should be 1 (right after PMBR).
  * The my_lba of secondary header should be the last secotr on drive. */
 uint32_t CheckMyLba(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   GptHeader *primary_header, *secondary_header;
 
   primary_header = (GptHeader*)gpt->primary_header;
   secondary_header = (GptHeader*)gpt->secondary_header;
 
   if (primary_header->my_lba != GPT_PMBR_SECTOR)  /* 2nd sector on drive */
-    INVALIDATE_HEADER(valid_headers, PRIMARY);
+    INVALIDATE_HEADER(gpt->valid_headers, PRIMARY);
   if (secondary_header->my_lba != (gpt->drive_sectors - 1))  /* last sector */
-    INVALIDATE_HEADER(valid_headers, SECONDARY);
-  return valid_headers;
+    INVALIDATE_HEADER(gpt->valid_headers, SECONDARY);
+  return gpt->valid_headers;
 }
 
 /* SizeOfPartitionEntry must be between MIN_SIZE_OF_ENTRY and
  * MAX_SIZE_OF_ENTRY, and a multiple of SIZE_OF_ENTRY_MULTIPLE. */
 uint32_t CheckSizeOfPartitionEntry(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   int i;
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     uint32_t size_of_entry = headers[i]->size_of_entry;
     if ((size_of_entry < MIN_SIZE_OF_ENTRY) ||
         (size_of_entry > MAX_SIZE_OF_ENTRY) ||
         (size_of_entry & (SIZE_OF_ENTRY_MULTIPLE - 1)))
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
   }
-  return valid_headers;
+  return gpt->valid_headers;
 }
 
 /* number_of_entries must be between MIN_NUMBER_OF_ENTRIES and
  * MAX_NUMBER_OF_ENTRIES, and size_of_entry * number_of_entries must be
  * equal to TOTAL_ENTRIES_SIZE. */
 uint32_t CheckNumberOfEntries(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   int i;
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     uint32_t number_of_entries = headers[i]->number_of_entries;
     if ((number_of_entries < MIN_NUMBER_OF_ENTRIES) ||
         (number_of_entries > MAX_NUMBER_OF_ENTRIES) ||
         (number_of_entries * headers[i]->size_of_entry != TOTAL_ENTRIES_SIZE))
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
   }
-  return valid_headers;
+  return gpt->valid_headers;
 }
 
 /* Make sure entries_lba is correct.
  *   2 for primary entries
  *   drive_sectors-1-GPT_ENTRIES_SECTORS for secondary entries. */
 uint32_t CheckEntriesLba(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   GptHeader *primary_header, *secondary_header;
 
   primary_header = (GptHeader*)gpt->primary_header;
   secondary_header = (GptHeader*)gpt->secondary_header;
 
   /* We assume the primary partition entry table is located at the sector
    * right after primary partition header. */
   if (primary_header->entries_lba != (GPT_PMBR_SECTOR + GPT_HEADER_SECTOR))
-    INVALIDATE_HEADER(valid_headers, PRIMARY);
+    INVALIDATE_HEADER(gpt->valid_headers, PRIMARY);
   /* We assume the secondary partition entry table is the 32 sectors
    * right before the secondary partition header. */
   if (secondary_header->entries_lba !=
       (gpt->drive_sectors - 1 - GPT_ENTRIES_SECTORS))
-    INVALIDATE_HEADER(valid_headers, SECONDARY);
-  return valid_headers;
+    INVALIDATE_HEADER(gpt->valid_headers, SECONDARY);
+  return gpt->valid_headers;
 }
 
 /* FirstUsableLBA must be after the end of the primary GPT table array.
  * LastUsableLBA must be before the start of the secondary GPT table array.
  * FirstUsableLBA <= LastUsableLBA. */
 uint32_t CheckValidUsableLbas(GptData *gpt) {
-  uint32_t valid_headers = MASK_BOTH;
   uint64_t end_of_primary_entries;
   uint64_t start_of_secondary_entries;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   int i;
 
   end_of_primary_entries = GPT_PMBR_SECTOR + GPT_HEADER_SECTOR +
                            GPT_ENTRIES_SECTORS;
   start_of_secondary_entries = (gpt->drive_sectors - 1 - GPT_ENTRIES_SECTORS);
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     if (headers[i]->first_usable_lba < end_of_primary_entries)
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
     if (headers[i]->last_usable_lba >= start_of_secondary_entries)
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
     if (headers[i]->first_usable_lba > headers[i]->last_usable_lba)
-      INVALIDATE_HEADER(valid_headers, i);
+      INVALIDATE_HEADER(gpt->valid_headers, i);
   }
 
   if (headers[PRIMARY]->first_usable_lba - headers[PRIMARY]->entries_lba <
       GPT_ENTRIES_SECTORS)
-    INVALIDATE_HEADER(valid_headers, PRIMARY);
+    INVALIDATE_HEADER(gpt->valid_headers, PRIMARY);
   if (headers[SECONDARY]->last_usable_lba >= headers[SECONDARY]->entries_lba)
-    INVALIDATE_HEADER(valid_headers, SECONDARY);
+    INVALIDATE_HEADER(gpt->valid_headers, SECONDARY);
 
-  return valid_headers;
+  return gpt->valid_headers;
 }
 
 /* Checks header CRC */
 uint32_t CheckHeaderCrc(GptData *gpt) {
   uint32_t crc32, original_crc32;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   int i;
@@ skipping 31 matching lines @@
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     crc32 = Crc32((const uint8_t *)entries[i], TOTAL_ENTRIES_SIZE);
     if (crc32 != entries_crc32)
       INVALIDATE_ENTRIES(gpt->valid_entries, i);
   }
   return gpt->valid_entries;
 }
 
 /* Returns non-zero if the given GUID is non-zero. */
-static int NonZeroGuid(const Guid *guid) {
+int NonZeroGuid(const Guid *guid) {
   static Guid zero = {{{0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0}}}};
   return Memcmp(&zero, guid, sizeof(zero));
 }
 
 /* Checks if entries geometry is valid.
  * All active (non-zero PartitionTypeGUID) partition entries should have:
  *   entry.StartingLBA >= header.FirstUsableLBA
  *   entry.EndingLBA <= header.LastUsableLBA
  *   entry.StartingLBA <= entry.EndingLBA
  */
@@ skipping 66 matching lines @@
         (pairs[i].starting <= pairs[i-1].ending))
       return 1;
   }
 
   return 0;
 }
 
 /* Checks if any two partitions are overlapped in primary and secondary entries.
  */
 uint32_t CheckOverlappedPartition(GptData *gpt) {
-  uint32_t valid_entries = MASK_BOTH;
   GptHeader *headers[] = {
     (GptHeader*)gpt->primary_header,
     (GptHeader*)gpt->secondary_header,
   };
   GptEntry *entries[] = {
     (GptEntry*)gpt->primary_entries,
     (GptEntry*)gpt->secondary_entries,
   };
   int i;
   uint32_t number_of_entries;
 
   if (gpt->valid_headers & MASK_PRIMARY)
     number_of_entries = headers[PRIMARY]->number_of_entries;
   else
     number_of_entries = headers[SECONDARY]->number_of_entries;
 
   for (i = PRIMARY; i <= SECONDARY; ++i) {
     if (OverlappedEntries(entries[i], number_of_entries))
-      INVALIDATE_ENTRIES(valid_entries, i);
+      INVALIDATE_ENTRIES(gpt->valid_entries, i);
   }
-  return valid_entries;
+  return gpt->valid_entries;
 }
 
 /* Primary entries and secondary entries should be bitwise identical.
  * If two entries tables are valid, compare them. If not the same,
  * overwrites secondary with primary (primary always has higher priority),
  * and marks secondary as modified.
  * If only one is valid, overwrites invalid one.
  * If all are invalid, does nothing.
  * This function returns bit masks for GptData.modified field.
  * Note that CRC is NOT re-computed in this function.
@@ skipping 399 matching lines @@
     RepairEntries(gpt, MASK_PRIMARY);
     /* Actually two entries are dirty now.
     * Also two headers are dirty because entries_crc32 has been updated. */
     gpt->modified |= (GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1 |
                       GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2);
     UpdateCrc(gpt);
   }
 
   return GPT_SUCCESS;
 }