VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/FatPkg/FatPei/Gpt.c@ 99454

Last change on this file since 99454 was 99404, checked in by vboxsync, 22 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 17.2 KB
Line 
1/** @file
2 Routines supporting partition discovery and
3 logical device reading
4
5Copyright (c) 2019 Intel Corporation. All rights reserved.<BR>
6
7SPDX-License-Identifier: BSD-2-Clause-Patent
8
9**/
10
11#include <IndustryStandard/Mbr.h>
12#include <Uefi/UefiGpt.h>
13#include <Library/BaseLib.h>
14#include "FatLitePeim.h"
15
16//
17// Assumption: 'a' and 'blocksize' are all UINT32 or UINT64.
18// If 'a' and 'blocksize' are not the same type, should use DivU64xU32 to calculate.
19//
20#define EFI_SIZE_TO_BLOCKS(a, blocksize) (((a) / (blocksize)) + (((a) % (blocksize)) ? 1 : 0))
21
22//
23// GPT Partition Entry Status
24//
25typedef struct {
26 BOOLEAN OutOfRange;
27 BOOLEAN Overlap;
28 BOOLEAN OsSpecific;
29} EFI_PARTITION_ENTRY_STATUS;
30
31/**
32 Check if the CRC field in the Partition table header is valid.
33
34 @param[in] PartHeader Partition table header structure
35
36 @retval TRUE the CRC is valid
37 @retval FALSE the CRC is invalid
38
39**/
40BOOLEAN
41PartitionCheckGptHeaderCRC (
42 IN EFI_PARTITION_TABLE_HEADER *PartHeader
43 )
44{
45 UINT32 GptHdrCrc;
46 UINT32 Crc;
47
48 GptHdrCrc = PartHeader->Header.CRC32;
49
50 //
51 // Set CRC field to zero when doing calculation
52 //
53 PartHeader->Header.CRC32 = 0;
54
55 Crc = CalculateCrc32 (PartHeader, PartHeader->Header.HeaderSize);
56
57 //
58 // Restore Header CRC
59 //
60 PartHeader->Header.CRC32 = GptHdrCrc;
61
62 return (GptHdrCrc == Crc);
63}
64
65/**
66 Check if the CRC field in the Partition table header is valid
67 for Partition entry array.
68
69 @param[in] PartHeader Partition table header structure
70 @param[in] PartEntry The partition entry array
71
72 @retval TRUE the CRC is valid
73 @retval FALSE the CRC is invalid
74
75**/
76BOOLEAN
77PartitionCheckGptEntryArrayCRC (
78 IN EFI_PARTITION_TABLE_HEADER *PartHeader,
79 IN EFI_PARTITION_ENTRY *PartEntry
80 )
81{
82 UINT32 Crc;
83 UINTN Size;
84
85 Size = (UINTN)MultU64x32 (PartHeader->NumberOfPartitionEntries, PartHeader->SizeOfPartitionEntry);
86 Crc = CalculateCrc32 (PartEntry, Size);
87
88 return (BOOLEAN)(PartHeader->PartitionEntryArrayCRC32 == Crc);
89}
90
91/**
92 The function is used for valid GPT table. Both for Primary and Backup GPT header.
93
94 @param[in] PrivateData The global memory map
95 @param[in] ParentBlockDevNo The parent block device
96 @param[in] IsPrimaryHeader Indicate to which header will be checked.
97 @param[in] PartHdr Stores the partition table that is read
98
99 @retval TRUE The partition table is valid
100 @retval FALSE The partition table is not valid
101
102**/
103BOOLEAN
104PartitionCheckGptHeader (
105 IN PEI_FAT_PRIVATE_DATA *PrivateData,
106 IN UINTN ParentBlockDevNo,
107 IN BOOLEAN IsPrimaryHeader,
108 IN EFI_PARTITION_TABLE_HEADER *PartHdr
109 )
110{
111 PEI_FAT_BLOCK_DEVICE *ParentBlockDev;
112 EFI_PEI_LBA Lba;
113 EFI_PEI_LBA AlternateLba;
114 EFI_PEI_LBA EntryArrayLastLba;
115
116 UINT64 PartitionEntryArraySize;
117 UINT64 PartitionEntryBlockNumb;
118 UINT32 EntryArraySizeRemainder;
119
120 ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);
121
122 if (IsPrimaryHeader) {
123 Lba = PRIMARY_PART_HEADER_LBA;
124 AlternateLba = ParentBlockDev->LastBlock;
125 } else {
126 Lba = ParentBlockDev->LastBlock;
127 AlternateLba = PRIMARY_PART_HEADER_LBA;
128 }
129
130 if ((PartHdr->Header.Signature != EFI_PTAB_HEADER_ID) ||
131 (PartHdr->Header.Revision != 0x00010000) ||
132 (PartHdr->Header.HeaderSize < 92) ||
133 (PartHdr->Header.HeaderSize > ParentBlockDev->BlockSize) ||
134 (!PartitionCheckGptHeaderCRC (PartHdr)) ||
135 (PartHdr->Header.Reserved != 0)
136 )
137 {
138 DEBUG ((DEBUG_ERROR, "Invalid efi partition table header\n"));
139 return FALSE;
140 }
141
142 //
143 // | Block0 | Block1 |Block2 ~ FirstUsableLBA - 1|FirstUsableLBA, ... ,LastUsableLBA|LastUsableLBA+1 ~ LastBlock-1| LastBlock |
144 // |Protective MBR|Primary Header|Entry Array(At Least 16384)| Partition | Entry Array(At Least 16384) |BackUp Header|
145 //
146 // 1. Protective MBR is fixed at Block 0.
147 // 2. Primary Header is fixed at Block 1.
148 // 3. Backup Header is fixed at LastBlock.
149 // 4. Must be remain 128*128 bytes for primary entry array.
150 // 5. Must be remain 128*128 bytes for backup entry array.
151 // 6. SizeOfPartitionEntry must be equals to 128 * 2^n.
152 //
153 if ((PartHdr->MyLBA != Lba) ||
154 (PartHdr->AlternateLBA != AlternateLba) ||
155 (PartHdr->FirstUsableLBA < 2 + EFI_SIZE_TO_BLOCKS (EFI_GPT_PART_ENTRY_MIN_SIZE, ParentBlockDev->BlockSize)) ||
156 (PartHdr->LastUsableLBA > ParentBlockDev->LastBlock - 1 - EFI_SIZE_TO_BLOCKS (EFI_GPT_PART_ENTRY_MIN_SIZE, ParentBlockDev->BlockSize)) ||
157 (PartHdr->FirstUsableLBA > PartHdr->LastUsableLBA) ||
158 (PartHdr->PartitionEntryLBA < 2) ||
159 (PartHdr->PartitionEntryLBA > ParentBlockDev->LastBlock - 1) ||
160 ((PartHdr->PartitionEntryLBA >= PartHdr->FirstUsableLBA) && (PartHdr->PartitionEntryLBA <= PartHdr->LastUsableLBA)) ||
161 (PartHdr->SizeOfPartitionEntry%128 != 0) ||
162 (PartHdr->SizeOfPartitionEntry != sizeof (EFI_PARTITION_ENTRY))
163 )
164 {
165 DEBUG ((DEBUG_ERROR, "Invalid efi partition table header\n"));
166 return FALSE;
167 }
168
169 //
170 // Ensure the NumberOfPartitionEntries * SizeOfPartitionEntry doesn't overflow.
171 //
172 if (PartHdr->NumberOfPartitionEntries > DivU64x32 (MAX_UINTN, PartHdr->SizeOfPartitionEntry)) {
173 DEBUG ((DEBUG_ERROR, "Memory overflow in GPT Entry Array\n"));
174 return FALSE;
175 }
176
177 PartitionEntryArraySize = MultU64x32 (PartHdr->NumberOfPartitionEntries, PartHdr->SizeOfPartitionEntry);
178 EntryArraySizeRemainder = 0;
179 PartitionEntryBlockNumb = DivU64x32Remainder (PartitionEntryArraySize, ParentBlockDev->BlockSize, &EntryArraySizeRemainder);
180 if (EntryArraySizeRemainder != 0) {
181 PartitionEntryBlockNumb++;
182 }
183
184 if (IsPrimaryHeader) {
185 EntryArrayLastLba = PartHdr->FirstUsableLBA;
186 } else {
187 EntryArrayLastLba = ParentBlockDev->LastBlock;
188 }
189
190 //
191 // Make sure partition entry array not overlaps with partition area or the LastBlock.
192 //
193 if (PartHdr->PartitionEntryLBA + PartitionEntryBlockNumb > EntryArrayLastLba) {
194 DEBUG ((DEBUG_ERROR, "GPT Partition Entry Array Error!\n"));
195 DEBUG ((DEBUG_ERROR, "PartitionEntryArraySize = %lu.\n", PartitionEntryArraySize));
196 DEBUG ((DEBUG_ERROR, "PartitionEntryLBA = %lu.\n", PartHdr->PartitionEntryLBA));
197 DEBUG ((DEBUG_ERROR, "PartitionEntryBlockNumb = %lu.\n", PartitionEntryBlockNumb));
198 DEBUG ((DEBUG_ERROR, "EntryArrayLastLba = %lu.\n", EntryArrayLastLba));
199 return FALSE;
200 }
201
202 return TRUE;
203}
204
205/**
206 This function is used to verify each partition in block device.
207
208 @param[in] PrivateData The global memory map
209 @param[in] ParentBlockDevNo The parent block device
210 @param[in] PartHdr Stores the partition table that is read
211
212 @retval TRUE The partition is valid
213 @retval FALSE The partition is not valid
214
215**/
216BOOLEAN
217PartitionCheckGptEntryArray (
218 IN PEI_FAT_PRIVATE_DATA *PrivateData,
219 IN UINTN ParentBlockDevNo,
220 IN EFI_PARTITION_TABLE_HEADER *PartHdr
221 )
222{
223 EFI_STATUS Status;
224 PEI_FAT_BLOCK_DEVICE *ParentBlockDev;
225 PEI_FAT_BLOCK_DEVICE *BlockDevPtr;
226
227 UINT64 PartitionEntryArraySize;
228 UINT64 PartitionEntryBlockNumb;
229 UINT32 EntryArraySizeRemainder;
230
231 EFI_PARTITION_ENTRY *PartitionEntryBuffer;
232 EFI_PARTITION_ENTRY_STATUS *PartitionEntryStatus;
233
234 BOOLEAN Found;
235 EFI_LBA StartingLBA;
236 EFI_LBA EndingLBA;
237 UINTN Index;
238 UINTN Index1;
239 UINTN Index2;
240 EFI_PARTITION_ENTRY *Entry;
241
242 PartitionEntryBuffer = NULL;
243 PartitionEntryStatus = NULL;
244
245 ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);
246 Found = FALSE;
247
248 PartitionEntryArraySize = MultU64x32 (PartHdr->NumberOfPartitionEntries, PartHdr->SizeOfPartitionEntry);
249 EntryArraySizeRemainder = 0;
250 PartitionEntryBlockNumb = DivU64x32Remainder (PartitionEntryArraySize, ParentBlockDev->BlockSize, &EntryArraySizeRemainder);
251 if (EntryArraySizeRemainder != 0) {
252 PartitionEntryBlockNumb++;
253 }
254
255 PartitionEntryArraySize = MultU64x32 (PartitionEntryBlockNumb, ParentBlockDev->BlockSize);
256
257 PartitionEntryBuffer = (EFI_PARTITION_ENTRY *)AllocatePages (EFI_SIZE_TO_PAGES ((UINTN)PartitionEntryArraySize));
258 if (PartitionEntryBuffer == NULL) {
259 DEBUG ((DEBUG_ERROR, "Allocate memory error!\n"));
260 goto EXIT;
261 }
262
263 PartitionEntryStatus = (EFI_PARTITION_ENTRY_STATUS *)AllocatePages (EFI_SIZE_TO_PAGES (PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS)));
264 if (PartitionEntryStatus == NULL) {
265 DEBUG ((DEBUG_ERROR, "Allocate memory error!\n"));
266 goto EXIT;
267 }
268
269 ZeroMem (PartitionEntryStatus, PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS));
270
271 Status = FatReadBlock (
272 PrivateData,
273 ParentBlockDevNo,
274 PartHdr->PartitionEntryLBA,
275 (UINTN)PartitionEntryArraySize,
276 PartitionEntryBuffer
277 );
278 if (EFI_ERROR (Status)) {
279 DEBUG ((DEBUG_ERROR, "Read partition entry array error!\n"));
280 goto EXIT;
281 }
282
283 if (!PartitionCheckGptEntryArrayCRC (PartHdr, PartitionEntryBuffer)) {
284 DEBUG ((DEBUG_ERROR, "Partition entries CRC check fail\n"));
285 goto EXIT;
286 }
287
288 for (Index1 = 0; Index1 < PartHdr->NumberOfPartitionEntries; Index1++) {
289 Entry = (EFI_PARTITION_ENTRY *)((UINT8 *)PartitionEntryBuffer + Index1 * PartHdr->SizeOfPartitionEntry);
290 if (CompareGuid (&Entry->PartitionTypeGUID, &gEfiPartTypeUnusedGuid)) {
291 continue;
292 }
293
294 StartingLBA = Entry->StartingLBA;
295 EndingLBA = Entry->EndingLBA;
296 if ((StartingLBA > EndingLBA) ||
297 (StartingLBA < PartHdr->FirstUsableLBA) ||
298 (StartingLBA > PartHdr->LastUsableLBA) ||
299 (EndingLBA < PartHdr->FirstUsableLBA) ||
300 (EndingLBA > PartHdr->LastUsableLBA)
301 )
302 {
303 PartitionEntryStatus[Index1].OutOfRange = TRUE;
304 continue;
305 }
306
307 if ((Entry->Attributes & BIT1) != 0) {
308 //
309 // If Bit 1 is set, this indicate that this is an OS specific GUID partition.
310 //
311 PartitionEntryStatus[Index1].OsSpecific = TRUE;
312 }
313
314 for (Index2 = Index1 + 1; Index2 < PartHdr->NumberOfPartitionEntries; Index2++) {
315 Entry = (EFI_PARTITION_ENTRY *)((UINT8 *)PartitionEntryBuffer + Index2 * PartHdr->SizeOfPartitionEntry);
316 if (CompareGuid (&Entry->PartitionTypeGUID, &gEfiPartTypeUnusedGuid)) {
317 continue;
318 }
319
320 if ((Entry->EndingLBA >= StartingLBA) && (Entry->StartingLBA <= EndingLBA)) {
321 //
322 // This region overlaps with the Index1'th region
323 //
324 PartitionEntryStatus[Index1].Overlap = TRUE;
325 PartitionEntryStatus[Index2].Overlap = TRUE;
326 continue;
327 }
328 }
329 }
330
331 for (Index = 0; Index < PartHdr->NumberOfPartitionEntries; Index++) {
332 if (CompareGuid (&PartitionEntryBuffer[Index].PartitionTypeGUID, &gEfiPartTypeUnusedGuid) ||
333 PartitionEntryStatus[Index].OutOfRange ||
334 PartitionEntryStatus[Index].Overlap ||
335 PartitionEntryStatus[Index].OsSpecific)
336 {
337 //
338 // Don't use null EFI Partition Entries, Invalid Partition Entries or OS specific
339 // partition Entries
340 //
341 continue;
342 }
343
344 if (PrivateData->BlockDeviceCount >= PEI_FAT_MAX_BLOCK_DEVICE) {
345 break;
346 }
347
348 Found = TRUE;
349 BlockDevPtr = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);
350
351 BlockDevPtr->BlockSize = ParentBlockDev->BlockSize;
352 BlockDevPtr->LastBlock = PartitionEntryBuffer[Index].EndingLBA;
353 BlockDevPtr->IoAlign = ParentBlockDev->IoAlign;
354 BlockDevPtr->Logical = TRUE;
355 BlockDevPtr->PartitionChecked = FALSE;
356 BlockDevPtr->StartingPos = MultU64x32 (
357 PartitionEntryBuffer[Index].StartingLBA,
358 ParentBlockDev->BlockSize
359 );
360 BlockDevPtr->ParentDevNo = ParentBlockDevNo;
361
362 PrivateData->BlockDeviceCount++;
363
364 DEBUG ((DEBUG_INFO, "Find GPT Partition [0x%lx", PartitionEntryBuffer[Index].StartingLBA));
365 DEBUG ((DEBUG_INFO, ", 0x%lx]\n", BlockDevPtr->LastBlock));
366 DEBUG ((DEBUG_INFO, " BlockSize %x\n", BlockDevPtr->BlockSize));
367 }
368
369EXIT:
370 if (PartitionEntryBuffer != NULL) {
371 FreePages (PartitionEntryBuffer, EFI_SIZE_TO_PAGES ((UINTN)PartitionEntryArraySize));
372 }
373
374 if (PartitionEntryStatus != NULL) {
375 FreePages (PartitionEntryStatus, EFI_SIZE_TO_PAGES (PartHdr->NumberOfPartitionEntries * sizeof (EFI_PARTITION_ENTRY_STATUS)));
376 }
377
378 return Found;
379}
380
381/**
382 The function is used to check GPT structure, include GPT header and GPT entry array.
383
384 1. Check GPT header.
385 2. Check partition entry array.
386 3. Check each partitions.
387
388 @param[in] PrivateData The global memory map
389 @param[in] ParentBlockDevNo The parent block device
390 @param[in] IsPrimary Indicate primary or backup to be check
391
392 @retval TRUE Primary or backup GPT structure is valid.
393 @retval FALSE Both primary and backup are invalid.
394
395**/
396BOOLEAN
397PartitionCheckGptStructure (
398 IN PEI_FAT_PRIVATE_DATA *PrivateData,
399 IN UINTN ParentBlockDevNo,
400 IN BOOLEAN IsPrimary
401 )
402{
403 EFI_STATUS Status;
404 PEI_FAT_BLOCK_DEVICE *ParentBlockDev;
405 EFI_PARTITION_TABLE_HEADER *PartHdr;
406 EFI_PEI_LBA GptHeaderLBA;
407
408 ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);
409 PartHdr = (EFI_PARTITION_TABLE_HEADER *)PrivateData->BlockData;
410
411 if (IsPrimary) {
412 GptHeaderLBA = PRIMARY_PART_HEADER_LBA;
413 } else {
414 GptHeaderLBA = ParentBlockDev->LastBlock;
415 }
416
417 Status = FatReadBlock (
418 PrivateData,
419 ParentBlockDevNo,
420 GptHeaderLBA,
421 ParentBlockDev->BlockSize,
422 PartHdr
423 );
424 if (EFI_ERROR (Status)) {
425 return FALSE;
426 }
427
428 if (!PartitionCheckGptHeader (PrivateData, ParentBlockDevNo, IsPrimary, PartHdr)) {
429 return FALSE;
430 }
431
432 if (!PartitionCheckGptEntryArray (PrivateData, ParentBlockDevNo, PartHdr)) {
433 return FALSE;
434 }
435
436 return TRUE;
437}
438
439/**
440 This function is used to check protective MBR structure before checking GPT.
441
442 @param[in] PrivateData The global memory map
443 @param[in] ParentBlockDevNo The parent block device
444
445 @retval TRUE Valid protective MBR
446 @retval FALSE Invalid MBR
447**/
448BOOLEAN
449PartitionCheckProtectiveMbr (
450 IN PEI_FAT_PRIVATE_DATA *PrivateData,
451 IN UINTN ParentBlockDevNo
452 )
453{
454 EFI_STATUS Status;
455 MASTER_BOOT_RECORD *ProtectiveMbr;
456 MBR_PARTITION_RECORD *MbrPartition;
457 PEI_FAT_BLOCK_DEVICE *ParentBlockDev;
458 UINTN Index;
459
460 ProtectiveMbr = (MASTER_BOOT_RECORD *)PrivateData->BlockData;
461 ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);
462
463 //
464 // Read Protective MBR
465 //
466 Status = FatReadBlock (
467 PrivateData,
468 ParentBlockDevNo,
469 0,
470 ParentBlockDev->BlockSize,
471 ProtectiveMbr
472 );
473 if (EFI_ERROR (Status)) {
474 DEBUG ((DEBUG_ERROR, "GPT Error When Read Protective Mbr From Partition!\n"));
475 return FALSE;
476 }
477
478 if (ProtectiveMbr->Signature != MBR_SIGNATURE) {
479 DEBUG ((DEBUG_ERROR, "Protective Mbr Signature is invalid!\n"));
480 return FALSE;
481 }
482
483 //
484 // The partition define in UEFI Spec Table 17.
485 // Boot Code, Unique MBR Disk Signature, Unknown.
486 // These parts will not be used by UEFI, so we skip to check them.
487 //
488 for (Index = 0; Index < MAX_MBR_PARTITIONS; Index++) {
489 MbrPartition = (MBR_PARTITION_RECORD *)&ProtectiveMbr->Partition[Index];
490 if ((MbrPartition->BootIndicator == 0x00) &&
491 (MbrPartition->StartSector == 0x02) &&
492 (MbrPartition->OSIndicator == PMBR_GPT_PARTITION) &&
493 (UNPACK_UINT32 (MbrPartition->StartingLBA) == 1)
494 )
495 {
496 return TRUE;
497 }
498 }
499
500 DEBUG ((DEBUG_ERROR, "Protective Mbr, All Partition Entry Are Empty!\n"));
501 return FALSE;
502}
503
504/**
505 This function is used for finding GPT partition on block device.
506 As follow UEFI spec we should check protective MBR first and then
507 try to check both primary/backup GPT structures.
508
509 @param[in] PrivateData The global memory map
510 @param[in] ParentBlockDevNo The parent block device
511
512 @retval TRUE New partitions are detected and logical block devices
513 are added to block device array
514 @retval FALSE No new partitions are added
515
516**/
517BOOLEAN
518FatFindGptPartitions (
519 IN PEI_FAT_PRIVATE_DATA *PrivateData,
520 IN UINTN ParentBlockDevNo
521 )
522{
523 BOOLEAN Found;
524 PEI_FAT_BLOCK_DEVICE *ParentBlockDev;
525
526 if (ParentBlockDevNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
527 return FALSE;
528 }
529
530 ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);
531 if (ParentBlockDev->BlockSize > PEI_FAT_MAX_BLOCK_SIZE) {
532 DEBUG ((DEBUG_ERROR, "Device BlockSize %x exceed FAT_MAX_BLOCK_SIZE\n", ParentBlockDev->BlockSize));
533 return FALSE;
534 }
535
536 if (!PartitionCheckProtectiveMbr (PrivateData, ParentBlockDevNo)) {
537 return FALSE;
538 }
539
540 Found = PartitionCheckGptStructure (PrivateData, ParentBlockDevNo, TRUE);
541 if (!Found) {
542 DEBUG ((DEBUG_ERROR, "Primary GPT Header Error, Try to Check Backup GPT Header!\n"));
543 Found = PartitionCheckGptStructure (PrivateData, ParentBlockDevNo, FALSE);
544 }
545
546 if (Found) {
547 ParentBlockDev->PartitionChecked = TRUE;
548 }
549
550 return Found;
551}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette