gpt
get_map_widths(gpt_t gpt)
for (m = map_first(gpt); m != NULL; m = m->map_next) {
gpt_t gpt;
gpt = gpt_open(dev, GPT_READONLY, 0, 0, 0, 0);
if (gpt == NULL)
if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) == NULL)
for (m = map_first(gpt); m != NULL; m = m->map_next) {
gpt_close(gpt);
gpt_t gpt;
gpt = gpt_open(dev, GPT_MODIFIED, verbose, 0, 0, 0);
if (gpt == NULL)
m = map_find(gpt, MAP_TYPE_MBR);
if (gpt_write(gpt, m) == -1)
gpt_close(gpt);
gpt_t gpt;
gpt = gpt_open(dev, GPT_READONLY, verbose, 0, 0, 0);
if (gpt == NULL)
if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) == NULL)
w = get_map_widths(gpt);
for (m = map_first(gpt); m != NULL; m = m->map_next)
gpt_close(gpt);
gpt_t gpt;
gpt = gpt_open(parent, GPT_READONLY,
if (gpt == NULL)
if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) == NULL)
w = get_map_widths(gpt);
for (m = map_first(gpt); m != NULL; m = m->map_next) {
gpt_warnx(gpt, "index %u out of range (%u max)",
ent = gpt_ent_primary(gpt, i);
gpt_warnx(gpt, "Entry at index %u is not free", entry);
ent = gpt_ent_primary(gpt, i);
gpt_warnx(gpt, "No available table entries");
if (gpt_uuid_generate(gpt, ent->ent_guid) == -1) {
gpt_warnx(gpt, "Unable to make UUID");
alignsecs = alignment / gpt->secsz;
map = map_alloc(gpt, block, sectors, alignsecs);
gpt_warnx(gpt, "Not enough space available on "
map = map_alloc(gpt, block, sectors, 0);
gpt_warnx(gpt, "Not enough space available on device");
if (gpt_write_primary(gpt) == -1)
ent = gpt_ent_backup(gpt, i);
if (gpt_write_backup(gpt) == -1)
gpt_msg(gpt, "Partition %d added: %s %" PRIu64 " %" PRIu64, i + 1,
cmd_add(gpt_t gpt, int argc, char *argv[])
if (gpt_human_get(gpt, &block) == -1)
if (gpt_name_get(gpt, &name) == -1)
if (gpt_uuid_get(gpt, &type) == -1)
if (gpt_add_ais(gpt, &alignment, &entry, &size, ch)
if ((sectors = gpt_check_ais(gpt, alignment, ~0U, size)) == -1)
return add(gpt, alignment, block, sectors, size, entry, name, type);
add(gpt_t gpt, off_t alignment, off_t block, off_t sectors, off_t size __unused,
if ((hdr = gpt_hdr(gpt)) == NULL)
gpt_warnx(gpt, "proplib failure");
store_gpt(gpt_t gpt __unused, const struct gpt_hdr *hdr,
store_tbl(gpt_t gpt, const map_t m, prop_dictionary_t *type_dict)
m->map_size * gpt->secsz; i++, ent++) {
backup(gpt_t gpt, const char *outfile)
assert(gpt->secsz <= INT_MAX);
(int)gpt->secsz));
m = map_first(gpt);
if (store_mbr(gpt, i, mbr, &mbr_array) == -1)
if (store_gpt(gpt, m->map_data, &type_dict) == -1)
if (store_tbl(gpt, m, &type_dict) == -1)
gpt_warn(gpt, "Can't open `%s'", outfile);
cmd_backup(gpt_t gpt, int argc, char *argv[])
return backup(gpt, outfile);
store_mbr(gpt_t gpt, unsigned int i, const struct mbr *mbr,
gpt_warn(gpt, "Can't allocate memory for bootpath");
if ((buf = malloc((size_t)gpt->secsz)) == NULL) {
gpt_warn(gpt, "Can't allocate memory for sector");
gpt_warn(gpt, "Can't open `%s'", bp);
gpt_warnx(gpt, "The bootcode in `%s' does not match the"
gpt_warn(gpt, "Error reading from `%s'", bp);
set_bootable(gpt_t gpt, map_t map, map_t tbl, unsigned int i)
return gpt_write_crc(gpt, map, tbl);
biosboot(gpt_t gpt, off_t start, uint64_t size, u_int entry, uint8_t *label,
if (gpt_hdr(gpt) == NULL)
mbrmap = map_find(gpt, MAP_TYPE_PMBR);
gpt_warnx(gpt, "No valid Protective MBR found");
if ((bootcode = read_boot(gpt, bootpath)) == NULL) {
gpt_warnx(gpt, "Error reading bootcode");
for (m = map_first(gpt); m != NULL; m = m->map_next) {
gpt_warnx(gpt, "No bootable partition");
if (set_bootable(gpt, gpt->gpt, gpt->tbl, i) == -1)
if (set_bootable(gpt, gpt->tpg, gpt->lbt, i) == -1)
if (gpt_write(gpt, mbrmap) == -1) {
gpt_warnx(gpt, "Cannot update Protective MBR");
gpt_msg(gpt, "Partition %d marked as bootable", i + 1);
cmd_biosboot(gpt_t gpt, int argc, char *argv[])
gpt_t ngpt = gpt;
if (gpt_name_get(gpt, &bootpath) == -1)
if (gpt_uint_get(gpt, &entry) == -1)
if (gpt_name_get(gpt, &label) == -1)
if (gpt_human_get(gpt, &start) == -1)
if ((gpt->sb.st_mode & S_IFMT) != S_IFREG &&
ioctl(gpt->fd, DIOCGWEDGEINFO, &dkw) != -1) {
ngpt = gpt_open(dkw.dkw_parent, gpt->flags, gpt->verbose,
if (ngpt != gpt)
if (ngpt != gpt)
read_boot(gpt_t gpt, const char *bootpath)
gpt_warnx(gpt, "Error reading MBR");
map = map_add(gpt, 0LL, 1LL, MAP_TYPE_PMBR, mbr, 1);
if (gpt_write(gpt, map) == -1) {
gpt_warn(gpt, "Can't write PMBR");
if (gpt_create(gpt, last, parts, primary_only) == -1)
if (gpt_write_primary(gpt) == -1)
if (!primary_only && gpt_write_backup(gpt) == -1)
cmd_create(gpt_t gpt, int argc, char *argv[])
if (gpt_uint_get(gpt, &parts) == -1)
return create(gpt, parts, force, primary_only, active);
create(gpt_t gpt, u_int parts, int force, int primary_only, int active)
off_t last = gpt_last(gpt);
map = map_find(gpt, MAP_TYPE_MBR);
gpt_warnx(gpt, "Device contains a MBR");
if (map_find(gpt, MAP_TYPE_PMBR) == NULL) {
if (map_free(gpt, 0LL, 1LL) == 0) {
gpt_warnx(gpt, "No room for the PMBR");
mbr = gpt_read(gpt, 0LL, 1);
memset(pmbr->map_data, 0, gpt->secsz);
if (gpt_write(gpt, pmbr) == -1) {
gpt_warnx(gpt, "Error deleting PMBR");
cmd_destroy(gpt_t gpt, int argc, char *argv[])
return destroy(gpt, 0, recoverable);
destroy(gpt_t gpt, int force __unused, int recoverable)
pri_hdr = map_find(gpt, MAP_TYPE_PRI_GPT_HDR);
sec_hdr = map_find(gpt, MAP_TYPE_SEC_GPT_HDR);
pmbr = map_find(gpt, MAP_TYPE_PMBR);
gpt_warnx(gpt, "Device doesn't contain a GPT");
gpt_warnx(gpt, "Recoverability not possible");
memset(pri_hdr->map_data, 0, gpt->secsz);
if (gpt_write(gpt, pri_hdr) == -1) {
gpt_warnx(gpt, "Error writing primary header");
memset(sec_hdr->map_data, 0, gpt->secsz);
if (gpt_write(gpt, sec_hdr) == -1) {
gpt_warnx(gpt, "Error writing backup header");
gpt_size_get(gpt_t gpt, off_t *size)
*size = sectors * gpt->secsz;
if (sectors % gpt->secsz) {
gpt_warnx(gpt,
gpt->secsz);
if (human_num % gpt->secsz) {
gpt_warnx(gpt, "Size must be a multiple of sector size (%u)",
gpt->secsz);
gpt_human_get(gpt_t gpt, off_t *human)
gpt_warn(gpt, "Already set to %jd new `%s'", (intmax_t)*human,
gpt_warn(gpt, "Bad number `%s'", optarg);
gpt_warn(gpt, "Number `%s' < 1", optarg);
gpt_add_find(gpt_t gpt, struct gpt_find *find, int ch)
gpt_warn(gpt, "-a is already set");
if (gpt_human_get(gpt, &find->block) == -1)
if (gpt_uint_get(gpt, &find->entry) == -1)
if (gpt_name_get(gpt, &find->label) == -1)
if (gpt_size_get(gpt, &find->size) == -1)
gpt_warn(gpt, "Unknown find option `%c'", ch);
gpt_change_ent(gpt_t gpt, const struct gpt_find *find,
if (gpt_hdr(gpt) == NULL)
for (m = map_first(gpt); m != NULL; m = m->map_next) {
ent = gpt_ent_primary(gpt, i);
if (gpt_write_primary(gpt) == -1)
ent = gpt_ent_backup(gpt, i);
if (gpt_write_backup(gpt) == -1)
gpt_msg(gpt, "Partition %d %s", m->map_index, find->msg);
gpt_change_hdr(gpt_t gpt, const struct gpt_find *find,
if ((hdr = gpt_hdr(gpt)) == NULL)
if (gpt_write_primary(gpt) == -1)
hdr = gpt->tpg->map_data;
if (gpt_write_backup(gpt) == -1)
gpt_msg(gpt, "Header %s", find->msg);
gpt_add_ais(gpt_t gpt, off_t *alignment, u_int *entry, off_t *size, int ch)
if (gpt_human_get(gpt, alignment) == -1)
if (gpt_uint_get(gpt, entry) == -1)
if (gpt_size_get(gpt, size) == -1)
gpt_warn(gpt, "Unknown alignment/index/size option `%c'", ch);
gpt_check_ais(gpt_t gpt, off_t alignment, u_int entry, off_t size)
gpt_warnx(gpt, "Entry not specified");
if (alignment % gpt->secsz != 0) {
gpt_warnx(gpt, "Alignment (%#jx) must be a multiple of "
"sector size (%#x)", (uintmax_t)alignment, gpt->secsz);
if (size % gpt->secsz != 0) {
gpt_warnx(gpt, "Size (%#jx) must be a multiple of "
"sector size (%#x)", (uintmax_t)size, gpt->secsz);
return size / gpt->secsz;
gpt_attr_get(gpt_t gpt, uint64_t *attributes)
gpt_warnx(gpt, "Unrecognized attribute `%s'", ptr);
gpt_attr_update(gpt_t gpt, u_int entry, uint64_t set, uint64_t clr)
gpt_warnx(gpt, "Nothing to set");
if ((hdr = gpt_hdr(gpt)) == NULL)
gpt_warnx(gpt, "Index %u out of range (%u max)",
ent = gpt_ent_primary(gpt, i);
gpt_warnx(gpt, "Entry at index %u is unused", entry);
if (gpt_write_primary(gpt) == -1)
ent = gpt_ent_backup(gpt, i);
if (gpt_write_backup(gpt) == -1)
gpt_msg(gpt, "Partition %d attributes updated", entry);
gpt_scaled_uint_get(gpt_t gpt, u_int *entry)
gpt_warnx(gpt, "Value too big '%s'", optarg);
gpt_warnx(gpt, "Bad number `%s'", optarg);
gpt_uint_get(gpt_t gpt, u_int *entry)
gpt_warn(gpt, "Bad number `%s'", optarg);
gpt_uuid_get(gpt_t gpt, gpt_uuid_t *uuid)
gpt_warnx(gpt, "Can't parse uuid/type `%s'", optarg);
gpt_name_get(gpt_t gpt, void *v)
gpt_warn(gpt, "Can't copy string");
gpt_add_hdr(gpt_t gpt, int type, off_t loc)
t = &gpt->gpt;
t = &gpt->tpg;
gpt_warnx(gpt, "Unknown GPT header type %d", type);
if ((p = calloc(1, gpt->secsz)) == NULL) {
gpt_warn(gpt, "Error allocating %s GPT header", msg);
*t = map_add(gpt, loc, 1LL, type, p, 1);
gpt_warn(gpt, "Error adding %s GPT header", msg);
gpt_read(gpt_t gpt, off_t lba, size_t count)
count *= gpt->secsz;
ofs = lba * gpt->secsz;
if (lseek(gpt->fd, ofs, SEEK_SET) == ofs &&
read(gpt->fd, buf, count) == (ssize_t)count)
gpt_write(gpt_t gpt, map_t map)
if (gpt->flags & GPT_READONLY) {
gpt_warnx(gpt, "Readonly mode, no changes made");
count = (size_t)(map->map_size * gpt->secsz);
ofs = map->map_start * gpt->secsz;
if (lseek(gpt->fd, ofs, SEEK_SET) != ofs ||
write(gpt->fd, map->map_data, count) != (ssize_t)count)
gpt->flags |= GPT_MODIFIED;
gpt_mbr(gpt_t gpt, off_t lba, unsigned int *next_index, off_t ext_offset)
mbr = gpt_read(gpt, lba, 1);
gpt_warn(gpt, "Read failed");
if (gpt->verbose)
gpt_msg(gpt,
else if ((gpt->flags & GPT_HYBRID) == 0)
gpt_warnx(gpt, "Suspicious PMBR at sector %ju",
else if (gpt->verbose > 1)
gpt_msg(gpt, "PMBR at sector %ju", (uintmax_t)lba);
p = map_add(gpt, lba, 1LL, MAP_TYPE_PMBR, mbr, 1);
gpt_warnx(gpt, "Suspicious MBR at sector %ju", (uintmax_t)lba);
else if (gpt->verbose > 1)
gpt_msg(gpt, "MBR at sector %ju", (uintmax_t)lba);
p = map_add(gpt, lba, 1LL, MAP_TYPE_MBR, mbr, 1);
gpt_warnx(gpt, "Malformed MBR at sector %ju",
if (gpt->verbose > 2)
gpt_msg(gpt, "MBR part: flag=%#x type=%d, start=%ju, "
m = map_add(gpt, start, size, MAP_TYPE_MBR_PART, p, 0);
if (gpt_mbr(gpt, start, next_index,
gpt_gpt(gpt_t gpt, off_t lba, int found)
hdr = gpt_read(gpt, lba, 1);
gpt_warn(gpt, "Read failed");
if (gpt->verbose)
gpt_msg(gpt, "Bad CRC in GPT header at sector %ju",
blocks = tblsz / gpt->secsz + ((tblsz % gpt->secsz) ? 1 : 0);
p = gpt_read(gpt, (off_t)le64toh((uint64_t)hdr->hdr_lba_table), blocks);
if (gpt->verbose)
gpt_msg(gpt,
if (gpt->verbose)
gpt_msg(gpt, "Bad CRC in GPT table at sector %ju",
if (gpt->verbose > 1)
gpt_msg(gpt, "%s GPT at sector %ju",
m = map_add(gpt, lba, 1, (lba == 1)
m = map_add(gpt, (off_t)le64toh((uint64_t)hdr->hdr_lba_table),
if (gpt->verbose > 2) {
gpt_msg(gpt, "GPT partition: type=%s, start=%ju, "
m = map_add(gpt, (off_t)le64toh((uint64_t)ent->ent_lba_start),
gpt_t gpt;
if ((gpt = calloc(1, sizeof(*gpt))) == NULL) {
gpt->flags = flags;
gpt->verbose = verbose;
gpt->mediasz = mediasz;
gpt->secsz = secsz;
gpt->timestamp = timestamp;
gpt->uuidgen = 0;
mode = (gpt->flags & GPT_READONLY) ? O_RDONLY : O_RDWR|O_EXCL;
gpt->fd = opendisk(dev, mode, gpt->device_name,
sizeof(gpt->device_name), 0);
if (gpt->fd == -1 && !(gpt->flags & GPT_READONLY) && errno == EACCES) {
gpt->fd = opendisk(dev, O_RDONLY, gpt->device_name,
sizeof(gpt->device_name), 0);
if (gpt->fd != -1) {
gpt_warnx(gpt,
gpt->flags |= GPT_READONLY;
if (gpt->fd == -1 && !(gpt->flags & GPT_READONLY) && mediasz != 0 &&
strlcpy(gpt->device_name, dev, sizeof(gpt->device_name));
gpt->fd = open(dev, O_RDWR|O_EXCL|O_CREAT, 0644);
if (gpt->fd == -1) {
strlcpy(gpt->device_name, dev, sizeof(gpt->device_name));
gpt_warn(gpt, "Cannot open");
if (fstat(gpt->fd, &gpt->sb) == -1) {
gpt_warn(gpt, "Cannot stat");
if ((gpt->sb.st_mode & S_IFMT) != S_IFREG) {
if ((gpt->sb.st_mode & S_IFMT) != S_IFCHR &&
(gpt->sb.st_mode & S_IFMT) != S_IFBLK) {
gpt_warnx(gpt, "Not a device or plain file");
if (gpt->secsz == 0) {
if (ioctl(gpt->fd, DIOCGSECTORSIZE, &gpt->secsz) == -1) {
gpt_warn(gpt, "Cannot get sector size");
if (gpt->secsz == 0) {
gpt_warnx(gpt, "Sector size can't be 0");
if (gpt->mediasz == 0) {
if (ioctl(gpt->fd, DIOCGMEDIASIZE, &gpt->mediasz) == -1) {
gpt_warn(gpt, "Cannot get media size");
if (gpt->mediasz == 0) {
gpt_warnx(gpt, "Media size can't be 0");
gpt->flags |= GPT_FILE;
if (gpt->secsz == 0)
gpt->secsz = 512; /* Fixed size for files. */
if (gpt->mediasz == 0) {
if (gpt->sb.st_size % gpt->secsz) {
gpt_warnx(gpt,
(intmax_t)gpt->sb.st_size, gpt->secsz);
gpt->mediasz = gpt->sb.st_size;
gpt->flags |= GPT_NOSYNC;
devsz = gpt->mediasz / gpt->secsz;
gpt_warnx(gpt, "Need 6 sectors, we have %ju",
if (gpt->verbose) {
gpt_msg(gpt, "mediasize=%ju; sectorsize=%u; blocks=%ju",
(uintmax_t)gpt->mediasz, gpt->secsz, (uintmax_t)devsz);
if (map_init(gpt, devsz) == -1)
if (gpt->flags & GPT_FILE && gpt->sb.st_size == 0) {
if (gpt->flags & GPT_READONLY) {
gpt_warnx(gpt, "Cannot operate on empty file with -r");
gpt_warnx(gpt, "Need -m mediasz to use an empty file");
if (truncate(gpt->device_name, gpt->mediasz) == -1) {
gpt_warn(gpt, "truncate(%ju) failed",
(uintmax_t)gpt->mediasz);
if (gpt_mbr(gpt, 0LL, &idx, 0U) == -1)
if ((found = gpt_gpt(gpt, 1LL, 1)) == -1)
map = map_find(gpt, MAP_TYPE_PRI_GPT_HDR);
if (gpt_gpt(gpt, (off_t)lba, found) == -1)
if (gpt_gpt(gpt, devsz - 1LL, found) == -1)
return gpt;
gpt_warn(gpt, "No GPT found");
if (gpt->fd != -1)
close(gpt->fd);
free(gpt);
gpt_close(gpt_t gpt)
if (gpt == NULL)
if (!(gpt->flags & GPT_MODIFIED) || !(gpt->flags & GPT_SYNC))
if (!(gpt->flags & GPT_NOSYNC)) {
if (ioctl(gpt->fd, DIOCMWEDGES, &bits) == -1)
gpt_warn(gpt, "Can't update wedge information");
if (!(gpt->flags & GPT_FILE))
gpt_msg(gpt, "You need to run \"dkctl %s makewedges\""
" for the changes to take effect\n", gpt->device_name);
close(gpt->fd);
gpt_vwarnx(gpt_t gpt, const char *fmt, va_list ap, const char *e)
if (gpt && (gpt->flags & GPT_QUIET))
if (gpt)
fprintf(stderr, "%s: ", gpt->device_name);
gpt_warnx(gpt_t gpt, const char *fmt, ...)
gpt_vwarnx(gpt, fmt, ap, NULL);
gpt_warn(gpt_t gpt, const char *fmt, ...)
gpt_vwarnx(gpt, fmt, ap, strerror(errno));
gpt_msg(gpt_t gpt, const char *fmt, ...)
if (gpt && (gpt->flags & GPT_QUIET))
if (gpt)
printf("%s: ", gpt->device_name);
gpt_hdr(gpt_t gpt)
gpt->gpt = map_find(gpt, MAP_TYPE_PRI_GPT_HDR);
if (gpt->gpt == NULL) {
gpt_warnx(gpt, "No primary GPT header; run create or recover");
gpt->tpg = map_find(gpt, MAP_TYPE_SEC_GPT_HDR);
if (gpt->tpg == NULL) {
gpt_warnx(gpt, "No secondary GPT header; run recover");
gpt->tbl = map_find(gpt, MAP_TYPE_PRI_GPT_TBL);
gpt->lbt = map_find(gpt, MAP_TYPE_SEC_GPT_TBL);
if (gpt->tbl == NULL || gpt->lbt == NULL) {
gpt_warnx(gpt, "Corrupt maps, run recover");
return gpt->gpt->map_data;
gpt_write_crc(gpt_t gpt, map_t map, map_t tbl)
if (gpt->flags & GPT_READONLY)
if (gpt_write(gpt, map) == -1) {
gpt_warn(gpt, "Error writing crc map");
if (gpt_write(gpt, tbl) == -1) {
gpt_warn(gpt, "Error writing crc table");
gpt_write_primary(gpt_t gpt)
if (gpt->flags & GPT_READONLY) {
gpt_warnx(gpt, "Readonly mode, device unchanged");
return gpt_write_crc(gpt, gpt->gpt, gpt->tbl);
gpt_write_backup(gpt_t gpt)
return gpt_write_crc(gpt, gpt->tpg, gpt->lbt);
gpt_ent_primary(gpt_t gpt, unsigned int i)
return gpt_ent(gpt->gpt, gpt->tbl, i);
gpt_ent_backup(gpt_t gpt, unsigned int i)
return gpt_ent(gpt->tpg, gpt->lbt, i);
gpt_last(gpt_t gpt)
return gpt->mediasz / gpt->secsz - 1LL;
gpt_create(gpt_t gpt, off_t last, u_int parts, int primary_only)
if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) != NULL ||
map_find(gpt, MAP_TYPE_SEC_GPT_HDR) != NULL) {
gpt_warnx(gpt, "Device already contains a GPT, "
blocks = map_free(gpt, 1LL, 0LL);
gpt_warnx(gpt, "No room for the GPT header");
if ((uint64_t)(blocks - 1) * gpt->secsz >
blocks = (off_t)((parts * sizeof(struct gpt_ent)) / gpt->secsz);
if ((parts * sizeof(struct gpt_ent)) % gpt->secsz)
map = map_last(gpt);
gpt_warnx(gpt, "No room for the backup header");
gpt_warnx(gpt, "No room for the GPT table");
if (gpt_add_hdr(gpt, MAP_TYPE_PRI_GPT_HDR, 1) == -1)
if ((p = calloc((size_t)blocks, gpt->secsz)) == NULL) {
gpt_warnx(gpt, "Can't allocate the primary GPT table");
if ((gpt->tbl = map_add(gpt, 2LL, blocks,
gpt_warnx(gpt, "Can't add the primary GPT table");
hdr = gpt->gpt->map_data;
hdr->hdr_lba_self = htole64((uint64_t)gpt->gpt->map_start);
hdr->hdr_lba_start = htole64((uint64_t)(gpt->tbl->map_start + blocks));
if (gpt_uuid_generate(gpt, hdr->hdr_guid) == -1)
hdr->hdr_lba_table = htole64((uint64_t)(gpt->tbl->map_start));
hdr->hdr_entries = htole32((uint32_t)(((uint64_t)blocks * gpt->secsz) /
ent = gpt->tbl->map_data;
if (gpt_uuid_generate(gpt, ent[i].ent_guid) == -1)
if (gpt_add_hdr(gpt, MAP_TYPE_SEC_GPT_HDR, last) == -1)
if ((gpt->lbt = map_add(gpt, last - blocks, blocks,
MAP_TYPE_SEC_GPT_TBL, gpt->tbl->map_data, 0)) == NULL) {
gpt_warnx(gpt, "Can't add the secondary GPT table");
memcpy(gpt->tpg->map_data, gpt->gpt->map_data, gpt->secsz);
hdr = gpt->tpg->map_data;
hdr->hdr_lba_self = htole64((uint64_t)gpt->tpg->map_start);
hdr->hdr_lba_alt = htole64((uint64_t)gpt->gpt->map_start);
hdr->hdr_lba_table = htole64((uint64_t)gpt->lbt->map_start);
typedef struct gpt *gpt_t;
struct map *tbl, *lbt, *gpt, *tpg;
gpt_uuid_random(gpt_t gpt, struct dce_uuid *u, size_t n)
gpt_warn(gpt, "Can't open `/dev/urandom'");
gpt_warn(gpt, "Can't read `/dev/urandom'");
gpt_warnx(gpt, "EOF from /dev/urandom");
gpt_warnx(gpt, "read too much: %zd > %zu", nread, n);
gpt_uuid_tstamp(gpt_t gpt, struct dce_uuid *u, size_t l __unused)
if (gpt->timestamp < -12219292800 ||
gpt->timestamp > 103072857660)
x = (uint64_t)(gpt->timestamp + 12219292800) * 10000000;
x += gpt->uuidgen++;
gpt_uuid_generate(gpt_t gpt, gpt_uuid_t t)
if (gpt && (gpt->flags & GPT_TIMESTAMP))
rv = gpt_uuid_tstamp(gpt, &u, sizeof(u));
rv = gpt_uuid_random(gpt, &u, sizeof(u));
struct gpt;
int gpt_uuid_generate(struct gpt *, gpt_uuid_t);
cmd_header(gpt_t gpt, int argc, char *argv[] __unused)
return header(gpt);
header(gpt_t gpt)
gpt_show_num("Media Size", (uintmax_t)gpt->mediasz);
printf("Sector Size: %u\n", gpt->secsz);
(uintmax_t)(gpt->mediasz / gpt->secsz));
map = map_find(gpt, MAP_TYPE_PRI_GPT_HDR);
gpt_warn(gpt, "Can't copy string");
gpt_warn(gpt, "Can't label from `%s'", fn);
cmd_label(gpt_t gpt, int argc, char *argv[])
if (name_from_file(gpt, &name) == -1)
if (gpt_name_get(gpt, &name) == -1)
if (gpt_add_find(gpt, &find, ch) == -1)
return gpt_change_ent(gpt, &find, change, name);
name_from_file(gpt_t gpt, void *v)
gpt_warn(gpt, "Can't open `%s'", fn);
gpt_t gpt;
gpt = gpt_open(dev, flags | cmdsw[i]->flags,
if (gpt == NULL)
if (sectormult && mediasz == (uintmax_t)gpt->mediasz) {
if (mediasz / 512 > UINTMAX_MAX / gpt->secsz)
gpt->mediasz /= 512; /* UNHACK */
gpt->mediasz *= gpt->secsz;
gpt = NULL;
if ((*cmdsw[i]->fptr)(gpt, argc, argv) == -1)
if (gpt)
gpt_close(gpt);
for (n = gpt->mediamap; n; n = n->map_next)
n = gpt->mediamap;
if (!(gpt->flags & GPT_QUIET))
gpt_warnx(gpt, "Can't find map");
if (!(gpt->flags & GPT_QUIET))
gpt_warnx(gpt, "map entry doesn't fit media: "
if (!(gpt->flags & GPT_QUIET))
gpt_warnx(gpt,
gpt_warnx(gpt, "bogus map current=%s new=%s",
gpt->mediamap = m;
gpt->mediamap = p;
gpt_warn(gpt, "Can't create map");
map_alloc(gpt_t gpt, off_t start, off_t size, off_t alignment)
for (m = gpt->mediamap; m != NULL; m = m->map_next) {
return map_add(gpt, m->map_start + delta, size,
map_resize(gpt_t gpt, map_t m, off_t size, off_t alignment)
gpt_warnx(gpt, "negative size or alignment");
gpt_warnx(gpt, "Can't delete, next map is not found");
gpt_warnx(gpt, "Can't delete, next map is in use");
gpt_warnx(gpt, "Can't coalesce %ju <= %ju",
gpt_warn(gpt, "Can't create map");
gpt_warnx(gpt, "Can't expand map, no space after it");
gpt_warnx(gpt,
gpt_warnx(gpt,
map_find(gpt_t gpt, int type)
m = gpt->mediamap;
map_first(gpt_t gpt)
return gpt->mediamap;
map_last(gpt_t gpt)
m = gpt->mediamap;
map_free(gpt_t gpt, off_t start, off_t size)
m = gpt->mediamap;
map_init(gpt_t gpt, off_t size)
gpt->mediamap = map_create(0LL, size, MAP_TYPE_UNUSED);
if (gpt->mediamap == NULL) {
gpt_warn(gpt, "Can't create map");
gpt->lbawidth = snprintf(buf, sizeof(buf), "%ju", (uintmax_t)size);
if (gpt->lbawidth < 5)
gpt->lbawidth = 5;
map_add(gpt_t gpt, off_t start, off_t size, int type, void *data, int alloc)
struct gpt;
struct map *map_add(struct gpt *, off_t, off_t, int, void *, int);
struct map *map_alloc(struct gpt *, off_t, off_t, off_t);
struct map *map_find(struct gpt *, int);
struct map *map_first(struct gpt *);
struct map *map_last(struct gpt *);
off_t map_resize(struct gpt *, struct map *, off_t, off_t);
off_t map_free(struct gpt *, off_t, off_t);
int map_init(struct gpt *, off_t);
freebsd_fstype_to_gpt_type(gpt_t gpt, u_int i __unused, u_int fstype)
gpt_warnx(gpt, "Unknown FreeBSD partition (%d)", fstype);
netbsd_fstype_to_gpt_type(gpt_t gpt, u_int i, u_int fstype)
gpt_warnx(gpt, "Partition %u unknown type %s, "
migrate_disklabel(gpt_t gpt, off_t start, struct gpt_ent *ent,
buf = gpt_read(gpt, start + LABELSECTOR, 1);
gpt_warn(gpt, "Error reading label");
gpt_warnx(gpt, "MBR partition without disklabel");
if (gpt->verbose > 1)
gpt_msg(gpt, "rawofs=%ju", (uintmax_t)rawofs);
rawofs /= gpt->secsz;
if (gpt->verbose > 1)
gpt_msg(gpt, "Disklabel partition %u type %s", i,
type = (*convert)(gpt, i, dl->d_partitions[i].p_fstype);
le32toh(dl->d_secsize)) / gpt->secsz;
migrate(gpt_t gpt, u_int parts, int force, int slice, int active)
off_t last = gpt_last(gpt);
map = map_find(gpt, MAP_TYPE_MBR);
gpt_warnx(gpt, "No MBR in disk to convert");
if (gpt_create(gpt, last, parts, 0) == -1)
ent = gpt->tbl->map_data;
if (gpt->verbose > 1)
gpt_msg(gpt, "MBR partition %u type %s", i,
ent = migrate_disklabel(gpt, start, ent,
ent = migrate_disklabel(gpt, start, ent,
gpt_warnx(gpt, "unknown partition type (%d)",
if (gpt_write_primary(gpt) == -1)
if (gpt_write_backup(gpt) == -1)
if (gpt_write(gpt, map) == -1) {
gpt_warn(gpt, "Cant write PMBR");
cmd_migrate(gpt_t gpt, int argc, char *argv[])
if (gpt_uint_get(gpt, &parts) == -1)
return migrate(gpt, parts, force, slice, active);
memcpy((*dgpt)->map_data, sgpt->map_data, gpt->secsz);
if (gpt_write(gpt, *dgpt) == -1) {
gpt_warnx(gpt, "Writing %s GPT header failed", name);
gpt_msg(gpt, "Recovered %s GPT header from %s", name, origname);
recover_gpt_tbl(gpt_t gpt, int type, off_t start)
dtbl = &gpt->tbl;
stbl = gpt->lbt;
dtbl = &gpt->lbt;
stbl = gpt->tbl;
gpt_warn(gpt, "Bad table type %d", type);
*dtbl = map_add(gpt, start, stbl->map_size, type, stbl->map_data, 0);
gpt_warnx(gpt, "Adding %s GPT table failed", name);
if (gpt_write(gpt, *dtbl) == -1) {
gpt_warnx(gpt, "Writing %s GPT table failed", name);
gpt_msg(gpt, "Recovered %s GPT table from %s", name, origname);
recover(gpt_t gpt)
off_t last = gpt_last(gpt);
if (map_find(gpt, MAP_TYPE_MBR) != NULL) {
gpt_warnx(gpt, "Device contains an MBR");
gpt->gpt = map_find(gpt, MAP_TYPE_PRI_GPT_HDR);
gpt->tpg = map_find(gpt, MAP_TYPE_SEC_GPT_HDR);
gpt->tbl = map_find(gpt, MAP_TYPE_PRI_GPT_TBL);
gpt->lbt = map_find(gpt, MAP_TYPE_SEC_GPT_TBL);
if (gpt->gpt == NULL && gpt->tpg == NULL) {
gpt_warnx(gpt, "No primary or secondary GPT headers, "
if (gpt->tbl == NULL && gpt->lbt == NULL) {
gpt_warnx(gpt, "No primary or secondary GPT tables, "
if (gpt->gpt != NULL &&
le64toh(((struct gpt_hdr *)(gpt->gpt->map_data))->hdr_lba_alt) !=
gpt_warnx(gpt, "Media size has changed, please use "
if (gpt->tbl != NULL && gpt->lbt == NULL) {
if (recover_gpt_tbl(gpt, MAP_TYPE_SEC_GPT_TBL,
last - gpt->tbl->map_size) == -1)
} else if (gpt->tbl == NULL && gpt->lbt != NULL) {
if (recover_gpt_tbl(gpt, MAP_TYPE_PRI_GPT_TBL, 2LL) == -1)
if (gpt->gpt != NULL && gpt->tpg == NULL) {
if (recover_gpt_hdr(gpt, MAP_TYPE_SEC_GPT_HDR, last) == -1)
} else if (gpt->gpt == NULL && gpt->tpg != NULL) {
if (recover_gpt_hdr(gpt, MAP_TYPE_PRI_GPT_HDR, 1LL) == -1)
if (map_find(gpt, MAP_TYPE_PMBR) == NULL) {
if (map_free(gpt, 0LL, 1LL) == 0) {
gpt_warnx(gpt, "No room for the PMBR");
mbr = gpt_read(gpt, 0LL, 1);
gpt_warnx(gpt, "Error reading MBR");
map = map_add(gpt, 0LL, 1LL, MAP_TYPE_PMBR, mbr, 1);
if (gpt_write(gpt, map) == -1) {
gpt_warn(gpt, "Can't write PMBR");
gpt_msg(gpt,
cmd_recover(gpt_t gpt, int argc, char *argv[])
return recover(gpt);
recover_gpt_hdr(gpt_t gpt, int type, off_t last)
if (gpt_add_hdr(gpt, type, last) == -1)
dgpt = &gpt->gpt;
dtbl = gpt->tbl;
sgpt = gpt->tpg;
stbl = gpt->lbt;
dgpt = &gpt->tpg;
dtbl = gpt->lbt;
sgpt = gpt->gpt;
stbl = gpt->tbl;
gpt_warn(gpt, "Bad table type %d", type);
cmd_remove(gpt_t gpt, int argc, char *argv[])
if (gpt_add_find(gpt, &find, ch) == -1)
return gpt_change_ent(gpt, &find, change, NULL);
gpt_warnx(gpt,
newsize = map_resize(gpt, map, sectors, alignsecs);
gpt_warnx(gpt,
if (gpt_write_primary(gpt) == -1)
ent = gpt_ent(gpt->gpt, gpt->lbt, i);
if (gpt_write_backup(gpt) == -1)
gpt_msg(gpt, "Partition %d resized: %" PRIu64 " %" PRIu64, entry,
cmd_resize(gpt_t gpt, int argc, char *argv[])
gpt_human_get(gpt, &start);
else if (gpt_add_ais(gpt, &alignment, &entry, &size, ch) == -1)
for (m = map_first(gpt); m != NULL; m = m->map_next) {
if ((sectors = gpt_check_ais(gpt, alignment, entry, size)) == -1)
return resize(gpt, entry, alignment, sectors, size, quiet);
resize(gpt_t gpt, u_int entry, off_t alignment, off_t sectors,
if (gpt_hdr(gpt) == NULL)
ent = gpt_ent_primary(gpt, i);
gpt_warnx(gpt, "Entry at index %u is unused", entry);
alignsecs = alignment / gpt->secsz;
for (map = map_first(gpt); map != NULL; map = map->map_next) {
gpt_warnx(gpt, "Could not find map entry corresponding "
mbrmap = map_find(gpt, MAP_TYPE_PMBR);
gpt_warnx(gpt, "No valid PMBR found");
gpt->gpt = map_find(gpt, MAP_TYPE_PRI_GPT_HDR);
if (gpt->gpt == NULL) {
gpt_warnx(gpt, "No primary GPT header; run create or recover");
gpt->tbl = map_find(gpt, MAP_TYPE_PRI_GPT_TBL);
if (gpt->tbl == NULL) {
gpt_warnx(gpt, "No primary GPT table; Run recover");
hdr = gpt->gpt->map_data;
gpt->tpg = map_find(gpt, MAP_TYPE_SEC_GPT_HDR);
gpt->lbt = map_find(gpt, MAP_TYPE_SEC_GPT_TBL);
if (gpt->tpg == NULL || gpt->lbt == NULL)
gpt_warnx(gpt, "No secondary GPT table");
gpt_size = gpt->tbl->map_size;
gpt_warnx(gpt, "Device is already the specified size");
gpt_warnx(gpt, "Device hasn't changed size");
if (gpt->tpg != NULL && gpt->lbt != NULL)
for (ent = gpt->tbl->map_data; ent <
(struct gpt_ent *)((char *)gpt->tbl->map_data +
gpt_warnx(gpt, "Not enough space at %" PRIu64
gpt_warnx(gpt, "Not enough space for new secondary GPT table");
if (newloc > 0 && gpt->tpg != NULL && gpt->lbt != NULL) {
gpt_msg(gpt, "Moving secondary GPT header");
gpt->tpg->map_start = newloc;
gpt->lbt->map_start = newloc - gpt_size;
gpt_msg(gpt, "Creating new secondary GPT header");
if (gpt_add_hdr(gpt, MAP_TYPE_SEC_GPT_HDR, newloc) == -1)
gpt->lbt = map_add(gpt, newloc - gpt_size, gpt_size,
MAP_TYPE_SEC_GPT_TBL, gpt->tbl->map_data, 0);
if (gpt->lbt == NULL) {
gpt_warn(gpt, "Error adding secondary GPT table");
memcpy(gpt->tpg->map_data, gpt->gpt->map_data, gpt->secsz);
hdr = gpt->gpt->map_data;
hdr->hdr_lba_alt = htole64((uint64_t)gpt->tpg->map_start);
hdr->hdr_lba_end = htole64((uint64_t)(gpt->lbt->map_start - 1));
htole32(crc32(gpt->gpt->map_data, GPT_HDR_SIZE));
gpt_write(gpt, gpt->gpt);
hdr = gpt->tpg->map_data;
hdr->hdr_lba_self = htole64((uint64_t)gpt->tpg->map_start);
hdr->hdr_lba_alt = htole64((uint64_t)gpt->gpt->map_start);
hdr->hdr_lba_end = htole64((uint64_t)(gpt->lbt->map_start - 1));
hdr->hdr_lba_table = htole64((uint64_t)gpt->lbt->map_start);
if (gpt_write_backup(gpt) == -1)
gpt_warnx(gpt, "No valid PMBR partition found");
if (gpt_write(gpt, mbrmap) == -1) {
gpt_warnx(gpt, "Error writing PMBR");
cmd_resizedisk(gpt_t gpt, int argc, char *argv[])
off_t sector, size = gpt->mediasz;
if (gpt_add_ais(gpt, NULL, NULL, &size, ch) == -1)
if ((sector = gpt_check_ais(gpt, 0, (u_int)~0, size)) == -1)
gpt_warnx(gpt, "New size %ju too small", (uintmax_t)size);
return resizedisk(gpt, sector, size, quiet);
resizedisk(gpt_t gpt, off_t sector, off_t size __unused, bool quiet)
last = gpt->mediasz / gpt->secsz - 1;
gpt_warnx(gpt, "specified number of sectors %jd"
restore_ent(gpt_t gpt, prop_dictionary_t gpt_dict, void *secbuf,
gpt_warnx(gpt, "%s: not able to convert to an UUID", s);
gpt_warnx(gpt, "%s: not able to convert to an UUID", s);
gpt_warnx(gpt, "Entity index out of bounds %u > %u\n",
memcpy((char *)secbuf + gpt->secsz + ((i - 1) * sizeof(ent)),
restore(gpt_t gpt, const char *infile, int force)
last = gpt->mediasz / gpt->secsz - 1LL;
if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) != NULL ||
map_find(gpt, MAP_TYPE_SEC_GPT_HDR) != NULL) {
gpt_warnx(gpt, "Device contains a GPT");
map = map_find(gpt, MAP_TYPE_MBR);
gpt_warnx(gpt, "Device contains an MBR");
gpt_warnx(gpt, "Unable to read/parse backup file");
if (!prop_number_equals_signed(propnum, gpt->secsz)) {
gpt_warnx(gpt, "Sector size does not match backup");
gpt_warnx(gpt, "backup is not revision 1.0");
gpt_size = (u_int)(entries * sizeof(struct gpt_ent) / gpt->secsz);
if (gpt_size * sizeof(struct gpt_ent) % gpt->secsz)
gpt_warnx(gpt, "%s: not able to convert to an UUID", s);
gpt_warnx(gpt, "%s: not able to convert to an UUID", s);
gpt_warnx(gpt, "Backup GPT doesn't fit");
if ((secbuf = calloc(gpt_size + 1, gpt->secsz)) == NULL) {
gpt_warn(gpt, "not enough memory to create a sector buffer");
if (lseek(gpt->fd, 0LL, SEEK_SET) == -1) {
gpt_warn(gpt, "Can't seek to beginning");
if (write(gpt->fd, secbuf, gpt->secsz) != (ssize_t)gpt->secsz) {
gpt_warn(gpt, "Error writing");
if (lseek(gpt->fd, (lastdata + 1) * gpt->secsz, SEEK_SET) == -1) {
gpt_warn(gpt, "Can't seek to end");
if (write(gpt->fd, secbuf, gpt->secsz) != (ssize_t)gpt->secsz) {
gpt_warn(gpt, "Error writing");
if (restore_mbr(gpt, mbr, mbr_dict, last) == -1)
if (lseek(gpt->fd, 0LL, SEEK_SET) == -1 ||
write(gpt->fd, mbr, gpt->secsz) != (ssize_t)gpt->secsz) {
gpt_warn(gpt, "Unable to seek/write MBR");
if (restore_ent(gpt, gpt_dict, secbuf, gpt_size, entries) == -1)
size_t len = gpt_size * gpt->secsz;
if (lseek(gpt->fd, 2 * gpt->secsz, SEEK_SET) == -1 ||
write(gpt->fd, (char *)secbuf + gpt->secsz, len) != (ssize_t) len) {
gpt_warn(gpt, "Unable to write primary GPT");
if (lseek(gpt->fd, (lastdata + 1) * gpt->secsz, SEEK_SET) == -1 ||
write(gpt->fd, (char *)secbuf + gpt->secsz, len) != (ssize_t) len) {
gpt_warn(gpt, "Unable to write secondary GPT");
memset(secbuf, 0, gpt->secsz);
hdr->hdr_crc_table = htole32(crc32((char *)secbuf + gpt->secsz, len));
if (lseek(gpt->fd, gpt->secsz, SEEK_SET) == -1 ||
write(gpt->fd, hdr, gpt->secsz) != (ssize_t)gpt->secsz) {
gpt_warn(gpt, "Unable to write primary header");
if (lseek(gpt->fd, last * gpt->secsz, SEEK_SET) == -1 ||
write(gpt->fd, hdr, gpt->secsz) != (ssize_t)gpt->secsz) {
gpt_warn(gpt, "Unable to write secondary header");
cmd_restore(gpt_t gpt, int argc, char *argv[])
return restore(gpt, infile, force);
gpt_warnx(gpt, "proplib failure"); \
restore_mbr(gpt_t gpt, struct mbr *mbr, prop_dictionary_t mbr_dict, off_t last)
for (m = map_first(gpt); m != NULL; m = m->map_next) {
if (gpt == NULL || argc != optind || (attributes != 0 && clear != 0))
return gpt_attr_update(gpt, entry, attributes, clear);
cmd_set(gpt_t gpt, int argc, char *argv[])
if (gpt == NULL || gpt_attr_get(gpt, &attributes) == -1)
if (gpt == NULL || gpt_human_get(gpt, &start) == -1)
if (gpt == NULL || gpt_uint_get(gpt, &entry) == -1)
parsable_label(gpt_t gpt, struct gpt_ent *ent)
print_part_type(gpt_t gpt, int map_type, int flags, void *map_data,
b = parsable_label(gpt, ent);
cvt_size(gpt_t gpt, uintmax_t sz, int xshow, char *b, unsigned int bs)
num = sz * gpt->secsz;
printf(FMT, gpt->lbawidth, sz);
show(gpt_t gpt, int xshow)
unsigned int w1 = (unsigned int)gpt->lbawidth + 2;
m = map_first(gpt);
p = cvt_size(gpt, (uintmax_t)m->map_start,
p = cvt_size(gpt, (uintmax_t)m->map_size,
m = map_first(gpt);
print_part_type(gpt, m->map_type, xshow, m->map_data,
p = cvt_size(gpt, (uintmax_t)m->map_start, xshow, szbuf, w1+1);
p = cvt_size(gpt, (uintmax_t)m->map_size, xshow, szbuf, w2+1);
print_part_type(gpt, m->map_type, xshow, m->map_data,
gpt_t gpt)
p = cvt_size(gpt, (uintmax_t)num, xshow,
show_parsable(gpt_t gpt, map_t m, struct gpt_ent *ent, int xshow)
if (gpt->verbose)
print_part_type(gpt, m->map_type, 0, m->map_data,
p = parsable_label(gpt, ent);
show_one(gpt_t gpt, unsigned int entry, int xshow)
for (m = map_first(gpt); m != NULL; m = m->map_next)
gpt_warnx(gpt, "Could not find index %d", entry);
return show_parsable(gpt, m, ent, xshow);
gpt_show_sec_num("Start", gpt->secsz, m->map_start, xshow, gpt);
gpt_show_sec_num("Size", gpt->secsz, m->map_size, xshow, gpt);
show_all(gpt_t gpt, int xshow)
m = map_first(gpt);
show_parsable(gpt, m, ent, xshow);
printf(" %*s", gpt->lbawidth, "start");
printf(" %*s", gpt->lbawidth, "size");
width = 2 * ((unsigned)gpt->lbawidth + 2) + 7;
printf(FMT, gpt->lbawidth, (uintmax_t)m->map_start);
printf(FMT, gpt->lbawidth, (uintmax_t)m->map_size);
print_part_type(gpt, m->map_type, 0, m->map_data,
(int64_t)(m->map_size * gpt->secsz),
(intmax_t)m->map_size * gpt->secsz,
p = cvt_size(gpt, (uintmax_t)m->map_size, xshow,
pr += (unsigned)print_part_type(gpt, m->map_type, 0,
p = cvt_size(gpt, (uintmax_t)m->map_size,
cmd_show(gpt_t gpt, int argc, char *argv[])
if (gpt_uint_get(gpt, &entry) == -1)
if (gpt_human_get(gpt, &start) == -1)
if (gpt_uint_get(gpt, &out_width) < 0)
if ((map_find(gpt, MAP_TYPE_PRI_GPT_HDR) == NULL) &&
! (gpt->flags & GPT_QUIET) )
return show_all(gpt, xshow);
for (m = map_first(gpt); m != NULL; m = m->map_next) {
return entry > 0 ? show_one(gpt, entry, xshow) : show(gpt, xshow);
if (gpt == NULL || gpt_add_find(gpt, &find, ch) == -1)
if (gpt == NULL || gpt_uuid_is_nil(newtype) || argc != optind)
return gpt_change_ent(gpt, &find, change, &newtype);
cmd_type(gpt_t gpt, int argc, char *argv[])
if (gpt == NULL || gpt_uuid_get(gpt, &newtype) == -1)
for (m = map_first(gpt); m != NULL; m = m->map_next) {
if (gpt == NULL || argc != optind)
return gpt_attr_update(gpt, entry, 0, attributes);
cmd_unset(gpt_t gpt, int argc, char *argv[])
if (gpt == NULL || gpt_attr_get(gpt, &attributes) == -1)
if (gpt == NULL || gpt_human_get(gpt, &start) == -1)
if (gpt == NULL || gpt_uint_get(gpt, &entry) == -1)
cmd_uuid(gpt_t gpt, int argc, char *argv[])
if (gpt == NULL)
ctx.gpt = gpt;
if (gpt_add_find(gpt, &find, ch) == -1)
rc = gpt_change_ent(gpt, &find, change_ent, &ctx);
return gpt_change_hdr(gpt, &find, change_hdr, &ctx);
gpt_t gpt;
gpt_uuid_generate(ctx->gpt, uuidstore);
gpt_uuid_generate(ctx->gpt, uuidstore);
bpart->gpt.fstype = fstype;
bpart->gpt.ent = *ent;
bpart->gpt.ent.ent_lba_start += RF_PROTECTED_SECTORS;
bpart->gpt.ent.ent_lba_end -= RF_PROTECTED_SECTORS;
fstype = bpart->gpt.fstype;
if (bpart->gpt.ent.ent_name[0] == 0x0000) {
print_guid(bpart->gpt.ent.ent_guid);
Print(L"\"%s\"", bpart->gpt.ent.ent_name);
size = (le64toh(bpart->gpt.ent.ent_lba_end) - le64toh(bpart->gpt.ent.ent_lba_start)) * bdev->bio->Media->BlockSize;
printf("%s\n", fstypenames[bpart->gpt.fstype]);
off = ((EFI_LBA)dblk + le64toh(bpart->gpt.ent.ent_lba_start)) * bdev->bio->Media->BlockSize;
struct efi_block_part_gpt gpt;
if (bpart->gpt.ent.ent_name[0] == 0x0000) {
int rv = ucs2_to_utf8(bpart->gpt.ent.ent_name, &label);