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;
}
// 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;
}
//------------------------------------------------------------------------------
stSize stSlimIndexNode::GetFree(){
stSize usedsize;
// Fixed size
usedsize = sizeof(stSlimNodeHeader);
// Entries
if (GetNumberOfEntries() > 0){
usedsize +=
// Total size of entries
(sizeof(stSlimIndexEntry) * GetNumberOfEntries()) +
// Total object size
(Page->GetPageSize() - Entries[GetNumberOfEntries() - 1].Offset);
}//end if
return Page->GetPageSize() - usedsize;
}//end stSlimIndexNode::GetFree()
//------------------------------------------------------------------------------
const stByte * stSlimLeafNode::GetObject(stCount idx){
#ifdef __stDEBUG__
if (idx >= GetNumberOfEntries()){
throw invalid_argument("idx value is out of range.");
}//end if
#endif //__stDEBUG__
return Page->GetData() + Entries[idx].Offset;
}//end stSlimLeafNode::GetObject()
//------------------------------------------------------------------------------
stCount stSlimIndexNode::GetTotalObjectCount(){
stSize count;
stCount i;
count = 0;
for (i = 0; i < GetNumberOfEntries(); i++){
count += GetIndexEntry(i).NEntries;
}//end for
return count;
}//end stSlimIndexNode::GetTotalObjectCount
//------------------------------------------------------------------------------
stDistance stMLeafNode::GetMinimumRadius(){
int i;
stDistance d = 0;
for (i = 0; i < GetNumberOfEntries(); i++){
if (d < GetLeafEntry(i).Distance){
d = GetLeafEntry(i).Distance;
}//end if
}//end for
return d;
}//end stMLeafNode::GetMinimumRadius
//------------------------------------------------------------------------------
stDistance stSlimLeafNode::GetMinimumRadius(){
stCount i;
stDistance radius = 0;
for (i = 0; i < GetNumberOfEntries(); i++){
if (radius < GetLeafEntry(i).Distance){
radius = GetLeafEntry(i).Distance;
}//end if
}//end for
return radius;
}//end stSlimLeafNode::GetMinimumRadius
//------------------------------------------------------------------------------
stDistance stDFLeafNode::GetMinimumRadius(){
stDistance minRadius = 0;
stCount i;
// For each entry.
for (i = 0; i < GetNumberOfEntries(); i++){
if (minRadius < GetLeafEntry(i).Distance){
minRadius = GetLeafEntry(i).Distance;
}//end if
}//end for
return minRadius;
}//end stDFLeafNode::GetMinimumRadius
//------------------------------------------------------------------------------
stDistance stMIndexNode::GetMinimumRadius(){
int i;
stDistance d = 0;
stDistance r;
for (i = 0; i < GetNumberOfEntries(); i++){
r = GetIndexEntry(i).Distance + GetIndexEntry(i).Radius;
if (d < r){
d = r;
}//end if
}//end for
return d;
}//end stMIndexNode::GetMinimumRadius
//------------------------------------------------------------------------------
stDistance stSlimIndexNode::GetMinimumRadius(){
stDistance minRadius = 0;
stDistance distance;
stCount i;
// For each entry.
for (i = 0; i < GetNumberOfEntries(); i++){
distance = GetIndexEntry(i).Distance + GetIndexEntry(i).Radius;
if (minRadius < distance){
minRadius = distance;
}//end if
}//end for
return minRadius;
}//end stSlimIndexNode::GetMinimumRadius
size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
{
size_t n = m_pCurrentGroup->Entries().Count();
if ( bRecursive ) {
ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
size_t nSubgroups = m_pCurrentGroup->Groups().Count();
for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
n += GetNumberOfEntries(TRUE);
CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
}
}
return n;
}
//------------------------------------------------------------------------------
stSize stSlimLeafNode::GetObjectSize(stCount idx){
#ifdef __stDEBUG__
if (idx >= GetNumberOfEntries()){
throw invalid_argument("idx value is out of range.");
}//end if
#endif //__stDEBUG__
if (idx == 0){
// First object
return Page->GetPageSize() - Entries[0].Offset;
}else{
// Any other
return Entries[idx - 1].Offset - Entries[idx].Offset;
}//end if
}//end stSlimLeafIndexNode::GetObjectSize()
// 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;
}
//------------------------------------------------------------------------------
void stSlimLeafNode::RemoveEntry(stCount idx){
stCount lastID;
stCount i;
stSize rObjSize;
// Programmer's note: This procedure is simple but tricky! See the
// SlimIndexNode structure documentation for more details.
#ifdef __stDEBUG__
if (idx >= GetNumberOfEntries()){
// Oops! This idx doesn't exists.
throw range_error("idx value is out of range.");
}//end if
#endif //__stDEBUG__
// Let's remove
lastID = Header->Occupation - 1; // The idx of the last object. This
// value will be very useful.
// Do I need to move something ?
if (idx != lastID){
// Yes, I do.
rObjSize = GetObjectSize(idx); // Save the removed object size
// Let's move objects first. We will use memmove() from stdlib because
// it handles the overlap between src and dst. Remember that src is the
// offset of the last object and the dst is the offset of the last
// object plus removed object size.
memmove(Page->GetData() + Entries[lastID].Offset + rObjSize,
Page->GetData() + Entries[lastID].Offset,
Entries[idx].Offset - Entries[lastID].Offset);
// Let's move entries...
for (i = idx; i < lastID; i++){
// Copy all fields with memcpy (it's faster than field copy).
memcpy(Entries + i, Entries + i + 1, sizeof(stSlimLeafEntry));
// Update offset by adding the removed object size to it. It will
// reflect the previous move operation.
Entries[i].Offset += rObjSize;
}//end for
}//end if
// Update counter...
Header->Occupation--;
}//end stSlimLeafNode::RemoveEntry
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);
}
static int CgptGetUnusedPartition(struct drive *drive, uint32_t *index,
CgptAddParams *params) {
uint32_t i;
uint32_t max_part = GetNumberOfEntries(drive);
if (params->partition) {
if (params->partition > max_part) {
Error("invalid partition number: %d\n", params->partition);
return -1;
}
*index = params->partition - 1;
return 0;
} else {
// Find next empty partition.
for (i = 0; i < max_part; i++) {
if (IsUnused(drive, PRIMARY, i)) {
params->partition = i + 1;
*index = i;
return 0;
}
}
Error("no unused partitions available\n");
return -1;
}
}
/* 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;
}
ResourceEntryIterator ResourceDirectory::end()
{
return ResourceEntryIterator(GetPtr(), LocateFirstEntry(GetPtr()) + GetNumberOfEntries(GetPtr()));
}
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;
}
