2 UEFI Memory page management functions.
4 Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 #define EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT (EFI_PAGE_SIZE)
21 // Entry for tracking the memory regions for each memory type to coalesce similar memory types
24 EFI_PHYSICAL_ADDRESS BaseAddress
;
25 EFI_PHYSICAL_ADDRESS MaximumAddress
;
26 UINT64 CurrentNumberOfPages
;
28 UINTN InformationIndex
;
31 } EFI_MEMORY_TYPE_STATISTICS
;
34 // MemoryMap - The current memory map
36 UINTN mMemoryMapKey
= 0;
38 #define MAX_MAP_DEPTH 6
41 /// mMapDepth - depth of new descriptor stack
45 /// mMapStack - space to use as temp storage to build new map descriptors
47 MEMORY_MAP mMapStack
[MAX_MAP_DEPTH
];
48 UINTN mFreeMapStack
= 0;
50 /// This list maintain the free memory map list
52 LIST_ENTRY mFreeMemoryMapEntryList
= INITIALIZE_LIST_HEAD_VARIABLE (mFreeMemoryMapEntryList
);
53 BOOLEAN mMemoryTypeInformationInitialized
= FALSE
;
55 EFI_MEMORY_TYPE_STATISTICS mMemoryTypeStatistics
[EfiMaxMemoryType
+ 1] = {
56 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, TRUE
, FALSE
}, // EfiReservedMemoryType
57 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
}, // EfiLoaderCode
58 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
}, // EfiLoaderData
59 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
}, // EfiBootServicesCode
60 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
}, // EfiBootServicesData
61 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, TRUE
, TRUE
}, // EfiRuntimeServicesCode
62 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, TRUE
, TRUE
}, // EfiRuntimeServicesData
63 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
}, // EfiConventionalMemory
64 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
}, // EfiUnusableMemory
65 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, TRUE
, FALSE
}, // EfiACPIReclaimMemory
66 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, TRUE
, FALSE
}, // EfiACPIMemoryNVS
67 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
}, // EfiMemoryMappedIO
68 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
}, // EfiMemoryMappedIOPortSpace
69 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, TRUE
, TRUE
}, // EfiPalCode
70 { 0, MAX_ADDRESS
, 0, 0, EfiMaxMemoryType
, FALSE
, FALSE
} // EfiMaxMemoryType
73 EFI_PHYSICAL_ADDRESS mDefaultMaximumAddress
= MAX_ADDRESS
;
74 EFI_PHYSICAL_ADDRESS mDefaultBaseAddress
= MAX_ADDRESS
;
76 EFI_MEMORY_TYPE_INFORMATION gMemoryTypeInformation
[EfiMaxMemoryType
+ 1] = {
77 { EfiReservedMemoryType
, 0 },
80 { EfiBootServicesCode
, 0 },
81 { EfiBootServicesData
, 0 },
82 { EfiRuntimeServicesCode
, 0 },
83 { EfiRuntimeServicesData
, 0 },
84 { EfiConventionalMemory
, 0 },
85 { EfiUnusableMemory
, 0 },
86 { EfiACPIReclaimMemory
, 0 },
87 { EfiACPIMemoryNVS
, 0 },
88 { EfiMemoryMappedIO
, 0 },
89 { EfiMemoryMappedIOPortSpace
, 0 },
91 { EfiMaxMemoryType
, 0 }
94 // Only used when load module at fixed address feature is enabled. True means the memory is alreay successfully allocated
95 // and ready to load the module in to specified address.or else, the memory is not ready and module will be loaded at a
96 // address assigned by DXE core.
98 GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN gLoadFixedAddressCodeMemoryReady
= FALSE
;
101 Enter critical section by gaining lock on gMemoryLock.
105 CoreAcquireMemoryLock (
109 CoreAcquireLock (&gMemoryLock
);
115 Exit critical section by releasing lock on gMemoryLock.
119 CoreReleaseMemoryLock (
123 CoreReleaseLock (&gMemoryLock
);
130 Internal function. Removes a descriptor entry.
132 @param Entry The entry to remove
136 RemoveMemoryMapEntry (
137 IN OUT MEMORY_MAP
*Entry
140 RemoveEntryList (&Entry
->Link
);
141 Entry
->Link
.ForwardLink
= NULL
;
143 if (Entry
->FromPages
) {
145 // Insert the free memory map descriptor to the end of mFreeMemoryMapEntryList
147 InsertTailList (&mFreeMemoryMapEntryList
, &Entry
->Link
);
152 Internal function. Adds a ranges to the memory map.
153 The range must not already exist in the map.
155 @param Type The type of memory range to add
156 @param Start The starting address in the memory range Must be
158 @param End The last address in the range Must be the last
160 @param Attribute The attributes of the memory range to add
165 IN EFI_MEMORY_TYPE Type
,
166 IN EFI_PHYSICAL_ADDRESS Start
,
167 IN EFI_PHYSICAL_ADDRESS End
,
174 ASSERT ((Start
& EFI_PAGE_MASK
) == 0);
175 ASSERT (End
> Start
) ;
177 ASSERT_LOCKED (&gMemoryLock
);
179 DEBUG ((DEBUG_PAGE
, "AddRange: %lx-%lx to %d\n", Start
, End
, Type
));
182 // If memory of type EfiConventionalMemory is being added that includes the page
183 // starting at address 0, then zero the page starting at address 0. This has
184 // two benifits. It helps find NULL pointer bugs and it also maximizes
185 // compatibility with operating systems that may evaluate memory in this page
186 // for legacy data structures. If memory of any other type is added starting
187 // at address 0, then do not zero the page at address 0 because the page is being
188 // used for other purposes.
190 if (Type
== EfiConventionalMemory
&& Start
== 0 && (End
>= EFI_PAGE_SIZE
- 1)) {
191 SetMem ((VOID
*)(UINTN
)Start
, EFI_PAGE_SIZE
, 0);
195 // Memory map being altered so updated key
200 // UEFI 2.0 added an event group for notificaiton on memory map changes.
201 // So we need to signal this Event Group every time the memory map changes.
202 // If we are in EFI 1.10 compatability mode no event groups will be
203 // found and nothing will happen we we call this function. These events
204 // will get signaled but since a lock is held around the call to this
205 // function the notificaiton events will only be called after this funciton
206 // returns and the lock is released.
208 CoreNotifySignalList (&gEfiEventMemoryMapChangeGuid
);
211 // Look for adjoining memory descriptor
214 // Two memory descriptors can only be merged if they have the same Type
215 // and the same Attribute
218 Link
= gMemoryMap
.ForwardLink
;
219 while (Link
!= &gMemoryMap
) {
220 Entry
= CR (Link
, MEMORY_MAP
, Link
, MEMORY_MAP_SIGNATURE
);
221 Link
= Link
->ForwardLink
;
223 if (Entry
->Type
!= Type
) {
227 if (Entry
->Attribute
!= Attribute
) {
231 if (Entry
->End
+ 1 == Start
) {
233 Start
= Entry
->Start
;
234 RemoveMemoryMapEntry (Entry
);
236 } else if (Entry
->Start
== End
+ 1) {
239 RemoveMemoryMapEntry (Entry
);
247 mMapStack
[mMapDepth
].Signature
= MEMORY_MAP_SIGNATURE
;
248 mMapStack
[mMapDepth
].FromPages
= FALSE
;
249 mMapStack
[mMapDepth
].Type
= Type
;
250 mMapStack
[mMapDepth
].Start
= Start
;
251 mMapStack
[mMapDepth
].End
= End
;
252 mMapStack
[mMapDepth
].VirtualStart
= 0;
253 mMapStack
[mMapDepth
].Attribute
= Attribute
;
254 InsertTailList (&gMemoryMap
, &mMapStack
[mMapDepth
].Link
);
257 ASSERT (mMapDepth
< MAX_MAP_DEPTH
);
263 Internal function. Deque a descriptor entry from the mFreeMemoryMapEntryList.
264 If the list is emtry, then allocate a new page to refuel the list.
265 Please Note this algorithm to allocate the memory map descriptor has a property
266 that the memory allocated for memory entries always grows, and will never really be freed
267 For example, if the current boot uses 2000 memory map entries at the maximum point, but
268 ends up with only 50 at the time the OS is booted, then the memory associated with the 1950
269 memory map entries is still allocated from EfiBootServicesMemory.
272 @return The Memory map descriptor dequed from the mFreeMemoryMapEntryList
276 AllocateMemoryMapEntry (
280 MEMORY_MAP
* FreeDescriptorEntries
;
284 if (IsListEmpty (&mFreeMemoryMapEntryList
)) {
286 // The list is empty, to allocate one page to refuel the list
288 FreeDescriptorEntries
= CoreAllocatePoolPages (EfiBootServicesData
, EFI_SIZE_TO_PAGES(DEFAULT_PAGE_ALLOCATION
), DEFAULT_PAGE_ALLOCATION
);
289 if(FreeDescriptorEntries
!= NULL
) {
291 // Enque the free memmory map entries into the list
293 for (Index
= 0; Index
< DEFAULT_PAGE_ALLOCATION
/ sizeof(MEMORY_MAP
); Index
++) {
294 FreeDescriptorEntries
[Index
].Signature
= MEMORY_MAP_SIGNATURE
;
295 InsertTailList (&mFreeMemoryMapEntryList
, &FreeDescriptorEntries
[Index
].Link
);
302 // dequeue the first descriptor from the list
304 Entry
= CR (mFreeMemoryMapEntryList
.ForwardLink
, MEMORY_MAP
, Link
, MEMORY_MAP_SIGNATURE
);
305 RemoveEntryList (&Entry
->Link
);
312 Internal function. Moves any memory descriptors that are on the
313 temporary descriptor stack to heap.
317 CoreFreeMemoryMapStack (
325 ASSERT_LOCKED (&gMemoryLock
);
328 // If already freeing the map stack, then return
330 if (mFreeMapStack
!= 0) {
335 // Move the temporary memory descriptor stack into pool
339 while (mMapDepth
!= 0) {
341 // Deque an memory map entry from mFreeMemoryMapEntryList
343 Entry
= AllocateMemoryMapEntry ();
348 // Update to proper entry
352 if (mMapStack
[mMapDepth
].Link
.ForwardLink
!= NULL
) {
355 // Move this entry to general memory
357 RemoveEntryList (&mMapStack
[mMapDepth
].Link
);
358 mMapStack
[mMapDepth
].Link
.ForwardLink
= NULL
;
360 CopyMem (Entry
, &mMapStack
[mMapDepth
], sizeof (MEMORY_MAP
));
361 Entry
->FromPages
= TRUE
;
364 // Find insertion location
366 for (Link2
= gMemoryMap
.ForwardLink
; Link2
!= &gMemoryMap
; Link2
= Link2
->ForwardLink
) {
367 Entry2
= CR (Link2
, MEMORY_MAP
, Link
, MEMORY_MAP_SIGNATURE
);
368 if (Entry2
->FromPages
&& Entry2
->Start
> Entry
->Start
) {
373 InsertTailList (Link2
, &Entry
->Link
);
377 // This item of mMapStack[mMapDepth] has already been dequeued from gMemoryMap list,
378 // so here no need to move it to memory.
380 InsertTailList (&mFreeMemoryMapEntryList
, &Entry
->Link
);
388 Find untested but initialized memory regions in GCD map and convert them to be DXE allocatable.
392 PromoteMemoryResource (
397 EFI_GCD_MAP_ENTRY
*Entry
;
400 DEBUG ((DEBUG_PAGE
, "Promote the memory resource\n"));
402 CoreAcquireGcdMemoryLock ();
405 Link
= mGcdMemorySpaceMap
.ForwardLink
;
406 while (Link
!= &mGcdMemorySpaceMap
) {
408 Entry
= CR (Link
, EFI_GCD_MAP_ENTRY
, Link
, EFI_GCD_MAP_SIGNATURE
);
410 if (Entry
->GcdMemoryType
== EfiGcdMemoryTypeReserved
&&
411 Entry
->EndAddress
< MAX_ADDRESS
&&
412 (Entry
->Capabilities
& (EFI_MEMORY_PRESENT
| EFI_MEMORY_INITIALIZED
| EFI_MEMORY_TESTED
)) ==
413 (EFI_MEMORY_PRESENT
| EFI_MEMORY_INITIALIZED
)) {
415 // Update the GCD map
417 Entry
->GcdMemoryType
= EfiGcdMemoryTypeSystemMemory
;
418 Entry
->Capabilities
|= EFI_MEMORY_TESTED
;
419 Entry
->ImageHandle
= gDxeCoreImageHandle
;
420 Entry
->DeviceHandle
= NULL
;
423 // Add to allocable system memory resource
427 EfiConventionalMemory
,
430 Entry
->Capabilities
& ~(EFI_MEMORY_PRESENT
| EFI_MEMORY_INITIALIZED
| EFI_MEMORY_TESTED
| EFI_MEMORY_RUNTIME
)
432 CoreFreeMemoryMapStack ();
437 Link
= Link
->ForwardLink
;
440 CoreReleaseGcdMemoryLock ();
445 This function try to allocate Runtime code & Boot time code memory range. If LMFA enabled, 2 patchable PCD
446 PcdLoadFixAddressRuntimeCodePageNumber & PcdLoadFixAddressBootTimeCodePageNumber which are set by tools will record the
447 size of boot time and runtime code.
451 CoreLoadingFixedAddressHook (
455 UINT32 RuntimeCodePageNumber
;
456 UINT32 BootTimeCodePageNumber
;
457 EFI_PHYSICAL_ADDRESS RuntimeCodeBase
;
458 EFI_PHYSICAL_ADDRESS BootTimeCodeBase
;
462 // Make sure these 2 areas are not initialzied.
464 if (!gLoadFixedAddressCodeMemoryReady
) {
465 RuntimeCodePageNumber
= PcdGet32(PcdLoadFixAddressRuntimeCodePageNumber
);
466 BootTimeCodePageNumber
= PcdGet32(PcdLoadFixAddressBootTimeCodePageNumber
);
467 RuntimeCodeBase
= (EFI_PHYSICAL_ADDRESS
)(gLoadModuleAtFixAddressConfigurationTable
.DxeCodeTopAddress
- EFI_PAGES_TO_SIZE (RuntimeCodePageNumber
));
468 BootTimeCodeBase
= (EFI_PHYSICAL_ADDRESS
)(RuntimeCodeBase
- EFI_PAGES_TO_SIZE (BootTimeCodePageNumber
));
470 // Try to allocate runtime memory.
472 Status
= CoreAllocatePages (
474 EfiRuntimeServicesCode
,
475 RuntimeCodePageNumber
,
478 if (EFI_ERROR(Status
)) {
480 // Runtime memory allocation failed
485 // Try to allocate boot memory.
487 Status
= CoreAllocatePages (
490 BootTimeCodePageNumber
,
493 if (EFI_ERROR(Status
)) {
495 // boot memory allocation failed. Free Runtime code range and will try the allocation again when
496 // new memory range is installed.
500 RuntimeCodePageNumber
504 gLoadFixedAddressCodeMemoryReady
= TRUE
;
510 Called to initialize the memory map and add descriptors to
511 the current descriptor list.
512 The first descriptor that is added must be general usable
513 memory as the addition allocates heap.
515 @param Type The type of memory to add
516 @param Start The starting address in the memory range Must be
518 @param NumberOfPages The number of pages in the range
519 @param Attribute Attributes of the memory to add
521 @return None. The range is added to the memory map
525 CoreAddMemoryDescriptor (
526 IN EFI_MEMORY_TYPE Type
,
527 IN EFI_PHYSICAL_ADDRESS Start
,
528 IN UINT64 NumberOfPages
,
532 EFI_PHYSICAL_ADDRESS End
;
537 if ((Start
& EFI_PAGE_MASK
) != 0) {
541 if (Type
>= EfiMaxMemoryType
&& Type
<= 0x7fffffff) {
544 CoreAcquireMemoryLock ();
545 End
= Start
+ LShiftU64 (NumberOfPages
, EFI_PAGE_SHIFT
) - 1;
546 CoreAddRange (Type
, Start
, End
, Attribute
);
547 CoreFreeMemoryMapStack ();
548 CoreReleaseMemoryLock ();
551 // If Loading Module At Fixed Address feature is enabled. try to allocate memory with Runtime code & Boot time code type
553 if (PcdGet64(PcdLoadModuleAtFixAddressEnable
) != 0) {
554 CoreLoadingFixedAddressHook();
558 // Check to see if the statistics for the different memory types have already been established
560 if (mMemoryTypeInformationInitialized
) {
566 // Loop through each memory type in the order specified by the gMemoryTypeInformation[] array
568 for (Index
= 0; gMemoryTypeInformation
[Index
].Type
!= EfiMaxMemoryType
; Index
++) {
570 // Make sure the memory type in the gMemoryTypeInformation[] array is valid
572 Type
= (EFI_MEMORY_TYPE
) (gMemoryTypeInformation
[Index
].Type
);
573 if ((UINT32
)Type
> EfiMaxMemoryType
) {
576 if (gMemoryTypeInformation
[Index
].NumberOfPages
!= 0) {
578 // Allocate pages for the current memory type from the top of available memory
580 Status
= CoreAllocatePages (
583 gMemoryTypeInformation
[Index
].NumberOfPages
,
584 &mMemoryTypeStatistics
[Type
].BaseAddress
586 if (EFI_ERROR (Status
)) {
588 // If an error occurs allocating the pages for the current memory type, then
589 // free all the pages allocates for the previous memory types and return. This
590 // operation with be retied when/if more memory is added to the system
592 for (FreeIndex
= 0; FreeIndex
< Index
; FreeIndex
++) {
594 // Make sure the memory type in the gMemoryTypeInformation[] array is valid
596 Type
= (EFI_MEMORY_TYPE
) (gMemoryTypeInformation
[FreeIndex
].Type
);
597 if ((UINT32
)Type
> EfiMaxMemoryType
) {
601 if (gMemoryTypeInformation
[FreeIndex
].NumberOfPages
!= 0) {
603 mMemoryTypeStatistics
[Type
].BaseAddress
,
604 gMemoryTypeInformation
[FreeIndex
].NumberOfPages
606 mMemoryTypeStatistics
[Type
].BaseAddress
= 0;
607 mMemoryTypeStatistics
[Type
].MaximumAddress
= MAX_ADDRESS
;
614 // Compute the address at the top of the current statistics
616 mMemoryTypeStatistics
[Type
].MaximumAddress
=
617 mMemoryTypeStatistics
[Type
].BaseAddress
+
618 LShiftU64 (gMemoryTypeInformation
[Index
].NumberOfPages
, EFI_PAGE_SHIFT
) - 1;
621 // If the current base address is the lowest address so far, then update the default
624 if (mMemoryTypeStatistics
[Type
].BaseAddress
< mDefaultMaximumAddress
) {
625 mDefaultMaximumAddress
= mMemoryTypeStatistics
[Type
].BaseAddress
- 1;
631 // There was enough system memory for all the the memory types were allocated. So,
632 // those memory areas can be freed for future allocations, and all future memory
633 // allocations can occur within their respective bins
635 for (Index
= 0; gMemoryTypeInformation
[Index
].Type
!= EfiMaxMemoryType
; Index
++) {
637 // Make sure the memory type in the gMemoryTypeInformation[] array is valid
639 Type
= (EFI_MEMORY_TYPE
) (gMemoryTypeInformation
[Index
].Type
);
640 if ((UINT32
)Type
> EfiMaxMemoryType
) {
643 if (gMemoryTypeInformation
[Index
].NumberOfPages
!= 0) {
645 mMemoryTypeStatistics
[Type
].BaseAddress
,
646 gMemoryTypeInformation
[Index
].NumberOfPages
648 mMemoryTypeStatistics
[Type
].NumberOfPages
= gMemoryTypeInformation
[Index
].NumberOfPages
;
649 gMemoryTypeInformation
[Index
].NumberOfPages
= 0;
654 // If the number of pages reserved for a memory type is 0, then all allocations for that type
655 // should be in the default range.
657 for (Type
= (EFI_MEMORY_TYPE
) 0; Type
< EfiMaxMemoryType
; Type
++) {
658 for (Index
= 0; gMemoryTypeInformation
[Index
].Type
!= EfiMaxMemoryType
; Index
++) {
659 if (Type
== (EFI_MEMORY_TYPE
)gMemoryTypeInformation
[Index
].Type
) {
660 mMemoryTypeStatistics
[Type
].InformationIndex
= Index
;
663 mMemoryTypeStatistics
[Type
].CurrentNumberOfPages
= 0;
664 if (mMemoryTypeStatistics
[Type
].MaximumAddress
== MAX_ADDRESS
) {
665 mMemoryTypeStatistics
[Type
].MaximumAddress
= mDefaultMaximumAddress
;
669 mMemoryTypeInformationInitialized
= TRUE
;
674 Internal function. Converts a memory range to the specified type.
675 The range must exist in the memory map.
677 @param Start The first address of the range Must be page
679 @param NumberOfPages The number of pages to convert
680 @param NewType The new type for the memory range
682 @retval EFI_INVALID_PARAMETER Invalid parameter
683 @retval EFI_NOT_FOUND Could not find a descriptor cover the specified
684 range or convertion not allowed.
685 @retval EFI_SUCCESS Successfully converts the memory range to the
692 IN UINT64 NumberOfPages
,
693 IN EFI_MEMORY_TYPE NewType
697 UINT64 NumberOfBytes
;
705 NumberOfBytes
= LShiftU64 (NumberOfPages
, EFI_PAGE_SHIFT
);
706 End
= Start
+ NumberOfBytes
- 1;
708 ASSERT (NumberOfPages
);
709 ASSERT ((Start
& EFI_PAGE_MASK
) == 0);
710 ASSERT (End
> Start
) ;
711 ASSERT_LOCKED (&gMemoryLock
);
713 if (NumberOfPages
== 0 || ((Start
& EFI_PAGE_MASK
) != 0) || (Start
> (Start
+ NumberOfBytes
))) {
714 return EFI_INVALID_PARAMETER
;
718 // Convert the entire range
721 while (Start
< End
) {
724 // Find the entry that the covers the range
726 for (Link
= gMemoryMap
.ForwardLink
; Link
!= &gMemoryMap
; Link
= Link
->ForwardLink
) {
727 Entry
= CR (Link
, MEMORY_MAP
, Link
, MEMORY_MAP_SIGNATURE
);
729 if (Entry
->Start
<= Start
&& Entry
->End
> Start
) {
734 if (Link
== &gMemoryMap
) {
735 DEBUG ((DEBUG_ERROR
| DEBUG_PAGE
, "ConvertPages: failed to find range %lx - %lx\n", Start
, End
));
736 return EFI_NOT_FOUND
;
740 // Convert range to the end, or to the end of the descriptor
741 // if that's all we've got
745 ASSERT (Entry
!= NULL
);
746 if (Entry
->End
< End
) {
747 RangeEnd
= Entry
->End
;
750 DEBUG ((DEBUG_PAGE
, "ConvertRange: %lx-%lx to %d\n", Start
, RangeEnd
, NewType
));
753 // Debug code - verify conversion is allowed
755 if (!(NewType
== EfiConventionalMemory
? 1 : 0) ^ (Entry
->Type
== EfiConventionalMemory
? 1 : 0)) {
756 DEBUG ((DEBUG_ERROR
| DEBUG_PAGE
, "ConvertPages: Incompatible memory types\n"));
757 return EFI_NOT_FOUND
;
761 // Update counters for the number of pages allocated to each memory type
763 if ((UINT32
)Entry
->Type
< EfiMaxMemoryType
) {
764 if ((Start
>= mMemoryTypeStatistics
[Entry
->Type
].BaseAddress
&& Start
<= mMemoryTypeStatistics
[Entry
->Type
].MaximumAddress
) ||
765 (Start
>= mDefaultBaseAddress
&& Start
<= mDefaultMaximumAddress
) ) {
766 if (NumberOfPages
> mMemoryTypeStatistics
[Entry
->Type
].CurrentNumberOfPages
) {
767 mMemoryTypeStatistics
[Entry
->Type
].CurrentNumberOfPages
= 0;
769 mMemoryTypeStatistics
[Entry
->Type
].CurrentNumberOfPages
-= NumberOfPages
;
774 if ((UINT32
)NewType
< EfiMaxMemoryType
) {
775 if ((Start
>= mMemoryTypeStatistics
[NewType
].BaseAddress
&& Start
<= mMemoryTypeStatistics
[NewType
].MaximumAddress
) ||
776 (Start
>= mDefaultBaseAddress
&& Start
<= mDefaultMaximumAddress
) ) {
777 mMemoryTypeStatistics
[NewType
].CurrentNumberOfPages
+= NumberOfPages
;
778 if (mMemoryTypeStatistics
[NewType
].CurrentNumberOfPages
> gMemoryTypeInformation
[mMemoryTypeStatistics
[NewType
].InformationIndex
].NumberOfPages
) {
779 gMemoryTypeInformation
[mMemoryTypeStatistics
[NewType
].InformationIndex
].NumberOfPages
= (UINT32
)mMemoryTypeStatistics
[NewType
].CurrentNumberOfPages
;
785 // Pull range out of descriptor
787 if (Entry
->Start
== Start
) {
792 Entry
->Start
= RangeEnd
+ 1;
794 } else if (Entry
->End
== RangeEnd
) {
799 Entry
->End
= Start
- 1;
804 // Pull it out of the center, clip current
810 mMapStack
[mMapDepth
].Signature
= MEMORY_MAP_SIGNATURE
;
811 mMapStack
[mMapDepth
].FromPages
= FALSE
;
812 mMapStack
[mMapDepth
].Type
= Entry
->Type
;
813 mMapStack
[mMapDepth
].Start
= RangeEnd
+1;
814 mMapStack
[mMapDepth
].End
= Entry
->End
;
817 // Inherit Attribute from the Memory Descriptor that is being clipped
819 mMapStack
[mMapDepth
].Attribute
= Entry
->Attribute
;
821 Entry
->End
= Start
- 1;
822 ASSERT (Entry
->Start
< Entry
->End
);
824 Entry
= &mMapStack
[mMapDepth
];
825 InsertTailList (&gMemoryMap
, &Entry
->Link
);
828 ASSERT (mMapDepth
< MAX_MAP_DEPTH
);
832 // The new range inherits the same Attribute as the Entry
833 //it is being cut out of
835 Attribute
= Entry
->Attribute
;
838 // If the descriptor is empty, then remove it from the map
840 if (Entry
->Start
== Entry
->End
+ 1) {
841 RemoveMemoryMapEntry (Entry
);
846 // Add our new range in
848 CoreAddRange (NewType
, Start
, RangeEnd
, Attribute
);
849 if (NewType
== EfiConventionalMemory
) {
851 // Avoid calling DEBUG_CLEAR_MEMORY() for an address of 0 because this
852 // macro will ASSERT() if address is 0. Instead, CoreAddRange() guarantees
853 // that the page starting at address 0 is always filled with zeros.
856 if (RangeEnd
> EFI_PAGE_SIZE
) {
857 DEBUG_CLEAR_MEMORY ((VOID
*)(UINTN
) EFI_PAGE_SIZE
, (UINTN
) (RangeEnd
- EFI_PAGE_SIZE
+ 1));
860 DEBUG_CLEAR_MEMORY ((VOID
*)(UINTN
) Start
, (UINTN
) (RangeEnd
- Start
+ 1));
865 // Move any map descriptor stack to general pool
867 CoreFreeMemoryMapStack ();
870 // Bump the starting address, and convert the next range
872 Start
= RangeEnd
+ 1;
876 // Converted the whole range, done
885 Internal function. Finds a consecutive free page range below
886 the requested address.
888 @param MaxAddress The address that the range must be below
889 @param MinAddress The address that the range must be above
890 @param NumberOfPages Number of pages needed
891 @param NewType The type of memory the range is going to be
893 @param Alignment Bits to align with
895 @return The base address of the range, or 0 if the range was not found
900 IN UINT64 MaxAddress
,
901 IN UINT64 MinAddress
,
902 IN UINT64 NumberOfPages
,
903 IN EFI_MEMORY_TYPE NewType
,
907 UINT64 NumberOfBytes
;
911 UINT64 DescNumberOfBytes
;
915 if ((MaxAddress
< EFI_PAGE_MASK
) ||(NumberOfPages
== 0)) {
919 if ((MaxAddress
& EFI_PAGE_MASK
) != EFI_PAGE_MASK
) {
922 // If MaxAddress is not aligned to the end of a page
926 // Change MaxAddress to be 1 page lower
928 MaxAddress
-= (EFI_PAGE_MASK
+ 1);
931 // Set MaxAddress to a page boundary
933 MaxAddress
&= ~(UINT64
)EFI_PAGE_MASK
;
936 // Set MaxAddress to end of the page
938 MaxAddress
|= EFI_PAGE_MASK
;
941 NumberOfBytes
= LShiftU64 (NumberOfPages
, EFI_PAGE_SHIFT
);
944 for (Link
= gMemoryMap
.ForwardLink
; Link
!= &gMemoryMap
; Link
= Link
->ForwardLink
) {
945 Entry
= CR (Link
, MEMORY_MAP
, Link
, MEMORY_MAP_SIGNATURE
);
948 // If it's not a free entry, don't bother with it
950 if (Entry
->Type
!= EfiConventionalMemory
) {
954 DescStart
= Entry
->Start
;
955 DescEnd
= Entry
->End
;
958 // If desc is past max allowed address or below min allowed address, skip it
960 if ((DescStart
>= MaxAddress
) || (DescEnd
< MinAddress
)) {
965 // If desc ends past max allowed address, clip the end
967 if (DescEnd
>= MaxAddress
) {
968 DescEnd
= MaxAddress
;
971 DescEnd
= ((DescEnd
+ 1) & (~(Alignment
- 1))) - 1;
974 // Compute the number of bytes we can used from this
975 // descriptor, and see it's enough to satisfy the request
977 DescNumberOfBytes
= DescEnd
- DescStart
+ 1;
979 if (DescNumberOfBytes
>= NumberOfBytes
) {
981 // If the start of the allocated range is below the min address allowed, skip it
983 if ((DescEnd
- NumberOfBytes
+ 1) < MinAddress
) {
988 // If this is the best match so far remember it
990 if (DescEnd
> Target
) {
997 // If this is a grow down, adjust target to be the allocation base
999 Target
-= NumberOfBytes
- 1;
1002 // If we didn't find a match, return 0
1004 if ((Target
& EFI_PAGE_MASK
) != 0) {
1013 Internal function. Finds a consecutive free page range below
1014 the requested address
1016 @param MaxAddress The address that the range must be below
1017 @param NoPages Number of pages needed
1018 @param NewType The type of memory the range is going to be
1020 @param Alignment Bits to align with
1022 @return The base address of the range, or 0 if the range was not found.
1027 IN UINT64 MaxAddress
,
1029 IN EFI_MEMORY_TYPE NewType
,
1036 // Attempt to find free pages in the preferred bin based on the requested memory type
1038 if ((UINT32
)NewType
< EfiMaxMemoryType
&& MaxAddress
>= mMemoryTypeStatistics
[NewType
].MaximumAddress
) {
1039 Start
= CoreFindFreePagesI (
1040 mMemoryTypeStatistics
[NewType
].MaximumAddress
,
1041 mMemoryTypeStatistics
[NewType
].BaseAddress
,
1052 // Attempt to find free pages in the default allocation bin
1054 if (MaxAddress
>= mDefaultMaximumAddress
) {
1055 Start
= CoreFindFreePagesI (mDefaultMaximumAddress
, 0, NoPages
, NewType
, Alignment
);
1057 if (Start
< mDefaultBaseAddress
) {
1058 mDefaultBaseAddress
= Start
;
1065 // The allocation did not succeed in any of the prefered bins even after
1066 // promoting resources. Attempt to find free pages anywhere is the requested
1067 // address range. If this allocation fails, then there are not enough
1068 // resources anywhere to satisfy the request.
1070 Start
= CoreFindFreePagesI (MaxAddress
, 0, NoPages
, NewType
, Alignment
);
1076 // If allocations from the preferred bins fail, then attempt to promote memory resources.
1078 if (!PromoteMemoryResource ()) {
1083 // If any memory resources were promoted, then re-attempt the allocation
1085 return FindFreePages (MaxAddress
, NoPages
, NewType
, Alignment
);
1090 Allocates pages from the memory map.
1092 @param Type The type of allocation to perform
1093 @param MemoryType The type of memory to turn the allocated pages
1095 @param NumberOfPages The number of pages to allocate
1096 @param Memory A pointer to receive the base allocated memory
1099 @return Status. On success, Memory is filled in with the base address allocated
1100 @retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in
1102 @retval EFI_NOT_FOUND Could not allocate pages match the requirement.
1103 @retval EFI_OUT_OF_RESOURCES No enough pages to allocate.
1104 @retval EFI_SUCCESS Pages successfully allocated.
1109 CoreInternalAllocatePages (
1110 IN EFI_ALLOCATE_TYPE Type
,
1111 IN EFI_MEMORY_TYPE MemoryType
,
1112 IN UINTN NumberOfPages
,
1113 IN OUT EFI_PHYSICAL_ADDRESS
*Memory
1121 if ((UINT32
)Type
>= MaxAllocateType
) {
1122 return EFI_INVALID_PARAMETER
;
1125 if ((MemoryType
>= EfiMaxMemoryType
&& MemoryType
<= 0x7fffffff) ||
1126 MemoryType
== EfiConventionalMemory
) {
1127 return EFI_INVALID_PARAMETER
;
1130 if (Memory
== NULL
) {
1131 return EFI_INVALID_PARAMETER
;
1134 Alignment
= EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT
;
1136 if (MemoryType
== EfiACPIReclaimMemory
||
1137 MemoryType
== EfiACPIMemoryNVS
||
1138 MemoryType
== EfiRuntimeServicesCode
||
1139 MemoryType
== EfiRuntimeServicesData
) {
1141 Alignment
= EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT
;
1144 if (Type
== AllocateAddress
) {
1145 if ((*Memory
& (Alignment
- 1)) != 0) {
1146 return EFI_NOT_FOUND
;
1150 NumberOfPages
+= EFI_SIZE_TO_PAGES (Alignment
) - 1;
1151 NumberOfPages
&= ~(EFI_SIZE_TO_PAGES (Alignment
) - 1);
1154 // If this is for below a particular address, then
1159 // The max address is the max natively addressable address for the processor
1161 MaxAddress
= MAX_ADDRESS
;
1163 if (Type
== AllocateMaxAddress
) {
1167 CoreAcquireMemoryLock ();
1170 // If not a specific address, then find an address to allocate
1172 if (Type
!= AllocateAddress
) {
1173 Start
= FindFreePages (MaxAddress
, NumberOfPages
, MemoryType
, Alignment
);
1175 Status
= EFI_OUT_OF_RESOURCES
;
1181 // Convert pages from FreeMemory to the requested type
1183 Status
= CoreConvertPages (Start
, NumberOfPages
, MemoryType
);
1186 CoreReleaseMemoryLock ();
1188 if (!EFI_ERROR (Status
)) {
1196 Allocates pages from the memory map.
1198 @param Type The type of allocation to perform
1199 @param MemoryType The type of memory to turn the allocated pages
1201 @param NumberOfPages The number of pages to allocate
1202 @param Memory A pointer to receive the base allocated memory
1205 @return Status. On success, Memory is filled in with the base address allocated
1206 @retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in
1208 @retval EFI_NOT_FOUND Could not allocate pages match the requirement.
1209 @retval EFI_OUT_OF_RESOURCES No enough pages to allocate.
1210 @retval EFI_SUCCESS Pages successfully allocated.
1216 IN EFI_ALLOCATE_TYPE Type
,
1217 IN EFI_MEMORY_TYPE MemoryType
,
1218 IN UINTN NumberOfPages
,
1219 OUT EFI_PHYSICAL_ADDRESS
*Memory
1224 Status
= CoreInternalAllocatePages (Type
, MemoryType
, NumberOfPages
, Memory
);
1225 if (!EFI_ERROR (Status
)) {
1226 CoreUpdateProfile ((EFI_PHYSICAL_ADDRESS
) (UINTN
) RETURN_ADDRESS (0), MemoryProfileActionAllocatePages
, MemoryType
, EFI_PAGES_TO_SIZE (NumberOfPages
), (VOID
*) (UINTN
) *Memory
);
1232 Frees previous allocated pages.
1234 @param Memory Base address of memory being freed
1235 @param NumberOfPages The number of pages to free
1237 @retval EFI_NOT_FOUND Could not find the entry that covers the range
1238 @retval EFI_INVALID_PARAMETER Address not aligned
1239 @return EFI_SUCCESS -Pages successfully freed.
1244 CoreInternalFreePages (
1245 IN EFI_PHYSICAL_ADDRESS Memory
,
1246 IN UINTN NumberOfPages
1257 CoreAcquireMemoryLock ();
1260 // Find the entry that the covers the range
1263 for (Link
= gMemoryMap
.ForwardLink
; Link
!= &gMemoryMap
; Link
= Link
->ForwardLink
) {
1264 Entry
= CR(Link
, MEMORY_MAP
, Link
, MEMORY_MAP_SIGNATURE
);
1265 if (Entry
->Start
<= Memory
&& Entry
->End
> Memory
) {
1269 if (Link
== &gMemoryMap
) {
1270 Status
= EFI_NOT_FOUND
;
1274 Alignment
= EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT
;
1276 ASSERT (Entry
!= NULL
);
1277 if (Entry
->Type
== EfiACPIReclaimMemory
||
1278 Entry
->Type
== EfiACPIMemoryNVS
||
1279 Entry
->Type
== EfiRuntimeServicesCode
||
1280 Entry
->Type
== EfiRuntimeServicesData
) {
1282 Alignment
= EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT
;
1286 if ((Memory
& (Alignment
- 1)) != 0) {
1287 Status
= EFI_INVALID_PARAMETER
;
1291 NumberOfPages
+= EFI_SIZE_TO_PAGES (Alignment
) - 1;
1292 NumberOfPages
&= ~(EFI_SIZE_TO_PAGES (Alignment
) - 1);
1294 Status
= CoreConvertPages (Memory
, NumberOfPages
, EfiConventionalMemory
);
1296 if (EFI_ERROR (Status
)) {
1301 CoreReleaseMemoryLock ();
1306 Frees previous allocated pages.
1308 @param Memory Base address of memory being freed
1309 @param NumberOfPages The number of pages to free
1311 @retval EFI_NOT_FOUND Could not find the entry that covers the range
1312 @retval EFI_INVALID_PARAMETER Address not aligned
1313 @return EFI_SUCCESS -Pages successfully freed.
1319 IN EFI_PHYSICAL_ADDRESS Memory
,
1320 IN UINTN NumberOfPages
1325 Status
= CoreInternalFreePages (Memory
, NumberOfPages
);
1326 if (!EFI_ERROR (Status
)) {
1327 CoreUpdateProfile ((EFI_PHYSICAL_ADDRESS
) (UINTN
) RETURN_ADDRESS (0), MemoryProfileActionFreePages
, 0, EFI_PAGES_TO_SIZE (NumberOfPages
), (VOID
*) (UINTN
) Memory
);
1333 This function checks to see if the last memory map descriptor in a memory map
1334 can be merged with any of the other memory map descriptors in a memorymap.
1335 Memory descriptors may be merged if they are adjacent and have the same type
1338 @param MemoryMap A pointer to the start of the memory map.
1339 @param MemoryMapDescriptor A pointer to the last descriptor in MemoryMap.
1340 @param DescriptorSize The size, in bytes, of an individual
1341 EFI_MEMORY_DESCRIPTOR.
1343 @return A pointer to the next available descriptor in MemoryMap
1346 EFI_MEMORY_DESCRIPTOR
*
1347 MergeMemoryMapDescriptor (
1348 IN EFI_MEMORY_DESCRIPTOR
*MemoryMap
,
1349 IN EFI_MEMORY_DESCRIPTOR
*MemoryMapDescriptor
,
1350 IN UINTN DescriptorSize
1354 // Traverse the array of descriptors in MemoryMap
1356 for (; MemoryMap
!= MemoryMapDescriptor
; MemoryMap
= NEXT_MEMORY_DESCRIPTOR (MemoryMap
, DescriptorSize
)) {
1358 // Check to see if the Type fields are identical.
1360 if (MemoryMap
->Type
!= MemoryMapDescriptor
->Type
) {
1365 // Check to see if the Attribute fields are identical.
1367 if (MemoryMap
->Attribute
!= MemoryMapDescriptor
->Attribute
) {
1372 // Check to see if MemoryMapDescriptor is immediately above MemoryMap
1374 if (MemoryMap
->PhysicalStart
+ EFI_PAGES_TO_SIZE ((UINTN
)MemoryMap
->NumberOfPages
) == MemoryMapDescriptor
->PhysicalStart
) {
1376 // Merge MemoryMapDescriptor into MemoryMap
1378 MemoryMap
->NumberOfPages
+= MemoryMapDescriptor
->NumberOfPages
;
1381 // Return MemoryMapDescriptor as the next available slot int he MemoryMap array
1383 return MemoryMapDescriptor
;
1387 // Check to see if MemoryMapDescriptor is immediately below MemoryMap
1389 if (MemoryMap
->PhysicalStart
- EFI_PAGES_TO_SIZE ((UINTN
)MemoryMapDescriptor
->NumberOfPages
) == MemoryMapDescriptor
->PhysicalStart
) {
1391 // Merge MemoryMapDescriptor into MemoryMap
1393 MemoryMap
->PhysicalStart
= MemoryMapDescriptor
->PhysicalStart
;
1394 MemoryMap
->VirtualStart
= MemoryMapDescriptor
->VirtualStart
;
1395 MemoryMap
->NumberOfPages
+= MemoryMapDescriptor
->NumberOfPages
;
1398 // Return MemoryMapDescriptor as the next available slot int he MemoryMap array
1400 return MemoryMapDescriptor
;
1405 // MemoryMapDescrtiptor could not be merged with any descriptors in MemoryMap.
1407 // Return the slot immediately after MemoryMapDescriptor as the next available
1408 // slot in the MemoryMap array
1410 return NEXT_MEMORY_DESCRIPTOR (MemoryMapDescriptor
, DescriptorSize
);
1414 This function returns a copy of the current memory map. The map is an array of
1415 memory descriptors, each of which describes a contiguous block of memory.
1417 @param MemoryMapSize A pointer to the size, in bytes, of the
1418 MemoryMap buffer. On input, this is the size of
1419 the buffer allocated by the caller. On output,
1420 it is the size of the buffer returned by the
1421 firmware if the buffer was large enough, or the
1422 size of the buffer needed to contain the map if
1423 the buffer was too small.
1424 @param MemoryMap A pointer to the buffer in which firmware places
1425 the current memory map.
1426 @param MapKey A pointer to the location in which firmware
1427 returns the key for the current memory map.
1428 @param DescriptorSize A pointer to the location in which firmware
1429 returns the size, in bytes, of an individual
1430 EFI_MEMORY_DESCRIPTOR.
1431 @param DescriptorVersion A pointer to the location in which firmware
1432 returns the version number associated with the
1433 EFI_MEMORY_DESCRIPTOR.
1435 @retval EFI_SUCCESS The memory map was returned in the MemoryMap
1437 @retval EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small. The current
1438 buffer size needed to hold the memory map is
1439 returned in MemoryMapSize.
1440 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1446 IN OUT UINTN
*MemoryMapSize
,
1447 IN OUT EFI_MEMORY_DESCRIPTOR
*MemoryMap
,
1449 OUT UINTN
*DescriptorSize
,
1450 OUT UINT32
*DescriptorVersion
1456 UINTN NumberOfRuntimeEntries
;
1459 EFI_GCD_MAP_ENTRY
*GcdMapEntry
;
1460 EFI_MEMORY_TYPE Type
;
1461 EFI_MEMORY_DESCRIPTOR
*MemoryMapStart
;
1464 // Make sure the parameters are valid
1466 if (MemoryMapSize
== NULL
) {
1467 return EFI_INVALID_PARAMETER
;
1470 CoreAcquireGcdMemoryLock ();
1473 // Count the number of Reserved and MMIO entries that are marked for runtime use
1475 NumberOfRuntimeEntries
= 0;
1476 for (Link
= mGcdMemorySpaceMap
.ForwardLink
; Link
!= &mGcdMemorySpaceMap
; Link
= Link
->ForwardLink
) {
1477 GcdMapEntry
= CR (Link
, EFI_GCD_MAP_ENTRY
, Link
, EFI_GCD_MAP_SIGNATURE
);
1478 if ((GcdMapEntry
->GcdMemoryType
== EfiGcdMemoryTypeReserved
) ||
1479 (GcdMapEntry
->GcdMemoryType
== EfiGcdMemoryTypeMemoryMappedIo
)) {
1480 if ((GcdMapEntry
->Attributes
& EFI_MEMORY_RUNTIME
) == EFI_MEMORY_RUNTIME
) {
1481 NumberOfRuntimeEntries
++;
1486 Size
= sizeof (EFI_MEMORY_DESCRIPTOR
);
1489 // Make sure Size != sizeof(EFI_MEMORY_DESCRIPTOR). This will
1490 // prevent people from having pointer math bugs in their code.
1491 // now you have to use *DescriptorSize to make things work.
1493 Size
+= sizeof(UINT64
) - (Size
% sizeof (UINT64
));
1495 if (DescriptorSize
!= NULL
) {
1496 *DescriptorSize
= Size
;
1499 if (DescriptorVersion
!= NULL
) {
1500 *DescriptorVersion
= EFI_MEMORY_DESCRIPTOR_VERSION
;
1503 CoreAcquireMemoryLock ();
1506 // Compute the buffer size needed to fit the entire map
1508 BufferSize
= Size
* NumberOfRuntimeEntries
;
1509 for (Link
= gMemoryMap
.ForwardLink
; Link
!= &gMemoryMap
; Link
= Link
->ForwardLink
) {
1513 if (*MemoryMapSize
< BufferSize
) {
1514 Status
= EFI_BUFFER_TOO_SMALL
;
1518 if (MemoryMap
== NULL
) {
1519 Status
= EFI_INVALID_PARAMETER
;
1526 ZeroMem (MemoryMap
, BufferSize
);
1527 MemoryMapStart
= MemoryMap
;
1528 for (Link
= gMemoryMap
.ForwardLink
; Link
!= &gMemoryMap
; Link
= Link
->ForwardLink
) {
1529 Entry
= CR (Link
, MEMORY_MAP
, Link
, MEMORY_MAP_SIGNATURE
);
1530 ASSERT (Entry
->VirtualStart
== 0);
1533 // Convert internal map into an EFI_MEMORY_DESCRIPTOR
1535 MemoryMap
->Type
= Entry
->Type
;
1536 MemoryMap
->PhysicalStart
= Entry
->Start
;
1537 MemoryMap
->VirtualStart
= Entry
->VirtualStart
;
1538 MemoryMap
->NumberOfPages
= RShiftU64 (Entry
->End
- Entry
->Start
+ 1, EFI_PAGE_SHIFT
);
1540 // If the memory type is EfiConventionalMemory, then determine if the range is part of a
1541 // memory type bin and needs to be converted to the same memory type as the rest of the
1542 // memory type bin in order to minimize EFI Memory Map changes across reboots. This
1543 // improves the chances for a successful S4 resume in the presence of minor page allocation
1544 // differences across reboots.
1546 if (MemoryMap
->Type
== EfiConventionalMemory
) {
1547 for (Type
= (EFI_MEMORY_TYPE
) 0; Type
< EfiMaxMemoryType
; Type
++) {
1548 if (mMemoryTypeStatistics
[Type
].Special
&&
1549 mMemoryTypeStatistics
[Type
].NumberOfPages
> 0 &&
1550 Entry
->Start
>= mMemoryTypeStatistics
[Type
].BaseAddress
&&
1551 Entry
->End
<= mMemoryTypeStatistics
[Type
].MaximumAddress
) {
1552 MemoryMap
->Type
= Type
;
1556 MemoryMap
->Attribute
= Entry
->Attribute
;
1557 if (MemoryMap
->Type
< EfiMaxMemoryType
) {
1558 if (mMemoryTypeStatistics
[MemoryMap
->Type
].Runtime
) {
1559 MemoryMap
->Attribute
|= EFI_MEMORY_RUNTIME
;
1564 // Check to see if the new Memory Map Descriptor can be merged with an
1565 // existing descriptor if they are adjacent and have the same attributes
1567 MemoryMap
= MergeMemoryMapDescriptor (MemoryMapStart
, MemoryMap
, Size
);
1570 for (Link
= mGcdMemorySpaceMap
.ForwardLink
; Link
!= &mGcdMemorySpaceMap
; Link
= Link
->ForwardLink
) {
1571 GcdMapEntry
= CR (Link
, EFI_GCD_MAP_ENTRY
, Link
, EFI_GCD_MAP_SIGNATURE
);
1572 if ((GcdMapEntry
->GcdMemoryType
== EfiGcdMemoryTypeReserved
) ||
1573 (GcdMapEntry
->GcdMemoryType
== EfiGcdMemoryTypeMemoryMappedIo
)) {
1574 if ((GcdMapEntry
->Attributes
& EFI_MEMORY_RUNTIME
) == EFI_MEMORY_RUNTIME
) {
1576 // Create EFI_MEMORY_DESCRIPTOR for every Reserved and MMIO GCD entries
1577 // that are marked for runtime use
1579 MemoryMap
->PhysicalStart
= GcdMapEntry
->BaseAddress
;
1580 MemoryMap
->VirtualStart
= 0;
1581 MemoryMap
->NumberOfPages
= RShiftU64 ((GcdMapEntry
->EndAddress
- GcdMapEntry
->BaseAddress
+ 1), EFI_PAGE_SHIFT
);
1582 MemoryMap
->Attribute
= GcdMapEntry
->Attributes
& ~EFI_MEMORY_PORT_IO
;
1584 if (GcdMapEntry
->GcdMemoryType
== EfiGcdMemoryTypeReserved
) {
1585 MemoryMap
->Type
= EfiReservedMemoryType
;
1586 } else if (GcdMapEntry
->GcdMemoryType
== EfiGcdMemoryTypeMemoryMappedIo
) {
1587 if ((GcdMapEntry
->Attributes
& EFI_MEMORY_PORT_IO
) == EFI_MEMORY_PORT_IO
) {
1588 MemoryMap
->Type
= EfiMemoryMappedIOPortSpace
;
1590 MemoryMap
->Type
= EfiMemoryMappedIO
;
1595 // Check to see if the new Memory Map Descriptor can be merged with an
1596 // existing descriptor if they are adjacent and have the same attributes
1598 MemoryMap
= MergeMemoryMapDescriptor (MemoryMapStart
, MemoryMap
, Size
);
1604 // Compute the size of the buffer actually used after all memory map descriptor merge operations
1606 BufferSize
= ((UINT8
*)MemoryMap
- (UINT8
*)MemoryMapStart
);
1608 Status
= EFI_SUCCESS
;
1612 // Update the map key finally
1614 if (MapKey
!= NULL
) {
1615 *MapKey
= mMemoryMapKey
;
1618 CoreReleaseMemoryLock ();
1620 CoreReleaseGcdMemoryLock ();
1622 *MemoryMapSize
= BufferSize
;
1629 Internal function. Used by the pool functions to allocate pages
1630 to back pool allocation requests.
1632 @param PoolType The type of memory for the new pool pages
1633 @param NumberOfPages No of pages to allocate
1634 @param Alignment Bits to align.
1636 @return The allocated memory, or NULL
1640 CoreAllocatePoolPages (
1641 IN EFI_MEMORY_TYPE PoolType
,
1642 IN UINTN NumberOfPages
,
1649 // Find the pages to convert
1651 Start
= FindFreePages (MAX_ADDRESS
, NumberOfPages
, PoolType
, Alignment
);
1654 // Convert it to boot services data
1657 DEBUG ((DEBUG_ERROR
| DEBUG_PAGE
, "AllocatePoolPages: failed to allocate %d pages\n", (UINT32
)NumberOfPages
));
1659 CoreConvertPages (Start
, NumberOfPages
, PoolType
);
1662 return (VOID
*)(UINTN
) Start
;
1667 Internal function. Frees pool pages allocated via AllocatePoolPages ()
1669 @param Memory The base address to free
1670 @param NumberOfPages The number of pages to free
1675 IN EFI_PHYSICAL_ADDRESS Memory
,
1676 IN UINTN NumberOfPages
1679 CoreConvertPages (Memory
, NumberOfPages
, EfiConventionalMemory
);
1685 Make sure the memory map is following all the construction rules,
1686 it is the last time to check memory map error before exit boot services.
1688 @param MapKey Memory map key
1690 @retval EFI_INVALID_PARAMETER Memory map not consistent with construction
1692 @retval EFI_SUCCESS Valid memory map.
1696 CoreTerminateMemoryMap (
1704 Status
= EFI_SUCCESS
;
1706 CoreAcquireMemoryLock ();
1708 if (MapKey
== mMemoryMapKey
) {
1711 // Make sure the memory map is following all the construction rules
1712 // This is the last chance we will be able to display any messages on
1713 // the console devices.
1716 for (Link
= gMemoryMap
.ForwardLink
; Link
!= &gMemoryMap
; Link
= Link
->ForwardLink
) {
1717 Entry
= CR(Link
, MEMORY_MAP
, Link
, MEMORY_MAP_SIGNATURE
);
1718 if ((Entry
->Attribute
& EFI_MEMORY_RUNTIME
) != 0) {
1719 if (Entry
->Type
== EfiACPIReclaimMemory
|| Entry
->Type
== EfiACPIMemoryNVS
) {
1720 DEBUG((DEBUG_ERROR
| DEBUG_PAGE
, "ExitBootServices: ACPI memory entry has RUNTIME attribute set.\n"));
1721 Status
= EFI_INVALID_PARAMETER
;
1724 if ((Entry
->Start
& (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT
- 1)) != 0) {
1725 DEBUG((DEBUG_ERROR
| DEBUG_PAGE
, "ExitBootServices: A RUNTIME memory entry is not on a proper alignment.\n"));
1726 Status
= EFI_INVALID_PARAMETER
;
1729 if (((Entry
->End
+ 1) & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT
- 1)) != 0) {
1730 DEBUG((DEBUG_ERROR
| DEBUG_PAGE
, "ExitBootServices: A RUNTIME memory entry is not on a proper alignment.\n"));
1731 Status
= EFI_INVALID_PARAMETER
;
1738 // The map key they gave us matches what we expect. Fall through and
1739 // return success. In an ideal world we would clear out all of
1740 // EfiBootServicesCode and EfiBootServicesData. However this function
1741 // is not the last one called by ExitBootServices(), so we have to
1742 // preserve the memory contents.
1745 Status
= EFI_INVALID_PARAMETER
;
1749 CoreReleaseMemoryLock ();