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