[mirror_edk2.git] / EdkModulePkg / Core / Dxe / Image / Image.c

/*++\r
\r
Copyright (c) 2006, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
Module Name:\r
\r
  Image.c\r
\r
Abstract:\r
\r
  Core image handling services\r
\r
--*/\r
\r
#include <DxeMain.h>\r
//\r
// Module Globals\r
//\r
\r
//\r
// LIST of runtime images that need to be relocated.\r
//\r
LIST_ENTRY                 mRuntimeImageList = INITIALIZE_LIST_HEAD_VARIABLE (mRuntimeImageList);\r
\r
LOADED_IMAGE_PRIVATE_DATA  *mCurrentImage = NULL;\r
\r
LOAD_PE32_IMAGE_PRIVATE_DATA  mLoadPe32PrivateData = {\r
  LOAD_PE32_IMAGE_PRIVATE_DATA_SIGNATURE,\r
  NULL,\r
  {\r
    CoreLoadImageEx,\r
    CoreUnloadImageEx\r
  }\r
};\r
\r
\r
//\r
// This code is needed to build the Image handle for the DXE Core\r
//\r
LOADED_IMAGE_PRIVATE_DATA mCorePrivateImage  = {\r
  LOADED_IMAGE_PRIVATE_DATA_SIGNATURE,            // Signature\r
  NULL,                                           // Image handle\r
  EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER,    // Image type\r
  TRUE,                                           // If entrypoint has been called\r
  NULL, // EntryPoint\r
  {\r
    EFI_LOADED_IMAGE_INFORMATION_REVISION,        // Revision\r
    NULL,                                         // Parent handle\r
    NULL,                                         // System handle\r
\r
    NULL,                                         // Device handle\r
    NULL,                                         // File path\r
    NULL,                                         // Reserved\r
\r
    0,                                            // LoadOptionsSize\r
    NULL,                                         // LoadOptions\r
\r
    NULL,                                         // ImageBase\r
    0,                                            // ImageSize\r
    EfiBootServicesCode,                          // ImageCodeType\r
    EfiBootServicesData                           // ImageDataType\r
  },\r
  (EFI_PHYSICAL_ADDRESS)0,    // ImageBasePage\r
  0,                          // NumberOfPages\r
  NULL,                       // FixupData\r
  0,                          // Tpl\r
  EFI_SUCCESS,                // Status\r
  0,                          // ExitDataSize\r
  NULL,                       // ExitData\r
  NULL,                       // JumpContext\r
  0,                          // Machine\r
  NULL,                       // Ebc\r
  FALSE,                      // RuntimeFixupValid\r
  NULL,                       // RuntimeFixup\r
  { NULL, NULL },             // Link\r
};\r
\r
\r
EFI_STATUS\r
CoreInitializeImageServices (\r
  IN  VOID *HobStart\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Add the Image Services to EFI Boot Services Table and install the protocol\r
  interfaces for this image.\r
\r
Arguments:\r
\r
  HobStart        - The HOB to initialize\r
\r
Returns:\r
\r
  Status code.\r
\r
--*/\r
{\r
  EFI_STATUS                        Status;\r
  LOADED_IMAGE_PRIVATE_DATA         *Image;\r
  EFI_PHYSICAL_ADDRESS              DxeCoreImageBaseAddress;\r
  UINT64                            DxeCoreImageLength;\r
  VOID                              *DxeCoreEntryPoint;\r
  EFI_PEI_HOB_POINTERS              DxeCoreHob;\r
  //\r
  // Searching for image hob\r
  //\r
  DxeCoreHob.Raw          = HobStart;\r
  while ((DxeCoreHob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, DxeCoreHob.Raw)) != NULL) {\r
    if (CompareGuid (&DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.Name, &gEfiHobMemoryAllocModuleGuid)) {\r
      //\r
      // Find Dxe Core HOB\r
      //\r
      break;\r
    }\r
    DxeCoreHob.Raw = GET_NEXT_HOB (DxeCoreHob);\r
  }\r
  ASSERT (DxeCoreHob.Raw != NULL);\r
\r
  DxeCoreImageBaseAddress = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryBaseAddress;\r
  DxeCoreImageLength      = DxeCoreHob.MemoryAllocationModule->MemoryAllocationHeader.MemoryLength;\r
  DxeCoreEntryPoint       = (VOID *) (UINTN) DxeCoreHob.MemoryAllocationModule->EntryPoint;\r
  gDxeCoreFileName        = &DxeCoreHob.MemoryAllocationModule->ModuleName;\r
  //\r
  // Initialize the fields for an internal driver\r
  //\r
  Image = &mCorePrivateImage;\r
\r
  Image->EntryPoint         = (EFI_IMAGE_ENTRY_POINT)(UINTN)DxeCoreEntryPoint;\r
  Image->ImageBasePage      = DxeCoreImageBaseAddress;\r
  Image->NumberOfPages      = (UINTN)(EFI_SIZE_TO_PAGES((UINTN)(DxeCoreImageLength)));\r
  Image->Tpl                = gEfiCurrentTpl;\r
  Image->Info.SystemTable   = gST;\r
  Image->Info.ImageBase     = (VOID *)(UINTN)DxeCoreImageBaseAddress;\r
  Image->Info.ImageSize     = DxeCoreImageLength;\r
\r
  //\r
  // Install the protocol interfaces for this image\r
  //\r
  Status = CoreInstallProtocolInterface (\r
             &Image->Handle,\r
             &gEfiLoadedImageProtocolGuid,\r
             EFI_NATIVE_INTERFACE,\r
             &Image->Info\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  mCurrentImage = Image;\r
\r
  //\r
  // Fill in DXE globals\r
  //\r
  gDxeCoreImageHandle = Image->Handle;\r
  gDxeCoreLoadedImage = &Image->Info;\r
\r
  //\r
  // Export DXE Core PE Loader functionality\r
  //\r
  return CoreInstallProtocolInterface (\r
           &mLoadPe32PrivateData.Handle,\r
           &gEfiLoadPeImageProtocolGuid,\r
           EFI_NATIVE_INTERFACE,\r
           &mLoadPe32PrivateData.Pe32Image\r
           );\r
}\r
\r
\r
EFI_STATUS\r
CoreShutdownImageServices (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Transfer control of runtime images to runtime service\r
\r
Arguments:\r
\r
  None\r
\r
Returns:\r
\r
  EFI_SUCCESS       - Function successfully returned\r
\r
--*/\r
{\r
  LIST_ENTRY                  *Link;\r
  LOADED_IMAGE_PRIVATE_DATA   *Image;\r
\r
  //\r
  // The Runtime AP is required for the core to function!\r
  //\r
  ASSERT (gRuntime != NULL);\r
\r
  for (Link = mRuntimeImageList.ForwardLink; Link != &mRuntimeImageList; Link = Link->ForwardLink) {\r
    Image = CR (Link, LOADED_IMAGE_PRIVATE_DATA, Link, LOADED_IMAGE_PRIVATE_DATA_SIGNATURE);\r
    if (Image->RuntimeFixupValid) {\r
      gRuntime->RegisterImage (\r
                  gRuntime,\r
                  (UINT64)(UINTN)(Image->Info.ImageBase),\r
                  (EFI_SIZE_TO_PAGES ((UINTN)Image->Info.ImageSize)),\r
                  Image->RuntimeFixup\r
                  );\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
\r
EFI_STATUS\r
CoreLoadPeImage (\r
  IN VOID                        *Pe32Handle,\r
  IN LOADED_IMAGE_PRIVATE_DATA   *Image,\r
  IN EFI_PHYSICAL_ADDRESS        DstBuffer    OPTIONAL,\r
  OUT EFI_PHYSICAL_ADDRESS       *EntryPoint  OPTIONAL,\r
  IN  UINT32                     Attribute\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Loads, relocates, and invokes a PE/COFF image\r
\r
Arguments:\r
\r
  Pe32Handle       - The handle of PE32 image\r
  Image            - PE image to be loaded\r
  DstBuffer        - The buffer to store the image\r
  EntryPoint       - A pointer to the entry point\r
  Attribute        - The bit mask of attributes to set for the load PE image\r
\r
Returns:\r
\r
  EFI_SUCCESS          - The file was loaded, relocated, and invoked\r
\r
  EFI_OUT_OF_RESOURCES - There was not enough memory to load and relocate the PE/COFF file\r
\r
  EFI_INVALID_PARAMETER - Invalid parameter\r
\r
  EFI_BUFFER_TOO_SMALL  - Buffer for image is too small\r
\r
--*/\r
{\r
  EFI_STATUS                            Status;\r
  UINTN                                 Size;\r
\r
  ZeroMem (&Image->ImageContext, sizeof (Image->ImageContext));\r
\r
  Image->ImageContext.Handle    = Pe32Handle;\r
  Image->ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE)CoreReadImageFile;\r
\r
  //\r
  // Get information about the image being loaded\r
  //\r
  Status = gEfiPeiPeCoffLoader->GetImageInfo (gEfiPeiPeCoffLoader, &Image->ImageContext);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (Image->ImageContext.Machine)) {\r
    //\r
    // The PE/COFF loader can support loading image types that can be executed. \r
    // If we loaded an image type that we can not execute return EFI_UNSUPORTED. \r
    //\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
\r
  //\r
  // Allocate memory of the correct memory type aligned on the required image boundry\r
  //\r
\r
  if (DstBuffer == 0) {\r
    //\r
    // Allocate Destination Buffer as caller did not pass it in\r
    //\r
\r
    if (Image->ImageContext.SectionAlignment > EFI_PAGE_SIZE) {\r
      Size = (UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment;\r
    } else {\r
      Size = (UINTN)Image->ImageContext.ImageSize;\r
    }\r
\r
    Image->NumberOfPages = EFI_SIZE_TO_PAGES (Size);\r
\r
    //\r
    // If the image relocations have not been stripped, then load at any address.\r
    // Otherwise load at the address at which it was linked.\r
    //\r
    Status = CoreAllocatePages (\r
               (Image->ImageContext.RelocationsStripped) ? AllocateAddress : AllocateAnyPages,\r
               Image->ImageContext.ImageCodeMemoryType,\r
               Image->NumberOfPages,\r
               &Image->ImageContext.ImageAddress\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    Image->ImageBasePage = Image->ImageContext.ImageAddress;\r
\r
  } else {\r
    //\r
    // Caller provided the destination buffer\r
    //\r
\r
    if (Image->ImageContext.RelocationsStripped && (Image->ImageContext.ImageAddress != DstBuffer)) {\r
      //\r
      // If the image relocations were stripped, and the caller provided a\r
      // destination buffer address that does not match the address that the\r
      // image is linked at, then the image cannot be loaded.\r
      //\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    if (Image->NumberOfPages != 0 &&\r
        Image->NumberOfPages <\r
        (EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment))) {\r
      Image->NumberOfPages = EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment);\r
      return EFI_BUFFER_TOO_SMALL;\r
    }\r
\r
    Image->NumberOfPages = EFI_SIZE_TO_PAGES ((UINTN)Image->ImageContext.ImageSize + Image->ImageContext.SectionAlignment);\r
    Image->ImageContext.ImageAddress = DstBuffer;\r
    Image->ImageBasePage = Image->ImageContext.ImageAddress;\r
  }\r
\r
  Image->ImageContext.ImageAddress =\r
      (Image->ImageContext.ImageAddress + Image->ImageContext.SectionAlignment - 1) &\r
      ~((UINTN)Image->ImageContext.SectionAlignment - 1);\r
\r
  //\r
  // Load the image from the file into the allocated memory\r
  //\r
  Status = gEfiPeiPeCoffLoader->LoadImage (gEfiPeiPeCoffLoader, &Image->ImageContext);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // If this is a Runtime Driver, then allocate memory for the FixupData that\r
  // is used to relocate the image when SetVirtualAddressMap() is called. The\r
  // relocation is done by the Runtime AP.\r
  //\r
  if (Attribute & EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION) {\r
    if (Image->ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) {\r
      Image->ImageContext.FixupData = CoreAllocateRuntimePool ((UINTN)(Image->ImageContext.FixupDataSize));\r
      if (Image->ImageContext.FixupData == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto Done;\r
      }\r
\r
      //\r
      // Make a list off all the RT images so we can let the RT AP know about them\r
      //\r
      Image->RuntimeFixupValid = TRUE;\r
      Image->RuntimeFixup = Image->ImageContext.FixupData;\r
      InsertTailList (&mRuntimeImageList, &Image->Link);\r
    }\r
  }\r
\r
  //\r
  // Relocate the image in memory\r
  //\r
  Status = gEfiPeiPeCoffLoader->RelocateImage (gEfiPeiPeCoffLoader, &Image->ImageContext);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Flush the Instruction Cache\r
  //\r
  InvalidateInstructionCacheRange ((VOID *)(UINTN)Image->ImageContext.ImageAddress, (UINTN)Image->ImageContext.ImageSize);\r
\r
  //\r
  // Copy the machine type from the context to the image private data. This\r
  // is needed during image unload to know if we should call an EBC protocol\r
  // to unload the image.\r
  //\r
  Image->Machine = Image->ImageContext.Machine;\r
\r
  //\r
  // Get the image entry point. If it's an EBC image, then call into the\r
  // interpreter to create a thunk for the entry point and use the returned\r
  // value for the entry point.\r
  //\r
  Image->EntryPoint   = (EFI_IMAGE_ENTRY_POINT)(UINTN)Image->ImageContext.EntryPoint;\r
  if (Image->ImageContext.Machine == EFI_IMAGE_MACHINE_EBC) {\r
    //\r
    // Locate the EBC interpreter protocol\r
    //\r
    Status = CoreLocateProtocol (&gEfiEbcProtocolGuid, NULL, (VOID **)&Image->Ebc);\r
    if (EFI_ERROR(Status)) {\r
      goto Done;\r
    }\r
\r
    //\r
    // Register a callback for flushing the instruction cache so that created\r
    // thunks can be flushed.\r
    //\r
    Status = Image->Ebc->RegisterICacheFlush (Image->Ebc, (EBC_ICACHE_FLUSH)InvalidateInstructionCacheRange);\r
    if (EFI_ERROR(Status)) {\r
      goto Done;\r
    }\r
\r
    //\r
    // Create a thunk for the image's entry point. This will be the new\r
    // entry point for the image.\r
    //\r
    Status = Image->Ebc->CreateThunk (\r
                           Image->Ebc,\r
                           Image->Handle,\r
                           (VOID *)(UINTN)Image->ImageContext.EntryPoint,\r
                           (VOID **)&Image->EntryPoint\r
                           );\r
    if (EFI_ERROR(Status)) {\r
      goto Done;\r
    }\r
  }\r
\r
  //\r
  // Fill in the image information for the Loaded Image Protocol\r
  //\r
  Image->Type               = Image->ImageContext.ImageType;\r
  Image->Info.ImageBase     = (VOID *)(UINTN)Image->ImageContext.ImageAddress;\r
  Image->Info.ImageSize     = Image->ImageContext.ImageSize;\r
  Image->Info.ImageCodeType = Image->ImageContext.ImageCodeMemoryType;\r
  Image->Info.ImageDataType = Image->ImageContext.ImageDataMemoryType;\r
\r
  //\r
  // Fill in the entry point of the image if it is available\r
  //\r
  if (EntryPoint != NULL) {\r
    *EntryPoint = Image->ImageContext.EntryPoint;\r
  }\r
\r
  //\r
  // Print the load address and the PDB file name if it is available\r
  //\r
\r
  DEBUG_CODE_BEGIN ();\r
 \r
    UINTN Index;\r
    UINTN StartIndex;\r
    CHAR8 EfiFileName[256];\r
\r
    DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Loading driver at 0x%08x EntryPoint=0x%08x ", (UINTN)Image->ImageContext.ImageAddress, (UINTN)Image->ImageContext.EntryPoint));\r
    if (Image->ImageContext.PdbPointer != NULL) {\r
      StartIndex = 0;\r
      for (Index = 0; Image->ImageContext.PdbPointer[Index] != 0; Index++) {\r
        if (Image->ImageContext.PdbPointer[Index] == '\\') {\r
          StartIndex = Index + 1;\r
        }\r
      }\r
      //\r
      // Copy the PDB file name to our temporary string, and replace .pdb with .efi\r
      //\r
      for (Index = 0; Index < sizeof (EfiFileName); Index++) {\r
        EfiFileName[Index] = Image->ImageContext.PdbPointer[Index + StartIndex];\r
        if (EfiFileName[Index] == 0) {\r
          EfiFileName[Index] = '.';\r
        }\r
        if (EfiFileName[Index] == '.') {\r
          EfiFileName[Index + 1] = 'e';\r
          EfiFileName[Index + 2] = 'f';\r
          EfiFileName[Index + 3] = 'i';\r
          EfiFileName[Index + 4] = 0;\r
          break;\r
        }\r
      }\r
      DEBUG ((EFI_D_INFO | EFI_D_LOAD, "%a", EfiFileName)); // &Image->ImageContext.PdbPointer[StartIndex]));\r
    }\r
    DEBUG ((EFI_D_INFO | EFI_D_LOAD, "\n"));\r
  \r
  DEBUG_CODE_END ();\r
\r
  return EFI_SUCCESS;\r
\r
Done:\r
  //\r
  // Free memory\r
  //\r
  CoreFreePages (Image->ImageContext.ImageAddress, Image->NumberOfPages);\r
  return Status;\r
}\r
\r
\r
LOADED_IMAGE_PRIVATE_DATA *\r
CoreLoadedImageInfo (\r
  IN EFI_HANDLE  ImageHandle\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Get the image's private data from its handle.\r
\r
Arguments:\r
\r
  ImageHandle     - The image handle\r
\r
Returns:\r
\r
  Return the image private data associated with ImageHandle.\r
\r
--*/\r
{\r
  EFI_STATUS                 Status;\r
  EFI_LOADED_IMAGE_PROTOCOL  *LoadedImage;\r
  LOADED_IMAGE_PRIVATE_DATA  *Image;\r
\r
  Status = CoreHandleProtocol (\r
             ImageHandle,\r
             &gEfiLoadedImageProtocolGuid,\r
             (VOID **)&LoadedImage\r
             );\r
  if (!EFI_ERROR (Status)) {\r
    Image = LOADED_IMAGE_PRIVATE_DATA_FROM_THIS (LoadedImage);\r
  } else {\r
    DEBUG ((EFI_D_LOAD, "CoreLoadedImageInfo: Not an ImageHandle %x\n", ImageHandle));\r
    Image = NULL;\r
  }\r
\r
  return Image;\r
}\r
\r
\r
EFI_STATUS\r
CoreLoadImageCommon (\r
  IN  BOOLEAN                          BootPolicy,\r
  IN  EFI_HANDLE                       ParentImageHandle,\r
  IN  EFI_DEVICE_PATH_PROTOCOL         *FilePath,\r
  IN  VOID                             *SourceBuffer       OPTIONAL,\r
  IN  UINTN                            SourceSize,\r
  IN  EFI_PHYSICAL_ADDRESS             DstBuffer           OPTIONAL,\r
  IN OUT UINTN                         *NumberOfPages      OPTIONAL,\r
  OUT EFI_HANDLE                       *ImageHandle,\r
  OUT EFI_PHYSICAL_ADDRESS             *EntryPoint         OPTIONAL,\r
  IN  UINT32                           Attribute\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Loads an EFI image into memory and returns a handle to the image.\r
\r
Arguments:\r
\r
  BootPolicy          - If TRUE, indicates that the request originates from the boot manager,\r
                        and that the boot manager is attempting to load FilePath as a boot selection.\r
  ParentImageHandle   - The caller's image handle.\r
  FilePath            - The specific file path from which the image is loaded.\r
  SourceBuffer        - If not NULL, a pointer to the memory location containing a copy of\r
                        the image to be loaded.\r
  SourceSize          - The size in bytes of SourceBuffer.\r
  DstBuffer           - The buffer to store the image\r
  NumberOfPages       - If not NULL, a pointer to the image's page number, if this number\r
                        is not enough, return EFI_BUFFER_TOO_SMALL and this parameter contain\r
                        the required number.\r
  ImageHandle         - Pointer to the returned image handle that is created when the image\r
                        is successfully loaded.\r
  EntryPoint          - A pointer to the entry point\r
  Attribute           - The bit mask of attributes to set for the load PE image\r
\r
Returns:\r
\r
  EFI_SUCCESS            - The image was loaded into memory.\r
  EFI_NOT_FOUND          - The FilePath was not found.\r
  EFI_INVALID_PARAMETER  - One of the parameters has an invalid value.\r
  EFI_BUFFER_TOO_SMALL   - The buffer is too small\r
  EFI_UNSUPPORTED        - The image type is not supported, or the device path cannot be\r
                           parsed to locate the proper protocol for loading the file.\r
  EFI_OUT_OF_RESOURCES   - Image was not loaded due to insufficient resources.\r
--*/\r
{\r
  LOADED_IMAGE_PRIVATE_DATA  *Image;\r
  LOADED_IMAGE_PRIVATE_DATA  *ParentImage;\r
  IMAGE_FILE_HANDLE          FHand;\r
  EFI_STATUS                 Status;\r
  EFI_STATUS                 SecurityStatus;\r
  EFI_HANDLE                 DeviceHandle;\r
  UINT32                     AuthenticationStatus;\r
  EFI_DEVICE_PATH_PROTOCOL   *OriginalFilePath;\r
  EFI_DEVICE_PATH_PROTOCOL   *HandleFilePath;\r
  UINTN                      FilePathSize;\r
\r
\r
  ASSERT (gEfiCurrentTpl < EFI_TPL_NOTIFY);\r
  ParentImage = NULL;\r
\r
  //\r
  // The caller must pass in a valid ParentImageHandle\r
  //\r
  if (ImageHandle == NULL || ParentImageHandle == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  ParentImage = CoreLoadedImageInfo (ParentImageHandle);\r
  if (ParentImage == NULL) {\r
    DEBUG((EFI_D_LOAD|EFI_D_ERROR, "LoadImageEx: Parent handle not an image handle\n"));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Get simple read access to the source file\r
  //\r
  OriginalFilePath = FilePath;\r
  Status = CoreOpenImageFile (\r
             BootPolicy,\r
             SourceBuffer,\r
             SourceSize,\r
             FilePath,\r
             &DeviceHandle,\r
             &FHand,\r
             &AuthenticationStatus\r
             );\r
  if (Status == EFI_ALREADY_STARTED) {\r
    Image = NULL;\r
    goto Done;\r
  } else if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Verify the Authentication Status through the Security Architectural Protocol\r
  //\r
  if ((gSecurity != NULL) && (OriginalFilePath != NULL)) {\r
    SecurityStatus = gSecurity->FileAuthenticationState (\r
                                  gSecurity,\r
                                  AuthenticationStatus,\r
                                  OriginalFilePath\r
                                  );\r
    if (EFI_ERROR (SecurityStatus) && SecurityStatus != EFI_SECURITY_VIOLATION) {\r
      Status = SecurityStatus;\r
      Image = NULL;\r
      goto Done;\r
    }\r
  }\r
\r
\r
  //\r
  // Allocate a new image structure\r
  //\r
  Image = CoreAllocateZeroBootServicesPool (sizeof(LOADED_IMAGE_PRIVATE_DATA));\r
  if (Image == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Pull out just the file portion of the DevicePath for the LoadedImage FilePath\r
  //\r
  Status = CoreHandleProtocol (DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **)&HandleFilePath);\r
  if (!EFI_ERROR (Status)) {\r
    FilePathSize = CoreDevicePathSize (HandleFilePath) - sizeof(EFI_DEVICE_PATH_PROTOCOL);\r
    FilePath = (EFI_DEVICE_PATH_PROTOCOL *) ( ((UINT8 *)FilePath) + FilePathSize );\r
  }\r
\r
  //\r
  // Initialize the fields for an internal driver\r
  //\r
  Image->Signature         = LOADED_IMAGE_PRIVATE_DATA_SIGNATURE;\r
  Image->Info.SystemTable  = gST;\r
  Image->Info.DeviceHandle = DeviceHandle;\r
  Image->Info.Revision     = EFI_LOADED_IMAGE_INFORMATION_REVISION;\r
  Image->Info.FilePath     = CoreDuplicateDevicePath (FilePath);\r
  Image->Info.ParentHandle = ParentImageHandle;\r
\r
  if (NumberOfPages != NULL) {\r
    Image->NumberOfPages = *NumberOfPages ;\r
  } else {\r
    Image->NumberOfPages = 0 ;\r
  }\r
\r
  //\r
  // Install the protocol interfaces for this image\r
  // don't fire notifications yet\r
  //\r
  Status = CoreInstallProtocolInterfaceNotify (\r
             &Image->Handle,\r
             &gEfiLoadedImageProtocolGuid,\r
             EFI_NATIVE_INTERFACE,\r
             &Image->Info,\r
             FALSE\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
  //\r
  // Load the image.  If EntryPoint is Null, it will not be set.\r
  //\r
  Status = CoreLoadPeImage (&FHand, Image, DstBuffer, EntryPoint, Attribute);\r
  if (EFI_ERROR (Status)) {\r
    if ((Status == EFI_BUFFER_TOO_SMALL) || (Status == EFI_OUT_OF_RESOURCES)) {\r
      if (NumberOfPages != NULL) {\r
        *NumberOfPages = Image->NumberOfPages;\r
      }\r
    }\r
    goto Done;\r
  }\r
\r
  //\r
  // Register the image in the Debug Image Info Table if the attribute is set\r
  //\r
  if (Attribute & EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION) {\r
    CoreNewDebugImageInfoEntry (EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL, &Image->Info, Image->Handle);\r
  }\r
\r
  //\r
  //Reinstall loaded image protocol to fire any notifications\r
  //\r
  Status = CoreReinstallProtocolInterface (\r
             Image->Handle,\r
             &gEfiLoadedImageProtocolGuid,\r
             &Image->Info,\r
             &Image->Info\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
\r
  //\r
  // Success.  Return the image handle\r
  //\r
  *ImageHandle = Image->Handle;\r
\r
Done:\r
  //\r
  // All done accessing the source file\r
  // If we allocated the Source buffer, free it\r
  //\r
  if (FHand.FreeBuffer) {\r
    CoreFreePool (FHand.Source);\r
  }\r
\r
  //\r
  // There was an error.  If there's an Image structure, free it\r
  //\r
  if (EFI_ERROR (Status)) {\r
    if (Image != NULL) {\r
      CoreUnloadAndCloseImage (Image, (BOOLEAN)(DstBuffer == 0));\r
      *ImageHandle = NULL;\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
CoreLoadImage (\r
  IN BOOLEAN                    BootPolicy,\r
  IN EFI_HANDLE                 ParentImageHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL   *FilePath,\r
  IN VOID                       *SourceBuffer   OPTIONAL,\r
  IN UINTN                      SourceSize,\r
  OUT EFI_HANDLE                *ImageHandle\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Loads an EFI image into memory and returns a handle to the image.\r
\r
Arguments:\r
\r
  BootPolicy          - If TRUE, indicates that the request originates from the boot manager,\r
                        and that the boot manager is attempting to load FilePath as a boot selection.\r
  ParentImageHandle   - The caller's image handle.\r
  FilePath            - The specific file path from which the image is loaded.\r
  SourceBuffer        - If not NULL, a pointer to the memory location containing a copy of\r
                        the image to be loaded.\r
  SourceSize          - The size in bytes of SourceBuffer.\r
  ImageHandle         - Pointer to the returned image handle that is created when the image\r
                        is successfully loaded.\r
\r
Returns:\r
\r
  EFI_SUCCESS            - The image was loaded into memory.\r
  EFI_NOT_FOUND          - The FilePath was not found.\r
  EFI_INVALID_PARAMETER  - One of the parameters has an invalid value.\r
  EFI_UNSUPPORTED        - The image type is not supported, or the device path cannot be\r
                           parsed to locate the proper protocol for loading the file.\r
  EFI_OUT_OF_RESOURCES   - Image was not loaded due to insufficient resources.\r
--*/\r
{\r
  EFI_STATUS    Status;\r
\r
  PERF_START (NULL, "LoadImage", NULL, 0);\r
\r
  Status = CoreLoadImageCommon (\r
             BootPolicy,\r
             ParentImageHandle,\r
             FilePath,\r
             SourceBuffer,\r
             SourceSize,\r
             (EFI_PHYSICAL_ADDRESS)NULL,\r
             NULL,\r
             ImageHandle,\r
             NULL,\r
             EFI_LOAD_PE_IMAGE_ATTRIBUTE_RUNTIME_REGISTRATION | EFI_LOAD_PE_IMAGE_ATTRIBUTE_DEBUG_IMAGE_INFO_TABLE_REGISTRATION\r
             );\r
\r
  PERF_END (NULL, "LoadImage", NULL, 0);\r
\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
CoreLoadImageEx (\r
  IN  EFI_PE32_IMAGE_PROTOCOL          *This,\r
  IN  EFI_HANDLE                       ParentImageHandle,\r
  IN  EFI_DEVICE_PATH_PROTOCOL         *FilePath,\r
  IN  VOID                             *SourceBuffer       OPTIONAL,\r
  IN  UINTN                            SourceSize,\r
  IN  EFI_PHYSICAL_ADDRESS             DstBuffer           OPTIONAL,\r
  OUT UINTN                            *NumberOfPages      OPTIONAL,\r
  OUT EFI_HANDLE                       *ImageHandle,\r
  OUT EFI_PHYSICAL_ADDRESS             *EntryPoint         OPTIONAL,\r
  IN  UINT32                           Attribute\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Loads an EFI image into memory and returns a handle to the image with extended parameters.\r
\r
Arguments:\r
\r
  This                - Calling context\r
  ParentImageHandle   - The caller's image handle.\r
  FilePath            - The specific file path from which the image is loaded.\r
  SourceBuffer        - If not NULL, a pointer to the memory location containing a copy of\r
                        the image to be loaded.\r
  SourceSize          - The size in bytes of SourceBuffer.\r
  DstBuffer           - The buffer to store the image.\r
  NumberOfPages       - For input, specifies the space size of the image by caller if not NULL.\r
                        For output, specifies the actual space size needed.\r
  ImageHandle         - Image handle for output.\r
  EntryPoint          - Image entry point for output.\r
  Attribute           - The bit mask of attributes to set for the load PE image.\r
\r
Returns:\r
\r
  EFI_SUCCESS            - The image was loaded into memory.\r
  EFI_NOT_FOUND          - The FilePath was not found.\r
  EFI_INVALID_PARAMETER  - One of the parameters has an invalid value.\r
  EFI_UNSUPPORTED        - The image type is not supported, or the device path cannot be\r
                           parsed to locate the proper protocol for loading the file.\r
  EFI_OUT_OF_RESOURCES   - Image was not loaded due to insufficient resources.\r
--*/\r
{\r
  return CoreLoadImageCommon (\r
           TRUE,\r
           ParentImageHandle,\r
           FilePath,\r
           SourceBuffer,\r
           SourceSize,\r
           DstBuffer,\r
           NumberOfPages,\r
           ImageHandle,\r
           EntryPoint,\r
           Attribute\r
           );\r
}\r
\r
\r
\r
\r
EFI_STATUS\r
EFIAPI\r
CoreStartImage (\r
  IN EFI_HANDLE  ImageHandle,\r
  OUT UINTN      *ExitDataSize,\r
  OUT CHAR16     **ExitData  OPTIONAL\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Transfer control to a loaded image's entry point.\r
\r
Arguments:\r
\r
  ImageHandle     - Handle of image to be started.\r
\r
  ExitDataSize    - Pointer of the size to ExitData\r
\r
  ExitData        - Pointer to a pointer to a data buffer that includes a Null-terminated\r
                    Unicode string, optionally followed by additional binary data. The string\r
                    is a description that the caller may use to further indicate the reason for\r