[mirror_edk2.git] / EdkModulePkg / 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         EFI_FIRMWARE_VOLUME_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_FV_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_INVALID_PARAMETER;\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
  if (FfsFileHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {\r
    //\r
    // If tail is present substract it's size;\r
    //\r
    *Size -= sizeof(EFI_FFS_FILE_TAIL);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
FvReadFile (\r
  IN     EFI_FIRMWARE_VOLUME_PROTOCOL   *This,\r
  IN     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     EFI_FIRMWARE_VOLUME_PROTOCOL   *This,\r
  IN     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
878ddf1f	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
73	IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,\r
74	IN OUT VOID *Key,\r
75	IN OUT EFI_FV_FILETYPE *FileType,\r
76	OUT EFI_GUID *NameGuid,\r
77	OUT EFI_FV_FILE_ATTRIBUTES *Attributes,\r
78	OUT UINTN *Size\r
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
143	if ((FvAttributes & EFI_FV_READ_STATUS) == 0) {\r
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
151	return EFI_INVALID_PARAMETER;\r
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
223	if (FfsFileHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {\r
224	//\r
225	// If tail is present substract it's size;\r
226	//\r
227	*Size -= sizeof(EFI_FFS_FILE_TAIL);\r
228	}\r
229	\r
230	return EFI_SUCCESS;\r
231	}\r
232	\r
233	\r
234	EFI_STATUS\r
235	EFIAPI\r
236	FvReadFile (\r
237	IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,\r
238	IN EFI_GUID *NameGuid,\r
239	IN OUT VOID **Buffer,\r
240	IN OUT UINTN *BufferSize,\r
241	OUT EFI_FV_FILETYPE *FoundType,\r
242	OUT EFI_FV_FILE_ATTRIBUTES *FileAttributes,\r
243	OUT UINT32 *AuthenticationStatus\r
244	)\r
245	/*++\r
246	\r
247	Routine Description:\r
248	Locates a file in the firmware volume and\r
249	copies it to the supplied buffer.\r
250	\r
251	Arguments:\r
252	This - Indicates the calling context.\r
253	NameGuid - Pointer to an EFI_GUID, which is the filename.\r
254	Buffer - Buffer is a pointer to pointer to a buffer in\r
255	which the file or section contents or are returned.\r
256	BufferSize - BufferSize is a pointer to caller allocated\r
257	UINTN. On input *BufferSize indicates the size\r
258	in bytes of the memory region pointed to by\r
259	Buffer. On output, *BufferSize contains the number\r
260	of bytes required to read the file.\r
261	FoundType - FoundType is a pointer to a caller allocated\r
262	EFI_FV_FILETYPE that on successful return from Read()\r
263	contains the type of file read. This output reflects\r
264	the file type irrespective of the value of the\r
265	SectionType input.\r
266	FileAttributes - FileAttributes is a pointer to a caller allocated\r
267	EFI_FV_FILE_ATTRIBUTES. On successful return from\r
268	Read(), *FileAttributes contains the attributes of\r
269	the file read.\r
270	AuthenticationStatus - AuthenticationStatus is a pointer to a caller\r
271	allocated UINTN in which the authentication status\r
272	is returned.\r
273	Returns:\r
274	EFI_SUCCESS - Successfully read to memory buffer.\r
275	EFI_WARN_BUFFER_TOO_SMALL - Buffer too small.\r
276	EFI_NOT_FOUND - Not found.\r
277	EFI_DEVICE_ERROR - Device error.\r
278	EFI_ACCESS_DENIED - Could not read.\r
279	EFI_INVALID_PARAMETER - Invalid parameter.\r
280	EFI_OUT_OF_RESOURCES - Not enough buffer to be allocated.\r
281	\r
282	--*/\r
283	{\r
284	EFI_STATUS Status;\r
285	FV_DEVICE *FvDevice;\r
286	EFI_GUID SearchNameGuid;\r
287	EFI_FV_FILETYPE LocalFoundType;\r
288	EFI_FV_FILE_ATTRIBUTES LocalAttributes;\r
289	UINTN FileSize;\r
290	UINT8 *SrcPtr;\r
291	EFI_FFS_FILE_HEADER *FfsHeader;\r
292	UINTN InputBufferSize;\r
293	\r
294	if (NULL == NameGuid) {\r
295	return EFI_INVALID_PARAMETER;\r
296	}\r
297	\r
298	FvDevice = FV_DEVICE_FROM_THIS (This);\r
299	\r
300	\r
301	//\r
302	// Keep looking until we find the matching NameGuid.\r
303	// The Key is really an FfsFileEntry\r
304	//\r
305	FvDevice->LastKey = 0;\r
306	do {\r
307	LocalFoundType = 0;\r
308	Status = FvGetNextFile (\r
309	This,\r
310	&FvDevice->LastKey,\r
311	&LocalFoundType,\r
312	&SearchNameGuid,\r
313	&LocalAttributes,\r
314	&FileSize\r
315	);\r
316	if (EFI_ERROR (Status)) {\r
317	return EFI_NOT_FOUND;\r
318	}\r
319	} while (!CompareGuid (&SearchNameGuid, NameGuid));\r
320	\r
321	//\r
322	// Get a pointer to the header\r
323	//\r
324	FfsHeader = FvDevice->LastKey->FfsHeader;\r
325	\r
326	//\r
327	// Remember callers buffer size\r
328	//\r
329	InputBufferSize = *BufferSize;\r
330	\r
331	//\r
332	// Calculate return values\r
333	//\r
334	*FoundType = FfsHeader->Type;\r
335	*FileAttributes = FfsAttributes2FvFileAttributes (FfsHeader->Attributes);\r
336	*AuthenticationStatus = 0;\r
337	*BufferSize = FileSize;\r
338	\r
339	if (Buffer == NULL) {\r
340	//\r
341	// If Buffer is NULL, we only want to get the information colected so far\r
342	//\r
343	return EFI_SUCCESS;\r
344	}\r
345	\r
346	//\r
347	// Skip over file header\r
348	//\r
349	SrcPtr = ((UINT8 *)FfsHeader) + sizeof (EFI_FFS_FILE_HEADER);\r
350	\r
351	Status = EFI_SUCCESS;\r
352	if (*Buffer == NULL) {\r
353	//\r
354	// Caller passed in a pointer so allocate buffer for them\r
355	//\r
356	*Buffer = CoreAllocateBootServicesPool (FileSize);\r
357	if (*Buffer == NULL) {\r
358	return EFI_OUT_OF_RESOURCES;\r
359	}\r
360	} else if (FileSize > InputBufferSize) {\r
361	//\r
362	// Callers buffer was not big enough\r
363	// \r
364	Status = EFI_WARN_BUFFER_TOO_SMALL;\r
365	FileSize = InputBufferSize;\r
366	}\r
367	\r
368	//\r
369	// Copy data into callers buffer \r
370	//\r
371	CopyMem (*Buffer, SrcPtr, FileSize);\r
372	\r
373	return Status;\r
374	}\r
375	\r
376	\r
377	EFI_STATUS\r
378	EFIAPI\r
379	FvReadFileSection (\r
380	IN EFI_FIRMWARE_VOLUME_PROTOCOL *This,\r
381	IN EFI_GUID *NameGuid,\r
382	IN EFI_SECTION_TYPE SectionType,\r
383	IN UINTN SectionInstance,\r
384	IN OUT VOID **Buffer,\r
385	IN OUT UINTN *BufferSize,\r
386	OUT UINT32 *AuthenticationStatus\r
387	)\r
388	/*++\r
389	\r
390	Routine Description:\r
391	Locates a section in a given FFS File and\r
392	copies it to the supplied buffer (not including section header).\r
393	\r
394	Arguments:\r
395	This - Indicates the calling context.\r
396	NameGuid - Pointer to an EFI_GUID, which is the filename.\r
397	SectionType - Indicates the section type to return.\r
398	SectionInstance - Indicates which instance of sections with a type of\r
399	SectionType to return.\r
400	Buffer - Buffer is a pointer to pointer to a buffer in which\r
401	the file or section contents or are returned.\r
402	BufferSize - BufferSize is a pointer to caller allocated UINTN.\r
403	AuthenticationStatus -AuthenticationStatus is a pointer to a caller\r
404	allocated UINT32 in which the authentication status\r
405	is returned.\r
406	\r
407	Returns:\r
408	EFI_SUCCESS - Successfully read the file section into buffer.\r
409	EFI_WARN_BUFFER_TOO_SMALL - Buffer too small.\r
410	EFI_NOT_FOUND - Section not found.\r
411	EFI_DEVICE_ERROR - Device error.\r
412	EFI_ACCESS_DENIED - Could not read.\r
413	EFI_INVALID_PARAMETER - Invalid parameter.\r
414	\r
415	--*/\r
416	{\r
417	EFI_STATUS Status;\r
418	FV_DEVICE *FvDevice;\r
419	EFI_FV_FILETYPE FileType;\r
420	EFI_FV_FILE_ATTRIBUTES FileAttributes;\r
421	UINTN FileSize;\r
422	UINT8 *FileBuffer;\r
423	EFI_SECTION_EXTRACTION_PROTOCOL *Sep;\r
424	FFS_FILE_LIST_ENTRY *FfsEntry;\r
425	\r
426	if (NULL == NameGuid \|\| Buffer == NULL) {\r
427	return EFI_INVALID_PARAMETER;\r
428	}\r
429	\r
430	FvDevice = FV_DEVICE_FROM_THIS (This);\r
431	\r
432	//\r
433	// Read the whole file into buffer\r
434	//\r
435	FileBuffer = NULL;\r
436	Status = FvReadFile (\r
437	This,\r
438	NameGuid,\r
439	(VOID **)&FileBuffer,\r
440	&FileSize,\r
441	&FileType,\r
442	&FileAttributes,\r
443	AuthenticationStatus\r
444	); \r
445	//\r
446	// Get the last key used by our call to FvReadFile as it is the FfsEntry for this file.\r
447	// \r
448	FfsEntry = (FFS_FILE_LIST_ENTRY *)FvDevice->LastKey;\r
449	\r
450	if (EFI_ERROR (Status)) {\r
451	return Status;\r
452	}\r
453	\r
454	//\r
455	// Check to see that the file actually HAS sections before we go any further.\r
456	//\r
457	if (FileType == EFI_FV_FILETYPE_RAW) {\r
458	Status = EFI_NOT_FOUND;\r
459	goto Done;\r
460	}\r
461	\r
462	//\r
463	// Use FfsEntry to cache Section Extraction Protocol Inforomation\r
464	//\r
465	if (FfsEntry->StreamHandle == 0) {\r
466	//\r
467	// Located the protocol\r
468	//\r
469	Status = CoreLocateProtocol (&gEfiSectionExtractionProtocolGuid, NULL, (VOID **)&Sep);\r
470	//\r
471	// Section Extraction Protocol is part of Dxe Core so this should never fail\r
472	//\r
473	ASSERT_EFI_ERROR (Status);\r
474	\r
475	Status = Sep->OpenSectionStream (\r
476	Sep,\r
477	FileSize,\r
478	FileBuffer,\r
479	&FfsEntry->StreamHandle\r
480	);\r
481	if (EFI_ERROR (Status)) {\r
482	goto Done;\r
483	}\r
484	\r
485	FfsEntry->Sep = Sep;\r
486	} else {\r
487	//\r
488	// Get cached copy of Sep\r
489	//\r
490	Sep = FfsEntry->Sep;\r
491	}\r
492	\r
493	//\r
494	// If SectionType == 0 We need the whole section stream\r
495	//\r
496	Status = Sep->GetSection (\r
497	Sep,\r
498	FfsEntry->StreamHandle,\r
499	(SectionType == 0) ? NULL : &SectionType,\r
500	NULL,\r
501	(SectionType == 0) ? 0 : SectionInstance,\r
502	Buffer,\r
503	BufferSize,\r
504	AuthenticationStatus\r
505	);\r
506	\r
507	//\r
508	// Close of stream defered to close of FfsHeader list to allow SEP to cache data\r
509	//\r
510	\r
511	Done:\r
512	CoreFreePool (FileBuffer);\r
513	\r
514	return Status;\r
515	}\r
516	\r