]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Core/Dxe/Image/Image.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdeModulePkg DxeCore: Call UnregisterMemoryProfileImage correctly.
[mirror_edk2.git] / MdeModulePkg / Core / Dxe / Image / Image.c
1 /** @file
2 Core image handling services to load and unload PeImage.
3
4 Copyright (c) 2006 - 2015, 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
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 **/
14
15 #include "DxeMain.h"
16 #include "Image.h"
17
18 //
19 // Module Globals
20 //
21 LOADED_IMAGE_PRIVATE_DATA *mCurrentImage = NULL;
22
23 LOAD_PE32_IMAGE_PRIVATE_DATA mLoadPe32PrivateData = {
24 LOAD_PE32_IMAGE_PRIVATE_DATA_SIGNATURE,
25 NULL,
26 {
27 CoreLoadImageEx,
28 CoreUnloadImageEx
29 }
30 };
31
32
33 //
34 // This code is needed to build the Image handle for the DXE Core
35 //
36 LOADED_IMAGE_PRIVATE_DATA mCorePrivateImage = {
37 LOADED_IMAGE_PRIVATE_DATA_SIGNATURE, // Signature
38 NULL, // Image handle
39 EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER, // Image type
40 TRUE, // If entrypoint has been called
41 NULL, // EntryPoint
42 {
43 EFI_LOADED_IMAGE_INFORMATION_REVISION, // Revision
44 NULL, // Parent handle
45 NULL, // System handle
46
47 NULL, // Device handle
48 NULL, // File path
49 NULL, // Reserved
50
51 0, // LoadOptionsSize
52 NULL, // LoadOptions
53
54 NULL, // ImageBase
55 0, // ImageSize
56 EfiBootServicesCode, // ImageCodeType
57 EfiBootServicesData // ImageDataType
58 },
59 (EFI_PHYSICAL_ADDRESS)0, // ImageBasePage
60 0, // NumberOfPages
61 NULL, // FixupData
62 0, // Tpl
63 EFI_SUCCESS, // Status
64 0, // ExitDataSize
65 NULL, // ExitData
66 NULL, // JumpBuffer
67 NULL, // JumpContext
68 0, // Machine
69 NULL, // Ebc
70 NULL, // RuntimeData
71 NULL // LoadedImageDevicePath
72 };
73 //
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
76 // available or not.
77 //
78 GLOBAL_REMOVE_IF_UNREFERENCED UINT64 *mDxeCodeMemoryRangeUsageBitMap=NULL;
79
80 typedef struct {
81 UINT16 MachineType;
82 CHAR16 *MachineTypeName;
83 } MACHINE_TYPE_INFO;
84
85 //
86 // EBC machine is not listed in this table, because EBC is in the default supported scopes of other machine type.
87 //
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"}
93 };
94
95 UINT16 mDxeCoreImageMachineType = 0;
96
97 /**
98 Return machine type name.
99
100 @param MachineType The machine type
101
102 @return machine type name
103 **/
104 CHAR16 *
105 GetMachineTypeName (
106 UINT16 MachineType
107 )
108 {
109 UINTN Index;
110
111 for (Index = 0; Index < sizeof(mMachineTypeInfo)/sizeof(mMachineTypeInfo[0]); Index++) {
112 if (mMachineTypeInfo[Index].MachineType == MachineType) {
113 return mMachineTypeInfo[Index].MachineTypeName;
114 }
115 }
116
117 return L"<Unknown>";
118 }
119
120 /**
121 Add the Image Services to EFI Boot Services Table and install the protocol
122 interfaces for this image.
123
124 @param HobStart The HOB to initialize
125
126 @return Status code.
127
128 **/
129 EFI_STATUS
130 CoreInitializeImageServices (
131 IN VOID *HobStart
132 )
133 {
134 EFI_STATUS Status;
135 LOADED_IMAGE_PRIVATE_DATA *Image;
136 EFI_PHYSICAL_ADDRESS DxeCoreImageBaseAddress;
137 UINT64 DxeCoreImageLength;
138 VOID *DxeCoreEntryPoint;
139 EFI_PEI_HOB_POINTERS DxeCoreHob;
140
141 //
142 // Searching for image hob
143 //
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)) {
147 //
148 // Find Dxe Core HOB
149 //
150 break;
151 }
152 DxeCoreHob.Raw = GET_NEXT_HOB (DxeCoreHob);
153 }
154 ASSERT (DxeCoreHob.Raw != NULL);
155
156 DxeCoreImageBaseAddress = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryBaseAddress;
157 DxeCoreImageLength = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryLength;
158 DxeCoreEntryPoint = (VOID *) (UINTN) DxeCoreHob.MemoryAllocationModule->EntryPoint;
159 gDxeCoreFileName = &DxeCoreHob.MemoryAllocationModule->ModuleName;
160
161 //
162 // Initialize the fields for an internal driver
163 //
164 Image = &mCorePrivateImage;
165
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;
173
174 //
175 // Install the protocol interfaces for this image
176 //
177 Status = CoreInstallProtocolInterface (
178 &Image->Handle,
179 &gEfiLoadedImageProtocolGuid,
180 EFI_NATIVE_INTERFACE,
181 &Image->Info
182 );
183 ASSERT_EFI_ERROR (Status);
184
185 mCurrentImage = Image;
186
187 //
188 // Fill in DXE globals
189 //
190 mDxeCoreImageMachineType = PeCoffLoaderGetMachineType (Image->Info.ImageBase);
191 gDxeCoreImageHandle = Image->Handle;
192 gDxeCoreLoadedImage = &Image->Info;
193
194 if (FeaturePcdGet (PcdFrameworkCompatibilitySupport)) {
195 //
196 // Export DXE Core PE Loader functionality for backward compatibility.
197 //
198 Status = CoreInstallProtocolInterface (
199 &mLoadPe32PrivateData.Handle,
200 &gEfiLoadPeImageProtocolGuid,
201 EFI_NATIVE_INTERFACE,
202 &mLoadPe32PrivateData.Pe32Image
203 );
204 }
205
206 return Status;
207 }
208
209 /**
210 Read image file (specified by UserHandle) into user specified buffer with specified offset
211 and length.
212
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
218
219 @retval EFI_SUCCESS Successfully read the specified part of file
220 into buffer.
221
222 **/
223 EFI_STATUS
224 EFIAPI
225 CoreReadImageFile (
226 IN VOID *UserHandle,
227 IN UINTN Offset,
228 IN OUT UINTN *ReadSize,
229 OUT VOID *Buffer
230 )
231 {
232 UINTN EndPosition;
233 IMAGE_FILE_HANDLE *FHand;
234
235 if (UserHandle == NULL || ReadSize == NULL || Buffer == NULL) {
236 return EFI_INVALID_PARAMETER;
237 }
238
239 if (MAX_ADDRESS - Offset < *ReadSize) {
240 return EFI_INVALID_PARAMETER;
241 }
242
243 FHand = (IMAGE_FILE_HANDLE *)UserHandle;
244 ASSERT (FHand->Signature == IMAGE_FILE_HANDLE_SIGNATURE);
245
246 //
247 // Move data from our local copy of the file
248 //
249 EndPosition = Offset + *ReadSize;
250 if (EndPosition > FHand->SourceSize) {
251 *ReadSize = (UINT32)(FHand->SourceSize - Offset);
252 }
253 if (Offset >= FHand->SourceSize) {
254 *ReadSize = 0;
255 }
256
257 CopyMem (Buffer, (CHAR8 *)FHand->Source + Offset, *ReadSize);
258 return EFI_SUCCESS;
259 }
260 /**
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.
264
265 @param ImageBase The base addres the image will be loaded at.
266 @param ImageSize The size of the image
267
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
270 **/
271 EFI_STATUS
272 CheckAndMarkFixLoadingMemoryUsageBitMap (
273 IN EFI_PHYSICAL_ADDRESS ImageBase,
274 IN UINTN ImageSize
275 )
276 {
277 UINT32 DxeCodePageNumber;
278 UINT64 DxeCodeSize;
279 EFI_PHYSICAL_ADDRESS DxeCodeBase;
280 UINTN BaseOffsetPageNumber;
281 UINTN TopOffsetPageNumber;
282 UINTN Index;
283 //
284 // The DXE code range includes RuntimeCodePage range and Boot time code range.
285 //
286 DxeCodePageNumber = PcdGet32(PcdLoadFixAddressRuntimeCodePageNumber);
287 DxeCodePageNumber += PcdGet32(PcdLoadFixAddressBootTimeCodePageNumber);
288 DxeCodeSize = EFI_PAGES_TO_SIZE(DxeCodePageNumber);
289 DxeCodeBase = gLoadModuleAtFixAddressConfigurationTable.DxeCodeTopAddress - DxeCodeSize;
290
291 //
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
294 //
295 if (mDxeCodeMemoryRangeUsageBitMap == NULL) {
296 mDxeCodeMemoryRangeUsageBitMap = AllocateZeroPool(((DxeCodePageNumber/64) + 1)*sizeof(UINT64));
297 }
298 //
299 // If the Dxe code memory range is not allocated or the bit map array allocation failed, return EFI_NOT_FOUND
300 //
301 if (!gLoadFixedAddressCodeMemoryReady || mDxeCodeMemoryRangeUsageBitMap == NULL) {
302 return EFI_NOT_FOUND;
303 }
304 //
305 // Test the memory range for loading the image in the DXE code range.
306 //
307 if (gLoadModuleAtFixAddressConfigurationTable.DxeCodeTopAddress < ImageBase + ImageSize ||
308 DxeCodeBase > ImageBase) {
309 return EFI_NOT_FOUND;
310 }
311 //
312 // Test if the memory is avalaible or not.
313 //
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) {
318 //
319 // This page is already used.
320 //
321 return EFI_NOT_FOUND;
322 }
323 }
324
325 //
326 // Being here means the memory range is available. So mark the bits for the memory range
327 //
328 for (Index = BaseOffsetPageNumber; Index < TopOffsetPageNumber; Index ++) {
329 mDxeCodeMemoryRangeUsageBitMap[Index / 64] |= LShiftU64(1, (Index % 64));
330 }
331 return EFI_SUCCESS;
332 }
333 /**
334
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.
337
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.
342
343 **/
344 EFI_STATUS
345 GetPeCoffImageFixLoadingAssignedAddress(
346 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
347 )
348 {
349 UINTN SectionHeaderOffset;
350 EFI_STATUS Status;
351 EFI_IMAGE_SECTION_HEADER SectionHeader;
352 EFI_IMAGE_OPTIONAL_HEADER_UNION *ImgHdr;
353 UINT16 Index;
354 UINTN Size;
355 UINT16 NumberOfSections;
356 IMAGE_FILE_HANDLE *Handle;
357 UINT64 ValueInSectionHeader;
358
359
360 Status = EFI_NOT_FOUND;
361
362 //
363 // Get PeHeader pointer
364 //
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 +
369 sizeof (UINT32) +
370 sizeof (EFI_IMAGE_FILE_HEADER) +
371 ImgHdr->Pe32.FileHeader.SizeOfOptionalHeader
372 );
373 NumberOfSections = ImgHdr->Pe32.FileHeader.NumberOfSections;
374
375 //
376 // Get base address from the first section header that doesn't point to code section.
377 //
378 for (Index = 0; Index < NumberOfSections; Index++) {
379 //
380 // Read section header from file
381 //
382 Size = sizeof (EFI_IMAGE_SECTION_HEADER);
383 Status = ImageContext->ImageRead (
384 ImageContext->Handle,
385 SectionHeaderOffset,
386 &Size,
387 &SectionHeader
388 );
389 if (EFI_ERROR (Status)) {
390 return Status;
391 }
392 if (Size != sizeof (EFI_IMAGE_SECTION_HEADER)) {
393 return EFI_NOT_FOUND;
394 }
395
396 Status = EFI_NOT_FOUND;
397
398 if ((SectionHeader.Characteristics & EFI_IMAGE_SCN_CNT_CODE) == 0) {
399 //
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
404 //
405 ValueInSectionHeader = ReadUnaligned64((UINT64*)&SectionHeader.PointerToRelocations);
406 if (ValueInSectionHeader != 0) {
407 //
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
411 //
412 if ((INT64)PcdGet64(PcdLoadModuleAtFixAddressEnable) < 0) {
413 ImageContext->ImageAddress = gLoadModuleAtFixAddressConfigurationTable.DxeCodeTopAddress + (INT64)(INTN)ImageContext->ImageAddress;
414 }
415 //
416 // Check if the memory range is avaliable.
417 //
418 Status = CheckAndMarkFixLoadingMemoryUsageBitMap (ImageContext->ImageAddress, (UINTN)(ImageContext->ImageSize + ImageContext->SectionAlignment));
419 }
420 break;
421 }
422 SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);
423 }
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));
425 return Status;
426 }
427 /**
428 Loads, relocates, and invokes a PE/COFF image
429
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
433 boot selection.
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
439 PE image
440
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
446
447 **/
448 EFI_STATUS
449 CoreLoadPeImage (
450 IN BOOLEAN BootPolicy,
451 IN VOID *Pe32Handle,
452 IN LOADED_IMAGE_PRIVATE_DATA *Image,
453 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
454 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
455 IN UINT32 Attribute
456 )
457 {
458 EFI_STATUS Status;
459 BOOLEAN DstBufAlocated;
460 UINTN Size;
461
462 ZeroMem (&Image->ImageContext, sizeof (Image->ImageContext));
463
464 Image->ImageContext.Handle = Pe32Handle;
465 Image->ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE)CoreReadImageFile;
466
467 //
468 // Get information about the image being loaded
469 //
470 Status = PeCoffLoaderGetImageInfo (&Image->ImageContext);
471 if (EFI_ERROR (Status)) {
472 return Status;
473 }
474
475 if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Image->ImageContext.Machine)) {
476 if (!EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED (Image->ImageContext.Machine)) {
477 //
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.
480 //
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;
484 }
485 }
486
487 //
488 // Set EFI memory type based on ImageType
489 //
490 switch (Image->ImageContext.ImageType) {
491 case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION:
492 Image->ImageContext.ImageCodeMemoryType = EfiLoaderCode;
493 Image->ImageContext.ImageDataMemoryType = EfiLoaderData;
494 break;
495 case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
496 Image->ImageContext.ImageCodeMemoryType = EfiBootServicesCode;
497 Image->ImageContext.ImageDataMemoryType = EfiBootServicesData;
498 break;
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;
503 break;
504 default:
505 Image->ImageContext.ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM;
506 return EFI_UNSUPPORTED;
507 }
508
509 //
510 // Allocate memory of the correct memory type aligned on the required image boundry
511 //
512 DstBufAlocated = FALSE;
513 if (DstBuffer == 0) {
514 //
515 // Allocate Destination Buffer as caller did not pass it in
516 //
517
518 if (Image->ImageContext.SectionAlignment > EFI_PAGE_SIZE) {
519 Size = (UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment;
520 } else {
521 Size = (UINTN)Image->ImageContext.ImageSize;
522 }
523
524 Image->NumberOfPages = EFI_SIZE_TO_PAGES (Size);
525
526 //
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.
529 //
530 // Memory below 1MB should be treated reserved for CSM and there should be
531 // no modules whose preferred load addresses are below 1MB.
532 //
533 Status = EFI_OUT_OF_RESOURCES;
534 //
535 // If Loading Module At Fixed Address feature is enabled, the module should be loaded to
536 // a specified address.
537 //
538 if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0 ) {
539 Status = GetPeCoffImageFixLoadingAssignedAddress (&(Image->ImageContext));
540
541 if (EFI_ERROR (Status)) {
542 //
543 // If the code memory is not ready, invoke CoreAllocatePage with AllocateAnyPages to load the driver.
544 //
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"));
546
547 Status = CoreAllocatePages (
548 AllocateAnyPages,
549 (EFI_MEMORY_TYPE) (Image->ImageContext.ImageCodeMemoryType),
550 Image->NumberOfPages,
551 &Image->ImageContext.ImageAddress
552 );
553 }
554 } else {
555 if (Image->ImageContext.ImageAddress >= 0x100000 || Image->ImageContext.RelocationsStripped) {
556 Status = CoreAllocatePages (
557 AllocateAddress,
558 (EFI_MEMORY_TYPE) (Image->ImageContext.ImageCodeMemoryType),
559 Image->NumberOfPages,
560 &Image->ImageContext.ImageAddress
561 );
562 }
563 if (EFI_ERROR (Status) && !Image->ImageContext.RelocationsStripped) {
564 Status = CoreAllocatePages (
565 AllocateAnyPages,
566 (EFI_MEMORY_TYPE) (Image->ImageContext.ImageCodeMemoryType),
567 Image->NumberOfPages,
568 &Image->ImageContext.ImageAddress
569 );
570 }
571 }
572 if (EFI_ERROR (Status)) {
573 return Status;
574 }
575 DstBufAlocated = TRUE;
576 } else {
577 //
578 // Caller provided the destination buffer
579 //
580
581 if (Image->ImageContext.RelocationsStripped && (Image->ImageContext.ImageAddress != DstBuffer)) {
582 //
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.
586 //
587 return EFI_INVALID_PARAMETER;
588 }
589
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;
595 }
596
597 Image->NumberOfPages = EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment);
598 Image->ImageContext.ImageAddress = DstBuffer;
599 }
600
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);
606 }
607
608 //
609 // Load the image from the file into the allocated memory
610 //
611 Status = PeCoffLoaderLoadImage (&Image->ImageContext);
612 if (EFI_ERROR (Status)) {
613 goto Done;
614 }
615
616 //
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.
620 //
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;
626 goto Done;
627 }
628 }
629 }
630
631 //
632 // Relocate the image in memory
633 //
634 Status = PeCoffLoaderRelocateImage (&Image->ImageContext);
635 if (EFI_ERROR (Status)) {
636 goto Done;
637 }
638
639 //
640 // Flush the Instruction Cache
641 //
642 InvalidateInstructionCacheRange ((VOID *)(UINTN)Image->ImageContext.ImageAddress, (UINTN)Image->ImageContext.ImageSize);
643
644 //
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.
648 //
649 Image->Machine = Image->ImageContext.Machine;
650
651 //
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.
655 //
656 Image->EntryPoint = (EFI_IMAGE_ENTRY_POINT)(UINTN)Image->ImageContext.EntryPoint;
657 if (Image->ImageContext.Machine == EFI_IMAGE_MACHINE_EBC) {
658 //
659 // Locate the EBC interpreter protocol
660 //
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"));
664 goto Done;
665 }
666
667 //
668 // Register a callback for flushing the instruction cache so that created
669 // thunks can be flushed.
670 //
671 Status = Image->Ebc->RegisterICacheFlush (Image->Ebc, (EBC_ICACHE_FLUSH)InvalidateInstructionCacheRange);
672 if (EFI_ERROR(Status)) {
673 goto Done;
674 }
675
676 //
677 // Create a thunk for the image's entry point. This will be the new
678 // entry point for the image.
679 //
680 Status = Image->Ebc->CreateThunk (
681 Image->Ebc,
682 Image->Handle,
683 (VOID *)(UINTN) Image->ImageContext.EntryPoint,
684 (VOID **) &Image->EntryPoint
685 );
686 if (EFI_ERROR(Status)) {
687 goto Done;
688 }
689 }
690
691 //
692 // Fill in the image information for the Loaded Image Protocol
693 //
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) {
701 //
702 // Make a list off all the RT images so we can let the RT AP know about them.
703 //
704 Image->RuntimeData = AllocateRuntimePool (sizeof(EFI_RUNTIME_IMAGE_ENTRY));
705 if (Image->RuntimeData == NULL) {
706 goto Done;
707 }
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);
714 }
715 }
716
717 //
718 // Fill in the entry point of the image if it is available
719 //
720 if (EntryPoint != NULL) {
721 *EntryPoint = Image->ImageContext.EntryPoint;
722 }
723
724 //
725 // Print the load address and the PDB file name if it is available
726 //
727
728 DEBUG_CODE_BEGIN ();
729
730 UINTN Index;
731 UINTN StartIndex;
732 CHAR8 EfiFileName[256];
733
734
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)));
739
740
741 //
742 // Print Module Name by Pdb file path.
743 // Windows and Unix style file path are all trimmed correctly.
744 //
745 if (Image->ImageContext.PdbPointer != NULL) {
746 StartIndex = 0;
747 for (Index = 0; Image->ImageContext.PdbPointer[Index] != 0; Index++) {
748 if ((Image->ImageContext.PdbPointer[Index] == '\\') || (Image->ImageContext.PdbPointer[Index] == '/')) {
749 StartIndex = Index + 1;
750 }
751 }
752 //
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.
756 //
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] = '.';
761 }
762 if (EfiFileName[Index] == '.') {
763 EfiFileName[Index + 1] = 'e';
764 EfiFileName[Index + 2] = 'f';
765 EfiFileName[Index + 3] = 'i';
766 EfiFileName[Index + 4] = 0;
767 break;
768 }
769 }
770
771 if (Index == sizeof (EfiFileName) - 4) {
772 EfiFileName[Index] = 0;
773 }
774 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "%a", EfiFileName)); // &Image->ImageContext.PdbPointer[StartIndex]));
775 }
776 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "\n"));
777
778 DEBUG_CODE_END ();
779
780 return EFI_SUCCESS;
781
782 Done:
783
784 //
785 // Free memory.
786 //
787
788 if (DstBufAlocated) {
789 CoreFreePages (Image->ImageContext.ImageAddress, Image->NumberOfPages);
790 }
791
792 if (Image->ImageContext.FixupData != NULL) {
793 CoreFreePool (Image->ImageContext.FixupData);
794 }
795
796 return Status;
797 }
798
799
800
801 /**
802 Get the image's private data from its handle.
803
804 @param ImageHandle The image handle
805
806 @return Return the image private data associated with ImageHandle.
807
808 **/
809 LOADED_IMAGE_PRIVATE_DATA *
810 CoreLoadedImageInfo (
811 IN EFI_HANDLE ImageHandle
812 )
813 {
814 EFI_STATUS Status;
815 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
816 LOADED_IMAGE_PRIVATE_DATA *Image;
817
818 Status = CoreHandleProtocol (
819 ImageHandle,
820 &gEfiLoadedImageProtocolGuid,
821 (VOID **)&LoadedImage
822 );
823 if (!EFI_ERROR (Status)) {
824 Image = LOADED_IMAGE_PRIVATE_DATA_FROM_THIS (LoadedImage);
825 } else {
826 DEBUG ((DEBUG_LOAD, "CoreLoadedImageInfo: Not an ImageHandle %p\n", ImageHandle));
827 Image = NULL;
828 }
829
830 return Image;
831 }
832
833
834 /**
835 Unloads EFI image from memory.
836
837 @param Image EFI image
838 @param FreePage Free allocated pages
839
840 **/
841 VOID
842 CoreUnloadAndCloseImage (
843 IN LOADED_IMAGE_PRIVATE_DATA *Image,
844 IN BOOLEAN FreePage
845 )
846 {
847 EFI_STATUS Status;
848 UINTN HandleCount;
849 EFI_HANDLE *HandleBuffer;
850 UINTN HandleIndex;
851 EFI_GUID **ProtocolGuidArray;
852 UINTN ArrayCount;
853 UINTN ProtocolIndex;
854 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
855 UINTN OpenInfoCount;
856 UINTN OpenInfoIndex;
857
858 HandleBuffer = NULL;
859 ProtocolGuidArray = NULL;
860
861 if (Image->Started) {
862 UnregisterMemoryProfileImage (Image);
863 }
864
865 if (Image->Ebc != NULL) {
866 //
867 // If EBC protocol exists we must perform cleanups for this image.
868 //
869 Image->Ebc->UnloadImage (Image->Ebc, Image->Handle);
870 }
871
872 //
873 // Unload image, free Image->ImageContext->ModHandle
874 //
875 PeCoffLoaderUnloadImage (&Image->ImageContext);
876
877 //
878 // Free our references to the image handle
879 //
880 if (Image->Handle != NULL) {
881
882 Status = CoreLocateHandleBuffer (
883 AllHandles,
884 NULL,
885 NULL,
886 &HandleCount,
887 &HandleBuffer
888 );
889 if (!EFI_ERROR (Status)) {
890 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
891 Status = CoreProtocolsPerHandle (
892 HandleBuffer[HandleIndex],
893 &ProtocolGuidArray,
894 &ArrayCount
895 );
896 if (!EFI_ERROR (Status)) {
897 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
898 Status = CoreOpenProtocolInformation (
899 HandleBuffer[HandleIndex],
900 ProtocolGuidArray[ProtocolIndex],
901 &OpenInfo,
902 &OpenInfoCount
903 );
904 if (!EFI_ERROR (Status)) {
905 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
906 if (OpenInfo[OpenInfoIndex].AgentHandle == Image->Handle) {
907 Status = CoreCloseProtocol (
908 HandleBuffer[HandleIndex],
909 ProtocolGuidArray[ProtocolIndex],
910 Image->Handle,
911 OpenInfo[OpenInfoIndex].ControllerHandle
912 );
913 }
914 }
915 if (OpenInfo != NULL) {
916 CoreFreePool(OpenInfo);
917 }
918 }
919 }
920 if (ProtocolGuidArray != NULL) {
921 CoreFreePool(ProtocolGuidArray);
922 }
923 }
924 }
925 if (HandleBuffer != NULL) {
926 CoreFreePool (HandleBuffer);
927 }
928 }
929
930 CoreRemoveDebugImageInfoEntry (Image->Handle);
931
932 Status = CoreUninstallProtocolInterface (
933 Image->Handle,
934 &gEfiLoadedImageDevicePathProtocolGuid,
935 Image->LoadedImageDevicePath
936 );
937
938 Status = CoreUninstallProtocolInterface (
939 Image->Handle,
940 &gEfiLoadedImageProtocolGuid,
941 &Image->Info
942 );
943
944 if (Image->ImageContext.HiiResourceData != 0) {
945 Status = CoreUninstallProtocolInterface (
946 Image->Handle,
947 &gEfiHiiPackageListProtocolGuid,
948 (VOID *) (UINTN) Image->ImageContext.HiiResourceData
949 );
950 }
951
952 }
953
954 if (Image->RuntimeData != NULL) {
955 if (Image->RuntimeData->Link.ForwardLink != NULL) {
956 //
957 // Remove the Image from the Runtime Image list as we are about to Free it!
958 //
959 RemoveEntryList (&Image->RuntimeData->Link);
960 RemoveImageRecord (Image->RuntimeData);
961 }
962 CoreFreePool (Image->RuntimeData);
963 }
964
965 //
966 // Free the Image from memory
967 //
968 if ((Image->ImageBasePage != 0) && FreePage) {
969 CoreFreePages (Image->ImageBasePage, Image->NumberOfPages);
970 }
971
972 //
973 // Done with the Image structure
974 //
975 if (Image->Info.FilePath != NULL) {
976 CoreFreePool (Image->Info.FilePath);
977 }
978
979 if (Image->LoadedImageDevicePath != NULL) {
980 CoreFreePool (Image->LoadedImageDevicePath);
981 }
982
983 if (Image->FixupData != NULL) {
984 CoreFreePool (Image->FixupData);
985 }
986
987 CoreFreePool (Image);
988 }
989
990
991 /**
992 Loads an EFI image into memory and returns a handle to the image.
993
994 @param BootPolicy If TRUE, indicates that the request originates
995 from the boot manager, and that the boot
996 manager is attempting to load FilePath as a
997 boot selection.
998 @param ParentImageHandle The caller's image handle.
999 @param FilePath The specific file path from which the image is
1000 loaded.
1001 @param SourceBuffer If not NULL, a pointer to the memory location
1002 containing a copy of the image to be loaded.
1003 @param SourceSize The size in bytes of SourceBuffer.
1004 @param DstBuffer The buffer to store the image
1005 @param NumberOfPages If not NULL, it inputs a pointer to the page
1006 number of DstBuffer and outputs a pointer to
1007 the page number of the image. If this number is
1008 not enough, return EFI_BUFFER_TOO_SMALL and
1009 this parameter contains the required number.
1010 @param ImageHandle Pointer to the returned image handle that is
1011 created when the image is successfully loaded.
1012 @param EntryPoint A pointer to the entry point
1013 @param Attribute The bit mask of attributes to set for the load
1014 PE image
1015
1016 @retval EFI_SUCCESS The image was loaded into memory.
1017 @retval EFI_NOT_FOUND The FilePath was not found.
1018 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1019 @retval EFI_BUFFER_TOO_SMALL The buffer is too small
1020 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1021 path cannot be parsed to locate the proper
1022 protocol for loading the file.
1023 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1024 resources.
1025 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1026 understood.
1027 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1028 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1029 image from being loaded. NULL is returned in *ImageHandle.
1030 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1031 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1032 platform policy specifies that the image should not be started.
1033
1034 **/
1035 EFI_STATUS
1036 CoreLoadImageCommon (
1037 IN BOOLEAN BootPolicy,
1038 IN EFI_HANDLE ParentImageHandle,
1039 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
1040 IN VOID *SourceBuffer OPTIONAL,
1041 IN UINTN SourceSize,
1042 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
1043 IN OUT UINTN *NumberOfPages OPTIONAL,
1044 OUT EFI_HANDLE *ImageHandle,
1045 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
1046 IN UINT32 Attribute
1047 )
1048 {
1049 LOADED_IMAGE_PRIVATE_DATA *Image;
1050 LOADED_IMAGE_PRIVATE_DATA *ParentImage;
1051 IMAGE_FILE_HANDLE FHand;
1052 EFI_STATUS Status;
1053 EFI_STATUS SecurityStatus;
1054 EFI_HANDLE DeviceHandle;
1055 UINT32 AuthenticationStatus;
1056 EFI_DEVICE_PATH_PROTOCOL *OriginalFilePath;
1057 EFI_DEVICE_PATH_PROTOCOL *HandleFilePath;
1058 UINTN FilePathSize;
1059 BOOLEAN ImageIsFromFv;
1060
1061 SecurityStatus = EFI_SUCCESS;
1062
1063 ASSERT (gEfiCurrentTpl < TPL_NOTIFY);
1064 ParentImage = NULL;
1065
1066 //
1067 // The caller must pass in a valid ParentImageHandle
1068 //
1069 if (ImageHandle == NULL || ParentImageHandle == NULL) {
1070 return EFI_INVALID_PARAMETER;
1071 }
1072
1073 ParentImage = CoreLoadedImageInfo (ParentImageHandle);
1074 if (ParentImage == NULL) {
1075 DEBUG((DEBUG_LOAD|DEBUG_ERROR, "LoadImageEx: Parent handle not an image handle\n"));
1076 return EFI_INVALID_PARAMETER;
1077 }
1078
1079 ZeroMem (&FHand, sizeof (IMAGE_FILE_HANDLE));
1080 FHand.Signature = IMAGE_FILE_HANDLE_SIGNATURE;
1081 OriginalFilePath = FilePath;
1082 HandleFilePath = FilePath;
1083 DeviceHandle = NULL;
1084 Status = EFI_SUCCESS;
1085 AuthenticationStatus = 0;
1086 ImageIsFromFv = FALSE;
1087
1088 //
1089 // If the caller passed a copy of the file, then just use it
1090 //
1091 if (SourceBuffer != NULL) {
1092 FHand.Source = SourceBuffer;
1093 FHand.SourceSize = SourceSize;
1094 Status = CoreLocateDevicePath (&gEfiDevicePathProtocolGuid, &HandleFilePath, &DeviceHandle);
1095 if (EFI_ERROR (Status)) {
1096 DeviceHandle = NULL;
1097 }
1098 if (SourceSize > 0) {
1099 Status = EFI_SUCCESS;
1100 } else {
1101 Status = EFI_LOAD_ERROR;
1102 }
1103 } else {
1104 if (FilePath == NULL) {
1105 return EFI_INVALID_PARAMETER;
1106 }
1107 //
1108 // Get the source file buffer by its device path.
1109 //
1110 FHand.Source = GetFileBufferByFilePath (
1111 BootPolicy,
1112 FilePath,
1113 &FHand.SourceSize,
1114 &AuthenticationStatus
1115 );
1116 if (FHand.Source == NULL) {
1117 Status = EFI_NOT_FOUND;
1118 } else {
1119 //
1120 // Try to get the image device handle by checking the match protocol.
1121 //
1122 FHand.FreeBuffer = TRUE;
1123 Status = CoreLocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &HandleFilePath, &DeviceHandle);
1124 if (!EFI_ERROR (Status)) {
1125 ImageIsFromFv = TRUE;
1126 } else {
1127 HandleFilePath = FilePath;
1128 Status = CoreLocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &HandleFilePath, &DeviceHandle);
1129 if (EFI_ERROR (Status)) {
1130 if (!BootPolicy) {
1131 HandleFilePath = FilePath;
1132 Status = CoreLocateDevicePath (&gEfiLoadFile2ProtocolGuid, &HandleFilePath, &DeviceHandle);
1133 }
1134 if (EFI_ERROR (Status)) {
1135 HandleFilePath = FilePath;
1136 Status = CoreLocateDevicePath (&gEfiLoadFileProtocolGuid, &HandleFilePath, &DeviceHandle);
1137 }
1138 }
1139 }
1140 }
1141 }
1142
1143 if (EFI_ERROR (Status)) {
1144 Image = NULL;
1145 goto Done;
1146 }
1147
1148 if (gSecurity2 != NULL) {
1149 //
1150 // Verify File Authentication through the Security2 Architectural Protocol
1151 //
1152 SecurityStatus = gSecurity2->FileAuthentication (
1153 gSecurity2,
1154 OriginalFilePath,
1155 FHand.Source,
1156 FHand.SourceSize,
1157 BootPolicy
1158 );
1159 if (!EFI_ERROR (SecurityStatus) && ImageIsFromFv) {
1160 //
1161 // When Security2 is installed, Security Architectural Protocol must be published.
1162 //
1163 ASSERT (gSecurity != NULL);
1164
1165 //
1166 // Verify the Authentication Status through the Security Architectural Protocol
1167 // Only on images that have been read using Firmware Volume protocol.
1168 //
1169 SecurityStatus = gSecurity->FileAuthenticationState (
1170 gSecurity,
1171 AuthenticationStatus,
1172 OriginalFilePath
1173 );
1174 }
1175 } else if ((gSecurity != NULL) && (OriginalFilePath != NULL)) {
1176 //
1177 // Verify the Authentication Status through the Security Architectural Protocol
1178 //
1179 SecurityStatus = gSecurity->FileAuthenticationState (
1180 gSecurity,
1181 AuthenticationStatus,
1182 OriginalFilePath
1183 );
1184 }
1185
1186 //
1187 // Check Security Status.
1188 //
1189 if (EFI_ERROR (SecurityStatus) && SecurityStatus != EFI_SECURITY_VIOLATION) {
1190 if (SecurityStatus == EFI_ACCESS_DENIED) {
1191 //
1192 // Image was not loaded because the platform policy prohibits the image from being loaded.
1193 // It's the only place we could meet EFI_ACCESS_DENIED.
1194 //
1195 *ImageHandle = NULL;
1196 }
1197 Status = SecurityStatus;
1198 Image = NULL;
1199 goto Done;
1200 }
1201
1202 //
1203 // Allocate a new image structure
1204 //
1205 Image = AllocateZeroPool (sizeof(LOADED_IMAGE_PRIVATE_DATA));
1206 if (Image == NULL) {
1207 Status = EFI_OUT_OF_RESOURCES;
1208 goto Done;
1209 }
1210
1211 //
1212 // Pull out just the file portion of the DevicePath for the LoadedImage FilePath
1213 //
1214 FilePath = OriginalFilePath;
1215 if (DeviceHandle != NULL) {
1216 Status = CoreHandleProtocol (DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **)&HandleFilePath);
1217 if (!EFI_ERROR (Status)) {
1218 FilePathSize = GetDevicePathSize (HandleFilePath) - sizeof(EFI_DEVICE_PATH_PROTOCOL);
1219 FilePath = (EFI_DEVICE_PATH_PROTOCOL *) (((UINT8 *)FilePath) + FilePathSize );
1220 }
1221 }
1222 //
1223 // Initialize the fields for an internal driver
1224 //
1225 Image->Signature = LOADED_IMAGE_PRIVATE_DATA_SIGNATURE;
1226 Image->Info.SystemTable = gDxeCoreST;
1227 Image->Info.DeviceHandle = DeviceHandle;
1228 Image->Info.Revision = EFI_LOADED_IMAGE_PROTOCOL_REVISION;
1229 Image->Info.FilePath = DuplicateDevicePath (FilePath);
1230 Image->Info.ParentHandle = ParentImageHandle;
1231
1232
1233 if (NumberOfPages != NULL) {
1234 Image->NumberOfPages = *NumberOfPages ;
1235 } else {
1236 Image->NumberOfPages = 0 ;
1237 }
1238
1239 //
1240 // Install the protocol interfaces for this image
1241 // don't fire notifications yet
1242 //
1243 Status = CoreInstallProtocolInterfaceNotify (
1244 &Image->Handle,
1245 &gEfiLoadedImageProtocolGuid,
1246 EFI_NATIVE_INTERFACE,
1247 &Image->Info,
1248 FALSE
1249 );
1250 if (EFI_ERROR (Status)) {
1251 goto Done;
1252 }
1253
1254 //
1255 // Load the image. If EntryPoint is Null, it will not be set.
1256 //
1257 Status = CoreLoadPeImage (BootPolicy, &FHand, Image, DstBuffer, EntryPoint, Attribute);
1258 if (EFI_ERROR (Status)) {
1259 if ((Status == EFI_BUFFER_TOO_SMALL) || (Status == EFI_OUT_OF_RESOURCES)) {
1260 if (NumberOfPages != NULL) {
1261 *NumberOfPages = Image->NumberOfPages;
1262 }
1263 }
1264 goto Done;
1265 }
1266
1267 if (NumberOfPages != NULL) {
1268 *NumberOfPages = Image->NumberOfPages;
1269 }
1270
1271 //
1272 // Register the image in the Debug Image Info Table if the attribute is set
1273 //
1274 if ((Attribute & EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION) != 0) {
1275 CoreNewDebugImageInfoEntry (EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL, &Image->Info, Image->Handle);
1276 }
1277
1278 //
1279 //Reinstall loaded image protocol to fire any notifications
1280 //
1281 Status = CoreReinstallProtocolInterface (
1282 Image->Handle,
1283 &gEfiLoadedImageProtocolGuid,
1284 &Image->Info,
1285 &Image->Info
1286 );
1287 if (EFI_ERROR (Status)) {
1288 goto Done;
1289 }
1290
1291 //
1292 // If DevicePath parameter to the LoadImage() is not NULL, then make a copy of DevicePath,
1293 // otherwise Loaded Image Device Path Protocol is installed with a NULL interface pointer.
1294 //
1295 if (OriginalFilePath != NULL) {
1296 Image->LoadedImageDevicePath = DuplicateDevicePath (OriginalFilePath);
1297 }
1298
1299 //
1300 // Install Loaded Image Device Path Protocol onto the image handle of a PE/COFE image
1301 //
1302 Status = CoreInstallProtocolInterface (
1303 &Image->Handle,
1304 &gEfiLoadedImageDevicePathProtocolGuid,
1305 EFI_NATIVE_INTERFACE,
1306 Image->LoadedImageDevicePath
1307 );
1308 if (EFI_ERROR (Status)) {
1309 goto Done;
1310 }
1311
1312 //
1313 // Install HII Package List Protocol onto the image handle
1314 //
1315 if (Image->ImageContext.HiiResourceData != 0) {
1316 Status = CoreInstallProtocolInterface (
1317 &Image->Handle,
1318 &gEfiHiiPackageListProtocolGuid,
1319 EFI_NATIVE_INTERFACE,
1320 (VOID *) (UINTN) Image->ImageContext.HiiResourceData
1321 );
1322 if (EFI_ERROR (Status)) {
1323 goto Done;
1324 }
1325 }
1326
1327 //
1328 // Success. Return the image handle
1329 //
1330 *ImageHandle = Image->Handle;
1331
1332 Done:
1333 //
1334 // All done accessing the source file
1335 // If we allocated the Source buffer, free it
1336 //
1337 if (FHand.FreeBuffer) {
1338 CoreFreePool (FHand.Source);
1339 }
1340
1341 //
1342 // There was an error. If there's an Image structure, free it
1343 //
1344 if (EFI_ERROR (Status)) {
1345 if (Image != NULL) {
1346 CoreUnloadAndCloseImage (Image, (BOOLEAN)(DstBuffer == 0));
1347 Image = NULL;
1348 }
1349 } else if (EFI_ERROR (SecurityStatus)) {
1350 Status = SecurityStatus;
1351 }
1352
1353 //
1354 // Track the return status from LoadImage.
1355 //
1356 if (Image != NULL) {
1357 Image->LoadImageStatus = Status;
1358 }
1359
1360 return Status;
1361 }
1362
1363
1364
1365
1366 /**
1367 Loads an EFI image into memory and returns a handle to the image.
1368
1369 @param BootPolicy If TRUE, indicates that the request originates
1370 from the boot manager, and that the boot
1371 manager is attempting to load FilePath as a
1372 boot selection.
1373 @param ParentImageHandle The caller's image handle.
1374 @param FilePath The specific file path from which the image is
1375 loaded.
1376 @param SourceBuffer If not NULL, a pointer to the memory location
1377 containing a copy of the image to be loaded.
1378 @param SourceSize The size in bytes of SourceBuffer.
1379 @param ImageHandle Pointer to the returned image handle that is
1380 created when the image is successfully loaded.
1381
1382 @retval EFI_SUCCESS The image was loaded into memory.
1383 @retval EFI_NOT_FOUND The FilePath was not found.
1384 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1385 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1386 path cannot be parsed to locate the proper
1387 protocol for loading the file.
1388 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1389 resources.
1390 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1391 understood.
1392 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1393 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1394 image from being loaded. NULL is returned in *ImageHandle.
1395 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1396 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1397 platform policy specifies that the image should not be started.
1398
1399 **/
1400 EFI_STATUS
1401 EFIAPI
1402 CoreLoadImage (
1403 IN BOOLEAN BootPolicy,
1404 IN EFI_HANDLE ParentImageHandle,
1405 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
1406 IN VOID *SourceBuffer OPTIONAL,
1407 IN UINTN SourceSize,
1408 OUT EFI_HANDLE *ImageHandle
1409 )
1410 {
1411 EFI_STATUS Status;
1412 UINT64 Tick;
1413 EFI_HANDLE Handle;
1414
1415 Tick = 0;
1416 PERF_CODE (
1417 Tick = GetPerformanceCounter ();
1418 );
1419
1420 Status = CoreLoadImageCommon (
1421 BootPolicy,
1422 ParentImageHandle,
1423 FilePath,
1424 SourceBuffer,
1425 SourceSize,
1426 (EFI_PHYSICAL_ADDRESS) (UINTN) NULL,
1427 NULL,
1428 ImageHandle,
1429 NULL,
1430 EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION | EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION
1431 );
1432
1433 Handle = NULL;
1434 if (!EFI_ERROR (Status)) {
1435 //
1436 // ImageHandle will be valid only Status is success.
1437 //
1438 Handle = *ImageHandle;
1439 }
1440
1441 PERF_START (Handle, "LoadImage:", NULL, Tick);
1442 PERF_END (Handle, "LoadImage:", NULL, 0);
1443
1444 return Status;
1445 }
1446
1447
1448
1449 /**
1450 Loads an EFI image into memory and returns a handle to the image with extended parameters.
1451
1452 @param This Calling context
1453 @param ParentImageHandle The caller's image handle.
1454 @param FilePath The specific file path from which the image is
1455 loaded.
1456 @param SourceBuffer If not NULL, a pointer to the memory location
1457 containing a copy of the image to be loaded.
1458 @param SourceSize The size in bytes of SourceBuffer.
1459 @param DstBuffer The buffer to store the image.
1460 @param NumberOfPages For input, specifies the space size of the
1461 image by caller if not NULL. For output,
1462 specifies the actual space size needed.
1463 @param ImageHandle Image handle for output.
1464 @param EntryPoint Image entry point for output.
1465 @param Attribute The bit mask of attributes to set for the load
1466 PE image.
1467
1468 @retval EFI_SUCCESS The image was loaded into memory.
1469 @retval EFI_NOT_FOUND The FilePath was not found.
1470 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1471 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1472 path cannot be parsed to locate the proper
1473 protocol for loading the file.
1474 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1475 resources.
1476 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1477 understood.
1478 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1479 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1480 image from being loaded. NULL is returned in *ImageHandle.
1481 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1482 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1483 platform policy specifies that the image should not be started.
1484
1485 **/
1486 EFI_STATUS
1487 EFIAPI
1488 CoreLoadImageEx (
1489 IN EFI_PE32_IMAGE_PROTOCOL *This,
1490 IN EFI_HANDLE ParentImageHandle,
1491 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
1492 IN VOID *SourceBuffer OPTIONAL,
1493 IN UINTN SourceSize,
1494 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
1495 OUT UINTN *NumberOfPages OPTIONAL,
1496 OUT EFI_HANDLE *ImageHandle,
1497 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
1498 IN UINT32 Attribute
1499 )
1500 {
1501 EFI_STATUS Status;
1502 UINT64 Tick;
1503 EFI_HANDLE Handle;
1504
1505 Tick = 0;
1506 PERF_CODE (
1507 Tick = GetPerformanceCounter ();
1508 );
1509
1510 Status = CoreLoadImageCommon (
1511 TRUE,
1512 ParentImageHandle,
1513 FilePath,
1514 SourceBuffer,
1515 SourceSize,
1516 DstBuffer,
1517 NumberOfPages,
1518 ImageHandle,
1519 EntryPoint,
1520 Attribute
1521 );
1522
1523 Handle = NULL;
1524 if (!EFI_ERROR (Status)) {
1525 //
1526 // ImageHandle will be valid only Status is success.
1527 //
1528 Handle = *ImageHandle;
1529 }
1530
1531 PERF_START (Handle, "LoadImage:", NULL, Tick);
1532 PERF_END (Handle, "LoadImage:", NULL, 0);
1533
1534 return Status;
1535 }
1536
1537
1538 /**
1539 Transfer control to a loaded image's entry point.
1540
1541 @param ImageHandle Handle of image to be started.
1542 @param ExitDataSize Pointer of the size to ExitData
1543 @param ExitData Pointer to a pointer to a data buffer that
1544 includes a Null-terminated string,
1545 optionally followed by additional binary data.
1546 The string is a description that the caller may
1547 use to further indicate the reason for the
1548 image's exit.
1549
1550 @retval EFI_INVALID_PARAMETER Invalid parameter
1551 @retval EFI_OUT_OF_RESOURCES No enough buffer to allocate
1552 @retval EFI_SECURITY_VIOLATION The current platform policy specifies that the image should not be started.
1553 @retval EFI_SUCCESS Successfully transfer control to the image's
1554 entry point.
1555
1556 **/
1557 EFI_STATUS
1558 EFIAPI
1559 CoreStartImage (
1560 IN EFI_HANDLE ImageHandle,
1561 OUT UINTN *ExitDataSize,
1562 OUT CHAR16 **ExitData OPTIONAL
1563 )
1564 {
1565 EFI_STATUS Status;
1566 LOADED_IMAGE_PRIVATE_DATA *Image;
1567 LOADED_IMAGE_PRIVATE_DATA *LastImage;
1568 UINT64 HandleDatabaseKey;
1569 UINTN SetJumpFlag;
1570 UINT64 Tick;
1571 EFI_HANDLE Handle;
1572
1573 Tick = 0;
1574 Handle = ImageHandle;
1575
1576 Image = CoreLoadedImageInfo (ImageHandle);
1577 if (Image == NULL || Image->Started) {
1578 return EFI_INVALID_PARAMETER;
1579 }
1580 if (EFI_ERROR (Image->LoadImageStatus)) {
1581 return Image->LoadImageStatus;
1582 }
1583
1584 //
1585 // The image to be started must have the machine type supported by DxeCore.
1586 //
1587 if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Image->Machine)) {
1588 //
1589 // Do not ASSERT here, because image might be loaded via EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED
1590 // But it can not be started.
1591 //
1592 DEBUG ((EFI_D_ERROR, "Image type %s can't be started ", GetMachineTypeName(Image->Machine)));
1593 DEBUG ((EFI_D_ERROR, "on %s UEFI system.\n", GetMachineTypeName(mDxeCoreImageMachineType)));
1594 return EFI_UNSUPPORTED;
1595 }
1596
1597 PERF_CODE (
1598 Tick = GetPerformanceCounter ();
1599 );
1600
1601
1602 //
1603 // Push the current start image context, and
1604 // link the current image to the head. This is the
1605 // only image that can call Exit()
1606 //
1607 HandleDatabaseKey = CoreGetHandleDatabaseKey ();
1608 LastImage = mCurrentImage;
1609 mCurrentImage = Image;
1610 Image->Tpl = gEfiCurrentTpl;
1611
1612 //
1613 // Set long jump for Exit() support
1614 // JumpContext must be aligned on a CPU specific boundary.
1615 // Overallocate the buffer and force the required alignment
1616 //
1617 Image->JumpBuffer = AllocatePool (sizeof (BASE_LIBRARY_JUMP_BUFFER) + BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT);
1618 if (Image->JumpBuffer == NULL) {
1619 //
1620 // Image may be unloaded after return with failure,
1621 // then ImageHandle may be invalid, so use NULL handle to record perf log.
1622 //
1623 PERF_START (NULL, "StartImage:", NULL, Tick);
1624 PERF_END (NULL, "StartImage:", NULL, 0);
1625 return EFI_OUT_OF_RESOURCES;
1626 }
1627 Image->JumpContext = ALIGN_POINTER (Image->JumpBuffer, BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT);
1628
1629 SetJumpFlag = SetJump (Image->JumpContext);
1630 //
1631 // The initial call to SetJump() must always return 0.
1632 // Subsequent calls to LongJump() cause a non-zero value to be returned by SetJump().
1633 //
1634 if (SetJumpFlag == 0) {
1635 RegisterMemoryProfileImage (Image, (Image->ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION ? EFI_FV_FILETYPE_APPLICATION : EFI_FV_FILETYPE_DRIVER));
1636 //
1637 // Call the image's entry point
1638 //
1639 Image->Started = TRUE;
1640 Image->Status = Image->EntryPoint (ImageHandle, Image->Info.SystemTable);
1641
1642 //
1643 // Add some debug information if the image returned with error.
1644 // This make the user aware and check if the driver image have already released
1645 // all the resource in this situation.
1646 //
1647 DEBUG_CODE_BEGIN ();
1648 if (EFI_ERROR (Image->Status)) {
1649 DEBUG ((DEBUG_ERROR, "Error: Image at %11p start failed: %r\n", Image->Info.ImageBase, Image->Status));
1650 }
1651 DEBUG_CODE_END ();
1652
1653 //
1654 // If the image returns, exit it through Exit()
1655 //
1656 CoreExit (ImageHandle, Image->Status, 0, NULL);
1657 }
1658
1659 //
1660 // Image has completed. Verify the tpl is the same
1661 //
1662 ASSERT (Image->Tpl == gEfiCurrentTpl);
1663 CoreRestoreTpl (Image->Tpl);
1664
1665 CoreFreePool (Image->JumpBuffer);
1666
1667 //
1668 // Pop the current start image context
1669 //
1670 mCurrentImage = LastImage;
1671
1672 //
1673 // Go connect any handles that were created or modified while the image executed.
1674 //
1675 CoreConnectHandlesByKey (HandleDatabaseKey);
1676
1677 //
1678 // Handle the image's returned ExitData
1679 //
1680 DEBUG_CODE_BEGIN ();
1681 if (Image->ExitDataSize != 0 || Image->ExitData != NULL) {
1682
1683 DEBUG ((DEBUG_LOAD, "StartImage: ExitDataSize %d, ExitData %p", (UINT32)Image->ExitDataSize, Image->ExitData));
1684 if (Image->ExitData != NULL) {
1685 DEBUG ((DEBUG_LOAD, " (%hs)", Image->ExitData));
1686 }
1687 DEBUG ((DEBUG_LOAD, "\n"));
1688 }
1689 DEBUG_CODE_END ();
1690
1691 //
1692 // Return the exit data to the caller
1693 //
1694 if (ExitData != NULL && ExitDataSize != NULL) {
1695 *ExitDataSize = Image->ExitDataSize;
1696 *ExitData = Image->ExitData;
1697 } else {
1698 //
1699 // Caller doesn't want the exit data, free it
1700 //
1701 CoreFreePool (Image->ExitData);
1702 Image->ExitData = NULL;
1703 }
1704
1705 //
1706 // Save the Status because Image will get destroyed if it is unloaded.
1707 //
1708 Status = Image->Status;
1709
1710 //
1711 // If the image returned an error, or if the image is an application
1712 // unload it
1713 //
1714 if (EFI_ERROR (Image->Status) || Image->Type == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1715 CoreUnloadAndCloseImage (Image, TRUE);
1716 //
1717 // ImageHandle may be invalid after the image is unloaded, so use NULL handle to record perf log.
1718 //
1719 Handle = NULL;
1720 }
1721
1722 //
1723 // Done
1724 //
1725 PERF_START (Handle, "StartImage:", NULL, Tick);
1726 PERF_END (Handle, "StartImage:", NULL, 0);
1727 return Status;
1728 }
1729
1730 /**
1731 Terminates the currently loaded EFI image and returns control to boot services.
1732
1733 @param ImageHandle Handle that identifies the image. This
1734 parameter is passed to the image on entry.
1735 @param Status The image's exit code.
1736 @param ExitDataSize The size, in bytes, of ExitData. Ignored if
1737 ExitStatus is EFI_SUCCESS.
1738 @param ExitData Pointer to a data buffer that includes a
1739 Null-terminated Unicode string, optionally
1740 followed by additional binary data. The string
1741 is a description that the caller may use to
1742 further indicate the reason for the image's
1743 exit.
1744
1745 @retval EFI_INVALID_PARAMETER Image handle is NULL or it is not current
1746 image.
1747 @retval EFI_SUCCESS Successfully terminates the currently loaded
1748 EFI image.
1749 @retval EFI_ACCESS_DENIED Should never reach there.
1750 @retval EFI_OUT_OF_RESOURCES Could not allocate pool
1751
1752 **/
1753 EFI_STATUS
1754 EFIAPI
1755 CoreExit (
1756 IN EFI_HANDLE ImageHandle,
1757 IN EFI_STATUS Status,
1758 IN UINTN ExitDataSize,
1759 IN CHAR16 *ExitData OPTIONAL
1760 )
1761 {
1762 LOADED_IMAGE_PRIVATE_DATA *Image;
1763 EFI_TPL OldTpl;
1764
1765 //
1766 // Prevent possible reentrance to this function
1767 // for the same ImageHandle
1768 //
1769 OldTpl = CoreRaiseTpl (TPL_NOTIFY);
1770
1771 Image = CoreLoadedImageInfo (ImageHandle);
1772 if (Image == NULL) {
1773 Status = EFI_INVALID_PARAMETER;
1774 goto Done;
1775 }
1776
1777 if (!Image->Started) {
1778 //
1779 // The image has not been started so just free its resources
1780 //
1781 CoreUnloadAndCloseImage (Image, TRUE);
1782 Status = EFI_SUCCESS;
1783 goto Done;
1784 }
1785
1786 //
1787 // Image has been started, verify this image can exit
1788 //
1789 if (Image != mCurrentImage) {
1790 DEBUG ((DEBUG_LOAD|DEBUG_ERROR, "Exit: Image is not exitable image\n"));
1791 Status = EFI_INVALID_PARAMETER;
1792 goto Done;
1793 }
1794
1795 //
1796 // Set status
1797 //
1798 Image->Status = Status;
1799
1800 //
1801 // If there's ExitData info, move it
1802 //
1803 if (ExitData != NULL) {
1804 Image->ExitDataSize = ExitDataSize;
1805 Image->ExitData = AllocatePool (Image->ExitDataSize);
1806 if (Image->ExitData == NULL) {
1807 Status = EFI_OUT_OF_RESOURCES;
1808 goto Done;
1809 }
1810 CopyMem (Image->ExitData, ExitData, Image->ExitDataSize);
1811 }
1812
1813 CoreRestoreTpl (OldTpl);
1814 //
1815 // return to StartImage
1816 //
1817 LongJump (Image->JumpContext, (UINTN)-1);
1818
1819 //
1820 // If we return from LongJump, then it is an error
1821 //
1822 ASSERT (FALSE);
1823 Status = EFI_ACCESS_DENIED;
1824 Done:
1825 CoreRestoreTpl (OldTpl);
1826 return Status;
1827 }
1828
1829
1830
1831
1832 /**
1833 Unloads an image.
1834
1835 @param ImageHandle Handle that identifies the image to be
1836 unloaded.
1837
1838 @retval EFI_SUCCESS The image has been unloaded.
1839 @retval EFI_UNSUPPORTED The image has been sarted, and does not support
1840 unload.
1841 @retval EFI_INVALID_PARAMPETER ImageHandle is not a valid image handle.
1842
1843 **/
1844 EFI_STATUS
1845 EFIAPI
1846 CoreUnloadImage (
1847 IN EFI_HANDLE ImageHandle
1848 )
1849 {
1850 EFI_STATUS Status;
1851 LOADED_IMAGE_PRIVATE_DATA *Image;
1852
1853 Image = CoreLoadedImageInfo (ImageHandle);
1854 if (Image == NULL ) {
1855 //
1856 // The image handle is not valid
1857 //
1858 Status = EFI_INVALID_PARAMETER;
1859 goto Done;
1860 }
1861
1862 if (Image->Started) {
1863 //
1864 // The image has been started, request it to unload.
1865 //
1866 Status = EFI_UNSUPPORTED;
1867 if (Image->Info.Unload != NULL) {
1868 Status = Image->Info.Unload (ImageHandle);
1869 }
1870
1871 } else {
1872 //
1873 // This Image hasn't been started, thus it can be unloaded
1874 //
1875 Status = EFI_SUCCESS;
1876 }
1877
1878
1879 if (!EFI_ERROR (Status)) {
1880 //
1881 // if the Image was not started or Unloaded O.K. then clean up
1882 //
1883 CoreUnloadAndCloseImage (Image, TRUE);
1884 }
1885
1886 Done:
1887 return Status;
1888 }
1889
1890
1891
1892 /**
1893 Unload the specified image.
1894
1895 @param This Indicates the calling context.
1896 @param ImageHandle The specified image handle.
1897
1898 @retval EFI_INVALID_PARAMETER Image handle is NULL.
1899 @retval EFI_UNSUPPORTED Attempt to unload an unsupported image.
1900 @retval EFI_SUCCESS Image successfully unloaded.
1901
1902 **/
1903 EFI_STATUS
1904 EFIAPI
1905 CoreUnloadImageEx (
1906 IN EFI_PE32_IMAGE_PROTOCOL *This,
1907 IN EFI_HANDLE ImageHandle
1908 )
1909 {
1910 return CoreUnloadImage (ImageHandle);
1911 }
EFI Development Kit II mirror for PVE