EdkCompatibilityPkg/Compatibility/PiSmbiosRecordOnDataHubSmbiosRecordThunk/Translate.c

   1 /** @file
   2   Translate the DataHub records via EFI_DATA_HUB_PROTOCOL to Smbios recorders
   3   via EFI_SMBIOS_PROTOCOL.
   4
   5 Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "Thunk.h"
  17
  18 EFI_SMBIOS_PROTOCOL  *mSmbiosProtocol = NULL;
  19
  20 /**
  21   Release the structure Node.
  22
  23   @param StructureNode  Point to SMBIOS_STRUCTURE_NODE which will be removed.
  24 **/
  25 VOID
  26 ReleaseStructureNode (
  27   SMBIOS_STRUCTURE_NODE  *StructureNode
  28   )
  29 {
  30   EFI_SMBIOS_PROTOCOL *Smbios;
  31
  32   RemoveEntryList (&(StructureNode->Link));
  33   Smbios = GetSmbiosProtocol();
  34   ASSERT (Smbios != NULL);
  35   Smbios->Remove (Smbios, StructureNode->SmbiosHandle);
  36   gBS->FreePool (StructureNode);
  37 }
  38
  39 /**
  40   Process a datahub's record and find corresponding translation way to translate
  41   to SMBIOS record.
  42
  43   @param Record  Point to datahub record.
  44 **/
  45 VOID
  46 SmbiosProcessDataRecord (
  47   IN EFI_DATA_RECORD_HEADER  *Record
  48   )
  49 {
  50   EFI_DATA_RECORD_HEADER        *RecordHeader;
  51   EFI_SUBCLASS_TYPE1_HEADER     *DataHeader;
  52   UINTN                         Index;
  53   SMBIOS_CONVERSION_TABLE_ENTRY *Conversion;
  54   UINT8                         *SrcData;
  55   UINTN                         SrcDataSize;
  56   LIST_ENTRY                    *Link;
  57   SMBIOS_STRUCTURE_NODE         *StructureNode;
  58   BOOLEAN                       StructureCreated;
  59   EFI_STATUS                    Status;
  60
  61   Conversion        = NULL;
  62   StructureNode     = NULL;
  63   StructureCreated  = FALSE;
  64   RecordHeader      = Record;
  65   DataHeader        = (EFI_SUBCLASS_TYPE1_HEADER *) (Record + 1);
  66   SrcData           = (UINT8 *) (DataHeader + 1);
  67   SrcDataSize       = RecordHeader->RecordSize - RecordHeader->HeaderSize - sizeof (EFI_SUBCLASS_TYPE1_HEADER);
  68
  69   if (DataHeader->HeaderSize != sizeof (EFI_SUBCLASS_TYPE1_HEADER) ||
  70       DataHeader->Instance == EFI_SUBCLASS_INSTANCE_RESERVED ||
  71       DataHeader->SubInstance == EFI_SUBCLASS_INSTANCE_RESERVED
  72       ) {
  73     //
  74     // Invalid Data Record
  75     //
  76     goto Done;
  77   }
  78
  79   Index = 0;
  80   while(TRUE) {
  81     //
  82     // Find a matching entry in the conversion table for this
  83     // (SubClass, RecordNumber) pair
  84     //
  85     for (; !CompareGuid (&(mConversionTable[Index].SubClass), &gZeroGuid); Index++) {
  86       if (CompareGuid (
  87             &(mConversionTable[Index].SubClass),
  88             &(RecordHeader->DataRecordGuid)
  89             )) {
  90         if (mConversionTable[Index].RecordType == DataHeader->RecordType) {
  91           break;
  92         }
  93       }
  94     }
  95
  96     if (CompareGuid (&(mConversionTable[Index].SubClass), &gZeroGuid)) {
  97       //
  98       // We cannot find a matching entry in conversion table,
  99       // this means this data record cannot be used for SMBIOS.
 100       // Just skip it.
 101       //
 102       goto Done;
 103     }
 104
 105     Conversion = &mConversionTable[Index++];
 106
 107     //
 108     // Find corresponding structure in the Structure List
 109     //
 110     for (Link = mStructureList.ForwardLink; Link != &mStructureList; Link = Link->ForwardLink) {
 111
 112       StructureNode = CR (
 113                         Link,
 114                         SMBIOS_STRUCTURE_NODE,
 115                         Link,
 116                         SMBIOS_STRUCTURE_NODE_SIGNATURE
 117                         );
 118
 119       if (Conversion->StructureLocatingMethod == BySubclassInstanceSubinstanceProducer) {
 120         //
 121         // Look at SubClass, Instance, SubInstance and ProducerName for a matching
 122         // node
 123         //
 124         if (CompareGuid (&(StructureNode->SubClass), &(RecordHeader->DataRecordGuid)) &&
 125             StructureNode->Instance == DataHeader->Instance &&
 126             StructureNode->SubInstance == DataHeader->SubInstance &&
 127             CompareGuid (&(StructureNode->ProducerName), &(RecordHeader->ProducerName))
 128               ) {
 129           if (Conversion->SmbiosType >= 0x80) {
 130             if (StructureNode->SmbiosType == ((SMBIOS_STRUCTURE_HDR *) SrcData)->Type) {
 131               break;
 132             }
 133           } else if (StructureNode->SmbiosType == Conversion->SmbiosType) {
 134             break;
 135           }
 136         }
 137
 138       } else if (Conversion->StructureLocatingMethod == BySubClassInstanceProducer) {
 139         //
 140         // Look at SubClass, Instance and ProducerName for a matching node
 141         //
 142         if (CompareGuid (&(StructureNode->SubClass), &(RecordHeader->DataRecordGuid)) &&
 143             StructureNode->Instance == DataHeader->Instance &&
 144             CompareGuid (&(StructureNode->ProducerName), &(RecordHeader->ProducerName))
 145               ) {
 146           if (Conversion->SmbiosType >= 0x80) {
 147             if (StructureNode->SmbiosType == ((SMBIOS_STRUCTURE_HDR *) SrcData)->Type) {
 148               break;
 149             }
 150           } else if (StructureNode->SmbiosType == Conversion->SmbiosType) {
 151             break;
 152           }
 153         }
 154
 155       } else {
 156         //
 157         // Invalid conversion table entry
 158         //
 159         goto Done;
 160       }
 161     }
 162
 163     if (Link == &mStructureList || StructureNode == NULL) {
 164
 165       //
 166       // Not found, create a new structure
 167       //
 168       StructureNode = AllocateZeroPool (sizeof (SMBIOS_STRUCTURE_NODE));
 169
 170       if (StructureNode == NULL) {
 171         goto Done;
 172       }
 173
 174       if (Conversion->StructureLocatingMethod == BySubclassInstanceSubinstanceProducer) {
 175         //
 176         // Fill in SubClass, Instance, SubInstance and ProducerName
 177         //
 178         CopyMem (&(StructureNode->SubClass), &(RecordHeader->DataRecordGuid), sizeof (EFI_GUID));
 179         StructureNode->Instance     = DataHeader->Instance;
 180         StructureNode->SubInstance  = DataHeader->SubInstance;
 181         CopyMem (&(StructureNode->ProducerName), &(RecordHeader->ProducerName), sizeof (EFI_GUID));
 182
 183       } else if (Conversion->StructureLocatingMethod == BySubClassInstanceProducer) {
 184         //
 185         // Fill in at SubClass, Instance and ProducerName, mark SubInstance as Non
 186         // Applicable
 187         //
 188         CopyMem (&(StructureNode->SubClass), &(RecordHeader->DataRecordGuid), sizeof (EFI_GUID));
 189         StructureNode->Instance     = DataHeader->Instance;
 190         StructureNode->SubInstance  = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
 191         CopyMem (&(StructureNode->ProducerName), &(RecordHeader->ProducerName), sizeof (EFI_GUID));
 192
 193       }
 194       //
 195       // Allocate the structure instance
 196       //
 197       StructureNode->StructureSize = SmbiosGetTypeMinimalLength (Conversion->SmbiosType);
 198
 199       //
 200       // StructureSize include the TWO trailing zero byte.
 201       //
 202       if (StructureNode->StructureSize < (sizeof(SMBIOS_STRUCTURE) + 2)) {
 203         //
 204         // Invalid Type
 205         //
 206         gBS->FreePool (StructureNode);
 207         goto Done;
 208       }
 209
 210       //
 211       // Assign correct SmbiosType when OEM type and Non-OEM type
 212       //
 213       if (Conversion->SmbiosType >= 0x80) {
 214         StructureNode->SmbiosType = ((SMBIOS_STRUCTURE_HDR *) SrcData)->Type;
 215       } else {
 216         StructureNode->SmbiosType = Conversion->SmbiosType;
 217       }
 218
 219       StructureNode->SmbiosHandle        = SMBIOS_HANDLE_PI_RESERVED;
 220       Status = SmbiosProtocolCreateRecord (
 221                  NULL,
 222                  StructureNode
 223                  );
 224       if (EFI_ERROR (Status)) {
 225         goto Done;
 226       }
 227       //
 228       // Temporary cache the structrue pointer to Smbios database.
 229       //
 230       StructureNode->Structure = GetSmbiosBufferFromHandle (StructureNode->SmbiosHandle, StructureNode->SmbiosType, NULL);
 231
 232       InitializeListHead (&StructureNode->LinkDataFixup);
 233
 234       //
 235       // Insert the Structure Node into the Strucutre List
 236       //
 237       StructureNode->Signature = SMBIOS_STRUCTURE_NODE_SIGNATURE;
 238       InsertTailList (&mStructureList, &(StructureNode->Link));
 239
 240       StructureCreated = TRUE;
 241
 242     }
 243
 244
 245     //
 246     // Re-calculate the structure pointer to Smbios database.
 247     //
 248     StructureNode->Structure = GetSmbiosBufferFromHandle (StructureNode->SmbiosHandle, StructureNode->SmbiosType, NULL);
 249
 250     //
 251     // Fill the Structure's field corresponding to this data record
 252     //
 253     if (Conversion->FieldFillingMethod == RecordDataUnchangedOffsetSpecified) {
 254       //
 255       // Field data is just the record data without transforming and
 256       // offset is specified directly in the conversion table entry
 257       //
 258       if (Conversion->FieldOffset + SrcDataSize > StructureNode->Structure->Length) {
 259         //
 260         // Invalid Conversion Table Entry
 261         //
 262         if (StructureCreated) {
 263           ReleaseStructureNode (StructureNode);
 264         }
 265
 266         goto Done;
 267       }
 268
 269       CopyMem ((UINT8 *) (StructureNode->Structure) + Conversion->FieldOffset, SrcData, SrcDataSize);
 270
 271     } else if (Conversion->FieldFillingMethod == ByFunctionWithOffsetSpecified) {
 272       //
 273       // Field offfset is specified in the conversion table entry, but
 274       // record data needs to be transformed to be filled into the field,
 275       // so let the FieldFillingFunction do it.
 276       //
 277       if (Conversion->FieldFillingFunction == NULL) {
 278         //
 279         // Invalid Conversion Table Entry
 280         //
 281         if (StructureCreated) {
 282           ReleaseStructureNode (StructureNode);
 283         }
 284
 285         goto Done;
 286       }
 287
 288       Status = Conversion->FieldFillingFunction (
 289                             StructureNode,
 290                             Conversion->FieldOffset,
 291                             SrcData,
 292                             (UINT32) SrcDataSize
 293                             );
 294       if (EFI_ERROR (Status)) {
 295         if (StructureCreated) {
 296           ReleaseStructureNode (StructureNode);
 297         }
 298
 299         goto Done;
 300       }
 301     } else if (Conversion->FieldFillingMethod == ByFunction) {
 302       //
 303       // Both field offset and field content are determined by
 304       // FieldFillingFunction
 305       //
 306       if (Conversion->FieldFillingFunction == NULL) {
 307         //
 308         // Invalid Conversion Table Entry
 309         //
 310         if (StructureCreated) {
 311           ReleaseStructureNode (StructureNode);
 312         }
 313
 314         goto Done;
 315       }
 316
 317       Status = Conversion->FieldFillingFunction (
 318                             StructureNode,
 319                             0,
 320                             SrcData,
 321                             (UINT32) SrcDataSize
 322                             );
 323       if (EFI_ERROR (Status)) {
 324         if (StructureCreated) {
 325           ReleaseStructureNode (StructureNode);
 326         }
 327
 328         goto Done;
 329       }
 330     } else if (Conversion->FieldFillingMethod == ByFunctionWithWholeDataRecord) {
 331       //
 332       // Both field offset and field content are determined by
 333       // FieldFillingFunction and the function accepts the whole data record
 334       // including the data header
 335       //
 336       if (Conversion->FieldFillingFunction == NULL) {
 337         //
 338         // Invalid Conversion Table Entry
 339         //
 340         if (StructureCreated) {
 341           ReleaseStructureNode (StructureNode);
 342         }
 343
 344         goto Done;
 345       }
 346
 347       Status = Conversion->FieldFillingFunction (
 348                             StructureNode,
 349                             0,
 350                             DataHeader,
 351                             RecordHeader->RecordSize - RecordHeader->HeaderSize
 352                             );
 353       if (EFI_ERROR (Status)) {
 354         if (StructureCreated) {
 355           ReleaseStructureNode (StructureNode);
 356         }
 357
 358         goto Done;
 359       }
 360     } else {
 361       //
 362       // Invalid Conversion Table Entry
 363       //
 364       if (StructureCreated) {
 365         ReleaseStructureNode (StructureNode);
 366       }
 367
 368       goto Done;
 369     }
 370
 371     //
 372     // SmbiosEnlargeStructureBuffer is called to remove and add again
 373     // this SMBIOS entry to reflash SMBIOS table in configuration table.
 374     //
 375     SmbiosEnlargeStructureBuffer (
 376       StructureNode,
 377       StructureNode->Structure->Length,
 378       StructureNode->StructureSize,
 379       StructureNode->StructureSize
 380       );
 381   }
 382 Done:
 383   return ;
 384 }
 385
 386 /**
 387   Calculate the minimal length for a SMBIOS type. This length maybe not equal
 388   to sizeof (SMBIOS_RECORD_STRUCTURE), but defined in conformance chapter in SMBIOS specification.
 389
 390   @param Type  SMBIOS's type.
 391
 392   @return the minimal length of a smbios record.
 393 **/
 394 UINT32
 395 SmbiosGetTypeMinimalLength (
 396   IN UINT8  Type
 397   )
 398 {
 399   UINTN Index;
 400
 401   for (Index = 0; mTypeInfoTable[Index].MinLength != 0; Index++) {
 402     if (mTypeInfoTable[Index].Type == Type) {
 403       return mTypeInfoTable[Index].MinLength;
 404     }
 405   }
 406
 407   return 0;
 408 }
 409
 410 /**
 411   Get pointer of EFI_SMBIOS_PROTOCOL.
 412
 413   @return pointer of EFI_SMBIOS_PROTOCOL.
 414 **/
 415 EFI_SMBIOS_PROTOCOL*
 416 GetSmbiosProtocol(
 417   VOID
 418   )
 419 {
 420   EFI_STATUS  Status;
 421
 422   if (mSmbiosProtocol == NULL) {
 423     Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID*) &mSmbiosProtocol);
 424     ASSERT_EFI_ERROR (Status);
 425   }
 426
 427   ASSERT (mSmbiosProtocol != NULL);
 428   return mSmbiosProtocol;
 429 }
 430
 431 /**
 432   Create a blank smbios record. The datahub record is only a field of smbios record.
 433   So before fill any field from datahub's record. A blank smbios record need to be
 434   created.
 435
 436   @param ProducerHandle   The produce handle for a datahub record
 437   @param StructureNode    Point to SMBIOS_STRUCTURE_NODE
 438
 439   @retval EFI_OUT_OF_RESOURCES Fail to allocate memory for new blank SMBIOS record.
 440   @retval EFI_SUCCESS          Success to create blank smbios record.
 441 **/
 442 EFI_STATUS
 443 SmbiosProtocolCreateRecord (
 444   IN      EFI_HANDLE              ProducerHandle, OPTIONAL
 445   IN      SMBIOS_STRUCTURE_NODE   *StructureNode
 446   )
 447 {
 448   EFI_SMBIOS_PROTOCOL         *Smbios;
 449   EFI_SMBIOS_TABLE_HEADER     *BlankRecord;
 450   EFI_STATUS                  Status;
 451   SMBIOS_STRUCTURE_NODE       *RefStructureNode;
 452   LIST_ENTRY                  *Link;
 453   LIST_ENTRY                  *Link1;
 454   LIST_ENTRY                  *Link2;
 455   SMBIOS_LINK_DATA_FIXUP_NODE *LinkDataFixupNode;
 456   UINT8                       *BufferPointer;
 457
 458   Smbios = GetSmbiosProtocol();
 459   ASSERT (Smbios != NULL);
 460
 461   //
 462   // Prepare a blank smbios record.
 463   //
 464   BlankRecord = (EFI_SMBIOS_TABLE_HEADER*) AllocateZeroPool (StructureNode->StructureSize);
 465   if (BlankRecord == NULL) {
 466     return EFI_OUT_OF_RESOURCES;
 467   }
 468   BlankRecord->Type   = StructureNode->SmbiosType;
 469   BlankRecord->Length = (UINT8) (StructureNode->StructureSize - 2);
 470
 471   //
 472   // Add blank record into SMBIOS database.
 473   //
 474   Status = Smbios->Add (Smbios, NULL, &StructureNode->SmbiosHandle, BlankRecord);
 475   FreePool (BlankRecord);
 476
 477   //
 478   // Fix up the InterLink node for new added smbios record if some other
 479   // existing smbios record want to link this new record's handle.
 480   //
 481   for (Link = mStructureList.ForwardLink; Link != &mStructureList; Link = Link->ForwardLink) {
 482     RefStructureNode = CR (Link, SMBIOS_STRUCTURE_NODE, Link, SMBIOS_STRUCTURE_NODE_SIGNATURE);
 483     for (Link1 = RefStructureNode->LinkDataFixup.ForwardLink; Link1 != &RefStructureNode->LinkDataFixup;) {
 484       LinkDataFixupNode = CR (Link1, SMBIOS_LINK_DATA_FIXUP_NODE, Link, SMBIOS_LINK_DATA_FIXUP_NODE_SIGNATURE);
 485       Link2 = Link1;
 486       Link1 = Link1->ForwardLink;
 487
 488       if ((StructureNode->SmbiosType != LinkDataFixupNode->TargetType) ||
 489           !(CompareGuid (&StructureNode->SubClass, &LinkDataFixupNode->SubClass)) ||
 490           (StructureNode->Instance != LinkDataFixupNode->LinkData.Instance) ||
 491           (StructureNode->SubInstance != LinkDataFixupNode->LinkData.SubInstance)) {
 492         continue;
 493       }
 494
 495       //
 496       // Fill the field with the handle found
 497       //
 498       BufferPointer         = (UINT8 *) (RefStructureNode->Structure) + LinkDataFixupNode->Offset;
 499       *BufferPointer        = (UINT8) (StructureNode->SmbiosHandle & 0xFF);
 500       *(BufferPointer + 1)  = (UINT8) ((StructureNode->SmbiosHandle >> 8) & 0xFF);
 501       BufferPointer         = NULL;
 502
 503       RemoveEntryList (Link2);
 504       FreePool (LinkDataFixupNode);
 505     }
 506   }
 507
 508   return Status;
 509 }
 510
 511 /**
 512   Get pointer of a SMBIOS record's buffer according to its handle.
 513
 514   @param Handle         The handle of SMBIOS record want to be searched.
 515   @param Type           The type of SMBIOS record want to be searched.
 516   @param ProducerHandle The producer handle of SMBIOS record.
 517
 518   @return EFI_SMBIOS_TABLE_HEADER Point to a SMBIOS record's buffer.
 519 **/
 520 EFI_SMBIOS_TABLE_HEADER*
 521 GetSmbiosBufferFromHandle (
 522   IN  EFI_SMBIOS_HANDLE  Handle,
 523   IN  EFI_SMBIOS_TYPE    Type,
 524   IN  EFI_HANDLE         ProducerHandle  OPTIONAL
 525   )
 526 {
 527   EFI_SMBIOS_PROTOCOL*    Smbios;
 528   EFI_SMBIOS_HANDLE       SearchingHandle;
 529   EFI_SMBIOS_TABLE_HEADER *RecordInSmbiosDatabase;
 530   EFI_STATUS              Status;
 531
 532   SearchingHandle = SMBIOS_HANDLE_PI_RESERVED;
 533   Smbios          = GetSmbiosProtocol();
 534   ASSERT (Smbios != NULL);
 535
 536   do {
 537     Status = Smbios->GetNext (Smbios, &SearchingHandle, &Type, &RecordInSmbiosDatabase, NULL);
 538   } while ((SearchingHandle != Handle) && (Status != EFI_NOT_FOUND));
 539
 540   return RecordInSmbiosDatabase;
 541 }
 542
 543 /**
 544
 545   Get the full size of smbios structure including optional strings that follow the formatted structure.
 546
 547   @param Head                   Pointer to the beginning of smbios structure.
 548   @param Size                   The returned size.
 549   @param NumberOfStrings        The returned number of optional strings that follow the formatted structure.
 550
 551   @retval EFI_SUCCESS           Size retured in Size.
 552   @retval EFI_INVALID_PARAMETER Input smbios structure mal-formed or Size is NULL.
 553
 554 **/
 555 EFI_STATUS
 556 EFIAPI
 557 GetSmbiosStructureSize (
 558   IN   EFI_SMBIOS_TABLE_HEADER          *Head,
 559   OUT  UINT32                           *Size,
 560   OUT  UINT8                            *NumberOfStrings
 561   )
 562 {
 563   UINT32 FullSize;
 564   UINT8  StrLen;
 565   INT8*  CharInStr;
 566
 567   if (Size == NULL || NumberOfStrings == NULL) {
 568     return EFI_INVALID_PARAMETER;
 569   }
 570
 571   FullSize = Head->Length;
 572   CharInStr = (INT8*)Head + Head->Length;
 573   *Size = FullSize;
 574   *NumberOfStrings = 0;
 575   StrLen = 0;
 576   //
 577   // look for the two consecutive zeros, check the string limit by the way.
 578   //
 579   while (*CharInStr != 0 || *(CharInStr+1) != 0) {
 580     if (*CharInStr == 0) {
 581       *Size += 1;
 582       CharInStr++;
 583     }
 584
 585     for (StrLen = 0 ; StrLen < SMBIOS_STRING_MAX_LENGTH; StrLen++) {
 586       if (*(CharInStr+StrLen) == 0) {
 587         break;
 588       }
 589     }
 590
 591     if (StrLen == SMBIOS_STRING_MAX_LENGTH) {
 592       return EFI_INVALID_PARAMETER;
 593     }
 594     //
 595     // forward the pointer
 596     //
 597     CharInStr += StrLen;
 598     *Size += StrLen;
 599     *NumberOfStrings += 1;
 600
 601   }
 602
 603   //
 604   // count ending two zeros.
 605   //
 606   *Size += 2;
 607   return EFI_SUCCESS;
 608 }