]> 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
Fix the potential issue that NULL pointer may be referred in LoadImage().
[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 - 2012, 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
393 Status = EFI_NOT_FOUND;
394
395 if ((SectionHeader.Characteristics & EFI_IMAGE_SCN_CNT_CODE) == 0) {
396 //
397 // Build tool will save the address in PointerToRelocations & PointerToLineNumbers fields in the first section header
398 // that doesn't point to code section in image header, as well as ImageBase field of image header. And there is an
399 // assumption that when the feature is enabled, if a module is assigned a loading address by tools, PointerToRelocations
400 // & PointerToLineNumbers fields should NOT be Zero, or else, these 2 fileds should be set to Zero
401 //
402 ValueInSectionHeader = ReadUnaligned64((UINT64*)&SectionHeader.PointerToRelocations);
403 if (ValueInSectionHeader != 0) {
404 //
405 // When the feature is configured as load module at fixed absolute address, the ImageAddress field of ImageContext
406 // hold the spcified address. If the feature is configured as load module at fixed offset, ImageAddress hold an offset
407 // relative to top address
408 //
409 if ((INT64)PcdGet64(PcdLoadModuleAtFixAddressEnable) < 0) {
410 ImageContext->ImageAddress = gLoadModuleAtFixAddressConfigurationTable.DxeCodeTopAddress + (INT64)(INTN)ImageContext->ImageAddress;
411 }
412 //
413 // Check if the memory range is avaliable.
414 //
415 Status = CheckAndMarkFixLoadingMemoryUsageBitMap (ImageContext->ImageAddress, (UINTN)(ImageContext->ImageSize + ImageContext->SectionAlignment));
416 }
417 break;
418 }
419 SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);
420 }
421 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));
422 return Status;
423 }
424 /**
425 Loads, relocates, and invokes a PE/COFF image
426
427 @param BootPolicy If TRUE, indicates that the request originates
428 from the boot manager, and that the boot
429 manager is attempting to load FilePath as a
430 boot selection.
431 @param Pe32Handle The handle of PE32 image
432 @param Image PE image to be loaded
433 @param DstBuffer The buffer to store the image
434 @param EntryPoint A pointer to the entry point
435 @param Attribute The bit mask of attributes to set for the load
436 PE image
437
438 @retval EFI_SUCCESS The file was loaded, relocated, and invoked
439 @retval EFI_OUT_OF_RESOURCES There was not enough memory to load and
440 relocate the PE/COFF file
441 @retval EFI_INVALID_PARAMETER Invalid parameter
442 @retval EFI_BUFFER_TOO_SMALL Buffer for image is too small
443
444 **/
445 EFI_STATUS
446 CoreLoadPeImage (
447 IN BOOLEAN BootPolicy,
448 IN VOID *Pe32Handle,
449 IN LOADED_IMAGE_PRIVATE_DATA *Image,
450 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
451 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
452 IN UINT32 Attribute
453 )
454 {
455 EFI_STATUS Status;
456 BOOLEAN DstBufAlocated;
457 UINTN Size;
458
459 ZeroMem (&Image->ImageContext, sizeof (Image->ImageContext));
460
461 Image->ImageContext.Handle = Pe32Handle;
462 Image->ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE)CoreReadImageFile;
463
464 //
465 // Get information about the image being loaded
466 //
467 Status = PeCoffLoaderGetImageInfo (&Image->ImageContext);
468 if (EFI_ERROR (Status)) {
469 return Status;
470 }
471
472 if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Image->ImageContext.Machine)) {
473 if (!EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED (Image->ImageContext.Machine)) {
474 //
475 // The PE/COFF loader can support loading image types that can be executed.
476 // If we loaded an image type that we can not execute return EFI_UNSUPORTED.
477 //
478 DEBUG ((EFI_D_ERROR, "Image type %s can't be loaded ", GetMachineTypeName(Image->ImageContext.Machine)));
479 DEBUG ((EFI_D_ERROR, "on %s UEFI system.\n", GetMachineTypeName(mDxeCoreImageMachineType)));
480 return EFI_UNSUPPORTED;
481 }
482 }
483
484 //
485 // Set EFI memory type based on ImageType
486 //
487 switch (Image->ImageContext.ImageType) {
488 case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION:
489 Image->ImageContext.ImageCodeMemoryType = EfiLoaderCode;
490 Image->ImageContext.ImageDataMemoryType = EfiLoaderData;
491 break;
492 case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
493 Image->ImageContext.ImageCodeMemoryType = EfiBootServicesCode;
494 Image->ImageContext.ImageDataMemoryType = EfiBootServicesData;
495 break;
496 case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
497 case EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
498 Image->ImageContext.ImageCodeMemoryType = EfiRuntimeServicesCode;
499 Image->ImageContext.ImageDataMemoryType = EfiRuntimeServicesData;
500 break;
501 default:
502 Image->ImageContext.ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM;
503 return EFI_UNSUPPORTED;
504 }
505
506 //
507 // Allocate memory of the correct memory type aligned on the required image boundry
508 //
509 DstBufAlocated = FALSE;
510 if (DstBuffer == 0) {
511 //
512 // Allocate Destination Buffer as caller did not pass it in
513 //
514
515 if (Image->ImageContext.SectionAlignment > EFI_PAGE_SIZE) {
516 Size = (UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment;
517 } else {
518 Size = (UINTN)Image->ImageContext.ImageSize;
519 }
520
521 Image->NumberOfPages = EFI_SIZE_TO_PAGES (Size);
522
523 //
524 // If the image relocations have not been stripped, then load at any address.
525 // Otherwise load at the address at which it was linked.
526 //
527 // Memory below 1MB should be treated reserved for CSM and there should be
528 // no modules whose preferred load addresses are below 1MB.
529 //
530 Status = EFI_OUT_OF_RESOURCES;
531 //
532 // If Loading Module At Fixed Address feature is enabled, the module should be loaded to
533 // a specified address.
534 //
535 if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0 ) {
536 Status = GetPeCoffImageFixLoadingAssignedAddress (&(Image->ImageContext));
537
538 if (EFI_ERROR (Status)) {
539 //
540 // If the code memory is not ready, invoke CoreAllocatePage with AllocateAnyPages to load the driver.
541 //
542 DEBUG ((EFI_D_INFO|EFI_D_LOAD, "LOADING MODULE FIXED ERROR: Loading module at fixed address failed since specified memory is not available.\n"));
543
544 Status = CoreAllocatePages (
545 AllocateAnyPages,
546 (EFI_MEMORY_TYPE) (Image->ImageContext.ImageCodeMemoryType),
547 Image->NumberOfPages,
548 &Image->ImageContext.ImageAddress
549 );
550 }
551 } else {
552 if (Image->ImageContext.ImageAddress >= 0x100000 || Image->ImageContext.RelocationsStripped) {
553 Status = CoreAllocatePages (
554 AllocateAddress,
555 (EFI_MEMORY_TYPE) (Image->ImageContext.ImageCodeMemoryType),
556 Image->NumberOfPages,
557 &Image->ImageContext.ImageAddress
558 );
559 }
560 if (EFI_ERROR (Status) && !Image->ImageContext.RelocationsStripped) {
561 Status = CoreAllocatePages (
562 AllocateAnyPages,
563 (EFI_MEMORY_TYPE) (Image->ImageContext.ImageCodeMemoryType),
564 Image->NumberOfPages,
565 &Image->ImageContext.ImageAddress
566 );
567 }
568 }
569 if (EFI_ERROR (Status)) {
570 return Status;
571 }
572 DstBufAlocated = TRUE;
573 } else {
574 //
575 // Caller provided the destination buffer
576 //
577
578 if (Image->ImageContext.RelocationsStripped && (Image->ImageContext.ImageAddress != DstBuffer)) {
579 //
580 // If the image relocations were stripped, and the caller provided a
581 // destination buffer address that does not match the address that the
582 // image is linked at, then the image cannot be loaded.
583 //
584 return EFI_INVALID_PARAMETER;
585 }
586
587 if (Image->NumberOfPages != 0 &&
588 Image->NumberOfPages <
589 (EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment))) {
590 Image->NumberOfPages = EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment);
591 return EFI_BUFFER_TOO_SMALL;
592 }
593
594 Image->NumberOfPages = EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment);
595 Image->ImageContext.ImageAddress = DstBuffer;
596 }
597
598 Image->ImageBasePage = Image->ImageContext.ImageAddress;
599 if (!Image->ImageContext.IsTeImage) {
600 Image->ImageContext.ImageAddress =
601 (Image->ImageContext.ImageAddress + Image->ImageContext.SectionAlignment - 1) &
602 ~((UINTN)Image->ImageContext.SectionAlignment - 1);
603 }
604
605 //
606 // Load the image from the file into the allocated memory
607 //
608 Status = PeCoffLoaderLoadImage (&Image->ImageContext);
609 if (EFI_ERROR (Status)) {
610 goto Done;
611 }
612
613 //
614 // If this is a Runtime Driver, then allocate memory for the FixupData that
615 // is used to relocate the image when SetVirtualAddressMap() is called. The
616 // relocation is done by the Runtime AP.
617 //
618 if ((Attribute & EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION) != 0) {
619 if (Image->ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) {
620 Image->ImageContext.FixupData = AllocateRuntimePool ((UINTN)(Image->ImageContext.FixupDataSize));
621 if (Image->ImageContext.FixupData == NULL) {
622 Status = EFI_OUT_OF_RESOURCES;
623 goto Done;
624 }
625 }
626 }
627
628 //
629 // Relocate the image in memory
630 //
631 Status = PeCoffLoaderRelocateImage (&Image->ImageContext);
632 if (EFI_ERROR (Status)) {
633 goto Done;
634 }
635
636 //
637 // Flush the Instruction Cache
638 //
639 InvalidateInstructionCacheRange ((VOID *)(UINTN)Image->ImageContext.ImageAddress, (UINTN)Image->ImageContext.ImageSize);
640
641 //
642 // Copy the machine type from the context to the image private data. This
643 // is needed during image unload to know if we should call an EBC protocol
644 // to unload the image.
645 //
646 Image->Machine = Image->ImageContext.Machine;
647
648 //
649 // Get the image entry point. If it's an EBC image, then call into the
650 // interpreter to create a thunk for the entry point and use the returned
651 // value for the entry point.
652 //
653 Image->EntryPoint = (EFI_IMAGE_ENTRY_POINT)(UINTN)Image->ImageContext.EntryPoint;
654 if (Image->ImageContext.Machine == EFI_IMAGE_MACHINE_EBC) {
655 //
656 // Locate the EBC interpreter protocol
657 //
658 Status = CoreLocateProtocol (&gEfiEbcProtocolGuid, NULL, (VOID **)&Image->Ebc);
659 if (EFI_ERROR(Status) || Image->Ebc == NULL) {
660 DEBUG ((DEBUG_LOAD | DEBUG_ERROR, "CoreLoadPeImage: There is no EBC interpreter for an EBC image.\n"));
661 goto Done;
662 }
663
664 //
665 // Register a callback for flushing the instruction cache so that created
666 // thunks can be flushed.
667 //
668 Status = Image->Ebc->RegisterICacheFlush (Image->Ebc, (EBC_ICACHE_FLUSH)InvalidateInstructionCacheRange);
669 if (EFI_ERROR(Status)) {
670 goto Done;
671 }
672
673 //
674 // Create a thunk for the image's entry point. This will be the new
675 // entry point for the image.
676 //
677 Status = Image->Ebc->CreateThunk (
678 Image->Ebc,
679 Image->Handle,
680 (VOID *)(UINTN) Image->ImageContext.EntryPoint,
681 (VOID **) &Image->EntryPoint
682 );
683 if (EFI_ERROR(Status)) {
684 goto Done;
685 }
686 }
687
688 //
689 // Fill in the image information for the Loaded Image Protocol
690 //
691 Image->Type = Image->ImageContext.ImageType;
692 Image->Info.ImageBase = (VOID *)(UINTN)Image->ImageContext.ImageAddress;
693 Image->Info.ImageSize = Image->ImageContext.ImageSize;
694 Image->Info.ImageCodeType = (EFI_MEMORY_TYPE) (Image->ImageContext.ImageCodeMemoryType);
695 Image->Info.ImageDataType = (EFI_MEMORY_TYPE) (Image->ImageContext.ImageDataMemoryType);
696 if ((Attribute & EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION) != 0) {
697 if (Image->ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) {
698 //
699 // Make a list off all the RT images so we can let the RT AP know about them.
700 //
701 Image->RuntimeData = AllocateRuntimePool (sizeof(EFI_RUNTIME_IMAGE_ENTRY));
702 if (Image->RuntimeData == NULL) {
703 goto Done;
704 }
705 Image->RuntimeData->ImageBase = Image->Info.ImageBase;
706 Image->RuntimeData->ImageSize = (UINT64) (Image->Info.ImageSize);
707 Image->RuntimeData->RelocationData = Image->ImageContext.FixupData;
708 Image->RuntimeData->Handle = Image->Handle;
709 InsertTailList (&gRuntime->ImageHead, &Image->RuntimeData->Link);
710 }
711 }
712
713 //
714 // Fill in the entry point of the image if it is available
715 //
716 if (EntryPoint != NULL) {
717 *EntryPoint = Image->ImageContext.EntryPoint;
718 }
719
720 //
721 // Print the load address and the PDB file name if it is available
722 //
723
724 DEBUG_CODE_BEGIN ();
725
726 UINTN Index;
727 UINTN StartIndex;
728 CHAR8 EfiFileName[256];
729
730
731 DEBUG ((DEBUG_INFO | DEBUG_LOAD,
732 "Loading driver at 0x%11p EntryPoint=0x%11p ",
733 (VOID *)(UINTN) Image->ImageContext.ImageAddress,
734 FUNCTION_ENTRY_POINT (Image->ImageContext.EntryPoint)));
735
736
737 //
738 // Print Module Name by Pdb file path.
739 // Windows and Unix style file path are all trimmed correctly.
740 //
741 if (Image->ImageContext.PdbPointer != NULL) {
742 StartIndex = 0;
743 for (Index = 0; Image->ImageContext.PdbPointer[Index] != 0; Index++) {
744 if ((Image->ImageContext.PdbPointer[Index] == '\\') || (Image->ImageContext.PdbPointer[Index] == '/')) {
745 StartIndex = Index + 1;
746 }
747 }
748 //
749 // Copy the PDB file name to our temporary string, and replace .pdb with .efi
750 // The PDB file name is limited in the range of 0~255.
751 // If the length is bigger than 255, trim the redudant characters to avoid overflow in array boundary.
752 //
753 for (Index = 0; Index < sizeof (EfiFileName) - 4; Index++) {
754 EfiFileName[Index] = Image->ImageContext.PdbPointer[Index + StartIndex];
755 if (EfiFileName[Index] == 0) {
756 EfiFileName[Index] = '.';
757 }
758 if (EfiFileName[Index] == '.') {
759 EfiFileName[Index + 1] = 'e';
760 EfiFileName[Index + 2] = 'f';
761 EfiFileName[Index + 3] = 'i';
762 EfiFileName[Index + 4] = 0;
763 break;
764 }
765 }
766
767 if (Index == sizeof (EfiFileName) - 4) {
768 EfiFileName[Index] = 0;
769 }
770 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "%a", EfiFileName)); // &Image->ImageContext.PdbPointer[StartIndex]));
771 }
772 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "\n"));
773
774 DEBUG_CODE_END ();
775
776 return EFI_SUCCESS;
777
778 Done:
779
780 //
781 // Free memory.
782 //
783
784 if (DstBufAlocated) {
785 CoreFreePages (Image->ImageContext.ImageAddress, Image->NumberOfPages);
786 }
787
788 if (Image->ImageContext.FixupData != NULL) {
789 CoreFreePool (Image->ImageContext.FixupData);
790 }
791
792 return Status;
793 }
794
795
796
797 /**
798 Get the image's private data from its handle.
799
800 @param ImageHandle The image handle
801
802 @return Return the image private data associated with ImageHandle.
803
804 **/
805 LOADED_IMAGE_PRIVATE_DATA *
806 CoreLoadedImageInfo (
807 IN EFI_HANDLE ImageHandle
808 )
809 {
810 EFI_STATUS Status;
811 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
812 LOADED_IMAGE_PRIVATE_DATA *Image;
813
814 Status = CoreHandleProtocol (
815 ImageHandle,
816 &gEfiLoadedImageProtocolGuid,
817 (VOID **)&LoadedImage
818 );
819 if (!EFI_ERROR (Status)) {
820 Image = LOADED_IMAGE_PRIVATE_DATA_FROM_THIS (LoadedImage);
821 } else {
822 DEBUG ((DEBUG_LOAD, "CoreLoadedImageInfo: Not an ImageHandle %p\n", ImageHandle));
823 Image = NULL;
824 }
825
826 return Image;
827 }
828
829
830 /**
831 Unloads EFI image from memory.
832
833 @param Image EFI image
834 @param FreePage Free allocated pages
835
836 **/
837 VOID
838 CoreUnloadAndCloseImage (
839 IN LOADED_IMAGE_PRIVATE_DATA *Image,
840 IN BOOLEAN FreePage
841 )
842 {
843 EFI_STATUS Status;
844 UINTN HandleCount;
845 EFI_HANDLE *HandleBuffer;
846 UINTN HandleIndex;
847 EFI_GUID **ProtocolGuidArray;
848 UINTN ArrayCount;
849 UINTN ProtocolIndex;
850 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
851 UINTN OpenInfoCount;
852 UINTN OpenInfoIndex;
853
854 if (Image->Ebc != NULL) {
855 //
856 // If EBC protocol exists we must perform cleanups for this image.
857 //
858 Image->Ebc->UnloadImage (Image->Ebc, Image->Handle);
859 }
860
861 //
862 // Unload image, free Image->ImageContext->ModHandle
863 //
864 PeCoffLoaderUnloadImage (&Image->ImageContext);
865
866 //
867 // Free our references to the image handle
868 //
869 if (Image->Handle != NULL) {
870
871 Status = CoreLocateHandleBuffer (
872 AllHandles,
873 NULL,
874 NULL,
875 &HandleCount,
876 &HandleBuffer
877 );
878 if (!EFI_ERROR (Status)) {
879 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
880 Status = CoreProtocolsPerHandle (
881 HandleBuffer[HandleIndex],
882 &ProtocolGuidArray,
883 &ArrayCount
884 );
885 if (!EFI_ERROR (Status)) {
886 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
887 Status = CoreOpenProtocolInformation (
888 HandleBuffer[HandleIndex],
889 ProtocolGuidArray[ProtocolIndex],
890 &OpenInfo,
891 &OpenInfoCount
892 );
893 if (!EFI_ERROR (Status)) {
894 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
895 if (OpenInfo[OpenInfoIndex].AgentHandle == Image->Handle) {
896 Status = CoreCloseProtocol (
897 HandleBuffer[HandleIndex],
898 ProtocolGuidArray[ProtocolIndex],
899 Image->Handle,
900 OpenInfo[OpenInfoIndex].ControllerHandle
901 );
902 }
903 }
904 if (OpenInfo != NULL) {
905 CoreFreePool(OpenInfo);
906 }
907 }
908 }
909 if (ProtocolGuidArray != NULL) {
910 CoreFreePool(ProtocolGuidArray);
911 }
912 }
913 }
914 if (HandleBuffer != NULL) {
915 CoreFreePool (HandleBuffer);
916 }
917 }
918
919 CoreRemoveDebugImageInfoEntry (Image->Handle);
920
921 Status = CoreUninstallProtocolInterface (
922 Image->Handle,
923 &gEfiLoadedImageDevicePathProtocolGuid,
924 Image->LoadedImageDevicePath
925 );
926
927 Status = CoreUninstallProtocolInterface (
928 Image->Handle,
929 &gEfiLoadedImageProtocolGuid,
930 &Image->Info
931 );
932
933 if (Image->ImageContext.HiiResourceData != 0) {
934 Status = CoreUninstallProtocolInterface (
935 Image->Handle,
936 &gEfiHiiPackageListProtocolGuid,
937 (VOID *) (UINTN) Image->ImageContext.HiiResourceData
938 );
939 }
940
941 }
942
943 if (Image->RuntimeData != NULL) {
944 if (Image->RuntimeData->Link.ForwardLink != NULL) {
945 //
946 // Remove the Image from the Runtime Image list as we are about to Free it!
947 //
948 RemoveEntryList (&Image->RuntimeData->Link);
949 }
950 CoreFreePool (Image->RuntimeData);
951 }
952
953 //
954 // Free the Image from memory
955 //
956 if ((Image->ImageBasePage != 0) && FreePage) {
957 CoreFreePages (Image->ImageBasePage, Image->NumberOfPages);
958 }
959
960 //
961 // Done with the Image structure
962 //
963 if (Image->Info.FilePath != NULL) {
964 CoreFreePool (Image->Info.FilePath);
965 }
966
967 if (Image->LoadedImageDevicePath != NULL) {
968 CoreFreePool (Image->LoadedImageDevicePath);
969 }
970
971 if (Image->FixupData != NULL) {
972 CoreFreePool (Image->FixupData);
973 }
974
975 CoreFreePool (Image);
976 }
977
978
979 /**
980 Loads an EFI image into memory and returns a handle to the image.
981
982 @param BootPolicy If TRUE, indicates that the request originates
983 from the boot manager, and that the boot
984 manager is attempting to load FilePath as a
985 boot selection.
986 @param ParentImageHandle The caller's image handle.
987 @param FilePath The specific file path from which the image is
988 loaded.
989 @param SourceBuffer If not NULL, a pointer to the memory location
990 containing a copy of the image to be loaded.
991 @param SourceSize The size in bytes of SourceBuffer.
992 @param DstBuffer The buffer to store the image
993 @param NumberOfPages If not NULL, it inputs a pointer to the page
994 number of DstBuffer and outputs a pointer to
995 the page number of the image. If this number is
996 not enough, return EFI_BUFFER_TOO_SMALL and
997 this parameter contains the required number.
998 @param ImageHandle Pointer to the returned image handle that is
999 created when the image is successfully loaded.
1000 @param EntryPoint A pointer to the entry point
1001 @param Attribute The bit mask of attributes to set for the load
1002 PE image
1003
1004 @retval EFI_SUCCESS The image was loaded into memory.
1005 @retval EFI_NOT_FOUND The FilePath was not found.
1006 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1007 @retval EFI_BUFFER_TOO_SMALL The buffer is too small
1008 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1009 path cannot be parsed to locate the proper
1010 protocol for loading the file.
1011 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1012 resources.
1013 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1014 understood.
1015 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1016 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1017 image from being loaded. NULL is returned in *ImageHandle.
1018 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1019 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1020 platform policy specifies that the image should not be started.
1021
1022 **/
1023 EFI_STATUS
1024 CoreLoadImageCommon (
1025 IN BOOLEAN BootPolicy,
1026 IN EFI_HANDLE ParentImageHandle,
1027 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
1028 IN VOID *SourceBuffer OPTIONAL,
1029 IN UINTN SourceSize,
1030 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
1031 IN OUT UINTN *NumberOfPages OPTIONAL,
1032 OUT EFI_HANDLE *ImageHandle,
1033 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
1034 IN UINT32 Attribute
1035 )
1036 {
1037 LOADED_IMAGE_PRIVATE_DATA *Image;
1038 LOADED_IMAGE_PRIVATE_DATA *ParentImage;
1039 IMAGE_FILE_HANDLE FHand;
1040 EFI_STATUS Status;
1041 EFI_STATUS SecurityStatus;
1042 EFI_HANDLE DeviceHandle;
1043 UINT32 AuthenticationStatus;
1044 EFI_DEVICE_PATH_PROTOCOL *OriginalFilePath;
1045 EFI_DEVICE_PATH_PROTOCOL *HandleFilePath;
1046 UINTN FilePathSize;
1047
1048 SecurityStatus = EFI_SUCCESS;
1049
1050 ASSERT (gEfiCurrentTpl < TPL_NOTIFY);
1051 ParentImage = NULL;
1052
1053 //
1054 // The caller must pass in a valid ParentImageHandle
1055 //
1056 if (ImageHandle == NULL || ParentImageHandle == NULL) {
1057 return EFI_INVALID_PARAMETER;
1058 }
1059
1060 ParentImage = CoreLoadedImageInfo (ParentImageHandle);
1061 if (ParentImage == NULL) {
1062 DEBUG((DEBUG_LOAD|DEBUG_ERROR, "LoadImageEx: Parent handle not an image handle\n"));
1063 return EFI_INVALID_PARAMETER;
1064 }
1065
1066 ZeroMem (&FHand, sizeof (IMAGE_FILE_HANDLE));
1067 FHand.Signature = IMAGE_FILE_HANDLE_SIGNATURE;
1068 OriginalFilePath = FilePath;
1069 HandleFilePath = FilePath;
1070 DeviceHandle = NULL;
1071 Status = EFI_SUCCESS;
1072 AuthenticationStatus = 0;
1073 //
1074 // If the caller passed a copy of the file, then just use it
1075 //
1076 if (SourceBuffer != NULL) {
1077 FHand.Source = SourceBuffer;
1078 FHand.SourceSize = SourceSize;
1079 CoreLocateDevicePath (&gEfiDevicePathProtocolGuid, &HandleFilePath, &DeviceHandle);
1080 if (SourceSize > 0) {
1081 Status = EFI_SUCCESS;
1082 } else {
1083 Status = EFI_LOAD_ERROR;
1084 }
1085 } else {
1086 if (FilePath == NULL) {
1087 return EFI_INVALID_PARAMETER;
1088 }
1089 //
1090 // Get the source file buffer by its device path.
1091 //
1092 FHand.Source = GetFileBufferByFilePath (
1093 BootPolicy,
1094 FilePath,
1095 &FHand.SourceSize,
1096 &AuthenticationStatus
1097 );
1098 if (FHand.Source == NULL) {
1099 Status = EFI_NOT_FOUND;
1100 } else {
1101 //
1102 // Try to get the image device handle by checking the match protocol.
1103 //
1104 FHand.FreeBuffer = TRUE;
1105 Status = CoreLocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &HandleFilePath, &DeviceHandle);
1106 if (EFI_ERROR (Status)) {
1107 HandleFilePath = FilePath;
1108 Status = CoreLocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &HandleFilePath, &DeviceHandle);
1109 if (EFI_ERROR (Status)) {
1110 if (!BootPolicy) {
1111 HandleFilePath = FilePath;
1112 Status = CoreLocateDevicePath (&gEfiLoadFile2ProtocolGuid, &HandleFilePath, &DeviceHandle);
1113 }
1114 if (EFI_ERROR (Status)) {
1115 HandleFilePath = FilePath;
1116 Status = CoreLocateDevicePath (&gEfiLoadFileProtocolGuid, &HandleFilePath, &DeviceHandle);
1117 }
1118 }
1119 }
1120 }
1121 }
1122
1123 if (Status == EFI_ALREADY_STARTED) {
1124 Image = NULL;
1125 goto Done;
1126 } else if (EFI_ERROR (Status)) {
1127 return Status;
1128 }
1129
1130 //
1131 // Verify the Authentication Status through the Security Architectural Protocol
1132 //
1133 if ((gSecurity != NULL) && (OriginalFilePath != NULL)) {
1134 SecurityStatus = gSecurity->FileAuthenticationState (
1135 gSecurity,
1136 AuthenticationStatus,
1137 OriginalFilePath
1138 );
1139 if (EFI_ERROR (SecurityStatus) && SecurityStatus != EFI_SECURITY_VIOLATION) {
1140 if (SecurityStatus == EFI_ACCESS_DENIED) {
1141 //
1142 // Image was not loaded because the platform policy prohibits the image from being loaded.
1143 // It's the only place we could meet EFI_ACCESS_DENIED.
1144 //
1145 *ImageHandle = NULL;
1146 }
1147 Status = SecurityStatus;
1148 Image = NULL;
1149 goto Done;
1150 }
1151 }
1152
1153
1154 //
1155 // Allocate a new image structure
1156 //
1157 Image = AllocateZeroPool (sizeof(LOADED_IMAGE_PRIVATE_DATA));
1158 if (Image == NULL) {
1159 return EFI_OUT_OF_RESOURCES;
1160 }
1161
1162 //
1163 // Pull out just the file portion of the DevicePath for the LoadedImage FilePath
1164 //
1165 FilePath = OriginalFilePath;
1166 if (DeviceHandle != NULL) {
1167 Status = CoreHandleProtocol (DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **)&HandleFilePath);
1168 if (!EFI_ERROR (Status)) {
1169 FilePathSize = GetDevicePathSize (HandleFilePath) - sizeof(EFI_DEVICE_PATH_PROTOCOL);
1170 FilePath = (EFI_DEVICE_PATH_PROTOCOL *) (((UINT8 *)FilePath) + FilePathSize );
1171 }
1172 }
1173 //
1174 // Initialize the fields for an internal driver
1175 //
1176 Image->Signature = LOADED_IMAGE_PRIVATE_DATA_SIGNATURE;
1177 Image->Info.SystemTable = gDxeCoreST;
1178 Image->Info.DeviceHandle = DeviceHandle;
1179 Image->Info.Revision = EFI_LOADED_IMAGE_PROTOCOL_REVISION;
1180 Image->Info.FilePath = DuplicateDevicePath (FilePath);
1181 Image->Info.ParentHandle = ParentImageHandle;
1182
1183
1184 if (NumberOfPages != NULL) {
1185 Image->NumberOfPages = *NumberOfPages ;
1186 } else {
1187 Image->NumberOfPages = 0 ;
1188 }
1189
1190 //
1191 // Install the protocol interfaces for this image
1192 // don't fire notifications yet
1193 //
1194 Status = CoreInstallProtocolInterfaceNotify (
1195 &Image->Handle,
1196 &gEfiLoadedImageProtocolGuid,
1197 EFI_NATIVE_INTERFACE,
1198 &Image->Info,
1199 FALSE
1200 );
1201 if (EFI_ERROR (Status)) {
1202 goto Done;
1203 }
1204
1205 //
1206 // Load the image. If EntryPoint is Null, it will not be set.
1207 //
1208 Status = CoreLoadPeImage (BootPolicy, &FHand, Image, DstBuffer, EntryPoint, Attribute);
1209 if (EFI_ERROR (Status)) {
1210 if ((Status == EFI_BUFFER_TOO_SMALL) || (Status == EFI_OUT_OF_RESOURCES)) {
1211 if (NumberOfPages != NULL) {
1212 *NumberOfPages = Image->NumberOfPages;
1213 }
1214 }
1215 goto Done;
1216 }
1217
1218 if (NumberOfPages != NULL) {
1219 *NumberOfPages = Image->NumberOfPages;
1220 }
1221
1222 //
1223 // Register the image in the Debug Image Info Table if the attribute is set
1224 //
1225 if ((Attribute & EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION) != 0) {
1226 CoreNewDebugImageInfoEntry (EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL, &Image->Info, Image->Handle);
1227 }
1228
1229 //
1230 //Reinstall loaded image protocol to fire any notifications
1231 //
1232 Status = CoreReinstallProtocolInterface (
1233 Image->Handle,
1234 &gEfiLoadedImageProtocolGuid,
1235 &Image->Info,
1236 &Image->Info
1237 );
1238 if (EFI_ERROR (Status)) {
1239 goto Done;
1240 }
1241
1242 //
1243 // If DevicePath parameter to the LoadImage() is not NULL, then make a copy of DevicePath,
1244 // otherwise Loaded Image Device Path Protocol is installed with a NULL interface pointer.
1245 //
1246 if (OriginalFilePath != NULL) {
1247 Image->LoadedImageDevicePath = DuplicateDevicePath (OriginalFilePath);
1248 }
1249
1250 //
1251 // Install Loaded Image Device Path Protocol onto the image handle of a PE/COFE image
1252 //
1253 Status = CoreInstallProtocolInterface (
1254 &Image->Handle,
1255 &gEfiLoadedImageDevicePathProtocolGuid,
1256 EFI_NATIVE_INTERFACE,
1257 Image->LoadedImageDevicePath
1258 );
1259 if (EFI_ERROR (Status)) {
1260 goto Done;
1261 }
1262
1263 //
1264 // Install HII Package List Protocol onto the image handle
1265 //
1266 if (Image->ImageContext.HiiResourceData != 0) {
1267 Status = CoreInstallProtocolInterface (
1268 &Image->Handle,
1269 &gEfiHiiPackageListProtocolGuid,
1270 EFI_NATIVE_INTERFACE,
1271 (VOID *) (UINTN) Image->ImageContext.HiiResourceData
1272 );
1273 if (EFI_ERROR (Status)) {
1274 goto Done;
1275 }
1276 }
1277
1278 //
1279 // Success. Return the image handle
1280 //
1281 *ImageHandle = Image->Handle;
1282
1283 Done:
1284 //
1285 // All done accessing the source file
1286 // If we allocated the Source buffer, free it
1287 //
1288 if (FHand.FreeBuffer) {
1289 CoreFreePool (FHand.Source);
1290 }
1291
1292 //
1293 // There was an error. If there's an Image structure, free it
1294 //
1295 if (EFI_ERROR (Status)) {
1296 if (Image != NULL) {
1297 CoreUnloadAndCloseImage (Image, (BOOLEAN)(DstBuffer == 0));
1298 }
1299 } else if (EFI_ERROR (SecurityStatus)) {
1300 Status = SecurityStatus;
1301 }
1302
1303 return Status;
1304 }
1305
1306
1307
1308
1309 /**
1310 Loads an EFI image into memory and returns a handle to the image.
1311
1312 @param BootPolicy If TRUE, indicates that the request originates
1313 from the boot manager, and that the boot
1314 manager is attempting to load FilePath as a
1315 boot selection.
1316 @param ParentImageHandle The caller's image handle.
1317 @param FilePath The specific file path from which the image is
1318 loaded.
1319 @param SourceBuffer If not NULL, a pointer to the memory location
1320 containing a copy of the image to be loaded.
1321 @param SourceSize The size in bytes of SourceBuffer.
1322 @param ImageHandle Pointer to the returned image handle that is
1323 created when the image is successfully loaded.
1324
1325 @retval EFI_SUCCESS The image was loaded into memory.
1326 @retval EFI_NOT_FOUND The FilePath was not found.
1327 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1328 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1329 path cannot be parsed to locate the proper
1330 protocol for loading the file.
1331 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1332 resources.
1333 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1334 understood.
1335 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1336 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1337 image from being loaded. NULL is returned in *ImageHandle.
1338 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1339 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1340 platform policy specifies that the image should not be started.
1341
1342 **/
1343 EFI_STATUS
1344 EFIAPI
1345 CoreLoadImage (
1346 IN BOOLEAN BootPolicy,
1347 IN EFI_HANDLE ParentImageHandle,
1348 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
1349 IN VOID *SourceBuffer OPTIONAL,
1350 IN UINTN SourceSize,
1351 OUT EFI_HANDLE *ImageHandle
1352 )
1353 {
1354 EFI_STATUS Status;
1355 UINT64 Tick;
1356 EFI_HANDLE Handle;
1357
1358 Tick = 0;
1359 PERF_CODE (
1360 Tick = GetPerformanceCounter ();
1361 );
1362
1363 Status = CoreLoadImageCommon (
1364 BootPolicy,
1365 ParentImageHandle,
1366 FilePath,
1367 SourceBuffer,
1368 SourceSize,
1369 (EFI_PHYSICAL_ADDRESS) (UINTN) NULL,
1370 NULL,
1371 ImageHandle,
1372 NULL,
1373 EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION | EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION
1374 );
1375
1376 Handle = NULL;
1377 if (!EFI_ERROR (Status)) {
1378 //
1379 // ImageHandle will be valid only Status is success.
1380 //
1381 Handle = *ImageHandle;
1382 }
1383
1384 PERF_START (Handle, "LoadImage:", NULL, Tick);
1385 PERF_END (Handle, "LoadImage:", NULL, 0);
1386
1387 return Status;
1388 }
1389
1390
1391
1392 /**
1393 Loads an EFI image into memory and returns a handle to the image with extended parameters.
1394
1395 @param This Calling context
1396 @param ParentImageHandle The caller's image handle.
1397 @param FilePath The specific file path from which the image is
1398 loaded.
1399 @param SourceBuffer If not NULL, a pointer to the memory location
1400 containing a copy of the image to be loaded.
1401 @param SourceSize The size in bytes of SourceBuffer.
1402 @param DstBuffer The buffer to store the image.
1403 @param NumberOfPages For input, specifies the space size of the
1404 image by caller if not NULL. For output,
1405 specifies the actual space size needed.
1406 @param ImageHandle Image handle for output.
1407 @param EntryPoint Image entry point for output.
1408 @param Attribute The bit mask of attributes to set for the load
1409 PE image.
1410
1411 @retval EFI_SUCCESS The image was loaded into memory.
1412 @retval EFI_NOT_FOUND The FilePath was not found.
1413 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1414 @retval EFI_UNSUPPORTED The image type is not supported, or the device
1415 path cannot be parsed to locate the proper
1416 protocol for loading the file.
1417 @retval EFI_OUT_OF_RESOURCES Image was not loaded due to insufficient
1418 resources.
1419 @retval EFI_LOAD_ERROR Image was not loaded because the image format was corrupt or not
1420 understood.
1421 @retval EFI_DEVICE_ERROR Image was not loaded because the device returned a read error.
1422 @retval EFI_ACCESS_DENIED Image was not loaded because the platform policy prohibits the
1423 image from being loaded. NULL is returned in *ImageHandle.
1424 @retval EFI_SECURITY_VIOLATION Image was loaded and an ImageHandle was created with a
1425 valid EFI_LOADED_IMAGE_PROTOCOL. However, the current
1426 platform policy specifies that the image should not be started.
1427
1428 **/
1429 EFI_STATUS
1430 EFIAPI
1431 CoreLoadImageEx (
1432 IN EFI_PE32_IMAGE_PROTOCOL *This,
1433 IN EFI_HANDLE ParentImageHandle,
1434 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
1435 IN VOID *SourceBuffer OPTIONAL,
1436 IN UINTN SourceSize,
1437 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
1438 OUT UINTN *NumberOfPages OPTIONAL,
1439 OUT EFI_HANDLE *ImageHandle,
1440 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
1441 IN UINT32 Attribute
1442 )
1443 {
1444 return CoreLoadImageCommon (
1445 TRUE,
1446 ParentImageHandle,
1447 FilePath,
1448 SourceBuffer,
1449 SourceSize,
1450 DstBuffer,
1451 NumberOfPages,
1452 ImageHandle,
1453 EntryPoint,
1454 Attribute
1455 );
1456 }
1457
1458
1459 /**
1460 Transfer control to a loaded image's entry point.
1461
1462 @param ImageHandle Handle of image to be started.
1463 @param ExitDataSize Pointer of the size to ExitData
1464 @param ExitData Pointer to a pointer to a data buffer that
1465 includes a Null-terminated string,
1466 optionally followed by additional binary data.
1467 The string is a description that the caller may
1468 use to further indicate the reason for the
1469 image's exit.
1470
1471 @retval EFI_INVALID_PARAMETER Invalid parameter
1472 @retval EFI_OUT_OF_RESOURCES No enough buffer to allocate
1473 @retval EFI_SUCCESS Successfully transfer control to the image's
1474 entry point.
1475
1476 **/
1477 EFI_STATUS
1478 EFIAPI
1479 CoreStartImage (
1480 IN EFI_HANDLE ImageHandle,
1481 OUT UINTN *ExitDataSize,
1482 OUT CHAR16 **ExitData OPTIONAL
1483 )
1484 {
1485 EFI_STATUS Status;
1486 LOADED_IMAGE_PRIVATE_DATA *Image;
1487 LOADED_IMAGE_PRIVATE_DATA *LastImage;
1488 UINT64 HandleDatabaseKey;
1489 UINTN SetJumpFlag;
1490
1491 Image = CoreLoadedImageInfo (ImageHandle);
1492 if (Image == NULL || Image->Started) {
1493 return EFI_INVALID_PARAMETER;
1494 }
1495
1496 //
1497 // The image to be started must have the machine type supported by DxeCore.
1498 //
1499 if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Image->Machine)) {
1500 //
1501 // Do not ASSERT here, because image might be loaded via EFI_IMAGE_MACHINE_CROSS_TYPE_SUPPORTED
1502 // But it can not be started.
1503 //
1504 DEBUG ((EFI_D_ERROR, "Image type %s can't be started ", GetMachineTypeName(Image->Machine)));
1505 DEBUG ((EFI_D_ERROR, "on %s UEFI system.\n", GetMachineTypeName(mDxeCoreImageMachineType)));
1506 return EFI_UNSUPPORTED;
1507 }
1508
1509 //
1510 // Don't profile Objects or invalid start requests
1511 //
1512 PERF_START (ImageHandle, "StartImage:", NULL, 0);
1513
1514
1515 //
1516 // Push the current start image context, and
1517 // link the current image to the head. This is the
1518 // only image that can call Exit()
1519 //
1520 HandleDatabaseKey = CoreGetHandleDatabaseKey ();
1521 LastImage = mCurrentImage;
1522 mCurrentImage = Image;
1523 Image->Tpl = gEfiCurrentTpl;
1524
1525 //
1526 // Set long jump for Exit() support
1527 // JumpContext must be aligned on a CPU specific boundary.
1528 // Overallocate the buffer and force the required alignment
1529 //
1530 Image->JumpBuffer = AllocatePool (sizeof (BASE_LIBRARY_JUMP_BUFFER) + BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT);
1531 if (Image->JumpBuffer == NULL) {
1532 PERF_END (ImageHandle, "StartImage:", NULL, 0);
1533 return EFI_OUT_OF_RESOURCES;
1534 }
1535 Image->JumpContext = ALIGN_POINTER (Image->JumpBuffer, BASE_LIBRARY_JUMP_BUFFER_ALIGNMENT);
1536
1537 SetJumpFlag = SetJump (Image->JumpContext);
1538 //
1539 // The initial call to SetJump() must always return 0.
1540 // Subsequent calls to LongJump() cause a non-zero value to be returned by SetJump().
1541 //
1542 if (SetJumpFlag == 0) {
1543 //
1544 // Call the image's entry point
1545 //
1546 Image->Started = TRUE;
1547 Image->Status = Image->EntryPoint (ImageHandle, Image->Info.SystemTable);
1548
1549 //
1550 // Add some debug information if the image returned with error.
1551 // This make the user aware and check if the driver image have already released
1552 // all the resource in this situation.
1553 //
1554 DEBUG_CODE_BEGIN ();
1555 if (EFI_ERROR (Image->Status)) {
1556 DEBUG ((DEBUG_ERROR, "Error: Image at %11p start failed: %r\n", Image->Info.ImageBase, Image->Status));
1557 }
1558 DEBUG_CODE_END ();
1559
1560 //
1561 // If the image returns, exit it through Exit()
1562 //
1563 CoreExit (ImageHandle, Image->Status, 0, NULL);
1564 }
1565
1566 //
1567 // Image has completed. Verify the tpl is the same
1568 //
1569 ASSERT (Image->Tpl == gEfiCurrentTpl);
1570 CoreRestoreTpl (Image->Tpl);
1571
1572 CoreFreePool (Image->JumpBuffer);
1573
1574 //
1575 // Pop the current start image context
1576 //
1577 mCurrentImage = LastImage;
1578
1579 //
1580 // Go connect any handles that were created or modified while the image executed.
1581 //
1582 CoreConnectHandlesByKey (HandleDatabaseKey);
1583
1584 //
1585 // Handle the image's returned ExitData
1586 //
1587 DEBUG_CODE_BEGIN ();
1588 if (Image->ExitDataSize != 0 || Image->ExitData != NULL) {
1589
1590 DEBUG ((DEBUG_LOAD, "StartImage: ExitDataSize %d, ExitData %p", (UINT32)Image->ExitDataSize, Image->ExitData));
1591 if (Image->ExitData != NULL) {
1592 DEBUG ((DEBUG_LOAD, " (%hs)", Image->ExitData));
1593 }
1594 DEBUG ((DEBUG_LOAD, "\n"));
1595 }
1596 DEBUG_CODE_END ();
1597
1598 //
1599 // Return the exit data to the caller
1600 //
1601 if (ExitData != NULL && ExitDataSize != NULL) {
1602 *ExitDataSize = Image->ExitDataSize;
1603 *ExitData = Image->ExitData;
1604 } else {
1605 //
1606 // Caller doesn't want the exit data, free it
1607 //
1608 CoreFreePool (Image->ExitData);
1609 Image->ExitData = NULL;
1610 }
1611
1612 //
1613 // Save the Status because Image will get destroyed if it is unloaded.
1614 //
1615 Status = Image->Status;
1616
1617 //
1618 // If the image returned an error, or if the image is an application
1619 // unload it
1620 //
1621 if (EFI_ERROR (Image->Status) || Image->Type == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1622 CoreUnloadAndCloseImage (Image, TRUE);
1623 }
1624
1625 //
1626 // Done
1627 //
1628 PERF_END (ImageHandle, "StartImage:", NULL, 0);
1629 return Status;
1630 }
1631
1632 /**
1633 Terminates the currently loaded EFI image and returns control to boot services.
1634
1635 @param ImageHandle Handle that identifies the image. This
1636 parameter is passed to the image on entry.
1637 @param Status The image's exit code.
1638 @param ExitDataSize The size, in bytes, of ExitData. Ignored if
1639 ExitStatus is EFI_SUCCESS.
1640 @param ExitData Pointer to a data buffer that includes a
1641 Null-terminated Unicode string, optionally
1642 followed by additional binary data. The string
1643 is a description that the caller may use to
1644 further indicate the reason for the image's
1645 exit.
1646
1647 @retval EFI_INVALID_PARAMETER Image handle is NULL or it is not current
1648 image.
1649 @retval EFI_SUCCESS Successfully terminates the currently loaded
1650 EFI image.
1651 @retval EFI_ACCESS_DENIED Should never reach there.
1652 @retval EFI_OUT_OF_RESOURCES Could not allocate pool
1653
1654 **/
1655 EFI_STATUS
1656 EFIAPI
1657 CoreExit (
1658 IN EFI_HANDLE ImageHandle,
1659 IN EFI_STATUS Status,
1660 IN UINTN ExitDataSize,
1661 IN CHAR16 *ExitData OPTIONAL
1662 )
1663 {
1664 LOADED_IMAGE_PRIVATE_DATA *Image;
1665 EFI_TPL OldTpl;
1666
1667 //
1668 // Prevent possible reentrance to this function
1669 // for the same ImageHandle
1670 //
1671 OldTpl = CoreRaiseTpl (TPL_NOTIFY);
1672
1673 Image = CoreLoadedImageInfo (ImageHandle);
1674 if (Image == NULL) {
1675 Status = EFI_INVALID_PARAMETER;
1676 goto Done;
1677 }
1678
1679 if (!Image->Started) {
1680 //
1681 // The image has not been started so just free its resources
1682 //
1683 CoreUnloadAndCloseImage (Image, TRUE);
1684 Status = EFI_SUCCESS;
1685 goto Done;
1686 }
1687
1688 //
1689 // Image has been started, verify this image can exit
1690 //
1691 if (Image != mCurrentImage) {
1692 DEBUG ((DEBUG_LOAD|DEBUG_ERROR, "Exit: Image is not exitable image\n"));
1693 Status = EFI_INVALID_PARAMETER;
1694 goto Done;
1695 }
1696
1697 //
1698 // Set status
1699 //
1700 Image->Status = Status;
1701
1702 //
1703 // If there's ExitData info, move it
1704 //
1705 if (ExitData != NULL) {
1706 Image->ExitDataSize = ExitDataSize;
1707 Image->ExitData = AllocatePool (Image->ExitDataSize);
1708 if (Image->ExitData == NULL) {
1709 Status = EFI_OUT_OF_RESOURCES;
1710 goto Done;
1711 }
1712 CopyMem (Image->ExitData, ExitData, Image->ExitDataSize);
1713 }
1714
1715 CoreRestoreTpl (OldTpl);
1716 //
1717 // return to StartImage
1718 //
1719 LongJump (Image->JumpContext, (UINTN)-1);
1720
1721 //
1722 // If we return from LongJump, then it is an error
1723 //
1724 ASSERT (FALSE);
1725 Status = EFI_ACCESS_DENIED;
1726 Done:
1727 CoreRestoreTpl (OldTpl);
1728 return Status;
1729 }
1730
1731
1732
1733
1734 /**
1735 Unloads an image.
1736
1737 @param ImageHandle Handle that identifies the image to be
1738 unloaded.
1739
1740 @retval EFI_SUCCESS The image has been unloaded.
1741 @retval EFI_UNSUPPORTED The image has been sarted, and does not support
1742 unload.
1743 @retval EFI_INVALID_PARAMPETER ImageHandle is not a valid image handle.
1744
1745 **/
1746 EFI_STATUS
1747 EFIAPI
1748 CoreUnloadImage (
1749 IN EFI_HANDLE ImageHandle
1750 )
1751 {
1752 EFI_STATUS Status;
1753 LOADED_IMAGE_PRIVATE_DATA *Image;
1754
1755 Image = CoreLoadedImageInfo (ImageHandle);
1756 if (Image == NULL ) {
1757 //
1758 // The image handle is not valid
1759 //
1760 Status = EFI_INVALID_PARAMETER;
1761 goto Done;
1762 }
1763
1764 if (Image->Started) {
1765 //
1766 // The image has been started, request it to unload.
1767 //
1768 Status = EFI_UNSUPPORTED;
1769 if (Image->Info.Unload != NULL) {
1770 Status = Image->Info.Unload (ImageHandle);
1771 }
1772
1773 } else {
1774 //
1775 // This Image hasn't been started, thus it can be unloaded
1776 //
1777 Status = EFI_SUCCESS;
1778 }
1779
1780
1781 if (!EFI_ERROR (Status)) {
1782 //
1783 // if the Image was not started or Unloaded O.K. then clean up
1784 //
1785 CoreUnloadAndCloseImage (Image, TRUE);
1786 }
1787
1788 Done:
1789 return Status;
1790 }
1791
1792
1793
1794 /**
1795 Unload the specified image.
1796
1797 @param This Indicates the calling context.
1798 @param ImageHandle The specified image handle.
1799
1800 @retval EFI_INVALID_PARAMETER Image handle is NULL.
1801 @retval EFI_UNSUPPORTED Attempt to unload an unsupported image.
1802 @retval EFI_SUCCESS Image successfully unloaded.
1803
1804 **/
1805 EFI_STATUS
1806 EFIAPI
1807 CoreUnloadImageEx (
1808 IN EFI_PE32_IMAGE_PROTOCOL *This,
1809 IN EFI_HANDLE ImageHandle
1810 )
1811 {
1812 return CoreUnloadImage (ImageHandle);
1813 }
EFI Development Kit II mirror for PVE