data.c3

在efi下读取datahub的一个小程序

    PackageList.KeyboardPack = NULL;
    PackageList.GuidId       = &EfiDataHubGuid;

    Status = Hii->NewPack (Hii, &PackageList, HiiHandle);
  } 

  FreePool(HiiHandleBuffer);
  FreePool(Buffer);
  return Status;
}

EFI_STATUS
ExtractDataFromHiiHandle (
  IN      EFI_HII_HANDLE      HiiHandle,
  IN OUT  UINT16              *ImageLength,
  OUT     UINT8               *DefaultImage,
  OUT     EFI_GUID            *Guid
  )

{
  EFI_STATUS                      Status;
  EFI_HII_PROTOCOL                *Hii;
  UINTN                           DataLength;
  UINT8                           *RawData;
  UINT8                           *OldData;
  UINTN                           Index;
  UINTN                           Temp;
  UINTN                           SizeOfNvStore;
  UINTN                           CachedStart;

  DataLength = 0x10000;
  SizeOfNvStore = 0;
  CachedStart = 0;

  Status = GetHiiInterface(&Hii);

  if (EFI_ERROR(Status)) {
    return Status;
  }

  //
  // Allocate space for retrieval of IFR data
  //
  RawData = AllocateZeroPool ((UINTN)DataLength);
  if (RawData == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  //
  // Get all the forms associated with this HiiHandle
  //
  Status = Hii->GetForms (Hii, HiiHandle, 0, (UINT16 *)&DataLength, RawData);

  if (EFI_ERROR(Status)) {
   
BS->FreePool(RawData);

    //
    // Allocate space for retrieval of IFR data
    //
    RawData = AllocateZeroPool ((UINTN)DataLength);
    if (RawData == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }

    //
    // Get all the forms associated with this HiiHandle
    //
    Status = Hii->GetForms (Hii, HiiHandle, 0, (UINT16 *)&DataLength, RawData);
  }

  OldData = RawData;

  //
  // Point RawData to the beginning of the form data
  //
  RawData = (UINT8 *)((UINTN)RawData + sizeof(EFI_HII_PACK_HEADER));

  for (Index = 0; RawData[Index] != EFI_IFR_END_FORM_SET_OP;) {
    switch (RawData[Index]) {
      case EFI_IFR_FORM_SET_OP:
        //
        // Copy the GUID information from this handle
        //
        EfiCopyMem(Guid, &((EFI_IFR_FORM_SET *)&RawData[Index])->Guid, sizeof(EFI_GUID));
        break;

      case EFI_IFR_ONE_OF_OP:
      case EFI_IFR_CHECKBOX_OP:
      case EFI_IFR_NUMERIC_OP:
      case EFI_IFR_DATE_OP:
      case EFI_IFR_TIME_OP:
      case EFI_IFR_PASSWORD_OP:
      case EFI_IFR_STRING_OP:
        //
        // Remember, multiple op-codes may reference the same item, so let's keep a running
        // marker of what the highest QuestionId that wasn't zero length.  This will accurately
        // maintain the Size of the NvStore
        //
        if (((EFI_IFR_ONE_OF *)&RawData[Index])->Width != 0) {
          Temp = ((EFI_IFR_ONE_OF *)&RawData[Index])->QuestionId + ((EFI_IFR_ONE_OF *)&RawData[Index])->Width;
          if (SizeOfNvStore < Temp) {
            SizeOfNvStore = ((EFI_IFR_ONE_OF *)&RawData[Index])->QuestionId + ((EFI_IFR_ONE_OF *)&RawData[Index])->Width;
          }
        }
    }
    Index = RawData[Index+1] + Index;
  }
    
  //
  // Return an error if buffer is too small
  //
  if (SizeOfNvStore > *ImageLength) {
    BS->FreePool(OldData);
    *ImageLength = (UINT16)SizeOfNvStore;
    return EFI_BUFFER_TOO_SMALL;
  }

  EfiZeroMem (DefaultImage, SizeOfNvStore);

  //
  // Copy the default image information to the user's buffer
  //
  for (Index = 0; RawData[Index] != EFI_IFR_END_FORM_SET_OP;) {
    switch (RawData[Index]) {
      case EFI_IFR_ONE_OF_OP:
        CachedStart = ((EFI_IFR_ONE_OF *)&RawData[Index])->QuestionId;
        break;

      case EFI_IFR_ONE_OF_OPTION_OP:
        if (((EFI_IFR_ONE_OF_OPTION *)&RawData[Index])->Flags & EFI_IFR_FLAG_DEFAULT) {
          EfiCopyMem(&DefaultImage[CachedStart],&((EFI_IFR_ONE_OF_OPTION *)&RawData[Index])->Value, 2);
        }
        break;

      case EFI_IFR_CHECKBOX_OP:
        DefaultImage[((EFI_IFR_ONE_OF *)&RawData[Index])->QuestionId] = ((EFI_IFR_CHECK_BOX *)&RawData[Index])->Flags;
        break;

      case EFI_IFR_NUMERIC_OP:
        EfiCopyMem(&DefaultImage[((EFI_IFR_ONE_OF *)&RawData[Index])->QuestionId], &((EFI_IFR_NUMERIC *)&RawData[Index])->Default, 2);
        break;

    }
    Index = RawData[Index+1] + Index;
  }

  *ImageLength = (UINT16)SizeOfNvStore;

  //
  // Free our temporary repository of form data
  //
  
  BS->FreePool(OldData);

  return EFI_SUCCESS;
}

VOID
DisplayDataHubEntry (
  IN  EFI_DATA_RECORD_HEADER *Data
  )
{
  DATA_HUB_STATUS_CODE_DATA_RECORD  *DataHubHeader;
  UINTN                             Size;
  UINTN                             RawSize;
  CHAR8                             *RawFormat;

  RawSize = Data->RecordSize - Data->HeaderSize;
  RawFormat = ((UINT8 *)Data) + Data->HeaderSize;
 
  if (CompareGuid (&Data->DataRecordGuid, &gEfiStatusCodeGuid) == 0) {
    DataHubHeader = (DATA_HUB_STATUS_CODE_DATA_RECORD *)RawFormat;

    //
    // Print DATA_HUB_STATUS_CODE_DATA_RECORD header
    //
    PrintToken (STRING_TOKEN(STR_DATAHUB_STATUSCODE), 
      HiiHandle,
      Data->LogMonotonicCount,
      DataHubHeader->CodeType, DataHubHeader->Value, DataHubHeader->Instance,
      &DataHubHeader->CallerId
      );

    //
    // Print EFI_STATUS_CODE_DATA 
    //
    PrintToken (
      STRING_TOKEN(STR_DATAHUB_HEADER_DATA_SIZE), 
      HiiHandle,
      DataHubHeader->Data.HeaderSize, 
      DataHubHeader->Data.Size, 
      &DataHubHeader->Data.Type
      );

    if (DataHubHeader->Data.Size == 0) {
      return;
    }

    //
    // Print data according to Data Type Id
    //
    if (CompareGuid (&DataHubHeader->Data.Type, &gEfiStatusCodeDataTypeStringGuid) == 0) {
      //
      // String Data
      //
      EFI_STATUS_CODE_STRING_DATA  *StringData;
      StringData = (EFI_STATUS_CODE_STRING_DATA *)(DataHubHeader + 1);
      PrintStringData (StringData, DataHubHeader->Data.Size);

    } else if (CompareGuid (&DataHubHeader->Data.Type, &gEfiStatusCodeDataTypeAssertGuid) == 0) {
      //
      // Assert Data
      //
      EFI_DEBUG_ASSERT_DATA   *AssertData;

      AssertData = (EFI_DEBUG_ASSERT_DATA *)(DataHubHeader + 1);
      PrintToken (STRING_TOKEN(STR_DATAHUB_LINENUMBER), HiiHandle, AssertData->LineNumber);
      PrintToken (STRING_TOKEN(STR_DATAHUB_FILENAME), HiiHandle, AssertData + 1);

    } else if (CompareGuid (&DataHubHeader->Data.Type, &gEfiStatusCodeDataTypeDebugGuid) == 0) {
      //
      // Debug Data 
      //
      UINT32 OldAttributes;

      OldAttributes = ST->ConOut->Mode->Attribute;
      ST->ConOut->SetAttribute (ST->ConOut, EFI_TEXT_ATTR (EFI_MAGENTA, EFI_BLACK));
      Print ((CHAR16 *)(DataHubHeader + 1));
      ST->ConOut->SetAttribute (ST->ConOut, OldAttributes);

    } else if (CompareGuid (&DataHubHeader->Data.Type, &gEfiStatusCodeDataTypeErrorGuid) == 0) {
      //
      // Error Data 
      //
      EFI_DEBUG_INFO  *DebugInfo;

      DebugInfo = (EFI_DEBUG_INFO *)(DataHubHeader + 1);
      PrintToken (STRING_TOKEN(STR_DATAHUB_DEBUGLEVEL), HiiHandle, DebugInfo + 1);

    } else if (CompareGuid (&DataHubHeader->Data.Type, &gEfiStatusCodeDataTypeProgressCodeGuid) == 0) {
      //
      // Progress Code Data
      //
      EFI_STATUS_CODE_STRING_DATA  *String;
      String = (EFI_STATUS_CODE_STRING_DATA *)(DataHubHeader + 1);
      PrintStringData (String, DataHubHeader->Data.Size);

    } else if (CompareGuid (&DataHubHeader->Data.Type, &gEfiStatusCodeDataTypeExceptionHandlerGuid) == 0) {
      //
      // Exception Context Data
      //
      EFI_SYSTEM_CONTEXT  *ExceptContext;
      ExceptContext = (EFI_SYSTEM_CONTEXT *)(DataHubHeader + 1);
      PrintExceptContext (ExceptContext, DataHubHeader->Data.Size);

    } else {
      PrintToken (STRING_TOKEN(STR_DATAHUB_STATUSCODE_2), HiiHandle,
        CodeTypeString (DataHubHeader->CodeType & EFI_STATUS_CODE_TYPE_MASK),
        SeverityString (DataHubHeader->CodeType & EFI_STATUS_CODE_TYPE_MASK),
        DataHubHeader->Instance,
        (DataHubHeader->Value & EFI_STATUS_CODE_CLASS_MASK),
        (DataHubHeader->Value & EFI_STATUS_CODE_SUBCLASS_MASK),
        (DataHubHeader->Value & EFI_STATUS_CODE_OPERATION_MASK)
        );

      Size = RawSize - sizeof (DATA_HUB_STATUS_CODE_DATA_RECORD);
      DumpHex (2, 0, Size, DataHubHeader + 1);    

    }
  } else {
    DataHubDefaultDisplay (Data);
  }

}