UefiLib:
[mirror_edk2.git] / MdePkg / Library / PeiMemoryAllocationLib / MemoryAllocationLib.c
1 /** @file
2 Support routines for memory allocation routines for use with drivers.
3
4 Copyright (c) 2006, Intel Corporation<BR>
5 All rights reserved. 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
9
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.
12
13 Module Name: MemoryAllocationLib.c
14
15 **/
16
17
18
19 /**
20 Allocates the number of 4KB pages specified by Pages of a certain memory type.
21
22 @param MemoryType The type of memory to allocate.
23 @param Pages The number of 4 KB pages to allocate.
24
25 @return A pointer to the allocated buffer. The buffer returned is aligned on a 4KB boundary.
26 If Pages is 0, then NULL is returned.
27 If there is not enough memory remaining to satisfy the request, then NULL is returned.
28
29 **/
30 VOID *
31 InternalAllocatePages (
32 IN EFI_MEMORY_TYPE MemoryType,
33 IN UINTN Pages
34 )
35 {
36 EFI_STATUS Status;
37 EFI_PHYSICAL_ADDRESS Memory;
38 EFI_PEI_SERVICES **PeiServices;
39
40 if (Pages == 0) {
41 return NULL;
42 }
43
44 PeiServices = GetPeiServicesTablePointer ();
45 Status = (*PeiServices)->AllocatePages (PeiServices, MemoryType, Pages, &Memory);
46 if (EFI_ERROR (Status)) {
47 Memory = 0;
48 }
49 return (VOID *) (UINTN) Memory;
50 }
51
52 /**
53 Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData.
54
55 @param Pages The number of 4 KB pages to allocate.
56
57 @return A pointer to the allocated buffer. The buffer returned is aligned on a 4KB boundary.
58 If Pages is 0, then NULL is returned.
59 If there is not enough memory remaining to satisfy the request, then NULL is returned.
60
61 **/
62 VOID *
63 EFIAPI
64 AllocatePages (
65 IN UINTN Pages
66 )
67 {
68 return InternalAllocatePages (EfiBootServicesData, Pages);
69 }
70
71 /**
72 Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData.
73
74 @param Pages The number of 4 KB pages to allocate.
75
76 @return A pointer to the allocated buffer. The buffer returned is aligned on a 4KB boundary.
77 If Pages is 0, then NULL is returned.
78 If there is not enough memory remaining to satisfy the request, then NULL is returned.
79
80 **/
81 VOID *
82 EFIAPI
83 AllocateRuntimePages (
84 IN UINTN Pages
85 )
86 {
87 return InternalAllocatePages (EfiRuntimeServicesData, Pages);
88 }
89
90 /**
91 Allocates the number of 4KB pages specified by Pages of type EfiReservedMemoryType.
92
93 @param Pages The number of 4 KB pages to allocate.
94
95 @return A pointer to the allocated buffer. The buffer returned is aligned on a 4KB boundary.
96 If Pages is 0, then NULL is returned.
97 If there is not enough memory remaining to satisfy the request, then NULL is returned.
98
99 **/
100 VOID *
101 EFIAPI
102 AllocateReservedPages (
103 IN UINTN Pages
104 )
105 {
106 return InternalAllocatePages (EfiReservedMemoryType, Pages);
107 }
108
109 /**
110 Frees one or more 4KB pages that were previously allocated with
111 one of the page allocation functions in the Memory Allocation Library.
112
113 @param Buffer Pointer to the buffer of pages to free.
114 @param Pages The number of 4 KB pages to free.
115
116 **/
117 VOID
118 EFIAPI
119 FreePages (
120 IN VOID *Buffer,
121 IN UINTN Pages
122 )
123 {
124 //
125 // PEI phase does not support to free pages, so leave it as NOP.
126 //
127 }
128
129 /**
130 Allocates the number of 4KB pages specified by Pages of a certian memory type
131 with an alignment specified by Alignment.
132
133 @param MemoryType The type of memory to allocate.
134 @param Pages The number of 4 KB pages to allocate.
135 @param Alignment The requested alignment of the allocation. Must be a power of two.
136 If Alignment is zero, then byte alignment is used.
137
138 @return The allocated buffer is returned. If Pages is 0, then NULL is returned.
139 If there is not enough memory at the specified alignment remaining to satisfy the request, then NULL is returned.
140
141 **/
142 VOID *
143 InternalAllocateAlignedPages (
144 IN EFI_MEMORY_TYPE MemoryType,
145 IN UINTN Pages,
146 IN UINTN Alignment
147 )
148 {
149 VOID *Memory;
150 UINTN AlignmentMask;
151
152 //
153 // Alignment must be a power of two or zero.
154 //
155 ASSERT ((Alignment & (Alignment - 1)) == 0);
156
157 if (Pages == 0) {
158 return NULL;
159 }
160 //
161 // Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not overflow.
162 //
163 ASSERT (Pages <= (MAX_ADDRESS - EFI_SIZE_TO_PAGES (Alignment)));
164 //
165 // We would rather waste some memory to save PEI code size.
166 //
167 Memory = InternalAllocatePages (MemoryType, Pages + EFI_SIZE_TO_PAGES (Alignment));
168 if (Alignment == 0) {
169 AlignmentMask = Alignment;
170 } else {
171 AlignmentMask = Alignment - 1;
172 }
173 return (VOID *) (UINTN) (((UINTN) Memory + AlignmentMask) & ~AlignmentMask);
174 }
175
176 /**
177 Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData
178 with an alignment specified by Alignment.
179
180 @param Pages The number of 4 KB pages to allocate.
181 @param Alignment The requested alignment of the allocation. Must be a power of two.
182 If Alignment is zero, then byte alignment is used.
183
184 @return The allocated buffer is returned. If Pages is 0, then NULL is returned.
185 If there is not enough memory at the specified alignment remaining to satisfy the request, then NULL is returned.
186
187 **/
188 VOID *
189 EFIAPI
190 AllocateAlignedPages (
191 IN UINTN Pages,
192 IN UINTN Alignment
193 )
194 {
195 return InternalAllocateAlignedPages (EfiBootServicesData, Pages, Alignment);
196 }
197
198 /**
199 Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData
200 with an alignment specified by Alignment.
201
202 @param Pages The number of 4 KB pages to allocate.
203 @param Alignment The requested alignment of the allocation. Must be a power of two.
204 If Alignment is zero, then byte alignment is used.
205
206 @return The allocated buffer is returned. If Pages is 0, then NULL is returned.
207 If there is not enough memory at the specified alignment remaining to satisfy the request, then NULL is returned.
208
209 **/
210 VOID *
211 EFIAPI
212 AllocateAlignedRuntimePages (
213 IN UINTN Pages,
214 IN UINTN Alignment
215 )
216 {
217 return InternalAllocateAlignedPages (EfiRuntimeServicesData, Pages, Alignment);
218 }
219
220 /**
221 Allocates one or more 4KB pages of type EfiReservedMemoryType at a specified alignment.
222
223 @param Pages The number of 4 KB pages to allocate.
224 @param Alignment The requested alignment of the allocation. Must be a power of two.
225 If Alignment is zero, then byte alignment is used.
226
227 @return The allocated buffer is returned. If Pages is 0, then NULL is returned.
228 If there is not enough memory at the specified alignment remaining to satisfy the request, then NULL is returned.
229
230 **/
231 VOID *
232 EFIAPI
233 AllocateAlignedReservedPages (
234 IN UINTN Pages,
235 IN UINTN Alignment
236 )
237 {
238 return InternalAllocateAlignedPages (EfiReservedMemoryType, Pages, Alignment);
239 }
240
241 /**
242 Frees one or more 4KB pages that were previously allocated with
243 one of the aligned page allocation functions in the Memory Allocation Library.
244
245 @param Buffer Pointer to the buffer of pages to free.
246 @param Pages The number of 4 KB pages to free.
247
248 **/
249 VOID
250 EFIAPI
251 FreeAlignedPages (
252 IN VOID *Buffer,
253 IN UINTN Pages
254 )
255 {
256 //
257 // PEI phase does not support to free pages, so leave it as NOP.
258 //
259 }
260
261 /**
262 Allocates a buffer of a certain memory type.
263
264 @param MemoryType The type of memory to allocate.
265 @param AllocationSize The number of bytes to allocate.
266
267 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
268 If there is not enough memory remaining to satisfy the request, then NULL is returned.
269
270 **/
271 VOID *
272 InternalAllocatePool (
273 IN EFI_MEMORY_TYPE MemoryType,
274 IN UINTN AllocationSize
275 )
276 {
277 //
278 // If we need lots of small runtime/reserved memory type from PEI in the future,
279 // we can consider providing a more complex algorithm that allocates runtime pages and
280 // provide pool allocations from those pages.
281 //
282 return InternalAllocatePages (MemoryType, EFI_SIZE_TO_PAGES (AllocationSize));
283 }
284
285 /**
286 Allocates a buffer of type EfiBootServicesData.
287
288 @param AllocationSize The number of bytes to allocate.
289
290 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
291 If there is not enough memory remaining to satisfy the request, then NULL is returned.
292
293 **/
294 VOID *
295 EFIAPI
296 AllocatePool (
297 IN UINTN AllocationSize
298 )
299 {
300 EFI_STATUS Status;
301 EFI_PEI_SERVICES **PeiServices;
302 VOID *Buffer;
303
304 PeiServices = GetPeiServicesTablePointer ();
305
306 Status = (*PeiServices)->AllocatePool (PeiServices, AllocationSize, &Buffer);
307 if (EFI_ERROR (Status)) {
308 Buffer = NULL;
309 }
310 return Buffer;
311 }
312
313 /**
314 Allocates a buffer of type EfiRuntimeServicesData.
315
316 @param AllocationSize The number of bytes to allocate.
317
318 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
319 If there is not enough memory remaining to satisfy the request, then NULL is returned.
320
321 **/
322 VOID *
323 EFIAPI
324 AllocateRuntimePool (
325 IN UINTN AllocationSize
326 )
327 {
328 return InternalAllocatePool (EfiRuntimeServicesData, AllocationSize);
329 }
330
331 /**
332 Allocates a buffer of type EfiReservedMemoryType.
333
334 @param AllocationSize The number of bytes to allocate.
335
336 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
337 If there is not enough memory remaining to satisfy the request, then NULL is returned.
338
339 **/
340 VOID *
341 EFIAPI
342 AllocateReservedPool (
343 IN UINTN AllocationSize
344 )
345 {
346 return InternalAllocatePool (EfiReservedMemoryType, AllocationSize);
347 }
348
349 /**
350 Allocates and zeros a buffer of a certian pool type.
351
352 @param PoolType The type of memory to allocate.
353 @param AllocationSize The number of bytes to allocate and zero.
354
355 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
356 If there is not enough memory remaining to satisfy the request, then NULL is returned.
357
358 **/
359 VOID *
360 InternalAllocateZeroPool (
361 IN EFI_MEMORY_TYPE PoolType,
362 IN UINTN AllocationSize
363 )
364 {
365 VOID *Memory;
366
367 Memory = InternalAllocatePool (PoolType, AllocationSize);
368 if (Memory != NULL) {
369 Memory = ZeroMem (Memory, AllocationSize);
370 }
371 return Memory;
372 }
373
374 /**
375 Allocates and zeros a buffer of type EfiBootServicesData.
376
377 @param AllocationSize The number of bytes to allocate and zero.
378
379 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
380 If there is not enough memory remaining to satisfy the request, then NULL is returned.
381
382 **/
383 VOID *
384 EFIAPI
385 AllocateZeroPool (
386 IN UINTN AllocationSize
387 )
388 {
389 VOID *Memory;
390
391 Memory = AllocatePool (AllocationSize);
392 if (Memory != NULL) {
393 Memory = ZeroMem (Memory, AllocationSize);
394 }
395 return Memory;
396 }
397
398 /**
399 Allocates and zeros a buffer of type EfiRuntimeServicesData.
400
401 @param AllocationSize The number of bytes to allocate and zero.
402
403 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
404 If there is not enough memory remaining to satisfy the request, then NULL is returned.
405
406 **/
407 VOID *
408 EFIAPI
409 AllocateRuntimeZeroPool (
410 IN UINTN AllocationSize
411 )
412 {
413 return InternalAllocateZeroPool (EfiRuntimeServicesData, AllocationSize);
414 }
415
416 /**
417 Allocates and zeros a buffer of type EfiReservedMemoryType.
418
419 @param AllocationSize The number of bytes to allocate and zero.
420
421 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
422 If there is not enough memory remaining to satisfy the request, then NULL is returned.
423
424 **/
425 VOID *
426 EFIAPI
427 AllocateReservedZeroPool (
428 IN UINTN AllocationSize
429 )
430 {
431 return InternalAllocateZeroPool (EfiReservedMemoryType, AllocationSize);
432 }
433
434 /**
435 Copies a buffer to an allocated buffer of a certian memory type.
436
437 @param MemoryType The type of pool to allocate.
438 @param AllocationSize The number of bytes to allocate and zero.
439 @param Buffer The buffer to copy to the allocated buffer.
440
441 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
442 If there is not enough memory remaining to satisfy the request, then NULL is returned.
443
444 **/
445 VOID *
446 InternalAllocateCopyPool (
447 IN EFI_MEMORY_TYPE PoolType,
448 IN UINTN AllocationSize,
449 IN CONST VOID *Buffer
450 )
451 {
452 VOID *Memory;
453
454 ASSERT (Buffer != NULL);
455 ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
456
457 Memory = InternalAllocatePool (PoolType, AllocationSize);
458 if (Memory != NULL) {
459 Memory = CopyMem (Memory, Buffer, AllocationSize);
460 }
461 return Memory;
462 }
463
464 /**
465 Copies a buffer to an allocated buffer of type EfiBootServicesData.
466
467 @param AllocationSize The number of bytes to allocate.
468 @param Buffer The buffer to copy to the allocated buffer.
469
470 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
471 If there is not enough memory remaining to satisfy the request, then NULL is returned.
472
473 **/
474 VOID *
475 EFIAPI
476 AllocateCopyPool (
477 IN UINTN AllocationSize,
478 IN CONST VOID *Buffer
479 )
480 {
481 VOID *Memory;
482
483 ASSERT (Buffer != NULL);
484 ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
485
486 Memory = AllocatePool (AllocationSize);
487 if (Memory != NULL) {
488 Memory = CopyMem (Memory, Buffer, AllocationSize);
489 }
490 return Memory;
491 }
492
493 /**
494 Copies a buffer to an allocated buffer of type EfiRuntimeServicesData.
495
496 @param AllocationSize The number of bytes to allocate.
497 @param Buffer The buffer to copy to the allocated buffer.
498
499 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
500 If there is not enough memory remaining to satisfy the request, then NULL is returned.
501
502 **/
503 VOID *
504 EFIAPI
505 AllocateRuntimeCopyPool (
506 IN UINTN AllocationSize,
507 IN CONST VOID *Buffer
508 )
509 {
510 return InternalAllocateCopyPool (EfiRuntimeServicesData, AllocationSize, Buffer);
511 }
512
513 /**
514 Copies a buffer to an allocated buffer of type EfiReservedMemoryType.
515
516 @param AllocationSize The number of bytes to allocate.
517 @param Buffer The buffer to copy to the allocated buffer.
518
519 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
520 If there is not enough memory remaining to satisfy the request, then NULL is returned.
521
522 **/
523 VOID *
524 EFIAPI
525 AllocateReservedCopyPool (
526 IN UINTN AllocationSize,
527 IN CONST VOID *Buffer
528 )
529 {
530 return InternalAllocateCopyPool (EfiReservedMemoryType, AllocationSize, Buffer);
531 }
532
533 /**
534 Copies a buffer to an allocated buffer of type EfiReservedMemoryType at a specified alignment.
535
536 @param Buffer Pointer to the buffer to free.
537
538 **/
539 VOID
540 EFIAPI
541 FreePool (
542 IN VOID *Buffer
543 )
544 {
545 //
546 // PEI phase does not support to free pool, so leave it as NOP.
547 //
548 }
549
550 /**
551 Allocates a buffer of a certain pool type at a specified alignment.
552
553 @param PoolType The type of pool to allocate.
554 @param AllocationSize The number of bytes to allocate.
555 @param Alignment The requested alignment of the allocation. Must be a power of two. If Alignment is zero, then byte alignment is used.
556
557 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
558 If there is not enough memory remaining to satisfy the request, then NULL is returned.
559
560 **/
561 VOID *
562 InternalAllocateAlignedPool (
563 IN EFI_MEMORY_TYPE PoolType,
564 IN UINTN AllocationSize,
565 IN UINTN Alignment
566 )
567 {
568 VOID *RawAddress;
569 UINTN AlignedAddress;
570 UINTN AlignmentMask;
571
572 //
573 // Alignment must be a power of two or zero.
574 //
575 ASSERT ((Alignment & (Alignment - 1)) == 0);
576
577 if (Alignment == 0) {
578 AlignmentMask = Alignment;
579 } else {
580 AlignmentMask = Alignment - 1;
581 }
582 //
583 // Make sure that AllocationSize plus AlignmentMask does not overflow.
584 //
585 ASSERT (AllocationSize <= (MAX_ADDRESS - AlignmentMask));
586
587 RawAddress = InternalAllocatePool (PoolType, AllocationSize + AlignmentMask);
588
589 AlignedAddress = ((UINTN) RawAddress + AlignmentMask) & ~AlignmentMask;
590
591 return (VOID *) AlignedAddress;
592 }
593
594 /**
595 Allocates a buffer of type EfiBootServicesData at a specified alignment.
596
597 @param AllocationSize The number of bytes to allocate.
598 @param Alignment The requested alignment of the allocation. Must be a power of two. If Alignment is zero, then byte alignment is used.
599
600 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
601 If there is not enough memory remaining to satisfy the request, then NULL is returned.
602
603 **/
604 VOID *
605 EFIAPI
606 AllocateAlignedPool (
607 IN UINTN AllocationSize,
608 IN UINTN Alignment
609 )
610 {
611 VOID *RawAddress;
612 UINTN AlignedAddress;
613 UINTN AlignmentMask;
614
615 //
616 // Alignment must be a power of two or zero.
617 //
618 ASSERT ((Alignment & (Alignment - 1)) == 0);
619
620 if (Alignment == 0) {
621 AlignmentMask = Alignment;
622 } else {
623 AlignmentMask = Alignment - 1;
624 }
625
626 //
627 // Make sure that AllocationSize plus AlignmentMask does not overflow.
628 //
629 ASSERT (AllocationSize <= (MAX_ADDRESS - AlignmentMask));
630
631 RawAddress = AllocatePool (AllocationSize + AlignmentMask);
632
633 AlignedAddress = ((UINTN) RawAddress + AlignmentMask) & ~AlignmentMask;
634
635 return (VOID *) AlignedAddress;
636 }
637
638 /**
639 Allocates a buffer of type EfiRuntimeServicesData at a specified alignment.
640
641 @param AllocationSize The number of bytes to allocate.
642 @param Alignment The requested alignment of the allocation. Must be a power of two.
643 If Alignment is zero, then byte alignment is used.
644
645 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
646 If there is not enough memory remaining to satisfy the request, then NULL is returned.
647
648 **/
649 VOID *
650 EFIAPI
651 AllocateAlignedRuntimePool (
652 IN UINTN AllocationSize,
653 IN UINTN Alignment
654 )
655 {
656 return InternalAllocateAlignedPool (EfiRuntimeServicesData, AllocationSize, Alignment);
657 }
658
659 /**
660 Allocates a buffer of type EfiReservedMemoryType at a specified alignment.
661
662 @param AllocationSize The number of bytes to allocate.
663 @param Alignment The requested alignment of the allocation. Must be a power of two.
664 If Alignment is zero, then byte alignment is used.
665
666 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
667 If there is not enough memory remaining to satisfy the request, then NULL is returned.
668
669 **/
670 VOID *
671 EFIAPI
672 AllocateAlignedReservedPool (
673 IN UINTN AllocationSize,
674 IN UINTN Alignment
675 )
676 {
677 return InternalAllocateAlignedPool (EfiReservedMemoryType, AllocationSize, Alignment);
678 }
679
680 /**
681 Allocates and zeros a buffer of type EfiBootServicesData at a specified alignment.
682
683 @param PoolType The type of pool to allocate.
684 @param AllocationSize The number of bytes to allocate.
685 @param Alignment The requested alignment of the allocation. Must be a power of two.
686 If Alignment is zero, then byte alignment is used.
687
688 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
689 If there is not enough memory remaining to satisfy the request, then NULL is returned.
690
691 **/
692 VOID *
693 InternalAllocateAlignedZeroPool (
694 IN EFI_MEMORY_TYPE PoolType,
695 IN UINTN AllocationSize,
696 IN UINTN Alignment
697 )
698 {
699 VOID *Memory;
700
701 Memory = InternalAllocateAlignedPool (PoolType, AllocationSize, Alignment);
702 if (Memory != NULL) {
703 Memory = ZeroMem (Memory, AllocationSize);
704 }
705 return Memory;
706 }
707
708 /**
709 Allocates and zeros a buffer of type EfiBootServicesData at a specified alignment.
710
711 @param AllocationSize The number of bytes to allocate.
712 @param Alignment The requested alignment of the allocation. Must be a power of two.
713 If Alignment is zero, then byte alignment is used.
714
715 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
716 If there is not enough memory remaining to satisfy the request, then NULL is returned.
717
718 **/
719 VOID *
720 EFIAPI
721 AllocateAlignedZeroPool (
722 IN UINTN AllocationSize,
723 IN UINTN Alignment
724 )
725 {
726 VOID *Memory;
727
728 Memory = AllocateAlignedPool (AllocationSize, Alignment);
729 if (Memory != NULL) {
730 Memory = ZeroMem (Memory, AllocationSize);
731 }
732 return Memory;
733 }
734
735 /**
736 Allocates and zeros a buffer of type EfiRuntimeServicesData at a specified alignment.
737
738 @param AllocationSize The number of bytes to allocate.
739 @param Alignment The requested alignment of the allocation. Must be a power of two.
740 If Alignment is zero, then byte alignment is used.
741
742 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
743 If there is not enough memory remaining to satisfy the request, then NULL is returned.
744
745 **/
746 VOID *
747 EFIAPI
748 AllocateAlignedRuntimeZeroPool (
749 IN UINTN AllocationSize,
750 IN UINTN Alignment
751 )
752 {
753 return InternalAllocateAlignedZeroPool (EfiRuntimeServicesData, AllocationSize, Alignment);
754 }
755
756 /**
757 Allocates and zeros a buffer of type EfiReservedMemoryType at a specified alignment.
758
759 @param AllocationSize The number of bytes to allocate.
760 @param Alignment The requested alignment of the allocation. Must be a power of two.
761 If Alignment is zero, then byte alignment is used.
762
763 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
764 If there is not enough memory remaining to satisfy the request, then NULL is returned.
765
766 **/
767 VOID *
768 EFIAPI
769 AllocateAlignedReservedZeroPool (
770 IN UINTN AllocationSize,
771 IN UINTN Alignment
772 )
773 {
774 return InternalAllocateAlignedZeroPool (EfiReservedMemoryType, AllocationSize, Alignment);
775 }
776
777 /**
778 Copies a buffer to an allocated buffer of type EfiBootServicesData at a specified alignment.
779
780 @param PoolType The type of pool to allocate.
781 @param AllocationSize The number of bytes to allocate.
782 @param Buffer The buffer to copy to the allocated buffer.
783 @param Alignment The requested alignment of the allocation. Must be a power of two.
784 If Alignment is zero, then byte alignment is used.
785
786 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
787 If there is not enough memory remaining to satisfy the request, then NULL is returned.
788
789 **/
790 VOID *
791 InternalAllocateAlignedCopyPool (
792 IN EFI_MEMORY_TYPE PoolType,
793 IN UINTN AllocationSize,
794 IN CONST VOID *Buffer,
795 IN UINTN Alignment
796 )
797 {
798 VOID *Memory;
799
800 ASSERT (Buffer != NULL);
801 ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
802
803 Memory = InternalAllocateAlignedPool (PoolType, AllocationSize, Alignment);
804 if (Memory != NULL) {
805 Memory = CopyMem (Memory, Buffer, AllocationSize);
806 }
807 return Memory;
808 }
809
810 /**
811 Copies a buffer to an allocated buffer of type EfiBootServicesData at a specified alignment.
812
813 @param AllocationSize The number of bytes to allocate.
814 @param Buffer The buffer to copy to the allocated buffer.
815 @param Alignment The requested alignment of the allocation. Must be a power of two.
816 If Alignment is zero, then byte alignment is used.
817
818 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
819 If there is not enough memory remaining to satisfy the request, then NULL is returned.
820
821 **/
822 VOID *
823 EFIAPI
824 AllocateAlignedCopyPool (
825 IN UINTN AllocationSize,
826 IN CONST VOID *Buffer,
827 IN UINTN Alignment
828 )
829 {
830 VOID *Memory;
831
832 ASSERT (Buffer != NULL);
833 ASSERT (AllocationSize <= (MAX_ADDRESS - (UINTN) Buffer + 1));
834
835 Memory = AllocateAlignedPool (AllocationSize, Alignment);
836 if (Memory != NULL) {
837 Memory = CopyMem (Memory, Buffer, AllocationSize);
838 }
839 return Memory;
840 }
841
842 /**
843 Copies a buffer to an allocated buffer of type EfiRuntimeServicesData at a specified alignment.
844
845 @param AllocationSize The number of bytes to allocate.
846 @param Buffer The buffer to copy to the allocated buffer.
847 @param Alignment The requested alignment of the allocation. Must be a power of two.
848 If Alignment is zero, then byte alignment is used.
849
850 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
851 If there is not enough memory remaining to satisfy the request, then NULL is returned.
852
853 **/
854 VOID *
855 EFIAPI
856 AllocateAlignedRuntimeCopyPool (
857 IN UINTN AllocationSize,
858 IN CONST VOID *Buffer,
859 IN UINTN Alignment
860 )
861 {
862 return InternalAllocateAlignedCopyPool (EfiRuntimeServicesData, AllocationSize, Buffer, Alignment);
863 }
864
865 /**
866 Copies a buffer to an allocated buffer of type EfiReservedMemoryType at a specified alignment.
867
868 @param AllocationSize The number of bytes to allocate.
869 @param Buffer The buffer to copy to the allocated buffer.
870 @param Alignment The requested alignment of the allocation. Must be a power of two.
871 If Alignment is zero, then byte alignment is used.
872
873 @return A pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is returned.
874 If there is not enough memory remaining to satisfy the request, then NULL is returned.
875
876 **/
877 VOID *
878 EFIAPI
879 AllocateAlignedReservedCopyPool (
880 IN UINTN AllocationSize,
881 IN CONST VOID *Buffer,
882 IN UINTN Alignment
883 )
884 {
885 return InternalAllocateAlignedCopyPool (EfiReservedMemoryType, AllocationSize, Buffer, Alignment);
886 }
887
888 /**
889 Frees a buffer that was previously allocated with one of the aligned pool allocation functions
890 in the Memory Allocation Library.
891
892 @param Buffer Pointer to the buffer to free.
893
894 **/
895 VOID
896 EFIAPI
897 FreeAlignedPool (
898 IN VOID *Buffer
899 )
900 {
901 //
902 // PEI phase does not support to free pool, so leave it as NOP.
903 //
904 }