From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by ml01.01.org (Postfix) with ESMTP id 7BA381A1E06 for ; Sun, 31 Jul 2016 18:49:38 -0700 (PDT) Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by fmsmga101.fm.intel.com with ESMTP; 31 Jul 2016 18:49:38 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.28,453,1464678000"; d="scan'208";a="742361016" Received: from fmsmsx107.amr.corp.intel.com ([10.18.124.205]) by FMSMGA003.fm.intel.com with ESMTP; 31 Jul 2016 18:49:38 -0700 Received: from fmsmsx120.amr.corp.intel.com (10.18.124.208) by fmsmsx107.amr.corp.intel.com (10.18.124.205) with Microsoft SMTP Server (TLS) id 14.3.248.2; Sun, 31 Jul 2016 18:49:38 -0700 Received: from shsmsx152.ccr.corp.intel.com (10.239.6.52) by fmsmsx120.amr.corp.intel.com (10.18.124.208) with Microsoft SMTP Server (TLS) id 14.3.248.2; Sun, 31 Jul 2016 18:49:37 -0700 Received: from shsmsx101.ccr.corp.intel.com ([169.254.1.8]) by SHSMSX152.ccr.corp.intel.com ([169.254.6.107]) with mapi id 14.03.0248.002; Mon, 1 Aug 2016 09:49:35 +0800 From: "Tian, Feng" To: Leif Lindholm , "edk2-devel@lists.01.org" CC: Jeff Brasen , Ard Biesheuvel , Daniil Egranov , "Zeng, Star" , "Tian, Feng" Thread-Topic: [RFC 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM support Thread-Index: AQHR6bMstl/1KMbMLUq1X5cdoIXLs6AzWdug Date: Mon, 1 Aug 2016 01:49:35 +0000 Message-ID: <7F1BAD85ADEA444D97065A60D2E97EE53881E396@SHSMSX101.ccr.corp.intel.com> References: <1469808369-5344-1-git-send-email-leif.lindholm@linaro.org> <1469808369-5344-2-git-send-email-leif.lindholm@linaro.org> In-Reply-To: <1469808369-5344-2-git-send-email-leif.lindholm@linaro.org> Accept-Language: zh-CN, en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.239.127.40] MIME-Version: 1.0 Subject: Re: [RFC 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM support X-BeenThere: edk2-devel@lists.01.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: EDK II Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 01 Aug 2016 01:49:38 -0000 Content-Language: en-US Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Hi, Leif If I understand correctly, EDKII doesn't allow such BSD license. Correct me if anybody has different opinions. Thanks Feng -----Original Message----- From: Leif Lindholm [mailto:leif.lindholm@linaro.org]=20 Sent: Saturday, July 30, 2016 12:06 AM To: edk2-devel@lists.01.org Cc: Jeff Brasen ; Ard Biesheuvel ; Daniil Egranov ; Tian, Feng ; Zeng, Star Subject: [RFC 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM support From: Jeff Brasen Adds support for the EBC VM for AARCH64 platforms Submitted on behalf of a third-party: The Linux Foundation This contributio= n is licensed under the BSD license as found at http://opensource.org/licen= ses/bsd-license.php [Taken from https://source.codeaurora.org/external/server/edk2-blue/] Signed-off-by: Leif Lindholm --- .../Universal/EbcDxe/AArch64/EbcLowLevel.S | 135 +++++ MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c | 563 +++++++++++++++++= ++++ MdeModulePkg/Universal/EbcDxe/EbcDxe.inf | 6 +- 3 files changed, 703 insertions(+), 1 deletion(-) create mode 100644 MdeM= odulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S create mode 100644 MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c diff --git a/MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S b/MdeModul= ePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S new file mode 100644 index 0000000..e858227 --- /dev/null +++ b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S @@ -0,0 +1,135 @@ +#/** @file +# +# This code provides low level routines that support the Virtual Machin= e +# for option ROMs. +# +# Copyright (c) 2015, The Linux Foundation. All rights reserved. +# Copyright (c) 2007 - 2014, Intel Corporation. All rights=20 +reserved.
# This program and the accompanying materials # are=20 +licensed and made available under the terms and conditions of the BSD=20 +License # which accompanies this distribution. The full text of the=20 +license may be found at # =20 +http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS"=20 +BASIS, # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRES= S 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 #=20 +code. For AArch64, we copy the VM stack into the main stack and then=20 +pop # the first 8 arguments off according to the AArch64 Procedure Call=20 +Standard # On return, we restore the stack pointer to its original locatio= n. +# +#********************************************************************** +****** # UINTN EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer,=20 +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 =3D 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=20 +call # This can handle up to 16 arguments (1-8 on in x0-x7, 9-16 are on=20 +the stack) # x9 contains the Entry point that will be the first=20 +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=20 +point # x9 contains the Entry point that will be the first argument=20 +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/MdeModule= Pkg/Universal/EbcDxe/AArch64/EbcSupport.c new file mode 100644 index 0000000..23261a0 --- /dev/null +++ b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c @@ -0,0 +1,563 @@ +/** @file + This module contains EBC support routines that are customized based=20 +on + the target AArch64 processor. + +Copyright (c) 2015, The Linux Foundation. All rights reserved. +Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.
=20 +This program and the accompanying materials are licensed and made=20 +available under the terms and conditions of the BSD License which=20 +accompanies this distribution. The full text of the license may be=20 +found at http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,=20 +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLI= ED. + +**/ + +#include "EbcInt.h" +#include "EbcExecute.h" + +// +// Amount of space that is not used in the stack // #define=20 +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[] =3D { + 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] -=3D sizeof (UINT64); + *(UINT64 *) VmPtr->Gpr[0] =3D 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 =3D 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 =3D (VMIP) Addr; + + // + // Initialize the stack pointer for the EBC. Get the current system=20 + stack // pointer and adjust it down by the max needed for the interprete= r. + // + + // + // Adjust the VM's stack pointer down. + // + + Status =3D GetEBCStack((EFI_HANDLE)(UINTN)-1, &VmContext.StackPool,=20 + &StackIndex); if (EFI_ERROR(Status)) { + return Status; + } + VmContext.StackTop =3D (UINT8*)VmContext.StackPool +=20 + (STACK_REMAIN_SIZE); VmContext.Gpr[0] =3D (UINT64)=20 + ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); =20 + VmContext.HighStackBottom =3D (UINTN) VmContext.Gpr[0]; =20 + VmContext.Gpr[0] -=3D sizeof (UINTN); + + // + // Align the stack on a natural boundary. + // + VmContext.Gpr[0] &=3D ~(VM_REGISTER)(sizeof (UINTN) - 1); + + // + // Put a magic value in the stack gap, then adjust down again. + // + *(UINTN *) (UINTN) (VmContext.Gpr[0]) =3D (UINTN) VM_STACK_KEY_VALUE; + VmContext.StackMagicPtr =3D (UINTN *) (UINTN) VmContext.Gpr[= 0]; + + // + // The stack upper to LowStackTop is belong to the VM. + // + VmContext.LowStackTop =3D (UINTN) VmContext.Gpr[0]; + + // + // For the worst case, assume there are 4 arguments passed in=20 + 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 // =20 + VmContext.StackRetAddr =3D (UINT64) VmContext.Gpr[0]; + + // + // We need to keep track of where the EBC stack starts. This way, if=20 + the EBC // accesses any stack variables above its initial stack=20 + setting, then we know // it's accessing variables passed into it,=20 + which means the data is on the // VM's stack. + // When we're called, on the stack (high to low) we have the=20 + 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 par= ameters. + // The offset is the size of locals (VMContext + Addr + saved ebp). + // Note that the interpreter assumes there is a 16 bytes of return=20 + address on // the stack too, so adjust accordingly. + // VmContext.HighStackBottom =3D (UINTN)(Addr + sizeof (VmContext) +=20 + 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 exec= uting + @param SystemTable standard system table passed into an driver's e= ntry + 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 =3D 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=20 + image // VmContext.ImageHandle =3D ImageHandle; VmContext.SystemTable= =20 + =3D SystemTable; + + // + // Set the VM instruction pointer to the correct location in memory. + // + VmContext.Ip =3D (VMIP) Addr; + + // + // Initialize the stack pointer for the EBC. Get the current system=20 + stack // pointer and adjust it down by the max needed for the interprete= r. + // + + Status =3D GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex); = =20 + if (EFI_ERROR(Status)) { + return Status; + } + VmContext.StackTop =3D (UINT8*)VmContext.StackPool +=20 + (STACK_REMAIN_SIZE); VmContext.Gpr[0] =3D (UINT64)=20 + ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); =20 + VmContext.HighStackBottom =3D (UINTN) VmContext.Gpr[0]; =20 + VmContext.Gpr[0] -=3D sizeof (UINTN); + + + // + // Put a magic value in the stack gap, then adjust down again // =20 + *(UINTN *) (UINTN) (VmContext.Gpr[0]) =3D (UINTN) VM_STACK_KEY_VALUE; + VmContext.StackMagicPtr =3D (UINTN *) (UINTN) VmContext.Gpr[= 0]; + + // + // Align the stack on a natural boundary VmContext.Gpr[0] &=3D=20 + ~(VM_REGISTER)(sizeof(UINTN) - 1); // + VmContext.LowStackTop =3D (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 // =20 + VmContext.StackRetAddr =3D (UINT64) VmContext.Gpr[0]; + + // + // Entry function needn't access high stack context, simply // put=20 + 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 nul= l, 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-b= it + 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)=20 + EbcEntryPoint & 0x01) { + return EFI_INVALID_PARAMETER; + } + + ThunkSize =3D sizeof(mInstructionBufferTemplate); + + Ptr =3D AllocatePool (sizeof(mInstructionBufferTemplate)); + + if (Ptr =3D=3D NULL) { + return EFI_OUT_OF_RESOURCES; + } + // + // Print(L"Allocate TH: 0x%X\n", (UINT32)Ptr); // // Save the=20 + start address so we can add a pointer to it to a list later. + // + ThunkBase =3D Ptr; + + // + // Give them the address of our buffer we're going to fix up // =20 + *Thunk =3D (VOID *) Ptr; + + // + // Copy whole thunk instruction buffer template // CopyMem (Ptr,=20 + mInstructionBufferTemplate, sizeof(mInstructionBufferTemplate)); + + // + // Patch EbcEntryPoint and EbcLLEbcInterpret // for (Index =3D 0;=20 + Index < sizeof(mInstructionBufferTemplate) - sizeof(UINTN); Index++) { + if (*(UINTN *)&Ptr[Index] =3D=3D EBC_ENTRYPOINT_SIGNATURE) { + *(UINTN *)&Ptr[Index] =3D (UINTN)EbcEntryPoint; + } + if (*(UINTN *)&Ptr[Index] =3D=3D EBC_LL_EBC_ENTRYPOINT_SIGNATURE) { + if ((Flags & FLAG_THUNK_ENTRY_POINT) !=3D 0) { + *(UINTN *)&Ptr[Index] =3D (UINTN)EbcLLExecuteEbcImageEntryPoint; + } else { + *(UINTN *)&Ptr[Index] =3D (UINTN)EbcLLEbcInterpret; + } + } + } + + // + // Add the thunk to the list for this image. Do this last since the=20 + 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=20 +native + code or a thunk to another piece of EBC code. + If the callee is common native code, use EbcLLCAllEXASM to=20 +manipulate, + otherwise, set the VM->IP to target EBC code directly to avoid=20 +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 =3D 1; + TargetEbcAddr =3D 0; + IndexOfEbcEntrypoint =3D 0; + + // + // Processor specific code to check whether the callee is a thunk to EBC= . + // + CopyMem (InstructionBuffer, (VOID *)FuncAddr,=20 + sizeof(InstructionBuffer)); // // Fill the signature according to=20 + mInstructionBufferTemplate // for (Index =3D 0; Index <=20 + sizeof(mInstructionBufferTemplate) - sizeof(UINTN); Index++) { + if (*(UINTN *)&mInstructionBufferTemplate[Index] =3D=3D EBC_ENTRYPOINT= _SIGNATURE) { + *(UINTN *)&InstructionBuffer[Index] =3D EBC_ENTRYPOINT_SIGNATURE; + IndexOfEbcEntrypoint =3D Index; + } + if (*(UINTN *)&mInstructionBufferTemplate[Index] =3D=3D EBC_LL_EBC_ENT= RYPOINT_SIGNATURE) { + *(UINTN *)&InstructionBuffer[Index] =3D EBC_LL_EBC_ENTRYPOINT_SIGNAT= URE; + } + } + // + // Check if we need thunk to native + // + if (CompareMem (InstructionBuffer, mInstructionBufferTemplate, sizeof(mI= nstructionBufferTemplate)) !=3D 0) { + IsThunk =3D 0; + } + + if (IsThunk =3D=3D 1){ + // + // The callee is a thunk to EBC, adjust the stack pointer down 16 byte= s 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] -=3D 8; + VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr); + VmPtr->FramePtr =3D (VOID *) (UINTN) VmPtr->Gpr[0]; + VmPtr->Gpr[0] -=3D 8; + VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (UINTN)=20 + (VmPtr->Ip + Size)); + + CopyMem (&TargetEbcAddr, (UINT8 *)FuncAddr + IndexOfEbcEntrypoint, siz= eof(UINTN)); + VmPtr->Ip =3D (VMIP) (UINTN) TargetEbcAddr; } else { + // + // The callee is not a thunk to EBC, call native code, + // and get return value. + // + VmPtr->Gpr[7] =3D EbcLLCALLEXNative (FuncAddr, NewStackPointer,=20 + FramePtr); + + // + // Advance the IP. + // + VmPtr->Ip +=3D Size; + } +} + diff --git a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf b/MdeModulePkg/Univer= sal/EbcDxe/EbcDxe.inf index 15dc01c..e9a0b28 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.
= # This program and the accompanying materials # are licensed and made a= vailable under the terms and conditions of the BSD License @@ -28,7 +29,7 @= @ [Defines] # # The following information is for reference only and not r= equired by the build tools. # -# VALID_ARCHITECTURES =3D IA32 X64 IPF +# VALID_ARCHITECTURES =3D IA32 X64 IPF AARCH64 # =20 [Sources] @@ -54,6 +55,9 @@ [Sources.IPF] Ipf/EbcSupport.c Ipf/EbcLowLevel.s =20 +[Sources.AARCH64] + AArch64/EbcSupport.c + AArch64/EbcLowLevel.S =20 [Packages] MdePkg/MdePkg.dec -- 2.1.4