MdeModulePkg/Library/DxeCapsuleLibFmp/DxeCapsuleReportLib.c

   1 /** @file
   2   DXE capsule report related function.
   3
   4   Copyright (c) 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 <PiDxe.h>
  16 #include <Protocol/FirmwareManagement.h>
  17 #include <Protocol/VariableLock.h>
  18 #include <Guid/CapsuleReport.h>
  19 #include <Guid/FmpCapsule.h>
  20 #include <Guid/CapsuleVendor.h>
  21
  22 #include <Library/BaseLib.h>
  23 #include <Library/DebugLib.h>
  24 #include <Library/BaseMemoryLib.h>
  25 #include <Library/UefiBootServicesTableLib.h>
  26 #include <Library/UefiRuntimeServicesTableLib.h>
  27 #include <Library/MemoryAllocationLib.h>
  28 #include <Library/UefiLib.h>
  29 #include <Library/PcdLib.h>
  30 #include <Library/HobLib.h>
  31 #include <Library/PrintLib.h>
  32 #include <Library/ReportStatusCodeLib.h>
  33 #include <Library/CapsuleLib.h>
  34
  35 #include <IndustryStandard/WindowsUxCapsule.h>
  36
  37 typedef struct {
  38   EFI_CAPSULE_RESULT_VARIABLE_HEADER  CapsuleResultHeader;
  39   EFI_CAPSULE_RESULT_VARIABLE_FMP     CapsuleResultFmp;
  40 } CAPSULE_RESULT_VARIABLE_CACHE;
  41
  42 #define CAPSULE_RESULT_VARIABLE_CACHE_COUNT   0x10
  43
  44 CAPSULE_RESULT_VARIABLE_CACHE *mCapsuleResultVariableCache;
  45 UINTN                         mCapsuleResultVariableCacheMaxCount;
  46 UINTN                         mCapsuleResultVariableCacheCount;
  47
  48 /**
  49   Get current capsule last variable index.
  50
  51   @return Current capsule last variable index.
  52   @retval -1  No current capsule last variable.
  53 **/
  54 INTN
  55 GetCurrentCapsuleLastIndex (
  56   VOID
  57   )
  58 {
  59   UINTN                            Size;
  60   CHAR16                           CapsuleLastStr[sizeof("Capsule####")];
  61   EFI_STATUS                       Status;
  62   UINT16                           CurrentIndex;
  63
  64   Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator
  65   Status = gRT->GetVariable(
  66                   L"CapsuleLast",
  67                   &gEfiCapsuleReportGuid,
  68                   NULL,
  69                   &Size,
  70                   CapsuleLastStr
  71                   );
  72   if (EFI_ERROR(Status)) {
  73     return -1;
  74   }
  75   CurrentIndex = (UINT16)StrHexToUintn(&CapsuleLastStr[sizeof("Capsule") - 1]);
  76   return CurrentIndex;
  77 }
  78
  79 /**
  80   Check if this FMP capsule is processed.
  81
  82   @param[in] CapsuleHeader  The capsule image header
  83   @param[in] PayloadIndex   FMP payload index
  84   @param[in] ImageHeader    FMP image header
  85
  86   @retval TRUE  This FMP capsule is processed.
  87   @retval FALSE This FMP capsule is not processed.
  88 **/
  89 BOOLEAN
  90 IsFmpCapsuleProcessed (
  91   IN EFI_CAPSULE_HEADER                            *CapsuleHeader,
  92   IN UINTN                                         PayloadIndex,
  93   IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader
  94   )
  95 {
  96   UINTN                               Index;
  97   EFI_CAPSULE_RESULT_VARIABLE_HEADER  *CapsuleResult;
  98   EFI_CAPSULE_RESULT_VARIABLE_FMP     *CapsuleResultFmp;
  99
 100   for (Index = 0; Index < mCapsuleResultVariableCacheCount; Index++) {
 101     //
 102     // Check
 103     //
 104     CapsuleResult = &mCapsuleResultVariableCache[Index].CapsuleResultHeader;
 105     if (CapsuleResult->VariableTotalSize >= sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER)) {
 106       if (CompareGuid(&CapsuleResult->CapsuleGuid, &gEfiFmpCapsuleGuid)) {
 107         if (CapsuleResult->VariableTotalSize >= sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP)) {
 108           CapsuleResultFmp = (EFI_CAPSULE_RESULT_VARIABLE_FMP *)(CapsuleResult + 1);
 109           if (CompareGuid(&CapsuleResultFmp->UpdateImageTypeId, &ImageHeader->UpdateImageTypeId) &&
 110               (CapsuleResultFmp->UpdateImageIndex == ImageHeader->UpdateImageIndex) &&
 111               (CapsuleResultFmp->PayloadIndex == PayloadIndex) ) {
 112             return TRUE;
 113           }
 114         }
 115       }
 116     }
 117   }
 118
 119   return FALSE;
 120 }
 121
 122 /**
 123   Write a new capsule status variable cache.
 124
 125   @param[in] CapsuleResult      The capsule status variable
 126   @param[in] CapsuleResultSize  The size of the capsule stauts variable in bytes
 127
 128   @retval EFI_SUCCESS          The capsule status variable is cached.
 129   @retval EFI_OUT_OF_RESOURCES No resource to cache the capsule status variable.
 130 **/
 131 EFI_STATUS
 132 WriteNewCapsuleResultVariableCache (
 133   IN VOID    *CapsuleResult,
 134   IN UINTN   CapsuleResultSize
 135   )
 136 {
 137   if (CapsuleResultSize > sizeof(CAPSULE_RESULT_VARIABLE_CACHE)) {
 138     CapsuleResultSize = sizeof(CAPSULE_RESULT_VARIABLE_CACHE);
 139   }
 140
 141   if (mCapsuleResultVariableCacheCount == mCapsuleResultVariableCacheMaxCount) {
 142     mCapsuleResultVariableCache = ReallocatePool(
 143                                     mCapsuleResultVariableCacheMaxCount * sizeof(CAPSULE_RESULT_VARIABLE_CACHE),
 144                                     (mCapsuleResultVariableCacheMaxCount + CAPSULE_RESULT_VARIABLE_CACHE_COUNT) * sizeof(CAPSULE_RESULT_VARIABLE_CACHE),
 145                                     mCapsuleResultVariableCache
 146                                     );
 147     if (mCapsuleResultVariableCache == NULL) {
 148       return EFI_OUT_OF_RESOURCES;
 149     }
 150     mCapsuleResultVariableCacheMaxCount += CAPSULE_RESULT_VARIABLE_CACHE_COUNT;
 151   }
 152
 153   ASSERT(mCapsuleResultVariableCacheCount < mCapsuleResultVariableCacheMaxCount);
 154   ASSERT(mCapsuleResultVariableCache != NULL);
 155   CopyMem(
 156     &mCapsuleResultVariableCache[mCapsuleResultVariableCacheCount],
 157     CapsuleResult,
 158     CapsuleResultSize
 159     );
 160   mCapsuleResultVariableCacheCount++;
 161
 162   return EFI_SUCCESS;
 163 }
 164
 165 /**
 166   Get a new capsule status variable index.
 167
 168   @return A new capsule status variable index.
 169   @retval -1  No new capsule status variable index.
 170 **/
 171 INTN
 172 GetNewCapsuleResultIndex (
 173   VOID
 174   )
 175 {
 176   INTN                             CurrentIndex;
 177
 178   CurrentIndex = GetCurrentCapsuleLastIndex();
 179   if (CurrentIndex >= PcdGet16(PcdCapsuleMax)) {
 180     return -1;
 181   }
 182
 183   return CurrentIndex + 1;
 184 }
 185
 186 /**
 187   Write a new capsule status variable.
 188
 189   @param[in] CapsuleResult      The capsule status variable
 190   @param[in] CapsuleResultSize  The size of the capsule stauts variable in bytes
 191
 192   @retval EFI_SUCCESS          The capsule status variable is recorded.
 193   @retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.
 194 **/
 195 EFI_STATUS
 196 WriteNewCapsuleResultVariable (
 197   IN VOID    *CapsuleResult,
 198   IN UINTN   CapsuleResultSize
 199   )
 200 {
 201   INTN                                CapsuleResultIndex;
 202   CHAR16                              CapsuleResultStr[sizeof("Capsule####")];
 203   UINTN                               Size;
 204   EFI_STATUS                          Status;
 205
 206   CapsuleResultIndex = GetNewCapsuleResultIndex();
 207   DEBUG((DEBUG_INFO, "New CapsuleResultIndex - 0x%x\n", CapsuleResultIndex));
 208   if (CapsuleResultIndex == -1) {
 209     return EFI_OUT_OF_RESOURCES;
 210   }
 211   UnicodeSPrint(
 212     CapsuleResultStr,
 213     sizeof(CapsuleResultStr),
 214     L"Capsule%04x",
 215     CapsuleResultIndex
 216     );
 217
 218   Status = gRT->SetVariable(
 219                   CapsuleResultStr,
 220                   &gEfiCapsuleReportGuid,
 221                   EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 222                   CapsuleResultSize,
 223                   CapsuleResult
 224                   );
 225   if (!EFI_ERROR(Status)) {
 226     Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator
 227     DEBUG((DEBUG_INFO, "Set CapsuleLast - %s\n", CapsuleResultStr));
 228     Status = gRT->SetVariable(
 229                     L"CapsuleLast",
 230                     &gEfiCapsuleReportGuid,
 231                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 232                     Size,
 233                     CapsuleResultStr
 234                     );
 235   }
 236
 237   return Status;
 238 }
 239
 240 /**
 241   Record capsule status variable and to local cache.
 242
 243   @param[in] CapsuleHeader  The capsule image header
 244   @param[in] CapsuleStatus  The capsule process stauts
 245
 246   @retval EFI_SUCCESS          The capsule status variable is recorded.
 247   @retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.
 248 **/
 249 EFI_STATUS
 250 RecordCapsuleStatusVariable (
 251   IN EFI_CAPSULE_HEADER                           *CapsuleHeader,
 252   IN EFI_STATUS                                   CapsuleStatus
 253   )
 254 {
 255   EFI_CAPSULE_RESULT_VARIABLE_HEADER  CapsuleResultVariable;
 256   EFI_STATUS                          Status;
 257
 258   CapsuleResultVariable.VariableTotalSize = sizeof(CapsuleResultVariable);
 259   CopyGuid (&CapsuleResultVariable.CapsuleGuid, &CapsuleHeader->CapsuleGuid);
 260   ZeroMem(&CapsuleResultVariable.CapsuleProcessed, sizeof(CapsuleResultVariable.CapsuleProcessed));
 261   gRT->GetTime(&CapsuleResultVariable.CapsuleProcessed, NULL);
 262   CapsuleResultVariable.CapsuleStatus = CapsuleStatus;
 263
 264   //
 265   // Save Local Cache
 266   //
 267   Status = WriteNewCapsuleResultVariableCache(&CapsuleResultVariable, sizeof(CapsuleResultVariable));
 268
 269   if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {
 270     Status = WriteNewCapsuleResultVariable(&CapsuleResultVariable, sizeof(CapsuleResultVariable));
 271   }
 272   return Status;
 273 }
 274
 275 /**
 276   Record FMP capsule status variable and to local cache.
 277
 278   @param[in] CapsuleHeader  The capsule image header
 279   @param[in] CapsuleStatus  The capsule process stauts
 280   @param[in] PayloadIndex   FMP payload index
 281   @param[in] ImageHeader    FMP image header
 282
 283   @retval EFI_SUCCESS          The capsule status variable is recorded.
 284   @retval EFI_OUT_OF_RESOURCES No resource to record the capsule status variable.
 285 **/
 286 EFI_STATUS
 287 RecordFmpCapsuleStatusVariable (
 288   IN EFI_CAPSULE_HEADER                            *CapsuleHeader,
 289   IN EFI_STATUS                                    CapsuleStatus,
 290   IN UINTN                                         PayloadIndex,
 291   IN EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER  *ImageHeader
 292   )
 293 {
 294   EFI_CAPSULE_RESULT_VARIABLE_HEADER  *CapsuleResultVariableHeader;
 295   EFI_CAPSULE_RESULT_VARIABLE_FMP     *CapsuleResultVariableFmp;
 296   EFI_STATUS                          Status;
 297   UINT8                               *CapsuleResultVariable;
 298   UINT32                              CapsuleResultVariableSize;
 299
 300   CapsuleResultVariable     = NULL;
 301   CapsuleResultVariableSize = sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER) + sizeof(EFI_CAPSULE_RESULT_VARIABLE_FMP);
 302   CapsuleResultVariable     = AllocatePool (CapsuleResultVariableSize);
 303   if (CapsuleResultVariable == NULL) {
 304     return EFI_OUT_OF_RESOURCES;
 305   }
 306   CapsuleResultVariableHeader = (VOID *)CapsuleResultVariable;
 307   CapsuleResultVariableHeader->VariableTotalSize = CapsuleResultVariableSize;
 308   CopyGuid(&CapsuleResultVariableHeader->CapsuleGuid, &CapsuleHeader->CapsuleGuid);
 309   ZeroMem(&CapsuleResultVariableHeader->CapsuleProcessed, sizeof(CapsuleResultVariableHeader->CapsuleProcessed));
 310   gRT->GetTime(&CapsuleResultVariableHeader->CapsuleProcessed, NULL);
 311   CapsuleResultVariableHeader->CapsuleStatus = CapsuleStatus;
 312
 313   CapsuleResultVariableFmp = (VOID *)(CapsuleResultVariable + sizeof(EFI_CAPSULE_RESULT_VARIABLE_HEADER));
 314   CapsuleResultVariableFmp->Version = 0x1;
 315   CapsuleResultVariableFmp->PayloadIndex = (UINT8)PayloadIndex;
 316   CapsuleResultVariableFmp->UpdateImageIndex = ImageHeader->UpdateImageIndex;
 317   CopyGuid (&CapsuleResultVariableFmp->UpdateImageTypeId, &ImageHeader->UpdateImageTypeId);
 318
 319   //
 320   // Save Local Cache
 321   //
 322   Status = WriteNewCapsuleResultVariableCache(CapsuleResultVariable, CapsuleResultVariableSize);
 323
 324   if ((CapsuleHeader->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {
 325     Status = WriteNewCapsuleResultVariable(CapsuleResultVariable, CapsuleResultVariableSize);
 326   }
 327   FreePool (CapsuleResultVariable);
 328   return Status;
 329 }
 330
 331 /**
 332   Initialize CapsuleMax variables.
 333 **/
 334 VOID
 335 InitCapsuleMaxVariable (
 336   VOID
 337   )
 338 {
 339   EFI_STATUS                       Status;
 340   UINTN                            Size;
 341   CHAR16                           CapsuleMaxStr[sizeof("Capsule####")];
 342   EDKII_VARIABLE_LOCK_PROTOCOL     *VariableLock;
 343
 344   UnicodeSPrint(
 345     CapsuleMaxStr,
 346     sizeof(CapsuleMaxStr),
 347     L"Capsule%04x",
 348     PcdGet16(PcdCapsuleMax)
 349     );
 350
 351   Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator
 352   Status = gRT->SetVariable(
 353                   L"CapsuleMax",
 354                   &gEfiCapsuleReportGuid,
 355                   EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 356                   Size,
 357                   CapsuleMaxStr
 358                   );
 359   if (!EFI_ERROR(Status)) {
 360     // Lock it per UEFI spec.
 361     Status = gBS->LocateProtocol(&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLock);
 362     if (!EFI_ERROR(Status)) {
 363       Status = VariableLock->RequestToLock(VariableLock, L"CapsuleMax", &gEfiCapsuleReportGuid);
 364       ASSERT_EFI_ERROR(Status);
 365     }
 366   }
 367 }
 368
 369 /**
 370   Initialize CapsuleLast variables.
 371 **/
 372 VOID
 373 InitCapsuleLastVariable (
 374   VOID
 375   )
 376 {
 377   EFI_STATUS                       Status;
 378   EFI_BOOT_MODE                    BootMode;
 379   EDKII_VARIABLE_LOCK_PROTOCOL     *VariableLock;
 380   VOID                             *CapsuleResult;
 381   UINTN                            Size;
 382   CHAR16                           CapsuleLastStr[sizeof("Capsule####")];
 383
 384   BootMode = GetBootModeHob();
 385   if (BootMode == BOOT_ON_FLASH_UPDATE) {
 386     Status = gRT->SetVariable(
 387                     L"CapsuleLast",
 388                     &gEfiCapsuleReportGuid,
 389                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 390                     0,
 391                     NULL
 392                     );
 393     // Do not lock it because it will be updated later.
 394   } else {
 395     //
 396     // Check if OS/APP cleared L"Capsule####"
 397     //
 398     ZeroMem(CapsuleLastStr, sizeof(CapsuleLastStr));
 399     Size = sizeof(L"Capsule####") - sizeof(CHAR16); // no zero terminator
 400     Status = gRT->GetVariable(
 401                     L"CapsuleLast",
 402                     &gEfiCapsuleReportGuid,
 403                     NULL,
 404                     &Size,
 405                     CapsuleLastStr
 406                     );
 407     if (!EFI_ERROR(Status)) {
 408       //
 409       // L"CapsuleLast" is got, check if data is there.
 410       //
 411       Status = GetVariable2 (
 412                  CapsuleLastStr,
 413                  &gEfiCapsuleReportGuid,
 414                  (VOID **) &CapsuleResult,
 415                  NULL
 416                  );
 417       if (EFI_ERROR(Status)) {
 418         //
 419         // If no data, delete L"CapsuleLast"
 420         //
 421         Status = gRT->SetVariable(
 422                         L"CapsuleLast",
 423                         &gEfiCapsuleReportGuid,
 424                         EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 425                         0,
 426                         NULL
 427                         );
 428       }
 429     }
 430
 431     // Lock it in normal boot path per UEFI spec.
 432     Status = gBS->LocateProtocol(&gEdkiiVariableLockProtocolGuid, NULL, (VOID **)&VariableLock);
 433     if (!EFI_ERROR(Status)) {
 434       Status = VariableLock->RequestToLock(VariableLock, L"CapsuleLast", &gEfiCapsuleReportGuid);
 435       ASSERT_EFI_ERROR(Status);
 436     }
 437   }
 438 }
 439
 440 /**
 441   Initialize capsule update variables.
 442 **/
 443 VOID
 444 InitCapsuleUpdateVariable (
 445   VOID
 446   )
 447 {
 448   EFI_STATUS                     Status;
 449   UINTN                          Index;
 450   CHAR16                         CapsuleVarName[30];
 451   CHAR16                         *TempVarName;
 452
 453   //
 454   // Clear all the capsule variables CapsuleUpdateData, CapsuleUpdateData1, CapsuleUpdateData2...
 455   // as early as possible which will avoid the next time boot after the capsule update
 456   // will still into the capsule loop
 457   //
 458   StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CapsuleVarName[0]), EFI_CAPSULE_VARIABLE_NAME);
 459   TempVarName = CapsuleVarName + StrLen (CapsuleVarName);
 460   Index = 0;
 461   while (TRUE) {
 462     if (Index > 0) {
 463       UnicodeValueToString (TempVarName, 0, Index, 0);
 464     }
 465     Status = gRT->SetVariable (
 466                     CapsuleVarName,
 467                     &gEfiCapsuleVendorGuid,
 468                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
 469                     0,
 470                     (VOID *)NULL
 471                     );
 472     if (EFI_ERROR (Status)) {
 473       //
 474       // There is no capsule variables, quit
 475       //
 476       break;
 477     }
 478     Index++;
 479   }
 480 }
 481
 482 /**
 483   Initialize capsule related variables.
 484 **/
 485 VOID
 486 InitCapsuleVariable (
 487   VOID
 488   )
 489 {
 490   InitCapsuleUpdateVariable();
 491   InitCapsuleMaxVariable();
 492   InitCapsuleLastVariable();
 493   //
 494   // No need to clear L"Capsule####", because OS/APP should refer L"CapsuleLast"
 495   // to check status and delete them.
 496   //
 497 }