[mirror_edk2.git] / OvmfPkg / Library / GenericQemuLoadImageLib / GenericQemuLoadImageLib.c

/**  @file\r
  Generic implementation of QemuLoadImageLib library class interface.\r
\r
  Copyright (c) 2020, ARM Ltd. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
**/\r
\r
#include <Uefi.h>\r
\r
#include <Base.h>\r
#include <Guid/QemuKernelLoaderFsMedia.h>\r
#include <Library/DebugLib.h>\r
#include <Library/FileHandleLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/PrintLib.h>\r
#include <Library/QemuLoadImageLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Protocol/DevicePath.h>\r
#include <Protocol/LoadedImage.h>\r
#include <Protocol/SimpleFileSystem.h>\r
\r
#pragma pack (1)\r
typedef struct {\r
  EFI_DEVICE_PATH_PROTOCOL    FilePathHeader;\r
  CHAR16                      FilePath[ARRAY_SIZE (L"kernel")];\r
} KERNEL_FILE_DEVPATH;\r
\r
typedef struct {\r
  VENDOR_DEVICE_PATH          VenMediaNode;\r
  KERNEL_FILE_DEVPATH         FileNode;\r
  EFI_DEVICE_PATH_PROTOCOL    EndNode;\r
} KERNEL_VENMEDIA_FILE_DEVPATH;\r
\r
typedef struct {\r
  VENDOR_DEVICE_PATH          VenMediaNode;\r
  EFI_DEVICE_PATH_PROTOCOL    EndNode;\r
} SINGLE_VENMEDIA_NODE_DEVPATH;\r
#pragma pack ()\r
\r
STATIC CONST KERNEL_VENMEDIA_FILE_DEVPATH  mKernelDevicePath = {\r
  {\r
    {\r
      MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP,\r
      { sizeof (VENDOR_DEVICE_PATH)       }\r
    },\r
    QEMU_KERNEL_LOADER_FS_MEDIA_GUID\r
  },  {\r
    {\r
      MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP,\r
      { sizeof (KERNEL_FILE_DEVPATH)      }\r
    },\r
    L"kernel",\r
  },  {\r
    END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
    { sizeof (EFI_DEVICE_PATH_PROTOCOL) }\r
  }\r
};\r
\r
STATIC CONST SINGLE_VENMEDIA_NODE_DEVPATH  mQemuKernelLoaderFsDevicePath = {\r
  {\r
    {\r
      MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP,\r
      { sizeof (VENDOR_DEVICE_PATH)       }\r
    },\r
    QEMU_KERNEL_LOADER_FS_MEDIA_GUID\r
  },  {\r
    END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
    { sizeof (EFI_DEVICE_PATH_PROTOCOL) }\r
  }\r
};\r
\r
STATIC\r
EFI_STATUS\r
GetQemuKernelLoaderBlobSize (\r
  IN  EFI_FILE_HANDLE  Root,\r
  IN  CHAR16           *FileName,\r
  OUT UINTN            *Size\r
  )\r
{\r
  EFI_STATUS       Status;\r
  EFI_FILE_HANDLE  FileHandle;\r
  UINT64           FileSize;\r
\r
  Status = Root->Open (Root, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = FileHandleGetSize (FileHandle, &FileSize);\r
  if (EFI_ERROR (Status)) {\r
    goto CloseFile;\r
  }\r
\r
  if (FileSize > MAX_UINTN) {\r
    Status = EFI_UNSUPPORTED;\r
    goto CloseFile;\r
  }\r
\r
  *Size  = (UINTN)FileSize;\r
  Status = EFI_SUCCESS;\r
CloseFile:\r
  FileHandle->Close (FileHandle);\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
ReadWholeQemuKernelLoaderBlob (\r
  IN  EFI_FILE_HANDLE  Root,\r
  IN  CHAR16           *FileName,\r
  IN  UINTN            Size,\r
  OUT VOID             *Buffer\r
  )\r
{\r
  EFI_STATUS       Status;\r
  EFI_FILE_HANDLE  FileHandle;\r
  UINTN            ReadSize;\r
\r
  Status = Root->Open (Root, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  ReadSize = Size;\r
  Status   = FileHandle->Read (FileHandle, &ReadSize, Buffer);\r
  if (EFI_ERROR (Status)) {\r
    goto CloseFile;\r
  }\r
\r
  if (ReadSize != Size) {\r
    Status = EFI_PROTOCOL_ERROR;\r
    goto CloseFile;\r
  }\r
\r
  Status = EFI_SUCCESS;\r
CloseFile:\r
  FileHandle->Close (FileHandle);\r
  return Status;\r
}\r
\r
/**\r
  Download the kernel, the initial ramdisk, and the kernel command line from\r
  QEMU's fw_cfg. The kernel will be instructed via its command line to load\r
  the initrd from the same Simple FileSystem where the kernel was loaded from.\r
\r
  @param[out] ImageHandle       The image handle that was allocated for\r
                                loading the image\r
\r
  @retval EFI_SUCCESS           The image was loaded successfully.\r
  @retval EFI_NOT_FOUND         Kernel image was not found.\r
  @retval EFI_OUT_OF_RESOURCES  Memory allocation failed.\r
  @retval EFI_PROTOCOL_ERROR    Unterminated kernel command line.\r
  @retval EFI_ACCESS_DENIED     The underlying LoadImage boot service call\r
                                returned EFI_SECURITY_VIOLATION, and the image\r
                                was unloaded again.\r
\r
  @return                       Error codes from any of the underlying\r
                                functions.\r
**/\r
EFI_STATUS\r
EFIAPI\r
QemuLoadKernelImage (\r
  OUT EFI_HANDLE  *ImageHandle\r
  )\r
{\r
  EFI_STATUS                       Status;\r
  EFI_HANDLE                       KernelImageHandle;\r
  EFI_LOADED_IMAGE_PROTOCOL        *KernelLoadedImage;\r
  EFI_DEVICE_PATH_PROTOCOL         *DevicePathNode;\r
  EFI_HANDLE                       FsVolumeHandle;\r
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *FsProtocol;\r
  EFI_FILE_HANDLE                  Root;\r
  UINTN                            CommandLineSize;\r
  CHAR8                            *CommandLine;\r
  UINTN                            InitrdSize;\r
\r
  //\r
  // Load the image. This should call back into the QEMU EFI loader file system.\r
  //\r
  Status = gBS->LoadImage (\r
                  FALSE,                    // BootPolicy: exact match required\r
                  gImageHandle,             // ParentImageHandle\r
                  (EFI_DEVICE_PATH_PROTOCOL *)&mKernelDevicePath,\r
                  NULL,                     // SourceBuffer\r
                  0,                        // SourceSize\r
                  &KernelImageHandle\r
                  );\r
  switch (Status) {\r
    case EFI_SUCCESS:\r
      break;\r
\r
    case EFI_SECURITY_VIOLATION:\r
      //\r
      // In this case, the image was loaded but failed to authenticate.\r
      //\r
      Status = EFI_ACCESS_DENIED;\r
      goto UnloadImage;\r
\r
    default:\r
      DEBUG ((\r
        Status == EFI_NOT_FOUND ? DEBUG_INFO : DEBUG_ERROR,\r
        "%a: LoadImage(): %r\n",\r
        __FUNCTION__,\r
        Status\r
        ));\r
      return Status;\r
  }\r
\r
  //\r
  // Construct the kernel command line.\r
  //\r
  Status = gBS->OpenProtocol (\r
                  KernelImageHandle,\r
                  &gEfiLoadedImageProtocolGuid,\r
                  (VOID **)&KernelLoadedImage,\r
                  gImageHandle,                  // AgentHandle\r
                  NULL,                          // ControllerHandle\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Open the Qemu Kernel Loader abstract filesystem (volume) which will be\r
  // used to query the "initrd" and to read the "cmdline" synthetic files.\r
  //\r
  DevicePathNode = (EFI_DEVICE_PATH_PROTOCOL *)&mQemuKernelLoaderFsDevicePath;\r
  Status         = gBS->LocateDevicePath (\r
                          &gEfiSimpleFileSystemProtocolGuid,\r
                          &DevicePathNode,\r
                          &FsVolumeHandle\r
                          );\r
  if (EFI_ERROR (Status)) {\r
    goto UnloadImage;\r
  }\r
\r
  Status = gBS->HandleProtocol (\r
                  FsVolumeHandle,\r
                  &gEfiSimpleFileSystemProtocolGuid,\r
                  (VOID **)&FsProtocol\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto UnloadImage;\r
  }\r
\r
  Status = FsProtocol->OpenVolume (FsVolumeHandle, &Root);\r
  if (EFI_ERROR (Status)) {\r
    goto UnloadImage;\r
  }\r
\r
  Status = GetQemuKernelLoaderBlobSize (Root, L"cmdline", &CommandLineSize);\r
  if (EFI_ERROR (Status)) {\r
    goto CloseRoot;\r
  }\r
\r
  if (CommandLineSize == 0) {\r
    KernelLoadedImage->LoadOptionsSize = 0;\r
  } else {\r
    CommandLine = AllocatePool (CommandLineSize);\r
    if (CommandLine == NULL) {\r
      Status = EFI_OUT_OF_RESOURCES;\r
      goto CloseRoot;\r
    }\r
\r
    Status = ReadWholeQemuKernelLoaderBlob (\r
               Root,\r
               L"cmdline",\r
               CommandLineSize,\r
               CommandLine\r
               );\r
    if (EFI_ERROR (Status)) {\r
      goto FreeCommandLine;\r
    }\r
\r
    //\r
    // Verify NUL-termination of the command line.\r
    //\r
    if (CommandLine[CommandLineSize - 1] != '\0') {\r
      DEBUG ((\r
        DEBUG_ERROR,\r
        "%a: kernel command line is not NUL-terminated\n",\r
        __FUNCTION__\r
        ));\r
      Status = EFI_PROTOCOL_ERROR;\r
      goto FreeCommandLine;\r
    }\r
\r
    //\r
    // Drop the terminating NUL, convert to UTF-16.\r
    //\r
    KernelLoadedImage->LoadOptionsSize = (UINT32)((CommandLineSize - 1) * 2);\r
  }\r
\r
  Status = GetQemuKernelLoaderBlobSize (Root, L"initrd", &InitrdSize);\r
  if (EFI_ERROR (Status)) {\r
    goto FreeCommandLine;\r
  }\r
\r
  if (InitrdSize > 0) {\r
    //\r
    // Append ' initrd=initrd' in UTF-16.\r
    //\r
    KernelLoadedImage->LoadOptionsSize += sizeof (L" initrd=initrd") - 2;\r
  }\r
\r
  if (KernelLoadedImage->LoadOptionsSize == 0) {\r
    KernelLoadedImage->LoadOptions = NULL;\r
  } else {\r
    //\r
    // NUL-terminate in UTF-16.\r
    //\r
    KernelLoadedImage->LoadOptionsSize += 2;\r
\r
    KernelLoadedImage->LoadOptions = AllocatePool (\r
                                       KernelLoadedImage->LoadOptionsSize\r
                                       );\r
    if (KernelLoadedImage->LoadOptions == NULL) {\r
      KernelLoadedImage->LoadOptionsSize = 0;\r
      Status                             = EFI_OUT_OF_RESOURCES;\r
      goto FreeCommandLine;\r
    }\r
\r
    UnicodeSPrintAsciiFormat (\r
      KernelLoadedImage->LoadOptions,\r
      KernelLoadedImage->LoadOptionsSize,\r
      "%a%a",\r
      (CommandLineSize == 0) ?  "" : CommandLine,\r
      (InitrdSize == 0)      ?  "" : " initrd=initrd"\r
      );\r
    DEBUG ((\r
      DEBUG_INFO,\r
      "%a: command line: \"%s\"\n",\r
      __FUNCTION__,\r
      (CHAR16 *)KernelLoadedImage->LoadOptions\r
      ));\r
  }\r
\r
  *ImageHandle = KernelImageHandle;\r
  Status       = EFI_SUCCESS;\r
\r
FreeCommandLine:\r
  if (CommandLineSize > 0) {\r
    FreePool (CommandLine);\r
  }\r
\r
CloseRoot:\r
  Root->Close (Root);\r
UnloadImage:\r
  if (EFI_ERROR (Status)) {\r
    gBS->UnloadImage (KernelImageHandle);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Transfer control to a kernel image loaded with QemuLoadKernelImage ()\r
\r
  @param[in,out]  ImageHandle     Handle of image to be started. May assume a\r
                                  different value on return if the image was\r
                                  reloaded.\r
\r
  @retval EFI_INVALID_PARAMETER   ImageHandle is either an invalid image handle\r
                                  or the image has already been initialized with\r
                                  StartImage\r
  @retval EFI_SECURITY_VIOLATION  The current platform policy specifies that the\r
                                  image should not be started.\r
\r
  @return                         Error codes returned by the started image\r
**/\r
EFI_STATUS\r
EFIAPI\r
QemuStartKernelImage (\r
  IN  OUT EFI_HANDLE  *ImageHandle\r
  )\r
{\r
  return gBS->StartImage (\r
                *ImageHandle,\r
                NULL,              // ExitDataSize\r
                NULL               // ExitData\r
                );\r
}\r
\r
/**\r
  Unloads an image loaded with QemuLoadKernelImage ().\r
\r
  @param  ImageHandle             Handle that identifies the image to be\r
                                  unloaded.\r
\r
  @retval EFI_SUCCESS             The image has been unloaded.\r
  @retval EFI_UNSUPPORTED         The image has been started, and does not\r
                                  support unload.\r
  @retval EFI_INVALID_PARAMETER   ImageHandle is not a valid image handle.\r
\r
  @return                         Exit code from the image's unload function.\r
**/\r
EFI_STATUS\r
EFIAPI\r
QemuUnloadKernelImage (\r
  IN  EFI_HANDLE  ImageHandle\r
  )\r
{\r
  EFI_LOADED_IMAGE_PROTOCOL  *KernelLoadedImage;\r
  EFI_STATUS                 Status;\r
\r
  Status = gBS->OpenProtocol (\r
                  ImageHandle,\r
                  &gEfiLoadedImageProtocolGuid,\r
                  (VOID **)&KernelLoadedImage,\r
                  gImageHandle,                  // AgentHandle\r
                  NULL,                          // ControllerHandle\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (KernelLoadedImage->LoadOptions != NULL) {\r
    FreePool (KernelLoadedImage->LoadOptions);\r
    KernelLoadedImage->LoadOptions = NULL;\r
  }\r
\r
  KernelLoadedImage->LoadOptionsSize = 0;\r
\r
  return gBS->UnloadImage (ImageHandle);\r
}\r
Commit	Line	Data
ddd2be6b AB	1	/** @file\r
	2	Generic implementation of QemuLoadImageLib library class interface.\r
	3	\r
	4	Copyright (c) 2020, ARM Ltd. All rights reserved.<BR>\r
	5	\r
	6	SPDX-License-Identifier: BSD-2-Clause-Patent\r
	7	**/\r
	8	\r
	9	#include <Uefi.h>\r
	10	\r
	11	#include <Base.h>\r
	12	#include <Guid/QemuKernelLoaderFsMedia.h>\r
	13	#include <Library/DebugLib.h>\r
cf203024	14	#include <Library/FileHandleLib.h>\r
ddd2be6b AB	15	#include <Library/MemoryAllocationLib.h>\r
ddd2be6b AB	16	#include <Library/PrintLib.h>\r
ddd2be6b AB	17	#include <Library/QemuLoadImageLib.h>\r
	18	#include <Library/UefiBootServicesTableLib.h>\r
	19	#include <Protocol/DevicePath.h>\r
	20	#include <Protocol/LoadedImage.h>\r
cf203024	21	#include <Protocol/SimpleFileSystem.h>\r
ddd2be6b AB	22	\r
	23	#pragma pack (1)\r
	24	typedef struct {\r
ac0a286f MK	25	EFI_DEVICE_PATH_PROTOCOL FilePathHeader;\r
ac0a286f MK	26	CHAR16 FilePath[ARRAY_SIZE (L"kernel")];\r
ddd2be6b AB	27	} KERNEL_FILE_DEVPATH;\r
	28	\r
	29	typedef struct {\r
ac0a286f MK	30	VENDOR_DEVICE_PATH VenMediaNode;\r
	31	KERNEL_FILE_DEVPATH FileNode;\r
	32	EFI_DEVICE_PATH_PROTOCOL EndNode;\r
ddd2be6b	33	} KERNEL_VENMEDIA_FILE_DEVPATH;\r
cf203024 DM	34	\r
cf203024 DM	35	typedef struct {\r
ac0a286f MK	36	VENDOR_DEVICE_PATH VenMediaNode;\r
ac0a286f MK	37	EFI_DEVICE_PATH_PROTOCOL EndNode;\r
cf203024	38	} SINGLE_VENMEDIA_NODE_DEVPATH;\r
ddd2be6b AB	39	#pragma pack ()\r
ddd2be6b AB	40	\r
ac0a286f	41	STATIC CONST KERNEL_VENMEDIA_FILE_DEVPATH mKernelDevicePath = {\r
ddd2be6b AB	42	{\r
	43	{\r
	44	MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP,\r
ac0a286f	45	{ sizeof (VENDOR_DEVICE_PATH) }\r
ddd2be6b AB	46	},\r
ddd2be6b AB	47	QEMU_KERNEL_LOADER_FS_MEDIA_GUID\r
ac0a286f	48	}, {\r
ddd2be6b AB	49	{\r
ddd2be6b AB	50	MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP,\r
ac0a286f	51	{ sizeof (KERNEL_FILE_DEVPATH) }\r
ddd2be6b AB	52	},\r
ddd2be6b AB	53	L"kernel",\r
ac0a286f	54	}, {\r
ddd2be6b AB	55	END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
	56	{ sizeof (EFI_DEVICE_PATH_PROTOCOL) }\r
	57	}\r
	58	};\r
	59	\r
ac0a286f	60	STATIC CONST SINGLE_VENMEDIA_NODE_DEVPATH mQemuKernelLoaderFsDevicePath = {\r
cf203024 DM	61	{\r
	62	{\r
	63	MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP,\r
ac0a286f	64	{ sizeof (VENDOR_DEVICE_PATH) }\r
cf203024 DM	65	},\r
cf203024 DM	66	QEMU_KERNEL_LOADER_FS_MEDIA_GUID\r
ac0a286f	67	}, {\r
cf203024 DM	68	END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
	69	{ sizeof (EFI_DEVICE_PATH_PROTOCOL) }\r
	70	}\r
	71	};\r
	72	\r
	73	STATIC\r
	74	EFI_STATUS\r
	75	GetQemuKernelLoaderBlobSize (\r
ac0a286f MK	76	IN EFI_FILE_HANDLE Root,\r
	77	IN CHAR16 *FileName,\r
	78	OUT UINTN *Size\r
cf203024 DM	79	)\r
cf203024 DM	80	{\r
ac0a286f MK	81	EFI_STATUS Status;\r
	82	EFI_FILE_HANDLE FileHandle;\r
	83	UINT64 FileSize;\r
cf203024 DM	84	\r
	85	Status = Root->Open (Root, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);\r
	86	if (EFI_ERROR (Status)) {\r
	87	return Status;\r
	88	}\r
ac0a286f	89	\r
cf203024 DM	90	Status = FileHandleGetSize (FileHandle, &FileSize);\r
	91	if (EFI_ERROR (Status)) {\r
	92	goto CloseFile;\r
	93	}\r
ac0a286f	94	\r
cf203024 DM	95	if (FileSize > MAX_UINTN) {\r
	96	Status = EFI_UNSUPPORTED;\r
	97	goto CloseFile;\r
	98	}\r
ac0a286f MK	99	\r
ac0a286f MK	100	*Size = (UINTN)FileSize;\r
cf203024 DM	101	Status = EFI_SUCCESS;\r
	102	CloseFile:\r
	103	FileHandle->Close (FileHandle);\r
	104	return Status;\r
	105	}\r
	106	\r
	107	STATIC\r
	108	EFI_STATUS\r
	109	ReadWholeQemuKernelLoaderBlob (\r
ac0a286f MK	110	IN EFI_FILE_HANDLE Root,\r
	111	IN CHAR16 *FileName,\r
	112	IN UINTN Size,\r
	113	OUT VOID *Buffer\r
cf203024 DM	114	)\r
cf203024 DM	115	{\r
ac0a286f MK	116	EFI_STATUS Status;\r
	117	EFI_FILE_HANDLE FileHandle;\r
	118	UINTN ReadSize;\r
cf203024 DM	119	\r
	120	Status = Root->Open (Root, &FileHandle, FileName, EFI_FILE_MODE_READ, 0);\r
	121	if (EFI_ERROR (Status)) {\r
	122	return Status;\r
	123	}\r
ac0a286f	124	\r
cf203024	125	ReadSize = Size;\r
ac0a286f	126	Status = FileHandle->Read (FileHandle, &ReadSize, Buffer);\r
cf203024 DM	127	if (EFI_ERROR (Status)) {\r
	128	goto CloseFile;\r
	129	}\r
ac0a286f	130	\r
cf203024 DM	131	if (ReadSize != Size) {\r
	132	Status = EFI_PROTOCOL_ERROR;\r
	133	goto CloseFile;\r
	134	}\r
ac0a286f	135	\r
cf203024 DM	136	Status = EFI_SUCCESS;\r
	137	CloseFile:\r
	138	FileHandle->Close (FileHandle);\r
	139	return Status;\r
	140	}\r
	141	\r
ddd2be6b AB	142	/**\r
	143	Download the kernel, the initial ramdisk, and the kernel command line from\r
	144	QEMU's fw_cfg. The kernel will be instructed via its command line to load\r
	145	the initrd from the same Simple FileSystem where the kernel was loaded from.\r
	146	\r
	147	@param[out] ImageHandle The image handle that was allocated for\r
	148	loading the image\r
	149	\r
	150	@retval EFI_SUCCESS The image was loaded successfully.\r
	151	@retval EFI_NOT_FOUND Kernel image was not found.\r
	152	@retval EFI_OUT_OF_RESOURCES Memory allocation failed.\r
	153	@retval EFI_PROTOCOL_ERROR Unterminated kernel command line.\r
	154	@retval EFI_ACCESS_DENIED The underlying LoadImage boot service call\r
	155	returned EFI_SECURITY_VIOLATION, and the image\r
	156	was unloaded again.\r
	157	\r
	158	@return Error codes from any of the underlying\r
	159	functions.\r
	160	**/\r
	161	EFI_STATUS\r
	162	EFIAPI\r
	163	QemuLoadKernelImage (\r
ac0a286f	164	OUT EFI_HANDLE *ImageHandle\r
ddd2be6b AB	165	)\r
ddd2be6b AB	166	{\r
ac0a286f MK	167	EFI_STATUS Status;\r
	168	EFI_HANDLE KernelImageHandle;\r
	169	EFI_LOADED_IMAGE_PROTOCOL *KernelLoadedImage;\r
	170	EFI_DEVICE_PATH_PROTOCOL *DevicePathNode;\r
	171	EFI_HANDLE FsVolumeHandle;\r
	172	EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *FsProtocol;\r
	173	EFI_FILE_HANDLE Root;\r
	174	UINTN CommandLineSize;\r
	175	CHAR8 *CommandLine;\r
	176	UINTN InitrdSize;\r
ddd2be6b AB	177	\r
	178	//\r
	179	// Load the image. This should call back into the QEMU EFI loader file system.\r
	180	//\r
	181	Status = gBS->LoadImage (\r
	182	FALSE, // BootPolicy: exact match required\r
	183	gImageHandle, // ParentImageHandle\r
	184	(EFI_DEVICE_PATH_PROTOCOL *)&mKernelDevicePath,\r
	185	NULL, // SourceBuffer\r
	186	0, // SourceSize\r
	187	&KernelImageHandle\r
	188	);\r
	189	switch (Status) {\r
ac0a286f MK	190	case EFI_SUCCESS:\r
	191	break;\r
	192	\r
	193	case EFI_SECURITY_VIOLATION:\r
	194	//\r
	195	// In this case, the image was loaded but failed to authenticate.\r
	196	//\r
	197	Status = EFI_ACCESS_DENIED;\r
	198	goto UnloadImage;\r
	199	\r
	200	default:\r
	201	DEBUG ((\r
	202	Status == EFI_NOT_FOUND ? DEBUG_INFO : DEBUG_ERROR,\r
	203	"%a: LoadImage(): %r\n",\r
	204	__FUNCTION__,\r
	205	Status\r
	206	));\r
	207	return Status;\r
ddd2be6b AB	208	}\r
	209	\r
	210	//\r
	211	// Construct the kernel command line.\r
	212	//\r
	213	Status = gBS->OpenProtocol (\r
	214	KernelImageHandle,\r
	215	&gEfiLoadedImageProtocolGuid,\r
	216	(VOID **)&KernelLoadedImage,\r
	217	gImageHandle, // AgentHandle\r
	218	NULL, // ControllerHandle\r
	219	EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
	220	);\r
	221	ASSERT_EFI_ERROR (Status);\r
	222	\r
cf203024 DM	223	//\r
	224	// Open the Qemu Kernel Loader abstract filesystem (volume) which will be\r
	225	// used to query the "initrd" and to read the "cmdline" synthetic files.\r
	226	//\r
	227	DevicePathNode = (EFI_DEVICE_PATH_PROTOCOL *)&mQemuKernelLoaderFsDevicePath;\r
ac0a286f MK	228	Status = gBS->LocateDevicePath (\r
	229	&gEfiSimpleFileSystemProtocolGuid,\r
	230	&DevicePathNode,\r
	231	&FsVolumeHandle\r
	232	);\r
cf203024 DM	233	if (EFI_ERROR (Status)) {\r
	234	goto UnloadImage;\r
	235	}\r
	236	\r
	237	Status = gBS->HandleProtocol (\r
	238	FsVolumeHandle,\r
	239	&gEfiSimpleFileSystemProtocolGuid,\r
	240	(VOID **)&FsProtocol\r
	241	);\r
	242	if (EFI_ERROR (Status)) {\r
	243	goto UnloadImage;\r
	244	}\r
	245	\r
	246	Status = FsProtocol->OpenVolume (FsVolumeHandle, &Root);\r
	247	if (EFI_ERROR (Status)) {\r
	248	goto UnloadImage;\r
	249	}\r
	250	\r
	251	Status = GetQemuKernelLoaderBlobSize (Root, L"cmdline", &CommandLineSize);\r
	252	if (EFI_ERROR (Status)) {\r
	253	goto CloseRoot;\r
	254	}\r
ddd2be6b AB	255	\r
	256	if (CommandLineSize == 0) {\r
	257	KernelLoadedImage->LoadOptionsSize = 0;\r
	258	} else {\r
	259	CommandLine = AllocatePool (CommandLineSize);\r
	260	if (CommandLine == NULL) {\r
	261	Status = EFI_OUT_OF_RESOURCES;\r
cf203024	262	goto CloseRoot;\r
ddd2be6b AB	263	}\r
ddd2be6b AB	264	\r
ac0a286f MK	265	Status = ReadWholeQemuKernelLoaderBlob (\r
	266	Root,\r
	267	L"cmdline",\r
	268	CommandLineSize,\r
	269	CommandLine\r
	270	);\r
cf203024 DM	271	if (EFI_ERROR (Status)) {\r
	272	goto FreeCommandLine;\r
	273	}\r
ddd2be6b AB	274	\r
	275	//\r
	276	// Verify NUL-termination of the command line.\r
	277	//\r
	278	if (CommandLine[CommandLineSize - 1] != '\0') {\r
ac0a286f MK	279	DEBUG ((\r
	280	DEBUG_ERROR,\r
	281	"%a: kernel command line is not NUL-terminated\n",\r
	282	__FUNCTION__\r
	283	));\r
ddd2be6b AB	284	Status = EFI_PROTOCOL_ERROR;\r
	285	goto FreeCommandLine;\r
	286	}\r
	287	\r
	288	//\r
	289	// Drop the terminating NUL, convert to UTF-16.\r
	290	//\r
3000c296	291	KernelLoadedImage->LoadOptionsSize = (UINT32)((CommandLineSize - 1) * 2);\r
ddd2be6b AB	292	}\r
ddd2be6b AB	293	\r
cf203024 DM	294	Status = GetQemuKernelLoaderBlobSize (Root, L"initrd", &InitrdSize);\r
	295	if (EFI_ERROR (Status)) {\r
	296	goto FreeCommandLine;\r
	297	}\r
ddd2be6b AB	298	\r
	299	if (InitrdSize > 0) {\r
	300	//\r
	301	// Append ' initrd=initrd' in UTF-16.\r
	302	//\r
	303	KernelLoadedImage->LoadOptionsSize += sizeof (L" initrd=initrd") - 2;\r
	304	}\r
	305	\r
	306	if (KernelLoadedImage->LoadOptionsSize == 0) {\r
	307	KernelLoadedImage->LoadOptions = NULL;\r
	308	} else {\r
	309	//\r
	310	// NUL-terminate in UTF-16.\r
	311	//\r
	312	KernelLoadedImage->LoadOptionsSize += 2;\r
	313	\r
	314	KernelLoadedImage->LoadOptions = AllocatePool (\r
ac0a286f MK	315	KernelLoadedImage->LoadOptionsSize\r
ac0a286f MK	316	);\r
ddd2be6b AB	317	if (KernelLoadedImage->LoadOptions == NULL) {\r
ddd2be6b AB	318	KernelLoadedImage->LoadOptionsSize = 0;\r
ac0a286f	319	Status = EFI_OUT_OF_RESOURCES;\r
ddd2be6b AB	320	goto FreeCommandLine;\r
	321	}\r
	322	\r
	323	UnicodeSPrintAsciiFormat (\r
	324	KernelLoadedImage->LoadOptions,\r
	325	KernelLoadedImage->LoadOptionsSize,\r
	326	"%a%a",\r
	327	(CommandLineSize == 0) ? "" : CommandLine,\r
	328	(InitrdSize == 0) ? "" : " initrd=initrd"\r
	329	);\r
ac0a286f MK	330	DEBUG ((\r
	331	DEBUG_INFO,\r
	332	"%a: command line: \"%s\"\n",\r
	333	__FUNCTION__,\r
	334	(CHAR16 *)KernelLoadedImage->LoadOptions\r
	335	));\r
ddd2be6b AB	336	}\r
	337	\r
	338	*ImageHandle = KernelImageHandle;\r
ac0a286f	339	Status = EFI_SUCCESS;\r
ddd2be6b AB	340	\r
	341	FreeCommandLine:\r
	342	if (CommandLineSize > 0) {\r
	343	FreePool (CommandLine);\r
	344	}\r
ac0a286f	345	\r
cf203024 DM	346	CloseRoot:\r
cf203024 DM	347	Root->Close (Root);\r
ddd2be6b	348	UnloadImage:\r
5a2e030f DM	349	if (EFI_ERROR (Status)) {\r
	350	gBS->UnloadImage (KernelImageHandle);\r
	351	}\r
ddd2be6b AB	352	\r
	353	return Status;\r
	354	}\r
	355	\r
	356	/**\r
	357	Transfer control to a kernel image loaded with QemuLoadKernelImage ()\r
	358	\r
	359	@param[in,out] ImageHandle Handle of image to be started. May assume a\r
	360	different value on return if the image was\r
	361	reloaded.\r
	362	\r
	363	@retval EFI_INVALID_PARAMETER ImageHandle is either an invalid image handle\r
	364	or the image has already been initialized with\r
	365	StartImage\r
	366	@retval EFI_SECURITY_VIOLATION The current platform policy specifies that the\r
	367	image should not be started.\r
	368	\r
	369	@return Error codes returned by the started image\r
	370	**/\r
	371	EFI_STATUS\r
	372	EFIAPI\r
	373	QemuStartKernelImage (\r
ac0a286f	374	IN OUT EFI_HANDLE *ImageHandle\r
ddd2be6b AB	375	)\r
	376	{\r
	377	return gBS->StartImage (\r
	378	*ImageHandle,\r
	379	NULL, // ExitDataSize\r
	380	NULL // ExitData\r
	381	);\r
	382	}\r
	383	\r
	384	/**\r
	385	Unloads an image loaded with QemuLoadKernelImage ().\r
	386	\r
	387	@param ImageHandle Handle that identifies the image to be\r
	388	unloaded.\r
	389	\r
	390	@retval EFI_SUCCESS The image has been unloaded.\r
	391	@retval EFI_UNSUPPORTED The image has been started, and does not\r
	392	support unload.\r
	393	@retval EFI_INVALID_PARAMETER ImageHandle is not a valid image handle.\r
	394	\r
	395	@return Exit code from the image's unload function.\r
	396	**/\r
	397	EFI_STATUS\r
	398	EFIAPI\r
	399	QemuUnloadKernelImage (\r
ac0a286f	400	IN EFI_HANDLE ImageHandle\r
ddd2be6b AB	401	)\r
ddd2be6b AB	402	{\r
ac0a286f MK	403	EFI_LOADED_IMAGE_PROTOCOL *KernelLoadedImage;\r
ac0a286f MK	404	EFI_STATUS Status;\r
ddd2be6b AB	405	\r
	406	Status = gBS->OpenProtocol (\r
	407	ImageHandle,\r
	408	&gEfiLoadedImageProtocolGuid,\r
	409	(VOID **)&KernelLoadedImage,\r
	410	gImageHandle, // AgentHandle\r
	411	NULL, // ControllerHandle\r
	412	EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
	413	);\r
	414	if (EFI_ERROR (Status)) {\r
	415	return EFI_INVALID_PARAMETER;\r
	416	}\r
	417	\r
	418	if (KernelLoadedImage->LoadOptions != NULL) {\r
	419	FreePool (KernelLoadedImage->LoadOptions);\r
	420	KernelLoadedImage->LoadOptions = NULL;\r
	421	}\r
ac0a286f	422	\r
ddd2be6b AB	423	KernelLoadedImage->LoadOptionsSize = 0;\r
	424	\r
	425	return gBS->UnloadImage (ImageHandle);\r
	426	}\r