ebcsupport.c

来自「Next BIOS Source code : Extensible Firmw」· C语言 代码 · 共 725 行 · 第 1/2 页

/*++

Copyright (c)  1999 - 2003 Intel Corporation. All rights reserved
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.


Module Name:

  EbcSupport.c

Abstract:

  This module contains EBC support routines that are customized based on
  the target processor.

--*/

#include "Efi.h"
#include "EfiDriverLib.h"

//
// To support the EFI debug support protocol
//
#include EFI_PROTOCOL_DEFINITION(Ebc)
#include EFI_PROTOCOL_DEFINITION(DebugSupport)

#include "EbcInt.h"
#include "EbcExecute.h"

#define VM_STACK_SIZE               (1024 * 32)

#define EBC_THUNK_SIZE              128

//
// For code execution, thunks must be aligned on 16-byte boundary
//
#define EBC_THUNK_ALIGNMENT         16

//
// Per the IA-64 Software Conventions and Runtime Architecture Guide, 
// section 3.3.4, IPF stack must always be 16-byte aligned.
//
#define IPF_STACK_ALIGNMENT         16

//
// Opcodes for IPF instructions. We'll need to hand-create thunk code (stuffing
// bits) to insert a jump to the interpreter.
//
#define OPCODE_NOP                (UINT64)0x00008000000
#define OPCODE_BR_COND_SPTK_FEW   (UINT64)0x00100000000
#define OPCODE_MOV_BX_RX          (UINT64)0x00E00100000

//
// Opcode for MOVL instruction
//
#define MOVL_OPCODE     0x06

VOID 
EbcAsmLLCALLEX (
  IN UINTN    CallAddr, 
  IN UINTN    EbcSp
  );

static
EFI_STATUS
WriteBundle (
  IN    VOID    *MemPtr,
  IN    UINT8   Template,
  IN    UINT64  Slot0,
  IN    UINT64  Slot1,
  IN    UINT64  Slot2
  );

static 
VOID 
PushU64 (
  VM_CONTEXT *VmPtr, 
  UINT64 Arg
  )
{
  //
  // Advance the VM stack down, and then copy the argument to the stack.
  // Hope it's aligned.
  //
  VmPtr->R[0] -= sizeof(UINT64);
  *(UINT64 *)VmPtr->R[0] = Arg;
}
UINT64 
EbcInterpret (
  UINT64      Arg1,
  ...
  )
{
  //
  // Create a new VM context on the stack
  //
  VM_CONTEXT      VmContext;
  UINTN           Addr;
  VA_LIST         List;
  UINT64          Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8;
  UINTN           Arg9Addr;
  //
  // Get the EBC entry point from the processor register. Make sure you don't
  // call any functions before this or you could mess up the register the
  // entry point is passed in.
  //
  Addr = EbcLLGetEbcEntryPoint ();
  //
  // Need the args off the stack.
  //
  VA_START (List, Arg1);
  Arg2 = VA_ARG(List, UINT64);
  Arg3 = VA_ARG(List, UINT64);
  Arg4 = VA_ARG(List, UINT64);
  Arg5 = VA_ARG(List, UINT64);
  Arg6 = VA_ARG(List, UINT64);
  Arg7 = VA_ARG(List, UINT64);
  Arg8 = VA_ARG(List, UINT64);
  Arg9Addr = (UINTN)List;
  //
  // Now clear out our context
  //
  EfiZeroMem ((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.
  //
  Addr = (UINTN)Arg9Addr;
  //
  // NOTE: Eventually we should have the interpreter allocate memory
  //       for stack space which it will use during its execution. This
  //       would likely improve performance because the interpreter would
  //       no longer be required to test each memory access and adjust 
  //       those reading from the stack gap.
  //
  // For IPF, the stack looks like (assuming 10 args passed)
  //   arg10
  //   arg9       (Bottom of high stack)
  //   [ stack gap for interpreter execution ]
  //   [ magic value for detection of stack corruption ]
  //   arg8       (Top of low stack)
  //   arg7....
  //   arg1
  //   [ 64-bit return address ] 
  //   [ ebc stack ]
  // If the EBC accesses memory in the stack gap, then we assume that it's
  // actually trying to access args9 and greater. Therefore we need to
  // adjust memory accesses in this region to point above the stack gap.
  //
  VmContext.HighStackBottom = (UINTN)Addr;
  //
  // Now adjust the EBC stack pointer down to leave a gap for interpreter 
  // execution. Then stuff a magic value there.
  //
  VmContext.R[0] = (UINT64)Addr;
  VmContext.R[0] -= VM_STACK_SIZE;
  PushU64 (&VmContext, (UINT64)VM_STACK_KEY_VALUE);
  VmContext.StackMagicPtr = (UINTN *)VmContext.R[0];
  VmContext.LowStackTop = (UINTN)VmContext.R[0];
  //
  // Push the EBC arguments on the stack. Does not matter that they may not
  // all be valid. 
  //
  PushU64 (&VmContext, Arg8);
  PushU64 (&VmContext, Arg7);
  PushU64 (&VmContext, Arg6);
  PushU64 (&VmContext, Arg5);
  PushU64 (&VmContext, Arg4);
  PushU64 (&VmContext, Arg3);
  PushU64 (&VmContext, Arg2);
  PushU64 (&VmContext, Arg1);
  //
  // Push a bogus return address on the EBC stack because the
  // interpreter expects one there. For stack alignment purposes on IPF,
  // EBC return addresses are always 16 bytes. Push a bogus value as well.
  //
  PushU64 (&VmContext, 0);
  PushU64 (&VmContext, 0xDEADBEEFDEADBEEF);
  VmContext.StackRetAddr = (UINT64)VmContext.R[0];
  //
  // Begin executing the EBC code
  //
  EbcExecute (&VmContext);
  //
  // Return the value in R[7] unless there was an error
  //
  return (UINT64)VmContext.R[7];
}

UINT64
ExecuteEbcImageEntryPoint (
  IN EFI_HANDLE           ImageHandle,
  IN EFI_SYSTEM_TABLE     *SystemTable
  )
/*++

Routine Description:

  IPF implementation.

  Begin executing an EBC image. The address of the entry point is passed
  in via a processor register, so we'll need to make a call to get the
  value.
  
Arguments:

  ImageHandle   - image handle for the EBC application we're executing
  SystemTable   - standard system table passed into an driver's entry point

Returns:

  The value returned by the EBC application we're going to run.

--*/
{
  //
  // Create a new VM context on the stack
  //
  VM_CONTEXT      VmContext;
  UINTN           Addr;

  //
  // Get the EBC entry point from the processor register. Make sure you don't
  // call any functions before this or you could mess up the register the
  // entry point is passed in.
  //
  Addr = EbcLLGetEbcEntryPoint ();

  //
  // Now clear out our context
  //
  EfiZeroMem ((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;

  //
  // Get the stack pointer. This is the bottom of the upper stack.
  //
  Addr = EbcLLGetStackPointer ();
  VmContext.HighStackBottom = (UINTN)Addr;
  VmContext.R[0] = (INT64)Addr;

  //
  // Allocate stack space for the interpreter. Then put a magic value
  // at the bottom so we can detect stack corruption.
  //
  VmContext.R[0] -= VM_STACK_SIZE;
  PushU64 (&VmContext, (UINT64)VM_STACK_KEY_VALUE);
  VmContext.StackMagicPtr = (UINTN *)(UINTN)VmContext.R[0];

  //
  // When we thunk to external native code, we copy the last 8 qwords from
  // the EBC stack into the processor registers, and adjust the stack pointer
  // up. If the caller is not passing 8 parameters, then we've moved the
  // stack pointer up into the stack gap. If this happens, then the caller
  // can mess up the stack gap contents (in particular our magic value). 
  // Therefore, leave another gap below the magic value. Pick 10 qwords down,
  // just as a starting point.
  //
  VmContext.R[0] -= 10 * sizeof (UINT64);

  //
  // Align the stack pointer such that after pushing the system table, 
  // image handle, and return address on the stack, it's aligned on a 16-byte
  // boundary as required for IPF.
  //
  VmContext.R[0] &= (INT64)~0x0f;
  VmContext.LowStackTop = (UINTN)VmContext.R[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);

  //
  // Interpreter assumes 64-bit return address is pushed on the stack.
  // IPF does not do this so pad the stack accordingly. Also, a 
  // "return address" is 16 bytes as required for IPF stack alignments.
  //
  PushU64 (&VmContext, (UINT64)0);
  PushU64 (&VmContext, (UINT64)0x1234567887654321);
  VmContext.StackRetAddr = (UINT64)VmContext.R[0];

  //
  // Begin executing the EBC code
  //
  EbcExecute (&VmContext);

  //
  // Return the value in R[7] unless there was an error
  //
  return (UINT64)VmContext.R[7];
}
EFI_STATUS 
EbcCreateThunks  (
  IN EFI_HANDLE   ImageHandle,
  IN VOID         *EbcEntryPoint,
  OUT VOID        **Thunk,
  IN  UINT32      Flags
  )
/*++

Routine Description:

  Create thunks for an EBC image entry point, or an EBC protocol service.
  
Arguments:

  ImageHandle     - Image handle for the EBC image. If not null, then we're
                    creating a thunk for an image entry point.
  EbcEntryPoint   - Address of the EBC code that the thunk is to call
  Thunk           - Returned thunk we create here
  Flags           - Flags indicating options for creating the thunk
  
Returns:

  Standard EFI status.
  
--*/
{
  UINT8         *Ptr, *ThunkBase;
  UINT64        Addr;
  UINT64        Code[3];    // Code in a bundle
  UINT64        RegNum;     // register number for MOVL
  UINT64        I;          // bits of MOVL immediate data
  UINT64        Ic;         // bits of MOVL immediate data
  UINT64        Imm5c;      // bits of MOVL immediate data
  UINT64        Imm9d;      // bits of MOVL immediate data
  UINT64        Imm7b;      // bits of MOVL immediate data
  UINT64        Br;         // branch register for loading and jumping
  UINT64        *Data64Ptr;
  UINT32        ThunkSize, Size;
  EFI_STATUS    Status;
        
  //
  // Check alignment of pointer to EBC code, which must always be aligned
  // on a 2-byte boundary.
  //
  if ((UINT32)(UINTN)EbcEntryPoint & 0x01) {
    return EFI_INVALID_PARAMETER;
  }
  //
  // Allocate memory for the thunk. Make the (most likely incorrect) assumption