I fixed following bugs in EDKII.
[mirror_edk2.git] / EdkModulePkg / Core / Dxe / Image / Image.c
1 /*++
2
3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 Image.c
15
16 Abstract:
17
18 Core image handling services
19
20 --*/
21
22 #include <DxeMain.h>
23 //
24 // Module Globals
25 //
26
27 //
28 // LIST of runtime images that need to be relocated.
29 //
30 LIST_ENTRY mRuntimeImageList = INITIALIZE_LIST_HEAD_VARIABLE (mRuntimeImageList);
31
32 LOADED_IMAGE_PRIVATE_DATA *mCurrentImage = NULL;
33
34 LOAD_PE32_IMAGE_PRIVATE_DATA mLoadPe32PrivateData = {
35 LOAD_PE32_IMAGE_PRIVATE_DATA_SIGNATURE,
36 NULL,
37 {
38 CoreLoadImageEx,
39 CoreUnloadImageEx
40 }
41 };
42
43
44 //
45 // This code is needed to build the Image handle for the DXE Core
46 //
47 LOADED_IMAGE_PRIVATE_DATA mCorePrivateImage = {
48 LOADED_IMAGE_PRIVATE_DATA_SIGNATURE, // Signature
49 NULL, // Image handle
50 EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER, // Image type
51 TRUE, // If entrypoint has been called
52 NULL, // EntryPoint
53 {
54 EFI_LOADED_IMAGE_INFORMATION_REVISION, // Revision
55 NULL, // Parent handle
56 NULL, // System handle
57
58 NULL, // Device handle
59 NULL, // File path
60 NULL, // Reserved
61
62 0, // LoadOptionsSize
63 NULL, // LoadOptions
64
65 NULL, // ImageBase
66 0, // ImageSize
67 EfiBootServicesCode, // ImageCodeType
68 EfiBootServicesData // ImageDataType
69 },
70 (EFI_PHYSICAL_ADDRESS)0, // ImageBasePage
71 0, // NumberOfPages
72 NULL, // FixupData
73 0, // Tpl
74 EFI_SUCCESS, // Status
75 0, // ExitDataSize
76 NULL, // ExitData
77 NULL, // JumpContext
78 0, // Machine
79 NULL, // Ebc
80 FALSE, // RuntimeFixupValid
81 NULL, // RuntimeFixup
82 { NULL, NULL }, // Link
83 };
84
85
86 EFI_STATUS
87 CoreInitializeImageServices (
88 IN VOID *HobStart
89 )
90 /*++
91
92 Routine Description:
93
94 Add the Image Services to EFI Boot Services Table and install the protocol
95 interfaces for this image.
96
97 Arguments:
98
99 HobStart - The HOB to initialize
100
101 Returns:
102
103 Status code.
104
105 --*/
106 {
107 EFI_STATUS Status;
108 LOADED_IMAGE_PRIVATE_DATA *Image;
109 EFI_PHYSICAL_ADDRESS DxeCoreImageBaseAddress;
110 UINT64 DxeCoreImageLength;
111 VOID *DxeCoreEntryPoint;
112 EFI_PEI_HOB_POINTERS DxeCoreHob;
113 //
114 // Searching for image hob
115 //
116 DxeCoreHob.Raw = HobStart;
117 while ((DxeCoreHob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, DxeCoreHob.Raw)) != NULL) {
118 if (CompareGuid (&DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.Name, &gEfiHobMemoryAllocModuleGuid)) {
119 //
120 // Find Dxe Core HOB
121 //
122 break;
123 }
124 DxeCoreHob.Raw = GET_NEXT_HOB (DxeCoreHob);
125 }
126 ASSERT (DxeCoreHob.Raw != NULL);
127
128 DxeCoreImageBaseAddress = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryBaseAddress;
129 DxeCoreImageLength = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryLength;
130 DxeCoreEntryPoint = (VOID *) (UINTN) DxeCoreHob.MemoryAllocationModule->EntryPoint;
131 gDxeCoreFileName = &DxeCoreHob.MemoryAllocationModule->ModuleName;
132 //
133 // Initialize the fields for an internal driver
134 //
135 Image = &mCorePrivateImage;
136
137 Image->EntryPoint = (EFI_IMAGE_ENTRY_POINT)(UINTN)DxeCoreEntryPoint;
138 Image->ImageBasePage = DxeCoreImageBaseAddress;
139 Image->NumberOfPages = (UINTN)(EFI_SIZE_TO_PAGES((UINTN)(DxeCoreImageLength)));
140 Image->Tpl = gEfiCurrentTpl;
141 Image->Info.SystemTable = gST;
142 Image->Info.ImageBase = (VOID *)(UINTN)DxeCoreImageBaseAddress;
143 Image->Info.ImageSize = DxeCoreImageLength;
144
145 //
146 // Install the protocol interfaces for this image
147 //
148 Status = CoreInstallProtocolInterface (
149 &Image->Handle,
150 &gEfiLoadedImageProtocolGuid,
151 EFI_NATIVE_INTERFACE,
152 &Image->Info
153 );
154 ASSERT_EFI_ERROR (Status);
155
156 mCurrentImage = Image;
157
158 //
159 // Fill in DXE globals
160 //
161 gDxeCoreImageHandle = Image->Handle;
162 gDxeCoreLoadedImage = &Image->Info;
163
164 //
165 // Export DXE Core PE Loader functionality
166 //
167 return CoreInstallProtocolInterface (
168 &mLoadPe32PrivateData.Handle,
169 &gEfiLoadPeImageProtocolGuid,
170 EFI_NATIVE_INTERFACE,
171 &mLoadPe32PrivateData.Pe32Image
172 );
173 }
174
175
176 EFI_STATUS
177 CoreShutdownImageServices (
178 VOID
179 )
180 /*++
181
182 Routine Description:
183
184 Transfer control of runtime images to runtime service
185
186 Arguments:
187
188 None
189
190 Returns:
191
192 EFI_SUCCESS - Function successfully returned
193
194 --*/
195 {
196 LIST_ENTRY *Link;
197 LOADED_IMAGE_PRIVATE_DATA *Image;
198
199 //
200 // The Runtime AP is required for the core to function!
201 //
202 ASSERT (gRuntime != NULL);
203
204 for (Link = mRuntimeImageList.ForwardLink; Link != &mRuntimeImageList; Link = Link->ForwardLink) {
205 Image = CR (Link, LOADED_IMAGE_PRIVATE_DATA, Link, LOADED_IMAGE_PRIVATE_DATA_SIGNATURE);
206 if (Image->RuntimeFixupValid) {
207 gRuntime->RegisterImage (
208 gRuntime,
209 (UINT64)(UINTN)(Image->Info.ImageBase),
210 (EFI_SIZE_TO_PAGES ((UINTN)Image->Info.ImageSize)),
211 Image->RuntimeFixup
212 );
213 }
214 }
215
216 return EFI_SUCCESS;
217 }
218
219
220
221 EFI_STATUS
222 CoreLoadPeImage (
223 IN VOID *Pe32Handle,
224 IN LOADED_IMAGE_PRIVATE_DATA *Image,
225 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
226 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
227 IN UINT32 Attribute
228 )
229 /*++
230
231 Routine Description:
232
233 Loads, relocates, and invokes a PE/COFF image
234
235 Arguments:
236
237 Pe32Handle - The handle of PE32 image
238 Image - PE image to be loaded
239 DstBuffer - The buffer to store the image
240 EntryPoint - A pointer to the entry point
241 Attribute - The bit mask of attributes to set for the load PE image
242
243 Returns:
244
245 EFI_SUCCESS - The file was loaded, relocated, and invoked
246
247 EFI_OUT_OF_RESOURCES - There was not enough memory to load and relocate the PE/COFF file
248
249 EFI_INVALID_PARAMETER - Invalid parameter
250
251 EFI_BUFFER_TOO_SMALL - Buffer for image is too small
252
253 --*/
254 {
255 EFI_STATUS Status;
256 UINTN Size;
257
258 ZeroMem (&Image->ImageContext, sizeof (Image->ImageContext));
259
260 Image->ImageContext.Handle = Pe32Handle;
261 Image->ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE)CoreReadImageFile;
262
263 //
264 // Get information about the image being loaded
265 //
266 Status = gEfiPeiPeCoffLoader->GetImageInfo (gEfiPeiPeCoffLoader, &Image->ImageContext);
267 if (EFI_ERROR (Status)) {
268 return Status;
269 }
270
271 if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Image->ImageContext.Machine)) {
272 //
273 // The PE/COFF loader can support loading image types that can be executed.
274 // If we loaded an image type that we can not execute return EFI_UNSUPORTED.
275 //
276 return EFI_UNSUPPORTED;
277 }
278
279
280 //
281 // Allocate memory of the correct memory type aligned on the required image boundry
282 //
283
284 if (DstBuffer == 0) {
285 //
286 // Allocate Destination Buffer as caller did not pass it in
287 //
288
289 if (Image->ImageContext.SectionAlignment > EFI_PAGE_SIZE) {
290 Size = (UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment;
291 } else {
292 Size = (UINTN)Image->ImageContext.ImageSize;
293 }
294
295 Image->NumberOfPages = EFI_SIZE_TO_PAGES (Size);
296
297 //
298 // If the image relocations have not been stripped, then load at any address.
299 // Otherwise load at the address at which it was linked.
300 //
301 Status = CoreAllocatePages (
302 (Image->ImageContext.RelocationsStripped) ? AllocateAddress : AllocateAnyPages,
303 Image->ImageContext.ImageCodeMemoryType,
304 Image->NumberOfPages,
305 &Image->ImageContext.ImageAddress
306 );
307 if (EFI_ERROR (Status)) {
308 return Status;
309 }
310
311 Image->ImageBasePage = Image->ImageContext.ImageAddress;
312
313 } else {
314 //
315 // Caller provided the destination buffer
316 //
317
318 if (Image->ImageContext.RelocationsStripped && (Image->ImageContext.ImageAddress != DstBuffer)) {
319 //
320 // If the image relocations were stripped, and the caller provided a
321 // destination buffer address that does not match the address that the
322 // image is linked at, then the image cannot be loaded.
323 //
324 return EFI_INVALID_PARAMETER;
325 }
326
327 if (Image->NumberOfPages != 0 &&
328 Image->NumberOfPages <
329 (EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment))) {
330 Image->NumberOfPages = EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment);
331 return EFI_BUFFER_TOO_SMALL;
332 }
333
334 Image->NumberOfPages = EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment);
335 Image->ImageContext.ImageAddress = DstBuffer;
336 Image->ImageBasePage = Image->ImageContext.ImageAddress;
337 }
338
339 Image->ImageContext.ImageAddress =
340 (Image->ImageContext.ImageAddress + Image->ImageContext.SectionAlignment - 1) &
341 ~((UINTN)Image->ImageContext.SectionAlignment - 1);
342
343 //
344 // Load the image from the file into the allocated memory
345 //
346 Status = gEfiPeiPeCoffLoader->LoadImage (gEfiPeiPeCoffLoader, &Image->ImageContext);
347 if (EFI_ERROR (Status)) {
348 return Status;
349 }
350
351 //
352 // If this is a Runtime Driver, then allocate memory for the FixupData that
353 // is used to relocate the image when SetVirtualAddressMap() is called. The
354 // relocation is done by the Runtime AP.
355 //
356 if (Attribute & EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION) {
357 if (Image->ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) {
358 Image->ImageContext.FixupData = CoreAllocateRuntimePool ((UINTN)(Image->ImageContext.FixupDataSize));
359 if (Image->ImageContext.FixupData == NULL) {
360 Status = EFI_OUT_OF_RESOURCES;
361 goto Done;
362 }
363
364 //
365 // Make a list off all the RT images so we can let the RT AP know about them
366 //
367 Image->RuntimeFixupValid = TRUE;
368 Image->RuntimeFixup = Image->ImageContext.FixupData;
369 InsertTailList (&mRuntimeImageList, &Image->Link);
370 }
371 }
372
373 //
374 // Relocate the image in memory
375 //
376 Status = gEfiPeiPeCoffLoader->RelocateImage (gEfiPeiPeCoffLoader, &Image->ImageContext);
377 if (EFI_ERROR (Status)) {
378 return Status;
379 }
380
381 //
382 // Flush the Instruction Cache
383 //
384 InvalidateInstructionCacheRange ((VOID *)(UINTN)Image->ImageContext.ImageAddress, (UINTN)Image->ImageContext.ImageSize);
385
386 //
387 // Copy the machine type from the context to the image private data. This
388 // is needed during image unload to know if we should call an EBC protocol
389 // to unload the image.
390 //
391 Image->Machine = Image->ImageContext.Machine;
392
393 //
394 // Get the image entry point. If it's an EBC image, then call into the
395 // interpreter to create a thunk for the entry point and use the returned
396 // value for the entry point.
397 //
398 Image->EntryPoint = (EFI_IMAGE_ENTRY_POINT)(UINTN)Image->ImageContext.EntryPoint;
399 if (Image->ImageContext.Machine == EFI_IMAGE_MACHINE_EBC) {
400 //
401 // Locate the EBC interpreter protocol
402 //
403 Status = CoreLocateProtocol (&gEfiEbcProtocolGuid, NULL, (VOID **)&Image->Ebc);
404 if (EFI_ERROR(Status)) {
405 goto Done;
406 }
407
408 //
409 // Register a callback for flushing the instruction cache so that created
410 // thunks can be flushed.
411 //
412 Status = Image->Ebc->RegisterICacheFlush (Image->Ebc, (EBC_ICACHE_FLUSH)InvalidateInstructionCacheRange);
413 if (EFI_ERROR(Status)) {
414 goto Done;
415 }
416
417 //
418 // Create a thunk for the image's entry point. This will be the new
419 // entry point for the image.
420 //
421 Status = Image->Ebc->CreateThunk (
422 Image->Ebc,
423 Image->Handle,
424 (VOID *)(UINTN)Image->ImageContext.EntryPoint,
425 (VOID **)&Image->EntryPoint
426 );
427 if (EFI_ERROR(Status)) {
428 goto Done;
429 }
430 }
431
432 //
433 // Fill in the image information for the Loaded Image Protocol
434 //
435 Image->Type = Image->ImageContext.ImageType;
436 Image->Info.ImageBase = (VOID *)(UINTN)Image->ImageContext.ImageAddress;
437 Image->Info.ImageSize = Image->ImageContext.ImageSize;
438 Image->Info.ImageCodeType = Image->ImageContext.ImageCodeMemoryType;
439 Image->Info.ImageDataType = Image->ImageContext.ImageDataMemoryType;
440
441 //
442 // Fill in the entry point of the image if it is available
443 //
444 if (EntryPoint != NULL) {
445 *EntryPoint = Image->ImageContext.EntryPoint;
446 }
447
448 //
449 // Print the load address and the PDB file name if it is available
450 //
451
452 DEBUG_CODE_BEGIN ();
453
454 UINTN Index;
455 UINTN StartIndex;
456 CHAR8 EfiFileName[256];
457
458 DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Loading driver at 0x%08x EntryPoint=0x%08x ", (UINTN)Image->ImageContext.ImageAddress, (UINTN)Image->ImageContext.EntryPoint));
459 if (Image->ImageContext.PdbPointer != NULL) {
460 StartIndex = 0;
461 for (Index = 0; Image->ImageContext.PdbPointer[Index] != 0; Index++) {
462 if (Image->ImageContext.PdbPointer[Index] == '\\') {
463 StartIndex = Index + 1;
464 }
465 }
466 //
467 // Copy the PDB file name to our temporary string, and replace .pdb with .efi
468 //
469 for (Index = 0; Index < sizeof (EfiFileName); Index++) {
470 EfiFileName[Index] = Image->ImageContext.PdbPointer[Index + StartIndex];
471 if (EfiFileName[Index] == 0) {
472 EfiFileName[Index] = '.';
473 }
474 if (EfiFileName[Index] == '.') {
475 EfiFileName[Index + 1] = 'e';
476 EfiFileName[Index + 2] = 'f';
477 EfiFileName[Index + 3] = 'i';
478 EfiFileName[Index + 4] = 0;
479 break;
480 }
481 }
482 DEBUG ((EFI_D_INFO | EFI_D_LOAD, "%a", EfiFileName)); // &Image->ImageContext.PdbPointer[StartIndex]));
483 }
484 DEBUG ((EFI_D_INFO | EFI_D_LOAD, "\n"));
485
486 DEBUG_CODE_END ();
487
488 return EFI_SUCCESS;
489
490 Done:
491 //
492 // Free memory
493 //
494 CoreFreePages (Image->ImageContext.ImageAddress, Image->NumberOfPages);
495 return Status;
496 }
497
498
499 LOADED_IMAGE_PRIVATE_DATA *
500 CoreLoadedImageInfo (
501 IN EFI_HANDLE ImageHandle
502 )
503 /*++
504
505 Routine Description:
506
507 Get the image's private data from its handle.
508
509 Arguments:
510
511 ImageHandle - The image handle
512
513 Returns:
514
515 Return the image private data associated with ImageHandle.
516
517 --*/
518 {
519 EFI_STATUS Status;
520 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
521 LOADED_IMAGE_PRIVATE_DATA *Image;
522
523 Status = CoreHandleProtocol (
524 ImageHandle,
525 &gEfiLoadedImageProtocolGuid,
526 (VOID **)&LoadedImage
527 );
528 if (!EFI_ERROR (Status)) {
529 Image = LOADED_IMAGE_PRIVATE_DATA_FROM_THIS (LoadedImage);
530 } else {
531 DEBUG ((EFI_D_LOAD, "CoreLoadedImageInfo: Not an ImageHandle %x\n", ImageHandle));
532 Image = NULL;
533 }
534
535 return Image;
536 }
537
538
539 EFI_STATUS
540 CoreLoadImageCommon (
541 IN BOOLEAN BootPolicy,
542 IN EFI_HANDLE ParentImageHandle,
543 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
544 IN VOID *SourceBuffer OPTIONAL,
545 IN UINTN SourceSize,
546 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
547 IN OUT UINTN *NumberOfPages OPTIONAL,
548 OUT EFI_HANDLE *ImageHandle,
549 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
550 IN UINT32 Attribute
551 )
552 /*++
553
554 Routine Description:
555
556 Loads an EFI image into memory and returns a handle to the image.
557
558 Arguments:
559
560 BootPolicy - If TRUE, indicates that the request originates from the boot manager,
561 and that the boot manager is attempting to load FilePath as a boot selection.
562 ParentImageHandle - The caller's image handle.
563 FilePath - The specific file path from which the image is loaded.
564 SourceBuffer - If not NULL, a pointer to the memory location containing a copy of
565 the image to be loaded.
566 SourceSize - The size in bytes of SourceBuffer.
567 DstBuffer - The buffer to store the image
568 NumberOfPages - If not NULL, a pointer to the image's page number, if this number
569 is not enough, return EFI_BUFFER_TOO_SMALL and this parameter contain
570 the required number.
571 ImageHandle - Pointer to the returned image handle that is created when the image
572 is successfully loaded.
573 EntryPoint - A pointer to the entry point
574 Attribute - The bit mask of attributes to set for the load PE image
575
576 Returns:
577
578 EFI_SUCCESS - The image was loaded into memory.
579 EFI_NOT_FOUND - The FilePath was not found.
580 EFI_INVALID_PARAMETER - One of the parameters has an invalid value.
581 EFI_BUFFER_TOO_SMALL - The buffer is too small
582 EFI_UNSUPPORTED - The image type is not supported, or the device path cannot be
583 parsed to locate the proper protocol for loading the file.
584 EFI_OUT_OF_RESOURCES - Image was not loaded due to insufficient resources.
585 --*/
586 {
587 LOADED_IMAGE_PRIVATE_DATA *Image;
588 LOADED_IMAGE_PRIVATE_DATA *ParentImage;
589 IMAGE_FILE_HANDLE FHand;
590 EFI_STATUS Status;
591 EFI_STATUS SecurityStatus;
592 EFI_HANDLE DeviceHandle;
593 UINT32 AuthenticationStatus;
594 EFI_DEVICE_PATH_PROTOCOL *OriginalFilePath;
595 EFI_DEVICE_PATH_PROTOCOL *HandleFilePath;
596 UINTN FilePathSize;
597
598 SecurityStatus = EFI_SUCCESS;
599
600 ASSERT (gEfiCurrentTpl < EFI_TPL_NOTIFY);
601 ParentImage = NULL;
602
603 //
604 // The caller must pass in a valid ParentImageHandle
605 //
606 if (ImageHandle == NULL || ParentImageHandle == NULL) {
607 return EFI_INVALID_PARAMETER;
608 }
609
610 ParentImage = CoreLoadedImageInfo (ParentImageHandle);
611 if (ParentImage == NULL) {
612 DEBUG((EFI_D_LOAD|EFI_D_ERROR, "LoadImageEx: Parent handle not an image handle\n"));
613 return EFI_INVALID_PARAMETER;
614 }
615
616 //
617 // Get simple read access to the source file
618 //
619 OriginalFilePath = FilePath;
620 Status = CoreOpenImageFile (
621 BootPolicy,
622 SourceBuffer,
623 SourceSize,
624 FilePath,
625 &DeviceHandle,
626 &FHand,
627 &AuthenticationStatus
628 );
629 if (Status == EFI_ALREADY_STARTED) {
630 Image = NULL;
631 goto Done;
632 } else if (EFI_ERROR (Status)) {
633 return Status;
634 }
635
636 //
637 // Verify the Authentication Status through the Security Architectural Protocol
638 //
639 if ((gSecurity != NULL) && (OriginalFilePath != NULL)) {
640 SecurityStatus = gSecurity->FileAuthenticationState (
641 gSecurity,
642 AuthenticationStatus,
643 OriginalFilePath
644 );
645 if (EFI_ERROR (SecurityStatus) && SecurityStatus != EFI_SECURITY_VIOLATION) {
646 Status = SecurityStatus;
647 Image = NULL;
648 goto Done;
649 }
650 }
651
652
653 //
654 // Allocate a new image structure
655 //
656 Image = CoreAllocateZeroBootServicesPool (sizeof(LOADED_IMAGE_PRIVATE_DATA));
657 if (Image == NULL) {
658 return EFI_OUT_OF_RESOURCES;
659 }
660
661 //
662 // Pull out just the file portion of the DevicePath for the LoadedImage FilePath
663 //
664 Status = CoreHandleProtocol (DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **)&HandleFilePath);
665 if (!EFI_ERROR (Status)) {
666 FilePathSize = CoreDevicePathSize (HandleFilePath) - sizeof(EFI_DEVICE_PATH_PROTOCOL);
667 FilePath = (EFI_DEVICE_PATH_PROTOCOL *) ( ((UINT8 *)FilePath) + FilePathSize );
668 }
669
670 //
671 // Initialize the fields for an internal driver
672 //
673 Image->Signature = LOADED_IMAGE_PRIVATE_DATA_SIGNATURE;
674 Image->Info.SystemTable = gST;
675 Image->Info.DeviceHandle = DeviceHandle;
676 Image->Info.Revision = EFI_LOADED_IMAGE_INFORMATION_REVISION;
677 Image->Info.FilePath = CoreDuplicateDevicePath (FilePath);
678 Image->Info.ParentHandle = ParentImageHandle;
679
680 if (NumberOfPages != NULL) {
681 Image->NumberOfPages = *NumberOfPages ;
682 } else {
683 Image->NumberOfPages = 0 ;
684 }
685
686 //
687 // Install the protocol interfaces for this image
688 // don't fire notifications yet
689 //
690 Status = CoreInstallProtocolInterfaceNotify (
691 &Image->Handle,
692 &gEfiLoadedImageProtocolGuid,
693 EFI_NATIVE_INTERFACE,
694 &Image->Info,
695 FALSE
696 );
697 if (EFI_ERROR (Status)) {
698 goto Done;
699 }
700
701 //
702 // Load the image. If EntryPoint is Null, it will not be set.
703 //
704 Status = CoreLoadPeImage (&FHand, Image, DstBuffer, EntryPoint, Attribute);
705 if (EFI_ERROR (Status)) {
706 if ((Status == EFI_BUFFER_TOO_SMALL) || (Status == EFI_OUT_OF_RESOURCES)) {
707 if (NumberOfPages != NULL) {
708 *NumberOfPages = Image->NumberOfPages;
709 }
710 }
711 goto Done;
712 }
713
714 //
715 // Register the image in the Debug Image Info Table if the attribute is set
716 //
717 if (Attribute & EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION) {
718 CoreNewDebugImageInfoEntry (EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL, &Image->Info, Image->Handle);
719 }
720
721 //
722 //Reinstall loaded image protocol to fire any notifications
723 //
724 Status = CoreReinstallProtocolInterface (
725 Image->Handle,
726 &gEfiLoadedImageProtocolGuid,
727 &Image->Info,
728 &Image->Info
729 );
730 if (EFI_ERROR (Status)) {
731 goto Done;
732 }
733
734
735 //
736 // Success. Return the image handle
737 //
738 *ImageHandle = Image->Handle;
739
740 Done:
741 //
742 // All done accessing the source file
743 // If we allocated the Source buffer, free it
744 //
745 if (FHand.FreeBuffer) {
746 CoreFreePool (FHand.Source);
747 }
748
749 //
750 // There was an error. If there's an Image structure, free it
751 //
752 if (EFI_ERROR (Status)) {
753 if (Image != NULL) {
754 CoreUnloadAndCloseImage (Image, (BOOLEAN)(DstBuffer == 0));
755 *ImageHandle = NULL;
756 }
757 } else if (EFI_ERROR (SecurityStatus)) {
758 Status = SecurityStatus;
759 }
760
761 return Status;
762 }
763
764
765
766 EFI_STATUS
767 EFIAPI
768 CoreLoadImage (
769 IN BOOLEAN BootPolicy,
770 IN EFI_HANDLE ParentImageHandle,
771 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
772 IN VOID *SourceBuffer OPTIONAL,
773 IN UINTN SourceSize,
774 OUT EFI_HANDLE *ImageHandle
775 )
776 /*++
777
778 Routine Description:
779
780 Loads an EFI image into memory and returns a handle to the image.
781
782 Arguments:
783
784 BootPolicy - If TRUE, indicates that the request originates from the boot manager,
785 and that the boot manager is attempting to load FilePath as a boot selection.
786 ParentImageHandle - The caller's image handle.
787 FilePath - The specific file path from which the image is loaded.
788 SourceBuffer - If not NULL, a pointer to the memory location containing a copy of
789 the image to be loaded.
790 SourceSize - The size in bytes of SourceBuffer.
791 ImageHandle - Pointer to the returned image handle that is created when the image
792 is successfully loaded.
793
794 Returns:
795
796 EFI_SUCCESS - The image was loaded into memory.
797 EFI_NOT_FOUND - The FilePath was not found.
798 EFI_INVALID_PARAMETER - One of the parameters has an invalid value.
799 EFI_UNSUPPORTED - The image type is not supported, or the device path cannot be
800 parsed to locate the proper protocol for loading the file.
801 EFI_OUT_OF_RESOURCES - Image was not loaded due to insufficient resources.
802 --*/
803 {
804 EFI_STATUS Status;
805
806 PERF_START (NULL, "LoadImage", NULL, 0);
807
808 Status = CoreLoadImageCommon (
809 BootPolicy,
810 ParentImageHandle,
811 FilePath,
812 SourceBuffer,
813 SourceSize,
814 (EFI_PHYSICAL_ADDRESS)NULL,
815 NULL,
816 ImageHandle,
817 NULL,
818 EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION | EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION
819 );
820
821 PERF_END (NULL, "LoadImage", NULL, 0);
822
823 return Status;
824 }
825
826
827 EFI_STATUS
828 EFIAPI
829 CoreLoadImageEx (
830 IN EFI_PE32_IMAGE_PROTOCOL *This,
831 IN EFI_HANDLE ParentImageHandle,
832 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
833 IN VOID *SourceBuffer OPTIONAL,
834 IN UINTN SourceSize,
835 IN EFI_PHYSICAL_ADDRESS DstBuffer OPTIONAL,
836 OUT UINTN *NumberOfPages OPTIONAL,
837 OUT EFI_HANDLE *ImageHandle,
838 OUT EFI_PHYSICAL_ADDRESS *EntryPoint OPTIONAL,
839 IN UINT32 Attribute
840 )
841 /*++
842
843 Routine Description:
844
845 Loads an EFI image into memory and returns a handle to the image with extended parameters.
846
847 Arguments:
848
849 This - Calling context
850 ParentImageHandle - The caller's image handle.
851 FilePath - The specific file path from which the image is loaded.
852 SourceBuffer - If not NULL, a pointer to the memory location containing a copy of
853 the image to be loaded.
854 SourceSize - The size in bytes of SourceBuffer.
855 DstBuffer - The buffer to store the image.
856 NumberOfPages - For input, specifies the space size of the image by caller if not NULL.
857 For output, specifies the actual space size needed.
858 ImageHandle - Image handle for output.
859 EntryPoint - Image entry point for output.
860 Attribute - The bit mask of attributes to set for the load PE image.
861
862 Returns:
863
864 EFI_SUCCESS - The image was loaded into memory.
865 EFI_NOT_FOUND - The FilePath was not found.
866 EFI_INVALID_PARAMETER - One of the parameters has an invalid value.
867 EFI_UNSUPPORTED - The image type is not supported, or the device path cannot be
868 parsed to locate the proper protocol for loading the file.
869 EFI_OUT_OF_RESOURCES - Image was not loaded due to insufficient resources.
870 --*/
871 {
872 return CoreLoadImageCommon (
873 TRUE,
874 ParentImageHandle,
875 FilePath,
876 SourceBuffer,
877 SourceSize,
878 DstBuffer,
879 NumberOfPages,
880 ImageHandle,
881 EntryPoint,
882 Attribute
883 );
884 }
885
886
887
888
889 EFI_STATUS
890 EFIAPI
891 CoreStartImage (
892 IN EFI_HANDLE ImageHandle,
893 OUT UINTN *ExitDataSize,
894 OUT CHAR16 **ExitData OPTIONAL
895 )
896 /*++
897
898 Routine Description:
899
900 Transfer control to a loaded image's entry point.
901
902 Arguments:
903
904 ImageHandle - Handle of image to be started.
905
906 ExitDataSize - Pointer of the size to ExitData
907
908 ExitData - Pointer to a pointer to a data buffer that includes a Null-terminated
909 Unicode string, optionally followed by additional binary data. The string
910 is a description that the caller may use to further indicate the reason for
911 the image's exit.
912
913 Returns:
914
915 EFI_INVALID_PARAMETER - Invalid parameter
916
917 EFI_OUT_OF_RESOURCES - No enough buffer to allocate
918
919 EFI_SUCCESS - Successfully transfer control to the image's entry point.
920
921 --*/
922 {
923 EFI_STATUS Status;
924 LOADED_IMAGE_PRIVATE_DATA *Image;
925 LOADED_IMAGE_PRIVATE_DATA *LastImage;
926 UINT64 HandleDatabaseKey;
927 UINTN SetJumpFlag;
928
929 Image = CoreLoadedImageInfo (ImageHandle);
930 if (Image == NULL_HANDLE || Image->Started) {
931 return EFI_INVALID_PARAMETER;
932 }
933
934 //
935 // Don't profile Objects or invalid start requests
936 //
937 PERF_START (ImageHandle, START_IMAGE_TOK, NULL, 0);
938
939
940 //
941 // Push the current start image context, and
942 // link the current image to the head. This is the
943 // only image that can call Exit()
944 //
945 HandleDatabaseKey = CoreGetHandleDatabaseKey ();
946 LastImage = mCurrentImage;
947 mCurrentImage = Image;
948 Image->Tpl = gEfiCurrentTpl;
949
950 //
951 // Set long jump for Exit() support
952 //
953 Image->JumpContext = CoreAllocateBootServicesPool (sizeof (*Image->JumpContext));
954 if (Image->JumpContext == NULL) {
955 PERF_END (ImageHandle, START_IMAGE_TOK, NULL, 0);
956 return EFI_OUT_OF_RESOURCES;
957 }
958
959 SetJumpFlag = SetJump (Image->JumpContext);
960 //
961 // The initial call to SetJump() must always return 0.
962 // Subsequent calls to LongJump() cause a non-zero value to be returned by SetJump().
963 //
964 if (!SetJumpFlag) {
965 //
966 // Call the image's entry point
967 //
968 Image->Started = TRUE;
969 Image->Status = Image->EntryPoint (ImageHandle, Image->Info.SystemTable);
970
971 //
972 // Add some debug information if the image returned with error.
973 // This make the user aware and check if the driver image have already released
974 // all the resource in this situation.
975 //
976 DEBUG_CODE_BEGIN ();
977 if (EFI_ERROR (Image->Status)) {
978 DEBUG ((EFI_D_ERROR, "Error: Image at %08X start failed: %x\n", Image->Info.ImageBase, Image->Status));
979 }
980 DEBUG_CODE_END ();
981
982 //
983 // If the image returns, exit it through Exit()
984 //
985 CoreExit (ImageHandle, Image->Status, 0, NULL);
986 }
987
988 //
989 // Image has completed. Verify the tpl is the same
990 //
991 ASSERT (Image->Tpl == gEfiCurrentTpl);
992 CoreRestoreTpl (Image->Tpl);
993
994 CoreFreePool (Image->JumpContext);
995
996 //
997 // Pop the current start image context
998 //
999 mCurrentImage = LastImage;
1000
1001 //
1002 // Go connect any handles that were created or modified while the image executed.
1003 //
1004 CoreConnectHandlesByKey (HandleDatabaseKey);
1005
1006 //
1007 // Handle the image's returned ExitData
1008 //
1009 DEBUG_CODE_BEGIN ();
1010 if (Image->ExitDataSize != 0 || Image->ExitData != NULL) {
1011
1012 DEBUG (
1013 (EFI_D_LOAD,
1014 "StartImage: ExitDataSize %d, ExitData %x",
1015 Image->ExitDataSize,
1016 Image->ExitData)
1017 );
1018 if (Image->ExitData != NULL) {
1019 DEBUG ((EFI_D_LOAD, " (%hs)", Image->ExitData));
1020 }
1021 DEBUG ((EFI_D_LOAD, "\n"));
1022 }
1023 DEBUG_CODE_END ();
1024
1025 //
1026 // Return the exit data to the caller
1027 //
1028 if (ExitData != NULL && ExitDataSize != NULL) {
1029 *ExitDataSize = Image->ExitDataSize;
1030 *ExitData = Image->ExitData;
1031 } else {
1032 //
1033 // Caller doesn't want the exit data, free it
1034 //
1035 CoreFreePool (Image->ExitData);
1036 Image->ExitData = NULL;
1037 }
1038
1039 //
1040 // Save the Status because Image will get destroyed if it is unloaded.
1041 //
1042 Status = Image->Status;
1043
1044 //
1045 // If the image returned an error, or if the image is an application
1046 // unload it
1047 //
1048 if (EFI_ERROR (Image->Status) || Image->Type == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1049 CoreUnloadAndCloseImage (Image, TRUE);
1050 }
1051
1052 //
1053 // Done
1054 //
1055 PERF_END (ImageHandle, START_IMAGE_TOK, NULL, 0);
1056 return Status;
1057 }
1058
1059
1060 VOID
1061 CoreUnloadAndCloseImage (
1062 IN LOADED_IMAGE_PRIVATE_DATA *Image,
1063 IN BOOLEAN FreePage
1064 )
1065 /*++
1066
1067 Routine Description:
1068
1069 Unloads EFI image from memory.
1070
1071 Arguments:
1072
1073 Image - EFI image
1074 FreePage - Free allocated pages
1075
1076 Returns:
1077
1078 None
1079
1080 --*/
1081 {
1082 EFI_STATUS Status;
1083 UINTN HandleCount;
1084 EFI_HANDLE *HandleBuffer;
1085 UINTN HandleIndex;
1086 EFI_GUID **ProtocolGuidArray;
1087 UINTN ArrayCount;
1088 UINTN ProtocolIndex;
1089 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
1090 UINTN OpenInfoCount;
1091 UINTN OpenInfoIndex;
1092
1093 if (Image->Ebc != NULL) {
1094 //
1095 // If EBC protocol exists we must perform cleanups for this image.
1096 //
1097 Image->Ebc->UnloadImage (Image->Ebc, Image->Handle);
1098 }
1099
1100 //
1101 // Unload image, free Image->ImageContext->ModHandle
1102 //
1103 gEfiPeiPeCoffLoader->UnloadImage (gEfiPeiPeCoffLoader, &Image->ImageContext);
1104
1105 //
1106 // Free our references to the image handle
1107 //
1108 if (Image->Handle != NULL_HANDLE) {
1109
1110 Status = CoreLocateHandleBuffer (
1111 AllHandles,
1112 NULL,
1113 NULL,
1114 &HandleCount,
1115 &HandleBuffer
1116 );
1117 if (!EFI_ERROR (Status)) {
1118 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
1119 Status = CoreProtocolsPerHandle (
1120 HandleBuffer[HandleIndex],
1121 &ProtocolGuidArray,
1122 &ArrayCount
1123 );
1124 if (!EFI_ERROR (Status)) {
1125 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
1126 Status = CoreOpenProtocolInformation (
1127 HandleBuffer[HandleIndex],
1128 ProtocolGuidArray[ProtocolIndex],
1129 &OpenInfo,
1130 &OpenInfoCount
1131 );
1132 if (!EFI_ERROR (Status)) {
1133 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
1134 if (OpenInfo[OpenInfoIndex].AgentHandle == Image->Handle) {
1135 Status = CoreCloseProtocol (
1136 HandleBuffer[HandleIndex],
1137 ProtocolGuidArray[ProtocolIndex],
1138 Image->Handle,
1139 OpenInfo[OpenInfoIndex].ControllerHandle
1140 );
1141 }
1142 }
1143 if (OpenInfo != NULL) {
1144 CoreFreePool(OpenInfo);
1145 }
1146 }
1147 }
1148 if (ProtocolGuidArray != NULL) {
1149 CoreFreePool(ProtocolGuidArray);
1150 }
1151 }
1152 }
1153 if (HandleBuffer != NULL) {
1154 CoreFreePool (HandleBuffer);
1155 }
1156 }
1157
1158 CoreRemoveDebugImageInfoEntry (Image->Handle);
1159
1160 Status = CoreUninstallProtocolInterface (
1161 Image->Handle,
1162 &gEfiLoadedImageProtocolGuid,
1163 &Image->Info
1164 );
1165 }
1166
1167 if (Image->RuntimeFixupValid) {
1168 //
1169 // Remove the Image from the Runtime Image list as we are about to Free it!
1170 //
1171 RemoveEntryList (&Image->Link);
1172 }
1173
1174 //
1175 // Free the Image from memory
1176 //
1177 if ((Image->ImageBasePage != 0) && FreePage) {
1178 CoreFreePages (Image->ImageBasePage, Image->NumberOfPages);
1179 }
1180
1181 //
1182 // Done with the Image structure
1183 //
1184 if (Image->Info.FilePath != NULL) {
1185 CoreFreePool (Image->Info.FilePath);
1186 }
1187
1188 if (Image->FixupData != NULL) {
1189 CoreFreePool (Image->FixupData);
1190 }
1191
1192 CoreFreePool (Image);
1193 }
1194
1195
1196
1197 EFI_STATUS
1198 EFIAPI
1199 CoreExit (
1200 IN EFI_HANDLE ImageHandle,
1201 IN EFI_STATUS Status,
1202 IN UINTN ExitDataSize,
1203 IN CHAR16 *ExitData OPTIONAL
1204 )
1205 /*++
1206
1207 Routine Description:
1208
1209 Terminates the currently loaded EFI image and returns control to boot services.
1210
1211 Arguments:
1212
1213 ImageHandle - Handle that identifies the image. This parameter is passed to the image
1214 on entry.
1215 Status - The image's exit code.
1216 ExitDataSize - The size, in bytes, of ExitData. Ignored if ExitStatus is
1217 EFI_SUCCESS.
1218 ExitData - Pointer to a data buffer that includes a Null-terminated Unicode string,
1219 optionally followed by additional binary data. The string is a
1220 description that the caller may use to further indicate the reason for
1221 the image's exit.
1222
1223 Returns:
1224
1225 EFI_INVALID_PARAMETER - Image handle is NULL or it is not current image.
1226
1227 EFI_SUCCESS - Successfully terminates the currently loaded EFI image.
1228
1229 EFI_ACCESS_DENIED - Should never reach there.
1230
1231 EFI_OUT_OF_RESOURCES - Could not allocate pool
1232
1233 --*/
1234 {
1235 LOADED_IMAGE_PRIVATE_DATA *Image;
1236
1237 Image = CoreLoadedImageInfo (ImageHandle);
1238 if (Image == NULL_HANDLE) {
1239 return EFI_INVALID_PARAMETER;
1240 }
1241
1242 if (!Image->Started) {
1243 //
1244 // The image has not been started so just free its resources
1245 //
1246 CoreUnloadAndCloseImage (Image, TRUE);
1247 return EFI_SUCCESS;
1248 }
1249
1250 //
1251 // Image has been started, verify this image can exit
1252 //
1253 if (Image != mCurrentImage) {
1254 DEBUG ((EFI_D_LOAD|EFI_D_ERROR, "Exit: Image is not exitable image\n"));
1255 return EFI_INVALID_PARAMETER;
1256 }
1257
1258 //
1259 // Set status
1260 //
1261 Image->Status = Status;
1262
1263 //
1264 // If there's ExitData info, move it
1265 //
1266 if (ExitData != NULL) {
1267 Image->ExitDataSize = ExitDataSize;
1268 Image->ExitData = CoreAllocateBootServicesPool (Image->ExitDataSize);
1269 if (Image->ExitData == NULL) {
1270 return EFI_OUT_OF_RESOURCES;
1271 }
1272 CopyMem (Image->ExitData, ExitData, Image->ExitDataSize);
1273 }
1274
1275 //
1276 // return to StartImage
1277 //
1278 LongJump (Image->JumpContext, (UINTN)-1);
1279
1280 //
1281 // If we return from LongJump, then it is an error
1282 //
1283 ASSERT (FALSE);
1284 return EFI_ACCESS_DENIED;
1285 }
1286
1287
1288
1289 EFI_STATUS
1290 EFIAPI
1291 CoreUnloadImage (
1292 IN EFI_HANDLE ImageHandle
1293 )
1294 /*++
1295
1296 Routine Description:
1297
1298 Unloads an image.
1299
1300 Arguments:
1301
1302 ImageHandle - Handle that identifies the image to be unloaded.
1303
1304 Returns:
1305
1306 EFI_SUCCESS - The image has been unloaded.
1307 EFI_UNSUPPORTED - The image has been sarted, and does not support unload.
1308 EFI_INVALID_PARAMPETER - ImageHandle is not a valid image handle.
1309
1310 --*/
1311 {
1312 EFI_STATUS Status;
1313 LOADED_IMAGE_PRIVATE_DATA *Image;
1314
1315 Image = CoreLoadedImageInfo (ImageHandle);
1316 if (Image == NULL ) {
1317 //
1318 // The image handle is not valid
1319 //
1320 return EFI_INVALID_PARAMETER;
1321 }
1322
1323 if (Image->Started) {
1324 //
1325 // The image has been started, request it to unload.
1326 //
1327 Status = EFI_UNSUPPORTED;
1328 if (Image->Info.Unload != NULL) {
1329 Status = Image->Info.Unload (ImageHandle);
1330 }
1331
1332 } else {
1333 //
1334 // This Image hasn't been started, thus it can be unloaded
1335 //
1336 Status = EFI_SUCCESS;
1337 }
1338
1339
1340 if (!EFI_ERROR (Status)) {
1341 //
1342 // if the Image was not started or Unloaded O.K. then clean up
1343 //
1344 CoreUnloadAndCloseImage (Image, TRUE);
1345 }
1346
1347 return Status;
1348 }
1349
1350
1351 EFI_STATUS
1352 EFIAPI
1353 CoreUnloadImageEx (
1354 IN EFI_PE32_IMAGE_PROTOCOL *This,
1355 IN EFI_HANDLE ImageHandle
1356 )
1357 /*++
1358
1359 Routine Description:
1360
1361 Unload the specified image.
1362
1363 Arguments:
1364
1365 This - Indicates the calling context.
1366
1367 ImageHandle - The specified image handle.
1368
1369 Returns:
1370
1371 EFI_INVALID_PARAMETER - Image handle is NULL.
1372
1373 EFI_UNSUPPORTED - Attempt to unload an unsupported image.
1374
1375 EFI_SUCCESS - Image successfully unloaded.
1376
1377 --*/
1378 {
1379 return CoreUnloadImage (ImageHandle);
1380 }