#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>
#include <ntifs.h>
#include <ntndk.h>
#include <ntintsafe.h>
#include <ntimage.h>
#include <drivers/acpi/acpi.h>
#include <Uefi.h>
#include <DevicePath.h>
#include <LoadedImage.h>
#include <GraphicsOutput.h>
#include <UgaDraw.h>
#include <BlockIo.h>
#include <Acpi.h>
#include <GlobalVariable.h>
#include <cmlib.h>

Include dependency graph for bl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_BL_LIBRARY_PARAMETERS

struct	_BOOT_APPLICATION_PARAMETER_BLOCK

struct	_BL_MEMORY_DATA

struct	_BL_FIRMWARE_DESCRIPTOR

struct	_BL_RETURN_ARGUMENTS

struct	_BL_MEMORY_DESCRIPTOR

struct	_BL_BCD_OPTION

struct	_BL_APPLICATION_ENTRY

struct	_BL_LOADED_APPLICATION_ENTRY

struct	_BL_MENU_STATUS

struct	_BL_HARDDISK_DEVICE

struct	_BL_LOCAL_DEVICE

struct	_BL_DEVICE_DESCRIPTOR

struct	_BL_FILE_PATH_DESCRIPTOR

struct	_BL_WINDOWS_LOAD_OPTIONS

struct	_BL_ARCH_CONTEXT

struct	_BL_MEMORY_DESCRIPTOR_LIST

struct	_BL_ADDRESS_RANGE

struct	_BL_FILE_INFORMATION

struct	_BL_FILE_CALLBACKS

struct	_BL_FILE_ENTRY

struct	_BL_FILE_SYSTEM_ENTRY

struct	_BL_FILE_SYSTEM_REGISTRATION_TABLE

struct	_BL_DISPLAY_STATE

struct	_BL_DISPLAY_MODE

struct	_BL_TEXT_CONSOLE_VTABLE

struct	_BL_GRAPHICS_CONSOLE_VTABLE

struct	_BL_TEXT_CONSOLE

struct	_BL_INPUT_CONSOLE_VTABLE

struct	_BL_INPUT_CONSOLE

struct	_BL_GRAPHICS_CONSOLE

struct	_BL_REMOTE_CONSOLE

struct	_BL_HASH_TABLE

struct	_BL_HASH_ENTRY

struct	_BL_HASH_VALUE

struct	_BL_HASH_NODE

struct	_BL_BLOCK_DEVICE_INFORMATION

struct	_BL_DEVICE_INFORMATION

struct	_BL_BLOCK_DEVICE

struct	_BL_PROTOCOL_HANDLE

struct	_BL_DEVICE_CALLBACKS

struct	_BL_DEVICE_ENTRY

struct	_BL_IMG_FILE

struct	_BL_IMAGE_APPLICATION_ENTRY

struct	_BL_BUFFER_DESCRIPTOR

struct	_BL_DEFERRED_FONT_FILE

struct	_BMP_HEADER

struct	_DIB_HEADER

struct	_BITMAP

struct	_COORD

struct	_BL_PD_DATA_BLOB

Macros
#define	BL_APPLICATION_FLAG_CONVERTED_FROM_EFI 0x01

#define	BL_APP_ENTRY_SIGNATURE "BTAPENT"

#define	BOOT_APPLICATION_SIGNATURE_1 'TOOB'

#define	BOOT_APPLICATION_SIGNATURE_2 ' PPA'

#define	BOOT_MEMORY_TRANSLATION_TYPE_PHYSICAL 0

#define	BOOT_MEMORY_TRANSLATION_TYPE_VIRTUAL 1

#define	BOOT_APPLICATION_VERSION 2

#define	BL_MEMORY_DATA_VERSION 1

#define	BL_RETURN_ARGUMENTS_VERSION 1

#define	BL_FIRMWARE_DESCRIPTOR_VERSION 2

#define	BL_RETURN_ARGUMENTS_NO_PAE_FLAG 0x40

#define	BL_APPLICATION_ENTRY_FLAG_NO_GUID 0x01

#define	BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL 0x02

#define	BL_APPLICATION_ENTRY_WINLOAD 0x04

#define	BL_APPLICATION_ENTRY_STARTUP 0x08

#define	BL_APPLICATION_ENTRY_REBOOT_ON_ERROR 0x20

#define	BL_APPLICATION_ENTRY_NTLDR 0x40

#define	BL_APPLICATION_ENTRY_BCD_OPTIONS_EXTERNAL 0x80

#define	BL_APPLICATION_ENTRY_WINRESUME 0x100

#define	BL_APPLICATION_ENTRY_SETUPLDR 0x200

#define	BL_APPLICATION_ENTRY_BOOTSECTOR 0x400

#define	BL_APPLICATION_ENTRY_BOOTMGR 0x1000

#define	BL_APPLICATION_ENTRY_DISPLAY_ORDER 0x800000

#define	BL_APPLICATION_ENTRY_FIXED_SEQUENCE 0x20000000

#define	BL_APPLICATION_ENTRY_RECOVERY 0x40000000

#define	BL_CONTEXT_PAGING_ON 1

#define	BL_CONTEXT_INTERRUPTS_ON 2

#define	BL_MM_FLAG_USE_FIRMWARE_FOR_MEMORY_MAP_BUFFERS 0x01

#define	BL_MM_FLAG_REQUEST_COALESCING 0x02

#define	BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG 0x01

#define	BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG 0x02

#define	BL_MM_ADD_DESCRIPTOR_NEVER_COALESCE_FLAG 0x10

#define	BL_MM_ADD_DESCRIPTOR_NEVER_TRUNCATE_FLAG 0x20

#define	BL_MM_ADD_DESCRIPTOR_ALLOCATE_FLAG 0x1000

#define	BL_MM_ADD_DESCRIPTOR_UPDATE_LIST_POINTER_FLAG 0x2000

#define	BL_MM_INCLUDE_MAPPED_ALLOCATED 0x01

#define	BL_MM_INCLUDE_MAPPED_UNALLOCATED 0x02

#define	BL_MM_INCLUDE_UNMAPPED_ALLOCATED 0x04

#define	BL_MM_INCLUDE_UNMAPPED_UNALLOCATED 0x08

#define	BL_MM_INCLUDE_RESERVED_ALLOCATED 0x10

#define	BL_MM_INCLUDE_BAD_MEMORY 0x20

#define	BL_MM_INCLUDE_FIRMWARE_MEMORY 0x40

#define	BL_MM_INCLUDE_TRUNCATED_MEMORY 0x80

#define	BL_MM_INCLUDE_PERSISTENT_MEMORY 0x100

#define	BL_MM_INCLUDE_FIRMWARE_MEMORY_2 0x200

#define	BL_MM_INCLUDE_NO_FIRMWARE_MEMORY

#define	BL_MM_INCLUDE_ONLY_FIRMWARE_MEMORY

#define	BL_MM_REQUEST_DEFAULT_TYPE 1

#define	BL_MM_REQUEST_TOP_DOWN_TYPE 2

#define	BL_MM_REMOVE_PHYSICAL_REGION_FLAG 0x40000000

#define	BL_MM_REMOVE_VIRTUAL_REGION_FLAG 0x80000000

#define	BL_LIBRARY_FLAG_NO_DISPLAY 0x01

#define	BL_LIBRARY_FLAG_REINITIALIZE 0x02

#define	BL_LIBRARY_FLAG_REINITIALIZE_ALL 0x04

#define	BL_LIBRARY_FLAG_ZERO_HEAP_ALLOCATIONS_ON_FREE 0x10

#define	BL_LIBRARY_FLAG_INITIALIZATION_COMPLETED 0x20

#define	BL_LIBRARY_FLAG_NO_GRAPHICS_CONSOLE 0x800

#define	BL_DISPLAY_GRAPHICS_FORCED_VIDEO_MODE_FLAG 0x01

#define	BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG 0x02

#define	BL_HT_VALUE_IS_INLINE 0x01

#define	BL_FS_REGISTER_AT_HEAD_FLAG 1

#define	BL_BLOCK_DEVICE_REMOVABLE_FLAG 0x01

#define	BL_BLOCK_DEVICE_PRESENT_FLAG 0x02

#define	BL_BLOCK_DEVICE_VIRTUAL_FLAG 0x04

#define	BL_MEMORY_CLASS_SHIFT 28

#define	BL_FILE_READ_ACCESS 0x01

#define	BL_FILE_WRITE_ACCESS 0x02

#define	BL_DIRECTORY_ACCESS 0x04

#define	BL_UNKNOWN_ACCESS 0x10

#define	BL_DEVICE_READ_ACCESS 0x01

#define	BL_DEVICE_WRITE_ACCESS 0x02

#define	BL_DEVICE_ENTRY_OPENED 0x01

#define	BL_DEVICE_ENTRY_READ_ACCESS 0x02

#define	BL_DEVICE_ENTRY_WRITE_ACCESS 0x04

#define	BL_FILE_ENTRY_OPENED 0x01

#define	BL_FILE_ENTRY_READ_ACCESS 0x02

#define	BL_FILE_ENTRY_WRITE_ACCESS 0x04

#define	BL_FILE_ENTRY_UNKNOWN_ACCESS 0x10

#define	BL_FILE_ENTRY_DIRECTORY 0x10000

#define	BL_ETFS_FILE_ENTRY_DIRECTORY 0x01

#define	BL_IMG_VALID_FILE 0x01

#define	BL_IMG_MEMORY_FILE 0x02

#define	BL_IMG_REMOTE_FILE 0x04

#define	BL_LOAD_IMG_VIRTUAL_BUFFER 0x01

#define	BL_LOAD_IMG_EXISTING_BUFFER 0x04

#define	BL_LOAD_IMG_UNKNOWN_BUFFER_FLAG 0x08

#define	BL_LOAD_IMG_COMPUTE_SIGNATURE 0x10

#define	BL_LOAD_IMG_COMPUTE_HASH 0x40000

#define	BL_LOAD_PE_IMG_VIRTUAL_BUFFER BL_LOAD_IMG_VIRTUAL_BUFFER

#define	BL_LOAD_PE_IMG_CHECK_MACHINE 0x02

#define	BL_LOAD_PE_IMG_EXISTING_BUFFER BL_LOAD_IMG_EXISTING_BUFFER

#define	BL_LOAD_PE_IMG_COMPUTE_HASH 0x10

#define	BL_LOAD_PE_IMG_CHECK_SUBSYSTEM 0x80

#define	BL_LOAD_PE_IMG_SKIP_RELOCATIONS 0x100

#define	BL_LOAD_PE_IMG_CHECK_FORCED_INTEGRITY 0x200

#define	BL_LOAD_PE_IMG_IGNORE_CHECKSUM_MISMATCH 0x10000

#define	BL_LOAD_PE_IMG_VALIDATE_ORIGINAL_FILENAME 0x400000

#define	BL_UTL_CHECKSUM_COMPLEMENT 0x10000

#define	BL_UTL_CHECKSUM_ROTATE 0x20000

#define	BL_UTL_CHECKSUM_NEGATE 0x40000

#define	BL_UTL_CHECKSUM_UCHAR_BUFFER 0x01

#define	BL_UTL_CHECKSUM_USHORT_BUFFER 0x02

Typedefs
typedef enum _BL_COLOR	BL_COLOR

typedef enum _BL_COLOR *	PBL_COLOR

typedef enum _BL_MENU_POLICY	BL_MENU_POLICY

typedef enum _BL_MEMORY_DESCRIPTOR_TYPE	BL_MEMORY_DESCRIPTOR_TYPE

typedef enum _BL_TRANSLATION_TYPE	BL_TRANSLATION_TYPE

typedef enum _BL_ARCH_MODE	BL_ARCH_MODE

typedef enum _BL_DEVICE_TYPE	BL_DEVICE_TYPE

typedef enum _BL_LOCAL_DEVICE_TYPE	BL_LOCAL_DEVICE_TYPE

typedef enum _BL_PARTITION_TYPE	BL_PARTITION_TYPE

typedef enum _BL_PATH_TYPE	BL_PATH_TYPE

typedef enum _BL_MEMORY_CLASS	BL_MEMORY_CLASS

typedef enum _BL_MEMORY_TYPE	BL_MEMORY_TYPE

typedef enum _BL_MEMORY_ATTR	BL_MEMORY_ATTR

typedef NTSTATUS(*	PBL_FILE_OPEN) (_In_ struct _BL_FILE_ENTRY Directory, _In_ PWCHAR FileName, _In_ ULONG Flags, _Out_ struct _BL_FILE_ENTRY *FileEntry)

typedef NTSTATUS(*	PBL_FILE_CLOSE) (_In_ struct _BL_FILE_ENTRY *FileEntry)

typedef NTSTATUS(*	PBL_FILE_READ) (_In_ struct _BL_FILE_ENTRY *FileEntry, _In_ PVOID Buffer, _In_ ULONG Size, _Out_opt_ PULONG BytesRead)

typedef NTSTATUS(*	PBL_FILE_WRITE) (VOID)

typedef NTSTATUS(*	PBL_FILE_GET_NEXT) (VOID)

typedef NTSTATUS(*	PBL_FILE_GET_INFO) (_In_ struct _BL_FILE_ENTRY FileEntry, _Out_ struct _BL_FILE_INFORMATION FileInfo)

typedef NTSTATUS(*	PBL_FILE_SET_INFO) (_In_ struct _BL_FILE_ENTRY FileEntry, _In_ struct _BL_FILE_INFORMATION FileInfo)

typedef NTSTATUS(*	PBL_FS_INIT_CALLBACK) (VOID)

typedef NTSTATUS(*	PBL_FS_DESTROY_CALLBACK) (VOID)

typedef NTSTATUS(*	PBL_FS_MOUNT_CALLBACK) (_In_ ULONG DeviceId, _In_ ULONG Unknown, _Out_ struct _BL_FILE_ENTRY **FileEntry)

typedef NTSTATUS(*	PBL_FS_PURGE_CALLBACK) (VOID)

typedef NTSTATUS(*	PBL_FILE_DESTROY_CALLBACK) (_In_ PVOID Entry)

typedef VOID(*	PCONSOLE_DESTRUCT) (_In_ struct _BL_TEXT_CONSOLE *Console)

typedef NTSTATUS(*	PCONSOLE_REINITIALIZE) (_In_ struct _BL_TEXT_CONSOLE *Console)

typedef NTSTATUS(*	PCONSOLE_GET_TEXT_STATE) (_In_ struct _BL_TEXT_CONSOLE Console, _Out_ struct _BL_DISPLAY_STATE TextState)

typedef NTSTATUS(*	PCONSOLE_SET_TEXT_STATE) (_In_ struct _BL_TEXT_CONSOLE Console, _In_ ULONG Flags, _In_ struct _BL_DISPLAY_STATE TextState)

typedef NTSTATUS(*	PCONSOLE_GET_TEXT_RESOLUTION) (_In_ struct _BL_TEXT_CONSOLE *Console, _Out_ PULONG TextResolution)

typedef NTSTATUS(*	PCONSOLE_SET_TEXT_RESOLUTION) (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ ULONG NewTextResolution, _Out_ PULONG OldTextResolution)

typedef NTSTATUS(*	PCONSOLE_CLEAR_TEXT) (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ BOOLEAN LineOnly)

typedef BOOLEAN(*	PCONSOLE_IS_ENABLED) (_In_ struct _BL_GRAPHICS_CONSOLE *Console)

typedef NTSTATUS(*	PCONSOLE_GET_GRAPHICAL_RESOLUTION) (_In_ struct _BL_GRAPHICS_CONSOLE Console, _Out_ struct _BL_DISPLAY_MODE DisplayMode)

typedef NTSTATUS(*	PCONSOLE_SET_GRAPHICAL_RESOLUTION) (_In_ struct _BL_GRAPHICS_CONSOLE *Console, _In_ struct _BL_DISPLAY_MODE DisplayMode)

typedef NTSTATUS(*	PCONSOLE_ENABLE) (_In_ struct _BL_GRAPHICS_CONSOLE *Console, _In_ BOOLEAN Enable)

typedef NTSTATUS(*	PCONSOLE_WRITE_TEXT) (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ PCHAR Text, _In_ ULONG Attribute)

typedef BOOLEAN(*	PBL_TBL_LOOKUP_ROUTINE) (_In_ PVOID Entry, _In_ PVOID Argument1, _In_ PVOID Argument2, _In_ PVOID Argument3, _In_ PVOID Argument4)

typedef NTSTATUS(*	PBL_TBL_MAP_ROUTINE) (_In_ PVOID Entry, _In_ ULONG EntryIndex)

typedef NTSTATUS(*	PBL_TBL_SET_ROUTINE) (_In_ PVOID Entry)

typedef NTSTATUS(*	PBL_IO_DESTROY_ROUTINE) (VOID)

typedef BOOLEAN(*	PBL_HASH_TABLE_COMPARE_FUNCTION) (_In_ struct _BL_HASH_ENTRY Entry1, _In_ struct _BL_HASH_ENTRY Entry2)

typedef ULONG(*	PBL_HASH_TABLE_HASH_FUNCTION) (_In_ struct _BL_HASH_ENTRY *Entry, _In_ ULONG TableSize)

typedef NTSTATUS(*	PBL_DEVICE_ENUMERATE_DEVICE_CLASS) (VOID)

typedef NTSTATUS(*	PBL_DEVICE_OPEN) (_In_ struct _BL_DEVICE_DESCRIPTOR Device, _In_ struct _BL_DEVICE_ENTRY DeviceEntry)

typedef NTSTATUS(*	PBL_DEVICE_CLOSE) (_In_ struct _BL_DEVICE_ENTRY *DeviceEntry)

typedef NTSTATUS(*	PBL_DEVICE_READ) (_In_ struct _BL_DEVICE_ENTRY *DeviceEntry, _In_ PVOID Buffer, _In_ ULONG Size, _Out_ PULONG BytesRead)

typedef NTSTATUS(*	PBL_DEVICE_WRITE) (VOID)

typedef NTSTATUS(*	PBL_DEVICE_GET_INFORMATION) (_In_ struct _BL_DEVICE_ENTRY DeviceEntry, _Out_ struct _BL_DEVICE_INFORMATION DeviceInformation)

typedef NTSTATUS(*	PBL_DEVICE_SET_INFORMATION) (_In_ struct _BL_DEVICE_ENTRY DeviceEntry, _In_ struct _BL_DEVICE_INFORMATION DeviceInformation)

typedef NTSTATUS(*	PBL_DEVICE_RESET) (VOID)

typedef NTSTATUS(*	PBL_DEVICE_FLUSH) (VOID)

typedef NTSTATUS(*	PBL_DEVICE_CREATE) (VOID)

typedef VOID(*	PBL_MM_FLUSH_TLB) (VOID)

typedef VOID(*	PBL_MM_RELOCATE_SELF_MAP) (VOID)

typedef NTSTATUS(*	PBL_MM_MOVE_VIRTUAL_ADDRESS_RANGE) (_In_ PVOID DestinationAddress, _In_ PVOID SourceAddress, _In_ ULONGLONG Size)

typedef NTSTATUS(*	PBL_MM_ZERO_VIRTUAL_ADDRESS_RANGE) (_In_ PVOID DestinationAddress, _In_ ULONGLONG Size)

typedef VOID(*	PBL_MM_DESTROY_SELF_MAP) (VOID)

typedef VOID(*	PBL_MM_FLUSH_TLB_ENTRY) (_In_ PVOID VirtualAddress)

typedef NTSTATUS(*	PBL_MM_UNMAP_VIRTUAL_ADDRESS) (_In_ PVOID VirtualAddress, _In_ ULONG Size)

typedef NTSTATUS(*	PBL_MM_REMAP_VIRTUAL_ADDRESS) (_In_ PPHYSICAL_ADDRESS PhysicalAddress, _Out_ PVOID VirtualAddress, _In_ ULONG Size, _In_ ULONG CacheAttributes)

typedef NTSTATUS(*	PBL_MM_MAP_PHYSICAL_ADDRESS) (_In_ PHYSICAL_ADDRESS PhysicalAddress, _Out_ PVOID VirtualAddress, _In_ ULONG Size, _In_ ULONG CacheAttributes)

typedef BOOLEAN(*	PBL_MM_TRANSLATE_VIRTUAL_ADDRESS) (_In_ PVOID VirtualAddress, _Out_ PPHYSICAL_ADDRESS PhysicalAddress, _Out_opt_ PULONG CacheAttributes)

typedef NTSTATUS(*	PBL_STATUS_ERROR_HANDLER) (_In_ ULONG ErrorCode, _In_ ULONG Parameter1, _In_ ULONG_PTR Parameter2, _In_ ULONG_PTR Parameter3, _In_ ULONG_PTR Parameter4)

typedef struct _BL_LIBRARY_PARAMETERS	BL_LIBRARY_PARAMETERS

typedef struct _BL_LIBRARY_PARAMETERS *	PBL_LIBRARY_PARAMETERS

typedef struct _BOOT_APPLICATION_PARAMETER_BLOCK	BOOT_APPLICATION_PARAMETER_BLOCK

typedef struct _BOOT_APPLICATION_PARAMETER_BLOCK *	PBOOT_APPLICATION_PARAMETER_BLOCK

typedef struct _BL_MEMORY_DATA	BL_MEMORY_DATA

typedef struct _BL_MEMORY_DATA *	PBL_MEMORY_DATA

typedef struct _BL_FIRMWARE_DESCRIPTOR	BL_FIRMWARE_DESCRIPTOR

typedef struct _BL_FIRMWARE_DESCRIPTOR *	PBL_FIRMWARE_DESCRIPTOR

typedef struct _BL_RETURN_ARGUMENTS	BL_RETURN_ARGUMENTS

typedef struct _BL_RETURN_ARGUMENTS *	PBL_RETURN_ARGUMENTS

typedef struct _BL_MEMORY_DESCRIPTOR	BL_MEMORY_DESCRIPTOR

typedef struct _BL_MEMORY_DESCRIPTOR *	PBL_MEMORY_DESCRIPTOR

typedef struct _BL_BCD_OPTION	BL_BCD_OPTION

typedef struct _BL_BCD_OPTION *	PBL_BCD_OPTION

typedef struct _BL_APPLICATION_ENTRY	BL_APPLICATION_ENTRY

typedef struct _BL_APPLICATION_ENTRY *	PBL_APPLICATION_ENTRY

typedef struct _BL_LOADED_APPLICATION_ENTRY	BL_LOADED_APPLICATION_ENTRY

typedef struct _BL_LOADED_APPLICATION_ENTRY *	PBL_LOADED_APPLICATION_ENTRY

typedef struct _BL_MENU_STATUS	BL_MENU_STATUS

typedef struct _BL_MENU_STATUS *	PL_MENU_STATUS

typedef enum _BL_BOOT_ERROR_STATUS	BL_BOOT_ERROR_STATUS

typedef struct _BL_HARDDISK_DEVICE	BL_HARDDISK_DEVICE

typedef struct _BL_LOCAL_DEVICE	BL_LOCAL_DEVICE

typedef struct _BL_LOCAL_DEVICE *	PBL_LOCAL_DEVICE

typedef struct _BL_DEVICE_DESCRIPTOR	BL_DEVICE_DESCRIPTOR

typedef struct _BL_DEVICE_DESCRIPTOR *	PBL_DEVICE_DESCRIPTOR

typedef struct _BL_FILE_PATH_DESCRIPTOR	BL_FILE_PATH_DESCRIPTOR

typedef struct _BL_FILE_PATH_DESCRIPTOR *	PBL_FILE_PATH_DESCRIPTOR

typedef struct _BL_WINDOWS_LOAD_OPTIONS	BL_WINDOWS_LOAD_OPTIONS

typedef struct _BL_WINDOWS_LOAD_OPTIONS *	PBL_WINDOWS_LOAD_OPTIONS

typedef struct _BL_ARCH_CONTEXT	BL_ARCH_CONTEXT

typedef struct _BL_ARCH_CONTEXT *	PBL_ARCH_CONTEXT

typedef struct _BL_MEMORY_DESCRIPTOR_LIST	BL_MEMORY_DESCRIPTOR_LIST

typedef struct _BL_MEMORY_DESCRIPTOR_LIST *	PBL_MEMORY_DESCRIPTOR_LIST

typedef struct _BL_ADDRESS_RANGE	BL_ADDRESS_RANGE

typedef struct _BL_ADDRESS_RANGE *	PBL_ADDRESS_RANGE

typedef struct _BL_FILE_INFORMATION	BL_FILE_INFORMATION

typedef struct _BL_FILE_INFORMATION *	PBL_FILE_INFORMATION

typedef struct _BL_FILE_CALLBACKS	BL_FILE_CALLBACKS

typedef struct _BL_FILE_CALLBACKS *	PBL_FILE_CALLBACKS

typedef struct _BL_FILE_ENTRY	BL_FILE_ENTRY

typedef struct _BL_FILE_ENTRY *	PBL_FILE_ENTRY

typedef struct _BL_FILE_SYSTEM_ENTRY	BL_FILE_SYSTEM_ENTRY

typedef struct _BL_FILE_SYSTEM_ENTRY *	PBL_FILE_SYSTEM_ENTRY

typedef struct _BL_FILE_SYSTEM_REGISTRATION_TABLE	BL_FILE_SYSTEM_REGISTRATION_TABLE

typedef struct _BL_DISPLAY_STATE	BL_DISPLAY_STATE

typedef struct _BL_DISPLAY_STATE *	PBL_DISPLAY_STATE

typedef struct _BL_DISPLAY_MODE	BL_DISPLAY_MODE

typedef struct _BL_DISPLAY_MODE *	PBL_DISPLAY_MODE

typedef struct _BL_TEXT_CONSOLE_VTABLE	BL_TEXT_CONSOLE_VTABLE

typedef struct _BL_TEXT_CONSOLE_VTABLE *	PBL_TEXT_CONSOLE_VTABLE

typedef struct _BL_GRAPHICS_CONSOLE_VTABLE	BL_GRAPHICS_CONSOLE_VTABLE

typedef struct _BL_GRAPHICS_CONSOLE_VTABLE *	PBL_GRAPHICS_CONSOLE_VTABLE

typedef struct _BL_TEXT_CONSOLE	BL_TEXT_CONSOLE

typedef struct _BL_TEXT_CONSOLE *	PBL_TEXT_CONSOLE

typedef struct _BL_INPUT_CONSOLE_VTABLE	BL_INPUT_CONSOLE_VTABLE

typedef struct _BL_INPUT_CONSOLE_VTABLE *	PBL_INPUT_CONSOLE_VTABLE

typedef struct _BL_INPUT_CONSOLE	BL_INPUT_CONSOLE

typedef struct _BL_INPUT_CONSOLE *	PBL_INPUT_CONSOLE

typedef enum _BL_GRAPHICS_CONSOLE_TYPE	BL_GRAPHICS_CONSOLE_TYPE

typedef struct _BL_GRAPHICS_CONSOLE	BL_GRAPHICS_CONSOLE

typedef struct _BL_GRAPHICS_CONSOLE *	PBL_GRAPHICS_CONSOLE

typedef struct _BL_REMOTE_CONSOLE	BL_REMOTE_CONSOLE

typedef struct _BL_REMOTE_CONSOLE *	PBL_REMOTE_CONSOLE

typedef struct _BL_HASH_TABLE	BL_HASH_TABLE

typedef struct _BL_HASH_TABLE *	PBL_HASH_TABLE

typedef struct _BL_HASH_ENTRY	BL_HASH_ENTRY

typedef struct _BL_HASH_ENTRY *	PBL_HASH_ENTRY

typedef struct _BL_HASH_VALUE	BL_HASH_VALUE

typedef struct _BL_HASH_VALUE *	PBL_HASH_VALUE

typedef struct _BL_HASH_NODE	BL_HASH_NODE

typedef struct _BL_HASH_NODE *	PBL_HASH_NODE

typedef struct _BL_BLOCK_DEVICE_INFORMATION	BL_BLOCK_DEVICE_INFORMATION

typedef struct _BL_BLOCK_DEVICE_INFORMATION *	PBL_BLOCK_DEVICE_INFORMATION

typedef struct _BL_DEVICE_INFORMATION	BL_DEVICE_INFORMATION

typedef struct _BL_DEVICE_INFORMATION *	PBL_DEVICE_INFORMATION

typedef struct _BL_BLOCK_DEVICE	BL_BLOCK_DEVICE

typedef struct _BL_BLOCK_DEVICE *	PBL_BLOCK_DEVICE

typedef struct _BL_PROTOCOL_HANDLE	BL_PROTOCOL_HANDLE

typedef struct _BL_PROTOCOL_HANDLE *	PBL_PROTOCOL_HANDLE

typedef struct _BL_DEVICE_CALLBACKS	BL_DEVICE_CALLBACKS

typedef struct _BL_DEVICE_CALLBACKS *	PBL_DEVICE_CALLBACKS

typedef struct _BL_DEVICE_ENTRY	BL_DEVICE_ENTRY

typedef struct _BL_DEVICE_ENTRY *	PBL_DEVICE_ENTRY

typedef struct _BL_IMG_FILE	BL_IMG_FILE

typedef struct _BL_IMG_FILE *	PBL_IMG_FILE

typedef struct _BL_IMAGE_APPLICATION_ENTRY	BL_IMAGE_APPLICATION_ENTRY

typedef struct _BL_IMAGE_APPLICATION_ENTRY *	PBL_IMAGE_APPLICATION_ENTRY

typedef struct _BL_BUFFER_DESCRIPTOR	BL_BUFFER_DESCRIPTOR

typedef struct _BL_BUFFER_DESCRIPTOR *	PBL_BUFFER_DESCRIPTOR

typedef struct _BL_DEFERRED_FONT_FILE	BL_DEFERRED_FONT_FILE

typedef struct _BL_DEFERRED_FONT_FILE *	PBL_DEFERRED_FONT_FILE

typedef struct _BMP_HEADER	BMP_HEADER

typedef struct _BMP_HEADER *	PBMP_HEADER

typedef struct _DIB_HEADER	DIB_HEADER

typedef struct _DIB_HEADER *	PDIB_HEADER

typedef struct _BITMAP	BITMAP

typedef struct _BITMAP *	PBITMAP

typedef struct _COORD	COORD

typedef struct _COORD *	PCOORD

typedef struct _BL_PD_DATA_BLOB	BL_PD_DATA_BLOB

typedef struct _BL_PD_DATA_BLOB *	PBL_PD_DATA_BLOB

Enumerations
enum	_BL_COLOR { Black , Blue , Green , Cyan , Red , Magenta , Brown , LtGray , Gray , LtBlue , LtGreen , LtCyan , LtRed , LtMagenta , Yellow , White }

enum	_BL_MENU_POLICY { MenuPolicyLegacy = 0 , MenuPolicyStandard = 1 }

enum	_BL_MEMORY_DESCRIPTOR_TYPE { BlMdPhysical , BlMdVirtual , BlMdTracker }

enum	_BL_TRANSLATION_TYPE { BlNone , BlVirtual , BlPae , BlMax }

enum	_BL_ARCH_MODE { BlProtectedMode , BlRealMode }

enum	_BL_DEVICE_TYPE { DiskDevice = 0 , LegacyPartitionDevice = 2 , SerialDevice = 3 , UdpDevice = 4 , BootDevice = 5 , PartitionDevice = 6 , LocateDevice = 8 }

enum	_BL_LOCAL_DEVICE_TYPE { LocalDevice = 0 , FloppyDevice = 1 , CdRomDevice = 2 , RamDiskDevice = 3 , FileDevice = 5 , VirtualDiskDevice = 6 }

enum	_BL_PARTITION_TYPE { GptPartition , MbrPartition , RawPartition }

enum	_BL_PATH_TYPE { InternalPath = 3 , EfiPath = 4 }

enum	_BL_MEMORY_CLASS { BlLoaderClass = 0xD , BlApplicationClass , BlSystemClass }

enum	_BL_MEMORY_TYPE { BlLoaderMemory = 0xD0000002 , BlLoaderDeviceMemory = 0xD0000004 , BlLoaderHeap = 0xD0000005 , BlLoaderPageDirectory = 0xD0000006 , BlLoaderReferencePage = 0xD0000007 , BlLoaderRamDisk = 0xD0000008 , BlLoaderArchData = 0xD0000009 , BlLoaderData = 0xD000000A , BlLoaderRegistry = 0xD000000B , BlLoaderBlockMemory = 0xD000000C , BlLoaderSelfMap = 0xD000000F , BlApplicationReserved = 0xE0000001 , BlApplicationData = 0xE0000004 , BlConventionalMemory = 0xF0000001 , BlUnusableMemory = 0xF0000002 , BlReservedMemory = 0xF0000003 , BlEfiBootMemory = 0xF0000004 , BlConventionalZeroedMemory = 0xF000005 , BlEfiRuntimeCodeMemory = 0xF0000006 , BlAcpiReclaimMemory = 0xF0000008 , BlAcpiNvsMemory = 0xF0000009 , BlDeviceIoMemory = 0xF000000A , BlDevicePortMemory = 0xF000000B , BlPalMemory = 0xF000000C , BlEfiRuntimeDataMemory = 0xF000000E }

enum	_BL_MEMORY_ATTR { BlMemoryUncached = 0x00000001 , BlMemoryWriteCombined = 0x00000002 , BlMemoryWriteThrough = 0x00000004 , BlMemoryWriteBack = 0x00000008 , BlMemoryUncachedExported = 0x00000010 , BlMemoryValidCacheAttributes = BlMemoryUncached \| BlMemoryWriteCombined \| BlMemoryWriteThrough \| BlMemoryWriteBack \| BlMemoryUncachedExported , BlMemoryValidCacheAttributeMask = 0x000000FF , BlMemoryWriteProtected = 0x00000100 , BlMemoryReadProtected = 0x00000200 , BlMemoryExecuteProtected = 0x00000400 , BlMemoryValidProtectionAttributes = BlMemoryWriteProtected \| BlMemoryReadProtected \| BlMemoryExecuteProtected , BlMemoryValidProtectionAttributeMask = 0x0000FF00 , BlMemoryLargePages = 0x00010000 , BlMemoryKernelRange = 0x00020000 , BlMemoryFixed = 0x00040000 , BlMemoryBelow1MB = 0x00080000 , BlMemoryValidAllocationAttributes = BlMemoryKernelRange \| BlMemoryFixed \| BlMemoryBelow1MB \| BlMemoryLargePages , BlMemoryValidAllocationAttributeMask = 0x00FF0000 , BlMemoryRuntime = 0x01000000 , BlMemoryCoalesced = 0x02000000 , BlMemoryUpdate = 0x04000000 , BlMemoryNonFirmware = 0x08000000 , BlMemoryPersistent = 0x10000000 , BlMemorySpecial = 0x20000000 , BlMemoryFirmware = 0x80000000 , BlMemoryValidTypeAttributes = BlMemoryRuntime \| BlMemoryCoalesced \| BlMemoryUpdate \| BlMemoryNonFirmware \| BlMemoryPersistent \| BlMemorySpecial \| BlMemoryFirmware , BlMemoryValidTypeAttributeMask = 0xFF000000 }

enum	_BL_BOOT_ERROR_STATUS { Reboot = 1 , Recover = 2 , RecoverOem = 3 , OsSelection = 4 , NextOs = 5 , TryAgain = 6 , AdvancedOptions = 7 , BootOptions = 8 }

enum	_BL_GRAPHICS_CONSOLE_TYPE { BlGopConsole , BlUgaConsole }

Functions
	DEFINE_GUID (BadMemoryGuid, 0x54B8275B, 0xD431, 0x473F, 0xAC, 0xFB, 0xE5, 0x36, 0xA0, 0x84, 0x94, 0xA3)

	C_ASSERT (BL_MM_INCLUDE_NO_FIRMWARE_MEMORY==0x1BF)

	C_ASSERT (BL_MM_INCLUDE_ONLY_FIRMWARE_MEMORY==0x240)

FORCEINLINE VOID	BlSetupDefaultParameters (_Out_ PBL_LIBRARY_PARAMETERS LibraryParameters)

FORCEINLINE VOID	MmMdInitializeListHead (_In_ PBL_MEMORY_DESCRIPTOR_LIST List)

FORCEINLINE PVOID	PhysicalAddressToPtr (_In_ PHYSICAL_ADDRESS PhysicalAddress)

NTSTATUS	BlInitializeLibrary (_In_ PBOOT_APPLICATION_PARAMETER_BLOCK BootAppParameters, _In_ PBL_LIBRARY_PARAMETERS LibraryParameters)

NTSTATUS	BlpArchInitialize (_In_ ULONG Phase)

NTSTATUS	BlpFwInitialize (_In_ ULONG Phase, _In_ PBL_FIRMWARE_DESCRIPTOR FirmwareParameters)

NTSTATUS	BlpMmInitialize (_In_ PBL_MEMORY_DATA MemoryData, _In_ BL_TRANSLATION_TYPE TranslationType, _In_ PBL_LIBRARY_PARAMETERS LibraryParameters)

NTSTATUS	MmBaInitialize (VOID)

NTSTATUS	MmPaInitialize (_In_ PBL_MEMORY_DATA MemoryData, _In_ ULONG MinimumPages)

NTSTATUS	MmArchInitialize (_In_ ULONG Phase, _In_ PBL_MEMORY_DATA MemoryData, _In_ BL_TRANSLATION_TYPE TranslationType, _In_ BL_TRANSLATION_TYPE LibraryTranslationType)

NTSTATUS	MmHaInitialize (_In_ ULONG HeapSize, _In_ ULONG HeapAttributes)

VOID	MmMdInitialize (_In_ ULONG Phase, _In_ PBL_LIBRARY_PARAMETERS LibraryParameters)

NTSTATUS	BlpDeviceInitialize (VOID)

NTSTATUS	BlpIoInitialize (VOID)

NTSTATUS	BlpFileInitialize (VOID)

NTSTATUS	BlpDisplayInitialize (_In_ ULONG Flags)

NTSTATUS	BlpDisplayReinitialize (VOID)

VOID	BlDestroyLibrary (VOID)

NTSTATUS	BcInitialize (VOID)

VOID	EfiPrintf (_In_ PWCHAR Format,...)

NTSTATUS	BlFwGetParameters (_In_ PBL_FIRMWARE_DESCRIPTOR Parameters)

NTSTATUS	BlFwEnumerateDevice (_In_ PBL_DEVICE_DESCRIPTOR Device)

NTSTATUS	EfiAllocatePages (_In_ ULONG Type, _In_ ULONG Pages, _Inout_ EFI_PHYSICAL_ADDRESS *Memory)

NTSTATUS	EfiStall (_In_ ULONG StallTime)

NTSTATUS	EfiConInExReset (VOID)

NTSTATUS	EfiConInReset (VOID)

NTSTATUS	EfiConOutOutputString (_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *TextInterface, _In_ PWCHAR String)

NTSTATUS	EfiConOutQueryMode (_In_ SIMPLE_TEXT_OUTPUT_INTERFACE TextInterface, _In_ ULONG Mode, _In_ UINTN Columns, _In_ UINTN *Rows)

NTSTATUS	EfiConOutSetMode (_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *TextInterface, _In_ ULONG Mode)

VOID	EfiConOutReadCurrentMode (_In_ SIMPLE_TEXT_OUTPUT_INTERFACE TextInterface, _Out_ EFI_SIMPLE_TEXT_OUTPUT_MODE Mode)

NTSTATUS	EfiConOutSetAttribute (_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *TextInterface, _In_ ULONG Attribute)

NTSTATUS	EfiConOutSetCursorPosition (_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *TextInterface, _In_ ULONG Column, _In_ ULONG Row)

NTSTATUS	EfiConOutEnableCursor (_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *TextInterface, _In_ BOOLEAN Visible)

NTSTATUS	EfiLocateHandleBuffer (_In_ EFI_LOCATE_SEARCH_TYPE SearchType, _In_ EFI_GUID Protocol, _Inout_ PULONG HandleCount, _Inout_ EFI_HANDLE *Buffer)

NTSTATUS	EfiOpenProtocol (_In_ EFI_HANDLE Handle, _In_ EFI_GUID Protocol, _Out_ PVOID Interface)

NTSTATUS	EfiCloseProtocol (_In_ EFI_HANDLE Handle, _In_ EFI_GUID *Protocol)

NTSTATUS	EfiGopGetCurrentMode (_In_ EFI_GRAPHICS_OUTPUT_PROTOCOL GopInterface, _Out_ UINTN Mode, _Out_ EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Information)

NTSTATUS	EfiGopSetMode (_In_ EFI_GRAPHICS_OUTPUT_PROTOCOL *GopInterface, _In_ ULONG Mode)

VOID	EfiGopGetFrameBuffer (_In_ EFI_GRAPHICS_OUTPUT_PROTOCOL GopInterface, _Out_ PHYSICAL_ADDRESS FrameBuffer, _Out_ UINTN *FrameBufferSize)

VOID	EfiResetSystem (_In_ EFI_RESET_TYPE ResetType)

EFI_DEVICE_PATH *	EfiGetLeafNode (_In_ EFI_DEVICE_PATH *DevicePath)

EFI_DEVICE_PATH *	EfiIsDevicePathParent (_In_ EFI_DEVICE_PATH DevicePath1, _In_ EFI_DEVICE_PATH DevicePath2)

NTSTATUS	EfipGetRsdt (_Out_ PPHYSICAL_ADDRESS FoundRsdt)

NTSTATUS	EfiFreePages (_In_ ULONG Pages, _In_ EFI_PHYSICAL_ADDRESS PhysicalAddress)

NTSTATUS	BlpTimeCalibratePerformanceCounter (VOID)

ULONGLONG	BlTimeQueryPerformanceCounter (_Out_opt_ PLARGE_INTEGER Frequency)

ULONGLONG	BlArchGetPerformanceCounter (VOID)

NTSTATUS	BlpDisplayRegisterLocale (_In_ PWCHAR Locale)

VOID	BfiFreeDeferredFontFile (_In_ PBL_DEFERRED_FONT_FILE DeferredFontFile)

NTSTATUS	BfLoadFontFile (_In_ PBL_DEVICE_DESCRIPTOR Device, _In_ PWCHAR FontPath)

NTSTATUS	BfLoadDeferredFontFiles (VOID)

NTSTATUS	BfClearScreen (_In_ PBL_GRAPHICS_CONSOLE Console)

NTSTATUS	BfClearToEndOfLine (_In_ PBL_GRAPHICS_CONSOLE Console)

NTSTATUS	FatInitialize (VOID)

NTSTATUS	FatMount (_In_ ULONG DeviceId, _In_ ULONG Unknown, _Out_ PBL_FILE_ENTRY *FileEntry)

NTSTATUS	EtfsInitialize (VOID)

NTSTATUS	EtfsMount (_In_ ULONG DeviceId, _In_ ULONG Unknown, _Out_ PBL_FILE_ENTRY *FileEntry)

BOOLEAN	BlBdDebuggerEnabled (VOID)

NTSTATUS	BlBdPullRemoteFile (_In_ PWCHAR FilePath, _Out_ PVOID BaseAddress, _Out_ PULONGLONG FileSize)

VOID	BlStatusPrint (_In_ PCWCH Format,...)

VOID	BlStatusError (_In_ ULONG ErrorCode, _In_ ULONG Parameter1, _In_ ULONG_PTR Parameter2, _In_ ULONG_PTR Parameter3, _In_ ULONG_PTR Parameter4)

VOID	BlArchCpuId (_In_ ULONG Function, _In_ ULONG SubFunction, _Out_ PCPU_INFO Result)

CPU_VENDORS	BlArchGetCpuVendor (VOID)

BOOLEAN	BlArchIsCpuIdFunctionSupported (_In_ ULONG Function)

VOID	BlUtlUpdateProgress (_In_ ULONG Percentage, _Out_opt_ PBOOLEAN Completed)

NTSTATUS	BlUtlGetAcpiTable (_Out_ PVOID *TableAddress, _In_ ULONG Signature)

NTSTATUS	BlUtlInitialize (VOID)

NTSTATUS	BlUtlRegisterProgressRoutine (VOID)

ULONG	BlUtlCheckSum (_In_ ULONG PartialSum, _In_ PUCHAR Buffer, _In_ ULONG Length, _In_ ULONG Flags)

NTSTATUS	BlGetApplicationBaseAndSize (_Out_ PVOID *ImageBase, _Out_ PULONG ImageSize)

VOID	BlDestroyBootEntry (_In_ PBL_LOADED_APPLICATION_ENTRY AppEntry)

NTSTATUS	BlPdQueryData (_In_ const GUID *DataGuid, _In_ PVOID Unknown, _Inout_ PBL_PD_DATA_BLOB DataBlob)

EFI_STATUS	EfiGetEfiStatusCode (_In_ NTSTATUS Status)

NTSTATUS	EfiGetNtStatusCode (_In_ EFI_STATUS EfiStatus)

VOID	BlFwReboot (VOID)

NTSTATUS	MmFwFreePages (_In_ ULONG BasePage, _In_ ULONG PageCount)

PGUID	BlGetApplicationIdentifier (VOID)

NTSTATUS	BlpSecureBootEFIIsEnabled (VOID)

NTSTATUS	BlSecureBootIsEnabled (_Out_ PBOOLEAN SecureBootEnabled)

NTSTATUS	BlSecureBootCheckForFactoryReset (VOID)

PWCHAR	BlResourceFindMessage (_In_ ULONG MsgId)

PWCHAR	BlResourceFindHtml (VOID)

NTSTATUS	BlpResourceInitialize (VOID)

NTSTATUS	BlTblMap (_In_ PVOID *Table, _In_ ULONG Count, _In_ PBL_TBL_MAP_ROUTINE MapCallback)

PVOID	BlTblFindEntry (_In_ PVOID *Table, _In_ ULONG Count, _Out_ PULONG EntryIndex, _In_ PBL_TBL_LOOKUP_ROUTINE Callback, _In_ PVOID Argument1, _In_ PVOID Argument2, _In_ PVOID Argument3, _In_ PVOID Argument4)

NTSTATUS	BlTblSetEntry (_Inout_ PVOID **Table, _Inout_ PULONG Count, _In_ PVOID Entry, _Out_ PULONG EntryIndex, _In_ PBL_TBL_SET_ROUTINE Callback)

NTSTATUS	TblDoNotPurgeEntry (_In_ PVOID Entry)

NTSTATUS	BlHtStore (_In_ ULONG TableId, _In_ PBL_HASH_ENTRY Entry, _In_ PVOID Data, _In_ ULONG DataSize)

NTSTATUS	BlHtDelete (_In_ ULONG TableId, _In_ PBL_HASH_ENTRY Entry)

NTSTATUS	BlHtLookup (_In_ ULONG TableId, _In_ PBL_HASH_ENTRY Entry, _Out_ PBL_HASH_VALUE *Value)

NTSTATUS	BlHtCreate (_In_ ULONG Size, _In_ PBL_HASH_TABLE_HASH_FUNCTION HashFunction, _In_ PBL_HASH_TABLE_COMPARE_FUNCTION CompareFunction, _Out_ PULONG Id)

PBL_BCD_OPTION	MiscGetBootOption (_In_ PBL_BCD_OPTION List, _In_ ULONG Type)

ULONG	BlGetBootOptionListSize (_In_ PBL_BCD_OPTION BcdOption)

ULONG	BlGetBootOptionSize (_In_ PBL_BCD_OPTION BcdOption)

NTSTATUS	BlGetBootOptionString (_In_ PBL_BCD_OPTION List, _In_ ULONG Type, _Out_ PWCHAR *Value)

NTSTATUS	BlGetBootOptionInteger (_In_ PBL_BCD_OPTION List, _In_ ULONG Type, _Out_ PULONGLONG Value)

NTSTATUS	BlGetBootOptionBoolean (_In_ PBL_BCD_OPTION List, _In_ ULONG Type, _Out_ PBOOLEAN Value)

NTSTATUS	BlpGetBootOptionIntegerList (_In_ PBL_BCD_OPTION List, _In_ ULONG Type, _Out_ PULONGLONG *Value, _Out_ PULONGLONG Count, _In_ BOOLEAN NoCopy)

NTSTATUS	BlGetBootOptionDevice (_In_ PBL_BCD_OPTION List, _In_ ULONG Type, _Out_ PBL_DEVICE_DESCRIPTOR Value, _In_opt_ PBL_BCD_OPTION ExtraOptions)

NTSTATUS	BlGetBootOptionGuid (_In_ PBL_BCD_OPTION List, _In_ ULONG Type, _Out_ PGUID Value)

NTSTATUS	BlGetBootOptionGuidList (_In_ PBL_BCD_OPTION List, _In_ ULONG Type, _Out_ PGUID *Value, _In_ PULONG Count)

NTSTATUS	BlCopyBootOptions (_In_ PBL_BCD_OPTION OptionList, _Out_ PBL_BCD_OPTION *CopiedOptions)

NTSTATUS	BlAppendBootOptionBoolean (_In_ PBL_LOADED_APPLICATION_ENTRY AppEntry, _In_ ULONG OptionId, _In_ BOOLEAN Value)

NTSTATUS	BlAppendBootOptionInteger (_In_ PBL_LOADED_APPLICATION_ENTRY AppEntry, _In_ ULONG OptionId, _In_ ULONGLONG Value)

NTSTATUS	BlAppendBootOptionString (_In_ PBL_LOADED_APPLICATION_ENTRY AppEntry, _In_ ULONG OptionId, _In_ PWCHAR OptionString)

NTSTATUS	BlAppendBootOptions (_In_ PBL_LOADED_APPLICATION_ENTRY AppEntry, _In_ PBL_BCD_OPTION Options)

VOID	BlRemoveBootOption (_In_ PBL_BCD_OPTION List, _In_ ULONG Type)

NTSTATUS	BlReplaceBootOptions (_In_ PBL_LOADED_APPLICATION_ENTRY AppEntry, _In_ PBL_BCD_OPTION NewOptions)

VOID	BiCloseKey (_In_ HANDLE KeyHandle)

NTSTATUS	BiOpenKey (_In_ HANDLE ParentHandle, _In_ PWCHAR KeyName, _Out_ PHANDLE Handle)

NTSTATUS	BiLoadHive (_In_ PBL_FILE_PATH_DESCRIPTOR FilePath, _Out_ PHANDLE HiveHandle)

NTSTATUS	BiGetRegistryValue (_In_ HANDLE KeyHandle, _In_ PWCHAR ValueName, _In_ ULONG Type, _Out_ PVOID *Buffer, _Out_ PULONG ValueLength)

NTSTATUS	BiEnumerateSubKeys (_In_ HANDLE KeyHandle, _Out_ PWCHAR **SubKeyList, _Out_ PULONG SubKeyCount)

NTSTATUS	BiDeleteKey (_In_ HANDLE KeyHandle)

VOID	BiDereferenceHive (_In_ HANDLE KeyHandle)

VOID	BlpArchSwitchContext (_In_ BL_ARCH_MODE NewMode)

VOID	BlpArchEnableTranslation (VOID)

VOID	Archx86TransferTo32BitApplicationAsm (VOID)

VOID	MmMdDbgDumpList (_In_ PBL_MEMORY_DESCRIPTOR_LIST DescriptorList, _In_opt_ ULONG MaxCount)

VOID	MmMdInitializeList (_In_ PBL_MEMORY_DESCRIPTOR_LIST DescriptorList, _In_ ULONG Type, _In_ PLIST_ENTRY ListHead)

PBL_MEMORY_DESCRIPTOR	MmMdFindDescriptor (_In_ ULONG WhichList, _In_ ULONG Flags, _In_ ULONGLONG Page)

PBL_MEMORY_DESCRIPTOR	MmMdFindDescriptorFromMdl (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ ULONG Flags, _In_ ULONGLONG Page)

NTSTATUS	MmMdCopyList (_In_ PBL_MEMORY_DESCRIPTOR_LIST DestinationList, _In_ PBL_MEMORY_DESCRIPTOR_LIST SourceList, _In_opt_ PBL_MEMORY_DESCRIPTOR ListDescriptor, _Out_ PULONG ActualCount, _In_ ULONG Count, _In_ ULONG Flags)

ULONG	MmMdCountList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList)

VOID	MmMdFreeList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList)

PBL_MEMORY_DESCRIPTOR	MmMdInitByteGranularDescriptor (_In_ ULONG Flags, _In_ BL_MEMORY_TYPE Type, _In_ ULONGLONG BasePage, _In_ ULONGLONG VirtualPage, _In_ ULONGLONG PageCount)

VOID	MmMdFreeGlobalDescriptors (VOID)

NTSTATUS	MmMdAddDescriptorToList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PBL_MEMORY_DESCRIPTOR MemoryDescriptor, _In_ ULONG Flags)

NTSTATUS	MmMdTruncateDescriptors (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PBL_MEMORY_DESCRIPTOR_LIST NewList, _In_ ULONGLONG BasePage)

VOID	MmMdRemoveDescriptorFromList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PBL_MEMORY_DESCRIPTOR Entry)

BOOLEAN	MmMdFindSatisfyingRegion (_In_ PBL_MEMORY_DESCRIPTOR Descriptor, _Out_ PBL_MEMORY_DESCRIPTOR NewDescriptor, _In_ ULONGLONG Pages, _In_ PBL_ADDRESS_RANGE BaseRange, _In_ PBL_ADDRESS_RANGE VirtualRange, _In_ BOOLEAN TopDown, _In_ BL_MEMORY_TYPE MemoryType, _In_ ULONG Flags, _In_ ULONG Alignment)

NTSTATUS	MmMdRemoveRegionFromMdlEx (__in PBL_MEMORY_DESCRIPTOR_LIST MdList, __in ULONG Flags, __in ULONGLONG BasePage, __in ULONGLONG PageCount, __in PBL_MEMORY_DESCRIPTOR_LIST NewMdList)

NTSTATUS	MmMdFreeDescriptor (_In_ PBL_MEMORY_DESCRIPTOR MemoryDescriptor)

NTSTATUS	MmPaTruncateMemory (_In_ ULONGLONG BasePage)

NTSTATUS	BlMmAllocatePhysicalPages (_Inout_ PPHYSICAL_ADDRESS Address, _In_ BL_MEMORY_TYPE MemoryType, _In_ ULONGLONG PageCount, _In_ ULONG Attributes, _In_ ULONG Alignment)

NTSTATUS	MmPapAllocatePhysicalPagesInRange (_Inout_ PPHYSICAL_ADDRESS BaseAddress, _In_ BL_MEMORY_TYPE MemoryType, _In_ ULONGLONG Pages, _In_ ULONG Attributes, _In_ ULONG Alignment, _In_ PBL_MEMORY_DESCRIPTOR_LIST NewList, _In_opt_ PBL_ADDRESS_RANGE Range, _In_ ULONG RangeType)

NTSTATUS	MmPaReleaseSelfMapPages (_In_ PHYSICAL_ADDRESS Address)

NTSTATUS	MmPaReserveSelfMapPages (_Inout_ PPHYSICAL_ADDRESS PhysicalAddress, _In_ ULONG Alignment, _In_ ULONG PageCount)

NTSTATUS	BlMmFreePhysicalPages (_In_ PHYSICAL_ADDRESS Address)

NTSTATUS	MmPapFreePages (_In_ PVOID Address, _In_ ULONG WhichList)

NTSTATUS	MmPapAllocatePagesInRange (_Inout_ PVOID *PhysicalAddress, _In_ BL_MEMORY_TYPE MemoryType, _In_ ULONGLONG Pages, _In_ ULONG Attributes, _In_ ULONG Alignment, _In_opt_ PBL_ADDRESS_RANGE Range, _In_ ULONG Type)

NTSTATUS	MmFwGetMemoryMap (_Out_ PBL_MEMORY_DESCRIPTOR_LIST MemoryMap, _In_ ULONG Flags)

NTSTATUS	BlpMmInitializeConstraints (VOID)

NTSTATUS	BlMmRemoveBadMemory (VOID)

NTSTATUS	BlMmGetMemoryMap (_In_ PLIST_ENTRY MemoryMap, _In_ PBL_BUFFER_DESCRIPTOR MemoryParameters, _In_ ULONG WhichTypes, _In_ ULONG Flags)

NTSTATUS	MmSelectMappingAddress (_Out_ PVOID *MappingAddress, _In_ PVOID PreferredAddress, _In_ ULONGLONG Size, _In_ ULONG AllocationAttributes, _In_ ULONG Flags, _In_ PHYSICAL_ADDRESS PhysicalAddress)

NTSTATUS	MmMapPhysicalAddress (_Inout_ PPHYSICAL_ADDRESS PhysicalAddress, _Out_ PVOID *VirtualAddress, _Inout_ PULONGLONG Size, _In_ ULONG CacheAttributes)

NTSTATUS	MmUnmapVirtualAddress (_Inout_ PVOID *VirtualAddress, _Inout_ PULONGLONG Size)

NTSTATUS	BlMmMapPhysicalAddressEx (_In_ PVOID *VirtualAddress, _In_ ULONG Attributes, _In_ ULONGLONG Size, _In_ PHYSICAL_ADDRESS PhysicalAddress)

NTSTATUS	BlMmUnmapVirtualAddressEx (_In_ PVOID VirtualAddress, _In_ ULONGLONG Size)

BOOLEAN	BlMmTranslateVirtualAddress (_In_ PVOID VirtualAddress, _Out_ PPHYSICAL_ADDRESS PhysicalAddress)

BOOLEAN	MmArchTranslateVirtualAddress (_In_ PVOID VirtualAddress, _Out_opt_ PPHYSICAL_ADDRESS PhysicalAddress, _Out_opt_ PULONG CachingFlags)

NTSTATUS	BlpMmCreateBlockAllocator (VOID)

PVOID	BlMmAllocateHeap (_In_ SIZE_T Size)

NTSTATUS	BlMmFreeHeap (_In_ PVOID Buffer)

VOID	BlDisplayGetTextCellResolution (_Out_ PULONG TextWidth, _Out_ PULONG TextHeight)

NTSTATUS	BlDisplaySetScreenResolution (VOID)

NTSTATUS	BlDisplayGetScreenResolution (_Out_ PULONG HRes, _Out_ PULONG Vres)

VOID	BlDisplayInvalidateOemBitmap (VOID)

PBITMAP	BlDisplayGetOemBitmap (_Out_ PCOORD Offset, _Out_opt_ PULONG Flags)

BOOLEAN	BlDisplayValidOemBitmap (VOID)

NTSTATUS	BlDisplayClearScreen (VOID)

NTSTATUS	BlDisplaySetCursorType (_In_ ULONG Type)

NTSTATUS	BlpIoRegisterDestroyRoutine (_In_ PBL_IO_DESTROY_ROUTINE DestroyRoutine)

NTSTATUS	BlDeviceClose (_In_ ULONG DeviceId)

BOOLEAN	BlDeviceIsVirtualPartitionDevice (_In_ PBL_DEVICE_DESCRIPTOR InputDevice, _Outptr_ PBL_DEVICE_DESCRIPTOR *VirtualDevice)

NTSTATUS	BlpDeviceOpen (_In_ PBL_DEVICE_DESCRIPTOR Device, _In_ ULONG Flags, _In_ ULONG Unknown, _Out_ PULONG DeviceId)

NTSTATUS	BlDeviceGetInformation (_In_ ULONG DeviceId, _Out_ PBL_DEVICE_INFORMATION DeviceInformation)

NTSTATUS	BlDeviceSetInformation (_In_ ULONG DeviceId, _In_ PBL_DEVICE_INFORMATION DeviceInformation)

NTSTATUS	BlDeviceReadAtOffset (_In_ ULONG DeviceId, _In_ ULONG Size, _In_ ULONGLONG Offset, _In_ PVOID Buffer, _Out_ PULONG BytesRead)

NTSTATUS	BlImgLoadImageWithProgress2 (_In_ ULONG DeviceId, _In_ BL_MEMORY_TYPE MemoryType, _In_ PWCHAR FileName, _Inout_ PVOID MappedBase, _Inout_ PULONG MappedSize, _In_ ULONG ImageFlags, _In_ BOOLEAN ShowProgress, _Out_opt_ PUCHAR HashBuffer, _Out_opt_ PULONG HashSize)

PIMAGE_SECTION_HEADER	BlImgFindSection (_In_ PVOID ImageBase, _In_ ULONG ImageSize)

NTSTATUS	BlImgLoadBootApplication (_In_ PBL_LOADED_APPLICATION_ENTRY BootEntry, _Out_ PULONG AppHandle)

NTSTATUS	BlImgStartBootApplication (_In_ ULONG AppHandle, _Inout_ PBL_RETURN_ARGUMENTS ReturnArguments)

NTSTATUS	BlImgUnloadBootApplication (_In_ ULONG AppHandle)

VOID	BlImgQueryCodeIntegrityBootOptions (_In_ PBL_LOADED_APPLICATION_ENTRY ApplicationEntry, _Out_ PBOOLEAN IntegrityChecksDisabled, _Out_ PBOOLEAN TestSigning)

NTSTATUS	BlFileClose (_In_ ULONG FileId)

NTSTATUS	BlFileReadAtOffsetEx (_In_ ULONG FileId, _In_ ULONG Size, _In_ ULONGLONG ByteOffset, _In_ PVOID Buffer, _Out_ PULONG BytesReturned, _In_ ULONG Flags)

NTSTATUS	BlFileGetInformation (_In_ ULONG FileId, _In_ PBL_FILE_INFORMATION FileInfo)

NTSTATUS	BlFileOpen (_In_ ULONG DeviceId, _In_ PWCHAR FileName, _In_ ULONG Flags, _Out_ PULONG FileId)

NTSTATUS	BlockIoEfiCompareDevice (_In_ PBL_DEVICE_DESCRIPTOR Device, _In_ EFI_HANDLE Handle)

VOID	ConsoleInputLocalDestruct (_In_ struct _BL_INPUT_CONSOLE *Console)

NTSTATUS	ConsoleInputBaseReinitialize (_In_ struct _BL_INPUT_CONSOLE *Console)

NTSTATUS	ConsoleCreateLocalInputCnsole (VOID)

VOID	ConsoleGraphicalDestruct (_In_ struct _BL_GRAPHICS_CONSOLE *Console)

NTSTATUS	ConsoleGraphicalClearText (_In_ PBL_GRAPHICS_CONSOLE Console, _In_ BOOLEAN LineOnly)

NTSTATUS	ConsoleGraphicalClearPixels (_In_ PBL_GRAPHICS_CONSOLE Console, _In_ ULONG Color)

NTSTATUS	ConsoleGraphicalReinitialize (_In_ struct _BL_GRAPHICS_CONSOLE *Console)

NTSTATUS	ConsoleGraphicalSetTextState (_In_ PBL_GRAPHICS_CONSOLE Console, _In_ ULONG Mask, _In_ PBL_DISPLAY_STATE TextState)

BOOLEAN	ConsoleGraphicalIsEnabled (_In_ struct _BL_GRAPHICS_CONSOLE *Console)

NTSTATUS	ConsoleGraphicalGetGraphicalResolution (_In_ struct _BL_GRAPHICS_CONSOLE *Console, _In_ PBL_DISPLAY_MODE DisplayMode)

NTSTATUS	ConsoleGraphicalGetOriginalResolution (_In_ struct _BL_GRAPHICS_CONSOLE *Console, _In_ PBL_DISPLAY_MODE DisplayMode)

NTSTATUS	ConsoleGraphicalEnable (_In_ struct _BL_GRAPHICS_CONSOLE *Console, _In_ BOOLEAN Enable)

VOID	ConsoleTextLocalDestruct (_In_ struct _BL_TEXT_CONSOLE *Console)

NTSTATUS	ConsoleTextLocalReinitialize (_In_ struct _BL_TEXT_CONSOLE *Console)

NTSTATUS	ConsoleTextBaseGetTextState (_In_ struct _BL_TEXT_CONSOLE *Console, _Out_ PBL_DISPLAY_STATE TextState)

NTSTATUS	ConsoleTextLocalSetTextState (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ ULONG Flags, _In_ PBL_DISPLAY_STATE TextState)

NTSTATUS	ConsoleTextBaseGetTextResolution (_In_ struct _BL_TEXT_CONSOLE *Console, _Out_ PULONG TextResolution)

NTSTATUS	ConsoleTextLocalSetTextResolution (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ ULONG NewTextResolution, _Out_ PULONG OldTextResolution)

NTSTATUS	ConsoleTextLocalClearText (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ BOOLEAN LineOnly)

NTSTATUS	ConsoleTextLocalWriteText (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ PCHAR Text, _In_ ULONG Attribute)

NTSTATUS	ConsoleTextLocalConstruct (_In_ PBL_TEXT_CONSOLE TextConsole, _In_ BOOLEAN Activate)

BOOLEAN	ConsolepFindResolution (_In_ PBL_DISPLAY_MODE Mode, _In_ PBL_DISPLAY_MODE List, _In_ ULONG MaxIndex)

NTSTATUS	ConsoleFirmwareTextClear (_In_ PBL_TEXT_CONSOLE Console, _In_ BOOLEAN LineOnly)

VOID	ConsoleFirmwareTextClose (_In_ PBL_TEXT_CONSOLE TextConsole)

NTSTATUS	ConsoleFirmwareTextOpen (_In_ PBL_TEXT_CONSOLE TextConsole)

NTSTATUS	ConsoleFirmwareTextSetState (_In_ PBL_TEXT_CONSOLE TextConsole, _In_ UCHAR Mask, _In_ PBL_DISPLAY_STATE State)

NTSTATUS	ConsoleGraphicalConstruct (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

NTSTATUS	ConsoleCreateRemoteConsole (_In_ PBL_TEXT_CONSOLE *TextConsole)

NTSTATUS	ConsoleEfiGraphicalOpenProtocol (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole, _In_ BL_GRAPHICS_CONSOLE_TYPE Type)

VOID	ConsoleFirmwareGraphicalClose (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

VOID	ConsoleFirmwareGraphicalDisable (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

NTSTATUS	ConsoleFirmwareGraphicalClear (_In_ PBL_GRAPHICS_CONSOLE Console, _In_ ULONG Color)

NTSTATUS	ConsoleFirmwareGraphicalEnable (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

NTSTATUS	ConsoleEfiUgaOpen (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

VOID	ConsoleEfiUgaClose (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

VOID	ConsoleEfiGopClose (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

NTSTATUS	ConsoleEfiGopOpen (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

NTSTATUS	ConsoleEfiGopEnable (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole)

NTSTATUS	ConsoleEfiUgaSetResolution (_In_ PBL_GRAPHICS_CONSOLE GraphicsConsole, _In_ PBL_DISPLAY_MODE DisplayMode, _In_ ULONG DisplayModeCount)

NTSTATUS	ConsoleCreateLocalInputConsole (VOID)

NTSTATUS	ConsoleInputLocalEraseBuffer (_In_ PBL_INPUT_CONSOLE Console, _In_opt_ PULONG ValueToFill)

VOID	ConsolepClearBuffer (_In_ PUCHAR FrameBuffer, _In_ ULONG Width, _In_ PUCHAR FillColor, _In_ ULONG Height, _In_ ULONG ScanlineWidth, _In_ ULONG PixelDepth)

NTSTATUS	ConsolepConvertColorToPixel (_In_ BL_COLOR Color, _Out_ PUCHAR Pixel)

Variables
ULONG	MmDescriptorCallTreeCount

ULONG	BlpApplicationFlags

BL_LIBRARY_PARAMETERS	BlpLibraryParameters

BL_TRANSLATION_TYPE	MmTranslationType

PBL_ARCH_CONTEXT	CurrentExecutionContext

PBL_DEVICE_DESCRIPTOR	BlpBootDevice

BL_LOADED_APPLICATION_ENTRY	BlpApplicationEntry

EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *	EfiConOut

EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *	EfiConInEx

EFI_GUID	EfiGraphicsOutputProtocol

EFI_GUID	EfiUgaDrawProtocol

EFI_GUID	EfiLoadedImageProtocol

EFI_GUID	EfiDevicePathProtocol

EFI_GUID	EfiBlockIoProtocol

EFI_GUID	EfiSimpleTextInputExProtocol

EFI_GUID	EfiRootAcpiTableGuid

EFI_GUID	EfiRootAcpiTable10Guid

EFI_GUID	EfiGlobalVariable

ULONG	ConsoleGraphicalResolutionListFlags

BL_DISPLAY_MODE	ConsoleGraphicalResolutionList []

BL_DISPLAY_MODE	ConsoleTextResolutionList []

ULONG	ConsoleGraphicalResolutionListSize

PVOID	DspRemoteInputConsole

PVOID	DspLocalInputConsole

WCHAR	BlScratchBuffer [8192]

BL_MEMORY_DESCRIPTOR_LIST	MmMdlMappedAllocated

BL_MEMORY_DESCRIPTOR_LIST	MmMdlMappedUnallocated

BL_MEMORY_DESCRIPTOR_LIST	MmMdlFwAllocationTracker

BL_MEMORY_DESCRIPTOR_LIST	MmMdlUnmappedAllocated

BL_MEMORY_DESCRIPTOR_LIST	MmMdlUnmappedUnallocated

BL_MEMORY_DESCRIPTOR_LIST	MmMdlReservedAllocated

BL_MEMORY_DESCRIPTOR_LIST	MmMdlBadMemory

BL_MEMORY_DESCRIPTOR_LIST	MmMdlTruncatedMemory

BL_MEMORY_DESCRIPTOR_LIST	MmMdlPersistentMemory

BL_MEMORY_DESCRIPTOR_LIST	MmMdlCompleteBadMemory

BL_MEMORY_DESCRIPTOR_LIST	MmMdlFreeVirtual

BL_MEMORY_DESCRIPTOR_LIST	MmMdlMappingTrackers

ULONGLONG	BlpTimePerformanceFrequency

LIST_ENTRY	RegisteredFileSystems

BL_ADDRESS_RANGE	MmArchKsegAddressRange

ULONG_PTR	MmArchTopOfApplicationAddressSpace

PBL_MM_RELOCATE_SELF_MAP	BlMmRelocateSelfMap

PBL_MM_FLUSH_TLB	BlMmFlushTlb

PBL_MM_MOVE_VIRTUAL_ADDRESS_RANGE	BlMmMoveVirtualAddressRange

PBL_MM_ZERO_VIRTUAL_ADDRESS_RANGE	BlMmZeroVirtualAddressRange

PBL_STATUS_ERROR_HANDLER	BlpStatusErrorHandler

Macro Definition Documentation

◆ BL_APP_ENTRY_SIGNATURE

#define BL_APP_ENTRY_SIGNATURE "BTAPENT"

Definition at line 53 of file bl.h.

◆ BL_APPLICATION_ENTRY_BCD_OPTIONS_EXTERNAL

#define BL_APPLICATION_ENTRY_BCD_OPTIONS_EXTERNAL 0x80

Definition at line 74 of file bl.h.

◆ BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL

#define BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL 0x02

Definition at line 69 of file bl.h.

◆ BL_APPLICATION_ENTRY_BOOTMGR

#define BL_APPLICATION_ENTRY_BOOTMGR 0x1000

Definition at line 78 of file bl.h.

◆ BL_APPLICATION_ENTRY_BOOTSECTOR

#define BL_APPLICATION_ENTRY_BOOTSECTOR 0x400

Definition at line 77 of file bl.h.

◆ BL_APPLICATION_ENTRY_DISPLAY_ORDER

#define BL_APPLICATION_ENTRY_DISPLAY_ORDER 0x800000

Definition at line 79 of file bl.h.

◆ BL_APPLICATION_ENTRY_FIXED_SEQUENCE

#define BL_APPLICATION_ENTRY_FIXED_SEQUENCE 0x20000000

Definition at line 80 of file bl.h.

◆ BL_APPLICATION_ENTRY_FLAG_NO_GUID

#define BL_APPLICATION_ENTRY_FLAG_NO_GUID 0x01

Definition at line 68 of file bl.h.

◆ BL_APPLICATION_ENTRY_NTLDR

#define BL_APPLICATION_ENTRY_NTLDR 0x40

Definition at line 73 of file bl.h.

◆ BL_APPLICATION_ENTRY_REBOOT_ON_ERROR

#define BL_APPLICATION_ENTRY_REBOOT_ON_ERROR 0x20

Definition at line 72 of file bl.h.

◆ BL_APPLICATION_ENTRY_RECOVERY

#define BL_APPLICATION_ENTRY_RECOVERY 0x40000000

Definition at line 81 of file bl.h.

◆ BL_APPLICATION_ENTRY_SETUPLDR

#define BL_APPLICATION_ENTRY_SETUPLDR 0x200

Definition at line 76 of file bl.h.

◆ BL_APPLICATION_ENTRY_STARTUP

#define BL_APPLICATION_ENTRY_STARTUP 0x08

Definition at line 71 of file bl.h.

◆ BL_APPLICATION_ENTRY_WINLOAD

#define BL_APPLICATION_ENTRY_WINLOAD 0x04

Definition at line 70 of file bl.h.

◆ BL_APPLICATION_ENTRY_WINRESUME

#define BL_APPLICATION_ENTRY_WINRESUME 0x100

Definition at line 75 of file bl.h.

◆ BL_APPLICATION_FLAG_CONVERTED_FROM_EFI

#define BL_APPLICATION_FLAG_CONVERTED_FROM_EFI 0x01

Definition at line 51 of file bl.h.

◆ BL_BLOCK_DEVICE_PRESENT_FLAG

#define BL_BLOCK_DEVICE_PRESENT_FLAG 0x02

Definition at line 142 of file bl.h.

◆ BL_BLOCK_DEVICE_REMOVABLE_FLAG

#define BL_BLOCK_DEVICE_REMOVABLE_FLAG 0x01

Definition at line 141 of file bl.h.

◆ BL_BLOCK_DEVICE_VIRTUAL_FLAG

#define BL_BLOCK_DEVICE_VIRTUAL_FLAG 0x04

Definition at line 143 of file bl.h.

◆ BL_CONTEXT_INTERRUPTS_ON

#define BL_CONTEXT_INTERRUPTS_ON 2

Definition at line 84 of file bl.h.

◆ BL_CONTEXT_PAGING_ON

#define BL_CONTEXT_PAGING_ON 1

Definition at line 83 of file bl.h.

◆ BL_DEVICE_ENTRY_OPENED

#define BL_DEVICE_ENTRY_OPENED 0x01

Definition at line 155 of file bl.h.

◆ BL_DEVICE_ENTRY_READ_ACCESS

#define BL_DEVICE_ENTRY_READ_ACCESS 0x02

Definition at line 156 of file bl.h.

◆ BL_DEVICE_ENTRY_WRITE_ACCESS

#define BL_DEVICE_ENTRY_WRITE_ACCESS 0x04

Definition at line 157 of file bl.h.

◆ BL_DEVICE_READ_ACCESS

#define BL_DEVICE_READ_ACCESS 0x01

Definition at line 152 of file bl.h.

◆ BL_DEVICE_WRITE_ACCESS

#define BL_DEVICE_WRITE_ACCESS 0x02

Definition at line 153 of file bl.h.

◆ BL_DIRECTORY_ACCESS

#define BL_DIRECTORY_ACCESS 0x04

Definition at line 149 of file bl.h.

◆ BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG

#define BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG 0x02

Definition at line 135 of file bl.h.

◆ BL_DISPLAY_GRAPHICS_FORCED_VIDEO_MODE_FLAG

#define BL_DISPLAY_GRAPHICS_FORCED_VIDEO_MODE_FLAG 0x01

Definition at line 134 of file bl.h.

◆ BL_ETFS_FILE_ENTRY_DIRECTORY

#define BL_ETFS_FILE_ENTRY_DIRECTORY 0x01

Definition at line 165 of file bl.h.

◆ BL_FILE_ENTRY_DIRECTORY

#define BL_FILE_ENTRY_DIRECTORY 0x10000

Definition at line 163 of file bl.h.

◆ BL_FILE_ENTRY_OPENED

#define BL_FILE_ENTRY_OPENED 0x01

Definition at line 159 of file bl.h.

◆ BL_FILE_ENTRY_READ_ACCESS

#define BL_FILE_ENTRY_READ_ACCESS 0x02

Definition at line 160 of file bl.h.

◆ BL_FILE_ENTRY_UNKNOWN_ACCESS

#define BL_FILE_ENTRY_UNKNOWN_ACCESS 0x10

Definition at line 162 of file bl.h.

◆ BL_FILE_ENTRY_WRITE_ACCESS

#define BL_FILE_ENTRY_WRITE_ACCESS 0x04

Definition at line 161 of file bl.h.

◆ BL_FILE_READ_ACCESS

#define BL_FILE_READ_ACCESS 0x01

Definition at line 147 of file bl.h.

◆ BL_FILE_WRITE_ACCESS

#define BL_FILE_WRITE_ACCESS 0x02

Definition at line 148 of file bl.h.

◆ BL_FIRMWARE_DESCRIPTOR_VERSION

#define BL_FIRMWARE_DESCRIPTOR_VERSION 2

Definition at line 64 of file bl.h.

◆ BL_FS_REGISTER_AT_HEAD_FLAG

#define BL_FS_REGISTER_AT_HEAD_FLAG 1

Definition at line 139 of file bl.h.

◆ BL_HT_VALUE_IS_INLINE

#define BL_HT_VALUE_IS_INLINE 0x01

Definition at line 137 of file bl.h.

◆ BL_IMG_MEMORY_FILE

#define BL_IMG_MEMORY_FILE 0x02

Definition at line 168 of file bl.h.

◆ BL_IMG_REMOTE_FILE

#define BL_IMG_REMOTE_FILE 0x04

Definition at line 169 of file bl.h.

◆ BL_IMG_VALID_FILE

#define BL_IMG_VALID_FILE 0x01

Definition at line 167 of file bl.h.

◆ BL_LIBRARY_FLAG_INITIALIZATION_COMPLETED

#define BL_LIBRARY_FLAG_INITIALIZATION_COMPLETED 0x20

Definition at line 131 of file bl.h.

◆ BL_LIBRARY_FLAG_NO_DISPLAY

#define BL_LIBRARY_FLAG_NO_DISPLAY 0x01

Definition at line 127 of file bl.h.

◆ BL_LIBRARY_FLAG_NO_GRAPHICS_CONSOLE

#define BL_LIBRARY_FLAG_NO_GRAPHICS_CONSOLE 0x800

Definition at line 132 of file bl.h.

◆ BL_LIBRARY_FLAG_REINITIALIZE

#define BL_LIBRARY_FLAG_REINITIALIZE 0x02

Definition at line 128 of file bl.h.

◆ BL_LIBRARY_FLAG_REINITIALIZE_ALL

#define BL_LIBRARY_FLAG_REINITIALIZE_ALL 0x04

Definition at line 129 of file bl.h.

◆ BL_LIBRARY_FLAG_ZERO_HEAP_ALLOCATIONS_ON_FREE

#define BL_LIBRARY_FLAG_ZERO_HEAP_ALLOCATIONS_ON_FREE 0x10

Definition at line 130 of file bl.h.

◆ BL_LOAD_IMG_COMPUTE_HASH

#define BL_LOAD_IMG_COMPUTE_HASH 0x40000

Definition at line 175 of file bl.h.

◆ BL_LOAD_IMG_COMPUTE_SIGNATURE

#define BL_LOAD_IMG_COMPUTE_SIGNATURE 0x10

Definition at line 174 of file bl.h.

◆ BL_LOAD_IMG_EXISTING_BUFFER

#define BL_LOAD_IMG_EXISTING_BUFFER 0x04

Definition at line 172 of file bl.h.

◆ BL_LOAD_IMG_UNKNOWN_BUFFER_FLAG

#define BL_LOAD_IMG_UNKNOWN_BUFFER_FLAG 0x08

Definition at line 173 of file bl.h.

◆ BL_LOAD_IMG_VIRTUAL_BUFFER

#define BL_LOAD_IMG_VIRTUAL_BUFFER 0x01

Definition at line 171 of file bl.h.

◆ BL_LOAD_PE_IMG_CHECK_FORCED_INTEGRITY

#define BL_LOAD_PE_IMG_CHECK_FORCED_INTEGRITY 0x200

Definition at line 183 of file bl.h.

◆ BL_LOAD_PE_IMG_CHECK_MACHINE

#define BL_LOAD_PE_IMG_CHECK_MACHINE 0x02

Definition at line 178 of file bl.h.

◆ BL_LOAD_PE_IMG_CHECK_SUBSYSTEM

#define BL_LOAD_PE_IMG_CHECK_SUBSYSTEM 0x80

Definition at line 181 of file bl.h.

◆ BL_LOAD_PE_IMG_COMPUTE_HASH

#define BL_LOAD_PE_IMG_COMPUTE_HASH 0x10

Definition at line 180 of file bl.h.

◆ BL_LOAD_PE_IMG_EXISTING_BUFFER

#define BL_LOAD_PE_IMG_EXISTING_BUFFER BL_LOAD_IMG_EXISTING_BUFFER

Definition at line 179 of file bl.h.

◆ BL_LOAD_PE_IMG_IGNORE_CHECKSUM_MISMATCH

#define BL_LOAD_PE_IMG_IGNORE_CHECKSUM_MISMATCH 0x10000

Definition at line 184 of file bl.h.

◆ BL_LOAD_PE_IMG_SKIP_RELOCATIONS

#define BL_LOAD_PE_IMG_SKIP_RELOCATIONS 0x100

Definition at line 182 of file bl.h.

◆ BL_LOAD_PE_IMG_VALIDATE_ORIGINAL_FILENAME

#define BL_LOAD_PE_IMG_VALIDATE_ORIGINAL_FILENAME 0x400000

Definition at line 185 of file bl.h.

◆ BL_LOAD_PE_IMG_VIRTUAL_BUFFER

#define BL_LOAD_PE_IMG_VIRTUAL_BUFFER BL_LOAD_IMG_VIRTUAL_BUFFER

Definition at line 177 of file bl.h.

◆ BL_MEMORY_CLASS_SHIFT

#define BL_MEMORY_CLASS_SHIFT 28

Definition at line 145 of file bl.h.

◆ BL_MEMORY_DATA_VERSION

#define BL_MEMORY_DATA_VERSION 1

Definition at line 62 of file bl.h.

◆ BL_MM_ADD_DESCRIPTOR_ALLOCATE_FLAG

#define BL_MM_ADD_DESCRIPTOR_ALLOCATE_FLAG 0x1000

Definition at line 93 of file bl.h.

◆ BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG

#define BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG 0x01

Definition at line 89 of file bl.h.

◆ BL_MM_ADD_DESCRIPTOR_NEVER_COALESCE_FLAG

#define BL_MM_ADD_DESCRIPTOR_NEVER_COALESCE_FLAG 0x10

Definition at line 91 of file bl.h.

◆ BL_MM_ADD_DESCRIPTOR_NEVER_TRUNCATE_FLAG

#define BL_MM_ADD_DESCRIPTOR_NEVER_TRUNCATE_FLAG 0x20

Definition at line 92 of file bl.h.

◆ BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG

#define BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG 0x02

Definition at line 90 of file bl.h.

◆ BL_MM_ADD_DESCRIPTOR_UPDATE_LIST_POINTER_FLAG

#define BL_MM_ADD_DESCRIPTOR_UPDATE_LIST_POINTER_FLAG 0x2000

Definition at line 94 of file bl.h.

◆ BL_MM_FLAG_REQUEST_COALESCING

#define BL_MM_FLAG_REQUEST_COALESCING 0x02

Definition at line 87 of file bl.h.

◆ BL_MM_FLAG_USE_FIRMWARE_FOR_MEMORY_MAP_BUFFERS

#define BL_MM_FLAG_USE_FIRMWARE_FOR_MEMORY_MAP_BUFFERS 0x01

Definition at line 86 of file bl.h.

◆ BL_MM_INCLUDE_BAD_MEMORY

#define BL_MM_INCLUDE_BAD_MEMORY 0x20

Definition at line 101 of file bl.h.

◆ BL_MM_INCLUDE_FIRMWARE_MEMORY

#define BL_MM_INCLUDE_FIRMWARE_MEMORY 0x40

Definition at line 102 of file bl.h.

◆ BL_MM_INCLUDE_FIRMWARE_MEMORY_2

#define BL_MM_INCLUDE_FIRMWARE_MEMORY_2 0x200

Definition at line 105 of file bl.h.

◆ BL_MM_INCLUDE_MAPPED_ALLOCATED

#define BL_MM_INCLUDE_MAPPED_ALLOCATED 0x01

Definition at line 96 of file bl.h.

◆ BL_MM_INCLUDE_MAPPED_UNALLOCATED

#define BL_MM_INCLUDE_MAPPED_UNALLOCATED 0x02

Definition at line 97 of file bl.h.

◆ BL_MM_INCLUDE_NO_FIRMWARE_MEMORY

#define BL_MM_INCLUDE_NO_FIRMWARE_MEMORY

Value:

                                                         (BL_MM_INCLUDE_PERSISTENT_MEMORY | \
                                                         BL_MM_INCLUDE_TRUNCATED_MEMORY | \
                                                         BL_MM_INCLUDE_BAD_MEMORY | \
                                                         BL_MM_INCLUDE_RESERVED_ALLOCATED | \
                                                         BL_MM_INCLUDE_UNMAPPED_UNALLOCATED | \
                                                         BL_MM_INCLUDE_UNMAPPED_ALLOCATED | \
                                                         BL_MM_INCLUDE_MAPPED_UNALLOCATED | \
                                                         BL_MM_INCLUDE_MAPPED_ALLOCATED)

Definition at line 107 of file bl.h.

◆ BL_MM_INCLUDE_ONLY_FIRMWARE_MEMORY

#define BL_MM_INCLUDE_ONLY_FIRMWARE_MEMORY

Value:

(BL_MM_INCLUDE_FIRMWARE_MEMORY_2 | \

BL_MM_INCLUDE_FIRMWARE_MEMORY)

BL_MM_INCLUDE_FIRMWARE_MEMORY

#define BL_MM_INCLUDE_FIRMWARE_MEMORY

Definition: bl.h:102

BL_MM_INCLUDE_FIRMWARE_MEMORY_2

#define BL_MM_INCLUDE_FIRMWARE_MEMORY_2

Definition: bl.h:105

Definition at line 117 of file bl.h.

◆ BL_MM_INCLUDE_PERSISTENT_MEMORY

#define BL_MM_INCLUDE_PERSISTENT_MEMORY 0x100

Definition at line 104 of file bl.h.

◆ BL_MM_INCLUDE_RESERVED_ALLOCATED

#define BL_MM_INCLUDE_RESERVED_ALLOCATED 0x10

Definition at line 100 of file bl.h.

◆ BL_MM_INCLUDE_TRUNCATED_MEMORY

#define BL_MM_INCLUDE_TRUNCATED_MEMORY 0x80

Definition at line 103 of file bl.h.

◆ BL_MM_INCLUDE_UNMAPPED_ALLOCATED

#define BL_MM_INCLUDE_UNMAPPED_ALLOCATED 0x04

Definition at line 98 of file bl.h.

◆ BL_MM_INCLUDE_UNMAPPED_UNALLOCATED

#define BL_MM_INCLUDE_UNMAPPED_UNALLOCATED 0x08

Definition at line 99 of file bl.h.

◆ BL_MM_REMOVE_PHYSICAL_REGION_FLAG

#define BL_MM_REMOVE_PHYSICAL_REGION_FLAG 0x40000000

Definition at line 124 of file bl.h.

◆ BL_MM_REMOVE_VIRTUAL_REGION_FLAG

#define BL_MM_REMOVE_VIRTUAL_REGION_FLAG 0x80000000

Definition at line 125 of file bl.h.

◆ BL_MM_REQUEST_DEFAULT_TYPE

#define BL_MM_REQUEST_DEFAULT_TYPE 1

Definition at line 121 of file bl.h.

◆ BL_MM_REQUEST_TOP_DOWN_TYPE

#define BL_MM_REQUEST_TOP_DOWN_TYPE 2

Definition at line 122 of file bl.h.

◆ BL_RETURN_ARGUMENTS_NO_PAE_FLAG

#define BL_RETURN_ARGUMENTS_NO_PAE_FLAG 0x40

Definition at line 66 of file bl.h.

◆ BL_RETURN_ARGUMENTS_VERSION

#define BL_RETURN_ARGUMENTS_VERSION 1

Definition at line 63 of file bl.h.

◆ BL_UNKNOWN_ACCESS

#define BL_UNKNOWN_ACCESS 0x10

Definition at line 150 of file bl.h.

◆ BL_UTL_CHECKSUM_COMPLEMENT

#define BL_UTL_CHECKSUM_COMPLEMENT 0x10000

Definition at line 187 of file bl.h.

◆ BL_UTL_CHECKSUM_NEGATE

#define BL_UTL_CHECKSUM_NEGATE 0x40000

Definition at line 189 of file bl.h.

◆ BL_UTL_CHECKSUM_ROTATE

#define BL_UTL_CHECKSUM_ROTATE 0x20000

Definition at line 188 of file bl.h.

◆ BL_UTL_CHECKSUM_UCHAR_BUFFER

#define BL_UTL_CHECKSUM_UCHAR_BUFFER 0x01

Definition at line 190 of file bl.h.

◆ BL_UTL_CHECKSUM_USHORT_BUFFER

#define BL_UTL_CHECKSUM_USHORT_BUFFER 0x02

Definition at line 191 of file bl.h.

◆ BOOT_APPLICATION_SIGNATURE_1

#define BOOT_APPLICATION_SIGNATURE_1 'TOOB'

Definition at line 55 of file bl.h.

◆ BOOT_APPLICATION_SIGNATURE_2

#define BOOT_APPLICATION_SIGNATURE_2 ' PPA'

Definition at line 56 of file bl.h.

◆ BOOT_APPLICATION_VERSION

#define BOOT_APPLICATION_VERSION 2

Definition at line 61 of file bl.h.

◆ BOOT_MEMORY_TRANSLATION_TYPE_PHYSICAL

#define BOOT_MEMORY_TRANSLATION_TYPE_PHYSICAL 0

Definition at line 58 of file bl.h.

◆ BOOT_MEMORY_TRANSLATION_TYPE_VIRTUAL

#define BOOT_MEMORY_TRANSLATION_TYPE_VIRTUAL 1

Definition at line 59 of file bl.h.

Typedef Documentation

◆ BITMAP

typedef struct _BITMAP BITMAP

◆ BL_ADDRESS_RANGE

typedef struct _BL_ADDRESS_RANGE BL_ADDRESS_RANGE

◆ BL_APPLICATION_ENTRY

typedef struct _BL_APPLICATION_ENTRY BL_APPLICATION_ENTRY

◆ BL_ARCH_CONTEXT

typedef struct _BL_ARCH_CONTEXT BL_ARCH_CONTEXT

◆ BL_ARCH_MODE

typedef enum _BL_ARCH_MODE BL_ARCH_MODE

◆ BL_BCD_OPTION

typedef struct _BL_BCD_OPTION BL_BCD_OPTION

◆ BL_BLOCK_DEVICE

typedef struct _BL_BLOCK_DEVICE BL_BLOCK_DEVICE

◆ BL_BLOCK_DEVICE_INFORMATION

typedef struct _BL_BLOCK_DEVICE_INFORMATION BL_BLOCK_DEVICE_INFORMATION

◆ BL_BOOT_ERROR_STATUS

typedef enum _BL_BOOT_ERROR_STATUS BL_BOOT_ERROR_STATUS

◆ BL_BUFFER_DESCRIPTOR

typedef struct _BL_BUFFER_DESCRIPTOR BL_BUFFER_DESCRIPTOR

◆ BL_COLOR

typedef enum _BL_COLOR BL_COLOR

◆ BL_DEFERRED_FONT_FILE

typedef struct _BL_DEFERRED_FONT_FILE BL_DEFERRED_FONT_FILE

◆ BL_DEVICE_CALLBACKS

typedef struct _BL_DEVICE_CALLBACKS BL_DEVICE_CALLBACKS

◆ BL_DEVICE_DESCRIPTOR

typedef struct _BL_DEVICE_DESCRIPTOR BL_DEVICE_DESCRIPTOR

◆ BL_DEVICE_ENTRY

typedef struct _BL_DEVICE_ENTRY BL_DEVICE_ENTRY

◆ BL_DEVICE_INFORMATION

typedef struct _BL_DEVICE_INFORMATION BL_DEVICE_INFORMATION

◆ BL_DEVICE_TYPE

typedef enum _BL_DEVICE_TYPE BL_DEVICE_TYPE

◆ BL_DISPLAY_MODE

typedef struct _BL_DISPLAY_MODE BL_DISPLAY_MODE

◆ BL_DISPLAY_STATE

typedef struct _BL_DISPLAY_STATE BL_DISPLAY_STATE

◆ BL_FILE_CALLBACKS

typedef struct _BL_FILE_CALLBACKS BL_FILE_CALLBACKS

◆ BL_FILE_ENTRY

typedef struct _BL_FILE_ENTRY BL_FILE_ENTRY

◆ BL_FILE_INFORMATION

typedef struct _BL_FILE_INFORMATION BL_FILE_INFORMATION

◆ BL_FILE_PATH_DESCRIPTOR

typedef struct _BL_FILE_PATH_DESCRIPTOR BL_FILE_PATH_DESCRIPTOR

◆ BL_FILE_SYSTEM_ENTRY

typedef struct _BL_FILE_SYSTEM_ENTRY BL_FILE_SYSTEM_ENTRY

◆ BL_FILE_SYSTEM_REGISTRATION_TABLE

typedef struct _BL_FILE_SYSTEM_REGISTRATION_TABLE BL_FILE_SYSTEM_REGISTRATION_TABLE

◆ BL_FIRMWARE_DESCRIPTOR

typedef struct _BL_FIRMWARE_DESCRIPTOR BL_FIRMWARE_DESCRIPTOR

◆ BL_GRAPHICS_CONSOLE

typedef struct _BL_GRAPHICS_CONSOLE BL_GRAPHICS_CONSOLE

◆ BL_GRAPHICS_CONSOLE_TYPE

typedef enum _BL_GRAPHICS_CONSOLE_TYPE BL_GRAPHICS_CONSOLE_TYPE

◆ BL_GRAPHICS_CONSOLE_VTABLE

typedef struct _BL_GRAPHICS_CONSOLE_VTABLE BL_GRAPHICS_CONSOLE_VTABLE

◆ BL_HARDDISK_DEVICE

typedef struct _BL_HARDDISK_DEVICE BL_HARDDISK_DEVICE

◆ BL_HASH_ENTRY

typedef struct _BL_HASH_ENTRY BL_HASH_ENTRY

◆ BL_HASH_NODE

typedef struct _BL_HASH_NODE BL_HASH_NODE

◆ BL_HASH_TABLE

typedef struct _BL_HASH_TABLE BL_HASH_TABLE

◆ BL_HASH_VALUE

typedef struct _BL_HASH_VALUE BL_HASH_VALUE

◆ BL_IMAGE_APPLICATION_ENTRY

typedef struct _BL_IMAGE_APPLICATION_ENTRY BL_IMAGE_APPLICATION_ENTRY

◆ BL_IMG_FILE

typedef struct _BL_IMG_FILE BL_IMG_FILE

◆ BL_INPUT_CONSOLE

typedef struct _BL_INPUT_CONSOLE BL_INPUT_CONSOLE

◆ BL_INPUT_CONSOLE_VTABLE

typedef struct _BL_INPUT_CONSOLE_VTABLE BL_INPUT_CONSOLE_VTABLE

◆ BL_LIBRARY_PARAMETERS

typedef struct _BL_LIBRARY_PARAMETERS BL_LIBRARY_PARAMETERS

◆ BL_LOADED_APPLICATION_ENTRY

typedef struct _BL_LOADED_APPLICATION_ENTRY BL_LOADED_APPLICATION_ENTRY

◆ BL_LOCAL_DEVICE

typedef struct _BL_LOCAL_DEVICE BL_LOCAL_DEVICE

◆ BL_LOCAL_DEVICE_TYPE

typedef enum _BL_LOCAL_DEVICE_TYPE BL_LOCAL_DEVICE_TYPE

◆ BL_MEMORY_ATTR

typedef enum _BL_MEMORY_ATTR BL_MEMORY_ATTR

◆ BL_MEMORY_CLASS

typedef enum _BL_MEMORY_CLASS BL_MEMORY_CLASS

◆ BL_MEMORY_DATA

typedef struct _BL_MEMORY_DATA BL_MEMORY_DATA

◆ BL_MEMORY_DESCRIPTOR

typedef struct _BL_MEMORY_DESCRIPTOR BL_MEMORY_DESCRIPTOR

◆ BL_MEMORY_DESCRIPTOR_LIST

typedef struct _BL_MEMORY_DESCRIPTOR_LIST BL_MEMORY_DESCRIPTOR_LIST

◆ BL_MEMORY_DESCRIPTOR_TYPE

typedef enum _BL_MEMORY_DESCRIPTOR_TYPE BL_MEMORY_DESCRIPTOR_TYPE

◆ BL_MEMORY_TYPE

typedef enum _BL_MEMORY_TYPE BL_MEMORY_TYPE

◆ BL_MENU_POLICY

typedef enum _BL_MENU_POLICY BL_MENU_POLICY

◆ BL_MENU_STATUS

typedef struct _BL_MENU_STATUS BL_MENU_STATUS

◆ BL_PARTITION_TYPE

typedef enum _BL_PARTITION_TYPE BL_PARTITION_TYPE

◆ BL_PATH_TYPE

typedef enum _BL_PATH_TYPE BL_PATH_TYPE

◆ BL_PD_DATA_BLOB

typedef struct _BL_PD_DATA_BLOB BL_PD_DATA_BLOB

◆ BL_PROTOCOL_HANDLE

typedef struct _BL_PROTOCOL_HANDLE BL_PROTOCOL_HANDLE

◆ BL_REMOTE_CONSOLE

typedef struct _BL_REMOTE_CONSOLE BL_REMOTE_CONSOLE

◆ BL_RETURN_ARGUMENTS

typedef struct _BL_RETURN_ARGUMENTS BL_RETURN_ARGUMENTS

◆ BL_TEXT_CONSOLE

typedef struct _BL_TEXT_CONSOLE BL_TEXT_CONSOLE

◆ BL_TEXT_CONSOLE_VTABLE

typedef struct _BL_TEXT_CONSOLE_VTABLE BL_TEXT_CONSOLE_VTABLE

◆ BL_TRANSLATION_TYPE

typedef enum _BL_TRANSLATION_TYPE BL_TRANSLATION_TYPE

◆ BL_WINDOWS_LOAD_OPTIONS

typedef struct _BL_WINDOWS_LOAD_OPTIONS BL_WINDOWS_LOAD_OPTIONS

◆ BMP_HEADER

typedef struct _BMP_HEADER BMP_HEADER

◆ BOOT_APPLICATION_PARAMETER_BLOCK

typedef struct _BOOT_APPLICATION_PARAMETER_BLOCK BOOT_APPLICATION_PARAMETER_BLOCK

◆ COORD

typedef struct _COORD COORD

◆ DIB_HEADER

typedef struct _DIB_HEADER DIB_HEADER

◆ PBITMAP

typedef struct _BITMAP * PBITMAP

◆ PBL_ADDRESS_RANGE

typedef struct _BL_ADDRESS_RANGE * PBL_ADDRESS_RANGE

◆ PBL_APPLICATION_ENTRY

typedef struct _BL_APPLICATION_ENTRY * PBL_APPLICATION_ENTRY

◆ PBL_ARCH_CONTEXT

typedef struct _BL_ARCH_CONTEXT * PBL_ARCH_CONTEXT

◆ PBL_BCD_OPTION

typedef struct _BL_BCD_OPTION * PBL_BCD_OPTION

◆ PBL_BLOCK_DEVICE

typedef struct _BL_BLOCK_DEVICE * PBL_BLOCK_DEVICE

◆ PBL_BLOCK_DEVICE_INFORMATION

typedef struct _BL_BLOCK_DEVICE_INFORMATION * PBL_BLOCK_DEVICE_INFORMATION

◆ PBL_BUFFER_DESCRIPTOR

typedef struct _BL_BUFFER_DESCRIPTOR * PBL_BUFFER_DESCRIPTOR

◆ PBL_COLOR

typedef enum _BL_COLOR * PBL_COLOR

◆ PBL_DEFERRED_FONT_FILE

typedef struct _BL_DEFERRED_FONT_FILE * PBL_DEFERRED_FONT_FILE

◆ PBL_DEVICE_CALLBACKS

typedef struct _BL_DEVICE_CALLBACKS * PBL_DEVICE_CALLBACKS

◆ PBL_DEVICE_CLOSE

typedef NTSTATUS(* PBL_DEVICE_CLOSE) (_In_ struct _BL_DEVICE_ENTRY *DeviceEntry)

Definition at line 625 of file bl.h.

◆ PBL_DEVICE_CREATE

typedef NTSTATUS(* PBL_DEVICE_CREATE) (VOID)

Definition at line 672 of file bl.h.

◆ PBL_DEVICE_DESCRIPTOR

typedef struct _BL_DEVICE_DESCRIPTOR * PBL_DEVICE_DESCRIPTOR

◆ PBL_DEVICE_ENTRY

typedef struct _BL_DEVICE_ENTRY * PBL_DEVICE_ENTRY

◆ PBL_DEVICE_ENUMERATE_DEVICE_CLASS

typedef NTSTATUS(* PBL_DEVICE_ENUMERATE_DEVICE_CLASS) (VOID)

Definition at line 612 of file bl.h.

◆ PBL_DEVICE_FLUSH

typedef NTSTATUS(* PBL_DEVICE_FLUSH) (VOID)

Definition at line 666 of file bl.h.

◆ PBL_DEVICE_GET_INFORMATION

typedef NTSTATUS(* PBL_DEVICE_GET_INFORMATION) (_In_ struct _BL_DEVICE_ENTRY *DeviceEntry, _Out_ struct _BL_DEVICE_INFORMATION *DeviceInformation)

Definition at line 646 of file bl.h.

◆ PBL_DEVICE_INFORMATION

typedef struct _BL_DEVICE_INFORMATION * PBL_DEVICE_INFORMATION

◆ PBL_DEVICE_OPEN

typedef NTSTATUS(* PBL_DEVICE_OPEN) (_In_ struct _BL_DEVICE_DESCRIPTOR *Device, _In_ struct _BL_DEVICE_ENTRY *DeviceEntry)

Definition at line 618 of file bl.h.

◆ PBL_DEVICE_READ

typedef NTSTATUS(* PBL_DEVICE_READ) (_In_ struct _BL_DEVICE_ENTRY *DeviceEntry, _In_ PVOID Buffer, _In_ ULONG Size, _Out_ PULONG BytesRead)

Definition at line 631 of file bl.h.

◆ PBL_DEVICE_RESET

typedef NTSTATUS(* PBL_DEVICE_RESET) (VOID)

Definition at line 660 of file bl.h.

◆ PBL_DEVICE_SET_INFORMATION

typedef NTSTATUS(* PBL_DEVICE_SET_INFORMATION) (_In_ struct _BL_DEVICE_ENTRY *DeviceEntry, _In_ struct _BL_DEVICE_INFORMATION *DeviceInformation)

Definition at line 653 of file bl.h.

◆ PBL_DEVICE_WRITE

typedef NTSTATUS(* PBL_DEVICE_WRITE) (VOID)

Definition at line 640 of file bl.h.

◆ PBL_DISPLAY_MODE

typedef struct _BL_DISPLAY_MODE * PBL_DISPLAY_MODE

◆ PBL_DISPLAY_STATE

typedef struct _BL_DISPLAY_STATE * PBL_DISPLAY_STATE

◆ PBL_FILE_CALLBACKS

typedef struct _BL_FILE_CALLBACKS * PBL_FILE_CALLBACKS

◆ PBL_FILE_CLOSE

typedef NTSTATUS(* PBL_FILE_CLOSE) (_In_ struct _BL_FILE_ENTRY *FileEntry)

Definition at line 401 of file bl.h.

◆ PBL_FILE_DESTROY_CALLBACK

typedef NTSTATUS(* PBL_FILE_DESTROY_CALLBACK) (_In_ PVOID Entry)

Definition at line 468 of file bl.h.

◆ PBL_FILE_ENTRY

typedef struct _BL_FILE_ENTRY * PBL_FILE_ENTRY

◆ PBL_FILE_GET_INFO

typedef NTSTATUS(* PBL_FILE_GET_INFO) (_In_ struct _BL_FILE_ENTRY *FileEntry, _Out_ struct _BL_FILE_INFORMATION *FileInfo)

Definition at line 428 of file bl.h.

◆ PBL_FILE_GET_NEXT

typedef NTSTATUS(* PBL_FILE_GET_NEXT) (VOID)

Definition at line 422 of file bl.h.

◆ PBL_FILE_INFORMATION

typedef struct _BL_FILE_INFORMATION * PBL_FILE_INFORMATION

◆ PBL_FILE_OPEN

typedef NTSTATUS(* PBL_FILE_OPEN) (_In_ struct _BL_FILE_ENTRY *Directory, _In_ PWCHAR FileName, _In_ ULONG Flags, _Out_ struct _BL_FILE_ENTRY **FileEntry)

Definition at line 392 of file bl.h.

◆ PBL_FILE_PATH_DESCRIPTOR

typedef struct _BL_FILE_PATH_DESCRIPTOR * PBL_FILE_PATH_DESCRIPTOR

◆ PBL_FILE_READ

typedef NTSTATUS(* PBL_FILE_READ) (_In_ struct _BL_FILE_ENTRY *FileEntry, _In_ PVOID Buffer, _In_ ULONG Size, _Out_opt_ PULONG BytesRead)

Definition at line 407 of file bl.h.

◆ PBL_FILE_SET_INFO

typedef NTSTATUS(* PBL_FILE_SET_INFO) (_In_ struct _BL_FILE_ENTRY *FileEntry, _In_ struct _BL_FILE_INFORMATION *FileInfo)

Definition at line 435 of file bl.h.

◆ PBL_FILE_SYSTEM_ENTRY

typedef struct _BL_FILE_SYSTEM_ENTRY * PBL_FILE_SYSTEM_ENTRY

◆ PBL_FILE_WRITE

typedef NTSTATUS(* PBL_FILE_WRITE) (VOID)

Definition at line 416 of file bl.h.

◆ PBL_FIRMWARE_DESCRIPTOR

typedef struct _BL_FIRMWARE_DESCRIPTOR * PBL_FIRMWARE_DESCRIPTOR

◆ PBL_FS_DESTROY_CALLBACK

typedef NTSTATUS(* PBL_FS_DESTROY_CALLBACK) (VOID)

Definition at line 448 of file bl.h.

◆ PBL_FS_INIT_CALLBACK

typedef NTSTATUS(* PBL_FS_INIT_CALLBACK) (VOID)

Definition at line 442 of file bl.h.

◆ PBL_FS_MOUNT_CALLBACK

typedef NTSTATUS(* PBL_FS_MOUNT_CALLBACK) (_In_ ULONG DeviceId, _In_ ULONG Unknown, _Out_ struct _BL_FILE_ENTRY **FileEntry)

Definition at line 454 of file bl.h.

◆ PBL_FS_PURGE_CALLBACK

typedef NTSTATUS(* PBL_FS_PURGE_CALLBACK) (VOID)

Definition at line 462 of file bl.h.

◆ PBL_GRAPHICS_CONSOLE

typedef struct _BL_GRAPHICS_CONSOLE * PBL_GRAPHICS_CONSOLE

◆ PBL_GRAPHICS_CONSOLE_VTABLE

typedef struct _BL_GRAPHICS_CONSOLE_VTABLE * PBL_GRAPHICS_CONSOLE_VTABLE

◆ PBL_HASH_ENTRY

typedef struct _BL_HASH_ENTRY * PBL_HASH_ENTRY

◆ PBL_HASH_NODE

typedef struct _BL_HASH_NODE * PBL_HASH_NODE

◆ PBL_HASH_TABLE

typedef struct _BL_HASH_TABLE * PBL_HASH_TABLE

◆ PBL_HASH_TABLE_COMPARE_FUNCTION

typedef BOOLEAN(* PBL_HASH_TABLE_COMPARE_FUNCTION) (_In_ struct _BL_HASH_ENTRY *Entry1, _In_ struct _BL_HASH_ENTRY *Entry2)

Definition at line 594 of file bl.h.

◆ PBL_HASH_TABLE_HASH_FUNCTION

typedef ULONG(* PBL_HASH_TABLE_HASH_FUNCTION) (_In_ struct _BL_HASH_ENTRY *Entry, _In_ ULONG TableSize)

Definition at line 601 of file bl.h.

◆ PBL_HASH_VALUE

typedef struct _BL_HASH_VALUE * PBL_HASH_VALUE

◆ PBL_IMAGE_APPLICATION_ENTRY

typedef struct _BL_IMAGE_APPLICATION_ENTRY * PBL_IMAGE_APPLICATION_ENTRY

◆ PBL_IMG_FILE

typedef struct _BL_IMG_FILE * PBL_IMG_FILE

◆ PBL_INPUT_CONSOLE

typedef struct _BL_INPUT_CONSOLE * PBL_INPUT_CONSOLE

◆ PBL_INPUT_CONSOLE_VTABLE

typedef struct _BL_INPUT_CONSOLE_VTABLE * PBL_INPUT_CONSOLE_VTABLE

◆ PBL_IO_DESTROY_ROUTINE

typedef NTSTATUS(* PBL_IO_DESTROY_ROUTINE) (VOID)

Definition at line 587 of file bl.h.

◆ PBL_LIBRARY_PARAMETERS

typedef struct _BL_LIBRARY_PARAMETERS * PBL_LIBRARY_PARAMETERS

◆ PBL_LOADED_APPLICATION_ENTRY

typedef struct _BL_LOADED_APPLICATION_ENTRY * PBL_LOADED_APPLICATION_ENTRY

◆ PBL_LOCAL_DEVICE

typedef struct _BL_LOCAL_DEVICE * PBL_LOCAL_DEVICE

◆ PBL_MEMORY_DATA

typedef struct _BL_MEMORY_DATA * PBL_MEMORY_DATA

◆ PBL_MEMORY_DESCRIPTOR

typedef struct _BL_MEMORY_DESCRIPTOR * PBL_MEMORY_DESCRIPTOR

◆ PBL_MEMORY_DESCRIPTOR_LIST

typedef struct _BL_MEMORY_DESCRIPTOR_LIST * PBL_MEMORY_DESCRIPTOR_LIST

◆ PBL_MM_DESTROY_SELF_MAP

typedef VOID(* PBL_MM_DESTROY_SELF_MAP) (VOID)

Definition at line 700 of file bl.h.

◆ PBL_MM_FLUSH_TLB

typedef VOID(* PBL_MM_FLUSH_TLB)(VOID)

Definition at line 677 of file bl.h.

◆ PBL_MM_FLUSH_TLB_ENTRY

typedef VOID(* PBL_MM_FLUSH_TLB_ENTRY) (_In_ PVOID VirtualAddress)

Definition at line 705 of file bl.h.

◆ PBL_MM_MAP_PHYSICAL_ADDRESS

typedef NTSTATUS(* PBL_MM_MAP_PHYSICAL_ADDRESS) (_In_ PHYSICAL_ADDRESS PhysicalAddress, _Out_ PVOID VirtualAddress, _In_ ULONG Size, _In_ ULONG CacheAttributes)

Definition at line 729 of file bl.h.

◆ PBL_MM_MOVE_VIRTUAL_ADDRESS_RANGE

typedef NTSTATUS(* PBL_MM_MOVE_VIRTUAL_ADDRESS_RANGE) (_In_ PVOID DestinationAddress, _In_ PVOID SourceAddress, _In_ ULONGLONG Size)

Definition at line 687 of file bl.h.

◆ PBL_MM_RELOCATE_SELF_MAP

typedef VOID(* PBL_MM_RELOCATE_SELF_MAP) (VOID)

Definition at line 682 of file bl.h.

◆ PBL_MM_REMAP_VIRTUAL_ADDRESS

typedef NTSTATUS(* PBL_MM_REMAP_VIRTUAL_ADDRESS) (_In_ PPHYSICAL_ADDRESS PhysicalAddress, _Out_ PVOID VirtualAddress, _In_ ULONG Size, _In_ ULONG CacheAttributes)

Definition at line 721 of file bl.h.

◆ PBL_MM_TRANSLATE_VIRTUAL_ADDRESS

typedef BOOLEAN(* PBL_MM_TRANSLATE_VIRTUAL_ADDRESS) (_In_ PVOID VirtualAddress, _Out_ PPHYSICAL_ADDRESS PhysicalAddress, _Out_opt_ PULONG CacheAttributes)

Definition at line 737 of file bl.h.

◆ PBL_MM_UNMAP_VIRTUAL_ADDRESS

typedef NTSTATUS(* PBL_MM_UNMAP_VIRTUAL_ADDRESS) (_In_ PVOID VirtualAddress, _In_ ULONG Size)

Definition at line 715 of file bl.h.

◆ PBL_MM_ZERO_VIRTUAL_ADDRESS_RANGE

typedef NTSTATUS(* PBL_MM_ZERO_VIRTUAL_ADDRESS_RANGE) (_In_ PVOID DestinationAddress, _In_ ULONGLONG Size)

Definition at line 694 of file bl.h.

◆ PBL_PD_DATA_BLOB

typedef struct _BL_PD_DATA_BLOB * PBL_PD_DATA_BLOB

◆ PBL_PROTOCOL_HANDLE

typedef struct _BL_PROTOCOL_HANDLE * PBL_PROTOCOL_HANDLE

◆ PBL_REMOTE_CONSOLE

typedef struct _BL_REMOTE_CONSOLE * PBL_REMOTE_CONSOLE

◆ PBL_RETURN_ARGUMENTS

typedef struct _BL_RETURN_ARGUMENTS * PBL_RETURN_ARGUMENTS

◆ PBL_STATUS_ERROR_HANDLER

typedef NTSTATUS(* PBL_STATUS_ERROR_HANDLER) (_In_ ULONG ErrorCode, _In_ ULONG Parameter1, _In_ ULONG_PTR Parameter2, _In_ ULONG_PTR Parameter3, _In_ ULONG_PTR Parameter4)

Definition at line 744 of file bl.h.

◆ PBL_TBL_LOOKUP_ROUTINE

typedef BOOLEAN(* PBL_TBL_LOOKUP_ROUTINE) (_In_ PVOID Entry, _In_ PVOID Argument1, _In_ PVOID Argument2, _In_ PVOID Argument3, _In_ PVOID Argument4)

Definition at line 564 of file bl.h.

◆ PBL_TBL_MAP_ROUTINE

typedef NTSTATUS(* PBL_TBL_MAP_ROUTINE) (_In_ PVOID Entry, _In_ ULONG EntryIndex)

Definition at line 574 of file bl.h.

◆ PBL_TBL_SET_ROUTINE

typedef NTSTATUS(* PBL_TBL_SET_ROUTINE) (_In_ PVOID Entry)

Definition at line 581 of file bl.h.

◆ PBL_TEXT_CONSOLE

typedef struct _BL_TEXT_CONSOLE * PBL_TEXT_CONSOLE

◆ PBL_TEXT_CONSOLE_VTABLE

typedef struct _BL_TEXT_CONSOLE_VTABLE * PBL_TEXT_CONSOLE_VTABLE

◆ PBL_WINDOWS_LOAD_OPTIONS

typedef struct _BL_WINDOWS_LOAD_OPTIONS * PBL_WINDOWS_LOAD_OPTIONS

◆ PBMP_HEADER

typedef struct _BMP_HEADER * PBMP_HEADER

◆ PBOOT_APPLICATION_PARAMETER_BLOCK

typedef struct _BOOT_APPLICATION_PARAMETER_BLOCK * PBOOT_APPLICATION_PARAMETER_BLOCK

◆ PCONSOLE_CLEAR_TEXT

typedef NTSTATUS(* PCONSOLE_CLEAR_TEXT) (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ BOOLEAN LineOnly)

Definition at line 522 of file bl.h.

◆ PCONSOLE_DESTRUCT

typedef VOID(* PCONSOLE_DESTRUCT) (_In_ struct _BL_TEXT_CONSOLE *Console)

Definition at line 480 of file bl.h.

◆ PCONSOLE_ENABLE

typedef NTSTATUS(* PCONSOLE_ENABLE) (_In_ struct _BL_GRAPHICS_CONSOLE *Console, _In_ BOOLEAN Enable)

Definition at line 549 of file bl.h.

◆ PCONSOLE_GET_GRAPHICAL_RESOLUTION

typedef NTSTATUS(* PCONSOLE_GET_GRAPHICAL_RESOLUTION) (_In_ struct _BL_GRAPHICS_CONSOLE *Console, _Out_ struct _BL_DISPLAY_MODE *DisplayMode)

Definition at line 535 of file bl.h.

◆ PCONSOLE_GET_TEXT_RESOLUTION

typedef NTSTATUS(* PCONSOLE_GET_TEXT_RESOLUTION) (_In_ struct _BL_TEXT_CONSOLE *Console, _Out_ PULONG TextResolution)

Definition at line 507 of file bl.h.

◆ PCONSOLE_GET_TEXT_STATE

typedef NTSTATUS(* PCONSOLE_GET_TEXT_STATE) (_In_ struct _BL_TEXT_CONSOLE *Console, _Out_ struct _BL_DISPLAY_STATE *TextState)

Definition at line 492 of file bl.h.

◆ PCONSOLE_IS_ENABLED

typedef BOOLEAN(* PCONSOLE_IS_ENABLED) (_In_ struct _BL_GRAPHICS_CONSOLE *Console)

Definition at line 529 of file bl.h.

◆ PCONSOLE_REINITIALIZE

typedef NTSTATUS(* PCONSOLE_REINITIALIZE) (_In_ struct _BL_TEXT_CONSOLE *Console)

Definition at line 486 of file bl.h.

◆ PCONSOLE_SET_GRAPHICAL_RESOLUTION

typedef NTSTATUS(* PCONSOLE_SET_GRAPHICAL_RESOLUTION) (_In_ struct _BL_GRAPHICS_CONSOLE *Console, _In_ struct _BL_DISPLAY_MODE DisplayMode)

Definition at line 542 of file bl.h.

◆ PCONSOLE_SET_TEXT_RESOLUTION

typedef NTSTATUS(* PCONSOLE_SET_TEXT_RESOLUTION) (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ ULONG NewTextResolution, _Out_ PULONG OldTextResolution)

Definition at line 514 of file bl.h.

◆ PCONSOLE_SET_TEXT_STATE

typedef NTSTATUS(* PCONSOLE_SET_TEXT_STATE) (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ ULONG Flags, _In_ struct _BL_DISPLAY_STATE *TextState)

Definition at line 499 of file bl.h.

◆ PCONSOLE_WRITE_TEXT

typedef NTSTATUS(* PCONSOLE_WRITE_TEXT) (_In_ struct _BL_TEXT_CONSOLE *Console, _In_ PCHAR Text, _In_ ULONG Attribute)

Definition at line 556 of file bl.h.

◆ PCOORD

typedef struct _COORD * PCOORD

◆ PDIB_HEADER

typedef struct _DIB_HEADER * PDIB_HEADER

◆ PL_MENU_STATUS

typedef struct _BL_MENU_STATUS * PL_MENU_STATUS

Enumeration Type Documentation

◆ _BL_ARCH_MODE

enum _BL_ARCH_MODE

Enumerator
BlProtectedMode
BlRealMode

Definition at line 236 of file bl.h.

{
    BlProtectedMode,
    BlRealMode
} BL_ARCH_MODE;

◆ _BL_BOOT_ERROR_STATUS

enum _BL_BOOT_ERROR_STATUS

Enumerator
Reboot
Recover
RecoverOem
OsSelection
NextOs
TryAgain
AdvancedOptions
BootOptions

Definition at line 889 of file bl.h.

{
    Reboot = 1,
    Recover = 2,
    RecoverOem = 3,
    OsSelection = 4,
    NextOs = 5,
    TryAgain = 6,
    AdvancedOptions = 7,
    BootOptions = 8
} BL_BOOT_ERROR_STATUS;

◆ _BL_COLOR

enum _BL_COLOR

Enumerator
Black
Blue
Green
Cyan
Red
Magenta
Brown
LtGray
Gray
LtBlue
LtGreen
LtCyan
LtRed
LtMagenta
Yellow
White

Definition at line 195 of file bl.h.

{
    Black,
    Blue,
    Green,
    Cyan,
    Red,
    Magenta,
    Brown,
    LtGray,
    Gray,
    LtBlue,
    LtGreen,
    LtCyan,
    LtRed,
    LtMagenta,
    Yellow,
    White
} BL_COLOR, *PBL_COLOR;

◆ _BL_DEVICE_TYPE

enum _BL_DEVICE_TYPE

Enumerator
DiskDevice
LegacyPartitionDevice
SerialDevice
UdpDevice
BootDevice
PartitionDevice
LocateDevice

Definition at line 245 of file bl.h.

{
    DiskDevice = 0,
    LegacyPartitionDevice = 2,
    SerialDevice = 3,
    UdpDevice = 4,
    BootDevice = 5,
    PartitionDevice = 6,
    LocateDevice = 8,
} BL_DEVICE_TYPE;

◆ _BL_GRAPHICS_CONSOLE_TYPE

enum _BL_GRAPHICS_CONSOLE_TYPE

Enumerator
BlGopConsole
BlUgaConsole

Definition at line 1138 of file bl.h.

{
    BlGopConsole,
    BlUgaConsole
} BL_GRAPHICS_CONSOLE_TYPE;

◆ _BL_LOCAL_DEVICE_TYPE

enum _BL_LOCAL_DEVICE_TYPE

Enumerator
LocalDevice
FloppyDevice
CdRomDevice
RamDiskDevice
FileDevice
VirtualDiskDevice

Definition at line 259 of file bl.h.

{
    LocalDevice = 0,
    FloppyDevice = 1,
    CdRomDevice = 2,
    RamDiskDevice = 3,
    FileDevice = 5,
    VirtualDiskDevice = 6
} BL_LOCAL_DEVICE_TYPE;

◆ _BL_MEMORY_ATTR

enum _BL_MEMORY_ATTR

Enumerator
BlMemoryUncached
BlMemoryWriteCombined
BlMemoryWriteThrough
BlMemoryWriteBack
BlMemoryUncachedExported
BlMemoryValidCacheAttributes
BlMemoryValidCacheAttributeMask
BlMemoryWriteProtected
BlMemoryReadProtected
BlMemoryExecuteProtected
BlMemoryValidProtectionAttributes
BlMemoryValidProtectionAttributeMask
BlMemoryLargePages
BlMemoryKernelRange
BlMemoryFixed
BlMemoryBelow1MB
BlMemoryValidAllocationAttributes
BlMemoryValidAllocationAttributeMask
BlMemoryRuntime
BlMemoryCoalesced
BlMemoryUpdate
BlMemoryNonFirmware
BlMemoryPersistent
BlMemorySpecial
BlMemoryFirmware
BlMemoryValidTypeAttributes
BlMemoryValidTypeAttributeMask

Definition at line 341 of file bl.h.

{
    //
    // Memory Caching Attributes
    //
    BlMemoryUncached =          0x00000001,
    BlMemoryWriteCombined =     0x00000002,
    BlMemoryWriteThrough =      0x00000004,
    BlMemoryWriteBack =         0x00000008,
    BlMemoryUncachedExported =  0x00000010,
    BlMemoryValidCacheAttributes            = BlMemoryUncached | BlMemoryWriteCombined | BlMemoryWriteThrough | BlMemoryWriteBack | BlMemoryUncachedExported,
    BlMemoryValidCacheAttributeMask         = 0x000000FF,
 
    //
    // Memory Protection Attributes
    //
    BlMemoryWriteProtected =    0x00000100,
    BlMemoryReadProtected =     0x00000200,
    BlMemoryExecuteProtected =  0x00000400,
    BlMemoryValidProtectionAttributes       = BlMemoryWriteProtected | BlMemoryReadProtected | BlMemoryExecuteProtected,
    BlMemoryValidProtectionAttributeMask    = 0x0000FF00,
 
    //
    // Memory Allocation Attributes
    //
    BlMemoryLargePages =        0x00010000,
    BlMemoryKernelRange =       0x00020000,
    BlMemoryFixed =             0x00040000,
    BlMemoryBelow1MB =          0x00080000,
    BlMemoryValidAllocationAttributes       = BlMemoryKernelRange | BlMemoryFixed | BlMemoryBelow1MB | BlMemoryLargePages,
    BlMemoryValidAllocationAttributeMask    = 0x00FF0000,
 
    //
    // Memory Type Attributes
    //
    BlMemoryRuntime =           0x01000000,
    BlMemoryCoalesced =         0x02000000,
    BlMemoryUpdate =            0x04000000,
    BlMemoryNonFirmware =       0x08000000,
    BlMemoryPersistent =        0x10000000,
    BlMemorySpecial =           0x20000000,
    BlMemoryFirmware =          0x80000000,
    BlMemoryValidTypeAttributes             = BlMemoryRuntime | BlMemoryCoalesced | BlMemoryUpdate | BlMemoryNonFirmware | BlMemoryPersistent | BlMemorySpecial | BlMemoryFirmware,
    BlMemoryValidTypeAttributeMask          = 0xFF000000,
} BL_MEMORY_ATTR;

◆ _BL_MEMORY_CLASS

enum _BL_MEMORY_CLASS

Enumerator
BlLoaderClass
BlApplicationClass
BlSystemClass

Definition at line 291 of file bl.h.

{
    BlLoaderClass = 0xD,
    BlApplicationClass,
    BlSystemClass
} BL_MEMORY_CLASS;

◆ _BL_MEMORY_DESCRIPTOR_TYPE

enum _BL_MEMORY_DESCRIPTOR_TYPE

Enumerator
BlMdPhysical
BlMdVirtual
BlMdTracker

Definition at line 221 of file bl.h.

{
    BlMdPhysical,
    BlMdVirtual,
    BlMdTracker
} BL_MEMORY_DESCRIPTOR_TYPE;

◆ _BL_MEMORY_TYPE

enum _BL_MEMORY_TYPE

Enumerator
BlLoaderMemory
BlLoaderDeviceMemory
BlLoaderHeap
BlLoaderPageDirectory
BlLoaderReferencePage
BlLoaderRamDisk
BlLoaderArchData
BlLoaderData
BlLoaderRegistry
BlLoaderBlockMemory
BlLoaderSelfMap
BlApplicationReserved
BlApplicationData
BlConventionalMemory
BlUnusableMemory
BlReservedMemory
BlEfiBootMemory
BlConventionalZeroedMemory
BlEfiRuntimeCodeMemory
BlAcpiReclaimMemory
BlAcpiNvsMemory
BlDeviceIoMemory
BlDevicePortMemory
BlPalMemory
BlEfiRuntimeDataMemory

Definition at line 301 of file bl.h.

{
    //
    // Loader Memory
    //
    BlLoaderMemory = 0xD0000002,
    BlLoaderDeviceMemory = 0xD0000004,
    BlLoaderHeap = 0xD0000005,
    BlLoaderPageDirectory = 0xD0000006,
    BlLoaderReferencePage = 0xD0000007,
    BlLoaderRamDisk = 0xD0000008,
    BlLoaderArchData = 0xD0000009,
    BlLoaderData = 0xD000000A,
    BlLoaderRegistry = 0xD000000B,
    BlLoaderBlockMemory = 0xD000000C,
    BlLoaderSelfMap = 0xD000000F,
 
    //
    // Application Memory
    //
    BlApplicationReserved = 0xE0000001,
    BlApplicationData = 0xE0000004,
 
    //
    // System Memory
    //
    BlConventionalMemory = 0xF0000001,
    BlUnusableMemory = 0xF0000002,
    BlReservedMemory = 0xF0000003,
    BlEfiBootMemory = 0xF0000004,
    BlConventionalZeroedMemory = 0xF000005,
    BlEfiRuntimeCodeMemory = 0xF0000006,
    BlAcpiReclaimMemory = 0xF0000008,
    BlAcpiNvsMemory = 0xF0000009,
    BlDeviceIoMemory = 0xF000000A,
    BlDevicePortMemory = 0xF000000B,
    BlPalMemory = 0xF000000C,
    BlEfiRuntimeDataMemory = 0xF000000E,
} BL_MEMORY_TYPE;

◆ _BL_MENU_POLICY

enum _BL_MENU_POLICY

Enumerator
MenuPolicyLegacy
MenuPolicyStandard

Definition at line 215 of file bl.h.

{
    MenuPolicyLegacy = 0,
    MenuPolicyStandard = 1
} BL_MENU_POLICY;

◆ _BL_PARTITION_TYPE

enum _BL_PARTITION_TYPE

Enumerator
GptPartition
MbrPartition
RawPartition

Definition at line 272 of file bl.h.

{
    GptPartition,
    MbrPartition,
    RawPartition,
} BL_PARTITION_TYPE;

◆ _BL_PATH_TYPE

enum _BL_PATH_TYPE

Enumerator
InternalPath
EfiPath

Definition at line 282 of file bl.h.

{
    InternalPath = 3,
    EfiPath = 4
} BL_PATH_TYPE;

◆ _BL_TRANSLATION_TYPE

enum _BL_TRANSLATION_TYPE

Enumerator
BlNone
BlVirtual
BlPae
BlMax

Definition at line 228 of file bl.h.

{
    BlNone,
    BlVirtual,
    BlPae,
    BlMax
} BL_TRANSLATION_TYPE;

Function Documentation

◆ Archx86TransferTo32BitApplicationAsm()

VOID Archx86TransferTo32BitApplicationAsm ( VOID )

Definition at line 51 of file arch.c.

{
    EfiPrintf(L" Archx86TransferTo32BitApplicationAsm NOT IMPLEMENTED for this platform\r\n");
}

Referenced by ImgArchEfiStartBootApplication().

◆ BcInitialize()

NTSTATUS BcInitialize ( VOID )

Definition at line 73 of file blkcache.c.

{
    NTSTATUS Status;
 
    Status = BlHtCreate(50, BcpHashFunction, BcpCompareKey, &BcpHashTableId);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    BcpBlockAllocatorHandle = BlpMmCreateBlockAllocator();
    if (BcpBlockAllocatorHandle == -1)
    {
        Status = STATUS_UNSUCCESSFUL;
        goto Quickie;
    }
 
    Status = BlpIoRegisterDestroyRoutine(BcpDestroy);
    if (Status >= 0)
    {
        return Status;
    }
 
Quickie:
    EfiPrintf(L"Failure path not yet implemented\r\n");
#if 0
    if (BcpHashTableId != -1)
    {
        BlHtDestroy(BcpHashTableId);
    }
    if (BcpBlockAllocatorHandle != -1)
    {
        BlpMmDeleteBlockAllocator(BcpBlockAllocatorHandle);
    }
#endif
    return Status;
}

Referenced by BlockIopInitialize().

◆ BfClearScreen()

NTSTATUS BfClearScreen ( _In_ PBL_GRAPHICS_CONSOLE Console )

Definition at line 158 of file font.c.

{
    NTSTATUS Status;
 
    /* Reset the cursor position */
    Console->TextConsole.State.XPos = 0;
    Console->TextConsole.State.YPos = 0;
 
    /* Fill the screen with the background color */
    Status = ConsoleGraphicalClearPixels(Console,
                                         Console->TextConsole.State.BgColor);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Check if the cursor should be visible */
    if (Console->TextConsole.State.CursorVisible)
    {
        /* Load any fonts at this time */
        if (!IsListEmpty(&BfiDeferredListHead))
        {
            BfLoadDeferredFontFiles();
        }
 
        /* Switch the cursor to visible */
        Status = BfiFlipCursorCharacter(Console, TRUE);
    }
    else
    {
        /* Nothing left to do */
        Status = STATUS_SUCCESS;
    }
 
    /* Return cursor flip result, if any */
    return Status;
}

Referenced by ConsoleGraphicalClearText().

◆ BfClearToEndOfLine()

NTSTATUS BfClearToEndOfLine ( _In_ PBL_GRAPHICS_CONSOLE Console )

Definition at line 149 of file font.c.

{
    /* not implemented */
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by ConsoleGraphicalClearText().

◆ BfiFreeDeferredFontFile()

VOID BfiFreeDeferredFontFile ( _In_ PBL_DEFERRED_FONT_FILE DeferredFontFile )

Definition at line 30 of file font.c.

{
    /* Free the device copy if there was one */
    if (DeferredFontFile->Device)
    {
        BlMmFreeHeap(DeferredFontFile->Device);
    }
 
    /* Free the path copy if there was one */
    if (DeferredFontFile->FontPath)
    {
        BlMmFreeHeap(DeferredFontFile->FontPath);
    }
 
    /* Free the whole thing */
    BlMmFreeHeap(DeferredFontFile);
}

Referenced by BfLoadDeferredFontFiles(), BfLoadFontFile(), and BlpDisplayRegisterLocale().

◆ BfLoadDeferredFontFiles()

NTSTATUS BfLoadDeferredFontFiles ( VOID )

Definition at line 99 of file font.c.

{
    PLIST_ENTRY NextEntry;
    PBL_DEFERRED_FONT_FILE DeferredFont;
    NTSTATUS Status, LoadStatus;
 
    /* Assume empty list */
    Status = STATUS_SUCCESS;
 
    /* Parse the list */
    NextEntry = BfiDeferredListHead.Flink;
    while (NextEntry != &BfiDeferredListHead)
    {
        /* Get the font */
        DeferredFont = CONTAINING_RECORD(NextEntry, BL_DEFERRED_FONT_FILE, ListEntry);
 
        /* Move to the next entry and remove this one */
        NextEntry = NextEntry->Flink;
        RemoveEntryList(&DeferredFont->ListEntry);
 
        /* Load the font */
        LoadStatus = BfiLoadFontFile(DeferredFont->Device,
                                     DeferredFont->FontPath);
        if (!NT_SUCCESS(LoadStatus))
        {
            /* Remember the load failure if there was one */
            Status = LoadStatus;
        }
 
        /* Free the deferred font */
        BfiFreeDeferredFontFile(DeferredFont);
    }
 
    /* Return load status */
    return Status;
}

Referenced by BfClearScreen(), and BlResourceFindMessage().

◆ BfLoadFontFile()

NTSTATUS BfLoadFontFile	(	_In_ PBL_DEVICE_DESCRIPTOR	Device,
		_In_ PWCHAR	FontPath
	)

Definition at line 51 of file font.c.

{
    PBL_DEFERRED_FONT_FILE DeferredFont;
    SIZE_T FontPathSize;
 
    /* Allocate the deferred font structure */
    DeferredFont = (PBL_DEFERRED_FONT_FILE)BlMmAllocateHeap(sizeof(*DeferredFont));
    if (!DeferredFont)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Zero it out */
    RtlZeroMemory(DeferredFont, sizeof(*DeferredFont));
 
    /* Allocate a copy for the file path */
    FontPathSize = sizeof(WCHAR) * wcslen(FontPath) + sizeof(UNICODE_NULL);
    DeferredFont->FontPath = (PWCHAR)BlMmAllocateHeap(FontPathSize);
    if (!DeferredFont->FontPath)
    {
        BfiFreeDeferredFontFile(DeferredFont);
        return STATUS_NO_MEMORY;
    }
 
    /* Allocate a copy for the device */
    DeferredFont->Device = BlMmAllocateHeap(Device->Size);
    if (!DeferredFont->Device)
    {
        BfiFreeDeferredFontFile(DeferredFont);
        return STATUS_NO_MEMORY;
    }
 
    /* Copy the path and device */
    RtlCopyMemory(DeferredFont->FontPath, FontPath, FontPathSize);
    RtlCopyMemory(DeferredFont->Device,Device, Device->Size);
 
    /* Set pending flag? */
    DeferredFont->Flags = 1;
 
    /* Insert it into the list */
    InsertTailList(&BfiDeferredListHead, &DeferredFont->ListEntry);
    return STATUS_SUCCESS;
}

Referenced by DsppLoadFontFile().

◆ BiCloseKey()

VOID BiCloseKey ( _In_ HANDLE KeyHandle )

Definition at line 141 of file bootreg.c.

{
    PBI_KEY_HIVE KeyHive;
    PBI_KEY_OBJECT KeyObject;
 
    /* Get the key object and hive */
    KeyObject = (PBI_KEY_OBJECT)KeyHandle;
    KeyHive = KeyObject->KeyHive;
 
    /* Check if we have a hive, or name, or key node */
    if ((KeyHive) || (KeyObject->KeyNode) || (KeyObject->KeyName))
    {
        /* Drop a reference, see if it's the last one */
        BiDereferenceHive(KeyHandle);
        if (!KeyHive->ReferenceCount)
        {
            /* Check if we should flush it */
            if (KeyHive->Flags & BI_FLUSH_HIVE)
            {
                BiFlushHive(KeyHandle);
            }
 
            /* Unmap the hive */
            MmPapFreePages(KeyHive->BaseBlock, BL_MM_INCLUDE_MAPPED_ALLOCATED);
 
            /* Free the hive and hive path */
            BlMmFreeHeap(KeyHive->FilePath);
            BlMmFreeHeap(KeyHive);
        }
 
        /* Check if a key name is present */
        if (KeyObject->KeyName)
        {
            /* Free it */
            BlMmFreeHeap(KeyObject->KeyName);
        }
    }
 
    /* Free the object */
    BlMmFreeHeap(KeyObject);
}

Referenced by BcdDeleteElement(), BcdOpenObject(), BiAddStoreFromFile(), BiDeleteKey(), BiEnumerateElements(), BiEnumerateSubElements(), BiGetObjectDescription(), BmCloseDataStore(), BmGetEntryDescription(), BmGetOptionList(), and BmPurgeOption().

◆ BiDeleteKey()

NTSTATUS BiDeleteKey ( _In_ HANDLE KeyHandle )

Definition at line 892 of file bootreg.c.

{
    NTSTATUS Status;
    PBI_KEY_OBJECT KeyObject;
    PHHIVE Hive;
    ULONG SubKeyCount, i;
    PWCHAR* SubKeyList;
    HANDLE SubKeyHandle;
 
    /* Get the key object and hive */
    KeyObject = (PBI_KEY_OBJECT)KeyHandle;
    Hive = &KeyObject->KeyHive->Hive.Hive;
 
    /* Make sure the hive is writeable */
    if (!(KeyObject->KeyHive->Flags & BI_HIVE_WRITEABLE))
    {
        return STATUS_MEDIA_WRITE_PROTECTED;
    }
 
    /* Enumerate all of the subkeys */
    Status = BiEnumerateSubKeys(KeyHandle, &SubKeyList, &SubKeyCount);
    if ((NT_SUCCESS(Status)) && (SubKeyCount > 0))
    {
        /* Loop through each one */
        for (i = 0; i < SubKeyCount; i++)
        {
            /* Open a handle to it */
            Status = BiOpenKey(KeyHandle, SubKeyList[i], &SubKeyHandle);
            if (NT_SUCCESS(Status))
            {
                /* Recursively call us to delete it */
                Status = BiDeleteKey(SubKeyHandle);
                if (Status != STATUS_SUCCESS)
                {
                    /* Close the key on failure */
                    BiCloseKey(SubKeyHandle);
                }
            }
        }
    }
 
    /* Check if we had a list of subkeys */
    if (SubKeyList)
    {
        /* Free it */
        BlMmFreeHeap(SubKeyList);
    }
 
    /* Delete this key cell */
    Status = CmpFreeKeyByCell(Hive, KeyObject->KeyCell, TRUE);
    if (NT_SUCCESS(Status))
    {
        /* Mark the hive as requiring a flush */
        KeyObject->KeyHive->Flags |= BI_FLUSH_HIVE;
        BiCloseKey(KeyHandle);
    }
 
    /* All done */
    return Status;
}

Referenced by BcdDeleteElement(), and BiDeleteKey().

◆ BiDereferenceHive()

VOID BiDereferenceHive ( _In_ HANDLE KeyHandle )

Definition at line 117 of file bootreg.c.

{
    PBI_KEY_OBJECT KeyObject;
 
    /* Get the key object */
    KeyObject = (PBI_KEY_OBJECT)KeyHandle;
 
    /* Drop a reference on the parent hive */
    --KeyObject->KeyHive->ReferenceCount;
}

Referenced by BiAddStoreFromFile(), BiCloseKey(), and BmCloseDataStore().

◆ BiEnumerateSubKeys()

NTSTATUS BiEnumerateSubKeys	(	_In_ HANDLE	KeyHandle,
		_Out_ PWCHAR **	SubKeyList,
		_Out_ PULONG	SubKeyCount
	)

Definition at line 723 of file bootreg.c.

{
    PCM_KEY_NODE KeyNode, Node;
    PBI_KEY_OBJECT KeyObject;
    ULONG KeyCount;
    ULONG NameLength, NewTotalNameLength, FinalLength, TotalNameLength;
    PHHIVE Hive;
    PWCHAR KeyName, NameEnd;
    HCELL_INDEX CellIndex;
    PWCHAR* SubKeys;
    NTSTATUS Status;
    ULONG i;
 
    /* Get the key object, node, and hive */
    KeyObject = (PBI_KEY_OBJECT)KeyHandle;
    KeyNode = KeyObject->KeyNode;
    Hive = &KeyObject->KeyHive->Hive.Hive;
 
    /* Assume it's empty */
    *SubKeyList = 0;
    *SubKeyCount = 0;
 
    /* Initialize locals */
    KeyCount = 0;
    SubKeys = 0;
    TotalNameLength = 0;
 
    /* Find the first subkey cell index */
    CellIndex = CmpFindSubKeyByNumber(Hive, KeyNode, KeyCount);
    while (CellIndex != HCELL_NIL)
    {
        /* Move to the next one */
        KeyCount++;
 
        /* Get the cell data for it */
        Node = (PCM_KEY_NODE)HvGetCell(Hive, CellIndex);
        if (!Node)
        {
            return STATUS_REGISTRY_CORRUPT;
        }
 
        /* Check if the value is compressed */
        if (Node->Flags & KEY_COMP_NAME)
        {
            /* Get the compressed name size */
            NameLength = CmpCompressedNameSize(Node->Name, Node->NameLength);
        }
        else
        {
            /* Get the real size */
            NameLength = Node->NameLength;
        }
 
        /* Add up the new length, protecting against overflow */
        NewTotalNameLength = TotalNameLength + NameLength + sizeof(UNICODE_NULL);
        if (NewTotalNameLength < TotalNameLength)
        {
            Status = STATUS_NAME_TOO_LONG;
            goto Quickie;
        }
 
        /* We're good, use the new length */
        TotalNameLength = NewTotalNameLength;
 
        /* Find the next subkey cell index */
        CellIndex = CmpFindSubKeyByNumber(Hive, KeyNode, KeyCount);
    }
 
    /* Were there no keys? We're done, if so */
    if (!KeyCount)
    {
        return STATUS_SUCCESS;
    }
 
    /* Safely compute the size of the array needed */
    Status = RtlULongLongToULong(sizeof(PWCHAR) * KeyCount, &FinalLength);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Safely add that to the name length */
    Status = RtlULongAdd(TotalNameLength, FinalLength, &FinalLength);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Allocate an array big enough for the names and pointers */
    SubKeys = BlMmAllocateHeap(FinalLength);
    if (!SubKeys)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Go over each key again */
    NameEnd = (PWCHAR)&SubKeys[KeyCount];
    for (i = 0; i < KeyCount; i++)
    {
        /* Get the cell index for this subkey */
        CellIndex = CmpFindSubKeyByNumber(Hive, KeyNode, i);
        if (CellIndex == HCELL_NIL)
        {
            break;
        }
 
        /* Get the cell data for it */
        Node = (PCM_KEY_NODE)HvGetCell(Hive, CellIndex);
        if (!Node)
        {
            Status = STATUS_REGISTRY_CORRUPT;
            goto Quickie;
        }
 
        /* Check if the value is compressed */
        KeyName = Node->Name;
        if (Node->Flags & KEY_COMP_NAME)
        {
            /* Get the compressed name size */
            NameLength = CmpCompressedNameSize(KeyName, Node->NameLength);
            CmpCopyCompressedName(NameEnd, NameLength, KeyName, Node->NameLength);
        }
        else
        {
            /* Get the real size */
            NameLength = Node->NameLength;
            RtlCopyMemory(NameEnd, KeyName, NameLength);
        }
 
        /* Move the name buffer to the next spot, and NULL-terminate */
        SubKeys[i] = NameEnd;
        NameEnd += (NameLength / sizeof(WCHAR));
        *NameEnd = UNICODE_NULL;
 
        /* Keep going */
        NameEnd++;
    }
 
    /* Check if the subkeys were empty */
    if (i == 0)
    {
        /* They disappeared in the middle of enumeration */
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
        goto Quickie;
    }
 
    /* Return the count and the array of names */
    *SubKeyList = SubKeys;
    *SubKeyCount = i;
    SubKeys = NULL;
    Status = STATUS_SUCCESS;
 
Quickie:
    /* On the failure path, free the subkeys if any exist */
    if (SubKeys)
    {
        BlMmFreeHeap(SubKeys);
    }
 
    /* All done, return the result */
    return Status;
}

Referenced by BiDeleteKey(), and BiEnumerateElements().

◆ BiGetRegistryValue()

NTSTATUS BiGetRegistryValue	(	_In_ HANDLE	KeyHandle,
		_In_ PWCHAR	ValueName,
		_In_ ULONG	Type,
		_Out_ PVOID *	Buffer,
		_Out_ PULONG	ValueLength
	)

Definition at line 657 of file bootreg.c.

{
    PCM_KEY_NODE KeyNode;
    PHHIVE KeyHive;
    UNICODE_STRING ValueString;
    PBI_KEY_OBJECT KeyObject;
    PCM_KEY_VALUE KeyValue;
    PVOID ValueCopy;
    ULONG Size;
    HCELL_INDEX CellIndex;
    PCELL_DATA ValueData;
 
    /* Get the key object, node,and hive */
    KeyObject = (PBI_KEY_OBJECT)KeyHandle;
    KeyNode = KeyObject->KeyNode;
    KeyHive = &KeyObject->KeyHive->Hive.Hive;
 
    /* Find the value cell index in the list of values */
    RtlInitUnicodeString(&ValueString, ValueName);
    CmpFindNameInList(KeyHive,
                      &KeyNode->ValueList,
                      &ValueString,
                      NULL,
                      &CellIndex);
    if (CellIndex == HCELL_NIL)
    {
        return STATUS_OBJECT_NAME_NOT_FOUND;
    }
 
    /* Get the cell data for it */
    KeyValue = (PCM_KEY_VALUE)HvGetCell(KeyHive, CellIndex);
    if (!KeyValue)
    {
        return STATUS_REGISTRY_CORRUPT;
    }
 
    /* Make sure the type matches */
    if (KeyValue->Type != Type)
    {
        return STATUS_OBJECT_TYPE_MISMATCH;
    }
 
    /* Now get the data cell */
    ValueData = CmpValueToData(KeyHive, KeyValue, &Size);
 
    /* Make a copy of it */
    ValueCopy = BlMmAllocateHeap(Size);
    if (!ValueCopy)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Copy it in the buffer, and return it and its size */
    RtlCopyMemory(ValueCopy, ValueData, Size);
    *Buffer = ValueCopy;
    *ValueLength = Size;
    return STATUS_SUCCESS;
}

Referenced by BiEnumerateElements(), and BiGetObjectDescription().

◆ BiLoadHive()

NTSTATUS BiLoadHive	(	_In_ PBL_FILE_PATH_DESCRIPTOR	FilePath,
		_Out_ PHANDLE	HiveHandle
	)

Definition at line 369 of file bootreg.c.

{
    ULONG DeviceId;
    PHBASE_BLOCK BaseBlock, NewBaseBlock;
    PBI_KEY_OBJECT KeyObject;
    PBI_KEY_HIVE BcdHive;
    PBL_DEVICE_DESCRIPTOR BcdDevice;
    ULONG PathLength, DeviceLength, HiveSize, HiveLength, NewHiveSize;
    PWCHAR HiveName, LogName;
    BOOLEAN HaveWriteAccess;
    NTSTATUS Status;
    PVOID LogData;
    PHHIVE Hive;
    UNICODE_STRING KeyString;
    PCM_KEY_NODE RootNode;
    HCELL_INDEX CellIndex;
 
    /* Initialize variables */
    DeviceId = -1;
    BaseBlock = NULL;
    BcdHive = NULL;
    KeyObject = NULL;
    LogData = NULL;
    LogName = NULL;
 
    /* Initialize the crypto seed */
    if (!BiHiveHashLibraryInitialized)
    {
        HvSymcryptSeed = 0x82EF4D887A4E55C5;
        BiHiveHashLibraryInitialized = TRUE;
    }
 
    /* Extract and validate the input path */
    BcdDevice = (PBL_DEVICE_DESCRIPTOR)&FilePath->Path;
    PathLength = FilePath->Length;
    DeviceLength = BcdDevice->Size;
    HiveName = (PWCHAR)((ULONG_PTR)BcdDevice + BcdDevice->Size);
    if (PathLength <= DeviceLength)
    {
        /* Doesn't make sense, bail out */
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Attempt to open the underlying device for RW access */
    HaveWriteAccess = TRUE;
    Status = BlpDeviceOpen(BcdDevice,
                           BL_DEVICE_READ_ACCESS | BL_DEVICE_WRITE_ACCESS,
                           0,
                           &DeviceId);
    if (!NT_SUCCESS(Status))
    {
        /* Try for RO access instead */
        HaveWriteAccess = FALSE;
        Status = BlpDeviceOpen(BcdDevice, BL_DEVICE_READ_ACCESS, 0, &DeviceId);
        if (!NT_SUCCESS(Status))
        {
            /* No access at all -- bail out */
            goto Quickie;
        }
    }
 
    /* Now try to load the hive on disk */
    Status = BlImgLoadImageWithProgress2(DeviceId,
                                         BlLoaderRegistry,
                                         HiveName,
                                         (PVOID*)&BaseBlock,
                                         &HiveSize,
                                         0,
                                         FALSE,
                                         NULL,
                                         NULL);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Hive read failure: % lx\r\n", Status);
        goto Quickie;
    }
 
    /* Allocate a hive structure */
    BcdHive = BlMmAllocateHeap(sizeof(*BcdHive));
    if (!BcdHive)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Initialize it */
    RtlZeroMemory(BcdHive, sizeof(*BcdHive));
    BcdHive->BaseBlock = BaseBlock;
    BcdHive->HiveSize = HiveSize;
    if (HaveWriteAccess)
    {
        BcdHive->Flags |= BI_HIVE_WRITEABLE;
    }
 
    /* Make sure the hive was at least one bin long */
    if (HiveSize < sizeof(*BaseBlock))
    {
        Status = STATUS_REGISTRY_CORRUPT;
        goto Quickie;
    }
 
    /* Make sure the hive contents are at least one bin long */
    HiveLength = BaseBlock->Length;
    if (BaseBlock->Length < sizeof(*BaseBlock))
    {
        Status = STATUS_REGISTRY_CORRUPT;
        goto Quickie;
    }
 
    /* Validate the initial bin (the base block) */
    if (!HvIsInPlaceBaseBlockValid(BaseBlock))
    {
        EfiPrintf(L"Recovery not implemented\r\n");
        Status = STATUS_REGISTRY_CORRUPT;
        goto Quickie;
    }
 
    /* Check if there's log recovery that needs to happen */
    if (BaseBlock->Sequence1 != BaseBlock->Sequence2)
    {
        EfiPrintf(L"Log fix not implemented: %lx %lx\r\n");
        Status = STATUS_REGISTRY_CORRUPT;
        goto Quickie;
    }
 
    /*
     * Check if the whole hive doesn't fit in the buffer.
     * Note: HiveLength does not include the size of the baseblock itself
     */
    if (HiveSize < (HiveLength + sizeof(*BaseBlock)))
    {
        EfiPrintf(L"Need bigger hive buffer path\r\n");
 
        /* Allocate a slightly bigger buffer */
        NewHiveSize = HiveLength + sizeof(*BaseBlock);
        Status = MmPapAllocatePagesInRange((PVOID*)&NewBaseBlock,
                                           BlLoaderRegistry,
                                           NewHiveSize >> PAGE_SHIFT,
                                           0,
                                           0,
                                           NULL,
                                           0);
        if (!NT_SUCCESS(Status))
        {
            goto Quickie;
        }
 
        /* Copy the current data in there */
        RtlCopyMemory(NewBaseBlock, BaseBlock, HiveSize);
 
        /* Free the old data */
        MmPapFreePages(BaseBlock, BL_MM_INCLUDE_MAPPED_ALLOCATED);
 
        /* Update our pointers */
        BaseBlock = NewBaseBlock;
        HiveSize = NewHiveSize;
        BcdHive->BaseBlock = BaseBlock;
        BcdHive->HiveSize = HiveSize;
    }
 
    /* Check if any log stuff needs to happen */
    if (LogData)
    {
        EfiPrintf(L"Log fix not implemented: %lx %lx\r\n");
        Status = STATUS_REGISTRY_CORRUPT;
        goto Quickie;
    }
 
    /* Call Hv to setup the hive library */
    Status = BiInitializeAndValidateHive(BcdHive);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Now get the root node */
    Hive = &BcdHive->Hive.Hive;
    RootNode = (PCM_KEY_NODE)HvGetCell(Hive, Hive->BaseBlock->RootCell);
    if (!RootNode)
    {
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
        goto Quickie;
    }
 
    /* Find the Objects subkey under it to see if it's a real BCD hive */
    RtlInitUnicodeString(&KeyString, L"Objects");
    CellIndex = CmpFindSubKeyByName(Hive, RootNode, &KeyString);
    if (CellIndex == HCELL_NIL)
    {
        EfiPrintf(L"No OBJECTS subkey found!\r\n");
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
        goto Quickie;
    }
 
    /* This is a valid BCD hive, store its root node here */
    BcdHive->RootNode = RootNode;
 
    /* Allocate a copy of the file path */
    BcdHive->FilePath = BlMmAllocateHeap(FilePath->Length);
    if (!BcdHive->FilePath)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Make a copy of it */
    RtlCopyMemory(BcdHive->FilePath, FilePath, FilePath->Length);
 
    /* Create a key object to describe the rot */
    KeyObject = BlMmAllocateHeap(sizeof(*KeyObject));
    if (!KeyObject)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Fill out the details */
    KeyObject->KeyNode = RootNode;
    KeyObject->KeyHive = BcdHive;
    KeyObject->KeyName = NULL;
    KeyObject->KeyCell = Hive->BaseBlock->RootCell;
 
    /* One reference for the key object, plus one lifetime reference */
    BcdHive->ReferenceCount = 2;
 
    /* This is the hive handle */
    *HiveHandle  = KeyObject;
 
    /* We're all good */
    Status = STATUS_SUCCESS;
 
Quickie:
    /* If we had a log name, free it */
    if (LogName)
    {
        BlMmFreeHeap(LogName);
    }
 
    /* If we had logging data, free it */
    if (LogData)
    {
        MmPapFreePages(LogData, BL_MM_INCLUDE_MAPPED_ALLOCATED);
    }
 
    /* Check if this is the failure path */
    if (!NT_SUCCESS(Status))
    {
        /* If we mapped the hive, free it */
        if (BaseBlock)
        {
            MmPapFreePages(BaseBlock, BL_MM_INCLUDE_MAPPED_ALLOCATED);
        }
 
        /* If we opened the device, close it */
        if (DeviceId != -1)
        {
            BlDeviceClose(DeviceId);
        }
 
        /* Did we create a hive object? */
        if (BcdHive)
        {
            /* Free the file path if we made a copy of it */
            if (BcdHive->FilePath)
            {
                BlMmFreeHeap(BcdHive->FilePath);
            }
 
            /* Free the hive itself */
            BlMmFreeHeap(BcdHive);
        }
 
        /* Finally, free the root key object if we created one */
        if (KeyObject)
        {
            BlMmFreeHeap(KeyObject);
        }
    }
 
    /* Return the final status */
    return Status;
}

Referenced by BiAddStoreFromFile().

◆ BiOpenKey()

NTSTATUS BiOpenKey	(	_In_ HANDLE	ParentHandle,
		_In_ PWCHAR	KeyName,
		_Out_ PHANDLE	Handle
	)

Definition at line 186 of file bootreg.c.

{
    PBI_KEY_OBJECT ParentKey, NewKey;
    PBI_KEY_HIVE ParentHive;
    NTSTATUS Status;
    SIZE_T NameLength, SubNameLength, NameBytes;
    PWCHAR NameStart, NameBuffer;
    UNICODE_STRING KeyString;
    HCELL_INDEX KeyCell;
    PHHIVE Hive;
    PCM_KEY_NODE ParentNode;
 
    /* Convert from a handle to our key object */
    ParentKey = (PBI_KEY_OBJECT)ParentHandle;
 
    /* Extract the hive and node information */
    ParentHive = ParentKey->KeyHive;
    ParentNode = ParentKey->KeyNode;
    Hive = &ParentKey->KeyHive->Hive.Hive;
 
    /* Initialize variables */
    KeyCell = HCELL_NIL;
    Status = STATUS_SUCCESS;
    NameBuffer = NULL;
 
    /* Loop as long as there's still portions of the key name in play */
    NameLength = wcslen(KeyName);
    while (NameLength)
    {
        /* Find the first path separator */
        NameStart = wcschr(KeyName, OBJ_NAME_PATH_SEPARATOR);
        if (NameStart)
        {
            /* Look only at the key before the separator */
            SubNameLength = NameStart - KeyName;
            ++NameStart;
        }
        else
        {
            /* No path separator, this is the final leaf key */
            SubNameLength = NameLength;
        }
 
        /* Free the name buffer from the previous pass if needed */
        if (NameBuffer)
        {
            BlMmFreeHeap(NameBuffer);
        }
 
        /* Allocate a buffer to hold the name of this specific subkey only */
        NameBytes = SubNameLength * sizeof(WCHAR);
        NameBuffer = BlMmAllocateHeap(NameBytes + sizeof(UNICODE_NULL));
        if (!NameBuffer)
        {
            Status = STATUS_NO_MEMORY;
            goto Quickie;
        }
 
        /* Copy and null-terminate the name of the subkey */
        RtlCopyMemory(NameBuffer, KeyName, NameBytes);
        NameBuffer[SubNameLength] = UNICODE_NULL;
 
        /* Convert it into a UNICODE_STRING and try to find it */
        RtlInitUnicodeString(&KeyString, NameBuffer);
        KeyCell = CmpFindSubKeyByName(Hive, ParentNode, &KeyString);
        if (KeyCell == HCELL_NIL)
        {
            Status = STATUS_OBJECT_NAME_NOT_FOUND;
            goto Quickie;
        }
 
        /* We found it -- get the key node out of it */
        ParentNode = (PCM_KEY_NODE)HvGetCell(Hive, KeyCell);
        if (!ParentNode)
        {
            Status = STATUS_REGISTRY_CORRUPT;
            goto Quickie;
        }
 
        /* Update the key name to the next remaining path element */
        KeyName = NameStart;
        if (NameStart)
        {
            /* Update the length to the remainder of the path */
            NameLength += -1 - SubNameLength;
        }
        else
        {
            /* There's nothing left, this was the leaf key */
            NameLength = 0;
        }
    }
 
    /* Allocate a key object */
    NewKey = BlMmAllocateHeap(sizeof(*NewKey));
    if (!NewKey)
    {
        /* Bail out if we had no memory for it */
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Fill out the key object data */
    NewKey->KeyNode = ParentNode;
    NewKey->KeyHive = ParentHive;
    NewKey->KeyName = NameBuffer;
    NewKey->KeyCell = KeyCell;
 
    /* Add a reference to the hive */
    ++ParentHive->ReferenceCount;
 
    /* Return the object back to the caller */
    *Handle = NewKey;
 
Quickie:
    /* If we had a name buffer, free it */
    if (NameBuffer)
    {
        BlMmFreeHeap(NameBuffer);
    }
 
    /* Return status of the open operation */
    return Status;
}

Referenced by BcdDeleteElement(), BcdOpenObject(), BiAddStoreFromFile(), BiDeleteKey(), BiEnumerateElements(), and BiGetObjectDescription().

◆ BlAppendBootOptionBoolean()

NTSTATUS BlAppendBootOptionBoolean	(	_In_ PBL_LOADED_APPLICATION_ENTRY	AppEntry,
		_In_ ULONG	OptionId,
		_In_ BOOLEAN	Value
	)

Definition at line 625 of file bcdopt.c.

{
    NTSTATUS Status;
    PBL_BCD_OPTION Option;
 
    /* Allocate space for the entry -- remember BOOLEANs are USHORTs in BCD */
    Option = BlMmAllocateHeap(sizeof(*Option) + sizeof(USHORT));
    if (!Option)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Initialize it and set the boolean to TRUE */
    RtlZeroMemory(Option, sizeof(*Option) + sizeof(USHORT));
    Option->DataSize = sizeof(USHORT);
    Option->Type = OptionId;
    Option->DataOffset = sizeof(*Option);
    *(PBOOLEAN)(Option + 1) = Value;
 
    /* Append it */
    Status = BlAppendBootOptions(AppEntry, Option);
 
    /* We're all done, free our initial option */
    BlMmFreeHeap(Option);
    return Status;
}

Referenced by BmpLaunchBootEntry(), and OslPrepareTarget().

◆ BlAppendBootOptionInteger()

NTSTATUS BlAppendBootOptionInteger	(	_In_ PBL_LOADED_APPLICATION_ENTRY	AppEntry,
		_In_ ULONG	OptionId,
		_In_ ULONGLONG	Value
	)

Definition at line 657 of file bcdopt.c.

{
    NTSTATUS Status;
    PBL_BCD_OPTION Option;
 
    /* Allocate space for the entry */
    Option = BlMmAllocateHeap(sizeof(*Option) + sizeof(Value));
    if (!Option)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Initialize it and set the integer to the given value */
    RtlZeroMemory(Option, sizeof(*Option) + sizeof(Value));
    Option->DataSize = sizeof(Value);
    Option->Type = OptionId;
    Option->DataOffset = sizeof(*Option);
    *(PULONGLONG)(Option + 1) = Value;
 
    /* Append it */
    Status = BlAppendBootOptions(AppEntry, Option);
 
    /* We're all done, free our initial option */
    BlMmFreeHeap(Option);
    return Status;
}

Referenced by BlImgLoadBootApplication(), and BmLaunchRecoverySequence().

◆ BlAppendBootOptions()

NTSTATUS BlAppendBootOptions	(	_In_ PBL_LOADED_APPLICATION_ENTRY	AppEntry,
		_In_ PBL_BCD_OPTION	Options
	)

Definition at line 737 of file bcdopt.c.

{
    ULONG OptionsSize, CurrentSize;
    PBL_BCD_OPTION NewOptions, CurrentOptions, NextOption;
    NTSTATUS Status;
    ULONG CurrentOffset;
 
    /* Get the current options */
    CurrentOptions = AppEntry->BcdData;
 
    /* Calculate the size of the current, and the appended options */
    CurrentSize = BlGetBootOptionListSize(CurrentOptions);
    OptionsSize = BlGetBootOptionListSize(Options);
 
    /* Allocate a buffer for the concatenated (new) options */
    NewOptions = BlMmAllocateHeap(CurrentSize + OptionsSize);
    if (!NewOptions)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Copy the old options, and the ones to be added */
    RtlCopyMemory(NewOptions, CurrentOptions, CurrentSize);
    RtlCopyMemory((PVOID)((ULONG_PTR)NewOptions + CurrentSize),
                  Options,
                  OptionsSize);
 
    /* We made it! */
    Status = STATUS_SUCCESS;
 
    /* Scan through to the last option in the list */
    CurrentOffset = 0;
    do
    {
        NextOption = (PBL_BCD_OPTION)((ULONG_PTR)NewOptions + CurrentOffset);
        CurrentOffset = NextOption->NextEntryOffset;
    } while (CurrentOffset);
 
    /* Every other option now has to have its offset adjusted */
    do
    {
        NextOption->NextEntryOffset += CurrentSize;
        NextOption = (PBL_BCD_OPTION)((ULONG_PTR)NewOptions + NextOption->NextEntryOffset);
    } while (NextOption->NextEntryOffset);
 
    /* If we already had internal options, free them */
    if (AppEntry->Flags & BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL)
    {
        BlMmFreeHeap(AppEntry->BcdData);
    }
 
    /* Write the new pointer */
    AppEntry->BcdData = NewOptions;
 
    /* Options are now internal, not external */
    AppEntry->Flags &= ~BL_APPLICATION_ENTRY_BCD_OPTIONS_EXTERNAL;
    AppEntry->Flags |= BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL;
    return Status;
}

Referenced by BlAppendBootOptionBoolean(), BlAppendBootOptionInteger(), BlAppendBootOptionString(), and BmpUpdateApplicationOptions().

◆ BlAppendBootOptionString()

NTSTATUS BlAppendBootOptionString	(	_In_ PBL_LOADED_APPLICATION_ENTRY	AppEntry,
		_In_ ULONG	OptionId,
		_In_ PWCHAR	OptionString
	)

Definition at line 689 of file bcdopt.c.

{
    NTSTATUS Status;
    ULONG StringSize;
    PBL_BCD_OPTION Option;
 
    /* Get the length in bytes */
    Status = RtlULongLongToULong(wcslen(OptionString) * sizeof(WCHAR),
                                 &StringSize);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Add a NULL-terminator */
    Status = RtlULongAdd(StringSize, sizeof(UNICODE_NULL), &StringSize);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Allocate space for the entry */
    Option = BlMmAllocateHeap(sizeof(*Option) + StringSize);
    if (!Option)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Initialize it and copy the string value */
    RtlZeroMemory(Option, sizeof(*Option) + StringSize);
    Option->DataSize = StringSize;
    Option->Type = OptionId;
    Option->DataOffset = sizeof(*Option);
    wcsncpy((PWCHAR)Option + 1, OptionString, StringSize / sizeof(WCHAR));
 
    /* Append it */
    Status = BlAppendBootOptions(AppEntry, Option);
 
    /* We're all done, free our initial option */
    BlMmFreeHeap(Option);
    return Status;
}

Referenced by BmpPopulateBootEntryList(), and OslpRemoveInternalApplicationOptions().

◆ BlArchCpuId()

VOID BlArchCpuId	(	_In_ ULONG	Function,
		_In_ ULONG	SubFunction,
		_Out_ PCPU_INFO	Result
	)

Definition at line 924 of file util.c.

{
#if defined(_M_IX86) || defined(_M_X64)
    /* Use the intrinsic */
    __cpuidex((INT*)Result->AsUINT32, Function, SubFunction);
#endif
}

Referenced by BlArchGetCpuVendor(), BlArchGetPerformanceCounter(), MmArchInitialize(), OslMain(), and OslpMain().

◆ BlArchGetCpuVendor()

CPU_VENDORS BlArchGetCpuVendor ( VOID )

Definition at line 937 of file util.c.

{
    CPU_INFO CpuInfo;
    INT Temp;
 
    /* Get the CPU Vendor */
    BlArchCpuId(0, 0, &CpuInfo);
#if defined(_M_IX86) || defined(_M_X64)
    Temp = CpuInfo.Ecx;
    CpuInfo.Ecx = CpuInfo.Edx;
    CpuInfo.Edx = Temp;
 
    /* Check against supported values */
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "GenuineIntel", 12))
    {
        return CPU_INTEL;
    }
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "AuthenticAMD", 12))
    {
        return CPU_AMD;
    }
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "CentaurHauls", 12))
    {
        return CPU_VIA;
    }
#ifdef _M_IX86
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "CyrixInstead", 12))
    {
        return CPU_CYRIX;
    }
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "GenuineTMx86", 12))
    {
        return CPU_TRANSMETA;
    }
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "RiseRiseRise", 12))
    {
        return CPU_RISE;
    }
#endif // _M_IX86
#else // defined(_M_IX86) || defined(_M_X64)
    EfiPrintf(L"BlArchGetCpuVendor not implemented for this platform.\r\n");
#endif
    /* Other */
    return CPU_UNKNOWN;
}

Referenced by OslpMain().

◆ BlArchGetPerformanceCounter()

ULONGLONG BlArchGetPerformanceCounter ( VOID )

Definition at line 902 of file util.c.

{
#if defined(_M_IX86) || defined(_M_X64)
    CPU_INFO CpuInfo;
 
    /* Serialize with CPUID, if it exists */
    if (Archx86IsCpuidSupported())
    {
        BlArchCpuId(0, 0, &CpuInfo);
    }
 
    /* Read the TSC */
    return __rdtsc();
#else
    EfiPrintf(L"BlArchGetPerformanceCounter not implemented for this platform.\r\n");
    return 0;
#endif
}

Referenced by MmArchInitialize(), and OslPrepareTarget().

◆ BlArchIsCpuIdFunctionSupported()

BOOLEAN BlArchIsCpuIdFunctionSupported ( _In_ ULONG Function )

Definition at line 856 of file util.c.

{
#if defined(_M_IX86) || defined(_M_X64)
    BOOLEAN Supported;
    INT CpuInfo[4];
 
    /* Check if the CPU supports this instruction */
    Supported = Archx86IsCpuidSupported();
    if (!Supported)
    {
        return FALSE;
    }
 
    /* Check if it's the extended function */
    if (Function >= 0x80000000)
    {
        /* Check if extended functions are supported */
        __cpuid(CpuInfo, 0x80000000);
        if ((CpuInfo[0] & 0xFFFFFF00) != 0x80000000)
        {
            /* Nope */
            return FALSE;
        }
    }
    else
    {
        /* It's a regular function, get the maximum one supported */
        __cpuid(CpuInfo, 0);
    }
 
    /* Check if our function is within bounds */
    if (Function <= CpuInfo[0])
    {
        return TRUE;
    }
#else
    EfiPrintf(L"BlArchIsCpuIdFunctionSupported not implemented for this platform.\r\n");
#endif
 
    /* Nope */
    return FALSE;
}

Referenced by MmArchInitialize(), and OslMain().

◆ BlBdDebuggerEnabled()

BOOLEAN BlBdDebuggerEnabled ( VOID )

Definition at line 53 of file debug.c.

{
    BOOLEAN Initialized, Enabled;
 
    /* Check if the debugger is initialized */
    Initialized = BdDebuggerInitialized();
 
    /* Check if it's currently active */
    Enabled = FALSE;
    if ((Initialized) && !(BdDebuggerNotPresent))
    {
        /* Yep! */
        Enabled = TRUE;
    }
 
    /* Return enabled state */
    return Enabled;
}

Referenced by BlBdPullRemoteFile(), BlImgLoadBootApplication(), BlStatusError(), BlStatusPrint(), and MmHapReportHeapCorruption().

◆ BlBdPullRemoteFile()

NTSTATUS BlBdPullRemoteFile	(	_In_ PWCHAR	FilePath,
		_Out_ PVOID	BaseAddress,
		_Out_ PULONGLONG	FileSize
	)

Definition at line 34 of file debug.c.

{
    /* Is the boot debugger enabled? */
    if (!BlBdDebuggerEnabled())
    {
        /* Nothing to pull */
        return STATUS_DEBUGGER_INACTIVE;
    }
 
    /* TODO */
    EfiPrintf(L"Todo\r\n");
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by ImgpOpenFile().

◆ BlCopyBootOptions()

NTSTATUS BlCopyBootOptions	(	_In_ PBL_BCD_OPTION	OptionList,
		_Out_ PBL_BCD_OPTION *	CopiedOptions
	)

Definition at line 597 of file bcdopt.c.

{
    NTSTATUS Status;
    ULONG OptionSize;
    PBL_BCD_OPTION Options;
 
    /* Assume no options */
    Status = STATUS_SUCCESS;
    *CopiedOptions = NULL;
 
    /* Get the size of the list and allocate a copy for it */
    OptionSize = BlGetBootOptionListSize(OptionList);
    Options = BlMmAllocateHeap(OptionSize);
    if (!Options)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Make the copy and return it to the caller */
    RtlCopyMemory(Options, OptionList, OptionSize);
    *CopiedOptions = Options;
    return Status;
}

Referenced by BmMain().

◆ BlDestroyBootEntry()

VOID BlDestroyBootEntry ( _In_ PBL_LOADED_APPLICATION_ENTRY AppEntry )

Definition at line 442 of file bootlib.c.

{
    /* Check if we had allocated BCD options */
    if (AppEntry->Flags & BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL)
    {
        BlMmFreeHeap(AppEntry->BcdData);
    }
 
    /* Free the entry itself */
    BlMmFreeHeap(AppEntry);
}

Referenced by BmLaunchRecoverySequence(), BmMain(), BmpGetSelectedBootEntry(), and BmpPopulateBootEntryList().

◆ BlDestroyLibrary()

VOID BlDestroyLibrary ( VOID )

Definition at line 405 of file bootlib.c.

{
    EfiPrintf(L"Destroy not yet implemented\r\n");
    return;
}

Referenced by BmMain(), and OslMain().

◆ BlDeviceClose()

NTSTATUS BlDeviceClose ( _In_ ULONG DeviceId )

Definition at line 2073 of file device.c.

{
    PBL_DEVICE_ENTRY DeviceEntry;
 
    /* Validate the device ID */
    if (DmTableEntries <= DeviceId)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure there's a device there */
    DeviceEntry = DmDeviceTable[DeviceId];
    if (DeviceEntry == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure the device is active */
    if (!(DeviceEntry->Flags & BL_DEVICE_ENTRY_OPENED))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Drop a reference and check if it's the last one */
    DeviceEntry->ReferenceCount--;
    if (!DeviceEntry->ReferenceCount)
    {
        /* Mark the device as inactive */
        DeviceEntry->Flags = ~BL_DEVICE_ENTRY_OPENED;
    }
 
    /* We're good */
    return STATUS_SUCCESS;
}

Referenced by BiLoadHive(), BlBsdInitializeLog(), BlImgLoadBootApplication(), and BmFwInitializeBootDirectoryPath().

◆ BlDeviceGetInformation()

NTSTATUS BlDeviceGetInformation	(	_In_ ULONG	DeviceId,
		_Out_ PBL_DEVICE_INFORMATION	DeviceInformation
	)

Definition at line 682 of file device.c.

{
    PBL_DEVICE_ENTRY DeviceEntry;
 
    /* This parameter is not optional */
    if (!DeviceInformation)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure the device ID is valid */
    if (DmTableEntries <= DeviceId)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get the device entry */
    DeviceEntry = DmDeviceTable[DeviceId];
    if (!DeviceEntry)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure the device is open */
    if (!(DeviceEntry->Flags & BL_DEVICE_ENTRY_OPENED))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the device information */
    DeviceInformation->DeviceType = DeviceEntry->DeviceDescriptor->DeviceType;
    return DeviceEntry->Callbacks.GetInformation(DeviceEntry, DeviceInformation);
}

Referenced by BlDeviceReadAtOffset(), BlFileOpen(), BlFileReadEx(), EtfspCheckEtfs(), and FatMount().

◆ BlDeviceIsVirtualPartitionDevice()

BOOLEAN BlDeviceIsVirtualPartitionDevice	(	_In_ PBL_DEVICE_DESCRIPTOR	InputDevice,
		_Outptr_ PBL_DEVICE_DESCRIPTOR *	VirtualDevice
	)

Definition at line 612 of file device.c.

{
    BOOLEAN IsVirtual;
    PBL_LOCAL_DEVICE ParentDisk;
 
    /* Assume it isn't */
    IsVirtual = FALSE;
 
    /* Check if this is a partition device */
    if ((InputDevice->DeviceType == LegacyPartitionDevice) ||
        (InputDevice->DeviceType == PartitionDevice))
    {
        /* Check if the parent disk is a VHD */
        ParentDisk = &InputDevice->Partition.Disk;
        if (ParentDisk->Type == VirtualDiskDevice)
        {
            /* This is a virtual partition device -- does the caller want it? */
            IsVirtual = TRUE;
            if (VirtualDevice)
            {
                *VirtualDevice = (PBL_DEVICE_DESCRIPTOR)(&ParentDisk->VirtualHardDisk + 1);
            }
        }
    }
 
    /* Return */
    return IsVirtual;
}

Referenced by OslPrepareTarget().

◆ BlDeviceReadAtOffset()

NTSTATUS BlDeviceReadAtOffset	(	_In_ ULONG	DeviceId,
		_In_ ULONG	Size,
		_In_ ULONGLONG	Offset,
		_In_ PVOID	Buffer,
		_Out_ PULONG	BytesRead
	)

Definition at line 773 of file device.c.

{
    NTSTATUS Status;
    BL_DEVICE_INFORMATION DeviceInfo;
 
    /* Get the current block and offset  */
    Status = BlDeviceGetInformation(DeviceId, &DeviceInfo);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Get the block and block-offset based on the new raw offset */
    DeviceInfo.BlockDeviceInfo.Block = Offset / DeviceInfo.BlockDeviceInfo.BlockSize;
    DeviceInfo.BlockDeviceInfo.Offset = Offset % DeviceInfo.BlockDeviceInfo.BlockSize;
 
    /* Update the block and offset */
    Status = BlDeviceSetInformation(DeviceId, &DeviceInfo);
    if (NT_SUCCESS(Status))
    {
        /* Now issue a read, with this block and offset configured */
        Status = BlDeviceRead(DeviceId, Buffer, Size, BytesRead);
    }
 
    /* All good, return the caller */
    return Status;
}

Referenced by EtfspCheckEtfs(), EtfspGetDirent(), EtfsRead(), and FatMount().

◆ BlDeviceSetInformation()

NTSTATUS BlDeviceSetInformation	(	_In_ ULONG	DeviceId,
		_In_ PBL_DEVICE_INFORMATION	DeviceInformation
	)

Referenced by BlFileReadEx(), EtfspCheckEtfs(), and FatMount().

◆ BlDisplayClearScreen()

NTSTATUS BlDisplayClearScreen ( VOID )

Definition at line 943 of file display.c.

{
    NTSTATUS Status;
    PBL_TEXT_CONSOLE TextConsole;
 
    /* Nothing to do if there's no text console */
    Status = STATUS_SUCCESS;
    TextConsole = DspTextConsole;
    if (TextConsole)
    {
        /* Otherwise, clear the whole screen */
        Status = TextConsole->Callbacks->ClearText(TextConsole, FALSE);
        if (NT_SUCCESS(Status))
        {
            /* Invalidate the OEM bitmap at this point */
            BlDisplayInvalidateOemBitmap();
        }
    }
 
    /* All done */
    return Status;
};

Referenced by BmMain(), and OslDrawLogo().

◆ BlDisplayGetOemBitmap()

PBITMAP BlDisplayGetOemBitmap	(	_Out_ PCOORD	Offset,
		_Out_opt_ PULONG	Flags
	)

◆ BlDisplayGetScreenResolution()

NTSTATUS BlDisplayGetScreenResolution	(	_Out_ PULONG	HRes,
		_Out_ PULONG	Vres
	)

Definition at line 680 of file display.c.

{
    NTSTATUS Status;
    BL_DISPLAY_MODE Resolution;
    PBL_GRAPHICS_CONSOLE GraphicsConsole;
 
    /* Assume failure if no consoles are active */
    Status = STATUS_UNSUCCESSFUL;
 
    /* Do we have a text console? */
    if (DspTextConsole)
    {
        /* Do we have an active graphics console? */
        GraphicsConsole = DspGraphicalConsole;
        if ((GraphicsConsole) &&
            (((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->IsEnabled(GraphicsConsole)))
        {
            /* Get the resolution */
            Status = ((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->GetGraphicalResolution(GraphicsConsole, &Resolution);
            if (NT_SUCCESS(Status))
            {
                /* Return it back to the caller */
                *HRes = Resolution.HRes;
                *VRes = Resolution.VRes;
            }
        }
        else
        {
            /* Return defaults */
            *HRes = 640;
            *VRes = 200;
            Status = STATUS_SUCCESS;
        }
    }
 
    /* Return if we got a valid resolution back */
    return Status;
}

Referenced by BlDisplayValidOemBitmap(), and BlpResourceInitialize().

◆ BlDisplayGetTextCellResolution()

VOID BlDisplayGetTextCellResolution	(	_Out_ PULONG	TextWidth,
		_Out_ PULONG	TextHeight
	)

Definition at line 603 of file display.c.

{
    NTSTATUS Status;
    PBL_GRAPHICS_CONSOLE GraphicsConsole;
 
    /* If the caller doesn't want anything, bail out */
    if (!(TextWidth) || !(TextHeight))
    {
        return;
    }
 
    /* Do we have a text console? */
    Status = STATUS_UNSUCCESSFUL;
    if (DspTextConsole)
    {
        /* Do we have a graphics console? */
        GraphicsConsole = DspGraphicalConsole;
        if (GraphicsConsole)
        {
            /* Is it currently active? */
            if (((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->IsEnabled(GraphicsConsole))
            {
                /* Yep -- query it */
                EfiPrintf(L"GFX active, not supported query\r\n");
                Status = STATUS_NOT_IMPLEMENTED;
                //Status = ((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->GetTextCellResolution(GraphicsConsole);
            }
        }
    }
 
    /* Check if we failed to get it from the graphics console */
    if (!NT_SUCCESS(Status))
    {
        /* Set default text size */
        *TextWidth = 8;
        *TextHeight = 8;
    }
}

Referenced by ConsoleEfiTextGetStateFromMode(), ConsoleFirmwareTextClear(), and ConsoleFirmwareTextSetState().

◆ BlDisplayInvalidateOemBitmap()

VOID BlDisplayInvalidateOemBitmap ( VOID )

Definition at line 723 of file display.c.

{
    PBGRT_TABLE BgrtTable;
    NTSTATUS Status;
 
    /* Search for the BGRT */
    Status = BlUtlGetAcpiTable((PVOID*)&BgrtTable, BGRT_SIGNATURE);
    if (NT_SUCCESS(Status))
    {
        /* Mark the bitmap as invalid */
        BgrtTable->Status &= ~BGRT_STATUS_IMAGE_VALID;
 
        /* Unmap the table */
        BlMmUnmapVirtualAddressEx(BgrtTable, BgrtTable->Header.Length);
    }
}

Referenced by BlDisplayClearScreen(), ConsoleEfiGopClose(), and ConsoleEfiGopEnable().

◆ BlDisplaySetCursorType()

NTSTATUS BlDisplaySetCursorType ( _In_ ULONG Type )

Definition at line 969 of file display.c.

{
    NTSTATUS Status;
    PBL_TEXT_CONSOLE TextConsole;
    BL_DISPLAY_STATE State;
 
    /* Nothing to do if there's no text console */
    Status = STATUS_SUCCESS;
    TextConsole = DspTextConsole;
    if (TextConsole)
    {
        /* Write visibility state and call the function to change it */
        State.CursorVisible = Type;
        Status = TextConsole->Callbacks->SetTextState(TextConsole, 8, &State);
    }
 
    /* All done */
    return Status;
}

Referenced by BlXmiInitialize().

◆ BlDisplaySetScreenResolution()

NTSTATUS BlDisplaySetScreenResolution ( VOID )

Definition at line 646 of file display.c.

{
    PBL_GRAPHICS_CONSOLE Console;
    NTSTATUS Status;
 
    /* Assume success */
    Status = STATUS_SUCCESS;
 
    /* Do we have a graphics console? */
    Console = DspGraphicalConsole;
    if (Console)
    {
        /* Is it currently active? */
        if (((PBL_GRAPHICS_CONSOLE_VTABLE)Console->TextConsole.Callbacks)->IsEnabled(Console))
        {
            /* If so, disable it */
            return ((PBL_GRAPHICS_CONSOLE_VTABLE)Console->TextConsole.Callbacks)->Enable(Console, FALSE);
        }
    }
 
    /* We should've now fallen back to text mode */
    if (!DspTextConsole)
    {
        /* Then fail, as no display appears active */
        Status = STATUS_UNSUCCESSFUL;
    }
 
    /* Return back to the caller */
    return Status;
}

Referenced by BlResourceFindMessage(), and ResSelectLocale().

◆ BlDisplayValidOemBitmap()

BOOLEAN BlDisplayValidOemBitmap ( VOID )

Definition at line 880 of file display.c.

{
    PBITMAP Bitmap;
    ULONG HRes, VRes, Height, Width, Flags;
    COORD Offsets;
    BOOLEAN Result;
    NTSTATUS Status;
 
    /* First check if mobile graphics are enabled */
    Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
                                    BcdLibraryBoolean_MobileGraphics,
                                    &Result);
    if ((NT_SUCCESS(Status)) && (Result))
    {
        /* Yes, so use the firmware image */
        return TRUE;
    }
 
    /* Nope, so we'll check the ACPI OEM bitmap */
    Result = FALSE;
    Bitmap = BlDisplayGetOemBitmap(&Offsets, &Flags);
 
    /* Is there one? */
    if (Bitmap)
    {
        /* Is it valid? */
        if (Flags & BGRT_STATUS_IMAGE_VALID)
        {
            /* Get the current screen resolution */
            Status = BlDisplayGetScreenResolution(&HRes, &VRes);
            if (NT_SUCCESS(Status))
            {
                /* Is there a valid width? */
                Width = Bitmap->DibHeader.Width;
                if (Width)
                {
                    /* Is there a valid height? */
                    Height = Bitmap->DibHeader.Height;
                    if (Height)
                    {
                        /* Will if fit on this screen? */
                        if (((Width + Offsets.X) <= HRes) &&
                            ((Height + Offsets.Y) <= VRes))
                        {
                            /* Then it's all good! */
                            Result = TRUE;
                        }
                    }
                }
            }
        }
 
        /* Unmap the bitmap for now, it will be drawn later */
        BlMmUnmapVirtualAddressEx(Bitmap, Bitmap->BmpHeader.Size);
    }
 
    /* Return that a valid OEM bitmap exists */
    return Result;
}

Referenced by BmMain().

◆ BlFileClose()

NTSTATUS BlFileClose ( _In_ ULONG FileId )

Definition at line 220 of file file.c.

{
    PBL_FILE_ENTRY FileEntry;
 
    /* Validate the file ID */
    if (FileEntries <= FileId)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure a file entry actually exists */
    FileEntry = FileTable[FileId];
    if (!FileEntry)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* And that it's actually open */
    if (!(FileEntry->Flags & BL_FILE_ENTRY_OPENED))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Drop a reference, check if this was the last one */
    --FileEntry->ReferenceCount;
    if (!FileEntry->ReferenceCount)
    {
        /* File is no longer open */
        FileEntry->Flags &= ~BL_FILE_ENTRY_OPENED;
    }
 
    /* All good */
    return STATUS_SUCCESS;
}

Referenced by BlBsdInitializeLog(), BmFwInitializeBootDirectoryPath(), FileIoOpen(), and ImgpCloseFile().

◆ BlFileGetInformation()

NTSTATUS BlFileGetInformation	(	_In_ ULONG	FileId,
		_In_ PBL_FILE_INFORMATION	FileInfo
	)

Definition at line 564 of file file.c.

{
    PBL_FILE_ENTRY FileEntry;
 
    /* Make sure caller passed this in */
    if (!FileInfo)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validate file ID */
    if (FileId > FileEntries)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make sure an opened file exits with this ID */
    FileEntry = FileTable[FileId];
    if (!(FileEntry) || !(FileEntry->Flags & BL_FILE_ENTRY_OPENED))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Do the I/O operation */
    return FileEntry->Callbacks.GetInfo(FileEntry, FileInfo);
}

Referenced by BlFileReadAtOffsetEx(), BlFileReadEx(), and ImgpGetFileSize().

◆ BlFileOpen()

NTSTATUS BlFileOpen	(	_In_ ULONG	DeviceId,
		_In_ PWCHAR	FileName,
		_In_ ULONG	Flags,
		_Out_ PULONG	FileId
	)

Definition at line 477 of file file.c.

{
    NTSTATUS Status;
    PBL_FILE_ENTRY FileEntry;
    BL_DEVICE_INFORMATION DeviceInformation;
 
    /* Make sure we have a valid file name, access flags and parameters */
    if (!(FileName) ||
        (*FileName != OBJ_NAME_PATH_SEPARATOR) ||
        !(FileId) ||
        !(Flags & (BL_FILE_READ_ACCESS | BL_FILE_WRITE_ACCESS)))
    {
        EfiPrintf(L"Invalid file options\r\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get information on the underlying device */
    Status = BlDeviceGetInformation(DeviceId, &DeviceInformation);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Get device info failed: %lx\r\n", Status);
        return Status;
    }
 
    /* Make sure it's a device that can host files */
    if ((DeviceInformation.DeviceType != DiskDevice) &&
        (DeviceInformation.DeviceType != LegacyPartitionDevice) &&
        (DeviceInformation.DeviceType != UdpDevice))
    {
        EfiPrintf(L"Invalid device type\r\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Open a file on this device, creating one if needed */
    Status = FileIoOpen(DeviceId,
                        FileName,
                        Flags,
                        0,
                        FileTableCompareWithSameAttributes,
                        &FileEntry);
    if (NT_SUCCESS(Status))
    {
        /* Return the file ID back to the caller */
        *FileId = FileEntry->FileId;
    }
 
    /* All good */
    return Status;
}

Referenced by BlBsdInitializeLog(), BmFwInitializeBootDirectoryPath(), and ImgpOpenFile().

◆ BlFileReadAtOffsetEx()

NTSTATUS BlFileReadAtOffsetEx	(	_In_ ULONG	FileId,
		_In_ ULONG	Size,
		_In_ ULONGLONG	ByteOffset,
		_In_ PVOID	Buffer,
		_Out_ PULONG	BytesReturned,
		_In_ ULONG	Flags
	)

Definition at line 788 of file file.c.

{
    NTSTATUS Status;
    BL_FILE_INFORMATION FileInfo;
    ULONG RequiredSize;
    ULONGLONG FileOffset;
 
    /* Get information on the specified file */
    Status = BlFileGetInformation(FileId, &FileInfo);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Save the current offset, and overwrite it with the one we want */
    FileOffset = FileInfo.Offset;
    FileInfo.Offset = ByteOffset;
 
    /* Check the validity of the read and the actual size to read */
    RequiredSize = Size;
    Status = FileInformationCheck(&FileInfo,
                                  FALSE,
                                  &RequiredSize,
                                  BytesReturned,
                                  &RequiredSize);
    if (!NT_SUCCESS(Status))
    {
        /* Bail out if the read is invalid */
        EfiPrintf(L"File info check failure: %lx\r\n", Status);
        return Status;
    }
 
    /* Check if the offset we're requesting is not the current offset */
    if (FileInfo.Offset != FileOffset)
    {
        /* Set the new offset to use */
        Status = BlFileSetInformation(FileId, &FileInfo);
        if (!NT_SUCCESS(Status))
        {
            /* Can't do much if that failed */
            return Status;
        }
    }
 
    /* Do the read at the required offset now */
    Status = BlFileReadEx(FileId,
                          Buffer,
                          RequiredSize,
                          BytesReturned,
                          Flags);
    if (!NT_SUCCESS(Status))
    {
        /* The read failed -- had we modified the offset? */
        if (FileInfo.Offset != FileOffset)
        {
            /* Restore the offset back to its original value */
            FileInfo.Offset = FileOffset;
            BlFileSetInformation(FileId, &FileInfo);
        }
    }
 
    /* Return the status of the read */
    return Status;
}

Referenced by ImgpReadAtFileOffset().

◆ BlFwEnumerateDevice()

NTSTATUS BlFwEnumerateDevice ( _In_ PBL_DEVICE_DESCRIPTOR Device )

Definition at line 2375 of file firmware.c.

{
    NTSTATUS Status;
    ULONG PathProtocols, BlockProtocols;
    EFI_HANDLE* PathArray;
    EFI_HANDLE* BlockArray;
 
    /* Initialize locals */
    BlockArray = NULL;
    PathArray = NULL;
    PathProtocols = 0;
    BlockProtocols = 0;
 
    /* Enumeration only makes sense on disks or partitions */
    if ((Device->DeviceType != DiskDevice) &&
        (Device->DeviceType != LegacyPartitionDevice) &&
        (Device->DeviceType != PartitionDevice))
    {
        return STATUS_NOT_SUPPORTED;
    }
 
    /* Enumerate the list of device paths */
    Status = EfiLocateHandleBuffer(ByProtocol,
                                   &EfiDevicePathProtocol,
                                   &PathProtocols,
                                   &PathArray);
    if (NT_SUCCESS(Status))
    {
        /* Loop through each one */
        Status = STATUS_NOT_FOUND;
        while (PathProtocols)
        {
            /* Attempt to connect the driver for this device epath */
            Status = EfiConnectController(PathArray[--PathProtocols]);
            if (NT_SUCCESS(Status))
            {
                /* Now enumerate any block I/O devices the driver added */
                Status = EfiLocateHandleBuffer(ByProtocol,
                                               &EfiBlockIoProtocol,
                                               &BlockProtocols,
                                               &BlockArray);
                if (!NT_SUCCESS(Status))
                {
                    break;
                }
 
                /* Loop through each one */
                while (BlockProtocols)
                {
                    /* Check if one of the new devices is the one we want */
                    Status = BlockIoEfiCompareDevice(Device,
                                                     BlockArray[--BlockProtocols]);
                    if (NT_SUCCESS(Status))
                    {
                        /* Yep, all done */
                        goto Quickie;
                    }
                }
 
                /* Move on to the next device path */
                BlMmFreeHeap(BlockArray);
                BlockArray = NULL;
            }
        }
    }
 
Quickie:
    /* We're done -- free the array of device path protocols, if any */
    if (PathArray)
    {
        BlMmFreeHeap(PathArray);
    }
 
    /* We're done -- free the array of block I/O protocols, if any */
    if (BlockArray)
    {
        BlMmFreeHeap(BlockArray);
    }
 
    /* Return if we found the device or not */
    return Status;
}

Referenced by BmpTransferExecution().

◆ BlFwGetParameters()

NTSTATUS BlFwGetParameters ( _In_ PBL_FIRMWARE_DESCRIPTOR Parameters )

Definition at line 2359 of file firmware.c.

{
    /* Make sure we got an argument */
    if (!Parameters)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Copy the static data */
    *Parameters = *EfiFirmwareParameters;
    return STATUS_SUCCESS;
}

Referenced by ImgpInitializeBootApplicationParameters().

◆ BlFwReboot()

VOID BlFwReboot ( VOID )

Definition at line 14 of file fwutil.c.

{
#ifdef BL_KD_SUPPORTED
    /* Stop the boot debugger*/
    BlBdStop();
#endif
 
    /* Reset the machine */
    EfiResetSystem(EfiResetCold);
}

Referenced by BmMain().

◆ BlGetApplicationBaseAndSize()

NTSTATUS BlGetApplicationBaseAndSize	(	_Out_ PVOID *	ImageBase,
		_Out_ PULONG	ImageSize
	)

Definition at line 424 of file bootlib.c.

{
    /* Fail if output parameters are missing */
    if (!ImageBase || !ImageSize)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the requested data */
    *ImageBase = (PVOID)(ULONG_PTR)BlpApplicationParameters->ImageBase;
    *ImageSize = BlpApplicationParameters->ImageSize;
    return STATUS_SUCCESS;
}

Referenced by BlpResourceInitialize(), and Mmx86InitializeMemoryMap().

◆ BlGetApplicationIdentifier()

PGUID BlGetApplicationIdentifier ( VOID )

Definition at line 414 of file bootlib.c.

{
    /* Return the GUID, if one was present */
    return (BlpApplicationEntry.Flags & BL_APPLICATION_ENTRY_FLAG_NO_GUID) ?
            NULL : &BlpApplicationEntry.Guid;
}

Referenced by BlGetBootOptionBoolean(), BlGetBootOptionDevice(), BlGetBootOptionInteger(), BlGetBootOptionString(), BmMain(), and OslPrepareTarget().

◆ BlGetBootOptionBoolean()

NTSTATUS BlGetBootOptionBoolean	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type,
		_Out_ PBOOLEAN	Value
	)

Definition at line 504 of file bcdopt.c.

{
    NTSTATUS Status;
    PBL_BCD_OPTION Option;
    //PGUID AppIdentifier;
    BcdElementType ElementType;
 
    /* Make sure this is a BCD_TYPE_BOOLEAN */
    ElementType.PackedValue = Type;
    if (ElementType.Format != BCD_TYPE_BOOLEAN)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the data */
    Option = MiscGetBootOption(List, Type);
    if (Option)
    {
        *Value = *(PBOOLEAN)((ULONG_PTR)Option + Option->DataOffset);
    }
 
#ifdef _SECURE_BOOT_
    /* Filter out SecureBoot Options */
    AppIdentifier = BlGetApplicationIdentifier();
    Status = BlpBootOptionCallbackBoolean(AppIdentifier, Type, Value);
#else
    /* Option found */
    Status = Option ? STATUS_SUCCESS : STATUS_NOT_FOUND;
#endif
    return Status;
}

Referenced by BlDisplayValidOemBitmap(), BlImgQueryCodeIntegrityBootOptions(), BlMmRemoveBadMemory(), BmDisplayDumpError(), BmFatalErrorEx(), BmGetBootMenuPolicy(), BmMain(), BmpGetSelectedBootEntry(), BmpInitializeBootStatusDataLog(), BmpLaunchBootEntry(), BmpPopulateBootEntryList(), BmpTransferExecution(), BmResumeFromHibernate(), DsppGraphicsDisabledByBcd(), DsppInitialize(), and DsppReinitialize().

◆ BlGetBootOptionDevice()

NTSTATUS BlGetBootOptionDevice	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type,
		_Out_ PBL_DEVICE_DESCRIPTOR *	Value,
		_In_opt_ PBL_BCD_OPTION *	ExtraOptions
	)

Definition at line 321 of file bcdopt.c.

{
    NTSTATUS Status;
    PBL_BCD_OPTION Option, ListData, ListCopy, SecureListData;
    PBCD_DEVICE_OPTION BcdDevice;
    ULONG DeviceSize, ListOffset, ListSize;
    PBL_DEVICE_DESCRIPTOR DeviceDescriptor, SecureDescriptor;
    //PGUID AppIdentifier;
    BcdElementType ElementType;
 
    /* Make sure this is a BCD_TYPE_DEVICE */
    ElementType.PackedValue = Type;
    if (ElementType.Format != BCD_TYPE_DEVICE)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the data */
    Option = MiscGetBootOption(List, Type);
    if (!Option)
    {
        /* Set failure if no data exists */
        Status = STATUS_NOT_FOUND;
    }
    else
    {
        /* Otherwise, read the size of the BCD device encoded */
        BcdDevice = (PBCD_DEVICE_OPTION)((ULONG_PTR)Option + Option->DataOffset);
        DeviceSize = BcdDevice->DeviceDescriptor.Size;
 
        /* Allocate a buffer to copy it into */
        DeviceDescriptor = BlMmAllocateHeap(DeviceSize);
        if (!DeviceDescriptor)
        {
            return STATUS_NO_MEMORY;
        }
 
        /* Copy it into that buffer */
        RtlCopyMemory(DeviceDescriptor, &BcdDevice->DeviceDescriptor, DeviceSize);
        Status = STATUS_SUCCESS;
    }
 
    /* Check if extra options were requested */
    if (ExtraOptions)
    {
        /* See where they are */
        ListOffset = Option->ListOffset;
        if (ListOffset)
        {
            /* See how big they are */
            ListData = (PBL_BCD_OPTION)((ULONG_PTR)Option + ListOffset);
            ListSize = BlGetBootOptionListSize(ListData);
 
            /* Allocate a buffer to hold them into */
            ListCopy = BlMmAllocateHeap(ListSize);
            if (!ListCopy)
            {
                Status = STATUS_NO_MEMORY;
                goto Quickie;
            }
 
            /* Copy them in there */
            RtlCopyMemory(ListCopy, ListData, ListSize);
        }
    }
 
#ifdef _SECURE_BOOT_
    /* Filter out SecureBoot Options */
    AppIdentifier = BlGetApplicationIdentifier();
    if (BlpBootOptionCallbacks)
    {
        DeviceCallback = BlpBootOptionCallbacks->Device;
        if (DeviceCallback)
        {
            Status = DeviceCallback(BlpBootOptionCallbackCookie,
                                    Status,
                                    0,
                                    AppIdentifier,
                                    Type,
                                    &SecureDescriptor,
                                    PtrOptionData);
        }
    }
#else
    /* No secure boot, so the secure descriptors are the standard ones */
    SecureDescriptor = DeviceDescriptor;
    SecureListData = ListCopy;
#endif
 
    /* Check if the data was read correctly */
    if (NT_SUCCESS(Status))
    {
        /* Check if we had a new descriptor after filtering */
        if (SecureDescriptor != DeviceDescriptor)
        {
            /* Yep -- if we had an old one, free it */
            if (DeviceDescriptor)
            {
                BlMmFreeHeap(DeviceDescriptor);
            }
        }
 
        /* Check if we had a new list after filtering */
        if (SecureListData != ListCopy)
        {
            /* Yep -- if we had an old list, free it */
            if (ListCopy)
            {
                BlMmFreeHeap(ListCopy);
            }
        }
 
        /* Finally, check if the caller wanted extra options */
        if (ExtraOptions)
        {
            /* Yep -- so pass the caller our copy */
            *ExtraOptions = ListCopy;
            ListCopy = NULL;
        }
 
        /* Caller always wants data back, so pass them our copy */
        *Value = DeviceDescriptor;
        DeviceDescriptor = NULL;
    }
 
Quickie:
    /* On the failure path, if these buffers are active, we should free them */
    if (ListCopy)
    {
        BlMmFreeHeap(ListCopy);
    }
    if (DeviceDescriptor)
    {
        BlMmFreeHeap(DeviceDescriptor);
    }
 
    /* All done */
    return Status;
}

Referenced by BlImgLoadBootApplication(), BmOpenDataStore(), BmpInitializeBootStatusDataLog(), BmpTransferExecution(), DsppLoadFontFile(), and OslPrepareTarget().

◆ BlGetBootOptionGuid()

NTSTATUS BlGetBootOptionGuid	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type,
		_Out_ PGUID	Value
	)

Definition at line 228 of file bcdopt.c.

{
    NTSTATUS Status;
    PBL_BCD_OPTION Option;
    PGUID Guid;
    BcdElementType ElementType;
 
    /* Make sure this is a BCD_TYPE_OBJECT */
    ElementType.PackedValue = Type;
    if (ElementType.Format != BCD_TYPE_OBJECT)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the data */
    Option = MiscGetBootOption(List, Type);
    if (!Option)
    {
        /* Set failure if no data exists */
        Status = STATUS_NOT_FOUND;
    }
    else
    {
        /* Copy the GUID */
        Guid = (PGUID)((ULONG_PTR)Option + Option->DataOffset);
        RtlCopyMemory(Value, Guid, Option->DataSize);
        Status = STATUS_SUCCESS;
    }
 
    /* All good */
    return Status;
}

Referenced by BmEnumerateBootEntries(), and BmpGetDefaultBootEntry().

◆ BlGetBootOptionGuidList()

NTSTATUS BlGetBootOptionGuidList	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type,
		_Out_ PGUID *	Value,
		_In_ PULONG	Count
	)

Definition at line 266 of file bcdopt.c.

{
    NTSTATUS Status;
    PBL_BCD_OPTION Option;
    PGUID GuidCopy, Guid;
    ULONG GuidCount;
    BcdElementType ElementType;
 
    /* Make sure this is a BCD_TYPE_OBJECT_LIST */
    ElementType.PackedValue = Type;
    if (ElementType.Format != BCD_TYPE_OBJECT_LIST)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the data */
    Option = MiscGetBootOption(List, Type);
    if (!Option)
    {
        /* Set failure if no data exists */
        Status = STATUS_NOT_FOUND;
    }
    else
    {
        /* Get the GUIDs and allocate a copy for them */
        Guid = (PGUID)((ULONG_PTR)Option + Option->DataOffset);
        GuidCopy = BlMmAllocateHeap(Option->DataSize);
        if (GuidCopy)
        {
            /* Copy the GUIDs */
            RtlCopyMemory(GuidCopy, Guid, Option->DataSize);
 
            /* Return the number of GUIDs and the start of the array */
            GuidCount = Option->DataSize / sizeof(GUID);
            *Value = GuidCopy;
            *Count = GuidCount;
            Status = STATUS_SUCCESS;
        }
        else
        {
            /* No memory for the copy */
            Status = STATUS_NO_MEMORY;
        }
    }
 
    /* All good */
    return Status;
}

Referenced by BmEnumerateBootEntries(), BmLaunchRecoverySequence(), and BmMain().

◆ BlGetBootOptionInteger()

NTSTATUS BlGetBootOptionInteger	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type,
		_Out_ PULONGLONG	Value
	)

Definition at line 467 of file bcdopt.c.

{
    NTSTATUS Status;
    PBL_BCD_OPTION Option;
    //PGUID AppIdentifier;
    BcdElementType ElementType;
 
    /* Make sure this is a BCD_TYPE_INTEGER */
    ElementType.PackedValue = Type;
    if (ElementType.Format != BCD_TYPE_INTEGER)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the data */
    Option = MiscGetBootOption(List, Type);
    if (Option)
    {
        *Value = *(PULONGLONG)((ULONG_PTR)Option + Option->DataOffset);
    }
 
#ifdef _SECURE_BOOT_
    /* Filter out SecureBoot Options */
    AppIdentifier = BlGetApplicationIdentifier();
    Status = BlpBootOptionCallbackULongLong(AppIdentifier, Type, Value);
#else
    /* Option found */
    Status = Option ? STATUS_SUCCESS : STATUS_NOT_FOUND;
#endif
    return Status;
}

Referenced by BlpMmInitializeConstraints(), BmGetBootMenuPolicy(), BmpGetSelectedBootEntry(), DsppInitialize(), DsppReinitialize(), InitializeLibrary(), MmArchInitialize(), OslGetBootStatusData(), and OslpCheckForcedFailure().

◆ BlGetBootOptionListSize()

ULONG BlGetBootOptionListSize ( _In_ PBL_BCD_OPTION BcdOption )

Definition at line 79 of file bcdopt.c.

{
    ULONG Size = 0, NextOffset = 0;
    PBL_BCD_OPTION NextOption;
 
    /* Loop all the options*/
    do
    {
        /* Move to the next one */
        NextOption = (PBL_BCD_OPTION)((ULONG_PTR)BcdOption + NextOffset);
 
        /* Compute the size of the next one */
        Size += BlGetBootOptionSize(NextOption);
 
        /* Update the offset */
        NextOffset = NextOption->NextEntryOffset;
    } while (NextOffset);
 
    /* Return final computed size */
    return Size;
}

Referenced by BlAppendBootOptions(), BlCopyBootOptions(), BlGetBootOptionDevice(), BlGetBootOptionSize(), BlImgLoadBootApplication(), BlReplaceBootOptions(), BmGetOptionList(), BmpPopulateBootEntryList(), and ImgpInitializeBootApplicationParameters().

◆ BlGetBootOptionSize()

ULONG BlGetBootOptionSize ( _In_ PBL_BCD_OPTION BcdOption )

Definition at line 115 of file bcdopt.c.

{
    ULONG Size, Offset;
 
    /* Check if there's any data */
    if (BcdOption->DataOffset)
    {
        /* Add the size of the data */
        Size = BcdOption->DataOffset + BcdOption->DataSize;
    }
    else
    {
        /* No data, just the structure itself */
        Size = sizeof(*BcdOption);
    }
 
    /* Any associated options? */
    Offset = BcdOption->ListOffset;
    if (Offset)
    {
        /* Go get those too */
        Size += BlGetBootOptionListSize((PVOID)((ULONG_PTR)BcdOption + Offset));
    }
 
    /* Return the final size */
    return Size;
}

Referenced by BlGetBootOptionListSize(), BmGetOptionList(), and EfiInitpCreateApplicationEntry().

◆ BlGetBootOptionString()

NTSTATUS BlGetBootOptionString	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type,
		_Out_ PWCHAR *	Value
	)

Definition at line 146 of file bcdopt.c.

{
    NTSTATUS Status;
    PBL_BCD_OPTION Option;
    PWCHAR String, StringCopy;
    ULONG StringLength;
    BcdElementType ElementType;
    //PGUID AppIdentifier;
 
    /* Make sure this is a BCD_STRING */
    ElementType.PackedValue = Type;
    if (ElementType.Format != BCD_TYPE_STRING)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the data */
    Option = MiscGetBootOption(List, Type);
    if (Option)
    {
        /* Extract the string */
        String = (PWCHAR)((ULONG_PTR)Option + Option->DataOffset);
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* No string is present */
        String = NULL;
        Status = STATUS_NOT_FOUND;
    }
 
    /* Compute the data size */
    StringLength = Option->DataSize / sizeof(WCHAR);
 
#ifdef _SECURE_BOOT_
    /* Filter out SecureBoot Options */
    AppIdentifier = BlGetApplicationIdentifier();
    Status = BlpBootOptionCallbackString(AppIdentifier, Type, String, StringLength, &String, &StringLength);
#else
#endif
 
    /* Make sure we have a valid, non-filtered string */
    if (NT_SUCCESS(Status))
    {
        /* Check if we have space for one more character */
        Status = RtlULongAdd(StringLength, 1, &StringLength);
        if (NT_SUCCESS(Status))
        {
            /* Check if it's safe to multiply by two */
            Status = RtlULongMult(StringLength, sizeof(WCHAR), &StringLength);
            if (NT_SUCCESS(Status))
            {
                /* Allocate a copy for the string */
                StringCopy = BlMmAllocateHeap(StringLength);
                if (StringCopy)
                {
                    /* NULL-terminate it */
                    RtlCopyMemory(StringCopy,
                                  String,
                                  StringLength - sizeof(UNICODE_NULL));
                    StringCopy[StringLength] = UNICODE_NULL;
                    *Value = StringCopy;
                    Status = STATUS_SUCCESS;
                }
                else
                {
                    /* No memory, fail */
                    Status = STATUS_NO_MEMORY;
                }
            }
        }
    }
 
    /* All done */
    return Status;
}

Referenced by BlImgLoadBootApplication(), BmOpenDataStore(), BmpFwGetApplicationDirectoryPath(), BmpInitializeBootStatusDataLog(), BmpTransferExecution(), DsppLoadFontFile(), OslpRemoveInternalApplicationOptions(), and OslPrepareTarget().

◆ BlHtCreate()

NTSTATUS BlHtCreate	(	_In_ ULONG	Size,
		_In_ PBL_HASH_TABLE_HASH_FUNCTION	HashFunction,
		_In_ PBL_HASH_TABLE_COMPARE_FUNCTION	CompareFunction,
		_Out_ PULONG	Id
	)

Definition at line 504 of file util.c.

{
    NTSTATUS Status;
    PBL_HASH_TABLE HashTable;
    ULONG i;
 
    /* Assume failure */
    HashTable = NULL;
 
    /* Can't create a table with no ID */
    if (!Id)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check if we don't already have a hash table table */
    if (!HtTableSize)
    {
        /* Allocate it and zero it out */
        HtTableSize = 4;
        HtTableArray = BlMmAllocateHeap(HtTableSize * sizeof(PVOID));
        if (!HtTableArray)
        {
            Status = STATUS_NO_MEMORY;
            goto Quickie;
        }
        RtlZeroMemory(HtTableArray, HtTableSize * sizeof(PVOID));
        HtTableEntries = 0;
    }
 
    /* Allocate the hash table */
    HashTable = BlMmAllocateHeap(sizeof(*HashTable));
    if (!HashTable)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Fill it out */
    HashTable->HashFunction = HashFunction ? HashFunction : DefaultHashFunction;
    HashTable->CompareFunction = CompareFunction ? CompareFunction : HtpCompareKeys;
    HashTable->Size = Size ? Size : 13;
 
    /* Allocate the hash links, one for each bucket */
    HashTable->HashLinks = BlMmAllocateHeap(sizeof(LIST_ENTRY) * HashTable->Size);
    if (!HashTable->HashLinks)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Initialize the hash links */
    for (i = 0; i < HashTable->Size; i++)
    {
        InitializeListHead(&HashTable->HashLinks[i]);
    }
 
    /* Save us in the table of hash tables */
    Status = BlTblSetEntry((PVOID**)&HtTableArray,
                           &Size,
                           HashTable,
                           Id,
                           TblDoNotPurgeEntry);
    if (NT_SUCCESS(Status))
    {
        /* One more -- we're done */
        ++HtTableEntries;
        return Status;
    }
 
Quickie:
    /* Check if we just allocated the table array now */
    if (!(HtTableEntries) && (HtTableArray))
    {
        /* Free it */
        BlMmFreeHeap(HtTableArray);
        HtTableArray = NULL;
        HtTableSize = 0;
    }
 
    /* Check if we allocated a hash table*/
    if (HashTable)
    {
        /* With links? */
        if (HashTable->HashLinks)
        {
            /* Free them */
            BlMmFreeHeap(HashTable->HashLinks);
        }
 
        /* Free the table*/
        BlMmFreeHeap(HashTable);
    }
 
    /* We're done */
    return Status;
}

Referenced by BcInitialize(), BlockIopInitialize(), and EfiVmOpenProtocol().

◆ BlHtDelete()

NTSTATUS BlHtDelete	(	_In_ ULONG	TableId,
		_In_ PBL_HASH_ENTRY	Entry
	)

Definition at line 722 of file util.c.

{
    PBL_HASH_TABLE HashTable;
    ULONG HashValue;
    NTSTATUS Status;
    PLIST_ENTRY HashLinkHead, HashLink;
    PBL_HASH_NODE HashNode;
 
    /* Check if the table ID is invalid, or we have no entry, or it's malformed */
    if ((HtTableSize <= TableId) ||
        !(Entry) ||
        !(Entry->Size) ||
        !(Entry->Value) ||
        ((Entry->Flags & BL_HT_VALUE_IS_INLINE) && (Entry->Size != sizeof(ULONG))))
    {
        /* Fail */
        Status = STATUS_INVALID_PARAMETER;
    }
    else
    {
        /* Otherwise, get the hash table for this index */
        HashTable = HtTableArray[TableId];
 
        /* Get the hash bucket */
        HashValue = HashTable->HashFunction(Entry, HashTable->Size);
 
        /* Start iterating each entry in the bucket, assuming failure */
        Status = STATUS_NOT_FOUND;
        HashLinkHead = &HashTable->HashLinks[HashValue];
        HashLink = HashLinkHead->Flink;
        while (HashLink != HashLinkHead)
        {
            /* Get a node in this bucket, and compare the value */
            HashNode = CONTAINING_RECORD(HashLink, BL_HASH_NODE, ListEntry);
            if (HashTable->CompareFunction(&HashNode->Entry, Entry))
            {
                /* Remove it from the list and free it */
                RemoveEntryList(&HashNode->ListEntry);
                BlMmFreeHeap(HashNode);
                return STATUS_SUCCESS;
            }
 
            /* Try the next node */
            HashLink = HashLink->Flink;
        }
    }
 
    /* Return back to the caller */
    return Status;
}

Referenced by BlockIoFirmwareOpen(), and EfiVmpFreeInterfaceEntry().

◆ BlHtLookup()

NTSTATUS BlHtLookup	(	_In_ ULONG	TableId,
		_In_ PBL_HASH_ENTRY	Entry,
		_Out_ PBL_HASH_VALUE *	Value
	)

Referenced by BlockIoFirmwareOpen(), EfiVmCloseProtocol(), and EfiVmOpenProtocol().

◆ BlHtStore()

NTSTATUS BlHtStore	(	_In_ ULONG	TableId,
		_In_ PBL_HASH_ENTRY	Entry,
		_In_ PVOID	Data,
		_In_ ULONG	DataSize
	)

Definition at line 668 of file util.c.

{
    PBL_HASH_NODE HashNode;
    NTSTATUS Status;
    PLIST_ENTRY HashLinkHead;
    PBL_HASH_TABLE HashTable;
 
    /* Check for invalid table ID, missing arguments, or malformed entry */
    if ((HtTableSize <= TableId) ||
        !(Entry) ||
        !(Data) ||
        !(Entry->Size) ||
        !(Entry->Value) ||
        !(DataSize) ||
        ((Entry->Flags & BL_HT_VALUE_IS_INLINE) && (Entry->Size != sizeof(ULONG))))
    {
        /* Fail the call */
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Get the hash table for this ID */
    HashTable = HtTableArray[TableId];
 
    /* Allocate a hash node */
    HashNode = BlMmAllocateHeap(sizeof(*HashNode));
    if (!HashNode)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Capture all the data*/
    HashNode->Entry.Size = Entry->Size;
    HashNode->Entry.Flags = Entry->Flags;
    HashNode->Entry.Value = Entry->Value;
    HashNode->Value.DataSize = DataSize;
    HashNode->Value.Data = Data;
 
    /* Insert it into the bucket list and return success */
    HashLinkHead = &HashTable->HashLinks[HashTable->HashFunction(Entry, HashTable->Size)];
    InsertTailList(HashLinkHead, &HashNode->ListEntry);
    Status = STATUS_SUCCESS;
 
Quickie:
    return Status;
}

Referenced by BlockIoFirmwareOpen(), and EfiVmOpenProtocol().

◆ BlImgFindSection()

PIMAGE_SECTION_HEADER BlImgFindSection	(	_In_ PVOID	ImageBase,
		_In_ ULONG	ImageSize
	)

Definition at line 611 of file image.c.

{
    PIMAGE_SECTION_HEADER FoundSection;
    ULONG i;
    PIMAGE_SECTION_HEADER SectionHeader;
    PIMAGE_NT_HEADERS NtHeader;
    NTSTATUS Status;
 
    /* Assume failure */
    FoundSection = NULL;
 
    /* Make sure the image is valid */
    Status = RtlImageNtHeaderEx(0, ImageBase, ImageSize, &NtHeader);
    if (NT_SUCCESS(Status))
    {
        /* Get the first section and loop through them all */
        SectionHeader = IMAGE_FIRST_SECTION(NtHeader);
        for (i = 0; i < NtHeader->FileHeader.NumberOfSections; i++)
        {
            /* Check if this is the resource section */
            if (!_stricmp((PCCH)SectionHeader->Name, ".rsrc"))
            {
                /* Yep, we're done */
                FoundSection = SectionHeader;
                break;
            }
 
            /* Nope, keep going */
            SectionHeader++;
        }
    }
 
    /* Return the matching section */
    return FoundSection;
}

Referenced by BlpResourceInitialize(), and ResFindDataEntryFromImage().

◆ BlImgLoadBootApplication()

NTSTATUS BlImgLoadBootApplication	(	_In_ PBL_LOADED_APPLICATION_ENTRY	BootEntry,
		_Out_ PULONG	AppHandle
	)

Definition at line 1324 of file image.c.

{
    NTSTATUS Status;
    PULONGLONG AllowedList;
    ULONGLONG AllowedCount;
    ULONG i, DeviceId, ImageSize, Flags, ListSize;
    LARGE_INTEGER Frequency;
    PVOID UnlockCode, ImageBase;
    PBL_DEVICE_DESCRIPTOR Device, BitLockerDevice;
    PWCHAR Path;
    PBL_APPLICATION_ENTRY AppEntry;
    PBL_IMG_FILE ImageFile;
    BOOLEAN DisableIntegrity, TestSigning;
    UCHAR Hash[64];
    PBL_IMAGE_APPLICATION_ENTRY ImageAppEntry;
 
    /* Initialize all locals */
    BitLockerDevice = NULL;
    UnlockCode = NULL;
    ImageFile = NULL;
    DeviceId = -1;
    Device = NULL;
    ImageAppEntry = NULL;
    AppEntry = NULL;
    Path = NULL;
    ImageSize = 0;
    ImageBase = NULL;
 
    /* Check for "allowed in-memory settings" */
    Status = BlpGetBootOptionIntegerList(BootEntry->BcdData,
                                         BcdLibraryIntegerList_AllowedInMemorySettings,
                                         &AllowedList,
                                         &AllowedCount,
                                         TRUE);
    if (Status == STATUS_SUCCESS)
    {
        /* Loop through the list of allowed setting */
        for (i = 0; i < AllowedCount; i++)
        {
            /* Find the super undocumented one */
            if (AllowedList[i] == BcdLibraryInteger_UndocumentedMagic)
            {
                /* If it's present, append the current perf frequence to it */
                BlTimeQueryPerformanceCounter(&Frequency);
                BlAppendBootOptionInteger(BootEntry,
                                          BcdLibraryInteger_UndocumentedMagic,
                                          Frequency.QuadPart);
            }
        }
    }
 
#if BL_BITLOCKER_SUPPORT
    /* Do bitlocker stuff */
    Status = BlFveSecureBootUnlockBootDevice(BootEntry, &BitLockerDevice, &UnlockCode);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
#endif
 
    /* Get the device on which this application is on*/
    Status = BlGetBootOptionDevice(BootEntry->BcdData,
                                   BcdLibraryDevice_ApplicationDevice,
                                   &Device,
                                   NULL);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Get the path of the application */
    Status = BlGetBootOptionString(BootEntry->BcdData,
                                   BcdLibraryString_ApplicationPath,
                                   &Path);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Open the device */
    Status = BlpDeviceOpen(Device,
                           BL_DEVICE_READ_ACCESS,
                           0,
                           &DeviceId);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Check for integrity BCD options */
    BlImgQueryCodeIntegrityBootOptions(BootEntry,
                                       &DisableIntegrity,
                                       &TestSigning);
 
#if BL_TPM_SUPPORT
    RtlZeroMemory(&Context, sizeof(Context);
    Context.BootEntry = BootEntry;
    BlEnNotifyEvent(0x10000003, &Context);
#endif
 
    /* Enable signing and hashing checks if integrity is enabled */
    Flags = 0;
    if (!DisableIntegrity)
    {
        Flags = 0x8070;
    }
 
    /* Now call the PE loader to load the image */
    Status = BlImgLoadPEImageEx(DeviceId,
                                BlLoaderMemory,
                                Path,
                                &ImageBase,
                                &ImageSize,
                                Hash,
                                Flags);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
#if BL_KD_SUPPORT
    /* Check if we should notify the debugger of load */
    if (BdDebugTransitions)
    {
        /* Initialize it */
        BdForceDebug = 1;
        Status = BlBdInitialize();
        if (NT_SUCCESS(Status))
        {
            /* Check if it's enabled */
            if (BlBdDebuggerEnabled())
            {
                /* Send it an image load notification */
                BdDebuggerNotPresent = FALSE;
                RtlInitUnicodeString(&PathString, Path);
                BlBdLoadImageSymbols(&PathString, ImageBase);
            }
        }
    }
#endif
 
#if BL_BITLOCKER_SUPPORT
    /* Do bitlocker stuff */
    Status = BlSecureBootCheckPolicyOnFveDevice(BitLockerDevice);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
#endif
 
#if BL_BITLOCKER_SUPPORT
    /* Do bitlocker stuff */
    Status = BlFveSecureBootCheckpointBootApp(BootEntry, BitLockerDevice, Hash, UnlockCode);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
#endif
 
    /* Get the BCD option size */
    ListSize = BlGetBootOptionListSize(BootEntry->BcdData);
 
    /* Allocate an entry with all the BCD options */
    AppEntry = BlMmAllocateHeap(ListSize + sizeof(*AppEntry));
    if (!AppEntry)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Zero it out */
    RtlZeroMemory(AppEntry, sizeof(*AppEntry));
 
    /* Initialize it */
    strcpy(AppEntry->Signature, "BTAPENT");
    AppEntry->Guid = BootEntry->Guid;
    AppEntry->Flags = BootEntry->Flags;
 
    /* Copy the BCD options */
    RtlCopyMemory(&AppEntry->BcdData, BootEntry->BcdData, ListSize);
 
    /* Allocate the image entry */
    ImageAppEntry = BlMmAllocateHeap(sizeof(*ImageAppEntry));
    if (!ImageAppEntry)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Initialize it */
    ImageAppEntry->ImageBase = ImageBase;
    ImageAppEntry->ImageSize = ImageSize;
    ImageAppEntry->AppEntry = AppEntry;
 
    /* Check if this is the first entry */
    if (!IapTableEntries)
    {
        /* Allocate two entries */
        IapAllocatedTableEntries = 0;
        IapTableEntries = 2;
        IapImageTable = BlMmAllocateHeap(IapTableEntries * sizeof(PVOID));
        if (!IapImageTable)
        {
            Status = STATUS_NO_MEMORY;
            goto Quickie;
        }
 
        /* Zero out the entries for now */
        RtlZeroMemory(IapImageTable, IapTableEntries * sizeof(PVOID));
    }
 
    /* Set this entry into the table */
    Status = BlTblSetEntry(&IapImageTable,
                           &IapTableEntries,
                           ImageAppEntry,
                           AppHandle,
                           TblDoNotPurgeEntry);
 
Quickie:
    /* Is the device open? Close it if so */
    if (DeviceId != 1)
    {
        BlDeviceClose(DeviceId);
    }
 
    /* Is there an allocated device? Free it */
    if (Device)
    {
        BlMmFreeHeap(Device);
    }
 
    /* Is there an allocated path? Free it */
    if (Path)
    {
        BlMmFreeHeap(Path);
    }
 
    /* Is there a bitlocker device? Free it */
    if (BitLockerDevice)
    {
        BlMmFreeHeap(BitLockerDevice);
    }
 
    /* Is there a bitlocker unlock code? Free it */
    if (UnlockCode)
    {
        BlMmFreeHeap(UnlockCode);
    }
 
    /* Did we succeed in creating an entry? */
    if (NT_SUCCESS(Status))
    {
        /* Remember there's one more in the table */
        IapAllocatedTableEntries++;
 
        /* Return success */
        return Status;
    }
 
    /* Did we load an image after all? */
    if (ImageBase)
    {
        /* Unload it */
        BlImgUnLoadImage(ImageBase, ImageSize, 0);
    }
 
    /* Did we allocate an app entry? Free it */
    if (AppEntry)
    {
        BlMmFreeHeap(AppEntry);
    }
 
    /* Do we have an image file entry?  Free it */
    if (ImageFile)
    {
        BlMmFreeHeap(ImageFile);
    }
 
    /* Do we no longer have a single entry in the table? */
    if (!(IapAllocatedTableEntries) && (IapImageTable))
    {
        /* Free and destroy the table */
        BlMmFreeHeap(IapImageTable);
        IapTableEntries = 0;
        IapImageTable = NULL;
    }
 
    /* Return the failure code */
    return Status;
}

Referenced by BmpTransferExecution().

◆ BlImgLoadImageWithProgress2()

NTSTATUS BlImgLoadImageWithProgress2	(	_In_ ULONG	DeviceId,
		_In_ BL_MEMORY_TYPE	MemoryType,
		_In_ PWCHAR	FileName,
		_Inout_ PVOID *	MappedBase,
		_Inout_ PULONG	MappedSize,
		_In_ ULONG	ImageFlags,
		_In_ BOOLEAN	ShowProgress,
		_Out_opt_ PUCHAR *	HashBuffer,
		_Out_opt_ PULONG	HashSize
	)

Definition at line 358 of file image.c.

{
    NTSTATUS Status;
    PVOID BaseAddress, Buffer;
    ULONG RemainingLength, CurrentSize, ImageSize, ReadSize;
    BOOLEAN ComputeSignature, ComputeHash, Completed;
    BL_IMG_FILE FileHandle;
    ULONGLONG ByteOffset;
    PHYSICAL_ADDRESS PhysicalAddress;
 
    /* Initialize variables */
    BaseAddress = 0;
    ImageSize = 0;
    Completed = FALSE;
    RtlZeroMemory(&FileHandle, sizeof(FileHandle));
 
    /* Check for missing parameters */
    if (!MappedBase)
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
    if (!FileName)
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
    if (!MappedSize)
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Check if the image buffer is being provided */
    if (ImageFlags & BL_LOAD_IMG_EXISTING_BUFFER)
    {
        /* An existing base must already exist */
        if (!(*MappedBase))
        {
            Status = STATUS_INVALID_PARAMETER;
            goto Quickie;
        }
    }
 
    /* Check of a hash is being requested */
    if (ImageFlags & BL_LOAD_IMG_COMPUTE_HASH)
    {
        /* Make sure we can return the hash */
        if (!HashBuffer)
        {
            Status = STATUS_INVALID_PARAMETER;
            goto Quickie;
        }
        if (!HashSize)
        {
            Status = STATUS_INVALID_PARAMETER;
            goto Quickie;
        }
    }
 
    /* Check for invalid combination of parameters */
    if ((ImageFlags & BL_LOAD_IMG_COMPUTE_HASH) && (ImageFlags & 0x270))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Initialize hash if requested by caller */
    if (HashBuffer)
    {
        *HashBuffer = 0;
    }
 
    /* Do the same for the hash size */
    if (HashSize)
    {
        *HashSize = 0;
    }
 
    /* Open the image file */
    Status = ImgpOpenFile(DeviceId, FileName, DeviceId, &FileHandle);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Error opening file: %lx\r\n", Status);
        goto Quickie;
    }
 
    /* Get the size of the image */
    Status = ImgpGetFileSize(&FileHandle, &ImageSize);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Error getting file size: %lx\r\n", Status);
        goto Quickie;
    }
 
    /* Read the current base address */
    BaseAddress = *MappedBase;
    if (ImageFlags & BL_LOAD_IMG_EXISTING_BUFFER)
    {
        /* Check if the current buffer is too small */
        if (*MappedSize < ImageSize)
        {
            /* Return the required size of the buffer */
            *MappedSize = ImageSize;
            Status = STATUS_BUFFER_TOO_SMALL;
        }
    }
    else
    {
        /* A buffer was not provided, allocate one ourselves */
        Status = BlImgAllocateImageBuffer(&BaseAddress,
                                          MemoryType,
                                          ImageSize,
                                          ImageFlags);
    }
 
    /* Bail out if allocation failed */
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Set the initial byte offset and length to read */
    RemainingLength = ImageSize;
    ByteOffset = 0;
    Buffer = BaseAddress;
 
    /* Update the initial progress */
    Completed = FALSE;
    if (ShowProgress)
    {
        BlUtlUpdateProgress(0, &Completed);
        ShowProgress &= (Completed != 0) - 1;
    }
 
    /* Set the chunk size for each read */
    ReadSize = 0x100000;
    if (ReadSize > ImageSize)
    {
        ReadSize = ImageSize;
    }
 
    /* Check if we should compute hash and/or signatures */
    ComputeSignature = ImageFlags & BL_LOAD_IMG_COMPUTE_SIGNATURE;
    ComputeHash = FALSE;
    if ((ComputeSignature) || (ImageFlags & BL_LOAD_IMG_COMPUTE_HASH))
    {
        ComputeHash = TRUE;
        // todo: crypto is hard
    }
 
    /* Begin the read loop */
    while (RemainingLength)
    {
        /* Check if we've got more than a chunk left to read */
        if (RemainingLength > ReadSize)
        {
            /* Read a chunk*/
            CurrentSize = ReadSize;
        }
        else
        {
            /* Read only what's left */
            CurrentSize = RemainingLength;
        }
 
        /* Read the chunk */
        Status = ImgpReadAtFileOffset(&FileHandle,
                                      CurrentSize,
                                      ByteOffset,
                                      Buffer,
                                      0);
        if (!NT_SUCCESS(Status))
        {
            goto Quickie;
        }
 
        /* Check if we need to compute the hash of this chunk */
        if (ComputeHash)
        {
            // todo: crypto is hard
        }
 
        /* Update our position and read information */
        Buffer = (PVOID)((ULONG_PTR)Buffer + CurrentSize);
        RemainingLength -= CurrentSize;
        ByteOffset += CurrentSize;
 
        /* Check if we should update the progress bar */
        if (ShowProgress)
        {
            /* Compute new percentage completed, check if we're done */
            BlUtlUpdateProgress(100 - 100 * RemainingLength / ImageSize,
                                &Completed);
            ShowProgress &= (Completed != 0) - 1;
        }
    }
 
    /* Is the read fully complete? We need to finalize the hash if requested */
    if (ComputeHash)
    {
        // todo: CRYPTO IS HARD
    }
 
    /* Success path, return back the buffer and the size of the image */
    *MappedBase = BaseAddress;
    *MappedSize = ImageSize;
 
Quickie:
    /* Close the file handle */
    ImgpCloseFile(&FileHandle);
 
    /* Check if we failed and had allocated a buffer */
    if (!(NT_SUCCESS(Status)) &&
        (BaseAddress) &&
        !(ImageFlags & BL_LOAD_IMG_EXISTING_BUFFER))
    {
        /* Check what kind of buffer we had allocated */
        if (ImageFlags & BL_LOAD_IMG_VIRTUAL_BUFFER)
        {
            /* Unmap and free the virtual buffer */
            PhysicalAddress.QuadPart = (ULONG_PTR)BaseAddress;
            BlMmUnmapVirtualAddressEx(BaseAddress, ImageSize);
            BlMmFreePhysicalPages(PhysicalAddress);
        }
        else
        {
            /* Free the physical buffer */
            MmPapFreePages(BaseAddress, BL_MM_INCLUDE_MAPPED_ALLOCATED);
        }
    }
 
    /* If we hadn't gotten to 100% yet, do it now */
    if (ShowProgress)
    {
        BlUtlUpdateProgress(100, &Completed);
    }
 
    /* Return the final status */
    return Status;
}

Referenced by BiLoadHive().

◆ BlImgQueryCodeIntegrityBootOptions()

VOID BlImgQueryCodeIntegrityBootOptions	(	_In_ PBL_LOADED_APPLICATION_ENTRY	ApplicationEntry,
		_Out_ PBOOLEAN	IntegrityChecksDisabled,
		_Out_ PBOOLEAN	TestSigning
	)

Definition at line 651 of file image.c.

{
 
    NTSTATUS Status;
    BOOLEAN Value;
 
    /* Check if /DISABLEINTEGRITYCHECKS is on */
    Status = BlGetBootOptionBoolean(ApplicationEntry->BcdData,
                                    BcdLibraryBoolean_DisableIntegrityChecks,
                                    &Value);
    *IntegrityChecksDisabled = NT_SUCCESS(Status) && (Value);
 
    /* Check if /TESTSIGNING is on */
    Status = BlGetBootOptionBoolean(ApplicationEntry->BcdData,
                                    BcdLibraryBoolean_AllowPrereleaseSignatures,
                                    &Value);
    *TestSigning = NT_SUCCESS(Status) && (Value);
}

Referenced by BlImgLoadBootApplication(), and BmMain().

◆ BlImgStartBootApplication()

NTSTATUS BlImgStartBootApplication	(	_In_ ULONG	AppHandle,
		_Inout_ PBL_RETURN_ARGUMENTS	ReturnArguments
	)

Referenced by BmpTransferExecution().

◆ BlImgUnloadBootApplication()

NTSTATUS BlImgUnloadBootApplication ( _In_ ULONG AppHandle )

Definition at line 2021 of file image.c.

{
    PBL_IMAGE_APPLICATION_ENTRY ImageAppEntry;
    NTSTATUS Status;
 
    /* Make sure the handle index is valid */
    if (IapTableEntries <= AppHandle)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get the entry for this handle, making sure it exists */
    ImageAppEntry = IapImageTable[AppHandle];
    if (!ImageAppEntry)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Unload the image */
    Status = BlImgUnLoadImage(ImageAppEntry->ImageBase,
                              ImageAppEntry->ImageSize,
                              0);
    if (NT_SUCCESS(Status))
    {
        /* Normalize the success code */
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* Normalize the failure code */
        Status = STATUS_MEMORY_NOT_ALLOCATED;
    }
 
    /* Free the entry and the image entry as well */
    BlMmFreeHeap(ImageAppEntry->AppEntry);
    BlMmFreeHeap(ImageAppEntry);
 
    /* Clear the handle */
    IapImageTable[AppHandle] = NULL;
 
    /* Free one entry */
    if (!(--IapAllocatedTableEntries))
    {
        /* There are no more, so get rid of the table itself */
        BlMmFreeHeap(IapImageTable);
        IapImageTable = NULL;
        IapTableEntries = 0;
    }
 
    /* All good */
    return Status;
}

Referenced by BmpTransferExecution().

◆ BlInitializeLibrary()

NTSTATUS BlInitializeLibrary	(	_In_ PBOOT_APPLICATION_PARAMETER_BLOCK	BootAppParameters,
		_In_ PBL_LIBRARY_PARAMETERS	LibraryParameters
	)

Definition at line 355 of file bootlib.c.

{
    NTSTATUS Status;
 
    /* Are we re-initializing the library? */
    if (LibraryParameters->LibraryFlags & BL_LIBRARY_FLAG_REINITIALIZE)
    {
        /* From scratch? */
        BlpLibraryParameters = *LibraryParameters;
        if (LibraryParameters->LibraryFlags & BL_LIBRARY_FLAG_REINITIALIZE_ALL)
        {
#ifdef BL_TPM_SUPPORT
            /* Reinitialize the TPM security enclave as BCD hash changed */
            BlpSiInitialize(1);
#endif
#ifdef BL_KD_SUPPORT
            /* Reinitialize the boot debugger as BCD debug options changed */
            BlBdInitialize();
#endif
 
            /* Reparse the bad page list now that the BCD has been reloaded */
            BlMmRemoveBadMemory();
 
            /* Reparse the low/high physical address limits as well */
            BlpMmInitializeConstraints();
 
            /* Redraw the graphics console as needed */
            BlpDisplayInitialize(LibraryParameters->LibraryFlags);
 
            /* Reinitialize resources (language may have changed) */
            BlpResourceInitialize();
        }
 
        /* Nothing to do, we're done */
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* Nope, this is first time initialization */
        Status = InitializeLibrary(BootAppParameters, LibraryParameters);
    }
 
    /* Return initialization status */
    return Status;
}

Referenced by BmMain(), and OslMain().

◆ BlMmAllocateHeap()

PVOID BlMmAllocateHeap ( _In_ SIZE_T Size )

Definition at line 569 of file heapalloc.c.

{
    ULONG BufferSize;
    PBL_HEAP_BOUNDARIES Heap;
    PBL_BUSY_HEAP_ENTRY BusyEntry, FreeEntry, NextEntry;
 
    /* Ignore heap allocation if the heap allocator isn't ready yet */
    if (HapInitializationStatus != 1)
    {
        return NULL;
    }
 
    /* Align the buffer size to the minimum size required */
    BufferSize = ALIGN_UP_BY(Size + FIELD_OFFSET(BL_BUSY_HEAP_ENTRY, Buffer),
                             FIELD_OFFSET(BL_BUSY_HEAP_ENTRY, Buffer));
 
    /* Watch out for overflow */
    if (BufferSize <= Size)
    {
        return NULL;
    }
 
    /* Make sure it's at least big enough to hold a free entry later on */
    if (BufferSize < sizeof(BL_FREE_HEAP_ENTRY))
    {
        BufferSize = sizeof(BL_FREE_HEAP_ENTRY);
    }
 
    /* Loop while we try to allocate memory */
    while (1)
    {
        /* Find a free buffer for this allocation */
        BusyEntry = MmHapFindBufferInFreeList(BufferSize);
        if (BusyEntry)
        {
            break;
        }
 
        /* We couldn't find a free buffer. Do we have any heaps? */
        if (!IsListEmpty(&MmHeapBoundaries))
        {
            /* Get the current heap */
            Heap = CONTAINING_RECORD(MmHeapBoundaries.Flink,
                                     BL_HEAP_BOUNDARIES,
                                     ListEntry);
 
            /* Check if we have space in the heap page for this allocation? */
            FreeEntry = Heap->HeapStart;
            NextEntry = (PBL_BUSY_HEAP_ENTRY)((ULONG_PTR)FreeEntry + BufferSize);
 
            if ((NextEntry >= FreeEntry) &&
                ((ULONG_PTR)NextEntry <=
                 Heap->HeapLimit - FIELD_OFFSET(BL_BUSY_HEAP_ENTRY, Buffer)))
            {
                /* Update the heap top pointer past this allocation */
                Heap->HeapStart = NextEntry;
 
                /* Make this allocation point to the slot */
                FreeEntry->BufferNext.P = Heap->HeapStart;
 
                /* And make the free heap entry point back to us */
                Heap->HeapStart->BufferPrevious.P = FreeEntry;
 
                /* Mark the heap entry as being free and on the heap */
                Heap->HeapStart->BufferNext.BufferFree = 1;
                Heap->HeapStart->BufferNext.BufferOnHeap = 1;
 
                /* The previously freed entry on the heap page is now ours */
                BusyEntry = FreeEntry;
                break;
            }
        }
 
        /* We have no heaps or space on any heap -- extend the heap and retry */
        if (!NT_SUCCESS(MmHapHeapAllocatorExtend(BufferSize)))
        {
            EfiPrintf(L"Heap extension failed!\r\n");
            return NULL;
        }
 
        EfiPrintf(L"Heap extended -- trying again\r\n");
    }
 
    /* Clear all the bits, marking this entry as allocated */
    BusyEntry->BufferNext.P = MmHapDecodeLink(BusyEntry->BufferNext);
 
    /* Return the entry's data buffer */
    //EfiPrintf(L"Returning buffer at 0x%p\r\n", &BusyEntry->Buffer);
    return &BusyEntry->Buffer;
}

Referenced by BcdEnumerateAndUnpackElements(), BcdOpenStoreFromFile(), BfLoadFontFile(), BiEnumerateElements(), BiEnumerateSubKeys(), BiGetRegistryValue(), BiLoadHive(), BiOpenKey(), BlAppendBootOptionBoolean(), BlAppendBootOptionInteger(), BlAppendBootOptions(), BlAppendBootOptionString(), BlCopyBootOptions(), BlGetBootOptionDevice(), BlGetBootOptionGuidList(), BlGetBootOptionString(), BlHtCreate(), BlHtStore(), BlImgLoadBootApplication(), BlMmGetMemoryMap(), BlockIoEfiCreateDeviceEntry(), BlockIoOpen(), BlockIopInitialize(), BlpDeviceInitialize(), BlpDeviceOpen(), BlpFileInitialize(), BlpFileRegisterFileSystem(), BlpGetBootOptionIntegerList(), BlpIoInitialize(), BlpMmCreateBlockAllocator(), BlReplaceBootOptions(), BlTblSetEntry(), BmEnumerateBootEntries(), BmFwInitializeBootDirectoryPath(), BmGetBootSequence(), BmGetOptionList(), BmOpenDataStore(), BmpFwGetApplicationDirectoryPath(), BmpFwGetFullPath(), BmpGetSelectedBootEntry(), BmpPopulateBootEntryList(), CmpAllocate(), ConsoleCreateLocalInputConsole(), ConsoleCreateRemoteConsole(), ConsoleEfiTextFindModeFromAllowed(), ConsoleInputBaseConstruct(), ConsolepClearBuffer(), ConvertBmpToGopBlt(), DsppInitialize(), DsppLoadFontFile(), EfiLocateHandleBuffer(), EfiVmOpenProtocol(), EtfsInitialize(), EtfsMount(), EtfsOpen(), EtfspCreateContext(), FatInitialize(), FileIoCopyFileName(), FileIoCopyParentDirectoryPath(), ImgpInitializeBootApplicationParameters(), MmBaInitialize(), MmMdFreeGlobalDescriptors(), OslPrepareTarget(), and RtlpAllocateMemory().

◆ BlMmAllocatePhysicalPages()

NTSTATUS BlMmAllocatePhysicalPages	(	_Inout_ PPHYSICAL_ADDRESS	Address,
		_In_ BL_MEMORY_TYPE	MemoryType,
		_In_ ULONGLONG	PageCount,
		_In_ ULONG	Attributes,
		_In_ ULONG	Alignment
	)

Referenced by BlImgAllocateImageBuffer(), and BmMain().

◆ BlMmFreeHeap()

NTSTATUS BlMmFreeHeap ( _In_ PVOID Buffer )

Definition at line 663 of file heapalloc.c.

{
    PBL_BUSY_HEAP_ENTRY BusyEntry;
    PBL_HEAP_BOUNDARIES Heap;
    PLIST_ENTRY NextEntry;
 
    /* If the heap is not initialized, fail */
    if (HapInitializationStatus != 1)
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Get the heap header */
    //EfiPrintf(L"Freeing entry at: %p\r\n", Buffer);
    if (Buffer)
    {
        /* Don't free heap until we discover the corruption */
        return STATUS_SUCCESS;
    }
 
    BusyEntry = CONTAINING_RECORD(Buffer, BL_BUSY_HEAP_ENTRY, Buffer);
 
    /* Loop all the heaps */
    NextEntry = MmHeapBoundaries.Flink;
    while (NextEntry != &MmHeapBoundaries)
    {
        /* Get the current heap in the list */
        Heap = CONTAINING_RECORD(NextEntry, BL_HEAP_BOUNDARIES, ListEntry);
 
        /* Is this entry part of this heap? */
        if (((ULONG_PTR)Heap->HeapBase <= (ULONG_PTR)BusyEntry) &&
            ((ULONG_PTR)BusyEntry < (ULONG_PTR)Heap->HeapStart))
        {
            /* Ignore double-free */
            if (BusyEntry->BufferNext.BufferFree)
            {
                return STATUS_INVALID_PARAMETER;
            }
 
            /* It is -- add it to the free list */
            MmHapAddToFreeList(BusyEntry, 0);
            return STATUS_SUCCESS;
        }
 
        /* It isn't, move to the next heap */
        NextEntry = NextEntry->Flink;
    }
 
    /* The entry is not on any valid heap */
    return STATUS_INVALID_PARAMETER;
}

Referenced by BcdEnumerateAndUnpackElements(), BcdOpenStoreFromFile(), BfiFreeDeferredFontFile(), BiCloseKey(), BiDeleteKey(), BiEnumerateElements(), BiEnumerateSubKeys(), BiGetObjectDescription(), BiLoadHive(), BiOpenKey(), BlAppendBootOptionBoolean(), BlAppendBootOptionInteger(), BlAppendBootOptions(), BlAppendBootOptionString(), BlDestroyBootEntry(), BlFwEnumerateDevice(), BlGetBootOptionDevice(), BlHtCreate(), BlHtDelete(), BlImgLoadBootApplication(), BlImgUnloadBootApplication(), BlMmGetMemoryMap(), BlockIoDeviceTableDestroy(), BlockIoDeviceTableDestroyEntry(), BlockIoEfiCompareDevice(), BlockIoEfiCreateDeviceEntry(), BlockIoEfiGetChildHandle(), BlockIoFirmwareOpen(), BlockIopDestroy(), BlockIopFreeAllocations(), BlpDeviceOpen(), BlpFileRegisterFileSystem(), BlpMmCreateBlockAllocator(), BlpResourceInitialize(), BlReplaceBootOptions(), BlTblSetEntry(), BmEnumerateBootEntries(), BmErrorPurge(), BmFwInitializeBootDirectoryPath(), BmGetBootSequence(), BmGetOptionList(), BmLaunchRecoverySequence(), BmMain(), BmOpenDataStore(), BmpFwGetApplicationDirectoryPath(), BmpGetSelectedBootEntry(), BmpInitializeBootStatusDataLog(), BmpPopulateBootEntryList(), BmpTransferExecution(), BmpUpdateApplicationOptions(), CmpFree(), ConsoleCreateLocalInputConsole(), ConsoleCreateRemoteConsole(), ConsoleEfiTextFindModeFromAllowed(), ConsoleInputLocalDestruct(), DeviceTableDestroyEntry(), DsppInitialize(), DsppLoadFontFile(), EfiLocateHandleBuffer(), EfiVmOpenProtocol(), EfiVmpFreeInterfaceEntry(), EtfsMount(), EtfsOpen(), EtfspDeviceContextDestroy(), FileIoCopyParentDirectoryPath(), FileIoOpen(), FileTableDestroyEntry(), ImgpInitializeBootApplicationParameters(), MmBapFreeBlockAllocatorTableEntry(), MmMdFreeDescriptor(), OslpRemoveInternalApplicationOptions(), OslPrepareTarget(), and RtlpFreeMemory().

◆ BlMmFreePhysicalPages()

NTSTATUS BlMmFreePhysicalPages ( _In_ PHYSICAL_ADDRESS Address )

Definition at line 1187 of file pagealloc.c.

{
    /* Call the physical allocator */
    return MmPapFreePhysicalPages(BL_MM_INCLUDE_UNMAPPED_ALLOCATED, 0, Address);
}

Referenced by BlImgAllocateImageBuffer(), BlImgLoadImageWithProgress2(), BlImgUnallocateImageBuffer(), BmMain(), ImgpLoadPEImage(), and MmDefInitializeTranslation().

◆ BlMmGetMemoryMap()

NTSTATUS BlMmGetMemoryMap	(	_In_ PLIST_ENTRY	MemoryMap,
		_In_ PBL_BUFFER_DESCRIPTOR	MemoryParameters,
		_In_ ULONG	WhichTypes,
		_In_ ULONG	Flags
	)

Definition at line 1222 of file pagealloc.c.

{
    BL_MEMORY_DESCRIPTOR_LIST FirmwareMdList, FullMdList;
    BOOLEAN DoFirmware, DoPersistent, DoTruncated, DoBad;
    BOOLEAN DoReserved, DoUnmapUnalloc, DoUnmapAlloc;
    BOOLEAN DoMapAlloc, DoMapUnalloc, DoFirmware2;
    ULONG LoopCount, MdListCount, MdListSize, Used;
    NTSTATUS Status;
 
    /* Initialize the firmware list if we use it */
    MmMdInitializeListHead(&FirmwareMdList);
 
    /* Make sure we got our input parameters */
    if (!(MemoryMap) || !(MemoryParameters))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Either ask for firmware memory, or don't. Not neither */
    if ((WhichTypes & ~BL_MM_INCLUDE_NO_FIRMWARE_MEMORY) &&
        (WhichTypes & ~BL_MM_INCLUDE_ONLY_FIRMWARE_MEMORY))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Either ask for firmware memory, or don't. Not both */
    if ((WhichTypes & BL_MM_INCLUDE_NO_FIRMWARE_MEMORY) &&
        (WhichTypes & BL_MM_INCLUDE_ONLY_FIRMWARE_MEMORY))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Initialize the memory map list */
    InitializeListHead(MemoryMap);
 
    /* Check which types of memory to dump */
    DoFirmware = WhichTypes & BL_MM_INCLUDE_FIRMWARE_MEMORY;
    DoPersistent = WhichTypes & BL_MM_INCLUDE_PERSISTENT_MEMORY;
    DoTruncated = WhichTypes & BL_MM_INCLUDE_TRUNCATED_MEMORY;
    DoBad = WhichTypes & BL_MM_INCLUDE_BAD_MEMORY;
    DoReserved = WhichTypes & BL_MM_INCLUDE_RESERVED_ALLOCATED;
    DoUnmapUnalloc = WhichTypes & BL_MM_INCLUDE_UNMAPPED_UNALLOCATED;
    DoUnmapAlloc = WhichTypes & BL_MM_INCLUDE_UNMAPPED_ALLOCATED;
    DoMapAlloc = WhichTypes & BL_MM_INCLUDE_MAPPED_ALLOCATED;
    DoMapUnalloc = WhichTypes & BL_MM_INCLUDE_MAPPED_UNALLOCATED;
    DoFirmware2 = WhichTypes & BL_MM_INCLUDE_FIRMWARE_MEMORY_2;
 
    /* Begin the attempt loop */
    LoopCount = 0;
    while (TRUE)
    {
        /* Count how many entries we will need */
        MdListCount = 0;
        if (DoMapAlloc) MdListCount = MmMdCountList(&MmMdlMappedAllocated);
        if (DoMapUnalloc) MdListCount += MmMdCountList(&MmMdlMappedUnallocated);
        if (DoUnmapAlloc) MdListCount += MmMdCountList(&MmMdlUnmappedAllocated);
        if (DoUnmapUnalloc) MdListCount += MmMdCountList(&MmMdlUnmappedUnallocated);
        if (DoReserved) MdListCount += MmMdCountList(&MmMdlReservedAllocated);
        if (DoBad) MdListCount += MmMdCountList(&MmMdlBadMemory);
        if (DoTruncated) MdListCount += MmMdCountList(&MmMdlTruncatedMemory);
        if (DoPersistent) MdListCount += MmMdCountList(&MmMdlPersistentMemory);
 
        /* Plus firmware entries */
        if (DoFirmware)
        {
            /* Free the previous entries, if any */
            MmMdFreeList(&FirmwareMdList);
 
            /* Get the firmware map, coalesced */
            Status = MmFwGetMemoryMap(&FirmwareMdList,
                                      BL_MM_FLAG_REQUEST_COALESCING);
            if (!NT_SUCCESS(Status))
            {
                goto Quickie;
            }
 
            /* We overwrite, since this type is exclusive */
            MdListCount = MmMdCountList(&FirmwareMdList);
        }
 
        /* Plus firmware entries-2 */
        if (DoFirmware2)
        {
            /* Free the previous entries, if any */
            MmMdFreeList(&FirmwareMdList);
 
            /* Get the firmware map, uncoalesced */
            Status = MmFwGetMemoryMap(&FirmwareMdList, 0);
            if (!NT_SUCCESS(Status))
            {
                goto Quickie;
            }
 
            /* We overwrite, since this type is exclusive */
            MdListCount = MmMdCountList(&FirmwareMdList);
        }
 
        /* If there's no descriptors, we're done */
        if (!MdListCount)
        {
            Status = STATUS_SUCCESS;
            goto Quickie;
        }
 
        /* Check if the buffer we have is big enough */
        if (MemoryParameters->BufferSize >=
            (sizeof(BL_MEMORY_DESCRIPTOR) * MdListCount))
        {
            break;
        }
 
        /* It's not, allocate it, with a slack of 4 extra descriptors */
        MdListSize = sizeof(BL_MEMORY_DESCRIPTOR) * (MdListCount + 4);
 
        /* Except if we weren't asked to */
        if (!(Flags & BL_MM_ADD_DESCRIPTOR_ALLOCATE_FLAG))
        {
            MemoryParameters->BufferSize = MdListSize;
            Status = STATUS_BUFFER_TOO_SMALL;
            goto Quickie;
        }
 
        /* Has it been less than 4 times we've tried this? */
        if (++LoopCount <= 4)
        {
            /* Free the previous attempt, if any */
            if (MemoryParameters->BufferSize)
            {
                BlMmFreeHeap(MemoryParameters->Buffer);
            }
 
            /* Allocate a new buffer */
            MemoryParameters->BufferSize = MdListSize;
            MemoryParameters->Buffer = BlMmAllocateHeap(MdListSize);
            if (MemoryParameters->Buffer)
            {
                /* Try again */
                continue;
            }
        }
 
        /* If we got here, we're out of memory after 4 attempts */
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* We should have a buffer by now... */
    if (MemoryParameters->Buffer)
    {
        /* Zero it out */
        RtlZeroMemory(MemoryParameters->Buffer,
                      MdListCount * sizeof(BL_MEMORY_DESCRIPTOR));
    }
 
    /* Initialize our list of descriptors */
    MmMdInitializeList(&FullMdList, 0, MemoryMap);
    Used = 0;
 
    /* Handle mapped, allocated */
    if (DoMapAlloc)
    {
        Status = MmMdCopyList(&FullMdList,
                              &MmMdlMappedAllocated,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle mapped, unallocated */
    if (DoMapUnalloc)
    {
        Status = MmMdCopyList(&FullMdList,
                              &MmMdlMappedUnallocated,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle unmapped, allocated */
    if (DoUnmapAlloc)
    {
        Status = MmMdCopyList(&FullMdList,
                              &MmMdlUnmappedAllocated,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle unmapped, unallocated */
    if (DoUnmapUnalloc)
    {
        Status = MmMdCopyList(&FullMdList,
                              &MmMdlUnmappedUnallocated,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle reserved, allocated */
    if (DoReserved)
    {
        Status = MmMdCopyList(&FullMdList,
                              &MmMdlReservedAllocated,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle bad */
    if (DoBad)
    {
        Status = MmMdCopyList(&FullMdList,
                              &MmMdlBadMemory,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle truncated */
    if (DoTruncated)
    {
        Status = MmMdCopyList(&FullMdList,
                              &MmMdlTruncatedMemory,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle persistent */
    if (DoPersistent)
    {
        Status = MmMdCopyList(&FullMdList,
                              &MmMdlPersistentMemory,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle firmware */
    if (DoFirmware)
    {
        Status = MmMdCopyList(&FullMdList,
                              &FirmwareMdList,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Handle firmware2 */
    if (DoFirmware2)
    {
        Status = MmMdCopyList(&FullMdList,
                              &FirmwareMdList,
                              MemoryParameters->Buffer,
                              &Used,
                              MdListCount,
                              Flags);
    }
 
    /* Add up the final size */
    Status = RtlULongLongToULong(Used * sizeof(BL_MEMORY_DESCRIPTOR),
                                 &MemoryParameters->ActualSize);
 
Quickie:
    MmMdFreeList(&FirmwareMdList);
    return Status;
}

Referenced by ImgpInitializeBootApplicationParameters().

◆ BlMmMapPhysicalAddressEx()

NTSTATUS BlMmMapPhysicalAddressEx	(	_In_ PVOID *	VirtualAddress,
		_In_ ULONG	Attributes,
		_In_ ULONGLONG	Size,
		_In_ PHYSICAL_ADDRESS	PhysicalAddress
	)

Definition at line 192 of file mm.c.

{
    NTSTATUS Status;
    PVOID MappingAddress;
    PHYSICAL_ADDRESS MappedAddress;
    PVOID MappedBase;
    ULONGLONG MapSize;
    UCHAR CacheAttributes;
    ULONGLONG BasePage, EndPage, MappedPage, FoundBasePage;
    ULONGLONG PageOffset, FoundPageCount;
    PBL_MEMORY_DESCRIPTOR Descriptor, NewDescriptor;
    PBL_MEMORY_DESCRIPTOR_LIST List;
    ULONG AddPages;
 
    /* Increase call depth */
    ++MmDescriptorCallTreeCount;
 
    /* Check if any parameters are missing */
    if (!(VirtualAddress) || !(Size))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Check for fixed allocation without an actual address */
    if ((Flags & BlMemoryFixed) &&
        (PhysicalAddress.QuadPart == -1) &&
        !(*VirtualAddress))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Check for invalid requirement flag, if one is present */
    if (((Flags & BlMemoryValidAllocationAttributes) != BlMemoryFixed) &&
        ((Flags & BlMemoryValidAllocationAttributes) != BlMemoryKernelRange) &&
        (Flags & BlMemoryValidAllocationAttributes))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Check for invalid cache attribute flags */
    if (((Flags & BlMemoryValidCacheAttributeMask) - 1) &
         (Flags & BlMemoryValidCacheAttributeMask))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Select an address to map this at */
    Status = MmSelectMappingAddress(&MappingAddress,
                                    *VirtualAddress,
                                    Size,
                                    Flags & BlMemoryValidAllocationAttributes,
                                    Flags,
                                    PhysicalAddress);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Map the selected address, using the appropriate caching attributes */
    MappedAddress = PhysicalAddress;
    MapSize = Size;
    CacheAttributes = ((Flags & BlMemoryValidCacheAttributeMask) != 0x20) ?
                      (Flags & BlMemoryValidCacheAttributeMask) : 0;
    Status = MmMapPhysicalAddress(&MappedAddress,
                                  &MappingAddress,
                                  &MapSize,
                                  CacheAttributes);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Compute the final address where the mapping was made */
    MappedBase = (PVOID)(ULONG_PTR)((ULONG_PTR)MappingAddress +
                                    PhysicalAddress.QuadPart -
                                    MappedAddress.QuadPart);
    MappedAddress.QuadPart = (ULONG_PTR)MappedBase;
 
    /* Check if we're in physical or virtual mode */
    if (MmTranslationType == BlNone)
    {
        /* We are in physical mode -- just return this address directly */
        Status = STATUS_SUCCESS;
        *VirtualAddress = MappedBase;
        goto Quickie;
    }
 
    /* Remove the mapping address from the list of free virtual memory */
    Status = MmMdRemoveRegionFromMdlEx(&MmMdlFreeVirtual,
                                       BL_MM_REMOVE_VIRTUAL_REGION_FLAG,
                                       (ULONG_PTR)MappingAddress >> PAGE_SHIFT,
                                       MapSize >> PAGE_SHIFT,
                                       NULL);
    if (NT_SUCCESS(Status))
    {
        /* And then add an entry for the fact we mapped it */
        Status = TrpGenerateMappingTracker(MappedBase,
                                           CacheAttributes,
                                           PhysicalAddress,
                                           MapSize);
    }
 
    /* Abandon if we didn't update the memory map successfully */
    if (!NT_SUCCESS(Status))
    {
        /* Unmap the virtual address so it can be used later */
        MmUnmapVirtualAddress(MappingAddress, &MapSize);
        goto Quickie;
    }
 
    /* Check if no real mapping into RAM was made */
    if (PhysicalAddress.QuadPart == -1)
    {
        /* Then we're done here */
        Status = STATUS_SUCCESS;
        *VirtualAddress = MappedBase;
        goto Quickie;
    }
 
 
    /* Loop over the entire allocation */
    BasePage = MappedAddress.QuadPart >> PAGE_SHIFT;
    EndPage = (MappedAddress.QuadPart + MapSize) >> PAGE_SHIFT;
    MappedPage = (ULONG_PTR)MappingAddress >> PAGE_SHIFT;
    do
    {
        /* Start with the unmapped allocated list */
        List = &MmMdlUnmappedAllocated;
        Descriptor = MmMdFindDescriptor(BL_MM_INCLUDE_UNMAPPED_ALLOCATED,
                                        BL_MM_REMOVE_PHYSICAL_REGION_FLAG,
                                        BasePage);
        if (!Descriptor)
        {
            /* Try persistent next */
            List = &MmMdlPersistentMemory;
            Descriptor = MmMdFindDescriptor(BL_MM_INCLUDE_PERSISTENT_MEMORY,
                                            BL_MM_REMOVE_PHYSICAL_REGION_FLAG,
                                            BasePage);
        }
        if (!Descriptor)
        {
            /* Try unmapped, unallocated, next */
            List = &MmMdlUnmappedUnallocated;
            Descriptor = MmMdFindDescriptor(BL_MM_INCLUDE_UNMAPPED_UNALLOCATED,
                                            BL_MM_REMOVE_PHYSICAL_REGION_FLAG,
                                            BasePage);
        }
        if (!Descriptor)
        {
            /* Try reserved next */
            List = &MmMdlReservedAllocated;
            Descriptor = MmMdFindDescriptor(BL_MM_INCLUDE_RESERVED_ALLOCATED,
                                            BL_MM_REMOVE_PHYSICAL_REGION_FLAG,
                                            BasePage);
        }
 
        /* Check if we have a descriptor */
        if (Descriptor)
        {
            /* Remove it from its list */
            MmMdRemoveDescriptorFromList(List, Descriptor);
 
            /* Check if it starts before our allocation */
            FoundBasePage = Descriptor->BasePage;
            if (FoundBasePage < BasePage)
            {
                /* Create a new descriptor to cover the gap before our allocation */
                PageOffset = BasePage - FoundBasePage;
                NewDescriptor = MmMdInitByteGranularDescriptor(Descriptor->Flags,
                                                               Descriptor->Type,
                                                               FoundBasePage,
                                                               0,
                                                               PageOffset);
 
                /* Insert it */
                MmMdAddDescriptorToList(List, NewDescriptor, 0);
 
                /* Adjust ours to ignore that piece */
                Descriptor->PageCount -= PageOffset;
                Descriptor->BasePage = BasePage;
            }
 
            /* Check if it goes beyond our allocation */
            FoundPageCount = Descriptor->PageCount;
            if (EndPage < (FoundPageCount + Descriptor->BasePage))
            {
                /* Create a new descriptor to cover the range after our allocation */
                PageOffset = EndPage - BasePage;
                NewDescriptor = MmMdInitByteGranularDescriptor(Descriptor->Flags,
                                                               Descriptor->Type,
                                                               EndPage,
                                                               0,
                                                               FoundPageCount -
                                                               PageOffset);
 
                /* Insert it */
                MmMdAddDescriptorToList(List, NewDescriptor, 0);
 
                /* Adjust ours to ignore that piece */
                Descriptor->PageCount = PageOffset;
            }
 
            /* Update the descriptor to be mapepd at this virtual page */
            Descriptor->VirtualPage = MappedPage;
 
            /* Check if this was one of the regular lists */
            if ((List != &MmMdlReservedAllocated) &&
                (List != &MmMdlPersistentMemory))
            {
                /* Was it allocated, or unallocated? */
                if (List != &MmMdlUnmappedAllocated)
                {
                    /* In which case use the unallocated mapped list */
                    List = &MmMdlMappedUnallocated;
                }
                else
                {
                    /* Insert it into the mapped list */
                    List = &MmMdlMappedAllocated;
                }
            }
 
            /* Add the descriptor that was removed, into the right list */
            MmMdAddDescriptorToList(List, Descriptor, 0);
 
            /* Add the pages this descriptor had */
            AddPages = Descriptor->PageCount;
        }
        else
        {
            /* Nope, so just add one page */
            AddPages = 1;
        }
 
        /* Increment the number of pages the descriptor had */
        MappedPage += AddPages;
        BasePage += AddPages;
    }
    while (BasePage < EndPage);
 
    /* We're done -- returned the address */
    Status = STATUS_SUCCESS;
    *VirtualAddress = MappedBase;
 
Quickie:
    /* Cleanup descriptors and reduce depth */
    MmMdFreeGlobalDescriptors();
    --MmDescriptorCallTreeCount;
    return Status;
}

Referenced by BlDisplayGetOemBitmap(), BlImgAllocateImageBuffer(), BlUtlGetAcpiTable(), ConsoleEfiGopEnable(), EfipGetRsdt(), EfiVmOpenProtocol(), and MmPapPageAllocatorExtend().

◆ BlMmRemoveBadMemory()

NTSTATUS BlMmRemoveBadMemory ( VOID )

Definition at line 155 of file mm.c.

{
    BOOLEAN AllowBad;
    NTSTATUS Status;
    PULONGLONG BadPages;
    ULONGLONG BadPageCount;
 
    /* First check if bad memory access is allowed */
    AllowBad = FALSE;
    Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
                                    BcdLibraryBoolean_AllowBadMemoryAccess,
                                    &AllowBad);
    if ((NT_SUCCESS(Status)) && (AllowBad))
    {
        /* No point checking the list if it is */
        return STATUS_SUCCESS;
    }
 
    /* Otherwise, check if there's a persisted bad page list */
    Status = BlpGetBootOptionIntegerList(BlpApplicationEntry.BcdData,
                                         BcdLibraryIntegerList_BadMemoryList,
                                         &BadPages,
                                         &BadPageCount,
                                         TRUE);
    if (NT_SUCCESS(Status))
    {
        EfiPrintf(L"Persistent bad page list not supported\r\n");
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* All done here */
    return STATUS_SUCCESS;
}

Referenced by BlInitializeLibrary(), and BlpMmInitialize().

◆ BlMmTranslateVirtualAddress()

BOOLEAN BlMmTranslateVirtualAddress	(	_In_ PVOID	VirtualAddress,
		_Out_ PPHYSICAL_ADDRESS	PhysicalAddress
	)

Definition at line 525 of file mm.c.

{
    /* Make sure arguments are present */
    if (!(VirtualAddress) || !(PhysicalAddress))
    {
        return FALSE;
    }
 
    /* Do the architecture-specific translation */
    return MmArchTranslateVirtualAddress(VirtualAddress, PhysicalAddress, NULL);
}

Referenced by BlImgUnallocateImageBuffer(), EfiAllocatePages(), EfiConInExSetState(), EfiGetMemoryMap(), EfiGopGetCurrentMode(), EfiGopGetFrameBuffer(), EfiLocateHandleBuffer(), EfiVmOpenProtocol(), ImgpLoadPEImage(), and OslDrawLogo().

◆ BlMmUnmapVirtualAddressEx()

NTSTATUS BlMmUnmapVirtualAddressEx	(	_In_ PVOID	VirtualAddress,
		_In_ ULONGLONG	Size
	)

Definition at line 487 of file mm.c.

{
    NTSTATUS Status;
 
    /* Increment call depth */
    ++MmDescriptorCallTreeCount;
 
    /* Make sure all parameters are there */
    if ((VirtualAddress) && (Size))
    {
        /* Unmap the virtual address */
        Status = MmUnmapVirtualAddress(&VirtualAddress, &Size);
 
        /* Check if we actually had a virtual mapping active */
        if ((NT_SUCCESS(Status)) && (MmTranslationType != BlNone))
        {
            /* We don't support virtual memory yet @TODO */
            EfiPrintf(L"not yet implemented in %S\r\n", __FUNCTION__);
            EfiStall(1000000);
            Status = STATUS_NOT_IMPLEMENTED;
        }
    }
    else
    {
        /* Fail */
        Status = STATUS_INVALID_PARAMETER;
    }
 
    /* Cleanup descriptors and reduce depth */
    MmMdFreeGlobalDescriptors();
    --MmDescriptorCallTreeCount;
    return Status;
}

Referenced by BlDisplayGetOemBitmap(), BlDisplayInvalidateOemBitmap(), BlDisplayValidOemBitmap(), BlImgLoadImageWithProgress2(), BlImgUnallocateImageBuffer(), BlUtlGetAcpiTable(), ConsoleFirmwareGraphicalDisable(), EfipGetRsdt(), EfiVmOpenProtocol(), EfiVmpFreeInterfaceEntry(), and ImgpLoadPEImage().

◆ BlockIoEfiCompareDevice()

NTSTATUS BlockIoEfiCompareDevice	(	_In_ PBL_DEVICE_DESCRIPTOR	Device,
		_In_ EFI_HANDLE	Handle
	)

Definition at line 1268 of file device.c.

{
    PBL_LOCAL_DEVICE LocalDeviceInfo, EfiLocalDeviceInfo;
    PBL_DEVICE_ENTRY DeviceEntry;
    PBL_DEVICE_DESCRIPTOR EfiDevice;
    NTSTATUS Status;
 
    DeviceEntry = NULL;
 
    /* Check if no device was given */
    if (!Device)
    {
        /* Fail the comparison */
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Check if this is a local disk device */
    if (Device->DeviceType != DiskDevice)
    {
        /* Nope -- is it a partition device? */
        if ((Device->DeviceType != LegacyPartitionDevice) &&
            (Device->DeviceType != PartitionDevice))
        {
            /* Nope, so we can't compare */
            Status = STATUS_INVALID_PARAMETER;
            goto Quickie;
        }
 
        /* If so, return the device information for the parent disk */
        LocalDeviceInfo = &Device->Partition.Disk;
    }
    else
    {
        /* Just return the disk information itself */
        LocalDeviceInfo = &Device->Local;
    }
 
    /* Create an EFI device entry for the EFI device handle */
    Status = BlockIoEfiCreateDeviceEntry(&DeviceEntry, Handle);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Read the descriptor and assume failure for now */
    EfiDevice = DeviceEntry->DeviceDescriptor;
    Status = STATUS_UNSUCCESSFUL;
 
    /* Check if the EFI device is a disk */
    if (EfiDevice->DeviceType != DiskDevice)
    {
        /* Nope, is it a partition? */
        if ((EfiDevice->DeviceType != LegacyPartitionDevice) &&
            (EfiDevice->DeviceType != PartitionDevice))
        {
            /* Neither, invalid handle so bail out */
            Status = STATUS_INVALID_PARAMETER;
            goto Quickie;
        }
 
        /* Yes, so get the information of the parent disk */
        EfiLocalDeviceInfo = &EfiDevice->Partition.Disk;
    }
    else
    {
        /* It's a disk, so get the disk information itself */
        EfiLocalDeviceInfo = &EfiDevice->Local;
    }
 
    /* Are the two devices the same type? */
    if (EfiLocalDeviceInfo->Type != LocalDeviceInfo->Type)
    {
        /* Nope, that was easy */
        goto Quickie;
    }
 
    /* Yes, what kind of device is the EFI side? */
    switch (EfiLocalDeviceInfo->Type)
    {
        case LocalDevice:
 
            /* Local hard drive, compare the signature */
            if (RtlCompareMemory(&EfiLocalDeviceInfo->HardDisk,
                                 &LocalDeviceInfo->HardDisk,
                                 sizeof(LocalDeviceInfo->HardDisk)) ==
                sizeof(LocalDeviceInfo->HardDisk))
            {
                Status = STATUS_SUCCESS;
            }
            break;
 
        case FloppyDevice:
        case CdRomDevice:
 
            /* Removable floppy or CD, compare the disk number */
            if (RtlCompareMemory(&EfiLocalDeviceInfo->FloppyDisk,
                                 &LocalDeviceInfo->FloppyDisk,
                                 sizeof(LocalDeviceInfo->FloppyDisk)) ==
                sizeof(LocalDeviceInfo->FloppyDisk))
            {
                Status = STATUS_SUCCESS;
            }
            break;
 
        case RamDiskDevice:
 
            /* RAM disk, compare the size and base information */
            if (RtlCompareMemory(&EfiLocalDeviceInfo->RamDisk,
                                 &LocalDeviceInfo->RamDisk,
                                 sizeof(LocalDeviceInfo->RamDisk)) ==
                sizeof(LocalDeviceInfo->RamDisk))
            {
                Status = STATUS_SUCCESS;
            }
            break;
 
        case FileDevice:
 
            /* File, compare the file identifier */
            if (RtlCompareMemory(&EfiLocalDeviceInfo->File,
                                 &LocalDeviceInfo->File,
                                 sizeof(LocalDeviceInfo->File)) ==
                sizeof(LocalDeviceInfo->File))
            {
                Status = STATUS_SUCCESS;
            }
            break;
 
        /* Something else we don't support */
        default:
            break;
    }
 
Quickie:
    /* All done, did we have an EFI device entry? */
    if (DeviceEntry)
    {
        /* Free it, since we only needed it locally for comparison */
        BlMmFreeHeap(DeviceEntry->DeviceDescriptor);
        BlockIopFreeAllocations(DeviceEntry->DeviceSpecificData);
        BlMmFreeHeap(DeviceEntry);
    }
 
    /* Return back to the caller */
    return Status;
}

Referenced by BlFwEnumerateDevice().

◆ BlpArchEnableTranslation()

VOID BlpArchEnableTranslation ( VOID )

Definition at line 189 of file arch.c.

{
    PBL_ARCH_CONTEXT Context;
 
    /* Does the current execution context already have paging enabled? */
    Context = CurrentExecutionContext;
    if (!(Context->ContextFlags & BL_CONTEXT_PAGING_ON))
    {
        /* No -- does it have interrupts enabled? */
        if (Context->ContextFlags & BL_CONTEXT_INTERRUPTS_ON)
        {
            /* Disable them */
            _disable();
            Context->ContextFlags &= ~BL_CONTEXT_INTERRUPTS_ON;
        }
 
        /* Are we enabling PAE? */
        if (Context->TranslationType == BlPae)
        {
            /* Make sure CR4 reflects this */
            __writecr4(__readcr4() | CR4_PAE);
        }
 
        /* Enable paging in the CPU */
        __writecr0(__readcr0() | CR0_PG);
 
        /* Reflect that paging is enabled */
        Context->ContextFlags |= BL_CONTEXT_PAGING_ON;
    }
}

Referenced by MmDefInitializeTranslation().

◆ BlpArchInitialize()

NTSTATUS BlpArchInitialize ( _In_ ULONG Phase )

Definition at line 235 of file arch.c.

{
    KDESCRIPTOR Idtr;
    USHORT CodeSegment;
    NTSTATUS Status;
    PKIDTENTRY IdtBase;
 
    /* Assume success */
    Status = STATUS_SUCCESS;
 
    /* Is this phase 1? */
    if (Phase != 0)
    {
        /* Get the IDT */
        __sidt(&Idtr);
        IdtBase = (PKIDTENTRY)Idtr.Base;
 
        /* Get the Code Segment */
#if defined(__GNUC__)
        __asm__ __volatile__ ("mov %%cs,%0\n\t" :"=r" (CodeSegment));
#elif defined (_MSC_VER)
        _asm { mov CodeSegment, cs };
#else
#error wtf are you using
#endif
 
        /* Set up INT 3, ASSERT, and SECURITY_ASSERT to be no-op (for Rtl) */
        IdtBase[3].Offset = (USHORT)(ULONG_PTR)ArchTrapNoProcess;
        IdtBase[3].Selector = CodeSegment;
        IdtBase[3].Access = 0x8E00u;
        IdtBase[3].ExtendedOffset = (ULONG_PTR)ArchTrapNoProcess >> 16;
        IdtBase[0x2C].Offset = (USHORT)(ULONG_PTR)ArchTrapNoProcess;
        IdtBase[0x2C].Selector = CodeSegment;
        IdtBase[0x2C].Access = 0x8E00u;
        IdtBase[0x2C].ExtendedOffset = (ULONG_PTR)ArchTrapNoProcess >> 16;
        IdtBase[0x2D].Offset = (USHORT)(ULONG_PTR)ArchTrapNoProcess;
        IdtBase[0x2D].Selector = CodeSegment;
        IdtBase[0x2D].Access = 0x8E00u;
        IdtBase[0x2D].ExtendedOffset = (ULONG_PTR)ArchTrapNoProcess >> 16;
 
        /* Write the IDT back */
        Idtr.Base = (ULONG)IdtBase;
        __lidt(&Idtr);
 
        /* Reset FPU state */
#if defined(__GNUC__)
        __asm__ __volatile__ ("fninit");
#elif defined (_MSC_VER)
        _asm { fninit };
#else
#error wtf are you using
#endif
    }
    else
    {
        /* Reset TSC if needed */
        if ((__readmsr(0x10) >> 32) & 0xFFC00000)
        {
            __writemsr(0x10, 0);
        }
 
        /* Initialize all the contexts */
        Status = ArchInitializeContexts();
    }
 
    /* Return initialization state */
    return Status;
}

Referenced by InitializeLibrary().

◆ BlpArchSwitchContext()

VOID BlpArchSwitchContext ( _In_ BL_ARCH_MODE NewMode )

Definition at line 166 of file arch.c.

{
    PBL_ARCH_CONTEXT Context;
 
    /* In real mode, use EFI, otherwise, use the application mode */
    Context = &FirmwareExecutionContext;
    if (NewMode != BlRealMode)
    {
        Context = &ApplicationExecutionContext;
    }
 
    /* Are we in a different mode? */
    if (CurrentExecutionContext->Mode != NewMode)
    {
        /* Switch to the new one */
        ArchSwitchContext(Context, CurrentExecutionContext);
        CurrentExecutionContext = Context;
    }
}

Referenced by BlockIoFirmwareRead(), ConsoleFirmwareTextClear(), EfiAllocatePages(), EfiCloseProtocol(), EfiConInExReset(), EfiConInExSetState(), EfiConInReset(), EfiConnectController(), EfiConOutEnableCursor(), EfiConOutOutputString(), EfiConOutQueryMode(), EfiConOutReadCurrentMode(), EfiConOutSetAttribute(), EfiConOutSetCursorPosition(), EfiConOutSetMode(), EfiFreePages(), EfiGetMemoryMap(), EfiGetVariable(), EfiGopGetCurrentMode(), EfiGopGetFrameBuffer(), EfiGopSetMode(), EfiLocateHandleBuffer(), EfiOpenProtocol(), EfiPrintf(), EfiSetWatchdogTimer(), EfiStall(), EfiVmOpenProtocol(), EfiVmpCloseProtocol(), MmFwGetMemoryMap(), and OslDrawLogo().

◆ BlpDeviceInitialize()

NTSTATUS BlpDeviceInitialize ( VOID )

Definition at line 2309 of file device.c.

{
    NTSTATUS Status;
 
    /* Initialize the table count and list of devices */
    DmTableEntries = 8;
    InitializeListHead(&DmRegisteredDevices);
 
    /* Initialize device information */
    DmDeviceIoInformation.ReadCount = 0;
    DmDeviceIoInformation.WriteCount = 0;
 
    /* Allocate the device table */
    DmDeviceTable = BlMmAllocateHeap(DmTableEntries * sizeof(PVOID));
    if (DmDeviceTable)
    {
        /* Clear it */
        RtlZeroMemory(DmDeviceTable, DmTableEntries * sizeof(PVOID));
#if BL_BITLOCKER_SUPPORT
        /* Initialize BitLocker support */
        Status = FvebInitialize();
#else
        Status = STATUS_SUCCESS;
#endif
    }
    else
    {
        /* No memory, we'll fail */
        Status = STATUS_NO_MEMORY;
    }
 
    /* Return initialization state */
    return Status;
}

Referenced by BlpIoInitialize().

◆ BlpDeviceOpen()

NTSTATUS BlpDeviceOpen	(	_In_ PBL_DEVICE_DESCRIPTOR	Device,
		_In_ ULONG	Flags,
		_In_ ULONG	Unknown,
		_Out_ PULONG	DeviceId
	)

Definition at line 2111 of file device.c.

{
    NTSTATUS Status;
    PBL_DEVICE_ENTRY DeviceEntry;
    PBL_DEVICE_DESCRIPTOR LocateDeviceDescriptor;
    PBL_REGISTERED_DEVICE RegisteredDevice;
    PLIST_ENTRY NextEntry, ListHead;
 
    DeviceEntry = NULL;
 
    /* Check for missing parameters */
    if (!(Device) || !(DeviceId) || !(Device->Size))
    {
        /* Bail out */
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Make sure both read and write access are set */
    if (!(Flags & (BL_DEVICE_READ_ACCESS | BL_DEVICE_WRITE_ACCESS)))
    {
        /* Bail out */
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Check if the boot device is being opened */
    if (Device->DeviceType == BootDevice)
    {
        /* Select it */
        Device = BlpBootDevice;
    }
 
    /* Check if the 'locate' device is being opened */
    if (Device->DeviceType == LocateDevice)
    {
        /* Go find it */
        Status = BlpDeviceResolveLocate(Device, &LocateDeviceDescriptor);
        if (!NT_SUCCESS(Status))
        {
            /* Not found, bail out */
            goto Quickie;
        }
 
        /* Select it */
        Device = LocateDeviceDescriptor;
    }
 
    /* Check if the device isn't ready yet */
    if (Device->Flags & 1)
    {
        /* Return a failure */
        Status = STATUS_DEVICE_NOT_READY;
        goto Quickie;
    }
 
    /* Check if we already have an entry for the device */
    DeviceEntry = BlTblFindEntry(DmDeviceTable,
                                 DmTableEntries,
                                 DeviceId,
                                 DeviceTableCompare,
                                 Device,
                                 &Flags,
                                 &Unknown,
                                 NULL);
    if (DeviceEntry)
    {
        /* Return it, taking a reference on it */
        *DeviceId = DeviceEntry->DeviceId;
        ++DeviceEntry->ReferenceCount;
        DeviceEntry->Flags |= BL_DEVICE_ENTRY_OPENED;
        return STATUS_SUCCESS;
    }
 
    /* We don't, allocate one */
    DeviceEntry = BlMmAllocateHeap(sizeof(*DeviceEntry));
    if (!DeviceEntry)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Fill it out */
    RtlZeroMemory(DeviceEntry, sizeof(*DeviceEntry));
    DeviceEntry->ReferenceCount = 1;
    DeviceEntry->Flags |= (BL_DEVICE_ENTRY_OPENED |
                           BL_DEVICE_ENTRY_READ_ACCESS |
                           BL_DEVICE_ENTRY_WRITE_ACCESS);
    DeviceEntry->Unknown = Unknown;
 
    /* Save flag 8 if needed */
    if (Flags & 8)
    {
        DeviceEntry->Flags |= 8;
    }
 
    /* Allocate a device descriptor for the device */
    DeviceEntry->DeviceDescriptor = BlMmAllocateHeap(Device->Size);
    if (!DeviceEntry->DeviceDescriptor)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Copy the descriptor that was passed in */
    RtlCopyMemory(DeviceEntry->DeviceDescriptor, Device, Device->Size);
 
    /* Now loop the list of dynamically registered devices */
    ListHead = &DmRegisteredDevices;
    NextEntry = ListHead->Flink;
    while (NextEntry != ListHead)
    {
        /* Get the device */
        RegisteredDevice = CONTAINING_RECORD(NextEntry,
                                             BL_REGISTERED_DEVICE,
                                             ListEntry);
 
        /* Open the device */
        Status = RegisteredDevice->Callbacks.Open(Device, DeviceEntry);
        if (NT_SUCCESS(Status))
        {
            /* The device was opened, so we have the right one */
            goto DeviceOpened;
        }
 
        /* Nope, keep trying */
        NextEntry = NextEntry->Flink;
    }
 
    /* Well, it wasn't a dynamic device. Is it a block device? */
    if ((Device->DeviceType == PartitionDevice) ||
        (Device->DeviceType == DiskDevice) ||
        (Device->DeviceType == LegacyPartitionDevice))
    {
        /* Call the Block I/O handler */
        Status = BlockIoDeviceFunctionTable.Open(Device, DeviceEntry);
    }
    else if (Device->DeviceType == SerialDevice)
    {
        /* It's a serial device, call the serial device handler */
        Status = SerialPortFunctionTable.Open(Device, DeviceEntry);
    }
    else if (Device->DeviceType == UdpDevice)
    {
        /* It's a network device, call the UDP device handler */
        Status = UdpFunctionTable.Open(Device, DeviceEntry);
    }
    else
    {
        /* Unsupported type of device */
        Status = STATUS_NOT_IMPLEMENTED;
    }
 
    /* Check if the device was opened successfully */
    if (NT_SUCCESS(Status))
    {
DeviceOpened:
        /* Save the entry in the device table */
        Status = BlTblSetEntry(&DmDeviceTable,
                               &DmTableEntries,
                               DeviceEntry,
                               DeviceId,
                               DeviceTablePurge);
        if (NT_SUCCESS(Status))
        {
            /* It worked -- return the ID in the table to the caller */
            EfiPrintf(L"Device ID: %lx\r\n", *DeviceId);
            DeviceEntry->DeviceId = *DeviceId;
            return STATUS_SUCCESS;
        }
    }
 
Quickie:
    /* Failure path -- did we allocate a device entry? */
    EfiPrintf(L"Block failure: %lx\r\n", Status);
    if (DeviceEntry)
    {
        /* Yep -- did it have a descriptor? */
        if (DeviceEntry->DeviceDescriptor)
        {
            /* Free it */
            BlMmFreeHeap(DeviceEntry->DeviceDescriptor);
        }
 
        /* Free the entry */
        BlMmFreeHeap(DeviceEntry);
    }
 
    /* Return the failure */
    return Status;
}

Referenced by BiLoadHive(), BlBsdInitializeLog(), BlImgLoadBootApplication(), BmFwInitializeBootDirectoryPath(), and OslPrepareTarget().

◆ BlpDisplayInitialize()

NTSTATUS BlpDisplayInitialize ( _In_ ULONG Flags )

Definition at line 575 of file display.c.

{
    NTSTATUS Status;
 
    /* Are we resetting or initializing? */
    if (Flags & BL_LIBRARY_FLAG_REINITIALIZE)
    {
        /* This is a reset */
        Status = DsppReinitialize(Flags);
        if (NT_SUCCESS(Status))
        {
            /* Re-initialize the class as well */
            Status = BlpDisplayReinitialize();
        }
    }
    else
    {
        /* Initialize the display */
        Status = DsppInitialize(Flags);
    }
 
    /* Return display initialization state */
    return Status;
}

Referenced by BlInitializeLibrary(), and InitializeLibrary().

◆ BlpDisplayRegisterLocale()

NTSTATUS BlpDisplayRegisterLocale ( _In_ PWCHAR Locale )

Definition at line 177 of file display.c.

{
    BOOLEAN StandardLocale;
    NTSTATUS Status;
    PWCHAR FontFileName;
    PBL_DEFERRED_FONT_FILE DeferredFont;
    PLIST_ENTRY NextEntry;
    WCHAR Prefix[3];
 
    /* Assume custom locale */
    StandardLocale = FALSE;
 
    /* Bail out if the locale string seems invalid */
    if (wcslen(Locale) < 2)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check the prefix first, then traditional vs. simplified */
    Prefix[0] = Locale[0];
    Prefix[1] = Locale[1];
    Prefix[2] = UNICODE_NULL;
    if (!_wcsicmp(Prefix, L"ja"))
    {
        FontFileName = L"\\jpn_boot.ttf";
    }
    else if (!_wcsicmp(Prefix, L"ko"))
    {
        FontFileName = L"\\kor_boot.ttf";
    }
    else if (!(_wcsicmp(Locale, L"zh-CN")) ||
             !(_wcsicmp(Locale, L"zh-CHS")) ||
             !(_wcsicmp(Locale, L"zh-Hans")))
    {
        FontFileName = L"\\chs_boot.ttf";
    }
    else if (!(_wcsicmp(Locale, L"zh-TW")) &&
             !(_wcsicmp(Locale, L"zh-CHT")) &&
             !(_wcsicmp(Locale, L"zh-HK")) &&
             !(_wcsicmp(Locale, L"zh-Hant")))
    {
        FontFileName = L"\\cht_boot.ttf";
    }
    else
    {
        StandardLocale = TRUE;
        FontFileName = L"\\wgl4_boot.ttf";
    }
 
    /* Parse all the currently deferred fonts*/
    NextEntry = BfiDeferredListHead.Flink;
    while (NextEntry != &BfiDeferredListHead)
    {
        /* Grab the font */
        DeferredFont = CONTAINING_RECORD(NextEntry, BL_DEFERRED_FONT_FILE, ListEntry);
 
        /* Move to the next entry, and remove this one */
        NextEntry = NextEntry->Flink;
        RemoveEntryList(&DeferredFont->ListEntry);
 
        /* Free the deferred font, we'll be loading a new one */
        BfiFreeDeferredFontFile(DeferredFont);
    }
 
    /* Load the primary font */
    Status = DsppLoadFontFile(FontFileName);
    if (NT_SUCCESS(Status) && !(StandardLocale))
    {
        /* Also load the standard US one if we loaded a different one */
        Status = DsppLoadFontFile(L"\\wgl4_boot.ttf");
    }
 
    /* Return back to caller */
    return Status;
}

Referenced by ResSelectLocale().

◆ BlpDisplayReinitialize()

NTSTATUS BlpDisplayReinitialize ( VOID )

Definition at line 542 of file display.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PBL_TEXT_CONSOLE TextConsole;
    PBL_INPUT_CONSOLE InputConsole;
 
    /* Do we have a local console? */
    InputConsole = DspLocalInputConsole;
    if (InputConsole)
    {
        /* Reinitialize it */
        Status = InputConsole->Callbacks->Reinitialize((PBL_TEXT_CONSOLE)InputConsole);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
 
    /* Do we have a text console? */
    TextConsole = DspTextConsole;
    if (TextConsole)
    {
        /* Reinitialize it */
        Status = TextConsole->Callbacks->Reinitialize(TextConsole);
    }
 
    /* Return status */
    return Status;
}

Referenced by BlImgStartBootApplication(), and BlpDisplayInitialize().

◆ BlPdQueryData()

NTSTATUS BlPdQueryData	(	_In_ const GUID *	DataGuid,
		_In_ PVOID	Unknown,
		_Inout_ PBL_PD_DATA_BLOB	DataBlob
	)

Definition at line 457 of file bootlib.c.

{
    /* Check for invalid or missing parameters */
    if (!(DataBlob) ||
        !(DataGuid) ||
        ((DataBlob->BlobSize) && !(DataBlob->Data)))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check if there's no persistent data blobs */
    if (IsListEmpty(&BlpPdListHead))
    {
        return STATUS_NOT_FOUND;
    }
 
    /* Not yet handled, TODO */
    EfiPrintf(L"Boot persistent data not yet implemented\r\n");
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by BmpProcessBadMemory().

◆ BlpFileInitialize()

NTSTATUS BlpFileInitialize ( VOID )

Definition at line 908 of file file.c.

{
    NTSTATUS Status;
 
    /* Allocate the file table */
    FileEntries = 16;
    FileTable = BlMmAllocateHeap(sizeof(PBL_FILE_ENTRY) * FileEntries);
    if (!FileTable)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Initialize it */
    RtlZeroMemory(FileTable, sizeof(PBL_FILE_ENTRY) * FileEntries);
    InitializeListHead(&RegisteredFileSystems);
 
#if 0
    /* Initialize the network file system */
    Status = BlpFileRegisterFileSystem(NetRegisterFunctionTable.Init,
                                       NetRegisterFunctionTable.Destroy,
                                       NetRegisterFunctionTable.Mount,
                                       NetRegisterFunctionTable.Purge,
                                       1);
    if (NT_SUCCESS(Status))
    {
        /* Initialize NTFS */
        Status = BlpFileRegisterFileSystem(NtfsRegisterFunctionTable.Init,
                                           NtfsRegisterFunctionTable.Destroy,
                                           NtfsRegisterFunctionTable.Mount,
                                           NtfsRegisterFunctionTable.Purge,
                                           0);
    }
 
    if (NT_SUCCESS(Status))
#endif
    {
        /* Initialize FAT */
        Status = BlpFileRegisterFileSystem(FatRegisterFunctionTable.Init,
                                           FatRegisterFunctionTable.Destroy,
                                           FatRegisterFunctionTable.Mount,
                                           FatRegisterFunctionTable.Purge,
                                           0);
    }
 
#if 0
    if (NT_SUCCESS(Status))
    {
        /* Initialize EXFAT (FatPlus) */
        Status = BlpFileRegisterFileSystem(FppRegisterFunctionTable.Init,
                                           FppRegisterFunctionTable.Destroy,
                                           FppRegisterFunctionTable.Mount,
                                           FppRegisterFunctionTable.Purge,
                                           0);
    }
 
    if (NT_SUCCESS(Status))
    {
        /* Initialize WIM */
        Status = BlpFileRegisterFileSystem(WimRegisterFunctionTable.Init,
                                           WimRegisterFunctionTable.Destroy,
                                           WimRegisterFunctionTable.Mount,
                                           WimRegisterFunctionTable.Purge,
                                           0);
    }
 
    if (NT_SUCCESS(Status))
    {
        /* Initialize UDFS */
        Status = BlpFileRegisterFileSystem(UdfsRegisterFunctionTable.Init,
                                           UdfsRegisterFunctionTable.Destroy,
                                           UdfsRegisterFunctionTable.Mount,
                                           UdfsRegisterFunctionTable.Purge,
                                           0);
    }
#endif
    if (NT_SUCCESS(Status))
    {
        /* Initialize El-Torito CDFS */
        Status = BlpFileRegisterFileSystem(EtfsRegisterFunctionTable.Init,
                                           EtfsRegisterFunctionTable.Destroy,
                                           EtfsRegisterFunctionTable.Mount,
                                           EtfsRegisterFunctionTable.Purge,
                                           0);
    }
 
    /* Destroy the file manager if any of the file systems didn't initialize */
    if (!NT_SUCCESS(Status))
    {
        if (FileTable)
        {
            //BlpFileDestroy();
        }
    }
    return Status;
}

Referenced by BlpIoInitialize().

◆ BlpFwInitialize()

NTSTATUS BlpFwInitialize	(	_In_ ULONG	Phase,
		_In_ PBL_FIRMWARE_DESCRIPTOR	FirmwareParameters
	)

Definition at line 2290 of file firmware.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    EFI_KEY_TOGGLE_STATE KeyToggleState;
 
    /* Check if we have valid firmware data */
    if (!(FirmwareData) || !(FirmwareData->Version))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check which boot phase we're in */
    if (Phase != 0)
    {
        /* Memory manager is ready, open the extended input protocol */
        Status = EfiOpenProtocol(EfiST->ConsoleInHandle,
                                 &EfiSimpleTextInputExProtocol,
                                 (PVOID*)&EfiConInEx);
        if (NT_SUCCESS(Status))
        {
            /* Set the initial key toggle state */
            KeyToggleState = EFI_TOGGLE_STATE_VALID | 40;
            EfiConInExSetState(EfiConInEx, &KeyToggleState);
        }
 
        /* Setup the watchdog timer */
        EfiSetWatchdogTimer();
    }
    else
    {
        /* Make a copy of the parameters */
        EfiFirmwareParameters = &EfiFirmwareData;
 
        /* Check which version we received */
        if (FirmwareData->Version == 1)
        {
            /* FIXME: Not supported */
            Status = STATUS_NOT_SUPPORTED;
        }
        else if (FirmwareData->Version >= BL_FIRMWARE_DESCRIPTOR_VERSION)
        {
            /* Version 2 -- save the data */
            EfiFirmwareData = *FirmwareData;
            EfiSystemTable = FirmwareData->SystemTable;
            EfiImageHandle = FirmwareData->ImageHandle;
 
            /* Set the EDK-II style variables as well */
            EfiST = EfiSystemTable;
            EfiBS = EfiSystemTable->BootServices;
            EfiRT = EfiSystemTable->RuntimeServices;
            EfiConOut = EfiSystemTable->ConOut;
            EfiConIn = EfiSystemTable->ConIn;
            EfiConInEx = NULL;
        }
        else
        {
            /* Unknown version */
            Status = STATUS_NOT_SUPPORTED;
        }
    }
 
    /* Return the initialization state */
    return Status;
}

Referenced by InitializeLibrary().

◆ BlpGetBootOptionIntegerList()

NTSTATUS BlpGetBootOptionIntegerList	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type,
		_Out_ PULONGLONG *	Value,
		_Out_ PULONGLONG	Count,
		_In_ BOOLEAN	NoCopy
	)

Definition at line 541 of file bcdopt.c.

{
    PBL_BCD_OPTION Option;
    BcdElementType ElementType;
    PULONGLONG ValueCopy;
 
    /* Make sure this is a BCD_TYPE_INTEGER_LIST */
    ElementType.PackedValue = Type;
    if (ElementType.Format != BCD_TYPE_INTEGER_LIST)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the data */
    Option = MiscGetBootOption(List, Type);
    if (!Option)
    {
        return STATUS_NOT_FOUND;
    }
 
    /* Check if a copy should be made of it */
    if (NoCopy)
    {
        /* Nope, return the raw value */
        *Value = (PULONGLONG)((ULONG_PTR)Option + Option->DataOffset);
    }
    else
    {
        /* Allocate a buffer for the copy */
        ValueCopy = BlMmAllocateHeap(Option->DataSize);
        if (!ValueCopy)
        {
            return STATUS_NO_MEMORY;
        }
 
        /* Copy the data in */
        RtlCopyMemory(ValueCopy,
                      (PVOID)((ULONG_PTR)Option + Option->DataOffset),
                      Option->DataSize);
 
        /* Return our copy */
        *Value = ValueCopy;
    }
 
    /* Return count and success */
    *Count = Option->DataSize / sizeof(ULONGLONG);
    return STATUS_SUCCESS;
}

Referenced by BlImgLoadBootApplication(), and BlMmRemoveBadMemory().

◆ BlpIoInitialize()

NTSTATUS BlpIoInitialize ( VOID )

Definition at line 35 of file io.c.

{
    NTSTATUS Status;
    ULONG Size;
 
    /* Allocate the I/O table */
    IoMgrRoutineEntries = 4;
    Size = IoMgrRoutineEntries * sizeof(PVOID);
    IoMgrDestroyRoutineTable = BlMmAllocateHeap(Size);
    if (IoMgrDestroyRoutineTable)
    {
        /* Zero it out */
        RtlZeroMemory(IoMgrDestroyRoutineTable, Size);
 
        /* Initialize the device manager */
        Status = BlpDeviceInitialize();
 
        /* Initialize the file manager */
        if (NT_SUCCESS(Status))
        {
            Status = BlpFileInitialize();
        }
    }
    else
    {
        /* No memory */
        Status = STATUS_NO_MEMORY;
    }
 
    /* Return initialization status */
    return Status;
}

Referenced by InitializeLibrary().

◆ BlpIoRegisterDestroyRoutine()

NTSTATUS BlpIoRegisterDestroyRoutine ( _In_ PBL_IO_DESTROY_ROUTINE DestroyRoutine )

Definition at line 21 of file io.c.

{
    ULONG Id;
 
    return BlTblSetEntry(&IoMgrDestroyRoutineTable,
                         &IoMgrRoutineEntries,
                         DestroyRoutine,
                         &Id,
                         TblDoNotPurgeEntry);
}

Referenced by BcInitialize(), and BlockIopInitialize().

◆ BlpMmCreateBlockAllocator()

NTSTATUS BlpMmCreateBlockAllocator ( VOID )

Definition at line 213 of file blkalloc.c.

{
    PBL_BLOCK_DESCRIPTOR BlockInfo;
    ULONG BlockId;
    NTSTATUS Status;
 
    /* If the block allocator isn't initialized, bail out */
    BlockId = -1;
    if (!MmBlockAllocatorInitialized)
    {
        goto Quickie;
    }
 
    /* Allocate a block descriptor and zero it out */
    BlockInfo = BlMmAllocateHeap(sizeof(*BlockInfo));
    if (!BlockInfo)
    {
        goto Quickie;
    }
    RtlZeroMemory(BlockInfo, sizeof(*BlockInfo));
 
    /* Setup the block descriptor */
    BlockInfo->Attributes = 0;
    BlockInfo->Type = BlLoaderBlockMemory;
    BlockInfo->Unknown = 1;
    BlockInfo->Unknown2 = 1;
    BlockInfo->Size = PAGE_SIZE;
    BlockInfo->Count = 128;
    BlockInfo->Count2 = 128;
    InitializeListHead(&BlockInfo->ListHead);
 
    /* Add it to the list of block descriptors */
    Status = BlTblSetEntry(&MmBlockAllocatorTable,
                           &MmBlockAllocatorTableEntries,
                           BlockInfo,
                           &BlockId,
                           MmBapPurgeBlockAllocatorTableEntry);
    if (NT_SUCCESS(Status))
    {
        /* Add the initial reference and store the block ID */
        BlockInfo->ReferenceCount = 1;
        BlockInfo->BlockId = BlockId;
    }
 
Quickie:
    /* On failure, free the block descriptor */
    if (BlockId == -1)
    {
        BlMmFreeHeap(BlockInfo);
    }
 
    /* Return the block descriptor ID, or -1 on failure */
    return BlockId;
}

Referenced by BcInitialize().

◆ BlpMmInitialize()

NTSTATUS BlpMmInitialize	(	_In_ PBL_MEMORY_DATA	MemoryData,
		_In_ BL_TRANSLATION_TYPE	TranslationType,
		_In_ PBL_LIBRARY_PARAMETERS	LibraryParameters
	)

Definition at line 541 of file mm.c.

{
    NTSTATUS Status;
 
    /* Take a reference */
    MmDescriptorCallTreeCount = 1;
 
    /* Only support valid translation types */
    if ((TranslationType > BlPae) || (LibraryParameters->TranslationType > BlPae))
    {
        /* Bail out */
        EfiPrintf(L"Invalid translation types present\r\n");
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Initialize memory descriptors */
    MmMdInitialize(0, LibraryParameters);
 
    /* Remember the page type we came in with */
    MmOriginalTranslationType = TranslationType;
 
    /* Initialize the physical page allocator */
    Status = MmPaInitialize(MemoryData,
                            LibraryParameters->MinimumAllocationCount);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Initialize the memory tracker */
    Status = MmTrInitialize();
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"TR Mm init failed: %lx\r\n", Status);
        //MmArchDestroy();
        //MmPaDestroy(1);
        goto Quickie;
    }
 
    /* Initialize paging, large pages, self-mapping, PAE, if needed */
    Status = MmArchInitialize(1,
                              MemoryData,
                              TranslationType,
                              LibraryParameters->TranslationType);
    if (NT_SUCCESS(Status))
    {
        /* Save the newly active transation type */
        MmTranslationType = LibraryParameters->TranslationType;
 
        /* Initialize the heap allocator now */
        Status = MmHaInitialize(LibraryParameters->MinimumHeapSize,
                                LibraryParameters->HeapAllocationAttributes);
    }
 
    /* If Phase 1 init failed, bail out */
    if (!NT_SUCCESS(Status))
    {
        /* Kill everything set setup so far */
        EfiPrintf(L"Phase 1 Mm init failed: %lx\r\n", Status);
        //MmPaDestroy(0);
        //MmTrDestroy();
        //MmArchDestroy();
        //MmPaDestroy(1);
        goto Quickie;
    }
 
    /* Do we have too many descriptors? */
    if (LibraryParameters->DescriptorCount > 512)
    {
        /* Switch to using a dynamic buffer instead */
        EfiPrintf(L"Warning: too many descriptors\r\n");
        Status = STATUS_NOT_IMPLEMENTED;
        goto Quickie;
        //MmMdpSwitchToDynamicDescriptors(LibraryParameters->DescriptorCount);
    }
 
    /* Remove memory that the BCD says is bad */
    BlMmRemoveBadMemory();
 
    /* Now map all the memory regions as needed */
    Status = MmArchInitialize(2,
                              MemoryData,
                              TranslationType,
                              LibraryParameters->TranslationType);
    if (NT_SUCCESS(Status))
    {
        /* Initialize the block allocator */
        Status = MmBaInitialize();
    }
 
    /* Check if anything in phase 2 failed */
    if (!NT_SUCCESS(Status))
    {
        /* Go back to static descriptors and kill the heap */
        EfiPrintf(L"Phase 2 Mm init failed: %lx\r\n", Status);
        //MmMdpSwitchToStaticDescriptors();
        //HapInitializationStatus = 0;
        //++MmDescriptorCallTreeCount;
 
        /* Destroy the Phase 1 initialization */
        //MmPaDestroy(0);
        //MmTrDestroy();
        //MmArchDestroy();
        //MmPaDestroy(1);
    }
 
Quickie:
    /* Free the memory descriptors and return the initialization state */
    MmMdFreeGlobalDescriptors();
    --MmDescriptorCallTreeCount;
    return Status;
}

Referenced by InitializeLibrary().

◆ BlpMmInitializeConstraints()

NTSTATUS BlpMmInitializeConstraints ( VOID )

Definition at line 106 of file pagealloc.c.

{
    NTSTATUS Status, ReturnStatus;
    ULONGLONG LowestAddressValid, HighestAddressValid;
    ULONGLONG LowestPage, HighestPage;
 
    /* Assume success */
    ReturnStatus = STATUS_SUCCESS;
 
    /* Check for LOWMEM */
    Status = BlGetBootOptionInteger(BlpApplicationEntry.BcdData,
                                    BcdLibraryInteger_AvoidLowPhysicalMemory,
                                    &LowestAddressValid);
    if (NT_SUCCESS(Status))
    {
        /* Align the address */
        LowestAddressValid = (ULONG_PTR)PAGE_ALIGN(LowestAddressValid);
        LowestPage = LowestAddressValid >> PAGE_SHIFT;
 
        /* Make sure it's below 4GB */
        if (LowestPage <= 0x100000)
        {
            PapMinimumPhysicalPage = LowestPage;
        }
    }
 
    /* Check for MAXMEM */
    Status = BlGetBootOptionInteger(BlpApplicationEntry.BcdData,
                                    BcdLibraryInteger_TruncatePhysicalMemory,
                                    &HighestAddressValid);
    if (NT_SUCCESS(Status))
    {
        /* Get the page */
        HighestPage = HighestAddressValid >> PAGE_SHIFT;
 
        /* Truncate memory above this page */
        ReturnStatus = MmPaTruncateMemory(HighestPage);
    }
 
    /* Return back to the caller */
    return ReturnStatus;
}

Referenced by BlInitializeLibrary(), and MmPaInitialize().

◆ BlpResourceInitialize()

NTSTATUS BlpResourceInitialize ( VOID )

Definition at line 478 of file resource.c.

{
    NTSTATUS Status;
    PIMAGE_SECTION_HEADER ResourceSection;
    PVOID ImageBase;
    ULONG ImageSize, VRes, HRes;
    BOOLEAN UsePrimary;
 
    /* Default to using fallback */
    UsePrimary = FALSE;
 
    /* Initialize all globals */
    ResMuiImageBase = 0;
    ResMuiImageSize = 0;
    ResRootDirectoryPrimary = 0;
    ResRootDirectoryPrimaryOffset = 0;
    ResPeImageBasePrimary = 0;
    ResPeImageEndPrimary = 0;
    ResRootDirectoryFallback = 0;
    ResRootDirectoryFallbackOffset = 0;
    ResPeImageBaseFallback = 0;
    ResPeImageEndFallback = 0;
    ResRootDirectory = 0;
    ResRootDirectoryOffset = 0;
    ResPeImageBase = 0;
    ResPeImageEnd = 0;
    ResLoadedFontFiles = 0;
 
    /* Check if we had allocated a locale already */
    if (ResLocale)
    {
        /* Free it and reset */
        BlMmFreeHeap(ResLocale);
        ResLocale = 0;
    }
 
    /* Get our base address and size*/
    Status = BlGetApplicationBaseAndSize(&ImageBase, &ImageSize);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Find our resource section */
    ResourceSection = BlImgFindSection(ImageBase, ImageSize);
    if (ResourceSection)
    {
        /* The resource section will be our fallback. Save down its details */
        ResRootDirectoryFallbackOffset = ResourceSection->VirtualAddress;
        ResPeImageBaseFallback = ImageBase;
        ResPeImageEndFallback = (PVOID)((ULONG_PTR)ImageBase + ImageSize);
        ResRootDirectoryFallback = (PIMAGE_RESOURCE_DIRECTORY)((ULONG_PTR)ImageBase +
                                            ResRootDirectoryFallbackOffset);
    }
 
    /* Get the current screen resolution and check if we're in graphics mode */
    Status = BlDisplayGetScreenResolution(&HRes, &VRes);
    if ((NT_SUCCESS(Status)) && ((HRes != 640) || (VRes != 200)))
    {
        /* We are... we should load MUI data */
        Status = STATUS_NOT_IMPLEMENTED;//ResInitializeMuiResources();
        if (NT_SUCCESS(Status))
        {
            /* And not rely on the fallback */
            UsePrimary = TRUE;
        }
    }
 
    /* Load the locale resources */
    return ResSelectLocale(UsePrimary);
}

Referenced by BlInitializeLibrary(), and InitializeLibrary().

◆ BlpSecureBootEFIIsEnabled()

NTSTATUS BlpSecureBootEFIIsEnabled ( VOID )

Definition at line 687 of file firmware.c.

{
    NTSTATUS Status;
    BOOLEAN SetupMode, SecureBoot;
    ULONG DataSize;
 
    /* Assume setup mode enabled, and no secure boot */
    SecureBoot = FALSE;
    SetupMode = TRUE;
 
    /* Get the SetupMode variable */
    DataSize = sizeof(SetupMode);
    Status = EfiGetVariable(L"SetupMode",
                            &EfiGlobalVariable,
                            NULL,
                            &DataSize,
                            &SetupMode);
    if (NT_SUCCESS(Status))
    {
        /* If it worked, get the SecureBoot variable */
        DataSize = sizeof(SecureBoot);
        Status = EfiGetVariable(L"SecureBoot",
                                &EfiGlobalVariable,
                                NULL,
                                &DataSize,
                                &SecureBoot);
        if (NT_SUCCESS(Status))
        {
            /* In setup mode or without secureboot turned on, return failure */
            if ((SecureBoot != TRUE) || (SetupMode))
            {
                Status = STATUS_INVALID_SIGNATURE;
            }
 
            // BlpSbdiStateFlags |= 8u;
        }
    }
 
    /* Return secureboot status */
    return Status;
}

Referenced by BlSecureBootIsEnabled().

◆ BlpTimeCalibratePerformanceCounter()

NTSTATUS BlpTimeCalibratePerformanceCounter ( VOID )

Definition at line 62 of file time.c.

{
#if defined(_M_IX86) || defined(_M_X64)
    INT CpuInfo[4];
 
    /* Check if the ISVM bit it set, meaning we're in a hypervisor */
    __cpuid(CpuInfo, 1);
    if (CpuInfo[2] & 0x80000000)
    {
        /* Get the Hypervisor Identification Leaf */
        __cpuid(CpuInfo, 0x40000001);
 
        /* Is this Hyper-V? */
        if (CpuInfo[0] == '1#vH')
        {
            /* Get the Hypervisor Feature Identification Leaf */
            __cpuid(CpuInfo, 0x40000003);
 
            /* Check if HV_X64_MSR_REFERENCE_TSC is present */
            if (CpuInfo[3] & 0x100)
            {
                /* Read the TSC frequency from the MSR */
                BlpTimePerformanceFrequency = __readmsr(0x40000022);
                return STATUS_SUCCESS;
            }
        }
    }
 
    /* On other systems, compute it */
    return BlpTimeMeasureTscFrequency();
#else
    EfiPrintf(L"BlpTimeCalibratePerformanceCounter not implemented for this platform.\r\n");
    return STATUS_NOT_IMPLEMENTED;
#endif
}

Referenced by InitializeLibrary().

◆ BlRemoveBootOption()

VOID BlRemoveBootOption	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type
	)

Definition at line 801 of file bcdopt.c.

{
    PBL_BCD_OPTION Option;
 
    /* Keep going until the option is gone */
    while (1)
    {
        /* Get the BCD option */
        Option = MiscGetBootOption(List, Type);
        if (!Option)
        {
            break;
        }
 
        /* Pretend it's empty */
        Option->Empty = TRUE;
    }
}

Referenced by BmLaunchRecoverySequence(), BmMain(), BmpGetSelectedBootEntry(), BmpLaunchBootEntry(), and OslpRemoveInternalApplicationOptions().

◆ BlReplaceBootOptions()

NTSTATUS BlReplaceBootOptions	(	_In_ PBL_LOADED_APPLICATION_ENTRY	AppEntry,
		_In_ PBL_BCD_OPTION	NewOptions
	)

Definition at line 824 of file bcdopt.c.

{
    NTSTATUS Status;
    ULONG OptionSize;
    PBL_BCD_OPTION NewOptions;
 
    /* Make sure there's something to replace with */
    if (!OldOptions)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check if we already had allocated internal options */
    if (AppEntry->Flags & BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL)
    {
        /* Free them */
        BlMmFreeHeap(AppEntry->BcdData);
    }
 
    /* Reset option flags */
    AppEntry->Flags &= ~(BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL |
                         BL_APPLICATION_ENTRY_BCD_OPTIONS_EXTERNAL);
 
    /* Reset the options and set success for now */
    Status = STATUS_SUCCESS;
    AppEntry->BcdData = NULL;
 
    /* Get the size of the new list of options */
    OptionSize = BlGetBootOptionListSize(OldOptions);
 
    /* Allocate a copy of the new list */
    NewOptions = BlMmAllocateHeap(OptionSize);
    if (!NewOptions)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Copy it in */
    RtlCopyMemory(NewOptions, OldOptions, OptionSize);
 
    /* Set it as the new set of options and return */
    AppEntry->Flags |= BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL;
    AppEntry->BcdData = NewOptions;
    return Status;
}

Referenced by BmMain().

◆ BlResourceFindHtml()

PWCHAR BlResourceFindHtml ( VOID )

Definition at line 305 of file resource.c.

{
    NTSTATUS Status;
    PIMAGE_RESOURCE_DATA_ENTRY HtmlDataEntry;
    PWCHAR Stylesheet;
 
    /* Assume failure */
    Stylesheet = NULL;
 
    /* Look for an RT_HTML resource called BOOTMGR.XSL */
    Status = ResFindDataEntryFromImage(NULL,
                                       0,
                                       23,
                                       NULL,
                                       L"BOOTMGR.XSL",
                                       &HtmlDataEntry,
                                       (PVOID*)&Stylesheet);
    if (!NT_SUCCESS(Status))
    {
        return Stylesheet;
    }
 
    /* Check for Unicode BOM */
    if (*Stylesheet == 0xFEFF)
    {
        /* Overwrite it, and NULL-terminate */
        RtlMoveMemory(Stylesheet,
                      Stylesheet + 1,
                      HtmlDataEntry->Size - sizeof(WCHAR));
        Stylesheet[(HtmlDataEntry->Size / sizeof(WCHAR)) - 1] = UNICODE_NULL;
    }
    else if (Stylesheet[(HtmlDataEntry->Size / sizeof(WCHAR)) - 1] != UNICODE_NULL)
    {
        /* If it's not NULL-terminated, fail */
        Stylesheet = NULL;
    }
 
    /* Return it back */
    return Stylesheet;
}

Referenced by BmMain().

◆ BlResourceFindMessage()

PWCHAR BlResourceFindMessage ( _In_ ULONG MsgId )

Definition at line 349 of file resource.c.

{
    PWCHAR Message;
    PIMAGE_RESOURCE_DIRECTORY ResourceDir;
    PIMAGE_RESOURCE_DATA_ENTRY DataEntry;
    PMESSAGE_RESOURCE_DATA MsgData;
    PMESSAGE_RESOURCE_ENTRY MsgEntry;
    ULONG i, j;
    USHORT Id;
    PVOID MsgEnd;
    NTSTATUS Status;
 
    /* Bail out if there's no resource directory */
    Message = NULL;
    if (!ResRootDirectory)
    {
        return Message;
    }
 
    /* Check if we've loaded fonts already */
    if (!ResLoadedFontFiles)
    {
        /* Nope, load them now */
        Status = BfLoadDeferredFontFiles();
        if (!NT_SUCCESS(Status))
        {
            /* We failed to load fonts, fallback to fallback locale */
            Status = ResSelectLocale(FALSE);
            if (NT_SUCCESS(Status))
            {
                /* Try fonts now */
                Status = BfLoadDeferredFontFiles();
                if (!NT_SUCCESS(Status))
                {
                    /* Still didn't work -- fallback to text mode */
                    EfiPrintf(L"Font loading failed, falling back to text mode\r\n");
                    Status = BlDisplaySetScreenResolution();
                    if (!NT_SUCCESS(Status))
                    {
                        /* That didn't work either. F*ck it. */
                        return Message;
                    }
                }
            }
        }
 
        /* Now we have a resource directory, and fonts are loaded */
        NT_ASSERT(ResRootDirectory != NULL);
        ResLoadedFontFiles = TRUE;
    }
 
    /* Go look for RT_MESSAGETABLE */
    Id = 11;
    ResourceDir = (PIMAGE_RESOURCE_DIRECTORY)ResFindDirectoryEntry(ResRootDirectory,
                                                                   &Id,
                                                                   NULL,
                                                                   (ULONG_PTR)ResRootDirectory);
    if (!ResourceDir)
    {
        return Message;
    }
 
    /* Go look for the first directory in the table */
    Id = 1;
    ResourceDir = (PIMAGE_RESOURCE_DIRECTORY)ResFindDirectoryEntry(ResourceDir,
                                                                   &Id,
                                                                   NULL,
                                                                   (ULONG_PTR)ResRootDirectory);
    if (!ResourceDir)
    {
        return Message;
    }
 
    /* Go look for any language entry in the table */
    Id = -1;
    DataEntry = (PIMAGE_RESOURCE_DATA_ENTRY)ResFindDirectoryEntry(ResourceDir,
                                                                  &Id,
                                                                  NULL,
                                                                  (ULONG_PTR)ResRootDirectory);
    if (!DataEntry)
    {
        return Message;
    }
 
    /* Get the message data*/
    MsgData = (PMESSAGE_RESOURCE_DATA)((ULONG_PTR)ResRootDirectory +
                                        DataEntry->OffsetToData -
                                        ResRootDirectoryOffset);
 
    /* Loop through the message blocks */
    for (j = 0; j < MsgData->NumberOfBlocks; j++)
    {
        /* Check if the ID is within this range */
        if ((MsgId >= MsgData->Blocks[j].LowId) &&
            (MsgId <= MsgData->Blocks[j].HighId))
        {
            /* Get the first entry */
            MsgEntry = (PMESSAGE_RESOURCE_ENTRY)((ULONG_PTR)MsgData +
                                                 MsgData->Blocks[j].OffsetToEntries);
 
            /* Loop till we find the right one */
            for (i = MsgId - MsgData->Blocks[j].LowId; i; --i)
            {
                MsgEntry = (PMESSAGE_RESOURCE_ENTRY)((ULONG_PTR)MsgEntry +
                                                     MsgEntry->Length);
            }
 
            /* Find where this message ends */
            MsgEnd = (PVOID)((ULONG_PTR)MsgEntry + MsgEntry->Length);
 
            /* Now make sure that the message is within bounds */
            if ((MsgEnd >= (PVOID)MsgEntry) &&
                ((PVOID)MsgEntry >= ResPeImageBase) &&
                (MsgEnd <= ResPeImageEnd))
            {
                /* If so, read the text associated with it */
                Message = (PWCHAR)MsgEntry->Text;
                break;
            }
        }
    }
 
    /* Return the text, if one was found */
    return Message;
}

Referenced by BmpErrorLog().

◆ BlSecureBootCheckForFactoryReset()

NTSTATUS BlSecureBootCheckForFactoryReset ( VOID )

Definition at line 759 of file firmware.c.

{
    BOOLEAN SecureBootEnabled;
    NTSTATUS Status;
    ULONG DataSize;
 
    /* Initialize locals */
    DataSize = 0;
    SecureBootEnabled = FALSE;
 
    /* Check if secureboot is enabled */
    Status = BlSecureBootIsEnabled(&SecureBootEnabled);
    if (!(NT_SUCCESS(Status)) || !(SecureBootEnabled))
    {
        /* It's not. Check if there's a revocation list */
        Status = EfiGetVariable(L"RevocationList",
                                &BlpEfiSecureBootPrivateNamespace,
                                NULL,
                                &DataSize,
                                NULL);
        if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_TOO_SMALL))
        {
            /* We don't support this yet */
            EfiPrintf(L"Not yet supported\r\n");
            Status = STATUS_NOT_IMPLEMENTED;
        }
    }
 
    /* Return back to the caller */
    return Status;
}

Referenced by BmMain().

◆ BlSecureBootIsEnabled()

NTSTATUS BlSecureBootIsEnabled ( _Out_ PBOOLEAN SecureBootEnabled )

Definition at line 732 of file firmware.c.

{
    NTSTATUS Status;
 
    /* Have we checked before ? */
    if (!BlpFirmwareChecked)
    {
        /* First time checking */
        Status = BlpSecureBootEFIIsEnabled();
        if NT_SUCCESS(Status)
        {
            /* Yep, it's on */
            BlpFirmwareEnabled = TRUE;
        }
 
        /* Don't check again */
        BlpFirmwareChecked = TRUE;
    }
 
    /* Return the firmware result */
    *SecureBootEnabled = BlpFirmwareEnabled;
    return STATUS_SUCCESS;
}

Referenced by BlSecureBootCheckForFactoryReset(), and BmFwRegisterRevocationList().

◆ BlSetupDefaultParameters()

FORCEINLINE VOID BlSetupDefaultParameters ( _Out_ PBL_LIBRARY_PARAMETERS LibraryParameters )

Definition at line 1354 of file bl.h.

{
    BL_LIBRARY_PARAMETERS DefaultParameters =
    {
        0x20,
        BlVirtual,
        1024,
        2 * 1024 * 1024,
        0,
        NULL,
        0,
        NULL
    };
 
    /* Copy the defaults */
    RtlCopyMemory(LibraryParameters, &DefaultParameters, sizeof(*LibraryParameters));
}

Referenced by BmMain(), and OslMain().

◆ BlStatusError()

VOID BlStatusError	(	_In_ ULONG	ErrorCode,
		_In_ ULONG	Parameter1,
		_In_ ULONG_PTR	Parameter2,
		_In_ ULONG_PTR	Parameter3,
		_In_ ULONG_PTR	Parameter4
	)

Definition at line 121 of file debug.c.

{
    NTSTATUS Status;
 
    /* Is this a non-boot error? */
    if (ErrorCode != 1)
    {
        /* Is one already ongoing? */
        if (!BlpStatusErrorInProgress)
        {
            /* Do we have a custom error handler registered? */
            if (BlpStatusErrorHandler)
            {
                /* Call it, making sure to avoid recursion */
                BlpStatusErrorInProgress = TRUE;
                Status = BlpStatusErrorHandler(ErrorCode,
                                               Parameter1,
                                               Parameter2,
                                               Parameter3,
                                               Parameter4);
                BlpStatusErrorInProgress = FALSE;
 
                /* If the error handler consumed the error, we're done */
                if (NT_SUCCESS(Status))
                {
                    return;
                }
            }
        }
    }
 
    /* Check if the boot debugger is enabled */
    if (BlBdDebuggerEnabled())
    {
        /* Print out the fatal error */
        BlStatusPrint(L"\n"
                      L"*** Fatal Error 0x%08x :\n"
                      L"                (0x%p, 0x%p, 0x%p, 0x%p)\n"
                      L"\n",
                      ErrorCode,
                      Parameter1,
                      Parameter2,
                      Parameter3,
                      Parameter4);
 
        /* Issue a breakpoint */
        __debugbreak();
    }
}

Referenced by BmFatalErrorEx().

◆ BlStatusPrint()

VOID BlStatusPrint	(	_In_ PCWCH	Format,
			...
	)

Definition at line 75 of file debug.c.

{
    ANSI_STRING AnsiString;
    UNICODE_STRING UnicodeString;
    va_list va;
    NTSTATUS Status;
 
    va_start(va, Format);
 
    /* Check if the boot debugger is enabled */
    if (BlBdDebuggerEnabled()
#if DBG
        || TRUE
#endif
    )
    {
        /* Print the string out into a buffer */
        if (vswprintf(BlScratchBuffer, Format, va) > 0)
        {
#if DBG
            EfiPrintf(BlScratchBuffer);
            EfiPrintf(L"\r\n");
#endif
            /* Make it a UNICODE_STRING */
            RtlInitUnicodeString(&UnicodeString, BlScratchBuffer);
 
            /* Then convert it into an ANSI_STRING */
            AnsiString.Length = 0;
            AnsiString.MaximumLength = sizeof(AnsiBuffer);
            AnsiString.Buffer = AnsiBuffer;
            Status = RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, FALSE);
            if (NT_SUCCESS(Status))
            {
                /* Print it out to the debugger if that worked */
                DbgPrint(AnsiString.Buffer);
            }
        }
    }
 
    va_end(va);
}

Referenced by BiEnumerateSubObjectElements(), BlStatusError(), BmFatalErrorEx(), BmFwMemoryInitialize(), MmHapReportHeapCorruption(), OslAbortBoot(), and OslFatalErrorEx().

◆ BlTblFindEntry()

PVOID BlTblFindEntry	(	_In_ PVOID *	Table,
		_In_ ULONG	Count,
		_Out_ PULONG	EntryIndex,
		_In_ PBL_TBL_LOOKUP_ROUTINE	Callback,
		_In_ PVOID	Argument1,
		_In_ PVOID	Argument2,
		_In_ PVOID	Argument3,
		_In_ PVOID	Argument4
	)

Definition at line 273 of file util.c.

{
    PVOID Entry = NULL;
    ULONG Index;
    BOOLEAN Result;
 
    /* Check for invalid parameters */
    if (!(Table) || !(EntryIndex))
    {
        return Entry;
    }
 
    /* Loop each entry in the table */
    for (Index = 0; Index < Count;  Index++)
    {
        /* Check if this entry is filled out */
        if (Table[Index])
        {
            /* Call the comparison function */
            Result = Callback(Table[Index],
                              Argument1,
                              Argument2,
                              Argument3,
                              Argument4);
            if (Result)
            {
                /* Entry found return it */
                *EntryIndex = Index;
                Entry = Table[Index];
                break;
            }
        }
    }
 
    /* Return the entry that was (or wasn't) found */
    return Entry;
}

Referenced by BlockIoOpen(), BlpDeviceOpen(), FileIoOpen(), and MmBapFindBlockInformation().

◆ BlTblMap()

NTSTATUS BlTblMap	(	_In_ PVOID *	Table,
		_In_ ULONG	Count,
		_In_ PBL_TBL_MAP_ROUTINE	MapCallback
	)

Definition at line 399 of file util.c.

{
    NTSTATUS Status, LocalStatus;
    PVOID Entry;
    ULONG Index;
 
    /* Bail out if there's no table */
    if (!Table)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Assume success and loop each index */
    Status = STATUS_SUCCESS;
    for (Index = 0; Index < Count; Index++)
    {
        /* See if an entry exists at this index */
        Entry = Table[Index];
        if (Entry)
        {
            /* Call the map routine for this entry */
            LocalStatus = MapCallback(Entry, Index);
            if (!NT_SUCCESS(LocalStatus))
            {
                /* Propagate failure only */
                Status = LocalStatus;
            }
        }
    }
 
    /* Return status to caller */
    return Status;
}

Referenced by BlockIoDeviceTableDestroy().

◆ BlTblSetEntry()

NTSTATUS BlTblSetEntry	(	_Inout_ PVOID **	Table,
		_Inout_ PULONG	Count,
		_In_ PVOID	Entry,
		_Out_ PULONG	EntryIndex,
		_In_ PBL_TBL_SET_ROUTINE	Callback
	)

Definition at line 321 of file util.c.

{
    ULONG NewCount;
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG Index = 0;
    PVOID* NewTable;
 
    /* Make sure all the parameters were specified */
    if (!(Table) || !(*Table) || !(Count) || !(Callback))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Read the current table */
    NewTable = *Table;
    NewCount = *Count;
 
    /* Iterate over it */
    while (Index < NewCount)
    {
        /* Look for a free index */
        if (!NewTable[Index])
        {
            goto SetIndex;
        }
 
        /* No free index yet, keep going */
        ++Index;
    }
 
    /* No free index was found, try to purge some entries */
    Index = 0;
    while (Index < NewCount)
    {
        /* Call each purge callback, trying to make space */
        Status = Callback(NewTable[Index]);
        if (NT_SUCCESS(Status))
        {
            /* We should have this slot available now */
            goto SetIndex;
        }
 
        /* Keep trying to purge more */
        ++Index;
    }
 
    /* Double the table */
    NewTable = BlMmAllocateHeap(2 * sizeof(PVOID) * NewCount);
    if (!NewTable)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Clear the new table, and copy the old entries */
    RtlZeroMemory(&NewTable[NewCount], sizeof(PVOID) * NewCount);
    RtlCopyMemory(NewTable, *Table, sizeof(PVOID) * NewCount);
 
    /* Free the old table */
    BlMmFreeHeap(*Table);
 
    /* Return the new table and count */
    *Count = 2 * NewCount;
    *Table = NewTable;
 
SetIndex:
    /* Set the index and return */
    NewTable[Index] = Entry;
    *EntryIndex = Index;
    return Status;
}

Referenced by BlHtCreate(), BlImgLoadBootApplication(), BlockIoFirmwareOpen(), BlpDeviceOpen(), BlpIoRegisterDestroyRoutine(), BlpMmCreateBlockAllocator(), EtfsMount(), and FileIoOpen().

◆ BlTimeQueryPerformanceCounter()

ULONGLONG BlTimeQueryPerformanceCounter ( _Out_opt_ PLARGE_INTEGER Frequency )

Definition at line 101 of file time.c.

{
#if defined(_M_IX86) || defined(_M_X64)
    /* Check if caller wants frequency */
    if (Frequency)
    {
        /* Return it */
        Frequency->QuadPart = BlpTimePerformanceFrequency;
    }
 
    /* Return the TSC value */
    return __rdtsc();
#else
    EfiPrintf(L"BlTimeQueryPerformanceCounter not implemented for this platform.\r\n");
    return 0;
#endif
};

Referenced by BlImgLoadBootApplication().

◆ BlUtlCheckSum()

ULONG BlUtlCheckSum	(	_In_ ULONG	PartialSum,
		_In_ PUCHAR	Buffer,
		_In_ ULONG	Length,
		_In_ ULONG	Flags
	)

Definition at line 777 of file util.c.

{
    ULONG i;
 
    if (Flags & BL_UTL_CHECKSUM_UCHAR_BUFFER)
    {
        EfiPrintf(L"Not supported\r\n");
        return 0;
    }
    else if (Flags & BL_UTL_CHECKSUM_USHORT_BUFFER)
    {
        PartialSum = (unsigned __int16)PartialSum;
        Length &= ~1;
 
        for (i = 0; i < Length; i += 2)
        {
            PartialSum += *(unsigned __int16 *)&Buffer[i];
            if (Flags & BL_UTL_CHECKSUM_COMPLEMENT)
            {
                PartialSum = (unsigned __int16)((PartialSum >> 16) + PartialSum);
            }
        }
 
        if (i != Length)
        {
            PartialSum += (unsigned __int8)Buffer[Length];
            if (Flags & BL_UTL_CHECKSUM_COMPLEMENT)
            {
                PartialSum = (unsigned __int16)((PartialSum >> 16) + PartialSum);
            }
        }
 
        if (Flags & BL_UTL_CHECKSUM_NEGATE)
        {
            return ~PartialSum;
        }
 
        PartialSum = (unsigned __int16)PartialSum;
    }
    else
    {
        /* Invalid mode */
        return 0;
    }
 
    if (Flags & BL_UTL_CHECKSUM_NEGATE)
    {
        return ~PartialSum;
    }
 
    return PartialSum;
}

Referenced by ImgpLoadPEImage().

◆ BlUtlGetAcpiTable()

NTSTATUS BlUtlGetAcpiTable	(	_Out_ PVOID *	TableAddress,
		_In_ ULONG	Signature
	)

Definition at line 34 of file util.c.

{
    ULONG i, TableCount, HeaderLength;
    NTSTATUS Status;
    PRSDT Rsdt;
    PXSDT Xsdt;
    PHYSICAL_ADDRESS PhysicalAddress;
    PDESCRIPTION_HEADER Header;
 
    Header = 0;
 
    /* Make sure there's an output parameter */
    if (!TableAddress)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get the currently known RSDT and XSDT */
    Rsdt = (PRSDT)UtlRsdt;
    Xsdt = (PXSDT)UtlXsdt;
 
    /* Is there an RSDT? */
    if (!Rsdt)
    {
        /* No -- is there an XSDT? */
        if (!Xsdt)
        {
            /* No. Look up the RSDT */
            Status = EfipGetRsdt(&PhysicalAddress);
            if (!NT_SUCCESS(Status))
            {
                EfiPrintf(L"no rsdp found\r\n");
                return Status;
            }
 
            /* Map the header */
            Status = BlMmMapPhysicalAddressEx((PVOID)&Header,
                                              0,
                                              sizeof(*Header),
                                              PhysicalAddress);
            if (!NT_SUCCESS(Status))
            {
                return Status;
            }
 
            /* Unmap the header */
            BlMmUnmapVirtualAddressEx(Header, sizeof(*Header));
 
            /* Map the whole table */
            Status = BlMmMapPhysicalAddressEx((PVOID)&Header,
                                              0,
                                              Header->Length,
                                              PhysicalAddress);
            if (!NT_SUCCESS(Status))
            {
                return Status;
            }
 
            /* Check if its an XSDT or an RSDT */
            if (Header->Signature == XSDT_SIGNATURE)
            {
                /* It's an XSDT */
                Xsdt = (PXSDT)Header;
                UtlXsdt = Xsdt;
            }
            else
            {
                /* It's an RSDT */
                Rsdt = (PRSDT)Header;
                UtlRsdt = Rsdt;
            }
        }
    }
 
    /* OK, so do we have an XSDT after all? */
    if (Xsdt)
    {
        /* Yes... how big is it? */
        HeaderLength = Xsdt->Header.Length;
        if (HeaderLength >= sizeof(*Header))
        {
            HeaderLength = sizeof(*Header);
        }
 
        /* Based on that, how many tables are there? */
        TableCount = (Xsdt->Header.Length - HeaderLength) / sizeof(PHYSICAL_ADDRESS);
    }
    else
    {
        /* Nope, we have an RSDT. How big is it? */
        HeaderLength = Rsdt->Header.Length;
        if (HeaderLength >= sizeof(*Header))
        {
            HeaderLength = sizeof(*Header);
        }
 
        /* Based on that, how many tables are there? */
        TableCount = (Rsdt->Header.Length - HeaderLength) / sizeof(ULONG);
    }
 
    /* Loop through the ACPI tables */
    for (i = 0; i < TableCount; i++)
    {
        /* For an XSDT, read the 64-bit address directly */
        if (Xsdt)
        {
            PhysicalAddress = Xsdt->Tables[i];
        }
        else
        {
            /* For RSDT, cast it */
            PhysicalAddress.QuadPart = Rsdt->Tables[i];
        }
 
        /* Map the header */
        Status = BlMmMapPhysicalAddressEx((PVOID)&Header,
                                          0,
                                          sizeof(*Header),
                                          PhysicalAddress);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
 
        /* Is it the right one? */
        if (Header->Signature == Signature)
        {
            /* Unmap the header */
            BlMmUnmapVirtualAddressEx(Header, sizeof(*Header));
 
            /* Map the whole table */
            return BlMmMapPhysicalAddressEx(TableAddress,
                                            0,
                                            Header->Length,
                                            PhysicalAddress);
        }
    }
 
    /* Requested table does not exist */
    return STATUS_NOT_FOUND;
}

Referenced by BlDisplayGetOemBitmap(), and BlDisplayInvalidateOemBitmap().

◆ BlUtlInitialize()

NTSTATUS BlUtlInitialize ( VOID )

Definition at line 197 of file util.c.

{
    UtlRsdt = 0;
    UtlXsdt = 0;
 
    UtlMcContext = 0;
    UtlMcDisplayMessageRoutine = 0;
    UtlMcUpdateMessageRoutine = 0;
 
    UtlProgressRoutine = 0;
    UtlProgressContext = 0;
    UtlProgressInfoRoutine = 0;
    UtlProgressGranularity = 0;
    UtlCurrentPercentComplete = 0;
    UtlNextUpdatePercentage = 0;
    UtlProgressNeedsInfoUpdate = 0;
    UtlProgressInfo = 0;
 
    return STATUS_SUCCESS;
}

Referenced by InitializeLibrary().

◆ BlUtlRegisterProgressRoutine()

NTSTATUS BlUtlRegisterProgressRoutine ( VOID )

Definition at line 244 of file util.c.

{
    /* One shouldn't already exist */
    if (UtlProgressRoutine)
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Set the routine, and no context */
    UtlProgressRoutine = BmUpdateProgress;
    UtlProgressContext = NULL;
 
    /* Progress increases by one */
    UtlProgressGranularity = 1;
 
    /* Set progress to zero for now */
    UtlCurrentPercentComplete = 0;
    UtlNextUpdatePercentage = 0;
 
    /* Set the info routine if there is one */
    UtlProgressInfoRoutine = BmUpdateProgressInfo;
 
    /* All good */
    return STATUS_SUCCESS;
}

Referenced by BmMain().

◆ BlUtlUpdateProgress()

VOID BlUtlUpdateProgress	(	_In_ ULONG	Percentage,
		_Out_opt_ PBOOLEAN	Completed
	)

Definition at line 181 of file util.c.

{
    if (UtlProgressRoutine)
    {
        EfiPrintf(L"Unimplemented\r\n");
    }
    else if (*Completed)
    {
        *Completed = TRUE;
    }
}

Referenced by BlImgLoadImageWithProgress2().

◆ C_ASSERT() [1/2]

C_ASSERT ( BL_MM_INCLUDE_NO_FIRMWARE_MEMORY = =0x1BF )

◆ C_ASSERT() [2/2]

C_ASSERT ( BL_MM_INCLUDE_ONLY_FIRMWARE_MEMORY = =0x240 )

◆ ConsoleCreateLocalInputCnsole()

NTSTATUS ConsoleCreateLocalInputCnsole ( VOID )

◆ ConsoleCreateLocalInputConsole()

NTSTATUS ConsoleCreateLocalInputConsole ( VOID )

Definition at line 243 of file textcons.c.

{
    PBL_INPUT_CONSOLE InputConsole;
    NTSTATUS Status;
 
    /* Allocate the input console */
    InputConsole = BlMmAllocateHeap(sizeof(*InputConsole));
    if (!InputConsole)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Construct it */
    Status = ConsoleInputBaseConstruct(InputConsole);
    if (!NT_SUCCESS(Status))
    {
        /* Tear down on failure */
        BlMmFreeHeap(InputConsole);
        return Status;
    }
 
    /* Set the callback table, and set us as the local input console */
    InputConsole->Callbacks = &ConsoleInputLocalVtbl;
    DspLocalInputConsole = InputConsole;
    return STATUS_SUCCESS;
}

Referenced by DsppInitialize(), and DsppReinitialize().

◆ ConsoleCreateRemoteConsole()

NTSTATUS ConsoleCreateRemoteConsole ( _In_ PBL_TEXT_CONSOLE * TextConsole )

Definition at line 31 of file emscons.c.

{
    PBL_REMOTE_CONSOLE RemoteConsole;
    NTSTATUS Status;
 
    /* Allocate the remote console */
    RemoteConsole = BlMmAllocateHeap(sizeof(*RemoteConsole));
    if (!RemoteConsole)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Construct it */
    Status = ConsoleRemoteConstruct(RemoteConsole);
    if (!NT_SUCCESS(Status))
    {
        /* Failed to construct it, delete it */
        BlMmFreeHeap(RemoteConsole);
        return Status;
    }
 
    /* Save the global pointer and return a pointer to the text console */
    DspRemoteInputConsole = RemoteConsole;
    *TextConsole = &RemoteConsole->TextConsole;
    return STATUS_SUCCESS;
}

Referenced by DsppInitialize(), and DsppReinitialize().

◆ ConsoleEfiGopClose()

VOID ConsoleEfiGopClose ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 177 of file gop.c.

{
    ULONG OldMode;
 
    /* Did we switch modes when we turned on the console? */
    OldMode = GraphicsConsole->OldMode;
    if (GraphicsConsole->Mode != OldMode)
    {
        /* Restore the old mode and reset the OEM bitmap in ACPI */
        EfiGopSetMode(GraphicsConsole->Protocol, OldMode);
        BlDisplayInvalidateOemBitmap();
    }
 
    /* Close the GOP protocol */
    EfiCloseProtocol(GraphicsConsole->Handle,
                     &EfiGraphicsOutputProtocol);
}

Referenced by ConsoleFirmwareGraphicalClose().

◆ ConsoleEfiGopEnable()

NTSTATUS ConsoleEfiGopEnable ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 88 of file gop.c.

{
    PVOID FrameBuffer;
    UINTN CurrentMode, Dummy;
    ULONG Mode, PixelDepth;
    UINTN FrameBufferSize;
    EFI_GRAPHICS_OUTPUT_MODE_INFORMATION ModeInformation;
    EFI_GRAPHICS_OUTPUT_PROTOCOL* Protocol;
    NTSTATUS Status;
    PHYSICAL_ADDRESS FrameBufferPhysical;
 
    /* Capture the current mode and protocol */
    Mode = GraphicsConsole->Mode;
    Protocol = GraphicsConsole->Protocol;
 
    /* Get the current mode and its information */
    Status = EfiGopGetCurrentMode(Protocol, &CurrentMode, &ModeInformation);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Check if we're not in the mode we should be */
    if (CurrentMode != Mode)
    {
        /* Switch modes */
        Status = EfiGopSetMode(Protocol, Mode);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
 
        /* Reset the OEM bitmap and get the new more information */
        BlDisplayInvalidateOemBitmap();
        EfiGopGetCurrentMode(Protocol, &Dummy, &ModeInformation);
    }
 
    /* Get the pixel depth for this mode */
    Status = ConsoleEfiGopGetGraphicalFormat(&ModeInformation, &PixelDepth);
    if (NT_SUCCESS(Status))
    {
        /* Get the framebuffer for this mode */
        EfiGopGetFrameBuffer(Protocol, &FrameBufferPhysical, &FrameBufferSize);
 
        /* Map the framebuffer, try as writeback first */
        FrameBuffer = NULL;
        Status = BlMmMapPhysicalAddressEx(&FrameBuffer,
                                          BlMemoryWriteBack,
                                          FrameBufferSize,
                                          FrameBufferPhysical);
        if (!NT_SUCCESS(Status))
        {
            /* That didn't work, so try uncached next */
            Status = BlMmMapPhysicalAddressEx(&FrameBuffer,
                                              BlMemoryUncached,
                                              FrameBufferSize,
                                              FrameBufferPhysical);
        }
    }
 
    /* Check if getting all the required information worked out */
    if (NT_SUCCESS(Status))
    {
        /* Capture the resolution, depth, and framebuffer information */
        GraphicsConsole->DisplayMode.HRes = ModeInformation.HorizontalResolution;
        GraphicsConsole->DisplayMode.VRes = ModeInformation.VerticalResolution;
        GraphicsConsole->DisplayMode.HRes2 = ModeInformation.PixelsPerScanLine;
        GraphicsConsole->PixelDepth = PixelDepth;
        GraphicsConsole->FrameBuffer = FrameBuffer;
        GraphicsConsole->FrameBufferSize = FrameBufferSize;
        GraphicsConsole->PixelsPerScanLine = ModeInformation.PixelsPerScanLine;
 
        /* All good */
        Status = STATUS_SUCCESS;
    }
    else if (CurrentMode != GraphicsConsole->Mode)
    {
        /* We failed somewhere, reset the mode and the OEM bitmap back */
        EfiGopSetMode(Protocol, CurrentMode);
        BlDisplayInvalidateOemBitmap();
    }
 
    /* Return back to caller */
    return Status;
}

Referenced by ConsoleFirmwareGraphicalEnable().

◆ ConsoleEfiGopOpen()

NTSTATUS ConsoleEfiGopOpen ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 198 of file gop.c.

{
    NTSTATUS Status;
    EFI_GRAPHICS_OUTPUT_PROTOCOL *GopProtocol;
    ULONG Mode, PixelDepth;
    UINTN CurrentMode;
    EFI_GRAPHICS_OUTPUT_MODE_INFORMATION ModeInformation;
    BOOLEAN CurrentModeOk;
 
    /* Open a handle to GOP */
    Status = EfiOpenProtocol(GraphicsConsole->Handle,
                             &EfiGraphicsOutputProtocol,
                             (PVOID*)&GopProtocol);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"GOP OPEN failed: %lx\r\n", Status);
        return STATUS_NOT_SUPPORTED;
    }
 
    /* Get the current mode */
    Status = EfiGopGetCurrentMode(GopProtocol, &CurrentMode, &ModeInformation);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"GOP mode failed: %lx\r\n", Status);
        goto Quickie;
    }
 
    Mode = CurrentMode;
 
    /* Check if any custom BCD options were provided */
    if (ConsoleGraphicalResolutionListFlags &
        (BL_DISPLAY_GRAPHICS_FORCED_VIDEO_MODE_FLAG |
         BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG))
    {
        /* We'll have to find a mode */
        CurrentModeOk = FALSE;
    }
    else
    {
        /* Then we should be in the default mode, check if the pixel format is OK */
        CurrentModeOk = ConsoleEfiGopIsPixelFormatSupported(&ModeInformation);
    }
 
    /* Is the mode/format OK? */
    if (!CurrentModeOk)
    {
        /* Nope -- we'll have to go find one */
        Status = ConsoleEfiGopFindModeFromAllowed(GopProtocol,
                                                  ConsoleGraphicalResolutionList,
                                                  ConsoleGraphicalResolutionListSize,
                                                  &Mode);
        if (!NT_SUCCESS(Status))
        {
            goto Quickie;
        }
    }
 
    /* Store mode information */
    GraphicsConsole->Protocol = GopProtocol;
    GraphicsConsole->Mode = Mode;
    GraphicsConsole->OldMode = CurrentMode;
 
    /* Get format information */
    Status = ConsoleEfiGopGetGraphicalFormat(&ModeInformation, &PixelDepth);
    if (NT_SUCCESS(Status))
    {
        /* Store it */
        GraphicsConsole->OldDisplayMode.HRes = ModeInformation.HorizontalResolution;
        GraphicsConsole->OldDisplayMode.VRes = ModeInformation.VerticalResolution;
        GraphicsConsole->OldDisplayMode.HRes2 = ModeInformation.PixelsPerScanLine;
        GraphicsConsole->PixelDepth = PixelDepth;
        return STATUS_SUCCESS;
    }
 
Quickie:
    /* We failed, close the protocol and return the failure code */
    EfiPrintf(L"Get format failed: %lx\r\n", Status);
    EfiCloseProtocol(GraphicsConsole->Handle, &EfiGraphicsOutputProtocol);
    return Status;
}

Referenced by ConsoleEfiGraphicalOpenProtocol().

◆ ConsoleEfiGraphicalOpenProtocol()

NTSTATUS ConsoleEfiGraphicalOpenProtocol	(	_In_ PBL_GRAPHICS_CONSOLE	GraphicsConsole,
		_In_ BL_GRAPHICS_CONSOLE_TYPE	Type
	)

Definition at line 34 of file guicons.c.

{
    ULONG HandleIndex, HandleCount;
    EFI_HANDLE* HandleArray;
    EFI_HANDLE Handle;
    NTSTATUS Status;
    PVOID Interface;
 
    /* Find a device handle that implements either GOP or UGA */
    HandleCount = 0;
    HandleArray = NULL;
    Status = EfiLocateHandleBuffer(ByProtocol,
                                   (Type == BlGopConsole) ?
                                   &EfiGraphicsOutputProtocol :
                                   &EfiUgaDrawProtocol,
                                   &HandleCount,
                                   &HandleArray);
    if (!NT_SUCCESS(Status))
    {
        /* Nothing supports this (no video card?) */
        EfiPrintf(L"Status: %lx Count: %d\r\n", Status, HandleCount);
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Scan through the handles we received */
    for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++)
    {
        /* Try to open each one */
        GraphicsConsole->Handle = HandleArray[HandleIndex];
        Handle = HandleArray[HandleIndex];
        Status = EfiOpenProtocol(Handle, &EfiDevicePathProtocol, &Interface);
        if (NT_SUCCESS(Status))
        {
            /* Test worked, close the protocol */
            EfiCloseProtocol(Handle, &EfiDevicePathProtocol);
 
            /* Now open the real protocol we want, either UGA or GOP */
            Status = Type ? ConsoleEfiUgaOpen(GraphicsConsole) :
                            ConsoleEfiGopOpen(GraphicsConsole);
            if (NT_SUCCESS(Status))
            {
                /* It worked -- store the type of console this is */
                GraphicsConsole->Type = Type;
                return STATUS_SUCCESS;
            }
        }
    }
 
    /* We failed to find a working GOP/UGA protocol provider */
    return STATUS_UNSUCCESSFUL;
}

Referenced by ConsoleGraphicalConstruct().

◆ ConsoleEfiUgaClose()

VOID ConsoleEfiUgaClose ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 27 of file uga.c.

{
    return;
}

Referenced by ConsoleFirmwareGraphicalClose().

◆ ConsoleEfiUgaOpen()

NTSTATUS ConsoleEfiUgaOpen ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 18 of file uga.c.

{
    EfiPrintf(L"UGA not implemented\r\n");
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by ConsoleEfiGraphicalOpenProtocol().

◆ ConsoleEfiUgaSetResolution()

NTSTATUS ConsoleEfiUgaSetResolution	(	_In_ PBL_GRAPHICS_CONSOLE	GraphicsConsole,
		_In_ PBL_DISPLAY_MODE	DisplayMode,
		_In_ ULONG	DisplayModeCount
	)

Definition at line 35 of file uga.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by ConsoleFirmwareGraphicalEnable().

◆ ConsoleFirmwareGraphicalClear()

NTSTATUS ConsoleFirmwareGraphicalClear	(	_In_ PBL_GRAPHICS_CONSOLE	Console,
		_In_ ULONG	Color
	)

Definition at line 90 of file guicons.c.

{
    NTSTATUS Status;
    UCHAR Pixel[4] = { 0 };
 
    /* Convert the standard color to a firmware pixel color */
    Status = ConsolepConvertColorToPixel(Color, Pixel);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Check if this is GOP or UGA */
    if (Console->Type == BlUgaConsole)
    {
        EfiPrintf(L"Uga not supported\r\n");
        Status = STATUS_NOT_IMPLEMENTED;
    }
    else
    {
        /* For GOP, just fill the screen */
        ConsolepClearBuffer(Console->FrameBuffer,
                            Console->DisplayMode.HRes,
                            Pixel,
                            Console->DisplayMode.VRes,
                            Console->PixelsPerScanLine,
                            Console->PixelDepth);
        Status = STATUS_SUCCESS;
    }
 
    /* All clear */
    return Status;
}

Referenced by ConsoleGraphicalClearPixels().

◆ ConsoleFirmwareGraphicalClose()

VOID ConsoleFirmwareGraphicalClose ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 18 of file guicons.c.

{
    /* Call the correct close routine based on the console mode */
    if (GraphicsConsole->Type == BlUgaConsole)
    {
        ConsoleEfiUgaClose(GraphicsConsole);
    }
    else
    {
        ConsoleEfiGopClose(GraphicsConsole);
    }
}

Referenced by ConsoleGraphicalConstruct(), and ConsoleGraphicalDestruct().

◆ ConsoleFirmwareGraphicalDisable()

VOID ConsoleFirmwareGraphicalDisable ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 153 of file guicons.c.

{
    /* Is this a GOP console? */
    if (GraphicsConsole->Type == BlGopConsole)
    {
        /* Did we map a framebuffer? */
        if (GraphicsConsole->FrameBuffer)
        {
            /* Unmap it */
            BlMmUnmapVirtualAddressEx(GraphicsConsole->FrameBuffer,
                                      GraphicsConsole->FrameBufferSize);
        }
    }
}

Referenced by ConsoleGraphicalDestruct(), ConsoleGraphicalEnable(), and ConsoleGraphicalReinitialize().

◆ ConsoleFirmwareGraphicalEnable()

NTSTATUS ConsoleFirmwareGraphicalEnable ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 128 of file guicons.c.

{
    NTSTATUS Status;
 
    /* Check what type of console this is */
    if (GraphicsConsole->Type == BlUgaConsole)
    {
        /* Handle UGA */
        Status = ConsoleEfiUgaSetResolution(GraphicsConsole,
                                            &GraphicsConsole->DisplayMode,
                                            1);
    }
    else
    {
        /* Handle GOP */
        Status = ConsoleEfiGopEnable(GraphicsConsole);
    }
 
    /* Return back to caller */
    return Status;
}

Referenced by ConsoleGraphicalConstruct(), ConsoleGraphicalEnable(), and ConsoleGraphicalReinitialize().

◆ ConsoleFirmwareTextClear()

NTSTATUS ConsoleFirmwareTextClear	(	_In_ PBL_TEXT_CONSOLE	Console,
		_In_ BOOLEAN	LineOnly
	)

Definition at line 557 of file textcons.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
    NTSTATUS Status;
    ULONG i, Column, Row, TextWidth, TextHeight;
 
    /* Get the text resolution */
    BlDisplayGetTextCellResolution(&TextWidth, &TextHeight);
 
    /* Are we just clearing a line? */
    if (LineOnly)
    {
        /* Get the current column and row */
        Column = Console->State.XPos / TextWidth;
        Row = Console->State.YPos / TextHeight;
 
        /* Loop over every remaining character */
        for (i = 0; i < Console->DisplayMode.HRes - Column - 1; i++)
        {
            /* Write a space on top of it */
            Status = EfiConOutOutputString(Console->Protocol, L" ");
            if (!NT_SUCCESS(Status))
            {
                break;
            }
        }
 
        /* And reset the cursor back at the initial position */
        Status = EfiConOutSetCursorPosition(Console->Protocol,
                                            Column,
                                            Row);
    }
    else
    {
        /* Are we in protected mode? */
        OldMode = CurrentExecutionContext->Mode;
        if (OldMode != BlRealMode)
        {
            /* FIXME: Not yet implemented */
            return STATUS_NOT_IMPLEMENTED;
        }
 
        /* Clear the screen */
        EfiStatus = Console->Protocol->ClearScreen(Console->Protocol);
 
        /* Switch back to protected mode if we came from there */
        if (OldMode != BlRealMode)
        {
            BlpArchSwitchContext(OldMode);
        }
 
        /* Conver to NT status -- did that work? */
        Status = EfiGetNtStatusCode(EfiStatus);
        if (NT_SUCCESS(Status))
        {
            /* Reset current positions */
            Console->State.XPos = 0;
            Console->State.YPos = 0;
        }
    }
 
    /* All done */
    return Status;
}

Referenced by ConsoleGraphicalClearText(), and ConsoleTextLocalClearText().

◆ ConsoleFirmwareTextClose()

VOID ConsoleFirmwareTextClose ( _In_ PBL_TEXT_CONSOLE TextConsole )

Definition at line 398 of file textcons.c.

{
    ULONG Mode;
    BL_DISPLAY_STATE DisplayState;
 
    /* Read the original mode, and see if it's different than the one now */
    Mode = TextConsole->OldMode.Mode;
    if (Mode != TextConsole->Mode)
    {
        /* Restore to the original mode */
        EfiConOutSetMode(TextConsole->Protocol, Mode);
    }
 
    /* Read the EFI settings for the original mode */
    ConsoleEfiTextGetStateFromMode(&TextConsole->OldMode, &DisplayState);
 
    /* Set the original settings */
    ConsoleFirmwareTextSetState(TextConsole, 0xF, &DisplayState);
}

Referenced by ConsoleGraphicalEnable(), and ConsoleTextLocalConstruct().

◆ ConsoleFirmwareTextOpen()

NTSTATUS ConsoleFirmwareTextOpen ( _In_ PBL_TEXT_CONSOLE TextConsole )

Definition at line 421 of file textcons.c.

{
    BL_DISPLAY_MODE DisplayMode;
    EFI_SIMPLE_TEXT_OUTPUT_MODE CurrentMode, NewMode;
    UINTN HRes, VRes;
    ULONG Mode;
    NTSTATUS Status;
 
    /* Read the current mode and its settings */
    EfiConOutReadCurrentMode(EfiConOut, &CurrentMode);
    Status = EfiConOutQueryMode(EfiConOut, CurrentMode.Mode, &HRes, &VRes);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Save the current mode and its settings */
    NewMode = CurrentMode;
    DisplayMode.VRes = VRes;
    DisplayMode.HRes = HRes;
    DisplayMode.HRes2 = HRes;
 
    /* Check if the current mode is compatible with one of our modes */
    if (!ConsolepFindResolution(&DisplayMode, ConsoleTextResolutionList, 1))
    {
        /* It isn't -- find a matching EFI mode for what we need */
        EfiPrintf(L"In incorrect mode, scanning for right one\r\n");
        Status = ConsoleEfiTextFindModeFromAllowed(EfiConOut,
                                                   ConsoleTextResolutionList,
                                                   1,
                                                   &Mode);
        if (!NT_SUCCESS(Status))
        {
            EfiPrintf(L"Failed to find mode: %lx\r\n", Status);
            return Status;
        }
 
        /* Set the new EFI mode */
        EfiPrintf(L"Setting new mode: %d\r\n", Mode);
        Status = EfiConOutSetMode(EfiConOut, Mode);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
 
        /* Read the current mode and its settings */
        EfiConOutReadCurrentMode(EfiConOut, &NewMode);
        Status = EfiConOutQueryMode(EfiConOut, Mode, &HRes, &VRes);
        if (!NT_SUCCESS(Status))
        {
            EfiConOutSetMode(EfiConOut, CurrentMode.Mode);
            return Status;
        }
 
        /* Save the current mode and its settings */
        DisplayMode.HRes = HRes;
        DisplayMode.VRes = VRes;
        DisplayMode.HRes2 = HRes;
    }
 
    /* Capture all the current settings */
    ConsoleEfiTextGetStateFromMode(&NewMode, &TextConsole->State);
    TextConsole->Mode = NewMode.Mode;
    TextConsole->DisplayMode = DisplayMode;
    TextConsole->Protocol = EfiConOut;
    TextConsole->OldMode = CurrentMode;
    return STATUS_SUCCESS;
}

Referenced by ConsoleGraphicalEnable(), and ConsoleTextLocalConstruct().

◆ ConsoleFirmwareTextSetState()

NTSTATUS ConsoleFirmwareTextSetState	(	_In_ PBL_TEXT_CONSOLE	TextConsole,
		_In_ UCHAR	Mask,
		_In_ PBL_DISPLAY_STATE	State
	)

Definition at line 198 of file textcons.c.

{
    NTSTATUS Status;
    ULONG FgColor, BgColor, Attribute, XPos, YPos, TextHeight, TextWidth;
    BOOLEAN Visible;
 
    /* Check if foreground state is being set */
    if (Mask & 1)
    {
        /* Check if there's a difference from current */
        FgColor = State->FgColor;
        if (TextConsole->State.FgColor != FgColor)
        {
            /* Ignore invalid color */
            if (FgColor > White)
            {
                return STATUS_INVALID_PARAMETER;
            }
 
            /* Convert from NT/CGA format to EFI, and then set the attribute */
            Attribute = ConsoleEfiTextGetAttribute(TextConsole->State.BgColor,
                                                   FgColor);
            Status = EfiConOutSetAttribute(TextConsole->Protocol, Attribute);
            if (!NT_SUCCESS(Status))
            {
                return Status;
            }
 
            /* Update cached state */
            TextConsole->State.FgColor = FgColor;
        }
    }
 
    /* Check if background state is being set */
    if (Mask & 2)
    {
        /* Check if there's a difference from current */
        BgColor = State->BgColor;
        if (TextConsole->State.BgColor != BgColor)
        {
            /* Ignore invalid color */
            if (BgColor > White)
            {
                return STATUS_INVALID_PARAMETER;
            }
 
            /* Convert from NT/CGA format to EFI, and then set the attribute */
            Attribute = ConsoleEfiTextGetAttribute(BgColor,
                                                   TextConsole->State.FgColor);
            Status = EfiConOutSetAttribute(TextConsole->Protocol, Attribute);
 
            if (!NT_SUCCESS(Status))
            {
                return Status;
            }
 
            /* Update cached state */
            TextConsole->State.BgColor = BgColor;
        }
    }
 
    /* Check if position state is being set */
    if (Mask & 4)
    {
        /* Check if there's a difference from current */
        XPos = State->XPos;
        YPos = State->YPos;
        if ((TextConsole->State.XPos != XPos) ||
            (TextConsole->State.YPos != YPos))
        {
            /* Set the new cursor position */
            BlDisplayGetTextCellResolution(&TextWidth, &TextHeight);
            Status = EfiConOutSetCursorPosition(TextConsole->Protocol,
                                                XPos/ TextWidth,
                                                YPos / TextHeight);
            if (!NT_SUCCESS(Status))
            {
                return Status;
            }
 
            /* Update cached state */
            TextConsole->State.XPos = XPos;
            TextConsole->State.YPos = YPos;
        }
    }
 
    /* Check if cursor state is being set */
    if (Mask & 8)
    {
        /* Check if there's a difference from current */
        Visible = State->CursorVisible;
        if (TextConsole->State.CursorVisible != Visible)
        {
            /* Ignore invalid state */
            if (Visible >= 3)
            {
                return STATUS_INVALID_PARAMETER;
            }
 
            /* Set the new cursor state */
            Status = EfiConOutEnableCursor(TextConsole->Protocol, Visible);
            if (!NT_SUCCESS(Status))
            {
                return Status;
            }
 
            /* Update cached status */
            TextConsole->State.CursorVisible = Visible;
        }
    }
 
    /* Return success */
    return STATUS_SUCCESS;
}

Referenced by ConsoleFirmwareTextClose(), ConsoleGraphicalSetTextState(), ConsoleTextLocalConstruct(), and ConsoleTextLocalSetTextState().

◆ ConsoleGraphicalClearPixels()

NTSTATUS ConsoleGraphicalClearPixels	(	_In_ PBL_GRAPHICS_CONSOLE	Console,
		_In_ ULONG	Color
	)

Definition at line 275 of file guicons.c.

{
    NTSTATUS Status;
 
    /* Check if the text console is active */
    if (Console->TextConsole.Active)
    {
        /* We shouldn't be here */
        Status = STATUS_UNSUCCESSFUL;
    }
    else
    {
        /* Clear it in graphics mode */
        Status = ConsoleFirmwareGraphicalClear(Console, Color);
    }
 
    /* All good */
    return Status;
}

Referenced by BfClearScreen().

◆ ConsoleGraphicalClearText()

NTSTATUS ConsoleGraphicalClearText	(	_In_ PBL_GRAPHICS_CONSOLE	Console,
		_In_ BOOLEAN	LineOnly
	)

Definition at line 299 of file guicons.c.

{
    /* Is the text console active? */
    if (Console->TextConsole.Active)
    {
        /* Let firmware clear do it */
        return ConsoleFirmwareTextClear(&Console->TextConsole, LineOnly);
    }
 
    /* Are we clearing a line only? */
    if (LineOnly)
    {
        return BfClearToEndOfLine(Console);
    }
 
    /* Nope -- the whole screen */
    return BfClearScreen(Console);
}

◆ ConsoleGraphicalConstruct()

NTSTATUS ConsoleGraphicalConstruct ( _In_ PBL_GRAPHICS_CONSOLE GraphicsConsole )

Definition at line 58 of file guicons.c.

{
    NTSTATUS Status;
 
    /* Create a text console */
    Status = ConsoleTextLocalConstruct(&GraphicsConsole->TextConsole, FALSE);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Text failed: %lx\r\n", Status);
        return Status;
    }
 
    /* But overwrite its callbacks with ours */
    GraphicsConsole->TextConsole.Callbacks = &ConsoleGraphicalVtbl.Text;
 
    /* Try to create a GOP console */
    Status = ConsoleEfiGraphicalOpenProtocol(GraphicsConsole, BlGopConsole);
    if (!NT_SUCCESS(Status))
    {
        /* That failed, try an older EFI 1.02 UGA console */
        EfiPrintf(L"GOP open failed!\r\n", Status);
        Status = ConsoleEfiGraphicalOpenProtocol(GraphicsConsole, BlUgaConsole);
        if (!NT_SUCCESS(Status))
        {
            /* That failed too, give up */
            EfiPrintf(L"UGA failed!\r\n", Status);
            ConsoleTextLocalDestruct(&GraphicsConsole->TextConsole);
            return STATUS_UNSUCCESSFUL;
        }
    }
 
    /* Enable the console */
    Status = ConsoleFirmwareGraphicalEnable(GraphicsConsole);
    if (!NT_SUCCESS(Status))
    {
        /* Failed to enable it, undo everything */
        EfiPrintf(L"Enable failed\r\n");
        ConsoleFirmwareGraphicalClose(GraphicsConsole);
        ConsoleTextLocalDestruct(&GraphicsConsole->TextConsole);
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Save the graphics text color from the text mode text color */
    GraphicsConsole->FgColor = GraphicsConsole->TextConsole.State.FgColor;
    GraphicsConsole->BgColor = GraphicsConsole->TextConsole.State.BgColor;
    return STATUS_SUCCESS;
}

Referenced by DsppInitialize().

◆ ConsoleGraphicalDestruct()

VOID ConsoleGraphicalDestruct ( _In_ struct _BL_GRAPHICS_CONSOLE * Console )

◆ ConsoleGraphicalEnable()

NTSTATUS ConsoleGraphicalEnable	(	_In_ struct _BL_GRAPHICS_CONSOLE *	Console,
		_In_ BOOLEAN	Enable
	)

◆ ConsoleGraphicalGetGraphicalResolution()

NTSTATUS ConsoleGraphicalGetGraphicalResolution	(	_In_ struct _BL_GRAPHICS_CONSOLE *	Console,
		_In_ PBL_DISPLAY_MODE	DisplayMode
	)

◆ ConsoleGraphicalGetOriginalResolution()

NTSTATUS ConsoleGraphicalGetOriginalResolution	(	_In_ struct _BL_GRAPHICS_CONSOLE *	Console,
		_In_ PBL_DISPLAY_MODE	DisplayMode
	)

◆ ConsoleGraphicalIsEnabled()

BOOLEAN ConsoleGraphicalIsEnabled ( _In_ struct _BL_GRAPHICS_CONSOLE * Console )

◆ ConsoleGraphicalReinitialize()

NTSTATUS ConsoleGraphicalReinitialize ( _In_ struct _BL_GRAPHICS_CONSOLE * Console )

◆ ConsoleGraphicalSetTextState()

NTSTATUS ConsoleGraphicalSetTextState	(	_In_ PBL_GRAPHICS_CONSOLE	Console,
		_In_ ULONG	Mask,
		_In_ PBL_DISPLAY_STATE	TextState
	)

Definition at line 37 of file guicons.c.

{
    /* Is the text console active? */
    if (Console->TextConsole.Active)
    {
        /* Let it handle that */
        return ConsoleFirmwareTextSetState(&Console->TextConsole,
                                           Mask,
                                           TextState);
    }
 
    /* Not yet */
    EfiPrintf(L"FFX set not implemented\r\n");
    return STATUS_NOT_IMPLEMENTED;
}

◆ ConsoleInputBaseReinitialize()

NTSTATUS ConsoleInputBaseReinitialize ( _In_ struct _BL_INPUT_CONSOLE * Console )

◆ ConsoleInputLocalDestruct()

VOID ConsoleInputLocalDestruct ( _In_ struct _BL_INPUT_CONSOLE * Console )

◆ ConsoleInputLocalEraseBuffer()

NTSTATUS ConsoleInputLocalEraseBuffer	(	_In_ PBL_INPUT_CONSOLE	Console,
		_In_opt_ PULONG	ValueToFill
	)

Definition at line 527 of file textcons.c.

{
    NTSTATUS Status, EfiStatus;
 
    /* Erase the software buffer */
    Status = ConsoleInputBaseEraseBuffer(Console, FillValue);
 
    /* Reset the hardware console */
    EfiStatus = EfiConInEx ? EfiConInExReset() : EfiConInReset();
    if (!NT_SUCCESS(EfiStatus))
    {
        /* Normalize the failure code */
        EfiStatus = STATUS_UNSUCCESSFUL;
    }
 
    /* Check if software reset worked */
    if (NT_SUCCESS(Status))
    {
        /* Then return the firmware code */
        Status = EfiStatus;
    }
 
    /* All done */
    return Status;
}

Referenced by ConsoleInputLocalDestruct().

◆ ConsolepClearBuffer()

VOID ConsolepClearBuffer	(	_In_ PUCHAR	FrameBuffer,
		_In_ ULONG	Width,
		_In_ PUCHAR	FillColor,
		_In_ ULONG	Height,
		_In_ ULONG	ScanlineWidth,
		_In_ ULONG	PixelDepth
	)

Definition at line 109 of file guicons.c.

{
    PUCHAR Scanline, Current, FrameBufferEnd, LineEnd;
    ULONG LineBytes, WidthBytes, BytesPerPixel;
 
    /* Get the BPP */
    BytesPerPixel = PixelDepth / 8;
 
    /* Using that, calculate the size of a scan line */
    LineBytes = ScanlineWidth * BytesPerPixel;
 
    /* And the size of line we'll have to clear */
    WidthBytes = Width * BytesPerPixel;
 
    /* Allocate a scanline */
    Scanline = BlMmAllocateHeap(WidthBytes);
    if (Scanline)
    {
        /* For each remaining pixel on the scanline */
        Current = Scanline;
        while (Width--)
        {
            /* Copy in the fill color */
            RtlCopyMemory(Current, FillColor, BytesPerPixel);
            Current += BytesPerPixel;
        }
 
        /* For each scanline in the frame buffer */
        while (Height--)
        {
            /* Copy our constructed scanline */
            RtlCopyMemory(FrameBuffer, Scanline, WidthBytes);
            FrameBuffer += LineBytes;
        }
    }
    else
    {
        FrameBufferEnd = FrameBuffer + Height * LineBytes;
        ScanlineWidth = BytesPerPixel * (ScanlineWidth - Width);
        while (FrameBuffer != FrameBufferEnd)
        {
            if (FrameBuffer != (FrameBuffer + WidthBytes))
            {
                LineEnd = FrameBuffer + WidthBytes;
                do
                {
                    RtlCopyMemory(FrameBuffer, FillColor, BytesPerPixel);
                    FrameBuffer += BytesPerPixel;
                }
                while (FrameBuffer != LineEnd);
            }
 
            FrameBuffer += ScanlineWidth;
        }
    }
}

Referenced by ConsoleFirmwareGraphicalClear().

◆ ConsolepConvertColorToPixel()

NTSTATUS ConsolepConvertColorToPixel	(	_In_ BL_COLOR	Color,
		_Out_ PUCHAR	Pixel
	)

Definition at line 174 of file guicons.c.

{
    NTSTATUS Status;
 
    /* Assume success */
    Status = STATUS_SUCCESS;
 
    /* Convert the color to a pixel value */
    switch (Color)
    {
    case Black:
        Pixel[1] = 0;
        Pixel[2] = 0;
        Pixel[0] = 0;
        break;
    case Blue:
        Pixel[1] = 0;
        Pixel[2] = 0;
        Pixel[0] = 0x7F;
        break;
    case Green:
        Pixel[1] = 0x7F;
        Pixel[2] = 0;
        Pixel[0] = 0;
        break;
    case Cyan:
        Pixel[1] = 0x7F;
        Pixel[2] = 0;
        Pixel[0] = 0x7F;
        break;
    case Red:
        Pixel[1] = 0;
        Pixel[2] = 0x7F;
        Pixel[0] = 0x7F;
        break;
    case Magenta:
        Pixel[1] = 0;
        Pixel[2] = 0x7F;
        Pixel[0] = 0x7F;
        break;
    case Brown:
        Pixel[1] = 0x3F;
        Pixel[2] = 0x7F;
        Pixel[0] = 0;
        break;
    case LtGray:
        Pixel[1] = 0xBFu;
        Pixel[2] = 0xBFu;
        *Pixel = 0xBFu;
        break;
    case Gray:
        Pixel[1] = 0x7F;
        Pixel[2] = 0x7F;
        Pixel[0] = 0x7F;
        break;
    case LtBlue:
        Pixel[1] = 0;
        Pixel[2] = 0;
        Pixel[0] = 0xFF;
        break;
    case LtGreen:
        Pixel[1] = 0xFF;
        Pixel[2] = 0;
        Pixel[0] = 0;
        break;
    case LtCyan:
        Pixel[1] = 0xFF;
        Pixel[2] = 0;
        Pixel[0] = 0xFF;
        break;
    case LtRed:
        Pixel[1] = 0;
        Pixel[2] = 0xFF;
        Pixel[0] = 0;
        break;
    case LtMagenta:
        Pixel[1] = 0;
        Pixel[2] = 0xFF;
        Pixel[0] = 0xFF;
        break;
    case Yellow:
        Pixel[1] = 0xFF;
        Pixel[2] = 0xFF;
        Pixel[0] = 0;
        break;
    case White:
        Pixel[1] = 0xFF;
        Pixel[2] = 0xFF;
        Pixel[0] = 0xFF;
        break;
    default:
        Status = STATUS_INVALID_PARAMETER;
        break;
    }
    return Status;
}

Referenced by ConsoleFirmwareGraphicalClear().

◆ ConsolepFindResolution()

BOOLEAN ConsolepFindResolution	(	_In_ PBL_DISPLAY_MODE	Mode,
		_In_ PBL_DISPLAY_MODE	List,
		_In_ ULONG	MaxIndex
	)

Definition at line 159 of file textcons.c.

{
    PBL_DISPLAY_MODE ListEnd;
 
    /* Loop until we hit the maximum supported list index */
    ListEnd = &List[MaxIndex];
    while (List != ListEnd)
    {
        /* Does this resolution match? */
        if ((Mode->HRes == List->HRes) && (Mode->VRes == List->VRes))
        {
            /* Yep -- we got a match */
            return TRUE;
 
        }
 
        /* Try another one*/
        List++;
    }
 
    /* No matches were found */
    return FALSE;
}

Referenced by ConsoleFirmwareTextOpen().

◆ ConsoleTextBaseGetTextResolution()

NTSTATUS ConsoleTextBaseGetTextResolution	(	_In_ struct _BL_TEXT_CONSOLE *	Console,
		_Out_ PULONG	TextResolution
	)

Definition at line 66 of file textcons.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ ConsoleTextBaseGetTextState()

NTSTATUS ConsoleTextBaseGetTextState	(	_In_ struct _BL_TEXT_CONSOLE *	Console,
		_Out_ PBL_DISPLAY_STATE	TextState
	)

Definition at line 47 of file textcons.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ ConsoleTextLocalClearText()

NTSTATUS ConsoleTextLocalClearText	(	_In_ struct _BL_TEXT_CONSOLE *	Console,
		_In_ BOOLEAN	LineOnly
	)

Definition at line 85 of file textcons.c.

{
    return ConsoleFirmwareTextClear(Console, LineOnly);
}

◆ ConsoleTextLocalConstruct()

NTSTATUS ConsoleTextLocalConstruct	(	_In_ PBL_TEXT_CONSOLE	TextConsole,
		_In_ BOOLEAN	Activate
	)

Definition at line 104 of file textcons.c.

{
    NTSTATUS Status;
    BL_DISPLAY_STATE TextState;
 
    /* Set our callbacks */
    TextConsole->Callbacks = &ConsoleTextLocalVtbl;
 
    /* Are we activating this console? */
    if (Activate)
    {
        /* Call firmware to activate it */
        Status = ConsoleFirmwareTextOpen(TextConsole);
        if (!NT_SUCCESS(Status))
        {
            EfiPrintf(L"Failed to activate console: %lx\r\n", Status);
            return Status;
        }
    }
 
    /* Set default text state */
    TextState.BgColor = 0;
    TextState.XPos = 0;
    TextState.YPos = 0;
    TextState.CursorVisible = FALSE;
    TextState.FgColor = White;
 
    /* Are we activating? */
    if (Activate)
    {
        /* Call firmware to set it */
        Status = ConsoleFirmwareTextSetState(TextConsole, 0xF, &TextState);
        if (!NT_SUCCESS(Status))
        {
            /* We failed, back down */
            EfiPrintf(L"Failed to set console state: %lx\r\n", Status);
            ConsoleFirmwareTextClose(TextConsole);
            return Status;
        }
    }
    else
    {
        /* Just save the state for now, someone else can activate later */
        TextConsole->State = TextState;
    }
 
    /* Remember if we activated it */
    TextConsole->Active = Activate;
    return STATUS_SUCCESS;
}

Referenced by ConsoleGraphicalConstruct(), and DsppInitialize().

◆ ConsoleTextLocalDestruct()

VOID ConsoleTextLocalDestruct ( _In_ struct _BL_TEXT_CONSOLE * Console )

Definition at line 30 of file textcons.c.

{
 
}

Referenced by ConsoleGraphicalConstruct(), and ConsoleGraphicalDestruct().

◆ ConsoleTextLocalReinitialize()

NTSTATUS ConsoleTextLocalReinitialize ( _In_ struct _BL_TEXT_CONSOLE * Console )

Definition at line 38 of file textcons.c.

{
    EfiPrintf(L"Not active yet!\r\n");
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by ConsoleGraphicalReinitialize().

◆ ConsoleTextLocalSetTextResolution()

NTSTATUS ConsoleTextLocalSetTextResolution	(	_In_ struct _BL_TEXT_CONSOLE *	Console,
		_In_ ULONG	NewTextResolution,
		_Out_ PULONG	OldTextResolution
	)

Definition at line 75 of file textcons.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ ConsoleTextLocalSetTextState()

NTSTATUS ConsoleTextLocalSetTextState	(	_In_ struct _BL_TEXT_CONSOLE *	Console,
		_In_ ULONG	Flags,
		_In_ PBL_DISPLAY_STATE	TextState
	)

Definition at line 56 of file textcons.c.

{
    return ConsoleFirmwareTextSetState(Console, Mask, TextState);
}

◆ ConsoleTextLocalWriteText()

NTSTATUS ConsoleTextLocalWriteText	(	_In_ struct _BL_TEXT_CONSOLE *	Console,
		_In_ PCHAR	Text,
		_In_ ULONG	Attribute
	)

Definition at line 94 of file textcons.c.

{
    return STATUS_NOT_IMPLEMENTED;
}

◆ DEFINE_GUID()

DEFINE_GUID	(	BadMemoryGuid	,
		0x54B8275B	,
		0xD431	,
		0x473F	,
		0xAC	,
		0xFB	,
		0xE5	,
		0x36	,
		0xA0	,
		0x84	,
		0x94	,
		0xA3
	)

◆ EfiAllocatePages()

NTSTATUS EfiAllocatePages	(	_In_ ULONG	Type,
		_In_ ULONG	Pages,
		_Inout_ EFI_PHYSICAL_ADDRESS *	Memory
	)

Definition at line 1568 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
    PHYSICAL_ADDRESS MemoryPhysical;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* Translate output address */
        BlMmTranslateVirtualAddress(Memory, &MemoryPhysical);
        Memory = (EFI_PHYSICAL_ADDRESS*)PhysicalAddressToPtr(MemoryPhysical);
 
        /* Switch to real mode */
        BlpArchSwitchContext(BlRealMode);
    }
 
    /* Make the EFI call */
    EfiStatus = EfiBS->AllocatePages(Type, EfiLoaderData, Pages, Memory);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by MmFwGetMemoryMap(), and MmPapAllocateRegionFromMdl().

◆ EfiCloseProtocol()

NTSTATUS EfiCloseProtocol	(	_In_ EFI_HANDLE	Handle,
		_In_ EFI_GUID *	Protocol
	)

Definition at line 581 of file firmware.c.

{
    EFI_STATUS EfiStatus;
    NTSTATUS Status;
    BL_ARCH_MODE OldMode;
 
    /* Are we using virtual memory/ */
    if (MmTranslationType != BlNone)
    {
        /* We need complex tracking to make this work */
        Status = EfiVmCloseProtocol(Handle, Protocol);
    }
    else
    {
        /* Are we on legacy 1.02? */
        if (EfiST->FirmwareRevision == EFI_1_02_SYSTEM_TABLE_REVISION)
        {
            /* Nothing to close */
            EfiStatus = EFI_SUCCESS;
        }
        else
        {
            /* Are we in protected mode? */
            OldMode = CurrentExecutionContext->Mode;
            if (OldMode != BlRealMode)
            {
                /* Switch to real mode */
                BlpArchSwitchContext(BlRealMode);
            }
 
            /* Use the UEFI version */
            EfiStatus = EfiBS->CloseProtocol(Handle, Protocol, EfiImageHandle, NULL);
 
            /* Switch back to protected mode if we came from there */
            if (OldMode != BlRealMode)
            {
                BlpArchSwitchContext(OldMode);
            }
 
            /* Normalize not found as success */
            if (EfiStatus == EFI_NOT_FOUND)
            {
                EfiStatus = EFI_SUCCESS;
            }
        }
 
        /* Convert the error to an NTSTATUS */
        Status = EfiGetNtStatusCode(EfiStatus);
    }
 
    /* All done */
    return Status;
}

Referenced by BlockIoEfiGetChildHandle(), BlockIoEfiGetDeviceInformation(), BlockIoFirmwareRead(), ConsoleEfiGopClose(), ConsoleEfiGopOpen(), ConsoleEfiGraphicalOpenProtocol(), and DiskClose().

◆ EfiConInExReset()

NTSTATUS EfiConInExReset ( VOID )

Definition at line 825 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"conreset vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    EfiStatus = EfiConInEx->Reset(EfiConInEx, FALSE);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by ConsoleInputLocalEraseBuffer().

◆ EfiConInReset()

NTSTATUS EfiConInReset ( VOID )

Definition at line 794 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"coninreset vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    EfiStatus = EfiConIn->Reset(EfiConIn, FALSE);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by ConsoleInputLocalEraseBuffer().

◆ EfiConOutEnableCursor()

NTSTATUS EfiConOutEnableCursor	(	_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *	TextInterface,
		_In_ BOOLEAN	Visible
	)

Definition at line 1163 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"enablecurso vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    EfiStatus = TextInterface->EnableCursor(TextInterface, Visible);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by ConsoleFirmwareTextSetState().

◆ EfiConOutOutputString()

NTSTATUS EfiConOutOutputString	(	_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *	TextInterface,
		_In_ PWCHAR	String
	)

Definition at line 1195 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"output string vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    EfiStatus = TextInterface->OutputString(TextInterface, String);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by ConsoleFirmwareTextClear().

◆ EfiConOutQueryMode()

NTSTATUS EfiConOutQueryMode	(	_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *	TextInterface,
		_In_ ULONG	Mode,
		_In_ UINTN *	Columns,
		_In_ UINTN *	Rows
	)

Definition at line 1032 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"conqmode vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    EfiStatus = TextInterface->QueryMode(TextInterface, Mode, Columns, Rows);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by ConsoleEfiTextFindModeFromAllowed(), and ConsoleFirmwareTextOpen().

◆ EfiConOutReadCurrentMode()

VOID EfiConOutReadCurrentMode	(	_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *	TextInterface,
		_Out_ EFI_SIMPLE_TEXT_OUTPUT_MODE *	Mode
	)

Definition at line 1227 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"readmode vm path\r\n");
        EfiStall(10000000);
        return;
    }
 
    /* Make the EFI call */
    RtlCopyMemory(Mode, TextInterface->Mode, sizeof(*Mode));
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
}

Referenced by ConsoleEfiTextFindModeFromAllowed(), and ConsoleFirmwareTextOpen().

◆ EfiConOutSetAttribute()

NTSTATUS EfiConOutSetAttribute	(	_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *	TextInterface,
		_In_ ULONG	Attribute
	)

Definition at line 1098 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"sattr vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    EfiStatus = TextInterface->SetAttribute(TextInterface, Attribute);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by ConsoleFirmwareTextSetState().

◆ EfiConOutSetCursorPosition()

NTSTATUS EfiConOutSetCursorPosition	(	_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *	TextInterface,
		_In_ ULONG	Column,
		_In_ ULONG	Row
	)

Definition at line 1130 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"setcursor vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    EfiStatus = TextInterface->SetCursorPosition(TextInterface, Column, Row);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by ConsoleFirmwareTextClear(), and ConsoleFirmwareTextSetState().

◆ EfiConOutSetMode()

NTSTATUS EfiConOutSetMode	(	_In_ SIMPLE_TEXT_OUTPUT_INTERFACE *	TextInterface,
		_In_ ULONG	Mode
	)

Definition at line 1066 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"setmode vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    EfiStatus = TextInterface->SetMode(TextInterface, Mode);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by ConsoleFirmwareTextClose(), and ConsoleFirmwareTextOpen().

◆ EfiFreePages()

NTSTATUS EfiFreePages	(	_In_ ULONG	Pages,
		_In_ EFI_PHYSICAL_ADDRESS	PhysicalAddress
	)

Definition at line 973 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* Switch to real mode */
        BlpArchSwitchContext(BlRealMode);
    }
 
    /* Make the EFI call */
    EfiStatus = EfiBS->FreePages(PhysicalAddress, Pages);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by MmFwFreePages(), and MmFwGetMemoryMap().

◆ EfiGetEfiStatusCode()

EFI_STATUS EfiGetEfiStatusCode ( _In_ NTSTATUS Status )

Definition at line 2474 of file firmware.c.

{
    switch (Status)
    {
        case STATUS_NOT_SUPPORTED:
            return EFI_UNSUPPORTED;
        case STATUS_DISK_FULL:
            return EFI_VOLUME_FULL;
        case STATUS_INSUFFICIENT_RESOURCES:
            return EFI_OUT_OF_RESOURCES;
        case STATUS_MEDIA_WRITE_PROTECTED:
            return EFI_WRITE_PROTECTED;
        case STATUS_DEVICE_NOT_READY:
            return EFI_NOT_STARTED;
        case STATUS_DEVICE_ALREADY_ATTACHED:
            return EFI_ALREADY_STARTED;
        case STATUS_MEDIA_CHANGED:
            return EFI_MEDIA_CHANGED;
        case STATUS_INVALID_PARAMETER:
            return EFI_INVALID_PARAMETER;
        case STATUS_ACCESS_DENIED:
            return EFI_ACCESS_DENIED;
        case STATUS_BUFFER_TOO_SMALL:
            return EFI_BUFFER_TOO_SMALL;
        case STATUS_DISK_CORRUPT_ERROR:
            return EFI_VOLUME_CORRUPTED;
        case STATUS_REQUEST_ABORTED:
            return EFI_ABORTED;
        case STATUS_NO_MEDIA:
            return EFI_NO_MEDIA;
        case STATUS_IO_DEVICE_ERROR:
            return EFI_DEVICE_ERROR;
        case STATUS_INVALID_BUFFER_SIZE:
            return EFI_BAD_BUFFER_SIZE;
        case STATUS_NOT_FOUND:
            return EFI_NOT_FOUND;
        case STATUS_DRIVER_UNABLE_TO_LOAD:
            return EFI_LOAD_ERROR;
        case STATUS_NO_MATCH:
            return EFI_NO_MAPPING;
        case STATUS_SUCCESS:
            return EFI_SUCCESS;
        case STATUS_TIMEOUT:
            return EFI_TIMEOUT;
        default:
            return EFI_NO_MAPPING;
    }
}

Referenced by EfiEntry().

◆ EfiGetLeafNode()

EFI_DEVICE_PATH * EfiGetLeafNode ( _In_ EFI_DEVICE_PATH * DevicePath )

Definition at line 102 of file firmware.c.

{
    EFI_DEVICE_PATH *NextDevicePath;
 
    /* Make sure we're not already at the end */
    if (!IsDevicePathEndType(DevicePath))
    {
        /* Grab the next node element, and keep going until the end */
        for (NextDevicePath = NextDevicePathNode(DevicePath);
             !IsDevicePathEndType(NextDevicePath);
             NextDevicePath = NextDevicePathNode(NextDevicePath))
        {
            /* Save the current node we're at  */
            DevicePath = NextDevicePath;
        }
    }
 
    /* This now contains the deepest (leaf) node */
    return DevicePath;
}

Referenced by BlockIoEfiGetDeviceInformation().

◆ EfiGetNtStatusCode()

NTSTATUS EfiGetNtStatusCode ( _In_ EFI_STATUS EfiStatus )

Definition at line 2539 of file firmware.c.

{
    switch (EfiStatus)
    {
        case EFI_NOT_READY:
        case EFI_NOT_FOUND:
            return STATUS_NOT_FOUND;
        case EFI_NO_MEDIA:
            return STATUS_NO_MEDIA;
        case EFI_MEDIA_CHANGED:
            return STATUS_MEDIA_CHANGED;
        case EFI_ACCESS_DENIED:
        case EFI_SECURITY_VIOLATION:
            return STATUS_ACCESS_DENIED;
        case EFI_TIMEOUT:
        case EFI_NO_RESPONSE:
            return STATUS_TIMEOUT;
        case EFI_NO_MAPPING:
            return STATUS_NO_MATCH;
        case EFI_NOT_STARTED:
            return STATUS_DEVICE_NOT_READY;
        case EFI_ALREADY_STARTED:
            return STATUS_DEVICE_ALREADY_ATTACHED;
        case EFI_ABORTED:
            return STATUS_REQUEST_ABORTED;
        case EFI_VOLUME_FULL:
            return STATUS_DISK_FULL;
        case EFI_DEVICE_ERROR:
            return STATUS_IO_DEVICE_ERROR;
        case EFI_WRITE_PROTECTED:
            return STATUS_MEDIA_WRITE_PROTECTED;
        /* @FIXME: ReactOS Headers don't yet have this */
        //case EFI_OUT_OF_RESOURCES:
            //return STATUS_INSUFFICIENT_NVRAM_RESOURCES;
        case EFI_VOLUME_CORRUPTED:
            return STATUS_DISK_CORRUPT_ERROR;
        case EFI_BUFFER_TOO_SMALL:
            return STATUS_BUFFER_TOO_SMALL;
        case EFI_SUCCESS:
            return STATUS_SUCCESS;
        case  EFI_LOAD_ERROR:
            return STATUS_DRIVER_UNABLE_TO_LOAD;
        case EFI_INVALID_PARAMETER:
            return STATUS_INVALID_PARAMETER;
        case EFI_UNSUPPORTED:
            return STATUS_NOT_SUPPORTED;
        case EFI_BAD_BUFFER_SIZE:
            return STATUS_INVALID_BUFFER_SIZE;
        default:
            return STATUS_UNSUCCESSFUL;
    }
}

Referenced by BlockIoFirmwareRead(), ConsoleFirmwareTextClear(), EfiAllocatePages(), EfiCloseProtocol(), EfiConInExReset(), EfiConInExSetState(), EfiConInReset(), EfiConnectController(), EfiConOutEnableCursor(), EfiConOutOutputString(), EfiConOutQueryMode(), EfiConOutSetAttribute(), EfiConOutSetCursorPosition(), EfiConOutSetMode(), EfiFreePages(), EfiGetMemoryMap(), EfiGetVariable(), EfiGopSetMode(), EfiLocateHandleBuffer(), EfiOpenProtocol(), EfiSetWatchdogTimer(), EfiStall(), EfiVmOpenProtocol(), EfiVmpCloseProtocol(), and MmFwGetMemoryMap().

◆ EfiGopGetCurrentMode()

NTSTATUS EfiGopGetCurrentMode	(	_In_ EFI_GRAPHICS_OUTPUT_PROTOCOL *	GopInterface,
		_Out_ UINTN *	Mode,
		_Out_ EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *	Information
	)

Definition at line 1296 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    PHYSICAL_ADDRESS GopInterfacePhys, ModePhys, InformationPhys;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* Translate pointer to physical */
        if (!BlMmTranslateVirtualAddress(GopInterface, &GopInterfacePhys))
        {
            return STATUS_UNSUCCESSFUL;
        }
        GopInterface = PhysicalAddressToPtr(GopInterfacePhys);
 
        /* Translate pointer to physical */
        if (!BlMmTranslateVirtualAddress(Mode, &ModePhys))
        {
            return STATUS_UNSUCCESSFUL;
        }
        Mode = PhysicalAddressToPtr(ModePhys);
 
        /* Translate pointer to physical */
        if (!BlMmTranslateVirtualAddress(Information, &InformationPhys))
        {
            return STATUS_UNSUCCESSFUL;
        }
        Information = PhysicalAddressToPtr(InformationPhys);
 
        /* Switch to real mode */
        BlpArchSwitchContext(BlRealMode);
    }
 
    /* Make the EFI call */
    *Mode = GopInterface->Mode->Mode;
    RtlCopyMemory(Information, GopInterface->Mode->Info, sizeof(*Information));
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Return back */
    return STATUS_SUCCESS;
}

Referenced by ConsoleEfiGopEnable(), and ConsoleEfiGopOpen().

◆ EfiGopGetFrameBuffer()

VOID EfiGopGetFrameBuffer	(	_In_ EFI_GRAPHICS_OUTPUT_PROTOCOL *	GopInterface,
		_Out_ PHYSICAL_ADDRESS *	FrameBuffer,
		_Out_ UINTN *	FrameBufferSize
	)

Definition at line 1255 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    PHYSICAL_ADDRESS GopInterfacePhys, FrameBufferPhys, FrameBufferSizePhys;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* Translate pointer to physical */
        BlMmTranslateVirtualAddress(GopInterface, &GopInterfacePhys);
        GopInterface = PhysicalAddressToPtr(GopInterfacePhys);
 
        /* Translate pointer to physical */
        BlMmTranslateVirtualAddress(FrameBuffer, &FrameBufferPhys);
        FrameBuffer = PhysicalAddressToPtr(FrameBufferPhys);
 
        /* Translate pointer to physical */
        BlMmTranslateVirtualAddress(FrameBufferSize, &FrameBufferSizePhys);
        FrameBufferSize = PhysicalAddressToPtr(FrameBufferSizePhys);
 
        /* Switch to real mode */
        BlpArchSwitchContext(BlRealMode);
    }
 
    /* Make the EFI call */
    FrameBuffer->QuadPart = GopInterface->Mode->FrameBufferBase;
    *FrameBufferSize = GopInterface->Mode->FrameBufferSize;
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
}

Referenced by ConsoleEfiGopEnable().

◆ EfiGopSetMode()

NTSTATUS EfiGopSetMode	(	_In_ EFI_GRAPHICS_OUTPUT_PROTOCOL *	GopInterface,
		_In_ ULONG	Mode
	)

Definition at line 1349 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
    BOOLEAN ModeChanged;
    NTSTATUS Status;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"gopsmode vm path\r\n");
        EfiStall(10000000);
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Make the EFI call */
    if (Mode == GopInterface->Mode->Mode)
    {
        EfiStatus = EFI_SUCCESS;
        ModeChanged = FALSE;
    }
    {
        EfiStatus = GopInterface->SetMode(GopInterface, Mode);
        ModeChanged = TRUE;
    }
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Print out to the debugger if the mode was changed */
    Status = EfiGetNtStatusCode(EfiStatus);
    if ((ModeChanged) && (NT_SUCCESS(Status)))
    {
        /* FIXME @TODO: Should be BlStatusPrint */
        EfiPrintf(L"Console video mode set to 0x%x\r\n", Mode);
    }
 
    /* Convert the error to an NTSTATUS */
    return Status;
}

Referenced by ConsoleEfiGopClose(), and ConsoleEfiGopEnable().

◆ EfiIsDevicePathParent()

EFI_DEVICE_PATH * EfiIsDevicePathParent	(	_In_ EFI_DEVICE_PATH *	DevicePath1,
		_In_ EFI_DEVICE_PATH *	DevicePath2
	)

Definition at line 47 of file firmware.c.

{
    EFI_DEVICE_PATH* CurrentPath1;
    EFI_DEVICE_PATH* CurrentPath2;
    USHORT Length1, Length2;
 
    /* Start with the current nodes */
    CurrentPath1 = DevicePath1;
    CurrentPath2 = DevicePath2;
 
    /* Loop each element of the device path */
    while (!(IsDevicePathEndType(CurrentPath1)) &&
           !(IsDevicePathEndType(CurrentPath2)))
    {
        /* Check if the element has a different length */
        Length1 = DevicePathNodeLength(CurrentPath1);
        Length2 = DevicePathNodeLength(CurrentPath2);
        if (Length1 != Length2)
        {
            /* Then they're not related */
            return NULL;
        }
 
        /* Check if the rest of the element data matches */
        if (RtlCompareMemory(CurrentPath1, CurrentPath2, Length1) != Length1)
        {
            /* Nope, not related */
            return NULL;
        }
 
        /* Move to the next element */
        CurrentPath1 = NextDevicePathNode(CurrentPath1);
        CurrentPath2 = NextDevicePathNode(CurrentPath2);
    }
 
    /* If the last element in path 1 is empty, then path 2 is the child (deeper) */
    if (!IsDevicePathEndType(CurrentPath1))
    {
        return DevicePath2;
    }
 
    /* If the last element in path 2 is empty, then path 1 is the child (deeper) */
    if (!IsDevicePathEndType(CurrentPath2))
    {
        return DevicePath1;
    }
 
    /* They're both the end, so they're identical, so there's no parent */
    return NULL;
}

Referenced by BlockIoEfiGetChildHandle().

◆ EfiLocateHandleBuffer()

NTSTATUS EfiLocateHandleBuffer	(	_In_ EFI_LOCATE_SEARCH_TYPE	SearchType,
		_In_ EFI_GUID *	Protocol,
		_Inout_ PULONG	HandleCount,
		_Inout_ EFI_HANDLE **	Buffer
	)

Definition at line 1399 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
    UINTN BufferSize;
    PVOID InputBuffer;
    BOOLEAN TranslateResult;
    PHYSICAL_ADDRESS BufferPhys;
 
    /* Bail out if we're missing parameters */
    if (!(Buffer) || !(HandleCount))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check if a buffer was passed in*/
    InputBuffer = *Buffer;
    if (InputBuffer)
    {
        /* Then we should already have a buffer size*/
        BufferSize = sizeof(EFI_HANDLE) * *HandleCount;
    }
    else
    {
        /* Then no buffer size exists */
        BufferSize = 0;
    }
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* Translate the input buffer from virtual to physical */
        TranslateResult = BlMmTranslateVirtualAddress(InputBuffer, &BufferPhys);
        InputBuffer = TranslateResult ? PhysicalAddressToPtr(BufferPhys) : NULL;
 
        /* Switch to real mode */
        BlpArchSwitchContext(BlRealMode);
    }
 
    /* Try the first time */
    EfiStatus = EfiBS->LocateHandle(SearchType,
                                    Protocol,
                                    NULL,
                                    &BufferSize,
                                    InputBuffer);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Check result of first search */
    if (EfiStatus == EFI_BUFFER_TOO_SMALL)
    {
        /* Did we have an existing buffer? */
        if (*Buffer)
        {
            /* Free it */
            BlMmFreeHeap(*Buffer);
        }
 
        /* Allocate a new one */
        InputBuffer = BlMmAllocateHeap(BufferSize);
        *Buffer = InputBuffer;
        if (!InputBuffer)
        {
            /* No space, fail */
            return STATUS_NO_MEMORY;
        }
 
        if (OldMode != BlRealMode)
        {
            /* Translate the input buffer from virtual to physical */
            TranslateResult = BlMmTranslateVirtualAddress(InputBuffer,
                                                          &BufferPhys);
            InputBuffer = TranslateResult ? PhysicalAddressToPtr(BufferPhys) : NULL;
 
            /* Switch to real mode */
            BlpArchSwitchContext(BlRealMode);
        }
 
        /* Try again */
        EfiStatus = EfiBS->LocateHandle(SearchType,
                                        Protocol,
                                        NULL,
                                        &BufferSize,
                                        InputBuffer);
 
        /* Switch back to protected mode if we came from there */
        if (OldMode != BlRealMode)
        {
            BlpArchSwitchContext(OldMode);
        }
    }
 
    /* Return the number of handles */
    *HandleCount = BufferSize / sizeof(EFI_HANDLE);
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by BlFwEnumerateDevice(), BlockIoEfiGetChildHandle(), BlockIoFirmwareOpen(), and ConsoleEfiGraphicalOpenProtocol().

◆ EfiOpenProtocol()

NTSTATUS EfiOpenProtocol	(	_In_ EFI_HANDLE	Handle,
		_In_ EFI_GUID *	Protocol,
		_Out_ PVOID *	Interface
	)

Referenced by BlockIoEfiGetBlockIoInformation(), BlockIoEfiGetChildHandle(), BlockIoEfiGetDeviceInformation(), BlockIoFirmwareRead(), ConsoleEfiGopOpen(), and ConsoleEfiGraphicalOpenProtocol().

◆ EfipGetRsdt()

NTSTATUS EfipGetRsdt ( _Out_ PPHYSICAL_ADDRESS FoundRsdt )

Definition at line 1635 of file firmware.c.

{
    NTSTATUS Status;
    ULONG Length;
    PHYSICAL_ADDRESS RsdpAddress, Rsdt;
    PRSDP Rsdp;
 
    /* Assume failure */
    Length = 0;
    Rsdp = NULL;
 
    /* Check if we already know it */
    if (EfiRsdt.QuadPart)
    {
        /* Return it */
        *FoundRsdt = EfiRsdt;
        return STATUS_SUCCESS;
    }
 
    /* Otherwise, look for the ACPI 2.0 RSDP (XSDT really) */
    Status = EfipGetSystemTable(&EfiRootAcpiTableGuid, &RsdpAddress);
    if (!NT_SUCCESS(Status))
    {
        /* Didn't fint it, look for the ACPI 1.0 RSDP (RSDT really) */
        Status = EfipGetSystemTable(&EfiRootAcpiTable10Guid, &RsdpAddress);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
 
    /* Map it */
    Length = sizeof(*Rsdp);
    Status = BlMmMapPhysicalAddressEx((PVOID*)&Rsdp,
                                      0,
                                      Length,
                                      RsdpAddress);
    if (NT_SUCCESS(Status))
    {
        /* Check the revision (anything >= 2.0 is XSDT) */
        if (Rsdp->Revision)
        {
            /* Check if the table is bigger than just its header */
            if (Rsdp->Length > Length)
            {
                /* Capture the real length */
                Length = Rsdp->Length;
 
                /* Unmap our header mapping */
                BlMmUnmapVirtualAddressEx(Rsdp, sizeof(*Rsdp));
 
                /* And map the whole thing now */
                Status = BlMmMapPhysicalAddressEx((PVOID*)&Rsdp,
                                                  0,
                                                  Length,
                                                  RsdpAddress);
                if (!NT_SUCCESS(Status))
                {
                    return Status;
                }
            }
 
            /* Read the XSDT address from the table*/
            Rsdt = Rsdp->XsdtAddress;
        }
        else
        {
            /* ACPI 1.0 so just read the RSDT */
            Rsdt.QuadPart = Rsdp->RsdtAddress;
        }
 
        /* Save it for later */
        EfiRsdt = Rsdt;
 
        /* And return it back */
        *FoundRsdt = Rsdt;
    }
 
    /* Check if we had mapped the RSDP */
    if (Rsdp)
    {
        /* Unmap it */
        BlMmUnmapVirtualAddressEx(Rsdp, Length);
    }
 
    /* Return search result back to caller */
    return Status;
}

Referenced by BlUtlGetAcpiTable().

◆ EfiPrintf()

VOID EfiPrintf	(	_In_ PWCHAR	Format,
			...
	)

Definition at line 126 of file firmware.c.

{
    va_list args;
    va_start(args, Format);
 
    /* Capture the buffer in our scratch pad, and NULL-terminate */
    vsnwprintf(BlScratchBuffer, RTL_NUMBER_OF(BlScratchBuffer) - 1, Format, args);
    BlScratchBuffer[RTL_NUMBER_OF(BlScratchBuffer) - 1] = UNICODE_NULL;
 
    /* Check which mode we're in */
    if (CurrentExecutionContext->Mode == BlRealMode)
    {
        /* Call EFI directly */
        EfiConOut->OutputString(EfiConOut, BlScratchBuffer);
    }
    else
    {
        /* Switch to real mode */
        BlpArchSwitchContext(BlRealMode);
 
        /* Call EFI directly */
        if (EfiConOut != NULL)
        {
            EfiConOut->OutputString(EfiConOut, BlScratchBuffer);
        }
 
        /* Switch back to protected mode */
        BlpArchSwitchContext(BlProtectedMode);
    }
 
    /* All done */
    va_end(args);
}

Referenced by Archx86TransferTo32BitApplicationAsm(), BcInitialize(), BcpDestroy(), BfiLoadFontFile(), BiConvertRegistryDataToElement(), BiEnumerateElements(), BiFlushHive(), BiLoadHive(), BiNotifyEnumerationError(), BlArchGetCpuVendor(), BlArchGetPerformanceCounter(), BlArchIsCpuIdFunctionSupported(), BlBdPullRemoteFile(), BlBsdInitializeLog(), BlDestroyLibrary(), BlDisplayGetTextCellResolution(), BlFileOpen(), BlFileReadAtOffsetEx(), BlImgLoadImageWithProgress2(), BlMmAllocateHeap(), BlMmRemoveBadMemory(), BlMmUnmapVirtualAddressEx(), BlockIoEfiCreateDeviceEntry(), BlockIoEfiFlush(), BlockIoEfiGetDeviceInformation(), BlockIoEfiReset(), BlockIoFirmwareOpen(), BlockIoGetGPTDiskSignature(), BlockIopOperation(), BlockIopReadPhysicalDevice(), BlockIopReadUsingPrefetch(), BlockIoSetInformation(), BlpArchInitialize(), BlpDeviceOpen(), BlpDeviceResolveLocate(), BlPdQueryData(), BlpMmInitialize(), BlpPdParseReturnArguments(), BlpTimeCalibratePerformanceCounter(), BlpTimeMeasureTscFrequency(), BlResourceFindMessage(), BlSecureBootCheckForFactoryReset(), BlStatusPrint(), BlTimeQueryPerformanceCounter(), BlUtlCheckSum(), BlUtlGetAcpiTable(), BlUtlUpdateProgress(), BlXmiWrite(), BmCloseDataStore(), BmDisplayDumpError(), BmEnumerateBootEntries(), BmFatalErrorEx(), BmFwInitializeBootDirectoryPath(), BmFwRegisterRevocationList(), BmMain(), BmOpenDataStore(), BmpCreateDevices(), BmpGetSelectedBootEntry(), BmpPopulateBootEntryList(), BmpProcessBadMemory(), BmpProcessBootEntry(), BmProcessCustomAction(), BmpTransferExecution(), BmResumeFromHibernate(), BmUpdateProgress(), BmUpdateProgressInfo(), ConsoleEfiGopOpen(), ConsoleEfiGraphicalOpenProtocol(), ConsoleEfiTextFindModeFromAllowed(), ConsoleEfiUgaOpen(), ConsoleFirmwareGraphicalClear(), ConsoleFirmwareTextOpen(), ConsoleGraphicalConstruct(), ConsoleGraphicalSetTextState(), ConsoleTextLocalConstruct(), ConsoleTextLocalReinitialize(), DbgPrint(), DsppInitialize(), DsppReinitialize(), EfiConInExReset(), EfiConInReset(), EfiConnectController(), EfiConOutEnableCursor(), EfiConOutOutputString(), EfiConOutQueryMode(), EfiConOutReadCurrentMode(), EfiConOutSetAttribute(), EfiConOutSetCursorPosition(), EfiConOutSetMode(), EfiGetVariable(), EfiGopSetMode(), EfiResetSystem(), EtfsMount(), EtfspCheckCdfs(), EtfspCheckEtfs(), EtfspCreateContext(), EtfspGetDirent(), EtfsSetInformation(), FatMount(), FileDeviceOpen(), FileIoOpen(), ImgArchEfiStartBootApplication(), ImgpCopyApplicationBootDevice(), ImgpLoadPEImage(), InitializeLibrary(), MmArchInitialize(), MmArchTranslateVirtualAddress(), MmBapFreeBlockAllocatorDescriptor(), MmDefInitializeTranslation(), MmDefMoveVirtualAddressRange(), MmDefpDestroySelfMap(), MmDefpMapPhysicalAddress(), MmDefpRemapVirtualAddress(), MmDefpTranslateVirtualAddress(), MmDefpUnmapVirtualAddress(), MmDefRelocateSelfMap(), MmDefZeroVirtualAddressRange(), MmFwGetMemoryMap(), MmHapHeapAllocatorExtend(), MmHapReportHeapCorruption(), MmMapPhysicalAddress(), MmMdDbgDumpList(), MmMdInitByteGranularDescriptor(), MmMdpCoalesceDescriptor(), MmMdpSwitchToDynamicDescriptors(), MmMdpTruncateDescriptor(), MmMdTruncateDescriptors(), MmPaAllocatePages(), MmPaInitialize(), MmPapAllocatePagesInRange(), MmPapAllocateRegionFromMdl(), MmPapFreePages(), MmPapFreePhysicalPages(), MmPapPageAllocatorExtend(), MmPaReleaseSelfMapPages(), MmTrInitialize(), MmUnmapVirtualAddress(), OslArchTransferToKernel(), OslDrawLogo(), OslMain(), OslpMain(), OslPrepareTarget(), PartitionOpen(), RdDeviceOpen(), RtlAssert(), SpOpen(), UdpOpen(), and VhdFileDeviceOpen().

◆ EfiResetSystem()

VOID EfiResetSystem ( _In_ EFI_RESET_TYPE ResetType )

Definition at line 1509 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* FIXME: Not yet implemented */
        EfiPrintf(L"reset vm path\r\n");
        EfiStall(10000000);
        return;
    }
 
    /* Call the EFI runtime */
    EfiRT->ResetSystem(ResetType, EFI_SUCCESS, 0, NULL);
}

Referenced by BlFwReboot().

◆ EfiStall()

NTSTATUS EfiStall ( _In_ ULONG StallTime )

Definition at line 1003 of file firmware.c.

{
    BL_ARCH_MODE OldMode;
    EFI_STATUS EfiStatus;
 
    /* Are we in protected mode? */
    OldMode = CurrentExecutionContext->Mode;
    if (OldMode != BlRealMode)
    {
        /* Switch to real mode */
        BlpArchSwitchContext(BlRealMode);
    }
 
    /* Make the EFI call */
    EfiStatus = EfiBS->Stall(StallTime);
 
    /* Switch back to protected mode if we came from there */
    if (OldMode != BlRealMode)
    {
        BlpArchSwitchContext(OldMode);
    }
 
    /* Convert the error to an NTSTATUS */
    return EfiGetNtStatusCode(EfiStatus);
}

Referenced by BiEnumerateElements(), BlMmUnmapVirtualAddressEx(), BlpTimeMeasureTscFrequency(), BmMain(), BmpGetSelectedBootEntry(), EfiConInExReset(), EfiConInReset(), EfiConnectController(), EfiConOutEnableCursor(), EfiConOutOutputString(), EfiConOutQueryMode(), EfiConOutReadCurrentMode(), EfiConOutSetAttribute(), EfiConOutSetCursorPosition(), EfiConOutSetMode(), EfiGetVariable(), EfiGopSetMode(), EfiResetSystem(), ImgArchEfiStartBootApplication(), MmDefpMapPhysicalAddress(), MmHapHeapAllocatorExtend(), MmMapPhysicalAddress(), MmMdInitByteGranularDescriptor(), MmMdpSwitchToDynamicDescriptors(), MmMdpTruncateDescriptor(), MmPaAllocatePages(), MmPapAllocatePagesInRange(), MmPapAllocateRegionFromMdl(), MmPapPageAllocatorExtend(), MmTrInitialize(), MmUnmapVirtualAddress(), and OslDrawLogo().

◆ EtfsInitialize()

NTSTATUS EtfsInitialize ( VOID )

Definition at line 969 of file etfs.c.

{
    NTSTATUS Status;
 
    /* Allocate the device table with 2 entries*/
    EtfsDeviceTableEntries = 2;
    EtfsDeviceTable = BlMmAllocateHeap(sizeof(PBL_FILE_ENTRY) *
                                       EtfsDeviceTableEntries);
    if (EtfsDeviceTable)
    {
        /* Zero it out */
        RtlZeroMemory(EtfsDeviceTable,
                      sizeof(PBL_FILE_ENTRY) * EtfsDeviceTableEntries);
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* No memory, fail */
        Status = STATUS_NO_MEMORY;
    }
 
    /* Return back to caller */
    return Status;
}

◆ EtfsMount()

NTSTATUS EtfsMount	(	_In_ ULONG	DeviceId,
		_In_ ULONG	Unknown,
		_Out_ PBL_FILE_ENTRY *	FileEntry
	)

Definition at line 874 of file etfs.c.

{
    PBL_ETFS_DEVICE EtfsDevice = NULL;
    PBL_FILE_ENTRY RootEntry;
    NTSTATUS Status;
    PBL_ETFS_FILE EtfsFile;
 
    EfiPrintf(L"Trying to mount as ETFS...\r\n");
 
    Status = EtfspCreateContext(DeviceId, &EtfsDevice);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"ETFS context failed: %lx\r\n");
        return Status;
    }
 
    Status = BlTblSetEntry(&EtfsDeviceTable,
                           &EtfsDeviceTableEntries,
                           EtfsDevice,
                           &DeviceId,
                           TblDoNotPurgeEntry);
    if (!NT_SUCCESS(Status))
    {
        EtfspDeviceContextDestroy(EtfsDevice);
        return Status;
    }
 
    RootEntry = BlMmAllocateHeap(sizeof(*RootEntry));
    if (!RootEntry)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    RtlZeroMemory(RootEntry, sizeof(*RootEntry));
 
    RootEntry->FilePath = BlMmAllocateHeap(4);
    if (!RootEntry->FilePath)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    wcsncpy(RootEntry->FilePath, L"\\", 1);
 
    RootEntry->DeviceId = DeviceId;
    RtlCopyMemory(&RootEntry->Callbacks,
                  &EtfsFunctionTable,
                  sizeof(RootEntry->Callbacks));
 
    EtfsFile = (PBL_ETFS_FILE)BlMmAllocateHeap(sizeof(*EtfsFile));
    if (!EtfsFile)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    RootEntry->Flags |= 0x10000;
 
    RtlZeroMemory(EtfsFile, sizeof(*EtfsFile));
    RootEntry->FsSpecificData = EtfsFile;
    EtfsFile->DeviceId = DeviceId;
    EtfsFile->Flags |= 1;
    EtfsFile->DiskOffset = EtfsDevice->RootDirOffset;
    EtfsFile->DirOffset = 0;
    EtfsFile->Size = EtfsDevice->RootDirSize;
    EtfsFile->FsName = L"cdfs";
    *FileEntry = RootEntry;
 
    return STATUS_SUCCESS;
 
Quickie:
    if (RootEntry->FilePath)
    {
        BlMmFreeHeap(RootEntry->FilePath);
    }
    if (RootEntry->FsSpecificData)
    {
        BlMmFreeHeap(RootEntry->FsSpecificData);
    }
    if (RootEntry)
    {
        BlMmFreeHeap(RootEntry);
    }
 
    EtfspDeviceTableDestroyEntry(EtfsDevice, DeviceId);
 
    return Status;
}

◆ FatInitialize()

NTSTATUS FatInitialize ( VOID )

Definition at line 81 of file fat.c.

{
    NTSTATUS Status;
 
    /* Allocate the device table with 2 entries*/
    FatDeviceTableEntries = 2;
    FatDeviceTable = BlMmAllocateHeap(sizeof(PBL_FILE_ENTRY) *
                                      FatDeviceTableEntries);
    if (FatDeviceTable)
    {
        /* Zero it out */
        RtlZeroMemory(FatDeviceTable,
                      sizeof(PBL_FILE_ENTRY) * FatDeviceTableEntries);
 
        /* Allocate a 512 byte buffer for long file name conversion */
        FatpLongFileName = BlMmAllocateHeap(512);
        Status = FatpLongFileName != NULL ? STATUS_SUCCESS : STATUS_NO_MEMORY;
    }
    else
    {
        /* No memory, fail */
        Status = STATUS_NO_MEMORY;
    }
 
    /* Return back to caller */
    return Status;
}

◆ FatMount()

NTSTATUS FatMount	(	_In_ ULONG	DeviceId,
		_In_ ULONG	Unknown,
		_Out_ PBL_FILE_ENTRY *	FileEntry
	)

Definition at line 23 of file fat.c.

{
    BL_DEVICE_INFORMATION DeviceInformation;
    ULONG UnknownFlag;
    NTSTATUS Status;
    PACKED_BOOT_SECTOR FatBootSector;
    BIOS_PARAMETER_BLOCK BiosBlock;
 
    /* Capture thing */
    BlDeviceGetInformation(DeviceId, &DeviceInformation);
    UnknownFlag = DeviceInformation.BlockDeviceInfo.Unknown;
 
    /* Set thing to 1 */
    DeviceInformation.BlockDeviceInfo.Unknown |= 1;
    BlDeviceSetInformation(DeviceId, &DeviceInformation);
 
    /* Read the boot sector */
    Status = BlDeviceReadAtOffset(DeviceId,
                                  sizeof(FatBootSector),
                                  0,
                                  &FatBootSector,
                                  NULL);
 
    /* Restore thing back */
    DeviceInformation.BlockDeviceInfo.Unknown = UnknownFlag;
    BlDeviceSetInformation(DeviceId, &DeviceInformation);
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Failed reading drive: %lx\r\n", Status);
        return Status;
    }
 
    FatUnpackBios(&BiosBlock, &FatBootSector.PackedBpb);
 
    /* For now, quickly fail if this isn't FAT */
    if (FatBootSector.Jump[0] != 0xE9)
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    EfiPrintf(L"Jump: %lx Bytes Per Sector: %d Sectors Per Cluster: %d Reserved: %d Fats: %d Sectors: %d Large Sectors: %d Media: %lx RootEntries: %d\r\n",
              FatBootSector.Jump[0],
              BiosBlock.BytesPerSector,
              BiosBlock.SectorsPerCluster,
              BiosBlock.ReservedSectors,
              BiosBlock.Fats,
              BiosBlock.Sectors,
              BiosBlock.LargeSectors,
              BiosBlock.Media,
              BiosBlock.RootEntries);
    return STATUS_NOT_IMPLEMENTED;
}

◆ MiscGetBootOption()

PBL_BCD_OPTION MiscGetBootOption	(	_In_ PBL_BCD_OPTION	List,
		_In_ ULONG	Type
	)

Definition at line 17 of file bcdopt.c.

{
    ULONG_PTR NextOption = 0, ListOption;
    PBL_BCD_OPTION Option, FoundOption;
 
    /* No options, bail out */
    if (!List)
    {
        return NULL;
    }
 
    /* Loop while we find an option */
    FoundOption = NULL;
    do
    {
        /* Get the next option and see if it matches the type */
        Option = (PBL_BCD_OPTION)((ULONG_PTR)List + NextOption);
        if ((Option->Type == Type) && !(Option->Empty))
        {
            FoundOption = Option;
            break;
        }
 
        /* Store the offset of the next option */
        NextOption = Option->NextEntryOffset;
 
        /* Failed to match. Check for list options */
        ListOption = Option->ListOffset;
        if (ListOption)
        {
            /* Try to get a match in the associated option */
            Option = MiscGetBootOption((PBL_BCD_OPTION)((ULONG_PTR)Option +
                                       ListOption),
                                       Type);
            if (Option)
            {
                /* Return it */
                FoundOption = Option;
                break;
            }
        }
    } while (NextOption);
 
    /* Return the option that was found, if any */
    return FoundOption;
}

Referenced by BlGetBootOptionBoolean(), BlGetBootOptionDevice(), BlGetBootOptionGuid(), BlGetBootOptionGuidList(), BlGetBootOptionInteger(), BlGetBootOptionString(), BlpGetBootOptionIntegerList(), BlRemoveBootOption(), BmGetOptionList(), BmpLaunchBootEntry(), BmpPopulateBootEntryList(), BmpTransferExecution(), DsppReinitialize(), and MiscGetBootOption().

◆ MmArchInitialize()

NTSTATUS MmArchInitialize	(	_In_ ULONG	Phase,
		_In_ PBL_MEMORY_DATA	MemoryData,
		_In_ BL_TRANSLATION_TYPE	TranslationType,
		_In_ BL_TRANSLATION_TYPE	LibraryTranslationType
	)

Definition at line 1028 of file mmx86.c.

{
    NTSTATUS Status;
    ULONGLONG IncreaseUserVa, PerfCounter, CpuRandom;
    CPU_INFO CpuInfo;
 
    /* For phase 2, just map deferred regions */
    if (Phase != 1)
    {
        return Mmx86pMapMemoryRegions(2, MemoryData);
    }
 
    /* What translation type are we switching to? */
    switch (RequestedTranslationType)
    {
        /* Physical memory */
        case BlNone:
 
            /* Initialize everything to default/null values */
            MmArchLargePageSize = 1;
            MmArchKsegBase = 0;
            MmArchKsegBias = 0;
            MmArchKsegAddressRange.Minimum = 0;
            MmArchKsegAddressRange.Maximum = (ULONGLONG)~0;
            MmArchTopOfApplicationAddressSpace = 0;
            Mmx86SelfMapBase.QuadPart = 0;
 
            /* Set stub functions */
            BlMmRelocateSelfMap = MmArchNullFunction;
            BlMmFlushTlb = MmArchNullFunction;
 
            /* Set success */
            Status = STATUS_SUCCESS;
            break;
 
        case BlVirtual:
 
            /* Set the large page size to 1024 pages (4MB) */
            MmArchLargePageSize = (4 * 1024 * 1024) / PAGE_SIZE;
 
            /* Check if /USERVA option was used */
            Status = BlGetBootOptionInteger(BlpApplicationEntry.BcdData,
                                            BcdOSLoaderInteger_IncreaseUserVa,
                                            &IncreaseUserVa);
            if (NT_SUCCESS(Status) && (IncreaseUserVa))
            {
                /* Yes -- load the kernel at 0xE0000000 instead */
                MmArchKsegBase = 0xE0000000;
            }
            else
            {
                /* Nope, load at the standard 2GB split */
                MmArchKsegBase = 0x80000000;
            }
 
            /* Check if CPUID 01h is supported */
            CpuRandom = 0;
            if (BlArchIsCpuIdFunctionSupported(1))
            {
                /* Call it */
                BlArchCpuId(1, 0, &CpuInfo);
 
                /* Check if RDRAND is supported */
                if (CpuInfo.Ecx & 0x40000000)
                {
                    EfiPrintf(L"Your CPU can do RDRAND! Good for you!\r\n");
                    CpuRandom = 0;
                }
            }
 
            /* Read the TSC */
            PerfCounter = BlArchGetPerformanceCounter();
            PerfCounter >>= 4;
            _rotl16(PerfCounter, 5);
 
            /* Set the address range */
            MmArchKsegAddressRange.Minimum = 0;
            MmArchKsegAddressRange.Maximum = (ULONGLONG)~0;
 
            /* Set the KASLR bias */
            MmArchKsegBias = ((PerfCounter ^ CpuRandom) & 0xFFF) << 12;
            MmArchKsegBias = 0;
            MmArchKsegBase += MmArchKsegBias;
 
            /* Set the kernel range */
            MmArchKsegAddressRange.Minimum = MmArchKsegBase;
            MmArchKsegAddressRange.Maximum = (ULONGLONG)~0;
 
            /* Set the boot application top maximum */
            MmArchTopOfApplicationAddressSpace = 0x70000000 - 1; // Windows bug
 
            /* Initialize virtual address space translation */
            Status = MmDefInitializeTranslation(MemoryData, TranslationType);
            if (NT_SUCCESS(Status))
            {
                /* Set stub functions */
                BlMmRelocateSelfMap = MmDefRelocateSelfMap;
                BlMmFlushTlb = Mmx86FlushTlb;
                BlMmMoveVirtualAddressRange = MmDefMoveVirtualAddressRange;
                BlMmZeroVirtualAddressRange = MmDefZeroVirtualAddressRange;
            }
            break;
 
        case BlPae:
 
            /* We don't support PAE */
            Status = STATUS_NOT_SUPPORTED;
            break;
 
        default:
 
            /* Invalid architecture type*/
            Status = STATUS_INVALID_PARAMETER;
            break;
    }
 
    /* Back to caller */
    return Status;
}

Referenced by BlpMmInitialize().

◆ MmArchTranslateVirtualAddress()

BOOLEAN MmArchTranslateVirtualAddress	(	_In_ PVOID	VirtualAddress,
		_Out_opt_ PPHYSICAL_ADDRESS	PhysicalAddress,
		_Out_opt_ PULONG	CachingFlags
	)

Definition at line 108 of file mmx86.c.

{
    PBL_MEMORY_DESCRIPTOR Descriptor;
 
    /* Check if paging is on */
    if ((CurrentExecutionContext) &&
        (CurrentExecutionContext->ContextFlags & BL_CONTEXT_PAGING_ON))
    {
        /* Yes -- we have to translate this from virtual */
        return Mmx86TranslateVirtualAddress(VirtualAddress,
                                            PhysicalAddress,
                                            CachingFlags);
    }
 
    /* Look in all descriptors except truncated and firmware ones */
    Descriptor = MmMdFindDescriptor(BL_MM_INCLUDE_NO_FIRMWARE_MEMORY &
                                    ~BL_MM_INCLUDE_TRUNCATED_MEMORY,
                                    BL_MM_REMOVE_PHYSICAL_REGION_FLAG,
                                    (ULONG_PTR)VirtualAddress >> PAGE_SHIFT);
 
    /* Return the virtual address as the physical address */
    if (PhysicalAddress)
    {
        PhysicalAddress->HighPart = 0;
        PhysicalAddress->LowPart = (ULONG_PTR)VirtualAddress;
    }
 
    /* There's no caching on physical memory */
    if (CachingFlags)
    {
        *CachingFlags = 0;
    }
 
    /* Success is if we found a descriptor */
    return Descriptor != NULL;
}

Referenced by BlMmTranslateVirtualAddress(), and MmMapPhysicalAddress().

◆ MmBaInitialize()

NTSTATUS MmBaInitialize ( VOID )

Definition at line 271 of file blkalloc.c.

{
    NTSTATUS Status;
    ULONG Size;
 
    /* Allocate 8 table entries */
    MmBlockAllocatorTableEntries = 8;
    Size = sizeof(BL_BLOCK_DESCRIPTOR) * MmBlockAllocatorTableEntries;
    MmBlockAllocatorTable = BlMmAllocateHeap(Size);
    if (MmBlockAllocatorTable)
    {
        /* Zero them out -- we're all done */
        Status = STATUS_SUCCESS;
        RtlZeroMemory(MmBlockAllocatorTable, Size);
        MmBlockAllocatorInitialized = 1;
    }
    else
    {
        /* Bail out since we're out of memory */
        Status = STATUS_NO_MEMORY;
        MmBlockAllocatorInitialized = 0;
    }
 
    /* Return initialization status */
    return Status;
}

Referenced by BlpMmInitialize().

◆ MmFwFreePages()

NTSTATUS MmFwFreePages	(	_In_ ULONG	BasePage,
		_In_ ULONG	PageCount
	)

Definition at line 28 of file fwutil.c.

{
    /* Free the pages */
    return EfiFreePages(PageCount, BasePage << PAGE_SHIFT);
}

Referenced by MmPapFreePhysicalPages(), MmPapPageAllocatorExtend(), and MmPaReleaseSelfMapPages().

◆ MmFwGetMemoryMap()

NTSTATUS MmFwGetMemoryMap	(	_Out_ PBL_MEMORY_DESCRIPTOR_LIST	MemoryMap,
		_In_ ULONG	Flags
	)

Definition at line 1845 of file firmware.c.

{
    BL_LIBRARY_PARAMETERS LibraryParameters = BlpLibraryParameters;
    BOOLEAN UseEfiBuffer, HaveRamDisk;
    NTSTATUS Status;
    ULONGLONG Pages, StartPage, EndPage, EfiBufferPage;
    UINTN EfiMemoryMapSize, MapKey, DescriptorSize, DescriptorVersion;
    EFI_PHYSICAL_ADDRESS EfiBuffer = 0;
    EFI_MEMORY_DESCRIPTOR* EfiMemoryMap;
    EFI_STATUS EfiStatus;
    BL_ARCH_MODE OldMode;
    EFI_MEMORY_DESCRIPTOR EfiDescriptor;
    BL_MEMORY_TYPE MemoryType;
    PBL_MEMORY_DESCRIPTOR Descriptor;
    BL_MEMORY_ATTR Attribute;
    PVOID LibraryBuffer;
 
    /* Initialize EFI memory map attributes */
    EfiMemoryMapSize = MapKey = DescriptorSize = DescriptorVersion = 0;
    LibraryBuffer = NULL;
 
    /* Increment the nesting depth */
    MmDescriptorCallTreeCount++;
 
    /* Determine if we should use EFI or our own allocator at this point */
    UseEfiBuffer = Flags & BL_MM_FLAG_USE_FIRMWARE_FOR_MEMORY_MAP_BUFFERS;
    if (!(LibraryParameters.LibraryFlags & BL_LIBRARY_FLAG_INITIALIZATION_COMPLETED))
    {
        UseEfiBuffer = TRUE;
    }
 
    /* Bail out if we don't have a list to use */
    if (MemoryMap == NULL)
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Free the current descriptor list */
    MmMdFreeList(MemoryMap);
 
    /* Call into EFI to get the size of the memory map */
    Status = EfiGetMemoryMap(&EfiMemoryMapSize,
                             NULL,
                             &MapKey,
                             &DescriptorSize,
                             &DescriptorVersion);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        /* This should've failed because our buffer was too small, nothing else */
        if (NT_SUCCESS(Status))
        {
            Status = STATUS_UNSUCCESSFUL;
        }
        goto Quickie;
    }
 
    /* Add 4 more descriptors just in case things changed */
    EfiMemoryMapSize += (4 * DescriptorSize);
    Pages = BYTES_TO_PAGES(EfiMemoryMapSize);
 
    /* Should we use EFI to grab memory? */
    if (UseEfiBuffer)
    {
        /* Yes -- request one more page to align up correctly */
        Pages++;
 
        /* Grab the required pages */
        Status = EfiAllocatePages(AllocateAnyPages,
                                  Pages,
                                  &EfiBuffer);
        if (!NT_SUCCESS(Status))
        {
            EfiPrintf(L"EFI allocation failed: %lx\r\n", Status);
            goto Quickie;
        }
 
        /* Free the pages for now */
        Status = EfiFreePages(Pages, EfiBuffer);
        if (!NT_SUCCESS(Status))
        {
            EfiBuffer = 0;
            goto Quickie;
        }
 
        /* Now round to the actual buffer size, removing the extra page */
        EfiBuffer = ROUND_TO_PAGES(EfiBuffer);
        Pages--;
        Status = EfiAllocatePages(AllocateAddress,
                                  Pages,
                                  &EfiBuffer);
        if (!NT_SUCCESS(Status))
        {
            EfiBuffer = 0;
            goto Quickie;
        }
 
        /* Get the final aligned size and proper buffer */
        EfiMemoryMapSize = EFI_PAGES_TO_SIZE(Pages);
        EfiMemoryMap = (EFI_MEMORY_DESCRIPTOR*)(ULONG_PTR)EfiBuffer;
 
        /* Switch to real mode if not already in it */
        OldMode = CurrentExecutionContext->Mode;
        if (OldMode != BlRealMode)
        {
            BlpArchSwitchContext(BlRealMode);
        }
 
        /* Call EFI to get the memory map */
        EfiStatus = EfiBS->GetMemoryMap(&EfiMemoryMapSize,
                                        EfiMemoryMap,
                                        &MapKey,
                                        &DescriptorSize,
                                        &DescriptorVersion);
 
        /* Switch back into the previous mode */
        if (OldMode != BlRealMode)
        {
            BlpArchSwitchContext(OldMode);
        }
 
        /* Convert the result code */
        Status = EfiGetNtStatusCode(EfiStatus);
    }
    else
    {
        /* Round the map to pages */
        Pages = BYTES_TO_PAGES(EfiMemoryMapSize);
 
        /* Allocate a large enough buffer */
        Status = MmPapAllocatePagesInRange(&LibraryBuffer,
                                           BlLoaderData,
                                           Pages,
                                           0,
                                           0,
                                           0,
                                           0);
        if (!NT_SUCCESS(Status))
        {
            EfiPrintf(L"Failed to allocate mapped VM for EFI map: %lx\r\n", Status);
            goto Quickie;
        }
 
        /* Call EFI to get the memory map */
        EfiMemoryMap = LibraryBuffer;
        Status = EfiGetMemoryMap(&EfiMemoryMapSize,
                                 LibraryBuffer,
                                 &MapKey,
                                 &DescriptorSize,
                                 &DescriptorVersion);
    }
 
    /* So far so good? */
    if (!NT_SUCCESS(Status))
    {
        EfiPrintf(L"Failed to get EFI memory map: %lx\r\n", Status);
        goto Quickie;
    }
 
    /* Did we get correct data from firmware? */
    if (((EfiMemoryMapSize % DescriptorSize)) ||
        (DescriptorSize < sizeof(EFI_MEMORY_DESCRIPTOR)))
    {
        EfiPrintf(L"Incorrect descriptor size\r\n");
        Status = STATUS_UNSUCCESSFUL;
        goto Quickie;
    }
 
    /* Did we boot from a RAM disk? */
    if ((BlpBootDevice->DeviceType == LocalDevice) &&
        (BlpBootDevice->Local.Type == RamDiskDevice))
    {
        /* We don't handle this yet */
        EfiPrintf(L"RAM boot not supported\r\n");
        Status = STATUS_NOT_IMPLEMENTED;
        goto Quickie;
    }
    else
    {
        /* We didn't, so there won't be any need to find the memory descriptor */
        HaveRamDisk = FALSE;
    }
 
    /* Loop the EFI memory map */
#if 0
    EfiPrintf(L"UEFI MEMORY MAP\r\n\r\n");
    EfiPrintf(L"TYPE        START              END                   ATTRIBUTES\r\n");
    EfiPrintf(L"===============================================================\r\n");
#endif
    while (EfiMemoryMapSize != 0)
    {
        /* Check if this is an EFI buffer, but we're not in real mode */
        if ((UseEfiBuffer) && (OldMode != BlRealMode))
        {
            BlpArchSwitchContext(BlRealMode);
        }
 
        /* Capture it so we can go back to protected mode (if possible) */
        EfiDescriptor = *EfiMemoryMap;
 
        /* Go back to protected mode, if we had switched */
        if ((UseEfiBuffer) && (OldMode != BlRealMode))
        {
            BlpArchSwitchContext(OldMode);
        }
 
        /* Convert to OS memory type */
        MemoryType = MmFwpGetOsMemoryType(EfiDescriptor.Type);
 
        /* Round up or round down depending on where the memory is coming from */
        if (MemoryType == BlConventionalMemory)
        {
            StartPage = BYTES_TO_PAGES(EfiDescriptor.PhysicalStart);
        }
        else
        {
            StartPage = EfiDescriptor.PhysicalStart >> PAGE_SHIFT;
        }
 
        /* Calculate the ending page */
        EndPage = StartPage + EfiDescriptor.NumberOfPages;
 
        /* If after rounding, we ended up with 0 pages, skip this */
        if (StartPage == EndPage)
        {
            goto LoopAgain;
        }
#if 0
        EfiPrintf(L"%08X    0x%016I64X-0x%016I64X    0x%I64X\r\n",
                   MemoryType,
                   StartPage << PAGE_SHIFT,
                   EndPage << PAGE_SHIFT,
                   EfiDescriptor.Attribute);
#endif
        /* Check for any range of memory below 1MB */
        if (StartPage < 0x100)
        {
            /* Does this range actually contain NULL? */
            if (StartPage == 0)
            {
                /* Manually create a reserved descriptof for this page */
                Attribute = MmFwpGetOsAttributeType(EfiDescriptor.Attribute);
                Descriptor = MmMdInitByteGranularDescriptor(Attribute,
                                                            BlReservedMemory,
                                                            0,
                                                            0,
                                                            1);
                if (!Descriptor)
                {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
 
                /* Add this descriptor into the list */
                Status = MmMdAddDescriptorToList(MemoryMap,
                                                 Descriptor,
                                                 BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG);
                if (!NT_SUCCESS(Status))
                {
                    EfiPrintf(L"Failed to add zero page descriptor: %lx\r\n", Status);
                    break;
                }
 
                /* Now handle the rest of the range, unless this was it */
                StartPage = 1;
                if (EndPage == 1)
                {
                    goto LoopAgain;
                }
            }
 
            /* Does the range go beyond 1MB? */
            if (EndPage > 0x100)
            {
                /* Then create the descriptor for everything up until the megabyte */
                Attribute = MmFwpGetOsAttributeType(EfiDescriptor.Attribute);
                Descriptor = MmMdInitByteGranularDescriptor(Attribute,
                                                            MemoryType,
                                                            StartPage,
                                                            0,
                                                            0x100 - StartPage);
                if (!Descriptor)
                {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
 
                /* Check if this region is currently free RAM */
                if (Descriptor->Type == BlConventionalMemory)
                {
                    /* Set the appropriate flag on the descriptor */
                    Descriptor->Flags |= BlMemoryBelow1MB;
                }
 
                /* Add this descriptor into the list */
                Status = MmMdAddDescriptorToList(MemoryMap,
                                                 Descriptor,
                                                 BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG);
                if (!NT_SUCCESS(Status))
                {
                    EfiPrintf(L"Failed to add 1MB descriptor: %lx\r\n", Status);
                    break;
                }
 
                /* Now handle the rest of the range above 1MB */
                StartPage = 0x100;
            }
        }
 
        /* Check if we loaded from a RAM disk */
        if (HaveRamDisk)
        {
            /* We don't handle this yet */
            EfiPrintf(L"RAM boot not supported\r\n");
            Status = STATUS_NOT_IMPLEMENTED;
            goto Quickie;
        }
 
        /* Create a descriptor for the current range */
        Attribute = MmFwpGetOsAttributeType(EfiDescriptor.Attribute);
        Descriptor = MmMdInitByteGranularDescriptor(Attribute,
                                                    MemoryType,
                                                    StartPage,
                                                    0,
                                                    EndPage - StartPage);
        if (!Descriptor)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        /* Check if this region is currently free RAM below 1MB */
        if ((Descriptor->Type == BlConventionalMemory) && (EndPage <= 0x100))
        {
            /* Set the appropriate flag on the descriptor */
            Descriptor->Flags |= BlMemoryBelow1MB;
        }
 
        /* Add the descriptor to the list, requesting coalescing as asked */
        Status = MmMdAddDescriptorToList(MemoryMap,
                                         Descriptor,
                                         BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG |
                                         ((Flags & BL_MM_FLAG_REQUEST_COALESCING) ?
                                          BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG : 0));
        if (!NT_SUCCESS(Status))
        {
            EfiPrintf(L"Failed to add full descriptor: %lx\r\n", Status);
            break;
        }
 
LoopAgain:
        /* Consume this descriptor, and move to the next one */
        EfiMemoryMapSize -= DescriptorSize;
        EfiMemoryMap = (PVOID)((ULONG_PTR)EfiMemoryMap + DescriptorSize);
    }
 
    /* Check if we are using the local UEFI buffer */
    if (!UseEfiBuffer)
    {
        goto Quickie;
    }
 
    /* Free the EFI buffer */
    Status = EfiFreePages(Pages, EfiBuffer);
    if (!NT_SUCCESS(Status))
    {
        /* Keep the pages marked 'in use' and fake success */
        Status = STATUS_SUCCESS;
        goto Quickie;
    }
 
    /* Get the base page of the EFI buffer */
    EfiBufferPage = EfiBuffer >> PAGE_SHIFT;
    Pages = (EfiBufferPage + Pages) - EfiBufferPage;
 
    /* Don't try freeing below */
    EfiBuffer = 0;
 
    /* Find the current descriptor for the allocation */
    Descriptor = MmMdFindDescriptorFromMdl(MemoryMap,
                                           BL_MM_REMOVE_PHYSICAL_REGION_FLAG,
                                           EfiBufferPage);
    if (!Descriptor)
    {
        Status = STATUS_UNSUCCESSFUL;
        goto Quickie;
    }
 
    /* Convert it to a free descriptor */
    Descriptor = MmMdInitByteGranularDescriptor(Descriptor->Flags,
                                                BlConventionalMemory,
                                                EfiBufferPage,
                                                0,
                                                Pages);
    if (!Descriptor)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Quickie;
    }
 
    /* Remove the region from the memory map */
    Status = MmMdRemoveRegionFromMdlEx(MemoryMap,
                                       BL_MM_REMOVE_PHYSICAL_REGION_FLAG,
                                       EfiBufferPage,
                                       Pages,
                                       NULL);
    if (!NT_SUCCESS(Status))
    {
        MmMdFreeDescriptor(Descriptor);
        goto Quickie;
    }
 
    /* Add it back as free memory */
    Status = MmMdAddDescriptorToList(MemoryMap,
                                     Descriptor,
                                     BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG);
 
Quickie:
    /* Free the EFI buffer, if we had one */
    if (EfiBuffer != 0)
    {
        EfiFreePages(Pages, EfiBuffer);
    }
 
    /* Free the library-allocated buffer, if we had one */
    if (LibraryBuffer != 0)
    {
        MmPapFreePages(LibraryBuffer, BL_MM_INCLUDE_MAPPED_ALLOCATED);
    }
 
    /* On failure, free the memory map if one was passed in */
    if (!NT_SUCCESS(Status) && (MemoryMap != NULL))
    {
        MmMdFreeList(MemoryMap);
    }
 
    /* Decrement the nesting depth and return */
    MmDescriptorCallTreeCount--;
    return Status;
}

Referenced by BlMmGetMemoryMap(), MmPaInitialize(), and Mmx86pMapMemoryRegions().

◆ MmHaInitialize()

NTSTATUS MmHaInitialize	(	_In_ ULONG	HeapSize,
		_In_ ULONG	HeapAttributes
	)

Definition at line 538 of file heapalloc.c.

{
    NTSTATUS Status;
 
    /* No free list to begin with */
    MmFreeList = NULL;
 
    /* Configure the minimum heap size and allocation attributes */
    HapMinimumHeapSize = ALIGN_UP_BY(HeapSize, PAGE_SIZE);
    HapAllocationAttributes = HeapAttributes & 0x20000;
 
    /* Initialize the heap boundary list */
    InitializeListHead(&MmHeapBoundaries);
 
    /* Initialize a heap big enough to handle a one pointer long allocation */
    Status = MmHapHeapAllocatorExtend(sizeof(PVOID));
    if (NT_SUCCESS(Status))
    {
        /* The heap is ready! */
        HapInitializationStatus = 1;
        Status = STATUS_SUCCESS;
    }
 
    /* Return initialization status */
    return Status;
}

Referenced by BlpMmInitialize().

◆ MmMapPhysicalAddress()

NTSTATUS MmMapPhysicalAddress	(	_Inout_ PPHYSICAL_ADDRESS	PhysicalAddress,
		_Out_ PVOID *	VirtualAddress,
		_Inout_ PULONGLONG	Size,
		_In_ ULONG	CacheAttributes
	)

Referenced by BlMmMapPhysicalAddressEx().

◆ MmMdAddDescriptorToList()

NTSTATUS MmMdAddDescriptorToList	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		_In_ PBL_MEMORY_DESCRIPTOR	MemoryDescriptor,
		_In_ ULONG	Flags
	)

Definition at line 582 of file descriptor.c.

{
    PLIST_ENTRY ThisEntry, FirstEntry;
    PBL_MEMORY_DESCRIPTOR ThisDescriptor;
 
    /* Arguments must be present */
    if (!(MdList) || !(MemoryDescriptor))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check if coalescing is forcefully disabled */
    if (Flags & BL_MM_ADD_DESCRIPTOR_NEVER_COALESCE_FLAG)
    {
        /* Then we won't be coalescing */
        Flags &= ~BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG;
    }
    else if (MemoryDescriptor->Flags & BlMemoryCoalesced)
    {
        /* Coalesce if the descriptor requires it */
        Flags |= BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG;
    }
 
    /* Check if truncation is forcefully disabled */
    if (Flags & BL_MM_ADD_DESCRIPTOR_NEVER_TRUNCATE_FLAG)
    {
        Flags &= ~BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG;
    }
 
    /* Update the current list pointer if the descriptor requires it */
    if (MemoryDescriptor->Flags & BlMemoryUpdate)
    {
        Flags |= BL_MM_ADD_DESCRIPTOR_UPDATE_LIST_POINTER_FLAG;
    }
 
    /* Get the current descriptor */
    ThisEntry = MdList->This;
    ThisDescriptor = CONTAINING_RECORD(ThisEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
 
    /* Also get the first descriptor */
    FirstEntry = MdList->First;
 
    /* Check if there's no current pointer, or if it's higher than the new one */
    if (!(ThisEntry) ||
        (MemoryDescriptor->BasePage <= ThisDescriptor->BasePage))
    {
        /* Start at the first descriptor instead, since current is past us */
        ThisEntry = FirstEntry->Flink;
    }
 
    /* Loop until we find the right location to insert */
    while (ThisEntry != FirstEntry)
    {
        /* Get the descriptor part of this entry */
        ThisDescriptor = CONTAINING_RECORD(ThisEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
 
        /* Is the address smaller, or equal but more important? */
        if ((MemoryDescriptor->BasePage < ThisDescriptor->BasePage) ||
            ((MemoryDescriptor->BasePage == ThisDescriptor->BasePage) &&
             (MmMdpHasPrecedence(MemoryDescriptor->Type, ThisDescriptor->Type))))
        {
            /* Then insert right here */
            InsertTailList(ThisEntry, &MemoryDescriptor->ListEntry);
            goto Quickie;
        }
 
        /* Try the next entry */
        ThisEntry = ThisEntry->Flink;
    }
 
    /* Then we didn't find a good match, so insert it right here */
    InsertTailList(FirstEntry, &MemoryDescriptor->ListEntry);
 
Quickie:
    /* Do we have to truncate? */
    if (Flags & BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG)
    {
        /* Do it and then exit */
        if (MmMdpTruncateDescriptor(MdList, MemoryDescriptor, Flags))
        {
            return STATUS_SUCCESS;
        }
    }
 
    /* Do we have to coalesce? */
    if (Flags & BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG)
    {
        /* Do it and then exit */
        if (MmMdpCoalesceDescriptor(MdList, MemoryDescriptor, Flags))
        {
            return STATUS_SUCCESS;
        }
    }
 
    /* Do we have to update the current pointer? */
    if (Flags & BL_MM_ADD_DESCRIPTOR_UPDATE_LIST_POINTER_FLAG)
    {
        /* Do it */
        MmMdpSaveCurrentListPointer(MdList, &MemoryDescriptor->ListEntry);
    }
 
    /* We're done */
    return STATUS_SUCCESS;
}

Referenced by BlMmMapPhysicalAddressEx(), MmFwGetMemoryMap(), MmMdCopyList(), MmMdRemoveRegionFromMdlEx(), MmMdTruncateDescriptors(), MmPaInitialize(), MmPapAllocateRegionFromMdl(), MmPapFreePhysicalPages(), MmPapPageAllocatorExtend(), MmPaReleaseSelfMapPages(), and MmTrInitialize().

◆ MmMdCopyList()

NTSTATUS MmMdCopyList	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	DestinationList,
		_In_ PBL_MEMORY_DESCRIPTOR_LIST	SourceList,
		_In_opt_ PBL_MEMORY_DESCRIPTOR	ListDescriptor,
		_Out_ PULONG	ActualCount,
		_In_ ULONG	Count,
		_In_ ULONG	Flags
	)

Definition at line 249 of file descriptor.c.

{
    NTSTATUS Status;
    PULONG Used;
    PLIST_ENTRY First, NextEntry;
    PBL_MEMORY_DESCRIPTOR Descriptor;
 
    /* Both parameters must be present */
    if (!(DestinationList) || !(SourceList))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Assume success */
    Status = STATUS_SUCCESS;
 
    /* Check if a descriptor is being used to store the list */
    if (ListDescriptor)
    {
        /* See how big it is */
        Flags |= BL_MM_ADD_DESCRIPTOR_NEVER_COALESCE_FLAG;
        Used = ActualCount;
    }
    else
    {
        /* We are using our internal descriptors instead */
        Used = &MmGlobalMemoryDescriptorsUsed;
        ++MmDescriptorCallTreeCount;
 
        /* Use as many as are available */
        Count = MmGlobalMemoryDescriptorCount;
        ListDescriptor = MmGlobalMemoryDescriptors;
    }
 
    /* Never truncate descriptors during a list copy */
    Flags |= BL_MM_ADD_DESCRIPTOR_NEVER_TRUNCATE_FLAG;
 
    /* Iterate through the list */
    First = SourceList->First;
    NextEntry = First->Flink;
    while ((NextEntry != First) && (NT_SUCCESS(Status)))
    {
        /* Make sure there's still space */
        if (Count <= *Used)
        {
            Status = STATUS_NO_MEMORY;
            break;
        }
 
        /* Get the current descriptor */
        Descriptor = CONTAINING_RECORD(NextEntry,
                                       BL_MEMORY_DESCRIPTOR,
                                       ListEntry);
 
        /* Copy it into one of the descriptors we have */
        RtlCopyMemory(&ListDescriptor[*Used],
                      Descriptor,
                      sizeof(*Descriptor));
 
        /* Add it to the list we have */
        Status = MmMdAddDescriptorToList(DestinationList,
                                         &ListDescriptor[*Used],
                                         Flags);
        ++*Used;
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
    }
 
    /* Check if the global descriptors were used */
    if (ListDescriptor == MmGlobalMemoryDescriptors)
    {
        /* Unwind our usage */
        MmMdFreeGlobalDescriptors();
        --MmDescriptorCallTreeCount;
    }
 
    /* Return back to caller */
    return Status;
}

Referenced by BlMmGetMemoryMap().

◆ MmMdCountList()

ULONG MmMdCountList ( _In_ PBL_MEMORY_DESCRIPTOR_LIST MdList )

Definition at line 205 of file descriptor.c.

{
    PLIST_ENTRY First, NextEntry;
    ULONG Count;
 
    /* Iterate the list */
    for (Count = 0, First = MdList->First, NextEntry = First->Flink;
         NextEntry != First;
         NextEntry = NextEntry->Flink, Count++);
 
    /* Return the count */
    return Count;
}

Referenced by BlMmGetMemoryMap().

◆ MmMdDbgDumpList()

VOID MmMdDbgDumpList	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	DescriptorList,
		_In_opt_ ULONG	MaxCount
	)

Definition at line 579 of file mmx86.c.

{
    ULONGLONG EndPage, VirtualEndPage;
    PBL_MEMORY_DESCRIPTOR MemoryDescriptor;
    PLIST_ENTRY NextEntry;
 
    /* If no maximum was provided, use essentially infinite */
    if (MaxCount == 0)
    {
        MaxCount = 0xFFFFFFFF;
    }
 
    /* Loop the list as long as there's entries and max isn't reached */
    NextEntry = DescriptorList->First->Flink;
    while ((NextEntry != DescriptorList->First) && (MaxCount--))
    {
        /* Get the descriptor */
        MemoryDescriptor = CONTAINING_RECORD(NextEntry,
                                             BL_MEMORY_DESCRIPTOR,
                                             ListEntry);
 
        /* Get the descriptor end page, and see if it was virtually mapepd */
        EndPage = MemoryDescriptor->BasePage + MemoryDescriptor->PageCount;
        if (MemoryDescriptor->VirtualPage)
        {
            /* Get the virtual end page too, then */
            VirtualEndPage = MemoryDescriptor->VirtualPage +
                             MemoryDescriptor->PageCount;
        }
        else
        {
            VirtualEndPage = 0;
        }
 
        /* Print out the descriptor, physical range, virtual range, and type */
        EfiPrintf(L"%p - [%08llx-%08llx @ %08llx-%08llx]:%x\r\n",
                    MemoryDescriptor,
                    MemoryDescriptor->BasePage << PAGE_SHIFT,
                    (EndPage << PAGE_SHIFT) - 1,
                    MemoryDescriptor->VirtualPage << PAGE_SHIFT,
                    VirtualEndPage ? (VirtualEndPage << PAGE_SHIFT) - 1 : 0,
                    (ULONG)MemoryDescriptor->Type);
 
        /* Next entry */
        NextEntry = NextEntry->Flink;
    }
}

◆ MmMdFindDescriptor()

PBL_MEMORY_DESCRIPTOR MmMdFindDescriptor	(	_In_ ULONG	WhichList,
		_In_ ULONG	Flags,
		_In_ ULONGLONG	Page
	)

Definition at line 1049 of file descriptor.c.

{
    PBL_MEMORY_DESCRIPTOR FoundDescriptor;
 
    /* Check if the caller is looking for mapped, allocated memory */
    if (WhichList & BL_MM_INCLUDE_MAPPED_ALLOCATED)
    {
        /* Find a descriptor in that list */
        FoundDescriptor = MmMdFindDescriptorFromMdl(&MmMdlMappedAllocated, Flags, Page);
        if (FoundDescriptor)
        {
            /* Got it */
            return FoundDescriptor;
        }
    }
 
    /* Check if the caller is looking for mapped, unallocated memory */
    if (WhichList & BL_MM_INCLUDE_MAPPED_UNALLOCATED)
    {
        /* Find a descriptor in that list */
        FoundDescriptor = MmMdFindDescriptorFromMdl(&MmMdlMappedUnallocated, Flags, Page);
        if (FoundDescriptor)
        {
            /* Got it */
            return FoundDescriptor;
        }
    }
 
    /* Check if the caller is looking for unmapped, allocated memory */
    if (WhichList & BL_MM_INCLUDE_UNMAPPED_ALLOCATED)
    {
        /* Find a descriptor in that list */
        FoundDescriptor = MmMdFindDescriptorFromMdl(&MmMdlUnmappedAllocated, Flags, Page);
        if (FoundDescriptor)
        {
            /* Got it */
            return FoundDescriptor;
        }
    }
 
    /* Check if the caller is looking for unmapped, unallocated memory */
    if (WhichList & BL_MM_INCLUDE_UNMAPPED_UNALLOCATED)
    {
        /* Find a descriptor in that list */
        FoundDescriptor = MmMdFindDescriptorFromMdl(&MmMdlUnmappedUnallocated, Flags, Page);
        if (FoundDescriptor)
        {
            /* Got it */
            return FoundDescriptor;
        }
    }
 
    /* Check if the caller is looking for reserved, allocated memory */
    if (WhichList & BL_MM_INCLUDE_RESERVED_ALLOCATED)
    {
        /* Find a descriptor in that list */
        FoundDescriptor = MmMdFindDescriptorFromMdl(&MmMdlReservedAllocated, Flags, Page);
        if (FoundDescriptor)
        {
            /* Got it */
            return FoundDescriptor;
        }
    }
 
    /* Check if the caller is looking for bad memory */
    if (WhichList & BL_MM_INCLUDE_BAD_MEMORY)
    {
        /* Find a descriptor in that list */
        FoundDescriptor = MmMdFindDescriptorFromMdl(&MmMdlBadMemory, Flags, Page);
        if (FoundDescriptor)
        {
            /* Got it */
            return FoundDescriptor;
        }
    }
 
    /* Check if the caller is looking for truncated memory */
    if (WhichList & BL_MM_INCLUDE_TRUNCATED_MEMORY)
    {
        /* Find a descriptor in that list */
        FoundDescriptor = MmMdFindDescriptorFromMdl(&MmMdlTruncatedMemory, Flags, Page);
        if (FoundDescriptor)
        {
            /* Got it */
            return FoundDescriptor;
        }
    }
 
    /* Check if the caller is looking for persistent memory */
    if (WhichList & BL_MM_INCLUDE_PERSISTENT_MEMORY)
    {
        /* Find a descriptor in that list */
        FoundDescriptor = MmMdFindDescriptorFromMdl(&MmMdlPersistentMemory, Flags, Page);
        if (FoundDescriptor)
        {
            /* Got it */
            return FoundDescriptor;
        }
    }
 
    /* Nothing if we got here */
    return NULL;
}

Referenced by BlMmMapPhysicalAddressEx(), MmArchTranslateVirtualAddress(), MmPapFreePhysicalPages(), and MmPaReleaseSelfMapPages().

◆ MmMdFindDescriptorFromMdl()

PBL_MEMORY_DESCRIPTOR MmMdFindDescriptorFromMdl	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		_In_ ULONG	Flags,
		_In_ ULONGLONG	Page
	)

Definition at line 960 of file descriptor.c.

{
    BOOLEAN IsVirtual;
    PLIST_ENTRY NextEntry, ListHead;
    PBL_MEMORY_DESCRIPTOR Current;
    ULONGLONG BasePage;
 
    /* Assume physical */
    IsVirtual = FALSE;
 
    /* Check if the caller wants physical memory */
    if (!(Flags & BL_MM_REMOVE_VIRTUAL_REGION_FLAG))
    {
        /* Check if this is a virtual memory list */
        if (MdList->Type == BlMdVirtual)
        {
            /* We won't find anything */
            return NULL;
        }
    }
    else if (MdList->Type == BlMdPhysical)
    {
        /* Otherwise, caller wants virtual, but this is a physical list */
        IsVirtual = TRUE;
        NextEntry = MdList->First->Flink;
    }
 
    /* Check if this is a physical search */
    if (!IsVirtual)
    {
        /* Check if we can use the current pointer */
        NextEntry = MdList->This;
        if (!NextEntry)
        {
            /* We can't -- start at the beginning */
            NextEntry = MdList->First->Flink;
        }
        else
        {
            /* If the page is below the current pointer, restart */
            Current = CONTAINING_RECORD(NextEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
            if (Page < Current->BasePage)
            {
                NextEntry = MdList->First->Flink;
            }
        }
    }
 
    /* Loop the list of descriptors */
    ListHead = MdList->First;
    while (NextEntry != ListHead)
    {
        /* Get the current one */
        Current = CONTAINING_RECORD(NextEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
 
        /* Check if we are looking for virtual memory */
        if (IsVirtual)
        {
            /* Use the base address */
            BasePage = Current->VirtualPage;
        }
        else
        {
            /* Use the page */
            BasePage = Current->BasePage;
        }
 
        /* If this is a virtual descriptor, make sure it has a base address */
        if ((!(IsVirtual) || (BasePage)) &&
            (BasePage <= Page) &&
            (Page < (BasePage + Current->PageCount)))
        {
            /* The descriptor fits the page being requested */
            return Current;
        }
 
        /* Try the next one */
        NextEntry = NextEntry->Flink;
    }
 
    /* Nothing found if we're here */
    return NULL;
}

Referenced by MmFwGetMemoryMap(), and MmMdFindDescriptor().

◆ MmMdFindSatisfyingRegion()

BOOLEAN MmMdFindSatisfyingRegion	(	_In_ PBL_MEMORY_DESCRIPTOR	Descriptor,
		_Out_ PBL_MEMORY_DESCRIPTOR	NewDescriptor,
		_In_ ULONGLONG	Pages,
		_In_ PBL_ADDRESS_RANGE	BaseRange,
		_In_ PBL_ADDRESS_RANGE	VirtualRange,
		_In_ BOOLEAN	TopDown,
		_In_ BL_MEMORY_TYPE	MemoryType,
		_In_ ULONG	Flags,
		_In_ ULONG	Alignment
	)

Definition at line 1158 of file descriptor.c.

{
    ULONGLONG BaseMin, BaseMax, AlignedMin;
    ULONGLONG VirtualPage, BasePage;
    ULONGLONG BaseDelta, AlignedBase;
    ULONGLONG VirtualMin, VirtualMax;
 
    /* Extract the minimum and maximum range */
    BaseMin = BaseRange->Minimum;
    BaseMax = BaseRange->Maximum;
 
    /* Don't go below where the descriptor starts */
    if (BaseMin < Descriptor->BasePage)
    {
        BaseMin = Descriptor->BasePage;
    }
 
    /* Don't go beyond where the descriptor ends */
    if (BaseMax > (Descriptor->BasePage + Descriptor->PageCount - 1))
    {
        BaseMax = (Descriptor->BasePage + Descriptor->PageCount - 1);
    }
 
    /* Check for start overflow */
    if (BaseMin > BaseMax)
    {
        return FALSE;
    }
 
    /* Align the base as required */
    if (Alignment != 1)
    {
        AlignedMin = ALIGN_UP_BY(BaseMin, Alignment);
    }
    else
    {
        AlignedMin = BaseMin;
    }
 
    /* Check for range overflow */
    if (((AlignedMin + Pages - 1) < AlignedMin) || ((AlignedMin + Pages - 1) > BaseMax))
    {
        return FALSE;
    }
 
    /* Check if this was a top-down request */
    if (TopDown)
    {
        /* Then get the highest page possible */
        BasePage = BaseMax - Pages + 1;
        if (Alignment != 1)
        {
            /* Align it as needed */
            AlignedBase = ALIGN_DOWN_BY(BasePage, Alignment);
        }
        else
        {
            AlignedBase = BasePage;
        }
 
        /* Calculate the delta between max address and our aligned base */
        BaseDelta = BasePage - AlignedBase;
        BasePage -= BaseDelta;
    }
    else
    {
        /* Otherwise, get the lowest page possible */
        BasePage = AlignedMin;
        BaseDelta = 0;
    }
 
    /* If a virtual address range was passed in, this must be a virtual descriptor */
    if (((VirtualRange->Minimum) || (VirtualRange->Maximum)) &&
        !(Descriptor->VirtualPage))
    {
        return FALSE;
    }
 
    /* Any mapped page already? */
    if (Descriptor->VirtualPage)
    {
        /* Get virtual min/max */
        VirtualMin = VirtualRange->Minimum;
        VirtualMax = VirtualRange->Maximum;
 
        /* Don't go below where the descriptor maps */
        if (VirtualMin <= Descriptor->VirtualPage)
        {
            VirtualMin = Descriptor->VirtualPage;
        }
 
        /* Don't go above where the descriptor maps */
        if (VirtualMax >= (Descriptor->VirtualPage + Descriptor->PageCount - 1))
        {
            VirtualMax = Descriptor->VirtualPage + Descriptor->PageCount - 1;
        }
 
        /* Don't let the base overflow */
        if (VirtualMin > VirtualMax)
        {
            return FALSE;
        }
 
        /* Adjust the base by the alignment delta */
        VirtualMin += AlignedMin - BaseMin;
 
        /* Check that the bounds don't overflow or underflow */
        if (((VirtualMin + Pages - 1) < VirtualMin) ||
            ((VirtualMin + Pages - 1) > VirtualMax))
        {
            return FALSE;
        }
 
        /* Finally, pick the correct address based on direction */
        if (TopDown)
        {
            /* Highest possible base address, aligned */
            VirtualPage = VirtualMax - Pages + 1 - BaseDelta;
        }
        else
        {
            /* Lowest possible base address, aligned */
            VirtualPage = VirtualMin;
        }
    }
    else
    {
        /* Nothing to worry about */
        VirtualPage = 0;
    }
 
    /* Bail out if the memory type attributes don't match */
    if ((((Flags & 0xFF) & (Descriptor->Flags & 0xFF)) != (Flags & 0xFF)) ||
        (((Flags & 0xFF00) & (Descriptor->Flags & 0xFF00)) != (Flags & 0xFF00)))
    {
        //EfiPrintf(L"Incorrect memory attributes\r\n");
        return FALSE;
    }
 
    /* Bail out if the allocation flags don't match */
    if (((Flags ^ Descriptor->Flags) & (BlMemoryRuntime | BlMemoryBelow1MB | BlMemoryLargePages)))
    {
        //EfiPrintf(L"Incorrect memory allocation flags\r\n");
        return FALSE;
    }
 
    /* Bail out if the type doesn't match */
    if (Descriptor->Type != MemoryType)
    {
        //EfiPrintf(L"Incorrect descriptor type: %lx %lx\r\n", Descriptor->Type, MemoryType);
        return FALSE;
    }
 
    /* We have a matching region, fill out the descriptor for it */
    NewDescriptor->BasePage = BasePage;
    NewDescriptor->PageCount = Pages;
    NewDescriptor->Type = Descriptor->Type;
    NewDescriptor->VirtualPage = VirtualPage;
    NewDescriptor->Flags = Descriptor->Flags;
    //EfiPrintf(L"Found a matching descriptor: %08I64X with %08I64X pages\r\n", BasePage, Pages);
    return TRUE;
}

Referenced by MmPapAllocateRegionFromMdl().

◆ MmMdFreeDescriptor()

NTSTATUS MmMdFreeDescriptor ( _In_ PBL_MEMORY_DESCRIPTOR MemoryDescriptor )

Definition at line 157 of file descriptor.c.

{
    NTSTATUS Status;
 
    /* Check if this is a valid static descriptor */
    if (((MmDynamicMemoryDescriptors) &&
        (MemoryDescriptor >= MmDynamicMemoryDescriptors) &&
        (MemoryDescriptor < &MmDynamicMemoryDescriptors[MmDynamicMemoryDescriptorCount])) ||
        ((MemoryDescriptor >= MmStaticMemoryDescriptors) &&
        (MemoryDescriptor < &MmStaticMemoryDescriptors[RTL_NUMBER_OF(MmStaticMemoryDescriptors)])))
    {
        /* It's a global/static descriptor, so just zero it */
        RtlZeroMemory(MemoryDescriptor, sizeof(BL_MEMORY_DESCRIPTOR));
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* It's a dynamic descriptor, so free it */
        Status = BlMmFreeHeap(MemoryDescriptor);
    }
 
    /* Done */
    return Status;
}

Referenced by MmFwGetMemoryMap(), MmMdFreeList(), MmMdRemoveRegionFromMdlEx(), MmPapAllocateRegionFromMdl(), and Mmx86pMapMemoryRegions().

◆ MmMdFreeGlobalDescriptors()

VOID MmMdFreeGlobalDescriptors ( VOID )

Definition at line 1332 of file descriptor.c.

{
    PBL_MEMORY_DESCRIPTOR Descriptor, OldDescriptor;
    ULONG Index = 0;
    PLIST_ENTRY OldFlink, OldBlink;
 
    /* Make sure we're not int middle of a call using a descriptor */
    if (MmDescriptorCallTreeCount != 1)
    {
        return;
    }
 
    /* Loop every current global descriptor */
    while (Index < MmGlobalMemoryDescriptorsUsed)
    {
        /* Does it have any valid pages? */
        OldDescriptor = &MmGlobalMemoryDescriptors[Index];
        if (OldDescriptor->PageCount)
        {
            /* Allocate a copy of it */
            Descriptor = BlMmAllocateHeap(sizeof(*Descriptor));
            if (!Descriptor)
            {
                return;
            }
 
            /* Save the links */
            OldBlink = OldDescriptor->ListEntry.Blink;
            OldFlink = OldDescriptor->ListEntry.Flink;
 
            /* Make the copy */
            *Descriptor = *OldDescriptor;
 
            /* Fix the links */
            OldBlink->Flink = &Descriptor->ListEntry;
            OldFlink->Blink = &Descriptor->ListEntry;
 
            /* Zero the descriptor */
            RtlZeroMemory(OldDescriptor, sizeof(*OldDescriptor));
        }
 
        /* Keep going */
        Index++;
    }
 
    /* All global descriptors freed */
    MmGlobalMemoryDescriptorsUsed = 0;
}

Referenced by BlMmMapPhysicalAddressEx(), BlMmUnmapVirtualAddressEx(), BlpMmInitialize(), MmMdCopyList(), MmPapAllocatePagesInRange(), MmPapAllocatePhysicalPagesInRange(), MmPaReserveSelfMapPages(), MmPaTruncateMemory(), and TrpGenerateMappingTracker().

◆ MmMdFreeList()

VOID MmMdFreeList ( _In_ PBL_MEMORY_DESCRIPTOR_LIST MdList )

Definition at line 356 of file descriptor.c.

{
    PLIST_ENTRY FirstEntry, NextEntry;
    PBL_MEMORY_DESCRIPTOR Entry;
 
    /* Go over every descriptor from the top */
    FirstEntry = MdList->First;
    NextEntry = FirstEntry->Flink;
    while (NextEntry != FirstEntry)
    {
        /* Remove and free each one */
        Entry = CONTAINING_RECORD(NextEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
        NextEntry = NextEntry->Flink;
        MmMdRemoveDescriptorFromList(MdList, Entry);
        MmMdFreeDescriptor(Entry);
    }
}

Referenced by BlMmGetMemoryMap(), MmFwGetMemoryMap(), and MmMdRemoveRegionFromMdlEx().

◆ MmMdInitByteGranularDescriptor()

PBL_MEMORY_DESCRIPTOR MmMdInitByteGranularDescriptor	(	_In_ ULONG	Flags,
		_In_ BL_MEMORY_TYPE	Type,
		_In_ ULONGLONG	BasePage,
		_In_ ULONGLONG	VirtualPage,
		_In_ ULONGLONG	PageCount
	)

Definition at line 377 of file descriptor.c.

{
    PBL_MEMORY_DESCRIPTOR MemoryDescriptor;
 
    /* If we're out of descriptors, bail out */
    if (MmGlobalMemoryDescriptorsUsed >= MmGlobalMemoryDescriptorCount)
    {
        EfiPrintf(L"Out of descriptors!\r\n");
        EfiStall(1000000);
        return NULL;
    }
 
    /* Take one of the available descriptors and fill it out */
    MemoryDescriptor = &MmGlobalMemoryDescriptors[MmGlobalMemoryDescriptorsUsed];
    MemoryDescriptor->BasePage = BasePage;
    MemoryDescriptor->VirtualPage = VirtualPage;
    MemoryDescriptor->PageCount = PageCount;
    MemoryDescriptor->Flags = Flags;
    MemoryDescriptor->Type = Type;
    InitializeListHead(&MemoryDescriptor->ListEntry);
 
    /* Increment the count and return the descriptor */
    MmGlobalMemoryDescriptorsUsed++;
    return MemoryDescriptor;
}

Referenced by BlMmMapPhysicalAddressEx(), MmFwGetMemoryMap(), MmMdRemoveRegionFromMdlEx(), MmMdTruncateDescriptors(), MmPaInitialize(), MmPapAllocateRegionFromMdl(), MmPapFreePhysicalPages(), MmPapPageAllocatorExtend(), MmPaReleaseSelfMapPages(), MmTrInitialize(), and TrpGenerateMappingTracker().

◆ MmMdInitialize()

VOID MmMdInitialize	(	_In_ ULONG	Phase,
		_In_ PBL_LIBRARY_PARAMETERS	LibraryParameters
	)

Definition at line 1384 of file descriptor.c.

{
    /* Are we in phase 1? */
    if (Phase != 0)
    {
        /* Switch to dynamic descriptors if we have too many */
        if (LibraryParameters->DescriptorCount > RTL_NUMBER_OF(MmStaticMemoryDescriptors))
        {
            MmMdpSwitchToDynamicDescriptors(LibraryParameters->DescriptorCount);
        }
    }
    else
    {
        /* In phase 0, start with a pool of 512 static descriptors */
        MmGlobalMemoryDescriptorCount = RTL_NUMBER_OF(MmStaticMemoryDescriptors);
        MmGlobalMemoryDescriptors = MmStaticMemoryDescriptors;
        RtlZeroMemory(MmStaticMemoryDescriptors, sizeof(MmStaticMemoryDescriptors));
        MmGlobalMemoryDescriptorsUsed = 0;
    }
}

Referenced by BlpMmInitialize().

◆ MmMdInitializeList()

VOID MmMdInitializeList	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	DescriptorList,
		_In_ ULONG	Type,
		_In_ PLIST_ENTRY	ListHead
	)

Definition at line 222 of file descriptor.c.

{
    /* Check if a list was specified */
    if (ListHead)
    {
        /* Use it */
        MdList->First = ListHead;
    }
    else
    {
        /* Otherwise, use the internal, built-in list */
        InitializeListHead(&MdList->ListHead);
        MdList->First = &MdList->ListHead;
    }
 
    /* Set the type */
    MdList->Type = Type;
 
    /* Initialize current iterator to nothing */
    MdList->This = NULL;
}

Referenced by BlMmGetMemoryMap(), and MmMdRemoveRegionFromMdlEx().

◆ MmMdInitializeListHead()

FORCEINLINE VOID MmMdInitializeListHead ( _In_ PBL_MEMORY_DESCRIPTOR_LIST List )

Definition at line 1376 of file bl.h.

{
    /* Initialize the list */
    InitializeListHead(&List->ListHead);
    List->First = &List->ListHead;
    List->This = NULL;
    List->Type = 0;
}

Referenced by BlMmGetMemoryMap(), MmPaInitialize(), MmTrInitialize(), and Mmx86pMapMemoryRegions().

◆ MmMdRemoveDescriptorFromList()

VOID MmMdRemoveDescriptorFromList	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		_In_ PBL_MEMORY_DESCRIPTOR	Entry
	)

Definition at line 338 of file descriptor.c.

{
    /* Remove the entry */
    RemoveEntryList(&Entry->ListEntry);
 
    /* Check if this was the current link */
    if (MdList->This == &Entry->ListEntry)
    {
        /* Remove the current link and set the next one */
        MdList->This = NULL;
        MmMdpSaveCurrentListPointer(MdList, Entry->ListEntry.Blink);
    }
}

Referenced by BlMmMapPhysicalAddressEx(), MmMdFreeList(), MmMdRemoveRegionFromMdlEx(), MmMdTruncateDescriptors(), MmPapAllocateRegionFromMdl(), MmPapFreePhysicalPages(), and Mmx86pMapMemoryRegions().

◆ MmMdRemoveRegionFromMdlEx()

NTSTATUS MmMdRemoveRegionFromMdlEx	(	__in PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		__in ULONG	Flags,
		__in ULONGLONG	BasePage,
		__in ULONGLONG	PageCount,
		__in PBL_MEMORY_DESCRIPTOR_LIST	NewMdList
	)

Referenced by BlMmMapPhysicalAddressEx(), MmDefInitializeTranslation(), MmFwGetMemoryMap(), MmPaInitialize(), MmPapFreePhysicalPages(), MmPaReserveSelfMapPages(), and Mmx86MapInitStructure().

◆ MmMdTruncateDescriptors()

NTSTATUS MmMdTruncateDescriptors	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		_In_ PBL_MEMORY_DESCRIPTOR_LIST	NewList,
		_In_ ULONGLONG	BasePage
	)

Definition at line 410 of file descriptor.c.

{
    PLIST_ENTRY ListHead, NextEntry;
    PBL_MEMORY_DESCRIPTOR Descriptor, NewDescriptor;
    ULONGLONG FoundEndPage;
 
    /* Search the descriptor list */
    ListHead = MdList->First;
    NextEntry = ListHead->Flink;
    while (NextEntry != ListHead)
    {
        /* Get the current descriptor */
        Descriptor = CONTAINING_RECORD(NextEntry,
                                       BL_MEMORY_DESCRIPTOR,
                                       ListEntry);
 
        /* Go to the next entry in case we have to remove */
        NextEntry = NextEntry->Flink;
 
        /* Don't touch anything else but free RAM */
        if (((Descriptor->Type >> BL_MEMORY_CLASS_SHIFT) == BlSystemClass) &&
            (Descriptor->Type != BlConventionalMemory))
        {
            continue;
        }
 
        /* Check if this page is within the descriptor's region */
        FoundEndPage = Descriptor->BasePage + Descriptor->PageCount;
        if (BasePage > Descriptor->BasePage)
        {
            /* Check if it doesn't go beyond the descriptor */
            if (BasePage < FoundEndPage)
            {
                /* Create a new descriptor to describe this region */
                EfiPrintf(L"Truncating descriptor type %lx base: %llx end: %llx\r\n",
                          Descriptor->Type, Descriptor->BasePage, FoundEndPage);
                NewDescriptor = MmMdInitByteGranularDescriptor(Descriptor->Flags,
                                                               Descriptor->Type,
                                                               BasePage,
                                                               0,
                                                               FoundEndPage - BasePage);
                if (!NewDescriptor)
                {
                    return STATUS_NO_MEMORY;
                }
 
                /* Cut off this descriptor to make it shorter */
                Descriptor->PageCount = BasePage - Descriptor->BasePage;
 
                /* Add the region to the new list */
                MmMdAddDescriptorToList(NewList,
                                        NewDescriptor,
                                        BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG);
            }
        }
        else
        {
            /* This whole descriptor covers the truncated area */
            EfiPrintf(L"Truncating descriptor type %lx base: %llx end: %llx\r\n",
                      Descriptor->Type, Descriptor->BasePage, FoundEndPage);
            MmMdRemoveDescriptorFromList(MdList, Descriptor);
            MmMdAddDescriptorToList(NewList,
                                    Descriptor,
                                    BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG);
        }
    }
 
    /* All good if we got here */
    return STATUS_SUCCESS;
}

Referenced by MmPaTruncateMemory().

◆ MmPaInitialize()

NTSTATUS MmPaInitialize	(	_In_ PBL_MEMORY_DATA	MemoryData,
		_In_ ULONG	MinimumPages
	)

Referenced by BlpMmInitialize().

◆ MmPapAllocatePagesInRange()

NTSTATUS MmPapAllocatePagesInRange	(	_Inout_ PVOID *	PhysicalAddress,
		_In_ BL_MEMORY_TYPE	MemoryType,
		_In_ ULONGLONG	Pages,
		_In_ ULONG	Attributes,
		_In_ ULONG	Alignment,
		_In_opt_ PBL_ADDRESS_RANGE	Range,
		_In_ ULONG	Type
	)

Definition at line 707 of file pagealloc.c.

{
    NTSTATUS Status;
    PHYSICAL_ADDRESS BaseAddress;
    BL_PA_REQUEST Request;
    PBL_MEMORY_DESCRIPTOR_LIST List;
    BL_MEMORY_DESCRIPTOR Descriptor;
 
    /* Increment nesting depth */
    ++MmDescriptorCallTreeCount;
 
    /* Default list */
    List = &MmMdlMappedAllocated;
 
    /* Check for missing parameters or invalid range */
    if (!(PhysicalAddress) ||
        !(Pages) ||
        ((Range) && (Range->Minimum >= Range->Maximum)))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }
 
    /* What translation mode are we using? */
    if (MmTranslationType != BlNone)
    {
        /* Use 1 page alignment if none was requested */
        if (!Alignment)
        {
            Alignment = 1;
        }
 
        /* Check if we got a range */
        if (Range)
        {
            /* We don't support virtual memory yet @TODO */
            EfiPrintf(L"virt range not yet implemented in %S\r\n", __FUNCTION__);
            EfiStall(1000000);
            Status = STATUS_NOT_IMPLEMENTED;
            goto Exit;
        }
        else
        {
            /* Use the entire range that's possible */
            Request.BaseRange.Minimum = PapMinimumPhysicalPage;
            Request.BaseRange.Maximum = 0xFFFFFFFF >> PAGE_SHIFT;
        }
 
        /* Check if a fixed allocation was requested */
        if (Attributes & BlMemoryFixed)
        {
            /* We don't support virtual memory yet @TODO */
            EfiPrintf(L"fixed not yet implemented in %S\r\n", __FUNCTION__);
            EfiStall(1000000);
            Status = STATUS_NOT_IMPLEMENTED;
            goto Exit;
        }
        else
        {
            /* Check if kernel range was specifically requested */
            if (Attributes & BlMemoryKernelRange)
            {
                /* Use the kernel range */
                Request.VirtualRange.Minimum = MmArchKsegAddressRange.Minimum >> PAGE_SHIFT;
                Request.VirtualRange.Maximum = MmArchKsegAddressRange.Maximum >> PAGE_SHIFT;
            }
            else
            {
                /* Set the virtual address range */
                Request.VirtualRange.Minimum = 0;
                Request.VirtualRange.Maximum = 0xFFFFFFFF >> PAGE_SHIFT;
            }
        }
 
        /* Check what type of allocation was requested */
        if ((Type) && !(Type & ~(BL_MM_REQUEST_DEFAULT_TYPE |
                               BL_MM_REQUEST_TOP_DOWN_TYPE)))
        {
            /* Save it if it was valid */
            Request.Type = Type;
        }
        else
        {
            /* Set the default */
            Request.Type = BL_MM_REQUEST_DEFAULT_TYPE;
        }
 
        /* Fill out the request of the request */
        Request.Flags = Attributes;
        Request.Alignment = Alignment;
        Request.Pages = Pages;
 
        /* Try to allocate the pages */
        Status = MmPaAllocatePages(List,
                                   &Descriptor,
                                   &MmMdlMappedUnallocated,
                                   &Request,
                                   MemoryType);
        if (!NT_SUCCESS(Status))
        {
            /* Extend the physical allocator */
            Status = MmPapPageAllocatorExtend(Attributes,
                                              Alignment,
                                              Pages,
                                              ((ULONG_PTR)*PhysicalAddress) >>
                                              PAGE_SHIFT,
                                              Range,
                                              Type);
            if (!NT_SUCCESS(Status))
            {
                /* Fail since we're out of memory */
                EfiPrintf(L"EXTEND OUT OF MEMORY: %lx\r\n", Status);
                Status = STATUS_NO_MEMORY;
                goto Exit;
            }
 
            /* Try the allocation again now */
            Status = MmPaAllocatePages(&MmMdlMappedAllocated,
                                       &Descriptor,
                                       &MmMdlMappedUnallocated,
                                       &Request,
                                       MemoryType);
            if (!NT_SUCCESS(Status))
            {
                /* Fail since we're out of memory */
                EfiPrintf(L"PALLOC OUT OF MEMORY: %lx\r\n", Status);
                goto Exit;
            }
        }
 
        /* Return the allocated address */
        *PhysicalAddress = (PVOID)((ULONG_PTR)Descriptor.VirtualPage << PAGE_SHIFT);
    }
    else
    {
        /* Check if this is a fixed allocation */
        BaseAddress.QuadPart = (Attributes & BlMemoryFixed) ?
                                (ULONG_PTR)*PhysicalAddress : 0;
 
        /* Allocate the pages */
        Status = MmPapAllocatePhysicalPagesInRange(&BaseAddress,
                                                   MemoryType,
                                                   Pages,
                                                   Attributes,
                                                   Alignment,
                                                   (&MmMdlMappedAllocated !=
                                                    &MmMdlPersistentMemory) ?
                                                   &MmMdlUnmappedAllocated :
                                                   &MmMdlMappedAllocated,
                                                   Range,
                                                   Type);
 
        /* Return the allocated address */
        *PhysicalAddress = PhysicalAddressToPtr(BaseAddress);
    }
 
Exit:
    /* Restore the nesting depth */
    MmMdFreeGlobalDescriptors();
    --MmDescriptorCallTreeCount;
    return Status;
}

Referenced by BiLoadHive(), BlImgAllocateImageBuffer(), BlockIopAllocateAlignedBuffer(), BlockIopInitialize(), ImgArchEfiStartBootApplication(), MmFwGetMemoryMap(), and MmHapHeapAllocatorExtend().

◆ MmPapAllocatePhysicalPagesInRange()

NTSTATUS MmPapAllocatePhysicalPagesInRange	(	_Inout_ PPHYSICAL_ADDRESS	BaseAddress,
		_In_ BL_MEMORY_TYPE	MemoryType,
		_In_ ULONGLONG	Pages,
		_In_ ULONG	Attributes,
		_In_ ULONG	Alignment,
		_In_ PBL_MEMORY_DESCRIPTOR_LIST	NewList,
		_In_opt_ PBL_ADDRESS_RANGE	Range,
		_In_ ULONG	RangeType
	)

Definition at line 438 of file pagealloc.c.

{
    NTSTATUS Status;
    BL_PA_REQUEST Request;
    BL_MEMORY_DESCRIPTOR Descriptor;
 
    /* Increase nesting depth */
    ++MmDescriptorCallTreeCount;
 
    /* Bail out if no address was specified */
    if (!BaseAddress)
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Bail out if no page count was passed in, or a bad list was specified  */
    if (!(Pages) ||
        ((NewList != &MmMdlUnmappedAllocated) &&
         (NewList != &MmMdlPersistentMemory)))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Bail out if the passed in range is invalid */
    if ((Range) && (Range->Minimum >= Range->Maximum))
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Adjust alignment as needed */
    if (!Alignment)
    {
        Alignment = 1;
    }
 
    /* Clear the virtual range */
    Request.VirtualRange.Minimum = 0;
    Request.VirtualRange.Maximum = 0;
 
    /* Check if a fixed allocation was requested*/
    if (Attributes & BlMemoryFixed)
    {
        /* Force the only available range to be the passed in address */
        Request.BaseRange.Minimum = BaseAddress->QuadPart >> PAGE_SHIFT;
        Request.BaseRange.Maximum = Request.BaseRange.Minimum + Pages - 1;
    }
    else if (Range)
    {
        /* Otherwise, a manual range was specified, use it */
        Request.BaseRange.Minimum = Range->Minimum >> PAGE_SHIFT;
        Request.BaseRange.Maximum = Request.BaseRange.Minimum +
                                    (Range->Maximum >> PAGE_SHIFT) - 1;
    }
    else
    {
        /* Otherwise, use any possible range of pages */
        Request.BaseRange.Minimum = PapMinimumPhysicalPage;
        Request.BaseRange.Maximum = MAXULONG >> PAGE_SHIFT;
    }
 
    /* Check if no type was specified, or if it was invalid */
    if (!(RangeType) ||
         (RangeType & ~(BL_MM_REQUEST_TOP_DOWN_TYPE | BL_MM_REQUEST_DEFAULT_TYPE)))
    {
        /* Use default type */
        Request.Type = BL_MM_REQUEST_DEFAULT_TYPE;
    }
    else
    {
        /* Use the requested type */
        Request.Type = RangeType;
    }
 
    /* Capture the other request parameters */
    Request.Alignment = Alignment;
    Request.Pages = Pages;
    Request.Flags = Attributes;
    Status = MmPaAllocatePages(NewList,
                               &Descriptor,
                               &MmMdlUnmappedUnallocated,
                               &Request,
                               MemoryType);
    if (NT_SUCCESS(Status))
    {
        /* We got a descriptor back, return its address */
        BaseAddress->QuadPart = Descriptor.BasePage << PAGE_SHIFT;
    }
 
Quickie:
    /* Restore the nesting depth */
    MmMdFreeGlobalDescriptors();
    --MmDescriptorCallTreeCount;
    return Status;
}

Referenced by BlMmAllocatePhysicalPages(), BmFwMemoryInitialize(), MmDefInitializeTranslation(), MmDefpMapPhysicalAddress(), and MmPapAllocatePagesInRange().

◆ MmPapFreePages()

NTSTATUS MmPapFreePages	(	_In_ PVOID	Address,
		_In_ ULONG	WhichList
	)

Definition at line 1196 of file pagealloc.c.

{
    PHYSICAL_ADDRESS PhysicalAddress;
 
    /* Handle virtual memory scenario */
    if (MmTranslationType != BlNone)
    {
        EfiPrintf(L"Unimplemented free virtual path: %p %lx\r\n", Address, WhichList);
        return STATUS_SUCCESS;
    }
 
    /* Physical memory should be in the unmapped allocated list */
    if (WhichList != BL_MM_INCLUDE_PERSISTENT_MEMORY)
    {
        WhichList = BL_MM_INCLUDE_UNMAPPED_ALLOCATED;
    }
 
    /* Free it from there */
    PhysicalAddress.QuadPart = (ULONG_PTR)Address;
    return MmPapFreePhysicalPages(WhichList, 0, PhysicalAddress);
}

Referenced by BiCloseKey(), BiLoadHive(), BlImgLoadImageWithProgress2(), BlImgUnallocateImageBuffer(), BlockIopFreeAlignedBuffer(), BlockIopInitialize(), ImgArchEfiStartBootApplication(), ImgpCloseFile(), ImgpLoadPEImage(), and MmFwGetMemoryMap().

◆ MmPaReleaseSelfMapPages()

NTSTATUS MmPaReleaseSelfMapPages ( _In_ PHYSICAL_ADDRESS Address )

Definition at line 1505 of file pagealloc.c.

{
    PBL_MEMORY_DESCRIPTOR Descriptor;
    ULONGLONG BasePage;
    NTSTATUS Status;
 
    /* Only page-aligned addresses are accepted */
    if (Address.QuadPart & (PAGE_SIZE - 1))
    {
        EfiPrintf(L"free mem fail 1\r\n");
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get the base page, and find a descriptor that matches */
    BasePage = Address.QuadPart >> PAGE_SHIFT;
    Descriptor = MmMdFindDescriptor(BL_MM_INCLUDE_UNMAPPED_UNALLOCATED,
                                    BL_MM_REMOVE_PHYSICAL_REGION_FLAG,
                                    BasePage);
    if (!(Descriptor) || (Descriptor->BasePage != BasePage))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Free the physical pages */
    Status = MmFwFreePages(BasePage, Descriptor->PageCount);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Remove the firmware flags */
    Descriptor->Flags &= ~(BlMemoryNonFirmware |
                           BlMemoryFirmware |
                           BlMemoryPersistent);
 
    /* Set it as free memory */
    Descriptor->Type = BlConventionalMemory;
 
    /* Create a new descriptor that's free memory, covering the old range */
    Descriptor = MmMdInitByteGranularDescriptor(0,
                                                BlConventionalMemory,
                                                BasePage,
                                                0,
                                                Descriptor->PageCount);
    if (!Descriptor)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Insert it into the virtual free list */
    return MmMdAddDescriptorToList(&MmMdlFreeVirtual,
                                   Descriptor,
                                   BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG |
                                   BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG);
}

Referenced by MmDefInitializeTranslation().

◆ MmPaReserveSelfMapPages()

NTSTATUS MmPaReserveSelfMapPages	(	_Inout_ PPHYSICAL_ADDRESS	PhysicalAddress,
		_In_ ULONG	Alignment,
		_In_ ULONG	PageCount
	)

Definition at line 1564 of file pagealloc.c.

{
    NTSTATUS Status;
    BL_PA_REQUEST Request;
    BL_MEMORY_DESCRIPTOR Descriptor;
 
    /* Increment descriptor usage count */
    ++MmDescriptorCallTreeCount;
 
    /* Bail if we don't have an address */
    if (!PhysicalAddress)
    {
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Make a request for the required number of self-map pages */
    Request.BaseRange.Minimum = PapMinimumPhysicalPage;
    Request.BaseRange.Maximum = 0xFFFFFFFF >> PAGE_SHIFT;
    Request.VirtualRange.Minimum = 0;
    Request.VirtualRange.Maximum = 0;
    Request.Pages = PageCount;
    Request.Alignment = Alignment;
    Request.Type = BL_MM_REQUEST_DEFAULT_TYPE;
    Request.Flags = 0;
    Status = MmPaAllocatePages(&MmMdlUnmappedUnallocated,
                               &Descriptor,
                               &MmMdlUnmappedUnallocated,
                               &Request,
                               BlLoaderSelfMap);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Remove this region from free virtual memory */
    Status = MmMdRemoveRegionFromMdlEx(&MmMdlFreeVirtual,
                                       BL_MM_REMOVE_VIRTUAL_REGION_FLAG,
                                       Descriptor.BasePage,
                                       Descriptor.PageCount,
                                       0);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Return the physical address */
    PhysicalAddress->QuadPart = Descriptor.BasePage << PAGE_SHIFT;
 
Quickie:
    /* Free global descriptors and reduce the count by one */
    MmMdFreeGlobalDescriptors();
    --MmDescriptorCallTreeCount;
    return Status;
}

Referenced by MmDefInitializeTranslation().

◆ MmPaTruncateMemory()

NTSTATUS MmPaTruncateMemory ( _In_ ULONGLONG BasePage )

Definition at line 51 of file pagealloc.c.

{
    NTSTATUS Status;
 
    /* Increase nesting depth */
    ++MmDescriptorCallTreeCount;
 
    /* Set the maximum page to the truncated request */
    if (BasePage < PapMaximumPhysicalPage)
    {
        PapMaximumPhysicalPage = BasePage;
    }
 
    /* Truncate mapped and allocated memory */
    Status = MmMdTruncateDescriptors(&MmMdlMappedAllocated,
                                     &MmMdlTruncatedMemory,
                                     BasePage);
    if (NT_SUCCESS(Status))
    {
        /* Truncate unmapped and allocated memory */
        Status = MmMdTruncateDescriptors(&MmMdlUnmappedAllocated,
                                         &MmMdlTruncatedMemory,
                                         BasePage);
        if (NT_SUCCESS(Status))
        {
            /* Truncate mapped and unallocated memory */
            Status = MmMdTruncateDescriptors(&MmMdlMappedUnallocated,
                                             &MmMdlTruncatedMemory,
                                             BasePage);
            if (NT_SUCCESS(Status))
            {
                /* Truncate unmapped and unallocated memory */
                Status = MmMdTruncateDescriptors(&MmMdlUnmappedUnallocated,
                                                 &MmMdlTruncatedMemory,
                                                 BasePage);
                if (NT_SUCCESS(Status))
                {
                    /* Truncate reserved memory */
                    Status = MmMdTruncateDescriptors(&MmMdlReservedAllocated,
                                                     &MmMdlTruncatedMemory,
                                                     BasePage);
                }
            }
        }
    }
 
    /* Restore the nesting depth */
    MmMdFreeGlobalDescriptors();
    --MmDescriptorCallTreeCount;
    return Status;
}

Referenced by BlpMmInitializeConstraints(), and MmDefInitializeTranslation().

◆ MmSelectMappingAddress()

NTSTATUS MmSelectMappingAddress	(	_Out_ PVOID *	MappingAddress,
		_In_ PVOID	PreferredAddress,
		_In_ ULONGLONG	Size,
		_In_ ULONG	AllocationAttributes,
		_In_ ULONG	Flags,
		_In_ PHYSICAL_ADDRESS	PhysicalAddress
	)

Definition at line 1625 of file pagealloc.c.

{
    BL_PA_REQUEST Request;
    NTSTATUS Status;
    BL_MEMORY_DESCRIPTOR NewDescriptor;
 
    /* Are we in physical mode? */
    if (MmTranslationType == BlNone)
    {
        /* Just return the physical address as the mapping address */
        PreferredAddress = PhysicalAddressToPtr(PhysicalAddress);
        goto Success;
    }
 
    /* If no physical address, or caller wants a fixed address... */
    if ((PhysicalAddress.QuadPart == -1) || (Flags & BlMemoryFixed))
    {
        /* Then just return the preferred address */
        goto Success;
    }
 
    /* Check which range of virtual memory should be used */
    if (AllocationAttributes & BlMemoryKernelRange)
    {
        /* Use kernel range */
        Request.BaseRange.Minimum = MmArchKsegAddressRange.Minimum >> PAGE_SHIFT;
        Request.BaseRange.Maximum = MmArchKsegAddressRange.Maximum >> PAGE_SHIFT;
        Request.Type = BL_MM_REQUEST_DEFAULT_TYPE;
    }
    else
    {
        /* User user/application range */
        Request.BaseRange.Minimum = 0 >> PAGE_SHIFT;
        Request.BaseRange.Maximum = MmArchTopOfApplicationAddressSpace >> PAGE_SHIFT;
        Request.Type = BL_MM_REQUEST_TOP_DOWN_TYPE;
    }
 
    /* Build a request */
    Request.VirtualRange.Minimum = 0;
    Request.VirtualRange.Maximum = 0;
    Request.Flags = AllocationAttributes & BlMemoryLargePages;
    Request.Alignment = 1;
    Request.Pages = ADDRESS_AND_SIZE_TO_SPAN_PAGES(PhysicalAddress.LowPart, Size);
 
    /* Allocate the physical pages */
    Status = MmPaAllocatePages(NULL,
                               &NewDescriptor,
                               &MmMdlFreeVirtual,
                               &Request,
                               BlConventionalMemory);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Return the address we got back */
    PreferredAddress = (PVOID)((ULONG_PTR)NewDescriptor.BasePage << PAGE_SHIFT);
 
    /* Check if the existing physical address was not aligned */
    if (PhysicalAddress.QuadPart != -1)
    {
        /* Add the offset to the returned virtual address */
        PreferredAddress = (PVOID)((ULONG_PTR)PreferredAddress +
                                   BYTE_OFFSET(PhysicalAddress.QuadPart));
    }
 
Success:
    /* Return the mapping address and success */
    *MappingAddress = PreferredAddress;
    return STATUS_SUCCESS;
}

Referenced by BlMmMapPhysicalAddressEx().

◆ MmUnmapVirtualAddress()

NTSTATUS MmUnmapVirtualAddress	(	_Inout_ PVOID *	VirtualAddress,
		_Inout_ PULONGLONG	Size
	)

Definition at line 453 of file mm.c.

{
    NTSTATUS Status;
 
    /* Make sure parameters were passed in and are valid */
    if ((VirtualAddress) && (Size) && (*Size <= 0xFFFFFFFF))
    {
        /* Nothing to do if translation isn't active */
        if (MmTranslationType == BlNone)
        {
            Status = STATUS_SUCCESS;
        }
        else
        {
            /* We don't support virtual memory yet @TODO */
            EfiPrintf(L"unmap not yet implemented in %S\r\n", __FUNCTION__);
            EfiStall(1000000);
            Status = STATUS_NOT_IMPLEMENTED;
        }
    }
    else
    {
        /* Fail */
        Status = STATUS_INVALID_PARAMETER;
    }
 
    /* All done */
    return Status;
}

Referenced by BlMmMapPhysicalAddressEx(), BlMmUnmapVirtualAddressEx(), and Mmx86MapInitStructure().

◆ PhysicalAddressToPtr()

FORCEINLINE PVOID PhysicalAddressToPtr ( _In_ PHYSICAL_ADDRESS PhysicalAddress )

Definition at line 1389 of file bl.h.

{
    return (PVOID)(ULONG_PTR)PhysicalAddress.QuadPart;
}

Referenced by BlImgAllocateImageBuffer(), EfiAllocatePages(), EfiConInExSetState(), EfiGetMemoryMap(), EfiGopGetCurrentMode(), EfiGopGetFrameBuffer(), EfiLocateHandleBuffer(), EfiVmOpenProtocol(), MmPapAllocatePagesInRange(), MmSelectMappingAddress(), and OslDrawLogo().

◆ TblDoNotPurgeEntry()

NTSTATUS TblDoNotPurgeEntry ( _In_ PVOID Entry )

Definition at line 495 of file util.c.

{
    /* Never purge this entry */
    return STATUS_UNSUCCESSFUL;
}

Referenced by BlHtCreate(), BlImgLoadBootApplication(), BlockIoFirmwareOpen(), BlpIoRegisterDestroyRoutine(), and EtfsMount().

Variable Documentation

◆ BlMmFlushTlb

PBL_MM_FLUSH_TLB BlMmFlushTlb

extern

Definition at line 48 of file mmx86.c.

Referenced by MmArchInitialize().

◆ BlMmMoveVirtualAddressRange

PBL_MM_MOVE_VIRTUAL_ADDRESS_RANGE BlMmMoveVirtualAddressRange

extern

Definition at line 17 of file arch.c.

Referenced by MmArchInitialize(), and OslArchKernelSetup().

◆ BlMmRelocateSelfMap

PBL_MM_RELOCATE_SELF_MAP BlMmRelocateSelfMap

extern

Definition at line 16 of file arch.c.

Referenced by MmArchInitialize(), and OslArchKernelSetup().

◆ BlMmZeroVirtualAddressRange

PBL_MM_ZERO_VIRTUAL_ADDRESS_RANGE BlMmZeroVirtualAddressRange

extern

Definition at line 18 of file arch.c.

Referenced by MmArchInitialize(), and OslArchKernelSetup().

◆ BlpApplicationEntry

BL_LOADED_APPLICATION_ENTRY BlpApplicationEntry

extern

◆ BlpApplicationFlags

ULONG BlpApplicationFlags

extern

Definition at line 21 of file bootlib.c.

Referenced by ArchInitializeContext(), BmFwVerifySelfIntegrity(), and EfiInitCreateInputParametersEx().

◆ BlpBootDevice

PBL_DEVICE_DESCRIPTOR BlpBootDevice

extern

Definition at line 16 of file bootlib.c.

Referenced by BlpDeviceOpen(), BmFwInitializeBootDirectoryPath(), BmFwVerifySelfIntegrity(), BmpInitializeBootStatusDataLog(), DsppLoadFontFile(), ImgpInitializeBootApplicationParameters(), InitializeLibrary(), MmFwGetMemoryMap(), and OslPrepareTarget().

◆ BlpLibraryParameters

BL_LIBRARY_PARAMETERS BlpLibraryParameters

extern

Definition at line 15 of file bootlib.c.

Referenced by ArchInitializeContext(), BlInitializeLibrary(), BmMain(), DsppInitialize(), DsppLoadFontFile(), InitializeLibrary(), MmFwGetMemoryMap(), MmHapAddToFreeList(), and MmPapFreePhysicalPages().

◆ BlpStatusErrorHandler

PBL_STATUS_ERROR_HANDLER BlpStatusErrorHandler

extern

Definition at line 20 of file debug.c.

Referenced by BlStatusError(), and OslPrepareTarget().

◆ BlpTimePerformanceFrequency

ULONGLONG BlpTimePerformanceFrequency

extern

Definition at line 15 of file time.c.

Referenced by BlpTimeCalibratePerformanceCounter(), BlpTimeMeasureTscFrequency(), BlTimeQueryPerformanceCounter(), and InitializeLibrary().

◆ BlScratchBuffer

WCHAR BlScratchBuffer[8192]

extern

Definition at line 39 of file firmware.c.

Referenced by BlStatusPrint(), and EfiPrintf().

◆ ConsoleGraphicalResolutionList

BL_DISPLAY_MODE ConsoleGraphicalResolutionList[]

extern

Definition at line 22 of file display.c.

Referenced by ConsoleEfiGopOpen(), and DsppInitialize().

◆ ConsoleGraphicalResolutionListFlags

ULONG ConsoleGraphicalResolutionListFlags

extern

Definition at line 21 of file display.c.

Referenced by ConsoleEfiGopOpen(), DsppInitialize(), and DsppReinitialize().

◆ ConsoleGraphicalResolutionListSize

ULONG ConsoleGraphicalResolutionListSize

extern

Definition at line 28 of file display.c.

Referenced by ConsoleEfiGopOpen().

◆ ConsoleTextResolutionList

BL_DISPLAY_MODE ConsoleTextResolutionList[]

extern

Definition at line 30 of file display.c.

Referenced by ConsoleFirmwareTextOpen().

◆ CurrentExecutionContext

PBL_ARCH_CONTEXT CurrentExecutionContext

extern

Definition at line 17 of file arch.c.

Referenced by ArchInitializeContexts(), BlMmIsTranslationEnabled(), BlockIoFirmwareRead(), BlpArchEnableTranslation(), BlpArchSwitchContext(), ConsoleFirmwareTextClear(), EfiAllocatePages(), EfiCloseProtocol(), EfiConInExReset(), EfiConInExSetState(), EfiConInReset(), EfiConnectController(), EfiConOutEnableCursor(), EfiConOutOutputString(), EfiConOutQueryMode(), EfiConOutReadCurrentMode(), EfiConOutSetAttribute(), EfiConOutSetCursorPosition(), EfiConOutSetMode(), EfiFreePages(), EfiGetMemoryMap(), EfiGetVariable(), EfiGopGetCurrentMode(), EfiGopGetFrameBuffer(), EfiGopSetMode(), EfiLocateHandleBuffer(), EfiOpenProtocol(), EfiPrintf(), EfiResetSystem(), EfiSetWatchdogTimer(), EfiStall(), EfiVmOpenProtocol(), EfiVmpCloseProtocol(), MmArchTranslateVirtualAddress(), MmFwGetMemoryMap(), and MmMapPhysicalAddress().

◆ DspLocalInputConsole

PVOID DspLocalInputConsole

extern

Definition at line 38 of file display.c.

Referenced by BlpDisplayReinitialize(), ConsoleCreateLocalInputConsole(), and DsppReinitialize().

◆ DspRemoteInputConsole

PVOID DspRemoteInputConsole

extern

Definition at line 35 of file display.c.

Referenced by ConsoleCreateRemoteConsole(), DsppInitialize(), and DsppReinitialize().

◆ EfiBlockIoProtocol

EFI_GUID EfiBlockIoProtocol

extern

Definition at line 33 of file firmware.c.

Referenced by BlFwEnumerateDevice(), BlockIoEfiGetBlockIoInformation(), BlockIoEfiGetChildHandle(), BlockIoFirmwareOpen(), BlockIoFirmwareRead(), and DiskClose().

◆ EfiConInEx

EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL* EfiConInEx

extern

Definition at line 25 of file firmware.c.

Referenced by BlpFwInitialize(), ConsoleInputLocalEraseBuffer(), and EfiConInExReset().

◆ EfiConOut

EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL* EfiConOut

extern

Definition at line 23 of file firmware.c.

Referenced by BlpFwInitialize(), ConsoleFirmwareTextOpen(), and EfiPrintf().

◆ EfiDevicePathProtocol

EFI_GUID EfiDevicePathProtocol

extern

Definition at line 31 of file firmware.c.

Referenced by BlFwEnumerateDevice(), BlockIoEfiGetChildHandle(), BlockIoEfiGetDeviceInformation(), ConsoleEfiGraphicalOpenProtocol(), and EfiInitCreateInputParametersEx().

◆ EfiGlobalVariable

EFI_GUID EfiGlobalVariable

extern

Definition at line 36 of file firmware.c.

Referenced by BlpSecureBootEFIIsEnabled().

◆ EfiGraphicsOutputProtocol

EFI_GUID EfiGraphicsOutputProtocol

extern

Definition at line 28 of file firmware.c.

Referenced by ConsoleEfiGopClose(), ConsoleEfiGopOpen(), ConsoleEfiGraphicalOpenProtocol(), OslDrawLogo(), and UefiInitializeVideo().

◆ EfiLoadedImageProtocol

EFI_GUID EfiLoadedImageProtocol

extern

Definition at line 30 of file firmware.c.

Referenced by EfiInitCreateInputParametersEx(), and UefiMemGetMemoryMap().

◆ EfiRootAcpiTable10Guid

EFI_GUID EfiRootAcpiTable10Guid

extern

Definition at line 35 of file firmware.c.

Referenced by EfipGetRsdt().

◆ EfiRootAcpiTableGuid

EFI_GUID EfiRootAcpiTableGuid

extern

Definition at line 34 of file firmware.c.

Referenced by EfipGetRsdt().

◆ EfiSimpleTextInputExProtocol

EFI_GUID EfiSimpleTextInputExProtocol

extern

Definition at line 32 of file firmware.c.

Referenced by BlpFwInitialize().

◆ EfiUgaDrawProtocol

EFI_GUID EfiUgaDrawProtocol

extern

Definition at line 29 of file firmware.c.

Referenced by ConsoleEfiGraphicalOpenProtocol().

◆ MmArchKsegAddressRange

BL_ADDRESS_RANGE MmArchKsegAddressRange

extern

Definition at line 29 of file mmx86.c.

Referenced by MmArchInitialize(), MmPapAllocatePagesInRange(), and MmSelectMappingAddress().

◆ MmArchTopOfApplicationAddressSpace

ULONG_PTR MmArchTopOfApplicationAddressSpace

extern

Definition at line 30 of file mmx86.c.

Referenced by MmArchInitialize(), and MmSelectMappingAddress().

◆ MmDescriptorCallTreeCount

ULONG MmDescriptorCallTreeCount

extern

Definition at line 19 of file mm.c.

Referenced by BlMmMapPhysicalAddressEx(), BlMmUnmapVirtualAddressEx(), BlpMmInitialize(), MmFwGetMemoryMap(), MmMdCopyList(), MmMdFreeGlobalDescriptors(), MmPapAllocatePagesInRange(), MmPapAllocatePhysicalPagesInRange(), MmPaReserveSelfMapPages(), MmPaTruncateMemory(), and TrpGenerateMappingTracker().

◆ MmMdlBadMemory

BL_MEMORY_DESCRIPTOR_LIST MmMdlBadMemory

extern

Definition at line 41 of file pagealloc.c.

Referenced by BlMmGetMemoryMap(), MmMdFindDescriptor(), and MmPaInitialize().

◆ MmMdlCompleteBadMemory

BL_MEMORY_DESCRIPTOR_LIST MmMdlCompleteBadMemory

extern

Definition at line 44 of file pagealloc.c.

Referenced by MmPaInitialize().

◆ MmMdlFreeVirtual

BL_MEMORY_DESCRIPTOR_LIST MmMdlFreeVirtual

extern

Definition at line 45 of file pagealloc.c.

Referenced by BlMmMapPhysicalAddressEx(), MmDefInitializeTranslation(), MmPaReleaseSelfMapPages(), MmPaReserveSelfMapPages(), MmSelectMappingAddress(), MmTrInitialize(), and Mmx86MapInitStructure().

◆ MmMdlFwAllocationTracker

BL_MEMORY_DESCRIPTOR_LIST MmMdlFwAllocationTracker

extern

Definition at line 37 of file pagealloc.c.

Referenced by MmPaInitialize(), and MmPapPageAllocatorExtend().

◆ MmMdlMappedAllocated

BL_MEMORY_DESCRIPTOR_LIST MmMdlMappedAllocated

extern

Definition at line 35 of file pagealloc.c.

Referenced by BlMmGetMemoryMap(), BlMmMapPhysicalAddressEx(), MmMdFindDescriptor(), MmMdListPointerToName(), MmPaInitialize(), MmPapAllocatePagesInRange(), and MmPaTruncateMemory().

◆ MmMdlMappedUnallocated

BL_MEMORY_DESCRIPTOR_LIST MmMdlMappedUnallocated

extern

Definition at line 36 of file pagealloc.c.

Referenced by BlMmGetMemoryMap(), BlMmMapPhysicalAddressEx(), MmMdFindDescriptor(), MmMdListPointerToName(), MmPaInitialize(), MmPapAllocatePagesInRange(), MmPapAllocateRegionFromMdl(), MmPapPageAllocatorExtend(), and MmPaTruncateMemory().

◆ MmMdlMappingTrackers

BL_MEMORY_DESCRIPTOR_LIST MmMdlMappingTrackers

extern

Definition at line 46 of file pagealloc.c.

Referenced by MmTrInitialize(), and TrpGenerateMappingTracker().

◆ MmMdlPersistentMemory

BL_MEMORY_DESCRIPTOR_LIST MmMdlPersistentMemory

extern

Definition at line 43 of file pagealloc.c.

Referenced by BlMmGetMemoryMap(), BlMmMapPhysicalAddressEx(), MmMdFindDescriptor(), MmPaInitialize(), MmPapAllocatePagesInRange(), and MmPapAllocatePhysicalPagesInRange().

◆ MmMdlReservedAllocated

BL_MEMORY_DESCRIPTOR_LIST MmMdlReservedAllocated

extern

Definition at line 40 of file pagealloc.c.

Referenced by BlMmGetMemoryMap(), BlMmMapPhysicalAddressEx(), MmMdFindDescriptor(), MmPaInitialize(), MmPaTruncateMemory(), and MmTrInitialize().

◆ MmMdlTruncatedMemory

BL_MEMORY_DESCRIPTOR_LIST MmMdlTruncatedMemory

extern

Definition at line 42 of file pagealloc.c.

Referenced by BlMmGetMemoryMap(), MmMdFindDescriptor(), MmPaInitialize(), and MmPaTruncateMemory().

◆ MmMdlUnmappedAllocated

BL_MEMORY_DESCRIPTOR_LIST MmMdlUnmappedAllocated

extern

Definition at line 38 of file pagealloc.c.

Referenced by BlMmAllocatePhysicalPages(), BlMmGetMemoryMap(), BlMmMapPhysicalAddressEx(), BmFwMemoryInitialize(), MmDefInitializeTranslation(), MmDefpMapPhysicalAddress(), MmMdFindDescriptor(), MmMdListPointerToName(), MmPaInitialize(), MmPapAllocatePagesInRange(), MmPapAllocatePhysicalPagesInRange(), MmPapFreePhysicalPages(), MmPapPageAllocatorExtend(), and MmPaTruncateMemory().

◆ MmMdlUnmappedUnallocated

BL_MEMORY_DESCRIPTOR_LIST MmMdlUnmappedUnallocated

extern

Definition at line 39 of file pagealloc.c.

Referenced by BlMmGetMemoryMap(), BlMmMapPhysicalAddressEx(), MmMdFindDescriptor(), MmMdListPointerToName(), MmPaInitialize(), MmPapAllocatePhysicalPagesInRange(), MmPapAllocateRegionFromMdl(), MmPapFreePhysicalPages(), MmPapPageAllocatorExtend(), MmPaReserveSelfMapPages(), and MmPaTruncateMemory().

◆ MmTranslationType

BL_TRANSLATION_TYPE MmTranslationType

extern

Definition at line 17 of file mm.c.

Referenced by BlMmMapPhysicalAddressEx(), BlMmUnmapVirtualAddressEx(), BlpMmInitialize(), EfiCloseProtocol(), EfiOpenProtocol(), ImgpInitializeBootApplicationParameters(), MmMapPhysicalAddress(), MmPapAllocatePagesInRange(), MmPapFreePages(), MmSelectMappingAddress(), MmTrInitialize(), MmUnmapVirtualAddress(), and Mmx86MapInitStructure().

◆ RegisteredFileSystems

LIST_ENTRY RegisteredFileSystems

extern

Definition at line 18 of file file.c.

Referenced by BlpFileInitialize(), BlpFileRegisterFileSystem(), and FileIoOpen().

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BL_APP_ENTRY_SIGNATURE

◆ BL_APPLICATION_ENTRY_BCD_OPTIONS_EXTERNAL

◆ BL_APPLICATION_ENTRY_BCD_OPTIONS_INTERNAL

◆ BL_APPLICATION_ENTRY_BOOTMGR

◆ BL_APPLICATION_ENTRY_BOOTSECTOR

◆ BL_APPLICATION_ENTRY_DISPLAY_ORDER

◆ BL_APPLICATION_ENTRY_FIXED_SEQUENCE

◆ BL_APPLICATION_ENTRY_FLAG_NO_GUID

◆ BL_APPLICATION_ENTRY_NTLDR

◆ BL_APPLICATION_ENTRY_REBOOT_ON_ERROR

◆ BL_APPLICATION_ENTRY_RECOVERY

◆ BL_APPLICATION_ENTRY_SETUPLDR

◆ BL_APPLICATION_ENTRY_STARTUP

◆ BL_APPLICATION_ENTRY_WINLOAD

◆ BL_APPLICATION_ENTRY_WINRESUME

◆ BL_APPLICATION_FLAG_CONVERTED_FROM_EFI

◆ BL_BLOCK_DEVICE_PRESENT_FLAG

◆ BL_BLOCK_DEVICE_REMOVABLE_FLAG

◆ BL_BLOCK_DEVICE_VIRTUAL_FLAG

◆ BL_CONTEXT_INTERRUPTS_ON

◆ BL_CONTEXT_PAGING_ON

◆ BL_DEVICE_ENTRY_OPENED

◆ BL_DEVICE_ENTRY_READ_ACCESS

◆ BL_DEVICE_ENTRY_WRITE_ACCESS

◆ BL_DEVICE_READ_ACCESS

◆ BL_DEVICE_WRITE_ACCESS

◆ BL_DIRECTORY_ACCESS

◆ BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG

◆ BL_DISPLAY_GRAPHICS_FORCED_VIDEO_MODE_FLAG

◆ BL_ETFS_FILE_ENTRY_DIRECTORY

◆ BL_FILE_ENTRY_DIRECTORY

◆ BL_FILE_ENTRY_OPENED

◆ BL_FILE_ENTRY_READ_ACCESS

◆ BL_FILE_ENTRY_UNKNOWN_ACCESS

◆ BL_FILE_ENTRY_WRITE_ACCESS

◆ BL_FILE_READ_ACCESS

◆ BL_FILE_WRITE_ACCESS

◆ BL_FIRMWARE_DESCRIPTOR_VERSION

◆ BL_FS_REGISTER_AT_HEAD_FLAG

◆ BL_HT_VALUE_IS_INLINE

◆ BL_IMG_MEMORY_FILE

◆ BL_IMG_REMOTE_FILE

◆ BL_IMG_VALID_FILE

◆ BL_LIBRARY_FLAG_INITIALIZATION_COMPLETED

◆ BL_LIBRARY_FLAG_NO_DISPLAY

◆ BL_LIBRARY_FLAG_NO_GRAPHICS_CONSOLE

◆ BL_LIBRARY_FLAG_REINITIALIZE

◆ BL_LIBRARY_FLAG_REINITIALIZE_ALL

◆ BL_LIBRARY_FLAG_ZERO_HEAP_ALLOCATIONS_ON_FREE

◆ BL_LOAD_IMG_COMPUTE_HASH

◆ BL_LOAD_IMG_COMPUTE_SIGNATURE

◆ BL_LOAD_IMG_EXISTING_BUFFER

◆ BL_LOAD_IMG_UNKNOWN_BUFFER_FLAG

◆ BL_LOAD_IMG_VIRTUAL_BUFFER

◆ BL_LOAD_PE_IMG_CHECK_FORCED_INTEGRITY

◆ BL_LOAD_PE_IMG_CHECK_MACHINE

◆ BL_LOAD_PE_IMG_CHECK_SUBSYSTEM

◆ BL_LOAD_PE_IMG_COMPUTE_HASH

◆ BL_LOAD_PE_IMG_EXISTING_BUFFER

◆ BL_LOAD_PE_IMG_IGNORE_CHECKSUM_MISMATCH

◆ BL_LOAD_PE_IMG_SKIP_RELOCATIONS

◆ BL_LOAD_PE_IMG_VALIDATE_ORIGINAL_FILENAME

◆ BL_LOAD_PE_IMG_VIRTUAL_BUFFER

◆ BL_MEMORY_CLASS_SHIFT

◆ BL_MEMORY_DATA_VERSION

◆ BL_MM_ADD_DESCRIPTOR_ALLOCATE_FLAG

◆ BL_MM_ADD_DESCRIPTOR_COALESCE_FLAG

◆ BL_MM_ADD_DESCRIPTOR_NEVER_COALESCE_FLAG

◆ BL_MM_ADD_DESCRIPTOR_NEVER_TRUNCATE_FLAG

◆ BL_MM_ADD_DESCRIPTOR_TRUNCATE_FLAG

◆ BL_MM_ADD_DESCRIPTOR_UPDATE_LIST_POINTER_FLAG

◆ BL_MM_FLAG_REQUEST_COALESCING

◆ BL_MM_FLAG_USE_FIRMWARE_FOR_MEMORY_MAP_BUFFERS