UefiCpuPkg/PiSmmCpuDxeSmm/PiSmmCpuDxeSmm.h

   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 extern UINTN                  mInternalCr3;
 267
 268 ///
 269 /// The mode of the CPU at the time an SMI occurs
 270 ///
 271 extern UINT8  mSmmSaveStateRegisterLma;
 272
 273 //
 274 // SMM CPU Protocol function prototypes.
 275 //
 276
 277 /**
 278   Read information from the CPU save state.
 279
 280   @param  This      EFI_SMM_CPU_PROTOCOL instance
 281   @param  Width     The number of bytes to read from the CPU save state.
 282   @param  Register  Specifies the CPU register to read form the save state.
 283   @param  CpuIndex  Specifies the zero-based index of the CPU save state
 284   @param  Buffer    Upon return, this holds the CPU register value read from the save state.
 285
 286   @retval EFI_SUCCESS   The register was read from Save State
 287   @retval EFI_NOT_FOUND The register is not defined for the Save State of Processor
 288   @retval EFI_INVALID_PARAMETER   This or Buffer is NULL.
 289
 290 **/
 291 EFI_STATUS
 292 EFIAPI
 293 SmmReadSaveState (
 294   IN CONST EFI_SMM_CPU_PROTOCOL         *This,
 295   IN UINTN                              Width,
 296   IN EFI_SMM_SAVE_STATE_REGISTER        Register,
 297   IN UINTN                              CpuIndex,
 298   OUT VOID                              *Buffer
 299   );
 300
 301 /**
 302   Write data to the CPU save state.
 303
 304   @param  This      EFI_SMM_CPU_PROTOCOL instance
 305   @param  Width     The number of bytes to read from the CPU save state.
 306   @param  Register  Specifies the CPU register to write to the save state.
 307   @param  CpuIndex  Specifies the zero-based index of the CPU save state
 308   @param  Buffer    Upon entry, this holds the new CPU register value.
 309
 310   @retval EFI_SUCCESS   The register was written from Save State
 311   @retval EFI_NOT_FOUND The register is not defined for the Save State of Processor
 312   @retval EFI_INVALID_PARAMETER   ProcessorIndex or Width is not correct
 313
 314 **/
 315 EFI_STATUS
 316 EFIAPI
 317 SmmWriteSaveState (
 318   IN CONST EFI_SMM_CPU_PROTOCOL         *This,
 319   IN UINTN                              Width,
 320   IN EFI_SMM_SAVE_STATE_REGISTER        Register,
 321   IN UINTN                              CpuIndex,
 322   IN CONST VOID                         *Buffer
 323   );
 324
 325 /**
 326 Read a CPU Save State register on the target processor.
 327
 328 This function abstracts the differences that whether the CPU Save State register is in the
 329 IA32 CPU Save State Map or X64 CPU Save State Map.
 330
 331 This function supports reading a CPU Save State register in SMBase relocation handler.
 332
 333 @param[in]  CpuIndex       Specifies the zero-based index of the CPU save state.
 334 @param[in]  RegisterIndex  Index into mSmmCpuWidthOffset[] look up table.
 335 @param[in]  Width          The number of bytes to read from the CPU save state.
 336 @param[out] Buffer         Upon return, this holds the CPU register value read from the save state.
 337
 338 @retval EFI_SUCCESS           The register was read from Save State.
 339 @retval EFI_NOT_FOUND         The register is not defined for the Save State of Processor.
 340 @retval EFI_INVALID_PARAMETER Buffer is NULL, or Width does not meet requirement per Register type.
 341
 342 **/
 343 EFI_STATUS
 344 EFIAPI
 345 ReadSaveStateRegister (
 346   IN UINTN                        CpuIndex,
 347   IN EFI_SMM_SAVE_STATE_REGISTER  Register,
 348   IN UINTN                        Width,
 349   OUT VOID                        *Buffer
 350   );
 351
 352 /**
 353 Write value to a CPU Save State register on the target processor.
 354
 355 This function abstracts the differences that whether the CPU Save State register is in the
 356 IA32 CPU Save State Map or X64 CPU Save State Map.
 357
 358 This function supports writing a CPU Save State register in SMBase relocation handler.
 359
 360 @param[in] CpuIndex       Specifies the zero-based index of the CPU save state.
 361 @param[in] RegisterIndex  Index into mSmmCpuWidthOffset[] look up table.
 362 @param[in] Width          The number of bytes to read from the CPU save state.
 363 @param[in] Buffer         Upon entry, this holds the new CPU register value.
 364
 365 @retval EFI_SUCCESS           The register was written to Save State.
 366 @retval EFI_NOT_FOUND         The register is not defined for the Save State of Processor.
 367 @retval EFI_INVALID_PARAMETER  ProcessorIndex or Width is not correct.
 368
 369 **/
 370 EFI_STATUS
 371 EFIAPI
 372 WriteSaveStateRegister (
 373   IN UINTN                        CpuIndex,
 374   IN EFI_SMM_SAVE_STATE_REGISTER  Register,
 375   IN UINTN                        Width,
 376   IN CONST VOID                   *Buffer
 377   );
 378
 379 extern CONST UINT8                  gcSmmInitTemplate[];
 380 extern CONST UINT16                 gcSmmInitSize;
 381 X86_ASSEMBLY_PATCH_LABEL            gPatchSmmCr0;
 382 extern UINT32                       mSmmCr0;
 383 X86_ASSEMBLY_PATCH_LABEL            gPatchSmmCr3;
 384 extern UINT32                       mSmmCr4;
 385 X86_ASSEMBLY_PATCH_LABEL            gPatchSmmCr4;
 386 X86_ASSEMBLY_PATCH_LABEL            gPatchSmmInitStack;
 387 X86_ASSEMBLY_PATCH_LABEL            mPatchCetSupported;
 388 extern BOOLEAN                      mCetSupported;
 389
 390 /**
 391   Semaphore operation for all processor relocate SMMBase.
 392 **/
 393 VOID
 394 EFIAPI
 395 SmmRelocationSemaphoreComplete (
 396   VOID
 397   );
 398
 399 ///
 400 /// The type of SMM CPU Information
 401 ///
 402 typedef struct {
 403   SPIN_LOCK                         *Busy;
 404   volatile EFI_AP_PROCEDURE2        Procedure;
 405   volatile VOID                     *Parameter;
 406   volatile UINT32                   *Run;
 407   volatile BOOLEAN                  *Present;
 408   PROCEDURE_TOKEN                   *Token;
 409   EFI_STATUS                        *Status;
 410 } SMM_CPU_DATA_BLOCK;
 411
 412 typedef enum {
 413   SmmCpuSyncModeTradition,
 414   SmmCpuSyncModeRelaxedAp,
 415   SmmCpuSyncModeMax
 416 } SMM_CPU_SYNC_MODE;
 417
 418 typedef struct {
 419   //
 420   // Pointer to an array. The array should be located immediately after this structure
 421   // so that UC cache-ability can be set together.
 422   //
 423   SMM_CPU_DATA_BLOCK            *CpuData;
 424   volatile UINT32               *Counter;
 425   volatile UINT32               BspIndex;
 426   volatile BOOLEAN              *InsideSmm;
 427   volatile BOOLEAN              *AllCpusInSync;
 428   volatile SMM_CPU_SYNC_MODE    EffectiveSyncMode;
 429   volatile BOOLEAN              SwitchBsp;
 430   volatile BOOLEAN              *CandidateBsp;
 431   EFI_AP_PROCEDURE              StartupProcedure;
 432   VOID                          *StartupProcArgs;
 433 } SMM_DISPATCHER_MP_SYNC_DATA;
 434
 435 #define SMM_PSD_OFFSET              0xfb00
 436
 437 ///
 438 /// All global semaphores' pointer
 439 ///
 440 typedef struct {
 441   volatile UINT32      *Counter;
 442   volatile BOOLEAN     *InsideSmm;
 443   volatile BOOLEAN     *AllCpusInSync;
 444   SPIN_LOCK            *PFLock;
 445   SPIN_LOCK            *CodeAccessCheckLock;
 446 } SMM_CPU_SEMAPHORE_GLOBAL;
 447
 448 ///
 449 /// All semaphores for each processor
 450 ///
 451 typedef struct {
 452   SPIN_LOCK                         *Busy;
 453   volatile UINT32                   *Run;
 454   volatile BOOLEAN                  *Present;
 455   SPIN_LOCK                         *Token;
 456 } SMM_CPU_SEMAPHORE_CPU;
 457
 458 ///
 459 /// All semaphores' information
 460 ///
 461 typedef struct {
 462   SMM_CPU_SEMAPHORE_GLOBAL          SemaphoreGlobal;
 463   SMM_CPU_SEMAPHORE_CPU             SemaphoreCpu;
 464 } SMM_CPU_SEMAPHORES;
 465
 466 extern IA32_DESCRIPTOR                     gcSmiGdtr;
 467 extern EFI_PHYSICAL_ADDRESS                mGdtBuffer;
 468 extern UINTN                               mGdtBufferSize;
 469 extern IA32_DESCRIPTOR                     gcSmiIdtr;
 470 extern VOID                                *gcSmiIdtrPtr;
 471 extern UINT64                              gPhyMask;
 472 extern SMM_DISPATCHER_MP_SYNC_DATA         *mSmmMpSyncData;
 473 extern UINTN                               mSmmStackArrayBase;
 474 extern UINTN                               mSmmStackArrayEnd;
 475 extern UINTN                               mSmmStackSize;
 476 extern EFI_SMM_CPU_SERVICE_PROTOCOL        mSmmCpuService;
 477 extern IA32_DESCRIPTOR                     gcSmiInitGdtr;
 478 extern SMM_CPU_SEMAPHORES                  mSmmCpuSemaphores;
 479 extern UINTN                               mSemaphoreSize;
 480 extern SPIN_LOCK                           *mPFLock;
 481 extern SPIN_LOCK                           *mConfigSmmCodeAccessCheckLock;
 482 extern EFI_SMRAM_DESCRIPTOR                *mSmmCpuSmramRanges;
 483 extern UINTN                               mSmmCpuSmramRangeCount;
 484 extern UINT8                               mPhysicalAddressBits;
 485
 486 //
 487 // Copy of the PcdPteMemoryEncryptionAddressOrMask
 488 //
 489 extern UINT64  mAddressEncMask;
 490
 491 /**
 492   Create 4G PageTable in SMRAM.
 493
 494   @param[in]      Is32BitPageTable Whether the page table is 32-bit PAE
 495   @return         PageTable Address
 496
 497 **/
 498 UINT32
 499 Gen4GPageTable (
 500   IN      BOOLEAN                   Is32BitPageTable
 501   );
 502
 503
 504 /**
 505   Initialize global data for MP synchronization.
 506
 507   @param Stacks             Base address of SMI stack buffer for all processors.
 508   @param StackSize          Stack size for each processor in SMM.
 509   @param ShadowStackSize    Shadow Stack size for each processor in SMM.
 510
 511 **/
 512 UINT32
 513 InitializeMpServiceData (
 514   IN VOID        *Stacks,
 515   IN UINTN       StackSize,
 516   IN UINTN       ShadowStackSize
 517   );
 518
 519 /**
 520   Initialize Timer for SMM AP Sync.
 521
 522 **/
 523 VOID
 524 InitializeSmmTimer (
 525   VOID
 526   );
 527
 528 /**
 529   Start Timer for SMM AP Sync.
 530
 531 **/
 532 UINT64
 533 EFIAPI
 534 StartSyncTimer (
 535   VOID
 536   );
 537
 538 /**
 539   Check if the SMM AP Sync timer is timeout.
 540
 541   @param Timer  The start timer from the begin.
 542
 543 **/
 544 BOOLEAN
 545 EFIAPI
 546 IsSyncTimerTimeout (
 547   IN      UINT64                    Timer
 548   );
 549
 550 /**
 551   Initialize IDT for SMM Stack Guard.
 552
 553 **/
 554 VOID
 555 EFIAPI
 556 InitializeIDTSmmStackGuard (
 557   VOID
 558   );
 559
 560 /**
 561   Initialize Gdt for all processors.
 562
 563   @param[in]   Cr3          CR3 value.
 564   @param[out]  GdtStepSize  The step size for GDT table.
 565
 566   @return GdtBase for processor 0.
 567           GdtBase for processor X is: GdtBase + (GdtStepSize * X)
 568 **/
 569 VOID *
 570 InitGdt (
 571   IN  UINTN  Cr3,
 572   OUT UINTN  *GdtStepSize
 573   );
 574
 575 /**
 576
 577   Register the SMM Foundation entry point.
 578
 579   @param          This              Pointer to EFI_SMM_CONFIGURATION_PROTOCOL instance
 580   @param          SmmEntryPoint     SMM Foundation EntryPoint
 581
 582   @retval         EFI_SUCCESS       Successfully to register SMM foundation entry point
 583
 584 **/
 585 EFI_STATUS
 586 EFIAPI
 587 RegisterSmmEntry (
 588   IN CONST EFI_SMM_CONFIGURATION_PROTOCOL  *This,
 589   IN EFI_SMM_ENTRY_POINT                   SmmEntryPoint
 590   );
 591
 592 /**
 593   Create PageTable for SMM use.
 594
 595   @return     PageTable Address
 596
 597 **/
 598 UINT32
 599 SmmInitPageTable (
 600   VOID
 601   );
 602
 603 /**
 604   Schedule a procedure to run on the specified CPU.
 605
 606   @param   Procedure        The address of the procedure to run
 607   @param   CpuIndex         Target CPU number
 608   @param   ProcArguments    The parameter to pass to the procedure
 609
 610   @retval   EFI_INVALID_PARAMETER    CpuNumber not valid
 611   @retval   EFI_INVALID_PARAMETER    CpuNumber specifying BSP
 612   @retval   EFI_INVALID_PARAMETER    The AP specified by CpuNumber did not enter SMM
 613   @retval   EFI_INVALID_PARAMETER    The AP specified by CpuNumber is busy
 614   @retval   EFI_SUCCESS - The procedure has been successfully scheduled
 615
 616 **/
 617 EFI_STATUS
 618 EFIAPI
 619 SmmStartupThisAp (
 620   IN      EFI_AP_PROCEDURE          Procedure,
 621   IN      UINTN                     CpuIndex,
 622   IN OUT  VOID                      *ProcArguments OPTIONAL
 623   );
 624
 625 /**
 626   Schedule a procedure to run on the specified CPU in a blocking fashion.
 627
 628   @param  Procedure                The address of the procedure to run
 629   @param  CpuIndex                 Target CPU Index
 630   @param  ProcArguments            The parameter to pass to the procedure
 631
 632   @retval EFI_INVALID_PARAMETER    CpuNumber not valid
 633   @retval EFI_INVALID_PARAMETER    CpuNumber specifying BSP
 634   @retval EFI_INVALID_PARAMETER    The AP specified by CpuNumber did not enter SMM
 635   @retval EFI_INVALID_PARAMETER    The AP specified by CpuNumber is busy
 636   @retval EFI_SUCCESS              The procedure has been successfully scheduled
 637
 638 **/
 639 EFI_STATUS
 640 EFIAPI
 641 SmmBlockingStartupThisAp (
 642   IN      EFI_AP_PROCEDURE          Procedure,
 643   IN      UINTN                     CpuIndex,
 644   IN OUT  VOID                      *ProcArguments OPTIONAL
 645   );
 646
 647 /**
 648   This function sets the attributes for the memory region specified by BaseAddress and
 649   Length from their current attributes to the attributes specified by Attributes.
 650
 651   @param[in]  BaseAddress      The physical address that is the start address of a memory region.
 652   @param[in]  Length           The size in bytes of the memory region.
 653   @param[in]  Attributes       The bit mask of attributes to set for the memory region.
 654
 655   @retval EFI_SUCCESS           The attributes were set for the memory region.
 656   @retval EFI_ACCESS_DENIED     The attributes for the memory resource range specified by
 657                                 BaseAddress and Length cannot be modified.
 658   @retval EFI_INVALID_PARAMETER Length is zero.
 659                                 Attributes specified an illegal combination of attributes that
 660                                 cannot be set together.
 661   @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to modify the attributes of
 662                                 the memory resource range.
 663   @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the memory
 664                                 resource range specified by BaseAddress and Length.
 665                                 The bit mask of attributes is not support for the memory resource
 666                                 range specified by BaseAddress and Length.
 667
 668 **/
 669 EFI_STATUS
 670 EFIAPI
 671 SmmSetMemoryAttributes (
 672   IN  EFI_PHYSICAL_ADDRESS                       BaseAddress,
 673   IN  UINT64                                     Length,
 674   IN  UINT64                                     Attributes
 675   );
 676
 677 /**
 678   This function clears the attributes for the memory region specified by BaseAddress and
 679   Length from their current attributes to the attributes specified by Attributes.
 680
 681   @param[in]  BaseAddress      The physical address that is the start address of a memory region.
 682   @param[in]  Length           The size in bytes of the memory region.
 683   @param[in]  Attributes       The bit mask of attributes to clear for the memory region.
 684
 685   @retval EFI_SUCCESS           The attributes were cleared for the memory region.
 686   @retval EFI_ACCESS_DENIED     The attributes for the memory resource range specified by
 687                                 BaseAddress and Length cannot be modified.
 688   @retval EFI_INVALID_PARAMETER Length is zero.
 689                                 Attributes specified an illegal combination of attributes that
 690                                 cannot be set together.
 691   @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to modify the attributes of
 692                                 the memory resource range.
 693   @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the memory
 694                                 resource range specified by BaseAddress and Length.
 695                                 The bit mask of attributes is not support for the memory resource
 696                                 range specified by BaseAddress and Length.
 697
 698 **/
 699 EFI_STATUS
 700 EFIAPI
 701 SmmClearMemoryAttributes (
 702   IN  EFI_PHYSICAL_ADDRESS                       BaseAddress,
 703   IN  UINT64                                     Length,
 704   IN  UINT64                                     Attributes
 705   );
 706
 707 /**
 708   Initialize MP synchronization data.
 709
 710 **/
 711 VOID
 712 EFIAPI
 713 InitializeMpSyncData (
 714   VOID
 715   );
 716
 717 /**
 718
 719   Find out SMRAM information including SMRR base and SMRR size.
 720
 721   @param          SmrrBase          SMRR base
 722   @param          SmrrSize          SMRR size
 723
 724 **/
 725 VOID
 726 FindSmramInfo (
 727   OUT UINT32   *SmrrBase,
 728   OUT UINT32   *SmrrSize
 729   );
 730
 731 /**
 732   Relocate SmmBases for each processor.
 733
 734   Execute on first boot and all S3 resumes
 735
 736 **/
 737 VOID
 738 EFIAPI
 739 SmmRelocateBases (
 740   VOID
 741   );
 742
 743 /**
 744   Page Fault handler for SMM use.
 745
 746   @param  InterruptType    Defines the type of interrupt or exception that
 747                            occurred on the processor.This parameter is processor architecture specific.
 748   @param  SystemContext    A pointer to the processor context when
 749                            the interrupt occurred on the processor.
 750 **/
 751 VOID
 752 EFIAPI
 753 SmiPFHandler (
 754   IN EFI_EXCEPTION_TYPE   InterruptType,
 755   IN EFI_SYSTEM_CONTEXT   SystemContext
 756   );
 757
 758 /**
 759   Perform the remaining tasks.
 760
 761 **/
 762 VOID
 763 PerformRemainingTasks (
 764   VOID
 765   );
 766
 767 /**
 768   Perform the pre tasks.
 769
 770 **/
 771 VOID
 772 PerformPreTasks (
 773   VOID
 774   );
 775
 776 /**
 777   Initialize MSR spin lock by MSR index.
 778
 779   @param  MsrIndex       MSR index value.
 780
 781 **/
 782 VOID
 783 InitMsrSpinLockByIndex (
 784   IN UINT32      MsrIndex
 785   );
 786
 787 /**
 788   Hook return address of SMM Save State so that semaphore code
 789   can be executed immediately after AP exits SMM to indicate to
 790   the BSP that an AP has exited SMM after SMBASE relocation.
 791
 792   @param[in] CpuIndex     The processor index.
 793   @param[in] RebasedFlag  A pointer to a flag that is set to TRUE
 794                           immediately after AP exits SMM.
 795
 796 **/
 797 VOID
 798 SemaphoreHook (
 799   IN UINTN             CpuIndex,
 800   IN volatile BOOLEAN  *RebasedFlag
 801   );
 802
 803 /**
 804 Configure SMM Code Access Check feature for all processors.
 805 SMM Feature Control MSR will be locked after configuration.
 806 **/
 807 VOID
 808 ConfigSmmCodeAccessCheck (
 809   VOID
 810   );
 811
 812 /**
 813   Hook the code executed immediately after an RSM instruction on the currently
 814   executing CPU.  The mode of code executed immediately after RSM must be
 815   detected, and the appropriate hook must be selected.  Always clear the auto
 816   HALT restart flag if it is set.
 817
 818   @param[in] CpuIndex                 The processor index for the currently
 819                                       executing CPU.
 820   @param[in] CpuState                 Pointer to SMRAM Save State Map for the
 821                                       currently executing CPU.
 822   @param[in] NewInstructionPointer32  Instruction pointer to use if resuming to
 823                                       32-bit mode from 64-bit SMM.
 824   @param[in] NewInstructionPointer    Instruction pointer to use if resuming to
 825                                       same mode as SMM.
 826
 827   @retval The value of the original instruction pointer before it was hooked.
 828
 829 **/
 830 UINT64
 831 EFIAPI
 832 HookReturnFromSmm (
 833   IN UINTN              CpuIndex,
 834   SMRAM_SAVE_STATE_MAP  *CpuState,
 835   UINT64                NewInstructionPointer32,
 836   UINT64                NewInstructionPointer
 837   );
 838
 839 /**
 840   Get the size of the SMI Handler in bytes.
 841
 842   @retval The size, in bytes, of the SMI Handler.
 843
 844 **/
 845 UINTN
 846 EFIAPI
 847 GetSmiHandlerSize (
 848   VOID
 849   );
 850
 851 /**
 852   Install the SMI handler for the CPU specified by CpuIndex.  This function
 853   is called by the CPU that was elected as monarch during System Management
 854   Mode initialization.
 855
 856   @param[in] CpuIndex   The index of the CPU to install the custom SMI handler.
 857                         The value must be between 0 and the NumberOfCpus field
 858                         in the System Management System Table (SMST).
 859   @param[in] SmBase     The SMBASE address for the CPU specified by CpuIndex.
 860   @param[in] SmiStack   The stack to use when an SMI is processed by the
 861                         the CPU specified by CpuIndex.
 862   @param[in] StackSize  The size, in bytes, if the stack used when an SMI is
 863                         processed by the CPU specified by CpuIndex.
 864   @param[in] GdtBase    The base address of the GDT to use when an SMI is
 865                         processed by the CPU specified by CpuIndex.
 866   @param[in] GdtSize    The size, in bytes, of the GDT used when an SMI is
 867                         processed by the CPU specified by CpuIndex.
 868   @param[in] IdtBase    The base address of the IDT to use when an SMI is
 869                         processed by the CPU specified by CpuIndex.
 870   @param[in] IdtSize    The size, in bytes, of the IDT used when an SMI is
 871                         processed by the CPU specified by CpuIndex.
 872   @param[in] Cr3        The base address of the page tables to use when an SMI
 873                         is processed by the CPU specified by CpuIndex.
 874 **/
 875 VOID
 876 EFIAPI
 877 InstallSmiHandler (
 878   IN UINTN   CpuIndex,
 879   IN UINT32  SmBase,
 880   IN VOID    *SmiStack,
 881   IN UINTN   StackSize,
 882   IN UINTN   GdtBase,
 883   IN UINTN   GdtSize,
 884   IN UINTN   IdtBase,
 885   IN UINTN   IdtSize,
 886   IN UINT32  Cr3
 887   );
 888
 889 /**
 890   Search module name by input IP address and output it.
 891
 892   @param CallerIpAddress   Caller instruction pointer.
 893
 894 **/
 895 VOID
 896 DumpModuleInfoByIp (
 897   IN  UINTN              CallerIpAddress
 898   );
 899
 900 /**
 901   This function sets memory attribute according to MemoryAttributesTable.
 902 **/
 903 VOID
 904 SetMemMapAttributes (
 905   VOID
 906   );
 907
 908 /**
 909   This function sets UEFI memory attribute according to UEFI memory map.
 910 **/
 911 VOID
 912 SetUefiMemMapAttributes (
 913   VOID
 914   );
 915
 916 /**
 917   Return if the Address is forbidden as SMM communication buffer.
 918
 919   @param[in] Address the address to be checked
 920
 921   @return TRUE  The address is forbidden as SMM communication buffer.
 922   @return FALSE The address is allowed as SMM communication buffer.
 923 **/
 924 BOOLEAN
 925 IsSmmCommBufferForbiddenAddress (
 926   IN UINT64  Address
 927   );
 928
 929 /**
 930   This function caches the UEFI memory map information.
 931 **/
 932 VOID
 933 GetUefiMemoryMap (
 934   VOID
 935   );
 936
 937 /**
 938   This function sets memory attribute for page table.
 939 **/
 940 VOID
 941 SetPageTableAttributes (
 942   VOID
 943   );
 944
 945 /**
 946   Get page table base address and the depth of the page table.
 947
 948   @param[out] Base        Page table base address.
 949   @param[out] FiveLevels  TRUE means 5 level paging. FALSE means 4 level paging.
 950 **/
 951 VOID
 952 GetPageTable (
 953   OUT UINTN   *Base,
 954   OUT BOOLEAN *FiveLevels OPTIONAL
 955   );
 956
 957 /**
 958   This function sets the attributes for the memory region specified by BaseAddress and
 959   Length from their current attributes to the attributes specified by Attributes.
 960
 961   @param[in]   BaseAddress      The physical address that is the start address of a memory region.
 962   @param[in]   Length           The size in bytes of the memory region.
 963   @param[in]   Attributes       The bit mask of attributes to set for the memory region.
 964   @param[out]  IsSplitted       TRUE means page table splitted. FALSE means page table not splitted.
 965
 966   @retval EFI_SUCCESS           The attributes were set for the memory region.
 967   @retval EFI_ACCESS_DENIED     The attributes for the memory resource range specified by
 968                                 BaseAddress and Length cannot be modified.
 969   @retval EFI_INVALID_PARAMETER Length is zero.
 970                                 Attributes specified an illegal combination of attributes that
 971                                 cannot be set together.
 972   @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to modify the attributes of
 973                                 the memory resource range.
 974   @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the memory
 975                                 resource range specified by BaseAddress and Length.
 976                                 The bit mask of attributes is not support for the memory resource
 977                                 range specified by BaseAddress and Length.
 978
 979 **/
 980 EFI_STATUS
 981 EFIAPI
 982 SmmSetMemoryAttributesEx (
 983   IN  EFI_PHYSICAL_ADDRESS                       BaseAddress,
 984   IN  UINT64                                     Length,
 985   IN  UINT64                                     Attributes,
 986   OUT BOOLEAN                                    *IsSplitted  OPTIONAL
 987   );
 988
 989 /**
 990   This function clears the attributes for the memory region specified by BaseAddress and
 991   Length from their current attributes to the attributes specified by Attributes.
 992
 993   @param[in]   BaseAddress      The physical address that is the start address of a memory region.
 994   @param[in]   Length           The size in bytes of the memory region.
 995   @param[in]   Attributes       The bit mask of attributes to clear for the memory region.
 996   @param[out]  IsSplitted       TRUE means page table splitted. FALSE means page table not splitted.
 997
 998   @retval EFI_SUCCESS           The attributes were cleared for the memory region.
 999   @retval EFI_ACCESS_DENIED     The attributes for the memory resource range specified by
1000                                 BaseAddress and Length cannot be modified.
1001   @retval EFI_INVALID_PARAMETER Length is zero.
1002                                 Attributes specified an illegal combination of attributes that
1003                                 cannot be set together.
1004   @retval EFI_OUT_OF_RESOURCES  There are not enough system resources to modify the attributes of
1005                                 the memory resource range.
1006   @retval EFI_UNSUPPORTED       The processor does not support one or more bytes of the memory
1007                                 resource range specified by BaseAddress and Length.
1008                                 The bit mask of attributes is not support for the memory resource
1009                                 range specified by BaseAddress and Length.
1010
1011 **/
1012 EFI_STATUS
1013 EFIAPI
1014 SmmClearMemoryAttributesEx (
1015   IN  EFI_PHYSICAL_ADDRESS                       BaseAddress,
1016   IN  UINT64                                     Length,
1017   IN  UINT64                                     Attributes,
1018   OUT BOOLEAN                                    *IsSplitted  OPTIONAL
1019   );
1020
1021 /**
1022   This API provides a way to allocate memory for page table.
1023
1024   This API can be called more once to allocate memory for page tables.
1025
1026   Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer to the
1027   allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
1028   is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
1029   returned.
1030
1031   @param  Pages                 The number of 4 KB pages to allocate.
1032
1033   @return A pointer to the allocated buffer or NULL if allocation fails.
1034
1035 **/
1036 VOID *
1037 AllocatePageTableMemory (
1038   IN UINTN           Pages
1039   );
1040
1041 /**
1042   Allocate pages for code.
1043
1044   @param[in]  Pages Number of pages to be allocated.
1045
1046   @return Allocated memory.
1047 **/
1048 VOID *
1049 AllocateCodePages (
1050   IN UINTN           Pages
1051   );
1052
1053 /**
1054   Allocate aligned pages for code.
1055
1056   @param[in]  Pages                 Number of pages to be allocated.
1057   @param[in]  Alignment             The requested alignment of the allocation.
1058                                     Must be a power of two.
1059                                     If Alignment is zero, then byte alignment is used.
1060
1061   @return Allocated memory.
1062 **/
1063 VOID *
1064 AllocateAlignedCodePages (
1065   IN UINTN            Pages,
1066   IN UINTN            Alignment
1067   );
1068
1069
1070 //
1071 // S3 related global variable and function prototype.
1072 //
1073
1074 extern BOOLEAN                mSmmS3Flag;
1075
1076 /**
1077   Initialize SMM S3 resume state structure used during S3 Resume.
1078
1079   @param[in] Cr3    The base address of the page tables to use in SMM.
1080
1081 **/
1082 VOID
1083 InitSmmS3ResumeState (
1084   IN UINT32  Cr3
1085   );
1086
1087 /**
1088   Get ACPI CPU data.
1089
1090 **/
1091 VOID
1092 GetAcpiCpuData (
1093   VOID
1094   );
1095
1096 /**
1097   Restore SMM Configuration in S3 boot path.
1098
1099 **/
1100 VOID
1101 RestoreSmmConfigurationInS3 (
1102   VOID
1103   );
1104
1105 /**
1106   Get ACPI S3 enable flag.
1107
1108 **/
1109 VOID
1110 GetAcpiS3EnableFlag (
1111   VOID
1112   );
1113
1114 /**
1115   Transfer AP to safe hlt-loop after it finished restore CPU features on S3 patch.
1116
1117   @param[in] ApHltLoopCode          The address of the safe hlt-loop function.
1118   @param[in] TopOfStack             A pointer to the new stack to use for the ApHltLoopCode.
1119   @param[in] NumberToFinishAddress  Address of Semaphore of APs finish count.
1120
1121 **/
1122 VOID
1123 TransferApToSafeState (
1124   IN UINTN  ApHltLoopCode,
1125   IN UINTN  TopOfStack,
1126   IN UINTN  NumberToFinishAddress
1127   );
1128
1129 /**
1130   Set ShadowStack memory.
1131
1132   @param[in]  Cr3              The page table base address.
1133   @param[in]  BaseAddress      The physical address that is the start address of a memory region.
1134   @param[in]  Length           The size in bytes of the memory region.
1135
1136   @retval EFI_SUCCESS           The shadow stack memory is set.
1137 **/
1138 EFI_STATUS
1139 SetShadowStack (
1140   IN  UINTN                                      Cr3,
1141   IN  EFI_PHYSICAL_ADDRESS                       BaseAddress,
1142   IN  UINT64                                     Length
1143   );
1144
1145 /**
1146   Set not present memory.
1147
1148   @param[in]  Cr3              The page table base address.
1149   @param[in]  BaseAddress      The physical address that is the start address of a memory region.
1150   @param[in]  Length           The size in bytes of the memory region.
1151
1152   @retval EFI_SUCCESS           The not present memory is set.
1153 **/
1154 EFI_STATUS
1155 SetNotPresentPage (
1156   IN  UINTN                                      Cr3,
1157   IN  EFI_PHYSICAL_ADDRESS                       BaseAddress,
1158   IN  UINT64                                     Length
1159   );
1160
1161 /**
1162   Initialize the shadow stack related data structure.
1163
1164   @param CpuIndex     The index of CPU.
1165   @param ShadowStack  The bottom of the shadow stack for this CPU.
1166 **/
1167 VOID
1168 InitShadowStack (
1169   IN UINTN  CpuIndex,
1170   IN VOID   *ShadowStack
1171   );
1172
1173 /**
1174   This function set given attributes of the memory region specified by
1175   BaseAddress and Length.
1176
1177   @param  This              The EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL instance.
1178   @param  BaseAddress       The physical address that is the start address of
1179                             a memory region.
1180   @param  Length            The size in bytes of the memory region.
1181   @param  Attributes        The bit mask of attributes to set for the memory
1182                             region.
1183
1184   @retval EFI_SUCCESS           The attributes were set for the memory region.
1185   @retval EFI_INVALID_PARAMETER Length is zero.
1186                                 Attributes specified an illegal combination of
1187                                 attributes that cannot be set together.
1188   @retval EFI_UNSUPPORTED       The processor does not support one or more
1189                                 bytes of the memory resource range specified
1190                                 by BaseAddress and Length.
1191                                 The bit mask of attributes is not supported for
1192                                 the memory resource range specified by
1193                                 BaseAddress and Length.
1194
1195 **/
1196 EFI_STATUS
1197 EFIAPI
1198 EdkiiSmmSetMemoryAttributes (
1199   IN  EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL   *This,
1200   IN  EFI_PHYSICAL_ADDRESS                  BaseAddress,
1201   IN  UINT64                                Length,
1202   IN  UINT64                                Attributes
1203   );
1204
1205 /**
1206   This function clears given attributes of the memory region specified by
1207   BaseAddress and Length.
1208
1209   @param  This              The EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL instance.
1210   @param  BaseAddress       The physical address that is the start address of
1211                             a memory region.
1212   @param  Length            The size in bytes of the memory region.
1213   @param  Attributes        The bit mask of attributes to clear for the memory
1214                             region.
1215
1216   @retval EFI_SUCCESS           The attributes were cleared for the memory region.
1217   @retval EFI_INVALID_PARAMETER Length is zero.
1218                                 Attributes specified an illegal combination of
1219                                 attributes that cannot be cleared together.
1220   @retval EFI_UNSUPPORTED       The processor does not support one or more
1221                                 bytes of the memory resource range specified
1222                                 by BaseAddress and Length.
1223                                 The bit mask of attributes is not supported for
1224                                 the memory resource range specified by
1225                                 BaseAddress and Length.
1226
1227 **/
1228 EFI_STATUS
1229 EFIAPI
1230 EdkiiSmmClearMemoryAttributes (
1231   IN  EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL   *This,
1232   IN  EFI_PHYSICAL_ADDRESS                  BaseAddress,
1233   IN  UINT64                                Length,
1234   IN  UINT64                                Attributes
1235   );
1236
1237 /**
1238   This function retrieves the attributes of the memory region specified by
1239   BaseAddress and Length. If different attributes are got from different part
1240   of the memory region, EFI_NO_MAPPING will be returned.
1241
1242   @param  This              The EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL instance.
1243   @param  BaseAddress       The physical address that is the start address of
1244                             a memory region.
1245   @param  Length            The size in bytes of the memory region.
1246   @param  Attributes        Pointer to attributes returned.
1247
1248   @retval EFI_SUCCESS           The attributes got for the memory region.
1249   @retval EFI_INVALID_PARAMETER Length is zero.
1250                                 Attributes is NULL.
1251   @retval EFI_NO_MAPPING        Attributes are not consistent cross the memory
1252                                 region.
1253   @retval EFI_UNSUPPORTED       The processor does not support one or more
1254                                 bytes of the memory resource range specified
1255                                 by BaseAddress and Length.
1256
1257 **/
1258 EFI_STATUS
1259 EFIAPI
1260 EdkiiSmmGetMemoryAttributes (
1261   IN  EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL   *This,
1262   IN  EFI_PHYSICAL_ADDRESS                  BaseAddress,
1263   IN  UINT64                                Length,
1264   IN  UINT64                                *Attributes
1265   );
1266
1267 /**
1268   This function fixes up the address of the global variable or function
1269   referred in SmmInit assembly files to be the absolute address.
1270 **/
1271 VOID
1272 EFIAPI
1273 PiSmmCpuSmmInitFixupAddress (
1274  );
1275
1276 /**
1277   This function fixes up the address of the global variable or function
1278   referred in SmiEntry assembly files to be the absolute address.
1279 **/
1280 VOID
1281 EFIAPI
1282 PiSmmCpuSmiEntryFixupAddress (
1283  );
1284
1285 /**
1286   This function reads CR2 register when on-demand paging is enabled
1287   for 64 bit and no action for 32 bit.
1288
1289   @param[out]  *Cr2  Pointer to variable to hold CR2 register value.
1290 **/
1291 VOID
1292 SaveCr2 (
1293   OUT UINTN  *Cr2
1294   );
1295
1296 /**
1297   This function writes into CR2 register when on-demand paging is enabled
1298   for 64 bit and no action for 32 bit.
1299
1300   @param[in]  Cr2  Value to write into CR2 register.
1301 **/
1302 VOID
1303 RestoreCr2 (
1304   IN UINTN  Cr2
1305   );
1306
1307 /**
1308   Schedule a procedure to run on the specified CPU.
1309
1310   @param[in]       Procedure                The address of the procedure to run
1311   @param[in]       CpuIndex                 Target CPU Index
1312   @param[in,out]   ProcArguments            The parameter to pass to the procedure
1313   @param[in,out]   Token                    This is an optional parameter that allows the caller to execute the
1314                                             procedure in a blocking or non-blocking fashion. If it is NULL the
1315                                             call is blocking, and the call will not return until the AP has
1316                                             completed the procedure. If the token is not NULL, the call will
1317                                             return immediately. The caller can check whether the procedure has
1318                                             completed with CheckOnProcedure or WaitForProcedure.
1319   @param[in]       TimeoutInMicroseconds    Indicates the time limit in microseconds for the APs to finish
1320                                             execution of Procedure, either for blocking or non-blocking mode.
1321                                             Zero means infinity. If the timeout expires before all APs return
1322                                             from Procedure, then Procedure on the failed APs is terminated. If
1323                                             the timeout expires in blocking mode, the call returns EFI_TIMEOUT.
1324                                             If the timeout expires in non-blocking mode, the timeout determined
1325                                             can be through CheckOnProcedure or WaitForProcedure.
1326                                             Note that timeout support is optional. Whether an implementation
1327                                             supports this feature can be determined via the Attributes data
1328                                             member.
1329   @param[in,out]   CpuStatus                This optional pointer may be used to get the status code returned
1330                                             by Procedure when it completes execution on the target AP, or with
1331                                             EFI_TIMEOUT if the Procedure fails to complete within the optional
1332                                             timeout. The implementation will update this variable with
1333                                             EFI_NOT_READY prior to starting Procedure on the target AP.
1334
1335   @retval EFI_INVALID_PARAMETER    CpuNumber not valid
1336   @retval EFI_INVALID_PARAMETER    CpuNumber specifying BSP
1337   @retval EFI_INVALID_PARAMETER    The AP specified by CpuNumber did not enter SMM
1338   @retval EFI_INVALID_PARAMETER    The AP specified by CpuNumber is busy
1339   @retval EFI_SUCCESS              The procedure has been successfully scheduled
1340
1341 **/
1342 EFI_STATUS
1343 InternalSmmStartupThisAp (
1344   IN      EFI_AP_PROCEDURE2              Procedure,
1345   IN      UINTN                          CpuIndex,
1346   IN OUT  VOID                           *ProcArguments OPTIONAL,
1347   IN OUT  MM_COMPLETION                  *Token,
1348   IN      UINTN                          TimeoutInMicroseconds,
1349   IN OUT  EFI_STATUS                     *CpuStatus
1350   );
1351
1352 /**
1353   Checks whether the input token is the current used token.
1354
1355   @param[in]  Token      This parameter describes the token that was passed into DispatchProcedure or
1356                          BroadcastProcedure.
1357
1358   @retval TRUE           The input token is the current used token.
1359   @retval FALSE          The input token is not the current used token.
1360 **/
1361 BOOLEAN
1362 IsTokenInUse (
1363   IN SPIN_LOCK           *Token
1364   );
1365
1366 /**
1367   Checks status of specified AP.
1368
1369   This function checks whether the specified AP has finished the task assigned
1370   by StartupThisAP(), and whether timeout expires.
1371
1372   @param[in]  Token             This parameter describes the token that was passed into DispatchProcedure or
1373                                 BroadcastProcedure.
1374
1375   @retval EFI_SUCCESS           Specified AP has finished task assigned by StartupThisAPs().
1376   @retval EFI_NOT_READY         Specified AP has not finished task and timeout has not expired.
1377 **/
1378 EFI_STATUS
1379 IsApReady (
1380   IN SPIN_LOCK  *Token
1381   );
1382
1383 /**
1384   Check whether it is an present AP.
1385
1386   @param   CpuIndex      The AP index which calls this function.
1387
1388   @retval  TRUE           It's a present AP.
1389   @retval  TRUE           This is not an AP or it is not present.
1390
1391 **/
1392 BOOLEAN
1393 IsPresentAp (
1394   IN UINTN        CpuIndex
1395   );
1396
1397 /**
1398   Worker function to execute a caller provided function on all enabled APs.
1399
1400   @param[in]     Procedure               A pointer to the function to be run on
1401                                          enabled APs of the system.
1402   @param[in]     TimeoutInMicroseconds   Indicates the time limit in microseconds for
1403                                          APs to return from Procedure, either for
1404                                          blocking or non-blocking mode.
1405   @param[in,out] ProcedureArguments      The parameter passed into Procedure for
1406                                          all APs.
1407   @param[in,out] Token                   This is an optional parameter that allows the caller to execute the
1408                                          procedure in a blocking or non-blocking fashion. If it is NULL the
1409                                          call is blocking, and the call will not return until the AP has
1410                                          completed the procedure. If the token is not NULL, the call will
1411                                          return immediately. The caller can check whether the procedure has
1412                                          completed with CheckOnProcedure or WaitForProcedure.
1413   @param[in,out] CPUStatus               This optional pointer may be used to get the status code returned
1414                                          by Procedure when it completes execution on the target AP, or with
1415                                          EFI_TIMEOUT if the Procedure fails to complete within the optional
1416                                          timeout. The implementation will update this variable with
1417                                          EFI_NOT_READY prior to starting Procedure on the target AP.
1418
1419   @retval EFI_SUCCESS             In blocking mode, all APs have finished before
1420                                   the timeout expired.
1421   @retval EFI_SUCCESS             In non-blocking mode, function has been dispatched
1422                                   to all enabled APs.
1423   @retval others                  Failed to Startup all APs.
1424
1425 **/
1426 EFI_STATUS
1427 InternalSmmStartupAllAPs (
1428   IN       EFI_AP_PROCEDURE2             Procedure,
1429   IN       UINTN                         TimeoutInMicroseconds,
1430   IN OUT   VOID                          *ProcedureArguments OPTIONAL,
1431   IN OUT   MM_COMPLETION                 *Token,
1432   IN OUT   EFI_STATUS                    *CPUStatus
1433   );
1434
1435 /**
1436
1437   Register the SMM Foundation entry point.
1438
1439   @param[in]      Procedure            A pointer to the code stream to be run on the designated target AP
1440                                        of the system. Type EFI_AP_PROCEDURE is defined below in Volume 2
1441                                        with the related definitions of
1442                                        EFI_MP_SERVICES_PROTOCOL.StartupAllAPs.
1443                                        If caller may pass a value of NULL to deregister any existing
1444                                        startup procedure.
1445   @param[in,out]  ProcedureArguments   Allows the caller to pass a list of parameters to the code that is
1446                                        run by the AP. It is an optional common mailbox between APs and
1447                                        the caller to share information
1448
1449   @retval EFI_SUCCESS                  The Procedure has been set successfully.
1450   @retval EFI_INVALID_PARAMETER        The Procedure is NULL but ProcedureArguments not NULL.
1451
1452 **/
1453 EFI_STATUS
1454 RegisterStartupProcedure (
1455   IN     EFI_AP_PROCEDURE    Procedure,
1456   IN OUT VOID                *ProcedureArguments OPTIONAL
1457   );
1458
1459 /**
1460   Allocate buffer for SpinLock and Wrapper function buffer.
1461
1462 **/
1463 VOID
1464 InitializeDataForMmMp (
1465   VOID
1466   );
1467
1468 /**
1469   Return whether access to non-SMRAM is restricted.
1470
1471   @retval TRUE  Access to non-SMRAM is restricted.
1472   @retval FALSE Access to non-SMRAM is not restricted.
1473 **/
1474 BOOLEAN
1475 IsRestrictedMemoryAccess (
1476   VOID
1477   );
1478
1479 #endif