MdeModulePkg/Core/Pei/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   EFI PEI Core dispatch services
  19
  20 Revision History
  21
  22 --*/
  23
  24 #include <PeiMain.h>
  25
  26 STATIC
  27 VOID
  28 InvokePeiCore (
  29   VOID          *Context1,
  30   VOID          *Context2
  31   );
  32
  33
  34 VOID
  35 DiscoverPeimsAndOrderWithApriori (
  36   IN  PEI_CORE_INSTANCE    *Private,
  37   IN  EFI_PEI_FV_HANDLE    VolumeHandle
  38   )
  39 /*++
  40
  41 Routine Description:
  42
  43   Discover all Peims and optional Apriori file in one FV. There is at most one
  44   Apriori file in one FV.
  45
  46 Arguments:
  47
  48   Private          - Pointer to the private data passed in from caller
  49   VolumeHandle     - Fv handle.
  50 Returns:
  51
  52   NONE
  53
  54 --*/
  55 {
  56   EFI_STATUS                          Status;
  57   EFI_PEI_FV_HANDLE                   FileHandle;
  58   EFI_PEI_FV_HANDLE                   AprioriFileHandle;
  59   EFI_GUID                            *Apriori;
  60   UINTN                               Index;
  61   UINTN                               Index2;
  62   UINTN                               PeimIndex;
  63   UINTN                               PeimCount;
  64   EFI_GUID                            *Guid;
  65   EFI_PEI_FV_HANDLE                   TempFileHandles[PEI_CORE_MAX_PEIM_PER_FV];
  66   EFI_GUID                            FileGuid[PEI_CORE_MAX_PEIM_PER_FV];
  67
  68   //
  69   // Walk the FV and find all the PEIMs and the Apriori file.
  70   //
  71   AprioriFileHandle = NULL;
  72   Private->CurrentFvFileHandles[0] = NULL;
  73   Guid = NULL;
  74   FileHandle = NULL;
  75
  76   //
  77   // If the current Fv has been scanned, directly get its cachable record.
  78   //
  79   if (Private->Fv[Private->CurrentPeimFvCount].ScanFv) {
  80     CopyMem (Private->CurrentFvFileHandles, Private->Fv[Private->CurrentPeimFvCount].FvFileHandles, sizeof (Private->CurrentFvFileHandles));
  81     return;
  82   }
  83
  84   //
  85   // Go ahead to scan this Fv, and cache FileHandles within it.
  86   //
  87   for (PeimCount = 0; PeimCount < PEI_CORE_MAX_PEIM_PER_FV; PeimCount++) {
  88     Status = PeiFindFileEx (
  89                 VolumeHandle,
  90                 NULL,
  91                 PEI_CORE_INTERNAL_FFS_FILE_DISPATCH_TYPE,
  92                 &FileHandle,
  93                 &AprioriFileHandle
  94                 );
  95     if (Status != EFI_SUCCESS) {
  96       break;
  97     }
  98
  99     Private->CurrentFvFileHandles[PeimCount] = FileHandle;
 100   }
 101
 102   Private->AprioriCount = 0;
 103   if (AprioriFileHandle != NULL) {
 104     //
 105     // Read the Apriori file
 106     //
 107     Status = PeiServicesFfsFindSectionData (EFI_SECTION_RAW, &AprioriFileHandle, (VOID **) &Apriori);
 108     if (!EFI_ERROR (Status)) {
 109       //
 110       // Calculate the number of PEIMs in the A Priori list
 111       //
 112       Private->AprioriCount = *(UINT32 *)(((EFI_FFS_FILE_HEADER *)AprioriFileHandle)->Size) & 0x00FFFFFF;
 113       Private->AprioriCount -= sizeof (EFI_FFS_FILE_HEADER) - sizeof (EFI_COMMON_SECTION_HEADER);
 114       Private->AprioriCount /= sizeof (EFI_GUID);
 115
 116       SetMem (FileGuid, sizeof (FileGuid), 0);
 117       for (Index = 0; Index < PeimCount; Index++) {
 118         //
 119         // Make an array of file name guids that matches the FileHandle array so we can convert
 120         // quickly from file name to file handle
 121         //
 122         CopyMem (&FileGuid[Index], &((EFI_FFS_FILE_HEADER *)Private->CurrentFvFileHandles[Index])->Name,sizeof(EFI_GUID));
 123       }
 124
 125       //
 126       // Walk through FileGuid array to find out who is invalid PEIM guid in Apriori file.
 127       // Add avalible PEIMs in Apriori file into TempFileHandles array at first.
 128       //
 129       Index2 = 0;
 130       for (Index = 0; Index2 < Private->AprioriCount; Index++) {
 131         while (Index2 < Private->AprioriCount) {
 132           Guid = ScanGuid (FileGuid, PeimCount * sizeof (EFI_GUID), &Apriori[Index2++]);
 133           if (Guid != NULL) {
 134             break;
 135           }
 136         }
 137         if (Guid == NULL) {
 138           break;
 139         }
 140         PeimIndex = ((UINTN)Guid - (UINTN)&FileGuid[0])/sizeof (EFI_GUID);
 141         TempFileHandles[Index] = Private->CurrentFvFileHandles[PeimIndex];
 142
 143         //
 144         // Since we have copied the file handle we can remove it from this list.
 145         //
 146         Private->CurrentFvFileHandles[PeimIndex] = NULL;
 147       }
 148
 149       //
 150       // Update valid Aprioricount
 151       //
 152       Private->AprioriCount = Index;
 153
 154       //
 155       // Add in any PEIMs not in the Apriori file
 156       //
 157       for (;Index < PeimCount; Index++) {
 158         for (Index2 = 0; Index2 < PeimCount; Index2++) {
 159           if (Private->CurrentFvFileHandles[Index2] != NULL) {
 160             TempFileHandles[Index] = Private->CurrentFvFileHandles[Index2];
 161             Private->CurrentFvFileHandles[Index2] = NULL;
 162             break;
 163           }
 164         }
 165       }
 166       //
 167       //Index the end of array contains re-range Pei moudle.
 168       //
 169       TempFileHandles[Index] = NULL;
 170
 171       //
 172       // Private->CurrentFvFileHandles is currently in PEIM in the FV order.
 173       // We need to update it to start with files in the A Priori list and
 174       // then the remaining files in PEIM order.
 175       //
 176       CopyMem (Private->CurrentFvFileHandles, TempFileHandles, sizeof (Private->CurrentFvFileHandles));
 177     }
 178   }
 179   //
 180   // Cache the current Fv File Handle. So that we don't have to scan the Fv again.
 181   // Instead, we can retrieve the file handles within this Fv from cachable data.
 182   //
 183   Private->Fv[Private->CurrentPeimFvCount].ScanFv = TRUE;
 184   CopyMem (Private->Fv[Private->CurrentPeimFvCount].FvFileHandles, Private->CurrentFvFileHandles, sizeof (Private->CurrentFvFileHandles));
 185
 186 }
 187
 188 VOID
 189 PeiDispatcher (
 190   IN CONST EFI_SEC_PEI_HAND_OFF  *SecCoreData,
 191   IN PEI_CORE_INSTANCE           *Private
 192   )
 193
 194 /*++
 195
 196 Routine Description:
 197
 198   Conduct PEIM dispatch.
 199
 200 Arguments:
 201
 202   SecCoreData          - Points to a data structure containing information about the PEI core's operating
 203                          environment, such as the size and location of temporary RAM, the stack location and
 204                          the BFV location.
 205   PrivateData          - Pointer to the private data passed in from caller
 206   DispatchData         - Pointer to PEI_CORE_DISPATCH_DATA data.
 207
 208 Returns:
 209
 210   EFI_SUCCESS   - Successfully dispatched PEIM.
 211   EFI_NOT_FOUND - The dispatch failed.
 212
 213 --*/
 214 {
 215   EFI_STATUS                          Status;
 216   UINT32                              Index1;
 217   UINT32                              Index2;
 218   EFI_PEI_SERVICES                    **PeiServices;
 219   VOID                                *PrivateInMem;
 220   EFI_PEI_FV_HANDLE                   VolumeHandle;
 221   EFI_PEI_FILE_HANDLE                 PeiCoreFileHandle;
 222   EFI_PEI_FILE_HANDLE                 PeimFileHandle;
 223   UINTN                               FvCount;
 224   UINTN                               PeimCount;
 225   UINT32                              AuthenticationState;
 226   EFI_PHYSICAL_ADDRESS                EntryPoint;
 227   EFI_PEIM_ENTRY_POINT                PeimEntryPoint;
 228   BOOLEAN                             PeimNeedingDispatch;
 229   BOOLEAN                             PeimDispatchOnThisPass;
 230   UINTN                               SaveCurrentPeimCount;
 231   EFI_PEI_FILE_HANDLE                 SaveCurrentFileHandle;
 232   VOID                                *TopOfStack;
 233   PEI_CORE_PARAMETERS                 PeiCoreParameters;
 234   EFI_DEVICE_HANDLE_EXTENDED_DATA     ExtendedData;
 235
 236
 237   PeiServices = &Private->PS;
 238   PeimEntryPoint = NULL;
 239   PeimFileHandle = NULL;
 240
 241   if ((Private->PeiMemoryInstalled) && (Private->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {
 242     //
 243     // Once real memory is available, shadow the RegisterForShadow modules. And meanwhile
 244     // update the modules' status from PEIM_STATE_REGISITER_FOR_SHADOW to PEIM_STATE_DONE.
 245     //
 246     SaveCurrentPeimCount  = Private->CurrentPeimCount;
 247     SaveCurrentFileHandle =  Private->CurrentFileHandle;
 248
 249     for (Index1 = 0;Index1 <= Private->CurrentPeimFvCount; Index1++) {
 250       for (Index2 = 0; (Index2 < PEI_CORE_MAX_PEIM_PER_FV) && (Private->Fv[Index1].FvFileHandles[Index2] != NULL); Index2++) {
 251         if (Private->Fv[Index1].PeimState[Index2] == PEIM_STATE_REGISITER_FOR_SHADOW) {
 252           PeimFileHandle = Private->Fv[Index1].FvFileHandles[Index2];
 253           Status = PeiLoadImage (
 254                     &Private->PS,
 255                     PeimFileHandle,
 256                     &EntryPoint,
 257                     &AuthenticationState
 258                     );
 259           if (Status == EFI_SUCCESS) {
 260             //
 261             // PEIM_STATE_REGISITER_FOR_SHADOW move to PEIM_STATE_DONE
 262             //
 263             Private->Fv[Index1].PeimState[Index2]++;
 264             Private->CurrentFileHandle = PeimFileHandle;
 265             Private->CurrentPeimCount  = Index2;
 266             //
 267             // Call the PEIM entry point
 268             //
 269             PeimEntryPoint = (EFI_PEIM_ENTRY_POINT)(UINTN)EntryPoint;
 270
 271             PERF_START (0, "PEIM", NULL, 0);
 272             PeimEntryPoint(PeimFileHandle, &Private->PS);
 273             PERF_END (0, "PEIM", NULL, 0);
 274           }
 275
 276           //
 277           // Process the Notify list and dispatch any notifies for
 278           // newly installed PPIs.
 279           //
 280           ProcessNotifyList (Private);
 281         }
 282       }
 283     }
 284     Private->CurrentFileHandle = SaveCurrentFileHandle;
 285     Private->CurrentPeimCount  = SaveCurrentPeimCount;
 286   }
 287
 288   //
 289   // This is the main dispatch loop.  It will search known FVs for PEIMs and
 290   // attempt to dispatch them.  If any PEIM gets dispatched through a single
 291   // pass of the dispatcher, it will start over from the Bfv again to see
 292   // if any new PEIMs dependencies got satisfied.  With a well ordered
 293   // FV where PEIMs are found in the order their dependencies are also
 294   // satisfied, this dipatcher should run only once.
 295   //
 296   do {
 297     PeimNeedingDispatch = FALSE;
 298     PeimDispatchOnThisPass = FALSE;
 299
 300     for (FvCount = Private->CurrentPeimFvCount; FvCount < Private->FvCount; FvCount++) {
 301       Private->CurrentPeimFvCount = FvCount;
 302       VolumeHandle = Private->Fv[FvCount].FvHeader;
 303
 304       if (Private->CurrentPeimCount == 0) {
 305         //
 306         // When going through each FV, at first, search Apriori file to
 307         // reorder all PEIMs to ensure the PEIMs in Apriori file to get
 308         // dispatch at first.
 309         //
 310         DiscoverPeimsAndOrderWithApriori (Private, VolumeHandle);
 311       }
 312
 313       //
 314       // Start to dispatch all modules within the current Fv.
 315       //
 316       for (PeimCount = Private->CurrentPeimCount;
 317            (PeimCount < PEI_CORE_MAX_PEIM_PER_FV) && (Private->CurrentFvFileHandles[PeimCount] != NULL);
 318            PeimCount++) {
 319         Private->CurrentPeimCount  = PeimCount;
 320         PeimFileHandle = Private->CurrentFileHandle = Private->CurrentFvFileHandles[PeimCount];
 321
 322         if (Private->Fv[FvCount].PeimState[PeimCount] == PEIM_STATE_NOT_DISPATCHED) {
 323           if (!DepexSatisfied (Private, PeimFileHandle, PeimCount)) {
 324             PeimNeedingDispatch = TRUE;
 325           } else {
 326             Status = PeiLoadImage (
 327                        PeiServices,
 328                        PeimFileHandle,
 329                        &EntryPoint,
 330                        &AuthenticationState
 331                        );
 332             if ((Status == EFI_SUCCESS)) {
 333               //
 334               // The PEIM has its dependencies satisfied, and its entry point
 335               // has been found, so invoke it.
 336               //
 337               PERF_START (0, "PEIM", NULL, 0);
 338
 339               ExtendedData.Handle = (EFI_HANDLE)PeimFileHandle;
 340
 341               REPORT_STATUS_CODE_WITH_EXTENDED_DATA (
 342                 EFI_PROGRESS_CODE,
 343                 EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT_BEGIN,
 344                 (VOID *)(&ExtendedData),
 345                 sizeof (ExtendedData)
 346                 );
 347
 348               Status = VerifyPeim (Private, VolumeHandle, PeimFileHandle);
 349               if (Status != EFI_SECURITY_VIOLATION && (AuthenticationState == 0)) {
 350                 //
 351                 // PEIM_STATE_NOT_DISPATCHED move to PEIM_STATE_DISPATCHED
 352                 //
 353                 Private->Fv[FvCount].PeimState[PeimCount]++;
 354
 355                 //
 356                 // Call the PEIM entry point
 357                 //
 358                 PeimEntryPoint = (EFI_PEIM_ENTRY_POINT)(UINTN)EntryPoint;
 359                 PeimEntryPoint (PeimFileHandle, PeiServices);
 360                 PeimDispatchOnThisPass = TRUE;
 361               }
 362
 363               REPORT_STATUS_CODE_WITH_EXTENDED_DATA (
 364                 EFI_PROGRESS_CODE,
 365                 EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT_END,
 366                 (VOID *)(&ExtendedData),
 367                 sizeof (ExtendedData)
 368                 );
 369               PERF_END (0, "PEIM", NULL, 0);
 370
 371             }
 372
 373             //
 374             // Process the Notify list and dispatch any notifies for
 375             // newly installed PPIs.
 376             //
 377             ProcessNotifyList (Private);
 378
 379             //
 380             // If permanent memory was discovered and installed by this
 381             // PEIM, shadow PEI Core and switch the stacks to the new memory.
 382             //
 383             if (Private->SwitchStackSignal) {
 384
 385               //
 386               // Make sure we don't retry the same PEIM that added memory
 387               //
 388               Private->CurrentPeimCount++;
 389
 390               //
 391               // Migrate IDT from CAR into real memory, so after stack switches to
 392               // the new memory, the caller can get memory version PeiServiceTable.
 393               //
 394               //MigrateIdtTable (PeiServices);
 395               //
 396               // Since we are at dispatch level, only the Core's private data
 397               // is preserved, nobody else should have any data on the stack.
 398               // So we need to copy PEI core instance data to memory.
 399               //
 400               PrivateInMem = AllocateCopyPool (sizeof (PEI_CORE_INSTANCE), Private);
 401               ASSERT (PrivateInMem != NULL);
 402
 403               //
 404               // Shadow PEI Core. When permanent memory is avaiable, shadow
 405               // PEI Core and PEIMs to get high performance.
 406               //
 407               PeiCoreFileHandle = NULL;
 408               //
 409               // Find the PEI Core in the BFV
 410               //
 411               Status = PeiFindFileEx (
 412                         (EFI_PEI_FV_HANDLE)Private->Fv[0].FvHeader,
 413                         NULL,
 414                         EFI_FV_FILETYPE_PEI_CORE,
 415                         &PeiCoreFileHandle,
 416                         NULL
 417                         );
 418               ASSERT_EFI_ERROR (Status);
 419
 420               //
 421               // Shadow PEI Core into memory so it will run faster
 422               //
 423               Status = PeiLoadImage (PeiServices, PeiCoreFileHandle, &EntryPoint, &AuthenticationState);
 424               ASSERT_EFI_ERROR (Status);
 425
 426               //
 427               // Switch to memory based stack and reenter PEI Core that has been
 428               //  shadowed to memory.
 429               //
 430               //
 431               // Adjust the top of stack to be aligned at CPU_STACK_ALIGNMENT
 432               //
 433               TopOfStack = (VOID *)((UINTN)Private->StackBase + (UINTN)Private->StackSize - CPU_STACK_ALIGNMENT);
 434               TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
 435
 436               PeiCoreParameters.SecCoreData = SecCoreData;
 437               PeiCoreParameters.PpiList     = NULL;
 438               PeiCoreParameters.Data        = PrivateInMem;
 439               ASSERT (PeiCoreParameters.Data != 0);
 440
 441               PeiSwitchStacks (
 442                 InvokePeiCore,
 443                 (VOID*) (UINTN) PeiCore,
 444                 (VOID*) &PeiCoreParameters,
 445                 TopOfStack,
 446                 (VOID*)(UINTN)Private->StackBase
 447                 );
 448             }
 449
 450             if ((Private->PeiMemoryInstalled) && (Private->Fv[FvCount].PeimState[PeimCount] == PEIM_STATE_REGISITER_FOR_SHADOW) &&   \
 451                 (Private->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {
 452               //
 453               // If memory is availble we shadow images by default for performance reasons.
 454               // We call the entry point a 2nd time so the module knows it's shadowed.
 455               //
 456               //PERF_START (PeiServices, L"PEIM", PeimFileHandle, 0);
 457               PeimEntryPoint (PeimFileHandle, PeiServices);
 458               //PERF_END (PeiServices, L"PEIM", PeimFileHandle, 0);
 459
 460               //
 461               // PEIM_STATE_REGISITER_FOR_SHADOW move to PEIM_STATE_DONE
 462               //
 463               Private->Fv[FvCount].PeimState[PeimCount]++;
 464
 465               //
 466               // Process the Notify list and dispatch any notifies for
 467               // newly installed PPIs.
 468               //
 469               ProcessNotifyList (Private);
 470             }
 471           }
 472         }
 473       }
 474
 475       //
 476       // We set to NULL here to optimize the 2nd entry to this routine after
 477       //  memory is found. This reprevents rescanning of the FV. We set to
 478       //  NULL here so we start at the begining of the next FV
 479       //
 480       Private->CurrentFileHandle = NULL;
 481       Private->CurrentPeimCount = 0;
 482       //
 483       // Before walking through the next FV,Private->CurrentFvFileHandles[]should set to NULL
 484       //
 485       SetMem (Private->CurrentFvFileHandles, sizeof (Private->CurrentFvFileHandles), 0);
 486     }
 487
 488     //
 489     // Before making another pass, we should set Private->CurrentPeimFvCount =0 to go
 490     // through all the FV.
 491     //
 492     Private->CurrentPeimFvCount = 0;
 493
 494     //
 495     // PeimNeedingDispatch being TRUE means we found a PEIM that did not get
 496     //  dispatched. So we need to make another pass
 497     //
 498     // PeimDispatchOnThisPass being TRUE means we dispatched a PEIM on this
 499     //  pass. If we did not dispatch a PEIM there is no point in trying again
 500     //  as it will fail the next time too (nothing has changed).
 501     //
 502   } while (PeimNeedingDispatch && PeimDispatchOnThisPass);
 503
 504 }
 505
 506 VOID
 507 InitializeDispatcherData (
 508   IN PEI_CORE_INSTANCE            *PrivateData,
 509   IN PEI_CORE_INSTANCE            *OldCoreData,
 510   IN CONST EFI_SEC_PEI_HAND_OFF   *SecCoreData
 511   )
 512 /*++
 513
 514 Routine Description:
 515
 516   Initialize the Dispatcher's data members
 517
 518 Arguments:
 519
 520   PeiServices          - The PEI core services table.
 521   OldCoreData          - Pointer to old core data (before switching stack).
 522                          NULL if being run in non-permament memory mode.
 523   SecCoreData          - Points to a data structure containing information about the PEI core's operating
 524                          environment, such as the size and location of temporary RAM, the stack location and
 525                          the BFV location.
 526
 527 Returns:
 528
 529   None.
 530
 531 --*/
 532 {
 533   if (OldCoreData == NULL) {
 534     PeiInitializeFv (PrivateData, SecCoreData);
 535   }
 536
 537   return;
 538 }
 539
 540
 541 BOOLEAN
 542 DepexSatisfied (
 543   IN PEI_CORE_INSTANCE          *Private,
 544   IN EFI_PEI_FILE_HANDLE        FileHandle,
 545   IN UINTN                      PeimCount
 546   )
 547 /*++
 548
 549 Routine Description:
 550
 551   This routine parses the Dependency Expression, if available, and
 552   decides if the module can be executed.
 553
 554 Arguments:
 555   PeiServices - The PEI Service Table
 556   CurrentPeimAddress - Address of the PEIM Firmware File under investigation
 557
 558 Returns:
 559   TRUE  - Can be dispatched
 560   FALSE - Cannot be dispatched
 561
 562 --*/
 563 {
 564   EFI_STATUS  Status;
 565   VOID        *DepexData;
 566
 567   if (PeimCount < Private->AprioriCount) {
 568     //
 569     // If its in the A priori file then we set Depex to TRUE
 570     //
 571     return TRUE;
 572   }
 573
 574   Status = PeiServicesFfsFindSectionData (EFI_SECTION_PEI_DEPEX, FileHandle, (VOID **) &DepexData);
 575   if (EFI_ERROR (Status)) {
 576     //
 577     // If there is no DEPEX, assume the module can be executed
 578     //
 579     return TRUE;
 580   }
 581
 582   //
 583   // Evaluate a given DEPEX
 584   //
 585   return PeimDispatchReadiness (&Private->PS, DepexData);
 586 }
 587
 588 /**
 589   This routine enable a PEIM to register itself to shadow when PEI Foundation
 590   discovery permanent memory.
 591
 592         @param FileHandle       File handle of a PEIM.
 593
 594   @retval EFI_NOT_FOUND                                 The file handle doesn't point to PEIM itself.
 595   @retval EFI_ALREADY_STARTED           Indicate that the PEIM has been registered itself.
 596   @retval EFI_SUCCESS                                           Successfully to register itself.
 597
 598 **/
 599 EFI_STATUS
 600 EFIAPI
 601 PeiRegisterForShadow (
 602   IN EFI_PEI_FILE_HANDLE       FileHandle
 603   )
 604 {
 605   PEI_CORE_INSTANCE            *Private;
 606   Private = PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
 607
 608   if (Private->CurrentFileHandle != FileHandle) {
 609     //
 610     // The FileHandle must be for the current PEIM
 611     //
 612     return EFI_NOT_FOUND;
 613   }
 614
 615   if (Private->Fv[Private->CurrentPeimFvCount].PeimState[Private->CurrentPeimCount] >= PEIM_STATE_REGISITER_FOR_SHADOW) {
 616     //
 617     // If the PEIM has already entered the PEIM_STATE_REGISTER_FOR_SHADOW or PEIM_STATE_DONE then it's already been started
 618     //
 619     return EFI_ALREADY_STARTED;
 620   }
 621
 622   Private->Fv[Private->CurrentPeimFvCount].PeimState[Private->CurrentPeimCount] = PEIM_STATE_REGISITER_FOR_SHADOW;
 623
 624   return EFI_SUCCESS;
 625 }
 626
 627
 628 /**
 629   This routine invoke the PeiCore's entry in new stack environment.
 630
 631         @param Context1         The first context parameter is entry of PeiCore
 632   @param Context2       The second context parameter is parameter structure point for PeiCore
 633
 634 **/
 635 STATIC
 636 VOID
 637 InvokePeiCore (
 638   VOID          *Context1,
 639   VOID          *Context2
 640   )
 641 {
 642   PEI_CORE_ENTRY_POINT  PeiCoreEntryPoint;
 643   PEI_CORE_PARAMETERS       *PeiCoreParameters;
 644
 645   //
 646   // Running on new stack in SEC Core
 647   //
 648
 649   PeiCoreEntryPoint = (PEI_CORE_ENTRY_POINT) (UINTN) Context1;
 650   PeiCoreParameters = (PEI_CORE_PARAMETERS *)Context2;
 651
 652   //
 653   // Call PEI Core using new stack
 654   //
 655   PeiCoreEntryPoint (
 656     PeiCoreParameters->SecCoreData,
 657     PeiCoreParameters->PpiList,
 658     PeiCoreParameters->Data
 659     );
 660
 661   //
 662   // Never returns
 663   //
 664   ASSERT_EFI_ERROR (FALSE);
 665 }