7b82da70ed
__FUNCTION__ is a pre-standard extension that gcc and Visual C++ among others support, while __func__ was standardized in C99. Since it's more standard, replace __FUNCTION__ with __func__ throughout MdeModulePkg. Signed-off-by: Rebecca Cran <rebecca@bsdio.com> Reviewed-by: Michael D Kinney <michael.d.kinney@intel.com> Reviewed-by: Ard Biesheuvel <ardb@kernel.org>
1380 lines
43 KiB
C
1380 lines
43 KiB
C
/** @file
|
|
Capsule update PEIM for UEFI2.0
|
|
|
|
Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>
|
|
Copyright (c) 2017, AMD Incorporated. All rights reserved.<BR>
|
|
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
**/
|
|
|
|
#include "Capsule.h"
|
|
|
|
#define DEFAULT_SG_LIST_HEADS (20)
|
|
|
|
#ifdef MDE_CPU_IA32
|
|
//
|
|
// Global Descriptor Table (GDT)
|
|
//
|
|
GLOBAL_REMOVE_IF_UNREFERENCED IA32_SEGMENT_DESCRIPTOR mGdtEntries[] = {
|
|
/* selector { Global Segment Descriptor } */
|
|
/* 0x00 */ {
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
|
|
}, // null descriptor
|
|
/* 0x08 */ {
|
|
{ 0xffff, 0, 0, 0x3, 1, 0, 1, 0xf, 0, 0, 1, 1, 0 }
|
|
}, // linear data segment descriptor
|
|
/* 0x10 */ {
|
|
{ 0xffff, 0, 0, 0xf, 1, 0, 1, 0xf, 0, 0, 1, 1, 0 }
|
|
}, // linear code segment descriptor
|
|
/* 0x18 */ {
|
|
{ 0xffff, 0, 0, 0x3, 1, 0, 1, 0xf, 0, 0, 1, 1, 0 }
|
|
}, // system data segment descriptor
|
|
/* 0x20 */ {
|
|
{ 0xffff, 0, 0, 0xb, 1, 0, 1, 0xf, 0, 0, 1, 1, 0 }
|
|
}, // system code segment descriptor
|
|
/* 0x28 */ {
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
|
|
}, // spare segment descriptor
|
|
/* 0x30 */ {
|
|
{ 0xffff, 0, 0, 0x3, 1, 0, 1, 0xf, 0, 0, 1, 1, 0 }
|
|
}, // system data segment descriptor
|
|
/* 0x38 */ {
|
|
{ 0xffff, 0, 0, 0xb, 1, 0, 1, 0xf, 0, 1, 0, 1, 0 }
|
|
}, // system code segment descriptor
|
|
/* 0x40 */ {
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
|
|
}, // spare segment descriptor
|
|
};
|
|
|
|
//
|
|
// IA32 Gdt register
|
|
//
|
|
GLOBAL_REMOVE_IF_UNREFERENCED CONST IA32_DESCRIPTOR mGdt = {
|
|
sizeof (mGdtEntries) - 1,
|
|
(UINTN)mGdtEntries
|
|
};
|
|
|
|
/**
|
|
The function will check if 1G page is supported.
|
|
|
|
@retval TRUE 1G page is supported.
|
|
@retval FALSE 1G page is not supported.
|
|
|
|
**/
|
|
BOOLEAN
|
|
IsPage1GSupport (
|
|
VOID
|
|
)
|
|
{
|
|
UINT32 RegEax;
|
|
UINT32 RegEdx;
|
|
BOOLEAN Page1GSupport;
|
|
|
|
Page1GSupport = FALSE;
|
|
if (PcdGetBool (PcdUse1GPageTable)) {
|
|
AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
|
|
if (RegEax >= 0x80000001) {
|
|
AsmCpuid (0x80000001, NULL, NULL, NULL, &RegEdx);
|
|
if ((RegEdx & BIT26) != 0) {
|
|
Page1GSupport = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Page1GSupport;
|
|
}
|
|
|
|
/**
|
|
Calculate the total size of page table.
|
|
|
|
@param[in] Page1GSupport 1G page support or not.
|
|
|
|
@return The size of page table.
|
|
|
|
**/
|
|
UINTN
|
|
CalculatePageTableSize (
|
|
IN BOOLEAN Page1GSupport
|
|
)
|
|
{
|
|
UINTN ExtraPageTablePages;
|
|
UINTN TotalPagesNum;
|
|
UINT8 PhysicalAddressBits;
|
|
UINT32 NumberOfPml4EntriesNeeded;
|
|
UINT32 NumberOfPdpEntriesNeeded;
|
|
|
|
//
|
|
// Create 4G page table by default,
|
|
// and let PF handler to handle > 4G request.
|
|
//
|
|
PhysicalAddressBits = 32;
|
|
ExtraPageTablePages = EXTRA_PAGE_TABLE_PAGES;
|
|
|
|
//
|
|
// Calculate the table entries needed.
|
|
//
|
|
if (PhysicalAddressBits <= 39 ) {
|
|
NumberOfPml4EntriesNeeded = 1;
|
|
NumberOfPdpEntriesNeeded = (UINT32)LShiftU64 (1, (PhysicalAddressBits - 30));
|
|
} else {
|
|
NumberOfPml4EntriesNeeded = (UINT32)LShiftU64 (1, (PhysicalAddressBits - 39));
|
|
NumberOfPdpEntriesNeeded = 512;
|
|
}
|
|
|
|
if (!Page1GSupport) {
|
|
TotalPagesNum = (NumberOfPdpEntriesNeeded + 1) * NumberOfPml4EntriesNeeded + 1;
|
|
} else {
|
|
TotalPagesNum = NumberOfPml4EntriesNeeded + 1;
|
|
}
|
|
|
|
TotalPagesNum += ExtraPageTablePages;
|
|
|
|
return EFI_PAGES_TO_SIZE (TotalPagesNum);
|
|
}
|
|
|
|
/**
|
|
Allocates and fills in the Page Directory and Page Table Entries to
|
|
establish a 4G page table.
|
|
|
|
@param[in] PageTablesAddress The base address of page table.
|
|
@param[in] Page1GSupport 1G page support or not.
|
|
|
|
**/
|
|
VOID
|
|
Create4GPageTables (
|
|
IN EFI_PHYSICAL_ADDRESS PageTablesAddress,
|
|
IN BOOLEAN Page1GSupport
|
|
)
|
|
{
|
|
UINT8 PhysicalAddressBits;
|
|
EFI_PHYSICAL_ADDRESS PageAddress;
|
|
UINTN IndexOfPml4Entries;
|
|
UINTN IndexOfPdpEntries;
|
|
UINTN IndexOfPageDirectoryEntries;
|
|
UINT32 NumberOfPml4EntriesNeeded;
|
|
UINT32 NumberOfPdpEntriesNeeded;
|
|
PAGE_MAP_AND_DIRECTORY_POINTER *PageMapLevel4Entry;
|
|
PAGE_MAP_AND_DIRECTORY_POINTER *PageMap;
|
|
PAGE_MAP_AND_DIRECTORY_POINTER *PageDirectoryPointerEntry;
|
|
PAGE_TABLE_ENTRY *PageDirectoryEntry;
|
|
UINTN BigPageAddress;
|
|
PAGE_TABLE_1G_ENTRY *PageDirectory1GEntry;
|
|
UINT64 AddressEncMask;
|
|
|
|
//
|
|
// Make sure AddressEncMask is contained to smallest supported address field.
|
|
//
|
|
AddressEncMask = PcdGet64 (PcdPteMemoryEncryptionAddressOrMask) & PAGING_1G_ADDRESS_MASK_64;
|
|
|
|
//
|
|
// Create 4G page table by default,
|
|
// and let PF handler to handle > 4G request.
|
|
//
|
|
PhysicalAddressBits = 32;
|
|
|
|
//
|
|
// Calculate the table entries needed.
|
|
//
|
|
if (PhysicalAddressBits <= 39 ) {
|
|
NumberOfPml4EntriesNeeded = 1;
|
|
NumberOfPdpEntriesNeeded = (UINT32)LShiftU64 (1, (PhysicalAddressBits - 30));
|
|
} else {
|
|
NumberOfPml4EntriesNeeded = (UINT32)LShiftU64 (1, (PhysicalAddressBits - 39));
|
|
NumberOfPdpEntriesNeeded = 512;
|
|
}
|
|
|
|
//
|
|
// Pre-allocate big pages to avoid later allocations.
|
|
//
|
|
BigPageAddress = (UINTN)PageTablesAddress;
|
|
|
|
//
|
|
// By architecture only one PageMapLevel4 exists - so lets allocate storage for it.
|
|
//
|
|
PageMap = (VOID *)BigPageAddress;
|
|
BigPageAddress += SIZE_4KB;
|
|
|
|
PageMapLevel4Entry = PageMap;
|
|
PageAddress = 0;
|
|
for (IndexOfPml4Entries = 0; IndexOfPml4Entries < NumberOfPml4EntriesNeeded; IndexOfPml4Entries++, PageMapLevel4Entry++) {
|
|
//
|
|
// Each PML4 entry points to a page of Page Directory Pointer entires.
|
|
// So lets allocate space for them and fill them in in the IndexOfPdpEntries loop.
|
|
//
|
|
PageDirectoryPointerEntry = (VOID *)BigPageAddress;
|
|
BigPageAddress += SIZE_4KB;
|
|
|
|
//
|
|
// Make a PML4 Entry
|
|
//
|
|
PageMapLevel4Entry->Uint64 = (UINT64)(UINTN)PageDirectoryPointerEntry | AddressEncMask;
|
|
PageMapLevel4Entry->Bits.ReadWrite = 1;
|
|
PageMapLevel4Entry->Bits.Present = 1;
|
|
|
|
if (Page1GSupport) {
|
|
PageDirectory1GEntry = (VOID *)PageDirectoryPointerEntry;
|
|
|
|
for (IndexOfPageDirectoryEntries = 0; IndexOfPageDirectoryEntries < 512; IndexOfPageDirectoryEntries++, PageDirectory1GEntry++, PageAddress += SIZE_1GB) {
|
|
//
|
|
// Fill in the Page Directory entries
|
|
//
|
|
PageDirectory1GEntry->Uint64 = (UINT64)PageAddress | AddressEncMask;
|
|
PageDirectory1GEntry->Bits.ReadWrite = 1;
|
|
PageDirectory1GEntry->Bits.Present = 1;
|
|
PageDirectory1GEntry->Bits.MustBe1 = 1;
|
|
}
|
|
} else {
|
|
for (IndexOfPdpEntries = 0; IndexOfPdpEntries < NumberOfPdpEntriesNeeded; IndexOfPdpEntries++, PageDirectoryPointerEntry++) {
|
|
//
|
|
// Each Directory Pointer entries points to a page of Page Directory entires.
|
|
// So allocate space for them and fill them in in the IndexOfPageDirectoryEntries loop.
|
|
//
|
|
PageDirectoryEntry = (VOID *)BigPageAddress;
|
|
BigPageAddress += SIZE_4KB;
|
|
|
|
//
|
|
// Fill in a Page Directory Pointer Entries
|
|
//
|
|
PageDirectoryPointerEntry->Uint64 = (UINT64)(UINTN)PageDirectoryEntry | AddressEncMask;
|
|
PageDirectoryPointerEntry->Bits.ReadWrite = 1;
|
|
PageDirectoryPointerEntry->Bits.Present = 1;
|
|
|
|
for (IndexOfPageDirectoryEntries = 0; IndexOfPageDirectoryEntries < 512; IndexOfPageDirectoryEntries++, PageDirectoryEntry++, PageAddress += SIZE_2MB) {
|
|
//
|
|
// Fill in the Page Directory entries
|
|
//
|
|
PageDirectoryEntry->Uint64 = (UINT64)PageAddress | AddressEncMask;
|
|
PageDirectoryEntry->Bits.ReadWrite = 1;
|
|
PageDirectoryEntry->Bits.Present = 1;
|
|
PageDirectoryEntry->Bits.MustBe1 = 1;
|
|
}
|
|
}
|
|
|
|
for ( ; IndexOfPdpEntries < 512; IndexOfPdpEntries++, PageDirectoryPointerEntry++) {
|
|
ZeroMem (
|
|
PageDirectoryPointerEntry,
|
|
sizeof (PAGE_MAP_AND_DIRECTORY_POINTER)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// For the PML4 entries we are not using fill in a null entry.
|
|
//
|
|
for ( ; IndexOfPml4Entries < 512; IndexOfPml4Entries++, PageMapLevel4Entry++) {
|
|
ZeroMem (
|
|
PageMapLevel4Entry,
|
|
sizeof (PAGE_MAP_AND_DIRECTORY_POINTER)
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
Return function from long mode to 32-bit mode.
|
|
|
|
@param EntrypointContext Context for mode switching
|
|
@param ReturnContext Context for mode switching
|
|
|
|
**/
|
|
VOID
|
|
ReturnFunction (
|
|
SWITCH_32_TO_64_CONTEXT *EntrypointContext,
|
|
SWITCH_64_TO_32_CONTEXT *ReturnContext
|
|
)
|
|
{
|
|
//
|
|
// Restore original GDT
|
|
//
|
|
AsmWriteGdtr (&ReturnContext->Gdtr);
|
|
|
|
//
|
|
// return to original caller
|
|
//
|
|
LongJump ((BASE_LIBRARY_JUMP_BUFFER *)(UINTN)EntrypointContext->JumpBuffer, 1);
|
|
|
|
//
|
|
// never be here
|
|
//
|
|
ASSERT (FALSE);
|
|
}
|
|
|
|
/**
|
|
Thunk function from 32-bit protection mode to long mode.
|
|
|
|
@param PageTableAddress Page table base address
|
|
@param Context Context for mode switching
|
|
@param ReturnContext Context for mode switching
|
|
|
|
@retval EFI_SUCCESS Function successfully executed.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
Thunk32To64 (
|
|
EFI_PHYSICAL_ADDRESS PageTableAddress,
|
|
SWITCH_32_TO_64_CONTEXT *Context,
|
|
SWITCH_64_TO_32_CONTEXT *ReturnContext
|
|
)
|
|
{
|
|
UINTN SetJumpFlag;
|
|
EFI_STATUS Status;
|
|
|
|
//
|
|
// Save return address, LongJump will return here then
|
|
//
|
|
SetJumpFlag = SetJump ((BASE_LIBRARY_JUMP_BUFFER *)(UINTN)Context->JumpBuffer);
|
|
|
|
if (SetJumpFlag == 0) {
|
|
//
|
|
// Build 4G Page Tables.
|
|
//
|
|
Create4GPageTables (PageTableAddress, Context->Page1GSupport);
|
|
|
|
//
|
|
// Create 64-bit GDT
|
|
//
|
|
AsmWriteGdtr (&mGdt);
|
|
|
|
//
|
|
// Write CR3
|
|
//
|
|
AsmWriteCr3 ((UINTN)PageTableAddress);
|
|
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"%a() Stack Base: 0x%lx, Stack Size: 0x%lx\n",
|
|
__func__,
|
|
Context->StackBufferBase,
|
|
Context->StackBufferLength
|
|
));
|
|
|
|
//
|
|
// Disable interrupt of Debug timer, since the IDT table cannot work in long mode
|
|
//
|
|
SaveAndSetDebugTimerInterrupt (FALSE);
|
|
//
|
|
// Transfer to long mode
|
|
//
|
|
AsmEnablePaging64 (
|
|
0x38,
|
|
(UINT64)Context->EntryPoint,
|
|
(UINT64)(UINTN)Context,
|
|
(UINT64)(UINTN)ReturnContext,
|
|
Context->StackBufferBase + Context->StackBufferLength
|
|
);
|
|
}
|
|
|
|
//
|
|
// Convert to 32-bit Status and return
|
|
//
|
|
Status = EFI_SUCCESS;
|
|
if ((UINTN)ReturnContext->ReturnStatus != 0) {
|
|
Status = ENCODE_ERROR ((UINTN)ReturnContext->ReturnStatus);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
If in 32 bit protection mode, and coalesce image is of X64, switch to long mode.
|
|
|
|
@param LongModeBuffer The context of long mode.
|
|
@param CoalesceEntry Entry of coalesce image.
|
|
@param BlockListAddr Address of block list.
|
|
@param MemoryResource Pointer to the buffer of memory resource descriptor.
|
|
@param MemoryBase Base of memory range.
|
|
@param MemorySize Size of memory range.
|
|
|
|
@retval EFI_SUCCESS Successfully switched to long mode and execute coalesce.
|
|
@retval Others Failed to execute coalesce in long mode.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
ModeSwitch (
|
|
IN EFI_CAPSULE_LONG_MODE_BUFFER *LongModeBuffer,
|
|
IN COALESCE_ENTRY CoalesceEntry,
|
|
IN EFI_PHYSICAL_ADDRESS BlockListAddr,
|
|
IN MEMORY_RESOURCE_DESCRIPTOR *MemoryResource,
|
|
IN OUT VOID **MemoryBase,
|
|
IN OUT UINTN *MemorySize
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_PHYSICAL_ADDRESS MemoryBase64;
|
|
UINT64 MemorySize64;
|
|
EFI_PHYSICAL_ADDRESS MemoryEnd64;
|
|
SWITCH_32_TO_64_CONTEXT Context;
|
|
SWITCH_64_TO_32_CONTEXT ReturnContext;
|
|
BASE_LIBRARY_JUMP_BUFFER JumpBuffer;
|
|
EFI_PHYSICAL_ADDRESS ReservedRangeBase;
|
|
EFI_PHYSICAL_ADDRESS ReservedRangeEnd;
|
|
BOOLEAN Page1GSupport;
|
|
|
|
ZeroMem (&Context, sizeof (SWITCH_32_TO_64_CONTEXT));
|
|
ZeroMem (&ReturnContext, sizeof (SWITCH_64_TO_32_CONTEXT));
|
|
|
|
MemoryBase64 = (UINT64)(UINTN)*MemoryBase;
|
|
MemorySize64 = (UINT64)(UINTN)*MemorySize;
|
|
MemoryEnd64 = MemoryBase64 + MemorySize64;
|
|
|
|
Page1GSupport = IsPage1GSupport ();
|
|
|
|
//
|
|
// Merge memory range reserved for stack and page table
|
|
//
|
|
if (LongModeBuffer->StackBaseAddress < LongModeBuffer->PageTableAddress) {
|
|
ReservedRangeBase = LongModeBuffer->StackBaseAddress;
|
|
ReservedRangeEnd = LongModeBuffer->PageTableAddress + CalculatePageTableSize (Page1GSupport);
|
|
} else {
|
|
ReservedRangeBase = LongModeBuffer->PageTableAddress;
|
|
ReservedRangeEnd = LongModeBuffer->StackBaseAddress + LongModeBuffer->StackSize;
|
|
}
|
|
|
|
//
|
|
// Check if memory range reserved is overlap with MemoryBase ~ MemoryBase + MemorySize.
|
|
// If they are overlapped, get a larger range to process capsule data.
|
|
//
|
|
if (ReservedRangeBase <= MemoryBase64) {
|
|
if (ReservedRangeEnd < MemoryEnd64) {
|
|
MemoryBase64 = ReservedRangeEnd;
|
|
} else {
|
|
DEBUG ((DEBUG_ERROR, "Memory is not enough to process capsule!\n"));
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
} else if (ReservedRangeBase < MemoryEnd64) {
|
|
if ((ReservedRangeEnd < MemoryEnd64) &&
|
|
(ReservedRangeBase - MemoryBase64 < MemoryEnd64 - ReservedRangeEnd))
|
|
{
|
|
MemoryBase64 = ReservedRangeEnd;
|
|
} else {
|
|
MemorySize64 = (UINT64)(UINTN)(ReservedRangeBase - MemoryBase64);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Initialize context jumping to 64-bit enviroment
|
|
//
|
|
Context.JumpBuffer = (EFI_PHYSICAL_ADDRESS)(UINTN)&JumpBuffer;
|
|
Context.StackBufferBase = LongModeBuffer->StackBaseAddress;
|
|
Context.StackBufferLength = LongModeBuffer->StackSize;
|
|
Context.EntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)CoalesceEntry;
|
|
Context.BlockListAddr = BlockListAddr;
|
|
Context.MemoryResource = (EFI_PHYSICAL_ADDRESS)(UINTN)MemoryResource;
|
|
Context.MemoryBase64Ptr = (EFI_PHYSICAL_ADDRESS)(UINTN)&MemoryBase64;
|
|
Context.MemorySize64Ptr = (EFI_PHYSICAL_ADDRESS)(UINTN)&MemorySize64;
|
|
Context.Page1GSupport = Page1GSupport;
|
|
Context.AddressEncMask = PcdGet64 (PcdPteMemoryEncryptionAddressOrMask) & PAGING_1G_ADDRESS_MASK_64;
|
|
|
|
//
|
|
// Prepare data for return back
|
|
//
|
|
ReturnContext.ReturnCs = 0x10;
|
|
ReturnContext.ReturnEntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)ReturnFunction;
|
|
//
|
|
// Will save the return status of processing capsule
|
|
//
|
|
ReturnContext.ReturnStatus = 0;
|
|
|
|
//
|
|
// Save original GDT
|
|
//
|
|
AsmReadGdtr ((IA32_DESCRIPTOR *)&ReturnContext.Gdtr);
|
|
|
|
Status = Thunk32To64 (LongModeBuffer->PageTableAddress, &Context, &ReturnContext);
|
|
|
|
if (!EFI_ERROR (Status)) {
|
|
*MemoryBase = (VOID *)(UINTN)MemoryBase64;
|
|
*MemorySize = (UINTN)MemorySize64;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Locates the coalesce image entry point, and detects its machine type.
|
|
|
|
@param CoalesceImageEntryPoint Pointer to coalesce image entry point for output.
|
|
@param CoalesceImageMachineType Pointer to machine type of coalesce image.
|
|
|
|
@retval EFI_SUCCESS Coalesce image successfully located.
|
|
@retval Others Failed to locate the coalesce image.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
FindCapsuleCoalesceImage (
|
|
OUT EFI_PHYSICAL_ADDRESS *CoalesceImageEntryPoint,
|
|
OUT UINT16 *CoalesceImageMachineType
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN Instance;
|
|
EFI_PEI_LOAD_FILE_PPI *LoadFile;
|
|
EFI_PEI_FV_HANDLE VolumeHandle;
|
|
EFI_PEI_FILE_HANDLE FileHandle;
|
|
EFI_PHYSICAL_ADDRESS CoalesceImageAddress;
|
|
UINT64 CoalesceImageSize;
|
|
UINT32 AuthenticationState;
|
|
|
|
Instance = 0;
|
|
|
|
while (TRUE) {
|
|
Status = PeiServicesFfsFindNextVolume (Instance++, &VolumeHandle);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
Status = PeiServicesFfsFindFileByName (PcdGetPtr (PcdCapsuleCoalesceFile), VolumeHandle, &FileHandle);
|
|
if (!EFI_ERROR (Status)) {
|
|
Status = PeiServicesLocatePpi (&gEfiPeiLoadFilePpiGuid, 0, NULL, (VOID **)&LoadFile);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Status = LoadFile->LoadFile (
|
|
LoadFile,
|
|
FileHandle,
|
|
&CoalesceImageAddress,
|
|
&CoalesceImageSize,
|
|
CoalesceImageEntryPoint,
|
|
&AuthenticationState
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "Unable to find PE32 section in CapsuleX64 image ffs %r!\n", Status));
|
|
return Status;
|
|
}
|
|
|
|
*CoalesceImageMachineType = PeCoffLoaderGetMachineType ((VOID *)(UINTN)CoalesceImageAddress);
|
|
break;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Gets the reserved long mode buffer.
|
|
|
|
@param LongModeBuffer Pointer to the long mode buffer for output.
|
|
|
|
@retval EFI_SUCCESS Long mode buffer successfully retrieved.
|
|
@retval Others Variable storing long mode buffer not found.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
GetLongModeContext (
|
|
OUT EFI_CAPSULE_LONG_MODE_BUFFER *LongModeBuffer
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN Size;
|
|
EFI_PEI_READ_ONLY_VARIABLE2_PPI *PPIVariableServices;
|
|
|
|
Status = PeiServicesLocatePpi (
|
|
&gEfiPeiReadOnlyVariable2PpiGuid,
|
|
0,
|
|
NULL,
|
|
(VOID **)&PPIVariableServices
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Size = sizeof (EFI_CAPSULE_LONG_MODE_BUFFER);
|
|
Status = PPIVariableServices->GetVariable (
|
|
PPIVariableServices,
|
|
EFI_CAPSULE_LONG_MODE_BUFFER_NAME,
|
|
&gEfiCapsuleVendorGuid,
|
|
NULL,
|
|
&Size,
|
|
LongModeBuffer
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "Error Get LongModeBuffer variable %r!\n", Status));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
|
|
|
|
/**
|
|
Get physical address bits.
|
|
|
|
@return Physical address bits.
|
|
|
|
**/
|
|
UINT8
|
|
GetPhysicalAddressBits (
|
|
VOID
|
|
)
|
|
{
|
|
UINT32 RegEax;
|
|
UINT8 PhysicalAddressBits;
|
|
VOID *Hob;
|
|
|
|
//
|
|
// Get physical address bits supported.
|
|
//
|
|
Hob = GetFirstHob (EFI_HOB_TYPE_CPU);
|
|
if (Hob != NULL) {
|
|
PhysicalAddressBits = ((EFI_HOB_CPU *)Hob)->SizeOfMemorySpace;
|
|
} else {
|
|
AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
|
|
if (RegEax >= 0x80000008) {
|
|
AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);
|
|
PhysicalAddressBits = (UINT8)RegEax;
|
|
} else {
|
|
PhysicalAddressBits = 36;
|
|
}
|
|
}
|
|
|
|
//
|
|
// IA-32e paging translates 48-bit linear addresses to 52-bit physical addresses.
|
|
//
|
|
ASSERT (PhysicalAddressBits <= 52);
|
|
if (PhysicalAddressBits > 48) {
|
|
PhysicalAddressBits = 48;
|
|
}
|
|
|
|
return PhysicalAddressBits;
|
|
}
|
|
|
|
#endif
|
|
|
|
/**
|
|
Sort memory resource entries based upon PhysicalStart, from low to high.
|
|
|
|
@param[in, out] MemoryResource A pointer to the memory resource entry buffer.
|
|
|
|
**/
|
|
VOID
|
|
SortMemoryResourceDescriptor (
|
|
IN OUT MEMORY_RESOURCE_DESCRIPTOR *MemoryResource
|
|
)
|
|
{
|
|
MEMORY_RESOURCE_DESCRIPTOR *MemoryResourceEntry;
|
|
MEMORY_RESOURCE_DESCRIPTOR *NextMemoryResourceEntry;
|
|
MEMORY_RESOURCE_DESCRIPTOR TempMemoryResource;
|
|
|
|
MemoryResourceEntry = MemoryResource;
|
|
NextMemoryResourceEntry = MemoryResource + 1;
|
|
while (MemoryResourceEntry->ResourceLength != 0) {
|
|
while (NextMemoryResourceEntry->ResourceLength != 0) {
|
|
if (MemoryResourceEntry->PhysicalStart > NextMemoryResourceEntry->PhysicalStart) {
|
|
CopyMem (&TempMemoryResource, MemoryResourceEntry, sizeof (MEMORY_RESOURCE_DESCRIPTOR));
|
|
CopyMem (MemoryResourceEntry, NextMemoryResourceEntry, sizeof (MEMORY_RESOURCE_DESCRIPTOR));
|
|
CopyMem (NextMemoryResourceEntry, &TempMemoryResource, sizeof (MEMORY_RESOURCE_DESCRIPTOR));
|
|
}
|
|
|
|
NextMemoryResourceEntry = NextMemoryResourceEntry + 1;
|
|
}
|
|
|
|
MemoryResourceEntry = MemoryResourceEntry + 1;
|
|
NextMemoryResourceEntry = MemoryResourceEntry + 1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
Merge continous memory resource entries.
|
|
|
|
@param[in, out] MemoryResource A pointer to the memory resource entry buffer.
|
|
|
|
**/
|
|
VOID
|
|
MergeMemoryResourceDescriptor (
|
|
IN OUT MEMORY_RESOURCE_DESCRIPTOR *MemoryResource
|
|
)
|
|
{
|
|
MEMORY_RESOURCE_DESCRIPTOR *MemoryResourceEntry;
|
|
MEMORY_RESOURCE_DESCRIPTOR *NewMemoryResourceEntry;
|
|
MEMORY_RESOURCE_DESCRIPTOR *NextMemoryResourceEntry;
|
|
MEMORY_RESOURCE_DESCRIPTOR *MemoryResourceEnd;
|
|
|
|
MemoryResourceEntry = MemoryResource;
|
|
NewMemoryResourceEntry = MemoryResource;
|
|
while (MemoryResourceEntry->ResourceLength != 0) {
|
|
CopyMem (NewMemoryResourceEntry, MemoryResourceEntry, sizeof (MEMORY_RESOURCE_DESCRIPTOR));
|
|
NextMemoryResourceEntry = MemoryResourceEntry + 1;
|
|
|
|
while ((NextMemoryResourceEntry->ResourceLength != 0) &&
|
|
(NextMemoryResourceEntry->PhysicalStart == (MemoryResourceEntry->PhysicalStart + MemoryResourceEntry->ResourceLength)))
|
|
{
|
|
MemoryResourceEntry->ResourceLength += NextMemoryResourceEntry->ResourceLength;
|
|
if (NewMemoryResourceEntry != MemoryResourceEntry) {
|
|
NewMemoryResourceEntry->ResourceLength += NextMemoryResourceEntry->ResourceLength;
|
|
}
|
|
|
|
NextMemoryResourceEntry = NextMemoryResourceEntry + 1;
|
|
}
|
|
|
|
MemoryResourceEntry = NextMemoryResourceEntry;
|
|
NewMemoryResourceEntry = NewMemoryResourceEntry + 1;
|
|
}
|
|
|
|
//
|
|
// Set NULL terminate memory resource descriptor after merging.
|
|
//
|
|
MemoryResourceEnd = NewMemoryResourceEntry;
|
|
ZeroMem (MemoryResourceEnd, sizeof (MEMORY_RESOURCE_DESCRIPTOR));
|
|
}
|
|
|
|
/**
|
|
Build memory resource descriptor from resource descriptor in HOB list.
|
|
|
|
@return Pointer to the buffer of memory resource descriptor.
|
|
NULL if no memory resource descriptor reported in HOB list
|
|
before capsule Coalesce.
|
|
|
|
**/
|
|
MEMORY_RESOURCE_DESCRIPTOR *
|
|
BuildMemoryResourceDescriptor (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_PEI_HOB_POINTERS Hob;
|
|
UINTN Index;
|
|
EFI_HOB_RESOURCE_DESCRIPTOR *ResourceDescriptor;
|
|
MEMORY_RESOURCE_DESCRIPTOR *MemoryResource;
|
|
EFI_STATUS Status;
|
|
|
|
//
|
|
// Get the count of memory resource descriptor.
|
|
//
|
|
Index = 0;
|
|
Hob.Raw = GetFirstHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR);
|
|
while (Hob.Raw != NULL) {
|
|
ResourceDescriptor = (EFI_HOB_RESOURCE_DESCRIPTOR *)Hob.Raw;
|
|
if (ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) {
|
|
Index++;
|
|
}
|
|
|
|
Hob.Raw = GET_NEXT_HOB (Hob);
|
|
Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw);
|
|
}
|
|
|
|
if (Index == 0) {
|
|
DEBUG ((DEBUG_INFO | DEBUG_WARN, "No memory resource descriptor reported in HOB list before capsule Coalesce\n"));
|
|
#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
|
|
//
|
|
// Allocate memory to hold memory resource descriptor,
|
|
// include extra one NULL terminate memory resource descriptor.
|
|
//
|
|
Status = PeiServicesAllocatePool ((1 + 1) * sizeof (MEMORY_RESOURCE_DESCRIPTOR), (VOID **)&MemoryResource);
|
|
ASSERT_EFI_ERROR (Status);
|
|
ZeroMem (MemoryResource, (1 + 1) * sizeof (MEMORY_RESOURCE_DESCRIPTOR));
|
|
|
|
MemoryResource[0].PhysicalStart = 0;
|
|
MemoryResource[0].ResourceLength = LShiftU64 (1, GetPhysicalAddressBits ());
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"MemoryResource[0x0] - Start(0x%0lx) Length(0x%0lx)\n",
|
|
MemoryResource[0x0].PhysicalStart,
|
|
MemoryResource[0x0].ResourceLength
|
|
));
|
|
return MemoryResource;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//
|
|
// Allocate memory to hold memory resource descriptor,
|
|
// include extra one NULL terminate memory resource descriptor.
|
|
//
|
|
Status = PeiServicesAllocatePool ((Index + 1) * sizeof (MEMORY_RESOURCE_DESCRIPTOR), (VOID **)&MemoryResource);
|
|
ASSERT_EFI_ERROR (Status);
|
|
ZeroMem (MemoryResource, (Index + 1) * sizeof (MEMORY_RESOURCE_DESCRIPTOR));
|
|
|
|
//
|
|
// Get the content of memory resource descriptor.
|
|
//
|
|
Index = 0;
|
|
Hob.Raw = GetFirstHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR);
|
|
while (Hob.Raw != NULL) {
|
|
ResourceDescriptor = (EFI_HOB_RESOURCE_DESCRIPTOR *)Hob.Raw;
|
|
if (ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) {
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
"MemoryResource[0x%x] - Start(0x%0lx) Length(0x%0lx)\n",
|
|
Index,
|
|
ResourceDescriptor->PhysicalStart,
|
|
ResourceDescriptor->ResourceLength
|
|
));
|
|
MemoryResource[Index].PhysicalStart = ResourceDescriptor->PhysicalStart;
|
|
MemoryResource[Index].ResourceLength = ResourceDescriptor->ResourceLength;
|
|
Index++;
|
|
}
|
|
|
|
Hob.Raw = GET_NEXT_HOB (Hob);
|
|
Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw);
|
|
}
|
|
|
|
SortMemoryResourceDescriptor (MemoryResource);
|
|
MergeMemoryResourceDescriptor (MemoryResource);
|
|
|
|
DEBUG ((DEBUG_INFO, "Dump MemoryResource[] after sorted and merged\n"));
|
|
for (Index = 0; MemoryResource[Index].ResourceLength != 0; Index++) {
|
|
DEBUG ((
|
|
DEBUG_INFO,
|
|
" MemoryResource[0x%x] - Start(0x%0lx) Length(0x%0lx)\n",
|
|
Index,
|
|
MemoryResource[Index].PhysicalStart,
|
|
MemoryResource[Index].ResourceLength
|
|
));
|
|
}
|
|
|
|
return MemoryResource;
|
|
}
|
|
|
|
/**
|
|
Check if the capsules are staged.
|
|
|
|
@retval TRUE The capsules are staged.
|
|
@retval FALSE The capsules are not staged.
|
|
|
|
**/
|
|
BOOLEAN
|
|
AreCapsulesStaged (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN Size;
|
|
EFI_PEI_READ_ONLY_VARIABLE2_PPI *PPIVariableServices;
|
|
EFI_PHYSICAL_ADDRESS CapsuleDataPtr64;
|
|
|
|
CapsuleDataPtr64 = 0;
|
|
|
|
Status = PeiServicesLocatePpi (
|
|
&gEfiPeiReadOnlyVariable2PpiGuid,
|
|
0,
|
|
NULL,
|
|
(VOID **)&PPIVariableServices
|
|
);
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "Failed to find ReadOnlyVariable2PPI\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Check for Update capsule
|
|
//
|
|
Size = sizeof (CapsuleDataPtr64);
|
|
Status = PPIVariableServices->GetVariable (
|
|
PPIVariableServices,
|
|
EFI_CAPSULE_VARIABLE_NAME,
|
|
&gEfiCapsuleVendorGuid,
|
|
NULL,
|
|
&Size,
|
|
(VOID *)&CapsuleDataPtr64
|
|
);
|
|
|
|
if (!EFI_ERROR (Status)) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
Check all the variables for SG list heads and get the count and addresses.
|
|
|
|
@param ListLength A pointer would return the SG list length.
|
|
@param HeadList A ponter to the capsule SG list.
|
|
|
|
@retval EFI_SUCCESS a valid capsule is present
|
|
@retval EFI_NOT_FOUND if a valid capsule is not present
|
|
@retval EFI_INVALID_PARAMETER the input parameter is invalid
|
|
@retval EFI_OUT_OF_RESOURCES fail to allocate memory
|
|
|
|
**/
|
|
EFI_STATUS
|
|
GetScatterGatherHeadEntries (
|
|
OUT UINTN *ListLength,
|
|
OUT EFI_PHYSICAL_ADDRESS **HeadList
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN Size;
|
|
UINTN Index;
|
|
UINTN TempIndex;
|
|
UINTN ValidIndex;
|
|
BOOLEAN Flag;
|
|
CHAR16 CapsuleVarName[30];
|
|
CHAR16 *TempVarName;
|
|
EFI_PHYSICAL_ADDRESS CapsuleDataPtr64;
|
|
EFI_PEI_READ_ONLY_VARIABLE2_PPI *PPIVariableServices;
|
|
EFI_PHYSICAL_ADDRESS *TempList;
|
|
EFI_PHYSICAL_ADDRESS *EnlargedTempList;
|
|
UINTN TempListLength;
|
|
|
|
Index = 0;
|
|
TempVarName = NULL;
|
|
CapsuleVarName[0] = 0;
|
|
ValidIndex = 0;
|
|
CapsuleDataPtr64 = 0;
|
|
|
|
if ((ListLength == NULL) || (HeadList == NULL)) {
|
|
DEBUG ((DEBUG_ERROR, "%a Invalid parameters. Inputs can't be NULL\n", __func__));
|
|
ASSERT (ListLength != NULL);
|
|
ASSERT (HeadList != NULL);
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
*ListLength = 0;
|
|
*HeadList = NULL;
|
|
|
|
Status = PeiServicesLocatePpi (
|
|
&gEfiPeiReadOnlyVariable2PpiGuid,
|
|
0,
|
|
NULL,
|
|
(VOID **)&PPIVariableServices
|
|
);
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "Failed to find ReadOnlyVariable2PPI\n"));
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Allocate memory for sg list head
|
|
//
|
|
TempListLength = DEFAULT_SG_LIST_HEADS * sizeof (EFI_PHYSICAL_ADDRESS);
|
|
TempList = AllocateZeroPool (TempListLength);
|
|
if (TempList == NULL) {
|
|
DEBUG ((DEBUG_ERROR, "Failed to allocate memory\n"));
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// setup var name buffer for update capsules
|
|
//
|
|
StrCpyS (CapsuleVarName, sizeof (CapsuleVarName) / sizeof (CHAR16), EFI_CAPSULE_VARIABLE_NAME);
|
|
TempVarName = CapsuleVarName + StrLen (CapsuleVarName);
|
|
while (TRUE) {
|
|
if (Index != 0) {
|
|
UnicodeValueToStringS (
|
|
TempVarName,
|
|
(sizeof (CapsuleVarName) - ((UINTN)TempVarName - (UINTN)CapsuleVarName)),
|
|
0,
|
|
Index,
|
|
0
|
|
);
|
|
}
|
|
|
|
Size = sizeof (CapsuleDataPtr64);
|
|
Status = PPIVariableServices->GetVariable (
|
|
PPIVariableServices,
|
|
CapsuleVarName,
|
|
&gEfiCapsuleVendorGuid,
|
|
NULL,
|
|
&Size,
|
|
(VOID *)&CapsuleDataPtr64
|
|
);
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
if (Status != EFI_NOT_FOUND) {
|
|
DEBUG ((DEBUG_ERROR, "Unexpected error getting Capsule Update variable. Status = %r\n", Status));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If this BlockList has been linked before, skip this variable
|
|
//
|
|
Flag = FALSE;
|
|
for (TempIndex = 0; TempIndex < ValidIndex; TempIndex++) {
|
|
if (TempList[TempIndex] == CapsuleDataPtr64) {
|
|
Flag = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Flag) {
|
|
Index++;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// The TempList is full, enlarge it
|
|
//
|
|
if ((ValidIndex + 1) >= TempListLength) {
|
|
EnlargedTempList = AllocateZeroPool (TempListLength * 2);
|
|
if (EnlargedTempList == NULL) {
|
|
DEBUG ((DEBUG_ERROR, "Fail to allocate memory!\n"));
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
CopyMem (EnlargedTempList, TempList, TempListLength);
|
|
FreePool (TempList);
|
|
TempList = EnlargedTempList;
|
|
TempListLength *= 2;
|
|
}
|
|
|
|
//
|
|
// add it to the cached list
|
|
//
|
|
TempList[ValidIndex++] = CapsuleDataPtr64;
|
|
Index++;
|
|
}
|
|
|
|
if (ValidIndex == 0) {
|
|
DEBUG ((DEBUG_ERROR, "%a didn't find any SG lists in variables\n", __func__));
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
*HeadList = AllocateZeroPool ((ValidIndex + 1) * sizeof (EFI_PHYSICAL_ADDRESS));
|
|
if (*HeadList == NULL) {
|
|
DEBUG ((DEBUG_ERROR, "Failed to allocate memory\n"));
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
CopyMem (*HeadList, TempList, (ValidIndex) * sizeof (EFI_PHYSICAL_ADDRESS));
|
|
*ListLength = ValidIndex;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Capsule PPI service to coalesce a fragmented capsule in memory.
|
|
|
|
@param PeiServices General purpose services available to every PEIM.
|
|
@param MemoryBase Pointer to the base of a block of memory that we can walk
|
|
all over while trying to coalesce our buffers.
|
|
On output, this variable will hold the base address of
|
|
a coalesced capsule.
|
|
@param MemorySize Size of the memory region pointed to by MemoryBase.
|
|
On output, this variable will contain the size of the
|
|
coalesced capsule.
|
|
|
|
@retval EFI_NOT_FOUND if we can't determine the boot mode
|
|
if the boot mode is not flash-update
|
|
if we could not find the capsule descriptors
|
|
|
|
@retval EFI_BUFFER_TOO_SMALL
|
|
if we could not coalesce the capsule in the memory
|
|
region provided to us
|
|
|
|
@retval EFI_SUCCESS if there's no capsule, or if we processed the
|
|
capsule successfully.
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CapsuleCoalesce (
|
|
IN EFI_PEI_SERVICES **PeiServices,
|
|
IN OUT VOID **MemoryBase,
|
|
IN OUT UINTN *MemorySize
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_BOOT_MODE BootMode;
|
|
UINTN ListLength;
|
|
EFI_PHYSICAL_ADDRESS *VariableArrayAddress;
|
|
MEMORY_RESOURCE_DESCRIPTOR *MemoryResource;
|
|
|
|
#ifdef MDE_CPU_IA32
|
|
UINT16 CoalesceImageMachineType;
|
|
EFI_PHYSICAL_ADDRESS CoalesceImageEntryPoint;
|
|
COALESCE_ENTRY CoalesceEntry;
|
|
EFI_CAPSULE_LONG_MODE_BUFFER LongModeBuffer;
|
|
#endif
|
|
|
|
ListLength = 0;
|
|
VariableArrayAddress = NULL;
|
|
|
|
//
|
|
// Someone should have already ascertained the boot mode. If it's not
|
|
// capsule update, then return normally.
|
|
//
|
|
Status = PeiServicesGetBootMode (&BootMode);
|
|
if (EFI_ERROR (Status) || (BootMode != BOOT_ON_FLASH_UPDATE)) {
|
|
DEBUG ((DEBUG_ERROR, "Boot mode is not correct for capsule update path.\n"));
|
|
Status = EFI_NOT_FOUND;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Get SG list entries
|
|
//
|
|
Status = GetScatterGatherHeadEntries (&ListLength, &VariableArrayAddress);
|
|
if (EFI_ERROR (Status) || (VariableArrayAddress == NULL)) {
|
|
DEBUG ((DEBUG_ERROR, "%a failed to get Scatter Gather List Head Entries. Status = %r\n", __func__, Status));
|
|
goto Done;
|
|
}
|
|
|
|
MemoryResource = BuildMemoryResourceDescriptor ();
|
|
|
|
#ifdef MDE_CPU_IA32
|
|
if (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) {
|
|
//
|
|
// Switch to 64-bit mode to process capsule data when:
|
|
// 1. When DXE phase is 64-bit
|
|
// 2. When the buffer for 64-bit transition exists
|
|
// 3. When Capsule X64 image is built in BIOS image
|
|
// In 64-bit mode, we can process capsule data above 4GB.
|
|
//
|
|
CoalesceImageEntryPoint = 0;
|
|
Status = GetLongModeContext (&LongModeBuffer);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "Fail to find the variable for long mode context!\n"));
|
|
Status = EFI_NOT_FOUND;
|
|
goto Done;
|
|
}
|
|
|
|
Status = FindCapsuleCoalesceImage (&CoalesceImageEntryPoint, &CoalesceImageMachineType);
|
|
if ((EFI_ERROR (Status)) || (CoalesceImageMachineType != EFI_IMAGE_MACHINE_X64)) {
|
|
DEBUG ((DEBUG_ERROR, "Fail to find CapsuleX64 module in FV!\n"));
|
|
Status = EFI_NOT_FOUND;
|
|
goto Done;
|
|
}
|
|
|
|
ASSERT (CoalesceImageEntryPoint != 0);
|
|
CoalesceEntry = (COALESCE_ENTRY)(UINTN)CoalesceImageEntryPoint;
|
|
Status = ModeSwitch (&LongModeBuffer, CoalesceEntry, (EFI_PHYSICAL_ADDRESS)(UINTN)VariableArrayAddress, MemoryResource, MemoryBase, MemorySize);
|
|
} else {
|
|
//
|
|
// Capsule is processed in IA32 mode.
|
|
//
|
|
Status = CapsuleDataCoalesce (PeiServices, (EFI_PHYSICAL_ADDRESS *)(UINTN)VariableArrayAddress, MemoryResource, MemoryBase, MemorySize);
|
|
}
|
|
|
|
#else
|
|
//
|
|
// Process capsule directly.
|
|
//
|
|
Status = CapsuleDataCoalesce (PeiServices, (EFI_PHYSICAL_ADDRESS *)(UINTN)VariableArrayAddress, MemoryResource, MemoryBase, MemorySize);
|
|
#endif
|
|
|
|
DEBUG ((DEBUG_INFO, "Capsule Coalesce Status = %r!\n", Status));
|
|
|
|
if (Status == EFI_BUFFER_TOO_SMALL) {
|
|
DEBUG ((DEBUG_ERROR, "There is not enough memory to process capsule!\n"));
|
|
}
|
|
|
|
if (Status == EFI_NOT_FOUND) {
|
|
DEBUG ((DEBUG_ERROR, "Fail to parse capsule descriptor in memory!\n"));
|
|
REPORT_STATUS_CODE (
|
|
EFI_ERROR_CODE | EFI_ERROR_MAJOR,
|
|
(EFI_SOFTWARE_PEI_MODULE | EFI_SW_PEI_EC_INVALID_CAPSULE_DESCRIPTOR)
|
|
);
|
|
}
|
|
|
|
Done:
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Determine if we're in capsule update boot mode.
|
|
|
|
@param PeiServices PEI services table
|
|
|
|
@retval EFI_SUCCESS if we have a capsule available
|
|
@retval EFI_NOT_FOUND no capsule detected
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CheckCapsuleUpdate (
|
|
IN EFI_PEI_SERVICES **PeiServices
|
|
)
|
|
{
|
|
if (AreCapsulesStaged ()) {
|
|
return EFI_SUCCESS;
|
|
} else {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
/**
|
|
This function will look at a capsule and determine if it's a test pattern.
|
|
If it is, then it will verify it and emit an error message if corruption is detected.
|
|
|
|
@param PeiServices Standard pei services pointer
|
|
@param CapsuleBase Base address of coalesced capsule, which is preceeded
|
|
by private data. Very implementation specific.
|
|
|
|
@retval TRUE Capsule image is the test image
|
|
@retval FALSE Capsule image is not the test image.
|
|
|
|
**/
|
|
BOOLEAN
|
|
CapsuleTestPattern (
|
|
IN EFI_PEI_SERVICES **PeiServices,
|
|
IN VOID *CapsuleBase
|
|
)
|
|
{
|
|
UINT32 *TestPtr;
|
|
UINT32 TestCounter;
|
|
UINT32 TestSize;
|
|
BOOLEAN RetValue;
|
|
|
|
RetValue = FALSE;
|
|
|
|
//
|
|
// Look at the capsule data and determine if it's a test pattern. If it
|
|
// is, then test it now.
|
|
//
|
|
TestPtr = (UINT32 *)CapsuleBase;
|
|
//
|
|
// 0x54534554 "TEST"
|
|
//
|
|
if (*TestPtr == 0x54534554) {
|
|
RetValue = TRUE;
|
|
DEBUG ((DEBUG_INFO, "Capsule test pattern mode activated...\n"));
|
|
TestSize = TestPtr[1] / sizeof (UINT32);
|
|
//
|
|
// Skip over the signature and the size fields in the pattern data header
|
|
//
|
|
TestPtr += 2;
|
|
TestCounter = 0;
|
|
while (TestSize > 0) {
|
|
if (*TestPtr != TestCounter) {
|
|
DEBUG ((DEBUG_INFO, "Capsule test pattern mode FAILED: BaseAddr/FailAddr 0x%X 0x%X\n", (UINT32)(UINTN)(EFI_CAPSULE_PEIM_PRIVATE_DATA *)CapsuleBase, (UINT32)(UINTN)TestPtr));
|
|
return TRUE;
|
|
}
|
|
|
|
TestPtr++;
|
|
TestCounter++;
|
|
TestSize--;
|
|
}
|
|
|
|
DEBUG ((DEBUG_INFO, "Capsule test pattern mode SUCCESS\n"));
|
|
}
|
|
|
|
return RetValue;
|
|
}
|
|
|
|
/**
|
|
Capsule PPI service that gets called after memory is available. The
|
|
capsule coalesce function, which must be called first, returns a base
|
|
address and size, which can be anything actually. Once the memory init
|
|
PEIM has discovered memory, then it should call this function and pass in
|
|
the base address and size returned by the coalesce function. Then this
|
|
function can create a capsule HOB and return.
|
|
|
|
@param PeiServices standard pei services pointer
|
|
@param CapsuleBase address returned by the capsule coalesce function. Most
|
|
likely this will actually be a pointer to private data.
|
|
@param CapsuleSize value returned by the capsule coalesce function.
|
|
|
|
@retval EFI_VOLUME_CORRUPTED CapsuleBase does not appear to point to a
|
|
coalesced capsule
|
|
@retval EFI_SUCCESS if all goes well.
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CreateState (
|
|
IN EFI_PEI_SERVICES **PeiServices,
|
|
IN VOID *CapsuleBase,
|
|
IN UINTN CapsuleSize
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_CAPSULE_PEIM_PRIVATE_DATA *PrivateData;
|
|
UINTN Size;
|
|
EFI_PHYSICAL_ADDRESS NewBuffer;
|
|
UINTN CapsuleNumber;
|
|
UINT32 Index;
|
|
EFI_PHYSICAL_ADDRESS BaseAddress;
|
|
UINT64 Length;
|
|
|
|
PrivateData = (EFI_CAPSULE_PEIM_PRIVATE_DATA *)CapsuleBase;
|
|
if (PrivateData->Signature != EFI_CAPSULE_PEIM_PRIVATE_DATA_SIGNATURE) {
|
|
return EFI_VOLUME_CORRUPTED;
|
|
}
|
|
|
|
if (PrivateData->CapsuleAllImageSize >= MAX_ADDRESS) {
|
|
DEBUG ((DEBUG_ERROR, "CapsuleAllImageSize too big - 0x%lx\n", PrivateData->CapsuleAllImageSize));
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
if (PrivateData->CapsuleNumber >= MAX_ADDRESS) {
|
|
DEBUG ((DEBUG_ERROR, "CapsuleNumber too big - 0x%lx\n", PrivateData->CapsuleNumber));
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Capsule Number and Capsule Offset is in the tail of Capsule data.
|
|
//
|
|
Size = (UINTN)PrivateData->CapsuleAllImageSize;
|
|
CapsuleNumber = (UINTN)PrivateData->CapsuleNumber;
|
|
//
|
|
// Allocate the memory so that it gets preserved into DXE
|
|
//
|
|
Status = PeiServicesAllocatePages (
|
|
EfiRuntimeServicesData,
|
|
EFI_SIZE_TO_PAGES (Size),
|
|
&NewBuffer
|
|
);
|
|
|
|
if (Status != EFI_SUCCESS) {
|
|
DEBUG ((DEBUG_ERROR, "AllocatePages Failed!\n"));
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Copy to our new buffer for DXE
|
|
//
|
|
DEBUG ((DEBUG_INFO, "Capsule copy from 0x%8X to 0x%8X with size 0x%8X\n", (UINTN)((UINT8 *)PrivateData + sizeof (EFI_CAPSULE_PEIM_PRIVATE_DATA) + (CapsuleNumber - 1) * sizeof (UINT64)), (UINTN)NewBuffer, Size));
|
|
CopyMem ((VOID *)(UINTN)NewBuffer, (VOID *)(UINTN)((UINT8 *)PrivateData + sizeof (EFI_CAPSULE_PEIM_PRIVATE_DATA) + (CapsuleNumber - 1) * sizeof (UINT64)), Size);
|
|
//
|
|
// Check for test data pattern. If it is the test pattern, then we'll
|
|
// test it and still create the HOB so that it can be used to verify
|
|
// that capsules don't get corrupted all the way into BDS. BDS will
|
|
// still try to turn it into a firmware volume, but will think it's
|
|
// corrupted so nothing will happen.
|
|
//
|
|
DEBUG_CODE (
|
|
CapsuleTestPattern (PeiServices, (VOID *)(UINTN)NewBuffer);
|
|
);
|
|
|
|
//
|
|
// Build the UEFI Capsule Hob for each capsule image.
|
|
//
|
|
for (Index = 0; Index < CapsuleNumber; Index++) {
|
|
BaseAddress = NewBuffer + PrivateData->CapsuleOffset[Index];
|
|
Length = ((EFI_CAPSULE_HEADER *)((UINTN)BaseAddress))->CapsuleImageSize;
|
|
|
|
BuildCvHob (BaseAddress, Length);
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
CONST EFI_PEI_CAPSULE_PPI mCapsulePpi = {
|
|
CapsuleCoalesce,
|
|
CheckCapsuleUpdate,
|
|
CreateState
|
|
};
|
|
|
|
CONST EFI_PEI_PPI_DESCRIPTOR mUefiPpiListCapsule = {
|
|
(EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
|
|
&gEfiPeiCapsulePpiGuid,
|
|
(EFI_PEI_CAPSULE_PPI *)&mCapsulePpi
|
|
};
|
|
|
|
/**
|
|
Entry point function for the PEIM
|
|
|
|
@param FileHandle Handle of the file being invoked.
|
|
@param PeiServices Describes the list of possible PEI Services.
|
|
|
|
@return EFI_SUCCESS If we installed our PPI
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CapsuleMain (
|
|
IN EFI_PEI_FILE_HANDLE FileHandle,
|
|
IN CONST EFI_PEI_SERVICES **PeiServices
|
|
)
|
|
{
|
|
//
|
|
// Just produce our PPI
|
|
//
|
|
return PeiServicesInstallPpi (&mUefiPpiListCapsule);
|
|
}
|