MdeModulePkg/Universal/Disk/PartitionDxe/Mbr.c

   1 /** @file
   2   Decode a hard disk partitioned with the legacy MBR found on most PC's
   3
   4   MBR - Master Boot Record is in the first sector of a partitioned hard disk.
   5         The MBR supports four partitions per disk. The MBR also contains legacy
   6         code that is not run on an EFI system. The legacy code reads the
   7         first sector of the active partition into memory and
   8
   9   BPB - BIOS Parameter Block is in the first sector of a FAT file system.
  10         The BPB contains information about the FAT file system. The BPB is
  11         always on the first sector of a media. The first sector also contains
  12         the legacy boot strap code.
  13
  14 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
  15 This program and the accompanying materials
  16 are licensed and made available under the terms and conditions of the BSD License
  17 which accompanies this distribution.  The full text of the license may be found at
  18 http://opensource.org/licenses/bsd-license.php
  19
  20 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  21 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  22
  23 **/
  24
  25 #include "Partition.h"
  26
  27 /**
  28   Test to see if the Mbr buffer is a valid MBR.
  29
  30   @param  Mbr         Parent Handle.
  31   @param  LastLba     Last Lba address on the device.
  32
  33   @retval TRUE        Mbr is a Valid MBR.
  34   @retval FALSE       Mbr is not a Valid MBR.
  35
  36 **/
  37 BOOLEAN
  38 PartitionValidMbr (
  39   IN  MASTER_BOOT_RECORD      *Mbr,
  40   IN  EFI_LBA                 LastLba
  41   )
  42 {
  43   UINT32  StartingLBA;
  44   UINT32  EndingLBA;
  45   UINT32  NewEndingLBA;
  46   INTN    Index1;
  47   INTN    Index2;
  48   BOOLEAN MbrValid;
  49
  50   if (Mbr->Signature != MBR_SIGNATURE) {
  51     return FALSE;
  52   }
  53   //
  54   // The BPB also has this signature, so it can not be used alone.
  55   //
  56   MbrValid = FALSE;
  57   for (Index1 = 0; Index1 < MAX_MBR_PARTITIONS; Index1++) {
  58     if (Mbr->Partition[Index1].OSIndicator == 0x00 || UNPACK_UINT32 (Mbr->Partition[Index1].SizeInLBA) == 0) {
  59       continue;
  60     }
  61
  62     MbrValid    = TRUE;
  63     StartingLBA = UNPACK_UINT32 (Mbr->Partition[Index1].StartingLBA);
  64     EndingLBA   = StartingLBA + UNPACK_UINT32 (Mbr->Partition[Index1].SizeInLBA) - 1;
  65     if (EndingLBA > LastLba) {
  66       //
  67       // Compatibility Errata:
  68       //  Some systems try to hide drive space with their INT 13h driver
  69       //  This does not hide space from the OS driver. This means the MBR
  70       //  that gets created from DOS is smaller than the MBR created from
  71       //  a real OS (NT & Win98). This leads to BlockIo->LastBlock being
  72       //  wrong on some systems FDISKed by the OS.
  73       //
  74       // return FALSE since no block devices on a system are implemented
  75       // with INT 13h
  76       //
  77       return FALSE;
  78     }
  79
  80     for (Index2 = Index1 + 1; Index2 < MAX_MBR_PARTITIONS; Index2++) {
  81       if (Mbr->Partition[Index2].OSIndicator == 0x00 || UNPACK_UINT32 (Mbr->Partition[Index2].SizeInLBA) == 0) {
  82         continue;
  83       }
  84
  85       NewEndingLBA = UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) + UNPACK_UINT32 (Mbr->Partition[Index2].SizeInLBA) - 1;
  86       if (NewEndingLBA >= StartingLBA && UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) <= EndingLBA) {
  87         //
  88         // This region overlaps with the Index1'th region
  89         //
  90         return FALSE;
  91       }
  92     }
  93   }
  94   //
  95   // None of the regions overlapped so MBR is O.K.
  96   //
  97   return MbrValid;
  98 }
  99
 100
 101 /**
 102   Install child handles if the Handle supports MBR format.
 103
 104   @param[in]  This              Calling context.
 105   @param[in]  Handle            Parent Handle.
 106   @param[in]  DiskIo            Parent DiskIo interface.
 107   @param[in]  BlockIo           Parent BlockIo interface.
 108   @param[in]  BlockIo2          Parent BlockIo2 interface.
 109   @param[in]  DevicePath        Parent Device Path.
 110
 111   @retval EFI_SUCCESS       A child handle was added.
 112   @retval EFI_MEDIA_CHANGED Media change was detected.
 113   @retval Others            MBR partition was not found.
 114
 115 **/
 116 EFI_STATUS
 117 PartitionInstallMbrChildHandles (
 118   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 119   IN  EFI_HANDLE                   Handle,
 120   IN  EFI_DISK_IO_PROTOCOL         *DiskIo,
 121   IN  EFI_BLOCK_IO_PROTOCOL        *BlockIo,
 122   IN  EFI_BLOCK_IO2_PROTOCOL       *BlockIo2,
 123   IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath
 124   )
 125 {
 126   EFI_STATUS                Status;
 127   MASTER_BOOT_RECORD        *Mbr;
 128   UINT32                    ExtMbrStartingLba;
 129   UINTN                     Index;
 130   HARDDRIVE_DEVICE_PATH     HdDev;
 131   HARDDRIVE_DEVICE_PATH     ParentHdDev;
 132   EFI_STATUS                Found;
 133   UINT32                    PartitionNumber;
 134   EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode;
 135   EFI_DEVICE_PATH_PROTOCOL  *LastDevicePathNode;
 136   UINT32                    BlockSize;
 137   UINT32                    MediaId;
 138   EFI_LBA                   LastBlock;
 139
 140   Found           = EFI_NOT_FOUND;
 141
 142   BlockSize = BlockIo->Media->BlockSize;
 143   MediaId   = BlockIo->Media->MediaId;
 144   LastBlock = BlockIo->Media->LastBlock;
 145
 146   Mbr = AllocatePool (BlockSize);
 147   if (Mbr == NULL) {
 148     return Found;
 149   }
 150
 151   Status = DiskIo->ReadDisk (
 152                      DiskIo,
 153                      MediaId,
 154                      0,
 155                      BlockSize,
 156                      Mbr
 157                      );
 158   if (EFI_ERROR (Status)) {
 159     Found = Status;
 160     goto Done;
 161   }
 162   if (!PartitionValidMbr (Mbr, LastBlock)) {
 163     goto Done;
 164   }
 165   //
 166   // We have a valid mbr - add each partition
 167   //
 168   //
 169   // Get starting and ending LBA of the parent block device.
 170   //
 171   LastDevicePathNode = NULL;
 172   ZeroMem (&ParentHdDev, sizeof (ParentHdDev));
 173   DevicePathNode = DevicePath;
 174   while (!IsDevicePathEnd (DevicePathNode)) {
 175     LastDevicePathNode  = DevicePathNode;
 176     DevicePathNode      = NextDevicePathNode (DevicePathNode);
 177   }
 178
 179   if (LastDevicePathNode != NULL) {
 180     if (DevicePathType (LastDevicePathNode) == MEDIA_DEVICE_PATH &&
 181         DevicePathSubType (LastDevicePathNode) == MEDIA_HARDDRIVE_DP
 182         ) {
 183       CopyMem (&ParentHdDev, LastDevicePathNode, sizeof (ParentHdDev));
 184     } else {
 185       LastDevicePathNode = NULL;
 186     }
 187   }
 188
 189   PartitionNumber = 1;
 190
 191   ZeroMem (&HdDev, sizeof (HdDev));
 192   HdDev.Header.Type     = MEDIA_DEVICE_PATH;
 193   HdDev.Header.SubType  = MEDIA_HARDDRIVE_DP;
 194   SetDevicePathNodeLength (&HdDev.Header, sizeof (HdDev));
 195   HdDev.MBRType         = MBR_TYPE_PCAT;
 196   HdDev.SignatureType   = SIGNATURE_TYPE_MBR;
 197
 198   if (LastDevicePathNode == NULL) {
 199     //
 200     // This is a MBR, add each partition
 201     //
 202     for (Index = 0; Index < MAX_MBR_PARTITIONS; Index++) {
 203       if (Mbr->Partition[Index].OSIndicator == 0x00 || UNPACK_UINT32 (Mbr->Partition[Index].SizeInLBA) == 0) {
 204         //
 205         // Don't use null MBR entries
 206         //
 207         continue;
 208       }
 209
 210       if (Mbr->Partition[Index].OSIndicator == PMBR_GPT_PARTITION) {
 211         //
 212         // This is the guard MBR for the GPT. If you ever see a GPT disk with zero partitions you can get here.
 213         //  We can not produce an MBR BlockIo for this device as the MBR spans the GPT headers. So formating
 214         //  this BlockIo would corrupt the GPT structures and require a recovery that would corrupt the format
 215         //  that corrupted the GPT partition.
 216         //
 217         continue;
 218       }
 219
 220       HdDev.PartitionNumber = PartitionNumber ++;
 221       HdDev.PartitionStart  = UNPACK_UINT32 (Mbr->Partition[Index].StartingLBA);
 222       HdDev.PartitionSize   = UNPACK_UINT32 (Mbr->Partition[Index].SizeInLBA);
 223       CopyMem (HdDev.Signature, &(Mbr->UniqueMbrSignature[0]), sizeof (Mbr->UniqueMbrSignature));
 224
 225       Status = PartitionInstallChildHandle (
 226                 This,
 227                 Handle,
 228                 DiskIo,
 229                 BlockIo,
 230                 BlockIo2,
 231                 DevicePath,
 232                 (EFI_DEVICE_PATH_PROTOCOL *) &HdDev,
 233                 HdDev.PartitionStart,
 234                 HdDev.PartitionStart + HdDev.PartitionSize - 1,
 235                 MBR_SIZE,
 236                 (BOOLEAN) (Mbr->Partition[Index].OSIndicator == EFI_PARTITION)
 237                 );
 238
 239       if (!EFI_ERROR (Status)) {
 240         Found = EFI_SUCCESS;
 241       }
 242     }
 243   } else {
 244     //
 245     // It's an extended partition. Follow the extended partition
 246     // chain to get all the logical drives
 247     //
 248     ExtMbrStartingLba = 0;
 249
 250     do {
 251
 252       Status = DiskIo->ReadDisk (
 253                          DiskIo,
 254                          MediaId,
 255                          MultU64x32 (ExtMbrStartingLba, BlockSize),
 256                          BlockSize,
 257                          Mbr
 258                          );
 259       if (EFI_ERROR (Status)) {
 260         Found = Status;
 261         goto Done;
 262       }
 263
 264       if (UNPACK_UINT32 (Mbr->Partition[0].SizeInLBA) == 0) {
 265         break;
 266       }
 267
 268       if ((Mbr->Partition[0].OSIndicator == EXTENDED_DOS_PARTITION) ||
 269           (Mbr->Partition[0].OSIndicator == EXTENDED_WINDOWS_PARTITION)) {
 270         ExtMbrStartingLba = UNPACK_UINT32 (Mbr->Partition[0].StartingLBA);
 271         continue;
 272       }
 273       HdDev.PartitionNumber = PartitionNumber ++;
 274       HdDev.PartitionStart  = UNPACK_UINT32 (Mbr->Partition[0].StartingLBA) + ExtMbrStartingLba + ParentHdDev.PartitionStart;
 275       HdDev.PartitionSize   = UNPACK_UINT32 (Mbr->Partition[0].SizeInLBA);
 276       if ((HdDev.PartitionStart + HdDev.PartitionSize - 1 >= ParentHdDev.PartitionStart + ParentHdDev.PartitionSize) ||
 277           (HdDev.PartitionStart <= ParentHdDev.PartitionStart)) {
 278         break;
 279       }
 280
 281       //
 282       // The signature in EBR(Extended Boot Record) should always be 0.
 283       //
 284       *((UINT32 *) &HdDev.Signature[0]) = 0;
 285
 286       Status = PartitionInstallChildHandle (
 287                  This,
 288                  Handle,
 289                  DiskIo,
 290                  BlockIo,
 291                  BlockIo2,
 292                  DevicePath,
 293                  (EFI_DEVICE_PATH_PROTOCOL *) &HdDev,
 294                  HdDev.PartitionStart - ParentHdDev.PartitionStart,
 295                  HdDev.PartitionStart - ParentHdDev.PartitionStart + HdDev.PartitionSize - 1,
 296                  MBR_SIZE,
 297                  (BOOLEAN) (Mbr->Partition[0].OSIndicator == EFI_PARTITION)
 298                  );
 299       if (!EFI_ERROR (Status)) {
 300         Found = EFI_SUCCESS;
 301       }
 302
 303       if ((Mbr->Partition[1].OSIndicator != EXTENDED_DOS_PARTITION) &&
 304           (Mbr->Partition[1].OSIndicator != EXTENDED_WINDOWS_PARTITION)
 305           ) {
 306         break;
 307       }
 308
 309       ExtMbrStartingLba = UNPACK_UINT32 (Mbr->Partition[1].StartingLBA);
 310       //
 311       // Don't allow partition to be self referencing
 312       //
 313       if (ExtMbrStartingLba == 0) {
 314         break;
 315       }
 316     } while (ExtMbrStartingLba  < ParentHdDev.PartitionSize);
 317   }
 318
 319 Done:
 320   FreePool (Mbr);
 321
 322   return Found;
 323 }