MdeModulePkg/Bus: Fix typos in comments
[mirror_edk2.git] / MdeModulePkg / Core / Dxe / Mem / Page.c
CommitLineData
504214c4 1/** @file\r
504214c4
LG
2 UEFI Memory page management functions.\r
3\r
f0459afe 4Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>\r
cd5ebaa0 5This program and the accompanying materials\r
23c98c94 6are licensed and made available under the terms and conditions of the BSD License\r
7which accompanies this distribution. The full text of the license may be found at\r
8http://opensource.org/licenses/bsd-license.php\r
9\r
10THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
28a00297 12\r
504214c4 13**/\r
28a00297 14\r
9c4ac31c 15#include "DxeMain.h"\r
ec90508b 16#include "Imem.h"\r
28a00297 17\r
18#define EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT (EFI_PAGE_SIZE)\r
19\r
20//\r
d45fd260 21// Entry for tracking the memory regions for each memory type to coalesce similar memory types\r
28a00297 22//\r
23typedef struct {\r
24 EFI_PHYSICAL_ADDRESS BaseAddress;\r
25 EFI_PHYSICAL_ADDRESS MaximumAddress;\r
26 UINT64 CurrentNumberOfPages;\r
b74350e9 27 UINT64 NumberOfPages;\r
28a00297 28 UINTN InformationIndex;\r
b74350e9 29 BOOLEAN Special;\r
30 BOOLEAN Runtime;\r
d613c2a8 31} EFI_MEMORY_TYPE_STATISTICS;\r
28a00297 32\r
33//\r
34// MemoryMap - The current memory map\r
35//\r
36UINTN mMemoryMapKey = 0;\r
37\r
28a00297 38#define MAX_MAP_DEPTH 6\r
dc8d93ca 39\r
40///\r
41/// mMapDepth - depth of new descriptor stack\r
42///\r
28a00297 43UINTN mMapDepth = 0;\r
dc8d93ca 44///\r
45/// mMapStack - space to use as temp storage to build new map descriptors\r
46///\r
28a00297 47MEMORY_MAP mMapStack[MAX_MAP_DEPTH];\r
48UINTN mFreeMapStack = 0;\r
dc8d93ca 49///\r
50/// This list maintain the free memory map list\r
51///\r
e94a9ff7 52LIST_ENTRY mFreeMemoryMapEntryList = INITIALIZE_LIST_HEAD_VARIABLE (mFreeMemoryMapEntryList);\r
53BOOLEAN mMemoryTypeInformationInitialized = FALSE;\r
28a00297 54\r
d613c2a8 55EFI_MEMORY_TYPE_STATISTICS mMemoryTypeStatistics[EfiMaxMemoryType + 1] = {\r
f3f2e05d 56 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiReservedMemoryType\r
57 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiLoaderCode\r
58 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiLoaderData\r
59 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiBootServicesCode\r
60 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiBootServicesData\r
61 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiRuntimeServicesCode\r
62 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiRuntimeServicesData\r
63 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiConventionalMemory\r
64 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiUnusableMemory\r
65 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiACPIReclaimMemory\r
66 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiACPIMemoryNVS\r
67 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiMemoryMappedIO\r
68 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiMemoryMappedIOPortSpace\r
69 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiPalCode\r
a671a012 70 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiPersistentMemory\r
f3f2e05d 71 { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE } // EfiMaxMemoryType\r
28a00297 72};\r
73\r
f3f2e05d 74EFI_PHYSICAL_ADDRESS mDefaultMaximumAddress = MAX_ADDRESS;\r
2345e7d4 75EFI_PHYSICAL_ADDRESS mDefaultBaseAddress = MAX_ADDRESS;\r
28a00297 76\r
77EFI_MEMORY_TYPE_INFORMATION gMemoryTypeInformation[EfiMaxMemoryType + 1] = {\r
78 { EfiReservedMemoryType, 0 },\r
79 { EfiLoaderCode, 0 },\r
80 { EfiLoaderData, 0 },\r
81 { EfiBootServicesCode, 0 },\r
82 { EfiBootServicesData, 0 },\r
83 { EfiRuntimeServicesCode, 0 },\r
84 { EfiRuntimeServicesData, 0 },\r
85 { EfiConventionalMemory, 0 },\r
86 { EfiUnusableMemory, 0 },\r
87 { EfiACPIReclaimMemory, 0 },\r
88 { EfiACPIMemoryNVS, 0 },\r
89 { EfiMemoryMappedIO, 0 },\r
90 { EfiMemoryMappedIOPortSpace, 0 },\r
91 { EfiPalCode, 0 },\r
a671a012 92 { EfiPersistentMemory, 0 },\r
28a00297 93 { EfiMaxMemoryType, 0 }\r
94};\r
54ea99a7 95//\r
96// Only used when load module at fixed address feature is enabled. True means the memory is alreay successfully allocated\r
97// and ready to load the module in to specified address.or else, the memory is not ready and module will be loaded at a \r
98// address assigned by DXE core.\r
99//\r
100GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN gLoadFixedAddressCodeMemoryReady = FALSE;\r
d9177625 101\r
162ed594 102/**\r
d9177625 103 Enter critical section by gaining lock on gMemoryLock.\r
162ed594 104\r
105**/\r
23c98c94 106VOID\r
d9177625 107CoreAcquireMemoryLock (\r
108 VOID\r
109 )\r
110{\r
111 CoreAcquireLock (&gMemoryLock);\r
112}\r
113\r
114\r
115\r
116/**\r
117 Exit critical section by releasing lock on gMemoryLock.\r
118\r
119**/\r
120VOID\r
121CoreReleaseMemoryLock (\r
28a00297 122 VOID\r
d9177625 123 )\r
124{\r
125 CoreReleaseLock (&gMemoryLock);\r
126}\r
127\r
128\r
129\r
130\r
131/**\r
132 Internal function. Removes a descriptor entry.\r
133\r
134 @param Entry The entry to remove\r
135\r
136**/\r
137VOID\r
138RemoveMemoryMapEntry (\r
139 IN OUT MEMORY_MAP *Entry\r
140 )\r
141{\r
142 RemoveEntryList (&Entry->Link);\r
143 Entry->Link.ForwardLink = NULL;\r
144\r
145 if (Entry->FromPages) {\r
146 //\r
147 // Insert the free memory map descriptor to the end of mFreeMemoryMapEntryList\r
148 //\r
149 InsertTailList (&mFreeMemoryMapEntryList, &Entry->Link);\r
150 }\r
151}\r
162ed594 152\r
153/**\r
154 Internal function. Adds a ranges to the memory map.\r
155 The range must not already exist in the map.\r
156\r
022c6d45 157 @param Type The type of memory range to add\r
158 @param Start The starting address in the memory range Must be\r
159 paged aligned\r
160 @param End The last address in the range Must be the last\r
161 byte of a page\r
162 @param Attribute The attributes of the memory range to add\r
28a00297 163\r
162ed594 164**/\r
28a00297 165VOID\r
166CoreAddRange (\r
167 IN EFI_MEMORY_TYPE Type,\r
168 IN EFI_PHYSICAL_ADDRESS Start,\r
169 IN EFI_PHYSICAL_ADDRESS End,\r
170 IN UINT64 Attribute\r
d9177625 171 )\r
172{\r
173 LIST_ENTRY *Link;\r
174 MEMORY_MAP *Entry;\r
28a00297 175\r
d9177625 176 ASSERT ((Start & EFI_PAGE_MASK) == 0);\r
177 ASSERT (End > Start) ;\r
162ed594 178\r
d9177625 179 ASSERT_LOCKED (&gMemoryLock);\r
28a00297 180\r
d9177625 181 DEBUG ((DEBUG_PAGE, "AddRange: %lx-%lx to %d\n", Start, End, Type));\r
d436d5ca 182 \r
183 //\r
184 // If memory of type EfiConventionalMemory is being added that includes the page \r
185 // starting at address 0, then zero the page starting at address 0. This has \r
186 // two benifits. It helps find NULL pointer bugs and it also maximizes \r
187 // compatibility with operating systems that may evaluate memory in this page \r
188 // for legacy data structures. If memory of any other type is added starting \r
189 // at address 0, then do not zero the page at address 0 because the page is being \r
190 // used for other purposes.\r
191 // \r
192 if (Type == EfiConventionalMemory && Start == 0 && (End >= EFI_PAGE_SIZE - 1)) {\r
193 SetMem ((VOID *)(UINTN)Start, EFI_PAGE_SIZE, 0);\r
194 }\r
195 \r
d9177625 196 //\r
197 // Memory map being altered so updated key\r
198 //\r
199 mMemoryMapKey += 1;\r
162ed594 200\r
d9177625 201 //\r
202 // UEFI 2.0 added an event group for notificaiton on memory map changes.\r
203 // So we need to signal this Event Group every time the memory map changes.\r
204 // If we are in EFI 1.10 compatability mode no event groups will be\r
205 // found and nothing will happen we we call this function. These events\r
206 // will get signaled but since a lock is held around the call to this\r
207 // function the notificaiton events will only be called after this funciton\r
208 // returns and the lock is released.\r
209 //\r
210 CoreNotifySignalList (&gEfiEventMemoryMapChangeGuid);\r
162ed594 211\r
d9177625 212 //\r
213 // Look for adjoining memory descriptor\r
214 //\r
28a00297 215\r
d9177625 216 // Two memory descriptors can only be merged if they have the same Type\r
217 // and the same Attribute\r
218 //\r
162ed594 219\r
d9177625 220 Link = gMemoryMap.ForwardLink;\r
221 while (Link != &gMemoryMap) {\r
222 Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
223 Link = Link->ForwardLink;\r
162ed594 224\r
d9177625 225 if (Entry->Type != Type) {\r
226 continue;\r
227 }\r
228\r
229 if (Entry->Attribute != Attribute) {\r
230 continue;\r
231 }\r
232\r
233 if (Entry->End + 1 == Start) {\r
234\r
235 Start = Entry->Start;\r
236 RemoveMemoryMapEntry (Entry);\r
237\r
238 } else if (Entry->Start == End + 1) {\r
239\r
240 End = Entry->End;\r
241 RemoveMemoryMapEntry (Entry);\r
242 }\r
243 }\r
244\r
245 //\r
246 // Add descriptor\r
247 //\r
248\r
249 mMapStack[mMapDepth].Signature = MEMORY_MAP_SIGNATURE;\r
250 mMapStack[mMapDepth].FromPages = FALSE;\r
251 mMapStack[mMapDepth].Type = Type;\r
252 mMapStack[mMapDepth].Start = Start;\r
253 mMapStack[mMapDepth].End = End;\r
254 mMapStack[mMapDepth].VirtualStart = 0;\r
255 mMapStack[mMapDepth].Attribute = Attribute;\r
256 InsertTailList (&gMemoryMap, &mMapStack[mMapDepth].Link);\r
257\r
258 mMapDepth += 1;\r
259 ASSERT (mMapDepth < MAX_MAP_DEPTH);\r
260\r
261 return ;\r
262}\r
022c6d45 263\r
162ed594 264/**\r
265 Internal function. Deque a descriptor entry from the mFreeMemoryMapEntryList.\r
266 If the list is emtry, then allocate a new page to refuel the list.\r
267 Please Note this algorithm to allocate the memory map descriptor has a property\r
268 that the memory allocated for memory entries always grows, and will never really be freed\r
269 For example, if the current boot uses 2000 memory map entries at the maximum point, but\r
270 ends up with only 50 at the time the OS is booted, then the memory associated with the 1950\r
271 memory map entries is still allocated from EfiBootServicesMemory.\r
272\r
273\r
274 @return The Memory map descriptor dequed from the mFreeMemoryMapEntryList\r
275\r
276**/\r
28a00297 277MEMORY_MAP *\r
278AllocateMemoryMapEntry (\r
279 VOID\r
d9177625 280 )\r
281{\r
282 MEMORY_MAP* FreeDescriptorEntries;\r
283 MEMORY_MAP* Entry;\r
284 UINTN Index;\r
285\r
286 if (IsListEmpty (&mFreeMemoryMapEntryList)) {\r
287 //\r
288 // The list is empty, to allocate one page to refuel the list\r
289 //\r
290 FreeDescriptorEntries = CoreAllocatePoolPages (EfiBootServicesData, EFI_SIZE_TO_PAGES(DEFAULT_PAGE_ALLOCATION), DEFAULT_PAGE_ALLOCATION);\r
291 if(FreeDescriptorEntries != NULL) {\r
292 //\r
293 // Enque the free memmory map entries into the list\r
294 //\r
295 for (Index = 0; Index< DEFAULT_PAGE_ALLOCATION / sizeof(MEMORY_MAP); Index++) {\r
296 FreeDescriptorEntries[Index].Signature = MEMORY_MAP_SIGNATURE;\r
297 InsertTailList (&mFreeMemoryMapEntryList, &FreeDescriptorEntries[Index].Link);\r
298 }\r
299 } else {\r
300 return NULL;\r
301 }\r
302 }\r
303 //\r
304 // dequeue the first descriptor from the list\r
305 //\r
306 Entry = CR (mFreeMemoryMapEntryList.ForwardLink, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
307 RemoveEntryList (&Entry->Link);\r
308\r
309 return Entry;\r
310}\r
022c6d45 311\r
162ed594 312\r
313/**\r
d9177625 314 Internal function. Moves any memory descriptors that are on the\r
315 temporary descriptor stack to heap.\r
162ed594 316\r
317**/\r
28a00297 318VOID\r
d9177625 319CoreFreeMemoryMapStack (\r
28a00297 320 VOID\r
321 )\r
28a00297 322{\r
d9177625 323 MEMORY_MAP *Entry;\r
324 MEMORY_MAP *Entry2;\r
325 LIST_ENTRY *Link2;\r
28a00297 326\r
d9177625 327 ASSERT_LOCKED (&gMemoryLock);\r
28a00297 328\r
d9177625 329 //\r
330 // If already freeing the map stack, then return\r
331 //\r
332 if (mFreeMapStack != 0) {\r
333 return ;\r
334 }\r
162ed594 335\r
d9177625 336 //\r
337 // Move the temporary memory descriptor stack into pool\r
338 //\r
339 mFreeMapStack += 1;\r
162ed594 340\r
d9177625 341 while (mMapDepth != 0) {\r
342 //\r
343 // Deque an memory map entry from mFreeMemoryMapEntryList\r
344 //\r
345 Entry = AllocateMemoryMapEntry ();\r
346\r
347 ASSERT (Entry);\r
348\r
349 //\r
350 // Update to proper entry\r
351 //\r
352 mMapDepth -= 1;\r
353\r
354 if (mMapStack[mMapDepth].Link.ForwardLink != NULL) {\r
355\r
356 //\r
357 // Move this entry to general memory\r
358 //\r
359 RemoveEntryList (&mMapStack[mMapDepth].Link);\r
360 mMapStack[mMapDepth].Link.ForwardLink = NULL;\r
361\r
362 CopyMem (Entry , &mMapStack[mMapDepth], sizeof (MEMORY_MAP));\r
363 Entry->FromPages = TRUE;\r
364\r
365 //\r
366 // Find insertion location\r
367 //\r
368 for (Link2 = gMemoryMap.ForwardLink; Link2 != &gMemoryMap; Link2 = Link2->ForwardLink) {\r
369 Entry2 = CR (Link2, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
370 if (Entry2->FromPages && Entry2->Start > Entry->Start) {\r
371 break;\r
372 }\r
373 }\r
374\r
375 InsertTailList (Link2, &Entry->Link);\r
376\r
377 } else {\r
378 //\r
379 // This item of mMapStack[mMapDepth] has already been dequeued from gMemoryMap list,\r
380 // so here no need to move it to memory.\r
381 //\r
382 InsertTailList (&mFreeMemoryMapEntryList, &Entry->Link);\r
383 }\r
384 }\r
28a00297 385\r
d9177625 386 mFreeMapStack -= 1;\r
387}\r
162ed594 388\r
389/**\r
390 Find untested but initialized memory regions in GCD map and convert them to be DXE allocatable.\r
391\r
392**/\r
2345e7d4 393BOOLEAN\r
28a00297 394PromoteMemoryResource (\r
395 VOID\r
396 )\r
28a00297 397{\r
2345e7d4 398 LIST_ENTRY *Link;\r
399 EFI_GCD_MAP_ENTRY *Entry;\r
400 BOOLEAN Promoted;\r
28a00297 401\r
d45fd260 402 DEBUG ((DEBUG_PAGE, "Promote the memory resource\n"));\r
022c6d45 403\r
28a00297 404 CoreAcquireGcdMemoryLock ();\r
022c6d45 405\r
2345e7d4 406 Promoted = FALSE;\r
28a00297 407 Link = mGcdMemorySpaceMap.ForwardLink;\r
408 while (Link != &mGcdMemorySpaceMap) {\r
409\r
410 Entry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
411\r
412 if (Entry->GcdMemoryType == EfiGcdMemoryTypeReserved &&\r
f3f2e05d 413 Entry->EndAddress < MAX_ADDRESS &&\r
28a00297 414 (Entry->Capabilities & (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED)) ==\r
415 (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED)) {\r
416 //\r
417 // Update the GCD map\r
418 //\r
74705ca5
SZ
419 if ((Entry->Capabilities & EFI_MEMORY_MORE_RELIABLE) == EFI_MEMORY_MORE_RELIABLE) {\r
420 Entry->GcdMemoryType = EfiGcdMemoryTypeMoreReliable;\r
421 } else {\r
422 Entry->GcdMemoryType = EfiGcdMemoryTypeSystemMemory;\r
423 }\r
28a00297 424 Entry->Capabilities |= EFI_MEMORY_TESTED;\r
425 Entry->ImageHandle = gDxeCoreImageHandle;\r
426 Entry->DeviceHandle = NULL;\r
427\r
428 //\r
429 // Add to allocable system memory resource\r
022c6d45 430 //\r
28a00297 431\r
432 CoreAddRange (\r
022c6d45 433 EfiConventionalMemory,\r
434 Entry->BaseAddress,\r
435 Entry->EndAddress,\r
28a00297 436 Entry->Capabilities & ~(EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED | EFI_MEMORY_RUNTIME)\r
437 );\r
438 CoreFreeMemoryMapStack ();\r
022c6d45 439\r
2345e7d4 440 Promoted = TRUE;\r
28a00297 441 }\r
442\r
443 Link = Link->ForwardLink;\r
444 }\r
022c6d45 445\r
28a00297 446 CoreReleaseGcdMemoryLock ();\r
022c6d45 447\r
2345e7d4 448 return Promoted;\r
28a00297 449}\r
54ea99a7 450/**\r
451 This function try to allocate Runtime code & Boot time code memory range. If LMFA enabled, 2 patchable PCD \r
452 PcdLoadFixAddressRuntimeCodePageNumber & PcdLoadFixAddressBootTimeCodePageNumber which are set by tools will record the \r
453 size of boot time and runtime code.\r
28a00297 454\r
54ea99a7 455**/\r
456VOID\r
457CoreLoadingFixedAddressHook (\r
458 VOID\r
459 )\r
460{\r
461 UINT32 RuntimeCodePageNumber;\r
462 UINT32 BootTimeCodePageNumber;\r
463 EFI_PHYSICAL_ADDRESS RuntimeCodeBase;\r
464 EFI_PHYSICAL_ADDRESS BootTimeCodeBase;\r
465 EFI_STATUS Status;\r
466\r
467 //\r
468 // Make sure these 2 areas are not initialzied.\r
469 //\r
470 if (!gLoadFixedAddressCodeMemoryReady) { \r
471 RuntimeCodePageNumber = PcdGet32(PcdLoadFixAddressRuntimeCodePageNumber);\r
472 BootTimeCodePageNumber= PcdGet32(PcdLoadFixAddressBootTimeCodePageNumber);\r
473 RuntimeCodeBase = (EFI_PHYSICAL_ADDRESS)(gLoadModuleAtFixAddressConfigurationTable.DxeCodeTopAddress - EFI_PAGES_TO_SIZE (RuntimeCodePageNumber));\r
474 BootTimeCodeBase = (EFI_PHYSICAL_ADDRESS)(RuntimeCodeBase - EFI_PAGES_TO_SIZE (BootTimeCodePageNumber));\r
475 //\r
476 // Try to allocate runtime memory.\r
477 //\r
478 Status = CoreAllocatePages (\r
479 AllocateAddress,\r
480 EfiRuntimeServicesCode,\r
481 RuntimeCodePageNumber,\r
482 &RuntimeCodeBase\r
483 );\r
484 if (EFI_ERROR(Status)) {\r
485 //\r
486 // Runtime memory allocation failed \r
487 //\r
488 return;\r
489 }\r
490 //\r
491 // Try to allocate boot memory.\r
492 //\r
493 Status = CoreAllocatePages (\r
494 AllocateAddress,\r
495 EfiBootServicesCode,\r
496 BootTimeCodePageNumber,\r
497 &BootTimeCodeBase\r
498 );\r
499 if (EFI_ERROR(Status)) {\r
500 //\r
501 // boot memory allocation failed. Free Runtime code range and will try the allocation again when \r
502 // new memory range is installed.\r
503 //\r
504 CoreFreePages (\r
505 RuntimeCodeBase,\r
506 RuntimeCodePageNumber\r
507 );\r
508 return;\r
509 }\r
510 gLoadFixedAddressCodeMemoryReady = TRUE;\r
511 } \r
512 return;\r
513} \r
28a00297 514\r
162ed594 515/**\r
28a00297 516 Called to initialize the memory map and add descriptors to\r
517 the current descriptor list.\r
28a00297 518 The first descriptor that is added must be general usable\r
519 memory as the addition allocates heap.\r
520\r
022c6d45 521 @param Type The type of memory to add\r
522 @param Start The starting address in the memory range Must be\r
523 page aligned\r
524 @param NumberOfPages The number of pages in the range\r
525 @param Attribute Attributes of the memory to add\r
28a00297 526\r
162ed594 527 @return None. The range is added to the memory map\r
28a00297 528\r
162ed594 529**/\r
530VOID\r
531CoreAddMemoryDescriptor (\r
532 IN EFI_MEMORY_TYPE Type,\r
533 IN EFI_PHYSICAL_ADDRESS Start,\r
534 IN UINT64 NumberOfPages,\r
535 IN UINT64 Attribute\r
536 )\r
28a00297 537{\r
538 EFI_PHYSICAL_ADDRESS End;\r
539 EFI_STATUS Status;\r
540 UINTN Index;\r
541 UINTN FreeIndex;\r
54ea99a7 542 \r
28a00297 543 if ((Start & EFI_PAGE_MASK) != 0) {\r
544 return;\r
545 }\r
546\r
8ee25f48 547 if (Type >= EfiMaxMemoryType && Type < MEMORY_TYPE_OEM_RESERVED_MIN) {\r
28a00297 548 return;\r
549 }\r
28a00297 550 CoreAcquireMemoryLock ();\r
551 End = Start + LShiftU64 (NumberOfPages, EFI_PAGE_SHIFT) - 1;\r
552 CoreAddRange (Type, Start, End, Attribute);\r
553 CoreFreeMemoryMapStack ();\r
554 CoreReleaseMemoryLock ();\r
555\r
54ea99a7 556 //\r
557 // If Loading Module At Fixed Address feature is enabled. try to allocate memory with Runtime code & Boot time code type\r
558 //\r
852081fc 559 if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0) {\r
54ea99a7 560 CoreLoadingFixedAddressHook();\r
561 }\r
562 \r
28a00297 563 //\r
564 // Check to see if the statistics for the different memory types have already been established\r
565 //\r
566 if (mMemoryTypeInformationInitialized) {\r
567 return;\r
568 }\r
569\r
54ea99a7 570 \r
28a00297 571 //\r
572 // Loop through each memory type in the order specified by the gMemoryTypeInformation[] array\r
573 //\r
574 for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
575 //\r
576 // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
577 //\r
578 Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[Index].Type);\r
3d78c020 579 if ((UINT32)Type > EfiMaxMemoryType) {\r
28a00297 580 continue;\r
581 }\r
28a00297 582 if (gMemoryTypeInformation[Index].NumberOfPages != 0) {\r
583 //\r
584 // Allocate pages for the current memory type from the top of available memory\r
585 //\r
586 Status = CoreAllocatePages (\r
587 AllocateAnyPages,\r
588 Type,\r
589 gMemoryTypeInformation[Index].NumberOfPages,\r
590 &mMemoryTypeStatistics[Type].BaseAddress\r
591 );\r
592 if (EFI_ERROR (Status)) {\r
593 //\r
022c6d45 594 // If an error occurs allocating the pages for the current memory type, then\r
28a00297 595 // free all the pages allocates for the previous memory types and return. This\r
596 // operation with be retied when/if more memory is added to the system\r
597 //\r
598 for (FreeIndex = 0; FreeIndex < Index; FreeIndex++) {\r
599 //\r
600 // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
601 //\r
602 Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[FreeIndex].Type);\r
3d78c020 603 if ((UINT32)Type > EfiMaxMemoryType) {\r
28a00297 604 continue;\r
605 }\r
606\r
607 if (gMemoryTypeInformation[FreeIndex].NumberOfPages != 0) {\r
608 CoreFreePages (\r
022c6d45 609 mMemoryTypeStatistics[Type].BaseAddress,\r
28a00297 610 gMemoryTypeInformation[FreeIndex].NumberOfPages\r
611 );\r
612 mMemoryTypeStatistics[Type].BaseAddress = 0;\r
f3f2e05d 613 mMemoryTypeStatistics[Type].MaximumAddress = MAX_ADDRESS;\r
28a00297 614 }\r
615 }\r
616 return;\r
617 }\r
618\r
619 //\r
620 // Compute the address at the top of the current statistics\r
621 //\r
022c6d45 622 mMemoryTypeStatistics[Type].MaximumAddress =\r
623 mMemoryTypeStatistics[Type].BaseAddress +\r
28a00297 624 LShiftU64 (gMemoryTypeInformation[Index].NumberOfPages, EFI_PAGE_SHIFT) - 1;\r
625\r
626 //\r
022c6d45 627 // If the current base address is the lowest address so far, then update the default\r
28a00297 628 // maximum address\r
629 //\r
630 if (mMemoryTypeStatistics[Type].BaseAddress < mDefaultMaximumAddress) {\r
631 mDefaultMaximumAddress = mMemoryTypeStatistics[Type].BaseAddress - 1;\r
632 }\r
633 }\r
634 }\r
635\r
636 //\r
637 // There was enough system memory for all the the memory types were allocated. So,\r
638 // those memory areas can be freed for future allocations, and all future memory\r
639 // allocations can occur within their respective bins\r
640 //\r
641 for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
642 //\r
643 // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
644 //\r
645 Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[Index].Type);\r
3d78c020 646 if ((UINT32)Type > EfiMaxMemoryType) {\r
28a00297 647 continue;\r
648 }\r
28a00297 649 if (gMemoryTypeInformation[Index].NumberOfPages != 0) {\r
650 CoreFreePages (\r
022c6d45 651 mMemoryTypeStatistics[Type].BaseAddress,\r
28a00297 652 gMemoryTypeInformation[Index].NumberOfPages\r
653 );\r
b74350e9 654 mMemoryTypeStatistics[Type].NumberOfPages = gMemoryTypeInformation[Index].NumberOfPages;\r
28a00297 655 gMemoryTypeInformation[Index].NumberOfPages = 0;\r
656 }\r
657 }\r
658\r
659 //\r
660 // If the number of pages reserved for a memory type is 0, then all allocations for that type\r
661 // should be in the default range.\r
662 //\r
663 for (Type = (EFI_MEMORY_TYPE) 0; Type < EfiMaxMemoryType; Type++) {\r
664 for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
665 if (Type == (EFI_MEMORY_TYPE)gMemoryTypeInformation[Index].Type) {\r
666 mMemoryTypeStatistics[Type].InformationIndex = Index;\r
667 }\r
668 }\r
669 mMemoryTypeStatistics[Type].CurrentNumberOfPages = 0;\r
f3f2e05d 670 if (mMemoryTypeStatistics[Type].MaximumAddress == MAX_ADDRESS) {\r
28a00297 671 mMemoryTypeStatistics[Type].MaximumAddress = mDefaultMaximumAddress;\r
672 }\r
673 }\r
674\r
675 mMemoryTypeInformationInitialized = TRUE;\r
676}\r
677\r
678\r
162ed594 679/**\r
771ee501
EC
680 Internal function. Converts a memory range to the specified type or attributes.\r
681 The range must exist in the memory map. Either ChangingType or\r
682 ChangingAttributes must be set, but not both.\r
162ed594 683\r
022c6d45 684 @param Start The first address of the range Must be page\r
685 aligned\r
686 @param NumberOfPages The number of pages to convert\r
771ee501 687 @param ChangingType Boolean indicating that type value should be changed\r
022c6d45 688 @param NewType The new type for the memory range\r
771ee501
EC
689 @param ChangingAttributes Boolean indicating that attributes value should be changed\r
690 @param NewAttributes The new attributes for the memory range\r
162ed594 691\r
022c6d45 692 @retval EFI_INVALID_PARAMETER Invalid parameter\r
693 @retval EFI_NOT_FOUND Could not find a descriptor cover the specified\r
694 range or convertion not allowed.\r
695 @retval EFI_SUCCESS Successfully converts the memory range to the\r
162ed594 696 specified type.\r
697\r
698**/\r
28a00297 699EFI_STATUS\r
771ee501 700CoreConvertPagesEx (\r
28a00297 701 IN UINT64 Start,\r
702 IN UINT64 NumberOfPages,\r
771ee501
EC
703 IN BOOLEAN ChangingType,\r
704 IN EFI_MEMORY_TYPE NewType,\r
705 IN BOOLEAN ChangingAttributes,\r
706 IN UINT64 NewAttributes\r
28a00297 707 )\r
28a00297 708{\r
709\r
710 UINT64 NumberOfBytes;\r
711 UINT64 End;\r
712 UINT64 RangeEnd;\r
713 UINT64 Attribute;\r
771ee501 714 EFI_MEMORY_TYPE MemType;\r
28a00297 715 LIST_ENTRY *Link;\r
716 MEMORY_MAP *Entry;\r
717\r
718 Entry = NULL;\r
719 NumberOfBytes = LShiftU64 (NumberOfPages, EFI_PAGE_SHIFT);\r
720 End = Start + NumberOfBytes - 1;\r
721\r
722 ASSERT (NumberOfPages);\r
723 ASSERT ((Start & EFI_PAGE_MASK) == 0);\r
724 ASSERT (End > Start) ;\r
725 ASSERT_LOCKED (&gMemoryLock);\r
771ee501 726 ASSERT ( (ChangingType == FALSE) || (ChangingAttributes == FALSE) );\r
28a00297 727\r
f0459afe 728 if (NumberOfPages == 0 || ((Start & EFI_PAGE_MASK) != 0) || (Start >= End)) {\r
28a00297 729 return EFI_INVALID_PARAMETER;\r
730 }\r
731\r
732 //\r
733 // Convert the entire range\r
734 //\r
735\r
736 while (Start < End) {\r
737\r
738 //\r
739 // Find the entry that the covers the range\r
740 //\r
741 for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
742 Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
743\r
744 if (Entry->Start <= Start && Entry->End > Start) {\r
745 break;\r
746 }\r
747 }\r
748\r
749 if (Link == &gMemoryMap) {\r
162ed594 750 DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "ConvertPages: failed to find range %lx - %lx\n", Start, End));\r
28a00297 751 return EFI_NOT_FOUND;\r
752 }\r
753\r
754 //\r
755 // Convert range to the end, or to the end of the descriptor\r
756 // if that's all we've got\r
757 //\r
758 RangeEnd = End;\r
525aded9 759\r
760 ASSERT (Entry != NULL);\r
28a00297 761 if (Entry->End < End) {\r
762 RangeEnd = Entry->End;\r
763 }\r
764\r
771ee501
EC
765 if (ChangingType) {\r
766 DEBUG ((DEBUG_PAGE, "ConvertRange: %lx-%lx to type %d\n", Start, RangeEnd, NewType));\r
767 }\r
768 if (ChangingAttributes) {\r
769 DEBUG ((DEBUG_PAGE, "ConvertRange: %lx-%lx to attr %lx\n", Start, RangeEnd, NewAttributes));\r
022c6d45 770 }\r
28a00297 771\r
771ee501
EC
772 if (ChangingType) {\r
773 //\r
774 // Debug code - verify conversion is allowed\r
775 //\r
776 if (!(NewType == EfiConventionalMemory ? 1 : 0) ^ (Entry->Type == EfiConventionalMemory ? 1 : 0)) {\r
777 DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "ConvertPages: Incompatible memory types\n"));\r
778 return EFI_NOT_FOUND;\r
779 }\r
780\r
781 //\r
782 // Update counters for the number of pages allocated to each memory type\r
783 //\r
784 if ((UINT32)Entry->Type < EfiMaxMemoryType) {\r
785 if ((Start >= mMemoryTypeStatistics[Entry->Type].BaseAddress && Start <= mMemoryTypeStatistics[Entry->Type].MaximumAddress) ||\r
786 (Start >= mDefaultBaseAddress && Start <= mDefaultMaximumAddress) ) {\r
787 if (NumberOfPages > mMemoryTypeStatistics[Entry->Type].CurrentNumberOfPages) {\r
788 mMemoryTypeStatistics[Entry->Type].CurrentNumberOfPages = 0;\r
789 } else {\r
790 mMemoryTypeStatistics[Entry->Type].CurrentNumberOfPages -= NumberOfPages;\r
791 }\r
28a00297 792 }\r
793 }\r
28a00297 794\r
771ee501
EC
795 if ((UINT32)NewType < EfiMaxMemoryType) {\r
796 if ((Start >= mMemoryTypeStatistics[NewType].BaseAddress && Start <= mMemoryTypeStatistics[NewType].MaximumAddress) ||\r
797 (Start >= mDefaultBaseAddress && Start <= mDefaultMaximumAddress) ) {\r
798 mMemoryTypeStatistics[NewType].CurrentNumberOfPages += NumberOfPages;\r
799 if (mMemoryTypeStatistics[NewType].CurrentNumberOfPages > gMemoryTypeInformation[mMemoryTypeStatistics[NewType].InformationIndex].NumberOfPages) {\r
800 gMemoryTypeInformation[mMemoryTypeStatistics[NewType].InformationIndex].NumberOfPages = (UINT32)mMemoryTypeStatistics[NewType].CurrentNumberOfPages;\r
801 }\r
28a00297 802 }\r
803 }\r
804 }\r
805\r
806 //\r
807 // Pull range out of descriptor\r
808 //\r
809 if (Entry->Start == Start) {\r
022c6d45 810\r
28a00297 811 //\r
812 // Clip start\r
813 //\r
814 Entry->Start = RangeEnd + 1;\r
815\r
816 } else if (Entry->End == RangeEnd) {\r
022c6d45 817\r
28a00297 818 //\r
819 // Clip end\r
820 //\r
821 Entry->End = Start - 1;\r
822\r
823 } else {\r
824\r
825 //\r
826 // Pull it out of the center, clip current\r
827 //\r
022c6d45 828\r
28a00297 829 //\r
830 // Add a new one\r
831 //\r
832 mMapStack[mMapDepth].Signature = MEMORY_MAP_SIGNATURE;\r
833 mMapStack[mMapDepth].FromPages = FALSE;\r
834 mMapStack[mMapDepth].Type = Entry->Type;\r
835 mMapStack[mMapDepth].Start = RangeEnd+1;\r
836 mMapStack[mMapDepth].End = Entry->End;\r
837\r
838 //\r
839 // Inherit Attribute from the Memory Descriptor that is being clipped\r
840 //\r
841 mMapStack[mMapDepth].Attribute = Entry->Attribute;\r
842\r
843 Entry->End = Start - 1;\r
844 ASSERT (Entry->Start < Entry->End);\r
845\r
846 Entry = &mMapStack[mMapDepth];\r
847 InsertTailList (&gMemoryMap, &Entry->Link);\r
848\r
849 mMapDepth += 1;\r
850 ASSERT (mMapDepth < MAX_MAP_DEPTH);\r
851 }\r
852\r
853 //\r
022c6d45 854 // The new range inherits the same Attribute as the Entry\r
771ee501 855 // it is being cut out of unless attributes are being changed\r
28a00297 856 //\r
771ee501
EC
857 if (ChangingType) {\r
858 Attribute = Entry->Attribute;\r
859 MemType = NewType;\r
860 } else {\r
861 Attribute = NewAttributes;\r
862 MemType = Entry->Type;\r
863 }\r
28a00297 864\r
865 //\r
866 // If the descriptor is empty, then remove it from the map\r
867 //\r
868 if (Entry->Start == Entry->End + 1) {\r
869 RemoveMemoryMapEntry (Entry);\r
870 Entry = NULL;\r
871 }\r
022c6d45 872\r
28a00297 873 //\r
874 // Add our new range in\r
875 //\r
771ee501
EC
876 CoreAddRange (MemType, Start, RangeEnd, Attribute);\r
877 if (ChangingType && (MemType == EfiConventionalMemory)) {\r
9a340872 878 //\r
879 // Avoid calling DEBUG_CLEAR_MEMORY() for an address of 0 because this\r
880 // macro will ASSERT() if address is 0. Instead, CoreAddRange() guarantees\r
881 // that the page starting at address 0 is always filled with zeros.\r
882 //\r
883 if (Start == 0) {\r
884 if (RangeEnd > EFI_PAGE_SIZE) {\r
885 DEBUG_CLEAR_MEMORY ((VOID *)(UINTN) EFI_PAGE_SIZE, (UINTN) (RangeEnd - EFI_PAGE_SIZE + 1));\r
886 }\r
887 } else {\r
888 DEBUG_CLEAR_MEMORY ((VOID *)(UINTN) Start, (UINTN) (RangeEnd - Start + 1));\r
889 }\r
38c7df98 890 }\r
28a00297 891\r
892 //\r
893 // Move any map descriptor stack to general pool\r
894 //\r
895 CoreFreeMemoryMapStack ();\r
896\r
897 //\r
898 // Bump the starting address, and convert the next range\r
899 //\r
900 Start = RangeEnd + 1;\r
901 }\r
902\r
903 //\r
904 // Converted the whole range, done\r
905 //\r
906\r
907 return EFI_SUCCESS;\r
908}\r
909\r
910\r
771ee501
EC
911/**\r
912 Internal function. Converts a memory range to the specified type.\r
913 The range must exist in the memory map.\r
914\r
915 @param Start The first address of the range Must be page\r
916 aligned\r
917 @param NumberOfPages The number of pages to convert\r
918 @param NewType The new type for the memory range\r
919\r
920 @retval EFI_INVALID_PARAMETER Invalid parameter\r
921 @retval EFI_NOT_FOUND Could not find a descriptor cover the specified\r
922 range or convertion not allowed.\r
923 @retval EFI_SUCCESS Successfully converts the memory range to the\r
924 specified type.\r
925\r
926**/\r
927EFI_STATUS\r
928CoreConvertPages (\r
929 IN UINT64 Start,\r
930 IN UINT64 NumberOfPages,\r
931 IN EFI_MEMORY_TYPE NewType\r
932 )\r
933{\r
934 return CoreConvertPagesEx(Start, NumberOfPages, TRUE, NewType, FALSE, 0);\r
935}\r
936\r
937\r
938/**\r
939 Internal function. Converts a memory range to use new attributes.\r
940\r
941 @param Start The first address of the range Must be page\r
942 aligned\r
943 @param NumberOfPages The number of pages to convert\r
944 @param NewAttributes The new attributes value for the range.\r
945\r
771ee501
EC
946**/\r
947VOID\r
948CoreUpdateMemoryAttributes (\r
949 IN EFI_PHYSICAL_ADDRESS Start,\r
950 IN UINT64 NumberOfPages,\r
951 IN UINT64 NewAttributes\r
952 )\r
953{\r
954 CoreAcquireMemoryLock ();\r
955\r
956 //\r
957 // Update the attributes to the new value\r
958 //\r
959 CoreConvertPagesEx(Start, NumberOfPages, FALSE, (EFI_MEMORY_TYPE)0, TRUE, NewAttributes);\r
960\r
961 CoreReleaseMemoryLock ();\r
962}\r
963\r
162ed594 964\r
965/**\r
966 Internal function. Finds a consecutive free page range below\r
967 the requested address.\r
968\r
022c6d45 969 @param MaxAddress The address that the range must be below\r
35f9e94e 970 @param MinAddress The address that the range must be above\r
022c6d45 971 @param NumberOfPages Number of pages needed\r
972 @param NewType The type of memory the range is going to be\r
973 turned into\r
974 @param Alignment Bits to align with\r
162ed594 975\r
976 @return The base address of the range, or 0 if the range was not found\r
977\r
978**/\r
28a00297 979UINT64\r
980CoreFindFreePagesI (\r
981 IN UINT64 MaxAddress,\r
2345e7d4 982 IN UINT64 MinAddress,\r
28a00297 983 IN UINT64 NumberOfPages,\r
984 IN EFI_MEMORY_TYPE NewType,\r
985 IN UINTN Alignment\r
986 )\r
28a00297 987{\r
988 UINT64 NumberOfBytes;\r
989 UINT64 Target;\r
990 UINT64 DescStart;\r
991 UINT64 DescEnd;\r
992 UINT64 DescNumberOfBytes;\r
993 LIST_ENTRY *Link;\r
994 MEMORY_MAP *Entry;\r
995\r
996 if ((MaxAddress < EFI_PAGE_MASK) ||(NumberOfPages == 0)) {\r
997 return 0;\r
998 }\r
999\r
1000 if ((MaxAddress & EFI_PAGE_MASK) != EFI_PAGE_MASK) {\r
022c6d45 1001\r
28a00297 1002 //\r
1003 // If MaxAddress is not aligned to the end of a page\r
1004 //\r
022c6d45 1005\r
28a00297 1006 //\r
1007 // Change MaxAddress to be 1 page lower\r
1008 //\r
1009 MaxAddress -= (EFI_PAGE_MASK + 1);\r
022c6d45 1010\r
28a00297 1011 //\r
1012 // Set MaxAddress to a page boundary\r
1013 //\r
6e1e5405 1014 MaxAddress &= ~(UINT64)EFI_PAGE_MASK;\r
022c6d45 1015\r
28a00297 1016 //\r
1017 // Set MaxAddress to end of the page\r
1018 //\r
1019 MaxAddress |= EFI_PAGE_MASK;\r
1020 }\r
1021\r
1022 NumberOfBytes = LShiftU64 (NumberOfPages, EFI_PAGE_SHIFT);\r
1023 Target = 0;\r
1024\r
1025 for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
1026 Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
022c6d45 1027\r
28a00297 1028 //\r
1029 // If it's not a free entry, don't bother with it\r
1030 //\r
1031 if (Entry->Type != EfiConventionalMemory) {\r
1032 continue;\r
1033 }\r
1034\r
1035 DescStart = Entry->Start;\r
1036 DescEnd = Entry->End;\r
1037\r
1038 //\r
2345e7d4 1039 // If desc is past max allowed address or below min allowed address, skip it\r
28a00297 1040 //\r
2345e7d4 1041 if ((DescStart >= MaxAddress) || (DescEnd < MinAddress)) {\r
28a00297 1042 continue;\r
1043 }\r
1044\r
1045 //\r
1046 // If desc ends past max allowed address, clip the end\r
1047 //\r
1048 if (DescEnd >= MaxAddress) {\r
1049 DescEnd = MaxAddress;\r
1050 }\r
1051\r
1052 DescEnd = ((DescEnd + 1) & (~(Alignment - 1))) - 1;\r
1053\r
1365bedd
HG
1054 // Skip if DescEnd is less than DescStart after alignment clipping\r
1055 if (DescEnd < DescStart) {\r
1056 continue;\r
1057 }\r
1058\r
28a00297 1059 //\r
022c6d45 1060 // Compute the number of bytes we can used from this\r
28a00297 1061 // descriptor, and see it's enough to satisfy the request\r
1062 //\r
1063 DescNumberOfBytes = DescEnd - DescStart + 1;\r
1064\r
1065 if (DescNumberOfBytes >= NumberOfBytes) {\r
2345e7d4 1066 //\r
1067 // If the start of the allocated range is below the min address allowed, skip it\r
1068 //\r
1069 if ((DescEnd - NumberOfBytes + 1) < MinAddress) {\r
1070 continue;\r
1071 }\r
28a00297 1072\r
1073 //\r
1074 // If this is the best match so far remember it\r
1075 //\r
1076 if (DescEnd > Target) {\r
1077 Target = DescEnd;\r
1078 }\r
1079 }\r
022c6d45 1080 }\r
28a00297 1081\r
1082 //\r
1083 // If this is a grow down, adjust target to be the allocation base\r
1084 //\r
1085 Target -= NumberOfBytes - 1;\r
1086\r
1087 //\r
1088 // If we didn't find a match, return 0\r
1089 //\r
1090 if ((Target & EFI_PAGE_MASK) != 0) {\r
1091 return 0;\r
1092 }\r
1093\r
1094 return Target;\r
1095}\r
1096\r
162ed594 1097\r
1098/**\r
1099 Internal function. Finds a consecutive free page range below\r
1100 the requested address\r
1101\r
022c6d45 1102 @param MaxAddress The address that the range must be below\r
1103 @param NoPages Number of pages needed\r
1104 @param NewType The type of memory the range is going to be\r
1105 turned into\r
1106 @param Alignment Bits to align with\r
162ed594 1107\r
1108 @return The base address of the range, or 0 if the range was not found.\r
1109\r
1110**/\r
28a00297 1111UINT64\r
1112FindFreePages (\r
1113 IN UINT64 MaxAddress,\r
1114 IN UINT64 NoPages,\r
1115 IN EFI_MEMORY_TYPE NewType,\r
1116 IN UINTN Alignment\r
1117 )\r
28a00297 1118{\r
2345e7d4 1119 UINT64 Start;\r
28a00297 1120\r
2345e7d4 1121 //\r
1122 // Attempt to find free pages in the preferred bin based on the requested memory type\r
1123 //\r
3d78c020 1124 if ((UINT32)NewType < EfiMaxMemoryType && MaxAddress >= mMemoryTypeStatistics[NewType].MaximumAddress) {\r
2345e7d4 1125 Start = CoreFindFreePagesI (\r
1126 mMemoryTypeStatistics[NewType].MaximumAddress, \r
1127 mMemoryTypeStatistics[NewType].BaseAddress, \r
1128 NoPages, \r
1129 NewType, \r
1130 Alignment\r
1131 );\r
1132 if (Start != 0) {\r
1133 return Start;\r
1134 }\r
1135 }\r
28a00297 1136\r
2345e7d4 1137 //\r
1138 // Attempt to find free pages in the default allocation bin\r
1139 //\r
1140 if (MaxAddress >= mDefaultMaximumAddress) {\r
1141 Start = CoreFindFreePagesI (mDefaultMaximumAddress, 0, NoPages, NewType, Alignment);\r
1142 if (Start != 0) {\r
1143 if (Start < mDefaultBaseAddress) {\r
1144 mDefaultBaseAddress = Start;\r
1145 }\r
1146 return Start;\r
28a00297 1147 }\r
1148 }\r
1149\r
2345e7d4 1150 //\r
1151 // The allocation did not succeed in any of the prefered bins even after \r
1152 // promoting resources. Attempt to find free pages anywhere is the requested \r
1153 // address range. If this allocation fails, then there are not enough \r
1154 // resources anywhere to satisfy the request.\r
1155 //\r
1156 Start = CoreFindFreePagesI (MaxAddress, 0, NoPages, NewType, Alignment);\r
1157 if (Start != 0) {\r
1158 return Start;\r
1159 }\r
28a00297 1160\r
2345e7d4 1161 //\r
1162 // If allocations from the preferred bins fail, then attempt to promote memory resources.\r
1163 //\r
1164 if (!PromoteMemoryResource ()) {\r
1165 return 0;\r
28a00297 1166 }\r
1167\r
2345e7d4 1168 //\r
1169 // If any memory resources were promoted, then re-attempt the allocation\r
1170 //\r
1171 return FindFreePages (MaxAddress, NoPages, NewType, Alignment);\r
28a00297 1172}\r
1173\r
1174\r
162ed594 1175/**\r
1176 Allocates pages from the memory map.\r
1177\r
022c6d45 1178 @param Type The type of allocation to perform\r
1179 @param MemoryType The type of memory to turn the allocated pages\r
1180 into\r
1181 @param NumberOfPages The number of pages to allocate\r
1182 @param Memory A pointer to receive the base allocated memory\r
1183 address\r
162ed594 1184\r
1185 @return Status. On success, Memory is filled in with the base address allocated\r
022c6d45 1186 @retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in\r
1187 spec.\r
1188 @retval EFI_NOT_FOUND Could not allocate pages match the requirement.\r
1189 @retval EFI_OUT_OF_RESOURCES No enough pages to allocate.\r
162ed594 1190 @retval EFI_SUCCESS Pages successfully allocated.\r
1191\r
1192**/\r
28a00297 1193EFI_STATUS\r
1194EFIAPI\r
84edd20b 1195CoreInternalAllocatePages (\r
28a00297 1196 IN EFI_ALLOCATE_TYPE Type,\r
1197 IN EFI_MEMORY_TYPE MemoryType,\r
1198 IN UINTN NumberOfPages,\r
1199 IN OUT EFI_PHYSICAL_ADDRESS *Memory\r
1200 )\r
28a00297 1201{\r
1202 EFI_STATUS Status;\r
1203 UINT64 Start;\r
c2a07a10
SZ
1204 UINT64 NumberOfBytes;\r
1205 UINT64 End;\r
28a00297 1206 UINT64 MaxAddress;\r
1207 UINTN Alignment;\r
1208\r
3d78c020 1209 if ((UINT32)Type >= MaxAllocateType) {\r
28a00297 1210 return EFI_INVALID_PARAMETER;\r
1211 }\r
1212\r
8ee25f48 1213 if ((MemoryType >= EfiMaxMemoryType && MemoryType < MEMORY_TYPE_OEM_RESERVED_MIN) ||\r
a671a012 1214 (MemoryType == EfiConventionalMemory) || (MemoryType == EfiPersistentMemory)) {\r
28a00297 1215 return EFI_INVALID_PARAMETER;\r
1216 }\r
1217\r
3e058701
ED
1218 if (Memory == NULL) {\r
1219 return EFI_INVALID_PARAMETER;\r
1220 }\r
1221\r
28a00297 1222 Alignment = EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT;\r
1223\r
1224 if (MemoryType == EfiACPIReclaimMemory ||\r
1225 MemoryType == EfiACPIMemoryNVS ||\r
1226 MemoryType == EfiRuntimeServicesCode ||\r
1227 MemoryType == EfiRuntimeServicesData) {\r
1228\r
1229 Alignment = EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT;\r
1230 }\r
1231\r
1232 if (Type == AllocateAddress) {\r
1233 if ((*Memory & (Alignment - 1)) != 0) {\r
1234 return EFI_NOT_FOUND;\r
1235 }\r
1236 }\r
1237\r
1238 NumberOfPages += EFI_SIZE_TO_PAGES (Alignment) - 1;\r
1239 NumberOfPages &= ~(EFI_SIZE_TO_PAGES (Alignment) - 1);\r
1240\r
1241 //\r
022c6d45 1242 // If this is for below a particular address, then\r
28a00297 1243 //\r
1244 Start = *Memory;\r
022c6d45 1245\r
28a00297 1246 //\r
1247 // The max address is the max natively addressable address for the processor\r
1248 //\r
f3f2e05d 1249 MaxAddress = MAX_ADDRESS;\r
022c6d45 1250\r
c2a07a10
SZ
1251 //\r
1252 // Check for Type AllocateAddress,\r
1253 // if NumberOfPages is 0 or\r
1254 // if (NumberOfPages << EFI_PAGE_SHIFT) is above MAX_ADDRESS or\r
1255 // if (Start + NumberOfBytes) rolls over 0 or\r
1256 // if Start is above MAX_ADDRESS or\r
1257 // if End is above MAX_ADDRESS,\r
1258 // return EFI_NOT_FOUND.\r
1259 //\r
1260 if (Type == AllocateAddress) {\r
1261 if ((NumberOfPages == 0) ||\r
1262 (NumberOfPages > RShiftU64 (MaxAddress, EFI_PAGE_SHIFT))) {\r
1263 return EFI_NOT_FOUND;\r
1264 }\r
1265 NumberOfBytes = LShiftU64 (NumberOfPages, EFI_PAGE_SHIFT);\r
1266 End = Start + NumberOfBytes - 1;\r
1267\r
1268 if ((Start >= End) ||\r
1269 (Start > MaxAddress) || \r
1270 (End > MaxAddress)) {\r
1271 return EFI_NOT_FOUND;\r
1272 }\r
1273 }\r
1274\r
28a00297 1275 if (Type == AllocateMaxAddress) {\r
1276 MaxAddress = Start;\r
1277 }\r
1278\r
1279 CoreAcquireMemoryLock ();\r
022c6d45 1280\r
28a00297 1281 //\r
1282 // If not a specific address, then find an address to allocate\r
1283 //\r
1284 if (Type != AllocateAddress) {\r
1285 Start = FindFreePages (MaxAddress, NumberOfPages, MemoryType, Alignment);\r
1286 if (Start == 0) {\r
1287 Status = EFI_OUT_OF_RESOURCES;\r
1288 goto Done;\r
1289 }\r
1290 }\r
1291\r
1292 //\r
1293 // Convert pages from FreeMemory to the requested type\r
1294 //\r
1295 Status = CoreConvertPages (Start, NumberOfPages, MemoryType);\r
1296\r
1297Done:\r
1298 CoreReleaseMemoryLock ();\r
1299\r
1300 if (!EFI_ERROR (Status)) {\r
1301 *Memory = Start;\r
1302 }\r
1303\r
1304 return Status;\r
1305}\r
1306\r
84edd20b
SZ
1307/**\r
1308 Allocates pages from the memory map.\r
1309\r
1310 @param Type The type of allocation to perform\r
1311 @param MemoryType The type of memory to turn the allocated pages\r
1312 into\r
1313 @param NumberOfPages The number of pages to allocate\r
1314 @param Memory A pointer to receive the base allocated memory\r
1315 address\r
1316\r
1317 @return Status. On success, Memory is filled in with the base address allocated\r
1318 @retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in\r
1319 spec.\r
1320 @retval EFI_NOT_FOUND Could not allocate pages match the requirement.\r
1321 @retval EFI_OUT_OF_RESOURCES No enough pages to allocate.\r
1322 @retval EFI_SUCCESS Pages successfully allocated.\r
1323\r
1324**/\r
1325EFI_STATUS\r
1326EFIAPI\r
1327CoreAllocatePages (\r
1328 IN EFI_ALLOCATE_TYPE Type,\r
1329 IN EFI_MEMORY_TYPE MemoryType,\r
1330 IN UINTN NumberOfPages,\r
1331 OUT EFI_PHYSICAL_ADDRESS *Memory\r
1332 )\r
1333{\r
1334 EFI_STATUS Status;\r
1335\r
1336 Status = CoreInternalAllocatePages (Type, MemoryType, NumberOfPages, Memory);\r
1337 if (!EFI_ERROR (Status)) {\r
1d60fe96
SZ
1338 CoreUpdateProfile (\r
1339 (EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),\r
1340 MemoryProfileActionAllocatePages,\r
1341 MemoryType,\r
1342 EFI_PAGES_TO_SIZE (NumberOfPages),\r
1343 (VOID *) (UINTN) *Memory,\r
1344 NULL\r
1345 );\r
74a88770 1346 InstallMemoryAttributesTableOnMemoryAllocation (MemoryType);\r
84edd20b
SZ
1347 }\r
1348 return Status;\r
1349}\r
28a00297 1350\r
162ed594 1351/**\r
1352 Frees previous allocated pages.\r
1353\r
022c6d45 1354 @param Memory Base address of memory being freed\r
1355 @param NumberOfPages The number of pages to free\r
925f0d1a 1356 @param MemoryType Pointer to memory type\r
162ed594 1357\r
022c6d45 1358 @retval EFI_NOT_FOUND Could not find the entry that covers the range\r
1359 @retval EFI_INVALID_PARAMETER Address not aligned\r
162ed594 1360 @return EFI_SUCCESS -Pages successfully freed.\r
1361\r
1362**/\r
022c6d45 1363EFI_STATUS\r
28a00297 1364EFIAPI\r
84edd20b 1365CoreInternalFreePages (\r
28a00297 1366 IN EFI_PHYSICAL_ADDRESS Memory,\r
925f0d1a
SZ
1367 IN UINTN NumberOfPages,\r
1368 OUT EFI_MEMORY_TYPE *MemoryType OPTIONAL\r
28a00297 1369 )\r
28a00297 1370{\r
1371 EFI_STATUS Status;\r
1372 LIST_ENTRY *Link;\r
1373 MEMORY_MAP *Entry;\r
1374 UINTN Alignment;\r
1375\r
1376 //\r
1377 // Free the range\r
1378 //\r
1379 CoreAcquireMemoryLock ();\r
1380\r
1381 //\r
1382 // Find the entry that the covers the range\r
1383 //\r
1384 Entry = NULL;\r
1385 for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
1386 Entry = CR(Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
1387 if (Entry->Start <= Memory && Entry->End > Memory) {\r
1388 break;\r
1389 }\r
1390 }\r
1391 if (Link == &gMemoryMap) {\r
a5ca8fa7 1392 Status = EFI_NOT_FOUND;\r
1393 goto Done;\r
28a00297 1394 }\r
1395\r
1396 Alignment = EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT;\r
1397\r
525aded9 1398 ASSERT (Entry != NULL);\r
28a00297 1399 if (Entry->Type == EfiACPIReclaimMemory ||\r
1400 Entry->Type == EfiACPIMemoryNVS ||\r
1401 Entry->Type == EfiRuntimeServicesCode ||\r
1402 Entry->Type == EfiRuntimeServicesData) {\r
1403\r
1404 Alignment = EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT;\r
1405\r
1406 }\r
1407\r
1408 if ((Memory & (Alignment - 1)) != 0) {\r
a5ca8fa7 1409 Status = EFI_INVALID_PARAMETER;\r
1410 goto Done;\r
28a00297 1411 }\r
1412\r
1413 NumberOfPages += EFI_SIZE_TO_PAGES (Alignment) - 1;\r
1414 NumberOfPages &= ~(EFI_SIZE_TO_PAGES (Alignment) - 1);\r
1415\r
925f0d1a
SZ
1416 if (MemoryType != NULL) {\r
1417 *MemoryType = Entry->Type;\r
1418 }\r
1419\r
28a00297 1420 Status = CoreConvertPages (Memory, NumberOfPages, EfiConventionalMemory);\r
1421\r
28a00297 1422 if (EFI_ERROR (Status)) {\r
a5ca8fa7 1423 goto Done;\r
28a00297 1424 }\r
1425\r
a5ca8fa7 1426Done:\r
1427 CoreReleaseMemoryLock ();\r
28a00297 1428 return Status;\r
1429}\r
1430\r
84edd20b
SZ
1431/**\r
1432 Frees previous allocated pages.\r
1433\r
1434 @param Memory Base address of memory being freed\r
1435 @param NumberOfPages The number of pages to free\r
1436\r
1437 @retval EFI_NOT_FOUND Could not find the entry that covers the range\r
1438 @retval EFI_INVALID_PARAMETER Address not aligned\r
1439 @return EFI_SUCCESS -Pages successfully freed.\r
1440\r
1441**/\r
1442EFI_STATUS\r
1443EFIAPI\r
1444CoreFreePages (\r
1445 IN EFI_PHYSICAL_ADDRESS Memory,\r
1446 IN UINTN NumberOfPages\r
1447 )\r
1448{\r
925f0d1a
SZ
1449 EFI_STATUS Status;\r
1450 EFI_MEMORY_TYPE MemoryType;\r
736a692e 1451\r
925f0d1a 1452 Status = CoreInternalFreePages (Memory, NumberOfPages, &MemoryType);\r
736a692e 1453 if (!EFI_ERROR (Status)) {\r
1d60fe96
SZ
1454 CoreUpdateProfile (\r
1455 (EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),\r
1456 MemoryProfileActionFreePages,\r
1457 MemoryType,\r
1458 EFI_PAGES_TO_SIZE (NumberOfPages),\r
1459 (VOID *) (UINTN) Memory,\r
1460 NULL\r
1461 );\r
74a88770 1462 InstallMemoryAttributesTableOnMemoryAllocation (MemoryType);\r
736a692e
HT
1463 }\r
1464 return Status;\r
1465}\r
84edd20b 1466\r
2345e7d4 1467/**\r
1468 This function checks to see if the last memory map descriptor in a memory map\r
1469 can be merged with any of the other memory map descriptors in a memorymap.\r
1470 Memory descriptors may be merged if they are adjacent and have the same type\r
1471 and attributes.\r
1472\r
1473 @param MemoryMap A pointer to the start of the memory map.\r
1474 @param MemoryMapDescriptor A pointer to the last descriptor in MemoryMap.\r
1475 @param DescriptorSize The size, in bytes, of an individual\r
1476 EFI_MEMORY_DESCRIPTOR.\r
1477\r
1478 @return A pointer to the next available descriptor in MemoryMap\r
1479\r
1480**/\r
1481EFI_MEMORY_DESCRIPTOR *\r
1482MergeMemoryMapDescriptor (\r
1483 IN EFI_MEMORY_DESCRIPTOR *MemoryMap,\r
1484 IN EFI_MEMORY_DESCRIPTOR *MemoryMapDescriptor,\r
1485 IN UINTN DescriptorSize\r
1486 )\r
1487{\r
1488 //\r
1489 // Traverse the array of descriptors in MemoryMap\r
1490 //\r
1491 for (; MemoryMap != MemoryMapDescriptor; MemoryMap = NEXT_MEMORY_DESCRIPTOR (MemoryMap, DescriptorSize)) {\r
1492 //\r
1493 // Check to see if the Type fields are identical.\r
1494 //\r
1495 if (MemoryMap->Type != MemoryMapDescriptor->Type) {\r
1496 continue;\r
1497 }\r
1498\r
1499 //\r
1500 // Check to see if the Attribute fields are identical.\r
1501 //\r
1502 if (MemoryMap->Attribute != MemoryMapDescriptor->Attribute) {\r
1503 continue;\r
1504 }\r
1505\r
1506 //\r
1507 // Check to see if MemoryMapDescriptor is immediately above MemoryMap\r
1508 //\r
1509 if (MemoryMap->PhysicalStart + EFI_PAGES_TO_SIZE ((UINTN)MemoryMap->NumberOfPages) == MemoryMapDescriptor->PhysicalStart) { \r
1510 //\r
1511 // Merge MemoryMapDescriptor into MemoryMap\r
1512 //\r
1513 MemoryMap->NumberOfPages += MemoryMapDescriptor->NumberOfPages;\r
1514\r
1515 //\r
1516 // Return MemoryMapDescriptor as the next available slot int he MemoryMap array\r
1517 //\r
1518 return MemoryMapDescriptor;\r
1519 }\r
1520\r
1521 //\r
1522 // Check to see if MemoryMapDescriptor is immediately below MemoryMap\r
1523 //\r
1524 if (MemoryMap->PhysicalStart - EFI_PAGES_TO_SIZE ((UINTN)MemoryMapDescriptor->NumberOfPages) == MemoryMapDescriptor->PhysicalStart) {\r
1525 //\r
1526 // Merge MemoryMapDescriptor into MemoryMap\r
1527 //\r
1528 MemoryMap->PhysicalStart = MemoryMapDescriptor->PhysicalStart;\r
1529 MemoryMap->VirtualStart = MemoryMapDescriptor->VirtualStart;\r
1530 MemoryMap->NumberOfPages += MemoryMapDescriptor->NumberOfPages;\r
1531\r
1532 //\r
1533 // Return MemoryMapDescriptor as the next available slot int he MemoryMap array\r
1534 //\r
1535 return MemoryMapDescriptor;\r
1536 }\r
1537 }\r
1538\r
1539 //\r
1540 // MemoryMapDescrtiptor could not be merged with any descriptors in MemoryMap.\r
1541 //\r
1542 // Return the slot immediately after MemoryMapDescriptor as the next available \r
1543 // slot in the MemoryMap array\r
1544 //\r
1545 return NEXT_MEMORY_DESCRIPTOR (MemoryMapDescriptor, DescriptorSize);\r
1546}\r
28a00297 1547\r
162ed594 1548/**\r
1549 This function returns a copy of the current memory map. The map is an array of\r
1550 memory descriptors, each of which describes a contiguous block of memory.\r
1551\r
022c6d45 1552 @param MemoryMapSize A pointer to the size, in bytes, of the\r
1553 MemoryMap buffer. On input, this is the size of\r
1554 the buffer allocated by the caller. On output,\r
1555 it is the size of the buffer returned by the\r
1556 firmware if the buffer was large enough, or the\r
1557 size of the buffer needed to contain the map if\r
1558 the buffer was too small.\r
1559 @param MemoryMap A pointer to the buffer in which firmware places\r
1560 the current memory map.\r
1561 @param MapKey A pointer to the location in which firmware\r
1562 returns the key for the current memory map.\r
1563 @param DescriptorSize A pointer to the location in which firmware\r
1564 returns the size, in bytes, of an individual\r
1565 EFI_MEMORY_DESCRIPTOR.\r
1566 @param DescriptorVersion A pointer to the location in which firmware\r
1567 returns the version number associated with the\r
1568 EFI_MEMORY_DESCRIPTOR.\r
1569\r
1570 @retval EFI_SUCCESS The memory map was returned in the MemoryMap\r
1571 buffer.\r
1572 @retval EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small. The current\r
1573 buffer size needed to hold the memory map is\r
1574 returned in MemoryMapSize.\r
162ed594 1575 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.\r
1576\r
1577**/\r
28a00297 1578EFI_STATUS\r
1579EFIAPI\r
1580CoreGetMemoryMap (\r
1581 IN OUT UINTN *MemoryMapSize,\r
1582 IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap,\r
1583 OUT UINTN *MapKey,\r
1584 OUT UINTN *DescriptorSize,\r
1585 OUT UINT32 *DescriptorVersion\r
1586 )\r
28a00297 1587{\r
1588 EFI_STATUS Status;\r
022c6d45 1589 UINTN Size;\r
1590 UINTN BufferSize;\r
ba2c0527 1591 UINTN NumberOfEntries;\r
28a00297 1592 LIST_ENTRY *Link;\r
022c6d45 1593 MEMORY_MAP *Entry;\r
1594 EFI_GCD_MAP_ENTRY *GcdMapEntry;\r
46a65f18 1595 EFI_GCD_MAP_ENTRY MergeGcdMapEntry;\r
b74350e9 1596 EFI_MEMORY_TYPE Type;\r
2345e7d4 1597 EFI_MEMORY_DESCRIPTOR *MemoryMapStart;\r
28a00297 1598\r
1599 //\r
1600 // Make sure the parameters are valid\r
1601 //\r
1602 if (MemoryMapSize == NULL) {\r
1603 return EFI_INVALID_PARAMETER;\r
1604 }\r
022c6d45 1605\r
28a00297 1606 CoreAcquireGcdMemoryLock ();\r
022c6d45 1607\r
28a00297 1608 //\r
ba2c0527 1609 // Count the number of Reserved and runtime MMIO entries\r
a671a012 1610 // And, count the number of Persistent entries.\r
28a00297 1611 //\r
ba2c0527 1612 NumberOfEntries = 0;\r
28a00297 1613 for (Link = mGcdMemorySpaceMap.ForwardLink; Link != &mGcdMemorySpaceMap; Link = Link->ForwardLink) {\r
1614 GcdMapEntry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
ba2c0527
LG
1615 if ((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypePersistentMemory) || \r
1616 (GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeReserved) ||\r
1617 ((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo) &&\r
1618 ((GcdMapEntry->Attributes & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME))) {\r
1619 NumberOfEntries ++;\r
a671a012 1620 }\r
28a00297 1621 }\r
1622\r
1623 Size = sizeof (EFI_MEMORY_DESCRIPTOR);\r
1624\r
1625 //\r
1626 // Make sure Size != sizeof(EFI_MEMORY_DESCRIPTOR). This will\r
1627 // prevent people from having pointer math bugs in their code.\r
1628 // now you have to use *DescriptorSize to make things work.\r
1629 //\r
1630 Size += sizeof(UINT64) - (Size % sizeof (UINT64));\r
1631\r
1632 if (DescriptorSize != NULL) {\r
1633 *DescriptorSize = Size;\r
1634 }\r
022c6d45 1635\r
28a00297 1636 if (DescriptorVersion != NULL) {\r
1637 *DescriptorVersion = EFI_MEMORY_DESCRIPTOR_VERSION;\r
1638 }\r
1639\r
1640 CoreAcquireMemoryLock ();\r
1641\r
1642 //\r
1643 // Compute the buffer size needed to fit the entire map\r
1644 //\r
ba2c0527 1645 BufferSize = Size * NumberOfEntries;\r
28a00297 1646 for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
1647 BufferSize += Size;\r
1648 }\r
1649\r
1650 if (*MemoryMapSize < BufferSize) {\r
1651 Status = EFI_BUFFER_TOO_SMALL;\r
1652 goto Done;\r
1653 }\r
1654\r
1655 if (MemoryMap == NULL) {\r
1656 Status = EFI_INVALID_PARAMETER;\r
1657 goto Done;\r
1658 }\r
1659\r
1660 //\r
1661 // Build the map\r
1662 //\r
383c303c 1663 ZeroMem (MemoryMap, BufferSize);\r
2345e7d4 1664 MemoryMapStart = MemoryMap;\r
28a00297 1665 for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
1666 Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
1667 ASSERT (Entry->VirtualStart == 0);\r
1668\r
b74350e9 1669 //\r
1670 // Convert internal map into an EFI_MEMORY_DESCRIPTOR\r
1671 //\r
28a00297 1672 MemoryMap->Type = Entry->Type;\r
1673 MemoryMap->PhysicalStart = Entry->Start;\r
1674 MemoryMap->VirtualStart = Entry->VirtualStart;\r
1675 MemoryMap->NumberOfPages = RShiftU64 (Entry->End - Entry->Start + 1, EFI_PAGE_SHIFT);\r
b74350e9 1676 //\r
1677 // If the memory type is EfiConventionalMemory, then determine if the range is part of a\r
022c6d45 1678 // memory type bin and needs to be converted to the same memory type as the rest of the\r
1679 // memory type bin in order to minimize EFI Memory Map changes across reboots. This\r
b74350e9 1680 // improves the chances for a successful S4 resume in the presence of minor page allocation\r
1681 // differences across reboots.\r
1682 //\r
1683 if (MemoryMap->Type == EfiConventionalMemory) {\r
1684 for (Type = (EFI_MEMORY_TYPE) 0; Type < EfiMaxMemoryType; Type++) {\r
1685 if (mMemoryTypeStatistics[Type].Special &&\r
1686 mMemoryTypeStatistics[Type].NumberOfPages > 0 &&\r
1687 Entry->Start >= mMemoryTypeStatistics[Type].BaseAddress &&\r
e94a9ff7 1688 Entry->End <= mMemoryTypeStatistics[Type].MaximumAddress) {\r
b74350e9 1689 MemoryMap->Type = Type;\r
1690 }\r
1691 }\r
1692 }\r
1693 MemoryMap->Attribute = Entry->Attribute;\r
10fe0d81
RN
1694 if (MemoryMap->Type < EfiMaxMemoryType) {\r
1695 if (mMemoryTypeStatistics[MemoryMap->Type].Runtime) {\r
1696 MemoryMap->Attribute |= EFI_MEMORY_RUNTIME;\r
1697 }\r
28a00297 1698 }\r
022c6d45 1699\r
2345e7d4 1700 //\r
1701 // Check to see if the new Memory Map Descriptor can be merged with an \r
1702 // existing descriptor if they are adjacent and have the same attributes\r
1703 //\r
1704 MemoryMap = MergeMemoryMapDescriptor (MemoryMapStart, MemoryMap, Size);\r
28a00297 1705 }\r
1706\r
46a65f18
LG
1707 \r
1708 ZeroMem (&MergeGcdMapEntry, sizeof (MergeGcdMapEntry));\r
1709 GcdMapEntry = NULL;\r
1710 for (Link = mGcdMemorySpaceMap.ForwardLink; ; Link = Link->ForwardLink) {\r
1711 if (Link != &mGcdMemorySpaceMap) {\r
1712 //\r
1713 // Merge adjacent same type and attribute GCD memory range\r
1714 //\r
1715 GcdMapEntry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
1716 \r
1717 if ((MergeGcdMapEntry.Capabilities == GcdMapEntry->Capabilities) && \r
1718 (MergeGcdMapEntry.Attributes == GcdMapEntry->Attributes) &&\r
1719 (MergeGcdMapEntry.GcdMemoryType == GcdMapEntry->GcdMemoryType) &&\r
1720 (MergeGcdMapEntry.GcdIoType == GcdMapEntry->GcdIoType)) {\r
1721 MergeGcdMapEntry.EndAddress = GcdMapEntry->EndAddress;\r
1722 continue;\r
1723 }\r
1724 }\r
1725\r
1726 if ((MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypeReserved) ||\r
1727 ((MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo) &&\r
1728 ((MergeGcdMapEntry.Attributes & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME))) {\r
1729 //\r
1730 // Page Align GCD range is required. When it is converted to EFI_MEMORY_DESCRIPTOR, \r
1731 // it will be recorded as page PhysicalStart and NumberOfPages. \r
1732 //\r
1733 ASSERT ((MergeGcdMapEntry.BaseAddress & EFI_PAGE_MASK) == 0);\r
1734 ASSERT (((MergeGcdMapEntry.EndAddress - MergeGcdMapEntry.BaseAddress + 1) & EFI_PAGE_MASK) == 0);\r
1735 \r
ba2c0527
LG
1736 // \r
1737 // Create EFI_MEMORY_DESCRIPTOR for every Reserved and runtime MMIO GCD entries\r
1738 //\r
46a65f18 1739 MemoryMap->PhysicalStart = MergeGcdMapEntry.BaseAddress;\r
ba2c0527 1740 MemoryMap->VirtualStart = 0;\r
46a65f18
LG
1741 MemoryMap->NumberOfPages = RShiftU64 ((MergeGcdMapEntry.EndAddress - MergeGcdMapEntry.BaseAddress + 1), EFI_PAGE_SHIFT);\r
1742 MemoryMap->Attribute = (MergeGcdMapEntry.Attributes & ~EFI_MEMORY_PORT_IO) | \r
1743 (MergeGcdMapEntry.Capabilities & (EFI_MEMORY_RP | EFI_MEMORY_WP | EFI_MEMORY_XP | EFI_MEMORY_RO |\r
ff0c6d66 1744 EFI_MEMORY_UC | EFI_MEMORY_UCE | EFI_MEMORY_WC | EFI_MEMORY_WT | EFI_MEMORY_WB));\r
ba2c0527 1745\r
46a65f18 1746 if (MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypeReserved) {\r
ba2c0527 1747 MemoryMap->Type = EfiReservedMemoryType;\r
46a65f18
LG
1748 } else if (MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo) {\r
1749 if ((MergeGcdMapEntry.Attributes & EFI_MEMORY_PORT_IO) == EFI_MEMORY_PORT_IO) {\r
ba2c0527
LG
1750 MemoryMap->Type = EfiMemoryMappedIOPortSpace;\r
1751 } else {\r
1752 MemoryMap->Type = EfiMemoryMappedIO;\r
28a00297 1753 }\r
28a00297 1754 }\r
ba2c0527
LG
1755\r
1756 //\r
1757 // Check to see if the new Memory Map Descriptor can be merged with an \r
1758 // existing descriptor if they are adjacent and have the same attributes\r
1759 //\r
1760 MemoryMap = MergeMemoryMapDescriptor (MemoryMapStart, MemoryMap, Size);\r
28a00297 1761 }\r
a671a012 1762 \r
46a65f18
LG
1763 if (MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypePersistentMemory) {\r
1764 //\r
1765 // Page Align GCD range is required. When it is converted to EFI_MEMORY_DESCRIPTOR, \r
1766 // it will be recorded as page PhysicalStart and NumberOfPages. \r
1767 //\r
1768 ASSERT ((MergeGcdMapEntry.BaseAddress & EFI_PAGE_MASK) == 0);\r
1769 ASSERT (((MergeGcdMapEntry.EndAddress - MergeGcdMapEntry.BaseAddress + 1) & EFI_PAGE_MASK) == 0);\r
1770\r
a671a012
LG
1771 // \r
1772 // Create EFI_MEMORY_DESCRIPTOR for every Persistent GCD entries\r
1773 //\r
46a65f18 1774 MemoryMap->PhysicalStart = MergeGcdMapEntry.BaseAddress;\r
a671a012 1775 MemoryMap->VirtualStart = 0;\r
46a65f18
LG
1776 MemoryMap->NumberOfPages = RShiftU64 ((MergeGcdMapEntry.EndAddress - MergeGcdMapEntry.BaseAddress + 1), EFI_PAGE_SHIFT);\r
1777 MemoryMap->Attribute = MergeGcdMapEntry.Attributes | EFI_MEMORY_NV | \r
1778 (MergeGcdMapEntry.Capabilities & (EFI_MEMORY_RP | EFI_MEMORY_WP | EFI_MEMORY_XP | EFI_MEMORY_RO |\r
ff0c6d66 1779 EFI_MEMORY_UC | EFI_MEMORY_UCE | EFI_MEMORY_WC | EFI_MEMORY_WT | EFI_MEMORY_WB));\r
a671a012
LG
1780 MemoryMap->Type = EfiPersistentMemory;\r
1781 \r
1782 //\r
1783 // Check to see if the new Memory Map Descriptor can be merged with an \r
1784 // existing descriptor if they are adjacent and have the same attributes\r
1785 //\r
1786 MemoryMap = MergeMemoryMapDescriptor (MemoryMapStart, MemoryMap, Size);\r
1787 }\r
46a65f18
LG
1788 if (Link == &mGcdMemorySpaceMap) {\r
1789 //\r
1790 // break loop when arrive at head.\r
1791 //\r
1792 break;\r
1793 }\r
1794 if (GcdMapEntry != NULL) {\r
1795 //\r
1796 // Copy new GCD map entry for the following GCD range merge\r
1797 //\r
1798 CopyMem (&MergeGcdMapEntry, GcdMapEntry, sizeof (MergeGcdMapEntry));\r
1799 }\r
28a00297 1800 }\r
022c6d45 1801\r
2345e7d4 1802 //\r
1803 // Compute the size of the buffer actually used after all memory map descriptor merge operations\r
1804 //\r
1805 BufferSize = ((UINT8 *)MemoryMap - (UINT8 *)MemoryMapStart);\r
1806\r
28a00297 1807 Status = EFI_SUCCESS;\r
1808\r
1809Done:\r
022c6d45 1810 //\r
1811 // Update the map key finally\r
1812 //\r
28a00297 1813 if (MapKey != NULL) {\r
1814 *MapKey = mMemoryMapKey;\r
1815 }\r
022c6d45 1816\r
e439df50 1817 CoreReleaseMemoryLock ();\r
1818\r
1819 CoreReleaseGcdMemoryLock ();\r
1820\r
28a00297 1821 *MemoryMapSize = BufferSize;\r
022c6d45 1822\r
28a00297 1823 return Status;\r
1824}\r
1825\r
28a00297 1826\r
162ed594 1827/**\r
28a00297 1828 Internal function. Used by the pool functions to allocate pages\r
1829 to back pool allocation requests.\r
1830\r
022c6d45 1831 @param PoolType The type of memory for the new pool pages\r
1832 @param NumberOfPages No of pages to allocate\r
1833 @param Alignment Bits to align.\r
28a00297 1834\r
162ed594 1835 @return The allocated memory, or NULL\r
28a00297 1836\r
162ed594 1837**/\r
1838VOID *\r
1839CoreAllocatePoolPages (\r
1840 IN EFI_MEMORY_TYPE PoolType,\r
1841 IN UINTN NumberOfPages,\r
1842 IN UINTN Alignment\r
1843 )\r
28a00297 1844{\r
1845 UINT64 Start;\r
1846\r
1847 //\r
1848 // Find the pages to convert\r
1849 //\r
f3f2e05d 1850 Start = FindFreePages (MAX_ADDRESS, NumberOfPages, PoolType, Alignment);\r
28a00297 1851\r
1852 //\r
1853 // Convert it to boot services data\r
1854 //\r
1855 if (Start == 0) {\r
7df7393f 1856 DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "AllocatePoolPages: failed to allocate %d pages\n", (UINT32)NumberOfPages));\r
28a00297 1857 } else {\r
1858 CoreConvertPages (Start, NumberOfPages, PoolType);\r
1859 }\r
1860\r
e94a9ff7 1861 return (VOID *)(UINTN) Start;\r
28a00297 1862}\r
1863\r
162ed594 1864\r
1865/**\r
1866 Internal function. Frees pool pages allocated via AllocatePoolPages ()\r
1867\r
022c6d45 1868 @param Memory The base address to free\r
162ed594 1869 @param NumberOfPages The number of pages to free\r
1870\r
1871**/\r
28a00297 1872VOID\r
1873CoreFreePoolPages (\r
1874 IN EFI_PHYSICAL_ADDRESS Memory,\r
1875 IN UINTN NumberOfPages\r
1876 )\r
28a00297 1877{\r
1878 CoreConvertPages (Memory, NumberOfPages, EfiConventionalMemory);\r
1879}\r
1880\r
1881\r
28a00297 1882\r
162ed594 1883/**\r
1884 Make sure the memory map is following all the construction rules,\r
28a00297 1885 it is the last time to check memory map error before exit boot services.\r
1886\r
022c6d45 1887 @param MapKey Memory map key\r
28a00297 1888\r
022c6d45 1889 @retval EFI_INVALID_PARAMETER Memory map not consistent with construction\r
1890 rules.\r
162ed594 1891 @retval EFI_SUCCESS Valid memory map.\r
28a00297 1892\r
162ed594 1893**/\r
1894EFI_STATUS\r
1895CoreTerminateMemoryMap (\r
1896 IN UINTN MapKey\r
1897 )\r
28a00297 1898{\r
1899 EFI_STATUS Status;\r
1900 LIST_ENTRY *Link;\r
1901 MEMORY_MAP *Entry;\r
1902\r
1903 Status = EFI_SUCCESS;\r
1904\r
1905 CoreAcquireMemoryLock ();\r
1906\r
1907 if (MapKey == mMemoryMapKey) {\r
1908\r
1909 //\r
1910 // Make sure the memory map is following all the construction rules\r
1911 // This is the last chance we will be able to display any messages on\r
1912 // the console devices.\r
1913 //\r
1914\r
1915 for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
1916 Entry = CR(Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
7d17a6a1
AB
1917 if (Entry->Type < EfiMaxMemoryType) {\r
1918 if (mMemoryTypeStatistics[Entry->Type].Runtime) {\r
1919 ASSERT (Entry->Type != EfiACPIReclaimMemory);\r
1920 ASSERT (Entry->Type != EfiACPIMemoryNVS);\r
1921 if ((Entry->Start & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) != 0) {\r
1922 DEBUG((DEBUG_ERROR | DEBUG_PAGE, "ExitBootServices: A RUNTIME memory entry is not on a proper alignment.\n"));\r
1923 Status = EFI_INVALID_PARAMETER;\r
1924 goto Done;\r
1925 }\r
1926 if (((Entry->End + 1) & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) != 0) {\r
1927 DEBUG((DEBUG_ERROR | DEBUG_PAGE, "ExitBootServices: A RUNTIME memory entry is not on a proper alignment.\n"));\r
1928 Status = EFI_INVALID_PARAMETER;\r
1929 goto Done;\r
1930 }\r
28a00297 1931 }\r
1932 }\r
1933 }\r
1934\r
1935 //\r
1936 // The map key they gave us matches what we expect. Fall through and\r
1937 // return success. In an ideal world we would clear out all of\r
1938 // EfiBootServicesCode and EfiBootServicesData. However this function\r
1939 // is not the last one called by ExitBootServices(), so we have to\r
1940 // preserve the memory contents.\r
1941 //\r
1942 } else {\r
1943 Status = EFI_INVALID_PARAMETER;\r
1944 }\r
1945\r
d45fd260 1946Done:\r
28a00297 1947 CoreReleaseMemoryLock ();\r
1948\r
1949 return Status;\r
1950}\r
1951\r
1952\r
1953\r
1954\r
1955\r
1956\r
1957\r
1958\r
162ed594 1959\r