• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*++ @file
2   A simple FV stack so the SEC can extract the SEC Core from an
3   FV.
4 
5 Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution.  The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10 
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13 
14 **/
15 
16 #include <PiPei.h>
17 
18 
19 #define GET_OCCUPIED_SIZE(ActualSize, Alignment) \
20   (ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))
21 
22 EFI_FFS_FILE_STATE
GetFileState(IN UINT8 ErasePolarity,IN EFI_FFS_FILE_HEADER * FfsHeader)23 GetFileState (
24   IN UINT8                ErasePolarity,
25   IN EFI_FFS_FILE_HEADER  *FfsHeader
26   )
27 /*++
28 
29 Routine Description:
30   Returns the highest bit set of the State field
31 
32 Arguments:
33   ErasePolarity   - Erase Polarity  as defined by EFI_FVB2_ERASE_POLARITY
34                     in the Attributes field.
35   FfsHeader       - Pointer to FFS File Header.
36 
37 Returns:
38   Returns the highest bit in the State field
39 
40 **/
41 {
42   EFI_FFS_FILE_STATE  FileState;
43   EFI_FFS_FILE_STATE  HighestBit;
44 
45   FileState = FfsHeader->State;
46 
47   if (ErasePolarity != 0) {
48     FileState = (EFI_FFS_FILE_STATE)~FileState;
49   }
50 
51   HighestBit = 0x80;
52   while (HighestBit != 0 && (HighestBit & FileState) == 0) {
53     HighestBit >>= 1;
54   }
55 
56   return HighestBit;
57 }
58 
59 UINT8
CalculateHeaderChecksum(IN EFI_FFS_FILE_HEADER * FileHeader)60 CalculateHeaderChecksum (
61   IN EFI_FFS_FILE_HEADER  *FileHeader
62   )
63 /*++
64 
65 Routine Description:
66   Calculates the checksum of the header of a file.
67 
68 Arguments:
69   FileHeader       - Pointer to FFS File Header.
70 
71 Returns:
72   Checksum of the header.
73 
74 **/
75 {
76   UINT8 *ptr;
77   UINTN Index;
78   UINT8 Sum;
79 
80   Sum = 0;
81   ptr = (UINT8 *) FileHeader;
82 
83   for (Index = 0; Index < sizeof (EFI_FFS_FILE_HEADER) - 3; Index += 4) {
84     Sum = (UINT8) (Sum + ptr[Index]);
85     Sum = (UINT8) (Sum + ptr[Index + 1]);
86     Sum = (UINT8) (Sum + ptr[Index + 2]);
87     Sum = (UINT8) (Sum + ptr[Index + 3]);
88   }
89 
90   for (; Index < sizeof (EFI_FFS_FILE_HEADER); Index++) {
91     Sum = (UINT8) (Sum + ptr[Index]);
92   }
93   //
94   // State field (since this indicates the different state of file).
95   //
96   Sum = (UINT8) (Sum - FileHeader->State);
97   //
98   // Checksum field of the file is not part of the header checksum.
99   //
100   Sum = (UINT8) (Sum - FileHeader->IntegrityCheck.Checksum.File);
101 
102   return Sum;
103 }
104 
105 EFI_STATUS
SecFfsFindNextFile(IN EFI_FV_FILETYPE SearchType,IN EFI_PEI_FV_HANDLE FvHandle,IN OUT EFI_PEI_FILE_HANDLE * FileHandle)106 SecFfsFindNextFile (
107   IN EFI_FV_FILETYPE             SearchType,
108   IN EFI_PEI_FV_HANDLE           FvHandle,
109   IN OUT EFI_PEI_FILE_HANDLE     *FileHandle
110   )
111 /*++
112 
113 Routine Description:
114     Given the input file pointer, search for the next matching file in the
115     FFS volume as defined by SearchType. The search starts from FileHeader inside
116     the Firmware Volume defined by FwVolHeader.
117 
118 Arguments:
119     SearchType - Filter to find only files of this type.
120                  Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
121     FwVolHeader - Pointer to the FV header of the volume to search.
122                   This parameter must point to a valid FFS volume.
123     FileHeader  - Pointer to the current file from which to begin searching.
124                   This pointer will be updated upon return to reflect the file
125                   found.
126 
127 Returns:
128     EFI_NOT_FOUND - No files matching the search criteria were found
129     EFI_SUCCESS
130 
131 **/
132 {
133   EFI_FFS_FILE_HEADER *FfsFileHeader;
134   UINT32              FileLength;
135   UINT32              FileOccupiedSize;
136   UINT32              FileOffset;
137   UINT64              FvLength;
138   UINT8               ErasePolarity;
139   UINT8               FileState;
140   EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;
141   EFI_FFS_FILE_HEADER         **FileHeader;
142 
143   //
144   // Convert the handle of FV to FV header for memory-mapped firmware volume
145   //
146   FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) FvHandle;
147   FileHeader  = (EFI_FFS_FILE_HEADER **)FileHandle;
148 
149   FvLength = FwVolHeader->FvLength;
150   if (FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) {
151     ErasePolarity = 1;
152   } else {
153     ErasePolarity = 0;
154   }
155   //
156   // If FileHeader is not specified (NULL) start with the first file in the
157   // firmware volume.  Otherwise, start from the FileHeader.
158   //
159   if (*FileHeader == NULL) {
160     FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FwVolHeader + FwVolHeader->HeaderLength);
161   } else {
162     //
163     // Length is 24 bits wide so mask upper 8 bits
164     // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
165     //
166     FileLength        = *(UINT32 *) (*FileHeader)->Size & 0x00FFFFFF;
167     FileOccupiedSize  = GET_OCCUPIED_SIZE (FileLength, 8);
168     FfsFileHeader     = (EFI_FFS_FILE_HEADER *) ((UINT8 *) *FileHeader + FileOccupiedSize);
169   }
170 
171   FileOffset = (UINT32) ((UINT8 *) FfsFileHeader - (UINT8 *) FwVolHeader);
172 
173   while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {
174     //
175     // Get FileState which is the highest bit of the State
176     //
177     FileState = GetFileState (ErasePolarity, FfsFileHeader);
178 
179     switch (FileState) {
180 
181     case EFI_FILE_HEADER_INVALID:
182       FileOffset += sizeof (EFI_FFS_FILE_HEADER);
183       FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER));
184       break;
185 
186     case EFI_FILE_DATA_VALID:
187     case EFI_FILE_MARKED_FOR_UPDATE:
188       if (CalculateHeaderChecksum (FfsFileHeader) == 0) {
189         FileLength        = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF;
190         FileOccupiedSize  = GET_OCCUPIED_SIZE (FileLength, 8);
191 
192         if ((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) {
193 
194           *FileHeader = FfsFileHeader;
195 
196           return EFI_SUCCESS;
197         }
198 
199         FileOffset += FileOccupiedSize;
200         FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize);
201       } else {
202         return EFI_NOT_FOUND;
203       }
204       break;
205 
206     case EFI_FILE_DELETED:
207       FileLength        = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF;
208       FileOccupiedSize  = GET_OCCUPIED_SIZE (FileLength, 8);
209       FileOffset += FileOccupiedSize;
210       FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize);
211       break;
212 
213     default:
214       return EFI_NOT_FOUND;
215 
216     }
217   }
218 
219   return EFI_NOT_FOUND;
220 }
221 
222 EFI_STATUS
SecFfsFindSectionData(IN EFI_SECTION_TYPE SectionType,IN EFI_FFS_FILE_HEADER * FfsFileHeader,IN OUT VOID ** SectionData)223 SecFfsFindSectionData (
224   IN EFI_SECTION_TYPE      SectionType,
225   IN EFI_FFS_FILE_HEADER   *FfsFileHeader,
226   IN OUT VOID              **SectionData
227   )
228 /*++
229 
230 Routine Description:
231     Given the input file pointer, search for the next matching section in the
232     FFS volume.
233 
234 Arguments:
235     SearchType    - Filter to find only sections of this type.
236     FfsFileHeader - Pointer to the current file to search.
237     SectionData   - Pointer to the Section matching SectionType in FfsFileHeader.
238                      NULL if section not found
239 
240 Returns:
241     EFI_NOT_FOUND - No files matching the search criteria were found
242     EFI_SUCCESS
243 
244 **/
245 {
246   UINT32                    FileSize;
247   EFI_COMMON_SECTION_HEADER *Section;
248   UINT32                    SectionLength;
249   UINT32                    ParsedLength;
250 
251   //
252   // Size is 24 bits wide so mask upper 8 bits.
253   //    Does not include FfsFileHeader header size
254   // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.
255   //
256   Section   = (EFI_COMMON_SECTION_HEADER *) (FfsFileHeader + 1);
257   FileSize  = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF;
258   FileSize -= sizeof (EFI_FFS_FILE_HEADER);
259 
260   *SectionData  = NULL;
261   ParsedLength  = 0;
262   while (ParsedLength < FileSize) {
263     if (Section->Type == SectionType) {
264       *SectionData = (VOID *) (Section + 1);
265       return EFI_SUCCESS;
266     }
267     //
268     // Size is 24 bits wide so mask upper 8 bits.
269     // SectionLength is adjusted it is 4 byte aligned.
270     // Go to the next section
271     //
272     SectionLength = *(UINT32 *) Section->Size & 0x00FFFFFF;
273     SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
274 
275     ParsedLength += SectionLength;
276     Section = (EFI_COMMON_SECTION_HEADER *) ((UINT8 *) Section + SectionLength);
277   }
278 
279   return EFI_NOT_FOUND;
280 }
281 
282