Variable.h

Go to the documentation of this file.

 
#ifndef _VARIABLE_H_
#define _VARIABLE_H_
 
#include <PiDxe.h>
#include <Protocol/VariableWrite.h>
#include <Protocol/FaultTolerantWrite.h>
#include <Protocol/FirmwareVolumeBlock.h>
#include <Protocol/Variable.h>
#include <Protocol/VariableLock.h>
#include <Protocol/VarCheck.h>
#include <Library/PcdLib.h>
#include <Library/HobLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/DxeServicesTableLib.h>
#include <Library/UefiRuntimeLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Library/BaseLib.h>
#include <Library/SynchronizationLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/AuthVariableLib.h>
#include <Library/VarCheckLib.h>
#include <Guid/GlobalVariable.h>
#include <Guid/EventGroup.h>
#include <Guid/VariableFormat.h>
#include <Guid/SystemNvDataGuid.h>
#include <Guid/FaultTolerantWrite.h>
#include <Guid/VarErrorFlag.h>
 
#include "PrivilegePolymorphic.h"
 
#define NV_STORAGE_VARIABLE_BASE  (EFI_PHYSICAL_ADDRESS)\
                                   (PcdGet64 (PcdFlashNvStorageVariableBase64) != 0 ? \
                                    PcdGet64 (PcdFlashNvStorageVariableBase64) : \
                                    PcdGet32 (PcdFlashNvStorageVariableBase))
 
#define EFI_VARIABLE_ATTRIBUTES_MASK  (EFI_VARIABLE_NON_VOLATILE |\
                                      EFI_VARIABLE_BOOTSERVICE_ACCESS | \
                                      EFI_VARIABLE_RUNTIME_ACCESS | \
                                      EFI_VARIABLE_HARDWARE_ERROR_RECORD | \
                                      EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | \
                                      EFI_VARIABLE_APPEND_WRITE)
 
#define ISO_639_2_ENTRY_SIZE  3
 
typedef enum {
  VariableStoreTypeVolatile,
  VariableStoreTypeHob,
  VariableStoreTypeNv,
  VariableStoreTypeMax
} VARIABLE_STORE_TYPE;
 
typedef struct {
  UINT32                   PendingUpdateOffset;
  UINT32                   PendingUpdateLength;
  VARIABLE_STORE_HEADER    *Store;
} VARIABLE_RUNTIME_CACHE;
 
typedef struct {
  BOOLEAN                   *ReadLock;
  BOOLEAN                   *PendingUpdate;
  BOOLEAN                   *HobFlushComplete;
  VARIABLE_RUNTIME_CACHE    VariableRuntimeHobCache;
  VARIABLE_RUNTIME_CACHE    VariableRuntimeNvCache;
  VARIABLE_RUNTIME_CACHE    VariableRuntimeVolatileCache;
} VARIABLE_RUNTIME_CACHE_CONTEXT;
 
typedef struct {
  VARIABLE_HEADER    *CurrPtr;
  //
  // If both ADDED and IN_DELETED_TRANSITION variable are present,
  // InDeletedTransitionPtr will point to the IN_DELETED_TRANSITION one.
  // Otherwise, CurrPtr will point to the ADDED or IN_DELETED_TRANSITION one,
  // and InDeletedTransitionPtr will be NULL at the same time.
  //
  VARIABLE_HEADER    *InDeletedTransitionPtr;
  VARIABLE_HEADER    *EndPtr;
  VARIABLE_HEADER    *StartPtr;
  BOOLEAN            Volatile;
} VARIABLE_POINTER_TRACK;
 
typedef struct {
  EFI_PHYSICAL_ADDRESS              HobVariableBase;
  EFI_PHYSICAL_ADDRESS              VolatileVariableBase;
  EFI_PHYSICAL_ADDRESS              NonVolatileVariableBase;
  VARIABLE_RUNTIME_CACHE_CONTEXT    VariableRuntimeCacheContext;
  EFI_LOCK                          VariableServicesLock;
  UINT32                            ReentrantState;
  BOOLEAN                           AuthFormat;
  BOOLEAN                           AuthSupport;
  BOOLEAN                           EmuNvMode;
} VARIABLE_GLOBAL;
 
typedef struct {
  VARIABLE_GLOBAL                       VariableGlobal;
  UINTN                                 VolatileLastVariableOffset;
  UINTN                                 NonVolatileLastVariableOffset;
  UINTN                                 CommonVariableSpace;
  UINTN                                 CommonMaxUserVariableSpace;
  UINTN                                 CommonRuntimeVariableSpace;
  UINTN                                 CommonVariableTotalSize;
  UINTN                                 CommonUserVariableTotalSize;
  UINTN                                 HwErrVariableTotalSize;
  UINTN                                 MaxVariableSize;
  UINTN                                 MaxAuthVariableSize;
  UINTN                                 MaxVolatileVariableSize;
  UINTN                                 ScratchBufferSize;
  CHAR8                                 *PlatformLangCodes;
  CHAR8                                 *LangCodes;
  CHAR8                                 *PlatformLang;
  CHAR8                                 Lang[ISO_639_2_ENTRY_SIZE + 1];
  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL    *FvbInstance;
} VARIABLE_MODULE_GLOBAL;
 
VOID
FlushHobVariableToFlash (
  IN CHAR16    *VariableName,
  IN EFI_GUID  *VendorGuid
  );
 
EFI_STATUS
FtwVariableSpace (
  IN EFI_PHYSICAL_ADDRESS   VariableBase,
  IN VARIABLE_STORE_HEADER  *VariableBuffer
  );
 
EFI_STATUS
FindVariable (
  IN  CHAR16                  *VariableName,
  IN  EFI_GUID                *VendorGuid,
  OUT VARIABLE_POINTER_TRACK  *PtrTrack,
  IN  VARIABLE_GLOBAL         *Global,
  IN  BOOLEAN                 IgnoreRtCheck
  );
 
BOOLEAN
EFIAPI
CheckRemainingSpaceForConsistencyInternal (
  IN UINT32   Attributes,
  IN VA_LIST  Marker
  );
 
EFI_STATUS
UpdateVariable (
  IN      CHAR16                  *VariableName,
  IN      EFI_GUID                *VendorGuid,
  IN      VOID                    *Data,
  IN      UINTN                   DataSize,
  IN      UINT32                  Attributes OPTIONAL,
  IN      UINT32                  KeyIndex  OPTIONAL,
  IN      UINT64                  MonotonicCount  OPTIONAL,
  IN OUT  VARIABLE_POINTER_TRACK  *Variable,
  IN      EFI_TIME                *TimeStamp  OPTIONAL
  );
 
BOOLEAN
AtRuntime (
  VOID
  );
 
EFI_LOCK *
InitializeLock (
  IN OUT EFI_LOCK  *Lock,
  IN EFI_TPL       Priority
  );
 
VOID
AcquireLockOnlyAtBootTime (
  IN EFI_LOCK  *Lock
  );
 
VOID
ReleaseLockOnlyAtBootTime (
  IN EFI_LOCK  *Lock
  );
 
EFI_STATUS
GetFvbByHandle (
  IN  EFI_HANDLE                          FvBlockHandle,
  OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvBlock
  );
 
EFI_STATUS
GetFvbCountAndBuffer (
  OUT UINTN       *NumberHandles,
  OUT EFI_HANDLE  **Buffer
  );
 
EFI_STATUS
VariableCommonInitialize (
  VOID
  );
 
VOID
ReclaimForOS (
  VOID
  );
 
UINTN
GetMaxVariableSize (
  VOID
  );
 
EFI_STATUS
VariableWriteServiceInitialize (
  VOID
  );
 
EFI_STATUS
GetFtwProtocol (
  OUT VOID  **FtwProtocol
  );
 
EFI_STATUS
GetFvbInfoByAddress (
  IN  EFI_PHYSICAL_ADDRESS                Address,
  OUT EFI_HANDLE                          *FvbHandle OPTIONAL,
  OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvbProtocol OPTIONAL
  );
 
EFI_STATUS
EFIAPI
VariableServiceGetVariable (
  IN      CHAR16    *VariableName,
  IN      EFI_GUID  *VendorGuid,
  OUT     UINT32    *Attributes OPTIONAL,
  IN OUT  UINTN     *DataSize,
  OUT     VOID      *Data OPTIONAL
  );
 
EFI_STATUS
EFIAPI
VariableServiceGetNextVariableName (
  IN OUT  UINTN     *VariableNameSize,
  IN OUT  CHAR16    *VariableName,
  IN OUT  EFI_GUID  *VendorGuid
  );
 
EFI_STATUS
EFIAPI
VariableServiceSetVariable (
  IN CHAR16    *VariableName,
  IN EFI_GUID  *VendorGuid,
  IN UINT32    Attributes,
  IN UINTN     DataSize,
  IN VOID      *Data
  );
 
EFI_STATUS
EFIAPI
VariableServiceQueryVariableInfoInternal (
  IN  UINT32  Attributes,
  OUT UINT64  *MaximumVariableStorageSize,
  OUT UINT64  *RemainingVariableStorageSize,
  OUT UINT64  *MaximumVariableSize
  );
 
EFI_STATUS
EFIAPI
VariableServiceQueryVariableInfo (
  IN  UINT32  Attributes,
  OUT UINT64  *MaximumVariableStorageSize,
  OUT UINT64  *RemainingVariableStorageSize,
  OUT UINT64  *MaximumVariableSize
  );
 
EFI_STATUS
EFIAPI
VariableLockRequestToLock (
  IN CONST EDKII_VARIABLE_LOCK_PROTOCOL  *This,
  IN       CHAR16                        *VariableName,
  IN       EFI_GUID                      *VendorGuid
  );
 
EFI_STATUS
EFIAPI
VarCheckRegisterSetVariableCheckHandler (
  IN VAR_CHECK_SET_VARIABLE_CHECK_HANDLER  Handler
  );
 
EFI_STATUS
EFIAPI
VarCheckVariablePropertySet (
  IN CHAR16                       *Name,
  IN EFI_GUID                     *Guid,
  IN VAR_CHECK_VARIABLE_PROPERTY  *VariableProperty
  );
 
EFI_STATUS
EFIAPI
VarCheckVariablePropertyGet (
  IN CHAR16                        *Name,
  IN EFI_GUID                      *Guid,
  OUT VAR_CHECK_VARIABLE_PROPERTY  *VariableProperty
  );
 
VOID
InitializeVariableQuota (
  VOID
  );
 
extern VARIABLE_MODULE_GLOBAL      *mVariableModuleGlobal;
extern EFI_FIRMWARE_VOLUME_HEADER  *mNvFvHeaderCache;
extern VARIABLE_STORE_HEADER       *mNvVariableCache;
extern VARIABLE_INFO_ENTRY         *gVariableInfo;
extern BOOLEAN                     mEndOfDxe;
extern VAR_CHECK_REQUEST_SOURCE    mRequestSource;
 
extern AUTH_VAR_LIB_CONTEXT_OUT  mAuthContextOut;
 
EFI_STATUS
EFIAPI
VariableExLibFindVariable (
  IN  CHAR16              *VariableName,
  IN  EFI_GUID            *VendorGuid,
  OUT AUTH_VARIABLE_INFO  *AuthVariableInfo
  );
 
EFI_STATUS
EFIAPI
VariableExLibFindNextVariable (
  IN  CHAR16              *VariableName,
  IN  EFI_GUID            *VendorGuid,
  OUT AUTH_VARIABLE_INFO  *AuthVariableInfo
  );
 
EFI_STATUS
EFIAPI
VariableExLibUpdateVariable (
  IN AUTH_VARIABLE_INFO  *AuthVariableInfo
  );
 
EFI_STATUS
EFIAPI
VariableExLibGetScratchBuffer (
  IN OUT UINTN  *ScratchBufferSize,
  OUT    VOID   **ScratchBuffer
  );
 
BOOLEAN
EFIAPI
VariableExLibCheckRemainingSpaceForConsistency (
  IN UINT32  Attributes,
  ...
  );
 
BOOLEAN
EFIAPI
VariableExLibAtRuntime (
  VOID
  );
 
#endif