EsrtFmp.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DebugLib.h>
#include <Library/PcdLib.h>
#include <Library/UefiLib.h>
#include <Protocol/FirmwareManagement.h>
#include <Guid/EventGroup.h>
#include <Guid/SystemResourceTable.h>
 
typedef struct {
  EFI_GUID    ImageTypeGuid;
  UINT64      HardwareInstance;
} GUID_HARDWAREINSTANCE_PAIR;
 
VOID
EFIAPI
PrintTable (
  IN EFI_SYSTEM_RESOURCE_TABLE  *Table
  );
 
EFI_STATUS
InstallEfiSystemResourceTableInUefiConfigurationTable (
  IN EFI_SYSTEM_RESOURCE_TABLE  *Table
  )
{
  EFI_STATUS  Status;
 
  Status = EFI_SUCCESS;
  if (Table->FwResourceCount == 0) {
    DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Can't install ESRT table because it has zero Entries. \n"));
    Status = EFI_UNSUPPORTED;
  } else {
    //
    // Install the pointer into config table
    //
    Status = gBS->InstallConfigurationTable (&gEfiSystemResourceTableGuid, Table);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Can't install ESRT table.  Status: %r. \n", Status));
    } else {
      DEBUG ((DEBUG_INFO, "EsrtFmpDxe: Installed ESRT table. \n"));
    }
  }
 
  return Status;
}
 
BOOLEAN
IsSystemFmp (
  IN EFI_FIRMWARE_IMAGE_DESCRIPTOR  *FmpImageInfo
  )
{
  GUID   *Guid;
  UINTN  Count;
  UINTN  Index;
 
  Guid  = PcdGetPtr (PcdSystemFmpCapsuleImageTypeIdGuid);
  Count = PcdGetSize (PcdSystemFmpCapsuleImageTypeIdGuid) / sizeof (GUID);
 
  for (Index = 0; Index < Count; Index++, Guid++) {
    if (CompareGuid (&FmpImageInfo->ImageTypeId, Guid)) {
      return TRUE;
    }
  }
 
  return FALSE;
}
 
EFI_STATUS
CreateEsrtEntry (
  IN OUT EFI_SYSTEM_RESOURCE_TABLE      *Table,
  IN OUT GUID_HARDWAREINSTANCE_PAIR     *HardwareInstances,
  IN OUT UINT32                         *NumberOfDescriptors,
  IN     EFI_FIRMWARE_IMAGE_DESCRIPTOR  *FmpImageInfoBuf,
  IN     UINT32                         FmpVersion
  )
{
  UINTN                      Index;
  EFI_SYSTEM_RESOURCE_ENTRY  *Entry;
  UINT64                     FmpHardwareInstance;
 
  FmpHardwareInstance = 0;
  if (FmpVersion >= 3) {
    FmpHardwareInstance = FmpImageInfoBuf->HardwareInstance;
  }
 
  //
  // Check to see of FmpImageInfoBuf GUID/HardwareInstance is unique
  // Skip if HardwareInstance is 0 as this is the case if FmpVersion < 3
  // or the device can not create a unique ID per UEFI specification
  //
  if (FmpHardwareInstance != 0) {
    for (Index = 0; Index < *NumberOfDescriptors; Index++) {
      if (CompareGuid (&HardwareInstances[Index].ImageTypeGuid, &FmpImageInfoBuf->ImageTypeId)) {
        if (HardwareInstances[Index].HardwareInstance == FmpHardwareInstance) {
          DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Duplicate firmware image descriptor with GUID %g HardwareInstance:0x%x\n", &FmpImageInfoBuf->ImageTypeId, FmpHardwareInstance));
          ASSERT (
            !CompareGuid (&HardwareInstances[Index].ImageTypeGuid, &FmpImageInfoBuf->ImageTypeId) ||
            HardwareInstances[Index].HardwareInstance != FmpHardwareInstance
            );
          return EFI_UNSUPPORTED;
        }
      }
    }
  }
 
  //
  // Record new GUID/HardwareInstance pair
  //
  CopyGuid (&HardwareInstances[*NumberOfDescriptors].ImageTypeGuid, &FmpImageInfoBuf->ImageTypeId);
  HardwareInstances[*NumberOfDescriptors].HardwareInstance = FmpHardwareInstance;
  *NumberOfDescriptors                                     = *NumberOfDescriptors + 1;
 
  DEBUG ((DEBUG_INFO, "EsrtFmpDxe: Add new image descriptor with GUID %g HardwareInstance:0x%x\n", &FmpImageInfoBuf->ImageTypeId, FmpHardwareInstance));
 
  //
  // Check to see if GUID is already in the ESRT table
  //
  Entry = (EFI_SYSTEM_RESOURCE_ENTRY *)(Table + 1);
  for (Index = 0; Index < Table->FwResourceCount; Index++, Entry++) {
    if (!CompareGuid (&Entry->FwClass, &FmpImageInfoBuf->ImageTypeId)) {
      continue;
    }
 
    DEBUG ((DEBUG_INFO, "EsrtFmpDxe: ESRT Entry already exists for FMP Instance with GUID %g\n", &Entry->FwClass));
 
    //
    // Set ESRT FwVersion to the smaller of the two values
    //
    Entry->FwVersion = MIN (FmpImageInfoBuf->Version, Entry->FwVersion);
 
    //
    // VERSION 2 has Lowest Supported
    //
    if (FmpVersion >= 2) {
      //
      // Set ESRT LowestSupportedFwVersion to the smaller of the two values
      //
      Entry->LowestSupportedFwVersion =
        MIN (
          FmpImageInfoBuf->LowestSupportedImageVersion,
          Entry->LowestSupportedFwVersion
          );
    }
 
    //
    // VERSION 3 supports last attempt values
    //
    if (FmpVersion >= 3) {
      //
      // Update the ESRT entry with the last attempt status and last attempt
      // version from the first FMP instance whose last attempt status is not
      // SUCCESS.  If all FMP instances are SUCCESS, then set version to the
      // smallest value from all FMP instances.
      //
      if (Entry->LastAttemptStatus == LAST_ATTEMPT_STATUS_SUCCESS) {
        if (FmpImageInfoBuf->LastAttemptStatus != LAST_ATTEMPT_STATUS_SUCCESS) {
          Entry->LastAttemptStatus  = FmpImageInfoBuf->LastAttemptStatus;
          Entry->LastAttemptVersion = FmpImageInfoBuf->LastAttemptVersion;
        } else {
          Entry->LastAttemptVersion =
            MIN (
              FmpImageInfoBuf->LastAttemptVersion,
              Entry->LastAttemptVersion
              );
        }
      }
    }
 
    return EFI_SUCCESS;
  }
 
  //
  // Add a new ESRT Table Entry
  //
  Entry = (EFI_SYSTEM_RESOURCE_ENTRY *)(Table + 1) + Table->FwResourceCount;
 
  CopyGuid (&Entry->FwClass, &FmpImageInfoBuf->ImageTypeId);
 
  if (IsSystemFmp (FmpImageInfoBuf)) {
    DEBUG ((DEBUG_INFO, "EsrtFmpDxe: Found an ESRT entry for a System Device.\n"));
    Entry->FwType = (UINT32)(ESRT_FW_TYPE_SYSTEMFIRMWARE);
  } else {
    Entry->FwType = (UINT32)(ESRT_FW_TYPE_DEVICEFIRMWARE);
  }
 
  Entry->FwVersion                = FmpImageInfoBuf->Version;
  Entry->LowestSupportedFwVersion = 0;
  Entry->CapsuleFlags             = 0;
  Entry->LastAttemptVersion       = 0;
  Entry->LastAttemptStatus        = 0;
 
  //
  // VERSION 2 has Lowest Supported
  //
  if (FmpVersion >= 2) {
    Entry->LowestSupportedFwVersion = FmpImageInfoBuf->LowestSupportedImageVersion;
  }
 
  //
  // VERSION 3 supports last attempt values
  //
  if (FmpVersion >= 3) {
    Entry->LastAttemptVersion = FmpImageInfoBuf->LastAttemptVersion;
    Entry->LastAttemptStatus  = FmpImageInfoBuf->LastAttemptStatus;
  }
 
  //
  // Increment the number of active ESRT Table Entries
  //
  Table->FwResourceCount++;
 
  return EFI_SUCCESS;
}
 
EFI_FIRMWARE_IMAGE_DESCRIPTOR *
FmpGetFirmwareImageDescriptor (
  IN  EFI_FIRMWARE_MANAGEMENT_PROTOCOL  *Fmp,
  OUT UINT32                            *FmpImageInfoDescriptorVer,
  OUT UINT8                             *FmpImageInfoCount,
  OUT UINTN                             *DescriptorSize
  )
{
  EFI_STATUS                     Status;
  UINTN                          ImageInfoSize;
  UINT32                         PackageVersion;
  CHAR16                         *PackageVersionName;
  EFI_FIRMWARE_IMAGE_DESCRIPTOR  *FmpImageInfoBuf;
 
  ImageInfoSize = 0;
  Status        = Fmp->GetImageInfo (
                         Fmp,                       // FMP Pointer
                         &ImageInfoSize,            // Buffer Size (in this case 0)
                         NULL,                      // NULL so we can get size
                         FmpImageInfoDescriptorVer, // DescriptorVersion
                         FmpImageInfoCount,         // DescriptorCount
                         DescriptorSize,            // DescriptorSize
                         &PackageVersion,           // PackageVersion
                         &PackageVersionName        // PackageVersionName
                         );
  if (Status != EFI_BUFFER_TOO_SMALL) {
    DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Unexpected Failure in GetImageInfo.  Status = %r\n", Status));
    return NULL;
  }
 
  FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
  if (FmpImageInfoBuf == NULL) {
    DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Failed to get memory for FMP descriptor.\n"));
    return NULL;
  }
 
  PackageVersionName = NULL;
  Status             = Fmp->GetImageInfo (
                              Fmp,                       // FMP Pointer
                              &ImageInfoSize,            // ImageInfoSize
                              FmpImageInfoBuf,           // ImageInfo
                              FmpImageInfoDescriptorVer, // DescriptorVersion
                              FmpImageInfoCount,         // DescriptorCount
                              DescriptorSize,            // DescriptorSize
                              &PackageVersion,           // PackageVersion
                              &PackageVersionName        // PackageVersionName
                              );
  if (PackageVersionName != NULL) {
    FreePool (PackageVersionName);
  }
 
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Failure in GetImageInfo.  Status = %r\n", Status));
    FreePool (FmpImageInfoBuf);
    return NULL;
  }
 
  return FmpImageInfoBuf;
}
 
EFI_SYSTEM_RESOURCE_TABLE *
CreateFmpBasedEsrt (
  VOID
  )
{
  EFI_STATUS                     Status;
  UINTN                          NoProtocols;
  VOID                           **Buffer;
  UINTN                          Index;
  UINT32                         FmpImageInfoDescriptorVer;
  UINT8                          FmpImageInfoCount;
  UINTN                          DescriptorSize;
  UINT32                         NumberOfDescriptors;
  EFI_FIRMWARE_IMAGE_DESCRIPTOR  *FmpImageInfoBuf;
  EFI_FIRMWARE_IMAGE_DESCRIPTOR  *OrgFmpImageInfoBuf;
  EFI_SYSTEM_RESOURCE_TABLE      *Table;
  GUID_HARDWAREINSTANCE_PAIR     *HardwareInstances;
 
  Status             = EFI_SUCCESS;
  NoProtocols        = 0;
  Buffer             = NULL;
  FmpImageInfoBuf    = NULL;
  OrgFmpImageInfoBuf = NULL;
  Table              = NULL;
  HardwareInstances  = NULL;
 
  Status = EfiLocateProtocolBuffer (
             &gEfiFirmwareManagementProtocolGuid,
             &NoProtocols,
             &Buffer
             );
  if (EFI_ERROR (Status) || (Buffer == NULL)) {
    return NULL;
  }
 
  //
  // Count the total number of EFI_FIRMWARE_IMAGE_DESCRIPTORs
  //
  for (Index = 0, NumberOfDescriptors = 0; Index < NoProtocols; Index++) {
    FmpImageInfoBuf = FmpGetFirmwareImageDescriptor (
                        (EFI_FIRMWARE_MANAGEMENT_PROTOCOL *)Buffer[Index],
                        &FmpImageInfoDescriptorVer,
                        &FmpImageInfoCount,
                        &DescriptorSize
                        );
    if (FmpImageInfoBuf != NULL) {
      NumberOfDescriptors += FmpImageInfoCount;
      FreePool (FmpImageInfoBuf);
    }
  }
 
  //
  // Allocate ESRT Table and GUID/HardwareInstance table
  //
  Table = AllocateZeroPool (
            (NumberOfDescriptors * sizeof (EFI_SYSTEM_RESOURCE_ENTRY)) + sizeof (EFI_SYSTEM_RESOURCE_TABLE)
            );
  if (Table == NULL) {
    DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Failed to allocate memory for ESRT.\n"));
    FreePool (Buffer);
    return NULL;
  }
 
  HardwareInstances = AllocateZeroPool (NumberOfDescriptors * sizeof (GUID_HARDWAREINSTANCE_PAIR));
  if (HardwareInstances == NULL) {
    DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Failed to allocate memory for HW Instance Table.\n"));
    FreePool (Table);
    FreePool (Buffer);
    return NULL;
  }
 
  //
  // Initialize ESRT Table
  //
  Table->FwResourceCount    = 0;
  Table->FwResourceCountMax = NumberOfDescriptors;
  Table->FwResourceVersion  = EFI_SYSTEM_RESOURCE_TABLE_FIRMWARE_RESOURCE_VERSION;
 
  NumberOfDescriptors = 0;
  for (Index = 0; Index < NoProtocols; Index++) {
    FmpImageInfoBuf = FmpGetFirmwareImageDescriptor (
                        (EFI_FIRMWARE_MANAGEMENT_PROTOCOL *)Buffer[Index],
                        &FmpImageInfoDescriptorVer,
                        &FmpImageInfoCount,
                        &DescriptorSize
                        );
    if (FmpImageInfoBuf == NULL) {
      continue;
    }
 
    //
    // Check each descriptor and read from the one specified
    //
    OrgFmpImageInfoBuf = FmpImageInfoBuf;
    while (FmpImageInfoCount > 0) {
      //
      // If the descriptor has the IN USE bit set, create ESRT entry otherwise ignore.
      //
      if ((FmpImageInfoBuf->AttributesSetting & FmpImageInfoBuf->AttributesSupported & IMAGE_ATTRIBUTE_IN_USE) == IMAGE_ATTRIBUTE_IN_USE) {
        //
        // Create ESRT entry
        //
        CreateEsrtEntry (Table, HardwareInstances, &NumberOfDescriptors, FmpImageInfoBuf, FmpImageInfoDescriptorVer);
      }
 
      FmpImageInfoCount--;
      //
      // Increment the buffer pointer ahead by the size of the descriptor
      //
      FmpImageInfoBuf = (EFI_FIRMWARE_IMAGE_DESCRIPTOR *)(((UINT8 *)FmpImageInfoBuf) + DescriptorSize);
    }
 
    FreePool (OrgFmpImageInfoBuf);
    OrgFmpImageInfoBuf = NULL;
  }
 
  FreePool (Buffer);
  FreePool (HardwareInstances);
  return Table;
}
 
VOID
EFIAPI
EsrtReadyToBootEventNotify (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  EFI_STATUS                 Status;
  EFI_SYSTEM_RESOURCE_TABLE  *Table;
 
  Table = CreateFmpBasedEsrt ();
  if (Table != NULL) {
    //
    // Print table on debug builds
    //
    DEBUG_CODE_BEGIN ();
    PrintTable (Table);
    DEBUG_CODE_END ();
 
    Status = InstallEfiSystemResourceTableInUefiConfigurationTable (Table);
    if (EFI_ERROR (Status)) {
      FreePool (Table);
    }
  } else {
    DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Can't install ESRT table because it is NULL. \n"));
  }
 
  //
  // Close the event to prevent it be signalled again.
  //
  gBS->CloseEvent (Event);
}
 
EFI_STATUS
EFIAPI
EsrtFmpEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
  EFI_EVENT   EsrtReadyToBootEvent;
 
  //
  // Register notify function to install ESRT on ReadyToBoot Event.
  //
  Status = EfiCreateEventReadyToBootEx (
             TPL_CALLBACK,
             EsrtReadyToBootEventNotify,
             NULL,
             &EsrtReadyToBootEvent
             );
 
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "EsrtFmpDxe: Failed to register for ready to boot\n"));
  }
 
  return Status;
}