[mirror_edk2.git] / MdeModulePkg / Core / Dxe / Image / ImageFile.c

/** @file\r
  Handle services to image file.\r
\r
Copyright (c) 2006 - 2008, Intel Corporation. <BR>\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
**/\r
\r
#include "DxeMain.h"\r
#include "Image.h"\r
\r
/**\r
  Search a handle to a device on a specified device path that supports a specified protocol,\r
  interface of that protocol on that handle is another output.\r
\r
\r
\r
  @param  Protocol               The protocol to search for\r
  @param  FilePath               The specified device path\r
  @param  Interface              Interface of the protocol on the handle\r
  @param  Handle                 The handle to the device on the specified device\r
                                 path that supports the protocol.\r
\r
  @return Status code.\r
\r
**/\r
EFI_STATUS\r
CoreDevicePathToInterface (\r
  IN EFI_GUID                     *Protocol,\r
  IN EFI_DEVICE_PATH_PROTOCOL     **FilePath,\r
  OUT VOID                        **Interface,\r
  OUT EFI_HANDLE                  *Handle\r
  )\r
{\r
  EFI_STATUS                      Status;\r
\r
  Status = CoreLocateDevicePath (Protocol, FilePath, Handle);\r
  if (!EFI_ERROR (Status)) {\r
    Status = CoreHandleProtocol (*Handle, Protocol, Interface);\r
  }\r
  return Status;\r
}\r
\r
\r
/**\r
  Opens a file for (simple) reading.  The simple read abstraction\r
  will access the file either from a memory copy, from a file\r
  system interface, or from the load file interface.\r
\r
  @param  BootPolicy             Policy for Open Image File.\r
  @param  SourceBuffer           Pointer to the memory location containing copy\r
                                 of the image to be loaded.\r
  @param  SourceSize             The size in bytes of SourceBuffer.\r
  @param  FilePath               The specific file path from which the image is\r
                                 loaded\r
  @param  DeviceHandle           Pointer to the return device handle.\r
  @param  ImageFileHandle        Pointer to the image file handle.\r
  @param  AuthenticationStatus   Pointer to a caller-allocated UINT32 in which\r
                                 the authentication status is returned.\r
\r
  @retval EFI_SUCCESS            Image file successfully opened.\r
  @retval EFI_LOAD_ERROR         If the caller passed a copy of the file, and\r
                                 SourceSize is 0.\r
  @retval EFI_INVALID_PARAMETER  File path is not valid.\r
  @retval EFI_NOT_FOUND          File not found.\r
\r
**/\r
EFI_STATUS\r
CoreOpenImageFile (\r
  IN BOOLEAN                        BootPolicy,\r
  IN VOID                           *SourceBuffer   OPTIONAL,\r
  IN UINTN                          SourceSize,\r
  IN OUT EFI_DEVICE_PATH_PROTOCOL   **FilePath,\r
  OUT EFI_HANDLE                    *DeviceHandle,\r
  IN IMAGE_FILE_HANDLE              *ImageFileHandle,\r
  OUT UINT32                        *AuthenticationStatus\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  EFI_DEVICE_PATH_PROTOCOL          *TempFilePath;\r
  FILEPATH_DEVICE_PATH              *FilePathNode;\r
  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FwVolFilePathNode;\r
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Volume;\r
  EFI_FILE_HANDLE                   FileHandle;\r
  EFI_FILE_HANDLE                   LastHandle;\r
  EFI_LOAD_FILE_PROTOCOL            *LoadFile;\r
  EFI_FIRMWARE_VOLUME2_PROTOCOL     *FwVol;\r
  EFI_SECTION_TYPE                  SectionType;\r
  UINT8                             *Pe32Buffer;\r
  UINTN                             Pe32BufferSize;\r
  EFI_FV_FILETYPE                   Type;\r
  EFI_FV_FILE_ATTRIBUTES            Attrib;\r
  EFI_FILE_INFO                     *FileInfo;\r
  UINTN                             FileInfoSize;\r
  EFI_GUID                          *NameGuid;\r
  FILEPATH_DEVICE_PATH              *OriginalFilePathNode;\r
\r
  OriginalFilePathNode = NULL;\r
  *AuthenticationStatus = 0;\r
  ZeroMem (ImageFileHandle, sizeof (IMAGE_FILE_HANDLE));\r
  ImageFileHandle->Signature = IMAGE_FILE_HANDLE_SIGNATURE;\r
\r
  //\r
  // If the caller passed a copy of the file, then just use it\r
  //\r
  if (SourceBuffer != NULL) {\r
    ImageFileHandle->Source     = SourceBuffer;\r
    ImageFileHandle->SourceSize = SourceSize;\r
    *DeviceHandle               = NULL;\r
    CoreLocateDevicePath (&gEfiDevicePathProtocolGuid, FilePath, DeviceHandle);\r
    if (SourceSize > 0) {\r
      Status = EFI_SUCCESS;\r
    } else {\r
      Status = EFI_LOAD_ERROR;\r
    }\r
    goto Done;\r
  }\r
\r
  //\r
  // Make sure FilePath is valid\r
  //\r
  if (*FilePath == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Check to see if it's in a Firmware Volume\r
  //\r
  FwVolFilePathNode = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) *FilePath;\r
  Status = CoreDevicePathToInterface (\r
            &gEfiFirmwareVolume2ProtocolGuid,\r
            (EFI_DEVICE_PATH_PROTOCOL **)&FwVolFilePathNode,\r
            (VOID*)&FwVol,\r
            DeviceHandle\r
            );\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // For FwVol File system there is only a single file name that is a GUID.\r
    //\r
    NameGuid = EfiGetNameGuidFromFwVolDevicePathNode (FwVolFilePathNode);\r
    if (NameGuid != NULL) {\r
\r
      SectionType = EFI_SECTION_PE32;\r
      Pe32Buffer  = NULL;\r
      Status = FwVol->ReadSection (\r
                        FwVol,\r
                        NameGuid,\r
                        SectionType,\r
                        0,\r
                        (VOID **)&Pe32Buffer,\r
                        &Pe32BufferSize,\r
                        AuthenticationStatus\r
                        );\r
      if (EFI_ERROR (Status)) {\r
        //\r
        // Try a raw file, since a PE32 SECTION does not exist\r
        //\r
        if (Pe32Buffer != NULL) {\r
          CoreFreePool (Pe32Buffer);\r
          *AuthenticationStatus = 0;\r
        }\r
        Pe32Buffer = NULL;\r
        Status = FwVol->ReadFile (\r
                          FwVol,\r
                          NameGuid,\r
                          (VOID **)&Pe32Buffer,\r
                          &Pe32BufferSize,\r
                          &Type,\r
                          &Attrib,\r
                          AuthenticationStatus\r
                          );\r
      }\r
\r
      if (!EFI_ERROR (Status)) {\r
        //\r
        // One of the reads passed so we are done\r
        //\r
        ImageFileHandle->Source = Pe32Buffer;\r
        ImageFileHandle->SourceSize = Pe32BufferSize;\r
        ImageFileHandle->FreeBuffer = TRUE;\r
        goto Done;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Attempt to access the file via a file system interface\r
  //\r
  FilePathNode = (FILEPATH_DEVICE_PATH *) *FilePath;\r
  Status = CoreDevicePathToInterface (\r
            &gEfiSimpleFileSystemProtocolGuid,\r
            (EFI_DEVICE_PATH_PROTOCOL **)&FilePathNode,\r
            (VOID*)&Volume,\r
            DeviceHandle\r
            );\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // Open the Volume to get the File System handle\r
    //\r
    Status = Volume->OpenVolume (Volume, &FileHandle);\r
    if (!EFI_ERROR (Status)) {\r
      //\r
      // Duplicate the device path to avoid the access to unaligned device path node.\r
      // Because the device path consists of one or more FILE PATH MEDIA DEVICE PATH\r
      // nodes, It assures the fields in device path nodes are 2 byte aligned.\r
      //\r
      FilePathNode = (FILEPATH_DEVICE_PATH *)DuplicateDevicePath((EFI_DEVICE_PATH_PROTOCOL *)(UINTN)FilePathNode);\r
      if (FilePathNode == NULL) {\r
        FileHandle->Close (FileHandle);\r
        Status = EFI_OUT_OF_RESOURCES;\r
      } else {\r
        OriginalFilePathNode = FilePathNode;\r
        //\r
        // Parse each MEDIA_FILEPATH_DP node. There may be more than one, since the\r
        // directory information and filename can be seperate. The goal is to inch\r
        // our way down each device path node and close the previous node\r
        //\r
        while (!IsDevicePathEnd (&FilePathNode->Header)) {\r
          if (DevicePathType (&FilePathNode->Header) != MEDIA_DEVICE_PATH ||\r
              DevicePathSubType (&FilePathNode->Header) != MEDIA_FILEPATH_DP) {\r
            Status = EFI_UNSUPPORTED;\r
          }\r
\r
          if (EFI_ERROR (Status)) {\r
            //\r
            // Exit loop on Error\r
            //\r
            break;\r
          }\r
\r
          LastHandle = FileHandle;\r
          FileHandle = NULL;\r
\r
          Status = LastHandle->Open (\r
                                LastHandle,\r
                                &FileHandle,\r
                                FilePathNode->PathName,\r
                                EFI_FILE_MODE_READ,\r
                                0\r
                                );\r
\r
          //\r
          // Close the previous node\r
          //\r
          LastHandle->Close (LastHandle);\r
\r
          FilePathNode = (FILEPATH_DEVICE_PATH *) NextDevicePathNode (&FilePathNode->Header);\r
        }\r
        //\r
        // Free the allocated memory pool\r
        //\r
        CoreFreePool(OriginalFilePathNode);\r
      }\r
\r
      if (!EFI_ERROR (Status)) {\r
        //\r
        // We have found the file. Now we need to read it. Before we can read the file we need to\r
        // figure out how big the file is.\r
        //\r
        FileInfo = NULL;\r
        FileInfoSize = 0;\r
        Status = FileHandle->GetInfo (\r
                              FileHandle,\r
                              &gEfiFileInfoGuid,\r
                              &FileInfoSize,\r
                              FileInfo\r
                              );\r
        if (Status == EFI_BUFFER_TOO_SMALL) {\r
          FileInfo = AllocatePool (FileInfoSize);\r
          if (FileInfo != NULL) {\r
            Status = FileHandle->GetInfo (\r
                                  FileHandle,\r
                                  &gEfiFileInfoGuid,\r
                                  &FileInfoSize,\r
                                  FileInfo\r
                                  );\r
          } else {\r
            Status = EFI_OUT_OF_RESOURCES;\r
            goto Done;\r
          }\r
        }\r
        \r
        if (!EFI_ERROR (Status)) {\r
          //\r
          // Allocate space for the file\r
          //\r
          ASSERT (FileInfo != NULL);\r
          ImageFileHandle->Source = AllocatePool ((UINTN)FileInfo->FileSize);\r
          if (ImageFileHandle->Source != NULL) {\r
            //\r
            // Read the file into the buffer we allocated\r
            //\r
            ImageFileHandle->SourceSize = (UINTN) FileInfo->FileSize;\r
            ImageFileHandle->FreeBuffer = TRUE;\r
            Status = FileHandle->Read (FileHandle, &ImageFileHandle->SourceSize, ImageFileHandle->Source);\r
\r
            //\r
            // Close the file since we are done\r
            //\r
            FileHandle->Close (FileHandle);\r
            CoreFreePool (FileInfo);\r
          } else {\r
            Status = EFI_OUT_OF_RESOURCES;\r
          }\r
\r
          goto Done;\r
        }\r
      }\r
    }\r
  }\r
\r
\r
  //\r
  // Try LoadFile style\r
  //\r
\r
  TempFilePath = *FilePath;\r
  Status = CoreDevicePathToInterface (\r
             &gEfiLoadFileProtocolGuid,\r
             &TempFilePath,\r
             (VOID*) &LoadFile,\r
             DeviceHandle\r
             );\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // Call LoadFile with the correct buffer size\r
    //\r
    ASSERT (ImageFileHandle->SourceSize == 0);\r
    ASSERT (ImageFileHandle->Source == NULL);\r
    Status = LoadFile->LoadFile (\r
                         LoadFile,\r
                         TempFilePath,\r
                         BootPolicy,\r
                         &ImageFileHandle->SourceSize,\r
                         ImageFileHandle->Source\r
                         );\r
    if (Status == EFI_BUFFER_TOO_SMALL) {\r
      ImageFileHandle->Source = AllocatePool (ImageFileHandle->SourceSize);\r
      if (ImageFileHandle->Source == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
      } else {\r
        Status = LoadFile->LoadFile (\r
                             LoadFile,\r
                             TempFilePath,\r
                             BootPolicy,\r
                             &ImageFileHandle->SourceSize,\r
                             ImageFileHandle->Source\r
                             );\r
      }\r
    }\r
\r
    if (!EFI_ERROR (Status)) {\r
      ImageFileHandle->FreeBuffer = TRUE;\r
      goto Done;\r
    }\r
  }\r
\r
  //\r
  // Nothing else to try\r
  //\r
  DEBUG ((DEBUG_LOAD|DEBUG_WARN, "CoreOpenImageFile: Device did not support a known load protocol\n"));\r
  Status = EFI_NOT_FOUND;\r
\r
Done:\r
  //\r
  // If the file was not accessed, clean up\r
  //\r
  if (EFI_ERROR (Status)) {\r
    if (ImageFileHandle->FreeBuffer) {\r
      //\r
      // Free the source buffer if we allocated it\r
      //\r
      CoreFreePool (ImageFileHandle->Source);\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
\r
\r
/**\r
  Read image file (specified by UserHandle) into user specified buffer with specified offset\r
  and length.\r
\r
  @param  UserHandle             Image file handle\r
  @param  Offset                 Offset to the source file\r
  @param  ReadSize               For input, pointer of size to read; For output,\r
                                 pointer of size actually read.\r
  @param  Buffer                 Buffer to write into\r
\r
  @retval EFI_SUCCESS            Successfully read the specified part of file\r
                                 into buffer.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
CoreReadImageFile (\r
  IN     VOID    *UserHandle,\r
  IN     UINTN   Offset,\r
  IN OUT UINTN   *ReadSize,\r
  OUT    VOID    *Buffer\r
  )\r
{\r
  UINTN               EndPosition;\r
  IMAGE_FILE_HANDLE  *FHand;\r
\r
  FHand = (IMAGE_FILE_HANDLE  *)UserHandle;\r
  ASSERT (FHand->Signature == IMAGE_FILE_HANDLE_SIGNATURE);\r
\r
  //\r
  // Move data from our local copy of the file\r
  //\r
  EndPosition = Offset + *ReadSize;\r
  if (EndPosition > FHand->SourceSize) {\r
    *ReadSize = (UINT32)(FHand->SourceSize - Offset);\r
  }\r
  if (Offset >= FHand->SourceSize) {\r
      *ReadSize = 0;\r
  }\r
\r
  CopyMem (Buffer, (CHAR8 *)FHand->Source + Offset, *ReadSize);\r
  return EFI_SUCCESS;\r
}\r
\r
Commit	Line	Data
	1	/** @file\r
	2	Handle services to image file.\r
	3	\r
	4	Copyright (c) 2006 - 2008, Intel Corporation. <BR>\r
	5	All rights reserved. This program and the accompanying materials\r
	6	are licensed and made available under the terms and conditions of the BSD License\r
	7	which accompanies this distribution. The full text of the license may be found at\r
	8	http://opensource.org/licenses/bsd-license.php\r
	9	\r
	10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	12	\r
	13	**/\r
	14	\r
	15	#include "DxeMain.h"\r
	16	#include "Image.h"\r
	17	\r
	18	/**\r
	19	Search a handle to a device on a specified device path that supports a specified protocol,\r
	20	interface of that protocol on that handle is another output.\r
	21	\r
	22	\r
	23	\r
	24	@param Protocol The protocol to search for\r
	25	@param FilePath The specified device path\r
	26	@param Interface Interface of the protocol on the handle\r
	27	@param Handle The handle to the device on the specified device\r
	28	path that supports the protocol.\r
	29	\r
	30	@return Status code.\r
	31	\r
	32	**/\r
	33	EFI_STATUS\r
	34	CoreDevicePathToInterface (\r
	35	IN EFI_GUID *Protocol,\r
	36	IN EFI_DEVICE_PATH_PROTOCOL **FilePath,\r
	37	OUT VOID **Interface,\r
	38	OUT EFI_HANDLE *Handle\r
	39	)\r
	40	{\r
	41	EFI_STATUS Status;\r
	42	\r
	43	Status = CoreLocateDevicePath (Protocol, FilePath, Handle);\r
	44	if (!EFI_ERROR (Status)) {\r
	45	Status = CoreHandleProtocol (*Handle, Protocol, Interface);\r
	46	}\r
	47	return Status;\r
	48	}\r
	49	\r
	50	\r
	51	/**\r
	52	Opens a file for (simple) reading. The simple read abstraction\r
	53	will access the file either from a memory copy, from a file\r
	54	system interface, or from the load file interface.\r
	55	\r
	56	@param BootPolicy Policy for Open Image File.\r
	57	@param SourceBuffer Pointer to the memory location containing copy\r
	58	of the image to be loaded.\r
	59	@param SourceSize The size in bytes of SourceBuffer.\r
	60	@param FilePath The specific file path from which the image is\r
	61	loaded\r
	62	@param DeviceHandle Pointer to the return device handle.\r
	63	@param ImageFileHandle Pointer to the image file handle.\r
	64	@param AuthenticationStatus Pointer to a caller-allocated UINT32 in which\r
	65	the authentication status is returned.\r
	66	\r
	67	@retval EFI_SUCCESS Image file successfully opened.\r
	68	@retval EFI_LOAD_ERROR If the caller passed a copy of the file, and\r
	69	SourceSize is 0.\r
	70	@retval EFI_INVALID_PARAMETER File path is not valid.\r
	71	@retval EFI_NOT_FOUND File not found.\r
	72	\r
	73	**/\r
	74	EFI_STATUS\r
	75	CoreOpenImageFile (\r
	76	IN BOOLEAN BootPolicy,\r
	77	IN VOID *SourceBuffer OPTIONAL,\r
	78	IN UINTN SourceSize,\r
	79	IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath,\r
	80	OUT EFI_HANDLE *DeviceHandle,\r
	81	IN IMAGE_FILE_HANDLE *ImageFileHandle,\r
	82	OUT UINT32 *AuthenticationStatus\r
	83	)\r
	84	{\r
	85	EFI_STATUS Status;\r
	86	EFI_DEVICE_PATH_PROTOCOL *TempFilePath;\r
	87	FILEPATH_DEVICE_PATH *FilePathNode;\r
	88	MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FwVolFilePathNode;\r
	89	EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;\r
	90	EFI_FILE_HANDLE FileHandle;\r
	91	EFI_FILE_HANDLE LastHandle;\r
	92	EFI_LOAD_FILE_PROTOCOL *LoadFile;\r
	93	EFI_FIRMWARE_VOLUME2_PROTOCOL *FwVol;\r
	94	EFI_SECTION_TYPE SectionType;\r
	95	UINT8 *Pe32Buffer;\r
	96	UINTN Pe32BufferSize;\r
	97	EFI_FV_FILETYPE Type;\r
	98	EFI_FV_FILE_ATTRIBUTES Attrib;\r
	99	EFI_FILE_INFO *FileInfo;\r
	100	UINTN FileInfoSize;\r
	101	EFI_GUID *NameGuid;\r
	102	FILEPATH_DEVICE_PATH *OriginalFilePathNode;\r
	103	\r
	104	OriginalFilePathNode = NULL;\r
	105	*AuthenticationStatus = 0;\r
	106	ZeroMem (ImageFileHandle, sizeof (IMAGE_FILE_HANDLE));\r
	107	ImageFileHandle->Signature = IMAGE_FILE_HANDLE_SIGNATURE;\r
	108	\r
	109	//\r
	110	// If the caller passed a copy of the file, then just use it\r
	111	//\r
	112	if (SourceBuffer != NULL) {\r
	113	ImageFileHandle->Source = SourceBuffer;\r
	114	ImageFileHandle->SourceSize = SourceSize;\r
	115	*DeviceHandle = NULL;\r
	116	CoreLocateDevicePath (&gEfiDevicePathProtocolGuid, FilePath, DeviceHandle);\r
	117	if (SourceSize > 0) {\r
	118	Status = EFI_SUCCESS;\r
	119	} else {\r
	120	Status = EFI_LOAD_ERROR;\r
	121	}\r
	122	goto Done;\r
	123	}\r
	124	\r
	125	//\r
	126	// Make sure FilePath is valid\r
	127	//\r
	128	if (*FilePath == NULL) {\r
	129	return EFI_INVALID_PARAMETER;\r
	130	}\r
	131	\r
	132	//\r
	133	// Check to see if it's in a Firmware Volume\r
	134	//\r
	135	FwVolFilePathNode = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH ) FilePath;\r
	136	Status = CoreDevicePathToInterface (\r
	137	&gEfiFirmwareVolume2ProtocolGuid,\r
	138	(EFI_DEVICE_PATH_PROTOCOL **)&FwVolFilePathNode,\r
	139	(VOID*)&FwVol,\r
	140	DeviceHandle\r
	141	);\r
	142	if (!EFI_ERROR (Status)) {\r
	143	//\r
	144	// For FwVol File system there is only a single file name that is a GUID.\r
	145	//\r
	146	NameGuid = EfiGetNameGuidFromFwVolDevicePathNode (FwVolFilePathNode);\r
	147	if (NameGuid != NULL) {\r
	148	\r
	149	SectionType = EFI_SECTION_PE32;\r
	150	Pe32Buffer = NULL;\r
	151	Status = FwVol->ReadSection (\r
	152	FwVol,\r
	153	NameGuid,\r
	154	SectionType,\r
	155	0,\r
	156	(VOID **)&Pe32Buffer,\r
	157	&Pe32BufferSize,\r
	158	AuthenticationStatus\r
	159	);\r
	160	if (EFI_ERROR (Status)) {\r
	161	//\r
	162	// Try a raw file, since a PE32 SECTION does not exist\r
	163	//\r
	164	if (Pe32Buffer != NULL) {\r
	165	CoreFreePool (Pe32Buffer);\r
	166	*AuthenticationStatus = 0;\r
	167	}\r
	168	Pe32Buffer = NULL;\r
	169	Status = FwVol->ReadFile (\r
	170	FwVol,\r
	171	NameGuid,\r
	172	(VOID **)&Pe32Buffer,\r
	173	&Pe32BufferSize,\r
	174	&Type,\r
	175	&Attrib,\r
	176	AuthenticationStatus\r
	177	);\r
	178	}\r
	179	\r
	180	if (!EFI_ERROR (Status)) {\r
	181	//\r
	182	// One of the reads passed so we are done\r
	183	//\r
	184	ImageFileHandle->Source = Pe32Buffer;\r
	185	ImageFileHandle->SourceSize = Pe32BufferSize;\r
	186	ImageFileHandle->FreeBuffer = TRUE;\r
	187	goto Done;\r
	188	}\r
	189	}\r
	190	}\r
	191	\r
	192	//\r
	193	// Attempt to access the file via a file system interface\r
	194	//\r
	195	FilePathNode = (FILEPATH_DEVICE_PATH ) FilePath;\r
	196	Status = CoreDevicePathToInterface (\r
	197	&gEfiSimpleFileSystemProtocolGuid,\r
	198	(EFI_DEVICE_PATH_PROTOCOL **)&FilePathNode,\r
	199	(VOID*)&Volume,\r
	200	DeviceHandle\r
	201	);\r
	202	if (!EFI_ERROR (Status)) {\r
	203	//\r
	204	// Open the Volume to get the File System handle\r
	205	//\r
	206	Status = Volume->OpenVolume (Volume, &FileHandle);\r
	207	if (!EFI_ERROR (Status)) {\r
	208	//\r
	209	// Duplicate the device path to avoid the access to unaligned device path node.\r
	210	// Because the device path consists of one or more FILE PATH MEDIA DEVICE PATH\r
	211	// nodes, It assures the fields in device path nodes are 2 byte aligned.\r
	212	//\r
	213	FilePathNode = (FILEPATH_DEVICE_PATH )DuplicateDevicePath((EFI_DEVICE_PATH_PROTOCOL )(UINTN)FilePathNode);\r
	214	if (FilePathNode == NULL) {\r
	215	FileHandle->Close (FileHandle);\r
	216	Status = EFI_OUT_OF_RESOURCES;\r
	217	} else {\r
	218	OriginalFilePathNode = FilePathNode;\r
	219	//\r
	220	// Parse each MEDIA_FILEPATH_DP node. There may be more than one, since the\r
	221	// directory information and filename can be seperate. The goal is to inch\r
	222	// our way down each device path node and close the previous node\r
	223	//\r
	224	while (!IsDevicePathEnd (&FilePathNode->Header)) {\r
	225	if (DevicePathType (&FilePathNode->Header) != MEDIA_DEVICE_PATH \|\|\r
	226	DevicePathSubType (&FilePathNode->Header) != MEDIA_FILEPATH_DP) {\r
	227	Status = EFI_UNSUPPORTED;\r
	228	}\r
	229	\r
	230	if (EFI_ERROR (Status)) {\r
	231	//\r
	232	// Exit loop on Error\r
	233	//\r
	234	break;\r
	235	}\r
	236	\r
	237	LastHandle = FileHandle;\r
	238	FileHandle = NULL;\r
	239	\r
	240	Status = LastHandle->Open (\r
	241	LastHandle,\r
	242	&FileHandle,\r
	243	FilePathNode->PathName,\r
	244	EFI_FILE_MODE_READ,\r
	245	0\r
	246	);\r
	247	\r
	248	//\r
	249	// Close the previous node\r
	250	//\r
	251	LastHandle->Close (LastHandle);\r
	252	\r
	253	FilePathNode = (FILEPATH_DEVICE_PATH *) NextDevicePathNode (&FilePathNode->Header);\r
	254	}\r
	255	//\r
	256	// Free the allocated memory pool\r
	257	//\r
	258	CoreFreePool(OriginalFilePathNode);\r
	259	}\r
	260	\r
	261	if (!EFI_ERROR (Status)) {\r
	262	//\r
	263	// We have found the file. Now we need to read it. Before we can read the file we need to\r
	264	// figure out how big the file is.\r
	265	//\r
	266	FileInfo = NULL;\r
	267	FileInfoSize = 0;\r
	268	Status = FileHandle->GetInfo (\r
	269	FileHandle,\r
	270	&gEfiFileInfoGuid,\r
	271	&FileInfoSize,\r
	272	FileInfo\r
	273	);\r
	274	if (Status == EFI_BUFFER_TOO_SMALL) {\r
	275	FileInfo = AllocatePool (FileInfoSize);\r
	276	if (FileInfo != NULL) {\r
	277	Status = FileHandle->GetInfo (\r
	278	FileHandle,\r
	279	&gEfiFileInfoGuid,\r
	280	&FileInfoSize,\r
	281	FileInfo\r
	282	);\r
	283	} else {\r
	284	Status = EFI_OUT_OF_RESOURCES;\r
	285	goto Done;\r
	286	}\r
	287	}\r
	288	\r
	289	if (!EFI_ERROR (Status)) {\r
	290	//\r
	291	// Allocate space for the file\r
	292	//\r
	293	ASSERT (FileInfo != NULL);\r
	294	ImageFileHandle->Source = AllocatePool ((UINTN)FileInfo->FileSize);\r
	295	if (ImageFileHandle->Source != NULL) {\r
	296	//\r
	297	// Read the file into the buffer we allocated\r
	298	//\r
	299	ImageFileHandle->SourceSize = (UINTN) FileInfo->FileSize;\r
	300	ImageFileHandle->FreeBuffer = TRUE;\r
	301	Status = FileHandle->Read (FileHandle, &ImageFileHandle->SourceSize, ImageFileHandle->Source);\r
	302	\r
	303	//\r
	304	// Close the file since we are done\r
	305	//\r
	306	FileHandle->Close (FileHandle);\r
	307	CoreFreePool (FileInfo);\r
	308	} else {\r
	309	Status = EFI_OUT_OF_RESOURCES;\r
	310	}\r
	311	\r
	312	goto Done;\r
	313	}\r
	314	}\r
	315	}\r
	316	}\r
	317	\r
	318	\r
	319	//\r
	320	// Try LoadFile style\r
	321	//\r
	322	\r
	323	TempFilePath = *FilePath;\r
	324	Status = CoreDevicePathToInterface (\r
	325	&gEfiLoadFileProtocolGuid,\r
	326	&TempFilePath,\r
	327	(VOID*) &LoadFile,\r
	328	DeviceHandle\r
	329	);\r
	330	if (!EFI_ERROR (Status)) {\r
	331	//\r
	332	// Call LoadFile with the correct buffer size\r
	333	//\r
	334	ASSERT (ImageFileHandle->SourceSize == 0);\r
	335	ASSERT (ImageFileHandle->Source == NULL);\r
	336	Status = LoadFile->LoadFile (\r
	337	LoadFile,\r
	338	TempFilePath,\r
	339	BootPolicy,\r
	340	&ImageFileHandle->SourceSize,\r
	341	ImageFileHandle->Source\r
	342	);\r
	343	if (Status == EFI_BUFFER_TOO_SMALL) {\r
	344	ImageFileHandle->Source = AllocatePool (ImageFileHandle->SourceSize);\r
	345	if (ImageFileHandle->Source == NULL) {\r
	346	Status = EFI_OUT_OF_RESOURCES;\r
	347	} else {\r
	348	Status = LoadFile->LoadFile (\r
	349	LoadFile,\r
	350	TempFilePath,\r
	351	BootPolicy,\r
	352	&ImageFileHandle->SourceSize,\r
	353	ImageFileHandle->Source\r
	354	);\r
	355	}\r
	356	}\r
	357	\r
	358	if (!EFI_ERROR (Status)) {\r
	359	ImageFileHandle->FreeBuffer = TRUE;\r
	360	goto Done;\r
	361	}\r
	362	}\r
	363	\r
	364	//\r
	365	// Nothing else to try\r
	366	//\r
	367	DEBUG ((DEBUG_LOAD\|DEBUG_WARN, "CoreOpenImageFile: Device did not support a known load protocol\n"));\r
	368	Status = EFI_NOT_FOUND;\r
	369	\r
	370	Done:\r
	371	//\r
	372	// If the file was not accessed, clean up\r
	373	//\r
	374	if (EFI_ERROR (Status)) {\r
	375	if (ImageFileHandle->FreeBuffer) {\r
	376	//\r
	377	// Free the source buffer if we allocated it\r
	378	//\r
	379	CoreFreePool (ImageFileHandle->Source);\r
	380	}\r
	381	}\r
	382	\r
	383	return Status;\r
	384	}\r
	385	\r
	386	\r
	387	\r
	388	/**\r
	389	Read image file (specified by UserHandle) into user specified buffer with specified offset\r
	390	and length.\r
	391	\r
	392	@param UserHandle Image file handle\r
	393	@param Offset Offset to the source file\r
	394	@param ReadSize For input, pointer of size to read; For output,\r
	395	pointer of size actually read.\r
	396	@param Buffer Buffer to write into\r
	397	\r
	398	@retval EFI_SUCCESS Successfully read the specified part of file\r
	399	into buffer.\r
	400	\r
	401	**/\r
	402	EFI_STATUS\r
	403	EFIAPI\r
	404	CoreReadImageFile (\r
	405	IN VOID *UserHandle,\r
	406	IN UINTN Offset,\r
	407	IN OUT UINTN *ReadSize,\r
	408	OUT VOID *Buffer\r
	409	)\r
	410	{\r
	411	UINTN EndPosition;\r
	412	IMAGE_FILE_HANDLE *FHand;\r
	413	\r
	414	FHand = (IMAGE_FILE_HANDLE *)UserHandle;\r
	415	ASSERT (FHand->Signature == IMAGE_FILE_HANDLE_SIGNATURE);\r
	416	\r
	417	//\r
	418	// Move data from our local copy of the file\r
	419	//\r
	420	EndPosition = Offset + *ReadSize;\r
	421	if (EndPosition > FHand->SourceSize) {\r
	422	*ReadSize = (UINT32)(FHand->SourceSize - Offset);\r
	423	}\r
	424	if (Offset >= FHand->SourceSize) {\r
	425	*ReadSize = 0;\r
	426	}\r
	427	\r
	428	CopyMem (Buffer, (CHAR8 )FHand->Source + Offset, ReadSize);\r
	429	return EFI_SUCCESS;\r
	430	}\r
	431	\r