| /* basicmbr.cc -- Functions for loading, saving, and manipulating legacy MBR partition |
| data. */ |
| |
| /* Initial coding by Rod Smith, January to February, 2009 */ |
| |
| /* This program is copyright (c) 2009-2013 by Roderick W. Smith. It is distributed |
| under the terms of the GNU GPL version 2, as detailed in the COPYING file. */ |
| |
| #define __STDC_LIMIT_MACROS |
| #ifndef __STDC_CONSTANT_MACROS |
| #define __STDC_CONSTANT_MACROS |
| #endif |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <time.h> |
| #include <sys/stat.h> |
| #include <errno.h> |
| #include <iostream> |
| #include <algorithm> |
| #include "mbr.h" |
| #include "support.h" |
| |
| using namespace std; |
| |
| /**************************************** |
| * * |
| * MBRData class and related structures * |
| * * |
| ****************************************/ |
| |
| BasicMBRData::BasicMBRData(void) { |
| blockSize = SECTOR_SIZE; |
| diskSize = 0; |
| device = ""; |
| state = invalid; |
| numHeads = MAX_HEADS; |
| numSecspTrack = MAX_SECSPERTRACK; |
| myDisk = NULL; |
| canDeleteMyDisk = 0; |
| // memset(&EbrLocations, 0, MAX_MBR_PARTS * sizeof(uint32_t)); |
| EmptyMBR(); |
| } // BasicMBRData default constructor |
| |
| BasicMBRData::BasicMBRData(string filename) { |
| blockSize = SECTOR_SIZE; |
| diskSize = 0; |
| device = filename; |
| state = invalid; |
| numHeads = MAX_HEADS; |
| numSecspTrack = MAX_SECSPERTRACK; |
| myDisk = NULL; |
| canDeleteMyDisk = 0; |
| // memset(&EbrLocations, 0, MAX_MBR_PARTS * sizeof(uint32_t)); |
| |
| // Try to read the specified partition table, but if it fails.... |
| if (!ReadMBRData(filename)) { |
| EmptyMBR(); |
| device = ""; |
| } // if |
| } // BasicMBRData(string filename) constructor |
| |
| // Free space used by myDisk only if that's OK -- sometimes it will be |
| // copied from an outside source, in which case that source should handle |
| // it! |
| BasicMBRData::~BasicMBRData(void) { |
| if (canDeleteMyDisk) |
| delete myDisk; |
| } // BasicMBRData destructor |
| |
| // Assignment operator -- copy entire set of MBR data. |
| BasicMBRData & BasicMBRData::operator=(const BasicMBRData & orig) { |
| int i; |
| |
| memcpy(code, orig.code, 440); |
| diskSignature = orig.diskSignature; |
| nulls = orig.nulls; |
| MBRSignature = orig.MBRSignature; |
| blockSize = orig.blockSize; |
| diskSize = orig.diskSize; |
| numHeads = orig.numHeads; |
| numSecspTrack = orig.numSecspTrack; |
| canDeleteMyDisk = orig.canDeleteMyDisk; |
| device = orig.device; |
| state = orig.state; |
| |
| myDisk = new DiskIO; |
| if (myDisk == NULL) { |
| cerr << "Unable to allocate memory in BasicMBRData::operator=()! Terminating!\n"; |
| exit(1); |
| } // if |
| if (orig.myDisk != NULL) |
| myDisk->OpenForRead(orig.myDisk->GetName()); |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| partitions[i] = orig.partitions[i]; |
| } // for |
| return *this; |
| } // BasicMBRData::operator=() |
| |
| /********************** |
| * * |
| * Disk I/O functions * |
| * * |
| **********************/ |
| |
| // Read data from MBR. Returns 1 if read was successful (even if the |
| // data isn't a valid MBR), 0 if the read failed. |
| int BasicMBRData::ReadMBRData(const string & deviceFilename) { |
| int allOK = 1; |
| |
| if (myDisk == NULL) { |
| myDisk = new DiskIO; |
| if (myDisk == NULL) { |
| cerr << "Unable to allocate memory in BasicMBRData::ReadMBRData()! Terminating!\n"; |
| exit(1); |
| } // if |
| canDeleteMyDisk = 1; |
| } // if |
| if (myDisk->OpenForRead(deviceFilename)) { |
| allOK = ReadMBRData(myDisk); |
| } else { |
| allOK = 0; |
| } // if |
| |
| if (allOK) |
| device = deviceFilename; |
| |
| return allOK; |
| } // BasicMBRData::ReadMBRData(const string & deviceFilename) |
| |
| // Read data from MBR. If checkBlockSize == 1 (the default), the block |
| // size is checked; otherwise it's set to the default (512 bytes). |
| // Note that any extended partition(s) present will be omitted from |
| // in the partitions[] array; these partitions must be re-created when |
| // the partition table is saved in MBR format. |
| int BasicMBRData::ReadMBRData(DiskIO * theDisk, int checkBlockSize) { |
| int allOK = 1, i, logicalNum = 3; |
| int err = 1; |
| TempMBR tempMBR; |
| |
| if ((myDisk != NULL) && (myDisk != theDisk) && (canDeleteMyDisk)) { |
| delete myDisk; |
| canDeleteMyDisk = 0; |
| } // if |
| |
| myDisk = theDisk; |
| |
| // Empty existing MBR data, including the logical partitions... |
| EmptyMBR(0); |
| |
| if (myDisk->Seek(0)) |
| if (myDisk->Read(&tempMBR, 512)) |
| err = 0; |
| if (err) { |
| cerr << "Problem reading disk in BasicMBRData::ReadMBRData()!\n"; |
| } else { |
| for (i = 0; i < 440; i++) |
| code[i] = tempMBR.code[i]; |
| diskSignature = tempMBR.diskSignature; |
| nulls = tempMBR.nulls; |
| for (i = 0; i < 4; i++) { |
| partitions[i] = tempMBR.partitions[i]; |
| if (partitions[i].GetLengthLBA() > 0) |
| partitions[i].SetInclusion(PRIMARY); |
| } // for i... (reading all four partitions) |
| MBRSignature = tempMBR.MBRSignature; |
| ReadCHSGeom(); |
| |
| // Reverse the byte order, if necessary |
| if (IsLittleEndian() == 0) { |
| ReverseBytes(&diskSignature, 4); |
| ReverseBytes(&nulls, 2); |
| ReverseBytes(&MBRSignature, 2); |
| for (i = 0; i < 4; i++) { |
| partitions[i].ReverseByteOrder(); |
| } // for |
| } // if |
| |
| if (MBRSignature != MBR_SIGNATURE) { |
| allOK = 0; |
| state = invalid; |
| } // if |
| |
| // Find disk size |
| diskSize = myDisk->DiskSize(&err); |
| |
| // Find block size |
| if (checkBlockSize) { |
| blockSize = myDisk->GetBlockSize(); |
| } // if (checkBlockSize) |
| |
| // Load logical partition data, if any is found.... |
| if (allOK) { |
| for (i = 0; i < 4; i++) { |
| if ((partitions[i].GetType() == 0x05) || (partitions[i].GetType() == 0x0f) |
| || (partitions[i].GetType() == 0x85)) { |
| // Found it, so call a function to load everything from them.... |
| logicalNum = ReadLogicalParts(partitions[i].GetStartLBA(), abs(logicalNum) + 1); |
| if (logicalNum < 0) { |
| cerr << "Error reading logical partitions! List may be truncated!\n"; |
| } // if maxLogicals valid |
| DeletePartition(i); |
| } // if primary partition is extended |
| } // for primary partition loop |
| if (allOK) { // Loaded logicals OK |
| state = mbr; |
| } else { |
| state = invalid; |
| } // if |
| } // if |
| |
| // Check to see if it's in GPT format.... |
| if (allOK) { |
| for (i = 0; i < 4; i++) { |
| if (partitions[i].GetType() == UINT8_C(0xEE)) { |
| state = gpt; |
| } // if |
| } // for |
| } // if |
| |
| // If there's an EFI GPT partition, look for other partition types, |
| // to flag as hybrid |
| if (state == gpt) { |
| for (i = 0 ; i < 4; i++) { |
| if ((partitions[i].GetType() != UINT8_C(0xEE)) && |
| (partitions[i].GetType() != UINT8_C(0x00))) |
| state = hybrid; |
| if (logicalNum != 3) |
| cerr << "Warning! MBR Logical partitions found on a hybrid MBR disk! This is an\n" |
| << "EXTREMELY dangerous configuration!\n\a"; |
| } // for |
| } // if (hybrid detection code) |
| } // no initial error |
| return allOK; |
| } // BasicMBRData::ReadMBRData(DiskIO * theDisk, int checkBlockSize) |
| |
| // This is a function to read all the logical partitions, following the |
| // logical partition linked list from the disk and storing the basic data in the |
| // partitions[] array. Returns last index to partitions[] used, or -1 times the |
| // that index if there was a problem. (Some problems can leave valid logical |
| // partition data.) |
| // Parameters: |
| // extendedStart = LBA of the start of the extended partition |
| // partNum = number of first partition in extended partition (normally 4). |
| int BasicMBRData::ReadLogicalParts(uint64_t extendedStart, int partNum) { |
| struct TempMBR ebr; |
| int i, another = 1, allOK = 1; |
| uint8_t ebrType; |
| uint64_t offset; |
| uint64_t EbrLocations[MAX_MBR_PARTS]; |
| |
| offset = extendedStart; |
| memset(&EbrLocations, 0, MAX_MBR_PARTS * sizeof(uint64_t)); |
| while (another && (partNum < MAX_MBR_PARTS) && (partNum >= 0) && (allOK > 0)) { |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if (EbrLocations[i] == offset) { // already read this one; infinite logical partition loop! |
| cerr << "Logical partition infinite loop detected! This is being corrected.\n"; |
| allOK = -1; |
| partNum -= 1; |
| } // if |
| } // for |
| EbrLocations[partNum] = offset; |
| if (myDisk->Seek(offset) == 0) { // seek to EBR record |
| cerr << "Unable to seek to " << offset << "! Aborting!\n"; |
| allOK = -1; |
| } |
| if (myDisk->Read(&ebr, 512) != 512) { // Load the data.... |
| cerr << "Error seeking to or reading logical partition data from " << offset |
| << "!\nSome logical partitions may be missing!\n"; |
| allOK = -1; |
| } else if (IsLittleEndian() != 1) { // Reverse byte ordering of some data.... |
| ReverseBytes(&ebr.MBRSignature, 2); |
| ReverseBytes(&ebr.partitions[0].firstLBA, 4); |
| ReverseBytes(&ebr.partitions[0].lengthLBA, 4); |
| ReverseBytes(&ebr.partitions[1].firstLBA, 4); |
| ReverseBytes(&ebr.partitions[1].lengthLBA, 4); |
| } // if/else/if |
| |
| if (ebr.MBRSignature != MBR_SIGNATURE) { |
| allOK = -1; |
| cerr << "EBR signature for logical partition invalid; read 0x"; |
| cerr.fill('0'); |
| cerr.width(4); |
| cerr.setf(ios::uppercase); |
| cerr << hex << ebr.MBRSignature << ", but should be 0x"; |
| cerr.width(4); |
| cerr << MBR_SIGNATURE << dec << "\n"; |
| cerr.fill(' '); |
| } // if |
| |
| if ((partNum >= 0) && (partNum < MAX_MBR_PARTS) && (allOK > 0)) { |
| // Sometimes an EBR points directly to another EBR, rather than defining |
| // a logical partition and then pointing to another EBR. Thus, we skip |
| // the logical partition when this is the case.... |
| ebrType = ebr.partitions[0].partitionType; |
| if ((ebrType == 0x05) || (ebrType == 0x0f) || (ebrType == 0x85)) { |
| cout << "EBR points to an EBR!\n"; |
| offset = extendedStart + ebr.partitions[0].firstLBA; |
| } else { |
| // Copy over the basic data.... |
| partitions[partNum] = ebr.partitions[0]; |
| // Adjust the start LBA, since it's encoded strangely.... |
| partitions[partNum].SetStartLBA(ebr.partitions[0].firstLBA + offset); |
| partitions[partNum].SetInclusion(LOGICAL); |
| |
| // Find the next partition (if there is one) |
| if ((ebr.partitions[1].firstLBA != UINT32_C(0)) && (partNum < (MAX_MBR_PARTS - 1))) { |
| offset = extendedStart + ebr.partitions[1].firstLBA; |
| partNum++; |
| } else { |
| another = 0; |
| } // if another partition |
| } // if/else |
| } // if |
| } // while() |
| return (partNum * allOK); |
| } // BasicMBRData::ReadLogicalPart() |
| |
| // Write the MBR data to the default defined device. This writes both the |
| // MBR itself and any defined logical partitions, provided there's an |
| // MBR extended partition. |
| int BasicMBRData::WriteMBRData(void) { |
| int allOK = 1; |
| |
| if (myDisk != NULL) { |
| if (myDisk->OpenForWrite() != 0) { |
| allOK = WriteMBRData(myDisk); |
| cout << "Done writing data!\n"; |
| } else { |
| allOK = 0; |
| } // if/else |
| myDisk->Close(); |
| } else allOK = 0; |
| return allOK; |
| } // BasicMBRData::WriteMBRData(void) |
| |
| // Save the MBR data to a file. This writes both the |
| // MBR itself and any defined logical partitions. |
| int BasicMBRData::WriteMBRData(DiskIO *theDisk) { |
| int i, j, partNum, next, allOK = 1, moreLogicals = 0; |
| uint64_t extFirstLBA = 0; |
| uint64_t writeEbrTo; // 64-bit because we support extended in 2-4TiB range |
| TempMBR tempMBR; |
| |
| allOK = CreateExtended(); |
| if (allOK) { |
| // First write the main MBR data structure.... |
| memcpy(tempMBR.code, code, 440); |
| tempMBR.diskSignature = diskSignature; |
| tempMBR.nulls = nulls; |
| tempMBR.MBRSignature = MBRSignature; |
| for (i = 0; i < 4; i++) { |
| partitions[i].StoreInStruct(&tempMBR.partitions[i]); |
| if (partitions[i].GetType() == 0x0f) { |
| extFirstLBA = partitions[i].GetStartLBA(); |
| moreLogicals = 1; |
| } // if |
| } // for i... |
| } // if |
| allOK = allOK && WriteMBRData(tempMBR, theDisk, 0); |
| |
| // Set up tempMBR with some constant data for logical partitions... |
| tempMBR.diskSignature = 0; |
| for (i = 2; i < 4; i++) { |
| tempMBR.partitions[i].firstLBA = tempMBR.partitions[i].lengthLBA = 0; |
| tempMBR.partitions[i].partitionType = 0x00; |
| for (j = 0; j < 3; j++) { |
| tempMBR.partitions[i].firstSector[j] = 0; |
| tempMBR.partitions[i].lastSector[j] = 0; |
| } // for j |
| } // for i |
| |
| partNum = FindNextInUse(4); |
| writeEbrTo = (uint64_t) extFirstLBA; |
| // Write logicals... |
| while (allOK && moreLogicals && (partNum < MAX_MBR_PARTS) && (partNum >= 0)) { |
| partitions[partNum].StoreInStruct(&tempMBR.partitions[0]); |
| tempMBR.partitions[0].firstLBA = 1; |
| // tempMBR.partitions[1] points to next EBR or terminates EBR linked list... |
| next = FindNextInUse(partNum + 1); |
| if ((next < MAX_MBR_PARTS) && (next > 0) && (partitions[next].GetStartLBA() > 0)) { |
| tempMBR.partitions[1].partitionType = 0x0f; |
| tempMBR.partitions[1].firstLBA = (uint32_t) (partitions[next].GetStartLBA() - extFirstLBA - 1); |
| tempMBR.partitions[1].lengthLBA = (uint32_t) (partitions[next].GetLengthLBA() + 1); |
| LBAtoCHS((uint64_t) tempMBR.partitions[1].firstLBA, |
| (uint8_t *) &tempMBR.partitions[1].firstSector); |
| LBAtoCHS(tempMBR.partitions[1].lengthLBA - extFirstLBA, |
| (uint8_t *) &tempMBR.partitions[1].lastSector); |
| } else { |
| tempMBR.partitions[1].partitionType = 0x00; |
| tempMBR.partitions[1].firstLBA = 0; |
| tempMBR.partitions[1].lengthLBA = 0; |
| moreLogicals = 0; |
| } // if/else |
| allOK = WriteMBRData(tempMBR, theDisk, writeEbrTo); |
| writeEbrTo = (uint64_t) tempMBR.partitions[1].firstLBA + (uint64_t) extFirstLBA; |
| partNum = next; |
| } // while |
| DeleteExtendedParts(); |
| return allOK; |
| } // BasicMBRData::WriteMBRData(DiskIO *theDisk) |
| |
| int BasicMBRData::WriteMBRData(const string & deviceFilename) { |
| device = deviceFilename; |
| return WriteMBRData(); |
| } // BasicMBRData::WriteMBRData(const string & deviceFilename) |
| |
| // Write a single MBR record to the specified sector. Used by the like-named |
| // function to write both the MBR and multiple EBR (for logical partition) |
| // records. |
| // Returns 1 on success, 0 on failure |
| int BasicMBRData::WriteMBRData(struct TempMBR & mbr, DiskIO *theDisk, uint64_t sector) { |
| int i, allOK; |
| |
| // Reverse the byte order, if necessary |
| if (IsLittleEndian() == 0) { |
| ReverseBytes(&mbr.diskSignature, 4); |
| ReverseBytes(&mbr.nulls, 2); |
| ReverseBytes(&mbr.MBRSignature, 2); |
| for (i = 0; i < 4; i++) { |
| ReverseBytes(&mbr.partitions[i].firstLBA, 4); |
| ReverseBytes(&mbr.partitions[i].lengthLBA, 4); |
| } // for |
| } // if |
| |
| // Now write the data structure... |
| allOK = theDisk->OpenForWrite(); |
| if (allOK && theDisk->Seek(sector)) { |
| if (theDisk->Write(&mbr, 512) != 512) { |
| allOK = 0; |
| cerr << "Error " << errno << " when saving MBR!\n"; |
| } // if |
| } else { |
| allOK = 0; |
| cerr << "Error " << errno << " when seeking to MBR to write it!\n"; |
| } // if/else |
| theDisk->Close(); |
| |
| // Reverse the byte order back, if necessary |
| if (IsLittleEndian() == 0) { |
| ReverseBytes(&mbr.diskSignature, 4); |
| ReverseBytes(&mbr.nulls, 2); |
| ReverseBytes(&mbr.MBRSignature, 2); |
| for (i = 0; i < 4; i++) { |
| ReverseBytes(&mbr.partitions[i].firstLBA, 4); |
| ReverseBytes(&mbr.partitions[i].lengthLBA, 4); |
| } // for |
| }// if |
| return allOK; |
| } // BasicMBRData::WriteMBRData(uint64_t sector) |
| |
| // Set a new disk device; used in copying one disk's partition |
| // table to another disk. |
| void BasicMBRData::SetDisk(DiskIO *theDisk) { |
| int err; |
| |
| myDisk = theDisk; |
| diskSize = theDisk->DiskSize(&err); |
| canDeleteMyDisk = 0; |
| ReadCHSGeom(); |
| } // BasicMBRData::SetDisk() |
| |
| /******************************************** |
| * * |
| * Functions that display data for the user * |
| * * |
| ********************************************/ |
| |
| // Show the MBR data to the user, up to the specified maximum number |
| // of partitions.... |
| void BasicMBRData::DisplayMBRData(void) { |
| int i; |
| |
| cout << "\nDisk size is " << diskSize << " sectors (" |
| << BytesToIeee(diskSize, blockSize) << ")\n"; |
| cout << "MBR disk identifier: 0x"; |
| cout.width(8); |
| cout.fill('0'); |
| cout.setf(ios::uppercase); |
| cout << hex << diskSignature << dec << "\n"; |
| cout << "MBR partitions:\n\n"; |
| if ((state == gpt) || (state == hybrid)) { |
| cout << "Number Boot Start Sector End Sector Status Code\n"; |
| } else { |
| cout << " Can Be Can Be\n"; |
| cout << "Number Boot Start Sector End Sector Status Logical Primary Code\n"; |
| UpdateCanBeLogical(); |
| } // |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if (partitions[i].GetLengthLBA() != 0) { |
| cout.fill(' '); |
| cout.width(4); |
| cout << i + 1 << " "; |
| partitions[i].ShowData((state == gpt) || (state == hybrid)); |
| } // if |
| cout.fill(' '); |
| } // for |
| } // BasicMBRData::DisplayMBRData() |
| |
| // Displays the state, as a word, on stdout. Used for debugging & to |
| // tell the user about the MBR state when the program launches.... |
| void BasicMBRData::ShowState(void) { |
| switch (state) { |
| case invalid: |
| cout << " MBR: not present\n"; |
| break; |
| case gpt: |
| cout << " MBR: protective\n"; |
| break; |
| case hybrid: |
| cout << " MBR: hybrid\n"; |
| break; |
| case mbr: |
| cout << " MBR: MBR only\n"; |
| break; |
| default: |
| cout << "\a MBR: unknown -- bug!\n"; |
| break; |
| } // switch |
| } // BasicMBRData::ShowState() |
| |
| /************************ |
| * * |
| * GPT Checks and fixes * |
| * * |
| ************************/ |
| |
| // Perform a very rudimentary check for GPT data on the disk; searches for |
| // the GPT signature in the main and backup metadata areas. |
| // Returns 0 if GPT data not found, 1 if main data only is found, 2 if |
| // backup only is found, 3 if both main and backup data are found, and |
| // -1 if a disk error occurred. |
| int BasicMBRData::CheckForGPT(void) { |
| int retval = 0, err; |
| char signature1[9], signature2[9]; |
| |
| if (myDisk != NULL) { |
| if (myDisk->OpenForRead() != 0) { |
| if (myDisk->Seek(1)) { |
| myDisk->Read(signature1, 8); |
| signature1[8] = '\0'; |
| } else retval = -1; |
| if (myDisk->Seek(myDisk->DiskSize(&err) - 1)) { |
| myDisk->Read(signature2, 8); |
| signature2[8] = '\0'; |
| } else retval = -1; |
| if ((retval >= 0) && (strcmp(signature1, "EFI PART") == 0)) |
| retval += 1; |
| if ((retval >= 0) && (strcmp(signature2, "EFI PART") == 0)) |
| retval += 2; |
| } else { |
| retval = -1; |
| } // if/else |
| myDisk->Close(); |
| } else retval = -1; |
| return retval; |
| } // BasicMBRData::CheckForGPT() |
| |
| // Blanks the 2nd (sector #1, numbered from 0) and last sectors of the disk, |
| // but only if GPT data are verified on the disk, and only for the sector(s) |
| // with GPT signatures. |
| // Returns 1 if operation completes successfully, 0 if not (returns 1 if |
| // no GPT data are found on the disk). |
| int BasicMBRData::BlankGPTData(void) { |
| int allOK = 1, err; |
| uint8_t blank[512]; |
| |
| memset(blank, 0, 512); |
| switch (CheckForGPT()) { |
| case -1: |
| allOK = 0; |
| break; |
| case 0: |
| break; |
| case 1: |
| if ((myDisk != NULL) && (myDisk->OpenForWrite())) { |
| if (!((myDisk->Seek(1)) && (myDisk->Write(blank, 512) == 512))) |
| allOK = 0; |
| myDisk->Close(); |
| } else allOK = 0; |
| break; |
| case 2: |
| if ((myDisk != NULL) && (myDisk->OpenForWrite())) { |
| if (!((myDisk->Seek(myDisk->DiskSize(&err) - 1)) && |
| (myDisk->Write(blank, 512) == 512))) |
| allOK = 0; |
| myDisk->Close(); |
| } else allOK = 0; |
| break; |
| case 3: |
| if ((myDisk != NULL) && (myDisk->OpenForWrite())) { |
| if (!((myDisk->Seek(1)) && (myDisk->Write(blank, 512) == 512))) |
| allOK = 0; |
| if (!((myDisk->Seek(myDisk->DiskSize(&err) - 1)) && |
| (myDisk->Write(blank, 512) == 512))) |
| allOK = 0; |
| myDisk->Close(); |
| } else allOK = 0; |
| break; |
| default: |
| break; |
| } // switch() |
| return allOK; |
| } // BasicMBRData::BlankGPTData |
| |
| /********************************************************************* |
| * * |
| * Functions that set or get disk metadata (CHS geometry, disk size, * |
| * etc.) * |
| * * |
| *********************************************************************/ |
| |
| // Read the CHS geometry using OS calls, or if that fails, set to |
| // the most common value for big disks (255 heads, 63 sectors per |
| // track, & however many cylinders that computes to). |
| void BasicMBRData::ReadCHSGeom(void) { |
| int err; |
| |
| numHeads = myDisk->GetNumHeads(); |
| numSecspTrack = myDisk->GetNumSecsPerTrack(); |
| diskSize = myDisk->DiskSize(&err); |
| blockSize = myDisk->GetBlockSize(); |
| partitions[0].SetGeometry(numHeads, numSecspTrack, diskSize, blockSize); |
| } // BasicMBRData::ReadCHSGeom() |
| |
| // Find the low and high used partition numbers (numbered from 0). |
| // Return value is the number of partitions found. Note that the |
| // *low and *high values are both set to 0 when no partitions |
| // are found, as well as when a single partition in the first |
| // position exists. Thus, the return value is the only way to |
| // tell when no partitions exist. |
| int BasicMBRData::GetPartRange(uint32_t *low, uint32_t *high) { |
| uint32_t i; |
| int numFound = 0; |
| |
| *low = MAX_MBR_PARTS + 1; // code for "not found" |
| *high = 0; |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if (partitions[i].GetStartLBA() != UINT32_C(0)) { // it exists |
| *high = i; // since we're counting up, set the high value |
| // Set the low value only if it's not yet found... |
| if (*low == (MAX_MBR_PARTS + 1)) |
| *low = i; |
| numFound++; |
| } // if |
| } // for |
| |
| // Above will leave *low pointing to its "not found" value if no partitions |
| // are defined, so reset to 0 if this is the case.... |
| if (*low == (MAX_MBR_PARTS + 1)) |
| *low = 0; |
| return numFound; |
| } // GPTData::GetPartRange() |
| |
| // Converts 64-bit LBA value to MBR-style CHS value. Returns 1 if conversion |
| // was within the range that can be expressed by CHS (including 0, for an |
| // empty partition), 0 if the value is outside that range, and -1 if chs is |
| // invalid. |
| int BasicMBRData::LBAtoCHS(uint64_t lba, uint8_t * chs) { |
| uint64_t cylinder, head, sector; // all numbered from 0 |
| uint64_t remainder; |
| int retval = 1; |
| int done = 0; |
| |
| if (chs != NULL) { |
| // Special case: In case of 0 LBA value, zero out CHS values.... |
| if (lba == 0) { |
| chs[0] = chs[1] = chs[2] = UINT8_C(0); |
| done = 1; |
| } // if |
| // If LBA value is too large for CHS, max out CHS values.... |
| if ((!done) && (lba >= ((uint64_t) numHeads * numSecspTrack * MAX_CYLINDERS))) { |
| chs[0] = 254; |
| chs[1] = chs[2] = 255; |
| done = 1; |
| retval = 0; |
| } // if |
| // If neither of the above applies, compute CHS values.... |
| if (!done) { |
| cylinder = lba / (uint64_t) (numHeads * numSecspTrack); |
| remainder = lba - (cylinder * numHeads * numSecspTrack); |
| head = remainder / numSecspTrack; |
| remainder -= head * numSecspTrack; |
| sector = remainder; |
| if (head < numHeads) |
| chs[0] = (uint8_t) head; |
| else |
| retval = 0; |
| if (sector < numSecspTrack) { |
| chs[1] = (uint8_t) ((sector + 1) + (cylinder >> 8) * 64); |
| chs[2] = (uint8_t) (cylinder & UINT64_C(0xFF)); |
| } else { |
| retval = 0; |
| } // if/else |
| } // if value is expressible and non-0 |
| } else { // Invalid (NULL) chs pointer |
| retval = -1; |
| } // if CHS pointer valid |
| return (retval); |
| } // BasicMBRData::LBAtoCHS() |
| |
| // Look for overlapping partitions. Also looks for a couple of non-error |
| // conditions that the user should be told about. |
| // Returns the number of problems found |
| int BasicMBRData::FindOverlaps(void) { |
| int i, j, numProbs = 0, numEE = 0, ProtectiveOnOne = 0; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| for (j = i + 1; j < MAX_MBR_PARTS; j++) { |
| if ((partitions[i].GetInclusion() != NONE) && (partitions[j].GetInclusion() != NONE) && |
| (partitions[i].DoTheyOverlap(partitions[j]))) { |
| numProbs++; |
| cout << "\nProblem: MBR partitions " << i + 1 << " and " << j + 1 |
| << " overlap!\n"; |
| } // if |
| } // for (j...) |
| if (partitions[i].GetType() == 0xEE) { |
| numEE++; |
| if (partitions[i].GetStartLBA() == 1) |
| ProtectiveOnOne = 1; |
| } // if |
| } // for (i...) |
| |
| if (numEE > 1) |
| cout << "\nCaution: More than one 0xEE MBR partition found. This can cause problems\n" |
| << "in some OSes.\n"; |
| if (!ProtectiveOnOne && (numEE > 0)) |
| cout << "\nWarning: 0xEE partition doesn't start on sector 1. This can cause " |
| << "problems\nin some OSes.\n"; |
| |
| return numProbs; |
| } // BasicMBRData::FindOverlaps() |
| |
| // Returns the number of primary partitions, including the extended partition |
| // required to hold any logical partitions found. |
| int BasicMBRData::NumPrimaries(void) { |
| int i, numPrimaries = 0, logicalsFound = 0; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if (partitions[i].GetLengthLBA() > 0) { |
| if (partitions[i].GetInclusion() == PRIMARY) |
| numPrimaries++; |
| if (partitions[i].GetInclusion() == LOGICAL) |
| logicalsFound = 1; |
| } // if |
| } // for |
| return (numPrimaries + logicalsFound); |
| } // BasicMBRData::NumPrimaries() |
| |
| // Returns the number of logical partitions. |
| int BasicMBRData::NumLogicals(void) { |
| int i, numLogicals = 0; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if (partitions[i].GetInclusion() == LOGICAL) |
| numLogicals++; |
| } // for |
| return numLogicals; |
| } // BasicMBRData::NumLogicals() |
| |
| // Returns the number of partitions (primaries plus logicals), NOT including |
| // the extended partition required to house the logicals. |
| int BasicMBRData::CountParts(void) { |
| int i, num = 0; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if ((partitions[i].GetInclusion() == LOGICAL) || |
| (partitions[i].GetInclusion() == PRIMARY)) |
| num++; |
| } // for |
| return num; |
| } // BasicMBRData::CountParts() |
| |
| // Updates the canBeLogical and canBePrimary flags for all the partitions. |
| void BasicMBRData::UpdateCanBeLogical(void) { |
| int i, j, sectorBefore, numPrimaries, numLogicals, usedAsEBR; |
| uint64_t firstLogical, lastLogical, lStart, pStart; |
| |
| numPrimaries = NumPrimaries(); |
| numLogicals = NumLogicals(); |
| firstLogical = FirstLogicalLBA() - 1; |
| lastLogical = LastLogicalLBA(); |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| usedAsEBR = (SectorUsedAs(partitions[i].GetLastLBA()) == EBR); |
| if (usedAsEBR) { |
| partitions[i].SetCanBeLogical(0); |
| partitions[i].SetCanBePrimary(0); |
| } else if (partitions[i].GetLengthLBA() > 0) { |
| // First determine if it can be logical.... |
| sectorBefore = SectorUsedAs(partitions[i].GetStartLBA() - 1); |
| lStart = partitions[i].GetStartLBA(); // start of potential logical part. |
| if ((lastLogical > 0) && |
| ((sectorBefore == EBR) || (sectorBefore == NONE))) { |
| // Assume it can be logical, then search for primaries that make it |
| // not work and, if found, flag appropriately. |
| partitions[i].SetCanBeLogical(1); |
| for (j = 0; j < MAX_MBR_PARTS; j++) { |
| if ((i != j) && (partitions[j].GetInclusion() == PRIMARY)) { |
| pStart = partitions[j].GetStartLBA(); |
| if (((pStart < lStart) && (firstLogical < pStart)) || |
| ((pStart > lStart) && (firstLogical > pStart))) { |
| partitions[i].SetCanBeLogical(0); |
| } // if/else |
| } // if |
| } // for |
| } else { |
| if ((sectorBefore != EBR) && (sectorBefore != NONE)) |
| partitions[i].SetCanBeLogical(0); |
| else |
| partitions[i].SetCanBeLogical(lastLogical == 0); // can be logical only if no logicals already |
| } // if/else |
| // Now determine if it can be primary. Start by assuming it can be... |
| partitions[i].SetCanBePrimary(1); |
| if ((numPrimaries >= 4) && (partitions[i].GetInclusion() != PRIMARY)) { |
| partitions[i].SetCanBePrimary(0); |
| if ((partitions[i].GetInclusion() == LOGICAL) && (numLogicals == 1) && |
| (numPrimaries == 4)) |
| partitions[i].SetCanBePrimary(1); |
| } // if |
| if ((partitions[i].GetStartLBA() > (firstLogical + 1)) && |
| (partitions[i].GetLastLBA() < lastLogical)) |
| partitions[i].SetCanBePrimary(0); |
| } // else if |
| } // for |
| } // BasicMBRData::UpdateCanBeLogical() |
| |
| // Returns the first sector occupied by any logical partition. Note that |
| // this does NOT include the logical partition's EBR! Returns UINT32_MAX |
| // if there are no logical partitions defined. |
| uint64_t BasicMBRData::FirstLogicalLBA(void) { |
| int i; |
| uint64_t firstFound = UINT32_MAX; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if ((partitions[i].GetInclusion() == LOGICAL) && |
| (partitions[i].GetStartLBA() < firstFound)) { |
| firstFound = partitions[i].GetStartLBA(); |
| } // if |
| } // for |
| return firstFound; |
| } // BasicMBRData::FirstLogicalLBA() |
| |
| // Returns the last sector occupied by any logical partition, or 0 if |
| // there are no logical partitions defined. |
| uint64_t BasicMBRData::LastLogicalLBA(void) { |
| int i; |
| uint64_t lastFound = 0; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if ((partitions[i].GetInclusion() == LOGICAL) && |
| (partitions[i].GetLastLBA() > lastFound)) |
| lastFound = partitions[i].GetLastLBA(); |
| } // for |
| return lastFound; |
| } // BasicMBRData::LastLogicalLBA() |
| |
| // Returns 1 if logical partitions are contiguous (have no primaries |
| // in their midst), or 0 if one or more primaries exist between |
| // logicals. |
| int BasicMBRData::AreLogicalsContiguous(void) { |
| int allOK = 1, i = 0; |
| uint64_t firstLogical, lastLogical; |
| |
| firstLogical = FirstLogicalLBA() - 1; // subtract 1 for EBR |
| lastLogical = LastLogicalLBA(); |
| if (lastLogical > 0) { |
| do { |
| if ((partitions[i].GetInclusion() == PRIMARY) && |
| (partitions[i].GetStartLBA() >= firstLogical) && |
| (partitions[i].GetStartLBA() <= lastLogical)) { |
| allOK = 0; |
| } // if |
| i++; |
| } while ((i < MAX_MBR_PARTS) && allOK); |
| } // if |
| return allOK; |
| } // BasicMBRData::AreLogicalsContiguous() |
| |
| // Returns 1 if all partitions fit on the disk, given its size; 0 if any |
| // partition is too big. |
| int BasicMBRData::DoTheyFit(void) { |
| int i, allOK = 1; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if ((partitions[i].GetStartLBA() > diskSize) || (partitions[i].GetLastLBA() > diskSize)) { |
| allOK = 0; |
| } // if |
| } // for |
| return allOK; |
| } // BasicMBRData::DoTheyFit(void) |
| |
| // Returns 1 if there's at least one free sector immediately preceding |
| // all partitions flagged as logical; 0 if any logical partition lacks |
| // this space. |
| int BasicMBRData::SpaceBeforeAllLogicals(void) { |
| int i = 0, allOK = 1; |
| |
| do { |
| if ((partitions[i].GetStartLBA() > 0) && (partitions[i].GetInclusion() == LOGICAL)) { |
| allOK = allOK && (SectorUsedAs(partitions[i].GetStartLBA() - 1) == EBR); |
| } // if |
| i++; |
| } while (allOK && (i < MAX_MBR_PARTS)); |
| return allOK; |
| } // BasicMBRData::SpaceBeforeAllLogicals() |
| |
| // Returns 1 if the partitions describe a legal layout -- all logicals |
| // are contiguous and have at least one preceding empty sector, |
| // the number of primaries is under 4 (or under 3 if there are any |
| // logicals), there are no overlapping partitions, etc. |
| // Does NOT assume that primaries are numbered 1-4; uses the |
| // IsItPrimary() function of the MBRPart class to determine |
| // primary status. Also does NOT consider partition order; there |
| // can be gaps and it will still be considered legal. |
| int BasicMBRData::IsLegal(void) { |
| int allOK = 1; |
| |
| allOK = (FindOverlaps() == 0); |
| allOK = (allOK && (NumPrimaries() <= 4)); |
| allOK = (allOK && AreLogicalsContiguous()); |
| allOK = (allOK && DoTheyFit()); |
| allOK = (allOK && SpaceBeforeAllLogicals()); |
| return allOK; |
| } // BasicMBRData::IsLegal() |
| |
| // Returns 1 if the 0xEE partition in the protective/hybrid MBR is marked as |
| // active/bootable. |
| int BasicMBRData::IsEEActive(void) { |
| int i, IsActive = 0; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if ((partitions[i].GetStatus() & 0x80) && (partitions[i].GetType() == 0xEE)) |
| IsActive = 1; |
| } |
| return IsActive; |
| } // BasicMBRData::IsEEActive() |
| |
| // Finds the next in-use partition, starting with start (will return start |
| // if it's in use). Returns -1 if no subsequent partition is in use. |
| int BasicMBRData::FindNextInUse(int start) { |
| if (start >= MAX_MBR_PARTS) |
| start = -1; |
| while ((start < MAX_MBR_PARTS) && (start >= 0) && (partitions[start].GetInclusion() == NONE)) |
| start++; |
| if ((start < 0) || (start >= MAX_MBR_PARTS)) |
| start = -1; |
| return start; |
| } // BasicMBRData::FindFirstLogical(); |
| |
| /***************************************************** |
| * * |
| * Functions to create, delete, or change partitions * |
| * * |
| *****************************************************/ |
| |
| // Empty all data. Meant mainly for calling by constructors, but it's also |
| // used by the hybrid MBR functions in the GPTData class. |
| void BasicMBRData::EmptyMBR(int clearBootloader) { |
| int i; |
| |
| // Zero out the boot loader section, the disk signature, and the |
| // 2-byte nulls area only if requested to do so. (This is the |
| // default.) |
| if (clearBootloader == 1) { |
| EmptyBootloader(); |
| } // if |
| |
| // Blank out the partitions |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| partitions[i].Empty(); |
| } // for |
| MBRSignature = MBR_SIGNATURE; |
| state = mbr; |
| } // BasicMBRData::EmptyMBR() |
| |
| // Blank out the boot loader area. Done with the initial MBR-to-GPT |
| // conversion, since MBR boot loaders don't understand GPT, and so |
| // need to be replaced.... |
| void BasicMBRData::EmptyBootloader(void) { |
| int i; |
| |
| for (i = 0; i < 440; i++) |
| code[i] = 0; |
| nulls = 0; |
| } // BasicMBRData::EmptyBootloader |
| |
| // Create a partition of the specified number based on the passed |
| // partition. This function does *NO* error checking, so it's possible |
| // to seriously screw up a partition table using this function! |
| // Note: This function should NOT be used to create the 0xEE partition |
| // in a conventional GPT configuration, since that partition has |
| // specific size requirements that this function won't handle. It may |
| // be used for creating the 0xEE partition(s) in a hybrid MBR, though, |
| // since those toss the rulebook away anyhow.... |
| void BasicMBRData::AddPart(int num, const MBRPart& newPart) { |
| partitions[num] = newPart; |
| } // BasicMBRData::AddPart() |
| |
| // Create a partition of the specified number, starting LBA, and |
| // length. This function does almost no error checking, so it's possible |
| // to seriously screw up a partition table using this function! |
| // Note: This function should NOT be used to create the 0xEE partition |
| // in a conventional GPT configuration, since that partition has |
| // specific size requirements that this function won't handle. It may |
| // be used for creating the 0xEE partition(s) in a hybrid MBR, though, |
| // since those toss the rulebook away anyhow.... |
| void BasicMBRData::MakePart(int num, uint64_t start, uint64_t length, int type, int bootable) { |
| if ((num >= 0) && (num < MAX_MBR_PARTS) && (start <= UINT32_MAX) && (length <= UINT32_MAX)) { |
| partitions[num].Empty(); |
| partitions[num].SetType(type); |
| partitions[num].SetLocation(start, length); |
| if (num < 4) |
| partitions[num].SetInclusion(PRIMARY); |
| else |
| partitions[num].SetInclusion(LOGICAL); |
| SetPartBootable(num, bootable); |
| } // if valid partition number & size |
| } // BasicMBRData::MakePart() |
| |
| // Set the partition's type code. |
| // Returns 1 if successful, 0 if not (invalid partition number) |
| int BasicMBRData::SetPartType(int num, int type) { |
| int allOK = 1; |
| |
| if ((num >= 0) && (num < MAX_MBR_PARTS)) { |
| if (partitions[num].GetLengthLBA() != UINT32_C(0)) { |
| allOK = partitions[num].SetType(type); |
| } else allOK = 0; |
| } else allOK = 0; |
| return allOK; |
| } // BasicMBRData::SetPartType() |
| |
| // Set (or remove) the partition's bootable flag. Setting it is the |
| // default; pass 0 as bootable to remove the flag. |
| // Returns 1 if successful, 0 if not (invalid partition number) |
| int BasicMBRData::SetPartBootable(int num, int bootable) { |
| int allOK = 1; |
| |
| if ((num >= 0) && (num < MAX_MBR_PARTS)) { |
| if (partitions[num].GetLengthLBA() != UINT32_C(0)) { |
| if (bootable == 0) |
| partitions[num].SetStatus(UINT8_C(0x00)); |
| else |
| partitions[num].SetStatus(UINT8_C(0x80)); |
| } else allOK = 0; |
| } else allOK = 0; |
| return allOK; |
| } // BasicMBRData::SetPartBootable() |
| |
| // Create a partition that fills the most available space. Returns |
| // 1 if partition was created, 0 otherwise. Intended for use in |
| // creating hybrid MBRs. |
| int BasicMBRData::MakeBiggestPart(int i, int type) { |
| uint64_t start = UINT64_C(1); // starting point for each search |
| uint64_t firstBlock; // first block in a segment |
| uint64_t lastBlock; // last block in a segment |
| uint64_t segmentSize; // size of segment in blocks |
| uint64_t selectedSegment = UINT64_C(0); // location of largest segment |
| uint64_t selectedSize = UINT64_C(0); // size of largest segment in blocks |
| int found = 0; |
| string anything; |
| |
| do { |
| firstBlock = FindFirstAvailable(start); |
| if (firstBlock > UINT64_C(0)) { // something's free... |
| lastBlock = FindLastInFree(firstBlock); |
| segmentSize = lastBlock - firstBlock + UINT64_C(1); |
| if (segmentSize > selectedSize) { |
| selectedSize = segmentSize; |
| selectedSegment = firstBlock; |
| } // if |
| start = lastBlock + 1; |
| } // if |
| } while (firstBlock != 0); |
| if ((selectedSize > UINT64_C(0)) && (selectedSize < diskSize)) { |
| found = 1; |
| MakePart(i, selectedSegment, selectedSize, type, 0); |
| } else { |
| found = 0; |
| } // if/else |
| return found; |
| } // BasicMBRData::MakeBiggestPart(int i) |
| |
| // Delete partition #i |
| void BasicMBRData::DeletePartition(int i) { |
| partitions[i].Empty(); |
| } // BasicMBRData::DeletePartition() |
| |
| // Set the inclusion status (PRIMARY, LOGICAL, or NONE) with some sanity |
| // checks to ensure the table remains legal. |
| // Returns 1 on success, 0 on failure. |
| int BasicMBRData::SetInclusionwChecks(int num, int inclStatus) { |
| int allOK = 1, origValue; |
| |
| if (IsLegal()) { |
| if ((inclStatus == PRIMARY) || (inclStatus == LOGICAL) || (inclStatus == NONE)) { |
| origValue = partitions[num].GetInclusion(); |
| partitions[num].SetInclusion(inclStatus); |
| if (!IsLegal()) { |
| partitions[num].SetInclusion(origValue); |
| cerr << "Specified change is not legal! Aborting change!\n"; |
| } // if |
| } else { |
| cerr << "Invalid partition inclusion code in BasicMBRData::SetInclusionwChecks()!\n"; |
| } // if/else |
| } else { |
| cerr << "Partition table is not currently in a valid state. Aborting change!\n"; |
| allOK = 0; |
| } // if/else |
| return allOK; |
| } // BasicMBRData::SetInclusionwChecks() |
| |
| // Recomputes the CHS values for the specified partition and adjusts the value. |
| // Note that this will create a technically incorrect CHS value for EFI GPT (0xEE) |
| // protective partitions, but this is required by some buggy BIOSes, so I'm |
| // providing a function to do this deliberately at the user's command. |
| // This function does nothing if the partition's length is 0. |
| void BasicMBRData::RecomputeCHS(int partNum) { |
| partitions[partNum].RecomputeCHS(); |
| } // BasicMBRData::RecomputeCHS() |
| |
| // Sorts the partitions starting with partition #start. This function |
| // does NOT pay attention to primary/logical assignment, which is |
| // critical when writing the partitions. |
| void BasicMBRData::SortMBR(int start) { |
| if ((start < MAX_MBR_PARTS) && (start >= 0)) |
| sort(partitions + start, partitions + MAX_MBR_PARTS); |
| } // BasicMBRData::SortMBR() |
| |
| // Delete any partitions that are too big to fit on the disk |
| // or that are too big for MBR (32-bit limits). |
| // This deletes the partitions by setting values to 0, not just |
| // by setting them as being omitted. |
| // Returns the number of partitions deleted in this way. |
| int BasicMBRData::DeleteOversizedParts() { |
| int num = 0, i; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if ((partitions[i].GetStartLBA() > diskSize) || (partitions[i].GetLastLBA() > diskSize) || |
| (partitions[i].GetStartLBA() > UINT32_MAX) || (partitions[i].GetLengthLBA() > UINT32_MAX)) { |
| cerr << "\aWarning: Deleting oversized partition #" << i + 1 << "! Start = " |
| << partitions[i].GetStartLBA() << ", length = " << partitions[i].GetLengthLBA() << "\n"; |
| partitions[i].Empty(); |
| num++; |
| } // if |
| } // for |
| return num; |
| } // BasicMBRData::DeleteOversizedParts() |
| |
| // Search for and delete extended partitions. |
| // Returns the number of partitions deleted. |
| int BasicMBRData::DeleteExtendedParts() { |
| int i, numDeleted = 0; |
| uint8_t type; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| type = partitions[i].GetType(); |
| if (((type == 0x05) || (type == 0x0f) || (type == (0x85))) && |
| (partitions[i].GetLengthLBA() > 0)) { |
| partitions[i].Empty(); |
| numDeleted++; |
| } // if |
| } // for |
| return numDeleted; |
| } // BasicMBRData::DeleteExtendedParts() |
| |
| // Finds any overlapping partitions and omits the smaller of the two. |
| void BasicMBRData::OmitOverlaps() { |
| int i, j; |
| |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| for (j = i + 1; j < MAX_MBR_PARTS; j++) { |
| if ((partitions[i].GetInclusion() != NONE) && |
| partitions[i].DoTheyOverlap(partitions[j])) { |
| if (partitions[i].GetLengthLBA() < partitions[j].GetLengthLBA()) |
| partitions[i].SetInclusion(NONE); |
| else |
| partitions[j].SetInclusion(NONE); |
| } // if |
| } // for (j...) |
| } // for (i...) |
| } // BasicMBRData::OmitOverlaps() |
| |
| // Convert as many partitions into logicals as possible, except for |
| // the first partition, if possible. |
| void BasicMBRData::MaximizeLogicals() { |
| int earliestPart = 0, earliestPartWas = NONE, i; |
| |
| for (i = MAX_MBR_PARTS - 1; i >= 0; i--) { |
| UpdateCanBeLogical(); |
| earliestPart = i; |
| if (partitions[i].CanBeLogical()) { |
| partitions[i].SetInclusion(LOGICAL); |
| } else if (partitions[i].CanBePrimary()) { |
| partitions[i].SetInclusion(PRIMARY); |
| } else { |
| partitions[i].SetInclusion(NONE); |
| } // if/elseif/else |
| } // for |
| // If we have spare primaries, convert back the earliest partition to |
| // its original state.... |
| if ((NumPrimaries() < 4) && (partitions[earliestPart].GetInclusion() == LOGICAL)) |
| partitions[earliestPart].SetInclusion(earliestPartWas); |
| } // BasicMBRData::MaximizeLogicals() |
| |
| // Add primaries up to the maximum allowed, from the omitted category. |
| void BasicMBRData::MaximizePrimaries() { |
| int num, i = 0; |
| |
| num = NumPrimaries(); |
| while ((num < 4) && (i < MAX_MBR_PARTS)) { |
| if ((partitions[i].GetInclusion() == NONE) && (partitions[i].CanBePrimary())) { |
| partitions[i].SetInclusion(PRIMARY); |
| num++; |
| UpdateCanBeLogical(); |
| } // if |
| i++; |
| } // while |
| } // BasicMBRData::MaximizePrimaries() |
| |
| // Remove primary partitions in excess of 4, starting with the later ones, |
| // in terms of the array location.... |
| void BasicMBRData::TrimPrimaries(void) { |
| int numToDelete, i = MAX_MBR_PARTS - 1; |
| |
| numToDelete = NumPrimaries() - 4; |
| while ((numToDelete > 0) && (i >= 0)) { |
| if (partitions[i].GetInclusion() == PRIMARY) { |
| partitions[i].SetInclusion(NONE); |
| numToDelete--; |
| } // if |
| i--; |
| } // while (numToDelete > 0) |
| } // BasicMBRData::TrimPrimaries() |
| |
| // Locates primary partitions located between logical partitions and |
| // either converts the primaries into logicals (if possible) or omits |
| // them. |
| void BasicMBRData::MakeLogicalsContiguous(void) { |
| uint64_t firstLogicalLBA, lastLogicalLBA; |
| int i; |
| |
| firstLogicalLBA = FirstLogicalLBA(); |
| lastLogicalLBA = LastLogicalLBA(); |
| for (i = 0; i < MAX_MBR_PARTS; i++) { |
| if ((partitions[i].GetInclusion() == PRIMARY) && |
| (partitions[i].GetStartLBA() >= firstLogicalLBA) && |
| (partitions[i].GetLastLBA() <= lastLogicalLBA)) { |
| if (SectorUsedAs(partitions[i].GetStartLBA() - 1) == NONE) |
| partitions[i].SetInclusion(LOGICAL); |
| else |
| partitions[i].SetInclusion(NONE); |
| } // if |
| } // for |
| } // BasicMBRData::MakeLogicalsContiguous() |
| |
| // If MBR data aren't legal, adjust primary/logical assignments and, |
| // if necessary, drop partitions, to make the data legal. |
| void BasicMBRData::MakeItLegal(void) { |
| if (!IsLegal()) { |
| DeleteOversizedParts(); |
| MaximizeLogicals(); |
| MaximizePrimaries(); |
| if (!AreLogicalsContiguous()) |
| MakeLogicalsContiguous(); |
| if (NumPrimaries() > 4) |
| TrimPrimaries(); |
| OmitOverlaps(); |
| } // if |
| } // BasicMBRData::MakeItLegal() |
| |
| // Removes logical partitions and deactivated partitions from first four |
| // entries (primary space). |
| // Returns the number of partitions moved. |
| int BasicMBRData::RemoveLogicalsFromFirstFour(void) { |
| int i, j = 4, numMoved = 0, swapped = 0; |
| MBRPart temp; |
| |
| for (i = 0; i < 4; i++) { |
| if ((partitions[i].GetInclusion() != PRIMARY) && (partitions[i].GetLengthLBA() > 0)) { |
| j = 4; |
| swapped = 0; |
| do { |
| if ((partitions[j].GetInclusion() == NONE) && (partitions[j].GetLengthLBA() == 0)) { |
| temp = partitions[j]; |
| partitions[j] = partitions[i]; |
| partitions[i] = temp; |
| swapped = 1; |
| numMoved++; |
| } // if |
| j++; |
| } while ((j < MAX_MBR_PARTS) && !swapped); |
| if (j >= MAX_MBR_PARTS) |
| cerr << "Warning! Too many partitions in BasicMBRData::RemoveLogicalsFromFirstFour()!\n"; |
| } // if |
| } // for i... |
| return numMoved; |
| } // BasicMBRData::RemoveLogicalsFromFirstFour() |
| |
| // Move all primaries into the first four partition spaces |
| // Returns the number of partitions moved. |
| int BasicMBRData::MovePrimariesToFirstFour(void) { |
| int i, j = 0, numMoved = 0, swapped = 0; |
| MBRPart temp; |
| |
| for (i = 4; i < MAX_MBR_PARTS; i++) { |
| if (partitions[i].GetInclusion() == PRIMARY) { |
| j = 0; |
| swapped = 0; |
| do { |
| if (partitions[j].GetInclusion() != PRIMARY) { |
| temp = partitions[j]; |
| partitions[j] = partitions[i]; |
| partitions[i] = temp; |
| swapped = 1; |
| numMoved++; |
| } // if |
| j++; |
| } while ((j < 4) && !swapped); |
| } // if |
| } // for |
| return numMoved; |
| } // BasicMBRData::MovePrimariesToFirstFour() |
| |
| // Create an extended partition, if necessary, to hold the logical partitions. |
| // This function also sorts the primaries into the first four positions of |
| // the table. |
| // Returns 1 on success, 0 on failure. |
| int BasicMBRData::CreateExtended(void) { |
| int allOK = 1, i = 0, swapped = 0; |
| MBRPart temp; |
| |
| if (IsLegal()) { |
| // Move logicals out of primary space... |
| RemoveLogicalsFromFirstFour(); |
| // Move primaries out of logical space... |
| MovePrimariesToFirstFour(); |
| |
| // Create the extended partition |
| if (NumLogicals() > 0) { |
| SortMBR(4); // sort starting from 4 -- that is, logicals only |
| temp.Empty(); |
| temp.SetStartLBA(FirstLogicalLBA() - 1); |
| temp.SetLengthLBA(LastLogicalLBA() - FirstLogicalLBA() + 2); |
| temp.SetType(0x0f, 1); |
| temp.SetInclusion(PRIMARY); |
| do { |
| if ((partitions[i].GetInclusion() == NONE) || (partitions[i].GetLengthLBA() == 0)) { |
| partitions[i] = temp; |
| swapped = 1; |
| } // if |
| i++; |
| } while ((i < 4) && !swapped); |
| if (!swapped) { |
| cerr << "Could not create extended partition; no room in primary table!\n"; |
| allOK = 0; |
| } // if |
| } // if (NumLogicals() > 0) |
| } else allOK = 0; |
| // Do a final check for EFI GPT (0xEE) partitions & flag as a problem if found |
| // along with an extended partition |
| for (i = 0; i < MAX_MBR_PARTS; i++) |
| if (swapped && partitions[i].GetType() == 0xEE) |
| allOK = 0; |
| return allOK; |
| } // BasicMBRData::CreateExtended() |
| |
| /**************************************** |
| * * |
| * Functions to find data on free space * |
| * * |
| ****************************************/ |
| |
| // Finds the first free space on the disk from start onward; returns 0 |
| // if none available.... |
| uint64_t BasicMBRData::FindFirstAvailable(uint64_t start) { |
| uint64_t first; |
| uint64_t i; |
| int firstMoved; |
| |
| if ((start >= (UINT32_MAX - 1)) || (start >= (diskSize - 1))) |
| return 0; |
| |
| first = start; |
| |
| // ...now search through all partitions; if first is within an |
| // existing partition, move it to the next sector after that |
| // partition and repeat. If first was moved, set firstMoved |
| // flag; repeat until firstMoved is not set, so as to catch |
| // cases where partitions are out of sequential order.... |
| do { |
| firstMoved = 0; |
| for (i = 0; i < 4; i++) { |
| // Check if it's in the existing partition |
| if ((first >= partitions[i].GetStartLBA()) && |
| (first < (partitions[i].GetStartLBA() + partitions[i].GetLengthLBA()))) { |
| first = partitions[i].GetStartLBA() + partitions[i].GetLengthLBA(); |
| firstMoved = 1; |
| } // if |
| } // for |
| } while (firstMoved == 1); |
| if ((first >= diskSize) || (first > UINT32_MAX)) |
| first = 0; |
| return (first); |
| } // BasicMBRData::FindFirstAvailable() |
| |
| // Finds the last free sector on the disk from start forward. |
| uint64_t BasicMBRData::FindLastInFree(uint64_t start) { |
| uint64_t nearestStart; |
| uint64_t i; |
| |
| if ((diskSize <= UINT32_MAX) && (diskSize > 0)) |
| nearestStart = diskSize - 1; |
| else |
| nearestStart = UINT32_MAX - 1; |
| |
| for (i = 0; i < 4; i++) { |
| if ((nearestStart > partitions[i].GetStartLBA()) && |
| (partitions[i].GetStartLBA() > start)) { |
| nearestStart = partitions[i].GetStartLBA() - 1; |
| } // if |
| } // for |
| return (nearestStart); |
| } // BasicMBRData::FindLastInFree() |
| |
| // Finds the first free sector on the disk from start backward. |
| uint64_t BasicMBRData::FindFirstInFree(uint64_t start) { |
| uint64_t bestLastLBA, thisLastLBA; |
| int i; |
| |
| bestLastLBA = 1; |
| for (i = 0; i < 4; i++) { |
| thisLastLBA = partitions[i].GetLastLBA() + 1; |
| if (thisLastLBA > 0) |
| thisLastLBA--; |
| if ((thisLastLBA > bestLastLBA) && (thisLastLBA < start)) |
| bestLastLBA = thisLastLBA + 1; |
| } // for |
| return (bestLastLBA); |
| } // BasicMBRData::FindFirstInFree() |
| |
| // Returns NONE (unused), PRIMARY, LOGICAL, EBR (for EBR or MBR), or INVALID. |
| // Note: If the sector immediately before a logical partition is in use by |
| // another partition, this function returns PRIMARY or LOGICAL for that |
| // sector, rather than EBR. |
| int BasicMBRData::SectorUsedAs(uint64_t sector, int topPartNum) { |
| int i = 0, usedAs = NONE; |
| |
| do { |
| if ((partitions[i].GetStartLBA() <= sector) && (partitions[i].GetLastLBA() >= sector)) |
| usedAs = partitions[i].GetInclusion(); |
| if ((partitions[i].GetStartLBA() == (sector + 1)) && (partitions[i].GetInclusion() == LOGICAL)) |
| usedAs = EBR; |
| if (sector == 0) |
| usedAs = EBR; |
| if (sector >= diskSize) |
| usedAs = INVALID; |
| i++; |
| } while ((i < topPartNum) && ((usedAs == NONE) || (usedAs == EBR))); |
| return usedAs; |
| } // BasicMBRData::SectorUsedAs() |
| |
| /****************************************************** |
| * * |
| * Functions that extract data on specific partitions * |
| * * |
| ******************************************************/ |
| |
| uint8_t BasicMBRData::GetStatus(int i) { |
| MBRPart* thePart; |
| uint8_t retval; |
| |
| thePart = GetPartition(i); |
| if (thePart != NULL) |
| retval = thePart->GetStatus(); |
| else |
| retval = UINT8_C(0); |
| return retval; |
| } // BasicMBRData::GetStatus() |
| |
| uint8_t BasicMBRData::GetType(int i) { |
| MBRPart* thePart; |
| uint8_t retval; |
| |
| thePart = GetPartition(i); |
| if (thePart != NULL) |
| retval = thePart->GetType(); |
| else |
| retval = UINT8_C(0); |
| return retval; |
| } // BasicMBRData::GetType() |
| |
| uint64_t BasicMBRData::GetFirstSector(int i) { |
| MBRPart* thePart; |
| uint64_t retval; |
| |
| thePart = GetPartition(i); |
| if (thePart != NULL) { |
| retval = thePart->GetStartLBA(); |
| } else |
| retval = UINT32_C(0); |
| return retval; |
| } // BasicMBRData::GetFirstSector() |
| |
| uint64_t BasicMBRData::GetLength(int i) { |
| MBRPart* thePart; |
| uint64_t retval; |
| |
| thePart = GetPartition(i); |
| if (thePart != NULL) { |
| retval = thePart->GetLengthLBA(); |
| } else |
| retval = UINT64_C(0); |
| return retval; |
| } // BasicMBRData::GetLength() |
| |
| /*********************** |
| * * |
| * Protected functions * |
| * * |
| ***********************/ |
| |
| // Return a pointer to a primary or logical partition, or NULL if |
| // the partition is out of range.... |
| MBRPart* BasicMBRData::GetPartition(int i) { |
| MBRPart* thePart = NULL; |
| |
| if ((i >= 0) && (i < MAX_MBR_PARTS)) |
| thePart = &partitions[i]; |
| return thePart; |
| } // GetPartition() |
| |
| /******************************************* |
| * * |
| * Functions that involve user interaction * |
| * * |
| *******************************************/ |
| |
| // Present the MBR operations menu. Note that the 'w' option does not |
| // immediately write data; that's handled by the calling function. |
| // Returns the number of partitions defined on exit, or -1 if the |
| // user selected the 'q' option. (Thus, the caller should save data |
| // if the return value is >0, or possibly >=0 depending on intentions.) |
| int BasicMBRData::DoMenu(const string& prompt) { |
| int goOn = 1, quitting = 0, retval, num, haveShownInfo = 0; |
| unsigned int hexCode; |
| string tempStr; |
| |
| do { |
| cout << prompt; |
| switch (ReadString()[0]) { |
| case '\0': |
| goOn = cin.good(); |
| break; |
| case 'a': case 'A': |
| num = GetNumber(1, MAX_MBR_PARTS, 1, "Toggle active flag for partition: ") - 1; |
| if (partitions[num].GetInclusion() != NONE) |
| partitions[num].SetStatus(partitions[num].GetStatus() ^ 0x80); |
| break; |
| case 'c': case 'C': |
| for (num = 0; num < MAX_MBR_PARTS; num++) |
| RecomputeCHS(num); |
| break; |
| case 'l': case 'L': |
| num = GetNumber(1, MAX_MBR_PARTS, 1, "Partition to set as logical: ") - 1; |
| SetInclusionwChecks(num, LOGICAL); |
| break; |
| case 'o': case 'O': |
| num = GetNumber(1, MAX_MBR_PARTS, 1, "Partition to omit: ") - 1; |
| SetInclusionwChecks(num, NONE); |
| break; |
| case 'p': case 'P': |
| if (!haveShownInfo) { |
| cout << "\n** NOTE: Partition numbers do NOT indicate final primary/logical " |
| << "status,\n** unlike in most MBR partitioning tools!\n\a"; |
| cout << "\n** Extended partitions are not displayed, but will be generated " |
| << "as required.\n"; |
| haveShownInfo = 1; |
| } // if |
| DisplayMBRData(); |
| break; |
| case 'q': case 'Q': |
| cout << "This will abandon your changes. Are you sure? "; |
| if (GetYN() == 'Y') { |
| goOn = 0; |
| quitting = 1; |
| } // if |
| break; |
| case 'r': case 'R': |
| num = GetNumber(1, MAX_MBR_PARTS, 1, "Partition to set as primary: ") - 1; |
| SetInclusionwChecks(num, PRIMARY); |
| break; |
| case 's': case 'S': |
| SortMBR(); |
| break; |
| case 't': case 'T': |
| num = GetNumber(1, MAX_MBR_PARTS, 1, "Partition to change type code: ") - 1; |
| hexCode = 0x00; |
| if (partitions[num].GetLengthLBA() > 0) { |
| while ((hexCode <= 0) || (hexCode > 255)) { |
| cout << "Enter an MBR hex code: "; |
| tempStr = ReadString(); |
| if (IsHex(tempStr)) |
| sscanf(tempStr.c_str(), "%x", &hexCode); |
| } // while |
| partitions[num].SetType(hexCode); |
| } // if |
| break; |
| case 'w': case 'W': |
| goOn = 0; |
| break; |
| default: |
| ShowCommands(); |
| break; |
| } // switch |
| } while (goOn); |
| if (quitting) |
| retval = -1; |
| else |
| retval = CountParts(); |
| return (retval); |
| } // BasicMBRData::DoMenu() |
| |
| void BasicMBRData::ShowCommands(void) { |
| cout << "a\ttoggle the active/boot flag\n"; |
| cout << "c\trecompute all CHS values\n"; |
| cout << "l\tset partition as logical\n"; |
| cout << "o\tomit partition\n"; |
| cout << "p\tprint the MBR partition table\n"; |
| cout << "q\tquit without saving changes\n"; |
| cout << "r\tset partition as primary\n"; |
| cout << "s\tsort MBR partitions\n"; |
| cout << "t\tchange partition type code\n"; |
| cout << "w\twrite the MBR partition table to disk and exit\n"; |
| } // BasicMBRData::ShowCommands() |
