xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Insyde/InsydeModulePkg/Universal/Variable/VariableRuntimeDxe/Variable.h

742 lines
26 KiB
C
Raw Blame History

/** @file
;******************************************************************************
;* Copyright (c) 2012 - 2021, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
#ifndef _VARIABLE_H_
#define _VARIABLE_H_
#include <PiSmm.h>
#include <H2OStatusCode.h>
#include <Protocol/SmmBase2.h>
#include <Protocol/VariableWrite.h>
#include <Protocol/FirmwareVolumeBlock.h>
#include <Protocol/FirmwareVolume2.h>
#include <Protocol/DevicePath.h>
#include <Protocol/Variable.h>
#include <Protocol/VariableLock.h>
#include <Protocol/VarCheck.h>
#include <Protocol/SmmVarCheck.h>
#include <Protocol/Hash.h>
#include <Protocol/CryptoServices.h>
#include <Protocol/FaultTolerantWriteLite.h>
#include <Protocol/SmmFtw.h>
#include <Protocol/SmmFwBlockService.h>
#include <Protocol/SmmVariable.h>
#include <Protocol/SmmAccess2.h>
#include <Protocol/NonVolatileVariable.h>
#include <Protocol/SmmReadyToBoot.h>
#include <Protocol/TcgService.h>
#include <Protocol/Tcg2Protocol.h>
#include <Protocol/SmmCommunication.h>
#include <Protocol/VariablePolicy.h>
#include <Library/PcdLib.h>
#include <Library/HobLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/DxeServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.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/VariableSupportLib.h>
#include <Library/ImageRelocationLib.h>
#include <Library/DxeOemSvcKernelLib.h>
#include <Library/CacheMaintenanceLib.h>
#include <Library/MultiConfigBaseLib.h>
#include <Library/H2OCpLib.h>
#include <Library/ReportStatusCodeLib.h>
#include <Library/SafeIntLib.h>
#include <Library/VariablePolicyHelperLib.h>
#include <Guid/GlobalVariable.h>
#include <Guid/EventGroup.h>
#include <Guid/AuthenticatedVariableFormat.h>
#include <Guid/ImageAuthentication.h>
#include <Guid/AdmiSecureBoot.h>
#include <Guid/DebugMask.h>
#include <Guid/BootOrderHook.h>
#include <Guid/VarErrorFlag.h>
#include <Guid/H2OCp.h>
#include "Reclaim.h"
#include "Misc.h"
#include "SecureBoot.h"
#include "GlobalVariable.h"
#include <MultiConfigStructDef.h>
//
// SMI related definitions
//
#define SW_SMI_PORT PcdGet16(PcdSoftwareSmiPort)
#define SECURE_BOOT_SW_SMI 0xEC
#define UPDATE_VARIABLE_PROPERTY_FUN_NUM 0xF8
#define SMM_VARIABLE_CHECK_FUN_NUM 0xF9
#define SMM_VARIABLE_LOCK_FUN_NUM 0xFA
#define LEGACY_BOOT_SMI_FUN_NUM 0xFB
#define SMM_SET_VARIABLE_SMI_FUN_NUM 0xFC
#define DISABLE_VARIABLE_CACHE_SMI_FUN_NUM 0xFE
#define DISABLE_SECURE_BOOT_SMI_FUN_NUM 0xFF
//
// Signature related definitions
//
#define SMM_VARIABLE_CHECK_SIGNATURE SIGNATURE_32 ('s', 'V', 'C', 'L')
#define SMM_VARIABLE_LOCK_SIGNATURE SIGNATURE_32 ('s', 'V', 'L', 'L')
#define SMM_LEGACY_BOOT_SIGNATURE SIGNATURE_32 ('s', 'S', 'L', 'B')
#define SMM_VARIABLE_SIGNATURE SIGNATURE_32 ('s', 'm', 'v', 'a')
#define DISABLE_VARIABLE_CACHE_SIGNATURE SIGNATURE_32 ('s', 'D', 'V', 'C')
#define DISABLE_SET_SENSITIVE_SIGNATURE SIGNATURE_32 ('s', 'D', 'S', 'S')
#define ENABLE_SET_SENSITIVE_SIGNATURE SIGNATURE_32 ('s', 'E', 'S', 'S')
#define UPDATE_VARIABLE_PROPERTY_SIGNATURE SIGNATURE_32 ('s', 'U', 'V', 'P')
#define INSTANCE_FROM_EFI_SMM_VARIABLE_THIS(a) CR (a, SMM_VARIABLE_INSTANCE, SmmVariable, SMM_VARIABLE_SIGNATURE)
//
// Size related definitions
//
#define VARIABLE_STORE_SIZE (64 * 1024)
//
// To make sure SCRATCH_SIZE is large enough, set the SCRATCH_SIZE is MAX_VARIABLE_SIZE + 4KB.
//
#define SCRATCH_SIZE ((MAX_VARIABLE_SIZE) + (4 * 1024))
#define MAX_HARDWARE_ERROR_VARIABLE_SIZE MAX_VARIABLE_SIZE
#define VARIABLE_RECLAIM_THRESHOLD (1024)
#define APPEND_BUFF_SIZE MAX_VARIABLE_SIZE
//
// Attributes related definitions
//
#define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x00000008
#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 VARIABLE_ATTRIBUTE_NV_BS (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS)
#define VARIABLE_ATTRIBUTE_BS_RT (EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS)
#define VARIABLE_ATTRIBUTE_NV_BS_RT (VARIABLE_ATTRIBUTE_BS_RT | EFI_VARIABLE_NON_VOLATILE)
#define VARIABLE_ATTRIBUTE_NV_BS_RT_AT (VARIABLE_ATTRIBUTE_NV_BS_RT | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)
#define VARIABLE_ATTRIBUTE_NV_BS_RT_HR (VARIABLE_ATTRIBUTE_NV_BS_RT | EFI_VARIABLE_HARDWARE_ERROR_RECORD)
#define VARIABLE_ATTRIBUTE_NV_BS_RT_AW (VARIABLE_ATTRIBUTE_NV_BS_RT | EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS)
//
// Misc definitions
//
#define MAX_TRY_SET_VARIABLE_TIMES 2
#define NEED_DO_RECLAIM_NAME L"NeedDoReclaim"
#ifndef EFI_OS_INDICATIONS_START_OS_RECOVERY
#define EFI_OS_INDICATIONS_START_OS_RECOVERY 0x0000000000000020
#endif
typedef enum {
VariableStoreTypeHob,
VariableStoreTypeNv,
VariableStoreTypeVolatile,
VariableStoreTypeMax
} VARIABLE_STORE_TYPE;
typedef struct {
VOID *BackupBuffer;
EFI_LBA VariableLba;
UINTN VariableOffset;
EFI_FTW_LITE_PROTOCOL *FtwLiteProtocol;
} VARIABLE_RECLAIM_INFO;
typedef struct {
VARIABLE_HEADER *CurrPtr;
VARIABLE_HEADER *EndPtr;
VARIABLE_HEADER *StartPtr;
BOOLEAN Volatile;
} VARIABLE_POINTER_TRACK;
typedef struct {
EFI_PHYSICAL_ADDRESS VolatileVariableBase;
EFI_PHYSICAL_ADDRESS NonVolatileVariableBase;
EFI_LOCK VariableServicesLock;
UINT32 ReentrantState;
} VARIABLE_GLOBAL;
typedef struct {
NON_VOLATILE_VARIABLE_PROTOCOL NonVolatileVariableProtocol;
VARIABLE_GLOBAL VariableBase;
UINTN VolatileLastVariableOffset;
UINTN NonVolatileLastVariableOffset;
UINTN NonVolatileVariableCacheSize;
UINTN CommonVariableSpace;
UINTN CommonMaxUserVariableSpace;
UINTN CommonUserVariableTotalSize;
EFI_PHYSICAL_ADDRESS FactoryDefaultBase;
UINTN FactoryDefaultSize;
EFI_PHYSICAL_ADDRESS VariableDefaultBase;
UINTN VariableDefaultSize;
EFI_PHYSICAL_ADDRESS HobVariableBase;
UINTN HobVariableSize;
UINT8 *NonVolatileVariableCache;
UINT32 NonVolatileVariableCacheCrc32;
UINT8 *FactoryDefaultCache;
UINT8 *VariableDefaultCache;
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *FvbInstance;
LIST_ENTRY *VarCheckVariableList;
BOOLEAN SmmCodeReady;
BOOLEAN SecureBootCallbackEnabled;
BOOLEAN BootOrderVariableHook;
BOOLEAN AtRuntime;
BOOLEAN EndOfDxe;
BOOLEAN InsydeSecureVariableLocked;
BOOLEAN VariableWriteReady;
BOOLEAN TcgAvailable;
PRESERVED_VARIABLE_TABLE *PreservedVariableTable;
UINT32 PreservedTableSize;
VOID *GlobalVariableList;
EFI_SET_VARIABLE SmmSetVariable;
VARIABLE_RECLAIM_INFO *ReclaimInfo;
SMM_VAR_BUFFER *SmmVarBuf;
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicationBuffer;
} ESAL_VARIABLE_GLOBAL;
typedef struct {
EFI_PHYSICAL_ADDRESS FvbBaseAddress;
EFI_LBA Lba;
UINTN Offset;
} VARIABLE_STORE_INFO;
typedef struct {
UINT32 Signature;
EFI_SMM_FW_BLOCK_SERVICE_PROTOCOL *SmmFwbService;
UINTN CurrentlyExecutingCpu;
VARIABLE_STORE_INFO VariableStoreInfo;
ESAL_VARIABLE_GLOBAL *ProtectedModeVariableModuleGlobal;
} SMM_VARIABLE_INSTANCE;
#define EFI_FREE_POOL(Addr) \
{ mSmst ? mSmst->SmmFreePool((VOID*) (Addr)) : gBS->FreePool ((VOID *) (Addr)); \
Addr = NULL;}
/**
Initializes variable store area for non-volatile and volatile variable.
@retval EFI_SUCCESS Function successfully executed.
@retval EFI_OUT_OF_RESOURCES Fail to allocate enough memory resource.
**/
EFI_STATUS
VariableCommonInitialize (
VOID
);
/**
Initializes read-only variable services.
@retval EFI_SUCCESS Function successfully executed.
@retval EFI_OUT_OF_RESOURCES Fail to allocate enough memory resource.
@return Others Ohter error occurred in this function.
**/
EFI_STATUS
VariableReadyOnlyInitialize (
VOID
);
/**
Initialize SMM mode NV data
@param SmmBase Pointer to EFI_SMM_BASE_PROTOCOL
@retval EFI_SUCCESS Initialize SMM mode NV data successful.
@retval Other Any error occurred during initialize SMM NV data.
**/
EFI_STATUS
EFIAPI
SmmNvsInitialize (
IN EFI_SMM_BASE2_PROTOCOL *SmmBase
);
/**
Communication service SMI Handler entry.
This SMI handler provides services for administer secure boot through SMI.
@param[in] DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister().
@param[in] Context Points to an optional handler context which was specified when the
handler was registered.
@param[in,out] CommBuffer A pointer to a collection of data in memory that will
be conveyed from a non-SMM environment into an SMM environment.
@param[in,out] CommBufferSize The size of the CommBuffer.
@retval EFI_SUCCESS The interrupt was handled and quiesced. No other handlers
should still be called.
@retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quiesced but other handlers should
still be called.
@retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pending and other handlers should still
be called.
@retval EFI_INTERRUPT_PENDING The interrupt could not be quiesced.
**/
EFI_STATUS
EFIAPI
SecureBootHandler (
IN EFI_HANDLE DispatchHandle,
IN CONST VOID *Context OPTIONAL,
IN OUT VOID *CommBuffer OPTIONAL,
IN OUT UINTN *CommBufferSize OPTIONAL
);
/**
Setup Variable driver for SMM
@param Event Event whose notification function is being invoked.
@param Context Pointer to the notification function's context.
None
**/
VOID
EFIAPI
SetupSmmVariable (
IN EFI_EVENT Event,
IN VOID *Context
);
EFI_STATUS
EFIAPI
VariableServicesGetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID * VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Data OPTIONAL
);
EFI_STATUS
EFIAPI
VariableServicesGetNextVariableName (
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid
);
EFI_STATUS
EFIAPI
VariableServicesSetVariable (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Data
);
EFI_STATUS
EFIAPI
VariableServicesQueryVariableInfo (
IN UINT32 Attributes,
OUT UINT64 *MaximumVariableStorageSize,
OUT UINT64 *RemainingVariableStorageSize,
OUT UINT64 *MaximumVariableSize
);
/**
This code finds variable in storage blocks (Volatile or Non-Volatile)
@param VariableName Name of the variable to be found
@param VendorGuid Vendor GUID to be found.
@param PtrTrack Variable Track Pointer structure that contains Variable Information.
@param VariableCount The number of found variable.
@param Global VARIABLE_GLOBAL pointer.
@retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while
VendorGuid is NULL.
@retval EFI_SUCCESS Variable successfully found.
@retval EFI_NOT_FOUND Variable not found
**/
EFI_STATUS
FindVariable (
IN CONST CHAR16 *VariableName,
IN CONST EFI_GUID *VendorGuid,
OUT VARIABLE_POINTER_TRACK *PtrTrack,
OUT UINTN *VariableCount,
IN VARIABLE_GLOBAL *Global
);
/**
This code finds variable in all of storage blocks (Volatile, Non-Volatile variable store and
variable default store)
@param VariableName Name of the variable to be found
@param VendorGuid Vendor GUID to be found.
@param PtrTrack Variable Track Pointer structure that contains Variable Information.
@param VariableCount The number of found variable.
@param Global VARIABLE_GLOBAL pointer.
@retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while
VendorGuid is NULL.
@retval EFI_SUCCESS Variable successfully found.
@retval EFI_NOT_FOUND Variable not found
**/
EFI_STATUS
FindVariableInAllRegions (
IN CONST CHAR16 *VariableName,
IN CONST EFI_GUID *VendorGuid,
OUT VARIABLE_POINTER_TRACK *PtrTrack,
OUT UINTN *VariableCount,
IN VARIABLE_GLOBAL *Global
);
/**
Finds variable in storage blocks of volatile and non-volatile storage areas.
This code finds variable in storage blocks of volatile and non-volatile storage areas.
If VariableName is an empty string, then we just return the first
qualified variable without comparing VariableName and VendorGuid.
Otherwise, VariableName and VendorGuid are compared.
@param VariableName Name of the variable to be found.
@param VendorGuid Vendor GUID to be found.
@param PtrTrack VARIABLE_POINTER_TRACK structure for output,
including the range searched and the target position.
@param PtrTrack Variable count for output.
@param Global Pointer to VARIABLE_GLOBAL structure, including
base of volatile variable storage area, base of
NV variable storage area, and a lock.
@retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while
VendorGuid is NULL.
@retval EFI_SUCCESS Variable successfully found.
@retval EFI_INVALID_PARAMETER Variable not found.
**/
EFI_STATUS
FindVariableByLifetime (
IN CONST CHAR16 *VariableName,
IN CONST EFI_GUID *VendorGuid,
OUT VARIABLE_POINTER_TRACK *PtrTrack,
OUT UINTN *VariableCount,
IN VARIABLE_GLOBAL *Global
);
/**
This code finds variable in all of storage blocks (Volatile, Non-Volatile variable store and
variable default store)
@param VariableName Name of the variable to be found
@param VendorGuid Vendor GUID to be found.
@param PtrTrack Variable Track Pointer structure that contains Variable Information.
@param VariableCount The number of found variable.
@param Global VARIABLE_GLOBAL pointer.
@retval EFI_INVALID_PARAMETER If VariableName is not an empty string, while
VendorGuid is NULL.
@retval EFI_SUCCESS Variable successfully found.
@retval EFI_NOT_FOUND Variable not found
**/
EFI_STATUS
FindVariableByLifetimeInAllRegions (
IN CONST CHAR16 *VariableName,
IN CONST EFI_GUID *VendorGuid,
OUT VARIABLE_POINTER_TRACK *PtrTrack,
OUT UINTN *VariableCount,
IN VARIABLE_GLOBAL *Global
);
/**
Update the variable region with Variable information. If EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS is set,
index of associated public key is needed.
@param[in] VariableName Name of variable.
@param[in] VendorGuid Guid of variable.
@param[in] Data Variable data.
@param[in] DataSize Size of data. 0 means delete.
@param[in] Attributes Attributes of the variable.
@param[in] KeyIndex Index of associated public key.
@param[in] MonotonicCount Value of associated monotonic count.
@param[in] Variable The variable information that is used to keep track of variable usage.
@param[in] TimeStamp Value of associated TimeStamp.
@param[in] Global Pointer to VARIABLE_GLOBAL
@retval EFI_SUCCESS The update operation is success.
@retval EFI_OUT_OF_RESOURCES Variable region is full, cannot write other data into this region.
**/
EFI_STATUS
UpdateVariable (
IN CONST CHAR16 *VariableName,
IN CONST EFI_GUID *VendorGuid,
IN CONST VOID *Data,
IN UINTN DataSize,
IN UINT32 Attributes,
IN UINT32 KeyIndex OPTIONAL,
IN UINT64 MonotonicCount OPTIONAL,
IN VARIABLE_POINTER_TRACK *Variable,
IN EFI_TIME *TimeStamp OPTIONAL,
IN VARIABLE_GLOBAL *Global
);
/**
Send the data in communicate buffer to SMM.
@retval EFI_SUCCESS Success is returned from the functin in SMM.
@return Others Failure is returned from the function in SMM.
**/
EFI_STATUS
SendCommunicateBuffer (
VOID
);
/**
Initial communication buffer header.
**/
VOID
InitCommunicationBufferHeader (
VOID
);
/**
This function uses to do specific action when legacy boot event is signaled.
@retval EFI_SUCCESS All of action for legacy boot event in SMM mode is successful.
@retval Other Any error occurred.
--*/
EFI_STATUS
SmmLegacyBootEvent (
VOID
);
/**
This function uses to invoke SMM mode SetVariable ()
@retval EFI_SUCCESS Calling SMM mode SetVariable () successful.
@return Other Any error occurred while setting variable.
**/
EFI_STATUS
SmmInternalSetVariable (
VOID
);
/**
Get the proper fvb handle and/or fvb protocol by the given Flash address.
@param[in] Address The Flash address.
@param[out] FvbHandle In output, if it is not NULL, it points to the proper FVB handle.
@param[out] FvbProtocol In output, if it is not NULL, it points to the proper FVB protocol.
@retval EFI_SUCCESS Get fvb handle and/or fvb protocol successfully.
@retval EFI_NOT_FOUND Cannot find fvb handle and/or fvb protocol.
**/
EFI_STATUS
GetFvbInfoByAddress (
IN EFI_PHYSICAL_ADDRESS Address,
OUT EFI_HANDLE *FvbHandle OPTIONAL,
OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL **FvbProtocol OPTIONAL
);
/**
This code gets the size of non-volatile variable store.
@return UINTN The size of non-volatile variable store.
**/
UINTN
GetNonVolatileVariableStoreSize (
VOID
);
/**
Function to get current nonvolatile offset from physical hardware device.
@return The offset of the first free nonvolatile variable space.
**/
UINTN
GetCurrentNonVolatileOffset (
VOID
);
/**
This code gets the pointer to the last variable memory pointer byte
@param[in] VarStoreHeader Pointer to the Variable Store Header.
@return Pointer to last unavailable Variable Header.
**/
VARIABLE_HEADER *
EFIAPI
GetNonVolatileEndPointer (
IN VARIABLE_STORE_HEADER *VarStoreHeader
);
/**
This function writes data to the FWH at the correct LBA even if the LBAs
are fragmented.
@param[in] Global Pointer to VARIABLE_GLOBAL structure.
@param[in] Volatile If the Variable is Volatile or Non-Volatile
@param[in] SetByIndex TRUE: Target pointer is given as index.
FALSE: Target pointer is absolute.
@param[in] DataPtrIndex Pointer to the Data from the end of VARIABLE_STORE_HEADER
structure.
@param[in] DataSize Size of data to be written.
@param[in] Buffer Pointer to the buffer from which data is written.
@retval EFI_SUCCESS Variable store successfully updated.
@retval EFI_INVALID_PARAMETER Parameters not valid.
--*/
EFI_STATUS
UpdateVariableStore (
IN VARIABLE_GLOBAL *Global,
IN BOOLEAN Volatile,
IN BOOLEAN SetByIndex,
IN UINTN DataPtrIndex,
IN UINT32 DataSize,
IN UINT8 *Buffer
);
/**
This code checks if variable header is valid or not and is whether whole data in variable region.
@param[in] Variable Pointer to the Variable Header.
@param[in] VariableStoreEnd Pointer to the Variable store end.
@retval TRUE Variable header is valid and in variable region.
@retval FALSE Variable header is not valid or isn't in variable region.
**/
BOOLEAN
IsValidVariableHeaderInVarRegion (
IN CONST VARIABLE_HEADER *Variable,
IN CONST VARIABLE_HEADER *VariableStoreEnd
);
/**
Function to check is whether PK variable exist.
@retval TRUE PK variable exist.
@retval FALSE PK variable doesn't exist.
**/
BOOLEAN
DoesPkExist (
VOID
);
/**
Returns if this is MOR related variable.
@param[in] VariableName the name of the vendor's variable, it's a Null-Terminated Unicode String
@param[in] VendorGuid Unify identifier for vendor.
@retval TRUE The variable is MOR related.
@retval FALSE The variable is NOT MOR related.
**/
BOOLEAN
IsAnyMorVariable (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid
);
/**
Initialization for MOR Lock Control.
@retval EFI_SUCCESS MorLock initialization success.
@return Others Some error occurs.
**/
EFI_STATUS
MorLockInit (
VOID
);
/**
Initialization for MOR Lock Control at ready to boot event in SMM.
**/
VOID
MorLockInitAtSmmReadyToBoot (
VOID
);
/**
This service is an MOR/MorLock checker handler for the SetVariable().
@param[in] VariableName the name of the vendor's variable, as a
Null-Terminated Unicode String
@param[in] VendorGuid Unify identifier for vendor.
@param[in] Attributes Point to memory location to return the attributes of variable. If the point
is NULL, the parameter would be ignored.
@param[in] DataSize The size in bytes of Data-Buffer.
@param[in] Data Point to the content of the variable.
@retval EFI_SUCCESS The MOR/MorLock check pass, and Variable driver can store the variable data.
@retval EFI_INVALID_PARAMETER The MOR/MorLock data or data size or attributes is not allowed for MOR variable.
@retval EFI_ACCESS_DENIED The MOR/MorLock is locked.
@retval EFI_ALREADY_STARTED The MorLock variable is handled inside this function.
Variable driver can just return EFI_SUCCESS.
**/
EFI_STATUS
SetVariableCheckHandlerMor (
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
IN UINT32 Attributes,
IN UINTN DataSize,
IN VOID *Data
);
/**
Check the variable which pointed by CurrPtr is whether a most value variable.
@param[in, out] CurrPtr Pointer to the header of current variable
@param[in, out] StartPtr Pointer to the start address of variable header.
@param[in, out] EndPtr Pointer to the end address of variable header.
@retval TRUE The input variable is most value variable.
@retval FALSE The input variable isn't most value variable.
**/
BOOLEAN
IsMostValueVariable (
IN VARIABLE_HEADER *CurrPtr,
IN VARIABLE_HEADER *StartPtr,
IN VARIABLE_HEADER *EndPtr
);
/**
Allocate SMM confidential pool for MOR lock key.
**/
VOID
InitMorLockKey (
VOID
);
extern ESAL_VARIABLE_GLOBAL *mVariableModuleGlobal;
extern SMM_VARIABLE_INSTANCE *mSmmVariableGlobal;
extern EFI_SMM_SYSTEM_TABLE2 *mSmst;
extern VOID *mStorageArea;
extern VOID *mCertDbList;
extern VARIABLE_RECLAIM_INFO *mVariableReclaimInfo;
extern BOOLEAN mEnableLocking;
extern LIST_ENTRY mVarCheckVariableList;
extern EFI_SMM_COMMUNICATE_HEADER *mSmmPhyCommunicationBuffer;
extern EFI_SMM_COMMUNICATION_PROTOCOL *mSmmCommunication;
#endif
Reference in New Issue View Git Blame Copy Permalink