[90061] | 1 | /* $Id: efivarstorevfs.cpp 103412 2024-02-19 07:13:29Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * IPRT - Expose a EFI variable store as a Virtual Filesystem.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2021-2023 Oracle and/or its affiliates.
|
---|
[90061] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
[90061] | 11 | *
|
---|
[96407] | 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 | *
|
---|
[90061] | 25 | * The contents of this file may alternatively be used under the terms
|
---|
| 26 | * of the Common Development and Distribution License Version 1.0
|
---|
[96407] | 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
|
---|
[90061] | 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.
|
---|
[96407] | 33 | *
|
---|
| 34 | * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
|
---|
[90061] | 35 | */
|
---|
| 36 |
|
---|
| 37 |
|
---|
| 38 | /*********************************************************************************************************************************
|
---|
| 39 | * Header Files *
|
---|
| 40 | *********************************************************************************************************************************/
|
---|
| 41 | #define LOG_GROUP RTLOGGROUP_FS
|
---|
| 42 | #include <iprt/efi.h>
|
---|
| 43 |
|
---|
| 44 | #include <iprt/asm.h>
|
---|
| 45 | #include <iprt/assert.h>
|
---|
[91497] | 46 | #include <iprt/crc.h>
|
---|
[90061] | 47 | #include <iprt/file.h>
|
---|
| 48 | #include <iprt/err.h>
|
---|
| 49 | #include <iprt/log.h>
|
---|
| 50 | #include <iprt/mem.h>
|
---|
| 51 | #include <iprt/string.h>
|
---|
| 52 | #include <iprt/uuid.h>
|
---|
| 53 | #include <iprt/utf16.h>
|
---|
| 54 | #include <iprt/vfs.h>
|
---|
| 55 | #include <iprt/vfslowlevel.h>
|
---|
| 56 | #include <iprt/formats/efi-fv.h>
|
---|
| 57 | #include <iprt/formats/efi-varstore.h>
|
---|
| 58 |
|
---|
| 59 |
|
---|
| 60 | /*********************************************************************************************************************************
|
---|
| 61 | * Defined Constants And Macros *
|
---|
| 62 | *********************************************************************************************************************************/
|
---|
| 63 |
|
---|
| 64 |
|
---|
| 65 | /*********************************************************************************************************************************
|
---|
| 66 | * Structures and Typedefs *
|
---|
| 67 | *********************************************************************************************************************************/
|
---|
| 68 | /** Pointer to the varstore filesystem data. */
|
---|
| 69 | typedef struct RTEFIVARSTORE *PRTEFIVARSTORE;
|
---|
| 70 |
|
---|
| 71 |
|
---|
| 72 | /**
|
---|
| 73 | * EFI variable entry.
|
---|
| 74 | */
|
---|
| 75 | typedef struct RTEFIVAR
|
---|
| 76 | {
|
---|
| 77 | /** Pointer to the owning variable store. */
|
---|
| 78 | PRTEFIVARSTORE pVarStore;
|
---|
[90114] | 79 | /** Offset of the variable data located in the backing image - 0 if not written yet. */
|
---|
[90061] | 80 | uint64_t offVarData;
|
---|
[90125] | 81 | /** Pointer to the in memory data, NULL if not yet read. */
|
---|
| 82 | void *pvData;
|
---|
[90114] | 83 | /** Monotonic counter value. */
|
---|
| 84 | uint64_t cMonotonic;
|
---|
| 85 | /** Size of the variable data in bytes. */
|
---|
| 86 | uint32_t cbData;
|
---|
| 87 | /** Index of the assoicated public key. */
|
---|
| 88 | uint32_t idPubKey;
|
---|
| 89 | /** Attributes for the variable. */
|
---|
| 90 | uint32_t fAttr;
|
---|
[90133] | 91 | /** Flag whether the variable was deleted. */
|
---|
| 92 | bool fDeleted;
|
---|
[90061] | 93 | /** Name of the variable. */
|
---|
| 94 | char *pszName;
|
---|
[90114] | 95 | /** The raw EFI timestamp as read from the header. */
|
---|
| 96 | EFI_TIME EfiTimestamp;
|
---|
| 97 | /** The creation/update time. */
|
---|
[90061] | 98 | RTTIMESPEC Time;
|
---|
| 99 | /** The vendor UUID of the variable. */
|
---|
| 100 | RTUUID Uuid;
|
---|
| 101 | } RTEFIVAR;
|
---|
| 102 | /** Pointer to an EFI variable. */
|
---|
| 103 | typedef RTEFIVAR *PRTEFIVAR;
|
---|
| 104 |
|
---|
| 105 |
|
---|
| 106 | /**
|
---|
| 107 | * EFI GUID entry.
|
---|
| 108 | */
|
---|
| 109 | typedef struct RTEFIGUID
|
---|
| 110 | {
|
---|
[90114] | 111 | /** The UUID representation of the GUID. */
|
---|
[90061] | 112 | RTUUID Uuid;
|
---|
| 113 | /** Pointer to the array of indices into RTEFIVARSTORE::paVars. */
|
---|
| 114 | uint32_t *paidxVars;
|
---|
| 115 | /** Number of valid indices in the array. */
|
---|
| 116 | uint32_t cVars;
|
---|
| 117 | /** Maximum number of indices the array can hold. */
|
---|
| 118 | uint32_t cVarsMax;
|
---|
| 119 | } RTEFIGUID;
|
---|
| 120 | /** Pointer to an EFI variable. */
|
---|
| 121 | typedef RTEFIGUID *PRTEFIGUID;
|
---|
| 122 |
|
---|
| 123 |
|
---|
| 124 | /**
|
---|
| 125 | * EFI variable store filesystem volume.
|
---|
| 126 | */
|
---|
| 127 | typedef struct RTEFIVARSTORE
|
---|
| 128 | {
|
---|
| 129 | /** Handle to itself. */
|
---|
| 130 | RTVFS hVfsSelf;
|
---|
| 131 | /** The file, partition, or whatever backing the volume has. */
|
---|
| 132 | RTVFSFILE hVfsBacking;
|
---|
| 133 | /** The size of the backing thingy. */
|
---|
| 134 | uint64_t cbBacking;
|
---|
| 135 |
|
---|
| 136 | /** RTVFSMNT_F_XXX. */
|
---|
| 137 | uint32_t fMntFlags;
|
---|
| 138 | /** RTEFIVARSTOREVFS_F_XXX (currently none defined). */
|
---|
| 139 | uint32_t fVarStoreFlags;
|
---|
| 140 |
|
---|
| 141 | /** Size of the variable store (minus the header). */
|
---|
[90114] | 142 | uint64_t cbVarStore;
|
---|
[90061] | 143 | /** Start offset into the backing image where the variable data starts. */
|
---|
| 144 | uint64_t offStoreData;
|
---|
| 145 | /** Flag whether the variable store uses authenticated variables. */
|
---|
| 146 | bool fAuth;
|
---|
| 147 | /** Number of bytes occupied by existing variables. */
|
---|
| 148 | uint64_t cbVarData;
|
---|
| 149 |
|
---|
| 150 | /** Pointer to the array of variables sorted by start offset. */
|
---|
| 151 | PRTEFIVAR paVars;
|
---|
| 152 | /** Number of valid variables in the array. */
|
---|
| 153 | uint32_t cVars;
|
---|
| 154 | /** Maximum number of variables the array can hold. */
|
---|
| 155 | uint32_t cVarsMax;
|
---|
| 156 |
|
---|
| 157 | /** Pointer to the array of vendor GUIDS. */
|
---|
| 158 | PRTEFIGUID paGuids;
|
---|
| 159 | /** Number of valid GUIDS in the array. */
|
---|
| 160 | uint32_t cGuids;
|
---|
| 161 | /** Maximum number of GUIDS the array can hold. */
|
---|
| 162 | uint32_t cGuidsMax;
|
---|
| 163 |
|
---|
| 164 | } RTEFIVARSTORE;
|
---|
| 165 |
|
---|
| 166 |
|
---|
| 167 | /**
|
---|
| 168 | * Variable store directory type.
|
---|
| 169 | */
|
---|
| 170 | typedef enum RTEFIVARSTOREDIRTYPE
|
---|
| 171 | {
|
---|
| 172 | /** Invalid directory type. */
|
---|
| 173 | RTEFIVARSTOREDIRTYPE_INVALID = 0,
|
---|
| 174 | /** Root directory type. */
|
---|
| 175 | RTEFIVARSTOREDIRTYPE_ROOT,
|
---|
| 176 | /** 'by-name' directory. */
|
---|
| 177 | RTEFIVARSTOREDIRTYPE_BY_NAME,
|
---|
[90114] | 178 | /** 'by-uuid' directory. */
|
---|
[90061] | 179 | RTEFIVARSTOREDIRTYPE_BY_GUID,
|
---|
[90114] | 180 | /** 'raw' directory. */
|
---|
| 181 | RTEFIVARSTOREDIRTYPE_RAW,
|
---|
[90061] | 182 | /** Specific 'by-uuid/{...}' directory. */
|
---|
| 183 | RTEFIVARSTOREDIRTYPE_GUID,
|
---|
[90114] | 184 | /** Specific 'raw/{...}' directory. */
|
---|
| 185 | RTEFIVARSTOREDIRTYPE_RAW_ENTRY,
|
---|
[90061] | 186 | /** 32bit blowup hack. */
|
---|
| 187 | RTEFIVARSTOREDIRTYPE_32BIT_HACK = 0x7fffffff
|
---|
| 188 | } RTEFIVARSTOREDIRTYPE;
|
---|
| 189 |
|
---|
| 190 |
|
---|
| 191 | /**
|
---|
[90343] | 192 | * EFI variable store directory entry.
|
---|
| 193 | */
|
---|
| 194 | typedef struct RTEFIVARSTOREDIRENTRY
|
---|
| 195 | {
|
---|
| 196 | /** Name of the directory if constant. */
|
---|
| 197 | const char *pszName;
|
---|
| 198 | /** Size of the name. */
|
---|
| 199 | size_t cbName;
|
---|
| 200 | /** Entry type. */
|
---|
| 201 | RTEFIVARSTOREDIRTYPE enmType;
|
---|
| 202 | /** Parent entry type. */
|
---|
| 203 | RTEFIVARSTOREDIRTYPE enmParentType;
|
---|
| 204 | } RTEFIVARSTOREDIRENTRY;
|
---|
| 205 | /** Pointer to a EFI variable store directory entry. */
|
---|
| 206 | typedef RTEFIVARSTOREDIRENTRY *PRTEFIVARSTOREDIRENTRY;
|
---|
| 207 | /** Pointer to a const EFI variable store directory entry. */
|
---|
| 208 | typedef const RTEFIVARSTOREDIRENTRY *PCRTEFIVARSTOREDIRENTRY;
|
---|
| 209 |
|
---|
| 210 |
|
---|
| 211 | /**
|
---|
[90061] | 212 | * Variable store directory.
|
---|
| 213 | */
|
---|
| 214 | typedef struct RTEFIVARSTOREDIR
|
---|
| 215 | {
|
---|
| 216 | /* Flag whether we reached the end of directory entries. */
|
---|
| 217 | bool fNoMoreFiles;
|
---|
| 218 | /** The index of the next item to read. */
|
---|
| 219 | uint32_t idxNext;
|
---|
[90343] | 220 | /** Directory entry. */
|
---|
| 221 | PCRTEFIVARSTOREDIRENTRY pEntry;
|
---|
[90061] | 222 | /** The variable store associated with this directory. */
|
---|
| 223 | PRTEFIVARSTORE pVarStore;
|
---|
[90114] | 224 | /** Time when the directory was created. */
|
---|
| 225 | RTTIMESPEC Time;
|
---|
[90061] | 226 | /** Pointer to the GUID entry, only valid for RTEFIVARSTOREDIRTYPE_GUID. */
|
---|
| 227 | PRTEFIGUID pGuid;
|
---|
[90114] | 228 | /** The variable ID, only valid for RTEFIVARSTOREDIRTYPE_RAW_ENTRY. */
|
---|
| 229 | uint32_t idVar;
|
---|
[90061] | 230 | } RTEFIVARSTOREDIR;
|
---|
| 231 | /** Pointer to an Variable store directory. */
|
---|
| 232 | typedef RTEFIVARSTOREDIR *PRTEFIVARSTOREDIR;
|
---|
| 233 |
|
---|
| 234 |
|
---|
| 235 | /**
|
---|
[90114] | 236 | * File type.
|
---|
| 237 | */
|
---|
| 238 | typedef enum RTEFIVARSTOREFILETYPE
|
---|
| 239 | {
|
---|
| 240 | /** Invalid type, do not use. */
|
---|
| 241 | RTEFIVARSTOREFILETYPE_INVALID = 0,
|
---|
| 242 | /** File accesses the data portion of the variable. */
|
---|
| 243 | RTEFIVARSTOREFILETYPE_DATA,
|
---|
| 244 | /** File accesses the attributes of the variable. */
|
---|
| 245 | RTEFIVARSTOREFILETYPE_ATTR,
|
---|
| 246 | /** File accesses the UUID of the variable. */
|
---|
| 247 | RTEFIVARSTOREFILETYPE_UUID,
|
---|
| 248 | /** File accesses the public key index of the variable. */
|
---|
| 249 | RTEFIVARSTOREFILETYPE_PUBKEY,
|
---|
| 250 | /** File accesses the raw EFI Time of the variable. */
|
---|
| 251 | RTEFIVARSTOREFILETYPE_TIME,
|
---|
| 252 | /** The monotonic counter (deprecated). */
|
---|
| 253 | RTEFIVARSTOREFILETYPE_MONOTONIC,
|
---|
| 254 | /** 32bit hack. */
|
---|
[90116] | 255 | RTEFIVARSTOREFILETYPE_32BIT_HACK = 0x7fffffff
|
---|
[90114] | 256 | } RTEFIVARSTOREFILETYPE;
|
---|
| 257 |
|
---|
| 258 |
|
---|
| 259 | /**
|
---|
| 260 | * Raw file type entry.
|
---|
| 261 | */
|
---|
| 262 | typedef struct RTEFIVARSTOREFILERAWENTRY
|
---|
| 263 | {
|
---|
| 264 | /** Name of the entry. */
|
---|
| 265 | const char *pszName;
|
---|
| 266 | /** The associated file type. */
|
---|
| 267 | RTEFIVARSTOREFILETYPE enmType;
|
---|
| 268 | /** File size of the object, 0 if dynamic. */
|
---|
| 269 | size_t cbObject;
|
---|
| 270 | /** Offset of the item in the variable header. */
|
---|
| 271 | uint32_t offObject;
|
---|
| 272 | } RTEFIVARSTOREFILERAWENTRY;
|
---|
| 273 | /** Pointer to a raw file type entry. */
|
---|
| 274 | typedef RTEFIVARSTOREFILERAWENTRY *PRTEFIVARSTOREFILERAWENTRY;
|
---|
| 275 | /** Pointer to a const file type entry. */
|
---|
| 276 | typedef const RTEFIVARSTOREFILERAWENTRY *PCRTEFIVARSTOREFILERAWENTRY;
|
---|
| 277 |
|
---|
| 278 |
|
---|
| 279 | /**
|
---|
[90061] | 280 | * Open file instance.
|
---|
| 281 | */
|
---|
| 282 | typedef struct RTEFIVARFILE
|
---|
| 283 | {
|
---|
[90114] | 284 | /** The file type. */
|
---|
| 285 | PCRTEFIVARSTOREFILERAWENTRY pEntry;
|
---|
[90061] | 286 | /** Variable store this file belongs to. */
|
---|
[90114] | 287 | PRTEFIVARSTORE pVarStore;
|
---|
[90061] | 288 | /** The underlying variable structure. */
|
---|
[90114] | 289 | PRTEFIVAR pVar;
|
---|
[90061] | 290 | /** Current offset into the file for I/O. */
|
---|
[90114] | 291 | RTFOFF offFile;
|
---|
[90061] | 292 | } RTEFIVARFILE;
|
---|
| 293 | /** Pointer to an open file instance. */
|
---|
| 294 | typedef RTEFIVARFILE *PRTEFIVARFILE;
|
---|
| 295 |
|
---|
| 296 |
|
---|
[90114] | 297 | /**
|
---|
[90343] | 298 | * Directories.
|
---|
| 299 | */
|
---|
| 300 | static const RTEFIVARSTOREDIRENTRY g_aDirs[] =
|
---|
| 301 | {
|
---|
| 302 | { NULL, 0, RTEFIVARSTOREDIRTYPE_ROOT, RTEFIVARSTOREDIRTYPE_ROOT },
|
---|
| 303 | { RT_STR_TUPLE("by-name"), RTEFIVARSTOREDIRTYPE_BY_NAME, RTEFIVARSTOREDIRTYPE_ROOT },
|
---|
| 304 | { RT_STR_TUPLE("by-uuid"), RTEFIVARSTOREDIRTYPE_BY_GUID, RTEFIVARSTOREDIRTYPE_ROOT },
|
---|
| 305 | { RT_STR_TUPLE("raw"), RTEFIVARSTOREDIRTYPE_RAW, RTEFIVARSTOREDIRTYPE_ROOT },
|
---|
| 306 | { NULL, 0, RTEFIVARSTOREDIRTYPE_GUID, RTEFIVARSTOREDIRTYPE_BY_GUID },
|
---|
| 307 | { NULL, 0, RTEFIVARSTOREDIRTYPE_RAW_ENTRY, RTEFIVARSTOREDIRTYPE_RAW },
|
---|
| 308 | };
|
---|
| 309 |
|
---|
| 310 |
|
---|
| 311 | /**
|
---|
[90114] | 312 | * Raw files for accessing specific items in the variable header.
|
---|
| 313 | */
|
---|
| 314 | static const RTEFIVARSTOREFILERAWENTRY g_aRawFiles[] =
|
---|
| 315 | {
|
---|
| 316 | { "attr", RTEFIVARSTOREFILETYPE_ATTR, sizeof(uint32_t), RT_UOFFSETOF(RTEFIVAR, fAttr) },
|
---|
| 317 | { "data", RTEFIVARSTOREFILETYPE_DATA, 0, 0 },
|
---|
| 318 | { "uuid", RTEFIVARSTOREFILETYPE_UUID, sizeof(RTUUID), RT_UOFFSETOF(RTEFIVAR, Uuid) },
|
---|
| 319 | { "pubkey", RTEFIVARSTOREFILETYPE_PUBKEY, sizeof(uint32_t), RT_UOFFSETOF(RTEFIVAR, idPubKey) },
|
---|
| 320 | { "time", RTEFIVARSTOREFILETYPE_TIME, sizeof(EFI_TIME), RT_UOFFSETOF(RTEFIVAR, EfiTimestamp) },
|
---|
| 321 | { "monotonic", RTEFIVARSTOREFILETYPE_MONOTONIC, sizeof(uint64_t), RT_UOFFSETOF(RTEFIVAR, cMonotonic) }
|
---|
| 322 | };
|
---|
| 323 |
|
---|
| 324 | #define RTEFIVARSTORE_FILE_ENTRY_DATA 1
|
---|
| 325 |
|
---|
| 326 |
|
---|
[90061] | 327 | /*********************************************************************************************************************************
|
---|
| 328 | * Internal Functions *
|
---|
| 329 | *********************************************************************************************************************************/
|
---|
[90114] | 330 | static int rtEfiVarStore_NewDirByType(PRTEFIVARSTORE pThis, RTEFIVARSTOREDIRTYPE enmDirType,
|
---|
| 331 | PRTEFIGUID pGuid, uint32_t idVar, PRTVFSOBJ phVfsObj);
|
---|
[90061] | 332 |
|
---|
| 333 |
|
---|
| 334 | #ifdef LOG_ENABLED
|
---|
[99739] | 335 |
|
---|
[90061] | 336 | /**
|
---|
| 337 | * Logs a firmware volume header.
|
---|
| 338 | *
|
---|
| 339 | * @param pFvHdr The firmware volume header.
|
---|
| 340 | */
|
---|
| 341 | static void rtEfiVarStoreFvHdr_Log(PCEFI_FIRMWARE_VOLUME_HEADER pFvHdr)
|
---|
| 342 | {
|
---|
| 343 | if (LogIs2Enabled())
|
---|
| 344 | {
|
---|
| 345 | Log2(("EfiVarStore: Volume Header:\n"));
|
---|
| 346 | Log2(("EfiVarStore: abZeroVec %#.*Rhxs\n", sizeof(pFvHdr->abZeroVec), &pFvHdr->abZeroVec[0]));
|
---|
| 347 | Log2(("EfiVarStore: GuidFilesystem %#.*Rhxs\n", sizeof(pFvHdr->GuidFilesystem), &pFvHdr->GuidFilesystem));
|
---|
| 348 | Log2(("EfiVarStore: cbFv %#RX64\n", RT_LE2H_U64(pFvHdr->cbFv)));
|
---|
| 349 | Log2(("EfiVarStore: u32Signature %#RX32\n", RT_LE2H_U32(pFvHdr->u32Signature)));
|
---|
| 350 | Log2(("EfiVarStore: fAttr %#RX32\n", RT_LE2H_U32(pFvHdr->fAttr)));
|
---|
| 351 | Log2(("EfiVarStore: cbFvHdr %#RX16\n", RT_LE2H_U16(pFvHdr->cbFvHdr)));
|
---|
| 352 | Log2(("EfiVarStore: u16Chksum %#RX16\n", RT_LE2H_U16(pFvHdr->u16Chksum)));
|
---|
| 353 | Log2(("EfiVarStore: offExtHdr %#RX16\n", RT_LE2H_U16(pFvHdr->offExtHdr)));
|
---|
| 354 | Log2(("EfiVarStore: bRsvd %#RX8\n", pFvHdr->bRsvd));
|
---|
| 355 | Log2(("EfiVarStore: bRevision %#RX8\n", pFvHdr->bRevision));
|
---|
| 356 | }
|
---|
| 357 | }
|
---|
| 358 |
|
---|
| 359 |
|
---|
| 360 | /**
|
---|
| 361 | * Logs a variable store header.
|
---|
| 362 | *
|
---|
| 363 | * @param pStoreHdr The variable store header.
|
---|
| 364 | */
|
---|
| 365 | static void rtEfiVarStoreHdr_Log(PCEFI_VARSTORE_HEADER pStoreHdr)
|
---|
| 366 | {
|
---|
| 367 | if (LogIs2Enabled())
|
---|
| 368 | {
|
---|
| 369 | Log2(("EfiVarStore: Variable Store Header:\n"));
|
---|
| 370 | Log2(("EfiVarStore: GuidVarStore %#.*Rhxs\n", sizeof(pStoreHdr->GuidVarStore), &pStoreHdr->GuidVarStore));
|
---|
| 371 | Log2(("EfiVarStore: cbVarStore %#RX32\n", RT_LE2H_U32(pStoreHdr->cbVarStore)));
|
---|
| 372 | Log2(("EfiVarStore: bFmt %#RX8\n", pStoreHdr->bFmt));
|
---|
| 373 | Log2(("EfiVarStore: bState %#RX8\n", pStoreHdr->bState));
|
---|
| 374 | }
|
---|
| 375 | }
|
---|
| 376 |
|
---|
| 377 |
|
---|
| 378 | /**
|
---|
| 379 | * Logs a authenticated variable header.
|
---|
| 380 | *
|
---|
| 381 | * @param pVarHdr The authenticated variable header.
|
---|
| 382 | * @param offVar Offset of the authenticated variable header.
|
---|
| 383 | */
|
---|
| 384 | static void rtEfiVarStoreAuthVarHdr_Log(PCEFI_AUTH_VAR_HEADER pVarHdr, uint64_t offVar)
|
---|
| 385 | {
|
---|
| 386 | if (LogIs2Enabled())
|
---|
| 387 | {
|
---|
| 388 | Log2(("EfiVarStore: Authenticated Variable Header at offset %#RU64:\n", offVar));
|
---|
| 389 | Log2(("EfiVarStore: u16StartId %#RX16\n", RT_LE2H_U16(pVarHdr->u16StartId)));
|
---|
| 390 | Log2(("EfiVarStore: bState %#RX8\n", pVarHdr->bState));
|
---|
| 391 | Log2(("EfiVarStore: bRsvd %#RX8\n", pVarHdr->bRsvd));
|
---|
| 392 | Log2(("EfiVarStore: fAttr %#RX32\n", RT_LE2H_U32(pVarHdr->fAttr)));
|
---|
| 393 | Log2(("EfiVarStore: cMonotonic %#RX64\n", RT_LE2H_U64(pVarHdr->cMonotonic)));
|
---|
| 394 | Log2(("EfiVarStore: Timestamp.u16Year %#RX16\n", RT_LE2H_U16(pVarHdr->Timestamp.u16Year)));
|
---|
| 395 | Log2(("EfiVarStore: Timestamp.u8Month %#RX8\n", pVarHdr->Timestamp.u8Month));
|
---|
| 396 | Log2(("EfiVarStore: Timestamp.u8Day %#RX8\n", pVarHdr->Timestamp.u8Day));
|
---|
| 397 | Log2(("EfiVarStore: Timestamp.u8Hour %#RX8\n", pVarHdr->Timestamp.u8Hour));
|
---|
| 398 | Log2(("EfiVarStore: Timestamp.u8Minute %#RX8\n", pVarHdr->Timestamp.u8Minute));
|
---|
| 399 | Log2(("EfiVarStore: Timestamp.u8Second %#RX8\n", pVarHdr->Timestamp.u8Second));
|
---|
| 400 | Log2(("EfiVarStore: Timestamp.bPad0 %#RX8\n", pVarHdr->Timestamp.bPad0));
|
---|
| 401 | Log2(("EfiVarStore: Timestamp.u32Nanosecond %#RX32\n", RT_LE2H_U32(pVarHdr->Timestamp.u32Nanosecond)));
|
---|
| 402 | Log2(("EfiVarStore: Timestamp.iTimezone %#RI16\n", RT_LE2H_S16(pVarHdr->Timestamp.iTimezone)));
|
---|
| 403 | Log2(("EfiVarStore: Timestamp.u8Daylight %#RX8\n", pVarHdr->Timestamp.u8Daylight));
|
---|
| 404 | Log2(("EfiVarStore: Timestamp.bPad1 %#RX8\n", pVarHdr->Timestamp.bPad1));
|
---|
| 405 | Log2(("EfiVarStore: idPubKey %#RX32\n", RT_LE2H_U32(pVarHdr->idPubKey)));
|
---|
| 406 | Log2(("EfiVarStore: cbName %#RX32\n", RT_LE2H_U32(pVarHdr->cbName)));
|
---|
| 407 | Log2(("EfiVarStore: cbData %#RX32\n", RT_LE2H_U32(pVarHdr->cbData)));
|
---|
| 408 | Log2(("EfiVarStore: GuidVendor %#.*Rhxs\n", sizeof(pVarHdr->GuidVendor), &pVarHdr->GuidVendor));
|
---|
| 409 | }
|
---|
| 410 | }
|
---|
| 411 |
|
---|
[99739] | 412 | #endif /* LOG_ENABLED */
|
---|
[90061] | 413 |
|
---|
| 414 | /**
|
---|
| 415 | * Worker for rtEfiVarStoreFile_QueryInfo() and rtEfiVarStoreDir_QueryInfo().
|
---|
| 416 | *
|
---|
| 417 | * @returns IPRT status code.
|
---|
| 418 | * @param cbObject Size of the object in bytes.
|
---|
| 419 | * @param fIsDir Flag whether the object is a directory or file.
|
---|
| 420 | * @param pTime The time to use.
|
---|
| 421 | * @param pObjInfo The FS object information structure to fill in.
|
---|
| 422 | * @param enmAddAttr What to fill in.
|
---|
| 423 | */
|
---|
| 424 | static int rtEfiVarStore_QueryInfo(uint64_t cbObject, bool fIsDir, PCRTTIMESPEC pTime, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
|
---|
| 425 | {
|
---|
| 426 | pObjInfo->cbObject = cbObject;
|
---|
| 427 | pObjInfo->cbAllocated = cbObject;
|
---|
| 428 | pObjInfo->AccessTime = *pTime;
|
---|
| 429 | pObjInfo->ModificationTime = *pTime;
|
---|
| 430 | pObjInfo->ChangeTime = *pTime;
|
---|
| 431 | pObjInfo->BirthTime = *pTime;
|
---|
| 432 | pObjInfo->Attr.fMode = fIsDir
|
---|
[90125] | 433 | ? RTFS_TYPE_DIRECTORY | RTFS_UNIX_ALL_ACCESS_PERMS
|
---|
| 434 | : RTFS_TYPE_FILE | RTFS_UNIX_IWOTH | RTFS_UNIX_IROTH
|
---|
| 435 | | RTFS_UNIX_IWGRP | RTFS_UNIX_IRGRP
|
---|
| 436 | | RTFS_UNIX_IWUSR | RTFS_UNIX_IRUSR;
|
---|
[90061] | 437 | pObjInfo->Attr.enmAdditional = enmAddAttr;
|
---|
| 438 |
|
---|
| 439 | switch (enmAddAttr)
|
---|
| 440 | {
|
---|
| 441 | case RTFSOBJATTRADD_NOTHING: RT_FALL_THRU();
|
---|
| 442 | case RTFSOBJATTRADD_UNIX:
|
---|
| 443 | pObjInfo->Attr.u.Unix.uid = NIL_RTUID;
|
---|
| 444 | pObjInfo->Attr.u.Unix.gid = NIL_RTGID;
|
---|
| 445 | pObjInfo->Attr.u.Unix.cHardlinks = 1;
|
---|
| 446 | pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
|
---|
| 447 | pObjInfo->Attr.u.Unix.INodeId = 0;
|
---|
| 448 | pObjInfo->Attr.u.Unix.fFlags = 0;
|
---|
| 449 | pObjInfo->Attr.u.Unix.GenerationId = 0;
|
---|
| 450 | pObjInfo->Attr.u.Unix.Device = 0;
|
---|
| 451 | break;
|
---|
| 452 | case RTFSOBJATTRADD_UNIX_OWNER:
|
---|
| 453 | pObjInfo->Attr.u.UnixOwner.uid = 0;
|
---|
| 454 | pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
|
---|
| 455 | break;
|
---|
| 456 | case RTFSOBJATTRADD_UNIX_GROUP:
|
---|
| 457 | pObjInfo->Attr.u.UnixGroup.gid = 0;
|
---|
| 458 | pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
|
---|
| 459 | break;
|
---|
| 460 | case RTFSOBJATTRADD_EASIZE:
|
---|
| 461 | pObjInfo->Attr.u.EASize.cb = 0;
|
---|
| 462 | break;
|
---|
| 463 | default:
|
---|
| 464 | return VERR_INVALID_PARAMETER;
|
---|
| 465 | }
|
---|
| 466 | return VINF_SUCCESS;
|
---|
| 467 | }
|
---|
| 468 |
|
---|
| 469 |
|
---|
| 470 | /**
|
---|
| 471 | * Tries to find and return the GUID entry for the given UUID.
|
---|
| 472 | *
|
---|
| 473 | * @returns Pointer to the GUID entry or NULL if not found.
|
---|
| 474 | * @param pThis The EFI variable store instance.
|
---|
| 475 | * @param pUuid The UUID to look for.
|
---|
| 476 | */
|
---|
| 477 | static PRTEFIGUID rtEfiVarStore_GetGuid(PRTEFIVARSTORE pThis, PCRTUUID pUuid)
|
---|
| 478 | {
|
---|
| 479 | for (uint32_t i = 0; i < pThis->cGuids; i++)
|
---|
| 480 | if (!RTUuidCompare(&pThis->paGuids[i].Uuid, pUuid))
|
---|
| 481 | return &pThis->paGuids[i];
|
---|
| 482 |
|
---|
| 483 | return NULL;
|
---|
| 484 | }
|
---|
| 485 |
|
---|
| 486 |
|
---|
| 487 | /**
|
---|
| 488 | * Adds the given UUID to the array of known GUIDs.
|
---|
| 489 | *
|
---|
| 490 | * @returns Pointer to the GUID entry or NULL if out of memory.
|
---|
| 491 | * @param pThis The EFI variable store instance.
|
---|
| 492 | * @param pUuid The UUID to add.
|
---|
| 493 | */
|
---|
| 494 | static PRTEFIGUID rtEfiVarStore_AddGuid(PRTEFIVARSTORE pThis, PCRTUUID pUuid)
|
---|
| 495 | {
|
---|
| 496 | if (pThis->cGuids == pThis->cGuidsMax)
|
---|
| 497 | {
|
---|
| 498 | /* Grow the array. */
|
---|
| 499 | uint32_t cGuidsMaxNew = pThis->cGuidsMax + 10;
|
---|
| 500 | PRTEFIGUID paGuidsNew = (PRTEFIGUID)RTMemRealloc(pThis->paGuids, cGuidsMaxNew * sizeof(RTEFIGUID));
|
---|
| 501 | if (!paGuidsNew)
|
---|
| 502 | return NULL;
|
---|
| 503 |
|
---|
| 504 | pThis->paGuids = paGuidsNew;
|
---|
| 505 | pThis->cGuidsMax = cGuidsMaxNew;
|
---|
| 506 | }
|
---|
| 507 |
|
---|
| 508 | PRTEFIGUID pGuid = &pThis->paGuids[pThis->cGuids++];
|
---|
| 509 | pGuid->Uuid = *pUuid;
|
---|
| 510 | pGuid->paidxVars = NULL;
|
---|
| 511 | pGuid->cVars = 0;
|
---|
| 512 | pGuid->cVarsMax = 0;
|
---|
| 513 | return pGuid;
|
---|
| 514 | }
|
---|
| 515 |
|
---|
| 516 |
|
---|
| 517 | /**
|
---|
| 518 | * Adds the given variable to the GUID array.
|
---|
| 519 | *
|
---|
| 520 | * @returns IPRT status code.
|
---|
| 521 | * @param pThis The EFI variable store instance.
|
---|
| 522 | * @param pUuid The UUID of the variable.
|
---|
| 523 | * @param idVar The variable index into the array.
|
---|
| 524 | */
|
---|
| 525 | static int rtEfiVarStore_AddVarByGuid(PRTEFIVARSTORE pThis, PCRTUUID pUuid, uint32_t idVar)
|
---|
| 526 | {
|
---|
| 527 | PRTEFIGUID pGuid = rtEfiVarStore_GetGuid(pThis, pUuid);
|
---|
| 528 | if (!pGuid)
|
---|
| 529 | pGuid = rtEfiVarStore_AddGuid(pThis, pUuid);
|
---|
| 530 |
|
---|
| 531 | if ( pGuid
|
---|
| 532 | && pGuid->cVars == pGuid->cVarsMax)
|
---|
| 533 | {
|
---|
| 534 | /* Grow the array. */
|
---|
| 535 | uint32_t cVarsMaxNew = pGuid->cVarsMax + 10;
|
---|
| 536 | uint32_t *paidxVarsNew = (uint32_t *)RTMemRealloc(pGuid->paidxVars, cVarsMaxNew * sizeof(uint32_t));
|
---|
| 537 | if (!paidxVarsNew)
|
---|
| 538 | return VERR_NO_MEMORY;
|
---|
| 539 |
|
---|
| 540 | pGuid->paidxVars = paidxVarsNew;
|
---|
| 541 | pGuid->cVarsMax = cVarsMaxNew;
|
---|
| 542 | }
|
---|
| 543 |
|
---|
| 544 | int rc = VINF_SUCCESS;
|
---|
| 545 | if (pGuid)
|
---|
| 546 | pGuid->paidxVars[pGuid->cVars++] = idVar;
|
---|
| 547 | else
|
---|
| 548 | rc = VERR_NO_MEMORY;
|
---|
| 549 |
|
---|
| 550 | return rc;
|
---|
| 551 | }
|
---|
| 552 |
|
---|
| 553 |
|
---|
[90114] | 554 | /**
|
---|
| 555 | * Reads variable data from the given memory area.
|
---|
[90061] | 556 | *
|
---|
[90114] | 557 | * @returns IPRT status code.
|
---|
| 558 | * @param pThis The EFI variable file instance.
|
---|
[100908] | 559 | * @param pbData Pointer to the start of the data.
|
---|
[90114] | 560 | * @param cbData Size of the variable data in bytes.
|
---|
| 561 | * @param off Where to start reading relative from the data start offset.
|
---|
| 562 | * @param pSgBuf Where to store the read data.
|
---|
| 563 | * @param pcbRead Where to return the number of bytes read, optional.
|
---|
[90061] | 564 | */
|
---|
[100908] | 565 | static int rtEfiVarStoreFile_ReadMem(PRTEFIVARFILE pThis, const uint8_t *pbData, size_t cbData,
|
---|
| 566 | RTFOFF off, PRTSGBUF pSgBuf, size_t *pcbRead)
|
---|
[90061] | 567 | {
|
---|
[100908] | 568 | int rc;
|
---|
| 569 | size_t cbSeg = 0;
|
---|
| 570 | void * const pvSeg = RTSgBufGetCurrentSegment(pSgBuf, ~(size_t)0, &cbSeg);
|
---|
| 571 | size_t const cbDataLeft = (uint64_t)off < cbData ? cbData - (size_t)off : 0;
|
---|
[90114] | 572 | if (!pcbRead)
|
---|
| 573 | {
|
---|
[100908] | 574 | if (cbSeg <= cbDataLeft)
|
---|
[90114] | 575 | {
|
---|
[100908] | 576 | memcpy(pvSeg, &pbData[off], cbSeg);
|
---|
| 577 | pThis->offFile = off + cbSeg;
|
---|
| 578 | Log6(("rtEfiVarStoreFile_ReadMem: off=%#RX64 cbSeg=%#x -> VINF_SUCCESS\n", off, cbSeg));
|
---|
| 579 | RTSgBufAdvance(pSgBuf, cbSeg);
|
---|
| 580 | rc = VINF_SUCCESS;
|
---|
[90114] | 581 | }
|
---|
| 582 | else
|
---|
| 583 | {
|
---|
[100908] | 584 | Log6(("rtEfiVarStoreFile_ReadMem: off=%#RX64 cbSeg=%#x -> VERR_EOF (cbDataLeft=%#x)\n", off, cbSeg, cbDataLeft));
|
---|
| 585 | rc = VERR_EOF;
|
---|
[90114] | 586 | }
|
---|
| 587 | }
|
---|
[100908] | 588 | else if (cbDataLeft == 0)
|
---|
| 589 | {
|
---|
| 590 | Log6(("rtEfiVarStoreFile_ReadMem: off=%#RX64 cbSeg=%#x -> VINF_EOF *pcbRead=0\n", off, cbSeg));
|
---|
| 591 | *pcbRead = 0;
|
---|
| 592 | rc = VINF_EOF;
|
---|
| 593 | }
|
---|
| 594 | else
|
---|
| 595 | {
|
---|
| 596 | size_t const cbThisRead = RT_MAX(cbSeg, cbDataLeft);
|
---|
| 597 | memcpy(pvSeg, &pbData[off], cbThisRead);
|
---|
[90061] | 598 |
|
---|
[100908] | 599 | pThis->offFile = off + cbThisRead;
|
---|
| 600 | *pcbRead = cbThisRead;
|
---|
| 601 | RTSgBufAdvance(pSgBuf, cbThisRead);
|
---|
| 602 |
|
---|
| 603 | /* Return VINF_EOF if beyond end-of-file. */
|
---|
| 604 | rc = cbThisRead == cbSeg ? VINF_SUCCESS : VINF_EOF;
|
---|
| 605 | Log6(("rtEfiVarStoreFile_ReadMem: off=%#RX64 cbSeg=%#x -> %Rrc *pcbRead=%#x\n", off, cbSeg, rc, cbThisRead));
|
---|
| 606 | }
|
---|
| 607 |
|
---|
[90114] | 608 | return rc;
|
---|
[90061] | 609 | }
|
---|
| 610 |
|
---|
| 611 |
|
---|
| 612 | /**
|
---|
[90125] | 613 | * Writes variable data from the given memory area.
|
---|
| 614 | *
|
---|
| 615 | * @returns IPRT status code.
|
---|
| 616 | * @param pThis The EFI variable file instance.
|
---|
[100908] | 617 | * @param pbData Pointer to the start of the data.
|
---|
[90125] | 618 | * @param cbData Size of the variable data in bytes.
|
---|
| 619 | * @param off Where to start writing relative from the data start offset.
|
---|
| 620 | * @param pSgBuf The data to write.
|
---|
| 621 | * @param pcbWritten Where to return the number of bytes written, optional.
|
---|
| 622 | */
|
---|
[100908] | 623 | static int rtEfiVarStoreFile_WriteMem(PRTEFIVARFILE pThis, uint8_t *pbData, size_t cbData,
|
---|
| 624 | RTFOFF off, PRTSGBUF pSgBuf, size_t *pcbWritten)
|
---|
[90125] | 625 | {
|
---|
[100908] | 626 | int rc;
|
---|
| 627 | size_t cbSeg = 0;
|
---|
| 628 | void const * const pvSeg = RTSgBufGetCurrentSegment(pSgBuf, ~(size_t)0, &cbSeg);
|
---|
| 629 | size_t const cbDataLeft = (uint64_t)off < cbData ? cbData - (size_t)off : 0;
|
---|
[90125] | 630 | if (!pcbWritten)
|
---|
| 631 | {
|
---|
[100908] | 632 | if (cbSeg <= cbDataLeft)
|
---|
[90125] | 633 | {
|
---|
[100908] | 634 | memcpy(&pbData[off], pvSeg, cbSeg);
|
---|
| 635 | pThis->offFile = off + cbSeg;
|
---|
| 636 | RTSgBufAdvance(pSgBuf, cbSeg);
|
---|
| 637 | Log6(("rtEfiVarStoreFile_WriteMem: off=%#RX64 cbSeg=%#x -> VINF_SUCCESS\n", off, cbSeg));
|
---|
| 638 | rc = VINF_SUCCESS;
|
---|
[90125] | 639 | }
|
---|
| 640 | else
|
---|
| 641 | {
|
---|
[100908] | 642 | Log6(("rtEfiVarStoreFile_WriteMem: off=%#RX64 cbSeg=%#x -> VERR_EOF\n", off, cbSeg));
|
---|
| 643 | rc = VERR_EOF; /** @todo r=bird: This status seems bogus. Use VERR_FILE_TOO_BIG instead? */
|
---|
[90125] | 644 | }
|
---|
| 645 | }
|
---|
[100908] | 646 | else if (cbDataLeft == 0)
|
---|
| 647 | {
|
---|
| 648 | *pcbWritten = 0;
|
---|
| 649 | rc = VINF_EOF; /** @todo r=bird: This is weird. Implementing the read EOF protocol for a write... */
|
---|
| 650 | }
|
---|
| 651 | else
|
---|
| 652 | {
|
---|
| 653 | size_t const cbThisWrite = RT_MAX(cbSeg, cbDataLeft);
|
---|
| 654 | memcpy(&pbData[off], pvSeg, cbThisWrite);
|
---|
[90125] | 655 |
|
---|
[100908] | 656 | pThis->offFile = off + cbThisWrite;
|
---|
| 657 | *pcbWritten = cbThisWrite;
|
---|
| 658 | RTSgBufAdvance(pSgBuf, cbThisWrite);
|
---|
| 659 |
|
---|
| 660 | /* Return VINF_EOF if beyond end-of-file. */
|
---|
| 661 | /** @todo r=bird: This is weird. Implementing the read EOF protocol for a write... */
|
---|
| 662 | rc = cbThisWrite == cbSeg ? VINF_SUCCESS : VINF_EOF;
|
---|
| 663 | Log6(("rtEfiVarStoreFile_WriteMem: off=%#RX64 cbSeg=%#x -> %Rrc *pcbWritten=%#x\n", off, cbSeg, rc, cbThisWrite));
|
---|
| 664 | }
|
---|
[90125] | 665 | return rc;
|
---|
| 666 | }
|
---|
| 667 |
|
---|
| 668 |
|
---|
| 669 | /**
|
---|
[90114] | 670 | * Reads variable data from the given range.
|
---|
| 671 | *
|
---|
| 672 | * @returns IPRT status code.
|
---|
| 673 | * @param pThis The EFI variable file instance.
|
---|
| 674 | * @param offData Where the data starts in the backing storage.
|
---|
| 675 | * @param cbData Size of the variable data in bytes.
|
---|
| 676 | * @param off Where to start reading relative from the data start offset.
|
---|
| 677 | * @param pSgBuf Where to store the read data.
|
---|
| 678 | * @param pcbRead Where to return the number of bytes read, optional.
|
---|
[90061] | 679 | */
|
---|
[90114] | 680 | static int rtEfiVarStoreFile_ReadFile(PRTEFIVARFILE pThis, uint64_t offData, size_t cbData,
|
---|
[100908] | 681 | RTFOFF off, PRTSGBUF pSgBuf, size_t *pcbRead)
|
---|
[90061] | 682 | {
|
---|
[100908] | 683 | int rc;
|
---|
| 684 | PRTEFIVARSTORE const pVarStore = pThis->pVarStore;
|
---|
| 685 | size_t cbSeg = 0;
|
---|
| 686 | void * const pvSeg = RTSgBufGetCurrentSegment(pSgBuf, ~(size_t)0, &cbSeg);
|
---|
| 687 | size_t const cbDataLeft = (uint64_t)off < cbData ? cbData - (size_t)off : 0;
|
---|
| 688 | uint64_t const offBacking = offData + off;
|
---|
[90061] | 689 | if (!pcbRead)
|
---|
| 690 | {
|
---|
[100908] | 691 | if (cbSeg <= cbDataLeft)
|
---|
| 692 | {
|
---|
| 693 | rc = RTVfsFileSgRead(pVarStore->hVfsBacking, offBacking, pSgBuf, true /*fBlocking*/, NULL /*pcbRead*/);
|
---|
| 694 | if (RT_SUCCESS(rc))
|
---|
| 695 | pThis->offFile = off + cbSeg;
|
---|
| 696 | Log6(("rtEfiVarStoreFile_ReadFile: off=%#RX64 cbSeg=%#x -> %Rrc\n", off, cbSeg, rc));
|
---|
| 697 | }
|
---|
[90061] | 698 | else
|
---|
[100908] | 699 | {
|
---|
| 700 | Log6(("rtEfiVarStoreFile_ReadFile: off=%#RX64 cbSeg=%#x cbDataLeft=%#zx -> VERR_EOF\n", off, cbSeg, cbDataLeft));
|
---|
[90061] | 701 | rc = VERR_EOF;
|
---|
[100908] | 702 | }
|
---|
[90061] | 703 | }
|
---|
[100908] | 704 | else if (cbDataLeft == 0)
|
---|
| 705 | {
|
---|
| 706 | Log6(("rtEfiVarStoreFile_ReadFile: off=%#RX64 cbSeg=%#x -> VINF_EOF\n", off, cbSeg));
|
---|
| 707 | *pcbRead = 0;
|
---|
| 708 | rc = VINF_EOF;
|
---|
| 709 | }
|
---|
[90061] | 710 | else
|
---|
| 711 | {
|
---|
[100908] | 712 | size_t const cbThisRead = RT_MAX(cbSeg, cbDataLeft);
|
---|
| 713 | rc = RTVfsFileReadAt(pVarStore->hVfsBacking, offBacking, pvSeg, cbThisRead, NULL /*pcbRead*/);
|
---|
| 714 | if (RT_SUCCESS(rc))
|
---|
[90061] | 715 | {
|
---|
[100908] | 716 | pThis->offFile = off + cbThisRead;
|
---|
| 717 | *pcbRead = cbThisRead;
|
---|
| 718 | RTSgBufAdvance(pSgBuf, cbThisRead);
|
---|
| 719 |
|
---|
| 720 | /* Return VINF_EOF if beyond end-of-file. */
|
---|
| 721 | rc = cbThisRead == cbSeg ? VINF_SUCCESS : VINF_EOF;
|
---|
[90061] | 722 | }
|
---|
| 723 | else
|
---|
[100908] | 724 | *pcbRead = 0;
|
---|
| 725 | Log6(("rtFsEfiVarStore_Read: off=%#RX64 cbSeg=%#x -> %Rrc *pcbRead=%#x\n", off, cbSeg, rc, *pcbRead));
|
---|
[90061] | 726 | }
|
---|
| 727 | return rc;
|
---|
| 728 | }
|
---|
| 729 |
|
---|
| 730 |
|
---|
| 731 | /**
|
---|
[90125] | 732 | * Ensures that the variable data is available before any modification.
|
---|
| 733 | *
|
---|
| 734 | * @returns IPRT status code.
|
---|
| 735 | * @param pVar The variable instance.
|
---|
| 736 | */
|
---|
| 737 | static int rtEfiVarStore_VarReadData(PRTEFIVAR pVar)
|
---|
| 738 | {
|
---|
| 739 | if (RT_LIKELY( !pVar->offVarData
|
---|
| 740 | || !pVar->cbData))
|
---|
| 741 | return VINF_SUCCESS;
|
---|
| 742 |
|
---|
| 743 | Assert(!pVar->pvData);
|
---|
| 744 | pVar->pvData = RTMemAlloc(pVar->cbData);
|
---|
| 745 | if (RT_UNLIKELY(!pVar->pvData))
|
---|
| 746 | return VERR_NO_MEMORY;
|
---|
| 747 |
|
---|
| 748 | PRTEFIVARSTORE pVarStore = pVar->pVarStore;
|
---|
| 749 | int rc = RTVfsFileReadAt(pVarStore->hVfsBacking, pVar->offVarData, pVar->pvData, pVar->cbData, NULL);
|
---|
| 750 | if (RT_SUCCESS(rc))
|
---|
| 751 | pVar->offVarData = 0; /* Marks the variable data as in memory. */
|
---|
| 752 | else
|
---|
| 753 | {
|
---|
| 754 | RTMemFree(pVar->pvData);
|
---|
| 755 | pVar->pvData = NULL;
|
---|
| 756 | }
|
---|
| 757 |
|
---|
| 758 | return rc;
|
---|
| 759 | }
|
---|
| 760 |
|
---|
| 761 |
|
---|
| 762 | /**
|
---|
| 763 | * Ensures that the given variable has the given data size.
|
---|
| 764 | *
|
---|
| 765 | * @returns IPRT status code.
|
---|
| 766 | * @retval VERR_DISK_FULL if the new size would exceed the variable storage size.
|
---|
| 767 | * @param pVar The variable instance.
|
---|
| 768 | * @param cbData New number of bytes of data for the variable.
|
---|
| 769 | */
|
---|
| 770 | static int rtEfiVarStore_VarEnsureDataSz(PRTEFIVAR pVar, size_t cbData)
|
---|
| 771 | {
|
---|
| 772 | PRTEFIVARSTORE pVarStore = pVar->pVarStore;
|
---|
| 773 |
|
---|
| 774 | if (pVar->cbData == cbData)
|
---|
| 775 | return VINF_SUCCESS;
|
---|
| 776 |
|
---|
[90126] | 777 | if ((uint32_t)cbData != cbData)
|
---|
| 778 | return VERR_FILE_TOO_BIG;
|
---|
| 779 |
|
---|
[90125] | 780 | int rc = VINF_SUCCESS;
|
---|
| 781 | if (cbData < pVar->cbData)
|
---|
| 782 | {
|
---|
| 783 | /* Shrink. */
|
---|
| 784 | void *pvNew = RTMemRealloc(pVar->pvData, cbData);
|
---|
| 785 | if (pvNew)
|
---|
| 786 | {
|
---|
| 787 | pVar->pvData = pvNew;
|
---|
| 788 | pVarStore->cbVarData -= pVar->cbData - cbData;
|
---|
[90126] | 789 | pVar->cbData = (uint32_t)cbData;
|
---|
[90125] | 790 | }
|
---|
| 791 | else
|
---|
| 792 | rc = VERR_NO_MEMORY;
|
---|
| 793 | }
|
---|
| 794 | else if (cbData > pVar->cbData)
|
---|
| 795 | {
|
---|
| 796 | /* Grow. */
|
---|
| 797 | if (pVarStore->cbVarStore - pVarStore->cbVarData >= cbData - pVar->cbData)
|
---|
| 798 | {
|
---|
| 799 | void *pvNew = RTMemRealloc(pVar->pvData, cbData);
|
---|
| 800 | if (pvNew)
|
---|
| 801 | {
|
---|
| 802 | pVar->pvData = pvNew;
|
---|
| 803 | pVarStore->cbVarData += cbData - pVar->cbData;
|
---|
[90126] | 804 | pVar->cbData = (uint32_t)cbData;
|
---|
[90125] | 805 | }
|
---|
| 806 | else
|
---|
| 807 | rc = VERR_NO_MEMORY;
|
---|
| 808 | }
|
---|
| 809 | else
|
---|
| 810 | rc = VERR_DISK_FULL;
|
---|
| 811 | }
|
---|
| 812 |
|
---|
| 813 | return rc;
|
---|
| 814 | }
|
---|
| 815 |
|
---|
| 816 |
|
---|
| 817 | /**
|
---|
[90114] | 818 | * Flush the variable store to the backing storage. This will remove any
|
---|
| 819 | * deleted variables in the backing storage.
|
---|
| 820 | *
|
---|
| 821 | * @returns IPRT status code.
|
---|
| 822 | * @param pThis The EFI variable store instance.
|
---|
| 823 | */
|
---|
| 824 | static int rtEfiVarStore_Flush(PRTEFIVARSTORE pThis)
|
---|
| 825 | {
|
---|
| 826 | int rc = VINF_SUCCESS;
|
---|
| 827 | uint64_t offCur = pThis->offStoreData;
|
---|
| 828 |
|
---|
| 829 | for (uint32_t i = 0; i < pThis->cVars && RT_SUCCESS(rc); i++)
|
---|
| 830 | {
|
---|
| 831 | PRTUTF16 pwszName = NULL;
|
---|
| 832 | size_t cwcLen = 0;
|
---|
| 833 | PRTEFIVAR pVar = &pThis->paVars[i];
|
---|
| 834 |
|
---|
[90133] | 835 | if (!pVar->fDeleted)
|
---|
[90114] | 836 | {
|
---|
[90133] | 837 | rc = RTStrToUtf16Ex(pVar->pszName, RTSTR_MAX, &pwszName, 0, &cwcLen);
|
---|
[90114] | 838 | if (RT_SUCCESS(rc))
|
---|
| 839 | {
|
---|
[90133] | 840 | cwcLen++; /* Include the terminator. */
|
---|
[90114] | 841 |
|
---|
[90133] | 842 | /* Read in the data of the variable if it exists. */
|
---|
| 843 | rc = rtEfiVarStore_VarReadData(pVar);
|
---|
[90114] | 844 | if (RT_SUCCESS(rc))
|
---|
| 845 | {
|
---|
[90133] | 846 | /* Write out the variable. */
|
---|
| 847 | EFI_AUTH_VAR_HEADER VarHdr;
|
---|
| 848 | size_t cbName = cwcLen * sizeof(RTUTF16);
|
---|
| 849 |
|
---|
| 850 | VarHdr.u16StartId = RT_H2LE_U16(EFI_AUTH_VAR_HEADER_START);
|
---|
| 851 | VarHdr.bState = EFI_AUTH_VAR_HEADER_STATE_ADDED;
|
---|
| 852 | VarHdr.bRsvd = 0;
|
---|
| 853 | VarHdr.fAttr = RT_H2LE_U32(pVar->fAttr);
|
---|
| 854 | VarHdr.cMonotonic = RT_H2LE_U64(pVar->cMonotonic);
|
---|
| 855 | VarHdr.idPubKey = RT_H2LE_U32(pVar->idPubKey);
|
---|
| 856 | VarHdr.cbName = RT_H2LE_U32((uint32_t)cbName);
|
---|
| 857 | VarHdr.cbData = RT_H2LE_U32(pVar->cbData);
|
---|
| 858 | RTEfiGuidFromUuid(&VarHdr.GuidVendor, &pVar->Uuid);
|
---|
| 859 | memcpy(&VarHdr.Timestamp, &pVar->EfiTimestamp, sizeof(pVar->EfiTimestamp));
|
---|
| 860 |
|
---|
| 861 | rc = RTVfsFileWriteAt(pThis->hVfsBacking, offCur, &VarHdr, sizeof(VarHdr), NULL);
|
---|
| 862 | if (RT_SUCCESS(rc))
|
---|
| 863 | rc = RTVfsFileWriteAt(pThis->hVfsBacking, offCur + sizeof(VarHdr), pwszName, cbName, NULL);
|
---|
| 864 | if (RT_SUCCESS(rc))
|
---|
| 865 | rc = RTVfsFileWriteAt(pThis->hVfsBacking, offCur + sizeof(VarHdr) + cbName, pVar->pvData, pVar->cbData, NULL);
|
---|
| 866 | if (RT_SUCCESS(rc))
|
---|
[90114] | 867 | {
|
---|
[90133] | 868 | offCur += sizeof(VarHdr) + cbName + pVar->cbData;
|
---|
[90343] | 869 | uint64_t offCurAligned = RT_ALIGN_64(offCur, sizeof(uint32_t));
|
---|
[90133] | 870 | if (offCurAligned > offCur)
|
---|
| 871 | {
|
---|
[90343] | 872 | /* Should be at most 3 bytes to align the next variable to a 32bit boundary. */
|
---|
| 873 | Assert(offCurAligned - offCur <= 3);
|
---|
| 874 | uint8_t abFill[3] = { 0xff };
|
---|
| 875 | rc = RTVfsFileWriteAt(pThis->hVfsBacking, offCur, &abFill[0], offCurAligned - offCur, NULL);
|
---|
[90133] | 876 | }
|
---|
| 877 |
|
---|
| 878 | offCur = offCurAligned;
|
---|
[90114] | 879 | }
|
---|
[90133] | 880 | }
|
---|
[90114] | 881 |
|
---|
[90133] | 882 | RTUtf16Free(pwszName);
|
---|
[90114] | 883 | }
|
---|
| 884 | }
|
---|
| 885 | }
|
---|
| 886 |
|
---|
| 887 | if (RT_SUCCESS(rc))
|
---|
| 888 | {
|
---|
| 889 | /* Fill the remainder with 0xff as it would be the case for a real NAND flash device. */
|
---|
| 890 | uint8_t abFF[512];
|
---|
| 891 | memset(&abFF[0], 0xff, sizeof(abFF));
|
---|
| 892 |
|
---|
| 893 | uint64_t offStart = offCur;
|
---|
| 894 | uint64_t offEnd = pThis->offStoreData + pThis->cbVarStore;
|
---|
| 895 | while ( offStart < offEnd
|
---|
| 896 | && RT_SUCCESS(rc))
|
---|
| 897 | {
|
---|
| 898 | size_t cbThisWrite = RT_MIN(sizeof(abFF), offEnd - offStart);
|
---|
| 899 | rc = RTVfsFileWriteAt(pThis->hVfsBacking, offStart, &abFF[0], cbThisWrite, NULL);
|
---|
| 900 | offStart += cbThisWrite;
|
---|
| 901 | }
|
---|
| 902 | }
|
---|
| 903 |
|
---|
| 904 | return rc;
|
---|
| 905 | }
|
---|
| 906 |
|
---|
| 907 |
|
---|
[90133] | 908 | /**
|
---|
| 909 | * Tries to find a variable with the given name.
|
---|
| 910 | *
|
---|
| 911 | * @returns Pointer to the variable if found or NULL otherwise.
|
---|
| 912 | * @param pThis The variable store instance.
|
---|
| 913 | * @param pszName Name of the variable to look for.
|
---|
| 914 | * @param pidVar Where to store the index of the variable, optional.
|
---|
| 915 | */
|
---|
| 916 | static PRTEFIVAR rtEfiVarStore_VarGet(PRTEFIVARSTORE pThis, const char *pszName, uint32_t *pidVar)
|
---|
| 917 | {
|
---|
| 918 | for (uint32_t i = 0; i < pThis->cVars; i++)
|
---|
| 919 | if ( !pThis->paVars[i].fDeleted
|
---|
| 920 | && !strcmp(pszName, pThis->paVars[i].pszName))
|
---|
| 921 | {
|
---|
| 922 | if (pidVar)
|
---|
| 923 | *pidVar = i;
|
---|
| 924 | return &pThis->paVars[i];
|
---|
| 925 | }
|
---|
| 926 |
|
---|
| 927 | return NULL;
|
---|
| 928 | }
|
---|
| 929 |
|
---|
| 930 |
|
---|
| 931 | /**
|
---|
| 932 | * Maybe grows the array of variables to hold more entries.
|
---|
| 933 | *
|
---|
| 934 | * @returns IPRT status code.
|
---|
| 935 | * @param pThis The variable store instance.
|
---|
| 936 | */
|
---|
| 937 | static int rtEfiVarStore_VarMaybeGrowEntries(PRTEFIVARSTORE pThis)
|
---|
| 938 | {
|
---|
| 939 | if (pThis->cVars == pThis->cVarsMax)
|
---|
| 940 | {
|
---|
| 941 | /* Grow the variable array. */
|
---|
| 942 | uint32_t cVarsMaxNew = pThis->cVarsMax + 10;
|
---|
| 943 | PRTEFIVAR paVarsNew = (PRTEFIVAR)RTMemRealloc(pThis->paVars, cVarsMaxNew * sizeof(RTEFIVAR));
|
---|
| 944 | if (!paVarsNew)
|
---|
| 945 | return VERR_NO_MEMORY;
|
---|
| 946 |
|
---|
| 947 | pThis->paVars = paVarsNew;
|
---|
| 948 | pThis->cVarsMax = cVarsMaxNew;
|
---|
| 949 | }
|
---|
| 950 |
|
---|
| 951 | return VINF_SUCCESS;
|
---|
| 952 | }
|
---|
| 953 |
|
---|
| 954 |
|
---|
| 955 | /**
|
---|
| 956 | * Add a variable with the given name.
|
---|
| 957 | *
|
---|
| 958 | * @returns Pointer to the entry or NULL if out of memory.
|
---|
| 959 | * @param pThis The variable store instance.
|
---|
| 960 | * @param pszName Name of the variable to add.
|
---|
[90343] | 961 | * @param pUuid The UUID of the variable owner.
|
---|
[90133] | 962 | * @param pidVar Where to store the variable index on success, optional
|
---|
| 963 | */
|
---|
[90343] | 964 | static PRTEFIVAR rtEfiVarStore_VarAdd(PRTEFIVARSTORE pThis, const char *pszName, PCRTUUID pUuid, uint32_t *pidVar)
|
---|
[90133] | 965 | {
|
---|
| 966 | Assert(!rtEfiVarStore_VarGet(pThis, pszName, NULL));
|
---|
| 967 |
|
---|
| 968 | int rc = rtEfiVarStore_VarMaybeGrowEntries(pThis);
|
---|
| 969 | if (RT_SUCCESS(rc))
|
---|
| 970 | {
|
---|
| 971 | PRTEFIVAR pVar = &pThis->paVars[pThis->cVars];
|
---|
| 972 | RT_ZERO(*pVar);
|
---|
| 973 |
|
---|
| 974 | pVar->pszName = RTStrDup(pszName);
|
---|
| 975 | if (pVar->pszName)
|
---|
| 976 | {
|
---|
| 977 | pVar->pVarStore = pThis;
|
---|
| 978 | pVar->offVarData = 0;
|
---|
| 979 | pVar->fDeleted = false;
|
---|
[90343] | 980 | pVar->Uuid = *pUuid;
|
---|
[90133] | 981 | RTTimeNow(&pVar->Time);
|
---|
| 982 |
|
---|
[90343] | 983 | rc = rtEfiVarStore_AddVarByGuid(pThis, pUuid, pThis->cVars);
|
---|
| 984 | AssertRC(rc); /** @todo */
|
---|
| 985 |
|
---|
[90133] | 986 | if (pidVar)
|
---|
| 987 | *pidVar = pThis->cVars;
|
---|
| 988 | pThis->cVars++;
|
---|
| 989 | return pVar;
|
---|
| 990 | }
|
---|
| 991 | }
|
---|
| 992 |
|
---|
| 993 | return NULL;
|
---|
| 994 | }
|
---|
| 995 |
|
---|
| 996 |
|
---|
| 997 | /**
|
---|
| 998 | * Delete the given variable.
|
---|
| 999 | *
|
---|
| 1000 | * @returns IPRT status code.
|
---|
| 1001 | * @param pThis The variable store instance.
|
---|
| 1002 | * @param pVar The variable.
|
---|
| 1003 | */
|
---|
| 1004 | static int rtEfiVarStore_VarDel(PRTEFIVARSTORE pThis, PRTEFIVAR pVar)
|
---|
| 1005 | {
|
---|
| 1006 | pVar->fDeleted = true;
|
---|
| 1007 | if (pVar->pvData)
|
---|
| 1008 | RTMemFree(pVar->pvData);
|
---|
| 1009 | pVar->pvData = NULL;
|
---|
| 1010 | pThis->cbVarData -= sizeof(EFI_AUTH_VAR_HEADER) + pVar->cbData;
|
---|
| 1011 | /** @todo Delete from GUID entry. */
|
---|
| 1012 | return VINF_SUCCESS;
|
---|
| 1013 | }
|
---|
| 1014 |
|
---|
| 1015 |
|
---|
| 1016 | /**
|
---|
| 1017 | * Delete the variable with the given index.
|
---|
| 1018 | *
|
---|
| 1019 | * @returns IPRT status code.
|
---|
| 1020 | * @param pThis The variable store instance.
|
---|
| 1021 | * @param idVar The variable index.
|
---|
| 1022 | */
|
---|
| 1023 | static int rtEfiVarStore_VarDelById(PRTEFIVARSTORE pThis, uint32_t idVar)
|
---|
| 1024 | {
|
---|
| 1025 | return rtEfiVarStore_VarDel(pThis, &pThis->paVars[idVar]);
|
---|
| 1026 | }
|
---|
| 1027 |
|
---|
| 1028 |
|
---|
| 1029 | /**
|
---|
| 1030 | * Delete the variable with the given name.
|
---|
| 1031 | *
|
---|
| 1032 | * @returns IPRT status code.
|
---|
| 1033 | * @param pThis The variable store instance.
|
---|
| 1034 | * @param pszName Name of the variable to delete.
|
---|
| 1035 | */
|
---|
| 1036 | static int rtEfiVarStore_VarDelByName(PRTEFIVARSTORE pThis, const char *pszName)
|
---|
| 1037 | {
|
---|
| 1038 | PRTEFIVAR pVar = rtEfiVarStore_VarGet(pThis, pszName, NULL);
|
---|
| 1039 | if (pVar)
|
---|
| 1040 | return rtEfiVarStore_VarDel(pThis, pVar);
|
---|
| 1041 |
|
---|
| 1042 | return VERR_FILE_NOT_FOUND;
|
---|
| 1043 | }
|
---|
| 1044 |
|
---|
| 1045 |
|
---|
[90114] | 1046 | /*
|
---|
| 1047 | *
|
---|
| 1048 | * File operations.
|
---|
| 1049 | * File operations.
|
---|
| 1050 | * File operations.
|
---|
| 1051 | *
|
---|
| 1052 | */
|
---|
| 1053 |
|
---|
| 1054 | /**
|
---|
| 1055 | * @interface_method_impl{RTVFSOBJOPS,pfnClose}
|
---|
| 1056 | */
|
---|
| 1057 | static DECLCALLBACK(int) rtEfiVarStoreFile_Close(void *pvThis)
|
---|
| 1058 | {
|
---|
| 1059 | PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
|
---|
| 1060 | LogFlow(("rtEfiVarStoreFile_Close(%p/%p)\n", pThis, pThis->pVar));
|
---|
| 1061 | RT_NOREF(pThis);
|
---|
| 1062 | return VINF_SUCCESS;
|
---|
| 1063 | }
|
---|
| 1064 |
|
---|
| 1065 |
|
---|
| 1066 | /**
|
---|
| 1067 | * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
|
---|
| 1068 | */
|
---|
| 1069 | static DECLCALLBACK(int) rtEfiVarStoreFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
|
---|
| 1070 | {
|
---|
| 1071 | PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
|
---|
| 1072 | uint64_t cbObject = pThis->pEntry->cbObject > 0
|
---|
| 1073 | ? pThis->pEntry->cbObject
|
---|
| 1074 | : pThis->pVar->cbData;
|
---|
| 1075 | return rtEfiVarStore_QueryInfo(cbObject, false /*fIsDir*/, &pThis->pVar->Time, pObjInfo, enmAddAttr);
|
---|
| 1076 | }
|
---|
| 1077 |
|
---|
| 1078 |
|
---|
| 1079 | /**
|
---|
| 1080 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
|
---|
| 1081 | */
|
---|
[100908] | 1082 | static DECLCALLBACK(int) rtEfiVarStoreFile_Read(void *pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead)
|
---|
[90114] | 1083 | {
|
---|
| 1084 | PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
|
---|
| 1085 | PRTEFIVAR pVar = pThis->pVar;
|
---|
| 1086 | AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3);
|
---|
| 1087 | RT_NOREF(fBlocking);
|
---|
| 1088 |
|
---|
| 1089 | if (off == -1)
|
---|
| 1090 | off = pThis->offFile;
|
---|
| 1091 | else
|
---|
| 1092 | AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3);
|
---|
| 1093 |
|
---|
| 1094 | int rc;
|
---|
| 1095 | if (pThis->pEntry->cbObject)
|
---|
[100908] | 1096 | rc = rtEfiVarStoreFile_ReadMem(pThis, (const uint8_t *)pVar + pThis->pEntry->offObject, pThis->pEntry->cbObject, off,
|
---|
| 1097 | pSgBuf, pcbRead);
|
---|
[90114] | 1098 | else
|
---|
[90125] | 1099 | {
|
---|
| 1100 | /* Data section. */
|
---|
| 1101 | if (!pVar->offVarData)
|
---|
[100908] | 1102 | rc = rtEfiVarStoreFile_ReadMem(pThis, (const uint8_t *)pVar->pvData, pVar->cbData, off, pSgBuf, pcbRead);
|
---|
[90125] | 1103 | else
|
---|
| 1104 | rc = rtEfiVarStoreFile_ReadFile(pThis, pVar->offVarData, pVar->cbData, off, pSgBuf, pcbRead);
|
---|
| 1105 | }
|
---|
[90114] | 1106 |
|
---|
| 1107 | return rc;
|
---|
| 1108 | }
|
---|
| 1109 |
|
---|
| 1110 |
|
---|
| 1111 | /**
|
---|
[90061] | 1112 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
|
---|
| 1113 | */
|
---|
[100908] | 1114 | static DECLCALLBACK(int) rtEfiVarStoreFile_Write(void *pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten)
|
---|
[90061] | 1115 | {
|
---|
[90125] | 1116 | PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
|
---|
| 1117 | PRTEFIVARSTORE pVarStore = pThis->pVarStore;
|
---|
| 1118 | PRTEFIVAR pVar = pThis->pVar;
|
---|
| 1119 | AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3);
|
---|
| 1120 | RT_NOREF(fBlocking);
|
---|
| 1121 |
|
---|
| 1122 | if (pVarStore->fMntFlags & RTVFSMNT_F_READ_ONLY)
|
---|
| 1123 | return VERR_WRITE_PROTECT;
|
---|
| 1124 |
|
---|
| 1125 | if (off == -1)
|
---|
| 1126 | off = pThis->offFile;
|
---|
| 1127 | else
|
---|
| 1128 | AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3);
|
---|
| 1129 |
|
---|
| 1130 | int rc;
|
---|
| 1131 | if (pThis->pEntry->cbObject) /* These can't grow. */
|
---|
| 1132 | rc = rtEfiVarStoreFile_WriteMem(pThis, (uint8_t *)pVar + pThis->pEntry->offObject, pThis->pEntry->cbObject,
|
---|
| 1133 | off, pSgBuf, pcbWritten);
|
---|
| 1134 | else
|
---|
| 1135 | {
|
---|
| 1136 | /* Writing data section. */
|
---|
| 1137 | rc = rtEfiVarStore_VarReadData(pVar);
|
---|
| 1138 | if (RT_SUCCESS(rc))
|
---|
| 1139 | {
|
---|
| 1140 | if (off + pSgBuf->paSegs[0].cbSeg > pVar->cbData)
|
---|
| 1141 | rc = rtEfiVarStore_VarEnsureDataSz(pVar, off + pSgBuf->paSegs[0].cbSeg);
|
---|
| 1142 | if (RT_SUCCESS(rc))
|
---|
[100908] | 1143 | rc = rtEfiVarStoreFile_WriteMem(pThis, (uint8_t *)pVar->pvData, pVar->cbData, off, pSgBuf, pcbWritten);
|
---|
[90125] | 1144 | }
|
---|
| 1145 | }
|
---|
| 1146 |
|
---|
| 1147 | return rc;
|
---|
[90061] | 1148 | }
|
---|
| 1149 |
|
---|
| 1150 |
|
---|
| 1151 | /**
|
---|
| 1152 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
|
---|
| 1153 | */
|
---|
| 1154 | static DECLCALLBACK(int) rtEfiVarStoreFile_Flush(void *pvThis)
|
---|
| 1155 | {
|
---|
| 1156 | RT_NOREF(pvThis);
|
---|
| 1157 | return VINF_SUCCESS;
|
---|
| 1158 | }
|
---|
| 1159 |
|
---|
| 1160 |
|
---|
| 1161 | /**
|
---|
| 1162 | * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
|
---|
| 1163 | */
|
---|
| 1164 | static DECLCALLBACK(int) rtEfiVarStoreFile_Tell(void *pvThis, PRTFOFF poffActual)
|
---|
| 1165 | {
|
---|
| 1166 | PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
|
---|
| 1167 | *poffActual = pThis->offFile;
|
---|
| 1168 | return VINF_SUCCESS;
|
---|
| 1169 | }
|
---|
| 1170 |
|
---|
| 1171 |
|
---|
| 1172 | /**
|
---|
| 1173 | * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
|
---|
| 1174 | */
|
---|
| 1175 | static DECLCALLBACK(int) rtEfiVarStoreFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
|
---|
| 1176 | {
|
---|
| 1177 | RT_NOREF(pvThis, fMode, fMask);
|
---|
| 1178 | return VERR_WRITE_PROTECT;
|
---|
| 1179 | }
|
---|
| 1180 |
|
---|
| 1181 |
|
---|
| 1182 | /**
|
---|
| 1183 | * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
|
---|
| 1184 | */
|
---|
| 1185 | static DECLCALLBACK(int) rtEfiVarStoreFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
|
---|
| 1186 | PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
|
---|
| 1187 | {
|
---|
| 1188 | RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime);
|
---|
| 1189 | return VERR_WRITE_PROTECT;
|
---|
| 1190 | }
|
---|
| 1191 |
|
---|
| 1192 |
|
---|
| 1193 | /**
|
---|
| 1194 | * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
|
---|
| 1195 | */
|
---|
| 1196 | static DECLCALLBACK(int) rtEfiVarStoreFile_SetOwner(void *pvThis, RTUID uid, RTGID gid)
|
---|
| 1197 | {
|
---|
| 1198 | RT_NOREF(pvThis, uid, gid);
|
---|
| 1199 | return VERR_WRITE_PROTECT;
|
---|
| 1200 | }
|
---|
| 1201 |
|
---|
| 1202 |
|
---|
| 1203 | /**
|
---|
| 1204 | * @interface_method_impl{RTVFSFILEOPS,pfnSeek}
|
---|
| 1205 | */
|
---|
| 1206 | static DECLCALLBACK(int) rtEfiVarStoreFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
|
---|
| 1207 | {
|
---|
| 1208 | PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
|
---|
| 1209 | RTFOFF offNew;
|
---|
| 1210 | switch (uMethod)
|
---|
| 1211 | {
|
---|
| 1212 | case RTFILE_SEEK_BEGIN:
|
---|
| 1213 | offNew = offSeek;
|
---|
| 1214 | break;
|
---|
| 1215 | case RTFILE_SEEK_END:
|
---|
[90114] | 1216 | offNew = pThis->pVar->cbData + offSeek;
|
---|
[90061] | 1217 | break;
|
---|
| 1218 | case RTFILE_SEEK_CURRENT:
|
---|
| 1219 | offNew = (RTFOFF)pThis->offFile + offSeek;
|
---|
| 1220 | break;
|
---|
| 1221 | default:
|
---|
| 1222 | return VERR_INVALID_PARAMETER;
|
---|
| 1223 | }
|
---|
| 1224 | if (offNew >= 0)
|
---|
| 1225 | {
|
---|
| 1226 | pThis->offFile = offNew;
|
---|
| 1227 | *poffActual = offNew;
|
---|
| 1228 | return VINF_SUCCESS;
|
---|
| 1229 | }
|
---|
| 1230 | return VERR_NEGATIVE_SEEK;
|
---|
| 1231 | }
|
---|
| 1232 |
|
---|
| 1233 |
|
---|
| 1234 | /**
|
---|
| 1235 | * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize}
|
---|
| 1236 | */
|
---|
| 1237 | static DECLCALLBACK(int) rtEfiVarStoreFile_QuerySize(void *pvThis, uint64_t *pcbFile)
|
---|
| 1238 | {
|
---|
| 1239 | PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
|
---|
[90114] | 1240 | if (pThis->pEntry->cbObject)
|
---|
| 1241 | *pcbFile = pThis->pEntry->cbObject;
|
---|
| 1242 | else
|
---|
| 1243 | *pcbFile = (uint64_t)pThis->pVar->cbData;
|
---|
[90061] | 1244 | return VINF_SUCCESS;
|
---|
| 1245 | }
|
---|
| 1246 |
|
---|
| 1247 |
|
---|
| 1248 | /**
|
---|
| 1249 | * @interface_method_impl{RTVFSFILEOPS,pfnSetSize}
|
---|
| 1250 | */
|
---|
| 1251 | static DECLCALLBACK(int) rtEfiVarStoreFile_SetSize(void *pvThis, uint64_t cbFile, uint32_t fFlags)
|
---|
| 1252 | {
|
---|
[90125] | 1253 | PRTEFIVARFILE pThis = (PRTEFIVARFILE)pvThis;
|
---|
| 1254 | PRTEFIVAR pVar = pThis->pVar;
|
---|
| 1255 | PRTEFIVARSTORE pVarStore = pThis->pVarStore;
|
---|
| 1256 |
|
---|
| 1257 | RT_NOREF(fFlags);
|
---|
| 1258 |
|
---|
| 1259 | if (pVarStore->fMntFlags & RTVFSMNT_F_READ_ONLY)
|
---|
| 1260 | return VERR_WRITE_PROTECT;
|
---|
| 1261 |
|
---|
| 1262 | int rc = rtEfiVarStore_VarReadData(pVar);
|
---|
| 1263 | if (RT_SUCCESS(rc))
|
---|
| 1264 | rc = rtEfiVarStore_VarEnsureDataSz(pVar, cbFile);
|
---|
| 1265 |
|
---|
| 1266 | return rc;
|
---|
[90061] | 1267 | }
|
---|
| 1268 |
|
---|
| 1269 |
|
---|
| 1270 | /**
|
---|
| 1271 | * @interface_method_impl{RTVFSFILEOPS,pfnQueryMaxSize}
|
---|
| 1272 | */
|
---|
| 1273 | static DECLCALLBACK(int) rtEfiVarStoreFile_QueryMaxSize(void *pvThis, uint64_t *pcbMax)
|
---|
| 1274 | {
|
---|
| 1275 | RT_NOREF(pvThis);
|
---|
[90126] | 1276 | *pcbMax = UINT32_MAX;
|
---|
[90061] | 1277 | return VINF_SUCCESS;
|
---|
| 1278 | }
|
---|
| 1279 |
|
---|
| 1280 |
|
---|
| 1281 | /**
|
---|
[90125] | 1282 | * EFI variable store file operations.
|
---|
[90061] | 1283 | */
|
---|
| 1284 | static const RTVFSFILEOPS g_rtEfiVarStoreFileOps =
|
---|
| 1285 | {
|
---|
| 1286 | { /* Stream */
|
---|
| 1287 | { /* Obj */
|
---|
| 1288 | RTVFSOBJOPS_VERSION,
|
---|
| 1289 | RTVFSOBJTYPE_FILE,
|
---|
[90125] | 1290 | "EfiVarStore File",
|
---|
[90061] | 1291 | rtEfiVarStoreFile_Close,
|
---|
| 1292 | rtEfiVarStoreFile_QueryInfo,
|
---|
[94291] | 1293 | NULL,
|
---|
[90061] | 1294 | RTVFSOBJOPS_VERSION
|
---|
| 1295 | },
|
---|
| 1296 | RTVFSIOSTREAMOPS_VERSION,
|
---|
| 1297 | RTVFSIOSTREAMOPS_FEAT_NO_SG,
|
---|
| 1298 | rtEfiVarStoreFile_Read,
|
---|
| 1299 | rtEfiVarStoreFile_Write,
|
---|
| 1300 | rtEfiVarStoreFile_Flush,
|
---|
| 1301 | NULL /*PollOne*/,
|
---|
| 1302 | rtEfiVarStoreFile_Tell,
|
---|
| 1303 | NULL /*pfnSkip*/,
|
---|
| 1304 | NULL /*pfnZeroFill*/,
|
---|
| 1305 | RTVFSIOSTREAMOPS_VERSION,
|
---|
| 1306 | },
|
---|
| 1307 | RTVFSFILEOPS_VERSION,
|
---|
| 1308 | 0,
|
---|
| 1309 | { /* ObjSet */
|
---|
| 1310 | RTVFSOBJSETOPS_VERSION,
|
---|
| 1311 | RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
|
---|
| 1312 | rtEfiVarStoreFile_SetMode,
|
---|
| 1313 | rtEfiVarStoreFile_SetTimes,
|
---|
| 1314 | rtEfiVarStoreFile_SetOwner,
|
---|
| 1315 | RTVFSOBJSETOPS_VERSION
|
---|
| 1316 | },
|
---|
| 1317 | rtEfiVarStoreFile_Seek,
|
---|
| 1318 | rtEfiVarStoreFile_QuerySize,
|
---|
| 1319 | rtEfiVarStoreFile_SetSize,
|
---|
| 1320 | rtEfiVarStoreFile_QueryMaxSize,
|
---|
| 1321 | RTVFSFILEOPS_VERSION
|
---|
| 1322 | };
|
---|
| 1323 |
|
---|
| 1324 |
|
---|
| 1325 | /**
|
---|
| 1326 | * Creates a new VFS file from the given regular file inode.
|
---|
| 1327 | *
|
---|
| 1328 | * @returns IPRT status code.
|
---|
| 1329 | * @param pThis The ext volume instance.
|
---|
| 1330 | * @param fOpen Open flags passed.
|
---|
[90114] | 1331 | * @param pVar The variable this file accesses.
|
---|
| 1332 | * @param pEntry File type entry.
|
---|
[90061] | 1333 | * @param phVfsFile Where to store the VFS file handle on success.
|
---|
| 1334 | * @param pErrInfo Where to record additional error information on error, optional.
|
---|
| 1335 | */
|
---|
| 1336 | static int rtEfiVarStore_NewFile(PRTEFIVARSTORE pThis, uint64_t fOpen, PRTEFIVAR pVar,
|
---|
[90114] | 1337 | PCRTEFIVARSTOREFILERAWENTRY pEntry, PRTVFSOBJ phVfsObj)
|
---|
[90061] | 1338 | {
|
---|
| 1339 | RTVFSFILE hVfsFile;
|
---|
| 1340 | PRTEFIVARFILE pNewFile;
|
---|
| 1341 | int rc = RTVfsNewFile(&g_rtEfiVarStoreFileOps, sizeof(*pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK,
|
---|
| 1342 | &hVfsFile, (void **)&pNewFile);
|
---|
| 1343 | if (RT_SUCCESS(rc))
|
---|
| 1344 | {
|
---|
[90114] | 1345 | pNewFile->pEntry = pEntry;
|
---|
[90061] | 1346 | pNewFile->pVarStore = pThis;
|
---|
| 1347 | pNewFile->pVar = pVar;
|
---|
| 1348 | pNewFile->offFile = 0;
|
---|
| 1349 |
|
---|
| 1350 | *phVfsObj = RTVfsObjFromFile(hVfsFile);
|
---|
| 1351 | RTVfsFileRelease(hVfsFile);
|
---|
| 1352 | AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
|
---|
| 1353 | }
|
---|
| 1354 |
|
---|
| 1355 | return rc;
|
---|
| 1356 | }
|
---|
| 1357 |
|
---|
| 1358 |
|
---|
| 1359 |
|
---|
| 1360 | /*
|
---|
| 1361 | *
|
---|
| 1362 | * Directory instance methods
|
---|
| 1363 | * Directory instance methods
|
---|
| 1364 | * Directory instance methods
|
---|
| 1365 | *
|
---|
| 1366 | */
|
---|
| 1367 |
|
---|
| 1368 | /**
|
---|
| 1369 | * @interface_method_impl{RTVFSOBJOPS,pfnClose}
|
---|
| 1370 | */
|
---|
| 1371 | static DECLCALLBACK(int) rtEfiVarStoreDir_Close(void *pvThis)
|
---|
| 1372 | {
|
---|
| 1373 | PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
|
---|
| 1374 | LogFlowFunc(("pThis=%p\n", pThis));
|
---|
| 1375 | pThis->pVarStore = NULL;
|
---|
| 1376 | return VINF_SUCCESS;
|
---|
| 1377 | }
|
---|
| 1378 |
|
---|
| 1379 |
|
---|
| 1380 | /**
|
---|
| 1381 | * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
|
---|
| 1382 | */
|
---|
| 1383 | static DECLCALLBACK(int) rtEfiVarStoreDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
|
---|
| 1384 | {
|
---|
| 1385 | PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
|
---|
| 1386 | LogFlowFunc(("\n"));
|
---|
| 1387 | return rtEfiVarStore_QueryInfo(1, true /*fIsDir*/, &pThis->Time, pObjInfo, enmAddAttr);
|
---|
| 1388 | }
|
---|
| 1389 |
|
---|
| 1390 |
|
---|
| 1391 | /**
|
---|
| 1392 | * @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
|
---|
| 1393 | */
|
---|
| 1394 | static DECLCALLBACK(int) rtEfiVarStoreDir_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
|
---|
| 1395 | {
|
---|
| 1396 | LogFlowFunc(("\n"));
|
---|
| 1397 | RT_NOREF(pvThis, fMode, fMask);
|
---|
| 1398 | return VERR_WRITE_PROTECT;
|
---|
| 1399 | }
|
---|
| 1400 |
|
---|
| 1401 |
|
---|
| 1402 | /**
|
---|
| 1403 | * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
|
---|
| 1404 | */
|
---|
| 1405 | static DECLCALLBACK(int) rtEfiVarStoreDir_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
|
---|
| 1406 | PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
|
---|
| 1407 | {
|
---|
| 1408 | LogFlowFunc(("\n"));
|
---|
| 1409 | RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime);
|
---|
| 1410 | return VERR_WRITE_PROTECT;
|
---|
| 1411 | }
|
---|
| 1412 |
|
---|
| 1413 |
|
---|
| 1414 | /**
|
---|
| 1415 | * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
|
---|
| 1416 | */
|
---|
| 1417 | static DECLCALLBACK(int) rtEfiVarStoreDir_SetOwner(void *pvThis, RTUID uid, RTGID gid)
|
---|
| 1418 | {
|
---|
| 1419 | LogFlowFunc(("\n"));
|
---|
| 1420 | RT_NOREF(pvThis, uid, gid);
|
---|
| 1421 | return VERR_WRITE_PROTECT;
|
---|
| 1422 | }
|
---|
| 1423 |
|
---|
| 1424 |
|
---|
| 1425 | /**
|
---|
| 1426 | * @interface_method_impl{RTVFSDIROPS,pfnOpen}
|
---|
| 1427 | */
|
---|
| 1428 | static DECLCALLBACK(int) rtEfiVarStoreDir_Open(void *pvThis, const char *pszEntry, uint64_t fOpen,
|
---|
| 1429 | uint32_t fFlags, PRTVFSOBJ phVfsObj)
|
---|
| 1430 | {
|
---|
| 1431 | LogFlowFunc(("pszEntry='%s' fOpen=%#RX64 fFlags=%#x\n", pszEntry, fOpen, fFlags));
|
---|
| 1432 | PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
|
---|
| 1433 | PRTEFIVARSTORE pVarStore = pThis->pVarStore;
|
---|
| 1434 | int rc = VINF_SUCCESS;
|
---|
| 1435 |
|
---|
| 1436 | /*
|
---|
| 1437 | * Special cases '.' and '.'
|
---|
| 1438 | */
|
---|
| 1439 | if (pszEntry[0] == '.')
|
---|
| 1440 | {
|
---|
| 1441 | RTEFIVARSTOREDIRTYPE enmDirTypeNew = RTEFIVARSTOREDIRTYPE_INVALID;
|
---|
| 1442 | if (pszEntry[1] == '\0')
|
---|
[90343] | 1443 | enmDirTypeNew = pThis->pEntry->enmType;
|
---|
[90061] | 1444 | else if (pszEntry[1] == '.' && pszEntry[2] == '\0')
|
---|
[90343] | 1445 | enmDirTypeNew = pThis->pEntry->enmParentType;
|
---|
[90061] | 1446 |
|
---|
| 1447 | if (enmDirTypeNew != RTEFIVARSTOREDIRTYPE_INVALID)
|
---|
| 1448 | {
|
---|
| 1449 | if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY)
|
---|
| 1450 | {
|
---|
| 1451 | if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
|
---|
| 1452 | || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE)
|
---|
[90114] | 1453 | rc = rtEfiVarStore_NewDirByType(pVarStore, enmDirTypeNew, NULL /*pGuid*/, 0 /*idVar*/, phVfsObj);
|
---|
[90061] | 1454 | else
|
---|
| 1455 | rc = VERR_ACCESS_DENIED;
|
---|
| 1456 | }
|
---|
| 1457 | else
|
---|
| 1458 | rc = VERR_IS_A_DIRECTORY;
|
---|
| 1459 | return rc;
|
---|
| 1460 | }
|
---|
| 1461 | }
|
---|
| 1462 |
|
---|
| 1463 | /*
|
---|
[90343] | 1464 | * We can create or replace in certain directories.
|
---|
[90061] | 1465 | */
|
---|
| 1466 | if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
|
---|
[90125] | 1467 | || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
|
---|
[90343] | 1468 | || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE
|
---|
[90125] | 1469 | || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
|
---|
[90061] | 1470 | { /* likely */ }
|
---|
| 1471 | else
|
---|
| 1472 | return VERR_WRITE_PROTECT;
|
---|
| 1473 |
|
---|
[90343] | 1474 | switch (pThis->pEntry->enmType)
|
---|
[90061] | 1475 | {
|
---|
| 1476 | case RTEFIVARSTOREDIRTYPE_ROOT:
|
---|
| 1477 | {
|
---|
| 1478 | if (!strcmp(pszEntry, "by-name"))
|
---|
[90114] | 1479 | return rtEfiVarStore_NewDirByType(pVarStore, RTEFIVARSTOREDIRTYPE_BY_NAME,
|
---|
| 1480 | NULL /*pGuid*/, 0 /*idVar*/, phVfsObj);
|
---|
[90061] | 1481 | else if (!strcmp(pszEntry, "by-uuid"))
|
---|
[90114] | 1482 | return rtEfiVarStore_NewDirByType(pVarStore, RTEFIVARSTOREDIRTYPE_BY_GUID,
|
---|
| 1483 | NULL /*pGuid*/, 0 /*idVar*/, phVfsObj);
|
---|
| 1484 | else if (!strcmp(pszEntry, "raw"))
|
---|
| 1485 | return rtEfiVarStore_NewDirByType(pVarStore, RTEFIVARSTOREDIRTYPE_RAW,
|
---|
| 1486 | NULL /*pGuid*/, 0 /*idVar*/, phVfsObj);
|
---|
[90065] | 1487 | else
|
---|
| 1488 | rc = VERR_FILE_NOT_FOUND;
|
---|
[90061] | 1489 | break;
|
---|
| 1490 | }
|
---|
| 1491 | case RTEFIVARSTOREDIRTYPE_GUID: /** @todo This looks through all variables, not only the ones with the GUID. */
|
---|
| 1492 | case RTEFIVARSTOREDIRTYPE_BY_NAME:
|
---|
[90114] | 1493 | case RTEFIVARSTOREDIRTYPE_RAW:
|
---|
[90061] | 1494 | {
|
---|
| 1495 | /* Look for the name. */
|
---|
[90133] | 1496 | uint32_t idVar = 0;
|
---|
| 1497 | PRTEFIVAR pVar = rtEfiVarStore_VarGet(pVarStore, pszEntry, &idVar);
|
---|
[90343] | 1498 | if ( !pVar
|
---|
| 1499 | && ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
|
---|
| 1500 | || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE
|
---|
| 1501 | || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE))
|
---|
| 1502 | {
|
---|
| 1503 | if (pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_GUID)
|
---|
| 1504 | pVar = rtEfiVarStore_VarAdd(pVarStore, pszEntry, &pThis->pGuid->Uuid, &idVar);
|
---|
| 1505 | else
|
---|
| 1506 | {
|
---|
| 1507 | RTUUID UuidNull;
|
---|
| 1508 | RTUuidClear(&UuidNull);
|
---|
| 1509 | pVar = rtEfiVarStore_VarAdd(pVarStore, pszEntry, &UuidNull, &idVar);
|
---|
| 1510 | }
|
---|
| 1511 |
|
---|
| 1512 | if (!pVar)
|
---|
| 1513 | {
|
---|
| 1514 | rc = VERR_NO_MEMORY;
|
---|
| 1515 | break;
|
---|
| 1516 | }
|
---|
| 1517 | }
|
---|
| 1518 |
|
---|
[90133] | 1519 | if (pVar)
|
---|
| 1520 | {
|
---|
[90343] | 1521 | if (pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_RAW)
|
---|
[90133] | 1522 | return rtEfiVarStore_NewDirByType(pVarStore, RTEFIVARSTOREDIRTYPE_RAW_ENTRY,
|
---|
| 1523 | NULL /*pGuid*/, idVar, phVfsObj);
|
---|
| 1524 | else
|
---|
| 1525 | return rtEfiVarStore_NewFile(pVarStore, fOpen, pVar,
|
---|
| 1526 | &g_aRawFiles[RTEFIVARSTORE_FILE_ENTRY_DATA], phVfsObj);
|
---|
| 1527 | }
|
---|
[90061] | 1528 |
|
---|
| 1529 | rc = VERR_FILE_NOT_FOUND;
|
---|
| 1530 | break;
|
---|
| 1531 | }
|
---|
| 1532 | case RTEFIVARSTOREDIRTYPE_BY_GUID:
|
---|
| 1533 | {
|
---|
| 1534 | /* Look for the name. */
|
---|
| 1535 | for (uint32_t i = 0; i < pVarStore->cGuids; i++)
|
---|
| 1536 | {
|
---|
| 1537 | PRTEFIGUID pGuid = &pVarStore->paGuids[i];
|
---|
| 1538 | char szUuid[RTUUID_STR_LENGTH];
|
---|
| 1539 | rc = RTUuidToStr(&pGuid->Uuid, szUuid, sizeof(szUuid));
|
---|
| 1540 | AssertRC(rc);
|
---|
| 1541 |
|
---|
| 1542 | if (!strcmp(pszEntry, szUuid))
|
---|
[90114] | 1543 | return rtEfiVarStore_NewDirByType(pVarStore, RTEFIVARSTOREDIRTYPE_GUID,
|
---|
| 1544 | pGuid, 0 /*idVar*/, phVfsObj);
|
---|
[90061] | 1545 | }
|
---|
| 1546 |
|
---|
| 1547 | rc = VERR_FILE_NOT_FOUND;
|
---|
| 1548 | break;
|
---|
| 1549 | }
|
---|
[90114] | 1550 | case RTEFIVARSTOREDIRTYPE_RAW_ENTRY:
|
---|
| 1551 | {
|
---|
| 1552 | /* Look for the name. */
|
---|
| 1553 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aRawFiles); i++)
|
---|
| 1554 | if (!strcmp(pszEntry, g_aRawFiles[i].pszName))
|
---|
| 1555 | return rtEfiVarStore_NewFile(pVarStore, fOpen, &pVarStore->paVars[pThis->idVar],
|
---|
| 1556 | &g_aRawFiles[i], phVfsObj);
|
---|
| 1557 |
|
---|
| 1558 | rc = VERR_FILE_NOT_FOUND;
|
---|
| 1559 | break;
|
---|
| 1560 | }
|
---|
[90061] | 1561 | case RTEFIVARSTOREDIRTYPE_INVALID:
|
---|
| 1562 | default:
|
---|
| 1563 | AssertFailedReturn(VERR_INTERNAL_ERROR_3);
|
---|
| 1564 | }
|
---|
| 1565 |
|
---|
| 1566 | LogFlow(("rtEfiVarStoreDir_Open(%s): returns %Rrc\n", pszEntry, rc));
|
---|
| 1567 | return rc;
|
---|
| 1568 | }
|
---|
| 1569 |
|
---|
| 1570 |
|
---|
| 1571 | /**
|
---|
| 1572 | * @interface_method_impl{RTVFSDIROPS,pfnCreateDir}
|
---|
| 1573 | */
|
---|
| 1574 | static DECLCALLBACK(int) rtEfiVarStoreDir_CreateDir(void *pvThis, const char *pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir)
|
---|
| 1575 | {
|
---|
[90114] | 1576 | PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
|
---|
| 1577 | PRTEFIVARSTORE pVarStore = pThis->pVarStore;
|
---|
[90061] | 1578 | LogFlowFunc(("\n"));
|
---|
[90114] | 1579 |
|
---|
[90133] | 1580 | RT_NOREF(fMode, phVfsDir);
|
---|
[90114] | 1581 |
|
---|
| 1582 | if (pVarStore->fMntFlags & RTVFSMNT_F_READ_ONLY)
|
---|
| 1583 | return VERR_WRITE_PROTECT;
|
---|
| 1584 |
|
---|
[90133] | 1585 | /* We support creating directories only for GUIDs and RAW variable entries. */
|
---|
| 1586 | int rc = VINF_SUCCESS;
|
---|
[90343] | 1587 | if (pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_BY_GUID)
|
---|
[90133] | 1588 | {
|
---|
| 1589 | RTUUID Uuid;
|
---|
| 1590 | rc = RTUuidFromStr(&Uuid, pszSubDir);
|
---|
| 1591 | if (RT_FAILURE(rc))
|
---|
| 1592 | return VERR_NOT_SUPPORTED;
|
---|
[90114] | 1593 |
|
---|
[90133] | 1594 | PRTEFIGUID pGuid = rtEfiVarStore_GetGuid(pVarStore, &Uuid);
|
---|
| 1595 | if (pGuid)
|
---|
| 1596 | return VERR_ALREADY_EXISTS;
|
---|
[90114] | 1597 |
|
---|
[90133] | 1598 | pGuid = rtEfiVarStore_AddGuid(pVarStore, &Uuid);
|
---|
| 1599 | if (!pGuid)
|
---|
| 1600 | return VERR_NO_MEMORY;
|
---|
| 1601 | }
|
---|
[90343] | 1602 | else if (pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_RAW)
|
---|
[90133] | 1603 | {
|
---|
| 1604 | PRTEFIVAR pVar = rtEfiVarStore_VarGet(pVarStore, pszSubDir, NULL /*pidVar*/);
|
---|
| 1605 | if (!pVar)
|
---|
| 1606 | {
|
---|
| 1607 | if (sizeof(EFI_AUTH_VAR_HEADER) < pVarStore->cbVarStore - pVarStore->cbVarData)
|
---|
| 1608 | {
|
---|
| 1609 | uint32_t idVar = 0;
|
---|
[90343] | 1610 | RTUUID UuidNull;
|
---|
| 1611 | RTUuidClear(&UuidNull);
|
---|
| 1612 |
|
---|
| 1613 | pVar = rtEfiVarStore_VarAdd(pVarStore, pszSubDir, &UuidNull, &idVar);
|
---|
[90133] | 1614 | if (pVar)
|
---|
| 1615 | pVarStore->cbVarData += sizeof(EFI_AUTH_VAR_HEADER);
|
---|
| 1616 | else
|
---|
| 1617 | rc = VERR_NO_MEMORY;
|
---|
| 1618 | }
|
---|
| 1619 | else
|
---|
| 1620 | rc = VERR_DISK_FULL;
|
---|
| 1621 | }
|
---|
| 1622 | else
|
---|
| 1623 | rc = VERR_ALREADY_EXISTS;
|
---|
| 1624 | }
|
---|
| 1625 | else
|
---|
| 1626 | rc = VERR_NOT_SUPPORTED;
|
---|
[90114] | 1627 |
|
---|
[90133] | 1628 | return rc;
|
---|
[90061] | 1629 | }
|
---|
| 1630 |
|
---|
| 1631 |
|
---|
| 1632 | /**
|
---|
| 1633 | * @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink}
|
---|
| 1634 | */
|
---|
| 1635 | static DECLCALLBACK(int) rtEfiVarStoreDir_OpenSymlink(void *pvThis, const char *pszSymlink, PRTVFSSYMLINK phVfsSymlink)
|
---|
| 1636 | {
|
---|
| 1637 | RT_NOREF(pvThis, pszSymlink, phVfsSymlink);
|
---|
| 1638 | LogFlowFunc(("\n"));
|
---|
| 1639 | return VERR_NOT_SUPPORTED;
|
---|
| 1640 | }
|
---|
| 1641 |
|
---|
| 1642 |
|
---|
| 1643 | /**
|
---|
| 1644 | * @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink}
|
---|
| 1645 | */
|
---|
| 1646 | static DECLCALLBACK(int) rtEfiVarStoreDir_CreateSymlink(void *pvThis, const char *pszSymlink, const char *pszTarget,
|
---|
| 1647 | RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink)
|
---|
| 1648 | {
|
---|
| 1649 | RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink);
|
---|
| 1650 | LogFlowFunc(("\n"));
|
---|
| 1651 | return VERR_WRITE_PROTECT;
|
---|
| 1652 | }
|
---|
| 1653 |
|
---|
| 1654 |
|
---|
| 1655 | /**
|
---|
| 1656 | * @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry}
|
---|
| 1657 | */
|
---|
| 1658 | static DECLCALLBACK(int) rtEfiVarStoreDir_UnlinkEntry(void *pvThis, const char *pszEntry, RTFMODE fType)
|
---|
| 1659 | {
|
---|
[90133] | 1660 | PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
|
---|
| 1661 | PRTEFIVARSTORE pVarStore = pThis->pVarStore;
|
---|
[90061] | 1662 | LogFlowFunc(("\n"));
|
---|
[90133] | 1663 |
|
---|
| 1664 | RT_NOREF(fType);
|
---|
| 1665 |
|
---|
| 1666 | if (pVarStore->fMntFlags & RTVFSMNT_F_READ_ONLY)
|
---|
| 1667 | return VERR_WRITE_PROTECT;
|
---|
| 1668 |
|
---|
[90343] | 1669 | if ( pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_RAW
|
---|
| 1670 | || pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_BY_NAME
|
---|
| 1671 | || pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_GUID)
|
---|
[90133] | 1672 | return rtEfiVarStore_VarDelByName(pVarStore, pszEntry);
|
---|
[90343] | 1673 | else if (pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_BY_GUID)
|
---|
[90133] | 1674 | {
|
---|
| 1675 | /* Look for the name. */
|
---|
| 1676 | for (uint32_t i = 0; i < pVarStore->cGuids; i++)
|
---|
| 1677 | {
|
---|
| 1678 | PRTEFIGUID pGuid = &pVarStore->paGuids[i];
|
---|
| 1679 | char szUuid[RTUUID_STR_LENGTH];
|
---|
| 1680 | int rc = RTUuidToStr(&pGuid->Uuid, szUuid, sizeof(szUuid));
|
---|
| 1681 | AssertRC(rc); RT_NOREF(rc);
|
---|
| 1682 |
|
---|
| 1683 | if (!strcmp(pszEntry, szUuid))
|
---|
| 1684 | {
|
---|
| 1685 | for (uint32_t iVar = 0; iVar < pGuid->cVars; iVar++)
|
---|
| 1686 | rtEfiVarStore_VarDelById(pVarStore, pGuid->paidxVars[iVar]);
|
---|
| 1687 |
|
---|
| 1688 | if (pGuid->paidxVars)
|
---|
| 1689 | RTMemFree(pGuid->paidxVars);
|
---|
| 1690 | pGuid->paidxVars = NULL;
|
---|
| 1691 | pGuid->cVars = 0;
|
---|
| 1692 | pGuid->cVarsMax = 0;
|
---|
| 1693 | RTUuidClear(&pGuid->Uuid);
|
---|
| 1694 | return VINF_SUCCESS;
|
---|
| 1695 | }
|
---|
| 1696 | }
|
---|
| 1697 |
|
---|
| 1698 | return VERR_FILE_NOT_FOUND;
|
---|
| 1699 | }
|
---|
| 1700 |
|
---|
| 1701 | return VERR_NOT_SUPPORTED;
|
---|
[90061] | 1702 | }
|
---|
| 1703 |
|
---|
| 1704 |
|
---|
| 1705 | /**
|
---|
| 1706 | * @interface_method_impl{RTVFSDIROPS,pfnRenameEntry}
|
---|
| 1707 | */
|
---|
| 1708 | static DECLCALLBACK(int) rtEfiVarStoreDir_RenameEntry(void *pvThis, const char *pszEntry, RTFMODE fType, const char *pszNewName)
|
---|
| 1709 | {
|
---|
| 1710 | RT_NOREF(pvThis, pszEntry, fType, pszNewName);
|
---|
| 1711 | LogFlowFunc(("\n"));
|
---|
| 1712 | return VERR_WRITE_PROTECT;
|
---|
| 1713 | }
|
---|
| 1714 |
|
---|
| 1715 |
|
---|
| 1716 | /**
|
---|
| 1717 | * @interface_method_impl{RTVFSDIROPS,pfnRewindDir}
|
---|
| 1718 | */
|
---|
| 1719 | static DECLCALLBACK(int) rtEfiVarStoreDir_RewindDir(void *pvThis)
|
---|
| 1720 | {
|
---|
| 1721 | PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
|
---|
| 1722 | LogFlowFunc(("\n"));
|
---|
| 1723 |
|
---|
[90125] | 1724 | pThis->idxNext = 0;
|
---|
[90061] | 1725 | return VINF_SUCCESS;
|
---|
| 1726 | }
|
---|
| 1727 |
|
---|
| 1728 |
|
---|
| 1729 | /**
|
---|
| 1730 | * @interface_method_impl{RTVFSDIROPS,pfnReadDir}
|
---|
| 1731 | */
|
---|
| 1732 | static DECLCALLBACK(int) rtEfiVarStoreDir_ReadDir(void *pvThis, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry,
|
---|
| 1733 | RTFSOBJATTRADD enmAddAttr)
|
---|
| 1734 | {
|
---|
| 1735 | PRTEFIVARSTOREDIR pThis = (PRTEFIVARSTOREDIR)pvThis;
|
---|
| 1736 | PRTEFIVARSTORE pVarStore = pThis->pVarStore;
|
---|
| 1737 | LogFlowFunc(("\n"));
|
---|
| 1738 |
|
---|
| 1739 | if (pThis->fNoMoreFiles)
|
---|
| 1740 | return VERR_NO_MORE_FILES;
|
---|
| 1741 |
|
---|
| 1742 | int rc = VINF_SUCCESS;
|
---|
| 1743 | char aszUuid[RTUUID_STR_LENGTH];
|
---|
| 1744 | const char *pszName = NULL;
|
---|
| 1745 | size_t cbName = 0;
|
---|
| 1746 | uint64_t cbObject = 0;
|
---|
| 1747 | bool fIsDir = false;
|
---|
| 1748 | bool fNoMoreFiles = false;
|
---|
| 1749 | RTTIMESPEC Time;
|
---|
| 1750 | PCRTTIMESPEC pTimeSpec = &Time;
|
---|
| 1751 | RTTimeNow(&Time);
|
---|
| 1752 |
|
---|
[90343] | 1753 | switch (pThis->pEntry->enmType)
|
---|
[90061] | 1754 | {
|
---|
| 1755 | case RTEFIVARSTOREDIRTYPE_ROOT:
|
---|
| 1756 | {
|
---|
| 1757 | if (pThis->idxNext == 0)
|
---|
| 1758 | {
|
---|
| 1759 | pszName = "by-name";
|
---|
| 1760 | cbName = sizeof("by-name");
|
---|
| 1761 | cbObject = 1;
|
---|
| 1762 | fIsDir = true;
|
---|
| 1763 | }
|
---|
| 1764 | else if (pThis->idxNext == 1)
|
---|
| 1765 | {
|
---|
| 1766 | pszName = "by-uuid";
|
---|
| 1767 | cbName = sizeof("by-uuid");
|
---|
| 1768 | cbObject = 1;
|
---|
| 1769 | fIsDir = true;
|
---|
[90114] | 1770 | }
|
---|
| 1771 | else if (pThis->idxNext == 2)
|
---|
| 1772 | {
|
---|
| 1773 | pszName = "raw";
|
---|
| 1774 | cbName = sizeof("raw");
|
---|
| 1775 | cbObject = 1;
|
---|
| 1776 | fIsDir = true;
|
---|
[90061] | 1777 | fNoMoreFiles = true;
|
---|
| 1778 | }
|
---|
| 1779 | break;
|
---|
| 1780 | }
|
---|
| 1781 | case RTEFIVARSTOREDIRTYPE_BY_NAME:
|
---|
[90114] | 1782 | case RTEFIVARSTOREDIRTYPE_RAW:
|
---|
[90061] | 1783 | {
|
---|
| 1784 | PRTEFIVAR pVar = &pVarStore->paVars[pThis->idxNext];
|
---|
| 1785 | if (pThis->idxNext + 1 == pVarStore->cVars)
|
---|
| 1786 | fNoMoreFiles = true;
|
---|
| 1787 | pszName = pVar->pszName;
|
---|
| 1788 | cbName = strlen(pszName) + 1;
|
---|
[90114] | 1789 | cbObject = pVar->cbData;
|
---|
[90061] | 1790 | pTimeSpec = &pVar->Time;
|
---|
[90343] | 1791 | if (pThis->pEntry->enmType == RTEFIVARSTOREDIRTYPE_RAW)
|
---|
[90114] | 1792 | fIsDir = true;
|
---|
[90061] | 1793 | break;
|
---|
| 1794 | }
|
---|
| 1795 | case RTEFIVARSTOREDIRTYPE_BY_GUID:
|
---|
| 1796 | {
|
---|
| 1797 | PRTEFIGUID pGuid = &pVarStore->paGuids[pThis->idxNext];
|
---|
| 1798 | if (pThis->idxNext + 1 == pVarStore->cGuids)
|
---|
| 1799 | fNoMoreFiles = true;
|
---|
| 1800 | pszName = &aszUuid[0];
|
---|
| 1801 | cbName = sizeof(aszUuid);
|
---|
| 1802 | cbObject = 1;
|
---|
| 1803 | rc = RTUuidToStr(&pGuid->Uuid, &aszUuid[0], cbName);
|
---|
| 1804 | AssertRC(rc);
|
---|
| 1805 | break;
|
---|
| 1806 | }
|
---|
| 1807 | case RTEFIVARSTOREDIRTYPE_GUID:
|
---|
| 1808 | {
|
---|
| 1809 | PRTEFIGUID pGuid = pThis->pGuid;
|
---|
| 1810 | uint32_t idVar = pGuid->paidxVars[pThis->idxNext];
|
---|
| 1811 | PRTEFIVAR pVar = &pVarStore->paVars[idVar];
|
---|
| 1812 | if (pThis->idxNext + 1 == pGuid->cVars)
|
---|
| 1813 | fNoMoreFiles = true;
|
---|
| 1814 | pszName = pVar->pszName;
|
---|
| 1815 | cbName = strlen(pszName) + 1;
|
---|
[90114] | 1816 | cbObject = pVar->cbData;
|
---|
[90061] | 1817 | pTimeSpec = &pVar->Time;
|
---|
| 1818 | break;
|
---|
| 1819 | }
|
---|
[90114] | 1820 | case RTEFIVARSTOREDIRTYPE_RAW_ENTRY:
|
---|
| 1821 | {
|
---|
| 1822 | PCRTEFIVARSTOREFILERAWENTRY pEntry = &g_aRawFiles[pThis->idxNext];
|
---|
| 1823 | PRTEFIVAR pVar = &pVarStore->paVars[pThis->idVar];
|
---|
| 1824 |
|
---|
| 1825 | if (pThis->idxNext + 1 == RT_ELEMENTS(g_aRawFiles))
|
---|
| 1826 | fNoMoreFiles = true;
|
---|
| 1827 | pszName = pEntry->pszName;
|
---|
| 1828 | cbName = strlen(pszName) + 1;
|
---|
| 1829 | cbObject = pEntry->cbObject;
|
---|
| 1830 | if (!cbObject)
|
---|
| 1831 | cbObject = pVar->cbData;
|
---|
| 1832 | pTimeSpec = &pVar->Time;
|
---|
| 1833 | break;
|
---|
| 1834 | }
|
---|
[90061] | 1835 | case RTEFIVARSTOREDIRTYPE_INVALID:
|
---|
| 1836 | default:
|
---|
| 1837 | AssertFailedReturn(VERR_INTERNAL_ERROR_3);
|
---|
| 1838 | }
|
---|
| 1839 |
|
---|
| 1840 | if (cbName <= 255)
|
---|
| 1841 | {
|
---|
| 1842 | size_t const cbDirEntry = *pcbDirEntry;
|
---|
| 1843 |
|
---|
| 1844 | *pcbDirEntry = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cbName + 2]);
|
---|
| 1845 | if (*pcbDirEntry <= cbDirEntry)
|
---|
| 1846 | {
|
---|
| 1847 | memcpy(&pDirEntry->szName[0], pszName, cbName);
|
---|
| 1848 | pDirEntry->szName[cbName] = '\0';
|
---|
[90064] | 1849 | pDirEntry->cbName = (uint16_t)cbName;
|
---|
[103412] | 1850 | rc = rtEfiVarStore_QueryInfo(cbObject, fIsDir, pTimeSpec, &pDirEntry->Info, enmAddAttr);
|
---|
[90061] | 1851 | if (RT_SUCCESS(rc))
|
---|
| 1852 | {
|
---|
| 1853 | pThis->fNoMoreFiles = fNoMoreFiles;
|
---|
| 1854 | pThis->idxNext++;
|
---|
| 1855 | return VINF_SUCCESS;
|
---|
| 1856 | }
|
---|
| 1857 | }
|
---|
| 1858 | else
|
---|
| 1859 | rc = VERR_BUFFER_OVERFLOW;
|
---|
| 1860 | }
|
---|
| 1861 | else
|
---|
| 1862 | rc = VERR_FILENAME_TOO_LONG;
|
---|
| 1863 | return rc;
|
---|
| 1864 | }
|
---|
| 1865 |
|
---|
| 1866 |
|
---|
| 1867 | /**
|
---|
| 1868 | * EFI variable store directory operations.
|
---|
| 1869 | */
|
---|
| 1870 | static const RTVFSDIROPS g_rtEfiVarStoreDirOps =
|
---|
| 1871 | {
|
---|
| 1872 | { /* Obj */
|
---|
| 1873 | RTVFSOBJOPS_VERSION,
|
---|
| 1874 | RTVFSOBJTYPE_DIR,
|
---|
| 1875 | "EfiVarStore Dir",
|
---|
| 1876 | rtEfiVarStoreDir_Close,
|
---|
| 1877 | rtEfiVarStoreDir_QueryInfo,
|
---|
[94291] | 1878 | NULL,
|
---|
[90061] | 1879 | RTVFSOBJOPS_VERSION
|
---|
| 1880 | },
|
---|
| 1881 | RTVFSDIROPS_VERSION,
|
---|
| 1882 | 0,
|
---|
| 1883 | { /* ObjSet */
|
---|
| 1884 | RTVFSOBJSETOPS_VERSION,
|
---|
| 1885 | RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
|
---|
| 1886 | rtEfiVarStoreDir_SetMode,
|
---|
| 1887 | rtEfiVarStoreDir_SetTimes,
|
---|
| 1888 | rtEfiVarStoreDir_SetOwner,
|
---|
| 1889 | RTVFSOBJSETOPS_VERSION
|
---|
| 1890 | },
|
---|
| 1891 | rtEfiVarStoreDir_Open,
|
---|
| 1892 | NULL /* pfnFollowAbsoluteSymlink */,
|
---|
| 1893 | NULL /* pfnOpenFile */,
|
---|
| 1894 | NULL /* pfnOpenDir */,
|
---|
| 1895 | rtEfiVarStoreDir_CreateDir,
|
---|
| 1896 | rtEfiVarStoreDir_OpenSymlink,
|
---|
| 1897 | rtEfiVarStoreDir_CreateSymlink,
|
---|
| 1898 | NULL /* pfnQueryEntryInfo */,
|
---|
| 1899 | rtEfiVarStoreDir_UnlinkEntry,
|
---|
| 1900 | rtEfiVarStoreDir_RenameEntry,
|
---|
| 1901 | rtEfiVarStoreDir_RewindDir,
|
---|
| 1902 | rtEfiVarStoreDir_ReadDir,
|
---|
| 1903 | RTVFSDIROPS_VERSION,
|
---|
| 1904 | };
|
---|
| 1905 |
|
---|
| 1906 |
|
---|
[90114] | 1907 | static int rtEfiVarStore_NewDirByType(PRTEFIVARSTORE pThis, RTEFIVARSTOREDIRTYPE enmDirType,
|
---|
| 1908 | PRTEFIGUID pGuid, uint32_t idVar, PRTVFSOBJ phVfsObj)
|
---|
[90061] | 1909 | {
|
---|
| 1910 | RTVFSDIR hVfsDir;
|
---|
| 1911 | PRTEFIVARSTOREDIR pDir;
|
---|
| 1912 | int rc = RTVfsNewDir(&g_rtEfiVarStoreDirOps, sizeof(*pDir), 0 /*fFlags*/, pThis->hVfsSelf, NIL_RTVFSLOCK,
|
---|
| 1913 | &hVfsDir, (void **)&pDir);
|
---|
| 1914 | if (RT_SUCCESS(rc))
|
---|
| 1915 | {
|
---|
[90343] | 1916 | PCRTEFIVARSTOREDIRENTRY pEntry = NULL;
|
---|
| 1917 |
|
---|
| 1918 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aDirs); i++)
|
---|
| 1919 | if (g_aDirs[i].enmType == enmDirType)
|
---|
| 1920 | {
|
---|
| 1921 | pEntry = &g_aDirs[i];
|
---|
| 1922 | break;
|
---|
| 1923 | }
|
---|
| 1924 |
|
---|
| 1925 | AssertPtr(pEntry);
|
---|
[90061] | 1926 | pDir->idxNext = 0;
|
---|
[90343] | 1927 | pDir->pEntry = pEntry;
|
---|
[90061] | 1928 | pDir->pVarStore = pThis;
|
---|
| 1929 | pDir->pGuid = pGuid;
|
---|
[90114] | 1930 | pDir->idVar = idVar;
|
---|
[90061] | 1931 | RTTimeNow(&pDir->Time);
|
---|
| 1932 |
|
---|
| 1933 | *phVfsObj = RTVfsObjFromDir(hVfsDir);
|
---|
| 1934 | RTVfsDirRelease(hVfsDir);
|
---|
| 1935 | AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
|
---|
| 1936 | }
|
---|
| 1937 |
|
---|
| 1938 | return rc;
|
---|
| 1939 | }
|
---|
| 1940 |
|
---|
| 1941 |
|
---|
| 1942 | /*
|
---|
| 1943 | *
|
---|
| 1944 | * Volume level code.
|
---|
| 1945 | * Volume level code.
|
---|
| 1946 | * Volume level code.
|
---|
| 1947 | *
|
---|
| 1948 | */
|
---|
| 1949 |
|
---|
| 1950 | /**
|
---|
| 1951 | * @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose}
|
---|
| 1952 | */
|
---|
| 1953 | static DECLCALLBACK(int) rtEfiVarStore_Close(void *pvThis)
|
---|
| 1954 | {
|
---|
| 1955 | PRTEFIVARSTORE pThis = (PRTEFIVARSTORE)pvThis;
|
---|
| 1956 |
|
---|
[90114] | 1957 | /* Write the variable store if in read/write mode. */
|
---|
| 1958 | if (!(pThis->fMntFlags & RTVFSMNT_F_READ_ONLY))
|
---|
| 1959 | {
|
---|
| 1960 | int rc = rtEfiVarStore_Flush(pThis);
|
---|
| 1961 | if (RT_FAILURE(rc))
|
---|
| 1962 | return rc;
|
---|
| 1963 | }
|
---|
| 1964 |
|
---|
[90061] | 1965 | /*
|
---|
| 1966 | * Backing file and handles.
|
---|
| 1967 | */
|
---|
| 1968 | RTVfsFileRelease(pThis->hVfsBacking);
|
---|
| 1969 | pThis->hVfsBacking = NIL_RTVFSFILE;
|
---|
| 1970 | pThis->hVfsSelf = NIL_RTVFS;
|
---|
| 1971 | if (pThis->paVars)
|
---|
| 1972 | {
|
---|
| 1973 | for (uint32_t i = 0; i < pThis->cVars; i++)
|
---|
[90314] | 1974 | {
|
---|
[90061] | 1975 | RTStrFree(pThis->paVars[i].pszName);
|
---|
[90314] | 1976 | if (pThis->paVars[i].pvData)
|
---|
| 1977 | RTMemFree(pThis->paVars[i].pvData);
|
---|
| 1978 | }
|
---|
[90061] | 1979 |
|
---|
| 1980 | RTMemFree(pThis->paVars);
|
---|
| 1981 | pThis->paVars = NULL;
|
---|
| 1982 | pThis->cVars = 0;
|
---|
| 1983 | pThis->cVarsMax = 0;
|
---|
| 1984 | }
|
---|
| 1985 |
|
---|
| 1986 | if (pThis->paGuids)
|
---|
| 1987 | {
|
---|
| 1988 | for (uint32_t i = 0; i < pThis->cGuids; i++)
|
---|
| 1989 | {
|
---|
| 1990 | PRTEFIGUID pGuid = &pThis->paGuids[i];
|
---|
| 1991 |
|
---|
[90133] | 1992 | if (pGuid->paidxVars)
|
---|
| 1993 | {
|
---|
| 1994 | RTMemFree(pGuid->paidxVars);
|
---|
| 1995 | pGuid->paidxVars = NULL;
|
---|
| 1996 | }
|
---|
[90061] | 1997 | }
|
---|
| 1998 |
|
---|
| 1999 | RTMemFree(pThis->paGuids);
|
---|
| 2000 | pThis->paGuids = NULL;
|
---|
| 2001 | }
|
---|
| 2002 |
|
---|
| 2003 | return VINF_SUCCESS;
|
---|
| 2004 | }
|
---|
| 2005 |
|
---|
| 2006 |
|
---|
| 2007 | /**
|
---|
| 2008 | * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo}
|
---|
| 2009 | */
|
---|
| 2010 | static DECLCALLBACK(int) rtEfiVarStore_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
|
---|
| 2011 | {
|
---|
| 2012 | RT_NOREF(pvThis, pObjInfo, enmAddAttr);
|
---|
| 2013 | return VERR_WRONG_TYPE;
|
---|
| 2014 | }
|
---|
| 2015 |
|
---|
| 2016 |
|
---|
| 2017 | /**
|
---|
| 2018 | * @interface_method_impl{RTVFSOBJOPS::Obj,pfnOpenRoot}
|
---|
| 2019 | */
|
---|
| 2020 | static DECLCALLBACK(int) rtEfiVarStore_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir)
|
---|
| 2021 | {
|
---|
| 2022 | PRTEFIVARSTORE pThis = (PRTEFIVARSTORE)pvThis;
|
---|
[90343] | 2023 | RTVFSOBJ hVfsObj;
|
---|
| 2024 | int rc = rtEfiVarStore_NewDirByType(pThis, RTEFIVARSTOREDIRTYPE_ROOT,
|
---|
| 2025 | NULL /*pGuid*/, 0 /*idVar*/, &hVfsObj);
|
---|
[90061] | 2026 | if (RT_SUCCESS(rc))
|
---|
| 2027 | {
|
---|
[90343] | 2028 | *phVfsDir = RTVfsObjToDir(hVfsObj);
|
---|
| 2029 | RTVfsObjRelease(hVfsObj);
|
---|
[90061] | 2030 | }
|
---|
| 2031 |
|
---|
| 2032 | LogFlowFunc(("returns %Rrc\n", rc));
|
---|
| 2033 | return rc;
|
---|
| 2034 | }
|
---|
| 2035 |
|
---|
| 2036 |
|
---|
| 2037 | DECL_HIDDEN_CONST(const RTVFSOPS) g_rtEfiVarStoreOps =
|
---|
| 2038 | {
|
---|
| 2039 | /* .Obj = */
|
---|
| 2040 | {
|
---|
| 2041 | /* .uVersion = */ RTVFSOBJOPS_VERSION,
|
---|
| 2042 | /* .enmType = */ RTVFSOBJTYPE_VFS,
|
---|
| 2043 | /* .pszName = */ "EfiVarStore",
|
---|
| 2044 | /* .pfnClose = */ rtEfiVarStore_Close,
|
---|
| 2045 | /* .pfnQueryInfo = */ rtEfiVarStore_QueryInfo,
|
---|
[94291] | 2046 | /* .pfnQueryInfoEx = */ NULL,
|
---|
[90061] | 2047 | /* .uEndMarker = */ RTVFSOBJOPS_VERSION
|
---|
| 2048 | },
|
---|
| 2049 | /* .uVersion = */ RTVFSOPS_VERSION,
|
---|
| 2050 | /* .fFeatures = */ 0,
|
---|
| 2051 | /* .pfnOpenRoot = */ rtEfiVarStore_OpenRoot,
|
---|
| 2052 | /* .pfnQueryRangeState = */ NULL,
|
---|
| 2053 | /* .uEndMarker = */ RTVFSOPS_VERSION
|
---|
| 2054 | };
|
---|
| 2055 |
|
---|
| 2056 |
|
---|
| 2057 | /**
|
---|
| 2058 | * Validates the given firmware header.
|
---|
| 2059 | *
|
---|
| 2060 | * @returns true if the given header is considered valid, flse otherwise.
|
---|
| 2061 | * @param pThis The EFI variable store instance.
|
---|
| 2062 | * @param pFvHdr The firmware volume header to validate.
|
---|
| 2063 | * @param poffData The offset into the backing where the data area begins.
|
---|
| 2064 | * @param pErrInfo Where to return additional error info.
|
---|
| 2065 | */
|
---|
| 2066 | static int rtEfiVarStoreFvHdr_Validate(PRTEFIVARSTORE pThis, PCEFI_FIRMWARE_VOLUME_HEADER pFvHdr, uint64_t *poffData,
|
---|
| 2067 | PRTERRINFO pErrInfo)
|
---|
| 2068 | {
|
---|
| 2069 | #ifdef LOG_ENABLED
|
---|
| 2070 | rtEfiVarStoreFvHdr_Log(pFvHdr);
|
---|
| 2071 | #endif
|
---|
| 2072 |
|
---|
| 2073 | EFI_GUID GuidNvData = EFI_VARSTORE_FILESYSTEM_GUID;
|
---|
| 2074 | if (memcmp(&pFvHdr->GuidFilesystem, &GuidNvData, sizeof(GuidNvData)))
|
---|
| 2075 | return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Filesystem GUID doesn't indicate a variable store");
|
---|
| 2076 | if (RT_LE2H_U64(pFvHdr->cbFv) > pThis->cbBacking)
|
---|
| 2077 | return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Firmware volume length exceeds size of backing storage (truncated file?)");
|
---|
| 2078 | /* Signature was already verfied by caller. */
|
---|
| 2079 | /** @todo Check attributes. */
|
---|
| 2080 | if (pFvHdr->bRsvd != 0)
|
---|
| 2081 | return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Reserved field of header is not 0");
|
---|
| 2082 | if (pFvHdr->bRevision != EFI_FIRMWARE_VOLUME_HEADER_REVISION)
|
---|
| 2083 | return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Unexpected revision of the firmware volume header");
|
---|
| 2084 | if (RT_LE2H_U16(pFvHdr->offExtHdr) != 0)
|
---|
| 2085 | return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Firmware volume header contains unsupported extended headers");
|
---|
| 2086 |
|
---|
| 2087 | /* Start calculating the checksum of the main header. */
|
---|
| 2088 | uint16_t u16Chksum = 0;
|
---|
| 2089 | const uint16_t *pu16 = (const uint16_t *)pFvHdr;
|
---|
| 2090 | while (pu16 < (const uint16_t *)pFvHdr + (sizeof(*pFvHdr) / sizeof(uint16_t)))
|
---|
| 2091 | u16Chksum += RT_LE2H_U16(*pu16++);
|
---|
| 2092 |
|
---|
| 2093 | /* Read in the block map and verify it as well. */
|
---|
| 2094 | uint64_t cbFvVol = 0;
|
---|
[93283] | 2095 | uint64_t cbFvHdr = sizeof(*pFvHdr);
|
---|
[90061] | 2096 | uint64_t offBlockMap = sizeof(*pFvHdr);
|
---|
| 2097 | for (;;)
|
---|
| 2098 | {
|
---|
| 2099 | EFI_FW_BLOCK_MAP BlockMap;
|
---|
| 2100 | int rc = RTVfsFileReadAt(pThis->hVfsBacking, offBlockMap, &BlockMap, sizeof(BlockMap), NULL);
|
---|
| 2101 | if (RT_FAILURE(rc))
|
---|
| 2102 | return RTERRINFO_LOG_SET_F(pErrInfo, rc, "Reading block map entry from %#RX64 failed", offBlockMap);
|
---|
| 2103 |
|
---|
| 2104 | cbFvHdr += sizeof(BlockMap);
|
---|
| 2105 | offBlockMap += sizeof(BlockMap);
|
---|
| 2106 |
|
---|
| 2107 | /* A zero entry denotes the end. */
|
---|
| 2108 | if ( !RT_LE2H_U32(BlockMap.cBlocks)
|
---|
| 2109 | && !RT_LE2H_U32(BlockMap.cbBlock))
|
---|
| 2110 | break;
|
---|
| 2111 |
|
---|
| 2112 | cbFvVol += RT_LE2H_U32(BlockMap.cBlocks) * RT_LE2H_U32(BlockMap.cbBlock);
|
---|
| 2113 |
|
---|
| 2114 | pu16 = (const uint16_t *)&BlockMap;
|
---|
| 2115 | while (pu16 < (const uint16_t *)&BlockMap + (sizeof(BlockMap) / sizeof(uint16_t)))
|
---|
| 2116 | u16Chksum += RT_LE2H_U16(*pu16++);
|
---|
| 2117 | }
|
---|
| 2118 |
|
---|
| 2119 | *poffData = offBlockMap;
|
---|
| 2120 |
|
---|
| 2121 | if (u16Chksum)
|
---|
| 2122 | return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Firmware volume header has incorrect checksum");
|
---|
[96578] | 2123 | if (RT_LE2H_U16(pFvHdr->cbFvHdr) != cbFvHdr)
|
---|
[90061] | 2124 | return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Unexpected firmware volume header size");
|
---|
| 2125 |
|
---|
| 2126 | return VINF_SUCCESS;
|
---|
| 2127 | }
|
---|
| 2128 |
|
---|
| 2129 |
|
---|
| 2130 | /**
|
---|
| 2131 | * Validates the given variable store header.
|
---|
| 2132 | *
|
---|
| 2133 | * @returns true if the given header is considered valid, false otherwise.
|
---|
| 2134 | * @param pThis The EFI variable store instance.
|
---|
| 2135 | * @param pHdr The variable store header to validate.
|
---|
| 2136 | * @param pfAuth Where to store whether the variable store uses authenticated variables or not.
|
---|
| 2137 | * @param pErrInfo Where to return additional error info.
|
---|
| 2138 | */
|
---|
| 2139 | static int rtEfiVarStoreHdr_Validate(PRTEFIVARSTORE pThis, PCEFI_VARSTORE_HEADER pHdr, bool *pfAuth, PRTERRINFO pErrInfo)
|
---|
| 2140 | {
|
---|
| 2141 | #ifdef LOG_ENABLED
|
---|
| 2142 | rtEfiVarStoreHdr_Log(pHdr);
|
---|
| 2143 | #endif
|
---|
| 2144 |
|
---|
| 2145 | EFI_GUID GuidVarStoreAuth = EFI_VARSTORE_HEADER_GUID_AUTHENTICATED_VARIABLE;
|
---|
| 2146 | EFI_GUID GuidVarStore = EFI_VARSTORE_HEADER_GUID_VARIABLE;
|
---|
| 2147 | if (!memcmp(&pHdr->GuidVarStore, &GuidVarStoreAuth, sizeof(GuidVarStoreAuth)))
|
---|
| 2148 | *pfAuth = true;
|
---|
| 2149 | else if (!memcmp(&pHdr->GuidVarStore, &GuidVarStore, sizeof(GuidVarStore)))
|
---|
| 2150 | *pfAuth = false;
|
---|
| 2151 | else
|
---|
[99423] | 2152 | return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
|
---|
| 2153 | "Variable store GUID doesn't indicate a variable store (%RTuuid)", pHdr->GuidVarStore);
|
---|
[90061] | 2154 | if (RT_LE2H_U32(pHdr->cbVarStore) >= pThis->cbBacking)
|
---|
[99423] | 2155 | return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
|
---|
| 2156 | "Variable store length exceeds size of backing storage (truncated file?): %#RX32, max %#RX64",
|
---|
| 2157 | RT_LE2H_U32(pHdr->cbVarStore), pThis->cbBacking);
|
---|
[90061] | 2158 | if (pHdr->bFmt != EFI_VARSTORE_HEADER_FMT_FORMATTED)
|
---|
[99423] | 2159 | return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable store is not formatted (%#x)", pHdr->bFmt);
|
---|
[90061] | 2160 | if (pHdr->bState != EFI_VARSTORE_HEADER_STATE_HEALTHY)
|
---|
[99423] | 2161 | return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable store is not healthy (%#x)", pHdr->bState);
|
---|
[90061] | 2162 |
|
---|
| 2163 | return VINF_SUCCESS;
|
---|
| 2164 | }
|
---|
| 2165 |
|
---|
| 2166 |
|
---|
| 2167 | /**
|
---|
| 2168 | * Validates the given authenticate variable header.
|
---|
| 2169 | *
|
---|
| 2170 | * @returns true if the given header is considered valid, false otherwise.
|
---|
| 2171 | * @param pThis The EFI variable store instance.
|
---|
| 2172 | * @param pVarHdr The variable header to validate.
|
---|
| 2173 | * @param offVar Offset of the authenticated variable header.
|
---|
| 2174 | * @param pErrInfo Where to return additional error info.
|
---|
| 2175 | */
|
---|
| 2176 | static int rtEfiVarStoreAuthVar_Validate(PRTEFIVARSTORE pThis, PCEFI_AUTH_VAR_HEADER pVarHdr, uint64_t offVar, PRTERRINFO pErrInfo)
|
---|
| 2177 | {
|
---|
| 2178 | #ifdef LOG_ENABLED
|
---|
| 2179 | rtEfiVarStoreAuthVarHdr_Log(pVarHdr, offVar);
|
---|
| 2180 | #endif
|
---|
| 2181 |
|
---|
| 2182 | uint32_t cbName = RT_LE2H_U32(pVarHdr->cbName);
|
---|
| 2183 | uint32_t cbData = RT_LE2H_U32(pVarHdr->cbData);
|
---|
| 2184 | uint64_t cbVarMax = pThis->cbBacking - offVar - sizeof(*pVarHdr);
|
---|
| 2185 | if ( cbVarMax <= cbName
|
---|
| 2186 | || cbVarMax - cbName <= cbData)
|
---|
[90314] | 2187 | return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable exceeds remaining space in store (cbName=%u cbData=%u cbVarMax=%llu)",
|
---|
[90061] | 2188 | cbName, cbData, cbVarMax);
|
---|
| 2189 |
|
---|
| 2190 | return VINF_SUCCESS;
|
---|
| 2191 | }
|
---|
| 2192 |
|
---|
| 2193 |
|
---|
| 2194 | /**
|
---|
| 2195 | * Loads the authenticated variable at the given offset.
|
---|
| 2196 | *
|
---|
| 2197 | * @returns IPRT status code.
|
---|
| 2198 | * @retval VERR_EOF if the end of the store was reached.
|
---|
| 2199 | * @param pThis The EFI variable store instance.
|
---|
| 2200 | * @param offVar Offset of the variable to load.
|
---|
| 2201 | * @param poffVarEnd Where to store the offset pointing to the end of the variable.
|
---|
| 2202 | * @param fIgnoreDelVars Flag whether to ignore deleted variables.
|
---|
| 2203 | * @param pErrInfo Where to return additional error info.
|
---|
| 2204 | */
|
---|
| 2205 | static int rtEfiVarStoreLoadAuthVar(PRTEFIVARSTORE pThis, uint64_t offVar, uint64_t *poffVarEnd,
|
---|
| 2206 | bool fIgnoreDelVars, PRTERRINFO pErrInfo)
|
---|
| 2207 | {
|
---|
| 2208 | EFI_AUTH_VAR_HEADER VarHdr;
|
---|
| 2209 | int rc = RTVfsFileReadAt(pThis->hVfsBacking, offVar, &VarHdr, sizeof(VarHdr), NULL);
|
---|
| 2210 | if (RT_FAILURE(rc))
|
---|
| 2211 | return rc;
|
---|
| 2212 |
|
---|
| 2213 | rc = rtEfiVarStoreAuthVar_Validate(pThis, &VarHdr, offVar, pErrInfo);
|
---|
| 2214 | if (RT_FAILURE(rc))
|
---|
| 2215 | return rc;
|
---|
| 2216 |
|
---|
| 2217 | if (poffVarEnd)
|
---|
| 2218 | *poffVarEnd = offVar + sizeof(VarHdr) + RT_LE2H_U32(VarHdr.cbData) + RT_LE2H_U32(VarHdr.cbName);
|
---|
| 2219 |
|
---|
| 2220 | /* Only add complete variables or deleted variables when requested. */
|
---|
| 2221 | if ( ( fIgnoreDelVars
|
---|
| 2222 | && VarHdr.bState != EFI_AUTH_VAR_HEADER_STATE_ADDED)
|
---|
| 2223 | || VarHdr.bState == EFI_AUTH_VAR_HEADER_STATE_HDR_VALID_ONLY)
|
---|
| 2224 | return VINF_SUCCESS;
|
---|
| 2225 |
|
---|
| 2226 | pThis->cbVarData += sizeof(VarHdr) + RT_LE2H_U32(VarHdr.cbData) + RT_LE2H_U32(VarHdr.cbName);
|
---|
| 2227 |
|
---|
| 2228 | RTUTF16 awchName[128]; RT_ZERO(awchName);
|
---|
| 2229 | if (RT_LE2H_U32(VarHdr.cbName) > sizeof(awchName) - sizeof(RTUTF16))
|
---|
| 2230 | return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Variable name is too long (%llu vs. %llu)\n",
|
---|
[90063] | 2231 | RT_LE2H_U32(VarHdr.cbName), sizeof(awchName));
|
---|
[90061] | 2232 |
|
---|
| 2233 | rc = RTVfsFileReadAt(pThis->hVfsBacking, offVar + sizeof(VarHdr), &awchName[0], RT_LE2H_U32(VarHdr.cbName), NULL);
|
---|
| 2234 | if (RT_FAILURE(rc))
|
---|
| 2235 | return rc;
|
---|
| 2236 |
|
---|
| 2237 | Log2(("Variable name '%ls'\n", &awchName[0]));
|
---|
[90133] | 2238 | rc = rtEfiVarStore_VarMaybeGrowEntries(pThis);
|
---|
| 2239 | if (RT_FAILURE(rc))
|
---|
| 2240 | return rc;
|
---|
[90061] | 2241 |
|
---|
| 2242 | PRTEFIVAR pVar = &pThis->paVars[pThis->cVars++];
|
---|
| 2243 | pVar->pVarStore = pThis;
|
---|
[90314] | 2244 | if (RT_LE2H_U32(VarHdr.cbData))
|
---|
| 2245 | pVar->offVarData = offVar + sizeof(VarHdr) + RT_LE2H_U32(VarHdr.cbName);
|
---|
| 2246 | else
|
---|
| 2247 | pVar->offVarData = 0;
|
---|
[90114] | 2248 | pVar->fAttr = RT_LE2H_U32(VarHdr.fAttr);
|
---|
| 2249 | pVar->cMonotonic = RT_LE2H_U64(VarHdr.cMonotonic);
|
---|
| 2250 | pVar->idPubKey = RT_LE2H_U32(VarHdr.idPubKey);
|
---|
| 2251 | pVar->cbData = RT_LE2H_U32(VarHdr.cbData);
|
---|
[90125] | 2252 | pVar->pvData = NULL;
|
---|
[90133] | 2253 | pVar->fDeleted = false;
|
---|
[90114] | 2254 | memcpy(&pVar->EfiTimestamp, &VarHdr.Timestamp, sizeof(VarHdr.Timestamp));
|
---|
| 2255 |
|
---|
[90061] | 2256 | if (VarHdr.Timestamp.u8Month)
|
---|
| 2257 | RTEfiTimeToTimeSpec(&pVar->Time, &VarHdr.Timestamp);
|
---|
| 2258 | else
|
---|
| 2259 | RTTimeNow(&pVar->Time);
|
---|
| 2260 |
|
---|
| 2261 | RTEfiGuidToUuid(&pVar->Uuid, &VarHdr.GuidVendor);
|
---|
| 2262 |
|
---|
| 2263 | rc = RTUtf16ToUtf8(&awchName[0], &pVar->pszName);
|
---|
| 2264 | if (RT_FAILURE(rc))
|
---|
| 2265 | pThis->cVars--;
|
---|
| 2266 |
|
---|
| 2267 | rc = rtEfiVarStore_AddVarByGuid(pThis, &pVar->Uuid, pThis->cVars - 1);
|
---|
| 2268 |
|
---|
| 2269 | return rc;
|
---|
| 2270 | }
|
---|
| 2271 |
|
---|
| 2272 |
|
---|
| 2273 | /**
|
---|
| 2274 | * Looks for the next variable starting at the given offset.
|
---|
| 2275 | *
|
---|
| 2276 | * @returns IPRT status code.
|
---|
| 2277 | * @retval VERR_EOF if the end of the store was reached.
|
---|
| 2278 | * @param pThis The EFI variable store instance.
|
---|
| 2279 | * @param offStart Where in the image to start looking.
|
---|
| 2280 | * @param poffVar Where to store the start of the next variable if found.
|
---|
| 2281 | */
|
---|
| 2282 | static int rtEfiVarStoreFindVar(PRTEFIVARSTORE pThis, uint64_t offStart, uint64_t *poffVar)
|
---|
| 2283 | {
|
---|
| 2284 | /* Try to find the ID indicating a variable start by loading data in chunks. */
|
---|
| 2285 | uint64_t offEnd = pThis->offStoreData + pThis->cbVarStore;
|
---|
| 2286 | while (offStart < offEnd)
|
---|
| 2287 | {
|
---|
| 2288 | uint16_t au16Tmp[_1K / sizeof(uint16_t)];
|
---|
| 2289 | size_t cbThisRead = RT_MIN(sizeof(au16Tmp), offEnd - offStart);
|
---|
| 2290 | int rc = RTVfsFileReadAt(pThis->hVfsBacking, offStart, &au16Tmp[0], sizeof(au16Tmp), NULL);
|
---|
| 2291 | if (RT_FAILURE(rc))
|
---|
| 2292 | return rc;
|
---|
| 2293 |
|
---|
| 2294 | for (uint32_t i = 0; i < RT_ELEMENTS(au16Tmp); i++)
|
---|
| 2295 | if (RT_LE2H_U16(au16Tmp[i]) == EFI_AUTH_VAR_HEADER_START)
|
---|
| 2296 | {
|
---|
| 2297 | *poffVar = offStart + i * sizeof(uint16_t);
|
---|
| 2298 | return VINF_SUCCESS;
|
---|
| 2299 | }
|
---|
| 2300 |
|
---|
| 2301 | offStart += cbThisRead;
|
---|
| 2302 | }
|
---|
| 2303 |
|
---|
| 2304 | return VERR_EOF;
|
---|
| 2305 | }
|
---|
| 2306 |
|
---|
| 2307 |
|
---|
| 2308 | /**
|
---|
| 2309 | * Loads and parses the superblock of the filesystem.
|
---|
| 2310 | *
|
---|
| 2311 | * @returns IPRT status code.
|
---|
| 2312 | * @param pThis The EFI variable store instance.
|
---|
| 2313 | * @param pErrInfo Where to return additional error info.
|
---|
| 2314 | */
|
---|
| 2315 | static int rtEfiVarStoreLoad(PRTEFIVARSTORE pThis, PRTERRINFO pErrInfo)
|
---|
| 2316 | {
|
---|
| 2317 | EFI_FIRMWARE_VOLUME_HEADER FvHdr;
|
---|
[99423] | 2318 | int rc = RTVfsFileReadAt(pThis->hVfsBacking, 0, &FvHdr, sizeof(FvHdr), NULL);
|
---|
[90061] | 2319 | if (RT_FAILURE(rc))
|
---|
| 2320 | return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading firmware volume header");
|
---|
| 2321 |
|
---|
| 2322 | /* Validate the signature. */
|
---|
| 2323 | if (RT_LE2H_U32(FvHdr.u32Signature) != EFI_FIRMWARE_VOLUME_HEADER_SIGNATURE)
|
---|
| 2324 | return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not a EFI variable store - Signature mismatch: %RX32", RT_LE2H_U16(FvHdr.u32Signature));
|
---|
| 2325 |
|
---|
| 2326 | uint64_t offData = 0;
|
---|
| 2327 | rc = rtEfiVarStoreFvHdr_Validate(pThis, &FvHdr, &offData, pErrInfo);
|
---|
| 2328 | if (RT_FAILURE(rc))
|
---|
| 2329 | return rc;
|
---|
| 2330 |
|
---|
| 2331 | EFI_VARSTORE_HEADER StoreHdr;
|
---|
| 2332 | rc = RTVfsFileReadAt(pThis->hVfsBacking, offData, &StoreHdr, sizeof(StoreHdr), NULL);
|
---|
| 2333 | if (RT_FAILURE(rc))
|
---|
| 2334 | return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading variable store header");
|
---|
| 2335 |
|
---|
| 2336 | rc = rtEfiVarStoreHdr_Validate(pThis, &StoreHdr, &pThis->fAuth, pErrInfo);
|
---|
| 2337 | if (RT_FAILURE(rc))
|
---|
| 2338 | return rc;
|
---|
| 2339 |
|
---|
| 2340 | pThis->offStoreData = offData + sizeof(StoreHdr);
|
---|
| 2341 | pThis->cbVarStore = RT_LE2H_U32(StoreHdr.cbVarStore) - sizeof(StoreHdr);
|
---|
| 2342 |
|
---|
| 2343 | /* Go over variables and set up the pointers. */
|
---|
| 2344 | offData = pThis->offStoreData;
|
---|
| 2345 | for (;;)
|
---|
| 2346 | {
|
---|
| 2347 | uint64_t offVar = 0;
|
---|
| 2348 |
|
---|
| 2349 | rc = rtEfiVarStoreFindVar(pThis, offData, &offVar);
|
---|
| 2350 | if (RT_FAILURE(rc))
|
---|
| 2351 | break;
|
---|
| 2352 |
|
---|
| 2353 | rc = rtEfiVarStoreLoadAuthVar(pThis, offVar, &offData, true /* fIgnoreDelVars*/, pErrInfo);
|
---|
| 2354 | if (RT_FAILURE(rc))
|
---|
| 2355 | break;
|
---|
| 2356 |
|
---|
| 2357 | /* Align to 16bit boundary. */
|
---|
| 2358 | offData = RT_ALIGN_64(offData, 2);
|
---|
[90068] | 2359 | }
|
---|
[90061] | 2360 |
|
---|
| 2361 | if (rc == VERR_EOF) /* Reached end of variable store. */
|
---|
| 2362 | rc = VINF_SUCCESS;
|
---|
| 2363 |
|
---|
| 2364 | return rc;
|
---|
| 2365 | }
|
---|
| 2366 |
|
---|
| 2367 |
|
---|
[91497] | 2368 | /**
|
---|
| 2369 | * Fills the given range with 0xff to match what a real NAND flash device would return for
|
---|
| 2370 | * unwritten storage.
|
---|
| 2371 | *
|
---|
| 2372 | * @returns IPRT status code.
|
---|
| 2373 | * @param hVfsFile The VFS file handle to write to.
|
---|
| 2374 | * @param offStart The start offset to fill.
|
---|
| 2375 | * @param offEnd Offset to fill up to (exclusive).
|
---|
| 2376 | */
|
---|
| 2377 | static int rtEfiVarStoreFillWithFF(RTVFSFILE hVfsFile, uint64_t offStart, uint64_t offEnd)
|
---|
| 2378 | {
|
---|
| 2379 | int rc = VINF_SUCCESS;
|
---|
| 2380 | uint8_t abFF[512];
|
---|
| 2381 | memset(&abFF[0], 0xff, sizeof(abFF));
|
---|
| 2382 |
|
---|
| 2383 | while ( offStart < offEnd
|
---|
| 2384 | && RT_SUCCESS(rc))
|
---|
| 2385 | {
|
---|
| 2386 | size_t cbThisWrite = RT_MIN(sizeof(abFF), offEnd - offStart);
|
---|
| 2387 | rc = RTVfsFileWriteAt(hVfsFile, offStart, &abFF[0], cbThisWrite, NULL);
|
---|
| 2388 | offStart += cbThisWrite;
|
---|
| 2389 | }
|
---|
| 2390 |
|
---|
| 2391 | return rc;
|
---|
| 2392 | }
|
---|
| 2393 |
|
---|
| 2394 |
|
---|
[90061] | 2395 | RTDECL(int) RTEfiVarStoreOpenAsVfs(RTVFSFILE hVfsFileIn, uint32_t fMntFlags, uint32_t fVarStoreFlags, PRTVFS phVfs, PRTERRINFO pErrInfo)
|
---|
| 2396 | {
|
---|
| 2397 | AssertPtrReturn(phVfs, VERR_INVALID_POINTER);
|
---|
| 2398 | AssertReturn(!(fMntFlags & ~RTVFSMNT_F_VALID_MASK), VERR_INVALID_FLAGS);
|
---|
| 2399 | AssertReturn(!fVarStoreFlags, VERR_INVALID_FLAGS);
|
---|
| 2400 |
|
---|
| 2401 | uint32_t cRefs = RTVfsFileRetain(hVfsFileIn);
|
---|
| 2402 | AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
|
---|
| 2403 |
|
---|
| 2404 | /*
|
---|
| 2405 | * Create a VFS instance and initialize the data so rtFsExtVol_Close works.
|
---|
| 2406 | */
|
---|
| 2407 | RTVFS hVfs;
|
---|
| 2408 | PRTEFIVARSTORE pThis;
|
---|
| 2409 | int rc = RTVfsNew(&g_rtEfiVarStoreOps, sizeof(*pThis), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, (void **)&pThis);
|
---|
| 2410 | if (RT_SUCCESS(rc))
|
---|
| 2411 | {
|
---|
| 2412 | pThis->hVfsBacking = hVfsFileIn;
|
---|
| 2413 | pThis->hVfsSelf = hVfs;
|
---|
| 2414 | pThis->fMntFlags = fMntFlags;
|
---|
| 2415 | pThis->fVarStoreFlags = fVarStoreFlags;
|
---|
| 2416 |
|
---|
| 2417 | rc = RTVfsFileQuerySize(pThis->hVfsBacking, &pThis->cbBacking);
|
---|
| 2418 | if (RT_SUCCESS(rc))
|
---|
| 2419 | {
|
---|
| 2420 | rc = rtEfiVarStoreLoad(pThis, pErrInfo);
|
---|
| 2421 | if (RT_SUCCESS(rc))
|
---|
| 2422 | {
|
---|
| 2423 | *phVfs = hVfs;
|
---|
| 2424 | return VINF_SUCCESS;
|
---|
| 2425 | }
|
---|
| 2426 | }
|
---|
| 2427 |
|
---|
| 2428 | RTVfsRelease(hVfs);
|
---|
| 2429 | *phVfs = NIL_RTVFS;
|
---|
| 2430 | }
|
---|
| 2431 | else
|
---|
| 2432 | RTVfsFileRelease(hVfsFileIn);
|
---|
| 2433 |
|
---|
| 2434 | return rc;
|
---|
| 2435 | }
|
---|
| 2436 |
|
---|
| 2437 |
|
---|
| 2438 | RTDECL(int) RTEfiVarStoreCreate(RTVFSFILE hVfsFile, uint64_t offStore, uint64_t cbStore, uint32_t fFlags, uint32_t cbBlock,
|
---|
| 2439 | PRTERRINFO pErrInfo)
|
---|
| 2440 | {
|
---|
| 2441 | RT_NOREF(pErrInfo);
|
---|
| 2442 |
|
---|
| 2443 | /*
|
---|
| 2444 | * Validate input.
|
---|
| 2445 | */
|
---|
| 2446 | if (!cbBlock)
|
---|
| 2447 | cbBlock = 4096;
|
---|
| 2448 | else
|
---|
| 2449 | AssertMsgReturn(cbBlock <= 8192 && RT_IS_POWER_OF_TWO(cbBlock),
|
---|
| 2450 | ("cbBlock=%#x\n", cbBlock), VERR_INVALID_PARAMETER);
|
---|
| 2451 | AssertReturn(!(fFlags & ~RTEFIVARSTORE_CREATE_F_VALID_MASK), VERR_INVALID_FLAGS);
|
---|
| 2452 |
|
---|
| 2453 | if (!cbStore)
|
---|
| 2454 | {
|
---|
| 2455 | uint64_t cbFile;
|
---|
| 2456 | int rc = RTVfsFileQuerySize(hVfsFile, &cbFile);
|
---|
| 2457 | AssertRCReturn(rc, rc);
|
---|
| 2458 | AssertMsgReturn(cbFile > offStore, ("cbFile=%#RX64 offStore=%#RX64\n", cbFile, offStore), VERR_INVALID_PARAMETER);
|
---|
| 2459 | cbStore = cbFile - offStore;
|
---|
| 2460 | }
|
---|
[91497] | 2461 |
|
---|
| 2462 | uint32_t cbFtw = 0;
|
---|
| 2463 | uint32_t offFtw = 0;
|
---|
| 2464 | uint32_t cbVarStore = cbStore;
|
---|
| 2465 | uint32_t cbNvEventLog = 0;
|
---|
| 2466 | uint32_t offNvEventLog = 0;
|
---|
| 2467 | if (!(fFlags & RTEFIVARSTORE_CREATE_F_NO_FTW_WORKING_SPACE))
|
---|
| 2468 | {
|
---|
| 2469 | /* Split the available space in half for the fault tolerant working area. */
|
---|
| 2470 | /** @todo Don't fully understand how these values come together right now but
|
---|
| 2471 | * we want to create NVRAM files matching the default OVMF_VARS.fd for now, see
|
---|
| 2472 | * https://github.com/tianocore/edk2/commit/b24fca05751f8222acf264853709012e0ab7bf49
|
---|
| 2473 | * for the layout.
|
---|
| 2474 | * Probably have toadd more arguments to control the different parameters.
|
---|
| 2475 | */
|
---|
| 2476 | cbNvEventLog = _4K;
|
---|
| 2477 | cbVarStore = cbStore / 2 - cbNvEventLog - _4K;
|
---|
| 2478 | cbFtw = cbVarStore + _4K;
|
---|
| 2479 | offNvEventLog = cbVarStore;
|
---|
| 2480 | offFtw = offNvEventLog + cbNvEventLog;
|
---|
| 2481 | }
|
---|
| 2482 |
|
---|
[90061] | 2483 | uint32_t const cBlocks = (uint32_t)(cbStore / cbBlock);
|
---|
| 2484 |
|
---|
[90067] | 2485 | EFI_GUID GuidVarStore = EFI_VARSTORE_FILESYSTEM_GUID;
|
---|
| 2486 | EFI_GUID GuidVarAuth = EFI_VARSTORE_HEADER_GUID_AUTHENTICATED_VARIABLE;
|
---|
[90061] | 2487 | EFI_FIRMWARE_VOLUME_HEADER FvHdr; RT_ZERO(FvHdr);
|
---|
[91497] | 2488 | EFI_FW_BLOCK_MAP aBlockMap[2]; RT_ZERO(aBlockMap);
|
---|
[90061] | 2489 | EFI_VARSTORE_HEADER VarStoreHdr; RT_ZERO(VarStoreHdr);
|
---|
| 2490 |
|
---|
| 2491 | /* Firmware volume header. */
|
---|
[90067] | 2492 | memcpy(&FvHdr.GuidFilesystem, &GuidVarStore, sizeof(GuidVarStore));
|
---|
[90061] | 2493 | FvHdr.cbFv = RT_H2LE_U64(cbStore);
|
---|
| 2494 | FvHdr.u32Signature = RT_H2LE_U32(EFI_FIRMWARE_VOLUME_HEADER_SIGNATURE);
|
---|
| 2495 | FvHdr.fAttr = RT_H2LE_U32(0x4feff); /** @todo */
|
---|
[91497] | 2496 | FvHdr.cbFvHdr = RT_H2LE_U16(sizeof(FvHdr) + sizeof(aBlockMap));
|
---|
[90061] | 2497 | FvHdr.bRevision = EFI_FIRMWARE_VOLUME_HEADER_REVISION;
|
---|
| 2498 |
|
---|
| 2499 | /* Start calculating the checksum of the main header. */
|
---|
| 2500 | uint16_t u16Chksum = 0;
|
---|
| 2501 | const uint16_t *pu16 = (const uint16_t *)&FvHdr;
|
---|
| 2502 | while (pu16 < (const uint16_t *)&FvHdr + (sizeof(FvHdr) / sizeof(uint16_t)))
|
---|
| 2503 | u16Chksum += RT_LE2H_U16(*pu16++);
|
---|
| 2504 |
|
---|
[91497] | 2505 | /* Block map, the second entry remains 0 as it serves the delimiter. */
|
---|
| 2506 | aBlockMap[0].cbBlock = RT_H2LE_U32(cbBlock);
|
---|
| 2507 | aBlockMap[0].cBlocks = RT_H2LE_U32(cBlocks);
|
---|
[90061] | 2508 |
|
---|
[91497] | 2509 | pu16 = (const uint16_t *)&aBlockMap[0];
|
---|
[91500] | 2510 | while (pu16 < (const uint16_t *)&aBlockMap[0] + (sizeof(aBlockMap) / (sizeof(uint16_t))))
|
---|
[90061] | 2511 | u16Chksum += RT_LE2H_U16(*pu16++);
|
---|
| 2512 |
|
---|
[91497] | 2513 | FvHdr.u16Chksum = RT_H2LE_U16(UINT16_MAX - u16Chksum + 1);
|
---|
[90061] | 2514 |
|
---|
| 2515 | /* Variable store header. */
|
---|
[90067] | 2516 | memcpy(&VarStoreHdr.GuidVarStore, &GuidVarAuth, sizeof(GuidVarAuth));
|
---|
[91497] | 2517 | VarStoreHdr.cbVarStore = RT_H2LE_U32(cbVarStore - sizeof(FvHdr) - sizeof(aBlockMap));
|
---|
[90061] | 2518 | VarStoreHdr.bFmt = EFI_VARSTORE_HEADER_FMT_FORMATTED;
|
---|
| 2519 | VarStoreHdr.bState = EFI_VARSTORE_HEADER_STATE_HEALTHY;
|
---|
| 2520 |
|
---|
| 2521 | /* Write everything. */
|
---|
| 2522 | int rc = RTVfsFileWriteAt(hVfsFile, offStore, &FvHdr, sizeof(FvHdr), NULL);
|
---|
| 2523 | if (RT_SUCCESS(rc))
|
---|
[91497] | 2524 | rc = RTVfsFileWriteAt(hVfsFile, offStore + sizeof(FvHdr), &aBlockMap[0], sizeof(aBlockMap), NULL);
|
---|
[90061] | 2525 | if (RT_SUCCESS(rc))
|
---|
[91497] | 2526 | rc = RTVfsFileWriteAt(hVfsFile, offStore + sizeof(FvHdr) + sizeof(aBlockMap), &VarStoreHdr, sizeof(VarStoreHdr), NULL);
|
---|
[90061] | 2527 | if (RT_SUCCESS(rc))
|
---|
| 2528 | {
|
---|
| 2529 | /* Fill the remainder with 0xff as it would be the case for a real NAND flash device. */
|
---|
[91497] | 2530 | uint64_t offStart = offStore + sizeof(FvHdr) + sizeof(aBlockMap) + sizeof(VarStoreHdr);
|
---|
| 2531 | uint64_t offEnd = offStore + cbVarStore;
|
---|
[90061] | 2532 |
|
---|
[91497] | 2533 | rc = rtEfiVarStoreFillWithFF(hVfsFile, offStart, offEnd);
|
---|
| 2534 | }
|
---|
| 2535 |
|
---|
| 2536 | if ( RT_SUCCESS(rc)
|
---|
| 2537 | && !(fFlags & RTEFIVARSTORE_CREATE_F_NO_FTW_WORKING_SPACE))
|
---|
| 2538 | {
|
---|
| 2539 | EFI_GUID GuidFtwArea = EFI_WORKING_BLOCK_SIGNATURE_GUID;
|
---|
| 2540 | EFI_FTW_BLOCK_HEADER FtwHdr; RT_ZERO(FtwHdr);
|
---|
| 2541 |
|
---|
| 2542 | memcpy(&FtwHdr.GuidSignature, &GuidFtwArea, sizeof(GuidFtwArea));
|
---|
| 2543 | FtwHdr.fWorkingBlockValid = RT_H2LE_U32(0xfffffffe); /** @todo */
|
---|
[93283] | 2544 | FtwHdr.cbWriteQueue = RT_H2LE_U64(0xfe0ULL); /* This comes from the default OVMF variable volume. */
|
---|
[91497] | 2545 | FtwHdr.u32Chksum = RTCrc32(&FtwHdr, sizeof(FtwHdr));
|
---|
| 2546 |
|
---|
| 2547 | /* The area starts with the event log which defaults to 0xff. */
|
---|
| 2548 | rc = rtEfiVarStoreFillWithFF(hVfsFile, offNvEventLog, offNvEventLog + cbNvEventLog);
|
---|
| 2549 | if (RT_SUCCESS(rc))
|
---|
[90061] | 2550 | {
|
---|
[91497] | 2551 | /* Write the FTW header. */
|
---|
| 2552 | rc = RTVfsFileWriteAt(hVfsFile, offFtw, &FtwHdr, sizeof(FtwHdr), NULL);
|
---|
| 2553 | if (RT_SUCCESS(rc))
|
---|
| 2554 | rc = rtEfiVarStoreFillWithFF(hVfsFile, offFtw + sizeof(FtwHdr), offFtw + cbFtw);
|
---|
[90061] | 2555 | }
|
---|
| 2556 | }
|
---|
| 2557 |
|
---|
| 2558 | return rc;
|
---|
| 2559 | }
|
---|
| 2560 |
|
---|
| 2561 |
|
---|
| 2562 | /**
|
---|
| 2563 | * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate}
|
---|
| 2564 | */
|
---|
| 2565 | static DECLCALLBACK(int) rtVfsChainEfiVarStore_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec,
|
---|
| 2566 | PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo)
|
---|
| 2567 | {
|
---|
| 2568 | RT_NOREF(pProviderReg);
|
---|
| 2569 |
|
---|
| 2570 | /*
|
---|
| 2571 | * Basic checks.
|
---|
| 2572 | */
|
---|
| 2573 | if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE)
|
---|
| 2574 | return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE;
|
---|
| 2575 | if ( pElement->enmType != RTVFSOBJTYPE_VFS
|
---|
| 2576 | && pElement->enmType != RTVFSOBJTYPE_DIR)
|
---|
| 2577 | return VERR_VFS_CHAIN_ONLY_DIR_OR_VFS;
|
---|
| 2578 | if (pElement->cArgs > 1)
|
---|
| 2579 | return VERR_VFS_CHAIN_AT_MOST_ONE_ARG;
|
---|
| 2580 |
|
---|
| 2581 | /*
|
---|
| 2582 | * Parse the flag if present, save in pElement->uProvider.
|
---|
| 2583 | */
|
---|
| 2584 | bool fReadOnly = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ;
|
---|
| 2585 | if (pElement->cArgs > 0)
|
---|
| 2586 | {
|
---|
| 2587 | const char *psz = pElement->paArgs[0].psz;
|
---|
| 2588 | if (*psz)
|
---|
| 2589 | {
|
---|
| 2590 | if (!strcmp(psz, "ro"))
|
---|
| 2591 | fReadOnly = true;
|
---|
| 2592 | else if (!strcmp(psz, "rw"))
|
---|
| 2593 | fReadOnly = false;
|
---|
| 2594 | else
|
---|
| 2595 | {
|
---|
| 2596 | *poffError = pElement->paArgs[0].offSpec;
|
---|
| 2597 | return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument");
|
---|
| 2598 | }
|
---|
| 2599 | }
|
---|
| 2600 | }
|
---|
| 2601 |
|
---|
| 2602 | pElement->uProvider = fReadOnly ? RTVFSMNT_F_READ_ONLY : 0;
|
---|
| 2603 | return VINF_SUCCESS;
|
---|
| 2604 | }
|
---|
| 2605 |
|
---|
| 2606 |
|
---|
| 2607 | /**
|
---|
| 2608 | * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate}
|
---|
| 2609 | */
|
---|
| 2610 | static DECLCALLBACK(int) rtVfsChainEfiVarStore_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec,
|
---|
| 2611 | PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj,
|
---|
| 2612 | PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo)
|
---|
| 2613 | {
|
---|
| 2614 | RT_NOREF(pProviderReg, pSpec, poffError);
|
---|
| 2615 |
|
---|
| 2616 | int rc;
|
---|
| 2617 | RTVFSFILE hVfsFileIn = RTVfsObjToFile(hPrevVfsObj);
|
---|
| 2618 | if (hVfsFileIn != NIL_RTVFSFILE)
|
---|
| 2619 | {
|
---|
| 2620 | RTVFS hVfs;
|
---|
| 2621 | rc = RTEfiVarStoreOpenAsVfs(hVfsFileIn, (uint32_t)pElement->uProvider, (uint32_t)(pElement->uProvider >> 32), &hVfs, pErrInfo);
|
---|
| 2622 | RTVfsFileRelease(hVfsFileIn);
|
---|
| 2623 | if (RT_SUCCESS(rc))
|
---|
| 2624 | {
|
---|
| 2625 | *phVfsObj = RTVfsObjFromVfs(hVfs);
|
---|
| 2626 | RTVfsRelease(hVfs);
|
---|
| 2627 | if (*phVfsObj != NIL_RTVFSOBJ)
|
---|
| 2628 | return VINF_SUCCESS;
|
---|
| 2629 | rc = VERR_VFS_CHAIN_CAST_FAILED;
|
---|
| 2630 | }
|
---|
| 2631 | }
|
---|
| 2632 | else
|
---|
| 2633 | rc = VERR_VFS_CHAIN_CAST_FAILED;
|
---|
| 2634 | return rc;
|
---|
| 2635 | }
|
---|
| 2636 |
|
---|
| 2637 |
|
---|
| 2638 | /**
|
---|
| 2639 | * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
|
---|
| 2640 | */
|
---|
| 2641 | static DECLCALLBACK(bool) rtVfsChainEfiVarStore_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
|
---|
| 2642 | PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
|
---|
| 2643 | PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
|
---|
| 2644 | {
|
---|
| 2645 | RT_NOREF(pProviderReg, pSpec, pReuseSpec);
|
---|
| 2646 | if ( pElement->paArgs[0].uProvider == pReuseElement->paArgs[0].uProvider
|
---|
| 2647 | || !pReuseElement->paArgs[0].uProvider)
|
---|
| 2648 | return true;
|
---|
| 2649 | return false;
|
---|
| 2650 | }
|
---|
| 2651 |
|
---|
| 2652 |
|
---|
| 2653 | /** VFS chain element 'efivarstore'. */
|
---|
| 2654 | static RTVFSCHAINELEMENTREG g_rtVfsChainEfiVarStoreReg =
|
---|
| 2655 | {
|
---|
| 2656 | /* uVersion = */ RTVFSCHAINELEMENTREG_VERSION,
|
---|
| 2657 | /* fReserved = */ 0,
|
---|
| 2658 | /* pszName = */ "efivarstore",
|
---|
| 2659 | /* ListEntry = */ { NULL, NULL },
|
---|
| 2660 | /* pszHelp = */ "Open a EFI variable store, requires a file object on the left side.\n"
|
---|
| 2661 | "First argument is an optional 'ro' (read-only) or 'rw' (read-write) flag.\n",
|
---|
| 2662 | /* pfnValidate = */ rtVfsChainEfiVarStore_Validate,
|
---|
| 2663 | /* pfnInstantiate = */ rtVfsChainEfiVarStore_Instantiate,
|
---|
| 2664 | /* pfnCanReuseElement = */ rtVfsChainEfiVarStore_CanReuseElement,
|
---|
| 2665 | /* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION
|
---|
| 2666 | };
|
---|
| 2667 |
|
---|
| 2668 | RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainEfiVarStoreReg, rtVfsChainEfiVarStoreReg);
|
---|
| 2669 |
|
---|