mbrpart.cc

   1 /*
   2     MBRPart class, part of GPT fdisk program family.
   3     Copyright (C) 2011  Roderick W. Smith
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #define __STDC_LIMIT_MACROS
  21 #define __STDC_CONSTANT_MACROS
  22
  23 #include <stddef.h>
  24 #include <stdint.h>
  25 #include <iostream>
  26 #include "support.h"
  27 #include "mbrpart.h"
  28
  29 using namespace std;
  30
  31 uint32_t MBRPart::numHeads = MAX_HEADS;
  32 uint32_t MBRPart::numSecspTrack = MAX_SECSPERTRACK;
  33 uint64_t MBRPart::diskSize = 0;
  34 uint32_t MBRPart::blockSize = 512;
  35 int MBRPart::numInstances = 0;
  36
  37 MBRPart::MBRPart() {
  38    int i;
  39
  40    status = 0;
  41    for (i = 0; i < 3; i++) {
  42       firstSector[i] = 0;
  43       lastSector[i] = 0;
  44    } // for
  45    partitionType = 0x00;
  46    firstLBA = 0;
  47    lengthLBA = 0;
  48    includeAs = NONE;
  49    canBePrimary = 0;
  50    canBeLogical = 0;
  51    if (numInstances == 0) {
  52       numHeads = MAX_HEADS;
  53       numSecspTrack = MAX_SECSPERTRACK;
  54       diskSize = 0;
  55       blockSize = 512;
  56    } // if
  57    numInstances++;
  58 }
  59
  60 MBRPart::MBRPart(const MBRPart& orig) {
  61    numInstances++;
  62    operator=(orig);
  63 }
  64
  65 MBRPart::~MBRPart() {
  66    numInstances--;
  67 }
  68
  69 MBRPart& MBRPart::operator=(const MBRPart& orig) {
  70    int i;
  71
  72    status = orig.status;
  73    for (i = 0; i < 3; i++) {
  74       firstSector[i] = orig.firstSector[i];
  75       lastSector[i] = orig.lastSector[i];
  76    } // for
  77    partitionType = orig.partitionType;
  78    firstLBA = orig.firstLBA;
  79    lengthLBA = orig.lengthLBA;
  80    includeAs = orig.includeAs;
  81    canBePrimary = orig.canBePrimary;
  82    canBeLogical = orig.canBeLogical;
  83    return *this;
  84 } // MBRPart::operator=(const MBRPart& orig)
  85
  86 // Set partition data from packed MBRRecord structure.
  87 MBRPart& MBRPart::operator=(const struct MBRRecord& orig) {
  88    int i;
  89
  90    status = orig.status;
  91    for (i = 0; i < 3; i++) {
  92       firstSector[i] = orig.firstSector[i];
  93       lastSector[i] = orig.lastSector[i];
  94    } // for
  95    partitionType = orig.partitionType;
  96    firstLBA = orig.firstLBA;
  97    lengthLBA = orig.lengthLBA;
  98    if (lengthLBA > 0)
  99       includeAs = PRIMARY;
 100    else
 101       includeAs = NONE;
 102    return *this;
 103 } // MBRPart::operator=(const struct MBRRecord& orig)
 104
 105 // Compare the values, and return a bool result.
 106 // Because this is intended for sorting and a lengthLBA value of 0 denotes
 107 // a partition that's not in use and so that should be sorted upwards,
 108 // we return the opposite of the usual arithmetic result when either
 109 // lengthLBA value is 0.
 110 bool MBRPart::operator<(const MBRPart &other) const {
 111    if (lengthLBA && other.lengthLBA)
 112       return (firstLBA < other.firstLBA);
 113    else
 114       return (other.firstLBA < firstLBA);
 115 } // operator<()
 116
 117 /**************************************************
 118  *                                                *
 119  * Set information on partitions or disks without *
 120  * interacting with the user....                  *
 121  *                                                *
 122  **************************************************/
 123
 124 void MBRPart::SetGeometry(uint32_t heads, uint32_t sectors, uint64_t ds, uint32_t bs) {
 125    numHeads = heads;
 126    numSecspTrack = sectors;
 127    diskSize = ds;
 128    blockSize = bs;
 129 } // MBRPart::SetGeometry
 130
 131 // Empty the partition (zero out all values).
 132 void MBRPart::Empty(void) {
 133    status = UINT8_C(0);
 134    firstSector[0] = UINT8_C(0);
 135    firstSector[1] = UINT8_C(0);
 136    firstSector[2] = UINT8_C(0);
 137    partitionType = UINT8_C(0);
 138    lastSector[0] = UINT8_C(0);
 139    lastSector[1] = UINT8_C(0);
 140    lastSector[2] = UINT8_C(0);
 141    firstLBA = UINT32_C(0);
 142    lengthLBA = UINT32_C(0);
 143    includeAs = NONE;
 144 } // MBRPart::Empty()
 145
 146 // Sets the type code, but silently refuses to change it to an extended type
 147 // code.
 148 // Returns 1 on success, 0 on failure (extended type code)
 149 int MBRPart::SetType(uint8_t typeCode, int isExtended) {
 150    int allOK = 0;
 151
 152    if ((isExtended == 1) || ((typeCode != 0x05) && (typeCode != 0x0f) && (typeCode != 0x85))) {
 153       partitionType = typeCode;
 154       allOK = 1;
 155    } // if
 156    return allOK;
 157 } // MBRPart::SetType()
 158
 159 void MBRPart::SetStartLBA(uint64_t start) {
 160    if (start > UINT32_MAX)
 161       cerr << "Partition start out of range! Continuing, but problems now likely!\n";
 162    firstLBA = (uint32_t) start;
 163    RecomputeCHS();
 164 } // MBRPart::SetStartLBA()
 165
 166 void MBRPart::SetLengthLBA(uint64_t length) {
 167    if (length > UINT32_MAX)
 168       cerr << "Partition length out of range! Continuing, but problems now likely!\n";
 169    lengthLBA = (uint32_t) length;
 170    RecomputeCHS();
 171 } // MBRPart::SetLengthLBA()
 172
 173 // Set the start point and length of the partition. This function takes LBA
 174 // values, sets them directly, and sets the CHS values based on the LBA
 175 // values and the current geometry settings.
 176 void MBRPart::SetLocation(uint64_t start, uint64_t length) {
 177    int validCHS;
 178
 179    if ((start > UINT32_MAX) || (length > UINT32_MAX)) {
 180       cerr << "Partition values out of range in MBRPart::SetLocation()!\n"
 181            << "Continuing, but strange problems are now likely!\n";
 182    } // if
 183    firstLBA = (uint32_t) start;
 184    lengthLBA = (uint32_t) length;
 185    validCHS = RecomputeCHS();
 186
 187    // If this is a complete 0xEE protective MBR partition, max out its
 188    // CHS last sector value, as per the GPT spec. (Set to 0xffffff,
 189    // although the maximum legal MBR value is 0xfeffff, which is
 190    // actually what GNU Parted and Apple's Disk Utility use, in
 191    // violation of the GPT spec.)
 192    if ((partitionType == 0xEE) && (!validCHS) && (firstLBA == 1) &&
 193        ((lengthLBA == diskSize - 1) || (lengthLBA == UINT32_MAX))) {
 194       lastSector[0] = lastSector[1] = lastSector[2] = 0xFF;
 195    } // if
 196 } // MBRPart::SetLocation()
 197
 198 // Store the MBR data in the packed structure used for disk I/O...
 199 void MBRPart::StoreInStruct(MBRRecord* theStruct) {
 200    int i;
 201
 202    theStruct->firstLBA = firstLBA;
 203    theStruct->lengthLBA = lengthLBA;
 204    theStruct->partitionType = partitionType;
 205    theStruct->status = status;
 206    for (i = 0; i < 3; i++) {
 207       theStruct->firstSector[i] = firstSector[i];
 208       theStruct->lastSector[i] = lastSector[i];
 209    } // for
 210 } // MBRPart::StoreInStruct()
 211
 212 /**********************************************
 213 *                                            *
 214 * Get information on partitions or disks.... *
 215 *                                            *
 216 **********************************************/
 217
 218 // Returns the last LBA value. Note that this can theoretically be a 33-bit
 219 // value, so we return a 64-bit value. If lengthLBA == 0, returns 0, even if
 220 // firstLBA is non-0.
 221 uint64_t MBRPart::GetLastLBA(void) const {
 222    if (lengthLBA > 0)
 223       return (uint64_t) firstLBA + (uint64_t) lengthLBA - UINT64_C(1);
 224    else
 225       return 0;
 226 } // MBRPart::GetLastLBA()
 227
 228 // Returns 1 if other overlaps with the current partition, 0 if they don't
 229 // overlap
 230 int MBRPart::DoTheyOverlap (const MBRPart& other) {
 231    return lengthLBA && other.lengthLBA &&
 232           (firstLBA <= other.GetLastLBA()) != (GetLastLBA() < other.firstLBA);
 233 } // MBRPart::DoTheyOverlap()
 234
 235 /*************************************************
 236  *                                               *
 237  * Adjust information on partitions or disks.... *
 238  *                                               *
 239  *************************************************/
 240
 241 // Recompute the CHS values for the start and end points.
 242 // Returns 1 if both computed values are within the range
 243 // that can be expressed by that CHS, 0 otherwise.
 244 int MBRPart::RecomputeCHS(void) {
 245    int retval = 1;
 246
 247    if (lengthLBA > 0) {
 248       retval = LBAtoCHS(firstLBA, firstSector);
 249       retval *= LBAtoCHS(firstLBA + lengthLBA - 1, lastSector);
 250    } // if
 251    return retval;
 252 } // MBRPart::RecomputeCHS()
 253
 254 // Converts 32-bit LBA value to MBR-style CHS value. Returns 1 if conversion
 255 // was within the range that can be expressed by CHS (including 0, for an
 256 // empty partition), 0 if the value is outside that range, and -1 if chs is
 257 // invalid.
 258 int MBRPart::LBAtoCHS(uint32_t lba, uint8_t * chs) {
 259    uint64_t cylinder, head, sector; // all numbered from 0
 260    uint64_t remainder;
 261    int retval = 1;
 262    int done = 0;
 263
 264    if (chs != NULL) {
 265       // Special case: In case of 0 LBA value, zero out CHS values....
 266       if (lba == 0) {
 267          chs[0] = chs[1] = chs[2] = UINT8_C(0);
 268          done = 1;
 269       } // if
 270       // If LBA value is too large for CHS, max out CHS values....
 271       if ((!done) && (lba >= (numHeads * numSecspTrack * MAX_CYLINDERS))) {
 272          chs[0] = 254;
 273          chs[1] = chs[2] = 255;
 274          done = 1;
 275          retval = 0;
 276       } // if
 277       // If neither of the above applies, compute CHS values....
 278       if (!done) {
 279          cylinder = lba / (numHeads * numSecspTrack);
 280          remainder = lba - (cylinder * numHeads * numSecspTrack);
 281          head = remainder / numSecspTrack;
 282          remainder -= head * numSecspTrack;
 283          sector = remainder;
 284          if (head < numHeads)
 285             chs[0] = (uint8_t) head;
 286          else
 287             retval = 0;
 288          if (sector < numSecspTrack) {
 289             chs[1] = (uint8_t) ((sector + 1) + (cylinder >> 8) * 64);
 290             chs[2] = (uint8_t) (cylinder & UINT32_C(0xFF));
 291          } else {
 292             retval = 0;
 293          } // if/else
 294       } // if value is expressible and non-0
 295    } else { // Invalid (NULL) chs pointer
 296       retval = -1;
 297    } // if CHS pointer valid
 298    return (retval);
 299 } // MBRPart::LBAtoCHS()
 300
 301 // Reverses the byte order, but only if we're on a big-endian platform.
 302 // Note that most data come in 8-bit structures, so don't need reversing;
 303 // only the LBA data needs to be reversed....
 304 void MBRPart::ReverseByteOrder(void) {
 305    if (IsLittleEndian() == 0) {
 306       ReverseBytes(&firstLBA, 4);
 307       ReverseBytes(&lengthLBA, 4);
 308    } // if
 309 } // MBRPart::ReverseByteOrder()
 310
 311 /**************************
 312  *                        *
 313  * User I/O functions.... *
 314  *                        *
 315  **************************/
 316
 317 // Show MBR data. Should update canBeLogical flags before calling.
 318 // If isGpt == 1, omits the "can be logical" and "can be primary" columns.
 319 void MBRPart::ShowData(int isGpt) {
 320    char bootCode = ' ';
 321
 322    if (status && 0x80) // it's bootable
 323       bootCode = '*';
 324    cout.fill(' ');
 325    cout << bootCode << "  ";
 326    cout.width(13);
 327    cout << firstLBA;
 328    cout.width(13);
 329    cout << GetLastLBA() << "   ";
 330    switch (includeAs) {
 331       case PRIMARY:
 332          cout << "primary";
 333          break;
 334       case LOGICAL:
 335          cout << "logical";
 336          break;
 337       case NONE:
 338          cout << "omitted";
 339          break;
 340       default:
 341          cout << "error  ";
 342          break;
 343    } // switch
 344    cout.width(7);
 345    if (!isGpt) {
 346       if (canBeLogical)
 347          cout << "     Y      ";
 348       else
 349          cout << "            ";
 350       if (canBePrimary)
 351          cout << "  Y      ";
 352       else
 353          cout << "         ";
 354    } // if
 355    cout << "0x";
 356    cout.width(2);
 357    cout.fill('0');
 358    cout << hex << (int) partitionType << dec << "\n";
 359 } // MBRPart::ShowData()