EdkModulePkg/Universal/Disk/Partition/Dxe/Mbr.c

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