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