BaseTools/Source/C/Common/FirmwareVolumeBuffer.c

   1 /** @file
   2 EFI Firmware Volume routines which work on a Fv image in buffers.
   3
   4 Copyright (c) 1999 - 2014, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "FirmwareVolumeBufferLib.h"
  16 #include "BinderFuncs.h"
  17
  18 //
  19 // Local macros
  20 //
  21 #define EFI_TEST_FFS_ATTRIBUTES_BIT(FvbAttributes, TestAttributes, Bit) \
  22     ( \
  23       (BOOLEAN) ( \
  24           (FvbAttributes & EFI_FVB2_ERASE_POLARITY) ? (((~TestAttributes) & Bit) == Bit) : ((TestAttributes & Bit) == Bit) \
  25         ) \
  26     )
  27
  28
  29 //
  30 // Local prototypes
  31 //
  32
  33 STATIC
  34 UINT32
  35 FvBufGetSecHdrLen(
  36    IN EFI_COMMON_SECTION_HEADER *SectionHeader
  37    )
  38 {
  39   if (SectionHeader == NULL) {
  40     return 0;
  41   }
  42   if (FvBufExpand3ByteSize(SectionHeader->Size) == 0xffffff) {
  43     return sizeof(EFI_COMMON_SECTION_HEADER2);
  44   }
  45   return sizeof(EFI_COMMON_SECTION_HEADER);
  46 }
  47
  48 STATIC
  49 UINT32
  50 FvBufGetSecFileLen (
  51   IN EFI_COMMON_SECTION_HEADER *SectionHeader
  52   )
  53 {
  54   UINT32 Length;
  55   if (SectionHeader == NULL) {
  56     return 0;
  57   }
  58   Length = FvBufExpand3ByteSize(SectionHeader->Size);
  59   if (Length == 0xffffff) {
  60     Length = ((EFI_COMMON_SECTION_HEADER2 *)SectionHeader)->ExtendedSize;
  61   }
  62   return Length;
  63 }
  64
  65 //
  66 // Local prototypes
  67 //
  68
  69 STATIC
  70 UINT16
  71 FvBufCalculateChecksum16 (
  72   IN UINT16       *Buffer,
  73   IN UINTN        Size
  74   );
  75
  76 STATIC
  77 UINT8
  78 FvBufCalculateChecksum8 (
  79   IN UINT8        *Buffer,
  80   IN UINTN        Size
  81   );
  82
  83 //
  84 // Procedures start
  85 //
  86
  87 EFI_STATUS
  88 FvBufRemoveFileNew (
  89   IN OUT VOID *Fv,
  90   IN EFI_GUID *Name
  91   )
  92 /*++
  93
  94 Routine Description:
  95
  96   Clears out all files from the Fv buffer in memory
  97
  98 Arguments:
  99
 100   SourceFv - Address of the Fv in memory, this firmware volume volume will
 101              be modified, if SourceFfsFile exists
 102   SourceFfsFile - Input FFS file to replace
 103
 104 Returns:
 105
 106   EFI_SUCCESS
 107   EFI_NOT_FOUND
 108
 109 --*/
 110 {
 111   EFI_STATUS                  Status;
 112   EFI_FFS_FILE_HEADER*        FileToRm;
 113   UINTN                       FileToRmLength;
 114
 115   Status = FvBufFindFileByName(
 116     Fv,
 117     Name,
 118     (VOID **)&FileToRm
 119     );
 120   if (EFI_ERROR (Status)) {
 121     return Status;
 122   }
 123
 124   FileToRmLength = FvBufGetFfsFileSize (FileToRm);
 125
 126   CommonLibBinderSetMem (
 127     FileToRm,
 128     FileToRmLength,
 129     (((EFI_FIRMWARE_VOLUME_HEADER*)Fv)->Attributes & EFI_FVB2_ERASE_POLARITY)
 130       ? 0xFF : 0
 131     );
 132
 133   return EFI_SUCCESS;
 134 }
 135
 136
 137 EFI_STATUS
 138 FvBufRemoveFile (
 139   IN OUT VOID *Fv,
 140   IN EFI_GUID *Name
 141   )
 142 /*++
 143
 144 Routine Description:
 145
 146   Clears out all files from the Fv buffer in memory
 147
 148 Arguments:
 149
 150   SourceFv - Address of the Fv in memory, this firmware volume volume will
 151              be modified, if SourceFfsFile exists
 152   SourceFfsFile - Input FFS file to replace
 153
 154 Returns:
 155
 156   EFI_SUCCESS
 157   EFI_NOT_FOUND
 158
 159 --*/
 160 {
 161   EFI_STATUS                  Status;
 162   EFI_FFS_FILE_HEADER        *NextFile;
 163   EFI_FIRMWARE_VOLUME_HEADER *TempFv;
 164   UINTN                       FileKey;
 165   UINTN                       FvLength;
 166
 167   Status = FvBufFindFileByName(
 168     Fv,
 169     Name,
 170     NULL
 171     );
 172   if (EFI_ERROR (Status)) {
 173     return Status;
 174   }
 175
 176   Status = FvBufGetSize (Fv, &FvLength);
 177   if (EFI_ERROR (Status)) {
 178     return Status;
 179   }
 180
 181   TempFv = NULL;
 182   Status = FvBufDuplicate (Fv, (VOID **)&TempFv);
 183   if (EFI_ERROR (Status)) {
 184     return Status;
 185   }
 186
 187   Status = FvBufClearAllFiles (TempFv);
 188   if (EFI_ERROR (Status)) {
 189     return Status;
 190   }
 191
 192   // TempFv has been allocated.  It must now be freed
 193   // before returning.
 194
 195   FileKey = 0;
 196   while (TRUE) {
 197
 198     Status = FvBufFindNextFile (Fv, &FileKey, (VOID **)&NextFile);
 199     if (Status == EFI_NOT_FOUND) {
 200       break;
 201     } else if (EFI_ERROR (Status)) {
 202       CommonLibBinderFree (TempFv);
 203       return Status;
 204     }
 205
 206     if (CommonLibBinderCompareGuid (Name, &NextFile->Name)) {
 207       continue;
 208     }
 209     else {
 210       Status = FvBufAddFile (TempFv, NextFile);
 211       if (EFI_ERROR (Status)) {
 212         CommonLibBinderFree (TempFv);
 213         return Status;
 214       }
 215     }
 216   }
 217
 218   CommonLibBinderCopyMem (Fv, TempFv, FvLength);
 219   CommonLibBinderFree (TempFv);
 220
 221   return EFI_SUCCESS;
 222 }
 223
 224
 225 EFI_STATUS
 226 FvBufChecksumFile (
 227   IN OUT VOID *FfsFile
 228   )
 229 /*++
 230
 231 Routine Description:
 232
 233   Clears out all files from the Fv buffer in memory
 234
 235 Arguments:
 236
 237   SourceFfsFile - Input FFS file to update the checksum for
 238
 239 Returns:
 240
 241   EFI_SUCCESS
 242   EFI_NOT_FOUND
 243
 244 --*/
 245 {
 246   EFI_FFS_FILE_HEADER* File = (EFI_FFS_FILE_HEADER*)FfsFile;
 247   EFI_FFS_FILE_STATE StateBackup;
 248   UINT32 FileSize;
 249
 250   FileSize = FvBufGetFfsFileSize (File);
 251
 252   //
 253   // Fill in checksums and state, they must be 0 for checksumming.
 254   //
 255   File->IntegrityCheck.Checksum.Header = 0;
 256   File->IntegrityCheck.Checksum.File = 0;
 257   StateBackup = File->State;
 258   File->State = 0;
 259
 260   File->IntegrityCheck.Checksum.Header =
 261     FvBufCalculateChecksum8 (
 262       (UINT8 *) File,
 263       FvBufGetFfsHeaderSize (File)
 264       );
 265
 266   if (File->Attributes & FFS_ATTRIB_CHECKSUM) {
 267     File->IntegrityCheck.Checksum.File = FvBufCalculateChecksum8 (
 268                                                 (VOID*)((UINT8 *)File + FvBufGetFfsHeaderSize (File)),
 269                                                 FileSize - FvBufGetFfsHeaderSize (File)
 270                                                 );
 271   } else {
 272     File->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
 273   }
 274
 275   File->State = StateBackup;
 276
 277   return EFI_SUCCESS;
 278 }
 279
 280
 281 EFI_STATUS
 282 FvBufChecksumHeader (
 283   IN OUT VOID *Fv
 284   )
 285 /*++
 286
 287 Routine Description:
 288
 289   Clears out all files from the Fv buffer in memory
 290
 291 Arguments:
 292
 293   SourceFv - Address of the Fv in memory, this firmware volume volume will
 294              be modified, if SourceFfsFile exists
 295   SourceFfsFile - Input FFS file to replace
 296
 297 Returns:
 298
 299   EFI_SUCCESS
 300   EFI_NOT_FOUND
 301
 302 --*/
 303 {
 304   EFI_FIRMWARE_VOLUME_HEADER* FvHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;
 305
 306   FvHeader->Checksum = 0;
 307   FvHeader->Checksum =
 308     FvBufCalculateChecksum16 (
 309       (UINT16*) FvHeader,
 310       FvHeader->HeaderLength / sizeof (UINT16)
 311       );
 312
 313   return EFI_SUCCESS;
 314 }
 315
 316
 317 EFI_STATUS
 318 FvBufDuplicate (
 319   IN VOID *SourceFv,
 320   IN OUT VOID **DestinationFv
 321   )
 322 /*++
 323
 324 Routine Description:
 325
 326   Clears out all files from the Fv buffer in memory
 327
 328 Arguments:
 329
 330   SourceFv - Address of the Fv in memory
 331   DestinationFv - Output for destination Fv
 332     DestinationFv == NULL - invalid parameter
 333     *DestinationFv == NULL - memory will be allocated
 334     *DestinationFv != NULL - this address will be the destination
 335
 336 Returns:
 337
 338   EFI_SUCCESS
 339
 340 --*/
 341 {
 342   EFI_STATUS Status;
 343   UINTN size;
 344
 345   if (DestinationFv == NULL) {
 346     return EFI_INVALID_PARAMETER;
 347   }
 348
 349   Status = FvBufGetSize (SourceFv, &size);
 350   if (EFI_ERROR (Status)) {
 351     return Status;
 352   }
 353
 354   if (*DestinationFv == NULL) {
 355     *DestinationFv = CommonLibBinderAllocate (size);
 356   }
 357
 358   CommonLibBinderCopyMem (*DestinationFv, SourceFv, size);
 359
 360   return EFI_SUCCESS;
 361 }
 362
 363
 364 EFI_STATUS
 365 FvBufExtend (
 366   IN VOID **Fv,
 367   IN UINTN Size
 368   )
 369 /*++
 370
 371 Routine Description:
 372
 373   Extends a firmware volume by the given number of bytes.
 374
 375   BUGBUG: Does not handle the case where the firmware volume has a
 376           VTF (Volume Top File).  The VTF will not be moved to the
 377           end of the extended FV.
 378
 379 Arguments:
 380
 381   Fv - Source and destination firmware volume.
 382        Note: The original firmware volume buffer is freed!
 383
 384   Size - The minimum size that the firmware volume is to be extended by.
 385          The FV may be extended more than this size.
 386
 387 Returns:
 388
 389   EFI_SUCCESS
 390
 391 --*/
 392 {
 393   EFI_STATUS Status;
 394   UINTN OldSize;
 395   UINTN NewSize;
 396   UINTN BlockCount;
 397   VOID* NewFv;
 398
 399   EFI_FIRMWARE_VOLUME_HEADER* hdr;
 400   EFI_FV_BLOCK_MAP_ENTRY*     blk;
 401
 402   Status = FvBufGetSize (*Fv, &OldSize);
 403   if (EFI_ERROR (Status)) {
 404     return Status;
 405   }
 406
 407   //
 408   // Locate the block map in the fv header
 409   //
 410   hdr = (EFI_FIRMWARE_VOLUME_HEADER*)*Fv;
 411   blk = hdr->BlockMap;
 412
 413   //
 414   // Calculate the number of blocks needed to achieve the requested
 415   // size extension
 416   //
 417   BlockCount = ((Size + (blk->Length - 1)) / blk->Length);
 418
 419   //
 420   // Calculate the new size from the number of blocks that will be added
 421   //
 422   NewSize = OldSize + (BlockCount * blk->Length);
 423
 424   NewFv = CommonLibBinderAllocate (NewSize);
 425   if (NewFv == NULL) {
 426     return EFI_OUT_OF_RESOURCES;
 427   }
 428
 429   //
 430   // Copy the old data
 431   //
 432   CommonLibBinderCopyMem (NewFv, *Fv, OldSize);
 433
 434   //
 435   // Free the old fv buffer
 436   //
 437   CommonLibBinderFree (*Fv);
 438
 439   //
 440   // Locate the block map in the new fv header
 441   //
 442   hdr = (EFI_FIRMWARE_VOLUME_HEADER*)NewFv;
 443   hdr->FvLength = NewSize;
 444   blk = hdr->BlockMap;
 445
 446   //
 447   // Update the block map for the new fv
 448   //
 449   blk->NumBlocks += (UINT32)BlockCount;
 450
 451   //
 452   // Update the FV header checksum
 453   //
 454   FvBufChecksumHeader (NewFv);
 455
 456   //
 457   // Clear out the new area of the FV
 458   //
 459   CommonLibBinderSetMem (
 460     (UINT8*)NewFv + OldSize,
 461     (NewSize - OldSize),
 462     (hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0
 463     );
 464
 465   //
 466   // Set output with new fv that was created
 467   //
 468   *Fv = NewFv;
 469
 470   return EFI_SUCCESS;
 471
 472 }
 473
 474
 475 EFI_STATUS
 476 FvBufClearAllFiles (
 477   IN OUT VOID *Fv
 478   )
 479 /*++
 480
 481 Routine Description:
 482
 483   Clears out all files from the Fv buffer in memory
 484
 485 Arguments:
 486
 487   Fv - Address of the Fv in memory
 488
 489 Returns:
 490
 491   EFI_SUCCESS
 492
 493 --*/
 494
 495 {
 496   EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;
 497   EFI_STATUS Status;
 498   UINTN size = 0;
 499
 500   Status = FvBufGetSize (Fv, &size);
 501   if (EFI_ERROR (Status)) {
 502     return Status;
 503   }
 504
 505   CommonLibBinderSetMem(
 506     (UINT8*)hdr + hdr->HeaderLength,
 507     size - hdr->HeaderLength,
 508     (hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0
 509     );
 510
 511   return EFI_SUCCESS;
 512 }
 513
 514
 515 EFI_STATUS
 516 FvBufGetSize (
 517   IN VOID *Fv,
 518   OUT UINTN *Size
 519   )
 520 /*++
 521
 522 Routine Description:
 523
 524   Clears out all files from the Fv buffer in memory
 525
 526 Arguments:
 527
 528   Fv - Address of the Fv in memory
 529
 530 Returns:
 531
 532   EFI_SUCCESS
 533
 534 --*/
 535
 536 {
 537   EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;
 538   EFI_FV_BLOCK_MAP_ENTRY *blk = hdr->BlockMap;
 539
 540   *Size = 0;
 541
 542   while (blk->Length != 0 || blk->NumBlocks != 0) {
 543     *Size = *Size + (blk->Length * blk->NumBlocks);
 544     if (*Size >= 0x40000000) {
 545       // If size is greater than 1GB, then assume it is corrupted
 546       return EFI_VOLUME_CORRUPTED;
 547     }
 548     blk++;
 549   }
 550
 551   if (*Size == 0) {
 552     // If size is 0, then assume the volume is corrupted
 553     return EFI_VOLUME_CORRUPTED;
 554   }
 555
 556   return EFI_SUCCESS;
 557 }
 558
 559
 560 EFI_STATUS
 561 FvBufAddFile (
 562   IN OUT VOID *Fv,
 563   IN VOID *File
 564   )
 565 /*++
 566
 567 Routine Description:
 568
 569   Adds a new FFS file
 570
 571 Arguments:
 572
 573   Fv - Address of the Fv in memory
 574   File - FFS file to add to Fv
 575
 576 Returns:
 577
 578   EFI_SUCCESS
 579
 580 --*/
 581 {
 582   EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;
 583
 584   EFI_FFS_FILE_HEADER *fhdr = NULL;
 585   EFI_FVB_ATTRIBUTES_2 FvbAttributes;
 586   UINTN offset;
 587   UINTN fsize;
 588   UINTN newSize;
 589   UINTN clearLoop;
 590
 591   EFI_STATUS Status;
 592   UINTN fvSize;
 593
 594   Status = FvBufGetSize (Fv, &fvSize);
 595   if (EFI_ERROR (Status)) {
 596     return Status;
 597   }
 598
 599   FvbAttributes = hdr->Attributes;
 600   newSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File);
 601
 602   for(
 603       offset = (UINTN)ALIGN_POINTER (hdr->HeaderLength, 8);
 604       offset + newSize <= fvSize;
 605       offset = (UINTN)ALIGN_POINTER (offset, 8)
 606     ) {
 607
 608     fhdr = (EFI_FFS_FILE_HEADER*) ((UINT8*)hdr + offset);
 609
 610     if (EFI_TEST_FFS_ATTRIBUTES_BIT(
 611           FvbAttributes,
 612           fhdr->State,
 613           EFI_FILE_HEADER_VALID
 614         )
 615       ) {
 616       // BUGBUG: Need to make sure that the new file does not already
 617       // exist.
 618
 619       fsize = FvBufGetFfsFileSize (fhdr);
 620       if (fsize == 0 || (offset + fsize > fvSize)) {
 621         return EFI_VOLUME_CORRUPTED;
 622       }
 623
 624       offset = offset + fsize;
 625       continue;
 626     }
 627
 628     clearLoop = 0;
 629     while ((clearLoop < newSize) &&
 630            (((UINT8*)fhdr)[clearLoop] ==
 631              (UINT8)((hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0)
 632            )
 633           ) {
 634       clearLoop++;
 635     }
 636
 637     //
 638     // We found a place in the FV which is empty and big enough for
 639     // the new file
 640     //
 641     if (clearLoop >= newSize) {
 642       break;
 643     }
 644
 645     offset = offset + 1; // Make some forward progress
 646   }
 647
 648   if (offset + newSize > fvSize) {
 649     return EFI_OUT_OF_RESOURCES;
 650   }
 651
 652   CommonLibBinderCopyMem (fhdr, File, newSize);
 653
 654   return EFI_SUCCESS;
 655 }
 656
 657
 658 EFI_STATUS
 659 FvBufAddFileWithExtend (
 660   IN OUT VOID **Fv,
 661   IN VOID *File
 662   )
 663 /*++
 664
 665 Routine Description:
 666
 667   Adds a new FFS file.  Extends the firmware volume if needed.
 668
 669 Arguments:
 670
 671   Fv - Source and destination firmware volume.
 672        Note: If the FV is extended, then the original firmware volume
 673              buffer is freed!
 674
 675   Size - The minimum size that the firmware volume is to be extended by.
 676          The FV may be extended more than this size.
 677
 678 Returns:
 679
 680   EFI_SUCCESS
 681
 682 --*/
 683 {
 684   EFI_STATUS Status;
 685   EFI_FFS_FILE_HEADER* NewFile;
 686
 687   NewFile = (EFI_FFS_FILE_HEADER*)File;
 688
 689   //
 690   // Try to add to the capsule volume
 691   //
 692   Status = FvBufAddFile (*Fv, NewFile);
 693   if (Status == EFI_OUT_OF_RESOURCES) {
 694     //
 695     // Try to extend the capsule volume by the size of the file
 696     //
 697     Status = FvBufExtend (Fv, FvBufExpand3ByteSize (NewFile->Size));
 698     if (EFI_ERROR (Status)) {
 699       return Status;
 700     }
 701
 702     //
 703     // Now, try to add the file again
 704     //
 705     Status = FvBufAddFile (*Fv, NewFile);
 706   }
 707
 708   return Status;
 709 }
 710
 711
 712 EFI_STATUS
 713 FvBufAddVtfFile (
 714   IN OUT VOID *Fv,
 715   IN VOID *File
 716   )
 717 /*++
 718
 719 Routine Description:
 720
 721   Adds a new FFS VFT (Volume Top File) file.  In other words, adds the
 722   file to the end of the firmware volume.
 723
 724 Arguments:
 725
 726   Fv - Address of the Fv in memory
 727   File - FFS file to add to Fv
 728
 729 Returns:
 730
 731   EFI_SUCCESS
 732
 733 --*/
 734 {
 735   EFI_STATUS Status;
 736
 737   EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;
 738
 739   EFI_FFS_FILE_HEADER* NewFile;
 740   UINTN                NewFileSize;
 741
 742   UINT8 erasedUint8;
 743   UINTN clearLoop;
 744
 745   EFI_FFS_FILE_HEADER *LastFile;
 746   UINTN LastFileSize;
 747
 748   UINTN fvSize;
 749   UINTN Key;
 750
 751   Status = FvBufGetSize (Fv, &fvSize);
 752   if (EFI_ERROR (Status)) {
 753     return Status;
 754   }
 755
 756   erasedUint8 = (UINT8)((hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0);
 757   NewFileSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File);
 758
 759   if (NewFileSize != (UINTN)ALIGN_POINTER (NewFileSize, 8)) {
 760     return EFI_INVALID_PARAMETER;
 761   }
 762
 763   //
 764   // Find the last file in the FV
 765   //
 766   Key = 0;
 767   LastFile = NULL;
 768   LastFileSize = 0;
 769   do {
 770     Status = FvBufFindNextFile (Fv, &Key, (VOID **)&LastFile);
 771     LastFileSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File);
 772   } while (!EFI_ERROR (Status));
 773
 774   //
 775   // If no files were found, then we start at the beginning of the FV
 776   //
 777   if (LastFile == NULL) {
 778     LastFile = (EFI_FFS_FILE_HEADER*)((UINT8*)hdr + hdr->HeaderLength);
 779   }
 780
 781   //
 782   // We want to put the new file (VTF) at the end of the FV
 783   //
 784   NewFile = (EFI_FFS_FILE_HEADER*)((UINT8*)hdr + (fvSize - NewFileSize));
 785
 786   //
 787   // Check to see if there is enough room for the VTF after the last file
 788   // found in the FV
 789   //
 790   if ((UINT8*)NewFile < ((UINT8*)LastFile + LastFileSize)) {
 791     return EFI_OUT_OF_RESOURCES;
 792   }
 793
 794   //
 795   // Loop to determine if the end of the FV is empty
 796   //
 797   clearLoop = 0;
 798   while ((clearLoop < NewFileSize) &&
 799          (((UINT8*)NewFile)[clearLoop] == erasedUint8)
 800         ) {
 801     clearLoop++;
 802   }
 803
 804   //
 805   // Check to see if there was not enough room for the file
 806   //
 807   if (clearLoop < NewFileSize) {
 808     return EFI_OUT_OF_RESOURCES;
 809   }
 810
 811   CommonLibBinderCopyMem (NewFile, File, NewFileSize);
 812
 813   return EFI_SUCCESS;
 814 }
 815
 816
 817 VOID
 818 FvBufCompact3ByteSize (
 819   OUT VOID* SizeDest,
 820   IN UINT32 Size
 821   )
 822 /*++
 823
 824 Routine Description:
 825
 826   Expands the 3 byte size commonly used in Firmware Volume data structures
 827
 828 Arguments:
 829
 830   Size - Address of the 3 byte array representing the size
 831
 832 Returns:
 833
 834   UINT32
 835
 836 --*/
 837 {
 838   ((UINT8*)SizeDest)[0] = (UINT8)Size;
 839   ((UINT8*)SizeDest)[1] = (UINT8)(Size >> 8);
 840   ((UINT8*)SizeDest)[2] = (UINT8)(Size >> 16);
 841 }
 842
 843 UINT32
 844 FvBufGetFfsFileSize (
 845   IN EFI_FFS_FILE_HEADER *Ffs
 846   )
 847 /*++
 848
 849 Routine Description:
 850
 851   Get the FFS file size.
 852
 853 Arguments:
 854
 855   Ffs - Pointer to FFS header
 856
 857 Returns:
 858
 859   UINT32
 860
 861 --*/
 862 {
 863   if (Ffs == NULL) {
 864     return 0;
 865   }
 866   if (Ffs->Attributes & FFS_ATTRIB_LARGE_FILE) {
 867     return ((EFI_FFS_FILE_HEADER2 *)Ffs)->ExtendedSize;
 868   }
 869   return FvBufExpand3ByteSize(Ffs->Size);
 870 }
 871
 872 UINT32
 873 FvBufGetFfsHeaderSize (
 874   IN EFI_FFS_FILE_HEADER *Ffs
 875   )
 876 /*++
 877
 878 Routine Description:
 879
 880   Get the FFS header size.
 881
 882 Arguments:
 883
 884   Ffs - Pointer to FFS header
 885
 886 Returns:
 887
 888   UINT32
 889
 890 --*/
 891 {
 892   if (Ffs == NULL) {
 893     return 0;
 894   }
 895   if (Ffs->Attributes & FFS_ATTRIB_LARGE_FILE) {
 896     return sizeof(EFI_FFS_FILE_HEADER2);
 897   }
 898   return sizeof(EFI_FFS_FILE_HEADER);
 899 }
 900
 901 UINT32
 902 FvBufExpand3ByteSize (
 903   IN VOID* Size
 904   )
 905 /*++
 906
 907 Routine Description:
 908
 909   Expands the 3 byte size commonly used in Firmware Volume data structures
 910
 911 Arguments:
 912
 913   Size - Address of the 3 byte array representing the size
 914
 915 Returns:
 916
 917   UINT32
 918
 919 --*/
 920 {
 921   return (((UINT8*)Size)[2] << 16) +
 922          (((UINT8*)Size)[1] << 8) +
 923          ((UINT8*)Size)[0];
 924 }
 925
 926 EFI_STATUS
 927 FvBufFindNextFile (
 928   IN VOID *Fv,
 929   IN OUT UINTN *Key,
 930   OUT VOID **File
 931   )
 932 /*++
 933
 934 Routine Description:
 935
 936   Iterates through the files contained within the firmware volume
 937
 938 Arguments:
 939
 940   Fv - Address of the Fv in memory
 941   Key - Should be 0 to get the first file.  After that, it should be
 942         passed back in without modifying it's contents to retrieve
 943         subsequent files.
 944   File - Output file pointer
 945     File == NULL - invalid parameter
 946     otherwise - *File will be update to the location of the file
 947
 948 Returns:
 949
 950   EFI_SUCCESS
 951   EFI_NOT_FOUND
 952   EFI_VOLUME_CORRUPTED
 953
 954 --*/
 955 {
 956   EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;
 957
 958   EFI_FFS_FILE_HEADER *fhdr = NULL;
 959   EFI_FVB_ATTRIBUTES_2 FvbAttributes;
 960   UINTN fsize;
 961
 962   EFI_STATUS Status;
 963   UINTN fvSize;
 964
 965   if (Fv == NULL) {
 966     return EFI_INVALID_PARAMETER;
 967   }
 968
 969   Status = FvBufGetSize (Fv, &fvSize);
 970   if (EFI_ERROR (Status)) {
 971     return Status;
 972   }
 973
 974   if (*Key == 0) {
 975     *Key = hdr->HeaderLength;
 976   }
 977
 978   FvbAttributes = hdr->Attributes;
 979
 980   for(
 981       *Key = (UINTN)ALIGN_POINTER (*Key, 8);
 982       (*Key + sizeof (*fhdr)) < fvSize;
 983       *Key = (UINTN)ALIGN_POINTER (*Key, 8)
 984     ) {
 985
 986     fhdr = (EFI_FFS_FILE_HEADER*) ((UINT8*)hdr + *Key);
 987     fsize = FvBufGetFfsFileSize (fhdr);
 988
 989     if (!EFI_TEST_FFS_ATTRIBUTES_BIT(
 990           FvbAttributes,
 991           fhdr->State,
 992           EFI_FILE_HEADER_VALID
 993         ) ||
 994         EFI_TEST_FFS_ATTRIBUTES_BIT(
 995           FvbAttributes,
 996           fhdr->State,
 997           EFI_FILE_HEADER_INVALID
 998         )
 999       ) {
1000       *Key = *Key + 1; // Make some forward progress
1001       continue;
1002     } else if(
1003         EFI_TEST_FFS_ATTRIBUTES_BIT(
1004           FvbAttributes,
1005           fhdr->State,
1006           EFI_FILE_MARKED_FOR_UPDATE
1007         ) ||
1008         EFI_TEST_FFS_ATTRIBUTES_BIT(
1009           FvbAttributes,
1010           fhdr->State,
1011           EFI_FILE_DELETED
1012         )
1013       ) {
1014       *Key = *Key + fsize;
1015       continue;
1016     } else if (EFI_TEST_FFS_ATTRIBUTES_BIT(
1017           FvbAttributes,
1018           fhdr->State,
1019           EFI_FILE_DATA_VALID
1020         )
1021       ) {
1022       *File = (UINT8*)hdr + *Key;
1023       *Key = *Key + fsize;
1024       return EFI_SUCCESS;
1025     }
1026
1027     *Key = *Key + 1; // Make some forward progress
1028   }
1029
1030   return EFI_NOT_FOUND;
1031 }
1032
1033
1034 EFI_STATUS
1035 FvBufFindFileByName (
1036   IN VOID *Fv,
1037   IN EFI_GUID *Name,
1038   OUT VOID **File
1039   )
1040 /*++
1041
1042 Routine Description:
1043
1044   Searches the Fv for a file by its name
1045
1046 Arguments:
1047
1048   Fv - Address of the Fv in memory
1049   Name - Guid filename to search for in the firmware volume
1050   File - Output file pointer
1051     File == NULL - Only determine if the file exists, based on return
1052                    value from the function call.
1053     otherwise - *File will be update to the location of the file
1054
1055 Returns:
1056
1057   EFI_SUCCESS
1058   EFI_NOT_FOUND
1059   EFI_VOLUME_CORRUPTED
1060
1061 --*/
1062 {
1063   EFI_STATUS Status;
1064   UINTN Key;
1065   EFI_FFS_FILE_HEADER *NextFile;
1066
1067   Key = 0;
1068   while (TRUE) {
1069     Status = FvBufFindNextFile (Fv, &Key, (VOID **)&NextFile);
1070     if (EFI_ERROR (Status)) {
1071       return Status;
1072     }
1073
1074     if (CommonLibBinderCompareGuid (Name, &NextFile->Name)) {
1075       if (File != NULL) {
1076         *File = NextFile;
1077       }
1078       return EFI_SUCCESS;
1079     }
1080   }
1081
1082   return EFI_NOT_FOUND;
1083 }
1084
1085
1086 EFI_STATUS
1087 FvBufFindFileByType (
1088   IN VOID *Fv,
1089   IN EFI_FV_FILETYPE Type,
1090   OUT VOID **File
1091   )
1092 /*++
1093
1094 Routine Description:
1095
1096   Searches the Fv for a file by its type
1097
1098 Arguments:
1099
1100   Fv - Address of the Fv in memory
1101   Type - FFS FILE type to search for
1102   File - Output file pointer
1103     (File == NULL) -> Only determine if the file exists, based on return
1104                       value from the function call.
1105     otherwise -> *File will be update to the location of the file
1106
1107 Returns:
1108
1109   EFI_SUCCESS
1110   EFI_NOT_FOUND
1111   EFI_VOLUME_CORRUPTED
1112
1113 --*/
1114 {
1115   EFI_STATUS Status;
1116   UINTN Key;
1117   EFI_FFS_FILE_HEADER *NextFile;
1118
1119   Key = 0;
1120   while (TRUE) {
1121     Status = FvBufFindNextFile (Fv, &Key, (VOID **)&NextFile);
1122     if (EFI_ERROR (Status)) {
1123       return Status;
1124     }
1125
1126     if (Type == NextFile->Type) {
1127       if (File != NULL) {
1128         *File = NextFile;
1129       }
1130       return EFI_SUCCESS;
1131     }
1132   }
1133
1134   return EFI_NOT_FOUND;
1135 }
1136
1137
1138 EFI_STATUS
1139 FvBufGetFileRawData (
1140   IN  VOID*     FfsFile,
1141   OUT VOID**    RawData,
1142   OUT UINTN*    RawDataSize
1143   )
1144 /*++
1145
1146 Routine Description:
1147
1148   Searches the requested file for raw data.
1149
1150   This routine either returns all the payload of a EFI_FV_FILETYPE_RAW file,
1151   or finds the EFI_SECTION_RAW section within the file and returns its data.
1152
1153 Arguments:
1154
1155   FfsFile - Address of the FFS file in memory
1156   RawData - Pointer to the raw data within the file
1157             (This is NOT allocated.  It is within the file.)
1158   RawDataSize - Size of the raw data within the file
1159
1160 Returns:
1161
1162   EFI_STATUS
1163
1164 --*/
1165 {
1166   EFI_STATUS Status;
1167   EFI_FFS_FILE_HEADER* File;
1168   EFI_RAW_SECTION* Section;
1169
1170   File = (EFI_FFS_FILE_HEADER*)FfsFile;
1171
1172   //
1173   // Is the file type == EFI_FV_FILETYPE_RAW?
1174   //
1175   if (File->Type == EFI_FV_FILETYPE_RAW) {
1176     //
1177     // Raw filetypes don't have sections, so we just return the raw data
1178     //
1179     *RawData = (VOID*)((UINT8 *)File + FvBufGetFfsHeaderSize (File));
1180     *RawDataSize = FvBufGetFfsFileSize (File) - FvBufGetFfsHeaderSize (File);
1181     return EFI_SUCCESS;
1182   }
1183
1184   //
1185   // Within the file, we now need to find the EFI_SECTION_RAW section.
1186   //
1187   Status = FvBufFindSectionByType (File, EFI_SECTION_RAW, (VOID **)&Section);
1188   if (EFI_ERROR (Status)) {
1189     return Status;
1190   }
1191
1192   *RawData = (VOID*)((UINT8 *)Section + FvBufGetSecHdrLen(Section));
1193   *RawDataSize =
1194     FvBufGetSecFileLen (Section) - FvBufGetSecHdrLen(Section);
1195
1196   return EFI_SUCCESS;
1197
1198 }
1199
1200
1201 EFI_STATUS
1202 FvBufPackageFreeformRawFile (
1203   IN EFI_GUID*  Filename,
1204   IN VOID*      RawData,
1205   IN UINTN      RawDataSize,
1206   OUT VOID**    FfsFile
1207   )
1208 /*++
1209
1210 Routine Description:
1211
1212   Packages up a FFS file containing the input raw data.
1213
1214   The file created will have a type of EFI_FV_FILETYPE_FREEFORM, and will
1215   contain one EFI_FV_FILETYPE_RAW section.
1216
1217 Arguments:
1218
1219   RawData - Pointer to the raw data to be packed
1220   RawDataSize - Size of the raw data to be packed
1221   FfsFile - Address of the packaged FFS file.
1222             Note: The called must deallocate this memory!
1223
1224 Returns:
1225
1226   EFI_STATUS
1227
1228 --*/
1229 {
1230   EFI_FFS_FILE_HEADER* NewFile;
1231   UINT32 NewFileSize;
1232   EFI_RAW_SECTION* NewSection;
1233   UINT32 NewSectionSize;
1234   UINT32 FfsHdrLen;
1235   UINT32 SecHdrLen;
1236
1237   //
1238   // The section size is the DataSize + the size of the section header
1239   //
1240   NewSectionSize = (UINT32)sizeof (EFI_RAW_SECTION) + (UINT32)RawDataSize;
1241   SecHdrLen = sizeof (EFI_RAW_SECTION);
1242   if (NewSectionSize >= MAX_SECTION_SIZE) {
1243     NewSectionSize = (UINT32)sizeof (EFI_RAW_SECTION2) + (UINT32)RawDataSize;
1244     SecHdrLen = sizeof (EFI_RAW_SECTION2);
1245   }
1246
1247   //
1248   // The file size is the size of the file header + the section size
1249   //
1250   NewFileSize = sizeof (EFI_FFS_FILE_HEADER) + NewSectionSize;
1251   FfsHdrLen = sizeof (EFI_FFS_FILE_HEADER);
1252   if (NewFileSize >= MAX_FFS_SIZE) {
1253     NewFileSize = sizeof (EFI_FFS_FILE_HEADER2) + NewSectionSize;
1254     FfsHdrLen = sizeof (EFI_FFS_FILE_HEADER2);
1255   }
1256
1257   //
1258   // Try to allocate a buffer to build the new FFS file in
1259   //
1260   NewFile = CommonLibBinderAllocate (NewFileSize);
1261   if (NewFile == NULL) {
1262     return EFI_OUT_OF_RESOURCES;
1263   }
1264   CommonLibBinderSetMem (NewFile, NewFileSize, 0);
1265
1266   //
1267   // The NewSection follow right after the FFS file header
1268   //
1269   NewSection = (EFI_RAW_SECTION*)((UINT8*)NewFile + FfsHdrLen);
1270   if (NewSectionSize >= MAX_SECTION_SIZE) {
1271     FvBufCompact3ByteSize (NewSection->Size, 0xffffff);
1272     ((EFI_RAW_SECTION2 *)NewSection)->ExtendedSize = NewSectionSize;
1273   } else {
1274     FvBufCompact3ByteSize (NewSection->Size, NewSectionSize);
1275   }
1276   NewSection->Type = EFI_SECTION_RAW;
1277
1278   //
1279   // Copy the actual file data into the buffer
1280   //
1281   CommonLibBinderCopyMem ((UINT8 *)NewSection + SecHdrLen, RawData, RawDataSize);
1282
1283   //
1284   // Initialize the FFS file header
1285   //
1286   CommonLibBinderCopyMem (&NewFile->Name, Filename, sizeof (EFI_GUID));
1287   NewFile->Attributes = 0;
1288   if (NewFileSize >= MAX_FFS_SIZE) {
1289     FvBufCompact3ByteSize (NewFile->Size, 0x0);
1290     ((EFI_FFS_FILE_HEADER2 *)NewFile)->ExtendedSize = NewFileSize;
1291     NewFile->Attributes |= FFS_ATTRIB_LARGE_FILE;
1292   } else {
1293     FvBufCompact3ByteSize (NewFile->Size, NewFileSize);
1294   }
1295   NewFile->Type = EFI_FV_FILETYPE_FREEFORM;
1296   NewFile->IntegrityCheck.Checksum.Header =
1297     FvBufCalculateChecksum8 ((UINT8*)NewFile, FfsHdrLen);
1298   NewFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;
1299   NewFile->State = (UINT8)~( EFI_FILE_HEADER_CONSTRUCTION |
1300                              EFI_FILE_HEADER_VALID |
1301                              EFI_FILE_DATA_VALID
1302                            );
1303
1304   *FfsFile = NewFile;
1305
1306   return EFI_SUCCESS;
1307 }
1308
1309
1310 EFI_STATUS
1311 FvBufFindNextSection (
1312   IN VOID *SectionsStart,
1313   IN UINTN TotalSectionsSize,
1314   IN OUT UINTN *Key,
1315   OUT VOID **Section
1316   )
1317 /*++
1318
1319 Routine Description:
1320
1321   Iterates through the sections contained within a given array of sections
1322
1323 Arguments:
1324
1325   SectionsStart - Address of the start of the FFS sections array
1326   TotalSectionsSize - Total size of all the sections
1327   Key - Should be 0 to get the first section.  After that, it should be
1328         passed back in without modifying it's contents to retrieve
1329         subsequent files.
1330   Section - Output section pointer
1331     (Section == NULL) -> invalid parameter
1332     otherwise -> *Section will be update to the location of the file
1333
1334 Returns:
1335
1336   EFI_SUCCESS
1337   EFI_NOT_FOUND
1338   EFI_VOLUME_CORRUPTED
1339
1340 --*/
1341 {
1342   EFI_COMMON_SECTION_HEADER *sectionHdr;
1343   UINTN sectionSize;
1344
1345   *Key = (UINTN)ALIGN_POINTER (*Key, 4); // Sections are DWORD aligned
1346
1347   if ((*Key + sizeof (*sectionHdr)) > TotalSectionsSize) {
1348     return EFI_NOT_FOUND;
1349   }
1350
1351   sectionHdr = (EFI_COMMON_SECTION_HEADER*)((UINT8*)SectionsStart + *Key);
1352   sectionSize = FvBufGetSecFileLen (sectionHdr);
1353
1354   if (sectionSize < sizeof (EFI_COMMON_SECTION_HEADER)) {
1355     return EFI_NOT_FOUND;
1356   }
1357
1358   if ((*Key + sectionSize) > TotalSectionsSize) {
1359     return EFI_NOT_FOUND;
1360   }
1361
1362   *Section = (UINT8*)sectionHdr;
1363   *Key = *Key + sectionSize;
1364   return EFI_SUCCESS;
1365
1366 }
1367
1368
1369 EFI_STATUS
1370 FvBufCountSections (
1371   IN VOID* FfsFile,
1372   IN UINTN* Count
1373   )
1374 /*++
1375
1376 Routine Description:
1377
1378   Searches the FFS file and counts the number of sections found.
1379   The sections are NOT recursed.
1380
1381 Arguments:
1382
1383   FfsFile - Address of the FFS file in memory
1384   Count - The location to store the section count in
1385
1386 Returns:
1387
1388   EFI_SUCCESS
1389   EFI_NOT_FOUND
1390   EFI_VOLUME_CORRUPTED
1391
1392 --*/
1393 {
1394   EFI_STATUS                 Status;
1395   UINTN                      Key;
1396   VOID*                      SectionStart;
1397   UINTN                      TotalSectionsSize;
1398   EFI_COMMON_SECTION_HEADER* NextSection;
1399
1400   SectionStart = (VOID*)((UINTN)FfsFile + FvBufGetFfsHeaderSize(FfsFile));
1401   TotalSectionsSize =
1402     FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)FfsFile) -
1403     FvBufGetFfsHeaderSize(FfsFile);
1404   Key = 0;
1405   *Count = 0;
1406   while (TRUE) {
1407     Status = FvBufFindNextSection (
1408                SectionStart,
1409                TotalSectionsSize,
1410                &Key,
1411                (VOID **)&NextSection
1412                );
1413     if (Status == EFI_NOT_FOUND) {
1414       return EFI_SUCCESS;
1415     } else if (EFI_ERROR (Status)) {
1416       return Status;
1417     }
1418
1419     //
1420     // Increment the section counter
1421     //
1422     *Count += 1;
1423
1424   }
1425
1426   return EFI_NOT_FOUND;
1427 }
1428
1429
1430 EFI_STATUS
1431 FvBufFindSectionByType (
1432   IN VOID *FfsFile,
1433   IN UINT8 Type,
1434   OUT VOID **Section
1435   )
1436 /*++
1437
1438 Routine Description:
1439
1440   Searches the FFS file for a section by its type
1441
1442 Arguments:
1443
1444   FfsFile - Address of the FFS file in memory
1445   Type - FFS FILE section type to search for
1446   Section - Output section pointer
1447     (Section == NULL) -> Only determine if the section exists, based on return
1448                          value from the function call.
1449     otherwise -> *Section will be update to the location of the file
1450
1451 Returns:
1452
1453   EFI_SUCCESS
1454   EFI_NOT_FOUND
1455   EFI_VOLUME_CORRUPTED
1456
1457 --*/
1458 {
1459   EFI_STATUS Status;
1460   UINTN Key;
1461   VOID*                      SectionStart;
1462   UINTN                      TotalSectionsSize;
1463   EFI_COMMON_SECTION_HEADER* NextSection;
1464
1465   SectionStart = (VOID*)((UINTN)FfsFile + FvBufGetFfsHeaderSize(FfsFile));
1466   TotalSectionsSize =
1467     FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)FfsFile) -
1468     FvBufGetFfsHeaderSize(FfsFile);
1469   Key = 0;
1470   while (TRUE) {
1471     Status = FvBufFindNextSection (
1472                SectionStart,
1473                TotalSectionsSize,
1474                &Key,
1475                (VOID **)&NextSection
1476                );
1477     if (EFI_ERROR (Status)) {
1478       return Status;
1479     }
1480
1481     if (Type == NextSection->Type) {
1482       if (Section != NULL) {
1483         *Section = NextSection;
1484       }
1485       return EFI_SUCCESS;
1486     }
1487   }
1488
1489   return EFI_NOT_FOUND;
1490 }
1491
1492
1493 EFI_STATUS
1494 FvBufShrinkWrap (
1495   IN VOID *Fv
1496   )
1497 /*++
1498
1499 Routine Description:
1500
1501   Shrinks a firmware volume (in place) to provide a minimal FV.
1502
1503   BUGBUG: Does not handle the case where the firmware volume has a
1504           VTF (Volume Top File).  The VTF will not be moved to the
1505           end of the extended FV.
1506
1507 Arguments:
1508
1509   Fv - Firmware volume.
1510
1511 Returns:
1512
1513   EFI_SUCCESS
1514
1515 --*/
1516 {
1517   EFI_STATUS Status;
1518   UINTN OldSize;
1519   UINT32 BlockCount;
1520   UINT32 NewBlockSize = 128;
1521   UINTN Key;
1522   EFI_FFS_FILE_HEADER* FileIt;
1523   VOID* EndOfLastFile;
1524
1525   EFI_FIRMWARE_VOLUME_HEADER* FvHdr;
1526
1527   Status = FvBufGetSize (Fv, &OldSize);
1528   if (EFI_ERROR (Status)) {
1529     return Status;
1530   }
1531
1532   Status = FvBufUnifyBlockSizes (Fv, NewBlockSize);
1533   if (EFI_ERROR (Status)) {
1534     return Status;
1535   }
1536
1537   //
1538   // Locate the block map in the fv header
1539   //
1540   FvHdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;
1541
1542   //
1543   // Find the end of the last file
1544   //
1545   Key = 0;
1546   EndOfLastFile = (UINT8*)FvHdr + FvHdr->FvLength;
1547   while (!EFI_ERROR (FvBufFindNextFile (Fv, &Key, (VOID **)&FileIt))) {
1548     EndOfLastFile =
1549       (VOID*)((UINT8*)FileIt + FvBufGetFfsFileSize (FileIt));
1550   }
1551
1552   //
1553   // Set the BlockCount to have the minimal number of blocks for the Fv.
1554   //
1555   BlockCount = (UINT32)((UINTN)EndOfLastFile - (UINTN)Fv);
1556   BlockCount = BlockCount + NewBlockSize - 1;
1557   BlockCount = BlockCount / NewBlockSize;
1558
1559   //
1560   // Adjust the block count to shrink the Fv in place.
1561   //
1562   FvHdr->BlockMap[0].NumBlocks = BlockCount;
1563   FvHdr->FvLength = BlockCount * NewBlockSize;
1564
1565   //
1566   // Update the FV header checksum
1567   //
1568   FvBufChecksumHeader (Fv);
1569
1570   return EFI_SUCCESS;
1571
1572 }
1573
1574
1575 EFI_STATUS
1576 FvBufUnifyBlockSizes (
1577   IN OUT VOID *Fv,
1578   IN UINTN BlockSize
1579   )
1580 /*++
1581
1582 Routine Description:
1583
1584   Searches the FFS file for a section by its type
1585
1586 Arguments:
1587
1588   Fv - Address of the Fv in memory
1589   BlockSize - The size of the blocks to convert the Fv to.  If the total size
1590               of the Fv is not evenly divisible by this size, then
1591               EFI_INVALID_PARAMETER will be returned.
1592
1593 Returns:
1594
1595   EFI_SUCCESS
1596   EFI_NOT_FOUND
1597   EFI_VOLUME_CORRUPTED
1598
1599 --*/
1600 {
1601   EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv;
1602   EFI_FV_BLOCK_MAP_ENTRY *blk = hdr->BlockMap;
1603   UINT32 Size;
1604
1605   Size = 0;
1606
1607   //
1608   // Scan through the block map list, performing error checking, and adding
1609   // up the total Fv size.
1610   //
1611   while( blk->Length != 0 ||
1612          blk->NumBlocks != 0
1613        ) {
1614     Size = Size + (blk->Length * blk->NumBlocks);
1615     blk++;
1616     if ((UINT8*)blk > ((UINT8*)hdr + hdr->HeaderLength)) {
1617       return EFI_VOLUME_CORRUPTED;
1618     }
1619   }
1620
1621   //
1622   // Make sure that the Fv size is a multiple of the new block size.
1623   //
1624   if ((Size % BlockSize) != 0) {
1625     return EFI_INVALID_PARAMETER;
1626   }
1627
1628   //
1629   // Zero out the entire block map.
1630   //
1631   CommonLibBinderSetMem (
1632     &hdr->BlockMap,
1633     (UINTN)blk - (UINTN)&hdr->BlockMap,
1634     0
1635     );
1636
1637   //
1638   // Write out the single block map entry.
1639   //
1640   hdr->BlockMap[0].Length = (UINT32)BlockSize;
1641   hdr->BlockMap[0].NumBlocks = Size / (UINT32)BlockSize;
1642
1643   return EFI_SUCCESS;
1644 }
1645
1646 STATIC
1647 UINT16
1648 FvBufCalculateSum16 (
1649   IN UINT16       *Buffer,
1650   IN UINTN        Size
1651   )
1652 /*++
1653
1654 Routine Description:
1655
1656   This function calculates the UINT16 sum for the requested region.
1657
1658 Arguments:
1659
1660   Buffer      Pointer to buffer containing byte data of component.
1661   Size        Size of the buffer
1662
1663 Returns:
1664
1665   The 16 bit checksum
1666
1667 --*/
1668 {
1669   UINTN   Index;
1670   UINT16  Sum;
1671
1672   Sum = 0;
1673
1674   //
1675   // Perform the word sum for buffer
1676   //
1677   for (Index = 0; Index < Size; Index++) {
1678     Sum = (UINT16) (Sum + Buffer[Index]);
1679   }
1680
1681   return (UINT16) Sum;
1682 }
1683
1684
1685 STATIC
1686 UINT16
1687 FvBufCalculateChecksum16 (
1688   IN UINT16       *Buffer,
1689   IN UINTN        Size
1690   )
1691 /*++
1692
1693 Routine Description::
1694
1695   This function calculates the value needed for a valid UINT16 checksum
1696
1697 Arguments:
1698
1699   Buffer      Pointer to buffer containing byte data of component.
1700   Size        Size of the buffer
1701
1702 Returns:
1703
1704   The 16 bit checksum value needed.
1705
1706 --*/
1707 {
1708   return (UINT16)(0x10000 - FvBufCalculateSum16 (Buffer, Size));
1709 }
1710
1711
1712 STATIC
1713 UINT8
1714 FvBufCalculateSum8 (
1715   IN UINT8  *Buffer,
1716   IN UINTN  Size
1717   )
1718 /*++
1719
1720 Description:
1721
1722   This function calculates the UINT8 sum for the requested region.
1723
1724 Input:
1725
1726   Buffer      Pointer to buffer containing byte data of component.
1727   Size        Size of the buffer
1728
1729 Return:
1730
1731   The 8 bit checksum value needed.
1732
1733 --*/
1734 {
1735   UINTN   Index;
1736   UINT8   Sum;
1737
1738   Sum = 0;
1739
1740   //
1741   // Perform the byte sum for buffer
1742   //
1743   for (Index = 0; Index < Size; Index++) {
1744     Sum = (UINT8) (Sum + Buffer[Index]);
1745   }
1746
1747   return Sum;
1748 }
1749
1750
1751 STATIC
1752 UINT8
1753 FvBufCalculateChecksum8 (
1754   IN UINT8        *Buffer,
1755   IN UINTN        Size
1756   )
1757 /*++
1758
1759 Description:
1760
1761   This function calculates the value needed for a valid UINT8 checksum
1762
1763 Input:
1764
1765   Buffer      Pointer to buffer containing byte data of component.
1766   Size        Size of the buffer
1767
1768 Return:
1769
1770   The 8 bit checksum value needed.
1771
1772 --*/
1773 {
1774   return (UINT8)(0x100 - FvBufCalculateSum8 (Buffer, Size));
1775 }
1776
1777