code.delx.au - refind/blob - refind/gpt.c

   1 /*
   2  * refind/gpt.c
   3  * Functions related to GPT data structures
   4  *
   5  * Copyright (c) 2014-2015 Roderick W. Smith
   6  * All rights reserved.
   7  *
   8  * This program is distributed under the terms of the GNU General Public
   9  * License (GPL) version 3 (GPLv3), a copy of which must be distributed
  10  * with this source code or binaries made from it.
  11  *
  12  */
  13
  14 #include "gpt.h"
  15 #include "lib.h"
  16 #include "screen.h"
  17 #include "crc32.h"
  18 #include "../include/refit_call_wrapper.h"
  19
  20 #ifdef __MAKEWITH_TIANO
  21 #define BlockIoProtocol gEfiBlockIoProtocolGuid
  22 #endif
  23
  24 extern GPT_DATA *gPartitions;
  25
  26 // Allocate data for the main GPT_DATA structure, as well as the ProtectiveMBR
  27 // and Header structures it contains. This function does *NOT*, however,
  28 // allocate memory for the Entries data structure, since its size is variable
  29 // and is determined by the contents of Header.
  30 GPT_DATA * AllocateGptData(VOID) {
  31    GPT_DATA *GptData;
  32
  33    GptData = AllocateZeroPool(sizeof(GPT_DATA));
  34    if (GptData != NULL) {
  35       GptData->ProtectiveMBR = AllocateZeroPool(sizeof(MBR_RECORD));
  36       GptData->Header = AllocateZeroPool(sizeof(GPT_HEADER));
  37       if ((GptData->ProtectiveMBR == NULL) || (GptData->Header == NULL)) {
  38          MyFreePool(GptData->ProtectiveMBR);
  39          MyFreePool(GptData->Header);
  40          MyFreePool(GptData);
  41          GptData = NULL;
  42       } // if
  43    } // if
  44    return GptData;
  45 } // GPT_DATA * AllocateGptData()
  46
  47 // Unallocate a single GPT_DATA structure. This does NOT follow the
  48 // linked list, though.
  49 VOID ClearGptData(GPT_DATA *Data) {
  50    if (Data) {
  51       if (Data->ProtectiveMBR)
  52          MyFreePool(Data->ProtectiveMBR);
  53       if (Data->Header)
  54          MyFreePool(Data->Header);
  55       if (Data->Entries)
  56          MyFreePool(Data->Entries);
  57       MyFreePool(Data);
  58    } // if
  59 } // VOID ClearGptData()
  60
  61 // TODO: Make this work on big-endian systems; at the moment, it contains
  62 // little-endian assumptions!
  63 // Returns TRUE if the GPT protective MBR and header data appear valid,
  64 // FALSE otherwise.
  65 static BOOLEAN GptHeaderValid(GPT_DATA *GptData) {
  66    BOOLEAN IsValid;
  67    UINT32 CrcValue, StoredCrcValue;
  68    UINTN HeaderSize = sizeof(GPT_HEADER);
  69
  70    if ((GptData == NULL) || (GptData->ProtectiveMBR == NULL) || (GptData->Header == NULL))
  71       return FALSE;
  72
  73    IsValid = (GptData->ProtectiveMBR->MBRSignature == 0xAA55);
  74    IsValid = IsValid && ((GptData->ProtectiveMBR->partitions[0].type == 0xEE) ||
  75                          (GptData->ProtectiveMBR->partitions[1].type == 0xEE) ||
  76                          (GptData->ProtectiveMBR->partitions[2].type == 0xEE) ||
  77                          (GptData->ProtectiveMBR->partitions[3].type == 0xEE));
  78
  79    IsValid = IsValid && ((GptData->Header->signature == 0x5452415020494645ULL) &&
  80                          (GptData->Header->spec_revision == 0x00010000) &&
  81                          (GptData->Header->entry_size == 128));
  82
  83    // Looks good so far; check CRC value....
  84    if (IsValid) {
  85       if (GptData->Header->header_size < HeaderSize)
  86          HeaderSize = GptData->Header->header_size;
  87       StoredCrcValue = GptData->Header->header_crc32;
  88       GptData->Header->header_crc32 = 0;
  89       CrcValue = crc32(0x0, GptData->Header, HeaderSize);
  90       if (CrcValue != StoredCrcValue)
  91          IsValid = FALSE;
  92       GptData->Header->header_crc32 = StoredCrcValue;
  93    } // if
  94
  95    return IsValid;
  96 } // BOOLEAN GptHeaderValid()
  97
  98 // Read GPT data from Volume and store it in *Data. Note that this function
  99 // may be called on a Volume that is not in fact a GPT disk (an MBR disk,
 100 // a partition, etc.), in which case it will return EFI_LOAD_ERROR or some
 101 // other error condition. In this case, *Data will be left alone.
 102 // Note also that this function checks CRCs and does other sanity checks
 103 // on the input data, but does NOT resort to using the backup data if the
 104 // primary data structures are damaged. The intent is that the function
 105 // be very conservative about reading GPT data. Currently (version 0.7.10),
 106 // rEFInd uses the data only to provide access to partition names. This is
 107 // non-critical data, so it's OK to return nothing, but having the program
 108 // hang on reading garbage or return nonsense could be very bad.
 109 EFI_STATUS ReadGptData(REFIT_VOLUME *Volume, GPT_DATA **Data) {
 110    EFI_STATUS Status = EFI_SUCCESS;
 111    UINT64     BufferSize;
 112    UINTN      i;
 113    GPT_DATA   *GptData; // Temporary holding storage; transferred to *Data later
 114
 115    if ((Volume == NULL) || (Data == NULL))
 116       return EFI_INVALID_PARAMETER;
 117
 118    // get block i/o
 119    if ((Status == EFI_SUCCESS) && (Volume->BlockIO == NULL)) {
 120       Status = refit_call3_wrapper(BS->HandleProtocol, Volume->DeviceHandle, &BlockIoProtocol, (VOID **) &(Volume->BlockIO));
 121       if (EFI_ERROR(Status)) {
 122          Volume->BlockIO = NULL;
 123          Print(L"Warning: Can't get BlockIO protocol in ReadGptData().\n");
 124          Status = EFI_NOT_READY;
 125       }
 126    } // if
 127
 128    if ((Status == EFI_SUCCESS) && ((!Volume->BlockIO->Media->MediaPresent) || (Volume->BlockIO->Media->LogicalPartition)))
 129       Status = EFI_NO_MEDIA;
 130
 131    if (Status == EFI_SUCCESS) {
 132       GptData = AllocateGptData(); // Note: All but GptData->Entries
 133       if (GptData == NULL) {
 134          Status = EFI_OUT_OF_RESOURCES;
 135       } // if
 136    } // if
 137
 138    // Read the MBR and store it in GptData->ProtectiveMBR.
 139    if (Status == EFI_SUCCESS) {
 140       Status = refit_call5_wrapper(Volume->BlockIO->ReadBlocks, Volume->BlockIO, Volume->BlockIO->Media->MediaId,
 141                                    0, sizeof(MBR_RECORD), (VOID*) GptData->ProtectiveMBR);
 142    }
 143
 144    // Read the GPT header and store it in GptData->Header.
 145    if (Status == EFI_SUCCESS) {
 146       Status = refit_call5_wrapper(Volume->BlockIO->ReadBlocks, Volume->BlockIO, Volume->BlockIO->Media->MediaId,
 147                                    1, sizeof(GPT_HEADER), GptData->Header);
 148    }
 149
 150    // If it looks like a valid protective MBR & GPT header, try to do more with it....
 151    if (Status == EFI_SUCCESS) {
 152       if (GptHeaderValid(GptData)) {
 153          // Load actual GPT table....
 154          BufferSize = GptData->Header->entry_count * 128;
 155          GptData->Entries = AllocatePool(BufferSize);
 156          if (GptData->Entries == NULL)
 157             Status = EFI_OUT_OF_RESOURCES;
 158
 159          if (Status == EFI_SUCCESS)
 160             Status = refit_call5_wrapper(Volume->BlockIO->ReadBlocks, Volume->BlockIO, Volume->BlockIO->Media->MediaId,
 161                                          GptData->Header->entry_lba, BufferSize, GptData->Entries);
 162
 163          // Check CRC status of table
 164          if ((Status == EFI_SUCCESS) && (crc32(0x0, GptData->Entries, BufferSize) != GptData->Header->entry_crc32))
 165             Status = EFI_CRC_ERROR;
 166
 167          // Now, ensure that every name is null-terminated....
 168          if (Status == EFI_SUCCESS) {
 169             for (i = 0; i < GptData->Header->entry_count; i++)
 170                GptData->Entries[i].name[35] = '\0';
 171          } // if
 172       } else {
 173          Status = EFI_UNSUPPORTED;
 174       } // if/else valid header
 175    } // if header read OK
 176
 177    if (Status == EFI_SUCCESS) {
 178       // Everything looks OK, so copy it over
 179       ClearGptData(*Data);
 180       *Data = GptData;
 181    } else {
 182       ClearGptData(GptData);
 183    } // if/else
 184
 185    return Status;
 186 } // EFI_STATUS ReadGptData()
 187
 188 // Look in gPartitions for a partition with the specified Guid. If found, return
 189 // a pointer to that partition's name string. If not found, return a NULL pointer.
 190 // The calling function is responsible for freeing the returned memory.
 191 CHAR16 * PartNameFromGuid(EFI_GUID *Guid) {
 192    UINTN     i;
 193    CHAR16    *Found = NULL;
 194    GPT_DATA  *GptData;
 195
 196    if ((Guid == NULL) || (gPartitions == NULL))
 197       return NULL;
 198
 199    GptData = gPartitions;
 200    while ((GptData != NULL) && (!Found)) {
 201       i = 0;
 202       while ((i < GptData->Header->entry_count) && (!Found)) {
 203          if (GuidsAreEqual((EFI_GUID*) &(GptData->Entries[i].partition_guid), Guid))
 204             Found = StrDuplicate(GptData->Entries[i].name);
 205          else
 206             i++;
 207       } // while(scanning entries)
 208       GptData = GptData->NextEntry;
 209    } // while(scanning GPTs)
 210    return Found;
 211 } // CHAR16 * PartNameFromGuid()
 212
 213 // Erase the gPartitions linked-list data structure
 214 VOID ForgetPartitionTables(VOID) {
 215    GPT_DATA  *Next;
 216
 217    while (gPartitions != NULL) {
 218       Next = gPartitions->NextEntry;
 219       ClearGptData(gPartitions);
 220       gPartitions = Next;
 221    } // while
 222 } // VOID ForgetPartitionTables()
 223
 224 // If Volume points to a whole disk with a GPT, add it to the gPartitions
 225 // linked list of GPTs.
 226 VOID AddPartitionTable(REFIT_VOLUME *Volume) {
 227    GPT_DATA    *GptData = NULL, *GptList;
 228    EFI_STATUS  Status;
 229    UINTN       NumTables = 1;
 230
 231    Status = ReadGptData(Volume, &GptData);
 232    if (Status == EFI_SUCCESS) {
 233       if (gPartitions == NULL) {
 234          gPartitions = GptData;
 235       } else {
 236          GptList = gPartitions;
 237          while (GptList->NextEntry != NULL) {
 238             GptList = GptList->NextEntry;
 239             NumTables++;
 240          } // while
 241          GptList->NextEntry = GptData;
 242          NumTables++;
 243       } // if/else
 244    } else if (GptData != NULL) {
 245       ClearGptData(GptData);
 246       NumTables = 0;
 247    } // if/else
 248 } // VOID AddPartitionTable()
 249