Home | History | Annotate | Download | only in SmmCpuFeaturesLib 
      1 /** @file
      2   SMM STM support functions
      3 
      4   Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
      5   This program and the accompanying materials
      6   are licensed and made available under the terms and conditions of the BSD License
      7   which accompanies this distribution.  The full text of the license may be found at
      8   http://opensource.org/licenses/bsd-license.php.
      9 
     10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
     11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
     12 
     13 **/
     14 
     15 #include <PiSmm.h>
     16 #include <Library/BaseLib.h>
     17 #include <Library/BaseMemoryLib.h>
     18 #include <Library/MemoryAllocationLib.h>
     19 #include <Library/HobLib.h>
     20 #include <Library/DebugLib.h>
     21 #include <Library/UefiBootServicesTableLib.h>
     22 #include <Library/SmmServicesTableLib.h>
     23 #include <Library/TpmMeasurementLib.h>
     24 #include <Register/Cpuid.h>
     25 #include <Register/ArchitecturalMsr.h>
     26 #include <Register/SmramSaveStateMap.h>
     27 
     28 #include <Protocol/MpService.h>
     29 
     30 #include "SmmStm.h"
     31 
     32 #define TXT_EVTYPE_BASE                  0x400
     33 #define TXT_EVTYPE_STM_HASH              (TXT_EVTYPE_BASE + 14)
     34 
     35 #define RDWR_ACCS             3
     36 #define FULL_ACCS             7
     37 
     38 /**
     39   The constructor function
     40 
     41   @param[in]  ImageHandle  The firmware allocated handle for the EFI image.
     42   @param[in]  SystemTable  A pointer to the EFI System Table.
     43 
     44   @retval EFI_SUCCESS      The constructor always returns EFI_SUCCESS.
     45 
     46 **/
     47 EFI_STATUS
     48 EFIAPI
     49 SmmCpuFeaturesLibConstructor (
     50   IN EFI_HANDLE        ImageHandle,
     51   IN EFI_SYSTEM_TABLE  *SystemTable
     52   );
     53 
     54 EFI_HANDLE  mStmSmmCpuHandle = NULL;
     55 
     56 BOOLEAN mLockLoadMonitor = FALSE;
     57 
     58 //
     59 // Template of STM_RSC_END structure for copying.
     60 //
     61 GLOBAL_REMOVE_IF_UNREFERENCED STM_RSC_END mRscEndNode = {
     62   {END_OF_RESOURCES, sizeof (STM_RSC_END)},
     63 };
     64 
     65 GLOBAL_REMOVE_IF_UNREFERENCED UINT8  *mStmResourcesPtr         = NULL;
     66 GLOBAL_REMOVE_IF_UNREFERENCED UINTN  mStmResourceTotalSize     = 0x0;
     67 GLOBAL_REMOVE_IF_UNREFERENCED UINTN  mStmResourceSizeUsed      = 0x0;
     68 GLOBAL_REMOVE_IF_UNREFERENCED UINTN  mStmResourceSizeAvailable = 0x0;
     69 
     70 GLOBAL_REMOVE_IF_UNREFERENCED UINT32  mStmState = 0;
     71 
     72 //
     73 // System Configuration Table pointing to STM Configuration Table
     74 //
     75 GLOBAL_REMOVE_IF_UNREFERENCED
     76 EFI_SM_MONITOR_INIT_PROTOCOL mSmMonitorInitProtocol = {
     77   LoadMonitor,
     78   AddPiResource,
     79   DeletePiResource,
     80   GetPiResource,
     81   GetMonitorState,
     82 };
     83 
     84 
     85 
     86 
     87 #define   CPUID1_EDX_XD_SUPPORT      0x100000
     88 
     89 //
     90 // External global variables associated with SMI Handler Template
     91 //
     92 extern CONST TXT_PROCESSOR_SMM_DESCRIPTOR  gcStmPsd;
     93 extern UINT32                              gStmSmbase;
     94 extern volatile UINT32                     gStmSmiStack;
     95 extern UINT32                              gStmSmiCr3;
     96 extern volatile UINT8                      gcStmSmiHandlerTemplate[];
     97 extern CONST UINT16                        gcStmSmiHandlerSize;
     98 extern UINT16                              gcStmSmiHandlerOffset;
     99 extern BOOLEAN                             gStmXdSupported;
    100 
    101 //
    102 // Variables used by SMI Handler
    103 //
    104 IA32_DESCRIPTOR  gStmSmiHandlerIdtr;
    105 
    106 //
    107 // MP Services Protocol
    108 //
    109 EFI_MP_SERVICES_PROTOCOL  *mSmmCpuFeaturesLibMpService = NULL;
    110 
    111 //
    112 // MSEG Base and Length in SMRAM
    113 //
    114 UINTN  mMsegBase = 0;
    115 UINTN  mMsegSize = 0;
    116 
    117 BOOLEAN  mStmConfigurationTableInitialized = FALSE;
    118 
    119 
    120 /**
    121   The constructor function
    122 
    123   @param[in]  ImageHandle  The firmware allocated handle for the EFI image.
    124   @param[in]  SystemTable  A pointer to the EFI System Table.
    125 
    126   @retval EFI_SUCCESS      The constructor always returns EFI_SUCCESS.
    127 
    128 **/
    129 EFI_STATUS
    130 EFIAPI
    131 SmmCpuFeaturesLibStmConstructor (
    132   IN EFI_HANDLE        ImageHandle,
    133   IN EFI_SYSTEM_TABLE  *SystemTable
    134   )
    135 {
    136   EFI_STATUS              Status;
    137   CPUID_VERSION_INFO_ECX  RegEcx;
    138   EFI_HOB_GUID_TYPE       *GuidHob;
    139   EFI_SMRAM_DESCRIPTOR    *SmramDescriptor;
    140 
    141   //
    142   // Call the common constructor function
    143   //
    144   Status = SmmCpuFeaturesLibConstructor (ImageHandle, SystemTable);
    145   ASSERT_EFI_ERROR (Status);
    146 
    147   //
    148   // Lookup the MP Services Protocol
    149   //
    150   Status = gBS->LocateProtocol (
    151                   &gEfiMpServiceProtocolGuid,
    152                   NULL,
    153                   (VOID **)&mSmmCpuFeaturesLibMpService
    154                   );
    155   ASSERT_EFI_ERROR (Status);
    156 
    157   //
    158   // If CPU supports VMX, then determine SMRAM range for MSEG.
    159   //
    160   AsmCpuid (CPUID_VERSION_INFO, NULL, NULL, &RegEcx.Uint32, NULL);
    161   if (RegEcx.Bits.VMX == 1) {
    162     GuidHob = GetFirstGuidHob (&gMsegSmramGuid);
    163     if (GuidHob != NULL) {
    164       //
    165       // Retrieve MSEG location from MSEG SRAM HOB
    166       //
    167       SmramDescriptor = (EFI_SMRAM_DESCRIPTOR *) GET_GUID_HOB_DATA (GuidHob);
    168       if (SmramDescriptor->PhysicalSize > 0) {
    169         mMsegBase       = (UINTN)SmramDescriptor->CpuStart;
    170         mMsegSize       = (UINTN)SmramDescriptor->PhysicalSize;
    171       }
    172     } else if (PcdGet32 (PcdCpuMsegSize) > 0) {
    173       //
    174       // Allocate MSEG from SMRAM memory
    175       //
    176       mMsegBase = (UINTN)AllocatePages (EFI_SIZE_TO_PAGES (PcdGet32 (PcdCpuMsegSize)));
    177       if (mMsegBase > 0) {
    178         mMsegSize = ALIGN_VALUE (PcdGet32 (PcdCpuMsegSize), EFI_PAGE_SIZE);
    179       } else {
    180         DEBUG ((DEBUG_ERROR, "Not enough SMRAM resource to allocate MSEG size %08x\n", PcdGet32 (PcdCpuMsegSize)));
    181       }
    182     }
    183     if (mMsegBase > 0) {
    184       DEBUG ((DEBUG_INFO, "MsegBase: 0x%08x, MsegSize: 0x%08x\n", mMsegBase, mMsegSize));
    185     }
    186   }
    187 
    188   return EFI_SUCCESS;
    189 }
    190 
    191 /**
    192   Internal worker function that is called to complete CPU initialization at the
    193   end of SmmCpuFeaturesInitializeProcessor().
    194 
    195 **/
    196 VOID
    197 FinishSmmCpuFeaturesInitializeProcessor (
    198   VOID
    199   )
    200 {
    201   MSR_IA32_SMM_MONITOR_CTL_REGISTER  SmmMonitorCtl;
    202 
    203   //
    204   // Set MSEG Base Address in SMM Monitor Control MSR.
    205   //
    206   if (mMsegBase > 0) {
    207     SmmMonitorCtl.Uint64        = 0;
    208     SmmMonitorCtl.Bits.MsegBase = (UINT32)mMsegBase >> 12;
    209     SmmMonitorCtl.Bits.Valid    = 1;
    210     AsmWriteMsr64 (MSR_IA32_SMM_MONITOR_CTL, SmmMonitorCtl.Uint64);
    211   }
    212 }
    213 
    214 /**
    215   Return the size, in bytes, of a custom SMI Handler in bytes.  If 0 is
    216   returned, then a custom SMI handler is not provided by this library,
    217   and the default SMI handler must be used.
    218 
    219   @retval 0    Use the default SMI handler.
    220   @retval > 0  Use the SMI handler installed by SmmCpuFeaturesInstallSmiHandler()
    221                The caller is required to allocate enough SMRAM for each CPU to
    222                support the size of the custom SMI handler.
    223 **/
    224 UINTN
    225 EFIAPI
    226 SmmCpuFeaturesGetSmiHandlerSize (
    227   VOID
    228   )
    229 {
    230   return gcStmSmiHandlerSize;
    231 }
    232 
    233 /**
    234   Install a custom SMI handler for the CPU specified by CpuIndex.  This function
    235   is only called if SmmCpuFeaturesGetSmiHandlerSize() returns a size is greater
    236   than zero and is called by the CPU that was elected as monarch during System
    237   Management Mode initialization.
    238 
    239   @param[in] CpuIndex   The index of the CPU to install the custom SMI handler.
    240                         The value must be between 0 and the NumberOfCpus field
    241                         in the System Management System Table (SMST).
    242   @param[in] SmBase     The SMBASE address for the CPU specified by CpuIndex.
    243   @param[in] SmiStack   The stack to use when an SMI is processed by the
    244                         the CPU specified by CpuIndex.
    245   @param[in] StackSize  The size, in bytes, if the stack used when an SMI is
    246                         processed by the CPU specified by CpuIndex.
    247   @param[in] GdtBase    The base address of the GDT to use when an SMI is
    248                         processed by the CPU specified by CpuIndex.
    249   @param[in] GdtSize    The size, in bytes, of the GDT used when an SMI is
    250                         processed by the CPU specified by CpuIndex.
    251   @param[in] IdtBase    The base address of the IDT to use when an SMI is
    252                         processed by the CPU specified by CpuIndex.
    253   @param[in] IdtSize    The size, in bytes, of the IDT used when an SMI is
    254                         processed by the CPU specified by CpuIndex.
    255   @param[in] Cr3        The base address of the page tables to use when an SMI
    256                         is processed by the CPU specified by CpuIndex.
    257 **/
    258 VOID
    259 EFIAPI
    260 SmmCpuFeaturesInstallSmiHandler (
    261   IN UINTN   CpuIndex,
    262   IN UINT32  SmBase,
    263   IN VOID    *SmiStack,
    264   IN UINTN   StackSize,
    265   IN UINTN   GdtBase,
    266   IN UINTN   GdtSize,
    267   IN UINTN   IdtBase,
    268   IN UINTN   IdtSize,
    269   IN UINT32  Cr3
    270   )
    271 {
    272   EFI_STATUS                     Status;
    273   TXT_PROCESSOR_SMM_DESCRIPTOR   *Psd;
    274   VOID                           *Hob;
    275   UINT32                         RegEax;
    276   UINT32                         RegEdx;
    277   EFI_PROCESSOR_INFORMATION      ProcessorInfo;
    278 
    279   CopyMem ((VOID *)(UINTN)(SmBase + TXT_SMM_PSD_OFFSET), &gcStmPsd, sizeof (gcStmPsd));
    280   Psd = (TXT_PROCESSOR_SMM_DESCRIPTOR *)(VOID *)(UINTN)(SmBase + TXT_SMM_PSD_OFFSET);
    281   Psd->SmmGdtPtr = GdtBase;
    282   Psd->SmmGdtSize = (UINT32)GdtSize;
    283 
    284   //
    285   // Initialize values in template before copy
    286   //
    287   gStmSmiStack             = (UINT32)((UINTN)SmiStack + StackSize - sizeof (UINTN));
    288   gStmSmiCr3               = Cr3;
    289   gStmSmbase               = SmBase;
    290   gStmSmiHandlerIdtr.Base  = IdtBase;
    291   gStmSmiHandlerIdtr.Limit = (UINT16)(IdtSize - 1);
    292 
    293   if (gStmXdSupported) {
    294     AsmCpuid (CPUID_EXTENDED_FUNCTION, &RegEax, NULL, NULL, NULL);
    295     if (RegEax <= CPUID_EXTENDED_FUNCTION) {
    296       //
    297       // Extended CPUID functions are not supported on this processor.
    298       //
    299       gStmXdSupported = FALSE;
    300     }
    301 
    302     AsmCpuid (CPUID_EXTENDED_CPU_SIG, NULL, NULL, NULL, &RegEdx);
    303     if ((RegEdx & CPUID1_EDX_XD_SUPPORT) == 0) {
    304       //
    305       // Execute Disable Bit feature is not supported on this processor.
    306       //
    307       gStmXdSupported = FALSE;
    308     }
    309   }
    310 
    311   //
    312   // Set the value at the top of the CPU stack to the CPU Index
    313   //
    314   *(UINTN*)(UINTN)gStmSmiStack = CpuIndex;
    315 
    316   //
    317   // Copy template to CPU specific SMI handler location
    318   //
    319   CopyMem (
    320     (VOID*)(UINTN)(SmBase + SMM_HANDLER_OFFSET),
    321     (VOID*)gcStmSmiHandlerTemplate,
    322     gcStmSmiHandlerSize
    323     );
    324 
    325   Psd->SmmSmiHandlerRip = SmBase + SMM_HANDLER_OFFSET + gcStmSmiHandlerOffset;
    326   Psd->SmmSmiHandlerRsp = (UINTN)SmiStack + StackSize - sizeof(UINTN);
    327   Psd->SmmCr3           = Cr3;
    328 
    329   DEBUG((DEBUG_ERROR, "CpuSmmStmExceptionStackSize - %x\n", PcdGet32(PcdCpuSmmStmExceptionStackSize)));
    330   DEBUG((DEBUG_ERROR, "Pages - %x\n", EFI_SIZE_TO_PAGES(PcdGet32(PcdCpuSmmStmExceptionStackSize))));
    331   Psd->StmProtectionExceptionHandler.SpeRsp = (UINT64)(UINTN)AllocatePages (EFI_SIZE_TO_PAGES (PcdGet32 (PcdCpuSmmStmExceptionStackSize)));
    332   Psd->StmProtectionExceptionHandler.SpeRsp += EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (PcdGet32 (PcdCpuSmmStmExceptionStackSize)));
    333 
    334   Psd->BiosHwResourceRequirementsPtr        = (UINT64)(UINTN)GetStmResource ();
    335 
    336   //
    337   // Get the APIC ID for the CPU specified by CpuIndex
    338   //
    339   Status = mSmmCpuFeaturesLibMpService->GetProcessorInfo (
    340              mSmmCpuFeaturesLibMpService,
    341              CpuIndex,
    342              &ProcessorInfo
    343              );
    344   ASSERT_EFI_ERROR (Status);
    345 
    346   Psd->LocalApicId = (UINT32)ProcessorInfo.ProcessorId;
    347   Psd->AcpiRsdp = 0;
    348 
    349   Hob = GetFirstHob (EFI_HOB_TYPE_CPU);
    350   if (Hob != NULL) {
    351     Psd->PhysicalAddressBits = ((EFI_HOB_CPU *) Hob)->SizeOfMemorySpace;
    352   } else {
    353     AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
    354     if (RegEax >= 0x80000008) {
    355       AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);
    356       Psd->PhysicalAddressBits = (UINT8) RegEax;
    357     } else {
    358       Psd->PhysicalAddressBits = 36;
    359     }
    360   }
    361 
    362   if (!mStmConfigurationTableInitialized) {
    363     StmSmmConfigurationTableInit ();
    364     mStmConfigurationTableInitialized = TRUE;
    365   }
    366 }
    367 
    368 /**
    369   SMM End Of Dxe event notification handler.
    370 
    371   STM support need patch AcpiRsdp in TXT_PROCESSOR_SMM_DESCRIPTOR.
    372 
    373   @param[in] Protocol   Points to the protocol's unique identifier.
    374   @param[in] Interface  Points to the interface instance.
    375   @param[in] Handle     The handle on which the interface was installed.
    376 
    377   @retval EFI_SUCCESS   Notification handler runs successfully.
    378 **/
    379 EFI_STATUS
    380 EFIAPI
    381 SmmEndOfDxeEventNotify (
    382   IN CONST EFI_GUID  *Protocol,
    383   IN VOID            *Interface,
    384   IN EFI_HANDLE      Handle
    385   )
    386 {
    387   VOID                          *Rsdp;
    388   UINTN                         Index;
    389   TXT_PROCESSOR_SMM_DESCRIPTOR  *Psd;
    390 
    391   DEBUG ((DEBUG_INFO, "SmmEndOfDxeEventNotify\n"));
    392 
    393   //
    394   // found ACPI table RSD_PTR from system table
    395   //
    396   Rsdp = NULL;
    397   for (Index = 0; Index < gST->NumberOfTableEntries; Index++) {
    398     if (CompareGuid (&(gST->ConfigurationTable[Index].VendorGuid), &gEfiAcpi20TableGuid)) {
    399       //
    400       // A match was found.
    401       //
    402       Rsdp = gST->ConfigurationTable[Index].VendorTable;
    403       break;
    404     }
    405   }
    406   if (Rsdp == NULL) {
    407     for (Index = 0; Index < gST->NumberOfTableEntries; Index++) {
    408       if (CompareGuid (&(gST->ConfigurationTable[Index].VendorGuid), &gEfiAcpi10TableGuid)) {
    409         //
    410         // A match was found.
    411         //
    412         Rsdp = gST->ConfigurationTable[Index].VendorTable;
    413         break;
    414       }
    415     }
    416   }
    417 
    418   for (Index = 0; Index < gSmst->NumberOfCpus; Index++) {
    419     Psd = (TXT_PROCESSOR_SMM_DESCRIPTOR *)((UINTN)gSmst->CpuSaveState[Index] - SMRAM_SAVE_STATE_MAP_OFFSET + TXT_SMM_PSD_OFFSET);
    420     DEBUG ((DEBUG_INFO, "Index=%d  Psd=%p  Rsdp=%p\n", Index, Psd, Rsdp));
    421     Psd->AcpiRsdp = (UINT64)(UINTN)Rsdp;
    422   }
    423 
    424   mLockLoadMonitor = TRUE;
    425 
    426   return EFI_SUCCESS;
    427 }
    428 
    429 /**
    430   This function initializes the STM configuration table.
    431 **/
    432 VOID
    433 StmSmmConfigurationTableInit (
    434   VOID
    435   )
    436 {
    437   EFI_STATUS    Status;
    438     VOID        *Registration;
    439 
    440   Status = gSmst->SmmInstallProtocolInterface (
    441                     &mStmSmmCpuHandle,
    442                     &gEfiSmMonitorInitProtocolGuid,
    443                     EFI_NATIVE_INTERFACE,
    444                     &mSmMonitorInitProtocol
    445                     );
    446   ASSERT_EFI_ERROR (Status);
    447 
    448   //
    449   //
    450   // Register SMM End of DXE Event
    451   //
    452   Status = gSmst->SmmRegisterProtocolNotify (
    453                     &gEfiSmmEndOfDxeProtocolGuid,
    454                     SmmEndOfDxeEventNotify,
    455                     &Registration
    456                     );
    457   ASSERT_EFI_ERROR (Status);
    458 }
    459 
    460 /**
    461 
    462   Get STM state.
    463 
    464   @return STM state
    465 
    466 **/
    467 EFI_SM_MONITOR_STATE
    468 EFIAPI
    469 GetMonitorState (
    470   VOID
    471   )
    472 {
    473   return mStmState;
    474 }
    475 
    476 /**
    477 
    478   Handle single Resource to see if it can be merged into Record.
    479 
    480   @param Resource  A pointer to resource node to be added
    481   @param Record    A pointer to record node to be merged
    482 
    483   @retval TRUE  resource handled
    484   @retval FALSE resource is not handled
    485 
    486 **/
    487 BOOLEAN
    488 HandleSingleResource (
    489   IN  STM_RSC      *Resource,
    490   IN  STM_RSC      *Record
    491   )
    492 {
    493   UINT64      ResourceLo;
    494   UINT64      ResourceHi;
    495   UINT64      RecordLo;
    496   UINT64      RecordHi;
    497 
    498   ResourceLo = 0;
    499   ResourceHi = 0;
    500   RecordLo = 0;
    501   RecordHi = 0;
    502 
    503   //
    504   // Calling code is responsible for making sure that
    505   // Resource->Header.RscType == (*Record)->Header.RscType
    506   // thus we use just one of them as switch variable.
    507   //
    508   switch (Resource->Header.RscType) {
    509   case MEM_RANGE:
    510   case MMIO_RANGE:
    511     ResourceLo = Resource->Mem.Base;
    512     ResourceHi = Resource->Mem.Base + Resource->Mem.Length;
    513     RecordLo = Record->Mem.Base;
    514     RecordHi = Record->Mem.Base + Record->Mem.Length;
    515     if (Resource->Mem.RWXAttributes != Record->Mem.RWXAttributes) {
    516       if ((ResourceLo == RecordLo) && (ResourceHi == RecordHi)) {
    517         Record->Mem.RWXAttributes = Resource->Mem.RWXAttributes | Record->Mem.RWXAttributes;
    518         return TRUE;
    519       } else {
    520         return FALSE;
    521       }
    522     }
    523     break;
    524   case IO_RANGE:
    525   case TRAPPED_IO_RANGE:
    526     ResourceLo = (UINT64) Resource->Io.Base;
    527     ResourceHi = (UINT64) Resource->Io.Base + (UINT64) Resource->Io.Length;
    528     RecordLo = (UINT64) Record->Io.Base;
    529     RecordHi = (UINT64) Record->Io.Base + (UINT64) Record->Io.Length;
    530     break;
    531   case PCI_CFG_RANGE:
    532     if ((Resource->PciCfg.OriginatingBusNumber != Record->PciCfg.OriginatingBusNumber) ||
    533         (Resource->PciCfg.LastNodeIndex != Record->PciCfg.LastNodeIndex)) {
    534       return FALSE;
    535     }
    536     if (CompareMem (Resource->PciCfg.PciDevicePath, Record->PciCfg.PciDevicePath, sizeof(STM_PCI_DEVICE_PATH_NODE) * (Resource->PciCfg.LastNodeIndex + 1)) != 0) {
    537       return FALSE;
    538     }
    539     ResourceLo = (UINT64) Resource->PciCfg.Base;
    540     ResourceHi = (UINT64) Resource->PciCfg.Base + (UINT64) Resource->PciCfg.Length;
    541     RecordLo = (UINT64) Record->PciCfg.Base;
    542     RecordHi = (UINT64) Record->PciCfg.Base + (UINT64) Record->PciCfg.Length;
    543     if (Resource->PciCfg.RWAttributes != Record->PciCfg.RWAttributes) {
    544       if ((ResourceLo == RecordLo) && (ResourceHi == RecordHi)) {
    545         Record->PciCfg.RWAttributes = Resource->PciCfg.RWAttributes | Record->PciCfg.RWAttributes;
    546         return TRUE;
    547       } else {
    548         return FALSE;
    549       }
    550     }
    551     break;
    552   case MACHINE_SPECIFIC_REG:
    553     //
    554     // Special case - merge MSR masks in place.
    555     //
    556     if (Resource->Msr.MsrIndex != Record->Msr.MsrIndex) {
    557       return FALSE;
    558     }
    559     Record->Msr.ReadMask |= Resource->Msr.ReadMask;
    560     Record->Msr.WriteMask |= Resource->Msr.WriteMask;
    561     return TRUE;
    562   default:
    563     return FALSE;
    564   }
    565   //
    566   // If resources are disjoint
    567   //
    568   if ((ResourceHi < RecordLo) || (ResourceLo > RecordHi)) {
    569     return FALSE;
    570   }
    571 
    572   //
    573   // If resource is consumed by record.
    574   //
    575   if ((ResourceLo >= RecordLo) && (ResourceHi <= RecordHi)) {
    576     return TRUE;
    577   }
    578   //
    579   // Resources are overlapping.
    580   // Resource and record are merged.
    581   //
    582   ResourceLo = (ResourceLo < RecordLo) ? ResourceLo : RecordLo;
    583   ResourceHi = (ResourceHi > RecordHi) ? ResourceHi : RecordHi;
    584 
    585   switch (Resource->Header.RscType) {
    586   case MEM_RANGE:
    587   case MMIO_RANGE:
    588     Record->Mem.Base = ResourceLo;
    589     Record->Mem.Length = ResourceHi - ResourceLo;
    590     break;
    591   case IO_RANGE:
    592   case TRAPPED_IO_RANGE:
    593     Record->Io.Base = (UINT16) ResourceLo;
    594     Record->Io.Length = (UINT16) (ResourceHi - ResourceLo);
    595     break;
    596   case PCI_CFG_RANGE:
    597     Record->PciCfg.Base = (UINT16) ResourceLo;
    598     Record->PciCfg.Length = (UINT16) (ResourceHi - ResourceLo);
    599     break;
    600   default:
    601     return FALSE;
    602   }
    603 
    604   return TRUE;
    605 }
    606 
    607 /**
    608 
    609   Add resource node.
    610 
    611   @param Resource  A pointer to resource node to be added
    612 
    613 **/
    614 VOID
    615 AddSingleResource (
    616   IN  STM_RSC    *Resource
    617   )
    618 {
    619   STM_RSC    *Record;
    620 
    621   Record = (STM_RSC *)mStmResourcesPtr;
    622 
    623   while (TRUE) {
    624     if (Record->Header.RscType == END_OF_RESOURCES) {
    625       break;
    626     }
    627     //
    628     // Go to next record if resource and record types don't match.
    629     //
    630     if (Resource->Header.RscType != Record->Header.RscType) {
    631       Record = (STM_RSC *)((UINTN)Record + Record->Header.Length);
    632       continue;
    633     }
    634     //
    635     // Record is handled inside of procedure - don't adjust.
    636     //
    637     if (HandleSingleResource (Resource, Record)) {
    638       return ;
    639     }
    640     Record = (STM_RSC *)((UINTN)Record + Record->Header.Length);
    641   }
    642 
    643   //
    644   // Add resource to the end of area.
    645   //
    646   CopyMem (
    647     mStmResourcesPtr + mStmResourceSizeUsed - sizeof(mRscEndNode),
    648     Resource,
    649     Resource->Header.Length
    650     );
    651   CopyMem (
    652     mStmResourcesPtr + mStmResourceSizeUsed - sizeof(mRscEndNode) + Resource->Header.Length,
    653     &mRscEndNode,
    654     sizeof(mRscEndNode)
    655     );
    656   mStmResourceSizeUsed += Resource->Header.Length;
    657   mStmResourceSizeAvailable = mStmResourceTotalSize - mStmResourceSizeUsed;
    658 
    659   return ;
    660 }
    661 
    662 /**
    663 
    664   Add resource list.
    665 
    666   @param ResourceList  A pointer to resource list to be added
    667   @param NumEntries    Optional number of entries.
    668                        If 0, list must be terminated by END_OF_RESOURCES.
    669 
    670 **/
    671 VOID
    672 AddResource (
    673   IN  STM_RSC    *ResourceList,
    674   IN  UINT32      NumEntries OPTIONAL
    675   )
    676 {
    677   UINT32      Count;
    678   UINTN       Index;
    679   STM_RSC    *Resource;
    680 
    681   if (NumEntries == 0) {
    682     Count = 0xFFFFFFFF;
    683   } else {
    684     Count = NumEntries;
    685   }
    686 
    687   Resource = ResourceList;
    688 
    689   for (Index = 0; Index < Count; Index++) {
    690     if (Resource->Header.RscType == END_OF_RESOURCES) {
    691       return ;
    692     }
    693     AddSingleResource (Resource);
    694     Resource = (STM_RSC *)((UINTN)Resource + Resource->Header.Length);
    695   }
    696   return ;
    697 }
    698 
    699 /**
    700 
    701   Validate resource list.
    702 
    703   @param ResourceList  A pointer to resource list to be added
    704   @param NumEntries    Optional number of entries.
    705                        If 0, list must be terminated by END_OF_RESOURCES.
    706 
    707   @retval TRUE  resource valid
    708   @retval FALSE resource invalid
    709 
    710 **/
    711 BOOLEAN
    712 ValidateResource (
    713   IN  STM_RSC    *ResourceList,
    714   IN  UINT32      NumEntries OPTIONAL
    715   )
    716 {
    717   UINT32      Count;
    718   UINTN       Index;
    719   STM_RSC    *Resource;
    720   UINTN       SubIndex;
    721 
    722   //
    723   // If NumEntries == 0 make it very big. Scan will be terminated by
    724   // END_OF_RESOURCES.
    725   //
    726   if (NumEntries == 0) {
    727     Count = 0xFFFFFFFF;
    728   } else {
    729     Count = NumEntries;
    730   }
    731 
    732   //
    733   // Start from beginning of resource list.
    734   //
    735   Resource = ResourceList;
    736 
    737   for (Index = 0; Index < Count; Index++) {
    738     DEBUG ((DEBUG_ERROR, "ValidateResource (%d) - RscType(%x)\n", Index, Resource->Header.RscType));
    739     //
    740     // Validate resource.
    741     //
    742     switch (Resource->Header.RscType) {
    743       case END_OF_RESOURCES:
    744         if (Resource->Header.Length != sizeof (STM_RSC_END)) {
    745           return  FALSE;
    746         }
    747         //
    748         // If we are passed actual number of resources to add,
    749         // END_OF_RESOURCES structure between them is considered an
    750         // error. If NumEntries == 0 END_OF_RESOURCES is a termination.
    751         //
    752         if (NumEntries != 0) {
    753           return  FALSE;
    754         } else {
    755           //
    756           // If NumEntries == 0 and list reached end - return success.
    757           //
    758           return TRUE;
    759         }
    760         break;
    761 
    762       case MEM_RANGE:
    763       case MMIO_RANGE:
    764         if (Resource->Header.Length != sizeof (STM_RSC_MEM_DESC)) {
    765           return FALSE;
    766         }
    767 
    768         if (Resource->Mem.RWXAttributes > FULL_ACCS) {
    769           return FALSE;
    770         }
    771         break;
    772 
    773       case IO_RANGE:
    774       case TRAPPED_IO_RANGE:
    775         if (Resource->Header.Length != sizeof (STM_RSC_IO_DESC)) {
    776           return FALSE;
    777         }
    778 
    779         if ((Resource->Io.Base + Resource->Io.Length) > 0xFFFF) {
    780           return FALSE;
    781         }
    782         break;
    783 
    784       case PCI_CFG_RANGE:
    785         DEBUG ((DEBUG_ERROR, "ValidateResource - PCI (0x%02x, 0x%08x, 0x%02x, 0x%02x)\n", Resource->PciCfg.OriginatingBusNumber, Resource->PciCfg.LastNodeIndex, Resource->PciCfg.PciDevicePath[0].PciDevice, Resource->PciCfg.PciDevicePath[0].PciFunction));
    786         if (Resource->Header.Length != sizeof (STM_RSC_PCI_CFG_DESC) + (sizeof(STM_PCI_DEVICE_PATH_NODE) * Resource->PciCfg.LastNodeIndex)) {
    787           return FALSE;
    788         }
    789         for (SubIndex = 0; SubIndex <= Resource->PciCfg.LastNodeIndex; SubIndex++) {
    790           if ((Resource->PciCfg.PciDevicePath[SubIndex].PciDevice > 0x1F) || (Resource->PciCfg.PciDevicePath[SubIndex].PciFunction > 7)) {
    791             return FALSE;
    792           }
    793         }
    794         if ((Resource->PciCfg.Base + Resource->PciCfg.Length) > 0x1000) {
    795           return FALSE;
    796         }
    797         break;
    798 
    799       case MACHINE_SPECIFIC_REG:
    800         if (Resource->Header.Length != sizeof (STM_RSC_MSR_DESC)) {
    801           return FALSE;
    802         }
    803         break;
    804 
    805       default :
    806         DEBUG ((DEBUG_ERROR, "ValidateResource - Unknown RscType(%x)\n", Resource->Header.RscType));
    807         return FALSE;
    808     }
    809     Resource = (STM_RSC *)((UINTN)Resource + Resource->Header.Length);
    810   }
    811   return TRUE;
    812 }
    813 
    814 /**
    815 
    816   Get resource list.
    817   EndResource is excluded.
    818 
    819   @param ResourceList  A pointer to resource list to be added
    820   @param NumEntries    Optional number of entries.
    821                        If 0, list must be terminated by END_OF_RESOURCES.
    822 
    823   @retval TRUE  resource valid
    824   @retval FALSE resource invalid
    825 
    826 **/
    827 UINTN
    828 GetResourceSize (
    829   IN  STM_RSC    *ResourceList,
    830   IN  UINT32      NumEntries OPTIONAL
    831   )
    832 {
    833   UINT32      Count;
    834   UINTN       Index;
    835   STM_RSC    *Resource;
    836 
    837   Resource = ResourceList;
    838 
    839   //
    840   // If NumEntries == 0 make it very big. Scan will be terminated by
    841   // END_OF_RESOURCES.
    842   //
    843   if (NumEntries == 0) {
    844     Count = 0xFFFFFFFF;
    845   } else {
    846     Count = NumEntries;
    847   }
    848 
    849   //
    850   // Start from beginning of resource list.
    851   //
    852   Resource = ResourceList;
    853 
    854   for (Index = 0; Index < Count; Index++) {
    855     if (Resource->Header.RscType == END_OF_RESOURCES) {
    856       break;
    857     }
    858     Resource = (STM_RSC *)((UINTN)Resource + Resource->Header.Length);
    859   }
    860 
    861   return (UINTN)Resource - (UINTN)ResourceList;
    862 }
    863 
    864 /**
    865 
    866   Add resources in list to database. Allocate new memory areas as needed.
    867 
    868   @param ResourceList  A pointer to resource list to be added
    869   @param NumEntries    Optional number of entries.
    870                        If 0, list must be terminated by END_OF_RESOURCES.
    871 
    872   @retval EFI_SUCCESS            If resources are added
    873   @retval EFI_INVALID_PARAMETER  If nested procedure detected resource failer
    874   @retval EFI_OUT_OF_RESOURCES   If nested procedure returned it and we cannot allocate more areas.
    875 
    876 **/
    877 EFI_STATUS
    878 EFIAPI
    879 AddPiResource (
    880   IN  STM_RSC    *ResourceList,
    881   IN  UINT32      NumEntries OPTIONAL
    882   )
    883 {
    884   EFI_STATUS            Status;
    885   UINTN                 ResourceSize;
    886   EFI_PHYSICAL_ADDRESS  NewResource;
    887   UINTN                 NewResourceSize;
    888 
    889   DEBUG ((DEBUG_INFO, "AddPiResource - Enter\n"));
    890 
    891   if (!ValidateResource (ResourceList, NumEntries)) {
    892     return EFI_INVALID_PARAMETER;
    893   }
    894 
    895   ResourceSize = GetResourceSize (ResourceList, NumEntries);
    896   DEBUG ((DEBUG_INFO, "ResourceSize - 0x%08x\n", ResourceSize));
    897   if (ResourceSize == 0) {
    898     return EFI_INVALID_PARAMETER;
    899   }
    900 
    901   if (mStmResourcesPtr == NULL) {
    902     //
    903     // First time allocation
    904     //
    905     NewResourceSize = EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (ResourceSize + sizeof(mRscEndNode)));
    906     DEBUG ((DEBUG_INFO, "Allocate - 0x%08x\n", NewResourceSize));
    907     Status = gSmst->SmmAllocatePages (
    908                       AllocateAnyPages,
    909                       EfiRuntimeServicesData,
    910                       EFI_SIZE_TO_PAGES (NewResourceSize),
    911                       &NewResource
    912                       );
    913     if (EFI_ERROR (Status)) {
    914       return Status;
    915     }
    916 
    917     //
    918     // Copy EndResource for intialization
    919     //
    920     mStmResourcesPtr = (UINT8 *)(UINTN)NewResource;
    921     mStmResourceTotalSize = NewResourceSize;
    922     CopyMem (mStmResourcesPtr, &mRscEndNode, sizeof(mRscEndNode));
    923     mStmResourceSizeUsed      = sizeof(mRscEndNode);
    924     mStmResourceSizeAvailable = mStmResourceTotalSize - sizeof(mRscEndNode);
    925 
    926     //
    927     // Let SmmCore change resource ptr
    928     //
    929     NotifyStmResourceChange (mStmResourcesPtr);
    930   } else if (mStmResourceSizeAvailable < ResourceSize) {
    931     //
    932     // Need enlarge
    933     //
    934     NewResourceSize = mStmResourceTotalSize + (ResourceSize - mStmResourceSizeAvailable);
    935     NewResourceSize = EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (NewResourceSize));
    936     DEBUG ((DEBUG_INFO, "ReAllocate - 0x%08x\n", NewResourceSize));
    937     Status = gSmst->SmmAllocatePages (
    938                       AllocateAnyPages,
    939                       EfiRuntimeServicesData,
    940                       EFI_SIZE_TO_PAGES (NewResourceSize),
    941                       &NewResource
    942                       );
    943     if (EFI_ERROR (Status)) {
    944       return Status;
    945     }
    946     CopyMem ((VOID *)(UINTN)NewResource, mStmResourcesPtr, mStmResourceSizeUsed);
    947     mStmResourceSizeAvailable = NewResourceSize - mStmResourceSizeUsed;
    948 
    949     gSmst->SmmFreePages (
    950              (EFI_PHYSICAL_ADDRESS)(UINTN)mStmResourcesPtr,
    951              EFI_SIZE_TO_PAGES (mStmResourceTotalSize)
    952              );
    953 
    954     mStmResourceTotalSize = NewResourceSize;
    955     mStmResourcesPtr = (UINT8 *)(UINTN)NewResource;
    956 
    957     //
    958     // Let SmmCore change resource ptr
    959     //
    960     NotifyStmResourceChange (mStmResourcesPtr);
    961   }
    962 
    963   //
    964   // Check duplication
    965   //
    966   AddResource (ResourceList, NumEntries);
    967 
    968   return EFI_SUCCESS;
    969 }
    970 
    971 /**
    972 
    973   Delete resources in list to database.
    974 
    975   @param ResourceList  A pointer to resource list to be deleted
    976                        NULL means delete all resources.
    977   @param NumEntries    Optional number of entries.
    978                        If 0, list must be terminated by END_OF_RESOURCES.
    979 
    980   @retval EFI_SUCCESS            If resources are deleted
    981   @retval EFI_INVALID_PARAMETER  If nested procedure detected resource failer
    982 
    983 **/
    984 EFI_STATUS
    985 EFIAPI
    986 DeletePiResource (
    987   IN  STM_RSC    *ResourceList,
    988   IN  UINT32      NumEntries OPTIONAL
    989   )
    990 {
    991   if (ResourceList != NULL) {
    992     // TBD
    993     ASSERT (FALSE);
    994     return EFI_UNSUPPORTED;
    995   }
    996   //
    997   // Delete all
    998   //
    999   CopyMem (mStmResourcesPtr, &mRscEndNode, sizeof(mRscEndNode));
   1000   mStmResourceSizeUsed      = sizeof(mRscEndNode);
   1001   mStmResourceSizeAvailable = mStmResourceTotalSize - sizeof(mRscEndNode);
   1002   return EFI_SUCCESS;
   1003 }
   1004 
   1005 /**
   1006 
   1007   Get BIOS resources.
   1008 
   1009   @param ResourceList  A pointer to resource list to be filled
   1010   @param ResourceSize  On input it means size of resource list input.
   1011                        On output it means size of resource list filled,
   1012                        or the size of resource list to be filled if size of too small.
   1013 
   1014   @retval EFI_SUCCESS            If resources are returned.
   1015   @retval EFI_BUFFER_TOO_SMALL   If resource list buffer is too small to hold the whole resources.
   1016 
   1017 **/
   1018 EFI_STATUS
   1019 EFIAPI
   1020 GetPiResource (
   1021   OUT    STM_RSC *ResourceList,
   1022   IN OUT UINT32  *ResourceSize
   1023   )
   1024 {
   1025   if (*ResourceSize < mStmResourceSizeUsed) {
   1026     *ResourceSize = (UINT32)mStmResourceSizeUsed;
   1027     return EFI_BUFFER_TOO_SMALL;
   1028   }
   1029 
   1030   CopyMem (ResourceList, mStmResourcesPtr, mStmResourceSizeUsed);
   1031   *ResourceSize = (UINT32)mStmResourceSizeUsed;
   1032   return EFI_SUCCESS;
   1033 }
   1034 
   1035 /**
   1036 
   1037   Set valid bit for MSEG MSR.
   1038 
   1039   @param Buffer Ap function buffer. (not used)
   1040 
   1041 **/
   1042 VOID
   1043 EFIAPI
   1044 EnableMsegMsr (
   1045   IN VOID  *Buffer
   1046   )
   1047 {
   1048   MSR_IA32_SMM_MONITOR_CTL_REGISTER  SmmMonitorCtl;
   1049 
   1050   SmmMonitorCtl.Uint64 = AsmReadMsr64 (MSR_IA32_SMM_MONITOR_CTL);
   1051   SmmMonitorCtl.Bits.Valid = 1;
   1052   AsmWriteMsr64 (MSR_IA32_SMM_MONITOR_CTL, SmmMonitorCtl.Uint64);
   1053 }
   1054 
   1055 /**
   1056 
   1057   Get 4K page aligned VMCS size.
   1058 
   1059   @return 4K page aligned VMCS size
   1060 
   1061 **/
   1062 UINT32
   1063 GetVmcsSize (
   1064   VOID
   1065   )
   1066 {
   1067   MSR_IA32_VMX_BASIC_REGISTER  VmxBasic;
   1068 
   1069   //
   1070   // Read VMCS size and and align to 4KB
   1071   //
   1072   VmxBasic.Uint64 = AsmReadMsr64 (MSR_IA32_VMX_BASIC);
   1073   return ALIGN_VALUE (VmxBasic.Bits.VmcsSize, SIZE_4KB);
   1074 }
   1075 
   1076 /**
   1077 
   1078   Check STM image size.
   1079 
   1080   @param StmImage      STM image
   1081   @param StmImageSize  STM image size
   1082 
   1083   @retval TRUE  check pass
   1084   @retval FALSE check fail
   1085 **/
   1086 BOOLEAN
   1087 StmCheckStmImage (
   1088   IN EFI_PHYSICAL_ADDRESS StmImage,
   1089   IN UINTN                StmImageSize
   1090   )
   1091 {
   1092   UINTN                     MinMsegSize;
   1093   STM_HEADER                *StmHeader;
   1094   IA32_VMX_MISC_REGISTER    VmxMiscMsr;
   1095 
   1096   //
   1097   // Check to see if STM image is compatible with CPU
   1098   //
   1099   StmHeader = (STM_HEADER *)(UINTN)StmImage;
   1100   VmxMiscMsr.Uint64 = AsmReadMsr64 (MSR_IA32_VMX_MISC);
   1101   if (StmHeader->HwStmHdr.MsegHeaderRevision != VmxMiscMsr.Bits.MsegRevisionIdentifier) {
   1102     DEBUG ((DEBUG_ERROR, "STM Image not compatible with CPU\n"));
   1103     DEBUG ((DEBUG_ERROR, "  StmHeader->HwStmHdr.MsegHeaderRevision = %08x\n", StmHeader->HwStmHdr.MsegHeaderRevision));
   1104     DEBUG ((DEBUG_ERROR, "  VmxMiscMsr.Bits.MsegRevisionIdentifier = %08x\n", VmxMiscMsr.Bits.MsegRevisionIdentifier));
   1105     return FALSE;
   1106   }
   1107 
   1108   //
   1109   // Get Minimal required Mseg size
   1110   //
   1111   MinMsegSize = (EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (StmHeader->SwStmHdr.StaticImageSize)) +
   1112                  StmHeader->SwStmHdr.AdditionalDynamicMemorySize +
   1113                  (StmHeader->SwStmHdr.PerProcDynamicMemorySize + GetVmcsSize () * 2) * gSmst->NumberOfCpus);
   1114   if (MinMsegSize < StmImageSize) {
   1115     MinMsegSize = StmImageSize;
   1116   }
   1117 
   1118   if (StmHeader->HwStmHdr.Cr3Offset >= StmHeader->SwStmHdr.StaticImageSize) {
   1119     //
   1120     // We will create page table, just in case that SINIT does not create it.
   1121     //
   1122     if (MinMsegSize < StmHeader->HwStmHdr.Cr3Offset + EFI_PAGES_TO_SIZE(6)) {
   1123       MinMsegSize = StmHeader->HwStmHdr.Cr3Offset + EFI_PAGES_TO_SIZE(6);
   1124     }
   1125   }
   1126 
   1127   //
   1128   // Check if it exceeds MSEG size
   1129   //
   1130   if (MinMsegSize > mMsegSize) {
   1131     DEBUG ((DEBUG_ERROR, "MSEG too small.  Min MSEG Size = %08x  Current MSEG Size = %08x\n", MinMsegSize, mMsegSize));
   1132     DEBUG ((DEBUG_ERROR, "  StmHeader->SwStmHdr.StaticImageSize             = %08x\n", StmHeader->SwStmHdr.StaticImageSize));
   1133     DEBUG ((DEBUG_ERROR, "  StmHeader->SwStmHdr.AdditionalDynamicMemorySize = %08x\n", StmHeader->SwStmHdr.AdditionalDynamicMemorySize));
   1134     DEBUG ((DEBUG_ERROR, "  StmHeader->SwStmHdr.PerProcDynamicMemorySize    = %08x\n", StmHeader->SwStmHdr.PerProcDynamicMemorySize));
   1135     DEBUG ((DEBUG_ERROR, "  VMCS Size                                       = %08x\n", GetVmcsSize ()));
   1136     DEBUG ((DEBUG_ERROR, "  Max CPUs                                        = %08x\n", gSmst->NumberOfCpus));
   1137     DEBUG ((DEBUG_ERROR, "  StmHeader->HwStmHdr.Cr3Offset                   = %08x\n", StmHeader->HwStmHdr.Cr3Offset));
   1138     return FALSE;
   1139   }
   1140 
   1141   return TRUE;
   1142 }
   1143 
   1144 /**
   1145 
   1146   Load STM image to MSEG.
   1147 
   1148   @param StmImage      STM image
   1149   @param StmImageSize  STM image size
   1150 
   1151 **/
   1152 VOID
   1153 StmLoadStmImage (
   1154   IN EFI_PHYSICAL_ADDRESS StmImage,
   1155   IN UINTN                StmImageSize
   1156   )
   1157 {
   1158   MSR_IA32_SMM_MONITOR_CTL_REGISTER  SmmMonitorCtl;
   1159   UINT32                             MsegBase;
   1160   STM_HEADER                         *StmHeader;
   1161 
   1162   //
   1163   // Get MSEG base address from MSR_IA32_SMM_MONITOR_CTL
   1164   //
   1165   SmmMonitorCtl.Uint64 = AsmReadMsr64 (MSR_IA32_SMM_MONITOR_CTL);
   1166   MsegBase = SmmMonitorCtl.Bits.MsegBase << 12;
   1167 
   1168   //
   1169   // Zero all of MSEG base address
   1170   //
   1171   ZeroMem ((VOID *)(UINTN)MsegBase, mMsegSize);
   1172 
   1173   //
   1174   // Copy STM Image into MSEG
   1175   //
   1176   CopyMem ((VOID *)(UINTN)MsegBase, (VOID *)(UINTN)StmImage, StmImageSize);
   1177 
   1178   //
   1179   // STM Header is at the beginning of the STM Image
   1180   //
   1181   StmHeader = (STM_HEADER *)(UINTN)StmImage;
   1182 
   1183   StmGen4GPageTable ((UINTN)MsegBase + StmHeader->HwStmHdr.Cr3Offset);
   1184 }
   1185 
   1186 /**
   1187 
   1188   Load STM image to MSEG.
   1189 
   1190   @param StmImage      STM image
   1191   @param StmImageSize  STM image size
   1192 
   1193   @retval EFI_SUCCESS            Load STM to MSEG successfully
   1194   @retval EFI_ALREADY_STARTED    STM image is already loaded to MSEG
   1195   @retval EFI_BUFFER_TOO_SMALL   MSEG is smaller than minimal requirement of STM image
   1196   @retval EFI_UNSUPPORTED        MSEG is not enabled
   1197 
   1198 **/
   1199 EFI_STATUS
   1200 EFIAPI
   1201 LoadMonitor (
   1202   IN EFI_PHYSICAL_ADDRESS StmImage,
   1203   IN UINTN                StmImageSize
   1204   )
   1205 {
   1206   MSR_IA32_SMM_MONITOR_CTL_REGISTER  SmmMonitorCtl;
   1207 
   1208   if (mLockLoadMonitor) {
   1209     return EFI_ACCESS_DENIED;
   1210   }
   1211 
   1212   SmmMonitorCtl.Uint64 = AsmReadMsr64 (MSR_IA32_SMM_MONITOR_CTL);
   1213   if (SmmMonitorCtl.Bits.MsegBase == 0) {
   1214     return EFI_UNSUPPORTED;
   1215   }
   1216 
   1217   if (!StmCheckStmImage (StmImage, StmImageSize)) {
   1218     return EFI_BUFFER_TOO_SMALL;
   1219   }
   1220 
   1221   // Record STM_HASH to PCR 0, just in case it is NOT TXT launch, we still need provide the evidence.
   1222   TpmMeasureAndLogData(
   1223     0,                        // PcrIndex
   1224     TXT_EVTYPE_STM_HASH,      // EventType
   1225     NULL,                     // EventLog
   1226     0,                        // LogLen
   1227     (VOID *)(UINTN)StmImage,  // HashData
   1228     StmImageSize              // HashDataLen
   1229     );
   1230 
   1231   StmLoadStmImage (StmImage, StmImageSize);
   1232 
   1233   mStmState |= EFI_SM_MONITOR_STATE_ENABLED;
   1234 
   1235   return EFI_SUCCESS;
   1236 }
   1237 
   1238 /**
   1239   This function return BIOS STM resource.
   1240   Produced by SmmStm.
   1241   Comsumed by SmmMpService when Init.
   1242 
   1243   @return BIOS STM resource
   1244 
   1245 **/
   1246 VOID *
   1247 GetStmResource(
   1248   VOID
   1249   )
   1250 {
   1251   return mStmResourcesPtr;
   1252 }
   1253 
   1254 /**
   1255   This function notify STM resource change.
   1256 
   1257   @param StmResource BIOS STM resource
   1258 
   1259 **/
   1260 VOID
   1261 NotifyStmResourceChange (
   1262   VOID *StmResource
   1263   )
   1264 {
   1265   UINTN                         Index;
   1266   TXT_PROCESSOR_SMM_DESCRIPTOR  *Psd;
   1267 
   1268   for (Index = 0; Index < gSmst->NumberOfCpus; Index++) {
   1269     Psd = (TXT_PROCESSOR_SMM_DESCRIPTOR *)((UINTN)gSmst->CpuSaveState[Index] - SMRAM_SAVE_STATE_MAP_OFFSET + TXT_SMM_PSD_OFFSET);
   1270     Psd->BiosHwResourceRequirementsPtr = (UINT64)(UINTN)StmResource;
   1271   }
   1272   return ;
   1273 }
   1274 
   1275 
   1276 /**
   1277   This is STM setup BIOS callback.
   1278 **/
   1279 VOID
   1280 EFIAPI
   1281 SmmStmSetup (
   1282   VOID
   1283   )
   1284 {
   1285   mStmState |= EFI_SM_MONITOR_STATE_ACTIVATED;
   1286 }
   1287 
   1288 /**
   1289   This is STM teardown BIOS callback.
   1290 **/
   1291 VOID
   1292 EFIAPI
   1293 SmmStmTeardown (
   1294   VOID
   1295   )
   1296 {
   1297   mStmState &= ~EFI_SM_MONITOR_STATE_ACTIVATED;
   1298 }
   1299 
   1300