2 Pei Core Firmware File System service routines.
4 Copyright (c) 2006 - 2008, Intel Corporation
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 STATIC EFI_PEI_NOTIFY_DESCRIPTOR mNotifyOnFvInfoList
= {
18 (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
19 &gEfiPeiFirmwareVolumeInfoPpiGuid
,
20 FirmwareVolmeInfoPpiNotifyCallback
24 #define GET_OCCUPIED_SIZE(ActualSize, Alignment) \
25 ((ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1)))
28 Returns the file state set by the highest zero bit in the State field
30 @param ErasePolarity Erase Polarity as defined by EFI_FVB2_ERASE_POLARITY
31 in the Attributes field.
32 @param FfsHeader Pointer to FFS File Header.
34 @retval EFI_FFS_FILE_STATE File state is set by the highest none zero bit
35 in the header State field.
39 IN UINT8 ErasePolarity
,
40 IN EFI_FFS_FILE_HEADER
*FfsHeader
43 EFI_FFS_FILE_STATE FileState
;
44 EFI_FFS_FILE_STATE HighestBit
;
46 FileState
= FfsHeader
->State
;
48 if (ErasePolarity
!= 0) {
49 FileState
= (EFI_FFS_FILE_STATE
)~FileState
;
53 // Get file state set by its highest none zero bit.
56 while (HighestBit
!= 0 && (HighestBit
& FileState
) == 0) {
64 Calculates the checksum of the header of a file.
66 @param FileHeader Pointer to FFS File Header.
68 @return Checksum of the header.
69 Zero means the header is good.
70 Non-zero means the header is bad.
73 CalculateHeaderChecksum (
74 IN EFI_FFS_FILE_HEADER
*FileHeader
77 EFI_FFS_FILE_HEADER TestFileHeader
;
79 CopyMem (&TestFileHeader
, FileHeader
, sizeof (EFI_FFS_FILE_HEADER
));
81 // Ingore State and File field in FFS header.
83 TestFileHeader
.State
= 0;
84 TestFileHeader
.IntegrityCheck
.Checksum
.File
= 0;
86 return CalculateSum8 ((CONST UINT8
*) &TestFileHeader
, sizeof (EFI_FFS_FILE_HEADER
));
90 Find FV handler according some FileHandle in that FV.
92 @param FileHandle Handle of file image
93 @param VolumeHandle Handle of the found FV, if not found, NULL will be set.
95 @retval TRUE The corresponding FV handler is found.
96 @retval FALSE The corresponding FV handler is not found.
101 PeiFileHandleToVolume (
102 IN EFI_PEI_FILE_HANDLE FileHandle
,
103 OUT EFI_PEI_FV_HANDLE
*VolumeHandle
107 PEI_CORE_INSTANCE
*PrivateData
;
108 EFI_FIRMWARE_VOLUME_HEADER
*FwVolHeader
;
110 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
111 for (Index
= 0; Index
< PrivateData
->FvCount
; Index
++) {
112 FwVolHeader
= PrivateData
->Fv
[Index
].FvHeader
;
113 if (((UINT64
) (UINTN
) FileHandle
> (UINT64
) (UINTN
) FwVolHeader
) && \
114 ((UINT64
) (UINTN
) FileHandle
<= ((UINT64
) (UINTN
) FwVolHeader
+ FwVolHeader
->FvLength
- 1))) {
115 *VolumeHandle
= (EFI_PEI_FV_HANDLE
)FwVolHeader
;
119 *VolumeHandle
= NULL
;
124 Given the input file pointer, search for the first matching file in the
125 FFS volume as defined by SearchType. The search starts from FileHeader inside
126 the Firmware Volume defined by FwVolHeader.
127 If SearchType is EFI_FV_FILETYPE_ALL, the first FFS file will return without check its file type.
128 If SearchType is PEI_CORE_INTERNAL_FFS_FILE_DISPATCH_TYPE,
129 the first PEIM, or COMBINED PEIM or FV file type FFS file will return.
131 @param FvHandle Pointer to the FV header of the volume to search
132 @param FileName File name
133 @param SearchType Filter to find only files of this type.
134 Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
135 @param FileHandle This parameter must point to a valid FFS volume.
136 @param AprioriFile Pointer to AprioriFile image in this FV if has
138 @return EFI_NOT_FOUND No files matching the search criteria were found
139 @retval EFI_SUCCESS Success to search given file
144 IN CONST EFI_PEI_FV_HANDLE FvHandle
,
145 IN CONST EFI_GUID
*FileName
, OPTIONAL
146 IN EFI_FV_FILETYPE SearchType
,
147 IN OUT EFI_PEI_FILE_HANDLE
*FileHandle
,
148 IN OUT EFI_PEI_FV_HANDLE
*AprioriFile OPTIONAL
151 EFI_FIRMWARE_VOLUME_HEADER
*FwVolHeader
;
152 EFI_FFS_FILE_HEADER
**FileHeader
;
153 EFI_FFS_FILE_HEADER
*FfsFileHeader
;
154 EFI_FIRMWARE_VOLUME_EXT_HEADER
*FwVolExHeaderInfo
;
156 UINT32 FileOccupiedSize
;
162 FwVolHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)FvHandle
;
163 FileHeader
= (EFI_FFS_FILE_HEADER
**)FileHandle
;
165 FvLength
= FwVolHeader
->FvLength
;
166 if ((FwVolHeader
->Attributes
& EFI_FVB2_ERASE_POLARITY
) != 0) {
173 // If FileHeader is not specified (NULL) or FileName is not NULL,
174 // start with the first file in the firmware volume. Otherwise,
175 // start from the FileHeader.
177 if ((*FileHeader
== NULL
) || (FileName
!= NULL
)) {
178 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FwVolHeader
+ FwVolHeader
->HeaderLength
);
179 if (FwVolHeader
->ExtHeaderOffset
!= 0) {
180 FwVolExHeaderInfo
= (EFI_FIRMWARE_VOLUME_EXT_HEADER
*)(((UINT8
*)FwVolHeader
) + FwVolHeader
->ExtHeaderOffset
);
181 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)(((UINT8
*)FwVolExHeaderInfo
) + FwVolExHeaderInfo
->ExtHeaderSize
);
185 // Length is 24 bits wide so mask upper 8 bits
186 // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
188 FileLength
= *(UINT32
*)(*FileHeader
)->Size
& 0x00FFFFFF;
189 FileOccupiedSize
= GET_OCCUPIED_SIZE (FileLength
, 8);
190 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)*FileHeader
+ FileOccupiedSize
);
193 FileOffset
= (UINT32
) ((UINT8
*)FfsFileHeader
- (UINT8
*)FwVolHeader
);
194 ASSERT (FileOffset
<= 0xFFFFFFFF);
196 while (FileOffset
< (FvLength
- sizeof (EFI_FFS_FILE_HEADER
))) {
198 // Get FileState which is the highest bit of the State
200 FileState
= GetFileState (ErasePolarity
, FfsFileHeader
);
203 case EFI_FILE_HEADER_INVALID
:
204 FileOffset
+= sizeof(EFI_FFS_FILE_HEADER
);
205 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ sizeof(EFI_FFS_FILE_HEADER
));
208 case EFI_FILE_DATA_VALID
:
209 case EFI_FILE_MARKED_FOR_UPDATE
:
210 if (CalculateHeaderChecksum (FfsFileHeader
) != 0) {
213 return EFI_NOT_FOUND
;
216 FileLength
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
217 FileOccupiedSize
= GET_OCCUPIED_SIZE(FileLength
, 8);
219 if (FileName
!= NULL
) {
220 if (CompareGuid (&FfsFileHeader
->Name
, (EFI_GUID
*)FileName
)) {
221 *FileHeader
= FfsFileHeader
;
224 } else if (SearchType
== PEI_CORE_INTERNAL_FFS_FILE_DISPATCH_TYPE
) {
225 if ((FfsFileHeader
->Type
== EFI_FV_FILETYPE_PEIM
) ||
226 (FfsFileHeader
->Type
== EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER
) ||
227 (FfsFileHeader
->Type
== EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
)) {
229 *FileHeader
= FfsFileHeader
;
231 } else if (AprioriFile
!= NULL
) {
232 if (FfsFileHeader
->Type
== EFI_FV_FILETYPE_FREEFORM
) {
233 if (CompareGuid (&FfsFileHeader
->Name
, &gPeiAprioriFileNameGuid
)) {
234 *AprioriFile
= FfsFileHeader
;
238 } else if (((SearchType
== FfsFileHeader
->Type
) || (SearchType
== EFI_FV_FILETYPE_ALL
)) &&
239 (FfsFileHeader
->Type
!= EFI_FV_FILETYPE_FFS_PAD
)) {
240 *FileHeader
= FfsFileHeader
;
244 FileOffset
+= FileOccupiedSize
;
245 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ FileOccupiedSize
);
248 case EFI_FILE_DELETED
:
249 FileLength
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
250 FileOccupiedSize
= GET_OCCUPIED_SIZE(FileLength
, 8);
251 FileOffset
+= FileOccupiedSize
;
252 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ FileOccupiedSize
);
257 return EFI_NOT_FOUND
;
262 return EFI_NOT_FOUND
;
266 Initialize PeiCore Fv List.
268 @param PrivateData - Pointer to PEI_CORE_INSTANCE.
269 @param SecCoreData - Pointer to EFI_SEC_PEI_HAND_OFF.
273 IN PEI_CORE_INSTANCE
*PrivateData
,
274 IN CONST EFI_SEC_PEI_HAND_OFF
*SecCoreData
279 // The BFV must be the first entry. The Core FV support is stateless
280 // The AllFV list has a single entry per FV in PEI.
281 // The Fv list only includes FV that PEIMs will be dispatched from and
282 // its File System Format is PI 1.0 definition.
284 PrivateData
->FvCount
= 1;
285 PrivateData
->Fv
[0].FvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)SecCoreData
->BootFirmwareVolumeBase
;
287 PrivateData
->AllFvCount
= 1;
288 PrivateData
->AllFv
[0] = (EFI_PEI_FV_HANDLE
)PrivateData
->Fv
[0].FvHeader
;
292 // Post a call-back for the FvInfoPPI services to expose
293 // additional Fvs to PeiCore.
295 Status
= PeiServicesNotifyPpi (&mNotifyOnFvInfoList
);
296 ASSERT_EFI_ERROR (Status
);
301 Process Firmware Volum Information once FvInfoPPI install.
302 The FV Info will be registered into PeiCore private data structure.
303 And search the inside FV image, if found, the new FV INFO PPI will be installed.
305 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
306 @param NotifyDescriptor Address of the notification descriptor data structure.
307 @param Ppi Address of the PPI that was installed.
309 @retval EFI_SUCCESS The FV Info is registered into PeiCore private data structure.
310 @return if not EFI_SUCESS, fail to verify FV.
315 FirmwareVolmeInfoPpiNotifyCallback (
316 IN EFI_PEI_SERVICES
**PeiServices
,
317 IN EFI_PEI_NOTIFY_DESCRIPTOR
*NotifyDescriptor
,
322 EFI_PEI_FIRMWARE_VOLUME_INFO_PPI
*Fv
;
323 PEI_CORE_INSTANCE
*PrivateData
;
324 EFI_PEI_FILE_HANDLE FileHandle
;
326 UINT32 AuthenticationStatus
;
331 Status
= EFI_SUCCESS
;
332 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
334 if (PrivateData
->FvCount
>= FixedPcdGet32 (PcdPeiCoreMaxFvSupported
)) {
338 Fv
= (EFI_PEI_FIRMWARE_VOLUME_INFO_PPI
*)Ppi
;
340 if (CompareGuid (&Fv
->FvFormat
, &gEfiFirmwareFileSystem2Guid
)) {
341 for (FvCount
= 0; FvCount
< PrivateData
->FvCount
; FvCount
++) {
342 if ((UINTN
)PrivateData
->Fv
[FvCount
].FvHeader
== (UINTN
)Fv
->FvInfo
) {
347 Status
= VerifyFv ((EFI_FIRMWARE_VOLUME_HEADER
*)Fv
->FvInfo
);
348 if (EFI_ERROR(Status
)) {
349 DEBUG ((EFI_D_ERROR
, "Fail to verify FV which address is 0x%11p", (VOID
*) Fv
->FvInfo
));
353 PrivateData
->Fv
[PrivateData
->FvCount
++].FvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)Fv
->FvInfo
;
356 // Only add FileSystem2 Fv to the All list
358 PrivateData
->AllFv
[PrivateData
->AllFvCount
++] = (EFI_PEI_FV_HANDLE
)Fv
->FvInfo
;
360 DEBUG ((EFI_D_INFO
, "The %dth FvImage start address is 0x%11p and size is 0x%08x\n", PrivateData
->AllFvCount
, (VOID
*) Fv
->FvInfo
, Fv
->FvInfoSize
));
362 // Preprocess all FV type files in this new FileSystem2 Fv image
365 Status
= PeiFindFileEx (
366 (EFI_PEI_FV_HANDLE
)Fv
->FvInfo
,
368 EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
,
372 if (!EFI_ERROR (Status
)) {
373 Status
= PeiFfsFindSectionData (
374 (CONST EFI_PEI_SERVICES
**) PeiServices
,
375 EFI_SECTION_PEI_DEPEX
,
379 if (!EFI_ERROR (Status
)) {
380 if (!PeimDispatchReadiness (PeiServices
, DepexData
)) {
382 // Dependency is not satisfied.
388 // Process FvFile to install FvInfo ppi and build FvHob
390 ProcessFvFile (PeiServices
, FileHandle
, &AuthenticationStatus
);
392 } while (FileHandle
!= NULL
);
399 Go through the file to search SectionType section.
400 Search within encapsulation sections (compression and GUIDed) recursively,
401 until the match section is found.
403 @param PeiServices - An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
404 @param SectionType - Filter to find only section of this type.
405 @param Section - From where to search.
406 @param SectionSize - The file size to search.
407 @param OutputBuffer - A pointer to the discovered section, if successful.
408 NULL if section not found
410 @return EFI_NOT_FOUND The match section is not found.
411 @return EFI_SUCCESS The match section is found.
415 PeiFfsProcessSection (
416 IN CONST EFI_PEI_SERVICES
**PeiServices
,
417 IN EFI_SECTION_TYPE SectionType
,
418 IN EFI_COMMON_SECTION_HEADER
*Section
,
419 IN UINTN SectionSize
,
420 OUT VOID
**OutputBuffer
424 UINT32 SectionLength
;
426 EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
*GuidSectionPpi
;
427 EFI_PEI_DECOMPRESS_PPI
*DecompressPpi
;
431 UINT32 Authentication
;
432 PEI_CORE_INSTANCE
*PrivateData
;
434 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
435 *OutputBuffer
= NULL
;
438 Status
= EFI_NOT_FOUND
;
441 while (ParsedLength
< SectionSize
) {
442 if (Section
->Type
== SectionType
) {
443 *OutputBuffer
= (VOID
*)(Section
+ 1);
445 } else if ((Section
->Type
== EFI_SECTION_GUID_DEFINED
) || (Section
->Type
== EFI_SECTION_COMPRESSION
)) {
447 // Check the encapsulated section is extracted into the cache data.
449 for (Index
= 0; Index
< PrivateData
->CacheSection
.AllSectionCount
; Index
++) {
450 if (Section
== PrivateData
->CacheSection
.Section
[Index
]) {
451 PpiOutput
= PrivateData
->CacheSection
.SectionData
[Index
];
452 PpiOutputSize
= PrivateData
->CacheSection
.SectionSize
[Index
];
454 // Search section directly from the cache data.
456 return PeiFfsProcessSection (
466 Status
= EFI_NOT_FOUND
;
467 if (Section
->Type
== EFI_SECTION_GUID_DEFINED
) {
468 Status
= PeiServicesLocatePpi (
469 &((EFI_GUID_DEFINED_SECTION
*)Section
)->SectionDefinitionGuid
,
472 (VOID
**) &GuidSectionPpi
474 if (!EFI_ERROR (Status
)) {
475 Status
= GuidSectionPpi
->ExtractSection (
483 } else if (Section
->Type
== EFI_SECTION_COMPRESSION
) {
484 Status
= PeiServicesLocatePpi (&gEfiPeiDecompressPpiGuid
, 0, NULL
, (VOID
**) &DecompressPpi
);
485 if (!EFI_ERROR (Status
)) {
486 Status
= DecompressPpi
->Decompress (
488 (CONST EFI_COMPRESSION_SECTION
*) Section
,
495 if (!EFI_ERROR (Status
)) {
497 // Update cache section data.
499 if (PrivateData
->CacheSection
.AllSectionCount
< CACHE_SETION_MAX_NUMBER
) {
500 PrivateData
->CacheSection
.AllSectionCount
++;
502 PrivateData
->CacheSection
.Section
[PrivateData
->CacheSection
.SectionIndex
] = Section
;
503 PrivateData
->CacheSection
.SectionData
[PrivateData
->CacheSection
.SectionIndex
] = PpiOutput
;
504 PrivateData
->CacheSection
.SectionSize
[PrivateData
->CacheSection
.SectionIndex
] = PpiOutputSize
;
505 PrivateData
->CacheSection
.SectionIndex
= (PrivateData
->CacheSection
.SectionIndex
+ 1)%CACHE_SETION_MAX_NUMBER
;
507 return PeiFfsProcessSection (
518 // Size is 24 bits wide so mask upper 8 bits.
519 // SectionLength is adjusted it is 4 byte aligned.
520 // Go to the next section
522 SectionLength
= *(UINT32
*)Section
->Size
& 0x00FFFFFF;
523 SectionLength
= GET_OCCUPIED_SIZE (SectionLength
, 4);
524 ASSERT (SectionLength
!= 0);
525 ParsedLength
+= SectionLength
;
526 Section
= (EFI_COMMON_SECTION_HEADER
*)((UINT8
*)Section
+ SectionLength
);
529 return EFI_NOT_FOUND
;
534 Given the input file pointer, search for the first matching section in the
537 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
538 @param SectionType Filter to find only sections of this type.
539 @param FileHandle Pointer to the current file to search.
540 @param SectionData A pointer to the discovered section, if successful.
541 NULL if section not found
543 @retval EFI_NOT_FOUND No files matching the search criteria were found
544 @retval EFI_SUCCESS Success to find section data in given file
549 PeiFfsFindSectionData (
550 IN CONST EFI_PEI_SERVICES
**PeiServices
,
551 IN EFI_SECTION_TYPE SectionType
,
552 IN EFI_PEI_FILE_HANDLE FileHandle
,
553 IN OUT VOID
**SectionData
556 EFI_FFS_FILE_HEADER
*FfsFileHeader
;
558 EFI_COMMON_SECTION_HEADER
*Section
;
560 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)(FileHandle
);
563 // Size is 24 bits wide so mask upper 8 bits.
564 // Does not include FfsFileHeader header size
565 // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.
567 Section
= (EFI_COMMON_SECTION_HEADER
*)(FfsFileHeader
+ 1);
568 FileSize
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
569 FileSize
-= sizeof (EFI_FFS_FILE_HEADER
);
571 return PeiFfsProcessSection (
581 Given the input file pointer, search for the next matching file in the
582 FFS volume as defined by SearchType. The search starts from FileHeader inside
583 the Firmware Volume defined by FwVolHeader.
586 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
587 @param SearchType Filter to find only files of this type.
588 Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
589 @param VolumeHandle Pointer to the FV header of the volume to search.
590 @param FileHandle Pointer to the current file from which to begin searching.
591 This pointer will be updated upon return to reflect the file found.
592 @retval EFI_NOT_FOUND No files matching the search criteria were found
593 @retval EFI_SUCCESS Success to find next file in given volume
599 IN CONST EFI_PEI_SERVICES
**PeiServices
,
601 IN EFI_PEI_FV_HANDLE VolumeHandle
,
602 IN OUT EFI_PEI_FILE_HANDLE
*FileHandle
605 return PeiFindFileEx (VolumeHandle
, NULL
, SearchType
, FileHandle
, NULL
);
610 Search the firmware volumes by index
612 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation
613 @param Instance Instance of FV to find
614 @param VolumeHandle Pointer to found Volume.
616 @retval EFI_INVALID_PARAMETER FwVolHeader is NULL
617 @retval EFI_SUCCESS Firmware volume instance successfully found.
622 PeiFvFindNextVolume (
623 IN CONST EFI_PEI_SERVICES
**PeiServices
,
625 IN OUT EFI_PEI_FV_HANDLE
*VolumeHandle
628 PEI_CORE_INSTANCE
*Private
;
631 EFI_HOB_FIRMWARE_VOLUME
*FvHob
;
633 Private
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
634 if (VolumeHandle
== NULL
) {
635 return EFI_INVALID_PARAMETER
;
639 // Handle Framework FvHob and Install FvInfo Ppi for it.
641 if (FeaturePcdGet (PcdFrameworkFvHobCompatibilitySupport
)) {
643 // Loop to search the wanted FirmwareVolume which supports FFS
645 FvHob
= (EFI_HOB_FIRMWARE_VOLUME
*)GetFirstHob (EFI_HOB_TYPE_FV
);
646 while (FvHob
!= NULL
) {
647 for (Index
= 0, Match
= FALSE
; Index
< Private
->AllFvCount
; Index
++) {
648 if ((EFI_PEI_FV_HANDLE
)(UINTN
)FvHob
->BaseAddress
== Private
->AllFv
[Index
]) {
654 // If Not Found, Install FvInfo Ppi for it.
657 PiLibInstallFvInfoPpi (
659 (VOID
*)(UINTN
)FvHob
->BaseAddress
,
660 (UINT32
)FvHob
->Length
,
665 FvHob
= (EFI_HOB_FIRMWARE_VOLUME
*)GetNextHob (EFI_HOB_TYPE_FV
, (VOID
*)((UINTN
)FvHob
+ FvHob
->Header
.HobLength
));
669 if (Instance
>= Private
->AllFvCount
) {
671 return EFI_NOT_FOUND
;
674 *VolumeHandle
= Private
->AllFv
[Instance
];
680 Find a file within a volume by its name.
682 @param FileName A pointer to the name of the file to find within the firmware volume.
683 @param VolumeHandle The firmware volume to search
684 @param FileHandle Upon exit, points to the found file's handle
685 or NULL if it could not be found.
687 @retval EFI_SUCCESS File was found.
688 @retval EFI_NOT_FOUND File was not found.
689 @retval EFI_INVALID_PARAMETER VolumeHandle or FileHandle or FileName was NULL.
694 PeiFfsFindFileByName (
695 IN CONST EFI_GUID
*FileName
,
696 IN EFI_PEI_FV_HANDLE VolumeHandle
,
697 OUT EFI_PEI_FILE_HANDLE
*FileHandle
701 if ((VolumeHandle
== NULL
) || (FileName
== NULL
) || (FileHandle
== NULL
)) {
702 return EFI_INVALID_PARAMETER
;
704 Status
= PeiFindFileEx (VolumeHandle
, FileName
, 0, FileHandle
, NULL
);
705 if (Status
== EFI_NOT_FOUND
) {
713 Returns information about a specific file.
716 @param FileHandle - The handle to file.
717 @param FileInfo - Pointer to the file information.
719 @retval EFI_INVALID_PARAMETER Invalid FileHandle or FileInfo.
720 @retval EFI_SUCCESS Success to collect file info.
726 IN EFI_PEI_FILE_HANDLE FileHandle
,
727 OUT EFI_FV_FILE_INFO
*FileInfo
732 EFI_FFS_FILE_HEADER
*FileHeader
;
733 EFI_PEI_FV_HANDLE VolumeHandle
;
735 if ((FileHandle
== NULL
) || (FileInfo
== NULL
)) {
736 return EFI_INVALID_PARAMETER
;
741 // Retrieve the FirmwareVolume which the file resides in.
743 if (!PeiFileHandleToVolume(FileHandle
, &VolumeHandle
)) {
744 return EFI_INVALID_PARAMETER
;
747 if (((EFI_FIRMWARE_VOLUME_HEADER
*)VolumeHandle
)->Attributes
& EFI_FVB2_ERASE_POLARITY
) {
754 // Get FileState which is the highest bit of the State
756 FileState
= GetFileState (ErasePolarity
, (EFI_FFS_FILE_HEADER
*)FileHandle
);
759 case EFI_FILE_DATA_VALID
:
760 case EFI_FILE_MARKED_FOR_UPDATE
:
763 return EFI_INVALID_PARAMETER
;
766 FileHeader
= (EFI_FFS_FILE_HEADER
*)FileHandle
;
767 CopyMem (&FileInfo
->FileName
, &FileHeader
->Name
, sizeof(EFI_GUID
));
768 FileInfo
->FileType
= FileHeader
->Type
;
769 FileInfo
->FileAttributes
= FileHeader
->Attributes
;
770 FileInfo
->BufferSize
= ((*(UINT32
*)FileHeader
->Size
) & 0x00FFFFFF) - sizeof (EFI_FFS_FILE_HEADER
);
771 FileInfo
->Buffer
= (FileHeader
+ 1);
778 Collect information of given Fv Volume.
780 @param VolumeHandle - The handle to Fv Volume.
781 @param VolumeInfo - The pointer to volume information.
783 @retval EFI_INVALID_PARAMETER VolumeInfo is NULL
784 @retval EFI_SUCCESS Success to collect fv info.
788 PeiFfsGetVolumeInfo (
789 IN EFI_PEI_FV_HANDLE VolumeHandle
,
790 OUT EFI_FV_INFO
*VolumeInfo
793 EFI_FIRMWARE_VOLUME_HEADER FwVolHeader
;
794 EFI_FIRMWARE_VOLUME_EXT_HEADER
*FwVolExHeaderInfo
;
796 if (VolumeInfo
== NULL
) {
797 return EFI_INVALID_PARAMETER
;
801 // VolumeHandle may not align at 8 byte,
802 // but FvLength is UINT64 type, which requires FvHeader align at least 8 byte.
803 // So, Copy FvHeader into the local FvHeader structure.
805 CopyMem (&FwVolHeader
, VolumeHandle
, sizeof (EFI_FIRMWARE_VOLUME_HEADER
));
807 // Check Fv Image Signature
809 if (FwVolHeader
.Signature
!= EFI_FVH_SIGNATURE
) {
810 return EFI_INVALID_PARAMETER
;
812 VolumeInfo
->FvAttributes
= FwVolHeader
.Attributes
;
813 VolumeInfo
->FvStart
= (VOID
*) VolumeHandle
;
814 VolumeInfo
->FvSize
= FwVolHeader
.FvLength
;
815 CopyMem (&VolumeInfo
->FvFormat
, &FwVolHeader
.FileSystemGuid
, sizeof(EFI_GUID
));
817 if (FwVolHeader
.ExtHeaderOffset
!= 0) {
818 FwVolExHeaderInfo
= (EFI_FIRMWARE_VOLUME_EXT_HEADER
*)(((UINT8
*)VolumeHandle
) + FwVolHeader
.ExtHeaderOffset
);
819 CopyMem (&VolumeInfo
->FvName
, &FwVolExHeaderInfo
->FvName
, sizeof(EFI_GUID
));
825 Get Fv image from the FV type file, then install FV INFO ppi, Build FV hob.
827 @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
828 @param FvFileHandle File handle of a Fv type file.
829 @param AuthenticationState Pointer to attestation authentication state of image.
832 @retval EFI_NOT_FOUND FV image can't be found.
833 @retval EFI_SUCCESS Successfully to process it.
834 @retval EFI_OUT_OF_RESOURCES Can not allocate page when aligning FV image
835 @retval Others Can not find EFI_SECTION_FIRMWARE_VOLUME_IMAGE section
840 IN EFI_PEI_SERVICES
**PeiServices
,
841 IN EFI_PEI_FILE_HANDLE FvFileHandle
,
842 OUT UINT32
*AuthenticationState
846 EFI_PEI_FV_HANDLE FvImageHandle
;
847 EFI_FV_INFO FvImageInfo
;
850 EFI_PEI_HOB_POINTERS HobPtr
;
853 *AuthenticationState
= 0;
856 // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has already
859 HobPtr
.Raw
= GetHobList ();
860 while ((HobPtr
.Raw
= GetNextHob (EFI_HOB_TYPE_FV2
, HobPtr
.Raw
)) != NULL
) {
861 if (CompareGuid (&(((EFI_FFS_FILE_HEADER
*)FvFileHandle
)->Name
), &HobPtr
.FirmwareVolume2
->FileName
)) {
863 // this FILE has been dispatched, it will not be dispatched again.
867 HobPtr
.Raw
= GET_NEXT_HOB (HobPtr
);
871 // Find FvImage in FvFile
873 Status
= PeiFfsFindSectionData (
874 (CONST EFI_PEI_SERVICES
**) PeiServices
,
875 EFI_SECTION_FIRMWARE_VOLUME_IMAGE
,
877 (VOID
**)&FvImageHandle
880 if (EFI_ERROR (Status
)) {
885 // Collect FvImage Info.
887 Status
= PeiFfsGetVolumeInfo (FvImageHandle
, &FvImageInfo
);
888 ASSERT_EFI_ERROR (Status
);
891 // FvAlignment must be more than 8 bytes required by FvHeader structure.
893 FvAlignment
= 1 << ((FvImageInfo
.FvAttributes
& EFI_FVB2_ALIGNMENT
) >> 16);
894 if (FvAlignment
< 8) {
901 if ((UINTN
) FvImageInfo
.FvStart
% FvAlignment
!= 0) {
902 FvBuffer
= AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINT32
) FvImageInfo
.FvSize
), FvAlignment
);
903 if (FvBuffer
== NULL
) {
904 return EFI_OUT_OF_RESOURCES
;
906 CopyMem (FvBuffer
, FvImageInfo
.FvStart
, (UINTN
) FvImageInfo
.FvSize
);
908 // Update FvImageInfo after reload FvImage to new aligned memory
910 PeiFfsGetVolumeInfo ((EFI_PEI_FV_HANDLE
) FvBuffer
, &FvImageInfo
);
914 // Install FvPpi and Build FvHob
916 PiLibInstallFvInfoPpi (
919 (UINT32
) FvImageInfo
.FvSize
,
920 &(FvImageInfo
.FvName
),
921 &(((EFI_FFS_FILE_HEADER
*)FvFileHandle
)->Name
)
925 // Inform the extracted FvImage to Fv HOB consumer phase, i.e. DXE phase
928 (EFI_PHYSICAL_ADDRESS
) (UINTN
) FvImageInfo
.FvStart
,
933 // Makes the encapsulated volume show up in DXE phase to skip processing of
934 // encapsulated file again.
937 (EFI_PHYSICAL_ADDRESS
) (UINTN
) FvImageInfo
.FvStart
,
940 &(((EFI_FFS_FILE_HEADER
*)FvFileHandle
)->Name
)