EdkCompatibilityPkg/Compatibility/SmmBaseHelper/SmmBaseHelper.c

   1 /** @file
   2   SMM Base Helper SMM driver.
   3
   4   This driver is the counterpart of the SMM Base On SMM Base2 Thunk driver. It
   5   provides helping services in SMM to the SMM Base On SMM Base2 Thunk driver.
   6
   7   Copyright (c) 2009 - 2010, Intel Corporation
   8   All rights reserved. This program and the accompanying materials
   9   are licensed and made available under the terms and conditions of the BSD License
  10   which accompanies this distribution.  The full text of the license may be found at
  11   http://opensource.org/licenses/bsd-license.php
  12
  13   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15
  16 **/
  17
  18 #include <PiSmm.h>
  19 #include <Library/DebugLib.h>
  20 #include <Library/UefiBootServicesTableLib.h>
  21 #include <Library/SmmServicesTableLib.h>
  22 #include <Library/BaseLib.h>
  23 #include <Library/BaseMemoryLib.h>
  24 #include <Library/PeCoffLib.h>
  25 #include <Library/DevicePathLib.h>
  26 #include <Library/CacheMaintenanceLib.h>
  27 #include <Library/MemoryAllocationLib.h>
  28 #include <Guid/SmmBaseThunkCommunication.h>
  29 #include <Protocol/SmmBaseHelperReady.h>
  30 #include <Protocol/SmmCpu.h>
  31 #include <Protocol/LoadedImage.h>
  32 #include <Protocol/SmmCpuSaveState.h>
  33 #include <Protocol/MpService.h>
  34 #include <Protocol/LoadPe32Image.h>
  35
  36 ///
  37 /// Structure for tracking paired information of registered Framework SMI handler
  38 /// and correpsonding dispatch handle for SMI handler thunk.
  39 ///
  40 typedef struct {
  41   LIST_ENTRY                    Link;
  42   EFI_HANDLE                    DispatchHandle;
  43   EFI_HANDLE                    SmmImageHandle;
  44   EFI_SMM_CALLBACK_ENTRY_POINT  CallbackAddress;
  45   VOID                          *CommunicationBuffer;
  46   UINTN                         *SourceSize;
  47 } CALLBACK_INFO;
  48
  49 typedef struct {
  50   ///
  51   /// PI SMM CPU Save State register index
  52   ///
  53   EFI_SMM_SAVE_STATE_REGISTER   Register;
  54   ///
  55   /// Offset in Framework SMST
  56   ///
  57   UINTN                         Offset;
  58 } CPU_SAVE_STATE_CONVERSION;
  59
  60 #define CPU_SAVE_STATE_GET_OFFSET(Field)  (UINTN)(&(((EFI_SMM_CPU_SAVE_STATE *) 0)->Ia32SaveState.Field))
  61
  62
  63 EFI_HANDLE                         mDispatchHandle;
  64 EFI_SMM_CPU_PROTOCOL               *mSmmCpu;
  65 EFI_PE32_IMAGE_PROTOCOL            *mLoadPe32Image;
  66 EFI_GUID                           mEfiSmmCpuIoGuid = EFI_SMM_CPU_IO_GUID;
  67 EFI_SMM_BASE_HELPER_READY_PROTOCOL *mSmmBaseHelperReady;
  68 EFI_SMM_SYSTEM_TABLE               *mFrameworkSmst;
  69 UINTN                              mNumberOfProcessors;
  70
  71 LIST_ENTRY mCallbackInfoListHead = INITIALIZE_LIST_HEAD_VARIABLE (mCallbackInfoListHead);
  72
  73 CPU_SAVE_STATE_CONVERSION mCpuSaveStateConvTable[] = {
  74   {EFI_SMM_SAVE_STATE_REGISTER_LDTBASE  , CPU_SAVE_STATE_GET_OFFSET(LDTBase)},
  75   {EFI_SMM_SAVE_STATE_REGISTER_ES       , CPU_SAVE_STATE_GET_OFFSET(ES)},
  76   {EFI_SMM_SAVE_STATE_REGISTER_CS       , CPU_SAVE_STATE_GET_OFFSET(CS)},
  77   {EFI_SMM_SAVE_STATE_REGISTER_SS       , CPU_SAVE_STATE_GET_OFFSET(SS)},
  78   {EFI_SMM_SAVE_STATE_REGISTER_DS       , CPU_SAVE_STATE_GET_OFFSET(DS)},
  79   {EFI_SMM_SAVE_STATE_REGISTER_FS       , CPU_SAVE_STATE_GET_OFFSET(FS)},
  80   {EFI_SMM_SAVE_STATE_REGISTER_GS       , CPU_SAVE_STATE_GET_OFFSET(GS)},
  81   {EFI_SMM_SAVE_STATE_REGISTER_TR_SEL   , CPU_SAVE_STATE_GET_OFFSET(TR)},
  82   {EFI_SMM_SAVE_STATE_REGISTER_DR7      , CPU_SAVE_STATE_GET_OFFSET(DR7)},
  83   {EFI_SMM_SAVE_STATE_REGISTER_DR6      , CPU_SAVE_STATE_GET_OFFSET(DR6)},
  84   {EFI_SMM_SAVE_STATE_REGISTER_RAX      , CPU_SAVE_STATE_GET_OFFSET(EAX)},
  85   {EFI_SMM_SAVE_STATE_REGISTER_RBX      , CPU_SAVE_STATE_GET_OFFSET(EBX)},
  86   {EFI_SMM_SAVE_STATE_REGISTER_RCX      , CPU_SAVE_STATE_GET_OFFSET(ECX)},
  87   {EFI_SMM_SAVE_STATE_REGISTER_RDX      , CPU_SAVE_STATE_GET_OFFSET(EDX)},
  88   {EFI_SMM_SAVE_STATE_REGISTER_RSP      , CPU_SAVE_STATE_GET_OFFSET(ESP)},
  89   {EFI_SMM_SAVE_STATE_REGISTER_RBP      , CPU_SAVE_STATE_GET_OFFSET(EBP)},
  90   {EFI_SMM_SAVE_STATE_REGISTER_RSI      , CPU_SAVE_STATE_GET_OFFSET(ESI)},
  91   {EFI_SMM_SAVE_STATE_REGISTER_RDI      , CPU_SAVE_STATE_GET_OFFSET(EDI)},
  92   {EFI_SMM_SAVE_STATE_REGISTER_RIP      , CPU_SAVE_STATE_GET_OFFSET(EIP)},
  93   {EFI_SMM_SAVE_STATE_REGISTER_RFLAGS   , CPU_SAVE_STATE_GET_OFFSET(EFLAGS)},
  94   {EFI_SMM_SAVE_STATE_REGISTER_CR0      , CPU_SAVE_STATE_GET_OFFSET(CR0)},
  95   {EFI_SMM_SAVE_STATE_REGISTER_CR3      , CPU_SAVE_STATE_GET_OFFSET(CR3)}
  96 };
  97
  98 /**
  99   Framework SMST SmmInstallConfigurationTable() Thunk.
 100
 101   This thunk calls the PI SMM SmmInstallConfigurationTable() and then update the configuration
 102   table related fields in the Framework SMST because the PI SMM SmmInstallConfigurationTable()
 103   function may modify these fields.
 104
 105   @param[in] SystemTable         A pointer to the SMM System Table.
 106   @param[in] Guid                A pointer to the GUID for the entry to add, update, or remove.
 107   @param[in] Table               A pointer to the buffer of the table to add.
 108   @param[in] TableSize           The size of the table to install.
 109
 110   @retval EFI_SUCCESS            The (Guid, Table) pair was added, updated, or removed.
 111   @retval EFI_INVALID_PARAMETER  Guid is not valid.
 112   @retval EFI_NOT_FOUND          An attempt was made to delete a non-existent entry.
 113   @retval EFI_OUT_OF_RESOURCES   There is not enough memory available to complete the operation.
 114 **/
 115 EFI_STATUS
 116 EFIAPI
 117 SmmInstallConfigurationTable (
 118   IN EFI_SMM_SYSTEM_TABLE  *SystemTable,
 119   IN EFI_GUID              *Guid,
 120   IN VOID                  *Table,
 121   IN UINTN                 TableSize
 122   )
 123 {
 124   EFI_STATUS  Status;
 125
 126   Status = gSmst->SmmInstallConfigurationTable (gSmst, Guid, Table, TableSize);
 127   if (!EFI_ERROR (Status)) {
 128     mFrameworkSmst->NumberOfTableEntries = gSmst->NumberOfTableEntries;
 129     mFrameworkSmst->SmmConfigurationTable = gSmst->SmmConfigurationTable;
 130   }
 131   return Status;
 132 }
 133
 134 /**
 135   Construct a Framework SMST based on the PI SMM SMST.
 136
 137   @return  Pointer to the constructed Framework SMST.
 138 **/
 139 EFI_SMM_SYSTEM_TABLE *
 140 ConstructFrameworkSmst (
 141   VOID
 142   )
 143 {
 144   EFI_SMM_SYSTEM_TABLE  *FrameworkSmst;
 145
 146   FrameworkSmst = (EFI_SMM_SYSTEM_TABLE  *)AllocatePool (sizeof (EFI_SMM_SYSTEM_TABLE));
 147   ASSERT (FrameworkSmst != NULL);
 148
 149   ///
 150   /// Copy same things from PI SMST to Framework SMST
 151   ///
 152   CopyMem (FrameworkSmst, gSmst, (UINTN)(&((EFI_SMM_SYSTEM_TABLE *)0)->SmmIo));
 153   CopyMem (
 154     &FrameworkSmst->SmmIo,
 155     &gSmst->SmmIo,
 156     sizeof (EFI_SMM_SYSTEM_TABLE) - (UINTN)(&((EFI_SMM_SYSTEM_TABLE *)0)->SmmIo)
 157     );
 158
 159   ///
 160   /// Update Framework SMST
 161   ///
 162   FrameworkSmst->Hdr.Revision = EFI_SMM_SYSTEM_TABLE_REVISION;
 163   CopyGuid (&FrameworkSmst->EfiSmmCpuIoGuid, &mEfiSmmCpuIoGuid);
 164
 165   FrameworkSmst->CpuSaveState = (EFI_SMM_CPU_SAVE_STATE *)AllocateZeroPool (mNumberOfProcessors * sizeof (EFI_SMM_CPU_SAVE_STATE));
 166   ASSERT (FrameworkSmst->CpuSaveState != NULL);
 167
 168   ///
 169   /// Do not support floating point state now
 170   ///
 171   FrameworkSmst->CpuOptionalFloatingPointState = NULL;
 172
 173   FrameworkSmst->SmmInstallConfigurationTable = SmmInstallConfigurationTable;
 174
 175   return FrameworkSmst;
 176 }
 177
 178 /**
 179   Load a given Framework SMM driver into SMRAM and invoke its entry point.
 180
 181   @param[in]   ParentImageHandle     Parent Image Handle.
 182   @param[in]   FilePath              Location of the image to be installed as the handler.
 183   @param[in]   SourceBuffer          Optional source buffer in case the image file
 184                                      is in memory.
 185   @param[in]   SourceSize            Size of the source image file, if in memory.
 186   @param[out]  ImageHandle           The handle that the base driver uses to decode
 187                                      the handler. Unique among SMM handlers only,
 188                                      not unique across DXE/EFI.
 189
 190   @retval      EFI_SUCCESS           The operation was successful.
 191   @retval      EFI_OUT_OF_RESOURCES  There were no additional SMRAM resources to load the handler
 192   @retval      EFI_UNSUPPORTED       Can not find its copy in normal memory.
 193   @retval      EFI_INVALID_PARAMETER The handlers was not the correct image type
 194 **/
 195 EFI_STATUS
 196 LoadImage (
 197   IN      EFI_HANDLE                ParentImageHandle,
 198   IN      EFI_DEVICE_PATH_PROTOCOL  *FilePath,
 199   IN      VOID                      *SourceBuffer,
 200   IN      UINTN                     SourceSize,
 201   OUT     EFI_HANDLE                *ImageHandle
 202   )
 203 {
 204   EFI_STATUS            Status;
 205   UINTN                 PageCount;
 206   UINTN                 OrgPageCount;
 207   EFI_PHYSICAL_ADDRESS  DstBuffer;
 208
 209   if (FilePath == NULL || ImageHandle == NULL) {
 210     return EFI_INVALID_PARAMETER;
 211   }
 212
 213   PageCount = 1;
 214   do {
 215     OrgPageCount = PageCount;
 216     DstBuffer = (UINTN)-1;
 217     Status = gSmst->SmmAllocatePages (
 218                       AllocateMaxAddress,
 219                       EfiRuntimeServicesCode,
 220                       PageCount,
 221                       &DstBuffer
 222                       );
 223     if (EFI_ERROR (Status)) {
 224       return Status;
 225     }
 226
 227     Status = mLoadPe32Image->LoadPeImage (
 228                                mLoadPe32Image,
 229                                ParentImageHandle,
 230                                FilePath,
 231                                SourceBuffer,
 232                                SourceSize,
 233                                DstBuffer,
 234                                &PageCount,
 235                                ImageHandle,
 236                                NULL,
 237                                EFI_LOAD_PE_IMAGE_ATTRIBUTE_NONE
 238                                );
 239     if (EFI_ERROR (Status)) {
 240       FreePages ((VOID *)(UINTN)DstBuffer, OrgPageCount);
 241     }
 242   } while (Status == EFI_BUFFER_TOO_SMALL);
 243
 244   if (!EFI_ERROR (Status)) {
 245     ///
 246     /// Update MP state in Framework SMST before transferring control to Framework SMM driver entry point
 247     /// in case it may invoke AP
 248     ///
 249     mFrameworkSmst->CurrentlyExecutingCpu = gSmst->CurrentlyExecutingCpu;
 250
 251     Status = gBS->StartImage (*ImageHandle, NULL, NULL);
 252     if (EFI_ERROR (Status)) {
 253       mLoadPe32Image->UnLoadPeImage (mLoadPe32Image, *ImageHandle);
 254       *ImageHandle = NULL;
 255       FreePages ((VOID *)(UINTN)DstBuffer, PageCount);
 256     }
 257   }
 258
 259   return Status;
 260 }
 261
 262
 263 /**
 264   Thunk service of EFI_SMM_BASE_PROTOCOL.Register().
 265
 266   @param[in, out] FunctionData  Pointer to SMMBASE_FUNCTION_DATA.
 267 **/
 268 VOID
 269 Register (
 270   IN OUT SMMBASE_FUNCTION_DATA *FunctionData
 271   )
 272 {
 273   EFI_STATUS Status;
 274
 275   if (FunctionData->Args.Register.LegacyIA32Binary) {
 276     Status = EFI_UNSUPPORTED;
 277   } else {
 278     Status = LoadImage (
 279                FunctionData->SmmBaseImageHandle,
 280                FunctionData->Args.Register.FilePath,
 281                FunctionData->Args.Register.SourceBuffer,
 282                FunctionData->Args.Register.SourceSize,
 283                FunctionData->Args.Register.ImageHandle
 284                );
 285   }
 286   FunctionData->Status = Status;
 287 }
 288
 289 /**
 290   Thunk service of EFI_SMM_BASE_PROTOCOL.UnRegister().
 291
 292   @param[in, out] FunctionData  Pointer to SMMBASE_FUNCTION_DATA.
 293 **/
 294 VOID
 295 UnRegister (
 296   IN OUT SMMBASE_FUNCTION_DATA *FunctionData
 297   )
 298 {
 299   ///
 300   /// Unregister not supported now
 301   ///
 302   FunctionData->Status = EFI_UNSUPPORTED;
 303 }
 304
 305 /**
 306   Search for Framework SMI handler information according to specific PI SMM dispatch handle.
 307
 308   @param[in] DispatchHandle  The unique handle assigned by SmiHandlerRegister().
 309
 310   @return  Pointer to CALLBACK_INFO. If NULL, no callback info record is found.
 311 **/
 312 CALLBACK_INFO *
 313 GetCallbackInfo (
 314   IN EFI_HANDLE  DispatchHandle
 315   )
 316 {
 317   LIST_ENTRY  *Node;
 318
 319   Node = GetFirstNode (&mCallbackInfoListHead);
 320   while (!IsNull (&mCallbackInfoListHead, Node)) {
 321     if (((CALLBACK_INFO *)Node)->DispatchHandle == DispatchHandle) {
 322       return (CALLBACK_INFO *)Node;
 323     }
 324     Node = GetNextNode (&mCallbackInfoListHead, Node);
 325   }
 326   return NULL;
 327 }
 328
 329 /**
 330   Callback thunk for Framework SMI handler.
 331
 332   This thunk functions calls the Framework SMI handler and converts the return value
 333   defined from Framework SMI handlers to a correpsonding return value defined by PI SMM.
 334
 335   @param[in]     DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 336   @param[in]     Context         Points to an optional handler context which was specified when the
 337                                  handler was registered.
 338   @param[in, out] CommBuffer      A pointer to a collection of data in memory that will
 339                                  be conveyed from a non-SMM environment into an SMM environment.
 340   @param[in, out] CommBufferSize  The size of the CommBuffer.
 341
 342   @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers
 343                                               should still be called.
 344   @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should
 345                                               still be called.
 346   @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still
 347                                               be called.
 348   @retval EFI_INTERRUPT_PENDING               The interrupt could not be quiesced.
 349 **/
 350 EFI_STATUS
 351 EFIAPI
 352 CallbackThunk (
 353   IN EFI_HANDLE  DispatchHandle,
 354   IN CONST VOID  *Context         OPTIONAL,
 355   IN OUT VOID    *CommBuffer      OPTIONAL,
 356   IN OUT UINTN   *CommBufferSize  OPTIONAL
 357   )
 358 {
 359   EFI_STATUS        Status;
 360   CALLBACK_INFO     *CallbackInfo;
 361   UINTN             Index;
 362   UINTN             CpuIndex;
 363   EFI_SMM_CPU_STATE *State;
 364   EFI_SMI_CPU_SAVE_STATE *SaveState;
 365
 366   ///
 367   /// Before transferring the control into the Framework SMI handler, update CPU Save States
 368   /// and MP states in the Framework SMST.
 369   ///
 370
 371   for (CpuIndex = 0; CpuIndex < mNumberOfProcessors; CpuIndex++) {
 372     State = (EFI_SMM_CPU_STATE *)gSmst->CpuSaveState[CpuIndex];
 373     SaveState = &mFrameworkSmst->CpuSaveState[CpuIndex].Ia32SaveState;
 374
 375     if (State->x86.SMMRevId < EFI_SMM_MIN_REV_ID_x64) {
 376       SaveState->SMBASE = State->x86.SMBASE;
 377       SaveState->SMMRevId = State->x86.SMMRevId;
 378       SaveState->IORestart = State->x86.IORestart;
 379       SaveState->AutoHALTRestart = State->x86.AutoHALTRestart;
 380     } else {
 381       SaveState->SMBASE = State->x64.SMBASE;
 382       SaveState->SMMRevId = State->x64.SMMRevId;
 383       SaveState->IORestart = State->x64.IORestart;
 384       SaveState->AutoHALTRestart = State->x64.AutoHALTRestart;
 385     }
 386
 387     for (Index = 0; Index < sizeof (mCpuSaveStateConvTable) / sizeof (CPU_SAVE_STATE_CONVERSION); Index++) {
 388       ///
 389       /// Try to use SMM CPU Protocol to access CPU save states if possible
 390       ///
 391       Status = mSmmCpu->ReadSaveState (
 392                           mSmmCpu,
 393                           (UINTN)sizeof (UINT32),
 394                           mCpuSaveStateConvTable[Index].Register,
 395                           CpuIndex,
 396                           ((UINT8 *)SaveState) + mCpuSaveStateConvTable[Index].Offset
 397                           );
 398       ASSERT_EFI_ERROR (Status);
 399     }
 400   }
 401
 402   mFrameworkSmst->SmmStartupThisAp      = gSmst->SmmStartupThisAp;
 403   mFrameworkSmst->NumberOfCpus          = mNumberOfProcessors;
 404   mFrameworkSmst->CurrentlyExecutingCpu = gSmst->CurrentlyExecutingCpu;
 405
 406   ///
 407   /// Search for Framework SMI handler information
 408   ///
 409   CallbackInfo = GetCallbackInfo (DispatchHandle);
 410   ASSERT (CallbackInfo != NULL);
 411
 412   ///
 413   /// Thunk into original Framwork SMI handler
 414   ///
 415   Status = (CallbackInfo->CallbackAddress) (
 416                             CallbackInfo->SmmImageHandle,
 417                             CallbackInfo->CommunicationBuffer,
 418                             CallbackInfo->SourceSize
 419                             );
 420   ///
 421   /// Save CPU Save States in case any of them was modified
 422   ///
 423   for (CpuIndex = 0; CpuIndex < mNumberOfProcessors; CpuIndex++) {
 424     for (Index = 0; Index < sizeof (mCpuSaveStateConvTable) / sizeof (CPU_SAVE_STATE_CONVERSION); Index++) {
 425       Status = mSmmCpu->WriteSaveState (
 426                           mSmmCpu,
 427                           (UINTN)sizeof (UINT32),
 428                           mCpuSaveStateConvTable[Index].Register,
 429                           CpuIndex,
 430                           ((UINT8 *)&mFrameworkSmst->CpuSaveState[CpuIndex].Ia32SaveState) +
 431                           mCpuSaveStateConvTable[Index].Offset
 432                           );
 433     }
 434   }
 435
 436   ///
 437   /// Conversion of returned status code
 438   ///
 439   switch (Status) {
 440     case EFI_HANDLER_SUCCESS:
 441       Status = EFI_WARN_INTERRUPT_SOURCE_QUIESCED;
 442       break;
 443     case EFI_HANDLER_CRITICAL_EXIT:
 444     case EFI_HANDLER_SOURCE_QUIESCED:
 445       Status = EFI_SUCCESS;
 446       break;
 447     case EFI_HANDLER_SOURCE_PENDING:
 448       Status = EFI_WARN_INTERRUPT_SOURCE_PENDING;
 449       break;
 450   }
 451   return Status;
 452 }
 453
 454 /**
 455   Thunk service of EFI_SMM_BASE_PROTOCOL.RegisterCallback().
 456
 457   @param[in, out] FunctionData  Pointer to SMMBASE_FUNCTION_DATA.
 458 **/
 459 VOID
 460 RegisterCallback (
 461   IN OUT SMMBASE_FUNCTION_DATA  *FunctionData
 462   )
 463 {
 464   CALLBACK_INFO  *Buffer;
 465
 466   ///
 467   /// Note that MakeLast and FloatingPointSave options are not supported in PI SMM
 468   ///
 469
 470   ///
 471   /// Allocate buffer for callback thunk information
 472   ///
 473   Buffer = (CALLBACK_INFO *)AllocateZeroPool (sizeof (CALLBACK_INFO));
 474   if (Buffer == NULL) {
 475     FunctionData->Status = EFI_OUT_OF_RESOURCES;
 476     return;
 477   }
 478
 479   ///
 480   /// Fill SmmImageHandle and CallbackAddress into the thunk
 481   ///
 482   Buffer->SmmImageHandle = FunctionData->Args.RegisterCallback.SmmImageHandle;
 483   Buffer->CallbackAddress = FunctionData->Args.RegisterCallback.CallbackAddress;
 484
 485   ///
 486   /// Register the thunk code as a root SMI handler
 487   ///
 488   FunctionData->Status = gSmst->SmiHandlerRegister (
 489                                   CallbackThunk,
 490                                   NULL,
 491                                   &Buffer->DispatchHandle
 492                                   );
 493   if (EFI_ERROR (FunctionData->Status)) {
 494     FreePool (Buffer);
 495     return;
 496   }
 497
 498   ///
 499   /// Save this callback info
 500   ///
 501   InsertTailList (&mCallbackInfoListHead, &Buffer->Link);
 502 }
 503
 504
 505 /**
 506   Thunk service of EFI_SMM_BASE_PROTOCOL.SmmAllocatePool().
 507
 508   @param[in, out] FunctionData  Pointer to SMMBASE_FUNCTION_DATA.
 509 **/
 510 VOID
 511 HelperAllocatePool (
 512   IN OUT SMMBASE_FUNCTION_DATA *FunctionData
 513   )
 514 {
 515   FunctionData->Status = gSmst->SmmAllocatePool (
 516                                   FunctionData->Args.AllocatePool.PoolType,
 517                                   FunctionData->Args.AllocatePool.Size,
 518                                   FunctionData->Args.AllocatePool.Buffer
 519                                   );
 520 }
 521
 522 /**
 523   Thunk service of EFI_SMM_BASE_PROTOCOL.SmmFreePool().
 524
 525   @param[in, out] FunctionData  Pointer to SMMBASE_FUNCTION_DATA.
 526 **/
 527 VOID
 528 HelperFreePool (
 529   IN OUT SMMBASE_FUNCTION_DATA *FunctionData
 530   )
 531 {
 532   FreePool (FunctionData->Args.FreePool.Buffer);
 533   FunctionData->Status = EFI_SUCCESS;
 534 }
 535
 536 /**
 537   Thunk service of EFI_SMM_BASE_PROTOCOL.Communicate().
 538
 539   @param[in, out] FunctionData  Pointer to SMMBASE_FUNCTION_DATA.
 540 **/
 541 VOID
 542 HelperCommunicate (
 543   IN OUT SMMBASE_FUNCTION_DATA *FunctionData
 544   )
 545 {
 546   LIST_ENTRY     *Node;
 547   CALLBACK_INFO  *CallbackInfo;
 548
 549   if (FunctionData->Args.Communicate.CommunicationBuffer == NULL) {
 550     FunctionData->Status = EFI_INVALID_PARAMETER;
 551     return;
 552   }
 553
 554   Node = GetFirstNode (&mCallbackInfoListHead);
 555   while (!IsNull (&mCallbackInfoListHead, Node)) {
 556     CallbackInfo = (CALLBACK_INFO *)Node;
 557
 558     if (FunctionData->Args.Communicate.ImageHandle == CallbackInfo->SmmImageHandle) {
 559       CallbackInfo->CommunicationBuffer = FunctionData->Args.Communicate.CommunicationBuffer;
 560       CallbackInfo->SourceSize          = FunctionData->Args.Communicate.SourceSize;
 561
 562       ///
 563       /// The message was successfully posted.
 564       ///
 565       FunctionData->Status = EFI_SUCCESS;
 566       return;
 567     }
 568     Node = GetNextNode (&mCallbackInfoListHead, Node);
 569   }
 570
 571   FunctionData->Status = EFI_INVALID_PARAMETER;
 572 }
 573
 574 /**
 575   Communication service SMI Handler entry.
 576
 577   This SMI handler provides services for the SMM Base Thunk driver.
 578
 579   @param[in]     DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 580   @param[in]     RegisterContext Points to an optional handler context which was specified when the
 581                                  handler was registered.
 582   @param[in, out] CommBuffer      A pointer to a collection of data in memory that will
 583                                  be conveyed from a non-SMM environment into an SMM environment.
 584   @param[in, out] CommBufferSize  The size of the CommBuffer.
 585
 586   @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers
 587                                               should still be called.
 588   @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should
 589                                               still be called.
 590   @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still
 591                                               be called.
 592   @retval EFI_INTERRUPT_PENDING               The interrupt could not be quiesced.
 593 **/
 594 EFI_STATUS
 595 EFIAPI
 596 SmmHandlerEntry (
 597   IN     EFI_HANDLE               DispatchHandle,
 598   IN     CONST VOID               *RegisterContext,
 599   IN OUT VOID                     *CommBuffer,
 600   IN OUT UINTN                    *CommBufferSize
 601   )
 602 {
 603   SMMBASE_FUNCTION_DATA *FunctionData;
 604
 605   ASSERT (CommBuffer != NULL);
 606   ASSERT (*CommBufferSize == sizeof (SMMBASE_FUNCTION_DATA));
 607
 608   FunctionData = (SMMBASE_FUNCTION_DATA *)CommBuffer;
 609
 610   switch (FunctionData->Function) {
 611     case SmmBaseFunctionRegister:
 612       Register (FunctionData);
 613       break;
 614     case SmmBaseFunctionUnregister:
 615       UnRegister (FunctionData);
 616       break;
 617     case SmmBaseFunctionRegisterCallback:
 618       RegisterCallback (FunctionData);
 619       break;
 620     case SmmBaseFunctionAllocatePool:
 621       HelperAllocatePool (FunctionData);
 622       break;
 623     case SmmBaseFunctionFreePool:
 624       HelperFreePool (FunctionData);
 625       break;
 626     case SmmBaseFunctionCommunicate:
 627       HelperCommunicate (FunctionData);
 628       break;
 629     default:
 630       ASSERT (FALSE);
 631       FunctionData->Status = EFI_UNSUPPORTED;
 632   }
 633   return EFI_SUCCESS;
 634 }
 635
 636 /**
 637   Entry point function of the SMM Base Helper SMM driver.
 638
 639   @param[in] ImageHandle  The firmware allocated handle for the EFI image.
 640   @param[in] SystemTable  A pointer to the EFI System Table.
 641
 642   @retval EFI_SUCCESS     The entry point is executed successfully.
 643   @retval other           Some error occurs when executing this entry point.
 644 **/
 645 EFI_STATUS
 646 EFIAPI
 647 SmmBaseHelperMain (
 648   IN EFI_HANDLE        ImageHandle,
 649   IN EFI_SYSTEM_TABLE  *SystemTable
 650   )
 651 {
 652   EFI_STATUS  Status;
 653   EFI_MP_SERVICES_PROTOCOL   *MpServices;
 654   EFI_HANDLE                 Handle;
 655   UINTN                      NumberOfEnabledProcessors;
 656
 657   Handle = NULL;
 658   ///
 659   /// Locate SMM CPU Protocol which is used later to retrieve/update CPU Save States
 660   ///
 661   Status = gSmst->SmmLocateProtocol (&gEfiSmmCpuProtocolGuid, NULL, (VOID **) &mSmmCpu);
 662   ASSERT_EFI_ERROR (Status);
 663
 664   ///
 665   /// Locate PE32 Image Protocol which is used later to load Framework SMM driver
 666   ///
 667   Status = SystemTable->BootServices->LocateProtocol (&gEfiLoadPeImageProtocolGuid, NULL, (VOID **) &mLoadPe32Image);
 668   ASSERT_EFI_ERROR (Status);
 669
 670   //
 671   // Get MP Services Protocol
 672   //
 673   Status = SystemTable->BootServices->LocateProtocol (&gEfiMpServiceProtocolGuid, NULL, (VOID **)&MpServices);
 674   ASSERT_EFI_ERROR (Status);
 675
 676   //
 677   // Use MP Services Protocol to retrieve the number of processors and number of enabled processors
 678   //
 679   Status = MpServices->GetNumberOfProcessors (MpServices, &mNumberOfProcessors, &NumberOfEnabledProcessors);
 680   ASSERT_EFI_ERROR (Status);
 681
 682   ///
 683   /// Interface structure of SMM BASE Helper Ready Protocol is allocated from UEFI pool
 684   /// instead of SMM pool so that SMM Base Thunk driver can access it in Non-SMM mode.
 685   ///
 686   Status = gBS->AllocatePool (
 687                   EfiBootServicesData,
 688                   sizeof (EFI_SMM_BASE_HELPER_READY_PROTOCOL),
 689                   (VOID **)&mSmmBaseHelperReady
 690                   );
 691   ASSERT_EFI_ERROR (Status);
 692
 693   ///
 694   /// Construct Framework SMST from PI SMST
 695   ///
 696   mFrameworkSmst = ConstructFrameworkSmst ();
 697   mSmmBaseHelperReady->FrameworkSmst = mFrameworkSmst;
 698   mSmmBaseHelperReady->ServiceEntry = SmmHandlerEntry;
 699
 700   ///
 701   /// Register SMM Base Helper services for SMM Base Thunk driver
 702   ///
 703   Status = gSmst->SmiHandlerRegister (SmmHandlerEntry, &gEfiSmmBaseThunkCommunicationGuid, &mDispatchHandle);
 704   ASSERT_EFI_ERROR (Status);
 705
 706   ///
 707   /// Install EFI SMM Base Helper Protocol in the UEFI handle database
 708   ///
 709   Status = gBS->InstallProtocolInterface (
 710                   &Handle,
 711                   &gEfiSmmBaseHelperReadyProtocolGuid,
 712                   EFI_NATIVE_INTERFACE,
 713                   mSmmBaseHelperReady
 714                   );
 715   ASSERT_EFI_ERROR (Status);
 716
 717   return Status;
 718 }
 719