IntelFrameworkModulePkg/Library/DxeCapsuleLib/DxeCapsuleLib.c

   1 /** @file
   2   Capsule Library instance to process capsule images.
   3
   4   Copyright (c) 2007 - 2013, 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