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_FILE_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[FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv)];
  66   EFI_GUID                            FileGuid[FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv)];
  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 < FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv); 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   UINTN                               SaveCurrentFvCount;
 232   EFI_PEI_FILE_HANDLE                 SaveCurrentFileHandle;
 233   VOID                                *TopOfStack;
 234   PEI_CORE_PARAMETERS                 PeiCoreParameters;
 235   EFI_DEVICE_HANDLE_EXTENDED_DATA     ExtendedData;
 236
 237
 238   PeiServices = &Private->PS;
 239   PeimEntryPoint = NULL;
 240   PeimFileHandle = NULL;
 241
 242   if ((Private->PeiMemoryInstalled) && (Private->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {
 243     //
 244     // Once real memory is available, shadow the RegisterForShadow modules. And meanwhile
 245     // update the modules' status from PEIM_STATE_REGISITER_FOR_SHADOW to PEIM_STATE_DONE.
 246     //
 247     SaveCurrentPeimCount  = Private->CurrentPeimCount;
 248     SaveCurrentFvCount    = Private->CurrentPeimFvCount;
 249     SaveCurrentFileHandle =  Private->CurrentFileHandle;
 250
 251     for (Index1 = 0; Index1 <= SaveCurrentFvCount; Index1++) {
 252       for (Index2 = 0; (Index2 < FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv)) && (Private->Fv[Index1].FvFileHandles[Index2] != NULL); Index2++) {
 253         if (Private->Fv[Index1].PeimState[Index2] == PEIM_STATE_REGISITER_FOR_SHADOW) {
 254           PeimFileHandle = Private->Fv[Index1].FvFileHandles[Index2];
 255           Status = PeiLoadImage (
 256                     &Private->PS,
 257                     PeimFileHandle,
 258                     &EntryPoint,
 259                     &AuthenticationState
 260                     );
 261           if (Status == EFI_SUCCESS) {
 262             //
 263             // PEIM_STATE_REGISITER_FOR_SHADOW move to PEIM_STATE_DONE
 264             //
 265             Private->Fv[Index1].PeimState[Index2]++;
 266             Private->CurrentFileHandle   = PeimFileHandle;
 267             Private->CurrentPeimFvCount  = Index1;
 268             Private->CurrentPeimCount    = Index2;
 269             //
 270             // Call the PEIM entry point
 271             //
 272             PeimEntryPoint = (EFI_PEIM_ENTRY_POINT)(UINTN)EntryPoint;
 273
 274             PERF_START (0, "PEIM", NULL, 0);
 275             PeimEntryPoint(PeimFileHandle, &Private->PS);
 276             PERF_END (0, "PEIM", NULL, 0);
 277           }
 278
 279           //
 280           // Process the Notify list and dispatch any notifies for
 281           // newly installed PPIs.
 282           //
 283           ProcessNotifyList (Private);
 284         }
 285       }
 286     }
 287     Private->CurrentFileHandle  = SaveCurrentFileHandle;
 288     Private->CurrentPeimFvCount = SaveCurrentFvCount;
 289     Private->CurrentPeimCount   = SaveCurrentPeimCount;
 290   }
 291
 292   //
 293   // This is the main dispatch loop.  It will search known FVs for PEIMs and
 294   // attempt to dispatch them.  If any PEIM gets dispatched through a single
 295   // pass of the dispatcher, it will start over from the Bfv again to see
 296   // if any new PEIMs dependencies got satisfied.  With a well ordered
 297   // FV where PEIMs are found in the order their dependencies are also
 298   // satisfied, this dipatcher should run only once.
 299   //
 300   do {
 301     PeimNeedingDispatch = FALSE;
 302     PeimDispatchOnThisPass = FALSE;
 303
 304     for (FvCount = Private->CurrentPeimFvCount; FvCount < Private->FvCount; FvCount++) {
 305       Private->CurrentPeimFvCount = FvCount;
 306       VolumeHandle = Private->Fv[FvCount].FvHeader;
 307
 308       if (Private->CurrentPeimCount == 0) {
 309         //
 310         // When going through each FV, at first, search Apriori file to
 311         // reorder all PEIMs to ensure the PEIMs in Apriori file to get
 312         // dispatch at first.
 313         //
 314         DiscoverPeimsAndOrderWithApriori (Private, VolumeHandle);
 315       }
 316
 317       //
 318       // Start to dispatch all modules within the current Fv.
 319       //
 320       for (PeimCount = Private->CurrentPeimCount;
 321            (PeimCount < FixedPcdGet32 (PcdPeiCoreMaxPeimPerFv)) && (Private->CurrentFvFileHandles[PeimCount] != NULL);
 322            PeimCount++) {
 323         Private->CurrentPeimCount  = PeimCount;
 324         PeimFileHandle = Private->CurrentFileHandle = Private->CurrentFvFileHandles[PeimCount];
 325
 326         if (Private->Fv[FvCount].PeimState[PeimCount] == PEIM_STATE_NOT_DISPATCHED) {
 327           if (!DepexSatisfied (Private, PeimFileHandle, PeimCount)) {
 328             PeimNeedingDispatch = TRUE;
 329           } else {
 330             Status = PeiLoadImage (
 331                        PeiServices,
 332                        PeimFileHandle,
 333                        &EntryPoint,
 334                        &AuthenticationState
 335                        );
 336             if ((Status == EFI_SUCCESS)) {
 337               //
 338               // The PEIM has its dependencies satisfied, and its entry point
 339               // has been found, so invoke it.
 340               //
 341               PERF_START (0, "PEIM", NULL, 0);
 342
 343               ExtendedData.Handle = (EFI_HANDLE)PeimFileHandle;
 344
 345               REPORT_STATUS_CODE_WITH_EXTENDED_DATA (
 346                 EFI_PROGRESS_CODE,
 347                 EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT_BEGIN,
 348                 (VOID *)(&ExtendedData),
 349                 sizeof (ExtendedData)
 350                 );
 351
 352               Status = VerifyPeim (Private, VolumeHandle, PeimFileHandle);
 353               if (Status != EFI_SECURITY_VIOLATION && (AuthenticationState == 0)) {
 354                 //
 355                 // PEIM_STATE_NOT_DISPATCHED move to PEIM_STATE_DISPATCHED
 356                 //
 357                 Private->Fv[FvCount].PeimState[PeimCount]++;
 358
 359                 //
 360                 // Call the PEIM entry point
 361                 //
 362                 PeimEntryPoint = (EFI_PEIM_ENTRY_POINT)(UINTN)EntryPoint;
 363                 PeimEntryPoint (PeimFileHandle, PeiServices);
 364                 PeimDispatchOnThisPass = TRUE;
 365               }
 366
 367               REPORT_STATUS_CODE_WITH_EXTENDED_DATA (
 368                 EFI_PROGRESS_CODE,
 369                 EFI_SOFTWARE_PEI_CORE | EFI_SW_PC_INIT_END,
 370                 (VOID *)(&ExtendedData),
 371                 sizeof (ExtendedData)
 372                 );
 373               PERF_END (0, "PEIM", NULL, 0);
 374
 375             }
 376
 377             //
 378             // Process the Notify list and dispatch any notifies for
 379             // newly installed PPIs.
 380             //
 381             ProcessNotifyList (Private);
 382
 383             //
 384             // If permanent memory was discovered and installed by this
 385             // PEIM, shadow PEI Core and switch the stacks to the new memory.
 386             //
 387             if (Private->SwitchStackSignal) {
 388
 389               //
 390               // Make sure we don't retry the same PEIM that added memory
 391               //
 392               Private->CurrentPeimCount++;
 393
 394               //
 395               // Migrate IDT from CAR into real memory, so after stack switches to
 396               // the new memory, the caller can get memory version PeiServiceTable.
 397               //
 398               MigrateIdtTable (PeiServices);
 399
 400               //
 401               // Since we are at dispatch level, only the Core's private data
 402               // is preserved, nobody else should have any data on the stack.
 403               // So we need to copy PEI core instance data to memory.
 404               //
 405               PrivateInMem = AllocateCopyPool (sizeof (PEI_CORE_INSTANCE), Private);
 406               ASSERT (PrivateInMem != NULL);
 407
 408               //
 409               // Shadow PEI Core. When permanent memory is avaiable, shadow
 410               // PEI Core and PEIMs to get high performance.
 411               //
 412               PeiCoreFileHandle = NULL;
 413               //
 414               // Find the PEI Core in the BFV
 415               //
 416               Status = PeiFindFileEx (
 417                         (EFI_PEI_FV_HANDLE)Private->Fv[0].FvHeader,
 418                         NULL,
 419                         EFI_FV_FILETYPE_PEI_CORE,
 420                         &PeiCoreFileHandle,
 421                         NULL
 422                         );
 423               ASSERT_EFI_ERROR (Status);
 424
 425               //
 426               // Shadow PEI Core into memory so it will run faster
 427               //
 428               Status = PeiLoadImage (PeiServices, PeiCoreFileHandle, &EntryPoint, &AuthenticationState);
 429               ASSERT_EFI_ERROR (Status);
 430
 431               //
 432               // Switch to memory based stack and reenter PEI Core that has been
 433               //  shadowed to memory.
 434               //
 435               //
 436               // Adjust the top of stack to be aligned at CPU_STACK_ALIGNMENT
 437               //
 438               TopOfStack = (VOID *)((UINTN)Private->StackBase + (UINTN)Private->StackSize - CPU_STACK_ALIGNMENT);
 439               TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
 440
 441               PeiCoreParameters.SecCoreData = SecCoreData;
 442               PeiCoreParameters.PpiList     = NULL;
 443               PeiCoreParameters.Data        = PrivateInMem;
 444               ASSERT (PeiCoreParameters.Data != 0);
 445
 446               PeiSwitchStacks (
 447                 InvokePeiCore,
 448                 (VOID*) (UINTN) PeiCore,
 449                 (VOID*) &PeiCoreParameters,
 450                 TopOfStack,
 451                 (VOID*)(UINTN)Private->StackBase
 452                 );
 453             }
 454
 455             if ((Private->PeiMemoryInstalled) && (Private->Fv[FvCount].PeimState[PeimCount] == PEIM_STATE_REGISITER_FOR_SHADOW) &&   \
 456                 (Private->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {
 457               //
 458               // If memory is availble we shadow images by default for performance reasons.
 459               // We call the entry point a 2nd time so the module knows it's shadowed.
 460               //
 461               //PERF_START (PeiServices, L"PEIM", PeimFileHandle, 0);
 462               PeimEntryPoint (PeimFileHandle, PeiServices);
 463               //PERF_END (PeiServices, L"PEIM", PeimFileHandle, 0);
 464
 465               //
 466               // PEIM_STATE_REGISITER_FOR_SHADOW move to PEIM_STATE_DONE
 467               //
 468               Private->Fv[FvCount].PeimState[PeimCount]++;
 469
 470               //
 471               // Process the Notify list and dispatch any notifies for
 472               // newly installed PPIs.
 473               //
 474               ProcessNotifyList (Private);
 475             }
 476           }
 477         }
 478       }
 479
 480       //
 481       // We set to NULL here to optimize the 2nd entry to this routine after
 482       //  memory is found. This reprevents rescanning of the FV. We set to
 483       //  NULL here so we start at the begining of the next FV
 484       //
 485       Private->CurrentFileHandle = NULL;
 486       Private->CurrentPeimCount = 0;
 487       //
 488       // Before walking through the next FV,Private->CurrentFvFileHandles[]should set to NULL
 489       //
 490       SetMem (Private->CurrentFvFileHandles, sizeof (Private->CurrentFvFileHandles), 0);
 491     }
 492
 493     //
 494     // Before making another pass, we should set Private->CurrentPeimFvCount =0 to go
 495     // through all the FV.
 496     //
 497     Private->CurrentPeimFvCount = 0;
 498
 499     //
 500     // PeimNeedingDispatch being TRUE means we found a PEIM that did not get
 501     //  dispatched. So we need to make another pass
 502     //
 503     // PeimDispatchOnThisPass being TRUE means we dispatched a PEIM on this
 504     //  pass. If we did not dispatch a PEIM there is no point in trying again
 505     //  as it will fail the next time too (nothing has changed).
 506     //
 507   } while (PeimNeedingDispatch && PeimDispatchOnThisPass);
 508
 509 }
 510
 511 VOID
 512 InitializeDispatcherData (
 513   IN PEI_CORE_INSTANCE            *PrivateData,
 514   IN PEI_CORE_INSTANCE            *OldCoreData,
 515   IN CONST EFI_SEC_PEI_HAND_OFF   *SecCoreData
 516   )
 517 /*++
 518
 519 Routine Description:
 520
 521   Initialize the Dispatcher's data members
 522
 523 Arguments:
 524
 525   PeiServices          - The PEI core services table.
 526   OldCoreData          - Pointer to old core data (before switching stack).
 527                          NULL if being run in non-permament memory mode.
 528   SecCoreData          - Points to a data structure containing information about the PEI core's operating
 529                          environment, such as the size and location of temporary RAM, the stack location and
 530                          the BFV location.
 531
 532 Returns:
 533
 534   None.
 535
 536 --*/
 537 {
 538   if (OldCoreData == NULL) {
 539     PeiInitializeFv (PrivateData, SecCoreData);
 540   }
 541
 542   return;
 543 }
 544
 545
 546 BOOLEAN
 547 DepexSatisfied (
 548   IN PEI_CORE_INSTANCE          *Private,
 549   IN EFI_PEI_FILE_HANDLE        FileHandle,
 550   IN UINTN                      PeimCount
 551   )
 552 /*++
 553
 554 Routine Description:
 555
 556   This routine parses the Dependency Expression, if available, and
 557   decides if the module can be executed.
 558
 559 Arguments:
 560   PeiServices - The PEI Service Table
 561   CurrentPeimAddress - Address of the PEIM Firmware File under investigation
 562
 563 Returns:
 564   TRUE  - Can be dispatched
 565   FALSE - Cannot be dispatched
 566
 567 --*/
 568 {
 569   EFI_STATUS  Status;
 570   VOID        *DepexData;
 571
 572   if (PeimCount < Private->AprioriCount) {
 573     //
 574     // If its in the A priori file then we set Depex to TRUE
 575     //
 576     return TRUE;
 577   }
 578
 579   Status = PeiServicesFfsFindSectionData (EFI_SECTION_PEI_DEPEX, FileHandle, (VOID **) &DepexData);
 580   if (EFI_ERROR (Status)) {
 581     //
 582     // If there is no DEPEX, assume the module can be executed
 583     //
 584     return TRUE;
 585   }
 586
 587   //
 588   // Evaluate a given DEPEX
 589   //
 590   return PeimDispatchReadiness (&Private->PS, DepexData);
 591 }
 592
 593 /**
 594   This routine enable a PEIM to register itself to shadow when PEI Foundation
 595   discovery permanent memory.
 596
 597         @param FileHandle       File handle of a PEIM.
 598
 599   @retval EFI_NOT_FOUND                                 The file handle doesn't point to PEIM itself.
 600   @retval EFI_ALREADY_STARTED           Indicate that the PEIM has been registered itself.
 601   @retval EFI_SUCCESS                                           Successfully to register itself.
 602
 603 **/
 604 EFI_STATUS
 605 EFIAPI
 606 PeiRegisterForShadow (
 607   IN EFI_PEI_FILE_HANDLE       FileHandle
 608   )
 609 {
 610   PEI_CORE_INSTANCE            *Private;
 611   Private = PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
 612
 613   if (Private->CurrentFileHandle != FileHandle) {
 614     //
 615     // The FileHandle must be for the current PEIM
 616     //
 617     return EFI_NOT_FOUND;
 618   }
 619
 620   if (Private->Fv[Private->CurrentPeimFvCount].PeimState[Private->CurrentPeimCount] >= PEIM_STATE_REGISITER_FOR_SHADOW) {
 621     //
 622     // If the PEIM has already entered the PEIM_STATE_REGISTER_FOR_SHADOW or PEIM_STATE_DONE then it's already been started
 623     //
 624     return EFI_ALREADY_STARTED;
 625   }
 626
 627   Private->Fv[Private->CurrentPeimFvCount].PeimState[Private->CurrentPeimCount] = PEIM_STATE_REGISITER_FOR_SHADOW;
 628
 629   return EFI_SUCCESS;
 630 }
 631
 632
 633 /**
 634   This routine invoke the PeiCore's entry in new stack environment.
 635
 636         @param Context1         The first context parameter is entry of PeiCore
 637   @param Context2       The second context parameter is parameter structure point for PeiCore
 638
 639 **/
 640 STATIC
 641 VOID
 642 InvokePeiCore (
 643   VOID          *Context1,
 644   VOID          *Context2
 645   )
 646 {
 647   PEI_CORE_ENTRY_POINT  PeiCoreEntryPoint;
 648   PEI_CORE_PARAMETERS       *PeiCoreParameters;
 649
 650   //
 651   // Running on new stack in SEC Core
 652   //
 653
 654   PeiCoreEntryPoint = (PEI_CORE_ENTRY_POINT) (UINTN) Context1;
 655   PeiCoreParameters = (PEI_CORE_PARAMETERS *)Context2;
 656
 657   //
 658   // Call PEI Core using new stack
 659   //
 660   PeiCoreEntryPoint (
 661     PeiCoreParameters->SecCoreData,
 662     PeiCoreParameters->PpiList,
 663     PeiCoreParameters->Data
 664     );
 665
 666   //
 667   // Never returns
 668   //
 669   ASSERT_EFI_ERROR (FALSE);
 670 }