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)
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 Size, _In_ TYPE_OF_MEMORY MemoryType)
VOID	ReserveMemory (_Inout_ PFREELDR_MEMORY_DESCRIPTOR MemoryMap, _In_ ULONG_PTR BaseAddress, _In_ PFN_NUMBER Size, _In_ TYPE_OF_MEMORY MemoryType, _In_ PCHAR Usage)
static TYPE_OF_MEMORY	UefiConvertToFreeldrDesc (EFI_MEMORY_TYPE EfiMemoryType)
PFREELDR_MEMORY_DESCRIPTOR	UefiMemGetMemoryMap (ULONG *MemoryMapSize)
static VOID	UefiExitBootServices (VOID)
VOID	UefiPrepareForReactOS (VOID)

Variables
EFI_SYSTEM_TABLE *	GlobalSystemTable
EFI_HANDLE	GlobalImageHandle
REACTOS_INTERNAL_BGCONTEXT	framebufferData
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

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 ReserveMemory(), and 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 46 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().

ReserveMemory()

VOID ReserveMemory	(	_Inout_ PFREELDR_MEMORY_DESCRIPTOR	MemoryMap,
		_In_ ULONG_PTR	BaseAddress,
		_In_ PFN_NUMBER	Size,
		_In_ TYPE_OF_MEMORY	MemoryType,
		_In_ PCHAR	Usage
	)

Definition at line 105 of file uefimem.c.

{
    ULONG_PTR BasePage, PageCount;
    ULONG i;
 
    BasePage = BaseAddress / PAGE_SIZE;
    PageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseAddress, Size);
 
    for (i = 0; i < FreeldrDescCount; i++)
    {
        /* Check for conflicting descriptor */
        if ((MemoryMap[i].BasePage < BasePage + PageCount) &&
            (MemoryMap[i].BasePage + MemoryMap[i].PageCount > BasePage))
        {
            /* Check if the memory is free */
            if (MemoryMap[i].MemoryType != LoaderFree)
            {
                FrLdrBugCheckWithMessage(
                    MEMORY_INIT_FAILURE,
                    __FILE__,
                    __LINE__,
                    "Failed to reserve memory in the range 0x%Ix - 0x%Ix for %s",
                    BaseAddress,
                    Size,
                    Usage);
            }
        }
    }
 
    /* Add the memory descriptor */
    FreeldrDescCount = AddMemoryDescriptor(MemoryMap,
                                           UNUSED_MAX_DESCRIPTOR_COUNT,
                                           BasePage,
                                           PageCount,
                                           MemoryType);
}

UefiConvertToFreeldrDesc()

static TYPE_OF_MEMORY UefiConvertToFreeldrDesc ( EFI_MEMORY_TYPE  EfiMemoryType )

static

Definition at line 149 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()

static VOID UefiExitBootServices ( VOID  )

static

Definition at line 272 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");
    }
}

Referenced by UefiPrepareForReactOS().

UefiMemGetMemoryMap()

PFREELDR_MEMORY_DESCRIPTOR UefiMemGetMemoryMap

(

ULONG *

MemoryMapSize

)

Definition at line 186 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;
            }
        }
 
        UefiSetMemory(FreeldrMem,
                      MapEntry->PhysicalStart,
                      MapEntry->NumberOfPages,
                      MemoryType);
 
        MapEntry = NEXT_MEMORY_DESCRIPTOR(MapEntry, DescriptorSize);
    }
 
    *MemoryMapSize = FreeldrDescCount;
    return FreeldrMem;
}

Referenced by MachInit().

UefiPrepareForReactOS()

VOID UefiPrepareForReactOS

(

VOID

)

Definition at line 307 of file uefimem.c.

{
    UefiExitBootServices();
    ExitStack = MmAllocateMemoryWithType(EXIT_STACK_SIZE, LoaderOsloaderStack);
    EndofExitStack = (PVOID)((ULONG_PTR)ExitStack + EXIT_STACK_SIZE);
}

Referenced by MachInit().

UefiSetMemory()

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

static

Definition at line 85 of file uefimem.c.

{
    ULONG_PTR BasePage, PageCount;
 
    BasePage = BaseAddress / EFI_PAGE_SIZE;
    PageCount = Size;
 
    /* 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 34 of file uefimem.c.

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

EndofExitStack

PVOID EndofExitStack

Definition at line 40 of file uefimem.c.

Referenced by UefiPrepareForReactOS().

ExitStack

PVOID ExitStack

Definition at line 39 of file uefimem.c.

Referenced by UefiPrepareForReactOS().

framebufferData

REACTOS_INTERNAL_BGCONTEXT framebufferData

extern

Definition at line 25 of file uefivid.c.

Referenced by UefiInitalizeVideo(), UefiPrintFramebufferData(), UefiVideoClearScreenColor(), UefiVideoCopyOffScreenBufferToVRAM(), UefiVideoGetBufferSize(), UefiVideoGetDisplaySize(), UefiVideoOutputChar(), and UefiVideoScrollUp().

FreeldrDescCount

UINT32 FreeldrDescCount

Definition at line 35 of file uefimem.c.

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

GlobalImageHandle

EFI_HANDLE GlobalImageHandle

extern

Definition at line 14 of file uefildr.c.

Referenced by UefiExitBootServices(), and UefiMemGetMemoryMap().

GlobalSystemTable

EFI_SYSTEM_TABLE* GlobalSystemTable

extern

Definition at line 15 of file uefildr.c.

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

OsLoaderBase

PVOID OsLoaderBase

Definition at line 36 of file uefimem.c.

Referenced by UefiMemGetMemoryMap().

OsLoaderSize

SIZE_T OsLoaderSize

Definition at line 37 of file uefimem.c.

Referenced by UefiMemGetMemoryMap().

PublicBootHandle

EFI_HANDLE PublicBootHandle

Definition at line 38 of file uefimem.c.

Referenced by UefiMemGetMemoryMap(), and UefiSetupBlockDevices().