efivarstorevfs.cpp@ 90065

Last change on this file since 90065 was 90065, checked in by vboxsync, 4 years ago
Runtime/RTEfi*: Start of a VFS module to access a EFI variable store stored in the NVRAM file to allow changing the firmware config without having the VM running, bugref:9580 [build fix]
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 60.3 KB

Line
1	/* $Id: efivarstorevfs.cpp 90065 2021-07-06 13:10:40Z vboxsync $ */
2	/** @file
3	* IPRT - Expose a EFI variable store as a Virtual Filesystem.
4	*/
5
6	/*
7	* Copyright (C) 2021 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP RTLOGGROUP_FS
32	#include <iprt/efi.h>
33
34	#include <iprt/asm.h>
35	#include <iprt/assert.h>
36	#include <iprt/file.h>
37	#include <iprt/err.h>
38	#include <iprt/log.h>
39	#include <iprt/mem.h>
40	#include <iprt/string.h>
41	#include <iprt/uuid.h>
42	#include <iprt/utf16.h>
43	#include <iprt/vfs.h>
44	#include <iprt/vfslowlevel.h>
45	#include <iprt/formats/efi-fv.h>
46	#include <iprt/formats/efi-varstore.h>
47
48
49	/*********************************************************************************************************************************
50	* Defined Constants And Macros *
51	*********************************************************************************************************************************/
52
53
54	/*********************************************************************************************************************************
55	* Structures and Typedefs *
56	*********************************************************************************************************************************/
57	/** Pointer to the varstore filesystem data. */
58	typedef struct RTEFIVARSTORE *PRTEFIVARSTORE;
59
60
61	/**
62	* EFI variable entry.
63	*/
64	typedef struct RTEFIVAR
65	{
66	/** Pointer to the owning variable store. */
67	PRTEFIVARSTORE pVarStore;
68	/** Offset of the variable header located in the backing image. */
69	uint64_t offVarHdr;
70	/** Offset of the variable data located in the backing image. */
71	uint64_t offVarData;
72	/** The validated variable header. */
73	EFI_AUTH_VAR_HEADER VarHdr;
74	/** Name of the variable. */
75	char *pszName;
76	/** The time creation/update time. */
77	RTTIMESPEC Time;
78	/** The vendor UUID of the variable. */
79	RTUUID Uuid;
80	} RTEFIVAR;
81	/** Pointer to an EFI variable. */
82	typedef RTEFIVAR *PRTEFIVAR;
83
84
85	/**
86	* EFI GUID entry.
87	*/
88	typedef struct RTEFIGUID
89	{
90	/** The UUID rpresentation of the GUID. */
91	RTUUID Uuid;
92	/** Pointer to the array of indices into RTEFIVARSTORE::paVars. */
93	uint32_t *paidxVars;
94	/** Number of valid indices in the array. */
95	uint32_t cVars;
96	/** Maximum number of indices the array can hold. */
97	uint32_t cVarsMax;
98	} RTEFIGUID;
99	/** Pointer to an EFI variable. */
100	typedef RTEFIGUID *PRTEFIGUID;
101
102
103	/**
104	* EFI variable store filesystem volume.
105	*/
106	typedef struct RTEFIVARSTORE
107	{
108	/** Handle to itself. */
109	RTVFS hVfsSelf;
110	/** The file, partition, or whatever backing the volume has. */
111	RTVFSFILE hVfsBacking;
112	/** The size of the backing thingy. */
113	uint64_t cbBacking;
114
115	/** RTVFSMNT_F_XXX. */
116	uint32_t fMntFlags;
117	/** RTEFIVARSTOREVFS_F_XXX (currently none defined). */
118	uint32_t fVarStoreFlags;
119
120	/** Size of the variable store (minus the header). */
121	size_t cbVarStore;
122	/** Start offset into the backing image where the variable data starts. */
123	uint64_t offStoreData;
124	/** Flag whether the variable store uses authenticated variables. */
125	bool fAuth;
126	/** Number of bytes occupied by existing variables. */
127	uint64_t cbVarData;
128
129	/** Pointer to the array of variables sorted by start offset. */
130	PRTEFIVAR paVars;
131	/** Number of valid variables in the array. */
132	uint32_t cVars;
133	/** Maximum number of variables the array can hold. */
134	uint32_t cVarsMax;
135
136	/** Pointer to the array of vendor GUIDS. */
137	PRTEFIGUID paGuids;
138	/** Number of valid GUIDS in the array. */
139	uint32_t cGuids;
140	/** Maximum number of GUIDS the array can hold. */
141	uint32_t cGuidsMax;
142
143	} RTEFIVARSTORE;
144
145
146	/**
147	* Variable store directory type.
148	*/
149	typedef enum RTEFIVARSTOREDIRTYPE
150	{
151	/** Invalid directory type. */
152	RTEFIVARSTOREDIRTYPE_INVALID = 0,
153	/** Root directory type. */
154	RTEFIVARSTOREDIRTYPE_ROOT,
155	/** 'by-name' directory. */
156	RTEFIVARSTOREDIRTYPE_BY_NAME,
157	/** 'by-guid' directory. */
158	RTEFIVARSTOREDIRTYPE_BY_GUID,
159	/** Specific 'by-uuid/{...}' directory. */
160	RTEFIVARSTOREDIRTYPE_GUID,
161	/** 32bit blowup hack. */
162	RTEFIVARSTOREDIRTYPE_32BIT_HACK = 0x7fffffff
163	} RTEFIVARSTOREDIRTYPE;
164
165
166	/**
167	* Variable store directory.
168	*/
169	typedef struct RTEFIVARSTOREDIR
170	{
171	/* Flag whether we reached the end of directory entries. */
172	bool fNoMoreFiles;
173	/** The index of the next item to read. */
174	uint32_t idxNext;
175	/** Type of the directory. */
176	RTEFIVARSTOREDIRTYPE enmType;
177	/** The variable store associated with this directory. */
178	PRTEFIVARSTORE pVarStore;
179	/** Pointer to the GUID entry, only valid for RTEFIVARSTOREDIRTYPE_GUID. */
180	PRTEFIGUID pGuid;
181	/** Time when the directory was created. */
182	RTTIMESPEC Time;
183	} RTEFIVARSTOREDIR;
184	/** Pointer to an Variable store directory. */
185	typedef RTEFIVARSTOREDIR *PRTEFIVARSTOREDIR;
186
187
188	/**
189	* Open file instance.
190	*/
191	typedef struct RTEFIVARFILE
192	{
193	/** Variable store this file belongs to. */
194	PRTEFIVARSTORE pVarStore;
195	/** The underlying variable structure. */
196	PRTEFIVAR pVar;
197	/** Current offset into the file for I/O. */
198	RTFOFF offFile;
199	} RTEFIVARFILE;
200	/** Pointer to an open file instance. */
201	typedef RTEFIVARFILE *PRTEFIVARFILE;
202
203
204	/*********************************************************************************************************************************
205	* Internal Functions *
206	*********************************************************************************************************************************/
207	static int rtEfiVarStore_NewDirByType(PRTEFIVARSTORE pThis, RTEFIVARSTOREDIRTYPE enmDirType, PRTEFIGUID pGuid, PRTVFSOBJ phVfsObj);
208
209
210	#ifdef LOG_ENABLED
211	/**
212	* Logs a firmware volume header.
213	*
214	* @returns nothing.
215	* @param pFvHdr The firmware volume header.
216	*/
217	static void rtEfiVarStoreFvHdr_Log(PCEFI_FIRMWARE_VOLUME_HEADER pFvHdr)
218	{
219	if (LogIs2Enabled())
220	{
221	Log2(("EfiVarStore: Volume Header:\n"));
222	Log2(("EfiVarStore: abZeroVec %#.*Rhxs\n", sizeof(pFvHdr->abZeroVec), &pFvHdr->abZeroVec[0]));
223	Log2(("EfiVarStore: GuidFilesystem %#.*Rhxs\n", sizeof(pFvHdr->GuidFilesystem), &pFvHdr->GuidFilesystem));
224	Log2(("EfiVarStore: cbFv %#RX64\n", RT_LE2H_U64(pFvHdr->cbFv)));
225	Log2(("EfiVarStore: u32Signature %#RX32\n", RT_LE2H_U32(pFvHdr->u32Signature)));
226	Log2(("EfiVarStore: fAttr %#RX32\n", RT_LE2H_U32(pFvHdr->fAttr)));
227	Log2(("EfiVarStore: cbFvHdr %#RX16\n", RT_LE2H_U16(pFvHdr->cbFvHdr)));
228	Log2(("EfiVarStore: u16Chksum %#RX16\n", RT_LE2H_U16(pFvHdr->u16Chksum)));
229	Log2(("EfiVarStore: offExtHdr %#RX16\n", RT_LE2H_U16(pFvHdr->offExtHdr)));
230	Log2(("EfiVarStore: bRsvd %#RX8\n", pFvHdr->bRsvd));
231	Log2(("EfiVarStore: bRevision %#RX8\n", pFvHdr->bRevision));
232	}
233	}
234
235
236	/**
237	* Logs a variable store header.
238	*
239	* @returns nothing.
240	* @param pStoreHdr The variable store header.
241	*/
242	static void rtEfiVarStoreHdr_Log(PCEFI_VARSTORE_HEADER pStoreHdr)
243	{
244	if (LogIs2Enabled())
245	{
246	Log2(("EfiVarStore: Variable Store Header:\n"));
247	Log2(("EfiVarStore: GuidVarStore %#.*Rhxs\n", sizeof(pStoreHdr->GuidVarStore), &pStoreHdr->GuidVarStore));
248	Log2(("EfiVarStore: cbVarStore %#RX32\n", RT_LE2H_U32(pStoreHdr->cbVarStore)));
249	Log2(("EfiVarStore: bFmt %#RX8\n", pStoreHdr->bFmt));
250	Log2(("EfiVarStore: bState %#RX8\n", pStoreHdr->bState));
251	}
252	}
253
254
255	/**
256	* Logs a authenticated variable header.
257	*
258	* @returns nothing.
259	* @param pVarHdr The authenticated variable header.
260	* @param offVar Offset of the authenticated variable header.
261	*/
262	static void rtEfiVarStoreAuthVarHdr_Log(PCEFI_AUTH_VAR_HEADER pVarHdr, uint64_t offVar)
263	{
264	if (LogIs2Enabled())
265	{
266	Log2(("EfiVarStore: Authenticated Variable Header at offset %#RU64:\n", offVar));
267	Log2(("EfiVarStore: u16StartId %#RX16\n", RT_LE2H_U16(pVarHdr->u16StartId)));
268	Log2(("EfiVarStore: bState %#RX8\n", pVarHdr->bState));
269	Log2(("EfiVarStore: bRsvd %#RX8\n", pVarHdr->bRsvd));
270	Log2(("EfiVarStore: fAttr %#RX32\n", RT_LE2H_U32(pVarHdr->fAttr)));
271	Log2(("EfiVarStore: cMonotonic %#RX64\n", RT_LE2H_U64(pVarHdr->cMonotonic)));
272	Log2(("EfiVarStore: Timestamp.u16Year %#RX16\n", RT_LE2H_U16(pVarHdr->Timestamp.u16Year)));
273	Log2(("EfiVarStore: Timestamp.u8Month %#RX8\n", pVarHdr->Timestamp.u8Month));
274	Log2(("EfiVarStore: Timestamp.u8Day %#RX8\n", pVarHdr->Timestamp.u8Day));
275	Log2(("EfiVarStore: Timestamp.u8Hour %#RX8\n", pVarHdr->Timestamp.u8Hour));
276	Log2(("EfiVarStore: Timestamp.u8Minute %#RX8\n", pVarHdr->Timestamp.u8Minute));
277	Log2(("EfiVarStore: Timestamp.u8Second %#RX8\n", pVarHdr->Timestamp.u8Second));
278	Log2(("EfiVarStore: Timestamp.bPad0 %#RX8\n", pVarHdr->Timestamp.bPad0));
279	Log2(("EfiVarStore: Timestamp.u32Nanosecond %#RX32\n", RT_LE2H_U32(pVarHdr->Timestamp.u32Nanosecond)));
280	Log2(("EfiVarStore: Timestamp.iTimezone %#RI16\n", RT_LE2H_S16(pVarHdr->Timestamp.iTimezone)));
281	Log2(("EfiVarStore: Timestamp.u8Daylight %#RX8\n", pVarHdr->Timestamp.u8Daylight));
282	Log2(("EfiVarStore: Timestamp.bPad1 %#RX8\n", pVarHdr->Timestamp.bPad1));
283	Log2(("EfiVarStore: idPubKey %#RX32\n", RT_LE2H_U32(pVarHdr->idPubKey)));
284	Log2(("EfiVarStore: cbName %#RX32\n", RT_LE2H_U32(pVarHdr->cbName)));
285	Log2(("EfiVarStore: cbData %#RX32\n", RT_LE2H_U32(pVarHdr->cbData)));
286	Log2(("EfiVarStore: GuidVendor %#.*Rhxs\n", sizeof(pVarHdr->GuidVendor), &pVarHdr->GuidVendor));
287	}
288	}
289	#endif
290
291
292	/**
293	* Worker for rtEfiVarStoreFile_QueryInfo() and rtEfiVarStoreDir_QueryInfo().
294	*
295	* @returns IPRT status code.
296	* @param cbObject Size of the object in bytes.
297	* @param fIsDir Flag whether the object is a directory or file.
298	* @param pTime The time to use.
299	* @param pObjInfo The FS object information structure to fill in.
300	* @param enmAddAttr What to fill in.
301	*/
302	static int rtEfiVarStore_QueryInfo(uint64_t cbObject, bool fIsDir, PCRTTIMESPEC pTime, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
303	{
304	pObjInfo->cbObject = cbObject;
305	pObjInfo->cbAllocated = cbObject;
306	pObjInfo->AccessTime = *pTime;
307	pObjInfo->ModificationTime = *pTime;
308	pObjInfo->ChangeTime = *pTime;
309	pObjInfo->BirthTime = *pTime;
310	pObjInfo->Attr.fMode = fIsDir
311	? RTFS_TYPE_DIRECTORY \| RTFS_UNIX_ALL_PERMS
312	: RTFS_TYPE_FILE \| RTFS_UNIX_ALL_PERMS;
313	pObjInfo->Attr.enmAdditional = enmAddAttr;
314
315	switch (enmAddAttr)
316	{
317	case RTFSOBJATTRADD_NOTHING: RT_FALL_THRU();
318	case RTFSOBJATTRADD_UNIX:
319	pObjInfo->Attr.u.Unix.uid = NIL_RTUID;
320	pObjInfo->Attr.u.Unix.gid = NIL_RTGID;
321	pObjInfo->Attr.u.Unix.cHardlinks = 1;
322	pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
323	pObjInfo->Attr.u.Unix.INodeId = 0;
324	pObjInfo->Attr.u.Unix.fFlags = 0;
325	pObjInfo->Attr.u.Unix.GenerationId = 0;
326	pObjInfo->Attr.u.Unix.Device = 0;
327	break;
328	case RTFSOBJATTRADD_UNIX_OWNER:
329	pObjInfo->Attr.u.UnixOwner.uid = 0;
330	pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
331	break;
332	case RTFSOBJATTRADD_UNIX_GROUP:
333	pObjInfo->Attr.u.UnixGroup.gid = 0;
334	pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
335	break;
336	case RTFSOBJATTRADD_EASIZE:
337	pObjInfo->Attr.u.EASize.cb = 0;
338	break;
339	default:
340	return VERR_INVALID_PARAMETER;
341	}
342	return VINF_SUCCESS;
343	}
344
345
346	/**
347	* Tries to find and return the GUID entry for the given UUID.
348	*
349	* @returns Pointer to the GUID entry or NULL if not found.
350	* @param pThis The EFI variable store instance.
351	* @param pUuid The UUID to look for.
352	*/
353	static PRTEFIGUID rtEfiVarStore_GetGuid(PRTEFIVARSTORE pThis, PCRTUUID pUuid)
354	{
355	for (uint32_t i = 0; i < pThis->cGuids; i++)
356	if (!RTUuidCompare(&pThis->paGuids[i].Uuid, pUuid))
357	return &pThis->paGuids[i];
358
359	return NULL;
360	}
361
362
363	/**
364	* Adds the given UUID to the array of known GUIDs.
365	*
366	* @returns Pointer to the GUID entry or NULL if out of memory.
367	* @param pThis The EFI variable store instance.
368	* @param pUuid The UUID to add.
369	*/
370	static PRTEFIGUID rtEfiVarStore_AddGuid(PRTEFIVARSTORE pThis, PCRTUUID pUuid)
371	{
372	if (pThis->cGuids == pThis->cGuidsMax)
373	{
374	/* Grow the array. */
375	uint32_t cGuidsMaxNew = pThis->cGuidsMax + 10;
376	PRTEFIGUID paGuidsNew = (PRTEFIGUID)RTMemRealloc(pThis->paGuids, cGuidsMaxNew * sizeof(RTEFIGUID));
377	if (!paGuidsNew)
378	return NULL;
379
380	pThis->paGuids = paGuidsNew;
381	pThis->cGuidsMax = cGuidsMaxNew;
382	}
383
384	PRTEFIGUID pGuid = &pThis->paGuids[pThis->cGuids++];
385	pGuid->Uuid = *pUuid;
386	pGuid->paidxVars = NULL;
387	pGuid->cVars = 0;
388	pGuid->cVarsMax = 0;
389	return pGuid;
390	}
391
392
393	/**
394	* Adds the given variable to the GUID array.
395	*
396	* @returns IPRT status code.
397	* @param pThis The EFI variable store instance.
398	* @param pUuid The UUID of the variable.
399	* @param idVar The variable index into the array.
400	*/
401	static int rtEfiVarStore_AddVarByGuid(PRTEFIVARSTORE pThis, PCRTUUID pUuid, uint32_t idVar)
402	{
403	PRTEFIGUID pGuid = rtEfiVarStore_GetGuid(pThis, pUuid);
404	if (!pGuid)
405	pGuid = rtEfiVarStore_AddGuid(pThis, pUuid);
406
407	if ( pGuid
408	&& pGuid->cVars == pGuid->cVarsMax)
409	{
410	/* Grow the array. */
411	uint32_t cVarsMaxNew = pGuid->cVarsMax + 10;
412	uint32_t paidxVarsNew = (uint32_t )RTMemRealloc(pGuid->paidxVars, cVarsMaxNew * sizeof(uint32_t));
413	if (!paidxVarsNew)
414	return VERR_NO_MEMORY;
415
416	pGuid->paidxVars = paidxVarsNew;
417	pGuid->cVarsMax = cVarsMaxNew;
418	}
419
420	int rc = VINF_SUCCESS;
421	if (pGuid)
422	pGuid->paidxVars[pGuid->cVars++] = idVar;
423	else
424	rc = VERR_NO_MEMORY;
425
426	return rc;
427	}
428
429
430	/*
431	*
432	* File operations.
433	* File operations.
434	* File operations.
435	*
436	*/
437
438	/**
439	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
440	*/
441	static DECLCALLBACK(int) rtEfiVarStoreFile_Close(void *pvThis)
442	{
443	PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
444	LogFlow(("rtEfiVarStoreFile_Close(%p/%p)\n", pThis, pThis->pVar));
445	RT_NOREF(pThis);
446	return VINF_SUCCESS;
447	}
448
449
450	/**
451	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
452	*/
453	static DECLCALLBACK(int) rtEfiVarStoreFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
454	{
455	PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
456	return rtEfiVarStore_QueryInfo(RT_LE2H_U32(pThis->pVar->VarHdr.cbData), false /fIsDir/,
457	&pThis->pVar->Time, pObjInfo, enmAddAttr);
458	}
459
460
461	/**
462	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
463	*/
464	static DECLCALLBACK(int) rtEfiVarStoreFile_Read(void pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t pcbRead)
465	{
466	PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
467	PRTEFIVARSTORE pVarStore = pThis->pVarStore;
468	AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3);
469	RT_NOREF(fBlocking);
470
471	if (off == -1)
472	off = pThis->offFile;
473	else
474	AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3);
475
476	int rc;
477	size_t cbRead = pSgBuf->paSegs[0].cbSeg;
478	size_t cbData = RT_LE2H_U32(pThis->pVar->VarHdr.cbData);
479	size_t cbThisRead = RT_MIN(cbData - off, cbRead);
480	uint64_t offStart = pThis->pVar->offVarData + off;
481	if (!pcbRead)
482	{
483	if (cbThisRead == cbRead)
484	rc = RTVfsFileReadAt(pVarStore->hVfsBacking, offStart, pSgBuf->paSegs[0].pvSeg, cbThisRead, NULL);
485	else
486	rc = VERR_EOF;
487
488	if (RT_SUCCESS(rc))
489	pThis->offFile = off + cbThisRead;
490	Log6(("rtFsEfiVarStore_Read: off=%#RX64 cbSeg=%#x -> %Rrc\n", off, pSgBuf->paSegs[0].cbSeg, rc));
491	}
492	else
493	{
494	if ((uint64_t)off >= cbData)
495	{
496	*pcbRead = 0;
497	rc = VINF_EOF;
498	}
499	else
500	{
501	rc = RTVfsFileReadAt(pVarStore->hVfsBacking, offStart, pSgBuf->paSegs[0].pvSeg, cbThisRead, NULL);
502	if (RT_SUCCESS(rc))
503	{
504	/* Return VINF_EOF if beyond end-of-file. */
505	if (cbThisRead < cbRead)
506	rc = VINF_EOF;
507	pThis->offFile = off + cbThisRead;
508	*pcbRead = cbThisRead;
509	}
510	else
511	*pcbRead = 0;
512	}
513	Log6(("rtFsEfiVarStore_Read: off=%#RX64 cbSeg=%#x -> %Rrc pcbRead=%#x\n", off, pSgBuf->paSegs[0].cbSeg, rc, pcbRead));
514	}
515
516	return rc;
517	}
518
519
520	/**
521	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
522	*/
523	static DECLCALLBACK(int) rtEfiVarStoreFile_Write(void pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t pcbWritten)
524	{
525	RT_NOREF(pvThis, off, pSgBuf, fBlocking, pcbWritten);
526	return VERR_WRITE_PROTECT;
527	}
528
529
530	/**
531	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
532	*/
533	static DECLCALLBACK(int) rtEfiVarStoreFile_Flush(void *pvThis)
534	{
535	RT_NOREF(pvThis);
536	return VINF_SUCCESS;
537	}
538
539
540	/**
541	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
542	*/
543	static DECLCALLBACK(int) rtEfiVarStoreFile_Tell(void *pvThis, PRTFOFF poffActual)
544	{
545	PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
546	*poffActual = pThis->offFile;
547	return VINF_SUCCESS;
548	}
549
550
551	/**
552	* @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
553	*/
554	static DECLCALLBACK(int) rtEfiVarStoreFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
555	{
556	RT_NOREF(pvThis, fMode, fMask);
557	return VERR_WRITE_PROTECT;
558	}
559
560
561	/**
562	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
563	*/
564	static DECLCALLBACK(int) rtEfiVarStoreFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
565	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
566	{
567	RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime);
568	return VERR_WRITE_PROTECT;
569	}
570
571
572	/**
573	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
574	*/
575	static DECLCALLBACK(int) rtEfiVarStoreFile_SetOwner(void *pvThis, RTUID uid, RTGID gid)
576	{
577	RT_NOREF(pvThis, uid, gid);
578	return VERR_WRITE_PROTECT;
579	}
580
581
582	/**
583	* @interface_method_impl{RTVFSFILEOPS,pfnSeek}
584	*/
585	static DECLCALLBACK(int) rtEfiVarStoreFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
586	{
587	PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
588	RTFOFF offNew;
589	switch (uMethod)
590	{
591	case RTFILE_SEEK_BEGIN:
592	offNew = offSeek;
593	break;
594	case RTFILE_SEEK_END:
595	offNew = RT_LE2H_U32(pThis->pVar->VarHdr.cbData) + offSeek;
596	break;
597	case RTFILE_SEEK_CURRENT:
598	offNew = (RTFOFF)pThis->offFile + offSeek;
599	break;
600	default:
601	return VERR_INVALID_PARAMETER;
602	}
603	if (offNew >= 0)
604	{
605	pThis->offFile = offNew;
606	*poffActual = offNew;
607	return VINF_SUCCESS;
608	}
609	return VERR_NEGATIVE_SEEK;
610	}
611
612
613	/**
614	* @interface_method_impl{RTVFSFILEOPS,pfnQuerySize}
615	*/
616	static DECLCALLBACK(int) rtEfiVarStoreFile_QuerySize(void pvThis, uint64_t pcbFile)
617	{
618	PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
619	*pcbFile = (uint64_t)RT_LE2H_U32(pThis->pVar->VarHdr.cbData);
620	return VINF_SUCCESS;
621	}
622
623
624	/**
625	* @interface_method_impl{RTVFSFILEOPS,pfnSetSize}
626	*/
627	static DECLCALLBACK(int) rtEfiVarStoreFile_SetSize(void *pvThis, uint64_t cbFile, uint32_t fFlags)
628	{
629	RT_NOREF(pvThis, cbFile, fFlags);
630	return VERR_WRITE_PROTECT;
631	}
632
633
634	/**
635	* @interface_method_impl{RTVFSFILEOPS,pfnQueryMaxSize}
636	*/
637	static DECLCALLBACK(int) rtEfiVarStoreFile_QueryMaxSize(void pvThis, uint64_t pcbMax)
638	{
639	RT_NOREF(pvThis);
640	pcbMax = INT64_MAX; /* @todo */
641	return VINF_SUCCESS;
642	}
643
644
645	/**
646	* EXT file operations.
647	*/
648	static const RTVFSFILEOPS g_rtEfiVarStoreFileOps =
649	{
650	{ /* Stream */
651	{ /* Obj */
652	RTVFSOBJOPS_VERSION,
653	RTVFSOBJTYPE_FILE,
654	"EFiVarStore File",
655	rtEfiVarStoreFile_Close,
656	rtEfiVarStoreFile_QueryInfo,
657	RTVFSOBJOPS_VERSION
658	},
659	RTVFSIOSTREAMOPS_VERSION,
660	RTVFSIOSTREAMOPS_FEAT_NO_SG,
661	rtEfiVarStoreFile_Read,
662	rtEfiVarStoreFile_Write,
663	rtEfiVarStoreFile_Flush,
664	NULL /PollOne/,
665	rtEfiVarStoreFile_Tell,
666	NULL /pfnSkip/,
667	NULL /pfnZeroFill/,
668	RTVFSIOSTREAMOPS_VERSION,
669	},
670	RTVFSFILEOPS_VERSION,
671	0,
672	{ /* ObjSet */
673	RTVFSOBJSETOPS_VERSION,
674	RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
675	rtEfiVarStoreFile_SetMode,
676	rtEfiVarStoreFile_SetTimes,
677	rtEfiVarStoreFile_SetOwner,
678	RTVFSOBJSETOPS_VERSION
679	},
680	rtEfiVarStoreFile_Seek,
681	rtEfiVarStoreFile_QuerySize,
682	rtEfiVarStoreFile_SetSize,
683	rtEfiVarStoreFile_QueryMaxSize,
684	RTVFSFILEOPS_VERSION
685	};
686
687
688	/**
689	* Creates a new VFS file from the given regular file inode.
690	*
691	* @returns IPRT status code.
692	* @param pThis The ext volume instance.
693	* @param fOpen Open flags passed.
694	* @param iInode The inode for the file.
695	* @param phVfsFile Where to store the VFS file handle on success.
696	* @param pErrInfo Where to record additional error information on error, optional.
697	*/
698	static int rtEfiVarStore_NewFile(PRTEFIVARSTORE pThis, uint64_t fOpen, PRTEFIVAR pVar,
699	PRTVFSOBJ phVfsObj)
700	{
701	RTVFSFILE hVfsFile;
702	PRTEFIVARFILE pNewFile;
703	int rc = RTVfsNewFile(&g_rtEfiVarStoreFileOps, sizeof(*pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK,
704	&hVfsFile, (void **)&pNewFile);
705	if (RT_SUCCESS(rc))
706	{
707	pNewFile->pVarStore = pThis;
708	pNewFile->pVar = pVar;
709	pNewFile->offFile = 0;
710
711	*phVfsObj = RTVfsObjFromFile(hVfsFile);
712	RTVfsFileRelease(hVfsFile);
713	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
714	}
715
716	return rc;
717	}
718
719
720
721	/*
722	*
723	* Directory instance methods
724	* Directory instance methods
725	* Directory instance methods
726	*
727	*/
728
729	/**
730	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
731	*/
732	static DECLCALLBACK(int) rtEfiVarStoreDir_Close(void *pvThis)
733	{
734	PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
735	LogFlowFunc(("pThis=%p\n", pThis));
736	pThis->pVarStore = NULL;
737	return VINF_SUCCESS;
738	}
739
740
741	/**
742	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
743	*/
744	static DECLCALLBACK(int) rtEfiVarStoreDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
745	{
746	PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
747	LogFlowFunc(("\n"));
748	return rtEfiVarStore_QueryInfo(1, true /fIsDir/, &pThis->Time, pObjInfo, enmAddAttr);
749	}
750
751
752	/**
753	* @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
754	*/
755	static DECLCALLBACK(int) rtEfiVarStoreDir_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
756	{
757	LogFlowFunc(("\n"));
758	RT_NOREF(pvThis, fMode, fMask);
759	return VERR_WRITE_PROTECT;
760	}
761
762
763	/**
764	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
765	*/
766	static DECLCALLBACK(int) rtEfiVarStoreDir_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
767	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
768	{
769	LogFlowFunc(("\n"));
770	RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime);
771	return VERR_WRITE_PROTECT;
772	}
773
774
775	/**
776	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
777	*/
778	static DECLCALLBACK(int) rtEfiVarStoreDir_SetOwner(void *pvThis, RTUID uid, RTGID gid)
779	{
780	LogFlowFunc(("\n"));
781	RT_NOREF(pvThis, uid, gid);
782	return VERR_WRITE_PROTECT;
783	}
784
785
786	/**
787	* @interface_method_impl{RTVFSDIROPS,pfnOpen}
788	*/
789	static DECLCALLBACK(int) rtEfiVarStoreDir_Open(void pvThis, const char pszEntry, uint64_t fOpen,
790	uint32_t fFlags, PRTVFSOBJ phVfsObj)
791	{
792	LogFlowFunc(("pszEntry='%s' fOpen=%#RX64 fFlags=%#x\n", pszEntry, fOpen, fFlags));
793	PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
794	PRTEFIVARSTORE pVarStore = pThis->pVarStore;
795	int rc = VINF_SUCCESS;
796
797	/*
798	* Special cases '.' and '.'
799	*/
800	if (pszEntry[0] == '.')
801	{
802	RTEFIVARSTOREDIRTYPE enmDirTypeNew = RTEFIVARSTOREDIRTYPE_INVALID;
803	if (pszEntry[1] == '\0')
804	enmDirTypeNew = pThis->enmType;
805	else if (pszEntry[1] == '.' && pszEntry[2] == '\0')
806	{
807	if ( pThis->enmType == RTEFIVARSTOREDIRTYPE_BY_NAME
808	\|\| pThis->enmType == RTEFIVARSTOREDIRTYPE_BY_GUID
809	\|\| pThis->enmType == RTEFIVARSTOREDIRTYPE_ROOT)
810	enmDirTypeNew = RTEFIVARSTOREDIRTYPE_ROOT;
811	else if (pThis->enmType == RTEFIVARSTOREDIRTYPE_GUID)
812	enmDirTypeNew = RTEFIVARSTOREDIRTYPE_BY_GUID;
813	else
814	AssertMsgFailedReturn(("Invalid directory type %d\n", pThis->enmType), VERR_ACCESS_DENIED);
815	}
816
817	if (enmDirTypeNew != RTEFIVARSTOREDIRTYPE_INVALID)
818	{
819	if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY)
820	{
821	if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
822	\|\| (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE)
823	rc = rtEfiVarStore_NewDirByType(pVarStore, enmDirTypeNew, NULL /pGuid/, phVfsObj);
824	else
825	rc = VERR_ACCESS_DENIED;
826	}
827	else
828	rc = VERR_IS_A_DIRECTORY;
829	return rc;
830	}
831	}
832
833	/*
834	* We cannot create or replace anything, just open stuff.
835	*/
836	if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
837	\|\| (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE)
838	{ /* likely */ }
839	else
840	return VERR_WRITE_PROTECT;
841
842	switch (pThis->enmType)
843	{
844	case RTEFIVARSTOREDIRTYPE_ROOT:
845	{
846	if (!strcmp(pszEntry, "by-name"))
847	return rtEfiVarStore_NewDirByType(pVarStore, RTEFIVARSTOREDIRTYPE_BY_NAME, NULL /pGuid/, phVfsObj);
848	else if (!strcmp(pszEntry, "by-uuid"))
849	return rtEfiVarStore_NewDirByType(pVarStore, RTEFIVARSTOREDIRTYPE_BY_GUID, NULL /pGuid/, phVfsObj);
850	else
851	rc = VERR_FILE_NOT_FOUND;
852	break;
853	}
854	case RTEFIVARSTOREDIRTYPE_GUID: /** @todo This looks through all variables, not only the ones with the GUID. */
855	case RTEFIVARSTOREDIRTYPE_BY_NAME:
856	{
857	/* Look for the name. */
858	for (uint32_t i = 0; i < pVarStore->cVars; i++)
859	if (!strcmp(pszEntry, pVarStore->paVars[i].pszName))
860	return rtEfiVarStore_NewFile(pVarStore, fOpen, &pVarStore->paVars[i], phVfsObj);
861
862	rc = VERR_FILE_NOT_FOUND;
863	break;
864	}
865	case RTEFIVARSTOREDIRTYPE_BY_GUID:
866	{
867	/* Look for the name. */
868	for (uint32_t i = 0; i < pVarStore->cGuids; i++)
869	{
870	PRTEFIGUID pGuid = &pVarStore->paGuids[i];
871	char szUuid[RTUUID_STR_LENGTH];
872	rc = RTUuidToStr(&pGuid->Uuid, szUuid, sizeof(szUuid));
873	AssertRC(rc);
874
875	if (!strcmp(pszEntry, szUuid))
876	return rtEfiVarStore_NewDirByType(pVarStore, RTEFIVARSTOREDIRTYPE_GUID, pGuid, phVfsObj);
877	}
878
879	rc = VERR_FILE_NOT_FOUND;
880	break;
881	}
882	case RTEFIVARSTOREDIRTYPE_INVALID:
883	default:
884	AssertFailedReturn(VERR_INTERNAL_ERROR_3);
885	}
886
887	LogFlow(("rtEfiVarStoreDir_Open(%s): returns %Rrc\n", pszEntry, rc));
888	return rc;
889	}
890
891
892	/**
893	* @interface_method_impl{RTVFSDIROPS,pfnCreateDir}
894	*/
895	static DECLCALLBACK(int) rtEfiVarStoreDir_CreateDir(void pvThis, const char pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir)
896	{
897	RT_NOREF(pvThis, pszSubDir, fMode, phVfsDir);
898	LogFlowFunc(("\n"));
899	return VERR_WRITE_PROTECT;
900	}
901
902
903	/**
904	* @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink}
905	*/
906	static DECLCALLBACK(int) rtEfiVarStoreDir_OpenSymlink(void pvThis, const char pszSymlink, PRTVFSSYMLINK phVfsSymlink)
907	{
908	RT_NOREF(pvThis, pszSymlink, phVfsSymlink);
909	LogFlowFunc(("\n"));
910	return VERR_NOT_SUPPORTED;
911	}
912
913
914	/**
915	* @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink}
916	*/
917	static DECLCALLBACK(int) rtEfiVarStoreDir_CreateSymlink(void pvThis, const char pszSymlink, const char *pszTarget,
918	RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink)
919	{
920	RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink);
921	LogFlowFunc(("\n"));
922	return VERR_WRITE_PROTECT;
923	}
924
925
926	/**
927	* @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry}
928	*/
929	static DECLCALLBACK(int) rtEfiVarStoreDir_UnlinkEntry(void pvThis, const char pszEntry, RTFMODE fType)
930	{
931	RT_NOREF(pvThis, pszEntry, fType);
932	LogFlowFunc(("\n"));
933	return VERR_WRITE_PROTECT;
934	}
935
936
937	/**
938	* @interface_method_impl{RTVFSDIROPS,pfnRenameEntry}
939	*/
940	static DECLCALLBACK(int) rtEfiVarStoreDir_RenameEntry(void pvThis, const char pszEntry, RTFMODE fType, const char *pszNewName)
941	{
942	RT_NOREF(pvThis, pszEntry, fType, pszNewName);
943	LogFlowFunc(("\n"));
944	return VERR_WRITE_PROTECT;
945	}
946
947
948	/**
949	* @interface_method_impl{RTVFSDIROPS,pfnRewindDir}
950	*/
951	static DECLCALLBACK(int) rtEfiVarStoreDir_RewindDir(void *pvThis)
952	{
953	PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
954	LogFlowFunc(("\n"));
955
956	pThis->idxNext = 0;
957	return VINF_SUCCESS;
958	}
959
960
961	/**
962	* @interface_method_impl{RTVFSDIROPS,pfnReadDir}
963	*/
964	static DECLCALLBACK(int) rtEfiVarStoreDir_ReadDir(void pvThis, PRTDIRENTRYEX pDirEntry, size_t pcbDirEntry,
965	RTFSOBJATTRADD enmAddAttr)
966	{
967	PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
968	PRTEFIVARSTORE pVarStore = pThis->pVarStore;
969	LogFlowFunc(("\n"));
970
971	if (pThis->fNoMoreFiles)
972	return VERR_NO_MORE_FILES;
973
974	int rc = VINF_SUCCESS;
975	char aszUuid[RTUUID_STR_LENGTH];
976	const char *pszName = NULL;
977	size_t cbName = 0;
978	uint64_t cbObject = 0;
979	bool fIsDir = false;
980	bool fNoMoreFiles = false;
981	RTTIMESPEC Time;
982	PCRTTIMESPEC pTimeSpec = &Time;
983	RTTimeNow(&Time);
984
985	switch (pThis->enmType)
986	{
987	case RTEFIVARSTOREDIRTYPE_ROOT:
988	{
989	if (pThis->idxNext == 0)
990	{
991	pszName = "by-name";
992	cbName = sizeof("by-name");
993	cbObject = 1;
994	fIsDir = true;
995	}
996	else if (pThis->idxNext == 1)
997	{
998	pszName = "by-uuid";
999	cbName = sizeof("by-uuid");
1000	cbObject = 1;
1001	fIsDir = true;
1002	fNoMoreFiles = true;
1003	}
1004	break;
1005	}
1006	case RTEFIVARSTOREDIRTYPE_BY_NAME:
1007	{
1008	PRTEFIVAR pVar = &pVarStore->paVars[pThis->idxNext];
1009	if (pThis->idxNext + 1 == pVarStore->cVars)
1010	fNoMoreFiles = true;
1011	pszName = pVar->pszName;
1012	cbName = strlen(pszName) + 1;
1013	cbObject = RT_LE2H_U32(pVar->VarHdr.cbData);
1014	pTimeSpec = &pVar->Time;
1015	break;
1016	}
1017	case RTEFIVARSTOREDIRTYPE_BY_GUID:
1018	{
1019	PRTEFIGUID pGuid = &pVarStore->paGuids[pThis->idxNext];
1020	if (pThis->idxNext + 1 == pVarStore->cGuids)
1021	fNoMoreFiles = true;
1022	pszName = &aszUuid[0];
1023	cbName = sizeof(aszUuid);
1024	cbObject = 1;
1025	rc = RTUuidToStr(&pGuid->Uuid, &aszUuid[0], cbName);
1026	AssertRC(rc);
1027	break;
1028	}
1029	case RTEFIVARSTOREDIRTYPE_GUID:
1030	{
1031	PRTEFIGUID pGuid = pThis->pGuid;
1032	uint32_t idVar = pGuid->paidxVars[pThis->idxNext];
1033	PRTEFIVAR pVar = &pVarStore->paVars[idVar];
1034	if (pThis->idxNext + 1 == pGuid->cVars)
1035	fNoMoreFiles = true;
1036	pszName = pVar->pszName;
1037	cbName = strlen(pszName) + 1;
1038	cbObject = RT_LE2H_U32(pVar->VarHdr.cbData);
1039	pTimeSpec = &pVar->Time;
1040	break;
1041	}
1042	case RTEFIVARSTOREDIRTYPE_INVALID:
1043	default:
1044	AssertFailedReturn(VERR_INTERNAL_ERROR_3);
1045	}
1046
1047	if (cbName <= 255)
1048	{
1049	size_t const cbDirEntry = *pcbDirEntry;
1050
1051	*pcbDirEntry = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cbName + 2]);
1052	if (*pcbDirEntry <= cbDirEntry)
1053	{
1054	memcpy(&pDirEntry->szName[0], pszName, cbName);
1055	pDirEntry->szName[cbName] = '\0';
1056	pDirEntry->cbName = (uint16_t)cbName;
1057	rc = rtEfiVarStore_QueryInfo(cbObject, fIsDir, &Time, &pDirEntry->Info, enmAddAttr);
1058	if (RT_SUCCESS(rc))
1059	{
1060	pThis->fNoMoreFiles = fNoMoreFiles;
1061	pThis->idxNext++;
1062	return VINF_SUCCESS;
1063	}
1064	}
1065	else
1066	rc = VERR_BUFFER_OVERFLOW;
1067	}
1068	else
1069	rc = VERR_FILENAME_TOO_LONG;
1070	return rc;
1071	}
1072
1073
1074	/**
1075	* EFI variable store directory operations.
1076	*/
1077	static const RTVFSDIROPS g_rtEfiVarStoreDirOps =
1078	{
1079	{ /* Obj */
1080	RTVFSOBJOPS_VERSION,
1081	RTVFSOBJTYPE_DIR,
1082	"EfiVarStore Dir",
1083	rtEfiVarStoreDir_Close,
1084	rtEfiVarStoreDir_QueryInfo,
1085	RTVFSOBJOPS_VERSION
1086	},
1087	RTVFSDIROPS_VERSION,
1088	0,
1089	{ /* ObjSet */
1090	RTVFSOBJSETOPS_VERSION,
1091	RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
1092	rtEfiVarStoreDir_SetMode,
1093	rtEfiVarStoreDir_SetTimes,
1094	rtEfiVarStoreDir_SetOwner,
1095	RTVFSOBJSETOPS_VERSION
1096	},
1097	rtEfiVarStoreDir_Open,
1098	NULL /* pfnFollowAbsoluteSymlink */,
1099	NULL /* pfnOpenFile */,
1100	NULL /* pfnOpenDir */,
1101	rtEfiVarStoreDir_CreateDir,
1102	rtEfiVarStoreDir_OpenSymlink,
1103	rtEfiVarStoreDir_CreateSymlink,
1104	NULL /* pfnQueryEntryInfo */,
1105	rtEfiVarStoreDir_UnlinkEntry,
1106	rtEfiVarStoreDir_RenameEntry,
1107	rtEfiVarStoreDir_RewindDir,
1108	rtEfiVarStoreDir_ReadDir,
1109	RTVFSDIROPS_VERSION,
1110	};
1111
1112
1113	static int rtEfiVarStore_NewDirByType(PRTEFIVARSTORE pThis, RTEFIVARSTOREDIRTYPE enmDirType, PRTEFIGUID pGuid, PRTVFSOBJ phVfsObj)
1114	{
1115	RTVFSDIR hVfsDir;
1116	PRTEFIVARSTOREDIR pDir;
1117	int rc = RTVfsNewDir(&g_rtEfiVarStoreDirOps, sizeof(pDir), 0 /fFlags*/, pThis->hVfsSelf, NIL_RTVFSLOCK,
1118	&hVfsDir, (void **)&pDir);
1119	if (RT_SUCCESS(rc))
1120	{
1121	pDir->idxNext = 0;
1122	pDir->enmType = enmDirType;
1123	pDir->pVarStore = pThis;
1124	pDir->pGuid = pGuid;
1125	RTTimeNow(&pDir->Time);
1126
1127	*phVfsObj = RTVfsObjFromDir(hVfsDir);
1128	RTVfsDirRelease(hVfsDir);
1129	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
1130	}
1131
1132	return rc;
1133	}
1134
1135
1136	/*
1137	*
1138	* Volume level code.
1139	* Volume level code.
1140	* Volume level code.
1141	*
1142	*/
1143
1144	/**
1145	* @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose}
1146	*/
1147	static DECLCALLBACK(int) rtEfiVarStore_Close(void *pvThis)
1148	{
1149	PRTEFIVARSTORE pThis = (PRTEFIVARSTORE)pvThis;
1150
1151	/*
1152	* Backing file and handles.
1153	*/
1154	RTVfsFileRelease(pThis->hVfsBacking);
1155	pThis->hVfsBacking = NIL_RTVFSFILE;
1156	pThis->hVfsSelf = NIL_RTVFS;
1157	if (pThis->paVars)
1158	{
1159	for (uint32_t i = 0; i < pThis->cVars; i++)
1160	RTStrFree(pThis->paVars[i].pszName);
1161
1162	RTMemFree(pThis->paVars);
1163	pThis->paVars = NULL;
1164	pThis->cVars = 0;
1165	pThis->cVarsMax = 0;
1166	}
1167
1168	if (pThis->paGuids)
1169	{
1170	for (uint32_t i = 0; i < pThis->cGuids; i++)
1171	{
1172	PRTEFIGUID pGuid = &pThis->paGuids[i];
1173
1174	AssertPtr(pGuid->paidxVars);
1175	RTMemFree(pGuid->paidxVars);
1176	pGuid->paidxVars = NULL;
1177	}
1178
1179	RTMemFree(pThis->paGuids);
1180	pThis->paGuids = NULL;
1181	}
1182
1183	return VINF_SUCCESS;
1184	}
1185
1186
1187	/**
1188	* @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo}
1189	*/
1190	static DECLCALLBACK(int) rtEfiVarStore_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
1191	{
1192	RT_NOREF(pvThis, pObjInfo, enmAddAttr);
1193	return VERR_WRONG_TYPE;
1194	}
1195
1196
1197	/**
1198	* @interface_method_impl{RTVFSOBJOPS::Obj,pfnOpenRoot}
1199	*/
1200	static DECLCALLBACK(int) rtEfiVarStore_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir)
1201	{
1202	PRTEFIVARSTORE pThis = (PRTEFIVARSTORE)pvThis;
1203	PRTEFIVARSTOREDIR pRootDir;
1204	int rc = RTVfsNewDir(&g_rtEfiVarStoreDirOps, sizeof(pRootDir), 0 /fFlags*/, pThis->hVfsSelf, NIL_RTVFSLOCK,
1205	phVfsDir, (void **)&pRootDir);
1206	if (RT_SUCCESS(rc))
1207	{
1208	pRootDir->idxNext = 0;
1209	pRootDir->enmType = RTEFIVARSTOREDIRTYPE_ROOT;
1210	pRootDir->pVarStore = pThis;
1211	}
1212
1213	LogFlowFunc(("returns %Rrc\n", rc));
1214	return rc;
1215	}
1216
1217
1218	DECL_HIDDEN_CONST(const RTVFSOPS) g_rtEfiVarStoreOps =
1219	{
1220	/* .Obj = */
1221	{
1222	/* .uVersion = */ RTVFSOBJOPS_VERSION,
1223	/* .enmType = */ RTVFSOBJTYPE_VFS,
1224	/* .pszName = */ "EfiVarStore",
1225	/* .pfnClose = */ rtEfiVarStore_Close,
1226	/* .pfnQueryInfo = */ rtEfiVarStore_QueryInfo,
1227	/* .uEndMarker = */ RTVFSOBJOPS_VERSION
1228	},
1229	/* .uVersion = */ RTVFSOPS_VERSION,
1230	/* .fFeatures = */ 0,
1231	/* .pfnOpenRoot = */ rtEfiVarStore_OpenRoot,
1232	/* .pfnQueryRangeState = */ NULL,
1233	/* .uEndMarker = */ RTVFSOPS_VERSION
1234	};
1235
1236
1237	/**
1238	* Validates the given firmware header.
1239	*
1240	* @returns true if the given header is considered valid, flse otherwise.
1241	* @param pThis The EFI variable store instance.
1242	* @param pFvHdr The firmware volume header to validate.
1243	* @param poffData The offset into the backing where the data area begins.
1244	* @param pErrInfo Where to return additional error info.
1245	*/
1246	static int rtEfiVarStoreFvHdr_Validate(PRTEFIVARSTORE pThis, PCEFI_FIRMWARE_VOLUME_HEADER pFvHdr, uint64_t *poffData,
1247	PRTERRINFO pErrInfo)
1248	{
1249	#ifdef LOG_ENABLED
1250	rtEfiVarStoreFvHdr_Log(pFvHdr);
1251	#endif
1252
1253	EFI_GUID GuidNvData = EFI_VARSTORE_FILESYSTEM_GUID;
1254	if (memcmp(&pFvHdr->GuidFilesystem, &GuidNvData, sizeof(GuidNvData)))
1255	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Filesystem GUID doesn't indicate a variable store");
1256	if (RT_LE2H_U64(pFvHdr->cbFv) > pThis->cbBacking)
1257	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Firmware volume length exceeds size of backing storage (truncated file?)");
1258	/* Signature was already verfied by caller. */
1259	/** @todo Check attributes. */
1260	if (pFvHdr->bRsvd != 0)
1261	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Reserved field of header is not 0");
1262	if (pFvHdr->bRevision != EFI_FIRMWARE_VOLUME_HEADER_REVISION)
1263	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Unexpected revision of the firmware volume header");
1264	if (RT_LE2H_U16(pFvHdr->offExtHdr) != 0)
1265	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Firmware volume header contains unsupported extended headers");
1266
1267	/* Start calculating the checksum of the main header. */
1268	uint16_t u16Chksum = 0;
1269	const uint16_t pu16 = (const uint16_t )pFvHdr;
1270	while (pu16 < (const uint16_t )pFvHdr + (sizeof(pFvHdr) / sizeof(uint16_t)))
1271	u16Chksum += RT_LE2H_U16(*pu16++);
1272
1273	/* Read in the block map and verify it as well. */
1274	uint64_t cbFvVol = 0;
1275	uint16_t cbFvHdr = sizeof(*pFvHdr);
1276	uint64_t offBlockMap = sizeof(*pFvHdr);
1277	for (;;)
1278	{
1279	EFI_FW_BLOCK_MAP BlockMap;
1280	int rc = RTVfsFileReadAt(pThis->hVfsBacking, offBlockMap, &BlockMap, sizeof(BlockMap), NULL);
1281	if (RT_FAILURE(rc))
1282	return RTERRINFO_LOG_SET_F(pErrInfo, rc, "Reading block map entry from %#RX64 failed", offBlockMap);
1283
1284	cbFvHdr += sizeof(BlockMap);
1285	offBlockMap += sizeof(BlockMap);
1286
1287	/* A zero entry denotes the end. */
1288	if ( !RT_LE2H_U32(BlockMap.cBlocks)
1289	&& !RT_LE2H_U32(BlockMap.cbBlock))
1290	break;
1291
1292	cbFvVol += RT_LE2H_U32(BlockMap.cBlocks) * RT_LE2H_U32(BlockMap.cbBlock);
1293
1294	pu16 = (const uint16_t *)&BlockMap;
1295	while (pu16 < (const uint16_t *)&BlockMap + (sizeof(BlockMap) / sizeof(uint16_t)))
1296	u16Chksum += RT_LE2H_U16(*pu16++);
1297	}
1298
1299	*poffData = offBlockMap;
1300
1301	if (u16Chksum)
1302	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Firmware volume header has incorrect checksum");
1303	if (RT_LE2H_U64(pFvHdr->cbFvHdr) != cbFvHdr)
1304	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Unexpected firmware volume header size");
1305
1306	return VINF_SUCCESS;
1307	}
1308
1309
1310	/**
1311	* Validates the given variable store header.
1312	*
1313	* @returns true if the given header is considered valid, false otherwise.
1314	* @param pThis The EFI variable store instance.
1315	* @param pHdr The variable store header to validate.
1316	* @param pfAuth Where to store whether the variable store uses authenticated variables or not.
1317	* @param pErrInfo Where to return additional error info.
1318	*/
1319	static int rtEfiVarStoreHdr_Validate(PRTEFIVARSTORE pThis, PCEFI_VARSTORE_HEADER pHdr, bool *pfAuth, PRTERRINFO pErrInfo)
1320	{
1321	#ifdef LOG_ENABLED
1322	rtEfiVarStoreHdr_Log(pHdr);
1323	#endif
1324
1325	EFI_GUID GuidVarStoreAuth = EFI_VARSTORE_HEADER_GUID_AUTHENTICATED_VARIABLE;
1326	EFI_GUID GuidVarStore = EFI_VARSTORE_HEADER_GUID_VARIABLE;
1327	if (!memcmp(&pHdr->GuidVarStore, &GuidVarStoreAuth, sizeof(GuidVarStoreAuth)))
1328	*pfAuth = true;
1329	else if (!memcmp(&pHdr->GuidVarStore, &GuidVarStore, sizeof(GuidVarStore)))
1330	*pfAuth = false;
1331	else
1332	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable store GUID doesn't indicate a variable store");
1333	if (RT_LE2H_U32(pHdr->cbVarStore) >= pThis->cbBacking)
1334	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable store length exceeds size of backing storage (truncated file?)");
1335	if (pHdr->bFmt != EFI_VARSTORE_HEADER_FMT_FORMATTED)
1336	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable store is not formatted");
1337	if (pHdr->bState != EFI_VARSTORE_HEADER_STATE_HEALTHY)
1338	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable store is not healthy");
1339
1340	return VINF_SUCCESS;
1341	}
1342
1343
1344	/**
1345	* Validates the given authenticate variable header.
1346	*
1347	* @returns true if the given header is considered valid, false otherwise.
1348	* @param pThis The EFI variable store instance.
1349	* @param pVarHdr The variable header to validate.
1350	* @param offVar Offset of the authenticated variable header.
1351	* @param pErrInfo Where to return additional error info.
1352	*/
1353	static int rtEfiVarStoreAuthVar_Validate(PRTEFIVARSTORE pThis, PCEFI_AUTH_VAR_HEADER pVarHdr, uint64_t offVar, PRTERRINFO pErrInfo)
1354	{
1355	#ifdef LOG_ENABLED
1356	rtEfiVarStoreAuthVarHdr_Log(pVarHdr, offVar);
1357	#endif
1358
1359	uint32_t cbName = RT_LE2H_U32(pVarHdr->cbName);
1360	uint32_t cbData = RT_LE2H_U32(pVarHdr->cbData);
1361	uint64_t cbVarMax = pThis->cbBacking - offVar - sizeof(*pVarHdr);
1362	if ( cbVarMax <= cbName
1363	\|\| cbVarMax - cbName <= cbData)
1364	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable exceeds remaining space in store (cbName=%llu cbData=%llu cbVarMax=%llu)",
1365	cbName, cbData, cbVarMax);
1366
1367	return VINF_SUCCESS;
1368	}
1369
1370
1371	/**
1372	* Loads the authenticated variable at the given offset.
1373	*
1374	* @returns IPRT status code.
1375	* @retval VERR_EOF if the end of the store was reached.
1376	* @param pThis The EFI variable store instance.
1377	* @param offVar Offset of the variable to load.
1378	* @param poffVarEnd Where to store the offset pointing to the end of the variable.
1379	* @param fIgnoreDelVars Flag whether to ignore deleted variables.
1380	* @param pErrInfo Where to return additional error info.
1381	*/
1382	static int rtEfiVarStoreLoadAuthVar(PRTEFIVARSTORE pThis, uint64_t offVar, uint64_t *poffVarEnd,
1383	bool fIgnoreDelVars, PRTERRINFO pErrInfo)
1384	{
1385	EFI_AUTH_VAR_HEADER VarHdr;
1386	int rc = RTVfsFileReadAt(pThis->hVfsBacking, offVar, &VarHdr, sizeof(VarHdr), NULL);
1387	if (RT_FAILURE(rc))
1388	return rc;
1389
1390	rc = rtEfiVarStoreAuthVar_Validate(pThis, &VarHdr, offVar, pErrInfo);
1391	if (RT_FAILURE(rc))
1392	return rc;
1393
1394	if (poffVarEnd)
1395	*poffVarEnd = offVar + sizeof(VarHdr) + RT_LE2H_U32(VarHdr.cbData) + RT_LE2H_U32(VarHdr.cbName);
1396
1397	/* Only add complete variables or deleted variables when requested. */
1398	if ( ( fIgnoreDelVars
1399	&& VarHdr.bState != EFI_AUTH_VAR_HEADER_STATE_ADDED)
1400	\|\| VarHdr.bState == EFI_AUTH_VAR_HEADER_STATE_HDR_VALID_ONLY)
1401	return VINF_SUCCESS;
1402
1403	pThis->cbVarData += sizeof(VarHdr) + RT_LE2H_U32(VarHdr.cbData) + RT_LE2H_U32(VarHdr.cbName);
1404
1405	RTUTF16 awchName[128]; RT_ZERO(awchName);
1406	if (RT_LE2H_U32(VarHdr.cbName) > sizeof(awchName) - sizeof(RTUTF16))
1407	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable name is too long (%llu vs. %llu)\n",
1408	RT_LE2H_U32(VarHdr.cbName), sizeof(awchName));
1409
1410	rc = RTVfsFileReadAt(pThis->hVfsBacking, offVar + sizeof(VarHdr), &awchName[0], RT_LE2H_U32(VarHdr.cbName), NULL);
1411	if (RT_FAILURE(rc))
1412	return rc;
1413
1414	Log2(("Variable name '%ls'\n", &awchName[0]));
1415	if (pThis->cVars == pThis->cVarsMax)
1416	{
1417	/* Grow the variable array. */
1418	uint32_t cVarsMaxNew = pThis->cVarsMax + 10;
1419	PRTEFIVAR paVarsNew = (PRTEFIVAR)RTMemRealloc(pThis->paVars, cVarsMaxNew * sizeof(RTEFIVAR));
1420	if (!paVarsNew)
1421	return VERR_NO_MEMORY;
1422
1423	pThis->paVars = paVarsNew;
1424	pThis->cVarsMax = cVarsMaxNew;
1425	}
1426
1427	PRTEFIVAR pVar = &pThis->paVars[pThis->cVars++];
1428	pVar->pVarStore = pThis;
1429	pVar->offVarHdr = offVar;
1430	pVar->offVarData = offVar + sizeof(VarHdr) + RT_LE2H_U32(VarHdr.cbName);
1431	memcpy(&pVar->VarHdr, &VarHdr, sizeof(VarHdr));
1432	if (VarHdr.Timestamp.u8Month)
1433	RTEfiTimeToTimeSpec(&pVar->Time, &VarHdr.Timestamp);
1434	else
1435	RTTimeNow(&pVar->Time);
1436
1437	RTEfiGuidToUuid(&pVar->Uuid, &VarHdr.GuidVendor);
1438
1439	rc = RTUtf16ToUtf8(&awchName[0], &pVar->pszName);
1440	if (RT_FAILURE(rc))
1441	pThis->cVars--;
1442
1443	rc = rtEfiVarStore_AddVarByGuid(pThis, &pVar->Uuid, pThis->cVars - 1);
1444
1445	return rc;
1446	}
1447
1448
1449	/**
1450	* Looks for the next variable starting at the given offset.
1451	*
1452	* @returns IPRT status code.
1453	* @retval VERR_EOF if the end of the store was reached.
1454	* @param pThis The EFI variable store instance.
1455	* @param offStart Where in the image to start looking.
1456	* @param poffVar Where to store the start of the next variable if found.
1457	*/
1458	static int rtEfiVarStoreFindVar(PRTEFIVARSTORE pThis, uint64_t offStart, uint64_t *poffVar)
1459	{
1460	/* Try to find the ID indicating a variable start by loading data in chunks. */
1461	uint64_t offEnd = pThis->offStoreData + pThis->cbVarStore;
1462	while (offStart < offEnd)
1463	{
1464	uint16_t au16Tmp[_1K / sizeof(uint16_t)];
1465	size_t cbThisRead = RT_MIN(sizeof(au16Tmp), offEnd - offStart);
1466	int rc = RTVfsFileReadAt(pThis->hVfsBacking, offStart, &au16Tmp[0], sizeof(au16Tmp), NULL);
1467	if (RT_FAILURE(rc))
1468	return rc;
1469
1470	for (uint32_t i = 0; i < RT_ELEMENTS(au16Tmp); i++)
1471	if (RT_LE2H_U16(au16Tmp[i]) == EFI_AUTH_VAR_HEADER_START)
1472	{
1473	poffVar = offStart + i sizeof(uint16_t);
1474	return VINF_SUCCESS;
1475	}
1476
1477	offStart += cbThisRead;
1478	}
1479
1480	return VERR_EOF;
1481	}
1482
1483
1484	/**
1485	* Loads and parses the superblock of the filesystem.
1486	*
1487	* @returns IPRT status code.
1488	* @param pThis The EFI variable store instance.
1489	* @param pErrInfo Where to return additional error info.
1490	*/
1491	static int rtEfiVarStoreLoad(PRTEFIVARSTORE pThis, PRTERRINFO pErrInfo)
1492	{
1493	int rc = VINF_SUCCESS;
1494	EFI_FIRMWARE_VOLUME_HEADER FvHdr;
1495	rc = RTVfsFileReadAt(pThis->hVfsBacking, 0, &FvHdr, sizeof(FvHdr), NULL);
1496	if (RT_FAILURE(rc))
1497	return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading firmware volume header");
1498
1499	/* Validate the signature. */
1500	if (RT_LE2H_U32(FvHdr.u32Signature) != EFI_FIRMWARE_VOLUME_HEADER_SIGNATURE)
1501	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not a EFI variable store - Signature mismatch: %RX32", RT_LE2H_U16(FvHdr.u32Signature));
1502
1503	uint64_t offData = 0;
1504	rc = rtEfiVarStoreFvHdr_Validate(pThis, &FvHdr, &offData, pErrInfo);
1505	if (RT_FAILURE(rc))
1506	return rc;
1507
1508	EFI_VARSTORE_HEADER StoreHdr;
1509	rc = RTVfsFileReadAt(pThis->hVfsBacking, offData, &StoreHdr, sizeof(StoreHdr), NULL);
1510	if (RT_FAILURE(rc))
1511	return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading variable store header");
1512
1513	rc = rtEfiVarStoreHdr_Validate(pThis, &StoreHdr, &pThis->fAuth, pErrInfo);
1514	if (RT_FAILURE(rc))
1515	return rc;
1516
1517	pThis->offStoreData = offData + sizeof(StoreHdr);
1518	pThis->cbVarStore = RT_LE2H_U32(StoreHdr.cbVarStore) - sizeof(StoreHdr);
1519
1520	/* Go over variables and set up the pointers. */
1521	offData = pThis->offStoreData;
1522	for (;;)
1523	{
1524	uint64_t offVar = 0;
1525
1526	rc = rtEfiVarStoreFindVar(pThis, offData, &offVar);
1527	if (RT_FAILURE(rc))
1528	break;
1529
1530	rc = rtEfiVarStoreLoadAuthVar(pThis, offVar, &offData, true /* fIgnoreDelVars*/, pErrInfo);
1531	if (RT_FAILURE(rc))
1532	break;
1533
1534	/* Align to 16bit boundary. */
1535	offData = RT_ALIGN_64(offData, 2);
1536	} while (RT_SUCCESS(rc));
1537
1538	if (rc == VERR_EOF) /* Reached end of variable store. */
1539	rc = VINF_SUCCESS;
1540
1541	return rc;
1542	}
1543
1544
1545	RTDECL(int) RTEfiVarStoreOpenAsVfs(RTVFSFILE hVfsFileIn, uint32_t fMntFlags, uint32_t fVarStoreFlags, PRTVFS phVfs, PRTERRINFO pErrInfo)
1546	{
1547	AssertPtrReturn(phVfs, VERR_INVALID_POINTER);
1548	AssertReturn(!(fMntFlags & ~RTVFSMNT_F_VALID_MASK), VERR_INVALID_FLAGS);
1549	AssertReturn(!fVarStoreFlags, VERR_INVALID_FLAGS);
1550
1551	uint32_t cRefs = RTVfsFileRetain(hVfsFileIn);
1552	AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
1553
1554	/*
1555	* Create a VFS instance and initialize the data so rtFsExtVol_Close works.
1556	*/
1557	RTVFS hVfs;
1558	PRTEFIVARSTORE pThis;
1559	int rc = RTVfsNew(&g_rtEfiVarStoreOps, sizeof(pThis), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, (void *)&pThis);
1560	if (RT_SUCCESS(rc))
1561	{
1562	pThis->hVfsBacking = hVfsFileIn;
1563	pThis->hVfsSelf = hVfs;
1564	pThis->fMntFlags = fMntFlags;
1565	pThis->fVarStoreFlags = fVarStoreFlags;
1566
1567	rc = RTVfsFileQuerySize(pThis->hVfsBacking, &pThis->cbBacking);
1568	if (RT_SUCCESS(rc))
1569	{
1570	rc = rtEfiVarStoreLoad(pThis, pErrInfo);
1571	if (RT_SUCCESS(rc))
1572	{
1573	*phVfs = hVfs;
1574	return VINF_SUCCESS;
1575	}
1576	}
1577
1578	RTVfsRelease(hVfs);
1579	*phVfs = NIL_RTVFS;
1580	}
1581	else
1582	RTVfsFileRelease(hVfsFileIn);
1583
1584	return rc;
1585	}
1586
1587
1588	RTDECL(int) RTEfiVarStoreCreate(RTVFSFILE hVfsFile, uint64_t offStore, uint64_t cbStore, uint32_t fFlags, uint32_t cbBlock,
1589	PRTERRINFO pErrInfo)
1590	{
1591	RT_NOREF(pErrInfo);
1592
1593	/*
1594	* Validate input.
1595	*/
1596	if (!cbBlock)
1597	cbBlock = 4096;
1598	else
1599	AssertMsgReturn(cbBlock <= 8192 && RT_IS_POWER_OF_TWO(cbBlock),
1600	("cbBlock=%#x\n", cbBlock), VERR_INVALID_PARAMETER);
1601	AssertReturn(!(fFlags & ~RTEFIVARSTORE_CREATE_F_VALID_MASK), VERR_INVALID_FLAGS);
1602
1603	if (!cbStore)
1604	{
1605	uint64_t cbFile;
1606	int rc = RTVfsFileQuerySize(hVfsFile, &cbFile);
1607	AssertRCReturn(rc, rc);
1608	AssertMsgReturn(cbFile > offStore, ("cbFile=%#RX64 offStore=%#RX64\n", cbFile, offStore), VERR_INVALID_PARAMETER);
1609	cbStore = cbFile - offStore;
1610	}
1611	uint32_t const cBlocks = (uint32_t)(cbStore / cbBlock);
1612
1613	EFI_FIRMWARE_VOLUME_HEADER FvHdr; RT_ZERO(FvHdr);
1614	EFI_FW_BLOCK_MAP BlockMap; RT_ZERO(BlockMap);
1615	EFI_VARSTORE_HEADER VarStoreHdr; RT_ZERO(VarStoreHdr);
1616
1617	/* Firmware volume header. */
1618	FvHdr.GuidFilesystem = EFI_VARSTORE_FILESYSTEM_GUID;
1619	FvHdr.cbFv = RT_H2LE_U64(cbStore);
1620	FvHdr.u32Signature = RT_H2LE_U32(EFI_FIRMWARE_VOLUME_HEADER_SIGNATURE);
1621	FvHdr.fAttr = RT_H2LE_U32(0x4feff); /** @todo */
1622	FvHdr.cbFvHdr = RT_H2LE_U16(sizeof(FvHdr) + sizeof(BlockMap));
1623	FvHdr.bRevision = EFI_FIRMWARE_VOLUME_HEADER_REVISION;
1624
1625	/* Start calculating the checksum of the main header. */
1626	uint16_t u16Chksum = 0;
1627	const uint16_t pu16 = (const uint16_t )&FvHdr;
1628	while (pu16 < (const uint16_t *)&FvHdr + (sizeof(FvHdr) / sizeof(uint16_t)))
1629	u16Chksum += RT_LE2H_U16(*pu16++);
1630
1631	/* Block map. */
1632	BlockMap.cbBlock = RT_H2LE_U32(cbBlock);
1633	BlockMap.cBlocks = RT_H2LE_U32(cBlocks);
1634
1635	pu16 = (const uint16_t *)&BlockMap;
1636	while (pu16 < (const uint16_t *)&BlockMap + (sizeof(BlockMap) / sizeof(uint16_t)))
1637	u16Chksum += RT_LE2H_U16(*pu16++);
1638
1639	FvHdr.u16Chksum = RT_H2LE_U16(u16Chksum);
1640
1641	/* Variable store header. */
1642	VarStoreHdr.GuidVarStore = EFI_VARSTORE_HEADER_GUID_AUTHENTICATED_VARIABLE;
1643	VarStoreHdr.cbVarStore = cbStore - sizeof(FvHdr) - sizeof(BlockMap);
1644	VarStoreHdr.bFmt = EFI_VARSTORE_HEADER_FMT_FORMATTED;
1645	VarStoreHdr.bState = EFI_VARSTORE_HEADER_STATE_HEALTHY;
1646
1647	/* Write everything. */
1648	int rc = RTVfsFileWriteAt(hVfsFile, offStore, &FvHdr, sizeof(FvHdr), NULL);
1649	if (RT_SUCCESS(rc))
1650	rc = RTVfsFileWriteAt(hVfsFile, offStore + sizeof(FvHdr), &BlockMap, sizeof(BlockMap), NULL);
1651	if (RT_SUCCESS(rc))
1652	rc = RTVfsFileWriteAt(hVfsFile, offStore + sizeof(FvHdr) + sizeof(BlockMap), &VarStoreHdr, sizeof(VarStoreHdr), NULL);
1653	if (RT_SUCCESS(rc))
1654	{
1655	/* Fill the remainder with 0xff as it would be the case for a real NAND flash device. */
1656	uint8_t abFF[512];
1657	memset(&abFF[0], 0xff, sizeof(abFF));
1658
1659	uint64_t offStart = offStore + sizeof(FvHdr) + sizeof(BlockMap) + sizeof(VarStoreHdr);
1660	uint64_t offEnd = offStore + cbStore;
1661	while ( offStart < offEnd
1662	&& RT_SUCCESS(rc))
1663	{
1664	size_t cbThisWrite = RT_MIN(sizeof(abFF), offEnd - offStart);
1665	rc = RTVfsFileWriteAt(hVfsFile, offStart, &abFF[0], cbThisWrite, NULL);
1666	}
1667	}
1668
1669	/** @todo FTW region. */
1670
1671	return rc;
1672	}
1673
1674
1675	/**
1676	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate}
1677	*/
1678	static DECLCALLBACK(int) rtVfsChainEfiVarStore_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec,
1679	PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo)
1680	{
1681	RT_NOREF(pProviderReg);
1682
1683	/*
1684	* Basic checks.
1685	*/
1686	if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE)
1687	return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE;
1688	if ( pElement->enmType != RTVFSOBJTYPE_VFS
1689	&& pElement->enmType != RTVFSOBJTYPE_DIR)
1690	return VERR_VFS_CHAIN_ONLY_DIR_OR_VFS;
1691	if (pElement->cArgs > 1)
1692	return VERR_VFS_CHAIN_AT_MOST_ONE_ARG;
1693
1694	/*
1695	* Parse the flag if present, save in pElement->uProvider.
1696	*/
1697	bool fReadOnly = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ;
1698	if (pElement->cArgs > 0)
1699	{
1700	const char *psz = pElement->paArgs[0].psz;
1701	if (*psz)
1702	{
1703	if (!strcmp(psz, "ro"))
1704	fReadOnly = true;
1705	else if (!strcmp(psz, "rw"))
1706	fReadOnly = false;
1707	else
1708	{
1709	*poffError = pElement->paArgs[0].offSpec;
1710	return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument");
1711	}
1712	}
1713	}
1714
1715	pElement->uProvider = fReadOnly ? RTVFSMNT_F_READ_ONLY : 0;
1716	return VINF_SUCCESS;
1717	}
1718
1719
1720	/**
1721	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate}
1722	*/
1723	static DECLCALLBACK(int) rtVfsChainEfiVarStore_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec,
1724	PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj,
1725	PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo)
1726	{
1727	RT_NOREF(pProviderReg, pSpec, poffError);
1728
1729	int rc;
1730	RTVFSFILE hVfsFileIn = RTVfsObjToFile(hPrevVfsObj);
1731	if (hVfsFileIn != NIL_RTVFSFILE)
1732	{
1733	RTVFS hVfs;
1734	rc = RTEfiVarStoreOpenAsVfs(hVfsFileIn, (uint32_t)pElement->uProvider, (uint32_t)(pElement->uProvider >> 32), &hVfs, pErrInfo);
1735	RTVfsFileRelease(hVfsFileIn);
1736	if (RT_SUCCESS(rc))
1737	{
1738	*phVfsObj = RTVfsObjFromVfs(hVfs);
1739	RTVfsRelease(hVfs);
1740	if (*phVfsObj != NIL_RTVFSOBJ)
1741	return VINF_SUCCESS;
1742	rc = VERR_VFS_CHAIN_CAST_FAILED;
1743	}
1744	}
1745	else
1746	rc = VERR_VFS_CHAIN_CAST_FAILED;
1747	return rc;
1748	}
1749
1750
1751	/**
1752	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
1753	*/
1754	static DECLCALLBACK(bool) rtVfsChainEfiVarStore_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
1755	PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
1756	PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
1757	{
1758	RT_NOREF(pProviderReg, pSpec, pReuseSpec);
1759	if ( pElement->paArgs[0].uProvider == pReuseElement->paArgs[0].uProvider
1760	\|\| !pReuseElement->paArgs[0].uProvider)
1761	return true;
1762	return false;
1763	}
1764
1765
1766	/** VFS chain element 'efivarstore'. */
1767	static RTVFSCHAINELEMENTREG g_rtVfsChainEfiVarStoreReg =
1768	{
1769	/* uVersion = */ RTVFSCHAINELEMENTREG_VERSION,
1770	/* fReserved = */ 0,
1771	/* pszName = */ "efivarstore",
1772	/* ListEntry = */ { NULL, NULL },
1773	/* pszHelp = */ "Open a EFI variable store, requires a file object on the left side.\n"
1774	"First argument is an optional 'ro' (read-only) or 'rw' (read-write) flag.\n",
1775	/* pfnValidate = */ rtVfsChainEfiVarStore_Validate,
1776	/* pfnInstantiate = */ rtVfsChainEfiVarStore_Instantiate,
1777	/* pfnCanReuseElement = */ rtVfsChainEfiVarStore_CanReuseElement,
1778	/* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION
1779	};
1780
1781	RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainEfiVarStoreReg, rtVfsChainEfiVarStoreReg);
1782

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

source: vbox/trunk/src/VBox/Runtime/common/efi/efivarstorevfs.cpp@ 90065

Download in other formats: