{\r
UINT8 HeaderChecksum;\r
\r
- HeaderChecksum = CalculateSum8 ((UINT8 *) FfsHeader, sizeof (EFI_FFS_FILE_HEADER));\r
+ if (IS_FFS_FILE2 (FfsHeader)) {\r
+ HeaderChecksum = CalculateSum8 ((UINT8 *) FfsHeader, sizeof (EFI_FFS_FILE_HEADER2));\r
+ } else {\r
+ HeaderChecksum = CalculateSum8 ((UINT8 *) FfsHeader, sizeof (EFI_FFS_FILE_HEADER));\r
+ }\r
HeaderChecksum = (UINT8) (HeaderChecksum - FfsHeader->State - FfsHeader->IntegrityCheck.Checksum.File);\r
\r
if (HeaderChecksum == 0) {\r
{\r
UINT8 FileChecksum;\r
EFI_FV_FILE_ATTRIBUTES Attributes;\r
- UINT32 FileSize;\r
\r
Attributes = FfsHeader->Attributes;\r
\r
if ((Attributes & FFS_ATTRIB_CHECKSUM) != 0) {\r
\r
- FileSize = *(UINT32 *) FfsHeader->Size & 0x00FFFFFF;\r
-\r
//\r
// Check checksum of FFS data\r
//\r
- FileChecksum = CalculateSum8 ((UINT8 *) FfsHeader + sizeof (EFI_FFS_FILE_HEADER), FileSize - sizeof (EFI_FFS_FILE_HEADER));\r
+ if (IS_FFS_FILE2 (FfsHeader)) {\r
+ FileChecksum = CalculateSum8 ((UINT8 *) FfsHeader + sizeof (EFI_FFS_FILE_HEADER2), FFS_FILE2_SIZE (FfsHeader) - sizeof (EFI_FFS_FILE_HEADER2));\r
+ } else {\r
+ FileChecksum = CalculateSum8 ((UINT8 *) FfsHeader + sizeof (EFI_FFS_FILE_HEADER), FFS_FILE_SIZE (FfsHeader) - sizeof (EFI_FFS_FILE_HEADER));\r
+ }\r
FileChecksum = (UINT8) (FileChecksum + FfsHeader->IntegrityCheck.Checksum.File);\r
\r
if (FileChecksum == 0) {\r
//\r
// Skip this header\r
//\r
- return (EFI_PHYSICAL_ADDRESS) (UINTN) FfsHeader + sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (FfsHeader)) {\r
+ return (EFI_PHYSICAL_ADDRESS) (UINTN) FfsHeader + sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ return (EFI_PHYSICAL_ADDRESS) (UINTN) FfsHeader + sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
}\r
\r
- FileLength = *(UINT32 *) FfsHeader->Size & 0x00FFFFFF;\r
+ if (IS_FFS_FILE2 (FfsHeader)) {\r
+ FileLength = FFS_FILE2_SIZE (FfsHeader);\r
+ } else {\r
+ FileLength = FFS_FILE_SIZE (FfsHeader);\r
+ }\r
\r
//\r
// Since FileLength is not multiple of 8, we need skip some bytes\r
return TRUE;\r
}\r
\r
-/**\r
- Locate the first file in FV.\r
-\r
- @param FvDevice Cached FV image.\r
- @param FirstFile Points to the got first FFS file header.\r
-\r
- @retval EFI_NOT_FOUND No FFS file is found in FV.\r
- @retval EFI_SUCCESS The first FFS file is got.\r
-\r
-**/\r
-EFI_STATUS\r
-FvLocateFirstFile (\r
- IN FV_DEVICE *FvDevice,\r
- OUT EFI_FFS_FILE_HEADER **FirstFile\r
- )\r
-{\r
- FFS_FILE_LIST_ENTRY *TmpFileList;\r
- LIST_ENTRY *Link;\r
-\r
- Link = FvDevice->FfsFileListHeader.ForwardLink;\r
-\r
- if (Link == &FvDevice->FfsFileListHeader) {\r
- return EFI_NOT_FOUND;\r
- }\r
-\r
- TmpFileList = (FFS_FILE_LIST_ENTRY *) Link;\r
- *FirstFile = (EFI_FFS_FILE_HEADER *) TmpFileList->FfsHeader;\r
-\r
- return EFI_SUCCESS;\r
-}\r
IN EFI_FFS_FILE_HEADER *PadFileHeader\r
)\r
{\r
- UINT32 PadFileLength;\r
-\r
if ((PadFileHeader->Attributes & FFS_ATTRIB_CHECKSUM) != 0) {\r
\r
- PadFileLength = *(UINT32 *) PadFileHeader->Size & 0x00FFFFFF;\r
+ if (IS_FFS_FILE2 (PadFileHeader)) {\r
+ //\r
+ // Calculate checksum of Pad File Data\r
+ //\r
+ PadFileHeader->IntegrityCheck.Checksum.File =\r
+ CalculateCheckSum8 ((UINT8 *) PadFileHeader + sizeof (EFI_FFS_FILE_HEADER2), FFS_FILE2_SIZE (PadFileHeader) - sizeof (EFI_FFS_FILE_HEADER2));\r
\r
- //\r
- // Calculate checksum of Pad File Data\r
- //\r
- PadFileHeader->IntegrityCheck.Checksum.File =\r
- CalculateCheckSum8 ((UINT8 *) PadFileHeader + sizeof (EFI_FFS_FILE_HEADER), PadFileLength - sizeof (EFI_FFS_FILE_HEADER));\r
+ } else {\r
+ //\r
+ // Calculate checksum of Pad File Data\r
+ //\r
+ PadFileHeader->IntegrityCheck.Checksum.File =\r
+ CalculateCheckSum8 ((UINT8 *) PadFileHeader + sizeof (EFI_FFS_FILE_HEADER), FFS_FILE_SIZE (PadFileHeader) - sizeof (EFI_FFS_FILE_HEADER));\r
+ }\r
\r
} else {\r
\r
UINTN StateOffset;\r
UINT8 *StartPos;\r
FFS_FILE_LIST_ENTRY *FfsFileEntry;\r
+ UINTN HeaderSize;\r
+ UINTN FileSize;\r
+\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+ FileSize = Size + HeaderSize;\r
+ if (FileSize > 0x00FFFFFF) {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+ FileSize = Size + HeaderSize;\r
+ }\r
\r
- if (FreeSpaceEntry->Length < Size + sizeof (EFI_FFS_FILE_HEADER)) {\r
+ if (FreeSpaceEntry->Length < FileSize) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
if (!IsBufferErased (\r
FvDevice->ErasePolarity,\r
StartPos,\r
- Size + sizeof (EFI_FFS_FILE_HEADER)\r
+ FileSize\r
)) {\r
return EFI_DEVICE_ERROR;\r
}\r
//\r
// Update Free Space Entry, since header is allocated\r
//\r
- FreeSpaceEntry->Length -= sizeof (EFI_FFS_FILE_HEADER);\r
- FreeSpaceEntry->StartingAddress += sizeof (EFI_FFS_FILE_HEADER);\r
+ FreeSpaceEntry->Length -= HeaderSize;\r
+ FreeSpaceEntry->StartingAddress += HeaderSize;\r
\r
//\r
// Fill File Name Guid, here we assign a NULL-GUID to Pad files\r
//\r
PadFileHeader->Type = EFI_FV_FILETYPE_FFS_PAD;\r
PadFileHeader->Attributes = 0;\r
- *(UINT32 *) PadFileHeader->Size &= 0xFF000000;\r
- *(UINT32 *) PadFileHeader->Size |= (Size + sizeof (EFI_FFS_FILE_HEADER));\r
+ if ((FileSize) > 0x00FFFFFF) {\r
+ ((EFI_FFS_FILE_HEADER2 *) PadFileHeader)->ExtendedSize = (UINT32) FileSize;\r
+ *(UINT32 *) PadFileHeader->Size &= 0xFF000000;\r
+ PadFileHeader->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
+ } else {\r
+ *(UINT32 *) PadFileHeader->Size &= 0xFF000000;\r
+ *(UINT32 *) PadFileHeader->Size |= FileSize;\r
+ }\r
\r
SetHeaderChecksum (PadFileHeader);\r
SetPadFileChecksum (PadFileHeader);\r
\r
Offset = (UINTN) (StartPos - FvDevice->CachedFv);\r
\r
- NumBytesWritten = sizeof (EFI_FFS_FILE_HEADER);\r
+ NumBytesWritten = HeaderSize;\r
Status = FvcWrite (\r
FvDevice,\r
Offset,\r
//\r
PadFileHeader->Type = EFI_FV_FILETYPE_FFS_PAD;\r
PadFileHeader->Attributes = 0;\r
- *(UINT32 *) PadFileHeader->Size &= 0xFF000000;\r
- *(UINT32 *) PadFileHeader->Size |= PadFileLength;\r
+ if (PadFileLength > 0x00FFFFFF) {\r
+ ((EFI_FFS_FILE_HEADER2 *) PadFileHeader)->ExtendedSize = (UINT32) PadFileLength;\r
+ *(UINT32 *) PadFileHeader->Size &= 0xFF000000;\r
+ PadFileHeader->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
+ } else {\r
+ *(UINT32 *) PadFileHeader->Size &= 0xFF000000;\r
+ *(UINT32 *) PadFileHeader->Size |= PadFileLength;\r
+ }\r
\r
SetHeaderChecksum (PadFileHeader);\r
SetPadFileChecksum (PadFileHeader);\r
\r
TmpFileHeader->Attributes = TmpFileAttribute;\r
\r
- *(UINT32 *) TmpFileHeader->Size &= 0xFF000000;\r
- *(UINT32 *) TmpFileHeader->Size |= ActualFileSize;\r
+ if (ActualFileSize > 0x00FFFFFF) {\r
+ ((EFI_FFS_FILE_HEADER2 *) FileHeader)->ExtendedSize = (UINT32) ActualFileSize;\r
+ *(UINT32 *) FileHeader->Size &= 0xFF000000;\r
+ FileHeader->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
+ } else {\r
+ *(UINT32 *) FileHeader->Size &= 0xFF000000;\r
+ *(UINT32 *) FileHeader->Size |= ActualFileSize;\r
+ }\r
\r
SetHeaderChecksum (TmpFileHeader);\r
SetFileChecksum (TmpFileHeader, ActualFileSize);\r
IN UINTN ExtraLength\r
)\r
{\r
- UINTN FileLength;\r
UINT8 *Ptr;\r
UINT8 PadingByte;\r
\r
- FileLength = *(UINT32 *) FileHeader->Size & 0x00FFFFFF;\r
- Ptr = (UINT8 *) FileHeader + FileLength;\r
+ if (IS_FFS_FILE2 (FileHeader)) {\r
+ Ptr = (UINT8 *) FileHeader + FFS_FILE2_SIZE (FileHeader);\r
+ } else {\r
+ Ptr = (UINT8 *) FileHeader + FFS_FILE_SIZE (FileHeader);\r
+ }\r
\r
if (ErasePolarity == 0) {\r
PadingByte = 0;\r
//\r
InitializeListHead (&NewFileList);\r
\r
- PadAreaLength = (*(UINT32 *) OldPadFileHeader->Size & 0x00FFFFFF) - sizeof (EFI_FFS_FILE_HEADER);\r
-\r
- PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER));\r
+ if (IS_FFS_FILE2 (OldPadFileHeader)) {\r
+ PadAreaLength = FFS_FILE2_SIZE (OldPadFileHeader) - sizeof (EFI_FFS_FILE_HEADER);\r
+ PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER2));\r
+ } else {\r
+ PadAreaLength = FFS_FILE_SIZE (OldPadFileHeader) - sizeof (EFI_FFS_FILE_HEADER);\r
+ PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER));\r
+ }\r
\r
- if (RequiredAlignment != 8) {\r
+ if (PadSize != 0) {\r
//\r
// Insert a PAD file before to achieve required alignment\r
//\r
FileAttributes\r
);\r
if (EFI_ERROR (Status)) {\r
+ FreeFileList (&NewFileList);\r
return Status;\r
}\r
\r
//\r
// Start writing to FV\r
//\r
- StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (OldPadFileHeader)) {\r
+ StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
\r
Offset = (UINTN) (StartPos - FvDevice->CachedFv);\r
\r
);\r
if (EFI_ERROR (Status)) {\r
FreeFileList (&NewFileList);\r
+ FvDevice->CurrentFfsFile = NULL;\r
return Status;\r
}\r
\r
);\r
if (EFI_ERROR (Status)) {\r
SetFileState (EFI_FILE_HEADER_INVALID, OldPadFileHeader);\r
+ FreeFileList (&NewFileList);\r
+ FvDevice->CurrentFfsFile = NULL;\r
return Status;\r
}\r
\r
NewFileListEntry = NULL;\r
\r
OldPadFileHeader = (EFI_FFS_FILE_HEADER *) PadFileEntry->FfsHeader;\r
- PadAreaLength = (*(UINT32 *) OldPadFileHeader->Size & 0x00FFFFFF) - sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (OldPadFileHeader)) {\r
+ PadAreaLength = FFS_FILE2_SIZE (OldPadFileHeader) - sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ PadAreaLength = FFS_FILE_SIZE (OldPadFileHeader) - sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
\r
Status = UpdateHeaderBit (\r
FvDevice,\r
// Update PAD area\r
//\r
TotalSize = 0;\r
- PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER));\r
+ if (IS_FFS_FILE2 (OldPadFileHeader)) {\r
+ PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER2));\r
+ } else {\r
+ PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER));\r
+ }\r
FileHeader = PadFileHeader;\r
\r
for (Index = 0; Index < NumOfFiles; Index++) {\r
FvFillPadFile (PadFileHeader, PadSize[Index]);\r
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));\r
if (NewFileListEntry == NULL) {\r
+ FreeFileList (&NewFileList);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
FileData[Index].FileAttributes\r
);\r
if (EFI_ERROR (Status)) {\r
+ FreeFileList (&NewFileList);\r
return Status;\r
}\r
\r
NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));\r
if (NewFileListEntry == NULL) {\r
FreeFileList (&NewFileList);\r
+ FvDevice->CurrentFfsFile = NULL;\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
//\r
// Start writing to FV\r
//\r
- StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (OldPadFileHeader)) {\r
+ StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ StartPos = (UINT8 *) OldPadFileHeader + sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
\r
Offset = (UINTN) (StartPos - FvDevice->CachedFv);\r
\r
);\r
if (EFI_ERROR (Status)) {\r
FreeFileList (&NewFileList);\r
+ FvDevice->CurrentFfsFile = NULL;\r
return Status;\r
}\r
\r
);\r
if (EFI_ERROR (Status)) {\r
FreeFileList (&NewFileList);\r
+ FvDevice->CurrentFfsFile = NULL;\r
return Status;\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
+/**\r
+ Create multiple files within the Free Space.\r
+\r
+ @param FvDevice Firmware Volume Device.\r
+ @param FreeSpaceEntry Indicating in which Free Space(Cache) the multiple files will be inserted.\r
+ @param NumOfFiles Total File number to be written.\r
+ @param BufferSize The array of buffer size of each FfsBuffer.\r
+ @param ActualFileSize The array of actual file size.\r
+ @param PadSize The array of leading pad file size for each FFS File\r
+ @param FfsBuffer The array of Ffs Buffer pointer.\r
+ @param FileData The array of EFI_FV_WRITE_FILE_DATA structure, \r
+ used to get name, attributes, type, etc.\r
+\r
+ @retval EFI_SUCCESS Add the input multiple files into PAD file area.\r
+ @retval EFI_OUT_OF_RESOURCES No enough memory is allocated.\r
+ @retval other error Files can't be added into PAD file area.\r
+\r
+**/\r
+EFI_STATUS\r
+FvCreateMultipleFilesInsideFreeSpace (\r
+ IN FV_DEVICE *FvDevice,\r
+ IN FREE_SPACE_ENTRY *FreeSpaceEntry,\r
+ IN UINTN NumOfFiles,\r
+ IN UINTN *BufferSize,\r
+ IN UINTN *ActualFileSize,\r
+ IN UINTN *PadSize,\r
+ IN UINT8 **FfsBuffer,\r
+ IN EFI_FV_WRITE_FILE_DATA *FileData\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINTN Index;\r
+ EFI_FFS_FILE_HEADER *PadFileHeader;\r
+ EFI_FFS_FILE_HEADER *FileHeader;\r
+ UINTN TotalSize;\r
+ LIST_ENTRY NewFileList;\r
+ FFS_FILE_LIST_ENTRY *NewFileListEntry;\r
+ UINTN Offset;\r
+ UINTN NumBytesWritten;\r
+ UINT8 *StartPos;\r
+\r
+ InitializeListHead (&NewFileList);\r
+\r
+ NewFileListEntry = NULL;\r
+\r
+ TotalSize = 0;\r
+ StartPos = FreeSpaceEntry->StartingAddress;\r
+ PadFileHeader = (EFI_FFS_FILE_HEADER *) StartPos;\r
+ FileHeader = PadFileHeader;\r
+\r
+ for (Index = 0; Index < NumOfFiles; Index++) {\r
+ if (PadSize[Index] != 0) {\r
+ FvFillPadFile (PadFileHeader, PadSize[Index]);\r
+ NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));\r
+ if (NewFileListEntry == NULL) {\r
+ FreeFileList (&NewFileList);\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+\r
+ NewFileListEntry->FfsHeader = (UINT8 *) PadFileHeader;\r
+ InsertTailList (&NewFileList, &NewFileListEntry->Link);\r
+ }\r
+\r
+ FileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) PadFileHeader + PadSize[Index]);\r
+ Status = FvFillFfsFile (\r
+ FileHeader,\r
+ FfsBuffer[Index],\r
+ BufferSize[Index],\r
+ ActualFileSize[Index],\r
+ FileData[Index].NameGuid,\r
+ FileData[Index].Type,\r
+ FileData[Index].FileAttributes\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ FreeFileList (&NewFileList);\r
+ return Status;\r
+ }\r
+\r
+ NewFileListEntry = AllocatePool (sizeof (FFS_FILE_LIST_ENTRY));\r
+ if (NewFileListEntry == NULL) {\r
+ FreeFileList (&NewFileList);\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+\r
+ NewFileListEntry->FfsHeader = (UINT8 *) FileHeader;\r
+ InsertTailList (&NewFileList, &NewFileListEntry->Link);\r
+\r
+ PadFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FileHeader + BufferSize[Index]);\r
+ TotalSize += PadSize[Index];\r
+ TotalSize += BufferSize[Index];\r
+ }\r
+\r
+ if (FreeSpaceEntry->Length < TotalSize) {\r
+ FreeFileList (&NewFileList);\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+\r
+ FvDevice->CurrentFfsFile = NewFileListEntry;\r
+\r
+ //\r
+ // Start writing to FV\r
+ //\r
+ Offset = (UINTN) (StartPos - FvDevice->CachedFv);\r
+\r
+ NumBytesWritten = TotalSize;\r
+ Status = FvcWrite (\r
+ FvDevice,\r
+ Offset,\r
+ &NumBytesWritten,\r
+ StartPos\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ FreeFileList (&NewFileList);\r
+ FvDevice->CurrentFfsFile = NULL;\r
+ return Status;\r
+ }\r
+\r
+ FreeSpaceEntry->Length -= TotalSize;\r
+ FreeSpaceEntry->StartingAddress += TotalSize;\r
+\r
+ NewFileListEntry = (FFS_FILE_LIST_ENTRY *) (NewFileList.ForwardLink);\r
+\r
+ while (NewFileListEntry != (FFS_FILE_LIST_ENTRY *) &NewFileList) {\r
+ InsertTailList (&FvDevice->FfsFileListHeader, &NewFileListEntry->Link);\r
+ NewFileListEntry = (FFS_FILE_LIST_ENTRY *) (NewFileListEntry->Link.ForwardLink);\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
/**\r
Write multiple files into FV in reliable method.\r
\r
FFS_FILE_LIST_ENTRY *OldFfsFileEntry[MAX_FILES];\r
EFI_FFS_FILE_HEADER *OldFileHeader[MAX_FILES];\r
BOOLEAN IsCreateFile;\r
+ UINTN HeaderSize;\r
\r
//\r
// To use this function, we must ensure that the NumOfFiles is great\r
// Adjust file size\r
//\r
for (Index1 = 0; Index1 < NumOfFiles; Index1++) {\r
- ActualFileSize[Index1] = FileData[Index1].BufferSize + sizeof (EFI_FFS_FILE_HEADER);\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+ ActualFileSize[Index1] = FileData[Index1].BufferSize + HeaderSize;\r
+ if (ActualFileSize[Index1] > 0x00FFFFFF) {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+ ActualFileSize[Index1] = FileData[Index1].BufferSize + HeaderSize;\r
+ }\r
BufferSize[Index1] = ActualFileSize[Index1];\r
\r
- if (BufferSize[Index1] == sizeof (EFI_FFS_FILE_HEADER)) {\r
+ if (BufferSize[Index1] == HeaderSize) {\r
//\r
// clear file attributes, zero-length file does not have any attributes\r
//\r
// Copy File Data into FileBuffer\r
//\r
CopyMem (\r
- FfsBuffer[Index1] + sizeof (EFI_FFS_FILE_HEADER),\r
+ FfsBuffer[Index1] + HeaderSize,\r
FileData[Index1].Buffer,\r
FileData[Index1].BufferSize\r
);\r
\r
if (FvDevice->ErasePolarity == 1) {\r
- for (Index2 = 0; Index2 < sizeof (EFI_FFS_FILE_HEADER); Index2++) {\r
+ for (Index2 = 0; Index2 < HeaderSize; Index2++) {\r
FfsBuffer[Index1][Index2] = (UINT8)~FfsBuffer[Index1][Index2];\r
}\r
}\r
\r
- if ((FileData[Index1].FileAttributes & FFS_ATTRIB_DATA_ALIGNMENT) != 0) {\r
+ if ((FileData[Index1].FileAttributes & EFI_FV_FILE_ATTRIB_ALIGNMENT) != 0) {\r
RequiredAlignment[Index1] = GetRequiredAlignment (FileData[Index1].FileAttributes);\r
}\r
//\r
if (Status == EFI_NOT_FOUND) {\r
//\r
// Try to find a free space that can hold these files\r
- // and create a suitable PAD file in this free space\r
//\r
Status = FvSearchSuitableFreeSpace (\r
FvDevice,\r
FreeFfsBuffer (NumOfFiles, FfsBuffer);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
- //\r
- // Create a PAD file in that space\r
- //\r
- Status = FvCreatePadFileInFreeSpace (\r
+ Status = FvCreateMultipleFilesInsideFreeSpace (\r
FvDevice,\r
FreeSpaceEntry,\r
- TotalSizeNeeded,\r
- &PadFileEntry\r
+ NumOfFiles,\r
+ BufferSize,\r
+ ActualFileSize,\r
+ PadSize,\r
+ FfsBuffer,\r
+ FileData\r
);\r
\r
- if (EFI_ERROR (Status)) {\r
- FreeFfsBuffer (NumOfFiles, FfsBuffer);\r
- return Status;\r
- }\r
+ } else {\r
+ //\r
+ // Create multiple files inside such a pad file\r
+ // to achieve lock-step update\r
+ //\r
+ Status = FvCreateMultipleFilesInsidePadFile (\r
+ FvDevice,\r
+ PadFileEntry,\r
+ NumOfFiles,\r
+ BufferSize,\r
+ ActualFileSize,\r
+ PadSize,\r
+ FfsBuffer,\r
+ FileData\r
+ );\r
}\r
- //\r
- // Create multiple files inside such a pad file\r
- // to achieve lock-step update\r
- //\r
- Status = FvCreateMultipleFilesInsidePadFile (\r
- FvDevice,\r
- PadFileEntry,\r
- NumOfFiles,\r
- BufferSize,\r
- ActualFileSize,\r
- PadSize,\r
- FfsBuffer,\r
- FileData\r
- );\r
\r
FreeFfsBuffer (NumOfFiles, FfsBuffer);\r
\r
Layers on top of Firmware Block protocol to produce a file abstraction\r
of FV based files.\r
\r
- Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions\r
UINT8 *FreeStart;\r
UINTN FreeSize;\r
UINT8 ErasePolarity;\r
- UINTN FileLength;\r
EFI_FFS_FILE_STATE FileState;\r
UINT8 *TopFvAddress;\r
UINTN TestLength;\r
}\r
ASSERT (FwVolHeader != NULL);\r
\r
+ FvDevice->IsFfs3Fv = CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiFirmwareFileSystem3Guid);\r
+\r
//\r
// Double Check firmware volume header here\r
//\r
(EFI_FFS_FILE_HEADER *) Ptr\r
);\r
if ((FileState == EFI_FILE_HEADER_INVALID) || (FileState == EFI_FILE_HEADER_CONSTRUCTION)) {\r
- Ptr += sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (Ptr)) {\r
+ if (!FvDevice->IsFfs3Fv) {\r
+ DEBUG ((EFI_D_ERROR, "Found a FFS3 formatted file: %g in a non-FFS3 formatted FV.\n", &((EFI_FFS_FILE_HEADER *) Ptr)->Name));\r
+ }\r
+ Ptr = Ptr + sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ Ptr = Ptr + sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
\r
continue;\r
\r
}\r
}\r
\r
+ if (IS_FFS_FILE2 (Ptr)) {\r
+ ASSERT (FFS_FILE2_SIZE (Ptr) > 0x00FFFFFF);\r
+ if (!FvDevice->IsFfs3Fv) {\r
+ DEBUG ((EFI_D_ERROR, "Found a FFS3 formatted file: %g in a non-FFS3 formatted FV.\n", &((EFI_FFS_FILE_HEADER *) Ptr)->Name));\r
+ Ptr = Ptr + FFS_FILE2_SIZE (Ptr);\r
+ //\r
+ // Adjust Ptr to the next 8-byte aligned boundry.\r
+ //\r
+ while (((UINTN) Ptr & 0x07) != 0) {\r
+ Ptr++;\r
+ }\r
+ continue;\r
+ }\r
+ }\r
+\r
if (IsValidFFSFile (FvDevice, (EFI_FFS_FILE_HEADER *) Ptr)) {\r
- FileLength = *(UINT32 *) ((EFI_FFS_FILE_HEADER *) Ptr)->Size & 0x00FFFFFF;\r
FileState = GetFileState (\r
FvDevice->ErasePolarity,\r
(EFI_FFS_FILE_HEADER *) Ptr\r
InsertTailList (&FvDevice->FfsFileListHeader, &FfsFileEntry->Link);\r
}\r
\r
- Ptr += FileLength;\r
+ if (IS_FFS_FILE2 (Ptr)) {\r
+ Ptr = Ptr + FFS_FILE2_SIZE (Ptr);\r
+ } else {\r
+ Ptr = Ptr + FFS_FILE_SIZE (Ptr);\r
+ }\r
\r
//\r
// Adjust Ptr to the next 8-byte aligned boundry.\r
if (EFI_ERROR (Status)) {\r
return EFI_NOT_FOUND;\r
}\r
- //\r
- // Get FV with gEfiFirmwareFileSystemGuid\r
- //\r
+\r
for (Index = 0; Index < HandleCount; Index += 1) {\r
Status = gBS->HandleProtocol (\r
HandleBuffer[Index],\r
// Check to see that the file system is indeed formatted in a way we can\r
// understand it...\r
//\r
- if (!CompareGuid (\r
- &FwVolHeader->FileSystemGuid,\r
- &gEfiFirmwareFileSystem2Guid\r
- )) {\r
+ if ((!CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiFirmwareFileSystem2Guid)) &&\r
+ (!CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiFirmwareFileSystem3Guid))) {\r
FreePool (FwVolHeader);\r
continue;\r
}\r
/** @file\r
Common defines and definitions for a FwVolDxe driver.\r
\r
- Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions\r
#include <PiDxe.h>\r
\r
#include <Guid/FirmwareFileSystem2.h>\r
+#include <Guid/FirmwareFileSystem3.h>\r
#include <Protocol/SectionExtraction.h>\r
#include <Protocol/FaultTolerantWrite.h>\r
#include <Protocol/FirmwareVolume2.h>\r
LIST_ENTRY FfsFileListHeader;\r
\r
FFS_FILE_LIST_ENTRY *CurrentFfsFile;\r
-\r
+ BOOLEAN IsFfs3Fv;\r
} FV_DEVICE;\r
\r
#define FV_DEVICE_FROM_THIS(a) CR (a, FV_DEVICE, Fv, FV_DEVICE_SIGNATURE)\r
OUT EFI_FIRMWARE_VOLUME_HEADER **FwVolHeader\r
);\r
\r
-/**\r
- Locate the first file in FV.\r
-\r
- @param FvDevice Cached FV image.\r
- @param FirstFile Points to the got first FFS file header.\r
-\r
- @retval EFI_NOT_FOUND No FFS file is found in FV.\r
- @retval EFI_SUCCESS The first FFS file is got.\r
-\r
-**/\r
-EFI_STATUS\r
-FvLocateFirstFile (\r
- IN FV_DEVICE *FvDevice,\r
- OUT EFI_FFS_FILE_HEADER **FirstFile\r
- );\r
-\r
/**\r
Convert the Buffer Address to LBA Entry Address.\r
\r
[Guids]\r
gEfiFirmwareVolumeTopFileGuid ## CONSUMES\r
gEfiFirmwareFileSystem2Guid ## CONSUMES\r
+ gEfiFirmwareFileSystem3Guid ## CONSUMES\r
\r
[Protocols]\r
gEfiSectionExtractionProtocolGuid ## CONSUMES\r
/** @file\r
Implements functions to read firmware file.\r
\r
- Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions\r
UINTN *KeyValue;\r
LIST_ENTRY *Link;\r
FFS_FILE_LIST_ENTRY *FfsFileEntry;\r
- UINTN FileLength;\r
\r
FvDevice = FV_DEVICE_FROM_THIS (This);\r
\r
CopyGuid (NameGuid, &FfsFileHeader->Name);\r
*Attributes = FfsAttributes2FvFileAttributes (FfsFileHeader->Attributes);\r
\r
- FileLength = *(UINT32 *) FfsFileHeader->Size & 0x00FFFFFF;\r
-\r
//\r
// we need to substract the header size\r
//\r
- *Size = FileLength - sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (FfsFileHeader)) {\r
+ *Size = FFS_FILE2_SIZE (FfsFileHeader) - sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ *Size = FFS_FILE_SIZE (FfsFileHeader) - sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
\r
if (CompareGuid (&gEfiFirmwareVolumeTopFileGuid, NameGuid)) {\r
//\r
UINT8 *SrcPtr;\r
UINT32 Tmp;\r
\r
- SrcPtr = (UINT8 *) FfsFileHeader;\r
- SrcPtr += sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (FfsFileHeader)) {\r
+ SrcPtr = ((UINT8 *) FfsFileHeader) + sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ SrcPtr = ((UINT8 *) FfsFileHeader) + sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
\r
while (*Size >= 4) {\r
Tmp = *(UINT32 *) SrcPtr;\r
//\r
// Get File Size of the cached file\r
//\r
- FileSize = *(UINT32 *) FfsHeader->Size & 0x00FFFFFF;\r
- FileSize -= sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (FfsHeader)) {\r
+ FileSize = FFS_FILE2_SIZE (FfsHeader) - sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ FileSize = FFS_FILE_SIZE (FfsHeader) - sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
}\r
//\r
// Get file info\r
return EFI_SUCCESS;\r
}\r
\r
- SrcPtr = (UINT8 *) FfsHeader;\r
- SrcPtr += sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (FfsHeader)) {\r
+ SrcPtr = ((UINT8 *) FfsHeader) + sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ SrcPtr = ((UINT8 *) FfsHeader) + sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
\r
if (CompareGuid (&gEfiFirmwareVolumeTopFileGuid, NameGuid)) {\r
//\r
)\r
{\r
EFI_FFS_FILE_STATE State;\r
- UINT8 HeaderChecksum;\r
UINT8 FileChecksum;\r
\r
//\r
\r
FfsHeader->IntegrityCheck.Checksum.Header = 0;\r
\r
- HeaderChecksum = CalculateSum8 (\r
- (UINT8 *)FfsHeader,\r
- sizeof (EFI_FFS_FILE_HEADER)\r
- );\r
-\r
- FfsHeader->IntegrityCheck.Checksum.Header = (UINT8) (~HeaderChecksum + 1);\r
+ if (IS_FFS_FILE2 (FfsHeader)) {\r
+ FfsHeader->IntegrityCheck.Checksum.Header = CalculateCheckSum8 (\r
+ (UINT8 *) FfsHeader,\r
+ sizeof (EFI_FFS_FILE_HEADER2)\r
+ );\r
+ } else {\r
+ FfsHeader->IntegrityCheck.Checksum.Header = CalculateCheckSum8 (\r
+ (UINT8 *) FfsHeader,\r
+ sizeof (EFI_FFS_FILE_HEADER)\r
+ );\r
+ }\r
\r
FfsHeader->State = State;\r
FfsHeader->IntegrityCheck.Checksum.File = FileChecksum;\r
IN UINTN ActualFileSize\r
)\r
{\r
- EFI_FFS_FILE_STATE State;\r
- UINT8 FileChecksum;\r
-\r
if ((FfsHeader->Attributes & FFS_ATTRIB_CHECKSUM) != 0) {\r
- //\r
- // The file state is not included\r
- //\r
- State = FfsHeader->State;\r
- FfsHeader->State = 0;\r
\r
FfsHeader->IntegrityCheck.Checksum.File = 0;\r
\r
- //\r
- // File checksum \r
- //\r
- FileChecksum = CalculateSum8 (\r
- (UINT8 *)(FfsHeader + 1),\r
- ActualFileSize - sizeof (EFI_FFS_FILE_HEADER)\r
- );\r
-\r
- FfsHeader->IntegrityCheck.Checksum.File = (UINT8) (~FileChecksum + 1);\r
-\r
- FfsHeader->State = State;\r
+ if (IS_FFS_FILE2 (FfsHeader)) {\r
+ FfsHeader->IntegrityCheck.Checksum.File = CalculateCheckSum8 (\r
+ (UINT8 *) FfsHeader + sizeof (EFI_FFS_FILE_HEADER2),\r
+ ActualFileSize - sizeof (EFI_FFS_FILE_HEADER2)\r
+ );\r
+ } else {\r
+ FfsHeader->IntegrityCheck.Checksum.File = CalculateCheckSum8 (\r
+ (UINT8 *) FfsHeader + sizeof (EFI_FFS_FILE_HEADER),\r
+ ActualFileSize - sizeof (EFI_FFS_FILE_HEADER)\r
+ );\r
+ }\r
\r
} else {\r
\r
\r
@param FvDevice Cached Firmware Volume.\r
@param StartAddress The starting address to write the FFS File.\r
+ @param BufferSize The FFS File Buffer Size.\r
@param RequiredAlignment FFS File Data alignment requirement.\r
\r
@return The required Pad File Size.\r
CaculatePadFileSize (\r
IN FV_DEVICE *FvDevice,\r
IN EFI_PHYSICAL_ADDRESS StartAddress,\r
+ IN UINTN BufferSize,\r
IN UINTN RequiredAlignment\r
)\r
{\r
UINTN RelativePos;\r
UINTN PadSize;\r
\r
- DataStartPos = (UINTN) StartAddress + sizeof (EFI_FFS_FILE_HEADER);\r
+ if (BufferSize > 0x00FFFFFF) {\r
+ DataStartPos = (UINTN) StartAddress + sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ DataStartPos = (UINTN) StartAddress + sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
RelativePos = DataStartPos - (UINTN) FvDevice->CachedFv;\r
\r
PadSize = 0;\r
PadFileSize = CaculatePadFileSize (\r
FvDevice,\r
(EFI_PHYSICAL_ADDRESS) (UINTN) FreeSpaceListEntry->StartingAddress,\r
+ Size,\r
RequiredAlignment\r
);\r
if (FreeSpaceListEntry->Length >= Size + PadFileSize) {\r
\r
}\r
\r
-/**\r
- Locate a free space that can hold this file.\r
-\r
- @param FvDevice Cached Firmware Volume.\r
- @param Size On input, it is the required size.\r
- On output, it is the actual size of free space.\r
- @param RequiredAlignment FFS File Data alignment requirement.\r
- @param PadSize Pointer to the size of leading Pad File.\r
- @param StartingAddress The starting address of the Free Space Entry\r
- that meets the requirement.\r
-\r
- @retval EFI_SUCCESS The free space is found.\r
- @retval EFI_NOT_FOUND The free space can't be found.\r
-\r
-**/\r
-EFI_STATUS\r
-FvLocateFreeSpace (\r
- IN FV_DEVICE *FvDevice,\r
- IN OUT UINTN *Size,\r
- IN UINTN RequiredAlignment,\r
- OUT UINTN *PadSize,\r
- OUT EFI_PHYSICAL_ADDRESS *StartingAddress\r
- )\r
-{\r
- EFI_STATUS Status;\r
- FREE_SPACE_ENTRY *FreeSpaceEntry;\r
-\r
- //\r
- // First find the free space entry\r
- //\r
- Status = FvLocateFreeSpaceEntry (\r
- FvDevice,\r
- *Size,\r
- RequiredAlignment,\r
- PadSize,\r
- &FreeSpaceEntry\r
- );\r
-\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
-\r
- *Size = FreeSpaceEntry->Length;\r
- *StartingAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) FreeSpaceEntry->StartingAddress;\r
-\r
- return EFI_SUCCESS;\r
-}\r
-\r
/**\r
Locate Pad File for writing, this is got from FV Cache.\r
\r
FFS_FILE_LIST_ENTRY *FileEntry;\r
EFI_FFS_FILE_STATE FileState;\r
EFI_FFS_FILE_HEADER *FileHeader;\r
- UINTN FileLength;\r
UINTN PadAreaLength;\r
UINTN PadFileSize;\r
+ UINTN HeaderSize;\r
\r
FileEntry = (FFS_FILE_LIST_ENTRY *) FvDevice->FfsFileListHeader.ForwardLink;\r
\r
//\r
// we find one valid pad file, check its free area length\r
//\r
- FileLength = *(UINT32 *) FileHeader->Size & 0x00FFFFFF;\r
- PadAreaLength = FileLength - sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (FileHeader)) {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+ PadAreaLength = FFS_FILE2_SIZE (FileHeader) - HeaderSize;\r
+ } else {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+ PadAreaLength = FFS_FILE_SIZE (FileHeader) - HeaderSize;\r
+ }\r
\r
PadFileSize = CaculatePadFileSize (\r
FvDevice,\r
- (EFI_PHYSICAL_ADDRESS) (UINTN) FileHeader + sizeof (EFI_FFS_FILE_HEADER),\r
+ (EFI_PHYSICAL_ADDRESS) (UINTN) FileHeader + HeaderSize,\r
+ Size,\r
RequiredAlignment\r
);\r
if (PadAreaLength >= (Size + PadFileSize)) {\r
FFS_FILE_LIST_ENTRY *FileEntry;\r
EFI_FFS_FILE_STATE FileState;\r
EFI_FFS_FILE_HEADER *FileHeader;\r
- UINTN FileLength;\r
UINTN PadAreaLength;\r
UINTN TotalSize;\r
UINTN Index;\r
+ UINTN HeaderSize;\r
\r
FileEntry = (FFS_FILE_LIST_ENTRY *) FvDevice->FfsFileListHeader.ForwardLink;\r
\r
//\r
// we find one valid pad file, check its length\r
//\r
- FileLength = *(UINT32 *) FileHeader->Size & 0x00FFFFFF;\r
- PadAreaLength = FileLength - sizeof (EFI_FFS_FILE_HEADER);\r
+ if (IS_FFS_FILE2 (FileHeader)) {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+ PadAreaLength = FFS_FILE2_SIZE (FileHeader) - HeaderSize;\r
+ } else {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+ PadAreaLength = FFS_FILE_SIZE (FileHeader) - HeaderSize;\r
+ }\r
TotalSize = 0;\r
\r
for (Index = 0; Index < NumOfFiles; Index++) {\r
PadSize[Index] = CaculatePadFileSize (\r
FvDevice,\r
- (EFI_PHYSICAL_ADDRESS) (UINTN) FileHeader + sizeof (EFI_FFS_FILE_HEADER) + TotalSize,\r
+ (EFI_PHYSICAL_ADDRESS) (UINTN) FileHeader + HeaderSize + TotalSize,\r
+ BufferSize[Index],\r
RequiredAlignment[Index]\r
);\r
TotalSize += PadSize[Index];\r
PadSize[Index] = CaculatePadFileSize (\r
FvDevice,\r
(EFI_PHYSICAL_ADDRESS) (UINTN) StartAddr + TotalSize,\r
+ BufferSize[Index],\r
RequiredAlignment[Index]\r
);\r
\r
FFS_FILE_LIST_ENTRY *PadFileEntry;\r
EFI_FFS_FILE_ATTRIBUTES TmpFileAttribute;\r
FFS_FILE_LIST_ENTRY *FfsFileEntry;\r
+ UINTN HeaderSize;\r
\r
//\r
// File Type: 0x0E~0xE0 are reserved\r
// Write Name, IntegrityCheck.Header, Type, Attributes, and Size\r
//\r
FileHeader = (EFI_FFS_FILE_HEADER *) FfsFileBuffer;\r
+ if (ActualFileSize > 0x00FFFFFF) {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+ } else {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+ }\r
SetFileState (EFI_FILE_HEADER_CONSTRUCTION, FileHeader);\r
\r
Offset = (UINTN) (BufferPtr - FvDevice->CachedFv);\r
CopyMem (\r
(UINT8 *) (UINTN) BufferPtr,\r
FileHeader,\r
- sizeof (EFI_FFS_FILE_HEADER)\r
+ HeaderSize\r
);\r
\r
//\r
- // update Free Space Entry, now need to substract the EFI_FFS_FILE_HEADER\r
+ // update Free Space Entry, now need to substract the file header length\r
//\r
- FreeSpaceEntry->StartingAddress += sizeof (EFI_FFS_FILE_HEADER);\r
- FreeSpaceEntry->Length -= sizeof (EFI_FFS_FILE_HEADER);\r
+ FreeSpaceEntry->StartingAddress += HeaderSize;\r
+ FreeSpaceEntry->Length -= HeaderSize;\r
\r
CopyGuid (&FileHeader->Name, FileName);\r
FileHeader->Type = FileType;\r
//\r
// File size is including the FFS File Header.\r
//\r
- *(UINT32 *) FileHeader->Size &= 0xFF000000;\r
- *(UINT32 *) FileHeader->Size |= ActualFileSize;\r
+ if (ActualFileSize > 0x00FFFFFF) {\r
+ ((EFI_FFS_FILE_HEADER2 *) FileHeader)->ExtendedSize = (UINT32) ActualFileSize;\r
+ *(UINT32 *) FileHeader->Size &= 0xFF000000;\r
+ FileHeader->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
+ } else {\r
+ *(UINT32 *) FileHeader->Size &= 0xFF000000;\r
+ *(UINT32 *) FileHeader->Size |= ActualFileSize;\r
+ }\r
\r
SetHeaderChecksum (FileHeader);\r
\r
Offset = (UINTN) (BufferPtr - FvDevice->CachedFv);\r
\r
- NumBytesWritten = sizeof (EFI_FFS_FILE_HEADER);\r
+ NumBytesWritten = HeaderSize;\r
Status = FvcWrite (\r
FvDevice,\r
Offset,\r
CopyMem (\r
(UINT8 *) (UINTN) BufferPtr,\r
FileHeader,\r
- sizeof (EFI_FFS_FILE_HEADER)\r
+ HeaderSize\r
);\r
\r
//\r
CopyMem (\r
(UINT8 *) (UINTN) BufferPtr,\r
FileHeader,\r
- sizeof (EFI_FFS_FILE_HEADER)\r
+ HeaderSize\r
);\r
\r
//\r
// update Free Space Entry, now need to substract the file data length\r
//\r
- FreeSpaceEntry->StartingAddress += (BufferSize - sizeof (EFI_FFS_FILE_HEADER));\r
- FreeSpaceEntry->Length -= (BufferSize - sizeof (EFI_FFS_FILE_HEADER));\r
+ FreeSpaceEntry->StartingAddress += (BufferSize - HeaderSize);\r
+ FreeSpaceEntry->Length -= (BufferSize - HeaderSize);\r
\r
//\r
// Caculate File Checksum\r
CopyMem (\r
(UINT8 *) (UINTN) BufferPtr,\r
FileHeader,\r
- sizeof (EFI_FFS_FILE_HEADER)\r
+ HeaderSize\r
);\r
\r
//\r
UINTN NumDelete;\r
EFI_FV_ATTRIBUTES FvAttributes;\r
UINT32 AuthenticationStatus;\r
+ UINTN HeaderSize;\r
\r
if (NumberOfFiles > MAX_FILES) {\r
return EFI_UNSUPPORTED;\r
//\r
NumDelete = 0;\r
for (Index1 = 0; Index1 < NumberOfFiles; Index1++) {\r
+\r
+ if ((FileData[Index1].BufferSize + sizeof (EFI_FFS_FILE_HEADER) > 0x00FFFFFF) && !FvDevice->IsFfs3Fv) {\r
+ //\r
+ // Found a file needs a FFS3 formatted file to store it, but it is in a non-FFS3 formatted FV.\r
+ //\r
+ DEBUG ((EFI_D_ERROR, "FFS3 formatted file can't be written in a non-FFS3 formatted FV.\n"));\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+\r
if (FileData[Index1].BufferSize == 0) {\r
//\r
// Here we will delete this file\r
//\r
// Making Buffersize QWORD boundry, and add file tail.\r
//\r
- ActualSize = FileData[Index1].BufferSize + sizeof (EFI_FFS_FILE_HEADER);\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+ ActualSize = FileData[Index1].BufferSize + HeaderSize;\r
+ if (ActualSize > 0x00FFFFFF) {\r
+ HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+ ActualSize = FileData[Index1].BufferSize + HeaderSize;\r
+ }\r
BufferSize = ActualSize;\r
\r
while ((BufferSize & 0x07) != 0) {\r
// Copy File Data into FileBuffer\r
//\r
CopyMem (\r
- FileBuffer + sizeof (EFI_FFS_FILE_HEADER),\r
+ FileBuffer + HeaderSize,\r
FileData[Index1].Buffer,\r
FileData[Index1].BufferSize\r
);\r
//\r
// Fill the file header and padding byte with Erase Byte\r
//\r
- for (Index2 = 0; Index2 < sizeof (EFI_FFS_FILE_HEADER); Index2++) {\r
+ for (Index2 = 0; Index2 < HeaderSize; Index2++) {\r
FileBuffer[Index2] = (UINT8)~FileBuffer[Index2];\r
}\r
\r
3) A support protocol is not found, and the data is not available to be read\r
without it. This results in EFI_PROTOCOL_ERROR.\r
\r
-Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
SectionHeader = (EFI_COMMON_SECTION_HEADER *)SectionStream;\r
\r
while (TotalLength < SectionStreamLength) {\r
- SectionLength = SECTION_SIZE (SectionHeader);\r
+ if (IS_SECTION2 (SectionHeader)) {\r
+ SectionLength = SECTION2_SIZE (SectionHeader);\r
+ } else {\r
+ SectionLength = SECTION_SIZE (SectionHeader);\r
+ }\r
TotalLength += SectionLength;\r
\r
if (TotalLength == SectionStreamLength) {\r
return TRUE;\r
}\r
GuidedSection = (EFI_GUID_DEFINED_SECTION * )(Stream->StreamBuffer + Child->OffsetInStream);\r
- return CompareGuid (&GuidedSection->SectionDefinitionGuid, SectionDefinitionGuid);\r
+ if (IS_SECTION2 (GuidedSection)) {\r
+ return CompareGuid (&(((EFI_GUID_DEFINED_SECTION2 *) GuidedSection)->SectionDefinitionGuid), SectionDefinitionGuid);\r
+ } else {\r
+ return CompareGuid (&GuidedSection->SectionDefinitionGuid, SectionDefinitionGuid);\r
+ }\r
}\r
\r
/**\r
);\r
ASSERT_EFI_ERROR (Status);\r
//\r
- // OR in the parent stream's aggregagate status.\r
+ // OR in the parent stream's aggregate status.\r
//\r
AuthenticationStatus |= Context->ParentStream->AuthenticationStatus & EFI_AGGREGATE_AUTH_STATUS_ALL;\r
Status = OpenSectionStreamEx (\r
UINT32 ScratchSize;\r
UINTN NewStreamBufferSize;\r
UINT32 AuthenticationStatus;\r
- UINT32 SectionLength;\r
+ VOID *CompressionSource;\r
+ UINT32 CompressionSourceSize;\r
+ UINT32 UncompressedLength;\r
+ UINT8 CompressionType;\r
+ UINT16 GuidedSectionAttributes;\r
\r
FRAMEWORK_SECTION_CHILD_NODE *Node;\r
\r
//\r
Node->Signature = FRAMEWORK_SECTION_CHILD_SIGNATURE;\r
Node->Type = SectionHeader->Type;\r
- Node->Size = SECTION_SIZE (SectionHeader);\r
+ if (IS_SECTION2 (SectionHeader)) {\r
+ Node->Size = SECTION2_SIZE (SectionHeader);\r
+ } else {\r
+ Node->Size = SECTION_SIZE (SectionHeader);\r
+ }\r
Node->OffsetInStream = ChildOffset;\r
Node->EncapsulatedStreamHandle = NULL_STREAM_HANDLE;\r
Node->EncapsulationGuid = NULL;\r
ASSERT (Node->Size >= sizeof (EFI_COMPRESSION_SECTION));\r
\r
CompressionHeader = (EFI_COMPRESSION_SECTION *) SectionHeader;\r
- \r
+\r
+ if (IS_SECTION2 (CompressionHeader)) {\r
+ CompressionSource = (VOID *) ((UINT8 *) CompressionHeader + sizeof (EFI_COMPRESSION_SECTION2));\r
+ CompressionSourceSize = (UINT32) (SECTION2_SIZE (CompressionHeader) - sizeof (EFI_COMPRESSION_SECTION2));\r
+ UncompressedLength = ((EFI_COMPRESSION_SECTION2 *) CompressionHeader)->UncompressedLength;\r
+ CompressionType = ((EFI_COMPRESSION_SECTION2 *) CompressionHeader)->CompressionType;\r
+ } else {\r
+ CompressionSource = (VOID *) ((UINT8 *) CompressionHeader + sizeof (EFI_COMPRESSION_SECTION));\r
+ CompressionSourceSize = (UINT32) (SECTION_SIZE (CompressionHeader) - sizeof (EFI_COMPRESSION_SECTION));\r
+ UncompressedLength = CompressionHeader->UncompressedLength;\r
+ CompressionType = CompressionHeader->CompressionType;\r
+ }\r
+\r
//\r
// Allocate space for the new stream\r
//\r
- if (CompressionHeader->UncompressedLength > 0) {\r
- NewStreamBufferSize = CompressionHeader->UncompressedLength;\r
+ if (UncompressedLength > 0) {\r
+ NewStreamBufferSize = UncompressedLength;\r
NewStreamBuffer = AllocatePool (NewStreamBufferSize);\r
if (NewStreamBuffer == NULL) {\r
FreePool (Node);\r
return EFI_OUT_OF_RESOURCES;\r
}\r
\r
- if (CompressionHeader->CompressionType == EFI_NOT_COMPRESSED) {\r
+ if (CompressionType == EFI_NOT_COMPRESSED) {\r
//\r
// stream is not actually compressed, just encapsulated. So just copy it.\r
//\r
- CopyMem (NewStreamBuffer, CompressionHeader + 1, NewStreamBufferSize);\r
- } else if (CompressionHeader->CompressionType == EFI_STANDARD_COMPRESSION) {\r
+ CopyMem (NewStreamBuffer, CompressionSource, NewStreamBufferSize);\r
+ } else if (CompressionType == EFI_STANDARD_COMPRESSION) {\r
//\r
// Only support the EFI_SATNDARD_COMPRESSION algorithm.\r
// \r
\r
Status = Decompress->GetInfo (\r
Decompress,\r
- CompressionHeader + 1,\r
- Node->Size - sizeof (EFI_COMPRESSION_SECTION),\r
+ CompressionSource,\r
+ CompressionSourceSize,\r
(UINT32 *)&NewStreamBufferSize,\r
&ScratchSize\r
);\r
ASSERT_EFI_ERROR (Status);\r
- ASSERT (NewStreamBufferSize == CompressionHeader->UncompressedLength);\r
+ ASSERT (NewStreamBufferSize == UncompressedLength);\r
\r
ScratchBuffer = AllocatePool (ScratchSize);\r
if (ScratchBuffer == NULL) {\r
\r
Status = Decompress->Decompress (\r
Decompress,\r
- CompressionHeader + 1,\r
- Node->Size - sizeof (EFI_COMPRESSION_SECTION),\r
+ CompressionSource,\r
+ CompressionSourceSize,\r
NewStreamBuffer,\r
(UINT32)NewStreamBufferSize,\r
ScratchBuffer,\r
\r
case EFI_SECTION_GUID_DEFINED:\r
GuidedHeader = (EFI_GUID_DEFINED_SECTION *) SectionHeader;\r
- Node->EncapsulationGuid = &GuidedHeader->SectionDefinitionGuid;\r
+ if (IS_SECTION2 (GuidedHeader)) {\r
+ Node->EncapsulationGuid = &(((EFI_GUID_DEFINED_SECTION2 *) GuidedHeader)->SectionDefinitionGuid);\r
+ GuidedSectionAttributes = ((EFI_GUID_DEFINED_SECTION2 *) GuidedHeader)->Attributes;\r
+ } else {\r
+ Node->EncapsulationGuid = &GuidedHeader->SectionDefinitionGuid;\r
+ GuidedSectionAttributes = GuidedHeader->Attributes;\r
+ }\r
Status = gBS->LocateProtocol (Node->EncapsulationGuid, NULL, (VOID **)&GuidedExtraction);\r
if (!EFI_ERROR (Status)) {\r
//\r
// Make sure we initialize the new stream with the correct \r
// authentication status for both aggregate and local status fields.\r
//\r
- if ((GuidedHeader->Attributes & EFI_GUIDED_SECTION_AUTH_STATUS_VALID) == EFI_GUIDED_SECTION_AUTH_STATUS_VALID) {\r
+ if ((GuidedSectionAttributes & EFI_GUIDED_SECTION_AUTH_STATUS_VALID) == EFI_GUIDED_SECTION_AUTH_STATUS_VALID) {\r
//\r
// OR in the parent stream's aggregate status.\r
//\r
//\r
// There's no GUIDed section extraction protocol available.\r
//\r
- if ((GuidedHeader->Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == EFI_GUIDED_SECTION_PROCESSING_REQUIRED) {\r
+ if ((GuidedSectionAttributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == EFI_GUIDED_SECTION_PROCESSING_REQUIRED) {\r
//\r
// If the section REQUIRES an extraction protocol, register for RPN \r
// when the required GUIDed extraction protocol becomes available. \r
// Figure out the proper authentication status\r
//\r
AuthenticationStatus = Stream->AuthenticationStatus;\r
- if ((GuidedHeader->Attributes & EFI_GUIDED_SECTION_AUTH_STATUS_VALID) == EFI_GUIDED_SECTION_AUTH_STATUS_VALID) {\r
+ if ((GuidedSectionAttributes & EFI_GUIDED_SECTION_AUTH_STATUS_VALID) == EFI_GUIDED_SECTION_AUTH_STATUS_VALID) {\r
//\r
// The local status of the new stream is contained in \r
// AuthenticaionStatus. This value needs to be ORed into the\r
AuthenticationStatus |= AuthenticationStatus >> 16;\r
}\r
\r
- SectionLength = SECTION_SIZE (GuidedHeader);\r
- Status = OpenSectionStreamEx (\r
- SectionLength - GuidedHeader->DataOffset,\r
- (UINT8 *) GuidedHeader + GuidedHeader->DataOffset,\r
- TRUE,\r
- AuthenticationStatus,\r
- &Node->EncapsulatedStreamHandle\r
- );\r
+ if (IS_SECTION2 (GuidedHeader)) {\r
+ Status = OpenSectionStreamEx (\r
+ SECTION2_SIZE (GuidedHeader) - ((EFI_GUID_DEFINED_SECTION2 *) GuidedHeader)->DataOffset,\r
+ (UINT8 *) GuidedHeader + ((EFI_GUID_DEFINED_SECTION2 *) GuidedHeader)->DataOffset,\r
+ TRUE,\r
+ AuthenticationStatus,\r
+ &Node->EncapsulatedStreamHandle\r
+ );\r
+ } else {\r
+ Status = OpenSectionStreamEx (\r
+ SECTION_SIZE (GuidedHeader) - ((EFI_GUID_DEFINED_SECTION *) GuidedHeader)->DataOffset,\r
+ (UINT8 *) GuidedHeader + ((EFI_GUID_DEFINED_SECTION *) GuidedHeader)->DataOffset,\r
+ TRUE,\r
+ AuthenticationStatus,\r
+ &Node->EncapsulatedStreamHandle\r
+ );\r
+ }\r
if (EFI_ERROR (Status)) {\r
FreePool (Node);\r
return Status;\r
UINTN Instance;\r
UINT8 *CopyBuffer;\r
UINTN SectionSize;\r
+ EFI_COMMON_SECTION_HEADER *Section;\r
\r
\r
OldTpl = gBS->RaiseTPL (TPL_NOTIFY);\r
}\r
ASSERT (ChildNode != NULL);\r
ASSERT (ChildStreamNode != NULL);\r
- CopySize = ChildNode->Size - sizeof (EFI_COMMON_SECTION_HEADER);\r
- CopyBuffer = ChildStreamNode->StreamBuffer + ChildNode->OffsetInStream + sizeof (EFI_COMMON_SECTION_HEADER);\r
+ Section = (EFI_COMMON_SECTION_HEADER *) (ChildStreamNode->StreamBuffer + ChildNode->OffsetInStream);\r
+\r
+ if (IS_SECTION2 (Section)) {\r
+ CopySize = SECTION2_SIZE (Section) - sizeof (EFI_COMMON_SECTION_HEADER2);\r
+ CopyBuffer = (UINT8 *) Section + sizeof (EFI_COMMON_SECTION_HEADER2);\r
+ } else {\r
+ CopySize = SECTION_SIZE (Section) - sizeof (EFI_COMMON_SECTION_HEADER);\r
+ CopyBuffer = (UINT8 *) Section + sizeof (EFI_COMMON_SECTION_HEADER);\r
+ }\r
*AuthenticationStatus = ExtractedAuthenticationStatus;\r
} \r
\r
projects / mirror_edk2.git / commitdiff