VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.c@ 98942

最後變更 在這個檔案從98942是 80721,由 vboxsync 提交於 6 年 前

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • 屬性 svn:eol-style 設為 native
檔案大小: 45.8 KB
行 
1/** @file
2 This code produces the Smbios protocol. It also responsible for constructing
3 SMBIOS table into system table.
4
5Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
6SPDX-License-Identifier: BSD-2-Clause-Patent
7
8**/
9
10#include "SmbiosDxe.h"
11
12//
13// Module Global:
14// Since this driver will only ever produce one instance of the
15// protocol you are not required to dynamically allocate the PrivateData.
16//
17SMBIOS_INSTANCE mPrivateData;
18
19UINTN mPreAllocatedPages = 0;
20UINTN mPre64BitAllocatedPages = 0;
21
22//
23// Chassis for SMBIOS entry point structure that is to be installed into EFI system config table.
24//
25SMBIOS_TABLE_ENTRY_POINT *EntryPointStructure = NULL;
26SMBIOS_TABLE_ENTRY_POINT EntryPointStructureData = {
27 //
28 // AnchorString
29 //
30 {
31 0x5f,
32 0x53,
33 0x4d,
34 0x5f
35 },
36 //
37 // EntryPointStructureChecksum,TO BE FILLED
38 //
39 0,
40 //
41 // EntryPointStructure Length
42 //
43 0x1f,
44 //
45 // MajorVersion
46 //
47 0,
48 //
49 // MinorVersion
50 //
51 0,
52 //
53 // MaxStructureSize, TO BE FILLED
54 //
55 0,
56 //
57 // EntryPointRevision
58 //
59 0,
60 //
61 // FormattedArea
62 //
63 {
64 0,
65 0,
66 0,
67 0,
68 0
69 },
70 //
71 // IntermediateAnchorString
72 //
73 {
74 0x5f,
75 0x44,
76 0x4d,
77 0x49,
78 0x5f
79 },
80 //
81 // IntermediateChecksum, TO BE FILLED
82 //
83 0,
84 //
85 // TableLength, TO BE FILLED
86 //
87 0,
88 //
89 // TableAddress, TO BE FILLED
90 //
91 0,
92 //
93 // NumberOfSmbiosStructures, TO BE FILLED
94 //
95 0,
96 //
97 // SmbiosBcdRevision
98 //
99 0
100};
101
102SMBIOS_TABLE_3_0_ENTRY_POINT *Smbios30EntryPointStructure = NULL;
103SMBIOS_TABLE_3_0_ENTRY_POINT Smbios30EntryPointStructureData = {
104 //
105 // AnchorString _SM3_
106 //
107 {
108 0x5f,
109 0x53,
110 0x4d,
111 0x33,
112 0x5f,
113 },
114 //
115 // EntryPointStructureChecksum,TO BE FILLED
116 //
117 0,
118 //
119 // EntryPointLength
120 //
121 0x18,
122 //
123 // MajorVersion
124 //
125 0,
126 //
127 // MinorVersion
128 //
129 0,
130 //
131 // DocRev
132 //
133 0,
134 //
135 // EntryPointRevision
136 //
137 0x01,
138 //
139 // Reserved
140 //
141 0,
142 //
143 // TableMaximumSize,TO BE FILLED
144 //
145 0,
146 //
147 // TableAddress,TO BE FILLED
148 //
149 0
150};
151/**
152
153 Get the full size of SMBIOS structure including optional strings that follow the formatted structure.
154
155 @param This The EFI_SMBIOS_PROTOCOL instance.
156 @param Head Pointer to the beginning of SMBIOS structure.
157 @param Size The returned size.
158 @param NumberOfStrings The returned number of optional strings that follow the formatted structure.
159
160 @retval EFI_SUCCESS Size retured in Size.
161 @retval EFI_INVALID_PARAMETER Input SMBIOS structure mal-formed or Size is NULL.
162
163**/
164EFI_STATUS
165EFIAPI
166GetSmbiosStructureSize (
167 IN CONST EFI_SMBIOS_PROTOCOL *This,
168 IN EFI_SMBIOS_TABLE_HEADER *Head,
169 OUT UINTN *Size,
170 OUT UINTN *NumberOfStrings
171 )
172{
173 UINTN FullSize;
174 UINTN StrLen;
175 UINTN MaxLen;
176 INT8* CharInStr;
177
178 if (Size == NULL || NumberOfStrings == NULL) {
179 return EFI_INVALID_PARAMETER;
180 }
181
182 FullSize = Head->Length;
183 CharInStr = (INT8*)Head + Head->Length;
184 *Size = FullSize;
185 *NumberOfStrings = 0;
186 StrLen = 0;
187 //
188 // look for the two consecutive zeros, check the string limit by the way.
189 //
190 while (*CharInStr != 0 || *(CharInStr+1) != 0) {
191 if (*CharInStr == 0) {
192 *Size += 1;
193 CharInStr++;
194 }
195
196 if (This->MajorVersion < 2 || (This->MajorVersion == 2 && This->MinorVersion < 7)){
197 MaxLen = SMBIOS_STRING_MAX_LENGTH;
198 } else if (This->MajorVersion < 3) {
199 //
200 // Reference SMBIOS 2.7, chapter 6.1.3, it will have no limit on the length of each individual text string.
201 // However, the length of the entire structure table (including all strings) must be reported
202 // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
203 // which is a WORD field limited to 65,535 bytes.
204 //
205 MaxLen = SMBIOS_TABLE_MAX_LENGTH;
206 } else {
207 //
208 // SMBIOS 3.0 defines the Structure table maximum size as DWORD field limited to 0xFFFFFFFF bytes.
209 // Locate the end of string as long as possible.
210 //
211 MaxLen = SMBIOS_3_0_TABLE_MAX_LENGTH;
212 }
213
214 for (StrLen = 0 ; StrLen < MaxLen; StrLen++) {
215 if (*(CharInStr+StrLen) == 0) {
216 break;
217 }
218 }
219
220 if (StrLen == MaxLen) {
221 return EFI_INVALID_PARAMETER;
222 }
223
224 //
225 // forward the pointer
226 //
227 CharInStr += StrLen;
228 *Size += StrLen;
229 *NumberOfStrings += 1;
230 }
231
232 //
233 // count ending two zeros.
234 //
235 *Size += 2;
236 return EFI_SUCCESS;
237}
238
239/**
240
241 Determin whether an SmbiosHandle has already in use.
242
243 @param Head Pointer to the beginning of SMBIOS structure.
244 @param Handle A unique handle will be assigned to the SMBIOS record.
245
246 @retval TRUE Smbios handle already in use.
247 @retval FALSE Smbios handle is NOT used.
248
249**/
250BOOLEAN
251EFIAPI
252CheckSmbiosHandleExistance (
253 IN LIST_ENTRY *Head,
254 IN EFI_SMBIOS_HANDLE Handle
255 )
256{
257 LIST_ENTRY *Link;
258 SMBIOS_HANDLE_ENTRY *HandleEntry;
259
260 for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
261 HandleEntry = SMBIOS_HANDLE_ENTRY_FROM_LINK(Link);
262 if (HandleEntry->SmbiosHandle == Handle) {
263 return TRUE;
264 }
265 }
266
267 return FALSE;
268}
269
270/**
271
272 Get the max SmbiosHandle that could be use.
273
274 @param This The EFI_SMBIOS_PROTOCOL instance.
275 @param MaxHandle The max handle that could be assigned to the SMBIOS record.
276
277**/
278VOID
279EFIAPI
280GetMaxSmbiosHandle (
281 IN CONST EFI_SMBIOS_PROTOCOL *This,
282 IN OUT EFI_SMBIOS_HANDLE *MaxHandle
283 )
284{
285 if (This->MajorVersion == 2 && This->MinorVersion == 0) {
286 *MaxHandle = 0xFFFE;
287 } else {
288 *MaxHandle = 0xFEFF;
289 }
290}
291
292/**
293
294 Get an SmbiosHandle that could use.
295
296 @param This The EFI_SMBIOS_PROTOCOL instance.
297 @param SmbiosHandle A unique handle will be assigned to the SMBIOS record.
298
299 @retval EFI_SUCCESS Smbios handle got.
300 @retval EFI_OUT_OF_RESOURCES Smbios handle is NOT available.
301
302**/
303EFI_STATUS
304EFIAPI
305GetAvailableSmbiosHandle (
306 IN CONST EFI_SMBIOS_PROTOCOL *This,
307 IN OUT EFI_SMBIOS_HANDLE *Handle
308 )
309{
310 LIST_ENTRY *Head;
311 SMBIOS_INSTANCE *Private;
312 EFI_SMBIOS_HANDLE MaxSmbiosHandle;
313 EFI_SMBIOS_HANDLE AvailableHandle;
314
315 GetMaxSmbiosHandle(This, &MaxSmbiosHandle);
316
317 Private = SMBIOS_INSTANCE_FROM_THIS (This);
318 Head = &Private->AllocatedHandleListHead;
319 for (AvailableHandle = 0; AvailableHandle < MaxSmbiosHandle; AvailableHandle++) {
320 if (!CheckSmbiosHandleExistance(Head, AvailableHandle)) {
321 *Handle = AvailableHandle;
322 return EFI_SUCCESS;
323 }
324 }
325
326 return EFI_OUT_OF_RESOURCES;
327}
328
329
330/**
331 Add an SMBIOS record.
332
333 @param This The EFI_SMBIOS_PROTOCOL instance.
334 @param ProducerHandle The handle of the controller or driver associated with the SMBIOS information. NULL
335 means no handle.
336 @param SmbiosHandle On entry, the handle of the SMBIOS record to add. If FFFEh, then a unique handle
337 will be assigned to the SMBIOS record. If the SMBIOS handle is already in use,
338 EFI_ALREADY_STARTED is returned and the SMBIOS record is not updated.
339 @param Record The data for the fixed portion of the SMBIOS record. The format of the record is
340 determined by EFI_SMBIOS_TABLE_HEADER.Type. The size of the formatted area is defined
341 by EFI_SMBIOS_TABLE_HEADER.Length and either followed by a double-null (0x0000) or
342 a set of null terminated strings and a null.
343
344 @retval EFI_SUCCESS Record was added.
345 @retval EFI_OUT_OF_RESOURCES Record was not added due to lack of system resources.
346 @retval EFI_ALREADY_STARTED The SmbiosHandle passed in was already in use.
347
348**/
349EFI_STATUS
350EFIAPI
351SmbiosAdd (
352 IN CONST EFI_SMBIOS_PROTOCOL *This,
353 IN EFI_HANDLE ProducerHandle, OPTIONAL
354 IN OUT EFI_SMBIOS_HANDLE *SmbiosHandle,
355 IN EFI_SMBIOS_TABLE_HEADER *Record
356 )
357{
358 VOID *Raw;
359 UINTN TotalSize;
360 UINTN RecordSize;
361 UINTN StructureSize;
362 UINTN NumberOfStrings;
363 EFI_STATUS Status;
364 LIST_ENTRY *Head;
365 SMBIOS_INSTANCE *Private;
366 EFI_SMBIOS_ENTRY *SmbiosEntry;
367 EFI_SMBIOS_HANDLE MaxSmbiosHandle;
368 SMBIOS_HANDLE_ENTRY *HandleEntry;
369 EFI_SMBIOS_RECORD_HEADER *InternalRecord;
370 BOOLEAN Smbios32BitTable;
371 BOOLEAN Smbios64BitTable;
372
373 if (SmbiosHandle == NULL) {
374 return EFI_INVALID_PARAMETER;
375 }
376
377 Private = SMBIOS_INSTANCE_FROM_THIS (This);
378 //
379 // Check whether SmbiosHandle is already in use
380 //
381 Head = &Private->AllocatedHandleListHead;
382 if (*SmbiosHandle != SMBIOS_HANDLE_PI_RESERVED && CheckSmbiosHandleExistance(Head, *SmbiosHandle)) {
383 return EFI_ALREADY_STARTED;
384 }
385
386 //
387 // when SmbiosHandle is 0xFFFE, an available handle will be assigned
388 //
389 if (*SmbiosHandle == SMBIOS_HANDLE_PI_RESERVED) {
390 Status = GetAvailableSmbiosHandle(This, SmbiosHandle);
391 if (EFI_ERROR(Status)) {
392 return Status;
393 }
394 } else {
395 //
396 // Check this handle validity
397 //
398 GetMaxSmbiosHandle(This, &MaxSmbiosHandle);
399 if (*SmbiosHandle > MaxSmbiosHandle) {
400 return EFI_INVALID_PARAMETER;
401 }
402 }
403
404 //
405 // Calculate record size and string number
406 //
407 Status = GetSmbiosStructureSize(This, Record, &StructureSize, &NumberOfStrings);
408 if (EFI_ERROR(Status)) {
409 return Status;
410 }
411
412 Smbios32BitTable = FALSE;
413 Smbios64BitTable = FALSE;
414 if ((This->MajorVersion < 0x3) ||
415 ((This->MajorVersion >= 0x3) && ((PcdGet32 (PcdSmbiosEntryPointProvideMethod) & BIT0) == BIT0))) {
416 //
417 // For SMBIOS 32-bit table, the length of the entire structure table (including all strings) must be reported
418 // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
419 // which is a WORD field limited to 65,535 bytes. So the max size of 32-bit table should not exceed 65,535 bytes.
420 //
421 if ((EntryPointStructure != NULL) &&
422 (EntryPointStructure->TableLength + StructureSize > SMBIOS_TABLE_MAX_LENGTH)) {
423 DEBUG ((EFI_D_INFO, "SmbiosAdd: Total length exceeds max 32-bit table length with type = %d size = 0x%x\n", Record->Type, StructureSize));
424 } else {
425 Smbios32BitTable = TRUE;
426 DEBUG ((EFI_D_INFO, "SmbiosAdd: Smbios type %d with size 0x%x is added to 32-bit table\n", Record->Type, StructureSize));
427 }
428 }
429
430 //
431 // For SMBIOS 3.0, Structure table maximum size in Entry Point structure is DWORD field limited to 0xFFFFFFFF bytes.
432 //
433 if ((This->MajorVersion >= 0x3) && ((PcdGet32 (PcdSmbiosEntryPointProvideMethod) & BIT1) == BIT1)) {
434 //
435 // For SMBIOS 64-bit table, Structure table maximum size in SMBIOS 3.0 (64-bit) Entry Point
436 // is a DWORD field limited to 0xFFFFFFFF bytes. So the max size of 64-bit table should not exceed 0xFFFFFFFF bytes.
437 //
438 if ((Smbios30EntryPointStructure != NULL) &&
439 (Smbios30EntryPointStructure->TableMaximumSize + StructureSize > SMBIOS_3_0_TABLE_MAX_LENGTH)) {
440 DEBUG ((EFI_D_INFO, "SmbiosAdd: Total length exceeds max 64-bit table length with type = %d size = 0x%x\n", Record->Type, StructureSize));
441 } else {
442 DEBUG ((EFI_D_INFO, "SmbiosAdd: Smbios type %d with size 0x%x is added to 64-bit table\n", Record->Type, StructureSize));
443 Smbios64BitTable = TRUE;
444 }
445 }
446
447 if ((!Smbios32BitTable) && (!Smbios64BitTable)) {
448 //
449 // If both 32-bit and 64-bit table are not updated, quit
450 //
451 return EFI_OUT_OF_RESOURCES;
452 }
453
454 //
455 // Enter into critical section
456 //
457 Status = EfiAcquireLockOrFail (&Private->DataLock);
458 if (EFI_ERROR (Status)) {
459 return Status;
460 }
461
462 RecordSize = sizeof (EFI_SMBIOS_RECORD_HEADER) + StructureSize;
463 TotalSize = sizeof (EFI_SMBIOS_ENTRY) + RecordSize;
464
465 //
466 // Allocate internal buffer
467 //
468 SmbiosEntry = AllocateZeroPool (TotalSize);
469 if (SmbiosEntry == NULL) {
470 EfiReleaseLock (&Private->DataLock);
471 return EFI_OUT_OF_RESOURCES;
472 }
473 HandleEntry = AllocateZeroPool (sizeof(SMBIOS_HANDLE_ENTRY));
474 if (HandleEntry == NULL) {
475 EfiReleaseLock (&Private->DataLock);
476 return EFI_OUT_OF_RESOURCES;
477 }
478
479 //
480 // Build Handle Entry and insert into linked list
481 //
482 HandleEntry->Signature = SMBIOS_HANDLE_ENTRY_SIGNATURE;
483 HandleEntry->SmbiosHandle = *SmbiosHandle;
484 InsertTailList(&Private->AllocatedHandleListHead, &HandleEntry->Link);
485
486 InternalRecord = (EFI_SMBIOS_RECORD_HEADER *) (SmbiosEntry + 1);
487 Raw = (VOID *) (InternalRecord + 1);
488
489 //
490 // Build internal record Header
491 //
492 InternalRecord->Version = EFI_SMBIOS_RECORD_HEADER_VERSION;
493 InternalRecord->HeaderSize = (UINT16) sizeof (EFI_SMBIOS_RECORD_HEADER);
494 InternalRecord->RecordSize = RecordSize;
495 InternalRecord->ProducerHandle = ProducerHandle;
496 InternalRecord->NumberOfStrings = NumberOfStrings;
497 //
498 // Insert record into the internal linked list
499 //
500 SmbiosEntry->Signature = EFI_SMBIOS_ENTRY_SIGNATURE;
501 SmbiosEntry->RecordHeader = InternalRecord;
502 SmbiosEntry->RecordSize = TotalSize;
503 SmbiosEntry->Smbios32BitTable = Smbios32BitTable;
504 SmbiosEntry->Smbios64BitTable = Smbios64BitTable;
505 InsertTailList (&Private->DataListHead, &SmbiosEntry->Link);
506
507 CopyMem (Raw, Record, StructureSize);
508 ((EFI_SMBIOS_TABLE_HEADER*)Raw)->Handle = *SmbiosHandle;
509
510 //
511 // Some UEFI drivers (such as network) need some information in SMBIOS table.
512 // Here we create SMBIOS table and publish it in
513 // configuration table, so other UEFI drivers can get SMBIOS table from
514 // configuration table without depending on PI SMBIOS protocol.
515 //
516 SmbiosTableConstruction (Smbios32BitTable, Smbios64BitTable);
517
518 //
519 // Leave critical section
520 //
521 EfiReleaseLock (&Private->DataLock);
522 return EFI_SUCCESS;
523}
524
525/**
526 Update the string associated with an existing SMBIOS record.
527
528 @param This The EFI_SMBIOS_PROTOCOL instance.
529 @param SmbiosHandle SMBIOS Handle of structure that will have its string updated.
530 @param StringNumber The non-zero string number of the string to update
531 @param String Update the StringNumber string with String.
532
533 @retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated.
534 @retval EFI_INVALID_PARAMETER SmbiosHandle does not exist.
535 @retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports.
536 @retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record.
537
538**/
539EFI_STATUS
540EFIAPI
541SmbiosUpdateString (
542 IN CONST EFI_SMBIOS_PROTOCOL *This,
543 IN EFI_SMBIOS_HANDLE *SmbiosHandle,
544 IN UINTN *StringNumber,
545 IN CHAR8 *String
546 )
547{
548 UINTN InputStrLen;
549 UINTN TargetStrLen;
550 UINTN StrIndex;
551 UINTN TargetStrOffset;
552 UINTN NewEntrySize;
553 CHAR8 *StrStart;
554 VOID *Raw;
555 LIST_ENTRY *Link;
556 LIST_ENTRY *Head;
557 EFI_STATUS Status;
558 SMBIOS_INSTANCE *Private;
559 EFI_SMBIOS_ENTRY *SmbiosEntry;
560 EFI_SMBIOS_ENTRY *ResizedSmbiosEntry;
561 EFI_SMBIOS_HANDLE MaxSmbiosHandle;
562 EFI_SMBIOS_TABLE_HEADER *Record;
563 EFI_SMBIOS_RECORD_HEADER *InternalRecord;
564
565 //
566 // Check args validity
567 //
568 GetMaxSmbiosHandle(This, &MaxSmbiosHandle);
569
570 if (*SmbiosHandle > MaxSmbiosHandle) {
571 return EFI_INVALID_PARAMETER;
572 }
573
574 if (String == NULL) {
575 return EFI_ABORTED;
576 }
577
578 if (*StringNumber == 0) {
579 return EFI_NOT_FOUND;
580 }
581
582 InputStrLen = AsciiStrLen(String);
583
584 if (This->MajorVersion < 2 || (This->MajorVersion == 2 && This->MinorVersion < 7)) {
585 if (InputStrLen > SMBIOS_STRING_MAX_LENGTH) {
586 return EFI_UNSUPPORTED;
587 }
588 } else if (This->MajorVersion < 3) {
589 //
590 // Reference SMBIOS 2.7, chapter 6.1.3, it will have no limit on the length of each individual text string.
591 // However, the length of the entire structure table (including all strings) must be reported
592 // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
593 // which is a WORD field limited to 65,535 bytes.
594 //
595 if (InputStrLen > SMBIOS_TABLE_MAX_LENGTH) {
596 return EFI_UNSUPPORTED;
597 }
598 } else {
599 if (InputStrLen > SMBIOS_3_0_TABLE_MAX_LENGTH) {
600 //
601 // SMBIOS 3.0 defines the Structure table maximum size as DWORD field limited to 0xFFFFFFFF bytes.
602 // The input string length should not exceed 0xFFFFFFFF bytes.
603 //
604 return EFI_UNSUPPORTED;
605 }
606 }
607
608 Private = SMBIOS_INSTANCE_FROM_THIS (This);
609 //
610 // Enter into critical section
611 //
612 Status = EfiAcquireLockOrFail (&Private->DataLock);
613 if (EFI_ERROR (Status)) {
614 return Status;
615 }
616
617 Head = &Private->DataListHead;
618 for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
619 SmbiosEntry = SMBIOS_ENTRY_FROM_LINK(Link);
620 Record = (EFI_SMBIOS_TABLE_HEADER*)(SmbiosEntry->RecordHeader + 1);
621
622 if (Record->Handle == *SmbiosHandle) {
623 //
624 // Find out the specified SMBIOS record
625 //
626 if (*StringNumber > SmbiosEntry->RecordHeader->NumberOfStrings) {
627 EfiReleaseLock (&Private->DataLock);
628 return EFI_NOT_FOUND;
629 }
630 //
631 // Point to unformed string section
632 //
633 StrStart = (CHAR8 *) Record + Record->Length;
634
635 for (StrIndex = 1, TargetStrOffset = 0; StrIndex < *StringNumber; StrStart++, TargetStrOffset++) {
636 //
637 // A string ends in 00h
638 //
639 if (*StrStart == 0) {
640 StrIndex++;
641 }
642
643 //
644 // String section ends in double-null (0000h)
645 //
646 if (*StrStart == 0 && *(StrStart + 1) == 0) {
647 EfiReleaseLock (&Private->DataLock);
648 return EFI_NOT_FOUND;
649 }
650 }
651
652 if (*StrStart == 0) {
653 StrStart++;
654 TargetStrOffset++;
655 }
656
657 //
658 // Now we get the string target
659 //
660 TargetStrLen = AsciiStrLen(StrStart);
661 if (InputStrLen == TargetStrLen) {
662 AsciiStrCpyS(StrStart, TargetStrLen + 1, String);
663 //
664 // Some UEFI drivers (such as network) need some information in SMBIOS table.
665 // Here we create SMBIOS table and publish it in
666 // configuration table, so other UEFI drivers can get SMBIOS table from
667 // configuration table without depending on PI SMBIOS protocol.
668 //
669 SmbiosTableConstruction (SmbiosEntry->Smbios32BitTable, SmbiosEntry->Smbios64BitTable);
670 EfiReleaseLock (&Private->DataLock);
671 return EFI_SUCCESS;
672 }
673
674 SmbiosEntry->Smbios32BitTable = FALSE;
675 SmbiosEntry->Smbios64BitTable = FALSE;
676 if ((This->MajorVersion < 0x3) ||
677 ((This->MajorVersion >= 0x3) && ((PcdGet32 (PcdSmbiosEntryPointProvideMethod) & BIT0) == BIT0))) {
678 //
679 // 32-bit table is produced, check the valid length.
680 //
681 if ((EntryPointStructure != NULL) &&
682 (EntryPointStructure->TableLength + InputStrLen - TargetStrLen > SMBIOS_TABLE_MAX_LENGTH)) {
683 //
684 // The length of the entire structure table (including all strings) must be reported
685 // in the Structure Table Length field of the SMBIOS Structure Table Entry Point,
686 // which is a WORD field limited to 65,535 bytes.
687 //
688 DEBUG ((EFI_D_INFO, "SmbiosUpdateString: Total length exceeds max 32-bit table length\n"));
689 } else {
690 DEBUG ((EFI_D_INFO, "SmbiosUpdateString: New smbios record add to 32-bit table\n"));
691 SmbiosEntry->Smbios32BitTable = TRUE;
692 }
693 }
694
695 if ((This->MajorVersion >= 0x3) && ((PcdGet32 (PcdSmbiosEntryPointProvideMethod) & BIT1) == BIT1)) {
696 //
697 // 64-bit table is produced, check the valid length.
698 //
699 if ((Smbios30EntryPointStructure != NULL) &&
700 (Smbios30EntryPointStructure->TableMaximumSize + InputStrLen - TargetStrLen > SMBIOS_3_0_TABLE_MAX_LENGTH)) {
701 DEBUG ((EFI_D_INFO, "SmbiosUpdateString: Total length exceeds max 64-bit table length\n"));
702 } else {
703 DEBUG ((EFI_D_INFO, "SmbiosUpdateString: New smbios record add to 64-bit table\n"));
704 SmbiosEntry->Smbios64BitTable = TRUE;
705 }
706 }
707
708 if ((!SmbiosEntry->Smbios32BitTable) && (!SmbiosEntry->Smbios64BitTable)) {
709 EfiReleaseLock (&Private->DataLock);
710 return EFI_UNSUPPORTED;
711 }
712
713 //
714 // Original string buffer size is not exactly match input string length.
715 // Re-allocate buffer is needed.
716 //
717 NewEntrySize = SmbiosEntry->RecordSize + InputStrLen - TargetStrLen;
718 ResizedSmbiosEntry = AllocateZeroPool (NewEntrySize);
719
720 if (ResizedSmbiosEntry == NULL) {
721 EfiReleaseLock (&Private->DataLock);
722 return EFI_OUT_OF_RESOURCES;
723 }
724
725 InternalRecord = (EFI_SMBIOS_RECORD_HEADER *) (ResizedSmbiosEntry + 1);
726 Raw = (VOID *) (InternalRecord + 1);
727
728 //
729 // Build internal record Header
730 //
731 InternalRecord->Version = EFI_SMBIOS_RECORD_HEADER_VERSION;
732 InternalRecord->HeaderSize = (UINT16) sizeof (EFI_SMBIOS_RECORD_HEADER);
733 InternalRecord->RecordSize = SmbiosEntry->RecordHeader->RecordSize + InputStrLen - TargetStrLen;
734 InternalRecord->ProducerHandle = SmbiosEntry->RecordHeader->ProducerHandle;
735 InternalRecord->NumberOfStrings = SmbiosEntry->RecordHeader->NumberOfStrings;
736
737 //
738 // Copy SMBIOS structure and optional strings.
739 //
740 CopyMem (Raw, SmbiosEntry->RecordHeader + 1, Record->Length + TargetStrOffset);
741 CopyMem ((VOID*)((UINTN)Raw + Record->Length + TargetStrOffset), String, InputStrLen + 1);
742 CopyMem ((CHAR8*)((UINTN)Raw + Record->Length + TargetStrOffset + InputStrLen + 1),
743 (CHAR8*)Record + Record->Length + TargetStrOffset + TargetStrLen + 1,
744 SmbiosEntry->RecordHeader->RecordSize - sizeof (EFI_SMBIOS_RECORD_HEADER) - Record->Length - TargetStrOffset - TargetStrLen - 1);
745
746 //
747 // Insert new record
748 //
749 ResizedSmbiosEntry->Signature = EFI_SMBIOS_ENTRY_SIGNATURE;
750 ResizedSmbiosEntry->RecordHeader = InternalRecord;
751 ResizedSmbiosEntry->RecordSize = NewEntrySize;
752 ResizedSmbiosEntry->Smbios32BitTable = SmbiosEntry->Smbios32BitTable;
753 ResizedSmbiosEntry->Smbios64BitTable = SmbiosEntry->Smbios64BitTable;
754 InsertTailList (Link->ForwardLink, &ResizedSmbiosEntry->Link);
755
756 //
757 // Remove old record
758 //
759 RemoveEntryList(Link);
760 FreePool(SmbiosEntry);
761 //
762 // Some UEFI drivers (such as network) need some information in SMBIOS table.
763 // Here we create SMBIOS table and publish it in
764 // configuration table, so other UEFI drivers can get SMBIOS table from
765 // configuration table without depending on PI SMBIOS protocol.
766 //
767 SmbiosTableConstruction (ResizedSmbiosEntry->Smbios32BitTable, ResizedSmbiosEntry->Smbios64BitTable);
768 EfiReleaseLock (&Private->DataLock);
769 return EFI_SUCCESS;
770 }
771 }
772
773 EfiReleaseLock (&Private->DataLock);
774 return EFI_INVALID_PARAMETER;
775}
776
777/**
778 Remove an SMBIOS record.
779
780 @param This The EFI_SMBIOS_PROTOCOL instance.
781 @param SmbiosHandle The handle of the SMBIOS record to remove.
782
783 @retval EFI_SUCCESS SMBIOS record was removed.
784 @retval EFI_INVALID_PARAMETER SmbiosHandle does not specify a valid SMBIOS record.
785
786**/
787EFI_STATUS
788EFIAPI
789SmbiosRemove (
790 IN CONST EFI_SMBIOS_PROTOCOL *This,
791 IN EFI_SMBIOS_HANDLE SmbiosHandle
792 )
793{
794 LIST_ENTRY *Link;
795 LIST_ENTRY *Head;
796 EFI_STATUS Status;
797 EFI_SMBIOS_HANDLE MaxSmbiosHandle;
798 SMBIOS_INSTANCE *Private;
799 EFI_SMBIOS_ENTRY *SmbiosEntry;
800 SMBIOS_HANDLE_ENTRY *HandleEntry;
801 EFI_SMBIOS_TABLE_HEADER *Record;
802
803 //
804 // Check args validity
805 //
806 GetMaxSmbiosHandle(This, &MaxSmbiosHandle);
807
808 if (SmbiosHandle > MaxSmbiosHandle) {
809 return EFI_INVALID_PARAMETER;
810 }
811
812 Private = SMBIOS_INSTANCE_FROM_THIS (This);
813 //
814 // Enter into critical section
815 //
816 Status = EfiAcquireLockOrFail (&Private->DataLock);
817 if (EFI_ERROR (Status)) {
818 return Status;
819 }
820
821 Head = &Private->DataListHead;
822 for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
823 SmbiosEntry = SMBIOS_ENTRY_FROM_LINK(Link);
824 Record = (EFI_SMBIOS_TABLE_HEADER*)(SmbiosEntry->RecordHeader + 1);
825 if (Record->Handle == SmbiosHandle) {
826 //
827 // Remove specified smobios record from DataList
828 //
829 RemoveEntryList(Link);
830 //
831 // Remove this handle from AllocatedHandleList
832 //
833 Head = &Private->AllocatedHandleListHead;
834 for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
835 HandleEntry = SMBIOS_HANDLE_ENTRY_FROM_LINK(Link);
836 if (HandleEntry->SmbiosHandle == SmbiosHandle) {
837 RemoveEntryList(Link);
838 FreePool(HandleEntry);
839 break;
840 }
841 }
842 //
843 // Some UEFI drivers (such as network) need some information in SMBIOS table.
844 // Here we create SMBIOS table and publish it in
845 // configuration table, so other UEFI drivers can get SMBIOS table from
846 // configuration table without depending on PI SMBIOS protocol.
847 //
848 if (SmbiosEntry->Smbios32BitTable) {
849 DEBUG ((EFI_D_INFO, "SmbiosRemove: remove from 32-bit table\n"));
850 }
851 if (SmbiosEntry->Smbios64BitTable) {
852 DEBUG ((EFI_D_INFO, "SmbiosRemove: remove from 64-bit table\n"));
853 }
854 //
855 // Update the whole SMBIOS table again based on which table the removed SMBIOS record is in.
856 //
857 SmbiosTableConstruction (SmbiosEntry->Smbios32BitTable, SmbiosEntry->Smbios64BitTable);
858 FreePool(SmbiosEntry);
859 EfiReleaseLock (&Private->DataLock);
860 return EFI_SUCCESS;
861 }
862 }
863
864 //
865 // Leave critical section
866 //
867 EfiReleaseLock (&Private->DataLock);
868 return EFI_INVALID_PARAMETER;
869
870}
871
872/**
873 Allow the caller to discover all or some of the SMBIOS records.
874
875 @param This The EFI_SMBIOS_PROTOCOL instance.
876 @param SmbiosHandle On entry, points to the previous handle of the SMBIOS record. On exit, points to the
877 next SMBIOS record handle. If it is FFFEh on entry, then the first SMBIOS record
878 handle will be returned. If it returns FFFEh on exit, then there are no more SMBIOS records.
879 @param Type On entry it means return the next SMBIOS record of type Type. If a NULL is passed in
880 this functionally it ignored. Type is not modified by the GetNext() function.
881 @param Record On exit, points to the SMBIOS Record consisting of the formatted area followed by
882 the unformatted area. The unformatted area optionally contains text strings.
883 @param ProducerHandle On exit, points to the ProducerHandle registered by Add(). If no ProducerHandle was passed into Add() NULL is returned.
884 If a NULL pointer is passed in no data will be returned
885
886 @retval EFI_SUCCESS SMBIOS record information was successfully returned in Record.
887 @retval EFI_NOT_FOUND The SMBIOS record with SmbiosHandle was the last available record.
888
889**/
890EFI_STATUS
891EFIAPI
892SmbiosGetNext (
893 IN CONST EFI_SMBIOS_PROTOCOL *This,
894 IN OUT EFI_SMBIOS_HANDLE *SmbiosHandle,
895 IN EFI_SMBIOS_TYPE *Type, OPTIONAL
896 OUT EFI_SMBIOS_TABLE_HEADER **Record,
897 OUT EFI_HANDLE *ProducerHandle OPTIONAL
898 )
899{
900 BOOLEAN StartPointFound;
901 LIST_ENTRY *Link;
902 LIST_ENTRY *Head;
903 SMBIOS_INSTANCE *Private;
904 EFI_SMBIOS_ENTRY *SmbiosEntry;
905 EFI_SMBIOS_TABLE_HEADER *SmbiosTableHeader;
906
907 if (SmbiosHandle == NULL) {
908 return EFI_INVALID_PARAMETER;
909 }
910
911 StartPointFound = FALSE;
912 Private = SMBIOS_INSTANCE_FROM_THIS (This);
913 Head = &Private->DataListHead;
914 for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {
915 SmbiosEntry = SMBIOS_ENTRY_FROM_LINK(Link);
916 SmbiosTableHeader = (EFI_SMBIOS_TABLE_HEADER*)(SmbiosEntry->RecordHeader + 1);
917
918 //
919 // If SmbiosHandle is 0xFFFE, the first matched SMBIOS record handle will be returned
920 //
921 if (*SmbiosHandle == SMBIOS_HANDLE_PI_RESERVED) {
922 if ((Type != NULL) && (*Type != SmbiosTableHeader->Type)) {
923 continue;
924 }
925
926 *SmbiosHandle = SmbiosTableHeader->Handle;
927 *Record =SmbiosTableHeader;
928 if (ProducerHandle != NULL) {
929 *ProducerHandle = SmbiosEntry->RecordHeader->ProducerHandle;
930 }
931 return EFI_SUCCESS;
932 }
933
934 //
935 // Start this round search from the next SMBIOS handle
936 //
937 if (!StartPointFound && (*SmbiosHandle == SmbiosTableHeader->Handle)) {
938 StartPointFound = TRUE;
939 continue;
940 }
941
942 if (StartPointFound) {
943 if ((Type != NULL) && (*Type != SmbiosTableHeader->Type)) {
944 continue;
945 }
946
947 *SmbiosHandle = SmbiosTableHeader->Handle;
948 *Record = SmbiosTableHeader;
949 if (ProducerHandle != NULL) {
950 *ProducerHandle = SmbiosEntry->RecordHeader->ProducerHandle;
951 }
952
953 return EFI_SUCCESS;
954 }
955 }
956
957 *SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
958 return EFI_NOT_FOUND;
959
960}
961
962/**
963 Allow the caller to discover all of the SMBIOS records.
964
965 @param This The EFI_SMBIOS_PROTOCOL instance.
966 @param CurrentSmbiosEntry On exit, points to the SMBIOS entry on the list which includes the returned SMBIOS record information.
967 If *CurrentSmbiosEntry is NULL on entry, then the first SMBIOS entry on the list will be returned.
968 @param Record On exit, points to the SMBIOS Record consisting of the formatted area followed by
969 the unformatted area. The unformatted area optionally contains text strings.
970
971 @retval EFI_SUCCESS SMBIOS record information was successfully returned in Record.
972 *CurrentSmbiosEntry points to the SMBIOS entry which includes the returned SMBIOS record information.
973 @retval EFI_NOT_FOUND There is no more SMBIOS entry.
974
975**/
976EFI_STATUS
977EFIAPI
978GetNextSmbiosRecord (
979 IN CONST EFI_SMBIOS_PROTOCOL *This,
980 IN OUT EFI_SMBIOS_ENTRY **CurrentSmbiosEntry,
981 OUT EFI_SMBIOS_TABLE_HEADER **Record
982 )
983{
984 LIST_ENTRY *Link;
985 LIST_ENTRY *Head;
986 SMBIOS_INSTANCE *Private;
987 EFI_SMBIOS_ENTRY *SmbiosEntry;
988 EFI_SMBIOS_TABLE_HEADER *SmbiosTableHeader;
989
990 Private = SMBIOS_INSTANCE_FROM_THIS (This);
991 if (*CurrentSmbiosEntry == NULL) {
992 //
993 // Get the beginning of SMBIOS entry.
994 //
995 Head = &Private->DataListHead;
996 } else {
997 //
998 // Get previous SMBIOS entry and make it as start point.
999 //
1000 Head = &(*CurrentSmbiosEntry)->Link;
1001 }
1002
1003 Link = Head->ForwardLink;
1004
1005 if (Link == &Private->DataListHead) {
1006 //
1007 // If no more SMBIOS entry in the list, return not found.
1008 //
1009 return EFI_NOT_FOUND;
1010 }
1011
1012 SmbiosEntry = SMBIOS_ENTRY_FROM_LINK(Link);
1013 SmbiosTableHeader = (EFI_SMBIOS_TABLE_HEADER*)(SmbiosEntry->RecordHeader + 1);
1014 *Record = SmbiosTableHeader;
1015 *CurrentSmbiosEntry = SmbiosEntry;
1016 return EFI_SUCCESS;
1017}
1018
1019/**
1020 Assembles SMBIOS table from the SMBIOS protocol. Produce Table
1021 Entry Point and return the pointer to it.
1022
1023 @param TableEntryPointStructure On exit, points to the SMBIOS entrypoint structure.
1024
1025 @retval EFI_SUCCESS Structure created sucessfully.
1026 @retval EFI_OUT_OF_RESOURCES No enough memory.
1027
1028**/
1029EFI_STATUS
1030EFIAPI
1031SmbiosCreateTable (
1032 OUT VOID **TableEntryPointStructure
1033 )
1034{
1035 UINT8 *BufferPointer;
1036 UINTN RecordSize;
1037 UINTN NumOfStr;
1038 EFI_STATUS Status;
1039 EFI_SMBIOS_HANDLE SmbiosHandle;
1040 EFI_SMBIOS_PROTOCOL *SmbiosProtocol;
1041 EFI_PHYSICAL_ADDRESS PhysicalAddress;
1042 EFI_SMBIOS_TABLE_HEADER *SmbiosRecord;
1043 EFI_SMBIOS_TABLE_END_STRUCTURE EndStructure;
1044 EFI_SMBIOS_ENTRY *CurrentSmbiosEntry;
1045
1046 Status = EFI_SUCCESS;
1047 BufferPointer = NULL;
1048
1049 if (EntryPointStructure == NULL) {
1050 //
1051 // Initialize the EntryPointStructure with initial values.
1052 // It should be done only once.
1053 // Allocate memory (below 4GB).
1054 //
1055 DEBUG ((EFI_D_INFO, "SmbiosCreateTable: Initialize 32-bit entry point structure\n"));
1056 EntryPointStructureData.MajorVersion = mPrivateData.Smbios.MajorVersion;
1057 EntryPointStructureData.MinorVersion = mPrivateData.Smbios.MinorVersion;
1058 EntryPointStructureData.SmbiosBcdRevision = (UINT8) ((PcdGet16 (PcdSmbiosVersion) >> 4) & 0xf0) | (UINT8) (PcdGet16 (PcdSmbiosVersion) & 0x0f);
1059 PhysicalAddress = 0xffffffff;
1060 Status = gBS->AllocatePages (
1061 AllocateMaxAddress,
1062 EfiRuntimeServicesData,
1063 EFI_SIZE_TO_PAGES (sizeof (SMBIOS_TABLE_ENTRY_POINT)),
1064 &PhysicalAddress
1065 );
1066 if (EFI_ERROR (Status)) {
1067 DEBUG ((EFI_D_ERROR, "SmbiosCreateTable () could not allocate EntryPointStructure < 4GB\n"));
1068 Status = gBS->AllocatePages (
1069 AllocateAnyPages,
1070 EfiRuntimeServicesData,
1071 EFI_SIZE_TO_PAGES (sizeof (SMBIOS_TABLE_ENTRY_POINT)),
1072 &PhysicalAddress
1073 );
1074 if (EFI_ERROR (Status)) {
1075 return EFI_OUT_OF_RESOURCES;
1076 }
1077 }
1078
1079 EntryPointStructure = (SMBIOS_TABLE_ENTRY_POINT *) (UINTN) PhysicalAddress;
1080
1081 CopyMem (
1082 EntryPointStructure,
1083 &EntryPointStructureData,
1084 sizeof (SMBIOS_TABLE_ENTRY_POINT)
1085 );
1086 }
1087
1088 //
1089 // Get Smbios protocol to traverse SMBIOS records.
1090 //
1091 SmbiosProtocol = &mPrivateData.Smbios;
1092
1093 //
1094 // Make some statistics about all the structures
1095 //
1096 EntryPointStructure->NumberOfSmbiosStructures = 0;
1097 EntryPointStructure->TableLength = 0;
1098 EntryPointStructure->MaxStructureSize = 0;
1099
1100 //
1101 // Calculate EPS Table Length
1102 //
1103 CurrentSmbiosEntry = NULL;
1104 do {
1105 Status = GetNextSmbiosRecord (SmbiosProtocol, &CurrentSmbiosEntry, &SmbiosRecord);
1106
1107 if ((Status == EFI_SUCCESS) && (CurrentSmbiosEntry->Smbios32BitTable)) {
1108 GetSmbiosStructureSize(SmbiosProtocol, SmbiosRecord, &RecordSize, &NumOfStr);
1109 //
1110 // Record NumberOfSmbiosStructures, TableLength and MaxStructureSize
1111 //
1112 EntryPointStructure->NumberOfSmbiosStructures++;
1113 EntryPointStructure->TableLength = (UINT16) (EntryPointStructure->TableLength + RecordSize);
1114 if (RecordSize > EntryPointStructure->MaxStructureSize) {
1115 EntryPointStructure->MaxStructureSize = (UINT16) RecordSize;
1116 }
1117 }
1118 } while (!EFI_ERROR(Status));
1119
1120 //
1121 // Create End-Of-Table structure
1122 //
1123 GetMaxSmbiosHandle(SmbiosProtocol, &SmbiosHandle);
1124 EndStructure.Header.Type = SMBIOS_TYPE_END_OF_TABLE;
1125 EndStructure.Header.Length = (UINT8) sizeof (EFI_SMBIOS_TABLE_HEADER);
1126 EndStructure.Header.Handle = SmbiosHandle;
1127 EndStructure.Tailing[0] = 0;
1128 EndStructure.Tailing[1] = 0;
1129 EntryPointStructure->NumberOfSmbiosStructures++;
1130 EntryPointStructure->TableLength = (UINT16) (EntryPointStructure->TableLength + sizeof (EndStructure));
1131 if (sizeof (EndStructure) > EntryPointStructure->MaxStructureSize) {
1132 EntryPointStructure->MaxStructureSize = (UINT16) sizeof (EndStructure);
1133 }
1134
1135 if (EFI_SIZE_TO_PAGES ((UINT32) EntryPointStructure->TableLength) > mPreAllocatedPages) {
1136 //
1137 // If new SMBIOS table size exceeds the previous allocated page,
1138 // it is time to re-allocate memory (below 4GB).
1139 //
1140 DEBUG ((EFI_D_INFO, "%a() re-allocate SMBIOS 32-bit table\n",
1141 __FUNCTION__));
1142 if (EntryPointStructure->TableAddress != 0) {
1143 //
1144 // Free the previous allocated page
1145 //
1146 FreePages (
1147 (VOID*)(UINTN)EntryPointStructure->TableAddress,
1148 mPreAllocatedPages
1149 );
1150 EntryPointStructure->TableAddress = 0;
1151 mPreAllocatedPages = 0;
1152 }
1153
1154 PhysicalAddress = 0xffffffff;
1155 Status = gBS->AllocatePages (
1156 AllocateMaxAddress,
1157 EfiRuntimeServicesData,
1158 EFI_SIZE_TO_PAGES (EntryPointStructure->TableLength),
1159 &PhysicalAddress
1160 );
1161 if (EFI_ERROR (Status)) {
1162 DEBUG ((EFI_D_ERROR, "SmbiosCreateTable() could not allocate SMBIOS table < 4GB\n"));
1163 EntryPointStructure->TableAddress = 0;
1164 return EFI_OUT_OF_RESOURCES;
1165 } else {
1166 EntryPointStructure->TableAddress = (UINT32) PhysicalAddress;
1167 mPreAllocatedPages = EFI_SIZE_TO_PAGES (EntryPointStructure->TableLength);
1168 }
1169 }
1170
1171 //
1172 // Assemble the tables
1173 //
1174 ASSERT (EntryPointStructure->TableAddress != 0);
1175 BufferPointer = (UINT8 *) (UINTN) EntryPointStructure->TableAddress;
1176 CurrentSmbiosEntry = NULL;
1177 do {
1178 Status = GetNextSmbiosRecord (SmbiosProtocol, &CurrentSmbiosEntry, &SmbiosRecord);
1179
1180 if ((Status == EFI_SUCCESS) && (CurrentSmbiosEntry->Smbios32BitTable)) {
1181 GetSmbiosStructureSize(SmbiosProtocol, SmbiosRecord, &RecordSize, &NumOfStr);
1182 CopyMem (BufferPointer, SmbiosRecord, RecordSize);
1183 BufferPointer = BufferPointer + RecordSize;
1184 }
1185 } while (!EFI_ERROR(Status));
1186
1187 //
1188 // Assemble End-Of-Table structure
1189 //
1190 CopyMem (BufferPointer, &EndStructure, sizeof (EndStructure));
1191
1192 //
1193 // Fixup checksums in the Entry Point Structure
1194 //
1195 EntryPointStructure->IntermediateChecksum = 0;
1196 EntryPointStructure->EntryPointStructureChecksum = 0;
1197
1198 EntryPointStructure->IntermediateChecksum =
1199 CalculateCheckSum8 ((UINT8 *) EntryPointStructure + 0x10, EntryPointStructure->EntryPointLength - 0x10);
1200 EntryPointStructure->EntryPointStructureChecksum =
1201 CalculateCheckSum8 ((UINT8 *) EntryPointStructure, EntryPointStructure->EntryPointLength);
1202
1203 //
1204 // Returns the pointer
1205 //
1206 *TableEntryPointStructure = EntryPointStructure;
1207
1208 return EFI_SUCCESS;
1209}
1210
1211/**
1212 Assembles SMBIOS 64-bit table from the SMBIOS protocol. Produce Table
1213 Entry Point and return the pointer to it.
1214
1215 @param TableEntryPointStructure On exit, points to the SMBIOS entrypoint structure.
1216
1217 @retval EFI_SUCCESS Structure created sucessfully.
1218 @retval EFI_OUT_OF_RESOURCES No enough memory.
1219
1220**/
1221EFI_STATUS
1222EFIAPI
1223SmbiosCreate64BitTable (
1224 OUT VOID **TableEntryPointStructure
1225 )
1226{
1227 UINT8 *BufferPointer;
1228 UINTN RecordSize;
1229 UINTN NumOfStr;
1230 EFI_STATUS Status;
1231 EFI_SMBIOS_HANDLE SmbiosHandle;
1232 EFI_SMBIOS_PROTOCOL *SmbiosProtocol;
1233 EFI_PHYSICAL_ADDRESS PhysicalAddress;
1234 EFI_SMBIOS_TABLE_HEADER *SmbiosRecord;
1235 EFI_SMBIOS_TABLE_END_STRUCTURE EndStructure;
1236 EFI_SMBIOS_ENTRY *CurrentSmbiosEntry;
1237
1238 Status = EFI_SUCCESS;
1239 BufferPointer = NULL;
1240
1241 if (Smbios30EntryPointStructure == NULL) {
1242 //
1243 // Initialize the Smbios30EntryPointStructure with initial values.
1244 // It should be done only once.
1245 // Allocate memory at any address.
1246 //
1247 DEBUG ((EFI_D_INFO, "SmbiosCreateTable: Initialize 64-bit entry point structure\n"));
1248 Smbios30EntryPointStructureData.MajorVersion = mPrivateData.Smbios.MajorVersion;
1249 Smbios30EntryPointStructureData.MinorVersion = mPrivateData.Smbios.MinorVersion;
1250 Smbios30EntryPointStructureData.DocRev = PcdGet8 (PcdSmbiosDocRev);
1251 Status = gBS->AllocatePages (
1252 AllocateAnyPages,
1253 EfiRuntimeServicesData,
1254 EFI_SIZE_TO_PAGES (sizeof (SMBIOS_TABLE_3_0_ENTRY_POINT)),
1255 &PhysicalAddress
1256 );
1257 if (EFI_ERROR (Status)) {
1258 DEBUG ((EFI_D_ERROR, "SmbiosCreate64BitTable() could not allocate Smbios30EntryPointStructure\n"));
1259 return EFI_OUT_OF_RESOURCES;
1260 }
1261
1262 Smbios30EntryPointStructure = (SMBIOS_TABLE_3_0_ENTRY_POINT *) (UINTN) PhysicalAddress;
1263
1264 CopyMem (
1265 Smbios30EntryPointStructure,
1266 &Smbios30EntryPointStructureData,
1267 sizeof (SMBIOS_TABLE_3_0_ENTRY_POINT)
1268 );
1269 }
1270
1271 //
1272 // Get Smbios protocol to traverse SMBIOS records.
1273 //
1274 SmbiosProtocol = &mPrivateData.Smbios;
1275 Smbios30EntryPointStructure->TableMaximumSize = 0;
1276
1277 //
1278 // Calculate EPS Table Length
1279 //
1280 CurrentSmbiosEntry = NULL;
1281 do {
1282 Status = GetNextSmbiosRecord (SmbiosProtocol, &CurrentSmbiosEntry, &SmbiosRecord);
1283
1284 if ((Status == EFI_SUCCESS) && (CurrentSmbiosEntry->Smbios64BitTable)) {
1285 GetSmbiosStructureSize(SmbiosProtocol, SmbiosRecord, &RecordSize, &NumOfStr);
1286 //
1287 // Record TableMaximumSize
1288 //
1289 Smbios30EntryPointStructure->TableMaximumSize = (UINT32) (Smbios30EntryPointStructure->TableMaximumSize + RecordSize);
1290 }
1291 } while (!EFI_ERROR(Status));
1292
1293 //
1294 // Create End-Of-Table structure
1295 //
1296 GetMaxSmbiosHandle(SmbiosProtocol, &SmbiosHandle);
1297 EndStructure.Header.Type = SMBIOS_TYPE_END_OF_TABLE;
1298 EndStructure.Header.Length = (UINT8) sizeof (EFI_SMBIOS_TABLE_HEADER);
1299 EndStructure.Header.Handle = SmbiosHandle;
1300 EndStructure.Tailing[0] = 0;
1301 EndStructure.Tailing[1] = 0;
1302 Smbios30EntryPointStructure->TableMaximumSize = (UINT32) (Smbios30EntryPointStructure->TableMaximumSize + sizeof (EndStructure));
1303
1304 if (EFI_SIZE_TO_PAGES (Smbios30EntryPointStructure->TableMaximumSize) > mPre64BitAllocatedPages) {
1305 //
1306 // If new SMBIOS table size exceeds the previous allocated page,
1307 // it is time to re-allocate memory at anywhere.
1308 //
1309 DEBUG ((EFI_D_INFO, "%a() re-allocate SMBIOS 64-bit table\n",
1310 __FUNCTION__));
1311 if (Smbios30EntryPointStructure->TableAddress != 0) {
1312 //
1313 // Free the previous allocated page
1314 //
1315 FreePages (
1316 (VOID*)(UINTN)Smbios30EntryPointStructure->TableAddress,
1317 mPre64BitAllocatedPages
1318 );
1319 Smbios30EntryPointStructure->TableAddress = 0;
1320 mPre64BitAllocatedPages = 0;
1321 }
1322
1323 Status = gBS->AllocatePages (
1324 AllocateAnyPages,
1325 EfiRuntimeServicesData,
1326 EFI_SIZE_TO_PAGES (Smbios30EntryPointStructure->TableMaximumSize),
1327 &PhysicalAddress
1328 );
1329 if (EFI_ERROR (Status)) {
1330 DEBUG ((EFI_D_ERROR, "SmbiosCreateTable() could not allocate SMBIOS 64-bit table\n"));
1331 Smbios30EntryPointStructure->TableAddress = 0;
1332 return EFI_OUT_OF_RESOURCES;
1333 } else {
1334 Smbios30EntryPointStructure->TableAddress = PhysicalAddress;
1335 mPre64BitAllocatedPages = EFI_SIZE_TO_PAGES (Smbios30EntryPointStructure->TableMaximumSize);
1336 }
1337 }
1338
1339 //
1340 // Assemble the tables
1341 //
1342 ASSERT (Smbios30EntryPointStructure->TableAddress != 0);
1343 BufferPointer = (UINT8 *) (UINTN) Smbios30EntryPointStructure->TableAddress;
1344 CurrentSmbiosEntry = NULL;
1345 do {
1346 Status = GetNextSmbiosRecord (SmbiosProtocol, &CurrentSmbiosEntry, &SmbiosRecord);
1347
1348 if ((Status == EFI_SUCCESS) && (CurrentSmbiosEntry->Smbios64BitTable)) {
1349 //
1350 // This record can be added to 64-bit table
1351 //
1352 GetSmbiosStructureSize(SmbiosProtocol, SmbiosRecord, &RecordSize, &NumOfStr);
1353 CopyMem (BufferPointer, SmbiosRecord, RecordSize);
1354 BufferPointer = BufferPointer + RecordSize;
1355 }
1356 } while (!EFI_ERROR(Status));
1357
1358 //
1359 // Assemble End-Of-Table structure
1360 //
1361 CopyMem (BufferPointer, &EndStructure, sizeof (EndStructure));
1362
1363 //
1364 // Fixup checksums in the Entry Point Structure
1365 //
1366 Smbios30EntryPointStructure->EntryPointStructureChecksum = 0;
1367 Smbios30EntryPointStructure->EntryPointStructureChecksum =
1368 CalculateCheckSum8 ((UINT8 *) Smbios30EntryPointStructure, Smbios30EntryPointStructure->EntryPointLength);
1369
1370 //
1371 // Returns the pointer
1372 //
1373 *TableEntryPointStructure = Smbios30EntryPointStructure;
1374
1375 return EFI_SUCCESS;
1376}
1377
1378/**
1379 Create Smbios Table and installs the Smbios Table to the System Table.
1380
1381 @param Smbios32BitTable The flag to update 32-bit table.
1382 @param Smbios64BitTable The flag to update 64-bit table.
1383
1384**/
1385VOID
1386EFIAPI
1387SmbiosTableConstruction (
1388 BOOLEAN Smbios32BitTable,
1389 BOOLEAN Smbios64BitTable
1390 )
1391{
1392 UINT8 *Eps;
1393 UINT8 *Eps64Bit;
1394 EFI_STATUS Status;
1395
1396 if (Smbios32BitTable) {
1397 Status = SmbiosCreateTable ((VOID **) &Eps);
1398 if (!EFI_ERROR (Status)) {
1399 gBS->InstallConfigurationTable (&gEfiSmbiosTableGuid, Eps);
1400 }
1401 }
1402
1403 if (Smbios64BitTable) {
1404 Status = SmbiosCreate64BitTable ((VOID **) &Eps64Bit);
1405 if (!EFI_ERROR (Status)) {
1406 gBS->InstallConfigurationTable (&gEfiSmbios3TableGuid, Eps64Bit);
1407 }
1408 }
1409}
1410
1411/**
1412
1413 Driver to produce Smbios protocol and pre-allocate 1 page for the final SMBIOS table.
1414
1415 @param ImageHandle Module's image handle
1416 @param SystemTable Pointer of EFI_SYSTEM_TABLE
1417
1418 @retval EFI_SUCCESS Smbios protocol installed
1419 @retval Other No protocol installed, unload driver.
1420
1421**/
1422EFI_STATUS
1423EFIAPI
1424SmbiosDriverEntryPoint (
1425 IN EFI_HANDLE ImageHandle,
1426 IN EFI_SYSTEM_TABLE *SystemTable
1427 )
1428{
1429 EFI_STATUS Status;
1430
1431 mPrivateData.Signature = SMBIOS_INSTANCE_SIGNATURE;
1432 mPrivateData.Smbios.Add = SmbiosAdd;
1433 mPrivateData.Smbios.UpdateString = SmbiosUpdateString;
1434 mPrivateData.Smbios.Remove = SmbiosRemove;
1435 mPrivateData.Smbios.GetNext = SmbiosGetNext;
1436 mPrivateData.Smbios.MajorVersion = (UINT8) (PcdGet16 (PcdSmbiosVersion) >> 8);
1437 mPrivateData.Smbios.MinorVersion = (UINT8) (PcdGet16 (PcdSmbiosVersion) & 0x00ff);
1438
1439 InitializeListHead (&mPrivateData.DataListHead);
1440 InitializeListHead (&mPrivateData.AllocatedHandleListHead);
1441 EfiInitializeLock (&mPrivateData.DataLock, TPL_NOTIFY);
1442
1443 //
1444 // Make a new handle and install the protocol
1445 //
1446 mPrivateData.Handle = NULL;
1447 Status = gBS->InstallProtocolInterface (
1448 &mPrivateData.Handle,
1449 &gEfiSmbiosProtocolGuid,
1450 EFI_NATIVE_INTERFACE,
1451 &mPrivateData.Smbios
1452 );
1453
1454 return Status;
1455}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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