3 Copyright (c) 2006 - 2007, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 Pei Core Firmware File System service routines.
24 STATIC EFI_PEI_NOTIFY_DESCRIPTOR mNotifyOnFvInfoList
= {
25 (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST
),
26 &gEfiPeiFirmwareVolumeInfoPpiGuid
,
27 FirmwareVolmeInfoPpiNotifyCallback
31 #define GET_OCCUPIED_SIZE(ActualSize, Alignment) \
32 (ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))
37 IN UINT8 ErasePolarity
,
38 IN EFI_FFS_FILE_HEADER
*FfsHeader
44 Returns the highest bit set of the State field
48 ErasePolarity - Erase Polarity as defined by EFI_FVB2_ERASE_POLARITY
49 in the Attributes field.
50 FfsHeader - Pointer to FFS File Header.
53 Returns the highest bit in the State field
57 EFI_FFS_FILE_STATE FileState
;
58 EFI_FFS_FILE_STATE HighestBit
;
60 FileState
= FfsHeader
->State
;
62 if (ErasePolarity
!= 0) {
63 FileState
= (EFI_FFS_FILE_STATE
)~FileState
;
67 while (HighestBit
!= 0 && (HighestBit
& FileState
) == 0) {
76 CalculateHeaderChecksum (
77 IN EFI_FFS_FILE_HEADER
*FileHeader
83 Calculates the checksum of the header of a file.
87 FileHeader - Pointer to FFS File Header.
90 Checksum of the header.
92 The header is zero byte checksum.
93 - Zero means the header is good.
94 - Non-zero means the header is bad.
97 Bugbug: For PEI performance reason, we comments this code at this time.
105 ptr
= (UINT8
*)FileHeader
;
107 for (Index
= 0; Index
< sizeof(EFI_FFS_FILE_HEADER
) - 3; Index
+= 4) {
108 Sum
= (UINT8
)(Sum
+ ptr
[Index
]);
109 Sum
= (UINT8
)(Sum
+ ptr
[Index
+1]);
110 Sum
= (UINT8
)(Sum
+ ptr
[Index
+2]);
111 Sum
= (UINT8
)(Sum
+ ptr
[Index
+3]);
114 for (; Index
< sizeof(EFI_FFS_FILE_HEADER
); Index
++) {
115 Sum
= (UINT8
)(Sum
+ ptr
[Index
]);
119 // State field (since this indicates the different state of file).
121 Sum
= (UINT8
)(Sum
- FileHeader
->State
);
123 // Checksum field of the file is not part of the header checksum.
125 Sum
= (UINT8
)(Sum
- FileHeader
->IntegrityCheck
.Checksum
.File
);
133 PeiFileHandleToVolume (
134 IN EFI_PEI_FILE_HANDLE FileHandle
,
135 OUT EFI_PEI_FV_HANDLE
*VolumeHandle
139 PEI_CORE_INSTANCE
*PrivateData
;
140 EFI_FIRMWARE_VOLUME_HEADER
*FwVolHeader
;
142 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());
143 for (Index
= 0; Index
< PrivateData
->FvCount
; Index
++) {
144 FwVolHeader
= PrivateData
->Fv
[Index
].FvHeader
;
145 if (((UINT64
) (UINTN
) FileHandle
> (UINT64
) (UINTN
) FwVolHeader
) && \
146 ((UINT64
) (UINTN
) FileHandle
<= ((UINT64
) (UINTN
) FwVolHeader
+ FwVolHeader
->FvLength
- 1))) {
147 *VolumeHandle
= (EFI_PEI_FV_HANDLE
)FwVolHeader
;
157 IN CONST EFI_PEI_FV_HANDLE FvHandle
,
158 IN CONST EFI_GUID
*FileName
, OPTIONAL
159 IN EFI_FV_FILETYPE SearchType
,
160 IN OUT EFI_PEI_FILE_HANDLE
*FileHandle
,
161 IN OUT EFI_PEI_FV_HANDLE
*AprioriFile OPTIONAL
166 Given the input file pointer, search for the next matching file in the
167 FFS volume as defined by SearchType. The search starts from FileHeader inside
168 the Firmware Volume defined by FwVolHeader.
171 PeiServices - Pointer to the PEI Core Services Table.
172 SearchType - Filter to find only files of this type.
173 Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
174 FwVolHeader - Pointer to the FV header of the volume to search.
175 This parameter must point to a valid FFS volume.
176 FileHeader - Pointer to the current file from which to begin searching.
177 This pointer will be updated upon return to reflect the file found.
178 Flag - Indicator for if this is for PEI Dispath search
181 EFI_NOT_FOUND - No files matching the search criteria were found
186 EFI_FIRMWARE_VOLUME_HEADER
*FwVolHeader
;
187 EFI_FFS_FILE_HEADER
**FileHeader
;
188 EFI_FFS_FILE_HEADER
*FfsFileHeader
;
189 EFI_FIRMWARE_VOLUME_EXT_HEADER
*FwVolExHeaderInfo
;
191 UINT32 FileOccupiedSize
;
197 FwVolHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)FvHandle
;
198 FileHeader
= (EFI_FFS_FILE_HEADER
**)FileHandle
;
200 FvLength
= FwVolHeader
->FvLength
;
201 if (FwVolHeader
->Attributes
& EFI_FVB2_ERASE_POLARITY
) {
208 // If FileHeader is not specified (NULL) or FileName is not NULL,
209 // start with the first file in the firmware volume. Otherwise,
210 // start from the FileHeader.
212 if ((*FileHeader
== NULL
) || (FileName
!= NULL
)) {
213 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FwVolHeader
+ FwVolHeader
->HeaderLength
);
214 if (FwVolHeader
->ExtHeaderOffset
!= 0) {
215 FwVolExHeaderInfo
= (EFI_FIRMWARE_VOLUME_EXT_HEADER
*)(((UINT8
*)FwVolHeader
) + FwVolHeader
->ExtHeaderOffset
);
216 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)(((UINT8
*)FwVolExHeaderInfo
) + FwVolExHeaderInfo
->ExtHeaderSize
);
220 // Length is 24 bits wide so mask upper 8 bits
221 // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
223 FileLength
= *(UINT32
*)(*FileHeader
)->Size
& 0x00FFFFFF;
224 FileOccupiedSize
= GET_OCCUPIED_SIZE (FileLength
, 8);
225 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)*FileHeader
+ FileOccupiedSize
);
228 FileOffset
= (UINT32
) ((UINT8
*)FfsFileHeader
- (UINT8
*)FwVolHeader
);
229 ASSERT (FileOffset
<= 0xFFFFFFFF);
231 while (FileOffset
< (FvLength
- sizeof (EFI_FFS_FILE_HEADER
))) {
233 // Get FileState which is the highest bit of the State
235 FileState
= GetFileState (ErasePolarity
, FfsFileHeader
);
238 case EFI_FILE_HEADER_INVALID
:
239 FileOffset
+= sizeof(EFI_FFS_FILE_HEADER
);
240 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ sizeof(EFI_FFS_FILE_HEADER
));
243 case EFI_FILE_DATA_VALID
:
244 case EFI_FILE_MARKED_FOR_UPDATE
:
245 if (CalculateHeaderChecksum (FfsFileHeader
) != 0) {
248 return EFI_NOT_FOUND
;
251 FileLength
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
252 FileOccupiedSize
= GET_OCCUPIED_SIZE(FileLength
, 8);
254 if (FileName
!= NULL
) {
255 if (CompareGuid (&FfsFileHeader
->Name
, (EFI_GUID
*)FileName
)) {
256 *FileHeader
= FfsFileHeader
;
259 } else if (SearchType
== PEI_CORE_INTERNAL_FFS_FILE_DISPATCH_TYPE
) {
260 if ((FfsFileHeader
->Type
== EFI_FV_FILETYPE_PEIM
) ||
261 (FfsFileHeader
->Type
== EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER
) ||
262 (FfsFileHeader
->Type
== EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
)) {
264 *FileHeader
= FfsFileHeader
;
266 } else if (AprioriFile
!= NULL
) {
267 if (FfsFileHeader
->Type
== EFI_FV_FILETYPE_FREEFORM
) {
268 if (CompareGuid (&FfsFileHeader
->Name
, &gPeiAprioriFileNameGuid
)) {
269 *AprioriFile
= FfsFileHeader
;
273 } else if (((SearchType
== FfsFileHeader
->Type
) || (SearchType
== EFI_FV_FILETYPE_ALL
)) &&
274 (FfsFileHeader
->Type
!= EFI_FV_FILETYPE_FFS_PAD
)) {
275 *FileHeader
= FfsFileHeader
;
279 FileOffset
+= FileOccupiedSize
;
280 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ FileOccupiedSize
);
283 case EFI_FILE_DELETED
:
284 FileLength
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
285 FileOccupiedSize
= GET_OCCUPIED_SIZE(FileLength
, 8);
286 FileOffset
+= FileOccupiedSize
;
287 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)((UINT8
*)FfsFileHeader
+ FileOccupiedSize
);
292 return EFI_NOT_FOUND
;
297 return EFI_NOT_FOUND
;
302 IN PEI_CORE_INSTANCE
*PrivateData
,
303 IN CONST EFI_SEC_PEI_HAND_OFF
*SecCoreData
309 Initialize PeiCore Fv List.
312 PrivateData - Pointer to PEI_CORE_INSTANCE.
313 SecCoreData - Pointer to EFI_SEC_PEI_HAND_OFF.
322 // The BFV must be the first entry. The Core FV support is stateless
323 // The AllFV list has a single entry per FV in PEI.
324 // The Fv list only includes FV that PEIMs will be dispatched from and
325 // its File System Format is PI 1.0 definition.
327 PrivateData
->FvCount
= 1;
328 PrivateData
->Fv
[0].FvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)SecCoreData
->BootFirmwareVolumeBase
;
330 PrivateData
->AllFvCount
= 1;
331 PrivateData
->AllFv
[0] = (EFI_PEI_FV_HANDLE
)PrivateData
->Fv
[0].FvHeader
;
335 // Post a call-back for the FvInfoPPI services to expose
336 // additional Fvs to PeiCore.
338 Status
= PeiServicesNotifyPpi (&mNotifyOnFvInfoList
);
339 ASSERT_EFI_ERROR (Status
);
345 FirmwareVolmeInfoPpiNotifyCallback (
346 IN EFI_PEI_SERVICES
**PeiServices
,
347 IN EFI_PEI_NOTIFY_DESCRIPTOR
*NotifyDescriptor
,
354 Process Firmware Volum Information once FvInfoPPI install.
358 PeiServices - General purpose services available to every PEIM.
362 Status - EFI_SUCCESS if the interface could be successfully
368 EFI_PEI_FIRMWARE_VOLUME_INFO_PPI
*Fv
;
369 PEI_CORE_INSTANCE
*PrivateData
;
370 EFI_PEI_FILE_HANDLE FileHandle
;
372 UINT32 AuthenticationStatus
;
377 Status
= EFI_SUCCESS
;
378 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
380 if (PrivateData
->FvCount
>= FixedPcdGet32 (PcdPeiCoreMaxFvSupported
)) {
384 Fv
= (EFI_PEI_FIRMWARE_VOLUME_INFO_PPI
*)Ppi
;
386 if (CompareGuid (&Fv
->FvFormat
, &gEfiFirmwareFileSystem2Guid
)) {
387 for (FvCount
= 0; FvCount
< PrivateData
->FvCount
; FvCount
++) {
388 if ((UINTN
)PrivateData
->Fv
[FvCount
].FvHeader
== (UINTN
)Fv
->FvInfo
) {
392 PrivateData
->Fv
[PrivateData
->FvCount
++].FvHeader
= (EFI_FIRMWARE_VOLUME_HEADER
*)Fv
->FvInfo
;
395 // Only add FileSystem2 Fv to the All list
397 PrivateData
->AllFv
[PrivateData
->AllFvCount
++] = (EFI_PEI_FV_HANDLE
)Fv
->FvInfo
;
399 DEBUG ((EFI_D_INFO
, "The %dth FvImage start address is 0x%10p and size is 0x%08x\n", PrivateData
->AllFvCount
, (VOID
*) Fv
->FvInfo
, Fv
->FvInfoSize
));
401 // Preprocess all FV type files in this new FileSystem2 Fv image
404 Status
= PeiFindFileEx (
405 (EFI_PEI_FV_HANDLE
)Fv
->FvInfo
,
407 EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE
,
411 if (!EFI_ERROR (Status
)) {
412 Status
= PeiFfsFindSectionData (
413 (CONST EFI_PEI_SERVICES
**) PeiServices
,
414 EFI_SECTION_PEI_DEPEX
,
418 if (!EFI_ERROR (Status
)) {
419 if (!PeimDispatchReadiness (PeiServices
, DepexData
)) {
421 // Dependency is not satisfied.
427 // Process FvFile to install FvInfo ppi and build FvHob
429 ProcessFvFile (PeiServices
, FileHandle
, &AuthenticationStatus
);
431 } while (FileHandle
!= NULL
);
438 PeiFfsProcessSection (
439 IN CONST EFI_PEI_SERVICES
**PeiServices
,
440 IN EFI_SECTION_TYPE SectionType
,
441 IN EFI_COMMON_SECTION_HEADER
*Section
,
442 IN UINTN SectionSize
,
443 OUT VOID
**OutputBuffer
449 Go through the file to search SectionType section,
450 when meeting an encapsuled section.
453 PeiServices - General purpose services available to every PEIM.
454 SearchType - Filter to find only section of this type.
455 Section - From where to search.
456 SectionSize - The file size to search.
457 OutputBuffer - Pointer to the section to search.
465 UINT32 SectionLength
;
467 EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
*GuidSectionPpi
;
468 EFI_PEI_DECOMPRESS_PPI
*DecompressPpi
;
472 UINT32 Authentication
;
473 PEI_CORE_INSTANCE
*PrivateData
;
475 PrivateData
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
476 *OutputBuffer
= NULL
;
479 Status
= EFI_NOT_FOUND
;
482 while (ParsedLength
< SectionSize
) {
483 if (Section
->Type
== SectionType
) {
484 *OutputBuffer
= (VOID
*)(Section
+ 1);
486 } else if ((Section
->Type
== EFI_SECTION_GUID_DEFINED
) || (Section
->Type
== EFI_SECTION_COMPRESSION
)) {
488 // Check the encapsulated section is extracted into the cache data.
490 for (Index
= 0; Index
< PrivateData
->CacheSection
.AllSectionCount
; Index
++) {
491 if (Section
== PrivateData
->CacheSection
.Section
[Index
]) {
492 PpiOutput
= PrivateData
->CacheSection
.SectionData
[Index
];
493 PpiOutputSize
= PrivateData
->CacheSection
.SectionSize
[Index
];
495 // Search section directly from the cache data.
497 return PeiFfsProcessSection (
507 Status
= EFI_NOT_FOUND
;
508 if (Section
->Type
== EFI_SECTION_GUID_DEFINED
) {
509 Status
= PeiServicesLocatePpi (
510 &((EFI_GUID_DEFINED_SECTION
*)Section
)->SectionDefinitionGuid
,
513 (VOID
**) &GuidSectionPpi
515 if (!EFI_ERROR (Status
)) {
516 Status
= GuidSectionPpi
->ExtractSection (
524 } else if (Section
->Type
== EFI_SECTION_COMPRESSION
) {
525 Status
= PeiServicesLocatePpi (&gEfiPeiDecompressPpiGuid
, 0, NULL
, (VOID
**) &DecompressPpi
);
526 if (!EFI_ERROR (Status
)) {
527 Status
= DecompressPpi
->Decompress (
529 (CONST EFI_COMPRESSION_SECTION
*) Section
,
536 if (!EFI_ERROR (Status
)) {
538 // Update cache section data.
540 if (PrivateData
->CacheSection
.AllSectionCount
< CACHE_SETION_MAX_NUMBER
) {
541 PrivateData
->CacheSection
.AllSectionCount
++;
543 PrivateData
->CacheSection
.Section
[PrivateData
->CacheSection
.SectionIndex
] = Section
;
544 PrivateData
->CacheSection
.SectionData
[PrivateData
->CacheSection
.SectionIndex
] = PpiOutput
;
545 PrivateData
->CacheSection
.SectionSize
[PrivateData
->CacheSection
.SectionIndex
] = PpiOutputSize
;
546 PrivateData
->CacheSection
.SectionIndex
= (PrivateData
->CacheSection
.SectionIndex
+ 1)%CACHE_SETION_MAX_NUMBER
;
548 return PeiFfsProcessSection (
559 // Size is 24 bits wide so mask upper 8 bits.
560 // SectionLength is adjusted it is 4 byte aligned.
561 // Go to the next section
563 SectionLength
= *(UINT32
*)Section
->Size
& 0x00FFFFFF;
564 SectionLength
= GET_OCCUPIED_SIZE (SectionLength
, 4);
565 ASSERT (SectionLength
!= 0);
566 ParsedLength
+= SectionLength
;
567 Section
= (EFI_COMMON_SECTION_HEADER
*)((UINT8
*)Section
+ SectionLength
);
570 return EFI_NOT_FOUND
;
576 PeiFfsFindSectionData (
577 IN CONST EFI_PEI_SERVICES
**PeiServices
,
578 IN EFI_SECTION_TYPE SectionType
,
579 IN EFI_PEI_FILE_HANDLE FileHandle
,
580 IN OUT VOID
**SectionData
585 Given the input file pointer, search for the next matching section in the
589 PeiServices - Pointer to the PEI Core Services Table.
590 SearchType - Filter to find only sections of this type.
591 FfsFileHeader - Pointer to the current file to search.
592 SectionData - Pointer to the Section matching SectionType in FfsFileHeader.
593 - NULL if section not found
596 EFI_NOT_FOUND - No files matching the search criteria were found
601 EFI_FFS_FILE_HEADER
*FfsFileHeader
;
603 EFI_COMMON_SECTION_HEADER
*Section
;
605 FfsFileHeader
= (EFI_FFS_FILE_HEADER
*)(FileHandle
);
608 // Size is 24 bits wide so mask upper 8 bits.
609 // Does not include FfsFileHeader header size
610 // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.
612 Section
= (EFI_COMMON_SECTION_HEADER
*)(FfsFileHeader
+ 1);
613 FileSize
= *(UINT32
*)(FfsFileHeader
->Size
) & 0x00FFFFFF;
614 FileSize
-= sizeof (EFI_FFS_FILE_HEADER
);
616 return PeiFfsProcessSection (
629 IN CONST EFI_PEI_SERVICES
**PeiServices
,
631 IN EFI_PEI_FV_HANDLE VolumeHandle
,
632 IN OUT EFI_PEI_FILE_HANDLE
*FileHandle
637 Given the input file pointer, search for the next matching file in the
638 FFS volume as defined by SearchType. The search starts from FileHeader inside
639 the Firmware Volume defined by FwVolHeader.
642 PeiServices - Pointer to the PEI Core Services Table.
644 SearchType - Filter to find only files of this type.
645 Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
647 FwVolHeader - Pointer to the FV header of the volume to search.
648 This parameter must point to a valid FFS volume.
650 FileHeader - Pointer to the current file from which to begin searching.
651 This pointer will be updated upon return to reflect the file found.
654 EFI_NOT_FOUND - No files matching the search criteria were found
659 return PeiFindFileEx (VolumeHandle
, NULL
, SearchType
, FileHandle
, NULL
);
665 PeiFvFindNextVolume (
666 IN CONST EFI_PEI_SERVICES
**PeiServices
,
668 IN OUT EFI_PEI_FV_HANDLE
*VolumeHandle
674 Return the firmware volumes.
676 BugBug -- Move this to the location of this code to where the
677 other FV and FFS support code lives.
678 Also, update to use FindFV for instances #'s >= 1.
682 PeiServices - The PEI core services table.
683 Instance - Instance of FV to find
684 FwVolHeader - Pointer to contain the data to return
687 Pointer to the Firmware Volume instance requested
689 EFI_INVALID_PARAMETER - FwVolHeader is NULL
691 EFI_SUCCESS - Firmware volume instance successfully found.
695 PEI_CORE_INSTANCE
*Private
;
697 Private
= PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices
);
698 if (VolumeHandle
== NULL
) {
699 return EFI_INVALID_PARAMETER
;
702 if (Instance
>= Private
->AllFvCount
) {
704 return EFI_NOT_FOUND
;
707 *VolumeHandle
= Private
->AllFv
[Instance
];
714 PeiFfsFindFileByName (
715 IN CONST EFI_GUID
*FileName
,
716 IN EFI_PEI_FV_HANDLE VolumeHandle
,
717 OUT EFI_PEI_FILE_HANDLE
*FileHandle
723 Given the input VolumeHandle, search for the next matching name file.
727 FileName - File name to search.
728 VolumeHandle - The current FV to search.
729 FileHandle - Pointer to the file matching name in VolumeHandle.
730 - NULL if file not found
737 if ((VolumeHandle
== NULL
) || (FileName
== NULL
) || (FileHandle
== NULL
)) {
738 return EFI_INVALID_PARAMETER
;
740 Status
= PeiFindFileEx (VolumeHandle
, FileName
, 0, FileHandle
, NULL
);
741 if (Status
== EFI_NOT_FOUND
) {
750 IN EFI_PEI_FILE_HANDLE FileHandle
,
751 OUT EFI_FV_FILE_INFO
*FileInfo
757 Collect information of given file.
760 FileHandle - The handle to file.
761 FileInfo - Pointer to the file information.
770 EFI_FFS_FILE_HEADER
*FileHeader
;
771 EFI_PEI_FV_HANDLE VolumeHandle
;
773 if ((FileHandle
== NULL
) || (FileInfo
== NULL
)) {
774 return EFI_INVALID_PARAMETER
;
779 // Retrieve the FirmwareVolume which the file resides in.
781 if (!PeiFileHandleToVolume(FileHandle
, &VolumeHandle
)) {
782 return EFI_INVALID_PARAMETER
;
785 if (((EFI_FIRMWARE_VOLUME_HEADER
*)VolumeHandle
)->Attributes
& EFI_FVB2_ERASE_POLARITY
) {
792 // Get FileState which is the highest bit of the State
794 FileState
= GetFileState (ErasePolarity
, (EFI_FFS_FILE_HEADER
*)FileHandle
);
797 case EFI_FILE_DATA_VALID
:
798 case EFI_FILE_MARKED_FOR_UPDATE
:
801 return EFI_INVALID_PARAMETER
;
804 FileHeader
= (EFI_FFS_FILE_HEADER
*)FileHandle
;
805 CopyMem (&FileInfo
->FileName
, &FileHeader
->Name
, sizeof(EFI_GUID
));
806 FileInfo
->FileType
= FileHeader
->Type
;
807 FileInfo
->FileAttributes
= FileHeader
->Attributes
;
808 FileInfo
->BufferSize
= ((*(UINT32
*)FileHeader
->Size
) & 0x00FFFFFF) - sizeof (EFI_FFS_FILE_HEADER
);
809 FileInfo
->Buffer
= (FileHeader
+ 1);
816 PeiFfsGetVolumeInfo (
817 IN EFI_PEI_FV_HANDLE VolumeHandle
,
818 OUT EFI_FV_INFO
*VolumeInfo
824 Collect information of given Fv Volume.
827 VolumeHandle - The handle to Fv Volume.
828 VolumeInfo - The pointer to volume information.
835 EFI_FIRMWARE_VOLUME_HEADER FwVolHeader
;
836 EFI_FIRMWARE_VOLUME_EXT_HEADER
*FwVolExHeaderInfo
;
838 if (VolumeInfo
== NULL
) {
839 return EFI_INVALID_PARAMETER
;
843 // VolumeHandle may not align at 8 byte,
844 // but FvLength is UINT64 type, which requires FvHeader align at least 8 byte.
845 // So, Copy FvHeader into the local FvHeader structure.
847 CopyMem (&FwVolHeader
, VolumeHandle
, sizeof (EFI_FIRMWARE_VOLUME_HEADER
));
849 // Check Fv Image Signature
851 if (FwVolHeader
.Signature
!= EFI_FVH_SIGNATURE
) {
852 return EFI_INVALID_PARAMETER
;
854 VolumeInfo
->FvAttributes
= FwVolHeader
.Attributes
;
855 VolumeInfo
->FvStart
= (VOID
*) VolumeHandle
;
856 VolumeInfo
->FvSize
= FwVolHeader
.FvLength
;
857 CopyMem (&VolumeInfo
->FvFormat
, &FwVolHeader
.FileSystemGuid
, sizeof(EFI_GUID
));
859 if (FwVolHeader
.ExtHeaderOffset
!= 0) {
860 FwVolExHeaderInfo
= (EFI_FIRMWARE_VOLUME_EXT_HEADER
*)(((UINT8
*)VolumeHandle
) + FwVolHeader
.ExtHeaderOffset
);
861 CopyMem (&VolumeInfo
->FvName
, &FwVolExHeaderInfo
->FvName
, sizeof(EFI_GUID
));