public inbox for devel@edk2.groups.io
 help / color / mirror / Atom feed
From: Ard Biesheuvel <ard.biesheuvel@linaro.org>
To: Leif Lindholm <leif.lindholm@linaro.org>
Cc: edk2-devel-01 <edk2-devel@lists.01.org>,
	Feng Tian <feng.tian@intel.com>,  Star Zeng <star.zeng@intel.com>,
	Laszlo Ersek <lersek@redhat.com>
Subject: Re: [PATCH 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM support
Date: Wed, 17 Aug 2016 15:46:36 +0200	[thread overview]
Message-ID: <CAKv+Gu8o0Ni-LNVHX7PgTURs5q_uuMhL9=MtFt+m0dV2Ruk5aw@mail.gmail.com> (raw)
In-Reply-To: <1471441502-21873-2-git-send-email-leif.lindholm@linaro.org>

On 17 August 2016 at 15:45, Leif Lindholm <leif.lindholm@linaro.org> wrote:
> From: Jeff Brasen <jbrasen@codeaurora.org>
>
> Adds support for the EBC VM for AARCH64 platforms
>
> Submitted on behalf of a third-party: The Linux Foundation
> This contribution is licensed under the BSD license as found at
> http://opensource.org/licenses/bsd-license.php
>
> [Taken from https://source.codeaurora.org/external/server/edk2-blue/, branch
>  aarch64_ebc_support]
>
> Contributed-under: TianoCore Contribution Agreement 1.0
> Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>

Reviewed-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>

I have already shared some improvements to this code, but let's get
the base implementation merged first.

> ---
>  .../Universal/EbcDxe/AArch64/EbcLowLevel.S         | 135 +++++
>  MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c | 563 +++++++++++++++++++++
>  MdeModulePkg/Universal/EbcDxe/EbcDxe.inf           |   8 +-
>  3 files changed, 704 insertions(+), 2 deletions(-)
>  create mode 100644 MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S
>  create mode 100644 MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c
>
> diff --git a/MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S
> new file mode 100644
> index 0000000..e6fe947
> --- /dev/null
> +++ b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S
> @@ -0,0 +1,135 @@
> +#/** @file
> +#
> +#    This code provides low level routines that support the Virtual Machine
> +#   for option ROMs.
> +#
> +#  Copyright (c) 2015, The Linux Foundation. All rights reserved.
> +#  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
> +#  This program and the accompanying materials
> +#  are licensed and made available under the terms and conditions of the BSD License
> +#  which accompanies this distribution.  The full text of the license may be found at
> +#  http://opensource.org/licenses/bsd-license.php
> +#
> +#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> +#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +#
> +#**/
> +
> +#---------------------------------------------------------------------------
> +# Equate files needed.
> +#---------------------------------------------------------------------------
> +
> +ASM_GLOBAL ASM_PFX(CopyMem);
> +ASM_GLOBAL ASM_PFX(EbcInterpret);
> +ASM_GLOBAL ASM_PFX(ExecuteEbcImageEntryPoint);
> +
> +#****************************************************************************
> +# EbcLLCALLEX
> +#
> +# This function is called to execute an EBC CALLEX instruction.
> +# This instruction requires that we thunk out to external native
> +# code. For AArch64, we copy the VM stack into the main stack and then pop
> +# the first 8 arguments off according to the AArch64 Procedure Call Standard
> +# On return, we restore the stack pointer to its original location.
> +#
> +#****************************************************************************
> +# UINTN EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)
> +ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative);
> +ASM_PFX(EbcLLCALLEXNative):
> +      stp  x19, x20, [sp, #-16]!
> +      stp  x29, x30, [sp, #-16]!
> +
> +      mov  x19, x0
> +      mov  x20, sp
> +      sub  x2, x2, x1   // Length = NewStackPointer-FramePtr
> +      sub  sp, sp, x2
> +      sub  sp, sp, #64  // Make sure there is room for at least 8 args in the new stack
> +      mov  x0, sp
> +
> +      bl   CopyMem      // Sp, NewStackPointer, Length
> +
> +      ldp  x0, x1, [sp], #16
> +      ldp  x2, x3, [sp], #16
> +      ldp  x4, x5, [sp], #16
> +      ldp  x6, x7, [sp], #16
> +
> +      blr  x19
> +
> +      mov  sp,  x20
> +      ldp  x29, x30, [sp], #16
> +      ldp  x19, x20, [sp], #16
> +
> +      ret
> +
> +#****************************************************************************
> +# EbcLLEbcInterpret
> +#
> +# This function is called by the thunk code to handle an Native to EBC call
> +# This can handle up to 16 arguments (1-8 on in x0-x7, 9-16 are on the stack)
> +# x9 contains the Entry point that will be the first argument when
> +# EBCInterpret is called.
> +#
> +#****************************************************************************
> +ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret);
> +ASM_PFX(EbcLLEbcInterpret):
> +    stp  x29, x30, [sp, #-16]!
> +
> +    // copy the current arguments 9-16 from old location and add arg 7 to stack
> +    // keeping 16 byte stack alignment
> +    sub sp, sp, #80
> +    str x7, [sp]
> +    ldr x11, [sp, #96]
> +    str x11, [sp, #8]
> +    ldr x11, [sp, #104]
> +    str x11, [sp, #16]
> +    ldr x11, [sp, #112]
> +    str x11, [sp, #24]
> +    ldr x11, [sp, #120]
> +    str x11, [sp, #32]
> +    ldr x11, [sp, #128]
> +    str x11, [sp, #40]
> +    ldr x11, [sp, #136]
> +    str x11, [sp, #48]
> +    ldr x11, [sp, #144]
> +    str x11, [sp, #56]
> +    ldr x11, [sp, #152]
> +    str x11, [sp, #64]
> +
> +    // Shift arguments and add entry point and as argument 1
> +    mov x7, x6
> +    mov x6, x5
> +    mov x5, x4
> +    mov x4, x3
> +    mov x3, x2
> +    mov x2, x1
> +    mov x1, x0
> +    mov x0, x9
> +
> +    # call C-code
> +    bl ASM_PFX(EbcInterpret)
> +    add sp, sp, #80
> +
> +    ldp  x29, x30, [sp], #16
> +
> +    ret
> +
> +#****************************************************************************
> +# EbcLLExecuteEbcImageEntryPoint
> +#
> +# This function is called by the thunk code to handle the image entry point
> +# x9 contains the Entry point that will be the first argument when
> +# ExecuteEbcImageEntryPoint is called.
> +#
> +#****************************************************************************
> +ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint);
> +ASM_PFX(EbcLLExecuteEbcImageEntryPoint):
> +    stp  x29, x30, [sp, #-16]!
> +    # build new paramater calling convention
> +    mov  x2, x1
> +    mov  x1, x0
> +    mov  x0, x9
> +
> +    # call C-code
> +    bl ASM_PFX(ExecuteEbcImageEntryPoint)
> +    ldp  x29, x30, [sp], #16
> +    ret
> diff --git a/MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c
> new file mode 100644
> index 0000000..24436a3
> --- /dev/null
> +++ b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c
> @@ -0,0 +1,563 @@
> +/** @file
> +  This module contains EBC support routines that are customized based on
> +  the target AArch64 processor.
> +
> +Copyright (c) 2015, The Linux Foundation. All rights reserved.
> +Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
> +This program and the accompanying materials
> +are licensed and made available under the terms and conditions of the BSD License
> +which accompanies this distribution.  The full text of the license may be found at
> +http://opensource.org/licenses/bsd-license.php
> +
> +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
> +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
> +
> +**/
> +
> +#include "EbcInt.h"
> +#include "EbcExecute.h"
> +
> +//
> +// Amount of space that is not used in the stack
> +//
> +#define STACK_REMAIN_SIZE (1024 * 4)
> +
> +//
> +// This is instruction buffer used to create EBC thunk
> +//
> +#define EBC_MAGIC_SIGNATURE                0xCA112EBCCA112EBCull
> +#define EBC_ENTRYPOINT_SIGNATURE           0xAFAFAFAFAFAFAFAFull
> +#define EBC_LL_EBC_ENTRYPOINT_SIGNATURE    0xFAFAFAFAFAFAFAFAull
> +UINT8  mInstructionBufferTemplate[] = {
> +  0x03,  0x00, 0x00, 0x14, //b pc+16
> +  //
> +  // Add a magic code here to help the VM recognize the thunk..
> +  //
> +    (UINT8)(EBC_MAGIC_SIGNATURE & 0xFF),
> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 8) & 0xFF),
> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 16) & 0xFF),
> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 24) & 0xFF),
> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 32) & 0xFF),
> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 40) & 0xFF),
> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 48) & 0xFF),
> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 56) & 0xFF),
> +  0x69, 0x00, 0x00, 0x58, //ldr x9, #32
> +  0x8A, 0x00, 0x00, 0x58, //ldr x10, #40
> +  0x05, 0x00, 0x00, 0x14, //b pc+32
> +    (UINT8)(EBC_ENTRYPOINT_SIGNATURE & 0xFF),
> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 32) & 0xFF),
> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 40) & 0xFF),
> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 48) & 0xFF),
> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 56) & 0xFF),
> +    (UINT8)(EBC_LL_EBC_ENTRYPOINT_SIGNATURE & 0xFF),
> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 32) & 0xFF),
> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 40) & 0xFF),
> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 48) & 0xFF),
> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 56) & 0xFF),
> +  0x40, 0x01, 0x1F, 0xD6 //br x10
> +
> +};
> +
> +/**
> +  Begin executing an EBC image.
> +  This is used for Ebc Thunk call.
> +
> +  @return The value returned by the EBC application we're going to run.
> +
> +**/
> +UINT64
> +EFIAPI
> +EbcLLEbcInterpret (
> +  VOID
> +  );
> +
> +/**
> +  Begin executing an EBC image.
> +  This is used for Ebc image entrypoint.
> +
> +  @return The value returned by the EBC application we're going to run.
> +
> +**/
> +UINT64
> +EFIAPI
> +EbcLLExecuteEbcImageEntryPoint (
> +  VOID
> +  );
> +
> +/**
> +  Pushes a 64 bit unsigned value to the VM stack.
> +
> +  @param VmPtr  The pointer to current VM context.
> +  @param Arg    The value to be pushed.
> +
> +**/
> +VOID
> +PushU64 (
> +  IN VM_CONTEXT *VmPtr,
> +  IN UINT64     Arg
> +  )
> +{
> +  //
> +  // Advance the VM stack down, and then copy the argument to the stack.
> +  // Hope it's aligned.
> +  //
> +  VmPtr->Gpr[0] -= sizeof (UINT64);
> +  *(UINT64 *) VmPtr->Gpr[0] = Arg;
> +  return;
> +}
> +
> +
> +/**
> +  Begin executing an EBC image.
> +
> +  This is a thunk function.
> +
> +  @param  EntryPoint            The entrypoint of EBC code.
> +  @param  Arg1                  The 1st argument.
> +  @param  Arg2                  The 2nd argument.
> +  @param  Arg3                  The 3rd argument.
> +  @param  Arg4                  The 4th argument.
> +  @param  Arg5                  The 5th argument.
> +  @param  Arg6                  The 6th argument.
> +  @param  Arg7                  The 7th argument.
> +  @param  Arg8                  The 8th argument.
> +  @param  Arg9                  The 9th argument.
> +  @param  Arg10                 The 10th argument.
> +  @param  Arg11                 The 11th argument.
> +  @param  Arg12                 The 12th argument.
> +  @param  Arg13                 The 13th argument.
> +  @param  Arg14                 The 14th argument.
> +  @param  Arg15                 The 15th argument.
> +  @param  Arg16                 The 16th argument.
> +
> +  @return The value returned by the EBC application we're going to run.
> +
> +**/
> +UINT64
> +EFIAPI
> +EbcInterpret (
> +  IN UINTN      EntryPoint,
> +  IN UINTN      Arg1,
> +  IN UINTN      Arg2,
> +  IN UINTN      Arg3,
> +  IN UINTN      Arg4,
> +  IN UINTN      Arg5,
> +  IN UINTN      Arg6,
> +  IN UINTN      Arg7,
> +  IN UINTN      Arg8,
> +  IN UINTN      Arg9,
> +  IN UINTN      Arg10,
> +  IN UINTN      Arg11,
> +  IN UINTN      Arg12,
> +  IN UINTN      Arg13,
> +  IN UINTN      Arg14,
> +  IN UINTN      Arg15,
> +  IN UINTN      Arg16
> +  )
> +{
> +  //
> +  // Create a new VM context on the stack
> +  //
> +  VM_CONTEXT  VmContext;
> +  UINTN       Addr;
> +  EFI_STATUS  Status;
> +  UINTN       StackIndex;
> +
> +  //
> +  // Get the EBC entry point
> +  //
> +  Addr = EntryPoint;
> +
> +  //
> +  // Now clear out our context
> +  //
> +  ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
> +
> +  //
> +  // Set the VM instruction pointer to the correct location in memory.
> +  //
> +  VmContext.Ip = (VMIP) Addr;
> +
> +  //
> +  // Initialize the stack pointer for the EBC. Get the current system stack
> +  // pointer and adjust it down by the max needed for the interpreter.
> +  //
> +
> +  //
> +  // Adjust the VM's stack pointer down.
> +  //
> +
> +  Status = GetEBCStack((EFI_HANDLE)(UINTN)-1, &VmContext.StackPool, &StackIndex);
> +  if (EFI_ERROR(Status)) {
> +    return Status;
> +  }
> +  VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
> +  VmContext.Gpr[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
> +  VmContext.HighStackBottom = (UINTN) VmContext.Gpr[0];
> +  VmContext.Gpr[0] -= sizeof (UINTN);
> +
> +  //
> +  // Align the stack on a natural boundary.
> +  //
> +  VmContext.Gpr[0] &= ~(VM_REGISTER)(sizeof (UINTN) - 1);
> +
> +  //
> +  // Put a magic value in the stack gap, then adjust down again.
> +  //
> +  *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) VM_STACK_KEY_VALUE;
> +  VmContext.StackMagicPtr             = (UINTN *) (UINTN) VmContext.Gpr[0];
> +
> +  //
> +  // The stack upper to LowStackTop is belong to the VM.
> +  //
> +  VmContext.LowStackTop   = (UINTN) VmContext.Gpr[0];
> +
> +  //
> +  // For the worst case, assume there are 4 arguments passed in registers, store
> +  // them to VM's stack.
> +  //
> +  PushU64 (&VmContext, (UINT64) Arg16);
> +  PushU64 (&VmContext, (UINT64) Arg15);
> +  PushU64 (&VmContext, (UINT64) Arg14);
> +  PushU64 (&VmContext, (UINT64) Arg13);
> +  PushU64 (&VmContext, (UINT64) Arg12);
> +  PushU64 (&VmContext, (UINT64) Arg11);
> +  PushU64 (&VmContext, (UINT64) Arg10);
> +  PushU64 (&VmContext, (UINT64) Arg9);
> +  PushU64 (&VmContext, (UINT64) Arg8);
> +  PushU64 (&VmContext, (UINT64) Arg7);
> +  PushU64 (&VmContext, (UINT64) Arg6);
> +  PushU64 (&VmContext, (UINT64) Arg5);
> +  PushU64 (&VmContext, (UINT64) Arg4);
> +  PushU64 (&VmContext, (UINT64) Arg3);
> +  PushU64 (&VmContext, (UINT64) Arg2);
> +  PushU64 (&VmContext, (UINT64) Arg1);
> +
> +  //
> +  // Interpreter assumes 64-bit return address is pushed on the stack.
> +  // AArch64 does not do this so pad the stack accordingly.
> +  //
> +  PushU64 (&VmContext, (UINT64) 0);
> +  PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL);
> +
> +  //
> +  // For AArch64, this is where we say our return address is
> +  //
> +  VmContext.StackRetAddr  = (UINT64) VmContext.Gpr[0];
> +
> +  //
> +  // We need to keep track of where the EBC stack starts. This way, if the EBC
> +  // accesses any stack variables above its initial stack setting, then we know
> +  // it's accessing variables passed into it, which means the data is on the
> +  // VM's stack.
> +  // When we're called, on the stack (high to low) we have the parameters, the
> +  // return address, then the saved ebp. Save the pointer to the return address.
> +  // EBC code knows that's there, so should look above it for function parameters.
> +  // The offset is the size of locals (VMContext + Addr + saved ebp).
> +  // Note that the interpreter assumes there is a 16 bytes of return address on
> +  // the stack too, so adjust accordingly.
> +  //  VmContext.HighStackBottom = (UINTN)(Addr + sizeof (VmContext) + sizeof (Addr));
> +  //
> +
> +  //
> +  // Begin executing the EBC code
> +  //
> +  EbcExecute (&VmContext);
> +
> +  //
> +  // Return the value in R[7] unless there was an error
> +  //
> +  ReturnEBCStack(StackIndex);
> +  return (UINT64) VmContext.Gpr[7];
> +}
> +
> +
> +/**
> +  Begin executing an EBC image.
> +
> +  @param  EntryPoint       The entrypoint of EBC code.
> +  @param  ImageHandle      image handle for the EBC application we're executing
> +  @param  SystemTable      standard system table passed into an driver's entry
> +                           point
> +
> +  @return The value returned by the EBC application we're going to run.
> +
> +**/
> +UINT64
> +EFIAPI
> +ExecuteEbcImageEntryPoint (
> +  IN UINTN                EntryPoint,
> +  IN EFI_HANDLE           ImageHandle,
> +  IN EFI_SYSTEM_TABLE     *SystemTable
> +  )
> +{
> +  //
> +  // Create a new VM context on the stack
> +  //
> +  VM_CONTEXT  VmContext;
> +  UINTN       Addr;
> +  EFI_STATUS  Status;
> +  UINTN       StackIndex;
> +
> +  //
> +  // Get the EBC entry point
> +  //
> +  Addr = EntryPoint;
> +
> +  //
> +  // Now clear out our context
> +  //
> +  ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
> +
> +  //
> +  // Save the image handle so we can track the thunks created for this image
> +  //
> +  VmContext.ImageHandle = ImageHandle;
> +  VmContext.SystemTable = SystemTable;
> +
> +  //
> +  // Set the VM instruction pointer to the correct location in memory.
> +  //
> +  VmContext.Ip = (VMIP) Addr;
> +
> +  //
> +  // Initialize the stack pointer for the EBC. Get the current system stack
> +  // pointer and adjust it down by the max needed for the interpreter.
> +  //
> +
> +  Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex);
> +  if (EFI_ERROR(Status)) {
> +    return Status;
> +  }
> +  VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
> +  VmContext.Gpr[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
> +  VmContext.HighStackBottom = (UINTN) VmContext.Gpr[0];
> +  VmContext.Gpr[0] -= sizeof (UINTN);
> +
> +
> +  //
> +  // Put a magic value in the stack gap, then adjust down again
> +  //
> +  *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) VM_STACK_KEY_VALUE;
> +  VmContext.StackMagicPtr             = (UINTN *) (UINTN) VmContext.Gpr[0];
> +
> +  //
> +  // Align the stack on a natural boundary
> +  VmContext.Gpr[0] &= ~(VM_REGISTER)(sizeof(UINTN) - 1);
> +  //
> +  VmContext.LowStackTop   = (UINTN) VmContext.Gpr[0];
> +
> +  //
> +  // Simply copy the image handle and system table onto the EBC stack.
> +  // Greatly simplifies things by not having to spill the args.
> +  //
> +  PushU64 (&VmContext, (UINT64) SystemTable);
> +  PushU64 (&VmContext, (UINT64) ImageHandle);
> +
> +  //
> +  // VM pushes 16-bytes for return address. Simulate that here.
> +  //
> +  PushU64 (&VmContext, (UINT64) 0);
> +  PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL);
> +
> +  //
> +  // For AArch64, this is where we say our return address is
> +  //
> +  VmContext.StackRetAddr  = (UINT64) VmContext.Gpr[0];
> +
> +  //
> +  // Entry function needn't access high stack context, simply
> +  // put the stack pointer here.
> +  //
> +
> +  //
> +  // Begin executing the EBC code
> +  //
> +  EbcExecute (&VmContext);
> +
> +  //
> +  // Return the value in R[7] unless there was an error
> +  //
> +  ReturnEBCStack(StackIndex);
> +  return (UINT64) VmContext.Gpr[7];
> +}
> +
> +
> +/**
> +  Create thunks for an EBC image entry point, or an EBC protocol service.
> +
> +  @param  ImageHandle           Image handle for the EBC image. If not null, then
> +                                we're creating a thunk for an image entry point.
> +  @param  EbcEntryPoint         Address of the EBC code that the thunk is to call
> +  @param  Thunk                 Returned thunk we create here
> +  @param  Flags                 Flags indicating options for creating the thunk
> +
> +  @retval EFI_SUCCESS           The thunk was created successfully.
> +  @retval EFI_INVALID_PARAMETER The parameter of EbcEntryPoint is not 16-bit
> +                                aligned.
> +  @retval EFI_OUT_OF_RESOURCES  There is not enough memory to created the EBC
> +                                Thunk.
> +  @retval EFI_BUFFER_TOO_SMALL  EBC_THUNK_SIZE is not larger enough.
> +
> +**/
> +EFI_STATUS
> +EbcCreateThunks (
> +  IN EFI_HANDLE           ImageHandle,
> +  IN VOID                 *EbcEntryPoint,
> +  OUT VOID                **Thunk,
> +  IN  UINT32              Flags
> +  )
> +{
> +  UINT8       *Ptr;
> +  UINT8       *ThunkBase;
> +  UINT32      Index;
> +  INT32       ThunkSize;
> +
> +  //
> +  // Check alignment of pointer to EBC code
> +  //
> +  if ((UINT32) (UINTN) EbcEntryPoint & 0x01) {
> +    return EFI_INVALID_PARAMETER;
> +  }
> +
> +  ThunkSize = sizeof(mInstructionBufferTemplate);
> +
> +  Ptr = AllocatePool (sizeof(mInstructionBufferTemplate));
> +
> +  if (Ptr == NULL) {
> +    return EFI_OUT_OF_RESOURCES;
> +  }
> +  //
> +  //  Print(L"Allocate TH: 0x%X\n", (UINT32)Ptr);
> +  //
> +  // Save the start address so we can add a pointer to it to a list later.
> +  //
> +  ThunkBase = Ptr;
> +
> +  //
> +  // Give them the address of our buffer we're going to fix up
> +  //
> +  *Thunk = (VOID *) Ptr;
> +
> +  //
> +  // Copy whole thunk instruction buffer template
> +  //
> +  CopyMem (Ptr, mInstructionBufferTemplate, sizeof(mInstructionBufferTemplate));
> +
> +  //
> +  // Patch EbcEntryPoint and EbcLLEbcInterpret
> +  //
> +  for (Index = 0; Index < sizeof(mInstructionBufferTemplate) - sizeof(UINTN); Index++) {
> +    if (*(UINTN *)&Ptr[Index] == EBC_ENTRYPOINT_SIGNATURE) {
> +      *(UINTN *)&Ptr[Index] = (UINTN)EbcEntryPoint;
> +    }
> +    if (*(UINTN *)&Ptr[Index] == EBC_LL_EBC_ENTRYPOINT_SIGNATURE) {
> +      if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {
> +        *(UINTN *)&Ptr[Index] = (UINTN)EbcLLExecuteEbcImageEntryPoint;
> +      } else {
> +        *(UINTN *)&Ptr[Index] = (UINTN)EbcLLEbcInterpret;
> +      }
> +    }
> +  }
> +
> +  //
> +  // Add the thunk to the list for this image. Do this last since the add
> +  // function flushes the cache for us.
> +  //
> +  EbcAddImageThunk (ImageHandle, (VOID *) ThunkBase, ThunkSize);
> +
> +  return EFI_SUCCESS;
> +}
> +
> +
> +/**
> +  This function is called to execute an EBC CALLEX instruction.
> +  The function check the callee's content to see whether it is common native
> +  code or a thunk to another piece of EBC code.
> +  If the callee is common native code, use EbcLLCAllEXASM to manipulate,
> +  otherwise, set the VM->IP to target EBC code directly to avoid another VM
> +  be startup which cost time and stack space.
> +
> +  @param  VmPtr            Pointer to a VM context.
> +  @param  FuncAddr         Callee's address
> +  @param  NewStackPointer  New stack pointer after the call
> +  @param  FramePtr         New frame pointer after the call
> +  @param  Size             The size of call instruction
> +
> +**/
> +VOID
> +EbcLLCALLEX (
> +  IN VM_CONTEXT   *VmPtr,
> +  IN UINTN        FuncAddr,
> +  IN UINTN        NewStackPointer,
> +  IN VOID         *FramePtr,
> +  IN UINT8        Size
> +  )
> +{
> +  UINTN    IsThunk;
> +  UINTN    TargetEbcAddr;
> +  UINT8    InstructionBuffer[sizeof(mInstructionBufferTemplate)];
> +  UINTN    Index;
> +  UINTN    IndexOfEbcEntrypoint;
> +
> +  IsThunk       = 1;
> +  TargetEbcAddr = 0;
> +  IndexOfEbcEntrypoint = 0;
> +
> +  //
> +  // Processor specific code to check whether the callee is a thunk to EBC.
> +  //
> +  CopyMem (InstructionBuffer, (VOID *)FuncAddr, sizeof(InstructionBuffer));
> +  //
> +  // Fill the signature according to mInstructionBufferTemplate
> +  //
> +  for (Index = 0; Index < sizeof(mInstructionBufferTemplate) - sizeof(UINTN); Index++) {
> +    if (*(UINTN *)&mInstructionBufferTemplate[Index] == EBC_ENTRYPOINT_SIGNATURE) {
> +      *(UINTN *)&InstructionBuffer[Index] = EBC_ENTRYPOINT_SIGNATURE;
> +      IndexOfEbcEntrypoint = Index;
> +    }
> +    if (*(UINTN *)&mInstructionBufferTemplate[Index] == EBC_LL_EBC_ENTRYPOINT_SIGNATURE) {
> +      *(UINTN *)&InstructionBuffer[Index] = EBC_LL_EBC_ENTRYPOINT_SIGNATURE;
> +    }
> +  }
> +  //
> +  // Check if we need thunk to native
> +  //
> +  if (CompareMem (InstructionBuffer, mInstructionBufferTemplate, sizeof(mInstructionBufferTemplate)) != 0) {
> +    IsThunk = 0;
> +  }
> +
> +  if (IsThunk == 1){
> +    //
> +    // The callee is a thunk to EBC, adjust the stack pointer down 16 bytes and
> +    // put our return address and frame pointer on the VM stack.
> +    // Then set the VM's IP to new EBC code.
> +    //
> +    VmPtr->Gpr[0] -= 8;
> +    VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr);
> +    VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->Gpr[0];
> +    VmPtr->Gpr[0] -= 8;
> +    VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (UINTN) (VmPtr->Ip + Size));
> +
> +    CopyMem (&TargetEbcAddr, (UINT8 *)FuncAddr + IndexOfEbcEntrypoint, sizeof(UINTN));
> +    VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr;
> +  } else {
> +    //
> +    // The callee is not a thunk to EBC, call native code,
> +    // and get return value.
> +    //
> +    VmPtr->Gpr[7] = EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr);
> +
> +    //
> +    // Advance the IP.
> +    //
> +    VmPtr->Ip += Size;
> +  }
> +}
> +
> diff --git a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf b/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
> index 15dc01c..cb8022f 100644
> --- a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
> +++ b/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
> @@ -5,6 +5,7 @@
>  #  platform and processor-independent mechanisms for loading and executing EFI
>  #  device drivers.
>  #
> +#  Copyright (c) 2015, The Linux Foundation. All rights reserved.
>  #  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
>  #  This program and the accompanying materials
>  #  are licensed and made available under the terms and conditions of the BSD License
> @@ -28,7 +29,7 @@ [Defines]
>  #
>  # The following information is for reference only and not required by the build tools.
>  #
> -#  VALID_ARCHITECTURES           = IA32 X64 IPF
> +#  VALID_ARCHITECTURES           = IA32 X64 IPF AARCH64
>  #
>
>  [Sources]
> @@ -54,6 +55,9 @@ [Sources.IPF]
>    Ipf/EbcSupport.c
>    Ipf/EbcLowLevel.s
>
> +[Sources.AARCH64]
> +  AArch64/EbcSupport.c
> +  AArch64/EbcLowLevel.S
>
>  [Packages]
>    MdePkg/MdePkg.dec
> @@ -84,4 +88,4 @@ [Depex]
>  # EVENT_TYPE_PERIODIC_TIMER ## CONSUMES
>
>  [UserExtensions.TianoCore."ExtraFiles"]
> -  EbcDxeExtra.uni
> \ No newline at end of file
> +  EbcDxeExtra.uni
> --
> 2.1.4
>


  reply	other threads:[~2016-08-17 13:46 UTC|newest]

Thread overview: 13+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2016-08-17 13:45 [PATCH 0/2] Add EBC support for AArch64 Leif Lindholm
2016-08-17 13:45 ` [PATCH 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM support Leif Lindholm
2016-08-17 13:46   ` Ard Biesheuvel [this message]
2016-08-19  3:12   ` Tian, Feng
2016-08-23  4:33     ` Jordan Justen
2016-08-23  4:57       ` Tian, Feng
2016-08-26 10:56         ` Leif Lindholm
2016-08-17 13:45 ` [PATCH 2/2] ArmVirtPkg: enable EBC interpreter for AArch64 QEMU Leif Lindholm
2016-08-17 13:47   ` Ard Biesheuvel
2016-08-17 13:55     ` Laszlo Ersek
2016-08-17 14:04       ` Ard Biesheuvel
2016-08-19  1:42         ` Laszlo Ersek
2016-08-17 14:04       ` Leif Lindholm

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-list from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to='CAKv+Gu8o0Ni-LNVHX7PgTURs5q_uuMhL9=MtFt+m0dV2Ruk5aw@mail.gmail.com' \
    --to=devel@edk2.groups.io \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox