Check in following modules,
DxeIpl ConPlatform ConSplitter GraphicsConsole Terminal DevicePath git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3069 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
56
MdeModulePkg/Core/DxeIplPeim/CommonHeader.h
Normal file
56
MdeModulePkg/Core/DxeIplPeim/CommonHeader.h
Normal file
@@ -0,0 +1,56 @@
|
||||
/**@file
|
||||
Common header file shared by all source files.
|
||||
|
||||
This file includes package header files, library classes and protocol, PPI & GUID definitions.
|
||||
|
||||
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.
|
||||
**/
|
||||
|
||||
#ifndef __COMMON_HEADER_H_
|
||||
#define __COMMON_HEADER_H_
|
||||
|
||||
|
||||
//
|
||||
// The package level header files this module uses
|
||||
//
|
||||
#include <PiPei.h>
|
||||
//
|
||||
// The protocols, PPI and GUID defintions for this module
|
||||
//
|
||||
#include <Ppi/DxeIpl.h>
|
||||
#include <Ppi/S3Resume.h>
|
||||
#include <Protocol/EdkDecompress.h>
|
||||
#include <Ppi/EndOfPeiPhase.h>
|
||||
#include <Protocol/CustomizedDecompress.h>
|
||||
#include <Protocol/Decompress.h>
|
||||
#include <Ppi/Security.h>
|
||||
#include <Ppi/SectionExtraction.h>
|
||||
#include <Ppi/LoadFile.h>
|
||||
#include <Ppi/RecoveryModule.h>
|
||||
#include <Ppi/MemoryDiscovered.h>
|
||||
//
|
||||
// The Library classes this module consumes
|
||||
//
|
||||
#include <Library/DebugLib.h>
|
||||
#include <Library/PeimEntryPoint.h>
|
||||
#include <Library/BaseLib.h>
|
||||
#include <Library/HobLib.h>
|
||||
#include <Library/PeiServicesLib.h>
|
||||
#include <Library/ReportStatusCodeLib.h>
|
||||
#include <Library/CacheMaintenanceLib.h>
|
||||
#include <Library/PeCoffLoaderLib.h>
|
||||
#include <Library/UefiDecompressLib.h>
|
||||
#include <Library/CustomDecompressLib.h>
|
||||
#include <Library/PeiServicesTablePointerLib.h>
|
||||
#include <Library/BaseMemoryLib.h>
|
||||
#include <Library/MemoryAllocationLib.h>
|
||||
#include <Library/PcdLib.h>
|
||||
#include <Library/PeCoffLib.h>
|
||||
|
||||
#endif
|
28
MdeModulePkg/Core/DxeIplPeim/DxeIpl.dxs
Normal file
28
MdeModulePkg/Core/DxeIplPeim/DxeIpl.dxs
Normal file
@@ -0,0 +1,28 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
|
||||
DxeIpl.dxs
|
||||
|
||||
Abstract:
|
||||
|
||||
Dependency expression file for DXE Initial Program Loader PEIM.
|
||||
|
||||
--*/
|
||||
|
||||
#include <PeimDepex.h>
|
||||
|
||||
DEPENDENCY_START
|
||||
EFI_PEI_PERMANENT_MEMORY_INSTALLED_PPI_GUID
|
||||
DEPENDENCY_END
|
||||
|
||||
|
117
MdeModulePkg/Core/DxeIplPeim/DxeIpl.h
Normal file
117
MdeModulePkg/Core/DxeIplPeim/DxeIpl.h
Normal file
@@ -0,0 +1,117 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
|
||||
DxeIpl.h
|
||||
|
||||
Abstract:
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef __PEI_DXEIPL_H__
|
||||
#define __PEI_DXEIPL_H__
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#define STACK_SIZE 0x20000
|
||||
#define BSP_STORE_SIZE 0x4000
|
||||
|
||||
#define GET_OCCUPIED_SIZE(ActualSize, Alignment) ((ActualSize + (Alignment - 1)) & ~(Alignment - 1))
|
||||
|
||||
extern BOOLEAN gInMemory;
|
||||
|
||||
EFI_STATUS
|
||||
PeiFindFile (
|
||||
IN UINT8 Type,
|
||||
IN UINT16 SectionType,
|
||||
OUT EFI_GUID *FileName,
|
||||
OUT VOID **Pe32Data
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiLoadFile (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *PeiEfiPeiPeCoffLoader,
|
||||
IN VOID *Pe32Data,
|
||||
OUT EFI_PHYSICAL_ADDRESS *ImageAddress,
|
||||
OUT UINT64 *ImageSize,
|
||||
OUT EFI_PHYSICAL_ADDRESS *EntryPoint
|
||||
)
|
||||
;
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
GetImageReadFunction (
|
||||
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiImageRead (
|
||||
IN VOID *FileHandle,
|
||||
IN UINTN FileOffset,
|
||||
IN OUT UINTN *ReadSize,
|
||||
OUT VOID *Buffer
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DxeIplLoadFile (
|
||||
IN EFI_PEI_FV_FILE_LOADER_PPI *This,
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader,
|
||||
OUT EFI_PHYSICAL_ADDRESS *ImageAddress,
|
||||
OUT UINT64 *ImageSize,
|
||||
OUT EFI_PHYSICAL_ADDRESS *EntryPoint
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
ShadowDxeIpl (
|
||||
IN EFI_FFS_FILE_HEADER *DxeIpl,
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *PeiEfiPeiPeCoffLoader
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DxeLoadCore (
|
||||
IN EFI_DXE_IPL_PPI *This,
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PEI_HOB_POINTERS HobList
|
||||
);
|
||||
|
||||
VOID
|
||||
HandOffToDxeCore (
|
||||
IN EFI_PHYSICAL_ADDRESS DxeCoreEntryPoint,
|
||||
IN EFI_PEI_HOB_POINTERS HobList,
|
||||
IN EFI_PEI_PPI_DESCRIPTOR *EndOfPeiSignal
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
PeiProcessFile (
|
||||
IN UINT16 SectionType,
|
||||
IN EFI_FFS_FILE_HEADER *FfsFileHeader,
|
||||
OUT VOID **Pe32Data,
|
||||
IN EFI_PEI_HOB_POINTERS *OrigHob
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeimInitializeDxeIpl (
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader,
|
||||
IN EFI_PEI_SERVICES **PeiServices
|
||||
);
|
||||
|
||||
|
||||
#endif
|
171
MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf
Normal file
171
MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf
Normal file
@@ -0,0 +1,171 @@
|
||||
#/** @file
|
||||
# Component description file for DxeIpl module
|
||||
#
|
||||
# The responsibility of this module is to load the DXE Core from a Firmware Volume. This implementation i used to load a 32-bit DXE Core.
|
||||
# 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 = DxeIpl
|
||||
FILE_GUID = 86D70125-BAA3-4296-A62F-602BEBBB9081
|
||||
MODULE_TYPE = PEIM
|
||||
VERSION_STRING = 1.0
|
||||
EDK_RELEASE_VERSION = 0x00020000
|
||||
EFI_SPECIFICATION_VERSION = 0x00020000
|
||||
|
||||
ENTRY_POINT = PeimInitializeDxeIpl
|
||||
|
||||
#
|
||||
# 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]
|
||||
DxeIpl.h
|
||||
DxeLoad.c
|
||||
CommonHeader.h
|
||||
|
||||
[Sources.Ia32]
|
||||
Ia32/VirtualMemory.h
|
||||
Ia32/VirtualMemory.c
|
||||
Ia32/DxeLoadFunc.c
|
||||
Ia32/ImageRead.c
|
||||
|
||||
[Sources.X64]
|
||||
X64/DxeLoadFunc.c
|
||||
Ia32/ImageRead.c
|
||||
|
||||
[Sources.IPF]
|
||||
Ipf/DxeLoadFunc.c
|
||||
Ipf/ImageRead.c
|
||||
|
||||
[Sources.EBC]
|
||||
X64/DxeLoadFunc.c
|
||||
Ia32/ImageRead.c
|
||||
|
||||
|
||||
################################################################################
|
||||
#
|
||||
# Package Dependency Section - list of Package files that are required for
|
||||
# this module.
|
||||
#
|
||||
################################################################################
|
||||
|
||||
[Packages]
|
||||
MdePkg/MdePkg.dec
|
||||
IntelFrameworkPkg/IntelFrameworkPkg.dec
|
||||
IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec
|
||||
|
||||
|
||||
################################################################################
|
||||
#
|
||||
# Library Class Section - list of Library Classes that are required for
|
||||
# this module.
|
||||
#
|
||||
################################################################################
|
||||
|
||||
[LibraryClasses]
|
||||
PeCoffLib
|
||||
PcdLib
|
||||
MemoryAllocationLib
|
||||
BaseMemoryLib
|
||||
PeiServicesTablePointerLib
|
||||
CustomDecompressLib
|
||||
TianoDecompressLib
|
||||
UefiDecompressLib
|
||||
EdkPeCoffLoaderLib
|
||||
CacheMaintenanceLib
|
||||
ReportStatusCodeLib
|
||||
PeiServicesLib
|
||||
HobLib
|
||||
BaseLib
|
||||
PeimEntryPoint
|
||||
DebugLib
|
||||
|
||||
|
||||
################################################################################
|
||||
#
|
||||
# Guid C Name Section - list of Guids that this module uses or produces.
|
||||
#
|
||||
################################################################################
|
||||
|
||||
|
||||
################################################################################
|
||||
#
|
||||
# Protocol C Name Section - list of Protocol and Protocol Notify C Names
|
||||
# that this module uses or produces.
|
||||
#
|
||||
################################################################################
|
||||
|
||||
[Protocols]
|
||||
gEfiCustomizedDecompressProtocolGuid # PROTOCOL SOMETIMES_PRODUCED
|
||||
gEfiTianoDecompressProtocolGuid # PROTOCOL SOMETIMES_PRODUCED
|
||||
gEfiDecompressProtocolGuid # PROTOCOL SOMETIMES_PRODUCED
|
||||
|
||||
|
||||
################################################################################
|
||||
#
|
||||
# PPI C Name Section - list of PPI and PPI Notify C Names that this module
|
||||
# uses or produces.
|
||||
#
|
||||
################################################################################
|
||||
|
||||
[Ppis]
|
||||
gEfiPeiSecurityPpiGuid # PPI SOMETIMES_CONSUMED
|
||||
gEfiPeiSectionExtractionPpiGuid # PPI SOMETIMES_CONSUMED
|
||||
gEfiPeiS3ResumePpiGuid # PPI SOMETIMES_CONSUMED
|
||||
gEfiPeiRecoveryModulePpiGuid # PPI SOMETIMES_CONSUMED
|
||||
gEfiEndOfPeiSignalPpiGuid # PPI SOMETIMES_PRODUCED
|
||||
gEfiPeiFvFileLoaderPpiGuid # PPI SOMETIMES_PRODUCED
|
||||
gEfiDxeIplPpiGuid # PPI SOMETIMES_PRODUCED
|
||||
gEfiPeiPeCoffLoaderGuid
|
||||
|
||||
|
||||
################################################################################
|
||||
#
|
||||
# Pcd FEATURE_FLAG - list of PCDs that this module is coded for.
|
||||
#
|
||||
################################################################################
|
||||
|
||||
[PcdsFeatureFlag.common]
|
||||
PcdDxeIplSupportCustomDecompress|gEfiEdkModulePkgTokenSpaceGuid
|
||||
PcdDxeIplSupportTianoDecompress|gEfiEdkModulePkgTokenSpaceGuid
|
||||
PcdDxeIplSupportEfiDecompress|gEfiEdkModulePkgTokenSpaceGuid
|
||||
PcdDxeIplBuildShareCodeHobs|gEfiEdkModulePkgTokenSpaceGuid
|
||||
|
||||
[PcdsFeatureFlag.IA32]
|
||||
PcdDxeIplSwitchToLongMode|gEfiMdeModulePkgTokenSpaceGuid
|
||||
|
||||
|
||||
################################################################################
|
||||
#
|
||||
# Dependency Expression Section - list of Dependency expressions that are required for
|
||||
# this module.
|
||||
#
|
||||
################################################################################
|
||||
|
||||
[Depex]
|
||||
gEfiPeiMemoryDiscoveredPpiGuid
|
||||
|
168
MdeModulePkg/Core/DxeIplPeim/DxeIpl.msa
Normal file
168
MdeModulePkg/Core/DxeIplPeim/DxeIpl.msa
Normal file
@@ -0,0 +1,168 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
|
||||
<MsaHeader>
|
||||
<ModuleName>DxeIpl</ModuleName>
|
||||
<ModuleType>PEIM</ModuleType>
|
||||
<GuidValue>86D70125-BAA3-4296-A62F-602BEBBB9081</GuidValue>
|
||||
<Version>1.0</Version>
|
||||
<Abstract>Component description file for DxeIpl module</Abstract>
|
||||
<Description>The responsibility of this module is to load the DXE Core from a Firmware Volume. This implementation i used to load a 32-bit DXE Core.</Description>
|
||||
<Copyright>Copyright (c) 2006 - 2007, Intel Corporation</Copyright>
|
||||
<License>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.</License>
|
||||
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
|
||||
</MsaHeader>
|
||||
<ModuleDefinitions>
|
||||
<SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>
|
||||
<BinaryModule>false</BinaryModule>
|
||||
<OutputFileBasename>DxeIpl</OutputFileBasename>
|
||||
</ModuleDefinitions>
|
||||
<LibraryClassDefinitions>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>DebugLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>PeimEntryPoint</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>BaseLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>HobLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>PeiServicesLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>ReportStatusCodeLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>CacheMaintenanceLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>EdkPeCoffLoaderLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>UefiDecompressLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>TianoDecompressLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>CustomDecompressLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>PeiServicesTablePointerLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>BaseMemoryLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>MemoryAllocationLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>PcdLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>PeCoffLib</Keyword>
|
||||
</LibraryClass>
|
||||
</LibraryClassDefinitions>
|
||||
<SourceFiles>
|
||||
<Filename>DxeLoad.c</Filename>
|
||||
<Filename>DxeIpl.h</Filename>
|
||||
<Filename>DxeIpl.dxs</Filename>
|
||||
<Filename SupArchList="IA32 X64 EBC">Ia32/ImageRead.c</Filename>
|
||||
<Filename SupArchList="IA32">Ia32/DxeLoadFunc.c</Filename>
|
||||
<Filename SupArchList="IA32">Ia32/VirtualMemory.c</Filename>
|
||||
<Filename SupArchList="IA32">Ia32/VirtualMemory.h</Filename>
|
||||
<Filename SupArchList="X64 EBC">X64/DxeLoadFunc.c</Filename>
|
||||
<Filename SupArchList="IPF">Ipf/ImageRead.c</Filename>
|
||||
<Filename SupArchList="IPF">Ipf/DxeLoadFunc.c</Filename>
|
||||
</SourceFiles>
|
||||
<PackageDependencies>
|
||||
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
|
||||
<Package PackageGuid="68169ab0-d41b-4009-9060-292c253ac43d"/>
|
||||
</PackageDependencies>
|
||||
<Protocols>
|
||||
<Protocol Usage="SOMETIMES_PRODUCED">
|
||||
<ProtocolCName>gEfiDecompressProtocolGuid</ProtocolCName>
|
||||
</Protocol>
|
||||
<Protocol Usage="SOMETIMES_PRODUCED">
|
||||
<ProtocolCName>gEfiTianoDecompressProtocolGuid</ProtocolCName>
|
||||
</Protocol>
|
||||
<Protocol Usage="SOMETIMES_PRODUCED">
|
||||
<ProtocolCName>gEfiCustomizedDecompressProtocolGuid</ProtocolCName>
|
||||
</Protocol>
|
||||
</Protocols>
|
||||
<PPIs>
|
||||
<Ppi Usage="SOMETIMES_PRODUCED">
|
||||
<PpiCName>gEfiDxeIplPpiGuid</PpiCName>
|
||||
</Ppi>
|
||||
<Ppi Usage="SOMETIMES_PRODUCED">
|
||||
<PpiCName>gEfiPeiFvFileLoaderPpiGuid</PpiCName>
|
||||
</Ppi>
|
||||
<Ppi Usage="SOMETIMES_PRODUCED">
|
||||
<PpiCName>gEfiEndOfPeiSignalPpiGuid</PpiCName>
|
||||
</Ppi>
|
||||
<Ppi Usage="SOMETIMES_CONSUMED">
|
||||
<PpiCName>gEfiPeiRecoveryModulePpiGuid</PpiCName>
|
||||
</Ppi>
|
||||
<Ppi Usage="SOMETIMES_CONSUMED">
|
||||
<PpiCName>gEfiPeiS3ResumePpiGuid</PpiCName>
|
||||
</Ppi>
|
||||
<Ppi Usage="SOMETIMES_CONSUMED">
|
||||
<PpiCName>gEfiPeiSectionExtractionPpiGuid</PpiCName>
|
||||
</Ppi>
|
||||
<Ppi Usage="SOMETIMES_CONSUMED">
|
||||
<PpiCName>gEfiPeiSecurityPpiGuid</PpiCName>
|
||||
</Ppi>
|
||||
</PPIs>
|
||||
<Guids>
|
||||
<GuidCNames Usage="SOMETIMES_CONSUMED">
|
||||
<GuidCName>gEfiPeiPeCoffLoaderGuid</GuidCName>
|
||||
</GuidCNames>
|
||||
</Guids>
|
||||
<Externs>
|
||||
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
|
||||
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
|
||||
<Extern>
|
||||
<ModuleEntryPoint>PeimInitializeDxeIpl</ModuleEntryPoint>
|
||||
</Extern>
|
||||
</Externs>
|
||||
<PcdCoded>
|
||||
<PcdEntry PcdItemType="FEATURE_FLAG" Usage="ALWAYS_CONSUMED" SupArchList="IA32">
|
||||
<C_Name>PcdDxeIplSwitchToLongMode</C_Name>
|
||||
<TokenSpaceGuidCName>gEfiEdkModulePkgTokenSpaceGuid</TokenSpaceGuidCName>
|
||||
<DefaultValue>TRUE</DefaultValue>
|
||||
<HelpText>If this feature is enabled, then the DXE IPL will load a 64-bit DxeCore.</HelpText>
|
||||
</PcdEntry>
|
||||
<PcdEntry PcdItemType="FEATURE_FLAG" Usage="ALWAYS_CONSUMED">
|
||||
<C_Name>PcdDxeIplBuildShareCodeHobs</C_Name>
|
||||
<TokenSpaceGuidCName>gEfiEdkModulePkgTokenSpaceGuid</TokenSpaceGuidCName>
|
||||
<DefaultValue>FALSE</DefaultValue>
|
||||
<HelpText>If this feature is enabled, DXE IPL will build a series of HOBs to share code with DXE Core.</HelpText>
|
||||
</PcdEntry>
|
||||
<PcdEntry PcdItemType="FEATURE_FLAG" Usage="ALWAYS_CONSUMED">
|
||||
<C_Name>PcdDxeIplSupportEfiDecompress</C_Name>
|
||||
<TokenSpaceGuidCName>gEfiEdkModulePkgTokenSpaceGuid</TokenSpaceGuidCName>
|
||||
<DefaultValue>TRUE</DefaultValue>
|
||||
<HelpText>If this feature is enabled, then the DXE IPL must support decompressing files compressed with the EFI Compression algorithm</HelpText>
|
||||
</PcdEntry>
|
||||
<PcdEntry PcdItemType="FEATURE_FLAG" Usage="ALWAYS_CONSUMED">
|
||||
<C_Name>PcdDxeIplSupportTianoDecompress</C_Name>
|
||||
<TokenSpaceGuidCName>gEfiEdkModulePkgTokenSpaceGuid</TokenSpaceGuidCName>
|
||||
<DefaultValue>TRUE</DefaultValue>
|
||||
<HelpText>If this feature is enabled, then the DXE IPL must support decompressing files compressed with the Tiano Compression algorithm</HelpText>
|
||||
</PcdEntry>
|
||||
<PcdEntry PcdItemType="FEATURE_FLAG" Usage="ALWAYS_CONSUMED">
|
||||
<C_Name>PcdDxeIplSupportCustomDecompress</C_Name>
|
||||
<TokenSpaceGuidCName>gEfiEdkModulePkgTokenSpaceGuid</TokenSpaceGuidCName>
|
||||
<DefaultValue>TRUE</DefaultValue>
|
||||
<HelpText>If this feature is enabled, then the DXE IPL must support decompressing files compressed with the Custom Compression algorithm</HelpText>
|
||||
</PcdEntry>
|
||||
</PcdCoded>
|
||||
</ModuleSurfaceArea>
|
980
MdeModulePkg/Core/DxeIplPeim/DxeLoad.c
Normal file
980
MdeModulePkg/Core/DxeIplPeim/DxeLoad.c
Normal file
@@ -0,0 +1,980 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
|
||||
DxeLoad.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Last PEIM.
|
||||
Responsibility of this module is to load the DXE Core from a Firmware Volume.
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#include "DxeIpl.h"
|
||||
|
||||
// porting note remove later
|
||||
#include "Common/DecompressLibraryHob.h"
|
||||
#include "FrameworkPei.h"
|
||||
// end of remove later
|
||||
|
||||
BOOLEAN gInMemory = FALSE;
|
||||
|
||||
//
|
||||
// Module Globals used in the DXE to PEI handoff
|
||||
// These must be module globals, so the stack can be switched
|
||||
//
|
||||
static EFI_DXE_IPL_PPI mDxeIplPpi = {
|
||||
DxeLoadCore
|
||||
};
|
||||
|
||||
static EFI_PEI_FV_FILE_LOADER_PPI mLoadFilePpi = {
|
||||
DxeIplLoadFile
|
||||
};
|
||||
|
||||
static EFI_PEI_PPI_DESCRIPTOR mPpiList[] = {
|
||||
{
|
||||
EFI_PEI_PPI_DESCRIPTOR_PPI,
|
||||
&gEfiPeiFvFileLoaderPpiGuid,
|
||||
&mLoadFilePpi
|
||||
},
|
||||
{
|
||||
(EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
|
||||
&gEfiDxeIplPpiGuid,
|
||||
&mDxeIplPpi
|
||||
}
|
||||
};
|
||||
|
||||
static EFI_PEI_PPI_DESCRIPTOR mPpiSignal = {
|
||||
(EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
|
||||
&gEfiEndOfPeiSignalPpiGuid,
|
||||
NULL
|
||||
};
|
||||
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED DECOMPRESS_LIBRARY gEfiDecompress = {
|
||||
UefiDecompressGetInfo,
|
||||
UefiDecompress
|
||||
};
|
||||
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED DECOMPRESS_LIBRARY gCustomDecompress = {
|
||||
CustomDecompressGetInfo,
|
||||
CustomDecompress
|
||||
};
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeimInitializeDxeIpl (
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader,
|
||||
IN EFI_PEI_SERVICES **PeiServices
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Initializes the Dxe Ipl PPI
|
||||
|
||||
Arguments:
|
||||
|
||||
FfsHeader - Pointer to FFS file header
|
||||
PeiServices - General purpose services available to every PEIM.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_PEI_PE_COFF_LOADER_PROTOCOL *PeiEfiPeiPeCoffLoader;
|
||||
EFI_BOOT_MODE BootMode;
|
||||
|
||||
Status = PeiServicesGetBootMode (&BootMode);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
if (!gInMemory && (BootMode != BOOT_ON_S3_RESUME)) {
|
||||
//
|
||||
// The DxeIpl has not yet been shadowed
|
||||
//
|
||||
PeiEfiPeiPeCoffLoader = (EFI_PEI_PE_COFF_LOADER_PROTOCOL *)GetPeCoffLoaderProtocol ();
|
||||
|
||||
//
|
||||
// Shadow DxeIpl and then re-run its entry point
|
||||
//
|
||||
Status = ShadowDxeIpl (FfsHeader, PeiEfiPeiPeCoffLoader);
|
||||
} else {
|
||||
//
|
||||
// Install FvFileLoader and DxeIpl PPIs.
|
||||
//
|
||||
Status = PeiServicesInstallPpi (mPpiList);
|
||||
ASSERT_EFI_ERROR(Status);
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DxeLoadCore (
|
||||
IN EFI_DXE_IPL_PPI *This,
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PEI_HOB_POINTERS HobList
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Main entry point to last PEIM
|
||||
|
||||
Arguments:
|
||||
This - Entry point for DXE IPL PPI
|
||||
PeiServices - General purpose services available to every PEIM.
|
||||
HobList - Address to the Pei HOB list
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - DEX core was successfully loaded.
|
||||
EFI_OUT_OF_RESOURCES - There are not enough resources to load DXE core.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_GUID DxeCoreFileName;
|
||||
EFI_GUID FirmwareFileName;
|
||||
VOID *Pe32Data;
|
||||
VOID *FvImageData;
|
||||
EFI_PHYSICAL_ADDRESS DxeCoreAddress;
|
||||
UINT64 DxeCoreSize;
|
||||
EFI_PHYSICAL_ADDRESS DxeCoreEntryPoint;
|
||||
EFI_PEI_PE_COFF_LOADER_PROTOCOL *PeiEfiPeiPeCoffLoader;
|
||||
EFI_BOOT_MODE BootMode;
|
||||
EFI_PEI_RECOVERY_MODULE_PPI *PeiRecovery;
|
||||
EFI_PEI_S3_RESUME_PPI *S3Resume;
|
||||
|
||||
// PERF_START (PeiServices, L"DxeIpl", NULL, 0);
|
||||
|
||||
//
|
||||
// if in S3 Resume, restore configure
|
||||
//
|
||||
Status = PeiServicesGetBootMode (&BootMode);
|
||||
ASSERT_EFI_ERROR(Status);
|
||||
|
||||
if (BootMode == BOOT_ON_S3_RESUME) {
|
||||
Status = PeiServicesLocatePpi (
|
||||
&gEfiPeiS3ResumePpiGuid,
|
||||
0,
|
||||
NULL,
|
||||
(VOID **)&S3Resume
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
Status = S3Resume->S3RestoreConfig (PeiServices);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
} else if (BootMode == BOOT_IN_RECOVERY_MODE) {
|
||||
|
||||
Status = PeiServicesLocatePpi (
|
||||
&gEfiPeiRecoveryModulePpiGuid,
|
||||
0,
|
||||
NULL,
|
||||
(VOID **)&PeiRecovery
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
Status = PeiRecovery->LoadRecoveryCapsule (PeiServices, PeiRecovery);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((EFI_D_ERROR, "Load Recovery Capsule Failed.(Status = %r)\n", Status));
|
||||
CpuDeadLoop ();
|
||||
}
|
||||
|
||||
//
|
||||
// Now should have a HOB with the DXE core w/ the old HOB destroyed
|
||||
//
|
||||
}
|
||||
|
||||
//
|
||||
// Install the PEI Protocols that are shared between PEI and DXE
|
||||
//
|
||||
PeiEfiPeiPeCoffLoader = (EFI_PEI_PE_COFF_LOADER_PROTOCOL *)GetPeCoffLoaderProtocol ();
|
||||
ASSERT (PeiEfiPeiPeCoffLoader != NULL);
|
||||
|
||||
|
||||
//
|
||||
// Find the EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE type compressed Firmware Volume file
|
||||
// The file found will be processed by PeiProcessFile: It will first be decompressed to
|
||||
// a normal FV, then a corresponding FV type hob will be built.
|
||||
//
|
||||
Status = PeiFindFile (
|
||||
EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE,
|
||||
EFI_SECTION_FIRMWARE_VOLUME_IMAGE,
|
||||
&FirmwareFileName,
|
||||
&FvImageData
|
||||
);
|
||||
|
||||
//
|
||||
// Find the DXE Core in a Firmware Volume
|
||||
//
|
||||
Status = PeiFindFile (
|
||||
EFI_FV_FILETYPE_DXE_CORE,
|
||||
EFI_SECTION_PE32,
|
||||
&DxeCoreFileName,
|
||||
&Pe32Data
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
//
|
||||
// Load the DXE Core from a Firmware Volume
|
||||
//
|
||||
Status = PeiLoadFile (
|
||||
PeiEfiPeiPeCoffLoader,
|
||||
Pe32Data,
|
||||
&DxeCoreAddress,
|
||||
&DxeCoreSize,
|
||||
&DxeCoreEntryPoint
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
//
|
||||
// Add HOB for the DXE Core
|
||||
//
|
||||
BuildModuleHob (
|
||||
&DxeCoreFileName,
|
||||
DxeCoreAddress,
|
||||
DxeCoreSize,
|
||||
DxeCoreEntryPoint
|
||||
);
|
||||
|
||||
//
|
||||
// Report Status Code EFI_SW_PEI_PC_HANDOFF_TO_NEXT
|
||||
//
|
||||
REPORT_STATUS_CODE (
|
||||
EFI_PROGRESS_CODE,
|
||||
EFI_SOFTWARE_PEI_MODULE | EFI_SW_PEI_CORE_PC_HANDOFF_TO_NEXT
|
||||
);
|
||||
|
||||
if (FeaturePcdGet (PcdDxeIplBuildShareCodeHobs)) {
|
||||
if (FeaturePcdGet (PcdDxeIplSupportEfiDecompress)) {
|
||||
//
|
||||
// Add HOB for the EFI Decompress Protocol
|
||||
//
|
||||
BuildGuidDataHob (
|
||||
&gEfiDecompressProtocolGuid,
|
||||
(VOID *)&gEfiDecompress,
|
||||
sizeof (gEfiDecompress)
|
||||
);
|
||||
}
|
||||
if (FeaturePcdGet (PcdDxeIplSupportCustomDecompress)) {
|
||||
//
|
||||
// Add HOB for the user customized Decompress Protocol
|
||||
//
|
||||
BuildGuidDataHob (
|
||||
&gEfiCustomizedDecompressProtocolGuid,
|
||||
(VOID *)&gCustomDecompress,
|
||||
sizeof (gCustomDecompress)
|
||||
);
|
||||
}
|
||||
|
||||
//
|
||||
// Add HOB for the PE/COFF Loader Protocol
|
||||
//
|
||||
BuildGuidDataHob (
|
||||
&gEfiPeiPeCoffLoaderGuid,
|
||||
(VOID *)&PeiEfiPeiPeCoffLoader,
|
||||
sizeof (VOID *)
|
||||
);
|
||||
}
|
||||
|
||||
//
|
||||
// Transfer control to the DXE Core
|
||||
// The handoff state is simply a pointer to the HOB list
|
||||
//
|
||||
|
||||
DEBUG ((EFI_D_INFO, "DXE Core Entry Point 0x%08x\n", (UINTN) DxeCoreEntryPoint));
|
||||
HandOffToDxeCore (DxeCoreEntryPoint, HobList, &mPpiSignal);
|
||||
//
|
||||
// If we get here, then the DXE Core returned. This is an error
|
||||
// Dxe Core should not return.
|
||||
//
|
||||
ASSERT (FALSE);
|
||||
CpuDeadLoop ();
|
||||
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
PeiFindFile (
|
||||
IN UINT8 Type,
|
||||
IN UINT16 SectionType,
|
||||
OUT EFI_GUID *FileName,
|
||||
OUT VOID **Pe32Data
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Finds a PE/COFF of a specific Type and SectionType in the Firmware Volumes
|
||||
described in the HOB list. Able to search in a compression set in a FFS file.
|
||||
But only one level of compression is supported, that is, not able to search
|
||||
in a compression set that is within another compression set.
|
||||
|
||||
Arguments:
|
||||
|
||||
Type - The Type of file to retrieve
|
||||
|
||||
SectionType - The type of section to retrieve from a file
|
||||
|
||||
FileName - The name of the file found in the Firmware Volume
|
||||
|
||||
Pe32Data - Pointer to the beginning of the PE/COFF file found in the Firmware Volume
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The file was found, and the name is returned in FileName, and a pointer to
|
||||
the PE/COFF image is returned in Pe32Data
|
||||
|
||||
EFI_NOT_FOUND - The file was not found in the Firmware Volumes present in the HOB List
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
|
||||
EFI_FFS_FILE_HEADER *FfsFileHeader;
|
||||
EFI_STATUS Status;
|
||||
EFI_PEI_HOB_POINTERS Hob;
|
||||
|
||||
|
||||
FwVolHeader = NULL;
|
||||
FfsFileHeader = NULL;
|
||||
Status = EFI_SUCCESS;
|
||||
|
||||
//
|
||||
// For each Firmware Volume, look for a specified type
|
||||
// of file and break out until no one is found
|
||||
//
|
||||
Hob.Raw = GetHobList ();
|
||||
while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, Hob.Raw)) != NULL) {
|
||||
FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (Hob.FirmwareVolume->BaseAddress);
|
||||
//
|
||||
// Make sure the FV HOB does not get corrupted.
|
||||
//
|
||||
ASSERT (FwVolHeader->Signature == EFI_FVH_SIGNATURE);
|
||||
|
||||
Status = PeiServicesFfsFindNextFile (
|
||||
Type,
|
||||
FwVolHeader,
|
||||
&FfsFileHeader
|
||||
);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
Status = PeiProcessFile (
|
||||
SectionType,
|
||||
FfsFileHeader,
|
||||
Pe32Data,
|
||||
&Hob
|
||||
);
|
||||
CopyMem (FileName, &FfsFileHeader->Name, sizeof (EFI_GUID));
|
||||
//
|
||||
// Find all Fv type ffs to get all FvImage and add them into FvHob
|
||||
//
|
||||
if (!EFI_ERROR (Status) && (Type != EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE)) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
}
|
||||
Hob.Raw = GET_NEXT_HOB (Hob);
|
||||
}
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
PeiLoadFile (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *PeiEfiPeiPeCoffLoader,
|
||||
IN VOID *Pe32Data,
|
||||
OUT EFI_PHYSICAL_ADDRESS *ImageAddress,
|
||||
OUT UINT64 *ImageSize,
|
||||
OUT EFI_PHYSICAL_ADDRESS *EntryPoint
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Loads and relocates a PE/COFF image into memory.
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiEfiPeiPeCoffLoader - Pointer to a PE COFF loader protocol
|
||||
|
||||
Pe32Data - The base address of the PE/COFF file that is to be loaded and relocated
|
||||
|
||||
ImageAddress - The base address of the relocated PE/COFF image
|
||||
|
||||
ImageSize - The size of the relocated PE/COFF image
|
||||
|
||||
EntryPoint - The entry point of the relocated PE/COFF image
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The file was loaded and relocated
|
||||
|
||||
EFI_OUT_OF_RESOURCES - There was not enough memory to load and relocate the PE/COFF file
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
|
||||
|
||||
ZeroMem (&ImageContext, sizeof (ImageContext));
|
||||
ImageContext.Handle = Pe32Data;
|
||||
Status = GetImageReadFunction (&ImageContext);
|
||||
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
Status = PeiEfiPeiPeCoffLoader->GetImageInfo (PeiEfiPeiPeCoffLoader, &ImageContext);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
//
|
||||
// Allocate Memory for the image
|
||||
//
|
||||
ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) AllocatePages (EFI_SIZE_TO_PAGES ((UINT32) ImageContext.ImageSize));
|
||||
ASSERT (ImageContext.ImageAddress != 0);
|
||||
|
||||
//
|
||||
// Load the image to our new buffer
|
||||
//
|
||||
Status = PeiEfiPeiPeCoffLoader->LoadImage (PeiEfiPeiPeCoffLoader, &ImageContext);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
//
|
||||
// Relocate the image in our new buffer
|
||||
//
|
||||
Status = PeiEfiPeiPeCoffLoader->RelocateImage (PeiEfiPeiPeCoffLoader, &ImageContext);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Flush the instruction cache so the image data is written before we execute it
|
||||
//
|
||||
InvalidateInstructionCacheRange ((VOID *)(UINTN)ImageContext.ImageAddress, (UINTN)ImageContext.ImageSize);
|
||||
|
||||
*ImageAddress = ImageContext.ImageAddress;
|
||||
*ImageSize = ImageContext.ImageSize;
|
||||
*EntryPoint = ImageContext.EntryPoint;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
ShadowDxeIpl (
|
||||
IN EFI_FFS_FILE_HEADER *DxeIplFileHeader,
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *PeiEfiPeiPeCoffLoader
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Shadow the DXE IPL to a different memory location. This occurs after permanent
|
||||
memory has been discovered.
|
||||
|
||||
Arguments:
|
||||
|
||||
DxeIplFileHeader - Pointer to the FFS file header of the DXE IPL driver
|
||||
|
||||
PeiEfiPeiPeCoffLoader - Pointer to a PE COFF loader protocol
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - DXE IPL was successfully shadowed to a different memory location.
|
||||
|
||||
EFI_ ERROR - The shadow was unsuccessful.
|
||||
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN SectionLength;
|
||||
UINTN OccupiedSectionLength;
|
||||
EFI_PHYSICAL_ADDRESS DxeIplAddress;
|
||||
UINT64 DxeIplSize;
|
||||
EFI_PHYSICAL_ADDRESS DxeIplEntryPoint;
|
||||
EFI_STATUS Status;
|
||||
EFI_COMMON_SECTION_HEADER *Section;
|
||||
|
||||
Section = (EFI_COMMON_SECTION_HEADER *) (DxeIplFileHeader + 1);
|
||||
|
||||
while ((Section->Type != EFI_SECTION_PE32) && (Section->Type != EFI_SECTION_TE)) {
|
||||
SectionLength = *(UINT32 *) (Section->Size) & 0x00ffffff;
|
||||
OccupiedSectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
|
||||
Section = (EFI_COMMON_SECTION_HEADER *) ((UINT8 *) Section + OccupiedSectionLength);
|
||||
}
|
||||
//
|
||||
// Relocate DxeIpl into memory by using loadfile service
|
||||
//
|
||||
Status = PeiLoadFile (
|
||||
PeiEfiPeiPeCoffLoader,
|
||||
(VOID *) (Section + 1),
|
||||
&DxeIplAddress,
|
||||
&DxeIplSize,
|
||||
&DxeIplEntryPoint
|
||||
);
|
||||
|
||||
if (Status == EFI_SUCCESS) {
|
||||
//
|
||||
// Set gInMemory global variable to TRUE to indicate the dxeipl is shadowed.
|
||||
//
|
||||
*(BOOLEAN *) ((UINTN) &gInMemory + (UINTN) DxeIplEntryPoint - (UINTN) _ModuleEntryPoint) = TRUE;
|
||||
Status = ((EFI_PEIM_ENTRY_POINT) (UINTN) DxeIplEntryPoint) ((EFI_PEI_FILE_HANDLE *) DxeIplFileHeader, GetPeiServicesTablePointer());
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
DxeIplLoadFile (
|
||||
IN EFI_PEI_FV_FILE_LOADER_PPI *This,
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader,
|
||||
OUT EFI_PHYSICAL_ADDRESS *ImageAddress,
|
||||
OUT UINT64 *ImageSize,
|
||||
OUT EFI_PHYSICAL_ADDRESS *EntryPoint
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Given a pointer to an FFS file containing a PE32 image, get the
|
||||
information on the PE32 image, and then "load" it so that it
|
||||
can be executed.
|
||||
|
||||
Arguments:
|
||||
|
||||
This - pointer to our file loader protocol
|
||||
|
||||
FfsHeader - pointer to the FFS file header of the FFS file that
|
||||
contains the PE32 image we want to load
|
||||
|
||||
ImageAddress - returned address where the PE32 image is loaded
|
||||
|
||||
ImageSize - returned size of the loaded PE32 image
|
||||
|
||||
EntryPoint - entry point to the loaded PE32 image
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The FFS file was successfully loaded.
|
||||
|
||||
EFI_ERROR - Unable to load the FFS file.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_PEI_PE_COFF_LOADER_PROTOCOL *PeiEfiPeiPeCoffLoader;
|
||||
EFI_STATUS Status;
|
||||
VOID *Pe32Data;
|
||||
|
||||
Pe32Data = NULL;
|
||||
PeiEfiPeiPeCoffLoader = (EFI_PEI_PE_COFF_LOADER_PROTOCOL *)GetPeCoffLoaderProtocol ();
|
||||
|
||||
//
|
||||
// Preprocess the FFS file to get a pointer to the PE32 information
|
||||
// in the enclosed PE32 image.
|
||||
//
|
||||
Status = PeiProcessFile (
|
||||
EFI_SECTION_PE32,
|
||||
FfsHeader,
|
||||
&Pe32Data,
|
||||
NULL
|
||||
);
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
//
|
||||
// Load the PE image from the FFS file
|
||||
//
|
||||
Status = PeiLoadFile (
|
||||
PeiEfiPeiPeCoffLoader,
|
||||
Pe32Data,
|
||||
ImageAddress,
|
||||
ImageSize,
|
||||
EntryPoint
|
||||
);
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
PeiProcessFile (
|
||||
IN UINT16 SectionType,
|
||||
IN EFI_FFS_FILE_HEADER *FfsFileHeader,
|
||||
OUT VOID **Pe32Data,
|
||||
IN EFI_PEI_HOB_POINTERS *OrigHob
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Arguments:
|
||||
|
||||
SectionType - The type of section in the FFS file to process.
|
||||
|
||||
FfsFileHeader - Pointer to the FFS file to process, looking for the
|
||||
specified SectionType
|
||||
|
||||
Pe32Data - returned pointer to the start of the PE32 image found
|
||||
in the FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - found the PE32 section in the FFS file
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
VOID *SectionData;
|
||||
DECOMPRESS_LIBRARY *DecompressLibrary;
|
||||
UINT8 *DstBuffer;
|
||||
UINT8 *ScratchBuffer;
|
||||
UINT32 DstBufferSize;
|
||||
UINT32 ScratchBufferSize;
|
||||
EFI_COMMON_SECTION_HEADER *CmpSection;
|
||||
UINTN CmpSectionLength;
|
||||
UINTN OccupiedCmpSectionLength;
|
||||
VOID *CmpFileData;
|
||||
UINTN CmpFileSize;
|
||||
EFI_COMMON_SECTION_HEADER *Section;
|
||||
UINTN SectionLength;
|
||||
UINTN OccupiedSectionLength;
|
||||
UINT64 FileSize;
|
||||
UINT32 AuthenticationStatus;
|
||||
EFI_PEI_SECTION_EXTRACTION_PPI *SectionExtract;
|
||||
UINT32 BufferSize;
|
||||
UINT8 *Buffer;
|
||||
EFI_PEI_SECURITY_PPI *Security;
|
||||
BOOLEAN StartCrisisRecovery;
|
||||
EFI_GUID TempGuid;
|
||||
EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
|
||||
EFI_COMPRESSION_SECTION *CompressionSection;
|
||||
|
||||
//
|
||||
// Initialize local variables.
|
||||
//
|
||||
DecompressLibrary = NULL;
|
||||
DstBuffer = NULL;
|
||||
DstBufferSize = 0;
|
||||
|
||||
Status = PeiServicesFfsFindSectionData (
|
||||
EFI_SECTION_COMPRESSION,
|
||||
FfsFileHeader,
|
||||
&SectionData
|
||||
);
|
||||
|
||||
//
|
||||
// First process the compression section
|
||||
//
|
||||
if (!EFI_ERROR (Status)) {
|
||||
//
|
||||
// Yes, there is a compression section, so extract the contents
|
||||
// Decompress the image here
|
||||
//
|
||||
Section = (EFI_COMMON_SECTION_HEADER *) (UINTN) (VOID *) ((UINT8 *) (FfsFileHeader) + (UINTN) sizeof (EFI_FFS_FILE_HEADER));
|
||||
|
||||
do {
|
||||
SectionLength = *(UINT32 *) (Section->Size) & 0x00ffffff;
|
||||
OccupiedSectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
|
||||
|
||||
//
|
||||
// Was the DXE Core file encapsulated in a GUID'd section?
|
||||
//
|
||||
if (Section->Type == EFI_SECTION_GUID_DEFINED) {
|
||||
|
||||
//
|
||||
// This following code constitutes the addition of the security model
|
||||
// to the DXE IPL.
|
||||
//
|
||||
//
|
||||
// Set a default authenticatino state
|
||||
//
|
||||
AuthenticationStatus = 0;
|
||||
|
||||
Status = PeiServicesLocatePpi (
|
||||
&gEfiPeiSectionExtractionPpiGuid,
|
||||
0,
|
||||
NULL,
|
||||
(VOID **)&SectionExtract
|
||||
);
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
//
|
||||
// Verify Authentication State
|
||||
//
|
||||
CopyMem (&TempGuid, Section + 1, sizeof (EFI_GUID));
|
||||
|
||||
Status = SectionExtract->PeiGetSection (
|
||||
GetPeiServicesTablePointer(),
|
||||
SectionExtract,
|
||||
(EFI_SECTION_TYPE *) &SectionType,
|
||||
&TempGuid,
|
||||
0,
|
||||
(VOID **) &Buffer,
|
||||
&BufferSize,
|
||||
&AuthenticationStatus
|
||||
);
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
//
|
||||
// If not ask the Security PPI, if exists, for disposition
|
||||
//
|
||||
//
|
||||
Status = PeiServicesLocatePpi (
|
||||
&gEfiPeiSecurityPpiGuid,
|
||||
0,
|
||||
NULL,
|
||||
(VOID **)&Security
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
Status = Security->AuthenticationState (
|
||||
GetPeiServicesTablePointer(),
|
||||
(struct _EFI_PEI_SECURITY_PPI *) Security,
|
||||
AuthenticationStatus,
|
||||
FfsFileHeader,
|
||||
&StartCrisisRecovery
|
||||
);
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
//
|
||||
// If there is a security violation, report to caller and have
|
||||
// the upper-level logic possible engender a crisis recovery
|
||||
//
|
||||
if (StartCrisisRecovery) {
|
||||
return EFI_SECURITY_VIOLATION;
|
||||
}
|
||||
}
|
||||
|
||||
if (Section->Type == EFI_SECTION_PE32) {
|
||||
//
|
||||
// This is what we want
|
||||
//
|
||||
*Pe32Data = (VOID *) (Section + 1);
|
||||
return EFI_SUCCESS;
|
||||
} else if (Section->Type == EFI_SECTION_COMPRESSION) {
|
||||
//
|
||||
// This is a compression set, expand it
|
||||
//
|
||||
CompressionSection = (EFI_COMPRESSION_SECTION *) Section;
|
||||
|
||||
switch (CompressionSection->CompressionType) {
|
||||
case EFI_STANDARD_COMPRESSION:
|
||||
//
|
||||
// Load EFI standard compression.
|
||||
//
|
||||
if (FeaturePcdGet (PcdDxeIplSupportTianoDecompress)) {
|
||||
DecompressLibrary = &gEfiDecompress;
|
||||
} else {
|
||||
ASSERT (FALSE);
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
break;
|
||||
|
||||
// porting note the original branch for customized compress is removed, it should be change to use GUID compress
|
||||
|
||||
case EFI_NOT_COMPRESSED:
|
||||
//
|
||||
// Allocate destination buffer
|
||||
//
|
||||
DstBufferSize = CompressionSection->UncompressedLength;
|
||||
DstBuffer = AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize));
|
||||
if (DstBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
//
|
||||
// stream is not actually compressed, just encapsulated. So just copy it.
|
||||
//
|
||||
CopyMem (DstBuffer, CompressionSection + 1, DstBufferSize);
|
||||
break;
|
||||
|
||||
default:
|
||||
//
|
||||
// Don't support other unknown compression type.
|
||||
//
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
if (CompressionSection->CompressionType != EFI_NOT_COMPRESSED) {
|
||||
//
|
||||
// For compressed data, decompress them to dstbuffer.
|
||||
//
|
||||
Status = DecompressLibrary->GetInfo (
|
||||
(UINT8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),
|
||||
(UINT32) SectionLength - sizeof (EFI_COMPRESSION_SECTION),
|
||||
&DstBufferSize,
|
||||
&ScratchBufferSize
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
//
|
||||
// GetInfo failed
|
||||
//
|
||||
DEBUG ((EFI_D_ERROR, "Decompress GetInfo Failed - %r\n", Status));
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
//
|
||||
// Allocate scratch buffer
|
||||
//
|
||||
ScratchBuffer = AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize));
|
||||
if (ScratchBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
//
|
||||
// Allocate destination buffer
|
||||
//
|
||||
DstBuffer = AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize));
|
||||
if (DstBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
//
|
||||
// Call decompress function
|
||||
//
|
||||
Status = DecompressLibrary->Decompress (
|
||||
(CHAR8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),
|
||||
DstBuffer,
|
||||
ScratchBuffer
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
//
|
||||
// Decompress failed
|
||||
//
|
||||
DEBUG ((EFI_D_ERROR, "Decompress Failed - %r\n", Status));
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Decompress successfully.
|
||||
// Loop the decompressed data searching for expected section.
|
||||
//
|
||||
CmpSection = (EFI_COMMON_SECTION_HEADER *) DstBuffer;
|
||||
CmpFileData = (VOID *) DstBuffer;
|
||||
CmpFileSize = DstBufferSize;
|
||||
do {
|
||||
CmpSectionLength = *(UINT32 *) (CmpSection->Size) & 0x00ffffff;
|
||||
if (CmpSection->Type == SectionType) {
|
||||
//
|
||||
// This is what we want
|
||||
//
|
||||
if (SectionType == EFI_SECTION_PE32) {
|
||||
*Pe32Data = (VOID *) (CmpSection + 1);
|
||||
return EFI_SUCCESS;
|
||||
} else if (SectionType == EFI_SECTION_FIRMWARE_VOLUME_IMAGE) {
|
||||
//
|
||||
// Firmware Volume Image in this Section
|
||||
// Skip the section header to get FvHeader
|
||||
//
|
||||
FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (CmpSection + 1);
|
||||
|
||||
if (FvHeader->Signature == EFI_FVH_SIGNATURE) {
|
||||
//
|
||||
// Because FvLength in FvHeader is UINT64 type,
|
||||
// so FvHeader must meed at least 8 bytes alignment.
|
||||
// If current FvImage base address doesn't meet its alignment,
|
||||
// we need to reload this FvImage to another correct memory address.
|
||||
//
|
||||
if (((UINTN) FvHeader % sizeof (UINT64)) != 0) {
|
||||
DstBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINTN) CmpSectionLength - sizeof (EFI_COMMON_SECTION_HEADER)), sizeof (UINT64));
|
||||
if (DstBuffer == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
CopyMem (DstBuffer, FvHeader, (UINTN) CmpSectionLength - sizeof (EFI_COMMON_SECTION_HEADER));
|
||||
FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) DstBuffer;
|
||||
}
|
||||
|
||||
//
|
||||
// Build new FvHob for new decompressed Fv image.
|
||||
//
|
||||
BuildFvHob ((EFI_PHYSICAL_ADDRESS) (UINTN) FvHeader, FvHeader->FvLength);
|
||||
|
||||
//
|
||||
// Set the original FvHob to unused.
|
||||
//
|
||||
if (OrigHob != NULL) {
|
||||
OrigHob->Header->HobType = EFI_HOB_TYPE_UNUSED;
|
||||
}
|
||||
|
||||
//
|
||||
// return found FvImage data.
|
||||
//
|
||||
*Pe32Data = (VOID *) FvHeader;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
}
|
||||
}
|
||||
OccupiedCmpSectionLength = GET_OCCUPIED_SIZE (CmpSectionLength, 4);
|
||||
CmpSection = (EFI_COMMON_SECTION_HEADER *) ((UINT8 *) CmpSection + OccupiedCmpSectionLength);
|
||||
} while (CmpSection->Type != 0 && (UINTN) ((UINT8 *) CmpSection - (UINT8 *) CmpFileData) < CmpFileSize);
|
||||
}
|
||||
//
|
||||
// End of the decompression activity
|
||||
//
|
||||
|
||||
Section = (EFI_COMMON_SECTION_HEADER *) ((UINT8 *) Section + OccupiedSectionLength);
|
||||
FileSize = FfsFileHeader->Size[0] & 0xFF;
|
||||
FileSize += (FfsFileHeader->Size[1] << 8) & 0xFF00;
|
||||
FileSize += (FfsFileHeader->Size[2] << 16) & 0xFF0000;
|
||||
FileSize &= 0x00FFFFFF;
|
||||
} while (Section->Type != 0 && (UINTN) ((UINT8 *) Section - (UINT8 *) FfsFileHeader) < FileSize);
|
||||
|
||||
//
|
||||
// search all sections (compression and non compression) in this FFS, don't
|
||||
// find expected section.
|
||||
//
|
||||
return EFI_NOT_FOUND;
|
||||
} else {
|
||||
//
|
||||
// For those FFS that doesn't contain compression section, directly search
|
||||
// PE or TE section in this FFS.
|
||||
//
|
||||
|
||||
Status = PeiServicesFfsFindSectionData (
|
||||
EFI_SECTION_PE32,
|
||||
FfsFileHeader,
|
||||
&SectionData
|
||||
);
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
Status = PeiServicesFfsFindSectionData (
|
||||
EFI_SECTION_TE,
|
||||
FfsFileHeader,
|
||||
&SectionData
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*Pe32Data = SectionData;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
136
MdeModulePkg/Core/DxeIplPeim/Ia32/DxeLoadFunc.c
Normal file
136
MdeModulePkg/Core/DxeIplPeim/Ia32/DxeLoadFunc.c
Normal file
@@ -0,0 +1,136 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
|
||||
DxeLoadFunc.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Ia32-specifc functionality for DxeLoad.
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#include "DxeIpl.h"
|
||||
#include "VirtualMemory.h"
|
||||
|
||||
//
|
||||
// Global Descriptor Table (GDT)
|
||||
//
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED IA32_GDT gGdtEntries [] = {
|
||||
/* selector { Global Segment Descriptor } */
|
||||
/* 0x00 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, //null descriptor
|
||||
/* 0x08 */ {{0xffff, 0, 0, 0x2, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //linear data segment descriptor
|
||||
/* 0x10 */ {{0xffff, 0, 0, 0xf, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //linear code segment descriptor
|
||||
/* 0x18 */ {{0xffff, 0, 0, 0x3, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //system data segment descriptor
|
||||
/* 0x20 */ {{0xffff, 0, 0, 0xa, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //system code segment descriptor
|
||||
/* 0x28 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, //spare segment descriptor
|
||||
/* 0x30 */ {{0xffff, 0, 0, 0x2, 1, 0, 1, 0xf, 0, 0, 1, 1, 0}}, //system data segment descriptor
|
||||
/* 0x38 */ {{0xffff, 0, 0, 0xa, 1, 0, 1, 0xf, 0, 1, 0, 1, 0}}, //system code segment descriptor
|
||||
/* 0x40 */ {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, //spare segment descriptor
|
||||
};
|
||||
|
||||
//
|
||||
// IA32 Gdt register
|
||||
//
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED CONST IA32_DESCRIPTOR gGdt = {
|
||||
sizeof (gGdtEntries) - 1,
|
||||
(UINTN) gGdtEntries
|
||||
};
|
||||
|
||||
VOID
|
||||
HandOffToDxeCore (
|
||||
IN EFI_PHYSICAL_ADDRESS DxeCoreEntryPoint,
|
||||
IN EFI_PEI_HOB_POINTERS HobList,
|
||||
IN EFI_PEI_PPI_DESCRIPTOR *EndOfPeiSignal
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_PHYSICAL_ADDRESS BaseOfStack;
|
||||
EFI_PHYSICAL_ADDRESS TopOfStack;
|
||||
UINTN PageTables;
|
||||
|
||||
Status = PeiServicesAllocatePages (EfiBootServicesData, EFI_SIZE_TO_PAGES (STACK_SIZE), &BaseOfStack);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
if (FeaturePcdGet(PcdDxeIplSwitchToLongMode)) {
|
||||
//
|
||||
// Compute the top of the stack we were allocated, which is used to load X64 dxe core.
|
||||
// Pre-allocate a 32 bytes which confroms to x64 calling convention.
|
||||
//
|
||||
// The first four parameters to a function are passed in rcx, rdx, r8 and r9.
|
||||
// Any further parameters are pushed on the stack. Furthermore, space (4 * 8bytes) for the
|
||||
// register parameters is reserved on the stack, in case the called function
|
||||
// wants to spill them; this is important if the function is variadic.
|
||||
//
|
||||
TopOfStack = BaseOfStack + EFI_SIZE_TO_PAGES (STACK_SIZE) * EFI_PAGE_SIZE - 32;
|
||||
|
||||
//
|
||||
// X64 Calling Conventions requires that the stack must be aligned to 16 bytes
|
||||
//
|
||||
TopOfStack = (EFI_PHYSICAL_ADDRESS) (UINTN) ALIGN_POINTER (TopOfStack, 16);
|
||||
|
||||
//
|
||||
// Load the GDT of Go64. Since the GDT of 32-bit Tiano locates in the BS_DATA
|
||||
// memory, it may be corrupted when copying FV to high-end memory
|
||||
//
|
||||
AsmWriteGdtr (&gGdt);
|
||||
//
|
||||
// Create page table and save PageMapLevel4 to CR3
|
||||
//
|
||||
PageTables = CreateIdentityMappingPageTables ();
|
||||
|
||||
//
|
||||
// End of PEI phase singal
|
||||
//
|
||||
Status = PeiServicesInstallPpi (EndOfPeiSignal);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
AsmWriteCr3 (PageTables);
|
||||
//
|
||||
// Go to Long Mode. Interrupts will not get turned on until the CPU AP is loaded.
|
||||
// Call x64 drivers passing in single argument, a pointer to the HOBs.
|
||||
//
|
||||
AsmEnablePaging64 (
|
||||
SYS_CODE64_SEL,
|
||||
DxeCoreEntryPoint,
|
||||
(EFI_PHYSICAL_ADDRESS)(UINTN)(HobList.Raw),
|
||||
0,
|
||||
TopOfStack
|
||||
);
|
||||
} else {
|
||||
//
|
||||
// Compute the top of the stack we were allocated. Pre-allocate a UINTN
|
||||
// for safety.
|
||||
//
|
||||
TopOfStack = BaseOfStack + EFI_SIZE_TO_PAGES (STACK_SIZE) * EFI_PAGE_SIZE - CPU_STACK_ALIGNMENT;
|
||||
TopOfStack = (EFI_PHYSICAL_ADDRESS) (UINTN) ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
|
||||
|
||||
//
|
||||
// End of PEI phase singal
|
||||
//
|
||||
Status = PeiServicesInstallPpi (EndOfPeiSignal);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
SwitchStack (
|
||||
(SWITCH_STACK_ENTRY_POINT)(UINTN)DxeCoreEntryPoint,
|
||||
HobList.Raw,
|
||||
NULL,
|
||||
(VOID *) (UINTN) TopOfStack
|
||||
);
|
||||
}
|
||||
}
|
||||
|
117
MdeModulePkg/Core/DxeIplPeim/Ia32/ImageRead.c
Normal file
117
MdeModulePkg/Core/DxeIplPeim/Ia32/ImageRead.c
Normal file
@@ -0,0 +1,117 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
|
||||
ImageRead.c
|
||||
|
||||
Abstract:
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#include "DxeIpl.h"
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeiImageRead (
|
||||
IN VOID *FileHandle,
|
||||
IN UINTN FileOffset,
|
||||
IN OUT UINTN *ReadSize,
|
||||
OUT VOID *Buffer
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
|
||||
|
||||
Arguments:
|
||||
|
||||
FileHandle - The handle to the PE/COFF file
|
||||
|
||||
FileOffset - The offset, in bytes, into the file to read
|
||||
|
||||
ReadSize - The number of bytes to read from the file starting at FileOffset
|
||||
|
||||
Buffer - A pointer to the buffer to read the data into.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 *Destination32;
|
||||
UINT8 *Source32;
|
||||
UINTN Length;
|
||||
|
||||
|
||||
Destination32 = Buffer;
|
||||
Source32 = (UINT8 *) ((UINTN) FileHandle + FileOffset);
|
||||
|
||||
//
|
||||
// This function assumes 32-bit alignment to increase performance
|
||||
//
|
||||
// ASSERT (ALIGN_POINTER (Destination32, sizeof (UINT32)) == Destination32);
|
||||
// ASSERT (ALIGN_POINTER (Source32, sizeof (UINT32)) == Source32);
|
||||
|
||||
Length = *ReadSize;
|
||||
while (Length--) {
|
||||
*(Destination32++) = *(Source32++);
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetImageReadFunction (
|
||||
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Support routine to return the PE32 Image Reader.
|
||||
If the PeiImageRead() function is less than a page
|
||||
in legnth. If the function is more than a page the DXE IPL will crash!!!!
|
||||
|
||||
Arguments:
|
||||
ImageContext - The context of the image being loaded
|
||||
|
||||
Returns:
|
||||
EFI_SUCCESS - If Image function location is found
|
||||
|
||||
--*/
|
||||
{
|
||||
VOID *MemoryBuffer;
|
||||
|
||||
if (gInMemory) {
|
||||
ImageContext->ImageRead = PeiImageRead;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
//
|
||||
// BugBug; This code assumes PeiImageRead() is less than a page in size!
|
||||
// Allocate a page so we can shaddow the read function from FLASH into
|
||||
// memory to increase performance.
|
||||
//
|
||||
|
||||
MemoryBuffer = AllocateCopyPool (0x400, (VOID *)(UINTN) PeiImageRead);
|
||||
ASSERT (MemoryBuffer != NULL);
|
||||
|
||||
ImageContext->ImageRead = (PE_COFF_LOADER_READ_FILE) (UINTN) MemoryBuffer;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
173
MdeModulePkg/Core/DxeIplPeim/Ia32/VirtualMemory.c
Normal file
173
MdeModulePkg/Core/DxeIplPeim/Ia32/VirtualMemory.c
Normal file
@@ -0,0 +1,173 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
VirtualMemory.c
|
||||
|
||||
Abstract:
|
||||
|
||||
x64 Virtual Memory Management Services in the form of an IA-32 driver.
|
||||
Used to establish a 1:1 Virtual to Physical Mapping that is required to
|
||||
enter Long Mode (x64 64-bit mode).
|
||||
|
||||
While we make a 1:1 mapping (identity mapping) for all physical pages
|
||||
we still need to use the MTRR's to ensure that the cachability attirbutes
|
||||
for all memory regions is correct.
|
||||
|
||||
The basic idea is to use 2MB page table entries where ever possible. If
|
||||
more granularity of cachability is required then 4K page tables are used.
|
||||
|
||||
References:
|
||||
1) IA-32 Intel(R) Atchitecture Software Developer's Manual Volume 1:Basic Architecture, Intel
|
||||
2) IA-32 Intel(R) Atchitecture Software Developer's Manual Volume 2:Instruction Set Reference, Intel
|
||||
3) IA-32 Intel(R) Atchitecture Software Developer's Manual Volume 3:System Programmer's Guide, Intel
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#include "VirtualMemory.h"
|
||||
|
||||
UINTN
|
||||
CreateIdentityMappingPageTables (
|
||||
VOID
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Allocates and fills in the Page Directory and Page Table Entries to
|
||||
establish a 1:1 Virtual to Physical mapping.
|
||||
|
||||
Arguments:
|
||||
|
||||
NumberOfProcessorPhysicalAddressBits - Number of processor address bits to use.
|
||||
Limits the number of page table entries
|
||||
to the physical address space.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The 1:1 Virtual to Physical identity mapping was created
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 PhysicalAddressBits;
|
||||
EFI_PHYSICAL_ADDRESS PageAddress;
|
||||
UINTN IndexOfPml4Entries;
|
||||
UINTN IndexOfPdpEntries;
|
||||
UINTN IndexOfPageDirectoryEntries;
|
||||
UINTN NumberOfPml4EntriesNeeded;
|
||||
UINTN NumberOfPdpEntriesNeeded;
|
||||
PAGE_MAP_AND_DIRECTORY_POINTER *PageMapLevel4Entry;
|
||||
PAGE_MAP_AND_DIRECTORY_POINTER *PageMap;
|
||||
PAGE_MAP_AND_DIRECTORY_POINTER *PageDirectoryPointerEntry;
|
||||
PAGE_TABLE_ENTRY *PageDirectoryEntry;
|
||||
UINTN TotalPagesNum;
|
||||
UINTN BigPageAddress;
|
||||
VOID *Hob;
|
||||
|
||||
//
|
||||
// Get physical address bits supported from CPU HOB.
|
||||
//
|
||||
PhysicalAddressBits = 36;
|
||||
|
||||
Hob = GetFirstHob (EFI_HOB_TYPE_CPU);
|
||||
if (Hob != NULL) {
|
||||
PhysicalAddressBits = ((EFI_HOB_CPU *) Hob)->SizeOfMemorySpace;
|
||||
}
|
||||
|
||||
//
|
||||
// Calculate the table entries needed.
|
||||
//
|
||||
if (PhysicalAddressBits <= 39 ) {
|
||||
NumberOfPml4EntriesNeeded = 1;
|
||||
NumberOfPdpEntriesNeeded = 1 << (PhysicalAddressBits - 30);
|
||||
} else {
|
||||
NumberOfPml4EntriesNeeded = 1 << (PhysicalAddressBits - 39);
|
||||
NumberOfPdpEntriesNeeded = 512;
|
||||
}
|
||||
|
||||
//
|
||||
// Pre-allocate big pages to avoid later allocations.
|
||||
//
|
||||
TotalPagesNum = (NumberOfPdpEntriesNeeded + 1) * NumberOfPml4EntriesNeeded + 1;
|
||||
BigPageAddress = (UINTN) AllocatePages (TotalPagesNum);
|
||||
ASSERT (BigPageAddress != 0);
|
||||
|
||||
//
|
||||
// By architecture only one PageMapLevel4 exists - so lets allocate storage for it.
|
||||
//
|
||||
PageMap = (VOID *) BigPageAddress;
|
||||
BigPageAddress += EFI_PAGE_SIZE;
|
||||
|
||||
PageMapLevel4Entry = PageMap;
|
||||
PageAddress = 0;
|
||||
for (IndexOfPml4Entries = 0; IndexOfPml4Entries < NumberOfPml4EntriesNeeded; IndexOfPml4Entries++, PageMapLevel4Entry++) {
|
||||
//
|
||||
// Each PML4 entry points to a page of Page Directory Pointer entires.
|
||||
// So lets allocate space for them and fill them in in the IndexOfPdpEntries loop.
|
||||
//
|
||||
PageDirectoryPointerEntry = (VOID *) BigPageAddress;
|
||||
BigPageAddress += EFI_PAGE_SIZE;
|
||||
|
||||
//
|
||||
// Make a PML4 Entry
|
||||
//
|
||||
PageMapLevel4Entry->Uint64 = (UINT64)(UINTN)PageDirectoryPointerEntry;
|
||||
PageMapLevel4Entry->Bits.ReadWrite = 1;
|
||||
PageMapLevel4Entry->Bits.Present = 1;
|
||||
|
||||
for (IndexOfPdpEntries = 0; IndexOfPdpEntries < NumberOfPdpEntriesNeeded; IndexOfPdpEntries++, PageDirectoryPointerEntry++) {
|
||||
//
|
||||
// Each Directory Pointer entries points to a page of Page Directory entires.
|
||||
// So allocate space for them and fill them in in the IndexOfPageDirectoryEntries loop.
|
||||
//
|
||||
PageDirectoryEntry = (VOID *) BigPageAddress;
|
||||
BigPageAddress += EFI_PAGE_SIZE;
|
||||
|
||||
//
|
||||
// Fill in a Page Directory Pointer Entries
|
||||
//
|
||||
PageDirectoryPointerEntry->Uint64 = (UINT64)(UINTN)PageDirectoryEntry;
|
||||
PageDirectoryPointerEntry->Bits.ReadWrite = 1;
|
||||
PageDirectoryPointerEntry->Bits.Present = 1;
|
||||
|
||||
for (IndexOfPageDirectoryEntries = 0; IndexOfPageDirectoryEntries < 512; IndexOfPageDirectoryEntries++, PageDirectoryEntry++, PageAddress += 0x200000) {
|
||||
//
|
||||
// Fill in the Page Directory entries
|
||||
//
|
||||
PageDirectoryEntry->Uint64 = (UINT64)PageAddress;
|
||||
PageDirectoryEntry->Bits.ReadWrite = 1;
|
||||
PageDirectoryEntry->Bits.Present = 1;
|
||||
PageDirectoryEntry->Bits.MustBe1 = 1;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// For the PML4 entries we are not using fill in a null entry.
|
||||
// For now we just copy the first entry.
|
||||
//
|
||||
for (; IndexOfPml4Entries < 512; IndexOfPml4Entries++, PageMapLevel4Entry++) {
|
||||
CopyMem (
|
||||
PageMapLevel4Entry,
|
||||
PageMap,
|
||||
sizeof (PAGE_MAP_AND_DIRECTORY_POINTER)
|
||||
);
|
||||
}
|
||||
|
||||
return (UINTN)PageMap; // FIXME
|
||||
}
|
||||
|
112
MdeModulePkg/Core/DxeIplPeim/Ia32/VirtualMemory.h
Normal file
112
MdeModulePkg/Core/DxeIplPeim/Ia32/VirtualMemory.h
Normal file
@@ -0,0 +1,112 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
VirtualMemory.h
|
||||
|
||||
Abstract:
|
||||
|
||||
x64 Long Mode Virtual Memory Management Definitions
|
||||
|
||||
References:
|
||||
1) IA-32 Intel(R) Atchitecture Software Developer's Manual Volume 1:Basic Architecture, Intel
|
||||
2) IA-32 Intel(R) Atchitecture Software Developer's Manual Volume 2:Instruction Set Reference, Intel
|
||||
3) IA-32 Intel(R) Atchitecture Software Developer's Manual Volume 3:System Programmer's Guide, Intel
|
||||
4) AMD64 Architecture Programmer's Manual Volume 2: System Programming
|
||||
--*/
|
||||
#ifndef _VIRTUAL_MEMORY_H_
|
||||
#define _VIRTUAL_MEMORY_H_
|
||||
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#define SYS_CODE64_SEL 0x38
|
||||
|
||||
#pragma pack(1)
|
||||
|
||||
typedef union {
|
||||
struct {
|
||||
UINT32 LimitLow : 16;
|
||||
UINT32 BaseLow : 16;
|
||||
UINT32 BaseMid : 8;
|
||||
UINT32 Type : 4;
|
||||
UINT32 System : 1;
|
||||
UINT32 Dpl : 2;
|
||||
UINT32 Present : 1;
|
||||
UINT32 LimitHigh : 4;
|
||||
UINT32 Software : 1;
|
||||
UINT32 Reserved : 1;
|
||||
UINT32 DefaultSize : 1;
|
||||
UINT32 Granularity : 1;
|
||||
UINT32 BaseHigh : 8;
|
||||
} Bits;
|
||||
UINT64 Uint64;
|
||||
} IA32_GDT;
|
||||
|
||||
//
|
||||
// Page-Map Level-4 Offset (PML4) and
|
||||
// Page-Directory-Pointer Offset (PDPE) entries 4K & 2MB
|
||||
//
|
||||
|
||||
typedef union {
|
||||
struct {
|
||||
UINT64 Present:1; // 0 = Not present in memory, 1 = Present in memory
|
||||
UINT64 ReadWrite:1; // 0 = Read-Only, 1= Read/Write
|
||||
UINT64 UserSupervisor:1; // 0 = Supervisor, 1=User
|
||||
UINT64 WriteThrough:1; // 0 = Write-Back caching, 1=Write-Through caching
|
||||
UINT64 CacheDisabled:1; // 0 = Cached, 1=Non-Cached
|
||||
UINT64 Accessed:1; // 0 = Not accessed, 1 = Accessed (set by CPU)
|
||||
UINT64 Reserved:1; // Reserved
|
||||
UINT64 MustBeZero:2; // Must Be Zero
|
||||
UINT64 Available:3; // Available for use by system software
|
||||
UINT64 PageTableBaseAddress:40; // Page Table Base Address
|
||||
UINT64 AvabilableHigh:11; // Available for use by system software
|
||||
UINT64 Nx:1; // No Execute bit
|
||||
} Bits;
|
||||
UINT64 Uint64;
|
||||
} PAGE_MAP_AND_DIRECTORY_POINTER;
|
||||
|
||||
//
|
||||
// Page Table Entry 2MB
|
||||
//
|
||||
typedef union {
|
||||
struct {
|
||||
UINT64 Present:1; // 0 = Not present in memory, 1 = Present in memory
|
||||
UINT64 ReadWrite:1; // 0 = Read-Only, 1= Read/Write
|
||||
UINT64 UserSupervisor:1; // 0 = Supervisor, 1=User
|
||||
UINT64 WriteThrough:1; // 0 = Write-Back caching, 1=Write-Through caching
|
||||
UINT64 CacheDisabled:1; // 0 = Cached, 1=Non-Cached
|
||||
UINT64 Accessed:1; // 0 = Not accessed, 1 = Accessed (set by CPU)
|
||||
UINT64 Dirty:1; // 0 = Not Dirty, 1 = written by processor on access to page
|
||||
UINT64 MustBe1:1; // Must be 1
|
||||
UINT64 Global:1; // 0 = Not global page, 1 = global page TLB not cleared on CR3 write
|
||||
UINT64 Available:3; // Available for use by system software
|
||||
UINT64 PAT:1; //
|
||||
UINT64 MustBeZero:8; // Must be zero;
|
||||
UINT64 PageTableBaseAddress:31; // Page Table Base Address
|
||||
UINT64 AvabilableHigh:11; // Available for use by system software
|
||||
UINT64 Nx:1; // 0 = Execute Code, 1 = No Code Execution
|
||||
} Bits;
|
||||
UINT64 Uint64;
|
||||
} PAGE_TABLE_ENTRY;
|
||||
|
||||
#pragma pack()
|
||||
|
||||
UINTN
|
||||
CreateIdentityMappingPageTables (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
#endif
|
77
MdeModulePkg/Core/DxeIplPeim/Ipf/DxeLoadFunc.c
Normal file
77
MdeModulePkg/Core/DxeIplPeim/Ipf/DxeLoadFunc.c
Normal file
@@ -0,0 +1,77 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
|
||||
IpfDxeLoad.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Ipf-specifc functionality for DxeLoad.
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#include "DxeIpl.h"
|
||||
|
||||
VOID
|
||||
HandOffToDxeCore (
|
||||
IN EFI_PHYSICAL_ADDRESS DxeCoreEntryPoint,
|
||||
IN EFI_PEI_HOB_POINTERS HobList,
|
||||
IN EFI_PEI_PPI_DESCRIPTOR *EndOfPeiSignal
|
||||
)
|
||||
{
|
||||
VOID *BaseOfStack;
|
||||
VOID *TopOfStack;
|
||||
VOID *BspStore;
|
||||
EFI_STATUS Status;
|
||||
|
||||
//
|
||||
// Allocate 128KB for the Stack
|
||||
//
|
||||
BaseOfStack = AllocatePages (EFI_SIZE_TO_PAGES (STACK_SIZE));
|
||||
ASSERT (BaseOfStack != NULL);
|
||||
|
||||
//
|
||||
// Allocate 16KB for the BspStore
|
||||
//
|
||||
BspStore = AllocatePages (EFI_SIZE_TO_PAGES (BSP_STORE_SIZE));
|
||||
ASSERT (BspStore != NULL);
|
||||
//
|
||||
// Build BspStoreHob
|
||||
//
|
||||
BuildBspStoreHob ((EFI_PHYSICAL_ADDRESS) (UINTN) BspStore, BSP_STORE_SIZE, EfiBootServicesData);
|
||||
|
||||
//
|
||||
// Compute the top of the stack we were allocated. Pre-allocate a UINTN
|
||||
// for safety.
|
||||
//
|
||||
TopOfStack = (VOID *) ((UINTN) BaseOfStack + EFI_SIZE_TO_PAGES (STACK_SIZE) * EFI_PAGE_SIZE - CPU_STACK_ALIGNMENT);
|
||||
TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
|
||||
|
||||
//
|
||||
// End of PEI phase singal
|
||||
//
|
||||
Status = PeiServicesInstallPpi (EndOfPeiSignal);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
SwitchStack (
|
||||
(SWITCH_STACK_ENTRY_POINT)(UINTN)DxeCoreEntryPoint,
|
||||
HobList.Raw,
|
||||
NULL,
|
||||
TopOfStack,
|
||||
BspStore
|
||||
);
|
||||
}
|
77
MdeModulePkg/Core/DxeIplPeim/Ipf/ImageRead.c
Normal file
77
MdeModulePkg/Core/DxeIplPeim/Ipf/ImageRead.c
Normal file
@@ -0,0 +1,77 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
|
||||
ImageRead.c
|
||||
|
||||
Abstract:
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#include "DxeIpl.h"
|
||||
|
||||
EFI_STATUS
|
||||
PeiImageRead (
|
||||
IN VOID *FileHandle,
|
||||
IN UINTN FileOffset,
|
||||
IN OUT UINTN *ReadSize,
|
||||
OUT VOID *Buffer
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
|
||||
|
||||
Arguments:
|
||||
|
||||
FileHandle - The handle to the PE/COFF file
|
||||
|
||||
FileOffset - The offset, in bytes, into the file to read
|
||||
|
||||
ReadSize - The number of bytes to read from the file starting at FileOffset
|
||||
|
||||
Buffer - A pointer to the buffer to read the data into.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *Destination8;
|
||||
CHAR8 *Source8;
|
||||
volatile UINTN Length;
|
||||
|
||||
Destination8 = Buffer;
|
||||
Source8 = (CHAR8 *) ((UINTN) FileHandle + FileOffset);
|
||||
Length = *ReadSize;
|
||||
while (Length--) {
|
||||
*(Destination8++) = *(Source8++);
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetImageReadFunction (
|
||||
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
)
|
||||
{
|
||||
ImageContext->ImageRead = PeiImageRead;
|
||||
return EFI_SUCCESS;
|
||||
}
|
65
MdeModulePkg/Core/DxeIplPeim/X64/DxeLoadFunc.c
Normal file
65
MdeModulePkg/Core/DxeIplPeim/X64/DxeLoadFunc.c
Normal file
@@ -0,0 +1,65 @@
|
||||
/*++
|
||||
|
||||
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:
|
||||
|
||||
DxeLoadFunc.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Ia32-specifc functionality for DxeLoad.
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include common header file for this module.
|
||||
//
|
||||
#include "CommonHeader.h"
|
||||
|
||||
#include "DxeIpl.h"
|
||||
|
||||
VOID
|
||||
HandOffToDxeCore (
|
||||
IN EFI_PHYSICAL_ADDRESS DxeCoreEntryPoint,
|
||||
IN EFI_PEI_HOB_POINTERS HobList,
|
||||
IN EFI_PEI_PPI_DESCRIPTOR *EndOfPeiSignal
|
||||
)
|
||||
{
|
||||
VOID *BaseOfStack;
|
||||
VOID *TopOfStack;
|
||||
EFI_STATUS Status;
|
||||
|
||||
//
|
||||
// Allocate 128KB for the Stack
|
||||
//
|
||||
BaseOfStack = AllocatePages (EFI_SIZE_TO_PAGES (STACK_SIZE));
|
||||
ASSERT (BaseOfStack != NULL);
|
||||
|
||||
//
|
||||
// Compute the top of the stack we were allocated. Pre-allocate a UINTN
|
||||
// for safety.
|
||||
//
|
||||
TopOfStack = (VOID *) ((UINTN) BaseOfStack + EFI_SIZE_TO_PAGES (STACK_SIZE) * EFI_PAGE_SIZE - CPU_STACK_ALIGNMENT);
|
||||
TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
|
||||
|
||||
//
|
||||
// End of PEI phase singal
|
||||
//
|
||||
Status = PeiServicesInstallPpi (EndOfPeiSignal);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
SwitchStack (
|
||||
(SWITCH_STACK_ENTRY_POINT)(UINTN)DxeCoreEntryPoint,
|
||||
HobList.Raw,
|
||||
NULL,
|
||||
TopOfStack
|
||||
);
|
||||
}
|
Reference in New Issue
Block a user