Google Git
Sign in
chromium / external / github.com / coreos / seismograph / 426a3bbe7ca6c5250a52c7357511c0b233a644e6 / . / src / cgpt / cgpt_common.c
blob: 70c0c0474fb2c31eac85468d7511cbc66885f19a [file] [log] [blame]
/* 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 <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "cgpt.h"
#include "cgptlib_internal.h"
#include "crc32.h"
#include "vboot_host.h"
void Error(const char *format, ...) {
va_list ap;
va_start(ap, format);
fprintf(stderr, "ERROR: %s %s: ", progname, command);
vfprintf(stderr, format, ap);
va_end(ap);
}
int CheckValid(const struct drive *drive) {
if ((drive->gpt.valid_headers != MASK_BOTH) ||
(drive->gpt.valid_entries != MASK_BOTH)) {
fprintf(stderr, "\nWARNING: one of the GPT header/entries is invalid, "
"please run '%s repair'\n", progname);
return CGPT_FAILED;
}
return CGPT_OK;
}
/* Loads sectors from 'fd'.
* *buf is pointed to an allocated memory when returned, and should be
* freed by cgpt_close().
*
* fd -- file descriptot.
* buf -- pointer to buffer pointer
* sector -- offset of starting sector (in sectors)
* sector_bytes -- bytes per sector
* sector_count -- number of sectors to load
*
* Returns CGPT_OK for successful. Aborts if any error occurs.
*/
static int Load(const int fd, uint8_t **buf,
const uint64_t sector,
const uint64_t sector_bytes,
const uint64_t sector_count) {
int count; /* byte count to read */
int nread;
require(buf);
if (!sector_count || !sector_bytes) {
Error("%s() failed at line %d: sector_count=%d, sector_bytes=%d\n",
__FUNCTION__, __LINE__, sector_count, sector_bytes);
return CGPT_FAILED;
}
/* Make sure that sector_bytes * sector_count doesn't roll over. */
if (sector_bytes > (UINT64_MAX / sector_count)) {
Error("%s() failed at line %d: sector_count=%d, sector_bytes=%d\n",
__FUNCTION__, __LINE__, sector_count, sector_bytes);
return CGPT_FAILED;
}
count = sector_bytes * sector_count;
*buf = malloc(count);
require(*buf);
if (-1 == lseek(fd, sector * sector_bytes, SEEK_SET)) {
Error("Can't lseek: %s\n", strerror(errno));
goto error_free;
}
nread = read(fd, *buf, count);
if (nread < count) {
Error("Can't read enough: %d, not %d\n", nread, count);
goto error_free;
}
return CGPT_OK;
error_free:
free(*buf);
*buf = 0;
return CGPT_FAILED;
}
int ReadPMBR(struct drive *drive) {
if (-1 == lseek(drive->fd, 0, SEEK_SET))
return CGPT_FAILED;
int nread = read(drive->fd, &drive->pmbr, sizeof(struct pmbr));
if (nread != sizeof(struct pmbr))
return CGPT_FAILED;
return CGPT_OK;
}
int WritePMBR(struct drive *drive) {
if (-1 == lseek(drive->fd, 0, SEEK_SET))
return CGPT_FAILED;
int nwrote = write(drive->fd, &drive->pmbr, sizeof(struct pmbr));
if (nwrote != sizeof(struct pmbr))
return CGPT_FAILED;
return CGPT_OK;
}
/* Saves sectors to 'fd'.
*
* fd -- file descriptot.
* buf -- pointer to buffer
* sector -- starting sector offset
* sector_bytes -- bytes per sector
* sector_count -- number of sector to save
*
* Returns CGPT_OK for successful, CGPT_FAILED for failed.
*/
static int Save(const int fd, const uint8_t *buf,
const uint64_t sector,
const uint64_t sector_bytes,
const uint64_t sector_count) {
int count; /* byte count to write */
int nwrote;
require(buf);
count = sector_bytes * sector_count;
if (-1 == lseek(fd, sector * sector_bytes, SEEK_SET))
return CGPT_FAILED;
nwrote = write(fd, buf, count);
if (nwrote < count)
return CGPT_FAILED;
return CGPT_OK;
}
// Opens a block device or file, loads raw GPT data from it.
// If the drive is a file or doesn't exist and min_size is not zero then
// it will be extended to the requested size if necessary.
// An error raised if the drive is a block device smaller than min_size.
// min_size is specified in sectors
// mode should be O_RDONLY or O_RDWR
// min_size is required if mode includes O_CREAT
//
// Returns CGPT_FAILED if any error happens.
// Returns CGPT_OK if success and information are stored in 'drive'. */
int DriveOpen(const char *drive_path, struct drive *drive,
off_t min_size, int mode) {
struct stat stat;
require(drive_path);
require(drive);
if (mode & O_CREAT) {
require(min_size);
require(mode & O_RDWR);
}
// Clear struct for proper error handling.
memset(drive, 0, sizeof(struct drive));
drive->fd = open(drive_path, mode | O_LARGEFILE, 0666);
if (drive->fd == -1) {
Error("Can't open %s: %s\n", drive_path, strerror(errno));
return CGPT_FAILED;
}
if (fstat(drive->fd, &stat) == -1) {
Error("Can't fstat %s: %s\n", drive_path, strerror(errno));
goto error_close;
}
if ((stat.st_mode & S_IFMT) != S_IFREG) {
if (ioctl(drive->fd, BLKGETSIZE64, &drive->size) < 0) {
Error("Can't read drive size from %s: %s\n", drive_path, strerror(errno));
goto error_close;
}
if (ioctl(drive->fd, BLKSSZGET, &drive->gpt.sector_bytes) < 0) {
Error("Can't read sector size from %s: %s\n",
drive_path, strerror(errno));
goto error_close;
}
} else {
drive->gpt.sector_bytes = 512; /* bytes */
drive->size = stat.st_size;
if ((drive->size < (min_size * 512)) && (mode & O_RDWR)) {
drive->size = (min_size * 512);
if (ftruncate(drive->fd, drive->size) < 0) {
Error("Can't extend %s: %s\n", drive_path, strerror(errno));
goto error_close;
}
}
}
if (drive->size < (min_size * drive->gpt.sector_bytes)) {
Error("Drive %s is smaller than minimum: %d\n", drive_path, min_size);
goto error_close;
}
if (drive->size % drive->gpt.sector_bytes) {
Error("Media size (%llu) is not a multiple of sector size(%d)\n",
(long long unsigned int)drive->size, drive->gpt.sector_bytes);
goto error_close;
}
drive->gpt.drive_sectors = drive->size / drive->gpt.sector_bytes;
// Read the data.
if (CGPT_OK != Load(drive->fd, &drive->gpt.primary_header,
GPT_PMBR_SECTOR,
drive->gpt.sector_bytes, GPT_HEADER_SECTOR)) {
goto error_close;
}
if (CGPT_OK != Load(drive->fd, &drive->gpt.secondary_header,
drive->gpt.drive_sectors - GPT_PMBR_SECTOR,
drive->gpt.sector_bytes, GPT_HEADER_SECTOR)) {
goto error_close;
}
if (CGPT_OK != Load(drive->fd, &drive->gpt.primary_entries,
GPT_PMBR_SECTOR + GPT_HEADER_SECTOR,
drive->gpt.sector_bytes, GPT_ENTRIES_SECTORS)) {
goto error_close;
}
if (CGPT_OK != Load(drive->fd, &drive->gpt.secondary_entries,
drive->gpt.drive_sectors - GPT_HEADER_SECTOR
- GPT_ENTRIES_SECTORS,
drive->gpt.sector_bytes, GPT_ENTRIES_SECTORS)) {
goto error_close;
}
// We just load the data. Caller must validate it.
return CGPT_OK;
error_close:
(void) DriveClose(drive, 0);
return CGPT_FAILED;
}
int DriveClose(struct drive *drive, int update_as_needed) {
int errors = 0;
if (update_as_needed) {
if (drive->gpt.modified & GPT_MODIFIED_HEADER1) {
if (CGPT_OK != Save(drive->fd, drive->gpt.primary_header,
GPT_PMBR_SECTOR,
drive->gpt.sector_bytes, GPT_HEADER_SECTOR)) {
errors++;
Error("Cannot write primary header: %s\n", strerror(errno));
}
}
if (drive->gpt.modified & GPT_MODIFIED_HEADER2) {
if(CGPT_OK != Save(drive->fd, drive->gpt.secondary_header,
drive->gpt.drive_sectors - GPT_PMBR_SECTOR,
drive->gpt.sector_bytes, GPT_HEADER_SECTOR)) {
errors++;
Error("Cannot write secondary header: %s\n", strerror(errno));
}
}
if (drive->gpt.modified & GPT_MODIFIED_ENTRIES1) {
if (CGPT_OK != Save(drive->fd, drive->gpt.primary_entries,
GPT_PMBR_SECTOR + GPT_HEADER_SECTOR,
drive->gpt.sector_bytes, GPT_ENTRIES_SECTORS)) {
errors++;
Error("Cannot write primary entries: %s\n", strerror(errno));
}
}
if (drive->gpt.modified & GPT_MODIFIED_ENTRIES2) {
if (CGPT_OK != Save(drive->fd, drive->gpt.secondary_entries,
drive->gpt.drive_sectors - GPT_HEADER_SECTOR
- GPT_ENTRIES_SECTORS,
drive->gpt.sector_bytes, GPT_ENTRIES_SECTORS)) {
errors++;
Error("Cannot write secondary entries: %s\n", strerror(errno));
}
}
}
// Sync early! Only sync file descriptor here, and leave the whole system sync
// outside cgpt because whole system sync would trigger tons of disk accesses
// and timeout tests.
fsync(drive->fd);
close(drive->fd);
if (drive->gpt.primary_header)
free(drive->gpt.primary_header);
drive->gpt.primary_header = 0;
if (drive->gpt.primary_entries)
free(drive->gpt.primary_entries);
drive->gpt.primary_entries = 0;
if (drive->gpt.secondary_header)
free(drive->gpt.secondary_header);
drive->gpt.secondary_header = 0;
if (drive->gpt.secondary_entries)
free(drive->gpt.secondary_entries);
drive->gpt.secondary_entries = 0;
return errors ? CGPT_FAILED : CGPT_OK;
}
/* GUID conversion functions. Accepted format:
*
* "C12A7328-F81F-11D2-BA4B-00A0C93EC93B"
*
* Returns CGPT_OK if parsing is successful; otherwise CGPT_FAILED.
*/
#define GUID_FMT_UPPER "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X"
#define GUID_FMT_LOWER "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"
int StrToGuid(const char *str, Guid *guid) {
uint32_t time_low;
uint16_t time_mid;
uint16_t time_high_and_version;
unsigned int chunk[11];
if (11 != sscanf(str, GUID_FMT_UPPER,
chunk+0,
chunk+1,
chunk+2,
chunk+3,
chunk+4,
chunk+5,
chunk+6,
chunk+7,
chunk+8,
chunk+9,
chunk+10)) {
printf("FAILED\n");
return CGPT_FAILED;
}
time_low = chunk[0] & 0xffffffff;
time_mid = chunk[1] & 0xffff;
time_high_and_version = chunk[2] & 0xffff;
guid->u.Uuid.time_low = htole32(time_low);
guid->u.Uuid.time_mid = htole16(time_mid);
guid->u.Uuid.time_high_and_version = htole16(time_high_and_version);
guid->u.Uuid.clock_seq_high_and_reserved = chunk[3] & 0xff;
guid->u.Uuid.clock_seq_low = chunk[4] & 0xff;
guid->u.Uuid.node[0] = chunk[5] & 0xff;
guid->u.Uuid.node[1] = chunk[6] & 0xff;
guid->u.Uuid.node[2] = chunk[7] & 0xff;
guid->u.Uuid.node[3] = chunk[8] & 0xff;
guid->u.Uuid.node[4] = chunk[9] & 0xff;
guid->u.Uuid.node[5] = chunk[10] & 0xff;
return CGPT_OK;
}
static void GuidToStrGeneric(const char *fmt, const Guid *guid,
char *str, unsigned int buflen) {
require(buflen >= GUID_STRLEN);
require(snprintf(str, buflen, fmt,
le32toh(guid->u.Uuid.time_low),
le16toh(guid->u.Uuid.time_mid),
le16toh(guid->u.Uuid.time_high_and_version),
guid->u.Uuid.clock_seq_high_and_reserved,
guid->u.Uuid.clock_seq_low,
guid->u.Uuid.node[0], guid->u.Uuid.node[1],
guid->u.Uuid.node[2], guid->u.Uuid.node[3],
guid->u.Uuid.node[4], guid->u.Uuid.node[5]) == GUID_STRLEN-1);
}
void GuidToStrUpper(const Guid *guid, char *str, unsigned int buflen) {
GuidToStrGeneric(GUID_FMT_UPPER, guid, str, buflen);
}
void GuidToStrLower(const Guid *guid, char *str, unsigned int buflen) {
GuidToStrGeneric(GUID_FMT_LOWER, guid, str, buflen);
}
/* Convert possibly unterminated UTF16 string to UTF8.
* Caller must prepare enough space for UTF8, which could be up to
* twice the byte length of UTF16 string plus the terminating '\0'.
* See the following table for encoding lengths.
*
* Code point UTF16 UTF8
* 0x0000-0x007F 2 bytes 1 byte
* 0x0080-0x07FF 2 bytes 2 bytes
* 0x0800-0xFFFF 2 bytes 3 bytes
* 0x10000-0x10FFFF 4 bytes 4 bytes
*
* This function uses a simple state meachine to convert UTF-16 char(s) to
* a code point. Once a code point is parsed out, the state machine throws
* out sequencial UTF-8 chars in one time.
*
* Return: CGPT_OK --- all character are converted successfully.
* CGPT_FAILED --- convert error, i.e. output buffer is too short.
*/
int UTF16ToUTF8(const uint16_t *utf16, unsigned int maxinput,
uint8_t *utf8, unsigned int maxoutput)
{
size_t s16idx, s8idx;
uint32_t code_point = 0;
int code_point_ready = 1; // code point is ready to output.
int retval = CGPT_OK;
if (!utf16 || !maxinput || !utf8 || !maxoutput)
return CGPT_FAILED;
maxoutput--; /* plan for termination now */
for (s16idx = s8idx = 0;
s16idx < maxinput && utf16[s16idx] && maxoutput;
s16idx++) {
uint16_t codeunit = le16toh(utf16[s16idx]);
if (code_point_ready) {
if (codeunit >= 0xD800 && codeunit <= 0xDBFF) {
/* high surrogate, need the low surrogate. */
code_point_ready = 0;
code_point = (codeunit & 0x03FF) + 0x0040;
} else {
/* BMP char, output it. */
code_point = codeunit;
}
} else {
/* expect the low surrogate */
if (codeunit >= 0xDC00 && codeunit <= 0xDFFF) {
code_point = (code_point << 10) | (codeunit & 0x03FF);
code_point_ready = 1;
} else {
/* the second code unit is NOT the low surrogate. Unexpected. */
code_point_ready = 0;
retval = CGPT_FAILED;
break;
}
}
/* If UTF code point is ready, output it. */
if (code_point_ready) {
require(code_point <= 0x10FFFF);
if (code_point <= 0x7F && maxoutput >= 1) {
maxoutput -= 1;
utf8[s8idx++] = code_point & 0x7F;
} else if (code_point <= 0x7FF && maxoutput >= 2) {
maxoutput -= 2;
utf8[s8idx++] = 0xC0 | (code_point >> 6);
utf8[s8idx++] = 0x80 | (code_point & 0x3F);
} else if (code_point <= 0xFFFF && maxoutput >= 3) {
maxoutput -= 3;
utf8[s8idx++] = 0xE0 | (code_point >> 12);
utf8[s8idx++] = 0x80 | ((code_point >> 6) & 0x3F);
utf8[s8idx++] = 0x80 | (code_point & 0x3F);
} else if (code_point <= 0x10FFFF && maxoutput >= 4) {
maxoutput -= 4;
utf8[s8idx++] = 0xF0 | (code_point >> 18);
utf8[s8idx++] = 0x80 | ((code_point >> 12) & 0x3F);
utf8[s8idx++] = 0x80 | ((code_point >> 6) & 0x3F);
utf8[s8idx++] = 0x80 | (code_point & 0x3F);
} else {
/* buffer underrun */
retval = CGPT_FAILED;
break;
}
}
}
utf8[s8idx++] = 0;
return retval;
}
/* Convert UTF8 string to UTF16. The UTF8 string must be null-terminated.
* Caller must prepare enough space for UTF16, including a terminating 0x0000.
* See the following table for encoding lengths. In any case, the caller
* just needs to prepare the byte length of UTF8 plus the terminating 0x0000.
*
* Code point UTF16 UTF8
* 0x0000-0x007F 2 bytes 1 byte
* 0x0080-0x07FF 2 bytes 2 bytes
* 0x0800-0xFFFF 2 bytes 3 bytes
* 0x10000-0x10FFFF 4 bytes 4 bytes
*
* This function converts UTF8 chars to a code point first. Then, convrts it
* to UTF16 code unit(s).
*
* Return: CGPT_OK --- all character are converted successfully.
* CGPT_FAILED --- convert error, i.e. output buffer is too short.
*/
int UTF8ToUTF16(const uint8_t *utf8, uint16_t *utf16, unsigned int maxoutput)
{
size_t s16idx, s8idx;
uint32_t code_point = 0;
unsigned int expected_units = 1;
unsigned int decoded_units = 1;
int retval = CGPT_OK;
if (!utf8 || !utf16 || !maxoutput)
return CGPT_FAILED;
maxoutput--; /* plan for termination */
for (s8idx = s16idx = 0;
utf8[s8idx] && maxoutput;
s8idx++) {
uint8_t code_unit;
code_unit = utf8[s8idx];
if (expected_units != decoded_units) {
/* Trailing bytes of multi-byte character */
if ((code_unit & 0xC0) == 0x80) {
code_point = (code_point << 6) | (code_unit & 0x3F);
++decoded_units;
} else {
/* Unexpected code unit. */
retval = CGPT_FAILED;
break;
}
} else {
/* parsing a new code point. */
decoded_units = 1;
if (code_unit <= 0x7F) {
code_point = code_unit;
expected_units = 1;
} else if (code_unit <= 0xBF) {
/* 0x80-0xBF must NOT be the heading byte unit of a new code point. */
retval = CGPT_FAILED;
break;
} else if (code_unit >= 0xC2 && code_unit <= 0xDF) {
code_point = code_unit & 0x1F;
expected_units = 2;
} else if (code_unit >= 0xE0 && code_unit <= 0xEF) {
code_point = code_unit & 0x0F;
expected_units = 3;
} else if (code_unit >= 0xF0 && code_unit <= 0xF4) {
code_point = code_unit & 0x07;
expected_units = 4;
} else {
/* illegal code unit: 0xC0-0xC1, 0xF5-0xFF */
retval = CGPT_FAILED;
break;
}
}
/* If no more unit is needed, output the UTF16 unit(s). */
if ((retval == CGPT_OK) &&
(expected_units == decoded_units)) {
/* Check if the encoding is the shortest possible UTF-8 sequence. */
switch (expected_units) {
case 2:
if (code_point <= 0x7F) retval = CGPT_FAILED;
break;
case 3:
if (code_point <= 0x7FF) retval = CGPT_FAILED;
break;
case 4:
if (code_point <= 0xFFFF) retval = CGPT_FAILED;
break;
}
if (retval == CGPT_FAILED) break; /* leave immediately */
if ((code_point <= 0xD7FF) ||
(code_point >= 0xE000 && code_point <= 0xFFFF)) {
utf16[s16idx++] = code_point;
maxoutput -= 1;
} else if (code_point >= 0x10000 && code_point <= 0x10FFFF &&
maxoutput >= 2) {
utf16[s16idx++] = 0xD800 | ((code_point >> 10) - 0x0040);
utf16[s16idx++] = 0xDC00 | (code_point & 0x03FF);
maxoutput -= 2;
} else {
/* Three possibilities fall into here. Both are failure cases.
* a. surrogate pair (non-BMP characters; 0xD800~0xDFFF)
* b. invalid code point > 0x10FFFF
* c. buffer underrun
*/
retval = CGPT_FAILED;
break;
}
}
}
/* A null-terminator shows up before the UTF8 sequence ends. */
if (expected_units != decoded_units) {
retval = CGPT_FAILED;
}
utf16[s16idx++] = 0;
return retval;
}
/* global types to compare against */
const Guid guid_chromeos_firmware = GPT_ENT_TYPE_CHROMEOS_FIRMWARE;
const Guid guid_chromeos_kernel = GPT_ENT_TYPE_CHROMEOS_KERNEL;
const Guid guid_chromeos_rootfs = GPT_ENT_TYPE_CHROMEOS_ROOTFS;
const Guid guid_chromeos_reserved = GPT_ENT_TYPE_CHROMEOS_RESERVED;
const Guid guid_linux_data = GPT_ENT_TYPE_LINUX_DATA;
const Guid guid_linux_swap = GPT_ENT_TYPE_LINUX_SWAP;
const Guid guid_linux_boot = GPT_ENT_TYPE_LINUX_BOOT;
const Guid guid_linux_home = GPT_ENT_TYPE_LINUX_HOME;
const Guid guid_linux_lvm = GPT_ENT_TYPE_LINUX_LVM;
const Guid guid_linux_raid = GPT_ENT_TYPE_LINUX_RAID;
const Guid guid_linux_reserved = GPT_ENT_TYPE_LINUX_RESERVED;
const Guid guid_efi = GPT_ENT_TYPE_EFI;
const Guid guid_bios = GPT_ENT_TYPE_BIOS;
const Guid guid_unused = GPT_ENT_TYPE_UNUSED;
const Guid guid_coreos_reserved = GPT_ENT_TYPE_COREOS_RESERVED;
const Guid guid_coreos_resize = GPT_ENT_TYPE_COREOS_RESIZE;
const Guid guid_coreos_rootfs = GPT_ENT_TYPE_COREOS_ROOTFS;
const Guid guid_coreos_root_raid = GPT_ENT_TYPE_COREOS_ROOT_RAID;
const Guid guid_mswin_data = GPT_ENT_TYPE_MSWIN_DATA;
static struct {
const Guid *type;
char *name;
char *description;
} supported_types[] = {
// ChromeOS (prefix-less names for backwards compatibility)
{&guid_chromeos_firmware, "firmware", "ChromeOS firmware"},
{&guid_chromeos_kernel, "kernel", "ChromeOS kernel"},
{&guid_chromeos_rootfs, "rootfs", "ChromeOS rootfs"},
{&guid_linux_data, "data", "Alias for linux-data"},
{&guid_mswin_data, "chromeos-data", "Alias for mswin-data"},
{&guid_chromeos_reserved, "reserved", "ChromeOS reserved"},
// MS Windows (data used to use this GUID instead of linux-data)
{&guid_mswin_data, "mswin-data", "MS Windows data"},
// GPT/UEFI standard types
{&guid_efi, "efi", "EFI System Partition"},
{&guid_bios, "bios", "BIOS Boot Partition"},
{&guid_unused, "unused", "Unused (nonexistent) partition"},
// General Linux
{&guid_linux_data, "linux-data", "Linux data"},
{&guid_linux_swap, "linux-swap", "Linux swap"},
{&guid_linux_boot, "linux-boot", "Linux /boot"},
{&guid_linux_home, "linux-home", "Linux /home"},
{&guid_linux_lvm, "linux-lvm", "Linux LVM"},
{&guid_linux_raid, "linux-raid", "Linux RAID"},
{&guid_linux_reserved, "linux-reserved", "Linux reserved"},
// CoreOS
{&guid_coreos_rootfs, "coreos-usr", "Alias for coreos-rootfs"},
{&guid_coreos_rootfs, "coreos-rootfs", "CoreOS rootfs"},
{&guid_coreos_resize, "coreos-resize", "CoreOS auto-resize"},
{&guid_coreos_reserved, "coreos-reserved", "CoreOS reserved"},
{&guid_coreos_root_raid, "coreos-root-raid", "CoreOS RAID containing root"},
};
/* 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, size_t len) {
int i;
for (i = 0; i < ARRAY_COUNT(supported_types); ++i) {
if (!memcmp(type, supported_types[i].type, sizeof(Guid))) {
strncpy(buf, supported_types[i].description, len);
if (len > 0) {
buf[len-1] = '\0';
}
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));
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) {
printf(" %-16s %s\n", supported_types[i].name,
supported_types[i].description);
}
printf("\n");
}
GptHeader* GetGptHeader(const GptData *gpt) {
if (gpt->valid_headers & MASK_PRIMARY)
return (GptHeader*)gpt->primary_header;
else if (gpt->valid_headers & MASK_SECONDARY)
return (GptHeader*)gpt->secondary_header;
else
return 0;
}
uint32_t GetNumberOfEntries(const struct drive *drive) {
GptHeader *header = GetGptHeader(&drive->gpt);
if (!header)
return 0;
return header->number_of_entries;
}
GptEntry *GetEntry(GptData *gpt, int secondary, uint32_t entry_index) {
GptHeader *header = GetGptHeader(gpt);
uint8_t *entries;
uint32_t stride = header->size_of_entry;
require(stride);
require(entry_index < header->number_of_entries);
if (secondary == PRIMARY) {
entries = gpt->primary_entries;
} else if (secondary == SECONDARY) {
entries = gpt->secondary_entries;
} else { /* ANY_VALID */
require(secondary == ANY_VALID);
if (gpt->valid_entries & MASK_PRIMARY) {
entries = gpt->primary_entries;
} else {
require(gpt->valid_entries & MASK_SECONDARY);
entries = gpt->secondary_entries;
}
}
return (GptEntry*)(&entries[stride * entry_index]);
}
void SetLegacyBootable(struct drive *drive, int secondary,
uint32_t entry_index, int bootable) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
require(bootable >= 0 && bootable <= 1);
SetEntryLegacyBootable(entry, bootable);
}
int GetLegacyBootable(struct drive *drive, int secondary,
uint32_t entry_index) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
return GetEntryLegacyBootable(entry);
}
void SetPriority(struct drive *drive, int secondary, uint32_t entry_index,
int priority) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
require(priority >= 0 && priority <= CGPT_ATTRIBUTE_MAX_PRIORITY);
SetEntryPriority(entry, priority);
}
int GetPriority(struct drive *drive, int secondary, uint32_t entry_index) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
return GetEntryPriority(entry);
}
void SetTries(struct drive *drive, int secondary, uint32_t entry_index,
int tries) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
require(tries >= 0 && tries <= CGPT_ATTRIBUTE_MAX_TRIES);
SetEntryTries(entry, tries);
}
int GetTries(struct drive *drive, int secondary, uint32_t entry_index) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
return GetEntryTries(entry);
}
void SetSuccessful(struct drive *drive, int secondary, uint32_t entry_index,
int success) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
require(success >= 0 && success <= CGPT_ATTRIBUTE_MAX_SUCCESSFUL);
SetEntrySuccessful(entry, success);
}
int GetSuccessful(struct drive *drive, int secondary, uint32_t entry_index) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
return GetEntrySuccessful(entry);
}
void SetRaw(struct drive *drive, int secondary, uint32_t entry_index,
uint64_t raw) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, entry_index);
entry->attrs.whole = raw;
}
void UpdateAllEntries(struct drive *drive) {
RepairEntries(&drive->gpt, MASK_PRIMARY);
RepairHeader(&drive->gpt, MASK_PRIMARY);
drive->gpt.modified |= (GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1 |
GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2);
UpdateCrc(&drive->gpt);
}
int IsUnused(struct drive *drive, int secondary, uint32_t index) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, index);
return GuidIsZero(&entry->type);
}
int IsKernel(struct drive *drive, int secondary, uint32_t index) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, index);
return GuidEqual(&entry->type, &guid_chromeos_kernel);
}
int IsRoot(struct drive *drive, int secondary, uint32_t index) {
GptEntry *entry;
entry = GetEntry(&drive->gpt, secondary, index);
return GuidEqual(&entry->type, &guid_coreos_rootfs);
}
#define TOSTRING(A) #A
const char *GptError(int errnum) {
const char *error_string[] = {
TOSTRING(GPT_SUCCESS),
TOSTRING(GPT_ERROR_NO_VALID_KERNEL),
TOSTRING(GPT_ERROR_INVALID_HEADERS),
TOSTRING(GPT_ERROR_INVALID_ENTRIES),
TOSTRING(GPT_ERROR_INVALID_SECTOR_SIZE),
TOSTRING(GPT_ERROR_INVALID_SECTOR_NUMBER),
TOSTRING(GPT_ERROR_INVALID_UPDATE_TYPE)
};
if (errnum < 0 || errnum >= ARRAY_COUNT(error_string))
return "<illegal value>";
return error_string[errnum];
}
/* Update CRC value if necessary. */
void UpdateCrc(GptData *gpt) {
GptHeader *primary_header, *secondary_header;
primary_header = (GptHeader*)gpt->primary_header;
secondary_header = (GptHeader*)gpt->secondary_header;
if (gpt->modified & GPT_MODIFIED_ENTRIES1 &&
memcmp(primary_header, GPT_HEADER_SIGNATURE2,
GPT_HEADER_SIGNATURE_SIZE)) {
primary_header->entries_crc32 =
Crc32(gpt->primary_entries, TOTAL_ENTRIES_SIZE);
}
if (gpt->modified & GPT_MODIFIED_ENTRIES2) {
secondary_header->entries_crc32 =
Crc32(gpt->secondary_entries, TOTAL_ENTRIES_SIZE);
}
if (gpt->modified & GPT_MODIFIED_HEADER1) {
primary_header->header_crc32 = 0;
primary_header->header_crc32 = Crc32(
(const uint8_t *)primary_header, sizeof(GptHeader));
}
if (gpt->modified & GPT_MODIFIED_HEADER2) {
secondary_header->header_crc32 = 0;
secondary_header->header_crc32 = Crc32(
(const uint8_t *)secondary_header, sizeof(GptHeader));
}
}
/* Two headers are NOT bitwise identical. For example, my_lba pointers to header
* itself so that my_lba in primary and secondary is definitely different.
* Only the following fields should be identical.
*
* first_usable_lba
* last_usable_lba
* number_of_entries
* size_of_entry
* disk_uuid
*
* If any of above field are not matched, overwrite secondary with primary since
* we always trust primary.
* If any one of header is invalid, copy from another. */
int IsSynonymous(const GptHeader* a, const GptHeader* b) {
if ((a->first_usable_lba == b->first_usable_lba) &&
(a->last_usable_lba == b->last_usable_lba) &&
(a->number_of_entries == b->number_of_entries) &&
(a->size_of_entry == b->size_of_entry) &&
(!memcmp(&a->disk_uuid, &b->disk_uuid, sizeof(Guid))))
return 1;
return 0;
}
/* 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.
*/
uint8_t RepairEntries(GptData *gpt, const uint32_t valid_entries) {
/* If we have an alternate GPT header signature, don't overwrite
* the secondary GPT with the primary one as that might wipe the
* partition table. Also don't overwrite the primary one with the
* secondary one as that will stop Windows from booting. */
GptHeader* h = (GptHeader*)(gpt->primary_header);
if (!memcmp(h->signature, GPT_HEADER_SIGNATURE2, GPT_HEADER_SIGNATURE_SIZE))
return 0;
if (valid_entries == MASK_BOTH) {
if (memcmp(gpt->primary_entries, gpt->secondary_entries,
TOTAL_ENTRIES_SIZE)) {
memcpy(gpt->secondary_entries, gpt->primary_entries, TOTAL_ENTRIES_SIZE);
return GPT_MODIFIED_ENTRIES2;
}
} else if (valid_entries == MASK_PRIMARY) {
memcpy(gpt->secondary_entries, gpt->primary_entries, TOTAL_ENTRIES_SIZE);
return GPT_MODIFIED_ENTRIES2;
} else if (valid_entries == MASK_SECONDARY) {
memcpy(gpt->primary_entries, gpt->secondary_entries, TOTAL_ENTRIES_SIZE);
return GPT_MODIFIED_ENTRIES1;
}
return 0;
}
/* The above five fields are shared between primary and secondary headers.
* We can recover one header from another through copying those fields. */
void CopySynonymousParts(GptHeader* target, const GptHeader* source) {
target->first_usable_lba = source->first_usable_lba;
target->last_usable_lba = source->last_usable_lba;
target->number_of_entries = source->number_of_entries;
target->size_of_entry = source->size_of_entry;
memcpy(&target->disk_uuid, &source->disk_uuid, sizeof(Guid));
}
/* This function repairs primary and secondary headers if possible.
* If both headers are valid (CRC32 is correct) but
* a) indicate inconsistent usable LBA ranges,
* b) inconsistent partition entry size and number,
* c) inconsistent disk_uuid,
* we will use the primary header to overwrite secondary header.
* If primary is invalid (CRC32 is wrong), then we repair it from secondary.
* If secondary is invalid (CRC32 is wrong), then we repair it from primary.
* This function returns the bitmasks for modified header.
* Note that CRC value is NOT re-computed in this function. UpdateCrc() will
* do it later.
*/
uint8_t RepairHeader(GptData *gpt, const uint32_t valid_headers) {
GptHeader *primary_header, *secondary_header;
primary_header = (GptHeader*)gpt->primary_header;
secondary_header = (GptHeader*)gpt->secondary_header;
if (valid_headers == MASK_BOTH) {
if (!IsSynonymous(primary_header, secondary_header)) {
CopySynonymousParts(secondary_header, primary_header);
return GPT_MODIFIED_HEADER2;
}
} else if (valid_headers == MASK_PRIMARY) {
memcpy(secondary_header, primary_header, sizeof(GptHeader));
secondary_header->my_lba = gpt->drive_sectors - 1; /* the last sector */
secondary_header->alternate_lba = primary_header->my_lba;
secondary_header->entries_lba = secondary_header->my_lba -
GPT_ENTRIES_SECTORS;
return GPT_MODIFIED_HEADER2;
} else if (valid_headers == MASK_SECONDARY) {
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 GuidIsZero(const Guid *gp) {
return GuidEqual(gp, &guid_unused);
}
void InitPMBR(struct drive *drive, int secondary) {
memset(&drive->pmbr, 0, sizeof(drive->pmbr));
UpdatePMBR(drive, secondary);
}
/* Incoming support code for legacy CHS addressing and other MBR fun!
* References:
* http://en.wikipedia.org/wiki/Master_boot_record
* http://en.wikipedia.org/wiki/Cylinder-head-sector
* http://en.wikipedia.org/wiki/Logical_block_addressing#CHS_conversion
*
* Code checked against gptfdisk 0.8.8
* See mbrpart.cc for gptfdisk's implementation.
*/
#define MBR_CYL 1024 // 0 - 1023
#define MBR_HDS 255 // 0 - 254
#define MBR_SEC 63 // 1 - 63
static void compute_chs(uint8_t chs[3], uint64_t lba) {
uint32_t cyl, hds, sec;
require(lba <= UINT32_MAX);
if (lba == 0) {
cyl = hds = sec = 0;
} else if (lba > (MBR_CYL * MBR_HDS * MBR_SEC)) {
cyl = MBR_CYL - 1;
hds = MBR_HDS - 1;
sec = MBR_SEC;
} else {
sec = lba;
cyl = sec / (MBR_HDS * MBR_SEC);
sec = sec - cyl * MBR_HDS * MBR_SEC;
hds = sec / MBR_SEC;
sec = sec - hds * MBR_SEC + 1;
// sanity check that I wrote the above correctly
require(cyl < MBR_CYL && hds < MBR_HDS);
require(1 <= sec && sec <= MBR_SEC);
require(lba == (((cyl * MBR_HDS) + hds) * MBR_SEC) + sec - 1);
}
// heads
chs[0] = (uint8_t)hds;
// upper 2 bits of cylinders, sectors
chs[1] = ((uint8_t)(cyl >> 2) & 0xC0) | (uint8_t)sec;
// lower 8 bits of cylinders
chs[2] = (uint8_t)cyl;
}
enum mbr_type {
MBR_PROTECTIVE,
MBR_HYBRID,
MBR_BOOTABLE,
};
static void fill_part(struct legacy_partition *part, enum mbr_type type,
uint64_t starting_lba, uint64_t ending_lba) {
/* For simple protective MBRs do not compute CHS, use the same bogus
* values that parted does. May help avoid boot issues on some systems. */
if (type == MBR_PROTECTIVE) {
part->f_chs[0] = 0x00;
part->f_chs[1] = 0x01;
part->f_chs[2] = 0x00;
} else {
compute_chs(part->f_chs, starting_lba);
}
part->f_lba = htole32((uint32_t)starting_lba);
if (type == MBR_PROTECTIVE) {
part->l_chs[0] = 0xfe;
part->l_chs[1] = 0xff;
part->l_chs[2] = 0xff;
} else {
compute_chs(part->l_chs, ending_lba);
}
part->num_sect = htole32((uint32_t)(ending_lba - starting_lba + 1));
/* If the MBR partition is a bootable hybrid partition set the boot
* flag and use type 0x0c (FAT32 LBA). Although the partition is
* likely to be our EFI System Partition it cannot use it's proper
* type (0xef) because pvgrub and grub-0.97 will not recognize it. */
if (type == MBR_BOOTABLE) {
part->status = 0x80;
part->type = 0x0c;
} else {
part->status = 0x00;
part->type = 0xee;
}
}
void UpdatePMBR(struct drive *drive, int secondary) {
drive->pmbr.sig[0] = 0x55;
drive->pmbr.sig[1] = 0xaa;
memset(&drive->pmbr.part, 0, sizeof(drive->pmbr.part));
uint32_t max = UINT32_MAX;
if (drive->gpt.drive_sectors <= max)
max = drive->gpt.drive_sectors - 1;
// Search for any partitions with the Legacy BIOS Bootable flag,
// if found then create a hybrid MBR with the partition.
uint32_t index;
for (index = 0; index < GetNumberOfEntries(drive); index++) {
GptEntry *entry = GetEntry(&drive->gpt, secondary, index);
if (GuidIsZero(&entry->type) || !GetEntryLegacyBootable(entry))
continue;
// Only create a hybrid table if the partition fits
if (entry->ending_lba >= max)
continue;
// The first partition *must* be the boot partition for compatibility
// with Xen's pvgrub which only looks at the first MBR partition.
// The space between the MBR and first partition (which includes the
// primary GPT) is not covered by a protective partition because there
// may be issues when there are two partitions of type 0xee (EFI).
fill_part(&drive->pmbr.part[0], MBR_BOOTABLE,
entry->starting_lba, entry->ending_lba);
// Create protective partition to cover the GPT table.
fill_part(&drive->pmbr.part[1], MBR_HYBRID, 1, entry->starting_lba - 1);
return;
}
// No partition found for hybrid MBR, create standard protective MBR
fill_part(&drive->pmbr.part[0], MBR_PROTECTIVE, 1, max);
}
void PMBRToStr(struct pmbr *pmbr, char *str, unsigned int buflen) {
char buf[GUID_STRLEN];
if (pmbr->sig[0] != 0x55 || pmbr->sig[1] != 0xaa) {
require(snprintf(str, buflen, "Unknown") < buflen);
} else if (pmbr->magic[0] != 0x1d || pmbr->magic[1] != 0x9a) {
// Standard MBR code, no special SYSLINUX3 format.
if (pmbr->part[1].type != 0x00) {
require(snprintf(str, buflen, "Hybrid MBR") < buflen);
} else {
require(snprintf(str, buflen, "Protective MBR") < buflen);
}
} else if (GuidIsZero(&pmbr->syslinux3.boot_guid)) {
require(snprintf(str, buflen, "PMBR (SYSLINUX3)") < buflen);
} else {
GuidToStr(&pmbr->syslinux3.boot_guid, buf, sizeof(buf));
require(
snprintf(str, buflen, "PMBR (SYSLINUX3, Boot GUID: %s)", buf) < buflen);
}
}
#define DEV_DIR "/dev"
#define SYS_BLOCK_DIR "/sys/block"
#define BUFSIZE 1024
static const char *devdirs[] = { "/dev", "/devices", "/devfs", 0 };
// Given basename "foo", see if we can find a whole, real device by that name.
// This is copied from the logic in the linux utility 'findfs', although that
// does more exhaustive searching.
char *IsWholeDev(const char *basename) {
int i,j,len;
struct stat statbuf;
static char pathname[BUFSIZE]; // we'll return this.
char tmpname[BUFSIZE + 18]; // add sizeof(SYS_BLOCK_DIR"//device")
char tbasename[BUFSIZE];
// It should be a block device under /dev/,
for (i = 0; devdirs[i]; i++) {
snprintf(pathname, BUFSIZE, "%s/%s", devdirs[i], basename);
if (0 != stat(pathname, &statbuf))
continue;
if (!S_ISBLK(statbuf.st_mode))
continue;
// It should have a symlink called /sys/block/*/device
// but devices containing '/' (like cciss ones) must
// be changed to use "!" instead
len = strlen(basename);
for (j = 0; j < len && j < BUFSIZE - 1; j++) {
tbasename[j] = basename[j] == '/' ? '!' : basename[j];
}
tbasename[j] = 0;
snprintf(tmpname, sizeof(tmpname),
"%s/%s/device", SYS_BLOCK_DIR, tbasename);
if (0 != lstat(tmpname, &statbuf))
continue;
if (!S_ISLNK(statbuf.st_mode))
continue;
// found it
return pathname;
}
return 0;
}