int CgptCreate(CgptCreateParams *params) {
struct drive drive;
if (params == NULL)
return CGPT_FAILED;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDWR))
return CGPT_FAILED;
if (drive.is_mtd) {
if (MtdCreate(&drive, params))
goto bad;
} else {
if (GptCreate(&drive, params))
goto bad;
}
// Write it all out
return DriveClose(&drive, 1);
bad:
DriveClose(&drive, 0);
return CGPT_FAILED;
}
int CgptSetAttributes(CgptAddParams *params) {
struct drive drive;
if (params == NULL)
return CGPT_FAILED;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDWR))
return CGPT_FAILED;
if (CgptCheckAddValidity(&drive)) {
goto bad;
}
if (params->partition == 0 ||
params->partition >= GetNumberOfEntries(&drive)) {
Error("invalid partition number: %d\n", params->partition);
goto bad;
}
SetEntryAttributes(&drive, params->partition - 1, params);
UpdateAllEntries(&drive);
// Write it all out.
return DriveClose(&drive, 1);
bad:
DriveClose(&drive, 0);
return CGPT_FAILED;
}
int CgptRepair(CgptRepairParams *params) {
struct drive drive;
if (params == NULL)
return CGPT_FAILED;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDWR))
return CGPT_FAILED;
int gpt_retval = GptSanityCheck(&drive.gpt);
if (params->verbose)
printf("GptSanityCheck() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
GptRepair(&drive.gpt);
if (drive.gpt.modified & GPT_MODIFIED_HEADER1)
printf("Primary Header is updated.\n");
if (drive.gpt.modified & GPT_MODIFIED_ENTRIES1)
printf("Primary Entries is updated.\n");
if (drive.gpt.modified & GPT_MODIFIED_ENTRIES2)
printf("Secondary Entries is updated.\n");
if (drive.gpt.modified & GPT_MODIFIED_HEADER2)
printf("Secondary Header is updated.\n");
return DriveClose(&drive, 1);
}
// This method gets the partition details such as the attributes, the
// guids of the partitions, etc. Input is the partition number or the
// unique id of the partition. Output is populated in the respective
// fields of params.
int CgptGetPartitionDetails(CgptAddParams *params) {
struct drive drive;
int result = CGPT_FAILED;
int index;
if (params == NULL)
return CGPT_FAILED;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDWR))
return CGPT_FAILED;
if (CgptCheckAddValidity(&drive)) {
goto bad;
}
int max_part = GetNumberOfEntries(&drive);
if (params->partition > 0) {
if (params->partition >= max_part) {
Error("invalid partition number: %d\n", params->partition);
goto bad;
}
} else {
if (!params->set_unique) {
Error("either partition or unique_id must be specified\n");
goto bad;
}
for (index = 0; index < max_part; index++) {
GptEntry *entry = GetEntry(&drive.gpt, PRIMARY, index);
if (GuidEqual(&entry->unique, ¶ms->unique_guid)) {
params->partition = index + 1;
break;
}
}
if (index >= max_part) {
Error("no partitions with the given unique id available\n");
goto bad;
}
}
index = params->partition - 1;
{
// GPT-specific code
GptEntry *entry = GetEntry(&drive.gpt, PRIMARY, index);
params->begin = entry->starting_lba;
params->size = entry->ending_lba - entry->starting_lba + 1;
memcpy(¶ms->type_guid, &entry->type, sizeof(Guid));
memcpy(¶ms->unique_guid, &entry->unique, sizeof(Guid));
params->raw_value = entry->attrs.fields.gpt_att;
}
params->successful = GetSuccessful(&drive, PRIMARY, index);
params->tries = GetTries(&drive, PRIMARY, index);
params->priority = GetPriority(&drive, PRIMARY, index);
result = CGPT_OK;
bad:
DriveClose(&drive, 0);
return result;
}
int CgptAdd(CgptAddParams *params) {
struct drive drive;
GptEntry *entry, backup;
uint32_t index;
int rv;
if (params == NULL)
return CGPT_FAILED;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDWR))
return CGPT_FAILED;
if (CgptCheckAddValidity(&drive)) {
goto bad;
}
if (CgptGetUnusedPartition(&drive, &index, params)) {
goto bad;
}
entry = GetEntry(&drive.gpt, PRIMARY, index);
memcpy(&backup, entry, sizeof(backup));
if (SetEntryAttributes(&drive, index, params) ||
GptSetEntryAttributes(&drive, index, params)) {
memcpy(entry, &backup, sizeof(*entry));
goto bad;
}
UpdateAllEntries(&drive);
rv = CheckEntries((GptEntry*)drive.gpt.primary_entries,
(GptHeader*)drive.gpt.primary_header);
if (0 != rv) {
// If the modified entry is illegal, recover it and return error.
memcpy(entry, &backup, sizeof(*entry));
Error("%s\n", GptErrorText(rv));
Error(DumpCgptAddParams(params));
goto bad;
}
// Write it all out.
return DriveClose(&drive, 1);
bad:
DriveClose(&drive, 0);
return CGPT_FAILED;
}
// This returns true if a GPT partition matches the search criteria. If a match
// isn't found (or if the file doesn't contain a GPT), it returns false. The
// filename and partition number that matched is left in a global, since we
// could have multiple hits.
static int do_search(CgptFindParams *params, char *fileName) {
int retval = 0;
int i;
struct drive drive;
GptEntry *entry;
char partlabel[GPT_PARTNAME_LEN];
if (CGPT_OK != DriveOpen(fileName, &drive, O_RDONLY))
return 0;
if (GPT_SUCCESS != GptSanityCheck(&drive.gpt)) {
(void) DriveClose(&drive, 0);
return 0;
}
for (i = 0; i < GetNumberOfEntries(&drive); ++i) {
entry = GetEntry(&drive.gpt, ANY_VALID, i);
if (GuidIsZero(&entry->type))
continue;
int found = 0;
if ((params->set_unique && GuidEqual(¶ms->unique_guid, &entry->unique))
|| (params->set_type && GuidEqual(¶ms->type_guid, &entry->type))) {
found = 1;
} else if (params->set_label) {
if (CGPT_OK != UTF16ToUTF8(entry->name,
sizeof(entry->name) / sizeof(entry->name[0]),
(uint8_t *)partlabel, sizeof(partlabel))) {
Error("The label cannot be converted from UTF16, so abort.\n");
return 0;
}
if (!strncmp(params->label, partlabel, sizeof(partlabel)))
found = 1;
}
if (found && match_content(params, &drive, entry)) {
params->hits++;
retval++;
showmatch(params, fileName, i+1, entry);
if (!params->match_partnum)
params->match_partnum = i+1;
}
}
(void) DriveClose(&drive, 0);
return retval;
}
int CgptGetBootPartitionNumber(CgptBootParams *params) {
struct drive drive;
int gpt_retval= 0;
int retval;
if (params == NULL)
return CGPT_FAILED;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDONLY,
params->drive_size))
return CGPT_FAILED;
if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive.gpt))) {
Error("GptSanityCheck() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
retval = CGPT_FAILED;
goto done;
}
if (CGPT_OK != ReadPMBR(&drive)) {
Error("Unable to read PMBR\n");
retval = CGPT_FAILED;
goto done;
}
char buf[GUID_STRLEN];
GuidToStr(&drive.pmbr.boot_guid, buf, sizeof(buf));
int numEntries = GetNumberOfEntries(&drive);
int i;
for(i = 0; i < numEntries; i++) {
GptEntry *entry = GetEntry(&drive.gpt, ANY_VALID, i);
if (GuidEqual(&entry->unique, &drive.pmbr.boot_guid)) {
params->partition = i + 1;
retval = CGPT_OK;
goto done;
}
}
Error("Didn't find any boot partition\n");
params->partition = 0;
retval = CGPT_FAILED;
done:
(void) DriveClose(&drive, 1);
return retval;
}
int CgptCreate(CgptCreateParams *params) {
struct drive drive;
int mode = O_RDWR;
if (params == NULL)
return CGPT_FAILED;
if (params->create)
mode |= O_CREAT;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, params->min_size, mode))
return CGPT_FAILED;
// Erase the data
memset(drive.gpt.primary_header, 0,
drive.gpt.sector_bytes * GPT_HEADER_SECTOR);
memset(drive.gpt.secondary_header, 0,
drive.gpt.sector_bytes * GPT_HEADER_SECTOR);
memset(drive.gpt.primary_entries, 0,
drive.gpt.sector_bytes * GPT_ENTRIES_SECTORS);
memset(drive.gpt.secondary_entries, 0,
drive.gpt.sector_bytes * GPT_ENTRIES_SECTORS);
memset(&drive.pmbr, 0, sizeof(drive.pmbr));
drive.gpt.modified |= (GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1 |
GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2);
// Initialize a blank set
if (!params->zap)
{
if (CGPT_OK != initialize_gpt(&drive, params->drive_guid))
goto bad;
InitPMBR(&drive, PRIMARY);
}
if (CGPT_OK != WritePMBR(&drive))
goto bad;
// Write it all out
return DriveClose(&drive, 1);
bad:
DriveClose(&drive, 0);
return CGPT_FAILED;
}
int CgptNext(CgptNextParams *params) {
struct drive drive;
GptEntry *entry;
char tmp[64];
int tries;
next_index = -1;
int gpt_retval;
if (params == NULL)
return CGPT_FAILED;
if (params->drive_name) {
do_search(params);
} else {
scan_real_devs(params);
}
if (strlen(next_file_name) < 0) {
return CGPT_FAILED;
}
if (DriveOpen(next_file_name, &drive, 0, O_RDWR) == CGPT_OK) {
if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive.gpt))) {
Error("GptSanityCheck() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
return CGPT_FAILED;
}
// Decrement tries if we selected on that criteria
tries = GetTries(&drive, PRIMARY, next_index);
if (tries > 0) {
tries--;
}
SetTries(&drive, PRIMARY, next_index, tries);
// Print out the next disk to go!
entry = GetEntry(&drive.gpt, ANY_VALID, next_index);
GuidToStrLower(&entry->unique, tmp, sizeof(tmp));
printf("%s\n", tmp);
// Write it all out
UpdateAllEntries(&drive);
return DriveClose(&drive, 1);
}
return 1;
}
int CgptRepair(CgptRepairParams *params) {
struct drive drive;
if (params == NULL)
return CGPT_FAILED;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, 0, O_RDWR))
return CGPT_FAILED;
if (CGPT_OK != ReadPMBR(&drive)) {
Error("Unable to read PMBR\n");
}
int gpt_retval = GptSanityCheck(&drive.gpt);
if (params->verbose)
printf("GptSanityCheck() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
if (GPT_SUCCESS != (gpt_retval = GptRepair(&drive.gpt))) {
Error("GptRepair() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
return CGPT_FAILED;
}
if (drive.gpt.modified & GPT_MODIFIED_HEADER1)
printf("Primary Header is updated.\n");
if (drive.gpt.modified & GPT_MODIFIED_ENTRIES1)
printf("Primary Entries is updated.\n");
if (drive.gpt.modified & GPT_MODIFIED_ENTRIES2)
printf("Secondary Entries is updated.\n");
if (drive.gpt.modified & GPT_MODIFIED_HEADER2)
printf("Secondary Header is updated.\n");
UpdatePMBR(&drive, ANY_VALID);
if (WritePMBR(&drive) != CGPT_OK) {
Error("Failed to write legacy MBR.\n");
}
return DriveClose(&drive, 1);
}
static int do_search(CgptNextParams *params) {
struct drive drive;
uint32_t max_part;
int gpt_retval;
int priority, tries, successful;
int i;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, 0, O_RDONLY))
return CGPT_FAILED;
if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive.gpt))) {
Error("GptSanityCheck() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
return CGPT_FAILED;
}
max_part = GetNumberOfEntries(&drive);
for (i = 0; i < max_part; i++) {
if (!IsRoot(&drive, PRIMARY, i))
continue;
priority = GetPriority(&drive, PRIMARY, i);
tries = GetTries(&drive, PRIMARY, i);
successful = GetSuccessful(&drive, PRIMARY, i);
if (next_index == -1 || ((priority > next_priority) && (successful || tries))) {
strncpy(next_file_name, params->drive_name, BUFSIZE);
if (successful || tries) {
next_priority = priority;
} else {
next_priority = -1;
}
next_index = i;
}
}
return DriveClose(&drive, 0);
}
/* Resize the partition and notify the kernel.
* returns:
* CGPT_OK for resize successful or nothing to do
* CGPT_FAILED on error
*/
static int resize_partition(CgptResizeParams *params, blkid_dev dev) {
char *disk_devname;
struct drive drive;
GptHeader *header;
GptEntry *entry;
int gpt_retval, entry_index, entry_count;
uint64_t free_bytes, last_free_lba, entry_size_lba;
if ((disk_devname = dev_to_wholedevname(dev)) == NULL) {
Error("Failed to find whole disk device for %s\n", blkid_dev_devname(dev));
return CGPT_FAILED;
}
if (DriveOpen(disk_devname, &drive, 0, O_RDWR) != CGPT_OK) {
free(disk_devname);
return CGPT_FAILED;
}
free(disk_devname);
if (CGPT_OK != ReadPMBR(&drive)) {
Error("Unable to read PMBR\n");
goto nope;
}
if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive.gpt))) {
Error("GptSanityCheck() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
goto nope;
}
// If either table is bad fix it! (likely if disk was extended)
GptRepair(&drive.gpt);
header = (GptHeader*)drive.gpt.primary_header;
last_free_lba = header->last_usable_lba;
entry_count = GetNumberOfEntries(&drive);
entry_index = dev_to_partno(dev) - 1;
if (entry_index < 0 || entry_index >= entry_count) {
Error("Kernel and GPT disagree on the number of partitions!\n");
goto nope;
}
entry = GetEntry(&drive.gpt, PRIMARY, entry_index);
// Scan entire table to determine if entry can grow.
for (int i = 0; i < entry_count; i++) {
GptEntry *other = GetEntry(&drive.gpt, PRIMARY, i);
if (GuidIsZero(&other->type))
continue;
if (other->starting_lba > entry->ending_lba &&
other->starting_lba - 1 < last_free_lba) {
last_free_lba = other->starting_lba - 1;
}
}
// Exit without doing anything if the size is too small
free_bytes = (last_free_lba - entry->ending_lba) * drive.gpt.sector_bytes;
if (entry->ending_lba >= last_free_lba ||
free_bytes < params->min_resize_bytes) {
if (DriveClose(&drive, 0) != CGPT_OK)
return CGPT_FAILED;
else
return CGPT_OK;
}
// Update and test partition table in memory
entry->ending_lba = last_free_lba;
entry_size_lba = entry->ending_lba - entry->starting_lba;
UpdateAllEntries(&drive);
gpt_retval = CheckEntries((GptEntry*)drive.gpt.primary_entries,
(GptHeader*)drive.gpt.primary_header);
if (gpt_retval != GPT_SUCCESS) {
Error("CheckEntries() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
goto nope;
}
// Notify kernel of new partition size via an ioctl.
if (blkpg_resize_partition(drive.fd, dev_to_partno(dev),
entry->starting_lba * drive.gpt.sector_bytes,
entry_size_lba * drive.gpt.sector_bytes) < 0) {
Error("Failed to notify kernel of new partition size: %s\n"
"Leaving existing partition table in place.\n", strerror(errno));
goto nope;
}
UpdatePMBR(&drive, PRIMARY);
if (WritePMBR(&drive) != CGPT_OK) {
Error("Failed to write legacy MBR.\n");
goto nope;
}
// Whew! we made it! Flush to disk.
return DriveClose(&drive, 1);
nope:
DriveClose(&drive, 0);
return CGPT_FAILED;
}
int CgptBoot(CgptBootParams *params) {
struct drive drive;
int retval = 1;
int gpt_retval= 0;
int mode = O_RDONLY;
if (params == NULL)
return CGPT_FAILED;
if (params->create_pmbr || params->partition || params->bootfile)
mode = O_RDWR;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, mode,
params->drive_size)) {
return CGPT_FAILED;
}
if (CGPT_OK != ReadPMBR(&drive)) {
Error("Unable to read PMBR\n");
goto done;
}
if (params->create_pmbr) {
drive.pmbr.magic[0] = 0x1d;
drive.pmbr.magic[1] = 0x9a;
drive.pmbr.sig[0] = 0x55;
drive.pmbr.sig[1] = 0xaa;
memset(&drive.pmbr.part, 0, sizeof(drive.pmbr.part));
drive.pmbr.part[0].f_head = 0x00;
drive.pmbr.part[0].f_sect = 0x02;
drive.pmbr.part[0].f_cyl = 0x00;
drive.pmbr.part[0].type = 0xee;
drive.pmbr.part[0].l_head = 0xff;
drive.pmbr.part[0].l_sect = 0xff;
drive.pmbr.part[0].l_cyl = 0xff;
drive.pmbr.part[0].f_lba = htole32(1);
uint32_t max = 0xffffffff;
if (drive.gpt.streaming_drive_sectors < 0xffffffff)
max = drive.gpt.streaming_drive_sectors - 1;
drive.pmbr.part[0].num_sect = htole32(max);
}
if (params->partition) {
if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive.gpt))) {
Error("GptSanityCheck() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
goto done;
}
if (params->partition > GetNumberOfEntries(&drive)) {
Error("invalid partition number: %d\n", params->partition);
goto done;
}
uint32_t index = params->partition - 1;
GptEntry *entry = GetEntry(&drive.gpt, ANY_VALID, index);
memcpy(&drive.pmbr.boot_guid, &entry->unique, sizeof(Guid));
}
if (params->bootfile) {
int fd = open(params->bootfile, O_RDONLY);
if (fd < 0) {
Error("Can't read %s: %s\n", params->bootfile, strerror(errno));
goto done;
}
int n = read(fd, drive.pmbr.bootcode, sizeof(drive.pmbr.bootcode));
if (n < 1) {
Error("problem reading %s: %s\n", params->bootfile, strerror(errno));
close(fd);
goto done;
}
close(fd);
}
char buf[GUID_STRLEN];
GuidToStr(&drive.pmbr.boot_guid, buf, sizeof(buf));
printf("%s\n", buf);
// Write it all out, if needed.
if (mode == O_RDONLY || CGPT_OK == WritePMBR(&drive))
retval = 0;
done:
(void) DriveClose(&drive, 1);
return retval;
}
int CgptPrioritize(CgptPrioritizeParams *params) {
struct drive drive;
int priority;
int gpt_retval;
uint32_t index;
uint32_t max_part;
int num_root;
int i,j;
group_list_t *groups;
if (params == NULL)
return CGPT_FAILED;
if (CGPT_OK != DriveOpen(params->drive_name, &drive, 0, O_RDWR))
return CGPT_FAILED;
if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive.gpt))) {
Error("GptSanityCheck() returned %d: %s\n",
gpt_retval, GptError(gpt_retval));
return CGPT_FAILED;
}
max_part = GetNumberOfEntries(&drive);
if (params->set_partition) {
if (params->set_partition < 1 || params->set_partition > max_part) {
Error("invalid partition number: %d (must be between 1 and %d\n",
params->set_partition, max_part);
goto bad;
}
index = params->set_partition - 1;
// it must be a kernel
if (!IsRoot(&drive, PRIMARY, index) && !IsMarker(&drive, PRIMARY, index)) {
Error("partition %d is not a valid root\n", params->set_partition);
goto bad;
}
}
// How many kernel partitions do I have?
num_root = 0;
for (i = 0; i < max_part; i++) {
if (IsRoot(&drive, PRIMARY, i) || IsMarker(&drive, PRIMARY, i))
num_root++;
}
if (num_root) {
// Determine the current priority groups
groups = NewGroupList(num_root);
for (i = 0; i < max_part; i++) {
if (!IsRoot(&drive, PRIMARY, i) && !IsMarker(&drive, PRIMARY, i))
continue;
priority = GetPriority(&drive, PRIMARY, i);
// Is this partition special?
if (params->set_partition && (i+1 == params->set_partition)) {
params->orig_priority = priority; // remember the original priority
if (params->set_friends)
AddToGroup(groups, priority, i); // we'll move them all later
else
AddToGroup(groups, 99, i); // move only this one
} else {
AddToGroup(groups, priority, i); // just remember
}
}
// If we're including friends, then change the original group priority
if (params->set_partition && params->set_friends) {
ChangeGroup(groups, params->orig_priority, 99);
}
// Sorting gives the new order. Now we just need to reassign the
// priorities.
SortGroups(groups);
// We'll never lower anything to zero, so if the last group is priority zero
// we can ignore it.
i = groups->num_groups;
if (groups->group[i-1].priority == 0)
groups->num_groups--;
// Where do we start?
if (params->max_priority)
priority = params->max_priority;
else
priority = groups->num_groups > 15 ? 15 : groups->num_groups;
// Figure out what the new values should be
for (i=0; i<groups->num_groups; i++) {
groups->group[i].priority = priority;
if (priority > 1)
priority--;
}
// Now apply the ranking to the GPT
for (i=0; i<groups->num_groups; i++)
for (j=0; j<groups->group[i].num_parts; j++)
SetPriority(&drive, PRIMARY,
groups->group[i].part[j], groups->group[i].priority);
FreeGroups(groups);
}
// Write it all out
UpdateAllEntries(&drive);
return DriveClose(&drive, 1);
bad:
(void) DriveClose(&drive, 0);
return CGPT_FAILED;
}