[mirror_edk2.git] / MdeModulePkg / Library / VarCheckPcdLib / VarCheckPcdLibNullClass.c

/** @file\r
  Var Check PCD handler.\r
\r
Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <Library/VarCheckLib.h>\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/DxeServicesLib.h>\r
\r
#include "VarCheckPcdStructure.h"\r
\r
// #define DUMP_VAR_CHECK_PCD\r
\r
GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8  mVarCheckPcdHex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };\r
\r
/**\r
  Dump some hexadecimal data.\r
\r
  @param[in] Indent     How many spaces to indent the output.\r
  @param[in] Offset     The offset of the dump.\r
  @param[in] DataSize   The size in bytes of UserData.\r
  @param[in] UserData   The data to dump.\r
\r
**/\r
VOID\r
VarCheckPcdInternalDumpHex (\r
  IN UINTN  Indent,\r
  IN UINTN  Offset,\r
  IN UINTN  DataSize,\r
  IN VOID   *UserData\r
  )\r
{\r
  UINT8  *Data;\r
\r
  CHAR8  Val[50];\r
\r
  CHAR8  Str[20];\r
\r
  UINT8  TempByte;\r
  UINTN  Size;\r
  UINTN  Index;\r
\r
  Data = UserData;\r
  while (DataSize != 0) {\r
    Size = 16;\r
    if (Size > DataSize) {\r
      Size = DataSize;\r
    }\r
\r
    for (Index = 0; Index < Size; Index += 1) {\r
      TempByte           = Data[Index];\r
      Val[Index * 3 + 0] = mVarCheckPcdHex[TempByte >> 4];\r
      Val[Index * 3 + 1] = mVarCheckPcdHex[TempByte & 0xF];\r
      Val[Index * 3 + 2] = (CHAR8)((Index == 7) ? '-' : ' ');\r
      Str[Index]         = (CHAR8)((TempByte < ' ' || TempByte > 'z') ? '.' : TempByte);\r
    }\r
\r
    Val[Index * 3] = 0;\r
    Str[Index]     = 0;\r
    DEBUG ((DEBUG_INFO, "%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str));\r
\r
    Data     += Size;\r
    Offset   += Size;\r
    DataSize -= Size;\r
  }\r
}\r
\r
/**\r
  Var Check Pcd ValidData.\r
\r
  @param[in] PcdValidData   Pointer to Pcd ValidData\r
  @param[in] Data           Data pointer.\r
  @param[in] DataSize       Size of Data to set.\r
\r
  @retval TRUE  Check pass\r
  @retval FALSE Check fail.\r
\r
**/\r
BOOLEAN\r
VarCheckPcdValidData (\r
  IN VAR_CHECK_PCD_VALID_DATA_HEADER  *PcdValidData,\r
  IN VOID                             *Data,\r
  IN UINTN                            DataSize\r
  )\r
{\r
  UINT64  OneData;\r
  UINT64  Minimum;\r
  UINT64  Maximum;\r
  UINT64  OneValue;\r
  UINT8   *Ptr;\r
\r
  OneData = 0;\r
  CopyMem (&OneData, (UINT8 *)Data + PcdValidData->VarOffset, PcdValidData->StorageWidth);\r
\r
  switch (PcdValidData->Type) {\r
    case VarCheckPcdValidList:\r
      Ptr = (UINT8 *)((VAR_CHECK_PCD_VALID_LIST *)PcdValidData + 1);\r
      while ((UINTN)Ptr < (UINTN)PcdValidData + PcdValidData->Length) {\r
        OneValue = 0;\r
        CopyMem (&OneValue, Ptr, PcdValidData->StorageWidth);\r
        if (OneData == OneValue) {\r
          //\r
          // Match\r
          //\r
          break;\r
        }\r
\r
        Ptr += PcdValidData->StorageWidth;\r
      }\r
\r
      if ((UINTN)Ptr >= ((UINTN)PcdValidData + PcdValidData->Length)) {\r
        //\r
        // No match\r
        //\r
        DEBUG ((DEBUG_INFO, "VarCheckPcdValidData fail: ValidList mismatch (0x%lx)\n", OneData));\r
        DEBUG_CODE (\r
          VarCheckPcdInternalDumpHex (2, 0, PcdValidData->Length, (UINT8 *)PcdValidData);\r
          );\r
        return FALSE;\r
      }\r
\r
      break;\r
\r
    case VarCheckPcdValidRange:\r
      Minimum = 0;\r
      Maximum = 0;\r
      Ptr     = (UINT8 *)((VAR_CHECK_PCD_VALID_RANGE *)PcdValidData + 1);\r
      while ((UINTN)Ptr < (UINTN)PcdValidData + PcdValidData->Length) {\r
        CopyMem (&Minimum, Ptr, PcdValidData->StorageWidth);\r
        Ptr += PcdValidData->StorageWidth;\r
        CopyMem (&Maximum, Ptr, PcdValidData->StorageWidth);\r
        Ptr += PcdValidData->StorageWidth;\r
\r
        if ((OneData >= Minimum) && (OneData <= Maximum)) {\r
          return TRUE;\r
        }\r
      }\r
\r
      DEBUG ((DEBUG_INFO, "VarCheckPcdValidData fail: ValidRange mismatch (0x%lx)\n", OneData));\r
      DEBUG_CODE (\r
        VarCheckPcdInternalDumpHex (2, 0, PcdValidData->Length, (UINT8 *)PcdValidData);\r
        );\r
      return FALSE;\r
      break;\r
\r
    default:\r
      ASSERT (FALSE);\r
      break;\r
  }\r
\r
  return TRUE;\r
}\r
\r
VAR_CHECK_PCD_VARIABLE_HEADER  *mVarCheckPcdBin    = NULL;\r
UINTN                          mVarCheckPcdBinSize = 0;\r
\r
/**\r
  SetVariable check handler PCD.\r
\r
  @param[in] VariableName       Name of Variable to set.\r
  @param[in] VendorGuid         Variable vendor GUID.\r
  @param[in] Attributes         Attribute value of the variable.\r
  @param[in] DataSize           Size of Data to set.\r
  @param[in] Data               Data pointer.\r
\r
  @retval EFI_SUCCESS               The SetVariable check result was success.\r
  @retval EFI_SECURITY_VIOLATION    Check fail.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SetVariableCheckHandlerPcd (\r
  IN CHAR16    *VariableName,\r
  IN EFI_GUID  *VendorGuid,\r
  IN UINT32    Attributes,\r
  IN UINTN     DataSize,\r
  IN VOID      *Data\r
  )\r
{\r
  VAR_CHECK_PCD_VARIABLE_HEADER    *PcdVariable;\r
  VAR_CHECK_PCD_VALID_DATA_HEADER  *PcdValidData;\r
\r
  if (mVarCheckPcdBin == NULL) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) || (Attributes == 0)) {\r
    //\r
    // Do not check delete variable.\r
    //\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // For Pcd Variable header align.\r
  //\r
  PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *)HEADER_ALIGN (mVarCheckPcdBin);\r
  while ((UINTN)PcdVariable < ((UINTN)mVarCheckPcdBin + mVarCheckPcdBinSize)) {\r
    if ((StrCmp ((CHAR16 *)(PcdVariable + 1), VariableName) == 0) &&\r
        (CompareGuid (&PcdVariable->Guid, VendorGuid)))\r
    {\r
      //\r
      // Found the Pcd Variable that could be used to do check.\r
      //\r
      DEBUG ((DEBUG_INFO, "VarCheckPcdVariable - %s:%g with Attributes = 0x%08x Size = 0x%x\n", VariableName, VendorGuid, Attributes, DataSize));\r
      if ((PcdVariable->Attributes != 0) && (PcdVariable->Attributes != Attributes)) {\r
        DEBUG ((DEBUG_INFO, "VarCheckPcdVariable fail for Attributes - 0x%08x\n", PcdVariable->Attributes));\r
        return EFI_SECURITY_VIOLATION;\r
      }\r
\r
      if (DataSize == 0) {\r
        DEBUG ((DEBUG_INFO, "VarCheckPcdVariable - CHECK PASS with DataSize == 0 !\n"));\r
        return EFI_SUCCESS;\r
      }\r
\r
      //\r
      // Do the check.\r
      // For Pcd ValidData header align.\r
      //\r
      PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *)HEADER_ALIGN (((UINTN)PcdVariable + PcdVariable->HeaderLength));\r
      while ((UINTN)PcdValidData < ((UINTN)PcdVariable + PcdVariable->Length)) {\r
        if (((UINTN)PcdValidData->VarOffset + PcdValidData->StorageWidth) <= DataSize) {\r
          if (!VarCheckPcdValidData (PcdValidData, Data, DataSize)) {\r
            return EFI_SECURITY_VIOLATION;\r
          }\r
        }\r
\r
        //\r
        // For Pcd ValidData header align.\r
        //\r
        PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *)HEADER_ALIGN (((UINTN)PcdValidData + PcdValidData->Length));\r
      }\r
\r
      DEBUG ((DEBUG_INFO, "VarCheckPcdVariable - ALL CHECK PASS!\n"));\r
      return EFI_SUCCESS;\r
    }\r
\r
    //\r
    // For Pcd Variable header align.\r
    //\r
    PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *)HEADER_ALIGN (((UINTN)PcdVariable + PcdVariable->Length));\r
  }\r
\r
  // Not found, so pass.\r
  return EFI_SUCCESS;\r
}\r
\r
#ifdef DUMP_VAR_CHECK_PCD\r
\r
/**\r
  Dump Pcd ValidData.\r
\r
  @param[in] PcdValidData    Pointer to Pcd ValidData.\r
\r
**/\r
VOID\r
DumpPcdValidData (\r
  IN VAR_CHECK_PCD_VALID_DATA_HEADER  *PcdValidData\r
  )\r
{\r
  UINT64  Minimum;\r
  UINT64  Maximum;\r
  UINT64  OneValue;\r
  UINT8   *Ptr;\r
\r
  DEBUG ((DEBUG_INFO, "  VAR_CHECK_PCD_VALID_DATA_HEADER\n"));\r
  DEBUG ((DEBUG_INFO, "    Type          - 0x%02x\n", PcdValidData->Type));\r
  DEBUG ((DEBUG_INFO, "    Length        - 0x%02x\n", PcdValidData->Length));\r
  DEBUG ((DEBUG_INFO, "    VarOffset     - 0x%04x\n", PcdValidData->VarOffset));\r
  DEBUG ((DEBUG_INFO, "    StorageWidth  - 0x%02x\n", PcdValidData->StorageWidth));\r
\r
  switch (PcdValidData->Type) {\r
    case VarCheckPcdValidList:\r
      Ptr = (UINT8 *)((VAR_CHECK_PCD_VALID_LIST *)PcdValidData + 1);\r
      while ((UINTN)Ptr < ((UINTN)PcdValidData + PcdValidData->Length)) {\r
        OneValue = 0;\r
        CopyMem (&OneValue, Ptr, PcdValidData->StorageWidth);\r
        switch (PcdValidData->StorageWidth) {\r
          case sizeof (UINT8):\r
            DEBUG ((DEBUG_INFO, "    ValidList   - 0x%02x\n", OneValue));\r
            break;\r
          case sizeof (UINT16):\r
            DEBUG ((DEBUG_INFO, "    ValidList   - 0x%04x\n", OneValue));\r
            break;\r
          case sizeof (UINT32):\r
            DEBUG ((DEBUG_INFO, "    ValidList   - 0x%08x\n", OneValue));\r
            break;\r
          case sizeof (UINT64):\r
            DEBUG ((DEBUG_INFO, "    ValidList   - 0x%016lx\n", OneValue));\r
            break;\r
          default:\r
            ASSERT (FALSE);\r
            break;\r
        }\r
\r
        Ptr += PcdValidData->StorageWidth;\r
      }\r
\r
      break;\r
\r
    case VarCheckPcdValidRange:\r
      Minimum = 0;\r
      Maximum = 0;\r
      Ptr     = (UINT8 *)((VAR_CHECK_PCD_VALID_RANGE *)PcdValidData + 1);\r
      while ((UINTN)Ptr < (UINTN)PcdValidData + PcdValidData->Length) {\r
        CopyMem (&Minimum, Ptr, PcdValidData->StorageWidth);\r
        Ptr += PcdValidData->StorageWidth;\r
        CopyMem (&Maximum, Ptr, PcdValidData->StorageWidth);\r
        Ptr += PcdValidData->StorageWidth;\r
\r
        switch (PcdValidData->StorageWidth) {\r
          case sizeof (UINT8):\r
            DEBUG ((DEBUG_INFO, "    Minimum       - 0x%02x\n", Minimum));\r
            DEBUG ((DEBUG_INFO, "    Maximum       - 0x%02x\n", Maximum));\r
            break;\r
          case sizeof (UINT16):\r
            DEBUG ((DEBUG_INFO, "    Minimum       - 0x%04x\n", Minimum));\r
            DEBUG ((DEBUG_INFO, "    Maximum       - 0x%04x\n", Maximum));\r
            break;\r
          case sizeof (UINT32):\r
            DEBUG ((DEBUG_INFO, "    Minimum       - 0x%08x\n", Minimum));\r
            DEBUG ((DEBUG_INFO, "    Maximum       - 0x%08x\n", Maximum));\r
            break;\r
          case sizeof (UINT64):\r
            DEBUG ((DEBUG_INFO, "    Minimum       - 0x%016lx\n", Minimum));\r
            DEBUG ((DEBUG_INFO, "    Maximum       - 0x%016lx\n", Maximum));\r
            break;\r
          default:\r
            ASSERT (FALSE);\r
            break;\r
        }\r
      }\r
\r
      break;\r
\r
    default:\r
      ASSERT (FALSE);\r
      break;\r
  }\r
}\r
\r
/**\r
  Dump Pcd Variable.\r
\r
  @param[in] PcdVariable    Pointer to Pcd Variable.\r
\r
**/\r
VOID\r
DumpPcdVariable (\r
  IN VAR_CHECK_PCD_VARIABLE_HEADER  *PcdVariable\r
  )\r
{\r
  VAR_CHECK_PCD_VALID_DATA_HEADER  *PcdValidData;\r
\r
  DEBUG ((DEBUG_INFO, "VAR_CHECK_PCD_VARIABLE_HEADER\n"));\r
  DEBUG ((DEBUG_INFO, "  Revision        - 0x%04x\n", PcdVariable->Revision));\r
  DEBUG ((DEBUG_INFO, "  HeaderLength    - 0x%04x\n", PcdVariable->HeaderLength));\r
  DEBUG ((DEBUG_INFO, "  Length          - 0x%08x\n", PcdVariable->Length));\r
  DEBUG ((DEBUG_INFO, "  Type            - 0x%02x\n", PcdVariable->Type));\r
  DEBUG ((DEBUG_INFO, "  Attributes      - 0x%08x\n", PcdVariable->Attributes));\r
  DEBUG ((DEBUG_INFO, "  Guid            - %g\n", &PcdVariable->Guid));\r
  DEBUG ((DEBUG_INFO, "  Name            - %s\n", PcdVariable + 1));\r
\r
  //\r
  // For Pcd ValidData header align.\r
  //\r
  PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *)HEADER_ALIGN (((UINTN)PcdVariable + PcdVariable->HeaderLength));\r
  while ((UINTN)PcdValidData < ((UINTN)PcdVariable + PcdVariable->Length)) {\r
    //\r
    // Dump Pcd ValidData related to the Pcd Variable.\r
    //\r
    DumpPcdValidData (PcdValidData);\r
    //\r
    // For Pcd ValidData header align.\r
    //\r
    PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *)HEADER_ALIGN (((UINTN)PcdValidData + PcdValidData->Length));\r
  }\r
}\r
\r
/**\r
  Dump Var Check PCD.\r
\r
  @param[in] VarCheckPcdBin     Pointer to VarCheckPcdBin.\r
  @param[in] VarCheckPcdBinSize VarCheckPcdBin size.\r
\r
**/\r
VOID\r
DumpVarCheckPcd (\r
  IN VOID   *VarCheckPcdBin,\r
  IN UINTN  VarCheckPcdBinSize\r
  )\r
{\r
  VAR_CHECK_PCD_VARIABLE_HEADER  *PcdVariable;\r
\r
  DEBUG ((DEBUG_INFO, "DumpVarCheckPcd\n"));\r
\r
  //\r
  // For Pcd Variable header align.\r
  //\r
  PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *)HEADER_ALIGN (VarCheckPcdBin);\r
  while ((UINTN)PcdVariable < ((UINTN)VarCheckPcdBin + VarCheckPcdBinSize)) {\r
    DumpPcdVariable (PcdVariable);\r
    //\r
    // For Pcd Variable header align.\r
    //\r
    PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *)HEADER_ALIGN (((UINTN)PcdVariable + PcdVariable->Length));\r
  }\r
}\r
\r
#endif\r
\r
/**\r
  Locate VarCheckPcdBin.\r
\r
**/\r
VOID\r
EFIAPI\r
LocateVarCheckPcdBin (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  VAR_CHECK_PCD_VARIABLE_HEADER  *VarCheckPcdBin;\r
  UINTN                          VarCheckPcdBinSize;\r
\r
  //\r
  // Search the VarCheckPcdBin from the first RAW section of current FFS.\r
  //\r
  Status = GetSectionFromFfs (\r
             EFI_SECTION_RAW,\r
             0,\r
             (VOID **)&VarCheckPcdBin,\r
             &VarCheckPcdBinSize\r
             );\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // AllocateRuntimeZeroPool () from MemoryAllocateLib is used for runtime access\r
    // in SetVariable check handler.\r
    //\r
    mVarCheckPcdBin = AllocateRuntimeCopyPool (VarCheckPcdBinSize, VarCheckPcdBin);\r
    ASSERT (mVarCheckPcdBin != NULL);\r
    //\r
    // Make sure the allocated buffer for VarCheckPcdBin at required alignment.\r
    //\r
    ASSERT ((((UINTN)mVarCheckPcdBin) & (HEADER_ALIGNMENT - 1)) == 0);\r
    mVarCheckPcdBinSize = VarCheckPcdBinSize;\r
    FreePool (VarCheckPcdBin);\r
\r
    DEBUG ((DEBUG_INFO, "VarCheckPcdBin - at 0x%x size = 0x%x\n", mVarCheckPcdBin, mVarCheckPcdBinSize));\r
\r
 #ifdef DUMP_VAR_CHECK_PCD\r
    DEBUG_CODE (\r
      DumpVarCheckPcd (mVarCheckPcdBin, mVarCheckPcdBinSize);\r
      );\r
 #endif\r
  } else {\r
    DEBUG ((DEBUG_INFO, "[VarCheckPcd] No VarCheckPcdBin found at the first RAW section\n"));\r
  }\r
}\r
\r
/**\r
  Constructor function of VarCheckPcdLib to register var check PCD handler.\r
\r
  @param[in] ImageHandle    The firmware allocated handle for the EFI image.\r
  @param[in] SystemTable    A pointer to the EFI System Table.\r
\r
  @retval EFI_SUCCESS       The constructor executed correctly.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
VarCheckPcdLibNullClassConstructor (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  LocateVarCheckPcdBin ();\r
  VarCheckLibRegisterAddressPointer ((VOID **)&mVarCheckPcdBin);\r
  VarCheckLibRegisterSetVariableCheckHandler (SetVariableCheckHandlerPcd);\r
\r
  return EFI_SUCCESS;\r
}\r
Commit	Line	Data
a2918326 SZ	1	/** @file\r
	2	Var Check PCD handler.\r
	3	\r
cd16355b	4	Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>\r
9d510e61	5	SPDX-License-Identifier: BSD-2-Clause-Patent\r
a2918326 SZ	6	\r
	7	**/\r
	8	\r
	9	#include <Library/VarCheckLib.h>\r
	10	#include <Library/BaseLib.h>\r
	11	#include <Library/DebugLib.h>\r
	12	#include <Library/BaseMemoryLib.h>\r
	13	#include <Library/MemoryAllocationLib.h>\r
	14	#include <Library/DxeServicesLib.h>\r
	15	\r
	16	#include "VarCheckPcdStructure.h"\r
	17	\r
1436aea4	18	// #define DUMP_VAR_CHECK_PCD\r
a2918326	19	\r
1436aea4	20	GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mVarCheckPcdHex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };\r
a2918326 SZ	21	\r
	22	/**\r
	23	Dump some hexadecimal data.\r
	24	\r
	25	@param[in] Indent How many spaces to indent the output.\r
	26	@param[in] Offset The offset of the dump.\r
	27	@param[in] DataSize The size in bytes of UserData.\r
	28	@param[in] UserData The data to dump.\r
	29	\r
	30	**/\r
	31	VOID\r
	32	VarCheckPcdInternalDumpHex (\r
1436aea4 MK	33	IN UINTN Indent,\r
	34	IN UINTN Offset,\r
	35	IN UINTN DataSize,\r
	36	IN VOID *UserData\r
a2918326 SZ	37	)\r
a2918326 SZ	38	{\r
1436aea4	39	UINT8 *Data;\r
a2918326	40	\r
1436aea4	41	CHAR8 Val[50];\r
a2918326	42	\r
1436aea4	43	CHAR8 Str[20];\r
a2918326	44	\r
1436aea4 MK	45	UINT8 TempByte;\r
	46	UINTN Size;\r
	47	UINTN Index;\r
a2918326 SZ	48	\r
	49	Data = UserData;\r
	50	while (DataSize != 0) {\r
	51	Size = 16;\r
	52	if (Size > DataSize) {\r
	53	Size = DataSize;\r
	54	}\r
	55	\r
	56	for (Index = 0; Index < Size; Index += 1) {\r
1436aea4 MK	57	TempByte = Data[Index];\r
	58	Val[Index * 3 + 0] = mVarCheckPcdHex[TempByte >> 4];\r
	59	Val[Index * 3 + 1] = mVarCheckPcdHex[TempByte & 0xF];\r
	60	Val[Index * 3 + 2] = (CHAR8)((Index == 7) ? '-' : ' ');\r
	61	Str[Index] = (CHAR8)((TempByte < ' ' \|\| TempByte > 'z') ? '.' : TempByte);\r
a2918326 SZ	62	}\r
a2918326 SZ	63	\r
1436aea4 MK	64	Val[Index * 3] = 0;\r
1436aea4 MK	65	Str[Index] = 0;\r
87000d77	66	DEBUG ((DEBUG_INFO, "%a%08X: %-48a %a*\r\n", Indent, "", Offset, Val, Str));\r
a2918326	67	\r
1436aea4 MK	68	Data += Size;\r
1436aea4 MK	69	Offset += Size;\r
a2918326 SZ	70	DataSize -= Size;\r
	71	}\r
	72	}\r
	73	\r
	74	/**\r
	75	Var Check Pcd ValidData.\r
	76	\r
	77	@param[in] PcdValidData Pointer to Pcd ValidData\r
	78	@param[in] Data Data pointer.\r
	79	@param[in] DataSize Size of Data to set.\r
	80	\r
	81	@retval TRUE Check pass\r
	82	@retval FALSE Check fail.\r
	83	\r
	84	**/\r
	85	BOOLEAN\r
	86	VarCheckPcdValidData (\r
1436aea4 MK	87	IN VAR_CHECK_PCD_VALID_DATA_HEADER *PcdValidData,\r
	88	IN VOID *Data,\r
	89	IN UINTN DataSize\r
a2918326 SZ	90	)\r
a2918326 SZ	91	{\r
1436aea4 MK	92	UINT64 OneData;\r
	93	UINT64 Minimum;\r
	94	UINT64 Maximum;\r
	95	UINT64 OneValue;\r
	96	UINT8 *Ptr;\r
a2918326 SZ	97	\r
a2918326 SZ	98	OneData = 0;\r
1436aea4	99	CopyMem (&OneData, (UINT8 *)Data + PcdValidData->VarOffset, PcdValidData->StorageWidth);\r
a2918326 SZ	100	\r
	101	switch (PcdValidData->Type) {\r
	102	case VarCheckPcdValidList:\r
1436aea4 MK	103	Ptr = (UINT8 )((VAR_CHECK_PCD_VALID_LIST )PcdValidData + 1);\r
1436aea4 MK	104	while ((UINTN)Ptr < (UINTN)PcdValidData + PcdValidData->Length) {\r
a2918326 SZ	105	OneValue = 0;\r
	106	CopyMem (&OneValue, Ptr, PcdValidData->StorageWidth);\r
	107	if (OneData == OneValue) {\r
	108	//\r
	109	// Match\r
	110	//\r
	111	break;\r
	112	}\r
1436aea4	113	\r
a2918326 SZ	114	Ptr += PcdValidData->StorageWidth;\r
a2918326 SZ	115	}\r
1436aea4 MK	116	\r
1436aea4 MK	117	if ((UINTN)Ptr >= ((UINTN)PcdValidData + PcdValidData->Length)) {\r
a2918326 SZ	118	//\r
	119	// No match\r
	120	//\r
87000d77	121	DEBUG ((DEBUG_INFO, "VarCheckPcdValidData fail: ValidList mismatch (0x%lx)\n", OneData));\r
1436aea4 MK	122	DEBUG_CODE (\r
	123	VarCheckPcdInternalDumpHex (2, 0, PcdValidData->Length, (UINT8 *)PcdValidData);\r
	124	);\r
a2918326 SZ	125	return FALSE;\r
a2918326 SZ	126	}\r
1436aea4	127	\r
a2918326 SZ	128	break;\r
	129	\r
	130	case VarCheckPcdValidRange:\r
	131	Minimum = 0;\r
	132	Maximum = 0;\r
1436aea4 MK	133	Ptr = (UINT8 )((VAR_CHECK_PCD_VALID_RANGE )PcdValidData + 1);\r
1436aea4 MK	134	while ((UINTN)Ptr < (UINTN)PcdValidData + PcdValidData->Length) {\r
a2918326 SZ	135	CopyMem (&Minimum, Ptr, PcdValidData->StorageWidth);\r
	136	Ptr += PcdValidData->StorageWidth;\r
	137	CopyMem (&Maximum, Ptr, PcdValidData->StorageWidth);\r
	138	Ptr += PcdValidData->StorageWidth;\r
	139	\r
	140	if ((OneData >= Minimum) && (OneData <= Maximum)) {\r
	141	return TRUE;\r
	142	}\r
	143	}\r
1436aea4	144	\r
87000d77	145	DEBUG ((DEBUG_INFO, "VarCheckPcdValidData fail: ValidRange mismatch (0x%lx)\n", OneData));\r
1436aea4 MK	146	DEBUG_CODE (\r
	147	VarCheckPcdInternalDumpHex (2, 0, PcdValidData->Length, (UINT8 *)PcdValidData);\r
	148	);\r
a2918326 SZ	149	return FALSE;\r
	150	break;\r
	151	\r
	152	default:\r
	153	ASSERT (FALSE);\r
	154	break;\r
	155	}\r
	156	\r
	157	return TRUE;\r
	158	}\r
	159	\r
1436aea4 MK	160	VAR_CHECK_PCD_VARIABLE_HEADER *mVarCheckPcdBin = NULL;\r
1436aea4 MK	161	UINTN mVarCheckPcdBinSize = 0;\r
a2918326 SZ	162	\r
	163	/**\r
	164	SetVariable check handler PCD.\r
	165	\r
	166	@param[in] VariableName Name of Variable to set.\r
	167	@param[in] VendorGuid Variable vendor GUID.\r
	168	@param[in] Attributes Attribute value of the variable.\r
	169	@param[in] DataSize Size of Data to set.\r
	170	@param[in] Data Data pointer.\r
	171	\r
	172	@retval EFI_SUCCESS The SetVariable check result was success.\r
	173	@retval EFI_SECURITY_VIOLATION Check fail.\r
	174	\r
	175	**/\r
	176	EFI_STATUS\r
	177	EFIAPI\r
	178	SetVariableCheckHandlerPcd (\r
1436aea4 MK	179	IN CHAR16 *VariableName,\r
	180	IN EFI_GUID *VendorGuid,\r
	181	IN UINT32 Attributes,\r
	182	IN UINTN DataSize,\r
	183	IN VOID *Data\r
a2918326 SZ	184	)\r
a2918326 SZ	185	{\r
1436aea4 MK	186	VAR_CHECK_PCD_VARIABLE_HEADER *PcdVariable;\r
1436aea4 MK	187	VAR_CHECK_PCD_VALID_DATA_HEADER *PcdValidData;\r
a2918326 SZ	188	\r
	189	if (mVarCheckPcdBin == NULL) {\r
	190	return EFI_SUCCESS;\r
	191	}\r
	192	\r
	193	if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0)) \|\| (Attributes == 0)) {\r
	194	//\r
	195	// Do not check delete variable.\r
	196	//\r
	197	return EFI_SUCCESS;\r
	198	}\r
	199	\r
	200	//\r
	201	// For Pcd Variable header align.\r
	202	//\r
1436aea4 MK	203	PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *)HEADER_ALIGN (mVarCheckPcdBin);\r
	204	while ((UINTN)PcdVariable < ((UINTN)mVarCheckPcdBin + mVarCheckPcdBinSize)) {\r
	205	if ((StrCmp ((CHAR16 *)(PcdVariable + 1), VariableName) == 0) &&\r
	206	(CompareGuid (&PcdVariable->Guid, VendorGuid)))\r
	207	{\r
a2918326 SZ	208	//\r
	209	// Found the Pcd Variable that could be used to do check.\r
	210	//\r
87000d77	211	DEBUG ((DEBUG_INFO, "VarCheckPcdVariable - %s:%g with Attributes = 0x%08x Size = 0x%x\n", VariableName, VendorGuid, Attributes, DataSize));\r
1436aea4	212	if ((PcdVariable->Attributes != 0) && (PcdVariable->Attributes != Attributes)) {\r
87000d77	213	DEBUG ((DEBUG_INFO, "VarCheckPcdVariable fail for Attributes - 0x%08x\n", PcdVariable->Attributes));\r
a2918326 SZ	214	return EFI_SECURITY_VIOLATION;\r
	215	}\r
	216	\r
	217	if (DataSize == 0) {\r
87000d77	218	DEBUG ((DEBUG_INFO, "VarCheckPcdVariable - CHECK PASS with DataSize == 0 !\n"));\r
a2918326 SZ	219	return EFI_SUCCESS;\r
	220	}\r
	221	\r
	222	//\r
	223	// Do the check.\r
	224	// For Pcd ValidData header align.\r
	225	//\r
1436aea4 MK	226	PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *)HEADER_ALIGN (((UINTN)PcdVariable + PcdVariable->HeaderLength));\r
	227	while ((UINTN)PcdValidData < ((UINTN)PcdVariable + PcdVariable->Length)) {\r
	228	if (((UINTN)PcdValidData->VarOffset + PcdValidData->StorageWidth) <= DataSize) {\r
a2918326 SZ	229	if (!VarCheckPcdValidData (PcdValidData, Data, DataSize)) {\r
	230	return EFI_SECURITY_VIOLATION;\r
	231	}\r
	232	}\r
1436aea4	233	\r
a2918326 SZ	234	//\r
	235	// For Pcd ValidData header align.\r
	236	//\r
1436aea4	237	PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *)HEADER_ALIGN (((UINTN)PcdValidData + PcdValidData->Length));\r
a2918326 SZ	238	}\r
a2918326 SZ	239	\r
87000d77	240	DEBUG ((DEBUG_INFO, "VarCheckPcdVariable - ALL CHECK PASS!\n"));\r
a2918326 SZ	241	return EFI_SUCCESS;\r
a2918326 SZ	242	}\r
1436aea4	243	\r
a2918326 SZ	244	//\r
	245	// For Pcd Variable header align.\r
	246	//\r
1436aea4	247	PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *)HEADER_ALIGN (((UINTN)PcdVariable + PcdVariable->Length));\r
a2918326 SZ	248	}\r
	249	\r
	250	// Not found, so pass.\r
	251	return EFI_SUCCESS;\r
	252	}\r
	253	\r
	254	#ifdef DUMP_VAR_CHECK_PCD\r
1436aea4	255	\r
a2918326 SZ	256	/**\r
	257	Dump Pcd ValidData.\r
	258	\r
	259	@param[in] PcdValidData Pointer to Pcd ValidData.\r
	260	\r
	261	**/\r
	262	VOID\r
	263	DumpPcdValidData (\r
1436aea4	264	IN VAR_CHECK_PCD_VALID_DATA_HEADER *PcdValidData\r
a2918326 SZ	265	)\r
a2918326 SZ	266	{\r
1436aea4 MK	267	UINT64 Minimum;\r
	268	UINT64 Maximum;\r
	269	UINT64 OneValue;\r
	270	UINT8 *Ptr;\r
a2918326	271	\r
87000d77 MK	272	DEBUG ((DEBUG_INFO, " VAR_CHECK_PCD_VALID_DATA_HEADER\n"));\r
	273	DEBUG ((DEBUG_INFO, " Type - 0x%02x\n", PcdValidData->Type));\r
	274	DEBUG ((DEBUG_INFO, " Length - 0x%02x\n", PcdValidData->Length));\r
	275	DEBUG ((DEBUG_INFO, " VarOffset - 0x%04x\n", PcdValidData->VarOffset));\r
	276	DEBUG ((DEBUG_INFO, " StorageWidth - 0x%02x\n", PcdValidData->StorageWidth));\r
a2918326 SZ	277	\r
	278	switch (PcdValidData->Type) {\r
	279	case VarCheckPcdValidList:\r
1436aea4 MK	280	Ptr = (UINT8 )((VAR_CHECK_PCD_VALID_LIST )PcdValidData + 1);\r
1436aea4 MK	281	while ((UINTN)Ptr < ((UINTN)PcdValidData + PcdValidData->Length)) {\r
a2918326 SZ	282	OneValue = 0;\r
	283	CopyMem (&OneValue, Ptr, PcdValidData->StorageWidth);\r
	284	switch (PcdValidData->StorageWidth) {\r
	285	case sizeof (UINT8):\r
87000d77	286	DEBUG ((DEBUG_INFO, " ValidList - 0x%02x\n", OneValue));\r
a2918326 SZ	287	break;\r
a2918326 SZ	288	case sizeof (UINT16):\r
87000d77	289	DEBUG ((DEBUG_INFO, " ValidList - 0x%04x\n", OneValue));\r
a2918326 SZ	290	break;\r
a2918326 SZ	291	case sizeof (UINT32):\r
87000d77	292	DEBUG ((DEBUG_INFO, " ValidList - 0x%08x\n", OneValue));\r
a2918326 SZ	293	break;\r
a2918326 SZ	294	case sizeof (UINT64):\r
87000d77	295	DEBUG ((DEBUG_INFO, " ValidList - 0x%016lx\n", OneValue));\r
a2918326 SZ	296	break;\r
	297	default:\r
	298	ASSERT (FALSE);\r
	299	break;\r
	300	}\r
1436aea4	301	\r
a2918326 SZ	302	Ptr += PcdValidData->StorageWidth;\r
a2918326 SZ	303	}\r
1436aea4	304	\r
a2918326 SZ	305	break;\r
	306	\r
	307	case VarCheckPcdValidRange:\r
	308	Minimum = 0;\r
	309	Maximum = 0;\r
1436aea4 MK	310	Ptr = (UINT8 )((VAR_CHECK_PCD_VALID_RANGE )PcdValidData + 1);\r
1436aea4 MK	311	while ((UINTN)Ptr < (UINTN)PcdValidData + PcdValidData->Length) {\r
a2918326 SZ	312	CopyMem (&Minimum, Ptr, PcdValidData->StorageWidth);\r
	313	Ptr += PcdValidData->StorageWidth;\r
	314	CopyMem (&Maximum, Ptr, PcdValidData->StorageWidth);\r
	315	Ptr += PcdValidData->StorageWidth;\r
	316	\r
	317	switch (PcdValidData->StorageWidth) {\r
	318	case sizeof (UINT8):\r
87000d77 MK	319	DEBUG ((DEBUG_INFO, " Minimum - 0x%02x\n", Minimum));\r
87000d77 MK	320	DEBUG ((DEBUG_INFO, " Maximum - 0x%02x\n", Maximum));\r
a2918326 SZ	321	break;\r
a2918326 SZ	322	case sizeof (UINT16):\r
87000d77 MK	323	DEBUG ((DEBUG_INFO, " Minimum - 0x%04x\n", Minimum));\r
87000d77 MK	324	DEBUG ((DEBUG_INFO, " Maximum - 0x%04x\n", Maximum));\r
a2918326 SZ	325	break;\r
a2918326 SZ	326	case sizeof (UINT32):\r
87000d77 MK	327	DEBUG ((DEBUG_INFO, " Minimum - 0x%08x\n", Minimum));\r
87000d77 MK	328	DEBUG ((DEBUG_INFO, " Maximum - 0x%08x\n", Maximum));\r
a2918326 SZ	329	break;\r
a2918326 SZ	330	case sizeof (UINT64):\r
87000d77 MK	331	DEBUG ((DEBUG_INFO, " Minimum - 0x%016lx\n", Minimum));\r
87000d77 MK	332	DEBUG ((DEBUG_INFO, " Maximum - 0x%016lx\n", Maximum));\r
a2918326 SZ	333	break;\r
	334	default:\r
	335	ASSERT (FALSE);\r
	336	break;\r
	337	}\r
	338	}\r
1436aea4	339	\r
a2918326 SZ	340	break;\r
	341	\r
	342	default:\r
	343	ASSERT (FALSE);\r
	344	break;\r
	345	}\r
	346	}\r
	347	\r
	348	/**\r
	349	Dump Pcd Variable.\r
	350	\r
	351	@param[in] PcdVariable Pointer to Pcd Variable.\r
	352	\r
	353	**/\r
	354	VOID\r
	355	DumpPcdVariable (\r
	356	IN VAR_CHECK_PCD_VARIABLE_HEADER *PcdVariable\r
	357	)\r
	358	{\r
1436aea4	359	VAR_CHECK_PCD_VALID_DATA_HEADER *PcdValidData;\r
a2918326	360	\r
87000d77 MK	361	DEBUG ((DEBUG_INFO, "VAR_CHECK_PCD_VARIABLE_HEADER\n"));\r
	362	DEBUG ((DEBUG_INFO, " Revision - 0x%04x\n", PcdVariable->Revision));\r
	363	DEBUG ((DEBUG_INFO, " HeaderLength - 0x%04x\n", PcdVariable->HeaderLength));\r
	364	DEBUG ((DEBUG_INFO, " Length - 0x%08x\n", PcdVariable->Length));\r
	365	DEBUG ((DEBUG_INFO, " Type - 0x%02x\n", PcdVariable->Type));\r
	366	DEBUG ((DEBUG_INFO, " Attributes - 0x%08x\n", PcdVariable->Attributes));\r
	367	DEBUG ((DEBUG_INFO, " Guid - %g\n", &PcdVariable->Guid));\r
	368	DEBUG ((DEBUG_INFO, " Name - %s\n", PcdVariable + 1));\r
a2918326 SZ	369	\r
	370	//\r
	371	// For Pcd ValidData header align.\r
	372	//\r
1436aea4 MK	373	PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *)HEADER_ALIGN (((UINTN)PcdVariable + PcdVariable->HeaderLength));\r
1436aea4 MK	374	while ((UINTN)PcdValidData < ((UINTN)PcdVariable + PcdVariable->Length)) {\r
a2918326 SZ	375	//\r
	376	// Dump Pcd ValidData related to the Pcd Variable.\r
	377	//\r
	378	DumpPcdValidData (PcdValidData);\r
	379	//\r
	380	// For Pcd ValidData header align.\r
	381	//\r
1436aea4	382	PcdValidData = (VAR_CHECK_PCD_VALID_DATA_HEADER *)HEADER_ALIGN (((UINTN)PcdValidData + PcdValidData->Length));\r
a2918326 SZ	383	}\r
	384	}\r
	385	\r
	386	/**\r
	387	Dump Var Check PCD.\r
	388	\r
	389	@param[in] VarCheckPcdBin Pointer to VarCheckPcdBin.\r
	390	@param[in] VarCheckPcdBinSize VarCheckPcdBin size.\r
	391	\r
	392	**/\r
	393	VOID\r
	394	DumpVarCheckPcd (\r
	395	IN VOID *VarCheckPcdBin,\r
	396	IN UINTN VarCheckPcdBinSize\r
	397	)\r
	398	{\r
1436aea4	399	VAR_CHECK_PCD_VARIABLE_HEADER *PcdVariable;\r
a2918326	400	\r
87000d77	401	DEBUG ((DEBUG_INFO, "DumpVarCheckPcd\n"));\r
a2918326 SZ	402	\r
	403	//\r
	404	// For Pcd Variable header align.\r
	405	//\r
1436aea4 MK	406	PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *)HEADER_ALIGN (VarCheckPcdBin);\r
1436aea4 MK	407	while ((UINTN)PcdVariable < ((UINTN)VarCheckPcdBin + VarCheckPcdBinSize)) {\r
a2918326 SZ	408	DumpPcdVariable (PcdVariable);\r
	409	//\r
	410	// For Pcd Variable header align.\r
	411	//\r
1436aea4	412	PcdVariable = (VAR_CHECK_PCD_VARIABLE_HEADER *)HEADER_ALIGN (((UINTN)PcdVariable + PcdVariable->Length));\r
a2918326 SZ	413	}\r
a2918326 SZ	414	}\r
1436aea4	415	\r
a2918326 SZ	416	#endif\r
	417	\r
	418	/**\r
	419	Locate VarCheckPcdBin.\r
	420	\r
	421	**/\r
	422	VOID\r
	423	EFIAPI\r
	424	LocateVarCheckPcdBin (\r
	425	VOID\r
	426	)\r
	427	{\r
1436aea4 MK	428	EFI_STATUS Status;\r
	429	VAR_CHECK_PCD_VARIABLE_HEADER *VarCheckPcdBin;\r
	430	UINTN VarCheckPcdBinSize;\r
a2918326 SZ	431	\r
	432	//\r
	433	// Search the VarCheckPcdBin from the first RAW section of current FFS.\r
	434	//\r
	435	Status = GetSectionFromFfs (\r
	436	EFI_SECTION_RAW,\r
	437	0,\r
1436aea4	438	(VOID **)&VarCheckPcdBin,\r
a2918326 SZ	439	&VarCheckPcdBinSize\r
	440	);\r
	441	if (!EFI_ERROR (Status)) {\r
	442	//\r
	443	// AllocateRuntimeZeroPool () from MemoryAllocateLib is used for runtime access\r
	444	// in SetVariable check handler.\r
	445	//\r
	446	mVarCheckPcdBin = AllocateRuntimeCopyPool (VarCheckPcdBinSize, VarCheckPcdBin);\r
	447	ASSERT (mVarCheckPcdBin != NULL);\r
cd16355b SZ	448	//\r
	449	// Make sure the allocated buffer for VarCheckPcdBin at required alignment.\r
	450	//\r
1436aea4	451	ASSERT ((((UINTN)mVarCheckPcdBin) & (HEADER_ALIGNMENT - 1)) == 0);\r
a2918326 SZ	452	mVarCheckPcdBinSize = VarCheckPcdBinSize;\r
	453	FreePool (VarCheckPcdBin);\r
	454	\r
87000d77	455	DEBUG ((DEBUG_INFO, "VarCheckPcdBin - at 0x%x size = 0x%x\n", mVarCheckPcdBin, mVarCheckPcdBinSize));\r
a2918326	456	\r
1436aea4	457	#ifdef DUMP_VAR_CHECK_PCD\r
a2918326 SZ	458	DEBUG_CODE (\r
a2918326 SZ	459	DumpVarCheckPcd (mVarCheckPcdBin, mVarCheckPcdBinSize);\r
1436aea4 MK	460	);\r
1436aea4 MK	461	#endif\r
a2918326	462	} else {\r
87000d77	463	DEBUG ((DEBUG_INFO, "[VarCheckPcd] No VarCheckPcdBin found at the first RAW section\n"));\r
a2918326 SZ	464	}\r
	465	}\r
	466	\r
	467	/**\r
	468	Constructor function of VarCheckPcdLib to register var check PCD handler.\r
	469	\r
	470	@param[in] ImageHandle The firmware allocated handle for the EFI image.\r
	471	@param[in] SystemTable A pointer to the EFI System Table.\r
	472	\r
	473	@retval EFI_SUCCESS The constructor executed correctly.\r
	474	\r
	475	**/\r
	476	EFI_STATUS\r
	477	EFIAPI\r
	478	VarCheckPcdLibNullClassConstructor (\r
1436aea4 MK	479	IN EFI_HANDLE ImageHandle,\r
1436aea4 MK	480	IN EFI_SYSTEM_TABLE *SystemTable\r
a2918326 SZ	481	)\r
	482	{\r
	483	LocateVarCheckPcdBin ();\r
1436aea4	484	VarCheckLibRegisterAddressPointer ((VOID **)&mVarCheckPcdBin);\r
a2918326 SZ	485	VarCheckLibRegisterSetVariableCheckHandler (SetVariableCheckHandlerPcd);\r
	486	\r
	487	return EFI_SUCCESS;\r
	488	}\r