descriptor.c File Reference

#include "bl.h"

Include dependency graph for descriptor.c:

Go to the source code of this file.

Functions
LONG	MmMdpLookupTypePrecedenceIndex (_In_ BL_MEMORY_TYPE Type)
BOOLEAN	MmMdpHasPrecedence (_In_ BL_MEMORY_TYPE Type1, _In_ BL_MEMORY_TYPE Type2)
VOID	MmMdpSwitchToDynamicDescriptors (_In_ ULONG Count)
NTSTATUS	MmMdFreeDescriptor (_In_ PBL_MEMORY_DESCRIPTOR MemoryDescriptor)
VOID	MmMdpSaveCurrentListPointer (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PLIST_ENTRY Current)
ULONG	MmMdCountList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList)
VOID	MmMdInitializeList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ ULONG Type, _In_ PLIST_ENTRY ListHead)
NTSTATUS	MmMdCopyList (_In_ PBL_MEMORY_DESCRIPTOR_LIST DestinationList, _In_ PBL_MEMORY_DESCRIPTOR_LIST SourceList, _In_opt_ PBL_MEMORY_DESCRIPTOR ListDescriptor, _Out_ PULONG ActualCount, _In_ ULONG Count, _In_ ULONG Flags)
VOID	MmMdRemoveDescriptorFromList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PBL_MEMORY_DESCRIPTOR Entry)
VOID	MmMdFreeList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList)
PBL_MEMORY_DESCRIPTOR	MmMdInitByteGranularDescriptor (_In_ ULONG Flags, _In_ BL_MEMORY_TYPE Type, _In_ ULONGLONG BasePage, _In_ ULONGLONG VirtualPage, _In_ ULONGLONG PageCount)
NTSTATUS	MmMdTruncateDescriptors (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PBL_MEMORY_DESCRIPTOR_LIST NewList, _In_ ULONGLONG BasePage)
BOOLEAN	MmMdpTruncateDescriptor (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PBL_MEMORY_DESCRIPTOR MemoryDescriptor, _In_ ULONG Flags)
BOOLEAN	MmMdpCoalesceDescriptor (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PBL_MEMORY_DESCRIPTOR MemoryDescriptor, _In_ ULONG Flags)
NTSTATUS	MmMdAddDescriptorToList (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ PBL_MEMORY_DESCRIPTOR MemoryDescriptor, _In_ ULONG Flags)
NTSTATUS	MmMdRemoveRegionFromMdlEx (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ ULONG Flags, _In_ ULONGLONG BasePage, _In_ ULONGLONG PageCount, _Out_opt_ PBL_MEMORY_DESCRIPTOR_LIST NewMdList)
PBL_MEMORY_DESCRIPTOR	MmMdFindDescriptorFromMdl (_In_ PBL_MEMORY_DESCRIPTOR_LIST MdList, _In_ ULONG Flags, _In_ ULONGLONG Page)
PBL_MEMORY_DESCRIPTOR	MmMdFindDescriptor (_In_ ULONG WhichList, _In_ ULONG Flags, _In_ ULONGLONG Page)
BOOLEAN	MmMdFindSatisfyingRegion (_In_ PBL_MEMORY_DESCRIPTOR Descriptor, _Out_ PBL_MEMORY_DESCRIPTOR NewDescriptor, _In_ ULONGLONG Pages, _In_ PBL_ADDRESS_RANGE BaseRange, _In_ PBL_ADDRESS_RANGE VirtualRange, _In_ BOOLEAN TopDown, _In_ BL_MEMORY_TYPE MemoryType, _In_ ULONG Flags, _In_ ULONG Alignment)
VOID	MmMdFreeGlobalDescriptors (VOID)
VOID	MmMdInitialize (_In_ ULONG Phase, _In_ PBL_LIBRARY_PARAMETERS LibraryParameters)

Variables
BL_MEMORY_DESCRIPTOR	MmStaticMemoryDescriptors [512]
ULONG	MmGlobalMemoryDescriptorCount
PBL_MEMORY_DESCRIPTOR	MmGlobalMemoryDescriptors
ULONG	MmGlobalMemoryDescriptorsUsed
PBL_MEMORY_DESCRIPTOR	MmDynamicMemoryDescriptors
ULONG	MmDynamicMemoryDescriptorCount
BL_MEMORY_TYPE	MmPlatformMemoryTypePrecedence []

Function Documentation

MmMdAddDescriptorToList()

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

Definition at line 582 of file descriptor.c.

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

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

MmMdCopyList()

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

Definition at line 249 of file descriptor.c.

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

Referenced by BlMmGetMemoryMap().

MmMdCountList()

ULONG MmMdCountList

(

_In_ PBL_MEMORY_DESCRIPTOR_LIST

MdList

)

Definition at line 205 of file descriptor.c.

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

Referenced by BlMmGetMemoryMap().

MmMdFindDescriptor()

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

Definition at line 1049 of file descriptor.c.

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

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

MmMdFindDescriptorFromMdl()

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

Definition at line 960 of file descriptor.c.

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

Referenced by MmFwGetMemoryMap(), and MmMdFindDescriptor().

MmMdFindSatisfyingRegion()

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

Definition at line 1158 of file descriptor.c.

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

Referenced by MmPapAllocateRegionFromMdl().

MmMdFreeDescriptor()

NTSTATUS MmMdFreeDescriptor

(

_In_ PBL_MEMORY_DESCRIPTOR

MemoryDescriptor

)

Definition at line 157 of file descriptor.c.

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

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

MmMdFreeGlobalDescriptors()

VOID MmMdFreeGlobalDescriptors

(

VOID

)

Definition at line 1332 of file descriptor.c.

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

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

MmMdFreeList()

VOID MmMdFreeList

(

_In_ PBL_MEMORY_DESCRIPTOR_LIST

MdList

)

Definition at line 356 of file descriptor.c.

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

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

MmMdInitByteGranularDescriptor()

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

Definition at line 377 of file descriptor.c.

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

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

MmMdInitialize()

VOID MmMdInitialize	(	_In_ ULONG	Phase,
		_In_ PBL_LIBRARY_PARAMETERS	LibraryParameters
	)

Definition at line 1384 of file descriptor.c.

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

Referenced by BlpMmInitialize().

MmMdInitializeList()

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

Definition at line 222 of file descriptor.c.

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

Referenced by BlMmGetMemoryMap(), and MmMdRemoveRegionFromMdlEx().

MmMdpCoalesceDescriptor()

BOOLEAN MmMdpCoalesceDescriptor	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		_In_ PBL_MEMORY_DESCRIPTOR	MemoryDescriptor,
		_In_ ULONG	Flags
	)

Definition at line 528 of file descriptor.c.

{
    PBL_MEMORY_DESCRIPTOR NextDescriptor, PreviousDescriptor;
    PLIST_ENTRY NextEntry, PreviousEntry;
    ULONGLONG EndPage, PreviousEndPage, PreviousMappedEndPage, MappedEndPage;
 
    /* Get the next descriptor */
    NextEntry = MemoryDescriptor->ListEntry.Flink;
    NextDescriptor = CONTAINING_RECORD(NextEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
 
    /* Get the previous descriptor */
    PreviousEntry = MemoryDescriptor->ListEntry.Blink;
    PreviousDescriptor = CONTAINING_RECORD(PreviousEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
 
    /* Calculate end pages */
    EndPage = MemoryDescriptor->BasePage + MemoryDescriptor->PageCount;
    MappedEndPage = MemoryDescriptor->BasePage + MemoryDescriptor->PageCount;
    PreviousMappedEndPage = PreviousDescriptor->VirtualPage + PreviousDescriptor->PageCount;
    PreviousEndPage = PreviousDescriptor->BasePage + PreviousDescriptor->PageCount;
    PreviousMappedEndPage = PreviousDescriptor->VirtualPage + PreviousDescriptor->PageCount;
 
    /* Check if the previous entry touches the current entry, and is compatible */
    if ((PreviousEntry != MdList->First) &&
        (PreviousDescriptor->Type == MemoryDescriptor->Type) &&
        ((PreviousDescriptor->Flags ^ MemoryDescriptor->Flags) & 0x1B19FFFF) &&
        (PreviousEndPage == MemoryDescriptor->BasePage) &&
        ((!(MemoryDescriptor->VirtualPage) && !(PreviousDescriptor->VirtualPage)) ||
          ((MemoryDescriptor->VirtualPage) && (PreviousDescriptor->VirtualPage) &&
           (PreviousMappedEndPage == MemoryDescriptor->VirtualPage))))
    {
        EfiPrintf(L"Previous descriptor coalescable!\r\n");
    }
 
    /* CHeck if the current entry touches the next entry, and is compatible */
    if ((NextEntry != MdList->First) &&
        (NextDescriptor->Type == MemoryDescriptor->Type) &&
        ((NextDescriptor->Flags ^ MemoryDescriptor->Flags) & 0x1B19FFFF) &&
        (EndPage == NextDescriptor->BasePage) &&
        ((!(MemoryDescriptor->VirtualPage) && !(NextDescriptor->VirtualPage)) ||
          ((MemoryDescriptor->VirtualPage) && (NextDescriptor->VirtualPage) &&
           (MappedEndPage == NextDescriptor->VirtualPage))))
    {
        EfiPrintf(L"Next descriptor coalescable!\r\n");
    }
 
    /* Nothing to do */
    return FALSE;
}

Referenced by MmMdAddDescriptorToList().

MmMdpHasPrecedence()

BOOLEAN MmMdpHasPrecedence	(	_In_ BL_MEMORY_TYPE	Type1,
		_In_ BL_MEMORY_TYPE	Type2
	)

Definition at line 64 of file descriptor.c.

{
    BL_MEMORY_CLASS Class1, Class2;
    ULONG i, j;
 
    /* It isn't free RAM, but the comparator is -- it succeeds it */
    if (Type2 == BlConventionalMemory)
    {
        return TRUE;
    }
 
    /* Descriptor is free RAM -- it precedes */
    if (Type1 == BlConventionalMemory)
    {
        return FALSE;
    }
 
    /* Descriptor is not system, application, or loader class -- it precedes */
    Class1 = Type1 >> BL_MEMORY_CLASS_SHIFT;
    if ((Class1 != BlSystemClass) &&
        (Class1 != BlApplicationClass) &&
        (Class1 != BlLoaderClass))
    {
        return TRUE;
    }
 
    /* It isn't one of those classes, but the comparator it -- it succeeds it */
    Class2 = Type2 >> BL_MEMORY_CLASS_SHIFT;
    if ((Class2 != BlSystemClass) &&
        (Class2 != BlApplicationClass) &&
        (Class2 != BlLoaderClass))
    {
        return FALSE;
    }
 
    /* Descriptor is system class */
    if (Class1 == BlSystemClass)
    {
        /* If the other guy isn't, system wins */
        if (Class2 != BlSystemClass)
        {
            return TRUE;
        }
 
        /* Scan for the descriptor's system precedence index */
        i = MmMdpLookupTypePrecedenceIndex(Type1);
        j = MmMdpLookupTypePrecedenceIndex(Type2);
 
        /* Does the current have a valid index? */
        if (i == 0xFFFFFFFF)
        {
            return TRUE;
        }
 
        /* Yes, what about the comparator? */
        if (j == 0xFFFFFFFF)
        {
            return FALSE;
        }
 
        /* Let the indexes fight! */
        return i <= j;
    }
 
    /* Descriptor is not system class, but comparator is -- it succeeds it */
    if (Class2 == BlSystemClass)
    {
        return FALSE;
    }
 
    /* Descriptor is loader class -- it preceedes */
    if (Class1 == BlLoaderClass)
    {
        return TRUE;
    }
 
    /* It isn't loader class  -- if the other guy is, succeed it */
    return Class2 != BlLoaderClass;
}

Referenced by MmMdAddDescriptorToList().

MmMdpLookupTypePrecedenceIndex()

LONG MmMdpLookupTypePrecedenceIndex

(

_In_ BL_MEMORY_TYPE

Type

)

Definition at line 41 of file descriptor.c.

{
    ULONG i;
 
    /* Check the precedence array */
    for (i = 0; i < RTL_NUMBER_OF(MmPlatformMemoryTypePrecedence); i++)
    {
        /* Check for a match */
        if (MmPlatformMemoryTypePrecedence[i] == Type)
        {
            /* Return the index */
            return i;
        }
    }
 
    /* Invalid index type */
    return -1;
}

Referenced by MmMdpHasPrecedence().

MmMdpSaveCurrentListPointer()

VOID MmMdpSaveCurrentListPointer	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		_In_ PLIST_ENTRY	Current
	)

Definition at line 185 of file descriptor.c.

{
    PBL_MEMORY_DESCRIPTOR FirstEntry, LastEntry;
 
    /* Make sure that this is not a global descriptor and not the first one */
    FirstEntry = &MmGlobalMemoryDescriptors[0];
    LastEntry = &MmGlobalMemoryDescriptors[MmGlobalMemoryDescriptorCount];
    if ((((ULONG_PTR)Current < (ULONG_PTR)FirstEntry) ||
         ((ULONG_PTR)Current >= (ULONG_PTR)LastEntry)) &&
        (Current != MdList->First))
    {
        /* Save this as the current pointer */
        MdList->This = Current;
    }
}

Referenced by MmMdAddDescriptorToList(), and MmMdRemoveDescriptorFromList().

MmMdpSwitchToDynamicDescriptors()

VOID MmMdpSwitchToDynamicDescriptors

(

_In_ ULONG

Count

)

Definition at line 148 of file descriptor.c.

{
    EfiPrintf(L"Dynamic switch NOT SUPPORTED!!!\r\n");
    EfiStall(10000000);
}

Referenced by MmMdInitialize().

MmMdpTruncateDescriptor()

BOOLEAN MmMdpTruncateDescriptor	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		_In_ PBL_MEMORY_DESCRIPTOR	MemoryDescriptor,
		_In_ ULONG	Flags
	)

Definition at line 486 of file descriptor.c.

{
    PBL_MEMORY_DESCRIPTOR NextDescriptor, PreviousDescriptor;
    PLIST_ENTRY NextEntry, PreviousEntry;
    ULONGLONG EndPage, PreviousEndPage;// , NextEndPage;
 
    /* Get the next descriptor */
    NextEntry = MemoryDescriptor->ListEntry.Flink;
    NextDescriptor = CONTAINING_RECORD(NextEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
 
    /* Get the previous descriptor */
    PreviousEntry = MemoryDescriptor->ListEntry.Blink;
    PreviousDescriptor = CONTAINING_RECORD(PreviousEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
 
    /* Calculate end pages */
    EndPage = MemoryDescriptor->BasePage + MemoryDescriptor->PageCount;
    //NextEndPage = NextDescriptor->BasePage + NextDescriptor->PageCount;
    PreviousEndPage = PreviousDescriptor->BasePage + PreviousDescriptor->PageCount;
 
    /* Check for backward overlap */
    if ((PreviousEntry != MdList->First) && (MemoryDescriptor->BasePage < PreviousEndPage))
    {
        EfiPrintf(L"Overlap detected -- this is unexpected on x86/x64 platforms\r\n");
        EfiStall(1000000);
    }
 
    /* Check for forward overlap */
    if ((NextEntry != MdList->First) && (NextDescriptor->BasePage < EndPage))
    {
        EfiPrintf(L"Overlap detected -- this is unexpected on x86/x64 platforms\r\n");
        EfiStall(1000000);
    }
 
    /* Nothing to do */
    return FALSE;
}

Referenced by MmMdAddDescriptorToList().

MmMdRemoveDescriptorFromList()

VOID MmMdRemoveDescriptorFromList	(	_In_ PBL_MEMORY_DESCRIPTOR_LIST	MdList,
		_In_ PBL_MEMORY_DESCRIPTOR	Entry
	)

Definition at line 338 of file descriptor.c.

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

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

MmMdRemoveRegionFromMdlEx()

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

Definition at line 692 of file descriptor.c.

{
    BOOLEAN HaveNewList, UseVirtualPage;
    NTSTATUS Status;
    PLIST_ENTRY ListHead, NextEntry;
    PBL_MEMORY_DESCRIPTOR Descriptor, NewDescriptor, ListDescriptor;
    BL_MEMORY_DESCRIPTOR OldDescriptor;
    ULONGLONG RegionSize;
    ULONGLONG FoundBasePage, FoundEndPage, FoundPageCount, EndPage, VirtualPage;
 
    /* Set initial status */
    Status = STATUS_SUCCESS;
    ListDescriptor = NULL;
    NewDescriptor = NULL;
    HaveNewList = FALSE;
 
    /* Check if removed descriptors should go into a new list */
    if (NewMdList != NULL)
    {
        /* Initialize it */
        MmMdInitializeList(NewMdList, MdList->Type, NULL);
 
        /* Remember for later */
        HaveNewList = TRUE;
    }
 
    /* Is the region being removed physical? */
    UseVirtualPage = FALSE;
    if (!(Flags & BL_MM_REMOVE_VIRTUAL_REGION_FLAG))
    {
        /* Is this a list of virtual descriptors? */
        if (MdList->Type == BlMdVirtual)
        {
            /* Request is nonsensical, fail */
            Status = STATUS_INVALID_PARAMETER;
            goto Quickie;
        }
    }
    else
    {
        /* Is this a list of physical descriptors? */
        if (MdList->Type == BlMdPhysical)
        {
            /* We'll have to use the virtual page instead */
            UseVirtualPage = TRUE;
        }
    }
 
    /* Loop the list*/
    ListHead = MdList->First;
    NextEntry = ListHead->Flink;
    while (NextEntry != ListHead)
    {
        /* Get the descriptor */
        Descriptor = CONTAINING_RECORD(NextEntry, BL_MEMORY_DESCRIPTOR, ListEntry);
 
        /* Extract range details */
        FoundBasePage = UseVirtualPage ? Descriptor->VirtualPage : Descriptor->BasePage;
        FoundPageCount = Descriptor->PageCount;
        FoundEndPage = FoundBasePage + FoundPageCount;
        EndPage = PageCount + BasePage;
 
        /* Make a copy of the original descriptor */
        OldDescriptor = *Descriptor;
 
        /* Check if the region to be removed starts after the found region starts */
        if ((BasePage > FoundBasePage) || (FoundBasePage >= EndPage))
        {
            /* Check if the region ends after the found region */
            if ((BasePage >= FoundEndPage) || (FoundEndPage > EndPage))
            {
                /* Check if the found region starts after the region or ends before the region */
                if ((FoundBasePage >= BasePage) || (EndPage >= FoundEndPage))
                {
                    /* This is a fully-mapped descriptor -- change nothing */
                    OldDescriptor.PageCount = 0;
                }
                else
                {
                    /* This descriptor fully covers the entire allocation */
                    FoundBasePage = Descriptor->BasePage;
                    VirtualPage = Descriptor->VirtualPage;
                    FoundPageCount = BasePage - FoundBasePage;
 
                    /* This is how many pages we will eat away from the descriptor */
                    RegionSize = FoundPageCount + PageCount;
 
                    /* Update the descriptor to account for the consumed pages */
                    Descriptor->BasePage += RegionSize;
                    Descriptor->PageCount -= RegionSize;
                    if (VirtualPage)
                    {
                        Descriptor->VirtualPage += RegionSize;
                    }
 
                    /* Initialize a descriptor for the start of the region */
                    NewDescriptor = MmMdInitByteGranularDescriptor(Descriptor->Flags,
                                                                   Descriptor->Type,
                                                                   FoundBasePage,
                                                                   VirtualPage,
                                                                   FoundPageCount);
                    if (!NewDescriptor)
                    {
                        Status = STATUS_NO_MEMORY;
                        goto Quickie;
                    }
 
                    /* Add it into the list */
                    Status = MmMdAddDescriptorToList(MdList, NewDescriptor, Flags);
                    if (!NT_SUCCESS(Status))
                    {
                        Status = STATUS_NO_MEMORY;
                        goto Quickie;
                    }
 
                    /* Don't free it on exit path */
                    NewDescriptor = NULL;
 
                    /* Adjust the leftover descriptor */
                    OldDescriptor.BasePage += FoundPageCount;
                    OldDescriptor.PageCount = PageCount;
                    if (OldDescriptor.VirtualPage)
                    {
                        OldDescriptor.VirtualPage += FoundPageCount;
                    }
                }
            }
            else
            {
                /* This descriptor contains the entire allocation */
                RegionSize = FoundEndPage - BasePage;
                Descriptor->PageCount -= RegionSize;
 
                /* Adjust the leftover descriptor */
                OldDescriptor.BasePage += Descriptor->PageCount;
                OldDescriptor.PageCount = RegionSize;
                if (OldDescriptor.VirtualPage)
                {
                    OldDescriptor.VirtualPage += FoundPageCount;
                }
            }
 
            /* Go to the next entry */
            NextEntry = NextEntry->Flink;
        }
        else
        {
            /*
             * This descriptor contains the end of the allocation. It may:
             *
             * - Contain the full allocation (i.e.: the start is aligned)
             * - Contain parts of the end of the allocation (i.e.: the end is beyond)
             * - Contain the entire tail end of the allocation (i..e:the end is within)
             *
             * So first, figure out if we cover the entire end or not
             */
            if (EndPage < FoundEndPage)
            {
                /* The allocation goes past the end of this descriptor */
                FoundEndPage = EndPage;
            }
 
            /* This is how many pages we will eat away from the descriptor */
            FoundPageCount = FoundEndPage - FoundBasePage;
 
            /* Update the descriptor to account for the consumed pages */
            Descriptor->BasePage += FoundPageCount;
            Descriptor->PageCount -= FoundPageCount;
            if (Descriptor->VirtualPage)
            {
                Descriptor->VirtualPage += FoundPageCount;
            }
 
            /* Go to the next entry */
            NextEntry = NextEntry->Flink;
 
            /* Check if the descriptor is now empty */
            if (!Descriptor->PageCount)
            {
                /* Remove it */
                MmMdRemoveDescriptorFromList(MdList, Descriptor);
 
                /* Check if we're supposed to insert it into a new list */
                if (HaveNewList)
                {
                    /* This is the one to add */
                    ListDescriptor = Descriptor;
                }
                else
                {
                    /* Nope -- just get rid of it */
                    MmMdFreeDescriptor(Descriptor);
                }
            }
        }
 
        /* Is there a remainder descriptor, and do we have a list for it */
        if ((OldDescriptor.PageCount) && (HaveNewList))
        {
            /* Did we already chop off the descriptor? */
            if (ListDescriptor)
            {
                /* Use what we previously chopped */
                *ListDescriptor = OldDescriptor;
            }
            else
            {
                /* First time, so build a descriptor to describe the leftover */
                ListDescriptor = MmMdInitByteGranularDescriptor(OldDescriptor.Flags,
                                                                OldDescriptor.Type,
                                                                OldDescriptor.BasePage,
                                                                OldDescriptor.VirtualPage,
                                                                OldDescriptor.PageCount);
                if (!ListDescriptor)
                {
                    Status = STATUS_NO_MEMORY;
                    goto Quickie;
                }
 
                /* Add it into the list */
                Status = MmMdAddDescriptorToList(NewMdList, ListDescriptor, 0);
                if (!NT_SUCCESS(Status))
                {
                    goto Quickie;
                }
 
                /* Don't free on exit path */
                ListDescriptor = NULL;
            }
        }
    }
 
Quickie:
    /* Check for failure cleanup */
    if (!NT_SUCCESS(Status))
    {
        /* Did we have to build a new list? */
        if (HaveNewList)
        {
            /* Free and re-initialize it */
            MmMdFreeList(NewMdList);
            MmMdInitializeList(NewMdList, MdList->Type, NULL);
        }
 
        /* Check if we had a list descriptor, and free it */
        if (ListDescriptor)
        {
            MmMdFreeDescriptor(ListDescriptor);
        }
 
        /* Check if we had a new descriptor, and free it */
        if (NewDescriptor)
        {
            MmMdFreeDescriptor(NewDescriptor);
        }
    }
 
    /* All done */
    return Status;
}

MmMdTruncateDescriptors()

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

Definition at line 410 of file descriptor.c.

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

Referenced by MmPaTruncateMemory().

Variable Documentation

MmDynamicMemoryDescriptorCount

ULONG MmDynamicMemoryDescriptorCount

Definition at line 20 of file descriptor.c.

Referenced by MmMdFreeDescriptor().

MmDynamicMemoryDescriptors

PBL_MEMORY_DESCRIPTOR MmDynamicMemoryDescriptors

Definition at line 19 of file descriptor.c.

Referenced by MmMdFreeDescriptor().

MmGlobalMemoryDescriptorCount

ULONG MmGlobalMemoryDescriptorCount

Definition at line 16 of file descriptor.c.

Referenced by MmMdCopyList(), MmMdInitByteGranularDescriptor(), MmMdInitialize(), and MmMdpSaveCurrentListPointer().

MmGlobalMemoryDescriptors

PBL_MEMORY_DESCRIPTOR MmGlobalMemoryDescriptors

Definition at line 17 of file descriptor.c.

Referenced by MmMdCopyList(), MmMdFreeGlobalDescriptors(), MmMdInitByteGranularDescriptor(), MmMdInitialize(), and MmMdpSaveCurrentListPointer().

MmGlobalMemoryDescriptorsUsed

ULONG MmGlobalMemoryDescriptorsUsed

Definition at line 18 of file descriptor.c.

Referenced by MmMdCopyList(), MmMdFreeGlobalDescriptors(), MmMdInitByteGranularDescriptor(), and MmMdInitialize().

MmPlatformMemoryTypePrecedence

BL_MEMORY_TYPE MmPlatformMemoryTypePrecedence[]

Initial value:

=
{
    BlReservedMemory,
    BlUnusableMemory,
    BlDeviceIoMemory,
    BlDevicePortMemory,
    BlPalMemory,
    BlEfiRuntimeCodeMemory,
    BlEfiRuntimeDataMemory,
    BlAcpiNvsMemory,
    BlAcpiReclaimMemory,
    BlEfiBootMemory,
    BlConventionalMemory,
    BlConventionalZeroedMemory
}

Definition at line 22 of file descriptor.c.

Referenced by MmMdpLookupTypePrecedenceIndex().

MmStaticMemoryDescriptors

BL_MEMORY_DESCRIPTOR MmStaticMemoryDescriptors[512]

Definition at line 15 of file descriptor.c.

Referenced by MmMdFreeDescriptor(), and MmMdInitialize().