diff options
author | Randall Spangler <rspangler@chromium.org> | 2013-01-30 12:52:02 -0800 |
---|---|---|
committer | ChromeBot <chrome-bot@google.com> | 2013-01-31 13:00:38 -0800 |
commit | cefe12c105a91e6ee9f44bca218bd6e4f89bcb71 (patch) | |
tree | d088dc4d217edd9d63b9b3f9e53303745478c724 /firmware | |
parent | 7993f257af87c7c38cdc71b76bc67cde6c3cdbca (diff) | |
download | vboot-cefe12c105a91e6ee9f44bca218bd6e4f89bcb71.tar.gz |
Reformat cgptlib to kernel style
No code changes, just reformatting.
BUG=none
BRANCH=none
TEST=make runtests
Change-Id: Ib8748df93c64395c88e1f789805393fcfe3ac419
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://gerrit.chromium.org/gerrit/42397
Reviewed-by: Bill Richardson <wfrichar@chromium.org>
Diffstat (limited to 'firmware')
-rw-r--r-- | firmware/lib/cgptlib/cgptlib.c | 303 | ||||
-rw-r--r-- | firmware/lib/cgptlib/cgptlib_internal.c | 706 | ||||
-rwxr-xr-x | firmware/lib/cgptlib/crc32.c | 121 | ||||
-rw-r--r-- | firmware/lib/cgptlib/include/cgptlib.h | 139 | ||||
-rw-r--r-- | firmware/lib/cgptlib/include/cgptlib_internal.h | 125 | ||||
-rw-r--r-- | firmware/lib/cgptlib/include/gpt.h | 126 |
6 files changed, 800 insertions, 720 deletions
diff --git a/firmware/lib/cgptlib/cgptlib.c b/firmware/lib/cgptlib/cgptlib.c index c3f37442..370530f1 100644 --- a/firmware/lib/cgptlib/cgptlib.c +++ b/firmware/lib/cgptlib/cgptlib.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2011 The Chromium OS Authors. All rights reserved. +/* Copyright (c) 2013 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. */ @@ -10,150 +10,173 @@ #include "utility.h" #include "vboot_api.h" -int GptInit(GptData *gpt) { - int retval; +int GptInit(GptData *gpt) +{ + int retval; - gpt->modified = 0; - gpt->current_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND; - gpt->current_priority = 999; + gpt->modified = 0; + gpt->current_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND; + gpt->current_priority = 999; - retval = GptSanityCheck(gpt); - if (GPT_SUCCESS != retval) { - VBDEBUG(("GptInit() failed sanity check\n")); - return retval; - } + retval = GptSanityCheck(gpt); + if (GPT_SUCCESS != retval) { + VBDEBUG(("GptInit() failed sanity check\n")); + return retval; + } - GptRepair(gpt); - return GPT_SUCCESS; + GptRepair(gpt); + return GPT_SUCCESS; } - -int GptNextKernelEntry(GptData* gpt, uint64_t* start_sector, uint64_t* size) { - GptHeader* header = (GptHeader*)gpt->primary_header; - GptEntry* entries = (GptEntry*)gpt->primary_entries; - GptEntry* e; - int new_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND; - int new_prio = 0; - uint32_t i; - - /* If we already found a kernel, continue the scan at the current - * kernel's prioity, in case there is another kernel with the same - * priority. */ - if (gpt->current_kernel != CGPT_KERNEL_ENTRY_NOT_FOUND) { - for (i = gpt->current_kernel + 1; i < header->number_of_entries; i++) { - e = entries + i; - if (!IsKernelEntry(e)) - continue; - VBDEBUG(("GptNextKernelEntry looking at same prio partition %d\n", i+1)); - VBDEBUG(("GptNextKernelEntry s%d t%d p%d\n", - GetEntrySuccessful(e), GetEntryTries(e), GetEntryPriority(e))); - if (!(GetEntrySuccessful(e) || GetEntryTries(e))) - continue; - if (GetEntryPriority(e) == gpt->current_priority) { - gpt->current_kernel = i; - *start_sector = e->starting_lba; - *size = e->ending_lba - e->starting_lba + 1; - VBDEBUG(("GptNextKernelEntry likes that one\n")); - return GPT_SUCCESS; - } - } - } - - /* We're still here, so scan for the remaining kernel with the - * highest priority less than the previous attempt. */ - for (i = 0, e = entries; i < header->number_of_entries; i++, e++) { - int current_prio = GetEntryPriority(e); - if (!IsKernelEntry(e)) - continue; - VBDEBUG(("GptNextKernelEntry looking at new prio partition %d\n", i+1)); - VBDEBUG(("GptNextKernelEntry s%d t%d p%d\n", - GetEntrySuccessful(e), GetEntryTries(e), GetEntryPriority(e))); - if (!(GetEntrySuccessful(e) || GetEntryTries(e))) - continue; - if (current_prio >= gpt->current_priority) - continue; /* Already returned this kernel in a previous call */ - if (current_prio > new_prio) { - new_kernel = i; - new_prio = current_prio; - } - } - - /* Save what we found. Note that if we didn't find a new kernel, - * new_prio will still be -1, so future calls to this function will - * also fail. */ - gpt->current_kernel = new_kernel; - gpt->current_priority = new_prio; - - if (CGPT_KERNEL_ENTRY_NOT_FOUND == new_kernel) { - VBDEBUG(("GptNextKernelEntry no more kernels\n")); - return GPT_ERROR_NO_VALID_KERNEL; - } - - VBDEBUG(("GptNextKernelEntry likes partition %d\n", new_kernel+1)); - e = entries + new_kernel; - *start_sector = e->starting_lba; - *size = e->ending_lba - e->starting_lba + 1; - return GPT_SUCCESS; +int GptNextKernelEntry(GptData *gpt, uint64_t *start_sector, uint64_t *size) +{ + GptHeader *header = (GptHeader *)gpt->primary_header; + GptEntry *entries = (GptEntry *)gpt->primary_entries; + GptEntry *e; + int new_kernel = CGPT_KERNEL_ENTRY_NOT_FOUND; + int new_prio = 0; + uint32_t i; + + /* + * If we already found a kernel, continue the scan at the current + * kernel's priority, in case there is another kernel with the same + * priority. + */ + if (gpt->current_kernel != CGPT_KERNEL_ENTRY_NOT_FOUND) { + for (i = gpt->current_kernel + 1; + i < header->number_of_entries; i++) { + e = entries + i; + if (!IsKernelEntry(e)) + continue; + VBDEBUG(("GptNextKernelEntry looking at same prio " + "partition %d\n", i+1)); + VBDEBUG(("GptNextKernelEntry s%d t%d p%d\n", + GetEntrySuccessful(e), GetEntryTries(e), + GetEntryPriority(e))); + if (!(GetEntrySuccessful(e) || GetEntryTries(e))) + continue; + if (GetEntryPriority(e) == gpt->current_priority) { + gpt->current_kernel = i; + *start_sector = e->starting_lba; + *size = e->ending_lba - e->starting_lba + 1; + VBDEBUG(("GptNextKernelEntry likes it\n")); + return GPT_SUCCESS; + } + } + } + + /* + * We're still here, so scan for the remaining kernel with the highest + * priority less than the previous attempt. + */ + for (i = 0, e = entries; i < header->number_of_entries; i++, e++) { + int current_prio = GetEntryPriority(e); + if (!IsKernelEntry(e)) + continue; + VBDEBUG(("GptNextKernelEntry looking at new prio " + "partition %d\n", i+1)); + VBDEBUG(("GptNextKernelEntry s%d t%d p%d\n", + GetEntrySuccessful(e), GetEntryTries(e), + GetEntryPriority(e))); + if (!(GetEntrySuccessful(e) || GetEntryTries(e))) + continue; + if (current_prio >= gpt->current_priority) { + /* Already returned this kernel in a previous call */ + continue; + } + if (current_prio > new_prio) { + new_kernel = i; + new_prio = current_prio; + } + } + + /* + * Save what we found. Note that if we didn't find a new kernel, + * new_prio will still be -1, so future calls to this function will + * also fail. + */ + gpt->current_kernel = new_kernel; + gpt->current_priority = new_prio; + + if (CGPT_KERNEL_ENTRY_NOT_FOUND == new_kernel) { + VBDEBUG(("GptNextKernelEntry no more kernels\n")); + return GPT_ERROR_NO_VALID_KERNEL; + } + + VBDEBUG(("GptNextKernelEntry likes partition %d\n", new_kernel + 1)); + e = entries + new_kernel; + *start_sector = e->starting_lba; + *size = e->ending_lba - e->starting_lba + 1; + return GPT_SUCCESS; } - -int GptUpdateKernelEntry(GptData* gpt, uint32_t update_type) { - GptHeader* header = (GptHeader*)gpt->primary_header; - GptEntry* entries = (GptEntry*)gpt->primary_entries; - GptEntry* e = entries + gpt->current_kernel; - uint16_t previous_attr = e->attrs.fields.gpt_att; - - if (gpt->current_kernel == CGPT_KERNEL_ENTRY_NOT_FOUND) - return GPT_ERROR_INVALID_UPDATE_TYPE; - if (!IsKernelEntry(e)) - return GPT_ERROR_INVALID_UPDATE_TYPE; - - switch (update_type) { - case GPT_UPDATE_ENTRY_TRY: { - /* Used up a try */ - int tries; - if (GetEntrySuccessful(e)) - return GPT_SUCCESS; /* Successfully booted this partition, so - * tries field is ignored. */ - tries = GetEntryTries(e); - if (tries > 1) { - /* Still have tries left */ - SetEntryTries(e, tries - 1); - break; - } - /* Out of tries, so drop through and mark partition bad. */ - } - case GPT_UPDATE_ENTRY_BAD: { - /* Giving up on this partition entirely. */ - if (!GetEntrySuccessful(e)) { - /* Only clear tries and priority if the successful bit is not set. */ - e->attrs.fields.gpt_att = previous_attr & ~( - CGPT_ATTRIBUTE_TRIES_MASK | - CGPT_ATTRIBUTE_PRIORITY_MASK); - } - break; - } - default: - return GPT_ERROR_INVALID_UPDATE_TYPE; - } - - /* If no change to attributes, we're done */ - if (e->attrs.fields.gpt_att == previous_attr) - return GPT_SUCCESS; - - /* Update the CRCs */ - header->entries_crc32 = Crc32((const uint8_t *)entries, - header->size_of_entry * - header->number_of_entries); - header->header_crc32 = HeaderCrc(header); - gpt->modified |= GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1; - - /* Use the repair function to update the other copy of the GPT. - * This is a tad inefficient, but is much faster than the disk I/O - * to update the GPT on disk so it doesn't matter. */ - gpt->valid_headers = MASK_PRIMARY; - gpt->valid_entries = MASK_PRIMARY; - GptRepair(gpt); - - return GPT_SUCCESS; +int GptUpdateKernelEntry(GptData *gpt, uint32_t update_type) +{ + GptHeader *header = (GptHeader *)gpt->primary_header; + GptEntry *entries = (GptEntry *)gpt->primary_entries; + GptEntry *e = entries + gpt->current_kernel; + uint16_t previous_attr = e->attrs.fields.gpt_att; + + if (gpt->current_kernel == CGPT_KERNEL_ENTRY_NOT_FOUND) + return GPT_ERROR_INVALID_UPDATE_TYPE; + if (!IsKernelEntry(e)) + return GPT_ERROR_INVALID_UPDATE_TYPE; + + switch (update_type) { + case GPT_UPDATE_ENTRY_TRY: { + /* Used up a try */ + int tries; + if (GetEntrySuccessful(e)) { + /* + * Successfully booted this partition, so tries field + * is ignored. + */ + return GPT_SUCCESS; + } + tries = GetEntryTries(e); + if (tries > 1) { + /* Still have tries left */ + SetEntryTries(e, tries - 1); + break; + } + /* Out of tries, so drop through and mark partition bad. */ + } + case GPT_UPDATE_ENTRY_BAD: { + /* Giving up on this partition entirely. */ + if (!GetEntrySuccessful(e)) { + /* + * Only clear tries and priority if the successful bit + * is not set. + */ + e->attrs.fields.gpt_att = previous_attr & + ~(CGPT_ATTRIBUTE_TRIES_MASK | + CGPT_ATTRIBUTE_PRIORITY_MASK); + } + break; + } + default: + return GPT_ERROR_INVALID_UPDATE_TYPE; + } + + /* If no change to attributes, we're done */ + if (e->attrs.fields.gpt_att == previous_attr) + return GPT_SUCCESS; + + /* Update the CRCs */ + header->entries_crc32 = Crc32((const uint8_t *)entries, + header->size_of_entry * + header->number_of_entries); + header->header_crc32 = HeaderCrc(header); + gpt->modified |= GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1; + + /* + * Use the repair function to update the other copy of the GPT. This + * is a tad inefficient, but is much faster than the disk I/O to update + * the GPT on disk so it doesn't matter. + */ + gpt->valid_headers = MASK_PRIMARY; + gpt->valid_entries = MASK_PRIMARY; + GptRepair(gpt); + + return GPT_SUCCESS; } diff --git a/firmware/lib/cgptlib/cgptlib_internal.c b/firmware/lib/cgptlib/cgptlib_internal.c index 86b2c151..d51ce33b 100644 --- a/firmware/lib/cgptlib/cgptlib_internal.c +++ b/firmware/lib/cgptlib/cgptlib_internal.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2010 The Chromium OS Authors. All rights reserved. +/* Copyright (c) 2013 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. */ @@ -10,396 +10,410 @@ #include "utility.h" -int CheckParameters(GptData *gpt) { - /* Currently, we only support 512-byte sector. In the future, we may support - * larger sector. */ - if (gpt->sector_bytes != 512) - return GPT_ERROR_INVALID_SECTOR_SIZE; - - /* The sector number of a drive should be reasonable. If the given value is - * too small to contain basic GPT structure (PMBR + Headers + Entries), - * the value is wrong. */ - if (gpt->drive_sectors < (1 + 2 * (1 + GPT_ENTRIES_SECTORS))) - return GPT_ERROR_INVALID_SECTOR_NUMBER; - - return GPT_SUCCESS; +int CheckParameters(GptData *gpt) +{ + /* Currently, we only support 512-byte sectors. */ + if (gpt->sector_bytes != 512) + return GPT_ERROR_INVALID_SECTOR_SIZE; + + /* + * Sector count of a drive should be reasonable. If the given value is + * too small to contain basic GPT structure (PMBR + Headers + Entries), + * the value is wrong. + */ + if (gpt->drive_sectors < (1 + 2 * (1 + GPT_ENTRIES_SECTORS))) + return GPT_ERROR_INVALID_SECTOR_NUMBER; + + return GPT_SUCCESS; } +uint32_t HeaderCrc(GptHeader *h) +{ + uint32_t crc32, original_crc32; -uint32_t HeaderCrc(GptHeader* h) { - uint32_t crc32, original_crc32; - - /* Original CRC is calculated with the CRC field 0. */ - original_crc32 = h->header_crc32; - h->header_crc32 = 0; - crc32 = Crc32((const uint8_t *)h, h->size); - h->header_crc32 = original_crc32; + /* Original CRC is calculated with the CRC field 0. */ + original_crc32 = h->header_crc32; + h->header_crc32 = 0; + crc32 = Crc32((const uint8_t *)h, h->size); + h->header_crc32 = original_crc32; - return crc32; + return crc32; } - -int CheckHeader(GptHeader *h, int is_secondary, uint64_t drive_sectors) { - if (!h) - return 1; - - /* Make sure we're looking at a header of reasonable size before - * attempting to calculate CRC. */ - if (Memcmp(h->signature, GPT_HEADER_SIGNATURE, GPT_HEADER_SIGNATURE_SIZE) && - Memcmp(h->signature, GPT_HEADER_SIGNATURE2, GPT_HEADER_SIGNATURE_SIZE)) - return 1; - if (h->revision != GPT_HEADER_REVISION) - return 1; - if (h->size < MIN_SIZE_OF_HEADER || h->size > MAX_SIZE_OF_HEADER) - return 1; - - /* Check CRC before looking at remaining fields */ - if (HeaderCrc(h) != h->header_crc32) - return 1; - - /* Reserved fields must be zero. */ - if (h->reserved_zero) - return 1; - - /* Could check that padding is zero, but that doesn't matter to us. */ - - /* If entry size is different than our struct, we won't be able to - * parse it. Technically, any size 2^N where N>=7 is valid. */ - if (h->size_of_entry != sizeof(GptEntry)) - return 1; - if ((h->number_of_entries < MIN_NUMBER_OF_ENTRIES) || - (h->number_of_entries > MAX_NUMBER_OF_ENTRIES) || - (h->number_of_entries * h->size_of_entry != TOTAL_ENTRIES_SIZE)) - return 1; - - /* Check locations for the header and its entries. The primary - * immediately follows the PMBR, and is followed by its entries. - * The secondary is at the end of the drive, preceded by its - * entries. */ - if (is_secondary) { - if (h->my_lba != drive_sectors - 1) - return 1; - if (h->entries_lba != h->my_lba - GPT_ENTRIES_SECTORS) - return 1; - } else { - if (h->my_lba != 1) - return 1; - if (h->entries_lba != h->my_lba + 1) - return 1; - } - - /* 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. */ - if (h->first_usable_lba < 2 + GPT_ENTRIES_SECTORS) - return 1; - if (h->last_usable_lba >= drive_sectors - 1 - GPT_ENTRIES_SECTORS) - return 1; - if (h->first_usable_lba > h->last_usable_lba) - return 1; - - /* Success */ - return 0; +int CheckHeader(GptHeader *h, int is_secondary, uint64_t drive_sectors) +{ + if (!h) + return 1; + + /* + * Make sure we're looking at a header of reasonable size before + * attempting to calculate CRC. + */ + if (Memcmp(h->signature, GPT_HEADER_SIGNATURE, + GPT_HEADER_SIGNATURE_SIZE) && + Memcmp(h->signature, GPT_HEADER_SIGNATURE2, + GPT_HEADER_SIGNATURE_SIZE)) + return 1; + if (h->revision != GPT_HEADER_REVISION) + return 1; + if (h->size < MIN_SIZE_OF_HEADER || h->size > MAX_SIZE_OF_HEADER) + return 1; + + /* Check CRC before looking at remaining fields */ + if (HeaderCrc(h) != h->header_crc32) + return 1; + + /* Reserved fields must be zero. */ + if (h->reserved_zero) + return 1; + + /* Could check that padding is zero, but that doesn't matter to us. */ + + /* + * If entry size is different than our struct, we won't be able to + * parse it. Technically, any size 2^N where N>=7 is valid. + */ + if (h->size_of_entry != sizeof(GptEntry)) + return 1; + if ((h->number_of_entries < MIN_NUMBER_OF_ENTRIES) || + (h->number_of_entries > MAX_NUMBER_OF_ENTRIES) || + (h->number_of_entries * h->size_of_entry != TOTAL_ENTRIES_SIZE)) + return 1; + + /* + * Check locations for the header and its entries. The primary + * immediately follows the PMBR, and is followed by its entries. The + * secondary is at the end of the drive, preceded by its entries. + */ + if (is_secondary) { + if (h->my_lba != drive_sectors - 1) + return 1; + if (h->entries_lba != h->my_lba - GPT_ENTRIES_SECTORS) + return 1; + } else { + if (h->my_lba != 1) + return 1; + if (h->entries_lba != h->my_lba + 1) + return 1; + } + + /* + * 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. + */ + if (h->first_usable_lba < 2 + GPT_ENTRIES_SECTORS) + return 1; + if (h->last_usable_lba >= drive_sectors - 1 - GPT_ENTRIES_SECTORS) + return 1; + if (h->first_usable_lba > h->last_usable_lba) + return 1; + + /* Success */ + return 0; } - -/* Return non-zero if the entry is unused, 0 if it is used. */ -int IsUnusedEntry(const GptEntry* e) { - static Guid zero = {{{0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0}}}}; - return !Memcmp(&zero, (const uint8_t*)(&e->type), sizeof(zero)); +int IsUnusedEntry(const GptEntry *e) +{ + static Guid zero = {{{0, 0, 0, 0, 0, {0, 0, 0, 0, 0, 0}}}}; + return !Memcmp(&zero, (const uint8_t*)(&e->type), sizeof(zero)); } -/* Returns non-zero if the entry is a Chrome OS kernel partition, else 0. */ -int IsKernelEntry(const GptEntry* e) { - static Guid chromeos_kernel = GPT_ENT_TYPE_CHROMEOS_KERNEL; - return !Memcmp(&e->type, &chromeos_kernel, sizeof(Guid)); +int IsKernelEntry(const GptEntry *e) +{ + static Guid chromeos_kernel = GPT_ENT_TYPE_CHROMEOS_KERNEL; + return !Memcmp(&e->type, &chromeos_kernel, sizeof(Guid)); } - -int CheckEntries(GptEntry* entries, GptHeader* h) { - - GptEntry* entry; - uint32_t crc32; - uint32_t i; - - /* Check CRC before examining entries. */ - crc32 = Crc32((const uint8_t *)entries, - h->size_of_entry * h->number_of_entries); - if (crc32 != h->entries_crc32) - return GPT_ERROR_CRC_CORRUPTED; - - /* Check all entries. */ - for (i = 0, entry = entries; i < h->number_of_entries; i++, entry++) { - GptEntry* e2; - uint32_t i2; - - if (IsUnusedEntry(entry)) - continue; - - /* Entry must be in valid region. */ - if ((entry->starting_lba < h->first_usable_lba) || - (entry->ending_lba > h->last_usable_lba) || - (entry->ending_lba < entry->starting_lba)) - return GPT_ERROR_OUT_OF_REGION; - - /* Entry must not overlap other entries. */ - for (i2 = 0, e2 = entries; i2 < h->number_of_entries; i2++, e2++) { - if (i2 == i || IsUnusedEntry(e2)) - continue; - - if ((entry->starting_lba >= e2->starting_lba) && - (entry->starting_lba <= e2->ending_lba)) - return GPT_ERROR_START_LBA_OVERLAP; - if ((entry->ending_lba >= e2->starting_lba) && - (entry->ending_lba <= e2->ending_lba)) - return GPT_ERROR_END_LBA_OVERLAP; - - /* UniqueGuid field must be unique. */ - if (0 == Memcmp(&entry->unique, &e2->unique, sizeof(Guid))) - return GPT_ERROR_DUP_GUID; - } - } - - /* Success */ - return 0; +int CheckEntries(GptEntry *entries, GptHeader *h) +{ + GptEntry *entry; + uint32_t crc32; + uint32_t i; + + /* Check CRC before examining entries. */ + crc32 = Crc32((const uint8_t *)entries, + h->size_of_entry * h->number_of_entries); + if (crc32 != h->entries_crc32) + return GPT_ERROR_CRC_CORRUPTED; + + /* Check all entries. */ + for (i = 0, entry = entries; i < h->number_of_entries; i++, entry++) { + GptEntry *e2; + uint32_t i2; + + if (IsUnusedEntry(entry)) + continue; + + /* Entry must be in valid region. */ + if ((entry->starting_lba < h->first_usable_lba) || + (entry->ending_lba > h->last_usable_lba) || + (entry->ending_lba < entry->starting_lba)) + return GPT_ERROR_OUT_OF_REGION; + + /* Entry must not overlap other entries. */ + for (i2 = 0, e2 = entries; i2 < h->number_of_entries; + i2++, e2++) { + if (i2 == i || IsUnusedEntry(e2)) + continue; + + if ((entry->starting_lba >= e2->starting_lba) && + (entry->starting_lba <= e2->ending_lba)) + return GPT_ERROR_START_LBA_OVERLAP; + if ((entry->ending_lba >= e2->starting_lba) && + (entry->ending_lba <= e2->ending_lba)) + return GPT_ERROR_END_LBA_OVERLAP; + + /* UniqueGuid field must be unique. */ + if (0 == Memcmp(&entry->unique, &e2->unique, + sizeof(Guid))) + return GPT_ERROR_DUP_GUID; + } + } + + /* Success */ + return 0; } - -/* Returns 0 if the GptHeaders are the same for all fields which don't - * differ between the primary and secondary headers - that is, all - * fields other than: - * - * my_lba - * alternate_lba - * entries_lba */ -int HeaderFieldsSame(GptHeader *h1, GptHeader *h2) { - if (Memcmp(h1->signature, h2->signature, sizeof(h1->signature))) - return 1; - if (h1->revision != h2->revision) - return 1; - if (h1->size != h2->size) - return 1; - if (h1->reserved_zero != h2->reserved_zero) - return 1; - if (h1->first_usable_lba != h2->first_usable_lba) - return 1; - if (h1->last_usable_lba != h2->last_usable_lba) - return 1; - if (Memcmp(&h1->disk_uuid, &h2->disk_uuid, sizeof(Guid))) - return 1; - if (h1->number_of_entries != h2->number_of_entries) - return 1; - if (h1->size_of_entry != h2->size_of_entry) - return 1; - if (h1->entries_crc32 != h2->entries_crc32) - return 1; - - return 0; +int HeaderFieldsSame(GptHeader *h1, GptHeader *h2) +{ + if (Memcmp(h1->signature, h2->signature, sizeof(h1->signature))) + return 1; + if (h1->revision != h2->revision) + return 1; + if (h1->size != h2->size) + return 1; + if (h1->reserved_zero != h2->reserved_zero) + return 1; + if (h1->first_usable_lba != h2->first_usable_lba) + return 1; + if (h1->last_usable_lba != h2->last_usable_lba) + return 1; + if (Memcmp(&h1->disk_uuid, &h2->disk_uuid, sizeof(Guid))) + return 1; + if (h1->number_of_entries != h2->number_of_entries) + return 1; + if (h1->size_of_entry != h2->size_of_entry) + return 1; + if (h1->entries_crc32 != h2->entries_crc32) + return 1; + + return 0; } - -int GptSanityCheck(GptData *gpt) { - int retval; - GptHeader* header1 = (GptHeader*)(gpt->primary_header); - GptHeader* header2 = (GptHeader*)(gpt->secondary_header); - GptEntry* entries1 = (GptEntry*)(gpt->primary_entries); - GptEntry* entries2 = (GptEntry*)(gpt->secondary_entries); - GptHeader* goodhdr = NULL; - - gpt->valid_headers = 0; - gpt->valid_entries = 0; - - retval = CheckParameters(gpt); - if (retval != GPT_SUCCESS) - return retval; - - /* Check both headers; we need at least one valid header. */ - if (0 == CheckHeader(header1, 0, gpt->drive_sectors)) { - gpt->valid_headers |= MASK_PRIMARY; - goodhdr = header1; - } - if (0 == CheckHeader(header2, 1, gpt->drive_sectors)) { - gpt->valid_headers |= MASK_SECONDARY; - if (!goodhdr) - goodhdr = header2; - } - - if (!gpt->valid_headers) - return GPT_ERROR_INVALID_HEADERS; - - /* Checks if entries are valid. - * - * Note that we use the same header in both checks. This way we'll - * catch the case where (header1,entries1) and (header2,entries2) - * are both valid, but (entries1 != entries2). */ - if (0 == CheckEntries(entries1, goodhdr)) - gpt->valid_entries |= MASK_PRIMARY; - if (0 == CheckEntries(entries2, goodhdr)) - gpt->valid_entries |= MASK_SECONDARY; - - /* If both headers are good but neither entries were good, check the - * entries with the secondary header. */ - if (MASK_BOTH == gpt->valid_headers && !gpt->valid_entries) { - if (0 == CheckEntries(entries1, header2)) - gpt->valid_entries |= MASK_PRIMARY; - if (0 == CheckEntries(entries2, header2)) - gpt->valid_entries |= MASK_SECONDARY; - if (gpt->valid_entries) { - /* Sure enough, header2 had a good CRC for one of the entries. Mark - * header1 invalid, so we'll update its entries CRC. */ - gpt->valid_headers &= ~MASK_PRIMARY; - goodhdr = header2; - } - } - - if (!gpt->valid_entries) - return GPT_ERROR_INVALID_ENTRIES; - - /* Now that we've determined which header contains a good CRC for - * the entries, make sure the headers are otherwise identical. */ - if (MASK_BOTH == gpt->valid_headers && - 0 != HeaderFieldsSame(header1, header2)) - gpt->valid_headers &= ~MASK_SECONDARY; - - return GPT_SUCCESS; +int GptSanityCheck(GptData *gpt) +{ + int retval; + GptHeader *header1 = (GptHeader *)(gpt->primary_header); + GptHeader *header2 = (GptHeader *)(gpt->secondary_header); + GptEntry *entries1 = (GptEntry *)(gpt->primary_entries); + GptEntry *entries2 = (GptEntry *)(gpt->secondary_entries); + GptHeader *goodhdr = NULL; + + gpt->valid_headers = 0; + gpt->valid_entries = 0; + + retval = CheckParameters(gpt); + if (retval != GPT_SUCCESS) + return retval; + + /* Check both headers; we need at least one valid header. */ + if (0 == CheckHeader(header1, 0, gpt->drive_sectors)) { + gpt->valid_headers |= MASK_PRIMARY; + goodhdr = header1; + } + if (0 == CheckHeader(header2, 1, gpt->drive_sectors)) { + gpt->valid_headers |= MASK_SECONDARY; + if (!goodhdr) + goodhdr = header2; + } + + if (!gpt->valid_headers) + return GPT_ERROR_INVALID_HEADERS; + + /* + * Check if entries are valid. + * + * Note that we use the same header in both checks. This way we'll + * catch the case where (header1,entries1) and (header2,entries2) are + * both valid, but (entries1 != entries2). + */ + if (0 == CheckEntries(entries1, goodhdr)) + gpt->valid_entries |= MASK_PRIMARY; + if (0 == CheckEntries(entries2, goodhdr)) + gpt->valid_entries |= MASK_SECONDARY; + + /* + * If both headers are good but neither entries were good, check the + * entries with the secondary header. + */ + if (MASK_BOTH == gpt->valid_headers && !gpt->valid_entries) { + if (0 == CheckEntries(entries1, header2)) + gpt->valid_entries |= MASK_PRIMARY; + if (0 == CheckEntries(entries2, header2)) + gpt->valid_entries |= MASK_SECONDARY; + if (gpt->valid_entries) { + /* + * Sure enough, header2 had a good CRC for one of the + * entries. Mark header1 invalid, so we'll update its + * entries CRC. + */ + gpt->valid_headers &= ~MASK_PRIMARY; + goodhdr = header2; + } + } + + if (!gpt->valid_entries) + return GPT_ERROR_INVALID_ENTRIES; + + /* + * Now that we've determined which header contains a good CRC for + * the entries, make sure the headers are otherwise identical. + */ + if (MASK_BOTH == gpt->valid_headers && + 0 != HeaderFieldsSame(header1, header2)) + gpt->valid_headers &= ~MASK_SECONDARY; + + return GPT_SUCCESS; } - -void GptRepair(GptData *gpt) { - GptHeader* header1 = (GptHeader*)(gpt->primary_header); - GptHeader* header2 = (GptHeader*)(gpt->secondary_header); - GptEntry* entries1 = (GptEntry*)(gpt->primary_entries); - GptEntry* entries2 = (GptEntry*)(gpt->secondary_entries); - int entries_size; - - /* Need at least one good header and one good set of entries. */ - if (MASK_NONE == gpt->valid_headers || MASK_NONE == gpt->valid_entries) - return; - - /* Repair headers if necessary */ - if (MASK_PRIMARY == gpt->valid_headers) { - /* Primary is good, secondary is bad */ - Memcpy(header2, header1, sizeof(GptHeader)); - header2->my_lba = gpt->drive_sectors - 1; - header2->alternate_lba = 1; - header2->entries_lba = header2->my_lba - GPT_ENTRIES_SECTORS; - header2->header_crc32 = HeaderCrc(header2); - gpt->modified |= GPT_MODIFIED_HEADER2; - } - else if (MASK_SECONDARY == gpt->valid_headers) { - /* Secondary is good, primary is bad */ - Memcpy(header1, header2, sizeof(GptHeader)); - header1->my_lba = 1; - header1->alternate_lba = gpt->drive_sectors - 1; - header1->entries_lba = header1->my_lba + 1; - header1->header_crc32 = HeaderCrc(header1); - gpt->modified |= GPT_MODIFIED_HEADER1; - } - gpt->valid_headers = MASK_BOTH; - - /* Repair entries if necessary */ - entries_size = header1->size_of_entry * header1->number_of_entries; - if (MASK_PRIMARY == gpt->valid_entries) { - /* Primary is good, secondary is bad */ - Memcpy(entries2, entries1, entries_size); - gpt->modified |= GPT_MODIFIED_ENTRIES2; - } - else if (MASK_SECONDARY == gpt->valid_entries) { - /* Secondary is good, primary is bad */ - Memcpy(entries1, entries2, entries_size); - gpt->modified |= GPT_MODIFIED_ENTRIES1; - } - gpt->valid_entries = MASK_BOTH; +void GptRepair(GptData *gpt) +{ + GptHeader *header1 = (GptHeader *)(gpt->primary_header); + GptHeader *header2 = (GptHeader *)(gpt->secondary_header); + GptEntry *entries1 = (GptEntry *)(gpt->primary_entries); + GptEntry *entries2 = (GptEntry *)(gpt->secondary_entries); + int entries_size; + + /* Need at least one good header and one good set of entries. */ + if (MASK_NONE == gpt->valid_headers || MASK_NONE == gpt->valid_entries) + return; + + /* Repair headers if necessary */ + if (MASK_PRIMARY == gpt->valid_headers) { + /* Primary is good, secondary is bad */ + Memcpy(header2, header1, sizeof(GptHeader)); + header2->my_lba = gpt->drive_sectors - 1; + header2->alternate_lba = 1; + header2->entries_lba = header2->my_lba - GPT_ENTRIES_SECTORS; + header2->header_crc32 = HeaderCrc(header2); + gpt->modified |= GPT_MODIFIED_HEADER2; + } + else if (MASK_SECONDARY == gpt->valid_headers) { + /* Secondary is good, primary is bad */ + Memcpy(header1, header2, sizeof(GptHeader)); + header1->my_lba = 1; + header1->alternate_lba = gpt->drive_sectors - 1; + header1->entries_lba = header1->my_lba + 1; + header1->header_crc32 = HeaderCrc(header1); + gpt->modified |= GPT_MODIFIED_HEADER1; + } + gpt->valid_headers = MASK_BOTH; + + /* Repair entries if necessary */ + entries_size = header1->size_of_entry * header1->number_of_entries; + if (MASK_PRIMARY == gpt->valid_entries) { + /* Primary is good, secondary is bad */ + Memcpy(entries2, entries1, entries_size); + gpt->modified |= GPT_MODIFIED_ENTRIES2; + } + else if (MASK_SECONDARY == gpt->valid_entries) { + /* Secondary is good, primary is bad */ + Memcpy(entries1, entries2, entries_size); + gpt->modified |= GPT_MODIFIED_ENTRIES1; + } + gpt->valid_entries = MASK_BOTH; } - -int GetEntrySuccessful(const GptEntry* e) { - return (e->attrs.fields.gpt_att & CGPT_ATTRIBUTE_SUCCESSFUL_MASK) >> - CGPT_ATTRIBUTE_SUCCESSFUL_OFFSET; +int GetEntrySuccessful(const GptEntry *e) +{ + return (e->attrs.fields.gpt_att & CGPT_ATTRIBUTE_SUCCESSFUL_MASK) >> + CGPT_ATTRIBUTE_SUCCESSFUL_OFFSET; } - -int GetEntryPriority(const GptEntry* e) { - return (e->attrs.fields.gpt_att & CGPT_ATTRIBUTE_PRIORITY_MASK) >> - CGPT_ATTRIBUTE_PRIORITY_OFFSET; +int GetEntryPriority(const GptEntry *e) +{ + return (e->attrs.fields.gpt_att & CGPT_ATTRIBUTE_PRIORITY_MASK) >> + CGPT_ATTRIBUTE_PRIORITY_OFFSET; } - -int GetEntryTries(const GptEntry* e) { - return (e->attrs.fields.gpt_att & CGPT_ATTRIBUTE_TRIES_MASK) >> - CGPT_ATTRIBUTE_TRIES_OFFSET; +int GetEntryTries(const GptEntry *e) +{ + return (e->attrs.fields.gpt_att & CGPT_ATTRIBUTE_TRIES_MASK) >> + CGPT_ATTRIBUTE_TRIES_OFFSET; } - -void SetEntrySuccessful(GptEntry* e, int successful) { - if (successful) - e->attrs.fields.gpt_att |= CGPT_ATTRIBUTE_SUCCESSFUL_MASK; - else - e->attrs.fields.gpt_att &= ~CGPT_ATTRIBUTE_SUCCESSFUL_MASK; +void SetEntrySuccessful(GptEntry *e, int successful) +{ + if (successful) + e->attrs.fields.gpt_att |= CGPT_ATTRIBUTE_SUCCESSFUL_MASK; + else + e->attrs.fields.gpt_att &= ~CGPT_ATTRIBUTE_SUCCESSFUL_MASK; } - -void SetEntryPriority(GptEntry* e, int priority) { - e->attrs.fields.gpt_att &= ~CGPT_ATTRIBUTE_PRIORITY_MASK; - e->attrs.fields.gpt_att |= (priority << CGPT_ATTRIBUTE_PRIORITY_OFFSET) & - CGPT_ATTRIBUTE_PRIORITY_MASK; +void SetEntryPriority(GptEntry *e, int priority) +{ + e->attrs.fields.gpt_att &= ~CGPT_ATTRIBUTE_PRIORITY_MASK; + e->attrs.fields.gpt_att |= + (priority << CGPT_ATTRIBUTE_PRIORITY_OFFSET) & + CGPT_ATTRIBUTE_PRIORITY_MASK; } - -void SetEntryTries(GptEntry* e, int tries) { - e->attrs.fields.gpt_att &= ~CGPT_ATTRIBUTE_TRIES_MASK; - e->attrs.fields.gpt_att |= (tries << CGPT_ATTRIBUTE_TRIES_OFFSET) & - CGPT_ATTRIBUTE_TRIES_MASK; +void SetEntryTries(GptEntry *e, int tries) +{ + e->attrs.fields.gpt_att &= ~CGPT_ATTRIBUTE_TRIES_MASK; + e->attrs.fields.gpt_att |= (tries << CGPT_ATTRIBUTE_TRIES_OFFSET) & + CGPT_ATTRIBUTE_TRIES_MASK; } -void GetCurrentKernelUniqueGuid(GptData *gpt, void *dest) { - GptEntry* entries = (GptEntry*)gpt->primary_entries; - GptEntry* e = entries + gpt->current_kernel; - Memcpy(dest, &e->unique, sizeof(Guid)); +void GetCurrentKernelUniqueGuid(GptData *gpt, void *dest) +{ + GptEntry *entries = (GptEntry *)gpt->primary_entries; + GptEntry *e = entries + gpt->current_kernel; + Memcpy(dest, &e->unique, sizeof(Guid)); } - -const char* GptErrorText(int error_code) +const char *GptErrorText(int error_code) { - switch(error_code) { - case GPT_SUCCESS: - return "none"; + switch(error_code) { + case GPT_SUCCESS: + return "none"; - case GPT_ERROR_NO_VALID_KERNEL: - return "Invalid kernel"; + case GPT_ERROR_NO_VALID_KERNEL: + return "Invalid kernel"; - case GPT_ERROR_INVALID_HEADERS: - return "Invalid headers"; + case GPT_ERROR_INVALID_HEADERS: + return "Invalid headers"; - case GPT_ERROR_INVALID_ENTRIES: - return "Invalid entries"; + case GPT_ERROR_INVALID_ENTRIES: + return "Invalid entries"; - case GPT_ERROR_INVALID_SECTOR_SIZE: - return "Invalid sector size"; + case GPT_ERROR_INVALID_SECTOR_SIZE: + return "Invalid sector size"; - case GPT_ERROR_INVALID_SECTOR_NUMBER: - return "Invalid sector number"; + case GPT_ERROR_INVALID_SECTOR_NUMBER: + return "Invalid sector number"; - case GPT_ERROR_INVALID_UPDATE_TYPE: - return "Invalid update type"; + case GPT_ERROR_INVALID_UPDATE_TYPE: + return "Invalid update type"; - case GPT_ERROR_CRC_CORRUPTED: - return "Entries' crc corrupted"; + case GPT_ERROR_CRC_CORRUPTED: + return "Entries' crc corrupted"; - case GPT_ERROR_OUT_OF_REGION: - return "Entry outside of valid region"; + case GPT_ERROR_OUT_OF_REGION: + return "Entry outside of valid region"; - case GPT_ERROR_START_LBA_OVERLAP: - return "Starting LBA overlaps"; + case GPT_ERROR_START_LBA_OVERLAP: + return "Starting LBA overlaps"; - case GPT_ERROR_END_LBA_OVERLAP: - return "Ending LBA overlaps"; + case GPT_ERROR_END_LBA_OVERLAP: + return "Ending LBA overlaps"; - case GPT_ERROR_DUP_GUID: - return "Duplicated GUID"; + case GPT_ERROR_DUP_GUID: + return "Duplicated GUID"; - default: - break; - }; - return "Unknown"; + default: + break; + }; + return "Unknown"; } diff --git a/firmware/lib/cgptlib/crc32.c b/firmware/lib/cgptlib/crc32.c index 9dacd178..002c5b9a 100755 --- a/firmware/lib/cgptlib/crc32.c +++ b/firmware/lib/cgptlib/crc32.c @@ -42,67 +42,68 @@ #include "crc32.h" static uint32_t crc32_tab[] = { - 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, - 0x706af48fU, 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, - 0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, - 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU, - 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U, 0x136c9856U, - 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U, - 0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U, - 0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU, - 0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, - 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U, 0x26d930acU, 0x51de003aU, - 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U, - 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U, - 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U, - 0x01db7106U, 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU, - 0x9fbfe4a5U, 0xe8b8d433U, 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU, - 0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU, 0x91646c97U, 0xe6635c01U, - 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU, 0x6c0695edU, - 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U, - 0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U, - 0xfbd44c65U, 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U, - 0x4adfa541U, 0x3dd895d7U, 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU, - 0x346ed9fcU, 0xad678846U, 0xda60b8d0U, 0x44042d73U, 0x33031de5U, - 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU, 0xbe0b1010U, - 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU, - 0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U, - 0x2eb40d81U, 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U, - 0x03b6e20cU, 0x74b1d29aU, 0xead54739U, 0x9dd277afU, 0x04db2615U, - 0x73dc1683U, 0xe3630b12U, 0x94643b84U, 0x0d6d6a3eU, 0x7a6a5aa8U, - 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U, 0xf00f9344U, - 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU, - 0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU, - 0x67dd4accU, 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U, - 0xd6d6a3e8U, 0xa1d1937eU, 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U, - 0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU, 0xd80d2bdaU, 0xaf0a1b4cU, - 0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U, 0x316e8eefU, - 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U, - 0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU, - 0xb2bd0b28U, 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U, - 0x2cd99e8bU, 0x5bdeae1dU, 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU, - 0x026d930aU, 0x9c0906a9U, 0xeb0e363fU, 0x72076785U, 0x05005713U, - 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U, 0x92d28e9bU, - 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U, - 0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U, - 0x18b74777U, 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU, - 0x8f659effU, 0xf862ae69U, 0x616bffd3U, 0x166ccf45U, 0xa00ae278U, - 0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U, 0xa7672661U, 0xd06016f7U, - 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU, 0x40df0b66U, - 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U, - 0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U, - 0xcdd70693U, 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U, - 0x5d681b02U, 0x2a6f2b94U, 0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU, - 0x2d02ef8dU + 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, + 0x706af48fU, 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, + 0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, + 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU, + 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U, 0x136c9856U, + 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U, + 0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U, + 0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU, + 0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, + 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U, 0x26d930acU, 0x51de003aU, + 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U, + 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U, + 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U, + 0x01db7106U, 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU, + 0x9fbfe4a5U, 0xe8b8d433U, 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU, + 0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU, 0x91646c97U, 0xe6635c01U, + 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU, 0x6c0695edU, + 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U, + 0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U, + 0xfbd44c65U, 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U, + 0x4adfa541U, 0x3dd895d7U, 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU, + 0x346ed9fcU, 0xad678846U, 0xda60b8d0U, 0x44042d73U, 0x33031de5U, + 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU, 0xbe0b1010U, + 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU, + 0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U, + 0x2eb40d81U, 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U, + 0x03b6e20cU, 0x74b1d29aU, 0xead54739U, 0x9dd277afU, 0x04db2615U, + 0x73dc1683U, 0xe3630b12U, 0x94643b84U, 0x0d6d6a3eU, 0x7a6a5aa8U, + 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U, 0xf00f9344U, + 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU, + 0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU, + 0x67dd4accU, 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U, + 0xd6d6a3e8U, 0xa1d1937eU, 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U, + 0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU, 0xd80d2bdaU, 0xaf0a1b4cU, + 0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U, 0x316e8eefU, + 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U, + 0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU, + 0xb2bd0b28U, 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U, + 0x2cd99e8bU, 0x5bdeae1dU, 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU, + 0x026d930aU, 0x9c0906a9U, 0xeb0e363fU, 0x72076785U, 0x05005713U, + 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U, 0x92d28e9bU, + 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U, + 0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U, + 0x18b74777U, 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU, + 0x8f659effU, 0xf862ae69U, 0x616bffd3U, 0x166ccf45U, 0xa00ae278U, + 0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U, 0xa7672661U, 0xd06016f7U, + 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU, 0x40df0b66U, + 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U, + 0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U, + 0xcdd70693U, 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U, + 0x5d681b02U, 0x2a6f2b94U, 0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU, + 0x2d02ef8dU }; -/* Returns a 32-bit CRC of the contents of the buffer. */ -uint32_t Crc32(const void *buffer, uint32_t len) { - uint8_t *byte = (uint8_t*)buffer; - uint32_t i; - uint32_t value = ~0U; - for (i = 0; i < len; ++i) - value = crc32_tab[(value ^ byte[i]) & 0xff] ^ (value >> 8); - return value ^ ~0U; +uint32_t Crc32(const void *buffer, uint32_t len) +{ + uint8_t *byte = (uint8_t *)buffer; + uint32_t i; + uint32_t value = ~0U; + + for (i = 0; i < len; ++i) + value = crc32_tab[(value ^ byte[i]) & 0xff] ^ (value >> 8); + return value ^ ~0U; } diff --git a/firmware/lib/cgptlib/include/cgptlib.h b/firmware/lib/cgptlib/include/cgptlib.h index 6633733e..ccaa2beb 100644 --- a/firmware/lib/cgptlib/include/cgptlib.h +++ b/firmware/lib/cgptlib/include/cgptlib.h @@ -9,20 +9,20 @@ #include "sysincludes.h" enum { - GPT_SUCCESS = 0, - GPT_ERROR_NO_VALID_KERNEL, - GPT_ERROR_INVALID_HEADERS, - GPT_ERROR_INVALID_ENTRIES, - GPT_ERROR_INVALID_SECTOR_SIZE, - GPT_ERROR_INVALID_SECTOR_NUMBER, - GPT_ERROR_INVALID_UPDATE_TYPE, - GPT_ERROR_CRC_CORRUPTED, - GPT_ERROR_OUT_OF_REGION, - GPT_ERROR_START_LBA_OVERLAP, - GPT_ERROR_END_LBA_OVERLAP, - GPT_ERROR_DUP_GUID, - /* Number of errors */ - GPT_ERROR_COUNT + GPT_SUCCESS = 0, + GPT_ERROR_NO_VALID_KERNEL, + GPT_ERROR_INVALID_HEADERS, + GPT_ERROR_INVALID_ENTRIES, + GPT_ERROR_INVALID_SECTOR_SIZE, + GPT_ERROR_INVALID_SECTOR_NUMBER, + GPT_ERROR_INVALID_UPDATE_TYPE, + GPT_ERROR_CRC_CORRUPTED, + GPT_ERROR_OUT_OF_REGION, + GPT_ERROR_START_LBA_OVERLAP, + GPT_ERROR_END_LBA_OVERLAP, + GPT_ERROR_DUP_GUID, + /* Number of errors */ + GPT_ERROR_COUNT }; /* Bit masks for GptData.modified field. */ @@ -31,56 +31,64 @@ enum { #define GPT_MODIFIED_ENTRIES1 0x04 #define GPT_MODIFIED_ENTRIES2 0x08 -#define TOTAL_ENTRIES_SIZE 16384 /* Size of GptData.primary_entries - * and secondary_entries: 128 - * bytes/entry * 128 entries. */ +/* + * Size of GptData.primary_entries and secondary_entries: 128 bytes/entry * 128 + * entries. + */ +#define TOTAL_ENTRIES_SIZE 16384 -/* The 'update_type' of GptUpdateKernelEntry() - * We expose TRY and BAD only because those are what verified boot needs. - * For more precise control on GPT attribute bits, please refer to - * gpt_internal.h */ +/* + * The 'update_type' of GptUpdateKernelEntry(). We expose TRY and BAD only + * because those are what verified boot needs. For more precise control on GPT + * attribute bits, please refer to gpt_internal.h. + */ enum { - GPT_UPDATE_ENTRY_TRY = 1, - /* System will be trying to boot the currently selected kernel partition. - * Update its try count if necessary. */ - GPT_UPDATE_ENTRY_BAD = 2, - /* The currently selected kernel partition failed validation. Mark entry as - * invalid. */ + /* + * System will be trying to boot the currently selected kernel + * partition. Update its try count if necessary. + */ + GPT_UPDATE_ENTRY_TRY = 1, + /* + * The currently selected kernel partition failed validation. Mark + * entry as invalid. + */ + GPT_UPDATE_ENTRY_BAD = 2, }; typedef struct { - /* Fill in the following fields before calling GptInit() */ - uint8_t *primary_header; /* GPT primary header, from sector 1 of disk - * (size: 512 bytes) */ - uint8_t *secondary_header; /* GPT secondary header, from last sector of - * disk (size: 512 bytes) */ - uint8_t *primary_entries; /* primary GPT table, follows primary header - * (size: 16 KB) */ - uint8_t *secondary_entries; /* secondary GPT table, precedes secondary - * header (size: 16 KB) */ - uint32_t sector_bytes; /* Size of a LBA sector, in bytes */ - uint64_t drive_sectors; /* Size of drive in LBA sectors, in sectors */ + /* Fill in the following fields before calling GptInit() */ + /* GPT primary header, from sector 1 of disk (size: 512 bytes) */ + uint8_t *primary_header; + /* GPT secondary header, from last sector of disk (size: 512 bytes) */ + uint8_t *secondary_header; + /* Primary GPT table, follows primary header (size: 16 KB) */ + uint8_t *primary_entries; + /* Secondary GPT table, precedes secondary header (size: 16 KB) */ + uint8_t *secondary_entries; + /* Size of a LBA sector, in bytes */ + uint32_t sector_bytes; + /* Size of drive in LBA sectors, in sectors */ + uint64_t drive_sectors; - /* Outputs */ - uint8_t modified; /* Which inputs have been modified? - * 0x01 = header1 - * 0x02 = header2 - * 0x04 = table1 - * 0x08 = table2 */ - int current_kernel; /* the current chromeos kernel index in partition table. - * -1 means not found on drive. Note that GPT partition - * numbers are traditionally 1-based, but we're using - * a zero-based index here. - */ + /* Outputs */ + /* Which inputs have been modified? GPT_MODIFIED_* */ + uint8_t modified; + /* + * The current chromeos kernel index in partition table. -1 means not + * found on drive. Note that GPT partition numbers are traditionally + * 1-based, but we're using a zero-based index here. + */ + int current_kernel; - /* Internal variables */ - uint32_t valid_headers, valid_entries; - int current_priority; + /* Internal variables */ + uint32_t valid_headers, valid_entries; + int current_priority; } GptData; -int GptInit(GptData* gpt); -/* Initializes the GPT data structure's internal state. The following fields - * must be filled before calling this function: +/** + * Initializes the GPT data structure's internal state. + * + * The following fields must be filled before calling this function: * * primary_header * secondary_header @@ -100,19 +108,23 @@ int GptInit(GptData* gpt); * GPT_ERROR_INVALID_SECTOR_SIZE, size of a sector is not supported, * GPT_ERROR_INVALID_SECTOR_NUMBER, number of sectors in drive is invalid (too * small) */ +int GptInit(GptData *gpt); -int GptNextKernelEntry(GptData* gpt, uint64_t* start_sector, uint64_t* size); -/* Provides the location of the next kernel partition, in order of decreasing - * priority. On return the start_sector parameter contains the LBA sector - * for the start of the kernel partition, and the size parameter contains the - * size of the kernel partition in LBA sectors. gpt.current_kernel contains - * the partition index of the current chromeos kernel partition. +/** + * Provides the location of the next kernel partition, in order of decreasing + * priority. + * + * On return the start_sector parameter contains the LBA sector for the start + * of the kernel partition, and the size parameter contains the size of the + * kernel partition in LBA sectors. gpt.current_kernel contains the partition + * index of the current chromeos kernel partition. * * Returns GPT_SUCCESS if successful, else * GPT_ERROR_NO_VALID_KERNEL, no avaliable kernel, enters recovery mode */ +int GptNextKernelEntry(GptData *gpt, uint64_t *start_sector, uint64_t *size); -int GptUpdateKernelEntry(GptData* gpt, uint32_t update_type); -/* Updates the kernel entry with the specified index, using the specified type +/** + * Updates the kernel entry with the specified index, using the specified type * of update (GPT_UPDATE_ENTRY_*). * * On return the modified field may be set, if the GPT data has been modified @@ -121,5 +133,6 @@ int GptUpdateKernelEntry(GptData* gpt, uint32_t update_type); * Returns GPT_SUCCESS if successful, else * GPT_ERROR_INVALID_UPDATE_TYPE, invalid 'update_type' is given. */ +int GptUpdateKernelEntry(GptData *gpt, uint32_t update_type); #endif /* VBOOT_REFERENCE_CGPTLIB_H_ */ diff --git a/firmware/lib/cgptlib/include/cgptlib_internal.h b/firmware/lib/cgptlib/include/cgptlib_internal.h index 36e598c2..c7606287 100644 --- a/firmware/lib/cgptlib/include/cgptlib_internal.h +++ b/firmware/lib/cgptlib/include/cgptlib_internal.h @@ -10,13 +10,15 @@ #include "cgptlib.h" #include "gpt.h" -/* If gpt->current_kernel is this value, means either: +/* + * If gpt->current_kernel is this value, means either: * 1. an initial value before scanning GPT entries, * 2. after scanning, no any valid kernel is found. */ #define CGPT_KERNEL_ENTRY_NOT_FOUND (-1) -/* Bit definitions and masks for GPT attributes. +/* + * Bit definitions and masks for GPT attributes. * * 63-61 -- (reserved) * 60 -- read-only @@ -55,80 +57,107 @@ /* Defines GPT sizes */ #define GPT_PMBR_SECTOR 1 /* size (in sectors) of PMBR */ #define GPT_HEADER_SECTOR 1 -#define GPT_ENTRIES_SECTORS 32 /* assume sector size if 512 bytes, then - * (TOTAL_ENTRIES_SIZE / 512) = 32 */ +/* + * Entries sectors assumes sector size if 512 bytes; then (TOTAL_ENTRIES_SIZE / + * 512) = 32 + */ +#define GPT_ENTRIES_SECTORS 32 -/* alias name of index in internal array for primary and secondary header and - * entries. */ +/* + * Alias name of index in internal array for primary and secondary header and + * entries. + */ enum { - /* constants for index */ - PRIMARY = 0, - SECONDARY = 1, - ANY_VALID = 9999, /* accept any between primary and secondary */ - - /* constants for bit mask */ - MASK_NONE = 0, - MASK_PRIMARY = 1, - MASK_SECONDARY = 2, - MASK_BOTH = 3, + /* constants for index */ + PRIMARY = 0, + SECONDARY = 1, + ANY_VALID = 9999, /* accept any between primary and secondary */ + + /* constants for bit mask */ + MASK_NONE = 0, + MASK_PRIMARY = 1, + MASK_SECONDARY = 2, + MASK_BOTH = 3, }; -/* Verify GptData parameters are sane. */ +/** + * Verify GptData parameters are sane. + */ int CheckParameters(GptData* gpt); -/* Check header fields. +/** + * Check header fields. * - * Returns 0 if header is valid, 1 if invalid. */ -int CheckHeader(GptHeader* h, int is_secondary, uint64_t drive_sectors); + * Returns 0 if header is valid, 1 if invalid. + */ +int CheckHeader(GptHeader *h, int is_secondary, uint64_t drive_sectors); -/* Calculate and return the header CRC. */ -uint32_t HeaderCrc(GptHeader* h); +/** + * Calculate and return the header CRC. + */ +uint32_t HeaderCrc(GptHeader *h); -/* Check entries. +/** + * Check entries. * - * Returns 0 if entries are valid, 1 if invalid. */ -int CheckEntries(GptEntry* entries, GptHeader* h); + * Returns 0 if entries are valid, 1 if invalid. + */ +int CheckEntries(GptEntry *entries, GptHeader *h); -/* Return 0 if the GptHeaders are the same for all fields which don't - * differ between the primary and secondary headers - that is, all - * fields other than: +/** + * Return 0 if the GptHeaders are the same for all fields which don't differ + * between the primary and secondary headers - that is, all fields other than: * * my_lba * alternate_lba - * entries_lba */ + * entries_lba + */ int HeaderFieldsSame(GptHeader *h1, GptHeader *h2); -/* Check GptData, headers, entries. +/** + * Check GptData, headers, entries. * * If successful, sets gpt->valid_headers and gpt->valid_entries and returns * GPT_SUCCESS. * - * On error, returns a GPT_ERROR_* return code. */ -int GptSanityCheck(GptData* gpt); + * On error, returns a GPT_ERROR_* return code. + */ +int GptSanityCheck(GptData *gpt); -/* Repairs GPT data by copying from one set of valid headers/entries to the +/** + * Repair GPT data by copying from one set of valid headers/entries to the * other. Assumes GptSanityCheck() has been run to determine which headers - * and/or entries are already valid. */ -void GptRepair(GptData* gpt); + * and/or entries are already valid. + */ +void GptRepair(GptData *gpt); /* Getters and setters for partition attribute fields. */ -int GetEntrySuccessful(const GptEntry* e); -int GetEntryPriority(const GptEntry* e); -int GetEntryTries(const GptEntry* e); -void SetEntrySuccessful(GptEntry* e, int successful); -void SetEntryPriority(GptEntry* e, int priority); -void SetEntryTries(GptEntry* e, int tries); -/* Return 1 if the entry is unused, 0 if it is used. */ -int IsUnusedEntry(const GptEntry* e); +int GetEntrySuccessful(const GptEntry *e); +int GetEntryPriority(const GptEntry *e); +int GetEntryTries(const GptEntry *e); +void SetEntrySuccessful(GptEntry *e, int successful); +void SetEntryPriority(GptEntry *e, int priority); +void SetEntryTries(GptEntry *e, int tries); -/* Returns 1 if the entry is a Chrome OS kernel partition, else 0. */ -int IsKernelEntry(const GptEntry* e); +/** + * Return 1 if the entry is unused, 0 if it is used. + */ +int IsUnusedEntry(const GptEntry *e); -/* Copies the current kernel partition's UniquePartitionGuid to the dest */ +/** + * Return 1 if the entry is a Chrome OS kernel partition, else 0. + */ +int IsKernelEntry(const GptEntry *e); + +/** + * Copy the current kernel partition's UniquePartitionGuid to the dest. + */ void GetCurrentKernelUniqueGuid(GptData *gpt, void *dest); -/* Returns a pointer to text describing the passed in error */ -const char* GptErrorText(int error_code); +/** + * Return a pointer to text describing the passed in error. + */ +const char *GptErrorText(int error_code); #endif /* VBOOT_REFERENCE_CGPTLIB_INTERNAL_H_ */ diff --git a/firmware/lib/cgptlib/include/gpt.h b/firmware/lib/cgptlib/include/gpt.h index 95b77145..5e60e957 100644 --- a/firmware/lib/cgptlib/include/gpt.h +++ b/firmware/lib/cgptlib/include/gpt.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2010-2011 The Chromium OS Authors. All rights reserved. +/* Copyright (c) 2013 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. * @@ -19,97 +19,97 @@ __pragma(pack(push,1)) /* Support packing for MSVC. */ #define GPT_HEADER_SIGNATURE_SIZE sizeof(GPT_HEADER_SIGNATURE) #define GPT_HEADER_REVISION 0x00010000 -/* The first 3 numbers should be stored in network-endian format - * according to the GUID RFC. The UEFI spec appendix A claims they - * should be stored in little-endian format. But they need to be - * _displayed_ in network-endian format, which is also how they're - * documented in the specs. +/* + * The first 3 numbers should be stored in network-endian format according to + * the GUID RFC. The UEFI spec appendix A claims they should be stored in + * little-endian format. But they need to be _displayed_ in network-endian + * format, which is also how they're documented in the specs. * - * Since what we have here are little-endian constants, they're - * byte-swapped from the normal display order. */ + * Since what we have here are little-endian constants, they're byte-swapped + * from the normal display order. + */ #define GPT_ENT_TYPE_UNUSED \ - {{{0x00000000,0x0000,0x0000,0x00,0x00,{0x00,0x00,0x00,0x00,0x00,0x00}}}} + {{{0x00000000,0x0000,0x0000,0x00,0x00,{0x00,0x00,0x00,0x00,0x00,0x00}}}} #define GPT_ENT_TYPE_EFI \ - {{{0xc12a7328,0xf81f,0x11d2,0xba,0x4b,{0x00,0xa0,0xc9,0x3e,0xc9,0x3b}}}} + {{{0xc12a7328,0xf81f,0x11d2,0xba,0x4b,{0x00,0xa0,0xc9,0x3e,0xc9,0x3b}}}} #define GPT_ENT_TYPE_CHROMEOS_FIRMWARE \ - {{{0xcab6e88e,0xabf3,0x4102,0xa0,0x7a,{0xd4,0xbb,0x9b,0xe3,0xc1,0xd3}}}} + {{{0xcab6e88e,0xabf3,0x4102,0xa0,0x7a,{0xd4,0xbb,0x9b,0xe3,0xc1,0xd3}}}} #define GPT_ENT_TYPE_CHROMEOS_KERNEL \ - {{{0xfe3a2a5d,0x4f32,0x41a7,0xb7,0x25,{0xac,0xcc,0x32,0x85,0xa3,0x09}}}} + {{{0xfe3a2a5d,0x4f32,0x41a7,0xb7,0x25,{0xac,0xcc,0x32,0x85,0xa3,0x09}}}} #define GPT_ENT_TYPE_CHROMEOS_ROOTFS \ - {{{0x3cb8e202,0x3b7e,0x47dd,0x8a,0x3c,{0x7f,0xf2,0xa1,0x3c,0xfc,0xec}}}} + {{{0x3cb8e202,0x3b7e,0x47dd,0x8a,0x3c,{0x7f,0xf2,0xa1,0x3c,0xfc,0xec}}}} #define GPT_ENT_TYPE_CHROMEOS_RESERVED \ - {{{0x2e0a753d,0x9e48,0x43b0,0x83,0x37,{0xb1,0x51,0x92,0xcb,0x1b,0x5e}}}} + {{{0x2e0a753d,0x9e48,0x43b0,0x83,0x37,{0xb1,0x51,0x92,0xcb,0x1b,0x5e}}}} #define GPT_ENT_TYPE_LINUX_DATA \ - {{{0xebd0a0a2,0xb9e5,0x4433,0x87,0xc0,{0x68,0xb6,0xb7,0x26,0x99,0xc7}}}} - + {{{0xebd0a0a2,0xb9e5,0x4433,0x87,0xc0,{0x68,0xb6,0xb7,0x26,0x99,0xc7}}}} #define UUID_NODE_LEN 6 #define GUID_SIZE 16 -/* GUID definition. - * Defined in appendix A of EFI standard. - */ +/* GUID definition. Defined in appendix A of EFI standard. */ typedef struct { - union { - struct { - uint32_t time_low; - uint16_t time_mid; - uint16_t time_high_and_version; - uint8_t clock_seq_high_and_reserved; - uint8_t clock_seq_low; - uint8_t node[UUID_NODE_LEN]; - } Uuid; - uint8_t raw[GUID_SIZE]; - } u; + union { + struct { + uint32_t time_low; + uint16_t time_mid; + uint16_t time_high_and_version; + uint8_t clock_seq_high_and_reserved; + uint8_t clock_seq_low; + uint8_t node[UUID_NODE_LEN]; + } Uuid; + uint8_t raw[GUID_SIZE]; + } u; } __attribute__((packed)) Guid; #define GUID_EXPECTED_SIZE GUID_SIZE -/* GPT header defines how many partitions exist on a drive and sectors managed. - * For every drive device, there are 2 headers, primary and secondary. - * Most of fields are duplicated except my_lba and entries_lba. +/* + * GPT header defines how many partitions exist on a drive and sectors managed. + * For every drive device, there are 2 headers, primary and secondary. Most of + * fields are duplicated except my_lba and entries_lba. * * You may find more details in chapter 5 of EFI standard. */ typedef struct { - char signature[8]; - uint32_t revision; - uint32_t size; - uint32_t header_crc32; - uint32_t reserved_zero; - uint64_t my_lba; - uint64_t alternate_lba; - uint64_t first_usable_lba; - uint64_t last_usable_lba; - Guid disk_uuid; - uint64_t entries_lba; - uint32_t number_of_entries; - uint32_t size_of_entry; - uint32_t entries_crc32; - /* Remainder of sector is reserved and should be 0 */ + char signature[8]; + uint32_t revision; + uint32_t size; + uint32_t header_crc32; + uint32_t reserved_zero; + uint64_t my_lba; + uint64_t alternate_lba; + uint64_t first_usable_lba; + uint64_t last_usable_lba; + Guid disk_uuid; + uint64_t entries_lba; + uint32_t number_of_entries; + uint32_t size_of_entry; + uint32_t entries_crc32; + /* Remainder of sector is reserved and should be 0 */ } __attribute__((packed)) GptHeader; #define GPTHEADER_EXPECTED_SIZE 92 -/* GPT partition entry defines the starting and ending LBAs of a partition. - * It also contains the unique GUID, type, and attribute bits. +/* + * GPT partition entry defines the starting and ending LBAs of a partition. It + * also contains the unique GUID, type, and attribute bits. * * You may find more details in chapter 5 of EFI standard. */ typedef struct { - Guid type; - Guid unique; - uint64_t starting_lba; - uint64_t ending_lba; - union { - struct { - uint16_t reserved[3]; - uint16_t gpt_att; - } __attribute__((packed)) fields; - uint64_t whole; - } attrs; - uint16_t name[36]; /* UTF-16 encoded partition name */ - /* Remainder of entry is reserved and should be 0 */ + Guid type; + Guid unique; + uint64_t starting_lba; + uint64_t ending_lba; + union { + struct { + uint16_t reserved[3]; + uint16_t gpt_att; + } __attribute__((packed)) fields; + uint64_t whole; + } attrs; + uint16_t name[36]; /* UTF-16 encoded partition name */ + /* Remainder of entry is reserved and should be 0 */ } __attribute__((packed)) GptEntry; #define GPTENTRY_EXPECTED_SIZE 128 |