OvmfPkg/Library/X86QemuLoadImageLib/X86QemuLoadImageLib.c

   1 /**  @file
   2   X86 specific implementation of QemuLoadImageLib library class interface
   3   with support for loading mixed mode images and non-EFI stub images
   4
   5   Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
   6   Copyright (c) 2020, ARM Ltd. All rights reserved.<BR>
   7
   8   SPDX-License-Identifier: BSD-2-Clause-Patent
   9 **/
  10
  11 #include <Uefi.h>
  12
  13 #include <Guid/QemuKernelLoaderFsMedia.h>
  14 #include <Library/DebugLib.h>
  15 #include <Library/LoadLinuxLib.h>
  16 #include <Library/MemoryAllocationLib.h>
  17 #include <Library/PrintLib.h>
  18 #include <Library/QemuFwCfgLib.h>
  19 #include <Library/QemuLoadImageLib.h>
  20 #include <Library/UefiBootServicesTableLib.h>
  21 #include <Protocol/DevicePath.h>
  22 #include <Protocol/LoadedImage.h>
  23 #include <Protocol/OvmfLoadedX86LinuxKernel.h>
  24
  25 #pragma pack (1)
  26 typedef struct {
  27   EFI_DEVICE_PATH_PROTOCOL  FilePathHeader;
  28   CHAR16                    FilePath[ARRAY_SIZE (L"kernel")];
  29 } KERNEL_FILE_DEVPATH;
  30
  31 typedef struct {
  32   VENDOR_DEVICE_PATH        VenMediaNode;
  33   KERNEL_FILE_DEVPATH       FileNode;
  34   EFI_DEVICE_PATH_PROTOCOL  EndNode;
  35 } KERNEL_VENMEDIA_FILE_DEVPATH;
  36 #pragma pack ()
  37
  38 STATIC CONST KERNEL_VENMEDIA_FILE_DEVPATH mKernelDevicePath = {
  39   {
  40     {
  41       MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP,
  42       { sizeof (VENDOR_DEVICE_PATH) }
  43     },
  44     QEMU_KERNEL_LOADER_FS_MEDIA_GUID
  45   }, {
  46     {
  47       MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP,
  48       { sizeof (KERNEL_FILE_DEVPATH) }
  49     },
  50     L"kernel",
  51   }, {
  52     END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,
  53     { sizeof (EFI_DEVICE_PATH_PROTOCOL) }
  54   }
  55 };
  56
  57 STATIC
  58 VOID
  59 FreeLegacyImage (
  60   IN  OVMF_LOADED_X86_LINUX_KERNEL *LoadedImage
  61   )
  62 {
  63   if (LoadedImage->SetupBuf != NULL) {
  64     FreePages (LoadedImage->SetupBuf,
  65       EFI_SIZE_TO_PAGES (LoadedImage->SetupSize));
  66   }
  67   if (LoadedImage->KernelBuf != NULL) {
  68     FreePages (LoadedImage->KernelBuf,
  69       EFI_SIZE_TO_PAGES (LoadedImage->KernelInitialSize));
  70   }
  71   if (LoadedImage->CommandLine != NULL) {
  72     FreePages (LoadedImage->CommandLine,
  73       EFI_SIZE_TO_PAGES (LoadedImage->CommandLineSize));
  74   }
  75   if (LoadedImage->InitrdData != NULL) {
  76     FreePages (LoadedImage->InitrdData,
  77       EFI_SIZE_TO_PAGES (LoadedImage->InitrdSize));
  78   }
  79 }
  80
  81 STATIC
  82 EFI_STATUS
  83 QemuLoadLegacyImage (
  84   OUT EFI_HANDLE                  *ImageHandle
  85   )
  86 {
  87   EFI_STATUS                      Status;
  88   UINTN                           KernelSize;
  89   UINTN                           SetupSize;
  90   OVMF_LOADED_X86_LINUX_KERNEL    *LoadedImage;
  91
  92   QemuFwCfgSelectItem (QemuFwCfgItemKernelSize);
  93   KernelSize = (UINTN)QemuFwCfgRead32 ();
  94
  95   QemuFwCfgSelectItem (QemuFwCfgItemKernelSetupSize);
  96   SetupSize = (UINTN)QemuFwCfgRead32 ();
  97
  98   if (KernelSize == 0 || SetupSize == 0) {
  99     DEBUG ((DEBUG_INFO, "qemu -kernel was not used.\n"));
 100     return EFI_NOT_FOUND;
 101   }
 102
 103   LoadedImage = AllocateZeroPool (sizeof (*LoadedImage));
 104   if (LoadedImage == NULL) {
 105     return EFI_OUT_OF_RESOURCES;
 106   }
 107
 108   LoadedImage->SetupSize = SetupSize;
 109   LoadedImage->SetupBuf = LoadLinuxAllocateKernelSetupPages (
 110                             EFI_SIZE_TO_PAGES (LoadedImage->SetupSize));
 111   if (LoadedImage->SetupBuf == NULL) {
 112     DEBUG ((DEBUG_ERROR, "Unable to allocate memory for kernel setup!\n"));
 113     Status = EFI_OUT_OF_RESOURCES;
 114     goto FreeImageDesc;
 115   }
 116
 117   DEBUG ((DEBUG_INFO, "Setup size: 0x%x\n", (UINT32)LoadedImage->SetupSize));
 118   DEBUG ((DEBUG_INFO, "Reading kernel setup image ..."));
 119   QemuFwCfgSelectItem (QemuFwCfgItemKernelSetupData);
 120   QemuFwCfgReadBytes (LoadedImage->SetupSize, LoadedImage->SetupBuf);
 121   DEBUG ((DEBUG_INFO, " [done]\n"));
 122
 123   Status = LoadLinuxCheckKernelSetup (LoadedImage->SetupBuf,
 124              LoadedImage->SetupSize);
 125   if (EFI_ERROR (Status)) {
 126     goto FreeImage;
 127   }
 128
 129   Status = LoadLinuxInitializeKernelSetup (LoadedImage->SetupBuf);
 130   if (EFI_ERROR (Status)) {
 131     goto FreeImage;
 132   }
 133
 134   LoadedImage->KernelInitialSize = LoadLinuxGetKernelSize (
 135                                      LoadedImage->SetupBuf, KernelSize);
 136   if (LoadedImage->KernelInitialSize == 0) {
 137     Status = EFI_UNSUPPORTED;
 138     goto FreeImage;
 139   }
 140
 141   LoadedImage->KernelBuf = LoadLinuxAllocateKernelPages (
 142                              LoadedImage->SetupBuf,
 143                              EFI_SIZE_TO_PAGES (LoadedImage->KernelInitialSize)
 144                              );
 145   if (LoadedImage->KernelBuf == NULL) {
 146     DEBUG ((DEBUG_ERROR, "Unable to allocate memory for kernel!\n"));
 147     Status = EFI_OUT_OF_RESOURCES;
 148     goto FreeImage;
 149   }
 150
 151   DEBUG ((DEBUG_INFO, "Kernel size: 0x%x\n", (UINT32)KernelSize));
 152   DEBUG ((DEBUG_INFO, "Reading kernel image ..."));
 153   QemuFwCfgSelectItem (QemuFwCfgItemKernelData);
 154   QemuFwCfgReadBytes (KernelSize, LoadedImage->KernelBuf);
 155   DEBUG ((DEBUG_INFO, " [done]\n"));
 156
 157   QemuFwCfgSelectItem (QemuFwCfgItemCommandLineSize);
 158   LoadedImage->CommandLineSize = (UINTN)QemuFwCfgRead32 ();
 159
 160   if (LoadedImage->CommandLineSize > 0) {
 161     LoadedImage->CommandLine = LoadLinuxAllocateCommandLinePages (
 162                                  EFI_SIZE_TO_PAGES (
 163                                    LoadedImage->CommandLineSize));
 164     QemuFwCfgSelectItem (QemuFwCfgItemCommandLineData);
 165     QemuFwCfgReadBytes (LoadedImage->CommandLineSize, LoadedImage->CommandLine);
 166   }
 167
 168   Status = LoadLinuxSetCommandLine (LoadedImage->SetupBuf,
 169              LoadedImage->CommandLine);
 170   if (EFI_ERROR (Status)) {
 171     goto FreeImage;
 172   }
 173
 174   QemuFwCfgSelectItem (QemuFwCfgItemInitrdSize);
 175   LoadedImage->InitrdSize = (UINTN)QemuFwCfgRead32 ();
 176
 177   if (LoadedImage->InitrdSize > 0) {
 178     LoadedImage->InitrdData = LoadLinuxAllocateInitrdPages (
 179                                 LoadedImage->SetupBuf,
 180                                 EFI_SIZE_TO_PAGES (LoadedImage->InitrdSize));
 181     DEBUG ((DEBUG_INFO, "Initrd size: 0x%x\n",
 182       (UINT32)LoadedImage->InitrdSize));
 183     DEBUG ((DEBUG_INFO, "Reading initrd image ..."));
 184     QemuFwCfgSelectItem (QemuFwCfgItemInitrdData);
 185     QemuFwCfgReadBytes (LoadedImage->InitrdSize, LoadedImage->InitrdData);
 186     DEBUG ((DEBUG_INFO, " [done]\n"));
 187   }
 188
 189   Status = LoadLinuxSetInitrd (LoadedImage->SetupBuf, LoadedImage->InitrdData,
 190              LoadedImage->InitrdSize);
 191   if (EFI_ERROR (Status)) {
 192     goto FreeImage;
 193   }
 194
 195   *ImageHandle = NULL;
 196   Status = gBS->InstallProtocolInterface (ImageHandle,
 197                   &gOvmfLoadedX86LinuxKernelProtocolGuid, EFI_NATIVE_INTERFACE,
 198                   LoadedImage);
 199   if (EFI_ERROR (Status)) {
 200     goto FreeImage;
 201   }
 202   return EFI_SUCCESS;
 203
 204 FreeImage:
 205   FreeLegacyImage (LoadedImage);
 206 FreeImageDesc:
 207   FreePool (LoadedImage);
 208   return Status;
 209 }
 210
 211 STATIC
 212 EFI_STATUS
 213 QemuStartLegacyImage (
 214   IN  EFI_HANDLE                ImageHandle
 215   )
 216 {
 217   EFI_STATUS                    Status;
 218   OVMF_LOADED_X86_LINUX_KERNEL  *LoadedImage;
 219
 220   Status = gBS->OpenProtocol (
 221                   ImageHandle,
 222                   &gOvmfLoadedX86LinuxKernelProtocolGuid,
 223                   (VOID **)&LoadedImage,
 224                   gImageHandle,                  // AgentHandle
 225                   NULL,                          // ControllerHandle
 226                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 227                   );
 228   if (EFI_ERROR (Status)) {
 229     return EFI_INVALID_PARAMETER;
 230   }
 231
 232   return LoadLinux (LoadedImage->KernelBuf, LoadedImage->SetupBuf);
 233 }
 234
 235 STATIC
 236 EFI_STATUS
 237 QemuUnloadLegacyImage (
 238   IN  EFI_HANDLE          ImageHandle
 239   )
 240 {
 241   EFI_STATUS                    Status;
 242   OVMF_LOADED_X86_LINUX_KERNEL  *LoadedImage;
 243
 244   Status = gBS->OpenProtocol (
 245                   ImageHandle,
 246                   &gOvmfLoadedX86LinuxKernelProtocolGuid,
 247                   (VOID **)&LoadedImage,
 248                   gImageHandle,                  // AgentHandle
 249                   NULL,                          // ControllerHandle
 250                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 251                   );
 252   if (EFI_ERROR (Status)) {
 253     return EFI_INVALID_PARAMETER;
 254   }
 255
 256   Status = gBS->UninstallProtocolInterface (ImageHandle,
 257                   &gOvmfLoadedX86LinuxKernelProtocolGuid, LoadedImage);
 258   ASSERT_EFI_ERROR (Status);
 259
 260   FreeLegacyImage (LoadedImage);
 261   FreePool (LoadedImage);
 262   return EFI_SUCCESS;
 263 }
 264
 265 /**
 266   Download the kernel, the initial ramdisk, and the kernel command line from
 267   QEMU's fw_cfg. The kernel will be instructed via its command line to load
 268   the initrd from the same Simple FileSystem where the kernel was loaded from.
 269
 270   @param[out] ImageHandle       The image handle that was allocated for
 271                                 loading the image
 272
 273   @retval EFI_SUCCESS           The image was loaded successfully.
 274   @retval EFI_NOT_FOUND         Kernel image was not found.
 275   @retval EFI_OUT_OF_RESOURCES  Memory allocation failed.
 276   @retval EFI_PROTOCOL_ERROR    Unterminated kernel command line.
 277
 278   @return                       Error codes from any of the underlying
 279                                 functions.
 280 **/
 281 EFI_STATUS
 282 EFIAPI
 283 QemuLoadKernelImage (
 284   OUT EFI_HANDLE            *ImageHandle
 285   )
 286 {
 287   EFI_STATUS                Status;
 288   EFI_HANDLE                KernelImageHandle;
 289   EFI_LOADED_IMAGE_PROTOCOL *KernelLoadedImage;
 290   UINTN                     CommandLineSize;
 291   CHAR8                     *CommandLine;
 292   UINTN                     InitrdSize;
 293
 294   //
 295   // Load the image. This should call back into the QEMU EFI loader file system.
 296   //
 297   Status = gBS->LoadImage (
 298                   FALSE,                    // BootPolicy: exact match required
 299                   gImageHandle,             // ParentImageHandle
 300                   (EFI_DEVICE_PATH_PROTOCOL *)&mKernelDevicePath,
 301                   NULL,                     // SourceBuffer
 302                   0,                        // SourceSize
 303                   &KernelImageHandle
 304                   );
 305   switch (Status) {
 306   case EFI_SUCCESS:
 307     break;
 308
 309   case EFI_NOT_FOUND:
 310     //
 311     // The image does not exist - no -kernel image was supplied via the
 312     // command line so no point in invoking the legacy fallback
 313     //
 314     return EFI_NOT_FOUND;
 315
 316   case EFI_SECURITY_VIOLATION:
 317     //
 318     // We are running with UEFI secure boot enabled, and the image failed to
 319     // authenticate. For compatibility reasons, we fall back to the legacy
 320     // loader in this case. Since the image has been loaded, we need to unload
 321     // it before proceeding
 322     //
 323     gBS->UnloadImage (KernelImageHandle);
 324     //
 325     // Fall through
 326     //
 327   case EFI_UNSUPPORTED:
 328     //
 329     // The image is not natively supported or cross-type supported. Let's try
 330     // loading it using the loader that parses the bzImage metadata directly.
 331     //
 332     Status = QemuLoadLegacyImage (&KernelImageHandle);
 333     if (EFI_ERROR (Status)) {
 334       DEBUG ((DEBUG_ERROR, "%a: QemuLoadLegacyImage(): %r\n", __FUNCTION__,
 335         Status));
 336       return Status;
 337     }
 338     *ImageHandle = KernelImageHandle;
 339     return EFI_SUCCESS;
 340
 341   default:
 342     DEBUG ((DEBUG_ERROR, "%a: LoadImage(): %r\n", __FUNCTION__, Status));
 343     return Status;
 344   }
 345
 346   //
 347   // Construct the kernel command line.
 348   //
 349   Status = gBS->OpenProtocol (
 350                   KernelImageHandle,
 351                   &gEfiLoadedImageProtocolGuid,
 352                   (VOID **)&KernelLoadedImage,
 353                   gImageHandle,                  // AgentHandle
 354                   NULL,                          // ControllerHandle
 355                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 356                   );
 357   ASSERT_EFI_ERROR (Status);
 358
 359   QemuFwCfgSelectItem (QemuFwCfgItemCommandLineSize);
 360   CommandLineSize = (UINTN)QemuFwCfgRead32 ();
 361
 362   if (CommandLineSize == 0) {
 363     KernelLoadedImage->LoadOptionsSize = 0;
 364   } else {
 365     CommandLine = AllocatePool (CommandLineSize);
 366     if (CommandLine == NULL) {
 367       Status = EFI_OUT_OF_RESOURCES;
 368       goto UnloadImage;
 369     }
 370
 371     QemuFwCfgSelectItem (QemuFwCfgItemCommandLineData);
 372     QemuFwCfgReadBytes (CommandLineSize, CommandLine);
 373
 374     //
 375     // Verify NUL-termination of the command line.
 376     //
 377     if (CommandLine[CommandLineSize - 1] != '\0') {
 378       DEBUG ((DEBUG_ERROR, "%a: kernel command line is not NUL-terminated\n",
 379         __FUNCTION__));
 380       Status = EFI_PROTOCOL_ERROR;
 381       goto FreeCommandLine;
 382     }
 383
 384     //
 385     // Drop the terminating NUL, convert to UTF-16.
 386     //
 387     KernelLoadedImage->LoadOptionsSize = (CommandLineSize - 1) * 2;
 388   }
 389
 390   QemuFwCfgSelectItem (QemuFwCfgItemInitrdSize);
 391   InitrdSize = (UINTN)QemuFwCfgRead32 ();
 392
 393   if (InitrdSize > 0) {
 394     //
 395     // Append ' initrd=initrd' in UTF-16.
 396     //
 397     KernelLoadedImage->LoadOptionsSize += sizeof (L" initrd=initrd") - 2;
 398   }
 399
 400   if (KernelLoadedImage->LoadOptionsSize == 0) {
 401     KernelLoadedImage->LoadOptions = NULL;
 402   } else {
 403     //
 404     // NUL-terminate in UTF-16.
 405     //
 406     KernelLoadedImage->LoadOptionsSize += 2;
 407
 408     KernelLoadedImage->LoadOptions = AllocatePool (
 409                                        KernelLoadedImage->LoadOptionsSize);
 410     if (KernelLoadedImage->LoadOptions == NULL) {
 411       KernelLoadedImage->LoadOptionsSize = 0;
 412       Status = EFI_OUT_OF_RESOURCES;
 413       goto FreeCommandLine;
 414     }
 415
 416     UnicodeSPrintAsciiFormat (
 417       KernelLoadedImage->LoadOptions,
 418       KernelLoadedImage->LoadOptionsSize,
 419       "%a%a",
 420       (CommandLineSize == 0) ?  "" : CommandLine,
 421       (InitrdSize == 0)      ?  "" : " initrd=initrd"
 422       );
 423     DEBUG ((DEBUG_INFO, "%a: command line: \"%s\"\n", __FUNCTION__,
 424       (CHAR16 *)KernelLoadedImage->LoadOptions));
 425   }
 426
 427   *ImageHandle = KernelImageHandle;
 428   return EFI_SUCCESS;
 429
 430 FreeCommandLine:
 431   if (CommandLineSize > 0) {
 432     FreePool (CommandLine);
 433   }
 434 UnloadImage:
 435   gBS->UnloadImage (KernelImageHandle);
 436
 437   return Status;
 438 }
 439
 440 /**
 441   Transfer control to a kernel image loaded with QemuLoadKernelImage ()
 442
 443   @param[in,out]  ImageHandle     Handle of image to be started. May assume a
 444                                   different value on return if the image was
 445                                   reloaded.
 446
 447   @retval EFI_INVALID_PARAMETER   ImageHandle is either an invalid image handle
 448                                   or the image has already been initialized with
 449                                   StartImage
 450   @retval EFI_SECURITY_VIOLATION  The current platform policy specifies that the
 451                                   image should not be started.
 452
 453   @return                         Error codes returned by the started image
 454 **/
 455 EFI_STATUS
 456 EFIAPI
 457 QemuStartKernelImage (
 458   IN  OUT EFI_HANDLE            *ImageHandle
 459   )
 460 {
 461   EFI_STATUS                    Status;
 462   OVMF_LOADED_X86_LINUX_KERNEL  *LoadedImage;
 463
 464   Status = gBS->OpenProtocol (
 465                   *ImageHandle,
 466                   &gOvmfLoadedX86LinuxKernelProtocolGuid,
 467                   (VOID **)&LoadedImage,
 468                   gImageHandle,                  // AgentHandle
 469                   NULL,                          // ControllerHandle
 470                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 471                   );
 472   if (!EFI_ERROR (Status)) {
 473     return QemuStartLegacyImage (*ImageHandle);
 474   }
 475
 476   Status = gBS->StartImage (
 477                   *ImageHandle,
 478                   NULL,              // ExitDataSize
 479                   NULL               // ExitData
 480                   );
 481 #ifdef MDE_CPU_IA32
 482   if (Status == EFI_UNSUPPORTED) {
 483     EFI_HANDLE KernelImageHandle;
 484
 485     //
 486     // On IA32, EFI_UNSUPPORTED means that the image's machine type is X64 while
 487     // we are expecting a IA32 one, and the StartImage () boot service is unable
 488     // to handle it, either because the image does not have the special .compat
 489     // PE/COFF section that Linux specifies for mixed mode capable images, or
 490     // because we are running without the support code for that. So load the
 491     // image again, using the legacy loader, and unload the normally loaded
 492     // image before starting the legacy one.
 493     //
 494     Status = QemuLoadLegacyImage (&KernelImageHandle);
 495     if (EFI_ERROR (Status)) {
 496       //
 497       // Note: no change to (*ImageHandle), the caller will release it.
 498       //
 499       return Status;
 500     }
 501     //
 502     // Swap in the legacy-loaded image.
 503     //
 504     QemuUnloadKernelImage (*ImageHandle);
 505     *ImageHandle = KernelImageHandle;
 506     return QemuStartLegacyImage (KernelImageHandle);
 507   }
 508 #endif
 509   return Status;
 510 }
 511
 512 /**
 513   Unloads an image loaded with QemuLoadKernelImage ().
 514
 515   @param  ImageHandle             Handle that identifies the image to be
 516                                   unloaded.
 517
 518   @retval EFI_SUCCESS             The image has been unloaded.
 519   @retval EFI_UNSUPPORTED         The image has been started, and does not
 520                                   support unload.
 521   @retval EFI_INVALID_PARAMETER   ImageHandle is not a valid image handle.
 522
 523   @return                         Exit code from the image's unload function.
 524 **/
 525 EFI_STATUS
 526 EFIAPI
 527 QemuUnloadKernelImage (
 528   IN  EFI_HANDLE          ImageHandle
 529   )
 530 {
 531   EFI_LOADED_IMAGE_PROTOCOL   *KernelLoadedImage;
 532   EFI_STATUS                  Status;
 533
 534   Status = gBS->OpenProtocol (
 535                   ImageHandle,
 536                   &gEfiLoadedImageProtocolGuid,
 537                   (VOID **)&KernelLoadedImage,
 538                   gImageHandle,                  // AgentHandle
 539                   NULL,                          // ControllerHandle
 540                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 541                   );
 542   if (Status == EFI_UNSUPPORTED) {
 543     //
 544     // The handle exists but does not have an instance of the standard loaded
 545     // image protocol installed on it. Attempt to unload it as a legacy image
 546     // instead.
 547     //
 548     return QemuUnloadLegacyImage (ImageHandle);
 549   }
 550
 551   if (EFI_ERROR (Status)) {
 552     return EFI_INVALID_PARAMETER;
 553   }
 554
 555   //
 556   // We are unloading a normal, non-legacy loaded image, either on behalf of
 557   // an external caller, or called from QemuStartKernelImage() on IA32, while
 558   // switching from the normal to the legacy method to load and start a X64
 559   // image.
 560   //
 561   if (KernelLoadedImage->LoadOptions != NULL) {
 562     FreePool (KernelLoadedImage->LoadOptions);
 563     KernelLoadedImage->LoadOptions = NULL;
 564   }
 565   KernelLoadedImage->LoadOptionsSize = 0;
 566
 567   return gBS->UnloadImage (ImageHandle);
 568 }