[mirror_edk2.git] / StandaloneMmPkg / Library / FvLib / FvLib.c

/** @file\r
\r
Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
Copyright (c) 2016 - 2018, ARM Limited. All rights reserved.<BR>\r
\r
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 <Library/FvLib.h>\r
\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
\r
#define GET_OCCUPIED_SIZE(ActualSize, Alignment) \\r
  (ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))\r
\r
/**\r
  Returns the highest bit set of the State field\r
\r
  @param ErasePolarity   Erase Polarity  as defined by EFI_FVB_ERASE_POLARITY\r
                         in the Attributes field.\r
  @param FfsHeader       Pointer to FFS File Header.\r
\r
  @return the highest bit in the State field\r
**/\r
EFI_FFS_FILE_STATE\r
GetFileState (\r
  IN UINT8                ErasePolarity,\r
  IN EFI_FFS_FILE_HEADER  *FfsHeader\r
  )\r
{\r
  EFI_FFS_FILE_STATE  FileState;\r
  EFI_FFS_FILE_STATE  HighestBit;\r
\r
  FileState = FfsHeader->State;\r
\r
  if (ErasePolarity != 0) {\r
    FileState = (EFI_FFS_FILE_STATE)~FileState;\r
  }\r
\r
  HighestBit = 0x80;\r
  while (HighestBit != 0 && (HighestBit & FileState) == 0) {\r
    HighestBit >>= 1;\r
  }\r
\r
  return HighestBit;\r
}\r
\r
/**\r
  Calculates the checksum of the header of a file.\r
\r
  @param FileHeader       Pointer to FFS File Header.\r
\r
  @return Checksum of the header.\r
**/\r
UINT8\r
CalculateHeaderChecksum (\r
  IN EFI_FFS_FILE_HEADER  *FileHeader\r
  )\r
{\r
  UINT8 *ptr;\r
  UINTN Index;\r
  UINT8 Sum;\r
\r
  Sum = 0;\r
  ptr = (UINT8 *) FileHeader;\r
\r
  for (Index = 0; Index < sizeof (EFI_FFS_FILE_HEADER) - 3; Index += 4) {\r
    Sum = (UINT8) (Sum + ptr[Index]);\r
    Sum = (UINT8) (Sum + ptr[Index + 1]);\r
    Sum = (UINT8) (Sum + ptr[Index + 2]);\r
    Sum = (UINT8) (Sum + ptr[Index + 3]);\r
  }\r
\r
  for (; Index < sizeof (EFI_FFS_FILE_HEADER); Index++) {\r
    Sum = (UINT8) (Sum + ptr[Index]);\r
  }\r
  //\r
  // State field (since this indicates the different state of file).\r
  //\r
  Sum = (UINT8) (Sum - FileHeader->State);\r
  //\r
  // Checksum field of the file is not part of the header checksum.\r
  //\r
  Sum = (UINT8) (Sum - FileHeader->IntegrityCheck.Checksum.File);\r
\r
  return Sum;\r
}\r
\r
/**\r
  Given the input file pointer, search for the next matching file in the\r
  FFS volume as defined by SearchType. The search starts from FileHeader inside\r
  the Firmware Volume defined by FwVolHeader.\r
\r
  @param  SearchType  Filter to find only files of this type.\r
                      Type EFI_FV_FILETYPE_ALL causes no filtering to be done.\r
  @param  FwVolHeader Pointer to the FV header of the volume to search.\r
                      This parameter must point to a valid FFS volume.\r
  @param  FileHeader  Pointer to the current file from which to begin searching.\r
                      This pointer will be updated upon return to reflect the file found.\r
\r
  @retval EFI_NOT_FOUND  No files matching the search criteria were found\r
  @retval EFI_SUCCESS\r
**/\r
EFI_STATUS\r
EFIAPI\r
FfsFindNextFile (\r
  IN EFI_FV_FILETYPE             SearchType,\r
  IN EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader,\r
  IN OUT EFI_FFS_FILE_HEADER     **FileHeader\r
  )\r
{\r
  EFI_FIRMWARE_VOLUME_EXT_HEADER *FvExtHeader;\r
\r
  EFI_FFS_FILE_HEADER *FfsFileHeader;\r
  UINT32              FileLength;\r
  UINT32              FileOccupiedSize;\r
  UINT32              FileOffset;\r
  UINT64              FvLength;\r
  UINT8               ErasePolarity;\r
  UINT8               FileState;\r
\r
  FvLength = FwVolHeader->FvLength;\r
  if (FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) {\r
    ErasePolarity = 1;\r
  } else {\r
    ErasePolarity = 0;\r
  }\r
  //\r
  // If FileHeader is not specified (NULL) start with the first file in the\r
  // firmware volume.  Otherwise, start from the FileHeader.\r
  //\r
  if (*FileHeader == NULL) {\r
\r
    if (FwVolHeader->ExtHeaderOffset != 0) {\r
\r
      FvExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)((UINT8 *)FwVolHeader +\r
                                                       FwVolHeader->ExtHeaderOffset);\r
\r
      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FvExtHeader +\r
                                              FvExtHeader->ExtHeaderSize);\r
\r
    } else {\r
\r
      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FwVolHeader +\r
                                              FwVolHeader->HeaderLength);\r
\r
    }\r
\r
    FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINTN)FwVolHeader +\r
                                            ALIGN_VALUE((UINTN)FfsFileHeader -\r
                                                        (UINTN)FwVolHeader, 8));\r
  } else {\r
    //\r
    // Length is 24 bits wide so mask upper 8 bits\r
    // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.\r
    //\r
    FileLength        = FFS_FILE_SIZE(*FileHeader);\r
    FileOccupiedSize  = GET_OCCUPIED_SIZE (FileLength, 8);\r
    FfsFileHeader     = (EFI_FFS_FILE_HEADER *) ((UINT8 *) *FileHeader + FileOccupiedSize);\r
  }\r
\r
  FileOffset = (UINT32) ((UINT8 *) FfsFileHeader - (UINT8 *) FwVolHeader);\r
\r
  while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {\r
    //\r
    // Get FileState which is the highest bit of the State\r
    //\r
    FileState = GetFileState (ErasePolarity, FfsFileHeader);\r
\r
    switch (FileState) {\r
\r
    case EFI_FILE_HEADER_INVALID:\r
      FileOffset += sizeof (EFI_FFS_FILE_HEADER);\r
      FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER));\r
      break;\r
\r
    case EFI_FILE_DATA_VALID:\r
    case EFI_FILE_MARKED_FOR_UPDATE:\r
      if (CalculateHeaderChecksum (FfsFileHeader) == 0) {\r
        FileLength        = FFS_FILE_SIZE(FfsFileHeader);\r
        FileOccupiedSize  = GET_OCCUPIED_SIZE (FileLength, 8);\r
\r
        if ((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) {\r
\r
          *FileHeader = FfsFileHeader;\r
\r
          return EFI_SUCCESS;\r
        }\r
\r
        FileOffset += FileOccupiedSize;\r
        FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize);\r
      } else {\r
        return EFI_NOT_FOUND;\r
      }\r
      break;\r
\r
    case EFI_FILE_DELETED:\r
      FileLength        = FFS_FILE_SIZE(FfsFileHeader);\r
      FileOccupiedSize  = GET_OCCUPIED_SIZE (FileLength, 8);\r
      FileOffset += FileOccupiedSize;\r
      FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize);\r
      break;\r
\r
    default:\r
      return EFI_NOT_FOUND;\r
\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
/**\r
  Locates a section within a series of sections\r
  with the specified section type.\r
\r
  @param[in]   Sections        The sections to search\r
  @param[in]   SizeOfSections  Total size of all sections\r
  @param[in]   SectionType     The section type to locate\r
  @param[out]  FoundSection    The FFS section if found\r
\r
  @retval EFI_SUCCESS           The file and section was found\r
  @retval EFI_NOT_FOUND         The file and section was not found\r
  @retval EFI_VOLUME_CORRUPTED  The firmware volume was corrupted\r
**/\r
EFI_STATUS\r
EFIAPI\r
FindFfsSectionInSections (\r
  IN  VOID                             *Sections,\r
  IN  UINTN                            SizeOfSections,\r
  IN  EFI_SECTION_TYPE                 SectionType,\r
  OUT EFI_COMMON_SECTION_HEADER        **FoundSection\r
  )\r
{\r
  EFI_PHYSICAL_ADDRESS        CurrentAddress;\r
  UINT32                      Size;\r
  EFI_PHYSICAL_ADDRESS        EndOfSections;\r
  EFI_COMMON_SECTION_HEADER   *Section;\r
  EFI_PHYSICAL_ADDRESS        EndOfSection;\r
\r
  //\r
  // Loop through the FFS file sections\r
  //\r
  EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN) Sections;\r
  EndOfSections = EndOfSection + SizeOfSections;\r
  for (;;) {\r
    if (EndOfSection == EndOfSections) {\r
      break;\r
    }\r
    CurrentAddress = EndOfSection;\r
\r
    Section = (EFI_COMMON_SECTION_HEADER*)(UINTN) CurrentAddress;\r
\r
    Size = SECTION_SIZE (Section);\r
    if (Size < sizeof (*Section)) {\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
\r
    EndOfSection = CurrentAddress + Size;\r
    if (EndOfSection > EndOfSections) {\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
    Size = GET_OCCUPIED_SIZE (Size, 4);\r
\r
    //\r
    // Look for the requested section type\r
    //\r
    if (Section->Type == SectionType) {\r
      *FoundSection = Section;\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
/**\r
  Given the input file pointer, search for the next matching section in the\r
  FFS volume.\r
\r
  @param  SearchType    Filter to find only sections of this type.\r
  @param  FfsFileHeader Pointer to the current file to search.\r
  @param  SectionHeader Pointer to the Section matching SectionType in FfsFileHeader.\r
                        NULL if section not found\r
\r
  @retval  EFI_NOT_FOUND  No files matching the search criteria were found\r
  @retval  EFI_SUCCESS\r
**/\r
EFI_STATUS\r
EFIAPI\r
FfsFindSection (\r
  IN EFI_SECTION_TYPE              SectionType,\r
  IN EFI_FFS_FILE_HEADER           *FfsFileHeader,\r
  IN OUT EFI_COMMON_SECTION_HEADER **SectionHeader\r
  )\r
{\r
  UINT32                    FileSize;\r
  EFI_COMMON_SECTION_HEADER *Section;\r
  EFI_STATUS                Status;\r
\r
  //\r
  // Size is 24 bits wide so mask upper 8 bits.\r
  //    Does not include FfsFileHeader header size\r
  // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.\r
  //\r
  Section   = (EFI_COMMON_SECTION_HEADER *) (FfsFileHeader + 1);\r
  FileSize  = FFS_FILE_SIZE(FfsFileHeader);\r
  FileSize -= sizeof (EFI_FFS_FILE_HEADER);\r
\r
  Status = FindFfsSectionInSections (\r
             Section,\r
             FileSize,\r
             SectionType,\r
             SectionHeader\r
             );\r
  return Status;\r
}\r
\r
/**\r
  Given the input file pointer, search for the next matching section in the\r
  FFS volume.\r
\r
  @param  SearchType      Filter to find only sections of this type.\r
  @param  FfsFileHeader   Pointer to the current file to search.\r
  @param  SectionData     Pointer to the Section matching SectionType in FfsFileHeader.\r
                          NULL if section not found\r
  @param  SectionDataSize The size of SectionData\r
\r
  @retval  EFI_NOT_FOUND  No files matching the search criteria were found\r
  @retval  EFI_SUCCESS\r
**/\r
EFI_STATUS\r
EFIAPI\r
FfsFindSectionData (\r
  IN EFI_SECTION_TYPE      SectionType,\r
  IN EFI_FFS_FILE_HEADER   *FfsFileHeader,\r
  IN OUT VOID              **SectionData,\r
  IN OUT UINTN             *SectionDataSize\r
  )\r
{\r
  UINT32                    FileSize;\r
  EFI_COMMON_SECTION_HEADER *Section;\r
  UINT32                    SectionLength;\r
  UINT32                    ParsedLength;\r
\r
  //\r
  // Size is 24 bits wide so mask upper 8 bits.\r
  // Does not include FfsFileHeader header size\r
  // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.\r
  //\r
  Section   = (EFI_COMMON_SECTION_HEADER *) (FfsFileHeader + 1);\r
  FileSize  = FFS_FILE_SIZE(FfsFileHeader);\r
  FileSize -= sizeof (EFI_FFS_FILE_HEADER);\r
\r
  *SectionData  = NULL;\r
  ParsedLength  = 0;\r
  while (ParsedLength < FileSize) {\r
    if (Section->Type == SectionType) {\r
      *SectionData = (VOID *) (Section + 1);\r
      *SectionDataSize = SECTION_SIZE(Section);\r
      return EFI_SUCCESS;\r
    }\r
    //\r
    // Size is 24 bits wide so mask upper 8 bits.\r
    // SectionLength is adjusted it is 4 byte aligned.\r
    // Go to the next section\r
    //\r
    SectionLength = SECTION_SIZE(Section);\r
    SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);\r
\r
    ParsedLength += SectionLength;\r
    Section = (EFI_COMMON_SECTION_HEADER *) ((UINT8 *) Section + SectionLength);\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
Commit	Line	Data
e85162ac SV	1	/** @file\r
	2	\r
	3	Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
	4	Copyright (c) 2016 - 2018, ARM Limited. All rights reserved.<BR>\r
	5	\r
	6	This program and the accompanying materials\r
	7	are licensed and made available under the terms and conditions of the BSD License\r
	8	which accompanies this distribution. The full text of the license may be found at\r
	9	http://opensource.org/licenses/bsd-license.php\r
	10	\r
	11	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	12	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	13	\r
	14	**/\r
	15	\r
	16	#include <Library/FvLib.h>\r
	17	\r
	18	#include <Library/BaseLib.h>\r
	19	#include <Library/BaseMemoryLib.h>\r
	20	#include <Library/DebugLib.h>\r
	21	\r
	22	#define GET_OCCUPIED_SIZE(ActualSize, Alignment) \\r
	23	(ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))\r
	24	\r
	25	/**\r
	26	Returns the highest bit set of the State field\r
	27	\r
	28	@param ErasePolarity Erase Polarity as defined by EFI_FVB_ERASE_POLARITY\r
	29	in the Attributes field.\r
	30	@param FfsHeader Pointer to FFS File Header.\r
	31	\r
	32	@return the highest bit in the State field\r
	33	**/\r
	34	EFI_FFS_FILE_STATE\r
	35	GetFileState (\r
	36	IN UINT8 ErasePolarity,\r
	37	IN EFI_FFS_FILE_HEADER *FfsHeader\r
	38	)\r
	39	{\r
	40	EFI_FFS_FILE_STATE FileState;\r
	41	EFI_FFS_FILE_STATE HighestBit;\r
	42	\r
	43	FileState = FfsHeader->State;\r
	44	\r
	45	if (ErasePolarity != 0) {\r
	46	FileState = (EFI_FFS_FILE_STATE)~FileState;\r
	47	}\r
	48	\r
	49	HighestBit = 0x80;\r
	50	while (HighestBit != 0 && (HighestBit & FileState) == 0) {\r
	51	HighestBit >>= 1;\r
	52	}\r
	53	\r
	54	return HighestBit;\r
	55	}\r
	56	\r
	57	/**\r
	58	Calculates the checksum of the header of a file.\r
	59	\r
	60	@param FileHeader Pointer to FFS File Header.\r
	61	\r
	62	@return Checksum of the header.\r
	63	**/\r
	64	UINT8\r
65	CalculateHeaderChecksum (\r
66	IN EFI_FFS_FILE_HEADER *FileHeader\r
67	)\r
68	{\r
69	UINT8 *ptr;\r
70	UINTN Index;\r
71	UINT8 Sum;\r
72	\r
73	Sum = 0;\r
74	ptr = (UINT8 *) FileHeader;\r
75	\r
76	for (Index = 0; Index < sizeof (EFI_FFS_FILE_HEADER) - 3; Index += 4) {\r
77	Sum = (UINT8) (Sum + ptr[Index]);\r
78	Sum = (UINT8) (Sum + ptr[Index + 1]);\r
79	Sum = (UINT8) (Sum + ptr[Index + 2]);\r
80	Sum = (UINT8) (Sum + ptr[Index + 3]);\r
81	}\r
82	\r
83	for (; Index < sizeof (EFI_FFS_FILE_HEADER); Index++) {\r
84	Sum = (UINT8) (Sum + ptr[Index]);\r
85	}\r
86	//\r
87	// State field (since this indicates the different state of file).\r
88	//\r
89	Sum = (UINT8) (Sum - FileHeader->State);\r
90	//\r
91	// Checksum field of the file is not part of the header checksum.\r
92	//\r
93	Sum = (UINT8) (Sum - FileHeader->IntegrityCheck.Checksum.File);\r
94	\r
95	return Sum;\r
96	}\r
97	\r
98	/**\r
99	Given the input file pointer, search for the next matching file in the\r
100	FFS volume as defined by SearchType. The search starts from FileHeader inside\r
101	the Firmware Volume defined by FwVolHeader.\r
102	\r
103	@param SearchType Filter to find only files of this type.\r
104	Type EFI_FV_FILETYPE_ALL causes no filtering to be done.\r
105	@param FwVolHeader Pointer to the FV header of the volume to search.\r
106	This parameter must point to a valid FFS volume.\r
107	@param FileHeader Pointer to the current file from which to begin searching.\r
108	This pointer will be updated upon return to reflect the file found.\r
109	\r
110	@retval EFI_NOT_FOUND No files matching the search criteria were found\r
111	@retval EFI_SUCCESS\r
112	**/\r
113	EFI_STATUS\r
114	EFIAPI\r
115	FfsFindNextFile (\r
116	IN EFI_FV_FILETYPE SearchType,\r
117	IN EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader,\r
118	IN OUT EFI_FFS_FILE_HEADER **FileHeader\r
119	)\r
120	{\r
121	EFI_FIRMWARE_VOLUME_EXT_HEADER *FvExtHeader;\r
122	\r
123	EFI_FFS_FILE_HEADER *FfsFileHeader;\r
124	UINT32 FileLength;\r
125	UINT32 FileOccupiedSize;\r
126	UINT32 FileOffset;\r
127	UINT64 FvLength;\r
128	UINT8 ErasePolarity;\r
129	UINT8 FileState;\r
130	\r
131	FvLength = FwVolHeader->FvLength;\r
132	if (FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) {\r
133	ErasePolarity = 1;\r
134	} else {\r
135	ErasePolarity = 0;\r
136	}\r
137	//\r
138	// If FileHeader is not specified (NULL) start with the first file in the\r
139	// firmware volume. Otherwise, start from the FileHeader.\r
140	//\r
141	if (*FileHeader == NULL) {\r
142	\r
143	if (FwVolHeader->ExtHeaderOffset != 0) {\r
144	\r
145	FvExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER )((UINT8 )FwVolHeader +\r
146	FwVolHeader->ExtHeaderOffset);\r
147	\r
148	FfsFileHeader = (EFI_FFS_FILE_HEADER )((UINT8 )FvExtHeader +\r
149	FvExtHeader->ExtHeaderSize);\r
150	\r
151	} else {\r
152	\r
153	FfsFileHeader = (EFI_FFS_FILE_HEADER )((UINT8 )FwVolHeader +\r
154	FwVolHeader->HeaderLength);\r
155	\r
156	}\r
157	\r
158	FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINTN)FwVolHeader +\r
159	ALIGN_VALUE((UINTN)FfsFileHeader -\r
160	(UINTN)FwVolHeader, 8));\r
161	} else {\r
162	//\r
163	// Length is 24 bits wide so mask upper 8 bits\r
164	// FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.\r
165	//\r
166	FileLength = FFS_FILE_SIZE(*FileHeader);\r
167	FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);\r
168	FfsFileHeader = (EFI_FFS_FILE_HEADER ) ((UINT8 ) *FileHeader + FileOccupiedSize);\r
169	}\r
170	\r
171	FileOffset = (UINT32) ((UINT8 ) FfsFileHeader - (UINT8 ) FwVolHeader);\r
172	\r
173	while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {\r
174	//\r
175	// Get FileState which is the highest bit of the State\r
176	//\r
177	FileState = GetFileState (ErasePolarity, FfsFileHeader);\r
178	\r
179	switch (FileState) {\r
180	\r
181	case EFI_FILE_HEADER_INVALID:\r
182	FileOffset += sizeof (EFI_FFS_FILE_HEADER);\r
183	FfsFileHeader = (EFI_FFS_FILE_HEADER ) ((UINT8 ) FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER));\r
184	break;\r
185	\r
186	case EFI_FILE_DATA_VALID:\r
187	case EFI_FILE_MARKED_FOR_UPDATE:\r
188	if (CalculateHeaderChecksum (FfsFileHeader) == 0) {\r
189	FileLength = FFS_FILE_SIZE(FfsFileHeader);\r
190	FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);\r
191	\r
192	if ((SearchType == FfsFileHeader->Type) \|\| (SearchType == EFI_FV_FILETYPE_ALL)) {\r
193	\r
194	*FileHeader = FfsFileHeader;\r
195	\r
196	return EFI_SUCCESS;\r
197	}\r
198	\r
199	FileOffset += FileOccupiedSize;\r
200	FfsFileHeader = (EFI_FFS_FILE_HEADER ) ((UINT8 ) FfsFileHeader + FileOccupiedSize);\r
201	} else {\r
202	return EFI_NOT_FOUND;\r
203	}\r
204	break;\r
205	\r
206	case EFI_FILE_DELETED:\r
207	FileLength = FFS_FILE_SIZE(FfsFileHeader);\r
208	FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);\r
209	FileOffset += FileOccupiedSize;\r
210	FfsFileHeader = (EFI_FFS_FILE_HEADER ) ((UINT8 ) FfsFileHeader + FileOccupiedSize);\r
211	break;\r
212	\r
213	default:\r
214	return EFI_NOT_FOUND;\r
215	\r
216	}\r
217	}\r
218	\r
219	return EFI_NOT_FOUND;\r
220	}\r
221	\r
222	/**\r
223	Locates a section within a series of sections\r
224	with the specified section type.\r
225	\r
226	@param[in] Sections The sections to search\r
227	@param[in] SizeOfSections Total size of all sections\r
228	@param[in] SectionType The section type to locate\r
229	@param[out] FoundSection The FFS section if found\r
230	\r
231	@retval EFI_SUCCESS The file and section was found\r
232	@retval EFI_NOT_FOUND The file and section was not found\r
233	@retval EFI_VOLUME_CORRUPTED The firmware volume was corrupted\r
234	**/\r
235	EFI_STATUS\r
236	EFIAPI\r
237	FindFfsSectionInSections (\r
238	IN VOID *Sections,\r
239	IN UINTN SizeOfSections,\r
240	IN EFI_SECTION_TYPE SectionType,\r
241	OUT EFI_COMMON_SECTION_HEADER **FoundSection\r
242	)\r
243	{\r
244	EFI_PHYSICAL_ADDRESS CurrentAddress;\r
245	UINT32 Size;\r
246	EFI_PHYSICAL_ADDRESS EndOfSections;\r
247	EFI_COMMON_SECTION_HEADER *Section;\r
248	EFI_PHYSICAL_ADDRESS EndOfSection;\r
249	\r
250	//\r
251	// Loop through the FFS file sections\r
252	//\r
253	EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN) Sections;\r
254	EndOfSections = EndOfSection + SizeOfSections;\r
255	for (;;) {\r
256	if (EndOfSection == EndOfSections) {\r
257	break;\r
258	}\r
259	CurrentAddress = EndOfSection;\r
260	\r
261	Section = (EFI_COMMON_SECTION_HEADER*)(UINTN) CurrentAddress;\r
262	\r
263	Size = SECTION_SIZE (Section);\r
264	if (Size < sizeof (*Section)) {\r
265	return EFI_VOLUME_CORRUPTED;\r
266	}\r
267	\r
268	EndOfSection = CurrentAddress + Size;\r
269	if (EndOfSection > EndOfSections) {\r
270	return EFI_VOLUME_CORRUPTED;\r
271	}\r
272	Size = GET_OCCUPIED_SIZE (Size, 4);\r
273	\r
274	//\r
275	// Look for the requested section type\r
276	//\r
277	if (Section->Type == SectionType) {\r
278	*FoundSection = Section;\r
279	return EFI_SUCCESS;\r
280	}\r
281	}\r
282	\r
283	return EFI_NOT_FOUND;\r
284	}\r
285	\r
286	/**\r
287	Given the input file pointer, search for the next matching section in the\r
288	FFS volume.\r
289	\r
290	@param SearchType Filter to find only sections of this type.\r
291	@param FfsFileHeader Pointer to the current file to search.\r
292	@param SectionHeader Pointer to the Section matching SectionType in FfsFileHeader.\r
293	NULL if section not found\r
294	\r
295	@retval EFI_NOT_FOUND No files matching the search criteria were found\r
296	@retval EFI_SUCCESS\r
297	**/\r
298	EFI_STATUS\r
299	EFIAPI\r
300	FfsFindSection (\r
301	IN EFI_SECTION_TYPE SectionType,\r
302	IN EFI_FFS_FILE_HEADER *FfsFileHeader,\r
303	IN OUT EFI_COMMON_SECTION_HEADER **SectionHeader\r
304	)\r
305	{\r
306	UINT32 FileSize;\r
307	EFI_COMMON_SECTION_HEADER *Section;\r
308	EFI_STATUS Status;\r
309	\r
310	//\r
311	// Size is 24 bits wide so mask upper 8 bits.\r
312	// Does not include FfsFileHeader header size\r
313	// FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.\r
314	//\r
315	Section = (EFI_COMMON_SECTION_HEADER *) (FfsFileHeader + 1);\r
316	FileSize = FFS_FILE_SIZE(FfsFileHeader);\r
317	FileSize -= sizeof (EFI_FFS_FILE_HEADER);\r
318	\r
319	Status = FindFfsSectionInSections (\r
320	Section,\r
321	FileSize,\r
322	SectionType,\r
323	SectionHeader\r
324	);\r
325	return Status;\r
326	}\r
327	\r
328	/**\r
329	Given the input file pointer, search for the next matching section in the\r
330	FFS volume.\r
331	\r
332	@param SearchType Filter to find only sections of this type.\r
333	@param FfsFileHeader Pointer to the current file to search.\r
334	@param SectionData Pointer to the Section matching SectionType in FfsFileHeader.\r
335	NULL if section not found\r
336	@param SectionDataSize The size of SectionData\r
337	\r
338	@retval EFI_NOT_FOUND No files matching the search criteria were found\r
339	@retval EFI_SUCCESS\r
340	**/\r
341	EFI_STATUS\r
342	EFIAPI\r
343	FfsFindSectionData (\r
344	IN EFI_SECTION_TYPE SectionType,\r
345	IN EFI_FFS_FILE_HEADER *FfsFileHeader,\r
346	IN OUT VOID **SectionData,\r
347	IN OUT UINTN *SectionDataSize\r
348	)\r
349	{\r
350	UINT32 FileSize;\r
351	EFI_COMMON_SECTION_HEADER *Section;\r
352	UINT32 SectionLength;\r
353	UINT32 ParsedLength;\r
354	\r
355	//\r
356	// Size is 24 bits wide so mask upper 8 bits.\r
357	// Does not include FfsFileHeader header size\r
358	// FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.\r
359	//\r
360	Section = (EFI_COMMON_SECTION_HEADER *) (FfsFileHeader + 1);\r
361	FileSize = FFS_FILE_SIZE(FfsFileHeader);\r
362	FileSize -= sizeof (EFI_FFS_FILE_HEADER);\r
363	\r
364	*SectionData = NULL;\r
365	ParsedLength = 0;\r
366	while (ParsedLength < FileSize) {\r
367	if (Section->Type == SectionType) {\r
368	SectionData = (VOID ) (Section + 1);\r
369	*SectionDataSize = SECTION_SIZE(Section);\r
370	return EFI_SUCCESS;\r
371	}\r
372	//\r
373	// Size is 24 bits wide so mask upper 8 bits.\r
374	// SectionLength is adjusted it is 4 byte aligned.\r
375	// Go to the next section\r
376	//\r
377	SectionLength = SECTION_SIZE(Section);\r
378	SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);\r
379	\r
380	ParsedLength += SectionLength;\r
381	Section = (EFI_COMMON_SECTION_HEADER ) ((UINT8 ) Section + SectionLength);\r
382	}\r
383	\r
384	return EFI_NOT_FOUND;\r
385	}\r