sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

SignedCapsulePkg: Apply uncrustify changes

Browse Source 
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3737

Apply uncrustify changes to .c/.h files in the SignedCapsulePkg package

Cc: Andrew Fish <afish@apple.com>
Cc: Leif Lindholm <leif@nuviainc.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com>
Reviewed-by: Jian J Wang <jian.j.wang@intel.com>
This commit is contained in:
Michael Kubacki
2021-12-05 14:54:14 -08:00
committed by mergify[bot]
parent 47d20b54f9
commit b878648967
15 changed files with 1336 additions and 1215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
SignedCapsulePkg/Include/Guid/EdkiiSystemFmpCapsule.h
View File

@ -7,7 +7,6 @@
**/ **/
#ifndef __EDKII_SYSTEM_FMP_CAPSULE_GUID_H__ #ifndef __EDKII_SYSTEM_FMP_CAPSULE_GUID_H__
#define __EDKII_SYSTEM_FMP_CAPSULE_GUID_H__ #define __EDKII_SYSTEM_FMP_CAPSULE_GUID_H__
@ -90,34 +89,34 @@
#pragma pack(1) #pragma pack(1)
typedef struct { typedef struct {
UINT32 Signature; UINT32 Signature;
UINT32 HeaderLength; // Length of EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR, excluding NameString UINT32 HeaderLength; // Length of EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR, excluding NameString
UINT32 Length; // Length of the data structure, including NameString UINT32 Length; // Length of the data structure, including NameString
// Below structure is similar as UEFI EFI_FIRMWARE_MANAGEMENT_PROTOCOL.GetPackageInfo() // Below structure is similar as UEFI EFI_FIRMWARE_MANAGEMENT_PROTOCOL.GetPackageInfo()
UINT32 PackageVersion; UINT32 PackageVersion;
UINT32 PackageVersionNameStringOffset; // Offset from head, CHAR16 string including NULL terminate char UINT32 PackageVersionNameStringOffset; // Offset from head, CHAR16 string including NULL terminate char
// Below structure is similar as UEFI EFI_FIRMWARE_IMAGE_DESCRIPTOR // Below structure is similar as UEFI EFI_FIRMWARE_IMAGE_DESCRIPTOR
UINT8 ImageIndex; UINT8 ImageIndex;
UINT8 Reserved[3]; UINT8 Reserved[3];
EFI_GUID ImageTypeId; EFI_GUID ImageTypeId;
UINT64 ImageId; UINT64 ImageId;
UINT32 ImageIdNameStringOffset; // Offset from head, CHAR16 string including NULL terminate char UINT32 ImageIdNameStringOffset; // Offset from head, CHAR16 string including NULL terminate char
UINT32 Version; UINT32 Version;
UINT32 VersionNameStringOffset; // Offset from head, CHAR16 string including NULL terminate char UINT32 VersionNameStringOffset; // Offset from head, CHAR16 string including NULL terminate char
UINT8 Reserved2[4]; UINT8 Reserved2[4];
UINT64 Size; UINT64 Size;
UINT64 AttributesSupported; UINT64 AttributesSupported;
UINT64 AttributesSetting; UINT64 AttributesSetting;
UINT64 Compatibilities; UINT64 Compatibilities;
UINT32 LowestSupportedImageVersion; UINT32 LowestSupportedImageVersion;
UINT32 LastAttemptVersion; UINT32 LastAttemptVersion;
UINT32 LastAttemptStatus; UINT32 LastAttemptStatus;
UINT8 Reserved3[4]; UINT8 Reserved3[4];
UINT64 HardwareInstance; UINT64 HardwareInstance;
// real string data // real string data
//CHAR16 ImageIdNameStr[]; // CHAR16 string including NULL terminate char // CHAR16 ImageIdNameStr[]; // CHAR16 string including NULL terminate char
//CHAR16 VersionNameStr[]; // CHAR16 string including NULL terminate char // CHAR16 VersionNameStr[]; // CHAR16 string including NULL terminate char
//CHAR16 PackageVersionNameStr[]; // CHAR16 string including NULL terminate char // CHAR16 PackageVersionNameStr[]; // CHAR16 string including NULL terminate char
} EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR; } EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR;
#pragma pack() #pragma pack()
@ -138,8 +137,8 @@ typedef struct {
+----------------------+ +----------------------+
**/ **/
extern EFI_GUID gEdkiiSystemFirmwareImageDescriptorFileGuid; extern EFI_GUID gEdkiiSystemFirmwareImageDescriptorFileGuid;
extern EFI_GUID gEdkiiSystemFmpCapsuleConfigFileGuid; extern EFI_GUID gEdkiiSystemFmpCapsuleConfigFileGuid;
extern EFI_GUID gEdkiiSystemFmpCapsuleDriverFvFileGuid; extern EFI_GUID gEdkiiSystemFmpCapsuleDriverFvFileGuid;
#endif #endif

58
SignedCapsulePkg/Include/Library/EdkiiSystemCapsuleLib.h
View File

@ -6,7 +6,6 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
**/ **/
#ifndef __EDKII_SYSTEM_CAPSULE_LIB_H__ #ifndef __EDKII_SYSTEM_CAPSULE_LIB_H__
#define __EDKII_SYSTEM_CAPSULE_LIB_H__ #define __EDKII_SYSTEM_CAPSULE_LIB_H__
@ -26,10 +25,10 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractSystemFirmwareImageFmpInfo ( ExtractSystemFirmwareImageFmpInfo (
IN VOID *SystemFirmwareImage, IN VOID *SystemFirmwareImage,
IN UINTN SystemFirmwareImageSize, IN UINTN SystemFirmwareImageSize,
OUT EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR **ImageFmpInfo, OUT EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR **ImageFmpInfo,
OUT UINTN *ImageFmpInfoSize OUT UINTN *ImageFmpInfoSize
); );
/** /**
@ -46,10 +45,10 @@ ExtractSystemFirmwareImageFmpInfo (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractDriverFvImage ( ExtractDriverFvImage (
IN VOID *AuthenticatedImage, IN VOID *AuthenticatedImage,
IN UINTN AuthenticatedImageSize, IN UINTN AuthenticatedImageSize,
OUT VOID **DriverFvImage, OUT VOID **DriverFvImage,
OUT UINTN *DriverFvImageSize OUT UINTN *DriverFvImageSize
); );
/** /**
@ -66,10 +65,10 @@ ExtractDriverFvImage (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractConfigImage ( ExtractConfigImage (
IN VOID *AuthenticatedImage, IN VOID *AuthenticatedImage,
IN UINTN AuthenticatedImageSize, IN UINTN AuthenticatedImageSize,
OUT VOID **ConfigImage, OUT VOID **ConfigImage,
OUT UINTN *ConfigImageSize OUT UINTN *ConfigImageSize
); );
/** /**
@ -86,10 +85,10 @@ ExtractConfigImage (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractSystemFirmwareImage ( ExtractSystemFirmwareImage (
IN VOID *AuthenticatedImage, IN VOID *AuthenticatedImage,
IN UINTN AuthenticatedImageSize, IN UINTN AuthenticatedImageSize,
OUT VOID **SystemFirmwareImage, OUT VOID **SystemFirmwareImage,
OUT UINTN *SystemFirmwareImageSize OUT UINTN *SystemFirmwareImageSize
); );
/** /**
@ -107,11 +106,11 @@ ExtractSystemFirmwareImage (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractAuthenticatedImage ( ExtractAuthenticatedImage (
IN VOID *Image, IN VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
OUT UINT32 *LastAttemptStatus, OUT UINT32 *LastAttemptStatus,
OUT VOID **AuthenticatedImage, OUT VOID **AuthenticatedImage,
OUT UINTN *AuthenticatedImageSize OUT UINTN *AuthenticatedImageSize
); );
/** /**
@ -135,14 +134,13 @@ ExtractAuthenticatedImage (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
CapsuleAuthenticateSystemFirmware ( CapsuleAuthenticateSystemFirmware (
IN VOID *Image, IN VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
IN BOOLEAN ForceVersionMatch, IN BOOLEAN ForceVersionMatch,
OUT UINT32 *LastAttemptVersion, OUT UINT32 *LastAttemptVersion,
OUT UINT32 *LastAttemptStatus, OUT UINT32 *LastAttemptStatus,
OUT VOID **AuthenticatedImage, OUT VOID **AuthenticatedImage,
OUT UINTN *AuthenticatedImageSize OUT UINTN *AuthenticatedImageSize
); );
#endif #endif

48
SignedCapsulePkg/Include/Library/IniParsingLib.h
View File

@ -24,7 +24,6 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
**/ **/
#ifndef __INI_PARSING_LIB_H__ #ifndef __INI_PARSING_LIB_H__
#define __INI_PARSING_LIB_H__ #define __INI_PARSING_LIB_H__
@ -41,8 +40,8 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
VOID * VOID *
EFIAPI EFIAPI
OpenIniFile ( OpenIniFile (
IN UINT8 *DataBuffer, IN UINT8 *DataBuffer,
IN UINTN BufferSize IN UINTN BufferSize
); );
/** /**
@ -59,10 +58,10 @@ OpenIniFile (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
GetStringFromDataFile ( GetStringFromDataFile (
IN VOID *Context, IN VOID *Context,
IN CHAR8 *SectionName, IN CHAR8 *SectionName,
IN CHAR8 *EntryName, IN CHAR8 *EntryName,
OUT CHAR8 **EntryValue OUT CHAR8 **EntryValue
); );
/** /**
@ -79,10 +78,10 @@ GetStringFromDataFile (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
GetGuidFromDataFile ( GetGuidFromDataFile (
IN VOID *Context, IN VOID *Context,
IN CHAR8 *SectionName, IN CHAR8 *SectionName,
IN CHAR8 *EntryName, IN CHAR8 *EntryName,
OUT EFI_GUID *Guid OUT EFI_GUID *Guid
); );
/** /**
@ -99,10 +98,10 @@ GetGuidFromDataFile (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
GetDecimalUintnFromDataFile ( GetDecimalUintnFromDataFile (
IN VOID *Context, IN VOID *Context,
IN CHAR8 *SectionName, IN CHAR8 *SectionName,
IN CHAR8 *EntryName, IN CHAR8 *EntryName,
OUT UINTN *Data OUT UINTN *Data
); );
/** /**
@ -119,10 +118,10 @@ GetDecimalUintnFromDataFile (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
GetHexUintnFromDataFile ( GetHexUintnFromDataFile (
IN VOID *Context, IN VOID *Context,
IN CHAR8 *SectionName, IN CHAR8 *SectionName,
IN CHAR8 *EntryName, IN CHAR8 *EntryName,
OUT UINTN *Data OUT UINTN *Data
); );
/** /**
@ -139,10 +138,10 @@ GetHexUintnFromDataFile (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
GetHexUint64FromDataFile ( GetHexUint64FromDataFile (
IN VOID *Context, IN VOID *Context,
IN CHAR8 *SectionName, IN CHAR8 *SectionName,
IN CHAR8 *EntryName, IN CHAR8 *EntryName,
OUT UINT64 *Data OUT UINT64 *Data
); );
/** /**
@ -153,8 +152,7 @@ GetHexUint64FromDataFile (
VOID VOID
EFIAPI EFIAPI
CloseIniFile ( CloseIniFile (
IN VOID *Context IN VOID *Context
); );
#endif #endif

11
SignedCapsulePkg/Include/Library/PlatformFlashAccessLib.h
View File

@ -6,7 +6,6 @@
**/ **/
#ifndef __PLATFORM_FLASH_ACCESS_LIB_H__ #ifndef __PLATFORM_FLASH_ACCESS_LIB_H__
#define __PLATFORM_FLASH_ACCESS_LIB_H__ #define __PLATFORM_FLASH_ACCESS_LIB_H__
@ -43,11 +42,11 @@ typedef enum {
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
PerformFlashWrite ( PerformFlashWrite (
IN PLATFORM_FIRMWARE_TYPE FirmwareType, IN PLATFORM_FIRMWARE_TYPE FirmwareType,
IN EFI_PHYSICAL_ADDRESS FlashAddress, IN EFI_PHYSICAL_ADDRESS FlashAddress,
IN FLASH_ADDRESS_TYPE FlashAddressType, IN FLASH_ADDRESS_TYPE FlashAddressType,
IN VOID *Buffer, IN VOID *Buffer,
IN UINTN Length IN UINTN Length
); );
/** /**

442
SignedCapsulePkg/Library/EdkiiSystemCapsuleLib/EdkiiSystemCapsuleLib.c
View File

@ -30,9 +30,9 @@
#include <Protocol/FirmwareManagement.h> #include <Protocol/FirmwareManagement.h>
EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *mImageFmpInfo; EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *mImageFmpInfo;
UINTN mImageFmpInfoSize; UINTN mImageFmpInfoSize;
EFI_GUID mEdkiiSystemFirmwareFileGuid; EFI_GUID mEdkiiSystemFirmwareFileGuid;
/** /**
Check if a block of buffer is erased. Check if a block of buffer is erased.
@ -46,16 +46,16 @@ EFI_GUID mEdkiiSystemFirmwareFileGuid;
**/ **/
BOOLEAN BOOLEAN
IsBufferErased ( IsBufferErased (
IN UINT8 ErasePolarity, IN UINT8 ErasePolarity,
IN VOID *InBuffer, IN VOID *InBuffer,
IN UINTN BufferSize IN UINTN BufferSize
) )
{ {
UINTN Count; UINTN Count;
UINT8 EraseByte; UINT8 EraseByte;
UINT8 *Buffer; UINT8 *Buffer;
if(ErasePolarity == 1) { if (ErasePolarity == 1) {
EraseByte = 0xFF; EraseByte = 0xFF;
} else { } else {
EraseByte = 0; EraseByte = 0;
@ -86,17 +86,17 @@ IsBufferErased (
**/ **/
BOOLEAN BOOLEAN
GetSectionByType ( GetSectionByType (
IN VOID *SectionBuffer, IN VOID *SectionBuffer,
IN UINT32 SectionBufferSize, IN UINT32 SectionBufferSize,
IN EFI_SECTION_TYPE SectionType, IN EFI_SECTION_TYPE SectionType,
IN UINTN SectionInstance, IN UINTN SectionInstance,
OUT VOID **OutSectionBuffer, OUT VOID **OutSectionBuffer,
OUT UINTN *OutSectionSize OUT UINTN *OutSectionSize
) )
{ {
EFI_COMMON_SECTION_HEADER *SectionHeader; EFI_COMMON_SECTION_HEADER *SectionHeader;
UINTN SectionSize; UINTN SectionSize;
UINTN Instance; UINTN Instance;
DEBUG ((DEBUG_INFO, "GetSectionByType - Buffer: 0x%08x - 0x%08x\n", SectionBuffer, SectionBufferSize)); DEBUG ((DEBUG_INFO, "GetSectionByType - Buffer: 0x%08x - 0x%08x\n", SectionBuffer, SectionBufferSize));
@ -108,20 +108,20 @@ GetSectionByType (
Instance = 0; Instance = 0;
while ((UINTN)SectionHeader < (UINTN)SectionBuffer + SectionBufferSize) { while ((UINTN)SectionHeader < (UINTN)SectionBuffer + SectionBufferSize) {
DEBUG ((DEBUG_INFO, "GetSectionByType - Section: 0x%08x\n", SectionHeader)); DEBUG ((DEBUG_INFO, "GetSectionByType - Section: 0x%08x\n", SectionHeader));
if (IS_SECTION2(SectionHeader)) { if (IS_SECTION2 (SectionHeader)) {
SectionSize = SECTION2_SIZE(SectionHeader); SectionSize = SECTION2_SIZE (SectionHeader);
} else { } else {
SectionSize = SECTION_SIZE(SectionHeader); SectionSize = SECTION_SIZE (SectionHeader);
} }
if (SectionHeader->Type == SectionType) { if (SectionHeader->Type == SectionType) {
if (Instance == SectionInstance) { if (Instance == SectionInstance) {
*OutSectionBuffer = (UINT8 *)SectionHeader; *OutSectionBuffer = (UINT8 *)SectionHeader;
*OutSectionSize = SectionSize; *OutSectionSize = SectionSize;
DEBUG((DEBUG_INFO, "GetSectionByType - 0x%x - 0x%x\n", *OutSectionBuffer, *OutSectionSize)); DEBUG ((DEBUG_INFO, "GetSectionByType - 0x%x - 0x%x\n", *OutSectionBuffer, *OutSectionSize));
return TRUE; return TRUE;
} else { } else {
DEBUG((DEBUG_INFO, "GetSectionByType - find section instance %x\n", Instance)); DEBUG ((DEBUG_INFO, "GetSectionByType - find section instance %x\n", Instance));
Instance++; Instance++;
} }
} else { } else {
@ -134,7 +134,7 @@ GetSectionByType (
// //
// Next Section // Next Section
// //
SectionHeader = (EFI_COMMON_SECTION_HEADER *)((UINTN)SectionHeader + ALIGN_VALUE(SectionSize, 4)); SectionHeader = (EFI_COMMON_SECTION_HEADER *)((UINTN)SectionHeader + ALIGN_VALUE (SectionSize, 4));
} }
return FALSE; return FALSE;
@ -155,25 +155,25 @@ GetSectionByType (
**/ **/
BOOLEAN BOOLEAN
GetFfsByName ( GetFfsByName (
IN VOID *FdStart, IN VOID *FdStart,
IN UINTN FdSize, IN UINTN FdSize,
IN EFI_GUID *FileName, IN EFI_GUID *FileName,
IN EFI_FV_FILETYPE Type, IN EFI_FV_FILETYPE Type,
OUT VOID **OutFfsBuffer, OUT VOID **OutFfsBuffer,
OUT UINTN *OutFfsBufferSize OUT UINTN *OutFfsBufferSize
) )
{ {
UINTN FvSize; UINTN FvSize;
EFI_FIRMWARE_VOLUME_HEADER *FvHeader; EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
EFI_FIRMWARE_VOLUME_EXT_HEADER *FvExtHeader; EFI_FIRMWARE_VOLUME_EXT_HEADER *FvExtHeader;
EFI_FFS_FILE_HEADER *FfsHeader; EFI_FFS_FILE_HEADER *FfsHeader;
UINT32 FfsSize; UINT32 FfsSize;
UINTN TestLength; UINTN TestLength;
BOOLEAN FvFound; BOOLEAN FvFound;
DEBUG ((DEBUG_INFO, "GetFfsByName - FV: 0x%08x - 0x%08x\n", (UINTN)FdStart, (UINTN)FdSize)); DEBUG ((DEBUG_INFO, "GetFfsByName - FV: 0x%08x - 0x%08x\n", (UINTN)FdStart, (UINTN)FdSize));
FvFound = FALSE; FvFound = FALSE;
FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)FdStart; FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)FdStart;
while ((UINTN)FvHeader < (UINTN)FdStart + FdSize - 1) { while ((UINTN)FvHeader < (UINTN)FdStart + FdSize - 1) {
FvSize = (UINTN)FdStart + FdSize - (UINTN)FvHeader; FvSize = (UINTN)FdStart + FdSize - (UINTN)FvHeader;
@ -182,12 +182,14 @@ GetFfsByName (
FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)((UINTN)FvHeader + SIZE_4KB); FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)((UINTN)FvHeader + SIZE_4KB);
continue; continue;
} }
DEBUG((DEBUG_INFO, "checking FV....0x%08x - 0x%x\n", FvHeader, FvHeader->FvLength));
DEBUG ((DEBUG_INFO, "checking FV....0x%08x - 0x%x\n", FvHeader, FvHeader->FvLength));
FvFound = TRUE; FvFound = TRUE;
if (FvHeader->FvLength > FvSize) { if (FvHeader->FvLength > FvSize) {
DEBUG((DEBUG_ERROR, "GetFfsByName - FvSize: 0x%08x, MaxSize - 0x%08x\n", (UINTN)FvHeader->FvLength, (UINTN)FvSize)); DEBUG ((DEBUG_ERROR, "GetFfsByName - FvSize: 0x%08x, MaxSize - 0x%08x\n", (UINTN)FvHeader->FvLength, (UINTN)FvSize));
return FALSE; return FALSE;
} }
FvSize = (UINTN)FvHeader->FvLength; FvSize = (UINTN)FvHeader->FvLength;
// //
@ -195,44 +197,47 @@ GetFfsByName (
// //
if (FvHeader->ExtHeaderOffset != 0) { if (FvHeader->ExtHeaderOffset != 0) {
FvExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)((UINT8 *)FvHeader + FvHeader->ExtHeaderOffset); FvExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)((UINT8 *)FvHeader + FvHeader->ExtHeaderOffset);
FfsHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FvExtHeader + FvExtHeader->ExtHeaderSize); FfsHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FvExtHeader + FvExtHeader->ExtHeaderSize);
} else { } else {
FfsHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FvHeader + FvHeader->HeaderLength); FfsHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FvHeader + FvHeader->HeaderLength);
} }
FfsHeader = (EFI_FFS_FILE_HEADER *)((UINTN)FvHeader + ALIGN_VALUE((UINTN)FfsHeader - (UINTN)FvHeader, 8));
FfsHeader = (EFI_FFS_FILE_HEADER *)((UINTN)FvHeader + ALIGN_VALUE ((UINTN)FfsHeader - (UINTN)FvHeader, 8));
while ((UINTN)FfsHeader < (UINTN)FvHeader + FvSize - 1) { while ((UINTN)FfsHeader < (UINTN)FvHeader + FvSize - 1) {
DEBUG((DEBUG_INFO, "GetFfsByName - FFS: 0x%08x\n", FfsHeader)); DEBUG ((DEBUG_INFO, "GetFfsByName - FFS: 0x%08x\n", FfsHeader));
TestLength = (UINTN)((UINTN)FvHeader + FvSize - (UINTN)FfsHeader); TestLength = (UINTN)((UINTN)FvHeader + FvSize - (UINTN)FfsHeader);
if (TestLength > sizeof(EFI_FFS_FILE_HEADER)) { if (TestLength > sizeof (EFI_FFS_FILE_HEADER)) {
TestLength = sizeof(EFI_FFS_FILE_HEADER); TestLength = sizeof (EFI_FFS_FILE_HEADER);
} }
if (IsBufferErased(1, FfsHeader, TestLength)) {
if (IsBufferErased (1, FfsHeader, TestLength)) {
break; break;
} }
if (IS_FFS_FILE2(FfsHeader)) { if (IS_FFS_FILE2 (FfsHeader)) {
FfsSize = FFS_FILE2_SIZE(FfsHeader); FfsSize = FFS_FILE2_SIZE (FfsHeader);
} else { } else {
FfsSize = FFS_FILE_SIZE(FfsHeader); FfsSize = FFS_FILE_SIZE (FfsHeader);
} }
if (CompareGuid(FileName, &FfsHeader->Name) && if (CompareGuid (FileName, &FfsHeader->Name) &&
((Type == EFI_FV_FILETYPE_ALL) || (FfsHeader->Type == Type))) { ((Type == EFI_FV_FILETYPE_ALL) || (FfsHeader->Type == Type)))
*OutFfsBuffer = FfsHeader; {
*OutFfsBuffer = FfsHeader;
*OutFfsBufferSize = FfsSize; *OutFfsBufferSize = FfsSize;
return TRUE; return TRUE;
} else { } else {
// //
// Any other type is not allowed // Any other type is not allowed
// //
DEBUG((DEBUG_INFO, "GetFfsByName - other FFS type 0x%x, name %g\n", FfsHeader->Type, &FfsHeader->Name)); DEBUG ((DEBUG_INFO, "GetFfsByName - other FFS type 0x%x, name %g\n", FfsHeader->Type, &FfsHeader->Name));
} }
// //
// Next File // Next File
// //
FfsHeader = (EFI_FFS_FILE_HEADER *)((UINTN)FfsHeader + ALIGN_VALUE(FfsSize, 8)); FfsHeader = (EFI_FFS_FILE_HEADER *)((UINTN)FfsHeader + ALIGN_VALUE (FfsSize, 8));
} }
// //
@ -242,8 +247,9 @@ GetFfsByName (
} }
if (!FvFound) { if (!FvFound) {
DEBUG((DEBUG_ERROR, "GetFfsByName - NO FV Found\n")); DEBUG ((DEBUG_ERROR, "GetFfsByName - NO FV Found\n"));
} }
return FALSE; return FALSE;
} }
@ -261,29 +267,30 @@ GetFfsByName (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractDriverFvImage ( ExtractDriverFvImage (
IN VOID *AuthenticatedImage, IN VOID *AuthenticatedImage,
IN UINTN AuthenticatedImageSize, IN UINTN AuthenticatedImageSize,
OUT VOID **DriverFvImage, OUT VOID **DriverFvImage,
OUT UINTN *DriverFvImageSize OUT UINTN *DriverFvImageSize
) )
{ {
BOOLEAN Result; BOOLEAN Result;
UINT32 FileHeaderSize; UINT32 FileHeaderSize;
*DriverFvImage = NULL; *DriverFvImage = NULL;
*DriverFvImageSize = 0; *DriverFvImageSize = 0;
Result = GetFfsByName(AuthenticatedImage, AuthenticatedImageSize, &gEdkiiSystemFmpCapsuleDriverFvFileGuid, EFI_FV_FILETYPE_RAW, DriverFvImage, DriverFvImageSize); Result = GetFfsByName (AuthenticatedImage, AuthenticatedImageSize, &gEdkiiSystemFmpCapsuleDriverFvFileGuid, EFI_FV_FILETYPE_RAW, DriverFvImage, DriverFvImageSize);
if (!Result) { if (!Result) {
return FALSE; return FALSE;
} }
if (IS_FFS_FILE2(*DriverFvImage)) { if (IS_FFS_FILE2 (*DriverFvImage)) {
FileHeaderSize = sizeof(EFI_FFS_FILE_HEADER2); FileHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
} else { } else {
FileHeaderSize = sizeof(EFI_FFS_FILE_HEADER); FileHeaderSize = sizeof (EFI_FFS_FILE_HEADER);
} }
*DriverFvImage = (UINT8 *)*DriverFvImage + FileHeaderSize;
*DriverFvImage = (UINT8 *)*DriverFvImage + FileHeaderSize;
*DriverFvImageSize = *DriverFvImageSize - FileHeaderSize; *DriverFvImageSize = *DriverFvImageSize - FileHeaderSize;
return Result; return Result;
@ -303,29 +310,30 @@ ExtractDriverFvImage (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractConfigImage ( ExtractConfigImage (
IN VOID *AuthenticatedImage, IN VOID *AuthenticatedImage,
IN UINTN AuthenticatedImageSize, IN UINTN AuthenticatedImageSize,
OUT VOID **ConfigImage, OUT VOID **ConfigImage,
OUT UINTN *ConfigImageSize OUT UINTN *ConfigImageSize
) )
{ {
BOOLEAN Result; BOOLEAN Result;
UINT32 FileHeaderSize; UINT32 FileHeaderSize;
*ConfigImage = NULL; *ConfigImage = NULL;
*ConfigImageSize = 0; *ConfigImageSize = 0;
Result = GetFfsByName(AuthenticatedImage, AuthenticatedImageSize, &gEdkiiSystemFmpCapsuleConfigFileGuid, EFI_FV_FILETYPE_RAW, ConfigImage, ConfigImageSize); Result = GetFfsByName (AuthenticatedImage, AuthenticatedImageSize, &gEdkiiSystemFmpCapsuleConfigFileGuid, EFI_FV_FILETYPE_RAW, ConfigImage, ConfigImageSize);
if (!Result) { if (!Result) {
return FALSE; return FALSE;
} }
if (IS_FFS_FILE2(*ConfigImage)) { if (IS_FFS_FILE2 (*ConfigImage)) {
FileHeaderSize = sizeof(EFI_FFS_FILE_HEADER2); FileHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
} else { } else {
FileHeaderSize = sizeof(EFI_FFS_FILE_HEADER); FileHeaderSize = sizeof (EFI_FFS_FILE_HEADER);
} }
*ConfigImage = (UINT8 *)*ConfigImage + FileHeaderSize;
*ConfigImage = (UINT8 *)*ConfigImage + FileHeaderSize;
*ConfigImageSize = *ConfigImageSize - FileHeaderSize; *ConfigImageSize = *ConfigImageSize - FileHeaderSize;
return Result; return Result;
@ -348,20 +356,20 @@ ExtractConfigImage (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractAuthenticatedImage ( ExtractAuthenticatedImage (
IN VOID *Image, IN VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
OUT UINT32 *LastAttemptStatus, OUT UINT32 *LastAttemptStatus,
OUT VOID **AuthenticatedImage, OUT VOID **AuthenticatedImage,
OUT UINTN *AuthenticatedImageSize OUT UINTN *AuthenticatedImageSize
) )
{ {
EFI_FIRMWARE_IMAGE_AUTHENTICATION *ImageAuth; EFI_FIRMWARE_IMAGE_AUTHENTICATION *ImageAuth;
EFI_STATUS Status; EFI_STATUS Status;
GUID *CertType; GUID *CertType;
VOID *PublicKeyData; VOID *PublicKeyData;
UINTN PublicKeyDataLength; UINTN PublicKeyDataLength;
DEBUG((DEBUG_INFO, "ExtractAuthenticatedImage - Image: 0x%08x - 0x%08x\n", (UINTN)Image, (UINTN)ImageSize)); DEBUG ((DEBUG_INFO, "ExtractAuthenticatedImage - Image: 0x%08x - 0x%08x\n", (UINTN)Image, (UINTN)ImageSize));
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
if ((Image == NULL) || (ImageSize == 0)) { if ((Image == NULL) || (ImageSize == 0)) {
@ -369,82 +377,91 @@ ExtractAuthenticatedImage (
} }
ImageAuth = (EFI_FIRMWARE_IMAGE_AUTHENTICATION *)Image; ImageAuth = (EFI_FIRMWARE_IMAGE_AUTHENTICATION *)Image;
if (ImageSize < sizeof(EFI_FIRMWARE_IMAGE_AUTHENTICATION)) { if (ImageSize < sizeof (EFI_FIRMWARE_IMAGE_AUTHENTICATION)) {
DEBUG((DEBUG_ERROR, "ExtractAuthenticatedImage - ImageSize too small\n")); DEBUG ((DEBUG_ERROR, "ExtractAuthenticatedImage - ImageSize too small\n"));
return FALSE; return FALSE;
} }
if (ImageAuth->AuthInfo.Hdr.dwLength <= OFFSET_OF(WIN_CERTIFICATE_UEFI_GUID, CertData)) {
DEBUG((DEBUG_ERROR, "ExtractAuthenticatedImage - dwLength too small\n")); if (ImageAuth->AuthInfo.Hdr.dwLength <= OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData)) {
DEBUG ((DEBUG_ERROR, "ExtractAuthenticatedImage - dwLength too small\n"));
return FALSE; return FALSE;
} }
if ((UINTN) ImageAuth->AuthInfo.Hdr.dwLength > MAX_UINTN - sizeof(UINT64)) {
DEBUG((DEBUG_ERROR, "ExtractAuthenticatedImage - dwLength too big\n")); if ((UINTN)ImageAuth->AuthInfo.Hdr.dwLength > MAX_UINTN - sizeof (UINT64)) {
DEBUG ((DEBUG_ERROR, "ExtractAuthenticatedImage - dwLength too big\n"));
return FALSE; return FALSE;
} }
if (ImageSize <= sizeof(ImageAuth->MonotonicCount) + ImageAuth->AuthInfo.Hdr.dwLength) {
DEBUG((DEBUG_ERROR, "ExtractAuthenticatedImage - ImageSize too small\n")); if (ImageSize <= sizeof (ImageAuth->MonotonicCount) + ImageAuth->AuthInfo.Hdr.dwLength) {
DEBUG ((DEBUG_ERROR, "ExtractAuthenticatedImage - ImageSize too small\n"));
return FALSE; return FALSE;
} }
if (ImageAuth->AuthInfo.Hdr.wRevision != 0x0200) { if (ImageAuth->AuthInfo.Hdr.wRevision != 0x0200) {
DEBUG((DEBUG_ERROR, "ExtractAuthenticatedImage - wRevision: 0x%02x, expect - 0x%02x\n", (UINTN)ImageAuth->AuthInfo.Hdr.wRevision, (UINTN)0x0200)); DEBUG ((DEBUG_ERROR, "ExtractAuthenticatedImage - wRevision: 0x%02x, expect - 0x%02x\n", (UINTN)ImageAuth->AuthInfo.Hdr.wRevision, (UINTN)0x0200));
return FALSE; return FALSE;
} }
if (ImageAuth->AuthInfo.Hdr.wCertificateType != WIN_CERT_TYPE_EFI_GUID) { if (ImageAuth->AuthInfo.Hdr.wCertificateType != WIN_CERT_TYPE_EFI_GUID) {
DEBUG((DEBUG_ERROR, "ExtractAuthenticatedImage - wCertificateType: 0x%02x, expect - 0x%02x\n", (UINTN)ImageAuth->AuthInfo.Hdr.wCertificateType, (UINTN)WIN_CERT_TYPE_EFI_GUID)); DEBUG ((DEBUG_ERROR, "ExtractAuthenticatedImage - wCertificateType: 0x%02x, expect - 0x%02x\n", (UINTN)ImageAuth->AuthInfo.Hdr.wCertificateType, (UINTN)WIN_CERT_TYPE_EFI_GUID));
return FALSE; return FALSE;
} }
CertType = &ImageAuth->AuthInfo.CertType; CertType = &ImageAuth->AuthInfo.CertType;
DEBUG((DEBUG_INFO, "ExtractAuthenticatedImage - CertType: %g\n", CertType)); DEBUG ((DEBUG_INFO, "ExtractAuthenticatedImage - CertType: %g\n", CertType));
if (CompareGuid(&gEfiCertPkcs7Guid, CertType)) { if (CompareGuid (&gEfiCertPkcs7Guid, CertType)) {
PublicKeyData = PcdGetPtr(PcdPkcs7CertBuffer); PublicKeyData = PcdGetPtr (PcdPkcs7CertBuffer);
PublicKeyDataLength = PcdGetSize(PcdPkcs7CertBuffer); PublicKeyDataLength = PcdGetSize (PcdPkcs7CertBuffer);
} else if (CompareGuid(&gEfiCertTypeRsa2048Sha256Guid, CertType)) { } else if (CompareGuid (&gEfiCertTypeRsa2048Sha256Guid, CertType)) {
PublicKeyData = PcdGetPtr(PcdRsa2048Sha256PublicKeyBuffer); PublicKeyData = PcdGetPtr (PcdRsa2048Sha256PublicKeyBuffer);
PublicKeyDataLength = PcdGetSize(PcdRsa2048Sha256PublicKeyBuffer); PublicKeyDataLength = PcdGetSize (PcdRsa2048Sha256PublicKeyBuffer);
} else { } else {
return FALSE; return FALSE;
} }
ASSERT (PublicKeyData != NULL); ASSERT (PublicKeyData != NULL);
ASSERT (PublicKeyDataLength != 0); ASSERT (PublicKeyDataLength != 0);
Status = AuthenticateFmpImage( Status = AuthenticateFmpImage (
ImageAuth, ImageAuth,
ImageSize, ImageSize,
PublicKeyData, PublicKeyData,
PublicKeyDataLength PublicKeyDataLength
); );
switch (Status) { switch (Status) {
case RETURN_SUCCESS: case RETURN_SUCCESS:
*LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS; *LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS;
break; break;
case RETURN_SECURITY_VIOLATION: case RETURN_SECURITY_VIOLATION:
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_AUTH_ERROR; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_AUTH_ERROR;
break; break;
case RETURN_INVALID_PARAMETER: case RETURN_INVALID_PARAMETER:
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
break; break;
case RETURN_UNSUPPORTED: case RETURN_UNSUPPORTED:
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
break; break;
case RETURN_OUT_OF_RESOURCES: case RETURN_OUT_OF_RESOURCES:
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INSUFFICIENT_RESOURCES;
break; break;
default: default:
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL;
break; break;
} }
if (EFI_ERROR(Status)) {
if (EFI_ERROR (Status)) {
return FALSE; return FALSE;
} }
if (AuthenticatedImage != NULL) { if (AuthenticatedImage != NULL) {
*AuthenticatedImage = (UINT8 *)ImageAuth + ImageAuth->AuthInfo.Hdr.dwLength + sizeof(ImageAuth->MonotonicCount); *AuthenticatedImage = (UINT8 *)ImageAuth + ImageAuth->AuthInfo.Hdr.dwLength + sizeof (ImageAuth->MonotonicCount);
} }
if (AuthenticatedImageSize != NULL) { if (AuthenticatedImageSize != NULL) {
*AuthenticatedImageSize = ImageSize - ImageAuth->AuthInfo.Hdr.dwLength - sizeof(ImageAuth->MonotonicCount); *AuthenticatedImageSize = ImageSize - ImageAuth->AuthInfo.Hdr.dwLength - sizeof (ImageAuth->MonotonicCount);
} }
return TRUE; return TRUE;
} }
@ -462,41 +479,45 @@ ExtractAuthenticatedImage (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractSystemFirmwareImageFmpInfo ( ExtractSystemFirmwareImageFmpInfo (
IN VOID *SystemFirmwareImage, IN VOID *SystemFirmwareImage,
IN UINTN SystemFirmwareImageSize, IN UINTN SystemFirmwareImageSize,
OUT EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR **ImageFmpInfo, OUT EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR **ImageFmpInfo,
OUT UINTN *ImageFmpInfoSize OUT UINTN *ImageFmpInfoSize
) )
{ {
BOOLEAN Result; BOOLEAN Result;
UINT32 SectionHeaderSize; UINT32 SectionHeaderSize;
UINT32 FileHeaderSize; UINT32 FileHeaderSize;
*ImageFmpInfo = NULL; *ImageFmpInfo = NULL;
*ImageFmpInfoSize = 0; *ImageFmpInfoSize = 0;
Result = GetFfsByName(SystemFirmwareImage, SystemFirmwareImageSize, &gEdkiiSystemFirmwareImageDescriptorFileGuid, EFI_FV_FILETYPE_ALL, (VOID **)ImageFmpInfo, ImageFmpInfoSize); Result = GetFfsByName (SystemFirmwareImage, SystemFirmwareImageSize, &gEdkiiSystemFirmwareImageDescriptorFileGuid, EFI_FV_FILETYPE_ALL, (VOID **)ImageFmpInfo, ImageFmpInfoSize);
if (!Result) { if (!Result) {
return FALSE; return FALSE;
} }
if (IS_FFS_FILE2 (*ImageFmpInfo)) { if (IS_FFS_FILE2 (*ImageFmpInfo)) {
FileHeaderSize = sizeof(EFI_FFS_FILE_HEADER2); FileHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
} else { } else {
FileHeaderSize = sizeof(EFI_FFS_FILE_HEADER); FileHeaderSize = sizeof (EFI_FFS_FILE_HEADER);
} }
*ImageFmpInfo = (VOID *)((UINT8 *)*ImageFmpInfo + FileHeaderSize);
*ImageFmpInfo = (VOID *)((UINT8 *)*ImageFmpInfo + FileHeaderSize);
*ImageFmpInfoSize = *ImageFmpInfoSize - FileHeaderSize; *ImageFmpInfoSize = *ImageFmpInfoSize - FileHeaderSize;
Result = GetSectionByType(*ImageFmpInfo, (UINT32)*ImageFmpInfoSize, EFI_SECTION_RAW, 0, (VOID **)ImageFmpInfo, ImageFmpInfoSize); Result = GetSectionByType (*ImageFmpInfo, (UINT32)*ImageFmpInfoSize, EFI_SECTION_RAW, 0, (VOID **)ImageFmpInfo, ImageFmpInfoSize);
if (!Result) { if (!Result) {
return FALSE; return FALSE;
} }
if (IS_SECTION2(*ImageFmpInfo)) {
SectionHeaderSize = sizeof(EFI_RAW_SECTION2); if (IS_SECTION2 (*ImageFmpInfo)) {
SectionHeaderSize = sizeof (EFI_RAW_SECTION2);
} else { } else {
SectionHeaderSize = sizeof(EFI_RAW_SECTION); SectionHeaderSize = sizeof (EFI_RAW_SECTION);
} }
*ImageFmpInfo = (VOID *)((UINT8 *)*ImageFmpInfo + SectionHeaderSize);
*ImageFmpInfo = (VOID *)((UINT8 *)*ImageFmpInfo + SectionHeaderSize);
*ImageFmpInfoSize = *ImageFmpInfoSize - SectionHeaderSize; *ImageFmpInfoSize = *ImageFmpInfoSize - SectionHeaderSize;
return TRUE; return TRUE;
@ -516,32 +537,34 @@ ExtractSystemFirmwareImageFmpInfo (
BOOLEAN BOOLEAN
EFIAPI EFIAPI
ExtractSystemFirmwareImage ( ExtractSystemFirmwareImage (
IN VOID *AuthenticatedImage, IN VOID *AuthenticatedImage,
IN UINTN AuthenticatedImageSize, IN UINTN AuthenticatedImageSize,
OUT VOID **SystemFirmwareImage, OUT VOID **SystemFirmwareImage,
OUT UINTN *SystemFirmwareImageSize OUT UINTN *SystemFirmwareImageSize
) )
{ {
BOOLEAN Result; BOOLEAN Result;
UINT32 FileHeaderSize; UINT32 FileHeaderSize;
*SystemFirmwareImage = NULL; *SystemFirmwareImage = NULL;
*SystemFirmwareImageSize = 0; *SystemFirmwareImageSize = 0;
Result = GetFfsByName(AuthenticatedImage, AuthenticatedImageSize, &mEdkiiSystemFirmwareFileGuid, EFI_FV_FILETYPE_RAW, SystemFirmwareImage, SystemFirmwareImageSize); Result = GetFfsByName (AuthenticatedImage, AuthenticatedImageSize, &mEdkiiSystemFirmwareFileGuid, EFI_FV_FILETYPE_RAW, SystemFirmwareImage, SystemFirmwareImageSize);
if (!Result) { if (!Result) {
// no nested FV, just return all data. // no nested FV, just return all data.
*SystemFirmwareImage = AuthenticatedImage; *SystemFirmwareImage = AuthenticatedImage;
*SystemFirmwareImageSize = AuthenticatedImageSize; *SystemFirmwareImageSize = AuthenticatedImageSize;
return TRUE; return TRUE;
} }
if (IS_FFS_FILE2 (*SystemFirmwareImage)) { if (IS_FFS_FILE2 (*SystemFirmwareImage)) {
FileHeaderSize = sizeof(EFI_FFS_FILE_HEADER2); FileHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);
} else { } else {
FileHeaderSize = sizeof(EFI_FFS_FILE_HEADER); FileHeaderSize = sizeof (EFI_FFS_FILE_HEADER);
} }
*SystemFirmwareImage = (UINT8 *)*SystemFirmwareImage + FileHeaderSize;
*SystemFirmwareImage = (UINT8 *)*SystemFirmwareImage + FileHeaderSize;
*SystemFirmwareImageSize = *SystemFirmwareImageSize - FileHeaderSize; *SystemFirmwareImageSize = *SystemFirmwareImageSize - FileHeaderSize;
return Result; return Result;
@ -568,22 +591,22 @@ ExtractSystemFirmwareImage (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
CapsuleAuthenticateSystemFirmware ( CapsuleAuthenticateSystemFirmware (
IN VOID *Image, IN VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
IN BOOLEAN ForceVersionMatch, IN BOOLEAN ForceVersionMatch,
OUT UINT32 *LastAttemptVersion, OUT UINT32 *LastAttemptVersion,
OUT UINT32 *LastAttemptStatus, OUT UINT32 *LastAttemptStatus,
OUT VOID **AuthenticatedImage, OUT VOID **AuthenticatedImage,
OUT UINTN *AuthenticatedImageSize OUT UINTN *AuthenticatedImageSize
) )
{ {
BOOLEAN Result; BOOLEAN Result;
EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *ImageFmpInfo; EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *ImageFmpInfo;
UINTN ImageFmpInfoSize; UINTN ImageFmpInfoSize;
EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *CurrentImageFmpInfo; EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *CurrentImageFmpInfo;
UINTN CurrentImageFmpInfoSize; UINTN CurrentImageFmpInfoSize;
VOID *SystemFirmwareImage; VOID *SystemFirmwareImage;
UINTN SystemFirmwareImageSize; UINTN SystemFirmwareImageSize;
*LastAttemptVersion = 0; *LastAttemptVersion = 0;
@ -592,55 +615,56 @@ CapsuleAuthenticateSystemFirmware (
// Do not touch FMP protocol and its private structure. // Do not touch FMP protocol and its private structure.
// //
if (mImageFmpInfo == NULL) { if (mImageFmpInfo == NULL) {
DEBUG((DEBUG_INFO, "ImageFmpInfo is not set\n")); DEBUG ((DEBUG_INFO, "ImageFmpInfo is not set\n"));
return EFI_SECURITY_VIOLATION; return EFI_SECURITY_VIOLATION;
} }
Result = ExtractAuthenticatedImage((VOID *)Image, ImageSize, LastAttemptStatus, AuthenticatedImage, AuthenticatedImageSize); Result = ExtractAuthenticatedImage ((VOID *)Image, ImageSize, LastAttemptStatus, AuthenticatedImage, AuthenticatedImageSize);
if (!Result) { if (!Result) {
DEBUG((DEBUG_INFO, "ExtractAuthenticatedImage - fail\n")); DEBUG ((DEBUG_INFO, "ExtractAuthenticatedImage - fail\n"));
return EFI_SECURITY_VIOLATION; return EFI_SECURITY_VIOLATION;
} }
DEBUG((DEBUG_INFO, "AuthenticatedImage - 0x%x - 0x%x\n", *AuthenticatedImage, *AuthenticatedImageSize)); DEBUG ((DEBUG_INFO, "AuthenticatedImage - 0x%x - 0x%x\n", *AuthenticatedImage, *AuthenticatedImageSize));
Result = ExtractSystemFirmwareImage(*AuthenticatedImage, *AuthenticatedImageSize, &SystemFirmwareImage, &SystemFirmwareImageSize); Result = ExtractSystemFirmwareImage (*AuthenticatedImage, *AuthenticatedImageSize, &SystemFirmwareImage, &SystemFirmwareImageSize);
if (!Result) { if (!Result) {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
DEBUG((DEBUG_INFO, "ExtractSystemFirmwareImage - fail\n")); DEBUG ((DEBUG_INFO, "ExtractSystemFirmwareImage - fail\n"));
return EFI_SECURITY_VIOLATION; return EFI_SECURITY_VIOLATION;
} }
DEBUG((DEBUG_INFO, "SystemFirmwareImage - 0x%x - 0x%x\n", SystemFirmwareImage, SystemFirmwareImageSize));
Result = ExtractSystemFirmwareImageFmpInfo(SystemFirmwareImage, SystemFirmwareImageSize, &ImageFmpInfo, &ImageFmpInfoSize); DEBUG ((DEBUG_INFO, "SystemFirmwareImage - 0x%x - 0x%x\n", SystemFirmwareImage, SystemFirmwareImageSize));
Result = ExtractSystemFirmwareImageFmpInfo (SystemFirmwareImage, SystemFirmwareImageSize, &ImageFmpInfo, &ImageFmpInfoSize);
if (!Result) { if (!Result) {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
DEBUG((DEBUG_INFO, "ExtractSystemFirmwareImageFmpInfo - fail\n")); DEBUG ((DEBUG_INFO, "ExtractSystemFirmwareImageFmpInfo - fail\n"));
return EFI_SECURITY_VIOLATION; return EFI_SECURITY_VIOLATION;
} }
*LastAttemptVersion = ImageFmpInfo->Version; *LastAttemptVersion = ImageFmpInfo->Version;
DEBUG((DEBUG_INFO, "ImageFmpInfo - 0x%x - 0x%x\n", ImageFmpInfo, ImageFmpInfoSize)); DEBUG ((DEBUG_INFO, "ImageFmpInfo - 0x%x - 0x%x\n", ImageFmpInfo, ImageFmpInfoSize));
DEBUG((DEBUG_INFO, "NewImage Version - 0x%x\n", ImageFmpInfo->Version)); DEBUG ((DEBUG_INFO, "NewImage Version - 0x%x\n", ImageFmpInfo->Version));
DEBUG((DEBUG_INFO, "NewImage LowestSupportedImageVersion - 0x%x\n", ImageFmpInfo->LowestSupportedImageVersion)); DEBUG ((DEBUG_INFO, "NewImage LowestSupportedImageVersion - 0x%x\n", ImageFmpInfo->LowestSupportedImageVersion));
CurrentImageFmpInfo = mImageFmpInfo; CurrentImageFmpInfo = mImageFmpInfo;
CurrentImageFmpInfoSize = mImageFmpInfoSize; CurrentImageFmpInfoSize = mImageFmpInfoSize;
DEBUG((DEBUG_INFO, "ImageFmpInfo - 0x%x - 0x%x\n", CurrentImageFmpInfo, CurrentImageFmpInfoSize)); DEBUG ((DEBUG_INFO, "ImageFmpInfo - 0x%x - 0x%x\n", CurrentImageFmpInfo, CurrentImageFmpInfoSize));
DEBUG((DEBUG_INFO, "Current Version - 0x%x\n", CurrentImageFmpInfo->Version)); DEBUG ((DEBUG_INFO, "Current Version - 0x%x\n", CurrentImageFmpInfo->Version));
DEBUG((DEBUG_INFO, "Current LowestSupportedImageVersion - 0x%x\n", CurrentImageFmpInfo->LowestSupportedImageVersion)); DEBUG ((DEBUG_INFO, "Current LowestSupportedImageVersion - 0x%x\n", CurrentImageFmpInfo->LowestSupportedImageVersion));
if (ForceVersionMatch) { if (ForceVersionMatch) {
if (CurrentImageFmpInfo->Version != ImageFmpInfo->Version) { if (CurrentImageFmpInfo->Version != ImageFmpInfo->Version) {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION;
DEBUG((DEBUG_INFO, "ForceVersionMatch check - fail\n")); DEBUG ((DEBUG_INFO, "ForceVersionMatch check - fail\n"));
return EFI_SECURITY_VIOLATION; return EFI_SECURITY_VIOLATION;
} }
} else { } else {
if (ImageFmpInfo->Version < CurrentImageFmpInfo->LowestSupportedImageVersion) { if (ImageFmpInfo->Version < CurrentImageFmpInfo->LowestSupportedImageVersion) {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INCORRECT_VERSION;
DEBUG((DEBUG_INFO, "LowestSupportedImageVersion check - fail\n")); DEBUG ((DEBUG_INFO, "LowestSupportedImageVersion check - fail\n"));
return EFI_SECURITY_VIOLATION; return EFI_SECURITY_VIOLATION;
} }
} }
@ -661,17 +685,18 @@ CapsuleAuthenticateSystemFirmware (
VOID VOID
EFIAPI EFIAPI
EdkiiSystemCapsuleLibPcdCallBack ( EdkiiSystemCapsuleLibPcdCallBack (
IN CONST GUID *CallBackGuid OPTIONAL, IN CONST GUID *CallBackGuid OPTIONAL,
IN UINTN CallBackToken, IN UINTN CallBackToken,
IN OUT VOID *TokenData, IN OUT VOID *TokenData,
IN UINTN TokenDataSize IN UINTN TokenDataSize
) )
{ {
if (CompareGuid (CallBackGuid, &gEfiSignedCapsulePkgTokenSpaceGuid) && if (CompareGuid (CallBackGuid, &gEfiSignedCapsulePkgTokenSpaceGuid) &&
CallBackToken == PcdToken (PcdEdkiiSystemFirmwareImageDescriptor)) { (CallBackToken == PcdToken (PcdEdkiiSystemFirmwareImageDescriptor)))
{
mImageFmpInfoSize = TokenDataSize; mImageFmpInfoSize = TokenDataSize;
mImageFmpInfo = AllocateCopyPool (mImageFmpInfoSize, TokenData); mImageFmpInfo = AllocateCopyPool (mImageFmpInfoSize, TokenData);
ASSERT(mImageFmpInfo != NULL); ASSERT (mImageFmpInfo != NULL);
// //
// Cancel Callback after get the real set value // Cancel Callback after get the real set value
// //
@ -683,8 +708,9 @@ EdkiiSystemCapsuleLibPcdCallBack (
} }
if (CompareGuid (CallBackGuid, &gEfiSignedCapsulePkgTokenSpaceGuid) && if (CompareGuid (CallBackGuid, &gEfiSignedCapsulePkgTokenSpaceGuid) &&
CallBackToken == PcdToken (PcdEdkiiSystemFirmwareFileGuid)) { (CallBackToken == PcdToken (PcdEdkiiSystemFirmwareFileGuid)))
CopyGuid(&mEdkiiSystemFirmwareFileGuid, TokenData); {
CopyGuid (&mEdkiiSystemFirmwareFileGuid, TokenData);
// //
// Cancel Callback after get the real set value // Cancel Callback after get the real set value
// //
@ -707,13 +733,14 @@ EdkiiSystemCapsuleLibConstructor (
VOID VOID
) )
{ {
mImageFmpInfoSize = PcdGetSize(PcdEdkiiSystemFirmwareImageDescriptor); mImageFmpInfoSize = PcdGetSize (PcdEdkiiSystemFirmwareImageDescriptor);
mImageFmpInfo = PcdGetPtr(PcdEdkiiSystemFirmwareImageDescriptor); mImageFmpInfo = PcdGetPtr (PcdEdkiiSystemFirmwareImageDescriptor);
// //
// Verify Firmware Image Descriptor first // Verify Firmware Image Descriptor first
// //
if (mImageFmpInfoSize < sizeof (EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR) || if ((mImageFmpInfoSize < sizeof (EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR)) ||
mImageFmpInfo->Signature != EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR_SIGNATURE) { (mImageFmpInfo->Signature != EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR_SIGNATURE))
{
// //
// SystemFirmwareImageDescriptor is not set. // SystemFirmwareImageDescriptor is not set.
// Register PCD set callback to hook PCD value set. // Register PCD set callback to hook PCD value set.
@ -727,10 +754,10 @@ EdkiiSystemCapsuleLibConstructor (
); );
} else { } else {
mImageFmpInfo = AllocateCopyPool (mImageFmpInfoSize, mImageFmpInfo); mImageFmpInfo = AllocateCopyPool (mImageFmpInfoSize, mImageFmpInfo);
ASSERT(mImageFmpInfo != NULL); ASSERT (mImageFmpInfo != NULL);
} }
CopyGuid(&mEdkiiSystemFirmwareFileGuid, PcdGetPtr(PcdEdkiiSystemFirmwareFileGuid)); CopyGuid (&mEdkiiSystemFirmwareFileGuid, PcdGetPtr (PcdEdkiiSystemFirmwareFileGuid));
// //
// Verify GUID value first // Verify GUID value first
// //
@ -741,5 +768,6 @@ EdkiiSystemCapsuleLibConstructor (
EdkiiSystemCapsuleLibPcdCallBack EdkiiSystemCapsuleLibPcdCallBack
); );
} }
return EFI_SUCCESS; return EFI_SUCCESS;
} }

601
SignedCapsulePkg/Library/IniParsingLib/IniParsingLib.c
View File

File diff suppressed because it is too large Load Diff

15
SignedCapsulePkg/Library/PlatformFlashAccessLibNull/PlatformFlashAccessLibNull.c
View File

@ -11,7 +11,7 @@
#include <Library/BaseMemoryLib.h> #include <Library/BaseMemoryLib.h>
#include <Library/PlatformFlashAccessLib.h> #include <Library/PlatformFlashAccessLib.h>
UINT64 mInternalFdAddress; UINT64 mInternalFdAddress;
/** /**
Perform flash write operation with progress indicator. The start and end Perform flash write operation with progress indicator. The start and end
@ -59,7 +59,8 @@ PerformFlashWriteWithProgress (
if (FlashAddressType == FlashAddressTypeRelativeAddress) { if (FlashAddressType == FlashAddressTypeRelativeAddress) {
FlashAddress = FlashAddress + mInternalFdAddress; FlashAddress = FlashAddress + mInternalFdAddress;
} }
CopyMem((VOID *)(UINTN)(FlashAddress), Buffer, Length);
CopyMem ((VOID *)(UINTN)(FlashAddress), Buffer, Length);
return EFI_SUCCESS; return EFI_SUCCESS;
} }
@ -80,11 +81,11 @@ PerformFlashWriteWithProgress (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
PerformFlashWrite ( PerformFlashWrite (
IN PLATFORM_FIRMWARE_TYPE FirmwareType, IN PLATFORM_FIRMWARE_TYPE FirmwareType,
IN EFI_PHYSICAL_ADDRESS FlashAddress, IN EFI_PHYSICAL_ADDRESS FlashAddress,
IN FLASH_ADDRESS_TYPE FlashAddressType, IN FLASH_ADDRESS_TYPE FlashAddressType,
IN VOID *Buffer, IN VOID *Buffer,
IN UINTN Length IN UINTN Length
) )
{ {
return PerformFlashWriteWithProgress ( return PerformFlashWriteWithProgress (

79
SignedCapsulePkg/Universal/RecoveryModuleLoadPei/ParseConfigProfile.c
View File

@ -12,7 +12,7 @@
#include <Library/IniParsingLib.h> #include <Library/IniParsingLib.h>
#include <Library/PrintLib.h> #include <Library/PrintLib.h>
#define MAX_LINE_LENGTH 512 #define MAX_LINE_LENGTH 512
/** /**
Parse Config data file to get the updated data array. Parse Config data file to get the updated data array.
@ -29,24 +29,24 @@
**/ **/
EFI_STATUS EFI_STATUS
ParseRecoveryDataFile ( ParseRecoveryDataFile (
IN UINT8 *DataBuffer, IN UINT8 *DataBuffer,
IN UINTN BufferSize, IN UINTN BufferSize,
IN OUT CONFIG_HEADER *ConfigHeader, IN OUT CONFIG_HEADER *ConfigHeader,
IN OUT RECOVERY_CONFIG_DATA **RecoveryArray IN OUT RECOVERY_CONFIG_DATA **RecoveryArray
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
CHAR8 *SectionName; CHAR8 *SectionName;
CHAR8 Entry[MAX_LINE_LENGTH]; CHAR8 Entry[MAX_LINE_LENGTH];
UINTN Num; UINTN Num;
UINTN Index; UINTN Index;
EFI_GUID FileGuid; EFI_GUID FileGuid;
VOID *Context; VOID *Context;
// //
// First process the data buffer and get all sections and entries // First process the data buffer and get all sections and entries
// //
Context = OpenIniFile(DataBuffer, BufferSize); Context = OpenIniFile (DataBuffer, BufferSize);
if (Context == NULL) { if (Context == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
@ -54,26 +54,26 @@ ParseRecoveryDataFile (
// //
// Now get NumOfUpdate // Now get NumOfUpdate
// //
Status = GetDecimalUintnFromDataFile( Status = GetDecimalUintnFromDataFile (
Context, Context,
"Head", "Head",
"NumOfRecovery", "NumOfRecovery",
&Num &Num
); );
if (EFI_ERROR(Status) || (Num == 0)) { if (EFI_ERROR (Status) || (Num == 0)) {
DEBUG((DEBUG_ERROR, "NumOfRecovery not found\n")); DEBUG ((DEBUG_ERROR, "NumOfRecovery not found\n"));
CloseIniFile(Context); CloseIniFile (Context);
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
ConfigHeader->NumOfRecovery = Num; ConfigHeader->NumOfRecovery = Num;
*RecoveryArray = AllocateZeroPool ((sizeof (RECOVERY_CONFIG_DATA) * Num)); *RecoveryArray = AllocateZeroPool ((sizeof (RECOVERY_CONFIG_DATA) * Num));
if (*RecoveryArray == NULL) { if (*RecoveryArray == NULL) {
CloseIniFile(Context); CloseIniFile (Context);
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
for (Index = 0 ; Index < ConfigHeader->NumOfRecovery; Index++) { for (Index = 0; Index < ConfigHeader->NumOfRecovery; Index++) {
// //
// Get the section name of each update // Get the section name of each update
// //
@ -85,15 +85,15 @@ ParseRecoveryDataFile (
Index, Index,
0 0
); );
Status = GetStringFromDataFile( Status = GetStringFromDataFile (
Context, Context,
"Head", "Head",
Entry, Entry,
&SectionName &SectionName
); );
if (EFI_ERROR(Status) || (SectionName == NULL)) { if (EFI_ERROR (Status) || (SectionName == NULL)) {
DEBUG((DEBUG_ERROR, "[%d] %a not found\n", Index, Entry)); DEBUG ((DEBUG_ERROR, "[%d] %a not found\n", Index, Entry));
CloseIniFile(Context); CloseIniFile (Context);
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
@ -105,58 +105,59 @@ ParseRecoveryDataFile (
// //
// FileGuid // FileGuid
// //
Status = GetGuidFromDataFile( Status = GetGuidFromDataFile (
Context, Context,
SectionName, SectionName,
"FileGuid", "FileGuid",
&FileGuid &FileGuid
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] FileGuid not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] FileGuid not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
CopyGuid(&((*RecoveryArray)[Index].FileGuid), &FileGuid); CopyGuid (&((*RecoveryArray)[Index].FileGuid), &FileGuid);
// //
// Length // Length
// //
Status = GetHexUintnFromDataFile( Status = GetHexUintnFromDataFile (
Context, Context,
SectionName, SectionName,
"Length", "Length",
&Num &Num
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] Length not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] Length not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
(*RecoveryArray)[Index].Length = Num; (*RecoveryArray)[Index].Length = Num;
// //
// ImageOffset // ImageOffset
// //
Status = GetHexUintnFromDataFile( Status = GetHexUintnFromDataFile (
Context, Context,
SectionName, SectionName,
"ImageOffset", "ImageOffset",
&Num &Num
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] ImageOffset not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] ImageOffset not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
(*RecoveryArray)[Index].ImageOffset = Num; (*RecoveryArray)[Index].ImageOffset = Num;
} }
// //
// Now all configuration data got. Free those temporary buffers // Now all configuration data got. Free those temporary buffers
// //
CloseIniFile(Context); CloseIniFile (Context);
return EFI_SUCCESS; return EFI_SUCCESS;
} }

339
SignedCapsulePkg/Universal/RecoveryModuleLoadPei/RecoveryModuleLoadPei.c
View File

@ -59,15 +59,15 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
LoadRecoveryCapsule ( LoadRecoveryCapsule (
IN EFI_PEI_SERVICES **PeiServices, IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_RECOVERY_MODULE_PPI *This IN EFI_PEI_RECOVERY_MODULE_PPI *This
); );
EFI_PEI_RECOVERY_MODULE_PPI mRecoveryPpi = { EFI_PEI_RECOVERY_MODULE_PPI mRecoveryPpi = {
LoadRecoveryCapsule LoadRecoveryCapsule
}; };
EFI_PEI_PPI_DESCRIPTOR mRecoveryPpiList = { EFI_PEI_PPI_DESCRIPTOR mRecoveryPpiList = {
(EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST), (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
&gEfiPeiRecoveryModulePpiGuid, &gEfiPeiRecoveryModulePpiGuid,
&mRecoveryPpi &mRecoveryPpi
@ -88,10 +88,10 @@ EFI_PEI_PPI_DESCRIPTOR mRecoveryPpiList = {
**/ **/
EFI_STATUS EFI_STATUS
ParseRecoveryDataFile ( ParseRecoveryDataFile (
IN UINT8 *DataBuffer, IN UINT8 *DataBuffer,
IN UINTN BufferSize, IN UINTN BufferSize,
IN OUT CONFIG_HEADER *ConfigHeader, IN OUT CONFIG_HEADER *ConfigHeader,
IN OUT RECOVERY_CONFIG_DATA **RecoveryArray IN OUT RECOVERY_CONFIG_DATA **RecoveryArray
); );
/** /**
@ -104,18 +104,18 @@ ParseRecoveryDataFile (
**/ **/
BOOLEAN BOOLEAN
IsSystemFmpImage ( IsSystemFmpImage (
IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *FmpImageHeader IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *FmpImageHeader
) )
{ {
GUID *Guid; GUID *Guid;
UINTN Count; UINTN Count;
UINTN Index; UINTN Index;
Guid = PcdGetPtr(PcdSystemFmpCapsuleImageTypeIdGuid); Guid = PcdGetPtr (PcdSystemFmpCapsuleImageTypeIdGuid);
Count = PcdGetSize(PcdSystemFmpCapsuleImageTypeIdGuid) / sizeof(GUID); Count = PcdGetSize (PcdSystemFmpCapsuleImageTypeIdGuid) / sizeof (GUID);
for (Index = 0; Index < Count; Index++, Guid++) { for (Index = 0; Index < Count; Index++, Guid++) {
if (CompareGuid(&FmpImageHeader->UpdateImageTypeId, Guid)) { if (CompareGuid (&FmpImageHeader->UpdateImageTypeId, Guid)) {
return TRUE; return TRUE;
} }
} }
@ -136,7 +136,7 @@ IsFmpCapsuleGuid (
IN EFI_GUID *CapsuleGuid IN EFI_GUID *CapsuleGuid
) )
{ {
if (CompareGuid(&gEfiFmpCapsuleGuid, CapsuleGuid)) { if (CompareGuid (&gEfiFmpCapsuleGuid, CapsuleGuid)) {
return TRUE; return TRUE;
} }
@ -159,16 +159,16 @@ IsFmpCapsuleGuid (
**/ **/
BOOLEAN BOOLEAN
IsSystemFmpCapsuleImage ( IsSystemFmpCapsuleImage (
IN EFI_CAPSULE_HEADER *CapsuleHeader IN EFI_CAPSULE_HEADER *CapsuleHeader
) )
{ {
EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *FmpCapsuleHeader; EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *FmpCapsuleHeader;
EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader; EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;
UINT64 *ItemOffsetList; UINT64 *ItemOffsetList;
UINT32 ItemNum; UINT32 ItemNum;
UINTN Index; UINTN Index;
FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize); FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);
if (FmpCapsuleHeader->EmbeddedDriverCount != 0) { if (FmpCapsuleHeader->EmbeddedDriverCount != 0) {
return FALSE; return FALSE;
@ -183,8 +183,8 @@ IsSystemFmpCapsuleImage (
ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1); ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
for (Index = 0; Index < ItemNum; Index++) { for (Index = 0; Index < ItemNum; Index++) {
ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]); ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);
if (!IsSystemFmpImage(ImageHeader)) { if (!IsSystemFmpImage (ImageHeader)) {
return FALSE; return FALSE;
} }
} }
@ -213,9 +213,11 @@ IsValidCapsuleHeader (
if (CapsuleHeader->CapsuleImageSize != CapsuleSize) { if (CapsuleHeader->CapsuleImageSize != CapsuleSize) {
return FALSE; return FALSE;
} }
if (CapsuleHeader->HeaderSize >= CapsuleHeader->CapsuleImageSize) { if (CapsuleHeader->HeaderSize >= CapsuleHeader->CapsuleImageSize) {
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -240,69 +242,73 @@ IsValidCapsuleHeader (
**/ **/
EFI_STATUS EFI_STATUS
ValidateFmpCapsule ( ValidateFmpCapsule (
IN EFI_CAPSULE_HEADER *CapsuleHeader, IN EFI_CAPSULE_HEADER *CapsuleHeader,
OUT BOOLEAN *IsSystemFmp OPTIONAL, OUT BOOLEAN *IsSystemFmp OPTIONAL,
OUT UINT16 *EmbeddedDriverCount OPTIONAL OUT UINT16 *EmbeddedDriverCount OPTIONAL
) )
{ {
EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *FmpCapsuleHeader; EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *FmpCapsuleHeader;
UINT8 *EndOfCapsule; UINT8 *EndOfCapsule;
EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader; EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;
UINT8 *EndOfPayload; UINT8 *EndOfPayload;
UINT64 *ItemOffsetList; UINT64 *ItemOffsetList;
UINT32 ItemNum; UINT32 ItemNum;
UINTN Index; UINTN Index;
UINTN FmpCapsuleSize; UINTN FmpCapsuleSize;
UINTN FmpCapsuleHeaderSize; UINTN FmpCapsuleHeaderSize;
UINT64 FmpImageSize; UINT64 FmpImageSize;
UINTN FmpImageHeaderSize; UINTN FmpImageHeaderSize;
if (CapsuleHeader->HeaderSize >= CapsuleHeader->CapsuleImageSize) { if (CapsuleHeader->HeaderSize >= CapsuleHeader->CapsuleImageSize) {
DEBUG((DEBUG_ERROR, "HeaderSize(0x%x) >= CapsuleImageSize(0x%x)\n", CapsuleHeader->HeaderSize, CapsuleHeader->CapsuleImageSize)); DEBUG ((DEBUG_ERROR, "HeaderSize(0x%x) >= CapsuleImageSize(0x%x)\n", CapsuleHeader->HeaderSize, CapsuleHeader->CapsuleImageSize));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize); FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);
EndOfCapsule = (UINT8 *) CapsuleHeader + CapsuleHeader->CapsuleImageSize; EndOfCapsule = (UINT8 *)CapsuleHeader + CapsuleHeader->CapsuleImageSize;
FmpCapsuleSize = (UINTN)EndOfCapsule - (UINTN)FmpCapsuleHeader; FmpCapsuleSize = (UINTN)EndOfCapsule - (UINTN)FmpCapsuleHeader;
if (FmpCapsuleSize < sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER)) { if (FmpCapsuleSize < sizeof (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER)) {
DEBUG((DEBUG_ERROR, "FmpCapsuleSize(0x%x) < EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER\n", FmpCapsuleSize)); DEBUG ((DEBUG_ERROR, "FmpCapsuleSize(0x%x) < EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER\n", FmpCapsuleSize));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
// Check EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER // Check EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER
if (FmpCapsuleHeader->Version != EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) { if (FmpCapsuleHeader->Version != EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {
DEBUG((DEBUG_ERROR, "FmpCapsuleHeader->Version(0x%x) != EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION\n", FmpCapsuleHeader->Version)); DEBUG ((DEBUG_ERROR, "FmpCapsuleHeader->Version(0x%x) != EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION\n", FmpCapsuleHeader->Version));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1); ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
// No overflow // No overflow
ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount; ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;
if ((FmpCapsuleSize - sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER))/sizeof(UINT64) < ItemNum) { if ((FmpCapsuleSize - sizeof (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER))/sizeof (UINT64) < ItemNum) {
DEBUG((DEBUG_ERROR, "ItemNum(0x%x) too big\n", ItemNum)); DEBUG ((DEBUG_ERROR, "ItemNum(0x%x) too big\n", ItemNum));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
FmpCapsuleHeaderSize = sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER) + sizeof(UINT64)*ItemNum;
FmpCapsuleHeaderSize = sizeof (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER) + sizeof (UINT64)*ItemNum;
// Check ItemOffsetList // Check ItemOffsetList
for (Index = 0; Index < ItemNum; Index++) { for (Index = 0; Index < ItemNum; Index++) {
if (ItemOffsetList[Index] >= FmpCapsuleSize) { if (ItemOffsetList[Index] >= FmpCapsuleSize) {
DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) >= FmpCapsuleSize(0x%x)\n", Index, ItemOffsetList[Index], FmpCapsuleSize)); DEBUG ((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) >= FmpCapsuleSize(0x%x)\n", Index, ItemOffsetList[Index], FmpCapsuleSize));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
if (ItemOffsetList[Index] < FmpCapsuleHeaderSize) { if (ItemOffsetList[Index] < FmpCapsuleHeaderSize) {
DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) < FmpCapsuleHeaderSize(0x%x)\n", Index, ItemOffsetList[Index], FmpCapsuleHeaderSize)); DEBUG ((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) < FmpCapsuleHeaderSize(0x%x)\n", Index, ItemOffsetList[Index], FmpCapsuleHeaderSize));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
// //
// All the address in ItemOffsetList must be stored in ascending order // All the address in ItemOffsetList must be stored in ascending order
// //
if (Index > 0) { if (Index > 0) {
if (ItemOffsetList[Index] <= ItemOffsetList[Index - 1]) { if (ItemOffsetList[Index] <= ItemOffsetList[Index - 1]) {
DEBUG((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) < ItemOffsetList[%d](0x%x)\n", Index, ItemOffsetList[Index], Index, ItemOffsetList[Index - 1])); DEBUG ((DEBUG_ERROR, "ItemOffsetList[%d](0x%lx) < ItemOffsetList[%d](0x%x)\n", Index, ItemOffsetList[Index], Index, ItemOffsetList[Index - 1]));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
} }
@ -310,37 +316,41 @@ ValidateFmpCapsule (
// Check EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER // Check EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER
for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < ItemNum; Index++) { for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < ItemNum; Index++) {
ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]); ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);
if (Index == ItemNum - 1) { if (Index == ItemNum - 1) {
EndOfPayload = (UINT8 *)((UINTN)EndOfCapsule - (UINTN)FmpCapsuleHeader); EndOfPayload = (UINT8 *)((UINTN)EndOfCapsule - (UINTN)FmpCapsuleHeader);
} else { } else {
EndOfPayload = (UINT8 *)(UINTN)ItemOffsetList[Index+1]; EndOfPayload = (UINT8 *)(UINTN)ItemOffsetList[Index+1];
} }
FmpImageSize = (UINTN)EndOfPayload - ItemOffsetList[Index]; FmpImageSize = (UINTN)EndOfPayload - ItemOffsetList[Index];
if (FmpImageSize < OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance)) { if (FmpImageSize < OFFSET_OF (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance)) {
DEBUG((DEBUG_ERROR, "FmpImageSize(0x%lx) < EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER\n", FmpImageSize)); DEBUG ((DEBUG_ERROR, "FmpImageSize(0x%lx) < EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER\n", FmpImageSize));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
FmpImageHeaderSize = sizeof(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER);
FmpImageHeaderSize = sizeof (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER);
if ((ImageHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) || if ((ImageHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER_INIT_VERSION) ||
(ImageHeader->Version < 1)) { (ImageHeader->Version < 1))
DEBUG((DEBUG_ERROR, "ImageHeader->Version(0x%x) Unknown\n", ImageHeader->Version)); {
DEBUG ((DEBUG_ERROR, "ImageHeader->Version(0x%x) Unknown\n", ImageHeader->Version));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
/// ///
/// Current Init ImageHeader version is 3. UpdateHardwareInstance field was added in version 2 /// Current Init ImageHeader version is 3. UpdateHardwareInstance field was added in version 2
/// and ImageCapsuleSupport field was added in version 3 /// and ImageCapsuleSupport field was added in version 3
/// ///
if (ImageHeader->Version == 1) { if (ImageHeader->Version == 1) {
FmpImageHeaderSize = OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance); FmpImageHeaderSize = OFFSET_OF (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance);
} else if (ImageHeader->Version == 2){ } else if (ImageHeader->Version == 2) {
FmpImageHeaderSize = OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, ImageCapsuleSupport); FmpImageHeaderSize = OFFSET_OF (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, ImageCapsuleSupport);
} }
// No overflow // No overflow
if (FmpImageSize != (UINT64)FmpImageHeaderSize + (UINT64)ImageHeader->UpdateImageSize + (UINT64)ImageHeader->UpdateVendorCodeSize) { if (FmpImageSize != (UINT64)FmpImageHeaderSize + (UINT64)ImageHeader->UpdateImageSize + (UINT64)ImageHeader->UpdateVendorCodeSize) {
DEBUG((DEBUG_ERROR, "FmpImageSize(0x%lx) mismatch, UpdateImageSize(0x%x) UpdateVendorCodeSize(0x%x)\n", FmpImageSize, ImageHeader->UpdateImageSize, ImageHeader->UpdateVendorCodeSize)); DEBUG ((DEBUG_ERROR, "FmpImageSize(0x%lx) mismatch, UpdateImageSize(0x%x) UpdateVendorCodeSize(0x%x)\n", FmpImageSize, ImageHeader->UpdateImageSize, ImageHeader->UpdateVendorCodeSize));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
} }
@ -351,9 +361,10 @@ ValidateFmpCapsule (
// //
EndOfPayload = (UINT8 *)(FmpCapsuleHeader + 1); EndOfPayload = (UINT8 *)(FmpCapsuleHeader + 1);
if (EndOfPayload != EndOfCapsule) { if (EndOfPayload != EndOfCapsule) {
DEBUG((DEBUG_ERROR, "EndOfPayload(0x%x) mismatch, EndOfCapsule(0x%x)\n", EndOfPayload, EndOfCapsule)); DEBUG ((DEBUG_ERROR, "EndOfPayload(0x%x) mismatch, EndOfCapsule(0x%x)\n", EndOfPayload, EndOfCapsule));
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
return EFI_UNSUPPORTED; return EFI_UNSUPPORTED;
} }
@ -361,7 +372,7 @@ ValidateFmpCapsule (
// Check in system FMP capsule // Check in system FMP capsule
// //
if (IsSystemFmp != NULL) { if (IsSystemFmp != NULL) {
*IsSystemFmp = IsSystemFmpCapsuleImage(CapsuleHeader); *IsSystemFmp = IsSystemFmpCapsuleImage (CapsuleHeader);
} }
if (EmbeddedDriverCount != NULL) { if (EmbeddedDriverCount != NULL) {
@ -389,8 +400,8 @@ InitializeRecoveryModule (
EFI_STATUS Status; EFI_STATUS Status;
UINTN BootMode; UINTN BootMode;
BootMode = GetBootModeHob(); BootMode = GetBootModeHob ();
ASSERT(BootMode == BOOT_IN_RECOVERY_MODE); ASSERT (BootMode == BOOT_IN_RECOVERY_MODE);
Status = (**PeiServices).InstallPpi (PeiServices, &mRecoveryPpiList); Status = (**PeiServices).InstallPpi (PeiServices, &mRecoveryPpiList);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
@ -411,8 +422,8 @@ InitializeRecoveryModule (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
CreateHobForRecoveryCapsule ( CreateHobForRecoveryCapsule (
IN VOID *FvImage, IN VOID *FvImage,
IN UINTN FvImageSize IN UINTN FvImageSize
) )
{ {
EFI_FIRMWARE_VOLUME_HEADER *FvHeader; EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
@ -423,14 +434,15 @@ CreateHobForRecoveryCapsule (
// //
// FvImage should be at its required alignment. // FvImage should be at its required alignment.
// //
FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) FvImage; FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)FvImage;
// //
// Validate FV Header, if not as expected, return // Validate FV Header, if not as expected, return
// //
if (ReadUnaligned32 (&FvHeader->Signature) != EFI_FVH_SIGNATURE) { if (ReadUnaligned32 (&FvHeader->Signature) != EFI_FVH_SIGNATURE) {
DEBUG((DEBUG_ERROR, "CreateHobForRecoveryCapsule (Fv Signature Error)\n")); DEBUG ((DEBUG_ERROR, "CreateHobForRecoveryCapsule (Fv Signature Error)\n"));
return EFI_VOLUME_CORRUPTED; return EFI_VOLUME_CORRUPTED;
} }
// //
// If EFI_FVB2_WEAK_ALIGNMENT is set in the volume header then the first byte of the volume // If EFI_FVB2_WEAK_ALIGNMENT is set in the volume header then the first byte of the volume
// can be aligned on any power-of-two boundary. A weakly aligned volume can not be moved from // can be aligned on any power-of-two boundary. A weakly aligned volume can not be moved from
@ -447,26 +459,28 @@ CreateHobForRecoveryCapsule (
if (FvAlignment < 8) { if (FvAlignment < 8) {
FvAlignment = 8; FvAlignment = 8;
} }
// //
// Allocate the aligned buffer for the FvImage. // Allocate the aligned buffer for the FvImage.
// //
if ((UINTN) FvHeader % FvAlignment != 0) { if ((UINTN)FvHeader % FvAlignment != 0) {
DEBUG((DEBUG_INFO, "CreateHobForRecoveryCapsule (FvHeader 0x%lx is not aligned)\n", (UINT64)(UINTN)FvHeader)); DEBUG ((DEBUG_INFO, "CreateHobForRecoveryCapsule (FvHeader 0x%lx is not aligned)\n", (UINT64)(UINTN)FvHeader));
FvLength = ReadUnaligned64 (&FvHeader->FvLength); FvLength = ReadUnaligned64 (&FvHeader->FvLength);
NewFvBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINTN) FvLength), FvAlignment); NewFvBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINTN)FvLength), FvAlignment);
if (NewFvBuffer == NULL) { if (NewFvBuffer == NULL) {
DEBUG((DEBUG_ERROR, "CreateHobForRecoveryCapsule (Not enough resource to allocate 0x%lx bytes)\n", FvLength)); DEBUG ((DEBUG_ERROR, "CreateHobForRecoveryCapsule (Not enough resource to allocate 0x%lx bytes)\n", FvLength));
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
CopyMem (NewFvBuffer, FvHeader, (UINTN) FvLength);
FvHeader = (EFI_FIRMWARE_VOLUME_HEADER*) NewFvBuffer; CopyMem (NewFvBuffer, FvHeader, (UINTN)FvLength);
FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)NewFvBuffer;
} }
} }
BuildFvHob((UINT64)(UINTN)FvHeader, FvHeader->FvLength); BuildFvHob ((UINT64)(UINTN)FvHeader, FvHeader->FvLength);
DEBUG((DEBUG_INFO, "BuildFvHob (FV in recovery) - 0x%lx - 0x%lx\n", (UINT64)(UINTN)FvHeader, FvHeader->FvLength)); DEBUG ((DEBUG_INFO, "BuildFvHob (FV in recovery) - 0x%lx - 0x%lx\n", (UINT64)(UINTN)FvHeader, FvHeader->FvLength));
PeiServicesInstallFvInfoPpi( PeiServicesInstallFvInfoPpi (
&FvHeader->FileSystemGuid, &FvHeader->FileSystemGuid,
(VOID *)FvHeader, (VOID *)FvHeader,
(UINT32)FvHeader->FvLength, (UINT32)FvHeader->FvLength,
@ -489,47 +503,48 @@ CreateHobForRecoveryCapsule (
**/ **/
EFI_STATUS EFI_STATUS
RecoverImage ( RecoverImage (
IN VOID *SystemFirmwareImage, IN VOID *SystemFirmwareImage,
IN UINTN SystemFirmwareImageSize, IN UINTN SystemFirmwareImageSize,
IN VOID *ConfigImage, IN VOID *ConfigImage,
IN UINTN ConfigImageSize IN UINTN ConfigImageSize
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
RECOVERY_CONFIG_DATA *ConfigData; RECOVERY_CONFIG_DATA *ConfigData;
RECOVERY_CONFIG_DATA *RecoveryConfigData; RECOVERY_CONFIG_DATA *RecoveryConfigData;
CONFIG_HEADER ConfigHeader; CONFIG_HEADER ConfigHeader;
UINTN Index; UINTN Index;
if (ConfigImage == NULL) { if (ConfigImage == NULL) {
DEBUG((DEBUG_INFO, "RecoverImage (NoConfig)\n")); DEBUG ((DEBUG_INFO, "RecoverImage (NoConfig)\n"));
Status = CreateHobForRecoveryCapsule( Status = CreateHobForRecoveryCapsule (
SystemFirmwareImage, SystemFirmwareImage,
SystemFirmwareImageSize SystemFirmwareImageSize
); );
return Status; return Status;
} }
ConfigData = NULL; ConfigData = NULL;
ZeroMem (&ConfigHeader, sizeof(ConfigHeader)); ZeroMem (&ConfigHeader, sizeof (ConfigHeader));
Status = ParseRecoveryDataFile ( Status = ParseRecoveryDataFile (
ConfigImage, ConfigImage,
ConfigImageSize, ConfigImageSize,
&ConfigHeader, &ConfigHeader,
&ConfigData &ConfigData
); );
DEBUG((DEBUG_INFO, "ParseRecoveryDataFile - %r\n", Status)); DEBUG ((DEBUG_INFO, "ParseRecoveryDataFile - %r\n", Status));
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
return Status; return Status;
} }
DEBUG((DEBUG_INFO, "ConfigHeader.NumOfRecovery - 0x%x\n", ConfigHeader.NumOfRecovery));
DEBUG((DEBUG_INFO, "PcdEdkiiSystemFirmwareFileGuid - %g\n", PcdGetPtr(PcdEdkiiSystemFirmwareFileGuid)));
Index = 0; DEBUG ((DEBUG_INFO, "ConfigHeader.NumOfRecovery - 0x%x\n", ConfigHeader.NumOfRecovery));
DEBUG ((DEBUG_INFO, "PcdEdkiiSystemFirmwareFileGuid - %g\n", PcdGetPtr (PcdEdkiiSystemFirmwareFileGuid)));
Index = 0;
RecoveryConfigData = ConfigData; RecoveryConfigData = ConfigData;
while (Index < ConfigHeader.NumOfRecovery) { while (Index < ConfigHeader.NumOfRecovery) {
if (CompareGuid(&RecoveryConfigData->FileGuid, PcdGetPtr(PcdEdkiiSystemFirmwareFileGuid))) { if (CompareGuid (&RecoveryConfigData->FileGuid, PcdGetPtr (PcdEdkiiSystemFirmwareFileGuid))) {
DEBUG((DEBUG_INFO, "FileGuid - %g (processing)\n", &RecoveryConfigData->FileGuid)); DEBUG ((DEBUG_INFO, "FileGuid - %g (processing)\n", &RecoveryConfigData->FileGuid));
Status = CreateHobForRecoveryCapsule ( Status = CreateHobForRecoveryCapsule (
(UINT8 *)SystemFirmwareImage + RecoveryConfigData->ImageOffset, (UINT8 *)SystemFirmwareImage + RecoveryConfigData->ImageOffset,
RecoveryConfigData->Length RecoveryConfigData->Length
@ -542,7 +557,7 @@ RecoverImage (
break; break;
} }
} else { } else {
DEBUG((DEBUG_INFO, "FileGuid - %g (ignored)\n", &RecoveryConfigData->FileGuid)); DEBUG ((DEBUG_INFO, "FileGuid - %g (ignored)\n", &RecoveryConfigData->FileGuid));
} }
Index++; Index++;
@ -569,31 +584,31 @@ ProcessRecoveryImage (
IN UINTN Length IN UINTN Length
) )
{ {
UINT32 LastAttemptVersion; UINT32 LastAttemptVersion;
UINT32 LastAttemptStatus; UINT32 LastAttemptStatus;
EFI_STATUS Status; EFI_STATUS Status;
VOID *SystemFirmwareImage; VOID *SystemFirmwareImage;
UINTN SystemFirmwareImageSize; UINTN SystemFirmwareImageSize;
VOID *ConfigImage; VOID *ConfigImage;
UINTN ConfigImageSize; UINTN ConfigImageSize;
VOID *AuthenticatedImage; VOID *AuthenticatedImage;
UINTN AuthenticatedImageSize; UINTN AuthenticatedImageSize;
AuthenticatedImage = NULL; AuthenticatedImage = NULL;
AuthenticatedImageSize = 0; AuthenticatedImageSize = 0;
Status = CapsuleAuthenticateSystemFirmware(Image, Length, TRUE, &LastAttemptVersion, &LastAttemptStatus, &AuthenticatedImage, &AuthenticatedImageSize); Status = CapsuleAuthenticateSystemFirmware (Image, Length, TRUE, &LastAttemptVersion, &LastAttemptStatus, &AuthenticatedImage, &AuthenticatedImageSize);
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
DEBUG((DEBUG_INFO, "CapsuleAuthenticateSystemFirmware - %r\n", Status)); DEBUG ((DEBUG_INFO, "CapsuleAuthenticateSystemFirmware - %r\n", Status));
return Status; return Status;
} }
ExtractSystemFirmwareImage(AuthenticatedImage, AuthenticatedImageSize, &SystemFirmwareImage, &SystemFirmwareImageSize); ExtractSystemFirmwareImage (AuthenticatedImage, AuthenticatedImageSize, &SystemFirmwareImage, &SystemFirmwareImageSize);
ExtractConfigImage(AuthenticatedImage, AuthenticatedImageSize, &ConfigImage, &ConfigImageSize); ExtractConfigImage (AuthenticatedImage, AuthenticatedImageSize, &ConfigImage, &ConfigImageSize);
Status = RecoverImage(SystemFirmwareImage, SystemFirmwareImageSize, ConfigImage, ConfigImageSize); Status = RecoverImage (SystemFirmwareImage, SystemFirmwareImageSize, ConfigImage, ConfigImageSize);
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
DEBUG((DEBUG_INFO, "RecoverImage - %r\n", Status)); DEBUG ((DEBUG_INFO, "RecoverImage - %r\n", Status));
return Status; return Status;
} }
@ -636,7 +651,7 @@ ProcessFmpCapsuleImage (
} }
FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize); FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *)((UINT8 *)CapsuleHeader + CapsuleHeader->HeaderSize);
ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1); ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
for (ItemIndex = 0; ItemIndex < FmpCapsuleHeader->PayloadItemCount; ItemIndex++) { for (ItemIndex = 0; ItemIndex < FmpCapsuleHeader->PayloadItemCount; ItemIndex++) {
ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[ItemIndex]); ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[ItemIndex]);
@ -649,14 +664,14 @@ ProcessFmpCapsuleImage (
// If version is 2 Header should exclude ImageCapsuleSupport field. // If version is 2 Header should exclude ImageCapsuleSupport field.
// //
if (ImageHeader->Version == 1) { if (ImageHeader->Version == 1) {
Image = (UINT8 *)ImageHeader + OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance); Image = (UINT8 *)ImageHeader + OFFSET_OF (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, UpdateHardwareInstance);
} else { } else {
Image = (UINT8 *)ImageHeader + OFFSET_OF(EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, ImageCapsuleSupport); Image = (UINT8 *)ImageHeader + OFFSET_OF (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER, ImageCapsuleSupport);
} }
} }
Status = ProcessRecoveryImage (Image, ImageHeader->UpdateImageSize); Status = ProcessRecoveryImage (Image, ImageHeader->UpdateImageSize);
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
return Status; return Status;
} }
} }
@ -679,42 +694,42 @@ ProcessFmpCapsuleImage (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
ProcessRecoveryCapsule ( ProcessRecoveryCapsule (
IN VOID *CapsuleBuffer, IN VOID *CapsuleBuffer,
IN UINTN CapsuleSize IN UINTN CapsuleSize
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
BOOLEAN IsSystemFmp; BOOLEAN IsSystemFmp;
EFI_CAPSULE_HEADER *CapsuleHeader; EFI_CAPSULE_HEADER *CapsuleHeader;
CapsuleHeader = CapsuleBuffer; CapsuleHeader = CapsuleBuffer;
if (!IsValidCapsuleHeader (CapsuleHeader, CapsuleSize)) { if (!IsValidCapsuleHeader (CapsuleHeader, CapsuleSize)) {
DEBUG((DEBUG_ERROR, "CapsuleImageSize incorrect\n")); DEBUG ((DEBUG_ERROR, "CapsuleImageSize incorrect\n"));
return EFI_SECURITY_VIOLATION; return EFI_SECURITY_VIOLATION;
} }
// //
// Check FMP capsule layout // Check FMP capsule layout
// //
if (IsFmpCapsuleGuid(&CapsuleHeader->CapsuleGuid)) { if (IsFmpCapsuleGuid (&CapsuleHeader->CapsuleGuid)) {
DEBUG((DEBUG_INFO, "CreateHobForRecoveryCapsule\n")); DEBUG ((DEBUG_INFO, "CreateHobForRecoveryCapsule\n"));
DEBUG((DEBUG_INFO, "ProcessCapsuleImage for FmpCapsule ...\n")); DEBUG ((DEBUG_INFO, "ProcessCapsuleImage for FmpCapsule ...\n"));
DEBUG((DEBUG_INFO, "ValidateFmpCapsule ...\n")); DEBUG ((DEBUG_INFO, "ValidateFmpCapsule ...\n"));
Status = ValidateFmpCapsule(CapsuleHeader, &IsSystemFmp, NULL); Status = ValidateFmpCapsule (CapsuleHeader, &IsSystemFmp, NULL);
DEBUG((DEBUG_INFO, "ValidateFmpCapsule - %r\n", Status)); DEBUG ((DEBUG_INFO, "ValidateFmpCapsule - %r\n", Status));
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
return Status; return Status;
} }
// //
// Process EFI FMP Capsule // Process EFI FMP Capsule
// //
DEBUG((DEBUG_INFO, "ProcessFmpCapsuleImage ...\n")); DEBUG ((DEBUG_INFO, "ProcessFmpCapsuleImage ...\n"));
Status = ProcessFmpCapsuleImage(CapsuleHeader, IsSystemFmp); Status = ProcessFmpCapsuleImage (CapsuleHeader, IsSystemFmp);
DEBUG((DEBUG_INFO, "ProcessFmpCapsuleImage - %r\n", Status)); DEBUG ((DEBUG_INFO, "ProcessFmpCapsuleImage - %r\n", Status));
DEBUG((DEBUG_INFO, "CreateHobForRecoveryCapsule Done\n")); DEBUG ((DEBUG_INFO, "CreateHobForRecoveryCapsule Done\n"));
return Status; return Status;
} }
@ -736,8 +751,8 @@ ProcessRecoveryCapsule (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
LoadRecoveryCapsule ( LoadRecoveryCapsule (
IN EFI_PEI_SERVICES **PeiServices, IN EFI_PEI_SERVICES **PeiServices,
IN EFI_PEI_RECOVERY_MODULE_PPI *This IN EFI_PEI_RECOVERY_MODULE_PPI *This
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
@ -749,7 +764,7 @@ LoadRecoveryCapsule (
EFI_GUID CapsuleType; EFI_GUID CapsuleType;
VOID *CapsuleBuffer; VOID *CapsuleBuffer;
DEBUG((DEBUG_INFO | DEBUG_LOAD, "Recovery Entry\n")); DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Recovery Entry\n"));
for (Instance = 0; ; Instance++) { for (Instance = 0; ; Instance++) {
Status = PeiServicesLocatePpi ( Status = PeiServicesLocatePpi (
@ -762,35 +777,38 @@ LoadRecoveryCapsule (
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
break; break;
} }
NumberRecoveryCapsules = 0; NumberRecoveryCapsules = 0;
Status = DeviceRecoveryPpi->GetNumberRecoveryCapsules ( Status = DeviceRecoveryPpi->GetNumberRecoveryCapsules (
(EFI_PEI_SERVICES **)PeiServices, (EFI_PEI_SERVICES **)PeiServices,
DeviceRecoveryPpi, DeviceRecoveryPpi,
&NumberRecoveryCapsules &NumberRecoveryCapsules
); );
DEBUG ((DEBUG_ERROR, "LoadRecoveryCapsule - GetNumberRecoveryCapsules (%d) - %r\n", NumberRecoveryCapsules, Status)); DEBUG ((DEBUG_ERROR, "LoadRecoveryCapsule - GetNumberRecoveryCapsules (%d) - %r\n", NumberRecoveryCapsules, Status));
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
continue; continue;
} }
for (CapsuleInstance = 1; CapsuleInstance <= NumberRecoveryCapsules; CapsuleInstance++) { for (CapsuleInstance = 1; CapsuleInstance <= NumberRecoveryCapsules; CapsuleInstance++) {
CapsuleSize = 0; CapsuleSize = 0;
Status = DeviceRecoveryPpi->GetRecoveryCapsuleInfo ( Status = DeviceRecoveryPpi->GetRecoveryCapsuleInfo (
(EFI_PEI_SERVICES **)PeiServices, (EFI_PEI_SERVICES **)PeiServices,
DeviceRecoveryPpi, DeviceRecoveryPpi,
CapsuleInstance, CapsuleInstance,
&CapsuleSize, &CapsuleSize,
&CapsuleType &CapsuleType
); );
DEBUG ((DEBUG_ERROR, "LoadRecoveryCapsule - GetRecoveryCapsuleInfo (%d - %x) - %r\n", CapsuleInstance, CapsuleSize, Status)); DEBUG ((DEBUG_ERROR, "LoadRecoveryCapsule - GetRecoveryCapsuleInfo (%d - %x) - %r\n", CapsuleInstance, CapsuleSize, Status));
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
break; break;
} }
CapsuleBuffer = AllocatePages (EFI_SIZE_TO_PAGES(CapsuleSize)); CapsuleBuffer = AllocatePages (EFI_SIZE_TO_PAGES (CapsuleSize));
if (CapsuleBuffer == NULL) { if (CapsuleBuffer == NULL) {
DEBUG ((DEBUG_ERROR, "LoadRecoveryCapsule - AllocatePool fail\n")); DEBUG ((DEBUG_ERROR, "LoadRecoveryCapsule - AllocatePool fail\n"));
continue; continue;
} }
Status = DeviceRecoveryPpi->LoadRecoveryCapsule ( Status = DeviceRecoveryPpi->LoadRecoveryCapsule (
(EFI_PEI_SERVICES **)PeiServices, (EFI_PEI_SERVICES **)PeiServices,
DeviceRecoveryPpi, DeviceRecoveryPpi,
@ -799,9 +817,10 @@ LoadRecoveryCapsule (
); );
DEBUG ((DEBUG_ERROR, "LoadRecoveryCapsule - LoadRecoveryCapsule (%d) - %r\n", CapsuleInstance, Status)); DEBUG ((DEBUG_ERROR, "LoadRecoveryCapsule - LoadRecoveryCapsule (%d) - %r\n", CapsuleInstance, Status));
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
FreePages (CapsuleBuffer, EFI_SIZE_TO_PAGES(CapsuleSize)); FreePages (CapsuleBuffer, EFI_SIZE_TO_PAGES (CapsuleSize));
break; break;
} }
// //
// good, load capsule buffer // good, load capsule buffer
// //

11
SignedCapsulePkg/Universal/RecoveryModuleLoadPei/RecoveryModuleLoadPei.h
View File

@ -24,15 +24,14 @@
// //
typedef struct { typedef struct {
UINTN NumOfRecovery; UINTN NumOfRecovery;
} CONFIG_HEADER; } CONFIG_HEADER;
typedef struct { typedef struct {
UINTN Index; UINTN Index;
EFI_GUID FileGuid; EFI_GUID FileGuid;
UINTN Length; UINTN Length;
UINTN ImageOffset; UINTN ImageOffset;
} RECOVERY_CONFIG_DATA; } RECOVERY_CONFIG_DATA;
#endif #endif

118
SignedCapsulePkg/Universal/SystemFirmwareUpdate/ParseConfigProfile.c
View File

@ -12,7 +12,7 @@
#include <Library/IniParsingLib.h> #include <Library/IniParsingLib.h>
#include <Library/PrintLib.h> #include <Library/PrintLib.h>
#define MAX_LINE_LENGTH 512 #define MAX_LINE_LENGTH 512
/** /**
Parse Config data file to get the updated data array. Parse Config data file to get the updated data array.
@ -29,25 +29,25 @@
**/ **/
EFI_STATUS EFI_STATUS
ParseUpdateDataFile ( ParseUpdateDataFile (
IN UINT8 *DataBuffer, IN UINT8 *DataBuffer,
IN UINTN BufferSize, IN UINTN BufferSize,
IN OUT CONFIG_HEADER *ConfigHeader, IN OUT CONFIG_HEADER *ConfigHeader,
IN OUT UPDATE_CONFIG_DATA **UpdateArray IN OUT UPDATE_CONFIG_DATA **UpdateArray
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
CHAR8 *SectionName; CHAR8 *SectionName;
CHAR8 Entry[MAX_LINE_LENGTH]; CHAR8 Entry[MAX_LINE_LENGTH];
UINTN Num; UINTN Num;
UINT64 Num64; UINT64 Num64;
UINTN Index; UINTN Index;
EFI_GUID FileGuid; EFI_GUID FileGuid;
VOID *Context; VOID *Context;
// //
// First process the data buffer and get all sections and entries // First process the data buffer and get all sections and entries
// //
Context = OpenIniFile(DataBuffer, BufferSize); Context = OpenIniFile (DataBuffer, BufferSize);
if (Context == NULL) { if (Context == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
@ -55,26 +55,26 @@ ParseUpdateDataFile (
// //
// Now get NumOfUpdate // Now get NumOfUpdate
// //
Status = GetDecimalUintnFromDataFile( Status = GetDecimalUintnFromDataFile (
Context, Context,
"Head", "Head",
"NumOfUpdate", "NumOfUpdate",
&Num &Num
); );
if (EFI_ERROR(Status) || (Num == 0)) { if (EFI_ERROR (Status) || (Num == 0)) {
DEBUG((DEBUG_ERROR, "NumOfUpdate not found\n")); DEBUG ((DEBUG_ERROR, "NumOfUpdate not found\n"));
CloseIniFile(Context); CloseIniFile (Context);
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
ConfigHeader->NumOfUpdates = Num; ConfigHeader->NumOfUpdates = Num;
*UpdateArray = AllocateZeroPool ((sizeof (UPDATE_CONFIG_DATA) * Num)); *UpdateArray = AllocateZeroPool ((sizeof (UPDATE_CONFIG_DATA) * Num));
if (*UpdateArray == NULL) { if (*UpdateArray == NULL) {
CloseIniFile(Context); CloseIniFile (Context);
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
for (Index = 0 ; Index < ConfigHeader->NumOfUpdates ; Index++) { for (Index = 0; Index < ConfigHeader->NumOfUpdates; Index++) {
// //
// Get the section name of each update // Get the section name of each update
// //
@ -86,15 +86,15 @@ ParseUpdateDataFile (
Index, Index,
0 0
); );
Status = GetStringFromDataFile( Status = GetStringFromDataFile (
Context, Context,
"Head", "Head",
Entry, Entry,
&SectionName &SectionName
); );
if (EFI_ERROR(Status) || (SectionName == NULL)) { if (EFI_ERROR (Status) || (SectionName == NULL)) {
DEBUG((DEBUG_ERROR, "[%d] %a not found\n", Index, Entry)); DEBUG ((DEBUG_ERROR, "[%d] %a not found\n", Index, Entry));
CloseIniFile(Context); CloseIniFile (Context);
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
@ -107,106 +107,110 @@ ParseUpdateDataFile (
// //
// FirmwareType // FirmwareType
// //
Status = GetDecimalUintnFromDataFile( Status = GetDecimalUintnFromDataFile (
Context, Context,
SectionName, SectionName,
"FirmwareType", "FirmwareType",
&Num &Num
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] FirmwareType not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] FirmwareType not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
(*UpdateArray)[Index].FirmwareType = (PLATFORM_FIRMWARE_TYPE) Num;
(*UpdateArray)[Index].FirmwareType = (PLATFORM_FIRMWARE_TYPE)Num;
// //
// AddressType // AddressType
// //
Status = GetDecimalUintnFromDataFile( Status = GetDecimalUintnFromDataFile (
Context, Context,
SectionName, SectionName,
"AddressType", "AddressType",
&Num &Num
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] AddressType not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] AddressType not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
(*UpdateArray)[Index].AddressType = (FLASH_ADDRESS_TYPE) Num;
(*UpdateArray)[Index].AddressType = (FLASH_ADDRESS_TYPE)Num;
// //
// BaseAddress // BaseAddress
// //
Status = GetHexUint64FromDataFile( Status = GetHexUint64FromDataFile (
Context, Context,
SectionName, SectionName,
"BaseAddress", "BaseAddress",
&Num64 &Num64
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] BaseAddress not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] BaseAddress not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
(*UpdateArray)[Index].BaseAddress = (EFI_PHYSICAL_ADDRESS) Num64;
(*UpdateArray)[Index].BaseAddress = (EFI_PHYSICAL_ADDRESS)Num64;
// //
// FileGuid // FileGuid
// //
Status = GetGuidFromDataFile( Status = GetGuidFromDataFile (
Context, Context,
SectionName, SectionName,
"FileGuid", "FileGuid",
&FileGuid &FileGuid
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] FileGuid not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] FileGuid not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
CopyGuid(&((*UpdateArray)[Index].FileGuid), &FileGuid); CopyGuid (&((*UpdateArray)[Index].FileGuid), &FileGuid);
// //
// Length // Length
// //
Status = GetHexUintnFromDataFile( Status = GetHexUintnFromDataFile (
Context, Context,
SectionName, SectionName,
"Length", "Length",
&Num &Num
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] Length not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] Length not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
(*UpdateArray)[Index].Length = (UINTN) Num;
(*UpdateArray)[Index].Length = (UINTN)Num;
// //
// ImageOffset // ImageOffset
// //
Status = GetHexUintnFromDataFile( Status = GetHexUintnFromDataFile (
Context, Context,
SectionName, SectionName,
"ImageOffset", "ImageOffset",
&Num &Num
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
CloseIniFile(Context); CloseIniFile (Context);
DEBUG((DEBUG_ERROR, "[%d] ImageOffset not found\n", Index)); DEBUG ((DEBUG_ERROR, "[%d] ImageOffset not found\n", Index));
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
(*UpdateArray)[Index].ImageOffset = (UINTN) Num;
(*UpdateArray)[Index].ImageOffset = (UINTN)Num;
} }
// //
// Now all configuration data got. Free those temporary buffers // Now all configuration data got. Free those temporary buffers
// //
CloseIniFile(Context); CloseIniFile (Context);
return EFI_SUCCESS; return EFI_SUCCESS;
} }

131
SignedCapsulePkg/Universal/SystemFirmwareUpdate/SystemFirmwareCommonDxe.c
View File

@ -8,10 +8,10 @@
#include "SystemFirmwareDxe.h" #include "SystemFirmwareDxe.h"
EFI_GUID gSystemFmpLastAttemptVariableGuid = SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_GUID; EFI_GUID gSystemFmpLastAttemptVariableGuid = SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_GUID;
EFI_GUID gSystemFmpProtocolGuid = SYSTEM_FMP_PROTOCOL_GUID; EFI_GUID gSystemFmpProtocolGuid = SYSTEM_FMP_PROTOCOL_GUID;
EFI_FIRMWARE_MANAGEMENT_PROTOCOL mFirmwareManagementProtocol = { EFI_FIRMWARE_MANAGEMENT_PROTOCOL mFirmwareManagementProtocol = {
FmpGetImageInfo, FmpGetImageInfo,
FmpGetImage, FmpGetImage,
FmpSetImage, FmpSetImage,
@ -61,48 +61,49 @@ EFI_FIRMWARE_MANAGEMENT_PROTOCOL mFirmwareManagementProtocol = {
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpGetImageInfo ( FmpGetImageInfo (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
IN OUT UINTN *ImageInfoSize, IN OUT UINTN *ImageInfoSize,
IN OUT EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo, IN OUT EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo,
OUT UINT32 *DescriptorVersion, OUT UINT32 *DescriptorVersion,
OUT UINT8 *DescriptorCount, OUT UINT8 *DescriptorCount,
OUT UINTN *DescriptorSize, OUT UINTN *DescriptorSize,
OUT UINT32 *PackageVersion, OUT UINT32 *PackageVersion,
OUT CHAR16 **PackageVersionName OUT CHAR16 **PackageVersionName
) )
{ {
SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate; SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate;
EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *ImageDescriptor; EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *ImageDescriptor;
SystemFmpPrivate = SYSTEM_FMP_PRIVATE_DATA_FROM_FMP(This); SystemFmpPrivate = SYSTEM_FMP_PRIVATE_DATA_FROM_FMP (This);
if(ImageInfoSize == NULL) { if (ImageInfoSize == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
if (*ImageInfoSize < sizeof(EFI_FIRMWARE_IMAGE_DESCRIPTOR) * SystemFmpPrivate->DescriptorCount) { if (*ImageInfoSize < sizeof (EFI_FIRMWARE_IMAGE_DESCRIPTOR) * SystemFmpPrivate->DescriptorCount) {
*ImageInfoSize = sizeof(EFI_FIRMWARE_IMAGE_DESCRIPTOR) * SystemFmpPrivate->DescriptorCount; *ImageInfoSize = sizeof (EFI_FIRMWARE_IMAGE_DESCRIPTOR) * SystemFmpPrivate->DescriptorCount;
return EFI_BUFFER_TOO_SMALL; return EFI_BUFFER_TOO_SMALL;
} }
if (ImageInfo == NULL || if ((ImageInfo == NULL) ||
DescriptorVersion == NULL || (DescriptorVersion == NULL) ||
DescriptorCount == NULL || (DescriptorCount == NULL) ||
DescriptorSize == NULL || (DescriptorSize == NULL) ||
PackageVersion == NULL || (PackageVersion == NULL) ||
PackageVersionName == NULL) { (PackageVersionName == NULL))
{
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
*ImageInfoSize = sizeof(EFI_FIRMWARE_IMAGE_DESCRIPTOR) * SystemFmpPrivate->DescriptorCount; *ImageInfoSize = sizeof (EFI_FIRMWARE_IMAGE_DESCRIPTOR) * SystemFmpPrivate->DescriptorCount;
*DescriptorSize = sizeof(EFI_FIRMWARE_IMAGE_DESCRIPTOR); *DescriptorSize = sizeof (EFI_FIRMWARE_IMAGE_DESCRIPTOR);
*DescriptorCount = SystemFmpPrivate->DescriptorCount; *DescriptorCount = SystemFmpPrivate->DescriptorCount;
*DescriptorVersion = EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION; *DescriptorVersion = EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION;
// //
// supports 1 ImageInfo descriptor // supports 1 ImageInfo descriptor
// //
ImageDescriptor = SystemFmpPrivate->ImageDescriptor; ImageDescriptor = SystemFmpPrivate->ImageDescriptor;
ImageInfo->ImageIndex = ImageDescriptor->ImageIndex; ImageInfo->ImageIndex = ImageDescriptor->ImageIndex;
CopyGuid (&ImageInfo->ImageTypeId, &ImageDescriptor->ImageTypeId); CopyGuid (&ImageInfo->ImageTypeId, &ImageDescriptor->ImageTypeId);
ImageInfo->ImageId = ImageDescriptor->ImageId; ImageInfo->ImageId = ImageDescriptor->ImageId;
@ -111,20 +112,22 @@ FmpGetImageInfo (
} else { } else {
ImageInfo->ImageIdName = NULL; ImageInfo->ImageIdName = NULL;
} }
ImageInfo->Version = ImageDescriptor->Version; ImageInfo->Version = ImageDescriptor->Version;
if (ImageDescriptor->VersionNameStringOffset != 0) { if (ImageDescriptor->VersionNameStringOffset != 0) {
ImageInfo->VersionName = (CHAR16 *)((UINTN)ImageDescriptor + ImageDescriptor->VersionNameStringOffset); ImageInfo->VersionName = (CHAR16 *)((UINTN)ImageDescriptor + ImageDescriptor->VersionNameStringOffset);
} else { } else {
ImageInfo->VersionName = NULL; ImageInfo->VersionName = NULL;
} }
ImageInfo->Size = (UINTN)ImageDescriptor->Size;
ImageInfo->AttributesSupported = ImageDescriptor->AttributesSupported; ImageInfo->Size = (UINTN)ImageDescriptor->Size;
ImageInfo->AttributesSetting = ImageDescriptor->AttributesSetting; ImageInfo->AttributesSupported = ImageDescriptor->AttributesSupported;
ImageInfo->Compatibilities = ImageDescriptor->Compatibilities; ImageInfo->AttributesSetting = ImageDescriptor->AttributesSetting;
ImageInfo->Compatibilities = ImageDescriptor->Compatibilities;
ImageInfo->LowestSupportedImageVersion = ImageDescriptor->LowestSupportedImageVersion; ImageInfo->LowestSupportedImageVersion = ImageDescriptor->LowestSupportedImageVersion;
ImageInfo->LastAttemptVersion = SystemFmpPrivate->LastAttempt.LastAttemptVersion; ImageInfo->LastAttemptVersion = SystemFmpPrivate->LastAttempt.LastAttemptVersion;
ImageInfo->LastAttemptStatus = SystemFmpPrivate->LastAttempt.LastAttemptStatus; ImageInfo->LastAttemptStatus = SystemFmpPrivate->LastAttempt.LastAttemptStatus;
ImageInfo->HardwareInstance = ImageDescriptor->HardwareInstance; ImageInfo->HardwareInstance = ImageDescriptor->HardwareInstance;
// //
// package version // package version
@ -132,7 +135,7 @@ FmpGetImageInfo (
*PackageVersion = ImageDescriptor->PackageVersion; *PackageVersion = ImageDescriptor->PackageVersion;
if (ImageDescriptor->PackageVersionNameStringOffset != 0) { if (ImageDescriptor->PackageVersionNameStringOffset != 0) {
*PackageVersionName = (VOID *)((UINTN)ImageDescriptor + ImageDescriptor->PackageVersionNameStringOffset); *PackageVersionName = (VOID *)((UINTN)ImageDescriptor + ImageDescriptor->PackageVersionNameStringOffset);
*PackageVersionName = AllocateCopyPool(StrSize(*PackageVersionName), *PackageVersionName); *PackageVersionName = AllocateCopyPool (StrSize (*PackageVersionName), *PackageVersionName);
} else { } else {
*PackageVersionName = NULL; *PackageVersionName = NULL;
} }
@ -243,12 +246,12 @@ FmpCheckImage (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpGetPackageInfo ( FmpGetPackageInfo (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
OUT UINT32 *PackageVersion, OUT UINT32 *PackageVersion,
OUT CHAR16 **PackageVersionName, OUT CHAR16 **PackageVersionName,
OUT UINT32 *PackageVersionNameMaxLen, OUT UINT32 *PackageVersionNameMaxLen,
OUT UINT64 *AttributesSupported, OUT UINT64 *AttributesSupported,
OUT UINT64 *AttributesSetting OUT UINT64 *AttributesSetting
) )
{ {
return EFI_UNSUPPORTED; return EFI_UNSUPPORTED;
@ -288,12 +291,12 @@ FmpGetPackageInfo (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpSetPackageInfo ( FmpSetPackageInfo (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
IN CONST VOID *Image, IN CONST VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
IN CONST VOID *VendorCode, IN CONST VOID *VendorCode,
IN UINT32 PackageVersion, IN UINT32 PackageVersion,
IN CONST CHAR16 *PackageVersionName IN CONST CHAR16 *PackageVersionName
) )
{ {
return EFI_UNSUPPORTED; return EFI_UNSUPPORTED;
@ -311,30 +314,28 @@ InitializePrivateData (
IN SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate IN SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate
) )
{ {
EFI_STATUS VarStatus; EFI_STATUS VarStatus;
UINTN VarSize; UINTN VarSize;
SystemFmpPrivate->Signature = SYSTEM_FMP_PRIVATE_DATA_SIGNATURE; SystemFmpPrivate->Signature = SYSTEM_FMP_PRIVATE_DATA_SIGNATURE;
SystemFmpPrivate->Handle = NULL; SystemFmpPrivate->Handle = NULL;
SystemFmpPrivate->DescriptorCount = 1; SystemFmpPrivate->DescriptorCount = 1;
CopyMem(&SystemFmpPrivate->Fmp, &mFirmwareManagementProtocol, sizeof(EFI_FIRMWARE_MANAGEMENT_PROTOCOL)); CopyMem (&SystemFmpPrivate->Fmp, &mFirmwareManagementProtocol, sizeof (EFI_FIRMWARE_MANAGEMENT_PROTOCOL));
SystemFmpPrivate->ImageDescriptor = PcdGetPtr(PcdEdkiiSystemFirmwareImageDescriptor); SystemFmpPrivate->ImageDescriptor = PcdGetPtr (PcdEdkiiSystemFirmwareImageDescriptor);
SystemFmpPrivate->LastAttempt.LastAttemptVersion = 0x0; SystemFmpPrivate->LastAttempt.LastAttemptVersion = 0x0;
SystemFmpPrivate->LastAttempt.LastAttemptStatus = 0x0; SystemFmpPrivate->LastAttempt.LastAttemptStatus = 0x0;
VarSize = sizeof(SystemFmpPrivate->LastAttempt); VarSize = sizeof (SystemFmpPrivate->LastAttempt);
VarStatus = gRT->GetVariable( VarStatus = gRT->GetVariable (
SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME, SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME,
&gSystemFmpLastAttemptVariableGuid, &gSystemFmpLastAttemptVariableGuid,
NULL, NULL,
&VarSize, &VarSize,
&SystemFmpPrivate->LastAttempt &SystemFmpPrivate->LastAttempt
); );
DEBUG((DEBUG_INFO, "GetLastAttempt - %r\n", VarStatus)); DEBUG ((DEBUG_INFO, "GetLastAttempt - %r\n", VarStatus));
DEBUG((DEBUG_INFO, "GetLastAttempt Version - 0x%x, State - 0x%x\n", SystemFmpPrivate->LastAttempt.LastAttemptVersion, SystemFmpPrivate->LastAttempt.LastAttemptStatus)); DEBUG ((DEBUG_INFO, "GetLastAttempt Version - 0x%x, State - 0x%x\n", SystemFmpPrivate->LastAttempt.LastAttemptVersion, SystemFmpPrivate->LastAttempt.LastAttemptStatus));
return EFI_SUCCESS; return EFI_SUCCESS;
} }

123
SignedCapsulePkg/Universal/SystemFirmwareUpdate/SystemFirmwareDxe.h
View File

@ -35,32 +35,32 @@
#include <Library/EdkiiSystemCapsuleLib.h> #include <Library/EdkiiSystemCapsuleLib.h>
typedef struct { typedef struct {
UINT32 LastAttemptVersion; UINT32 LastAttemptVersion;
UINT32 LastAttemptStatus; UINT32 LastAttemptStatus;
} SYSTEM_FMP_LAST_ATTEMPT_VARIABLE; } SYSTEM_FMP_LAST_ATTEMPT_VARIABLE;
#define SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME L"SystemLastAttempVar" #define SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME L"SystemLastAttempVar"
#define SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_GUID {0x2f564d6f, 0xcc2c, 0x4838, { 0xb9, 0xa8, 0xbe, 0x59, 0x48, 0xb0, 0x3d, 0x59 }} #define SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_GUID {0x2f564d6f, 0xcc2c, 0x4838, { 0xb9, 0xa8, 0xbe, 0x59, 0x48, 0xb0, 0x3d, 0x59 }}
#define SYSTEM_FMP_PRIVATE_DATA_SIGNATURE SIGNATURE_32('S', 'Y', 'S', 'F') #define SYSTEM_FMP_PRIVATE_DATA_SIGNATURE SIGNATURE_32('S', 'Y', 'S', 'F')
#define SYSTEM_FMP_PROTOCOL_GUID {0x6d16624a, 0x26a6, 0x4cb4, { 0x84, 0xfa, 0x6, 0x78, 0x5a, 0x7e, 0x82, 0x6a }} #define SYSTEM_FMP_PROTOCOL_GUID {0x6d16624a, 0x26a6, 0x4cb4, { 0x84, 0xfa, 0x6, 0x78, 0x5a, 0x7e, 0x82, 0x6a }}
// //
// SYSTEM FMP private data structure. // SYSTEM FMP private data structure.
// //
struct _SYSTEM_FMP_PRIVATE_DATA { struct _SYSTEM_FMP_PRIVATE_DATA {
UINT32 Signature; UINT32 Signature;
EFI_FIRMWARE_MANAGEMENT_PROTOCOL Fmp; EFI_FIRMWARE_MANAGEMENT_PROTOCOL Fmp;
EFI_HANDLE Handle; EFI_HANDLE Handle;
UINT8 DescriptorCount; UINT8 DescriptorCount;
EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *ImageDescriptor; EDKII_SYSTEM_FIRMWARE_IMAGE_DESCRIPTOR *ImageDescriptor;
SYSTEM_FMP_LAST_ATTEMPT_VARIABLE LastAttempt; SYSTEM_FMP_LAST_ATTEMPT_VARIABLE LastAttempt;
}; };
typedef struct _SYSTEM_FMP_PRIVATE_DATA SYSTEM_FMP_PRIVATE_DATA; typedef struct _SYSTEM_FMP_PRIVATE_DATA SYSTEM_FMP_PRIVATE_DATA;
/** /**
Returns a pointer to the SYSTEM_FMP_PRIVATE_DATA structure from the input a as Fmp. Returns a pointer to the SYSTEM_FMP_PRIVATE_DATA structure from the input a as Fmp.
@ -80,51 +80,49 @@ typedef struct _SYSTEM_FMP_PRIVATE_DATA SYSTEM_FMP_PRIVATE_DATA;
SYSTEM_FMP_PRIVATE_DATA_SIGNATURE \ SYSTEM_FMP_PRIVATE_DATA_SIGNATURE \
) )
// //
// Update data // Update data
// //
typedef struct { typedef struct {
UINTN NumOfUpdates; UINTN NumOfUpdates;
} CONFIG_HEADER; } CONFIG_HEADER;
typedef struct { typedef struct {
UINTN Index; UINTN Index;
PLATFORM_FIRMWARE_TYPE FirmwareType; PLATFORM_FIRMWARE_TYPE FirmwareType;
FLASH_ADDRESS_TYPE AddressType; FLASH_ADDRESS_TYPE AddressType;
EFI_GUID FileGuid; EFI_GUID FileGuid;
EFI_PHYSICAL_ADDRESS BaseAddress; EFI_PHYSICAL_ADDRESS BaseAddress;
UINTN Length; UINTN Length;
UINTN ImageOffset; UINTN ImageOffset;
} UPDATE_CONFIG_DATA; } UPDATE_CONFIG_DATA;
// //
// System Firmware Update SMM Communication // System Firmware Update SMM Communication
// //
#define SYSTEM_FIRMWARE_UPDATE_COMMUNICATION_FUNCTION_SET_IMAGE 1 #define SYSTEM_FIRMWARE_UPDATE_COMMUNICATION_FUNCTION_SET_IMAGE 1
typedef struct { typedef struct {
UINTN Function; UINTN Function;
EFI_STATUS ReturnStatus; EFI_STATUS ReturnStatus;
//UINT8 Data[]; // UINT8 Data[];
} SYSTEM_FIRMWARE_UPDATE_COMMUNICATION_HEAD; } SYSTEM_FIRMWARE_UPDATE_COMMUNICATION_HEAD;
#define ABORT_REASON_MAX_SIZE 0x40 // UnicodeStringSize including final L'\0' #define ABORT_REASON_MAX_SIZE 0x40 // UnicodeStringSize including final L'\0'
#define CAPSULE_IMAGE_ADDITIONAL_MAX_SIZE (0x20020 + 0xA0000) // Additional size for Capsule Header, FV block alignment + DispatchImage. #define CAPSULE_IMAGE_ADDITIONAL_MAX_SIZE (0x20020 + 0xA0000) // Additional size for Capsule Header, FV block alignment + DispatchImage.
typedef struct { typedef struct {
UINT8 ImageIndex; UINT8 ImageIndex;
UINTN ImageSize; UINTN ImageSize;
UINTN AbortReasonSize; UINTN AbortReasonSize;
UINT32 LastAttemptVersion; UINT32 LastAttemptVersion;
UINT32 LastAttemptStatus; UINT32 LastAttemptStatus;
//UINT8 Data[AbortReasonMaxSize + ImageSize]; // UINT8 Data[AbortReasonMaxSize + ImageSize];
} SYSTEM_FIRMWARE_UPDATE_COMMUNICATION_SET_IMAGE; } SYSTEM_FIRMWARE_UPDATE_COMMUNICATION_SET_IMAGE;
/** /**
Returns information about the current firmware image(s) of the device. Returns information about the current firmware image(s) of the device.
@ -166,14 +164,14 @@ typedef struct {
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpGetImageInfo ( FmpGetImageInfo (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
IN OUT UINTN *ImageInfoSize, IN OUT UINTN *ImageInfoSize,
IN OUT EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo, IN OUT EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo,
OUT UINT32 *DescriptorVersion, OUT UINT32 *DescriptorVersion,
OUT UINT8 *DescriptorCount, OUT UINT8 *DescriptorCount,
OUT UINTN *DescriptorSize, OUT UINTN *DescriptorSize,
OUT UINT32 *PackageVersion, OUT UINT32 *PackageVersion,
OUT CHAR16 **PackageVersionName OUT CHAR16 **PackageVersionName
); );
/** /**
@ -257,13 +255,13 @@ FmpGetImage (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpSetImage ( FmpSetImage (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
IN UINT8 ImageIndex, IN UINT8 ImageIndex,
IN CONST VOID *Image, IN CONST VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
IN CONST VOID *VendorCode, IN CONST VOID *VendorCode,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress, IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress,
OUT CHAR16 **AbortReason OUT CHAR16 **AbortReason
); );
/** /**
@ -331,12 +329,12 @@ FmpCheckImage (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpGetPackageInfo ( FmpGetPackageInfo (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
OUT UINT32 *PackageVersion, OUT UINT32 *PackageVersion,
OUT CHAR16 **PackageVersionName, OUT CHAR16 **PackageVersionName,
OUT UINT32 *PackageVersionNameMaxLen, OUT UINT32 *PackageVersionNameMaxLen,
OUT UINT64 *AttributesSupported, OUT UINT64 *AttributesSupported,
OUT UINT64 *AttributesSetting OUT UINT64 *AttributesSetting
); );
/** /**
@ -373,12 +371,12 @@ FmpGetPackageInfo (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpSetPackageInfo ( FmpSetPackageInfo (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
IN CONST VOID *Image, IN CONST VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
IN CONST VOID *VendorCode, IN CONST VOID *VendorCode,
IN UINT32 PackageVersion, IN UINT32 PackageVersion,
IN CONST CHAR16 *PackageVersionName IN CONST CHAR16 *PackageVersionName
); );
/** /**
@ -393,9 +391,8 @@ InitializePrivateData (
IN SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate IN SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate
); );
extern EFI_GUID gSystemFmpLastAttemptVariableGuid; extern EFI_GUID gSystemFmpLastAttemptVariableGuid;
extern EFI_GUID mCurrentImageTypeId; extern EFI_GUID mCurrentImageTypeId;
extern EFI_GUID gSystemFmpProtocolGuid; extern EFI_GUID gSystemFmpProtocolGuid;
#endif #endif

134
SignedCapsulePkg/Universal/SystemFirmwareUpdate/SystemFirmwareReportDxe.c
View File

@ -18,7 +18,7 @@
// //
// SystemFmp driver private data // SystemFmp driver private data
// //
SYSTEM_FMP_PRIVATE_DATA *mSystemFmpPrivate = NULL; SYSTEM_FMP_PRIVATE_DATA *mSystemFmpPrivate = NULL;
/** /**
Dispatch system FMP images. Dispatch system FMP images.
@ -37,57 +37,57 @@ SYSTEM_FMP_PRIVATE_DATA *mSystemFmpPrivate = NULL;
**/ **/
EFI_STATUS EFI_STATUS
DispatchSystemFmpImages ( DispatchSystemFmpImages (
IN VOID *Image, IN VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
OUT UINT32 *LastAttemptVersion, OUT UINT32 *LastAttemptVersion,
OUT UINT32 *LastAttemptStatus OUT UINT32 *LastAttemptStatus
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
VOID *AuthenticatedImage; VOID *AuthenticatedImage;
UINTN AuthenticatedImageSize; UINTN AuthenticatedImageSize;
VOID *DispatchFvImage; VOID *DispatchFvImage;
UINTN DispatchFvImageSize; UINTN DispatchFvImageSize;
EFI_HANDLE FvProtocolHandle; EFI_HANDLE FvProtocolHandle;
EFI_FIRMWARE_VOLUME_HEADER *FvImage; EFI_FIRMWARE_VOLUME_HEADER *FvImage;
BOOLEAN Result; BOOLEAN Result;
AuthenticatedImage = NULL; AuthenticatedImage = NULL;
AuthenticatedImageSize = 0; AuthenticatedImageSize = 0;
DEBUG((DEBUG_INFO, "DispatchSystemFmpImages\n")); DEBUG ((DEBUG_INFO, "DispatchSystemFmpImages\n"));
// //
// Verify // Verify
// //
Status = CapsuleAuthenticateSystemFirmware(Image, ImageSize, FALSE, LastAttemptVersion, LastAttemptStatus, &AuthenticatedImage, &AuthenticatedImageSize); Status = CapsuleAuthenticateSystemFirmware (Image, ImageSize, FALSE, LastAttemptVersion, LastAttemptStatus, &AuthenticatedImage, &AuthenticatedImageSize);
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
DEBUG((DEBUG_INFO, "SystemFirmwareAuthenticateImage - %r\n", Status)); DEBUG ((DEBUG_INFO, "SystemFirmwareAuthenticateImage - %r\n", Status));
return Status; return Status;
} }
// //
// Get FV // Get FV
// //
Result = ExtractDriverFvImage(AuthenticatedImage, AuthenticatedImageSize, &DispatchFvImage, &DispatchFvImageSize); Result = ExtractDriverFvImage (AuthenticatedImage, AuthenticatedImageSize, &DispatchFvImage, &DispatchFvImageSize);
if (Result) { if (Result) {
DEBUG((DEBUG_INFO, "ExtractDriverFvImage\n")); DEBUG ((DEBUG_INFO, "ExtractDriverFvImage\n"));
// //
// Dispatch // Dispatch
// //
if (((EFI_FIRMWARE_VOLUME_HEADER *)DispatchFvImage)->FvLength == DispatchFvImageSize) { if (((EFI_FIRMWARE_VOLUME_HEADER *)DispatchFvImage)->FvLength == DispatchFvImageSize) {
FvImage = AllocatePages(EFI_SIZE_TO_PAGES(DispatchFvImageSize)); FvImage = AllocatePages (EFI_SIZE_TO_PAGES (DispatchFvImageSize));
if (FvImage != NULL) { if (FvImage != NULL) {
CopyMem(FvImage, DispatchFvImage, DispatchFvImageSize); CopyMem (FvImage, DispatchFvImage, DispatchFvImageSize);
Status = gDS->ProcessFirmwareVolume( Status = gDS->ProcessFirmwareVolume (
(VOID *)FvImage, (VOID *)FvImage,
(UINTN)FvImage->FvLength, (UINTN)FvImage->FvLength,
&FvProtocolHandle &FvProtocolHandle
); );
DEBUG((DEBUG_INFO, "ProcessFirmwareVolume - %r\n", Status)); DEBUG ((DEBUG_INFO, "ProcessFirmwareVolume - %r\n", Status));
if (!EFI_ERROR(Status)) { if (!EFI_ERROR (Status)) {
gDS->Dispatch(); gDS->Dispatch ();
DEBUG((DEBUG_INFO, "Dispatch Done\n")); DEBUG ((DEBUG_INFO, "Dispatch Done\n"));
} }
} }
} }
@ -145,78 +145,78 @@ DispatchSystemFmpImages (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpSetImage ( FmpSetImage (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
IN UINT8 ImageIndex, IN UINT8 ImageIndex,
IN CONST VOID *Image, IN CONST VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
IN CONST VOID *VendorCode, IN CONST VOID *VendorCode,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress, IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress,
OUT CHAR16 **AbortReason OUT CHAR16 **AbortReason
) )
{ {
SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate; SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate;
EFI_FIRMWARE_MANAGEMENT_PROTOCOL *SystemFmp; EFI_FIRMWARE_MANAGEMENT_PROTOCOL *SystemFmp;
EFI_STATUS Status; EFI_STATUS Status;
EFI_STATUS VarStatus; EFI_STATUS VarStatus;
if (Image == NULL || ImageSize == 0 || AbortReason == NULL) { if ((Image == NULL) || (ImageSize == 0) || (AbortReason == NULL)) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
SystemFmpPrivate = SYSTEM_FMP_PRIVATE_DATA_FROM_FMP(This); SystemFmpPrivate = SYSTEM_FMP_PRIVATE_DATA_FROM_FMP (This);
*AbortReason = NULL; *AbortReason = NULL;
if (ImageIndex == 0 || ImageIndex > SystemFmpPrivate->DescriptorCount) { if ((ImageIndex == 0) || (ImageIndex > SystemFmpPrivate->DescriptorCount)) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
// //
// Process FV // Process FV
// //
Status = DispatchSystemFmpImages((VOID *)Image, ImageSize, &SystemFmpPrivate->LastAttempt.LastAttemptVersion, &SystemFmpPrivate->LastAttempt.LastAttemptStatus); Status = DispatchSystemFmpImages ((VOID *)Image, ImageSize, &SystemFmpPrivate->LastAttempt.LastAttemptVersion, &SystemFmpPrivate->LastAttempt.LastAttemptStatus);
DEBUG((DEBUG_INFO, "(Agent)SetImage - LastAttempt Version - 0x%x, State - 0x%x\n", SystemFmpPrivate->LastAttempt.LastAttemptVersion, SystemFmpPrivate->LastAttempt.LastAttemptStatus)); DEBUG ((DEBUG_INFO, "(Agent)SetImage - LastAttempt Version - 0x%x, State - 0x%x\n", SystemFmpPrivate->LastAttempt.LastAttemptVersion, SystemFmpPrivate->LastAttempt.LastAttemptStatus));
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
VarStatus = gRT->SetVariable( VarStatus = gRT->SetVariable (
SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME, SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME,
&gSystemFmpLastAttemptVariableGuid, &gSystemFmpLastAttemptVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS, EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof(SystemFmpPrivate->LastAttempt), sizeof (SystemFmpPrivate->LastAttempt),
&SystemFmpPrivate->LastAttempt &SystemFmpPrivate->LastAttempt
); );
DEBUG((DEBUG_INFO, "(Agent)SetLastAttempt - %r\n", VarStatus)); DEBUG ((DEBUG_INFO, "(Agent)SetLastAttempt - %r\n", VarStatus));
return Status; return Status;
} }
// //
// Pass Thru to System FMP Protocol on same handle as FMP Protocol // Pass Thru to System FMP Protocol on same handle as FMP Protocol
// //
Status = gBS->HandleProtocol( Status = gBS->HandleProtocol (
SystemFmpPrivate->Handle, SystemFmpPrivate->Handle,
&gSystemFmpProtocolGuid, &gSystemFmpProtocolGuid,
(VOID **)&SystemFmp (VOID **)&SystemFmp
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
Status = gBS->LocateProtocol ( Status = gBS->LocateProtocol (
&gSystemFmpProtocolGuid, &gSystemFmpProtocolGuid,
NULL, NULL,
(VOID **)&SystemFmp (VOID **)&SystemFmp
); );
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
DEBUG((DEBUG_INFO, "(Agent)SetImage - SystemFmpProtocol - %r\n", Status)); DEBUG ((DEBUG_INFO, "(Agent)SetImage - SystemFmpProtocol - %r\n", Status));
SystemFmpPrivate->LastAttempt.LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT; SystemFmpPrivate->LastAttempt.LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_INVALID_FORMAT;
VarStatus = gRT->SetVariable( VarStatus = gRT->SetVariable (
SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME, SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME,
&gSystemFmpLastAttemptVariableGuid, &gSystemFmpLastAttemptVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS, EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof(SystemFmpPrivate->LastAttempt), sizeof (SystemFmpPrivate->LastAttempt),
&SystemFmpPrivate->LastAttempt &SystemFmpPrivate->LastAttempt
); );
DEBUG((DEBUG_INFO, "(Agent)SetLastAttempt - %r\n", VarStatus)); DEBUG ((DEBUG_INFO, "(Agent)SetLastAttempt - %r\n", VarStatus));
return Status; return Status;
} }
} }
return SystemFmp->SetImage(SystemFmp, ImageIndex, Image, ImageSize, VendorCode, Progress, AbortReason); return SystemFmp->SetImage (SystemFmp, ImageIndex, Image, ImageSize, VendorCode, Progress, AbortReason);
} }
/** /**
@ -230,23 +230,23 @@ FmpSetImage (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SystemFirmwareReportMainDxe ( SystemFirmwareReportMainDxe (
IN EFI_HANDLE ImageHandle, IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable IN EFI_SYSTEM_TABLE *SystemTable
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
// //
// Initialize SystemFmpPrivateData // Initialize SystemFmpPrivateData
// //
mSystemFmpPrivate = AllocateZeroPool (sizeof(SYSTEM_FMP_PRIVATE_DATA)); mSystemFmpPrivate = AllocateZeroPool (sizeof (SYSTEM_FMP_PRIVATE_DATA));
if (mSystemFmpPrivate == NULL) { if (mSystemFmpPrivate == NULL) {
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
Status = InitializePrivateData(mSystemFmpPrivate); Status = InitializePrivateData (mSystemFmpPrivate);
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
FreePool(mSystemFmpPrivate); FreePool (mSystemFmpPrivate);
mSystemFmpPrivate = NULL; mSystemFmpPrivate = NULL;
return Status; return Status;
} }
@ -261,7 +261,7 @@ SystemFirmwareReportMainDxe (
&mSystemFmpPrivate->Fmp &mSystemFmpPrivate->Fmp
); );
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
FreePool(mSystemFmpPrivate); FreePool (mSystemFmpPrivate);
mSystemFmpPrivate = NULL; mSystemFmpPrivate = NULL;
return Status; return Status;
} }

384
SignedCapsulePkg/Universal/SystemFirmwareUpdate/SystemFirmwareUpdateDxe.c
View File

@ -18,9 +18,9 @@
// //
// SystemFmp driver private data // SystemFmp driver private data
// //
SYSTEM_FMP_PRIVATE_DATA *mSystemFmpPrivate = NULL; SYSTEM_FMP_PRIVATE_DATA *mSystemFmpPrivate = NULL;
EFI_GUID mCurrentImageTypeId; EFI_GUID mCurrentImageTypeId;
BOOLEAN mNvRamUpdated = FALSE; BOOLEAN mNvRamUpdated = FALSE;
@ -39,10 +39,10 @@ BOOLEAN mNvRamUpdated = FALSE;
**/ **/
EFI_STATUS EFI_STATUS
ParseUpdateDataFile ( ParseUpdateDataFile (
IN UINT8 *DataBuffer, IN UINT8 *DataBuffer,
IN UINTN BufferSize, IN UINTN BufferSize,
IN OUT CONFIG_HEADER *ConfigHeader, IN OUT CONFIG_HEADER *ConfigHeader,
IN OUT UPDATE_CONFIG_DATA **UpdateArray IN OUT UPDATE_CONFIG_DATA **UpdateArray
); );
/** /**
@ -72,15 +72,16 @@ PerformUpdate (
IN UINTN EndPercentage IN UINTN EndPercentage
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
DEBUG((DEBUG_INFO, "PlatformUpdate:")); DEBUG ((DEBUG_INFO, "PlatformUpdate:"));
DEBUG((DEBUG_INFO, " BaseAddress - 0x%lx,", ConfigData->BaseAddress)); DEBUG ((DEBUG_INFO, " BaseAddress - 0x%lx,", ConfigData->BaseAddress));
DEBUG((DEBUG_INFO, " ImageOffset - 0x%x,", ConfigData->ImageOffset)); DEBUG ((DEBUG_INFO, " ImageOffset - 0x%x,", ConfigData->ImageOffset));
DEBUG((DEBUG_INFO, " Legnth - 0x%x\n", ConfigData->Length)); DEBUG ((DEBUG_INFO, " Legnth - 0x%x\n", ConfigData->Length));
if (Progress != NULL) { if (Progress != NULL) {
Progress (StartPercentage); Progress (StartPercentage);
} }
Status = PerformFlashWriteWithProgress ( Status = PerformFlashWriteWithProgress (
ConfigData->FirmwareType, ConfigData->FirmwareType,
ConfigData->BaseAddress, ConfigData->BaseAddress,
@ -94,7 +95,8 @@ PerformUpdate (
if (Progress != NULL) { if (Progress != NULL) {
Progress (EndPercentage); Progress (EndPercentage);
} }
if (!EFI_ERROR(Status)) {
if (!EFI_ERROR (Status)) {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS; *LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS;
if (ConfigData->FirmwareType == PlatformFirmwareTypeNvRam) { if (ConfigData->FirmwareType == PlatformFirmwareTypeNvRam) {
mNvRamUpdated = TRUE; mNvRamUpdated = TRUE;
@ -102,6 +104,7 @@ PerformUpdate (
} else { } else {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL;
} }
return Status; return Status;
} }
@ -130,26 +133,27 @@ UpdateImage (
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
UPDATE_CONFIG_DATA *ConfigData; UPDATE_CONFIG_DATA *ConfigData;
UPDATE_CONFIG_DATA *UpdateConfigData; UPDATE_CONFIG_DATA *UpdateConfigData;
CONFIG_HEADER ConfigHeader; CONFIG_HEADER ConfigHeader;
UINTN Index; UINTN Index;
UINTN TotalSize; UINTN TotalSize;
UINTN BytesWritten; UINTN BytesWritten;
UINTN StartPercentage; UINTN StartPercentage;
UINTN EndPercentage; UINTN EndPercentage;
if (ConfigImage == NULL) { if (ConfigImage == NULL) {
DEBUG((DEBUG_INFO, "PlatformUpdate (NoConfig):")); DEBUG ((DEBUG_INFO, "PlatformUpdate (NoConfig):"));
DEBUG((DEBUG_INFO, " BaseAddress - 0x%x,", 0)); DEBUG ((DEBUG_INFO, " BaseAddress - 0x%x,", 0));
DEBUG((DEBUG_INFO, " Length - 0x%x\n", SystemFirmwareImageSize)); DEBUG ((DEBUG_INFO, " Length - 0x%x\n", SystemFirmwareImageSize));
// ASSUME the whole System Firmware include NVRAM region. // ASSUME the whole System Firmware include NVRAM region.
StartPercentage = 0; StartPercentage = 0;
EndPercentage = 100; EndPercentage = 100;
if (Progress != NULL) { if (Progress != NULL) {
Progress (StartPercentage); Progress (StartPercentage);
} }
Status = PerformFlashWriteWithProgress ( Status = PerformFlashWriteWithProgress (
PlatformFirmwareTypeNvRam, PlatformFirmwareTypeNvRam,
0, 0,
@ -163,57 +167,60 @@ UpdateImage (
if (Progress != NULL) { if (Progress != NULL) {
Progress (EndPercentage); Progress (EndPercentage);
} }
if (!EFI_ERROR(Status)) {
if (!EFI_ERROR (Status)) {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS; *LastAttemptStatus = LAST_ATTEMPT_STATUS_SUCCESS;
mNvRamUpdated = TRUE; mNvRamUpdated = TRUE;
} else { } else {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL;
} }
return Status; return Status;
} }
DEBUG((DEBUG_INFO, "PlatformUpdate (With Config):\n")); DEBUG ((DEBUG_INFO, "PlatformUpdate (With Config):\n"));
ConfigData = NULL; ConfigData = NULL;
ZeroMem (&ConfigHeader, sizeof(ConfigHeader)); ZeroMem (&ConfigHeader, sizeof (ConfigHeader));
Status = ParseUpdateDataFile ( Status = ParseUpdateDataFile (
ConfigImage, ConfigImage,
ConfigImageSize, ConfigImageSize,
&ConfigHeader, &ConfigHeader,
&ConfigData &ConfigData
); );
DEBUG((DEBUG_INFO, "ParseUpdateDataFile - %r\n", Status)); DEBUG ((DEBUG_INFO, "ParseUpdateDataFile - %r\n", Status));
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
*LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL; *LastAttemptStatus = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL;
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
DEBUG((DEBUG_INFO, "ConfigHeader.NumOfUpdates - 0x%x\n", ConfigHeader.NumOfUpdates));
DEBUG((DEBUG_INFO, "PcdEdkiiSystemFirmwareFileGuid - %g\n", PcdGetPtr(PcdEdkiiSystemFirmwareFileGuid))); DEBUG ((DEBUG_INFO, "ConfigHeader.NumOfUpdates - 0x%x\n", ConfigHeader.NumOfUpdates));
DEBUG ((DEBUG_INFO, "PcdEdkiiSystemFirmwareFileGuid - %g\n", PcdGetPtr (PcdEdkiiSystemFirmwareFileGuid)));
TotalSize = 0; TotalSize = 0;
for (Index = 0; Index < ConfigHeader.NumOfUpdates; Index++) { for (Index = 0; Index < ConfigHeader.NumOfUpdates; Index++) {
if (CompareGuid(&ConfigData[Index].FileGuid, PcdGetPtr(PcdEdkiiSystemFirmwareFileGuid))) { if (CompareGuid (&ConfigData[Index].FileGuid, PcdGetPtr (PcdEdkiiSystemFirmwareFileGuid))) {
TotalSize = TotalSize + ConfigData[Index].Length; TotalSize = TotalSize + ConfigData[Index].Length;
} }
} }
BytesWritten = 0; BytesWritten = 0;
Index = 0; Index = 0;
UpdateConfigData = ConfigData; UpdateConfigData = ConfigData;
while (Index < ConfigHeader.NumOfUpdates) { while (Index < ConfigHeader.NumOfUpdates) {
if (CompareGuid(&UpdateConfigData->FileGuid, PcdGetPtr(PcdEdkiiSystemFirmwareFileGuid))) { if (CompareGuid (&UpdateConfigData->FileGuid, PcdGetPtr (PcdEdkiiSystemFirmwareFileGuid))) {
DEBUG((DEBUG_INFO, "FileGuid - %g (processing)\n", &UpdateConfigData->FileGuid)); DEBUG ((DEBUG_INFO, "FileGuid - %g (processing)\n", &UpdateConfigData->FileGuid));
StartPercentage = (BytesWritten * 100) / TotalSize; StartPercentage = (BytesWritten * 100) / TotalSize;
EndPercentage = ((BytesWritten + UpdateConfigData->Length) * 100) / TotalSize; EndPercentage = ((BytesWritten + UpdateConfigData->Length) * 100) / TotalSize;
Status = PerformUpdate ( Status = PerformUpdate (
SystemFirmwareImage, SystemFirmwareImage,
SystemFirmwareImageSize, SystemFirmwareImageSize,
UpdateConfigData, UpdateConfigData,
LastAttemptVersion, LastAttemptVersion,
LastAttemptStatus, LastAttemptStatus,
Progress, Progress,
StartPercentage, StartPercentage,
EndPercentage EndPercentage
); );
// //
// Shall updates be serialized so that if an update is not successfully completed, // Shall updates be serialized so that if an update is not successfully completed,
// the remaining updates won't be performed. // the remaining updates won't be performed.
@ -222,7 +229,7 @@ UpdateImage (
break; break;
} }
} else { } else {
DEBUG((DEBUG_INFO, "FileGuid - %g (ignored)\n", &UpdateConfigData->FileGuid)); DEBUG ((DEBUG_INFO, "FileGuid - %g (ignored)\n", &UpdateConfigData->FileGuid));
} }
BytesWritten += UpdateConfigData->Length; BytesWritten += UpdateConfigData->Length;
@ -258,38 +265,38 @@ SystemFirmwareAuthenticatedUpdate (
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
VOID *SystemFirmwareImage; VOID *SystemFirmwareImage;
UINTN SystemFirmwareImageSize; UINTN SystemFirmwareImageSize;
VOID *ConfigImage; VOID *ConfigImage;
UINTN ConfigImageSize; UINTN ConfigImageSize;
VOID *AuthenticatedImage; VOID *AuthenticatedImage;
UINTN AuthenticatedImageSize; UINTN AuthenticatedImageSize;
AuthenticatedImage = NULL; AuthenticatedImage = NULL;
AuthenticatedImageSize = 0; AuthenticatedImageSize = 0;
DEBUG((DEBUG_INFO, "SystemFirmwareAuthenticatedUpdate...\n")); DEBUG ((DEBUG_INFO, "SystemFirmwareAuthenticatedUpdate...\n"));
Status = CapsuleAuthenticateSystemFirmware(Image, ImageSize, FALSE, LastAttemptVersion, LastAttemptStatus, &AuthenticatedImage, &AuthenticatedImageSize); Status = CapsuleAuthenticateSystemFirmware (Image, ImageSize, FALSE, LastAttemptVersion, LastAttemptStatus, &AuthenticatedImage, &AuthenticatedImageSize);
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
DEBUG((DEBUG_INFO, "SystemFirmwareAuthenticateImage - %r\n", Status)); DEBUG ((DEBUG_INFO, "SystemFirmwareAuthenticateImage - %r\n", Status));
return Status; return Status;
} }
DEBUG((DEBUG_INFO, "ExtractSystemFirmwareImage ...\n")); DEBUG ((DEBUG_INFO, "ExtractSystemFirmwareImage ...\n"));
ExtractSystemFirmwareImage(AuthenticatedImage, AuthenticatedImageSize, &SystemFirmwareImage, &SystemFirmwareImageSize); ExtractSystemFirmwareImage (AuthenticatedImage, AuthenticatedImageSize, &SystemFirmwareImage, &SystemFirmwareImageSize);
DEBUG((DEBUG_INFO, "ExtractConfigImage ...\n")); DEBUG ((DEBUG_INFO, "ExtractConfigImage ...\n"));
ExtractConfigImage(AuthenticatedImage, AuthenticatedImageSize, &ConfigImage, &ConfigImageSize); ExtractConfigImage (AuthenticatedImage, AuthenticatedImageSize, &ConfigImage, &ConfigImageSize);
DEBUG((DEBUG_INFO, "UpdateImage ...\n")); DEBUG ((DEBUG_INFO, "UpdateImage ...\n"));
Status = UpdateImage(SystemFirmwareImage, SystemFirmwareImageSize, ConfigImage, ConfigImageSize, LastAttemptVersion, LastAttemptStatus, Progress); Status = UpdateImage (SystemFirmwareImage, SystemFirmwareImageSize, ConfigImage, ConfigImageSize, LastAttemptVersion, LastAttemptStatus, Progress);
if (EFI_ERROR(Status)) { if (EFI_ERROR (Status)) {
DEBUG((DEBUG_INFO, "UpdateImage - %r\n", Status)); DEBUG ((DEBUG_INFO, "UpdateImage - %r\n", Status));
return Status; return Status;
} }
DEBUG((DEBUG_INFO, "SystemFirmwareAuthenticatedUpdate Done\n")); DEBUG ((DEBUG_INFO, "SystemFirmwareAuthenticatedUpdate Done\n"));
return EFI_SUCCESS; return EFI_SUCCESS;
} }
@ -314,14 +321,14 @@ SystemFirmwareAuthenticatedUpdate (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
GetVariableHook ( GetVariableHook (
IN CHAR16 *VariableName, IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid, IN EFI_GUID *VendorGuid,
OUT UINT32 *Attributes OPTIONAL, OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize, IN OUT UINTN *DataSize,
OUT VOID *Data OUT VOID *Data
) )
{ {
DEBUG((DEBUG_INFO, "GetVariableHook - %S, %g\n", VariableName, VendorGuid)); DEBUG ((DEBUG_INFO, "GetVariableHook - %S, %g\n", VariableName, VendorGuid));
return EFI_NOT_AVAILABLE_YET; return EFI_NOT_AVAILABLE_YET;
} }
@ -342,12 +349,12 @@ GetVariableHook (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
GetNextVariableNameHook ( GetNextVariableNameHook (
IN OUT UINTN *VariableNameSize, IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName, IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid IN OUT EFI_GUID *VendorGuid
) )
{ {
DEBUG((DEBUG_INFO, "GetNextVariableNameHook - %S, %g\n", VariableName, VendorGuid)); DEBUG ((DEBUG_INFO, "GetNextVariableNameHook - %S, %g\n", VariableName, VendorGuid));
return EFI_NOT_AVAILABLE_YET; return EFI_NOT_AVAILABLE_YET;
} }
@ -372,14 +379,14 @@ GetNextVariableNameHook (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SetVariableHook ( SetVariableHook (
IN CHAR16 *VariableName, IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid, IN EFI_GUID *VendorGuid,
IN UINT32 Attributes, IN UINT32 Attributes,
IN UINTN DataSize, IN UINTN DataSize,
IN VOID *Data IN VOID *Data
) )
{ {
DEBUG((DEBUG_INFO, "SetVariableHook - %S, %g, 0x%x (0x%x)\n", VariableName, VendorGuid, Attributes, DataSize)); DEBUG ((DEBUG_INFO, "SetVariableHook - %S, %g, 0x%x (0x%x)\n", VariableName, VendorGuid, Attributes, DataSize));
return EFI_NOT_AVAILABLE_YET; return EFI_NOT_AVAILABLE_YET;
} }
@ -402,13 +409,13 @@ SetVariableHook (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
QueryVariableInfoHook ( QueryVariableInfoHook (
IN UINT32 Attributes, IN UINT32 Attributes,
OUT UINT64 *MaximumVariableStorageSize, OUT UINT64 *MaximumVariableStorageSize,
OUT UINT64 *RemainingVariableStorageSize, OUT UINT64 *RemainingVariableStorageSize,
OUT UINT64 *MaximumVariableSize OUT UINT64 *MaximumVariableSize
) )
{ {
DEBUG((DEBUG_INFO, "QueryVariableInfoHook - 0x%x\n", Attributes)); DEBUG ((DEBUG_INFO, "QueryVariableInfoHook - 0x%x\n", Attributes));
return EFI_NOT_AVAILABLE_YET; return EFI_NOT_AVAILABLE_YET;
} }
@ -461,32 +468,32 @@ QueryVariableInfoHook (
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
FmpSetImage ( FmpSetImage (
IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This, IN EFI_FIRMWARE_MANAGEMENT_PROTOCOL *This,
IN UINT8 ImageIndex, IN UINT8 ImageIndex,
IN CONST VOID *Image, IN CONST VOID *Image,
IN UINTN ImageSize, IN UINTN ImageSize,
IN CONST VOID *VendorCode, IN CONST VOID *VendorCode,
IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress, IN EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS Progress,
OUT CHAR16 **AbortReason OUT CHAR16 **AbortReason
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
EFI_STATUS VarStatus; EFI_STATUS VarStatus;
SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate; SYSTEM_FMP_PRIVATE_DATA *SystemFmpPrivate;
if (Image == NULL || ImageSize == 0 || AbortReason == NULL) { if ((Image == NULL) || (ImageSize == 0) || (AbortReason == NULL)) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
SystemFmpPrivate = SYSTEM_FMP_PRIVATE_DATA_FROM_FMP(This); SystemFmpPrivate = SYSTEM_FMP_PRIVATE_DATA_FROM_FMP (This);
*AbortReason = NULL; *AbortReason = NULL;
if (ImageIndex == 0 || ImageIndex > SystemFmpPrivate->DescriptorCount) { if ((ImageIndex == 0) || (ImageIndex > SystemFmpPrivate->DescriptorCount)) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
Status = SystemFirmwareAuthenticatedUpdate((VOID *)Image, ImageSize, &SystemFmpPrivate->LastAttempt.LastAttemptVersion, &SystemFmpPrivate->LastAttempt.LastAttemptStatus, Progress); Status = SystemFirmwareAuthenticatedUpdate ((VOID *)Image, ImageSize, &SystemFmpPrivate->LastAttempt.LastAttemptVersion, &SystemFmpPrivate->LastAttempt.LastAttemptStatus, Progress);
DEBUG((DEBUG_INFO, "SetImage - LastAttempt Version - 0x%x, State - 0x%x\n", SystemFmpPrivate->LastAttempt.LastAttemptVersion, SystemFmpPrivate->LastAttempt.LastAttemptStatus)); DEBUG ((DEBUG_INFO, "SetImage - LastAttempt Version - 0x%x, State - 0x%x\n", SystemFmpPrivate->LastAttempt.LastAttemptVersion, SystemFmpPrivate->LastAttempt.LastAttemptStatus));
// //
// If NVRAM is updated, we should no longer touch variable services, because // If NVRAM is updated, we should no longer touch variable services, because
@ -501,20 +508,20 @@ FmpSetImage (
gRT->Hdr.CRC32 = 0; gRT->Hdr.CRC32 = 0;
gBS->CalculateCrc32 ( gBS->CalculateCrc32 (
(UINT8 *) &gRT->Hdr, (UINT8 *)&gRT->Hdr,
gRT->Hdr.HeaderSize, gRT->Hdr.HeaderSize,
&gRT->Hdr.CRC32 &gRT->Hdr.CRC32
); );
} }
VarStatus = gRT->SetVariable( VarStatus = gRT->SetVariable (
SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME, SYSTEM_FMP_LAST_ATTEMPT_VARIABLE_NAME,
&gSystemFmpLastAttemptVariableGuid, &gSystemFmpLastAttemptVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS, EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof(SystemFmpPrivate->LastAttempt), sizeof (SystemFmpPrivate->LastAttempt),
&SystemFmpPrivate->LastAttempt &SystemFmpPrivate->LastAttempt
); );
DEBUG((DEBUG_INFO, "SetLastAttempt - %r\n", VarStatus)); DEBUG ((DEBUG_INFO, "SetLastAttempt - %r\n", VarStatus));
return Status; return Status;
} }
@ -568,16 +575,16 @@ GetFmpImageDescriptors (
// Determine the size required for the set of EFI_FIRMWARE_IMAGE_DESCRIPTORs. // Determine the size required for the set of EFI_FIRMWARE_IMAGE_DESCRIPTORs.
// //
ImageInfoSize = 0; ImageInfoSize = 0;
Status = Fmp->GetImageInfo ( Status = Fmp->GetImageInfo (
Fmp, // FMP Pointer Fmp, // FMP Pointer
&ImageInfoSize, // Buffer Size (in this case 0) &ImageInfoSize, // Buffer Size (in this case 0)
NULL, // NULL so we can get size NULL, // NULL so we can get size
&FmpImageInfoDescriptorVer, // DescriptorVersion &FmpImageInfoDescriptorVer, // DescriptorVersion
FmpImageInfoCount, // DescriptorCount FmpImageInfoCount, // DescriptorCount
DescriptorSize, // DescriptorSize DescriptorSize, // DescriptorSize
&PackageVersion, // PackageVersion &PackageVersion, // PackageVersion
&PackageVersionName // PackageVersionName &PackageVersionName // PackageVersionName
); );
if (Status != EFI_BUFFER_TOO_SMALL) { if (Status != EFI_BUFFER_TOO_SMALL) {
DEBUG ((DEBUG_ERROR, "SystemFirmwareUpdateDxe: Unexpected Failure. Status = %r\n", Status)); DEBUG ((DEBUG_ERROR, "SystemFirmwareUpdateDxe: Unexpected Failure. Status = %r\n", Status));
return NULL; return NULL;
@ -597,16 +604,16 @@ GetFmpImageDescriptors (
// Retrieve the set of EFI_FIRMWARE_IMAGE_DESCRIPTORs. // Retrieve the set of EFI_FIRMWARE_IMAGE_DESCRIPTORs.
// //
PackageVersionName = NULL; PackageVersionName = NULL;
Status = Fmp->GetImageInfo ( Status = Fmp->GetImageInfo (
Fmp, Fmp,
&ImageInfoSize, // ImageInfoSize &ImageInfoSize, // ImageInfoSize
FmpImageInfoBuf, // ImageInfo FmpImageInfoBuf, // ImageInfo
&FmpImageInfoDescriptorVer, // DescriptorVersion &FmpImageInfoDescriptorVer, // DescriptorVersion
FmpImageInfoCount, // DescriptorCount FmpImageInfoCount, // DescriptorCount
DescriptorSize, // DescriptorSize DescriptorSize, // DescriptorSize
&PackageVersion, // PackageVersion &PackageVersion, // PackageVersion
&PackageVersionName // PackageVersionName &PackageVersionName // PackageVersionName
); );
// //
// Free unused PackageVersionName return buffer // Free unused PackageVersionName return buffer
@ -621,6 +628,7 @@ GetFmpImageDescriptors (
if (FmpImageInfoBuf != NULL) { if (FmpImageInfoBuf != NULL) {
FreePool (FmpImageInfoBuf); FreePool (FmpImageInfoBuf);
} }
return NULL; return NULL;
} }
@ -656,16 +664,16 @@ FindMatchingFmpHandles (
UINTN DescriptorSize; UINTN DescriptorSize;
BOOLEAN MatchFound; BOOLEAN MatchFound;
*HandleCount = 0; *HandleCount = 0;
TempHandleCount = 0; TempHandleCount = 0;
HandleBuffer = NULL; HandleBuffer = NULL;
Status = gBS->LocateHandleBuffer ( Status = gBS->LocateHandleBuffer (
ByProtocol, ByProtocol,
ProtocolGuid, ProtocolGuid,
NULL, NULL,
&TempHandleCount, &TempHandleCount,
&HandleBuffer &HandleBuffer
); );
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
return NULL; return NULL;
} }
@ -688,21 +696,24 @@ FindMatchingFmpHandles (
for (Index2 = 0; Index2 < FmpImageInfoCount; Index2++) { for (Index2 = 0; Index2 < FmpImageInfoCount; Index2++) {
for (Index3 = 0; Index3 < mSystemFmpPrivate->DescriptorCount; Index3++) { for (Index3 = 0; Index3 < mSystemFmpPrivate->DescriptorCount; Index3++) {
MatchFound = CompareGuid ( MatchFound = CompareGuid (
&FmpImageInfoBuf->ImageTypeId, &FmpImageInfoBuf->ImageTypeId,
&mSystemFmpPrivate->ImageDescriptor[Index3].ImageTypeId &mSystemFmpPrivate->ImageDescriptor[Index3].ImageTypeId
); );
if (MatchFound) { if (MatchFound) {
break; break;
} }
} }
if (MatchFound) { if (MatchFound) {
break; break;
} }
// //
// Increment the buffer pointer ahead by the size of the descriptor // Increment the buffer pointer ahead by the size of the descriptor
// //
FmpImageInfoBuf = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)(((UINT8 *)FmpImageInfoBuf) + DescriptorSize); FmpImageInfoBuf = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)(((UINT8 *)FmpImageInfoBuf) + DescriptorSize);
} }
if (MatchFound) { if (MatchFound) {
HandleBuffer[*HandleCount] = HandleBuffer[Index]; HandleBuffer[*HandleCount] = HandleBuffer[Index];
(*HandleCount)++; (*HandleCount)++;
@ -719,6 +730,7 @@ FindMatchingFmpHandles (
FreePool (HandleBuffer); FreePool (HandleBuffer);
return NULL; return NULL;
} }
return HandleBuffer; return HandleBuffer;
} }
@ -752,7 +764,7 @@ UninstallMatchingSystemFmpProtocols (
DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Found %d matching System FMP instances\n", HandleCount)); DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Found %d matching System FMP instances\n", HandleCount));
for (Index = 0; Index < HandleCount; Index++) { for (Index = 0; Index < HandleCount; Index++) {
Status = gBS->HandleProtocol( Status = gBS->HandleProtocol (
HandleBuffer[Index], HandleBuffer[Index],
&gSystemFmpProtocolGuid, &gSystemFmpProtocolGuid,
(VOID **)&SystemFmp (VOID **)&SystemFmp
@ -760,6 +772,7 @@ UninstallMatchingSystemFmpProtocols (
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
continue; continue;
} }
DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Uninstall SystemFmp produced by another capsule\n")); DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Uninstall SystemFmp produced by another capsule\n"));
Status = gBS->UninstallProtocolInterface ( Status = gBS->UninstallProtocolInterface (
HandleBuffer[Index], HandleBuffer[Index],
@ -772,6 +785,7 @@ UninstallMatchingSystemFmpProtocols (
return Status; return Status;
} }
} }
if (HandleBuffer != NULL) { if (HandleBuffer != NULL) {
FreePool (HandleBuffer); FreePool (HandleBuffer);
} }
@ -832,7 +846,7 @@ SystemFirmwareUpdateMainDxe (
// //
// Look for a handle with matching Firmware Management Protocol // Look for a handle with matching Firmware Management Protocol
// //
HandleCount = 0; HandleCount = 0;
HandleBuffer = FindMatchingFmpHandles ( HandleBuffer = FindMatchingFmpHandles (
&gEfiFirmwareManagementProtocolGuid, &gEfiFirmwareManagementProtocolGuid,
&HandleCount &HandleCount
@ -840,38 +854,38 @@ SystemFirmwareUpdateMainDxe (
DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Found %d matching FMP instances\n", HandleCount)); DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Found %d matching FMP instances\n", HandleCount));
switch (HandleCount) { switch (HandleCount) {
case 0: case 0:
// //
// Install FMP protocol onto a new handle. // Install FMP protocol onto a new handle.
// //
DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Install FMP onto a new handle\n")); DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Install FMP onto a new handle\n"));
Status = gBS->InstallMultipleProtocolInterfaces ( Status = gBS->InstallMultipleProtocolInterfaces (
&mSystemFmpPrivate->Handle, &mSystemFmpPrivate->Handle,
&gEfiFirmwareManagementProtocolGuid, &gEfiFirmwareManagementProtocolGuid,
&mSystemFmpPrivate->Fmp, &mSystemFmpPrivate->Fmp,
NULL NULL
); );
break; break;
case 1: case 1:
// //
// Install System FMP protocol onto handle with matching FMP Protocol // Install System FMP protocol onto handle with matching FMP Protocol
// //
DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Install System FMP onto matching FMP handle\n")); DEBUG ((DEBUG_INFO, "SystemFirmwareUpdateDxe: Install System FMP onto matching FMP handle\n"));
mSystemFmpPrivate->Handle = HandleBuffer[0]; mSystemFmpPrivate->Handle = HandleBuffer[0];
Status = gBS->InstallMultipleProtocolInterfaces ( Status = gBS->InstallMultipleProtocolInterfaces (
&HandleBuffer[0], &HandleBuffer[0],
&gSystemFmpProtocolGuid, &gSystemFmpProtocolGuid,
&mSystemFmpPrivate->Fmp, &mSystemFmpPrivate->Fmp,
NULL NULL
); );
break; break;
default: default:
// //
// More than one matching handle is not expected. Unload driver. // More than one matching handle is not expected. Unload driver.
// //
DEBUG ((DEBUG_ERROR, "SystemFirmwareUpdateDxe: More than one matching FMP handle. Unload driver.\n")); DEBUG ((DEBUG_ERROR, "SystemFirmwareUpdateDxe: More than one matching FMP handle. Unload driver.\n"));
Status = EFI_DEVICE_ERROR; Status = EFI_DEVICE_ERROR;
break; break;
} }
if (HandleBuffer != NULL) { if (HandleBuffer != NULL) {