meminit.c File Reference

#include <freeldr.h>
#include <debug.h>

Include dependency graph for meminit.c:

Go to the source code of this file.

Functions
	DBG_DEFAULT_CHANNEL (MEMORY)
ULONG	MmGetBiosMemoryMap (_Out_ PFREELDR_MEMORY_DESCRIPTOR *MemoryMap)
PFN_NUMBER	MmGetTotalPagesInLookupTable (VOID)
PCSTR	MmGetSystemMemoryMapTypeString (TYPE_OF_MEMORY Type)
ULONG	AddMemoryDescriptor (IN OUT PFREELDR_MEMORY_DESCRIPTOR List, IN ULONG MaxCount, IN PFN_NUMBER BasePage, IN PFN_NUMBER PageCount, IN TYPE_OF_MEMORY MemoryType)
const FREELDR_MEMORY_DESCRIPTOR *	ArcGetMemoryDescriptor (const FREELDR_MEMORY_DESCRIPTOR *Current)
static VOID	MmCheckFreeldrImageFile (VOID)
BOOLEAN	MmInitializeMemoryManager (VOID)
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)
PFN_NUMBER	MmGetHighestPhysicalPage (VOID)

Variables
PVOID	PageLookupTableAddress = NULL
PFN_NUMBER	TotalPagesInLookupTable = 0
PFN_NUMBER	FreePagesInLookupTable = 0
PFN_NUMBER	LastFreePageHint = 0
PFN_NUMBER	MmLowestPhysicalPage = 0xFFFFFFFF
PFN_NUMBER	MmHighestPhysicalPage = 0
PFREELDR_MEMORY_DESCRIPTOR	BiosMemoryMap
ULONG	BiosMemoryMapEntryCount
SIZE_T	FrLdrImageSize

Function Documentation

AddMemoryDescriptor()

ULONG AddMemoryDescriptor	(	IN OUT PFREELDR_MEMORY_DESCRIPTOR	List,
		IN ULONG	MaxCount,
		IN PFN_NUMBER	BasePage,
		IN PFN_NUMBER	PageCount,
		IN TYPE_OF_MEMORY	MemoryType
	)

Definition at line 123 of file meminit.c.

{
    ULONG Index, DescriptCount;
    PFN_NUMBER EndPage;
    TRACE("AddMemoryDescriptor(0x%Ix, 0x%Ix, %u)\n",
          BasePage, PageCount, MemoryType);
 
    EndPage = BasePage + PageCount;
 
    /* Skip over all descriptor below the new range */
    Index = 0;
    while ((List[Index].PageCount != 0) &&
           ((List[Index].BasePage + List[Index].PageCount) <= BasePage))
    {
        Index++;
    }
 
    /* Count the descriptors */
    DescriptCount = Index;
    while (List[DescriptCount].PageCount != 0)
    {
        DescriptCount++;
    }
 
    /* Check if the existing range conflicts with the new range */
    while ((List[Index].PageCount != 0) &&
           (List[Index].BasePage < EndPage))
    {
        TRACE("AddMemoryDescriptor conflict @%lu: new=[%lx:%lx], existing=[%lx,%lx]\n",
              Index, BasePage, PageCount, List[Index].BasePage, List[Index].PageCount);
 
        /*
         * We have 4 overlapping cases:
         *
         * Case              (a)       (b)       (c)       (d)
         * Existing range  |---|     |-----|    |---|      |---|
         * New range         |---|    |---|    |-----|   |---|
         *
         */
 
        /* Check if the existing range starts before the new range (a)/(b) */
        if (List[Index].BasePage < BasePage)
        {
            /* Check if the existing range extends beyond the new range (b) */
            if (List[Index].BasePage + List[Index].PageCount > EndPage)
            {
                /* Split the descriptor */
                RtlMoveMemory(&List[Index + 1],
                              &List[Index],
                              (DescriptCount - Index) * sizeof(List[0]));
                List[Index + 1].BasePage = EndPage;
                List[Index + 1].PageCount = List[Index].BasePage +
                                            List[Index].PageCount -
                                            List[Index + 1].BasePage;
                List[Index].PageCount = BasePage - List[Index].BasePage;
                Index++;
                DescriptCount++;
                break;
            }
            else
            {
                /* Crop the existing range and continue with the next range */
                List[Index].PageCount = BasePage - List[Index].BasePage;
                Index++;
            }
        }
        /* Check if the existing range is fully covered by the new range (c) */
        else if ((List[Index].BasePage + List[Index].PageCount) <=
                 EndPage)
        {
            /* Delete this descriptor */
            RtlMoveMemory(&List[Index],
                          &List[Index + 1],
                          (DescriptCount - Index) * sizeof(List[0]));
            DescriptCount--;
        }
        /* Otherwise the existing range ends after the new range (d) */
        else
        {
            /* Crop the existing range at the start and bail out */
            List[Index].PageCount -= EndPage - List[Index].BasePage;
            List[Index].BasePage = EndPage;
            break;
        }
    }
 
    /* Make sure we can still add a new descriptor */
    if (DescriptCount >= MaxCount)
    {
        FrLdrBugCheckWithMessage(
            MEMORY_INIT_FAILURE,
            __FILE__,
            __LINE__,
            "Ran out of static memory descriptors!");
    }
 
    /* Insert the new descriptor */
    if (Index < DescriptCount)
    {
        RtlMoveMemory(&List[Index + 1],
                      &List[Index],
                      (DescriptCount - Index) * sizeof(List[0]));
    }
 
    List[Index].BasePage = BasePage;
    List[Index].PageCount = PageCount;
    List[Index].MemoryType = MemoryType;
    DescriptCount++;
 
#if 0 // only enable on demand!
    DbgDumpMemoryMap(List);
#endif
    return DescriptCount;
}

Referenced by PcMemGetBiosMemoryMap(), PcMemGetMemoryMap(), ReserveMemory(), and SetMemory().

ArcGetMemoryDescriptor()

const FREELDR_MEMORY_DESCRIPTOR * ArcGetMemoryDescriptor

(

const FREELDR_MEMORY_DESCRIPTOR *

Current

)

Definition at line 244 of file meminit.c.

{
    if (Current == NULL)
    {
        return BiosMemoryMap;
    }
    else
    {
        Current++;
        if (Current->PageCount == 0) return NULL;
        return Current;
    }
}

Referenced by MmFindLocationForPageLookupTable(), MmGetAddressablePageCountIncludingHoles(), MmInitializeMemoryManager(), and MmInitPageLookupTable().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

MEMORY

)

MmAllocatePagesInLookupTable()

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

Definition at line 557 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 695 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().

MmCheckFreeldrImageFile()

static VOID MmCheckFreeldrImageFile ( VOID  )

static

Definition at line 260 of file meminit.c.

{
#ifndef UEFIBOOT
    PIMAGE_NT_HEADERS NtHeaders;
    PIMAGE_FILE_HEADER FileHeader;
    PIMAGE_OPTIONAL_HEADER OptionalHeader;
 
    /* Get the NT headers */
    NtHeaders = RtlImageNtHeader(&__ImageBase);
    if (!NtHeaders)
    {
        ERR("Could not get NtHeaders!\n");
        FrLdrBugCheckWithMessage(
            FREELDR_IMAGE_CORRUPTION,
            __FILE__,
            __LINE__,
            "Could not get NtHeaders!\n");
    }
 
    /* Check the file header */
    FileHeader = &NtHeaders->FileHeader;
    if ((FileHeader->Machine != IMAGE_FILE_MACHINE_NATIVE) ||
        (FileHeader->NumberOfSections != FREELDR_SECTION_COUNT) ||
        (FileHeader->PointerToSymbolTable != 0) ||  // Symbols stripped
        (FileHeader->NumberOfSymbols != 0) ||       //    ""      ""
        (FileHeader->SizeOfOptionalHeader != sizeof(IMAGE_OPTIONAL_HEADER)))
    {
        ERR("FreeLdr FileHeader is invalid.\n");
        FrLdrBugCheckWithMessage(
            FREELDR_IMAGE_CORRUPTION,
            __FILE__,
            __LINE__,
            "FreeLdr FileHeader is invalid.\n"
            "Machine == 0x%lx, expected 0x%lx\n"
            "NumberOfSections == 0x%lx, expected 0x%lx\n"
            "PointerToSymbolTable == 0x%lx, expected 0\n"
            "NumberOfSymbols == 0x%lx, expected 0\n"
            "SizeOfOptionalHeader == 0x%lx, expected 0x%lx\n",
            FileHeader->Machine, IMAGE_FILE_MACHINE_NATIVE,
            FileHeader->NumberOfSections, FREELDR_SECTION_COUNT,
            FileHeader->PointerToSymbolTable,
            FileHeader->NumberOfSymbols,
            FileHeader->SizeOfOptionalHeader, sizeof(IMAGE_OPTIONAL_HEADER));
    }
 
    /* Check the optional header */
    OptionalHeader = &NtHeaders->OptionalHeader;
    if ((OptionalHeader->Magic != IMAGE_NT_OPTIONAL_HDR_MAGIC) ||
        (OptionalHeader->Subsystem != IMAGE_SUBSYSTEM_NATIVE) ||
        (OptionalHeader->ImageBase != FREELDR_PE_BASE) ||
        (OptionalHeader->SizeOfImage > MAX_FREELDR_PE_SIZE) ||
        (OptionalHeader->SectionAlignment != OptionalHeader->FileAlignment))
    {
        ERR("FreeLdr OptionalHeader is invalid.\n");
        FrLdrBugCheckWithMessage(
            FREELDR_IMAGE_CORRUPTION,
            __FILE__,
            __LINE__,
            "FreeLdr OptionalHeader is invalid.\n"
            "Magic == 0x%lx, expected 0x%lx\n"
            "Subsystem == 0x%lx, expected 1 (native)\n"
            "ImageBase == 0x%lx, expected 0x%lx\n"
            "SizeOfImage == 0x%lx, maximum 0x%lx\n"
            "SectionAlignment 0x%lx doesn't match FileAlignment 0x%lx\n",
            OptionalHeader->Magic, IMAGE_NT_OPTIONAL_HDR_MAGIC,
            OptionalHeader->Subsystem,
            OptionalHeader->ImageBase, FREELDR_PE_BASE,
            OptionalHeader->SizeOfImage, MAX_FREELDR_PE_SIZE,
            OptionalHeader->SectionAlignment, OptionalHeader->FileAlignment);
    }
 
    /* Calculate the full image size */
    FrLdrImageSize = (ULONG_PTR)&__ImageBase + OptionalHeader->SizeOfImage - FREELDR_BASE;
#endif
}

Referenced by MmInitializeMemoryManager().

MmCountFreePagesInLookupTable()

PFN_NUMBER MmCountFreePagesInLookupTable	(	PVOID	PageLookupTable,
		PFN_NUMBER	TotalPageCount
	)

Definition at line 570 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 588 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 647 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 437 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().

MmGetAddressablePageCountIncludingHoles()

PFN_NUMBER MmGetAddressablePageCountIncludingHoles

(

VOID

)

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

MmGetBiosMemoryMap()

ULONG MmGetBiosMemoryMap

(

_Out_ PFREELDR_MEMORY_DESCRIPTOR *

MemoryMap

)

Definition at line 38 of file meminit.c.

{
    *MemoryMap = BiosMemoryMap;
    return BiosMemoryMapEntryCount;
}

Referenced by WinLdrSetupMemoryLayout().

MmGetHighestPhysicalPage()

PFN_NUMBER MmGetHighestPhysicalPage

(

VOID

)

Definition at line 728 of file meminit.c.

{
    return MmHighestPhysicalPage;
}

Referenced by WinLdrSetupMemoryLayout().

MmGetPageNumberFromAddress()

PFN_NUMBER MmGetPageNumberFromAddress

(

PVOID

Address

)

Definition at line 392 of file meminit.c.

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

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

MmGetSystemMemoryMapTypeString()

PCSTR MmGetSystemMemoryMapTypeString

(

TYPE_OF_MEMORY

Type

)

Definition at line 115 of file meminit.c.

{
    return "-";
}

Referenced by MmInitializeMemoryManager(), MmInitPageLookupTable(), and PcMemFinalizeMemoryMap().

MmGetTotalPagesInLookupTable()

PFN_NUMBER MmGetTotalPagesInLookupTable

(

VOID

)

Definition at line 45 of file meminit.c.

{
    return TotalPagesInLookupTable;
}

Referenced by MempAllocatePageTables().

MmInitializeMemoryManager()

BOOLEAN MmInitializeMemoryManager

(

VOID

)

Definition at line 336 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 484 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 527 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().

MmUpdateLastFreePageHint()

VOID MmUpdateLastFreePageHint	(	PVOID	PageLookupTable,
		PFN_NUMBER	TotalPageCount
	)

Definition at line 680 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

BiosMemoryMap

PFREELDR_MEMORY_DESCRIPTOR BiosMemoryMap

Definition at line 33 of file meminit.c.

Referenced by ArcGetMemoryDescriptor(), MmGetBiosMemoryMap(), MmInitializeMemoryManager(), and WinLdrSetupMemoryLayout().

BiosMemoryMapEntryCount

ULONG BiosMemoryMapEntryCount

Definition at line 34 of file meminit.c.

Referenced by MmGetBiosMemoryMap(), MmInitializeMemoryManager(), and WinLdrSetupMemoryLayout().

FreePagesInLookupTable

PFN_NUMBER FreePagesInLookupTable = 0

Definition at line 28 of file meminit.c.

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

FrLdrImageSize

SIZE_T FrLdrImageSize

Definition at line 35 of file meminit.c.

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

LastFreePageHint

PFN_NUMBER LastFreePageHint = 0

Definition at line 29 of file meminit.c.

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

MmHighestPhysicalPage

PFN_NUMBER MmHighestPhysicalPage = 0

Definition at line 31 of file meminit.c.

Referenced by MiAllocatePagesForMdl(), MiComputeNonPagedPoolVa(), MiDecrementReferenceCount(), MiInitializeSessionIds(), MiInsertPageInFreeList(), MiInsertPageInList(), MiInsertStandbyListAtFront(), MiSetupPfnForPageTable(), MmAllocateContiguousMemory(), MmAllocateContiguousMemorySpecifyCache(), MmCreatePhysicalMemorySection(), MmGetAddressablePageCountIncludingHoles(), MmGetHighestPhysicalPage(), MmInitializeMemoryManager(), MmMarkPagesInLookupTable(), MmReferencePage(), NtMapViewOfSection(), and QSI_DEF().

MmLowestPhysicalPage

PFN_NUMBER MmLowestPhysicalPage = 0xFFFFFFFF

Definition at line 30 of file meminit.c.

Referenced by MiInitializeSessionIds(), MiInsertPageInFreeList(), MiInsertPageInList(), MiInsertStandbyListAtFront(), MmAllocatePagesInLookupTable(), MmAreMemoryPagesAvailable(), MmFindAvailablePages(), MmFindAvailablePagesBeforePage(), MmGetAddressablePageCountIncludingHoles(), MmInitPageLookupTable(), MmMarkPagesInLookupTable(), MmUpdateLastFreePageHint(), and QSI_DEF().

PageLookupTableAddress

PVOID PageLookupTableAddress = NULL

Definition at line 26 of file meminit.c.

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

TotalPagesInLookupTable

PFN_NUMBER TotalPagesInLookupTable = 0

Definition at line 27 of file meminit.c.

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