[mirror_edk2.git] / MdeModulePkg / Universal / EbcDxe / EbcInt.c

/** @file\r
  Top level module for the EBC virtual machine implementation.\r
  Provides auxiliary support routines for the VM. That is, routines\r
  that are not particularly related to VM execution of EBC instructions.\r
\r
Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "EbcInt.h"\r
#include "EbcExecute.h"\r
#include "EbcDebuggerHook.h"\r
\r
//\r
// We'll keep track of all thunks we create in a linked list. Each\r
// thunk is tied to an image handle, so we have a linked list of\r
// image handles, with each having a linked list of thunks allocated\r
// to that image handle.\r
//\r
typedef struct _EBC_THUNK_LIST EBC_THUNK_LIST;\r
struct _EBC_THUNK_LIST {\r
  VOID              *ThunkBuffer;\r
  EBC_THUNK_LIST    *Next;\r
};\r
\r
typedef struct _EBC_IMAGE_LIST EBC_IMAGE_LIST;\r
struct _EBC_IMAGE_LIST {\r
  EBC_IMAGE_LIST    *Next;\r
  EFI_HANDLE        ImageHandle;\r
  EBC_THUNK_LIST    *ThunkList;\r
};\r
\r
/**\r
  This routine is called by the core when an image is being unloaded from\r
  memory. Basically we now have the opportunity to do any necessary cleanup.\r
  Typically this will include freeing any memory allocated for thunk-creation.\r
\r
  @param  This                  A pointer to the EFI_EBC_PROTOCOL instance.\r
  @param  ImageHandle           Handle of image for which the thunk is being\r
                                created.\r
\r
  @retval EFI_INVALID_PARAMETER The ImageHandle passed in was not found in the\r
                                internal list of EBC image handles.\r
  @retval EFI_SUCCESS           The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcUnloadImage (\r
  IN EFI_EBC_PROTOCOL  *This,\r
  IN EFI_HANDLE        ImageHandle\r
  );\r
\r
/**\r
  This is the top-level routine plugged into the EBC protocol. Since thunks\r
  are very processor-specific, from here we dispatch directly to the very\r
  processor-specific routine EbcCreateThunks().\r
\r
  @param  This                  A pointer to the EFI_EBC_PROTOCOL instance.\r
  @param  ImageHandle           Handle of image for which the thunk is being\r
                                created. The EBC interpreter may use this to\r
                                keep track of any resource allocations\r
                                performed in loading and executing the image.\r
  @param  EbcEntryPoint         Address of the actual EBC entry point or\r
                                protocol service the thunk should call.\r
  @param  Thunk                 Returned pointer to a thunk created.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_INVALID_PARAMETER Image entry point is not 2-byte aligned.\r
  @retval EFI_OUT_OF_RESOURCES  Memory could not be allocated for the thunk.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcCreateThunk (\r
  IN EFI_EBC_PROTOCOL  *This,\r
  IN EFI_HANDLE        ImageHandle,\r
  IN VOID              *EbcEntryPoint,\r
  OUT VOID             **Thunk\r
  );\r
\r
/**\r
  Called to get the version of the interpreter.\r
\r
  @param  This                  A pointer to the EFI_EBC_PROTOCOL instance.\r
  @param  Version               Pointer to where to store the returned version\r
                                of the interpreter.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_INVALID_PARAMETER Version pointer is NULL.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcGetVersion (\r
  IN EFI_EBC_PROTOCOL  *This,\r
  IN OUT UINT64        *Version\r
  );\r
\r
/**\r
  To install default Callback function for the VM interpreter.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval Others                Some error occurs when creating periodic event.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
InitializeEbcCallback (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This\r
  );\r
\r
/**\r
  The default Exception Callback for the VM interpreter.\r
  In this function, we report status code, and print debug information\r
  about EBC_CONTEXT, then dead loop.\r
\r
  @param  InterruptType          Interrupt type.\r
  @param  SystemContext          EBC system context.\r
\r
**/\r
VOID\r
EFIAPI\r
CommonEbcExceptionHandler (\r
  IN EFI_EXCEPTION_TYPE  InterruptType,\r
  IN EFI_SYSTEM_CONTEXT  SystemContext\r
  );\r
\r
/**\r
  The periodic callback function for EBC VM interpreter, which is used\r
  to support the EFI debug support protocol.\r
\r
  @param  Event                  The Periodic Callback Event.\r
  @param  Context                It should be the address of VM_CONTEXT pointer.\r
\r
**/\r
VOID\r
EFIAPI\r
EbcPeriodicNotifyFunction (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  );\r
\r
/**\r
  The VM interpreter calls this function on a periodic basis to support\r
  the EFI debug support protocol.\r
\r
  @param  VmPtr                  Pointer to a VM context for passing info to the\r
                                 debugger.\r
\r
  @retval EFI_SUCCESS            The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugPeriodic (\r
  IN VM_CONTEXT  *VmPtr\r
  );\r
\r
//\r
// These two functions and the  GUID are used to produce an EBC test protocol.\r
// This functionality is definitely not required for execution.\r
//\r
\r
/**\r
  Produces an EBC VM test protocol that can be used for regression tests.\r
\r
  @param  IHandle                Handle on which to install the protocol.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Memory allocation failed.\r
  @retval EFI_SUCCESS            The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
InitEbcVmTestProtocol (\r
  IN EFI_HANDLE  *IHandle\r
  );\r
\r
/**\r
  Returns the EFI_UNSUPPORTED Status.\r
\r
  @return EFI_UNSUPPORTED  This function always return EFI_UNSUPPORTED status.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcVmTestUnsupported (\r
  VOID\r
  );\r
\r
/**\r
  Registers a callback function that the EBC interpreter calls to flush the\r
  processor instruction cache following creation of thunks.\r
\r
  @param  This        A pointer to the EFI_EBC_PROTOCOL instance.\r
  @param  Flush       Pointer to a function of type EBC_ICACH_FLUSH.\r
\r
  @retval EFI_SUCCESS The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcRegisterICacheFlush (\r
  IN EFI_EBC_PROTOCOL  *This,\r
  IN EBC_ICACHE_FLUSH  Flush\r
  );\r
\r
/**\r
  This EBC debugger protocol service is called by the debug agent\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
  @param  MaxProcessorIndex     Pointer to a caller-allocated UINTN in which the\r
                                maximum supported processor index is returned.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugGetMaximumProcessorIndex (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,\r
  OUT UINTN                      *MaxProcessorIndex\r
  );\r
\r
/**\r
  This protocol service is called by the debug agent to register a function\r
  for us to call on a periodic basis.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
  @param  ProcessorIndex        Specifies which processor the callback function\r
                                applies to.\r
  @param  PeriodicCallback      A pointer to a function of type\r
                                PERIODIC_CALLBACK that is the main periodic\r
                                entry point of the debug agent. It receives as a\r
                                parameter a pointer to the full context of the\r
                                interrupted execution thread.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a\r
                                callback function was previously registered.\r
  @retval EFI_INVALID_PARAMETER Null PeriodicCallback parameter when no\r
                                callback function was previously registered.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugRegisterPeriodicCallback (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,\r
  IN UINTN                       ProcessorIndex,\r
  IN EFI_PERIODIC_CALLBACK       PeriodicCallback\r
  );\r
\r
/**\r
  This protocol service is called by the debug agent to register a function\r
  for us to call when we detect an exception.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
  @param  ProcessorIndex        Specifies which processor the callback function\r
                                applies to.\r
  @param  ExceptionCallback     A pointer to a function of type\r
                                EXCEPTION_CALLBACK that is called when the\r
                                processor exception specified by ExceptionType\r
                                occurs. Passing NULL unregisters any previously\r
                                registered function associated with\r
                                ExceptionType.\r
  @param  ExceptionType         Specifies which processor exception to hook.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_ALREADY_STARTED   Non-NULL ExceptionCallback parameter when a\r
                                callback function was previously registered.\r
  @retval EFI_INVALID_PARAMETER ExceptionType parameter is negative or exceeds\r
                                MAX_EBC_EXCEPTION.\r
  @retval EFI_INVALID_PARAMETER Null ExceptionCallback parameter when no\r
                                callback function was previously registered.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugRegisterExceptionCallback (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,\r
  IN UINTN                       ProcessorIndex,\r
  IN EFI_EXCEPTION_CALLBACK      ExceptionCallback,\r
  IN EFI_EXCEPTION_TYPE          ExceptionType\r
  );\r
\r
/**\r
  This EBC debugger protocol service is called by the debug agent.  Required\r
  for DebugSupport compliance but is only stubbed out for EBC.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
  @param  ProcessorIndex        Specifies which processor the callback function\r
                                applies to.\r
  @param  Start                 StartSpecifies the physical base of the memory\r
                                range to be invalidated.\r
  @param  Length                Specifies the minimum number of bytes in the\r
                                processor's instruction cache to invalidate.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugInvalidateInstructionCache (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,\r
  IN UINTN                       ProcessorIndex,\r
  IN VOID                        *Start,\r
  IN UINT64                      Length\r
  );\r
\r
//\r
// We have one linked list of image handles for the whole world. Since\r
// there should only be one interpreter, make them global. They must\r
// also be global since the execution of an EBC image does not provide\r
// a This pointer.\r
//\r
EBC_IMAGE_LIST  *mEbcImageList = NULL;\r
\r
//\r
// Callback function to flush the icache after thunk creation\r
//\r
EBC_ICACHE_FLUSH  mEbcICacheFlush;\r
\r
//\r
// These get set via calls by the debug agent\r
//\r
EFI_PERIODIC_CALLBACK   mDebugPeriodicCallback                         = NULL;\r
EFI_EXCEPTION_CALLBACK  mDebugExceptionCallback[MAX_EBC_EXCEPTION + 1] = { NULL };\r
\r
VOID        *mStackBuffer[MAX_STACK_NUM];\r
EFI_HANDLE  mStackBufferIndex[MAX_STACK_NUM];\r
UINTN       mStackNum = 0;\r
\r
//\r
// Event for Periodic callback\r
//\r
EFI_EVENT   mEbcPeriodicEvent;\r
VM_CONTEXT  *mVmPtr = NULL;\r
\r
/**\r
  Check whether the emulator supports executing a certain PE/COFF image\r
\r
  @param[in] This         This pointer for EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL\r
                          structure\r
  @param[in] ImageType    Whether the image is an application, a boot time\r
                          driver or a runtime driver.\r
  @param[in] DevicePath   Path to device where the image originated\r
                          (e.g., a PCI option ROM)\r
\r
  @retval TRUE            The image is supported by the emulator\r
  @retval FALSE           The image is not supported by the emulator.\r
**/\r
BOOLEAN\r
EFIAPI\r
EbcIsImageSupported (\r
  IN  EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL  *This,\r
  IN  UINT16                                ImageType,\r
  IN  EFI_DEVICE_PATH_PROTOCOL              *DevicePath   OPTIONAL\r
  )\r
{\r
  if ((ImageType != EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) &&\r
      (ImageType != EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER))\r
  {\r
    return FALSE;\r
  }\r
\r
  return TRUE;\r
}\r
\r
/**\r
  Register a supported PE/COFF image with the emulator. After this call\r
  completes successfully, the PE/COFF image may be started as usual, and\r
  it is the responsibility of the emulator implementation that any branch\r
  into the code section of the image (including returns from functions called\r
  from the foreign code) is executed as if it were running on the machine\r
  type it was built for.\r
\r
  @param[in]      This          This pointer for\r
                                EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL structure\r
  @param[in]      ImageBase     The base address in memory of the PE/COFF image\r
  @param[in]      ImageSize     The size in memory of the PE/COFF image\r
  @param[in,out]  EntryPoint    The entry point of the PE/COFF image. Passed by\r
                                reference so that the emulator may modify it.\r
\r
  @retval EFI_SUCCESS           The image was registered with the emulator and\r
                                can be started as usual.\r
  @retval other                 The image could not be registered.\r
\r
  If the PE/COFF machine type or image type are not supported by the emulator,\r
  then ASSERT().\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcRegisterImage (\r
  IN      EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL  *This,\r
  IN      EFI_PHYSICAL_ADDRESS                  ImageBase,\r
  IN      UINT64                                ImageSize,\r
  IN  OUT EFI_IMAGE_ENTRY_POINT                 *EntryPoint\r
  )\r
{\r
  DEBUG_CODE_BEGIN ();\r
  PE_COFF_LOADER_IMAGE_CONTEXT  ImageContext;\r
  EFI_STATUS                    Status;\r
\r
  ZeroMem (&ImageContext, sizeof (ImageContext));\r
\r
  ImageContext.Handle    = (VOID *)(UINTN)ImageBase;\r
  ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;\r
\r
  Status = PeCoffLoaderGetImageInfo (&ImageContext);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  ASSERT (ImageContext.Machine == EFI_IMAGE_MACHINE_EBC);\r
  ASSERT (\r
    ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION ||\r
    ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER\r
    );\r
  DEBUG_CODE_END ();\r
\r
  EbcRegisterICacheFlush (\r
    NULL,\r
    (EBC_ICACHE_FLUSH)InvalidateInstructionCacheRange\r
    );\r
\r
  return EbcCreateThunk (\r
           NULL,\r
           (VOID *)(UINTN)ImageBase,\r
           (VOID *)(UINTN)*EntryPoint,\r
           (VOID **)EntryPoint\r
           );\r
}\r
\r
/**\r
  Unregister a PE/COFF image that has been registered with the emulator.\r
  This should be done before the image is unloaded from memory.\r
\r
  @param[in] This         This pointer for EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL\r
                          structure\r
  @param[in] ImageBase    The base address in memory of the PE/COFF image\r
\r
  @retval EFI_SUCCESS     The image was unregistered with the emulator.\r
  @retval other           Image could not be unloaded.\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcUnregisterImage (\r
  IN  EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL  *This,\r
  IN  EFI_PHYSICAL_ADDRESS                  ImageBase\r
  )\r
{\r
  return EbcUnloadImage (NULL, (VOID *)(UINTN)ImageBase);\r
}\r
\r
STATIC EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL  mPeCoffEmuProtocol = {\r
  EbcIsImageSupported,\r
  EbcRegisterImage,\r
  EbcUnregisterImage,\r
  EDKII_PECOFF_IMAGE_EMULATOR_VERSION,\r
  EFI_IMAGE_MACHINE_EBC\r
};\r
\r
/**\r
  Initializes the VM EFI interface.  Allocates memory for the VM interface\r
  and registers the VM protocol.\r
\r
  @param  ImageHandle            EFI image handle.\r
  @param  SystemTable            Pointer to the EFI system table.\r
\r
  @return Standard EFI status code.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
InitializeEbcDriver (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  EFI_EBC_PROTOCOL            *EbcProtocol;\r
  EFI_EBC_PROTOCOL            *OldEbcProtocol;\r
  EFI_STATUS                  Status;\r
  EFI_DEBUG_SUPPORT_PROTOCOL  *EbcDebugProtocol;\r
  EFI_HANDLE                  *HandleBuffer;\r
  UINTN                       NumHandles;\r
  UINTN                       Index;\r
  BOOLEAN                     Installed;\r
\r
  EbcProtocol      = NULL;\r
  EbcDebugProtocol = NULL;\r
\r
  //\r
  // Allocate memory for our protocol. Then fill in the blanks.\r
  //\r
  EbcProtocol = AllocatePool (sizeof (EFI_EBC_PROTOCOL));\r
\r
  if (EbcProtocol == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  EbcProtocol->CreateThunk         = EbcCreateThunk;\r
  EbcProtocol->UnloadImage         = EbcUnloadImage;\r
  EbcProtocol->RegisterICacheFlush = EbcRegisterICacheFlush;\r
  EbcProtocol->GetVersion          = EbcGetVersion;\r
  mEbcICacheFlush                  = NULL;\r
\r
  //\r
  // Find any already-installed EBC protocols and uninstall them\r
  //\r
  Installed    = FALSE;\r
  HandleBuffer = NULL;\r
  Status       = gBS->LocateHandleBuffer (\r
                        ByProtocol,\r
                        &gEfiEbcProtocolGuid,\r
                        NULL,\r
                        &NumHandles,\r
                        &HandleBuffer\r
                        );\r
  if (Status == EFI_SUCCESS) {\r
    //\r
    // Loop through the handles\r
    //\r
    for (Index = 0; Index < NumHandles; Index++) {\r
      Status = gBS->HandleProtocol (\r
                      HandleBuffer[Index],\r
                      &gEfiEbcProtocolGuid,\r
                      (VOID **)&OldEbcProtocol\r
                      );\r
      if (Status == EFI_SUCCESS) {\r
        if (gBS->ReinstallProtocolInterface (\r
                   HandleBuffer[Index],\r
                   &gEfiEbcProtocolGuid,\r
                   OldEbcProtocol,\r
                   EbcProtocol\r
                   ) == EFI_SUCCESS)\r
        {\r
          Installed = TRUE;\r
        }\r
      }\r
    }\r
  }\r
\r
  if (HandleBuffer != NULL) {\r
    FreePool (HandleBuffer);\r
    HandleBuffer = NULL;\r
  }\r
\r
  //\r
  // Add the protocol so someone can locate us if we haven't already.\r
  //\r
  if (!Installed) {\r
    Status = gBS->InstallMultipleProtocolInterfaces (\r
                    &ImageHandle,\r
                    &gEfiEbcProtocolGuid,\r
                    EbcProtocol,\r
                    &gEdkiiPeCoffImageEmulatorProtocolGuid,\r
                    &mPeCoffEmuProtocol,\r
                    NULL\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (EbcProtocol);\r
      return Status;\r
    }\r
  }\r
\r
  Status = InitEBCStack ();\r
  if (EFI_ERROR (Status)) {\r
    goto ErrorExit;\r
  }\r
\r
  //\r
  // Allocate memory for our debug protocol. Then fill in the blanks.\r
  //\r
  EbcDebugProtocol = AllocatePool (sizeof (EFI_DEBUG_SUPPORT_PROTOCOL));\r
\r
  if (EbcDebugProtocol == NULL) {\r
    goto ErrorExit;\r
  }\r
\r
  EbcDebugProtocol->Isa                        = IsaEbc;\r
  EbcDebugProtocol->GetMaximumProcessorIndex   = EbcDebugGetMaximumProcessorIndex;\r
  EbcDebugProtocol->RegisterPeriodicCallback   = EbcDebugRegisterPeriodicCallback;\r
  EbcDebugProtocol->RegisterExceptionCallback  = EbcDebugRegisterExceptionCallback;\r
  EbcDebugProtocol->InvalidateInstructionCache = EbcDebugInvalidateInstructionCache;\r
\r
  //\r
  // Add the protocol so the debug agent can find us\r
  //\r
  Status = gBS->InstallProtocolInterface (\r
                  &ImageHandle,\r
                  &gEfiDebugSupportProtocolGuid,\r
                  EFI_NATIVE_INTERFACE,\r
                  EbcDebugProtocol\r
                  );\r
  //\r
  // This is recoverable, so free the memory and continue.\r
  //\r
  if (EFI_ERROR (Status)) {\r
    FreePool (EbcDebugProtocol);\r
    goto ErrorExit;\r
  }\r
\r
  //\r
  // Install EbcDebugSupport Protocol Successfully\r
  // Now we need to initialize the Ebc default Callback\r
  //\r
  Status = InitializeEbcCallback (EbcDebugProtocol);\r
\r
  //\r
  // Produce a VM test interface protocol. Not required for execution.\r
  //\r
  DEBUG_CODE_BEGIN ();\r
  InitEbcVmTestProtocol (&ImageHandle);\r
  DEBUG_CODE_END ();\r
\r
  EbcDebuggerHookInit (ImageHandle, EbcDebugProtocol);\r
\r
  return EFI_SUCCESS;\r
\r
ErrorExit:\r
  FreeEBCStack ();\r
  HandleBuffer = NULL;\r
  Status       = gBS->LocateHandleBuffer (\r
                        ByProtocol,\r
                        &gEfiEbcProtocolGuid,\r
                        NULL,\r
                        &NumHandles,\r
                        &HandleBuffer\r
                        );\r
  if (Status == EFI_SUCCESS) {\r
    //\r
    // Loop through the handles\r
    //\r
    for (Index = 0; Index < NumHandles; Index++) {\r
      Status = gBS->HandleProtocol (\r
                      HandleBuffer[Index],\r
                      &gEfiEbcProtocolGuid,\r
                      (VOID **)&OldEbcProtocol\r
                      );\r
      if (Status == EFI_SUCCESS) {\r
        gBS->UninstallProtocolInterface (\r
               HandleBuffer[Index],\r
               &gEfiEbcProtocolGuid,\r
               OldEbcProtocol\r
               );\r
      }\r
    }\r
  }\r
\r
  if (HandleBuffer != NULL) {\r
    FreePool (HandleBuffer);\r
    HandleBuffer = NULL;\r
  }\r
\r
  FreePool (EbcProtocol);\r
\r
  return Status;\r
}\r
\r
/**\r
  This is the top-level routine plugged into the EBC protocol. Since thunks\r
  are very processor-specific, from here we dispatch directly to the very\r
  processor-specific routine EbcCreateThunks().\r
\r
  @param  This                  A pointer to the EFI_EBC_PROTOCOL instance.\r
  @param  ImageHandle           Handle of image for which the thunk is being\r
                                created. The EBC interpreter may use this to\r
                                keep track of any resource allocations\r
                                performed in loading and executing the image.\r
  @param  EbcEntryPoint         Address of the actual EBC entry point or\r
                                protocol service the thunk should call.\r
  @param  Thunk                 Returned pointer to a thunk created.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_INVALID_PARAMETER Image entry point is not 2-byte aligned.\r
  @retval EFI_OUT_OF_RESOURCES  Memory could not be allocated for the thunk.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcCreateThunk (\r
  IN EFI_EBC_PROTOCOL  *This,\r
  IN EFI_HANDLE        ImageHandle,\r
  IN VOID              *EbcEntryPoint,\r
  OUT VOID             **Thunk\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = EbcCreateThunks (\r
             ImageHandle,\r
             EbcEntryPoint,\r
             Thunk,\r
             FLAG_THUNK_ENTRY_POINT\r
             );\r
  return Status;\r
}\r
\r
/**\r
  This EBC debugger protocol service is called by the debug agent\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
  @param  MaxProcessorIndex     Pointer to a caller-allocated UINTN in which the\r
                                maximum supported processor index is returned.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugGetMaximumProcessorIndex (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,\r
  OUT UINTN                      *MaxProcessorIndex\r
  )\r
{\r
  *MaxProcessorIndex = 0;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This protocol service is called by the debug agent to register a function\r
  for us to call on a periodic basis.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
  @param  ProcessorIndex        Specifies which processor the callback function\r
                                applies to.\r
  @param  PeriodicCallback      A pointer to a function of type\r
                                PERIODIC_CALLBACK that is the main periodic\r
                                entry point of the debug agent. It receives as a\r
                                parameter a pointer to the full context of the\r
                                interrupted execution thread.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a\r
                                callback function was previously registered.\r
  @retval EFI_INVALID_PARAMETER Null PeriodicCallback parameter when no\r
                                callback function was previously registered.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugRegisterPeriodicCallback (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,\r
  IN UINTN                       ProcessorIndex,\r
  IN EFI_PERIODIC_CALLBACK       PeriodicCallback\r
  )\r
{\r
  if ((mDebugPeriodicCallback == NULL) && (PeriodicCallback == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((mDebugPeriodicCallback != NULL) && (PeriodicCallback != NULL)) {\r
    return EFI_ALREADY_STARTED;\r
  }\r
\r
  mDebugPeriodicCallback = PeriodicCallback;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This protocol service is called by the debug agent to register a function\r
  for us to call when we detect an exception.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
  @param  ProcessorIndex        Specifies which processor the callback function\r
                                applies to.\r
  @param  ExceptionCallback     A pointer to a function of type\r
                                EXCEPTION_CALLBACK that is called when the\r
                                processor exception specified by ExceptionType\r
                                occurs. Passing NULL unregisters any previously\r
                                registered function associated with\r
                                ExceptionType.\r
  @param  ExceptionType         Specifies which processor exception to hook.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_ALREADY_STARTED   Non-NULL ExceptionCallback parameter when a\r
                                callback function was previously registered.\r
  @retval EFI_INVALID_PARAMETER ExceptionType parameter is negative or exceeds\r
                                MAX_EBC_EXCEPTION.\r
  @retval EFI_INVALID_PARAMETER Null ExceptionCallback parameter when no\r
                                callback function was previously registered.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugRegisterExceptionCallback (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,\r
  IN UINTN                       ProcessorIndex,\r
  IN EFI_EXCEPTION_CALLBACK      ExceptionCallback,\r
  IN EFI_EXCEPTION_TYPE          ExceptionType\r
  )\r
{\r
  if ((ExceptionType < 0) || (ExceptionType > MAX_EBC_EXCEPTION)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((mDebugExceptionCallback[ExceptionType] == NULL) && (ExceptionCallback == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((mDebugExceptionCallback[ExceptionType] != NULL) && (ExceptionCallback != NULL)) {\r
    return EFI_ALREADY_STARTED;\r
  }\r
\r
  mDebugExceptionCallback[ExceptionType] = ExceptionCallback;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This EBC debugger protocol service is called by the debug agent.  Required\r
  for DebugSupport compliance but is only stubbed out for EBC.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
  @param  ProcessorIndex        Specifies which processor the callback function\r
                                applies to.\r
  @param  Start                 StartSpecifies the physical base of the memory\r
                                range to be invalidated.\r
  @param  Length                Specifies the minimum number of bytes in the\r
                                processor's instruction cache to invalidate.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugInvalidateInstructionCache (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,\r
  IN UINTN                       ProcessorIndex,\r
  IN VOID                        *Start,\r
  IN UINT64                      Length\r
  )\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  The VM interpreter calls this function when an exception is detected.\r
\r
  @param  ExceptionType          Specifies the processor exception detected.\r
  @param  ExceptionFlags         Specifies the exception context.\r
  @param  VmPtr                  Pointer to a VM context for passing info to the\r
                                 EFI debugger.\r
\r
  @retval EFI_SUCCESS            This function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EbcDebugSignalException (\r
  IN EFI_EXCEPTION_TYPE  ExceptionType,\r
  IN EXCEPTION_FLAGS     ExceptionFlags,\r
  IN VM_CONTEXT          *VmPtr\r
  )\r
{\r
  EFI_SYSTEM_CONTEXT_EBC  EbcContext;\r
  EFI_SYSTEM_CONTEXT      SystemContext;\r
\r
  ASSERT ((ExceptionType >= 0) && (ExceptionType <= MAX_EBC_EXCEPTION));\r
  //\r
  // Save the exception in the context passed in\r
  //\r
  VmPtr->ExceptionFlags |= ExceptionFlags;\r
  VmPtr->LastException   = (UINTN)ExceptionType;\r
  //\r
  // If it's a fatal exception, then flag it in the VM context in case an\r
  // attached debugger tries to return from it.\r
  //\r
  if ((ExceptionFlags & EXCEPTION_FLAG_FATAL) != 0) {\r
    VmPtr->StopFlags |= STOPFLAG_APP_DONE;\r
  }\r
\r
  //\r
  // If someone's registered for exception callbacks, then call them.\r
  //\r
  // EBC driver will register default exception callback to report the\r
  // status code via the status code API\r
  //\r
  if (mDebugExceptionCallback[ExceptionType] != NULL) {\r
    //\r
    // Initialize the context structure\r
    //\r
    EbcContext.R0                  = (UINT64)VmPtr->Gpr[0];\r
    EbcContext.R1                  = (UINT64)VmPtr->Gpr[1];\r
    EbcContext.R2                  = (UINT64)VmPtr->Gpr[2];\r
    EbcContext.R3                  = (UINT64)VmPtr->Gpr[3];\r
    EbcContext.R4                  = (UINT64)VmPtr->Gpr[4];\r
    EbcContext.R5                  = (UINT64)VmPtr->Gpr[5];\r
    EbcContext.R6                  = (UINT64)VmPtr->Gpr[6];\r
    EbcContext.R7                  = (UINT64)VmPtr->Gpr[7];\r
    EbcContext.Ip                  = (UINT64)(UINTN)VmPtr->Ip;\r
    EbcContext.Flags               = VmPtr->Flags;\r
    EbcContext.ControlFlags        = 0;\r
    SystemContext.SystemContextEbc = &EbcContext;\r
\r
    mDebugExceptionCallback[ExceptionType](ExceptionType, SystemContext);\r
    //\r
    // Restore the context structure and continue to execute\r
    //\r
    VmPtr->Gpr[0] = EbcContext.R0;\r
    VmPtr->Gpr[1] = EbcContext.R1;\r
    VmPtr->Gpr[2] = EbcContext.R2;\r
    VmPtr->Gpr[3] = EbcContext.R3;\r
    VmPtr->Gpr[4] = EbcContext.R4;\r
    VmPtr->Gpr[5] = EbcContext.R5;\r
    VmPtr->Gpr[6] = EbcContext.R6;\r
    VmPtr->Gpr[7] = EbcContext.R7;\r
    VmPtr->Ip     = (VMIP)(UINTN)EbcContext.Ip;\r
    VmPtr->Flags  = EbcContext.Flags;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  To install default Callback function for the VM interpreter.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL\r
                                instance.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval Others                Some error occurs when creating periodic event.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
InitializeEbcCallback (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This\r
  )\r
{\r
  INTN        Index;\r
  EFI_STATUS  Status;\r
\r
  //\r
  // For ExceptionCallback\r
  //\r
  for (Index = 0; Index <= MAX_EBC_EXCEPTION; Index++) {\r
    EbcDebugRegisterExceptionCallback (\r
      This,\r
      0,\r
      CommonEbcExceptionHandler,\r
      Index\r
      );\r
  }\r
\r
  //\r
  // For PeriodicCallback\r
  //\r
  Status = gBS->CreateEvent (\r
                  EVT_TIMER | EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  EbcPeriodicNotifyFunction,\r
                  &mVmPtr,\r
                  &mEbcPeriodicEvent\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = gBS->SetTimer (\r
                  mEbcPeriodicEvent,\r
                  TimerPeriodic,\r
                  EBC_VM_PERIODIC_CALLBACK_RATE\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  The default Exception Callback for the VM interpreter.\r
  In this function, we report status code, and print debug information\r
  about EBC_CONTEXT, then dead loop.\r
\r
  @param  InterruptType          Interrupt type.\r
  @param  SystemContext          EBC system context.\r
\r
**/\r
VOID\r
EFIAPI\r
CommonEbcExceptionHandler (\r
  IN EFI_EXCEPTION_TYPE  InterruptType,\r
  IN EFI_SYSTEM_CONTEXT  SystemContext\r
  )\r
{\r
  //\r
  // We print debug information to let user know what happen.\r
  //\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "EBC Interrupter Version - 0x%016lx\n",\r
    (UINT64)(((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)))\r
    ));\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "Exception Type - 0x%016lx\n",\r
    (UINT64)(UINTN)InterruptType\r
    ));\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "  R0 - 0x%016lx, R1 - 0x%016lx\n",\r
    SystemContext.SystemContextEbc->R0,\r
    SystemContext.SystemContextEbc->R1\r
    ));\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "  R2 - 0x%016lx, R3 - 0x%016lx\n",\r
    SystemContext.SystemContextEbc->R2,\r
    SystemContext.SystemContextEbc->R3\r
    ));\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "  R4 - 0x%016lx, R5 - 0x%016lx\n",\r
    SystemContext.SystemContextEbc->R4,\r
    SystemContext.SystemContextEbc->R5\r
    ));\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "  R6 - 0x%016lx, R7 - 0x%016lx\n",\r
    SystemContext.SystemContextEbc->R6,\r
    SystemContext.SystemContextEbc->R7\r
    ));\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "  Flags - 0x%016lx\n",\r
    SystemContext.SystemContextEbc->Flags\r
    ));\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "  ControlFlags - 0x%016lx\n",\r
    SystemContext.SystemContextEbc->ControlFlags\r
    ));\r
  DEBUG ((\r
    DEBUG_ERROR,\r
    "  Ip - 0x%016lx\n\n",\r
    SystemContext.SystemContextEbc->Ip\r
    ));\r
\r
  //\r
  // We deadloop here to make it easy to debug this issue.\r
  //\r
  CpuDeadLoop ();\r
\r
  return;\r
}\r
\r
/**\r
  The periodic callback function for EBC VM interpreter, which is used\r
  to support the EFI debug support protocol.\r
\r
  @param  Event                  The Periodic Callback Event.\r
  @param  Context                It should be the address of VM_CONTEXT pointer.\r
\r
**/\r
VOID\r
EFIAPI\r
EbcPeriodicNotifyFunction (\r
  IN EFI_EVENT  Event,\r
  IN VOID       *Context\r
  )\r
{\r
  VM_CONTEXT  *VmPtr;\r
\r
  VmPtr = *(VM_CONTEXT **)Context;\r
\r
  if (VmPtr != NULL) {\r
    EbcDebugPeriodic (VmPtr);\r
  }\r
\r
  return;\r
}\r
\r
/**\r
  The VM interpreter calls this function on a periodic basis to support\r
  the EFI debug support protocol.\r
\r
  @param  VmPtr                  Pointer to a VM context for passing info to the\r
                                 debugger.\r
\r
  @retval EFI_SUCCESS            The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcDebugPeriodic (\r
  IN VM_CONTEXT  *VmPtr\r
  )\r
{\r
  EFI_SYSTEM_CONTEXT_EBC  EbcContext;\r
  EFI_SYSTEM_CONTEXT      SystemContext;\r
\r
  //\r
  // If someone's registered for periodic callbacks, then call them.\r
  //\r
  if (mDebugPeriodicCallback != NULL) {\r
    //\r
    // Initialize the context structure\r
    //\r
    EbcContext.R0                  = (UINT64)VmPtr->Gpr[0];\r
    EbcContext.R1                  = (UINT64)VmPtr->Gpr[1];\r
    EbcContext.R2                  = (UINT64)VmPtr->Gpr[2];\r
    EbcContext.R3                  = (UINT64)VmPtr->Gpr[3];\r
    EbcContext.R4                  = (UINT64)VmPtr->Gpr[4];\r
    EbcContext.R5                  = (UINT64)VmPtr->Gpr[5];\r
    EbcContext.R6                  = (UINT64)VmPtr->Gpr[6];\r
    EbcContext.R7                  = (UINT64)VmPtr->Gpr[7];\r
    EbcContext.Ip                  = (UINT64)(UINTN)VmPtr->Ip;\r
    EbcContext.Flags               = VmPtr->Flags;\r
    EbcContext.ControlFlags        = 0;\r
    SystemContext.SystemContextEbc = &EbcContext;\r
\r
    mDebugPeriodicCallback (SystemContext);\r
\r
    //\r
    // Restore the context structure and continue to execute\r
    //\r
    VmPtr->Gpr[0] = EbcContext.R0;\r
    VmPtr->Gpr[1] = EbcContext.R1;\r
    VmPtr->Gpr[2] = EbcContext.R2;\r
    VmPtr->Gpr[3] = EbcContext.R3;\r
    VmPtr->Gpr[4] = EbcContext.R4;\r
    VmPtr->Gpr[5] = EbcContext.R5;\r
    VmPtr->Gpr[6] = EbcContext.R6;\r
    VmPtr->Gpr[7] = EbcContext.R7;\r
    VmPtr->Ip     = (VMIP)(UINTN)EbcContext.Ip;\r
    VmPtr->Flags  = EbcContext.Flags;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  This routine is called by the core when an image is being unloaded from\r
  memory. Basically we now have the opportunity to do any necessary cleanup.\r
  Typically this will include freeing any memory allocated for thunk-creation.\r
\r
  @param  This                  A pointer to the EFI_EBC_PROTOCOL instance.\r
  @param  ImageHandle           Handle of image for which the thunk is being\r
                                created.\r
\r
  @retval EFI_INVALID_PARAMETER The ImageHandle passed in was not found in the\r
                                internal list of EBC image handles.\r
  @retval EFI_SUCCESS           The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcUnloadImage (\r
  IN EFI_EBC_PROTOCOL  *This,\r
  IN EFI_HANDLE        ImageHandle\r
  )\r
{\r
  EBC_THUNK_LIST  *ThunkList;\r
  EBC_THUNK_LIST  *NextThunkList;\r
  EBC_IMAGE_LIST  *ImageList;\r
  EBC_IMAGE_LIST  *PrevImageList;\r
\r
  //\r
  // First go through our list of known image handles and see if we've already\r
  // created an image list element for this image handle.\r
  //\r
  ReturnEBCStackByHandle (ImageHandle);\r
  PrevImageList = NULL;\r
  for (ImageList = mEbcImageList; ImageList != NULL; ImageList = ImageList->Next) {\r
    if (ImageList->ImageHandle == ImageHandle) {\r
      break;\r
    }\r
\r
    //\r
    // Save the previous so we can connect the lists when we remove this one\r
    //\r
    PrevImageList = ImageList;\r
  }\r
\r
  if (ImageList == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Free up all the thunk buffers and thunks list elements for this image\r
  // handle.\r
  //\r
  ThunkList = ImageList->ThunkList;\r
  while (ThunkList != NULL) {\r
    NextThunkList = ThunkList->Next;\r
    FreePool (ThunkList->ThunkBuffer);\r
    FreePool (ThunkList);\r
    ThunkList = NextThunkList;\r
  }\r
\r
  //\r
  // Now remove this image list element from the chain\r
  //\r
  if (PrevImageList == NULL) {\r
    //\r
    // Remove from head\r
    //\r
    mEbcImageList = ImageList->Next;\r
  } else {\r
    PrevImageList->Next = ImageList->Next;\r
  }\r
\r
  //\r
  // Now free up the image list element\r
  //\r
  FreePool (ImageList);\r
\r
  EbcDebuggerHookEbcUnloadImage (ImageHandle);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Add a thunk to our list of thunks for a given image handle.\r
  Also flush the instruction cache since we've written thunk code\r
  to memory that will be executed eventually.\r
\r
  @param  ImageHandle            The image handle to which the thunk is tied.\r
  @param  ThunkBuffer            The buffer that has been created/allocated.\r
  @param  ThunkSize              The size of the thunk memory allocated.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Memory allocation failed.\r
  @retval EFI_SUCCESS            The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EbcAddImageThunk (\r
  IN EFI_HANDLE  ImageHandle,\r
  IN VOID        *ThunkBuffer,\r
  IN UINT32      ThunkSize\r
  )\r
{\r
  EBC_THUNK_LIST  *ThunkList;\r
  EBC_IMAGE_LIST  *ImageList;\r
  EFI_STATUS      Status;\r
\r
  //\r
  // It so far so good, then flush the instruction cache\r
  //\r
  if (mEbcICacheFlush != NULL) {\r
    Status = mEbcICacheFlush ((EFI_PHYSICAL_ADDRESS)(UINTN)ThunkBuffer, ThunkSize);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // Go through our list of known image handles and see if we've already\r
  // created a image list element for this image handle.\r
  //\r
  for (ImageList = mEbcImageList; ImageList != NULL; ImageList = ImageList->Next) {\r
    if (ImageList->ImageHandle == ImageHandle) {\r
      break;\r
    }\r
  }\r
\r
  if (ImageList == NULL) {\r
    //\r
    // Allocate a new one\r
    //\r
    ImageList = AllocatePool (sizeof (EBC_IMAGE_LIST));\r
\r
    if (ImageList == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    ImageList->ThunkList   = NULL;\r
    ImageList->ImageHandle = ImageHandle;\r
    ImageList->Next        = mEbcImageList;\r
    mEbcImageList          = ImageList;\r
  }\r
\r
  //\r
  // Ok, now create a new thunk element to add to the list\r
  //\r
  ThunkList = AllocatePool (sizeof (EBC_THUNK_LIST));\r
\r
  if (ThunkList == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Add it to the head of the list\r
  //\r
  ThunkList->Next        = ImageList->ThunkList;\r
  ThunkList->ThunkBuffer = ThunkBuffer;\r
  ImageList->ThunkList   = ThunkList;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Registers a callback function that the EBC interpreter calls to flush the\r
  processor instruction cache following creation of thunks.\r
\r
  @param  This        A pointer to the EFI_EBC_PROTOCOL instance.\r
  @param  Flush       Pointer to a function of type EBC_ICACH_FLUSH.\r
\r
  @retval EFI_SUCCESS The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcRegisterICacheFlush (\r
  IN EFI_EBC_PROTOCOL  *This,\r
  IN EBC_ICACHE_FLUSH  Flush\r
  )\r
{\r
  mEbcICacheFlush = Flush;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Called to get the version of the interpreter.\r
\r
  @param  This                  A pointer to the EFI_EBC_PROTOCOL instance.\r
  @param  Version               Pointer to where to store the returned version\r
                                of the interpreter.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_INVALID_PARAMETER Version pointer is NULL.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcGetVersion (\r
  IN EFI_EBC_PROTOCOL  *This,\r
  IN OUT UINT64        *Version\r
  )\r
{\r
  if (Version == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *Version = GetVmVersion ();\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Returns the stack index and buffer assosicated with the Handle parameter.\r
\r
  @param  Handle                The EFI handle as the index to the EBC stack.\r
  @param  StackBuffer           A pointer to hold the returned stack buffer.\r
  @param  BufferIndex           A pointer to hold the returned stack index.\r
\r
  @retval EFI_OUT_OF_RESOURCES  The Handle parameter does not correspond to any\r
                                existing EBC stack.\r
  @retval EFI_SUCCESS           The stack index and buffer were found and\r
                                returned to the caller.\r
\r
**/\r
EFI_STATUS\r
GetEBCStack (\r
  IN  EFI_HANDLE  Handle,\r
  OUT VOID        **StackBuffer,\r
  OUT UINTN       *BufferIndex\r
  )\r
{\r
  UINTN    Index;\r
  EFI_TPL  OldTpl;\r
\r
  OldTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
  for (Index = 0; Index < mStackNum; Index++) {\r
    if (mStackBufferIndex[Index] == NULL) {\r
      mStackBufferIndex[Index] = Handle;\r
      break;\r
    }\r
  }\r
\r
  gBS->RestoreTPL (OldTpl);\r
  if (Index == mStackNum) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  *BufferIndex = Index;\r
  *StackBuffer = mStackBuffer[Index];\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Returns from the EBC stack by stack Index.\r
\r
  @param  Index        Specifies which EBC stack to return from.\r
\r
  @retval EFI_SUCCESS  The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
ReturnEBCStack (\r
  IN UINTN  Index\r
  )\r
{\r
  mStackBufferIndex[Index] = NULL;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Returns from the EBC stack associated with the Handle parameter.\r
\r
  @param  Handle      Specifies the EFI handle to find the EBC stack with.\r
\r
  @retval EFI_SUCCESS The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
ReturnEBCStackByHandle (\r
  IN EFI_HANDLE  Handle\r
  )\r
{\r
  UINTN  Index;\r
\r
  for (Index = 0; Index < mStackNum; Index++) {\r
    if (mStackBufferIndex[Index] == Handle) {\r
      break;\r
    }\r
  }\r
\r
  if (Index == mStackNum) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  mStackBufferIndex[Index] = NULL;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Allocates memory to hold all the EBC stacks.\r
\r
  @retval EFI_SUCCESS          The EBC stacks were allocated successfully.\r
  @retval EFI_OUT_OF_RESOURCES Not enough memory available for EBC stacks.\r
\r
**/\r
EFI_STATUS\r
InitEBCStack (\r
  VOID\r
  )\r
{\r
  for (mStackNum = 0; mStackNum < MAX_STACK_NUM; mStackNum++) {\r
    mStackBuffer[mStackNum]      = AllocatePool (STACK_POOL_SIZE);\r
    mStackBufferIndex[mStackNum] = NULL;\r
    if (mStackBuffer[mStackNum] == NULL) {\r
      break;\r
    }\r
  }\r
\r
  if (mStackNum == 0) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Free all EBC stacks allocated before.\r
\r
  @retval EFI_SUCCESS   All the EBC stacks were freed.\r
\r
**/\r
EFI_STATUS\r
FreeEBCStack (\r
  VOID\r
  )\r
{\r
  UINTN  Index;\r
\r
  for (Index = 0; Index < mStackNum; Index++) {\r
    FreePool (mStackBuffer[Index]);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Produces an EBC VM test protocol that can be used for regression tests.\r
\r
  @param  IHandle                Handle on which to install the protocol.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Memory allocation failed.\r
  @retval EFI_SUCCESS            The function completed successfully.\r
\r
**/\r
EFI_STATUS\r
InitEbcVmTestProtocol (\r
  IN EFI_HANDLE  *IHandle\r
  )\r
{\r
  EFI_HANDLE                Handle;\r
  EFI_STATUS                Status;\r
  EFI_EBC_VM_TEST_PROTOCOL  *EbcVmTestProtocol;\r
\r
  //\r
  // Allocate memory for the protocol, then fill in the fields\r
  //\r
  EbcVmTestProtocol = AllocatePool (sizeof (EFI_EBC_VM_TEST_PROTOCOL));\r
  if (EbcVmTestProtocol == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  EbcVmTestProtocol->Execute = (EBC_VM_TEST_EXECUTE)EbcExecuteInstructions;\r
\r
  DEBUG_CODE_BEGIN ();\r
  EbcVmTestProtocol->Assemble    = (EBC_VM_TEST_ASM)EbcVmTestUnsupported;\r
  EbcVmTestProtocol->Disassemble = (EBC_VM_TEST_DASM)EbcVmTestUnsupported;\r
  DEBUG_CODE_END ();\r
\r
  //\r
  // Publish the protocol\r
  //\r
  Handle = NULL;\r
  Status = gBS->InstallProtocolInterface (&Handle, &gEfiEbcVmTestProtocolGuid, EFI_NATIVE_INTERFACE, EbcVmTestProtocol);\r
  if (EFI_ERROR (Status)) {\r
    FreePool (EbcVmTestProtocol);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Returns the EFI_UNSUPPORTED Status.\r
\r
  @return EFI_UNSUPPORTED  This function always return EFI_UNSUPPORTED status.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
EbcVmTestUnsupported (\r
  VOID\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  Allocates a buffer of type EfiBootServicesCode.\r
\r
  @param  AllocationSize        The number of bytes to allocate.\r
\r
  @return A pointer to the allocated buffer or NULL if allocation fails.\r
\r
**/\r
VOID *\r
EFIAPI\r
EbcAllocatePoolForThunk (\r
  IN UINTN  AllocationSize\r
  )\r
{\r
  VOID        *Buffer;\r
  EFI_STATUS  Status;\r
\r
  Status = gBS->AllocatePool (EfiBootServicesCode, AllocationSize, &Buffer);\r
  if (EFI_ERROR (Status)) {\r
    return NULL;\r
  }\r
\r
  return Buffer;\r
}\r