VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/OvmfPkg/Library/GenericQemuLoadImageLib/GenericQemuLoadImageLib.c@ 101291

Last change on this file since 101291 was 101291, checked in by vboxsync, 14 months ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette