MdeModulePkg/Core/PiSmmCore/PiSmmCore.c

   1 /** @file
   2   SMM Core Main Entry Point
   3
   4   Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials are licensed and made available
   6   under the terms and conditions of the BSD License which accompanies this
   7   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 "PiSmmCore.h"
  16
  17 //
  18 // Physical pointer to private structure shared between SMM IPL and the SMM Core
  19 //
  20 SMM_CORE_PRIVATE_DATA  *gSmmCorePrivate;
  21
  22 //
  23 // SMM Core global variable for SMM System Table.  Only accessed as a physical structure in SMRAM.
  24 //
  25 EFI_SMM_SYSTEM_TABLE2  gSmmCoreSmst = {
  26   {
  27     SMM_SMST_SIGNATURE,
  28     EFI_SMM_SYSTEM_TABLE2_REVISION,
  29     sizeof (gSmmCoreSmst.Hdr)
  30   },
  31   NULL,                          // SmmFirmwareVendor
  32   0,                             // SmmFirmwareRevision
  33   SmmInstallConfigurationTable,
  34   {
  35     {
  36       (EFI_SMM_CPU_IO2) SmmEfiNotAvailableYetArg5,       // SmmMemRead
  37       (EFI_SMM_CPU_IO2) SmmEfiNotAvailableYetArg5        // SmmMemWrite
  38     },
  39     {
  40       (EFI_SMM_CPU_IO2) SmmEfiNotAvailableYetArg5,       // SmmIoRead
  41       (EFI_SMM_CPU_IO2) SmmEfiNotAvailableYetArg5        // SmmIoWrite
  42     }
  43   },
  44   SmmAllocatePool,
  45   SmmFreePool,
  46   SmmAllocatePages,
  47   SmmFreePages,
  48   NULL,                          // SmmStartupThisAp
  49   0,                             // CurrentlyExecutingCpu
  50   0,                             // NumberOfCpus
  51   NULL,                          // CpuSaveStateSize
  52   NULL,                          // CpuSaveState
  53   0,                             // NumberOfTableEntries
  54   NULL,                          // SmmConfigurationTable
  55   SmmInstallProtocolInterface,
  56   SmmUninstallProtocolInterface,
  57   SmmHandleProtocol,
  58   SmmRegisterProtocolNotify,
  59   SmmLocateHandle,
  60   SmmLocateProtocol,
  61   SmiManage,
  62   SmiHandlerRegister,
  63   SmiHandlerUnRegister
  64 };
  65
  66 //
  67 // Flag to determine if the platform has performed a legacy boot.
  68 // If this flag is TRUE, then the runtime code and runtime data associated with the
  69 // SMM IPL are converted to free memory, so the SMM COre must guarantee that is
  70 // does not touch of the code/data associated with the SMM IPL if this flag is TRUE.
  71 //
  72 BOOLEAN  mInLegacyBoot = FALSE;
  73
  74 //
  75 // Table of SMI Handlers that are registered by the SMM Core when it is initialized
  76 //
  77 SMM_CORE_SMI_HANDLERS  mSmmCoreSmiHandlers[] = {
  78   { SmmDriverDispatchHandler, &gEfiEventDxeDispatchGuid,          NULL, TRUE  },
  79   { SmmReadyToLockHandler,    &gEfiDxeSmmReadyToLockProtocolGuid, NULL, TRUE },
  80   { SmmLegacyBootHandler,     &gEfiEventLegacyBootGuid,           NULL, FALSE },
  81   { NULL,                     NULL,                               NULL, FALSE }
  82 };
  83
  84 /**
  85   Place holder function until all the SMM System Table Service are available.
  86
  87   Note: This function is only used by SMRAM invocation.  It is never used by DXE invocation.
  88
  89   @param  Arg1                   Undefined
  90   @param  Arg2                   Undefined
  91   @param  Arg3                   Undefined
  92   @param  Arg4                   Undefined
  93   @param  Arg5                   Undefined
  94
  95   @return EFI_NOT_AVAILABLE_YET
  96
  97 **/
  98 EFI_STATUS
  99 EFIAPI
 100 SmmEfiNotAvailableYetArg5 (
 101   UINTN Arg1,
 102   UINTN Arg2,
 103   UINTN Arg3,
 104   UINTN Arg4,
 105   UINTN Arg5
 106   )
 107 {
 108   //
 109   // This function should never be executed.  If it does, then the architectural protocols
 110   // have not been designed correctly.
 111   //
 112   return EFI_NOT_AVAILABLE_YET;
 113 }
 114
 115 /**
 116   Software SMI handler that is called when a Legacy Boot event is signalled.  The SMM
 117   Core uses this signal to know that a Legacy Boot has been performed and that
 118   gSmmCorePrivate that is shared between the UEFI and SMM execution environments can
 119   not be accessed from SMM anymore since that structure is considered free memory by
 120   a legacy OS.
 121
 122   @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 123   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 124   @param  CommBuffer      A pointer to a collection of data in memory that will
 125                           be conveyed from a non-SMM environment into an SMM environment.
 126   @param  CommBufferSize  The size of the CommBuffer.
 127
 128   @return Status Code
 129
 130 **/
 131 EFI_STATUS
 132 EFIAPI
 133 SmmLegacyBootHandler (
 134   IN     EFI_HANDLE  DispatchHandle,
 135   IN     CONST VOID  *Context,        OPTIONAL
 136   IN OUT VOID        *CommBuffer,     OPTIONAL
 137   IN OUT UINTN       *CommBufferSize  OPTIONAL
 138   )
 139 {
 140   mInLegacyBoot = TRUE;
 141   return EFI_SUCCESS;
 142 }
 143
 144 /**
 145   Software SMI handler that is called when the DxeSmmReadyToLock protocol is added
 146   or if gEfiEventReadyToBootGuid is signalled.  This function unregisters the
 147   Software SMIs that are nor required after SMRAM is locked and installs the
 148   SMM Ready To Lock Protocol so SMM Drivers are informed that SMRAM is about
 149   to be locked.  It also verifies the the SMM CPU I/O 2 Protocol has been installed
 150   and NULLs gBS and gST because they can not longer be used after SMRAM is locked.
 151
 152   @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 153   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 154   @param  CommBuffer      A pointer to a collection of data in memory that will
 155                           be conveyed from a non-SMM environment into an SMM environment.
 156   @param  CommBufferSize  The size of the CommBuffer.
 157
 158   @return Status Code
 159
 160 **/
 161 EFI_STATUS
 162 EFIAPI
 163 SmmReadyToLockHandler (
 164   IN     EFI_HANDLE  DispatchHandle,
 165   IN     CONST VOID  *Context,        OPTIONAL
 166   IN OUT VOID        *CommBuffer,     OPTIONAL
 167   IN OUT UINTN       *CommBufferSize  OPTIONAL
 168   )
 169 {
 170   EFI_STATUS  Status;
 171   UINTN       Index;
 172   EFI_HANDLE  SmmHandle;
 173   VOID        *Interface;
 174
 175   //
 176   // Unregister SMI Handlers that are no required after the SMM driver dispatch is stopped
 177   //
 178   for (Index = 0; mSmmCoreSmiHandlers[Index].HandlerType != NULL; Index++) {
 179     if (mSmmCoreSmiHandlers[Index].UnRegister) {
 180       SmiHandlerUnRegister (mSmmCoreSmiHandlers[Index].DispatchHandle);
 181     }
 182   }
 183
 184   //
 185   // Install SMM Ready to lock protocol
 186   //
 187   SmmHandle = NULL;
 188   Status = SmmInstallProtocolInterface (
 189              &SmmHandle,
 190              &gEfiSmmReadyToLockProtocolGuid,
 191              EFI_NATIVE_INTERFACE,
 192              NULL
 193              );
 194
 195   //
 196   // Make sure SMM CPU I/O 2 Procol has been installed into the handle database
 197   //
 198   Status = SmmLocateProtocol (&gEfiSmmCpuIo2ProtocolGuid, NULL, &Interface);
 199
 200   //
 201   // Print a message on a debug build if the SMM CPU I/O 2 Protocol is not installed
 202   //
 203   DEBUG_CODE_BEGIN ();
 204     if (EFI_ERROR (Status)) {
 205       DEBUG ((DEBUG_ERROR, "\nSMM: SmmCpuIo Arch Protocol not present!!\n"));
 206     }
 207   DEBUG_CODE_END ();
 208
 209   //
 210   // Assert if the CPU I/O 2 Protocol is not installed
 211   //
 212   ASSERT_EFI_ERROR (Status);
 213
 214   //
 215   // Display any drivers that were not dispatched because dependency expression
 216   // evaluated to false if this is a debug build
 217   //
 218   DEBUG_CODE_BEGIN ();
 219     SmmDisplayDiscoveredNotDispatched ();
 220   DEBUG_CODE_END ();
 221
 222   //
 223   // Not allowed to use gST or gBS after lock
 224   //
 225   gST = NULL;
 226   gBS = NULL;
 227
 228   return Status;
 229 }
 230
 231 /**
 232   The main entry point to SMM Foundation.
 233
 234   Note: This function is only used by SMRAM invocation.  It is never used by DXE invocation.
 235
 236   @param  SmmEntryContext           Processor information and functionality
 237                                     needed by SMM Foundation.
 238
 239 **/
 240 VOID
 241 EFIAPI
 242 SmmEntryPoint (
 243   IN CONST EFI_SMM_ENTRY_CONTEXT  *SmmEntryContext
 244 )
 245 {
 246   EFI_STATUS                  Status;
 247   EFI_SMM_COMMUNICATE_HEADER  *CommunicateHeader;
 248
 249   PERF_START (NULL, "SMM", NULL, 0) ;
 250
 251   //
 252   // Update SMST using the context
 253   //
 254   CopyMem (&gSmmCoreSmst.SmmStartupThisAp, SmmEntryContext, sizeof (EFI_SMM_ENTRY_CONTEXT));
 255
 256   //
 257   // Call platform hook before Smm Dispatch
 258   //
 259   PlatformHookBeforeSmmDispatch ();
 260
 261   //
 262   // If a legacy boot has occured, then make sure gSmmCorePrivate is not accessed
 263   //
 264   if (!mInLegacyBoot) {
 265     //
 266     // Mark the InSmm flag as TRUE, it will be used by SmmBase2 protocol
 267     //
 268     gSmmCorePrivate->InSmm = TRUE;
 269
 270     //
 271     // Check to see if this is a Synchronous SMI sent through the SMM Communication
 272     // Protocol or an Asynchronous SMI
 273     //
 274     if (gSmmCorePrivate->CommunicationBuffer != NULL) {
 275       //
 276       // Synchronous SMI for SMM Core or request from Communicate protocol
 277       //
 278       CommunicateHeader = (EFI_SMM_COMMUNICATE_HEADER *)gSmmCorePrivate->CommunicationBuffer;
 279       gSmmCorePrivate->BufferSize -= OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data);
 280       Status = SmiManage (
 281                  &CommunicateHeader->HeaderGuid,
 282                  NULL,
 283                  CommunicateHeader->Data,
 284                  &gSmmCorePrivate->BufferSize
 285                  );
 286
 287       //
 288       // Update CommunicationBuffer, BufferSize and ReturnStatus
 289       // Communicate service finished, reset the pointer to CommBuffer to NULL
 290       //
 291       gSmmCorePrivate->BufferSize += OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data);
 292       gSmmCorePrivate->CommunicationBuffer = NULL;
 293       gSmmCorePrivate->ReturnStatus = (Status == EFI_SUCCESS) ? EFI_SUCCESS : EFI_NOT_FOUND;
 294     }
 295   }
 296
 297   //
 298   // Process Asynchronous SMI sources
 299   //
 300   SmiManage (NULL, NULL, NULL, NULL);
 301
 302   //
 303   // Call platform hook after Smm Dispatch
 304   //
 305   PlatformHookAfterSmmDispatch ();
 306
 307   //
 308   // If a legacy boot has occured, then make sure gSmmCorePrivate is not accessed
 309   //
 310   if (!mInLegacyBoot) {
 311     //
 312     // Clear the InSmm flag as we are going to leave SMM
 313     //
 314     gSmmCorePrivate->InSmm = FALSE;
 315   }
 316
 317   PERF_END (NULL, "SMM", NULL, 0) ;
 318 }
 319
 320 /**
 321   The Entry Point for SMM Core
 322
 323   Install DXE Protocols and reload SMM Core into SMRAM and register SMM Core
 324   EntryPoint on the SMI vector.
 325
 326   Note: This function is called for both DXE invocation and SMRAM invocation.
 327
 328   @param  ImageHandle    The firmware allocated handle for the EFI image.
 329   @param  SystemTable    A pointer to the EFI System Table.
 330
 331   @retval EFI_SUCCESS    The entry point is executed successfully.
 332   @retval Other          Some error occurred when executing this entry point.
 333
 334 **/
 335 EFI_STATUS
 336 EFIAPI
 337 SmmMain (
 338   IN EFI_HANDLE        ImageHandle,
 339   IN EFI_SYSTEM_TABLE  *SystemTable
 340   )
 341 {
 342   EFI_STATUS  Status;
 343   UINTN       Index;
 344
 345   //
 346   // Get SMM Core Private context passed in from SMM IPL in ImageHandle.
 347   //
 348   gSmmCorePrivate = (SMM_CORE_PRIVATE_DATA *)ImageHandle;
 349
 350   //
 351   // Fill in SMRAM physical address for the SMM Services Table and the SMM Entry Point.
 352   //
 353   gSmmCorePrivate->Smst          = &gSmmCoreSmst;
 354   gSmmCorePrivate->SmmEntryPoint = SmmEntryPoint;
 355
 356   //
 357   // Initialize memory service using free SMRAM
 358   //
 359   SmmInitializeMemoryServices (gSmmCorePrivate->SmramRangeCount, gSmmCorePrivate->SmramRanges);
 360
 361   //
 362   // Register all SMI Handlers required by the SMM Core
 363   //
 364   for (Index = 0; mSmmCoreSmiHandlers[Index].HandlerType != NULL; Index++) {
 365     Status = SmiHandlerRegister (
 366                mSmmCoreSmiHandlers[Index].Handler,
 367                mSmmCoreSmiHandlers[Index].HandlerType,
 368                &mSmmCoreSmiHandlers[Index].DispatchHandle
 369                );
 370     ASSERT_EFI_ERROR (Status);
 371   }
 372
 373   return EFI_SUCCESS;
 374 }