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 - 2009, 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  This              Calling context.
 105   @param  Handle            Parent Handle.
 106   @param  DiskIo            Parent DiskIo interface.
 107   @param  BlockIo           Parent BlockIo interface.
 108   @param  DevicePath        Parent Device Path.
 109
 110   @retval EFI_SUCCESS       A child handle was added.
 111   @retval EFI_MEDIA_CHANGED Media change was detected.
 112   @retval Others            MBR partition was not found.
 113
 114 **/
 115 EFI_STATUS
 116 PartitionInstallMbrChildHandles (
 117   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 118   IN  EFI_HANDLE                   Handle,
 119   IN  EFI_DISK_IO_PROTOCOL         *DiskIo,
 120   IN  EFI_BLOCK_IO_PROTOCOL        *BlockIo,
 121   IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath
 122   )
 123 {
 124   EFI_STATUS                Status;
 125   MASTER_BOOT_RECORD        *Mbr;
 126   UINT32                    ExtMbrStartingLba;
 127   UINTN                     Index;
 128   HARDDRIVE_DEVICE_PATH     HdDev;
 129   HARDDRIVE_DEVICE_PATH     ParentHdDev;
 130   EFI_STATUS                Found;
 131   UINT32                    PartitionNumber;
 132   EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode;
 133   EFI_DEVICE_PATH_PROTOCOL  *LastDevicePathNode;
 134
 135   Found           = EFI_NOT_FOUND;
 136
 137   Mbr             = AllocatePool (BlockIo->Media->BlockSize);
 138   if (Mbr == NULL) {
 139     return Found;
 140   }
 141
 142   Status = DiskIo->ReadDisk (
 143                      DiskIo,
 144                      BlockIo->Media->MediaId,
 145                      0,
 146                      BlockIo->Media->BlockSize,
 147                      Mbr
 148                      );
 149   if (EFI_ERROR (Status)) {
 150     Found = Status;
 151     goto Done;
 152   }
 153   if (!PartitionValidMbr (Mbr, BlockIo->Media->LastBlock)) {
 154     goto Done;
 155   }
 156   //
 157   // We have a valid mbr - add each partition
 158   //
 159   //
 160   // Get starting and ending LBA of the parent block device.
 161   //
 162   LastDevicePathNode = NULL;
 163   ZeroMem (&ParentHdDev, sizeof (ParentHdDev));
 164   DevicePathNode = DevicePath;
 165   while (!IsDevicePathEnd (DevicePathNode)) {
 166     LastDevicePathNode  = DevicePathNode;
 167     DevicePathNode      = NextDevicePathNode (DevicePathNode);
 168   }
 169
 170   if (LastDevicePathNode != NULL) {
 171     if (DevicePathType (LastDevicePathNode) == MEDIA_DEVICE_PATH &&
 172         DevicePathSubType (LastDevicePathNode) == MEDIA_HARDDRIVE_DP
 173         ) {
 174       CopyMem (&ParentHdDev, LastDevicePathNode, sizeof (ParentHdDev));
 175     } else {
 176       LastDevicePathNode = NULL;
 177     }
 178   }
 179
 180   PartitionNumber = 1;
 181
 182   ZeroMem (&HdDev, sizeof (HdDev));
 183   HdDev.Header.Type     = MEDIA_DEVICE_PATH;
 184   HdDev.Header.SubType  = MEDIA_HARDDRIVE_DP;
 185   SetDevicePathNodeLength (&HdDev.Header, sizeof (HdDev));
 186   HdDev.MBRType         = MBR_TYPE_PCAT;
 187   HdDev.SignatureType   = SIGNATURE_TYPE_MBR;
 188
 189   if (LastDevicePathNode == NULL) {
 190     //
 191     // This is a MBR, add each partition
 192     //
 193     for (Index = 0; Index < MAX_MBR_PARTITIONS; Index++) {
 194       if (Mbr->Partition[Index].OSIndicator == 0x00 || UNPACK_UINT32 (Mbr->Partition[Index].SizeInLBA) == 0) {
 195         //
 196         // Don't use null MBR entries
 197         //
 198         continue;
 199       }
 200
 201       if (Mbr->Partition[Index].OSIndicator == PMBR_GPT_PARTITION) {
 202         //
 203         // This is the guard MBR for the GPT. If you ever see a GPT disk with zero partitions you can get here.
 204         //  We can not produce an MBR BlockIo for this device as the MBR spans the GPT headers. So formating
 205         //  this BlockIo would corrupt the GPT structures and require a recovery that would corrupt the format
 206         //  that corrupted the GPT partition.
 207         //
 208         continue;
 209       }
 210
 211       HdDev.PartitionNumber = PartitionNumber ++;
 212       HdDev.PartitionStart  = UNPACK_UINT32 (Mbr->Partition[Index].StartingLBA);
 213       HdDev.PartitionSize   = UNPACK_UINT32 (Mbr->Partition[Index].SizeInLBA);
 214       CopyMem (HdDev.Signature, &(Mbr->UniqueMbrSignature[0]), sizeof (Mbr->UniqueMbrSignature));
 215
 216       Status = PartitionInstallChildHandle (
 217                 This,
 218                 Handle,
 219                 DiskIo,
 220                 BlockIo,
 221                 DevicePath,
 222                 (EFI_DEVICE_PATH_PROTOCOL *) &HdDev,
 223                 HdDev.PartitionStart,
 224                 HdDev.PartitionStart + HdDev.PartitionSize - 1,
 225                 MBR_SIZE,
 226                 (BOOLEAN) (Mbr->Partition[Index].OSIndicator == EFI_PARTITION)
 227                 );
 228
 229       if (!EFI_ERROR (Status)) {
 230         Found = EFI_SUCCESS;
 231       }
 232     }
 233   } else {
 234     //
 235     // It's an extended partition. Follow the extended partition
 236     // chain to get all the logical drives
 237     //
 238     ExtMbrStartingLba = 0;
 239
 240     do {
 241
 242       Status = DiskIo->ReadDisk (
 243                          DiskIo,
 244                          BlockIo->Media->MediaId,
 245                          MultU64x32 (ExtMbrStartingLba, BlockIo->Media->BlockSize),
 246                          BlockIo->Media->BlockSize,
 247                          Mbr
 248                          );
 249       if (EFI_ERROR (Status)) {
 250         Found = Status;
 251         goto Done;
 252       }
 253
 254       if (UNPACK_UINT32 (Mbr->Partition[0].SizeInLBA) == 0) {
 255         break;
 256       }
 257
 258       if ((Mbr->Partition[0].OSIndicator == EXTENDED_DOS_PARTITION) ||
 259           (Mbr->Partition[0].OSIndicator == EXTENDED_WINDOWS_PARTITION)) {
 260         ExtMbrStartingLba = UNPACK_UINT32 (Mbr->Partition[0].StartingLBA);
 261         continue;
 262       }
 263       HdDev.PartitionNumber = PartitionNumber ++;
 264       HdDev.PartitionStart  = UNPACK_UINT32 (Mbr->Partition[0].StartingLBA) + ExtMbrStartingLba + ParentHdDev.PartitionStart;
 265       HdDev.PartitionSize   = UNPACK_UINT32 (Mbr->Partition[0].SizeInLBA);
 266       if ((HdDev.PartitionStart + HdDev.PartitionSize - 1 >= ParentHdDev.PartitionStart + ParentHdDev.PartitionSize) ||
 267           (HdDev.PartitionStart <= ParentHdDev.PartitionStart)) {
 268         break;
 269       }
 270
 271       //
 272       // The signature in EBR(Extended Boot Record) should always be 0.
 273       //
 274       *((UINT32 *) &HdDev.Signature[0]) = 0;
 275
 276       Status = PartitionInstallChildHandle (
 277                 This,
 278                 Handle,
 279                 DiskIo,
 280                 BlockIo,
 281                 DevicePath,
 282                 (EFI_DEVICE_PATH_PROTOCOL *) &HdDev,
 283                 HdDev.PartitionStart - ParentHdDev.PartitionStart,
 284                 HdDev.PartitionStart - ParentHdDev.PartitionStart + HdDev.PartitionSize - 1,
 285                 MBR_SIZE,
 286                 (BOOLEAN) (Mbr->Partition[0].OSIndicator == EFI_PARTITION)
 287                 );
 288       if (!EFI_ERROR (Status)) {
 289         Found = EFI_SUCCESS;
 290       }
 291
 292       if ((Mbr->Partition[1].OSIndicator != EXTENDED_DOS_PARTITION) &&
 293           (Mbr->Partition[1].OSIndicator != EXTENDED_WINDOWS_PARTITION)
 294           ) {
 295         break;
 296       }
 297
 298       ExtMbrStartingLba = UNPACK_UINT32 (Mbr->Partition[1].StartingLBA);
 299       //
 300       // Don't allow partition to be self referencing
 301       //
 302       if (ExtMbrStartingLba == 0) {
 303         break;
 304       }
 305     } while (ExtMbrStartingLba  < ParentHdDev.PartitionSize);
 306   }
 307
 308 Done:
 309   FreePool (Mbr);
 310
 311   return Found;
 312 }