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