This driver is the counterpart of the SMM Base On SMM Base2 Thunk driver. It\r
provides helping services in SMM to the SMM Base On SMM Base2 Thunk driver.\r
\r
- Copyright (c) 2009 - 2010, Intel Corporation\r
- All rights reserved. This program and the accompanying materials\r
+ Caution: This module requires additional review when modified.\r
+ This driver will have external input - communicate buffer in SMM mode.\r
+ This external input must be validated carefully to avoid security issue like\r
+ buffer overflow, integer overflow.\r
+\r
+ SmmHandlerEntry() will receive untrusted input and do validation.\r
+\r
+ Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>\r
+ This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/SynchronizationLib.h>\r
#include <Library/CpuLib.h>\r
+#include <Library/SmmMemLib.h>\r
#include <Guid/SmmBaseThunkCommunication.h>\r
#include <Protocol/SmmBaseHelperReady.h>\r
#include <Protocol/SmmCpu.h>\r
#include <Protocol/LoadPe32Image.h>\r
#include <Protocol/SmmReadyToLock.h>\r
\r
+/**\r
+ Register SMM image to SMRAM profile.\r
+\r
+ @param[in] FilePath File path of the image.\r
+ @param[in] ImageBuffer Image base address.\r
+ @param[in] NumberOfPage Number of page.\r
+\r
+ @retval TRUE Register success.\r
+ @retval FALSE Register fail.\r
+\r
+**/\r
+BOOLEAN\r
+RegisterSmramProfileImage (\r
+ IN EFI_DEVICE_PATH_PROTOCOL *FilePath,\r
+ IN PHYSICAL_ADDRESS ImageBuffer,\r
+ IN UINTN NumberOfPage\r
+ );\r
+\r
+/**\r
+ Unregister SMM image from SMRAM profile.\r
+\r
+ @param[in] FilePath File path of the image.\r
+ @param[in] ImageBuffer Image base address.\r
+ @param[in] NumberOfPage Number of page.\r
+\r
+ @retval TRUE Unregister success.\r
+ @retval FALSE Unregister fail.\r
+\r
+**/\r
+BOOLEAN\r
+UnregisterSmramProfileImage (\r
+ IN EFI_DEVICE_PATH_PROTOCOL *FilePath,\r
+ IN PHYSICAL_ADDRESS ImageBuffer,\r
+ IN UINTN NumberOfPage\r
+ );\r
+\r
///\r
/// Structure for tracking paired information of registered Framework SMI handler\r
/// and correpsonding dispatch handle for SMI handler thunk.\r
{EFI_SMM_SAVE_STATE_REGISTER_CR3 , CPU_SAVE_STATE_GET_OFFSET(CR3)}\r
};\r
\r
+/**\r
+ Page fault handler.\r
+\r
+**/\r
VOID\r
PageFaultHandlerHook (\r
VOID\r
);\r
\r
+/**\r
+ Read CpuSaveStates from PI for Framework use.\r
+\r
+ The function reads PI style CpuSaveStates of CpuIndex-th CPU for Framework driver use. If\r
+ ToRead is specified, the CpuSaveStates will be copied to ToRead, otherwise copied to\r
+ mFrameworkSmst->CpuSaveState[CpuIndex].\r
+\r
+ @param[in] CpuIndex The zero-based CPU index.\r
+ @param[in, out] ToRead If not NULL, CpuSaveStates will be copied to it.\r
+\r
+**/\r
VOID\r
ReadCpuSaveState (\r
- UINTN CpuIndex,\r
- EFI_SMM_CPU_SAVE_STATE *ToRead\r
+ IN UINTN CpuIndex,\r
+ IN OUT EFI_SMM_CPU_SAVE_STATE *ToRead\r
)\r
{\r
EFI_STATUS Status;\r
SaveState = &mFrameworkSmst->CpuSaveState[CpuIndex].Ia32SaveState;\r
}\r
\r
- if (State->x86.SMMRevId < EFI_SMM_MIN_REV_ID_x64) {\r
- SaveState->SMBASE = State->x86.SMBASE;\r
- SaveState->SMMRevId = State->x86.SMMRevId;\r
- SaveState->IORestart = State->x86.IORestart;\r
- SaveState->AutoHALTRestart = State->x86.AutoHALTRestart;\r
- } else {\r
- SaveState->SMBASE = State->x64.SMBASE;\r
- SaveState->SMMRevId = State->x64.SMMRevId;\r
- SaveState->IORestart = State->x64.IORestart;\r
- SaveState->AutoHALTRestart = State->x64.AutoHALTRestart;\r
- }\r
+ //\r
+ // Note that SMBASE/SMMRevId/IORestart/AutoHALTRestart are in same location in IA32 and X64 CPU Save State Map.\r
+ //\r
+ SaveState->SMBASE = State->x86.SMBASE;\r
+ SaveState->SMMRevId = State->x86.SMMRevId;\r
+ SaveState->IORestart = State->x86.IORestart;\r
+ SaveState->AutoHALTRestart = State->x86.AutoHALTRestart;\r
\r
for (Index = 0; Index < sizeof (mCpuSaveStateConvTable) / sizeof (CPU_SAVE_STATE_CONVERSION); Index++) {\r
///\r
}\r
}\r
\r
+/**\r
+ Write CpuSaveStates from Framework into PI.\r
+\r
+ The function writes back CpuSaveStates of CpuIndex-th CPU from PI to Framework. If\r
+ ToWrite is specified, it contains the CpuSaveStates to write from, otherwise CpuSaveStates\r
+ to write from mFrameworkSmst->CpuSaveState[CpuIndex].\r
+\r
+ @param[in] CpuIndex The zero-based CPU index.\r
+ @param[in] ToWrite If not NULL, CpuSaveStates to write from.\r
+\r
+**/\r
VOID\r
WriteCpuSaveState (\r
- UINTN CpuIndex,\r
- EFI_SMM_CPU_SAVE_STATE *ToWrite\r
+ IN UINTN CpuIndex,\r
+ IN EFI_SMM_CPU_SAVE_STATE *ToWrite\r
)\r
{\r
- EFI_STATUS Status;\r
- UINTN Index;\r
+ UINTN Index;\r
+ EFI_SMM_CPU_STATE *State;\r
EFI_SMI_CPU_SAVE_STATE *SaveState;\r
\r
+ State = (EFI_SMM_CPU_STATE *)gSmst->CpuSaveState[CpuIndex];\r
+\r
if (ToWrite != NULL) {\r
SaveState = &ToWrite->Ia32SaveState;\r
} else {\r
SaveState = &mFrameworkSmst->CpuSaveState[CpuIndex].Ia32SaveState;\r
}\r
+\r
+ //\r
+ // SMMRevId is read-only.\r
+ // Note that SMBASE/IORestart/AutoHALTRestart are in same location in IA32 and X64 CPU Save State Map.\r
+ //\r
+ State->x86.SMBASE = SaveState->SMBASE;\r
+ State->x86.IORestart = SaveState->IORestart;\r
+ State->x86.AutoHALTRestart = SaveState->AutoHALTRestart;\r
\r
for (Index = 0; Index < sizeof (mCpuSaveStateConvTable) / sizeof (CPU_SAVE_STATE_CONVERSION); Index++) {\r
- Status = mSmmCpu->WriteSaveState (\r
- mSmmCpu,\r
- (UINTN)sizeof (UINT32),\r
- mCpuSaveStateConvTable[Index].Register,\r
- CpuIndex,\r
- ((UINT8 *)SaveState) + \r
- mCpuSaveStateConvTable[Index].Offset\r
- );\r
+ mSmmCpu->WriteSaveState (\r
+ mSmmCpu,\r
+ (UINTN)sizeof (UINT32),\r
+ mCpuSaveStateConvTable[Index].Register,\r
+ CpuIndex,\r
+ ((UINT8 *)SaveState) +\r
+ mCpuSaveStateConvTable[Index].Offset\r
+ );\r
}\r
}\r
\r
+/**\r
+ Read or write a page that contains CpuSaveStates. Read is from PI to Framework.\r
+ Write is from Framework to PI.\r
+\r
+ This function reads or writes a page that contains CpuSaveStates. The page contains Framework\r
+ CpuSaveStates. On read, it reads PI style CpuSaveStates and fill the page up. On write, it\r
+ writes back from the page content to PI CpuSaveStates struct.\r
+ The first Framework CpuSaveStates (for CPU 0) is from mFrameworkSmst->CpuSaveState which is\r
+ page aligned. Because Framework CpuSaveStates are continuous, we can know which CPUs' SaveStates\r
+ are in the page start from PageAddress.\r
+\r
+ @param[in] PageAddress The base address for a page.\r
+ @param[in] IsRead TRUE for Read, FALSE for Write.\r
+\r
+**/\r
VOID\r
ReadWriteCpuStatePage (\r
- UINT64 PageAddress,\r
- BOOLEAN IsRead\r
+ IN UINT64 PageAddress,\r
+ IN BOOLEAN IsRead\r
)\r
{\r
UINTN FirstSSIndex; // Index of first CpuSaveState in the page\r
}\r
}\r
\r
+/**\r
+ The page fault handler that on-demand read PI CpuSaveStates for framework use. If the fault\r
+ is not targeted to mFrameworkSmst->CpuSaveState range, the function will return FALSE to let\r
+ PageFaultHandlerHook know it needs to pass the fault over to original page fault handler.\r
+ \r
+ @retval TRUE The page fault is correctly handled.\r
+ @retval FALSE The page fault is not handled and is passed through to original handler.\r
+\r
+**/\r
BOOLEAN\r
PageFaultHandler (\r
VOID\r
)\r
{\r
BOOLEAN IsHandled;\r
- UINT64 *PageTable;\r
UINT64 PFAddress;\r
UINTN NumCpuStatePages;\r
\r
ASSERT (mPageTableHookEnabled);\r
AcquireSpinLock (&mPFLock);\r
\r
- PageTable = (UINT64*)(UINTN)(AsmReadCr3 () & mPhyMask);\r
PFAddress = AsmReadCr2 ();\r
NumCpuStatePages = EFI_SIZE_TO_PAGES (mNumberOfProcessors * sizeof (EFI_SMM_CPU_SAVE_STATE));\r
IsHandled = FALSE;\r
return IsHandled;\r
}\r
\r
+/**\r
+ Write back the dirty Framework CpuSaveStates to PI.\r
+ \r
+ The function scans the page table for dirty pages in mFrameworkSmst->CpuSaveState\r
+ to write back to PI CpuSaveStates. It is meant to be called on each SmmBaseHelper SMI\r
+ callback after Framework handler is called.\r
+\r
+**/\r
VOID\r
WriteBackDirtyPages (\r
VOID\r
UINTN PTEndIndex;\r
\r
NumCpuStatePages = EFI_SIZE_TO_PAGES (mNumberOfProcessors * sizeof (EFI_SMM_CPU_SAVE_STATE));\r
- PTStartIndex = (UINTN)BitFieldRead64 ((UINT64)mFrameworkSmst->CpuSaveState, 12, 20);\r
- PTEndIndex = (UINTN)BitFieldRead64 ((UINT64)mFrameworkSmst->CpuSaveState + EFI_PAGES_TO_SIZE(NumCpuStatePages) - 1, 12, 20);\r
+ PTStartIndex = (UINTN)BitFieldRead64 ((UINT64) (UINTN) mFrameworkSmst->CpuSaveState, 12, 20);\r
+ PTEndIndex = (UINTN)BitFieldRead64 ((UINT64) (UINTN) mFrameworkSmst->CpuSaveState + EFI_PAGES_TO_SIZE(NumCpuStatePages) - 1, 12, 20);\r
for (PTIndex = PTStartIndex; PTIndex <= PTEndIndex; PTIndex++) {\r
if ((mCpuStatePageTable[PTIndex] & (BIT0|BIT6)) == (BIT0|BIT6)) { // present and dirty?\r
ReadWriteCpuStatePage (mCpuStatePageTable[PTIndex] & mPhyMask, FALSE);\r
}\r
}\r
\r
+/**\r
+ Hook IDT with our page fault handler so that the on-demand paging works on page fault.\r
+ \r
+ The function hooks the IDT with PageFaultHandlerHook to get on-demand paging work for\r
+ PI<->Framework CpuSaveStates marshalling. It also saves original handler for pass-through\r
+ purpose.\r
+\r
+**/\r
VOID\r
HookPageFaultHandler (\r
VOID\r
IdtGateDesc[14].Bits.OffsetHigh = (UINT32)(((UINTN)PageFaultHandlerHook >> 16) & ((1 << 16) - 1));\r
}\r
\r
+/**\r
+ Initialize page table for pages contain HookData.\r
+ \r
+ The function initialize PDE for 2MB range that contains HookData. If the related PDE points\r
+ to a 2MB page, a page table will be allocated and initialized for 4KB pages. Otherwise we juse\r
+ use the original page table.\r
+\r
+ @param[in] HookData Based on which to initialize page table.\r
+\r
+ @return The pointer to a Page Table that points to 4KB pages which contain HookData.\r
+**/\r
UINT64 *\r
InitCpuStatePageTable (\r
- VOID *HookData\r
+ IN VOID *HookData\r
)\r
{\r
UINTN Index;\r
UINT64 *PageTable;\r
- UINT64 *PDPTE;\r
+ UINT64 *Pdpte;\r
UINT64 HookAddress;\r
- UINT64 PDE;\r
+ UINT64 Pde;\r
UINT64 Address;\r
\r
//\r
PageTable = (UINT64 *)(UINTN)(PageTable[BitFieldRead64 (HookAddress, 39, 47)] & mPhyMask);\r
PageTable = (UINT64 *)(UINTN)(PageTable[BitFieldRead64 (HookAddress, 30, 38)] & mPhyMask);\r
\r
- PDPTE = (UINT64 *)(UINTN)PageTable;\r
- PDE = PDPTE[BitFieldRead64 (HookAddress, 21, 29)];\r
- ASSERT ((PDE & BIT0) != 0); // Present and 2M Page\r
+ Pdpte = (UINT64 *)(UINTN)PageTable;\r
+ Pde = Pdpte[BitFieldRead64 (HookAddress, 21, 29)];\r
+ ASSERT ((Pde & BIT0) != 0); // Present and 2M Page\r
\r
- if ((PDE & BIT7) == 0) { // 4KB Page Directory\r
- PageTable = (UINT64 *)(UINTN)(PDE & mPhyMask);\r
+ if ((Pde & BIT7) == 0) { // 4KB Page Directory\r
+ PageTable = (UINT64 *)(UINTN)(Pde & mPhyMask);\r
} else {\r
- ASSERT ((PDE & mPhyMask) == (HookAddress & ~(SIZE_2MB-1))); // 2MB Page Point to HookAddress\r
+ ASSERT ((Pde & mPhyMask) == (HookAddress & ~(SIZE_2MB-1))); // 2MB Page Point to HookAddress\r
PageTable = AllocatePages (1);\r
+ ASSERT (PageTable != NULL);\r
Address = HookAddress & ~(SIZE_2MB-1);\r
for (Index = 0; Index < 512; Index++) {\r
PageTable[Index] = Address | BIT0 | BIT1; // Present and RW\r
Address += SIZE_4KB;\r
}\r
- PDPTE[BitFieldRead64 (HookAddress, 21, 29)] = (UINT64)(UINTN)PageTable | BIT0 | BIT1; // Present and RW\r
+ Pdpte[BitFieldRead64 (HookAddress, 21, 29)] = (UINT64)(UINTN)PageTable | BIT0 | BIT1; // Present and RW\r
}\r
return PageTable;\r
}\r
\r
+/**\r
+ Mark all the CpuSaveStates as not present.\r
+ \r
+ The function marks all CpuSaveStates memory range as not present so that page fault can be triggered\r
+ on CpuSaveStates access. It is meant to be called on each SmmBaseHelper SMI callback before Framework\r
+ handler is called.\r
+\r
+ @param[in] CpuSaveState The base of CpuSaveStates.\r
+\r
+**/\r
VOID\r
HookCpuStateMemory (\r
- EFI_SMM_CPU_SAVE_STATE *CpuSaveState\r
+ IN EFI_SMM_CPU_SAVE_STATE *CpuSaveState\r
)\r
{\r
UINT64 Index;\r
return Status; \r
}\r
\r
+/**\r
+ Initialize all the stuff needed for on-demand paging hooks for PI<->Framework\r
+ CpuSaveStates marshalling.\r
+\r
+ @param[in] FrameworkSmst Framework SMM system table pointer.\r
+\r
+**/\r
VOID\r
InitHook (\r
- EFI_SMM_SYSTEM_TABLE *FrameworkSmst\r
+ IN EFI_SMM_SYSTEM_TABLE *FrameworkSmst\r
)\r
{\r
UINTN NumCpuStatePages;\r
if (!EFI_ERROR (Status)) {\r
///\r
/// Update MP state in Framework SMST before transferring control to Framework SMM driver entry point\r
- /// in case it may invoke AP\r
///\r
+ mFrameworkSmst->SmmStartupThisAp = gSmst->SmmStartupThisAp;\r
+ mFrameworkSmst->NumberOfCpus = mNumberOfProcessors;\r
mFrameworkSmst->CurrentlyExecutingCpu = gSmst->CurrentlyExecutingCpu;\r
\r
+ RegisterSmramProfileImage (FilePath, DstBuffer, PageCount);\r
Status = gBS->StartImage (*ImageHandle, NULL, NULL);\r
if (EFI_ERROR (Status)) {\r
+ UnregisterSmramProfileImage (FilePath, DstBuffer, PageCount);\r
mLoadPe32Image->UnLoadPeImage (mLoadPe32Image, *ImageHandle);\r
*ImageHandle = NULL;\r
FreePages ((VOID *)(UINTN)DstBuffer, PageCount);\r
return Status;\r
}\r
\r
-\r
/** \r
Thunk service of EFI_SMM_BASE_PROTOCOL.Register().\r
\r
\r
This SMI handler provides services for the SMM Base Thunk driver.\r
\r
+ Caution: This function may receive untrusted input during runtime.\r
+ The communicate buffer is external input, so this function will do operations only if the communicate\r
+ buffer is outside of SMRAM so that returning the status code in the buffer won't overwrite anywhere in SMRAM.\r
+\r
@param[in] DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister().\r
@param[in] RegisterContext Points to an optional handler context which was specified when the\r
handler was registered.\r
SMMBASE_FUNCTION_DATA *FunctionData;\r
\r
ASSERT (CommBuffer != NULL);\r
- ASSERT (*CommBufferSize == sizeof (SMMBASE_FUNCTION_DATA));\r
-\r
- FunctionData = (SMMBASE_FUNCTION_DATA *)CommBuffer;\r
-\r
- switch (FunctionData->Function) {\r
- case SmmBaseFunctionRegister:\r
- Register (FunctionData);\r
- break;\r
- case SmmBaseFunctionUnregister:\r
- UnRegister (FunctionData);\r
- break;\r
- case SmmBaseFunctionRegisterCallback:\r
- RegisterCallback (FunctionData);\r
- break;\r
- case SmmBaseFunctionAllocatePool:\r
- HelperAllocatePool (FunctionData);\r
- break;\r
- case SmmBaseFunctionFreePool:\r
- HelperFreePool (FunctionData);\r
- break;\r
- case SmmBaseFunctionCommunicate:\r
- HelperCommunicate (FunctionData);\r
- break;\r
- default:\r
- ASSERT (FALSE);\r
- FunctionData->Status = EFI_UNSUPPORTED;\r
+ ASSERT (CommBufferSize != NULL);\r
+\r
+ if (*CommBufferSize == sizeof (SMMBASE_FUNCTION_DATA) &&\r
+ SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)CommBuffer, (UINT64)*CommBufferSize)) {\r
+ FunctionData = (SMMBASE_FUNCTION_DATA *)CommBuffer;\r
+\r
+ switch (FunctionData->Function) {\r
+ case SmmBaseFunctionRegister:\r
+ Register (FunctionData);\r
+ break;\r
+ case SmmBaseFunctionUnregister:\r
+ UnRegister (FunctionData);\r
+ break;\r
+ case SmmBaseFunctionRegisterCallback:\r
+ RegisterCallback (FunctionData);\r
+ break;\r
+ case SmmBaseFunctionAllocatePool:\r
+ HelperAllocatePool (FunctionData);\r
+ break;\r
+ case SmmBaseFunctionFreePool:\r
+ HelperFreePool (FunctionData);\r
+ break;\r
+ case SmmBaseFunctionCommunicate:\r
+ HelperCommunicate (FunctionData);\r
+ break;\r
+ default:\r
+ DEBUG ((EFI_D_WARN, "SmmBaseHelper: invalid SMM Base function.\n"));\r
+ FunctionData->Status = EFI_UNSUPPORTED;\r
+ }\r
}\r
return EFI_SUCCESS;\r
}\r
projects / mirror_edk2.git / blobdiff