VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Universal/SmbiosMeasurementDxe/SmbiosMeasurementDxe.c@ 77662

Last change on this file since 77662 was 77662, checked in by vboxsync, 6 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette