CcExitLib.c

Go to the documentation of this file.

 
#include <Base.h>
#include <Uefi.h>
#include <Library/BaseMemoryLib.h>
#include <Library/CcExitLib.h>
#include <Register/Amd/Msr.h>
 
STATIC
UINT64
VmgExitErrorCheck (
  IN GHCB  *Ghcb
  )
{
  GHCB_EVENT_INJECTION  Event;
  GHCB_EXIT_INFO        ExitInfo;
  UINT64                Status;
 
  ExitInfo.Uint64 = Ghcb->SaveArea.SwExitInfo1;
  ASSERT (
    (ExitInfo.Elements.Lower32Bits == 0) ||
    (ExitInfo.Elements.Lower32Bits == 1)
    );
 
  Status = 0;
  if (ExitInfo.Elements.Lower32Bits == 0) {
    return Status;
  }
 
  if (ExitInfo.Elements.Lower32Bits == 1) {
    ASSERT (Ghcb->SaveArea.SwExitInfo2 != 0);
 
    //
    // Check that the return event is valid
    //
    Event.Uint64 = Ghcb->SaveArea.SwExitInfo2;
    if (Event.Elements.Valid &&
        (Event.Elements.Type == GHCB_EVENT_INJECTION_TYPE_EXCEPTION))
    {
      switch (Event.Elements.Vector) {
        case GP_EXCEPTION:
        case UD_EXCEPTION:
          //
          // Use returned event as return code
          //
          Status = Event.Uint64;
      }
    }
  }
 
  if (Status == 0) {
    GHCB_EVENT_INJECTION  GpEvent;
 
    GpEvent.Uint64          = 0;
    GpEvent.Elements.Vector = GP_EXCEPTION;
    GpEvent.Elements.Type   = GHCB_EVENT_INJECTION_TYPE_EXCEPTION;
    GpEvent.Elements.Valid  = 1;
 
    Status = GpEvent.Uint64;
  }
 
  return Status;
}
 
UINT64
EFIAPI
CcExitVmgExit (
  IN OUT GHCB    *Ghcb,
  IN     UINT64  ExitCode,
  IN     UINT64  ExitInfo1,
  IN     UINT64  ExitInfo2
  )
{
  Ghcb->SaveArea.SwExitCode  = ExitCode;
  Ghcb->SaveArea.SwExitInfo1 = ExitInfo1;
  Ghcb->SaveArea.SwExitInfo2 = ExitInfo2;
 
  CcExitVmgSetOffsetValid (Ghcb, GhcbSwExitCode);
  CcExitVmgSetOffsetValid (Ghcb, GhcbSwExitInfo1);
  CcExitVmgSetOffsetValid (Ghcb, GhcbSwExitInfo2);
 
  //
  // Guest memory is used for the guest-hypervisor communication, so fence
  // the invocation of the VMGEXIT instruction to ensure GHCB accesses are
  // synchronized properly.
  //
  MemoryFence ();
  AsmVmgExit ();
  MemoryFence ();
 
  return VmgExitErrorCheck (Ghcb);
}
 
VOID
EFIAPI
CcExitVmgInit (
  IN OUT GHCB     *Ghcb,
  IN OUT BOOLEAN  *InterruptState
  )
{
  //
  // Be sure that an interrupt can't cause a #VC while the GHCB is
  // being used.
  //
  *InterruptState = GetInterruptState ();
  if (*InterruptState) {
    DisableInterrupts ();
  }
 
  SetMem (&Ghcb->SaveArea, sizeof (Ghcb->SaveArea), 0);
}
 
VOID
EFIAPI
CcExitVmgDone (
  IN OUT GHCB     *Ghcb,
  IN     BOOLEAN  InterruptState
  )
{
  if (InterruptState) {
    EnableInterrupts ();
  }
}
 
VOID
EFIAPI
CcExitVmgSetOffsetValid (
  IN OUT GHCB           *Ghcb,
  IN     GHCB_REGISTER  Offset
  )
{
  UINT32  OffsetIndex;
  UINT32  OffsetBit;
 
  OffsetIndex = Offset / 8;
  OffsetBit   = Offset % 8;
 
  Ghcb->SaveArea.ValidBitmap[OffsetIndex] |= (1 << OffsetBit);
}
 
BOOLEAN
EFIAPI
CcExitVmgIsOffsetValid (
  IN GHCB           *Ghcb,
  IN GHCB_REGISTER  Offset
  )
{
  UINT32  OffsetIndex;
  UINT32  OffsetBit;
 
  OffsetIndex = Offset / 8;
  OffsetBit   = Offset % 8;
 
  return ((Ghcb->SaveArea.ValidBitmap[OffsetIndex] & (1 << OffsetBit)) != 0);
}