IntelFrameworkModulePkg/Library/DxeCapsuleLib/DxeCapsuleLib.c

   1 /** @file
   2   Capsule Library instance to process capsule images.
   3
   4   Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>
   5
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15 #include <PiDxe.h>
  16
  17 #include <Guid/Capsule.h>
  18 #include <Guid/FmpCapsule.h>
  19
  20 #include <Library/DebugLib.h>
  21 #include <Library/BaseMemoryLib.h>
  22 #include <Library/DxeServicesTableLib.h>
  23 #include <Library/MemoryAllocationLib.h>
  24 #include <Library/CapsuleLib.h>
  25 #include <Library/GenericBdsLib.h>
  26 #include <Library/UefiBootServicesTableLib.h>
  27 #include <Library/BaseLib.h>
  28 #include <Library/DevicePathLib.h>
  29
  30 #include <Protocol/FirmwareManagement.h>
  31 #include <Protocol/DevicePath.h>
  32
  33
  34 /**
  35   Function indicate the current completion progress of the firmware
  36   update. Platform may override with own specific progress function.
  37
  38   @param  Completion    A value between 1 and 100 indicating the current completion progress of the firmware update
  39
  40   @retval EFI_SUCESS    Input capsule is a correct FMP capsule.
  41 **/
  42 EFI_STATUS
  43 EFIAPI
  44 Update_Image_Progress (
  45    IN UINTN Completion
  46 )
  47 {
  48   return EFI_SUCCESS;
  49 }
  50
  51
  52 /**
  53   Validate Fmp capsules layout.
  54
  55   @param  CapsuleHeader    Points to a capsule header.
  56
  57   @retval EFI_SUCESS                     Input capsule is a correct FMP capsule.
  58   @retval EFI_INVALID_PARAMETER  Input capsule is not a correct FMP capsule.
  59 **/
  60 EFI_STATUS
  61 ValidateFmpCapsule (
  62   IN EFI_CAPSULE_HEADER *CapsuleHeader
  63   )
  64 {
  65   EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER       *FmpCapsuleHeader;
  66   UINT8                                        *EndOfCapsule;
  67   EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;
  68   UINT8                                        *EndOfPayload;
  69   UINT64                                       *ItemOffsetList;
  70   UINT32                                       ItemNum;
  71   UINTN                                        Index;
  72
  73   FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);
  74   EndOfCapsule     = (UINT8 *) CapsuleHeader + CapsuleHeader->CapsuleImageSize;
  75
  76   if (FmpCapsuleHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {
  77     return EFI_INVALID_PARAMETER;
  78   }
  79   ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
  80
  81   ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;
  82
  83   if (ItemNum == FmpCapsuleHeader->EmbeddedDriverCount) {
  84     //
  85     // No payload element
  86     //
  87     if (((UINT8 *)FmpCapsuleHeader + ItemOffsetList[ItemNum - 1]) < EndOfCapsule) {
  88       return EFI_SUCCESS;
  89     } else {
  90       return EFI_INVALID_PARAMETER;
  91     }
  92   }
  93
  94   if (FmpCapsuleHeader->PayloadItemCount != 0) {
  95     //
  96     // Check if the last payload is within capsule image range
  97     //
  98     ImageHeader  = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[ItemNum - 1]);
  99     EndOfPayload = (UINT8 *)(ImageHeader + 1) + ImageHeader->UpdateImageSize + ImageHeader->UpdateVendorCodeSize;
 100   } else {
 101     //
 102     // No driver & payload element in FMP
 103     //
 104     EndOfPayload = (UINT8 *)(FmpCapsuleHeader + 1);
 105   }
 106
 107   if (EndOfPayload != EndOfCapsule) {
 108     return EFI_INVALID_PARAMETER;
 109   }
 110
 111   //
 112   // All the address in ItemOffsetList must be stored in ascending order
 113   //
 114   if (ItemNum >= 2) {
 115     for (Index = 0; Index < ItemNum - 1; Index++) {
 116       if (ItemOffsetList[Index] >= ItemOffsetList[Index + 1]) {
 117         return EFI_INVALID_PARAMETER;
 118       }
 119     }
 120   }
 121
 122   return EFI_SUCCESS;
 123 }
 124
 125 /**
 126   Process Firmware management protocol data capsule.
 127
 128   @param  CapsuleHeader         Points to a capsule header.
 129
 130   @retval EFI_SUCESS            Process Capsule Image successfully.
 131   @retval EFI_UNSUPPORTED       Capsule image is not supported by the firmware.
 132   @retval EFI_VOLUME_CORRUPTED  FV volume in the capsule is corrupted.
 133   @retval EFI_OUT_OF_RESOURCES  Not enough memory.
 134 **/
 135 EFI_STATUS
 136 ProcessFmpCapsuleImage (
 137   IN EFI_CAPSULE_HEADER *CapsuleHeader
 138   )
 139 {
 140   EFI_STATUS                                    Status;
 141   EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER        *FmpCapsuleHeader;
 142   EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader;
 143   EFI_HANDLE                                    ImageHandle;
 144   UINT64                                        *ItemOffsetList;
 145   UINT32                                        ItemNum;
 146   UINTN                                         Index;
 147   UINTN                                         ExitDataSize;
 148   EFI_HANDLE                                    *HandleBuffer;
 149   EFI_FIRMWARE_MANAGEMENT_PROTOCOL              *Fmp;
 150   UINTN                                         NumberOfHandles;
 151   UINTN                                         DescriptorSize;
 152   UINT8                                         FmpImageInfoCount;
 153   UINT32                                        FmpImageInfoDescriptorVer;
 154   UINTN                                         ImageInfoSize;
 155   UINT32                                        PackageVersion;
 156   CHAR16                                        *PackageVersionName;
 157   CHAR16                                        *AbortReason;
 158   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *FmpImageInfoBuf;
 159   EFI_FIRMWARE_IMAGE_DESCRIPTOR                 *TempFmpImageInfo;
 160   UINTN                                         DriverLen;
 161   UINTN                                         Index1;
 162   UINTN                                         Index2;
 163   MEMMAP_DEVICE_PATH                            MemMapNode;
 164   EFI_DEVICE_PATH_PROTOCOL                      *DriverDevicePath;
 165
 166   Status           = EFI_SUCCESS;
 167   HandleBuffer     = NULL;
 168   ExitDataSize     = 0;
 169   DriverDevicePath = NULL;
 170
 171   FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);
 172
 173   if (FmpCapsuleHeader->Version > EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER_INIT_VERSION) {
 174     return EFI_INVALID_PARAMETER;
 175   }
 176   ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
 177
 178   ItemNum = FmpCapsuleHeader->EmbeddedDriverCount + FmpCapsuleHeader->PayloadItemCount;
 179
 180   //
 181   // capsule in which driver count and payload count are both zero is not processed.
 182   //
 183   if (ItemNum == 0) {
 184     return EFI_SUCCESS;
 185   }
 186
 187   //
 188   // 1. ConnectAll to ensure
 189   //    All the communication protocol required by driver in capsule installed
 190   //    All FMP protocols are installed
 191   //
 192   BdsLibConnectAll();
 193
 194
 195   //
 196   // 2. Try to load & start all the drivers within capsule
 197   //
 198   SetDevicePathNodeLength (&MemMapNode.Header, sizeof (MemMapNode));
 199   MemMapNode.Header.Type     = HARDWARE_DEVICE_PATH;
 200   MemMapNode.Header.SubType  = HW_MEMMAP_DP;
 201   MemMapNode.MemoryType      = EfiBootServicesCode;
 202   MemMapNode.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CapsuleHeader;
 203   MemMapNode.EndingAddress   = (EFI_PHYSICAL_ADDRESS)(UINTN)((UINT8 *)CapsuleHeader + CapsuleHeader->CapsuleImageSize - 1);
 204
 205   DriverDevicePath = AppendDevicePathNode (NULL, &MemMapNode.Header);
 206   if (DriverDevicePath == NULL) {
 207     return EFI_OUT_OF_RESOURCES;
 208   }
 209
 210   for (Index = 0; Index < FmpCapsuleHeader->EmbeddedDriverCount; Index++) {
 211     if (FmpCapsuleHeader->PayloadItemCount == 0 && Index == (UINTN)FmpCapsuleHeader->EmbeddedDriverCount - 1) {
 212       //
 213       // When driver is last element in the ItemOffsetList array, the driver size is calculated by reference CapsuleImageSize in EFI_CAPSULE_HEADER
 214       //
 215       DriverLen = CapsuleHeader->CapsuleImageSize - CapsuleHeader->HeaderSize - (UINTN)ItemOffsetList[Index];
 216     } else {
 217       DriverLen = (UINTN)ItemOffsetList[Index + 1] - (UINTN)ItemOffsetList[Index];
 218     }
 219
 220     Status = gBS->LoadImage(
 221                     FALSE,
 222                     gImageHandle,
 223                     DriverDevicePath,
 224                     (UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index],
 225                     DriverLen,
 226                     &ImageHandle
 227                     );
 228     if (EFI_ERROR(Status)) {
 229       goto EXIT;
 230     }
 231
 232     Status = gBS->StartImage(
 233                     ImageHandle,
 234                     &ExitDataSize,
 235                     NULL
 236                     );
 237     if (EFI_ERROR(Status)) {
 238       DEBUG ((DEBUG_ERROR, "Driver Return Status = %r\n", Status));
 239       goto EXIT;
 240     }
 241   }
 242
 243   //
 244   // Connnect all again to connect drivers within capsule
 245   //
 246   if (FmpCapsuleHeader->EmbeddedDriverCount > 0) {
 247     BdsLibConnectAll();
 248   }
 249
 250   //
 251   // 3. Route payload to right FMP instance
 252   //
 253   Status = gBS->LocateHandleBuffer (
 254                   ByProtocol,
 255                   &gEfiFirmwareManagementProtocolGuid,
 256                   NULL,
 257                   &NumberOfHandles,
 258                   &HandleBuffer
 259                   );
 260
 261   if (!EFI_ERROR(Status)) {
 262     for(Index1 = 0; Index1 < NumberOfHandles; Index1++) {
 263       Status = gBS->HandleProtocol(
 264                       HandleBuffer[Index1],
 265                       &gEfiFirmwareManagementProtocolGuid,
 266                       (VOID **)&Fmp
 267                       );
 268       if (EFI_ERROR(Status)) {
 269         continue;
 270       }
 271
 272       ImageInfoSize = 0;
 273       Status = Fmp->GetImageInfo (
 274                       Fmp,
 275                       &ImageInfoSize,
 276                       NULL,
 277                       NULL,
 278                       NULL,
 279                       NULL,
 280                       NULL,
 281                       NULL
 282                       );
 283       if (Status != EFI_BUFFER_TOO_SMALL) {
 284         continue;
 285       }
 286
 287       FmpImageInfoBuf = NULL;
 288       FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
 289       if (FmpImageInfoBuf == NULL) {
 290         Status = EFI_OUT_OF_RESOURCES;
 291         goto EXIT;
 292       }
 293
 294       PackageVersionName = NULL;
 295       Status = Fmp->GetImageInfo (
 296                       Fmp,
 297                       &ImageInfoSize,               // ImageInfoSize
 298                       FmpImageInfoBuf,              // ImageInfo
 299                       &FmpImageInfoDescriptorVer,   // DescriptorVersion
 300                       &FmpImageInfoCount,           // DescriptorCount
 301                       &DescriptorSize,              // DescriptorSize
 302                       &PackageVersion,              // PackageVersion
 303                       &PackageVersionName           // PackageVersionName
 304                       );
 305
 306       //
 307       // If FMP GetInformation interface failed, skip this resource
 308       //
 309       if (EFI_ERROR(Status)) {
 310         FreePool(FmpImageInfoBuf);
 311         continue;
 312       }
 313
 314       if (PackageVersionName != NULL) {
 315         FreePool(PackageVersionName);
 316       }
 317
 318       TempFmpImageInfo = FmpImageInfoBuf;
 319       for (Index2 = 0; Index2 < FmpImageInfoCount; Index2++) {
 320         //
 321         // Check all the payload entry in capsule payload list
 322         //
 323         for (Index = FmpCapsuleHeader->EmbeddedDriverCount; Index < ItemNum; Index++) {
 324           ImageHeader  = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *)((UINT8 *)FmpCapsuleHeader + ItemOffsetList[Index]);
 325           if (CompareGuid(&ImageHeader->UpdateImageTypeId, &TempFmpImageInfo->ImageTypeId) &&
 326               ImageHeader->UpdateImageIndex == TempFmpImageInfo->ImageIndex) {
 327             AbortReason = NULL;
 328             if (ImageHeader->UpdateVendorCodeSize == 0) {
 329               Status = Fmp->SetImage(
 330                               Fmp,
 331                               TempFmpImageInfo->ImageIndex,           // ImageIndex
 332                               (UINT8 *)(ImageHeader + 1),             // Image
 333                               ImageHeader->UpdateImageSize,           // ImageSize
 334                               NULL,                                   // VendorCode
 335                               Update_Image_Progress,                  // Progress
 336                               &AbortReason                            // AbortReason
 337                               );
 338             } else {
 339               Status = Fmp->SetImage(
 340                               Fmp,
 341                               TempFmpImageInfo->ImageIndex,                                          // ImageIndex
 342                               (UINT8 *)(ImageHeader + 1),                                            // Image
 343                               ImageHeader->UpdateImageSize,                                          // ImageSize
 344                               (UINT8 *)((UINT8 *) (ImageHeader + 1) + ImageHeader->UpdateImageSize), // VendorCode
 345                               Update_Image_Progress,                                                 // Progress
 346                               &AbortReason                                                           // AbortReason
 347                               );
 348             }
 349             if (AbortReason != NULL) {
 350               DEBUG ((EFI_D_ERROR, "%s\n", AbortReason));
 351               FreePool(AbortReason);
 352             }
 353           }
 354         }
 355         //
 356         // Use DescriptorSize to move ImageInfo Pointer to stay compatible with different ImageInfo version
 357         //
 358         TempFmpImageInfo = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)((UINT8 *)TempFmpImageInfo + DescriptorSize);
 359       }
 360       FreePool(FmpImageInfoBuf);
 361     }
 362   }
 363
 364 EXIT:
 365
 366   if (HandleBuffer != NULL) {
 367     FreePool(HandleBuffer);
 368   }
 369
 370   if (DriverDevicePath != NULL) {
 371     FreePool(DriverDevicePath);
 372   }
 373
 374   return Status;
 375 }
 376
 377 /**
 378   Those capsules supported by the firmwares.
 379
 380   @param  CapsuleHeader    Points to a capsule header.
 381
 382   @retval EFI_SUCESS       Input capsule is supported by firmware.
 383   @retval EFI_UNSUPPORTED  Input capsule is not supported by the firmware.
 384   @retval EFI_INVALID_PARAMETER Input capsule layout is not correct
 385 **/
 386 EFI_STATUS
 387 EFIAPI
 388 SupportCapsuleImage (
 389   IN EFI_CAPSULE_HEADER *CapsuleHeader
 390   )
 391 {
 392   if (CompareGuid (&gEfiCapsuleGuid, &CapsuleHeader->CapsuleGuid)) {
 393     return EFI_SUCCESS;
 394   }
 395
 396   if (CompareGuid (&gEfiFmpCapsuleGuid, &CapsuleHeader->CapsuleGuid)) {
 397     //
 398     // Check layout of FMP capsule
 399     //
 400     return ValidateFmpCapsule(CapsuleHeader);
 401   }
 402
 403   return EFI_UNSUPPORTED;
 404 }
 405
 406 /**
 407   The firmware implements to process the capsule image.
 408
 409   @param  CapsuleHeader         Points to a capsule header.
 410
 411   @retval EFI_SUCESS            Process Capsule Image successfully.
 412   @retval EFI_UNSUPPORTED       Capsule image is not supported by the firmware.
 413   @retval EFI_VOLUME_CORRUPTED  FV volume in the capsule is corrupted.
 414   @retval EFI_OUT_OF_RESOURCES  Not enough memory.
 415 **/
 416 EFI_STATUS
 417 EFIAPI
 418 ProcessCapsuleImage (
 419   IN EFI_CAPSULE_HEADER *CapsuleHeader
 420   )
 421 {
 422   UINT32                       Length;
 423   EFI_FIRMWARE_VOLUME_HEADER   *FvImage;
 424   EFI_FIRMWARE_VOLUME_HEADER   *ProcessedFvImage;
 425   EFI_STATUS                   Status;
 426   EFI_HANDLE                   FvProtocolHandle;
 427   UINT32                       FvAlignment;
 428
 429   FvImage = NULL;
 430   ProcessedFvImage = NULL;
 431   Status  = EFI_SUCCESS;
 432
 433   if (SupportCapsuleImage (CapsuleHeader) != EFI_SUCCESS) {
 434     return EFI_UNSUPPORTED;
 435   }
 436
 437   //
 438   // Check FMP capsule layout
 439   //
 440   if (CompareGuid (&gEfiFmpCapsuleGuid, &CapsuleHeader->CapsuleGuid)){
 441     Status = ValidateFmpCapsule(CapsuleHeader);
 442     if (EFI_ERROR(Status)) {
 443       return Status;
 444     }
 445
 446     //
 447     // Press EFI FMP Capsule
 448     //
 449     return ProcessFmpCapsuleImage(CapsuleHeader);
 450   }
 451
 452   //
 453   // Skip the capsule header, move to the Firware Volume
 454   //
 455   FvImage = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) CapsuleHeader + CapsuleHeader->HeaderSize);
 456   Length  = CapsuleHeader->CapsuleImageSize - CapsuleHeader->HeaderSize;
 457
 458   while (Length != 0) {
 459     //
 460     // Point to the next firmware volume header, and then
 461     // call the DXE service to process it.
 462     //
 463     if (FvImage->FvLength > (UINTN) Length) {
 464       //
 465       // Notes: need to stuff this status somewhere so that the
 466       // error can be detected at OS runtime
 467       //
 468       Status = EFI_VOLUME_CORRUPTED;
 469       break;
 470     }
 471
 472     FvAlignment = 1 << ((FvImage->Attributes & EFI_FVB2_ALIGNMENT) >> 16);
 473     //
 474     // FvAlignment must be more than 8 bytes required by FvHeader structure.
 475     //
 476     if (FvAlignment < 8) {
 477       FvAlignment = 8;
 478     }
 479     //
 480     // Check FvImage Align is required.
 481     //
 482     if (((UINTN) FvImage % FvAlignment) == 0) {
 483       ProcessedFvImage = FvImage;
 484     } else {
 485       //
 486       // Allocate new aligned buffer to store FvImage.
 487       //
 488       ProcessedFvImage = (EFI_FIRMWARE_VOLUME_HEADER *) AllocateAlignedPages ((UINTN) EFI_SIZE_TO_PAGES ((UINTN) FvImage->FvLength), (UINTN) FvAlignment);
 489       if (ProcessedFvImage == NULL) {
 490         Status = EFI_OUT_OF_RESOURCES;
 491         break;
 492       }
 493       CopyMem (ProcessedFvImage, FvImage, (UINTN) FvImage->FvLength);
 494     }
 495
 496     Status = gDS->ProcessFirmwareVolume (
 497                   (VOID *) ProcessedFvImage,
 498                   (UINTN) ProcessedFvImage->FvLength,
 499                   &FvProtocolHandle
 500                   );
 501     if (EFI_ERROR (Status)) {
 502       break;
 503     }
 504     //
 505     // Call the dispatcher to dispatch any drivers from the produced firmware volume
 506     //
 507     gDS->Dispatch ();
 508     //
 509     // On to the next FV in the capsule
 510     //
 511     Length -= (UINT32) FvImage->FvLength;
 512     FvImage = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) FvImage + FvImage->FvLength);
 513   }
 514
 515   return Status;
 516 }
 517
 518 /**
 519
 520   This routine is called to process capsules.
 521
 522   Caution: This function may receive untrusted input.
 523
 524   The capsules reported in EFI_HOB_UEFI_CAPSULE are processed.
 525   If there is no EFI_HOB_UEFI_CAPSULE, this routine does nothing.
 526
 527   This routine should be called twice in BDS.
 528   1) The first call must be before EndOfDxe. The system capsules is processed.
 529      If device capsule FMP protocols are exposted at this time and device FMP
 530      capsule has zero EmbeddedDriverCount, the device capsules are processed.
 531      Each individual capsule result is recorded in capsule record variable.
 532      System may reset in this function, if reset is required by capsule and
 533      all capsules are processed.
 534      If not all capsules are processed, reset will be defered to second call.
 535
 536   2) The second call must be after EndOfDxe and after ConnectAll, so that all
 537      device capsule FMP protocols are exposed.
 538      The system capsules are skipped. If the device capsules are NOT processed
 539      in first call, they are processed here.
 540      Each individual capsule result is recorded in capsule record variable.
 541      System may reset in this function, if reset is required by capsule
 542      processed in first call and second call.
 543
 544   @retval EFI_SUCCESS             There is no error when processing capsules.
 545   @retval EFI_OUT_OF_RESOURCES    No enough resource to process capsules.
 546
 547 **/
 548 EFI_STATUS
 549 EFIAPI
 550 ProcessCapsules (
 551   VOID
 552   )
 553 {
 554   return EFI_UNSUPPORTED;
 555 }
 556