MdeModulePkg/Universal/SmbiosMeasurementDxe/SmbiosMeasurementDxe.c

   1 /** @file
   2   This driver measures SMBIOS table to TPM.
   3
   4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <PiDxe.h>
  16
  17 #include <Protocol/Smbios.h>
  18 #include <IndustryStandard/SmBios.h>
  19 #include <IndustryStandard/UefiTcgPlatform.h>
  20 #include <Guid/EventGroup.h>
  21 #include <Guid/SmBios.h>
  22 #include <Library/DebugLib.h>
  23 #include <Library/UefiDriverEntryPoint.h>
  24 #include <Library/UefiLib.h>
  25 #include <Library/BaseLib.h>
  26 #include <Library/BaseMemoryLib.h>
  27 #include <Library/MemoryAllocationLib.h>
  28 #include <Library/UefiBootServicesTableLib.h>
  29 #include <Library/TpmMeasurementLib.h>
  30
  31 #define FIELD_SIZE_OF(TYPE, Field) ((UINTN)sizeof(((TYPE *)0)->Field))
  32
  33 typedef struct {
  34   UINT8  Type;
  35   UINTN  Offset;
  36   UINTN  Size;
  37   UINT32 Flags;
  38 } SMBIOS_FILTER_TABLE;
  39 #define SMBIOS_FILTER_TABLE_FLAG_IS_STRING  BIT0
  40
  41 typedef struct {
  42   UINT8                Type;
  43   SMBIOS_FILTER_TABLE  *Filter; // NULL means all fields
  44   UINTN                FilterCount;
  45 } SMBIOS_FILTER_STRUCT;
  46
  47 //
  48 // Platform Specific Policy
  49 //
  50 SMBIOS_FILTER_TABLE  mSmbiosFilterType1BlackList[] = {
  51   {0x01, OFFSET_OF(SMBIOS_TABLE_TYPE1, SerialNumber),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE1, SerialNumber),         SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  52   {0x01, OFFSET_OF(SMBIOS_TABLE_TYPE1, Uuid),                 FIELD_SIZE_OF(SMBIOS_TABLE_TYPE1, Uuid),                 0},
  53   {0x01, OFFSET_OF(SMBIOS_TABLE_TYPE1, WakeUpType),           FIELD_SIZE_OF(SMBIOS_TABLE_TYPE1, WakeUpType),           0},
  54 };
  55 SMBIOS_FILTER_TABLE  mSmbiosFilterType2BlackList[] = {
  56   {0x02, OFFSET_OF(SMBIOS_TABLE_TYPE2, SerialNumber),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE2, SerialNumber),         SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  57   {0x02, OFFSET_OF(SMBIOS_TABLE_TYPE2, LocationInChassis),    FIELD_SIZE_OF(SMBIOS_TABLE_TYPE2, LocationInChassis),    SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  58 };
  59 SMBIOS_FILTER_TABLE  mSmbiosFilterType3BlackList[] = {
  60   {0x03, OFFSET_OF(SMBIOS_TABLE_TYPE3, SerialNumber),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE3, SerialNumber),         SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  61   {0x03, OFFSET_OF(SMBIOS_TABLE_TYPE3, AssetTag),             FIELD_SIZE_OF(SMBIOS_TABLE_TYPE3, AssetTag),             SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  62 };
  63 SMBIOS_FILTER_TABLE  mSmbiosFilterType4BlackList[] = {
  64   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, SerialNumber),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, SerialNumber),         SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  65   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, AssetTag),             FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, AssetTag),             SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  66   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, PartNumber),           FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, PartNumber),           SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  67   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, CoreCount),            FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, CoreCount),            0},
  68   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, EnabledCoreCount),     FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, EnabledCoreCount),     0},
  69   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, ThreadCount),          FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, ThreadCount),          0},
  70   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, CoreCount2),           FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, CoreCount2),           0},
  71   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, EnabledCoreCount2),    FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, EnabledCoreCount2),    0},
  72   {0x04, OFFSET_OF(SMBIOS_TABLE_TYPE4, ThreadCount2),         FIELD_SIZE_OF(SMBIOS_TABLE_TYPE4, ThreadCount2),         0},
  73 };
  74 SMBIOS_FILTER_TABLE  mSmbiosFilterType17BlackList[] = {
  75   {0x11, OFFSET_OF(SMBIOS_TABLE_TYPE17, SerialNumber),        FIELD_SIZE_OF(SMBIOS_TABLE_TYPE17, SerialNumber),        SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  76   {0x11, OFFSET_OF(SMBIOS_TABLE_TYPE17, AssetTag),            FIELD_SIZE_OF(SMBIOS_TABLE_TYPE17, AssetTag),            SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  77   {0x11, OFFSET_OF(SMBIOS_TABLE_TYPE17, PartNumber),          FIELD_SIZE_OF(SMBIOS_TABLE_TYPE17, PartNumber),          SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  78 };
  79 SMBIOS_FILTER_TABLE  mSmbiosFilterType22BlackList[] = {
  80   {0x16, OFFSET_OF(SMBIOS_TABLE_TYPE22, SerialNumber),        FIELD_SIZE_OF(SMBIOS_TABLE_TYPE22, SerialNumber),        SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  81   {0x16, OFFSET_OF(SMBIOS_TABLE_TYPE22, SBDSSerialNumber),    FIELD_SIZE_OF(SMBIOS_TABLE_TYPE22, SBDSSerialNumber),    0},
  82   {0x16, OFFSET_OF(SMBIOS_TABLE_TYPE22, SBDSManufactureDate), FIELD_SIZE_OF(SMBIOS_TABLE_TYPE22, SBDSManufactureDate), 0},
  83 };
  84 SMBIOS_FILTER_TABLE  mSmbiosFilterType23BlackList[] = {
  85   {0x17, OFFSET_OF(SMBIOS_TABLE_TYPE23, ResetCount),          FIELD_SIZE_OF(SMBIOS_TABLE_TYPE23, ResetCount),          0},
  86 };
  87 SMBIOS_FILTER_TABLE  mSmbiosFilterType39BlackList[] = {
  88   {0x27, OFFSET_OF(SMBIOS_TABLE_TYPE39, SerialNumber),        FIELD_SIZE_OF(SMBIOS_TABLE_TYPE39, SerialNumber),        SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  89   {0x27, OFFSET_OF(SMBIOS_TABLE_TYPE39, AssetTagNumber),      FIELD_SIZE_OF(SMBIOS_TABLE_TYPE39, AssetTagNumber),      SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  90   {0x27, OFFSET_OF(SMBIOS_TABLE_TYPE39, ModelPartNumber),     FIELD_SIZE_OF(SMBIOS_TABLE_TYPE39, ModelPartNumber),     SMBIOS_FILTER_TABLE_FLAG_IS_STRING},
  91 };
  92
  93 SMBIOS_FILTER_STRUCT  mSmbiosFilterStandardTableBlackList[] = {
  94   {0x01, mSmbiosFilterType1BlackList,  sizeof(mSmbiosFilterType1BlackList)/sizeof(mSmbiosFilterType1BlackList[0])},
  95   {0x02, mSmbiosFilterType2BlackList,  sizeof(mSmbiosFilterType2BlackList)/sizeof(mSmbiosFilterType2BlackList[0])},
  96   {0x03, mSmbiosFilterType3BlackList,  sizeof(mSmbiosFilterType3BlackList)/sizeof(mSmbiosFilterType3BlackList[0])},
  97   {0x04, mSmbiosFilterType4BlackList,  sizeof(mSmbiosFilterType4BlackList)/sizeof(mSmbiosFilterType4BlackList[0])},
  98   {0x0B, NULL, 0},
  99   {0x0F, NULL, 0},
 100   {0x11, mSmbiosFilterType17BlackList, sizeof(mSmbiosFilterType17BlackList)/sizeof(mSmbiosFilterType17BlackList[0])},
 101   {0x12, NULL, 0},
 102   {0x16, mSmbiosFilterType22BlackList, sizeof(mSmbiosFilterType22BlackList)/sizeof(mSmbiosFilterType22BlackList[0])},
 103   {0x17, mSmbiosFilterType23BlackList, sizeof(mSmbiosFilterType23BlackList)/sizeof(mSmbiosFilterType23BlackList[0])},
 104   {0x1F, NULL, 0},
 105   {0x21, NULL, 0},
 106   {0x27, mSmbiosFilterType39BlackList, sizeof(mSmbiosFilterType39BlackList)/sizeof(mSmbiosFilterType39BlackList[0])},
 107 };
 108
 109 EFI_SMBIOS_PROTOCOL *mSmbios;
 110 UINTN               mMaxLen;
 111
 112 /**
 113
 114   This function dump raw data.
 115
 116   @param  Data  raw data
 117   @param  Size  raw data size
 118
 119 **/
 120 VOID
 121 InternalDumpData (
 122   IN UINT8  *Data,
 123   IN UINTN  Size
 124   )
 125 {
 126   UINTN  Index;
 127   for (Index = 0; Index < Size; Index++) {
 128     DEBUG ((EFI_D_VERBOSE, "%02x", (UINTN)Data[Index]));
 129   }
 130 }
 131
 132 /**
 133
 134   This function dump raw data with colume format.
 135
 136   @param  Data  raw data
 137   @param  Size  raw data size
 138
 139 **/
 140 VOID
 141 InternalDumpHex (
 142   IN UINT8  *Data,
 143   IN UINTN  Size
 144   )
 145 {
 146   UINTN   Index;
 147   UINTN   Count;
 148   UINTN   Left;
 149
 150 #define COLUME_SIZE  (16 * 2)
 151
 152   Count = Size / COLUME_SIZE;
 153   Left  = Size % COLUME_SIZE;
 154   for (Index = 0; Index < Count; Index++) {
 155     DEBUG ((EFI_D_VERBOSE, "%04x: ", Index * COLUME_SIZE));
 156     InternalDumpData (Data + Index * COLUME_SIZE, COLUME_SIZE);
 157     DEBUG ((EFI_D_VERBOSE, "\n"));
 158   }
 159
 160   if (Left != 0) {
 161     DEBUG ((EFI_D_VERBOSE, "%04x: ", Index * COLUME_SIZE));
 162     InternalDumpData (Data + Index * COLUME_SIZE, Left);
 163     DEBUG ((EFI_D_VERBOSE, "\n"));
 164   }
 165 }
 166
 167
 168 /**
 169
 170   This function get filter structure by SMBIOS type.
 171
 172   @param  Type  SMBIOS type
 173
 174 **/
 175 SMBIOS_FILTER_STRUCT *
 176 GetFilterStructByType (
 177   IN UINT8 Type
 178   )
 179 {
 180   UINTN  Index;
 181   for (Index = 0; Index < sizeof(mSmbiosFilterStandardTableBlackList)/sizeof(mSmbiosFilterStandardTableBlackList[0]); Index++) {
 182     if (mSmbiosFilterStandardTableBlackList[Index].Type == Type) {
 183       return &mSmbiosFilterStandardTableBlackList[Index];
 184     }
 185   }
 186   return NULL;
 187 }
 188
 189 /**
 190
 191   This function get SMBIOS string in SMBIOS table.
 192
 193   @param  Head      SMBIOS table head
 194   @param  StringId  SMBIOS string ID
 195   @param  StringLen length of SMBIOS string
 196
 197   @return SMBIOS string data
 198 **/
 199 CHAR8 *
 200 GetSmbiosStringById (
 201   IN   EFI_SMBIOS_TABLE_HEADER          *Head,
 202   IN   SMBIOS_TABLE_STRING              StringId,
 203   OUT  UINTN                            *StringLen
 204   )
 205 {
 206   UINTN  Size;
 207   UINTN  StrLen;
 208   CHAR8  *CharInStr;
 209   UINTN  StringsNumber;
 210   CHAR8  *String;
 211
 212   CharInStr = (CHAR8 *)Head + Head->Length;
 213   Size = Head->Length;
 214   StringsNumber = 0;
 215   StrLen = 0;
 216   //
 217   // look for the two consecutive zeros, check the string limit by the way.
 218   //
 219   String = NULL;
 220   while (*CharInStr != 0 || *(CharInStr+1) != 0) {
 221     if (*CharInStr == 0) {
 222       Size += 1;
 223       CharInStr++;
 224     }
 225     String = CharInStr;
 226
 227     for (StrLen = 0 ; StrLen < mMaxLen; StrLen++) {
 228       if (*(CharInStr+StrLen) == 0) {
 229         break;
 230       }
 231     }
 232     *StringLen = StrLen;
 233
 234     if (StrLen == mMaxLen) {
 235       return NULL;
 236     }
 237
 238     //
 239     // forward the pointer
 240     //
 241     CharInStr += StrLen;
 242     Size += StrLen;
 243     StringsNumber += 1;
 244     if (StringsNumber == StringId) {
 245       break;
 246     }
 247   }
 248
 249   return String;
 250 }
 251
 252 /**
 253
 254   This function update SMBIOS table based on policy.
 255
 256   @param  TableEntry      SMBIOS table
 257   @param  TableEntrySize  SMBIOS table size
 258
 259 **/
 260 VOID
 261 FilterSmbiosEntry (
 262   IN OUT VOID   *TableEntry,
 263   IN UINTN      TableEntrySize
 264   )
 265 {
 266   SMBIOS_FILTER_STRUCT  *FilterStruct;
 267   SMBIOS_FILTER_TABLE   *Filter;
 268   UINTN                 Index;
 269   SMBIOS_TABLE_STRING   StringId;
 270   CHAR8                 *String;
 271   UINTN                 StringLen;
 272
 273   DEBUG ((EFI_D_INFO, "Smbios Table (Type - %d):\n", ((SMBIOS_STRUCTURE *)TableEntry)->Type));
 274   DEBUG_CODE (InternalDumpHex (TableEntry, TableEntrySize););
 275
 276   FilterStruct = GetFilterStructByType (((SMBIOS_STRUCTURE *)TableEntry)->Type);
 277   if (FilterStruct != NULL) {
 278     if (FilterStruct->Filter == NULL || FilterStruct->FilterCount == 0) {
 279       // zero all table entries, except header
 280       ZeroMem ((UINT8 *)TableEntry + sizeof(SMBIOS_STRUCTURE), TableEntrySize - sizeof(SMBIOS_STRUCTURE));
 281     } else {
 282       Filter = FilterStruct->Filter;
 283       for (Index = 0; Index < FilterStruct->FilterCount; Index++) {
 284         if ((Filter[Index].Flags & SMBIOS_FILTER_TABLE_FLAG_IS_STRING) != 0) {
 285           CopyMem (&StringId, (UINT8 *)TableEntry + Filter[Index].Offset, sizeof(StringId));
 286           if (StringId != 0) {
 287             // set ' ' for string field
 288             String = GetSmbiosStringById (TableEntry, StringId, &StringLen);
 289             ASSERT (String != NULL);
 290             //DEBUG ((EFI_D_INFO,"StrId(0x%x)-%a(%d)\n", StringId, String, StringLen));
 291             SetMem (String, StringLen, ' ');
 292           }
 293         }
 294         // zero non-string field
 295         ZeroMem ((UINT8 *)TableEntry + Filter[Index].Offset, Filter[Index].Size);
 296       }
 297     }
 298   }
 299
 300   DEBUG ((EFI_D_INFO, "Filter Smbios Table (Type - %d):\n", ((SMBIOS_STRUCTURE *)TableEntry)->Type));
 301   DEBUG_CODE (InternalDumpHex (TableEntry, TableEntrySize););
 302 }
 303
 304 /**
 305
 306   Get the full size of SMBIOS structure including optional strings that follow the formatted structure.
 307
 308   @param Head                   Pointer to the beginning of SMBIOS structure.
 309   @param NumberOfStrings        The returned number of optional strings that follow the formatted structure.
 310
 311   @return Size                  The returned size.
 312 **/
 313 UINTN
 314 GetSmbiosStructureSize (
 315   IN   EFI_SMBIOS_TABLE_HEADER          *Head,
 316   OUT  UINTN                            *NumberOfStrings
 317   )
 318 {
 319   UINTN  Size;
 320   UINTN  StrLen;
 321   CHAR8  *CharInStr;
 322   UINTN  StringsNumber;
 323
 324   CharInStr = (CHAR8 *)Head + Head->Length;
 325   Size = Head->Length;
 326   StringsNumber = 0;
 327   StrLen = 0;
 328   //
 329   // look for the two consecutive zeros, check the string limit by the way.
 330   //
 331   while (*CharInStr != 0 || *(CharInStr+1) != 0) {
 332     if (*CharInStr == 0) {
 333       Size += 1;
 334       CharInStr++;
 335     }
 336
 337     for (StrLen = 0 ; StrLen < mMaxLen; StrLen++) {
 338       if (*(CharInStr+StrLen) == 0) {
 339         break;
 340       }
 341     }
 342
 343     if (StrLen == mMaxLen) {
 344       return 0;
 345     }
 346
 347     //
 348     // forward the pointer
 349     //
 350     CharInStr += StrLen;
 351     Size += StrLen;
 352     StringsNumber += 1;
 353   }
 354
 355   //
 356   // count ending two zeros.
 357   //
 358   Size += 2;
 359
 360   if (NumberOfStrings != NULL) {
 361     *NumberOfStrings = StringsNumber;
 362   }
 363   return Size;
 364 }
 365
 366 /**
 367
 368   This function returns full SMBIOS table length.
 369
 370   @param  TableAddress      SMBIOS table based address
 371   @param  TableMaximumSize  Maximum size of SMBIOS table
 372
 373   @return SMBIOS table length
 374
 375 **/
 376 UINTN
 377 GetSmbiosTableLength (
 378   IN VOID  *TableAddress,
 379   IN UINTN TableMaximumSize
 380   )
 381 {
 382   VOID  *TableEntry;
 383   VOID  *TableAddressEnd;
 384   UINTN TableEntryLength;
 385
 386   TableAddressEnd = (VOID *)((UINTN)TableAddress + TableMaximumSize);
 387   TableEntry = TableAddress;
 388   while (TableEntry < TableAddressEnd) {
 389     TableEntryLength = GetSmbiosStructureSize (TableEntry, NULL);
 390     if (TableEntryLength == 0) {
 391       break;
 392     }
 393     if (((SMBIOS_STRUCTURE *)TableEntry)->Type == 127) {
 394       TableEntry = (VOID *)((UINTN)TableEntry + TableEntryLength);
 395       break;
 396     }
 397     TableEntry = (VOID *)((UINTN)TableEntry + TableEntryLength);
 398   }
 399
 400   return ((UINTN)TableEntry - (UINTN)TableAddress);
 401 }
 402
 403 /**
 404
 405   This function updatess full SMBIOS table length.
 406
 407   @param  TableAddress      SMBIOS table based address
 408   @param  TableLength       SMBIOS table length
 409
 410 **/
 411 VOID
 412 FilterSmbiosTable (
 413   IN OUT VOID  *TableAddress,
 414   IN UINTN     TableLength
 415   )
 416 {
 417   VOID   *TableAddressEnd;
 418   VOID   *TableEntry;
 419   UINTN  TableEntryLength;
 420
 421   TableEntry = TableAddress;
 422   TableAddressEnd = (VOID *)((UINTN)TableAddress + TableLength);
 423   while ((UINTN)TableEntry < (UINTN)TableAddressEnd) {
 424     TableEntryLength = GetSmbiosStructureSize (TableEntry, NULL);
 425     if (TableEntryLength == 0) {
 426       break;
 427     }
 428
 429     FilterSmbiosEntry (TableEntry, TableEntryLength);
 430
 431     TableEntry = (VOID *)((UINTN)TableEntry + TableEntryLength);
 432   }
 433 }
 434
 435 /**
 436   Measure SMBIOS with EV_EFI_HANDOFF_TABLES to PCR[1].
 437
 438   @param[in] Event      Event whose notification function is being invoked.
 439   @param[in] Context    Pointer to the notification function's context.
 440
 441 **/
 442 VOID
 443 EFIAPI
 444 MeasureSmbiosTable (
 445   IN      EFI_EVENT                 Event,
 446   IN      VOID                      *Context
 447   )
 448 {
 449   EFI_STATUS                        Status;
 450   EFI_HANDOFF_TABLE_POINTERS        HandoffTables;
 451   SMBIOS_TABLE_ENTRY_POINT          *SmbiosTable;
 452   SMBIOS_TABLE_3_0_ENTRY_POINT      *Smbios3Table;
 453   VOID                              *SmbiosTableAddress;
 454   VOID                              *TableAddress;
 455   UINTN                             TableLength;
 456
 457   SmbiosTable = NULL;
 458   Smbios3Table = NULL;
 459   SmbiosTableAddress = NULL;
 460   TableLength = 0;
 461
 462   if (mSmbios->MajorVersion >= 3) {
 463     Status = EfiGetSystemConfigurationTable (
 464                &gEfiSmbios3TableGuid,
 465                (VOID **) &Smbios3Table
 466                );
 467     if (!EFI_ERROR (Status)) {
 468       DEBUG ((EFI_D_INFO, "Smbios3Table:\n"));
 469       DEBUG ((EFI_D_INFO, "  AnchorString                - '%c%c%c%c%c'\n",
 470         Smbios3Table->AnchorString[0],
 471         Smbios3Table->AnchorString[1],
 472         Smbios3Table->AnchorString[2],
 473         Smbios3Table->AnchorString[3],
 474         Smbios3Table->AnchorString[4]
 475         ));
 476       DEBUG ((EFI_D_INFO, "  EntryPointStructureChecksum - 0x%02x\n", Smbios3Table->EntryPointStructureChecksum));
 477       DEBUG ((EFI_D_INFO, "  EntryPointLength            - 0x%02x\n", Smbios3Table->EntryPointLength));
 478       DEBUG ((EFI_D_INFO, "  MajorVersion                - 0x%02x\n", Smbios3Table->MajorVersion));
 479       DEBUG ((EFI_D_INFO, "  MinorVersion                - 0x%02x\n", Smbios3Table->MinorVersion));
 480       DEBUG ((EFI_D_INFO, "  DocRev                      - 0x%02x\n", Smbios3Table->DocRev));
 481       DEBUG ((EFI_D_INFO, "  EntryPointRevision          - 0x%02x\n", Smbios3Table->EntryPointRevision));
 482       DEBUG ((EFI_D_INFO, "  TableMaximumSize            - 0x%08x\n", Smbios3Table->TableMaximumSize));
 483       DEBUG ((EFI_D_INFO, "  TableAddress                - 0x%016lx\n", Smbios3Table->TableAddress));
 484     }
 485   }
 486
 487   if (Smbios3Table == NULL) {
 488     Status = EfiGetSystemConfigurationTable (
 489                &gEfiSmbiosTableGuid,
 490                (VOID **) &SmbiosTable
 491                );
 492     if (!EFI_ERROR (Status)) {
 493       DEBUG ((EFI_D_INFO, "SmbiosTable:\n"));
 494       DEBUG ((EFI_D_INFO, "  AnchorString                - '%c%c%c%c'\n",
 495         SmbiosTable->AnchorString[0],
 496         SmbiosTable->AnchorString[1],
 497         SmbiosTable->AnchorString[2],
 498         SmbiosTable->AnchorString[3]
 499         ));
 500       DEBUG ((EFI_D_INFO, "  EntryPointStructureChecksum - 0x%02x\n", SmbiosTable->EntryPointStructureChecksum));
 501       DEBUG ((EFI_D_INFO, "  EntryPointLength            - 0x%02x\n", SmbiosTable->EntryPointLength));
 502       DEBUG ((EFI_D_INFO, "  MajorVersion                - 0x%02x\n", SmbiosTable->MajorVersion));
 503       DEBUG ((EFI_D_INFO, "  MinorVersion                - 0x%02x\n", SmbiosTable->MinorVersion));
 504       DEBUG ((EFI_D_INFO, "  MaxStructureSize            - 0x%08x\n", SmbiosTable->MaxStructureSize));
 505       DEBUG ((EFI_D_INFO, "  EntryPointRevision          - 0x%02x\n", SmbiosTable->EntryPointRevision));
 506       DEBUG ((EFI_D_INFO, "  FormattedArea               - '%c%c%c%c%c'\n",
 507         SmbiosTable->FormattedArea[0],
 508         SmbiosTable->FormattedArea[1],
 509         SmbiosTable->FormattedArea[2],
 510         SmbiosTable->FormattedArea[3],
 511         SmbiosTable->FormattedArea[4]
 512         ));
 513       DEBUG ((EFI_D_INFO, "  IntermediateAnchorString    - '%c%c%c%c%c'\n",
 514         SmbiosTable->IntermediateAnchorString[0],
 515         SmbiosTable->IntermediateAnchorString[1],
 516         SmbiosTable->IntermediateAnchorString[2],
 517         SmbiosTable->IntermediateAnchorString[3],
 518         SmbiosTable->IntermediateAnchorString[4]
 519         ));
 520       DEBUG ((EFI_D_INFO, "  IntermediateChecksum        - 0x%02x\n", SmbiosTable->IntermediateChecksum));
 521       DEBUG ((EFI_D_INFO, "  TableLength                 - 0x%04x\n", SmbiosTable->TableLength));
 522       DEBUG ((EFI_D_INFO, "  TableAddress                - 0x%08x\n", SmbiosTable->TableAddress));
 523       DEBUG ((EFI_D_INFO, "  NumberOfSmbiosStructures    - 0x%04x\n", SmbiosTable->NumberOfSmbiosStructures));
 524       DEBUG ((EFI_D_INFO, "  SmbiosBcdRevision           - 0x%02x\n", SmbiosTable->SmbiosBcdRevision));
 525     }
 526   }
 527
 528   if (Smbios3Table != NULL) {
 529     SmbiosTableAddress = (VOID *)(UINTN)Smbios3Table->TableAddress;
 530     TableLength = GetSmbiosTableLength (SmbiosTableAddress, Smbios3Table->TableMaximumSize);
 531   } else if (SmbiosTable != NULL) {
 532     SmbiosTableAddress = (VOID *)(UINTN)SmbiosTable->TableAddress;
 533     TableLength = SmbiosTable->TableLength;
 534   }
 535
 536   if (SmbiosTableAddress != NULL) {
 537     DEBUG ((DEBUG_INFO, "The Smbios Table starts at: 0x%x\n", SmbiosTableAddress));
 538     DEBUG ((DEBUG_INFO, "The Smbios Table size: 0x%x\n", TableLength));
 539     DEBUG_CODE (InternalDumpHex ((UINT8 *)(UINTN)SmbiosTableAddress, TableLength););
 540
 541     TableAddress = AllocateCopyPool ((UINTN)TableLength, (VOID *)(UINTN)SmbiosTableAddress);
 542     if (TableAddress == NULL) {
 543       return ;
 544     }
 545
 546     FilterSmbiosTable (TableAddress, TableLength);
 547
 548     DEBUG ((DEBUG_INFO, "The final Smbios Table starts at: 0x%x\n", TableAddress));
 549     DEBUG ((DEBUG_INFO, "The final Smbios Table size: 0x%x\n", TableLength));
 550     DEBUG_CODE (InternalDumpHex (TableAddress, TableLength););
 551
 552     HandoffTables.NumberOfTables = 1;
 553     if (Smbios3Table != NULL) {
 554       CopyGuid (&(HandoffTables.TableEntry[0].VendorGuid), &gEfiSmbios3TableGuid);
 555       HandoffTables.TableEntry[0].VendorTable = Smbios3Table;
 556     } else {
 557       CopyGuid (&(HandoffTables.TableEntry[0].VendorGuid), &gEfiSmbiosTableGuid);
 558       HandoffTables.TableEntry[0].VendorTable = SmbiosTable;
 559     }
 560     Status = TpmMeasureAndLogData (
 561                1,                       // PCRIndex
 562                EV_EFI_HANDOFF_TABLES,   // EventType
 563                &HandoffTables,          // EventLog
 564                sizeof (HandoffTables),  // LogLen
 565                TableAddress,            // HashData
 566                TableLength              // HashDataLen
 567                );
 568     if (EFI_ERROR (Status)) {
 569       return ;
 570     }
 571   }
 572
 573   return ;
 574 }
 575
 576 /**
 577
 578   Driver to produce Smbios measurement.
 579
 580   @param ImageHandle     Module's image handle
 581   @param SystemTable     Pointer of EFI_SYSTEM_TABLE
 582
 583   @return Status returned from EfiCreateEventReadyToBootEx().
 584
 585 **/
 586 EFI_STATUS
 587 EFIAPI
 588 SmbiosMeasurementDriverEntryPoint (
 589   IN EFI_HANDLE           ImageHandle,
 590   IN EFI_SYSTEM_TABLE     *SystemTable
 591   )
 592 {
 593   EFI_STATUS            Status;
 594   EFI_EVENT             Event;
 595
 596   Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **) &mSmbios);
 597   ASSERT_EFI_ERROR (Status);
 598   DEBUG ((DEBUG_INFO, "The Smbios Table Version: %x.%x\n", mSmbios->MajorVersion, mSmbios->MinorVersion));
 599
 600   if (mSmbios->MajorVersion < 2 || (mSmbios->MajorVersion == 2 && mSmbios->MinorVersion < 7)){
 601     mMaxLen = SMBIOS_STRING_MAX_LENGTH;
 602   } else if (mSmbios->MajorVersion < 3) {
 603     //
 604     // Reference SMBIOS 2.7, chapter 6.1.3, it will have no limit on the length of each individual text string.
 605     // However, the length of the entire structure table (including all strings) must be reported
 606     // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
 607     // which is a WORD field limited to 65,535 bytes.
 608     //
 609     mMaxLen = SMBIOS_TABLE_MAX_LENGTH;
 610   } else {
 611     //
 612     // SMBIOS 3.0 defines the Structure table maximum size as DWORD field limited to 0xFFFFFFFF bytes.
 613     // Locate the end of string as long as possible.
 614     //
 615     mMaxLen = SMBIOS_3_0_TABLE_MAX_LENGTH;
 616   }
 617
 618   //
 619   // Measure Smbios tables
 620   //
 621   Status = EfiCreateEventReadyToBootEx (
 622              TPL_CALLBACK,
 623              MeasureSmbiosTable,
 624              NULL,
 625              &Event
 626              );
 627
 628   return Status;
 629 }