VBoxApfsJmpStartDxe.c

Last change on this file was 106061, checked in by vboxsync, 3 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 20.4 KB

Line
1	/* $Id: VBoxApfsJmpStartDxe.c 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* VBoxApfsJmpStartDxe.c - VirtualBox APFS jumpstart driver.
4	*/
5
6	/*
7	* Copyright (C) 2019-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include <Protocol/ComponentName.h>
42	#include <Protocol/ComponentName2.h>
43	#include <Protocol/DriverBinding.h>
44	#include <Protocol/BlockIo.h>
45	#include <Protocol/DiskIo.h>
46	#include <Library/BaseMemoryLib.h>
47	#include <Library/MemoryAllocationLib.h>
48	#include <Library/DebugLib.h>
49	#include <Library/UefiBootServicesTableLib.h>
50	#include <Library/UefiLib.h>
51
52	#define IN_RING0
53	#include <iprt/cdefs.h>
54	#include <iprt/formats/apfs.h>
55
56	/**
57	* Contains the full jump start context being worked on.
58	*/
59	typedef struct
60	{
61	/** Block I/O protocol. */
62	EFI_BLOCK_IO *pBlockIo;
63	/** Disk I/O protocol. */
64	EFI_DISK_IO *pDiskIo;
65	/** Block size. */
66	uint32_t cbBlock;
67	/** Controller handle. */
68	EFI_HANDLE hController;
69	/** APFS UUID. */
70	APFSUUID Uuid;
71	} APFSJMPSTARTCTX;
72	typedef APFSJMPSTARTCTX *PAPFSJMPSTARTCTX;
73	typedef const APFSJMPSTARTCTX *PCAPFSJMPSTARTCTX;
74
75	static EFI_GUID g_ApfsDrvLoadedFromThisControllerGuid = { 0x01aaf8bc, 0x9c37, 0x4dc1,
76	{ 0xb1, 0x68, 0xe9, 0x67, 0xd4, 0x2c, 0x79, 0x25 } };
77
78	typedef struct APFS_DRV_LOADED_INFO
79	{
80	EFI_HANDLE hController;
81	EFI_GUID GuidContainer;
82	} APFS_DRV_LOADED_INFO;
83
84	/** Driver name translation table. */
85	static CONST EFI_UNICODE_STRING_TABLE g_aVBoxApfsJmpStartDriverLangAndNames[] =
86	{
87	{ "eng;en", L"VBox APFS Jumpstart Wrapper Driver" },
88	{ NULL, NULL }
89	};
90
91
92	/*********************************************************************************************************************************
93	* Internal Functions *
94	*********************************************************************************************************************************/
95
96	/**
97	* Reads data from the given offset into the buffer.
98	*
99	* @returns EFI status code.
100	* @param pCtx The jump start context.
101	* @param offRead Where to start reading from.
102	* @param pvBuf Where to read into.
103	* @param cbRead Number of bytes to read.
104	*/
105	static EFI_STATUS vboxApfsJmpStartRead(IN PAPFSJMPSTARTCTX pCtx, IN APFSPADDR offRead, IN void *pvBuf, IN size_t cbRead)
106	{
107	return pCtx->pDiskIo->ReadDisk(pCtx->pDiskIo, pCtx->pBlockIo->Media->MediaId, offRead * pCtx->cbBlock, cbRead, pvBuf);
108	}
109
110	/**
111	* Calculates the fletcher64 checksum of the given APFS block and returns TRUE if it matches the one given in the object header.
112	*
113	* @returns Flag indicating whether the checksum matched.
114	* @param pObjHdr The object header containing the checksum to check against.
115	* @param pvStruct Pointer to the struct to create the checksum of.
116	* @param cbStruct Size of the struct in bytes.
117	*/
118	static BOOLEAN vboxApfsObjPhysIsChksumValid(PCAPFSOBJPHYS pObjHdr, void *pvStruct, size_t cbStruct)
119	{
120	if (cbStruct % sizeof(uint32_t) == 0)
121	{
122	uint32_t pu32Data = (uint32_t )pvStruct + 2; /* Start after the checksum field at the beginning. */
123	size_t cWordsLeft = (cbStruct >> 2) - 2;
124
125	uint64_t u64C0 = 0;
126	uint64_t u64C1 = 0;
127	uint64_t u64ChksumFletcher64 = 0;
128	uint64_t u64Check0 = 0;
129	uint64_t u64Check1 = 0;
130
131	while (cWordsLeft)
132	{
133	u64C0 += (uint64_t)*pu32Data++;
134	u64C0 %= UINT32_C(0xffffffff);
135
136	u64C1 += u64C0;
137	u64C1 %= UINT32_C(0xffffffff);
138
139	cWordsLeft--;
140	}
141
142	u64Check0 = UINT32_C(0xffffffff) - (u64C0 + u64C1) % UINT32_C(0xffffffff);
143	u64Check1 = UINT32_C(0xffffffff) - (u64C0 + u64Check0) % UINT32_C(0xffffffff);
144
145	u64ChksumFletcher64 = (uint64_t)u64Check1 << 32 \| u64Check0;
146	if (!CompareMem(&u64ChksumFletcher64, &pObjHdr->abChkSum[0], sizeof(pObjHdr->abChkSum)))
147	return TRUE;
148	else
149	DEBUG((DEBUG_INFO, "vboxApfsObjPhysIsChksumValid: Checksum mismatch, expected 0x%llx got 0x%llx", u64ChksumFletcher64, (uint64_t )&pObjHdr->abChkSum[0]));
150	}
151	else
152	DEBUG((DEBUG_INFO, "vboxApfsObjPhysIsChksumValid: Structure not a multiple of 32bit\n"));
153
154	return FALSE;
155	}
156
157	/**
158	* Loads and starts the EFI driver contained in the given jump start structure.
159	*
160	* @returns EFI status code.
161	* @param pCtx APFS jump start driver context structure.
162	* @param pJmpStart APFS jump start structure describing the EFI file to load and start.
163	*/
164	static EFI_STATUS vboxApfsJmpStartLoadAndExecEfiDriver(IN PAPFSJMPSTARTCTX pCtx, IN PCAPFSEFIJMPSTART pJmpStart)
165	{
166	PCAPFSPRANGE paExtents = (PCAPFSPRANGE)(pJmpStart + 1);
167	UINTN cbReadLeft = RT_LE2H_U32(pJmpStart->cbEfiFile);
168	EFI_STATUS rc = EFI_SUCCESS;
169
170	void *pvApfsDrv = AllocateZeroPool(cbReadLeft);
171	if (pvApfsDrv)
172	{
173	uint32_t i = 0;
174	uint8_t pbBuf = (uint8_t )pvApfsDrv;
175
176	for (i = 0; i < RT_LE2H_U32(pJmpStart->cExtents) && !EFI_ERROR(rc) && cbReadLeft; i++)
177	{
178	UINTN cbRead = RT_MIN(cbReadLeft, (UINTN)RT_LE2H_U64(paExtents[i].cBlocks) * pCtx->cbBlock);
179
180	rc = vboxApfsJmpStartRead(pCtx, RT_LE2H_U64(paExtents[i].PAddrStart), pbBuf, cbRead);
181	pbBuf += cbRead;
182	cbReadLeft -= cbRead;
183	}
184
185	if (!EFI_ERROR(rc))
186	{
187	/* Retrieve the parent device path. */
188	EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
189
190	rc = gBS->HandleProtocol(pCtx->hController, &gEfiDevicePathProtocolGuid, (VOID **)&ParentDevicePath);
191	if (!EFI_ERROR(rc))
192	{
193	/* Load image and execute it. */
194	EFI_HANDLE hImage;
195
196	rc = gBS->LoadImage(FALSE, gImageHandle, ParentDevicePath,
197	pvApfsDrv, RT_LE2H_U32(pJmpStart->cbEfiFile),
198	&hImage);
199	if (!EFI_ERROR(rc))
200	{
201	/* Try to start the image. */
202	rc = gBS->StartImage(hImage, NULL, NULL);
203	if (!EFI_ERROR(rc))
204	{
205	APFS_DRV_LOADED_INFO pApfsDrvLoadedInfo = (APFS_DRV_LOADED_INFO )AllocatePool (sizeof(APFS_DRV_LOADED_INFO));
206	if (pApfsDrvLoadedInfo)
207	{
208	pApfsDrvLoadedInfo->hController = pCtx->hController;
209	CopyMem(&pApfsDrvLoadedInfo->GuidContainer, &pCtx->Uuid, sizeof(pApfsDrvLoadedInfo->GuidContainer));
210
211	rc = gBS->InstallMultipleProtocolInterfaces(&pCtx->hController, &g_ApfsDrvLoadedFromThisControllerGuid, pApfsDrvLoadedInfo, NULL);
212	if (!EFI_ERROR(rc))
213	{
214	/* Connect the driver with the controller it came from. */
215	EFI_HANDLE ahImage[2];
216
217	ahImage[0] = hImage;
218	ahImage[1] = NULL;
219
220	gBS->ConnectController(pCtx->hController, &ahImage[0], NULL, TRUE);
221	return EFI_SUCCESS;
222	}
223	else
224	{
225	FreePool(pApfsDrvLoadedInfo);
226	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Failed to install APFS driver loaded info protocol with %r\n", rc));
227	}
228	}
229	else
230	{
231	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Failed to allocate %u bytes for the driver loaded structure\n", sizeof(APFS_DRV_LOADED_INFO)));
232	rc = EFI_OUT_OF_RESOURCES;
233	}
234	}
235	else
236	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Starting APFS driver failed with %r\n", rc));
237
238	gBS->UnloadImage(hImage);
239	}
240	else
241	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Loading read image failed with %r\n", rc));
242	}
243	else
244	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Querying device path protocol failed with %r\n", rc));
245	}
246	else
247	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Reading the jump start extents failed with %r\n", rc));
248
249	FreePool(pvApfsDrv);
250	}
251	else
252	{
253	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Failed to allocate %u bytes for the APFS driver image\n", cbReadLeft));
254	rc = EFI_OUT_OF_RESOURCES;
255	}
256
257	return rc;
258	}
259
260	/**
261	* @copydoc EFI_DRIVER_BINDING_SUPPORTED
262	*/
263	static EFI_STATUS EFIAPI
264	VBoxApfsJmpStart_Supported(IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle,
265	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL)
266	{
267	/* Check whether the controller supports the block I/O protocol. */
268	EFI_STATUS rc = gBS->OpenProtocol(ControllerHandle,
269	&gEfiBlockIoProtocolGuid,
270	NULL,
271	This->DriverBindingHandle,
272	ControllerHandle,
273	EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
274	if (EFI_ERROR(rc))
275	return rc;
276
277	rc = gBS->OpenProtocol(ControllerHandle,
278	&gEfiDiskIoProtocolGuid,
279	NULL,
280	This->DriverBindingHandle,
281	ControllerHandle,
282	EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
283	if (EFI_ERROR(rc))
284	return rc;
285
286	return EFI_SUCCESS;
287	}
288
289
290	/**
291	* @copydoc EFI_DRIVER_BINDING_START
292	*/
293	static EFI_STATUS EFIAPI
294	VBoxApfsJmpStart_Start(IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle,
295	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL)
296	{
297	APFSJMPSTARTCTX Ctx;
298
299	/* Check whether the driver was already loaded from this controller. */
300	EFI_STATUS rc = gBS->OpenProtocol(ControllerHandle,
301	&g_ApfsDrvLoadedFromThisControllerGuid,
302	NULL,
303	This->DriverBindingHandle,
304	ControllerHandle,
305	EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
306	if (!EFI_ERROR(rc))
307	return EFI_UNSUPPORTED;
308
309	Ctx.cbBlock = 0; /* Will get filled when the superblock was read (starting at 0 anyway). */
310	Ctx.hController = ControllerHandle;
311
312	rc = gBS->OpenProtocol(ControllerHandle,
313	&gEfiBlockIoProtocolGuid,
314	(void **)&Ctx.pBlockIo,
315	This->DriverBindingHandle,
316	ControllerHandle,
317	EFI_OPEN_PROTOCOL_GET_PROTOCOL);
318	if (!EFI_ERROR(rc))
319	{
320	rc = gBS->OpenProtocol(ControllerHandle,
321	&gEfiDiskIoProtocolGuid,
322	(void **)&Ctx.pDiskIo,
323	This->DriverBindingHandle,
324	ControllerHandle,
325	EFI_OPEN_PROTOCOL_GET_PROTOCOL);
326	if (!EFI_ERROR(rc))
327	{
328	/* Read the NX superblock structure from the first block and verify it. */
329	APFSNXSUPERBLOCK Sb;
330
331	rc = vboxApfsJmpStartRead(&Ctx, 0, &Sb, sizeof(Sb));
332	if ( !EFI_ERROR(rc)
333	&& RT_LE2H_U32(Sb.u32Magic) == APFS_NX_SUPERBLOCK_MAGIC)
334	{
335	uint8_t pbBlock = (uint8_t )AllocateZeroPool(RT_LE2H_U32(Sb.cbBlock));
336
337	if (pbBlock)
338	{
339	PCAPFSNXSUPERBLOCK pSb = (PCAPFSNXSUPERBLOCK)pbBlock;
340
341	/* Read in the complete block (checksums always cover the whole block and not just the structure...). */
342	Ctx.cbBlock = RT_LE2H_U32(Sb.cbBlock);
343
344	rc = vboxApfsJmpStartRead(&Ctx, 0, pbBlock, Ctx.cbBlock);
345	if ( !EFI_ERROR(rc)
346	&& RT_LE2H_U64(Sb.PAddrEfiJmpStart) > 0
347	&& vboxApfsObjPhysIsChksumValid(&pSb->ObjHdr, pbBlock, Ctx.cbBlock))
348	{
349	PCAPFSEFIJMPSTART pJmpStart = (PCAPFSEFIJMPSTART)pbBlock;
350
351	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Found APFS superblock, reading jumpstart structure from %llx\n", RT_LE2H_U64(Sb.PAddrEfiJmpStart)));
352
353	CopyMem(&Ctx.Uuid, &pSb->Uuid, sizeof(Ctx.Uuid));
354
355	rc = vboxApfsJmpStartRead(&Ctx, RT_LE2H_U64(Sb.PAddrEfiJmpStart), pbBlock, Ctx.cbBlock);
356	if ( !EFI_ERROR(rc)
357	&& RT_H2LE_U32(pJmpStart->u32Magic) == APFS_EFIJMPSTART_MAGIC
358	&& RT_H2LE_U32(pJmpStart->u32Version) == APFS_EFIJMPSTART_VERSION
359	&& vboxApfsObjPhysIsChksumValid(&pJmpStart->ObjHdr, pbBlock, Ctx.cbBlock)
360	&& RT_H2LE_U32(pJmpStart->cExtents) <= (Ctx.cbBlock - sizeof(*pJmpStart)) / sizeof(APFSPRANGE))
361	rc = vboxApfsJmpStartLoadAndExecEfiDriver(&Ctx, pJmpStart);
362	else
363	{
364	rc = EFI_UNSUPPORTED;
365	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: The APFS EFI jumpstart structure is invalid\n"));
366	}
367	}
368	else
369	{
370	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Invalid APFS superblock -> no APFS filesystem (%r %x %llx)\n", rc, Sb.u32Magic, Sb.PAddrEfiJmpStart));
371	rc = EFI_UNSUPPORTED;
372	}
373
374	FreePool(pbBlock);
375	}
376	else
377	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Failed to allocate memory for APFS block data (%u bytes)\n", RT_LE2H_U32(Sb.cbBlock)));
378	}
379	else
380	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Invalid APFS superblock -> no APFS filesystem (%r %x)\n", rc, Sb.u32Magic));
381
382	gBS->CloseProtocol(ControllerHandle,
383	&gEfiDiskIoProtocolGuid,
384	This->DriverBindingHandle,
385	ControllerHandle);
386	}
387	else
388	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Opening the Disk I/O protocol failed with %r\n", rc));
389
390	gBS->CloseProtocol(ControllerHandle,
391	&gEfiBlockIoProtocolGuid,
392	This->DriverBindingHandle,
393	ControllerHandle);
394	}
395	else
396	DEBUG((DEBUG_INFO, "VBoxApfsJmpStart: Opening the Block I/O protocol failed with %r\n", rc));
397
398	return rc;
399	}
400
401
402	/**
403	* @copydoc EFI_DRIVER_BINDING_STOP
404	*/
405	static EFI_STATUS EFIAPI
406	VBoxApfsJmpStart_Stop(IN EFI_DRIVER_BINDING_PROTOCOL *This, IN EFI_HANDLE ControllerHandle,
407	IN UINTN NumberOfChildren, IN EFI_HANDLE *ChildHandleBuffer OPTIONAL)
408	{
409	/* EFI_STATUS rc; */
410
411	return EFI_UNSUPPORTED;
412	}
413
414
415	/** @copydoc EFI_COMPONENT_NAME_GET_DRIVER_NAME */
416	static EFI_STATUS EFIAPI
417	VBoxApfsJmpStartCN_GetDriverName(IN EFI_COMPONENT_NAME_PROTOCOL *This,
418	IN CHAR8 Language, OUT CHAR16 *DriverName)
419	{
420	return LookupUnicodeString2(Language,
421	This->SupportedLanguages,
422	&g_aVBoxApfsJmpStartDriverLangAndNames[0],
423	DriverName,
424	TRUE);
425	}
426
427	/** @copydoc EFI_COMPONENT_NAME_GET_CONTROLLER_NAME */
428	static EFI_STATUS EFIAPI
429	VBoxApfsJmpStartCN_GetControllerName(IN EFI_COMPONENT_NAME_PROTOCOL *This,
430	IN EFI_HANDLE ControllerHandle,
431	IN EFI_HANDLE ChildHandle OPTIONAL,
432	IN CHAR8 Language, OUT CHAR16 *ControllerName)
433	{
434	/** @todo try query the protocol from the controller and forward the query. */
435	return EFI_UNSUPPORTED;
436	}
437
438	/** @copydoc EFI_COMPONENT_NAME2_GET_DRIVER_NAME */
439	static EFI_STATUS EFIAPI
440	VBoxApfsJmpStartCN2_GetDriverName(IN EFI_COMPONENT_NAME2_PROTOCOL *This,
441	IN CHAR8 Language, OUT CHAR16 *DriverName)
442	{
443	return LookupUnicodeString2(Language,
444	This->SupportedLanguages,
445	&g_aVBoxApfsJmpStartDriverLangAndNames[0],
446	DriverName,
447	FALSE);
448	}
449
450	/** @copydoc EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME */
451	static EFI_STATUS EFIAPI
452	VBoxApfsJmpStartCN2_GetControllerName(IN EFI_COMPONENT_NAME2_PROTOCOL *This,
453	IN EFI_HANDLE ControllerHandle,
454	IN EFI_HANDLE ChildHandle OPTIONAL,
455	IN CHAR8 Language, OUT CHAR16 *ControllerName)
456	{
457	/** @todo try query the protocol from the controller and forward the query. */
458	return EFI_UNSUPPORTED;
459	}
460
461
462
463	/*********************************************************************************************************************************
464	* Entry point and driver registration *
465	*********************************************************************************************************************************/
466
467	/** EFI Driver Binding Protocol. */
468	static EFI_DRIVER_BINDING_PROTOCOL g_VBoxApfsJmpStartDB =
469	{
470	VBoxApfsJmpStart_Supported,
471	VBoxApfsJmpStart_Start,
472	VBoxApfsJmpStart_Stop,
473	/* .Version = */ 1,
474	/* .ImageHandle = */ NULL,
475	/* .DriverBindingHandle = */ NULL
476	};
477
478	/** EFI Component Name Protocol. */
479	static const EFI_COMPONENT_NAME_PROTOCOL g_VBoxApfsJmpStartCN =
480	{
481	VBoxApfsJmpStartCN_GetDriverName,
482	VBoxApfsJmpStartCN_GetControllerName,
483	"eng"
484	};
485
486	/** EFI Component Name 2 Protocol. */
487	static const EFI_COMPONENT_NAME2_PROTOCOL g_VBoxApfsJmpStartCN2 =
488	{
489	VBoxApfsJmpStartCN2_GetDriverName,
490	VBoxApfsJmpStartCN2_GetControllerName,
491	"en"
492	};
493
494
495	/**
496	* VBoxApfsJmpStart entry point.
497	*
498	* @returns EFI status code.
499	*
500	* @param ImageHandle The image handle.
501	* @param SystemTable The system table pointer.
502	*/
503	EFI_STATUS EFIAPI
504	VBoxApfsjmpStartEntryDxe(IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable)
505	{
506	EFI_STATUS rc;
507	DEBUG((DEBUG_INFO, "VBoxApfsjmpStartEntryDxe\n"));
508
509	rc = EfiLibInstallDriverBindingComponentName2(ImageHandle, SystemTable,
510	&g_VBoxApfsJmpStartDB, ImageHandle,
511	&g_VBoxApfsJmpStartCN, &g_VBoxApfsJmpStartCN2);
512	ASSERT_EFI_ERROR(rc);
513	return rc;
514	}
515
516	EFI_STATUS EFIAPI
517	VBoxApfsjmpStartUnloadDxe(IN EFI_HANDLE ImageHandle)
518	{
519	return EFI_SUCCESS;
520	}
521

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/VBoxPkg/VBoxApfsJmpStartDxe/VBoxApfsJmpStartDxe.c

Download in other formats: