2 SMM Base Helper SMM driver.
4 This driver is the counterpart of the SMM Base On SMM Base2 Thunk driver. It
5 provides helping services in SMM to the SMM Base On SMM Base2 Thunk driver.
7 Copyright (c) 2009 - 2010, Intel Corporation
8 All rights reserved. This program and the accompanying materials
9 are licensed and made available under the terms and conditions of the BSD License
10 which accompanies this distribution. The full text of the license may be found at
11 http://opensource.org/licenses/bsd-license.php
13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 #include <Library/DebugLib.h>
20 #include <Library/UefiBootServicesTableLib.h>
21 #include <Library/SmmServicesTableLib.h>
22 #include <Library/BaseLib.h>
23 #include <Library/BaseMemoryLib.h>
24 #include <Library/PeCoffLib.h>
25 #include <Library/DevicePathLib.h>
26 #include <Library/CacheMaintenanceLib.h>
27 #include <Library/MemoryAllocationLib.h>
28 #include <Library/SynchronizationLib.h>
29 #include <Library/CpuLib.h>
30 #include <Guid/SmmBaseThunkCommunication.h>
31 #include <Protocol/SmmBaseHelperReady.h>
32 #include <Protocol/SmmCpu.h>
33 #include <Protocol/LoadedImage.h>
34 #include <Protocol/SmmCpuSaveState.h>
35 #include <Protocol/MpService.h>
36 #include <Protocol/LoadPe32Image.h>
37 #include <Protocol/SmmReadyToLock.h>
40 /// Structure for tracking paired information of registered Framework SMI handler
41 /// and correpsonding dispatch handle for SMI handler thunk.
45 EFI_HANDLE DispatchHandle
;
46 EFI_HANDLE SmmImageHandle
;
47 EFI_SMM_CALLBACK_ENTRY_POINT CallbackAddress
;
48 VOID
*CommunicationBuffer
;
54 /// PI SMM CPU Save State register index
56 EFI_SMM_SAVE_STATE_REGISTER Register
;
58 /// Offset in Framework SMST
61 } CPU_SAVE_STATE_CONVERSION
;
63 #define CPU_SAVE_STATE_GET_OFFSET(Field) (UINTN)(&(((EFI_SMM_CPU_SAVE_STATE *) 0)->Ia32SaveState.Field))
66 EFI_HANDLE mDispatchHandle
;
67 EFI_SMM_CPU_PROTOCOL
*mSmmCpu
;
68 EFI_PE32_IMAGE_PROTOCOL
*mLoadPe32Image
;
69 EFI_GUID mEfiSmmCpuIoGuid
= EFI_SMM_CPU_IO_GUID
;
70 EFI_SMM_BASE_HELPER_READY_PROTOCOL
*mSmmBaseHelperReady
;
71 EFI_SMM_SYSTEM_TABLE
*mFrameworkSmst
;
72 UINTN mNumberOfProcessors
;
73 BOOLEAN mLocked
= FALSE
;
74 BOOLEAN mPageTableHookEnabled
;
75 BOOLEAN mHookInitialized
;
76 UINT64
*mCpuStatePageTable
;
79 VOID
*mOriginalHandler
;
80 EFI_SMM_CPU_SAVE_STATE
*mShadowSaveState
;
82 LIST_ENTRY mCallbackInfoListHead
= INITIALIZE_LIST_HEAD_VARIABLE (mCallbackInfoListHead
);
84 CPU_SAVE_STATE_CONVERSION mCpuSaveStateConvTable
[] = {
85 {EFI_SMM_SAVE_STATE_REGISTER_LDTBASE
, CPU_SAVE_STATE_GET_OFFSET(LDTBase
)},
86 {EFI_SMM_SAVE_STATE_REGISTER_ES
, CPU_SAVE_STATE_GET_OFFSET(ES
)},
87 {EFI_SMM_SAVE_STATE_REGISTER_CS
, CPU_SAVE_STATE_GET_OFFSET(CS
)},
88 {EFI_SMM_SAVE_STATE_REGISTER_SS
, CPU_SAVE_STATE_GET_OFFSET(SS
)},
89 {EFI_SMM_SAVE_STATE_REGISTER_DS
, CPU_SAVE_STATE_GET_OFFSET(DS
)},
90 {EFI_SMM_SAVE_STATE_REGISTER_FS
, CPU_SAVE_STATE_GET_OFFSET(FS
)},
91 {EFI_SMM_SAVE_STATE_REGISTER_GS
, CPU_SAVE_STATE_GET_OFFSET(GS
)},
92 {EFI_SMM_SAVE_STATE_REGISTER_TR_SEL
, CPU_SAVE_STATE_GET_OFFSET(TR
)},
93 {EFI_SMM_SAVE_STATE_REGISTER_DR7
, CPU_SAVE_STATE_GET_OFFSET(DR7
)},
94 {EFI_SMM_SAVE_STATE_REGISTER_DR6
, CPU_SAVE_STATE_GET_OFFSET(DR6
)},
95 {EFI_SMM_SAVE_STATE_REGISTER_RAX
, CPU_SAVE_STATE_GET_OFFSET(EAX
)},
96 {EFI_SMM_SAVE_STATE_REGISTER_RBX
, CPU_SAVE_STATE_GET_OFFSET(EBX
)},
97 {EFI_SMM_SAVE_STATE_REGISTER_RCX
, CPU_SAVE_STATE_GET_OFFSET(ECX
)},
98 {EFI_SMM_SAVE_STATE_REGISTER_RDX
, CPU_SAVE_STATE_GET_OFFSET(EDX
)},
99 {EFI_SMM_SAVE_STATE_REGISTER_RSP
, CPU_SAVE_STATE_GET_OFFSET(ESP
)},
100 {EFI_SMM_SAVE_STATE_REGISTER_RBP
, CPU_SAVE_STATE_GET_OFFSET(EBP
)},
101 {EFI_SMM_SAVE_STATE_REGISTER_RSI
, CPU_SAVE_STATE_GET_OFFSET(ESI
)},
102 {EFI_SMM_SAVE_STATE_REGISTER_RDI
, CPU_SAVE_STATE_GET_OFFSET(EDI
)},
103 {EFI_SMM_SAVE_STATE_REGISTER_RIP
, CPU_SAVE_STATE_GET_OFFSET(EIP
)},
104 {EFI_SMM_SAVE_STATE_REGISTER_RFLAGS
, CPU_SAVE_STATE_GET_OFFSET(EFLAGS
)},
105 {EFI_SMM_SAVE_STATE_REGISTER_CR0
, CPU_SAVE_STATE_GET_OFFSET(CR0
)},
106 {EFI_SMM_SAVE_STATE_REGISTER_CR3
, CPU_SAVE_STATE_GET_OFFSET(CR3
)}
110 PageFaultHandlerHook (
115 Read CpuSaveStates from PI for Framework use.
117 The function reads PI style CpuSaveStates of CpuIndex-th CPU for Framework driver use. If
118 ToRead is specified, the CpuSaveStates will be copied to ToRead, otherwise copied to
119 mFrameworkSmst->CpuSaveState[CpuIndex].
121 @param[in] CpuIndex The zero-based CPU index.
122 @param[in, out] ToRead If not NULL, CpuSaveStates will be copied to it.
128 IN OUT EFI_SMM_CPU_SAVE_STATE
*ToRead
133 EFI_SMM_CPU_STATE
*State
;
134 EFI_SMI_CPU_SAVE_STATE
*SaveState
;
136 State
= (EFI_SMM_CPU_STATE
*)gSmst
->CpuSaveState
[CpuIndex
];
137 if (ToRead
!= NULL
) {
138 SaveState
= &ToRead
->Ia32SaveState
;
140 SaveState
= &mFrameworkSmst
->CpuSaveState
[CpuIndex
].Ia32SaveState
;
143 if (State
->x86
.SMMRevId
< EFI_SMM_MIN_REV_ID_x64
) {
144 SaveState
->SMBASE
= State
->x86
.SMBASE
;
145 SaveState
->SMMRevId
= State
->x86
.SMMRevId
;
146 SaveState
->IORestart
= State
->x86
.IORestart
;
147 SaveState
->AutoHALTRestart
= State
->x86
.AutoHALTRestart
;
149 SaveState
->SMBASE
= State
->x64
.SMBASE
;
150 SaveState
->SMMRevId
= State
->x64
.SMMRevId
;
151 SaveState
->IORestart
= State
->x64
.IORestart
;
152 SaveState
->AutoHALTRestart
= State
->x64
.AutoHALTRestart
;
155 for (Index
= 0; Index
< sizeof (mCpuSaveStateConvTable
) / sizeof (CPU_SAVE_STATE_CONVERSION
); Index
++) {
157 /// Try to use SMM CPU Protocol to access CPU save states if possible
159 Status
= mSmmCpu
->ReadSaveState (
161 (UINTN
)sizeof (UINT32
),
162 mCpuSaveStateConvTable
[Index
].Register
,
164 ((UINT8
*)SaveState
) + mCpuSaveStateConvTable
[Index
].Offset
166 ASSERT_EFI_ERROR (Status
);
171 Write CpuSaveStates from Framework into PI.
173 The function writes back CpuSaveStates of CpuIndex-th CPU from PI to Framework. If
174 ToWrite is specified, it contains the CpuSaveStates to write from, otherwise CpuSaveStates
175 to write from mFrameworkSmst->CpuSaveState[CpuIndex].
177 @param[in] CpuIndex The zero-based CPU index.
178 @param[in] ToWrite If not NULL, CpuSaveStates to write from.
184 IN EFI_SMM_CPU_SAVE_STATE
*ToWrite
189 EFI_SMI_CPU_SAVE_STATE
*SaveState
;
191 if (ToWrite
!= NULL
) {
192 SaveState
= &ToWrite
->Ia32SaveState
;
194 SaveState
= &mFrameworkSmst
->CpuSaveState
[CpuIndex
].Ia32SaveState
;
197 for (Index
= 0; Index
< sizeof (mCpuSaveStateConvTable
) / sizeof (CPU_SAVE_STATE_CONVERSION
); Index
++) {
198 Status
= mSmmCpu
->WriteSaveState (
200 (UINTN
)sizeof (UINT32
),
201 mCpuSaveStateConvTable
[Index
].Register
,
203 ((UINT8
*)SaveState
) +
204 mCpuSaveStateConvTable
[Index
].Offset
210 Read or write a page that contains CpuSaveStates. Read is from PI to Framework.
211 Write is from Framework to PI.
213 This function reads or writes a page that contains CpuSaveStates. The page contains Framework
214 CpuSaveStates. On read, it reads PI style CpuSaveStates and fill the page up. On write, it
215 writes back from the page content to PI CpuSaveStates struct.
216 The first Framework CpuSaveStates (for CPU 0) is from mFrameworkSmst->CpuSaveState which is
217 page aligned. Because Framework CpuSaveStates are continuous, we can know which CPUs' SaveStates
218 are in the page start from PageAddress.
220 @param[in] PageAddress The base address for a page.
221 @param[in] IsRead TRUE for Read, FALSE for Write.
225 ReadWriteCpuStatePage (
226 IN UINT64 PageAddress
,
230 UINTN FirstSSIndex
; // Index of first CpuSaveState in the page
231 UINTN LastSSIndex
; // Index of last CpuSaveState in the page
232 BOOLEAN FirstSSAligned
; // Whether first CpuSaveState is page-aligned
233 BOOLEAN LastSSAligned
; // Whether the end of last CpuSaveState is page-aligned
237 FirstSSIndex
= ((UINTN
)PageAddress
- (UINTN
)mFrameworkSmst
->CpuSaveState
) / sizeof (EFI_SMM_CPU_SAVE_STATE
);
238 FirstSSAligned
= TRUE
;
239 if (((UINTN
)PageAddress
- (UINTN
)mFrameworkSmst
->CpuSaveState
) % sizeof (EFI_SMM_CPU_SAVE_STATE
) != 0) {
241 FirstSSAligned
= FALSE
;
243 LastSSIndex
= ((UINTN
)PageAddress
+ SIZE_4KB
- (UINTN
)mFrameworkSmst
->CpuSaveState
- 1) / sizeof (EFI_SMM_CPU_SAVE_STATE
);
244 LastSSAligned
= TRUE
;
245 if (((UINTN
)PageAddress
+ SIZE_4KB
- (UINTN
)mFrameworkSmst
->CpuSaveState
) % sizeof (EFI_SMM_CPU_SAVE_STATE
) != 0) {
247 LastSSAligned
= FALSE
;
249 for (CpuIndex
= FirstSSIndex
; CpuIndex
<= LastSSIndex
&& CpuIndex
< mNumberOfProcessors
; CpuIndex
++) {
251 ReadCpuSaveState (CpuIndex
, NULL
);
253 WriteCpuSaveState (CpuIndex
, NULL
);
256 if (!FirstSSAligned
) {
257 ReadCpuSaveState (FirstSSIndex
- 1, mShadowSaveState
);
258 ClippedSize
= (UINTN
)&mFrameworkSmst
->CpuSaveState
[FirstSSIndex
] & (SIZE_4KB
- 1);
260 CopyMem ((VOID
*)(UINTN
)PageAddress
, (VOID
*)((UINTN
)(mShadowSaveState
+ 1) - ClippedSize
), ClippedSize
);
262 CopyMem ((VOID
*)((UINTN
)(mShadowSaveState
+ 1) - ClippedSize
), (VOID
*)(UINTN
)PageAddress
, ClippedSize
);
263 WriteCpuSaveState (FirstSSIndex
- 1, mShadowSaveState
);
266 if (!LastSSAligned
&& LastSSIndex
+ 1 < mNumberOfProcessors
) {
267 ReadCpuSaveState (LastSSIndex
+ 1, mShadowSaveState
);
268 ClippedSize
= SIZE_4KB
- ((UINTN
)&mFrameworkSmst
->CpuSaveState
[LastSSIndex
+ 1] & (SIZE_4KB
- 1));
270 CopyMem (&mFrameworkSmst
->CpuSaveState
[LastSSIndex
+ 1], mShadowSaveState
, ClippedSize
);
272 CopyMem (mShadowSaveState
, &mFrameworkSmst
->CpuSaveState
[LastSSIndex
+ 1], ClippedSize
);
273 WriteCpuSaveState (LastSSIndex
+ 1, mShadowSaveState
);
279 The page fault handler that on-demand read PI CpuSaveStates for framework use. If the fault
280 is not targeted to mFrameworkSmst->CpuSaveState range, the function will return FALSE to let
281 PageFaultHandlerHook know it needs to pass the fault over to original page fault handler.
283 @retval TRUE The page fault is correctly handled.
284 @retval FALSE The page fault is not handled and is passed through to original handler.
295 UINTN NumCpuStatePages
;
297 ASSERT (mPageTableHookEnabled
);
298 AcquireSpinLock (&mPFLock
);
300 PageTable
= (UINT64
*)(UINTN
)(AsmReadCr3 () & mPhyMask
);
301 PFAddress
= AsmReadCr2 ();
302 NumCpuStatePages
= EFI_SIZE_TO_PAGES (mNumberOfProcessors
* sizeof (EFI_SMM_CPU_SAVE_STATE
));
304 if (((UINTN
)mFrameworkSmst
->CpuSaveState
& ~(SIZE_2MB
-1)) == (PFAddress
& ~(SIZE_2MB
-1))) {
305 if ((UINTN
)mFrameworkSmst
->CpuSaveState
<= PFAddress
&&
306 PFAddress
< (UINTN
)mFrameworkSmst
->CpuSaveState
+ EFI_PAGES_TO_SIZE (NumCpuStatePages
)
308 mCpuStatePageTable
[BitFieldRead64 (PFAddress
, 12, 20)] |= BIT0
| BIT1
; // present and rw
310 ReadWriteCpuStatePage (PFAddress
& ~(SIZE_4KB
-1), TRUE
);
317 ReleaseSpinLock (&mPFLock
);
322 Write back the dirty Framework CpuSaveStates to PI.
324 The function scans the page table for dirty pages in mFrameworkSmst->CpuSaveState
325 to write back to PI CpuSaveStates. It is meant to be called on each SmmBaseHelper SMI
326 callback after Framework handler is called.
330 WriteBackDirtyPages (
334 UINTN NumCpuStatePages
;
339 NumCpuStatePages
= EFI_SIZE_TO_PAGES (mNumberOfProcessors
* sizeof (EFI_SMM_CPU_SAVE_STATE
));
340 PTStartIndex
= (UINTN
)BitFieldRead64 ((UINT64
)mFrameworkSmst
->CpuSaveState
, 12, 20);
341 PTEndIndex
= (UINTN
)BitFieldRead64 ((UINT64
)mFrameworkSmst
->CpuSaveState
+ EFI_PAGES_TO_SIZE(NumCpuStatePages
) - 1, 12, 20);
342 for (PTIndex
= PTStartIndex
; PTIndex
<= PTEndIndex
; PTIndex
++) {
343 if ((mCpuStatePageTable
[PTIndex
] & (BIT0
|BIT6
)) == (BIT0
|BIT6
)) { // present and dirty?
344 ReadWriteCpuStatePage (mCpuStatePageTable
[PTIndex
] & mPhyMask
, FALSE
);
350 Hook IDT with our page fault handler so that the on-demand paging works on page fault.
352 The function hooks the IDT with PageFaultHandlerHook to get on-demand paging work for
353 PI<->Framework CpuSaveStates marshalling. It also saves original handler for pass-through
358 HookPageFaultHandler (
362 IA32_DESCRIPTOR Idtr
;
363 IA32_IDT_GATE_DESCRIPTOR
*IdtGateDesc
;
366 InitializeSpinLock (&mPFLock
);
369 IdtGateDesc
= (IA32_IDT_GATE_DESCRIPTOR
*) Idtr
.Base
;
370 OffsetUpper
= *(UINT32
*)((UINT64
*)IdtGateDesc
+ 1);
371 mOriginalHandler
= (VOID
*)(UINTN
)(LShiftU64 (OffsetUpper
, 32) + IdtGateDesc
[14].Bits
.OffsetLow
+ (IdtGateDesc
[14].Bits
.OffsetHigh
<< 16));
372 IdtGateDesc
[14].Bits
.OffsetLow
= (UINT32
)((UINTN
)PageFaultHandlerHook
& ((1 << 16) - 1));
373 IdtGateDesc
[14].Bits
.OffsetHigh
= (UINT32
)(((UINTN
)PageFaultHandlerHook
>> 16) & ((1 << 16) - 1));
377 Initialize page table for pages contain HookData.
379 The function initialize PDE for 2MB range that contains HookData. If the related PDE points
380 to a 2MB page, a page table will be allocated and initialized for 4KB pages. Otherwise we juse
381 use the original page table.
383 @param[in] HookData Based on which to initialize page table.
385 @return The pointer to a Page Table that points to 4KB pages which contain HookData.
388 InitCpuStatePageTable (
400 // Initialize physical address mask
401 // NOTE: Physical memory above virtual address limit is not supported !!!
403 AsmCpuid (0x80000008, (UINT32
*)&Index
, NULL
, NULL
, NULL
);
404 mPhyMask
= LShiftU64 (1, (UINT8
)Index
) - 1;
405 mPhyMask
&= (1ull << 48) - EFI_PAGE_SIZE
;
407 HookAddress
= (UINT64
)(UINTN
)HookData
;
408 PageTable
= (UINT64
*)(UINTN
)(AsmReadCr3 () & mPhyMask
);
409 PageTable
= (UINT64
*)(UINTN
)(PageTable
[BitFieldRead64 (HookAddress
, 39, 47)] & mPhyMask
);
410 PageTable
= (UINT64
*)(UINTN
)(PageTable
[BitFieldRead64 (HookAddress
, 30, 38)] & mPhyMask
);
412 PDPTE
= (UINT64
*)(UINTN
)PageTable
;
413 PDE
= PDPTE
[BitFieldRead64 (HookAddress
, 21, 29)];
414 ASSERT ((PDE
& BIT0
) != 0); // Present and 2M Page
416 if ((PDE
& BIT7
) == 0) { // 4KB Page Directory
417 PageTable
= (UINT64
*)(UINTN
)(PDE
& mPhyMask
);
419 ASSERT ((PDE
& mPhyMask
) == (HookAddress
& ~(SIZE_2MB
-1))); // 2MB Page Point to HookAddress
420 PageTable
= AllocatePages (1);
421 Address
= HookAddress
& ~(SIZE_2MB
-1);
422 for (Index
= 0; Index
< 512; Index
++) {
423 PageTable
[Index
] = Address
| BIT0
| BIT1
; // Present and RW
426 PDPTE
[BitFieldRead64 (HookAddress
, 21, 29)] = (UINT64
)(UINTN
)PageTable
| BIT0
| BIT1
; // Present and RW
432 Mark all the CpuSaveStates as not present.
434 The function marks all CpuSaveStates memory range as not present so that page fault can be triggered
435 on CpuSaveStates access. It is meant to be called on each SmmBaseHelper SMI callback before Framework
438 @param[in] CpuSaveState The base of CpuSaveStates.
443 IN EFI_SMM_CPU_SAVE_STATE
*CpuSaveState
450 PTStartIndex
= BitFieldRead64 ((UINTN
)CpuSaveState
, 12, 20);
451 PTEndIndex
= BitFieldRead64 ((UINTN
)CpuSaveState
+ mNumberOfProcessors
* sizeof (EFI_SMM_CPU_SAVE_STATE
) - 1, 12, 20);
452 for (Index
= PTStartIndex
; Index
<= PTEndIndex
; Index
++) {
453 mCpuStatePageTable
[Index
] &= ~(BIT0
|BIT5
|BIT6
); // not present nor accessed nor dirty
458 Framework SMST SmmInstallConfigurationTable() Thunk.
460 This thunk calls the PI SMM SmmInstallConfigurationTable() and then update the configuration
461 table related fields in the Framework SMST because the PI SMM SmmInstallConfigurationTable()
462 function may modify these fields.
464 @param[in] SystemTable A pointer to the SMM System Table.
465 @param[in] Guid A pointer to the GUID for the entry to add, update, or remove.
466 @param[in] Table A pointer to the buffer of the table to add.
467 @param[in] TableSize The size of the table to install.
469 @retval EFI_SUCCESS The (Guid, Table) pair was added, updated, or removed.
470 @retval EFI_INVALID_PARAMETER Guid is not valid.
471 @retval EFI_NOT_FOUND An attempt was made to delete a non-existent entry.
472 @retval EFI_OUT_OF_RESOURCES There is not enough memory available to complete the operation.
476 SmmInstallConfigurationTable (
477 IN EFI_SMM_SYSTEM_TABLE
*SystemTable
,
485 Status
= gSmst
->SmmInstallConfigurationTable (gSmst
, Guid
, Table
, TableSize
);
486 if (!EFI_ERROR (Status
)) {
487 mFrameworkSmst
->NumberOfTableEntries
= gSmst
->NumberOfTableEntries
;
488 mFrameworkSmst
->SmmConfigurationTable
= gSmst
->SmmConfigurationTable
;
494 Initialize all the stuff needed for on-demand paging hooks for PI<->Framework
495 CpuSaveStates marshalling.
497 @param[in] FrameworkSmst Framework SMM system table pointer.
502 IN EFI_SMM_SYSTEM_TABLE
*FrameworkSmst
505 UINTN NumCpuStatePages
;
510 mPageTableHookEnabled
= FALSE
;
511 NumCpuStatePages
= EFI_SIZE_TO_PAGES (mNumberOfProcessors
* sizeof (EFI_SMM_CPU_SAVE_STATE
));
513 // Only hook page table for X64 image and less than 2MB needed to hold all CPU Save States
515 if (EFI_IMAGE_MACHINE_TYPE_SUPPORTED(EFI_IMAGE_MACHINE_X64
) && NumCpuStatePages
<= EFI_SIZE_TO_PAGES (SIZE_2MB
)) {
517 // Allocate double page size to make sure all CPU Save States are in one 2MB page.
519 CpuStatePage
= (UINTN
)AllocatePages (NumCpuStatePages
* 2);
520 ASSERT (CpuStatePage
!= 0);
521 Bottom2MPage
= CpuStatePage
& ~(SIZE_2MB
-1);
522 Top2MPage
= (CpuStatePage
+ EFI_PAGES_TO_SIZE (NumCpuStatePages
* 2) - 1) & ~(SIZE_2MB
-1);
523 if (Bottom2MPage
== Top2MPage
||
524 CpuStatePage
+ EFI_PAGES_TO_SIZE (NumCpuStatePages
* 2) - Top2MPage
>= EFI_PAGES_TO_SIZE (NumCpuStatePages
)
527 // If the allocated 4KB pages are within the same 2MB page or higher portion is larger, use higher portion pages.
529 FrameworkSmst
->CpuSaveState
= (EFI_SMM_CPU_SAVE_STATE
*)(CpuStatePage
+ EFI_PAGES_TO_SIZE (NumCpuStatePages
));
530 FreePages ((VOID
*)CpuStatePage
, NumCpuStatePages
);
532 FrameworkSmst
->CpuSaveState
= (EFI_SMM_CPU_SAVE_STATE
*)CpuStatePage
;
533 FreePages ((VOID
*)(CpuStatePage
+ EFI_PAGES_TO_SIZE (NumCpuStatePages
)), NumCpuStatePages
);
536 // Add temporary working buffer for hooking
538 mShadowSaveState
= (EFI_SMM_CPU_SAVE_STATE
*) AllocatePool (sizeof (EFI_SMM_CPU_SAVE_STATE
));
539 ASSERT (mShadowSaveState
!= NULL
);
541 // Allocate and initialize 4KB Page Table for hooking CpuSaveState.
542 // Replace the original 2MB PDE with new 4KB page table.
544 mCpuStatePageTable
= InitCpuStatePageTable (FrameworkSmst
->CpuSaveState
);
546 // Mark PTE for CpuSaveState as non-exist.
548 HookCpuStateMemory (FrameworkSmst
->CpuSaveState
);
549 HookPageFaultHandler ();
551 mPageTableHookEnabled
= TRUE
;
553 mHookInitialized
= TRUE
;
557 Construct a Framework SMST based on the PI SMM SMST.
559 @return Pointer to the constructed Framework SMST.
561 EFI_SMM_SYSTEM_TABLE
*
562 ConstructFrameworkSmst (
566 EFI_SMM_SYSTEM_TABLE
*FrameworkSmst
;
568 FrameworkSmst
= (EFI_SMM_SYSTEM_TABLE
*)AllocatePool (sizeof (EFI_SMM_SYSTEM_TABLE
));
569 ASSERT (FrameworkSmst
!= NULL
);
572 /// Copy same things from PI SMST to Framework SMST
574 CopyMem (FrameworkSmst
, gSmst
, (UINTN
)(&((EFI_SMM_SYSTEM_TABLE
*)0)->SmmIo
));
576 &FrameworkSmst
->SmmIo
,
578 sizeof (EFI_SMM_SYSTEM_TABLE
) - (UINTN
)(&((EFI_SMM_SYSTEM_TABLE
*)0)->SmmIo
)
582 /// Update Framework SMST
584 FrameworkSmst
->Hdr
.Revision
= EFI_SMM_SYSTEM_TABLE_REVISION
;
585 CopyGuid (&FrameworkSmst
->EfiSmmCpuIoGuid
, &mEfiSmmCpuIoGuid
);
587 mHookInitialized
= FALSE
;
588 FrameworkSmst
->CpuSaveState
= (EFI_SMM_CPU_SAVE_STATE
*)AllocateZeroPool (mNumberOfProcessors
* sizeof (EFI_SMM_CPU_SAVE_STATE
));
589 ASSERT (FrameworkSmst
->CpuSaveState
!= NULL
);
592 /// Do not support floating point state now
594 FrameworkSmst
->CpuOptionalFloatingPointState
= NULL
;
596 FrameworkSmst
->SmmInstallConfigurationTable
= SmmInstallConfigurationTable
;
598 return FrameworkSmst
;
602 Load a given Framework SMM driver into SMRAM and invoke its entry point.
604 @param[in] ParentImageHandle Parent Image Handle.
605 @param[in] FilePath Location of the image to be installed as the handler.
606 @param[in] SourceBuffer Optional source buffer in case the image file
608 @param[in] SourceSize Size of the source image file, if in memory.
609 @param[out] ImageHandle The handle that the base driver uses to decode
610 the handler. Unique among SMM handlers only,
611 not unique across DXE/EFI.
613 @retval EFI_SUCCESS The operation was successful.
614 @retval EFI_OUT_OF_RESOURCES There were no additional SMRAM resources to load the handler
615 @retval EFI_UNSUPPORTED Can not find its copy in normal memory.
616 @retval EFI_INVALID_PARAMETER The handlers was not the correct image type
620 IN EFI_HANDLE ParentImageHandle
,
621 IN EFI_DEVICE_PATH_PROTOCOL
*FilePath
,
622 IN VOID
*SourceBuffer
,
624 OUT EFI_HANDLE
*ImageHandle
630 EFI_PHYSICAL_ADDRESS DstBuffer
;
632 if (FilePath
== NULL
|| ImageHandle
== NULL
) {
633 return EFI_INVALID_PARAMETER
;
638 OrgPageCount
= PageCount
;
639 DstBuffer
= (UINTN
)-1;
640 Status
= gSmst
->SmmAllocatePages (
642 EfiRuntimeServicesCode
,
646 if (EFI_ERROR (Status
)) {
650 Status
= mLoadPe32Image
->LoadPeImage (
660 EFI_LOAD_PE_IMAGE_ATTRIBUTE_NONE
662 if (EFI_ERROR (Status
)) {
663 FreePages ((VOID
*)(UINTN
)DstBuffer
, OrgPageCount
);
665 } while (Status
== EFI_BUFFER_TOO_SMALL
);
667 if (!EFI_ERROR (Status
)) {
669 /// Update MP state in Framework SMST before transferring control to Framework SMM driver entry point
670 /// in case it may invoke AP
672 mFrameworkSmst
->CurrentlyExecutingCpu
= gSmst
->CurrentlyExecutingCpu
;
674 Status
= gBS
->StartImage (*ImageHandle
, NULL
, NULL
);
675 if (EFI_ERROR (Status
)) {
676 mLoadPe32Image
->UnLoadPeImage (mLoadPe32Image
, *ImageHandle
);
678 FreePages ((VOID
*)(UINTN
)DstBuffer
, PageCount
);
687 Thunk service of EFI_SMM_BASE_PROTOCOL.Register().
689 @param[in, out] FunctionData Pointer to SMMBASE_FUNCTION_DATA.
693 IN OUT SMMBASE_FUNCTION_DATA
*FunctionData
698 if (mLocked
|| FunctionData
->Args
.Register
.LegacyIA32Binary
) {
699 Status
= EFI_UNSUPPORTED
;
702 FunctionData
->SmmBaseImageHandle
,
703 FunctionData
->Args
.Register
.FilePath
,
704 FunctionData
->Args
.Register
.SourceBuffer
,
705 FunctionData
->Args
.Register
.SourceSize
,
706 FunctionData
->Args
.Register
.ImageHandle
709 FunctionData
->Status
= Status
;
713 Thunk service of EFI_SMM_BASE_PROTOCOL.UnRegister().
715 @param[in, out] FunctionData Pointer to SMMBASE_FUNCTION_DATA.
719 IN OUT SMMBASE_FUNCTION_DATA
*FunctionData
723 /// Unregister not supported now
725 FunctionData
->Status
= EFI_UNSUPPORTED
;
729 Search for Framework SMI handler information according to specific PI SMM dispatch handle.
731 @param[in] DispatchHandle The unique handle assigned by SmiHandlerRegister().
733 @return Pointer to CALLBACK_INFO. If NULL, no callback info record is found.
737 IN EFI_HANDLE DispatchHandle
742 Node
= GetFirstNode (&mCallbackInfoListHead
);
743 while (!IsNull (&mCallbackInfoListHead
, Node
)) {
744 if (((CALLBACK_INFO
*)Node
)->DispatchHandle
== DispatchHandle
) {
745 return (CALLBACK_INFO
*)Node
;
747 Node
= GetNextNode (&mCallbackInfoListHead
, Node
);
753 Callback thunk for Framework SMI handler.
755 This thunk functions calls the Framework SMI handler and converts the return value
756 defined from Framework SMI handlers to a correpsonding return value defined by PI SMM.
758 @param[in] DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister().
759 @param[in] Context Points to an optional handler context which was specified when the
760 handler was registered.
761 @param[in, out] CommBuffer A pointer to a collection of data in memory that will
762 be conveyed from a non-SMM environment into an SMM environment.
763 @param[in, out] CommBufferSize The size of the CommBuffer.
765 @retval EFI_SUCCESS The interrupt was handled and quiesced. No other handlers
766 should still be called.
767 @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quiesced but other handlers should
769 @retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pending and other handlers should still
771 @retval EFI_INTERRUPT_PENDING The interrupt could not be quiesced.
776 IN EFI_HANDLE DispatchHandle
,
777 IN CONST VOID
*Context OPTIONAL
,
778 IN OUT VOID
*CommBuffer OPTIONAL
,
779 IN OUT UINTN
*CommBufferSize OPTIONAL
783 CALLBACK_INFO
*CallbackInfo
;
787 /// Before transferring the control into the Framework SMI handler, update CPU Save States
788 /// and MP states in the Framework SMST.
791 if (!mHookInitialized
) {
792 InitHook (mFrameworkSmst
);
794 if (mPageTableHookEnabled
) {
795 HookCpuStateMemory (mFrameworkSmst
->CpuSaveState
);
798 for (CpuIndex
= 0; CpuIndex
< mNumberOfProcessors
; CpuIndex
++) {
799 ReadCpuSaveState (CpuIndex
, NULL
);
803 mFrameworkSmst
->SmmStartupThisAp
= gSmst
->SmmStartupThisAp
;
804 mFrameworkSmst
->NumberOfCpus
= mNumberOfProcessors
;
805 mFrameworkSmst
->CurrentlyExecutingCpu
= gSmst
->CurrentlyExecutingCpu
;
808 /// Search for Framework SMI handler information
810 CallbackInfo
= GetCallbackInfo (DispatchHandle
);
811 ASSERT (CallbackInfo
!= NULL
);
814 /// Thunk into original Framwork SMI handler
816 Status
= (CallbackInfo
->CallbackAddress
) (
817 CallbackInfo
->SmmImageHandle
,
818 CallbackInfo
->CommunicationBuffer
,
819 CallbackInfo
->SourceSize
822 /// Save CPU Save States in case any of them was modified
824 if (mPageTableHookEnabled
) {
825 WriteBackDirtyPages ();
827 for (CpuIndex
= 0; CpuIndex
< mNumberOfProcessors
; CpuIndex
++) {
828 WriteCpuSaveState (CpuIndex
, NULL
);
833 /// Conversion of returned status code
836 case EFI_HANDLER_SUCCESS
:
837 Status
= EFI_WARN_INTERRUPT_SOURCE_QUIESCED
;
839 case EFI_HANDLER_CRITICAL_EXIT
:
840 case EFI_HANDLER_SOURCE_QUIESCED
:
841 Status
= EFI_SUCCESS
;
843 case EFI_HANDLER_SOURCE_PENDING
:
844 Status
= EFI_WARN_INTERRUPT_SOURCE_PENDING
;
851 Thunk service of EFI_SMM_BASE_PROTOCOL.RegisterCallback().
853 @param[in, out] FunctionData Pointer to SMMBASE_FUNCTION_DATA.
857 IN OUT SMMBASE_FUNCTION_DATA
*FunctionData
860 CALLBACK_INFO
*Buffer
;
863 FunctionData
->Status
= EFI_UNSUPPORTED
;
868 /// Note that MakeLast and FloatingPointSave options are not supported in PI SMM
872 /// Allocate buffer for callback thunk information
874 Buffer
= (CALLBACK_INFO
*)AllocateZeroPool (sizeof (CALLBACK_INFO
));
875 if (Buffer
== NULL
) {
876 FunctionData
->Status
= EFI_OUT_OF_RESOURCES
;
881 /// Fill SmmImageHandle and CallbackAddress into the thunk
883 Buffer
->SmmImageHandle
= FunctionData
->Args
.RegisterCallback
.SmmImageHandle
;
884 Buffer
->CallbackAddress
= FunctionData
->Args
.RegisterCallback
.CallbackAddress
;
887 /// Register the thunk code as a root SMI handler
889 FunctionData
->Status
= gSmst
->SmiHandlerRegister (
892 &Buffer
->DispatchHandle
894 if (EFI_ERROR (FunctionData
->Status
)) {
900 /// Save this callback info
902 InsertTailList (&mCallbackInfoListHead
, &Buffer
->Link
);
907 Thunk service of EFI_SMM_BASE_PROTOCOL.SmmAllocatePool().
909 @param[in, out] FunctionData Pointer to SMMBASE_FUNCTION_DATA.
913 IN OUT SMMBASE_FUNCTION_DATA
*FunctionData
917 FunctionData
->Status
= EFI_UNSUPPORTED
;
919 FunctionData
->Status
= gSmst
->SmmAllocatePool (
920 FunctionData
->Args
.AllocatePool
.PoolType
,
921 FunctionData
->Args
.AllocatePool
.Size
,
922 FunctionData
->Args
.AllocatePool
.Buffer
928 Thunk service of EFI_SMM_BASE_PROTOCOL.SmmFreePool().
930 @param[in, out] FunctionData Pointer to SMMBASE_FUNCTION_DATA.
934 IN OUT SMMBASE_FUNCTION_DATA
*FunctionData
938 FunctionData
->Status
= EFI_UNSUPPORTED
;
940 FreePool (FunctionData
->Args
.FreePool
.Buffer
);
941 FunctionData
->Status
= EFI_SUCCESS
;
946 Thunk service of EFI_SMM_BASE_PROTOCOL.Communicate().
948 @param[in, out] FunctionData Pointer to SMMBASE_FUNCTION_DATA.
952 IN OUT SMMBASE_FUNCTION_DATA
*FunctionData
956 CALLBACK_INFO
*CallbackInfo
;
958 if (FunctionData
->Args
.Communicate
.CommunicationBuffer
== NULL
) {
959 FunctionData
->Status
= EFI_INVALID_PARAMETER
;
963 Node
= GetFirstNode (&mCallbackInfoListHead
);
964 while (!IsNull (&mCallbackInfoListHead
, Node
)) {
965 CallbackInfo
= (CALLBACK_INFO
*)Node
;
967 if (FunctionData
->Args
.Communicate
.ImageHandle
== CallbackInfo
->SmmImageHandle
) {
968 CallbackInfo
->CommunicationBuffer
= FunctionData
->Args
.Communicate
.CommunicationBuffer
;
969 CallbackInfo
->SourceSize
= FunctionData
->Args
.Communicate
.SourceSize
;
972 /// The message was successfully posted.
974 FunctionData
->Status
= EFI_SUCCESS
;
977 Node
= GetNextNode (&mCallbackInfoListHead
, Node
);
980 FunctionData
->Status
= EFI_INVALID_PARAMETER
;
984 Communication service SMI Handler entry.
986 This SMI handler provides services for the SMM Base Thunk driver.
988 @param[in] DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister().
989 @param[in] RegisterContext Points to an optional handler context which was specified when the
990 handler was registered.
991 @param[in, out] CommBuffer A pointer to a collection of data in memory that will
992 be conveyed from a non-SMM environment into an SMM environment.
993 @param[in, out] CommBufferSize The size of the CommBuffer.
995 @retval EFI_SUCCESS The interrupt was handled and quiesced. No other handlers
996 should still be called.
997 @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quiesced but other handlers should
999 @retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pending and other handlers should still
1001 @retval EFI_INTERRUPT_PENDING The interrupt could not be quiesced.
1006 IN EFI_HANDLE DispatchHandle
,
1007 IN CONST VOID
*RegisterContext
,
1008 IN OUT VOID
*CommBuffer
,
1009 IN OUT UINTN
*CommBufferSize
1012 SMMBASE_FUNCTION_DATA
*FunctionData
;
1014 ASSERT (CommBuffer
!= NULL
);
1015 ASSERT (*CommBufferSize
== sizeof (SMMBASE_FUNCTION_DATA
));
1017 FunctionData
= (SMMBASE_FUNCTION_DATA
*)CommBuffer
;
1019 switch (FunctionData
->Function
) {
1020 case SmmBaseFunctionRegister
:
1021 Register (FunctionData
);
1023 case SmmBaseFunctionUnregister
:
1024 UnRegister (FunctionData
);
1026 case SmmBaseFunctionRegisterCallback
:
1027 RegisterCallback (FunctionData
);
1029 case SmmBaseFunctionAllocatePool
:
1030 HelperAllocatePool (FunctionData
);
1032 case SmmBaseFunctionFreePool
:
1033 HelperFreePool (FunctionData
);
1035 case SmmBaseFunctionCommunicate
:
1036 HelperCommunicate (FunctionData
);
1040 FunctionData
->Status
= EFI_UNSUPPORTED
;
1046 Smm Ready To Lock event notification handler.
1048 It sets a flag indicating that SMRAM has been locked.
1050 @param[in] Protocol Points to the protocol's unique identifier.
1051 @param[in] Interface Points to the interface instance.
1052 @param[in] Handle The handle on which the interface was installed.
1054 @retval EFI_SUCCESS Notification handler runs successfully.
1058 SmmReadyToLockEventNotify (
1059 IN CONST EFI_GUID
*Protocol
,
1061 IN EFI_HANDLE Handle
1069 Entry point function of the SMM Base Helper SMM driver.
1071 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1072 @param[in] SystemTable A pointer to the EFI System Table.
1074 @retval EFI_SUCCESS The entry point is executed successfully.
1075 @retval other Some error occurs when executing this entry point.
1080 IN EFI_HANDLE ImageHandle
,
1081 IN EFI_SYSTEM_TABLE
*SystemTable
1085 EFI_MP_SERVICES_PROTOCOL
*MpServices
;
1087 UINTN NumberOfEnabledProcessors
;
1092 /// Locate SMM CPU Protocol which is used later to retrieve/update CPU Save States
1094 Status
= gSmst
->SmmLocateProtocol (&gEfiSmmCpuProtocolGuid
, NULL
, (VOID
**) &mSmmCpu
);
1095 ASSERT_EFI_ERROR (Status
);
1098 /// Locate PE32 Image Protocol which is used later to load Framework SMM driver
1100 Status
= SystemTable
->BootServices
->LocateProtocol (&gEfiLoadPeImageProtocolGuid
, NULL
, (VOID
**) &mLoadPe32Image
);
1101 ASSERT_EFI_ERROR (Status
);
1104 // Get MP Services Protocol
1106 Status
= SystemTable
->BootServices
->LocateProtocol (&gEfiMpServiceProtocolGuid
, NULL
, (VOID
**)&MpServices
);
1107 ASSERT_EFI_ERROR (Status
);
1110 // Use MP Services Protocol to retrieve the number of processors and number of enabled processors
1112 Status
= MpServices
->GetNumberOfProcessors (MpServices
, &mNumberOfProcessors
, &NumberOfEnabledProcessors
);
1113 ASSERT_EFI_ERROR (Status
);
1116 /// Interface structure of SMM BASE Helper Ready Protocol is allocated from UEFI pool
1117 /// instead of SMM pool so that SMM Base Thunk driver can access it in Non-SMM mode.
1119 Status
= gBS
->AllocatePool (
1120 EfiBootServicesData
,
1121 sizeof (EFI_SMM_BASE_HELPER_READY_PROTOCOL
),
1122 (VOID
**)&mSmmBaseHelperReady
1124 ASSERT_EFI_ERROR (Status
);
1127 /// Construct Framework SMST from PI SMST
1129 mFrameworkSmst
= ConstructFrameworkSmst ();
1130 mSmmBaseHelperReady
->FrameworkSmst
= mFrameworkSmst
;
1131 mSmmBaseHelperReady
->ServiceEntry
= SmmHandlerEntry
;
1134 // Register SMM Ready To Lock Protocol notification
1136 Status
= gSmst
->SmmRegisterProtocolNotify (
1137 &gEfiSmmReadyToLockProtocolGuid
,
1138 SmmReadyToLockEventNotify
,
1141 ASSERT_EFI_ERROR (Status
);
1144 /// Register SMM Base Helper services for SMM Base Thunk driver
1146 Status
= gSmst
->SmiHandlerRegister (SmmHandlerEntry
, &gEfiSmmBaseThunkCommunicationGuid
, &mDispatchHandle
);
1147 ASSERT_EFI_ERROR (Status
);
1150 /// Install EFI SMM Base Helper Protocol in the UEFI handle database
1152 Status
= gBS
->InstallProtocolInterface (
1154 &gEfiSmmBaseHelperReadyProtocolGuid
,
1155 EFI_NATIVE_INTERFACE
,
1158 ASSERT_EFI_ERROR (Status
);