]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Core/Pei/FwVol/FwVol.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
1) Make PEI PI File system service to skip PAD file
[mirror_edk2.git] / MdeModulePkg / Core / Pei / FwVol / FwVol.c
1 /*++
2
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
8
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.
11
12 Module Name:
13
14 FwVol.c
15
16 Abstract:
17
18 Pei Core Firmware File System service routines.
19
20 --*/
21
22 #include <PeiMain.h>
23
24 STATIC EFI_PEI_NOTIFY_DESCRIPTOR mNotifyOnFvInfoList = {
25 (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
26 &gEfiPeiFirmwareVolumeInfoPpiGuid,
27 FirmwareVolmeInfoPpiNotifyCallback
28 };
29
30
31 #define GET_OCCUPIED_SIZE(ActualSize, Alignment) \
32 (ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))
33
34 STATIC
35 EFI_FFS_FILE_STATE
36 GetFileState(
37 IN UINT8 ErasePolarity,
38 IN EFI_FFS_FILE_HEADER *FfsHeader
39 )
40 /*++
41
42 Routine Description:
43
44 Returns the highest bit set of the State field
45
46 Arguments:
47
48 ErasePolarity - Erase Polarity as defined by EFI_FVB2_ERASE_POLARITY
49 in the Attributes field.
50 FfsHeader - Pointer to FFS File Header.
51
52 Returns:
53 Returns the highest bit in the State field
54
55 --*/
56 {
57 EFI_FFS_FILE_STATE FileState;
58 EFI_FFS_FILE_STATE HighestBit;
59
60 FileState = FfsHeader->State;
61
62 if (ErasePolarity != 0) {
63 FileState = (EFI_FFS_FILE_STATE)~FileState;
64 }
65
66 HighestBit = 0x80;
67 while (HighestBit != 0 && (HighestBit & FileState) == 0) {
68 HighestBit >>= 1;
69 }
70
71 return HighestBit;
72 }
73
74 STATIC
75 UINT8
76 CalculateHeaderChecksum (
77 IN EFI_FFS_FILE_HEADER *FileHeader
78 )
79 /*++
80
81 Routine Description:
82
83 Calculates the checksum of the header of a file.
84
85 Arguments:
86
87 FileHeader - Pointer to FFS File Header.
88
89 Returns:
90 Checksum of the header.
91
92 The header is zero byte checksum.
93 - Zero means the header is good.
94 - Non-zero means the header is bad.
95
96
97 Bugbug: For PEI performance reason, we comments this code at this time.
98 --*/
99 {
100 UINT8 *ptr;
101 UINTN Index;
102 UINT8 Sum;
103
104 Sum = 0;
105 ptr = (UINT8 *)FileHeader;
106
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]);
112 }
113
114 for (; Index < sizeof(EFI_FFS_FILE_HEADER); Index++) {
115 Sum = (UINT8)(Sum + ptr[Index]);
116 }
117
118 //
119 // State field (since this indicates the different state of file).
120 //
121 Sum = (UINT8)(Sum - FileHeader->State);
122 //
123 // Checksum field of the file is not part of the header checksum.
124 //
125 Sum = (UINT8)(Sum - FileHeader->IntegrityCheck.Checksum.File);
126
127 return Sum;
128 }
129
130 STATIC
131 BOOLEAN
132 EFIAPI
133 PeiFileHandleToVolume (
134 IN EFI_PEI_FILE_HANDLE FileHandle,
135 OUT EFI_PEI_FV_HANDLE *VolumeHandle
136 )
137 {
138 UINTN Index;
139 PEI_CORE_INSTANCE *PrivateData;
140 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
141
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;
148 return TRUE;
149 }
150 }
151 return FALSE;
152 }
153
154
155 EFI_STATUS
156 PeiFindFileEx (
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
162 )
163 /*++
164
165 Routine Description:
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.
169
170 Arguments:
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
179
180 Returns:
181 EFI_NOT_FOUND - No files matching the search criteria were found
182 EFI_SUCCESS
183
184 --*/
185 {
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;
190 UINT32 FileLength;
191 UINT32 FileOccupiedSize;
192 UINT32 FileOffset;
193 UINT64 FvLength;
194 UINT8 ErasePolarity;
195 UINT8 FileState;
196
197 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)FvHandle;
198 FileHeader = (EFI_FFS_FILE_HEADER **)FileHandle;
199
200 FvLength = FwVolHeader->FvLength;
201 if (FwVolHeader->Attributes & EFI_FVB_ERASE_POLARITY) {
202 ErasePolarity = 1;
203 } else {
204 ErasePolarity = 0;
205 }
206
207 //
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.
211 //
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);
217 }
218 } else {
219 //
220 // Length is 24 bits wide so mask upper 8 bits
221 // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
222 //
223 FileLength = *(UINT32 *)(*FileHeader)->Size & 0x00FFFFFF;
224 FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
225 FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)*FileHeader + FileOccupiedSize);
226 }
227
228 FileOffset = (UINT32) ((UINT8 *)FfsFileHeader - (UINT8 *)FwVolHeader);
229 ASSERT (FileOffset <= 0xFFFFFFFF);
230
231 while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {
232 //
233 // Get FileState which is the highest bit of the State
234 //
235 FileState = GetFileState (ErasePolarity, FfsFileHeader);
236 switch (FileState) {
237
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));
241 break;
242
243 case EFI_FILE_DATA_VALID:
244 case EFI_FILE_MARKED_FOR_UPDATE:
245 if (CalculateHeaderChecksum (FfsFileHeader) != 0) {
246 ASSERT (FALSE);
247 *FileHeader = NULL;
248 return EFI_NOT_FOUND;
249 }
250
251 FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
252 FileOccupiedSize = GET_OCCUPIED_SIZE(FileLength, 8);
253
254 if (FileName != NULL) {
255 if (CompareGuid (&FfsFileHeader->Name, (EFI_GUID*)FileName)) {
256 *FileHeader = FfsFileHeader;
257 return EFI_SUCCESS;
258 }
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
263 *FileHeader = FfsFileHeader;
264 return EFI_SUCCESS;
265 } else if (AprioriFile != NULL) {
266 if (FfsFileHeader->Type == EFI_FV_FILETYPE_FREEFORM) {
267 if (CompareGuid (&FfsFileHeader->Name, &gPeiAprioriFileNameGuid)) {
268 *AprioriFile = FfsFileHeader;
269 }
270 }
271 }
272 } else if (((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) &&
273 (FfsFileHeader->Type != EFI_FV_FILETYPE_FFS_PAD)) {
274 *FileHeader = FfsFileHeader;
275 return EFI_SUCCESS;
276 }
277
278 FileOffset += FileOccupiedSize;
279 FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
280 break;
281
282 case EFI_FILE_DELETED:
283 FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
284 FileOccupiedSize = GET_OCCUPIED_SIZE(FileLength, 8);
285 FileOffset += FileOccupiedSize;
286 FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
287 break;
288
289 default:
290 *FileHeader = NULL;
291 return EFI_NOT_FOUND;
292 }
293 }
294
295 *FileHeader = NULL;
296 return EFI_NOT_FOUND;
297 }
298
299 VOID
300 PeiInitializeFv (
301 IN PEI_CORE_INSTANCE *PrivateData,
302 IN CONST EFI_SEC_PEI_HAND_OFF *SecCoreData
303 )
304 /*++
305
306 Routine Description:
307
308 Initialize PeiCore Fv List.
309
310 Arguments:
311 PrivateData - Pointer to PEI_CORE_INSTANCE.
312 SecCoreData - Pointer to EFI_SEC_PEI_HAND_OFF.
313
314 Returns:
315 NONE
316
317 --*/
318 {
319 EFI_STATUS Status;
320 //
321 // The BFV must be the first entry. The Core FV support is stateless
322 // The AllFV list has a single entry per FV in PEI.
323 // The Fv list only includes FV that PEIMs will be dispatched from and
324 // its File System Format is PI 1.0 definition.
325 //
326 PrivateData->FvCount = 1;
327 PrivateData->Fv[0].FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)SecCoreData->BootFirmwareVolumeBase;
328
329 PrivateData->AllFvCount = 1;
330 PrivateData->AllFv[0] = (EFI_PEI_FV_HANDLE)PrivateData->Fv[0].FvHeader;
331
332
333 //
334 // Post a call-back for the FvInfoPPI services to expose
335 // additional Fvs to PeiCore.
336 //
337 Status = PeiServicesNotifyPpi (&mNotifyOnFvInfoList);
338 ASSERT_EFI_ERROR (Status);
339
340 }
341
342 EFI_STATUS
343 EFIAPI
344 FirmwareVolmeInfoPpiNotifyCallback (
345 IN EFI_PEI_SERVICES **PeiServices,
346 IN EFI_PEI_NOTIFY_DESCRIPTOR *NotifyDescriptor,
347 IN VOID *Ppi
348 )
349 /*++
350
351 Routine Description:
352
353 Process Firmware Volum Information once FvInfoPPI install.
354
355 Arguments:
356
357 PeiServices - General purpose services available to every PEIM.
358
359 Returns:
360
361 Status - EFI_SUCCESS if the interface could be successfully
362 installed
363
364 --*/
365 {
366 UINT8 FvCount;
367 EFI_PEI_FIRMWARE_VOLUME_INFO_PPI *Fv;
368 PEI_CORE_INSTANCE *PrivateData;
369
370 PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
371
372 if (PrivateData->FvCount >= FixedPcdGet32 (PcdPeiCoreMaxFvSupported)) {
373 ASSERT (FALSE);
374 }
375
376 Fv = (EFI_PEI_FIRMWARE_VOLUME_INFO_PPI *)Ppi;
377
378 if (CompareGuid (&Fv->FvFormat, &gEfiFirmwareFileSystem2Guid)) {
379 for (FvCount = 0; FvCount < PrivateData->FvCount; FvCount ++) {
380 if ((UINTN)PrivateData->Fv[FvCount].FvHeader == (UINTN)Fv->FvInfo) {
381 return EFI_SUCCESS;
382 }
383 }
384 PrivateData->Fv[PrivateData->FvCount++].FvHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Fv->FvInfo;
385 }
386
387 //
388 // Allways add to the All list
389 //
390 PrivateData->AllFv[PrivateData->AllFvCount++] = (EFI_PEI_FV_HANDLE)Fv->FvInfo;
391
392 return EFI_SUCCESS;
393 }
394
395 EFI_STATUS
396 PeiFfsProcessSection (
397 IN CONST EFI_PEI_SERVICES **PeiServices,
398 IN EFI_SECTION_TYPE SectionType,
399 IN EFI_COMMON_SECTION_HEADER *Section,
400 IN UINTN SectionSize,
401 OUT VOID **OutputBuffer,
402 OUT UINTN *OutputSize,
403 OUT UINT32 *Authentication
404 )
405 /*++
406
407 Routine Description:
408
409 Go through the file to search SectionType section,
410 when meeting an encapsuled section, search recursively.
411
412 Arguments:
413 PeiServices - Pointer to the PEI Core Services Table.
414 SearchType - Filter to find only section of this type.
415 Section - From where to search.
416 SectionSize - The file size to search.
417 OutputBuffer - Pointer to the section to search.
418 OutputSize - The size of the section to search.
419 Authentication - Authenticate the section.
420
421 Returns:
422 EFI_STATUS
423
424 --*/
425 {
426 EFI_STATUS Status;
427 UINT32 SectionLength;
428 UINT32 ParsedLength;
429 EFI_GUID_DEFINED_SECTION *GuidSection;
430 EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI *GuidSectionPpi;
431 EFI_COMPRESSION_SECTION *CompressionSection;
432 EFI_PEI_DECOMPRESS_PPI *DecompressPpi;
433 VOID *PpiOutput;
434 UINTN PpiOutputSize;
435
436 *OutputBuffer = NULL;
437 ParsedLength = 0;
438 while (ParsedLength < SectionSize) {
439 if (Section->Type == SectionType) {
440 *OutputBuffer = (VOID *)(Section + 1);
441 return EFI_SUCCESS;
442 } else if (Section->Type == EFI_SECTION_GUID_DEFINED) {
443 GuidSection = (EFI_GUID_DEFINED_SECTION *)Section;
444 Status = PeiServicesLocatePpi (&GuidSection->SectionDefinitionGuid, 0, NULL, (VOID **) &GuidSectionPpi);
445 if (!EFI_ERROR (Status)) {
446 Status = GuidSectionPpi->ExtractSection (
447 GuidSectionPpi,
448 Section,
449 &PpiOutput,
450 &PpiOutputSize,
451 Authentication
452 );
453 if (!EFI_ERROR (Status)) {
454 return PeiFfsProcessSection (
455 PeiServices,
456 SectionType,
457 PpiOutput,
458 PpiOutputSize,
459 OutputBuffer,
460 OutputSize,
461 Authentication
462 );
463 }
464 }
465 } else if (Section->Type == EFI_SECTION_COMPRESSION) {
466 CompressionSection = (EFI_COMPRESSION_SECTION *)Section;
467 Status = PeiServicesLocatePpi (&gEfiPeiDecompressPpiGuid, 0, NULL, (VOID **) &DecompressPpi);
468 if (!EFI_ERROR (Status)) {
469 Status = DecompressPpi->Decompress (
470 DecompressPpi,
471 CompressionSection,
472 &PpiOutput,
473 &PpiOutputSize
474 );
475 if (!EFI_ERROR (Status)) {
476 return PeiFfsProcessSection (
477 PeiServices, SectionType, PpiOutput, PpiOutputSize, OutputBuffer, OutputSize, Authentication
478 );
479 }
480 }
481 }
482
483 //
484 // Size is 24 bits wide so mask upper 8 bits.
485 // SectionLength is adjusted it is 4 byte aligned.
486 // Go to the next section
487 //
488 SectionLength = *(UINT32 *)Section->Size & 0x00FFFFFF;
489 SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
490 ASSERT (SectionLength != 0);
491 ParsedLength += SectionLength;
492 Section = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)Section + SectionLength);
493 }
494
495 return EFI_NOT_FOUND;
496 }
497
498
499 EFI_STATUS
500 EFIAPI
501 PeiFfsFindSectionData (
502 IN CONST EFI_PEI_SERVICES **PeiServices,
503 IN EFI_SECTION_TYPE SectionType,
504 IN EFI_PEI_FILE_HANDLE FileHandle,
505 IN OUT VOID **SectionData
506 )
507 /*++
508
509 Routine Description:
510 Given the input file pointer, search for the next matching section in the
511 FFS volume.
512
513 Arguments:
514 PeiServices - Pointer to the PEI Core Services Table.
515 SearchType - Filter to find only sections of this type.
516 FfsFileHeader - Pointer to the current file to search.
517 SectionData - Pointer to the Section matching SectionType in FfsFileHeader.
518 - NULL if section not found
519
520 Returns:
521 EFI_NOT_FOUND - No files matching the search criteria were found
522 EFI_SUCCESS
523
524 --*/
525 {
526 EFI_FFS_FILE_HEADER *FfsFileHeader;
527 UINT32 FileSize;
528 EFI_COMMON_SECTION_HEADER *Section;
529 UINTN OutputSize;
530 UINT32 AuthenticationStatus;
531
532
533 FfsFileHeader = (EFI_FFS_FILE_HEADER *)(FileHandle);
534
535 //
536 // Size is 24 bits wide so mask upper 8 bits.
537 // Does not include FfsFileHeader header size
538 // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.
539 //
540 Section = (EFI_COMMON_SECTION_HEADER *)(FfsFileHeader + 1);
541 FileSize = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
542 FileSize -= sizeof (EFI_FFS_FILE_HEADER);
543
544 return PeiFfsProcessSection (
545 PeiServices,
546 SectionType,
547 Section,
548 FileSize,
549 SectionData,
550 &OutputSize,
551 &AuthenticationStatus
552 );
553 }
554
555
556 EFI_STATUS
557 EFIAPI
558 PeiFfsFindNextFile (
559 IN CONST EFI_PEI_SERVICES **PeiServices,
560 IN UINT8 SearchType,
561 IN EFI_PEI_FV_HANDLE VolumeHandle,
562 IN OUT EFI_PEI_FILE_HANDLE *FileHandle
563 )
564 /*++
565
566 Routine Description:
567 Given the input file pointer, search for the next matching file in the
568 FFS volume as defined by SearchType. The search starts from FileHeader inside
569 the Firmware Volume defined by FwVolHeader.
570
571 Arguments:
572 PeiServices - Pointer to the PEI Core Services Table.
573
574 SearchType - Filter to find only files of this type.
575 Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
576
577 FwVolHeader - Pointer to the FV header of the volume to search.
578 This parameter must point to a valid FFS volume.
579
580 FileHeader - Pointer to the current file from which to begin searching.
581 This pointer will be updated upon return to reflect the file found.
582
583 Returns:
584 EFI_NOT_FOUND - No files matching the search criteria were found
585 EFI_SUCCESS
586
587 --*/
588 {
589 return PeiFindFileEx (VolumeHandle, NULL, SearchType, FileHandle, NULL);
590 }
591
592
593 EFI_STATUS
594 EFIAPI
595 PeiFvFindNextVolume (
596 IN CONST EFI_PEI_SERVICES **PeiServices,
597 IN UINTN Instance,
598 IN OUT EFI_PEI_FV_HANDLE *VolumeHandle
599 )
600 /*++
601
602 Routine Description:
603
604 Return the BFV location
605
606 BugBug -- Move this to the location of this code to where the
607 other FV and FFS support code lives.
608 Also, update to use FindFV for instances #'s >= 1.
609
610 Arguments:
611
612 PeiServices - The PEI core services table.
613 Instance - Instance of FV to find
614 FwVolHeader - Pointer to contain the data to return
615
616 Returns:
617 Pointer to the Firmware Volume instance requested
618
619 EFI_INVALID_PARAMETER - FwVolHeader is NULL
620
621 EFI_SUCCESS - Firmware volume instance successfully found.
622
623 --*/
624 {
625 PEI_CORE_INSTANCE *Private;
626
627 Private = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
628 if (VolumeHandle == NULL) {
629 return EFI_INVALID_PARAMETER;
630 }
631
632 if (Instance >= Private->AllFvCount) {
633 VolumeHandle = NULL;
634 return EFI_NOT_FOUND;
635 }
636
637 *VolumeHandle = Private->AllFv[Instance];
638 return EFI_SUCCESS;
639 }
640
641
642 EFI_STATUS
643 EFIAPI
644 PeiFfsFindFileByName (
645 IN CONST EFI_GUID *FileName,
646 IN EFI_PEI_FV_HANDLE VolumeHandle,
647 OUT EFI_PEI_FILE_HANDLE *FileHandle
648 )
649 /*++
650
651 Routine Description:
652
653 Given the input VolumeHandle, search for the next matching name file.
654
655 Arguments:
656
657 FileName - File name to search.
658 VolumeHandle - The current FV to search.
659 FileHandle - Pointer to the file matching name in VolumeHandle.
660 - NULL if file not found
661 Returns:
662 EFI_STATUS
663
664 --*/
665 {
666 EFI_STATUS Status;
667 if ((VolumeHandle == NULL) || (FileName == NULL) || (FileHandle == NULL)) {
668 return EFI_INVALID_PARAMETER;
669 }
670 Status = PeiFindFileEx (VolumeHandle, FileName, 0, FileHandle, NULL);
671 if (Status == EFI_NOT_FOUND) {
672 *FileHandle = NULL;
673 }
674 return Status;
675 }
676
677 EFI_STATUS
678 EFIAPI
679 PeiFfsGetFileInfo (
680 IN EFI_PEI_FILE_HANDLE FileHandle,
681 OUT EFI_FV_FILE_INFO *FileInfo
682 )
683 /*++
684
685 Routine Description:
686
687 Collect information of given file.
688
689 Arguments:
690 FileHandle - The handle to file.
691 FileInfo - Pointer to the file information.
692
693 Returns:
694 EFI_STATUS
695
696 --*/
697 {
698 UINT8 FileState;
699 UINT8 ErasePolarity;
700 EFI_FFS_FILE_HEADER *FileHeader;
701 EFI_PEI_FV_HANDLE VolumeHandle;
702
703 if ((FileHandle == NULL) || (FileInfo == NULL)) {
704 return EFI_INVALID_PARAMETER;
705 }
706
707 //
708 // Retrieve the FirmwareVolume which the file resides in.
709 //
710 if (!PeiFileHandleToVolume(FileHandle, &VolumeHandle)) {
711 return EFI_INVALID_PARAMETER;
712 }
713
714 if (((EFI_FIRMWARE_VOLUME_HEADER*)VolumeHandle)->Attributes & EFI_FVB_ERASE_POLARITY) {
715 ErasePolarity = 1;
716 } else {
717 ErasePolarity = 0;
718 }
719
720 //
721 // Get FileState which is the highest bit of the State
722 //
723 FileState = GetFileState (ErasePolarity, (EFI_FFS_FILE_HEADER*)FileHandle);
724
725 switch (FileState) {
726 case EFI_FILE_DATA_VALID:
727 case EFI_FILE_MARKED_FOR_UPDATE:
728 break;
729 default:
730 return EFI_INVALID_PARAMETER;
731 }
732
733 FileHeader = (EFI_FFS_FILE_HEADER *)FileHandle;
734 CopyMem (&FileInfo->FileName, &FileHeader->Name, sizeof(EFI_GUID));
735 FileInfo->FileType = FileHeader->Type;
736 FileInfo->FileAttributes = FileHeader->Attributes;
737 FileInfo->BufferSize = ((*(UINT32 *)FileHeader->Size) & 0x00FFFFFF) - sizeof (EFI_FFS_FILE_HEADER);
738 FileInfo->Buffer = (FileHeader + 1);
739 return EFI_SUCCESS;
740 }
741
742
743 EFI_STATUS
744 EFIAPI
745 PeiFfsGetVolumeInfo (
746 IN EFI_PEI_FV_HANDLE VolumeHandle,
747 OUT EFI_FV_INFO *VolumeInfo
748 )
749 /*++
750
751 Routine Description:
752
753 Collect information of given Fv Volume.
754
755 Arguments:
756 VolumeHandle - The handle to Fv Volume.
757 VolumeInfo - The pointer to volume information.
758
759 Returns:
760 EFI_STATUS
761
762 --*/
763 {
764 EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
765 EFI_FIRMWARE_VOLUME_EXT_HEADER *FwVolExHeaderInfo;
766
767 if (VolumeInfo == NULL) {
768 return EFI_INVALID_PARAMETER;
769 }
770
771 FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(VolumeHandle);
772 VolumeInfo->FvAttributes = FwVolHeader->Attributes;
773 VolumeInfo->FvStart = FwVolHeader;
774 VolumeInfo->FvSize = FwVolHeader->FvLength;
775 CopyMem (&VolumeInfo->FvFormat, &FwVolHeader->FileSystemGuid,sizeof(EFI_GUID));
776
777 if (FwVolHeader->ExtHeaderOffset != 0) {
778 FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER*)(((UINT8 *)FwVolHeader) + FwVolHeader->ExtHeaderOffset);
779 CopyMem (&VolumeInfo->FvName, &FwVolExHeaderInfo->FvName, sizeof(EFI_GUID));
780 }
781 return EFI_SUCCESS;
782 }
783
EFI Development Kit II mirror for PVE