411 lines
14 KiB
C
411 lines
14 KiB
C
/* Copyright (c) 2012 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.
|
|
*/
|
|
|
|
#define __STDC_FORMAT_MACROS
|
|
|
|
#include <string.h>
|
|
|
|
#include "cgpt.h"
|
|
#include "cgptlib_internal.h"
|
|
#include "crc32.h"
|
|
#include "vboot_host.h"
|
|
|
|
/* Generate output like:
|
|
*
|
|
* [AB-CD-EF-01] for group = 1
|
|
* [ABCD-EF01] for group = 3 (low byte first)
|
|
*
|
|
* Needs (size*3-1+3) bytes of space in 'buf' (included the tailing '\0').
|
|
*/
|
|
#define BUFFER_SIZE(size) (size *3 - 1 + 3)
|
|
static short Uint8To2Chars(const uint8_t t) {
|
|
int h = t >> 4;
|
|
int l = t & 0xf;
|
|
h = (h >= 0xA) ? h - 0xA + 'A' : h + '0';
|
|
l = (l >= 0xA) ? l - 0xA + 'A' : l + '0';
|
|
return (h << 8) + l;
|
|
}
|
|
|
|
static void RawDump(const uint8_t *memory, const int size,
|
|
char *buf, int group) {
|
|
int i, outlen = 0;
|
|
buf[outlen++] = '[';
|
|
for (i = 0; i < size; ++i) {
|
|
short c2 = Uint8To2Chars(memory[i]);
|
|
buf[outlen++] = c2 >> 8;
|
|
buf[outlen++] = c2 & 0xff;
|
|
if (i != (size - 1) && ((i + 1) % group) == 0)
|
|
buf[outlen++] = '-';
|
|
}
|
|
buf[outlen++] = ']';
|
|
buf[outlen++] = '\0';
|
|
}
|
|
|
|
/* Output formatters */
|
|
#define TITLE_FMT "%12s%12s%8s %s\n"
|
|
#define GPT_FMT "%12"PRId64"%12"PRId64"%8s %s\n"
|
|
#define GPT_MORE "%12s%12s%8s ", "", "", ""
|
|
#define PARTITION_FMT "%12"PRId64"%12"PRId64"%8d %s\n"
|
|
#define PARTITION_MORE "%12s%12s%8s %s%s\n", "", "", ""
|
|
|
|
static void PrintSignature(const char *indent, const char *sig, size_t n,
|
|
int raw) {
|
|
size_t i;
|
|
printf("%sSig: ", indent);
|
|
if (!raw) {
|
|
printf("[");
|
|
for (i = 0; i < n; ++i)
|
|
printf("%c", sig[i]);
|
|
printf("]");
|
|
} else {
|
|
char *buf = malloc(BUFFER_SIZE(n));
|
|
RawDump((uint8_t *)sig, n, buf, 1);
|
|
printf("%s", buf);
|
|
free(buf);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
static void HeaderDetails(GptHeader *header, GptEntry *entries,
|
|
const char *indent, int raw) {
|
|
PrintSignature(indent, header->signature, sizeof(header->signature), raw);
|
|
|
|
printf("%sRev: 0x%08x\n", indent, header->revision);
|
|
printf("%sSize: %d (blocks)\n", indent, header->size);
|
|
printf("%sHeader CRC: 0x%08x %s\n", indent, header->header_crc32,
|
|
(HeaderCrc(header) != header->header_crc32) ? "(INVALID)" : "");
|
|
printf("%sMy LBA: %lld\n", indent, (long long)header->my_lba);
|
|
printf("%sAlternate LBA: %lld\n", indent, (long long)header->alternate_lba);
|
|
printf("%sFirst LBA: %lld\n", indent, (long long)header->first_usable_lba);
|
|
printf("%sLast LBA: %lld\n", indent, (long long)header->last_usable_lba);
|
|
|
|
{ /* For disk guid */
|
|
char buf[GUID_STRLEN];
|
|
GuidToStr(&header->disk_uuid, buf, GUID_STRLEN);
|
|
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 %s\n", indent, header->entries_crc32,
|
|
header->entries_crc32 !=
|
|
Crc32((const uint8_t *)entries,header->size_of_entry *
|
|
header->number_of_entries)
|
|
? "INVALID" : ""
|
|
);
|
|
}
|
|
|
|
void EntryDetails(GptEntry *entry, uint32_t index, int raw) {
|
|
char contents[256]; // scratch buffer for formatting output
|
|
uint8_t label[GPT_PARTNAME_LEN];
|
|
char type[GUID_STRLEN], unique[GUID_STRLEN];
|
|
int clen;
|
|
|
|
UTF16ToUTF8(entry->name, sizeof(entry->name) / sizeof(entry->name[0]),
|
|
label, sizeof(label));
|
|
require(snprintf(contents, sizeof(contents),
|
|
"Label: \"%s\"", label) < sizeof(contents));
|
|
printf(PARTITION_FMT, (uint64_t)entry->starting_lba,
|
|
(uint64_t)(entry->ending_lba - entry->starting_lba + 1),
|
|
index+1, contents);
|
|
|
|
if (!raw && CGPT_OK == ResolveType(&entry->type, type)) {
|
|
printf(PARTITION_MORE, "Type: ", type);
|
|
} else {
|
|
GuidToStr(&entry->type, type, GUID_STRLEN);
|
|
printf(PARTITION_MORE, "Type: ", type);
|
|
}
|
|
GuidToStr(&entry->unique, unique, GUID_STRLEN);
|
|
printf(PARTITION_MORE, "UUID: ", unique);
|
|
|
|
clen = 0;
|
|
if (!raw) {
|
|
if (GuidEqual(&guid_chromeos_kernel, &entry->type)) {
|
|
int tries = (entry->attrs.fields.gpt_att &
|
|
CGPT_ATTRIBUTE_TRIES_MASK) >>
|
|
CGPT_ATTRIBUTE_TRIES_OFFSET;
|
|
int successful = (entry->attrs.fields.gpt_att &
|
|
CGPT_ATTRIBUTE_SUCCESSFUL_MASK) >>
|
|
CGPT_ATTRIBUTE_SUCCESSFUL_OFFSET;
|
|
int priority = (entry->attrs.fields.gpt_att &
|
|
CGPT_ATTRIBUTE_PRIORITY_MASK) >>
|
|
CGPT_ATTRIBUTE_PRIORITY_OFFSET;
|
|
clen = snprintf(contents, sizeof(contents),
|
|
"priority=%d tries=%d successful=%d ",
|
|
priority, tries, successful);
|
|
}
|
|
|
|
if (entry->attrs.fields.required) {
|
|
clen += snprintf(contents + clen, sizeof(contents) - clen,
|
|
"required=%d ", entry->attrs.fields.required);
|
|
require(clen < sizeof(contents));
|
|
}
|
|
|
|
if (entry->attrs.fields.efi_ignore) {
|
|
clen += snprintf(contents + clen, sizeof(contents) - clen,
|
|
"efi_ignore=%d ", entry->attrs.fields.efi_ignore);
|
|
require(clen < sizeof(contents));
|
|
}
|
|
|
|
if (entry->attrs.fields.legacy_boot) {
|
|
clen += snprintf(contents + clen, sizeof(contents) - clen,
|
|
"legacy_boot=%d ", entry->attrs.fields.legacy_boot);
|
|
require(clen < sizeof(contents));
|
|
}
|
|
} else {
|
|
clen = snprintf(contents, sizeof(contents),
|
|
"[%x]", entry->attrs.fields.gpt_att);
|
|
}
|
|
require(clen < sizeof(contents));
|
|
if (clen)
|
|
printf(PARTITION_MORE, "Attr: ", contents);
|
|
}
|
|
|
|
static void EntriesDetails(struct drive *drive, const int secondary, int raw) {
|
|
uint32_t i;
|
|
|
|
for (i = 0; i < GetNumberOfEntries(drive); ++i) {
|
|
GptEntry *entry;
|
|
entry = GetEntry(&drive->gpt, secondary, i);
|
|
|
|
if (GuidIsZero(&entry->type))
|
|
continue;
|
|
|
|
EntryDetails(entry, i, raw);
|
|
}
|
|
}
|
|
|
|
static int GptShow(struct drive *drive, CgptShowParams *params) {
|
|
int gpt_retval;
|
|
if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive->gpt))) {
|
|
Error("GptSanityCheck() returned %d: %s\n",
|
|
gpt_retval, GptError(gpt_retval));
|
|
return CGPT_FAILED;
|
|
}
|
|
|
|
if (params->partition) { // show single partition
|
|
|
|
if (params->partition > GetNumberOfEntries(drive)) {
|
|
Error("invalid partition number: %d\n", params->partition);
|
|
return CGPT_FAILED;
|
|
}
|
|
|
|
uint32_t index = params->partition - 1;
|
|
GptEntry *entry = GetEntry(&drive->gpt, ANY_VALID, index);
|
|
char buf[256]; // scratch buffer for string conversion
|
|
|
|
if (params->single_item) {
|
|
switch(params->single_item) {
|
|
case 'b':
|
|
printf("%" PRId64 "\n", entry->starting_lba);
|
|
break;
|
|
case 's': {
|
|
uint64_t size = 0;
|
|
// If these aren't actually defined, don't show anything
|
|
if (entry->ending_lba || entry->starting_lba)
|
|
size = entry->ending_lba - entry->starting_lba + 1;
|
|
printf("%" PRId64 "\n", size);
|
|
break;
|
|
}
|
|
case 't':
|
|
GuidToStr(&entry->type, buf, sizeof(buf));
|
|
printf("%s\n", buf);
|
|
break;
|
|
case 'u':
|
|
GuidToStr(&entry->unique, buf, sizeof(buf));
|
|
printf("%s\n", buf);
|
|
break;
|
|
case 'l':
|
|
UTF16ToUTF8(entry->name, sizeof(entry->name) / sizeof(entry->name[0]),
|
|
(uint8_t *)buf, sizeof(buf));
|
|
printf("%s\n", buf);
|
|
break;
|
|
case 'S':
|
|
printf("%d\n", GetSuccessful(drive, ANY_VALID, index));
|
|
break;
|
|
case 'T':
|
|
printf("%d\n", GetTries(drive, ANY_VALID, index));
|
|
break;
|
|
case 'P':
|
|
printf("%d\n", GetPriority(drive, ANY_VALID, index));
|
|
break;
|
|
case 'R':
|
|
printf("%d\n", GetRequired(drive, ANY_VALID, index));
|
|
break;
|
|
case 'B':
|
|
printf("%d\n", GetLegacyBoot(drive, ANY_VALID, index));
|
|
break;
|
|
case 'A':
|
|
printf("%#x\n", entry->attrs.fields.gpt_att);
|
|
break;
|
|
}
|
|
} else {
|
|
printf(TITLE_FMT, "start", "size", "part", "contents");
|
|
EntryDetails(entry, index, params->numeric);
|
|
}
|
|
|
|
} else if (params->quick) { // show all partitions, quickly
|
|
uint32_t i;
|
|
GptEntry *entry;
|
|
char type[GUID_STRLEN];
|
|
|
|
for (i = 0; i < GetNumberOfEntries(drive); ++i) {
|
|
entry = GetEntry(&drive->gpt, ANY_VALID, i);
|
|
|
|
if (GuidIsZero(&entry->type))
|
|
continue;
|
|
|
|
if (!params->numeric && CGPT_OK == ResolveType(&entry->type, type)) {
|
|
} else {
|
|
GuidToStr(&entry->type, type, GUID_STRLEN);
|
|
}
|
|
printf(PARTITION_FMT, (uint64_t)entry->starting_lba,
|
|
(uint64_t)(entry->ending_lba - entry->starting_lba + 1),
|
|
i+1, type);
|
|
}
|
|
} else { // show all partitions
|
|
GptEntry *entries;
|
|
|
|
if (params->debug || params->verbose) {
|
|
printf("Drive details:\n");
|
|
printf(" Total Size (bytes): %" PRIu64 "\n", drive->size);
|
|
printf(" LBA Size (bytes): %d\n", drive->gpt.sector_bytes);
|
|
if (drive->gpt.flags & GPT_FLAG_EXTERNAL) {
|
|
printf(" Drive (where GPT lives) Size (blocks): %" PRIu64 "\n",
|
|
drive->gpt.gpt_drive_sectors);
|
|
printf(" Drive (where partitions live) Size (blocks): %" PRIu64 "\n",
|
|
drive->gpt.streaming_drive_sectors);
|
|
} else {
|
|
// We know gpt_drive_sectors == streaming_drive_sectors here.
|
|
printf(" Drive Size (blocks): %" PRIu64 "\n",
|
|
drive->gpt.gpt_drive_sectors);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
if (CGPT_OK != ReadPMBR(drive)) {
|
|
Error("Unable to read PMBR\n");
|
|
return CGPT_FAILED;
|
|
}
|
|
|
|
printf(TITLE_FMT, "start", "size", "part", "contents");
|
|
char buf[256]; // buffer for formatted PMBR content
|
|
PMBRToStr(&drive->pmbr, buf, sizeof(buf)); // will exit if buf is too small
|
|
printf(GPT_FMT, (uint64_t)0, (uint64_t)GPT_PMBR_SECTORS, "", buf);
|
|
|
|
if (drive->gpt.ignored & MASK_PRIMARY) {
|
|
printf(GPT_FMT, (uint64_t)GPT_PMBR_SECTORS,
|
|
(uint64_t)GPT_HEADER_SECTORS, "IGNORED", "Pri GPT header");
|
|
} else {
|
|
if (drive->gpt.valid_headers & MASK_PRIMARY) {
|
|
printf(GPT_FMT, (uint64_t)GPT_PMBR_SECTORS,
|
|
(uint64_t)GPT_HEADER_SECTORS, "", "Pri GPT header");
|
|
} else {
|
|
printf(GPT_FMT, (uint64_t)GPT_PMBR_SECTORS,
|
|
(uint64_t)GPT_HEADER_SECTORS, "INVALID", "Pri GPT header");
|
|
}
|
|
|
|
if (params->debug ||
|
|
((drive->gpt.valid_headers & MASK_PRIMARY) && params->verbose)) {
|
|
GptHeader *header;
|
|
char indent[64];
|
|
|
|
require(snprintf(indent, sizeof(indent), GPT_MORE) < sizeof(indent));
|
|
header = (GptHeader*)drive->gpt.primary_header;
|
|
entries = (GptEntry*)drive->gpt.primary_entries;
|
|
HeaderDetails(header, entries, indent, params->numeric);
|
|
}
|
|
|
|
GptHeader* primary_header = (GptHeader*)drive->gpt.primary_header;
|
|
printf(GPT_FMT, (uint64_t)primary_header->entries_lba,
|
|
(uint64_t)CalculateEntriesSectors(primary_header,
|
|
drive->gpt.sector_bytes),
|
|
drive->gpt.valid_entries & MASK_PRIMARY ? "" : "INVALID",
|
|
"Pri GPT table");
|
|
|
|
if (params->debug ||
|
|
(drive->gpt.valid_entries & MASK_PRIMARY))
|
|
EntriesDetails(drive, PRIMARY, params->numeric);
|
|
}
|
|
|
|
/****************************** Secondary *************************/
|
|
if (drive->gpt.ignored & MASK_SECONDARY) {
|
|
printf(GPT_FMT,
|
|
(uint64_t)(drive->gpt.gpt_drive_sectors - GPT_HEADER_SECTORS),
|
|
(uint64_t)GPT_HEADER_SECTORS, "IGNORED", "Sec GPT header");
|
|
} else {
|
|
GptHeader* secondary_header = (GptHeader*)drive->gpt.secondary_header;
|
|
printf(GPT_FMT, (uint64_t)secondary_header->entries_lba,
|
|
(uint64_t)CalculateEntriesSectors(secondary_header,
|
|
drive->gpt.sector_bytes),
|
|
drive->gpt.valid_entries & MASK_SECONDARY ? "" : "INVALID",
|
|
"Sec GPT table");
|
|
/* We show secondary table details if any of following is true.
|
|
* 1. in debug mode.
|
|
* 2. primary table is being ignored
|
|
* 3. only secondary is valid.
|
|
* 4. secondary is not identical to primary.
|
|
*/
|
|
if (params->debug || (drive->gpt.ignored & MASK_PRIMARY) ||
|
|
((drive->gpt.valid_entries & MASK_SECONDARY) &&
|
|
(!(drive->gpt.valid_entries & MASK_PRIMARY) ||
|
|
memcmp(drive->gpt.primary_entries, drive->gpt.secondary_entries,
|
|
secondary_header->number_of_entries *
|
|
secondary_header->size_of_entry)))) {
|
|
EntriesDetails(drive, SECONDARY, params->numeric);
|
|
}
|
|
|
|
if (drive->gpt.valid_headers & MASK_SECONDARY) {
|
|
printf(GPT_FMT,
|
|
(uint64_t)(drive->gpt.gpt_drive_sectors - GPT_HEADER_SECTORS),
|
|
(uint64_t)GPT_HEADER_SECTORS, "", "Sec GPT header");
|
|
} else {
|
|
printf(GPT_FMT, (uint64_t)GPT_PMBR_SECTORS,
|
|
(uint64_t)GPT_HEADER_SECTORS, "INVALID", "Sec GPT header");
|
|
}
|
|
/* We show secondary header if any of following is true:
|
|
* 1. in debug mode.
|
|
* 2. primary table is being ignored
|
|
* 3. only secondary is valid.
|
|
* 4. secondary is not synonymous to primary and not ignored.
|
|
*/
|
|
if (params->debug || (drive->gpt.ignored & MASK_PRIMARY) ||
|
|
((drive->gpt.valid_headers & MASK_SECONDARY) &&
|
|
(!(drive->gpt.valid_headers & MASK_PRIMARY) ||
|
|
!IsSynonymous((GptHeader*)drive->gpt.primary_header,
|
|
(GptHeader*)drive->gpt.secondary_header)) &&
|
|
params->verbose)) {
|
|
GptHeader *header;
|
|
char indent[64];
|
|
|
|
require(snprintf(indent, sizeof(indent), GPT_MORE) < sizeof(indent));
|
|
header = (GptHeader*)drive->gpt.secondary_header;
|
|
entries = (GptEntry*)drive->gpt.secondary_entries;
|
|
HeaderDetails(header, entries, indent, params->numeric);
|
|
}
|
|
}
|
|
}
|
|
|
|
CheckValid(drive);
|
|
|
|
return CGPT_OK;
|
|
}
|
|
|
|
int CgptShow(CgptShowParams *params) {
|
|
struct drive drive;
|
|
|
|
if (params == NULL)
|
|
return CGPT_FAILED;
|
|
|
|
if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDONLY,
|
|
params->drive_size))
|
|
return CGPT_FAILED;
|
|
|
|
int ret = GptShow(&drive, params);
|
|
DriveClose(&drive, 0);
|
|
return ret;
|
|
}
|