Defer3rdPartyImageLoad.c

Go to the documentation of this file.

 
#include "Defer3rdPartyImageLoad.h"
 
//
// The structure to save the deferred 3rd party image information.
//
typedef struct {
  EFI_DEVICE_PATH_PROTOCOL    *ImageDevicePath;
  BOOLEAN                     BootOption;
  BOOLEAN                     Loaded;
} DEFERRED_3RD_PARTY_IMAGE_INFO;
 
//
// The table to save the deferred 3rd party image item.
//
typedef struct {
  UINTN                            Count;          
  DEFERRED_3RD_PARTY_IMAGE_INFO    *ImageInfo;     
} DEFERRED_3RD_PARTY_IMAGE_TABLE;
 
BOOLEAN                         mImageLoadedAfterEndOfDxe = FALSE;
BOOLEAN                         mEndOfDxe                 = FALSE;
DEFERRED_3RD_PARTY_IMAGE_TABLE  mDeferred3rdPartyImage    = {
  0,       // Deferred image count
  NULL     // The deferred image info
};
 
EFI_DEFERRED_IMAGE_LOAD_PROTOCOL  mDeferredImageLoad = {
  GetDefferedImageInfo
};
 
BOOLEAN
FileFromFv (
  IN  CONST EFI_DEVICE_PATH_PROTOCOL  *File
  )
{
  EFI_STATUS                Status;
  EFI_HANDLE                DeviceHandle;
  EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;
 
  //
  // First check to see if File is from a Firmware Volume
  //
  DeviceHandle   = NULL;
  TempDevicePath = (EFI_DEVICE_PATH_PROTOCOL *)File;
  Status         = gBS->LocateDevicePath (
                          &gEfiFirmwareVolume2ProtocolGuid,
                          &TempDevicePath,
                          &DeviceHandle
                          );
  if (!EFI_ERROR (Status)) {
    Status = gBS->OpenProtocol (
                    DeviceHandle,
                    &gEfiFirmwareVolume2ProtocolGuid,
                    NULL,
                    NULL,
                    NULL,
                    EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                    );
    if (!EFI_ERROR (Status)) {
      return TRUE;
    }
  }
 
  return FALSE;
}
 
DEFERRED_3RD_PARTY_IMAGE_INFO *
LookupImage (
  IN  CONST EFI_DEVICE_PATH_PROTOCOL  *ImageDevicePath,
  IN        BOOLEAN                   BootOption
  )
{
  UINTN  Index;
  UINTN  DevicePathSize;
 
  DevicePathSize = GetDevicePathSize (ImageDevicePath);
 
  for (Index = 0; Index < mDeferred3rdPartyImage.Count; Index++) {
    if (CompareMem (ImageDevicePath, mDeferred3rdPartyImage.ImageInfo[Index].ImageDevicePath, DevicePathSize) == 0) {
      ASSERT (mDeferred3rdPartyImage.ImageInfo[Index].BootOption == BootOption);
      return &mDeferred3rdPartyImage.ImageInfo[Index];
    }
  }
 
  return NULL;
}
 
VOID
QueueImage (
  IN  CONST EFI_DEVICE_PATH_PROTOCOL  *ImageDevicePath,
  IN        BOOLEAN                   BootOption
  )
{
  DEFERRED_3RD_PARTY_IMAGE_INFO  *ImageInfo;
 
  //
  // Expand memory for the new deferred image.
  //
  ImageInfo = ReallocatePool (
                mDeferred3rdPartyImage.Count * sizeof (DEFERRED_3RD_PARTY_IMAGE_INFO),
                (mDeferred3rdPartyImage.Count + 1) * sizeof (DEFERRED_3RD_PARTY_IMAGE_INFO),
                mDeferred3rdPartyImage.ImageInfo
                );
  if (ImageInfo == NULL) {
    return;
  }
 
  mDeferred3rdPartyImage.ImageInfo = ImageInfo;
 
  //
  // Save the deferred image information.
  //
  ImageInfo                  = &mDeferred3rdPartyImage.ImageInfo[mDeferred3rdPartyImage.Count];
  ImageInfo->ImageDevicePath = DuplicateDevicePath (ImageDevicePath);
  if (ImageInfo->ImageDevicePath == NULL) {
    return;
  }
 
  ImageInfo->BootOption = BootOption;
  ImageInfo->Loaded     = FALSE;
  mDeferred3rdPartyImage.Count++;
}
 
EFI_STATUS
EFIAPI
GetDefferedImageInfo (
  IN     EFI_DEFERRED_IMAGE_LOAD_PROTOCOL  *This,
  IN     UINTN                             ImageIndex,
  OUT EFI_DEVICE_PATH_PROTOCOL             **ImageDevicePath,
  OUT VOID                                 **Image,
  OUT UINTN                                *ImageSize,
  OUT BOOLEAN                              *BootOption
  )
{
  UINTN  Index;
  UINTN  NewCount;
 
  if ((This == NULL) || (ImageSize == NULL) || (Image == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((ImageDevicePath == NULL) || (BootOption == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Remove the loaded images from the defer list in the first call.
  //
  if (ImageIndex == 0) {
    NewCount = 0;
    for (Index = 0; Index < mDeferred3rdPartyImage.Count; Index++) {
      if (!mDeferred3rdPartyImage.ImageInfo[Index].Loaded) {
        CopyMem (
          &mDeferred3rdPartyImage.ImageInfo[NewCount],
          &mDeferred3rdPartyImage.ImageInfo[Index],
          sizeof (DEFERRED_3RD_PARTY_IMAGE_INFO)
          );
        NewCount++;
      }
    }
 
    mDeferred3rdPartyImage.Count = NewCount;
  }
 
  if (ImageIndex >= mDeferred3rdPartyImage.Count) {
    return EFI_NOT_FOUND;
  }
 
  //
  // Get the request deferred image.
  //
  *ImageDevicePath = mDeferred3rdPartyImage.ImageInfo[ImageIndex].ImageDevicePath;
  *BootOption      = mDeferred3rdPartyImage.ImageInfo[ImageIndex].BootOption;
  *Image           = NULL;
  *ImageSize       = 0;
 
  return EFI_SUCCESS;
}
 
VOID
EFIAPI
EndOfDxe (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  mEndOfDxe = TRUE;
}
 
VOID
EFIAPI
DxeSmmReadyToLock (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  EFI_STATUS  Status;
  VOID        *Interface;
 
  Status = gBS->LocateProtocol (&gEfiDxeSmmReadyToLockProtocolGuid, NULL, &Interface);
  if (EFI_ERROR (Status)) {
    return;
  }
 
  gBS->CloseEvent (Event);
 
  if (mImageLoadedAfterEndOfDxe) {
    //
    // Platform should not dispatch the 3rd party images after signaling EndOfDxe event
    // but before publishing DxeSmmReadyToLock protocol.
    //
    DEBUG ((
      DEBUG_ERROR,
      "[Security] 3rd party images must be dispatched after DxeSmmReadyToLock Protocol installation!\n"
      ));
    REPORT_STATUS_CODE (
      EFI_ERROR_CODE | EFI_ERROR_UNRECOVERED,
      (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_EC_ILLEGAL_SOFTWARE_STATE)
      );
    ASSERT (FALSE);
    CpuDeadLoop ();
  }
}
 
EFI_STATUS
Defer3rdPartyImageLoad (
  IN  CONST EFI_DEVICE_PATH_PROTOCOL  *File,
  IN  BOOLEAN                         BootPolicy
  )
{
  DEFERRED_3RD_PARTY_IMAGE_INFO  *ImageInfo;
 
  //
  // Ignore if File is NULL.
  //
  if (File == NULL) {
    return EFI_SUCCESS;
  }
 
  if (FileFromFv (File)) {
    return EFI_SUCCESS;
  }
 
  ImageInfo = LookupImage (File, BootPolicy);
 
  DEBUG_CODE_BEGIN ();
  CHAR16  *DevicePathStr;
 
  DevicePathStr = ConvertDevicePathToText (File, FALSE, FALSE);
  DEBUG ((
    DEBUG_INFO,
    "[Security] 3rd party image[%p] %s EndOfDxe: %s.\n",
    ImageInfo,
    mEndOfDxe ? L"can be loaded after" : L"is deferred to load before",
    DevicePathStr
    ));
  if (DevicePathStr != NULL) {
    FreePool (DevicePathStr);
  }
 
  DEBUG_CODE_END ();
 
  if (mEndOfDxe) {
    mImageLoadedAfterEndOfDxe = TRUE;
    //
    // The image might be first time loaded after EndOfDxe,
    // So ImageInfo can be NULL.
    //
    if (ImageInfo != NULL) {
      ImageInfo->Loaded = TRUE;
    }
 
    return EFI_SUCCESS;
  } else {
    //
    // The image might be second time loaded before EndOfDxe,
    // So ImageInfo can be non-NULL.
    //
    if (ImageInfo == NULL) {
      QueueImage (File, BootPolicy);
    }
 
    return EFI_ACCESS_DENIED;
  }
}
 
VOID
Defer3rdPartyImageLoadInitialize (
  VOID
  )
{
  EFI_STATUS  Status;
  EFI_HANDLE  Handle;
  EFI_EVENT   Event;
  VOID        *Registration;
 
  Handle = NULL;
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Handle,
                  &gEfiDeferredImageLoadProtocolGuid,
                  &mDeferredImageLoad,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);
 
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  EndOfDxe,
                  NULL,
                  &gEfiEndOfDxeEventGroupGuid,
                  &Event
                  );
  ASSERT_EFI_ERROR (Status);
 
  EfiCreateProtocolNotifyEvent (
    &gEfiDxeSmmReadyToLockProtocolGuid,
    TPL_CALLBACK,
    DxeSmmReadyToLock,
    NULL,
    &Registration
    );
}