]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Core/Dxe/DxeMain/DxeMain.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
DxeMain: Fix the bug that StackGuard is not enabled
[mirror_edk2.git] / MdeModulePkg / Core / Dxe / DxeMain / DxeMain.c
1 /** @file
2 DXE Core Main Entry Point
3
4 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
6
7 **/
8
9 #include "DxeMain.h"
10
11 //
12 // DXE Core Global Variables for Protocols from PEI
13 //
14 EFI_HANDLE mDecompressHandle = NULL;
15
16 //
17 // DXE Core globals for Architecture Protocols
18 //
19 EFI_SECURITY_ARCH_PROTOCOL *gSecurity = NULL;
20 EFI_SECURITY2_ARCH_PROTOCOL *gSecurity2 = NULL;
21 EFI_CPU_ARCH_PROTOCOL *gCpu = NULL;
22 EFI_METRONOME_ARCH_PROTOCOL *gMetronome = NULL;
23 EFI_TIMER_ARCH_PROTOCOL *gTimer = NULL;
24 EFI_BDS_ARCH_PROTOCOL *gBds = NULL;
25 EFI_WATCHDOG_TIMER_ARCH_PROTOCOL *gWatchdogTimer = NULL;
26
27 //
28 // DXE Core globals for optional protocol dependencies
29 //
30 EFI_SMM_BASE2_PROTOCOL *gSmmBase2 = NULL;
31
32 //
33 // DXE Core Global used to update core loaded image protocol handle
34 //
35 EFI_GUID *gDxeCoreFileName;
36 EFI_LOADED_IMAGE_PROTOCOL *gDxeCoreLoadedImage;
37
38 //
39 // DXE Core Module Variables
40 //
41 EFI_BOOT_SERVICES mBootServices = {
42 {
43 EFI_BOOT_SERVICES_SIGNATURE, // Signature
44 EFI_BOOT_SERVICES_REVISION, // Revision
45 sizeof (EFI_BOOT_SERVICES), // HeaderSize
46 0, // CRC32
47 0 // Reserved
48 },
49 (EFI_RAISE_TPL)CoreRaiseTpl, // RaiseTPL
50 (EFI_RESTORE_TPL)CoreRestoreTpl, // RestoreTPL
51 (EFI_ALLOCATE_PAGES)CoreAllocatePages, // AllocatePages
52 (EFI_FREE_PAGES)CoreFreePages, // FreePages
53 (EFI_GET_MEMORY_MAP)CoreGetMemoryMap, // GetMemoryMap
54 (EFI_ALLOCATE_POOL)CoreAllocatePool, // AllocatePool
55 (EFI_FREE_POOL)CoreFreePool, // FreePool
56 (EFI_CREATE_EVENT)CoreCreateEvent, // CreateEvent
57 (EFI_SET_TIMER)CoreSetTimer, // SetTimer
58 (EFI_WAIT_FOR_EVENT)CoreWaitForEvent, // WaitForEvent
59 (EFI_SIGNAL_EVENT)CoreSignalEvent, // SignalEvent
60 (EFI_CLOSE_EVENT)CoreCloseEvent, // CloseEvent
61 (EFI_CHECK_EVENT)CoreCheckEvent, // CheckEvent
62 (EFI_INSTALL_PROTOCOL_INTERFACE)CoreInstallProtocolInterface, // InstallProtocolInterface
63 (EFI_REINSTALL_PROTOCOL_INTERFACE)CoreReinstallProtocolInterface, // ReinstallProtocolInterface
64 (EFI_UNINSTALL_PROTOCOL_INTERFACE)CoreUninstallProtocolInterface, // UninstallProtocolInterface
65 (EFI_HANDLE_PROTOCOL)CoreHandleProtocol, // HandleProtocol
66 (VOID *)NULL, // Reserved
67 (EFI_REGISTER_PROTOCOL_NOTIFY)CoreRegisterProtocolNotify, // RegisterProtocolNotify
68 (EFI_LOCATE_HANDLE)CoreLocateHandle, // LocateHandle
69 (EFI_LOCATE_DEVICE_PATH)CoreLocateDevicePath, // LocateDevicePath
70 (EFI_INSTALL_CONFIGURATION_TABLE)CoreInstallConfigurationTable, // InstallConfigurationTable
71 (EFI_IMAGE_LOAD)CoreLoadImage, // LoadImage
72 (EFI_IMAGE_START)CoreStartImage, // StartImage
73 (EFI_EXIT)CoreExit, // Exit
74 (EFI_IMAGE_UNLOAD)CoreUnloadImage, // UnloadImage
75 (EFI_EXIT_BOOT_SERVICES)CoreExitBootServices, // ExitBootServices
76 (EFI_GET_NEXT_MONOTONIC_COUNT)CoreEfiNotAvailableYetArg1, // GetNextMonotonicCount
77 (EFI_STALL)CoreStall, // Stall
78 (EFI_SET_WATCHDOG_TIMER)CoreSetWatchdogTimer, // SetWatchdogTimer
79 (EFI_CONNECT_CONTROLLER)CoreConnectController, // ConnectController
80 (EFI_DISCONNECT_CONTROLLER)CoreDisconnectController, // DisconnectController
81 (EFI_OPEN_PROTOCOL)CoreOpenProtocol, // OpenProtocol
82 (EFI_CLOSE_PROTOCOL)CoreCloseProtocol, // CloseProtocol
83 (EFI_OPEN_PROTOCOL_INFORMATION)CoreOpenProtocolInformation, // OpenProtocolInformation
84 (EFI_PROTOCOLS_PER_HANDLE)CoreProtocolsPerHandle, // ProtocolsPerHandle
85 (EFI_LOCATE_HANDLE_BUFFER)CoreLocateHandleBuffer, // LocateHandleBuffer
86 (EFI_LOCATE_PROTOCOL)CoreLocateProtocol, // LocateProtocol
87 (EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES)CoreInstallMultipleProtocolInterfaces, // InstallMultipleProtocolInterfaces
88 (EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES)CoreUninstallMultipleProtocolInterfaces, // UninstallMultipleProtocolInterfaces
89 (EFI_CALCULATE_CRC32)CoreEfiNotAvailableYetArg3, // CalculateCrc32
90 (EFI_COPY_MEM)CopyMem, // CopyMem
91 (EFI_SET_MEM)SetMem, // SetMem
92 (EFI_CREATE_EVENT_EX)CoreCreateEventEx // CreateEventEx
93 };
94
95 EFI_DXE_SERVICES mDxeServices = {
96 {
97 DXE_SERVICES_SIGNATURE, // Signature
98 DXE_SERVICES_REVISION, // Revision
99 sizeof (DXE_SERVICES), // HeaderSize
100 0, // CRC32
101 0 // Reserved
102 },
103 (EFI_ADD_MEMORY_SPACE)CoreAddMemorySpace, // AddMemorySpace
104 (EFI_ALLOCATE_MEMORY_SPACE)CoreAllocateMemorySpace, // AllocateMemorySpace
105 (EFI_FREE_MEMORY_SPACE)CoreFreeMemorySpace, // FreeMemorySpace
106 (EFI_REMOVE_MEMORY_SPACE)CoreRemoveMemorySpace, // RemoveMemorySpace
107 (EFI_GET_MEMORY_SPACE_DESCRIPTOR)CoreGetMemorySpaceDescriptor, // GetMemorySpaceDescriptor
108 (EFI_SET_MEMORY_SPACE_ATTRIBUTES)CoreSetMemorySpaceAttributes, // SetMemorySpaceAttributes
109 (EFI_GET_MEMORY_SPACE_MAP)CoreGetMemorySpaceMap, // GetMemorySpaceMap
110 (EFI_ADD_IO_SPACE)CoreAddIoSpace, // AddIoSpace
111 (EFI_ALLOCATE_IO_SPACE)CoreAllocateIoSpace, // AllocateIoSpace
112 (EFI_FREE_IO_SPACE)CoreFreeIoSpace, // FreeIoSpace
113 (EFI_REMOVE_IO_SPACE)CoreRemoveIoSpace, // RemoveIoSpace
114 (EFI_GET_IO_SPACE_DESCRIPTOR)CoreGetIoSpaceDescriptor, // GetIoSpaceDescriptor
115 (EFI_GET_IO_SPACE_MAP)CoreGetIoSpaceMap, // GetIoSpaceMap
116 (EFI_DISPATCH)CoreDispatcher, // Dispatch
117 (EFI_SCHEDULE)CoreSchedule, // Schedule
118 (EFI_TRUST)CoreTrust, // Trust
119 (EFI_PROCESS_FIRMWARE_VOLUME)CoreProcessFirmwareVolume, // ProcessFirmwareVolume
120 (EFI_SET_MEMORY_SPACE_CAPABILITIES)CoreSetMemorySpaceCapabilities, // SetMemorySpaceCapabilities
121 };
122
123 EFI_SYSTEM_TABLE mEfiSystemTableTemplate = {
124 {
125 EFI_SYSTEM_TABLE_SIGNATURE, // Signature
126 EFI_SYSTEM_TABLE_REVISION, // Revision
127 sizeof (EFI_SYSTEM_TABLE), // HeaderSize
128 0, // CRC32
129 0 // Reserved
130 },
131 NULL, // FirmwareVendor
132 0, // FirmwareRevision
133 NULL, // ConsoleInHandle
134 NULL, // ConIn
135 NULL, // ConsoleOutHandle
136 NULL, // ConOut
137 NULL, // StandardErrorHandle
138 NULL, // StdErr
139 NULL, // RuntimeServices
140 &mBootServices, // BootServices
141 0, // NumberOfConfigurationTableEntries
142 NULL // ConfigurationTable
143 };
144
145 EFI_RUNTIME_SERVICES mEfiRuntimeServicesTableTemplate = {
146 {
147 EFI_RUNTIME_SERVICES_SIGNATURE, // Signature
148 EFI_RUNTIME_SERVICES_REVISION, // Revision
149 sizeof (EFI_RUNTIME_SERVICES), // HeaderSize
150 0, // CRC32
151 0 // Reserved
152 },
153 (EFI_GET_TIME)CoreEfiNotAvailableYetArg2, // GetTime
154 (EFI_SET_TIME)CoreEfiNotAvailableYetArg1, // SetTime
155 (EFI_GET_WAKEUP_TIME)CoreEfiNotAvailableYetArg3, // GetWakeupTime
156 (EFI_SET_WAKEUP_TIME)CoreEfiNotAvailableYetArg2, // SetWakeupTime
157 (EFI_SET_VIRTUAL_ADDRESS_MAP)CoreEfiNotAvailableYetArg4, // SetVirtualAddressMap
158 (EFI_CONVERT_POINTER)CoreEfiNotAvailableYetArg2, // ConvertPointer
159 (EFI_GET_VARIABLE)CoreEfiNotAvailableYetArg5, // GetVariable
160 (EFI_GET_NEXT_VARIABLE_NAME)CoreEfiNotAvailableYetArg3, // GetNextVariableName
161 (EFI_SET_VARIABLE)CoreEfiNotAvailableYetArg5, // SetVariable
162 (EFI_GET_NEXT_HIGH_MONO_COUNT)CoreEfiNotAvailableYetArg1, // GetNextHighMonotonicCount
163 (EFI_RESET_SYSTEM)CoreEfiNotAvailableYetArg4, // ResetSystem
164 (EFI_UPDATE_CAPSULE)CoreEfiNotAvailableYetArg3, // UpdateCapsule
165 (EFI_QUERY_CAPSULE_CAPABILITIES)CoreEfiNotAvailableYetArg4, // QueryCapsuleCapabilities
166 (EFI_QUERY_VARIABLE_INFO)CoreEfiNotAvailableYetArg4 // QueryVariableInfo
167 };
168
169 EFI_RUNTIME_ARCH_PROTOCOL gRuntimeTemplate = {
170 INITIALIZE_LIST_HEAD_VARIABLE (gRuntimeTemplate.ImageHead),
171 INITIALIZE_LIST_HEAD_VARIABLE (gRuntimeTemplate.EventHead),
172
173 //
174 // Make sure Size != sizeof (EFI_MEMORY_DESCRIPTOR). This will
175 // prevent people from having pointer math bugs in their code.
176 // now you have to use *DescriptorSize to make things work.
177 //
178 sizeof (EFI_MEMORY_DESCRIPTOR) + sizeof (UINT64) - (sizeof (EFI_MEMORY_DESCRIPTOR) % sizeof (UINT64)),
179 EFI_MEMORY_DESCRIPTOR_VERSION,
180 0,
181 NULL,
182 NULL,
183 FALSE,
184 FALSE
185 };
186
187 EFI_RUNTIME_ARCH_PROTOCOL *gRuntime = &gRuntimeTemplate;
188
189 //
190 // DXE Core Global Variables for the EFI System Table, Boot Services Table,
191 // DXE Services Table, and Runtime Services Table
192 //
193 EFI_DXE_SERVICES *gDxeCoreDS = &mDxeServices;
194 EFI_SYSTEM_TABLE *gDxeCoreST = NULL;
195
196 //
197 // For debug initialize gDxeCoreRT to template. gDxeCoreRT must be allocated from RT memory
198 // but gDxeCoreRT is used for ASSERT () and DEBUG () type macros so lets give it
199 // a value that will not cause debug infrastructure to crash early on.
200 //
201 EFI_RUNTIME_SERVICES *gDxeCoreRT = &mEfiRuntimeServicesTableTemplate;
202 EFI_HANDLE gDxeCoreImageHandle = NULL;
203
204 BOOLEAN gMemoryMapTerminated = FALSE;
205
206 //
207 // EFI Decompress Protocol
208 //
209 EFI_DECOMPRESS_PROTOCOL gEfiDecompress = {
210 DxeMainUefiDecompressGetInfo,
211 DxeMainUefiDecompress
212 };
213
214 //
215 // For Loading modules at fixed address feature, the configuration table is to cache the top address below which to load
216 // Runtime code&boot time code
217 //
218 GLOBAL_REMOVE_IF_UNREFERENCED EFI_LOAD_FIXED_ADDRESS_CONFIGURATION_TABLE gLoadModuleAtFixAddressConfigurationTable = { 0, 0 };
219
220 // Main entry point to the DXE Core
221 //
222
223 /**
224 Main entry point to DXE Core.
225
226 @param HobStart Pointer to the beginning of the HOB List from PEI.
227
228 @return This function should never return.
229
230 **/
231 VOID
232 EFIAPI
233 DxeMain (
234 IN VOID *HobStart
235 )
236 {
237 EFI_STATUS Status;
238 EFI_PHYSICAL_ADDRESS MemoryBaseAddress;
239 UINT64 MemoryLength;
240 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
241 UINTN Index;
242 EFI_HOB_GUID_TYPE *GuidHob;
243 EFI_VECTOR_HANDOFF_INFO *VectorInfoList;
244 EFI_VECTOR_HANDOFF_INFO *VectorInfo;
245 VOID *EntryPoint;
246
247 //
248 // Setup the default exception handlers
249 //
250 VectorInfoList = NULL;
251 GuidHob = GetNextGuidHob (&gEfiVectorHandoffInfoPpiGuid, HobStart);
252 if (GuidHob != NULL) {
253 VectorInfoList = (EFI_VECTOR_HANDOFF_INFO *)(GET_GUID_HOB_DATA (GuidHob));
254 }
255
256 Status = InitializeCpuExceptionHandlers (VectorInfoList);
257 ASSERT_EFI_ERROR (Status);
258
259 //
260 // Setup Stack Guard
261 //
262 if (PcdGetBool (PcdCpuStackGuard)) {
263 Status = InitializeSeparateExceptionStacks (NULL);
264 ASSERT_EFI_ERROR (Status);
265 }
266
267 //
268 // Initialize Debug Agent to support source level debug in DXE phase
269 //
270 InitializeDebugAgent (DEBUG_AGENT_INIT_DXE_CORE, HobStart, NULL);
271
272 //
273 // Initialize Memory Services
274 //
275 CoreInitializeMemoryServices (&HobStart, &MemoryBaseAddress, &MemoryLength);
276
277 MemoryProfileInit (HobStart);
278
279 //
280 // Allocate the EFI System Table and EFI Runtime Service Table from EfiRuntimeServicesData
281 // Use the templates to initialize the contents of the EFI System Table and EFI Runtime Services Table
282 //
283 gDxeCoreST = AllocateRuntimeCopyPool (sizeof (EFI_SYSTEM_TABLE), &mEfiSystemTableTemplate);
284 ASSERT (gDxeCoreST != NULL);
285
286 gDxeCoreRT = AllocateRuntimeCopyPool (sizeof (EFI_RUNTIME_SERVICES), &mEfiRuntimeServicesTableTemplate);
287 ASSERT (gDxeCoreRT != NULL);
288
289 gDxeCoreST->RuntimeServices = gDxeCoreRT;
290
291 //
292 // Start the Image Services.
293 //
294 Status = CoreInitializeImageServices (HobStart);
295 ASSERT_EFI_ERROR (Status);
296
297 //
298 // Initialize the Global Coherency Domain Services
299 //
300 Status = CoreInitializeGcdServices (&HobStart, MemoryBaseAddress, MemoryLength);
301 ASSERT_EFI_ERROR (Status);
302
303 //
304 // Call constructor for all libraries
305 //
306 ProcessLibraryConstructorList (gDxeCoreImageHandle, gDxeCoreST);
307 PERF_CROSSMODULE_END ("PEI");
308 PERF_CROSSMODULE_BEGIN ("DXE");
309
310 //
311 // Log MemoryBaseAddress and MemoryLength again (from
312 // CoreInitializeMemoryServices()), now that library constructors have
313 // executed.
314 //
315 DEBUG ((
316 DEBUG_INFO,
317 "%a: MemoryBaseAddress=0x%Lx MemoryLength=0x%Lx\n",
318 __FUNCTION__,
319 MemoryBaseAddress,
320 MemoryLength
321 ));
322
323 //
324 // Report DXE Core image information to the PE/COFF Extra Action Library
325 //
326 ZeroMem (&ImageContext, sizeof (ImageContext));
327 ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)gDxeCoreLoadedImage->ImageBase;
328 ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer ((VOID *)(UINTN)ImageContext.ImageAddress);
329 ImageContext.SizeOfHeaders = PeCoffGetSizeOfHeaders ((VOID *)(UINTN)ImageContext.ImageAddress);
330 Status = PeCoffLoaderGetEntryPoint ((VOID *)(UINTN)ImageContext.ImageAddress, &EntryPoint);
331 if (Status == EFI_SUCCESS) {
332 ImageContext.EntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)EntryPoint;
333 }
334
335 ImageContext.Handle = (VOID *)(UINTN)gDxeCoreLoadedImage->ImageBase;
336 ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;
337 PeCoffLoaderRelocateImageExtraAction (&ImageContext);
338
339 //
340 // Install the DXE Services Table into the EFI System Tables's Configuration Table
341 //
342 Status = CoreInstallConfigurationTable (&gEfiDxeServicesTableGuid, gDxeCoreDS);
343 ASSERT_EFI_ERROR (Status);
344
345 //
346 // Install the HOB List into the EFI System Tables's Configuration Table
347 //
348 Status = CoreInstallConfigurationTable (&gEfiHobListGuid, HobStart);
349 ASSERT_EFI_ERROR (Status);
350
351 //
352 // Install Memory Type Information Table into the EFI System Tables's Configuration Table
353 //
354 Status = CoreInstallConfigurationTable (&gEfiMemoryTypeInformationGuid, &gMemoryTypeInformation);
355 ASSERT_EFI_ERROR (Status);
356
357 //
358 // If Loading modules At fixed address feature is enabled, install Load moduels at fixed address
359 // Configuration Table so that user could easily to retrieve the top address to load Dxe and PEI
360 // Code and Tseg base to load SMM driver.
361 //
362 if (PcdGet64 (PcdLoadModuleAtFixAddressEnable) != 0) {
363 Status = CoreInstallConfigurationTable (&gLoadFixedAddressConfigurationTableGuid, &gLoadModuleAtFixAddressConfigurationTable);
364 ASSERT_EFI_ERROR (Status);
365 }
366
367 //
368 // Report Status Code here for DXE_ENTRY_POINT once it is available
369 //
370 REPORT_STATUS_CODE (
371 EFI_PROGRESS_CODE,
372 (EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_ENTRY_POINT)
373 );
374
375 //
376 // Create the aligned system table pointer structure that is used by external
377 // debuggers to locate the system table... Also, install debug image info
378 // configuration table.
379 //
380 CoreInitializeDebugImageInfoTable ();
381 CoreNewDebugImageInfoEntry (
382 EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL,
383 gDxeCoreLoadedImage,
384 gDxeCoreImageHandle
385 );
386
387 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "HOBLIST address in DXE = 0x%p\n", HobStart));
388
389 DEBUG_CODE_BEGIN ();
390 EFI_PEI_HOB_POINTERS Hob;
391
392 for (Hob.Raw = HobStart; !END_OF_HOB_LIST (Hob); Hob.Raw = GET_NEXT_HOB (Hob)) {
393 if (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_MEMORY_ALLOCATION) {
394 DEBUG ((
395 DEBUG_INFO | DEBUG_LOAD,
396 "Memory Allocation 0x%08x 0x%0lx - 0x%0lx\n", \
397 Hob.MemoryAllocation->AllocDescriptor.MemoryType, \
398 Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress, \
399 Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress + Hob.MemoryAllocation->AllocDescriptor.MemoryLength - 1
400 ));
401 }
402 }
403
404 for (Hob.Raw = HobStart; !END_OF_HOB_LIST (Hob); Hob.Raw = GET_NEXT_HOB (Hob)) {
405 if (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_FV) {
406 DEBUG ((
407 DEBUG_INFO | DEBUG_LOAD,
408 "FV Hob 0x%0lx - 0x%0lx\n",
409 Hob.FirmwareVolume->BaseAddress,
410 Hob.FirmwareVolume->BaseAddress + Hob.FirmwareVolume->Length - 1
411 ));
412 } else if (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_FV2) {
413 DEBUG ((
414 DEBUG_INFO | DEBUG_LOAD,
415 "FV2 Hob 0x%0lx - 0x%0lx\n",
416 Hob.FirmwareVolume2->BaseAddress,
417 Hob.FirmwareVolume2->BaseAddress + Hob.FirmwareVolume2->Length - 1
418 ));
419 DEBUG ((
420 DEBUG_INFO | DEBUG_LOAD,
421 " %g - %g\n",
422 &Hob.FirmwareVolume2->FvName,
423 &Hob.FirmwareVolume2->FileName
424 ));
425 } else if (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_FV3) {
426 DEBUG ((
427 DEBUG_INFO | DEBUG_LOAD,
428 "FV3 Hob 0x%0lx - 0x%0lx - 0x%x - 0x%x\n",
429 Hob.FirmwareVolume3->BaseAddress,
430 Hob.FirmwareVolume3->BaseAddress + Hob.FirmwareVolume3->Length - 1,
431 Hob.FirmwareVolume3->AuthenticationStatus,
432 Hob.FirmwareVolume3->ExtractedFv
433 ));
434 if (Hob.FirmwareVolume3->ExtractedFv) {
435 DEBUG ((
436 DEBUG_INFO | DEBUG_LOAD,
437 " %g - %g\n",
438 &Hob.FirmwareVolume3->FvName,
439 &Hob.FirmwareVolume3->FileName
440 ));
441 }
442 }
443 }
444
445 DEBUG_CODE_END ();
446
447 //
448 // Initialize the Event Services
449 //
450 Status = CoreInitializeEventServices ();
451 ASSERT_EFI_ERROR (Status);
452
453 MemoryProfileInstallProtocol ();
454
455 CoreInitializeMemoryAttributesTable ();
456 CoreInitializeMemoryProtection ();
457
458 //
459 // Get persisted vector hand-off info from GUIDeed HOB again due to HobStart may be updated,
460 // and install configuration table
461 //
462 GuidHob = GetNextGuidHob (&gEfiVectorHandoffInfoPpiGuid, HobStart);
463 if (GuidHob != NULL) {
464 VectorInfoList = (EFI_VECTOR_HANDOFF_INFO *)(GET_GUID_HOB_DATA (GuidHob));
465 VectorInfo = VectorInfoList;
466 Index = 1;
467 while (VectorInfo->Attribute != EFI_VECTOR_HANDOFF_LAST_ENTRY) {
468 VectorInfo++;
469 Index++;
470 }
471
472 VectorInfo = AllocateCopyPool (sizeof (EFI_VECTOR_HANDOFF_INFO) * Index, (VOID *)VectorInfoList);
473 ASSERT (VectorInfo != NULL);
474 Status = CoreInstallConfigurationTable (&gEfiVectorHandoffTableGuid, (VOID *)VectorInfo);
475 ASSERT_EFI_ERROR (Status);
476 }
477
478 //
479 // Get the Protocols that were passed in from PEI to DXE through GUIDed HOBs
480 //
481 // These Protocols are not architectural. This implementation is sharing code between
482 // PEI and DXE in order to save FLASH space. These Protocols could also be implemented
483 // as part of the DXE Core. However, that would also require the DXE Core to be ported
484 // each time a different CPU is used, a different Decompression algorithm is used, or a
485 // different Image type is used. By placing these Protocols in PEI, the DXE Core remains
486 // generic, and only PEI and the Arch Protocols need to be ported from Platform to Platform,
487 // and from CPU to CPU.
488 //
489
490 //
491 // Publish the EFI, Tiano, and Custom Decompress protocols for use by other DXE components
492 //
493 Status = CoreInstallMultipleProtocolInterfaces (
494 &mDecompressHandle,
495 &gEfiDecompressProtocolGuid,
496 &gEfiDecompress,
497 NULL
498 );
499 ASSERT_EFI_ERROR (Status);
500
501 //
502 // Register for the GUIDs of the Architectural Protocols, so the rest of the
503 // EFI Boot Services and EFI Runtime Services tables can be filled in.
504 // Also register for the GUIDs of optional protocols.
505 //
506 CoreNotifyOnProtocolInstallation ();
507
508 //
509 // Produce Firmware Volume Protocols, one for each FV in the HOB list.
510 //
511 Status = FwVolBlockDriverInit (gDxeCoreImageHandle, gDxeCoreST);
512 ASSERT_EFI_ERROR (Status);
513
514 Status = FwVolDriverInit (gDxeCoreImageHandle, gDxeCoreST);
515 ASSERT_EFI_ERROR (Status);
516
517 //
518 // Produce the Section Extraction Protocol
519 //
520 Status = InitializeSectionExtraction (gDxeCoreImageHandle, gDxeCoreST);
521 ASSERT_EFI_ERROR (Status);
522
523 //
524 // Initialize the DXE Dispatcher
525 //
526 CoreInitializeDispatcher ();
527
528 //
529 // Invoke the DXE Dispatcher
530 //
531 CoreDispatcher ();
532
533 //
534 // Display Architectural protocols that were not loaded if this is DEBUG build
535 //
536 DEBUG_CODE_BEGIN ();
537 CoreDisplayMissingArchProtocols ();
538 DEBUG_CODE_END ();
539
540 //
541 // Display any drivers that were not dispatched because dependency expression
542 // evaluated to false if this is a debug build
543 //
544 DEBUG_CODE_BEGIN ();
545 CoreDisplayDiscoveredNotDispatched ();
546 DEBUG_CODE_END ();
547
548 //
549 // Assert if the Architectural Protocols are not present.
550 //
551 Status = CoreAllEfiServicesAvailable ();
552 if (EFI_ERROR (Status)) {
553 //
554 // Report Status code that some Architectural Protocols are not present.
555 //
556 REPORT_STATUS_CODE (
557 EFI_ERROR_CODE | EFI_ERROR_MAJOR,
558 (EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_EC_NO_ARCH)
559 );
560 }
561
562 ASSERT_EFI_ERROR (Status);
563
564 //
565 // Report Status code before transfer control to BDS
566 //
567 REPORT_STATUS_CODE (
568 EFI_PROGRESS_CODE,
569 (EFI_SOFTWARE_DXE_CORE | EFI_SW_DXE_CORE_PC_HANDOFF_TO_NEXT)
570 );
571
572 //
573 // Transfer control to the BDS Architectural Protocol
574 //
575 gBds->Entry (gBds);
576
577 //
578 // BDS should never return
579 //
580 ASSERT (FALSE);
581 CpuDeadLoop ();
582
583 UNREACHABLE ();
584 }
585
586 /**
587 Place holder function until all the Boot Services and Runtime Services are
588 available.
589
590 @param Arg1 Undefined
591
592 @return EFI_NOT_AVAILABLE_YET
593
594 **/
595 EFI_STATUS
596 EFIAPI
597 CoreEfiNotAvailableYetArg1 (
598 UINTN Arg1
599 )
600 {
601 //
602 // This function should never be executed. If it does, then the architectural protocols
603 // have not been designed correctly. The CpuBreakpoint () is commented out for now until the
604 // DXE Core and all the Architectural Protocols are complete.
605 //
606
607 return EFI_NOT_AVAILABLE_YET;
608 }
609
610 /**
611 Place holder function until all the Boot Services and Runtime Services are available.
612
613 @param Arg1 Undefined
614 @param Arg2 Undefined
615
616 @return EFI_NOT_AVAILABLE_YET
617
618 **/
619 EFI_STATUS
620 EFIAPI
621 CoreEfiNotAvailableYetArg2 (
622 UINTN Arg1,
623 UINTN Arg2
624 )
625 {
626 //
627 // This function should never be executed. If it does, then the architectural protocols
628 // have not been designed correctly. The CpuBreakpoint () is commented out for now until the
629 // DXE Core and all the Architectural Protocols are complete.
630 //
631
632 return EFI_NOT_AVAILABLE_YET;
633 }
634
635 /**
636 Place holder function until all the Boot Services and Runtime Services are available.
637
638 @param Arg1 Undefined
639 @param Arg2 Undefined
640 @param Arg3 Undefined
641
642 @return EFI_NOT_AVAILABLE_YET
643
644 **/
645 EFI_STATUS
646 EFIAPI
647 CoreEfiNotAvailableYetArg3 (
648 UINTN Arg1,
649 UINTN Arg2,
650 UINTN Arg3
651 )
652 {
653 //
654 // This function should never be executed. If it does, then the architectural protocols
655 // have not been designed correctly. The CpuBreakpoint () is commented out for now until the
656 // DXE Core and all the Architectural Protocols are complete.
657 //
658
659 return EFI_NOT_AVAILABLE_YET;
660 }
661
662 /**
663 Place holder function until all the Boot Services and Runtime Services are available.
664
665 @param Arg1 Undefined
666 @param Arg2 Undefined
667 @param Arg3 Undefined
668 @param Arg4 Undefined
669
670 @return EFI_NOT_AVAILABLE_YET
671
672 **/
673 EFI_STATUS
674 EFIAPI
675 CoreEfiNotAvailableYetArg4 (
676 UINTN Arg1,
677 UINTN Arg2,
678 UINTN Arg3,
679 UINTN Arg4
680 )
681 {
682 //
683 // This function should never be executed. If it does, then the architectural protocols
684 // have not been designed correctly. The CpuBreakpoint () is commented out for now until the
685 // DXE Core and all the Architectural Protocols are complete.
686 //
687
688 return EFI_NOT_AVAILABLE_YET;
689 }
690
691 /**
692 Place holder function until all the Boot Services and Runtime Services are available.
693
694 @param Arg1 Undefined
695 @param Arg2 Undefined
696 @param Arg3 Undefined
697 @param Arg4 Undefined
698 @param Arg5 Undefined
699
700 @return EFI_NOT_AVAILABLE_YET
701
702 **/
703 EFI_STATUS
704 EFIAPI
705 CoreEfiNotAvailableYetArg5 (
706 UINTN Arg1,
707 UINTN Arg2,
708 UINTN Arg3,
709 UINTN Arg4,
710 UINTN Arg5
711 )
712 {
713 //
714 // This function should never be executed. If it does, then the architectural protocols
715 // have not been designed correctly. The CpuBreakpoint () is commented out for now until the
716 // DXE Core and all the Architectural Protocols are complete.
717 //
718
719 return EFI_NOT_AVAILABLE_YET;
720 }
721
722 /**
723 Calcualte the 32-bit CRC in a EFI table using the service provided by the
724 gRuntime service.
725
726 @param Hdr Pointer to an EFI standard header
727
728 **/
729 VOID
730 CalculateEfiHdrCrc (
731 IN OUT EFI_TABLE_HEADER *Hdr
732 )
733 {
734 UINT32 Crc;
735
736 Hdr->CRC32 = 0;
737
738 //
739 // If gBS->CalculateCrce32 () == CoreEfiNotAvailableYet () then
740 // Crc will come back as zero if we set it to zero here
741 //
742 Crc = 0;
743 gBS->CalculateCrc32 ((UINT8 *)Hdr, Hdr->HeaderSize, &Crc);
744 Hdr->CRC32 = Crc;
745 }
746
747 /**
748 Terminates all boot services.
749
750 @param ImageHandle Handle that identifies the exiting image.
751 @param MapKey Key to the latest memory map.
752
753 @retval EFI_SUCCESS Boot Services terminated
754 @retval EFI_INVALID_PARAMETER MapKey is incorrect.
755
756 **/
757 EFI_STATUS
758 EFIAPI
759 CoreExitBootServices (
760 IN EFI_HANDLE ImageHandle,
761 IN UINTN MapKey
762 )
763 {
764 EFI_STATUS Status;
765
766 //
767 // Disable Timer
768 //
769 gTimer->SetTimerPeriod (gTimer, 0);
770
771 //
772 // Terminate memory services if the MapKey matches
773 //
774 Status = CoreTerminateMemoryMap (MapKey);
775 if (EFI_ERROR (Status)) {
776 //
777 // Notify other drivers that ExitBootServices fail
778 //
779 CoreNotifySignalList (&gEventExitBootServicesFailedGuid);
780 return Status;
781 }
782
783 gMemoryMapTerminated = TRUE;
784
785 //
786 // Notify other drivers that we are exiting boot services.
787 //
788 CoreNotifySignalList (&gEfiEventExitBootServicesGuid);
789
790 //
791 // Report that ExitBootServices() has been called
792 //
793 REPORT_STATUS_CODE (
794 EFI_PROGRESS_CODE,
795 (EFI_SOFTWARE_EFI_BOOT_SERVICE | EFI_SW_BS_PC_EXIT_BOOT_SERVICES)
796 );
797
798 MemoryProtectionExitBootServicesCallback ();
799
800 //
801 // Disable interrupt of Debug timer.
802 //
803 SaveAndSetDebugTimerInterrupt (FALSE);
804
805 //
806 // Disable CPU Interrupts
807 //
808 gCpu->DisableInterrupt (gCpu);
809
810 //
811 // Clear the non-runtime values of the EFI System Table
812 //
813 gDxeCoreST->BootServices = NULL;
814 gDxeCoreST->ConIn = NULL;
815 gDxeCoreST->ConsoleInHandle = NULL;
816 gDxeCoreST->ConOut = NULL;
817 gDxeCoreST->ConsoleOutHandle = NULL;
818 gDxeCoreST->StdErr = NULL;
819 gDxeCoreST->StandardErrorHandle = NULL;
820
821 //
822 // Recompute the 32-bit CRC of the EFI System Table
823 //
824 CalculateEfiHdrCrc (&gDxeCoreST->Hdr);
825
826 //
827 // Zero out the Boot Service Table
828 //
829 ZeroMem (gBS, sizeof (EFI_BOOT_SERVICES));
830 gBS = NULL;
831
832 //
833 // Update the AtRuntime field in Runtiem AP.
834 //
835 gRuntime->AtRuntime = TRUE;
836
837 return Status;
838 }
839
840 /**
841 Given a compressed source buffer, this function retrieves the size of the
842 uncompressed buffer and the size of the scratch buffer required to decompress
843 the compressed source buffer.
844
845 The GetInfo() function retrieves the size of the uncompressed buffer and the
846 temporary scratch buffer required to decompress the buffer specified by Source
847 and SourceSize. If the size of the uncompressed buffer or the size of the
848 scratch buffer cannot be determined from the compressed data specified by
849 Source and SourceData, then EFI_INVALID_PARAMETER is returned. Otherwise, the
850 size of the uncompressed buffer is returned in DestinationSize, the size of
851 the scratch buffer is returned in ScratchSize, and EFI_SUCCESS is returned.
852 The GetInfo() function does not have scratch buffer available to perform a
853 thorough checking of the validity of the source data. It just retrieves the
854 "Original Size" field from the beginning bytes of the source data and output
855 it as DestinationSize. And ScratchSize is specific to the decompression
856 implementation.
857
858 @param This A pointer to the EFI_DECOMPRESS_PROTOCOL instance.
859 @param Source The source buffer containing the compressed data.
860 @param SourceSize The size, in bytes, of the source buffer.
861 @param DestinationSize A pointer to the size, in bytes, of the
862 uncompressed buffer that will be generated when the
863 compressed buffer specified by Source and
864 SourceSize is decompressed.
865 @param ScratchSize A pointer to the size, in bytes, of the scratch
866 buffer that is required to decompress the
867 compressed buffer specified by Source and
868 SourceSize.
869
870 @retval EFI_SUCCESS The size of the uncompressed data was returned in
871 DestinationSize and the size of the scratch buffer
872 was returned in ScratchSize.
873 @retval EFI_INVALID_PARAMETER The size of the uncompressed data or the size of
874 the scratch buffer cannot be determined from the
875 compressed data specified by Source and
876 SourceSize.
877
878 **/
879 EFI_STATUS
880 EFIAPI
881 DxeMainUefiDecompressGetInfo (
882 IN EFI_DECOMPRESS_PROTOCOL *This,
883 IN VOID *Source,
884 IN UINT32 SourceSize,
885 OUT UINT32 *DestinationSize,
886 OUT UINT32 *ScratchSize
887 )
888 {
889 if ((Source == NULL) || (DestinationSize == NULL) || (ScratchSize == NULL)) {
890 return EFI_INVALID_PARAMETER;
891 }
892
893 return UefiDecompressGetInfo (Source, SourceSize, DestinationSize, ScratchSize);
894 }
895
896 /**
897 Decompresses a compressed source buffer.
898
899 The Decompress() function extracts decompressed data to its original form.
900 This protocol is designed so that the decompression algorithm can be
901 implemented without using any memory services. As a result, the Decompress()
902 Function is not allowed to call AllocatePool() or AllocatePages() in its
903 implementation. It is the caller's responsibility to allocate and free the
904 Destination and Scratch buffers.
905 If the compressed source data specified by Source and SourceSize is
906 successfully decompressed into Destination, then EFI_SUCCESS is returned. If
907 the compressed source data specified by Source and SourceSize is not in a
908 valid compressed data format, then EFI_INVALID_PARAMETER is returned.
909
910 @param This A pointer to the EFI_DECOMPRESS_PROTOCOL instance.
911 @param Source The source buffer containing the compressed data.
912 @param SourceSize SourceSizeThe size of source data.
913 @param Destination On output, the destination buffer that contains
914 the uncompressed data.
915 @param DestinationSize The size of the destination buffer. The size of
916 the destination buffer needed is obtained from
917 EFI_DECOMPRESS_PROTOCOL.GetInfo().
918 @param Scratch A temporary scratch buffer that is used to perform
919 the decompression.
920 @param ScratchSize The size of scratch buffer. The size of the
921 scratch buffer needed is obtained from GetInfo().
922
923 @retval EFI_SUCCESS Decompression completed successfully, and the
924 uncompressed buffer is returned in Destination.
925 @retval EFI_INVALID_PARAMETER The source buffer specified by Source and
926 SourceSize is corrupted (not in a valid
927 compressed format).
928
929 **/
930 EFI_STATUS
931 EFIAPI
932 DxeMainUefiDecompress (
933 IN EFI_DECOMPRESS_PROTOCOL *This,
934 IN VOID *Source,
935 IN UINT32 SourceSize,
936 IN OUT VOID *Destination,
937 IN UINT32 DestinationSize,
938 IN OUT VOID *Scratch,
939 IN UINT32 ScratchSize
940 )
941 {
942 EFI_STATUS Status;
943 UINT32 TestDestinationSize;
944 UINT32 TestScratchSize;
945
946 if ((Source == NULL) || (Destination == NULL) || (Scratch == NULL)) {
947 return EFI_INVALID_PARAMETER;
948 }
949
950 Status = UefiDecompressGetInfo (Source, SourceSize, &TestDestinationSize, &TestScratchSize);
951 if (EFI_ERROR (Status)) {
952 return Status;
953 }
954
955 if ((ScratchSize < TestScratchSize) || (DestinationSize < TestDestinationSize)) {
956 return RETURN_INVALID_PARAMETER;
957 }
958
959 return UefiDecompress (Source, Destination, Scratch);
960 }
EFI Development Kit II mirror for PVE