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); } }