2 Core image handling services to load and unload PeImage.
4 Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
21 LOADED_IMAGE_PRIVATE_DATA
*mCurrentImage
= NULL
;
23 LOAD_PE32_IMAGE_PRIVATE_DATA mLoadPe32PrivateData
= {
24 LOAD_PE32_IMAGE_PRIVATE_DATA_SIGNATURE
,
34 // This code is needed to build the Image handle for the DXE Core
36 LOADED_IMAGE_PRIVATE_DATA mCorePrivateImage
= {
37 LOADED_IMAGE_PRIVATE_DATA_SIGNATURE
, // Signature
39 EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
, // Image type
40 TRUE
, // If entrypoint has been called
43 EFI_LOADED_IMAGE_INFORMATION_REVISION
, // Revision
44 NULL
, // Parent handle
45 NULL
, // System handle
47 NULL
, // Device handle
56 EfiBootServicesCode
, // ImageCodeType
57 EfiBootServicesData
// ImageDataType
59 (EFI_PHYSICAL_ADDRESS
)0, // ImageBasePage
63 EFI_SUCCESS
, // Status
71 NULL
// LoadedImageDevicePath
74 // The field is define for Loading modules at fixed address feature to tracker the PEI code
75 // memory range usage. It is a bit mapped array in which every bit indicates the correspoding memory page
78 GLOBAL_REMOVE_IF_UNREFERENCED UINT64
*mDxeCodeMemoryRangeUsageBitMap
=NULL
;
82 CHAR16
*MachineTypeName
;
86 // EBC machine is not listed in this table, because EBC is in the default supported scopes of other machine type.
88 GLOBAL_REMOVE_IF_UNREFERENCED MACHINE_TYPE_INFO mMachineTypeInfo
[] = {
89 {EFI_IMAGE_MACHINE_IA32
, L
"IA32"},
90 {EFI_IMAGE_MACHINE_IA64
, L
"IA64"},
91 {EFI_IMAGE_MACHINE_X64
, L
"X64"},
92 {EFI_IMAGE_MACHINE_ARMTHUMB_MIXED
, L
"ARM"}
95 UINT16 mDxeCoreImageMachineType
= 0;
98 Return machine type name.
100 @param MachineType The machine type
102 @return machine type name
111 for (Index
= 0; Index
< sizeof(mMachineTypeInfo
)/sizeof(mMachineTypeInfo
[0]); Index
++) {
112 if (mMachineTypeInfo
[Index
].MachineType
== MachineType
) {
113 return mMachineTypeInfo
[Index
].MachineTypeName
;
121 Add the Image Services to EFI Boot Services Table and install the protocol
122 interfaces for this image.
124 @param HobStart The HOB to initialize
130 CoreInitializeImageServices (
135 LOADED_IMAGE_PRIVATE_DATA
*Image
;
136 EFI_PHYSICAL_ADDRESS DxeCoreImageBaseAddress
;
137 UINT64 DxeCoreImageLength
;
138 VOID
*DxeCoreEntryPoint
;
139 EFI_PEI_HOB_POINTERS DxeCoreHob
;
142 // Searching for image hob
144 DxeCoreHob
.Raw
= HobStart
;
145 while ((DxeCoreHob
.Raw
= GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION
, DxeCoreHob
.Raw
)) != NULL
) {
146 if (CompareGuid (&DxeCoreHob
.MemoryAllocationModule
->MemoryAllocationHeader
.Name
, &gEfiHobMemoryAllocModuleGuid
)) {
152 DxeCoreHob
.Raw
= GET_NEXT_HOB (DxeCoreHob
);
154 ASSERT (DxeCoreHob
.Raw
!= NULL
);
156 DxeCoreImageBaseAddress
= DxeCoreHob
.MemoryAllocationModule
->MemoryAllocationHeader
.MemoryBaseAddress
;
157 DxeCoreImageLength
= DxeCoreHob
.MemoryAllocationModule
->MemoryAllocationHeader
.MemoryLength
;
158 DxeCoreEntryPoint
= (VOID
*) (UINTN
) DxeCoreHob
.MemoryAllocationModule
->EntryPoint
;
159 gDxeCoreFileName
= &DxeCoreHob
.MemoryAllocationModule
->ModuleName
;
162 // Initialize the fields for an internal driver
164 Image
= &mCorePrivateImage
;
166 Image
->EntryPoint
= (EFI_IMAGE_ENTRY_POINT
)(UINTN
)DxeCoreEntryPoint
;
167 Image
->ImageBasePage
= DxeCoreImageBaseAddress
;
168 Image
->NumberOfPages
= (UINTN
)(EFI_SIZE_TO_PAGES((UINTN
)(DxeCoreImageLength
)));
169 Image
->Tpl
= gEfiCurrentTpl
;
170 Image
->Info
.SystemTable
= gDxeCoreST
;
171 Image
->Info
.ImageBase
= (VOID
*)(UINTN
)DxeCoreImageBaseAddress
;
172 Image
->Info
.ImageSize
= DxeCoreImageLength
;
175 // Install the protocol interfaces for this image
177 Status
= CoreInstallProtocolInterface (
179 &gEfiLoadedImageProtocolGuid
,
180 EFI_NATIVE_INTERFACE
,
183 ASSERT_EFI_ERROR (Status
);
185 mCurrentImage
= Image
;
188 // Fill in DXE globals
190 mDxeCoreImageMachineType
= PeCoffLoaderGetMachineType (Image
->Info
.ImageBase
);
191 gDxeCoreImageHandle
= Image
->Handle
;
192 gDxeCoreLoadedImage
= &Image
->Info
;
194 if (FeaturePcdGet (PcdFrameworkCompatibilitySupport
)) {
196 // Export DXE Core PE Loader functionality for backward compatibility.
198 Status
= CoreInstallProtocolInterface (
199 &mLoadPe32PrivateData
.Handle
,
200 &gEfiLoadPeImageProtocolGuid
,
201 EFI_NATIVE_INTERFACE
,
202 &mLoadPe32PrivateData
.Pe32Image
210 Read image file (specified by UserHandle) into user specified buffer with specified offset
213 @param UserHandle Image file handle
214 @param Offset Offset to the source file
215 @param ReadSize For input, pointer of size to read; For output,
216 pointer of size actually read.
217 @param Buffer Buffer to write into
219 @retval EFI_SUCCESS Successfully read the specified part of file
228 IN OUT UINTN
*ReadSize
,
233 IMAGE_FILE_HANDLE
*FHand
;
235 if (UserHandle
== NULL
|| ReadSize
== NULL
|| Buffer
== NULL
) {
236 return EFI_INVALID_PARAMETER
;
239 if (MAX_ADDRESS
- Offset
< *ReadSize
) {
240 return EFI_INVALID_PARAMETER
;
243 FHand
= (IMAGE_FILE_HANDLE
*)UserHandle
;
244 ASSERT (FHand
->Signature
== IMAGE_FILE_HANDLE_SIGNATURE
);
247 // Move data from our local copy of the file
249 EndPosition
= Offset
+ *ReadSize
;
250 if (EndPosition
> FHand
->SourceSize
) {
251 *ReadSize
= (UINT32
)(FHand
->SourceSize
- Offset
);
253 if (Offset
>= FHand
->SourceSize
) {
257 CopyMem (Buffer
, (CHAR8
*)FHand
->Source
+ Offset
, *ReadSize
);
261 To check memory usage bit map arry to figure out if the memory range the image will be loaded in is available or not. If
262 memory range is avaliable, the function will mark the correponding bits to 1 which indicates the memory range is used.
263 The function is only invoked when load modules at fixed address feature is enabled.
265 @param ImageBase The base addres the image will be loaded at.
266 @param ImageSize The size of the image
268 @retval EFI_SUCCESS The memory range the image will be loaded in is available
269 @retval EFI_NOT_FOUND The memory range the image will be loaded in is not available
272 CheckAndMarkFixLoadingMemoryUsageBitMap (
273 IN EFI_PHYSICAL_ADDRESS ImageBase
,
277 UINT32 DxeCodePageNumber
;
279 EFI_PHYSICAL_ADDRESS DxeCodeBase
;
280 UINTN BaseOffsetPageNumber
;
281 UINTN TopOffsetPageNumber
;
284 // The DXE code range includes RuntimeCodePage range and Boot time code range.
286 DxeCodePageNumber
= PcdGet32(PcdLoadFixAddressRuntimeCodePageNumber
);
287 DxeCodePageNumber
+= PcdGet32(PcdLoadFixAddressBootTimeCodePageNumber
);
288 DxeCodeSize
= EFI_PAGES_TO_SIZE(DxeCodePageNumber
);
289 DxeCodeBase
= gLoadModuleAtFixAddressConfigurationTable
.DxeCodeTopAddress
- DxeCodeSize
;
292 // If the memory usage bit map is not initialized, do it. Every bit in the array
293 // indicate the status of the corresponding memory page, available or not
295 if (mDxeCodeMemoryRangeUsageBitMap
== NULL
) {
296 mDxeCodeMemoryRangeUsageBitMap
= AllocateZeroPool(((DxeCodePageNumber
/64) + 1)*sizeof(UINT64
));
299 // If the Dxe code memory range is not allocated or the bit map array allocation failed, return EFI_NOT_FOUND
301 if (!gLoadFixedAddressCodeMemoryReady
|| mDxeCodeMemoryRangeUsageBitMap
== NULL
) {
302 return EFI_NOT_FOUND
;
305 // Test the memory range for loading the image in the DXE code range.
307 if (gLoadModuleAtFixAddressConfigurationTable
.DxeCodeTopAddress
< ImageBase
+ ImageSize
||
308 DxeCodeBase
> ImageBase
) {
309 return EFI_NOT_FOUND
;
312 // Test if the memory is avalaible or not.
314 BaseOffsetPageNumber
= (UINTN
)EFI_SIZE_TO_PAGES((UINT32
)(ImageBase
- DxeCodeBase
));
315 TopOffsetPageNumber
= (UINTN
)EFI_SIZE_TO_PAGES((UINT32
)(ImageBase
+ ImageSize
- DxeCodeBase
));
316 for (Index
= BaseOffsetPageNumber
; Index
< TopOffsetPageNumber
; Index
++) {
317 if ((mDxeCodeMemoryRangeUsageBitMap
[Index
/ 64] & LShiftU64(1, (Index
% 64))) != 0) {
319 // This page is already used.
321 return EFI_NOT_FOUND
;
326 // Being here means the memory range is available. So mark the bits for the memory range
328 for (Index
= BaseOffsetPageNumber
; Index
< TopOffsetPageNumber
; Index
++) {
329 mDxeCodeMemoryRangeUsageBitMap
[Index
/ 64] |= LShiftU64(1, (Index
% 64));
335 Get the fixed loadding address from image header assigned by build tool. This function only be called
336 when Loading module at Fixed address feature enabled.
338 @param ImageContext Pointer to the image context structure that describes the PE/COFF
339 image that needs to be examined by this function.
340 @retval EFI_SUCCESS An fixed loading address is assigned to this image by build tools .
341 @retval EFI_NOT_FOUND The image has no assigned fixed loadding address.
345 GetPeCoffImageFixLoadingAssignedAddress(
346 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT
*ImageContext
349 UINTN SectionHeaderOffset
;
351 EFI_IMAGE_SECTION_HEADER SectionHeader
;
352 EFI_IMAGE_OPTIONAL_HEADER_UNION
*ImgHdr
;
355 UINT16 NumberOfSections
;
356 IMAGE_FILE_HANDLE
*Handle
;
357 UINT64 ValueInSectionHeader
;
360 Status
= EFI_NOT_FOUND
;
363 // Get PeHeader pointer
365 Handle
= (IMAGE_FILE_HANDLE
*)ImageContext
->Handle
;
366 ImgHdr
= (EFI_IMAGE_OPTIONAL_HEADER_UNION
*)((CHAR8
* )Handle
->Source
+ ImageContext
->PeCoffHeaderOffset
);
367 SectionHeaderOffset
= (UINTN
)(
368 ImageContext
->PeCoffHeaderOffset
+
370 sizeof (EFI_IMAGE_FILE_HEADER
) +
371 ImgHdr
->Pe32
.FileHeader
.SizeOfOptionalHeader
373 NumberOfSections
= ImgHdr
->Pe32
.FileHeader
.NumberOfSections
;
376 // Get base address from the first section header that doesn't point to code section.
378 for (Index
= 0; Index
< NumberOfSections
; Index
++) {
380 // Read section header from file
382 Size
= sizeof (EFI_IMAGE_SECTION_HEADER
);
383 Status
= ImageContext
->ImageRead (
384 ImageContext
->Handle
,
389 if (EFI_ERROR (Status
)) {
392 if (Size
!= sizeof (EFI_IMAGE_SECTION_HEADER
)) {
393 return EFI_NOT_FOUND
;
396 Status
= EFI_NOT_FOUND
;
398 if ((SectionHeader
.Characteristics
& EFI_IMAGE_SCN_CNT_CODE
) == 0) {
400 // Build tool will save the address in PointerToRelocations & PointerToLineNumbers fields in the first section header
401 // that doesn't point to code section in image header, as well as ImageBase field of image header. And there is an
402 // assumption that when the feature is enabled, if a module is assigned a loading address by tools, PointerToRelocations
403 // & PointerToLineNumbers fields should NOT be Zero, or else, these 2 fileds should be set to Zero
405 ValueInSectionHeader
= ReadUnaligned64((UINT64
*)&SectionHeader
.PointerToRelocations
);
406 if (ValueInSectionHeader
!= 0) {
408 // When the feature is configured as load module at fixed absolute address, the ImageAddress field of ImageContext
409 // hold the spcified address. If the feature is configured as load module at fixed offset, ImageAddress hold an offset
410 // relative to top address
412 if ((INT64
)PcdGet64(PcdLoadModuleAtFixAddressEnable
) < 0) {
413 ImageContext
->ImageAddress
= gLoadModuleAtFixAddressConfigurationTable
.DxeCodeTopAddress
+ (INT64
)(INTN
)ImageContext
->ImageAddress
;
416 // Check if the memory range is avaliable.
418 Status
= CheckAndMarkFixLoadingMemoryUsageBitMap (ImageContext
->ImageAddress
, (UINTN
)(ImageContext
->ImageSize
+ ImageContext
->SectionAlignment
));
422 SectionHeaderOffset
+= sizeof (EFI_IMAGE_SECTION_HEADER
);
424 DEBUG ((EFI_D_INFO
|EFI_D_LOAD
, "LOADING MODULE FIXED INFO: Loading module at fixed address 0x%11p. Status = %r \n", (VOID
*)(UINTN
)(ImageContext
->ImageAddress
), Status
));
428 Loads, relocates, and invokes a PE/COFF image
430 @param BootPolicy If TRUE, indicates that the request originates
431 from the boot manager, and that the boot
432 manager is attempting to load FilePath as a
434 @param Pe32Handle The handle of PE32 image
435 @param Image PE image to be loaded
436 @param DstBuffer The buffer to store the image
437 @param EntryPoint A pointer to the entry point
438 @param Attribute The bit mask of attributes to set for the load
441 @retval EFI_SUCCESS The file was loaded, relocated, and invoked
442 @retval EFI_OUT_OF_RESOURCES There was not enough memory to load and
443 relocate the PE/COFF file
444 @retval EFI_INVALID_PARAMETER Invalid parameter
445 @retval EFI_BUFFER_TOO_SMALL Buffer for image is too small
450 IN BOOLEAN BootPolicy
,
452 IN LOADED_IMAGE_PRIVATE_DATA
*Image
,
453 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL
,
454 OUT EFI_PHYSICAL_ADDRESS
*EntryPoint OPTIONAL
,
459 BOOLEAN DstBufAlocated
;
462 ZeroMem (&Image
->ImageContext
, sizeof (Image
->ImageContext
));
464 Image
->ImageContext
.Handle
= Pe32Handle
;
465 Image
->ImageContext
.ImageRead
= (PE_COFF_LOADER_READ_FILE
)CoreReadImageFile
;
468 // Get information about the image being loaded
470 Status
= PeCoffLoaderGetImageInfo (&Image
->ImageContext
);
471 if (EFI_ERROR (Status
)) {
475 if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Image
->ImageContext
.Machine
)) {
476 if (!EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED (Image
->ImageContext
.Machine
)) {
478 // The PE/COFF loader can support loading image types that can be executed.
479 // If we loaded an image type that we can not execute return EFI_UNSUPORTED.
481 DEBUG ((EFI_D_ERROR
, "Image type %s can't be loaded ", GetMachineTypeName(Image
->ImageContext
.Machine
)));
482 DEBUG ((EFI_D_ERROR
, "on %s UEFI system.\n", GetMachineTypeName(mDxeCoreImageMachineType
)));
483 return EFI_UNSUPPORTED
;
488 // Set EFI memory type based on ImageType
490 switch (Image
->ImageContext
.ImageType
) {
491 case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION
:
492 Image
->ImageContext
.ImageCodeMemoryType
= EfiLoaderCode
;
493 Image
->ImageContext
.ImageDataMemoryType
= EfiLoaderData
;
495 case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER
:
496 Image
->ImageContext
.ImageCodeMemoryType
= EfiBootServicesCode
;
497 Image
->ImageContext
.ImageDataMemoryType
= EfiBootServicesData
;
499 case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
:
500 case EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER
:
501 Image
->ImageContext
.ImageCodeMemoryType
= EfiRuntimeServicesCode
;
502 Image
->ImageContext
.ImageDataMemoryType
= EfiRuntimeServicesData
;
505 Image
->ImageContext
.ImageError
= IMAGE_ERROR_INVALID_SUBSYSTEM
;
506 return EFI_UNSUPPORTED
;
510 // Allocate memory of the correct memory type aligned on the required image boundry
512 DstBufAlocated
= FALSE
;
513 if (DstBuffer
== 0) {
515 // Allocate Destination Buffer as caller did not pass it in
518 if (Image
->ImageContext
.SectionAlignment
> EFI_PAGE_SIZE
) {
519 Size
= (UINTN
)Image
->ImageContext
.ImageSize
+ Image
->ImageContext
.SectionAlignment
;
521 Size
= (UINTN
)Image
->ImageContext
.ImageSize
;
524 Image
->NumberOfPages
= EFI_SIZE_TO_PAGES (Size
);
527 // If the image relocations have not been stripped, then load at any address.
528 // Otherwise load at the address at which it was linked.
530 // Memory below 1MB should be treated reserved for CSM and there should be
531 // no modules whose preferred load addresses are below 1MB.
533 Status
= EFI_OUT_OF_RESOURCES
;
535 // If Loading Module At Fixed Address feature is enabled, the module should be loaded to
536 // a specified address.
538 if (PcdGet64(PcdLoadModuleAtFixAddressEnable
) != 0 ) {
539 Status
= GetPeCoffImageFixLoadingAssignedAddress (&(Image
->ImageContext
));
541 if (EFI_ERROR (Status
)) {
543 // If the code memory is not ready, invoke CoreAllocatePage with AllocateAnyPages to load the driver.
545 DEBUG ((EFI_D_INFO
|EFI_D_LOAD
, "LOADING MODULE FIXED ERROR: Loading module at fixed address failed since specified memory is not available.\n"));
547 Status
= CoreAllocatePages (
549 (EFI_MEMORY_TYPE
) (Image
->ImageContext
.ImageCodeMemoryType
),
550 Image
->NumberOfPages
,
551 &Image
->ImageContext
.ImageAddress
555 if (Image
->ImageContext
.ImageAddress
>= 0x100000 || Image
->ImageContext
.RelocationsStripped
) {
556 Status
= CoreAllocatePages (
558 (EFI_MEMORY_TYPE
) (Image
->ImageContext
.ImageCodeMemoryType
),
559 Image
->NumberOfPages
,
560 &Image
->ImageContext
.ImageAddress
563 if (EFI_ERROR (Status
) && !Image
->ImageContext
.RelocationsStripped
) {
564 Status
= CoreAllocatePages (
566 (EFI_MEMORY_TYPE
) (Image
->ImageContext
.ImageCodeMemoryType
),
567 Image
->NumberOfPages
,
568 &Image
->ImageContext
.ImageAddress
572 if (EFI_ERROR (Status
)) {
575 DstBufAlocated
= TRUE
;
578 // Caller provided the destination buffer
581 if (Image
->ImageContext
.RelocationsStripped
&& (Image
->ImageContext
.ImageAddress
!= DstBuffer
)) {
583 // If the image relocations were stripped, and the caller provided a
584 // destination buffer address that does not match the address that the
585 // image is linked at, then the image cannot be loaded.
587 return EFI_INVALID_PARAMETER
;
590 if (Image
->NumberOfPages
!= 0 &&
591 Image
->NumberOfPages
<
592 (EFI_SIZE_TO_PAGES ((UINTN
)Image
->ImageContext
.ImageSize
+ Image
->ImageContext
.SectionAlignment
))) {
593 Image
->NumberOfPages
= EFI_SIZE_TO_PAGES ((UINTN
)Image
->ImageContext
.ImageSize
+ Image
->ImageContext
.SectionAlignment
);
594 return EFI_BUFFER_TOO_SMALL
;
597 Image
->NumberOfPages
= EFI_SIZE_TO_PAGES ((UINTN
)Image
->ImageContext
.ImageSize
+ Image
->ImageContext
.SectionAlignment
);
598 Image
->ImageContext
.ImageAddress
= DstBuffer
;
601 Image
->ImageBasePage
= Image
->ImageContext
.ImageAddress
;
602 if (!Image
->ImageContext
.IsTeImage
) {
603 Image
->ImageContext
.ImageAddress
=
604 (Image
->ImageContext
.ImageAddress
+ Image
->ImageContext
.SectionAlignment
- 1) &
605 ~((UINTN
)Image
->ImageContext
.SectionAlignment
- 1);
609 // Load the image from the file into the allocated memory
611 Status
= PeCoffLoaderLoadImage (&Image
->ImageContext
);
612 if (EFI_ERROR (Status
)) {
617 // If this is a Runtime Driver, then allocate memory for the FixupData that
618 // is used to relocate the image when SetVirtualAddressMap() is called. The
619 // relocation is done by the Runtime AP.
621 if ((Attribute
& EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION
) != 0) {
622 if (Image
->ImageContext
.ImageType
== EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
) {
623 Image
->ImageContext
.FixupData
= AllocateRuntimePool ((UINTN
)(Image
->ImageContext
.FixupDataSize
));
624 if (Image
->ImageContext
.FixupData
== NULL
) {
625 Status
= EFI_OUT_OF_RESOURCES
;
632 // Relocate the image in memory
634 Status
= PeCoffLoaderRelocateImage (&Image
->ImageContext
);
635 if (EFI_ERROR (Status
)) {
640 // Flush the Instruction Cache
642 InvalidateInstructionCacheRange ((VOID
*)(UINTN
)Image
->ImageContext
.ImageAddress
, (UINTN
)Image
->ImageContext
.ImageSize
);
645 // Copy the machine type from the context to the image private data. This
646 // is needed during image unload to know if we should call an EBC protocol
647 // to unload the image.
649 Image
->Machine
= Image
->ImageContext
.Machine
;
652 // Get the image entry point. If it's an EBC image, then call into the
653 // interpreter to create a thunk for the entry point and use the returned
654 // value for the entry point.
656 Image
->EntryPoint
= (EFI_IMAGE_ENTRY_POINT
)(UINTN
)Image
->ImageContext
.EntryPoint
;
657 if (Image
->ImageContext
.Machine
== EFI_IMAGE_MACHINE_EBC
) {
659 // Locate the EBC interpreter protocol
661 Status
= CoreLocateProtocol (&gEfiEbcProtocolGuid
, NULL
, (VOID
**)&Image
->Ebc
);
662 if (EFI_ERROR(Status
) || Image
->Ebc
== NULL
) {
663 DEBUG ((DEBUG_LOAD
| DEBUG_ERROR
, "CoreLoadPeImage: There is no EBC interpreter for an EBC image.\n"));
668 // Register a callback for flushing the instruction cache so that created
669 // thunks can be flushed.
671 Status
= Image
->Ebc
->RegisterICacheFlush (Image
->Ebc
, (EBC_ICACHE_FLUSH
)InvalidateInstructionCacheRange
);
672 if (EFI_ERROR(Status
)) {
677 // Create a thunk for the image's entry point. This will be the new
678 // entry point for the image.
680 Status
= Image
->Ebc
->CreateThunk (
683 (VOID
*)(UINTN
) Image
->ImageContext
.EntryPoint
,
684 (VOID
**) &Image
->EntryPoint
686 if (EFI_ERROR(Status
)) {
692 // Fill in the image information for the Loaded Image Protocol
694 Image
->Type
= Image
->ImageContext
.ImageType
;
695 Image
->Info
.ImageBase
= (VOID
*)(UINTN
)Image
->ImageContext
.ImageAddress
;
696 Image
->Info
.ImageSize
= Image
->ImageContext
.ImageSize
;
697 Image
->Info
.ImageCodeType
= (EFI_MEMORY_TYPE
) (Image
->ImageContext
.ImageCodeMemoryType
);
698 Image
->Info
.ImageDataType
= (EFI_MEMORY_TYPE
) (Image
->ImageContext
.ImageDataMemoryType
);
699 if ((Attribute
& EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION
) != 0) {
700 if (Image
->ImageContext
.ImageType
== EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER
) {
702 // Make a list off all the RT images so we can let the RT AP know about them.
704 Image
->RuntimeData
= AllocateRuntimePool (sizeof(EFI_RUNTIME_IMAGE_ENTRY
));
705 if (Image
->RuntimeData
== NULL
) {
708 Image
->RuntimeData
->ImageBase
= Image
->Info
.ImageBase
;
709 Image
->RuntimeData
->ImageSize
= (UINT64
) (Image
->Info
.ImageSize
);
710 Image
->RuntimeData
->RelocationData
= Image
->ImageContext
.FixupData
;
711 Image
->RuntimeData
->Handle
= Image
->Handle
;
712 InsertTailList (&gRuntime
->ImageHead
, &Image
->RuntimeData
->Link
);
713 InsertImageRecord (Image
->RuntimeData
);
718 // Fill in the entry point of the image if it is available
720 if (EntryPoint
!= NULL
) {
721 *EntryPoint
= Image
->ImageContext
.EntryPoint
;
725 // Print the load address and the PDB file name if it is available
732 CHAR8 EfiFileName
[256];
735 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
,
736 "Loading driver at 0x%11p EntryPoint=0x%11p ",
737 (VOID
*)(UINTN
) Image
->ImageContext
.ImageAddress
,
738 FUNCTION_ENTRY_POINT (Image
->ImageContext
.EntryPoint
)));
742 // Print Module Name by Pdb file path.
743 // Windows and Unix style file path are all trimmed correctly.
745 if (Image
->ImageContext
.PdbPointer
!= NULL
) {
747 for (Index
= 0; Image
->ImageContext
.PdbPointer
[Index
] != 0; Index
++) {
748 if ((Image
->ImageContext
.PdbPointer
[Index
] == '\\') || (Image
->ImageContext
.PdbPointer
[Index
] == '/')) {
749 StartIndex
= Index
+ 1;
753 // Copy the PDB file name to our temporary string, and replace .pdb with .efi
754 // The PDB file name is limited in the range of 0~255.
755 // If the length is bigger than 255, trim the redudant characters to avoid overflow in array boundary.
757 for (Index
= 0; Index
< sizeof (EfiFileName
) - 4; Index
++) {
758 EfiFileName
[Index
] = Image
->ImageContext
.PdbPointer
[Index
+ StartIndex
];
759 if (EfiFileName
[Index
] == 0) {
760 EfiFileName
[Index
] = '.';
762 if (EfiFileName
[Index
] == '.') {
763 EfiFileName
[Index
+ 1] = 'e';
764 EfiFileName
[Index
+ 2] = 'f';
765 EfiFileName
[Index
+ 3] = 'i';
766 EfiFileName
[Index
+ 4] = 0;
771 if (Index
== sizeof (EfiFileName
) - 4) {
772 EfiFileName
[Index
] = 0;
774 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "%a", EfiFileName
)); // &Image->ImageContext.PdbPointer[StartIndex]));
776 DEBUG ((DEBUG_INFO
| DEBUG_LOAD
, "\n"));
788 if (DstBufAlocated
) {
789 CoreFreePages (Image
->ImageContext
.ImageAddress
, Image
->NumberOfPages
);
792 if (Image
->ImageContext
.FixupData
!= NULL
) {
793 CoreFreePool (Image
->ImageContext
.FixupData
);
802 Get the image's private data from its handle.
804 @param ImageHandle The image handle
806 @return Return the image private data associated with ImageHandle.
809 LOADED_IMAGE_PRIVATE_DATA
*
810 CoreLoadedImageInfo (
811 IN EFI_HANDLE ImageHandle
815 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
816 LOADED_IMAGE_PRIVATE_DATA
*Image
;
818 Status
= CoreHandleProtocol (
820 &gEfiLoadedImageProtocolGuid
,
821 (VOID
**)&LoadedImage
823 if (!EFI_ERROR (Status
)) {
824 Image
= LOADED_IMAGE_PRIVATE_DATA_FROM_THIS (LoadedImage
);
826 DEBUG ((DEBUG_LOAD
, "CoreLoadedImageInfo: Not an ImageHandle %p\n", ImageHandle
));
835 Unloads EFI image from memory.
837 @param Image EFI image
838 @param FreePage Free allocated pages
842 CoreUnloadAndCloseImage (
843 IN LOADED_IMAGE_PRIVATE_DATA
*Image
,
849 EFI_HANDLE
*HandleBuffer
;
851 EFI_GUID
**ProtocolGuidArray
;
854 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY
*OpenInfo
;
859 ProtocolGuidArray
= NULL
;
861 if (Image
->Ebc
!= NULL
) {
863 // If EBC protocol exists we must perform cleanups for this image.
865 Image
->Ebc
->UnloadImage (Image
->Ebc
, Image
->Handle
);
869 // Unload image, free Image->ImageContext->ModHandle
871 PeCoffLoaderUnloadImage (&Image
->ImageContext
);
874 // Free our references to the image handle
876 if (Image
->Handle
!= NULL
) {
878 Status
= CoreLocateHandleBuffer (
885 if (!EFI_ERROR (Status
)) {
886 for (HandleIndex
= 0; HandleIndex
< HandleCount
; HandleIndex
++) {
887 Status
= CoreProtocolsPerHandle (
888 HandleBuffer
[HandleIndex
],
892 if (!EFI_ERROR (Status
)) {
893 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
894 Status
= CoreOpenProtocolInformation (
895 HandleBuffer
[HandleIndex
],
896 ProtocolGuidArray
[ProtocolIndex
],
900 if (!EFI_ERROR (Status
)) {
901 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
902 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== Image
->Handle
) {
903 Status
= CoreCloseProtocol (
904 HandleBuffer
[HandleIndex
],
905 ProtocolGuidArray
[ProtocolIndex
],
907 OpenInfo
[OpenInfoIndex
].ControllerHandle
911 if (OpenInfo
!= NULL
) {
912 CoreFreePool(OpenInfo
);
916 if (ProtocolGuidArray
!= NULL
) {
917 CoreFreePool(ProtocolGuidArray
);
921 if (HandleBuffer
!= NULL
) {
922 CoreFreePool (HandleBuffer
);
926 CoreRemoveDebugImageInfoEntry (Image
->Handle
);
928 Status
= CoreUninstallProtocolInterface (
930 &gEfiLoadedImageDevicePathProtocolGuid
,
931 Image
->LoadedImageDevicePath
934 Status
= CoreUninstallProtocolInterface (
936 &gEfiLoadedImageProtocolGuid
,
940 if (Image
->ImageContext
.HiiResourceData
!= 0) {
941 Status
= CoreUninstallProtocolInterface (
943 &gEfiHiiPackageListProtocolGuid
,
944 (VOID
*) (UINTN
) Image
->ImageContext
.HiiResourceData
950 if (Image
->RuntimeData
!= NULL
) {
951 if (Image
->RuntimeData
->Link
.ForwardLink
!= NULL
) {
953 // Remove the Image from the Runtime Image list as we are about to Free it!
955 RemoveEntryList (&Image
->RuntimeData
->Link
);
956 RemoveImageRecord (Image
->RuntimeData
);
958 CoreFreePool (Image
->RuntimeData
);
962 // Free the Image from memory
964 if ((Image
->ImageBasePage
!= 0) && FreePage
) {
965 CoreFreePages (Image
->ImageBasePage
, Image
->NumberOfPages
);
969 // Done with the Image structure
971 if (Image
->Info
.FilePath
!= NULL
) {
972 CoreFreePool (Image
->Info
.FilePath
);
975 if (Image
->LoadedImageDevicePath
!= NULL
) {
976 CoreFreePool (Image
->LoadedImageDevicePath
);
979 if (Image
->FixupData
!= NULL
) {
980 CoreFreePool (Image
->FixupData
);
983 CoreFreePool (Image
);
988 Loads an EFI image into memory and returns a handle to the image.
990 @param BootPolicy If TRUE, indicates that the request originates
991 from the boot manager, and that the boot
992 manager is attempting to load FilePath as a
994 @param ParentImageHandle The caller's image handle.
995 @param FilePath The specific file path from which the image is
997 @param SourceBuffer If not NULL, a pointer to the memory location
998 containing a copy of the image to be loaded.
999 @param SourceSize The size in bytes of SourceBuffer.
1000 @param DstBuffer The buffer to store the image
1001 @param NumberOfPages If not NULL, it inputs a pointer to the page
1002 number of DstBuffer and outputs a pointer to
1003 the page number of the image. If this number is
1004 not enough, return EFI_BUFFER_TOO_SMALL and
1005 this parameter contains the required number.
1006 @param ImageHandle Pointer to the returned image handle that is
1007 created when the image is successfully loaded.
1008 @param EntryPoint A pointer to the entry point
1009 @param Attribute The bit mask of attributes to set for the load
1012 @retval EFI_SUCCESS The image was loaded into memory.
1013 @retval EFI_NOT_FOUND The FilePath was not found.
1014 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1015 @retval EFI_BUFFER_TOO_SMALL The buffer is too small
1016 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1017 path cannot be parsed to locate the proper
1018 protocol for loading the file.
1019 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1021 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1023 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1024 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1025 image from being loaded. NULL is returned in *ImageHandle.
1026 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1027 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1028 platform policy specifies that the image should not be started.
1032 CoreLoadImageCommon (
1033 IN BOOLEAN BootPolicy
,
1034 IN EFI_HANDLE ParentImageHandle
,
1035 IN EFI_DEVICE_PATH_PROTOCOL
*FilePath
,
1036 IN VOID
*SourceBuffer OPTIONAL
,
1037 IN UINTN SourceSize
,
1038 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL
,
1039 IN OUT UINTN
*NumberOfPages OPTIONAL
,
1040 OUT EFI_HANDLE
*ImageHandle
,
1041 OUT EFI_PHYSICAL_ADDRESS
*EntryPoint OPTIONAL
,
1045 LOADED_IMAGE_PRIVATE_DATA
*Image
;
1046 LOADED_IMAGE_PRIVATE_DATA
*ParentImage
;
1047 IMAGE_FILE_HANDLE FHand
;
1049 EFI_STATUS SecurityStatus
;
1050 EFI_HANDLE DeviceHandle
;
1051 UINT32 AuthenticationStatus
;
1052 EFI_DEVICE_PATH_PROTOCOL
*OriginalFilePath
;
1053 EFI_DEVICE_PATH_PROTOCOL
*HandleFilePath
;
1055 BOOLEAN ImageIsFromFv
;
1057 SecurityStatus
= EFI_SUCCESS
;
1059 ASSERT (gEfiCurrentTpl
< TPL_NOTIFY
);
1063 // The caller must pass in a valid ParentImageHandle
1065 if (ImageHandle
== NULL
|| ParentImageHandle
== NULL
) {
1066 return EFI_INVALID_PARAMETER
;
1069 ParentImage
= CoreLoadedImageInfo (ParentImageHandle
);
1070 if (ParentImage
== NULL
) {
1071 DEBUG((DEBUG_LOAD
|DEBUG_ERROR
, "LoadImageEx: Parent handle not an image handle\n"));
1072 return EFI_INVALID_PARAMETER
;
1075 ZeroMem (&FHand
, sizeof (IMAGE_FILE_HANDLE
));
1076 FHand
.Signature
= IMAGE_FILE_HANDLE_SIGNATURE
;
1077 OriginalFilePath
= FilePath
;
1078 HandleFilePath
= FilePath
;
1079 DeviceHandle
= NULL
;
1080 Status
= EFI_SUCCESS
;
1081 AuthenticationStatus
= 0;
1082 ImageIsFromFv
= FALSE
;
1085 // If the caller passed a copy of the file, then just use it
1087 if (SourceBuffer
!= NULL
) {
1088 FHand
.Source
= SourceBuffer
;
1089 FHand
.SourceSize
= SourceSize
;
1090 Status
= CoreLocateDevicePath (&gEfiDevicePathProtocolGuid
, &HandleFilePath
, &DeviceHandle
);
1091 if (EFI_ERROR (Status
)) {
1092 DeviceHandle
= NULL
;
1094 if (SourceSize
> 0) {
1095 Status
= EFI_SUCCESS
;
1097 Status
= EFI_LOAD_ERROR
;
1100 if (FilePath
== NULL
) {
1101 return EFI_INVALID_PARAMETER
;
1104 // Get the source file buffer by its device path.
1106 FHand
.Source
= GetFileBufferByFilePath (
1110 &AuthenticationStatus
1112 if (FHand
.Source
== NULL
) {
1113 Status
= EFI_NOT_FOUND
;
1116 // Try to get the image device handle by checking the match protocol.
1118 FHand
.FreeBuffer
= TRUE
;
1119 Status
= CoreLocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid
, &HandleFilePath
, &DeviceHandle
);
1120 if (!EFI_ERROR (Status
)) {
1121 ImageIsFromFv
= TRUE
;
1123 HandleFilePath
= FilePath
;
1124 Status
= CoreLocateDevicePath (&gEfiSimpleFileSystemProtocolGuid
, &HandleFilePath
, &DeviceHandle
);
1125 if (EFI_ERROR (Status
)) {
1127 HandleFilePath
= FilePath
;
1128 Status
= CoreLocateDevicePath (&gEfiLoadFile2ProtocolGuid
, &HandleFilePath
, &DeviceHandle
);
1130 if (EFI_ERROR (Status
)) {
1131 HandleFilePath
= FilePath
;
1132 Status
= CoreLocateDevicePath (&gEfiLoadFileProtocolGuid
, &HandleFilePath
, &DeviceHandle
);
1139 if (EFI_ERROR (Status
)) {
1144 if (gSecurity2
!= NULL
) {
1146 // Verify File Authentication through the Security2 Architectural Protocol
1148 SecurityStatus
= gSecurity2
->FileAuthentication (
1155 if (!EFI_ERROR (SecurityStatus
) && ImageIsFromFv
) {
1157 // When Security2 is installed, Security Architectural Protocol must be published.
1159 ASSERT (gSecurity
!= NULL
);
1162 // Verify the Authentication Status through the Security Architectural Protocol
1163 // Only on images that have been read using Firmware Volume protocol.
1165 SecurityStatus
= gSecurity
->FileAuthenticationState (
1167 AuthenticationStatus
,
1171 } else if ((gSecurity
!= NULL
) && (OriginalFilePath
!= NULL
)) {
1173 // Verify the Authentication Status through the Security Architectural Protocol
1175 SecurityStatus
= gSecurity
->FileAuthenticationState (
1177 AuthenticationStatus
,
1183 // Check Security Status.
1185 if (EFI_ERROR (SecurityStatus
) && SecurityStatus
!= EFI_SECURITY_VIOLATION
) {
1186 if (SecurityStatus
== EFI_ACCESS_DENIED
) {
1188 // Image was not loaded because the platform policy prohibits the image from being loaded.
1189 // It's the only place we could meet EFI_ACCESS_DENIED.
1191 *ImageHandle
= NULL
;
1193 Status
= SecurityStatus
;
1199 // Allocate a new image structure
1201 Image
= AllocateZeroPool (sizeof(LOADED_IMAGE_PRIVATE_DATA
));
1202 if (Image
== NULL
) {
1203 Status
= EFI_OUT_OF_RESOURCES
;
1208 // Pull out just the file portion of the DevicePath for the LoadedImage FilePath
1210 FilePath
= OriginalFilePath
;
1211 if (DeviceHandle
!= NULL
) {
1212 Status
= CoreHandleProtocol (DeviceHandle
, &gEfiDevicePathProtocolGuid
, (VOID
**)&HandleFilePath
);
1213 if (!EFI_ERROR (Status
)) {
1214 FilePathSize
= GetDevicePathSize (HandleFilePath
) - sizeof(EFI_DEVICE_PATH_PROTOCOL
);
1215 FilePath
= (EFI_DEVICE_PATH_PROTOCOL
*) (((UINT8
*)FilePath
) + FilePathSize
);
1219 // Initialize the fields for an internal driver
1221 Image
->Signature
= LOADED_IMAGE_PRIVATE_DATA_SIGNATURE
;
1222 Image
->Info
.SystemTable
= gDxeCoreST
;
1223 Image
->Info
.DeviceHandle
= DeviceHandle
;
1224 Image
->Info
.Revision
= EFI_LOADED_IMAGE_PROTOCOL_REVISION
;
1225 Image
->Info
.FilePath
= DuplicateDevicePath (FilePath
);
1226 Image
->Info
.ParentHandle
= ParentImageHandle
;
1229 if (NumberOfPages
!= NULL
) {
1230 Image
->NumberOfPages
= *NumberOfPages
;
1232 Image
->NumberOfPages
= 0 ;
1236 // Install the protocol interfaces for this image
1237 // don't fire notifications yet
1239 Status
= CoreInstallProtocolInterfaceNotify (
1241 &gEfiLoadedImageProtocolGuid
,
1242 EFI_NATIVE_INTERFACE
,
1246 if (EFI_ERROR (Status
)) {
1251 // Load the image. If EntryPoint is Null, it will not be set.
1253 Status
= CoreLoadPeImage (BootPolicy
, &FHand
, Image
, DstBuffer
, EntryPoint
, Attribute
);
1254 if (EFI_ERROR (Status
)) {
1255 if ((Status
== EFI_BUFFER_TOO_SMALL
) || (Status
== EFI_OUT_OF_RESOURCES
)) {
1256 if (NumberOfPages
!= NULL
) {
1257 *NumberOfPages
= Image
->NumberOfPages
;
1263 if (NumberOfPages
!= NULL
) {
1264 *NumberOfPages
= Image
->NumberOfPages
;
1268 // Register the image in the Debug Image Info Table if the attribute is set
1270 if ((Attribute
& EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION
) != 0) {
1271 CoreNewDebugImageInfoEntry (EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL
, &Image
->Info
, Image
->Handle
);
1275 //Reinstall loaded image protocol to fire any notifications
1277 Status
= CoreReinstallProtocolInterface (
1279 &gEfiLoadedImageProtocolGuid
,
1283 if (EFI_ERROR (Status
)) {
1288 // If DevicePath parameter to the LoadImage() is not NULL, then make a copy of DevicePath,
1289 // otherwise Loaded Image Device Path Protocol is installed with a NULL interface pointer.
1291 if (OriginalFilePath
!= NULL
) {
1292 Image
->LoadedImageDevicePath
= DuplicateDevicePath (OriginalFilePath
);
1296 // Install Loaded Image Device Path Protocol onto the image handle of a PE/COFE image
1298 Status
= CoreInstallProtocolInterface (
1300 &gEfiLoadedImageDevicePathProtocolGuid
,
1301 EFI_NATIVE_INTERFACE
,
1302 Image
->LoadedImageDevicePath
1304 if (EFI_ERROR (Status
)) {
1309 // Install HII Package List Protocol onto the image handle
1311 if (Image
->ImageContext
.HiiResourceData
!= 0) {
1312 Status
= CoreInstallProtocolInterface (
1314 &gEfiHiiPackageListProtocolGuid
,
1315 EFI_NATIVE_INTERFACE
,
1316 (VOID
*) (UINTN
) Image
->ImageContext
.HiiResourceData
1318 if (EFI_ERROR (Status
)) {
1324 // Success. Return the image handle
1326 *ImageHandle
= Image
->Handle
;
1330 // All done accessing the source file
1331 // If we allocated the Source buffer, free it
1333 if (FHand
.FreeBuffer
) {
1334 CoreFreePool (FHand
.Source
);
1338 // There was an error. If there's an Image structure, free it
1340 if (EFI_ERROR (Status
)) {
1341 if (Image
!= NULL
) {
1342 CoreUnloadAndCloseImage (Image
, (BOOLEAN
)(DstBuffer
== 0));
1345 } else if (EFI_ERROR (SecurityStatus
)) {
1346 Status
= SecurityStatus
;
1350 // Track the return status from LoadImage.
1352 if (Image
!= NULL
) {
1353 Image
->LoadImageStatus
= Status
;
1363 Loads an EFI image into memory and returns a handle to the image.
1365 @param BootPolicy If TRUE, indicates that the request originates
1366 from the boot manager, and that the boot
1367 manager is attempting to load FilePath as a
1369 @param ParentImageHandle The caller's image handle.
1370 @param FilePath The specific file path from which the image is
1372 @param SourceBuffer If not NULL, a pointer to the memory location
1373 containing a copy of the image to be loaded.
1374 @param SourceSize The size in bytes of SourceBuffer.
1375 @param ImageHandle Pointer to the returned image handle that is
1376 created when the image is successfully loaded.
1378 @retval EFI_SUCCESS The image was loaded into memory.
1379 @retval EFI_NOT_FOUND The FilePath was not found.
1380 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1381 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1382 path cannot be parsed to locate the proper
1383 protocol for loading the file.
1384 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1386 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1388 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1389 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1390 image from being loaded. NULL is returned in *ImageHandle.
1391 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1392 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1393 platform policy specifies that the image should not be started.
1399 IN BOOLEAN BootPolicy
,
1400 IN EFI_HANDLE ParentImageHandle
,
1401 IN EFI_DEVICE_PATH_PROTOCOL
*FilePath
,
1402 IN VOID
*SourceBuffer OPTIONAL
,
1403 IN UINTN SourceSize
,
1404 OUT EFI_HANDLE
*ImageHandle
1413 Tick
= GetPerformanceCounter ();
1416 Status
= CoreLoadImageCommon (
1422 (EFI_PHYSICAL_ADDRESS
) (UINTN
) NULL
,
1426 EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION
| EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION
1430 if (!EFI_ERROR (Status
)) {
1432 // ImageHandle will be valid only Status is success.
1434 Handle
= *ImageHandle
;
1437 PERF_START (Handle
, "LoadImage:", NULL
, Tick
);
1438 PERF_END (Handle
, "LoadImage:", NULL
, 0);
1446 Loads an EFI image into memory and returns a handle to the image with extended parameters.
1448 @param This Calling context
1449 @param ParentImageHandle The caller's image handle.
1450 @param FilePath The specific file path from which the image is
1452 @param SourceBuffer If not NULL, a pointer to the memory location
1453 containing a copy of the image to be loaded.
1454 @param SourceSize The size in bytes of SourceBuffer.
1455 @param DstBuffer The buffer to store the image.
1456 @param NumberOfPages For input, specifies the space size of the
1457 image by caller if not NULL. For output,
1458 specifies the actual space size needed.
1459 @param ImageHandle Image handle for output.
1460 @param EntryPoint Image entry point for output.
1461 @param Attribute The bit mask of attributes to set for the load
1464 @retval EFI_SUCCESS The image was loaded into memory.
1465 @retval EFI_NOT_FOUND The FilePath was not found.
1466 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1467 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1468 path cannot be parsed to locate the proper
1469 protocol for loading the file.
1470 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1472 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1474 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1475 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1476 image from being loaded. NULL is returned in *ImageHandle.
1477 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1478 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1479 platform policy specifies that the image should not be started.
1485 IN EFI_PE32_IMAGE_PROTOCOL
*This
,
1486 IN EFI_HANDLE ParentImageHandle
,
1487 IN EFI_DEVICE_PATH_PROTOCOL
*FilePath
,
1488 IN VOID
*SourceBuffer OPTIONAL
,
1489 IN UINTN SourceSize
,
1490 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL
,
1491 OUT UINTN
*NumberOfPages OPTIONAL
,
1492 OUT EFI_HANDLE
*ImageHandle
,
1493 OUT EFI_PHYSICAL_ADDRESS
*EntryPoint OPTIONAL
,
1503 Tick
= GetPerformanceCounter ();
1506 Status
= CoreLoadImageCommon (
1520 if (!EFI_ERROR (Status
)) {
1522 // ImageHandle will be valid only Status is success.
1524 Handle
= *ImageHandle
;
1527 PERF_START (Handle
, "LoadImage:", NULL
, Tick
);
1528 PERF_END (Handle
, "LoadImage:", NULL
, 0);
1535 Transfer control to a loaded image's entry point.
1537 @param ImageHandle Handle of image to be started.
1538 @param ExitDataSize Pointer of the size to ExitData
1539 @param ExitData Pointer to a pointer to a data buffer that
1540 includes a Null-terminated string,
1541 optionally followed by additional binary data.
1542 The string is a description that the caller may
1543 use to further indicate the reason for the
1546 @retval EFI_INVALID_PARAMETER Invalid parameter
1547 @retval EFI_OUT_OF_RESOURCES No enough buffer to allocate
1548 @retval EFI_SECURITY_VIOLATION The current platform policy specifies that the image should not be started.
1549 @retval EFI_SUCCESS Successfully transfer control to the image's
1556 IN EFI_HANDLE ImageHandle
,
1557 OUT UINTN
*ExitDataSize
,
1558 OUT CHAR16
**ExitData OPTIONAL
1562 LOADED_IMAGE_PRIVATE_DATA
*Image
;
1563 LOADED_IMAGE_PRIVATE_DATA
*LastImage
;
1564 UINT64 HandleDatabaseKey
;
1570 Handle
= ImageHandle
;
1572 Image
= CoreLoadedImageInfo (ImageHandle
);
1573 if (Image
== NULL
|| Image
->Started
) {
1574 return EFI_INVALID_PARAMETER
;
1576 if (EFI_ERROR (Image
->LoadImageStatus
)) {
1577 return Image
->LoadImageStatus
;
1581 // The image to be started must have the machine type supported by DxeCore.
1583 if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Image
->Machine
)) {
1585 // Do not ASSERT here, because image might be loaded via EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED
1586 // But it can not be started.
1588 DEBUG ((EFI_D_ERROR
, "Image type %s can't be started ", GetMachineTypeName(Image
->Machine
)));
1589 DEBUG ((EFI_D_ERROR
, "on %s UEFI system.\n", GetMachineTypeName(mDxeCoreImageMachineType
)));
1590 return EFI_UNSUPPORTED
;
1594 Tick
= GetPerformanceCounter ();
1599 // Push the current start image context, and
1600 // link the current image to the head. This is the
1601 // only image that can call Exit()
1603 HandleDatabaseKey
= CoreGetHandleDatabaseKey ();
1604 LastImage
= mCurrentImage
;
1605 mCurrentImage
= Image
;
1606 Image
->Tpl
= gEfiCurrentTpl
;
1609 // Set long jump for Exit() support
1610 // JumpContext must be aligned on a CPU specific boundary.
1611 // Overallocate the buffer and force the required alignment
1613 Image
->JumpBuffer
= AllocatePool (sizeof (BASE_LIBRARY_JUMP_BUFFER
) + BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT
);
1614 if (Image
->JumpBuffer
== NULL
) {
1616 // Image may be unloaded after return with failure,
1617 // then ImageHandle may be invalid, so use NULL handle to record perf log.
1619 PERF_START (NULL
, "StartImage:", NULL
, Tick
);
1620 PERF_END (NULL
, "StartImage:", NULL
, 0);
1621 return EFI_OUT_OF_RESOURCES
;
1623 Image
->JumpContext
= ALIGN_POINTER (Image
->JumpBuffer
, BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT
);
1625 SetJumpFlag
= SetJump (Image
->JumpContext
);
1627 // The initial call to SetJump() must always return 0.
1628 // Subsequent calls to LongJump() cause a non-zero value to be returned by SetJump().
1630 if (SetJumpFlag
== 0) {
1631 RegisterMemoryProfileImage (Image
, (Image
->ImageContext
.ImageType
== EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION
? EFI_FV_FILETYPE_APPLICATION
: EFI_FV_FILETYPE_DRIVER
));
1633 // Call the image's entry point
1635 Image
->Started
= TRUE
;
1636 Image
->Status
= Image
->EntryPoint (ImageHandle
, Image
->Info
.SystemTable
);
1639 // Add some debug information if the image returned with error.
1640 // This make the user aware and check if the driver image have already released
1641 // all the resource in this situation.
1643 DEBUG_CODE_BEGIN ();
1644 if (EFI_ERROR (Image
->Status
)) {
1645 DEBUG ((DEBUG_ERROR
, "Error: Image at %11p start failed: %r\n", Image
->Info
.ImageBase
, Image
->Status
));
1650 // If the image returns, exit it through Exit()
1652 CoreExit (ImageHandle
, Image
->Status
, 0, NULL
);
1656 // Image has completed. Verify the tpl is the same
1658 ASSERT (Image
->Tpl
== gEfiCurrentTpl
);
1659 CoreRestoreTpl (Image
->Tpl
);
1661 CoreFreePool (Image
->JumpBuffer
);
1664 // Pop the current start image context
1666 mCurrentImage
= LastImage
;
1669 // Go connect any handles that were created or modified while the image executed.
1671 CoreConnectHandlesByKey (HandleDatabaseKey
);
1674 // Handle the image's returned ExitData
1676 DEBUG_CODE_BEGIN ();
1677 if (Image
->ExitDataSize
!= 0 || Image
->ExitData
!= NULL
) {
1679 DEBUG ((DEBUG_LOAD
, "StartImage: ExitDataSize %d, ExitData %p", (UINT32
)Image
->ExitDataSize
, Image
->ExitData
));
1680 if (Image
->ExitData
!= NULL
) {
1681 DEBUG ((DEBUG_LOAD
, " (%hs)", Image
->ExitData
));
1683 DEBUG ((DEBUG_LOAD
, "\n"));
1688 // Return the exit data to the caller
1690 if (ExitData
!= NULL
&& ExitDataSize
!= NULL
) {
1691 *ExitDataSize
= Image
->ExitDataSize
;
1692 *ExitData
= Image
->ExitData
;
1695 // Caller doesn't want the exit data, free it
1697 CoreFreePool (Image
->ExitData
);
1698 Image
->ExitData
= NULL
;
1702 // Save the Status because Image will get destroyed if it is unloaded.
1704 Status
= Image
->Status
;
1707 // If the image returned an error, or if the image is an application
1710 if (EFI_ERROR (Image
->Status
) || Image
->Type
== EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION
) {
1711 CoreUnloadAndCloseImage (Image
, TRUE
);
1713 // ImageHandle may be invalid after the image is unloaded, so use NULL handle to record perf log.
1721 PERF_START (Handle
, "StartImage:", NULL
, Tick
);
1722 PERF_END (Handle
, "StartImage:", NULL
, 0);
1727 Terminates the currently loaded EFI image and returns control to boot services.
1729 @param ImageHandle Handle that identifies the image. This
1730 parameter is passed to the image on entry.
1731 @param Status The image's exit code.
1732 @param ExitDataSize The size, in bytes, of ExitData. Ignored if
1733 ExitStatus is EFI_SUCCESS.
1734 @param ExitData Pointer to a data buffer that includes a
1735 Null-terminated Unicode string, optionally
1736 followed by additional binary data. The string
1737 is a description that the caller may use to
1738 further indicate the reason for the image's
1741 @retval EFI_INVALID_PARAMETER Image handle is NULL or it is not current
1743 @retval EFI_SUCCESS Successfully terminates the currently loaded
1745 @retval EFI_ACCESS_DENIED Should never reach there.
1746 @retval EFI_OUT_OF_RESOURCES Could not allocate pool
1752 IN EFI_HANDLE ImageHandle
,
1753 IN EFI_STATUS Status
,
1754 IN UINTN ExitDataSize
,
1755 IN CHAR16
*ExitData OPTIONAL
1758 LOADED_IMAGE_PRIVATE_DATA
*Image
;
1762 // Prevent possible reentrance to this function
1763 // for the same ImageHandle
1765 OldTpl
= CoreRaiseTpl (TPL_NOTIFY
);
1767 Image
= CoreLoadedImageInfo (ImageHandle
);
1768 if (Image
== NULL
) {
1769 Status
= EFI_INVALID_PARAMETER
;
1773 if (!Image
->Started
) {
1775 // The image has not been started so just free its resources
1777 CoreUnloadAndCloseImage (Image
, TRUE
);
1778 Status
= EFI_SUCCESS
;
1783 // Image has been started, verify this image can exit
1785 if (Image
!= mCurrentImage
) {
1786 DEBUG ((DEBUG_LOAD
|DEBUG_ERROR
, "Exit: Image is not exitable image\n"));
1787 Status
= EFI_INVALID_PARAMETER
;
1794 Image
->Status
= Status
;
1797 // If there's ExitData info, move it
1799 if (ExitData
!= NULL
) {
1800 Image
->ExitDataSize
= ExitDataSize
;
1801 Image
->ExitData
= AllocatePool (Image
->ExitDataSize
);
1802 if (Image
->ExitData
== NULL
) {
1803 Status
= EFI_OUT_OF_RESOURCES
;
1806 CopyMem (Image
->ExitData
, ExitData
, Image
->ExitDataSize
);
1809 CoreRestoreTpl (OldTpl
);
1811 // return to StartImage
1813 LongJump (Image
->JumpContext
, (UINTN
)-1);
1816 // If we return from LongJump, then it is an error
1819 Status
= EFI_ACCESS_DENIED
;
1821 CoreRestoreTpl (OldTpl
);
1831 @param ImageHandle Handle that identifies the image to be
1834 @retval EFI_SUCCESS The image has been unloaded.
1835 @retval EFI_UNSUPPORTED The image has been sarted, and does not support
1837 @retval EFI_INVALID_PARAMPETER ImageHandle is not a valid image handle.
1843 IN EFI_HANDLE ImageHandle
1847 LOADED_IMAGE_PRIVATE_DATA
*Image
;
1849 Image
= CoreLoadedImageInfo (ImageHandle
);
1850 if (Image
== NULL
) {
1852 // The image handle is not valid
1854 Status
= EFI_INVALID_PARAMETER
;
1857 UnregisterMemoryProfileImage (Image
);
1859 if (Image
->Started
) {
1861 // The image has been started, request it to unload.
1863 Status
= EFI_UNSUPPORTED
;
1864 if (Image
->Info
.Unload
!= NULL
) {
1865 Status
= Image
->Info
.Unload (ImageHandle
);
1870 // This Image hasn't been started, thus it can be unloaded
1872 Status
= EFI_SUCCESS
;
1876 if (!EFI_ERROR (Status
)) {
1878 // if the Image was not started or Unloaded O.K. then clean up
1880 CoreUnloadAndCloseImage (Image
, TRUE
);
1890 Unload the specified image.
1892 @param This Indicates the calling context.
1893 @param ImageHandle The specified image handle.
1895 @retval EFI_INVALID_PARAMETER Image handle is NULL.
1896 @retval EFI_UNSUPPORTED Attempt to unload an unsupported image.
1897 @retval EFI_SUCCESS Image successfully unloaded.
1903 IN EFI_PE32_IMAGE_PROTOCOL
*This
,
1904 IN EFI_HANDLE ImageHandle
1907 return CoreUnloadImage (ImageHandle
);