VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/VarCheckHiiLib/VarCheckHiiGenFromFv.c@ 81344

Last change on this file since 81344 was 80721, checked in by vboxsync, 5 years ago

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • Property svn:eol-style set to native
File size: 11.7 KB
Line 
1/** @file
2 Var Check Hii generation from FV.
3
4Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "VarCheckHiiGen.h"
10
11// {d0bc7cb4-6a47-495f-aa11-710746da06a2}
12#define EFI_VFR_ATTRACT_GUID \
13{ 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } }
14
15EFI_GUID gVfrArrayAttractGuid = EFI_VFR_ATTRACT_GUID;
16
17#define ALL_FF_GUID \
18{ 0xFFFFFFFF, 0xFFFF, 0xFFFF, { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF } }
19
20EFI_GUID mAllFfGuid = ALL_FF_GUID;
21
22#define VAR_CHECK_VFR_DRIVER_INFO_SIGNATURE SIGNATURE_32 ('V', 'D', 'R', 'I')
23
24typedef struct {
25 UINTN Signature;
26 LIST_ENTRY Link;
27 EFI_GUID *DriverGuid;
28} VAR_CHECK_VFR_DRIVER_INFO;
29
30LIST_ENTRY mVfrDriverList = INITIALIZE_LIST_HEAD_VARIABLE (mVfrDriverList);
31
32#define VAR_CHECK_VFR_DRIVER_INFO_FROM_LINK(a) CR (a, VAR_CHECK_VFR_DRIVER_INFO, Link, VAR_CHECK_VFR_DRIVER_INFO_SIGNATURE)
33
34#define MAX_MATCH_GUID_NUM 100
35
36/**
37 Get the address by Guid.
38
39 Parse the FFS and find the GUID address.
40 There may be multiple Guids matching the searched Guid.
41
42 @param Ffs Pointer to the FFS.
43 @param Guid Guid to find.
44 @param Length The length of FFS.
45 @param Offset Pointer to pointer to the offset.
46 @param NumOfMatchingGuid The number of matching Guid.
47
48 @retval EFI_SUCCESS One or multiple Guids matching the searched Guid.
49 @retval EFI_NOT_FOUND No Guid matching the searched Guid.
50
51**/
52EFI_STATUS
53GetAddressByGuid (
54 IN VOID *Ffs,
55 IN EFI_GUID *Guid,
56 IN UINTN Length,
57 OUT UINTN **Offset,
58 OUT UINT8 *NumOfMatchingGuid
59 )
60{
61 UINTN LoopControl;
62 BOOLEAN Found;
63
64 if((Ffs == NULL) || (Guid == NULL) || (Length == 0)){
65 return EFI_NOT_FOUND;
66 }
67
68 if (NumOfMatchingGuid != NULL) {
69 *NumOfMatchingGuid = 0;
70 }
71
72 Found = FALSE;
73 for (LoopControl = 0; LoopControl < Length; LoopControl++) {
74 if (CompareGuid (Guid, (EFI_GUID *) ((UINT8 *) Ffs + LoopControl))) {
75 Found = TRUE;
76 //
77 // If NumOfMatchGuid or Offset are NULL, means user only want
78 // to check whether current FFS includes this Guid or not.
79 //
80 if ((NumOfMatchingGuid != NULL) && (Offset != NULL)) {
81 if (*NumOfMatchingGuid == 0) {
82 *Offset = InternalVarCheckAllocateZeroPool (sizeof (UINTN) * MAX_MATCH_GUID_NUM);
83 ASSERT (*Offset != NULL);
84 }
85 *(*Offset + *NumOfMatchingGuid) = LoopControl + sizeof (EFI_GUID);
86 (*NumOfMatchingGuid)++;
87 } else {
88 break;
89 }
90 }
91 }
92
93 return (Found ? EFI_SUCCESS : EFI_NOT_FOUND);
94}
95
96/**
97 Search the VfrBin Base address.
98
99 According to the known GUID gVfrArrayAttractGuid to get the base address from FFS.
100
101 @param Ffs Pointer to the FFS.
102 @param EfiAddr Pointer to the EFI in FFS
103 @param Length The length of FFS.
104 @param Offset Pointer to pointer to the Addr (Offset).
105 @param NumOfMatchingOffset The number of Addr (Offset).
106
107 @retval EFI_SUCCESS Get the address successfully.
108 @retval EFI_NOT_FOUND No VfrBin found.
109
110**/
111EFI_STATUS
112SearchVfrBinInFfs (
113 IN VOID *Ffs,
114 IN VOID *EfiAddr,
115 IN UINTN Length,
116 OUT UINTN **Offset,
117 OUT UINT8 *NumOfMatchingOffset
118 )
119{
120 UINTN Index;
121 EFI_STATUS Status;
122 UINTN VirOffValue;
123
124 if ((Ffs == NULL) || (Offset == NULL)) {
125 return EFI_NOT_FOUND;
126 }
127 Status = GetAddressByGuid (
128 Ffs,
129 &gVfrArrayAttractGuid,
130 Length,
131 Offset,
132 NumOfMatchingOffset
133 );
134 if (Status != EFI_SUCCESS) {
135 return Status;
136 }
137
138 for (Index = 0; Index < *NumOfMatchingOffset; Index++) {
139 //
140 // Got the virOffset after the GUID
141 //
142 VirOffValue = *(UINTN *) ((UINTN) Ffs + *(*Offset + Index));
143 //
144 // Transfer the offset to the VA address. One modules may own multiple VfrBin address.
145 //
146 *(*Offset + Index) = (UINTN) EfiAddr + VirOffValue;
147 }
148
149 return Status;
150}
151
152/**
153 Parse FFS.
154
155 @param[in] Fv2 Pointer to Fv2 protocol.
156 @param[in] DriverGuid Pointer to driver GUID.
157
158 @return Found the driver in the FV or not.
159
160**/
161BOOLEAN
162ParseFfs (
163 IN EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv2,
164 IN EFI_GUID *DriverGuid
165 )
166{
167 EFI_STATUS Status;
168 EFI_FV_FILETYPE FoundType;
169 EFI_FV_FILE_ATTRIBUTES FileAttributes;
170 UINT32 AuthenticationStatus;
171 UINTN Size;
172 VOID *Buffer;
173 UINTN SectionSize;
174 VOID *SectionBuffer;
175 UINTN VfrBinIndex;
176 UINT8 NumberofMatchingVfrBin;
177 UINTN *VfrBinBaseAddress;
178
179 Status = Fv2->ReadFile (
180 Fv2,
181 DriverGuid,
182 NULL,
183 &Size,
184 &FoundType,
185 &FileAttributes,
186 &AuthenticationStatus
187 );
188 if (EFI_ERROR (Status)) {
189 return FALSE;
190 }
191
192 Buffer = NULL;
193 Status = Fv2->ReadSection (
194 Fv2,
195 DriverGuid,
196 EFI_SECTION_RAW,
197 0, // Instance
198 &Buffer,
199 &Size,
200 &AuthenticationStatus
201 );
202 if (!EFI_ERROR (Status)) {
203 Status = SearchVfrBinInFfs (Buffer, 0, Size, &VfrBinBaseAddress, &NumberofMatchingVfrBin);
204 if (!EFI_ERROR (Status)) {
205 SectionBuffer = NULL;
206 Status = Fv2->ReadSection (
207 Fv2,
208 DriverGuid,
209 EFI_SECTION_PE32,
210 0, // Instance
211 &SectionBuffer,
212 &SectionSize,
213 &AuthenticationStatus
214 );
215 if (!EFI_ERROR (Status)) {
216 DEBUG ((DEBUG_INFO , "FfsNameGuid - %g\n", DriverGuid));
217 DEBUG ((DEBUG_INFO , "NumberofMatchingVfrBin - 0x%02x\n", NumberofMatchingVfrBin));
218
219 for (VfrBinIndex = 0; VfrBinIndex < NumberofMatchingVfrBin; VfrBinIndex++) {
220#ifdef DUMP_HII_DATA
221 DEBUG_CODE (
222 DumpHiiPackage ((UINT8 *) (UINTN) SectionBuffer + VfrBinBaseAddress[VfrBinIndex] + sizeof (UINT32));
223 );
224#endif
225 VarCheckParseHiiPackage ((UINT8 *) (UINTN) SectionBuffer + VfrBinBaseAddress[VfrBinIndex] + sizeof (UINT32), TRUE);
226 }
227
228 FreePool (SectionBuffer);
229 }
230
231 InternalVarCheckFreePool (VfrBinBaseAddress);
232 }
233
234 FreePool (Buffer);
235 }
236
237 return TRUE;
238}
239
240/**
241 Parse FVs.
242
243 @param[in] ScanAll Scan all modules in all FVs or not.
244
245**/
246VOID
247ParseFv (
248 IN BOOLEAN ScanAll
249 )
250{
251 EFI_STATUS Status;
252 EFI_HANDLE *HandleBuffer;
253 UINTN HandleCount;
254 UINTN Index;
255 EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv2;
256 VOID *Key;
257 EFI_FV_FILETYPE FileType;
258 EFI_GUID NameGuid;
259 EFI_FV_FILE_ATTRIBUTES FileAttributes;
260 UINTN Size;
261 UINTN FfsIndex;
262 VAR_CHECK_VFR_DRIVER_INFO *VfrDriverInfo;
263 LIST_ENTRY *VfrDriverLink;
264
265 HandleBuffer = NULL;
266 Status = gBS->LocateHandleBuffer (
267 ByProtocol,
268 &gEfiFirmwareVolume2ProtocolGuid,
269 NULL,
270 &HandleCount,
271 &HandleBuffer
272 );
273 if (EFI_ERROR (Status)) {
274 return;
275 }
276
277 //
278 // Search all FVs
279 //
280 for (Index = 0; Index < HandleCount; Index++) {
281 DEBUG ((DEBUG_INFO , "FvIndex - %x\n", Index));
282 Status = gBS->HandleProtocol (
283 HandleBuffer[Index],
284 &gEfiFirmwareVolume2ProtocolGuid,
285 (VOID **) &Fv2
286 );
287 ASSERT_EFI_ERROR (Status);
288
289 DEBUG_CODE (
290 EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *Fvb2;
291 EFI_PHYSICAL_ADDRESS FvAddress;
292 UINT64 FvSize;
293
294 Status = gBS->HandleProtocol (
295 HandleBuffer[Index],
296 &gEfiFirmwareVolumeBlock2ProtocolGuid,
297 (VOID **) &Fvb2
298 );
299 ASSERT_EFI_ERROR (Status);
300 Status = Fvb2->GetPhysicalAddress (Fvb2, &FvAddress);
301 if (!EFI_ERROR (Status)) {
302 DEBUG ((DEBUG_INFO , "FvAddress - 0x%08x\n", FvAddress));
303 FvSize = ((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) FvAddress)->FvLength;
304 DEBUG ((DEBUG_INFO , "FvSize - 0x%08x\n", FvSize));
305 }
306 );
307
308 if (ScanAll) {
309 //
310 // Need to parse all modules in all FVs.
311 //
312 Key = InternalVarCheckAllocateZeroPool (Fv2->KeySize);
313 ASSERT (Key != NULL);
314
315 for (FfsIndex = 0; ; FfsIndex++) {
316 FileType = EFI_FV_FILETYPE_ALL;
317 Status = Fv2->GetNextFile (
318 Fv2,
319 Key,
320 &FileType,
321 &NameGuid,
322 &FileAttributes,
323 &Size
324 );
325 if (EFI_ERROR (Status)) {
326 break;
327 }
328
329 ParseFfs (Fv2, &NameGuid);
330 }
331
332 InternalVarCheckFreePool (Key);
333 } else {
334 //
335 // Only parse drivers in the VFR drivers list.
336 //
337 VfrDriverLink = mVfrDriverList.ForwardLink;
338 while (VfrDriverLink != &mVfrDriverList) {
339 VfrDriverInfo = VAR_CHECK_VFR_DRIVER_INFO_FROM_LINK (VfrDriverLink);
340 VfrDriverLink = VfrDriverLink->ForwardLink;
341 if (ParseFfs (Fv2, VfrDriverInfo->DriverGuid)) {
342 //
343 // Found the driver in the FV.
344 //
345 RemoveEntryList (&VfrDriverInfo->Link);
346 InternalVarCheckFreePool (VfrDriverInfo);
347 }
348 }
349 }
350 }
351
352 FreePool (HandleBuffer);
353}
354
355/**
356 Create Vfr Driver List.
357
358 @param[in] DriverGuidArray Driver Guid Array
359
360**/
361VOID
362CreateVfrDriverList (
363 IN EFI_GUID *DriverGuidArray
364 )
365{
366 UINTN Index;
367 VAR_CHECK_VFR_DRIVER_INFO *VfrDriverInfo;
368
369 for (Index = 0; !IsZeroGuid (&DriverGuidArray[Index]); Index++) {
370 DEBUG ((DEBUG_INFO , "CreateVfrDriverList: %g\n", &DriverGuidArray[Index]));
371 VfrDriverInfo = InternalVarCheckAllocateZeroPool (sizeof (*VfrDriverInfo));
372 ASSERT (VfrDriverInfo != NULL);
373 VfrDriverInfo->Signature = VAR_CHECK_VFR_DRIVER_INFO_SIGNATURE;
374 VfrDriverInfo->DriverGuid = &DriverGuidArray[Index];
375 InsertTailList (&mVfrDriverList, &VfrDriverInfo->Link);
376 }
377}
378
379/**
380 Destroy Vfr Driver List.
381
382**/
383VOID
384DestroyVfrDriverList (
385 VOID
386 )
387{
388 VAR_CHECK_VFR_DRIVER_INFO *VfrDriverInfo;
389 LIST_ENTRY *VfrDriverLink;
390
391 while (mVfrDriverList.ForwardLink != &mVfrDriverList) {
392 VfrDriverLink = mVfrDriverList.ForwardLink;
393 VfrDriverInfo = VAR_CHECK_VFR_DRIVER_INFO_FROM_LINK (VfrDriverLink);
394 RemoveEntryList (&VfrDriverInfo->Link);
395 InternalVarCheckFreePool (VfrDriverInfo);
396 }
397}
398
399/**
400 Generate from FV.
401
402**/
403VOID
404VarCheckHiiGenFromFv (
405 VOID
406 )
407{
408 EFI_GUID *DriverGuidArray;
409 BOOLEAN ScanAll;
410
411 DEBUG ((DEBUG_INFO , "VarCheckHiiGenDxeFromFv\n"));
412
413 //
414 // Get vfr driver guid array from PCD.
415 //
416 DriverGuidArray = (EFI_GUID *) PcdGetPtr (PcdVarCheckVfrDriverGuidArray);
417
418 if (IsZeroGuid (&DriverGuidArray[0])) {
419 //
420 // No VFR driver will be parsed from FVs.
421 //
422 return;
423 }
424
425 if (CompareGuid (&DriverGuidArray[0], &mAllFfGuid)) {
426 ScanAll = TRUE;
427 } else {
428 ScanAll = FALSE;
429 CreateVfrDriverList (DriverGuidArray);
430 }
431
432 ParseFv (ScanAll);
433
434 if (!ScanAll) {
435 DestroyVfrDriverList ();
436 }
437}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette