EbcInt.c

Go to the documentation of this file.

 
#include "EbcInt.h"
#include "EbcExecute.h"
#include "EbcDebuggerHook.h"
 
//
// We'll keep track of all thunks we create in a linked list. Each
// thunk is tied to an image handle, so we have a linked list of
// image handles, with each having a linked list of thunks allocated
// to that image handle.
//
typedef struct _EBC_THUNK_LIST EBC_THUNK_LIST;
struct _EBC_THUNK_LIST {
  VOID              *ThunkBuffer;
  EBC_THUNK_LIST    *Next;
};
 
typedef struct _EBC_IMAGE_LIST EBC_IMAGE_LIST;
struct _EBC_IMAGE_LIST {
  EBC_IMAGE_LIST    *Next;
  EFI_HANDLE        ImageHandle;
  EBC_THUNK_LIST    *ThunkList;
};
 
EFI_STATUS
EFIAPI
EbcUnloadImage (
  IN EFI_EBC_PROTOCOL  *This,
  IN EFI_HANDLE        ImageHandle
  );
 
EFI_STATUS
EFIAPI
EbcCreateThunk (
  IN EFI_EBC_PROTOCOL  *This,
  IN EFI_HANDLE        ImageHandle,
  IN VOID              *EbcEntryPoint,
  OUT VOID             **Thunk
  );
 
EFI_STATUS
EFIAPI
EbcGetVersion (
  IN EFI_EBC_PROTOCOL  *This,
  IN OUT UINT64        *Version
  );
 
EFI_STATUS
EFIAPI
InitializeEbcCallback (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This
  );
 
VOID
EFIAPI
CommonEbcExceptionHandler (
  IN EFI_EXCEPTION_TYPE  InterruptType,
  IN EFI_SYSTEM_CONTEXT  SystemContext
  );
 
VOID
EFIAPI
EbcPeriodicNotifyFunction (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  );
 
EFI_STATUS
EFIAPI
EbcDebugPeriodic (
  IN VM_CONTEXT  *VmPtr
  );
 
//
// These two functions and the  GUID are used to produce an EBC test protocol.
// This functionality is definitely not required for execution.
//
 
EFI_STATUS
InitEbcVmTestProtocol (
  IN EFI_HANDLE  *IHandle
  );
 
EFI_STATUS
EFIAPI
EbcVmTestUnsupported (
  VOID
  );
 
EFI_STATUS
EFIAPI
EbcRegisterICacheFlush (
  IN EFI_EBC_PROTOCOL  *This,
  IN EBC_ICACHE_FLUSH  Flush
  );
 
EFI_STATUS
EFIAPI
EbcDebugGetMaximumProcessorIndex (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
  OUT UINTN                      *MaxProcessorIndex
  );
 
EFI_STATUS
EFIAPI
EbcDebugRegisterPeriodicCallback (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
  IN UINTN                       ProcessorIndex,
  IN EFI_PERIODIC_CALLBACK       PeriodicCallback
  );
 
EFI_STATUS
EFIAPI
EbcDebugRegisterExceptionCallback (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
  IN UINTN                       ProcessorIndex,
  IN EFI_EXCEPTION_CALLBACK      ExceptionCallback,
  IN EFI_EXCEPTION_TYPE          ExceptionType
  );
 
EFI_STATUS
EFIAPI
EbcDebugInvalidateInstructionCache (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
  IN UINTN                       ProcessorIndex,
  IN VOID                        *Start,
  IN UINT64                      Length
  );
 
//
// We have one linked list of image handles for the whole world. Since
// there should only be one interpreter, make them global. They must
// also be global since the execution of an EBC image does not provide
// a This pointer.
//
EBC_IMAGE_LIST  *mEbcImageList = NULL;
 
//
// Callback function to flush the icache after thunk creation
//
EBC_ICACHE_FLUSH  mEbcICacheFlush;
 
//
// These get set via calls by the debug agent
//
EFI_PERIODIC_CALLBACK   mDebugPeriodicCallback                         = NULL;
EFI_EXCEPTION_CALLBACK  mDebugExceptionCallback[MAX_EBC_EXCEPTION + 1] = { NULL };
 
VOID        *mStackBuffer[MAX_STACK_NUM];
EFI_HANDLE  mStackBufferIndex[MAX_STACK_NUM];
UINTN       mStackNum = 0;
 
//
// Event for Periodic callback
//
EFI_EVENT   mEbcPeriodicEvent;
VM_CONTEXT  *mVmPtr = NULL;
 
BOOLEAN
EFIAPI
EbcIsImageSupported (
  IN  EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL  *This,
  IN  UINT16                                ImageType,
  IN  EFI_DEVICE_PATH_PROTOCOL              *DevicePath   OPTIONAL
  )
{
  if ((ImageType != EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) &&
      (ImageType != EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER))
  {
    return FALSE;
  }
 
  return TRUE;
}
 
EFI_STATUS
EFIAPI
EbcRegisterImage (
  IN      EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL  *This,
  IN      EFI_PHYSICAL_ADDRESS                  ImageBase,
  IN      UINT64                                ImageSize,
  IN  OUT EFI_IMAGE_ENTRY_POINT                 *EntryPoint
  )
{
  DEBUG_CODE_BEGIN ();
  PE_COFF_LOADER_IMAGE_CONTEXT  ImageContext;
  EFI_STATUS                    Status;
 
  ZeroMem (&ImageContext, sizeof (ImageContext));
 
  ImageContext.Handle    = (VOID *)(UINTN)ImageBase;
  ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;
 
  Status = PeCoffLoaderGetImageInfo (&ImageContext);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  ASSERT (ImageContext.Machine == EFI_IMAGE_MACHINE_EBC);
  ASSERT (
    ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION ||
    ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
    );
  DEBUG_CODE_END ();
 
  EbcRegisterICacheFlush (
    NULL,
    (EBC_ICACHE_FLUSH)InvalidateInstructionCacheRange
    );
 
  return EbcCreateThunk (
           NULL,
           (VOID *)(UINTN)ImageBase,
           (VOID *)(UINTN)*EntryPoint,
           (VOID **)EntryPoint
           );
}
 
EFI_STATUS
EFIAPI
EbcUnregisterImage (
  IN  EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL  *This,
  IN  EFI_PHYSICAL_ADDRESS                  ImageBase
  )
{
  return EbcUnloadImage (NULL, (VOID *)(UINTN)ImageBase);
}
 
STATIC EDKII_PECOFF_IMAGE_EMULATOR_PROTOCOL  mPeCoffEmuProtocol = {
  EbcIsImageSupported,
  EbcRegisterImage,
  EbcUnregisterImage,
  EDKII_PECOFF_IMAGE_EMULATOR_VERSION,
  EFI_IMAGE_MACHINE_EBC
};
 
EFI_STATUS
EFIAPI
InitializeEbcDriver (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_EBC_PROTOCOL            *EbcProtocol;
  EFI_EBC_PROTOCOL            *OldEbcProtocol;
  EFI_STATUS                  Status;
  EFI_DEBUG_SUPPORT_PROTOCOL  *EbcDebugProtocol;
  EFI_HANDLE                  *HandleBuffer;
  UINTN                       NumHandles;
  UINTN                       Index;
  BOOLEAN                     Installed;
 
  EbcProtocol      = NULL;
  EbcDebugProtocol = NULL;
 
  //
  // Allocate memory for our protocol. Then fill in the blanks.
  //
  EbcProtocol = AllocatePool (sizeof (EFI_EBC_PROTOCOL));
 
  if (EbcProtocol == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  EbcProtocol->CreateThunk         = EbcCreateThunk;
  EbcProtocol->UnloadImage         = EbcUnloadImage;
  EbcProtocol->RegisterICacheFlush = EbcRegisterICacheFlush;
  EbcProtocol->GetVersion          = EbcGetVersion;
  mEbcICacheFlush                  = NULL;
 
  //
  // Find any already-installed EBC protocols and uninstall them
  //
  Installed    = FALSE;
  HandleBuffer = NULL;
  Status       = gBS->LocateHandleBuffer (
                        ByProtocol,
                        &gEfiEbcProtocolGuid,
                        NULL,
                        &NumHandles,
                        &HandleBuffer
                        );
  if (Status == EFI_SUCCESS) {
    //
    // Loop through the handles
    //
    for (Index = 0; Index < NumHandles; Index++) {
      Status = gBS->HandleProtocol (
                      HandleBuffer[Index],
                      &gEfiEbcProtocolGuid,
                      (VOID **)&OldEbcProtocol
                      );
      if (Status == EFI_SUCCESS) {
        if (gBS->ReinstallProtocolInterface (
                   HandleBuffer[Index],
                   &gEfiEbcProtocolGuid,
                   OldEbcProtocol,
                   EbcProtocol
                   ) == EFI_SUCCESS)
        {
          Installed = TRUE;
        }
      }
    }
  }
 
  if (HandleBuffer != NULL) {
    FreePool (HandleBuffer);
    HandleBuffer = NULL;
  }
 
  //
  // Add the protocol so someone can locate us if we haven't already.
  //
  if (!Installed) {
    Status = gBS->InstallMultipleProtocolInterfaces (
                    &ImageHandle,
                    &gEfiEbcProtocolGuid,
                    EbcProtocol,
                    &gEdkiiPeCoffImageEmulatorProtocolGuid,
                    &mPeCoffEmuProtocol,
                    NULL
                    );
    if (EFI_ERROR (Status)) {
      FreePool (EbcProtocol);
      return Status;
    }
  }
 
  Status = InitEBCStack ();
  if (EFI_ERROR (Status)) {
    goto ErrorExit;
  }
 
  //
  // Allocate memory for our debug protocol. Then fill in the blanks.
  //
  EbcDebugProtocol = AllocatePool (sizeof (EFI_DEBUG_SUPPORT_PROTOCOL));
 
  if (EbcDebugProtocol == NULL) {
    goto ErrorExit;
  }
 
  EbcDebugProtocol->Isa                        = IsaEbc;
  EbcDebugProtocol->GetMaximumProcessorIndex   = EbcDebugGetMaximumProcessorIndex;
  EbcDebugProtocol->RegisterPeriodicCallback   = EbcDebugRegisterPeriodicCallback;
  EbcDebugProtocol->RegisterExceptionCallback  = EbcDebugRegisterExceptionCallback;
  EbcDebugProtocol->InvalidateInstructionCache = EbcDebugInvalidateInstructionCache;
 
  //
  // Add the protocol so the debug agent can find us
  //
  Status = gBS->InstallProtocolInterface (
                  &ImageHandle,
                  &gEfiDebugSupportProtocolGuid,
                  EFI_NATIVE_INTERFACE,
                  EbcDebugProtocol
                  );
  //
  // This is recoverable, so free the memory and continue.
  //
  if (EFI_ERROR (Status)) {
    FreePool (EbcDebugProtocol);
    goto ErrorExit;
  }
 
  //
  // Install EbcDebugSupport Protocol Successfully
  // Now we need to initialize the Ebc default Callback
  //
  Status = InitializeEbcCallback (EbcDebugProtocol);
 
  //
  // Produce a VM test interface protocol. Not required for execution.
  //
  DEBUG_CODE_BEGIN ();
  InitEbcVmTestProtocol (&ImageHandle);
  DEBUG_CODE_END ();
 
  EbcDebuggerHookInit (ImageHandle, EbcDebugProtocol);
 
  return EFI_SUCCESS;
 
ErrorExit:
  FreeEBCStack ();
  HandleBuffer = NULL;
  Status       = gBS->LocateHandleBuffer (
                        ByProtocol,
                        &gEfiEbcProtocolGuid,
                        NULL,
                        &NumHandles,
                        &HandleBuffer
                        );
  if (Status == EFI_SUCCESS) {
    //
    // Loop through the handles
    //
    for (Index = 0; Index < NumHandles; Index++) {
      Status = gBS->HandleProtocol (
                      HandleBuffer[Index],
                      &gEfiEbcProtocolGuid,
                      (VOID **)&OldEbcProtocol
                      );
      if (Status == EFI_SUCCESS) {
        gBS->UninstallProtocolInterface (
               HandleBuffer[Index],
               &gEfiEbcProtocolGuid,
               OldEbcProtocol
               );
      }
    }
  }
 
  if (HandleBuffer != NULL) {
    FreePool (HandleBuffer);
    HandleBuffer = NULL;
  }
 
  FreePool (EbcProtocol);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EbcCreateThunk (
  IN EFI_EBC_PROTOCOL  *This,
  IN EFI_HANDLE        ImageHandle,
  IN VOID              *EbcEntryPoint,
  OUT VOID             **Thunk
  )
{
  EFI_STATUS  Status;
 
  Status = EbcCreateThunks (
             ImageHandle,
             EbcEntryPoint,
             Thunk,
             FLAG_THUNK_ENTRY_POINT
             );
  return Status;
}
 
EFI_STATUS
EFIAPI
EbcDebugGetMaximumProcessorIndex (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
  OUT UINTN                      *MaxProcessorIndex
  )
{
  *MaxProcessorIndex = 0;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EbcDebugRegisterPeriodicCallback (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
  IN UINTN                       ProcessorIndex,
  IN EFI_PERIODIC_CALLBACK       PeriodicCallback
  )
{
  if ((mDebugPeriodicCallback == NULL) && (PeriodicCallback == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((mDebugPeriodicCallback != NULL) && (PeriodicCallback != NULL)) {
    return EFI_ALREADY_STARTED;
  }
 
  mDebugPeriodicCallback = PeriodicCallback;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EbcDebugRegisterExceptionCallback (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
  IN UINTN                       ProcessorIndex,
  IN EFI_EXCEPTION_CALLBACK      ExceptionCallback,
  IN EFI_EXCEPTION_TYPE          ExceptionType
  )
{
  if ((ExceptionType < 0) || (ExceptionType > MAX_EBC_EXCEPTION)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((mDebugExceptionCallback[ExceptionType] == NULL) && (ExceptionCallback == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((mDebugExceptionCallback[ExceptionType] != NULL) && (ExceptionCallback != NULL)) {
    return EFI_ALREADY_STARTED;
  }
 
  mDebugExceptionCallback[ExceptionType] = ExceptionCallback;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EbcDebugInvalidateInstructionCache (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This,
  IN UINTN                       ProcessorIndex,
  IN VOID                        *Start,
  IN UINT64                      Length
  )
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
EbcDebugSignalException (
  IN EFI_EXCEPTION_TYPE  ExceptionType,
  IN EXCEPTION_FLAGS     ExceptionFlags,
  IN VM_CONTEXT          *VmPtr
  )
{
  EFI_SYSTEM_CONTEXT_EBC  EbcContext;
  EFI_SYSTEM_CONTEXT      SystemContext;
 
  ASSERT ((ExceptionType >= 0) && (ExceptionType <= MAX_EBC_EXCEPTION));
  //
  // Save the exception in the context passed in
  //
  VmPtr->ExceptionFlags |= ExceptionFlags;
  VmPtr->LastException   = (UINTN)ExceptionType;
  //
  // If it's a fatal exception, then flag it in the VM context in case an
  // attached debugger tries to return from it.
  //
  if ((ExceptionFlags & EXCEPTION_FLAG_FATAL) != 0) {
    VmPtr->StopFlags |= STOPFLAG_APP_DONE;
  }
 
  //
  // If someone's registered for exception callbacks, then call them.
  //
  // EBC driver will register default exception callback to report the
  // status code via the status code API
  //
  if (mDebugExceptionCallback[ExceptionType] != NULL) {
    //
    // Initialize the context structure
    //
    EbcContext.R0                  = (UINT64)VmPtr->Gpr[0];
    EbcContext.R1                  = (UINT64)VmPtr->Gpr[1];
    EbcContext.R2                  = (UINT64)VmPtr->Gpr[2];
    EbcContext.R3                  = (UINT64)VmPtr->Gpr[3];
    EbcContext.R4                  = (UINT64)VmPtr->Gpr[4];
    EbcContext.R5                  = (UINT64)VmPtr->Gpr[5];
    EbcContext.R6                  = (UINT64)VmPtr->Gpr[6];
    EbcContext.R7                  = (UINT64)VmPtr->Gpr[7];
    EbcContext.Ip                  = (UINT64)(UINTN)VmPtr->Ip;
    EbcContext.Flags               = VmPtr->Flags;
    EbcContext.ControlFlags        = 0;
    SystemContext.SystemContextEbc = &EbcContext;
 
    mDebugExceptionCallback[ExceptionType](ExceptionType, SystemContext);
    //
    // Restore the context structure and continue to execute
    //
    VmPtr->Gpr[0] = EbcContext.R0;
    VmPtr->Gpr[1] = EbcContext.R1;
    VmPtr->Gpr[2] = EbcContext.R2;
    VmPtr->Gpr[3] = EbcContext.R3;
    VmPtr->Gpr[4] = EbcContext.R4;
    VmPtr->Gpr[5] = EbcContext.R5;
    VmPtr->Gpr[6] = EbcContext.R6;
    VmPtr->Gpr[7] = EbcContext.R7;
    VmPtr->Ip     = (VMIP)(UINTN)EbcContext.Ip;
    VmPtr->Flags  = EbcContext.Flags;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
InitializeEbcCallback (
  IN EFI_DEBUG_SUPPORT_PROTOCOL  *This
  )
{
  INTN        Index;
  EFI_STATUS  Status;
 
  //
  // For ExceptionCallback
  //
  for (Index = 0; Index <= MAX_EBC_EXCEPTION; Index++) {
    EbcDebugRegisterExceptionCallback (
      This,
      0,
      CommonEbcExceptionHandler,
      Index
      );
  }
 
  //
  // For PeriodicCallback
  //
  Status = gBS->CreateEvent (
                  EVT_TIMER | EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  EbcPeriodicNotifyFunction,
                  &mVmPtr,
                  &mEbcPeriodicEvent
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = gBS->SetTimer (
                  mEbcPeriodicEvent,
                  TimerPeriodic,
                  EBC_VM_PERIODIC_CALLBACK_RATE
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
VOID
EFIAPI
CommonEbcExceptionHandler (
  IN EFI_EXCEPTION_TYPE  InterruptType,
  IN EFI_SYSTEM_CONTEXT  SystemContext
  )
{
  //
  // We print debug information to let user know what happen.
  //
  DEBUG ((
    DEBUG_ERROR,
    "EBC Interrupter Version - 0x%016lx\n",
    (UINT64)(((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)))
    ));
  DEBUG ((
    DEBUG_ERROR,
    "Exception Type - 0x%016lx\n",
    (UINT64)(UINTN)InterruptType
    ));
  DEBUG ((
    DEBUG_ERROR,
    "  R0 - 0x%016lx, R1 - 0x%016lx\n",
    SystemContext.SystemContextEbc->R0,
    SystemContext.SystemContextEbc->R1
    ));
  DEBUG ((
    DEBUG_ERROR,
    "  R2 - 0x%016lx, R3 - 0x%016lx\n",
    SystemContext.SystemContextEbc->R2,
    SystemContext.SystemContextEbc->R3
    ));
  DEBUG ((
    DEBUG_ERROR,
    "  R4 - 0x%016lx, R5 - 0x%016lx\n",
    SystemContext.SystemContextEbc->R4,
    SystemContext.SystemContextEbc->R5
    ));
  DEBUG ((
    DEBUG_ERROR,
    "  R6 - 0x%016lx, R7 - 0x%016lx\n",
    SystemContext.SystemContextEbc->R6,
    SystemContext.SystemContextEbc->R7
    ));
  DEBUG ((
    DEBUG_ERROR,
    "  Flags - 0x%016lx\n",
    SystemContext.SystemContextEbc->Flags
    ));
  DEBUG ((
    DEBUG_ERROR,
    "  ControlFlags - 0x%016lx\n",
    SystemContext.SystemContextEbc->ControlFlags
    ));
  DEBUG ((
    DEBUG_ERROR,
    "  Ip - 0x%016lx\n\n",
    SystemContext.SystemContextEbc->Ip
    ));
 
  //
  // We deadloop here to make it easy to debug this issue.
  //
  CpuDeadLoop ();
 
  return;
}
 
VOID
EFIAPI
EbcPeriodicNotifyFunction (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  VM_CONTEXT  *VmPtr;
 
  VmPtr = *(VM_CONTEXT **)Context;
 
  if (VmPtr != NULL) {
    EbcDebugPeriodic (VmPtr);
  }
 
  return;
}
 
EFI_STATUS
EFIAPI
EbcDebugPeriodic (
  IN VM_CONTEXT  *VmPtr
  )
{
  EFI_SYSTEM_CONTEXT_EBC  EbcContext;
  EFI_SYSTEM_CONTEXT      SystemContext;
 
  //
  // If someone's registered for periodic callbacks, then call them.
  //
  if (mDebugPeriodicCallback != NULL) {
    //
    // Initialize the context structure
    //
    EbcContext.R0                  = (UINT64)VmPtr->Gpr[0];
    EbcContext.R1                  = (UINT64)VmPtr->Gpr[1];
    EbcContext.R2                  = (UINT64)VmPtr->Gpr[2];
    EbcContext.R3                  = (UINT64)VmPtr->Gpr[3];
    EbcContext.R4                  = (UINT64)VmPtr->Gpr[4];
    EbcContext.R5                  = (UINT64)VmPtr->Gpr[5];
    EbcContext.R6                  = (UINT64)VmPtr->Gpr[6];
    EbcContext.R7                  = (UINT64)VmPtr->Gpr[7];
    EbcContext.Ip                  = (UINT64)(UINTN)VmPtr->Ip;
    EbcContext.Flags               = VmPtr->Flags;
    EbcContext.ControlFlags        = 0;
    SystemContext.SystemContextEbc = &EbcContext;
 
    mDebugPeriodicCallback (SystemContext);
 
    //
    // Restore the context structure and continue to execute
    //
    VmPtr->Gpr[0] = EbcContext.R0;
    VmPtr->Gpr[1] = EbcContext.R1;
    VmPtr->Gpr[2] = EbcContext.R2;
    VmPtr->Gpr[3] = EbcContext.R3;
    VmPtr->Gpr[4] = EbcContext.R4;
    VmPtr->Gpr[5] = EbcContext.R5;
    VmPtr->Gpr[6] = EbcContext.R6;
    VmPtr->Gpr[7] = EbcContext.R7;
    VmPtr->Ip     = (VMIP)(UINTN)EbcContext.Ip;
    VmPtr->Flags  = EbcContext.Flags;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EbcUnloadImage (
  IN EFI_EBC_PROTOCOL  *This,
  IN EFI_HANDLE        ImageHandle
  )
{
  EBC_THUNK_LIST  *ThunkList;
  EBC_THUNK_LIST  *NextThunkList;
  EBC_IMAGE_LIST  *ImageList;
  EBC_IMAGE_LIST  *PrevImageList;
 
  //
  // First go through our list of known image handles and see if we've already
  // created an image list element for this image handle.
  //
  ReturnEBCStackByHandle (ImageHandle);
  PrevImageList = NULL;
  for (ImageList = mEbcImageList; ImageList != NULL; ImageList = ImageList->Next) {
    if (ImageList->ImageHandle == ImageHandle) {
      break;
    }
 
    //
    // Save the previous so we can connect the lists when we remove this one
    //
    PrevImageList = ImageList;
  }
 
  if (ImageList == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Free up all the thunk buffers and thunks list elements for this image
  // handle.
  //
  ThunkList = ImageList->ThunkList;
  while (ThunkList != NULL) {
    NextThunkList = ThunkList->Next;
    FreePool (ThunkList->ThunkBuffer);
    FreePool (ThunkList);
    ThunkList = NextThunkList;
  }
 
  //
  // Now remove this image list element from the chain
  //
  if (PrevImageList == NULL) {
    //
    // Remove from head
    //
    mEbcImageList = ImageList->Next;
  } else {
    PrevImageList->Next = ImageList->Next;
  }
 
  //
  // Now free up the image list element
  //
  FreePool (ImageList);
 
  EbcDebuggerHookEbcUnloadImage (ImageHandle);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EbcAddImageThunk (
  IN EFI_HANDLE  ImageHandle,
  IN VOID        *ThunkBuffer,
  IN UINT32      ThunkSize
  )
{
  EBC_THUNK_LIST  *ThunkList;
  EBC_IMAGE_LIST  *ImageList;
  EFI_STATUS      Status;
 
  //
  // It so far so good, then flush the instruction cache
  //
  if (mEbcICacheFlush != NULL) {
    Status = mEbcICacheFlush ((EFI_PHYSICAL_ADDRESS)(UINTN)ThunkBuffer, ThunkSize);
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  //
  // Go through our list of known image handles and see if we've already
  // created a image list element for this image handle.
  //
  for (ImageList = mEbcImageList; ImageList != NULL; ImageList = ImageList->Next) {
    if (ImageList->ImageHandle == ImageHandle) {
      break;
    }
  }
 
  if (ImageList == NULL) {
    //
    // Allocate a new one
    //
    ImageList = AllocatePool (sizeof (EBC_IMAGE_LIST));
 
    if (ImageList == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    ImageList->ThunkList   = NULL;
    ImageList->ImageHandle = ImageHandle;
    ImageList->Next        = mEbcImageList;
    mEbcImageList          = ImageList;
  }
 
  //
  // Ok, now create a new thunk element to add to the list
  //
  ThunkList = AllocatePool (sizeof (EBC_THUNK_LIST));
 
  if (ThunkList == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Add it to the head of the list
  //
  ThunkList->Next        = ImageList->ThunkList;
  ThunkList->ThunkBuffer = ThunkBuffer;
  ImageList->ThunkList   = ThunkList;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EbcRegisterICacheFlush (
  IN EFI_EBC_PROTOCOL  *This,
  IN EBC_ICACHE_FLUSH  Flush
  )
{
  mEbcICacheFlush = Flush;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EbcGetVersion (
  IN EFI_EBC_PROTOCOL  *This,
  IN OUT UINT64        *Version
  )
{
  if (Version == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  *Version = GetVmVersion ();
  return EFI_SUCCESS;
}
 
EFI_STATUS
GetEBCStack (
  IN  EFI_HANDLE  Handle,
  OUT VOID        **StackBuffer,
  OUT UINTN       *BufferIndex
  )
{
  UINTN    Index;
  EFI_TPL  OldTpl;
 
  OldTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
  for (Index = 0; Index < mStackNum; Index++) {
    if (mStackBufferIndex[Index] == NULL) {
      mStackBufferIndex[Index] = Handle;
      break;
    }
  }
 
  gBS->RestoreTPL (OldTpl);
  if (Index == mStackNum) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  *BufferIndex = Index;
  *StackBuffer = mStackBuffer[Index];
  return EFI_SUCCESS;
}
 
EFI_STATUS
ReturnEBCStack (
  IN UINTN  Index
  )
{
  mStackBufferIndex[Index] = NULL;
  return EFI_SUCCESS;
}
 
EFI_STATUS
ReturnEBCStackByHandle (
  IN EFI_HANDLE  Handle
  )
{
  UINTN  Index;
 
  for (Index = 0; Index < mStackNum; Index++) {
    if (mStackBufferIndex[Index] == Handle) {
      break;
    }
  }
 
  if (Index == mStackNum) {
    return EFI_NOT_FOUND;
  }
 
  mStackBufferIndex[Index] = NULL;
  return EFI_SUCCESS;
}
 
EFI_STATUS
InitEBCStack (
  VOID
  )
{
  for (mStackNum = 0; mStackNum < MAX_STACK_NUM; mStackNum++) {
    mStackBuffer[mStackNum]      = AllocatePool (STACK_POOL_SIZE);
    mStackBufferIndex[mStackNum] = NULL;
    if (mStackBuffer[mStackNum] == NULL) {
      break;
    }
  }
 
  if (mStackNum == 0) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
FreeEBCStack (
  VOID
  )
{
  UINTN  Index;
 
  for (Index = 0; Index < mStackNum; Index++) {
    FreePool (mStackBuffer[Index]);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
InitEbcVmTestProtocol (
  IN EFI_HANDLE  *IHandle
  )
{
  EFI_HANDLE                Handle;
  EFI_STATUS                Status;
  EFI_EBC_VM_TEST_PROTOCOL  *EbcVmTestProtocol;
 
  //
  // Allocate memory for the protocol, then fill in the fields
  //
  EbcVmTestProtocol = AllocatePool (sizeof (EFI_EBC_VM_TEST_PROTOCOL));
  if (EbcVmTestProtocol == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  EbcVmTestProtocol->Execute = (EBC_VM_TEST_EXECUTE)EbcExecuteInstructions;
 
  DEBUG_CODE_BEGIN ();
  EbcVmTestProtocol->Assemble    = (EBC_VM_TEST_ASM)EbcVmTestUnsupported;
  EbcVmTestProtocol->Disassemble = (EBC_VM_TEST_DASM)EbcVmTestUnsupported;
  DEBUG_CODE_END ();
 
  //
  // Publish the protocol
  //
  Handle = NULL;
  Status = gBS->InstallProtocolInterface (&Handle, &gEfiEbcVmTestProtocolGuid, EFI_NATIVE_INTERFACE, EbcVmTestProtocol);
  if (EFI_ERROR (Status)) {
    FreePool (EbcVmTestProtocol);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EbcVmTestUnsupported (
  VOID
  )
{
  return EFI_UNSUPPORTED;
}
 
VOID *
EFIAPI
EbcAllocatePoolForThunk (
  IN UINTN  AllocationSize
  )
{
  VOID        *Buffer;
  EFI_STATUS  Status;
 
  Status = gBS->AllocatePool (EfiBootServicesCode, AllocationSize, &Buffer);
  if (EFI_ERROR (Status)) {
    return NULL;
  }
 
  return Buffer;
}