extern void test_gptwrite_nosuchdir(void)
{
gpt_t* gpt;
CU_TEST_FATAL( (gpt = build_gpt()) != NULL );
const char path[] = "/no/such/directory";
CU_ASSERT( access(path, F_OK) != 0 );
CU_ASSERT( gpt_write(path, gpt) != 0 );
CU_ASSERT( access(path, F_OK) != 0 );
gpt_destroy(gpt);
}
static void
destroy(gd_t gd)
{
map_t pri_hdr, sec_hdr;
pri_hdr = map_find(gd, MAP_TYPE_PRI_GPT_HDR);
sec_hdr = map_find(gd, MAP_TYPE_SEC_GPT_HDR);
if (pri_hdr == NULL && sec_hdr == NULL) {
warnx("%s: error: device doesn't contain a GPT", gd->device_name);
return;
}
if (recoverable && sec_hdr == NULL) {
warnx("%s: error: recoverability not possible", gd->device_name);
return;
}
if (pri_hdr != NULL) {
bzero(pri_hdr->map_data, gd->secsz);
if (gpt_write(gd, pri_hdr) == -1) {
warnx("%s: error: overwriting primary header",
gd->device_name);
return;
}
}
if (!recoverable && sec_hdr != NULL) {
bzero(sec_hdr->map_data, gd->secsz);
if (gpt_write(gd, sec_hdr) == -1) {
warnx("%s: error: overwriting backup header",
gd->device_name);
return;
}
}
gpt_status(gd, -1, "destroyed gpt label");
}
extern void test_gptwrite_write(void)
{
gpt_t* gpt;
CU_TEST_FATAL( (gpt = build_gpt()) != NULL );
char *path;
CU_TEST_FATAL( (path = tmpnam(NULL)) != NULL );
CU_ASSERT( access(path, F_OK) != 0 );
CU_ASSERT( gpt_write(path, gpt) == 0 );
CU_ASSERT( access(path, F_OK) == 0 );
unlink(path);
gpt_destroy(gpt);
}
static int
recover_gpt_hdr(gpt_t gpt, int type, off_t last)
{
const char *name, *origname;
map_t *dgpt, dtbl, sgpt, stbl __unused;
struct gpt_hdr *hdr;
if (gpt_add_hdr(gpt, type, last) == -1)
return -1;
switch (type) {
case MAP_TYPE_PRI_GPT_HDR:
dgpt = &gpt->gpt;
dtbl = gpt->tbl;
sgpt = gpt->tpg;
stbl = gpt->lbt;
origname = "secondary";
name = "primary";
break;
case MAP_TYPE_SEC_GPT_HDR:
dgpt = &gpt->tpg;
dtbl = gpt->lbt;
sgpt = gpt->gpt;
stbl = gpt->tbl;
origname = "primary";
name = "secondary";
break;
default:
gpt_warn(gpt, "Bad table type %d", type);
return -1;
}
memcpy((*dgpt)->map_data, sgpt->map_data, gpt->secsz);
hdr = (*dgpt)->map_data;
hdr->hdr_lba_self = htole64((uint64_t)(*dgpt)->map_start);
hdr->hdr_lba_alt = htole64((uint64_t)sgpt->map_start);
hdr->hdr_lba_table = htole64((uint64_t)dtbl->map_start);
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
if (gpt_write(gpt, *dgpt) == -1) {
gpt_warnx(gpt, "Writing %s GPT header failed", name);
return -1;
}
gpt_msg(gpt, "Recovered %s GPT header from %s", name, origname);
return 0;
}
static int
recover_gpt_tbl(gpt_t gpt, int type, off_t start)
{
const char *name, *origname;
map_t *dtbl, stbl;
switch (type) {
case MAP_TYPE_PRI_GPT_TBL:
dtbl = &gpt->tbl;
stbl = gpt->lbt;
origname = "secondary";
name = "primary";
break;
case MAP_TYPE_SEC_GPT_TBL:
dtbl = &gpt->lbt;
stbl = gpt->tbl;
origname = "primary";
name = "secondary";
break;
default:
gpt_warn(gpt, "Bad table type %d", type);
return -1;
}
*dtbl = map_add(gpt, start, stbl->map_size, type, stbl->map_data, 0);
if (*dtbl == NULL) {
gpt_warnx(gpt, "Adding %s GPT table failed", name);
return -1;
}
if (gpt_write(gpt, *dtbl) == -1) {
gpt_warnx(gpt, "Writing %s GPT table failed", name);
return -1;
}
gpt_msg(gpt, "Recovered %s GPT table from %s", name, origname);
return 0;
}
static void
rem(gd_t gd)
{
uuid_t uuid;
map_t m;
struct gpt_hdr *hdr;
struct gpt_ent *ent;
unsigned int i;
if ((hdr = gpt_gethdr(gd)) == NULL)
return;
/* Remove all matching entries in the map. */
for (m = map_first(gd); m != NULL; m = m->map_next) {
if (m->map_type != MAP_TYPE_GPT_PART || m->map_index < 1)
continue;
if (entry > 0 && entry != m->map_index)
continue;
if (block > 0 && block != m->map_start)
continue;
if (size > 0 && size != m->map_size)
continue;
i = m->map_index - 1;
hdr = gd->gpt->map_data;
ent = (void*)((char*)gd->tbl->map_data + i *
le32toh(hdr->hdr_entsz));
uuid_dec_le(&ent->ent_type, &uuid);
if (!uuid_is_nil(&type, NULL) &&
!uuid_equal(&type, &uuid, NULL))
continue;
/* Remove the primary entry by clearing the partition type. */
uuid_create_nil(&uuid, NULL);
uuid_enc_le(&ent->ent_type, &uuid);
hdr->hdr_crc_table = htole32(crc32(gd->tbl->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(gd, gd->gpt);
gpt_write(gd, gd->tbl);
hdr = gd->tpg->map_data;
ent = (void*)((char*)gd->lbt->map_data + i *
le32toh(hdr->hdr_entsz));
/* Remove the secondary entry. */
uuid_enc_le(&ent->ent_type, &uuid);
hdr->hdr_crc_table = htole32(crc32(gd->lbt->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(gd, gd->lbt);
gpt_write(gd, gd->tpg);
gpt_status(gd, m->map_index, "removed");
}
}
static void
rem(int fd)
{
uuid_t uuid;
map_t *gpt, *tpg;
map_t *tbl, *lbt;
map_t *m;
struct gpt_hdr *hdr;
struct gpt_ent *ent;
unsigned int i;
gpt = map_find(MAP_TYPE_PRI_GPT_HDR);
if (gpt == NULL) {
warnx("%s: error: no primary GPT header; run create or recover",
device_name);
return;
}
tpg = map_find(MAP_TYPE_SEC_GPT_HDR);
if (tpg == NULL) {
warnx("%s: error: no secondary GPT header; run recover",
device_name);
return;
}
tbl = map_find(MAP_TYPE_PRI_GPT_TBL);
lbt = map_find(MAP_TYPE_SEC_GPT_TBL);
if (tbl == NULL || lbt == NULL) {
warnx("%s: error: run recover -- trust me", device_name);
return;
}
/* Remove all matching entries in the map. */
for (m = map_first(); m != NULL; m = m->map_next) {
if (m->map_type != MAP_TYPE_GPT_PART || m->map_index == NOENTRY)
continue;
if (entry != NOENTRY && entry != m->map_index)
continue;
if (block > 0 && block != m->map_start)
continue;
if (size > 0 && size != m->map_size)
continue;
i = m->map_index;
hdr = gpt->map_data;
ent = (void*)((char*)tbl->map_data + i *
le32toh(hdr->hdr_entsz));
le_uuid_dec(&ent->ent_type, &uuid);
if (!uuid_is_nil(&type, NULL) &&
!uuid_equal(&type, &uuid, NULL))
continue;
/* Remove the primary entry by clearing the partition type. */
uuid_create_nil(&ent->ent_type, NULL);
hdr->hdr_crc_table = htole32(crc32(tbl->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, gpt);
gpt_write(fd, tbl);
hdr = tpg->map_data;
ent = (void*)((char*)lbt->map_data + i *
le32toh(hdr->hdr_entsz));
/* Remove the secundary entry. */
uuid_create_nil(&ent->ent_type, NULL);
hdr->hdr_crc_table = htole32(crc32(lbt->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, lbt);
gpt_write(fd, tpg);
printf("%ss%u removed\n", device_name, m->map_index);
}
}
static void
add(int fd)
{
map_t *gpt, *tpg;
map_t *tbl, *lbt;
map_t *map;
struct gpt_hdr *hdr;
struct gpt_ent *ent;
unsigned int i;
gpt = map_find(MAP_TYPE_PRI_GPT_HDR);
if (gpt == NULL) {
warnx("%s: error: no primary GPT header; run create or recover",
device_name);
return;
}
tpg = map_find(MAP_TYPE_SEC_GPT_HDR);
if (tpg == NULL) {
warnx("%s: error: no secondary GPT header; run recover",
device_name);
return;
}
tbl = map_find(MAP_TYPE_PRI_GPT_TBL);
lbt = map_find(MAP_TYPE_SEC_GPT_TBL);
if (tbl == NULL || lbt == NULL) {
warnx("%s: error: run recover -- trust me", device_name);
return;
}
hdr = gpt->map_data;
if (entry != NOENTRY && entry > le32toh(hdr->hdr_entries)) {
warnx("%s: error: index %u out of range (%u max)", device_name,
entry, le32toh(hdr->hdr_entries));
return;
}
if (entry != NOENTRY) {
i = entry;
ent = (void*)((char*)tbl->map_data + i *
le32toh(hdr->hdr_entsz));
if (!uuid_is_nil(&ent->ent_type, NULL)) {
warnx("%s: error: entry at index %u is not free",
device_name, entry);
return;
}
} else {
/* Find empty slot in GPT table. */
ent = NULL;
for (i = 0; i < le32toh(hdr->hdr_entries); i++) {
ent = (void*)((char*)tbl->map_data + i *
le32toh(hdr->hdr_entsz));
if (uuid_is_nil(&ent->ent_type, NULL))
break;
}
if (i == le32toh(hdr->hdr_entries)) {
warnx("%s: error: no available table entries",
device_name);
return;
}
}
map = map_alloc(block, size);
if (map == NULL) {
warnx("%s: error: no space available on device", device_name);
return;
}
le_uuid_enc(&ent->ent_type, &type);
ent->ent_lba_start = htole64(map->map_start);
ent->ent_lba_end = htole64(map->map_start + map->map_size - 1LL);
hdr->hdr_crc_table = htole32(crc32(tbl->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, gpt);
gpt_write(fd, tbl);
hdr = tpg->map_data;
ent = (void*)((char*)lbt->map_data + i * le32toh(hdr->hdr_entsz));
le_uuid_enc(&ent->ent_type, &type);
ent->ent_lba_start = htole64(map->map_start);
ent->ent_lba_end = htole64(map->map_start + map->map_size - 1LL);
hdr->hdr_crc_table = htole32(crc32(lbt->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, lbt);
gpt_write(fd, tpg);
printf("%ss%u added\n", device_name, i);
}
static void
bootset(int fd)
{
uuid_t uuid;
off_t block;
off_t size;
unsigned int entry;
map_t *gpt, *tpg;
map_t *tbl, *lbt;
map_t *map;
u_int32_t status;
struct gpt_hdr *hdr;
struct gpt_ent *ent;
struct mbr *mbr;
int bfd;
/*
* Paramters for boot partition
*/
uuid_name_lookup(&uuid, "DragonFly Label32", &status);
if (status != uuid_s_ok)
err(1, "unable to find uuid for 'DragonFly Label32'");
entry = 0;
block = 0;
size = 768 * 1024 * 1024 / 512;
gpt = map_find(MAP_TYPE_PRI_GPT_HDR);
if (gpt == NULL)
errx(1, "%s: error: no primary GPT header", device_name);
tpg = map_find(MAP_TYPE_SEC_GPT_HDR);
if (tpg == NULL)
errx(1, "%s: error: no secondary GPT header", device_name);
tbl = map_find(MAP_TYPE_PRI_GPT_TBL);
lbt = map_find(MAP_TYPE_SEC_GPT_TBL);
if (tbl == NULL || lbt == NULL) {
errx(1, "%s: error: no primary or secondary gpt table",
device_name);
}
hdr = gpt->map_data;
if (entry > le32toh(hdr->hdr_entries)) {
errx(1, "%s: error: index %u out of range (%u max)",
device_name, entry, le32toh(hdr->hdr_entries));
}
ent = (void *)((char *)tbl->map_data + entry *
le32toh(hdr->hdr_entsz));
if (!uuid_is_nil(&ent->ent_type, NULL)) {
errx(1, "%s: error: entry at index %d is not free",
device_name, entry);
}
map = map_alloc(block, size);
if (map == NULL)
errx(1, "%s: error: no space available on device", device_name);
block = map->map_start;
size = map->map_size;
le_uuid_enc(&ent->ent_type, &uuid);
ent->ent_lba_start = htole64(map->map_start);
ent->ent_lba_end = htole64(map->map_start + map->map_size - 1LL);
hdr->hdr_crc_table = htole32(crc32(tbl->map_data,
le32toh(hdr->hdr_entries) *
le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, gpt);
gpt_write(fd, tbl);
hdr = tpg->map_data;
ent = (void*)((char*)lbt->map_data + entry * le32toh(hdr->hdr_entsz));
le_uuid_enc(&ent->ent_type, &uuid);
ent->ent_lba_start = htole64(map->map_start);
ent->ent_lba_end = htole64(map->map_start + map->map_size - 1LL);
hdr->hdr_crc_table = htole32(crc32(lbt->map_data,
le32toh(hdr->hdr_entries) *
le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, lbt);
gpt_write(fd, tpg);
/*
* Create a dummy partition
*/
map = map_find(MAP_TYPE_PMBR);
if (map == NULL)
errx(1, "I can't find the PMBR!");
mbr = map->map_data;
if (mbr == NULL)
errx(1, "I can't find the PMBR's data!");
/*
* Copy in real boot code
*/
bfd = open("/boot/boot0", O_RDONLY);
if (bfd < 0 ||
read(bfd, mbr->mbr_code, sizeof(mbr->mbr_code)) !=
sizeof(mbr->mbr_code)) {
errx(1, "Cannot read /boot/boot0");
}
close(bfd);
/*
* Generate partition #1
*/
mbr->mbr_part[1].part_shd = 0xff;
mbr->mbr_part[1].part_ssect = 0xff;
mbr->mbr_part[1].part_scyl = 0xff;
mbr->mbr_part[1].part_ehd = 0xff;
mbr->mbr_part[1].part_esect = 0xff;
mbr->mbr_part[1].part_ecyl = 0xff;
mbr->mbr_part[1].part_start_lo = htole16(block);
mbr->mbr_part[1].part_start_hi = htole16((block) >> 16);
mbr->mbr_part[1].part_size_lo = htole16(size);
mbr->mbr_part[1].part_size_hi = htole16(size >> 16);
mbr->mbr_part[1].part_typ = 165;
mbr->mbr_part[1].part_flag = 0x80;
gpt_write(fd, map);
}
static int
biosboot(gpt_t gpt, daddr_t start, uint64_t size, u_int entry, uint8_t *label,
const char *bootpath)
{
map_t mbrmap, m;
struct mbr *mbr, *bootcode;
unsigned int i;
struct gpt_ent *ent;
uint8_t utfbuf[__arraycount(ent->ent_name) * 3 + 1];
/*
* Parse and validate partition maps
*/
if (gpt_hdr(gpt) == NULL)
return -1;
mbrmap = map_find(gpt, MAP_TYPE_PMBR);
if (mbrmap == NULL || mbrmap->map_start != 0) {
gpt_warnx(gpt, "No valid Protective MBR found");
return -1;
}
mbr = mbrmap->map_data;
/*
* Update the boot code
*/
if ((bootcode = read_boot(gpt, bootpath)) == NULL) {
gpt_warnx(gpt, "Error reading bootcode");
return -1;
}
(void)memcpy(&mbr->mbr_code, &bootcode->mbr_code,
sizeof(mbr->mbr_code));
free(bootcode);
/*
* Walk through the GPT and see where we can boot from
*/
for (m = map_first(gpt); m != NULL; m = m->map_next) {
if (m->map_type != MAP_TYPE_GPT_PART || m->map_index < 1)
continue;
ent = m->map_data;
/* first, prefer user selection */
if (entry > 0 && m->map_index == entry)
break;
if (label != NULL) {
utf16_to_utf8(ent->ent_name, utfbuf, sizeof(utfbuf));
if (strcmp((char *)label, (char *)utfbuf) == 0)
break;
}
/* next, partition as could be specified by wedge */
if (entry < 1 && label == NULL && size > 0 &&
m->map_start == start && m->map_size == (off_t)size)
break;
}
if (m == NULL) {
gpt_warnx(gpt, "No bootable partition");
return -1;
}
i = m->map_index - 1;
if (set_bootable(gpt, gpt->gpt, gpt->tbl, i) == -1)
return -1;
if (set_bootable(gpt, gpt->tpg, gpt->lbt, i) == -1)
return -1;
if (gpt_write(gpt, mbrmap) == -1) {
gpt_warnx(gpt, "Cannot update Protective MBR");
return -1;
}
gpt_msg(gpt, "Partition %d marked as bootable", i + 1);
return 0;
}
static int
migrate(gpt_t gpt, u_int parts, int force, int slice, int active)
{
off_t last = gpt_last(gpt);
map_t map;
struct gpt_ent *ent;
struct mbr *mbr;
uint32_t start, size;
unsigned int i;
gpt_type_t type = GPT_TYPE_INVALID;
map = map_find(gpt, MAP_TYPE_MBR);
if (map == NULL || map->map_start != 0) {
gpt_warnx(gpt, "No MBR in disk to convert");
return -1;
}
mbr = map->map_data;
if (gpt_create(gpt, last, parts, 0) == -1)
return -1;
ent = gpt->tbl->map_data;
/* Mirror partitions. */
for (i = 0; i < 4; i++) {
start = le16toh(mbr->mbr_part[i].part_start_hi);
start = (start << 16) + le16toh(mbr->mbr_part[i].part_start_lo);
size = le16toh(mbr->mbr_part[i].part_size_hi);
size = (size << 16) + le16toh(mbr->mbr_part[i].part_size_lo);
if (gpt->verbose > 1)
gpt_msg(gpt, "MBR partition %u type %s", i,
mbrptypename(mbr->mbr_part[i].part_typ));
switch (mbr->mbr_part[i].part_typ) {
case MBR_PTYPE_UNUSED:
continue;
case MBR_PTYPE_386BSD: /* FreeBSD */
if (slice) {
type = GPT_TYPE_FREEBSD;
break;
} else {
ent = migrate_disklabel(gpt, start, ent,
freebsd_fstype_to_gpt_type);
continue;
}
case MBR_PTYPE_NETBSD: /* NetBSD */
ent = migrate_disklabel(gpt, start, ent,
netbsd_fstype_to_gpt_type);
continue;
case MBR_PTYPE_EFI:
type = GPT_TYPE_EFI;
break;
default:
if (!force) {
gpt_warnx(gpt, "unknown partition type (%d)",
mbr->mbr_part[i].part_typ);
return -1;
}
continue;
}
gpt_uuid_create(type, ent->ent_type, ent->ent_name,
sizeof(ent->ent_name));
ent->ent_lba_start = htole64((uint64_t)start);
ent->ent_lba_end = htole64((uint64_t)(start + size - 1LL));
ent++;
}
if (gpt_write_primary(gpt) == -1)
return -1;
if (gpt_write_backup(gpt) == -1)
return -1;
/*
* Turn the MBR into a Protective MBR.
*/
memset(mbr->mbr_part, 0, sizeof(mbr->mbr_part));
gpt_create_pmbr_part(mbr->mbr_part, last, active);
if (gpt_write(gpt, map) == -1) {
gpt_warn(gpt, "Cant write PMBR");
return -1;
}
return 0;
}
static int
recover(gpt_t gpt, int recoverable)
{
off_t last = gpt_last(gpt);
map_t map;
struct mbr *mbr;
if (map_find(gpt, MAP_TYPE_MBR) != NULL) {
gpt_warnx(gpt, "Device contains an MBR");
return -1;
}
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, "
"can't recover");
return -1;
}
if (gpt->tbl == NULL && gpt->lbt == NULL) {
gpt_warnx(gpt, "No primary or secondary GPT tables, "
"can't recover");
return -1;
}
if (gpt->gpt != NULL &&
((struct gpt_hdr *)(gpt->gpt->map_data))->hdr_lba_alt !=
(uint64_t)last) {
gpt_warnx(gpt, "Media size has changed, please use "
"'%s resizedisk'", getprogname());
return -1;
}
if (gpt->tbl != NULL && gpt->lbt == NULL) {
if (recover_gpt_tbl(gpt, MAP_TYPE_SEC_GPT_TBL,
last - gpt->tbl->map_size) == -1)
return -1;
} else if (gpt->tbl == NULL && gpt->lbt != NULL) {
if (recover_gpt_tbl(gpt, MAP_TYPE_PRI_GPT_TBL, 2LL) == -1)
return -1;
}
if (gpt->gpt != NULL && gpt->tpg == NULL) {
if (recover_gpt_hdr(gpt, MAP_TYPE_SEC_GPT_HDR, last) == -1)
return -1;
} else if (gpt->gpt == NULL && gpt->tpg != NULL) {
if (recover_gpt_hdr(gpt, MAP_TYPE_PRI_GPT_HDR, 1LL) == -1)
return -1;
}
/*
* Create PMBR if it doesn't already exist.
*/
if (map_find(gpt, MAP_TYPE_PMBR) == NULL) {
if (map_free(gpt, 0LL, 1LL) == 0) {
gpt_warnx(gpt, "No room for the PMBR");
return -1;
}
mbr = gpt_read(gpt, 0LL, 1);
if (mbr == NULL) {
gpt_warnx(gpt, "Error reading MBR");
return -1;
}
memset(mbr, 0, sizeof(*mbr));
mbr->mbr_sig = htole16(MBR_SIG);
gpt_create_pmbr_part(mbr->mbr_part, last, 0);
map = map_add(gpt, 0LL, 1LL, MAP_TYPE_PMBR, mbr, 1);
if (gpt_write(gpt, map) == -1) {
gpt_warn(gpt, "Can't write PMBR");
return -1;
}
gpt_msg(gpt,
"Recreated PMBR (you may need to rerun 'gpt biosboot'");
}
return 0;
}
static void
recover(int fd)
{
off_t last;
map_t *gpt, *tpg;
map_t *tbl, *lbt;
struct gpt_hdr *hdr;
if (map_find(MAP_TYPE_MBR) != NULL) {
warnx("%s: error: device contains a MBR", device_name);
return;
}
gpt = map_find(MAP_TYPE_PRI_GPT_HDR);
tpg = map_find(MAP_TYPE_SEC_GPT_HDR);
tbl = map_find(MAP_TYPE_PRI_GPT_TBL);
lbt = map_find(MAP_TYPE_SEC_GPT_TBL);
if (gpt == NULL && tpg == NULL) {
warnx("%s: no primary or secondary GPT headers, can't recover",
device_name);
return;
}
if (tbl == NULL && lbt == NULL) {
warnx("%s: no primary or secondary GPT tables, can't recover",
device_name);
return;
}
last = mediasz / secsz - 1LL;
if (tbl != NULL && lbt == NULL) {
lbt = map_add(last - tbl->map_size, tbl->map_size,
MAP_TYPE_SEC_GPT_TBL, tbl->map_data);
if (lbt == NULL) {
warnx("%s: adding secondary GPT table failed",
device_name);
return;
}
gpt_write(fd, lbt);
warnx("%s: recovered secondary GPT table from primary",
device_name);
} else if (tbl == NULL && lbt != NULL) {
tbl = map_add(2LL, lbt->map_size, MAP_TYPE_PRI_GPT_TBL,
lbt->map_data);
if (tbl == NULL) {
warnx("%s: adding primary GPT table failed",
device_name);
return;
}
gpt_write(fd, tbl);
warnx("%s: recovered primary GPT table from secondary",
device_name);
}
if (gpt != NULL && tpg == NULL) {
tpg = map_add(last, 1LL, MAP_TYPE_SEC_GPT_HDR,
calloc(1, secsz));
if (tpg == NULL) {
warnx("%s: adding secondary GPT header failed",
device_name);
return;
}
memcpy(tpg->map_data, gpt->map_data, secsz);
hdr = tpg->map_data;
hdr->hdr_lba_self = htole64(tpg->map_start);
hdr->hdr_lba_alt = htole64(gpt->map_start);
hdr->hdr_lba_table = htole64(lbt->map_start);
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, tpg);
warnx("%s: recovered secondary GPT header from primary",
device_name);
} else if (gpt == NULL && tpg != NULL) {
gpt = map_add(1LL, 1LL, MAP_TYPE_PRI_GPT_HDR,
calloc(1, secsz));
if (gpt == NULL) {
warnx("%s: adding primary GPT header failed",
device_name);
return;
}
memcpy(gpt->map_data, tpg->map_data, secsz);
hdr = gpt->map_data;
hdr->hdr_lba_self = htole64(gpt->map_start);
hdr->hdr_lba_alt = htole64(tpg->map_start);
hdr->hdr_lba_table = htole64(tbl->map_start);
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, gpt);
warnx("%s: recovered primary GPT header from secondary",
device_name);
}
}
