/** @file | |
The internal header file includes the common header files, defines | |
internal structure and functions used by DxeCore module. | |
Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR> | |
This program and the accompanying materials | |
are licensed and made available under the terms and conditions of the BSD License | |
which accompanies this distribution. The full text of the license may be found at | |
http://opensource.org/licenses/bsd-license.php | |
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
**/ | |
#ifndef _DXE_MAIN_H_ | |
#define _DXE_MAIN_H_ | |
#include <PiDxe.h> | |
#include <Protocol/LoadedImage.h> | |
#include <Protocol/GuidedSectionExtraction.h> | |
#include <Protocol/DevicePath.h> | |
#include <Protocol/Runtime.h> | |
#include <Protocol/LoadFile.h> | |
#include <Protocol/LoadFile2.h> | |
#include <Protocol/DriverBinding.h> | |
#include <Protocol/VariableWrite.h> | |
#include <Protocol/PlatformDriverOverride.h> | |
#include <Protocol/Variable.h> | |
#include <Protocol/Timer.h> | |
#include <Protocol/SimpleFileSystem.h> | |
#include <Protocol/Bds.h> | |
#include <Protocol/RealTimeClock.h> | |
#include <Protocol/WatchdogTimer.h> | |
#include <Protocol/FirmwareVolume2.h> | |
#include <Protocol/MonotonicCounter.h> | |
#include <Protocol/StatusCode.h> | |
#include <Protocol/Decompress.h> | |
#include <Protocol/LoadPe32Image.h> | |
#include <Protocol/Security.h> | |
#include <Protocol/Security2.h> | |
#include <Protocol/Ebc.h> | |
#include <Protocol/Reset.h> | |
#include <Protocol/Cpu.h> | |
#include <Protocol/Metronome.h> | |
#include <Protocol/FirmwareVolumeBlock.h> | |
#include <Protocol/Capsule.h> | |
#include <Protocol/BusSpecificDriverOverride.h> | |
#include <Protocol/DriverFamilyOverride.h> | |
#include <Protocol/TcgService.h> | |
#include <Protocol/HiiPackageList.h> | |
#include <Protocol/SmmBase2.h> | |
#include <Guid/MemoryTypeInformation.h> | |
#include <Guid/FirmwareFileSystem2.h> | |
#include <Guid/FirmwareFileSystem3.h> | |
#include <Guid/HobList.h> | |
#include <Guid/DebugImageInfoTable.h> | |
#include <Guid/FileInfo.h> | |
#include <Guid/Apriori.h> | |
#include <Guid/DxeServices.h> | |
#include <Guid/MemoryAllocationHob.h> | |
#include <Guid/EventLegacyBios.h> | |
#include <Guid/EventGroup.h> | |
#include <Guid/EventExitBootServiceFailed.h> | |
#include <Guid/LoadModuleAtFixedAddress.h> | |
#include <Guid/IdleLoopEvent.h> | |
#include <Guid/VectorHandoffTable.h> | |
#include <Ppi/VectorHandoffInfo.h> | |
#include <Guid/ZeroGuid.h> | |
#include <Guid/MemoryProfile.h> | |
#include <Library/DxeCoreEntryPoint.h> | |
#include <Library/DebugLib.h> | |
#include <Library/UefiLib.h> | |
#include <Library/BaseLib.h> | |
#include <Library/HobLib.h> | |
#include <Library/PerformanceLib.h> | |
#include <Library/UefiDecompressLib.h> | |
#include <Library/ExtractGuidedSectionLib.h> | |
#include <Library/CacheMaintenanceLib.h> | |
#include <Library/BaseMemoryLib.h> | |
#include <Library/PeCoffLib.h> | |
#include <Library/PeCoffGetEntryPointLib.h> | |
#include <Library/PeCoffExtraActionLib.h> | |
#include <Library/PcdLib.h> | |
#include <Library/MemoryAllocationLib.h> | |
#include <Library/DevicePathLib.h> | |
#include <Library/UefiBootServicesTableLib.h> | |
#include <Library/ReportStatusCodeLib.h> | |
#include <Library/TimerLib.h> | |
#include <Library/DxeServicesLib.h> | |
#include <Library/DebugAgentLib.h> | |
#include <Library/CpuExceptionHandlerLib.h> | |
// | |
// 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 | |
// | |
// range for memory mapped port I/O on IPF | |
// | |
#define EFI_MEMORY_PORT_IO 0x4000000000000000ULL | |
/// | |
/// EFI_DEP_REPLACE_TRUE - Used to dynamically patch the dependecy expression | |
/// to save time. A EFI_DEP_PUSH is evauated one an | |
/// replaced with EFI_DEP_REPLACE_TRUE. If PI spec's Vol 2 | |
/// Driver Execution Environment Core Interface use 0xff | |
/// as new DEPEX opcode. EFI_DEP_REPLACE_TRUE should be | |
/// defined to a new value that is not conflicting with PI spec. | |
/// | |
#define EFI_DEP_REPLACE_TRUE 0xff | |
/// | |
/// Define the initial size of the dependency expression evaluation stack | |
/// | |
#define DEPEX_STACK_SIZE_INCREMENT 0x1000 | |
#if defined (MDE_CPU_IPF) | |
/// | |
/// For Itanium machines make the default allocations 8K aligned | |
/// | |
#define EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT (EFI_PAGE_SIZE * 2) | |
#define DEFAULT_PAGE_ALLOCATION (EFI_PAGE_SIZE * 2) | |
#elif defined (MDE_CPU_AARCH64) | |
/// | |
/// 64-bit ARM systems allow the OS to execute with 64 KB page size, | |
/// so for improved interoperability with the firmware, align the | |
/// runtime regions to 64 KB as well | |
/// | |
#define EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT (SIZE_64KB) | |
#define DEFAULT_PAGE_ALLOCATION (EFI_PAGE_SIZE) | |
#else | |
/// | |
/// For genric EFI machines make the default allocations 4K aligned | |
/// | |
#define EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT (EFI_PAGE_SIZE) | |
#define DEFAULT_PAGE_ALLOCATION (EFI_PAGE_SIZE) | |
#endif | |
typedef struct { | |
EFI_GUID *ProtocolGuid; | |
VOID **Protocol; | |
EFI_EVENT Event; | |
VOID *Registration; | |
BOOLEAN Present; | |
} EFI_CORE_PROTOCOL_NOTIFY_ENTRY; | |
// | |
// DXE Dispatcher Data structures | |
// | |
#define KNOWN_HANDLE_SIGNATURE SIGNATURE_32('k','n','o','w') | |
typedef struct { | |
UINTN Signature; | |
LIST_ENTRY Link; // mFvHandleList | |
EFI_HANDLE Handle; | |
EFI_GUID FvNameGuid; | |
} KNOWN_HANDLE; | |
#define EFI_CORE_DRIVER_ENTRY_SIGNATURE SIGNATURE_32('d','r','v','r') | |
typedef struct { | |
UINTN Signature; | |
LIST_ENTRY Link; // mDriverList | |
LIST_ENTRY ScheduledLink; // mScheduledQueue | |
EFI_HANDLE FvHandle; | |
EFI_GUID FileName; | |
EFI_DEVICE_PATH_PROTOCOL *FvFileDevicePath; | |
EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv; | |
VOID *Depex; | |
UINTN DepexSize; | |
BOOLEAN Before; | |
BOOLEAN After; | |
EFI_GUID BeforeAfterGuid; | |
BOOLEAN Dependent; | |
BOOLEAN Unrequested; | |
BOOLEAN Scheduled; | |
BOOLEAN Untrusted; | |
BOOLEAN Initialized; | |
BOOLEAN DepexProtocolError; | |
EFI_HANDLE ImageHandle; | |
BOOLEAN IsFvImage; | |
} EFI_CORE_DRIVER_ENTRY; | |
// | |
//The data structure of GCD memory map entry | |
// | |
#define EFI_GCD_MAP_SIGNATURE SIGNATURE_32('g','c','d','m') | |
typedef struct { | |
UINTN Signature; | |
LIST_ENTRY Link; | |
EFI_PHYSICAL_ADDRESS BaseAddress; | |
UINT64 EndAddress; | |
UINT64 Capabilities; | |
UINT64 Attributes; | |
EFI_GCD_MEMORY_TYPE GcdMemoryType; | |
EFI_GCD_IO_TYPE GcdIoType; | |
EFI_HANDLE ImageHandle; | |
EFI_HANDLE DeviceHandle; | |
} EFI_GCD_MAP_ENTRY; | |
#define LOADED_IMAGE_PRIVATE_DATA_SIGNATURE SIGNATURE_32('l','d','r','i') | |
typedef struct { | |
UINTN Signature; | |
/// Image handle | |
EFI_HANDLE Handle; | |
/// Image type | |
UINTN Type; | |
/// If entrypoint has been called | |
BOOLEAN Started; | |
/// The image's entry point | |
EFI_IMAGE_ENTRY_POINT EntryPoint; | |
/// loaded image protocol | |
EFI_LOADED_IMAGE_PROTOCOL Info; | |
/// Location in memory | |
EFI_PHYSICAL_ADDRESS ImageBasePage; | |
/// Number of pages | |
UINTN NumberOfPages; | |
/// Original fixup data | |
CHAR8 *FixupData; | |
/// Tpl of started image | |
EFI_TPL Tpl; | |
/// Status returned by started image | |
EFI_STATUS Status; | |
/// Size of ExitData from started image | |
UINTN ExitDataSize; | |
/// Pointer to exit data from started image | |
VOID *ExitData; | |
/// Pointer to pool allocation for context save/retore | |
VOID *JumpBuffer; | |
/// Pointer to buffer for context save/retore | |
BASE_LIBRARY_JUMP_BUFFER *JumpContext; | |
/// Machine type from PE image | |
UINT16 Machine; | |
/// EBC Protocol pointer | |
EFI_EBC_PROTOCOL *Ebc; | |
/// Runtime image list | |
EFI_RUNTIME_IMAGE_ENTRY *RuntimeData; | |
/// Pointer to Loaded Image Device Path Protocl | |
EFI_DEVICE_PATH_PROTOCOL *LoadedImageDevicePath; | |
/// PeCoffLoader ImageContext | |
PE_COFF_LOADER_IMAGE_CONTEXT ImageContext; | |
/// Status returned by LoadImage() service. | |
EFI_STATUS LoadImageStatus; | |
} LOADED_IMAGE_PRIVATE_DATA; | |
#define LOADED_IMAGE_PRIVATE_DATA_FROM_THIS(a) \ | |
CR(a, LOADED_IMAGE_PRIVATE_DATA, Info, LOADED_IMAGE_PRIVATE_DATA_SIGNATURE) | |
// | |
// DXE Core Global Variables | |
// | |
extern EFI_SYSTEM_TABLE *gDxeCoreST; | |
extern EFI_RUNTIME_SERVICES *gDxeCoreRT; | |
extern EFI_DXE_SERVICES *gDxeCoreDS; | |
extern EFI_HANDLE gDxeCoreImageHandle; | |
extern BOOLEAN gMemoryMapTerminated; | |
extern EFI_DECOMPRESS_PROTOCOL gEfiDecompress; | |
extern EFI_RUNTIME_ARCH_PROTOCOL *gRuntime; | |
extern EFI_CPU_ARCH_PROTOCOL *gCpu; | |
extern EFI_WATCHDOG_TIMER_ARCH_PROTOCOL *gWatchdogTimer; | |
extern EFI_METRONOME_ARCH_PROTOCOL *gMetronome; | |
extern EFI_TIMER_ARCH_PROTOCOL *gTimer; | |
extern EFI_SECURITY_ARCH_PROTOCOL *gSecurity; | |
extern EFI_SECURITY2_ARCH_PROTOCOL *gSecurity2; | |
extern EFI_BDS_ARCH_PROTOCOL *gBds; | |
extern EFI_SMM_BASE2_PROTOCOL *gSmmBase2; | |
extern EFI_TPL gEfiCurrentTpl; | |
extern EFI_GUID *gDxeCoreFileName; | |
extern EFI_LOADED_IMAGE_PROTOCOL *gDxeCoreLoadedImage; | |
extern EFI_MEMORY_TYPE_INFORMATION gMemoryTypeInformation[EfiMaxMemoryType + 1]; | |
extern BOOLEAN gDispatcherRunning; | |
extern EFI_RUNTIME_ARCH_PROTOCOL gRuntimeTemplate; | |
extern EFI_LOAD_FIXED_ADDRESS_CONFIGURATION_TABLE gLoadModuleAtFixAddressConfigurationTable; | |
extern BOOLEAN gLoadFixedAddressCodeMemoryReady; | |
// | |
// Service Initialization Functions | |
// | |
/** | |
Called to initialize the pool. | |
**/ | |
VOID | |
CoreInitializePool ( | |
VOID | |
); | |
/** | |
Called to initialize the memory map and add descriptors to | |
the current descriptor list. | |
The first descriptor that is added must be general usable | |
memory as the addition allocates heap. | |
@param Type The type of memory to add | |
@param Start The starting address in the memory range Must be | |
page aligned | |
@param NumberOfPages The number of pages in the range | |
@param Attribute Attributes of the memory to add | |
@return None. The range is added to the memory map | |
**/ | |
VOID | |
CoreAddMemoryDescriptor ( | |
IN EFI_MEMORY_TYPE Type, | |
IN EFI_PHYSICAL_ADDRESS Start, | |
IN UINT64 NumberOfPages, | |
IN UINT64 Attribute | |
); | |
/** | |
Release memory lock on mGcdMemorySpaceLock. | |
**/ | |
VOID | |
CoreReleaseGcdMemoryLock ( | |
VOID | |
); | |
/** | |
Acquire memory lock on mGcdMemorySpaceLock. | |
**/ | |
VOID | |
CoreAcquireGcdMemoryLock ( | |
VOID | |
); | |
/** | |
External function. Initializes memory services based on the memory | |
descriptor HOBs. This function is responsible for priming the memory | |
map, so memory allocations and resource allocations can be made. | |
The first part of this function can not depend on any memory services | |
until at least one memory descriptor is provided to the memory services. | |
@param HobStart The start address of the HOB. | |
@param MemoryBaseAddress Start address of memory region found to init DXE | |
core. | |
@param MemoryLength Length of memory region found to init DXE core. | |
@retval EFI_SUCCESS Memory services successfully initialized. | |
**/ | |
EFI_STATUS | |
CoreInitializeMemoryServices ( | |
IN VOID **HobStart, | |
OUT EFI_PHYSICAL_ADDRESS *MemoryBaseAddress, | |
OUT UINT64 *MemoryLength | |
); | |
/** | |
External function. Initializes the GCD and memory services based on the memory | |
descriptor HOBs. This function is responsible for priming the GCD map and the | |
memory map, so memory allocations and resource allocations can be made. The | |
HobStart will be relocated to a pool buffer. | |
@param HobStart The start address of the HOB | |
@param MemoryBaseAddress Start address of memory region found to init DXE | |
core. | |
@param MemoryLength Length of memory region found to init DXE core. | |
@retval EFI_SUCCESS GCD services successfully initialized. | |
**/ | |
EFI_STATUS | |
CoreInitializeGcdServices ( | |
IN OUT VOID **HobStart, | |
IN EFI_PHYSICAL_ADDRESS MemoryBaseAddress, | |
IN UINT64 MemoryLength | |
); | |
/** | |
Initializes "event" support. | |
@retval EFI_SUCCESS Always return success | |
**/ | |
EFI_STATUS | |
CoreInitializeEventServices ( | |
VOID | |
); | |
/** | |
Add the Image Services to EFI Boot Services Table and install the protocol | |
interfaces for this image. | |
@param HobStart The HOB to initialize | |
@return Status code. | |
**/ | |
EFI_STATUS | |
CoreInitializeImageServices ( | |
IN VOID *HobStart | |
); | |
/** | |
Creates an event that is fired everytime a Protocol of a specific type is installed. | |
**/ | |
VOID | |
CoreNotifyOnProtocolInstallation ( | |
VOID | |
); | |
/** | |
Return TRUE if all AP services are availible. | |
@retval EFI_SUCCESS All AP services are available | |
@retval EFI_NOT_FOUND At least one AP service is not available | |
**/ | |
EFI_STATUS | |
CoreAllEfiServicesAvailable ( | |
VOID | |
); | |
/** | |
Calcualte the 32-bit CRC in a EFI table using the service provided by the | |
gRuntime service. | |
@param Hdr Pointer to an EFI standard header | |
**/ | |
VOID | |
CalculateEfiHdrCrc ( | |
IN OUT EFI_TABLE_HEADER *Hdr | |
); | |
/** | |
Called by the platform code to process a tick. | |
@param Duration The number of 100ns elasped since the last call | |
to TimerTick | |
**/ | |
VOID | |
EFIAPI | |
CoreTimerTick ( | |
IN UINT64 Duration | |
); | |
/** | |
Initialize the dispatcher. Initialize the notification function that runs when | |
an FV2 protocol is added to the system. | |
**/ | |
VOID | |
CoreInitializeDispatcher ( | |
VOID | |
); | |
/** | |
This is the POSTFIX version of the dependency evaluator. This code does | |
not need to handle Before or After, as it is not valid to call this | |
routine in this case. The SOR is just ignored and is a nop in the grammer. | |
POSTFIX means all the math is done on top of the stack. | |
@param DriverEntry DriverEntry element to update. | |
@retval TRUE If driver is ready to run. | |
@retval FALSE If driver is not ready to run or some fatal error | |
was found. | |
**/ | |
BOOLEAN | |
CoreIsSchedulable ( | |
IN EFI_CORE_DRIVER_ENTRY *DriverEntry | |
); | |
/** | |
Preprocess dependency expression and update DriverEntry to reflect the | |
state of Before, After, and SOR dependencies. If DriverEntry->Before | |
or DriverEntry->After is set it will never be cleared. If SOR is set | |
it will be cleared by CoreSchedule(), and then the driver can be | |
dispatched. | |
@param DriverEntry DriverEntry element to update . | |
@retval EFI_SUCCESS It always works. | |
**/ | |
EFI_STATUS | |
CorePreProcessDepex ( | |
IN EFI_CORE_DRIVER_ENTRY *DriverEntry | |
); | |
/** | |
Terminates all boot services. | |
@param ImageHandle Handle that identifies the exiting image. | |
@param MapKey Key to the latest memory map. | |
@retval EFI_SUCCESS Boot Services terminated | |
@retval EFI_INVALID_PARAMETER MapKey is incorrect. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreExitBootServices ( | |
IN EFI_HANDLE ImageHandle, | |
IN UINTN MapKey | |
); | |
/** | |
Make sure the memory map is following all the construction rules, | |
it is the last time to check memory map error before exit boot services. | |
@param MapKey Memory map key | |
@retval EFI_INVALID_PARAMETER Memory map not consistent with construction | |
rules. | |
@retval EFI_SUCCESS Valid memory map. | |
**/ | |
EFI_STATUS | |
CoreTerminateMemoryMap ( | |
IN UINTN MapKey | |
); | |
/** | |
Signals all events in the EventGroup. | |
@param EventGroup The list to signal | |
**/ | |
VOID | |
CoreNotifySignalList ( | |
IN EFI_GUID *EventGroup | |
); | |
/** | |
Boot Service called to add, modify, or remove a system configuration table from | |
the EFI System Table. | |
@param Guid Pointer to the GUID for the entry to add, update, or | |
remove | |
@param Table Pointer to the configuration table for the entry to add, | |
update, or remove, may be NULL. | |
@return EFI_SUCCESS Guid, Table pair added, updated, or removed. | |
@return EFI_INVALID_PARAMETER Input GUID not valid. | |
@return EFI_NOT_FOUND Attempted to delete non-existant entry | |
@return EFI_OUT_OF_RESOURCES Not enough memory available | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreInstallConfigurationTable ( | |
IN EFI_GUID *Guid, | |
IN VOID *Table | |
); | |
/** | |
Raise the task priority level to the new level. | |
High level is implemented by disabling processor interrupts. | |
@param NewTpl New task priority level | |
@return The previous task priority level | |
**/ | |
EFI_TPL | |
EFIAPI | |
CoreRaiseTpl ( | |
IN EFI_TPL NewTpl | |
); | |
/** | |
Lowers the task priority to the previous value. If the new | |
priority unmasks events at a higher priority, they are dispatched. | |
@param NewTpl New, lower, task priority | |
**/ | |
VOID | |
EFIAPI | |
CoreRestoreTpl ( | |
IN EFI_TPL NewTpl | |
); | |
/** | |
Introduces a fine-grained stall. | |
@param Microseconds The number of microseconds to stall execution. | |
@retval EFI_SUCCESS Execution was stalled for at least the requested | |
amount of microseconds. | |
@retval EFI_NOT_AVAILABLE_YET gMetronome is not available yet | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreStall ( | |
IN UINTN Microseconds | |
); | |
/** | |
Sets the system's watchdog timer. | |
@param Timeout The number of seconds to set the watchdog timer to. | |
A value of zero disables the timer. | |
@param WatchdogCode The numeric code to log on a watchdog timer timeout | |
event. The firmware reserves codes 0x0000 to 0xFFFF. | |
Loaders and operating systems may use other timeout | |
codes. | |
@param DataSize The size, in bytes, of WatchdogData. | |
@param WatchdogData A data buffer that includes a Null-terminated Unicode | |
string, optionally followed by additional binary data. | |
The string is a description that the call may use to | |
further indicate the reason to be logged with a | |
watchdog event. | |
@return EFI_SUCCESS Timeout has been set | |
@return EFI_NOT_AVAILABLE_YET WatchdogTimer is not available yet | |
@return EFI_UNSUPPORTED System does not have a timer (currently not used) | |
@return EFI_DEVICE_ERROR Could not complete due to hardware error | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreSetWatchdogTimer ( | |
IN UINTN Timeout, | |
IN UINT64 WatchdogCode, | |
IN UINTN DataSize, | |
IN CHAR16 *WatchdogData OPTIONAL | |
); | |
/** | |
Wrapper function to CoreInstallProtocolInterfaceNotify. This is the public API which | |
Calls the private one which contains a BOOLEAN parameter for notifications | |
@param UserHandle The handle to install the protocol handler on, | |
or NULL if a new handle is to be allocated | |
@param Protocol The protocol to add to the handle | |
@param InterfaceType Indicates whether Interface is supplied in | |
native form. | |
@param Interface The interface for the protocol being added | |
@return Status code | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreInstallProtocolInterface ( | |
IN OUT EFI_HANDLE *UserHandle, | |
IN EFI_GUID *Protocol, | |
IN EFI_INTERFACE_TYPE InterfaceType, | |
IN VOID *Interface | |
); | |
/** | |
Installs a protocol interface into the boot services environment. | |
@param UserHandle The handle to install the protocol handler on, | |
or NULL if a new handle is to be allocated | |
@param Protocol The protocol to add to the handle | |
@param InterfaceType Indicates whether Interface is supplied in | |
native form. | |
@param Interface The interface for the protocol being added | |
@param Notify indicates whether notify the notification list | |
for this protocol | |
@retval EFI_INVALID_PARAMETER Invalid parameter | |
@retval EFI_OUT_OF_RESOURCES No enough buffer to allocate | |
@retval EFI_SUCCESS Protocol interface successfully installed | |
**/ | |
EFI_STATUS | |
CoreInstallProtocolInterfaceNotify ( | |
IN OUT EFI_HANDLE *UserHandle, | |
IN EFI_GUID *Protocol, | |
IN EFI_INTERFACE_TYPE InterfaceType, | |
IN VOID *Interface, | |
IN BOOLEAN Notify | |
); | |
/** | |
Installs a list of protocol interface into the boot services environment. | |
This function calls InstallProtocolInterface() in a loop. If any error | |
occures all the protocols added by this function are removed. This is | |
basically a lib function to save space. | |
@param Handle The handle to install the protocol handlers on, | |
or NULL if a new handle is to be allocated | |
@param ... EFI_GUID followed by protocol instance. A NULL | |
terminates the list. The pairs are the | |
arguments to InstallProtocolInterface(). All the | |
protocols are added to Handle. | |
@retval EFI_SUCCESS All the protocol interface was installed. | |
@retval EFI_OUT_OF_RESOURCES There was not enough memory in pool to install all the protocols. | |
@retval EFI_ALREADY_STARTED A Device Path Protocol instance was passed in that is already present in | |
the handle database. | |
@retval EFI_INVALID_PARAMETER Handle is NULL. | |
@retval EFI_INVALID_PARAMETER Protocol is already installed on the handle specified by Handle. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreInstallMultipleProtocolInterfaces ( | |
IN OUT EFI_HANDLE *Handle, | |
... | |
); | |
/** | |
Uninstalls a list of protocol interface in the boot services environment. | |
This function calls UnisatllProtocolInterface() in a loop. This is | |
basically a lib function to save space. | |
@param Handle The handle to uninstall the protocol | |
@param ... EFI_GUID followed by protocol instance. A NULL | |
terminates the list. The pairs are the | |
arguments to UninstallProtocolInterface(). All | |
the protocols are added to Handle. | |
@return Status code | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreUninstallMultipleProtocolInterfaces ( | |
IN EFI_HANDLE Handle, | |
... | |
); | |
/** | |
Reinstall a protocol interface on a device handle. The OldInterface for Protocol is replaced by the NewInterface. | |
@param UserHandle Handle on which the interface is to be | |
reinstalled | |
@param Protocol The numeric ID of the interface | |
@param OldInterface A pointer to the old interface | |
@param NewInterface A pointer to the new interface | |
@retval EFI_SUCCESS The protocol interface was installed | |
@retval EFI_NOT_FOUND The OldInterface on the handle was not found | |
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreReinstallProtocolInterface ( | |
IN EFI_HANDLE UserHandle, | |
IN EFI_GUID *Protocol, | |
IN VOID *OldInterface, | |
IN VOID *NewInterface | |
); | |
/** | |
Uninstalls all instances of a protocol:interfacer from a handle. | |
If the last protocol interface is remove from the handle, the | |
handle is freed. | |
@param UserHandle The handle to remove the protocol handler from | |
@param Protocol The protocol, of protocol:interface, to remove | |
@param Interface The interface, of protocol:interface, to remove | |
@retval EFI_INVALID_PARAMETER Protocol is NULL. | |
@retval EFI_SUCCESS Protocol interface successfully uninstalled. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreUninstallProtocolInterface ( | |
IN EFI_HANDLE UserHandle, | |
IN EFI_GUID *Protocol, | |
IN VOID *Interface | |
); | |
/** | |
Queries a handle to determine if it supports a specified protocol. | |
@param UserHandle The handle being queried. | |
@param Protocol The published unique identifier of the protocol. | |
@param Interface Supplies the address where a pointer to the | |
corresponding Protocol Interface is returned. | |
@return The requested protocol interface for the handle | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreHandleProtocol ( | |
IN EFI_HANDLE UserHandle, | |
IN EFI_GUID *Protocol, | |
OUT VOID **Interface | |
); | |
/** | |
Locates the installed protocol handler for the handle, and | |
invokes it to obtain the protocol interface. Usage information | |
is registered in the protocol data base. | |
@param UserHandle The handle to obtain the protocol interface on | |
@param Protocol The ID of the protocol | |
@param Interface The location to return the protocol interface | |
@param ImageHandle The handle of the Image that is opening the | |
protocol interface specified by Protocol and | |
Interface. | |
@param ControllerHandle The controller handle that is requiring this | |
interface. | |
@param Attributes The open mode of the protocol interface | |
specified by Handle and Protocol. | |
@retval EFI_INVALID_PARAMETER Protocol is NULL. | |
@retval EFI_SUCCESS Get the protocol interface. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreOpenProtocol ( | |
IN EFI_HANDLE UserHandle, | |
IN EFI_GUID *Protocol, | |
OUT VOID **Interface OPTIONAL, | |
IN EFI_HANDLE ImageHandle, | |
IN EFI_HANDLE ControllerHandle, | |
IN UINT32 Attributes | |
); | |
/** | |
Return information about Opened protocols in the system | |
@param UserHandle The handle to close the protocol interface on | |
@param Protocol The ID of the protocol | |
@param EntryBuffer A pointer to a buffer of open protocol | |
information in the form of | |
EFI_OPEN_PROTOCOL_INFORMATION_ENTRY structures. | |
@param EntryCount Number of EntryBuffer entries | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreOpenProtocolInformation ( | |
IN EFI_HANDLE UserHandle, | |
IN EFI_GUID *Protocol, | |
OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer, | |
OUT UINTN *EntryCount | |
); | |
/** | |
Closes a protocol on a handle that was opened using OpenProtocol(). | |
@param UserHandle The handle for the protocol interface that was | |
previously opened with OpenProtocol(), and is | |
now being closed. | |
@param Protocol The published unique identifier of the protocol. | |
It is the caller's responsibility to pass in a | |
valid GUID. | |
@param AgentHandle The handle of the agent that is closing the | |
protocol interface. | |
@param ControllerHandle If the agent that opened a protocol is a driver | |
that follows the EFI Driver Model, then this | |
parameter is the controller handle that required | |
the protocol interface. If the agent does not | |
follow the EFI Driver Model, then this parameter | |
is optional and may be NULL. | |
@retval EFI_SUCCESS The protocol instance was closed. | |
@retval EFI_INVALID_PARAMETER Handle, AgentHandle or ControllerHandle is not a | |
valid EFI_HANDLE. | |
@retval EFI_NOT_FOUND Can not find the specified protocol or | |
AgentHandle. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreCloseProtocol ( | |
IN EFI_HANDLE UserHandle, | |
IN EFI_GUID *Protocol, | |
IN EFI_HANDLE AgentHandle, | |
IN EFI_HANDLE ControllerHandle | |
); | |
/** | |
Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated | |
from pool. | |
@param UserHandle The handle from which to retrieve the list of | |
protocol interface GUIDs. | |
@param ProtocolBuffer A pointer to the list of protocol interface GUID | |
pointers that are installed on Handle. | |
@param ProtocolBufferCount A pointer to the number of GUID pointers present | |
in ProtocolBuffer. | |
@retval EFI_SUCCESS The list of protocol interface GUIDs installed | |
on Handle was returned in ProtocolBuffer. The | |
number of protocol interface GUIDs was returned | |
in ProtocolBufferCount. | |
@retval EFI_INVALID_PARAMETER Handle is NULL. | |
@retval EFI_INVALID_PARAMETER Handle is not a valid EFI_HANDLE. | |
@retval EFI_INVALID_PARAMETER ProtocolBuffer is NULL. | |
@retval EFI_INVALID_PARAMETER ProtocolBufferCount is NULL. | |
@retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the | |
results. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreProtocolsPerHandle ( | |
IN EFI_HANDLE UserHandle, | |
OUT EFI_GUID ***ProtocolBuffer, | |
OUT UINTN *ProtocolBufferCount | |
); | |
/** | |
Add a new protocol notification record for the request protocol. | |
@param Protocol The requested protocol to add the notify | |
registration | |
@param Event The event to signal | |
@param Registration Returns the registration record | |
@retval EFI_INVALID_PARAMETER Invalid parameter | |
@retval EFI_SUCCESS Successfully returned the registration record | |
that has been added | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreRegisterProtocolNotify ( | |
IN EFI_GUID *Protocol, | |
IN EFI_EVENT Event, | |
OUT VOID **Registration | |
); | |
/** | |
Removes all the events in the protocol database that match Event. | |
@param Event The event to search for in the protocol | |
database. | |
@return EFI_SUCCESS when done searching the entire database. | |
**/ | |
EFI_STATUS | |
CoreUnregisterProtocolNotify ( | |
IN EFI_EVENT Event | |
); | |
/** | |
Locates the requested handle(s) and returns them in Buffer. | |
@param SearchType The type of search to perform to locate the | |
handles | |
@param Protocol The protocol to search for | |
@param SearchKey Dependant on SearchType | |
@param BufferSize On input the size of Buffer. On output the | |
size of data returned. | |
@param Buffer The buffer to return the results in | |
@retval EFI_BUFFER_TOO_SMALL Buffer too small, required buffer size is | |
returned in BufferSize. | |
@retval EFI_INVALID_PARAMETER Invalid parameter | |
@retval EFI_SUCCESS Successfully found the requested handle(s) and | |
returns them in Buffer. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreLocateHandle ( | |
IN EFI_LOCATE_SEARCH_TYPE SearchType, | |
IN EFI_GUID *Protocol OPTIONAL, | |
IN VOID *SearchKey OPTIONAL, | |
IN OUT UINTN *BufferSize, | |
OUT EFI_HANDLE *Buffer | |
); | |
/** | |
Locates the handle to a device on the device path that best matches the specified protocol. | |
@param Protocol The protocol to search for. | |
@param DevicePath On input, a pointer to a pointer to the device | |
path. On output, the device path pointer is | |
modified to point to the remaining part of the | |
devicepath. | |
@param Device A pointer to the returned device handle. | |
@retval EFI_SUCCESS The resulting handle was returned. | |
@retval EFI_NOT_FOUND No handles matched the search. | |
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreLocateDevicePath ( | |
IN EFI_GUID *Protocol, | |
IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath, | |
OUT EFI_HANDLE *Device | |
); | |
/** | |
Function returns an array of handles that support the requested protocol | |
in a buffer allocated from pool. This is a version of CoreLocateHandle() | |
that allocates a buffer for the caller. | |
@param SearchType Specifies which handle(s) are to be returned. | |
@param Protocol Provides the protocol to search by. This | |
parameter is only valid for SearchType | |
ByProtocol. | |
@param SearchKey Supplies the search key depending on the | |
SearchType. | |
@param NumberHandles The number of handles returned in Buffer. | |
@param Buffer A pointer to the buffer to return the requested | |
array of handles that support Protocol. | |
@retval EFI_SUCCESS The result array of handles was returned. | |
@retval EFI_NOT_FOUND No handles match the search. | |
@retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the | |
matching results. | |
@retval EFI_INVALID_PARAMETER One or more paramters are not valid. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreLocateHandleBuffer ( | |
IN EFI_LOCATE_SEARCH_TYPE SearchType, | |
IN EFI_GUID *Protocol OPTIONAL, | |
IN VOID *SearchKey OPTIONAL, | |
IN OUT UINTN *NumberHandles, | |
OUT EFI_HANDLE **Buffer | |
); | |
/** | |
Return the first Protocol Interface that matches the Protocol GUID. If | |
Registration is passed in, return a Protocol Instance that was just add | |
to the system. If Registration is NULL return the first Protocol Interface | |
you find. | |
@param Protocol The protocol to search for | |
@param Registration Optional Registration Key returned from | |
RegisterProtocolNotify() | |
@param Interface Return the Protocol interface (instance). | |
@retval EFI_SUCCESS If a valid Interface is returned | |
@retval EFI_INVALID_PARAMETER Invalid parameter | |
@retval EFI_NOT_FOUND Protocol interface not found | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreLocateProtocol ( | |
IN EFI_GUID *Protocol, | |
IN VOID *Registration OPTIONAL, | |
OUT VOID **Interface | |
); | |
/** | |
return handle database key. | |
@return Handle database key. | |
**/ | |
UINT64 | |
CoreGetHandleDatabaseKey ( | |
VOID | |
); | |
/** | |
Go connect any handles that were created or modified while a image executed. | |
@param Key The Key to show that the handle has been | |
created/modified | |
**/ | |
VOID | |
CoreConnectHandlesByKey ( | |
UINT64 Key | |
); | |
/** | |
Connects one or more drivers to a controller. | |
@param ControllerHandle The handle of the controller to which driver(s) are to be connected. | |
@param DriverImageHandle A pointer to an ordered list handles that support the | |
EFI_DRIVER_BINDING_PROTOCOL. | |
@param RemainingDevicePath A pointer to the device path that specifies a child of the | |
controller specified by ControllerHandle. | |
@param Recursive If TRUE, then ConnectController() is called recursively | |
until the entire tree of controllers below the controller specified | |
by ControllerHandle have been created. If FALSE, then | |
the tree of controllers is only expanded one level. | |
@retval EFI_SUCCESS 1) One or more drivers were connected to ControllerHandle. | |
2) No drivers were connected to ControllerHandle, but | |
RemainingDevicePath is not NULL, and it is an End Device | |
Path Node. | |
@retval EFI_INVALID_PARAMETER ControllerHandle is NULL. | |
@retval EFI_NOT_FOUND 1) There are no EFI_DRIVER_BINDING_PROTOCOL instances | |
present in the system. | |
2) No drivers were connected to ControllerHandle. | |
@retval EFI_SECURITY_VIOLATION | |
The user has no permission to start UEFI device drivers on the device path | |
associated with the ControllerHandle or specified by the RemainingDevicePath. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreConnectController ( | |
IN EFI_HANDLE ControllerHandle, | |
IN EFI_HANDLE *DriverImageHandle OPTIONAL, | |
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL, | |
IN BOOLEAN Recursive | |
); | |
/** | |
Disonnects a controller from a driver | |
@param ControllerHandle ControllerHandle The handle of | |
the controller from which | |
driver(s) are to be | |
disconnected. | |
@param DriverImageHandle DriverImageHandle The driver to | |
disconnect from ControllerHandle. | |
@param ChildHandle ChildHandle The handle of the | |
child to destroy. | |
@retval EFI_SUCCESS One or more drivers were | |
disconnected from the controller. | |
@retval EFI_SUCCESS On entry, no drivers are managing | |
ControllerHandle. | |
@retval EFI_SUCCESS DriverImageHandle is not NULL, | |
and on entry DriverImageHandle is | |
not managing ControllerHandle. | |
@retval EFI_INVALID_PARAMETER ControllerHandle is NULL. | |
@retval EFI_INVALID_PARAMETER DriverImageHandle is not NULL, | |
and it is not a valid EFI_HANDLE. | |
@retval EFI_INVALID_PARAMETER ChildHandle is not NULL, and it | |
is not a valid EFI_HANDLE. | |
@retval EFI_OUT_OF_RESOURCES There are not enough resources | |
available to disconnect any | |
drivers from ControllerHandle. | |
@retval EFI_DEVICE_ERROR The controller could not be | |
disconnected because of a device | |
error. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreDisconnectController ( | |
IN EFI_HANDLE ControllerHandle, | |
IN EFI_HANDLE DriverImageHandle OPTIONAL, | |
IN EFI_HANDLE ChildHandle OPTIONAL | |
); | |
/** | |
Allocates pages from the memory map. | |
@param Type The type of allocation to perform | |
@param MemoryType The type of memory to turn the allocated pages | |
into | |
@param NumberOfPages The number of pages to allocate | |
@param Memory A pointer to receive the base allocated memory | |
address | |
@return Status. On success, Memory is filled in with the base address allocated | |
@retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in | |
spec. | |
@retval EFI_NOT_FOUND Could not allocate pages match the requirement. | |
@retval EFI_OUT_OF_RESOURCES No enough pages to allocate. | |
@retval EFI_SUCCESS Pages successfully allocated. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreAllocatePages ( | |
IN EFI_ALLOCATE_TYPE Type, | |
IN EFI_MEMORY_TYPE MemoryType, | |
IN UINTN NumberOfPages, | |
IN OUT EFI_PHYSICAL_ADDRESS *Memory | |
); | |
/** | |
Frees previous allocated pages. | |
@param Memory Base address of memory being freed | |
@param NumberOfPages The number of pages to free | |
@retval EFI_NOT_FOUND Could not find the entry that covers the range | |
@retval EFI_INVALID_PARAMETER Address not aligned | |
@return EFI_SUCCESS -Pages successfully freed. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreFreePages ( | |
IN EFI_PHYSICAL_ADDRESS Memory, | |
IN UINTN NumberOfPages | |
); | |
/** | |
This function returns a copy of the current memory map. The map is an array of | |
memory descriptors, each of which describes a contiguous block of memory. | |
@param MemoryMapSize A pointer to the size, in bytes, of the | |
MemoryMap buffer. On input, this is the size of | |
the buffer allocated by the caller. On output, | |
it is the size of the buffer returned by the | |
firmware if the buffer was large enough, or the | |
size of the buffer needed to contain the map if | |
the buffer was too small. | |
@param MemoryMap A pointer to the buffer in which firmware places | |
the current memory map. | |
@param MapKey A pointer to the location in which firmware | |
returns the key for the current memory map. | |
@param DescriptorSize A pointer to the location in which firmware | |
returns the size, in bytes, of an individual | |
EFI_MEMORY_DESCRIPTOR. | |
@param DescriptorVersion A pointer to the location in which firmware | |
returns the version number associated with the | |
EFI_MEMORY_DESCRIPTOR. | |
@retval EFI_SUCCESS The memory map was returned in the MemoryMap | |
buffer. | |
@retval EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small. The current | |
buffer size needed to hold the memory map is | |
returned in MemoryMapSize. | |
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreGetMemoryMap ( | |
IN OUT UINTN *MemoryMapSize, | |
IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, | |
OUT UINTN *MapKey, | |
OUT UINTN *DescriptorSize, | |
OUT UINT32 *DescriptorVersion | |
); | |
/** | |
Allocate pool of a particular type. | |
@param PoolType Type of pool to allocate | |
@param Size The amount of pool to allocate | |
@param Buffer The address to return a pointer to the allocated | |
pool | |
@retval EFI_INVALID_PARAMETER PoolType not valid or Buffer is NULL | |
@retval EFI_OUT_OF_RESOURCES Size exceeds max pool size or allocation failed. | |
@retval EFI_SUCCESS Pool successfully allocated. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreAllocatePool ( | |
IN EFI_MEMORY_TYPE PoolType, | |
IN UINTN Size, | |
OUT VOID **Buffer | |
); | |
/** | |
Allocate pool of a particular type. | |
@param PoolType Type of pool to allocate | |
@param Size The amount of pool to allocate | |
@param Buffer The address to return a pointer to the allocated | |
pool | |
@retval EFI_INVALID_PARAMETER PoolType not valid or Buffer is NULL | |
@retval EFI_OUT_OF_RESOURCES Size exceeds max pool size or allocation failed. | |
@retval EFI_SUCCESS Pool successfully allocated. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreInternalAllocatePool ( | |
IN EFI_MEMORY_TYPE PoolType, | |
IN UINTN Size, | |
OUT VOID **Buffer | |
); | |
/** | |
Frees pool. | |
@param Buffer The allocated pool entry to free | |
@retval EFI_INVALID_PARAMETER Buffer is not a valid value. | |
@retval EFI_SUCCESS Pool successfully freed. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreFreePool ( | |
IN VOID *Buffer | |
); | |
/** | |
Frees pool. | |
@param Buffer The allocated pool entry to free | |
@param PoolType Pointer to pool type | |
@retval EFI_INVALID_PARAMETER Buffer is not a valid value. | |
@retval EFI_SUCCESS Pool successfully freed. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreInternalFreePool ( | |
IN VOID *Buffer, | |
OUT EFI_MEMORY_TYPE *PoolType OPTIONAL | |
); | |
/** | |
Loads an EFI image into memory and returns a handle to the image. | |
@param BootPolicy If TRUE, indicates that the request originates | |
from the boot manager, and that the boot | |
manager is attempting to load FilePath as a | |
boot selection. | |
@param ParentImageHandle The caller's image handle. | |
@param FilePath The specific file path from which the image is | |
loaded. | |
@param SourceBuffer If not NULL, a pointer to the memory location | |
containing a copy of the image to be loaded. | |
@param SourceSize The size in bytes of SourceBuffer. | |
@param ImageHandle Pointer to the returned image handle that is | |
created when the image is successfully loaded. | |
@retval EFI_SUCCESS The image was loaded into memory. | |
@retval EFI_NOT_FOUND The FilePath was not found. | |
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. | |
@retval EFI_UNSUPPORTED The image type is not supported, or the device | |
path cannot be parsed to locate the proper | |
protocol for loading the file. | |
@retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient | |
resources. | |
@retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not | |
understood. | |
@retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error. | |
@retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the | |
image from being loaded. NULL is returned in *ImageHandle. | |
@retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a | |
valid EFI_LOADED_IMAGE_PROTOCOL. However, the current | |
platform policy specifies that the image should not be started. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreLoadImage ( | |
IN BOOLEAN BootPolicy, | |
IN EFI_HANDLE ParentImageHandle, | |
IN EFI_DEVICE_PATH_PROTOCOL *FilePath, | |
IN VOID *SourceBuffer OPTIONAL, | |
IN UINTN SourceSize, | |
OUT EFI_HANDLE *ImageHandle | |
); | |
/** | |
Unloads an image. | |
@param ImageHandle Handle that identifies the image to be | |
unloaded. | |
@retval EFI_SUCCESS The image has been unloaded. | |
@retval EFI_UNSUPPORTED The image has been sarted, and does not support | |
unload. | |
@retval EFI_INVALID_PARAMPETER ImageHandle is not a valid image handle. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreUnloadImage ( | |
IN EFI_HANDLE ImageHandle | |
); | |
/** | |
Transfer control to a loaded image's entry point. | |
@param ImageHandle Handle of image to be started. | |
@param ExitDataSize Pointer of the size to ExitData | |
@param ExitData Pointer to a pointer to a data buffer that | |
includes a Null-terminated string, | |
optionally followed by additional binary data. | |
The string is a description that the caller may | |
use to further indicate the reason for the | |
image's exit. | |
@retval EFI_INVALID_PARAMETER Invalid parameter | |
@retval EFI_OUT_OF_RESOURCES No enough buffer to allocate | |
@retval EFI_SECURITY_VIOLATION The current platform policy specifies that the image should not be started. | |
@retval EFI_SUCCESS Successfully transfer control to the image's | |
entry point. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreStartImage ( | |
IN EFI_HANDLE ImageHandle, | |
OUT UINTN *ExitDataSize, | |
OUT CHAR16 **ExitData OPTIONAL | |
); | |
/** | |
Terminates the currently loaded EFI image and returns control to boot services. | |
@param ImageHandle Handle that identifies the image. This | |
parameter is passed to the image on entry. | |
@param Status The image's exit code. | |
@param ExitDataSize The size, in bytes, of ExitData. Ignored if | |
ExitStatus is EFI_SUCCESS. | |
@param ExitData Pointer to a data buffer that includes a | |
Null-terminated Unicode string, optionally | |
followed by additional binary data. The string | |
is a description that the caller may use to | |
further indicate the reason for the image's | |
exit. | |
@retval EFI_INVALID_PARAMETER Image handle is NULL or it is not current | |
image. | |
@retval EFI_SUCCESS Successfully terminates the currently loaded | |
EFI image. | |
@retval EFI_ACCESS_DENIED Should never reach there. | |
@retval EFI_OUT_OF_RESOURCES Could not allocate pool | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreExit ( | |
IN EFI_HANDLE ImageHandle, | |
IN EFI_STATUS Status, | |
IN UINTN ExitDataSize, | |
IN CHAR16 *ExitData OPTIONAL | |
); | |
/** | |
Creates an event. | |
@param Type The type of event to create and its mode and | |
attributes | |
@param NotifyTpl The task priority level of event notifications | |
@param NotifyFunction Pointer to the events notification function | |
@param NotifyContext Pointer to the notification functions context; | |
corresponds to parameter "Context" in the | |
notification function | |
@param Event Pointer to the newly created event if the call | |
succeeds; undefined otherwise | |
@retval EFI_SUCCESS The event structure was created | |
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value | |
@retval EFI_OUT_OF_RESOURCES The event could not be allocated | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreCreateEvent ( | |
IN UINT32 Type, | |
IN EFI_TPL NotifyTpl, | |
IN EFI_EVENT_NOTIFY NotifyFunction, OPTIONAL | |
IN VOID *NotifyContext, OPTIONAL | |
OUT EFI_EVENT *Event | |
); | |
/** | |
Creates an event in a group. | |
@param Type The type of event to create and its mode and | |
attributes | |
@param NotifyTpl The task priority level of event notifications | |
@param NotifyFunction Pointer to the events notification function | |
@param NotifyContext Pointer to the notification functions context; | |
corresponds to parameter "Context" in the | |
notification function | |
@param EventGroup GUID for EventGroup if NULL act the same as | |
gBS->CreateEvent(). | |
@param Event Pointer to the newly created event if the call | |
succeeds; undefined otherwise | |
@retval EFI_SUCCESS The event structure was created | |
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value | |
@retval EFI_OUT_OF_RESOURCES The event could not be allocated | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreCreateEventEx ( | |
IN UINT32 Type, | |
IN EFI_TPL NotifyTpl, | |
IN EFI_EVENT_NOTIFY NotifyFunction, OPTIONAL | |
IN CONST VOID *NotifyContext, OPTIONAL | |
IN CONST EFI_GUID *EventGroup, OPTIONAL | |
OUT EFI_EVENT *Event | |
); | |
/** | |
Creates a general-purpose event structure | |
@param Type The type of event to create and its mode and | |
attributes | |
@param NotifyTpl The task priority level of event notifications | |
@param NotifyFunction Pointer to the events notification function | |
@param NotifyContext Pointer to the notification functions context; | |
corresponds to parameter "Context" in the | |
notification function | |
@param EventGroup GUID for EventGroup if NULL act the same as | |
gBS->CreateEvent(). | |
@param Event Pointer to the newly created event if the call | |
succeeds; undefined otherwise | |
@retval EFI_SUCCESS The event structure was created | |
@retval EFI_INVALID_PARAMETER One of the parameters has an invalid value | |
@retval EFI_OUT_OF_RESOURCES The event could not be allocated | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreCreateEventInternal ( | |
IN UINT32 Type, | |
IN EFI_TPL NotifyTpl, | |
IN EFI_EVENT_NOTIFY NotifyFunction, OPTIONAL | |
IN CONST VOID *NotifyContext, OPTIONAL | |
IN CONST EFI_GUID *EventGroup, OPTIONAL | |
OUT EFI_EVENT *Event | |
); | |
/** | |
Sets the type of timer and the trigger time for a timer event. | |
@param UserEvent The timer event that is to be signaled at the | |
specified time | |
@param Type The type of time that is specified in | |
TriggerTime | |
@param TriggerTime The number of 100ns units until the timer | |
expires | |
@retval EFI_SUCCESS The event has been set to be signaled at the | |
requested time | |
@retval EFI_INVALID_PARAMETER Event or Type is not valid | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreSetTimer ( | |
IN EFI_EVENT UserEvent, | |
IN EFI_TIMER_DELAY Type, | |
IN UINT64 TriggerTime | |
); | |
/** | |
Signals the event. Queues the event to be notified if needed. | |
@param UserEvent The event to signal . | |
@retval EFI_INVALID_PARAMETER Parameters are not valid. | |
@retval EFI_SUCCESS The event was signaled. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreSignalEvent ( | |
IN EFI_EVENT UserEvent | |
); | |
/** | |
Stops execution until an event is signaled. | |
@param NumberOfEvents The number of events in the UserEvents array | |
@param UserEvents An array of EFI_EVENT | |
@param UserIndex Pointer to the index of the event which | |
satisfied the wait condition | |
@retval EFI_SUCCESS The event indicated by Index was signaled. | |
@retval EFI_INVALID_PARAMETER The event indicated by Index has a notification | |
function or Event was not a valid type | |
@retval EFI_UNSUPPORTED The current TPL is not TPL_APPLICATION | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreWaitForEvent ( | |
IN UINTN NumberOfEvents, | |
IN EFI_EVENT *UserEvents, | |
OUT UINTN *UserIndex | |
); | |
/** | |
Closes an event and frees the event structure. | |
@param UserEvent Event to close | |
@retval EFI_INVALID_PARAMETER Parameters are not valid. | |
@retval EFI_SUCCESS The event has been closed | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreCloseEvent ( | |
IN EFI_EVENT UserEvent | |
); | |
/** | |
Check the status of an event. | |
@param UserEvent The event to check | |
@retval EFI_SUCCESS The event is in the signaled state | |
@retval EFI_NOT_READY The event is not in the signaled state | |
@retval EFI_INVALID_PARAMETER Event is of type EVT_NOTIFY_SIGNAL | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreCheckEvent ( | |
IN EFI_EVENT UserEvent | |
); | |
/** | |
Adds reserved memory, system memory, or memory-mapped I/O resources to the | |
global coherency domain of the processor. | |
@param GcdMemoryType Memory type of the memory space. | |
@param BaseAddress Base address of the memory space. | |
@param Length Length of the memory space. | |
@param Capabilities alterable attributes of the memory space. | |
@retval EFI_SUCCESS Merged this memory space into GCD map. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreAddMemorySpace ( | |
IN EFI_GCD_MEMORY_TYPE GcdMemoryType, | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length, | |
IN UINT64 Capabilities | |
); | |
/** | |
Allocates nonexistent memory, reserved memory, system memory, or memorymapped | |
I/O resources from the global coherency domain of the processor. | |
@param GcdAllocateType The type of allocate operation | |
@param GcdMemoryType The desired memory type | |
@param Alignment Align with 2^Alignment | |
@param Length Length to allocate | |
@param BaseAddress Base address to allocate | |
@param ImageHandle The image handle consume the allocated space. | |
@param DeviceHandle The device handle consume the allocated space. | |
@retval EFI_INVALID_PARAMETER Invalid parameter. | |
@retval EFI_NOT_FOUND No descriptor contains the desired space. | |
@retval EFI_SUCCESS Memory space successfully allocated. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreAllocateMemorySpace ( | |
IN EFI_GCD_ALLOCATE_TYPE GcdAllocateType, | |
IN EFI_GCD_MEMORY_TYPE GcdMemoryType, | |
IN UINTN Alignment, | |
IN UINT64 Length, | |
IN OUT EFI_PHYSICAL_ADDRESS *BaseAddress, | |
IN EFI_HANDLE ImageHandle, | |
IN EFI_HANDLE DeviceHandle OPTIONAL | |
); | |
/** | |
Frees nonexistent memory, reserved memory, system memory, or memory-mapped | |
I/O resources from the global coherency domain of the processor. | |
@param BaseAddress Base address of the memory space. | |
@param Length Length of the memory space. | |
@retval EFI_SUCCESS Space successfully freed. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreFreeMemorySpace ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length | |
); | |
/** | |
Removes reserved memory, system memory, or memory-mapped I/O resources from | |
the global coherency domain of the processor. | |
@param BaseAddress Base address of the memory space. | |
@param Length Length of the memory space. | |
@retval EFI_SUCCESS Successfully remove a segment of memory space. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreRemoveMemorySpace ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length | |
); | |
/** | |
Retrieves the descriptor for a memory region containing a specified address. | |
@param BaseAddress Specified start address | |
@param Descriptor Specified length | |
@retval EFI_INVALID_PARAMETER Invalid parameter | |
@retval EFI_SUCCESS Successfully get memory space descriptor. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreGetMemorySpaceDescriptor ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
OUT EFI_GCD_MEMORY_SPACE_DESCRIPTOR *Descriptor | |
); | |
/** | |
Modifies the attributes for a memory region in the global coherency domain of the | |
processor. | |
@param BaseAddress Specified start address | |
@param Length Specified length | |
@param Attributes Specified attributes | |
@retval EFI_SUCCESS The attributes were set for the memory region. | |
@retval EFI_INVALID_PARAMETER Length is zero. | |
@retval EFI_UNSUPPORTED The processor does not support one or more bytes of the memory | |
resource range specified by BaseAddress and Length. | |
@retval EFI_UNSUPPORTED The bit mask of attributes is not support for the memory resource | |
range specified by BaseAddress and Length. | |
@retval EFI_ACCESS_DENIED The attributes for the memory resource range specified by | |
BaseAddress and Length cannot be modified. | |
@retval EFI_OUT_OF_RESOURCES There are not enough system resources to modify the attributes of | |
the memory resource range. | |
@retval EFI_NOT_AVAILABLE_YET The attributes cannot be set because CPU architectural protocol is | |
not available yet. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreSetMemorySpaceAttributes ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length, | |
IN UINT64 Attributes | |
); | |
/** | |
Modifies the capabilities for a memory region in the global coherency domain of the | |
processor. | |
@param BaseAddress The physical address that is the start address of a memory region. | |
@param Length The size in bytes of the memory region. | |
@param Capabilities The bit mask of capabilities that the memory region supports. | |
@retval EFI_SUCCESS The capabilities were set for the memory region. | |
@retval EFI_INVALID_PARAMETER Length is zero. | |
@retval EFI_UNSUPPORTED The capabilities specified by Capabilities do not include the | |
memory region attributes currently in use. | |
@retval EFI_ACCESS_DENIED The capabilities for the memory resource range specified by | |
BaseAddress and Length cannot be modified. | |
@retval EFI_OUT_OF_RESOURCES There are not enough system resources to modify the capabilities | |
of the memory resource range. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreSetMemorySpaceCapabilities ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length, | |
IN UINT64 Capabilities | |
); | |
/** | |
Returns a map of the memory resources in the global coherency domain of the | |
processor. | |
@param NumberOfDescriptors Number of descriptors. | |
@param MemorySpaceMap Descriptor array | |
@retval EFI_INVALID_PARAMETER Invalid parameter | |
@retval EFI_OUT_OF_RESOURCES No enough buffer to allocate | |
@retval EFI_SUCCESS Successfully get memory space map. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreGetMemorySpaceMap ( | |
OUT UINTN *NumberOfDescriptors, | |
OUT EFI_GCD_MEMORY_SPACE_DESCRIPTOR **MemorySpaceMap | |
); | |
/** | |
Adds reserved I/O or I/O resources to the global coherency domain of the processor. | |
@param GcdIoType IO type of the segment. | |
@param BaseAddress Base address of the segment. | |
@param Length Length of the segment. | |
@retval EFI_SUCCESS Merged this segment into GCD map. | |
@retval EFI_INVALID_PARAMETER Parameter not valid | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreAddIoSpace ( | |
IN EFI_GCD_IO_TYPE GcdIoType, | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length | |
); | |
/** | |
Allocates nonexistent I/O, reserved I/O, or I/O resources from the global coherency | |
domain of the processor. | |
@param GcdAllocateType The type of allocate operation | |
@param GcdIoType The desired IO type | |
@param Alignment Align with 2^Alignment | |
@param Length Length to allocate | |
@param BaseAddress Base address to allocate | |
@param ImageHandle The image handle consume the allocated space. | |
@param DeviceHandle The device handle consume the allocated space. | |
@retval EFI_INVALID_PARAMETER Invalid parameter. | |
@retval EFI_NOT_FOUND No descriptor contains the desired space. | |
@retval EFI_SUCCESS IO space successfully allocated. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreAllocateIoSpace ( | |
IN EFI_GCD_ALLOCATE_TYPE GcdAllocateType, | |
IN EFI_GCD_IO_TYPE GcdIoType, | |
IN UINTN Alignment, | |
IN UINT64 Length, | |
IN OUT EFI_PHYSICAL_ADDRESS *BaseAddress, | |
IN EFI_HANDLE ImageHandle, | |
IN EFI_HANDLE DeviceHandle OPTIONAL | |
); | |
/** | |
Frees nonexistent I/O, reserved I/O, or I/O resources from the global coherency | |
domain of the processor. | |
@param BaseAddress Base address of the segment. | |
@param Length Length of the segment. | |
@retval EFI_SUCCESS Space successfully freed. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreFreeIoSpace ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length | |
); | |
/** | |
Removes reserved I/O or I/O resources from the global coherency domain of the | |
processor. | |
@param BaseAddress Base address of the segment. | |
@param Length Length of the segment. | |
@retval EFI_SUCCESS Successfully removed a segment of IO space. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreRemoveIoSpace ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length | |
); | |
/** | |
Retrieves the descriptor for an I/O region containing a specified address. | |
@param BaseAddress Specified start address | |
@param Descriptor Specified length | |
@retval EFI_INVALID_PARAMETER Descriptor is NULL. | |
@retval EFI_SUCCESS Successfully get the IO space descriptor. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreGetIoSpaceDescriptor ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
OUT EFI_GCD_IO_SPACE_DESCRIPTOR *Descriptor | |
); | |
/** | |
Returns a map of the I/O resources in the global coherency domain of the processor. | |
@param NumberOfDescriptors Number of descriptors. | |
@param IoSpaceMap Descriptor array | |
@retval EFI_INVALID_PARAMETER Invalid parameter | |
@retval EFI_OUT_OF_RESOURCES No enough buffer to allocate | |
@retval EFI_SUCCESS Successfully get IO space map. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreGetIoSpaceMap ( | |
OUT UINTN *NumberOfDescriptors, | |
OUT EFI_GCD_IO_SPACE_DESCRIPTOR **IoSpaceMap | |
); | |
/** | |
This is the main Dispatcher for DXE and it exits when there are no more | |
drivers to run. Drain the mScheduledQueue and load and start a PE | |
image for each driver. Search the mDiscoveredList to see if any driver can | |
be placed on the mScheduledQueue. If no drivers are placed on the | |
mScheduledQueue exit the function. On exit it is assumed the Bds() | |
will be called, and when the Bds() exits the Dispatcher will be called | |
again. | |
@retval EFI_ALREADY_STARTED The DXE Dispatcher is already running | |
@retval EFI_NOT_FOUND No DXE Drivers were dispatched | |
@retval EFI_SUCCESS One or more DXE Drivers were dispatched | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreDispatcher ( | |
VOID | |
); | |
/** | |
Check every driver and locate a matching one. If the driver is found, the Unrequested | |
state flag is cleared. | |
@param FirmwareVolumeHandle The handle of the Firmware Volume that contains | |
the firmware file specified by DriverName. | |
@param DriverName The Driver name to put in the Dependent state. | |
@retval EFI_SUCCESS The DriverName was found and it's SOR bit was | |
cleared | |
@retval EFI_NOT_FOUND The DriverName does not exist or it's SOR bit was | |
not set. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreSchedule ( | |
IN EFI_HANDLE FirmwareVolumeHandle, | |
IN EFI_GUID *DriverName | |
); | |
/** | |
Convert a driver from the Untrused back to the Scheduled state. | |
@param FirmwareVolumeHandle The handle of the Firmware Volume that contains | |
the firmware file specified by DriverName. | |
@param DriverName The Driver name to put in the Scheduled state | |
@retval EFI_SUCCESS The file was found in the untrusted state, and it | |
was promoted to the trusted state. | |
@retval EFI_NOT_FOUND The file was not found in the untrusted state. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreTrust ( | |
IN EFI_HANDLE FirmwareVolumeHandle, | |
IN EFI_GUID *DriverName | |
); | |
/** | |
This routine is the driver initialization entry point. It initializes the | |
libraries, and registers two notification functions. These notification | |
functions are responsible for building the FV stack dynamically. | |
@param ImageHandle The image handle. | |
@param SystemTable The system table. | |
@retval EFI_SUCCESS Function successfully returned. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
FwVolDriverInit ( | |
IN EFI_HANDLE ImageHandle, | |
IN EFI_SYSTEM_TABLE *SystemTable | |
); | |
/** | |
Entry point of the section extraction code. Initializes an instance of the | |
section extraction interface and installs it on a new handle. | |
@param ImageHandle A handle for the image that is initializing this driver | |
@param SystemTable A pointer to the EFI system table | |
@retval EFI_SUCCESS Driver initialized successfully | |
@retval EFI_OUT_OF_RESOURCES Could not allocate needed resources | |
**/ | |
EFI_STATUS | |
EFIAPI | |
InitializeSectionExtraction ( | |
IN EFI_HANDLE ImageHandle, | |
IN EFI_SYSTEM_TABLE *SystemTable | |
); | |
/** | |
This DXE service routine is used to process a firmware volume. In | |
particular, it can be called by BDS to process a single firmware | |
volume found in a capsule. | |
@param FvHeader pointer to a firmware volume header | |
@param Size the size of the buffer pointed to by FvHeader | |
@param FVProtocolHandle the handle on which a firmware volume protocol | |
was produced for the firmware volume passed in. | |
@retval EFI_OUT_OF_RESOURCES if an FVB could not be produced due to lack of | |
system resources | |
@retval EFI_VOLUME_CORRUPTED if the volume was corrupted | |
@retval EFI_SUCCESS a firmware volume protocol was produced for the | |
firmware volume | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreProcessFirmwareVolume ( | |
IN VOID *FvHeader, | |
IN UINTN Size, | |
OUT EFI_HANDLE *FVProtocolHandle | |
); | |
// | |
//Functions used during debug buils | |
// | |
/** | |
Displays Architectural protocols that were not loaded and are required for DXE | |
core to function. Only used in Debug Builds. | |
**/ | |
VOID | |
CoreDisplayMissingArchProtocols ( | |
VOID | |
); | |
/** | |
Traverse the discovered list for any drivers that were discovered but not loaded | |
because the dependency experessions evaluated to false. | |
**/ | |
VOID | |
CoreDisplayDiscoveredNotDispatched ( | |
VOID | |
); | |
/** | |
Place holder function until all the Boot Services and Runtime Services are | |
available. | |
@return EFI_NOT_AVAILABLE_YET | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreEfiNotAvailableYetArg0 ( | |
VOID | |
); | |
/** | |
Place holder function until all the Boot Services and Runtime Services are | |
available. | |
@param Arg1 Undefined | |
@return EFI_NOT_AVAILABLE_YET | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreEfiNotAvailableYetArg1 ( | |
UINTN Arg1 | |
); | |
/** | |
Place holder function until all the Boot Services and Runtime Services are available. | |
@param Arg1 Undefined | |
@param Arg2 Undefined | |
@return EFI_NOT_AVAILABLE_YET | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreEfiNotAvailableYetArg2 ( | |
UINTN Arg1, | |
UINTN Arg2 | |
); | |
/** | |
Place holder function until all the Boot Services and Runtime Services are available. | |
@param Arg1 Undefined | |
@param Arg2 Undefined | |
@param Arg3 Undefined | |
@return EFI_NOT_AVAILABLE_YET | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreEfiNotAvailableYetArg3 ( | |
UINTN Arg1, | |
UINTN Arg2, | |
UINTN Arg3 | |
); | |
/** | |
Place holder function until all the Boot Services and Runtime Services are available. | |
@param Arg1 Undefined | |
@param Arg2 Undefined | |
@param Arg3 Undefined | |
@param Arg4 Undefined | |
@return EFI_NOT_AVAILABLE_YET | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreEfiNotAvailableYetArg4 ( | |
UINTN Arg1, | |
UINTN Arg2, | |
UINTN Arg3, | |
UINTN Arg4 | |
); | |
/** | |
Place holder function until all the Boot Services and Runtime Services are available. | |
@param Arg1 Undefined | |
@param Arg2 Undefined | |
@param Arg3 Undefined | |
@param Arg4 Undefined | |
@param Arg5 Undefined | |
@return EFI_NOT_AVAILABLE_YET | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CoreEfiNotAvailableYetArg5 ( | |
UINTN Arg1, | |
UINTN Arg2, | |
UINTN Arg3, | |
UINTN Arg4, | |
UINTN Arg5 | |
); | |
/** | |
Given a compressed source buffer, this function retrieves the size of the | |
uncompressed buffer and the size of the scratch buffer required to decompress | |
the compressed source buffer. | |
The GetInfo() function retrieves the size of the uncompressed buffer and the | |
temporary scratch buffer required to decompress the buffer specified by Source | |
and SourceSize. If the size of the uncompressed buffer or the size of the | |
scratch buffer cannot be determined from the compressed data specified by | |
Source and SourceData, then EFI_INVALID_PARAMETER is returned. Otherwise, the | |
size of the uncompressed buffer is returned in DestinationSize, the size of | |
the scratch buffer is returned in ScratchSize, and EFI_SUCCESS is returned. | |
The GetInfo() function does not have scratch buffer available to perform a | |
thorough checking of the validity of the source data. It just retrieves the | |
"Original Size" field from the beginning bytes of the source data and output | |
it as DestinationSize. And ScratchSize is specific to the decompression | |
implementation. | |
@param This A pointer to the EFI_DECOMPRESS_PROTOCOL instance. | |
@param Source The source buffer containing the compressed data. | |
@param SourceSize The size, in bytes, of the source buffer. | |
@param DestinationSize A pointer to the size, in bytes, of the | |
uncompressed buffer that will be generated when the | |
compressed buffer specified by Source and | |
SourceSize is decompressed. | |
@param ScratchSize A pointer to the size, in bytes, of the scratch | |
buffer that is required to decompress the | |
compressed buffer specified by Source and | |
SourceSize. | |
@retval EFI_SUCCESS The size of the uncompressed data was returned in | |
DestinationSize and the size of the scratch buffer | |
was returned in ScratchSize. | |
@retval EFI_INVALID_PARAMETER The size of the uncompressed data or the size of | |
the scratch buffer cannot be determined from the | |
compressed data specified by Source and | |
SourceSize. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
DxeMainUefiDecompressGetInfo ( | |
IN EFI_DECOMPRESS_PROTOCOL *This, | |
IN VOID *Source, | |
IN UINT32 SourceSize, | |
OUT UINT32 *DestinationSize, | |
OUT UINT32 *ScratchSize | |
); | |
/** | |
Decompresses a compressed source buffer. | |
The Decompress() function extracts decompressed data to its original form. | |
This protocol is designed so that the decompression algorithm can be | |
implemented without using any memory services. As a result, the Decompress() | |
Function is not allowed to call AllocatePool() or AllocatePages() in its | |
implementation. It is the caller's responsibility to allocate and free the | |
Destination and Scratch buffers. | |
If the compressed source data specified by Source and SourceSize is | |
sucessfully decompressed into Destination, then EFI_SUCCESS is returned. If | |
the compressed source data specified by Source and SourceSize is not in a | |
valid compressed data format, then EFI_INVALID_PARAMETER is returned. | |
@param This A pointer to the EFI_DECOMPRESS_PROTOCOL instance. | |
@param Source The source buffer containing the compressed data. | |
@param SourceSize SourceSizeThe size of source data. | |
@param Destination On output, the destination buffer that contains | |
the uncompressed data. | |
@param DestinationSize The size of the destination buffer. The size of | |
the destination buffer needed is obtained from | |
EFI_DECOMPRESS_PROTOCOL.GetInfo(). | |
@param Scratch A temporary scratch buffer that is used to perform | |
the decompression. | |
@param ScratchSize The size of scratch buffer. The size of the | |
scratch buffer needed is obtained from GetInfo(). | |
@retval EFI_SUCCESS Decompression completed successfully, and the | |
uncompressed buffer is returned in Destination. | |
@retval EFI_INVALID_PARAMETER The source buffer specified by Source and | |
SourceSize is corrupted (not in a valid | |
compressed format). | |
**/ | |
EFI_STATUS | |
EFIAPI | |
DxeMainUefiDecompress ( | |
IN EFI_DECOMPRESS_PROTOCOL *This, | |
IN VOID *Source, | |
IN UINT32 SourceSize, | |
IN OUT VOID *Destination, | |
IN UINT32 DestinationSize, | |
IN OUT VOID *Scratch, | |
IN UINT32 ScratchSize | |
); | |
/** | |
SEP member function. This function creates and returns a new section stream | |
handle to represent the new section stream. | |
@param SectionStreamLength Size in bytes of the section stream. | |
@param SectionStream Buffer containing the new section stream. | |
@param SectionStreamHandle A pointer to a caller allocated UINTN that on | |
output contains the new section stream handle. | |
@retval EFI_SUCCESS The section stream is created successfully. | |
@retval EFI_OUT_OF_RESOURCES memory allocation failed. | |
@retval EFI_INVALID_PARAMETER Section stream does not end concident with end | |
of last section. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
OpenSectionStream ( | |
IN UINTN SectionStreamLength, | |
IN VOID *SectionStream, | |
OUT UINTN *SectionStreamHandle | |
); | |
/** | |
SEP member function. Retrieves requested section from section stream. | |
@param SectionStreamHandle The section stream from which to extract the | |
requested section. | |
@param SectionType A pointer to the type of section to search for. | |
@param SectionDefinitionGuid If the section type is EFI_SECTION_GUID_DEFINED, | |
then SectionDefinitionGuid indicates which of | |
these types of sections to search for. | |
@param SectionInstance Indicates which instance of the requested | |
section to return. | |
@param Buffer Double indirection to buffer. If *Buffer is | |
non-null on input, then the buffer is caller | |
allocated. If Buffer is NULL, then the buffer | |
is callee allocated. In either case, the | |
requried buffer size is returned in *BufferSize. | |
@param BufferSize On input, indicates the size of *Buffer if | |
*Buffer is non-null on input. On output, | |
indicates the required size (allocated size if | |
callee allocated) of *Buffer. | |
@param AuthenticationStatus A pointer to a caller-allocated UINT32 that | |
indicates the authentication status of the | |
output buffer. If the input section's | |
GuidedSectionHeader.Attributes field | |
has the EFI_GUIDED_SECTION_AUTH_STATUS_VALID | |
bit as clear, AuthenticationStatus must return | |
zero. Both local bits (19:16) and aggregate | |
bits (3:0) in AuthenticationStatus are returned | |
by ExtractSection(). These bits reflect the | |
status of the extraction operation. The bit | |
pattern in both regions must be the same, as | |
the local and aggregate authentication statuses | |
have equivalent meaning at this level. If the | |
function returns anything other than | |
EFI_SUCCESS, the value of *AuthenticationStatus | |
is undefined. | |
@param IsFfs3Fv Indicates the FV format. | |
@retval EFI_SUCCESS Section was retrieved successfully | |
@retval EFI_PROTOCOL_ERROR A GUID defined section was encountered in the | |
section stream with its | |
EFI_GUIDED_SECTION_PROCESSING_REQUIRED bit set, | |
but there was no corresponding GUIDed Section | |
Extraction Protocol in the handle database. | |
*Buffer is unmodified. | |
@retval EFI_NOT_FOUND An error was encountered when parsing the | |
SectionStream. This indicates the SectionStream | |
is not correctly formatted. | |
@retval EFI_NOT_FOUND The requested section does not exist. | |
@retval EFI_OUT_OF_RESOURCES The system has insufficient resources to process | |
the request. | |
@retval EFI_INVALID_PARAMETER The SectionStreamHandle does not exist. | |
@retval EFI_WARN_TOO_SMALL The size of the caller allocated input buffer is | |
insufficient to contain the requested section. | |
The input buffer is filled and section contents | |
are truncated. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
GetSection ( | |
IN UINTN SectionStreamHandle, | |
IN EFI_SECTION_TYPE *SectionType, | |
IN EFI_GUID *SectionDefinitionGuid, | |
IN UINTN SectionInstance, | |
IN VOID **Buffer, | |
IN OUT UINTN *BufferSize, | |
OUT UINT32 *AuthenticationStatus, | |
IN BOOLEAN IsFfs3Fv | |
); | |
/** | |
SEP member function. Deletes an existing section stream | |
@param StreamHandleToClose Indicates the stream to close | |
@param FreeStreamBuffer TRUE - Need to free stream buffer; | |
FALSE - No need to free stream buffer. | |
@retval EFI_SUCCESS The section stream is closed sucessfully. | |
@retval EFI_OUT_OF_RESOURCES Memory allocation failed. | |
@retval EFI_INVALID_PARAMETER Section stream does not end concident with end | |
of last section. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
CloseSectionStream ( | |
IN UINTN StreamHandleToClose, | |
IN BOOLEAN FreeStreamBuffer | |
); | |
/** | |
Creates and initializes the DebugImageInfo Table. Also creates the configuration | |
table and registers it into the system table. | |
Note: | |
This function allocates memory, frees it, and then allocates memory at an | |
address within the initial allocation. Since this function is called early | |
in DXE core initialization (before drivers are dispatched), this should not | |
be a problem. | |
**/ | |
VOID | |
CoreInitializeDebugImageInfoTable ( | |
VOID | |
); | |
/** | |
Update the CRC32 in the Debug Table. | |
Since the CRC32 service is made available by the Runtime driver, we have to | |
wait for the Runtime Driver to be installed before the CRC32 can be computed. | |
This function is called elsewhere by the core when the runtime architectural | |
protocol is produced. | |
**/ | |
VOID | |
CoreUpdateDebugTableCrc32 ( | |
VOID | |
); | |
/** | |
Adds a new DebugImageInfo structure to the DebugImageInfo Table. Re-Allocates | |
the table if it's not large enough to accomidate another entry. | |
@param ImageInfoType type of debug image information | |
@param LoadedImage pointer to the loaded image protocol for the image being | |
loaded | |
@param ImageHandle image handle for the image being loaded | |
**/ | |
VOID | |
CoreNewDebugImageInfoEntry ( | |
IN UINT32 ImageInfoType, | |
IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage, | |
IN EFI_HANDLE ImageHandle | |
); | |
/** | |
Removes and frees an entry from the DebugImageInfo Table. | |
@param ImageHandle image handle for the image being unloaded | |
**/ | |
VOID | |
CoreRemoveDebugImageInfoEntry ( | |
EFI_HANDLE ImageHandle | |
); | |
/** | |
This routine consumes FV hobs and produces instances of FW_VOL_BLOCK_PROTOCOL as appropriate. | |
@param ImageHandle The image handle. | |
@param SystemTable The system table. | |
@retval EFI_SUCCESS Successfully initialized firmware volume block | |
driver. | |
**/ | |
EFI_STATUS | |
EFIAPI | |
FwVolBlockDriverInit ( | |
IN EFI_HANDLE ImageHandle, | |
IN EFI_SYSTEM_TABLE *SystemTable | |
); | |
/** | |
Get FVB authentication status | |
@param FvbProtocol FVB protocol. | |
@return Authentication status. | |
**/ | |
UINT32 | |
GetFvbAuthenticationStatus ( | |
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbProtocol | |
); | |
/** | |
This routine produces a firmware volume block protocol on a given | |
buffer. | |
@param BaseAddress base address of the firmware volume image | |
@param Length length of the firmware volume image | |
@param ParentHandle handle of parent firmware volume, if this image | |
came from an FV image file and section in another firmware | |
volume (ala capsules) | |
@param AuthenticationStatus Authentication status inherited, if this image | |
came from an FV image file and section in another firmware volume. | |
@param FvProtocol Firmware volume block protocol produced. | |
@retval EFI_VOLUME_CORRUPTED Volume corrupted. | |
@retval EFI_OUT_OF_RESOURCES No enough buffer to be allocated. | |
@retval EFI_SUCCESS Successfully produced a FVB protocol on given | |
buffer. | |
**/ | |
EFI_STATUS | |
ProduceFVBProtocolOnBuffer ( | |
IN EFI_PHYSICAL_ADDRESS BaseAddress, | |
IN UINT64 Length, | |
IN EFI_HANDLE ParentHandle, | |
IN UINT32 AuthenticationStatus, | |
OUT EFI_HANDLE *FvProtocol OPTIONAL | |
); | |
/** | |
Raising to the task priority level of the mutual exclusion | |
lock, and then acquires ownership of the lock. | |
@param Lock The lock to acquire | |
@return Lock owned | |
**/ | |
VOID | |
CoreAcquireLock ( | |
IN EFI_LOCK *Lock | |
); | |
/** | |
Initialize a basic mutual exclusion lock. Each lock | |
provides mutual exclusion access at it's task priority | |
level. Since there is no-premption (at any TPL) or | |
multiprocessor support, acquiring the lock only consists | |
of raising to the locks TPL. | |
@param Lock The EFI_LOCK structure to initialize | |
@retval EFI_SUCCESS Lock Owned. | |
@retval EFI_ACCESS_DENIED Reentrant Lock Acquisition, Lock not Owned. | |
**/ | |
EFI_STATUS | |
CoreAcquireLockOrFail ( | |
IN EFI_LOCK *Lock | |
); | |
/** | |
Releases ownership of the mutual exclusion lock, and | |
restores the previous task priority level. | |
@param Lock The lock to release | |
@return Lock unowned | |
**/ | |
VOID | |
CoreReleaseLock ( | |
IN EFI_LOCK *Lock | |
); | |
/** | |
An empty function to pass error checking of CreateEventEx (). | |
@param Event Event whose notification function is being invoked. | |
@param Context Pointer to the notification function's context, | |
which is implementation-dependent. | |
**/ | |
VOID | |
EFIAPI | |
CoreEmptyCallbackFunction ( | |
IN EFI_EVENT Event, | |
IN VOID *Context | |
); | |
/** | |
Read data from Firmware Block by FVB protocol Read. | |
The data may cross the multi block ranges. | |
@param Fvb The FW_VOL_BLOCK_PROTOCOL instance from which to read data. | |
@param StartLba Pointer to StartLba. | |
On input, the start logical block index from which to read. | |
On output,the end logical block index after reading. | |
@param Offset Pointer to Offset | |
On input, offset into the block at which to begin reading. | |
On output, offset into the end block after reading. | |
@param DataSize Size of data to be read. | |
@param Data Pointer to Buffer that the data will be read into. | |
@retval EFI_SUCCESS Successfully read data from firmware block. | |
@retval others | |
**/ | |
EFI_STATUS | |
ReadFvbData ( | |
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb, | |
IN OUT EFI_LBA *StartLba, | |
IN OUT UINTN *Offset, | |
IN UINTN DataSize, | |
OUT UINT8 *Data | |
); | |
/** | |
Given the supplied FW_VOL_BLOCK_PROTOCOL, allocate a buffer for output and | |
copy the real length volume header into it. | |
@param Fvb The FW_VOL_BLOCK_PROTOCOL instance from which to | |
read the volume header | |
@param FwVolHeader Pointer to pointer to allocated buffer in which | |
the volume header is returned. | |
@retval EFI_OUT_OF_RESOURCES No enough buffer could be allocated. | |
@retval EFI_SUCCESS Successfully read volume header to the allocated | |
buffer. | |
@retval EFI_INVALID_PARAMETER The FV Header signature is not as expected or | |
the file system could not be understood. | |
**/ | |
EFI_STATUS | |
GetFwVolHeader ( | |
IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *Fvb, | |
OUT EFI_FIRMWARE_VOLUME_HEADER **FwVolHeader | |
); | |
/** | |
Verify checksum of the firmware volume header. | |
@param FvHeader Points to the firmware volume header to be checked | |
@retval TRUE Checksum verification passed | |
@retval FALSE Checksum verification failed | |
**/ | |
BOOLEAN | |
VerifyFvHeaderChecksum ( | |
IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader | |
); | |
/** | |
Initialize memory profile. | |
@param HobStart The start address of the HOB. | |
**/ | |
VOID | |
MemoryProfileInit ( | |
IN VOID *HobStart | |
); | |
/** | |
Install memory profile protocol. | |
**/ | |
VOID | |
MemoryProfileInstallProtocol ( | |
VOID | |
); | |
/** | |
Register image to memory profile. | |
@param DriverEntry Image info. | |
@param FileType Image file type. | |
@retval TRUE Register success. | |
@retval FALSE Register fail. | |
**/ | |
BOOLEAN | |
RegisterMemoryProfileImage ( | |
IN LOADED_IMAGE_PRIVATE_DATA *DriverEntry, | |
IN EFI_FV_FILETYPE FileType | |
); | |
/** | |
Unregister image from memory profile. | |
@param DriverEntry Image info. | |
@retval TRUE Unregister success. | |
@retval FALSE Unregister fail. | |
**/ | |
BOOLEAN | |
UnregisterMemoryProfileImage ( | |
IN LOADED_IMAGE_PRIVATE_DATA *DriverEntry | |
); | |
/** | |
Update memory profile information. | |
@param CallerAddress Address of caller who call Allocate or Free. | |
@param Action This Allocate or Free action. | |
@param MemoryType Memory type. | |
@param Size Buffer size. | |
@param Buffer Buffer address. | |
@retval TRUE Profile udpate success. | |
@retval FALSE Profile update fail. | |
**/ | |
BOOLEAN | |
CoreUpdateProfile ( | |
IN EFI_PHYSICAL_ADDRESS CallerAddress, | |
IN MEMORY_PROFILE_ACTION Action, | |
IN EFI_MEMORY_TYPE MemoryType, | |
IN UINTN Size, // Valid for AllocatePages/FreePages/AllocatePool | |
IN VOID *Buffer | |
); | |
/** | |
Internal function. Converts a memory range to use new attributes. | |
@param Start The first address of the range Must be page | |
aligned | |
@param NumberOfPages The number of pages to convert | |
@param NewAttributes The new attributes value for the range. | |
**/ | |
VOID | |
CoreUpdateMemoryAttributes ( | |
IN EFI_PHYSICAL_ADDRESS Start, | |
IN UINT64 NumberOfPages, | |
IN UINT64 NewAttributes | |
); | |
/** | |
Initialize PropertiesTable support. | |
**/ | |
VOID | |
EFIAPI | |
CoreInitializePropertiesTable ( | |
VOID | |
); | |
/** | |
Initialize MemoryAttrubutesTable support. | |
**/ | |
VOID | |
EFIAPI | |
CoreInitializeMemoryAttributesTable ( | |
VOID | |
); | |
/** | |
Install MemoryAttributesTable on memory allocation. | |
@param[in] MemoryType EFI memory type. | |
**/ | |
VOID | |
InstallMemoryAttributesTableOnMemoryAllocation ( | |
IN EFI_MEMORY_TYPE MemoryType | |
); | |
/** | |
Insert image record. | |
@param RuntimeImage Runtime image information | |
**/ | |
VOID | |
InsertImageRecord ( | |
IN EFI_RUNTIME_IMAGE_ENTRY *RuntimeImage | |
); | |
/** | |
Remove Image record. | |
@param RuntimeImage Runtime image information | |
**/ | |
VOID | |
RemoveImageRecord ( | |
IN EFI_RUNTIME_IMAGE_ENTRY *RuntimeImage | |
); | |
#endif |