bsd.cc

   1 /* bsd.cc -- Functions for loading and manipulating legacy BSD disklabel
   2    data. */
   3
   4 /* By Rod Smith, initial coding August, 2009 */
   5
   6 /* This program is copyright (c) 2009 by Roderick W. Smith. It is distributed
   7   under the terms of the GNU GPL version 2, as detailed in the COPYING file. */
   8
   9 #define __STDC_LIMIT_MACROS
  10 #define __STDC_CONSTANT_MACROS
  11
  12 #include <stdio.h>
  13 //#include <unistd.h>
  14 #include <stdlib.h>
  15 #include <stdint.h>
  16 #include <fcntl.h>
  17 #include <sys/stat.h>
  18 #include <errno.h>
  19 #include <iostream>
  20 #include <string>
  21 #include "support.h"
  22 #include "bsd.h"
  23
  24 using namespace std;
  25
  26
  27 BSDData::BSDData(void) {
  28    state = unknown;
  29    signature = UINT32_C(0);
  30    signature2 = UINT32_C(0);
  31    sectorSize = 512;
  32    numParts = 0;
  33    labelFirstLBA = 0;
  34    labelLastLBA = 0;
  35    labelStart = LABEL_OFFSET1; // assume raw disk format
  36    partitions = NULL;
  37 } // default constructor
  38
  39 BSDData::~BSDData(void) {
  40    delete[] partitions;
  41 } // destructor
  42
  43 // Read BSD disklabel data from the specified device filename. This function
  44 // just opens the device file and then calls an overloaded function to do
  45 // the bulk of the work. Returns 1 on success, 0 on failure.
  46 int BSDData::ReadBSDData(const string & device, uint64_t startSector, uint64_t endSector) {
  47    int allOK = 1;
  48    DiskIO myDisk;
  49
  50    if (device != "") {
  51       if (myDisk.OpenForRead(device)) {
  52          allOK = ReadBSDData(&myDisk, startSector, endSector);
  53       } else {
  54          allOK = 0;
  55       } // if/else
  56
  57       myDisk.Close();
  58    } else {
  59       allOK = 0;
  60    } // if/else
  61    return allOK;
  62 } // BSDData::ReadBSDData() (device filename version)
  63
  64 // Load the BSD disklabel data from an already-opened disk
  65 // file, starting with the specified sector number.
  66 int BSDData::ReadBSDData(DiskIO *theDisk, uint64_t startSector, uint64_t endSector) {
  67    int allOK = 1;
  68    int i, foundSig = 0, bigEnd = 0;
  69    int relative = 0; // assume absolute partition sector numbering
  70    uint8_t buffer[4096]; // I/O buffer
  71    uint32_t realSig;
  72    uint32_t* temp32;
  73    uint16_t* temp16;
  74    BSDRecord* tempRecords;
  75    int offset[NUM_OFFSETS] = { LABEL_OFFSET1, LABEL_OFFSET2 };
  76
  77    labelFirstLBA = startSector;
  78    labelLastLBA = endSector;
  79    offset[1] = theDisk->GetBlockSize();
  80
  81    // Read 4096 bytes (eight 512-byte sectors or equivalent)
  82    // into memory; we'll extract data from this buffer.
  83    // (Done to work around FreeBSD limitation on size of reads
  84    // from block devices.)
  85    allOK = theDisk->Seek(startSector);
  86    if (allOK) allOK = theDisk->Read(buffer, 4096);
  87
  88    // Do some strangeness to support big-endian architectures...
  89    bigEnd = (IsLittleEndian() == 0);
  90    realSig = BSD_SIGNATURE;
  91    if (bigEnd && allOK)
  92       ReverseBytes(&realSig, 4);
  93
  94    // Look for the signature at any of two locations.
  95    // Note that the signature is repeated at both the original
  96    // offset and 132 bytes later, so we need two checks....
  97    if (allOK) {
  98       i = 0;
  99       do {
 100          temp32 = (uint32_t*) &buffer[offset[i]];
 101          signature = *temp32;
 102          if (signature == realSig) { // found first, look for second
 103             temp32 = (uint32_t*) &buffer[offset[i] + 132];
 104             signature2 = *temp32;
 105             if (signature2 == realSig) {
 106                foundSig = 1;
 107                labelStart = offset[i];
 108             } // if found signature
 109          } // if/else
 110          i++;
 111       } while ((!foundSig) && (i < NUM_OFFSETS));
 112       allOK = foundSig;
 113    } // if
 114
 115    // Load partition metadata from the buffer....
 116    if (allOK) {
 117       temp32 = (uint32_t*) &buffer[labelStart + 40];
 118       sectorSize = *temp32;
 119       temp16 = (uint16_t*) &buffer[labelStart + 138];
 120       numParts = *temp16;
 121    } // if
 122
 123    // Make it big-endian-aware....
 124    if ((IsLittleEndian() == 0) && allOK)
 125       ReverseMetaBytes();
 126
 127    // Check validity of the data and flag it appropriately....
 128    if (foundSig && (numParts <= MAX_BSD_PARTS) && allOK) {
 129       state = bsd;
 130    } else {
 131       state = bsd_invalid;
 132    } // if/else
 133
 134    // If the state is good, go ahead and load the main partition data....
 135    if (state == bsd) {
 136       partitions = new struct BSDRecord[numParts * sizeof(struct BSDRecord)];
 137       if (partitions == NULL) {
 138          cerr << "Unable to allocate memory in BSDData::ReadBSDData()! Terminating!\n";
 139          exit(1);
 140       } // if
 141       for (i = 0; i < numParts; i++) {
 142          // Once again, we use the buffer, but index it using a BSDRecord
 143          // pointer (dangerous, but effective)....
 144          tempRecords = (BSDRecord*) &buffer[labelStart + 148];
 145          partitions[i].lengthLBA = tempRecords[i].lengthLBA;
 146          partitions[i].firstLBA = tempRecords[i].firstLBA;
 147          partitions[i].fsType = tempRecords[i].fsType;
 148          if (bigEnd) { // reverse data (fsType is a single byte)
 149             ReverseBytes(&partitions[i].lengthLBA, 4);
 150             ReverseBytes(&partitions[i].firstLBA, 4);
 151          } // if big-endian
 152          // Check for signs of relative sector numbering: A "0" first sector
 153          // number on a partition with a non-zero length -- but ONLY if the
 154          // length is less than the disk size, since NetBSD has a habit of
 155          // creating a disk-sized partition within a carrier MBR partition
 156          // that's too small to house it, and this throws off everything....
 157          if ((partitions[i].firstLBA == 0) && (partitions[i].lengthLBA > 0)
 158              && (partitions[i].lengthLBA < labelLastLBA))
 159             relative = 1;
 160       } // for
 161       // Some disklabels use sector numbers relative to the enclosing partition's
 162       // start, others use absolute sector numbers. If relative numbering was
 163       // detected above, apply a correction to all partition start sectors....
 164       if (relative) {
 165          for (i = 0; i < numParts; i++) {
 166             partitions[i].firstLBA += (uint32_t) startSector;
 167          } // for
 168       } // if
 169    } // if signatures OK
 170 //   DisplayBSDData();
 171    return allOK;
 172 } // BSDData::ReadBSDData(DiskIO* theDisk, uint64_t startSector)
 173
 174 // Reverse metadata's byte order; called only on big-endian systems
 175 void BSDData::ReverseMetaBytes(void) {
 176    ReverseBytes(&signature, 4);
 177    ReverseBytes(&sectorSize, 4);
 178    ReverseBytes(&signature2, 4);
 179    ReverseBytes(&numParts, 2);
 180 } // BSDData::ReverseMetaByteOrder()
 181
 182 // Display basic BSD partition data. Used for debugging.
 183 void BSDData::DisplayBSDData(void) {
 184    int i;
 185
 186    if (state == bsd) {
 187       cout << "BSD partitions:\n";
 188       for (i = 0; i < numParts; i++) {
 189          cout.width(4);
 190          cout << i + 1 << "\t";
 191          cout.width(13);
 192          cout << partitions[i].firstLBA << "\t";
 193          cout.width(15);
 194          cout << partitions[i].lengthLBA << " \t0x";
 195          cout.width(2);
 196          cout.fill('0');
 197          cout.setf(ios::uppercase);
 198          cout << hex << (int) partitions[i].fsType << "\n" << dec;
 199          cout.fill(' ');
 200       } // for
 201    } // if
 202 } // BSDData::DisplayBSDData()
 203
 204 // Displays the BSD disklabel state. Called during program launch to inform
 205 // the user about the partition table(s) status
 206 int BSDData::ShowState(void) {
 207    int retval = 0;
 208
 209    switch (state) {
 210       case bsd_invalid:
 211          cout << "  BSD: not present\n";
 212          break;
 213       case bsd:
 214          cout << "  BSD: present\n";
 215          retval = 1;
 216          break;
 217       default:
 218          cout << "\a  BSD: unknown -- bug!\n";
 219          break;
 220    } // switch
 221    return retval;
 222 } // BSDData::ShowState()
 223
 224 // Weirdly, this function has stopped working when defined inline,
 225 // but it's OK here....
 226 int BSDData::IsDisklabel(void) {
 227    return (state == bsd);
 228 } // BSDData::IsDiskLabel()
 229
 230 // Returns the BSD table's partition type code
 231 uint8_t BSDData::GetType(int i) {
 232    uint8_t retval = 0; // 0 = "unused"
 233
 234    if ((i < numParts) && (i >= 0) && (state == bsd) && (partitions != 0))
 235       retval = partitions[i].fsType;
 236
 237    return(retval);
 238 } // BSDData::GetType()
 239
 240 // Returns the number of the first sector of the specified partition
 241 uint64_t BSDData::GetFirstSector(int i) {
 242    uint64_t retval = UINT64_C(0);
 243
 244    if ((i < numParts) && (i >= 0) && (state == bsd) && (partitions != 0))
 245       retval = (uint64_t) partitions[i].firstLBA;
 246
 247    return retval;
 248 } // BSDData::GetFirstSector
 249
 250 // Returns the length (in sectors) of the specified partition
 251 uint64_t BSDData::GetLength(int i) {
 252    uint64_t retval = UINT64_C(0);
 253
 254    if ((i < numParts) && (i >= 0) && (state == bsd) && (partitions != 0))
 255       retval = (uint64_t) partitions[i].lengthLBA;
 256
 257    return retval;
 258 } // BSDData::GetLength()
 259
 260 // Returns the number of partitions defined in the current table
 261 int BSDData::GetNumParts(void) {
 262    return numParts;
 263 } // BSDData::GetNumParts()
 264
 265 // Returns the specified partition as a GPT partition. Used in BSD-to-GPT
 266 // conversion process
 267 GPTPart BSDData::AsGPT(int i) {
 268    GPTPart guid;                  // dump data in here, then return it
 269    uint64_t sectorOne, sectorEnd; // first & last sectors of partition
 270    int passItOn = 1;              // Set to 0 if partition is empty or invalid
 271
 272    guid.BlankPartition();
 273    sectorOne = (uint64_t) partitions[i].firstLBA;
 274    sectorEnd = sectorOne + (uint64_t) partitions[i].lengthLBA;
 275    if (sectorEnd > 0) sectorEnd--;
 276    // Note on above: BSD partitions sometimes have a length of 0 and a start
 277    // sector of 0. With unsigned ints, the usual way (start + length - 1) to
 278    // find the end will result in a huge number, which will be confusing.
 279    // Thus, apply the "-1" part only if it's reasonable to do so.
 280
 281    // Do a few sanity checks on the partition before we pass it on....
 282    // First, check that it falls within the bounds of its container
 283    // and that it starts before it ends....
 284    if ((sectorOne < labelFirstLBA) || (sectorEnd > labelLastLBA) || (sectorOne > sectorEnd))
 285       passItOn = 0;
 286    // Some disklabels include a pseudo-partition that's the size of the entire
 287    // disk or containing partition. Don't return it.
 288    if ((sectorOne <= labelFirstLBA) && (sectorEnd >= labelLastLBA) &&
 289        (GetType(i) == 0))
 290       passItOn = 0;
 291    // If the end point is 0, it's not a valid partition.
 292    if ((sectorEnd == 0) || (sectorEnd == labelFirstLBA))
 293       passItOn = 0;
 294
 295    if (passItOn) {
 296       guid.SetFirstLBA(sectorOne);
 297       guid.SetLastLBA(sectorEnd);
 298       // Now set a random unique GUID for the partition....
 299       guid.RandomizeUniqueGUID();
 300       // ... zero out the attributes and name fields....
 301       guid.SetAttributes(UINT64_C(0));
 302       // Most BSD disklabel type codes seem to be archaic or rare.
 303       // They're also ambiguous; a FreeBSD filesystem is impossible
 304       // to distinguish from a NetBSD one. Thus, these code assignment
 305       // are going to be rough to begin with. For a list of meanings,
 306       // see http://fxr.watson.org/fxr/source/sys/dtype.h?v=DFBSD,
 307       // or Google it.
 308       switch (GetType(i)) {
 309          case 1: // BSD swap
 310             guid.SetType(0xa502); break;
 311          case 7: // BSD FFS
 312             guid.SetType(0xa503); break;
 313          case 8: case 11: // MS-DOS or HPFS
 314             guid.SetType(0x0700); break;
 315          case 9: // log-structured fs
 316             guid.SetType(0xa903); break;
 317          case 13: // bootstrap
 318             guid.SetType(0xa501); break;
 319          case 14: // vinum
 320             guid.SetType(0xa505); break;
 321          case 15: // RAID
 322             guid.SetType(0xa903); break;
 323          case 27: // FreeBSD ZFS
 324             guid.SetType(0xa504); break;
 325          default:
 326             guid.SetType(0xa503); break;
 327       } // switch
 328       // Set the partition name to the name of the type code....
 329       guid.SetName(guid.GetTypeName());
 330    } // if
 331    return guid;
 332 } // BSDData::AsGPT()