PiSmmCpuDxeSmm.h@ 86513

Last change on this file since 86513 was 85718, checked in by vboxsync, 4 years ago
Devices/EFI: Merge edk-stable202005 and make it build, bugref:4643
Property svn:eol-style set to `native`
File size: 48.5 KB

Line
1	/** @file
2	Agent Module to load other modules to deploy SMM Entry Vector for X86 CPU.
3
4	Copyright (c) 2009 - 2020, Intel Corporation. All rights reserved.<BR>
5	Copyright (c) 2017, AMD Incorporated. All rights reserved.<BR>
6
7	SPDX-License-Identifier: BSD-2-Clause-Patent
8
9	**/
10
11	#ifndef _CPU_PISMMCPUDXESMM_H_
12	#define _CPU_PISMMCPUDXESMM_H_
13
14	#include <PiSmm.h>
15
16	#include <Protocol/MpService.h>
17	#include <Protocol/SmmConfiguration.h>
18	#include <Protocol/SmmCpu.h>
19	#include <Protocol/SmmAccess2.h>
20	#include <Protocol/SmmReadyToLock.h>
21	#include <Protocol/SmmCpuService.h>
22	#include <Protocol/SmmMemoryAttribute.h>
23	#include <Protocol/MmMp.h>
24
25	#include <Guid/AcpiS3Context.h>
26	#include <Guid/MemoryAttributesTable.h>
27	#include <Guid/PiSmmMemoryAttributesTable.h>
28
29	#include <Library/BaseLib.h>
30	#include <Library/IoLib.h>
31	#include <Library/TimerLib.h>
32	#include <Library/SynchronizationLib.h>
33	#include <Library/DebugLib.h>
34	#include <Library/BaseMemoryLib.h>
35	#include <Library/PcdLib.h>
36	#include <Library/MtrrLib.h>
37	#include <Library/SmmCpuPlatformHookLib.h>
38	#include <Library/SmmServicesTableLib.h>
39	#include <Library/MemoryAllocationLib.h>
40	#include <Library/UefiBootServicesTableLib.h>
41	#include <Library/UefiRuntimeServicesTableLib.h>
42	#include <Library/DebugAgentLib.h>
43	#include <Library/UefiLib.h>
44	#include <Library/HobLib.h>
45	#include <Library/LocalApicLib.h>
46	#include <Library/UefiCpuLib.h>
47	#include <Library/CpuExceptionHandlerLib.h>
48	#include <Library/ReportStatusCodeLib.h>
49	#include <Library/SmmCpuFeaturesLib.h>
50	#include <Library/PeCoffGetEntryPointLib.h>
51	#include <Library/RegisterCpuFeaturesLib.h>
52
53	#include <AcpiCpuData.h>
54	#include <CpuHotPlugData.h>
55
56	#include <Register/Intel/Cpuid.h>
57	#include <Register/Intel/Msr.h>
58
59	#include "CpuService.h"
60	#include "SmmProfile.h"
61
62	//
63	// CET definition
64	//
65	#define CPUID_CET_SS BIT7
66	#define CPUID_CET_IBT BIT20
67
68	#define CR4_CET_ENABLE BIT23
69
70	#define MSR_IA32_S_CET 0x6A2
71	#define MSR_IA32_PL0_SSP 0x6A4
72	#define MSR_IA32_INTERRUPT_SSP_TABLE_ADDR 0x6A8
73
74	typedef union {
75	struct {
76	// enable shadow stacks
77	UINT32 SH_STK_ENP:1;
78	// enable the WRSS{D,Q}W instructions.
79	UINT32 WR_SHSTK_EN:1;
80	// enable tracking of indirect call/jmp targets to be ENDBRANCH instruction.
81	UINT32 ENDBR_EN:1;
82	// enable legacy compatibility treatment for indirect call/jmp tracking.
83	UINT32 LEG_IW_EN:1;
84	// enable use of no-track prefix on indirect call/jmp.
85	UINT32 NO_TRACK_EN:1;
86	// disable suppression of CET indirect branch tracking on legacy compatibility.
87	UINT32 SUPPRESS_DIS:1;
88	UINT32 RSVD:4;
89	// indirect branch tracking is suppressed.
90	// This bit can be written to 1 only if TRACKER is written as IDLE.
91	UINT32 SUPPRESS:1;
92	// Value of the endbranch state machine
93	// Values: IDLE (0), WAIT_FOR_ENDBRANCH(1).
94	UINT32 TRACKER:1;
95	// linear address of a bitmap in memory indicating valid
96	// pages as target of CALL/JMP_indirect that do not land on ENDBRANCH when CET is enabled
97	// and not suppressed. Valid when ENDBR_EN is 1. Must be machine canonical when written on
98	// parts that support 64 bit mode. On parts that do not support 64 bit mode, the bits 63:32 are
99	// reserved and must be 0. This value is extended by 12 bits at the low end to form the base address
100	// (this automatically aligns the address on a 4-Kbyte boundary).
101	UINT32 EB_LEG_BITMAP_BASE_low:12;
102	UINT32 EB_LEG_BITMAP_BASE_high:32;
103	} Bits;
104	UINT64 Uint64;
105	} MSR_IA32_CET;
106
107	//
108	// MSRs required for configuration of SMM Code Access Check
109	//
110	#define EFI_MSR_SMM_MCA_CAP 0x17D
111	#define SMM_CODE_ACCESS_CHK_BIT BIT58
112
113	#define SMM_FEATURE_CONTROL_LOCK_BIT BIT0
114	#define SMM_CODE_CHK_EN_BIT BIT2
115
116	///
117	/// Page Table Entry
118	///
119	#define IA32_PG_P BIT0
120	#define IA32_PG_RW BIT1
121	#define IA32_PG_U BIT2
122	#define IA32_PG_WT BIT3
123	#define IA32_PG_CD BIT4
124	#define IA32_PG_A BIT5
125	#define IA32_PG_D BIT6
126	#define IA32_PG_PS BIT7
127	#define IA32_PG_PAT_2M BIT12
128	#define IA32_PG_PAT_4K IA32_PG_PS
129	#define IA32_PG_PMNT BIT62
130	#define IA32_PG_NX BIT63
131
132	#define PAGE_ATTRIBUTE_BITS (IA32_PG_D \| IA32_PG_A \| IA32_PG_U \| IA32_PG_RW \| IA32_PG_P)
133	//
134	// Bits 1, 2, 5, 6 are reserved in the IA32 PAE PDPTE
135	// X64 PAE PDPTE does not have such restriction
136	//
137	#define IA32_PAE_PDPTE_ATTRIBUTE_BITS (IA32_PG_P)
138
139	#define PAGE_PROGATE_BITS (IA32_PG_NX \| PAGE_ATTRIBUTE_BITS)
140
141	#define PAGING_4K_MASK 0xFFF
142	#define PAGING_2M_MASK 0x1FFFFF
143	#define PAGING_1G_MASK 0x3FFFFFFF
144
145	#define PAGING_PAE_INDEX_MASK 0x1FF
146
147	#define PAGING_4K_ADDRESS_MASK_64 0x000FFFFFFFFFF000ull
148	#define PAGING_2M_ADDRESS_MASK_64 0x000FFFFFFFE00000ull
149	#define PAGING_1G_ADDRESS_MASK_64 0x000FFFFFC0000000ull
150
151	#define SMRR_MAX_ADDRESS BASE_4GB
152
153	typedef enum {
154	PageNone,
155	Page4K,
156	Page2M,
157	Page1G,
158	} PAGE_ATTRIBUTE;
159
160	typedef struct {
161	PAGE_ATTRIBUTE Attribute;
162	UINT64 Length;
163	UINT64 AddressMask;
164	} PAGE_ATTRIBUTE_TABLE;
165
166	//
167	// Size of Task-State Segment defined in IA32 Manual
168	//
169	#define TSS_SIZE 104
170	#define EXCEPTION_TSS_SIZE (TSS_SIZE + 4) // Add 4 bytes SSP
171	#define TSS_X64_IST1_OFFSET 36
172	#define TSS_IA32_CR3_OFFSET 28
173	#define TSS_IA32_ESP_OFFSET 56
174	#define TSS_IA32_SSP_OFFSET 104
175
176	#define CR0_WP BIT16
177
178	//
179	// Code select value
180	//
181	#define PROTECT_MODE_CODE_SEGMENT 0x08
182	#define LONG_MODE_CODE_SEGMENT 0x38
183
184	//
185	// The size 0x20 must be bigger than
186	// the size of template code of SmmInit. Currently,
187	// the size of SmmInit requires the 0x16 Bytes buffer
188	// at least.
189	//
190	#define BACK_BUF_SIZE 0x20
191
192	#define EXCEPTION_VECTOR_NUMBER 0x20
193
194	#define INVALID_APIC_ID 0xFFFFFFFFFFFFFFFFULL
195
196	typedef UINT32 SMM_CPU_ARRIVAL_EXCEPTIONS;
197	#define ARRIVAL_EXCEPTION_BLOCKED 0x1
198	#define ARRIVAL_EXCEPTION_DELAYED 0x2
199	#define ARRIVAL_EXCEPTION_SMI_DISABLED 0x4
200
201	//
202	// Wrapper used to convert EFI_AP_PROCEDURE2 and EFI_AP_PROCEDURE.
203	//
204	typedef struct {
205	EFI_AP_PROCEDURE Procedure;
206	VOID *ProcedureArgument;
207	} PROCEDURE_WRAPPER;
208
209	#define PROCEDURE_TOKEN_SIGNATURE SIGNATURE_32 ('P', 'R', 'T', 'S')
210
211	typedef struct {
212	UINTN Signature;
213	LIST_ENTRY Link;
214
215	SPIN_LOCK *SpinLock;
216	volatile UINT32 RunningApCount;
217	} PROCEDURE_TOKEN;
218
219	#define PROCEDURE_TOKEN_FROM_LINK(a) CR (a, PROCEDURE_TOKEN, Link, PROCEDURE_TOKEN_SIGNATURE)
220
221	#define TOKEN_BUFFER_SIGNATURE SIGNATURE_32 ('T', 'K', 'B', 'S')
222
223	typedef struct {
224	UINTN Signature;
225	LIST_ENTRY Link;
226
227	UINT8 *Buffer;
228	} TOKEN_BUFFER;
229
230	#define TOKEN_BUFFER_FROM_LINK(a) CR (a, TOKEN_BUFFER, Link, TOKEN_BUFFER_SIGNATURE)
231
232	//
233	// Private structure for the SMM CPU module that is stored in DXE Runtime memory
234	// Contains the SMM Configuration Protocols that is produced.
235	// Contains a mix of DXE and SMM contents. All the fields must be used properly.
236	//
237	#define SMM_CPU_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('s', 'c', 'p', 'u')
238
239	typedef struct {
240	UINTN Signature;
241
242	EFI_HANDLE SmmCpuHandle;
243
244	EFI_PROCESSOR_INFORMATION *ProcessorInfo;
245	SMM_CPU_OPERATION *Operation;
246	UINTN *CpuSaveStateSize;
247	VOID **CpuSaveState;
248
249	EFI_SMM_RESERVED_SMRAM_REGION SmmReservedSmramRegion[1];
250	EFI_SMM_ENTRY_CONTEXT SmmCoreEntryContext;
251	EFI_SMM_ENTRY_POINT SmmCoreEntry;
252
253	EFI_SMM_CONFIGURATION_PROTOCOL SmmConfiguration;
254
255	PROCEDURE_WRAPPER *ApWrapperFunc;
256	LIST_ENTRY TokenList;
257	LIST_ENTRY *FirstFreeToken;
258	} SMM_CPU_PRIVATE_DATA;
259
260	extern SMM_CPU_PRIVATE_DATA *gSmmCpuPrivate;
261	extern CPU_HOT_PLUG_DATA mCpuHotPlugData;
262	extern UINTN mMaxNumberOfCpus;
263	extern UINTN mNumberOfCpus;
264	extern EFI_SMM_CPU_PROTOCOL mSmmCpu;
265	extern EFI_MM_MP_PROTOCOL mSmmMp;
266
267	///
268	/// The mode of the CPU at the time an SMI occurs
269	///
270	extern UINT8 mSmmSaveStateRegisterLma;
271
272	//
273	// SMM CPU Protocol function prototypes.
274	//
275
276	/**
277	Read information from the CPU save state.
278
279	@param This EFI_SMM_CPU_PROTOCOL instance
280	@param Width The number of bytes to read from the CPU save state.
281	@param Register Specifies the CPU register to read form the save state.
282	@param CpuIndex Specifies the zero-based index of the CPU save state
283	@param Buffer Upon return, this holds the CPU register value read from the save state.
284
285	@retval EFI_SUCCESS The register was read from Save State
286	@retval EFI_NOT_FOUND The register is not defined for the Save State of Processor
287	@retval EFI_INVALID_PARAMETER This or Buffer is NULL.
288
289	**/
290	EFI_STATUS
291	EFIAPI
292	SmmReadSaveState (
293	IN CONST EFI_SMM_CPU_PROTOCOL *This,
294	IN UINTN Width,
295	IN EFI_SMM_SAVE_STATE_REGISTER Register,
296	IN UINTN CpuIndex,
297	OUT VOID *Buffer
298	);
299
300	/**
301	Write data to the CPU save state.
302
303	@param This EFI_SMM_CPU_PROTOCOL instance
304	@param Width The number of bytes to read from the CPU save state.
305	@param Register Specifies the CPU register to write to the save state.
306	@param CpuIndex Specifies the zero-based index of the CPU save state
307	@param Buffer Upon entry, this holds the new CPU register value.
308
309	@retval EFI_SUCCESS The register was written from Save State
310	@retval EFI_NOT_FOUND The register is not defined for the Save State of Processor
311	@retval EFI_INVALID_PARAMETER ProcessorIndex or Width is not correct
312
313	**/
314	EFI_STATUS
315	EFIAPI
316	SmmWriteSaveState (
317	IN CONST EFI_SMM_CPU_PROTOCOL *This,
318	IN UINTN Width,
319	IN EFI_SMM_SAVE_STATE_REGISTER Register,
320	IN UINTN CpuIndex,
321	IN CONST VOID *Buffer
322	);
323
324	/**
325	Read a CPU Save State register on the target processor.
326
327	This function abstracts the differences that whether the CPU Save State register is in the
328	IA32 CPU Save State Map or X64 CPU Save State Map.
329
330	This function supports reading a CPU Save State register in SMBase relocation handler.
331
332	@param[in] CpuIndex Specifies the zero-based index of the CPU save state.
333	@param[in] RegisterIndex Index into mSmmCpuWidthOffset[] look up table.
334	@param[in] Width The number of bytes to read from the CPU save state.
335	@param[out] Buffer Upon return, this holds the CPU register value read from the save state.
336
337	@retval EFI_SUCCESS The register was read from Save State.
338	@retval EFI_NOT_FOUND The register is not defined for the Save State of Processor.
339	@retval EFI_INVALID_PARAMETER This or Buffer is NULL.
340
341	**/
342	EFI_STATUS
343	EFIAPI
344	ReadSaveStateRegister (
345	IN UINTN CpuIndex,
346	IN EFI_SMM_SAVE_STATE_REGISTER Register,
347	IN UINTN Width,
348	OUT VOID *Buffer
349	);
350
351	/**
352	Write value to a CPU Save State register on the target processor.
353
354	This function abstracts the differences that whether the CPU Save State register is in the
355	IA32 CPU Save State Map or X64 CPU Save State Map.
356
357	This function supports writing a CPU Save State register in SMBase relocation handler.
358
359	@param[in] CpuIndex Specifies the zero-based index of the CPU save state.
360	@param[in] RegisterIndex Index into mSmmCpuWidthOffset[] look up table.
361	@param[in] Width The number of bytes to read from the CPU save state.
362	@param[in] Buffer Upon entry, this holds the new CPU register value.
363
364	@retval EFI_SUCCESS The register was written to Save State.
365	@retval EFI_NOT_FOUND The register is not defined for the Save State of Processor.
366	@retval EFI_INVALID_PARAMETER ProcessorIndex or Width is not correct.
367
368	**/
369	EFI_STATUS
370	EFIAPI
371	WriteSaveStateRegister (
372	IN UINTN CpuIndex,
373	IN EFI_SMM_SAVE_STATE_REGISTER Register,
374	IN UINTN Width,
375	IN CONST VOID *Buffer
376	);
377
378	extern CONST UINT8 gcSmmInitTemplate[];
379	extern CONST UINT16 gcSmmInitSize;
380	X86_ASSEMBLY_PATCH_LABEL gPatchSmmCr0;
381	extern UINT32 mSmmCr0;
382	X86_ASSEMBLY_PATCH_LABEL gPatchSmmCr3;
383	extern UINT32 mSmmCr4;
384	X86_ASSEMBLY_PATCH_LABEL gPatchSmmCr4;
385	X86_ASSEMBLY_PATCH_LABEL gPatchSmmInitStack;
386	X86_ASSEMBLY_PATCH_LABEL mPatchCetSupported;
387	extern BOOLEAN mCetSupported;
388
389	/**
390	Semaphore operation for all processor relocate SMMBase.
391	**/
392	VOID
393	EFIAPI
394	SmmRelocationSemaphoreComplete (
395	VOID
396	);
397
398	///
399	/// The type of SMM CPU Information
400	///
401	typedef struct {
402	SPIN_LOCK *Busy;
403	volatile EFI_AP_PROCEDURE2 Procedure;
404	volatile VOID *Parameter;
405	volatile UINT32 *Run;
406	volatile BOOLEAN *Present;
407	PROCEDURE_TOKEN *Token;
408	EFI_STATUS *Status;
409	} SMM_CPU_DATA_BLOCK;
410
411	typedef enum {
412	SmmCpuSyncModeTradition,
413	SmmCpuSyncModeRelaxedAp,
414	SmmCpuSyncModeMax
415	} SMM_CPU_SYNC_MODE;
416
417	typedef struct {
418	//
419	// Pointer to an array. The array should be located immediately after this structure
420	// so that UC cache-ability can be set together.
421	//
422	SMM_CPU_DATA_BLOCK *CpuData;
423	volatile UINT32 *Counter;
424	volatile UINT32 BspIndex;
425	volatile BOOLEAN *InsideSmm;
426	volatile BOOLEAN *AllCpusInSync;
427	volatile SMM_CPU_SYNC_MODE EffectiveSyncMode;
428	volatile BOOLEAN SwitchBsp;
429	volatile BOOLEAN *CandidateBsp;
430	EFI_AP_PROCEDURE StartupProcedure;
431	VOID *StartupProcArgs;
432	} SMM_DISPATCHER_MP_SYNC_DATA;
433
434	#define SMM_PSD_OFFSET 0xfb00
435
436	///
437	/// All global semaphores' pointer
438	///
439	typedef struct {
440	volatile UINT32 *Counter;
441	volatile BOOLEAN *InsideSmm;
442	volatile BOOLEAN *AllCpusInSync;
443	SPIN_LOCK *PFLock;
444	SPIN_LOCK *CodeAccessCheckLock;
445	} SMM_CPU_SEMAPHORE_GLOBAL;
446
447	///
448	/// All semaphores for each processor
449	///
450	typedef struct {
451	SPIN_LOCK *Busy;
452	volatile UINT32 *Run;
453	volatile BOOLEAN *Present;
454	SPIN_LOCK *Token;
455	} SMM_CPU_SEMAPHORE_CPU;
456
457	///
458	/// All semaphores' information
459	///
460	typedef struct {
461	SMM_CPU_SEMAPHORE_GLOBAL SemaphoreGlobal;
462	SMM_CPU_SEMAPHORE_CPU SemaphoreCpu;
463	} SMM_CPU_SEMAPHORES;
464
465	extern IA32_DESCRIPTOR gcSmiGdtr;
466	extern EFI_PHYSICAL_ADDRESS mGdtBuffer;
467	extern UINTN mGdtBufferSize;
468	extern IA32_DESCRIPTOR gcSmiIdtr;
469	extern VOID *gcSmiIdtrPtr;
470	extern UINT64 gPhyMask;
471	extern SMM_DISPATCHER_MP_SYNC_DATA *mSmmMpSyncData;
472	extern UINTN mSmmStackArrayBase;
473	extern UINTN mSmmStackArrayEnd;
474	extern UINTN mSmmStackSize;
475	extern EFI_SMM_CPU_SERVICE_PROTOCOL mSmmCpuService;
476	extern IA32_DESCRIPTOR gcSmiInitGdtr;
477	extern SMM_CPU_SEMAPHORES mSmmCpuSemaphores;
478	extern UINTN mSemaphoreSize;
479	extern SPIN_LOCK *mPFLock;
480	extern SPIN_LOCK *mConfigSmmCodeAccessCheckLock;
481	extern EFI_SMRAM_DESCRIPTOR *mSmmCpuSmramRanges;
482	extern UINTN mSmmCpuSmramRangeCount;
483	extern UINT8 mPhysicalAddressBits;
484
485	//
486	// Copy of the PcdPteMemoryEncryptionAddressOrMask
487	//
488	extern UINT64 mAddressEncMask;
489
490	/**
491	Create 4G PageTable in SMRAM.
492
493	@param[in] Is32BitPageTable Whether the page table is 32-bit PAE
494	@return PageTable Address
495
496	**/
497	UINT32
498	Gen4GPageTable (
499	IN BOOLEAN Is32BitPageTable
500	);
501
502
503	/**
504	Initialize global data for MP synchronization.
505
506	@param Stacks Base address of SMI stack buffer for all processors.
507	@param StackSize Stack size for each processor in SMM.
508	@param ShadowStackSize Shadow Stack size for each processor in SMM.
509
510	**/
511	UINT32
512	InitializeMpServiceData (
513	IN VOID *Stacks,
514	IN UINTN StackSize,
515	IN UINTN ShadowStackSize
516	);
517
518	/**
519	Initialize Timer for SMM AP Sync.
520
521	**/
522	VOID
523	InitializeSmmTimer (
524	VOID
525	);
526
527	/**
528	Start Timer for SMM AP Sync.
529
530	**/
531	UINT64
532	EFIAPI
533	StartSyncTimer (
534	VOID
535	);
536
537	/**
538	Check if the SMM AP Sync timer is timeout.
539
540	@param Timer The start timer from the begin.
541
542	**/
543	BOOLEAN
544	EFIAPI
545	IsSyncTimerTimeout (
546	IN UINT64 Timer
547	);
548
549	/**
550	Initialize IDT for SMM Stack Guard.
551
552	**/
553	VOID
554	EFIAPI
555	InitializeIDTSmmStackGuard (
556	VOID
557	);
558
559	/**
560	Initialize Gdt for all processors.
561
562	@param[in] Cr3 CR3 value.
563	@param[out] GdtStepSize The step size for GDT table.
564
565	@return GdtBase for processor 0.
566	GdtBase for processor X is: GdtBase + (GdtStepSize * X)
567	**/
568	VOID *
569	InitGdt (
570	IN UINTN Cr3,
571	OUT UINTN *GdtStepSize
572	);
573
574	/**
575
576	Register the SMM Foundation entry point.
577
578	@param This Pointer to EFI_SMM_CONFIGURATION_PROTOCOL instance
579	@param SmmEntryPoint SMM Foundation EntryPoint
580
581	@retval EFI_SUCCESS Successfully to register SMM foundation entry point
582
583	**/
584	EFI_STATUS
585	EFIAPI
586	RegisterSmmEntry (
587	IN CONST EFI_SMM_CONFIGURATION_PROTOCOL *This,
588	IN EFI_SMM_ENTRY_POINT SmmEntryPoint
589	);
590
591	/**
592	Create PageTable for SMM use.
593
594	@return PageTable Address
595
596	**/
597	UINT32
598	SmmInitPageTable (
599	VOID
600	);
601
602	/**
603	Schedule a procedure to run on the specified CPU.
604
605	@param Procedure The address of the procedure to run
606	@param CpuIndex Target CPU number
607	@param ProcArguments The parameter to pass to the procedure
608
609	@retval EFI_INVALID_PARAMETER CpuNumber not valid
610	@retval EFI_INVALID_PARAMETER CpuNumber specifying BSP
611	@retval EFI_INVALID_PARAMETER The AP specified by CpuNumber did not enter SMM
612	@retval EFI_INVALID_PARAMETER The AP specified by CpuNumber is busy
613	@retval EFI_SUCCESS - The procedure has been successfully scheduled
614
615	**/
616	EFI_STATUS
617	EFIAPI
618	SmmStartupThisAp (
619	IN EFI_AP_PROCEDURE Procedure,
620	IN UINTN CpuIndex,
621	IN OUT VOID *ProcArguments OPTIONAL
622	);
623
624	/**
625	Schedule a procedure to run on the specified CPU in a blocking fashion.
626
627	@param Procedure The address of the procedure to run
628	@param CpuIndex Target CPU Index
629	@param ProcArguments The parameter to pass to the procedure
630
631	@retval EFI_INVALID_PARAMETER CpuNumber not valid
632	@retval EFI_INVALID_PARAMETER CpuNumber specifying BSP
633	@retval EFI_INVALID_PARAMETER The AP specified by CpuNumber did not enter SMM
634	@retval EFI_INVALID_PARAMETER The AP specified by CpuNumber is busy
635	@retval EFI_SUCCESS The procedure has been successfully scheduled
636
637	**/
638	EFI_STATUS
639	EFIAPI
640	SmmBlockingStartupThisAp (
641	IN EFI_AP_PROCEDURE Procedure,
642	IN UINTN CpuIndex,
643	IN OUT VOID *ProcArguments OPTIONAL
644	);
645
646	/**
647	This function sets the attributes for the memory region specified by BaseAddress and
648	Length from their current attributes to the attributes specified by Attributes.
649
650	@param[in] BaseAddress The physical address that is the start address of a memory region.
651	@param[in] Length The size in bytes of the memory region.
652	@param[in] Attributes The bit mask of attributes to set for the memory region.
653
654	@retval EFI_SUCCESS The attributes were set for the memory region.
655	@retval EFI_ACCESS_DENIED The attributes for the memory resource range specified by
656	BaseAddress and Length cannot be modified.
657	@retval EFI_INVALID_PARAMETER Length is zero.
658	Attributes specified an illegal combination of attributes that
659	cannot be set together.
660	@retval EFI_OUT_OF_RESOURCES There are not enough system resources to modify the attributes of
661	the memory resource range.
662	@retval EFI_UNSUPPORTED The processor does not support one or more bytes of the memory
663	resource range specified by BaseAddress and Length.
664	The bit mask of attributes is not support for the memory resource
665	range specified by BaseAddress and Length.
666
667	**/
668	EFI_STATUS
669	EFIAPI
670	SmmSetMemoryAttributes (
671	IN EFI_PHYSICAL_ADDRESS BaseAddress,
672	IN UINT64 Length,
673	IN UINT64 Attributes
674	);
675
676	/**
677	This function clears the attributes for the memory region specified by BaseAddress and
678	Length from their current attributes to the attributes specified by Attributes.
679
680	@param[in] BaseAddress The physical address that is the start address of a memory region.
681	@param[in] Length The size in bytes of the memory region.
682	@param[in] Attributes The bit mask of attributes to clear for the memory region.
683
684	@retval EFI_SUCCESS The attributes were cleared for the memory region.
685	@retval EFI_ACCESS_DENIED The attributes for the memory resource range specified by
686	BaseAddress and Length cannot be modified.
687	@retval EFI_INVALID_PARAMETER Length is zero.
688	Attributes specified an illegal combination of attributes that
689	cannot be set together.
690	@retval EFI_OUT_OF_RESOURCES There are not enough system resources to modify the attributes of
691	the memory resource range.
692	@retval EFI_UNSUPPORTED The processor does not support one or more bytes of the memory
693	resource range specified by BaseAddress and Length.
694	The bit mask of attributes is not support for the memory resource
695	range specified by BaseAddress and Length.
696
697	**/
698	EFI_STATUS
699	EFIAPI
700	SmmClearMemoryAttributes (
701	IN EFI_PHYSICAL_ADDRESS BaseAddress,
702	IN UINT64 Length,
703	IN UINT64 Attributes
704	);
705
706	/**
707	Initialize MP synchronization data.
708
709	**/
710	VOID
711	EFIAPI
712	InitializeMpSyncData (
713	VOID
714	);
715
716	/**
717
718	Find out SMRAM information including SMRR base and SMRR size.
719
720	@param SmrrBase SMRR base
721	@param SmrrSize SMRR size
722
723	**/
724	VOID
725	FindSmramInfo (
726	OUT UINT32 *SmrrBase,
727	OUT UINT32 *SmrrSize
728	);
729
730	/**
731	Relocate SmmBases for each processor.
732
733	Execute on first boot and all S3 resumes
734
735	**/
736	VOID
737	EFIAPI
738	SmmRelocateBases (
739	VOID
740	);
741
742	/**
743	Page Fault handler for SMM use.
744
745	@param InterruptType Defines the type of interrupt or exception that
746	occurred on the processor.This parameter is processor architecture specific.
747	@param SystemContext A pointer to the processor context when
748	the interrupt occurred on the processor.
749	**/
750	VOID
751	EFIAPI
752	SmiPFHandler (
753	IN EFI_EXCEPTION_TYPE InterruptType,
754	IN EFI_SYSTEM_CONTEXT SystemContext
755	);
756
757	/**
758	Perform the remaining tasks.
759
760	**/
761	VOID
762	PerformRemainingTasks (
763	VOID
764	);
765
766	/**
767	Perform the pre tasks.
768
769	**/
770	VOID
771	PerformPreTasks (
772	VOID
773	);
774
775	/**
776	Initialize MSR spin lock by MSR index.
777
778	@param MsrIndex MSR index value.
779
780	**/
781	VOID
782	InitMsrSpinLockByIndex (
783	IN UINT32 MsrIndex
784	);
785
786	/**
787	Hook return address of SMM Save State so that semaphore code
788	can be executed immediately after AP exits SMM to indicate to
789	the BSP that an AP has exited SMM after SMBASE relocation.
790
791	@param[in] CpuIndex The processor index.
792	@param[in] RebasedFlag A pointer to a flag that is set to TRUE
793	immediately after AP exits SMM.
794
795	**/
796	VOID
797	SemaphoreHook (
798	IN UINTN CpuIndex,
799	IN volatile BOOLEAN *RebasedFlag
800	);
801
802	/**
803	Configure SMM Code Access Check feature for all processors.
804	SMM Feature Control MSR will be locked after configuration.
805	**/
806	VOID
807	ConfigSmmCodeAccessCheck (
808	VOID
809	);
810
811	/**
812	Hook the code executed immediately after an RSM instruction on the currently
813	executing CPU. The mode of code executed immediately after RSM must be
814	detected, and the appropriate hook must be selected. Always clear the auto
815	HALT restart flag if it is set.
816
817	@param[in] CpuIndex The processor index for the currently
818	executing CPU.
819	@param[in] CpuState Pointer to SMRAM Save State Map for the
820	currently executing CPU.
821	@param[in] NewInstructionPointer32 Instruction pointer to use if resuming to
822	32-bit mode from 64-bit SMM.
823	@param[in] NewInstructionPointer Instruction pointer to use if resuming to
824	same mode as SMM.
825
826	@retval The value of the original instruction pointer before it was hooked.
827
828	**/
829	UINT64
830	EFIAPI
831	HookReturnFromSmm (
832	IN UINTN CpuIndex,
833	SMRAM_SAVE_STATE_MAP *CpuState,
834	UINT64 NewInstructionPointer32,
835	UINT64 NewInstructionPointer
836	);
837
838	/**
839	Get the size of the SMI Handler in bytes.
840
841	@retval The size, in bytes, of the SMI Handler.
842
843	**/
844	UINTN
845	EFIAPI
846	GetSmiHandlerSize (
847	VOID
848	);
849
850	/**
851	Install the SMI handler for the CPU specified by CpuIndex. This function
852	is called by the CPU that was elected as monarch during System Management
853	Mode initialization.
854
855	@param[in] CpuIndex The index of the CPU to install the custom SMI handler.
856	The value must be between 0 and the NumberOfCpus field
857	in the System Management System Table (SMST).
858	@param[in] SmBase The SMBASE address for the CPU specified by CpuIndex.
859	@param[in] SmiStack The stack to use when an SMI is processed by the
860	the CPU specified by CpuIndex.
861	@param[in] StackSize The size, in bytes, if the stack used when an SMI is
862	processed by the CPU specified by CpuIndex.
863	@param[in] GdtBase The base address of the GDT to use when an SMI is
864	processed by the CPU specified by CpuIndex.
865	@param[in] GdtSize The size, in bytes, of the GDT used when an SMI is
866	processed by the CPU specified by CpuIndex.
867	@param[in] IdtBase The base address of the IDT to use when an SMI is
868	processed by the CPU specified by CpuIndex.
869	@param[in] IdtSize The size, in bytes, of the IDT used when an SMI is
870	processed by the CPU specified by CpuIndex.
871	@param[in] Cr3 The base address of the page tables to use when an SMI
872	is processed by the CPU specified by CpuIndex.
873	**/
874	VOID
875	EFIAPI
876	InstallSmiHandler (
877	IN UINTN CpuIndex,
878	IN UINT32 SmBase,
879	IN VOID *SmiStack,
880	IN UINTN StackSize,
881	IN UINTN GdtBase,
882	IN UINTN GdtSize,
883	IN UINTN IdtBase,
884	IN UINTN IdtSize,
885	IN UINT32 Cr3
886	);
887
888	/**
889	Search module name by input IP address and output it.
890
891	@param CallerIpAddress Caller instruction pointer.
892
893	**/
894	VOID
895	DumpModuleInfoByIp (
896	IN UINTN CallerIpAddress
897	);
898
899	/**
900	This function sets memory attribute according to MemoryAttributesTable.
901	**/
902	VOID
903	SetMemMapAttributes (
904	VOID
905	);
906
907	/**
908	This function sets UEFI memory attribute according to UEFI memory map.
909	**/
910	VOID
911	SetUefiMemMapAttributes (
912	VOID
913	);
914
915	/**
916	Return if the Address is forbidden as SMM communication buffer.
917
918	@param[in] Address the address to be checked
919
920	@return TRUE The address is forbidden as SMM communication buffer.
921	@return FALSE The address is allowed as SMM communication buffer.
922	**/
923	BOOLEAN
924	IsSmmCommBufferForbiddenAddress (
925	IN UINT64 Address
926	);
927
928	/**
929	This function caches the UEFI memory map information.
930	**/
931	VOID
932	GetUefiMemoryMap (
933	VOID
934	);
935
936	/**
937	This function sets memory attribute for page table.
938	**/
939	VOID
940	SetPageTableAttributes (
941	VOID
942	);
943
944	/**
945	Return page table base.
946
947	@return page table base.
948	**/
949	UINTN
950	GetPageTableBase (
951	VOID
952	);
953
954	/**
955	This function sets the attributes for the memory region specified by BaseAddress and
956	Length from their current attributes to the attributes specified by Attributes.
957
958	@param[in] BaseAddress The physical address that is the start address of a memory region.
959	@param[in] Length The size in bytes of the memory region.
960	@param[in] Attributes The bit mask of attributes to set for the memory region.
961	@param[out] IsSplitted TRUE means page table splitted. FALSE means page table not splitted.
962
963	@retval EFI_SUCCESS The attributes were set for the memory region.
964	@retval EFI_ACCESS_DENIED The attributes for the memory resource range specified by
965	BaseAddress and Length cannot be modified.
966	@retval EFI_INVALID_PARAMETER Length is zero.
967	Attributes specified an illegal combination of attributes that
968	cannot be set together.
969	@retval EFI_OUT_OF_RESOURCES There are not enough system resources to modify the attributes of
970	the memory resource range.
971	@retval EFI_UNSUPPORTED The processor does not support one or more bytes of the memory
972	resource range specified by BaseAddress and Length.
973	The bit mask of attributes is not support for the memory resource
974	range specified by BaseAddress and Length.
975
976	**/
977	EFI_STATUS
978	EFIAPI
979	SmmSetMemoryAttributesEx (
980	IN EFI_PHYSICAL_ADDRESS BaseAddress,
981	IN UINT64 Length,
982	IN UINT64 Attributes,
983	OUT BOOLEAN *IsSplitted OPTIONAL
984	);
985
986	/**
987	This function clears the attributes for the memory region specified by BaseAddress and
988	Length from their current attributes to the attributes specified by Attributes.
989
990	@param[in] BaseAddress The physical address that is the start address of a memory region.
991	@param[in] Length The size in bytes of the memory region.
992	@param[in] Attributes The bit mask of attributes to clear for the memory region.
993	@param[out] IsSplitted TRUE means page table splitted. FALSE means page table not splitted.
994
995	@retval EFI_SUCCESS The attributes were cleared for the memory region.
996	@retval EFI_ACCESS_DENIED The attributes for the memory resource range specified by
997	BaseAddress and Length cannot be modified.
998	@retval EFI_INVALID_PARAMETER Length is zero.
999	Attributes specified an illegal combination of attributes that
1000	cannot be set together.
1001	@retval EFI_OUT_OF_RESOURCES There are not enough system resources to modify the attributes of
1002	the memory resource range.
1003	@retval EFI_UNSUPPORTED The processor does not support one or more bytes of the memory
1004	resource range specified by BaseAddress and Length.
1005	The bit mask of attributes is not support for the memory resource
1006	range specified by BaseAddress and Length.
1007
1008	**/
1009	EFI_STATUS
1010	EFIAPI
1011	SmmClearMemoryAttributesEx (
1012	IN EFI_PHYSICAL_ADDRESS BaseAddress,
1013	IN UINT64 Length,
1014	IN UINT64 Attributes,
1015	OUT BOOLEAN *IsSplitted OPTIONAL
1016	);
1017
1018	/**
1019	This API provides a way to allocate memory for page table.
1020
1021	This API can be called more once to allocate memory for page tables.
1022
1023	Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer to the
1024	allocated buffer. The buffer returned is aligned on a 4KB boundary. If Pages is 0, then NULL
1025	is returned. If there is not enough memory remaining to satisfy the request, then NULL is
1026	returned.
1027
1028	@param Pages The number of 4 KB pages to allocate.
1029
1030	@return A pointer to the allocated buffer or NULL if allocation fails.
1031
1032	**/
1033	VOID *
1034	AllocatePageTableMemory (
1035	IN UINTN Pages
1036	);
1037
1038	/**
1039	Allocate pages for code.
1040
1041	@param[in] Pages Number of pages to be allocated.
1042
1043	@return Allocated memory.
1044	**/
1045	VOID *
1046	AllocateCodePages (
1047	IN UINTN Pages
1048	);
1049
1050	/**
1051	Allocate aligned pages for code.
1052
1053	@param[in] Pages Number of pages to be allocated.
1054	@param[in] Alignment The requested alignment of the allocation.
1055	Must be a power of two.
1056	If Alignment is zero, then byte alignment is used.
1057
1058	@return Allocated memory.
1059	**/
1060	VOID *
1061	AllocateAlignedCodePages (
1062	IN UINTN Pages,
1063	IN UINTN Alignment
1064	);
1065
1066
1067	//
1068	// S3 related global variable and function prototype.
1069	//
1070
1071	extern BOOLEAN mSmmS3Flag;
1072
1073	/**
1074	Initialize SMM S3 resume state structure used during S3 Resume.
1075
1076	@param[in] Cr3 The base address of the page tables to use in SMM.
1077
1078	**/
1079	VOID
1080	InitSmmS3ResumeState (
1081	IN UINT32 Cr3
1082	);
1083
1084	/**
1085	Get ACPI CPU data.
1086
1087	**/
1088	VOID
1089	GetAcpiCpuData (
1090	VOID
1091	);
1092
1093	/**
1094	Restore SMM Configuration in S3 boot path.
1095
1096	**/
1097	VOID
1098	RestoreSmmConfigurationInS3 (
1099	VOID
1100	);
1101
1102	/**
1103	Get ACPI S3 enable flag.
1104
1105	**/
1106	VOID
1107	GetAcpiS3EnableFlag (
1108	VOID
1109	);
1110
1111	/**
1112	Transfer AP to safe hlt-loop after it finished restore CPU features on S3 patch.
1113
1114	@param[in] ApHltLoopCode The address of the safe hlt-loop function.
1115	@param[in] TopOfStack A pointer to the new stack to use for the ApHltLoopCode.
1116	@param[in] NumberToFinishAddress Address of Semaphore of APs finish count.
1117
1118	**/
1119	VOID
1120	TransferApToSafeState (
1121	IN UINTN ApHltLoopCode,
1122	IN UINTN TopOfStack,
1123	IN UINTN NumberToFinishAddress
1124	);
1125
1126	/**
1127	Set ShadowStack memory.
1128
1129	@param[in] Cr3 The page table base address.
1130	@param[in] BaseAddress The physical address that is the start address of a memory region.
1131	@param[in] Length The size in bytes of the memory region.
1132
1133	@retval EFI_SUCCESS The shadow stack memory is set.
1134	**/
1135	EFI_STATUS
1136	SetShadowStack (
1137	IN UINTN Cr3,
1138	IN EFI_PHYSICAL_ADDRESS BaseAddress,
1139	IN UINT64 Length
1140	);
1141
1142	/**
1143	Set not present memory.
1144
1145	@param[in] Cr3 The page table base address.
1146	@param[in] BaseAddress The physical address that is the start address of a memory region.
1147	@param[in] Length The size in bytes of the memory region.
1148
1149	@retval EFI_SUCCESS The not present memory is set.
1150	**/
1151	EFI_STATUS
1152	SetNotPresentPage (
1153	IN UINTN Cr3,
1154	IN EFI_PHYSICAL_ADDRESS BaseAddress,
1155	IN UINT64 Length
1156	);
1157
1158	/**
1159	Initialize the shadow stack related data structure.
1160
1161	@param CpuIndex The index of CPU.
1162	@param ShadowStack The bottom of the shadow stack for this CPU.
1163	**/
1164	VOID
1165	InitShadowStack (
1166	IN UINTN CpuIndex,
1167	IN VOID *ShadowStack
1168	);
1169
1170	/**
1171	This function set given attributes of the memory region specified by
1172	BaseAddress and Length.
1173
1174	@param This The EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL instance.
1175	@param BaseAddress The physical address that is the start address of
1176	a memory region.
1177	@param Length The size in bytes of the memory region.
1178	@param Attributes The bit mask of attributes to set for the memory
1179	region.
1180
1181	@retval EFI_SUCCESS The attributes were set for the memory region.
1182	@retval EFI_INVALID_PARAMETER Length is zero.
1183	Attributes specified an illegal combination of
1184	attributes that cannot be set together.
1185	@retval EFI_UNSUPPORTED The processor does not support one or more
1186	bytes of the memory resource range specified
1187	by BaseAddress and Length.
1188	The bit mask of attributes is not supported for
1189	the memory resource range specified by
1190	BaseAddress and Length.
1191
1192	**/
1193	EFI_STATUS
1194	EFIAPI
1195	EdkiiSmmSetMemoryAttributes (
1196	IN EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL *This,
1197	IN EFI_PHYSICAL_ADDRESS BaseAddress,
1198	IN UINT64 Length,
1199	IN UINT64 Attributes
1200	);
1201
1202	/**
1203	This function clears given attributes of the memory region specified by
1204	BaseAddress and Length.
1205
1206	@param This The EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL instance.
1207	@param BaseAddress The physical address that is the start address of
1208	a memory region.
1209	@param Length The size in bytes of the memory region.
1210	@param Attributes The bit mask of attributes to clear for the memory
1211	region.
1212
1213	@retval EFI_SUCCESS The attributes were cleared for the memory region.
1214	@retval EFI_INVALID_PARAMETER Length is zero.
1215	Attributes specified an illegal combination of
1216	attributes that cannot be cleared together.
1217	@retval EFI_UNSUPPORTED The processor does not support one or more
1218	bytes of the memory resource range specified
1219	by BaseAddress and Length.
1220	The bit mask of attributes is not supported for
1221	the memory resource range specified by
1222	BaseAddress and Length.
1223
1224	**/
1225	EFI_STATUS
1226	EFIAPI
1227	EdkiiSmmClearMemoryAttributes (
1228	IN EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL *This,
1229	IN EFI_PHYSICAL_ADDRESS BaseAddress,
1230	IN UINT64 Length,
1231	IN UINT64 Attributes
1232	);
1233
1234	/**
1235	This function retrieves the attributes of the memory region specified by
1236	BaseAddress and Length. If different attributes are got from different part
1237	of the memory region, EFI_NO_MAPPING will be returned.
1238
1239	@param This The EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL instance.
1240	@param BaseAddress The physical address that is the start address of
1241	a memory region.
1242	@param Length The size in bytes of the memory region.
1243	@param Attributes Pointer to attributes returned.
1244
1245	@retval EFI_SUCCESS The attributes got for the memory region.
1246	@retval EFI_INVALID_PARAMETER Length is zero.
1247	Attributes is NULL.
1248	@retval EFI_NO_MAPPING Attributes are not consistent cross the memory
1249	region.
1250	@retval EFI_UNSUPPORTED The processor does not support one or more
1251	bytes of the memory resource range specified
1252	by BaseAddress and Length.
1253
1254	**/
1255	EFI_STATUS
1256	EFIAPI
1257	EdkiiSmmGetMemoryAttributes (
1258	IN EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL *This,
1259	IN EFI_PHYSICAL_ADDRESS BaseAddress,
1260	IN UINT64 Length,
1261	IN UINT64 *Attributes
1262	);
1263
1264	/**
1265	This function fixes up the address of the global variable or function
1266	referred in SmmInit assembly files to be the absolute address.
1267	**/
1268	VOID
1269	EFIAPI
1270	PiSmmCpuSmmInitFixupAddress (
1271	);
1272
1273	/**
1274	This function fixes up the address of the global variable or function
1275	referred in SmiEntry assembly files to be the absolute address.
1276	**/
1277	VOID
1278	EFIAPI
1279	PiSmmCpuSmiEntryFixupAddress (
1280	);
1281
1282	/**
1283	This function reads CR2 register when on-demand paging is enabled
1284	for 64 bit and no action for 32 bit.
1285
1286	@param[out] *Cr2 Pointer to variable to hold CR2 register value.
1287	**/
1288	VOID
1289	SaveCr2 (
1290	OUT UINTN *Cr2
1291	);
1292
1293	/**
1294	This function writes into CR2 register when on-demand paging is enabled
1295	for 64 bit and no action for 32 bit.
1296
1297	@param[in] Cr2 Value to write into CR2 register.
1298	**/
1299	VOID
1300	RestoreCr2 (
1301	IN UINTN Cr2
1302	);
1303
1304	/**
1305	Schedule a procedure to run on the specified CPU.
1306
1307	@param[in] Procedure The address of the procedure to run
1308	@param[in] CpuIndex Target CPU Index
1309	@param[in,out] ProcArguments The parameter to pass to the procedure
1310	@param[in,out] Token This is an optional parameter that allows the caller to execute the
1311	procedure in a blocking or non-blocking fashion. If it is NULL the
1312	call is blocking, and the call will not return until the AP has
1313	completed the procedure. If the token is not NULL, the call will
1314	return immediately. The caller can check whether the procedure has
1315	completed with CheckOnProcedure or WaitForProcedure.
1316	@param[in] TimeoutInMicroseconds Indicates the time limit in microseconds for the APs to finish
1317	execution of Procedure, either for blocking or non-blocking mode.
1318	Zero means infinity. If the timeout expires before all APs return
1319	from Procedure, then Procedure on the failed APs is terminated. If
1320	the timeout expires in blocking mode, the call returns EFI_TIMEOUT.
1321	If the timeout expires in non-blocking mode, the timeout determined
1322	can be through CheckOnProcedure or WaitForProcedure.
1323	Note that timeout support is optional. Whether an implementation
1324	supports this feature can be determined via the Attributes data
1325	member.
1326	@param[in,out] CpuStatus This optional pointer may be used to get the status code returned
1327	by Procedure when it completes execution on the target AP, or with
1328	EFI_TIMEOUT if the Procedure fails to complete within the optional
1329	timeout. The implementation will update this variable with
1330	EFI_NOT_READY prior to starting Procedure on the target AP.
1331
1332	@retval EFI_INVALID_PARAMETER CpuNumber not valid
1333	@retval EFI_INVALID_PARAMETER CpuNumber specifying BSP
1334	@retval EFI_INVALID_PARAMETER The AP specified by CpuNumber did not enter SMM
1335	@retval EFI_INVALID_PARAMETER The AP specified by CpuNumber is busy
1336	@retval EFI_SUCCESS The procedure has been successfully scheduled
1337
1338	**/
1339	EFI_STATUS
1340	InternalSmmStartupThisAp (
1341	IN EFI_AP_PROCEDURE2 Procedure,
1342	IN UINTN CpuIndex,
1343	IN OUT VOID *ProcArguments OPTIONAL,
1344	IN OUT MM_COMPLETION *Token,
1345	IN UINTN TimeoutInMicroseconds,
1346	IN OUT EFI_STATUS *CpuStatus
1347	);
1348
1349	/**
1350	Checks whether the input token is the current used token.
1351
1352	@param[in] Token This parameter describes the token that was passed into DispatchProcedure or
1353	BroadcastProcedure.
1354
1355	@retval TRUE The input token is the current used token.
1356	@retval FALSE The input token is not the current used token.
1357	**/
1358	BOOLEAN
1359	IsTokenInUse (
1360	IN SPIN_LOCK *Token
1361	);
1362
1363	/**
1364	Checks status of specified AP.
1365
1366	This function checks whether the specified AP has finished the task assigned
1367	by StartupThisAP(), and whether timeout expires.
1368
1369	@param[in] Token This parameter describes the token that was passed into DispatchProcedure or
1370	BroadcastProcedure.
1371
1372	@retval EFI_SUCCESS Specified AP has finished task assigned by StartupThisAPs().
1373	@retval EFI_NOT_READY Specified AP has not finished task and timeout has not expired.
1374	**/
1375	EFI_STATUS
1376	IsApReady (
1377	IN SPIN_LOCK *Token
1378	);
1379
1380	/**
1381	Check whether it is an present AP.
1382
1383	@param CpuIndex The AP index which calls this function.
1384
1385	@retval TRUE It's a present AP.
1386	@retval TRUE This is not an AP or it is not present.
1387
1388	**/
1389	BOOLEAN
1390	IsPresentAp (
1391	IN UINTN CpuIndex
1392	);
1393
1394	/**
1395	Worker function to execute a caller provided function on all enabled APs.
1396
1397	@param[in] Procedure A pointer to the function to be run on
1398	enabled APs of the system.
1399	@param[in] TimeoutInMicroseconds Indicates the time limit in microseconds for
1400	APs to return from Procedure, either for
1401	blocking or non-blocking mode.
1402	@param[in,out] ProcedureArguments The parameter passed into Procedure for
1403	all APs.
1404	@param[in,out] Token This is an optional parameter that allows the caller to execute the
1405	procedure in a blocking or non-blocking fashion. If it is NULL the
1406	call is blocking, and the call will not return until the AP has
1407	completed the procedure. If the token is not NULL, the call will
1408	return immediately. The caller can check whether the procedure has
1409	completed with CheckOnProcedure or WaitForProcedure.
1410	@param[in,out] CPUStatus This optional pointer may be used to get the status code returned
1411	by Procedure when it completes execution on the target AP, or with
1412	EFI_TIMEOUT if the Procedure fails to complete within the optional
1413	timeout. The implementation will update this variable with
1414	EFI_NOT_READY prior to starting Procedure on the target AP.
1415
1416	@retval EFI_SUCCESS In blocking mode, all APs have finished before
1417	the timeout expired.
1418	@retval EFI_SUCCESS In non-blocking mode, function has been dispatched
1419	to all enabled APs.
1420	@retval others Failed to Startup all APs.
1421
1422	**/
1423	EFI_STATUS
1424	InternalSmmStartupAllAPs (
1425	IN EFI_AP_PROCEDURE2 Procedure,
1426	IN UINTN TimeoutInMicroseconds,
1427	IN OUT VOID *ProcedureArguments OPTIONAL,
1428	IN OUT MM_COMPLETION *Token,
1429	IN OUT EFI_STATUS *CPUStatus
1430	);
1431
1432	/**
1433
1434	Register the SMM Foundation entry point.
1435
1436	@param[in] Procedure A pointer to the code stream to be run on the designated target AP
1437	of the system. Type EFI_AP_PROCEDURE is defined below in Volume 2
1438	with the related definitions of
1439	EFI_MP_SERVICES_PROTOCOL.StartupAllAPs.
1440	If caller may pass a value of NULL to deregister any existing
1441	startup procedure.
1442	@param[in,out] ProcedureArguments Allows the caller to pass a list of parameters to the code that is
1443	run by the AP. It is an optional common mailbox between APs and
1444	the caller to share information
1445
1446	@retval EFI_SUCCESS The Procedure has been set successfully.
1447	@retval EFI_INVALID_PARAMETER The Procedure is NULL but ProcedureArguments not NULL.
1448
1449	**/
1450	EFI_STATUS
1451	RegisterStartupProcedure (
1452	IN EFI_AP_PROCEDURE Procedure,
1453	IN OUT VOID *ProcedureArguments OPTIONAL
1454	);
1455
1456	/**
1457	Allocate buffer for SpinLock and Wrapper function buffer.
1458
1459	**/
1460	VOID
1461	InitializeDataForMmMp (
1462	VOID
1463	);
1464
1465	/**
1466	Return whether access to non-SMRAM is restricted.
1467
1468	@retval TRUE Access to non-SMRAM is restricted.
1469	@retval FALSE Access to non-SMRAM is not restricted.
1470	**/
1471	BOOLEAN
1472	IsRestrictedMemoryAccess (
1473	VOID
1474	);
1475
1476	#endif

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/UefiCpuPkg/PiSmmCpuDxeSmm/PiSmmCpuDxeSmm.h@ 86513

Download in other formats: