[mirror_edk2.git] / MdeModulePkg / Core / Dxe / FwVol / FwVolRead.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
  FwVolRead.c\r
\r
Abstract:\r
\r
  Implements read firmware file\r
\r
--*/\r
\r
#include <DxeMain.h>\r
\r
/*++\r
\r
Required Alignment    Alignment Value in FFS       Alignment Value in\r
(bytes)                        Attributes Field               Firmware Volume Interfaces\r
1                                    0                                     0\r
2                                    0                                     1\r
4                                    0                                     2\r
8                                    0                                     3\r
16                                   1                                     4\r
128                                  2                                     7\r
512                                  3                                     9\r
1 KB                                 4                                     10\r
4 KB                                 5                                     12\r
32 KB                                6                                     15\r
64 KB                                7                                     16\r
\r
--*/\r
\r
UINT8 mFvAttributes[] = {0, 4, 7, 9, 10, 12, 15, 16}; \r
\r
\r
STATIC\r
EFI_FV_FILE_ATTRIBUTES\r
FfsAttributes2FvFileAttributes (\r
  IN EFI_FFS_FILE_ATTRIBUTES FfsAttributes\r
  )\r
/*++\r
\r
  Routine Description:\r
    Convert the FFS File Attributes to FV File Attributes\r
    \r
  Arguments:\r
    FfsAttributes   -   The attributes of UINT8 type.\r
    \r
  Returns:\r
    The attributes of EFI_FV_FILE_ATTRIBUTES\r
    \r
--*/\r
{\r
  FfsAttributes = (EFI_FFS_FILE_ATTRIBUTES)((FfsAttributes & FFS_ATTRIB_DATA_ALIGNMENT) >> 3);\r
  ASSERT (FfsAttributes < 8);\r
\r
  return (EFI_FV_FILE_ATTRIBUTES) mFvAttributes[FfsAttributes];\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
FvGetNextFile (\r
  IN CONST   EFI_FIRMWARE_VOLUME2_PROTOCOL *This,\r
  IN OUT     VOID                          *Key,\r
  IN OUT     EFI_FV_FILETYPE               *FileType,\r
  OUT        EFI_GUID                      *NameGuid,\r
  OUT        EFI_FV_FILE_ATTRIBUTES        *Attributes,\r
  OUT        UINTN                          *Size\r
  )\r
/*++\r
\r
Routine Description:\r
    Given the input key, search for the next matching file in the volume.\r
\r
Arguments:\r
    This          -   Indicates the calling context.\r
    FileType      -   FileType is a pointer to a caller allocated\r
                      EFI_FV_FILETYPE. The GetNextFile() API can filter it's\r
                      search for files based on the value of *FileType input.\r
                      A *FileType input of 0 causes GetNextFile() to search for\r
                      files of all types.  If a file is found, the file's type\r
                      is returned in *FileType.  *FileType is not modified if\r
                      no file is found.\r
    Key           -   Key is a pointer to a caller allocated buffer that\r
                      contains implementation specific data that is used to\r
                      track where to begin the search for the next file.\r
                      The size of the buffer must be at least This->KeySize\r
                      bytes long. To reinitialize the search and begin from\r
                      the beginning of the firmware volume, the entire buffer\r
                      must be cleared to zero. Other than clearing the buffer\r
                      to initiate a new search, the caller must not modify the\r
                      data in the buffer between calls to GetNextFile().\r
    NameGuid      -   NameGuid is a pointer to a caller allocated EFI_GUID.\r
                      If a file is found, the file's name is returned in\r
                      *NameGuid.  *NameGuid is not modified if no file is\r
                      found.\r
    Attributes    -   Attributes is a pointer to a caller allocated\r
                      EFI_FV_FILE_ATTRIBUTES.  If a file is found, the file's\r
                      attributes are returned in *Attributes. *Attributes is\r
                      not modified if no file is found.\r
    Size          -   Size is a pointer to a caller allocated UINTN.\r
                      If a file is found, the file's size is returned in *Size.\r
                      *Size is not modified if no file is found.\r
\r
Returns:\r
    EFI_SUCCESS                 - Successfully find the file.\r
    EFI_DEVICE_ERROR            - Device error.\r
    EFI_ACCESS_DENIED           - Fv could not read.\r
    EFI_NOT_FOUND               - No matching file found.\r
    EFI_INVALID_PARAMETER       - Invalid parameter\r
\r
--*/\r
{\r
  EFI_STATUS                                  Status;\r
  FV_DEVICE                                   *FvDevice;\r
  EFI_FV_ATTRIBUTES                           FvAttributes;\r
  EFI_FFS_FILE_HEADER                         *FfsFileHeader;\r
  UINTN                                       *KeyValue;\r
  LIST_ENTRY                                  *Link;\r
  FFS_FILE_LIST_ENTRY                         *FfsFileEntry;\r
  UINTN                                       FileLength;\r
\r
  FvDevice = FV_DEVICE_FROM_THIS (This);\r
\r
  Status = FvGetVolumeAttributes (This, &FvAttributes);\r
  if (EFI_ERROR (Status)){\r
    return Status;\r
  }\r
\r
  //\r
  // Check if read operation is enabled\r
  //\r
  if ((FvAttributes & EFI_FV2_READ_STATUS) == 0) {\r
    return EFI_ACCESS_DENIED;\r
  }\r
\r
  if (*FileType > EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE) {\r
    //\r
    // File type needs to be in 0 - 0x0B\r
    //\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  KeyValue = (UINTN *)Key;\r
  for (;;) {\r
    if (*KeyValue == 0) {\r
      //\r
      // Search for 1st matching file\r
      //\r
      Link = &FvDevice->FfsFileListHeader;\r
    } else {\r
      //\r
      // Key is pointer to FFsFileEntry, so get next one\r
      //\r
      Link = (LIST_ENTRY *)(*KeyValue);\r
    }\r
\r
    if (Link->ForwardLink == &FvDevice->FfsFileListHeader) {\r
      //\r
      // Next is end of list so we did not find data\r
      //\r
      return EFI_NOT_FOUND;\r
    }\r
\r
    FfsFileEntry = (FFS_FILE_LIST_ENTRY *)Link->ForwardLink;\r
    FfsFileHeader = (EFI_FFS_FILE_HEADER *)FfsFileEntry->FfsHeader;\r
\r
    //\r
    // remember the key\r
    //\r
    *KeyValue = (UINTN)FfsFileEntry;\r
\r
    if (FfsFileHeader->Type == EFI_FV_FILETYPE_FFS_PAD) {\r
      //\r
      // we ignore pad files\r
      //\r
      continue;\r
    }\r
\r
    if (*FileType == 0) {\r
      //\r
      // Process all file types so we have a match\r
      //\r
      break;\r
    }\r
\r
    if (*FileType == FfsFileHeader->Type) {\r
      //\r
      // Found a matching file type\r
      //\r
      break;\r
    }\r
\r
  } \r
\r
  //\r
  // Return FileType, NameGuid, and Attributes\r
  //\r
  *FileType = FfsFileHeader->Type;\r
  CopyMem (NameGuid, &FfsFileHeader->Name, sizeof (EFI_GUID));\r
  *Attributes = FfsAttributes2FvFileAttributes (FfsFileHeader->Attributes);\r
\r
  //\r
  // Read four bytes out of the 3 byte array and throw out extra data\r
  //\r
  FileLength = *(UINT32 *)&FfsFileHeader->Size[0] & 0x00FFFFFF;\r
\r
  //\r
  // we need to substract the header size\r
  //\r
  *Size = FileLength - sizeof(EFI_FFS_FILE_HEADER);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
FvReadFile (\r
  IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,\r
  IN CONST EFI_GUID                      *NameGuid,\r
  IN OUT   VOID                          **Buffer,\r
  IN OUT   UINTN                         *BufferSize,\r
  OUT      EFI_FV_FILETYPE               *FoundType,\r
  OUT      EFI_FV_FILE_ATTRIBUTES        *FileAttributes,\r
  OUT      UINT32                        *AuthenticationStatus\r
  )\r
/*++\r
\r
Routine Description:\r
    Locates a file in the firmware volume and\r
    copies it to the supplied buffer.\r
\r
Arguments:\r
    This              -   Indicates the calling context.\r
    NameGuid          -   Pointer to an EFI_GUID, which is the filename.\r
    Buffer            -   Buffer is a pointer to pointer to a buffer in\r
                          which the file or section contents or are returned.\r
    BufferSize        -   BufferSize is a pointer to caller allocated\r
                          UINTN. On input *BufferSize indicates the size\r
                          in bytes of the memory region pointed to by\r
                          Buffer. On output, *BufferSize contains the number\r
                          of bytes required to read the file.\r
    FoundType         -   FoundType is a pointer to a caller allocated\r
                          EFI_FV_FILETYPE that on successful return from Read()\r
                          contains the type of file read.  This output reflects\r
                          the file type irrespective of the value of the\r
                          SectionType input.\r
    FileAttributes    -   FileAttributes is a pointer to a caller allocated\r
                          EFI_FV_FILE_ATTRIBUTES.  On successful return from\r
                          Read(), *FileAttributes contains the attributes of\r
                          the file read.\r
    AuthenticationStatus -  AuthenticationStatus is a pointer to a caller\r
                          allocated UINTN in which the authentication status\r
                          is returned.\r
Returns:\r
    EFI_SUCCESS                   - Successfully read to memory buffer.\r
    EFI_WARN_BUFFER_TOO_SMALL     - Buffer too small.\r
    EFI_NOT_FOUND                 - Not found.\r
    EFI_DEVICE_ERROR              - Device error.\r
    EFI_ACCESS_DENIED             - Could not read.\r
    EFI_INVALID_PARAMETER         - Invalid parameter.\r
    EFI_OUT_OF_RESOURCES          - Not enough buffer to be allocated.\r
\r
--*/\r
{\r
  EFI_STATUS                        Status;\r
  FV_DEVICE                         *FvDevice;\r
  EFI_GUID                          SearchNameGuid;\r
  EFI_FV_FILETYPE                   LocalFoundType;\r
  EFI_FV_FILE_ATTRIBUTES            LocalAttributes;\r
  UINTN                             FileSize;\r
  UINT8                             *SrcPtr;\r
  EFI_FFS_FILE_HEADER               *FfsHeader;\r
  UINTN                             InputBufferSize;\r
  \r
  if (NULL == NameGuid) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  FvDevice = FV_DEVICE_FROM_THIS (This);\r
  \r
\r
  //\r
  // Keep looking until we find the matching NameGuid.\r
  // The Key is really an FfsFileEntry\r
  //\r
  FvDevice->LastKey = 0;\r
  do {\r
    LocalFoundType = 0;\r
    Status = FvGetNextFile (\r
              This,\r
              &FvDevice->LastKey,\r
              &LocalFoundType,\r
              &SearchNameGuid,\r
              &LocalAttributes,\r
              &FileSize\r
              );\r
    if (EFI_ERROR (Status)) {\r
      return EFI_NOT_FOUND;\r
    }\r
  } while (!CompareGuid (&SearchNameGuid, NameGuid));\r
\r
  //\r
  // Get a pointer to the header\r
  //\r
  FfsHeader = FvDevice->LastKey->FfsHeader;\r
\r
  //\r
  // Remember callers buffer size\r
  //\r
  InputBufferSize = *BufferSize;\r
\r
  //\r
  // Calculate return values\r
  //\r
  *FoundType = FfsHeader->Type;\r
  *FileAttributes = FfsAttributes2FvFileAttributes (FfsHeader->Attributes);\r
  *AuthenticationStatus = 0;\r
  *BufferSize = FileSize;\r
\r
  if (Buffer == NULL) {\r
    //\r
    // If Buffer is NULL, we only want to get the information colected so far\r
    //\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Skip over file header\r
  //\r
  SrcPtr = ((UINT8 *)FfsHeader) + sizeof (EFI_FFS_FILE_HEADER);\r
\r
  Status = EFI_SUCCESS;\r
  if (*Buffer == NULL) {\r
    //\r
    // Caller passed in a pointer so allocate buffer for them\r
    //\r
    *Buffer = CoreAllocateBootServicesPool (FileSize);\r
    if (*Buffer == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
  } else if (FileSize > InputBufferSize) {\r
    //\r
    // Callers buffer was not big enough\r
    // \r
    Status = EFI_WARN_BUFFER_TOO_SMALL;\r
    FileSize = InputBufferSize;\r
  }\r
  \r
  //\r
  // Copy data into callers buffer \r
  //\r
  CopyMem (*Buffer, SrcPtr, FileSize);\r
\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
FvReadFileSection (\r
  IN CONST  EFI_FIRMWARE_VOLUME2_PROTOCOL  *This,\r
  IN CONST  EFI_GUID                       *NameGuid,\r
  IN        EFI_SECTION_TYPE               SectionType,\r
  IN        UINTN                          SectionInstance,\r
  IN OUT    VOID                           **Buffer,\r
  IN OUT    UINTN                          *BufferSize,\r
  OUT       UINT32                         *AuthenticationStatus\r
  )\r
/*++\r
\r
  Routine Description:\r
    Locates a section in a given FFS File and\r
    copies it to the supplied buffer (not including section header).\r
\r
  Arguments:\r
    This              -   Indicates the calling context.\r
    NameGuid          -   Pointer to an EFI_GUID, which is the filename.\r
    SectionType       -   Indicates the section type to return.\r
    SectionInstance   -   Indicates which instance of sections with a type of\r
                          SectionType to return.\r
    Buffer            -   Buffer is a pointer to pointer to a buffer in which\r
                          the file or section contents or are returned.\r
    BufferSize        -   BufferSize is a pointer to caller allocated UINTN.\r
    AuthenticationStatus -AuthenticationStatus is a pointer to a caller\r
                          allocated UINT32 in which the authentication status\r
                          is returned.\r
\r
  Returns:\r
    EFI_SUCCESS                     - Successfully read the file section into buffer.\r
    EFI_WARN_BUFFER_TOO_SMALL       - Buffer too small.\r
    EFI_NOT_FOUND                   - Section not found.\r
    EFI_DEVICE_ERROR                - Device error.\r
    EFI_ACCESS_DENIED               - Could not read.\r
    EFI_INVALID_PARAMETER           - Invalid parameter.\r
\r
--*/\r
{\r
  EFI_STATUS                        Status;\r
  FV_DEVICE                         *FvDevice;\r
  EFI_FV_FILETYPE                   FileType;\r
  EFI_FV_FILE_ATTRIBUTES            FileAttributes;\r
  UINTN                             FileSize;\r
  UINT8                             *FileBuffer;\r
  EFI_SECTION_EXTRACTION_PROTOCOL   *Sep;\r
  FFS_FILE_LIST_ENTRY               *FfsEntry;\r
 \r
  if (NULL == NameGuid || Buffer == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  FvDevice = FV_DEVICE_FROM_THIS (This);\r
\r
  //\r
  // Read the whole file into buffer\r
  //\r
  FileBuffer = NULL;\r
  Status = FvReadFile (\r
            This,\r
            NameGuid,\r
            (VOID **)&FileBuffer,\r
            &FileSize,\r
            &FileType,\r
            &FileAttributes,\r
            AuthenticationStatus\r
            );             \r
  //\r
  // Get the last key used by our call to FvReadFile as it is the FfsEntry for this file.\r
  //  \r
  FfsEntry = (FFS_FILE_LIST_ENTRY *)FvDevice->LastKey;\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
  \r
  //\r
  // Check to see that the file actually HAS sections before we go any further.\r
  //\r
  if (FileType == EFI_FV_FILETYPE_RAW) {\r
    Status = EFI_NOT_FOUND;\r
    goto Done;\r
  }\r
\r
  //\r
  // Use FfsEntry to cache Section Extraction Protocol Inforomation\r
  //\r
  if (FfsEntry->StreamHandle == 0) {\r
    //\r
    // Located the protocol\r
    //\r
    Status = CoreLocateProtocol (&gEfiSectionExtractionProtocolGuid, NULL, (VOID **)&Sep);\r
    //\r
    // Section Extraction Protocol is part of Dxe Core so this should never fail\r
    //\r
    ASSERT_EFI_ERROR (Status);\r
\r
    Status = Sep->OpenSectionStream (\r
                    Sep,\r
                    FileSize,\r
                    FileBuffer,\r
                    &FfsEntry->StreamHandle\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      goto Done;\r
    }\r
\r
    FfsEntry->Sep = Sep;\r
  } else {\r
    //\r
    // Get cached copy of Sep\r
    //\r
    Sep = FfsEntry->Sep;\r
  }\r
\r
  //\r
  // If SectionType == 0 We need the whole section stream\r
  //\r
  Status = Sep->GetSection (\r
                  Sep,\r
                            FfsEntry->StreamHandle,\r
                            (SectionType == 0) ? NULL : &SectionType,\r
                            NULL,\r
                            (SectionType == 0) ? 0 : SectionInstance,\r
                            Buffer,\r
                            BufferSize,\r
                            AuthenticationStatus\r
                            );\r
\r
  //\r
  // Close of stream defered to close of FfsHeader list to allow SEP to cache data\r
  //\r
\r
Done:\r
  CoreFreePool (FileBuffer);\r
\r
  return Status;\r
}\r
\r
Commit	Line	Data
28a00297	1	/*++\r
	2	\r
	3	Copyright (c) 2006, Intel Corporation \r
	4	All rights reserved. This program and the accompanying materials \r
	5	are licensed and made available under the terms and conditions of the BSD License \r
	6	which accompanies this distribution. The full text of the license may be found at \r
	7	http://opensource.org/licenses/bsd-license.php \r
	8	\r
	9	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
	10	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
	11	\r
	12	Module Name:\r
	13	\r
	14	FwVolRead.c\r
	15	\r
	16	Abstract:\r
	17	\r
	18	Implements read firmware file\r
	19	\r
	20	--*/\r
	21	\r
	22	#include <DxeMain.h>\r
	23	\r
	24	/*++\r
	25	\r
	26	Required Alignment Alignment Value in FFS Alignment Value in\r
	27	(bytes) Attributes Field Firmware Volume Interfaces\r
	28	1 0 0\r
	29	2 0 1\r
	30	4 0 2\r
	31	8 0 3\r
	32	16 1 4\r
	33	128 2 7\r
	34	512 3 9\r
	35	1 KB 4 10\r
	36	4 KB 5 12\r
	37	32 KB 6 15\r
	38	64 KB 7 16\r
	39	\r
	40	--*/\r
	41	\r
	42	UINT8 mFvAttributes[] = {0, 4, 7, 9, 10, 12, 15, 16}; \r
	43	\r
	44	\r
	45	STATIC\r
	46	EFI_FV_FILE_ATTRIBUTES\r
	47	FfsAttributes2FvFileAttributes (\r
	48	IN EFI_FFS_FILE_ATTRIBUTES FfsAttributes\r
	49	)\r
	50	/*++\r
	51	\r
	52	Routine Description:\r
	53	Convert the FFS File Attributes to FV File Attributes\r
	54	\r
	55	Arguments:\r
	56	FfsAttributes - The attributes of UINT8 type.\r
	57	\r
	58	Returns:\r
	59	The attributes of EFI_FV_FILE_ATTRIBUTES\r
	60	\r
	61	--*/\r
	62	{\r
	63	FfsAttributes = (EFI_FFS_FILE_ATTRIBUTES)((FfsAttributes & FFS_ATTRIB_DATA_ALIGNMENT) >> 3);\r
	64	ASSERT (FfsAttributes < 8);\r
65	\r
66	return (EFI_FV_FILE_ATTRIBUTES) mFvAttributes[FfsAttributes];\r
67	}\r
68	\r
69	\r
70	EFI_STATUS\r
71	EFIAPI\r
72	FvGetNextFile (\r
0c2b5da8	73	IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,\r
	74	IN OUT VOID *Key,\r
	75	IN OUT EFI_FV_FILETYPE *FileType,\r
28a00297	76	OUT EFI_GUID *NameGuid,\r
28a00297	77	OUT EFI_FV_FILE_ATTRIBUTES *Attributes,\r
0c2b5da8	78	OUT UINTN *Size\r
28a00297	79	)\r
	80	/*++\r
	81	\r
	82	Routine Description:\r
	83	Given the input key, search for the next matching file in the volume.\r
	84	\r
	85	Arguments:\r
	86	This - Indicates the calling context.\r
	87	FileType - FileType is a pointer to a caller allocated\r
	88	EFI_FV_FILETYPE. The GetNextFile() API can filter it's\r
	89	search for files based on the value of *FileType input.\r
	90	A *FileType input of 0 causes GetNextFile() to search for\r
	91	files of all types. If a file is found, the file's type\r
	92	is returned in FileType. FileType is not modified if\r
	93	no file is found.\r
	94	Key - Key is a pointer to a caller allocated buffer that\r
	95	contains implementation specific data that is used to\r
	96	track where to begin the search for the next file.\r
	97	The size of the buffer must be at least This->KeySize\r
	98	bytes long. To reinitialize the search and begin from\r
	99	the beginning of the firmware volume, the entire buffer\r
	100	must be cleared to zero. Other than clearing the buffer\r
	101	to initiate a new search, the caller must not modify the\r
	102	data in the buffer between calls to GetNextFile().\r
	103	NameGuid - NameGuid is a pointer to a caller allocated EFI_GUID.\r
	104	If a file is found, the file's name is returned in\r
	105	NameGuid. NameGuid is not modified if no file is\r
	106	found.\r
	107	Attributes - Attributes is a pointer to a caller allocated\r
	108	EFI_FV_FILE_ATTRIBUTES. If a file is found, the file's\r
	109	attributes are returned in Attributes. Attributes is\r
	110	not modified if no file is found.\r
	111	Size - Size is a pointer to a caller allocated UINTN.\r
	112	If a file is found, the file's size is returned in *Size.\r
	113	*Size is not modified if no file is found.\r
	114	\r
	115	Returns:\r
	116	EFI_SUCCESS - Successfully find the file.\r
	117	EFI_DEVICE_ERROR - Device error.\r
	118	EFI_ACCESS_DENIED - Fv could not read.\r
	119	EFI_NOT_FOUND - No matching file found.\r
	120	EFI_INVALID_PARAMETER - Invalid parameter\r
	121	\r
	122	--*/\r
	123	{\r
	124	EFI_STATUS Status;\r
	125	FV_DEVICE *FvDevice;\r
	126	EFI_FV_ATTRIBUTES FvAttributes;\r
	127	EFI_FFS_FILE_HEADER *FfsFileHeader;\r
	128	UINTN *KeyValue;\r
	129	LIST_ENTRY *Link;\r
	130	FFS_FILE_LIST_ENTRY *FfsFileEntry;\r
	131	UINTN FileLength;\r
	132	\r
	133	FvDevice = FV_DEVICE_FROM_THIS (This);\r
	134	\r
	135	Status = FvGetVolumeAttributes (This, &FvAttributes);\r
	136	if (EFI_ERROR (Status)){\r
	137	return Status;\r
	138	}\r
	139	\r
	140	//\r
	141	// Check if read operation is enabled\r
	142	//\r
0c2b5da8	143	if ((FvAttributes & EFI_FV2_READ_STATUS) == 0) {\r
28a00297	144	return EFI_ACCESS_DENIED;\r
	145	}\r
	146	\r
	147	if (*FileType > EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE) {\r
	148	//\r
	149	// File type needs to be in 0 - 0x0B\r
	150	//\r
26fa3b49	151	return EFI_NOT_FOUND;\r
28a00297	152	}\r
	153	\r
	154	KeyValue = (UINTN *)Key;\r
	155	for (;;) {\r
	156	if (*KeyValue == 0) {\r
	157	//\r
	158	// Search for 1st matching file\r
	159	//\r
	160	Link = &FvDevice->FfsFileListHeader;\r
	161	} else {\r
	162	//\r
	163	// Key is pointer to FFsFileEntry, so get next one\r
	164	//\r
	165	Link = (LIST_ENTRY )(KeyValue);\r
	166	}\r
	167	\r
	168	if (Link->ForwardLink == &FvDevice->FfsFileListHeader) {\r
	169	//\r
	170	// Next is end of list so we did not find data\r
	171	//\r
	172	return EFI_NOT_FOUND;\r
	173	}\r
	174	\r
	175	FfsFileEntry = (FFS_FILE_LIST_ENTRY *)Link->ForwardLink;\r
	176	FfsFileHeader = (EFI_FFS_FILE_HEADER *)FfsFileEntry->FfsHeader;\r
	177	\r
	178	//\r
	179	// remember the key\r
	180	//\r
	181	*KeyValue = (UINTN)FfsFileEntry;\r
	182	\r
	183	if (FfsFileHeader->Type == EFI_FV_FILETYPE_FFS_PAD) {\r
	184	//\r
	185	// we ignore pad files\r
	186	//\r
	187	continue;\r
	188	}\r
	189	\r
	190	if (*FileType == 0) {\r
	191	//\r
	192	// Process all file types so we have a match\r
	193	//\r
	194	break;\r
	195	}\r
	196	\r
	197	if (*FileType == FfsFileHeader->Type) {\r
	198	//\r
	199	// Found a matching file type\r
	200	//\r
	201	break;\r
	202	}\r
	203	\r
	204	} \r
	205	\r
	206	//\r
	207	// Return FileType, NameGuid, and Attributes\r
	208	//\r
	209	*FileType = FfsFileHeader->Type;\r
	210	CopyMem (NameGuid, &FfsFileHeader->Name, sizeof (EFI_GUID));\r
	211	*Attributes = FfsAttributes2FvFileAttributes (FfsFileHeader->Attributes);\r
	212	\r
	213	//\r
	214	// Read four bytes out of the 3 byte array and throw out extra data\r
	215	//\r
216	FileLength = (UINT32 )&FfsFileHeader->Size[0] & 0x00FFFFFF;\r
217	\r
218	//\r
219	// we need to substract the header size\r
220	//\r
221	*Size = FileLength - sizeof(EFI_FFS_FILE_HEADER);\r
222	\r
28a00297	223	return EFI_SUCCESS;\r
	224	}\r
	225	\r
	226	\r
	227	EFI_STATUS\r
	228	EFIAPI\r
	229	FvReadFile (\r
0c2b5da8	230	IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,\r
	231	IN CONST EFI_GUID *NameGuid,\r
	232	IN OUT VOID **Buffer,\r
	233	IN OUT UINTN *BufferSize,\r
	234	OUT EFI_FV_FILETYPE *FoundType,\r
	235	OUT EFI_FV_FILE_ATTRIBUTES *FileAttributes,\r
	236	OUT UINT32 *AuthenticationStatus\r
28a00297	237	)\r
	238	/*++\r
	239	\r
	240	Routine Description:\r
	241	Locates a file in the firmware volume and\r
	242	copies it to the supplied buffer.\r
	243	\r
	244	Arguments:\r
	245	This - Indicates the calling context.\r
	246	NameGuid - Pointer to an EFI_GUID, which is the filename.\r
	247	Buffer - Buffer is a pointer to pointer to a buffer in\r
	248	which the file or section contents or are returned.\r
	249	BufferSize - BufferSize is a pointer to caller allocated\r
	250	UINTN. On input *BufferSize indicates the size\r
	251	in bytes of the memory region pointed to by\r
	252	Buffer. On output, *BufferSize contains the number\r
	253	of bytes required to read the file.\r
	254	FoundType - FoundType is a pointer to a caller allocated\r
	255	EFI_FV_FILETYPE that on successful return from Read()\r
	256	contains the type of file read. This output reflects\r
	257	the file type irrespective of the value of the\r
	258	SectionType input.\r
	259	FileAttributes - FileAttributes is a pointer to a caller allocated\r
	260	EFI_FV_FILE_ATTRIBUTES. On successful return from\r
	261	Read(), *FileAttributes contains the attributes of\r
	262	the file read.\r
	263	AuthenticationStatus - AuthenticationStatus is a pointer to a caller\r
	264	allocated UINTN in which the authentication status\r
	265	is returned.\r
	266	Returns:\r
	267	EFI_SUCCESS - Successfully read to memory buffer.\r
	268	EFI_WARN_BUFFER_TOO_SMALL - Buffer too small.\r
	269	EFI_NOT_FOUND - Not found.\r
	270	EFI_DEVICE_ERROR - Device error.\r
	271	EFI_ACCESS_DENIED - Could not read.\r
	272	EFI_INVALID_PARAMETER - Invalid parameter.\r
	273	EFI_OUT_OF_RESOURCES - Not enough buffer to be allocated.\r
	274	\r
	275	--*/\r
	276	{\r
	277	EFI_STATUS Status;\r
	278	FV_DEVICE *FvDevice;\r
	279	EFI_GUID SearchNameGuid;\r
	280	EFI_FV_FILETYPE LocalFoundType;\r
	281	EFI_FV_FILE_ATTRIBUTES LocalAttributes;\r
	282	UINTN FileSize;\r
	283	UINT8 *SrcPtr;\r
	284	EFI_FFS_FILE_HEADER *FfsHeader;\r
	285	UINTN InputBufferSize;\r
	286	\r
	287	if (NULL == NameGuid) {\r
	288	return EFI_INVALID_PARAMETER;\r
	289	}\r
	290	\r
	291	FvDevice = FV_DEVICE_FROM_THIS (This);\r
	292	\r
	293	\r
	294	//\r
	295	// Keep looking until we find the matching NameGuid.\r
	296	// The Key is really an FfsFileEntry\r
	297	//\r
	298	FvDevice->LastKey = 0;\r
	299	do {\r
	300	LocalFoundType = 0;\r
301	Status = FvGetNextFile (\r
302	This,\r
303	&FvDevice->LastKey,\r
304	&LocalFoundType,\r
305	&SearchNameGuid,\r
306	&LocalAttributes,\r
307	&FileSize\r
308	);\r
309	if (EFI_ERROR (Status)) {\r
310	return EFI_NOT_FOUND;\r
311	}\r
312	} while (!CompareGuid (&SearchNameGuid, NameGuid));\r
313	\r
314	//\r
315	// Get a pointer to the header\r
316	//\r
317	FfsHeader = FvDevice->LastKey->FfsHeader;\r
318	\r
319	//\r
320	// Remember callers buffer size\r
321	//\r
322	InputBufferSize = *BufferSize;\r
323	\r
324	//\r
325	// Calculate return values\r
326	//\r
327	*FoundType = FfsHeader->Type;\r
328	*FileAttributes = FfsAttributes2FvFileAttributes (FfsHeader->Attributes);\r
329	*AuthenticationStatus = 0;\r
330	*BufferSize = FileSize;\r
331	\r
332	if (Buffer == NULL) {\r
333	//\r
334	// If Buffer is NULL, we only want to get the information colected so far\r
335	//\r
336	return EFI_SUCCESS;\r
337	}\r
338	\r
339	//\r
340	// Skip over file header\r
341	//\r
342	SrcPtr = ((UINT8 *)FfsHeader) + sizeof (EFI_FFS_FILE_HEADER);\r
343	\r
344	Status = EFI_SUCCESS;\r
345	if (*Buffer == NULL) {\r
346	//\r
347	// Caller passed in a pointer so allocate buffer for them\r
348	//\r
349	*Buffer = CoreAllocateBootServicesPool (FileSize);\r
350	if (*Buffer == NULL) {\r
351	return EFI_OUT_OF_RESOURCES;\r
352	}\r
353	} else if (FileSize > InputBufferSize) {\r
354	//\r
355	// Callers buffer was not big enough\r
356	// \r
357	Status = EFI_WARN_BUFFER_TOO_SMALL;\r
358	FileSize = InputBufferSize;\r
359	}\r
360	\r
361	//\r
362	// Copy data into callers buffer \r
363	//\r
364	CopyMem (*Buffer, SrcPtr, FileSize);\r
365	\r
366	return Status;\r
367	}\r
368	\r
369	\r
370	EFI_STATUS\r
371	EFIAPI\r
372	FvReadFileSection (\r
0c2b5da8	373	IN CONST EFI_FIRMWARE_VOLUME2_PROTOCOL *This,\r
	374	IN CONST EFI_GUID *NameGuid,\r
	375	IN EFI_SECTION_TYPE SectionType,\r
	376	IN UINTN SectionInstance,\r
	377	IN OUT VOID **Buffer,\r
	378	IN OUT UINTN *BufferSize,\r
	379	OUT UINT32 *AuthenticationStatus\r
28a00297	380	)\r
	381	/*++\r
	382	\r
	383	Routine Description:\r
	384	Locates a section in a given FFS File and\r
	385	copies it to the supplied buffer (not including section header).\r
	386	\r
	387	Arguments:\r
	388	This - Indicates the calling context.\r
	389	NameGuid - Pointer to an EFI_GUID, which is the filename.\r
	390	SectionType - Indicates the section type to return.\r
	391	SectionInstance - Indicates which instance of sections with a type of\r
	392	SectionType to return.\r
	393	Buffer - Buffer is a pointer to pointer to a buffer in which\r
	394	the file or section contents or are returned.\r
	395	BufferSize - BufferSize is a pointer to caller allocated UINTN.\r
	396	AuthenticationStatus -AuthenticationStatus is a pointer to a caller\r
	397	allocated UINT32 in which the authentication status\r
	398	is returned.\r
	399	\r
	400	Returns:\r
	401	EFI_SUCCESS - Successfully read the file section into buffer.\r
	402	EFI_WARN_BUFFER_TOO_SMALL - Buffer too small.\r
	403	EFI_NOT_FOUND - Section not found.\r
	404	EFI_DEVICE_ERROR - Device error.\r
	405	EFI_ACCESS_DENIED - Could not read.\r
	406	EFI_INVALID_PARAMETER - Invalid parameter.\r
	407	\r
	408	--*/\r
	409	{\r
	410	EFI_STATUS Status;\r
	411	FV_DEVICE *FvDevice;\r
	412	EFI_FV_FILETYPE FileType;\r
	413	EFI_FV_FILE_ATTRIBUTES FileAttributes;\r
	414	UINTN FileSize;\r
	415	UINT8 *FileBuffer;\r
	416	EFI_SECTION_EXTRACTION_PROTOCOL *Sep;\r
	417	FFS_FILE_LIST_ENTRY *FfsEntry;\r
	418	\r
	419	if (NULL == NameGuid \|\| Buffer == NULL) {\r
	420	return EFI_INVALID_PARAMETER;\r
	421	}\r
	422	\r
	423	FvDevice = FV_DEVICE_FROM_THIS (This);\r
	424	\r
	425	//\r
	426	// Read the whole file into buffer\r
	427	//\r
	428	FileBuffer = NULL;\r
	429	Status = FvReadFile (\r
	430	This,\r
	431	NameGuid,\r
	432	(VOID **)&FileBuffer,\r
	433	&FileSize,\r
	434	&FileType,\r
	435	&FileAttributes,\r
	436	AuthenticationStatus\r
	437	); \r
	438	//\r
	439	// Get the last key used by our call to FvReadFile as it is the FfsEntry for this file.\r
	440	// \r
	441	FfsEntry = (FFS_FILE_LIST_ENTRY *)FvDevice->LastKey;\r
	442	\r
	443	if (EFI_ERROR (Status)) {\r
444	return Status;\r
445	}\r
446	\r
447	//\r
448	// Check to see that the file actually HAS sections before we go any further.\r
449	//\r
450	if (FileType == EFI_FV_FILETYPE_RAW) {\r
451	Status = EFI_NOT_FOUND;\r
452	goto Done;\r
453	}\r
454	\r
455	//\r
456	// Use FfsEntry to cache Section Extraction Protocol Inforomation\r
457	//\r
458	if (FfsEntry->StreamHandle == 0) {\r
459	//\r
460	// Located the protocol\r
461	//\r
462	Status = CoreLocateProtocol (&gEfiSectionExtractionProtocolGuid, NULL, (VOID **)&Sep);\r
463	//\r
464	// Section Extraction Protocol is part of Dxe Core so this should never fail\r
465	//\r
466	ASSERT_EFI_ERROR (Status);\r
467	\r
468	Status = Sep->OpenSectionStream (\r
469	Sep,\r
470	FileSize,\r
471	FileBuffer,\r
472	&FfsEntry->StreamHandle\r
473	);\r
474	if (EFI_ERROR (Status)) {\r
475	goto Done;\r
476	}\r
477	\r
478	FfsEntry->Sep = Sep;\r
479	} else {\r
480	//\r
481	// Get cached copy of Sep\r
482	//\r
483	Sep = FfsEntry->Sep;\r
484	}\r
485	\r
486	//\r
487	// If SectionType == 0 We need the whole section stream\r
488	//\r
489	Status = Sep->GetSection (\r
490	Sep,\r
491	FfsEntry->StreamHandle,\r
492	(SectionType == 0) ? NULL : &SectionType,\r
493	NULL,\r
494	(SectionType == 0) ? 0 : SectionInstance,\r
495	Buffer,\r
496	BufferSize,\r
497	AuthenticationStatus\r
498	);\r
499	\r
500	//\r
501	// Close of stream defered to close of FfsHeader list to allow SEP to cache data\r
502	//\r
503	\r
504	Done:\r
505	CoreFreePool (FileBuffer);\r
506	\r
507	return Status;\r
508	}\r
509	\r