From d7dec593eaf18c9c2e197e92a4434e21c4f8e9b7 Mon Sep 17 00:00:00 2001 From: qhuang8 Date: Wed, 27 Jun 2007 14:52:40 +0000 Subject: [PATCH] Add EBC, FTW, Crc32SectionExtract, NullMemoryTest modules. CrcSectionExtract cannot build for now for some missing definitions. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2813 6f19259b-4bc3-4df7-8a09-765794883524 --- MdeModulePkg/MdeModulePkg.dsc | 8 + .../Capsule/RuntimeDxe/CapsuleRuntime.inf | 4 +- MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs | 25 + MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf | 108 + MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa | 80 + MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c | 4564 +++++++++++++++++ MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h | 323 ++ MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c | 1172 +++++ MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h | 283 + .../Universal/Ebc/Dxe/Ia32/EbcLowLevel.S | 54 + .../Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm | 163 + .../Universal/Ebc/Dxe/Ia32/EbcSupport.c | 545 ++ .../Universal/Ebc/Dxe/Ipf/EbcLowLevel.s | 197 + .../Universal/Ebc/Dxe/Ipf/EbcSupport.c | 869 ++++ .../Universal/Ebc/Dxe/Ipf/EbcSupport.h | 56 + .../Universal/Ebc/Dxe/x64/EbcLowLevel.S | 144 + .../Universal/Ebc/Dxe/x64/EbcLowLevel.asm | 154 + .../Universal/Ebc/Dxe/x64/EbcSupport.c | 619 +++ .../FaultTolerantWriteLite/Dxe/FtwLite.c | 931 ++++ .../FaultTolerantWriteLite/Dxe/FtwLite.dxs | 27 + .../FaultTolerantWriteLite/Dxe/FtwLite.h | 695 +++ .../FaultTolerantWriteLite/Dxe/FtwLite.inf | 133 + .../FaultTolerantWriteLite/Dxe/FtwLite.msa | 103 + .../FaultTolerantWriteLite/Dxe/FtwMisc.c | 530 ++ .../FaultTolerantWriteLite/Dxe/FtwWorkSpace.c | 561 ++ .../Dxe/Ia32/Ia32FtwMisc.c | 403 ++ .../Dxe/Ipf/IpfFtwMisc.c | 143 + .../Dxe/x64/x64FtwMisc.c | 140 + .../Dxe/Crc32SectionExtract.c | 230 + .../Dxe/Crc32SectionExtract.dxs | 26 + .../Dxe/Crc32SectionExtract.h | 112 + .../Dxe/Crc32SectionExtract.inf | 88 + .../Dxe/Crc32SectionExtract.msa | 66 + .../Crc32SectionExtract/Dxe/GuidedSection.c | 61 + .../Crc32SectionExtract/Dxe/GuidedSection.h | 54 + .../GenericMemoryTest/Dxe/NullMemoryTest.c | 214 + .../GenericMemoryTest/Dxe/NullMemoryTest.dxs | 25 + .../GenericMemoryTest/Dxe/NullMemoryTest.h | 124 + .../GenericMemoryTest/Dxe/NullMemoryTest.inf | 88 + .../GenericMemoryTest/Dxe/NullMemoryTest.msa | 64 + 40 files changed, 14183 insertions(+), 3 deletions(-) create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.S create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcSupport.c create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.S create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.asm create mode 100644 MdeModulePkg/Universal/Ebc/Dxe/x64/EbcSupport.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.dxs create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.h create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.inf create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.msa create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwMisc.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwWorkSpace.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/Ia32/Ia32FtwMisc.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/Ipf/IpfFtwMisc.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/x64/x64FtwMisc.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.dxs create mode 100644 MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.h create mode 100644 MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.inf create mode 100644 MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.msa create mode 100644 MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/GuidedSection.c create mode 100644 MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/GuidedSection.h create mode 100644 MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.c create mode 100644 MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.dxs create mode 100644 MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.h create mode 100644 MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.inf create mode 100644 MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.msa diff --git a/MdeModulePkg/MdeModulePkg.dsc b/MdeModulePkg/MdeModulePkg.dsc index 680a113b48..f574cc8e00 100644 --- a/MdeModulePkg/MdeModulePkg.dsc +++ b/MdeModulePkg/MdeModulePkg.dsc @@ -289,6 +289,10 @@ PcdUefiLibMaxPrintBufferSize|gEfiMdePkgTokenSpaceGuid|320 PcdMaxSizeNonPopulateCapsule|gEfiEdkModulePkgTokenSpaceGuid|0x0 PcdMaxSizePopulateCapsule|gEfiEdkModulePkgTokenSpaceGuid|0x0 + PcdFlashNvStorageFtwSpareBase|gEfiGenericPlatformTokenSpaceGuid|0x0 + PcdFlashNvStorageFtwSpareSize|gEfiGenericPlatformTokenSpaceGuid|0x0 + PcdFlashNvStorageFtwWorkingBase|gEfiGenericPlatformTokenSpaceGuid|0x0 + PcdFlashNvStorageFtwWorkingSize|gEfiGenericPlatformTokenSpaceGuid|0x0 [PcdsPatchableInModule.common] PcdDebugPrintErrorLevel|gEfiMdePkgTokenSpaceGuid|0x80000000 @@ -309,4 +313,8 @@ ${WORKSPACE}/MdeModulePkg/Universal/Disk/Partition/Dxe/Partition.inf ${WORKSPACE}/MdeModulePkg/Universal/Security/SecurityStub/Dxe/SecurityStub.inf ${WORKSPACE}/MdeModulePkg/Universal/Capsule/RuntimeDxe/CapsuleRuntime.inf + ${WORKSPACE}/MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf + ${WORKSPACE}/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.inf + ${WORKSPACE}/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.inf + #${WORKSPACE}/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.inf ${WORKSPACE}/MdeModulePkg/Bus/Pci/AtapiPassThru/Dxe/AtapiPassThru.inf diff --git a/MdeModulePkg/Universal/Capsule/RuntimeDxe/CapsuleRuntime.inf b/MdeModulePkg/Universal/Capsule/RuntimeDxe/CapsuleRuntime.inf index e733d79400..e599ebde1a 100644 --- a/MdeModulePkg/Universal/Capsule/RuntimeDxe/CapsuleRuntime.inf +++ b/MdeModulePkg/Universal/Capsule/RuntimeDxe/CapsuleRuntime.inf @@ -57,10 +57,8 @@ ################################################################################ [Packages] - MdeModulePkg/MdeModulePkg.dec - IntelFrameworkPkg/IntelFrameworkPkg.dec MdePkg/MdePkg.dec - + IntelFrameworkPkg/IntelFrameworkPkg.dec ################################################################################ # diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs new file mode 100644 index 0000000000..4b083dd945 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs @@ -0,0 +1,25 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + Ebc.dxs + +Abstract: + + Dependency expression file for EBC VM. + +--*/ +#include + +DEPENDENCY_START + TRUE +DEPENDENCY_END diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf new file mode 100644 index 0000000000..7367062b31 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf @@ -0,0 +1,108 @@ +#/** @file +# Component description file for Ebc module. +# +# This module for the EBC virtual machine implementation produces +# EBC and EBC debug support protocols. +# Copyright (c) 2006 - 2007, Intel Corporation +# +# All rights reserved. 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = Ebc + FILE_GUID = 13AC6DD0-73D0-11D4-B06B-00AA00BD6DE7 + MODULE_TYPE = DXE_DRIVER + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = InitializeEbcDriver + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + Ebc.dxs + EbcExecute.h + EbcExecute.c + EbcInt.h + EbcInt.c + +[Sources.Ia32] + Ia32/EbcSupport.c + Ia32/EbcLowLevel.S + Ia32/EbcLowLevel.asm + +[Sources.X64] + x64/EbcSupport.c + x64/EbcLowLevel.S + x64/EbcLowLevel.asm + +[Sources.IPF] + Ipf/EbcSupport.h + Ipf/EbcSupport.c + Ipf/EbcLowLevel.s + + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + MdePkg/MdePkg.dec + IntelFrameworkPkg/IntelFrameworkPkg.dec + + + +################################################################################ +# +# Library Class Section - list of Library Classes that are required for +# this module. +# +################################################################################ + +[LibraryClasses] + MemoryAllocationLib + UefiBootServicesTableLib + BaseMemoryLib + UefiDriverEntryPoint + DebugLib + BaseLib + + +################################################################################ +# +# Protocol C Name Section - list of Protocol and Protocol Notify C Names +# that this module uses or produces. +# +################################################################################ + +[Protocols] + gEfiDebugSupportProtocolGuid # PROTOCOL ALWAYS_PRODUCED + gEfiEbcProtocolGuid # PROTOCOL ALWAYS_PRODUCED + diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa new file mode 100644 index 0000000000..957f7008db --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa @@ -0,0 +1,80 @@ + + + + Ebc + DXE_DRIVER + 13AC6DD0-73D0-11D4-B06B-00AA00BD6DE7 + 1.0 + Component description file for Ebc module. + This module for the EBC virtual machine implementation produces + EBC and EBC debug support protocols. + Copyright (c) 2006 - 2007, Intel Corporation + All rights reserved. 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 X64 IPF + false + Ebc + + + + BaseLib + + + DebugLib + + + UefiDriverEntryPoint + + + BaseMemoryLib + + + UefiBootServicesTableLib + + + MemoryAllocationLib + + + + EbcInt.c + EbcInt.h + EbcExecute.c + EbcExecute.h + Ebc.dxs + Ia32/EbcLowLevel.asm + Ia32/EbcLowLevel.S + Ia32/EbcSupport.c + x64/EbcLowLevel.asm + x64/EbcLowLevel.S + x64/EbcSupport.c + Ipf/EbcLowLevel.s + Ipf/EbcSupport.c + Ipf/EbcSupport.h + + + + + + + + gEfiEbcProtocolGuid + + + gEfiDebugSupportProtocolGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + InitializeEbcDriver + + + diff --git a/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c b/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c new file mode 100644 index 0000000000..174e774de3 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c @@ -0,0 +1,4564 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + EbcExecute.c + +Abstract: + + Contains code that implements the virtual machine. + +--*/ + +#include "EbcInt.h" +#include "EbcExecute.h" + + +// +// Define some useful data size constants to allow switch statements based on +// size of operands or data. +// +#define DATA_SIZE_INVALID 0 +#define DATA_SIZE_8 1 +#define DATA_SIZE_16 2 +#define DATA_SIZE_32 4 +#define DATA_SIZE_64 8 +#define DATA_SIZE_N 48 // 4 or 8 +// +// Structure we'll use to dispatch opcodes to execute functions. +// +typedef struct { + EFI_STATUS (*ExecuteFunction) (IN VM_CONTEXT * VmPtr); +} +VM_TABLE_ENTRY; + +typedef +UINT64 +(*DATA_MANIP_EXEC_FUNCTION) ( + IN VM_CONTEXT * VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +INT16 +VmReadIndex16 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 CodeOffset + ); + +STATIC +INT32 +VmReadIndex32 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 CodeOffset + ); + +STATIC +INT64 +VmReadIndex64 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 CodeOffset + ); + +STATIC +UINT8 +VmReadMem8 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ); + +STATIC +UINT16 +VmReadMem16 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ); + +STATIC +UINT32 +VmReadMem32 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ); + +STATIC +UINT64 +VmReadMem64 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ); + +STATIC +UINTN +VmReadMemN ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ); + +STATIC +EFI_STATUS +VmWriteMem8 ( + IN VM_CONTEXT *VmPtr, + UINTN Addr, + IN UINT8 Data + ); + +STATIC +EFI_STATUS +VmWriteMem16 ( + IN VM_CONTEXT *VmPtr, + UINTN Addr, + IN UINT16 Data + ); + +STATIC +EFI_STATUS +VmWriteMem32 ( + IN VM_CONTEXT *VmPtr, + UINTN Addr, + IN UINT32 Data + ); + +STATIC +UINT16 +VmReadCode16 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ); + +STATIC +UINT32 +VmReadCode32 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ); + +STATIC +UINT64 +VmReadCode64 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ); + +STATIC +INT8 +VmReadImmed8 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ); + +STATIC +INT16 +VmReadImmed16 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ); + +STATIC +INT32 +VmReadImmed32 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ); + +STATIC +INT64 +VmReadImmed64 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ); + +STATIC +UINTN +ConvertStackAddr ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ); + +STATIC +EFI_STATUS +ExecuteDataManip ( + IN VM_CONTEXT *VmPtr, + IN BOOLEAN IsSignedOperation + ); + +// +// Functions that execute VM opcodes +// +STATIC +EFI_STATUS +ExecuteBREAK ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteJMP ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteJMP8 ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteCALL ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteRET ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteCMP ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteCMPI ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteMOVxx ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteMOVI ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteMOVIn ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteMOVREL ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecutePUSHn ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecutePUSH ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecutePOPn ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecutePOP ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteSignedDataManip ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteUnsignedDataManip ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteLOADSP ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteSTORESP ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteMOVsnd ( + IN VM_CONTEXT *VmPtr + ); + +STATIC +EFI_STATUS +ExecuteMOVsnw ( + IN VM_CONTEXT *VmPtr + ); + +// +// Data manipulation subfunctions +// +STATIC +UINT64 +ExecuteNOT ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteNEG ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteADD ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteSUB ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteMUL ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteMULU ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteDIV ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteDIVU ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteMOD ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteMODU ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteAND ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteOR ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteXOR ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteSHL ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteSHR ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteASHR ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteEXTNDB ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteEXTNDW ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +STATIC +UINT64 +ExecuteEXTNDD ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ); + +// +// Once we retrieve the operands for the data manipulation instructions, +// call these functions to perform the operation. +// +static CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = { + ExecuteNOT, + ExecuteNEG, + ExecuteADD, + ExecuteSUB, + ExecuteMUL, + ExecuteMULU, + ExecuteDIV, + ExecuteDIVU, + ExecuteMOD, + ExecuteMODU, + ExecuteAND, + ExecuteOR, + ExecuteXOR, + ExecuteSHL, + ExecuteSHR, + ExecuteASHR, + ExecuteEXTNDB, + ExecuteEXTNDW, + ExecuteEXTNDD, +}; + +static CONST VM_TABLE_ENTRY mVmOpcodeTable[] = { + { ExecuteBREAK }, // opcode 0x00 + { ExecuteJMP }, // opcode 0x01 + { ExecuteJMP8 }, // opcode 0x02 + { ExecuteCALL }, // opcode 0x03 + { ExecuteRET }, // opcode 0x04 + { ExecuteCMP }, // opcode 0x05 CMPeq + { ExecuteCMP }, // opcode 0x06 CMPlte + { ExecuteCMP }, // opcode 0x07 CMPgte + { ExecuteCMP }, // opcode 0x08 CMPulte + { ExecuteCMP }, // opcode 0x09 CMPugte + { ExecuteUnsignedDataManip }, // opcode 0x0A NOT + { ExecuteSignedDataManip }, // opcode 0x0B NEG + { ExecuteSignedDataManip }, // opcode 0x0C ADD + { ExecuteSignedDataManip }, // opcode 0x0D SUB + { ExecuteSignedDataManip }, // opcode 0x0E MUL + { ExecuteUnsignedDataManip }, // opcode 0x0F MULU + { ExecuteSignedDataManip }, // opcode 0x10 DIV + { ExecuteUnsignedDataManip }, // opcode 0x11 DIVU + { ExecuteSignedDataManip }, // opcode 0x12 MOD + { ExecuteUnsignedDataManip }, // opcode 0x13 MODU + { ExecuteUnsignedDataManip }, // opcode 0x14 AND + { ExecuteUnsignedDataManip }, // opcode 0x15 OR + { ExecuteUnsignedDataManip }, // opcode 0x16 XOR + { ExecuteUnsignedDataManip }, // opcode 0x17 SHL + { ExecuteUnsignedDataManip }, // opcode 0x18 SHR + { ExecuteSignedDataManip }, // opcode 0x19 ASHR + { ExecuteUnsignedDataManip }, // opcode 0x1A EXTNDB + { ExecuteUnsignedDataManip }, // opcode 0x1B EXTNDW + { ExecuteUnsignedDataManip }, // opcode 0x1C EXTNDD + { ExecuteMOVxx }, // opcode 0x1D MOVBW + { ExecuteMOVxx }, // opcode 0x1E MOVWW + { ExecuteMOVxx }, // opcode 0x1F MOVDW + { ExecuteMOVxx }, // opcode 0x20 MOVQW + { ExecuteMOVxx }, // opcode 0x21 MOVBD + { ExecuteMOVxx }, // opcode 0x22 MOVWD + { ExecuteMOVxx }, // opcode 0x23 MOVDD + { ExecuteMOVxx }, // opcode 0x24 MOVQD + { ExecuteMOVsnw }, // opcode 0x25 MOVsnw + { ExecuteMOVsnd }, // opcode 0x26 MOVsnd + { NULL }, // opcode 0x27 + { ExecuteMOVxx }, // opcode 0x28 MOVqq + { ExecuteLOADSP }, // opcode 0x29 LOADSP SP1, R2 + { ExecuteSTORESP }, // opcode 0x2A STORESP R1, SP2 + { ExecutePUSH }, // opcode 0x2B PUSH {@}R1 [imm16] + { ExecutePOP }, // opcode 0x2C POP {@}R1 [imm16] + { ExecuteCMPI }, // opcode 0x2D CMPIEQ + { ExecuteCMPI }, // opcode 0x2E CMPILTE + { ExecuteCMPI }, // opcode 0x2F CMPIGTE + { ExecuteCMPI }, // opcode 0x30 CMPIULTE + { ExecuteCMPI }, // opcode 0x31 CMPIUGTE + { ExecuteMOVxx }, // opcode 0x32 MOVN + { ExecuteMOVxx }, // opcode 0x33 MOVND + { NULL }, // opcode 0x34 + { ExecutePUSHn }, // opcode 0x35 + { ExecutePOPn }, // opcode 0x36 + { ExecuteMOVI }, // opcode 0x37 - mov immediate data + { ExecuteMOVIn }, // opcode 0x38 - mov immediate natural + { ExecuteMOVREL } // opcode 0x39 - move data relative to PC +}; + +// +// Length of JMP instructions, depending on upper two bits of opcode. +// +static CONST UINT8 mJMPLen[] = { 2, 2, 6, 10 }; + +// +// Simple Debugger Protocol GUID +// +EFI_GUID mEbcSimpleDebuggerProtocolGuid = EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL_GUID; + +EFI_STATUS +EbcExecuteInstructions ( + IN EFI_EBC_VM_TEST_PROTOCOL *This, + IN VM_CONTEXT *VmPtr, + IN OUT UINTN *InstructionCount + ) +/*++ + +Routine Description: + + Given a pointer to a new VM context, execute one or more instructions. This + function is only used for test purposes via the EBC VM test protocol. + +Arguments: + + This - pointer to protocol interface + VmPtr - pointer to a VM context + InstructionCount - how many instructions to execute. 0 if don't count. + +Returns: + + EFI_UNSUPPORTED + EFI_SUCCESS + +--*/ +{ + UINTN ExecFunc; + EFI_STATUS Status; + UINTN InstructionsLeft; + UINTN SavedInstructionCount; + + Status = EFI_SUCCESS; + + if (*InstructionCount == 0) { + InstructionsLeft = 1; + } else { + InstructionsLeft = *InstructionCount; + } + + SavedInstructionCount = *InstructionCount; + *InstructionCount = 0; + + // + // Index into the opcode table using the opcode byte for this instruction. + // This gives you the execute function, which we first test for null, then + // call it if it's not null. + // + while (InstructionsLeft != 0) { + ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & 0x3F)].ExecuteFunction; + if (ExecFunc == (UINTN) NULL) { + EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr); + return EFI_UNSUPPORTED; + } else { + mVmOpcodeTable[(*VmPtr->Ip & 0x3F)].ExecuteFunction (VmPtr); + *InstructionCount = *InstructionCount + 1; + } + + // + // Decrement counter if applicable + // + if (SavedInstructionCount != 0) { + InstructionsLeft--; + } + } + + return Status; +} + +EFI_STATUS +EbcExecute ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + Execute an EBC image from an entry point or from a published protocol. + +Arguments: + + VmPtr - pointer to prepared VM context. + +Returns: + + Standard EBC status. + +--*/ +{ + UINTN ExecFunc; + UINT8 StackCorrupted; + EFI_STATUS Status; + EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL *EbcSimpleDebugger; + + mVmPtr = VmPtr; + EbcSimpleDebugger = NULL; + Status = EFI_SUCCESS; + StackCorrupted = 0; + + // + // Make sure the magic value has been put on the stack before we got here. + // + if (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE) { + StackCorrupted = 1; + } + + VmPtr->FramePtr = (VOID *) ((UINT8 *) (UINTN) VmPtr->R[0] + 8); + + // + // Try to get the debug support for EBC + // + DEBUG_CODE_BEGIN (); + Status = gBS->LocateProtocol ( + &mEbcSimpleDebuggerProtocolGuid, + NULL, + (VOID **) &EbcSimpleDebugger + ); + if (EFI_ERROR (Status)) { + EbcSimpleDebugger = NULL; + } + DEBUG_CODE_END (); + + // + // Save the start IP for debug. For example, if we take an exception we + // can print out the location of the exception relative to the entry point, + // which could then be used in a disassembly listing to find the problem. + // + VmPtr->EntryPoint = (VOID *) VmPtr->Ip; + + // + // We'll wait for this flag to know when we're done. The RET + // instruction sets it if it runs out of stack. + // + VmPtr->StopFlags = 0; + while (!(VmPtr->StopFlags & STOPFLAG_APP_DONE)) { + // + // If we've found a simple debugger protocol, call it + // + DEBUG_CODE_BEGIN (); + if (EbcSimpleDebugger != NULL) { + EbcSimpleDebugger->Debugger (EbcSimpleDebugger, VmPtr); + } + DEBUG_CODE_END (); + + // + // Verify the opcode is in range. Otherwise generate an exception. + // + if ((*VmPtr->Ip & OPCODE_M_OPCODE) >= (sizeof (mVmOpcodeTable) / sizeof (mVmOpcodeTable[0]))) { + EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr); + Status = EFI_UNSUPPORTED; + goto Done; + } + // + // Use the opcode bits to index into the opcode dispatch table. If the + // function pointer is null then generate an exception. + // + ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction; + if (ExecFunc == (UINTN) NULL) { + EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr); + Status = EFI_UNSUPPORTED; + goto Done; + } + // + // The EBC VM is a strongly ordered processor, so perform a fence operation before + // and after each instruction is executed. + // + MemoryFence (); + + mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction (VmPtr); + + MemoryFence (); + + // + // If the step flag is set, signal an exception and continue. We don't + // clear it here. Assuming the debugger is responsible for clearing it. + // + if (VMFLAG_ISSET (VmPtr, VMFLAGS_STEP)) { + EbcDebugSignalException (EXCEPT_EBC_STEP, EXCEPTION_FLAG_NONE, VmPtr); + } + // + // Make sure stack has not been corrupted. Only report it once though. + // + if (!StackCorrupted && (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE)) { + EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr); + StackCorrupted = 1; + } + if (!StackCorrupted && ((UINT64)VmPtr->R[0] <= (UINT64)(UINTN) VmPtr->StackTop)) { + EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr); + StackCorrupted = 1; + } + } + +Done: + mVmPtr = NULL; + + return Status; +} + +STATIC +EFI_STATUS +ExecuteMOVxx ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + Execute the MOVxx instructions. + +Arguments: + + VmPtr - pointer to a VM context. + +Returns: + + EFI_UNSUPPORTED + EFI_SUCCESS + +Instruction format: + + MOV[b|w|d|q|n]{w|d} {@}R1 {Index16|32}, {@}R2 {Index16|32} + MOVqq {@}R1 {Index64}, {@}R2 {Index64} + + Copies contents of [R2] -> [R1], zero extending where required. + + First character indicates the size of the move. + Second character indicates the size of the index(s). + + Invalid to have R1 direct with index. + +--*/ +{ + UINT8 Opcode; + UINT8 OpcMasked; + UINT8 Operands; + UINT8 Size; + UINT8 MoveSize; + INT16 Index16; + INT32 Index32; + INT64 Index64Op1; + INT64 Index64Op2; + UINT64 Data64; + UINT64 DataMask; + UINTN Source; + + Opcode = GETOPCODE (VmPtr); + OpcMasked = (UINT8) (Opcode & OPCODE_M_OPCODE); + + // + // Get the operands byte so we can get R1 and R2 + // + Operands = GETOPERANDS (VmPtr); + + // + // Assume no indexes + // + Index64Op1 = 0; + Index64Op2 = 0; + Data64 = 0; + + // + // Determine if we have an index/immediate data. Base instruction size + // is 2 (opcode + operands). Add to this size each index specified. + // + Size = 2; + if (Opcode & (OPCODE_M_IMMED_OP1 | OPCODE_M_IMMED_OP2)) { + // + // Determine size of the index from the opcode. Then get it. + // + if ((OpcMasked <= OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVNW)) { + // + // MOVBW, MOVWW, MOVDW, MOVQW, and MOVNW have 16-bit immediate index. + // Get one or both index values. + // + if (Opcode & OPCODE_M_IMMED_OP1) { + Index16 = VmReadIndex16 (VmPtr, 2); + Index64Op1 = (INT64) Index16; + Size += sizeof (UINT16); + } + + if (Opcode & OPCODE_M_IMMED_OP2) { + Index16 = VmReadIndex16 (VmPtr, Size); + Index64Op2 = (INT64) Index16; + Size += sizeof (UINT16); + } + } else if ((OpcMasked <= OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVND)) { + // + // MOVBD, MOVWD, MOVDD, MOVQD, and MOVND have 32-bit immediate index + // + if (Opcode & OPCODE_M_IMMED_OP1) { + Index32 = VmReadIndex32 (VmPtr, 2); + Index64Op1 = (INT64) Index32; + Size += sizeof (UINT32); + } + + if (Opcode & OPCODE_M_IMMED_OP2) { + Index32 = VmReadIndex32 (VmPtr, Size); + Index64Op2 = (INT64) Index32; + Size += sizeof (UINT32); + } + } else if (OpcMasked == OPCODE_MOVQQ) { + // + // MOVqq -- only form with a 64-bit index + // + if (Opcode & OPCODE_M_IMMED_OP1) { + Index64Op1 = VmReadIndex64 (VmPtr, 2); + Size += sizeof (UINT64); + } + + if (Opcode & OPCODE_M_IMMED_OP2) { + Index64Op2 = VmReadIndex64 (VmPtr, Size); + Size += sizeof (UINT64); + } + } else { + // + // Obsolete MOVBQ, MOVWQ, MOVDQ, and MOVNQ have 64-bit immediate index + // + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + } + // + // Determine the size of the move, and create a mask for it so we can + // clear unused bits. + // + if ((OpcMasked == OPCODE_MOVBW) || (OpcMasked == OPCODE_MOVBD)) { + MoveSize = DATA_SIZE_8; + DataMask = 0xFF; + } else if ((OpcMasked == OPCODE_MOVWW) || (OpcMasked == OPCODE_MOVWD)) { + MoveSize = DATA_SIZE_16; + DataMask = 0xFFFF; + } else if ((OpcMasked == OPCODE_MOVDW) || (OpcMasked == OPCODE_MOVDD)) { + MoveSize = DATA_SIZE_32; + DataMask = 0xFFFFFFFF; + } else if ((OpcMasked == OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVQQ)) { + MoveSize = DATA_SIZE_64; + DataMask = (UINT64)~0; + } else if ((OpcMasked == OPCODE_MOVNW) || (OpcMasked == OPCODE_MOVND)) { + MoveSize = DATA_SIZE_N; + DataMask = (UINT64)~0 >> (64 - 8 * sizeof (UINTN)); + } else { + // + // We were dispatched to this function and we don't recognize the opcode + // + EbcDebugSignalException (EXCEPT_EBC_UNDEFINED, EXCEPTION_FLAG_FATAL, VmPtr); + return EFI_UNSUPPORTED; + } + // + // Now get the source address + // + if (OPERAND2_INDIRECT (Operands)) { + // + // Indirect form @R2. Compute address of operand2 + // + Source = (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index64Op2); + // + // Now get the data from the source. Always 0-extend and let the compiler + // sign-extend where required. + // + switch (MoveSize) { + case DATA_SIZE_8: + Data64 = (UINT64) (UINT8) VmReadMem8 (VmPtr, Source); + break; + + case DATA_SIZE_16: + Data64 = (UINT64) (UINT16) VmReadMem16 (VmPtr, Source); + break; + + case DATA_SIZE_32: + Data64 = (UINT64) (UINT32) VmReadMem32 (VmPtr, Source); + break; + + case DATA_SIZE_64: + Data64 = (UINT64) VmReadMem64 (VmPtr, Source); + break; + + case DATA_SIZE_N: + Data64 = (UINT64) (UINTN) VmReadMemN (VmPtr, Source); + break; + + default: + // + // not reached + // + break; + } + } else { + // + // Not indirect source: MOVxx {@}Rx, Ry [Index] + // + Data64 = VmPtr->R[OPERAND2_REGNUM (Operands)] + Index64Op2; + // + // Did Operand2 have an index? If so, treat as two signed values since + // indexes are signed values. + // + if (Opcode & OPCODE_M_IMMED_OP2) { + // + // NOTE: need to find a way to fix this, most likely by changing the VM + // implementation to remove the stack gap. To do that, we'd need to + // allocate stack space for the VM and actually set the system + // stack pointer to the allocated buffer when the VM starts. + // + // Special case -- if someone took the address of a function parameter + // then we need to make sure it's not in the stack gap. We can identify + // this situation if (Operand2 register == 0) && (Operand2 is direct) + // && (Index applies to Operand2) && (Index > 0) && (Operand1 register != 0) + // Situations that to be aware of: + // * stack adjustments at beginning and end of functions R0 = R0 += stacksize + // + if ((OPERAND2_REGNUM (Operands) == 0) && + (!OPERAND2_INDIRECT (Operands)) && + (Index64Op2 > 0) && + (OPERAND1_REGNUM (Operands) == 0) && + (OPERAND1_INDIRECT (Operands)) + ) { + Data64 = (UINT64) ConvertStackAddr (VmPtr, (UINTN) (INT64) Data64); + } + } + } + // + // Now write it back + // + if (OPERAND1_INDIRECT (Operands)) { + // + // Reuse the Source variable to now be dest. + // + Source = (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index64Op1); + // + // Do the write based on the size + // + switch (MoveSize) { + case DATA_SIZE_8: + VmWriteMem8 (VmPtr, Source, (UINT8) Data64); + break; + + case DATA_SIZE_16: + VmWriteMem16 (VmPtr, Source, (UINT16) Data64); + break; + + case DATA_SIZE_32: + VmWriteMem32 (VmPtr, Source, (UINT32) Data64); + break; + + case DATA_SIZE_64: + VmWriteMem64 (VmPtr, Source, Data64); + break; + + case DATA_SIZE_N: + VmWriteMemN (VmPtr, Source, (UINTN) Data64); + break; + + default: + // + // not reached + // + break; + } + } else { + // + // Operand1 direct. + // Make sure we didn't have an index on operand1. + // + if (Opcode & OPCODE_M_IMMED_OP1) { + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + // + // Direct storage in register. Clear unused bits and store back to + // register. + // + VmPtr->R[OPERAND1_REGNUM (Operands)] = Data64 & DataMask; + } + // + // Advance the instruction pointer + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteBREAK ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + Execute the EBC BREAK instruction + +Arguments: + + VmPtr - pointer to current VM context + +Returns: + + EFI_UNSUPPORTED + EFI_SUCCESS + +--*/ +{ + UINT8 Operands; + VOID *EbcEntryPoint; + VOID *Thunk; + UINT64 U64EbcEntryPoint; + INT32 Offset; + + Operands = GETOPERANDS (VmPtr); + switch (Operands) { + // + // Runaway program break. Generate an exception and terminate + // + case 0: + EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr); + break; + + // + // Get VM version -- return VM revision number in R7 + // + case 1: + // + // Bits: + // 63-17 = 0 + // 16-8 = Major version + // 7-0 = Minor version + // + VmPtr->R[7] = GetVmVersion (); + break; + + // + // Debugger breakpoint + // + case 3: + VmPtr->StopFlags |= STOPFLAG_BREAKPOINT; + // + // See if someone has registered a handler + // + EbcDebugSignalException ( + EXCEPT_EBC_BREAKPOINT, + EXCEPTION_FLAG_NONE, + VmPtr + ); + break; + + // + // System call, which there are none, so NOP it. + // + case 4: + break; + + // + // Create a thunk for EBC code. R7 points to a 32-bit (in a 64-bit slot) + // "offset from self" pointer to the EBC entry point. + // After we're done, *(UINT64 *)R7 will be the address of the new thunk. + // + case 5: + Offset = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->R[7]); + U64EbcEntryPoint = (UINT64) (VmPtr->R[7] + Offset + 4); + EbcEntryPoint = (VOID *) (UINTN) U64EbcEntryPoint; + + // + // Now create a new thunk + // + EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0); + + // + // Finally replace the EBC entry point memory with the thunk address + // + VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[7], (UINT64) (UINTN) Thunk); + break; + + // + // Compiler setting version per value in R7 + // + case 6: + VmPtr->CompilerVersion = (UINT32) VmPtr->R[7]; + // + // Check compiler version against VM version? + // + break; + + // + // Unhandled break code. Signal exception. + // + default: + EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr); + break; + } + // + // Advance IP + // + VmPtr->Ip += 2; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteJMP ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the JMP instruction + +Arguments: + VmPtr - pointer to VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + JMP64{cs|cc} Immed64 + JMP32{cs|cc} {@}R1 {Immed32|Index32} + +Encoding: + b0.7 - immediate data present + b0.6 - 1 = 64 bit immediate data + 0 = 32 bit immediate data + b1.7 - 1 = conditional + b1.6 1 = CS (condition set) + 0 = CC (condition clear) + b1.4 1 = relative address + 0 = absolute address + b1.3 1 = operand1 indirect + b1.2-0 operand 1 + +--*/ +{ + UINT8 Opcode; + UINT8 CompareSet; + UINT8 ConditionFlag; + UINT8 Size; + UINT8 Operand; + UINT64 Data64; + INT32 Index32; + UINTN Addr; + + Operand = GETOPERANDS (VmPtr); + Opcode = GETOPCODE (VmPtr); + + // + // Get instruction length from the opcode. The upper two bits are used here + // to index into the length array. + // + Size = mJMPLen[(Opcode >> 6) & 0x03]; + + // + // Decode instruction conditions + // If we haven't met the condition, then simply advance the IP and return. + // + CompareSet = (UINT8) ((Operand & JMP_M_CS) ? 1 : 0); + ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC); + if (Operand & CONDITION_M_CONDITIONAL) { + if (CompareSet != ConditionFlag) { + VmPtr->Ip += Size; + return EFI_SUCCESS; + } + } + // + // Check for 64-bit form and do it right away since it's the most + // straight-forward form. + // + if (Opcode & OPCODE_M_IMMDATA64) { + // + // Double check for immediate-data, which is required. If not there, + // then signal an exception + // + if (!(Opcode & OPCODE_M_IMMDATA)) { + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_ERROR, + VmPtr + ); + return EFI_UNSUPPORTED; + } + // + // 64-bit immediate data is full address. Read the immediate data, + // check for alignment, and jump absolute. + // + Data64 = VmReadImmed64 (VmPtr, 2); + if (!IS_ALIGNED ((UINTN) Data64, sizeof (UINT16))) { + EbcDebugSignalException ( + EXCEPT_EBC_ALIGNMENT_CHECK, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + + return EFI_UNSUPPORTED; + } + + // + // Take jump -- relative or absolute + // + if (Operand & JMP_M_RELATIVE) { + VmPtr->Ip += (UINTN) Data64 + Size; + } else { + VmPtr->Ip = (VMIP) (UINTN) Data64; + } + + return EFI_SUCCESS; + } + // + // 32-bit forms: + // Get the index if there is one. May be either an index, or an immediate + // offset depending on indirect operand. + // JMP32 @R1 Index32 -- immediate data is an index + // JMP32 R1 Immed32 -- immedate data is an offset + // + if (Opcode & OPCODE_M_IMMDATA) { + if (OPERAND1_INDIRECT (Operand)) { + Index32 = VmReadIndex32 (VmPtr, 2); + } else { + Index32 = VmReadImmed32 (VmPtr, 2); + } + } else { + Index32 = 0; + } + // + // Get the register data. If R == 0, then special case where it's ignored. + // + if (OPERAND1_REGNUM (Operand) == 0) { + Data64 = 0; + } else { + Data64 = OPERAND1_REGDATA (VmPtr, Operand); + } + // + // Decode the forms + // + if (OPERAND1_INDIRECT (Operand)) { + // + // Form: JMP32 @Rx {Index32} + // + Addr = VmReadMemN (VmPtr, (UINTN) Data64 + Index32); + if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) { + EbcDebugSignalException ( + EXCEPT_EBC_ALIGNMENT_CHECK, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + + return EFI_UNSUPPORTED; + } + + if (Operand & JMP_M_RELATIVE) { + VmPtr->Ip += (UINTN) Addr + Size; + } else { + VmPtr->Ip = (VMIP) Addr; + } + } else { + // + // Form: JMP32 Rx {Immed32} + // + Addr = (UINTN) (Data64 + Index32); + if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) { + EbcDebugSignalException ( + EXCEPT_EBC_ALIGNMENT_CHECK, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + + return EFI_UNSUPPORTED; + } + + if (Operand & JMP_M_RELATIVE) { + VmPtr->Ip += (UINTN) Addr + Size; + } else { + VmPtr->Ip = (VMIP) Addr; + } + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteJMP8 ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC JMP8 instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + JMP8{cs|cc} Offset/2 + +--*/ +{ + UINT8 Opcode; + UINT8 ConditionFlag; + UINT8 CompareSet; + INT8 Offset; + + // + // Decode instruction. + // + Opcode = GETOPCODE (VmPtr); + CompareSet = (UINT8) ((Opcode & JMP_M_CS) ? 1 : 0); + ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC); + + // + // If we haven't met the condition, then simply advance the IP and return + // + if (Opcode & CONDITION_M_CONDITIONAL) { + if (CompareSet != ConditionFlag) { + VmPtr->Ip += 2; + return EFI_SUCCESS; + } + } + // + // Get the offset from the instruction stream. It's relative to the + // following instruction, and divided by 2. + // + Offset = VmReadImmed8 (VmPtr, 1); + // + // Want to check for offset == -2 and then raise an exception? + // + VmPtr->Ip += (Offset * 2) + 2; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteMOVI ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + Execute the EBC MOVI + +Arguments: + + VmPtr - pointer to a VM context + +Returns: + + Standard EFI_STATUS + +Instruction syntax: + + MOVI[b|w|d|q][w|d|q] {@}R1 {Index16}, ImmData16|32|64 + + First variable character specifies the move size + Second variable character specifies size of the immediate data + + Sign-extend the immediate data to the size of the operation, and zero-extend + if storing to a register. + + Operand1 direct with index/immed is invalid. + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + UINT8 Size; + INT16 Index16; + INT64 ImmData64; + UINT64 Op1; + UINT64 Mask64; + + // + // Get the opcode and operands byte so we can get R1 and R2 + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + + // + // Get the index (16-bit) if present + // + if (Operands & MOVI_M_IMMDATA) { + Index16 = VmReadIndex16 (VmPtr, 2); + Size = 4; + } else { + Index16 = 0; + Size = 2; + } + // + // Extract the immediate data. Sign-extend always. + // + if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) { + ImmData64 = (INT64) (INT16) VmReadImmed16 (VmPtr, Size); + Size += 2; + } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) { + ImmData64 = (INT64) (INT32) VmReadImmed32 (VmPtr, Size); + Size += 4; + } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) { + ImmData64 = (INT64) VmReadImmed64 (VmPtr, Size); + Size += 8; + } else { + // + // Invalid encoding + // + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + // + // Now write back the result + // + if (!OPERAND1_INDIRECT (Operands)) { + // + // Operand1 direct. Make sure it didn't have an index. + // + if (Operands & MOVI_M_IMMDATA) { + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + // + // Writing directly to a register. Clear unused bits. + // + if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) { + Mask64 = 0x000000FF; + } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) { + Mask64 = 0x0000FFFF; + } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) { + Mask64 = 0x00000000FFFFFFFF; + } else { + Mask64 = (UINT64)~0; + } + + VmPtr->R[OPERAND1_REGNUM (Operands)] = ImmData64 & Mask64; + } else { + // + // Get the address then write back based on size of the move + // + Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; + if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) { + VmWriteMem8 (VmPtr, (UINTN) Op1, (UINT8) ImmData64); + } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) { + VmWriteMem16 (VmPtr, (UINTN) Op1, (UINT16) ImmData64); + } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) { + VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) ImmData64); + } else { + VmWriteMem64 (VmPtr, (UINTN) Op1, ImmData64); + } + } + // + // Advance the instruction pointer + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteMOVIn ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + Execute the EBC MOV immediate natural. This instruction moves an immediate + index value into a register or memory location. + +Arguments: + + VmPtr - pointer to a VM context + +Returns: + + Standard EFI_STATUS + +Instruction syntax: + + MOVIn[w|d|q] {@}R1 {Index16}, Index16|32|64 + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + UINT8 Size; + INT16 Index16; + INT16 ImmedIndex16; + INT32 ImmedIndex32; + INT64 ImmedIndex64; + UINT64 Op1; + + // + // Get the opcode and operands byte so we can get R1 and R2 + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + + // + // Get the operand1 index (16-bit) if present + // + if (Operands & MOVI_M_IMMDATA) { + Index16 = VmReadIndex16 (VmPtr, 2); + Size = 4; + } else { + Index16 = 0; + Size = 2; + } + // + // Extract the immediate data and convert to a 64-bit index. + // + if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) { + ImmedIndex16 = VmReadIndex16 (VmPtr, Size); + ImmedIndex64 = (INT64) ImmedIndex16; + Size += 2; + } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) { + ImmedIndex32 = VmReadIndex32 (VmPtr, Size); + ImmedIndex64 = (INT64) ImmedIndex32; + Size += 4; + } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) { + ImmedIndex64 = VmReadIndex64 (VmPtr, Size); + Size += 8; + } else { + // + // Invalid encoding + // + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + // + // Now write back the result + // + if (!OPERAND1_INDIRECT (Operands)) { + // + // Check for MOVIn R1 Index16, Immed (not indirect, with index), which + // is illegal + // + if (Operands & MOVI_M_IMMDATA) { + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + + VmPtr->R[OPERAND1_REGNUM (Operands)] = ImmedIndex64; + } else { + // + // Get the address + // + Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; + VmWriteMemN (VmPtr, (UINTN) Op1, (INTN) ImmedIndex64); + } + // + // Advance the instruction pointer + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteMOVREL ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + Execute the EBC MOVREL instruction. + Dest <- Ip + ImmData + +Arguments: + + VmPtr - pointer to a VM context + +Returns: + + Standard EFI_STATUS + +Instruction syntax: + + MOVREL[w|d|q] {@}R1 {Index16}, ImmData16|32|64 + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + UINT8 Size; + INT16 Index16; + INT64 ImmData64; + UINT64 Op1; + UINT64 Op2; + + // + // Get the opcode and operands byte so we can get R1 and R2 + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + + // + // Get the Operand 1 index (16-bit) if present + // + if (Operands & MOVI_M_IMMDATA) { + Index16 = VmReadIndex16 (VmPtr, 2); + Size = 4; + } else { + Index16 = 0; + Size = 2; + } + // + // Get the immediate data. + // + if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) { + ImmData64 = (INT64) VmReadImmed16 (VmPtr, Size); + Size += 2; + } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) { + ImmData64 = (INT64) VmReadImmed32 (VmPtr, Size); + Size += 4; + } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) { + ImmData64 = VmReadImmed64 (VmPtr, Size); + Size += 8; + } else { + // + // Invalid encoding + // + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + // + // Compute the value and write back the result + // + Op2 = (UINT64) ((INT64) ((UINT64) (UINTN) VmPtr->Ip) + (INT64) ImmData64 + Size); + if (!OPERAND1_INDIRECT (Operands)) { + // + // Check for illegal combination of operand1 direct with immediate data + // + if (Operands & MOVI_M_IMMDATA) { + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + + VmPtr->R[OPERAND1_REGNUM (Operands)] = (VM_REGISTER) Op2; + } else { + // + // Get the address = [Rx] + Index16 + // Write back the result. Always a natural size write, since + // we're talking addresses here. + // + Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; + VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN) Op2); + } + // + // Advance the instruction pointer + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteMOVsnw ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + Execute the EBC MOVsnw instruction. This instruction loads a signed + natural value from memory or register to another memory or register. On + 32-bit machines, the value gets sign-extended to 64 bits if the destination + is a register. + +Arguments: + + VmPtr - pointer to a VM context + +Returns: + + Standard EFI_STATUS + +Instruction syntax: + + MOVsnw {@}R1 {Index16}, {@}R2 {Index16|Immed16} + + 0:7 1=>operand1 index present + 0:6 1=>operand2 index present + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + UINT8 Size; + INT16 Op1Index; + INT16 Op2Index; + UINT64 Op2; + + // + // Get the opcode and operand bytes + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + + Op1Index = Op2Index = 0; + + // + // Get the indexes if present. + // + Size = 2; + if (Opcode & OPCODE_M_IMMED_OP1) { + if (OPERAND1_INDIRECT (Operands)) { + Op1Index = VmReadIndex16 (VmPtr, 2); + } else { + // + // Illegal form operand1 direct with index: MOVsnw R1 Index16, {@}R2 + // + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + + Size += sizeof (UINT16); + } + + if (Opcode & OPCODE_M_IMMED_OP2) { + if (OPERAND2_INDIRECT (Operands)) { + Op2Index = VmReadIndex16 (VmPtr, Size); + } else { + Op2Index = VmReadImmed16 (VmPtr, Size); + } + + Size += sizeof (UINT16); + } + // + // Get the data from the source. + // + Op2 = (INT64) ((INTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Op2Index)); + if (OPERAND2_INDIRECT (Operands)) { + Op2 = (INT64) (INTN) VmReadMemN (VmPtr, (UINTN) Op2); + } + // + // Now write back the result. + // + if (!OPERAND1_INDIRECT (Operands)) { + VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2; + } else { + VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2); + } + // + // Advance the instruction pointer + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteMOVsnd ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + Execute the EBC MOVsnw instruction. This instruction loads a signed + natural value from memory or register to another memory or register. On + 32-bit machines, the value gets sign-extended to 64 bits if the destination + is a register. + +Arguments: + + VmPtr - pointer to a VM context + +Returns: + + Standard EFI_STATUS + +Instruction syntax: + + MOVsnd {@}R1 {Indx32}, {@}R2 {Index32|Immed32} + + 0:7 1=>operand1 index present + 0:6 1=>operand2 index present + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + UINT8 Size; + INT32 Op1Index; + INT32 Op2Index; + UINT64 Op2; + + // + // Get the opcode and operand bytes + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + + Op1Index = Op2Index = 0; + + // + // Get the indexes if present. + // + Size = 2; + if (Opcode & OPCODE_M_IMMED_OP1) { + if (OPERAND1_INDIRECT (Operands)) { + Op1Index = VmReadIndex32 (VmPtr, 2); + } else { + // + // Illegal form operand1 direct with index: MOVsnd R1 Index16,.. + // + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return EFI_UNSUPPORTED; + } + + Size += sizeof (UINT32); + } + + if (Opcode & OPCODE_M_IMMED_OP2) { + if (OPERAND2_INDIRECT (Operands)) { + Op2Index = VmReadIndex32 (VmPtr, Size); + } else { + Op2Index = VmReadImmed32 (VmPtr, Size); + } + + Size += sizeof (UINT32); + } + // + // Get the data from the source. + // + Op2 = (INT64) ((INTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Op2Index)); + if (OPERAND2_INDIRECT (Operands)) { + Op2 = (INT64) (INTN) VmReadMemN (VmPtr, (UINTN) Op2); + } + // + // Now write back the result. + // + if (!OPERAND1_INDIRECT (Operands)) { + VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2; + } else { + VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2); + } + // + // Advance the instruction pointer + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecutePUSHn ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC PUSHn instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + PUSHn {@}R1 {Index16|Immed16} + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + INT16 Index16; + UINTN DataN; + + // + // Get opcode and operands + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + + // + // Get index if present + // + if (Opcode & PUSHPOP_M_IMMDATA) { + if (OPERAND1_INDIRECT (Operands)) { + Index16 = VmReadIndex16 (VmPtr, 2); + } else { + Index16 = VmReadImmed16 (VmPtr, 2); + } + + VmPtr->Ip += 4; + } else { + Index16 = 0; + VmPtr->Ip += 2; + } + // + // Get the data to push + // + if (OPERAND1_INDIRECT (Operands)) { + DataN = VmReadMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16)); + } else { + DataN = (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16); + } + // + // Adjust the stack down. + // + VmPtr->R[0] -= sizeof (UINTN); + VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], DataN); + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecutePUSH ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC PUSH instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + PUSH[32|64] {@}R1 {Index16|Immed16} + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + UINT32 Data32; + UINT64 Data64; + INT16 Index16; + + // + // Get opcode and operands + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + // + // Get immediate index if present, then advance the IP. + // + if (Opcode & PUSHPOP_M_IMMDATA) { + if (OPERAND1_INDIRECT (Operands)) { + Index16 = VmReadIndex16 (VmPtr, 2); + } else { + Index16 = VmReadImmed16 (VmPtr, 2); + } + + VmPtr->Ip += 4; + } else { + Index16 = 0; + VmPtr->Ip += 2; + } + // + // Get the data to push + // + if (Opcode & PUSHPOP_M_64) { + if (OPERAND1_INDIRECT (Operands)) { + Data64 = VmReadMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16)); + } else { + Data64 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; + } + // + // Adjust the stack down, then write back the data + // + VmPtr->R[0] -= sizeof (UINT64); + VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], Data64); + } else { + // + // 32-bit data + // + if (OPERAND1_INDIRECT (Operands)) { + Data32 = VmReadMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16)); + } else { + Data32 = (UINT32) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; + } + // + // Adjust the stack down and write the data + // + VmPtr->R[0] -= sizeof (UINT32); + VmWriteMem32 (VmPtr, (UINTN) VmPtr->R[0], Data32); + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecutePOPn ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC POPn instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + POPn {@}R1 {Index16|Immed16} + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + INT16 Index16; + UINTN DataN; + + // + // Get opcode and operands + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + // + // Get immediate data if present, and advance the IP + // + if (Opcode & PUSHPOP_M_IMMDATA) { + if (OPERAND1_INDIRECT (Operands)) { + Index16 = VmReadIndex16 (VmPtr, 2); + } else { + Index16 = VmReadImmed16 (VmPtr, 2); + } + + VmPtr->Ip += 4; + } else { + Index16 = 0; + VmPtr->Ip += 2; + } + // + // Read the data off the stack, then adjust the stack pointer + // + DataN = VmReadMemN (VmPtr, (UINTN) VmPtr->R[0]); + VmPtr->R[0] += sizeof (UINTN); + // + // Do the write-back + // + if (OPERAND1_INDIRECT (Operands)) { + VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), DataN); + } else { + VmPtr->R[OPERAND1_REGNUM (Operands)] = (INT64) (UINT64) ((UINTN) DataN + Index16); + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecutePOP ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC POP instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + POP {@}R1 {Index16|Immed16} + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + INT16 Index16; + INT32 Data32; + UINT64 Data64; + + // + // Get opcode and operands + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + // + // Get immediate data if present, and advance the IP. + // + if (Opcode & PUSHPOP_M_IMMDATA) { + if (OPERAND1_INDIRECT (Operands)) { + Index16 = VmReadIndex16 (VmPtr, 2); + } else { + Index16 = VmReadImmed16 (VmPtr, 2); + } + + VmPtr->Ip += 4; + } else { + Index16 = 0; + VmPtr->Ip += 2; + } + // + // Get the data off the stack, then write it to the appropriate location + // + if (Opcode & PUSHPOP_M_64) { + // + // Read the data off the stack, then adjust the stack pointer + // + Data64 = VmReadMem64 (VmPtr, (UINTN) VmPtr->R[0]); + VmPtr->R[0] += sizeof (UINT64); + // + // Do the write-back + // + if (OPERAND1_INDIRECT (Operands)) { + VmWriteMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), Data64); + } else { + VmPtr->R[OPERAND1_REGNUM (Operands)] = Data64 + Index16; + } + } else { + // + // 32-bit pop. Read it off the stack and adjust the stack pointer + // + Data32 = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->R[0]); + VmPtr->R[0] += sizeof (UINT32); + // + // Do the write-back + // + if (OPERAND1_INDIRECT (Operands)) { + VmWriteMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), Data32); + } else { + VmPtr->R[OPERAND1_REGNUM (Operands)] = (INT64) Data32 + Index16; + } + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteCALL ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Implements the EBC CALL instruction. + + Instruction format: + + CALL64 Immed64 + CALL32 {@}R1 {Immed32|Index32} + CALLEX64 Immed64 + CALLEX16 {@}R1 {Immed32} + + If Rx == R0, then it's a PC relative call to PC = PC + imm32. + +Arguments: + VmPtr - pointer to a VM context. + +Returns: + Standard EFI_STATUS + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + INT32 Immed32; + UINT8 Size; + INT64 Immed64; + VOID *FramePtr; + + // + // Get opcode and operands + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + // + // Assign these as well to avoid compiler warnings + // + Immed64 = 0; + Immed32 = 0; + + FramePtr = VmPtr->FramePtr; + // + // Determine the instruction size, and get immediate data if present + // + if (Opcode & OPCODE_M_IMMDATA) { + if (Opcode & OPCODE_M_IMMDATA64) { + Immed64 = VmReadImmed64 (VmPtr, 2); + Size = 10; + } else { + // + // If register operand is indirect, then the immediate data is an index + // + if (OPERAND1_INDIRECT (Operands)) { + Immed32 = VmReadIndex32 (VmPtr, 2); + } else { + Immed32 = VmReadImmed32 (VmPtr, 2); + } + + Size = 6; + } + } else { + Size = 2; + } + // + // If it's a call to EBC, adjust the stack pointer down 16 bytes and + // put our return address and frame pointer on the VM stack. + // + if ((Operands & OPERAND_M_NATIVE_CALL) == 0) { + VmPtr->R[0] -= 8; + VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], (UINTN) FramePtr); + VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->R[0]; + VmPtr->R[0] -= 8; + VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], (UINT64) (UINTN) (VmPtr->Ip + Size)); + } + // + // If 64-bit data, then absolute jump only + // + if (Opcode & OPCODE_M_IMMDATA64) { + // + // Native or EBC call? + // + if ((Operands & OPERAND_M_NATIVE_CALL) == 0) { + VmPtr->Ip = (VMIP) (UINTN) Immed64; + } else { + // + // Call external function, get the return value, and advance the IP + // + EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->R[0], FramePtr, Size); + } + } else { + // + // Get the register data. If operand1 == 0, then ignore register and + // take immediate data as relative or absolute address. + // Compiler should take care of upper bits if 32-bit machine. + // + if (OPERAND1_REGNUM (Operands) != 0) { + Immed64 = (UINT64) (UINTN) VmPtr->R[OPERAND1_REGNUM (Operands)]; + } + // + // Get final address + // + if (OPERAND1_INDIRECT (Operands)) { + Immed64 = (INT64) (UINT64) (UINTN) VmReadMemN (VmPtr, (UINTN) (Immed64 + Immed32)); + } else { + Immed64 += Immed32; + } + // + // Now determine if external call, and then if relative or absolute + // + if ((Operands & OPERAND_M_NATIVE_CALL) == 0) { + // + // EBC call. Relative or absolute? If relative, then it's relative to the + // start of the next instruction. + // + if (Operands & OPERAND_M_RELATIVE_ADDR) { + VmPtr->Ip += Immed64 + Size; + } else { + VmPtr->Ip = (VMIP) (UINTN) Immed64; + } + } else { + // + // Native call. Relative or absolute? + // + if (Operands & OPERAND_M_RELATIVE_ADDR) { + EbcLLCALLEX (VmPtr, (UINTN) (Immed64 + VmPtr->Ip + Size), (UINTN) VmPtr->R[0], FramePtr, Size); + } else { + if (VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) { + CpuBreakpoint (); + } + + EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->R[0], FramePtr, Size); + } + } + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteRET ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC RET instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + RET + +--*/ +{ + // + // If we're at the top of the stack, then simply set the done + // flag and return + // + if (VmPtr->StackRetAddr == (UINT64) VmPtr->R[0]) { + VmPtr->StopFlags |= STOPFLAG_APP_DONE; + } else { + // + // Pull the return address off the VM app's stack and set the IP + // to it + // + if (!IS_ALIGNED ((UINTN) VmPtr->R[0], sizeof (UINT16))) { + EbcDebugSignalException ( + EXCEPT_EBC_ALIGNMENT_CHECK, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + } + // + // Restore the IP and frame pointer from the stack + // + VmPtr->Ip = (VMIP) (UINTN) VmReadMem64 (VmPtr, (UINTN) VmPtr->R[0]); + VmPtr->R[0] += 8; + VmPtr->FramePtr = (VOID *) VmReadMemN (VmPtr, (UINTN) VmPtr->R[0]); + VmPtr->R[0] += 8; + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteCMP ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC CMP instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + CMP[32|64][eq|lte|gte|ulte|ugte] R1, {@}R2 {Index16|Immed16} + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + UINT8 Size; + INT16 Index16; + UINT32 Flag; + INT64 Op2; + INT64 Op1; + + // + // Get opcode and operands + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + // + // Get the register data we're going to compare to + // + Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)]; + // + // Get immediate data + // + if (Opcode & OPCODE_M_IMMDATA) { + if (OPERAND2_INDIRECT (Operands)) { + Index16 = VmReadIndex16 (VmPtr, 2); + } else { + Index16 = VmReadImmed16 (VmPtr, 2); + } + + Size = 4; + } else { + Index16 = 0; + Size = 2; + } + // + // Now get Op2 + // + if (OPERAND2_INDIRECT (Operands)) { + if (Opcode & OPCODE_M_64BIT) { + Op2 = (INT64) VmReadMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16)); + } else { + // + // 32-bit operations. 0-extend the values for all cases. + // + Op2 = (INT64) (UINT64) ((UINT32) VmReadMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16))); + } + } else { + Op2 = VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16; + } + // + // Now do the compare + // + Flag = 0; + if (Opcode & OPCODE_M_64BIT) { + // + // 64-bit compares + // + switch (Opcode & OPCODE_M_OPCODE) { + case OPCODE_CMPEQ: + if (Op1 == Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPLTE: + if (Op1 <= Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPGTE: + if (Op1 >= Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPULTE: + if ((UINT64) Op1 <= (UINT64) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPUGTE: + if ((UINT64) Op1 >= (UINT64) Op2) { + Flag = 1; + } + break; + + default: + ASSERT (0); + } + } else { + // + // 32-bit compares + // + switch (Opcode & OPCODE_M_OPCODE) { + case OPCODE_CMPEQ: + if ((INT32) Op1 == (INT32) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPLTE: + if ((INT32) Op1 <= (INT32) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPGTE: + if ((INT32) Op1 >= (INT32) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPULTE: + if ((UINT32) Op1 <= (UINT32) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPUGTE: + if ((UINT32) Op1 >= (UINT32) Op2) { + Flag = 1; + } + break; + + default: + ASSERT (0); + } + } + // + // Now set the flag accordingly for the comparison + // + if (Flag) { + VMFLAG_SET (VmPtr, VMFLAGS_CC); + } else { + VMFLAG_CLEAR (VmPtr, VMFLAGS_CC); + } + // + // Advance the IP + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteCMPI ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC CMPI instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + CMPI[32|64]{w|d}[eq|lte|gte|ulte|ugte] {@}Rx {Index16}, Immed16|Immed32 + +--*/ +{ + UINT8 Opcode; + UINT8 Operands; + UINT8 Size; + INT64 Op1; + INT64 Op2; + INT16 Index16; + UINT32 Flag; + + // + // Get opcode and operands + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + + // + // Get operand1 index if present + // + Size = 2; + if (Operands & OPERAND_M_CMPI_INDEX) { + Index16 = VmReadIndex16 (VmPtr, 2); + Size += 2; + } else { + Index16 = 0; + } + // + // Get operand1 data we're going to compare to + // + Op1 = (INT64) VmPtr->R[OPERAND1_REGNUM (Operands)]; + if (OPERAND1_INDIRECT (Operands)) { + // + // Indirect operand1. Fetch 32 or 64-bit value based on compare size. + // + if (Opcode & OPCODE_M_CMPI64) { + Op1 = (INT64) VmReadMem64 (VmPtr, (UINTN) Op1 + Index16); + } else { + Op1 = (INT64) VmReadMem32 (VmPtr, (UINTN) Op1 + Index16); + } + } else { + // + // Better not have been an index with direct. That is, CMPI R1 Index,... + // is illegal. + // + if (Operands & OPERAND_M_CMPI_INDEX) { + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_ERROR, + VmPtr + ); + VmPtr->Ip += Size; + return EFI_UNSUPPORTED; + } + } + // + // Get immediate data -- 16- or 32-bit sign extended + // + if (Opcode & OPCODE_M_CMPI32_DATA) { + Op2 = (INT64) VmReadImmed32 (VmPtr, Size); + Size += 4; + } else { + // + // 16-bit immediate data. Sign extend always. + // + Op2 = (INT64) ((INT16) VmReadImmed16 (VmPtr, Size)); + Size += 2; + } + // + // Now do the compare + // + Flag = 0; + if (Opcode & OPCODE_M_CMPI64) { + // + // 64 bit comparison + // + switch (Opcode & OPCODE_M_OPCODE) { + case OPCODE_CMPIEQ: + if (Op1 == (INT64) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPILTE: + if (Op1 <= (INT64) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPIGTE: + if (Op1 >= (INT64) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPIULTE: + if ((UINT64) Op1 <= (UINT64) ((UINT32) Op2)) { + Flag = 1; + } + break; + + case OPCODE_CMPIUGTE: + if ((UINT64) Op1 >= (UINT64) ((UINT32) Op2)) { + Flag = 1; + } + break; + + default: + ASSERT (0); + } + } else { + // + // 32-bit comparisons + // + switch (Opcode & OPCODE_M_OPCODE) { + case OPCODE_CMPIEQ: + if ((INT32) Op1 == Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPILTE: + if ((INT32) Op1 <= Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPIGTE: + if ((INT32) Op1 >= Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPIULTE: + if ((UINT32) Op1 <= (UINT32) Op2) { + Flag = 1; + } + break; + + case OPCODE_CMPIUGTE: + if ((UINT32) Op1 >= (UINT32) Op2) { + Flag = 1; + } + break; + + default: + ASSERT (0); + } + } + // + // Now set the flag accordingly for the comparison + // + if (Flag) { + VMFLAG_SET (VmPtr, VMFLAGS_CC); + } else { + VMFLAG_CLEAR (VmPtr, VMFLAGS_CC); + } + // + // Advance the IP + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +UINT64 +ExecuteNOT ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC NOT instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + ~Op2 + +Instruction syntax: + NOT[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + return ~Op2; +} + +STATIC +UINT64 +ExecuteNEG ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC NEG instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op2 * -1 + +Instruction syntax: + NEG[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + return ~Op2 + 1; +} + +STATIC +UINT64 +ExecuteADD ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + + Execute the EBC ADD instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 + Op2 + +Instruction syntax: + ADD[32|64] {@}R1, {@}R2 {Index16} + +--*/ +{ + return Op1 + Op2; +} + +STATIC +UINT64 +ExecuteSUB ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC SUB instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 - Op2 + Standard EFI_STATUS + +Instruction syntax: + SUB[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + if (*VmPtr->Ip & DATAMANIP_M_64) { + return (UINT64) ((INT64) ((INT64) Op1 - (INT64) Op2)); + } else { + return (UINT64) ((INT64) ((INT32) Op1 - (INT32) Op2)); + } +} + +STATIC +UINT64 +ExecuteMUL ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + + Execute the EBC MUL instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 * Op2 + +Instruction syntax: + MUL[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + if (*VmPtr->Ip & DATAMANIP_M_64) { + return MultS64x64 ((INT64)Op1, (INT64)Op2); + } else { + return (UINT64) ((INT64) ((INT32) Op1 * (INT32) Op2)); + } +} + +STATIC +UINT64 +ExecuteMULU ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC MULU instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + (unsigned)Op1 * (unsigned)Op2 + +Instruction syntax: + MULU[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + if (*VmPtr->Ip & DATAMANIP_M_64) { + return MultU64x64 (Op1, Op2); + } else { + return (UINT64) ((UINT32) Op1 * (UINT32) Op2); + } +} + +STATIC +UINT64 +ExecuteDIV ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + + Execute the EBC DIV instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1/Op2 + +Instruction syntax: + DIV[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + INT64 Remainder; + + // + // Check for divide-by-0 + // + if (Op2 == 0) { + EbcDebugSignalException ( + EXCEPT_EBC_DIVIDE_ERROR, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + + return 0; + } else { + if (*VmPtr->Ip & DATAMANIP_M_64) { + return (UINT64) (DivS64x64Remainder (Op1, Op2, &Remainder)); + } else { + return (UINT64) ((INT64) ((INT32) Op1 / (INT32) Op2)); + } + } +} + +STATIC +UINT64 +ExecuteDIVU ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC DIVU instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + (unsigned)Op1 / (unsigned)Op2 + +Instruction syntax: + DIVU[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + UINT64 Remainder; + + // + // Check for divide-by-0 + // + if (Op2 == 0) { + EbcDebugSignalException ( + EXCEPT_EBC_DIVIDE_ERROR, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return 0; + } else { + // + // Get the destination register + // + if (*VmPtr->Ip & DATAMANIP_M_64) { + return (UINT64) (DivU64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder)); + } else { + return (UINT64) ((UINT32) Op1 / (UINT32) Op2); + } + } +} + +STATIC +UINT64 +ExecuteMOD ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC MOD instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 MODULUS Op2 + +Instruction syntax: + MOD[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + INT64 Remainder; + + // + // Check for divide-by-0 + // + if (Op2 == 0) { + EbcDebugSignalException ( + EXCEPT_EBC_DIVIDE_ERROR, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return 0; + } else { + DivS64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder); + return Remainder; + } +} + +STATIC +UINT64 +ExecuteMODU ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC MODU instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 UNSIGNED_MODULUS Op2 + +Instruction syntax: + MODU[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + UINT64 Remainder; + + // + // Check for divide-by-0 + // + if (Op2 == 0) { + EbcDebugSignalException ( + EXCEPT_EBC_DIVIDE_ERROR, + EXCEPTION_FLAG_FATAL, + VmPtr + ); + return 0; + } else { + DivU64x64Remainder (Op1, Op2, &Remainder); + return Remainder; + } +} + +STATIC +UINT64 +ExecuteAND ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC AND instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 AND Op2 + +Instruction syntax: + AND[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + return Op1 & Op2; +} + +STATIC +UINT64 +ExecuteOR ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC OR instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 OR Op2 + +Instruction syntax: + OR[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + return Op1 | Op2; +} + +STATIC +UINT64 +ExecuteXOR ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC XOR instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 XOR Op2 + +Instruction syntax: + XOR[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + return Op1 ^ Op2; +} + +STATIC +UINT64 +ExecuteSHL ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + + Execute the EBC SHL shift left instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 << Op2 + +Instruction syntax: + SHL[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + if (*VmPtr->Ip & DATAMANIP_M_64) { + return LShiftU64 (Op1, (UINTN)Op2); + } else { + return (UINT64) ((UINT32) ((UINT32) Op1 << (UINT32) Op2)); + } +} + +STATIC +UINT64 +ExecuteSHR ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC SHR instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 >> Op2 (unsigned operands) + +Instruction syntax: + SHR[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + if (*VmPtr->Ip & DATAMANIP_M_64) { + return RShiftU64 (Op1, (UINTN)Op2); + } else { + return (UINT64) ((UINT32) Op1 >> (UINT32) Op2); + } +} + +STATIC +UINT64 +ExecuteASHR ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC ASHR instruction + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + Op1 >> Op2 (signed) + +Instruction syntax: + ASHR[32|64] {@}R1, {@}R2 {Index16|Immed16} + +--*/ +{ + if (*VmPtr->Ip & DATAMANIP_M_64) { + return ARShiftU64 (Op1, (UINTN)Op2); + } else { + return (UINT64) ((INT64) ((INT32) Op1 >> (UINT32) Op2)); + } +} + +STATIC +UINT64 +ExecuteEXTNDB ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC EXTNDB instruction to sign-extend a byte value. + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + (INT64)(INT8)Op2 + +Instruction syntax: + EXTNDB[32|64] {@}R1, {@}R2 {Index16|Immed16} + + +--*/ +{ + INT8 Data8; + INT64 Data64; + // + // Convert to byte, then return as 64-bit signed value to let compiler + // sign-extend the value + // + Data8 = (INT8) Op2; + Data64 = (INT64) Data8; + + return (UINT64) Data64; +} + +STATIC +UINT64 +ExecuteEXTNDW ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC EXTNDW instruction to sign-extend a 16-bit value. + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + (INT64)(INT16)Op2 + +Instruction syntax: + EXTNDW[32|64] {@}R1, {@}R2 {Index16|Immed16} + + +--*/ +{ + INT16 Data16; + INT64 Data64; + // + // Convert to word, then return as 64-bit signed value to let compiler + // sign-extend the value + // + Data16 = (INT16) Op2; + Data64 = (INT64) Data16; + + return (UINT64) Data64; +} +// +// Execute the EBC EXTNDD instruction. +// +// Format: EXTNDD {@}Rx, {@}Ry [Index16|Immed16] +// EXTNDD Dest, Source +// +// Operation: Dest <- SignExtended((DWORD)Source)) +// +STATIC +UINT64 +ExecuteEXTNDD ( + IN VM_CONTEXT *VmPtr, + IN UINT64 Op1, + IN UINT64 Op2 + ) +/*++ + +Routine Description: + Execute the EBC EXTNDD instruction to sign-extend a 32-bit value. + +Arguments: + VmPtr - pointer to a VM context + Op1 - Operand 1 from the instruction + Op2 - Operand 2 from the instruction + +Returns: + (INT64)(INT32)Op2 + +Instruction syntax: + EXTNDD[32|64] {@}R1, {@}R2 {Index16|Immed16} + + +--*/ +{ + INT32 Data32; + INT64 Data64; + // + // Convert to 32-bit value, then return as 64-bit signed value to let compiler + // sign-extend the value + // + Data32 = (INT32) Op2; + Data64 = (INT64) Data32; + + return (UINT64) Data64; +} + +STATIC +EFI_STATUS +ExecuteSignedDataManip ( + IN VM_CONTEXT *VmPtr + ) +{ + // + // Just call the data manipulation function with a flag indicating this + // is a signed operation. + // + return ExecuteDataManip (VmPtr, TRUE); +} + +STATIC +EFI_STATUS +ExecuteUnsignedDataManip ( + IN VM_CONTEXT *VmPtr + ) +{ + // + // Just call the data manipulation function with a flag indicating this + // is not a signed operation. + // + return ExecuteDataManip (VmPtr, FALSE); +} + +STATIC +EFI_STATUS +ExecuteDataManip ( + IN VM_CONTEXT *VmPtr, + IN BOOLEAN IsSignedOp + ) +/*++ + +Routine Description: + Execute all the EBC data manipulation instructions. + Since the EBC data manipulation instructions all have the same basic form, + they can share the code that does the fetch of operands and the write-back + of the result. This function performs the fetch of the operands (even if + both are not needed to be fetched, like NOT instruction), dispatches to the + appropriate subfunction, then writes back the returned result. + +Arguments: + VmPtr - pointer to VM context + +Returns: + Standard EBC status + +Format: + INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16} + +--*/ +{ + UINT8 Opcode; + INT16 Index16; + UINT8 Operands; + UINT8 Size; + UINT64 Op1; + UINT64 Op2; + + // + // Get opcode and operands + // + Opcode = GETOPCODE (VmPtr); + Operands = GETOPERANDS (VmPtr); + + // + // Determine if we have immediate data by the opcode + // + if (Opcode & DATAMANIP_M_IMMDATA) { + // + // Index16 if Ry is indirect, or Immed16 if Ry direct. + // + if (OPERAND2_INDIRECT (Operands)) { + Index16 = VmReadIndex16 (VmPtr, 2); + } else { + Index16 = VmReadImmed16 (VmPtr, 2); + } + + Size = 4; + } else { + Index16 = 0; + Size = 2; + } + // + // Now get operand2 (source). It's of format {@}R2 {Index16|Immed16} + // + Op2 = (UINT64) VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16; + if (OPERAND2_INDIRECT (Operands)) { + // + // Indirect form: @R2 Index16. Fetch as 32- or 64-bit data + // + if (Opcode & DATAMANIP_M_64) { + Op2 = VmReadMem64 (VmPtr, (UINTN) Op2); + } else { + // + // Read as signed value where appropriate. + // + if (IsSignedOp) { + Op2 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op2)); + } else { + Op2 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op2); + } + } + } else { + if ((Opcode & DATAMANIP_M_64) == 0) { + if (IsSignedOp) { + Op2 = (UINT64) (INT64) ((INT32) Op2); + } else { + Op2 = (UINT64) ((UINT32) Op2); + } + } + } + // + // Get operand1 (destination and sometimes also an actual operand) + // of form {@}R1 + // + Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)]; + if (OPERAND1_INDIRECT (Operands)) { + if (Opcode & DATAMANIP_M_64) { + Op1 = VmReadMem64 (VmPtr, (UINTN) Op1); + } else { + if (IsSignedOp) { + Op1 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op1)); + } else { + Op1 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op1); + } + } + } else { + if ((Opcode & DATAMANIP_M_64) == 0) { + if (IsSignedOp) { + Op1 = (UINT64) (INT64) ((INT32) Op1); + } else { + Op1 = (UINT64) ((UINT32) Op1); + } + } + } + // + // Dispatch to the computation function + // + if (((Opcode & OPCODE_M_OPCODE) - OPCODE_NOT) >= + (sizeof (mDataManipDispatchTable) / sizeof (mDataManipDispatchTable[0])) + ) { + EbcDebugSignalException ( + EXCEPT_EBC_INVALID_OPCODE, + EXCEPTION_FLAG_ERROR, + VmPtr + ); + // + // Advance and return + // + VmPtr->Ip += Size; + return EFI_UNSUPPORTED; + } else { + Op2 = mDataManipDispatchTable[(Opcode & OPCODE_M_OPCODE) - OPCODE_NOT](VmPtr, Op1, Op2); + } + // + // Write back the result. + // + if (OPERAND1_INDIRECT (Operands)) { + Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)]; + if (Opcode & DATAMANIP_M_64) { + VmWriteMem64 (VmPtr, (UINTN) Op1, Op2); + } else { + VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) Op2); + } + } else { + // + // Storage back to a register. Write back, clearing upper bits (as per + // the specification) if 32-bit operation. + // + VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2; + if ((Opcode & DATAMANIP_M_64) == 0) { + VmPtr->R[OPERAND1_REGNUM (Operands)] &= 0xFFFFFFFF; + } + } + // + // Advance the instruction pointer + // + VmPtr->Ip += Size; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteLOADSP ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC LOADSP instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + LOADSP SP1, R2 + +--*/ +{ + UINT8 Operands; + + // + // Get the operands + // + Operands = GETOPERANDS (VmPtr); + + // + // Do the operation + // + switch (OPERAND1_REGNUM (Operands)) { + // + // Set flags + // + case 0: + // + // Spec states that this instruction will not modify reserved bits in + // the flags register. + // + VmPtr->Flags = (VmPtr->Flags &~VMFLAGS_ALL_VALID) | (VmPtr->R[OPERAND2_REGNUM (Operands)] & VMFLAGS_ALL_VALID); + break; + + default: + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_WARNING, + VmPtr + ); + VmPtr->Ip += 2; + return EFI_UNSUPPORTED; + } + + VmPtr->Ip += 2; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +ExecuteSTORESP ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + Execute the EBC STORESP instruction + +Arguments: + VmPtr - pointer to a VM context + +Returns: + Standard EFI_STATUS + +Instruction syntax: + STORESP Rx, FLAGS|IP + +--*/ +{ + UINT8 Operands; + + // + // Get the operands + // + Operands = GETOPERANDS (VmPtr); + + // + // Do the operation + // + switch (OPERAND2_REGNUM (Operands)) { + // + // Get flags + // + case 0: + // + // Retrieve the value in the flags register, then clear reserved bits + // + VmPtr->R[OPERAND1_REGNUM (Operands)] = (UINT64) (VmPtr->Flags & VMFLAGS_ALL_VALID); + break; + + // + // Get IP -- address of following instruction + // + case 1: + VmPtr->R[OPERAND1_REGNUM (Operands)] = (UINT64) (UINTN) VmPtr->Ip + 2; + break; + + default: + EbcDebugSignalException ( + EXCEPT_EBC_INSTRUCTION_ENCODING, + EXCEPTION_FLAG_WARNING, + VmPtr + ); + VmPtr->Ip += 2; + return EFI_UNSUPPORTED; + break; + } + + VmPtr->Ip += 2; + return EFI_SUCCESS; +} + +STATIC +INT16 +VmReadIndex16 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 CodeOffset + ) +/*++ + +Routine Description: + Decode a 16-bit index to determine the offset. Given an index value: + + b15 - sign bit + b14:12 - number of bits in this index assigned to natural units (=a) + ba:11 - constant units = C + b0:a - natural units = N + + Given this info, the offset can be computed by: + offset = sign_bit * (C + N * sizeof(UINTN)) + + Max offset is achieved with index = 0x7FFF giving an offset of + 0x27B (32-bit machine) or 0x477 (64-bit machine). + Min offset is achieved with index = + +Arguments: + VmPtr - pointer to VM context + CodeOffset - offset from IP of the location of the 16-bit index to decode + +Returns: + The decoded offset. + +--*/ +{ + UINT16 Index; + INT16 Offset; + INT16 C; + INT16 N; + INT16 NBits; + INT16 Mask; + + // + // First read the index from the code stream + // + Index = VmReadCode16 (VmPtr, CodeOffset); + + // + // Get the mask for N. First get the number of bits from the index. + // + NBits = (INT16) ((Index & 0x7000) >> 12); + + // + // Scale it for 16-bit indexes + // + NBits *= 2; + + // + // Now using the number of bits, create a mask. + // + Mask = (INT16) ((INT16)~0 << NBits); + + // + // Now using the mask, extract N from the lower bits of the index. + // + N = (INT16) (Index &~Mask); + + // + // Now compute C + // + C = (INT16) (((Index &~0xF000) & Mask) >> NBits); + + Offset = (INT16) (N * sizeof (UINTN) + C); + + // + // Now set the sign + // + if (Index & 0x8000) { + // + // Do it the hard way to work around a bogus compiler warning + // + // Offset = -1 * Offset; + // + Offset = (INT16) ((INT32) Offset * -1); + } + + return Offset; +} + +STATIC +INT32 +VmReadIndex32 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 CodeOffset + ) +/*++ + +Routine Description: + Decode a 32-bit index to determine the offset. + +Arguments: + VmPtr - pointer to VM context + CodeOffset - offset from IP of the location of the 32-bit index to decode + +Returns: + Converted index per EBC VM specification + +--*/ +{ + UINT32 Index; + INT32 Offset; + INT32 C; + INT32 N; + INT32 NBits; + INT32 Mask; + + Index = VmReadImmed32 (VmPtr, CodeOffset); + + // + // Get the mask for N. First get the number of bits from the index. + // + NBits = (Index & 0x70000000) >> 28; + + // + // Scale it for 32-bit indexes + // + NBits *= 4; + + // + // Now using the number of bits, create a mask. + // + Mask = (INT32)~0 << NBits; + + // + // Now using the mask, extract N from the lower bits of the index. + // + N = Index &~Mask; + + // + // Now compute C + // + C = ((Index &~0xF0000000) & Mask) >> NBits; + + Offset = N * sizeof (UINTN) + C; + + // + // Now set the sign + // + if (Index & 0x80000000) { + Offset = Offset * -1; + } + + return Offset; +} + +STATIC +INT64 +VmReadIndex64 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 CodeOffset + ) +/*++ + +Routine Description: + Decode a 64-bit index to determine the offset. + +Arguments: + VmPtr - pointer to VM context + CodeOffset - offset from IP of the location of the 64-bit index to decode + +Returns: + Converted index per EBC VM specification + +--*/ +{ + UINT64 Index; + INT64 Offset; + INT64 C; + INT64 N; + INT64 NBits; + INT64 Mask; + + Index = VmReadCode64 (VmPtr, CodeOffset); + + // + // Get the mask for N. First get the number of bits from the index. + // + NBits = RShiftU64 ((Index & 0x7000000000000000ULL), 60); + + // + // Scale it for 64-bit indexes (multiply by 8 by shifting left 3) + // + NBits = LShiftU64 ((UINT64)NBits, 3); + + // + // Now using the number of bits, create a mask. + // + Mask = (LShiftU64 ((UINT64)~0, (UINTN)NBits)); + + // + // Now using the mask, extract N from the lower bits of the index. + // + N = Index &~Mask; + + // + // Now compute C + // + C = ARShiftU64 (((Index &~0xF000000000000000ULL) & Mask), (UINTN)NBits); + + Offset = MultU64x64 (N, sizeof (UINTN)) + C; + + // + // Now set the sign + // + if (Index & 0x8000000000000000ULL) { + Offset = MultS64x64 (Offset, -1); + } + + return Offset; +} + +STATIC +EFI_STATUS +VmWriteMem8 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr, + IN UINT8 Data + ) +/*++ + +Routine Description: + The following VmWriteMem? routines are called by the EBC data + movement instructions that write to memory. Since these writes + may be to the stack, which looks like (high address on top) this, + + [EBC entry point arguments] + [VM stack] + [EBC stack] + + we need to detect all attempts to write to the EBC entry point argument + stack area and adjust the address (which will initially point into the + VM stack) to point into the EBC entry point arguments. + +Arguments: + VmPtr - pointer to a VM context + Addr - adddress to write to + Data - value to write to Addr + +Returns: + Standard EFI_STATUS + +--*/ +{ + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + *(UINT8 *) Addr = Data; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +VmWriteMem16 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr, + IN UINT16 Data + ) +{ + EFI_STATUS Status; + + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + + // + // Do a simple write if aligned + // + if (IS_ALIGNED (Addr, sizeof (UINT16))) { + *(UINT16 *) Addr = Data; + } else { + // + // Write as two bytes + // + MemoryFence (); + if ((Status = VmWriteMem8 (VmPtr, Addr, (UINT8) Data)) != EFI_SUCCESS) { + return Status; + } + + MemoryFence (); + if ((Status = VmWriteMem8 (VmPtr, Addr + 1, (UINT8) (Data >> 8))) != EFI_SUCCESS) { + return Status; + } + + MemoryFence (); + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +VmWriteMem32 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr, + IN UINT32 Data + ) +{ + EFI_STATUS Status; + + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + + // + // Do a simple write if aligned + // + if (IS_ALIGNED (Addr, sizeof (UINT32))) { + *(UINT32 *) Addr = Data; + } else { + // + // Write as two words + // + MemoryFence (); + if ((Status = VmWriteMem16 (VmPtr, Addr, (UINT16) Data)) != EFI_SUCCESS) { + return Status; + } + + MemoryFence (); + if ((Status = VmWriteMem16 (VmPtr, Addr + sizeof (UINT16), (UINT16) (Data >> 16))) != EFI_SUCCESS) { + return Status; + } + + MemoryFence (); + } + + return EFI_SUCCESS; +} + +EFI_STATUS +VmWriteMem64 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr, + IN UINT64 Data + ) +{ + EFI_STATUS Status; + UINT32 Data32; + + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + + // + // Do a simple write if aligned + // + if (IS_ALIGNED (Addr, sizeof (UINT64))) { + *(UINT64 *) Addr = Data; + } else { + // + // Write as two 32-bit words + // + MemoryFence (); + if ((Status = VmWriteMem32 (VmPtr, Addr, (UINT32) Data)) != EFI_SUCCESS) { + return Status; + } + + MemoryFence (); + Data32 = (UINT32) (((UINT32 *) &Data)[1]); + if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), Data32)) != EFI_SUCCESS) { + return Status; + } + + MemoryFence (); + } + + return EFI_SUCCESS; +} + +EFI_STATUS +VmWriteMemN ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr, + IN UINTN Data + ) +{ + EFI_STATUS Status; + UINTN Index; + + Status = EFI_SUCCESS; + + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + + // + // Do a simple write if aligned + // + if (IS_ALIGNED (Addr, sizeof (UINTN))) { + *(UINTN *) Addr = Data; + } else { + for (Index = 0; Index < sizeof (UINTN) / sizeof (UINT32); Index++) { + MemoryFence (); + Status = VmWriteMem32 (VmPtr, Addr + Index * sizeof (UINT32), (UINT32) Data); + MemoryFence (); + Data = (UINTN)RShiftU64 ((UINT64)Data, 32); + } + } + + return Status; +} + +STATIC +INT8 +VmReadImmed8 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ) +/*++ + +Routine Description: + + The following VmReadImmed routines are called by the EBC execute + functions to read EBC immediate values from the code stream. + Since we can't assume alignment, each tries to read in the biggest + chunks size available, but will revert to smaller reads if necessary. + +Arguments: + VmPtr - pointer to a VM context + Offset - offset from IP of the code bytes to read. + +Returns: + Signed data of the requested size from the specified address. + +--*/ +{ + // + // Simply return the data in flat memory space + // + return * (INT8 *) (VmPtr->Ip + Offset); +} + +STATIC +INT16 +VmReadImmed16 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ) +{ + // + // Read direct if aligned + // + if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (INT16))) { + return * (INT16 *) (VmPtr->Ip + Offset); + } else { + // + // All code word reads should be aligned + // + EbcDebugSignalException ( + EXCEPT_EBC_ALIGNMENT_CHECK, + EXCEPTION_FLAG_WARNING, + VmPtr + ); + } + // + // Return unaligned data + // + return (INT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8)); +} + +STATIC +INT32 +VmReadImmed32 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ) +{ + UINT32 Data; + + // + // Read direct if aligned + // + if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) { + return * (INT32 *) (VmPtr->Ip + Offset); + } + // + // Return unaligned data + // + Data = (UINT32) VmReadCode16 (VmPtr, Offset); + Data |= (UINT32) (VmReadCode16 (VmPtr, Offset + 2) << 16); + return Data; +} + +STATIC +INT64 +VmReadImmed64 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ) +{ + UINT64 Data64; + UINT32 Data32; + UINT8 *Ptr; + + // + // Read direct if aligned + // + if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) { + return * (UINT64 *) (VmPtr->Ip + Offset); + } + // + // Return unaligned data. + // + Ptr = (UINT8 *) &Data64; + Data32 = VmReadCode32 (VmPtr, Offset); + *(UINT32 *) Ptr = Data32; + Ptr += sizeof (Data32); + Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32)); + *(UINT32 *) Ptr = Data32; + return Data64; +} + +STATIC +UINT16 +VmReadCode16 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ) +/*++ + +Routine Description: + The following VmReadCode() routines provide the ability to read raw + unsigned data from the code stream. + +Arguments: + VmPtr - pointer to VM context + Offset - offset from current IP to the raw data to read. + +Returns: + The raw unsigned 16-bit value from the code stream. + +--*/ +{ + // + // Read direct if aligned + // + if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT16))) { + return * (UINT16 *) (VmPtr->Ip + Offset); + } else { + // + // All code word reads should be aligned + // + EbcDebugSignalException ( + EXCEPT_EBC_ALIGNMENT_CHECK, + EXCEPTION_FLAG_WARNING, + VmPtr + ); + } + // + // Return unaligned data + // + return (UINT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8)); +} + +STATIC +UINT32 +VmReadCode32 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ) +{ + UINT32 Data; + // + // Read direct if aligned + // + if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) { + return * (UINT32 *) (VmPtr->Ip + Offset); + } + // + // Return unaligned data + // + Data = (UINT32) VmReadCode16 (VmPtr, Offset); + Data |= (VmReadCode16 (VmPtr, Offset + 2) << 16); + return Data; +} + +STATIC +UINT64 +VmReadCode64 ( + IN VM_CONTEXT *VmPtr, + IN UINT32 Offset + ) +{ + UINT64 Data64; + UINT32 Data32; + UINT8 *Ptr; + + // + // Read direct if aligned + // + if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) { + return * (UINT64 *) (VmPtr->Ip + Offset); + } + // + // Return unaligned data. + // + Ptr = (UINT8 *) &Data64; + Data32 = VmReadCode32 (VmPtr, Offset); + *(UINT32 *) Ptr = Data32; + Ptr += sizeof (Data32); + Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32)); + *(UINT32 *) Ptr = Data32; + return Data64; +} + +STATIC +UINT8 +VmReadMem8 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ) +{ + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + // + // Simply return the data in flat memory space + // + return * (UINT8 *) Addr; +} + +STATIC +UINT16 +VmReadMem16 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ) +{ + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + // + // Read direct if aligned + // + if (IS_ALIGNED (Addr, sizeof (UINT16))) { + return * (UINT16 *) Addr; + } + // + // Return unaligned data + // + return (UINT16) (*(UINT8 *) Addr + (*(UINT8 *) (Addr + 1) << 8)); +} + +STATIC +UINT32 +VmReadMem32 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ) +{ + UINT32 Data; + + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + // + // Read direct if aligned + // + if (IS_ALIGNED (Addr, sizeof (UINT32))) { + return * (UINT32 *) Addr; + } + // + // Return unaligned data + // + Data = (UINT32) VmReadMem16 (VmPtr, Addr); + Data |= (VmReadMem16 (VmPtr, Addr + 2) << 16); + return Data; +} + +STATIC +UINT64 +VmReadMem64 ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ) +{ + UINT64 Data; + UINT32 Data32; + + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + + // + // Read direct if aligned + // + if (IS_ALIGNED (Addr, sizeof (UINT64))) { + return * (UINT64 *) Addr; + } + // + // Return unaligned data. Assume little endian. + // + Data = (UINT64) VmReadMem32 (VmPtr, Addr); + Data32 = VmReadMem32 (VmPtr, Addr + sizeof (UINT32)); + *(UINT32 *) ((UINT32 *) &Data + 1) = Data32; + return Data; +} + +STATIC +UINTN +ConvertStackAddr ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ) +/*++ + +Routine Description: + + Given an address that EBC is going to read from or write to, return + an appropriate address that accounts for a gap in the stack. + + The stack for this application looks like this (high addr on top) + [EBC entry point arguments] + [VM stack] + [EBC stack] + + The EBC assumes that its arguments are at the top of its stack, which + is where the VM stack is really. Therefore if the EBC does memory + accesses into the VM stack area, then we need to convert the address + to point to the EBC entry point arguments area. Do this here. + +Arguments: + + VmPtr - pointer to VM context + Addr - address of interest + +Returns: + + The unchanged address if it's not in the VM stack region. Otherwise, + adjust for the stack gap and return the modified address. + +--*/ +{ + ASSERT(((Addr < VmPtr->LowStackTop) || (Addr > VmPtr->HighStackBottom))); + return Addr; +} + +STATIC +UINTN +VmReadMemN ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr + ) +/*++ + +Routine Description: + Read a natural value from memory. May or may not be aligned. + +Arguments: + VmPtr - current VM context + Addr - the address to read from + +Returns: + The natural value at address Addr. + +--*/ +{ + UINTN Data; + volatile UINT32 Size; + UINT8 *FromPtr; + UINT8 *ToPtr; + // + // Convert the address if it's in the stack gap + // + Addr = ConvertStackAddr (VmPtr, Addr); + // + // Read direct if aligned + // + if (IS_ALIGNED (Addr, sizeof (UINTN))) { + return * (UINTN *) Addr; + } + // + // Return unaligned data + // + Data = 0; + FromPtr = (UINT8 *) Addr; + ToPtr = (UINT8 *) &Data; + + for (Size = 0; Size < sizeof (Data); Size++) { + *ToPtr = *FromPtr; + ToPtr++; + FromPtr++; + } + + return Data; +} + +UINT64 +GetVmVersion ( + VOID + ) +{ + return (UINT64) (((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF))); +} diff --git a/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h b/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h new file mode 100644 index 0000000000..b1926ee975 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h @@ -0,0 +1,323 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + EbcExecute.h + +Abstract: + + Header file for Virtual Machine support. Contains EBC defines that can + be of use to a disassembler for the most part. Also provides function + prototypes for VM functions. + +--*/ + +#ifndef _EBC_EXECUTE_H_ +#define _EBC_EXECUTE_H_ + +// +// VM major/minor version +// +#define VM_MAJOR_VERSION 1 +#define VM_MINOR_VERSION 0 + +// +// Macros to check and set alignment +// +#define ASSERT_ALIGNED(addr, size) ASSERT (!((UINT32) (addr) & (size - 1))) +#define IS_ALIGNED(addr, size) !((UINT32) (addr) & (size - 1)) + +// +// Define a macro to get the operand. Then we can change it to be either a +// direct read or have it call a function to read memory. +// +#define GETOPERANDS(pVM) (UINT8) (*(UINT8 *) (pVM->Ip + 1)) +#define GETOPCODE(pVM) (UINT8) (*(UINT8 *) pVM->Ip) + +// +// Bit masks for opcode encodings +// +#define OPCODE_M_OPCODE 0x3F // bits of interest for first level decode +#define OPCODE_M_IMMDATA 0x80 +#define OPCODE_M_IMMDATA64 0x40 +#define OPCODE_M_64BIT 0x40 // for CMP +#define OPCODE_M_RELADDR 0x10 // for CALL instruction +#define OPCODE_M_CMPI32_DATA 0x80 // for CMPI +#define OPCODE_M_CMPI64 0x40 // for CMPI 32 or 64 bit comparison +#define OPERAND_M_MOVIN_N 0x80 +#define OPERAND_M_CMPI_INDEX 0x10 + +// +// Masks for instructions that encode presence of indexes for operand1 and/or +// operand2. +// +#define OPCODE_M_IMMED_OP1 0x80 +#define OPCODE_M_IMMED_OP2 0x40 + +// +// Bit masks for operand encodings +// +#define OPERAND_M_INDIRECT1 0x08 +#define OPERAND_M_INDIRECT2 0x80 +#define OPERAND_M_OP1 0x07 +#define OPERAND_M_OP2 0x70 + +// +// Masks for data manipulation instructions +// +#define DATAMANIP_M_64 0x40 // 64-bit width operation +#define DATAMANIP_M_IMMDATA 0x80 + +// +// For MOV instructions, need a mask for the opcode when immediate +// data applies to R2. +// +#define OPCODE_M_IMMED_OP2 0x40 + +// +// The MOVI/MOVIn instructions use bit 6 of operands byte to indicate +// if an index is present. Then bits 4 and 5 are used to indicate the width +// of the move. +// +#define MOVI_M_IMMDATA 0x40 +#define MOVI_M_DATAWIDTH 0xC0 +#define MOVI_DATAWIDTH16 0x40 +#define MOVI_DATAWIDTH32 0x80 +#define MOVI_DATAWIDTH64 0xC0 +#define MOVI_M_MOVEWIDTH 0x30 +#define MOVI_MOVEWIDTH8 0x00 +#define MOVI_MOVEWIDTH16 0x10 +#define MOVI_MOVEWIDTH32 0x20 +#define MOVI_MOVEWIDTH64 0x30 + +// +// Masks for CALL instruction encodings +// +#define OPERAND_M_RELATIVE_ADDR 0x10 +#define OPERAND_M_NATIVE_CALL 0x20 + +// +// Masks for decoding push/pop instructions +// +#define PUSHPOP_M_IMMDATA 0x80 // opcode bit indicating immediate data +#define PUSHPOP_M_64 0x40 // opcode bit indicating 64-bit operation +// +// Mask for operand of JMP instruction +// +#define JMP_M_RELATIVE 0x10 +#define JMP_M_CONDITIONAL 0x80 +#define JMP_M_CS 0x40 + +// +// Macros to determine if a given operand is indirect +// +#define OPERAND1_INDIRECT(op) ((op) & OPERAND_M_INDIRECT1) +#define OPERAND2_INDIRECT(op) ((op) & OPERAND_M_INDIRECT2) + +// +// Macros to extract the operands from second byte of instructions +// +#define OPERAND1_REGNUM(op) ((op) & OPERAND_M_OP1) +#define OPERAND2_REGNUM(op) (((op) & OPERAND_M_OP2) >> 4) + +#define OPERAND1_CHAR(op) ('0' + OPERAND1_REGNUM (op)) +#define OPERAND2_CHAR(op) ('0' + OPERAND2_REGNUM (op)) + +#define OPERAND1_REGDATA(pvm, op) pvm->R[OPERAND1_REGNUM (op)] +#define OPERAND2_REGDATA(pvm, op) pvm->R[OPERAND2_REGNUM (op)] + +// +// Condition masks usually for byte 1 encodings of code +// +#define CONDITION_M_CONDITIONAL 0x80 +#define CONDITION_M_CS 0x40 + +// +// Bits in the VM->StopFlags field +// +#define STOPFLAG_APP_DONE 0x0001 +#define STOPFLAG_BREAKPOINT 0x0002 +#define STOPFLAG_INVALID_BREAK 0x0004 +#define STOPFLAG_BREAK_ON_CALLEX 0x0008 + +// +// Masks for working with the VM flags register +// +#define VMFLAGS_CC 0x0001 // condition flag +#define VMFLAGS_STEP 0x0002 // step instruction mode +#define VMFLAGS_ALL_VALID (VMFLAGS_CC | VMFLAGS_STEP) + +// +// Macros for operating on the VM flags register +// +#define VMFLAG_SET(pVM, Flag) (pVM->Flags |= (Flag)) +#define VMFLAG_ISSET(pVM, Flag) ((pVM->Flags & (Flag)) ? 1 : 0) +#define VMFLAG_CLEAR(pVM, Flag) (pVM->Flags &= ~(Flag)) + +// +// Debug macro +// +#define EBCMSG(s) gST->ConOut->OutputString (gST->ConOut, s) + +// +// Define OPCODES +// +#define OPCODE_BREAK 0x00 +#define OPCODE_JMP 0x01 +#define OPCODE_JMP8 0x02 +#define OPCODE_CALL 0x03 +#define OPCODE_RET 0x04 +#define OPCODE_CMPEQ 0x05 +#define OPCODE_CMPLTE 0x06 +#define OPCODE_CMPGTE 0x07 +#define OPCODE_CMPULTE 0x08 +#define OPCODE_CMPUGTE 0x09 +#define OPCODE_NOT 0x0A +#define OPCODE_NEG 0x0B +#define OPCODE_ADD 0x0C +#define OPCODE_SUB 0x0D +#define OPCODE_MUL 0x0E +#define OPCODE_MULU 0x0F +#define OPCODE_DIV 0x10 +#define OPCODE_DIVU 0x11 +#define OPCODE_MOD 0x12 +#define OPCODE_MODU 0x13 +#define OPCODE_AND 0x14 +#define OPCODE_OR 0x15 +#define OPCODE_XOR 0x16 +#define OPCODE_SHL 0x17 +#define OPCODE_SHR 0x18 +#define OPCODE_ASHR 0x19 +#define OPCODE_EXTNDB 0x1A +#define OPCODE_EXTNDW 0x1B +#define OPCODE_EXTNDD 0x1C +#define OPCODE_MOVBW 0x1D +#define OPCODE_MOVWW 0x1E +#define OPCODE_MOVDW 0x1F +#define OPCODE_MOVQW 0x20 +#define OPCODE_MOVBD 0x21 +#define OPCODE_MOVWD 0x22 +#define OPCODE_MOVDD 0x23 +#define OPCODE_MOVQD 0x24 +#define OPCODE_MOVSNW 0x25 // Move signed natural with word index +#define OPCODE_MOVSND 0x26 // Move signed natural with dword index +// +// #define OPCODE_27 0x27 +// +#define OPCODE_MOVQQ 0x28 // Does this go away? +#define OPCODE_LOADSP 0x29 +#define OPCODE_STORESP 0x2A +#define OPCODE_PUSH 0x2B +#define OPCODE_POP 0x2C +#define OPCODE_CMPIEQ 0x2D +#define OPCODE_CMPILTE 0x2E +#define OPCODE_CMPIGTE 0x2F +#define OPCODE_CMPIULTE 0x30 +#define OPCODE_CMPIUGTE 0x31 +#define OPCODE_MOVNW 0x32 +#define OPCODE_MOVND 0x33 +// +// #define OPCODE_34 0x34 +// +#define OPCODE_PUSHN 0x35 +#define OPCODE_POPN 0x36 +#define OPCODE_MOVI 0x37 +#define OPCODE_MOVIN 0x38 +#define OPCODE_MOVREL 0x39 + +EFI_STATUS +EbcExecute ( + IN VM_CONTEXT *VmPtr + ) +; + + + +UINT64 +GetVmVersion ( + VOID + ) +; + +EFI_STATUS +VmWriteMemN ( + IN VM_CONTEXT *VmPtr, + IN UINTN Addr, + IN UINTN Data + ) +; + +EFI_STATUS +VmWriteMem64 ( + IN VM_CONTEXT *VmPtr, + UINTN Addr, + IN UINT64 Data + ) +; + +// +// Define a protocol for an EBC VM test interface. +// +#define EFI_EBC_VM_TEST_PROTOCOL_GUID \ + { \ + 0xAAEACCFDL, 0xF27B, 0x4C17, { 0xB6, 0x10, 0x75, 0xCA, 0x1F, 0x2D, 0xFB, 0x52 } \ + } + +// +// Define for forward reference. +// +typedef struct _EFI_EBC_VM_TEST_PROTOCOL EFI_EBC_VM_TEST_PROTOCOL; + +typedef +EFI_STATUS +(*EBC_VM_TEST_EXECUTE) ( + IN EFI_EBC_VM_TEST_PROTOCOL * This, + IN VM_CONTEXT * VmPtr, + IN OUT UINTN *InstructionCount + ); + +typedef +EFI_STATUS +(*EBC_VM_TEST_ASM) ( + IN EFI_EBC_VM_TEST_PROTOCOL * This, + IN CHAR16 *AsmText, + IN OUT INT8 *Buffer, + IN OUT UINTN *BufferLen + ); + +typedef +EFI_STATUS +(*EBC_VM_TEST_DASM) ( + IN EFI_EBC_VM_TEST_PROTOCOL * This, + IN OUT CHAR16 *AsmText, + IN OUT INT8 *Buffer, + IN OUT UINTN *Len + ); + +// +// Prototype for the actual EBC test protocol interface +// +struct _EFI_EBC_VM_TEST_PROTOCOL { + EBC_VM_TEST_EXECUTE Execute; + EBC_VM_TEST_ASM Assemble; + EBC_VM_TEST_DASM Disassemble; +}; + +EFI_STATUS +EbcExecuteInstructions ( + IN EFI_EBC_VM_TEST_PROTOCOL *This, + IN VM_CONTEXT *VmPtr, + IN OUT UINTN *InstructionCount + ) +; + +#endif // ifndef _EBC_EXECUTE_H_ diff --git a/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c b/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c new file mode 100644 index 0000000000..2b647d9bae --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c @@ -0,0 +1,1172 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + EbcInt.c + +Abstract: + + Top level module for the EBC virtual machine implementation. + Provides auxilliary support routines for the VM. That is, routines + that are not particularly related to VM execution of EBC instructions. + +--*/ + +#include "EbcInt.h" +#include "EbcExecute.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 { + VOID *ThunkBuffer; + struct _EBC_THUNK_LIST *Next; +} EBC_THUNK_LIST; + +typedef struct _EBC_IMAGE_LIST { + struct _EBC_IMAGE_LIST *Next; + EFI_HANDLE ImageHandle; + EBC_THUNK_LIST *ThunkList; +} EBC_IMAGE_LIST; + +STATIC +EFI_STATUS +EFIAPI +EbcUnloadImage ( + IN EFI_EBC_PROTOCOL *This, + IN EFI_HANDLE ImageHandle + ); + +STATIC +EFI_STATUS +EFIAPI +EbcCreateThunk ( + IN EFI_EBC_PROTOCOL *This, + IN EFI_HANDLE ImageHandle, + IN VOID *EbcEntryPoint, + OUT VOID **Thunk + ); + +STATIC +EFI_STATUS +EFIAPI +EbcGetVersion ( + IN EFI_EBC_PROTOCOL *This, + IN OUT UINT64 *Version + ); + +STATIC +EFI_STATUS +EFIAPI +InitializeEbcCallback ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This + ); + +STATIC +VOID +EFIAPI +CommonEbcExceptionHandler ( + IN EFI_EXCEPTION_TYPE InterruptType, + IN EFI_SYSTEM_CONTEXT SystemContext + ); + +STATIC +VOID +EFIAPI +EbcPeriodicNotifyFunction ( + IN EFI_EVENT Event, + IN VOID *Context + ); + +STATIC +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. +// +STATIC +EFI_STATUS +InitEbcVmTestProtocol ( + IN EFI_HANDLE *Handle + ); + +STATIC +EFI_STATUS +EbcVmTestUnsupported ( + VOID + ); + +STATIC +EFI_STATUS +EFIAPI +EbcRegisterICacheFlush ( + IN EFI_EBC_PROTOCOL *This, + IN EBC_ICACHE_FLUSH Flush + ); + +STATIC +EFI_STATUS +EFIAPI +EbcDebugGetMaximumProcessorIndex ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This, + OUT UINTN *MaxProcessorIndex + ); + +STATIC +EFI_STATUS +EFIAPI +EbcDebugRegisterPeriodicCallback ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This, + IN UINTN ProcessorIndex, + IN EFI_PERIODIC_CALLBACK PeriodicCallback + ); + +STATIC +EFI_STATUS +EFIAPI +EbcDebugRegisterExceptionCallback ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This, + IN UINTN ProcessorIndex, + IN EFI_EXCEPTION_CALLBACK ExceptionCallback, + IN EFI_EXCEPTION_TYPE ExceptionType + ); + +STATIC +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. +// +static EBC_IMAGE_LIST *mEbcImageList = NULL; + +// +// Callback function to flush the icache after thunk creation +// +static EBC_ICACHE_FLUSH mEbcICacheFlush; + +// +// These get set via calls by the debug agent +// +static EFI_PERIODIC_CALLBACK mDebugPeriodicCallback = NULL; +static EFI_EXCEPTION_CALLBACK mDebugExceptionCallback[MAX_EBC_EXCEPTION + 1] = {NULL}; +static EFI_GUID mEfiEbcVmTestProtocolGuid = EFI_EBC_VM_TEST_PROTOCOL_GUID; + +static VOID* mStackBuffer[MAX_STACK_NUM]; +static EFI_HANDLE mStackBufferIndex[MAX_STACK_NUM]; +static UINTN mStackNum = 0; + +// +// Event for Periodic callback +// +static EFI_EVENT mEbcPeriodicEvent; +VM_CONTEXT *mVmPtr = NULL; + +EFI_STATUS +EFIAPI +InitializeEbcDriver ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + + Initializes the VM EFI interface. Allocates memory for the VM interface + and registers the VM protocol. + +Arguments: + + ImageHandle - EFI image handle. + SystemTable - Pointer to the EFI system table. + +Returns: + Standard EFI status code. + +--*/ +{ + 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->InstallProtocolInterface ( + &ImageHandle, + &gEfiEbcProtocolGuid, + EFI_NATIVE_INTERFACE, + EbcProtocol + ); + 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 (); + + 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; +} + +STATIC +EFI_STATUS +EFIAPI +EbcCreateThunk ( + IN EFI_EBC_PROTOCOL *This, + IN EFI_HANDLE ImageHandle, + IN VOID *EbcEntryPoint, + OUT VOID **Thunk + ) +/*++ + +Routine Description: + + This is the top-level routine plugged into the EBC protocol. Since thunks + are very processor-specific, from here we dispatch directly to the very + processor-specific routine EbcCreateThunks(). + +Arguments: + + This - protocol instance pointer + ImageHandle - handle to the image. The EBC interpreter may use this to keep + track of any resource allocations performed in loading and + executing the image. + EbcEntryPoint - the entry point for the image (as defined in the file header) + Thunk - pointer to thunk pointer where the address of the created + thunk is returned. + +Returns: + + EFI_STATUS + +--*/ +{ + EFI_STATUS Status; + + Status = EbcCreateThunks ( + ImageHandle, + EbcEntryPoint, + Thunk, + FLAG_THUNK_ENTRY_POINT + ); + return Status; +} + +STATIC +EFI_STATUS +EFIAPI +EbcDebugGetMaximumProcessorIndex ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This, + OUT UINTN *MaxProcessorIndex + ) +/*++ + +Routine Description: + + This EBC debugger protocol service is called by the debug agent + +Arguments: + + This - pointer to the caller's debug support protocol interface + MaxProcessorIndex - pointer to a caller allocated UINTN in which the maximum + processor index is returned. + +Returns: + + Standard EFI_STATUS + +--*/ +{ + *MaxProcessorIndex = 0; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +EFIAPI +EbcDebugRegisterPeriodicCallback ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This, + IN UINTN ProcessorIndex, + IN EFI_PERIODIC_CALLBACK PeriodicCallback + ) +/*++ + +Routine Description: + + This protocol service is called by the debug agent to register a function + for us to call on a periodic basis. + + +Arguments: + + This - pointer to the caller's debug support protocol interface + PeriodicCallback - pointer to the function to call periodically + +Returns: + + Always EFI_SUCCESS + +--*/ +{ + if ((mDebugPeriodicCallback == NULL) && (PeriodicCallback == NULL)) { + return EFI_INVALID_PARAMETER; + } + if ((mDebugPeriodicCallback != NULL) && (PeriodicCallback != NULL)) { + return EFI_ALREADY_STARTED; + } + + mDebugPeriodicCallback = PeriodicCallback; + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +EFIAPI +EbcDebugRegisterExceptionCallback ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This, + IN UINTN ProcessorIndex, + IN EFI_EXCEPTION_CALLBACK ExceptionCallback, + IN EFI_EXCEPTION_TYPE ExceptionType + ) +/*++ + +Routine Description: + + This protocol service is called by the debug agent to register a function + for us to call when we detect an exception. + + +Arguments: + + This - pointer to the caller's debug support protocol interface + ExceptionCallback - pointer to the function to the exception + +Returns: + + Always EFI_SUCCESS + +--*/ +{ + 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; +} + +STATIC +EFI_STATUS +EFIAPI +EbcDebugInvalidateInstructionCache ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This, + IN UINTN ProcessorIndex, + IN VOID *Start, + IN UINT64 Length + ) +/*++ + +Routine Description: + + This EBC debugger protocol service is called by the debug agent. Required + for DebugSupport compliance but is only stubbed out for EBC. + +Arguments: + +Returns: + + EFI_SUCCESS + +--*/ +{ + return EFI_SUCCESS; +} + +EFI_STATUS +EbcDebugSignalException ( + IN EFI_EXCEPTION_TYPE ExceptionType, + IN EXCEPTION_FLAGS ExceptionFlags, + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + The VM interpreter calls this function when an exception is detected. + +Arguments: + + VmPtr - pointer to a VM context for passing info to the EFI debugger. + +Returns: + + EFI_SUCCESS if it returns at all + +--*/ +{ + 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 = 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) { + 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 = VmPtr->R[0]; + EbcContext.R1 = VmPtr->R[1]; + EbcContext.R2 = VmPtr->R[2]; + EbcContext.R3 = VmPtr->R[3]; + EbcContext.R4 = VmPtr->R[4]; + EbcContext.R5 = VmPtr->R[5]; + EbcContext.R6 = VmPtr->R[6]; + EbcContext.R7 = VmPtr->R[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->R[0] = EbcContext.R0; + VmPtr->R[1] = EbcContext.R1; + VmPtr->R[2] = EbcContext.R2; + VmPtr->R[3] = EbcContext.R3; + VmPtr->R[4] = EbcContext.R4; + VmPtr->R[5] = EbcContext.R5; + VmPtr->R[6] = EbcContext.R6; + VmPtr->R[7] = EbcContext.R7; + VmPtr->Ip = (VMIP)(UINTN)EbcContext.Ip; + VmPtr->Flags = EbcContext.Flags; + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +InitializeEbcCallback ( + IN EFI_DEBUG_SUPPORT_PROTOCOL *This + ) +/*++ + +Routine Description: + + To install default Callback function for the VM interpreter. + +Arguments: + + This - pointer to the instance of DebugSupport protocol + +Returns: + + None + +--*/ +{ + 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; +} + +STATIC +VOID +CommonEbcExceptionHandler ( + IN EFI_EXCEPTION_TYPE InterruptType, + IN EFI_SYSTEM_CONTEXT SystemContext + ) +/*++ + +Routine Description: + + The default Exception Callback for the VM interpreter. + In this function, we report status code, and print debug information + about EBC_CONTEXT, then dead loop. + +Arguments: + + InterruptType - Interrupt type. + SystemContext - EBC system context. + +Returns: + + None + +--*/ +{ + // + // We deadloop here to make it easy to debug this issue. + // + ASSERT (FALSE); + + return ; +} + +STATIC +VOID +EFIAPI +EbcPeriodicNotifyFunction ( + IN EFI_EVENT Event, + IN VOID *Context + ) +/*++ + +Routine Description: + + The periodic callback function for EBC VM interpreter, which is used + to support the EFI debug support protocol. + +Arguments: + + Event - The Periodic Callback Event. + Context - It should be the address of VM_CONTEXT pointer. + +Returns: + + None. + +--*/ +{ + VM_CONTEXT *VmPtr; + + VmPtr = *(VM_CONTEXT **)Context; + + if (VmPtr != NULL) { + EbcDebugPeriodic (VmPtr); + } + + return ; +} + +STATIC +EFI_STATUS +EbcDebugPeriodic ( + IN VM_CONTEXT *VmPtr + ) +/*++ + +Routine Description: + + The VM interpreter calls this function on a periodic basis to support + the EFI debug support protocol. + +Arguments: + + VmPtr - pointer to a VM context for passing info to the debugger. + +Returns: + + Standard EFI status. + +--*/ +{ + 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 = VmPtr->R[0]; + EbcContext.R1 = VmPtr->R[1]; + EbcContext.R2 = VmPtr->R[2]; + EbcContext.R3 = VmPtr->R[3]; + EbcContext.R4 = VmPtr->R[4]; + EbcContext.R5 = VmPtr->R[5]; + EbcContext.R6 = VmPtr->R[6]; + EbcContext.R7 = VmPtr->R[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->R[0] = EbcContext.R0; + VmPtr->R[1] = EbcContext.R1; + VmPtr->R[2] = EbcContext.R2; + VmPtr->R[3] = EbcContext.R3; + VmPtr->R[4] = EbcContext.R4; + VmPtr->R[5] = EbcContext.R5; + VmPtr->R[6] = EbcContext.R6; + VmPtr->R[7] = EbcContext.R7; + VmPtr->Ip = (VMIP)(UINTN)EbcContext.Ip; + VmPtr->Flags = EbcContext.Flags; + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +EFIAPI +EbcUnloadImage ( + IN EFI_EBC_PROTOCOL *This, + IN EFI_HANDLE ImageHandle + ) +/*++ + +Routine Description: + + This routine is called by the core when an image is being unloaded from + memory. Basically we now have the opportunity to do any necessary cleanup. + Typically this will include freeing any memory allocated for thunk-creation. + +Arguments: + + This - protocol instance pointer + ImageHandle - handle to the image being unloaded. + +Returns: + + EFI_INVALID_PARAMETER - the ImageHandle passed in was not found in + the internal list of EBC image handles. + EFI_STATUS - completed successfully + +--*/ +{ + 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); + return EFI_SUCCESS; +} + +EFI_STATUS +EbcAddImageThunk ( + IN EFI_HANDLE ImageHandle, + IN VOID *ThunkBuffer, + IN UINT32 ThunkSize + ) +/*++ + +Routine Description: + + Add a thunk to our list of thunks for a given image handle. + Also flush the instruction cache since we've written thunk code + to memory that will be executed eventually. + +Arguments: + + ImageHandle - the image handle to which the thunk is tied + ThunkBuffer - the buffer we've created/allocated + ThunkSize - the size of the thunk memory allocated + +Returns: + + EFI_OUT_OF_RESOURCES - memory allocation failed + EFI_SUCCESS - successful completion + +--*/ +{ + 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; +} + +STATIC +EFI_STATUS +EFIAPI +EbcRegisterICacheFlush ( + IN EFI_EBC_PROTOCOL *This, + IN EBC_ICACHE_FLUSH Flush + ) +{ + mEbcICacheFlush = Flush; + return EFI_SUCCESS; +} + +STATIC +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( + EFI_HANDLE Handle, + VOID **StackBuffer, + 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( + UINTN Index + ) +{ + mStackBufferIndex[Index] =NULL; + return EFI_SUCCESS; +} + +EFI_STATUS +ReturnEBCStackByHandle( + 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; +} +STATIC +EFI_STATUS +InitEbcVmTestProtocol ( + IN EFI_HANDLE *IHandle + ) +/*++ + +Routine Description: + + Produce an EBC VM test protocol that can be used for regression tests. + +Arguments: + + IHandle - handle on which to install the protocol. + +Returns: + + EFI_OUT_OF_RESOURCES - memory allocation failed + EFI_SUCCESS - successful completion + +--*/ +{ + 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, &mEfiEbcVmTestProtocolGuid, EFI_NATIVE_INTERFACE, EbcVmTestProtocol); + if (EFI_ERROR (Status)) { + FreePool (EbcVmTestProtocol); + } + return Status; +} +STATIC +EFI_STATUS +EbcVmTestUnsupported () +{ + return EFI_UNSUPPORTED; +} + diff --git a/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h b/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h new file mode 100644 index 0000000000..d1631f8e9b --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h @@ -0,0 +1,283 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + EbcInt.h + +Abstract: + + Main routines for the EBC interpreter. Includes the initialization and + main interpreter routines. + +--*/ + +#ifndef _EBC_INT_H_ +#define _EBC_INT_H_ + +// +// The package level header files this module uses +// +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include + +typedef INT64 VM_REGISTER; +typedef UINT8 *VMIP; // instruction pointer for the VM +typedef UINT32 EXCEPTION_FLAGS; + +typedef struct { + VM_REGISTER R[8]; // General purpose registers. + UINT64 Flags; // Flags register: + // 0 Set to 1 if the result of the last compare was true + // 1 Set to 1 if stepping + // 2..63 Reserved. + VMIP Ip; // Instruction pointer. + UINTN LastException; // + EXCEPTION_FLAGS ExceptionFlags; // to keep track of exceptions + UINT32 StopFlags; + UINT32 CompilerVersion; // via break(6) + UINTN HighStackBottom; // bottom of the upper stack + UINTN LowStackTop; // top of the lower stack + UINT64 StackRetAddr; // location of final return address on stack + UINTN *StackMagicPtr; // pointer to magic value on stack to detect corruption + EFI_HANDLE ImageHandle; // for this EBC driver + EFI_SYSTEM_TABLE *SystemTable; // for debugging only + UINTN LastAddrConverted; // for debug + UINTN LastAddrConvertedValue; // for debug + VOID *FramePtr; + VOID *EntryPoint; // entry point of EBC image + UINTN ImageBase; + VOID *StackPool; + VOID *StackTop; +} VM_CONTEXT; + +extern VM_CONTEXT *mVmPtr; + +// +// Bits of exception flags field of VM context +// +#define EXCEPTION_FLAG_FATAL 0x80000000 // can't continue +#define EXCEPTION_FLAG_ERROR 0x40000000 // bad, but try to continue +#define EXCEPTION_FLAG_WARNING 0x20000000 // harmless problem +#define EXCEPTION_FLAG_NONE 0x00000000 // for normal return +// +// Flags passed to the internal create-thunks function. +// +#define FLAG_THUNK_ENTRY_POINT 0x01 // thunk for an image entry point +#define FLAG_THUNK_PROTOCOL 0x00 // thunk for an EBC protocol service +// +// Put this value at the bottom of the VM's stack gap so we can check it on +// occasion to make sure the stack has not been corrupted. +// +#define VM_STACK_KEY_VALUE 0xDEADBEEF + +EFI_STATUS +EbcCreateThunks ( + IN EFI_HANDLE ImageHandle, + IN VOID *EbcEntryPoint, + OUT VOID **Thunk, + IN UINT32 Flags + ) +; + +EFI_STATUS +EbcAddImageThunk ( + IN EFI_HANDLE ImageHandle, + IN VOID *ThunkBuffer, + IN UINT32 ThunkSize + ) +; + +// +// The interpreter calls these when an exception is detected, +// or as a periodic callback. +// +EFI_STATUS +EbcDebugSignalException ( + IN EFI_EXCEPTION_TYPE ExceptionType, + IN EXCEPTION_FLAGS ExceptionFlags, + IN VM_CONTEXT *VmPtr + ) +; + +// +// Define a constant of how often to call the debugger periodic callback +// function. +// +#define EFI_TIMER_UNIT_1MS (1000 * 10) +#define EBC_VM_PERIODIC_CALLBACK_RATE (1000 * EFI_TIMER_UNIT_1MS) +#define STACK_POOL_SIZE (1024 * 1020) +#define MAX_STACK_NUM 4 + +EFI_STATUS +EbcDebugSignalPeriodic ( + IN VM_CONTEXT *VmPtr + ) +; + +// +// External low level functions that are native-processor dependent +// +UINTN +EbcLLGetEbcEntryPoint ( + VOID + ) +; + +UINTN +EbcLLGetStackPointer ( + VOID + ) +; + +VOID +EbcLLCALLEXNative ( + IN UINTN CallAddr, + IN UINTN EbcSp, + IN VOID *FramePtr + ) +; + +VOID +EbcLLCALLEX ( + IN VM_CONTEXT *VmPtr, + IN UINTN CallAddr, + IN UINTN EbcSp, + IN VOID *FramePtr, + IN UINT8 Size + ) +; + +INT64 +EbcLLGetReturnValue ( + VOID + ) +; + +EFI_STATUS +GetEBCStack( + EFI_HANDLE Handle, + VOID **StackBuffer, + UINTN *BufferIndex + ); + +EFI_STATUS +ReturnEBCStack( + UINTN Index + ); + +EFI_STATUS +InitEBCStack ( + VOID + ); + +EFI_STATUS +FreeEBCStack( + VOID + ); + +EFI_STATUS +ReturnEBCStackByHandle( + EFI_HANDLE Handle + ); +// +// Defines for a simple EBC debugger interface +// +typedef struct _EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL; + +#define EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL_GUID \ + { \ + 0x2a72d11e, 0x7376, 0x40f6, { 0x9c, 0x68, 0x23, 0xfa, 0x2f, 0xe3, 0x63, 0xf1 } \ + } + +typedef +EFI_STATUS +(*EBC_DEBUGGER_SIGNAL_EXCEPTION) ( + IN EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL * This, + IN VM_CONTEXT * VmPtr, + IN EFI_EXCEPTION_TYPE ExceptionType + ); + +typedef +VOID +(*EBC_DEBUGGER_DEBUG) ( + IN EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL * This, + IN VM_CONTEXT * VmPtr + ); + +typedef +UINT32 +(*EBC_DEBUGGER_DASM) ( + IN EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL * This, + IN VM_CONTEXT * VmPtr, + IN UINT16 *DasmString OPTIONAL, + IN UINT32 DasmStringSize + ); + +// +// This interface allows you to configure the EBC debug support +// driver. For example, turn on or off saving and printing of +// delta VM even if called. Or to even disable the entire interface, +// in which case all functions become no-ops. +// +typedef +EFI_STATUS +(*EBC_DEBUGGER_CONFIGURE) ( + IN EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL * This, + IN UINT32 ConfigId, + IN UINTN ConfigValue + ); + +// +// Prototype for the actual EBC debug support protocol interface +// +struct _EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL { + EBC_DEBUGGER_DEBUG Debugger; + EBC_DEBUGGER_SIGNAL_EXCEPTION SignalException; + EBC_DEBUGGER_DASM Dasm; + EBC_DEBUGGER_CONFIGURE Configure; +}; + +typedef struct { + EFI_EBC_PROTOCOL *This; + VOID *EntryPoint; + EFI_HANDLE ImageHandle; + VM_CONTEXT VmContext; +} EFI_EBC_THUNK_DATA; + +#define EBC_PROTOCOL_PRIVATE_DATA_SIGNATURE EFI_SIGNATURE_32 ('e', 'b', 'c', 'p') + +struct _EBC_PROTOCOL_PRIVATE_DATA { + UINT32 Signature; + EFI_EBC_PROTOCOL EbcProtocol; + UINTN StackBase; + UINTN StackTop; + UINTN StackSize; +} ; + +#define EBC_PROTOCOL_PRIVATE_DATA_FROM_THIS(a) \ + CR(a, EBC_PROTOCOL_PRIVATE_DATA, EbcProtocol, EBC_PROTOCOL_PRIVATE_DATA_SIGNATURE) + + +#endif // #ifndef _EBC_INT_H_ diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.S b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.S new file mode 100644 index 0000000000..5e9828dc11 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.S @@ -0,0 +1,54 @@ +#**************************************************************************** +#* +#* Copyright (c) 2006, Intel Corporation +#* All rights reserved. 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. +#* +#**************************************************************************** +.globl ASM_PFX(CopyMem) + +.globl ASM_PFX(EbcLLCALLEXNative) +ASM_PFX(EbcLLCALLEXNative): + push %ebp + push %ebx + mov %esp,%ebp + mov 0xc(%esp),%ecx + mov 0x14(%esp),%eax + mov 0x10(%esp),%edx + sub %edx,%eax + sub %eax,%esp + mov %esp,%ebx + push %ecx + push %eax + push %edx + push %ebx + call ASM_PFX(CopyMem) + pop %eax + pop %eax + pop %eax + pop %ecx + call *%ecx + mov %ebp,%esp + mov %ebp,%esp + pop %ebx + pop %ebp + ret + +.globl ASM_PFX(EbcLLGetEbcEntryPoint) +ASM_PFX(EbcLLGetEbcEntryPoint): + ret + +.globl ASM_PFX(EbcLLGetStackPointer) +ASM_PFX(EbcLLGetStackPointer): + mov %esp,%eax + add $0x4,%eax + ret + +.globl ASM_PFX(EbcLLGetReturnValue) +ASM_PFX(EbcLLGetReturnValue): + ret diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm new file mode 100644 index 0000000000..4249241e7d --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm @@ -0,0 +1,163 @@ + page ,132 + title VM ASSEMBLY LANGUAGE ROUTINES +;**************************************************************************** +;* +;* Copyright (c) 2006 - 2007, Intel Corporation +;* All rights reserved. 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. +;* +;**************************************************************************** +;**************************************************************************** +; REV 1.0 +;**************************************************************************** +; +; Rev Date Description +; --- -------- ------------------------------------------------------------ +; 1.0 03/14/01 Initial creation of file. +; +;**************************************************************************** + +;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * +; This code provides low level routines that support the Virtual Machine +; for option ROMs. +;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + +;--------------------------------------------------------------------------- +; Equate files needed. +;--------------------------------------------------------------------------- + +.XLIST + +.LIST + +;--------------------------------------------------------------------------- +; Assembler options +;--------------------------------------------------------------------------- + +.686p +.model flat +.code +;--------------------------------------------------------------------------- +;;GenericPostSegment SEGMENT USE16 +;--------------------------------------------------------------------------- +CopyMem PROTO C Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD + +;**************************************************************************** +; EbcLLCALLEXNative +; +; This function is called to execute an EBC CALLEX instruction +; to native code. +; This instruction requires that we thunk out to external native +; code. For IA32, we simply switch stacks and jump to the +; specified function. On return, we restore the stack pointer +; to its original location. +; +; Destroys no working registers. +;**************************************************************************** +; VOID EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr) +_EbcLLCALLEXNative PROC NEAR PUBLIC + push ebp + push ebx + mov ebp, esp ; standard function prolog + + ; Get function address in a register + ; mov ecx, FuncAddr => mov ecx, dword ptr [FuncAddr] + mov ecx, dword ptr [esp]+0Ch + + ; Set stack pointer to new value + ; mov eax, NewStackPointer => mov eax, dword ptr [NewSp] + mov eax, dword ptr [esp] + 14h + mov edx, dword ptr [esp] + 10h + sub eax, edx + sub esp, eax + mov ebx, esp + push ecx + push eax + push edx + push ebx + call CopyMem + pop eax + pop eax + pop eax + pop ecx + + ; Now call the external routine + call ecx + + ; ebp is preserved by the callee. In this function it + ; equals the original esp, so set them equal + mov esp, ebp + + ; Standard function epilog + mov esp, ebp + pop ebx + pop ebp + ret +_EbcLLCALLEXNative ENDP + + +; UINTN EbcLLGetEbcEntryPoint(VOID); +; Routine Description: +; The VM thunk code stuffs an EBC entry point into a processor +; register. Since we can't use inline assembly to get it from +; the interpreter C code, stuff it into the return value +; register and return. +; +; Arguments: +; None. +; +; Returns: +; The contents of the register in which the entry point is passed. +; +_EbcLLGetEbcEntryPoint PROC NEAR PUBLIC + ret +_EbcLLGetEbcEntryPoint ENDP + +;/*++ +; +;Routine Description: +; +; Return the caller's value of the stack pointer. +; +;Arguments: +; +; None. +; +;Returns: +; +; The current value of the stack pointer for the caller. We +; adjust it by 4 here because when they called us, the return address +; is put on the stack, thereby lowering it by 4 bytes. +; +;--*/ + +; UINTN EbcLLGetStackPointer() +_EbcLLGetStackPointer PROC NEAR PUBLIC + mov eax, esp ; get current stack pointer + add eax, 4 ; stack adjusted by this much when we were called + ret +_EbcLLGetStackPointer ENDP + +; UINT64 EbcLLGetReturnValue(VOID); +; Routine Description: +; When EBC calls native, on return the VM has to stuff the return +; value into a VM register. It's assumed here that the value is still +; in the register, so simply return and the caller should get the +; return result properly. +; +; Arguments: +; None. +; +; Returns: +; The unmodified value returned by the native code. +; +_EbcLLGetReturnValue PROC NEAR PUBLIC + ret +_EbcLLGetReturnValue ENDP + +END diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcSupport.c b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcSupport.c new file mode 100644 index 0000000000..a534e00780 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcSupport.c @@ -0,0 +1,545 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + EbcSupport.c + +Abstract: + + This module contains EBC support routines that are customized based on + the target processor. + +--*/ + +#include "EbcInt.h" +#include "EbcExecute.h" + +// +// NOTE: This is the stack size allocated for the interpreter +// when it executes an EBC image. The requirements can change +// based on whether or not a debugger is present, and other +// platform-specific configurations. +// +#define VM_STACK_SIZE (1024 * 4) +#define EBC_THUNK_SIZE 32 + +#define STACK_REMAIN_SIZE (1024 * 4) +VOID +EbcLLCALLEX ( + IN VM_CONTEXT *VmPtr, + IN UINTN FuncAddr, + IN UINTN NewStackPointer, + IN VOID *FramePtr, + IN UINT8 Size + ) +/*++ + +Routine Description: + + 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. + +Arguments: + + VmPtr - Pointer to a VM context. + FuncAddr - Callee's address + NewStackPointer - New stack pointer after the call + FramePtr - New frame pointer after the call + Size - The size of call instruction + +Returns: + + None. + +--*/ +{ + UINTN IsThunk; + UINTN TargetEbcAddr; + + IsThunk = 1; + TargetEbcAddr = 0; + + // + // Processor specific code to check whether the callee is a thunk to EBC. + // + if (*((UINT8 *)FuncAddr) != 0xB8) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 1) != 0xBC) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 2) != 0x2E) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 3) != 0x11) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 4) != 0xCA) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 5) != 0xB8) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 10) != 0xB9) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 15) != 0xFF) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 16) != 0xE1) { + IsThunk = 0; + goto Action; + } + + TargetEbcAddr = ((UINTN)(*((UINT8 *)FuncAddr + 9)) << 24) + ((UINTN)(*((UINT8 *)FuncAddr + 8)) << 16) + + ((UINTN)(*((UINT8 *)FuncAddr + 7)) << 8) + ((UINTN)(*((UINT8 *)FuncAddr + 6))); + +Action: + 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->R[0] -= 8; + VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], (UINTN) FramePtr); + VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->R[0]; + VmPtr->R[0] -= 8; + VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], (UINT64) (UINTN) (VmPtr->Ip + Size)); + + VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr; + } else { + // + // The callee is not a thunk to EBC, call native code. + // + EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr); + + // + // Get return value and advance the IP. + // + VmPtr->R[7] = EbcLLGetReturnValue (); + VmPtr->Ip += Size; + } +} + +STATIC +UINT64 +EbcInterpret ( + IN OUT UINTN Arg1, + IN OUT UINTN Arg2, + IN OUT UINTN Arg3, + IN OUT UINTN Arg4, + IN OUT UINTN Arg5, + IN OUT UINTN Arg6, + IN OUT UINTN Arg7, + IN OUT UINTN Arg8, + IN OUT UINTN Arg9, + IN OUT UINTN Arg10, + IN OUT UINTN Arg11, + IN OUT UINTN Arg12, + IN OUT UINTN Arg13, + IN OUT UINTN Arg14, + IN OUT UINTN Arg15, + IN OUT UINTN Arg16 + ) +/*++ + +Routine Description: + + 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: + + None. Since we're called from a fixed up thunk (which we want to keep + small), our only so-called argument is the EBC entry point passed in + to us in a processor register. + +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; + EFI_STATUS Status; + UINTN StackIndex; + + // + // Get the EBC entry point from the processor register. + // + Addr = EbcLLGetEbcEntryPoint (); + + // + // 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. + // + + // + // Align the stack on a natural boundary + // + + // + // Allocate stack pool + // + Status = GetEBCStack((EFI_HANDLE)-1, &VmContext.StackPool, &StackIndex); + if (EFI_ERROR(Status)) { + return Status; + } + VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE); + VmContext.R[0] = (UINT64)(UINTN) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); + VmContext.HighStackBottom = (UINTN)VmContext.R[0]; + VmContext.R[0] &= ~(sizeof (UINTN) - 1); + VmContext.R[0] -= sizeof (UINTN); + + // + // Put a magic value in the stack gap, then adjust down again + // + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) VM_STACK_KEY_VALUE; + VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0]; + VmContext.LowStackTop = (UINTN) VmContext.R[0]; + + // + // For IA32, this is where we say our return address is + // + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg16; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg15; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg14; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg13; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg12; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg11; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg10; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg9; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg8; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg7; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg6; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg5; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg4; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg3; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg2; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg1; + VmContext.R[0] -= 16; + VmContext.StackRetAddr = (UINT64) VmContext.R[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.R[7]; +} + +STATIC +UINT64 +ExecuteEbcImageEntryPoint ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + + 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; + EFI_STATUS Status; + UINTN StackIndex; + + // + // 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 (); + + // + // Print(L"*** Thunked into EBC entry point - ImageHandle = 0x%X\n", (UINTN)ImageHandle); + // Print(L"EBC entry point is 0x%X\n", (UINT32)(UINTN)Addr); + // + // 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. + // + + // + // Allocate stack pool + // + Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex); + if (EFI_ERROR(Status)) { + return Status; + } + VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE); + VmContext.R[0] = (UINT64)(UINTN) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); + VmContext.HighStackBottom = (UINTN)VmContext.R[0]; + VmContext.R[0] -= sizeof (UINTN); + + // + // Put a magic value in the stack gap, then adjust down again + // + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) VM_STACK_KEY_VALUE; + VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0]; + + // + // Align the stack on a natural boundary + // VmContext.R[0] &= ~(sizeof(UINTN) - 1); + // + VmContext.LowStackTop = (UINTN) VmContext.R[0]; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) SystemTable; + VmContext.R[0] -= sizeof (UINTN); + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) ImageHandle; + + VmContext.R[0] -= 16; + VmContext.StackRetAddr = (UINT64) VmContext.R[0]; + // + // VM pushes 16-bytes for return address. Simulate that here. + // + + // + // 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 an IA32 thunk for the given EBC entry point. + +Arguments: + + ImageHandle - Handle of image for which this thunk is being created + EbcEntryPoint - Address of the EBC code that the thunk is to call + Thunk - Returned thunk we create here + +Returns: + + Standard EFI status. + +--*/ +{ + UINT8 *Ptr; + UINT8 *ThunkBase; + UINT32 I; + UINT32 Addr; + INT32 Size; + INT32 ThunkSize; + + // + // Check alignment of pointer to EBC code + // + if ((UINT32) (UINTN) EbcEntryPoint & 0x01) { + return EFI_INVALID_PARAMETER; + } + + Size = EBC_THUNK_SIZE; + ThunkSize = Size; + + Ptr = AllocatePool (Size); + + 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; + + // + // Add a magic code here to help the VM recognize the thunk.. + // mov eax, 0xca112ebc => B8 BC 2E 11 CA + // + *Ptr = 0xB8; + Ptr++; + Size--; + Addr = (UINT32) 0xCA112EBC; + for (I = 0; I < sizeof (Addr); I++) { + *Ptr = (UINT8) (UINTN) Addr; + Addr >>= 8; + Ptr++; + Size--; + } + + // + // Add code bytes to load up a processor register with the EBC entry point. + // mov eax, 0xaa55aa55 => B8 55 AA 55 AA + // The first 8 bytes of the thunk entry is the address of the EBC + // entry point. + // + *Ptr = 0xB8; + Ptr++; + Size--; + Addr = (UINT32) EbcEntryPoint; + for (I = 0; I < sizeof (Addr); I++) { + *Ptr = (UINT8) (UINTN) Addr; + Addr >>= 8; + Ptr++; + Size--; + } + // + // Stick in a load of ecx with the address of appropriate VM function. + // mov ecx 12345678h => 0xB9 0x78 0x56 0x34 0x12 + // + if (Flags & FLAG_THUNK_ENTRY_POINT) { + Addr = (UINT32) (UINTN) ExecuteEbcImageEntryPoint; + } else { + Addr = (UINT32) (UINTN) EbcInterpret; + } + + // + // MOV ecx + // + *Ptr = 0xB9; + Ptr++; + Size--; + for (I = 0; I < sizeof (Addr); I++) { + *Ptr = (UINT8) Addr; + Addr >>= 8; + Ptr++; + Size--; + } + // + // Stick in jump opcode bytes for jmp ecx => 0xFF 0xE1 + // + *Ptr = 0xFF; + Ptr++; + Size--; + *Ptr = 0xE1; + Size--; + + // + // Double check that our defined size is ok (application error) + // + if (Size < 0) { + ASSERT (FALSE); + return EFI_BUFFER_TOO_SMALL; + } + // + // 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; +} diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s new file mode 100644 index 0000000000..e329b68e66 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s @@ -0,0 +1,197 @@ +//++ +// Copyright (c) 2006, Intel Corporation +// All rights reserved. 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. +// +// Module Name: +// +// EbcLowLevel.s +// +// Abstract: +// +// Contains low level routines for the Virtual Machine implementation +// on an Itanium-based platform. +// +// +//-- + +.file "EbcLowLevel.s" + +#define PROCEDURE_ENTRY(name) .##text; \ + .##type name, @function; \ + .##proc name; \ +name:: + +#define PROCEDURE_EXIT(name) .##endp name + +// Note: use of NESTED_SETUP requires number of locals (l) >= 3 + +#define NESTED_SETUP(i,l,o,r) \ + alloc loc1=ar##.##pfs,i,l,o,r ;\ + mov loc0=b0 + +#define NESTED_RETURN \ + mov b0=loc0 ;\ + mov ar##.##pfs=loc1 ;;\ + br##.##ret##.##dpnt b0;; + +.type CopyMem, @function; + +//----------------------------------------------------------------------------- +//++ +// EbcAsmLLCALLEX +// +// Implements the low level EBC CALLEX instruction. Sets up the +// stack pointer, does the spill of function arguments, and +// calls the native function. On return it restores the original +// stack pointer and returns to the caller. +// +// Arguments : +// +// On Entry : +// in0 = Address of native code to call +// in1 = New stack pointer +// +// Return Value: +// +// As per static calling conventions. +// +//-- +//--------------------------------------------------------------------------- +;// void EbcAsmLLCALLEX (UINTN FunctionAddr, UINTN EbcStackPointer) +PROCEDURE_ENTRY(EbcAsmLLCALLEX) + NESTED_SETUP (2,6,8,0) + + // NESTED_SETUP uses loc0 and loc1 for context save + + // + // Save a copy of the EBC VM stack pointer + // + mov r8 = in1;; + + // + // Copy stack arguments from EBC stack into registers. + // Assume worst case and copy 8. + // + ld8 out0 = [r8], 8;; + ld8 out1 = [r8], 8;; + ld8 out2 = [r8], 8;; + ld8 out3 = [r8], 8;; + ld8 out4 = [r8], 8;; + ld8 out5 = [r8], 8;; + ld8 out6 = [r8], 8;; + ld8 out7 = [r8], 8;; + + // + // Save the original stack pointer + // + mov loc2 = r12; + + // + // Save the gp + // + or loc3 = r1, r0 + + // + // Set the new aligned stack pointer. Reserve space for the required + // 16-bytes of scratch area as well. + // + add r12 = 48, in1 + + // + // Now call the function. Load up the function address from the descriptor + // pointed to by in0. Then get the gp from the descriptor at the following + // address in the descriptor. + // + ld8 r31 = [in0], 8;; + ld8 r30 = [in0];; + mov b1 = r31 + mov r1 = r30 + (p0) br.call.dptk.many b0 = b1;; + + // + // Restore the original stack pointer and gp + // + mov r12 = loc2 + or r1 = loc3, r0 + + // + // Now return + // + NESTED_RETURN + +PROCEDURE_EXIT(EbcAsmLLCALLEX) + +PROCEDURE_ENTRY(EbcLLCALLEXNative) + NESTED_SETUP (3,6,3,0) + + mov loc2 = in2;; + mov loc3 = in1;; + sub loc2 = loc2, loc3 + mov loc4 = r12;; + or loc5 = r1, r0 + + sub r12 = r12, loc2 + mov out2 = loc2;; + + and r12 = -0x10, r12 + mov out1 = in1;; + mov out0 = r12;; + adds r12 = -0x8, r12 + (p0) br.call.dptk.many b0 = CopyMem;; + adds r12 = 0x8, r12 + + mov out0 = in0;; + mov out1 = r12;; + (p0) br.call.dptk.many b0 = EbcAsmLLCALLEX;; + mov r12 = loc4;; + or r1 = loc5, r0 + + NESTED_RETURN +PROCEDURE_EXIT(EbcLLCALLEXNative) + + +// +// UINTN EbcLLGetEbcEntryPoint(VOID) +// +// Description: +// Simply return, so that the caller retrieves the return register +// contents (R8). That's where the thunk-to-ebc code stuffed the +// EBC entry point. +// +PROCEDURE_ENTRY(EbcLLGetEbcEntryPoint) + br.ret.sptk b0 ;; +PROCEDURE_EXIT(EbcLLGetEbcEntryPoint) + +// +// INT64 EbcLLGetReturnValue(VOID) +// +// Description: +// This function is called to get the value returned by native code +// to EBC. It simply returns because the return value should still +// be in the register, so the caller just gets the unmodified value. +// +PROCEDURE_ENTRY(EbcLLGetReturnValue) + br.ret.sptk b0 ;; +PROCEDURE_EXIT(EbcLLGetReturnValue) + +// +// UINTN EbcLLGetStackPointer(VOID) +// +PROCEDURE_ENTRY(EbcLLGetStackPointer) + mov r8 = r12 ;; + br.ret.sptk b0 ;; + br.sptk.few b6 +PROCEDURE_EXIT(EbcLLGetStackPointer) + + + + + + + diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c new file mode 100644 index 0000000000..3647a12fae --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c @@ -0,0 +1,869 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + EbcSupport.c + +Abstract: + + This module contains EBC support routines that are customized based on + the target processor. + +--*/ + +#include "EbcInt.h" +#include "EbcExecute.h" +#include "EbcSupport.h" + +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; +} + +STATIC +UINT64 +EbcInterpret ( + UINT64 Arg1, + ... + ) +{ + // + // Create a new VM context on the stack + // + VM_CONTEXT VmContext; + UINTN Addr; + EFI_STATUS Status; + UINTN StackIndex; + VA_LIST List; + UINT64 Arg2; + UINT64 Arg3; + UINT64 Arg4; + UINT64 Arg5; + UINT64 Arg6; + UINT64 Arg7; + UINT64 Arg8; + UINT64 Arg9; + UINT64 Arg10; + UINT64 Arg11; + UINT64 Arg12; + UINT64 Arg13; + UINT64 Arg14; + UINT64 Arg15; + UINT64 Arg16; + // + // 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); + Arg9 = VA_ARG (List, UINT64); + Arg10 = VA_ARG (List, UINT64); + Arg11 = VA_ARG (List, UINT64); + Arg12 = VA_ARG (List, UINT64); + Arg13 = VA_ARG (List, UINT64); + Arg14 = VA_ARG (List, UINT64); + Arg15 = VA_ARG (List, UINT64); + Arg16 = VA_ARG (List, UINT64); + // + // 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. + // + // + // 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. + // + // + // Now adjust the EBC stack pointer down to leave a gap for interpreter + // execution. Then stuff a magic value there. + // + + Status = GetEBCStack((EFI_HANDLE)(UINTN)-1, &VmContext.StackPool, &StackIndex); + if (EFI_ERROR(Status)) { + return Status; + } + VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE); + VmContext.R[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); + VmContext.HighStackBottom = (UINTN) VmContext.R[0]; + VmContext.R[0] -= sizeof (UINTN); + + + 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, Arg16); + PushU64 (&VmContext, Arg15); + PushU64 (&VmContext, Arg14); + PushU64 (&VmContext, Arg13); + PushU64 (&VmContext, Arg12); + PushU64 (&VmContext, Arg11); + PushU64 (&VmContext, Arg10); + PushU64 (&VmContext, Arg9); + 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 + // + ReturnEBCStack(StackIndex); + return (UINT64) VmContext.R[7]; +} + +STATIC +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; + EFI_STATUS Status; + UINTN StackIndex; + + // + // 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 + // + 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; + + // + // Get the stack pointer. This is the bottom of the upper stack. + // + Addr = EbcLLGetStackPointer (); + + Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex); + if (EFI_ERROR(Status)) { + return Status; + } + VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE); + VmContext.R[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); + VmContext.HighStackBottom = (UINTN) VmContext.R[0]; + VmContext.R[0] -= sizeof (UINTN); + + + // + // Allocate stack space for the interpreter. Then put a magic value + // at the bottom so we can detect stack corruption. + // + 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 + // + ReturnEBCStack(StackIndex); + 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; + UINT8 *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; + UINT32 Size; + + // + // 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 + // that the returned buffer is not aligned, so round up to the next + // alignment size. + // + Size = EBC_THUNK_SIZE + EBC_THUNK_ALIGNMENT - 1; + ThunkSize = Size; + Ptr = AllocatePool (Size); + + if (Ptr == NULL) { + return EFI_OUT_OF_RESOURCES; + } + // + // Save the start address of the buffer. + // + ThunkBase = Ptr; + + // + // Make sure it's aligned for code execution. If not, then + // round up. + // + if ((UINT32) (UINTN) Ptr & (EBC_THUNK_ALIGNMENT - 1)) { + Ptr = (UINT8 *) (((UINTN) Ptr + (EBC_THUNK_ALIGNMENT - 1)) &~ (UINT64) (EBC_THUNK_ALIGNMENT - 1)); + } + // + // Return the pointer to the thunk to the caller to user as the + // image entry point. + // + *Thunk = (VOID *) Ptr; + + // + // Clear out the thunk entry + // ZeroMem(Ptr, Size); + // + // For IPF, when you do a call via a function pointer, the function pointer + // actually points to a function descriptor which consists of a 64-bit + // address of the function, followed by a 64-bit gp for the function being + // called. See the the Software Conventions and Runtime Architecture Guide + // for details. + // So first off in our thunk, create a descriptor for our actual thunk code. + // This means we need to create a pointer to the thunk code (which follows + // the descriptor we're going to create), followed by the gp of the Vm + // interpret function we're going to eventually execute. + // + Data64Ptr = (UINT64 *) Ptr; + + // + // Write the function's entry point (which is our thunk code that follows + // this descriptor we're creating). + // + *Data64Ptr = (UINT64) (Data64Ptr + 2); + // + // Get the gp from the descriptor for EbcInterpret and stuff it in our thunk + // descriptor. + // + *(Data64Ptr + 1) = *(UINT64 *) ((UINT64 *) (UINTN) EbcInterpret + 1); + // + // Advance our thunk data pointer past the descriptor. Since the + // descriptor consists of 16 bytes, the pointer is still aligned for + // IPF code execution (on 16-byte boundary). + // + Ptr += sizeof (UINT64) * 2; + + // + // *************************** MAGIC BUNDLE ******************************** + // + // Write magic code bundle for: movl r8 = 0xca112ebcca112ebc to help the VM + // to recognize it is a thunk. + // + Addr = (UINT64) 0xCA112EBCCA112EBC; + + // + // Now generate the code bytes. First is nop.m 0x0 + // + Code[0] = OPCODE_NOP; + + // + // Next is simply Addr[62:22] (41 bits) of the address + // + Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff; + + // + // Extract bits from the address for insertion into the instruction + // i = Addr[63:63] + // + I = RShiftU64 (Addr, 63) & 0x01; + // + // ic = Addr[21:21] + // + Ic = RShiftU64 (Addr, 21) & 0x01; + // + // imm5c = Addr[20:16] for 5 bits + // + Imm5c = RShiftU64 (Addr, 16) & 0x1F; + // + // imm9d = Addr[15:7] for 9 bits + // + Imm9d = RShiftU64 (Addr, 7) & 0x1FF; + // + // imm7b = Addr[6:0] for 7 bits + // + Imm7b = Addr & 0x7F; + + // + // The EBC entry point will be put into r8, so r8 can be used here + // temporary. R8 is general register and is auto-serialized. + // + RegNum = 8; + + // + // Next is jumbled data, including opcode and rest of address + // + Code[2] = LShiftU64 (Imm7b, 13); + Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc + Code[2] = Code[2] | LShiftU64 (Ic, 21); + Code[2] = Code[2] | LShiftU64 (Imm5c, 22); + Code[2] = Code[2] | LShiftU64 (Imm9d, 27); + Code[2] = Code[2] | LShiftU64 (I, 36); + Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37); + Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6); + + WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]); + + // + // *************************** FIRST BUNDLE ******************************** + // + // Write code bundle for: movl r8 = EBC_ENTRY_POINT so we pass + // the ebc entry point in to the interpreter function via a processor + // register. + // Note -- we could easily change this to pass in a pointer to a structure + // that contained, among other things, the EBC image's entry point. But + // for now pass it directly. + // + Ptr += 16; + Addr = (UINT64) EbcEntryPoint; + + // + // Now generate the code bytes. First is nop.m 0x0 + // + Code[0] = OPCODE_NOP; + + // + // Next is simply Addr[62:22] (41 bits) of the address + // + Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff; + + // + // Extract bits from the address for insertion into the instruction + // i = Addr[63:63] + // + I = RShiftU64 (Addr, 63) & 0x01; + // + // ic = Addr[21:21] + // + Ic = RShiftU64 (Addr, 21) & 0x01; + // + // imm5c = Addr[20:16] for 5 bits + // + Imm5c = RShiftU64 (Addr, 16) & 0x1F; + // + // imm9d = Addr[15:7] for 9 bits + // + Imm9d = RShiftU64 (Addr, 7) & 0x1FF; + // + // imm7b = Addr[6:0] for 7 bits + // + Imm7b = Addr & 0x7F; + + // + // Put the EBC entry point in r8, which is the location of the return value + // for functions. + // + RegNum = 8; + + // + // Next is jumbled data, including opcode and rest of address + // + Code[2] = LShiftU64 (Imm7b, 13); + Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc + Code[2] = Code[2] | LShiftU64 (Ic, 21); + Code[2] = Code[2] | LShiftU64 (Imm5c, 22); + Code[2] = Code[2] | LShiftU64 (Imm9d, 27); + Code[2] = Code[2] | LShiftU64 (I, 36); + Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37); + Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6); + + WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]); + + // + // *************************** NEXT BUNDLE ********************************* + // + // Write code bundle for: + // movl rx = offset_of(EbcInterpret|ExecuteEbcImageEntryPoint) + // + // Advance pointer to next bundle, then compute the offset from this bundle + // to the address of the entry point of the interpreter. + // + Ptr += 16; + if (Flags & FLAG_THUNK_ENTRY_POINT) { + Addr = (UINT64) ExecuteEbcImageEntryPoint; + } else { + Addr = (UINT64) EbcInterpret; + } + // + // Indirection on Itanium-based systems + // + Addr = *(UINT64 *) Addr; + + // + // Now write the code to load the offset into a register + // + Code[0] = OPCODE_NOP; + + // + // Next is simply Addr[62:22] (41 bits) of the address + // + Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff; + + // + // Extract bits from the address for insertion into the instruction + // i = Addr[63:63] + // + I = RShiftU64 (Addr, 63) & 0x01; + // + // ic = Addr[21:21] + // + Ic = RShiftU64 (Addr, 21) & 0x01; + // + // imm5c = Addr[20:16] for 5 bits + // + Imm5c = RShiftU64 (Addr, 16) & 0x1F; + // + // imm9d = Addr[15:7] for 9 bits + // + Imm9d = RShiftU64 (Addr, 7) & 0x1FF; + // + // imm7b = Addr[6:0] for 7 bits + // + Imm7b = Addr & 0x7F; + + // + // Put it in r31, a scratch register + // + RegNum = 31; + + // + // Next is jumbled data, including opcode and rest of address + // + Code[2] = LShiftU64(Imm7b, 13); + Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc + Code[2] = Code[2] | LShiftU64 (Ic, 21); + Code[2] = Code[2] | LShiftU64 (Imm5c, 22); + Code[2] = Code[2] | LShiftU64 (Imm9d, 27); + Code[2] = Code[2] | LShiftU64 (I, 36); + Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37); + Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6); + + WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]); + + // + // *************************** NEXT BUNDLE ********************************* + // + // Load branch register with EbcInterpret() function offset from the bundle + // address: mov b6 = RegNum + // + // See volume 3 page 4-29 of the Arch. Software Developer's Manual. + // + // Advance pointer to next bundle + // + Ptr += 16; + Code[0] = OPCODE_NOP; + Code[1] = OPCODE_NOP; + Code[2] = OPCODE_MOV_BX_RX; + + // + // Pick a branch register to use. Then fill in the bits for the branch + // register and user register (same user register as previous bundle). + // + Br = 6; + Code[2] |= LShiftU64 (Br, 6); + Code[2] |= LShiftU64 (RegNum, 13); + WriteBundle ((VOID *) Ptr, 0x0d, Code[0], Code[1], Code[2]); + + // + // *************************** NEXT BUNDLE ********************************* + // + // Now do the branch: (p0) br.cond.sptk.few b6 + // + // Advance pointer to next bundle. + // Fill in the bits for the branch register (same reg as previous bundle) + // + Ptr += 16; + Code[0] = OPCODE_NOP; + Code[1] = OPCODE_NOP; + Code[2] = OPCODE_BR_COND_SPTK_FEW; + Code[2] |= LShiftU64 (Br, 13); + WriteBundle ((VOID *) Ptr, 0x1d, Code[0], Code[1], Code[2]); + + // + // Add the thunk to our list of allocated thunks so we can do some cleanup + // when the image is unloaded. Do this last since the Add function flushes + // the instruction cache for us. + // + EbcAddImageThunk (ImageHandle, (VOID *) ThunkBase, ThunkSize); + + // + // Done + // + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +WriteBundle ( + IN VOID *MemPtr, + IN UINT8 Template, + IN UINT64 Slot0, + IN UINT64 Slot1, + IN UINT64 Slot2 + ) +/*++ + +Routine Description: + + Given raw bytes of Itanium based code, format them into a bundle and + write them out. + +Arguments: + + MemPtr - pointer to memory location to write the bundles to + Template - 5-bit template + Slot0-2 - instruction slot data for the bundle + +Returns: + + EFI_INVALID_PARAMETER - Pointer is not aligned + - No more than 5 bits in template + - More than 41 bits used in code + EFI_SUCCESS - All data is written. + +--*/ +{ + UINT8 *BPtr; + UINT32 Index; + UINT64 Low64; + UINT64 High64; + + // + // Verify pointer is aligned + // + if ((UINT64) MemPtr & 0xF) { + return EFI_INVALID_PARAMETER; + } + // + // Verify no more than 5 bits in template + // + if (Template &~0x1F) { + return EFI_INVALID_PARAMETER; + } + // + // Verify max of 41 bits used in code + // + if ((Slot0 | Slot1 | Slot2) &~0x1ffffffffff) { + return EFI_INVALID_PARAMETER; + } + + Low64 = LShiftU64 (Slot1, 46); + Low64 = Low64 | LShiftU64 (Slot0, 5) | Template; + + High64 = RShiftU64 (Slot1, 18); + High64 = High64 | LShiftU64 (Slot2, 23); + + // + // Now write it all out + // + BPtr = (UINT8 *) MemPtr; + for (Index = 0; Index < 8; Index++) { + *BPtr = (UINT8) Low64; + Low64 = RShiftU64 (Low64, 8); + BPtr++; + } + + for (Index = 0; Index < 8; Index++) { + *BPtr = (UINT8) High64; + High64 = RShiftU64 (High64, 8); + BPtr++; + } + + return EFI_SUCCESS; +} + +VOID +EbcLLCALLEX ( + IN VM_CONTEXT *VmPtr, + IN UINTN FuncAddr, + IN UINTN NewStackPointer, + IN VOID *FramePtr, + IN UINT8 Size + ) +/*++ + +Routine Description: + + 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. + +Arguments: + + VmPtr - Pointer to a VM context. + FuncAddr - Callee's address + NewStackPointer - New stack pointer after the call + FramePtr - New frame pointer after the call + Size - The size of call instruction + +Returns: + + None. + +--*/ +{ + UINTN IsThunk; + UINTN TargetEbcAddr; + UINTN CodeOne18; + UINTN CodeOne23; + UINTN CodeTwoI; + UINTN CodeTwoIc; + UINTN CodeTwo7b; + UINTN CodeTwo5c; + UINTN CodeTwo9d; + UINTN CalleeAddr; + + IsThunk = 1; + TargetEbcAddr = 0; + + // + // FuncAddr points to the descriptor of the target instructions. + // + CalleeAddr = *((UINT64 *)FuncAddr); + + // + // Processor specific code to check whether the callee is a thunk to EBC. + // + if (*((UINT64 *)CalleeAddr) != 0xBCCA000100000005) { + IsThunk = 0; + goto Action; + } + if (*((UINT64 *)CalleeAddr + 1) != 0x697623C1004A112E) { + IsThunk = 0; + goto Action; + } + + CodeOne18 = RShiftU64 (*((UINT64 *)CalleeAddr + 2), 46) & 0x3FFFF; + CodeOne23 = (*((UINT64 *)CalleeAddr + 3)) & 0x7FFFFF; + CodeTwoI = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 59) & 0x1; + CodeTwoIc = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 44) & 0x1; + CodeTwo7b = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 36) & 0x7F; + CodeTwo5c = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 45) & 0x1F; + CodeTwo9d = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 50) & 0x1FF; + + TargetEbcAddr = CodeTwo7b; + TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwo9d, 7); + TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwo5c, 16); + TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwoIc, 21); + TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeOne18, 22); + TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeOne23, 40); + TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwoI, 63); + +Action: + 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->R[0] -= 8; + VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], (UINTN) FramePtr); + VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->R[0]; + VmPtr->R[0] -= 8; + VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], (UINT64) (VmPtr->Ip + Size)); + + VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr; + } else { + // + // The callee is not a thunk to EBC, call native code. + // + EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr); + + // + // Get return value and advance the IP. + // + VmPtr->R[7] = EbcLLGetReturnValue (); + VmPtr->Ip += Size; + } +} diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h new file mode 100644 index 0000000000..f6c929ba3e --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h @@ -0,0 +1,56 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + EbcSupport.h + +Abstract: + + Definition of EBC Support function + +Revision History + +--*/ + +#ifndef _IPF_EBC_SUPPORT_H_ +#define _IPF_EBC_SUPPORT_H_ + +#define VM_STACK_SIZE (1024 * 32) + +#define EBC_THUNK_SIZE 128 +#define STACK_REMAIN_SIZE (1024 * 4) + +// +// For code execution, thunks must be aligned on 16-byte boundary +// +#define EBC_THUNK_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 + ); + +#endif diff --git a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.S b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.S new file mode 100644 index 0000000000..538462575b --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.S @@ -0,0 +1,144 @@ +#**************************************************************************** +#* +#* Copyright (c) 2006, Intel Corporation +#* All rights reserved. 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. +#* +#**************************************************************************** +#**************************************************************************** +# REV 1.0 +#**************************************************************************** +# +# Rev Date Description +# --- -------- ------------------------------------------------------------ +# 1.0 05/09/12 Initial creation of file. +# +#**************************************************************************** + +#* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * +# This code provides low level routines that support the Virtual Machine +# for option ROMs. +#* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + +#--------------------------------------------------------------------------- +# Equate files needed. +#--------------------------------------------------------------------------- + +#--------------------------------------------------------------------------- +##GenericPostSegment SEGMENT USE16 +#--------------------------------------------------------------------------- + +#**************************************************************************** +# EbcLLCALLEX +# +# This function is called to execute an EBC CALLEX instruction. +# This instruction requires that we thunk out to external native +# code. For x64, we switch stacks, copy the arguments to the stack +# and jump to the specified function. +# On return, we restore the stack pointer to its original location. +# +# Destroys no working registers. +#**************************************************************************** +.global _CopyMem; + +# VOID EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr) +.global _EbcLLCALLEXNative; +_EbcLLCALLEXNative: + push %rbp + push %rbx + mov %rsp, %rbp + # Function prolog + + # Copy FuncAddr to a preserved register. + mov %rcx, %rbx + + # Set stack pointer to new value + sub %r8, %rdx + sub %rsp, %r8 + mov %rsp, %rcx + sub %rsp, 0x20 + call _CopyMem + add %rsp, 0x20 + + # Considering the worst case, load 4 potiential arguments + # into registers. + mov (%rsp), %rcx + mov 8(%rsp), %rdx + mov 10(%rsp), %r8 + mov 18(%rsp), %r9 + + # Now call the external routine + call *%rbx + + # Function epilog + mov %rbp, %rsp + pop %rbx + pop %rbp + ret + + +# UINTN EbcLLGetEbcEntryPoint(VOID); +# Routine Description: +# The VM thunk code stuffs an EBC entry point into a processor +# register. Since we can't use inline assembly to get it from +# the interpreter C code, stuff it into the return value +# register and return. +# +# Arguments: +# None. +# +# Returns: +# The contents of the register in which the entry point is passed. +# +.global _EbcLLGetEbcEntryPoint; +_EbcLLGetEbcEntryPoint: + ret + +#/*++ +# +#Routine Description: +# +# Return the caller's value of the stack pointer. +# +#Arguments: +# +# None. +# +#Returns: +# +# The current value of the stack pointer for the caller. We +# adjust it by 4 here because when they called us, the return address +# is put on the stack, thereby lowering it by 4 bytes. +# +#--*/ + +# UINTN EbcLLGetStackPointer() +.global _EbcLLGetStackPointer; +_EbcLLGetStackPointer: + mov %rsp, %rax + # Stack adjusted by this much when we were called, + # For this function, it's 4. + add $4, %rax + ret + +.global _EbcLLGetReturnValue; +_EbcLLGetReturnValue: +# UINT64 EbcLLGetReturnValue(VOID); +# Routine Description: +# When EBC calls native, on return the VM has to stuff the return +# value into a VM register. It's assumed here that the value is still +# in the register, so simply return and the caller should get the +# return result properly. +# +# Arguments: +# None. +# +# Returns: +# The unmodified value returned by the native code. +# + ret diff --git a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.asm b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.asm new file mode 100644 index 0000000000..7b59e93aa1 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.asm @@ -0,0 +1,154 @@ + page ,132 + title VM ASSEMBLY LANGUAGE ROUTINES +;**************************************************************************** +;* +;* Copyright (c) 2006, Intel Corporation +;* All rights reserved. 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. +;* +;**************************************************************************** +;**************************************************************************** +; REV 1.0 +;**************************************************************************** +; +; Rev Date Description +; --- -------- ------------------------------------------------------------ +; 1.0 05/09/12 Initial creation of file. +; +;**************************************************************************** + +;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * +; This code provides low level routines that support the Virtual Machine +; for option ROMs. +;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + +;--------------------------------------------------------------------------- +; Equate files needed. +;--------------------------------------------------------------------------- + +text SEGMENT + +;--------------------------------------------------------------------------- +;;GenericPostSegment SEGMENT USE16 +;--------------------------------------------------------------------------- + +;**************************************************************************** +; EbcLLCALLEX +; +; This function is called to execute an EBC CALLEX instruction. +; This instruction requires that we thunk out to external native +; code. For x64, we switch stacks, copy the arguments to the stack +; and jump to the specified function. +; On return, we restore the stack pointer to its original location. +; +; Destroys no working registers. +;**************************************************************************** +; VOID EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr) + +CopyMem PROTO Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD + + +EbcLLCALLEXNative PROC NEAR PUBLIC + push rbp + push rbx + mov rbp, rsp + ; Function prolog + + ; Copy FuncAddr to a preserved register. + mov rbx, rcx + + ; Set stack pointer to new value + sub r8, rdx + sub rsp, r8 + mov rcx, rsp + sub rsp, 20h + call CopyMem + add rsp, 20h + + ; Considering the worst case, load 4 potiential arguments + ; into registers. + mov rcx, qword ptr [rsp] + mov rdx, qword ptr [rsp+8h] + mov r8, qword ptr [rsp+10h] + mov r9, qword ptr [rsp+18h] + + ; Now call the external routine + call rbx + + ; Function epilog + mov rsp, rbp + pop rbx + pop rbp + ret +EbcLLCALLEXNative ENDP + + +; UINTN EbcLLGetEbcEntryPoint(VOID); +; Routine Description: +; The VM thunk code stuffs an EBC entry point into a processor +; register. Since we can't use inline assembly to get it from +; the interpreter C code, stuff it into the return value +; register and return. +; +; Arguments: +; None. +; +; Returns: +; The contents of the register in which the entry point is passed. +; +EbcLLGetEbcEntryPoint PROC NEAR PUBLIC + ret +EbcLLGetEbcEntryPoint ENDP + +;/*++ +; +;Routine Description: +; +; Return the caller's value of the stack pointer. +; +;Arguments: +; +; None. +; +;Returns: +; +; The current value of the stack pointer for the caller. We +; adjust it by 4 here because when they called us, the return address +; is put on the stack, thereby lowering it by 4 bytes. +; +;--*/ + +; UINTN EbcLLGetStackPointer() +EbcLLGetStackPointer PROC NEAR PUBLIC + mov rax, rsp ; get current stack pointer + ; Stack adjusted by this much when we were called, + ; For this function, it's 4. + add rax, 4 + ret +EbcLLGetStackPointer ENDP + +; UINT64 EbcLLGetReturnValue(VOID); +; Routine Description: +; When EBC calls native, on return the VM has to stuff the return +; value into a VM register. It's assumed here that the value is still +; in the register, so simply return and the caller should get the +; return result properly. +; +; Arguments: +; None. +; +; Returns: +; The unmodified value returned by the native code. +; +EbcLLGetReturnValue PROC NEAR PUBLIC + ret +EbcLLGetReturnValue ENDP + +text ENDS +END + diff --git a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcSupport.c b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcSupport.c new file mode 100644 index 0000000000..bec82d67c5 --- /dev/null +++ b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcSupport.c @@ -0,0 +1,619 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + EbcSupport.c + +Abstract: + + This module contains EBC support routines that are customized based on + the target x64 processor. + +--*/ + +#include "EbcInt.h" +#include "EbcExecute.h" + +// +// NOTE: This is the stack size allocated for the interpreter +// when it executes an EBC image. The requirements can change +// based on whether or not a debugger is present, and other +// platform-specific configurations. +// +#define VM_STACK_SIZE (1024 * 8) +#define EBC_THUNK_SIZE 64 + +#define STACK_REMAIN_SIZE (1024 * 4) + +STATIC +VOID +PushU64 ( + VM_CONTEXT *VmPtr, + UINT64 Arg + ) +/*++ + +Routine Description: + + Push a 64 bit unsigned value to the VM stack. + +Arguments: + + VmPtr - The pointer to current VM context. + Arg - The value to be pushed + +Returns: + + VOID + +--*/ +{ + // + // 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; + return; +} + +STATIC +UINT64 +EbcInterpret ( + UINTN Arg1, + UINTN Arg2, + UINTN Arg3, + UINTN Arg4, + UINTN Arg5, + UINTN Arg6, + UINTN Arg7, + UINTN Arg8, + UINTN Arg9, + UINTN Arg10, + UINTN Arg11, + UINTN Arg12, + UINTN Arg13, + UINTN Arg14, + UINTN Arg15, + UINTN Arg16 + ) +/*++ + +Routine Description: + + 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: + + This is a thunk function. Microsoft x64 compiler only provide fast_call + calling convention, so the first four arguments are passed by rcx, rdx, + r8, and r9, while other arguments are passed in stack. + +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; + EFI_STATUS Status; + UINTN StackIndex; + + // + // Get the EBC entry point from the processor register. + // Don't call any function before getting the EBC entry + // point because this will collab the return register. + // + Addr = EbcLLGetEbcEntryPoint (); + + // + // 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. + // + Addr = EbcLLGetStackPointer (); + + // + // 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.R[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); + VmContext.HighStackBottom = (UINTN) VmContext.R[0]; + VmContext.R[0] -= sizeof (UINTN); + + // + // Align the stack on a natural boundary. + // + VmContext.R[0] &= ~(sizeof (UINTN) - 1); + + // + // Put a magic value in the stack gap, then adjust down again. + // + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) VM_STACK_KEY_VALUE; + VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0]; + + // + // The stack upper to LowStackTop is belong to the VM. + // + VmContext.LowStackTop = (UINTN) VmContext.R[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. + // The x64 does not do this so pad the stack accordingly. + // + PushU64 (&VmContext, (UINT64) 0); + PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL); + + // + // For x64, this is where we say our return address is + // + VmContext.StackRetAddr = (UINT64) VmContext.R[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.R[7]; +} + +STATIC +UINT64 +ExecuteEbcImageEntryPoint ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + + 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; + EFI_STATUS Status; + UINTN StackIndex; + + // + // 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 + // + 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. + // + Addr = EbcLLGetStackPointer (); + + Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex); + if (EFI_ERROR(Status)) { + return Status; + } + VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE); + VmContext.R[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); + VmContext.HighStackBottom = (UINTN) VmContext.R[0]; + VmContext.R[0] -= sizeof (UINTN); + + + // + // Put a magic value in the stack gap, then adjust down again + // + *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) VM_STACK_KEY_VALUE; + VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0]; + + // + // Align the stack on a natural boundary + VmContext.R[0] &= ~(sizeof(UINTN) - 1); + // + 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); + + // + // VM pushes 16-bytes for return address. Simulate that here. + // + PushU64 (&VmContext, (UINT64) 0); + PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL); + + // + // For x64, this is where we say our return address is + // + VmContext.StackRetAddr = (UINT64) VmContext.R[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.R[7]; +} + +EFI_STATUS +EbcCreateThunks ( + IN EFI_HANDLE ImageHandle, + IN VOID *EbcEntryPoint, + OUT VOID **Thunk, + IN UINT32 Flags + ) +/*++ + +Routine Description: + + Create an IA32 thunk for the given EBC entry point. + +Arguments: + + ImageHandle - Handle of image for which this thunk is being created + EbcEntryPoint - Address of the EBC code that the thunk is to call + Thunk - Returned thunk we create here + +Returns: + + Standard EFI status. + +--*/ +{ + UINT8 *Ptr; + UINT8 *ThunkBase; + UINT32 I; + UINT64 Addr; + INT32 Size; + INT32 ThunkSize; + + // + // Check alignment of pointer to EBC code + // + if ((UINT32) (UINTN) EbcEntryPoint & 0x01) { + return EFI_INVALID_PARAMETER; + } + + Size = EBC_THUNK_SIZE; + ThunkSize = Size; + + Ptr = AllocatePool (Size); + + 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; + + // + // Add a magic code here to help the VM recognize the thunk.. + // mov rax, ca112ebccall2ebch => 48 B8 BC 2E 11 CA BC 2E 11 CA + // + *Ptr = 0x48; + Ptr++; + Size--; + *Ptr = 0xB8; + Ptr++; + Size--; + Addr = (UINT64) 0xCA112EBCCA112EBCULL; + for (I = 0; I < sizeof (Addr); I++) { + *Ptr = (UINT8) (UINTN) Addr; + Addr >>= 8; + Ptr++; + Size--; + } + + // + // Add code bytes to load up a processor register with the EBC entry point. + // mov rax, 123456789abcdef0h => 48 B8 F0 DE BC 9A 78 56 34 12 + // The first 8 bytes of the thunk entry is the address of the EBC + // entry point. + // + *Ptr = 0x48; + Ptr++; + Size--; + *Ptr = 0xB8; + Ptr++; + Size--; + Addr = (UINT64) EbcEntryPoint; + for (I = 0; I < sizeof (Addr); I++) { + *Ptr = (UINT8) (UINTN) Addr; + Addr >>= 8; + Ptr++; + Size--; + } + + // + // Stick in a load of ecx with the address of appropriate VM function. + // Using r11 because it's a volatile register and won't be used in this + // point. + // mov r11 123456789abcdef0h => 49 BB F0 DE BC 9A 78 56 34 12 + // + if (Flags & FLAG_THUNK_ENTRY_POINT) { + Addr = (UINTN) ExecuteEbcImageEntryPoint; + } else { + Addr = (UINTN) EbcInterpret; + } + + // + // mov r11 Addr => 0x49 0xBB + // + *Ptr = 0x49; + Ptr++; + Size--; + *Ptr = 0xBB; + Ptr++; + Size--; + for (I = 0; I < sizeof (Addr); I++) { + *Ptr = (UINT8) Addr; + Addr >>= 8; + Ptr++; + Size--; + } + // + // Stick in jump opcode bytes for jmp r11 => 0x41 0xFF 0xE3 + // + *Ptr = 0x41; + Ptr++; + Size--; + *Ptr = 0xFF; + Ptr++; + Size--; + *Ptr = 0xE3; + Size--; + + // + // Double check that our defined size is ok (application error) + // + if (Size < 0) { + ASSERT (FALSE); + return EFI_BUFFER_TOO_SMALL; + } + // + // 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; +} + +VOID +EbcLLCALLEX ( + IN VM_CONTEXT *VmPtr, + IN UINTN FuncAddr, + IN UINTN NewStackPointer, + IN VOID *FramePtr, + IN UINT8 Size + ) +/*++ + +Routine Description: + + 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. + +Arguments: + + VmPtr - Pointer to a VM context. + FuncAddr - Callee's address + NewStackPointer - New stack pointer after the call + FramePtr - New frame pointer after the call + Size - The size of call instruction + +Returns: + + None. + +--*/ +{ + UINTN IsThunk; + UINTN TargetEbcAddr; + + IsThunk = 1; + TargetEbcAddr = 0; + + // + // Processor specific code to check whether the callee is a thunk to EBC. + // + if (*((UINT8 *)FuncAddr) != 0x48) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 1) != 0xB8) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 2) != 0xBC) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 3) != 0x2E) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 4) != 0x11) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 5) != 0xCA) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 6) != 0xBC) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 7) != 0x2E) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 8) != 0x11) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 9) != 0xCA) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 10) != 0x48) { + IsThunk = 0; + goto Action; + } + if (*((UINT8 *)FuncAddr + 11) != 0xB8) { + IsThunk = 0; + goto Action; + } + + CopyMem (&TargetEbcAddr, (UINT8 *)FuncAddr + 12, 8); + +Action: + 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->R[0] -= 8; + VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], (UINTN) FramePtr); + VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->R[0]; + VmPtr->R[0] -= 8; + VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], (UINT64) (VmPtr->Ip + Size)); + + VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr; + } else { + // + // The callee is not a thunk to EBC, call native code. + // + EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr); + + // + // Get return value and advance the IP. + // + VmPtr->R[7] = EbcLLGetReturnValue (); + VmPtr->Ip += Size; + } +} + diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.c b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.c new file mode 100644 index 0000000000..38fe11d80b --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.c @@ -0,0 +1,931 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + + +Module Name: + + FtwLite.c + +Abstract: + + This is a simple fault tolerant write driver, based on PlatformFd library. + And it only supports write BufferSize <= SpareAreaLength. + + This boot service only protocol provides fault tolerant write capability for + block devices. The protocol has internal non-volatile intermediate storage + of the data and private information. It should be able to recover + automatically from a critical fault, such as power failure. + +Notes: + + The implementation uses an FTW Lite (Fault Tolerant Write) Work Space. + This work space is a memory copy of the work space on the Woring Block, + the size of the work space is the FTW_WORK_SPACE_SIZE bytes. + +--*/ + +#include + +// +// In write function, we should check the target range to prevent the user +// from writing Spare block and Working space directly. +// +// +// Fault Tolerant Write Protocol API +// +EFI_STATUS +EFIAPI +FtwLiteWrite ( + IN EFI_FTW_LITE_PROTOCOL *This, + IN EFI_HANDLE FvbHandle, + IN EFI_LBA Lba, + IN UINTN Offset, + IN OUT UINTN *NumBytes, + IN VOID *Buffer + ) +/*++ + +Routine Description: + Starts a target block update. This function will record data about write + in fault tolerant storage and will complete the write in a recoverable + manner, ensuring at all times that either the original contents or + the modified contents are available. + +Arguments: + This - Calling context + FvbHandle - The handle of FVB protocol that provides services for + reading, writing, and erasing the target block. + Lba - The logical block address of the target block. + Offset - The offset within the target block to place the data. + NumBytes - The number of bytes to write to the target block. + Buffer - The data to write. + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_BAD_BUFFER_SIZE - The write would span a target block, which is not + a valid action. + EFI_ACCESS_DENIED - No writes have been allocated. + EFI_NOT_FOUND - Cannot find FVB by handle. + EFI_OUT_OF_RESOURCES - Cannot allocate memory. + EFI_ABORTED - The function could not complete successfully. + +--*/ +{ + EFI_STATUS Status; + EFI_FTW_LITE_DEVICE *FtwLiteDevice; + EFI_FTW_LITE_RECORD *Record; + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb; + EFI_PHYSICAL_ADDRESS FvbPhysicalAddress; + UINTN MyLength; + UINTN MyOffset; + UINTN MyBufferSize; + UINT8 *MyBuffer; + UINTN SpareBufferSize; + UINT8 *SpareBuffer; + UINTN Index; + UINT8 *Ptr; + EFI_DEV_PATH_PTR DevPtr; + + // + // Refresh work space and get last record + // + FtwLiteDevice = FTW_LITE_CONTEXT_FROM_THIS (This); + Status = WorkSpaceRefresh (FtwLiteDevice); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + + Record = FtwLiteDevice->FtwLastRecord; + + // + // Check the flags of last write record + // + if ((Record->WriteAllocated == FTW_VALID_STATE) || (Record->SpareCompleted == FTW_VALID_STATE)) { + return EFI_ACCESS_DENIED; + } + // + // IF former record has completed, THEN use next record + // + if (Record->WriteCompleted == FTW_VALID_STATE) { + Record++; + FtwLiteDevice->FtwLastRecord = Record; + } + + MyOffset = (UINT8 *) Record - FtwLiteDevice->FtwWorkSpace; + + // + // Check if the input data can fit within the target block + // + if ((Offset +*NumBytes) > FtwLiteDevice->SpareAreaLength) { + return EFI_BAD_BUFFER_SIZE; + } + // + // Check if there is enough free space for allocate a record + // + if ((MyOffset + WRITE_TOTAL_SIZE) > FtwLiteDevice->FtwWorkSpaceSize) { + Status = FtwReclaimWorkSpace (FtwLiteDevice); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_ERROR, "FtwLite: Reclaim work space - %r", Status)); + return EFI_ABORTED; + } + } + // + // Get the FVB protocol by handle + // + Status = FtwGetFvbByHandle (FvbHandle, &Fvb); + if (EFI_ERROR (Status)) { + return EFI_NOT_FOUND; + } + // + // Allocate a write record in workspace. + // Update Header->WriteAllocated as VALID + // + Status = FtwUpdateFvState ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase + MyOffset, + WRITE_ALLOCATED + ); + + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Allocate record - %r\n", Status)); + return EFI_ABORTED; + } + + Record->WriteAllocated = FTW_VALID_STATE; + + // + // Prepare data of write record, filling DevPath with memory mapped address. + // + DevPtr.MemMap = (MEMMAP_DEVICE_PATH *) &Record->DevPath; + DevPtr.MemMap->Header.Type = HARDWARE_DEVICE_PATH; + DevPtr.MemMap->Header.SubType = HW_MEMMAP_DP; + SetDevicePathNodeLength (&DevPtr.MemMap->Header, sizeof (MEMMAP_DEVICE_PATH)); + + Status = Fvb->GetPhysicalAddress (Fvb, &FvbPhysicalAddress); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Get FVB physical address - %r\n", Status)); + return EFI_ABORTED; + } + + DevPtr.MemMap->MemoryType = EfiMemoryMappedIO; + DevPtr.MemMap->StartingAddress = FvbPhysicalAddress; + DevPtr.MemMap->EndingAddress = FvbPhysicalAddress +*NumBytes; + // + // ignored! + // + Record->Lba = Lba; + Record->Offset = Offset; + Record->NumBytes = *NumBytes; + + // + // Write the record to the work space. + // + MyOffset = (UINT8 *) Record - FtwLiteDevice->FtwWorkSpace; + MyLength = FTW_LITE_RECORD_SIZE; + + Status = FtwLiteDevice->FtwFvBlock->Write ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase + MyOffset, + &MyLength, + (UINT8 *) Record + ); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + // + // Record has been written to working block, then write data. + // + // + // Allocate a memory buffer + // + MyBufferSize = FtwLiteDevice->SpareAreaLength; + MyBuffer = AllocatePool (MyBufferSize); + if (MyBuffer == NULL) { + return EFI_OUT_OF_RESOURCES; + } + // + // Starting at Lba, if the number of the rest blocks on Fvb is less + // than NumberOfSpareBlock. + // + // + // Read all original data from target block to memory buffer + // + if (IsInWorkingBlock (FtwLiteDevice, Fvb, Lba)) { + // + // If target block falls into working block, we must follow the process of + // updating working block. + // + Ptr = MyBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + MyLength = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwFvBlock->Read ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkBlockLba + Index, + 0, + &MyLength, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (MyBuffer); + return EFI_ABORTED; + } + + Ptr += MyLength; + } + // + // Update Offset by adding the offset from the start LBA of working block to + // the target LBA. The target block can not span working block! + // + Offset = (((UINTN) (Lba - FtwLiteDevice->FtwWorkBlockLba)) * FtwLiteDevice->SizeOfSpareBlock + Offset); + ASSERT ((Offset +*NumBytes) <= FtwLiteDevice->SpareAreaLength); + + } else { + + Ptr = MyBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + MyLength = FtwLiteDevice->SizeOfSpareBlock; + Status = Fvb->Read (Fvb, Lba + Index, 0, &MyLength, Ptr); + if (EFI_ERROR (Status)) { + FreePool (MyBuffer); + return EFI_ABORTED; + } + + Ptr += MyLength; + } + } + // + // Overwrite the updating range data with + // the input buffer content + // + CopyMem (MyBuffer + Offset, Buffer, *NumBytes); + + // + // Try to keep the content of spare block + // Save spare block into a spare backup memory buffer (Sparebuffer) + // + SpareBufferSize = FtwLiteDevice->SpareAreaLength; + SpareBuffer = AllocatePool (SpareBufferSize); + if (SpareBuffer == NULL) { + FreePool (MyBuffer); + return EFI_OUT_OF_RESOURCES; + } + + Ptr = SpareBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + MyLength = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Read ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &MyLength, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (MyBuffer); + FreePool (SpareBuffer); + return EFI_ABORTED; + } + + Ptr += MyLength; + } + // + // Write the memory buffer to spare block + // Don't forget to erase Flash first. + // + Status = FtwEraseSpareBlock (FtwLiteDevice); + Ptr = MyBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + MyLength = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Write ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &MyLength, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (MyBuffer); + FreePool (SpareBuffer); + return EFI_ABORTED; + } + + Ptr += MyLength; + } + // + // Free MyBuffer + // + FreePool (MyBuffer); + + // + // Set the SpareCompleteD in the FTW record, + // + MyOffset = (UINT8 *) Record - FtwLiteDevice->FtwWorkSpace; + Status = FtwUpdateFvState ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase + MyOffset, + SPARE_COMPLETED + ); + if (EFI_ERROR (Status)) { + FreePool (SpareBuffer); + return EFI_ABORTED; + } + + Record->SpareCompleted = FTW_VALID_STATE; + + // + // Since the content has already backuped in spare block, the write is + // guaranteed to be completed with fault tolerant manner. + // + Status = FtwWriteRecord (FtwLiteDevice, Fvb); + if (EFI_ERROR (Status)) { + FreePool (SpareBuffer); + return EFI_ABORTED; + } + + Record++; + FtwLiteDevice->FtwLastRecord = Record; + + // + // Restore spare backup buffer into spare block , if no failure happened during FtwWrite. + // + Status = FtwEraseSpareBlock (FtwLiteDevice); + Ptr = SpareBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + MyLength = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Write ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &MyLength, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (SpareBuffer); + return EFI_ABORTED; + } + + Ptr += MyLength; + } + // + // All success. + // + FreePool (SpareBuffer); + + DEBUG ( + (EFI_D_FTW_LITE, + "FtwLite: Write() success, (Lba:Offset)=(%lx:0x%x), NumBytes: 0x%x\n", + Lba, + Offset, + *NumBytes) + ); + + return EFI_SUCCESS; +} + + +EFI_STATUS +FtwWriteRecord ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb + ) +/*++ + +Routine Description: + Write a record with fault tolerant mannaer. + Since the content has already backuped in spare block, the write is + guaranteed to be completed with fault tolerant manner. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + Fvb - The FVB protocol that provides services for + reading, writing, and erasing the target block. + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully + +--*/ +{ + EFI_STATUS Status; + EFI_FTW_LITE_RECORD *Record; + EFI_LBA WorkSpaceLbaOffset; + UINTN Offset; + + // + // Spare Complete but Destination not complete, + // Recover the targt block with the spare block. + // + Record = FtwLiteDevice->FtwLastRecord; + + // + // IF target block is working block, THEN Flush Spare Block To Working Block; + // ELSE IF target block is boot block, THEN Flush Spare Block To boot Block; + // ELSE flush spare block to normal target block.ENDIF + // + if (IsInWorkingBlock (FtwLiteDevice, Fvb, Record->Lba)) { + // + // If target block is working block, Attention: + // it's required to set SPARE_COMPLETED to spare block. + // + WorkSpaceLbaOffset = FtwLiteDevice->FtwWorkSpaceLba - FtwLiteDevice->FtwWorkBlockLba; + Offset = (UINT8 *) Record - FtwLiteDevice->FtwWorkSpace; + Status = FtwUpdateFvState ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + WorkSpaceLbaOffset, + FtwLiteDevice->FtwWorkSpaceBase + Offset, + SPARE_COMPLETED + ); + ASSERT_EFI_ERROR (Status); + + Status = FlushSpareBlockToWorkingBlock (FtwLiteDevice); + } else if (IsBootBlock (FtwLiteDevice, Fvb, Record->Lba)) { + // + // Update boot block + // + Status = FlushSpareBlockToBootBlock (FtwLiteDevice); + } else { + // + // Update blocks other than working block or boot block + // + Status = FlushSpareBlockToTargetBlock (FtwLiteDevice, Fvb, Record->Lba); + } + + ASSERT_EFI_ERROR (Status); + + // + // Set WriteCompleted flag in record + // + Offset = (UINT8 *) Record - FtwLiteDevice->FtwWorkSpace; + Status = FtwUpdateFvState ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase + Offset, + WRITE_COMPLETED + ); + ASSERT_EFI_ERROR (Status); + + Record->WriteCompleted = FTW_VALID_STATE; + return EFI_SUCCESS; +} + + +EFI_STATUS +FtwRestart ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Restarts a previously interrupted write. The caller must provide the + block protocol needed to complete the interrupted write. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + FvbHandle - The handle of FVB protocol that provides services for + reading, writing, and erasing the target block. + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ACCESS_DENIED - No pending writes exist + EFI_NOT_FOUND - FVB protocol not found by the handle + EFI_ABORTED - The function could not complete successfully + +--*/ +{ + EFI_STATUS Status; + EFI_FTW_LITE_RECORD *Record; + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb; + EFI_DEV_PATH_PTR DevPathPtr; + + // + // Spare Completed but Destination not complete, + // Recover the targt block with the spare block. + // + Record = FtwLiteDevice->FtwLastRecord; + + // + // Only support memory mapped FVB device path by now. + // + DevPathPtr.MemMap = (MEMMAP_DEVICE_PATH *) &Record->DevPath; + if (!((DevPathPtr.MemMap->Header.Type == HARDWARE_DEVICE_PATH) && (DevPathPtr.MemMap->Header.SubType == HW_MEMMAP_DP)) + ) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: FVB Device Path is not memory mapped\n")); + return EFI_ABORTED; + } + + Status = GetFvbByAddress (DevPathPtr.MemMap->StartingAddress, &Fvb); + if (EFI_ERROR (Status)) { + return EFI_NOT_FOUND; + } + // + // Since the content has already backuped in spare block, the write is + // guaranteed to be completed with fault tolerant manner. + // + Status = FtwWriteRecord (FtwLiteDevice, Fvb); + DEBUG ((EFI_D_FTW_INFO, "FtwLite: Restart() - %r\n", Status)); + + Record++; + FtwLiteDevice->FtwLastRecord = Record; + + // + // Erase Spare block + // This is restart, no need to keep spareblock content. + // + FtwEraseSpareBlock (FtwLiteDevice); + + return Status; +} + + +EFI_STATUS +FtwAbort ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Aborts all previous allocated writes. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully. + EFI_NOT_FOUND - No allocated writes exist. + +--*/ +{ + EFI_STATUS Status; + UINTN Offset; + + if (FtwLiteDevice->FtwLastRecord->WriteCompleted == FTW_VALID_STATE) { + return EFI_NOT_FOUND; + } + // + // Update the complete state of the header as VALID and abort. + // + Offset = (UINT8 *) FtwLiteDevice->FtwLastRecord - FtwLiteDevice->FtwWorkSpace; + Status = FtwUpdateFvState ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase + Offset, + WRITE_COMPLETED + ); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + + FtwLiteDevice->FtwLastRecord->WriteCompleted = FTW_VALID_STATE; + + Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord); + + // + // Erase the spare block + // + Status = FtwEraseSpareBlock (FtwLiteDevice); + + DEBUG ((EFI_D_FTW_INFO, "FtwLite: Abort() success \n")); + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +InitializeFtwLite ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + Routine Description: + This function is the entry point of the Fault Tolerant Write driver. + + Arguments: + ImageHandle - EFI_HANDLE: A handle for the image that is initializing + this driver + SystemTable - EFI_SYSTEM_TABLE: A pointer to the EFI system table + + Returns: + EFI_SUCCESS - FTW has finished the initialization + EFI_ABORTED - FTW initialization error + +--*/ +{ + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb; + UINTN Index; + EFI_HANDLE *HandleBuffer; + UINTN HandleCount; + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; + EFI_PHYSICAL_ADDRESS BaseAddress; + EFI_FTW_LITE_DEVICE *FtwLiteDevice; + EFI_FTW_LITE_RECORD *Record; + UINTN Length; + EFI_STATUS Status; + UINTN Offset; + EFI_FV_BLOCK_MAP_ENTRY *FvbMapEntry; + UINT32 LbaIndex; + + // + // Allocate Private data of this driver, + // INCLUDING THE FtwWorkSpace[FTW_WORK_SPACE_SIZE]. + // + FtwLiteDevice = NULL; + FtwLiteDevice = AllocatePool (sizeof (EFI_FTW_LITE_DEVICE) + FTW_WORK_SPACE_SIZE); + if (FtwLiteDevice != NULL) { + Status = EFI_SUCCESS; + } else { + Status = EFI_OUT_OF_RESOURCES; + } + + ASSERT_EFI_ERROR (Status); + + ZeroMem (FtwLiteDevice, sizeof (EFI_FTW_LITE_DEVICE)); + FtwLiteDevice->Signature = FTW_LITE_DEVICE_SIGNATURE; + + // + // Initialize other parameters, and set WorkSpace as FTW_ERASED_BYTE. + // + FtwLiteDevice->FtwWorkSpace = (UINT8 *) (FtwLiteDevice + 1); + FtwLiteDevice->FtwWorkSpaceSize = FTW_WORK_SPACE_SIZE; + SetMem ( + FtwLiteDevice->FtwWorkSpace, + FtwLiteDevice->FtwWorkSpaceSize, + FTW_ERASED_BYTE + ); + FtwLiteDevice->FtwWorkSpaceHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) FtwLiteDevice->FtwWorkSpace; + + FtwLiteDevice->FtwLastRecord = NULL; + + FtwLiteDevice->WorkSpaceAddress = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageFtwWorkingBase); + FtwLiteDevice->WorkSpaceLength = (UINTN) PcdGet32 (PcdFlashNvStorageFtwWorkingSize); + + FtwLiteDevice->SpareAreaAddress = (EFI_PHYSICAL_ADDRESS) PcdGet32 (PcdFlashNvStorageFtwSpareBase); + FtwLiteDevice->SpareAreaLength = (UINTN) PcdGet32 (PcdFlashNvStorageFtwSpareSize); + + ASSERT ((FtwLiteDevice->WorkSpaceLength != 0) && (FtwLiteDevice->SpareAreaLength != 0)); + + // + // Locate FVB protocol + // + Status = gBS->LocateHandleBuffer ( + ByProtocol, + &gEfiFirmwareVolumeBlockProtocolGuid, + NULL, + &HandleCount, + &HandleBuffer + ); + ASSERT_EFI_ERROR (Status); + + ASSERT (HandleCount > 0); + + FtwLiteDevice->FtwFvBlock = NULL; + FtwLiteDevice->FtwBackupFvb = NULL; + FtwLiteDevice->FtwWorkSpaceLba = (EFI_LBA) (-1); + FtwLiteDevice->FtwSpareLba = (EFI_LBA) (-1); + for (Index = 0; Index < HandleCount; Index += 1) { + Status = gBS->HandleProtocol ( + HandleBuffer[Index], + &gEfiFirmwareVolumeBlockProtocolGuid, + (VOID **) &Fvb + ); + ASSERT_EFI_ERROR (Status); + + Status = Fvb->GetPhysicalAddress (Fvb, &BaseAddress); + if (EFI_ERROR (Status)) { + continue; + } + + FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) BaseAddress); + + if ((FtwLiteDevice->WorkSpaceAddress >= BaseAddress) && + (FtwLiteDevice->WorkSpaceAddress <= (BaseAddress + FwVolHeader->FvLength)) + ) { + FtwLiteDevice->FtwFvBlock = Fvb; + // + // To get the LBA of work space + // + if ((FwVolHeader->FvLength) > (FwVolHeader->HeaderLength)) { + // + // FV may have multiple types of BlockLength + // + FvbMapEntry = &FwVolHeader->BlockMap[0]; + while (!((FvbMapEntry->NumBlocks == 0) && (FvbMapEntry->Length == 0))) { + for (LbaIndex = 1; LbaIndex <= FvbMapEntry->NumBlocks; LbaIndex += 1) { + if (FtwLiteDevice->WorkSpaceAddress < (BaseAddress + FvbMapEntry->Length * LbaIndex)) { + FtwLiteDevice->FtwWorkSpaceLba = LbaIndex - 1; + // + // Get the Work space size and Base(Offset) + // + FtwLiteDevice->FtwWorkSpaceSize = FtwLiteDevice->WorkSpaceLength; + FtwLiteDevice->FtwWorkSpaceBase = (UINTN) (FtwLiteDevice->WorkSpaceAddress - (BaseAddress + FvbMapEntry->Length * (LbaIndex - 1))); + break; + } + } + // + // end for + // + FvbMapEntry++; + } + // + // end while + // + } + } + + if ((FtwLiteDevice->SpareAreaAddress >= BaseAddress) && + (FtwLiteDevice->SpareAreaAddress <= (BaseAddress + FwVolHeader->FvLength)) + ) { + FtwLiteDevice->FtwBackupFvb = Fvb; + // + // To get the LBA of spare + // + if ((FwVolHeader->FvLength) > (FwVolHeader->HeaderLength)) { + // + // FV may have multiple types of BlockLength + // + FvbMapEntry = &FwVolHeader->BlockMap[0]; + while (!((FvbMapEntry->NumBlocks == 0) && (FvbMapEntry->Length == 0))) { + for (LbaIndex = 1; LbaIndex <= FvbMapEntry->NumBlocks; LbaIndex += 1) { + if (FtwLiteDevice->SpareAreaAddress < (BaseAddress + FvbMapEntry->Length * LbaIndex)) { + // + // Get the NumberOfSpareBlock and SizeOfSpareBlock + // + FtwLiteDevice->FtwSpareLba = LbaIndex - 1; + FtwLiteDevice->SizeOfSpareBlock = FvbMapEntry->Length; + FtwLiteDevice->NumberOfSpareBlock = FtwLiteDevice->SpareAreaLength / FtwLiteDevice->SizeOfSpareBlock; + // + // Check the range of spare area to make sure that it's in FV range + // + ASSERT ((FtwLiteDevice->FtwSpareLba + FtwLiteDevice->NumberOfSpareBlock) <= FvbMapEntry->NumBlocks); + break; + } + } + + FvbMapEntry++; + } + // + // end while + // + } + } + } + // + // Calculate the start LBA of working block. Working block is an area which + // contains working space in its last block and has the same size as spare + // block, unless there are not enough blocks before the block that contains + // working space. + // + FtwLiteDevice->FtwWorkBlockLba = FtwLiteDevice->FtwWorkSpaceLba - FtwLiteDevice->NumberOfSpareBlock + 1; + if ((INT64) (FtwLiteDevice->FtwWorkBlockLba) < 0) { + FtwLiteDevice->FtwWorkBlockLba = 0; + } + + if ((FtwLiteDevice->FtwFvBlock == NULL) || + (FtwLiteDevice->FtwBackupFvb == NULL) || + (FtwLiteDevice->FtwWorkSpaceLba == (EFI_LBA) (-1)) || + (FtwLiteDevice->FtwSpareLba == (EFI_LBA) (-1)) + ) { + DEBUG ((EFI_D_ERROR, "FtwLite: Working or spare FVB not ready\n")); + ASSERT_EFI_ERROR (Status); + } + // + // Refresh workspace data from working block + // + Status = WorkSpaceRefresh (FtwLiteDevice); + ASSERT_EFI_ERROR (Status); + + // + // If the working block workspace is not valid, try the spare block + // + if (!IsValidWorkSpace (FtwLiteDevice->FtwWorkSpaceHeader)) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Workspace invalid, read from backup\n")); + // + // Read from spare block + // + Length = FtwLiteDevice->FtwWorkSpaceSize; + Status = FtwLiteDevice->FtwBackupFvb->Read ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba, + FtwLiteDevice->FtwWorkSpaceBase, + &Length, + FtwLiteDevice->FtwWorkSpace + ); + ASSERT_EFI_ERROR (Status); + + // + // If spare block is valid, then replace working block content. + // + if (IsValidWorkSpace (FtwLiteDevice->FtwWorkSpaceHeader)) { + Status = FlushSpareBlockToWorkingBlock (FtwLiteDevice); + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Restart working block in Init() - %r\n", Status)); + ASSERT_EFI_ERROR (Status); + + FtwAbort (FtwLiteDevice); + // + // Refresh work space. + // + Status = WorkSpaceRefresh (FtwLiteDevice); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + } else { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Both are invalid, init workspace\n")); + // + // If both are invalid, then initialize work space. + // + SetMem ( + FtwLiteDevice->FtwWorkSpace, + FtwLiteDevice->FtwWorkSpaceSize, + FTW_ERASED_BYTE + ); + InitWorkSpaceHeader (FtwLiteDevice->FtwWorkSpaceHeader); + // + // Write to work space on the working block + // + Length = FtwLiteDevice->FtwWorkSpaceSize; + Status = FtwLiteDevice->FtwFvBlock->Write ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase, + &Length, + FtwLiteDevice->FtwWorkSpace + ); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + } + } + // + // Hook the protocol API + // + FtwLiteDevice->FtwLiteInstance.Write = FtwLiteWrite; + + // + // Install protocol interface + // + Status = gBS->InstallProtocolInterface ( + &FtwLiteDevice->Handle, + &gEfiFaultTolerantWriteLiteProtocolGuid, + EFI_NATIVE_INTERFACE, + &FtwLiteDevice->FtwLiteInstance + ); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + // + // If (!SpareCompleted) THEN Abort to rollback. + // + if ((FtwLiteDevice->FtwLastRecord->WriteAllocated == FTW_VALID_STATE) && + (FtwLiteDevice->FtwLastRecord->SpareCompleted != FTW_VALID_STATE) + ) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Init.. record not SpareCompleted, abort()\n")); + FtwAbort (FtwLiteDevice); + } + // + // if (SpareCompleted) THEN Restart to fault tolerant write. + // + if ((FtwLiteDevice->FtwLastRecord->SpareCompleted == FTW_VALID_STATE) && + (FtwLiteDevice->FtwLastRecord->WriteCompleted != FTW_VALID_STATE) + ) { + + Status = FtwRestart (FtwLiteDevice); + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Restart last write - %r\n", Status)); + if (EFI_ERROR (Status)) { + return Status; + } + } + // + // To check the workspace buffer behind last records is EMPTY or not. + // If it's not EMPTY, FTW_LITE also need to call reclaim(). + // + Record = FtwLiteDevice->FtwLastRecord; + Offset = (UINT8 *) Record - FtwLiteDevice->FtwWorkSpace; + if (FtwLiteDevice->FtwWorkSpace[Offset] != FTW_ERASED_BYTE) { + Offset += WRITE_TOTAL_SIZE; + } + + if (!IsErasedFlashBuffer ( + FTW_ERASE_POLARITY, + FtwLiteDevice->FtwWorkSpace + Offset, + FtwLiteDevice->FtwWorkSpaceSize - Offset + )) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Workspace is dirty, call reclaim...\n")); + Status = FtwReclaimWorkSpace (FtwLiteDevice); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Workspace reclaim - %r\n", Status)); + return EFI_ABORTED; + } + } + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.dxs b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.dxs new file mode 100644 index 0000000000..93aa2168ea --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.dxs @@ -0,0 +1,27 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + + +Module Name: + + FtwLite.dxs + +Abstract: + + Dependency expression source file. + +--*/ +#include + + +DEPENDENCY_START + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID AND EFI_ALTERNATE_FV_BLOCK_GUID +DEPENDENCY_END diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.h b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.h new file mode 100644 index 0000000000..8bc122dbd3 --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.h @@ -0,0 +1,695 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + + +Module Name: + + FtwLite.h + +Abstract: + + This is a simple fault tolerant write driver, based on PlatformFd library. + And it only supports write BufferSize <= SpareAreaLength. + + This boot service only protocol provides fault tolerant write capability for + block devices. The protocol has internal non-volatile intermediate storage + of the data and private information. It should be able to recover + automatically from a critical fault, such as power failure. + +--*/ + +#ifndef _EFI_FAULT_TOLERANT_WRITE_LITE_H_ +#define _EFI_FAULT_TOLERANT_WRITE_LITE_H_ + +// +// The package level header files this module uses +// +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include + +#include + +#define EFI_D_FTW_LITE EFI_D_ERROR +#define EFI_D_FTW_INFO EFI_D_INFO + +// +// Flash erase polarity is 1 +// +#define FTW_ERASE_POLARITY 1 + +#define FTW_VALID_STATE 0 +#define FTW_INVALID_STATE 1 + +#define FTW_ERASED_BYTE ((UINT8) (255)) +#define FTW_POLARITY_REVERT ((UINT8) (255)) + +typedef struct { + UINT8 WriteAllocated : 1; + UINT8 SpareCompleted : 1; + UINT8 WriteCompleted : 1; + UINT8 Reserved : 5; +#define WRITE_ALLOCATED 0x1 +#define SPARE_COMPLETED 0x2 +#define WRITE_COMPLETED 0x4 + + EFI_DEV_PATH DevPath; + EFI_LBA Lba; + UINTN Offset; + UINTN NumBytes; + // + // UINTN SpareAreaOffset; + // +} EFI_FTW_LITE_RECORD; + +#define FTW_LITE_DEVICE_SIGNATURE EFI_SIGNATURE_32 ('F', 'T', 'W', 'L') + +// +// MACRO for Block size. +// Flash Erasing will do in block granularity. +// +#ifdef FV_BLOCK_SIZE +#define FTW_BLOCK_SIZE FV_BLOCK_SIZE +#else +#define FV_BLOCK_SIZE 0x10000 +#define FTW_BLOCK_SIZE FV_BLOCK_SIZE +#endif +// +// MACRO for FTW WORK SPACE Base & Size +// +#ifdef EFI_FTW_WORKING_OFFSET +#define FTW_WORK_SPACE_BASE EFI_FTW_WORKING_OFFSET +#else +#define FTW_WORK_SPACE_BASE 0x00E000 +#endif + +#ifdef EFI_FTW_WORKING_LENGTH +#define FTW_WORK_SPACE_SIZE EFI_FTW_WORKING_LENGTH +#else +#define FTW_WORK_SPACE_SIZE 0x002000 +#endif +// +// MACRO for FTW header and record +// +#define FTW_WORKING_QUEUE_SIZE (FTW_WORK_SPACE_SIZE - sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER)) +#define FTW_LITE_RECORD_SIZE (sizeof (EFI_FTW_LITE_RECORD)) +#define WRITE_TOTAL_SIZE FTW_LITE_RECORD_SIZE + +// +// EFI Fault tolerant protocol private data structure +// +typedef struct { + UINTN Signature; + EFI_HANDLE Handle; + EFI_FTW_LITE_PROTOCOL FtwLiteInstance; + EFI_PHYSICAL_ADDRESS WorkSpaceAddress; + UINTN WorkSpaceLength; + EFI_PHYSICAL_ADDRESS SpareAreaAddress; + UINTN SpareAreaLength; + UINTN NumberOfSpareBlock; // Number of the blocks in spare block + UINTN SizeOfSpareBlock; // Block size in bytes of the blocks in spare block + EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *FtwWorkSpaceHeader; + EFI_FTW_LITE_RECORD *FtwLastRecord; + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FtwFvBlock; // FVB of working block + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FtwBackupFvb; // FVB of spare block + EFI_LBA FtwSpareLba; + EFI_LBA FtwWorkBlockLba; // Start LBA of working block + EFI_LBA FtwWorkSpaceLba; // Start LBA of working space + UINTN FtwWorkSpaceBase; // Offset from LBA start addr + UINTN FtwWorkSpaceSize; + UINT8 *FtwWorkSpace; + // + // Following a buffer of FtwWorkSpace[FTW_WORK_SPACE_SIZE], + // Allocated with EFI_FTW_LITE_DEVICE. + // +} EFI_FTW_LITE_DEVICE; + +#define FTW_LITE_CONTEXT_FROM_THIS(a) CR (a, EFI_FTW_LITE_DEVICE, FtwLiteInstance, FTW_LITE_DEVICE_SIGNATURE) + +// +// Driver entry point +// +EFI_STATUS +EFIAPI +InitializeFtwLite ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + This function is the entry point of the Fault Tolerant Write driver. + +Arguments: + ImageHandle - EFI_HANDLE: A handle for the image that is initializing + this driver + SystemTable - EFI_SYSTEM_TABLE: A pointer to the EFI system table + +Returns: + EFI_SUCCESS - FTW has finished the initialization + EFI_ABORTED - FTW initialization error + +--*/ +; + +// +// Fault Tolerant Write Protocol API +// +EFI_STATUS +EFIAPI +FtwLiteWrite ( + IN EFI_FTW_LITE_PROTOCOL *This, + IN EFI_HANDLE FvbHandle, + IN EFI_LBA Lba, + IN UINTN Offset, + IN UINTN *NumBytes, + IN VOID *Buffer + ) +/*++ + +Routine Description: + Starts a target block update. This function will record data about write + in fault tolerant storage and will complete the write in a recoverable + manner, ensuring at all times that either the original contents or + the modified contents are available. + +Arguments: + This - Calling context + FvbHandle - The handle of FVB protocol that provides services for + reading, writing, and erasing the target block. + Lba - The logical block address of the target block. + Offset - The offset within the target block to place the data. + NumBytes - The number of bytes to write to the target block. + Buffer - The data to write. + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_BAD_BUFFER_SIZE - The write would span a target block, which is not + a valid action. + EFI_ACCESS_DENIED - No writes have been allocated. + EFI_NOT_FOUND - Cannot find FVB by handle. + EFI_OUT_OF_RESOURCES - Cannot allocate memory. + EFI_ABORTED - The function could not complete successfully. + +--*/ +; + +// +// Internal functions +// +EFI_STATUS +FtwRestart ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Restarts a previously interrupted write. The caller must provide the + block protocol needed to complete the interrupted write. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + FvbHandle - The handle of FVB protocol that provides services for + reading, writing, and erasing the target block. + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ACCESS_DENIED - No pending writes exist + EFI_NOT_FOUND - FVB protocol not found by the handle + EFI_ABORTED - The function could not complete successfully + +--*/ +; + +EFI_STATUS +FtwAbort ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Aborts all previous allocated writes. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully. + EFI_NOT_FOUND - No allocated writes exist. + +--*/ +; + + +EFI_STATUS +FtwWriteRecord ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb + ) +/*++ + +Routine Description: + Write a record with fault tolerant mannaer. + Since the content has already backuped in spare block, the write is + guaranteed to be completed with fault tolerant manner. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + Fvb - The FVB protocol that provides services for + reading, writing, and erasing the target block. + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully + +--*/ +; + +EFI_STATUS +FtwEraseBlock ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + To Erase one block. The size is FTW_BLOCK_SIZE + +Arguments: + FtwLiteDevice - Calling context + FvBlock - FVB Protocol interface + Lba - Lba of the firmware block + +Returns: + EFI_SUCCESS - Block LBA is Erased successfully + Others - Error occurs + +--*/ +; + +EFI_STATUS +FtwEraseSpareBlock ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + + Erase spare block. + +Arguments: + + FtwLiteDevice - Calling context + +Returns: + + Status code + +--*/ +; + +EFI_STATUS +FtwGetFvbByHandle ( + IN EFI_HANDLE FvBlockHandle, + OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvBlock + ) +/*++ + +Routine Description: + Retrive the proper FVB protocol interface by HANDLE. + +Arguments: + FvBlockHandle - The handle of FVB protocol that provides services for + reading, writing, and erasing the target block. + FvBlock - The interface of FVB protocol + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully +--*/ +; + +EFI_STATUS +GetFvbByAddress ( + IN EFI_PHYSICAL_ADDRESS Address, + OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvBlock + ) +/*++ + +Routine Description: + + Get firmware block by address. + +Arguments: + + Address - Address specified the block + FvBlock - The block caller wanted + +Returns: + + Status code + + EFI_NOT_FOUND - Block not found + +--*/ +; + +BOOLEAN +IsInWorkingBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + + Is it in working block? + +Arguments: + + FtwLiteDevice - Calling context + FvBlock - Fvb protocol instance + Lba - The block specified + +Returns: + + In working block or not + +--*/ +; + +BOOLEAN +IsBootBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + + Check whether the block is a boot block. + +Arguments: + + FtwLiteDevice - Calling context + FvBlock - Fvb protocol instance + Lba - Lba value + +Returns: + + Is a boot block or not + +--*/ +; + +EFI_STATUS +FlushSpareBlockToTargetBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + Copy the content of spare block to a target block. Size is FTW_BLOCK_SIZE. + Spare block is accessed by FTW backup FVB protocol interface. LBA is + FtwLiteDevice->FtwSpareLba. + Target block is accessed by FvBlock protocol interface. LBA is Lba. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + FvBlock - FVB Protocol interface to access target block + Lba - Lba of the target block + +Returns: + EFI_SUCCESS - Spare block content is copied to target block + EFI_INVALID_PARAMETER - Input parameter error + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +--*/ +; + +EFI_STATUS +FlushSpareBlockToWorkingBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Copy the content of spare block to working block. Size is FTW_BLOCK_SIZE. + Spare block is accessed by FTW backup FVB protocol interface. LBA is + FtwLiteDevice->FtwSpareLba. + Working block is accessed by FTW working FVB protocol interface. LBA is + FtwLiteDevice->FtwWorkBlockLba. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + +Returns: + EFI_SUCCESS - Spare block content is copied to target block + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +Notes: + Since the working block header is important when FTW initializes, the + state of the operation should be handled carefully. The Crc value is + calculated without STATE element. + +--*/ +; + +EFI_STATUS +FlushSpareBlockToBootBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Copy the content of spare block to a boot block. Size is FTW_BLOCK_SIZE. + Spare block is accessed by FTW backup FVB protocol interface. LBA is + FtwLiteDevice->FtwSpareLba. + Boot block is accessed by BootFvb protocol interface. LBA is 0. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + +Returns: + EFI_SUCCESS - Spare block content is copied to boot block + EFI_INVALID_PARAMETER - Input parameter error + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +Notes: + +--*/ +; + +EFI_STATUS +FtwUpdateFvState ( + IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + IN EFI_LBA Lba, + IN UINTN Offset, + IN UINT8 NewBit + ) +/*++ + +Routine Description: + Update a bit of state on a block device. The location of the bit is + calculated by the (Lba, Offset, bit). Here bit is determined by the + the name of a certain bit. + +Arguments: + FvBlock - FVB Protocol interface to access SrcBlock and DestBlock + Lba - Lba of a block + Offset - Offset on the Lba + NewBit - New value that will override the old value if it can be change + +Returns: + EFI_SUCCESS - A state bit has been updated successfully + Others - Access block device error. + +Notes: + Assume all bits of State are inside the same BYTE. + + EFI_ABORTED - Read block fail +--*/ +; + +EFI_STATUS +FtwGetLastRecord ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + OUT EFI_FTW_LITE_RECORD **FtwLastRecord + ) +/*++ + +Routine Description: + Get the last Write record pointer. + The last record is the record whose 'complete' state hasn't been set. + After all, this header may be a EMPTY header entry for next Allocate. + +Arguments: + FtwLiteDevice - Private data of this driver + FtwLastRecord - Pointer to retrieve the last write record + +Returns: + EFI_SUCCESS - Get the last write record successfully + EFI_ABORTED - The FTW work space is damaged + +--*/ +; + +BOOLEAN +IsErasedFlashBuffer ( + IN BOOLEAN Polarity, + IN UINT8 *Buffer, + IN UINTN BufferSize + ) +/*++ + +Routine Description: + + Check whether a flash buffer is erased. + +Arguments: + + Polarity - All 1 or all 0 + Buffer - Buffer to check + BufferSize - Size of the buffer + +Returns: + + Erased or not. + +--*/ +; + +EFI_STATUS +InitWorkSpaceHeader ( + IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader + ) +/*++ + +Routine Description: + Initialize a work space when there is no work space. + +Arguments: + WorkingHeader - Pointer of working block header + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully. + +--*/ +; + +EFI_STATUS +WorkSpaceRefresh ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Read from working block to refresh the work space in memory. + +Arguments: + FtwLiteDevice - Point to private data of FTW driver + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully. + +--*/ +; + +BOOLEAN +IsValidWorkSpace ( + IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader + ) +/*++ + +Routine Description: + Check to see if it is a valid work space. + +Arguments: + WorkingHeader - Pointer of working block header + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully. + +--*/ +; + +EFI_STATUS +CleanupWorkSpace ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + IN OUT UINT8 *BlockBuffer, + IN UINTN BufferSize + ) +/*++ + +Routine Description: + Reclaim the work space. Get rid of all the completed write records + and write records in the Fault Tolerant work space. + +Arguments: + FtwLiteDevice - Point to private data of FTW driver + FtwSpaceBuffer - Buffer to contain the reclaimed clean data + BufferSize - Size of the FtwSpaceBuffer + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_BUFFER_TOO_SMALL - The FtwSpaceBuffer is too small + EFI_ABORTED - The function could not complete successfully. + +--*/ +; + +EFI_STATUS +FtwReclaimWorkSpace ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Reclaim the work space on the working block. + +Arguments: + FtwLiteDevice - Point to private data of FTW driver + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +--*/ +; + +#endif diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.inf b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.inf new file mode 100644 index 0000000000..39422f2428 --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.inf @@ -0,0 +1,133 @@ +#/** @file +# Component description file for FtwLite module. +# +# This driver provides fault tolerant write capability for block devices. +# Copyright (c) 2006 - 2007, Intel Corporation +# +# All rights reserved. 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = FtwLite + FILE_GUID = 4C862FC6-0E54-4e36-8C8F-FF6F3167951F + MODULE_TYPE = DXE_DRIVER + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = InitializeFtwLite + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF EBC +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + FtwLite.dxs + FtwWorkSpace.c + FtwMisc.c + FtwLite.c + FtwLite.h + +[Sources.Ia32] + Ia32/Ia32FtwMisc.c + +[Sources.X64] + x64/x64FtwMisc.c + +[Sources.IPF] + Ipf/IpfFtwMisc.c + +[Sources.EBC] + Ia32/Ia32FtwMisc.c + + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + + + +################################################################################ +# +# Library Class Section - list of Library Classes that are required for +# this module. +# +################################################################################ + +[LibraryClasses] + UefiBootServicesTableLib + MemoryAllocationLib + BaseMemoryLib + UefiDriverEntryPoint + DebugLib + PcdLib + + +################################################################################ +# +# Guid C Name Section - list of Guids that this module uses or produces. +# +################################################################################ + +[Guids] + gEfiSystemNvDataFvGuid # ALWAYS_CONSUMED + + +################################################################################ +# +# Protocol C Name Section - list of Protocol and Protocol Notify C Names +# that this module uses or produces. +# +################################################################################ + +[Protocols] + gEfiFirmwareVolumeBlockProtocolGuid # PROTOCOL ALWAYS_CONSUMED + gEfiFaultTolerantWriteLiteProtocolGuid # PROTOCOL ALWAYS_PRODUCED + +[Protocols.IA32] + gEfiPciRootBridgeIoProtocolGuid # PROTOCOL ALWAYS_CONSUMED + +[Protocols.EBC] + gEfiPciRootBridgeIoProtocolGuid # PROTOCOL ALWAYS_CONSUMED + + +################################################################################ +# +# Pcd DYNAMIC - list of PCDs that this module is coded for. +# +################################################################################ + +[PcdsDynamic.common] + PcdFlashNvStorageFtwWorkingSize|gEfiGenericPlatformTokenSpaceGuid + PcdFlashNvStorageFtwWorkingBase|gEfiGenericPlatformTokenSpaceGuid + PcdFlashNvStorageFtwSpareSize|gEfiGenericPlatformTokenSpaceGuid + PcdFlashNvStorageFtwSpareBase|gEfiGenericPlatformTokenSpaceGuid + diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.msa b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.msa new file mode 100644 index 0000000000..7362f47f33 --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.msa @@ -0,0 +1,103 @@ + + + + FtwLite + DXE_DRIVER + 4C862FC6-0E54-4e36-8C8F-FF6F3167951F + 1.0 + Component description file for FtwLite module. + This driver provides fault tolerant write capability for block devices. + Copyright (c) 2006 - 2007, Intel Corporation + All rights reserved. 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 X64 IPF EBC + false + FtwLite + + + + PcdLib + + + DebugLib + + + UefiDriverEntryPoint + + + BaseMemoryLib + + + MemoryAllocationLib + + + UefiBootServicesTableLib + + + + FtwLite.h + FtwLite.c + FtwMisc.c + FtwWorkSpace.c + FtwLite.dxs + Ia32/Ia32FtwMisc.c + x64/x64FtwMisc.c + Ipf/IpfFtwMisc.c + + + + + + + + gEfiFaultTolerantWriteLiteProtocolGuid + + + gEfiPciRootBridgeIoProtocolGuid + + + gEfiFirmwareVolumeBlockProtocolGuid + + + + + gEfiSystemNvDataFvGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + InitializeFtwLite + + + + + PcdFlashNvStorageFtwSpareBase + gEfiGenericPlatformTokenSpaceGuid + To get base address of the FTW spare block section in NV firmware volume. + + + PcdFlashNvStorageFtwSpareSize + gEfiGenericPlatformTokenSpaceGuid + To get size of the FTW spare block section in NV firmware volume. + + + PcdFlashNvStorageFtwWorkingBase + gEfiGenericPlatformTokenSpaceGuid + To get base address of the FTW working block section in NV firmware volume. + + + PcdFlashNvStorageFtwWorkingSize + gEfiGenericPlatformTokenSpaceGuid + To get size of the FTW working block section in NV firmware volume. + + + diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwMisc.c b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwMisc.c new file mode 100644 index 0000000000..eb334eaedd --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwMisc.c @@ -0,0 +1,530 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + +Module Name: + + FtwMisc.c + +Abstract: + + Internal functions to support fault tolerant write. + +Revision History + +--*/ + +#include + +BOOLEAN +IsErasedFlashBuffer ( + IN BOOLEAN Polarity, + IN UINT8 *Buffer, + IN UINTN BufferSize + ) +/*++ + +Routine Description: + + Check whether a flash buffer is erased. + +Arguments: + + Polarity - All 1 or all 0 + Buffer - Buffer to check + BufferSize - Size of the buffer + +Returns: + + Erased or not. + +--*/ +{ + UINT8 ErasedValue; + UINT8 *Ptr; + + if (Polarity) { + ErasedValue = 0xFF; + } else { + ErasedValue = 0; + } + + Ptr = Buffer; + while (BufferSize--) { + if (*Ptr++ != ErasedValue) { + return FALSE; + } + } + + return TRUE; +} + +EFI_STATUS +FtwEraseBlock ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + To Erase one block. The size is FTW_BLOCK_SIZE + +Arguments: + FtwLiteDevice - Calling context + FvBlock - FVB Protocol interface + Lba - Lba of the firmware block + +Returns: + EFI_SUCCESS - Block LBA is Erased successfully + Others - Error occurs + +--*/ +{ + return FvBlock->EraseBlocks ( + FvBlock, + Lba, + FtwLiteDevice->NumberOfSpareBlock, + EFI_LBA_LIST_TERMINATOR + ); +} + +EFI_STATUS +FtwEraseSpareBlock ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + + Erase spare block. + +Arguments: + + FtwLiteDevice - Calling context + +Returns: + + Status code + +--*/ +{ + return FtwLiteDevice->FtwBackupFvb->EraseBlocks ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba, + FtwLiteDevice->NumberOfSpareBlock, + EFI_LBA_LIST_TERMINATOR + ); +} + +EFI_STATUS +FtwGetFvbByHandle ( + IN EFI_HANDLE FvBlockHandle, + OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvBlock + ) +/*++ + +Routine Description: + Retrive the proper FVB protocol interface by HANDLE. + +Arguments: + FvBlockHandle - The handle of FVB protocol that provides services for + reading, writing, and erasing the target block. + FvBlock - The interface of FVB protocol + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully +--*/ +{ + // + // To get the FVB protocol interface on the handle + // + return gBS->HandleProtocol ( + FvBlockHandle, + &gEfiFirmwareVolumeBlockProtocolGuid, + (VOID **) FvBlock + ); +} + +EFI_STATUS +GetFvbByAddress ( + IN EFI_PHYSICAL_ADDRESS Address, + OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvBlock + ) +/*++ + +Routine Description: + + Get firmware block by address. + +Arguments: + + Address - Address specified the block + FvBlock - The block caller wanted + +Returns: + + Status code + + EFI_NOT_FOUND - Block not found + +--*/ +{ + EFI_STATUS Status; + EFI_HANDLE *HandleBuffer; + UINTN HandleCount; + UINTN Index; + EFI_PHYSICAL_ADDRESS FvbBaseAddress; + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb; + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; + + *FvBlock = NULL; + // + // Locate all handles of Fvb protocol + // + Status = gBS->LocateHandleBuffer ( + ByProtocol, + &gEfiFirmwareVolumeBlockProtocolGuid, + NULL, + &HandleCount, + &HandleBuffer + ); + if (EFI_ERROR (Status)) { + return EFI_NOT_FOUND; + } + // + // Search all FVB until find the right one + // + for (Index = 0; Index < HandleCount; Index += 1) { + Status = gBS->HandleProtocol ( + HandleBuffer[Index], + &gEfiFirmwareVolumeBlockProtocolGuid, + (VOID **) &Fvb + ); + if (EFI_ERROR (Status)) { + Status = EFI_NOT_FOUND; + break; + } + // + // Compare the address and select the right one + // + Status = Fvb->GetPhysicalAddress (Fvb, &FvbBaseAddress); + if (EFI_ERROR (Status)) { + continue; + } + + FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvbBaseAddress); + if ((Address >= FvbBaseAddress) && (Address <= (FvbBaseAddress + (FwVolHeader->FvLength - 1)))) { + *FvBlock = Fvb; + Status = EFI_SUCCESS; + break; + } + } + + FreePool (HandleBuffer); + return Status; +} + +BOOLEAN +IsInWorkingBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + + Is it in working block? + +Arguments: + + FtwLiteDevice - Calling context + FvBlock - Fvb protocol instance + Lba - The block specified + +Returns: + + In working block or not + +--*/ +{ + // + // If matching the following condition, the target block is in working block. + // 1. Target block is on the FV of working block (Using the same FVB protocol instance). + // 2. Lba falls into the range of working block. + // + return (BOOLEAN) + ( + (FvBlock == FtwLiteDevice->FtwFvBlock) && + (Lba >= FtwLiteDevice->FtwWorkBlockLba) && + (Lba <= FtwLiteDevice->FtwWorkSpaceLba) + ); +} + +EFI_STATUS +FlushSpareBlockToTargetBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + Copy the content of spare block to a target block. Size is FTW_BLOCK_SIZE. + Spare block is accessed by FTW backup FVB protocol interface. LBA is + FtwLiteDevice->FtwSpareLba. + Target block is accessed by FvBlock protocol interface. LBA is Lba. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + FvBlock - FVB Protocol interface to access target block + Lba - Lba of the target block + +Returns: + EFI_SUCCESS - Spare block content is copied to target block + EFI_INVALID_PARAMETER - Input parameter error + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +--*/ +{ + EFI_STATUS Status; + UINTN Length; + UINT8 *Buffer; + UINTN Count; + UINT8 *Ptr; + UINTN Index; + + if ((FtwLiteDevice == NULL) || (FvBlock == NULL)) { + return EFI_INVALID_PARAMETER; + } + // + // Allocate a memory buffer + // + Length = FtwLiteDevice->SpareAreaLength; + Buffer = AllocatePool (Length); + if (Buffer == NULL) { + return EFI_OUT_OF_RESOURCES; + } + // + // Read all content of spare block to memory buffer + // + Ptr = Buffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Count = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Read ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &Count, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return Status; + } + + Ptr += Count; + } + // + // Erase the target block + // + Status = FtwEraseBlock (FtwLiteDevice, FvBlock, Lba); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return EFI_ABORTED; + } + // + // Write memory buffer to block, using the FvbBlock protocol interface + // + Ptr = Buffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Count = FtwLiteDevice->SizeOfSpareBlock; + Status = FvBlock->Write (FvBlock, Lba + Index, 0, &Count, Ptr); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: FVB Write block - %r\n", Status)); + FreePool (Buffer); + return Status; + } + + Ptr += Count; + } + + FreePool (Buffer); + + return Status; +} + +EFI_STATUS +FlushSpareBlockToWorkingBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Copy the content of spare block to working block. Size is FTW_BLOCK_SIZE. + Spare block is accessed by FTW backup FVB protocol interface. LBA is + FtwLiteDevice->FtwSpareLba. + Working block is accessed by FTW working FVB protocol interface. LBA is + FtwLiteDevice->FtwWorkBlockLba. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + +Returns: + EFI_SUCCESS - Spare block content is copied to target block + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +Notes: + Since the working block header is important when FTW initializes, the + state of the operation should be handled carefully. The Crc value is + calculated without STATE element. + +--*/ +{ + EFI_STATUS Status; + UINTN Length; + UINT8 *Buffer; + EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader; + EFI_LBA WorkSpaceLbaOffset; + UINTN Count; + UINT8 *Ptr; + UINTN Index; + + // + // Allocate a memory buffer + // + Length = FtwLiteDevice->SpareAreaLength; + Buffer = AllocatePool (Length); + if (Buffer == NULL) { + return EFI_OUT_OF_RESOURCES; + } + // + // To guarantee that the WorkingBlockValid is set on spare block + // + WorkSpaceLbaOffset = FtwLiteDevice->FtwWorkSpaceLba - FtwLiteDevice->FtwWorkBlockLba; + FtwUpdateFvState ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + WorkSpaceLbaOffset, + FtwLiteDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32), + WORKING_BLOCK_VALID + ); + // + // Read from spare block to memory buffer + // + Ptr = Buffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Count = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Read ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &Count, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return Status; + } + + Ptr += Count; + } + // + // Clear the CRC and STATE, copy data from spare to working block. + // + WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) (Buffer + (UINTN) WorkSpaceLbaOffset * FtwLiteDevice->SizeOfSpareBlock + FtwLiteDevice->FtwWorkSpaceBase); + InitWorkSpaceHeader (WorkingBlockHeader); + WorkingBlockHeader->WorkingBlockValid = FTW_ERASE_POLARITY; + WorkingBlockHeader->WorkingBlockInvalid = FTW_ERASE_POLARITY; + + // + // target block is working block, then + // Set WorkingBlockInvalid in EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER + // before erase the working block. + // + // Offset = EFI_FIELD_OFFSET(EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER, + // WorkingBlockInvalid); + // To skip Signature and Crc: sizeof(EFI_GUID)+sizeof(UINT32). + // + Status = FtwUpdateFvState ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32), + WORKING_BLOCK_INVALID + ); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return EFI_ABORTED; + } + + FtwLiteDevice->FtwWorkSpaceHeader->WorkingBlockInvalid = FTW_VALID_STATE; + + // + // Erase the working block + // + Status = FtwEraseBlock ( + FtwLiteDevice, + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkBlockLba + ); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return EFI_ABORTED; + } + // + // Write memory buffer to working block, using the FvbBlock protocol interface + // + Ptr = Buffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Count = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwFvBlock->Write ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkBlockLba + Index, + 0, + &Count, + Ptr + ); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: FVB Write block - %r\n", Status)); + FreePool (Buffer); + return Status; + } + + Ptr += Count; + } + // + // Since the memory buffer will not be used, free memory Buffer. + // + FreePool (Buffer); + + // + // Update the VALID of the working block + // + // Offset = EFI_FIELD_OFFSET(EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER, + // WorkingBlockValid); + // Hardcode offset sizeof(EFI_GUID)+sizeof(UINT32), to skip Signature and Crc + // + Status = FtwUpdateFvState ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase + sizeof (EFI_GUID) + sizeof (UINT32), + WORKING_BLOCK_VALID + ); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + + FtwLiteDevice->FtwWorkSpaceHeader->WorkingBlockValid = FTW_VALID_STATE; + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwWorkSpace.c b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwWorkSpace.c new file mode 100644 index 0000000000..00d7d8e912 --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwWorkSpace.c @@ -0,0 +1,561 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + +Module Name: + + FtwWorkSpace.c + +Abstract: + +Revision History + +--*/ + + +#include + +BOOLEAN +IsValidWorkSpace ( + IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader + ) +/*++ + +Routine Description: + Check to see if it is a valid work space. + +Arguments: + WorkingHeader - Pointer of working block header + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully. + +--*/ +{ + EFI_STATUS Status; + EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER WorkingBlockHeader; + + ASSERT (WorkingHeader != NULL); + if (WorkingHeader->WorkingBlockValid != FTW_VALID_STATE) { + return FALSE; + } + // + // Check signature with gEfiSystemNvDataFvGuid + // + if (!CompareGuid (&gEfiSystemNvDataFvGuid, &WorkingHeader->Signature)) { + return FALSE; + } + // + // Check the CRC of header + // + CopyMem ( + &WorkingBlockHeader, + WorkingHeader, + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER) + ); + + // + // Filter out the Crc and State fields + // + SetMem ( + &WorkingBlockHeader.Crc, + sizeof (UINT32), + FTW_ERASED_BYTE + ); + WorkingBlockHeader.WorkingBlockValid = FTW_ERASE_POLARITY; + WorkingBlockHeader.WorkingBlockInvalid = FTW_ERASE_POLARITY; + + // + // Calculate the Crc of woking block header + // + Status = gBS->CalculateCrc32 ( + (UINT8 *) &WorkingBlockHeader, + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER), + &WorkingBlockHeader.Crc + ); + ASSERT_EFI_ERROR (Status); + + if (WorkingBlockHeader.Crc != WorkingHeader->Crc) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Work block header CRC check error\n")); + return FALSE; + } + + return TRUE; +} + +EFI_STATUS +InitWorkSpaceHeader ( + IN EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingHeader + ) +/*++ + +Routine Description: + Initialize a work space when there is no work space. + +Arguments: + WorkingHeader - Pointer of working block header + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully. + +--*/ +{ + EFI_STATUS Status; + + ASSERT (WorkingHeader != NULL); + + // + // Here using gEfiSystemNvDataFvGuid as the signature. + // + CopyMem ( + &WorkingHeader->Signature, + &gEfiSystemNvDataFvGuid, + sizeof (EFI_GUID) + ); + WorkingHeader->WriteQueueSize = FTW_WORKING_QUEUE_SIZE; + + // + // Crc is calculated with all the fields except Crc and STATE + // + WorkingHeader->WorkingBlockValid = FTW_ERASE_POLARITY; + WorkingHeader->WorkingBlockInvalid = FTW_ERASE_POLARITY; + SetMem (&WorkingHeader->Crc, sizeof (UINT32), FTW_ERASED_BYTE); + + // + // Calculate the CRC value + // + Status = gBS->CalculateCrc32 ( + (UINT8 *) WorkingHeader, + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER), + &WorkingHeader->Crc + ); + ASSERT_EFI_ERROR (Status); + + // + // Restore the WorkingBlockValid flag to VALID state + // + WorkingHeader->WorkingBlockValid = FTW_VALID_STATE; + WorkingHeader->WorkingBlockInvalid = FTW_INVALID_STATE; + + return EFI_SUCCESS; +} + +EFI_STATUS +FtwUpdateFvState ( + IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + IN EFI_LBA Lba, + IN UINTN Offset, + IN UINT8 NewBit + ) +/*++ + +Routine Description: + Update a bit of state on a block device. The location of the bit is + calculated by the (Lba, Offset, bit). Here bit is determined by the + the name of a certain bit. + +Arguments: + FvBlock - FVB Protocol interface to access SrcBlock and DestBlock + Lba - Lba of a block + Offset - Offset on the Lba + NewBit - New value that will override the old value if it can be change + +Returns: + EFI_SUCCESS - A state bit has been updated successfully + Others - Access block device error. + +Notes: + Assume all bits of State are inside the same BYTE. + + EFI_ABORTED - Read block fail +--*/ +{ + EFI_STATUS Status; + UINT8 State; + UINTN Length; + + // + // Read state from device, assume State is only one byte. + // + Length = sizeof (UINT8); + Status = FvBlock->Read (FvBlock, Lba, Offset, &Length, &State); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + + State ^= FTW_POLARITY_REVERT; + State = (UINT8) (State | NewBit); + State ^= FTW_POLARITY_REVERT; + + // + // Write state back to device + // + Length = sizeof (UINT8); + Status = FvBlock->Write (FvBlock, Lba, Offset, &Length, &State); + + return Status; +} + +EFI_STATUS +FtwGetLastRecord ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + OUT EFI_FTW_LITE_RECORD **FtwLastRecord + ) +/*++ + +Routine Description: + Get the last Write record pointer. + The last record is the record whose 'complete' state hasn't been set. + After all, this header may be a EMPTY header entry for next Allocate. + +Arguments: + FtwLiteDevice - Private data of this driver + FtwLastRecord - Pointer to retrieve the last write record + +Returns: + EFI_SUCCESS - Get the last write record successfully + EFI_ABORTED - The FTW work space is damaged + +--*/ +{ + EFI_FTW_LITE_RECORD *Record; + + Record = (EFI_FTW_LITE_RECORD *) (FtwLiteDevice->FtwWorkSpaceHeader + 1); + while (Record->WriteCompleted == FTW_VALID_STATE) { + // + // If Offset exceed the FTW work space boudary, return error. + // + if ((UINTN) ((UINT8 *) Record - FtwLiteDevice->FtwWorkSpace) > FtwLiteDevice->FtwWorkSpaceSize) { + return EFI_ABORTED; + } + + Record++; + } + // + // Last write record is found + // + *FtwLastRecord = Record; + return EFI_SUCCESS; +} + +EFI_STATUS +WorkSpaceRefresh ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Read from working block to refresh the work space in memory. + +Arguments: + FtwLiteDevice - Point to private data of FTW driver + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_ABORTED - The function could not complete successfully. + +--*/ +{ + EFI_STATUS Status; + UINTN Length; + UINTN Offset; + EFI_FTW_LITE_RECORD *Record; + + // + // Initialize WorkSpace as FTW_ERASED_BYTE + // + SetMem ( + FtwLiteDevice->FtwWorkSpace, + FtwLiteDevice->FtwWorkSpaceSize, + FTW_ERASED_BYTE + ); + + // + // Read from working block + // + Length = FtwLiteDevice->FtwWorkSpaceSize; + Status = FtwLiteDevice->FtwFvBlock->Read ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkSpaceLba, + FtwLiteDevice->FtwWorkSpaceBase, + &Length, + FtwLiteDevice->FtwWorkSpace + ); + if (EFI_ERROR (Status)) { + return EFI_ABORTED; + } + // + // Refresh the FtwLastRecord + // + Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord); + + Record = FtwLiteDevice->FtwLastRecord; + Offset = (UINTN) (UINT8 *) Record - (UINTN) FtwLiteDevice->FtwWorkSpace; + + // + // IF work space has error or Record is out of the workspace limit, THEN + // call reclaim. + // + if (EFI_ERROR (Status) || (Offset + WRITE_TOTAL_SIZE >= FtwLiteDevice->FtwWorkSpaceSize)) { + // + // reclaim work space in working block. + // + Status = FtwReclaimWorkSpace (FtwLiteDevice); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: Reclaim workspace - %r\n", Status)); + return EFI_ABORTED; + } + } + + return EFI_SUCCESS; +} + +EFI_STATUS +CleanupWorkSpace ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + IN OUT UINT8 *FtwSpaceBuffer, + IN UINTN BufferSize + ) +/*++ + +Routine Description: + Reclaim the work space. Get rid of all the completed write records + and write records in the Fault Tolerant work space. + +Arguments: + FtwLiteDevice - Point to private data of FTW driver + FtwSpaceBuffer - Buffer to contain the reclaimed clean data + BufferSize - Size of the FtwSpaceBuffer + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_BUFFER_TOO_SMALL - The FtwSpaceBuffer is too small + EFI_ABORTED - The function could not complete successfully. + +--*/ +{ + UINTN Length; + EFI_FTW_LITE_RECORD *Record; + + // + // To check if the buffer is large enough + // + Length = FtwLiteDevice->FtwWorkSpaceSize; + if (BufferSize < Length) { + return EFI_BUFFER_TOO_SMALL; + } + // + // Clear the content of buffer that will save the new work space data + // + SetMem (FtwSpaceBuffer, Length, FTW_ERASED_BYTE); + + // + // Copy EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER to buffer + // + CopyMem ( + FtwSpaceBuffer, + FtwLiteDevice->FtwWorkSpaceHeader, + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER) + ); + + // + // Get the last record + // + Record = FtwLiteDevice->FtwLastRecord; + if ((Record != NULL) && (Record->WriteAllocated == FTW_VALID_STATE) && (Record->WriteCompleted != FTW_VALID_STATE)) { + CopyMem ( + (UINT8 *) FtwSpaceBuffer + sizeof (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER), + Record, + WRITE_TOTAL_SIZE + ); + } + + return EFI_SUCCESS; +} + +EFI_STATUS +FtwReclaimWorkSpace ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Reclaim the work space on the working block. + +Arguments: + FtwLiteDevice - Point to private data of FTW driver + +Returns: + EFI_SUCCESS - The function completed successfully + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +--*/ +{ + EFI_STATUS Status; + UINT8 *TempBuffer; + UINTN TempBufferSize; + UINT8 *Ptr; + UINTN Length; + UINTN Index; + UINTN SpareBufferSize; + UINT8 *SpareBuffer; + EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *WorkingBlockHeader; + + DEBUG ((EFI_D_FTW_LITE, "FtwLite: start to reclaim work space\n")); + + // + // Read all original data from working block to a memory buffer + // + TempBufferSize = FtwLiteDevice->SpareAreaLength; + TempBuffer = AllocateZeroPool (TempBufferSize); + if (TempBuffer != NULL) { + return EFI_OUT_OF_RESOURCES; + } + + Ptr = TempBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Length = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwFvBlock->Read ( + FtwLiteDevice->FtwFvBlock, + FtwLiteDevice->FtwWorkBlockLba + Index, + 0, + &Length, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (TempBuffer); + return EFI_ABORTED; + } + + Ptr += Length; + } + // + // Clean up the workspace, remove all the completed records. + // + Ptr = TempBuffer + + ((UINTN) (FtwLiteDevice->FtwWorkSpaceLba - FtwLiteDevice->FtwWorkBlockLba)) * + FtwLiteDevice->SizeOfSpareBlock + FtwLiteDevice->FtwWorkSpaceBase; + + Status = CleanupWorkSpace ( + FtwLiteDevice, + Ptr, + FtwLiteDevice->FtwWorkSpaceSize + ); + + CopyMem ( + FtwLiteDevice->FtwWorkSpace, + Ptr, + FtwLiteDevice->FtwWorkSpaceSize + ); + + Status = FtwGetLastRecord (FtwLiteDevice, &FtwLiteDevice->FtwLastRecord); + + // + // Set the WorkingBlockValid and WorkingBlockInvalid as INVALID + // + WorkingBlockHeader = (EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER *) Ptr; + WorkingBlockHeader->WorkingBlockValid = FTW_INVALID_STATE; + WorkingBlockHeader->WorkingBlockInvalid = FTW_INVALID_STATE; + + // + // Try to keep the content of spare block + // Save spare block into a spare backup memory buffer (Sparebuffer) + // + SpareBufferSize = FtwLiteDevice->SpareAreaLength; + SpareBuffer = AllocatePool (SpareBufferSize); + if (SpareBuffer == NULL) { + FreePool (TempBuffer); + return EFI_OUT_OF_RESOURCES; + } + + Ptr = SpareBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Length = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Read ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &Length, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (TempBuffer); + FreePool (SpareBuffer); + return EFI_ABORTED; + } + + Ptr += Length; + } + // + // Write the memory buffer to spare block + // + Status = FtwEraseSpareBlock (FtwLiteDevice); + Ptr = TempBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Length = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Write ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &Length, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (TempBuffer); + FreePool (SpareBuffer); + return EFI_ABORTED; + } + + Ptr += Length; + } + // + // Free TempBuffer + // + FreePool (TempBuffer); + + // + // Write the spare block to working block + // + Status = FlushSpareBlockToWorkingBlock (FtwLiteDevice); + if (EFI_ERROR (Status)) { + FreePool (SpareBuffer); + return Status; + } + // + // Restore spare backup buffer into spare block , if no failure happened during FtwWrite. + // + Status = FtwEraseSpareBlock (FtwLiteDevice); + Ptr = SpareBuffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Length = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Write ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &Length, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (SpareBuffer); + return EFI_ABORTED; + } + + Ptr += Length; + } + + FreePool (SpareBuffer); + + DEBUG ((EFI_D_FTW_LITE, "FtwLite: reclaim work space success\n")); + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/Ia32/Ia32FtwMisc.c b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/Ia32/Ia32FtwMisc.c new file mode 100644 index 0000000000..6425f29b2c --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/Ia32/Ia32FtwMisc.c @@ -0,0 +1,403 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + +Module Name: + + Ia32FtwMisc.c + +Abstract: + + Ia32 platform related code to support FtwLite.. + +Revision History + +--*/ + + +#include + +// +// MACROs for boot block update +// +#define BOOT_BLOCK_BASE 0xFFFF0000 + +// +// (LPC -- D31:F0) +// +#define LPC_BUS_NUMBER 0x00 +#define LPC_DEVICE_NUMBER 0x1F +#define LPC_IF 0xF0 +// +// Top swap +// +#define GEN_STATUS 0xD4 +#define TOP_SWAP_BIT (1 << 13) + +STATIC +UINT32 +ReadPciRegister ( + IN UINT32 Offset + ) +/*++ + +Routine Description: + + Read PCI register value. + +Arguments: + + Offset - Offset of the register + +Returns: + + The value. + +--*/ +{ + EFI_STATUS Status; + UINT32 Value; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo; + + Value = 0; + Status = gBS->LocateProtocol (&gEfiPciRootBridgeIoProtocolGuid, NULL, (VOID **) &PciRootBridgeIo); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_ERROR, "FtwLite: Locate PCI root bridge io protocol - %r", Status)); + return 0; + } + + Status = PciRootBridgeIo->Pci.Read ( + PciRootBridgeIo, + EfiPciWidthUint32, + EFI_PCI_ADDRESS ( + LPC_BUS_NUMBER, + LPC_DEVICE_NUMBER, + LPC_IF, + Offset + ), + 1, + &Value + ); + ASSERT_EFI_ERROR (Status); + + return Value; +} + +STATIC +EFI_STATUS +GetSwapState ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + OUT BOOLEAN *SwapState + ) +/*++ + +Routine Description: + + Get swap state + +Arguments: + + FtwLiteDevice - Calling context + SwapState - Swap state + +Returns: + + EFI_SUCCESS - State successfully got + +--*/ +{ + // + // Top swap status is 13 bit + // + *SwapState = (BOOLEAN) ((ReadPciRegister (GEN_STATUS) & TOP_SWAP_BIT) != 0); + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +SetSwapState ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + IN BOOLEAN TopSwap + ) +/*++ + +Routine Description: + Set swap state. + +Arguments: + FtwLiteDevice - Indicates a pointer to the calling context. + TopSwap - New swap state + +Returns: + EFI_SUCCESS - The function completed successfully + +Note: + the Top-Swap bit (bit 13, D31: F0, Offset D4h). Note that + software will not be able to clear the Top-Swap bit until the system is + rebooted without GNT[A]# being pulled down. + +--*/ +{ + UINT32 GenStatus; + EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo; + EFI_STATUS Status; + + // + // Top-Swap bit (bit 13, D31: F0, Offset D4h) + // + GenStatus = ReadPciRegister (GEN_STATUS); + + // + // Set 13 bit, according to input NewSwapState + // + if (TopSwap) { + GenStatus |= TOP_SWAP_BIT; + } else { + GenStatus &= ~TOP_SWAP_BIT; + } + + Status = gBS->LocateProtocol (&gEfiPciRootBridgeIoProtocolGuid, NULL, (VOID **) &PciRootBridgeIo); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_ERROR, "FtwLite: Locate PCI root bridge io protocol - %r", Status)); + return Status; + } + // + // Write back the GenStatus register + // + Status = PciRootBridgeIo->Pci.Write ( + PciRootBridgeIo, + EfiPciWidthUint32, + EFI_PCI_ADDRESS ( + LPC_BUS_NUMBER, + LPC_DEVICE_NUMBER, + LPC_IF, + GEN_STATUS + ), + 1, + &GenStatus + ); + + DEBUG_CODE_BEGIN (); + if (TopSwap) { + DEBUG ((EFI_D_ERROR, "SAR: Set top swap\n")); + } else { + DEBUG ((EFI_D_ERROR, "SAR: Clear top swap\n")); + } + DEBUG_CODE_END (); + + return EFI_SUCCESS; +} + +BOOLEAN +IsBootBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + + Check whether the block is a boot block. + +Arguments: + + FtwLiteDevice - Calling context + FvBlock - Fvb protocol instance + Lba - Lba value + +Returns: + + Is a boot block or not + +--*/ +{ + EFI_STATUS Status; + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *BootFvb; + + Status = GetFvbByAddress (BOOT_BLOCK_BASE, &BootFvb); + if (EFI_ERROR (Status)) { + return FALSE; + } + // + // Compare the Fvb + // + return (BOOLEAN) (FvBlock == BootFvb); +} + +EFI_STATUS +FlushSpareBlockToBootBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Copy the content of spare block to a boot block. Size is FTW_BLOCK_SIZE. + Spare block is accessed by FTW backup FVB protocol interface. LBA is + FtwLiteDevice->FtwSpareLba. + Boot block is accessed by BootFvb protocol interface. LBA is 0. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + +Returns: + EFI_SUCCESS - Spare block content is copied to boot block + EFI_INVALID_PARAMETER - Input parameter error + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +Notes: + FTW will do extra work on boot block update. + FTW should depend on a protocol of EFI_ADDRESS_RANGE_SWAP_PROTOCOL, + which is produced by a chipset driver. + + FTW updating boot block steps: + 1. Erase top swap block (0xFFFE-0xFFFEFFFF) and write data to it ready + 2. Read data from top swap block to memory buffer + 3. SetSwapState(EFI_SWAPPED) + 4. Erasing boot block (0xFFFF-0xFFFFFFFF) + 5. Programming boot block until the boot block is ok. + 6. SetSwapState(UNSWAPPED) + + Notes: + 1. Since the SwapState bit is saved in CMOS, FTW can restore and continue + even in the scenario of power failure. + 2. FTW shall not allow to update boot block when battery state is error. + +--*/ +{ + EFI_STATUS Status; + UINTN Length; + UINT8 *Buffer; + UINTN Count; + UINT8 *Ptr; + UINTN Index; + BOOLEAN TopSwap; + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *BootFvb; + EFI_LBA BootLba; + + // + // Allocate a memory buffer + // + Length = FtwLiteDevice->SpareAreaLength; + Buffer = AllocatePool (Length); + if (Buffer == NULL) { + } + // + // Get TopSwap bit state + // + Status = GetSwapState (FtwLiteDevice, &TopSwap); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_ERROR, "FtwLite: Get Top Swapped status - %r\n", Status)); + FreePool (Buffer); + return EFI_ABORTED; + } + + if (TopSwap) { + // + // Get FVB of current boot block + // + Status = GetFvbByAddress (FtwLiteDevice->SpareAreaAddress + FTW_BLOCK_SIZE, &BootFvb); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return Status; + } + // + // Read data from current boot block + // + BootLba = 0; + Ptr = Buffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Count = FtwLiteDevice->SizeOfSpareBlock; + Status = BootFvb->Read ( + BootFvb, + BootLba + Index, + 0, + &Count, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return Status; + } + + Ptr += Count; + } + + } else { + // + // Read data from spare block + // + Ptr = Buffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Count = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Read ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &Count, + Ptr + ); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return Status; + } + + Ptr += Count; + } + // + // Set TopSwap bit + // + Status = SetSwapState (FtwLiteDevice, TRUE); + DEBUG ((EFI_D_ERROR, "FtwLite: Set Swap State - %r\n", Status)); + ASSERT_EFI_ERROR (Status); + } + // + // Erase boot block. After setting TopSwap bit, it's spare block now! + // + Status = FtwEraseSpareBlock (FtwLiteDevice); + if (EFI_ERROR (Status)) { + FreePool (Buffer); + return EFI_ABORTED; + } + // + // Write memory buffer to currenet spare block + // + Ptr = Buffer; + for (Index = 0; Index < FtwLiteDevice->NumberOfSpareBlock; Index += 1) { + Count = FtwLiteDevice->SizeOfSpareBlock; + Status = FtwLiteDevice->FtwBackupFvb->Write ( + FtwLiteDevice->FtwBackupFvb, + FtwLiteDevice->FtwSpareLba + Index, + 0, + &Count, + Ptr + ); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_FTW_LITE, "FtwLite: FVB Write boot block - %r\n", Status)); + FreePool (Buffer); + return Status; + } + + Ptr += Count; + } + + FreePool (Buffer); + + // + // Clear TopSwap bit + // + Status = SetSwapState (FtwLiteDevice, FALSE); + DEBUG ((EFI_D_ERROR, "FtwLite: Clear Swap State - %r\n", Status)); + ASSERT_EFI_ERROR (Status); + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/Ipf/IpfFtwMisc.c b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/Ipf/IpfFtwMisc.c new file mode 100644 index 0000000000..d31883b2ee --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/Ipf/IpfFtwMisc.c @@ -0,0 +1,143 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + IpfFtwMisc.c + +Abstract: + + Ipf platform related code to support FtwLite.. + +Revision History + +--*/ + + +#include + +// +// MACROs for boot block update +// +#define BOOT_BLOCK_BASE + +STATIC +EFI_STATUS +GetSwapState ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + OUT BOOLEAN *SwapState + ) +/*++ + +Routine Description: + + Get swap state + +Arguments: + + FtwLiteDevice - Calling context + SwapState - Swap state + +Returns: + + EFI_SUCCESS - State successfully got + +--*/ +{ + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +SetSwapState ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + IN BOOLEAN TopSwap + ) +/*++ + +Routine Description: + Set swap state. + +Arguments: + FtwLiteDevice - Indicates a pointer to the calling context. + TopSwap - New swap state + +Returns: + EFI_SUCCESS - The function completed successfully + +Note: + the Top-Swap bit (bit 13, D31: F0, Offset D4h). Note that + software will not be able to clear the Top-Swap bit until the system is + rebooted without GNT[A]# being pulled down. + +--*/ +{ + return EFI_SUCCESS; +} + +BOOLEAN +IsBootBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + + Check whether the block is a boot block. + +Arguments: + + FtwLiteDevice - Calling context + FvBlock - Fvb protocol instance + Lba - Lba value + +Returns: + + Is a boot block or not + +--*/ +{ + // + // IPF doesn't support safe bootblock update + // so treat bootblock as normal block + // + return FALSE; +} + +EFI_STATUS +FlushSpareBlockToBootBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Copy the content of spare block to a boot block. Size is FTW_BLOCK_SIZE. + Spare block is accessed by FTW backup FVB protocol interface. LBA is + FtwLiteDevice->FtwSpareLba. + Boot block is accessed by BootFvb protocol interface. LBA is 0. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + +Returns: + EFI_SUCCESS - Spare block content is copied to boot block + EFI_INVALID_PARAMETER - Input parameter error + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +Notes: + +--*/ +{ + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/x64/x64FtwMisc.c b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/x64/x64FtwMisc.c new file mode 100644 index 0000000000..d8e3a03fde --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/x64/x64FtwMisc.c @@ -0,0 +1,140 @@ + +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + x64FtwMisc.c + +Abstract: + + X64 platform related code to support FtwLite.. + +Revision History + +--*/ + + +#include + +// +// MACROs for boot block update +// +#define BOOT_BLOCK_BASE + +// STATIC +EFI_STATUS +GetSwapState ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + OUT BOOLEAN *SwapState + ) +/*++ + +Routine Description: + + Get swap state + +Arguments: + + FtwLiteDevice - Calling context + SwapState - Swap state + +Returns: + + EFI_SUCCESS - State successfully got + +--*/ +{ + return EFI_SUCCESS; +} + +// STATIC +EFI_STATUS +SetSwapState ( + IN EFI_FTW_LITE_DEVICE *FtwLiteDevice, + IN BOOLEAN TopSwap + ) +/*++ + +Routine Description: + Set swap state. + +Arguments: + FtwLiteDevice - Indicates a pointer to the calling context. + TopSwap - New swap state + +Returns: + EFI_SUCCESS - The function completed successfully + +Note: + the Top-Swap bit (bit 13, D31: F0, Offset D4h). Note that + software will not be able to clear the Top-Swap bit until the system is + rebooted without GNT[A]# being pulled down. + +--*/ +{ + return EFI_SUCCESS; +} + +BOOLEAN +IsBootBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice, + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvBlock, + EFI_LBA Lba + ) +/*++ + +Routine Description: + + Check whether the block is a boot block. + +Arguments: + + FtwLiteDevice - Calling context + FvBlock - Fvb protocol instance + Lba - Lba value + +Returns: + + Is a boot block or not + +--*/ +{ + return FALSE; +} + +EFI_STATUS +FlushSpareBlockToBootBlock ( + EFI_FTW_LITE_DEVICE *FtwLiteDevice + ) +/*++ + +Routine Description: + Copy the content of spare block to a boot block. Size is FTW_BLOCK_SIZE. + Spare block is accessed by FTW backup FVB protocol interface. LBA is + FtwLiteDevice->FtwSpareLba. + Boot block is accessed by BootFvb protocol interface. LBA is 0. + +Arguments: + FtwLiteDevice - The private data of FTW_LITE driver + +Returns: + EFI_SUCCESS - Spare block content is copied to boot block + EFI_INVALID_PARAMETER - Input parameter error + EFI_OUT_OF_RESOURCES - Allocate memory error + EFI_ABORTED - The function could not complete successfully + +Notes: + +--*/ +{ + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.c b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.c new file mode 100644 index 0000000000..de9ba8372f --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.c @@ -0,0 +1,230 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + +Module Name: + + Crc32SectionExtract.c + +Abstract: + + Implements GUIDed section extraction protocol interface with + a specific GUID: CRC32. + + Please refer to the Framewokr Firmware Volume Specification 0.9. + +--*/ + + +#include +#include + +EFI_STATUS +EFIAPI +InitializeCrc32GuidedSectionExtractionProtocol ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + + Entry point of the CRC32 GUIDed section extraction protocol. + Creates and initializes an instance of the GUIDed section + extraction protocol with CRC32 GUID. + +Arguments: + + ImageHandle EFI_HANDLE: A handle for the image that is initializing + this driver + SystemTable EFI_SYSTEM_TABLE: A pointer to the EFI system table + +Returns: + + EFI_SUCCESS: Driver initialized successfully + EFI_LOAD_ERROR: Failed to Initialize or has been loaded + EFI_OUT_OF_RESOURCES: Could not allocate needed resources + +--*/ +{ + EFI_STATUS Status; + EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL *Crc32GuidedSep; + EFI_HANDLE Handle; + + // + // Call all constructors per produced protocols + // + Status = GuidedSectionExtractionProtocolConstructor ( + &Crc32GuidedSep, + (EFI_EXTRACT_GUIDED_SECTION) Crc32ExtractSection + ); + if (EFI_ERROR (Status)) { + if (Crc32GuidedSep != NULL) { + FreePool (Crc32GuidedSep); + } + + return Status; + } + // + // Pass in a NULL to install to a new handle + // + Handle = NULL; + Status = gBS->InstallProtocolInterface ( + &Handle, + &gEfiCrc32GuidedSectionExtractionProtocolGuid, + EFI_NATIVE_INTERFACE, + Crc32GuidedSep + ); + if (EFI_ERROR (Status)) { + FreePool (Crc32GuidedSep); + return EFI_LOAD_ERROR; + } + + return EFI_SUCCESS; +} + +STATIC +UINT32 +EFIAPI +GetSectionLength ( + IN EFI_COMMON_SECTION_HEADER *CommonHeader + ) +/*++ + + Routine Description: + Get a length of section. + + Parameters: + CommonHeader - Pointer to the common section header. + + Return Value: + The length of the section, including the section header. + +--*/ +// TODO: function comment is missing 'Arguments:' +// TODO: function comment is missing 'Returns:' +// TODO: CommonHeader - add argument and description to function comment +{ + UINT32 Size; + + Size = *(UINT32 *) CommonHeader->Size & 0x00FFFFFF; + + return Size; +} + +STATIC +EFI_STATUS +EFIAPI +Crc32ExtractSection ( + IN EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL *This, + IN VOID *InputSection, + OUT VOID **OutputBuffer, + OUT UINTN *OutputSize, + OUT UINT32 *AuthenticationStatus + ) +/*++ + + Routine Description: + This function reads and extracts contents of a section from an + encapsulating section. + + Parameters: + This - Indicates the calling context. + InputSection - Buffer containing the input GUIDed section + to be processed. + OutputBuffer - *OutputBuffer is allocated from boot services + pool memory and containing the new section + stream. The caller is responsible for freeing + this buffer. + AuthenticationStatus - Pointer to a caller allocated UINT32 that + indicates the authentication status of the + output buffer + + Return Value: + EFI_SUCCESS + EFI_OUT_OF_RESOURCES + EFI_INVALID_PARAMETER + EFI_NOT_AVAILABLE_YET + +--*/ +// TODO: function comment is missing 'Arguments:' +// TODO: function comment is missing 'Returns:' +// TODO: This - add argument and description to function comment +// TODO: InputSection - add argument and description to function comment +// TODO: OutputBuffer - add argument and description to function comment +// TODO: OutputSize - add argument and description to function comment +// TODO: AuthenticationStatus - add argument and description to function comment +// TODO: EFI_INVALID_PARAMETER - add return value to function comment +// TODO: EFI_INVALID_PARAMETER - add return value to function comment +// TODO: EFI_OUT_OF_RESOURCES - add return value to function comment +// TODO: EFI_SUCCESS - add return value to function comment +{ + EFI_STATUS Status; + CRC32_SECTION_HEADER *Crc32SectionHeader; + EFI_GUID_DEFINED_SECTION *GuidedSectionHeader; + UINT8 *Image; + UINT32 Crc32Checksum; + VOID *DummyInterface; + + if (OutputBuffer == NULL) { + return EFI_INVALID_PARAMETER; + } + + *OutputBuffer = NULL; + + // + // Points to the section header + // + Crc32SectionHeader = (CRC32_SECTION_HEADER *) InputSection; + GuidedSectionHeader = (EFI_GUID_DEFINED_SECTION *) InputSection; + + // + // Check if the GUID is a CRC32 section GUID + // + if (!CompareGuid ( + &(GuidedSectionHeader->SectionDefinitionGuid), + &gEfiCrc32GuidedSectionExtractionProtocolGuid + )) { + return EFI_INVALID_PARAMETER; + } + + Image = (UINT8 *) InputSection + (UINT32) (GuidedSectionHeader->DataOffset); + *OutputSize = GetSectionLength ((EFI_COMMON_SECTION_HEADER *) InputSection) - (UINT32) GuidedSectionHeader->DataOffset; + + *OutputBuffer = AllocatePool (*OutputSize); + if (*OutputBuffer == NULL) { + return EFI_OUT_OF_RESOURCES; + } + // + // Implictly CRC32 GUIDed section should have STATUS_VALID bit set + // + ASSERT (GuidedSectionHeader->Attributes & EFI_GUIDED_SECTION_AUTH_STATUS_VALID); + *AuthenticationStatus = EFI_LOCAL_AUTH_STATUS_IMAGE_SIGNED | EFI_AGGREGATE_AUTH_STATUS_IMAGE_SIGNED; + + // + // Check whether there exists EFI_SECURITY_POLICY_PROTOCOL_GUID. + // + Status = gBS->LocateProtocol (&gEfiSecurityPolicyProtocolGuid, NULL, &DummyInterface); + if (!EFI_ERROR (Status)) { + *AuthenticationStatus |= EFI_LOCAL_AUTH_STATUS_PLATFORM_OVERRIDE | EFI_AGGREGATE_AUTH_STATUS_PLATFORM_OVERRIDE; + } else { + // + // Calculate CRC32 Checksum of Image + // + gBS->CalculateCrc32 (Image, *OutputSize, &Crc32Checksum); + if (Crc32Checksum != Crc32SectionHeader->CRC32Checksum) { + *AuthenticationStatus |= EFI_LOCAL_AUTH_STATUS_TEST_FAILED | EFI_AGGREGATE_AUTH_STATUS_TEST_FAILED; + } + } + + CopyMem (*OutputBuffer, Image, *OutputSize); + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.dxs b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.dxs new file mode 100644 index 0000000000..d42975a2a9 --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.dxs @@ -0,0 +1,26 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + Crc32SectionExtraction.dxs + +Abstract: + + Dependency expression file. + +--*/ +#include "DxeDepex.h" + +DEPENDENCY_START + EFI_RUNTIME_ARCH_PROTOCOL_GUID +DEPENDENCY_END + diff --git a/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.h b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.h new file mode 100644 index 0000000000..37af840fc6 --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.h @@ -0,0 +1,112 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + +Module Name: + + Crc32SectionExtract.h + +Abstract: + + Header file for Crc32SectionExtract.c + Please refer to the Framewokr Firmware Volume Specification 0.9. + +--*/ + +#ifndef _CRC32_GUIDED_SECTION_EXTRACTION_H +#define _CRC32_GUIDED_SECTION_EXTRACTION_H + +// +// The package level header files this module uses +// +#include +// +// The protocols, PPI and GUID defintions for this module +// +#include +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include + +typedef struct { + EFI_GUID_DEFINED_SECTION GuidedSectionHeader; + UINT32 CRC32Checksum; +} CRC32_SECTION_HEADER; + +// +// Function prototype declarations +// +STATIC +EFI_STATUS +EFIAPI +Crc32ExtractSection ( + IN EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL *This, + IN VOID *InputSection, + OUT VOID **OutputBuffer, + OUT UINTN *OutputSize, + OUT UINT32 *AuthenticationStatus + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + This - TODO: add argument description + InputSection - TODO: add argument description + OutputBuffer - TODO: add argument description + OutputSize - TODO: add argument description + AuthenticationStatus - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +InitializeCrc32GuidedSectionExtractionProtocol ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + + Entry point of the CRC32 GUIDed section extraction protocol. + Creates and initializes an instance of the GUIDed section + extraction protocol with CRC32 GUID. + +Arguments: + + ImageHandle EFI_HANDLE: A handle for the image that is initializing + this driver + SystemTable EFI_SYSTEM_TABLE: A pointer to the EFI system table + +Returns: + + EFI_SUCCESS: Driver initialized successfully + EFI_LOAD_ERROR: Failed to Initialize or has been loaded + EFI_OUT_OF_RESOURCES: Could not allocate needed resources + +--*/ +; + +#endif diff --git a/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.inf b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.inf new file mode 100644 index 0000000000..69becb8103 --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.inf @@ -0,0 +1,88 @@ +#/** @file +# Component description file for Crc32SectionExtract module. +# +# This driver implements CRC32 GUIDed section extraction protocol interface. +# Copyright (c) 2006 - 2007, Intel Corporation +# +# All rights reserved. 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = Crc32SectionExtract + FILE_GUID = 51C9F40C-5243-4473-B265-B3C8FFAFF9FA + MODULE_TYPE = DXE_DRIVER + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = InitializeCrc32GuidedSectionExtractionProtocol + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF EBC +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + Crc32SectionExtract.dxs + GuidedSection.h + GuidedSection.c + Crc32SectionExtract.h + Crc32SectionExtract.c + + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + MdePkg/MdePkg.dec + IntelFrameworkPkg/IntelFrameworkPkg.dec + +################################################################################ +# +# Library Class Section - list of Library Classes that are required for +# this module. +# +################################################################################ + +[LibraryClasses] + MemoryAllocationLib + UefiBootServicesTableLib + BaseMemoryLib + UefiDriverEntryPoint + DebugLib + + +################################################################################ +# +# Protocol C Name Section - list of Protocol and Protocol Notify C Names +# that this module uses or produces. +# +################################################################################ + +[Protocols] + gEfiSecurityPolicyProtocolGuid # PROTOCOL SOMETIMES_CONSUMED + gEfiCrc32GuidedSectionExtractionProtocolGuid # PROTOCOL ALWAYS_PRODUCED diff --git a/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.msa b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.msa new file mode 100644 index 0000000000..a4ab18235b --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.msa @@ -0,0 +1,66 @@ + + + + Crc32SectionExtract + DXE_DRIVER + 51C9F40C-5243-4473-B265-B3C8FFAFF9FA + 1.0 + Component description file for Crc32SectionExtract module. + This driver implements CRC32 GUIDed section extraction protocol interface. + Copyright (c) 2006 - 2007, Intel Corporation + All rights reserved. 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 X64 IPF EBC + false + Crc32SectionExtract + + + + DebugLib + + + UefiDriverEntryPoint + + + BaseMemoryLib + + + UefiBootServicesTableLib + + + MemoryAllocationLib + + + + Crc32SectionExtract.c + Crc32SectionExtract.h + GuidedSection.c + GuidedSection.h + Crc32SectionExtract.dxs + + + + + + + gEfiSecurityPolicyProtocolGuid + + + gEfiCrc32GuidedSectionExtractionProtocolGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + InitializeCrc32GuidedSectionExtractionProtocol + + + diff --git a/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/GuidedSection.c b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/GuidedSection.c new file mode 100644 index 0000000000..87605cc055 --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/GuidedSection.c @@ -0,0 +1,61 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + +Module Name: + + GuidedSection.c + +Abstract: + + GUIDed section extraction protocol implementation. + This contains the common constructor of GUIDed section + extraction protocol. GUID specific implementation of each + GUIDed section extraction protocol can be found in other + files under the same directory. + +--*/ + +#include "GuidedSection.h" + +EFI_STATUS +GuidedSectionExtractionProtocolConstructor ( + OUT EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL **GuidedSep, + IN EFI_EXTRACT_GUIDED_SECTION ExtractSection + ) +/*++ + +Routine Description: + + Constructor for the GUIDed section extraction protocol. Initializes + instance data. + +Arguments: + + This Instance to construct + +Returns: + + EFI_SUCCESS: Instance initialized. + +--*/ +// TODO: GuidedSep - add argument and description to function comment +// TODO: ExtractSection - add argument and description to function comment +// TODO: EFI_OUT_OF_RESOURCES - add return value to function comment +{ + *GuidedSep = AllocatePool (sizeof (EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL)); + if (*GuidedSep == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + (*GuidedSep)->ExtractSection = ExtractSection; + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/GuidedSection.h b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/GuidedSection.h new file mode 100644 index 0000000000..d6613b0f4b --- /dev/null +++ b/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/GuidedSection.h @@ -0,0 +1,54 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + +Module Name: + + GuidedSection.h + +Abstract: + + Header file for GuidedSection.c + Please refer to the Framewokr Firmware Volume Specification 0.9. + +--*/ + +#ifndef _GUIDED_SECTION_EXTRACTION_H +#define _GUIDED_SECTION_EXTRACTION_H + +#include "Crc32SectionExtract.h" + +// +// Function prototype declarations +// +EFI_STATUS +GuidedSectionExtractionProtocolConstructor ( + OUT EFI_GUIDED_SECTION_EXTRACTION_PROTOCOL **GuidedSep, + IN EFI_EXTRACT_GUIDED_SECTION ExtractSection + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + GuidedSep - TODO: add argument description + ExtractSection - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +#endif diff --git a/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.c b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.c new file mode 100644 index 0000000000..7a20a41312 --- /dev/null +++ b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.c @@ -0,0 +1,214 @@ +/*++ + +Copyright (c) 2006 - 2007, Intel Corporation +All rights reserved. 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. + +Module Name: + + NullMemoryTest.c + +Abstract: + +--*/ + + +#include "NullMemoryTest.h" + +// +// Module global members +// +UINT64 mTestedSystemMemory = 0; +UINT64 mTotalSystemMemory = 0; +EFI_HANDLE mGenericMemoryTestHandle; + +// +// Driver entry here +// +EFI_GENERIC_MEMORY_TEST_PROTOCOL mGenericMemoryTest = { + InitializeMemoryTest, + GenPerformMemoryTest, + GenMemoryTestFinished, + GenCompatibleRangeTest +}; + +EFI_STATUS +EFIAPI +GenericMemoryTestEntryPoint ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + +Routine Description: + + The generic memory test driver's entry point, it can initialize private data + to default value + +Arguments: + + ImageHandle of the loaded driver + Pointer to the System Table + +Returns: + + Status + + EFI_SUCCESS - Protocol successfully installed + EFI_OUT_OF_RESOURCES - Can not allocate protocol data structure in base + memory + +--*/ +{ + EFI_STATUS Status; + + // + // Install the protocol + // + Status = gBS->InstallProtocolInterface ( + &mGenericMemoryTestHandle, + &gEfiGenericMemTestProtocolGuid, + EFI_NATIVE_INTERFACE, + &mGenericMemoryTest + ); + + return Status; +} +// +// EFI_GENERIC_MEMORY_TEST_PROTOCOL implementation +// +EFI_STATUS +EFIAPI +InitializeMemoryTest ( + IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This, + IN EXTENDMEM_COVERAGE_LEVEL Level, + OUT BOOLEAN *RequireSoftECCInit + ) +/*++ + +Routine Description: + +Arguments: + +Returns: + +--*/ +{ + UINTN NumberOfDescriptors; + EFI_GCD_MEMORY_SPACE_DESCRIPTOR *MemorySpaceMap; + UINTN Index; + + gDS->GetMemorySpaceMap (&NumberOfDescriptors, &MemorySpaceMap); + for (Index = 0; Index < NumberOfDescriptors; Index++) { + if (MemorySpaceMap[Index].GcdMemoryType == EfiGcdMemoryTypeReserved && + (MemorySpaceMap[Index].Capabilities & (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED)) == + (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED) + ) { + gDS->RemoveMemorySpace ( + MemorySpaceMap[Index].BaseAddress, + MemorySpaceMap[Index].Length + ); + + gDS->AddMemorySpace ( + EfiGcdMemoryTypeSystemMemory, + MemorySpaceMap[Index].BaseAddress, + MemorySpaceMap[Index].Length, + MemorySpaceMap[Index].Capabilities &~ + (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED | EFI_MEMORY_RUNTIME) + ); + + mTestedSystemMemory += MemorySpaceMap[Index].Length; + mTotalSystemMemory += MemorySpaceMap[Index].Length; + } else if (MemorySpaceMap[Index].GcdMemoryType == EfiGcdMemoryTypeSystemMemory) { + mTotalSystemMemory += MemorySpaceMap[Index].Length; + } + } + + FreePool (MemorySpaceMap); + + *RequireSoftECCInit = FALSE; + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +GenPerformMemoryTest ( + IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This, + IN OUT UINT64 *TestedMemorySize, + OUT UINT64 *TotalMemorySize, + OUT BOOLEAN *ErrorOut, + IN BOOLEAN TestAbort + ) +/*++ + +Routine Description: + +Arguments: + +Returns: + +--*/ +{ + *ErrorOut = FALSE; + *TestedMemorySize = mTestedSystemMemory; + *TotalMemorySize = mTotalSystemMemory; + + return EFI_NOT_FOUND; + +} + +EFI_STATUS +EFIAPI +GenMemoryTestFinished ( + IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This + ) +/*++ + +Routine Description: + +Arguments: + +Returns: + +--*/ +{ + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +GenCompatibleRangeTest ( + IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This, + IN EFI_PHYSICAL_ADDRESS StartAddress, + IN UINT64 Length + ) +/*++ + +Routine Description: + +Arguments: + +Returns: + +--*/ +{ + EFI_GCD_MEMORY_SPACE_DESCRIPTOR descriptor; + + gDS->GetMemorySpaceDescriptor (StartAddress, &descriptor); + + gDS->RemoveMemorySpace (StartAddress, Length); + + gDS->AddMemorySpace ( + EfiGcdMemoryTypeSystemMemory, + StartAddress, + Length, + descriptor.Capabilities &~(EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED | EFI_MEMORY_RUNTIME) + ); + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.dxs b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.dxs new file mode 100644 index 0000000000..a1ac031349 --- /dev/null +++ b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.dxs @@ -0,0 +1,25 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + NullMemoryTest.dxs + +Abstract: + + Dependency expression source file. + +--*/ +#include + +DEPENDENCY_START + TRUE +DEPENDENCY_END diff --git a/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.h b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.h new file mode 100644 index 0000000000..4b04381812 --- /dev/null +++ b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.h @@ -0,0 +1,124 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. 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. + +Module Name: + + NullMemoryTest.h + +Abstract: + The generic memory test driver definition + +--*/ + +#ifndef _NULL_MEMORY_TEST_H +#define _NULL_MEMORY_TEST_H + +// +// The package level header files this module uses +// +#include + +// +// The protocols, PPI and GUID defintions for this module +// +#include +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include + +// +// attributes for reserved memory before it is promoted to system memory +// +#define EFI_MEMORY_PRESENT 0x0100000000000000ULL +#define EFI_MEMORY_INITIALIZED 0x0200000000000000ULL +#define EFI_MEMORY_TESTED 0x0400000000000000ULL + + +// +// Some global define +// +#define GENERIC_CACHELINE_SIZE 0x40 + +// +// The SPARSE_SPAN_SIZE size can not small then the MonoTestSize +// +#define TEST_BLOCK_SIZE 0x2000000 +#define QUICK_SPAN_SIZE (TEST_BLOCK_SIZE >> 2) +#define SPARSE_SPAN_SIZE (TEST_BLOCK_SIZE >> 4) + +// +// This structure records every nontested memory range parsed through GCD +// service. +// +#define EFI_NONTESTED_MEMORY_RANGE_SIGNATURE EFI_SIGNATURE_32 ('N', 'T', 'M', 'E') +typedef struct { + UINTN Signature; + LIST_ENTRY Link; + EFI_PHYSICAL_ADDRESS StartAddress; + UINT64 Length; + UINT64 Capabilities; + BOOLEAN Above4G; + BOOLEAN AlreadyMapped; +} NONTESTED_MEMORY_RANGE; + +#define NONTESTED_MEMORY_RANGE_FROM_LINK(link) \ + CR(link, NONTESTED_MEMORY_RANGE, Link, EFI_NONTESTED_MEMORY_RANGE_SIGNATURE) + +// +// This is the memory test driver's structure definition +// +#define EFI_GENERIC_MEMORY_TEST_PRIVATE_SIGNATURE EFI_SIGNATURE_32 ('G', 'E', 'M', 'T') + +// +// Function Prototypes +// +EFI_STATUS +EFIAPI +InitializeMemoryTest ( + IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This, + IN EXTENDMEM_COVERAGE_LEVEL Level, + OUT BOOLEAN *RequireSoftECCInit + ) +; + +EFI_STATUS +EFIAPI +GenPerformMemoryTest ( + IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This, + IN OUT UINT64 *TestedMemorySize, + OUT UINT64 *TotalMemorySize, + OUT BOOLEAN *ErrorOut, + IN BOOLEAN TestAbort + ) +; + +EFI_STATUS +EFIAPI +GenMemoryTestFinished ( + IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This + ) +; + +EFI_STATUS +EFIAPI +GenCompatibleRangeTest ( + IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This, + IN EFI_PHYSICAL_ADDRESS StartAddress, + IN UINT64 Length + ) +; + +#endif diff --git a/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.inf b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.inf new file mode 100644 index 0000000000..f10ed274f2 --- /dev/null +++ b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.inf @@ -0,0 +1,88 @@ +#/** @file +# Component description file for NullMemoryTest module. +# +# This driver installs EFI_GENERIC_MEMORY_TEST_PROTOCOL to +# provide simple generic memory test functions. +# Copyright (c) 2006 - 2007, Intel Corporation +# +# All rights reserved. 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. +# +# +#**/ + +################################################################################ +# +# Defines Section - statements that will be processed to create a Makefile. +# +################################################################################ +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = NullMemoryTest + FILE_GUID = 96B5C032-DF4C-4b6e-8232-438DCF448D0E + MODULE_TYPE = DXE_DRIVER + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + + ENTRY_POINT = GenericMemoryTestEntryPoint + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF EBC +# + +################################################################################ +# +# Sources Section - list of files that are required for the build to succeed. +# +################################################################################ + +[Sources.common] + NullMemoryTest.dxs + NullMemoryTest.h + NullMemoryTest.c + + +################################################################################ +# +# Package Dependency Section - list of Package files that are required for +# this module. +# +################################################################################ + +[Packages] + MdeModulePkg/MdeModulePkg.dec + MdePkg/MdePkg.dec + + +################################################################################ +# +# Library Class Section - list of Library Classes that are required for +# this module. +# +################################################################################ + +[LibraryClasses] + MemoryAllocationLib + UefiBootServicesTableLib + DxeServicesTableLib + UefiDriverEntryPoint + DebugLib + + +################################################################################ +# +# Protocol C Name Section - list of Protocol and Protocol Notify C Names +# that this module uses or produces. +# +################################################################################ + +[Protocols] + gEfiGenericMemTestProtocolGuid # PROTOCOL ALWAYS_PRODUCED + diff --git a/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.msa b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.msa new file mode 100644 index 0000000000..ade8ce1050 --- /dev/null +++ b/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.msa @@ -0,0 +1,64 @@ + + + + NullMemoryTest + DXE_DRIVER + 96B5C032-DF4C-4b6e-8232-438DCF448D0E + 1.0 + Component description file for NullMemoryTest module. + This driver installs EFI_GENERIC_MEMORY_TEST_PROTOCOL to + provide simple generic memory test functions. + Copyright (c) 2006 - 2007, Intel Corporation + All rights reserved. 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. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 X64 IPF EBC + false + NullMemoryTest + + + + DebugLib + + + UefiDriverEntryPoint + + + DxeServicesTableLib + + + UefiBootServicesTableLib + + + MemoryAllocationLib + + + + Common.h + NullMemoryTest.c + NullMemoryTest.h + NullMemoryTest.dxs + + + + + + + + gEfiGenericMemTestProtocolGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + GenericMemoryTestEntryPoint + + +