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