[mirror_edk2.git] / MdeModulePkg / Universal / SmbiosMeasurementDxe / SmbiosMeasurementDxe.c

/** @file\r
  This driver measures SMBIOS table to TPM.\r
  \r
Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials                          \r
are licensed and made available under the terms and conditions of the BSD License         \r
which accompanies this distribution.  The full text of the license may be found at        \r
http://opensource.org/licenses/bsd-license.php                                            \r
                                                                                          \r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
\r
**/\r
\r
#include <PiDxe.h>\r
\r
#include <Protocol/Smbios.h>\r
#include <IndustryStandard/SmBios.h>\r
#include <IndustryStandard/UefiTcgPlatform.h>\r
#include <Guid/EventGroup.h>\r
#include <Guid/SmBios.h>\r
#include <Library/DebugLib.h>\r
#include <Library/UefiDriverEntryPoint.h>\r
#include <Library/UefiLib.h>\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/TpmMeasurementLib.h>\r
\r
#define FIELD_SIZE_OF(TYPE, Field) ((UINTN)sizeof(((TYPE *)0)->Field))\r
\r
typedef struct {\r
  UINT8  Type;\r
  UINTN  Offset;\r
  UINTN  Size;\r
  UINT32 Flags;\r
} SMBIOS_FILTER_TABLE;\r
#define SMBIOS_FILTER_TABLE_FLAG_IS_STRING  BIT0\r
\r
typedef struct {\r
  UINT8                Type;\r
  SMBIOS_FILTER_TABLE  *Filter; // NULL means all fields\r
  UINTN                FilterCount;\r
} SMBIOS_FILTER_STRUCT;\r
\r
//\r
// Platform Specific Policy\r
//\r
SMBIOS_FILTER_TABLE  mSmbiosFilterType1BlackList[] = {\r
  {0x01, OFFSET_OF(SMBIOS_TABLE_TYPE1, SerialNumber),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE1, SerialNumber),         SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x01, OFFSET_OF(SMBIOS_TABLE_TYPE1, Uuid),                 FIELD_SIZE_OF(SMBIOS_TABLE_TYPE1, Uuid),                 0},\r
  {0x01, OFFSET_OF(SMBIOS_TABLE_TYPE1, WakeUpType),           FIELD_SIZE_OF(SMBIOS_TABLE_TYPE1, WakeUpType),           0},\r
};\r
SMBIOS_FILTER_TABLE  mSmbiosFilterType2BlackList[] = {\r
  {0x02, OFFSET_OF(SMBIOS_TABLE_TYPE2, SerialNumber),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE2, SerialNumber),         SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x02, OFFSET_OF(SMBIOS_TABLE_TYPE2, LocationInChassis),    FIELD_SIZE_OF(SMBIOS_TABLE_TYPE2, LocationInChassis),    SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
};\r
SMBIOS_FILTER_TABLE  mSmbiosFilterType3BlackList[] = {\r
  {0x03, OFFSET_OF(SMBIOS_TABLE_TYPE3, SerialNumber),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE3, SerialNumber),         SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x03, OFFSET_OF(SMBIOS_TABLE_TYPE3, AssetTag),             FIELD_SIZE_OF(SMBIOS_TABLE_TYPE3, AssetTag),             SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
};\r
SMBIOS_FILTER_TABLE  mSmbiosFilterType4BlackList[] = {\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, SerialNumber),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, SerialNumber),         SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, AssetTag),             FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, AssetTag),             SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, PartNumber),           FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, PartNumber),           SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, CoreCount),            FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, CoreCount),            0},\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, EnabledCoreCount),     FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, EnabledCoreCount),     0},\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, ThreadCount),          FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, ThreadCount),          0},\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, CoreCount2),           FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, CoreCount2),           0},\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, EnabledCoreCount2),    FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, EnabledCoreCount2),    0},\r
  {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, ThreadCount2),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, ThreadCount2),         0},\r
};\r
SMBIOS_FILTER_TABLE  mSmbiosFilterType17BlackList[] = {\r
  {0x11, OFFSET_OF(SMBIOS_TABLE_TYPE17, SerialNumber),        FIELD_SIZE_OF(SMBIOS_TABLE_TYPE17, SerialNumber),        SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x11, OFFSET_OF(SMBIOS_TABLE_TYPE17, AssetTag),            FIELD_SIZE_OF(SMBIOS_TABLE_TYPE17, AssetTag),            SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x11, OFFSET_OF(SMBIOS_TABLE_TYPE17, PartNumber),          FIELD_SIZE_OF(SMBIOS_TABLE_TYPE17, PartNumber),          SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
};\r
SMBIOS_FILTER_TABLE  mSmbiosFilterType22BlackList[] = {\r
  {0x16, OFFSET_OF(SMBIOS_TABLE_TYPE22, SerialNumber),        FIELD_SIZE_OF(SMBIOS_TABLE_TYPE22, SerialNumber),        SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x16, OFFSET_OF(SMBIOS_TABLE_TYPE22, SBDSSerialNumber),    FIELD_SIZE_OF(SMBIOS_TABLE_TYPE22, SBDSSerialNumber),    0},\r
  {0x16, OFFSET_OF(SMBIOS_TABLE_TYPE22, SBDSManufactureDate), FIELD_SIZE_OF(SMBIOS_TABLE_TYPE22, SBDSManufactureDate), 0},\r
};\r
SMBIOS_FILTER_TABLE  mSmbiosFilterType23BlackList[] = {\r
  {0x17, OFFSET_OF(SMBIOS_TABLE_TYPE23, ResetCount),          FIELD_SIZE_OF(SMBIOS_TABLE_TYPE23, ResetCount),          0},\r
};\r
SMBIOS_FILTER_TABLE  mSmbiosFilterType39BlackList[] = {\r
  {0x27, OFFSET_OF(SMBIOS_TABLE_TYPE39, SerialNumber),        FIELD_SIZE_OF(SMBIOS_TABLE_TYPE39, SerialNumber),        SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x27, OFFSET_OF(SMBIOS_TABLE_TYPE39, AssetTagNumber),      FIELD_SIZE_OF(SMBIOS_TABLE_TYPE39, AssetTagNumber),      SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
  {0x27, OFFSET_OF(SMBIOS_TABLE_TYPE39, ModelPartNumber),     FIELD_SIZE_OF(SMBIOS_TABLE_TYPE39, ModelPartNumber),     SMBIOS_FILTER_TABLE_FLAG_IS_STRING},\r
};\r
\r
SMBIOS_FILTER_STRUCT  mSmbiosFilterStandardTableBlackList[] = {\r
  {0x01, mSmbiosFilterType1BlackList,  sizeof(mSmbiosFilterType1BlackList)/sizeof(mSmbiosFilterType1BlackList[0])},\r
  {0x02, mSmbiosFilterType2BlackList,  sizeof(mSmbiosFilterType2BlackList)/sizeof(mSmbiosFilterType2BlackList[0])},\r
  {0x03, mSmbiosFilterType3BlackList,  sizeof(mSmbiosFilterType3BlackList)/sizeof(mSmbiosFilterType3BlackList[0])},\r
  {0x04, mSmbiosFilterType4BlackList,  sizeof(mSmbiosFilterType4BlackList)/sizeof(mSmbiosFilterType4BlackList[0])},\r
  {0x0B, NULL, 0},\r
  {0x0F, NULL, 0},\r
  {0x11, mSmbiosFilterType17BlackList, sizeof(mSmbiosFilterType17BlackList)/sizeof(mSmbiosFilterType17BlackList[0])},\r
  {0x12, NULL, 0},\r
  {0x16, mSmbiosFilterType22BlackList, sizeof(mSmbiosFilterType22BlackList)/sizeof(mSmbiosFilterType22BlackList[0])},\r
  {0x17, mSmbiosFilterType23BlackList, sizeof(mSmbiosFilterType23BlackList)/sizeof(mSmbiosFilterType23BlackList[0])},\r
  {0x1F, NULL, 0},\r
  {0x21, NULL, 0},\r
  {0x27, mSmbiosFilterType39BlackList, sizeof(mSmbiosFilterType39BlackList)/sizeof(mSmbiosFilterType39BlackList[0])},\r
};\r
\r
EFI_SMBIOS_PROTOCOL *mSmbios;\r
UINTN               mMaxLen;\r
\r
/**\r
\r
  This function dump raw data.\r
\r
  @param  Data  raw data\r
  @param  Size  raw data size\r
\r
**/\r
VOID\r
InternalDumpData (\r
  IN UINT8  *Data,\r
  IN UINTN  Size\r
  )\r
{\r
  UINTN  Index;\r
  for (Index = 0; Index < Size; Index++) {\r
    DEBUG ((EFI_D_VERBOSE, "%02x", (UINTN)Data[Index]));\r
  }\r
}\r
\r
/**\r
\r
  This function dump raw data with colume format.\r
\r
  @param  Data  raw data\r
  @param  Size  raw data size\r
\r
**/\r
VOID\r
InternalDumpHex (\r
  IN UINT8  *Data,\r
  IN UINTN  Size\r
  )\r
{\r
  UINTN   Index;\r
  UINTN   Count;\r
  UINTN   Left;\r
\r
#define COLUME_SIZE  (16 * 2)\r
\r
  Count = Size / COLUME_SIZE;\r
  Left  = Size % COLUME_SIZE;\r
  for (Index = 0; Index < Count; Index++) {\r
    DEBUG ((EFI_D_VERBOSE, "%04x: ", Index * COLUME_SIZE));\r
    InternalDumpData (Data + Index * COLUME_SIZE, COLUME_SIZE);\r
    DEBUG ((EFI_D_VERBOSE, "\n"));\r
  }\r
\r
  if (Left != 0) {\r
    DEBUG ((EFI_D_VERBOSE, "%04x: ", Index * COLUME_SIZE));\r
    InternalDumpData (Data + Index * COLUME_SIZE, Left);\r
    DEBUG ((EFI_D_VERBOSE, "\n"));\r
  }\r
}\r
\r
\r
/**\r
\r
  This function get filter structure by SMBIOS type.\r
\r
  @param  Type  SMBIOS type\r
\r
**/\r
SMBIOS_FILTER_STRUCT *\r
GetFilterStructByType (\r
  IN UINT8 Type\r
  )\r
{\r
  UINTN  Index;\r
  for (Index = 0; Index < sizeof(mSmbiosFilterStandardTableBlackList)/sizeof(mSmbiosFilterStandardTableBlackList[0]); Index++) {\r
    if (mSmbiosFilterStandardTableBlackList[Index].Type == Type) {\r
      return &mSmbiosFilterStandardTableBlackList[Index];\r
    }\r
  }\r
  return NULL;\r
}\r
\r
/**\r
\r
  This function get SMBIOS string in SMBIOS table.\r
\r
  @param  Head      SMBIOS table head\r
  @param  StringId  SMBIOS string ID\r
  @param  StringLen length of SMBIOS string\r
\r
  @return SMBIOS string data\r
**/\r
CHAR8 *\r
GetSmbiosStringById (\r
  IN   EFI_SMBIOS_TABLE_HEADER          *Head,\r
  IN   SMBIOS_TABLE_STRING              StringId,\r
  OUT  UINTN                            *StringLen\r
  )\r
{\r
  UINTN  Size;\r
  UINTN  StrLen;\r
  CHAR8  *CharInStr;\r
  UINTN  StringsNumber;\r
  CHAR8  *String;\r
\r
  CharInStr = (CHAR8 *)Head + Head->Length;\r
  Size = Head->Length;\r
  StringsNumber = 0;\r
  StrLen = 0;\r
  //\r
  // look for the two consecutive zeros, check the string limit by the way.\r
  //\r
  String = NULL;\r
  while (*CharInStr != 0 || *(CharInStr+1) != 0) { \r
    if (*CharInStr == 0) {\r
      Size += 1;\r
      CharInStr++;\r
    }\r
    String = CharInStr;\r
\r
    for (StrLen = 0 ; StrLen < mMaxLen; StrLen++) {\r
      if (*(CharInStr+StrLen) == 0) {\r
        break;\r
      }\r
    }\r
    *StringLen = StrLen;\r
\r
    if (StrLen == mMaxLen) {\r
      return NULL;\r
    }\r
\r
    //\r
    // forward the pointer\r
    //\r
    CharInStr += StrLen;\r
    Size += StrLen;\r
    StringsNumber += 1;\r
    if (StringsNumber == StringId) {\r
      break;\r
    }\r
  }\r
\r
  return String;\r
}\r
\r
/**\r
\r
  This function update SMBIOS table based on policy.\r
\r
  @param  TableEntry      SMBIOS table\r
  @param  TableEntrySize  SMBIOS table size\r
\r
**/\r
VOID\r
FilterSmbiosEntry (\r
  IN OUT VOID   *TableEntry,\r
  IN UINTN      TableEntrySize\r
  )\r
{\r
  SMBIOS_FILTER_STRUCT  *FilterStruct;\r
  SMBIOS_FILTER_TABLE   *Filter;\r
  UINTN                 Index;\r
  SMBIOS_TABLE_STRING   StringId;\r
  CHAR8                 *String;\r
  UINTN                 StringLen;\r
\r
  DEBUG ((EFI_D_INFO, "Smbios Table (Type - %d):\n", ((SMBIOS_STRUCTURE *)TableEntry)->Type));\r
  DEBUG_CODE (InternalDumpHex (TableEntry, TableEntrySize););\r
\r
  FilterStruct = GetFilterStructByType (((SMBIOS_STRUCTURE *)TableEntry)->Type);\r
  if (FilterStruct != NULL) {\r
    if (FilterStruct->Filter == NULL || FilterStruct->FilterCount == 0) {\r
      // zero all table entries, except header\r
      ZeroMem ((UINT8 *)TableEntry + sizeof(SMBIOS_STRUCTURE), TableEntrySize - sizeof(SMBIOS_STRUCTURE));\r
    } else {\r
      Filter = FilterStruct->Filter;\r
      for (Index = 0; Index < FilterStruct->FilterCount; Index++) {\r
        if ((Filter[Index].Flags & SMBIOS_FILTER_TABLE_FLAG_IS_STRING) != 0) {\r
          CopyMem (&StringId, (UINT8 *)TableEntry + Filter[Index].Offset, sizeof(StringId));\r
          if (StringId != 0) {\r
            // set ' ' for string field\r
            String = GetSmbiosStringById (TableEntry, StringId, &StringLen);\r
            //DEBUG ((EFI_D_INFO,"StrId(0x%x)-%a(%d)\n", StringId, String, StringLen));\r
            SetMem (String, StringLen, ' ');\r
          }\r
        }\r
        // zero non-string field\r
        ZeroMem ((UINT8 *)TableEntry + Filter[Index].Offset, Filter[Index].Size);\r
      }\r
    }\r
  }\r
\r
  DEBUG ((EFI_D_INFO, "Filter Smbios Table (Type - %d):\n", ((SMBIOS_STRUCTURE *)TableEntry)->Type));\r
  DEBUG_CODE (InternalDumpHex (TableEntry, TableEntrySize););\r
}\r
\r
/**\r
\r
  Get the full size of SMBIOS structure including optional strings that follow the formatted structure.\r
\r
  @param Head                   Pointer to the beginning of SMBIOS structure.\r
  @param NumberOfStrings        The returned number of optional strings that follow the formatted structure.\r
  \r
  @return Size                  The returned size.\r
**/\r
UINTN\r
GetSmbiosStructureSize (\r
  IN   EFI_SMBIOS_TABLE_HEADER          *Head,\r
  OUT  UINTN                            *NumberOfStrings\r
  )\r
{\r
  UINTN  Size;\r
  UINTN  StrLen;\r
  CHAR8  *CharInStr;\r
  UINTN  StringsNumber;\r
\r
  CharInStr = (CHAR8 *)Head + Head->Length;\r
  Size = Head->Length;\r
  StringsNumber = 0;\r
  StrLen = 0;\r
  //\r
  // look for the two consecutive zeros, check the string limit by the way.\r
  //\r
  while (*CharInStr != 0 || *(CharInStr+1) != 0) { \r
    if (*CharInStr == 0) {\r
      Size += 1;\r
      CharInStr++;\r
    }\r
\r
    for (StrLen = 0 ; StrLen < mMaxLen; StrLen++) {\r
      if (*(CharInStr+StrLen) == 0) {\r
        break;\r
      }\r
    }\r
\r
    if (StrLen == mMaxLen) {\r
      return 0;\r
    }\r
\r
    //\r
    // forward the pointer\r
    //\r
    CharInStr += StrLen;\r
    Size += StrLen;\r
    StringsNumber += 1;\r
  }\r
\r
  //\r
  // count ending two zeros.\r
  //\r
  Size += 2;\r
\r
  if (NumberOfStrings != NULL) {\r
    *NumberOfStrings = StringsNumber;\r
  }\r
  return Size;\r
}\r
\r
/**\r
\r
  This function returns full SMBIOS table length.\r
\r
  @param  TableAddress      SMBIOS table based address\r
  @param  TableMaximumSize  Maximum size of SMBIOS table\r
\r
  @return SMBIOS table length\r
\r
**/\r
UINTN\r
GetSmbiosTableLength (\r
  IN VOID  *TableAddress,\r
  IN UINTN TableMaximumSize\r
  )\r
{\r
  VOID  *TableEntry;\r
  VOID  *TableAddressEnd;\r
  UINTN TableEntryLength;\r
\r
  TableAddressEnd = (VOID *)((UINTN)TableAddress + TableMaximumSize);\r
  TableEntry = TableAddress;\r
  while (TableEntry < TableAddressEnd) {\r
    TableEntryLength = GetSmbiosStructureSize (TableEntry, NULL);\r
    if (TableEntryLength == 0) {\r
      break;\r
    }\r
    if (((SMBIOS_STRUCTURE *)TableEntry)->Type == 127) {\r
      TableEntry = (VOID *)((UINTN)TableEntry + TableEntryLength);\r
      break;\r
    }\r
    TableEntry = (VOID *)((UINTN)TableEntry + TableEntryLength);\r
  }\r
\r
  return ((UINTN)TableEntry - (UINTN)TableAddress);\r
}\r
\r
/**\r
\r
  This function updatess full SMBIOS table length.\r
\r
  @param  TableAddress      SMBIOS table based address\r
  @param  TableLength       SMBIOS table length\r
\r
**/\r
VOID\r
FilterSmbiosTable (\r
  IN OUT VOID  *TableAddress,\r
  IN UINTN     TableLength\r
  )\r
{\r
  VOID   *TableAddressEnd;\r
  VOID   *TableEntry;\r
  UINTN  TableEntryLength;\r
\r
  TableEntry = TableAddress;\r
  TableAddressEnd = (VOID *)((UINTN)TableAddress + TableLength);\r
  while ((UINTN)TableEntry < (UINTN)TableAddressEnd) {\r
    TableEntryLength = GetSmbiosStructureSize (TableEntry, NULL);\r
    if (TableEntryLength == 0) {\r
      break;\r
    }\r
\r
    FilterSmbiosEntry (TableEntry, TableEntryLength);\r
\r
    TableEntry = (VOID *)((UINTN)TableEntry + TableEntryLength);\r
  }\r
}\r
\r
/**\r
  Measure SMBIOS with EV_EFI_HANDOFF_TABLES to PCR[1]\r
**/\r
VOID\r
EFIAPI\r
MeasureSmbiosTable (\r
  IN      EFI_EVENT                 Event,\r
  IN      VOID                      *Context\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  EFI_HANDOFF_TABLE_POINTERS        HandoffTables;\r
  SMBIOS_TABLE_ENTRY_POINT          *SmbiosTable;\r
  SMBIOS_TABLE_3_0_ENTRY_POINT      *Smbios3Table;\r
  VOID                              *SmbiosTableAddress;\r
  VOID                              *TableAddress;\r
  UINTN                             TableLength;\r
\r
  SmbiosTable = NULL;\r
  Smbios3Table = NULL;\r
  SmbiosTableAddress = NULL;\r
  TableLength = 0;\r
\r
  if (mSmbios->MajorVersion >= 3) {\r
    Status = EfiGetSystemConfigurationTable (\r
               &gEfiSmbios3TableGuid,\r
               (VOID **) &Smbios3Table\r
               );\r
    if (!EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_INFO, "Smbios3Table:\n"));\r
      DEBUG ((EFI_D_INFO, "  AnchorString                - '%c%c%c%c%c'\n",\r
        Smbios3Table->AnchorString[0],\r
        Smbios3Table->AnchorString[1],\r
        Smbios3Table->AnchorString[2],\r
        Smbios3Table->AnchorString[3],\r
        Smbios3Table->AnchorString[4]\r
        ));\r
      DEBUG ((EFI_D_INFO, "  EntryPointStructureChecksum - 0x%02x\n", Smbios3Table->EntryPointStructureChecksum));\r
      DEBUG ((EFI_D_INFO, "  EntryPointLength            - 0x%02x\n", Smbios3Table->EntryPointLength));\r
      DEBUG ((EFI_D_INFO, "  MajorVersion                - 0x%02x\n", Smbios3Table->MajorVersion));\r
      DEBUG ((EFI_D_INFO, "  MinorVersion                - 0x%02x\n", Smbios3Table->MinorVersion));\r
      DEBUG ((EFI_D_INFO, "  DocRev                      - 0x%02x\n", Smbios3Table->DocRev));\r
      DEBUG ((EFI_D_INFO, "  EntryPointRevision          - 0x%02x\n", Smbios3Table->EntryPointRevision));\r
      DEBUG ((EFI_D_INFO, "  TableMaximumSize            - 0x%08x\n", Smbios3Table->TableMaximumSize));\r
      DEBUG ((EFI_D_INFO, "  TableAddress                - 0x%016lx\n", Smbios3Table->TableAddress));\r
    }\r
  }\r
\r
  if (Smbios3Table == NULL) {\r
    Status = EfiGetSystemConfigurationTable (\r
               &gEfiSmbiosTableGuid,\r
               (VOID **) &SmbiosTable\r
               );\r
    if (!EFI_ERROR (Status)) {\r
      DEBUG ((EFI_D_INFO, "SmbiosTable:\n"));\r
      DEBUG ((EFI_D_INFO, "  AnchorString                - '%c%c%c%c'\n",\r
        SmbiosTable->AnchorString[0],\r
        SmbiosTable->AnchorString[1],\r
        SmbiosTable->AnchorString[2],\r
        SmbiosTable->AnchorString[3]\r
        ));\r
      DEBUG ((EFI_D_INFO, "  EntryPointStructureChecksum - 0x%02x\n", SmbiosTable->EntryPointStructureChecksum));\r
      DEBUG ((EFI_D_INFO, "  EntryPointLength            - 0x%02x\n", SmbiosTable->EntryPointLength));\r
      DEBUG ((EFI_D_INFO, "  MajorVersion                - 0x%02x\n", SmbiosTable->MajorVersion));\r
      DEBUG ((EFI_D_INFO, "  MinorVersion                - 0x%02x\n", SmbiosTable->MinorVersion));\r
      DEBUG ((EFI_D_INFO, "  MaxStructureSize            - 0x%08x\n", SmbiosTable->MaxStructureSize));\r
      DEBUG ((EFI_D_INFO, "  EntryPointRevision          - 0x%02x\n", SmbiosTable->EntryPointRevision));\r
      DEBUG ((EFI_D_INFO, "  FormattedArea               - '%c%c%c%c%c'\n",\r
        SmbiosTable->FormattedArea[0],\r
        SmbiosTable->FormattedArea[1],\r
        SmbiosTable->FormattedArea[2],\r
        SmbiosTable->FormattedArea[3],\r
        SmbiosTable->FormattedArea[4]\r
        ));\r
      DEBUG ((EFI_D_INFO, "  IntermediateAnchorString    - '%c%c%c%c%c'\n",\r
        SmbiosTable->IntermediateAnchorString[0],\r
        SmbiosTable->IntermediateAnchorString[1],\r
        SmbiosTable->IntermediateAnchorString[2],\r
        SmbiosTable->IntermediateAnchorString[3],\r
        SmbiosTable->IntermediateAnchorString[4]\r
        ));\r
      DEBUG ((EFI_D_INFO, "  IntermediateChecksum        - 0x%02x\n", SmbiosTable->IntermediateChecksum));\r
      DEBUG ((EFI_D_INFO, "  TableLength                 - 0x%04x\n", SmbiosTable->TableLength));\r
      DEBUG ((EFI_D_INFO, "  TableAddress                - 0x%08x\n", SmbiosTable->TableAddress));\r
      DEBUG ((EFI_D_INFO, "  NumberOfSmbiosStructures    - 0x%04x\n", SmbiosTable->NumberOfSmbiosStructures));\r
      DEBUG ((EFI_D_INFO, "  SmbiosBcdRevision           - 0x%02x\n", SmbiosTable->SmbiosBcdRevision));\r
    }\r
  }\r
\r
  if (Smbios3Table != NULL) {\r
    SmbiosTableAddress = (VOID *)(UINTN)Smbios3Table->TableAddress;\r
    TableLength = GetSmbiosTableLength (SmbiosTableAddress, Smbios3Table->TableMaximumSize);\r
  } else if (SmbiosTable != NULL) {\r
    SmbiosTableAddress = (VOID *)(UINTN)SmbiosTable->TableAddress;\r
    TableLength = SmbiosTable->TableLength;\r
  }\r
\r
  if (SmbiosTableAddress != NULL) {\r
    DEBUG ((DEBUG_INFO, "The Smbios Table starts at: 0x%x\n", SmbiosTableAddress));\r
    DEBUG ((DEBUG_INFO, "The Smbios Table size: 0x%x\n", TableLength));\r
    DEBUG_CODE (InternalDumpHex ((UINT8 *)(UINTN)SmbiosTableAddress, TableLength););\r
\r
    TableAddress = AllocateCopyPool ((UINTN)TableLength, (VOID *)(UINTN)SmbiosTableAddress);\r
    if (TableAddress == NULL) {\r
      return ;\r
    }\r
\r
    FilterSmbiosTable (TableAddress, TableLength);\r
\r
    DEBUG ((DEBUG_INFO, "The final Smbios Table starts at: 0x%x\n", TableAddress));\r
    DEBUG ((DEBUG_INFO, "The final Smbios Table size: 0x%x\n", TableLength));\r
    DEBUG_CODE (InternalDumpHex (TableAddress, TableLength););\r
\r
    HandoffTables.NumberOfTables = 1;\r
    if (Smbios3Table != NULL) {\r
      CopyGuid (&(HandoffTables.TableEntry[0].VendorGuid), &gEfiSmbios3TableGuid);\r
      HandoffTables.TableEntry[0].VendorTable = Smbios3Table;\r
    } else {\r
      CopyGuid (&(HandoffTables.TableEntry[0].VendorGuid), &gEfiSmbiosTableGuid);\r
      HandoffTables.TableEntry[0].VendorTable = SmbiosTable;\r
    }\r
    Status = TpmMeasureAndLogData (\r
               1,                       // PCRIndex\r
               EV_EFI_HANDOFF_TABLES,   // EventType\r
               &HandoffTables,          // EventLog\r
               sizeof (HandoffTables),  // LogLen\r
               TableAddress,            // HashData\r
               TableLength              // HashDataLen\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return ;\r
    }\r
  }\r
\r
  return ;\r
}\r
\r
/**\r
\r
  Driver to produce Smbios measurement. \r
\r
  @param ImageHandle     Module's image handle\r
  @param SystemTable     Pointer of EFI_SYSTEM_TABLE\r
\r
  @retval EFI_SUCCESS    Smbios protocol installed\r
  @retval Other          No protocol installed, unload driver.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmbiosMeasurementDriverEntryPoint (\r
  IN EFI_HANDLE           ImageHandle,\r
  IN EFI_SYSTEM_TABLE     *SystemTable\r
  )\r
{\r
  EFI_STATUS            Status;\r
  EFI_EVENT             Event;\r
\r
  Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **) &mSmbios);\r
  ASSERT_EFI_ERROR (Status);\r
  DEBUG ((DEBUG_INFO, "The Smbios Table Version: %x.%x\n", mSmbios->MajorVersion, mSmbios->MinorVersion));\r
  \r
  if (mSmbios->MajorVersion < 2 || (mSmbios->MajorVersion == 2 && mSmbios->MinorVersion < 7)){\r
    mMaxLen = SMBIOS_STRING_MAX_LENGTH;\r
  } else if (mSmbios->MajorVersion < 3) {\r
    //\r
    // Reference SMBIOS 2.7, chapter 6.1.3, it will have no limit on the length of each individual text string.\r
    // However, the length of the entire structure table (including all strings) must be reported\r
    // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,\r
    // which is a WORD field limited to 65,535 bytes.\r
    //\r
    mMaxLen = SMBIOS_TABLE_MAX_LENGTH;\r
  } else {\r
    //\r
    // SMBIOS 3.0 defines the Structure table maximum size as DWORD field limited to 0xFFFFFFFF bytes.\r
    // Locate the end of string as long as possible.\r
    //\r
    mMaxLen = SMBIOS_3_0_TABLE_MAX_LENGTH;\r
  }\r
\r
  //\r
  // Measure Smbios tables\r
  //\r
  Status = EfiCreateEventReadyToBootEx (\r
             TPL_CALLBACK,\r
             MeasureSmbiosTable,\r
             NULL,\r
             &Event\r
             );\r
\r
  return Status;\r
}\r