BootAndroidBootImg.c

Go to the documentation of this file.

 
#include "AndroidFastbootApp.h"
 
#include <Protocol/DevicePath.h>
#include <Protocol/LoadedImage.h>
 
#include <Library/DevicePathLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
 
// Device Path representing an image in memory
#pragma pack(1)
typedef struct {
  MEMMAP_DEVICE_PATH          Node1;
  EFI_DEVICE_PATH_PROTOCOL    End;
} MEMORY_DEVICE_PATH;
#pragma pack()
 
STATIC CONST MEMORY_DEVICE_PATH  MemoryDevicePathTemplate =
{
  {
    {
      HARDWARE_DEVICE_PATH,
      HW_MEMMAP_DP,
      {
        (UINT8)(sizeof (MEMMAP_DEVICE_PATH)),
        (UINT8)((sizeof (MEMMAP_DEVICE_PATH)) >> 8),
      },
    }, // Header
    0, // StartingAddress (set at runtime)
    0  // EndingAddress   (set at runtime)
  }, // Node1
  {
    END_DEVICE_PATH_TYPE,
    END_ENTIRE_DEVICE_PATH_SUBTYPE,
    { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }
  } // End
};
 
STATIC
EFI_STATUS
StartEfiApplication (
  IN EFI_HANDLE                ParentImageHandle,
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
  IN UINTN                     LoadOptionsSize,
  IN VOID                      *LoadOptions
  )
{
  EFI_STATUS                 Status;
  EFI_HANDLE                 ImageHandle;
  EFI_LOADED_IMAGE_PROTOCOL  *LoadedImage;
 
  // Load the image from the device path with Boot Services function
  Status = gBS->LoadImage (
                  TRUE,
                  ParentImageHandle,
                  DevicePath,
                  NULL,
                  0,
                  &ImageHandle
                  );
  if (EFI_ERROR (Status)) {
    //
    // With EFI_SECURITY_VIOLATION retval, the Image was loaded and an ImageHandle was created
    // with a valid EFI_LOADED_IMAGE_PROTOCOL, but the image can not be started right now.
    // If the caller doesn't have the option to defer the execution of an image, we should
    // unload image for the EFI_SECURITY_VIOLATION to avoid resource leak.
    //
    if (Status == EFI_SECURITY_VIOLATION) {
      gBS->UnloadImage (ImageHandle);
    }
 
    return Status;
  }
 
  // Passed LoadOptions to the EFI Application
  if (LoadOptionsSize != 0) {
    Status = gBS->HandleProtocol (
                    ImageHandle,
                    &gEfiLoadedImageProtocolGuid,
                    (VOID **)&LoadedImage
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    LoadedImage->LoadOptionsSize = LoadOptionsSize;
    LoadedImage->LoadOptions     = LoadOptions;
  }
 
  // Before calling the image, enable the Watchdog Timer for  the 5 Minute period
  gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
  // Start the image
  Status = gBS->StartImage (ImageHandle, NULL, NULL);
  // Clear the Watchdog Timer after the image returns
  gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
 
  return Status;
}
 
EFI_STATUS
BootAndroidBootImg (
  IN UINTN  BufferSize,
  IN VOID   *Buffer
  )
{
  EFI_STATUS          Status;
  CHAR8               KernelArgs[ANDROID_BOOTIMG_KERNEL_ARGS_SIZE];
  VOID                *Kernel;
  UINTN               KernelSize;
  VOID                *Ramdisk;
  UINTN               RamdiskSize;
  MEMORY_DEVICE_PATH  KernelDevicePath;
  CHAR16              *LoadOptions, *NewLoadOptions;
 
  Status = ParseAndroidBootImg (
             Buffer,
             &Kernel,
             &KernelSize,
             &Ramdisk,
             &RamdiskSize,
             KernelArgs
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  KernelDevicePath = MemoryDevicePathTemplate;
 
  // Have to cast to UINTN before casting to EFI_PHYSICAL_ADDRESS in order to
  // appease GCC.
  KernelDevicePath.Node1.StartingAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Kernel;
  KernelDevicePath.Node1.EndingAddress   = (EFI_PHYSICAL_ADDRESS)(UINTN)Kernel + KernelSize;
 
  // Initialize Linux command line
  LoadOptions = CatSPrint (NULL, L"%a", KernelArgs);
  if (LoadOptions == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  if (RamdiskSize != 0) {
    NewLoadOptions = CatSPrint (
                       LoadOptions,
                       L" initrd=0x%x,0x%x",
                       (UINTN)Ramdisk,
                       RamdiskSize
                       );
    FreePool (LoadOptions);
    if (NewLoadOptions == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    LoadOptions = NewLoadOptions;
  }
 
  Status = StartEfiApplication (
             gImageHandle,
             (EFI_DEVICE_PATH_PROTOCOL *)&KernelDevicePath,
             StrSize (LoadOptions),
             LoadOptions
             );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "Couldn't Boot Linux: %d\n", Status));
    Status = EFI_DEVICE_ERROR;
    goto FreeLoadOptions;
  }
 
  // If we got here we do a confused face because BootLinuxFdt returned,
  // reporting success.
  DEBUG ((DEBUG_ERROR, "WARNING: BdsBootLinuxFdt returned EFI_SUCCESS.\n"));
  return EFI_SUCCESS;
 
FreeLoadOptions:
  FreePool (LoadOptions);
  return Status;
}