X86StandaloneMmMemLibInternal.c

Go to the documentation of this file.

 
#include "StandaloneMmMemLibInternal.h"
#include <PiMm.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/HobLib.h>
 
typedef struct {
  EFI_PHYSICAL_ADDRESS    Base;
  UINT64                  Length;
} NON_MM_MEMORY_RANGE;
 
NON_MM_MEMORY_RANGE  *mValidNonMmramRanges;
UINTN                mValidNonMmramCount;
 
//
// Maximum support address used to check input buffer
//
extern EFI_PHYSICAL_ADDRESS  mMmMemLibInternalMaximumSupportAddress;
 
VOID
MmMemLibCalculateMaximumSupportAddress (
  VOID
  )
{
  VOID    *Hob;
  UINT32  RegEax;
  UINT8   PhysicalAddressBits;
 
  //
  // Get physical address bits supported.
  //
  Hob = GetFirstHob (EFI_HOB_TYPE_CPU);
  if (Hob != NULL) {
    PhysicalAddressBits = ((EFI_HOB_CPU *)Hob)->SizeOfMemorySpace;
  } else {
    AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
    if (RegEax >= 0x80000008) {
      AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);
      PhysicalAddressBits = (UINT8)RegEax;
    } else {
      PhysicalAddressBits = 36;
    }
  }
 
  //
  // IA-32e paging translates 48-bit linear addresses to 52-bit physical addresses.
  //
  ASSERT (PhysicalAddressBits <= 52);
  if (PhysicalAddressBits > 48) {
    PhysicalAddressBits = 48;
  }
 
  //
  // Save the maximum support address in one global variable
  //
  mMmMemLibInternalMaximumSupportAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)(LShiftU64 (1, PhysicalAddressBits) - 1);
  DEBUG ((DEBUG_INFO, "mMmMemLibInternalMaximumSupportAddress = 0x%lx\n", mMmMemLibInternalMaximumSupportAddress));
}
 
STATIC
VOID
MergeOverlappedOrContinuousRanges (
  IN OUT NON_MM_MEMORY_RANGE  *MemoryRange,
  IN OUT UINTN                *MemoryRangeSize
  )
{
  NON_MM_MEMORY_RANGE   *MemoryRangeEntry;
  NON_MM_MEMORY_RANGE   *MemoryRangeEnd;
  NON_MM_MEMORY_RANGE   *NewMemoryRangeEntry;
  NON_MM_MEMORY_RANGE   *NextMemoryRangeEntry;
  EFI_PHYSICAL_ADDRESS  End;
 
  MemoryRangeEntry    = MemoryRange;
  NewMemoryRangeEntry = MemoryRange;
  MemoryRangeEnd      = (NON_MM_MEMORY_RANGE *)((UINT8 *)MemoryRange + *MemoryRangeSize);
  while ((UINTN)MemoryRangeEntry < (UINTN)MemoryRangeEnd) {
    NextMemoryRangeEntry = MemoryRangeEntry + 1;
 
    do {
      if (((UINTN)NextMemoryRangeEntry < (UINTN)MemoryRangeEnd) &&
          ((MemoryRangeEntry->Base + MemoryRangeEntry->Length) >= NextMemoryRangeEntry->Base))
      {
        //
        // Merge the overlapped or continuous ranges.
        //
        End = MAX (
                MemoryRangeEntry->Base + MemoryRangeEntry->Length,
                NextMemoryRangeEntry->Base + NextMemoryRangeEntry->Length
                );
        MemoryRangeEntry->Length = End - MemoryRangeEntry->Base;
 
        NextMemoryRangeEntry++;
        continue;
      } else {
        //
        // Copy the processed independent range to the new index location.
        //
        CopyMem (NewMemoryRangeEntry, MemoryRangeEntry, sizeof (NON_MM_MEMORY_RANGE));
        break;
      }
    } while (TRUE);
 
    MemoryRangeEntry = NextMemoryRangeEntry;
    NewMemoryRangeEntry++;
  }
 
  *MemoryRangeSize = (UINTN)NewMemoryRangeEntry - (UINTN)MemoryRange;
}
 
INTN
EFIAPI
NonMmMapCompare (
  IN  CONST VOID  *Buffer1,
  IN  CONST VOID  *Buffer2
  )
{
  if (((NON_MM_MEMORY_RANGE *)Buffer1)->Base > ((NON_MM_MEMORY_RANGE *)Buffer2)->Base) {
    return 1;
  } else if (((NON_MM_MEMORY_RANGE *)Buffer1)->Base < ((NON_MM_MEMORY_RANGE *)Buffer2)->Base) {
    return -1;
  }
 
  return 0;
}
 
VOID
MmMemLibInitializeValidNonMmramRanges (
  VOID
  )
{
  EFI_PEI_HOB_POINTERS  Hob;
  UINTN                 Count;
  UINTN                 Index;
  UINTN                 RangeSize;
  NON_MM_MEMORY_RANGE   SortBuffer;
 
  mValidNonMmramRanges = NULL;
  mValidNonMmramCount  = 0;
 
  Count     = 0;
  Index     = 0;
  RangeSize = 0;
 
  //
  // 1. Get the count.
  //
  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR);
  while (Hob.Raw != NULL) {
    Count++;
    Hob.Raw = GET_NEXT_HOB (Hob);
    Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw);
  }
 
  //
  // 2. Store the initial data.
  //
  RangeSize            = sizeof (NON_MM_MEMORY_RANGE) * Count;
  mValidNonMmramRanges = (NON_MM_MEMORY_RANGE *)AllocateZeroPool (RangeSize);
  ASSERT (mValidNonMmramRanges != NULL);
 
  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR);
  while (Hob.Raw != NULL) {
    mValidNonMmramRanges[Index].Base   = Hob.ResourceDescriptor->PhysicalStart;
    mValidNonMmramRanges[Index].Length = Hob.ResourceDescriptor->ResourceLength;
    Index++;
 
    Hob.Raw = GET_NEXT_HOB (Hob);
    Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw);
  }
 
  ASSERT (Index == Count);
 
  //
  // 3. Sort the data.
  //
  QuickSort (mValidNonMmramRanges, Count, sizeof (NON_MM_MEMORY_RANGE), (BASE_SORT_COMPARE)NonMmMapCompare, &SortBuffer);
 
  //
  // 4. Merge the overlapped or continuous ranges.
  //
  MergeOverlappedOrContinuousRanges (mValidNonMmramRanges, &RangeSize);
  mValidNonMmramCount = RangeSize/sizeof (NON_MM_MEMORY_RANGE);
}
 
VOID
MmMemLibFreeValidNonMmramRanges (
  VOID
  )
{
  if (mValidNonMmramRanges != NULL) {
    FreePool (mValidNonMmramRanges);
  }
}
 
BOOLEAN
MmMemLibIsValidNonMmramRange (
  IN EFI_PHYSICAL_ADDRESS  Buffer,
  IN UINT64                Length
  )
{
  UINTN  Index;
 
  for (Index = 0; Index < mValidNonMmramCount; Index++) {
    if ((Buffer >= mValidNonMmramRanges[Index].Base) &&
        (Buffer + Length <= mValidNonMmramRanges[Index].Base + mValidNonMmramRanges[Index].Length))
    {
      return TRUE;
    }
  }
 
  return FALSE;
}