BaseTools: Replace BSD License with BSD+Patent License

[mirror_edk2.git] / BaseTools / Source / C / Common / FirmwareVolumeBuffer.c

/** @file\r
EFI Firmware Volume routines which work on a Fv image in buffers.\r
\r
Copyright (c) 1999 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "FirmwareVolumeBufferLib.h"\r
#include "BinderFuncs.h"\r
\r
//\r
// Local macros\r
//\r
#define EFI_TEST_FFS_ATTRIBUTES_BIT(FvbAttributes, TestAttributes, Bit) \\r
    ( \\r
      (BOOLEAN) ( \\r
          (FvbAttributes & EFI_FVB2_ERASE_POLARITY) ? (((~TestAttributes) & Bit) == Bit) : ((TestAttributes & Bit) == Bit) \\r
        ) \\r
    )\r
\r
\r
//\r
// Local prototypes\r
//\r
\r
STATIC\r
UINT32\r
FvBufGetSecHdrLen(\r
   IN EFI_COMMON_SECTION_HEADER *SectionHeader\r
   )\r
{\r
  if (SectionHeader == NULL) {\r
    return 0;\r
  }\r
  if (FvBufExpand3ByteSize(SectionHeader->Size) == 0xffffff) {\r
    return sizeof(EFI_COMMON_SECTION_HEADER2);\r
  }\r
  return sizeof(EFI_COMMON_SECTION_HEADER);\r
}\r
\r
STATIC\r
UINT32\r
FvBufGetSecFileLen (\r
  IN EFI_COMMON_SECTION_HEADER *SectionHeader\r
  )\r
{\r
  UINT32 Length;\r
  if (SectionHeader == NULL) {\r
    return 0;\r
  }\r
  Length = FvBufExpand3ByteSize(SectionHeader->Size);\r
  if (Length == 0xffffff) {\r
    Length = ((EFI_COMMON_SECTION_HEADER2 *)SectionHeader)->ExtendedSize;\r
  }\r
  return Length;\r
}\r
\r
//\r
// Local prototypes\r
//\r
\r
STATIC\r
UINT16\r
FvBufCalculateChecksum16 (\r
  IN UINT16       *Buffer,\r
  IN UINTN        Size\r
  );\r
\r
STATIC\r
UINT8\r
FvBufCalculateChecksum8 (\r
  IN UINT8        *Buffer,\r
  IN UINTN        Size\r
  );\r
\r
//\r
// Procedures start\r
//\r
\r
EFI_STATUS\r
FvBufRemoveFileNew (\r
  IN OUT VOID *Fv,\r
  IN EFI_GUID *Name\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Clears out all files from the Fv buffer in memory\r
\r
Arguments:\r
\r
  SourceFv - Address of the Fv in memory, this firmware volume volume will\r
             be modified, if SourceFfsFile exists\r
  SourceFfsFile - Input FFS file to replace\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
\r
--*/\r
{\r
  EFI_STATUS                  Status;\r
  EFI_FFS_FILE_HEADER*        FileToRm;\r
  UINTN                       FileToRmLength;\r
\r
  Status = FvBufFindFileByName(\r
    Fv,\r
    Name,\r
    (VOID **)&FileToRm\r
    );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  FileToRmLength = FvBufGetFfsFileSize (FileToRm);\r
\r
  CommonLibBinderSetMem (\r
    FileToRm,\r
    FileToRmLength,\r
    (((EFI_FIRMWARE_VOLUME_HEADER*)Fv)->Attributes & EFI_FVB2_ERASE_POLARITY)\r
      ? 0xFF : 0\r
    );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufRemoveFile (\r
  IN OUT VOID *Fv,\r
  IN EFI_GUID *Name\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Clears out all files from the Fv buffer in memory\r
\r
Arguments:\r
\r
  SourceFv - Address of the Fv in memory, this firmware volume volume will\r
             be modified, if SourceFfsFile exists\r
  SourceFfsFile - Input FFS file to replace\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
\r
--*/\r
{\r
  EFI_STATUS                  Status;\r
  EFI_FFS_FILE_HEADER        *NextFile;\r
  EFI_FIRMWARE_VOLUME_HEADER *TempFv;\r
  UINTN                       FileKey;\r
  UINTN                       FvLength;\r
\r
  Status = FvBufFindFileByName(\r
    Fv,\r
    Name,\r
    NULL\r
    );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = FvBufGetSize (Fv, &FvLength);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  TempFv = NULL;\r
  Status = FvBufDuplicate (Fv, (VOID **)&TempFv);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = FvBufClearAllFiles (TempFv);\r
  if (EFI_ERROR (Status)) {\r
    CommonLibBinderFree (TempFv);\r
    return Status;\r
  }\r
\r
  // TempFv has been allocated.  It must now be freed\r
  // before returning.\r
\r
  FileKey = 0;\r
  while (TRUE) {\r
\r
    Status = FvBufFindNextFile (Fv, &FileKey, (VOID **)&NextFile);\r
    if (Status == EFI_NOT_FOUND) {\r
      break;\r
    } else if (EFI_ERROR (Status)) {\r
      CommonLibBinderFree (TempFv);\r
      return Status;\r
    }\r
\r
    if (CommonLibBinderCompareGuid (Name, &NextFile->Name)) {\r
      continue;\r
    }\r
    else {\r
      Status = FvBufAddFile (TempFv, NextFile);\r
      if (EFI_ERROR (Status)) {\r
        CommonLibBinderFree (TempFv);\r
        return Status;\r
      }\r
    }\r
  }\r
\r
  CommonLibBinderCopyMem (Fv, TempFv, FvLength);\r
  CommonLibBinderFree (TempFv);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufChecksumFile (\r
  IN OUT VOID *FfsFile\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Clears out all files from the Fv buffer in memory\r
\r
Arguments:\r
\r
  SourceFfsFile - Input FFS file to update the checksum for\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
\r
--*/\r
{\r
  EFI_FFS_FILE_HEADER* File = (EFI_FFS_FILE_HEADER*)FfsFile;\r
  EFI_FFS_FILE_STATE StateBackup;\r
  UINT32 FileSize;\r
\r
  FileSize = FvBufGetFfsFileSize (File);\r
\r
  //\r
  // Fill in checksums and state, they must be 0 for checksumming.\r
  //\r
  File->IntegrityCheck.Checksum.Header = 0;\r
  File->IntegrityCheck.Checksum.File = 0;\r
  StateBackup = File->State;\r
  File->State = 0;\r
\r
  File->IntegrityCheck.Checksum.Header =\r
    FvBufCalculateChecksum8 (\r
      (UINT8 *) File,\r
      FvBufGetFfsHeaderSize (File)\r
      );\r
\r
  if (File->Attributes & FFS_ATTRIB_CHECKSUM) {\r
    File->IntegrityCheck.Checksum.File = FvBufCalculateChecksum8 (\r
                                                (VOID*)((UINT8 *)File + FvBufGetFfsHeaderSize (File)),\r
                                                FileSize - FvBufGetFfsHeaderSize (File)\r
                                                );\r
  } else {\r
    File->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r
  }\r
\r
  File->State = StateBackup;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufChecksumHeader (\r
  IN OUT VOID *Fv\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Clears out all files from the Fv buffer in memory\r
\r
Arguments:\r
\r
  SourceFv - Address of the Fv in memory, this firmware volume volume will\r
             be modified, if SourceFfsFile exists\r
  SourceFfsFile - Input FFS file to replace\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
\r
--*/\r
{\r
  EFI_FIRMWARE_VOLUME_HEADER* FvHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;\r
\r
  FvHeader->Checksum = 0;\r
  FvHeader->Checksum =\r
    FvBufCalculateChecksum16 (\r
      (UINT16*) FvHeader,\r
      FvHeader->HeaderLength / sizeof (UINT16)\r
      );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufDuplicate (\r
  IN VOID *SourceFv,\r
  IN OUT VOID **DestinationFv\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Clears out all files from the Fv buffer in memory\r
\r
Arguments:\r
\r
  SourceFv - Address of the Fv in memory\r
  DestinationFv - Output for destination Fv\r
    DestinationFv == NULL - invalid parameter\r
    *DestinationFv == NULL - memory will be allocated\r
    *DestinationFv != NULL - this address will be the destination\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
  UINTN size;\r
\r
  if (DestinationFv == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Status = FvBufGetSize (SourceFv, &size);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (*DestinationFv == NULL) {\r
    *DestinationFv = CommonLibBinderAllocate (size);\r
    if (*DestinationFv == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
  }\r
\r
  CommonLibBinderCopyMem (*DestinationFv, SourceFv, size);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufExtend (\r
  IN VOID **Fv,\r
  IN UINTN Size\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Extends a firmware volume by the given number of bytes.\r
\r
  BUGBUG: Does not handle the case where the firmware volume has a\r
          VTF (Volume Top File).  The VTF will not be moved to the\r
          end of the extended FV.\r
\r
Arguments:\r
\r
  Fv - Source and destination firmware volume.\r
       Note: The original firmware volume buffer is freed!\r
\r
  Size - The minimum size that the firmware volume is to be extended by.\r
         The FV may be extended more than this size.\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
  UINTN OldSize;\r
  UINTN NewSize;\r
  UINTN BlockCount;\r
  VOID* NewFv;\r
\r
  EFI_FIRMWARE_VOLUME_HEADER* hdr;\r
  EFI_FV_BLOCK_MAP_ENTRY*     blk;\r
\r
  Status = FvBufGetSize (*Fv, &OldSize);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Locate the block map in the fv header\r
  //\r
  hdr = (EFI_FIRMWARE_VOLUME_HEADER*)*Fv;\r
  blk = hdr->BlockMap;\r
\r
  //\r
  // Calculate the number of blocks needed to achieve the requested\r
  // size extension\r
  //\r
  BlockCount = ((Size + (blk->Length - 1)) / blk->Length);\r
\r
  //\r
  // Calculate the new size from the number of blocks that will be added\r
  //\r
  NewSize = OldSize + (BlockCount * blk->Length);\r
\r
  NewFv = CommonLibBinderAllocate (NewSize);\r
  if (NewFv == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Copy the old data\r
  //\r
  CommonLibBinderCopyMem (NewFv, *Fv, OldSize);\r
\r
  //\r
  // Free the old fv buffer\r
  //\r
  CommonLibBinderFree (*Fv);\r
\r
  //\r
  // Locate the block map in the new fv header\r
  //\r
  hdr = (EFI_FIRMWARE_VOLUME_HEADER*)NewFv;\r
  hdr->FvLength = NewSize;\r
  blk = hdr->BlockMap;\r
\r
  //\r
  // Update the block map for the new fv\r
  //\r
  blk->NumBlocks += (UINT32)BlockCount;\r
\r
  //\r
  // Update the FV header checksum\r
  //\r
  FvBufChecksumHeader (NewFv);\r
\r
  //\r
  // Clear out the new area of the FV\r
  //\r
  CommonLibBinderSetMem (\r
    (UINT8*)NewFv + OldSize,\r
    (NewSize - OldSize),\r
    (hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0\r
    );\r
\r
  //\r
  // Set output with new fv that was created\r
  //\r
  *Fv = NewFv;\r
\r
  return EFI_SUCCESS;\r
\r
}\r
\r
\r
EFI_STATUS\r
FvBufClearAllFiles (\r
  IN OUT VOID *Fv\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Clears out all files from the Fv buffer in memory\r
\r
Arguments:\r
\r
  Fv - Address of the Fv in memory\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
\r
--*/\r
\r
{\r
  EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;\r
  EFI_STATUS Status;\r
  UINTN size = 0;\r
\r
  Status = FvBufGetSize (Fv, &size);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  CommonLibBinderSetMem(\r
    (UINT8*)hdr + hdr->HeaderLength,\r
    size - hdr->HeaderLength,\r
    (hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0\r
    );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufGetSize (\r
  IN VOID *Fv,\r
  OUT UINTN *Size\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Clears out all files from the Fv buffer in memory\r
\r
Arguments:\r
\r
  Fv - Address of the Fv in memory\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
\r
--*/\r
\r
{\r
  EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;\r
  EFI_FV_BLOCK_MAP_ENTRY *blk = hdr->BlockMap;\r
\r
  *Size = 0;\r
\r
  while (blk->Length != 0 || blk->NumBlocks != 0) {\r
    *Size = *Size + (blk->Length * blk->NumBlocks);\r
    if (*Size >= 0x40000000) {\r
      // If size is greater than 1GB, then assume it is corrupted\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
    blk++;\r
  }\r
\r
  if (*Size == 0) {\r
    // If size is 0, then assume the volume is corrupted\r
    return EFI_VOLUME_CORRUPTED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufAddFile (\r
  IN OUT VOID *Fv,\r
  IN VOID *File\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Adds a new FFS file\r
\r
Arguments:\r
\r
  Fv - Address of the Fv in memory\r
  File - FFS file to add to Fv\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
\r
--*/\r
{\r
  EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;\r
\r
  EFI_FFS_FILE_HEADER *fhdr = NULL;\r
  EFI_FVB_ATTRIBUTES_2 FvbAttributes;\r
  UINTN offset;\r
  UINTN fsize;\r
  UINTN newSize;\r
  UINTN clearLoop;\r
\r
  EFI_STATUS Status;\r
  UINTN fvSize;\r
\r
  Status = FvBufGetSize (Fv, &fvSize);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  FvbAttributes = hdr->Attributes;\r
  newSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File);\r
\r
  for(\r
      offset = (UINTN)ALIGN_POINTER (hdr->HeaderLength, 8);\r
      offset + newSize <= fvSize;\r
      offset = (UINTN)ALIGN_POINTER (offset, 8)\r
    ) {\r
\r
    fhdr = (EFI_FFS_FILE_HEADER*) ((UINT8*)hdr + offset);\r
\r
    if (EFI_TEST_FFS_ATTRIBUTES_BIT(\r
          FvbAttributes,\r
          fhdr->State,\r
          EFI_FILE_HEADER_VALID\r
        )\r
      ) {\r
      // BUGBUG: Need to make sure that the new file does not already\r
      // exist.\r
\r
      fsize = FvBufGetFfsFileSize (fhdr);\r
      if (fsize == 0 || (offset + fsize > fvSize)) {\r
        return EFI_VOLUME_CORRUPTED;\r
      }\r
\r
      offset = offset + fsize;\r
      continue;\r
    }\r
\r
    clearLoop = 0;\r
    while ((clearLoop < newSize) &&\r
           (((UINT8*)fhdr)[clearLoop] ==\r
             (UINT8)((hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0)\r
           )\r
          ) {\r
      clearLoop++;\r
    }\r
\r
    //\r
    // We found a place in the FV which is empty and big enough for\r
    // the new file\r
    //\r
    if (clearLoop >= newSize) {\r
      break;\r
    }\r
\r
    offset = offset + 1; // Make some forward progress\r
  }\r
\r
  if (offset + newSize > fvSize) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  CommonLibBinderCopyMem (fhdr, File, newSize);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufAddFileWithExtend (\r
  IN OUT VOID **Fv,\r
  IN VOID *File\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Adds a new FFS file.  Extends the firmware volume if needed.\r
\r
Arguments:\r
\r
  Fv - Source and destination firmware volume.\r
       Note: If the FV is extended, then the original firmware volume\r
             buffer is freed!\r
\r
  Size - The minimum size that the firmware volume is to be extended by.\r
         The FV may be extended more than this size.\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
  EFI_FFS_FILE_HEADER* NewFile;\r
\r
  NewFile = (EFI_FFS_FILE_HEADER*)File;\r
\r
  //\r
  // Try to add to the capsule volume\r
  //\r
  Status = FvBufAddFile (*Fv, NewFile);\r
  if (Status == EFI_OUT_OF_RESOURCES) {\r
    //\r
    // Try to extend the capsule volume by the size of the file\r
    //\r
    Status = FvBufExtend (Fv, FvBufExpand3ByteSize (NewFile->Size));\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // Now, try to add the file again\r
    //\r
    Status = FvBufAddFile (*Fv, NewFile);\r
  }\r
\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
FvBufAddVtfFile (\r
  IN OUT VOID *Fv,\r
  IN VOID *File\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Adds a new FFS VFT (Volume Top File) file.  In other words, adds the\r
  file to the end of the firmware volume.\r
\r
Arguments:\r
\r
  Fv - Address of the Fv in memory\r
  File - FFS file to add to Fv\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
\r
  EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;\r
\r
  EFI_FFS_FILE_HEADER* NewFile;\r
  UINTN                NewFileSize;\r
\r
  UINT8 erasedUint8;\r
  UINTN clearLoop;\r
\r
  EFI_FFS_FILE_HEADER *LastFile;\r
  UINTN LastFileSize;\r
\r
  UINTN fvSize;\r
  UINTN Key;\r
\r
  Status = FvBufGetSize (Fv, &fvSize);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  erasedUint8 = (UINT8)((hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0);\r
  NewFileSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File);\r
\r
  if (NewFileSize != (UINTN)ALIGN_POINTER (NewFileSize, 8)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Find the last file in the FV\r
  //\r
  Key = 0;\r
  LastFile = NULL;\r
  LastFileSize = 0;\r
  do {\r
    Status = FvBufFindNextFile (Fv, &Key, (VOID **)&LastFile);\r
    LastFileSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File);\r
  } while (!EFI_ERROR (Status));\r
\r
  //\r
  // If no files were found, then we start at the beginning of the FV\r
  //\r
  if (LastFile == NULL) {\r
    LastFile = (EFI_FFS_FILE_HEADER*)((UINT8*)hdr + hdr->HeaderLength);\r
  }\r
\r
  //\r
  // We want to put the new file (VTF) at the end of the FV\r
  //\r
  NewFile = (EFI_FFS_FILE_HEADER*)((UINT8*)hdr + (fvSize - NewFileSize));\r
\r
  //\r
  // Check to see if there is enough room for the VTF after the last file\r
  // found in the FV\r
  //\r
  if ((UINT8*)NewFile < ((UINT8*)LastFile + LastFileSize)) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Loop to determine if the end of the FV is empty\r
  //\r
  clearLoop = 0;\r
  while ((clearLoop < NewFileSize) &&\r
         (((UINT8*)NewFile)[clearLoop] == erasedUint8)\r
        ) {\r
    clearLoop++;\r
  }\r
\r
  //\r
  // Check to see if there was not enough room for the file\r
  //\r
  if (clearLoop < NewFileSize) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  CommonLibBinderCopyMem (NewFile, File, NewFileSize);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
VOID\r
FvBufCompact3ByteSize (\r
  OUT VOID* SizeDest,\r
  IN UINT32 Size\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Expands the 3 byte size commonly used in Firmware Volume data structures\r
\r
Arguments:\r
\r
  Size - Address of the 3 byte array representing the size\r
\r
Returns:\r
\r
  UINT32\r
\r
--*/\r
{\r
  ((UINT8*)SizeDest)[0] = (UINT8)Size;\r
  ((UINT8*)SizeDest)[1] = (UINT8)(Size >> 8);\r
  ((UINT8*)SizeDest)[2] = (UINT8)(Size >> 16);\r
}\r
\r
UINT32\r
FvBufGetFfsFileSize (\r
  IN EFI_FFS_FILE_HEADER *Ffs\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Get the FFS file size.\r
\r
Arguments:\r
\r
  Ffs - Pointer to FFS header\r
\r
Returns:\r
\r
  UINT32\r
\r
--*/\r
{\r
  if (Ffs == NULL) {\r
    return 0;\r
  }\r
  if (Ffs->Attributes & FFS_ATTRIB_LARGE_FILE) {\r
    return (UINT32) ((EFI_FFS_FILE_HEADER2 *)Ffs)->ExtendedSize;\r
  }\r
  return FvBufExpand3ByteSize(Ffs->Size);\r
}\r
\r
UINT32\r
FvBufGetFfsHeaderSize (\r
  IN EFI_FFS_FILE_HEADER *Ffs\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Get the FFS header size.\r
\r
Arguments:\r
\r
  Ffs - Pointer to FFS header\r
\r
Returns:\r
\r
  UINT32\r
\r
--*/\r
{\r
  if (Ffs == NULL) {\r
    return 0;\r
  }\r
  if (Ffs->Attributes & FFS_ATTRIB_LARGE_FILE) {\r
    return sizeof(EFI_FFS_FILE_HEADER2);\r
  }\r
  return sizeof(EFI_FFS_FILE_HEADER);\r
}\r
\r
UINT32\r
FvBufExpand3ByteSize (\r
  IN VOID* Size\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Expands the 3 byte size commonly used in Firmware Volume data structures\r
\r
Arguments:\r
\r
  Size - Address of the 3 byte array representing the size\r
\r
Returns:\r
\r
  UINT32\r
\r
--*/\r
{\r
  return (((UINT8*)Size)[2] << 16) +\r
         (((UINT8*)Size)[1] << 8) +\r
         ((UINT8*)Size)[0];\r
}\r
\r
EFI_STATUS\r
FvBufFindNextFile (\r
  IN VOID *Fv,\r
  IN OUT UINTN *Key,\r
  OUT VOID **File\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Iterates through the files contained within the firmware volume\r
\r
Arguments:\r
\r
  Fv - Address of the Fv in memory\r
  Key - Should be 0 to get the first file.  After that, it should be\r
        passed back in without modifying it's contents to retrieve\r
        subsequent files.\r
  File - Output file pointer\r
    File == NULL - invalid parameter\r
    otherwise - *File will be update to the location of the file\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
  EFI_VOLUME_CORRUPTED\r
\r
--*/\r
{\r
  EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;\r
\r
  EFI_FFS_FILE_HEADER *fhdr = NULL;\r
  EFI_FVB_ATTRIBUTES_2 FvbAttributes;\r
  UINTN fsize;\r
\r
  EFI_STATUS Status;\r
  UINTN fvSize;\r
\r
  if (Fv == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Status = FvBufGetSize (Fv, &fvSize);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  if (*Key == 0) {\r
    *Key = hdr->HeaderLength;\r
  }\r
\r
  FvbAttributes = hdr->Attributes;\r
\r
  for(\r
      *Key = (UINTN)ALIGN_POINTER (*Key, 8);\r
      (*Key + sizeof (*fhdr)) < fvSize;\r
      *Key = (UINTN)ALIGN_POINTER (*Key, 8)\r
    ) {\r
\r
    fhdr = (EFI_FFS_FILE_HEADER*) ((UINT8*)hdr + *Key);\r
    fsize = FvBufGetFfsFileSize (fhdr);\r
\r
    if (!EFI_TEST_FFS_ATTRIBUTES_BIT(\r
          FvbAttributes,\r
          fhdr->State,\r
          EFI_FILE_HEADER_VALID\r
        ) ||\r
        EFI_TEST_FFS_ATTRIBUTES_BIT(\r
          FvbAttributes,\r
          fhdr->State,\r
          EFI_FILE_HEADER_INVALID\r
        )\r
      ) {\r
      *Key = *Key + 1; // Make some forward progress\r
      continue;\r
    } else if(\r
        EFI_TEST_FFS_ATTRIBUTES_BIT(\r
          FvbAttributes,\r
          fhdr->State,\r
          EFI_FILE_MARKED_FOR_UPDATE\r
        ) ||\r
        EFI_TEST_FFS_ATTRIBUTES_BIT(\r
          FvbAttributes,\r
          fhdr->State,\r
          EFI_FILE_DELETED\r
        )\r
      ) {\r
      *Key = *Key + fsize;\r
      continue;\r
    } else if (EFI_TEST_FFS_ATTRIBUTES_BIT(\r
          FvbAttributes,\r
          fhdr->State,\r
          EFI_FILE_DATA_VALID\r
        )\r
      ) {\r
      *File = (UINT8*)hdr + *Key;\r
      *Key = *Key + fsize;\r
      return EFI_SUCCESS;\r
    }\r
\r
    *Key = *Key + 1; // Make some forward progress\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
EFI_STATUS\r
FvBufFindFileByName (\r
  IN VOID *Fv,\r
  IN EFI_GUID *Name,\r
  OUT VOID **File\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Searches the Fv for a file by its name\r
\r
Arguments:\r
\r
  Fv - Address of the Fv in memory\r
  Name - Guid filename to search for in the firmware volume\r
  File - Output file pointer\r
    File == NULL - Only determine if the file exists, based on return\r
                   value from the function call.\r
    otherwise - *File will be update to the location of the file\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
  EFI_VOLUME_CORRUPTED\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
  UINTN Key;\r
  EFI_FFS_FILE_HEADER *NextFile;\r
\r
  Key = 0;\r
  while (TRUE) {\r
    Status = FvBufFindNextFile (Fv, &Key, (VOID **)&NextFile);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    if (CommonLibBinderCompareGuid (Name, &NextFile->Name)) {\r
      if (File != NULL) {\r
        *File = NextFile;\r
      }\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
EFI_STATUS\r
FvBufFindFileByType (\r
  IN VOID *Fv,\r
  IN EFI_FV_FILETYPE Type,\r
  OUT VOID **File\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Searches the Fv for a file by its type\r
\r
Arguments:\r
\r
  Fv - Address of the Fv in memory\r
  Type - FFS FILE type to search for\r
  File - Output file pointer\r
    (File == NULL) -> Only determine if the file exists, based on return\r
                      value from the function call.\r
    otherwise -> *File will be update to the location of the file\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
  EFI_VOLUME_CORRUPTED\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
  UINTN Key;\r
  EFI_FFS_FILE_HEADER *NextFile;\r
\r
  Key = 0;\r
  while (TRUE) {\r
    Status = FvBufFindNextFile (Fv, &Key, (VOID **)&NextFile);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    if (Type == NextFile->Type) {\r
      if (File != NULL) {\r
        *File = NextFile;\r
      }\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
EFI_STATUS\r
FvBufGetFileRawData (\r
  IN  VOID*     FfsFile,\r
  OUT VOID**    RawData,\r
  OUT UINTN*    RawDataSize\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Searches the requested file for raw data.\r
\r
  This routine either returns all the payload of a EFI_FV_FILETYPE_RAW file,\r
  or finds the EFI_SECTION_RAW section within the file and returns its data.\r
\r
Arguments:\r
\r
  FfsFile - Address of the FFS file in memory\r
  RawData - Pointer to the raw data within the file\r
            (This is NOT allocated.  It is within the file.)\r
  RawDataSize - Size of the raw data within the file\r
\r
Returns:\r
\r
  EFI_STATUS\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
  EFI_FFS_FILE_HEADER* File;\r
  EFI_RAW_SECTION* Section;\r
\r
  File = (EFI_FFS_FILE_HEADER*)FfsFile;\r
\r
  //\r
  // Is the file type == EFI_FV_FILETYPE_RAW?\r
  //\r
  if (File->Type == EFI_FV_FILETYPE_RAW) {\r
    //\r
    // Raw filetypes don't have sections, so we just return the raw data\r
    //\r
    *RawData = (VOID*)((UINT8 *)File + FvBufGetFfsHeaderSize (File));\r
    *RawDataSize = FvBufGetFfsFileSize (File) - FvBufGetFfsHeaderSize (File);\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Within the file, we now need to find the EFI_SECTION_RAW section.\r
  //\r
  Status = FvBufFindSectionByType (File, EFI_SECTION_RAW, (VOID **)&Section);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  *RawData = (VOID*)((UINT8 *)Section + FvBufGetSecHdrLen(Section));\r
  *RawDataSize =\r
    FvBufGetSecFileLen (Section) - FvBufGetSecHdrLen(Section);\r
\r
  return EFI_SUCCESS;\r
\r
}\r
\r
\r
EFI_STATUS\r
FvBufPackageFreeformRawFile (\r
  IN EFI_GUID*  Filename,\r
  IN VOID*      RawData,\r
  IN UINTN      RawDataSize,\r
  OUT VOID**    FfsFile\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Packages up a FFS file containing the input raw data.\r
\r
  The file created will have a type of EFI_FV_FILETYPE_FREEFORM, and will\r
  contain one EFI_FV_FILETYPE_RAW section.\r
\r
Arguments:\r
\r
  RawData - Pointer to the raw data to be packed\r
  RawDataSize - Size of the raw data to be packed\r
  FfsFile - Address of the packaged FFS file.\r
            Note: The called must deallocate this memory!\r
\r
Returns:\r
\r
  EFI_STATUS\r
\r
--*/\r
{\r
  EFI_FFS_FILE_HEADER* NewFile;\r
  UINT32 NewFileSize;\r
  EFI_RAW_SECTION* NewSection;\r
  UINT32 NewSectionSize;\r
  UINT32 FfsHdrLen;\r
  UINT32 SecHdrLen;\r
\r
  //\r
  // The section size is the DataSize + the size of the section header\r
  //\r
  NewSectionSize = (UINT32)sizeof (EFI_RAW_SECTION) + (UINT32)RawDataSize;\r
  SecHdrLen = sizeof (EFI_RAW_SECTION);\r
  if (NewSectionSize >= MAX_SECTION_SIZE) {\r
    NewSectionSize = (UINT32)sizeof (EFI_RAW_SECTION2) + (UINT32)RawDataSize;\r
    SecHdrLen = sizeof (EFI_RAW_SECTION2);\r
  }\r
\r
  //\r
  // The file size is the size of the file header + the section size\r
  //\r
  NewFileSize = sizeof (EFI_FFS_FILE_HEADER) + NewSectionSize;\r
  FfsHdrLen = sizeof (EFI_FFS_FILE_HEADER);\r
  if (NewFileSize >= MAX_FFS_SIZE) {\r
    NewFileSize = sizeof (EFI_FFS_FILE_HEADER2) + NewSectionSize;\r
    FfsHdrLen = sizeof (EFI_FFS_FILE_HEADER2);\r
  }\r
\r
  //\r
  // Try to allocate a buffer to build the new FFS file in\r
  //\r
  NewFile = CommonLibBinderAllocate (NewFileSize);\r
  if (NewFile == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  CommonLibBinderSetMem (NewFile, NewFileSize, 0);\r
\r
  //\r
  // The NewSection follow right after the FFS file header\r
  //\r
  NewSection = (EFI_RAW_SECTION*)((UINT8*)NewFile + FfsHdrLen);\r
  if (NewSectionSize >= MAX_SECTION_SIZE) {\r
    FvBufCompact3ByteSize (NewSection->Size, 0xffffff);\r
    ((EFI_RAW_SECTION2 *)NewSection)->ExtendedSize = NewSectionSize;\r
  } else {\r
    FvBufCompact3ByteSize (NewSection->Size, NewSectionSize);\r
  }\r
  NewSection->Type = EFI_SECTION_RAW;\r
\r
  //\r
  // Copy the actual file data into the buffer\r
  //\r
  CommonLibBinderCopyMem ((UINT8 *)NewSection + SecHdrLen, RawData, RawDataSize);\r
\r
  //\r
  // Initialize the FFS file header\r
  //\r
  CommonLibBinderCopyMem (&NewFile->Name, Filename, sizeof (EFI_GUID));\r
  NewFile->Attributes = 0;\r
  if (NewFileSize >= MAX_FFS_SIZE) {\r
    FvBufCompact3ByteSize (NewFile->Size, 0x0);\r
    ((EFI_FFS_FILE_HEADER2 *)NewFile)->ExtendedSize = NewFileSize;\r
    NewFile->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
  } else {\r
    FvBufCompact3ByteSize (NewFile->Size, NewFileSize);\r
  }\r
  NewFile->Type = EFI_FV_FILETYPE_FREEFORM;\r
  NewFile->IntegrityCheck.Checksum.Header =\r
    FvBufCalculateChecksum8 ((UINT8*)NewFile, FfsHdrLen);\r
  NewFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r
  NewFile->State = (UINT8)~( EFI_FILE_HEADER_CONSTRUCTION |\r
                             EFI_FILE_HEADER_VALID |\r
                             EFI_FILE_DATA_VALID\r
                           );\r
\r
  *FfsFile = NewFile;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
FvBufFindNextSection (\r
  IN VOID *SectionsStart,\r
  IN UINTN TotalSectionsSize,\r
  IN OUT UINTN *Key,\r
  OUT VOID **Section\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Iterates through the sections contained within a given array of sections\r
\r
Arguments:\r
\r
  SectionsStart - Address of the start of the FFS sections array\r
  TotalSectionsSize - Total size of all the sections\r
  Key - Should be 0 to get the first section.  After that, it should be\r
        passed back in without modifying it's contents to retrieve\r
        subsequent files.\r
  Section - Output section pointer\r
    (Section == NULL) -> invalid parameter\r
    otherwise -> *Section will be update to the location of the file\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
  EFI_VOLUME_CORRUPTED\r
\r
--*/\r
{\r
  EFI_COMMON_SECTION_HEADER *sectionHdr;\r
  UINTN sectionSize;\r
\r
  *Key = (UINTN)ALIGN_POINTER (*Key, 4); // Sections are DWORD aligned\r
\r
  if ((*Key + sizeof (*sectionHdr)) > TotalSectionsSize) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  sectionHdr = (EFI_COMMON_SECTION_HEADER*)((UINT8*)SectionsStart + *Key);\r
  sectionSize = FvBufGetSecFileLen (sectionHdr);\r
\r
  if (sectionSize < sizeof (EFI_COMMON_SECTION_HEADER)) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  if ((*Key + sectionSize) > TotalSectionsSize) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  *Section = (UINT8*)sectionHdr;\r
  *Key = *Key + sectionSize;\r
  return EFI_SUCCESS;\r
\r
}\r
\r
\r
EFI_STATUS\r
FvBufCountSections (\r
  IN VOID* FfsFile,\r
  IN UINTN* Count\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Searches the FFS file and counts the number of sections found.\r
  The sections are NOT recursed.\r
\r
Arguments:\r
\r
  FfsFile - Address of the FFS file in memory\r
  Count - The location to store the section count in\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
  EFI_VOLUME_CORRUPTED\r
\r
--*/\r
{\r
  EFI_STATUS                 Status;\r
  UINTN                      Key;\r
  VOID*                      SectionStart;\r
  UINTN                      TotalSectionsSize;\r
  EFI_COMMON_SECTION_HEADER* NextSection;\r
\r
  SectionStart = (VOID*)((UINTN)FfsFile + FvBufGetFfsHeaderSize(FfsFile));\r
  TotalSectionsSize =\r
    FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)FfsFile) -\r
    FvBufGetFfsHeaderSize(FfsFile);\r
  Key = 0;\r
  *Count = 0;\r
  while (TRUE) {\r
    Status = FvBufFindNextSection (\r
               SectionStart,\r
               TotalSectionsSize,\r
               &Key,\r
               (VOID **)&NextSection\r
               );\r
    if (Status == EFI_NOT_FOUND) {\r
      return EFI_SUCCESS;\r
    } else if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // Increment the section counter\r
    //\r
    *Count += 1;\r
\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
EFI_STATUS\r
FvBufFindSectionByType (\r
  IN VOID *FfsFile,\r
  IN UINT8 Type,\r
  OUT VOID **Section\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Searches the FFS file for a section by its type\r
\r
Arguments:\r
\r
  FfsFile - Address of the FFS file in memory\r
  Type - FFS FILE section type to search for\r
  Section - Output section pointer\r
    (Section == NULL) -> Only determine if the section exists, based on return\r
                         value from the function call.\r
    otherwise -> *Section will be update to the location of the file\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
  EFI_VOLUME_CORRUPTED\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
  UINTN Key;\r
  VOID*                      SectionStart;\r
  UINTN                      TotalSectionsSize;\r
  EFI_COMMON_SECTION_HEADER* NextSection;\r
\r
  SectionStart = (VOID*)((UINTN)FfsFile + FvBufGetFfsHeaderSize(FfsFile));\r
  TotalSectionsSize =\r
    FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)FfsFile) -\r
    FvBufGetFfsHeaderSize(FfsFile);\r
  Key = 0;\r
  while (TRUE) {\r
    Status = FvBufFindNextSection (\r
               SectionStart,\r
               TotalSectionsSize,\r
               &Key,\r
               (VOID **)&NextSection\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    if (Type == NextSection->Type) {\r
      if (Section != NULL) {\r
        *Section = NextSection;\r
      }\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
EFI_STATUS\r
FvBufShrinkWrap (\r
  IN VOID *Fv\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Shrinks a firmware volume (in place) to provide a minimal FV.\r
\r
  BUGBUG: Does not handle the case where the firmware volume has a\r
          VTF (Volume Top File).  The VTF will not be moved to the\r
          end of the extended FV.\r
\r
Arguments:\r
\r
  Fv - Firmware volume.\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
\r
--*/\r
{\r
  EFI_STATUS Status;\r
  UINTN OldSize;\r
  UINT32 BlockCount;\r
  UINT32 NewBlockSize = 128;\r
  UINTN Key;\r
  EFI_FFS_FILE_HEADER* FileIt;\r
  VOID* EndOfLastFile;\r
\r
  EFI_FIRMWARE_VOLUME_HEADER* FvHdr;\r
\r
  Status = FvBufGetSize (Fv, &OldSize);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = FvBufUnifyBlockSizes (Fv, NewBlockSize);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Locate the block map in the fv header\r
  //\r
  FvHdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;\r
\r
  //\r
  // Find the end of the last file\r
  //\r
  Key = 0;\r
  EndOfLastFile = (UINT8*)FvHdr + FvHdr->FvLength;\r
  while (!EFI_ERROR (FvBufFindNextFile (Fv, &Key, (VOID **)&FileIt))) {\r
    EndOfLastFile =\r
      (VOID*)((UINT8*)FileIt + FvBufGetFfsFileSize (FileIt));\r
  }\r
\r
  //\r
  // Set the BlockCount to have the minimal number of blocks for the Fv.\r
  //\r
  BlockCount = (UINT32)((UINTN)EndOfLastFile - (UINTN)Fv);\r
  BlockCount = BlockCount + NewBlockSize - 1;\r
  BlockCount = BlockCount / NewBlockSize;\r
\r
  //\r
  // Adjust the block count to shrink the Fv in place.\r
  //\r
  FvHdr->BlockMap[0].NumBlocks = BlockCount;\r
  FvHdr->FvLength = BlockCount * NewBlockSize;\r
\r
  //\r
  // Update the FV header checksum\r
  //\r
  FvBufChecksumHeader (Fv);\r
\r
  return EFI_SUCCESS;\r
\r
}\r
\r
\r
EFI_STATUS\r
FvBufUnifyBlockSizes (\r
  IN OUT VOID *Fv,\r
  IN UINTN BlockSize\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Searches the FFS file for a section by its type\r
\r
Arguments:\r
\r
  Fv - Address of the Fv in memory\r
  BlockSize - The size of the blocks to convert the Fv to.  If the total size\r
              of the Fv is not evenly divisible by this size, then\r
              EFI_INVALID_PARAMETER will be returned.\r
\r
Returns:\r
\r
  EFI_SUCCESS\r
  EFI_NOT_FOUND\r
  EFI_VOLUME_CORRUPTED\r
\r
--*/\r
{\r
  EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;\r
  EFI_FV_BLOCK_MAP_ENTRY *blk = hdr->BlockMap;\r
  UINT32 Size;\r
\r
  Size = 0;\r
\r
  //\r
  // Scan through the block map list, performing error checking, and adding\r
  // up the total Fv size.\r
  //\r
  while( blk->Length != 0 ||\r
         blk->NumBlocks != 0\r
       ) {\r
    Size = Size + (blk->Length * blk->NumBlocks);\r
    blk++;\r
    if ((UINT8*)blk > ((UINT8*)hdr + hdr->HeaderLength)) {\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
  }\r
\r
  //\r
  // Make sure that the Fv size is a multiple of the new block size.\r
  //\r
  if ((Size % BlockSize) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Zero out the entire block map.\r
  //\r
  CommonLibBinderSetMem (\r
    &hdr->BlockMap,\r
    (UINTN)blk - (UINTN)&hdr->BlockMap,\r
    0\r
    );\r
\r
  //\r
  // Write out the single block map entry.\r
  //\r
  hdr->BlockMap[0].Length = (UINT32)BlockSize;\r
  hdr->BlockMap[0].NumBlocks = Size / (UINT32)BlockSize;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
UINT16\r
FvBufCalculateSum16 (\r
  IN UINT16       *Buffer,\r
  IN UINTN        Size\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function calculates the UINT16 sum for the requested region.\r
\r
Arguments:\r
\r
  Buffer      Pointer to buffer containing byte data of component.\r
  Size        Size of the buffer\r
\r
Returns:\r
\r
  The 16 bit checksum\r
\r
--*/\r
{\r
  UINTN   Index;\r
  UINT16  Sum;\r
\r
  Sum = 0;\r
\r
  //\r
  // Perform the word sum for buffer\r
  //\r
  for (Index = 0; Index < Size; Index++) {\r
    Sum = (UINT16) (Sum + Buffer[Index]);\r
  }\r
\r
  return (UINT16) Sum;\r
}\r
\r
\r
STATIC\r
UINT16\r
FvBufCalculateChecksum16 (\r
  IN UINT16       *Buffer,\r
  IN UINTN        Size\r
  )\r
/*++\r
\r
Routine Description::\r
\r
  This function calculates the value needed for a valid UINT16 checksum\r
\r
Arguments:\r
\r
  Buffer      Pointer to buffer containing byte data of component.\r
  Size        Size of the buffer\r
\r
Returns:\r
\r
  The 16 bit checksum value needed.\r
\r
--*/\r
{\r
  return (UINT16)(0x10000 - FvBufCalculateSum16 (Buffer, Size));\r
}\r
\r
\r
STATIC\r
UINT8\r
FvBufCalculateSum8 (\r
  IN UINT8  *Buffer,\r
  IN UINTN  Size\r
  )\r
/*++\r
\r
Description:\r
\r
  This function calculates the UINT8 sum for the requested region.\r
\r
Input:\r
\r
  Buffer      Pointer to buffer containing byte data of component.\r
  Size        Size of the buffer\r
\r
Return:\r
\r
  The 8 bit checksum value needed.\r
\r
--*/\r
{\r
  UINTN   Index;\r
  UINT8   Sum;\r
\r
  Sum = 0;\r
\r
  //\r
  // Perform the byte sum for buffer\r
  //\r
  for (Index = 0; Index < Size; Index++) {\r
    Sum = (UINT8) (Sum + Buffer[Index]);\r
  }\r
\r
  return Sum;\r
}\r
\r
\r
STATIC\r
UINT8\r
FvBufCalculateChecksum8 (\r
  IN UINT8        *Buffer,\r
  IN UINTN        Size\r
  )\r
/*++\r
\r
Description:\r
\r
  This function calculates the value needed for a valid UINT8 checksum\r
\r
Input:\r
\r
  Buffer      Pointer to buffer containing byte data of component.\r
  Size        Size of the buffer\r
\r
Return:\r
\r
  The 8 bit checksum value needed.\r
\r
--*/\r
{\r
  return (UINT8)(0x100 - FvBufCalculateSum8 (Buffer, Size));\r
}\r
\r
\r