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