#include "strutils.h"
#include "all-io.h"
-/*
- * in-memory fdisk GPT stuff
- */
-struct fdisk_gpt_label {
- struct fdisk_label head; /* generic part */
-};
-
-
#define GPT_HEADER_SIGNATURE 0x5452415020494645LL /* EFI PART */
#define GPT_HEADER_REVISION_V1_02 0x00010200
#define GPT_HEADER_REVISION_V1_00 0x00010000
DEF_GUID("85D5E45C-237C-11E1-B4B3-E89A8F7FC3A7", N_("MidnightBSD Vinum")),
};
-/* FIXME: move these global variables to fdisk_gpt_label */
-
-/* primary GPT header */
-static struct gpt_header *pheader = NULL;
-/* backup GPT header */
-static struct gpt_header *bheader = NULL;
-/* partition entry array */
-static struct gpt_entry *ents = NULL;
-
+/* gpt_entry macros */
#define gpt_partition_start(_e) le64_to_cpu((_e)->lba_start)
#define gpt_partition_end(_e) le64_to_cpu((_e)->lba_end)
+/*
+ * in-memory fdisk GPT stuff
+ */
+struct fdisk_gpt_label {
+ struct fdisk_label head; /* generic part */
+
+ /* gpt specific part */
+ struct gpt_header *pheader; /* primary header */
+ struct gpt_header *bheader; /* backup header */
+ struct gpt_entry *ents; /* entries (partitions) */
+};
+
+static void gpt_deinit(struct fdisk_label *lb);
+
+static inline struct fdisk_gpt_label *gpt_label(struct fdisk_context *cxt)
+{
+ assert(cxt);
+ assert(cxt->label);
+ assert(fdisk_is_disklabel(cxt, GPT));
+
+ return (struct fdisk_gpt_label *) cxt->label;
+}
+
/*
* Returns the partition length, or 0 if end is before beginning.
*/
/* Returns the GPT entry array */
static struct gpt_entry *gpt_read_entries(struct fdisk_context *cxt,
- struct gpt_header *header, const ssize_t sz)
+ struct gpt_header *header)
{
- struct gpt_entry *ret = xcalloc(1, sizeof(*ents) * sz);
- off_t offset = le64_to_cpu(header->partition_entry_lba) *
+ ssize_t sz;
+ struct gpt_entry *ret = NULL;
+ off_t offset;
+
+ assert(cxt);
+ assert(header);
+
+ sz = le32_to_cpu(header->npartition_entries) *
+ le32_to_cpu(header->sizeof_partition_entry);
+
+ ret = calloc(1, sizeof(*ret) * sz);
+ if (!ret)
+ return NULL;
+ offset = le64_to_cpu(header->partition_entry_lba) *
cxt->sector_size;
if (offset != lseek(cxt->dev_fd, offset, SEEK_SET))
- return NULL;
+ goto fail;
if (sz != read(cxt->dev_fd, ret, sz))
- return NULL;
+ goto fail;
return ret;
+
+fail:
+ free(ret);
+ return NULL;
}
static inline uint32_t count_crc32(const unsigned char *buf, size_t len)
* This function does not fail - if there's corruption, then it
* will be reported when checksuming it again (ie: probing or verify).
*/
-static void gpt_recompute_crc(struct gpt_header *header, struct gpt_entry *e)
+static void gpt_recompute_crc(struct gpt_header *header, struct gpt_entry *ents)
{
uint32_t crc = 0;
size_t entry_sz = 0;
entry_sz = le32_to_cpu(header->npartition_entries) *
le32_to_cpu(header->sizeof_partition_entry);
- crc = count_crc32((unsigned char *) e, entry_sz);
+ crc = count_crc32((unsigned char *) ents, entry_sz);
header->partition_entry_array_crc32 = cpu_to_le32(crc);
}
* Compute the 32bit CRC checksum of the partition table header.
* Returns 1 if it is valid, otherwise 0.
*/
-static int gpt_check_header_crc(struct gpt_header *header)
+static int gpt_check_header_crc(struct gpt_header *header, struct gpt_entry *ents)
{
uint32_t crc, orgcrc = le32_to_cpu(header->crc32);
crc = count_crc32((unsigned char *) header, le32_to_cpu(header->size));
header->crc32 = cpu_to_le32(orgcrc);
+ if (crc == le32_to_cpu(header->crc32))
+ return 1;
+
/*
* If we have checksum mismatch it may be due to stale data,
* like a partition being added or deleted. Recompute the CRC again
* and make sure this is not the case.
*/
- if (crc != le32_to_cpu(header->crc32)) {
+ if (ents) {
gpt_recompute_crc(header, ents);
orgcrc = le32_to_cpu(header->crc32);
header->crc32 = 0;
header->crc32 = cpu_to_le32(orgcrc);
return crc == le32_to_cpu(header->crc32);
- } else
- return 1;
+ }
+
+ return 0;
}
/*
* It initializes the partition entry array.
* Returns 1 if the checksum is valid, otherwise 0.
*/
-static int gpt_check_entryarr_crc(struct fdisk_context *cxt, struct gpt_header *header)
+static int gpt_check_entryarr_crc(struct gpt_header *header,
+ struct gpt_entry *ents)
{
int ret = 0;
ssize_t entry_sz;
uint32_t crc;
- if (!header)
+ if (!header || !ents)
goto done;
entry_sz = le32_to_cpu(header->npartition_entries) *
if (!entry_sz)
goto done;
- /* read header entries */
- if (!ents)
- ents = gpt_read_entries(cxt, header, entry_sz);
- if (!ents)
- goto done;
-
crc = count_crc32((unsigned char *) ents, entry_sz);
ret = (crc == le32_to_cpu(header->partition_entry_array_crc32));
done:
* Note that all tests must pass to ensure a valid header,
* we do not rely on only testing the signature for a valid probe.
*/
-static struct gpt_header *gpt_read_header(struct fdisk_context *cxt, uint64_t lba)
+static struct gpt_header *gpt_read_header(struct fdisk_context *cxt,
+ uint64_t lba,
+ struct gpt_entry **_ents)
{
struct gpt_header *header = NULL;
+ struct gpt_entry *ents = NULL;
uint32_t hsz;
if (!cxt)
header = xcalloc(1, sizeof(*header));
- /* read specified LBA */
+ /* read and verify header */
if (!read_lba(cxt, lba, header, sizeof(struct gpt_header)))
goto invalid;
if (!gpt_check_signature(header))
goto invalid;
- if (!gpt_check_header_crc(header) ||
- !gpt_check_entryarr_crc(cxt, header))
+ if (!gpt_check_header_crc(header, NULL))
+ goto invalid;
+
+ /* read and verify entries */
+ ents = gpt_read_entries(cxt, header);
+ if (!ents)
+ goto invalid;
+
+ if (!gpt_check_entryarr_crc(header, ents))
goto invalid;
if (!gpt_check_lba_sanity(cxt, header))
if (hsz < GPT_HEADER_MINSZ || hsz > cxt->sector_size)
goto invalid;
+ if (_ents)
+ *_ents = ents;
+ else
+ free(ents);
+
return header;
invalid:
free(header);
+ free(ents);
return NULL;
}
-/*
- * Return the Backup GPT Header, or NULL upon failure/invalid.
- */
-static struct gpt_header *gpt_read_bheader(struct fdisk_context *cxt)
-{
- return gpt_read_header(cxt, last_lba(cxt));
-}
-
-/*
- * Return the Primary GPT Header, or NULL upon failure/invalid.
- */
-static struct gpt_header *gpt_read_pheader(struct fdisk_context *cxt)
-{
- return gpt_read_header(cxt, GPT_PRIMARY_PARTITION_TABLE_LBA);
-}
-
/*
* Returns the number of partitions that are in use.
*/
/*
* Initialize fdisk-specific variables - call once probing passes!
*/
-static void gpt_init(struct fdisk_context *cxt __attribute__((__unused__)))
+static void gpt_init(struct fdisk_context *cxt)
{
- partitions = le32_to_cpu(pheader->npartition_entries);
+ struct fdisk_gpt_label *gpt = gpt_label(cxt);
+
+ partitions = le32_to_cpu(gpt->pheader->npartition_entries);
}
-static int gpt_probe_label(struct fdisk_context *cxt,
- struct fdisk_label *lb __attribute__((__unused__)))
+static int gpt_probe_label(struct fdisk_context *cxt, struct fdisk_label *lb)
{
int mbr_type;
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
- if (!cxt)
+ if (!cxt || !lb)
goto failed;
mbr_type = valid_pmbr(cxt);
DBG(LABEL, dbgprint("found a %s MBR", mbr_type == GPT_MBR_PROTECTIVE ?
"protective" : "hybrid"));
- pheader = gpt_read_pheader(cxt);
+ /* primary header */
+ gpt->pheader = gpt_read_header(cxt, GPT_PRIMARY_PARTITION_TABLE_LBA,
+ &gpt->ents);
/*
* TODO: If the primary GPT is corrupt, we must check the last LBA of the
*
* For now we just abort GPT probing!
*/
- if (!pheader)
+ if (!gpt->pheader || !gpt->ents)
goto failed;
/* OK, probing passed, now initialize backup header and fdisk variables. */
- bheader = gpt_read_bheader(cxt);
+ gpt->bheader = gpt_read_header(cxt, last_lba(cxt), NULL);
+
gpt_init(cxt);
printf(_("\nWARNING: fdisk GPT support is currently new, and therefore "
return 1;
failed:
DBG(LABEL, dbgprint("GPT probe failed"));
+ gpt_deinit(lb);
return 0;
}
int xtra __attribute__ ((__unused__)))
{
uint32_t i;
- uint64_t fu = le64_to_cpu(pheader->first_usable_lba);
- uint64_t lu = le64_to_cpu(pheader->last_usable_lba);
+ struct fdisk_gpt_label *gpt = gpt_label(cxt);
+ uint64_t fu = le64_to_cpu(gpt->pheader->first_usable_lba);
+ uint64_t lu = le64_to_cpu(gpt->pheader->last_usable_lba);
printf("\n# Start End Size Type Name\n");
- for (i = 0; i < le32_to_cpu(pheader->npartition_entries); i++) {
+ for (i = 0; i < le32_to_cpu(gpt->pheader->npartition_entries); i++) {
char *name = NULL, *sizestr = NULL;
- uint64_t start = gpt_partition_start(&ents[i]);
- uint64_t size = gpt_partition_size(&ents[i]);
+ uint64_t start = gpt_partition_start(&gpt->ents[i]);
+ uint64_t size = gpt_partition_size(&gpt->ents[i]);
struct fdisk_parttype *t;
- if (partition_unused(&ents[i]) || !size)
+ if (partition_unused(&gpt->ents[i]) || !size)
continue;
/* the partition has to inside usable range */
if (start < fu || start + size - 1 > lu)
continue;
- name = encode_to_utf8((unsigned char *)ents[i].partition_name,
- sizeof(ents[i].partition_name));
+ name = encode_to_utf8((unsigned char *)gpt->ents[i].partition_name,
+ sizeof(gpt->ents[i].partition_name));
if (!name)
continue;
sizestr = size_to_human_string(SIZE_SUFFIX_1LETTER,
printf("%2d %12ju %12ju %6s %-15.15s %s\n",
i+1,
start,
- gpt_partition_end(&ents[i]),
+ gpt_partition_end(&gpt->ents[i]),
sizestr,
t->name,
name);
* Returns 0 on success, or corresponding error otherwise.
*/
static int gpt_write_partitions(struct fdisk_context *cxt,
- struct gpt_header *header, struct gpt_entry *e)
+ struct gpt_header *header, struct gpt_entry *ents)
{
off_t offset = le64_to_cpu(header->partition_entry_lba) * cxt->sector_size;
uint32_t nparts = le32_to_cpu(header->npartition_entries);
if (offset != lseek(cxt->dev_fd, offset, SEEK_SET))
goto fail;
- rc = write(cxt->dev_fd, e, totwrite);
+
+ rc = write(cxt->dev_fd, ents, totwrite);
if (rc > 0 && totwrite == (uint32_t) rc)
return 0;
fail:
* Returns 0 if successful write, otherwise, a corresponding error.
* Any indication of error will abort the operation.
*/
-static int gpt_write_disklabel(struct fdisk_context *cxt,
- struct fdisk_label *lb __attribute__((__unused__)))
+static int gpt_write_disklabel(struct fdisk_context *cxt, struct fdisk_label *lb)
{
- if (!cxt)
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+
+ if (!cxt || !lb)
goto err0;
/* we do not want to mess up hybrid MBRs by creating a valid pmbr */
goto err0;
/* check that disk is big enough to handle the backup header */
- if (pheader->alternative_lba > cxt->total_sectors)
+ if (gpt->pheader->alternative_lba > cxt->total_sectors)
goto err0;
/* check that the backup header is properly placed */
- if (pheader->alternative_lba < cxt->total_sectors - 1)
+ if (gpt->pheader->alternative_lba < cxt->total_sectors - 1)
/* TODO: correct this (with user authorization) and write */
goto err0;
- if (partition_check_overlaps(pheader, ents))
+ if (partition_check_overlaps(gpt->pheader, gpt->ents))
goto err0;
/* recompute CRCs for both headers */
- gpt_recompute_crc(pheader, ents);
- gpt_recompute_crc(bheader, ents);
+ gpt_recompute_crc(gpt->pheader, gpt->ents);
+ gpt_recompute_crc(gpt->bheader, gpt->ents);
/*
* UEFI requires writing in this specific order:
*
* If any write fails, we abort the rest.
*/
- if (gpt_write_partitions(cxt, bheader, ents) != 0)
+ if (gpt_write_partitions(cxt, gpt->bheader, gpt->ents) != 0)
goto err1;
- if (gpt_write_header(cxt, bheader, pheader->alternative_lba) != 0)
+ if (gpt_write_header(cxt, gpt->bheader, gpt->pheader->alternative_lba) != 0)
goto err1;
- if (gpt_write_partitions(cxt, pheader, ents) != 0)
+ if (gpt_write_partitions(cxt, gpt->pheader, gpt->ents) != 0)
goto err1;
- if (gpt_write_header(cxt, pheader, GPT_PRIMARY_PARTITION_TABLE_LBA) != 0)
+ if (gpt_write_header(cxt, gpt->pheader, GPT_PRIMARY_PARTITION_TABLE_LBA) != 0)
goto err1;
if (gpt_write_pmbr(cxt) != 0)
goto err1;
* - primary and backup header validations
* - paritition validations
*/
-static int gpt_verify_disklabel(struct fdisk_context *cxt,
- struct fdisk_label *lb __attribute__((__unused__)))
+static int gpt_verify_disklabel(struct fdisk_context *cxt, struct fdisk_label *lb)
{
int nerror = 0, ptnum;
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
- if (!bheader) {
+ if (!gpt || !gpt->bheader) {
nerror++;
printf(_("Disk does not contain a valid backup header.\n"));
}
- if (!gpt_check_header_crc(pheader)) {
+ if (!gpt_check_header_crc(gpt->pheader, gpt->ents)) {
nerror++;
printf(_("Invalid primary header CRC checksum.\n"));
}
- if (bheader && !gpt_check_header_crc(bheader)) {
+ if (gpt->bheader && !gpt_check_header_crc(gpt->bheader, gpt->ents)) {
nerror++;
printf(_("Invalid backup header CRC checksum.\n"));
}
- if (!gpt_check_entryarr_crc(cxt, pheader)) {
+ if (!gpt_check_entryarr_crc(gpt->pheader, gpt->ents)) {
nerror++;
printf(_("Invalid partition entry checksum.\n"));
}
- if (!gpt_check_lba_sanity(cxt, pheader)) {
+ if (!gpt_check_lba_sanity(cxt, gpt->pheader)) {
nerror++;
printf(_("Invalid primary header LBA sanity checks.\n"));
}
- if (bheader && !gpt_check_lba_sanity(cxt, bheader)) {
+ if (gpt->bheader && !gpt_check_lba_sanity(cxt, gpt->bheader)) {
nerror++;
printf(_("Invalid backup header LBA sanity checks.\n"));
}
- if (le64_to_cpu(pheader->my_lba) != GPT_PRIMARY_PARTITION_TABLE_LBA) {
+ if (le64_to_cpu(gpt->pheader->my_lba) != GPT_PRIMARY_PARTITION_TABLE_LBA) {
nerror++;
printf(_("MyLBA mismatch with real position at primary header.\n"));
}
- if (bheader && le64_to_cpu(bheader->my_lba) != last_lba(cxt)) {
+ if (gpt->bheader && le64_to_cpu(gpt->bheader->my_lba) != last_lba(cxt)) {
nerror++;
printf(_("MyLBA mismatch with real position at backup header.\n"));
}
- if (pheader->alternative_lba >= cxt->total_sectors) {
+ if (gpt->pheader->alternative_lba >= cxt->total_sectors) {
nerror++;
printf(_("Disk is to small to hold all data.\n"));
}
* if the GPT is the primary table, check the alternateLBA
* to see if it is a valid GPT
*/
- if (bheader && (pheader->my_lba != bheader->alternative_lba)) {
+ if (gpt->bheader && (gpt->pheader->my_lba != gpt->bheader->alternative_lba)) {
nerror++;
printf(_("Primary and backup header mismatch.\n"));
}
- ptnum = partition_check_overlaps(pheader, ents);
+ ptnum = partition_check_overlaps(gpt->pheader, gpt->ents);
if (ptnum) {
nerror++;
printf(_("Partition %d overlaps with partition %d.\n"),
ptnum, ptnum + 1);
}
- ptnum = partition_check_too_big(pheader, ents, cxt->total_sectors);
+ ptnum = partition_check_too_big(gpt->pheader, gpt->ents, cxt->total_sectors);
if (ptnum) {
nerror++;
printf(_("Partition %u is too big for the disk.\n"), ptnum);
}
- ptnum = partition_start_after_end(pheader, ents);
+ ptnum = partition_start_after_end(gpt->pheader, gpt->ents);
if (ptnum) {
nerror++;
printf(_("Partition %u ends before it starts.\n"), ptnum);
uint64_t free_sectors = 0, largest_segment = 0;
printf(_("No errors detected\n"));
- printf(_("Header version: %s\n"), gpt_get_header_revstr(pheader));
+ printf(_("Header version: %s\n"), gpt_get_header_revstr(gpt->pheader));
printf(_("Using %d out of %d partitions\n"),
- partitions_in_use(pheader, ents),
- le32_to_cpu(pheader->npartition_entries));
+ partitions_in_use(gpt->pheader, gpt->ents),
+ le32_to_cpu(gpt->pheader->npartition_entries));
- free_sectors = get_free_sectors(cxt, pheader, ents,
+ free_sectors = get_free_sectors(cxt, gpt->pheader, gpt->ents,
&nsegments, &largest_segment);
printf(_("A total of %ju free sectors available in %u segment(s) "
"(largest %ju).\n"),
/* Delete a single GPT partition, specified by partnum. */
static int gpt_delete_partition(struct fdisk_context *cxt,
- struct fdisk_label *lb __attribute__((__unused__)),
+ struct fdisk_label *lb,
int partnum)
{
- if (!cxt || partition_unused(&ents[partnum]) || partnum < 0)
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+
+ if (!cxt || partnum < 0 || !gpt)
+ return -EINVAL;
+
+ if (partition_unused(&gpt->ents[partnum]))
return -EINVAL;
/* hasta la vista, baby! */
- memset(&ents[partnum], 0, sizeof(ents[partnum]));
- if (!partition_unused(&ents[partnum]))
+ memset(&gpt->ents[partnum], 0, sizeof(struct gpt_entry));
+ if (!partition_unused(&gpt->ents[partnum]))
return -EINVAL;
else {
- gpt_recompute_crc(pheader, ents);
- gpt_recompute_crc(bheader, ents);
+ gpt_recompute_crc(gpt->pheader, gpt->ents);
+ gpt_recompute_crc(gpt->bheader, gpt->ents);
}
return 0;
* of fsect to lsenct sectors, of type t.
* Returns 0 on success, or negative upon failure.
*/
-static int gpt_create_new_partition(int partnum, uint64_t fsect, uint64_t lsect,
+static int gpt_create_new_partition(struct fdisk_context *cxt,
+ int partnum, uint64_t fsect, uint64_t lsect,
struct gpt_guid *type,
struct gpt_entry *entries)
{
struct gpt_entry *e = NULL;
+ struct fdisk_gpt_label *gpt;
- if (fsect > lsect || partnum < 0)
+ if (!cxt || fsect > lsect || partnum < 0)
return -EINVAL;
+ gpt = gpt_label(cxt);
+
e = xcalloc(1, sizeof(*e));
e->lba_end = cpu_to_le64(lsect);
e->lba_start = cpu_to_le64(fsect);
uuid_generate_random((unsigned char *) &e->unique_partition_guid);
swap_efi_guid(&e->unique_partition_guid);
- memcpy(&entries[partnum] , e, sizeof(*e));
+ memcpy(&entries[partnum], e, sizeof(*e));
- gpt_recompute_crc(pheader, entries);
- gpt_recompute_crc(bheader, entries);
+ gpt_recompute_crc(gpt->pheader, entries);
+ gpt_recompute_crc(gpt->bheader, entries);
free(e);
return 0;
/* Performs logical checks to add a new partition entry */
static int gpt_add_partition(
struct fdisk_context *cxt,
- struct fdisk_label *lb __attribute__((__unused__)),
+ struct fdisk_label *lb,
int partnum,
struct fdisk_parttype *t)
{
uint64_t disk_f, disk_l; /* first and last available sector ranges on device*/
uint64_t dflt_f, dflt_l; /* largest segment (default) */
struct gpt_guid uuid = GPT_DEFAULT_ENTRY_GUID;
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+ struct gpt_header *pheader;
+ struct gpt_entry *ents;
/* check basic tests before even considering adding a new partition */
- if (!cxt || partnum < 0)
+ if (!cxt || partnum < 0 || !gpt)
return -EINVAL;
+
+ pheader = gpt->pheader;
+ ents = gpt->ents;
+
if (!partition_unused(&ents[partnum])) {
printf(_("Partition %d is already defined. "
"Delete it before re-adding it.\n"), partnum +1);
return -EINVAL;
}
- if (le32_to_cpu(pheader->npartition_entries) == partitions_in_use(pheader, ents)) {
+ if (le32_to_cpu(pheader->npartition_entries) ==
+ partitions_in_use(pheader, ents)) {
printf(_("All partitions are already in use.\n"));
return -EINVAL;
}
break;
}
- if (gpt_create_new_partition(partnum, user_f, user_l, &uuid, ents) != 0)
+ if (gpt_create_new_partition(cxt, partnum,
+ user_f, user_l, &uuid, ents) != 0)
printf(_("Could not create partition %d\n"), partnum + 1);
else
printf(_("Created partition %d\n"), partnum + 1);
* Create a new GPT disklabel - destroys any previous data.
*/
static int gpt_create_disklabel(struct fdisk_context *cxt,
- struct fdisk_label *lb __attribute__((__unused__)))
+ struct fdisk_label *lb)
{
int rc = 0;
ssize_t entry_sz = 0;
+ struct gpt_guid *uid;
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
- /* labe private stuff has to be empty, see gpt_deinit() */
- assert(pheader == NULL);
- assert(bheader == NULL);
+ /* label private stuff has to be empty, see gpt_deinit() */
+ assert(gpt);
+ assert(gpt->pheader == NULL);
+ assert(gpt->bheader == NULL);
/*
* When no header, entries or pmbr is set, we're probably
if (rc < 0)
goto done;
- pheader = xcalloc(1, sizeof(*pheader));
- rc = gpt_mknew_header(cxt, pheader, GPT_PRIMARY_PARTITION_TABLE_LBA);
+ /* primary */
+ gpt->pheader = xcalloc(1, sizeof(*gpt->pheader));
+ rc = gpt_mknew_header(cxt, gpt->pheader, GPT_PRIMARY_PARTITION_TABLE_LBA);
if (rc < 0)
goto done;
- bheader = xcalloc(1, sizeof(*bheader));
- rc = gpt_mknew_header_from_bkp(cxt, bheader, last_lba(cxt), pheader);
+ /* backup ("copy" primary) */
+ gpt->bheader = xcalloc(1, sizeof(*gpt->bheader));
+ rc = gpt_mknew_header_from_bkp(cxt, gpt->bheader,
+ last_lba(cxt), gpt->pheader);
if (rc < 0)
goto done;
- entry_sz = le32_to_cpu(pheader->npartition_entries) *
- le32_to_cpu(pheader->sizeof_partition_entry);
- ents = xcalloc(1, sizeof(*ents) * entry_sz);
+ entry_sz = le32_to_cpu(gpt->pheader->npartition_entries) *
+ le32_to_cpu(gpt->pheader->sizeof_partition_entry);
+ gpt->ents = xcalloc(1, sizeof(*gpt->ents) * entry_sz);
- gpt_recompute_crc(pheader, ents);
- gpt_recompute_crc(bheader, ents);
+ gpt_recompute_crc(gpt->pheader, gpt->ents);
+ gpt_recompute_crc(gpt->bheader, gpt->ents);
gpt_init(cxt);
+
+ uid = &gpt->pheader->disk_guid;
fprintf(stderr, ("Building a new GPT disklabel "
"(GUID: %08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X)\n"),
- pheader->disk_guid.time_low, pheader->disk_guid.time_mid,
- pheader->disk_guid.time_hi_and_version,
- pheader->disk_guid.clock_seq_hi,
- pheader->disk_guid.clock_seq_low,
- pheader->disk_guid.node[0], pheader->disk_guid.node[1],
- pheader->disk_guid.node[2], pheader->disk_guid.node[3],
- pheader->disk_guid.node[4], pheader->disk_guid.node[5]);
+ uid->time_low, uid->time_mid,
+ uid->time_hi_and_version,
+ uid->clock_seq_hi,
+ uid->clock_seq_low,
+ uid->node[0], uid->node[1],
+ uid->node[2], uid->node[3],
+ uid->node[4], uid->node[5]);
done:
return rc;
}
static struct fdisk_parttype *gpt_get_partition_type(
struct fdisk_context *cxt,
- struct fdisk_label *lb __attribute__((__unused__)),
+ struct fdisk_label *lb,
int i)
{
struct fdisk_parttype *t;
struct gpt_guid uuid;
char str[37];
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+
+ if (!cxt)
+ return NULL;
- if (!cxt || i < 0 || (uint32_t) i >= le32_to_cpu(pheader->npartition_entries))
+ if (!cxt || !gpt || i < 0
+ || (uint32_t) i >= le32_to_cpu(gpt->pheader->npartition_entries))
return NULL;
- uuid = ents[i].partition_type_guid;
+ uuid = gpt->ents[i].partition_type_guid;
swap_efi_guid(&uuid);
uuid_to_string(&uuid, str);
static int gpt_set_partition_type(
struct fdisk_context *cxt,
- struct fdisk_label *lb __attribute__((__unused__)),
+ struct fdisk_label *lb,
int i,
struct fdisk_parttype *t)
{
struct gpt_guid uuid;
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+
- if (!cxt || i < 0 || (uint32_t) i >= le32_to_cpu(pheader->npartition_entries) ||
- !t || !t->typestr || string_to_uuid(t->typestr, &uuid) != 0)
+ if (!cxt || !gpt || i < 0
+ || (uint32_t) i >= le32_to_cpu(gpt->pheader->npartition_entries)
+ || !t || !t->typestr || string_to_uuid(t->typestr, &uuid) != 0)
return -EINVAL;
- gpt_entry_set_type(&ents[i], &uuid);
- gpt_recompute_crc(pheader, ents);
- gpt_recompute_crc(bheader, ents);
+ gpt_entry_set_type(&gpt->ents[i], &uuid);
+ gpt_recompute_crc(gpt->pheader, gpt->ents);
+ gpt_recompute_crc(gpt->bheader, gpt->ents);
return 0;
}
/*
* Deinitialize fdisk-specific variables
*/
-static void gpt_deinit(struct fdisk_label *lb __attribute__((unused)))
+static void gpt_deinit(struct fdisk_label *lb)
{
- free(ents);
- free(pheader);
- free(bheader);
+ struct fdisk_gpt_label *gpt = (struct fdisk_gpt_label *) lb;
+
+ if (!gpt)
+ return;
+
+ free(gpt->ents);
+ free(gpt->pheader);
+ free(gpt->bheader);
+
+ gpt->ents = NULL;
+ gpt->pheader = NULL;
+ gpt->bheader = NULL;
- ents = NULL;
- pheader = NULL;
- bheader = NULL;
partitions = 0;
}
projects / thirdparty / util-linux.git / commitdiff
