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             } else {
 376               //
 377               // If PeiLoadImage fails, the section extraction PPI or Decompress PPI may not be ready,
 378               // we flag that more Peims need to be dispatched.
 379               //
 380               PeimNeedingDispatch = TRUE;
 381             }
 382
 383             //
 384             // Process the Notify list and dispatch any notifies for
 385             // newly installed PPIs.
 386             //
 387             ProcessNotifyList (Private);
 388
 389             //
 390             // If permanent memory was discovered and installed by this
 391             // PEIM, shadow PEI Core and switch the stacks to the new memory.
 392             //
 393             if (Private->SwitchStackSignal) {
 394
 395               //
 396               // Make sure we don't retry the same PEIM that added memory
 397               //
 398               Private->CurrentPeimCount++;
 399
 400               //
 401               // Migrate IDT from CAR into real memory, so after stack switches to
 402               // the new memory, the caller can get memory version PeiServiceTable.
 403               //
 404               MigrateIdtTable (PeiServices);
 405
 406               //
 407               // Since we are at dispatch level, only the Core's private data
 408               // is preserved, nobody else should have any data on the stack.
 409               // So we need to copy PEI core instance data to memory.
 410               //
 411               PrivateInMem = AllocateCopyPool (sizeof (PEI_CORE_INSTANCE), Private);
 412               ASSERT (PrivateInMem != NULL);
 413
 414               //
 415               // Shadow PEI Core. When permanent memory is avaiable, shadow
 416               // PEI Core and PEIMs to get high performance.
 417               //
 418               PeiCoreFileHandle = NULL;
 419               //
 420               // Find the PEI Core in the BFV
 421               //
 422               Status = PeiFindFileEx (
 423                         (EFI_PEI_FV_HANDLE)Private->Fv[0].FvHeader,
 424                         NULL,
 425                         EFI_FV_FILETYPE_PEI_CORE,
 426                         &PeiCoreFileHandle,
 427                         NULL
 428                         );
 429               ASSERT_EFI_ERROR (Status);
 430
 431               //
 432               // Shadow PEI Core into memory so it will run faster
 433               //
 434               Status = PeiLoadImage (PeiServices, PeiCoreFileHandle, &EntryPoint, &AuthenticationState);
 435               ASSERT_EFI_ERROR (Status);
 436
 437               //
 438               // Switch to memory based stack and reenter PEI Core that has been
 439               //  shadowed to memory.
 440               //
 441               //
 442               // Adjust the top of stack to be aligned at CPU_STACK_ALIGNMENT
 443               //
 444               TopOfStack = (VOID *)((UINTN)Private->StackBase + (UINTN)Private->StackSize - CPU_STACK_ALIGNMENT);
 445               TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
 446
 447               PeiCoreParameters.SecCoreData = SecCoreData;
 448               PeiCoreParameters.PpiList     = NULL;
 449               PeiCoreParameters.Data        = PrivateInMem;
 450               ASSERT (PeiCoreParameters.Data != 0);
 451
 452               PeiSwitchStacks (
 453                 InvokePeiCore,
 454                 (VOID*) ((UINTN) EntryPoint + ((UINTN) PeiCore - (UINTN) _ModuleEntryPoint)),
 455                 (VOID*) &PeiCoreParameters,
 456                 TopOfStack,
 457                 (VOID*)(UINTN)Private->StackBase
 458                 );
 459             }
 460
 461             if ((Private->PeiMemoryInstalled) && (Private->Fv[FvCount].PeimState[PeimCount] == PEIM_STATE_REGISITER_FOR_SHADOW) &&   \
 462                 (Private->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {
 463               //
 464               // If memory is availble we shadow images by default for performance reasons.
 465               // We call the entry point a 2nd time so the module knows it's shadowed.
 466               //
 467               //PERF_START (PeiServices, L"PEIM", PeimFileHandle, 0);
 468               PeimEntryPoint (PeimFileHandle, PeiServices);
 469               //PERF_END (PeiServices, L"PEIM", PeimFileHandle, 0);
 470
 471               //
 472               // PEIM_STATE_REGISITER_FOR_SHADOW move to PEIM_STATE_DONE
 473               //
 474               Private->Fv[FvCount].PeimState[PeimCount]++;
 475
 476               //
 477               // Process the Notify list and dispatch any notifies for
 478               // newly installed PPIs.
 479               //
 480               ProcessNotifyList (Private);
 481             }
 482           }
 483         }
 484       }
 485
 486       //
 487       // We set to NULL here to optimize the 2nd entry to this routine after
 488       //  memory is found. This reprevents rescanning of the FV. We set to
 489       //  NULL here so we start at the begining of the next FV
 490       //
 491       Private->CurrentFileHandle = NULL;
 492       Private->CurrentPeimCount = 0;
 493       //
 494       // Before walking through the next FV,Private->CurrentFvFileHandles[]should set to NULL
 495       //
 496       SetMem (Private->CurrentFvFileHandles, sizeof (Private->CurrentFvFileHandles), 0);
 497     }
 498
 499     //
 500     // Before making another pass, we should set Private->CurrentPeimFvCount =0 to go
 501     // through all the FV.
 502     //
 503     Private->CurrentPeimFvCount = 0;
 504
 505     //
 506     // PeimNeedingDispatch being TRUE means we found a PEIM that did not get
 507     //  dispatched. So we need to make another pass
 508     //
 509     // PeimDispatchOnThisPass being TRUE means we dispatched a PEIM on this
 510     //  pass. If we did not dispatch a PEIM there is no point in trying again
 511     //  as it will fail the next time too (nothing has changed).
 512     //
 513   } while (PeimNeedingDispatch && PeimDispatchOnThisPass);
 514
 515 }
 516
 517 VOID
 518 InitializeDispatcherData (
 519   IN PEI_CORE_INSTANCE            *PrivateData,
 520   IN PEI_CORE_INSTANCE            *OldCoreData,
 521   IN CONST EFI_SEC_PEI_HAND_OFF   *SecCoreData
 522   )
 523 /*++
 524
 525 Routine Description:
 526
 527   Initialize the Dispatcher's data members
 528
 529 Arguments:
 530
 531   PeiServices          - The PEI core services table.
 532   OldCoreData          - Pointer to old core data (before switching stack).
 533                          NULL if being run in non-permament memory mode.
 534   SecCoreData          - Points to a data structure containing information about the PEI core's operating
 535                          environment, such as the size and location of temporary RAM, the stack location and
 536                          the BFV location.
 537
 538 Returns:
 539
 540   None.
 541
 542 --*/
 543 {
 544   if (OldCoreData == NULL) {
 545     PeiInitializeFv (PrivateData, SecCoreData);
 546   }
 547
 548   return;
 549 }
 550
 551
 552 BOOLEAN
 553 DepexSatisfied (
 554   IN PEI_CORE_INSTANCE          *Private,
 555   IN EFI_PEI_FILE_HANDLE        FileHandle,
 556   IN UINTN                      PeimCount
 557   )
 558 /*++
 559
 560 Routine Description:
 561
 562   This routine parses the Dependency Expression, if available, and
 563   decides if the module can be executed.
 564
 565 Arguments:
 566   PeiServices - The PEI Service Table
 567   CurrentPeimAddress - Address of the PEIM Firmware File under investigation
 568
 569 Returns:
 570   TRUE  - Can be dispatched
 571   FALSE - Cannot be dispatched
 572
 573 --*/
 574 {
 575   EFI_STATUS  Status;
 576   VOID        *DepexData;
 577
 578   if (PeimCount < Private->AprioriCount) {
 579     //
 580     // If its in the A priori file then we set Depex to TRUE
 581     //
 582     return TRUE;
 583   }
 584
 585   Status = PeiServicesFfsFindSectionData (EFI_SECTION_PEI_DEPEX, FileHandle, (VOID **) &DepexData);
 586   if (EFI_ERROR (Status)) {
 587     //
 588     // If there is no DEPEX, assume the module can be executed
 589     //
 590     return TRUE;
 591   }
 592
 593   //
 594   // Evaluate a given DEPEX
 595   //
 596   return PeimDispatchReadiness (&Private->PS, DepexData);
 597 }
 598
 599 /**
 600   This routine enable a PEIM to register itself to shadow when PEI Foundation
 601   discovery permanent memory.
 602
 603         @param FileHandle       File handle of a PEIM.
 604
 605   @retval EFI_NOT_FOUND                                 The file handle doesn't point to PEIM itself.
 606   @retval EFI_ALREADY_STARTED           Indicate that the PEIM has been registered itself.
 607   @retval EFI_SUCCESS                                           Successfully to register itself.
 608
 609 **/
 610 EFI_STATUS
 611 EFIAPI
 612 PeiRegisterForShadow (
 613   IN EFI_PEI_FILE_HANDLE       FileHandle
 614   )
 615 {
 616   PEI_CORE_INSTANCE            *Private;
 617   Private = PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
 618
 619   if (Private->CurrentFileHandle != FileHandle) {
 620     //
 621     // The FileHandle must be for the current PEIM
 622     //
 623     return EFI_NOT_FOUND;
 624   }
 625
 626   if (Private->Fv[Private->CurrentPeimFvCount].PeimState[Private->CurrentPeimCount] >= PEIM_STATE_REGISITER_FOR_SHADOW) {
 627     //
 628     // If the PEIM has already entered the PEIM_STATE_REGISTER_FOR_SHADOW or PEIM_STATE_DONE then it's already been started
 629     //
 630     return EFI_ALREADY_STARTED;
 631   }
 632
 633   Private->Fv[Private->CurrentPeimFvCount].PeimState[Private->CurrentPeimCount] = PEIM_STATE_REGISITER_FOR_SHADOW;
 634
 635   return EFI_SUCCESS;
 636 }
 637
 638
 639 /**
 640   This routine invoke the PeiCore's entry in new stack environment.
 641
 642         @param Context1         The first context parameter is entry of PeiCore
 643   @param Context2       The second context parameter is parameter structure point for PeiCore
 644
 645 **/
 646 STATIC
 647 VOID
 648 InvokePeiCore (
 649   VOID          *Context1,
 650   VOID          *Context2
 651   )
 652 {
 653   PEI_CORE_ENTRY_POINT  PeiCoreEntryPoint;
 654   PEI_CORE_PARAMETERS       *PeiCoreParameters;
 655
 656   //
 657   // Running on new stack in SEC Core
 658   //
 659
 660   PeiCoreEntryPoint = (PEI_CORE_ENTRY_POINT) (UINTN) Context1;
 661   PeiCoreParameters = (PEI_CORE_PARAMETERS *)Context2;
 662
 663   //
 664   // Call PEI Core using new stack
 665   //
 666   PeiCoreEntryPoint (
 667     PeiCoreParameters->SecCoreData,
 668     PeiCoreParameters->PpiList,
 669     PeiCoreParameters->Data
 670     );
 671
 672   //
 673   // Never returns
 674   //
 675   ASSERT (FALSE);
 676   CpuDeadLoop ();
 677 }