mm.h File Reference

#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for mm.h:

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

Go to the source code of this file.

Classes
struct	_FREELDR_MEMORY_DESCRIPTOR
struct	PAGE_LOOKUP_TABLE_ITEM

Macros
#define	FREELDR_SECTION_COUNT   3
#define	HEAP_PAGES   0x400
#define	STACK_PAGES   0x00
#define	DUMP_MEM_MAP_ON_VERIFY   0
#define	DEFAULT_HEAP_SIZE   (1024 * 1024)
#define	TEMP_HEAP_SIZE   (32 * 1024 * 1024)

Typedefs
typedef struct _FREELDR_MEMORY_DESCRIPTOR	FREELDR_MEMORY_DESCRIPTOR
typedef struct _FREELDR_MEMORY_DESCRIPTOR *	PFREELDR_MEMORY_DESCRIPTOR
typedef struct PAGE_LOOKUP_TABLE_ITEM *	PPAGE_LOOKUP_TABLE_ITEM

Functions
PFN_NUMBER	MmGetPageNumberFromAddress (PVOID Address)
PFN_NUMBER	MmGetAddressablePageCountIncludingHoles (VOID)
PVOID	MmFindLocationForPageLookupTable (PFN_NUMBER TotalPageCount)
VOID	MmInitPageLookupTable (PVOID PageLookupTable, PFN_NUMBER TotalPageCount)
VOID	MmMarkPagesInLookupTable (PVOID PageLookupTable, PFN_NUMBER StartPage, PFN_NUMBER PageCount, TYPE_OF_MEMORY PageAllocated)
VOID	MmAllocatePagesInLookupTable (PVOID PageLookupTable, PFN_NUMBER StartPage, PFN_NUMBER PageCount, TYPE_OF_MEMORY MemoryType)
PFN_NUMBER	MmCountFreePagesInLookupTable (PVOID PageLookupTable, PFN_NUMBER TotalPageCount)
PFN_NUMBER	MmFindAvailablePages (PVOID PageLookupTable, PFN_NUMBER TotalPageCount, PFN_NUMBER PagesNeeded, BOOLEAN FromEnd)
PFN_NUMBER	MmFindAvailablePagesBeforePage (PVOID PageLookupTable, PFN_NUMBER TotalPageCount, PFN_NUMBER PagesNeeded, PFN_NUMBER LastPage)
VOID	MmUpdateLastFreePageHint (PVOID PageLookupTable, PFN_NUMBER TotalPageCount)
BOOLEAN	MmAreMemoryPagesAvailable (PVOID PageLookupTable, PFN_NUMBER TotalPageCount, PVOID PageAddress, PFN_NUMBER PageCount)
VOID	MmSetMemoryType (PVOID MemoryAddress, SIZE_T MemorySize, TYPE_OF_MEMORY NewType)
PPAGE_LOOKUP_TABLE_ITEM	MmGetMemoryMap (PFN_NUMBER *NoEntries)
BOOLEAN	MmInitializeMemoryManager (VOID)
VOID	MmInitializeHeap (PVOID PageLookupTable)
PVOID	MmAllocateMemory (SIZE_T MemorySize)
PVOID	MmAllocateMemoryWithType (SIZE_T MemorySize, TYPE_OF_MEMORY MemoryType)
VOID	MmFreeMemory (PVOID MemoryPointer)
PVOID	MmAllocateMemoryAtAddress (SIZE_T MemorySize, PVOID DesiredAddress, TYPE_OF_MEMORY MemoryType)
PVOID	MmAllocateHighestMemoryBelowAddress (SIZE_T MemorySize, PVOID DesiredAddress, TYPE_OF_MEMORY MemoryType)
PVOID	FrLdrHeapCreate (SIZE_T MaximumSize, TYPE_OF_MEMORY MemoryType)
VOID	FrLdrHeapDestroy (PVOID HeapHandle)
VOID	FrLdrHeapRelease (PVOID HeapHandle)
VOID	FrLdrHeapVerify (PVOID HeapHandle)
VOID	FrLdrHeapCleanupAll (VOID)
PVOID	FrLdrHeapAllocateEx (PVOID HeapHandle, SIZE_T ByteSize, ULONG Tag)
VOID	FrLdrHeapFreeEx (PVOID HeapHandle, PVOID Pointer, ULONG Tag)
FORCEINLINE PVOID	FrLdrHeapAlloc (SIZE_T MemorySize, ULONG Tag)
FORCEINLINE VOID	FrLdrHeapFree (PVOID MemoryPointer, ULONG Tag)
FORCEINLINE PVOID	FrLdrTempAlloc (_In_ SIZE_T Size, _In_ ULONG Tag)
FORCEINLINE VOID	FrLdrTempFree (PVOID Allocation, ULONG Tag)

Variables
char	__ImageBase
PVOID	PageLookupTableAddress
PFN_NUMBER	TotalPagesInLookupTable
PFN_NUMBER	FreePagesInLookupTable
PFN_NUMBER	LastFreePageHint
PVOID	FrLdrDefaultHeap
PVOID	FrLdrTempHeap
SIZE_T	FrLdrImageSize

Macro Definition Documentation

DEFAULT_HEAP_SIZE

#define DEFAULT_HEAP_SIZE   (1024 * 1024)

Definition at line 133 of file mm.h.

DUMP_MEM_MAP_ON_VERIFY

#define DUMP_MEM_MAP_ON_VERIFY   0

Definition at line 96 of file mm.h.

FREELDR_SECTION_COUNT

#define FREELDR_SECTION_COUNT   3

Definition at line 37 of file mm.h.

HEAP_PAGES

#define HEAP_PAGES   0x400

Definition at line 80 of file mm.h.

STACK_PAGES

#define STACK_PAGES   0x00

Definition at line 81 of file mm.h.

TEMP_HEAP_SIZE

#define TEMP_HEAP_SIZE   (32 * 1024 * 1024)

Definition at line 134 of file mm.h.

Typedef Documentation

FREELDR_MEMORY_DESCRIPTOR

typedef struct _FREELDR_MEMORY_DESCRIPTOR FREELDR_MEMORY_DESCRIPTOR

PFREELDR_MEMORY_DESCRIPTOR

typedef struct _FREELDR_MEMORY_DESCRIPTOR * PFREELDR_MEMORY_DESCRIPTOR

PPAGE_LOOKUP_TABLE_ITEM

typedef struct PAGE_LOOKUP_TABLE_ITEM * PPAGE_LOOKUP_TABLE_ITEM

Function Documentation

FrLdrHeapAlloc()

FORCEINLINE PVOID FrLdrHeapAlloc	(	SIZE_T	MemorySize,
		ULONG	Tag
	)

Definition at line 174 of file mm.h.

{
    return FrLdrHeapAllocateEx(FrLdrDefaultHeap, MemorySize, Tag);
}

Referenced by BuildArgvForOsLoader(), CmpAllocate(), CopyString(), DetectAcpiBios(), DetectApmBios(), DetectBiosDisks(), DetectBiosFloppyController(), DetectBiosFloppyPeripheral(), DetectCBusBios(), DetectDisplayController(), DetectDockingStation(), DetectIsaBios(), DetectKeyboardController(), DetectKeyboardPeripheral(), DetectNesaBios(), DetectParallelPorts(), DetectPciBios(), DetectPciIrqRoutingTable(), DetectPnpBios(), DetectPointerController(), DetectPointerPeripheral(), DetectPS2Mouse(), DetectSerialPointerPeripheral(), DetectSerialPorts(), FldrCreateComponentKey(), FldrCreateSystemKey(), FldrSetIdentifier(), InitOperatingSystemList(), NtLdrGetHigherPriorityOptions(), Pc98GetHarddiskConfigurationData(), PcGetHarddiskConfigurationData(), PeLdrAllocateDataTableEntry(), WinLdrInitializePhase1(), and XboxGetHarddiskConfigurationData().

FrLdrHeapAllocateEx()

PVOID FrLdrHeapAllocateEx	(	PVOID	HeapHandle,
		SIZE_T	ByteSize,
		ULONG	Tag
	)

Definition at line 321 of file heap.c.

{
    PHEAP Heap = HeapHandle;
    PHEAP_BLOCK Block, NextBlock;
    USHORT BlockSize, Remaining;
#if DBG && !defined(_M_ARM)
    ULONGLONG Time = __rdtsc();
#endif
 
#ifdef FREELDR_HEAP_VERIFIER
    /* Verify the heap */
    FrLdrHeapVerify(HeapHandle);
 
    /* Add space for a size field and 2 redzones */
    ByteSize += REDZONE_ALLOCATION;
#endif
 
    /* Check if the allocation is too large */
    if ((ByteSize +  sizeof(HEAP_BLOCK)) > MAXUSHORT * sizeof(HEAP_BLOCK))
    {
        ERR("HEAP: Allocation of 0x%lx bytes too large\n", ByteSize);
        return NULL;
    }
 
    /* We need a proper tag */
    if (Tag == 0) Tag = 'enoN';
 
    /* Calculate alloc size */
    BlockSize = (USHORT)((ByteSize + sizeof(HEAP_BLOCK) - 1) / sizeof(HEAP_BLOCK));
 
    /* Walk the free block list */
    Block = &Heap->Blocks + Heap->TerminatingBlock;
    for (Block = &Heap->Blocks + Block->Data[0].Flink;
         Block->Size != 0;
         Block = &Heap->Blocks + Block->Data[0].Flink)
    {
        ASSERT(Block->Tag == 0);
 
        /* Continue, if its too small */
        if (Block->Size < BlockSize) continue;
 
        /* This block is just fine, use it */
        Block->Tag = Tag;
 
        /* Remove this entry from the free list */
        FrLdrHeapRemoveFreeList(Heap, Block);
 
        /* Calculate the remaining size */
        Remaining = Block->Size - BlockSize;
 
        /* Check if the remaining space is large enough for a new block */
        if (Remaining > 1)
        {
            /* Make the allocated block as large as necessary */
            Block->Size = BlockSize;
 
            /* Get pointer to the new block */
            NextBlock = Block + 1 + BlockSize;
 
            /* Make it a free block */
            NextBlock->Tag = 0;
            NextBlock->Size = Remaining - 1;
            NextBlock->PreviousSize = BlockSize;
            BlockSize = NextBlock->Size;
            FrLdrHeapInsertFreeList(Heap, NextBlock);
 
            /* Advance to the next block */
            NextBlock = NextBlock + 1 + BlockSize;
        }
        else
        {
            /* Not enough left, use the full block */
            BlockSize = Block->Size;
 
            /* Get the next block */
            NextBlock = Block + 1 + BlockSize;
        }
 
        /* Update the next blocks back link */
        NextBlock->PreviousSize = BlockSize;
 
        /* Update heap usage */
        Heap->NumAllocs++;
        Heap->CurrentAllocBytes += Block->Size * sizeof(HEAP_BLOCK);
        Heap->MaxAllocBytes = max(Heap->MaxAllocBytes, Heap->CurrentAllocBytes);
        Heap->LargestAllocation = max(Heap->LargestAllocation,
                                      Block->Size * sizeof(HEAP_BLOCK));
#if DBG && !defined(_M_ARM)
        Heap->AllocationTime += (__rdtsc() - Time);
#endif
        TRACE("HeapAllocate(%p, %ld, %.4s) -> return %p\n",
              HeapHandle, ByteSize, &Tag, Block->Data);
 
        /* HACK: zero out the allocation */
        RtlZeroMemory(Block->Data, Block->Size * sizeof(HEAP_BLOCK));
 
#ifdef FREELDR_HEAP_VERIFIER
        /* Write size and redzones */
        *REDZONE_SIZE(Block) = ByteSize - REDZONE_ALLOCATION;
        *REDZONE_LOW(Block) = REDZONE_MARK;
        *REDZONE_HI(Block) = REDZONE_MARK;
 
        /* Allocation starts after size field and redzone */
        return (PUCHAR)Block->Data + REDZONE_LOW_OFFSET;
#endif
        /* Return pointer to the data */
        return Block->Data;
    }
 
    /* We found nothing */
    WARN("HEAP: nothing suitable found for 0x%lx bytes\n", ByteSize);
    return NULL;
}

Referenced by ExAllocatePool(), ExAllocatePoolWithTag(), FrLdrHeapAlloc(), FrLdrTempAlloc(), RtlAllocateHeap(), and RtlpAllocateMemory().

FrLdrHeapCleanupAll()

VOID FrLdrHeapCleanupAll

(

VOID

)

Definition at line 249 of file heap.c.

{
#if DBG
    PHEAP Heap;
 
    Heap = FrLdrDefaultHeap;
    TRACE("Heap statistics for default heap:\n"
          "CurrentAlloc=0x%lx, MaxAlloc=0x%lx, LargestAllocation=0x%lx\n"
          "NumAllocs=%ld, NumFrees=%ld\n",
          Heap->CurrentAllocBytes, Heap->MaxAllocBytes, Heap->LargestAllocation,
          Heap->NumAllocs, Heap->NumFrees);
    TRACE("AllocTime = %I64d, FreeTime = %I64d, sum = %I64d\n",
        Heap->AllocationTime, Heap->FreeTime, Heap->AllocationTime + Heap->FreeTime);
#endif
 
    /* Release free pages from the default heap */
    FrLdrHeapRelease(FrLdrDefaultHeap);
 
#if DBG
    Heap = FrLdrTempHeap;
    TRACE("Heap statistics for temp heap:\n"
          "CurrentAlloc=0x%lx, MaxAlloc=0x%lx, LargestAllocation=0x%lx\n"
          "NumAllocs=%ld, NumFrees=%ld\n",
          Heap->CurrentAllocBytes, Heap->MaxAllocBytes, Heap->LargestAllocation,
          Heap->NumAllocs, Heap->NumFrees);
#endif
 
    /* Destroy the temp heap */
    FrLdrHeapDestroy(FrLdrTempHeap);
}

Referenced by WinLdrSetupMemoryLayout().

FrLdrHeapCreate()

PVOID FrLdrHeapCreate	(	SIZE_T	MaximumSize,
		TYPE_OF_MEMORY	MemoryType
	)

Definition at line 66 of file heap.c.

{
    PHEAP Heap;
    PHEAP_BLOCK Block;
    SIZE_T Remaining;
    USHORT PreviousSize;
 
    TRACE("HeapCreate(MemoryType=%ld)\n", MemoryType);
 
    /* Allocate some memory for the heap */
    MaximumSize = ALIGN_UP_BY(MaximumSize, MM_PAGE_SIZE);
    Heap = MmAllocateMemoryWithType(MaximumSize, MemoryType);
    if (!Heap)
    {
        ERR("HEAP: Failed to allocate heap of size 0x%lx, Type %lu\n",
            MaximumSize, MemoryType);
        return NULL;
    }
 
    /* Initialize the heap header */
    Heap->MaximumSize = MaximumSize;
    Heap->CurrentAllocBytes = 0;
    Heap->MaxAllocBytes = 0;
    Heap->NumAllocs = 0;
    Heap->NumFrees = 0;
    Heap->LargestAllocation = 0;
 
    /* Calculate what's left to process */
    Remaining = (MaximumSize - sizeof(HEAP)) / sizeof(HEAP_BLOCK);
    TRACE("Remaining = %ld\n", Remaining);
 
    /* Substract 2 for the terminating entry (header + free entry) */
    Remaining -= 2;
 
    Block = &Heap->Blocks;
    PreviousSize = 0;
 
    /* Create free blocks */
    while (Remaining > 1)
    {
        /* Initialize this free block */
        Block->Size = (USHORT)min(MAXUSHORT, Remaining - 1);
        Block->PreviousSize = PreviousSize;
        Block->Tag = 0;
        Block->Data[0].Flink = (Block - &Heap->Blocks) + Block->Size + 1;
        Block->Data[0].Blink = (Block - &Heap->Blocks) - 1 - PreviousSize;
 
        /* Substract current block size from remainder */
        Remaining -= (Block->Size + 1);
 
        /* Go to next block */
        PreviousSize = Block->Size;
        Block = Block + Block->Size + 1;
 
        TRACE("Remaining = %ld\n", Remaining);
    }
 
    /* Now finish with a terminating block */
    Heap->TerminatingBlock = Block - &Heap->Blocks;
    Block->Size = 0;
    Block->PreviousSize = PreviousSize;
    Block->Tag = 'dnE#';
    Block->Data[0].Flink = 0;
    Block->Data[0].Blink = (Block - &Heap->Blocks) - 1 - PreviousSize;
    Heap->Blocks.Data[0].Blink = Heap->TerminatingBlock;
 
    return Heap;
}

Referenced by MmInitializeHeap().

FrLdrHeapDestroy()

VOID FrLdrHeapDestroy

(

PVOID

HeapHandle

)

Definition at line 138 of file heap.c.

{
    PHEAP Heap = HeapHandle;
 
    /* Mark all pages as firmware temporary, so they are free for the kernel */
    MmMarkPagesInLookupTable(PageLookupTableAddress,
                             (ULONG_PTR)Heap / MM_PAGE_SIZE,
                             (PFN_COUNT)(Heap->MaximumSize / MM_PAGE_SIZE),
                             LoaderFirmwareTemporary);
 
#if DBG
    /* Make sure everything is dead */
    RtlFillMemory(Heap, Heap->MaximumSize, 0xCCCCCCCC);
#endif
}

Referenced by FrLdrHeapCleanupAll().

FrLdrHeapFree()

FORCEINLINE VOID FrLdrHeapFree	(	PVOID	MemoryPointer,
		ULONG	Tag
	)

Definition at line 181 of file mm.h.

{
    FrLdrHeapFreeEx(FrLdrDefaultHeap, MemoryPointer, Tag);
}

Referenced by CmpFree(), LoadOperatingSystem(), LoadReactOSSetup(), NtLdrGetHigherPriorityOptions(), Pc98GetHarddiskConfigurationData(), PcGetHarddiskConfigurationData(), PeLdrAllocateDataTableEntry(), PeLdrFreeDataTableEntry(), and XboxGetHarddiskConfigurationData().

FrLdrHeapFreeEx()

VOID FrLdrHeapFreeEx	(	PVOID	HeapHandle,
		PVOID	Pointer,
		ULONG	Tag
	)

Definition at line 439 of file heap.c.

{
    PHEAP Heap = HeapHandle;
    PHEAP_BLOCK Block, PrevBlock, NextBlock;
#if DBG && !defined(_M_ARM)
    ULONGLONG Time = __rdtsc();
#endif
 
    TRACE("HeapFree(%p, %p)\n", HeapHandle, Pointer);
    ASSERT(Tag != 'dnE#');
 
#ifdef FREELDR_HEAP_VERIFIER
    /* Verify the heap */
    FrLdrHeapVerify(HeapHandle);
#endif
 
    /* Check if the block is really inside this heap */
    if ((Pointer < (PVOID)(Heap + 1)) ||
        (Pointer > (PVOID)((PUCHAR)Heap + Heap->MaximumSize)))
    {
        ERR("HEAP: trying to free %p outside of heap %p\n", Pointer, Heap);
        ASSERT(FALSE);
    }
 
    Block = ((PHEAP_BLOCK)Pointer) - 1;
#ifdef FREELDR_HEAP_VERIFIER
    Block = (PHEAP_BLOCK)((PUCHAR)Block - REDZONE_LOW_OFFSET);
 
    /* Verify size and redzones */
    ASSERT(*REDZONE_SIZE(Block) <= Block->Size * sizeof(HEAP_BLOCK));
    ASSERT(*REDZONE_LOW(Block) == REDZONE_MARK);
    ASSERT(*REDZONE_HI(Block) == REDZONE_MARK);
#endif
 
    /* Check if the tag matches */
    if ((Tag && (Block->Tag != Tag)) || (Block->Tag == 0))
    {
        ERR("HEAP: Bad tag! Pointer=%p: block tag '%.4s', requested '%.4s', size=0x%lx\n",
            Pointer, &Block->Tag, &Tag, Block->Size);
        ASSERT(FALSE);
    }
 
    /* Mark as free */
    Block->Tag = 0;
 
#if DBG
    /* Erase contents */
    RtlFillMemory(Block->Data, Block->Size * sizeof(HEAP_BLOCK), 0xCCCCCCCC);
#endif
 
    /* Update heap usage */
    Heap->NumFrees++;
    Heap->CurrentAllocBytes -= Block->Size * sizeof(HEAP_BLOCK);
 
    /* Get pointers to the next and previous block */
    PrevBlock = Block - Block->PreviousSize - 1;
    NextBlock = Block + Block->Size + 1;
 
    /* Check if next block is free */
    if ((NextBlock->Tag == 0) &&
        ((Block->Size + NextBlock->Size + 1) <= MAXUSHORT))
    {
        /* Merge next block into current */
        Block->Size += NextBlock->Size + 1;
        FrLdrHeapRemoveFreeList(Heap, NextBlock);
 
        NextBlock = Block + Block->Size + 1;
    }
 
    /* Check if there is a block before and it's free */
    if ((Block->PreviousSize != 0) && (PrevBlock->Tag == 0) &&
        ((PrevBlock->Size + Block->Size + 1) <= MAXUSHORT))
    {
        /* Merge current block into previous */
        PrevBlock->Size += Block->Size + 1;
        Block = PrevBlock;
    }
    else
    {
        /* Insert the entry into the free list */
        FrLdrHeapInsertFreeList(Heap, Block);
    }
 
    /* Update the next block's back link */
    NextBlock->PreviousSize = Block->Size;
#if DBG && !defined(_M_ARM)
    Heap->FreeTime += (__rdtsc() - Time);
#endif
}

Referenced by ExFreePool(), ExFreePoolWithTag(), FrLdrHeapFree(), FrLdrTempFree(), RtlFreeHeap(), and RtlpFreeMemory().

FrLdrHeapRelease()

VOID FrLdrHeapRelease

(

PVOID

HeapHandle

)

Definition at line 182 of file heap.c.

{
    PHEAP Heap = HeapHandle;
    PHEAP_BLOCK Block;
    PUCHAR StartAddress, EndAddress;
    PFN_COUNT FreePages, AllFreePages = 0;
 
    TRACE("HeapRelease(%p)\n", HeapHandle);
 
    /* Loop all heap chunks */
    for (Block = &Heap->Blocks;
         Block->Size != 0;
         Block = Block + 1 + Block->Size)
    {
        /* Continue, if its not free */
        if (Block->Tag != 0)
        {
#ifdef FREELDR_HEAP_VERIFIER
            /* Verify size and redzones */
            ASSERT(*REDZONE_SIZE(Block) <= Block->Size * sizeof(HEAP_BLOCK));
            ASSERT(*REDZONE_LOW(Block) == REDZONE_MARK);
            ASSERT(*REDZONE_HI(Block) == REDZONE_MARK);
#endif
            continue;
        }
 
        /* Calculate page aligned start address of the free region */
        StartAddress = ALIGN_UP_POINTER_BY(Block->Data, PAGE_SIZE);
 
        /* Walk over adjacent free blocks */
        while (Block->Tag == 0) Block = Block + Block->Size + 1;
 
        /* Check if this was the last block */
        if (Block->Size == 0)
        {
            /* Align the end address up to cover the end of the heap */
            EndAddress = ALIGN_UP_POINTER_BY(Block->Data, PAGE_SIZE);
        }
        else
        {
            /* Align the end address down to not cover any allocations */
            EndAddress = ALIGN_DOWN_POINTER_BY(Block->Data, PAGE_SIZE);
        }
 
        /* Check if we have free pages */
        if (EndAddress > StartAddress)
        {
            /* Calculate the size of the free region in pages */
            FreePages = (PFN_COUNT)((EndAddress - StartAddress) / MM_PAGE_SIZE);
            AllFreePages += FreePages;
 
            /* Now mark the pages free */
            MmMarkPagesInLookupTable(PageLookupTableAddress,
                                     (ULONG_PTR)StartAddress / MM_PAGE_SIZE,
                                     FreePages,
                                     LoaderFree);
        }
 
        /* bail out, if it was the last block */
        if (Block->Size == 0) break;
    }
 
    TRACE("HeapRelease() done, freed %lu of %lu pages\n", AllFreePages, Heap->MaximumSize / MM_PAGE_SIZE);
}

Referenced by FrLdrHeapCleanupAll().

FrLdrHeapVerify()

VOID FrLdrHeapVerify

(

PVOID

HeapHandle

)

Definition at line 157 of file heap.c.

{
    PHEAP Heap = HeapHandle;
    PHEAP_BLOCK Block;
 
    /* Loop all heap chunks */
    for (Block = &Heap->Blocks;
         Block->Size != 0;
         Block = Block + 1 + Block->Size)
    {
        /* Continue, if its not free */
        if (Block->Tag != 0)
        {
            /* Verify size and redzones */
            ASSERT(*REDZONE_SIZE(Block) <= Block->Size * sizeof(HEAP_BLOCK));
            ASSERT(*REDZONE_LOW(Block) == REDZONE_MARK);
            ASSERT(*REDZONE_HI(Block) == REDZONE_MARK);
            continue;
        }
    }
}

Referenced by FrLdrHeapAllocateEx(), and FrLdrHeapFreeEx().

FrLdrTempAlloc()

FORCEINLINE PVOID FrLdrTempAlloc	(	_In_ SIZE_T	Size,
		_In_ ULONG	Tag
	)

Definition at line 188 of file mm.h.

{
    return FrLdrHeapAllocateEx(FrLdrTempHeap, Size, Tag);
}

Referenced by __drv_allocatesMem(), btrfs_read_extent_reg(), btrfs_readlink(), BtrFsMount(), BtrFsOpen(), CacheInternalAddBlockToCache(), DiskOpen(), Ext2CopyDoubleIndirectBlockPointers(), Ext2CopyIndirectBlockPointers(), Ext2CopyTripleIndirectBlockPointers(), Ext2Mount(), Ext2OpenFile(), Ext2ReadBlockPointerList(), Ext2ReadDirectory(), Ext2ReadGroupDescriptors(), Ext2ReadPartialBlock(), Ext2ReadSuperBlock(), FatBufferDirectory(), FatMount(), FatOpen(), FatOpenVolume(), FatReadPartialCluster(), FsRegisterDevice(), IdentifyDevice(), InfOpenFile(), InfpAddFieldToLine(), InfpAddKeyToLine(), InfpCacheAddLine(), InfpCacheAddSection(), IniAddSection(), IniAddSettingValueToSection(), IniFileInitialize(), IniModifySettingValue(), IniParseFile(), init_path(), insert_chunk_item(), IsoBufferDirectory(), IsoOpen(), NormalizeArcDeviceName(), NtfsFindAttributeHelper(), NtfsFindMftRecord(), NtfsMount(), NtfsOpen(), NtfsPrepareAttributeContext(), RegImportBinaryHive(), RunLoader(), ScsiPortInitialize(), TuiFadeInBackdrop(), TuiFadeOut(), UefiDiskOpen(), UiShowMessageBoxesInArgv(), UiShowMessageBoxesInSection(), and VideoFadeIn().

FrLdrTempFree()

FORCEINLINE VOID FrLdrTempFree	(	PVOID	Allocation,
		ULONG	Tag
	)

Definition at line 197 of file mm.h.

{
    FrLdrHeapFreeEx(FrLdrTempHeap, Allocation, Tag);
}

Referenced by ArcOpen(), AtaFree(), btrfs_lookup_path(), btrfs_read_extent_reg(), BtrFsClose(), BtrFsMount(), CacheInitializeDrive(), CacheInternalAddBlockToCache(), CacheInternalFreeBlock(), DiskClose(), Ext2Close(), Ext2CopyDoubleIndirectBlockPointers(), Ext2CopyIndirectBlockPointers(), Ext2CopyTripleIndirectBlockPointers(), Ext2LookupFile(), Ext2Mount(), Ext2OpenFile(), Ext2ReadBlockPointerList(), Ext2ReadDirectory(), Ext2ReadGroupDescriptors(), Ext2ReadPartialBlock(), Ext2ReadSuperBlock(), FatBufferDirectory(), FatClose(), FatMount(), FatOpenVolume(), FatReadPartialCluster(), free_path(), InfCloseFile(), InfOpenFile(), InfpCacheFreeLine(), InfpCacheFreeSection(), IniAddSection(), IniAddSettingValueToSection(), IniFileInitialize(), IniFreeSection(), IniModifySettingValue(), IniParseFile(), IsoBufferDirectory(), IsoClose(), IsoLookupFile(), NtfsClose(), NtfsFindAttributeHelper(), NtfsFindMftRecord(), NtfsMount(), NtfsOpen(), NtfsReleaseAttributeContext(), RegImportBinaryHive(), ScsiPortInitialize(), TuiFadeInBackdrop(), TuiFadeOut(), TuiRestoreScreen(), UefiDiskClose(), UiShowMessageBoxesInArgv(), UiShowMessageBoxesInSection(), and VideoFadeIn().

MmAllocateHighestMemoryBelowAddress()

PVOID MmAllocateHighestMemoryBelowAddress	(	SIZE_T	MemorySize,
		PVOID	DesiredAddress,
		TYPE_OF_MEMORY	MemoryType
	)

Definition at line 160 of file mm.c.

{
    PFN_NUMBER        PagesNeeded;
    PFN_NUMBER        FirstFreePageFromEnd;
    PFN_NUMBER        DesiredAddressPageNumber;
    PVOID    MemPointer;
 
    if (MemorySize == 0)
    {
        WARN("MmAllocateHighestMemoryBelowAddress() called for 0 bytes. Returning NULL.\n");
        UiMessageBoxCritical("Memory allocation failed: MmAllocateHighestMemoryBelowAddress() called for 0 bytes.");
        return NULL;
    }
 
    // Find out how many blocks it will take to
    // satisfy this allocation
    PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 
    // Get the page number for their desired address
    DesiredAddressPageNumber = (ULONG_PTR)DesiredAddress / MM_PAGE_SIZE;
 
    // If we don't have enough available mem
    // then return NULL
    if (FreePagesInLookupTable < PagesNeeded)
    {
        ERR("Memory allocation failed in MmAllocateHighestMemoryBelowAddress(). Not enough free memory to allocate %d bytes.\n", MemorySize);
        UiMessageBoxCritical("Memory allocation failed: out of memory.");
        return NULL;
    }
 
    FirstFreePageFromEnd = MmFindAvailablePagesBeforePage(PageLookupTableAddress, TotalPagesInLookupTable, PagesNeeded, DesiredAddressPageNumber);
 
    if (FirstFreePageFromEnd == 0)
    {
        ERR("Memory allocation failed in MmAllocateHighestMemoryBelowAddress(). Not enough free memory to allocate %d bytes.\n", MemorySize);
        UiMessageBoxCritical("Memory allocation failed: out of memory.");
        return NULL;
    }
 
    MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded, MemoryType);
 
    FreePagesInLookupTable -= PagesNeeded;
    MemPointer = (PVOID)((ULONG_PTR)FirstFreePageFromEnd * MM_PAGE_SIZE);
 
    TRACE("Allocated %d bytes (%d pages) of memory starting at page %d.\n", MemorySize, PagesNeeded, FirstFreePageFromEnd);
    TRACE("Memory allocation pointer: 0x%x\n", MemPointer);
 
    // Update LoaderPagesSpanned count
    if ((((ULONG_PTR)MemPointer + MemorySize) >> PAGE_SHIFT) > LoaderPagesSpanned)
        LoaderPagesSpanned = (((ULONG_PTR)MemPointer + MemorySize) >> PAGE_SHIFT);
 
    // Now return the pointer
    return MemPointer;
}

MmAllocateMemory()

PVOID MmAllocateMemory

(

SIZE_T

MemorySize

)

MmAllocateMemoryAtAddress()

PVOID MmAllocateMemoryAtAddress	(	SIZE_T	MemorySize,
		PVOID	DesiredAddress,
		TYPE_OF_MEMORY	MemoryType
	)

Definition at line 85 of file mm.c.

{
    PFN_NUMBER        PagesNeeded;
    PFN_NUMBER        StartPageNumber;
    PVOID    MemPointer;
 
    if (MemorySize == 0)
    {
        WARN("MmAllocateMemoryAtAddress() called for 0 bytes. Returning NULL.\n");
        UiMessageBoxCritical("Memory allocation failed: MmAllocateMemoryAtAddress() called for 0 bytes.");
        return NULL;
    }
 
    // Find out how many blocks it will take to
    // satisfy this allocation
    PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 
    // Get the starting page number
    StartPageNumber = MmGetPageNumberFromAddress(DesiredAddress);
 
    // If we don't have enough available mem
    // then return NULL
    if (FreePagesInLookupTable < PagesNeeded)
    {
        ERR("Memory allocation failed in MmAllocateMemoryAtAddress(). "
            "Not enough free memory to allocate %d bytes (requesting %d pages but have only %d). "
            "\n", MemorySize, PagesNeeded, FreePagesInLookupTable);
        UiMessageBoxCritical("Memory allocation failed: out of memory.");
        return NULL;
    }
 
    if (MmAreMemoryPagesAvailable(PageLookupTableAddress, TotalPagesInLookupTable, DesiredAddress, PagesNeeded) == FALSE)
    {
        WARN("Memory allocation failed in MmAllocateMemoryAtAddress(). "
             "Not enough free memory to allocate %d bytes at address %p.\n",
             MemorySize, DesiredAddress);
 
        // Don't tell this to user since caller should try to alloc this memory
        // at a different address
        //UiMessageBoxCritical("Memory allocation failed: out of memory.");
        return NULL;
    }
 
    MmAllocatePagesInLookupTable(PageLookupTableAddress, StartPageNumber, PagesNeeded, MemoryType);
 
    FreePagesInLookupTable -= PagesNeeded;
    MemPointer = (PVOID)((ULONG_PTR)StartPageNumber * MM_PAGE_SIZE);
 
    TRACE("Allocated %d bytes (%d pages) of memory starting at page %d.\n", MemorySize, PagesNeeded, StartPageNumber);
    TRACE("Memory allocation pointer: 0x%x\n", MemPointer);
 
    // Update LoaderPagesSpanned count
    if ((((ULONG_PTR)MemPointer + MemorySize + PAGE_SIZE - 1) >> PAGE_SHIFT) > LoaderPagesSpanned)
        LoaderPagesSpanned = (((ULONG_PTR)MemPointer + MemorySize + PAGE_SIZE - 1) >> PAGE_SHIFT);
 
    // Now return the pointer
    return MemPointer;
}

Referenced by MempAllocatePageTables(), and PeLdrLoadImage().

MmAllocateMemoryWithType()

PVOID MmAllocateMemoryWithType	(	SIZE_T	MemorySize,
		TYPE_OF_MEMORY	MemoryType
	)

Definition at line 31 of file mm.c.

{
    PFN_NUMBER    PagesNeeded;
    PFN_NUMBER    FirstFreePageFromEnd;
    PVOID    MemPointer;
 
    if (MemorySize == 0)
    {
        WARN("MmAllocateMemory() called for 0 bytes. Returning NULL.\n");
        UiMessageBoxCritical("Memory allocation failed: MmAllocateMemory() called for 0 bytes.");
        return NULL;
    }
 
    MemorySize = ROUND_UP(MemorySize, 4);
 
    // Find out how many blocks it will take to
    // satisfy this allocation
    PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 
    // If we don't have enough available mem
    // then return NULL
    if (FreePagesInLookupTable < PagesNeeded)
    {
        ERR("Memory allocation failed in MmAllocateMemory(). Not enough free memory to allocate %d bytes.\n", MemorySize);
        UiMessageBoxCritical("Memory allocation failed: out of memory.");
        return NULL;
    }
 
    FirstFreePageFromEnd = MmFindAvailablePages(PageLookupTableAddress, TotalPagesInLookupTable, PagesNeeded, FALSE);
 
    if (FirstFreePageFromEnd == 0)
    {
        ERR("Memory allocation failed in MmAllocateMemory(). Not enough free memory to allocate %d bytes.\n", MemorySize);
        UiMessageBoxCritical("Memory allocation failed: out of memory.");
        return NULL;
    }
 
    MmAllocatePagesInLookupTable(PageLookupTableAddress, FirstFreePageFromEnd, PagesNeeded, MemoryType);
 
    FreePagesInLookupTable -= PagesNeeded;
    MemPointer = (PVOID)((ULONG_PTR)FirstFreePageFromEnd * MM_PAGE_SIZE);
 
    TRACE("Allocated %d bytes (%d pages) of memory (type %ld) starting at page 0x%lx.\n",
          MemorySize, PagesNeeded, MemoryType, FirstFreePageFromEnd);
    TRACE("Memory allocation pointer: 0x%x\n", MemPointer);
 
    // Update LoaderPagesSpanned count
    if ((((ULONG_PTR)MemPointer + MemorySize + PAGE_SIZE - 1) >> PAGE_SHIFT) > LoaderPagesSpanned)
        LoaderPagesSpanned = (((ULONG_PTR)MemPointer + MemorySize + PAGE_SIZE - 1) >> PAGE_SHIFT);
 
    // Now return the pointer
    return MemPointer;
}

Referenced by AllocateAndInitLPB(), EfiEntry(), FrLdrHeapCreate(), MempAllocatePageTables(), MempGetOrCreatePageDir(), PeLdrLoadImage(), RamDiskLoadVirtualFile(), RegLoadHiveLog(), UefiInitializeBootDevices(), UefiSetupBlockDevices(), VideoAllocateOffScreenBuffer(), WinLdrLoadModule(), WinLdrLoadNLSData(), WinLdrLoadSystemHive(), WinLdrSetupMachineDependent(), and WinLdrSetupMemoryLayout().

MmAllocatePagesInLookupTable()

VOID MmAllocatePagesInLookupTable	(	PVOID	PageLookupTable,
		PFN_NUMBER	StartPage,
		PFN_NUMBER	PageCount,
		TYPE_OF_MEMORY	MemoryType
	)

Definition at line 536 of file meminit.c.

{
    PPAGE_LOOKUP_TABLE_ITEM        RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable;
    PFN_NUMBER                    Index;
 
    StartPage -= MmLowestPhysicalPage;
    for (Index=StartPage; Index<(StartPage+PageCount); Index++)
    {
        RealPageLookupTable[Index].PageAllocated = MemoryType;
        RealPageLookupTable[Index].PageAllocationLength = (Index == StartPage) ? PageCount : 0;
    }
}

Referenced by MmAllocateHighestMemoryBelowAddress(), MmAllocateMemoryAtAddress(), MmAllocateMemoryWithType(), and MmSetMemoryType().

MmAreMemoryPagesAvailable()

BOOLEAN MmAreMemoryPagesAvailable	(	PVOID	PageLookupTable,
		PFN_NUMBER	TotalPageCount,
		PVOID	PageAddress,
		PFN_NUMBER	PageCount
	)

Definition at line 674 of file meminit.c.

{
    PPAGE_LOOKUP_TABLE_ITEM        RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable;
    PFN_NUMBER                            StartPage;
    PFN_NUMBER                            Index;
 
    StartPage = MmGetPageNumberFromAddress(PageAddress);
 
    if (StartPage < MmLowestPhysicalPage) return FALSE;
 
    StartPage -= MmLowestPhysicalPage;
 
    // Make sure they aren't trying to go past the
    // end of available memory
    if ((StartPage + PageCount) > TotalPageCount)
    {
        return FALSE;
    }
 
    for (Index = StartPage; Index < (StartPage + PageCount); Index++)
    {
        // If this page is allocated then there obviously isn't
        // memory available so return FALSE
        if (RealPageLookupTable[Index].PageAllocated != LoaderFree)
        {
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by MmAllocateMemoryAtAddress().

MmCountFreePagesInLookupTable()

PFN_NUMBER MmCountFreePagesInLookupTable	(	PVOID	PageLookupTable,
		PFN_NUMBER	TotalPageCount
	)

Definition at line 549 of file meminit.c.

{
    PPAGE_LOOKUP_TABLE_ITEM        RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable;
    PFN_NUMBER                            Index;
    PFN_NUMBER                            FreePageCount;
 
    FreePageCount = 0;
    for (Index=0; Index<TotalPageCount; Index++)
    {
        if (RealPageLookupTable[Index].PageAllocated == LoaderFree)
        {
            FreePageCount++;
        }
    }
 
    return FreePageCount;
}

Referenced by MmInitializeMemoryManager().

MmFindAvailablePages()

PFN_NUMBER MmFindAvailablePages	(	PVOID	PageLookupTable,
		PFN_NUMBER	TotalPageCount,
		PFN_NUMBER	PagesNeeded,
		BOOLEAN	FromEnd
	)

Definition at line 567 of file meminit.c.

{
    PPAGE_LOOKUP_TABLE_ITEM RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable;
    PFN_NUMBER AvailablePagesSoFar;
    PFN_NUMBER Index;
 
    if (LastFreePageHint > TotalPageCount)
    {
        LastFreePageHint = TotalPageCount;
    }
 
    AvailablePagesSoFar = 0;
    if (FromEnd)
    {
        /* Allocate "high" (from end) pages */
        for (Index=LastFreePageHint-1; Index>0; Index--)
        {
            if (RealPageLookupTable[Index].PageAllocated != LoaderFree)
            {
                AvailablePagesSoFar = 0;
                continue;
            }
            else
            {
                AvailablePagesSoFar++;
            }
 
            if (AvailablePagesSoFar >= PagesNeeded)
            {
                return Index + MmLowestPhysicalPage;
            }
        }
    }
    else
    {
        TRACE("Alloc low memory, LastFreePageHint 0x%x, TPC 0x%x\n", LastFreePageHint, TotalPageCount);
        /* Allocate "low" pages */
        for (Index=1; Index < LastFreePageHint; Index++)
        {
            if (RealPageLookupTable[Index].PageAllocated != LoaderFree)
            {
                AvailablePagesSoFar = 0;
                continue;
            }
            else
            {
                AvailablePagesSoFar++;
            }
 
            if (AvailablePagesSoFar >= PagesNeeded)
            {
                return Index - AvailablePagesSoFar + 1 + MmLowestPhysicalPage;
            }
        }
    }
 
    return 0;
}

Referenced by MmAllocateMemoryWithType(), and MmFindAvailablePagesBeforePage().

MmFindAvailablePagesBeforePage()

PFN_NUMBER MmFindAvailablePagesBeforePage	(	PVOID	PageLookupTable,
		PFN_NUMBER	TotalPageCount,
		PFN_NUMBER	PagesNeeded,
		PFN_NUMBER	LastPage
	)

Definition at line 626 of file meminit.c.

{
    PPAGE_LOOKUP_TABLE_ITEM        RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable;
    PFN_NUMBER                    AvailablePagesSoFar;
    PFN_NUMBER                    Index;
 
    if (LastPage > TotalPageCount)
    {
        return MmFindAvailablePages(PageLookupTable, TotalPageCount, PagesNeeded, TRUE);
    }
 
    AvailablePagesSoFar = 0;
    for (Index=LastPage-1; Index>0; Index--)
    {
        if (RealPageLookupTable[Index].PageAllocated != LoaderFree)
        {
            AvailablePagesSoFar = 0;
            continue;
        }
        else
        {
            AvailablePagesSoFar++;
        }
 
        if (AvailablePagesSoFar >= PagesNeeded)
        {
            return Index + MmLowestPhysicalPage;
        }
    }
 
    return 0;
}

Referenced by MmAllocateHighestMemoryBelowAddress().

MmFindLocationForPageLookupTable()

PVOID MmFindLocationForPageLookupTable

(

PFN_NUMBER

TotalPageCount

)

Definition at line 416 of file meminit.c.

{
    const FREELDR_MEMORY_DESCRIPTOR* MemoryDescriptor = NULL;
    SIZE_T PageLookupTableSize;
    PFN_NUMBER RequiredPages;
    PFN_NUMBER CandidateBasePage = 0;
    PFN_NUMBER CandidatePageCount = 0;
    PFN_NUMBER PageLookupTableEndPage;
    PVOID PageLookupTableMemAddress;
 
    // Calculate how much pages we need to keep the page lookup table
    PageLookupTableSize = TotalPageCount * sizeof(PAGE_LOOKUP_TABLE_ITEM);
    RequiredPages = PageLookupTableSize / MM_PAGE_SIZE;
 
    // Search the highest memory block big enough to contain lookup table
    while ((MemoryDescriptor = ArcGetMemoryDescriptor(MemoryDescriptor)) != NULL)
    {
        // Continue, if memory is not free
        if (MemoryDescriptor->MemoryType != LoaderFree) continue;
 
        // Continue, if the block is not big enough
        if (MemoryDescriptor->PageCount < RequiredPages) continue;
 
        // Continue, if it is not at a higher address than previous address
        if (MemoryDescriptor->BasePage < CandidateBasePage) continue;
 
        // Continue, if the address is too high
        if (MemoryDescriptor->BasePage + RequiredPages >= MM_MAX_PAGE_LOADER) continue;
 
        // Memory block is more suitable than the previous one
        CandidateBasePage = MemoryDescriptor->BasePage;
        CandidatePageCount = MemoryDescriptor->PageCount;
    }
 
    // Calculate the end address for the lookup table
    PageLookupTableEndPage = min(CandidateBasePage + CandidatePageCount,
                                 MM_MAX_PAGE_LOADER);
 
    // Calculate the virtual address
    PageLookupTableMemAddress = (PVOID)((PageLookupTableEndPage * PAGE_SIZE)
                                        - PageLookupTableSize);
 
    TRACE("MmFindLocationForPageLookupTable() returning 0x%x\n", PageLookupTableMemAddress);
 
    return PageLookupTableMemAddress;
}

Referenced by MmInitializeMemoryManager().

MmFreeMemory()

VOID MmFreeMemory

(

PVOID

MemoryPointer

)

Definition at line 215 of file mm.c.

{
}

Referenced by LoadBootDeviceDriver(), LoadModule(), LoadWindowsCore(), PeLdrLoadImage(), PeLdrpLoadAndScanReferencedDll(), RamDiskInitialize(), RamDiskLoadVirtualFile(), VideoFreeOffScreenBuffer(), and WinLdrLoadDeviceDriver().

MmGetAddressablePageCountIncludingHoles()

PFN_NUMBER MmGetAddressablePageCountIncludingHoles

(

VOID

)

Definition at line 376 of file meminit.c.

{
    const FREELDR_MEMORY_DESCRIPTOR* MemoryDescriptor = NULL;
    PFN_NUMBER PageCount;
 
    //
    // Go through the whole memory map to get max address
    //
    while ((MemoryDescriptor = ArcGetMemoryDescriptor(MemoryDescriptor)) != NULL)
    {
        //
        // Check if we got a higher end page address
        //
        if (MemoryDescriptor->BasePage + MemoryDescriptor->PageCount > MmHighestPhysicalPage)
        {
            //
            // Yes, remember it if this is real memory
            //
            if (MemoryDescriptor->MemoryType == LoaderFree)
                MmHighestPhysicalPage = MemoryDescriptor->BasePage + MemoryDescriptor->PageCount;
        }
 
        //
        // Check if we got a higher (usable) start page address
        //
        if (MemoryDescriptor->BasePage < MmLowestPhysicalPage)
        {
            //
            // Yes, remember it if this is real memory
            //
            MmLowestPhysicalPage = MemoryDescriptor->BasePage;
        }
    }
 
    TRACE("lo/hi %lx %lx\n", MmLowestPhysicalPage, MmHighestPhysicalPage);
    PageCount = MmHighestPhysicalPage - MmLowestPhysicalPage;
    TRACE("MmGetAddressablePageCountIncludingHoles() returning 0x%x\n", PageCount);
    return PageCount;
}

Referenced by MmInitializeMemoryManager().

MmGetMemoryMap()

PPAGE_LOOKUP_TABLE_ITEM MmGetMemoryMap

(

PFN_NUMBER *

NoEntries

)

Definition at line 297 of file mm.c.

{
    PPAGE_LOOKUP_TABLE_ITEM        RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTableAddress;
 
    *NoEntries = TotalPagesInLookupTable;
 
    return RealPageLookupTable;
}

Referenced by WinLdrSetupMemoryLayout().

MmGetPageNumberFromAddress()

PFN_NUMBER MmGetPageNumberFromAddress

(

PVOID

Address

)

Definition at line 371 of file meminit.c.

{
    return ((ULONG_PTR)Address) / MM_PAGE_SIZE;
}

Referenced by MmAllocateMemoryAtAddress(), MmAreMemoryPagesAvailable(), MmInitPageLookupTable(), and MmSetMemoryType().

MmInitializeHeap()

VOID MmInitializeHeap

(

PVOID

PageLookupTable

)

Definition at line 536 of file heap.c.

{
    TRACE("MmInitializeHeap()\n");
 
    /* Create the default heap */
    FrLdrDefaultHeap = FrLdrHeapCreate(DEFAULT_HEAP_SIZE, LoaderOsloaderHeap);
    ASSERT(FrLdrDefaultHeap);
 
    /* Create a temporary heap */
    FrLdrTempHeap = FrLdrHeapCreate(TEMP_HEAP_SIZE, LoaderFirmwareTemporary);
    ASSERT(FrLdrTempHeap);
 
    TRACE("MmInitializeHeap() done, default heap %p, temp heap %p\n",
          FrLdrDefaultHeap, FrLdrTempHeap);
}

Referenced by MmInitializeMemoryManager().

MmInitializeMemoryManager()

BOOLEAN MmInitializeMemoryManager

(

VOID

)

Definition at line 315 of file meminit.c.

{
#if DBG
    const FREELDR_MEMORY_DESCRIPTOR* MemoryDescriptor = NULL;
#endif
 
    TRACE("Initializing Memory Manager.\n");
 
    /* Check the freeldr binary */
    MmCheckFreeldrImageFile();
 
    BiosMemoryMap = MachVtbl.GetMemoryMap(&BiosMemoryMapEntryCount);
 
#if DBG
    // Dump the system memory map
    TRACE("System Memory Map (Base Address, Length, Type):\n");
    while ((MemoryDescriptor = ArcGetMemoryDescriptor(MemoryDescriptor)) != NULL)
    {
        TRACE("%x\t %x\t %s\n",
            MemoryDescriptor->BasePage * MM_PAGE_SIZE,
            MemoryDescriptor->PageCount * MM_PAGE_SIZE,
            MmGetSystemMemoryMapTypeString(MemoryDescriptor->MemoryType));
    }
#endif
 
    // Find address for the page lookup table
    TotalPagesInLookupTable = MmGetAddressablePageCountIncludingHoles();
    PageLookupTableAddress = MmFindLocationForPageLookupTable(TotalPagesInLookupTable);
    LastFreePageHint = MmHighestPhysicalPage;
 
    if (PageLookupTableAddress == 0)
    {
        // If we get here then we probably couldn't
        // find a contiguous chunk of memory big
        // enough to hold the page lookup table
        printf("Error initializing memory manager!\n");
        return FALSE;
    }
 
    // Initialize the page lookup table
    MmInitPageLookupTable(PageLookupTableAddress, TotalPagesInLookupTable);
 
    MmUpdateLastFreePageHint(PageLookupTableAddress, TotalPagesInLookupTable);
 
    FreePagesInLookupTable = MmCountFreePagesInLookupTable(PageLookupTableAddress,
                                                        TotalPagesInLookupTable);
 
    MmInitializeHeap(PageLookupTableAddress);
 
    TRACE("Memory Manager initialized. 0x%x pages available.\n", FreePagesInLookupTable);
 
 
    return TRUE;
}

Referenced by BootMain(), and EfiEntry().

MmInitPageLookupTable()

VOID MmInitPageLookupTable	(	PVOID	PageLookupTable,
		PFN_NUMBER	TotalPageCount
	)

Definition at line 463 of file meminit.c.

{
    const FREELDR_MEMORY_DESCRIPTOR* MemoryDescriptor = NULL;
    PFN_NUMBER PageLookupTableStartPage;
    PFN_NUMBER PageLookupTablePageCount;
 
    TRACE("MmInitPageLookupTable()\n");
 
    // Mark every page as allocated initially
    // We will go through and mark pages again according to the memory map
    // But this will mark any holes not described in the map as allocated
    MmMarkPagesInLookupTable(PageLookupTable, MmLowestPhysicalPage, TotalPageCount, LoaderFirmwarePermanent);
 
    // Parse the whole memory map
    while ((MemoryDescriptor = ArcGetMemoryDescriptor(MemoryDescriptor)) != NULL)
    {
        // Mark used pages in the lookup table
 
        if (MemoryDescriptor->BasePage + MemoryDescriptor->PageCount <= TotalPageCount)
        {
            TRACE("Marking pages 0x%lx-0x%lx as type %s\n",
                  MemoryDescriptor->BasePage,
                  MemoryDescriptor->BasePage + MemoryDescriptor->PageCount,
                  MmGetSystemMemoryMapTypeString(MemoryDescriptor->MemoryType));
            MmMarkPagesInLookupTable(PageLookupTable,
                                     MemoryDescriptor->BasePage,
                                     MemoryDescriptor->PageCount,
                                     MemoryDescriptor->MemoryType);
        }
        else
            TRACE("Ignoring pages 0x%lx-0x%lx (%s)\n",
                  MemoryDescriptor->BasePage,
                  MemoryDescriptor->BasePage + MemoryDescriptor->PageCount,
                  MmGetSystemMemoryMapTypeString(MemoryDescriptor->MemoryType));
    }
 
    // Mark the pages that the lookup table occupies as reserved
    PageLookupTableStartPage = MmGetPageNumberFromAddress(PageLookupTable);
    PageLookupTablePageCount = MmGetPageNumberFromAddress((PVOID)((ULONG_PTR)PageLookupTable + ROUND_UP(TotalPageCount * sizeof(PAGE_LOOKUP_TABLE_ITEM), MM_PAGE_SIZE))) - PageLookupTableStartPage;
    TRACE("Marking the page lookup table pages as reserved StartPage: 0x%x PageCount: 0x%x\n", PageLookupTableStartPage, PageLookupTablePageCount);
    MmMarkPagesInLookupTable(PageLookupTable, PageLookupTableStartPage, PageLookupTablePageCount, LoaderFirmwareTemporary);
}

Referenced by MmInitializeMemoryManager().

MmMarkPagesInLookupTable()

VOID MmMarkPagesInLookupTable	(	PVOID	PageLookupTable,
		PFN_NUMBER	StartPage,
		PFN_NUMBER	PageCount,
		TYPE_OF_MEMORY	PageAllocated
	)

Definition at line 506 of file meminit.c.

{
    PPAGE_LOOKUP_TABLE_ITEM RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable;
    PFN_NUMBER Index;
    TRACE("MmMarkPagesInLookupTable()\n");
 
    /* Validate the range */
    if ((StartPage < MmLowestPhysicalPage) ||
        ((StartPage + PageCount - 1) > MmHighestPhysicalPage))
    {
        ERR("Memory (0x%lx:0x%lx) outside of lookup table! Valid range: 0x%lx-0x%lx.\n",
            StartPage, PageCount, MmLowestPhysicalPage, MmHighestPhysicalPage);
        return;
    }
 
    StartPage -= MmLowestPhysicalPage;
    for (Index=StartPage; Index<(StartPage+PageCount); Index++)
    {
#if 0
        if ((Index <= (StartPage + 16)) || (Index >= (StartPage+PageCount-16)))
        {
            TRACE("Index = 0x%x StartPage = 0x%x PageCount = 0x%x\n", Index, StartPage, PageCount);
        }
#endif
        RealPageLookupTable[Index].PageAllocated = PageAllocated;
        RealPageLookupTable[Index].PageAllocationLength = (PageAllocated != LoaderFree) ? 1 : 0;
    }
    TRACE("MmMarkPagesInLookupTable() Done\n");
}

Referenced by FrLdrHeapDestroy(), FrLdrHeapRelease(), and MmInitPageLookupTable().

MmSetMemoryType()

VOID MmSetMemoryType	(	PVOID	MemoryAddress,
		SIZE_T	MemorySize,
		TYPE_OF_MEMORY	NewType
	)

Definition at line 144 of file mm.c.

{
    PFN_NUMBER        PagesNeeded;
    PFN_NUMBER        StartPageNumber;
 
    // Find out how many blocks it will take to
    // satisfy this allocation
    PagesNeeded = ROUND_UP(MemorySize, MM_PAGE_SIZE) / MM_PAGE_SIZE;
 
    // Get the starting page number
    StartPageNumber = MmGetPageNumberFromAddress(MemoryAddress);
 
    // Set new type for these pages
    MmAllocatePagesInLookupTable(PageLookupTableAddress, StartPageNumber, PagesNeeded, NewType);
}

Referenced by MempAllocatePageTables().

MmUpdateLastFreePageHint()

VOID MmUpdateLastFreePageHint	(	PVOID	PageLookupTable,
		PFN_NUMBER	TotalPageCount
	)

Definition at line 659 of file meminit.c.

{
    PPAGE_LOOKUP_TABLE_ITEM        RealPageLookupTable = (PPAGE_LOOKUP_TABLE_ITEM)PageLookupTable;
    PFN_NUMBER                            Index;
 
    for (Index=TotalPageCount-1; Index>0; Index--)
    {
        if (RealPageLookupTable[Index].PageAllocated == LoaderFree)
        {
            LastFreePageHint = Index + 1 + MmLowestPhysicalPage;
            break;
        }
    }
}

Referenced by MmInitializeMemoryManager().

Variable Documentation

__ImageBase

char __ImageBase

extern

FreePagesInLookupTable

PFN_NUMBER FreePagesInLookupTable

extern

Definition at line 28 of file meminit.c.

Referenced by MmAllocateHighestMemoryBelowAddress(), MmAllocateMemoryAtAddress(), MmAllocateMemoryWithType(), and MmInitializeMemoryManager().

FrLdrDefaultHeap

PVOID FrLdrDefaultHeap

extern

Definition at line 34 of file heap.c.

Referenced by ExAllocatePool(), ExAllocatePoolWithTag(), ExFreePool(), ExFreePoolWithTag(), FrLdrHeapAlloc(), FrLdrHeapCleanupAll(), FrLdrHeapFree(), MmInitializeHeap(), RtlAllocateHeap(), RtlFreeHeap(), RtlpAllocateMemory(), and RtlpFreeMemory().

FrLdrImageSize

SIZE_T FrLdrImageSize

extern

Definition at line 35 of file meminit.c.

Referenced by MmCheckFreeldrImageFile(), PcMemCheckUsableMemorySize(), and PcMemFinalizeMemoryMap().

FrLdrTempHeap

PVOID FrLdrTempHeap

extern

Definition at line 35 of file heap.c.

Referenced by FrLdrHeapCleanupAll(), FrLdrTempAlloc(), FrLdrTempFree(), and MmInitializeHeap().

LastFreePageHint

PFN_NUMBER LastFreePageHint

extern

Definition at line 29 of file meminit.c.

Referenced by MmFindAvailablePages(), MmInitializeMemoryManager(), and MmUpdateLastFreePageHint().

PageLookupTableAddress

PVOID PageLookupTableAddress

extern

Definition at line 26 of file meminit.c.

Referenced by FrLdrHeapDestroy(), FrLdrHeapRelease(), MmAllocateHighestMemoryBelowAddress(), MmAllocateMemoryAtAddress(), MmAllocateMemoryWithType(), MmGetMemoryMap(), MmInitializeMemoryManager(), and MmSetMemoryType().

TotalPagesInLookupTable

PFN_NUMBER TotalPagesInLookupTable

extern

Definition at line 27 of file meminit.c.

Referenced by CacheInitializeDrive(), MempAllocatePageTables(), MmAllocateHighestMemoryBelowAddress(), MmAllocateMemoryAtAddress(), MmAllocateMemoryWithType(), MmGetMemoryMap(), and MmInitializeMemoryManager().