1 /** @file 2 OVMF ACPI support using QEMU's fw-cfg interface 3 4 Copyright (c) 2008 - 2014, Intel Corporation. All rights reserved.<BR> 5 Copyright (C) 2012-2014, Red Hat, Inc. 6 7 This program and the accompanying materials 8 are licensed and made available under the terms and conditions of the BSD License 9 which accompanies this distribution. The full text of the license may be found at 10 http://opensource.org/licenses/bsd-license.php 11 12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 14 15 **/ 16 17 #include "AcpiPlatform.h" 18 #include "QemuLoader.h" 19 #include <Library/BaseMemoryLib.h> 20 #include <Library/MemoryAllocationLib.h> 21 #include <Library/QemuFwCfgLib.h> 22 #include <Library/DxeServicesTableLib.h> 23 #include <Library/PcdLib.h> 24 #include <Library/OrderedCollectionLib.h> 25 #include <IndustryStandard/Acpi.h> 26 27 28 // 29 // The user structure for the ordered collection that will track the fw_cfg 30 // blobs under processing. 31 // 32 typedef struct { 33 UINT8 File[QEMU_LOADER_FNAME_SIZE]; // NUL-terminated name of the fw_cfg 34 // blob. This is the ordering / search 35 // key. 36 UINTN Size; // The number of bytes in this blob. 37 UINT8 *Base; // Pointer to the blob data. 38 BOOLEAN HostsOnlyTableData; // TRUE iff the blob has been found to 39 // only contain data that is directly 40 // part of ACPI tables. 41 } BLOB; 42 43 44 /** 45 Compare a standalone key against a user structure containing an embedded key. 46 47 @param[in] StandaloneKey Pointer to the bare key. 48 49 @param[in] UserStruct Pointer to the user structure with the embedded 50 key. 51 52 @retval <0 If StandaloneKey compares less than UserStruct's key. 53 54 @retval 0 If StandaloneKey compares equal to UserStruct's key. 55 56 @retval >0 If StandaloneKey compares greater than UserStruct's key. 57 **/ 58 STATIC 59 INTN 60 EFIAPI 61 BlobKeyCompare ( 62 IN CONST VOID *StandaloneKey, 63 IN CONST VOID *UserStruct 64 ) 65 { 66 CONST BLOB *Blob; 67 68 Blob = UserStruct; 69 return AsciiStrCmp (StandaloneKey, (CONST CHAR8 *)Blob->File); 70 } 71 72 73 /** 74 Comparator function for two user structures. 75 76 @param[in] UserStruct1 Pointer to the first user structure. 77 78 @param[in] UserStruct2 Pointer to the second user structure. 79 80 @retval <0 If UserStruct1 compares less than UserStruct2. 81 82 @retval 0 If UserStruct1 compares equal to UserStruct2. 83 84 @retval >0 If UserStruct1 compares greater than UserStruct2. 85 **/ 86 STATIC 87 INTN 88 EFIAPI 89 BlobCompare ( 90 IN CONST VOID *UserStruct1, 91 IN CONST VOID *UserStruct2 92 ) 93 { 94 CONST BLOB *Blob1; 95 96 Blob1 = UserStruct1; 97 return BlobKeyCompare (Blob1->File, UserStruct2); 98 } 99 100 101 /** 102 Process a QEMU_LOADER_ALLOCATE command. 103 104 @param[in] Allocate The QEMU_LOADER_ALLOCATE command to process. 105 106 @param[in,out] Tracker The ORDERED_COLLECTION tracking the BLOB user 107 structures created thus far. 108 109 @retval EFI_SUCCESS An area of whole AcpiNVS pages has been 110 allocated for the blob contents, and the 111 contents have been saved. A BLOB object (user 112 structure) has been allocated from pool memory, 113 referencing the blob contents. The BLOB user 114 structure has been linked into Tracker. 115 116 @retval EFI_PROTOCOL_ERROR Malformed fw_cfg file name has been found in 117 Allocate, or the Allocate command references a 118 file that is already known by Tracker. 119 120 @retval EFI_UNSUPPORTED Unsupported alignment request has been found in 121 Allocate. 122 123 @retval EFI_OUT_OF_RESOURCES Pool allocation failed. 124 125 @return Error codes from QemuFwCfgFindFile() and 126 gBS->AllocatePages(). 127 **/ 128 STATIC 129 EFI_STATUS 130 EFIAPI 131 ProcessCmdAllocate ( 132 IN CONST QEMU_LOADER_ALLOCATE *Allocate, 133 IN OUT ORDERED_COLLECTION *Tracker 134 ) 135 { 136 FIRMWARE_CONFIG_ITEM FwCfgItem; 137 UINTN FwCfgSize; 138 EFI_STATUS Status; 139 UINTN NumPages; 140 EFI_PHYSICAL_ADDRESS Address; 141 BLOB *Blob; 142 143 if (Allocate->File[QEMU_LOADER_FNAME_SIZE - 1] != '\0') { 144 DEBUG ((EFI_D_ERROR, "%a: malformed file name\n", __FUNCTION__)); 145 return EFI_PROTOCOL_ERROR; 146 } 147 148 if (Allocate->Alignment > EFI_PAGE_SIZE) { 149 DEBUG ((EFI_D_ERROR, "%a: unsupported alignment 0x%x\n", __FUNCTION__, 150 Allocate->Alignment)); 151 return EFI_UNSUPPORTED; 152 } 153 154 Status = QemuFwCfgFindFile ((CHAR8 *)Allocate->File, &FwCfgItem, &FwCfgSize); 155 if (EFI_ERROR (Status)) { 156 DEBUG ((EFI_D_ERROR, "%a: QemuFwCfgFindFile(\"%a\"): %r\n", __FUNCTION__, 157 Allocate->File, Status)); 158 return Status; 159 } 160 161 NumPages = EFI_SIZE_TO_PAGES (FwCfgSize); 162 Address = 0xFFFFFFFF; 163 Status = gBS->AllocatePages (AllocateMaxAddress, EfiACPIMemoryNVS, NumPages, 164 &Address); 165 if (EFI_ERROR (Status)) { 166 return Status; 167 } 168 169 Blob = AllocatePool (sizeof *Blob); 170 if (Blob == NULL) { 171 Status = EFI_OUT_OF_RESOURCES; 172 goto FreePages; 173 } 174 CopyMem (Blob->File, Allocate->File, QEMU_LOADER_FNAME_SIZE); 175 Blob->Size = FwCfgSize; 176 Blob->Base = (VOID *)(UINTN)Address; 177 Blob->HostsOnlyTableData = TRUE; 178 179 Status = OrderedCollectionInsert (Tracker, NULL, Blob); 180 if (Status == RETURN_ALREADY_STARTED) { 181 DEBUG ((EFI_D_ERROR, "%a: duplicated file \"%a\"\n", __FUNCTION__, 182 Allocate->File)); 183 Status = EFI_PROTOCOL_ERROR; 184 } 185 if (EFI_ERROR (Status)) { 186 goto FreeBlob; 187 } 188 189 QemuFwCfgSelectItem (FwCfgItem); 190 QemuFwCfgReadBytes (FwCfgSize, Blob->Base); 191 ZeroMem (Blob->Base + Blob->Size, EFI_PAGES_TO_SIZE (NumPages) - Blob->Size); 192 193 DEBUG ((EFI_D_VERBOSE, "%a: File=\"%a\" Alignment=0x%x Zone=%d Size=0x%Lx " 194 "Address=0x%Lx\n", __FUNCTION__, Allocate->File, Allocate->Alignment, 195 Allocate->Zone, (UINT64)Blob->Size, (UINT64)(UINTN)Blob->Base)); 196 return EFI_SUCCESS; 197 198 FreeBlob: 199 FreePool (Blob); 200 201 FreePages: 202 gBS->FreePages (Address, NumPages); 203 204 return Status; 205 } 206 207 208 /** 209 Process a QEMU_LOADER_ADD_POINTER command. 210 211 @param[in] AddPointer The QEMU_LOADER_ADD_POINTER command to process. 212 213 @param[in] Tracker The ORDERED_COLLECTION tracking the BLOB user 214 structures created thus far. 215 216 @retval EFI_PROTOCOL_ERROR Malformed fw_cfg file name(s) have been found in 217 AddPointer, or the AddPointer command references 218 a file unknown to Tracker, or the pointer to 219 relocate has invalid location, size, or value, or 220 the relocated pointer value is not representable 221 in the given pointer size. 222 223 @retval EFI_SUCCESS The pointer field inside the pointer blob has 224 been relocated. 225 **/ 226 STATIC 227 EFI_STATUS 228 EFIAPI 229 ProcessCmdAddPointer ( 230 IN CONST QEMU_LOADER_ADD_POINTER *AddPointer, 231 IN CONST ORDERED_COLLECTION *Tracker 232 ) 233 { 234 ORDERED_COLLECTION_ENTRY *TrackerEntry, *TrackerEntry2; 235 BLOB *Blob, *Blob2; 236 UINT8 *PointerField; 237 UINT64 PointerValue; 238 239 if (AddPointer->PointerFile[QEMU_LOADER_FNAME_SIZE - 1] != '\0' || 240 AddPointer->PointeeFile[QEMU_LOADER_FNAME_SIZE - 1] != '\0') { 241 DEBUG ((EFI_D_ERROR, "%a: malformed file name\n", __FUNCTION__)); 242 return EFI_PROTOCOL_ERROR; 243 } 244 245 TrackerEntry = OrderedCollectionFind (Tracker, AddPointer->PointerFile); 246 TrackerEntry2 = OrderedCollectionFind (Tracker, AddPointer->PointeeFile); 247 if (TrackerEntry == NULL || TrackerEntry2 == NULL) { 248 DEBUG ((EFI_D_ERROR, "%a: invalid blob reference(s) \"%a\" / \"%a\"\n", 249 __FUNCTION__, AddPointer->PointerFile, AddPointer->PointeeFile)); 250 return EFI_PROTOCOL_ERROR; 251 } 252 253 Blob = OrderedCollectionUserStruct (TrackerEntry); 254 Blob2 = OrderedCollectionUserStruct (TrackerEntry2); 255 if ((AddPointer->PointerSize != 1 && AddPointer->PointerSize != 2 && 256 AddPointer->PointerSize != 4 && AddPointer->PointerSize != 8) || 257 Blob->Size < AddPointer->PointerSize || 258 Blob->Size - AddPointer->PointerSize < AddPointer->PointerOffset) { 259 DEBUG ((EFI_D_ERROR, "%a: invalid pointer location or size in \"%a\"\n", 260 __FUNCTION__, AddPointer->PointerFile)); 261 return EFI_PROTOCOL_ERROR; 262 } 263 264 PointerField = Blob->Base + AddPointer->PointerOffset; 265 PointerValue = 0; 266 CopyMem (&PointerValue, PointerField, AddPointer->PointerSize); 267 if (PointerValue >= Blob2->Size) { 268 DEBUG ((EFI_D_ERROR, "%a: invalid pointer value in \"%a\"\n", __FUNCTION__, 269 AddPointer->PointerFile)); 270 return EFI_PROTOCOL_ERROR; 271 } 272 273 // 274 // The memory allocation system ensures that the address of the byte past the 275 // last byte of any allocated object is expressible (no wraparound). 276 // 277 ASSERT ((UINTN)Blob2->Base <= MAX_ADDRESS - Blob2->Size); 278 279 PointerValue += (UINT64)(UINTN)Blob2->Base; 280 if (RShiftU64 ( 281 RShiftU64 (PointerValue, AddPointer->PointerSize * 8 - 1), 1) != 0) { 282 DEBUG ((EFI_D_ERROR, "%a: relocated pointer value unrepresentable in " 283 "\"%a\"\n", __FUNCTION__, AddPointer->PointerFile)); 284 return EFI_PROTOCOL_ERROR; 285 } 286 287 CopyMem (PointerField, &PointerValue, AddPointer->PointerSize); 288 289 DEBUG ((EFI_D_VERBOSE, "%a: PointerFile=\"%a\" PointeeFile=\"%a\" " 290 "PointerOffset=0x%x PointerSize=%d\n", __FUNCTION__, 291 AddPointer->PointerFile, AddPointer->PointeeFile, 292 AddPointer->PointerOffset, AddPointer->PointerSize)); 293 return EFI_SUCCESS; 294 } 295 296 297 /** 298 Process a QEMU_LOADER_ADD_CHECKSUM command. 299 300 @param[in] AddChecksum The QEMU_LOADER_ADD_CHECKSUM command to process. 301 302 @param[in] Tracker The ORDERED_COLLECTION tracking the BLOB user 303 structures created thus far. 304 305 @retval EFI_PROTOCOL_ERROR Malformed fw_cfg file name has been found in 306 AddChecksum, or the AddChecksum command 307 references a file unknown to Tracker, or the 308 range to checksum is invalid. 309 310 @retval EFI_SUCCESS The requested range has been checksummed. 311 **/ 312 STATIC 313 EFI_STATUS 314 EFIAPI 315 ProcessCmdAddChecksum ( 316 IN CONST QEMU_LOADER_ADD_CHECKSUM *AddChecksum, 317 IN CONST ORDERED_COLLECTION *Tracker 318 ) 319 { 320 ORDERED_COLLECTION_ENTRY *TrackerEntry; 321 BLOB *Blob; 322 323 if (AddChecksum->File[QEMU_LOADER_FNAME_SIZE - 1] != '\0') { 324 DEBUG ((EFI_D_ERROR, "%a: malformed file name\n", __FUNCTION__)); 325 return EFI_PROTOCOL_ERROR; 326 } 327 328 TrackerEntry = OrderedCollectionFind (Tracker, AddChecksum->File); 329 if (TrackerEntry == NULL) { 330 DEBUG ((EFI_D_ERROR, "%a: invalid blob reference \"%a\"\n", __FUNCTION__, 331 AddChecksum->File)); 332 return EFI_PROTOCOL_ERROR; 333 } 334 335 Blob = OrderedCollectionUserStruct (TrackerEntry); 336 if (Blob->Size <= AddChecksum->ResultOffset || 337 Blob->Size < AddChecksum->Length || 338 Blob->Size - AddChecksum->Length < AddChecksum->Start) { 339 DEBUG ((EFI_D_ERROR, "%a: invalid checksum range in \"%a\"\n", 340 __FUNCTION__, AddChecksum->File)); 341 return EFI_PROTOCOL_ERROR; 342 } 343 344 Blob->Base[AddChecksum->ResultOffset] = CalculateCheckSum8 ( 345 Blob->Base + AddChecksum->Start, 346 AddChecksum->Length 347 ); 348 DEBUG ((EFI_D_VERBOSE, "%a: File=\"%a\" ResultOffset=0x%x Start=0x%x " 349 "Length=0x%x\n", __FUNCTION__, AddChecksum->File, 350 AddChecksum->ResultOffset, AddChecksum->Start, AddChecksum->Length)); 351 return EFI_SUCCESS; 352 } 353 354 355 // 356 // We'll be saving the keys of installed tables so that we can roll them back 357 // in case of failure. 128 tables should be enough for anyone (TM). 358 // 359 #define INSTALLED_TABLES_MAX 128 360 361 /** 362 Process a QEMU_LOADER_ADD_POINTER command in order to see if its target byte 363 array is an ACPI table, and if so, install it. 364 365 This function assumes that the entire QEMU linker/loader command file has 366 been processed successfully in a prior first pass. 367 368 @param[in] AddPointer The QEMU_LOADER_ADD_POINTER command to process. 369 370 @param[in] Tracker The ORDERED_COLLECTION tracking the BLOB user 371 structures. 372 373 @param[in] AcpiProtocol The ACPI table protocol used to install tables. 374 375 @param[in,out] InstalledKey On input, an array of INSTALLED_TABLES_MAX UINTN 376 elements, allocated by the caller. On output, 377 the function will have stored (appended) the 378 AcpiProtocol-internal key of the ACPI table that 379 the function has installed, if the AddPointer 380 command identified an ACPI table that is 381 different from RSDT and XSDT. 382 383 @param[in,out] NumInstalled On input, the number of entries already used in 384 InstalledKey; it must be in [0, 385 INSTALLED_TABLES_MAX] inclusive. On output, the 386 parameter is incremented if the AddPointer 387 command identified an ACPI table that is 388 different from RSDT and XSDT. 389 390 @retval EFI_INVALID_PARAMETER NumInstalled was outside the allowed range on 391 input. 392 393 @retval EFI_OUT_OF_RESOURCES The AddPointer command identified an ACPI 394 table different from RSDT and XSDT, but there 395 was no more room in InstalledKey. 396 397 @retval EFI_SUCCESS AddPointer has been processed. Either an ACPI 398 table different from RSDT and XSDT has been 399 installed (reflected by InstalledKey and 400 NumInstalled), or RSDT or XSDT has been 401 identified but not installed, or the fw_cfg 402 blob pointed-into by AddPointer has been 403 marked as hosting something else than just 404 direct ACPI table contents. 405 406 @return Error codes returned by 407 AcpiProtocol->InstallAcpiTable(). 408 **/ 409 STATIC 410 EFI_STATUS 411 EFIAPI 412 Process2ndPassCmdAddPointer ( 413 IN CONST QEMU_LOADER_ADD_POINTER *AddPointer, 414 IN CONST ORDERED_COLLECTION *Tracker, 415 IN EFI_ACPI_TABLE_PROTOCOL *AcpiProtocol, 416 IN OUT UINTN InstalledKey[INSTALLED_TABLES_MAX], 417 IN OUT INT32 *NumInstalled 418 ) 419 { 420 CONST ORDERED_COLLECTION_ENTRY *TrackerEntry; 421 CONST ORDERED_COLLECTION_ENTRY *TrackerEntry2; 422 CONST BLOB *Blob; 423 BLOB *Blob2; 424 CONST UINT8 *PointerField; 425 UINT64 PointerValue; 426 UINTN Blob2Remaining; 427 UINTN TableSize; 428 CONST EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *Facs; 429 CONST EFI_ACPI_DESCRIPTION_HEADER *Header; 430 EFI_STATUS Status; 431 432 if (*NumInstalled < 0 || *NumInstalled > INSTALLED_TABLES_MAX) { 433 return EFI_INVALID_PARAMETER; 434 } 435 436 TrackerEntry = OrderedCollectionFind (Tracker, AddPointer->PointerFile); 437 TrackerEntry2 = OrderedCollectionFind (Tracker, AddPointer->PointeeFile); 438 Blob = OrderedCollectionUserStruct (TrackerEntry); 439 Blob2 = OrderedCollectionUserStruct (TrackerEntry2); 440 PointerField = Blob->Base + AddPointer->PointerOffset; 441 PointerValue = 0; 442 CopyMem (&PointerValue, PointerField, AddPointer->PointerSize); 443 444 // 445 // We assert that PointerValue falls inside Blob2's contents. This is ensured 446 // by the Blob2->Size check and later checks in ProcessCmdAddPointer(). 447 // 448 Blob2Remaining = (UINTN)Blob2->Base; 449 ASSERT(PointerValue >= Blob2Remaining); 450 Blob2Remaining += Blob2->Size; 451 ASSERT (PointerValue < Blob2Remaining); 452 453 Blob2Remaining -= (UINTN) PointerValue; 454 DEBUG ((EFI_D_VERBOSE, "%a: checking for ACPI header in \"%a\" at 0x%Lx " 455 "(remaining: 0x%Lx): ", __FUNCTION__, AddPointer->PointeeFile, 456 PointerValue, (UINT64)Blob2Remaining)); 457 458 TableSize = 0; 459 460 // 461 // To make our job simple, the FACS has a custom header. Sigh. 462 // 463 if (sizeof *Facs <= Blob2Remaining) { 464 Facs = (EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *)(UINTN)PointerValue; 465 466 if (Facs->Length >= sizeof *Facs && 467 Facs->Length <= Blob2Remaining && 468 Facs->Signature == 469 EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE) { 470 DEBUG ((EFI_D_VERBOSE, "found \"%-4.4a\" size 0x%x\n", 471 (CONST CHAR8 *)&Facs->Signature, Facs->Length)); 472 TableSize = Facs->Length; 473 } 474 } 475 476 // 477 // check for the uniform tables 478 // 479 if (TableSize == 0 && sizeof *Header <= Blob2Remaining) { 480 Header = (EFI_ACPI_DESCRIPTION_HEADER *)(UINTN)PointerValue; 481 482 if (Header->Length >= sizeof *Header && 483 Header->Length <= Blob2Remaining && 484 CalculateSum8 ((CONST UINT8 *)Header, Header->Length) == 0) { 485 // 486 // This looks very much like an ACPI table from QEMU: 487 // - Length field consistent with both ACPI and containing blob size 488 // - checksum is correct 489 // 490 DEBUG ((EFI_D_VERBOSE, "found \"%-4.4a\" size 0x%x\n", 491 (CONST CHAR8 *)&Header->Signature, Header->Length)); 492 TableSize = Header->Length; 493 494 // 495 // Skip RSDT and XSDT because those are handled by 496 // EFI_ACPI_TABLE_PROTOCOL automatically. 497 if (Header->Signature == 498 EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE || 499 Header->Signature == 500 EFI_ACPI_2_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE) { 501 return EFI_SUCCESS; 502 } 503 } 504 } 505 506 if (TableSize == 0) { 507 DEBUG ((EFI_D_VERBOSE, "not found; marking fw_cfg blob as opaque\n")); 508 Blob2->HostsOnlyTableData = FALSE; 509 return EFI_SUCCESS; 510 } 511 512 if (*NumInstalled == INSTALLED_TABLES_MAX) { 513 DEBUG ((EFI_D_ERROR, "%a: can't install more than %d tables\n", 514 __FUNCTION__, INSTALLED_TABLES_MAX)); 515 return EFI_OUT_OF_RESOURCES; 516 } 517 518 Status = AcpiProtocol->InstallAcpiTable (AcpiProtocol, 519 (VOID *)(UINTN)PointerValue, TableSize, 520 &InstalledKey[*NumInstalled]); 521 if (EFI_ERROR (Status)) { 522 DEBUG ((EFI_D_ERROR, "%a: InstallAcpiTable(): %r\n", __FUNCTION__, 523 Status)); 524 return Status; 525 } 526 ++*NumInstalled; 527 return EFI_SUCCESS; 528 } 529 530 531 /** 532 Download, process, and install ACPI table data from the QEMU loader 533 interface. 534 535 @param[in] AcpiProtocol The ACPI table protocol used to install tables. 536 537 @retval EFI_UNSUPPORTED Firmware configuration is unavailable, or QEMU 538 loader command with unsupported parameters 539 has been found. 540 541 @retval EFI_NOT_FOUND The host doesn't export the required fw_cfg 542 files. 543 544 @retval EFI_OUT_OF_RESOURCES Memory allocation failed, or more than 545 INSTALLED_TABLES_MAX tables found. 546 547 @retval EFI_PROTOCOL_ERROR Found invalid fw_cfg contents. 548 549 @return Status codes returned by 550 AcpiProtocol->InstallAcpiTable(). 551 552 **/ 553 EFI_STATUS 554 EFIAPI 555 InstallQemuFwCfgTables ( 556 IN EFI_ACPI_TABLE_PROTOCOL *AcpiProtocol 557 ) 558 { 559 EFI_STATUS Status; 560 FIRMWARE_CONFIG_ITEM FwCfgItem; 561 UINTN FwCfgSize; 562 QEMU_LOADER_ENTRY *LoaderStart; 563 CONST QEMU_LOADER_ENTRY *LoaderEntry, *LoaderEnd; 564 ORIGINAL_ATTRIBUTES *OriginalPciAttributes; 565 UINTN OriginalPciAttributesCount; 566 ORDERED_COLLECTION *Tracker; 567 UINTN *InstalledKey; 568 INT32 Installed; 569 ORDERED_COLLECTION_ENTRY *TrackerEntry, *TrackerEntry2; 570 571 Status = QemuFwCfgFindFile ("etc/table-loader", &FwCfgItem, &FwCfgSize); 572 if (EFI_ERROR (Status)) { 573 return Status; 574 } 575 if (FwCfgSize % sizeof *LoaderEntry != 0) { 576 DEBUG ((EFI_D_ERROR, "%a: \"etc/table-loader\" has invalid size 0x%Lx\n", 577 __FUNCTION__, (UINT64)FwCfgSize)); 578 return EFI_PROTOCOL_ERROR; 579 } 580 581 LoaderStart = AllocatePool (FwCfgSize); 582 if (LoaderStart == NULL) { 583 return EFI_OUT_OF_RESOURCES; 584 } 585 EnablePciDecoding (&OriginalPciAttributes, &OriginalPciAttributesCount); 586 QemuFwCfgSelectItem (FwCfgItem); 587 QemuFwCfgReadBytes (FwCfgSize, LoaderStart); 588 RestorePciDecoding (OriginalPciAttributes, OriginalPciAttributesCount); 589 LoaderEnd = LoaderStart + FwCfgSize / sizeof *LoaderEntry; 590 591 Tracker = OrderedCollectionInit (BlobCompare, BlobKeyCompare); 592 if (Tracker == NULL) { 593 Status = EFI_OUT_OF_RESOURCES; 594 goto FreeLoader; 595 } 596 597 // 598 // first pass: process the commands 599 // 600 for (LoaderEntry = LoaderStart; LoaderEntry < LoaderEnd; ++LoaderEntry) { 601 switch (LoaderEntry->Type) { 602 case QemuLoaderCmdAllocate: 603 Status = ProcessCmdAllocate (&LoaderEntry->Command.Allocate, Tracker); 604 break; 605 606 case QemuLoaderCmdAddPointer: 607 Status = ProcessCmdAddPointer (&LoaderEntry->Command.AddPointer, 608 Tracker); 609 break; 610 611 case QemuLoaderCmdAddChecksum: 612 Status = ProcessCmdAddChecksum (&LoaderEntry->Command.AddChecksum, 613 Tracker); 614 break; 615 616 default: 617 DEBUG ((EFI_D_VERBOSE, "%a: unknown loader command: 0x%x\n", 618 __FUNCTION__, LoaderEntry->Type)); 619 break; 620 } 621 622 if (EFI_ERROR (Status)) { 623 goto FreeTracker; 624 } 625 } 626 627 InstalledKey = AllocatePool (INSTALLED_TABLES_MAX * sizeof *InstalledKey); 628 if (InstalledKey == NULL) { 629 Status = EFI_OUT_OF_RESOURCES; 630 goto FreeTracker; 631 } 632 633 // 634 // second pass: identify and install ACPI tables 635 // 636 Installed = 0; 637 for (LoaderEntry = LoaderStart; LoaderEntry < LoaderEnd; ++LoaderEntry) { 638 if (LoaderEntry->Type == QemuLoaderCmdAddPointer) { 639 Status = Process2ndPassCmdAddPointer (&LoaderEntry->Command.AddPointer, 640 Tracker, AcpiProtocol, InstalledKey, &Installed); 641 if (EFI_ERROR (Status)) { 642 break; 643 } 644 } 645 } 646 647 if (EFI_ERROR (Status)) { 648 // 649 // roll back partial installation 650 // 651 while (Installed > 0) { 652 --Installed; 653 AcpiProtocol->UninstallAcpiTable (AcpiProtocol, InstalledKey[Installed]); 654 } 655 } else { 656 DEBUG ((EFI_D_INFO, "%a: installed %d tables\n", __FUNCTION__, Installed)); 657 } 658 659 FreePool (InstalledKey); 660 661 FreeTracker: 662 // 663 // Tear down the tracker infrastructure. Each fw_cfg blob will be left in 664 // place only if we're exiting with success and the blob hosts data that is 665 // not directly part of some ACPI table. 666 // 667 for (TrackerEntry = OrderedCollectionMin (Tracker); TrackerEntry != NULL; 668 TrackerEntry = TrackerEntry2) { 669 VOID *UserStruct; 670 BLOB *Blob; 671 672 TrackerEntry2 = OrderedCollectionNext (TrackerEntry); 673 OrderedCollectionDelete (Tracker, TrackerEntry, &UserStruct); 674 Blob = UserStruct; 675 676 if (EFI_ERROR (Status) || Blob->HostsOnlyTableData) { 677 DEBUG ((EFI_D_VERBOSE, "%a: freeing \"%a\"\n", __FUNCTION__, 678 Blob->File)); 679 gBS->FreePages ((UINTN)Blob->Base, EFI_SIZE_TO_PAGES (Blob->Size)); 680 } 681 FreePool (Blob); 682 } 683 OrderedCollectionUninit (Tracker); 684 685 FreeLoader: 686 FreePool (LoaderStart); 687 688 return Status; 689 } 690
