uefimem.c File Reference

#include <uefildr.h>
#include <debug.h>

Include dependency graph for uefimem.c:

Go to the source code of this file.

Macros
#define	NEXT_MEMORY_DESCRIPTOR(Descriptor, DescriptorSize)    (EFI_MEMORY_DESCRIPTOR*)((char*)(Descriptor) + (DescriptorSize))
#define	EXIT_STACK_SIZE   0x1000
#define	UNUSED_MAX_DESCRIPTOR_COUNT   10000

Functions
	DBG_DEFAULT_CHANNEL (WARNING)
ULONG	AddMemoryDescriptor (_Inout_ PFREELDR_MEMORY_DESCRIPTOR List, _In_ ULONG MaxCount, _In_ PFN_NUMBER BasePage, _In_ PFN_NUMBER PageCount, _In_ TYPE_OF_MEMORY MemoryType)
void	_exituefi (VOID)
static VOID	PUEFI_LoadMemoryMap (_Out_ UINTN *LocMapKey, _Out_ UINTN *LocMapSize, _Out_ UINTN *LocDescriptorSize, _Out_ UINT32 *LocDescriptorVersion)
static VOID	UefiSetMemory (_Inout_ PFREELDR_MEMORY_DESCRIPTOR MemoryMap, _In_ ULONG_PTR BaseAddress, _In_ PFN_COUNT SizeInPages, _In_ TYPE_OF_MEMORY MemoryType)
static TYPE_OF_MEMORY	UefiConvertToFreeldrDesc (EFI_MEMORY_TYPE EfiMemoryType)
PFREELDR_MEMORY_DESCRIPTOR	UefiMemGetMemoryMap (ULONG *MemoryMapSize)
VOID	UefiExitBootServices (VOID)
VOID	UefiPrepareForReactOS (VOID)

Variables
EFI_SYSTEM_TABLE *	GlobalSystemTable
EFI_HANDLE	GlobalImageHandle
EFI_MEMORY_DESCRIPTOR *	EfiMemoryMap = NULL
UINT32	FreeldrDescCount
PVOID	OsLoaderBase
SIZE_T	OsLoaderSize
EFI_HANDLE	PublicBootHandle
PVOID	ExitStack
PVOID	EndofExitStack

Macro Definition Documentation

EXIT_STACK_SIZE

#define EXIT_STACK_SIZE   0x1000

Definition at line 17 of file uefimem.c.

NEXT_MEMORY_DESCRIPTOR

#define NEXT_MEMORY_DESCRIPTOR	(		Descriptor,
			DescriptorSize
	)		(EFI_MEMORY_DESCRIPTOR*)((char*)(Descriptor) + (DescriptorSize))

Definition at line 15 of file uefimem.c.

UNUSED_MAX_DESCRIPTOR_COUNT

#define UNUSED_MAX_DESCRIPTOR_COUNT   10000

Definition at line 18 of file uefimem.c.

Function Documentation

_exituefi()

void _exituefi

(

VOID

)

Referenced by UefiPrepareForReactOS().

AddMemoryDescriptor()

ULONG AddMemoryDescriptor	(	_Inout_ PFREELDR_MEMORY_DESCRIPTOR	List,
		_In_ ULONG	MaxCount,
		_In_ PFN_NUMBER	BasePage,
		_In_ PFN_NUMBER	PageCount,
		_In_ TYPE_OF_MEMORY	MemoryType
	)

Referenced by UefiSetMemory().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

WARNING

)

PUEFI_LoadMemoryMap()

static VOID PUEFI_LoadMemoryMap ( _Out_ UINTN *  LocMapKey, _Out_ UINTN *  LocMapSize, _Out_ UINTN *  LocDescriptorSize, _Out_ UINT32 *  LocDescriptorVersion  )

static

Definition at line 47 of file uefimem.c.

{
    EFI_STATUS Status;
    UINTN AllocationSize = 0;
    ULONG Count = 0;
 
    Status = GlobalSystemTable->BootServices->GetMemoryMap(LocMapSize,
                                                           EfiMemoryMap,
                                                           LocMapKey,
                                                           LocDescriptorSize,
                                                           LocDescriptorVersion);
 
    /* Reallocate and retrieve again the needed memory map size (since memory
     * allocated by AllocatePool() counts in the map), until it's OK. */
    while (Status != EFI_SUCCESS)
    {
        /* Reallocate the memory map buffer */
        if (EfiMemoryMap)
            GlobalSystemTable->BootServices->FreePool(EfiMemoryMap);
 
        /* If MapSize never reports the correct size after the first time, increment */
        AllocationSize = *LocMapSize + (*LocDescriptorSize * Count);
        GlobalSystemTable->BootServices->AllocatePool(EfiLoaderData, AllocationSize,
                                                      (VOID**)&EfiMemoryMap);
        Status = GlobalSystemTable->BootServices->GetMemoryMap(LocMapSize,
                                                               EfiMemoryMap,
                                                               LocMapKey,
                                                               LocDescriptorSize,
                                                               LocDescriptorVersion);
        Count++;
    }
}

Referenced by UefiExitBootServices(), and UefiMemGetMemoryMap().

UefiConvertToFreeldrDesc()

static TYPE_OF_MEMORY UefiConvertToFreeldrDesc ( EFI_MEMORY_TYPE  EfiMemoryType )

static

Definition at line 107 of file uefimem.c.

{
    switch (EfiMemoryType)
    {
        case EfiReservedMemoryType:
            return LoaderReserve;
        case EfiLoaderCode:
            return LoaderLoadedProgram;
        case EfiLoaderData:
            return LoaderLoadedProgram;
        case EfiBootServicesCode:
            return LoaderFirmwareTemporary;
        case EfiBootServicesData:
            return LoaderFirmwareTemporary;
        case EfiRuntimeServicesCode:
            return LoaderFirmwarePermanent;
        case EfiRuntimeServicesData:
            return LoaderFirmwarePermanent;
        case EfiConventionalMemory:
            return LoaderFree;
        case EfiUnusableMemory:
            return LoaderBad;
        case EfiACPIReclaimMemory:
            return LoaderFirmwareTemporary;
        case EfiACPIMemoryNVS:
            return LoaderReserve;
        case EfiMemoryMappedIO:
            return LoaderReserve;
        case EfiMemoryMappedIOPortSpace:
            return LoaderReserve;
        default:
            break;
    }
    return LoaderReserve;
}

Referenced by UefiMemGetMemoryMap().

UefiExitBootServices()

VOID UefiExitBootServices

(

VOID

)

Definition at line 237 of file uefimem.c.

{
    UINTN MapKey;
    UINTN MapSize;
    EFI_STATUS Status;
    UINTN DescriptorSize;
    UINT32 DescriptorVersion;
 
    TRACE("Attempting to exit bootsevices\n");
    PUEFI_LoadMemoryMap(&MapKey,
                        &MapSize,
                        &DescriptorSize,
                        &DescriptorVersion);
 
    Status = GlobalSystemTable->BootServices->ExitBootServices(GlobalImageHandle, MapKey);
    /* UEFI spec demands twice! */
    if (Status != EFI_SUCCESS)
        Status = GlobalSystemTable->BootServices->ExitBootServices(GlobalImageHandle, MapKey);
 
    if (Status != EFI_SUCCESS)
    {
        TRACE("Failed to exit boot services with status: %d\n", Status);
        FrLdrBugCheckWithMessage(EXIT_BOOTSERVICES_FAILURE,
                                 __FILE__,
                                 __LINE__,
                                 "Failed to exit boot services with status: %d",
                                 Status);
    }
    else
    {
        TRACE("Exited bootservices\n");
    }
}

UefiMemGetMemoryMap()

PFREELDR_MEMORY_DESCRIPTOR UefiMemGetMemoryMap

(

ULONG *

MemoryMapSize

)

Definition at line 144 of file uefimem.c.

{
    EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
    UINT32 DescriptorVersion;
    SIZE_T FreeldrMemMapSize;
    UINTN DescriptorSize;
    EFI_STATUS Status;
    UINTN MapSize;
    UINTN MapKey;
    UINT32 Index;
 
    EFI_GUID EfiLoadedImageProtocol = EFI_LOADED_IMAGE_PROTOCOL_GUID;
    PFREELDR_MEMORY_DESCRIPTOR FreeldrMem = NULL;
    EFI_MEMORY_DESCRIPTOR* MapEntry = NULL;
    UINT32 EntryCount = 0;
    FreeldrDescCount = 0;
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(GlobalImageHandle,
                                                             &EfiLoadedImageProtocol,
                                                             (VOID**)&LoadedImage);
    if (Status != EFI_SUCCESS)
    {
        TRACE("Failed to find LoadedImageHandle with status: %d\n", Status);
        UiMessageBoxCritical("Unable to initialize memory manager.");
        return NULL;
    }
    OsLoaderBase = LoadedImage->ImageBase;
    OsLoaderSize = LoadedImage->ImageSize;
    PublicBootHandle = LoadedImage->DeviceHandle;
    EfiMemoryMap = NULL;
 
    TRACE("UefiMemGetMemoryMap: Gather memory map\n");
    PUEFI_LoadMemoryMap(&MapKey,
                        &MapSize,
                        &DescriptorSize,
                        &DescriptorVersion);
 
    TRACE("Value of MapKey: %d\n", MapKey);
    TRACE("Value of MapSize: %d\n", MapSize);
    TRACE("Value of DescriptorSize: %d\n", DescriptorSize);
    TRACE("Value of DescriptorVersion: %d\n", DescriptorVersion);
 
    EntryCount = (MapSize / DescriptorSize);
 
    FreeldrMemMapSize = (sizeof(FREELDR_MEMORY_DESCRIPTOR) * EntryCount);
    Status = GlobalSystemTable->BootServices->AllocatePool(EfiLoaderData,
                                                           FreeldrMemMapSize,
                                                           (void**)&FreeldrMem);
    if (Status != EFI_SUCCESS)
    {
        TRACE("Failed to allocate pool with status %d\n", Status);
        UiMessageBoxCritical("Unable to initialize memory manager.");
        return NULL;
    }
 
    RtlZeroMemory(FreeldrMem, FreeldrMemMapSize);
    MapEntry = EfiMemoryMap;
    for (Index = 0; Index < EntryCount; ++Index)
    {
        TYPE_OF_MEMORY MemoryType = UefiConvertToFreeldrDesc(MapEntry->Type);
        if (MemoryType == LoaderFree)
        {
            Status = GlobalSystemTable->BootServices->AllocatePages(AllocateAddress,
                                                                    EfiLoaderData,
                                                                    MapEntry->NumberOfPages,
                                                                    &MapEntry->PhysicalStart);
            if (Status != EFI_SUCCESS)
            {
                /* We failed to reserve the page, so change its type */
                MemoryType = LoaderFirmwareTemporary;
            }
        }
 
        /* We really don't want to touch these reserved spots at all */
        if (MemoryType != LoaderReserve)
        {
            UefiSetMemory(FreeldrMem,
                          MapEntry->PhysicalStart,
                          MapEntry->NumberOfPages,
                          MemoryType);
        }
 
        MapEntry = NEXT_MEMORY_DESCRIPTOR(MapEntry, DescriptorSize);
    }
 
    /* Windows expects the first page to be reserved, otherwise it asserts.
     * However it can be just a free page on some UEFI systems. */
    UefiSetMemory(FreeldrMem, 0x000000, 1, LoaderFirmwarePermanent);
    *MemoryMapSize = FreeldrDescCount;
    return FreeldrMem;
}

Referenced by MachInit().

UefiPrepareForReactOS()

VOID UefiPrepareForReactOS

(

VOID

)

Definition at line 272 of file uefimem.c.

{
    _exituefi();
}

Referenced by MachInit().

UefiSetMemory()

static VOID UefiSetMemory ( _Inout_ PFREELDR_MEMORY_DESCRIPTOR  MemoryMap, _In_ ULONG_PTR  BaseAddress, _In_ PFN_COUNT  SizeInPages, _In_ TYPE_OF_MEMORY  MemoryType  )

static

Definition at line 86 of file uefimem.c.

{
    ULONG_PTR BasePage, PageCount;
 
    BasePage = BaseAddress / EFI_PAGE_SIZE;
    PageCount = SizeInPages;
 
    /* Add the memory descriptor */
    FreeldrDescCount = AddMemoryDescriptor(MemoryMap,
                                           UNUSED_MAX_DESCRIPTOR_COUNT,
                                           BasePage,
                                           PageCount,
                                           MemoryType);
}

Referenced by UefiMemGetMemoryMap().

Variable Documentation

EfiMemoryMap

EFI_MEMORY_DESCRIPTOR* EfiMemoryMap = NULL

Definition at line 33 of file uefimem.c.

Referenced by DetectAcpiBios(), PUEFI_LoadMemoryMap(), and UefiMemGetMemoryMap().

EndofExitStack

PVOID EndofExitStack

Definition at line 39 of file uefimem.c.

ExitStack

PVOID ExitStack

Definition at line 38 of file uefimem.c.

FreeldrDescCount

UINT32 FreeldrDescCount

Definition at line 34 of file uefimem.c.

Referenced by DetectAcpiBios(), UefiMemGetMemoryMap(), and UefiSetMemory().

GlobalImageHandle

EFI_HANDLE GlobalImageHandle

extern

Definition at line 15 of file uefildr.c.

Referenced by UefiExitBootServices(), and UefiMemGetMemoryMap().

GlobalSystemTable

EFI_SYSTEM_TABLE* GlobalSystemTable

extern

Definition at line 16 of file uefildr.c.

Referenced by PUEFI_LoadMemoryMap(), UefiExitBootServices(), and UefiMemGetMemoryMap().

OsLoaderBase

PVOID OsLoaderBase

Definition at line 35 of file uefimem.c.

Referenced by UefiMemGetMemoryMap(), and WinLdrSetupMemoryLayout().

OsLoaderSize

SIZE_T OsLoaderSize

Definition at line 36 of file uefimem.c.

Referenced by UefiMemGetMemoryMap(), and WinLdrSetupMemoryLayout().

PublicBootHandle

EFI_HANDLE PublicBootHandle

Definition at line 37 of file uefimem.c.

Referenced by UefiMemGetMemoryMap(), and UefiSetupBlockDevices().