Add comments for EFI_CACHE_SRAM_TYPE_DATA because of the inconsistency between CacheS...
[mirror_edk2.git] / MdeModulePkg / Core / Dxe / Dispatcher / Dispatcher.c
CommitLineData
162ed594 1/** @file\r
797a9d67 2 DXE Dispatcher.\r
28a00297 3\r
4 Step #1 - When a FV protocol is added to the system every driver in the FV\r
022c6d45 5 is added to the mDiscoveredList. The SOR, Before, and After Depex are\r
6 pre-processed as drivers are added to the mDiscoveredList. If an Apriori\r
7 file exists in the FV those drivers are addeded to the\r
8 mScheduledQueue. The mFvHandleList is used to make sure a\r
28a00297 9 FV is only processed once.\r
10\r
11 Step #2 - Dispatch. Remove driver from the mScheduledQueue and load and\r
022c6d45 12 start it. After mScheduledQueue is drained check the\r
13 mDiscoveredList to see if any item has a Depex that is ready to\r
28a00297 14 be placed on the mScheduledQueue.\r
15\r
022c6d45 16 Step #3 - Adding to the mScheduledQueue requires that you process Before\r
28a00297 17 and After dependencies. This is done recursively as the call to add\r
022c6d45 18 to the mScheduledQueue checks for Before and recursively adds\r
19 all Befores. It then addes the item that was passed in and then\r
28a00297 20 processess the After dependecies by recursively calling the routine.\r
21\r
22 Dispatcher Rules:\r
022c6d45 23 The rules for the dispatcher are in chapter 10 of the DXE CIS. Figure 10-3\r
28a00297 24 is the state diagram for the DXE dispatcher\r
25\r
26 Depex - Dependency Expresion.\r
27 SOR - Schedule On Request - Don't schedule if this bit is set.\r
28\r
54cd17e9 29Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
cd5ebaa0 30This program and the accompanying materials\r
23c98c94 31are licensed and made available under the terms and conditions of the BSD License\r
32which accompanies this distribution. The full text of the license may be found at\r
33http://opensource.org/licenses/bsd-license.php\r
34\r
35THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
36WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
797a9d67 37\r
38**/\r
28a00297 39\r
9c4ac31c 40#include "DxeMain.h"\r
28a00297 41\r
42//\r
43// The Driver List contains one copy of every driver that has been discovered.\r
44// Items are never removed from the driver list. List of EFI_CORE_DRIVER_ENTRY\r
45//\r
022c6d45 46LIST_ENTRY mDiscoveredList = INITIALIZE_LIST_HEAD_VARIABLE (mDiscoveredList);\r
28a00297 47\r
48//\r
49// Queue of drivers that are ready to dispatch. This queue is a subset of the\r
50// mDiscoveredList.list of EFI_CORE_DRIVER_ENTRY.\r
51//\r
52LIST_ENTRY mScheduledQueue = INITIALIZE_LIST_HEAD_VARIABLE (mScheduledQueue);\r
53\r
54//\r
55// List of handles who's Fv's have been parsed and added to the mFwDriverList.\r
56//\r
57LIST_ENTRY mFvHandleList = INITIALIZE_LIST_HEAD_VARIABLE (mFvHandleList); // list of KNOWN_HANDLE\r
58\r
59//\r
60// Lock for mDiscoveredList, mScheduledQueue, gDispatcherRunning.\r
61//\r
62EFI_LOCK mDispatcherLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_HIGH_LEVEL);\r
63\r
64\r
65//\r
66// Flag for the DXE Dispacher. TRUE if dispatcher is execuing.\r
67//\r
68BOOLEAN gDispatcherRunning = FALSE;\r
69\r
70//\r
71// Module globals to manage the FwVol registration notification event\r
72//\r
73EFI_EVENT mFwVolEvent;\r
74VOID *mFwVolEventRegistration;\r
75\r
76//\r
77// List of file types supported by dispatcher\r
78//\r
022c6d45 79EFI_FV_FILETYPE mDxeFileTypes[] = {\r
80 EFI_FV_FILETYPE_DRIVER,\r
202c3279 81 EFI_FV_FILETYPE_COMBINED_SMM_DXE,\r
022c6d45 82 EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER,\r
28a00297 83 EFI_FV_FILETYPE_DXE_CORE,\r
84 EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE\r
85};\r
86\r
87typedef struct {\r
88 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH File;\r
89 EFI_DEVICE_PATH_PROTOCOL End;\r
90} FV_FILEPATH_DEVICE_PATH;\r
91\r
92FV_FILEPATH_DEVICE_PATH mFvDevicePath;\r
93\r
94\r
95//\r
96// Function Prototypes\r
97//\r
162ed594 98/**\r
99 Insert InsertedDriverEntry onto the mScheduledQueue. To do this you\r
100 must add any driver with a before dependency on InsertedDriverEntry first.\r
101 You do this by recursively calling this routine. After all the Befores are\r
102 processed you can add InsertedDriverEntry to the mScheduledQueue.\r
103 Then you can add any driver with an After dependency on InsertedDriverEntry\r
104 by recursively calling this routine.\r
105\r
106 @param InsertedDriverEntry The driver to insert on the ScheduledLink Queue\r
107\r
108**/\r
28a00297 109VOID\r
110CoreInsertOnScheduledQueueWhileProcessingBeforeAndAfter (\r
111 IN EFI_CORE_DRIVER_ENTRY *InsertedDriverEntry\r
112 );\r
022c6d45 113\r
162ed594 114/**\r
115 Event notification that is fired every time a FV dispatch protocol is added.\r
116 More than one protocol may have been added when this event is fired, so you\r
117 must loop on CoreLocateHandle () to see how many protocols were added and\r
118 do the following to each FV:\r
119 If the Fv has already been processed, skip it. If the Fv has not been\r
120 processed then mark it as being processed, as we are about to process it.\r
121 Read the Fv and add any driver in the Fv to the mDiscoveredList.The\r
122 mDiscoveredList is never free'ed and contains variables that define\r
123 the other states the DXE driver transitions to..\r
124 While you are at it read the A Priori file into memory.\r
125 Place drivers in the A Priori list onto the mScheduledQueue.\r
126\r
022c6d45 127 @param Event The Event that is being processed, not used.\r
162ed594 128 @param Context Event Context, not used.\r
129\r
130**/\r
28a00297 131VOID\r
132EFIAPI\r
133CoreFwVolEventProtocolNotify (\r
134 IN EFI_EVENT Event,\r
135 IN VOID *Context\r
136 );\r
137\r
162ed594 138/**\r
022c6d45 139 Convert FvHandle and DriverName into an EFI device path\r
162ed594 140\r
022c6d45 141 @param Fv Fv protocol, needed to read Depex info out of\r
142 FLASH.\r
143 @param FvHandle Handle for Fv, needed in the\r
144 EFI_CORE_DRIVER_ENTRY so that the PE image can be\r
145 read out of the FV at a later time.\r
146 @param DriverName Name of driver to add to mDiscoveredList.\r
162ed594 147\r
148 @return Pointer to device path constructed from FvHandle and DriverName\r
149\r
150**/\r
28a00297 151EFI_DEVICE_PATH_PROTOCOL *\r
152CoreFvToDevicePath (\r
0c2b5da8 153 IN EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv,\r
28a00297 154 IN EFI_HANDLE FvHandle,\r
155 IN EFI_GUID *DriverName\r
156 );\r
157\r
162ed594 158/**\r
159 Add an entry to the mDiscoveredList. Allocate memory to store the DriverEntry,\r
160 and initilize any state variables. Read the Depex from the FV and store it\r
161 in DriverEntry. Pre-process the Depex to set the SOR, Before and After state.\r
162 The Discovered list is never free'ed and contains booleans that represent the\r
163 other possible DXE driver states.\r
164\r
022c6d45 165 @param Fv Fv protocol, needed to read Depex info out of\r
166 FLASH.\r
167 @param FvHandle Handle for Fv, needed in the\r
168 EFI_CORE_DRIVER_ENTRY so that the PE image can be\r
169 read out of the FV at a later time.\r
170 @param DriverName Name of driver to add to mDiscoveredList.\r
d3592549 171 @param Type Fv File Type of file to add to mDiscoveredList.\r
162ed594 172\r
022c6d45 173 @retval EFI_SUCCESS If driver was added to the mDiscoveredList.\r
174 @retval EFI_ALREADY_STARTED The driver has already been started. Only one\r
175 DriverName may be active in the system at any one\r
162ed594 176 time.\r
177\r
178**/\r
28a00297 179EFI_STATUS\r
180CoreAddToDriverList (\r
23c98c94 181 IN EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv,\r
182 IN EFI_HANDLE FvHandle,\r
d3592549
LG
183 IN EFI_GUID *DriverName,\r
184 IN EFI_FV_FILETYPE Type\r
28a00297 185 );\r
186\r
162ed594 187/**\r
188 Get the driver from the FV through driver name, and produce a FVB protocol on FvHandle.\r
189\r
022c6d45 190 @param Fv The FIRMWARE_VOLUME protocol installed on the FV.\r
191 @param FvHandle The handle which FVB protocol installed on.\r
192 @param DriverName The driver guid specified.\r
162ed594 193\r
022c6d45 194 @retval EFI_OUT_OF_RESOURCES No enough memory or other resource.\r
195 @retval EFI_VOLUME_CORRUPTED Corrupted volume.\r
162ed594 196 @retval EFI_SUCCESS Function successfully returned.\r
197\r
198**/\r
022c6d45 199EFI_STATUS\r
28a00297 200CoreProcessFvImageFile (\r
0c2b5da8 201 IN EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv,\r
28a00297 202 IN EFI_HANDLE FvHandle,\r
203 IN EFI_GUID *DriverName\r
204 );\r
205\r
162ed594 206\r
207/**\r
208 Enter critical section by gaining lock on mDispatcherLock.\r
209\r
210**/\r
28a00297 211VOID\r
212CoreAcquireDispatcherLock (\r
213 VOID\r
214 )\r
28a00297 215{\r
216 CoreAcquireLock (&mDispatcherLock);\r
217}\r
218\r
162ed594 219\r
220/**\r
221 Exit critical section by releasing lock on mDispatcherLock.\r
222\r
223**/\r
28a00297 224VOID\r
225CoreReleaseDispatcherLock (\r
226 VOID\r
227 )\r
28a00297 228{\r
229 CoreReleaseLock (&mDispatcherLock);\r
230}\r
231\r
28a00297 232\r
162ed594 233/**\r
28a00297 234 Read Depex and pre-process the Depex for Before and After. If Section Extraction\r
235 protocol returns an error via ReadSection defer the reading of the Depex.\r
236\r
022c6d45 237 @param DriverEntry Driver to work on.\r
28a00297 238\r
022c6d45 239 @retval EFI_SUCCESS Depex read and preprossesed\r
240 @retval EFI_PROTOCOL_ERROR The section extraction protocol returned an error\r
241 and Depex reading needs to be retried.\r
162ed594 242 @retval Error DEPEX not found.\r
28a00297 243\r
162ed594 244**/\r
162ed594 245EFI_STATUS\r
246CoreGetDepexSectionAndPreProccess (\r
247 IN EFI_CORE_DRIVER_ENTRY *DriverEntry\r
248 )\r
28a00297 249{\r
250 EFI_STATUS Status;\r
251 EFI_SECTION_TYPE SectionType;\r
252 UINT32 AuthenticationStatus;\r
0c2b5da8 253 EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;\r
28a00297 254\r
022c6d45 255\r
28a00297 256 Fv = DriverEntry->Fv;\r
257\r
258 //\r
259 // Grab Depex info, it will never be free'ed.\r
260 //\r
261 SectionType = EFI_SECTION_DXE_DEPEX;\r
262 Status = Fv->ReadSection (\r
022c6d45 263 DriverEntry->Fv,\r
28a00297 264 &DriverEntry->FileName,\r
022c6d45 265 SectionType,\r
266 0,\r
267 &DriverEntry->Depex,\r
28a00297 268 (UINTN *)&DriverEntry->DepexSize,\r
269 &AuthenticationStatus\r
270 );\r
271 if (EFI_ERROR (Status)) {\r
272 if (Status == EFI_PROTOCOL_ERROR) {\r
273 //\r
274 // The section extraction protocol failed so set protocol error flag\r
275 //\r
276 DriverEntry->DepexProtocolError = TRUE;\r
277 } else {\r
278 //\r
8a7d75b0 279 // If no Depex assume UEFI 2.0 driver model\r
28a00297 280 //\r
281 DriverEntry->Depex = NULL;\r
282 DriverEntry->Dependent = TRUE;\r
283 DriverEntry->DepexProtocolError = FALSE;\r
284 }\r
285 } else {\r
286 //\r
287 // Set Before, After, and Unrequested state information based on Depex\r
288 // Driver will be put in Dependent or Unrequested state\r
289 //\r
290 CorePreProcessDepex (DriverEntry);\r
291 DriverEntry->DepexProtocolError = FALSE;\r
022c6d45 292 }\r
28a00297 293\r
294 return Status;\r
295}\r
296\r
162ed594 297\r
298/**\r
299 Check every driver and locate a matching one. If the driver is found, the Unrequested\r
300 state flag is cleared.\r
301\r
022c6d45 302 @param FirmwareVolumeHandle The handle of the Firmware Volume that contains\r
303 the firmware file specified by DriverName.\r
304 @param DriverName The Driver name to put in the Dependent state.\r
162ed594 305\r
022c6d45 306 @retval EFI_SUCCESS The DriverName was found and it's SOR bit was\r
307 cleared\r
308 @retval EFI_NOT_FOUND The DriverName does not exist or it's SOR bit was\r
309 not set.\r
162ed594 310\r
311**/\r
28a00297 312EFI_STATUS\r
313EFIAPI\r
314CoreSchedule (\r
315 IN EFI_HANDLE FirmwareVolumeHandle,\r
316 IN EFI_GUID *DriverName\r
317 )\r
28a00297 318{\r
319 LIST_ENTRY *Link;\r
320 EFI_CORE_DRIVER_ENTRY *DriverEntry;\r
321\r
322 //\r
323 // Check every driver\r
324 //\r
325 for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {\r
326 DriverEntry = CR(Link, EFI_CORE_DRIVER_ENTRY, Link, EFI_CORE_DRIVER_ENTRY_SIGNATURE);\r
327 if (DriverEntry->FvHandle == FirmwareVolumeHandle &&\r
022c6d45 328 DriverEntry->Unrequested &&\r
28a00297 329 CompareGuid (DriverName, &DriverEntry->FileName)) {\r
330 //\r
331 // Move the driver from the Unrequested to the Dependent state\r
332 //\r
333 CoreAcquireDispatcherLock ();\r
334 DriverEntry->Unrequested = FALSE;\r
335 DriverEntry->Dependent = TRUE;\r
336 CoreReleaseDispatcherLock ();\r
022c6d45 337\r
6a55eea3 338 DEBUG ((DEBUG_DISPATCH, "Schedule FFS(%g) - EFI_SUCCESS\n", DriverName));\r
339 \r
28a00297 340 return EFI_SUCCESS;\r
341 }\r
342 }\r
6a55eea3 343 \r
344 DEBUG ((DEBUG_DISPATCH, "Schedule FFS(%g) - EFI_NOT_FOUND\n", DriverName));\r
345 \r
022c6d45 346 return EFI_NOT_FOUND;\r
28a00297 347}\r
348\r
349\r
162ed594 350\r
351/**\r
e94a9ff7 352 Convert a driver from the Untrused back to the Scheduled state.\r
162ed594 353\r
022c6d45 354 @param FirmwareVolumeHandle The handle of the Firmware Volume that contains\r
355 the firmware file specified by DriverName.\r
356 @param DriverName The Driver name to put in the Scheduled state\r
162ed594 357\r
022c6d45 358 @retval EFI_SUCCESS The file was found in the untrusted state, and it\r
359 was promoted to the trusted state.\r
360 @retval EFI_NOT_FOUND The file was not found in the untrusted state.\r
162ed594 361\r
362**/\r
28a00297 363EFI_STATUS\r
364EFIAPI\r
365CoreTrust (\r
366 IN EFI_HANDLE FirmwareVolumeHandle,\r
367 IN EFI_GUID *DriverName\r
368 )\r
28a00297 369{\r
370 LIST_ENTRY *Link;\r
371 EFI_CORE_DRIVER_ENTRY *DriverEntry;\r
372\r
373 //\r
374 // Check every driver\r
375 //\r
376 for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {\r
377 DriverEntry = CR(Link, EFI_CORE_DRIVER_ENTRY, Link, EFI_CORE_DRIVER_ENTRY_SIGNATURE);\r
378 if (DriverEntry->FvHandle == FirmwareVolumeHandle &&\r
022c6d45 379 DriverEntry->Untrusted &&\r
28a00297 380 CompareGuid (DriverName, &DriverEntry->FileName)) {\r
381 //\r
382 // Transition driver from Untrusted to Scheduled state.\r
383 //\r
384 CoreAcquireDispatcherLock ();\r
385 DriverEntry->Untrusted = FALSE;\r
386 DriverEntry->Scheduled = TRUE;\r
387 InsertTailList (&mScheduledQueue, &DriverEntry->ScheduledLink);\r
388 CoreReleaseDispatcherLock ();\r
022c6d45 389\r
28a00297 390 return EFI_SUCCESS;\r
391 }\r
392 }\r
022c6d45 393 return EFI_NOT_FOUND;\r
28a00297 394}\r
395\r
396\r
202c3279 397/**\r
398 An empty function to pass error checking of CreateEventEx ().\r
399\r
400 @param Event Event whose notification function is being invoked.\r
401 @param Context Pointer to the notification function's context,\r
402 which is implementation-dependent.\r
403\r
404**/\r
405VOID\r
406EFIAPI\r
54cd17e9 407CoreEmptyCallbackFunction (\r
202c3279 408 IN EFI_EVENT Event,\r
409 IN VOID *Context\r
410 )\r
411{\r
412 return;\r
413}\r
28a00297 414\r
162ed594 415/**\r
416 This is the main Dispatcher for DXE and it exits when there are no more\r
28a00297 417 drivers to run. Drain the mScheduledQueue and load and start a PE\r
162ed594 418 image for each driver. Search the mDiscoveredList to see if any driver can\r
28a00297 419 be placed on the mScheduledQueue. If no drivers are placed on the\r
420 mScheduledQueue exit the function. On exit it is assumed the Bds()\r
162ed594 421 will be called, and when the Bds() exits the Dispatcher will be called\r
28a00297 422 again.\r
423\r
022c6d45 424 @retval EFI_ALREADY_STARTED The DXE Dispatcher is already running\r
425 @retval EFI_NOT_FOUND No DXE Drivers were dispatched\r
426 @retval EFI_SUCCESS One or more DXE Drivers were dispatched\r
28a00297 427\r
162ed594 428**/\r
162ed594 429EFI_STATUS\r
430EFIAPI\r
431CoreDispatcher (\r
432 VOID\r
433 )\r
28a00297 434{\r
435 EFI_STATUS Status;\r
436 EFI_STATUS ReturnStatus;\r
437 LIST_ENTRY *Link;\r
438 EFI_CORE_DRIVER_ENTRY *DriverEntry;\r
439 BOOLEAN ReadyToRun;\r
202c3279 440 EFI_EVENT DxeDispatchEvent;\r
441 \r
28a00297 442\r
443 if (gDispatcherRunning) {\r
444 //\r
445 // If the dispatcher is running don't let it be restarted.\r
446 //\r
447 return EFI_ALREADY_STARTED;\r
448 }\r
449\r
450 gDispatcherRunning = TRUE;\r
451\r
202c3279 452 Status = CoreCreateEventEx (\r
453 EVT_NOTIFY_SIGNAL,\r
454 TPL_NOTIFY,\r
54cd17e9 455 CoreEmptyCallbackFunction,\r
202c3279 456 NULL,\r
457 &gEfiEventDxeDispatchGuid,\r
458 &DxeDispatchEvent\r
459 );\r
460 if (EFI_ERROR (Status)) {\r
461 return Status;\r
462 }\r
28a00297 463\r
464 ReturnStatus = EFI_NOT_FOUND;\r
465 do {\r
466 //\r
467 // Drain the Scheduled Queue\r
468 //\r
469 while (!IsListEmpty (&mScheduledQueue)) {\r
470 DriverEntry = CR (\r
471 mScheduledQueue.ForwardLink,\r
472 EFI_CORE_DRIVER_ENTRY,\r
473 ScheduledLink,\r
474 EFI_CORE_DRIVER_ENTRY_SIGNATURE\r
475 );\r
476\r
477 //\r
478 // Load the DXE Driver image into memory. If the Driver was transitioned from\r
479 // Untrused to Scheduled it would have already been loaded so we may need to\r
480 // skip the LoadImage\r
481 //\r
d3592549 482 if (DriverEntry->ImageHandle == NULL && !DriverEntry->IsFvImage) {\r
94903510 483 DEBUG ((DEBUG_INFO, "Loading driver %g\n", &DriverEntry->FileName));\r
28a00297 484 Status = CoreLoadImage (\r
022c6d45 485 FALSE,\r
486 gDxeCoreImageHandle,\r
28a00297 487 DriverEntry->FvFileDevicePath,\r
022c6d45 488 NULL,\r
489 0,\r
28a00297 490 &DriverEntry->ImageHandle\r
491 );\r
492\r
493 //\r
494 // Update the driver state to reflect that it's been loaded\r
495 //\r
496 if (EFI_ERROR (Status)) {\r
497 CoreAcquireDispatcherLock ();\r
498\r
499 if (Status == EFI_SECURITY_VIOLATION) {\r
500 //\r
501 // Take driver from Scheduled to Untrused state\r
502 //\r
503 DriverEntry->Untrusted = TRUE;\r
504 } else {\r
505 //\r
506 // The DXE Driver could not be loaded, and do not attempt to load or start it again.\r
022c6d45 507 // Take driver from Scheduled to Initialized.\r
28a00297 508 //\r
509 // This case include the Never Trusted state if EFI_ACCESS_DENIED is returned\r
510 //\r
511 DriverEntry->Initialized = TRUE;\r
512 }\r
513\r
514 DriverEntry->Scheduled = FALSE;\r
515 RemoveEntryList (&DriverEntry->ScheduledLink);\r
022c6d45 516\r
28a00297 517 CoreReleaseDispatcherLock ();\r
022c6d45 518\r
28a00297 519 //\r
520 // If it's an error don't try the StartImage\r
521 //\r
522 continue;\r
523 }\r
524 }\r
525\r
526 CoreAcquireDispatcherLock ();\r
527\r
528 DriverEntry->Scheduled = FALSE;\r
529 DriverEntry->Initialized = TRUE;\r
530 RemoveEntryList (&DriverEntry->ScheduledLink);\r
022c6d45 531\r
28a00297 532 CoreReleaseDispatcherLock ();\r
533\r
2680a308 534 \r
d3592549
LG
535 if (DriverEntry->IsFvImage) {\r
536 //\r
537 // Produce a firmware volume block protocol for FvImage so it gets dispatched from. \r
538 //\r
539 Status = CoreProcessFvImageFile (DriverEntry->Fv, DriverEntry->FvHandle, &DriverEntry->FileName);\r
540 } else {\r
541 REPORT_STATUS_CODE_WITH_EXTENDED_DATA (\r
542 EFI_PROGRESS_CODE,\r
543 (EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_BEGIN),\r
544 &DriverEntry->ImageHandle,\r
545 sizeof (DriverEntry->ImageHandle)\r
546 );\r
547 \r
548 Status = CoreStartImage (DriverEntry->ImageHandle, NULL, NULL);\r
549 \r
550 REPORT_STATUS_CODE_WITH_EXTENDED_DATA (\r
551 EFI_PROGRESS_CODE,\r
552 (EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_END),\r
553 &DriverEntry->ImageHandle,\r
554 sizeof (DriverEntry->ImageHandle)\r
555 );\r
556 }\r
28a00297 557\r
558 ReturnStatus = EFI_SUCCESS;\r
559 }\r
560\r
0e4483bc
LG
561 //\r
562 // Now DXE Dispatcher finished one round of dispatch, signal an event group\r
563 // so that SMM Dispatcher get chance to dispatch SMM Drivers which depend\r
564 // on UEFI protocols\r
565 //\r
566 if (!EFI_ERROR (ReturnStatus)) {\r
567 CoreSignalEvent (DxeDispatchEvent);\r
568 }\r
569\r
28a00297 570 //\r
571 // Search DriverList for items to place on Scheduled Queue\r
572 //\r
573 ReadyToRun = FALSE;\r
574 for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {\r
575 DriverEntry = CR (Link, EFI_CORE_DRIVER_ENTRY, Link, EFI_CORE_DRIVER_ENTRY_SIGNATURE);\r
576\r
577 if (DriverEntry->DepexProtocolError){\r
578 //\r
579 // If Section Extraction Protocol did not let the Depex be read before retry the read\r
580 //\r
581 Status = CoreGetDepexSectionAndPreProccess (DriverEntry);\r
022c6d45 582 }\r
28a00297 583\r
584 if (DriverEntry->Dependent) {\r
585 if (CoreIsSchedulable (DriverEntry)) {\r
022c6d45 586 CoreInsertOnScheduledQueueWhileProcessingBeforeAndAfter (DriverEntry);\r
28a00297 587 ReadyToRun = TRUE;\r
022c6d45 588 }\r
6a55eea3 589 } else {\r
590 if (DriverEntry->Unrequested) {\r
591 DEBUG ((DEBUG_DISPATCH, "Evaluate DXE DEPEX for FFS(%g)\n", &DriverEntry->FileName));\r
592 DEBUG ((DEBUG_DISPATCH, " SOR = Not Requested\n"));\r
593 DEBUG ((DEBUG_DISPATCH, " RESULT = FALSE\n"));\r
594 }\r
28a00297 595 }\r
596 }\r
597 } while (ReadyToRun);\r
598\r
202c3279 599 //\r
600 // Close DXE dispatch Event\r
601 //\r
602 CoreCloseEvent (DxeDispatchEvent);\r
603\r
28a00297 604 gDispatcherRunning = FALSE;\r
605\r
606 return ReturnStatus;\r
607}\r
608\r
28a00297 609\r
162ed594 610/**\r
611 Insert InsertedDriverEntry onto the mScheduledQueue. To do this you\r
28a00297 612 must add any driver with a before dependency on InsertedDriverEntry first.\r
613 You do this by recursively calling this routine. After all the Befores are\r
162ed594 614 processed you can add InsertedDriverEntry to the mScheduledQueue.\r
615 Then you can add any driver with an After dependency on InsertedDriverEntry\r
28a00297 616 by recursively calling this routine.\r
617\r
162ed594 618 @param InsertedDriverEntry The driver to insert on the ScheduledLink Queue\r
28a00297 619\r
162ed594 620**/\r
162ed594 621VOID\r
622CoreInsertOnScheduledQueueWhileProcessingBeforeAndAfter (\r
623 IN EFI_CORE_DRIVER_ENTRY *InsertedDriverEntry\r
624 )\r
28a00297 625{\r
626 LIST_ENTRY *Link;\r
627 EFI_CORE_DRIVER_ENTRY *DriverEntry;\r
628\r
629 //\r
630 // Process Before Dependency\r
631 //\r
632 for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {\r
633 DriverEntry = CR(Link, EFI_CORE_DRIVER_ENTRY, Link, EFI_CORE_DRIVER_ENTRY_SIGNATURE);\r
6a55eea3 634 if (DriverEntry->Before && DriverEntry->Dependent && DriverEntry != InsertedDriverEntry) {\r
635 DEBUG ((DEBUG_DISPATCH, "Evaluate DXE DEPEX for FFS(%g)\n", &DriverEntry->FileName));\r
636 DEBUG ((DEBUG_DISPATCH, " BEFORE FFS(%g) = ", &DriverEntry->BeforeAfterGuid));\r
28a00297 637 if (CompareGuid (&InsertedDriverEntry->FileName, &DriverEntry->BeforeAfterGuid)) {\r
638 //\r
639 // Recursively process BEFORE\r
640 //\r
6a55eea3 641 DEBUG ((DEBUG_DISPATCH, "TRUE\n END\n RESULT = TRUE\n"));\r
28a00297 642 CoreInsertOnScheduledQueueWhileProcessingBeforeAndAfter (DriverEntry);\r
6a55eea3 643 } else {\r
644 DEBUG ((DEBUG_DISPATCH, "FALSE\n END\n RESULT = FALSE\n"));\r
28a00297 645 }\r
646 }\r
647 }\r
648\r
649 //\r
650 // Convert driver from Dependent to Scheduled state\r
651 //\r
652 CoreAcquireDispatcherLock ();\r
653\r
654 InsertedDriverEntry->Dependent = FALSE;\r
655 InsertedDriverEntry->Scheduled = TRUE;\r
656 InsertTailList (&mScheduledQueue, &InsertedDriverEntry->ScheduledLink);\r
022c6d45 657\r
28a00297 658 CoreReleaseDispatcherLock ();\r
659\r
660 //\r
661 // Process After Dependency\r
662 //\r
663 for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {\r
664 DriverEntry = CR(Link, EFI_CORE_DRIVER_ENTRY, Link, EFI_CORE_DRIVER_ENTRY_SIGNATURE);\r
6a55eea3 665 if (DriverEntry->After && DriverEntry->Dependent && DriverEntry != InsertedDriverEntry) {\r
666 DEBUG ((DEBUG_DISPATCH, "Evaluate DXE DEPEX for FFS(%g)\n", &DriverEntry->FileName));\r
667 DEBUG ((DEBUG_DISPATCH, " AFTER FFS(%g) = ", &DriverEntry->BeforeAfterGuid));\r
28a00297 668 if (CompareGuid (&InsertedDriverEntry->FileName, &DriverEntry->BeforeAfterGuid)) {\r
669 //\r
670 // Recursively process AFTER\r
671 //\r
6a55eea3 672 DEBUG ((DEBUG_DISPATCH, "TRUE\n END\n RESULT = TRUE\n"));\r
28a00297 673 CoreInsertOnScheduledQueueWhileProcessingBeforeAndAfter (DriverEntry);\r
6a55eea3 674 } else {\r
675 DEBUG ((DEBUG_DISPATCH, "FALSE\n END\n RESULT = FALSE\n"));\r
28a00297 676 }\r
677 }\r
678 }\r
679}\r
680\r
28a00297 681\r
162ed594 682/**\r
28a00297 683 Return TRUE if the Fv has been processed, FALSE if not.\r
684\r
022c6d45 685 @param FvHandle The handle of a FV that's being tested\r
28a00297 686\r
022c6d45 687 @retval TRUE Fv protocol on FvHandle has been processed\r
e94a9ff7 688 @retval FALSE Fv protocol on FvHandle has not yet been processed\r
28a00297 689\r
162ed594 690**/\r
162ed594 691BOOLEAN\r
692FvHasBeenProcessed (\r
693 IN EFI_HANDLE FvHandle\r
694 )\r
28a00297 695{\r
696 LIST_ENTRY *Link;\r
697 KNOWN_HANDLE *KnownHandle;\r
698\r
699 for (Link = mFvHandleList.ForwardLink; Link != &mFvHandleList; Link = Link->ForwardLink) {\r
700 KnownHandle = CR(Link, KNOWN_HANDLE, Link, KNOWN_HANDLE_SIGNATURE);\r
701 if (KnownHandle->Handle == FvHandle) {\r
702 return TRUE;\r
703 }\r
704 }\r
705 return FALSE;\r
706}\r
707\r
28a00297 708\r
162ed594 709/**\r
28a00297 710 Remember that Fv protocol on FvHandle has had it's drivers placed on the\r
711 mDiscoveredList. This fucntion adds entries on the mFvHandleList. Items are\r
712 never removed/freed from the mFvHandleList.\r
713\r
162ed594 714 @param FvHandle The handle of a FV that has been processed\r
28a00297 715\r
162ed594 716**/\r
162ed594 717VOID\r
718FvIsBeingProcesssed (\r
719 IN EFI_HANDLE FvHandle\r
720 )\r
28a00297 721{\r
722 KNOWN_HANDLE *KnownHandle;\r
723\r
9c4ac31c 724 KnownHandle = AllocatePool (sizeof (KNOWN_HANDLE));\r
28a00297 725 ASSERT (KnownHandle != NULL);\r
726\r
727 KnownHandle->Signature = KNOWN_HANDLE_SIGNATURE;\r
728 KnownHandle->Handle = FvHandle;\r
729 InsertTailList (&mFvHandleList, &KnownHandle->Link);\r
730}\r
731\r
732\r
733\r
162ed594 734\r
735/**\r
736 Convert FvHandle and DriverName into an EFI device path\r
737\r
022c6d45 738 @param Fv Fv protocol, needed to read Depex info out of\r
739 FLASH.\r
740 @param FvHandle Handle for Fv, needed in the\r
741 EFI_CORE_DRIVER_ENTRY so that the PE image can be\r
742 read out of the FV at a later time.\r
743 @param DriverName Name of driver to add to mDiscoveredList.\r
162ed594 744\r
745 @return Pointer to device path constructed from FvHandle and DriverName\r
746\r
747**/\r
28a00297 748EFI_DEVICE_PATH_PROTOCOL *\r
749CoreFvToDevicePath (\r
0c2b5da8 750 IN EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv,\r
28a00297 751 IN EFI_HANDLE FvHandle,\r
752 IN EFI_GUID *DriverName\r
753 )\r
28a00297 754{\r
755 EFI_STATUS Status;\r
756 EFI_DEVICE_PATH_PROTOCOL *FvDevicePath;\r
757 EFI_DEVICE_PATH_PROTOCOL *FileNameDevicePath;\r
758\r
759 //\r
760 // Remember the device path of the FV\r
761 //\r
762 Status = CoreHandleProtocol (FvHandle, &gEfiDevicePathProtocolGuid, (VOID **)&FvDevicePath);\r
763 if (EFI_ERROR (Status)) {\r
764 FileNameDevicePath = NULL;\r
765 } else {\r
766 //\r
767 // Build a device path to the file in the FV to pass into gBS->LoadImage\r
768 //\r
769 EfiInitializeFwVolDevicepathNode (&mFvDevicePath.File, DriverName);\r
1232b214 770 SetDevicePathEndNode (&mFvDevicePath.End);\r
28a00297 771\r
9c4ac31c 772 FileNameDevicePath = AppendDevicePath (\r
022c6d45 773 FvDevicePath,\r
28a00297 774 (EFI_DEVICE_PATH_PROTOCOL *)&mFvDevicePath\r
775 );\r
776 }\r
777\r
778 return FileNameDevicePath;\r
779}\r
780\r
781\r
782\r
162ed594 783/**\r
784 Add an entry to the mDiscoveredList. Allocate memory to store the DriverEntry,\r
28a00297 785 and initilize any state variables. Read the Depex from the FV and store it\r
786 in DriverEntry. Pre-process the Depex to set the SOR, Before and After state.\r
787 The Discovered list is never free'ed and contains booleans that represent the\r
788 other possible DXE driver states.\r
789\r
022c6d45 790 @param Fv Fv protocol, needed to read Depex info out of\r
791 FLASH.\r
792 @param FvHandle Handle for Fv, needed in the\r
793 EFI_CORE_DRIVER_ENTRY so that the PE image can be\r
794 read out of the FV at a later time.\r
795 @param DriverName Name of driver to add to mDiscoveredList.\r
d3592549 796 @param Type Fv File Type of file to add to mDiscoveredList.\r
28a00297 797\r
022c6d45 798 @retval EFI_SUCCESS If driver was added to the mDiscoveredList.\r
799 @retval EFI_ALREADY_STARTED The driver has already been started. Only one\r
800 DriverName may be active in the system at any one\r
162ed594 801 time.\r
28a00297 802\r
162ed594 803**/\r
804EFI_STATUS\r
805CoreAddToDriverList (\r
806 IN EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv,\r
807 IN EFI_HANDLE FvHandle,\r
d3592549
LG
808 IN EFI_GUID *DriverName,\r
809 IN EFI_FV_FILETYPE Type\r
162ed594 810 )\r
28a00297 811{\r
812 EFI_CORE_DRIVER_ENTRY *DriverEntry;\r
813\r
022c6d45 814\r
28a00297 815 //\r
022c6d45 816 // Create the Driver Entry for the list. ZeroPool initializes lots of variables to\r
28a00297 817 // NULL or FALSE.\r
818 //\r
9c4ac31c 819 DriverEntry = AllocateZeroPool (sizeof (EFI_CORE_DRIVER_ENTRY));\r
28a00297 820 ASSERT (DriverEntry != NULL);\r
d3592549
LG
821 if (Type == EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE) {\r
822 DriverEntry->IsFvImage = TRUE;\r
823 }\r
28a00297 824\r
825 DriverEntry->Signature = EFI_CORE_DRIVER_ENTRY_SIGNATURE;\r
e94a9ff7 826 CopyGuid (&DriverEntry->FileName, DriverName);\r
28a00297 827 DriverEntry->FvHandle = FvHandle;\r
828 DriverEntry->Fv = Fv;\r
829 DriverEntry->FvFileDevicePath = CoreFvToDevicePath (Fv, FvHandle, DriverName);\r
830\r
831 CoreGetDepexSectionAndPreProccess (DriverEntry);\r
022c6d45 832\r
28a00297 833 CoreAcquireDispatcherLock ();\r
022c6d45 834\r
28a00297 835 InsertTailList (&mDiscoveredList, &DriverEntry->Link);\r
836\r
837 CoreReleaseDispatcherLock ();\r
838\r
839 return EFI_SUCCESS;\r
840}\r
841\r
bbc0f1bb 842\r
162ed594 843/**\r
bbc0f1bb 844 Check if a FV Image type file (EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE) is\r
845 described by a EFI_HOB_FIRMWARE_VOLUME2 Hob.\r
846\r
022c6d45 847 @param FvHandle The handle which FVB protocol installed on.\r
848 @param DriverName The driver guid specified.\r
bbc0f1bb 849\r
022c6d45 850 @retval TRUE This file is found in a EFI_HOB_FIRMWARE_VOLUME2\r
851 Hob.\r
162ed594 852 @retval FALSE Not found.\r
bbc0f1bb 853\r
162ed594 854**/\r
162ed594 855BOOLEAN\r
856FvFoundInHobFv2 (\r
857 IN EFI_HANDLE FvHandle,\r
858 IN CONST EFI_GUID *DriverName\r
859 )\r
bbc0f1bb 860{\r
861 EFI_PEI_HOB_POINTERS HobFv2;\r
022c6d45 862\r
bbc0f1bb 863 HobFv2.Raw = GetHobList ();\r
022c6d45 864\r
bbc0f1bb 865 while ((HobFv2.Raw = GetNextHob (EFI_HOB_TYPE_FV2, HobFv2.Raw)) != NULL) {\r
866 if (CompareGuid (DriverName, &HobFv2.FirmwareVolume2->FileName)) {\r
b0d803fe 867 return TRUE;\r
bbc0f1bb 868 }\r
869 HobFv2.Raw = GET_NEXT_HOB (HobFv2);\r
870 }\r
871\r
872 return FALSE;\r
873}\r
28a00297 874\r
875\r
162ed594 876\r
877/**\r
878 Get the driver from the FV through driver name, and produce a FVB protocol on FvHandle.\r
879\r
022c6d45 880 @param Fv The FIRMWARE_VOLUME protocol installed on the FV.\r
881 @param FvHandle The handle which FVB protocol installed on.\r
882 @param DriverName The driver guid specified.\r
162ed594 883\r
022c6d45 884 @retval EFI_OUT_OF_RESOURCES No enough memory or other resource.\r
885 @retval EFI_VOLUME_CORRUPTED Corrupted volume.\r
162ed594 886 @retval EFI_SUCCESS Function successfully returned.\r
887\r
888**/\r
022c6d45 889EFI_STATUS\r
28a00297 890CoreProcessFvImageFile (\r
0c2b5da8 891 IN EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv,\r
28a00297 892 IN EFI_HANDLE FvHandle,\r
893 IN EFI_GUID *DriverName\r
894 )\r
28a00297 895{\r
896 EFI_STATUS Status;\r
897 EFI_SECTION_TYPE SectionType;\r
898 UINT32 AuthenticationStatus;\r
899 VOID *Buffer;\r
38837959 900 VOID *AlignedBuffer;\r
28a00297 901 UINTN BufferSize;\r
38837959 902 EFI_FIRMWARE_VOLUME_HEADER *FvHeader;\r
022c6d45 903 UINT32 FvAlignment;\r
28a00297 904\r
905 //\r
906 // Read the first (and only the first) firmware volume section\r
907 //\r
e94a9ff7 908 SectionType = EFI_SECTION_FIRMWARE_VOLUME_IMAGE;\r
909 FvHeader = NULL;\r
910 FvAlignment = 0;\r
911 Buffer = NULL;\r
912 BufferSize = 0;\r
38837959 913 AlignedBuffer = NULL;\r
28a00297 914 Status = Fv->ReadSection (\r
022c6d45 915 Fv,\r
916 DriverName,\r
917 SectionType,\r
918 0,\r
919 &Buffer,\r
e94a9ff7 920 &BufferSize,\r
921 &AuthenticationStatus\r
922 );\r
28a00297 923 if (!EFI_ERROR (Status)) {\r
924 //\r
38837959 925 // FvImage should be at its required alignment.\r
28a00297 926 //\r
38837959 927 FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) Buffer;\r
6d9a0f28
LG
928 //\r
929 // Get FvHeader alignment\r
930 //\r
38837959
LG
931 FvAlignment = 1 << ((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16);\r
932 //\r
6d9a0f28 933 // FvAlignment must be greater than or equal to 8 bytes of the minimum FFS alignment value. \r
022c6d45 934 //\r
38837959
LG
935 if (FvAlignment < 8) {\r
936 FvAlignment = 8;\r
937 }\r
e94a9ff7 938 //\r
939 // Allocate the aligned buffer for the FvImage.\r
940 //\r
b2c5e194 941 AlignedBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES (BufferSize), (UINTN) FvAlignment);\r
38837959
LG
942 if (AlignedBuffer == NULL) {\r
943 Status = EFI_OUT_OF_RESOURCES;\r
944 } else {\r
945 //\r
946 // Move FvImage into the aligned buffer and release the original buffer.\r
947 //\r
948 CopyMem (AlignedBuffer, Buffer, BufferSize);\r
949 CoreFreePool (Buffer);\r
950 Buffer = NULL;\r
951 //\r
952 // Produce a FVB protocol for the file\r
953 //\r
954 Status = ProduceFVBProtocolOnBuffer (\r
955 (EFI_PHYSICAL_ADDRESS) (UINTN) AlignedBuffer,\r
956 (UINT64)BufferSize,\r
957 FvHandle,\r
958 NULL\r
959 );\r
960 }\r
28a00297 961 }\r
962\r
022c6d45 963 if (EFI_ERROR (Status)) {\r
38837959
LG
964 //\r
965 // ReadSection or Produce FVB failed, Free data buffer\r
966 //\r
967 if (Buffer != NULL) {\r
9c4ac31c 968 FreePool (Buffer);\r
38837959 969 }\r
022c6d45 970\r
38837959 971 if (AlignedBuffer != NULL) {\r
b2c5e194 972 FreeAlignedPages (AlignedBuffer, EFI_SIZE_TO_PAGES (BufferSize));\r
38837959 973 }\r
28a00297 974 }\r
975\r
976 return Status;\r
977}\r
978\r
28a00297 979\r
162ed594 980/**\r
981 Event notification that is fired every time a FV dispatch protocol is added.\r
28a00297 982 More than one protocol may have been added when this event is fired, so you\r
983 must loop on CoreLocateHandle () to see how many protocols were added and\r
984 do the following to each FV:\r
162ed594 985 If the Fv has already been processed, skip it. If the Fv has not been\r
28a00297 986 processed then mark it as being processed, as we are about to process it.\r
162ed594 987 Read the Fv and add any driver in the Fv to the mDiscoveredList.The\r
28a00297 988 mDiscoveredList is never free'ed and contains variables that define\r
162ed594 989 the other states the DXE driver transitions to..\r
28a00297 990 While you are at it read the A Priori file into memory.\r
991 Place drivers in the A Priori list onto the mScheduledQueue.\r
992\r
022c6d45 993 @param Event The Event that is being processed, not used.\r
162ed594 994 @param Context Event Context, not used.\r
28a00297 995\r
162ed594 996**/\r
162ed594 997VOID\r
998EFIAPI\r
999CoreFwVolEventProtocolNotify (\r
1000 IN EFI_EVENT Event,\r
1001 IN VOID *Context\r
1002 )\r
28a00297 1003{\r
1004 EFI_STATUS Status;\r
1005 EFI_STATUS GetNextFileStatus;\r
1006 EFI_STATUS SecurityStatus;\r
0c2b5da8 1007 EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;\r
28a00297 1008 EFI_DEVICE_PATH_PROTOCOL *FvDevicePath;\r
1009 EFI_HANDLE FvHandle;\r
1010 UINTN BufferSize;\r
1011 EFI_GUID NameGuid;\r
1012 UINTN Key;\r
1013 EFI_FV_FILETYPE Type;\r
1014 EFI_FV_FILE_ATTRIBUTES Attributes;\r
1015 UINTN Size;\r
1016 EFI_CORE_DRIVER_ENTRY *DriverEntry;\r
1017 EFI_GUID *AprioriFile;\r
1018 UINTN AprioriEntryCount;\r
1019 UINTN Index;\r
1020 LIST_ENTRY *Link;\r
1021 UINT32 AuthenticationStatus;\r
1022 UINTN SizeOfBuffer;\r
d3592549 1023 VOID *DepexBuffer;\r
28a00297 1024\r
1025 while (TRUE) {\r
1026 BufferSize = sizeof (EFI_HANDLE);\r
1027 Status = CoreLocateHandle (\r
e94a9ff7 1028 ByRegisterNotify,\r
1029 NULL,\r
1030 mFwVolEventRegistration,\r
1031 &BufferSize,\r
1032 &FvHandle\r
1033 );\r
28a00297 1034 if (EFI_ERROR (Status)) {\r
1035 //\r
1036 // If no more notification events exit\r
1037 //\r
1038 return;\r
1039 }\r
1040\r
1041 if (FvHasBeenProcessed (FvHandle)) {\r
1042 //\r
1043 // This Fv has already been processed so lets skip it!\r
1044 //\r
1045 continue;\r
1046 }\r
1047\r
28a00297 1048 //\r
1049 // Since we are about to process this Fv mark it as processed.\r
1050 //\r
1051 FvIsBeingProcesssed (FvHandle);\r
1052\r
0c2b5da8 1053 Status = CoreHandleProtocol (FvHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID **)&Fv);\r
d2fbaaab 1054 if (EFI_ERROR (Status) || Fv == NULL) {\r
28a00297 1055 //\r
cd539d48 1056 // FvHandle must have Firmware Volume2 protocol thus we should never get here.\r
28a00297 1057 //\r
1058 ASSERT (FALSE);\r
1059 continue;\r
1060 }\r
022c6d45 1061\r
28a00297 1062 Status = CoreHandleProtocol (FvHandle, &gEfiDevicePathProtocolGuid, (VOID **)&FvDevicePath);\r
1063 if (EFI_ERROR (Status)) {\r
1064 //\r
1065 // The Firmware volume doesn't have device path, can't be dispatched.\r
1066 //\r
1067 continue;\r
1068 }\r
022c6d45 1069\r
28a00297 1070 //\r
022c6d45 1071 // Evaluate the authentication status of the Firmware Volume through\r
28a00297 1072 // Security Architectural Protocol\r
1073 //\r
1074 if (gSecurity != NULL) {\r
1075 SecurityStatus = gSecurity->FileAuthenticationState (\r
022c6d45 1076 gSecurity,\r
1077 0,\r
28a00297 1078 FvDevicePath\r
1079 );\r
1080 if (SecurityStatus != EFI_SUCCESS) {\r
1081 //\r
1082 // Security check failed. The firmware volume should not be used for any purpose.\r
1083 //\r
1084 continue;\r
1085 }\r
022c6d45 1086 }\r
1087\r
28a00297 1088 //\r
022c6d45 1089 // Discover Drivers in FV and add them to the Discovered Driver List.\r
1090 // Process EFI_FV_FILETYPE_DRIVER type and then EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER\r
28a00297 1091 // EFI_FV_FILETYPE_DXE_CORE is processed to produce a Loaded Image protocol for the core\r
1092 // EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE is processed to create a Fvb\r
1093 //\r
e94a9ff7 1094 for (Index = 0; Index < sizeof (mDxeFileTypes) / sizeof (EFI_FV_FILETYPE); Index++) {\r
28a00297 1095 //\r
1096 // Initialize the search key\r
1097 //\r
1098 Key = 0;\r
1099 do {\r
1100 Type = mDxeFileTypes[Index];\r
1101 GetNextFileStatus = Fv->GetNextFile (\r
022c6d45 1102 Fv,\r
28a00297 1103 &Key,\r
022c6d45 1104 &Type,\r
1105 &NameGuid,\r
1106 &Attributes,\r
28a00297 1107 &Size\r
1108 );\r
1109 if (!EFI_ERROR (GetNextFileStatus)) {\r
1110 if (Type == EFI_FV_FILETYPE_DXE_CORE) {\r
1111 //\r
1112 // If this is the DXE core fill in it's DevicePath & DeviceHandle\r
1113 //\r
1114 if (gDxeCoreLoadedImage->FilePath == NULL) {\r
1115 if (CompareGuid (&NameGuid, gDxeCoreFileName)) {\r
1116 //\r
1117 // Maybe One specail Fv cantains only one DXE_CORE module, so its device path must\r
1118 // be initialized completely.\r
1119 //\r
1120 EfiInitializeFwVolDevicepathNode (&mFvDevicePath.File, &NameGuid);\r
1232b214 1121 SetDevicePathEndNode (&mFvDevicePath.End);\r
28a00297 1122\r
9c4ac31c 1123 gDxeCoreLoadedImage->FilePath = DuplicateDevicePath (\r
28a00297 1124 (EFI_DEVICE_PATH_PROTOCOL *)&mFvDevicePath\r
1125 );\r
1126 gDxeCoreLoadedImage->DeviceHandle = FvHandle;\r
1127 }\r
1128 }\r
1129 } else if (Type == EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE) {\r
bbc0f1bb 1130 //\r
022c6d45 1131 // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has already\r
bbc0f1bb 1132 // been extracted.\r
1133 //\r
1134 if (FvFoundInHobFv2 (FvHandle, &NameGuid)) {\r
1135 continue;\r
1136 }\r
d3592549
LG
1137\r
1138 //\r
1139 // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has PEI depex section.\r
1140 //\r
1141 DepexBuffer = NULL;\r
1142 SizeOfBuffer = 0;\r
1143 Status = Fv->ReadSection (\r
1144 Fv,\r
1145 &NameGuid,\r
1146 EFI_SECTION_PEI_DEPEX,\r
1147 0,\r
1148 &DepexBuffer,\r
1149 &SizeOfBuffer,\r
1150 &AuthenticationStatus\r
1151 );\r
1152 if (!EFI_ERROR (Status)) {\r
1153 //\r
1154 // If PEI depex section is found, this FV image will be ignored in DXE phase.\r
1155 // Now, DxeCore doesn't support FV image with more one type DEPEX section.\r
1156 //\r
1157 FreePool (DepexBuffer);\r
1158 continue;\r
1159 }\r
1160\r
28a00297 1161 //\r
d3592549 1162 // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has SMM depex section.\r
28a00297 1163 //\r
d3592549
LG
1164 DepexBuffer = NULL;\r
1165 SizeOfBuffer = 0;\r
1166 Status = Fv->ReadSection (\r
1167 Fv,\r
1168 &NameGuid,\r
1169 EFI_SECTION_SMM_DEPEX,\r
1170 0,\r
1171 &DepexBuffer,\r
1172 &SizeOfBuffer,\r
1173 &AuthenticationStatus\r
1174 );\r
1175 if (!EFI_ERROR (Status)) {\r
1176 //\r
1177 // If SMM depex section is found, this FV image will be ignored in DXE phase.\r
1178 // Now, DxeCore doesn't support FV image with more one type DEPEX section.\r
1179 //\r
1180 FreePool (DepexBuffer);\r
1181 continue;\r
1182 }\r
1183\r
1184 //\r
1185 // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has DXE depex section.\r
1186 //\r
1187 DepexBuffer = NULL;\r
1188 SizeOfBuffer = 0;\r
1189 Status = Fv->ReadSection (\r
1190 Fv,\r
1191 &NameGuid,\r
1192 EFI_SECTION_DXE_DEPEX,\r
1193 0,\r
1194 &DepexBuffer,\r
1195 &SizeOfBuffer,\r
1196 &AuthenticationStatus\r
1197 );\r
1198 if (EFI_ERROR (Status)) {\r
1199 //\r
1200 // If no depex section, produce a firmware volume block protocol for it so it gets dispatched from. \r
1201 //\r
1202 CoreProcessFvImageFile (Fv, FvHandle, &NameGuid);\r
1203 } else {\r
1204 //\r
1205 // If depex section is found, this FV image will be dispatched until its depex is evaluated to TRUE.\r
1206 //\r
1207 FreePool (DepexBuffer);\r
1208 CoreAddToDriverList (Fv, FvHandle, &NameGuid, Type);\r
1209 }\r
28a00297 1210 } else {\r
1211 //\r
1212 // Transition driver from Undiscovered to Discovered state\r
1213 //\r
d3592549 1214 CoreAddToDriverList (Fv, FvHandle, &NameGuid, Type);\r
28a00297 1215 }\r
1216 }\r
1217 } while (!EFI_ERROR (GetNextFileStatus));\r
1218 }\r
022c6d45 1219\r
28a00297 1220 //\r
1221 // Read the array of GUIDs from the Apriori file if it is present in the firmware volume\r
1222 //\r
1223 AprioriFile = NULL;\r
1224 Status = Fv->ReadSection (\r
1225 Fv,\r
1226 &gAprioriGuid,\r
1227 EFI_SECTION_RAW,\r
1228 0,\r
1229 (VOID **)&AprioriFile,\r
1230 &SizeOfBuffer,\r
1231 &AuthenticationStatus\r
1232 );\r
1233 if (!EFI_ERROR (Status)) {\r
1234 AprioriEntryCount = SizeOfBuffer / sizeof (EFI_GUID);\r
1235 } else {\r
1236 AprioriEntryCount = 0;\r
1237 }\r
1238\r
1239 //\r
1240 // Put drivers on Apriori List on the Scheduled queue. The Discovered List includes\r
1241 // drivers not in the current FV and these must be skipped since the a priori list\r
1242 // is only valid for the FV that it resided in.\r
1243 //\r
022c6d45 1244\r
28a00297 1245 for (Index = 0; Index < AprioriEntryCount; Index++) {\r
1246 for (Link = mDiscoveredList.ForwardLink; Link != &mDiscoveredList; Link = Link->ForwardLink) {\r
1247 DriverEntry = CR(Link, EFI_CORE_DRIVER_ENTRY, Link, EFI_CORE_DRIVER_ENTRY_SIGNATURE);\r
1248 if (CompareGuid (&DriverEntry->FileName, &AprioriFile[Index]) &&\r
1249 (FvHandle == DriverEntry->FvHandle)) {\r
6a55eea3 1250 CoreAcquireDispatcherLock ();\r
28a00297 1251 DriverEntry->Dependent = FALSE;\r
1252 DriverEntry->Scheduled = TRUE;\r
1253 InsertTailList (&mScheduledQueue, &DriverEntry->ScheduledLink);\r
6a55eea3 1254 CoreReleaseDispatcherLock ();\r
1255 DEBUG ((DEBUG_DISPATCH, "Evaluate DXE DEPEX for FFS(%g)\n", &DriverEntry->FileName));\r
1256 DEBUG ((DEBUG_DISPATCH, " RESULT = TRUE (Apriori)\n"));\r
28a00297 1257 break;\r
1258 }\r
1259 }\r
1260 }\r
1261\r
28a00297 1262 //\r
022c6d45 1263 // Free data allocated by Fv->ReadSection ()\r
28a00297 1264 //\r
022c6d45 1265 CoreFreePool (AprioriFile);\r
28a00297 1266 }\r
1267}\r
1268\r
1269\r
28a00297 1270\r
162ed594 1271/**\r
28a00297 1272 Initialize the dispatcher. Initialize the notification function that runs when\r
e94a9ff7 1273 an FV2 protocol is added to the system.\r
28a00297 1274\r
162ed594 1275**/\r
1276VOID\r
1277CoreInitializeDispatcher (\r
1278 VOID\r
1279 )\r
28a00297 1280{\r
7899b797 1281 mFwVolEvent = EfiCreateProtocolNotifyEvent (\r
022c6d45 1282 &gEfiFirmwareVolume2ProtocolGuid,\r
28a00297 1283 TPL_CALLBACK,\r
1284 CoreFwVolEventProtocolNotify,\r
1285 NULL,\r
7899b797 1286 &mFwVolEventRegistration\r
28a00297 1287 );\r
1288}\r
1289\r
1290//\r
1291// Function only used in debug builds\r
1292//\r
162ed594 1293\r
1294/**\r
1295 Traverse the discovered list for any drivers that were discovered but not loaded\r
1296 because the dependency experessions evaluated to false.\r
1297\r
1298**/\r
28a00297 1299VOID\r
1300CoreDisplayDiscoveredNotDispatched (\r
1301 VOID\r
1302 )\r
28a00297 1303{\r
1304 LIST_ENTRY *Link;\r
1305 EFI_CORE_DRIVER_ENTRY *DriverEntry;\r
1306\r
1307 for (Link = mDiscoveredList.ForwardLink;Link !=&mDiscoveredList; Link = Link->ForwardLink) {\r
1308 DriverEntry = CR(Link, EFI_CORE_DRIVER_ENTRY, Link, EFI_CORE_DRIVER_ENTRY_SIGNATURE);\r
1309 if (DriverEntry->Dependent) {\r
162ed594 1310 DEBUG ((DEBUG_LOAD, "Driver %g was discovered but not loaded!!\n", &DriverEntry->FileName));\r
28a00297 1311 }\r
1312 }\r
1313}\r