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
24using namespace std;
25
26
27BSDData::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
39BSDData::~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.
46int 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.
66int 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
175void 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.
183void 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
206int 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....
226int BSDData::IsDisklabel(void) {
227   return (state == bsd);
228} // BSDData::IsDiskLabel()
229
230// Returns the BSD table's partition type code
231uint8_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
241uint64_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
251uint64_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
261int 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
267GPTPart 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()
333