xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Intel/AlderLake/AlderLakePlatSamplePkg/Telemetry/Library/DxeTelemetryAcpiLib/DxeTelemetryAcpiLib.c

1684 lines
57 KiB
C
Raw Permalink Blame History

/** @file
This file implements firmware version information.
Copyright (c) 2018 - 2021, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "DxeTelemetryAcpiLib.h"
#include "DxeTelemetryHwErrRec.h"
BOOLEAN mPhatInstalled = FALSE;
UINTN mTableKey;
GLOBAL_REMOVE_IF_UNREFERENCED EFI_ACPI_TABLE_PROTOCOL *mAcpiTableProtocol = NULL;
EFI_RSC_HANDLER_PROTOCOL *mRscHandlerProtocol = NULL;
UINT8 AcpiComPonentHeadSize = OFFSET_OF (EFI_COMPONENT_VERSION_DATA, Records);
UINT16 AcpiFviRecordSize = sizeof (TELEMETRY_DATA_RECORD);
GLOBAL_REMOVE_IF_UNREFERENCED EFI_GUID *mDriverHealthSupportList[] = {
&gAdapterInfoMotherBoardHealthGuid,
&gAdapterInfoCsmeGuid,
&gAdapterInfoMrcGuid,
&gAdapterInfoNvmeHealthGuid,
NULL
};
/**
This function calculates and updates an UINT8 checksum.
@param Buffer Pointer to buffer to checksum
@param Size Number of bytes to checksum
**/
VOID
AcpiPlatformChecksum (
IN UINT8 *Buffer,
IN UINTN Size
)
{
UINTN ChecksumOffset;
ChecksumOffset = OFFSET_OF (EFI_ACPI_DESCRIPTION_HEADER, Checksum);
//
// Set checksum to 0 first
//
Buffer[ChecksumOffset] = 0;
//
// Update checksum value
//
Buffer[ChecksumOffset] = CalculateCheckSum8(Buffer, Size);
}
/**
Collect driver health information by CommponentID(Guid).
@param[in] ComponentID The unique GUID associated with this device.
@param[out] AcpiDataBlock Point to the buffer of driver health Acpi record
@param[out] AcpiDataSize length of driver health Acpi record
@retval EFI_SUCCESS All driver health info was collected successfully
@retval EFI_NOT_FOUND No handles match the search or no record was found.
@retval EFI_OUT_OF_RESOURCES There is not enough memory resource.
**/
EFI_STATUS
DriverHealthAipDataCollection (
IN EFI_GUID *ComponentID,
OUT UINT8 **AcpiDataBlock,
OUT UINTN *AcpiDataSize
)
{
EFI_STATUS Status;
EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
EFI_GUID *InfoTypesBuffer;
UINTN InfoTypeBufferCount;
UINTN Index;
UINTN TypeIndex;
BOOLEAN Supported;
UINT8 *DataBlock;
UINTN BlockSize;
EFI_AIP_HEALTH_HEADER *AipPtr;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
UINTN SizeOfDevicePath;
UINTN DevSpecificDataOffset;
EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE *AcpiDataBlockHeader;
UINTN AcpiDataSizeTemp;
CHAR16 *DevicePathText;
UINT8 *AcpiDataBlockHead;
InfoTypesBuffer = NULL;
Status = EFI_SUCCESS;
AipPtr = NULL;
DataBlock = NULL;
BlockSize = 0;
DevSpecificDataOffset = 0;
DevicePathText = NULL;
SizeOfDevicePath = 0;
*AcpiDataBlock = NULL;
*AcpiDataSize = 0;
AcpiDataSizeTemp = 0;
AcpiDataBlockHead = NULL;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiAdapterInformationProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
//
// gEfiAdapterInformationProtocolGuid protocol not installed yet!
//
DEBUG ((EFI_D_ERROR, "gEfiAdapterInformationProtocolGuid locate failed, status = [%x] \n", Status));
return Status;
}
if (HandleBuffer == NULL) {
DEBUG ((EFI_D_ERROR, " HandleBuffer is null \n"));
return EFI_INVALID_PARAMETER;
}
for (Index = 0; Index < HandleCount ; Index++) {
Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiAdapterInformationProtocolGuid, (VOID **) &Aip);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "HandleProtocol gEfiAdapterInformationProtocolGuid failed. \n"));
return Status;
} else {
InfoTypeBufferCount = 0;
Status = Aip->GetSupportedTypes (Aip, &InfoTypesBuffer, &InfoTypeBufferCount);
if (EFI_ERROR (Status) || InfoTypesBuffer == NULL) {
continue;
}
//
// Check whether the AIP instance has FVI information block.
//
Supported = FALSE;
for (TypeIndex = 0; TypeIndex < InfoTypeBufferCount; TypeIndex++) {
if (CompareGuid (&InfoTypesBuffer[TypeIndex], ComponentID)) {
Supported = TRUE;
break;
}
}
if (!Supported) {
continue;
}
Status = Aip->GetInformation (Aip, ComponentID, (VOID **) &DataBlock, &BlockSize);
DEBUG ((EFI_D_ERROR, "Aip->GetInformation, Status=[%x], data length=[%x]. \n", Status, BlockSize));
if (EFI_ERROR (Status) || DataBlock == NULL || BlockSize == 0
|| BlockSize < sizeof (EFI_AIP_HEALTH_HEADER)) {
DEBUG ((EFI_D_ERROR, "It is failed to built driver Health. \n"));
continue;
}
AipPtr = (EFI_AIP_HEALTH_HEADER *) DataBlock;
//
// To handle driver health device path
//
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiDevicePathProtocolGuid,
(VOID **) &DevicePath
);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Can't get DevicePath, Status = [%x]. \n", Status));
break;
} else {
DevicePathText = ConvertDeviceNodeToText (DevicePath, FALSE, FALSE);
if (DevicePathText == NULL) {
DEBUG ((EFI_D_ERROR, "Invalid DevicePath node.\n"));
break;
}
}
SizeOfDevicePath = StrSize (DevicePathText);
DevSpecificDataOffset = sizeof (EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE) + SizeOfDevicePath;
//
// To save the previous total size
//
AcpiDataSizeTemp = *AcpiDataSize;
//
// Get the total length (just include one default capsule instance for Mother board health)
//
if ((MAX_UINTN - DevSpecificDataOffset) < BlockSize - sizeof (EFI_AIP_HEALTH_HEADER)) {
DEBUG ((EFI_D_ERROR, "Warning: found integer overflow.\n"));
continue;
}
*AcpiDataSize += DevSpecificDataOffset + (BlockSize - sizeof (EFI_AIP_HEALTH_HEADER));
if (*AcpiDataBlock == NULL) {
//
// Try to find the 1th health record
//
*AcpiDataBlock = AllocateZeroPool (*AcpiDataSize);
} else {
*AcpiDataBlock = ReallocatePool (AcpiDataSizeTemp, *AcpiDataSize, *AcpiDataBlock);
}
if (*AcpiDataBlock == NULL) {
if (InfoTypesBuffer != NULL) {
FreePool (InfoTypesBuffer);
}
if (HandleBuffer != NULL) {
FreePool (HandleBuffer);
}
if (DataBlock != NULL) {
FreePool (DataBlock);
}
return EFI_OUT_OF_RESOURCES;
}
AcpiDataBlockHead = *AcpiDataBlock;
*AcpiDataBlock += AcpiDataSizeTemp;
AcpiDataBlockHeader = (EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE *) (*AcpiDataBlock);
AcpiDataBlockHeader->Header.RecordType = FirmwareHealthDataRecord;
AcpiDataBlockHeader->Header.RecordLength = (UINT16) (*AcpiDataSize - AcpiDataSizeTemp);
AcpiDataBlockHeader->Header.Revision = TELEMETRY_ACPI_HEADER_REVISION;
AcpiDataBlockHeader->Reserved = 0;
AcpiDataBlockHeader->AmHealthy = AipPtr->Healthy;
CopyGuid (&AcpiDataBlockHeader->DeviceSignature, &AipPtr->Signature);
AcpiDataBlockHeader->DeviceSpecificDataOffset = (UINT32) DevSpecificDataOffset;
if (SizeOfDevicePath > 0) {
//
// Add device path data to ACPI table
//
CopyMem (
*AcpiDataBlock + sizeof (EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE),
DevicePathText,
SizeOfDevicePath
);
}
//
// Attach driver health special data
//
CopyMem (
*AcpiDataBlock + DevSpecificDataOffset,
DataBlock + sizeof (EFI_AIP_HEALTH_HEADER),
BlockSize - sizeof (EFI_AIP_HEALTH_HEADER)
);
*AcpiDataBlock = AcpiDataBlockHead;
if (InfoTypesBuffer != NULL) {
FreePool (InfoTypesBuffer);
}
if (DataBlock != NULL) {
FreePool (DataBlock);
}
}
}
if (HandleBuffer != NULL) {
FreePool (HandleBuffer);
}
if ((*AcpiDataBlock == NULL) || (*AcpiDataSize == 0)) {
return EFI_NOT_FOUND;
}
return Status;
}
/**
Retrieve all available Image info by Fmp protocol, and attach them
to the tail of Mother board health record.
@param[out] MotherBoardData Point to the buffer of EFI_LAST_UPDATE_DATA
in mother board health record
@param[out] MotherBoardSize totoal length of all EFI_LAST_UPDATE_DATA data
@retval EFI_SUCCESS Fmp info was collected successfully
@retval EFI_OUT_OF_RESOURCES There is not enough memory resource.
**/
EFI_STATUS
AttachAllFmpInfoToEnd (
OUT UINT8 **MotherBoardData,
OUT UINTN *MotherBoardSize
)
{
EFI_STATUS Status;
EFI_FIRMWARE_MANAGEMENT_PROTOCOL *Fmp;
EFI_HANDLE *HandleBuffer;
UINTN NumberOfHandles;
UINTN Index;
UINT8 Index2;
EFI_FIRMWARE_IMAGE_DESCRIPTOR *FmpImageInfoBuf;
UINTN ImageInfoSize;
UINT32 FmpImageInfoDescriptorVer;
UINT8 FmpImageInfoCount;
UINTN DescriptorSize;
UINT32 PackageVersion;
CHAR16 *PackageVersionName;
UINTN RecordCount;
UINT8 *ImageInfoHead;
UINT64 *LastUpdateTimeValue;
UINT8 *CapsuleUpdateValue;
UINT16 *CapsuleUpdateLastValue;
EFI_TIME CapsuleLastUdpateTime;
EFI_GUID CapsuleUpdateGuid;
UINTN NumOfCapsuleUpdate;
CHAR16 CapsuleUpdate[16];
EFI_STATUS CapsuleStatus;
RecordCount = 0;
ImageInfoHead = NULL;
FmpImageInfoBuf = NULL;
LastUpdateTimeValue = NULL;
CapsuleUpdateLastValue = NULL;
CapsuleUpdateValue = NULL;
CapsuleStatus = EFI_SUCCESS;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiFirmwareManagementProtocolGuid,
NULL,
&NumberOfHandles,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "FMP protocol is EFI_NOT_FOUND\n"));
return Status;
}
*MotherBoardData = AllocateZeroPool (sizeof (EFI_LAST_UPDATE_DATA) * NumberOfHandles);
if (*MotherBoardData == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto EXIT;
}
ImageInfoHead = *MotherBoardData;
for (Index = 0; Index < NumberOfHandles; Index++) {
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiFirmwareManagementProtocolGuid,
(VOID **) &Fmp
);
if (EFI_ERROR (Status)) {
continue;
}
ImageInfoSize = 0;
Status = Fmp->GetImageInfo (
Fmp,
&ImageInfoSize,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL
);
if (Status != EFI_BUFFER_TOO_SMALL) {
continue;
}
FmpImageInfoBuf = AllocateZeroPool (ImageInfoSize);
if (FmpImageInfoBuf == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto EXIT;
}
PackageVersionName = NULL;
Status = Fmp->GetImageInfo (
Fmp,
&ImageInfoSize, // ImageInfoSize
FmpImageInfoBuf, // ImageInfo
&FmpImageInfoDescriptorVer, // DescriptorVersion
&FmpImageInfoCount, // DescriptorCount
&DescriptorSize, // DescriptorSize
&PackageVersion, // PackageVersion
&PackageVersionName // PackageVersionName
);
//
// If FMP GetInformation interface failed, skip this resource
//
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "FMP (%d) ImageInfo - %r\n", Index, Status));
FreePool (FmpImageInfoBuf);
continue;
}
//
//Check CapsuleLast
//
Status = GetVariable2 (CAPSULELAST, &gEfiCapsuleReportGuid, (VOID **) &CapsuleUpdateLastValue, NULL);
if (!EFI_ERROR (Status)) {
NumOfCapsuleUpdate = (UINT16) StrHexToUintn (&CapsuleUpdateLastValue[sizeof ("Capsule") - 1]);
for (Index2 = 0; Index2 <= NumOfCapsuleUpdate; Index2++) {
UnicodeSPrint (CapsuleUpdate, sizeof (CapsuleUpdate), L"%s%04X", CAPSULE_VAR_NAME, Index2);
Status = GetVariable2 (CapsuleUpdate, &gEfiCapsuleReportGuid, (VOID **) &CapsuleUpdateValue, NULL);
if (!EFI_ERROR (Status)) {
CopyMem (&CapsuleStatus, CapsuleUpdateValue + OFFSET_OF (EFI_CAPSULE_RESULT_VARIABLE_HEADER,
CapsuleStatus), sizeof (EFI_STATUS));
if (EFI_ERROR (CapsuleStatus)) {
continue;
}
CopyGuid (&CapsuleUpdateGuid,
(EFI_GUID *) (CapsuleUpdateValue +
sizeof (EFI_CAPSULE_RESULT_VARIABLE_HEADER) +
OFFSET_OF (EFI_CAPSULE_RESULT_VARIABLE_FMP, UpdateImageTypeId)));
if (CompareGuid (&FmpImageInfoBuf->ImageTypeId, &CapsuleUpdateGuid)) {
CopyMem (&CapsuleLastUdpateTime,
CapsuleUpdateValue +
OFFSET_OF (EFI_CAPSULE_RESULT_VARIABLE_HEADER, CapsuleProcessed), sizeof (EFI_TIME));
Status = gRT->SetVariable (
VARNAME_LASTUPDATETIME,
&FmpImageInfoBuf->ImageTypeId,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
sizeof (EFI_TIME),
&CapsuleLastUdpateTime
);
}
if (CapsuleUpdateValue != NULL) {
FreePool (CapsuleUpdateValue);
}
} else {
Status = EFI_SUCCESS;
continue;
}
}
if (CapsuleUpdateLastValue != NULL) {
FreePool (CapsuleUpdateLastValue);
}
} else {
Status = EFI_SUCCESS;
}
//
// combine all LastUdpateTime and EsrtID here
//
Status = GetVariable2 (VARNAME_LASTUPDATETIME, &FmpImageInfoBuf->ImageTypeId, (VOID **) &LastUpdateTimeValue, NULL);
if (!EFI_ERROR (Status) && (LastUpdateTimeValue != NULL)) {
CopyMem (ImageInfoHead, LastUpdateTimeValue, sizeof (EFI_TIME));
} else {
ZeroMem (ImageInfoHead, sizeof (EFI_TIME));
Status = EFI_SUCCESS;
}
ImageInfoHead = ImageInfoHead + sizeof (EFI_TIME);
CopyMem (ImageInfoHead, &FmpImageInfoBuf->ImageTypeId, sizeof (EFI_GUID));
ImageInfoHead = ImageInfoHead + sizeof (EFI_GUID);
RecordCount++;
if (PackageVersionName != NULL) {
FreePool (PackageVersionName);
}
if (LastUpdateTimeValue != NULL) {
FreePool (LastUpdateTimeValue);
}
FreePool (FmpImageInfoBuf);
}
*MotherBoardSize = sizeof (EFI_LAST_UPDATE_DATA) * RecordCount;
EXIT:
if (HandleBuffer != NULL) {
FreePool (HandleBuffer);
}
return Status;
}
/**
This function scan ACPI table entry point.
@return ACPI table entry pointer
**/
VOID *
SearchAcpiTablePointer (
VOID
)
{
EFI_ACPI_3_0_ROOT_SYSTEM_DESCRIPTION_POINTER *Rsdp;
EFI_ACPI_DESCRIPTION_HEADER *Entry;
EFI_STATUS Status;
Entry = NULL;
Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **) &mAcpiTableProtocol);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_INFO, "locate gEfiAcpiTableProtocolGuid failed, status[%x].\n", Status));
return NULL;
}
//
// Find ACPI table RSD_PTR from the system table.
//
Status = EfiGetSystemConfigurationTable (&gEfiAcpiTableGuid, (VOID **) &Rsdp);
if (EFI_ERROR (Status)) {
Status = EfiGetSystemConfigurationTable (&gEfiAcpi10TableGuid, (VOID **) &Rsdp);
}
if (EFI_ERROR (Status) || (Rsdp == NULL)) {
DEBUG ((EFI_D_INFO, "Can't find RSD_PTR from system table! \n"));
return NULL;
} else if (Rsdp->Revision >= EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION && Rsdp->XsdtAddress != 0) {
Entry = (EFI_ACPI_DESCRIPTION_HEADER *) (UINTN) Rsdp->XsdtAddress;
} else if (Rsdp->RsdtAddress != 0) {
Entry = (EFI_ACPI_DESCRIPTION_HEADER *) (UINTN) Rsdp->RsdtAddress;
}
if (Entry == NULL) {
DEBUG ((EFI_D_INFO, "Both XsdtAddress and RsdtAddress are NULL! \n"));
return NULL;
}
return Entry;
}
/**
This function scan ACPI table entry point by its signature.
@param Xsdt XSDT table entry point.
@param Signature ACPI table signature.
@return ACPI table entry point.
**/
VOID *
ScanTableInXSDT (
IN EFI_ACPI_DESCRIPTION_HEADER *Xsdt,
IN UINT32 Signature
)
{
UINTN Index;
UINT32 EntryCount;
UINT64 EntryPtr;
UINTN BasePtr;
EFI_ACPI_DESCRIPTION_HEADER *Table;
if (Xsdt == NULL) {
return NULL;
}
EntryCount = (Xsdt->Length - sizeof (EFI_ACPI_DESCRIPTION_HEADER)) / sizeof (UINT64);
BasePtr = (UINTN)(Xsdt + 1);
for (Index = 0; Index < EntryCount; Index ++) {
CopyMem (&EntryPtr, (VOID *) (BasePtr + Index * sizeof (UINT64)), sizeof (UINT64));
Table = (EFI_ACPI_DESCRIPTION_HEADER *) ((UINTN) (EntryPtr));
if (Table->Signature == Signature) {
return Table;
}
}
return NULL;
}
/**
This function scan PHAT table which was created in READY_TO_BOOT, and update it when EXIT_BOOT_SERVICES
Even is triggered.
@param[in] AcpiPhatTablePointer A pointer to the EFI_ACPI_DESCRIPTION_HEADER instance.
@param[in] AcpiBasicBootPerformancePointer A pointer to the BOOT_PERFORMANCE_TABLE instance.
@param[in] TelemetryVariable A pointer to the PLATFORM_TELEMETRY_VARIABLE instance.
**/
VOID
SearchAndUpdatePhatTable (
IN EFI_ACPI_DESCRIPTION_HEADER *AcpiPhatTablePointer,
IN BOOT_PERFORMANCE_TABLE *AcpiBasicBootPerformancePointer,
IN MOTHER_BOARD_HEALTH_VARIABLE *TelemetryVariable
)
{
UINT8 *PhatPointer;
EFI_ACPI_PLATFORM_TELEMETRY_RECORD_HEADER *TelemetryRecordHeader;
UINT8 *HealthRecord;
UINTN TotalRecordLength;
UINTN TelemetryDataLength;
EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE *MBRecordHead;
EFI_ACPI_MOTHERBOARD_HEALTH_DATA *MBRecordData;
TotalRecordLength = 0;
HealthRecord = NULL;
MBRecordHead = NULL;
MBRecordData = NULL;
if (AcpiPhatTablePointer->Length > sizeof (EFI_ACPI_DESCRIPTION_HEADER)) {
TelemetryDataLength = AcpiPhatTablePointer->Length - sizeof (EFI_ACPI_DESCRIPTION_HEADER);
} else {
DEBUG ((EFI_D_ERROR, "PHAT table is not existed or corrupted \n"));
return;
}
//
// PHAT entry.
//
PhatPointer = (UINT8 *) AcpiPhatTablePointer + sizeof (EFI_ACPI_DESCRIPTION_HEADER);
for (TotalRecordLength = 0; TotalRecordLength < TelemetryDataLength - sizeof (EFI_ACPI_PLATFORM_TELEMETRY_RECORD_HEADER); ) {
TelemetryRecordHeader = (EFI_ACPI_PLATFORM_TELEMETRY_RECORD_HEADER *) PhatPointer;
if (TelemetryRecordHeader->RecordType == FirmwareHealthDataRecord
&& (TelemetryRecordHeader->RecordLength > sizeof (EFI_ACPI_PLATFORM_TELEMETRY_RECORD_HEADER))) {
//
// found driver health records
//
HealthRecord = (UINT8 *) TelemetryRecordHeader;
MBRecordHead = (EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE *) HealthRecord;
if (CompareGuid (&MBRecordHead->DeviceSignature, &gAdapterInfoMotherBoardHealthGuid)) {
MBRecordData = (EFI_ACPI_MOTHERBOARD_HEALTH_DATA *)(HealthRecord + MBRecordHead->DeviceSpecificDataOffset);
MBRecordData->MeanBootTime = TelemetryVariable->MeanBootTime;
MBRecordData->CurrentBootTime = AcpiBasicBootPerformancePointer->BasicBoot.OsLoaderStartImageStart;
MBRecordData->NumberOfBootsSinceUpdate = TelemetryVariable->NumberOfBootsSinceUpdate;
//
// Current Boot time over 50%(default) means NotHealth
//
if (PcdGet8 (PcdBootTimeOverPercentage) != 0) {
if ((DivU64x32 (MAX_UINT64, (UINT32) PcdGet8 (PcdBootTimeOverPercentage)) < TelemetryVariable->MeanBootTime)) {
DEBUG((EFI_D_ERROR, "MeanBootTime Overflow, Return Unhealthy.\n"));
((EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE *) TelemetryRecordHeader)->AmHealthy = TelemetryUnhealthy;
} else if (AcpiBasicBootPerformancePointer->BasicBoot.OsLoaderStartImageStart >
(TelemetryVariable->MeanBootTime + DivU64x32 (MultU64x32 (TelemetryVariable->MeanBootTime, (UINT32) PcdGet8 (PcdBootTimeOverPercentage)), 100))) {
((EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE *) TelemetryRecordHeader)->AmHealthy = TelemetryUnhealthy;
}
} else {
if (AcpiBasicBootPerformancePointer->BasicBoot.OsLoaderStartImageStart > TelemetryVariable->MeanBootTime) {
((EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE *) TelemetryRecordHeader)->AmHealthy = TelemetryUnhealthy;
}
}
AcpiPlatformChecksum (
(UINT8 *) AcpiPhatTablePointer,
AcpiPhatTablePointer->Length
);
break;
}
}
if (TelemetryRecordHeader->RecordLength > sizeof (EFI_ACPI_PLATFORM_TELEMETRY_RECORD_HEADER)) {
PhatPointer += TelemetryRecordHeader->RecordLength;
//
// check record border.
//
TotalRecordLength += TelemetryRecordHeader->RecordLength;
} else {
break;
}
}
}
/**
Update the final record to Mother board variable.
@attention This function may receive untrusted input.
Data and AcpiBasicBootPerformancePointer is external input, so this function will validate its data structure within this buffer before use.
@param[in] Data The contents for the variable.
@param[in] AcpiBasicBootPerformancePointer This structure contains BasicBoot performance record.
@retval EFI_SUCCESS The firmware has successfully stored the variable and its data as
defined by the Attributes.
@retval EFI_INVALID_PARAMETER The input was NULL or calculating the result overflow of MeanBootTime.
**/
EFI_STATUS
SetMotherBoardVariable (
IN VOID *Data,
IN BOOT_PERFORMANCE_TABLE *AcpiBasicBootPerformancePointer
)
{
EFI_STATUS Status;
MOTHER_BOARD_HEALTH_VARIABLE *TelemetryVariable;
if ((Data == NULL) || (AcpiBasicBootPerformancePointer == NULL)) {
return EFI_INVALID_PARAMETER;
}
TelemetryVariable = (MOTHER_BOARD_HEALTH_VARIABLE *) Data;
if (TelemetryVariable->NumberOfBootsSinceUpdate != 0) {
//
// Multiplication overflow check.
//
if (DivU64x32 (MAX_UINT64,(UINT32) TelemetryVariable->NumberOfBootsSinceUpdate) > TelemetryVariable->MeanBootTime ) {
//
// Addition overflow check.
//
if ((MAX_UINT64 - AcpiBasicBootPerformancePointer->BasicBoot.OsLoaderStartImageStart) <
(TelemetryVariable->MeanBootTime * TelemetryVariable->NumberOfBootsSinceUpdate)) {
DEBUG((EFI_D_ERROR, "Addition MeanBootTime Overflow.\n"));
return EFI_INVALID_PARAMETER;
}
} else {
DEBUG((EFI_D_ERROR, "Multiplication MeanBootTime Overflow.\n"));
return EFI_INVALID_PARAMETER;
}
}
//
// Search driver health from Acpi table and update them.
//
TelemetryVariable->MeanBootTime = DivU64x32 (TelemetryVariable->MeanBootTime * TelemetryVariable->NumberOfBootsSinceUpdate
+ AcpiBasicBootPerformancePointer->BasicBoot.OsLoaderStartImageStart,
(UINT32)(TelemetryVariable->NumberOfBootsSinceUpdate + 1));
TelemetryVariable->NumberOfBootsSinceUpdate += 1;
Status = gRT->SetVariable (
MOTHERBOARD_HEALTH_DATA_NAME,
&gMotherBoardHealthVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
sizeof (MOTHER_BOARD_HEALTH_VARIABLE),
TelemetryVariable
);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Failed to set the MOTHERBOARD_HEALTH_DATA_NAME record into a variable. Status = %r\n", Status));
return Status;
}
return EFI_SUCCESS;
}
/**
Report status code listener of PHAT. This is used to collect performance data
for OsLoaderStartImageStart in PHAT.
@param[in] CodeType Indicates the type of status code being reported.
@param[in] Value Describes the current status of a hardware or software entity.
This included information about the class and subclass that is used to
classify the entity as well as an operation.
@param[in] Instance The enumeration of a hardware or software entity within
the system. Valid instance numbers start with 1.
@param[in] CallerId This optional parameter may be used to identify the caller.
This parameter allows the status code driver to apply different rules to
different callers.
@param[in] Data This optional parameter may be used to pass additional data.
@retval EFI_SUCCESS Status code is what we expected.
@retval EFI_UNSUPPORTED Status code not supported.
**/
EFI_STATUS
EFIAPI
PhatStatusCodeListenerDxe (
IN EFI_STATUS_CODE_TYPE CodeType,
IN EFI_STATUS_CODE_VALUE Value,
IN UINT32 Instance,
IN EFI_GUID *CallerId,
IN EFI_STATUS_CODE_DATA *Data
)
{
EFI_ACPI_DESCRIPTION_HEADER *AcpiEntry;
EFI_ACPI_DESCRIPTION_HEADER *AcpiPhatTablePointer;
FIRMWARE_PERFORMANCE_TABLE *AcpiFpdtTablePointer;
BOOT_PERFORMANCE_TABLE *AcpiBasicBootPerformancePointer;
EFI_STATUS Status;
MOTHER_BOARD_HEALTH_VARIABLE TelemetryVariable;
UINTN TelemetryBufferSize;
AcpiEntry = NULL;
AcpiPhatTablePointer = NULL;
AcpiFpdtTablePointer = NULL;
AcpiBasicBootPerformancePointer = NULL;
TelemetryBufferSize = 0;
//
// Check whether status code is what we are interested in.
//
if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) != EFI_PROGRESS_CODE) {
return EFI_UNSUPPORTED;
}
ZeroMem (&TelemetryVariable, sizeof (MOTHER_BOARD_HEALTH_VARIABLE));
Status = EFI_SUCCESS;
if (Value == PcdGet32 (PcdProgressCodeOsLoaderLoad)) {
//
// Progress code for OS Loader LoadImage.
//
if (AcpiPhatTablePointer == NULL) {
return Status;
}
} else if (Value == (EFI_SOFTWARE_EFI_BOOT_SERVICE | EFI_SW_BS_PC_EXIT_BOOT_SERVICES)) {
AcpiEntry = SearchAcpiTablePointer ();
AcpiPhatTablePointer = ScanTableInXSDT (AcpiEntry, EFI_ACPI_PLATFORM_HEALTH_ASSESSMENT_TABLE_SIGNATURE);
if (AcpiPhatTablePointer == NULL) {
goto Done;
}
//
// Update OS Loader StartImage Start for UEFI boot.
//
AcpiFpdtTablePointer = ScanTableInXSDT (AcpiEntry, EFI_ACPI_6_1_FIRMWARE_PERFORMANCE_DATA_TABLE_SIGNATURE);
if (AcpiFpdtTablePointer == NULL) {
goto Done;
}
AcpiBasicBootPerformancePointer = (BOOT_PERFORMANCE_TABLE *) (UINTN)AcpiFpdtTablePointer->BootPointerRecord.BootPerformanceTablePointer;
TelemetryBufferSize = sizeof (MOTHER_BOARD_HEALTH_VARIABLE);
Status = gRT->GetVariable (
MOTHERBOARD_HEALTH_DATA_NAME,
&gMotherBoardHealthVariableGuid,
NULL,
&TelemetryBufferSize,
&TelemetryVariable
);
if (Status != EFI_SUCCESS) {
DEBUG ((EFI_D_ERROR, "Failed to get the MotherBoardHealth variable Status = %r\n", Status));
goto Done;
}
//
// Update the final record to Mother board variable.
//
Status = SetMotherBoardVariable (&TelemetryVariable, AcpiBasicBootPerformancePointer);
if (Status != EFI_SUCCESS) {
DEBUG ((EFI_D_ERROR, "Failed to set the MotherBoardHealth record into a variable. Status = %r\n", Status));
goto Done;
}
//
// Update the final record to PHAT table
//
SearchAndUpdatePhatTable (AcpiPhatTablePointer, AcpiBasicBootPerformancePointer, &TelemetryVariable);
Done:
//
// Set HwErrRec variable.
//
Status = SetDriverHealthHwErrRecVariable (AcpiPhatTablePointer);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Failed to set the Health record into a HwErrRec#### variable. Status = %r\n", Status));
}
//
// Unregister boot time report status code listener.
//
mRscHandlerProtocol->Unregister (PhatStatusCodeListenerDxe);
} else {
//
// Ignore else progress code.
//
Status = EFI_UNSUPPORTED;
}
return Status;
}
/**
Convert Telemetry Aip data to Telemetry ACPI data.
@param[in] AipRecord A pointer to the FVI record buffer,does not contain header information.
May be NULL in order to determine the size buffer needed.
@param[out] AcpiAipRecord A pointer to the FVI record buffer.
@param[in] LengthOfFVI A pointer to the Length of FVI record.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_INVALID_PARAMETER LengthOfFVI is NULL.
@retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the results.
**/
EFI_STATUS
ConvertFVIDataFromAipToAcpi (
IN UINT8 *AipRecord,
OUT UINT8 **AcpiAipRecord,
IN UINT16 *LengthOfFVI
)
{
if ((LengthOfFVI == NULL) || (AcpiAipRecord == NULL)) {
DEBUG ((EFI_D_ERROR, "ConvertFVIDataFromAipToAcpi : Invalid Parameter.\n"));
return EFI_INVALID_PARAMETER;
}
*AcpiAipRecord = NULL;
if (AipRecord == NULL) {
DEBUG ((EFI_D_INFO, "Get length of FVI successfully and then return.\n"));
return EFI_SUCCESS;
}
*AcpiAipRecord = AllocateZeroPool (*LengthOfFVI);
if (*AcpiAipRecord == NULL) {
DEBUG ((EFI_D_ERROR, "EFI_OUT_OF_RESOURCES : AcpiAipBuffHead allocate failed.\n"));
return EFI_OUT_OF_RESOURCES;
}
CopyMem (*AcpiAipRecord, AipRecord, *LengthOfFVI);
return EFI_SUCCESS;
}
/**
Get Aip data from Hobs, these records won't be updated in DXE phase.
@param[in, out] InformationBlock A pointer to the InformationBlock structure which contains details.
May be NULL in order to determine the size buffer needed.
@param[out] InformationBlockSize The size of the InformationBlock in bytes.
**/
VOID
GetAipHobRecords (
IN OUT UINT8 **InformationBlock,
OUT UINT16 *InformationBlockSize
)
{
EFI_PEI_HOB_POINTERS Hob;
UINT8 *RecordPtr;
UINT8 *FviRecord;
UINT8 *AcpiAipRecord;
UINT16 RecordSize;
UINT8 HobHeadLength;
UINT8 *HobBuffTemp;
TELEMETRY_FIRMWARE_VERSION_INFO2_HOB *FviHob;
EFI_STATUS Status;
FviHob = NULL;
HobBuffTemp = NULL;
AcpiAipRecord = NULL;
HobHeadLength = OFFSET_OF (TELEMETRY_FIRMWARE_VERSION_INFO2_HOB, Records);
if (InformationBlockSize == NULL) {
DEBUG ((EFI_D_ERROR, "GetAipHobRecords : Invalid Parameter.\n"));
return;
}
*InformationBlockSize = 0;
if (InformationBlock != NULL){
HobBuffTemp = *InformationBlock;
}
//
// Get FVI HOB
//
for (Hob.Raw = GetHobList (); !END_OF_HOB_LIST (Hob); Hob.Raw = GET_NEXT_HOB (Hob)) {
if ((GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_GUID_EXTENSION) && (CompareGuid (&Hob.Guid->Name, &gTelemetryVersionHobGuid))) {
FviHob = (TELEMETRY_FIRMWARE_VERSION_INFO2_HOB *) GET_GUID_HOB_DATA (Hob.Raw);
RecordPtr = (UINT8 *) FviHob->Records;
if (FviHob->Header.HobLength > HobHeadLength) {
RecordSize = FviHob->Header.HobLength - HobHeadLength;
//
// Convert Telemetry Aip data to Telemetry ACPI data or get Length of FVI.
//
if (InformationBlock != NULL) {
//
// Record need 16-bit alignment in ConvertFVIDataFromAipToAcpi process.
//
FviRecord = AllocatePool (RecordSize * sizeof(UINT8));
if (FviRecord == NULL) {
DEBUG ((EFI_D_ERROR, "EFI_OUT_OF_RESOURCES : AcpiAipBuffHead allocate failed.\n"));
*InformationBlockSize = 0;
return;
}
CopyMem (FviRecord, RecordPtr, RecordSize);
Status = ConvertFVIDataFromAipToAcpi (FviRecord, &AcpiAipRecord, &RecordSize);
if (Status == EFI_OUT_OF_RESOURCES) {
DEBUG ((EFI_D_ERROR, "Failed to process ConvertFVIDataFromAipToAcpi due to lack of resources!\n"));
FreePool (FviRecord);
*InformationBlockSize = 0;
return;
}
FreePool (FviRecord);
}
} else {
continue;
}
if (InformationBlock != NULL) {
CopyMem (HobBuffTemp, AcpiAipRecord, RecordSize);
HobBuffTemp += RecordSize;
FreePool (AcpiAipRecord);
}
*InformationBlockSize += (UINT16) RecordSize;
}
}
}
/**
Get FVI Aip data from Protocols.
@param[in, out] TempAipBuffHeader A pointer to the buffer which follows up with hob record.
May be NULL in order to determine the size buffer needed.
@param[in, out] TotalLength The size of telemetry Aip data in bytes.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_INVALID_PARAMETER HandleBuffer is NULL.
@retval EFI_INVALID_PARAMETER Aip is NULL.
@retval EFI_UNSUPPORTED The InformationType is not known.
@retval EFI_DEVICE_ERROR The device reported an error.
@retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the results.
**/
EFI_STATUS
CollectAipInfoFromProtocol (
IN OUT UINT8 **TempAipBuffHeader,
IN OUT UINT16 *TotalLength
)
{
EFI_STATUS Status;
EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
EFI_GUID *InfoTypesBuffer;
UINTN InfoTypeBufferCount;
UINTN TypeIndex;
BOOLEAN Supported;
VOID *DataBlock;
UINTN BufferSize;
UINT8 *FviRecordHeader;
UINTN Index;
UINT8 *AcpiAipRecord;
UINT16 AcpiFviSize;
FviRecordHeader = NULL;
DataBlock = NULL;
AcpiAipRecord = NULL;
BufferSize = 0;
AcpiFviSize = 0;
if (TotalLength == NULL) {
return EFI_INVALID_PARAMETER;
}
*TotalLength = 0;
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiAdapterInformationProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "gEfiAdapterInformationProtocolGuid locate failed, status = [%x] \n", Status));
//
// gEfiAdapterInformationProtocolGuid protocol not installed yet.
//
return Status;
}
for (Index = 0; Index < HandleCount ; Index++) {
Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiAdapterInformationProtocolGuid, (VOID **) &Aip);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "HandleProtocol gEfiAdapterInformationProtocolGuid failed. \n"));
} else {
InfoTypesBuffer = NULL;
InfoTypeBufferCount = 0;
//
// Check AIP
//
Status = Aip->GetSupportedTypes (Aip, &InfoTypesBuffer, &InfoTypeBufferCount);
if (EFI_ERROR (Status) || InfoTypesBuffer == NULL) {
continue;
}
//
// Check whether the AIP instance has FVI information block.
//
Supported = FALSE;
for (TypeIndex = 0; TypeIndex < InfoTypeBufferCount; TypeIndex++) {
if (CompareGuid (&InfoTypesBuffer[TypeIndex], &gTelemetryVersionRecord2Guid)) {
Supported = TRUE;
break;
}
}
FreePool (InfoTypesBuffer);
if (!Supported) {
continue;
}
Status = Aip->GetInformation (Aip, &gTelemetryVersionRecord2Guid, &DataBlock, &BufferSize);
if (EFI_ERROR (Status) || DataBlock == NULL || BufferSize == 0) {
continue;
} else {
//
// skip Revision & RecordCount in EFI_AIP_TELEMETRY_VERSION_RECORD, find the valid
//
FviRecordHeader = (UINT8 *) ((EFI_AIP_TELEMETRY_VERSION_RECORD *) DataBlock)->Record;
}
//
// kick Revision & RecordCount out.
//
if (BufferSize > OFFSET_OF (EFI_AIP_TELEMETRY_VERSION_RECORD, Record)) {
AcpiFviSize = AcpiFviRecordSize * (UINT16 ) (((EFI_AIP_TELEMETRY_VERSION_RECORD *) DataBlock)->RecordCount);
DEBUG ((EFI_D_INFO, "AcpiFviSize = %d\n", AcpiFviSize));
if (TempAipBuffHeader != NULL) {
//
// Convert Telemetry Aip data to Telemetry ACPI data.
//
Status = ConvertFVIDataFromAipToAcpi (FviRecordHeader, &AcpiAipRecord, &AcpiFviSize);
if (Status == EFI_OUT_OF_RESOURCES) {
DEBUG ((EFI_D_ERROR, "Failed to process ConvertFVIDataFromAipToAcpi due to lack of resources!\n"));
FreePool (DataBlock);
return EFI_OUT_OF_RESOURCES;
}
}
if ((MAX_UINT16 - *TotalLength) < AcpiFviSize) {
DEBUG ((EFI_D_ERROR, "TotalLength is Greater than 4G,abandon this FVI record.\n"));
FreePool (DataBlock);
if (AcpiAipRecord != NULL) {
FreePool (AcpiAipRecord);
}
continue;
}
if (TempAipBuffHeader != NULL) {
CopyMem (*TempAipBuffHeader, AcpiAipRecord, AcpiFviSize);
*TempAipBuffHeader += AcpiFviSize;
FreePool (AcpiAipRecord);
}
*TotalLength += (UINT16) AcpiFviSize;
}
FreePool (DataBlock);
}
}
return EFI_SUCCESS;
}
/**
Get Aip data from Health drivers listed in mDriverHealthSupportList.
@param[out] AcpiAipBuffHead A pointer to the buffer which follows up with FVI record.
May be NULL in order to determine the size buffer needed.
@param[out] LengthOfDriverHealth The size of telemetry Aip driver health
data in bytes.
**/
VOID
CollectAipInfoFromHealthDriver (
IN OUT UINT8 **AcpiAipBuffHead,
OUT UINT32 *LengthOfDriverHealth
)
{
EFI_STATUS Status;
UINTN Index;
UINT8 *DriverHealthData;
UINTN DriverHealthSize;
UINT8 *MotherBoardTemp;
UINTN MotherBoardTempSize;
UINT8 *MotherBoardFinal;
UINTN MotherBoardFinalSize;
DriverHealthData = NULL;
DriverHealthSize = 0;
MotherBoardTemp = NULL;
MotherBoardTempSize = 0;
MotherBoardFinal = NULL;
MotherBoardFinalSize = 0;
if (LengthOfDriverHealth == NULL) {
DEBUG ((EFI_D_ERROR, "CollectAipInfoFromHealthDriver : Invalid Parameter.\n"));
return;
}
*LengthOfDriverHealth = 0;
for (Index = 0; mDriverHealthSupportList[Index] != NULL; Index++ ) {
Status = DriverHealthAipDataCollection (mDriverHealthSupportList[Index], &DriverHealthData, &DriverHealthSize);
//
// Integrate all driver health records
//
if (!EFI_ERROR (Status) && (DriverHealthSize > sizeof (EFI_ACPI_TELEMETRY_HEALTH_DATA_RECORD_STRUCTURE))) {
if (CompareGuid (mDriverHealthSupportList[Index], &gAdapterInfoMotherBoardHealthGuid)) {
DEBUG ((EFI_D_INFO, "One Mother Board record is matched! \n"));
Status = AttachAllFmpInfoToEnd (&MotherBoardTemp, &MotherBoardTempSize);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_INFO, "Get Mother Board Health special Info failed .....! \n", Status));
} else {
//
// combine MotherBoardTemp(with 1 instance by default) and More (from Fmp protocol).
//
MotherBoardFinalSize = DriverHealthSize + MotherBoardTempSize - sizeof (EFI_LAST_UPDATE_DATA);
((EFI_ACPI_PLATFORM_TELEMETRY_RECORD_HEADER *) DriverHealthData)->RecordLength = (UINT16) MotherBoardFinalSize;
if ((DriverHealthSize > sizeof (EFI_LAST_UPDATE_DATA)) && (MotherBoardTempSize > 0)) {
MotherBoardFinal = AllocateZeroPool (MotherBoardFinalSize);
if (MotherBoardFinal == NULL) {
DEBUG ((EFI_D_ERROR, "MotherBoardFinal allocate failed, LastUpdateTime can't be updated! \n"));
continue;
}
//
// Override the default LastUpdateTime and EsrtID
//
CopyMem (MotherBoardFinal, DriverHealthData, DriverHealthSize);
CopyMem (MotherBoardFinal + DriverHealthSize - sizeof (EFI_LAST_UPDATE_DATA), MotherBoardTemp, MotherBoardTempSize);
if (AcpiAipBuffHead != NULL) {
//
// To attach integrated mother board info to the end of record.
//
CopyMem (*AcpiAipBuffHead, MotherBoardFinal, MotherBoardFinalSize);
}
DriverHealthSize = MotherBoardFinalSize;
} else {
DEBUG ((EFI_D_INFO, "Mother Board Health record is corrupted or its length is 0, drop it!! \n"));
}
}
if (MotherBoardTemp != NULL) {
FreePool (MotherBoardTemp);
}
if (MotherBoardFinal != NULL) {
FreePool (MotherBoardFinal);
}
} else {
if ((MAX_UINT32 - *LengthOfDriverHealth) < DriverHealthSize) {
DEBUG ((EFI_D_ERROR, "LengthOfDriverHealth is Greater than 4G,abandon this driverHealth record.\n"));
if (DriverHealthData != NULL) {
FreePool (DriverHealthData);
}
continue;
}
if (AcpiAipBuffHead != NULL) {
//
// To handle other driver health record
//
CopyMem (*AcpiAipBuffHead, DriverHealthData, DriverHealthSize);
}
}
if (AcpiAipBuffHead != NULL) {
*AcpiAipBuffHead = *AcpiAipBuffHead + DriverHealthSize;
}
*LengthOfDriverHealth = *LengthOfDriverHealth + (UINT32) DriverHealthSize;
DEBUG ((EFI_D_INFO, "Driver Health -- [%g] has been converted successfully \n", *mDriverHealthSupportList[Index]));
}
if (DriverHealthData != NULL) {
FreePool (DriverHealthData);
}
}
}
/**
Initialize the header of the Platform Health Assessment Table.
@param[out] Header The header of the ACPI Table.
@param[in] OemId The OEM ID.
@param[in] OemTableId The OEM table ID for the Phat.
**/
VOID
InitPhatAcpiTableHeader (
OUT EFI_ACPI_DESCRIPTION_HEADER *Header,
IN UINT8 *OemId,
IN UINT64 *OemTableId
)
{
ZeroMem (Header, sizeof (EFI_ACPI_DESCRIPTION_HEADER));
Header->Signature = EFI_ACPI_PLATFORM_HEALTH_ASSESSMENT_TABLE_SIGNATURE;
//
// tatal length (FVI, Driver Health).
//
Header->Length = 0;
Header->Revision = EFI_ACPI_PLATFORM_HEALTH_ASSESSMENT_TABLE_VERSION;
Header->Checksum = 0;
CopyMem (Header->OemId, OemId, sizeof (Header->OemId));
CopyMem (&Header->OemTableId, OemTableId, sizeof (UINT64));
Header->OemRevision = EFI_ACPI_OEM_REVISION;
Header->CreatorId = EFI_ACPI_CREATOR_ID;
Header->CreatorRevision = EFI_ACPI_CREATOR_REVISION;
}
/**
Initialize the Platform Health Assessment Table.
Convert AIP data block to telementry ACPI style, and publish it.
@param[in] InfoBlock Point to AIP data block.
@param[in] InfoBlockSize The size of AIP data.
@retval EFI_SUCCESS Success
@retval EFI_OUT_OF_RESOURCES Status code not supported.
@retval EFI_INVALID_PARAMETER Either AcpiTableBuffer is NULL,
TableKey is NULL, or
AcpiTableBufferSize and the size
field embedded in the ACPI table
pointed to by AcpiTableBuffer
are not in sync.
@retval EFI_ACCESS_DENIED The table signature matches a table already
present in the system and platform policy
does not allow duplicate tables of this type.
**/
EFI_STATUS
InstallAcpiTelemetryTable (
VOID *InfoBlock,
UINTN InfoBlockSize
)
{
EFI_ACPI_DESCRIPTION_HEADER *AcpiEntry;
UINT8 *Table;
EFI_ACPI_DESCRIPTION_HEADER AcpiHead;
EFI_STATUS Status;
if (mPhatInstalled) {
Status = mAcpiTableProtocol->UninstallAcpiTable (
mAcpiTableProtocol,
mTableKey
);
if (EFI_ERROR (Status)) {
return Status;
}
mPhatInstalled = FALSE;
}
AcpiEntry = SearchAcpiTablePointer ();
ZeroMem (&AcpiHead, sizeof (EFI_ACPI_DESCRIPTION_HEADER));
//
// Initialize the header of the Platform Health Assessment Table.
//
InitPhatAcpiTableHeader (&AcpiHead, AcpiEntry->OemId, &AcpiEntry->OemTableId);
//
// Allocate resource to hold the ACPI table.
//
Table = AllocateZeroPool (InfoBlockSize + sizeof (EFI_ACPI_DESCRIPTION_HEADER));
if (Table == NULL) {
return EFI_OUT_OF_RESOURCES;
}
AcpiHead.Length = sizeof (EFI_ACPI_DESCRIPTION_HEADER) + (UINT32)InfoBlockSize;
CopyMem (Table, &AcpiHead, sizeof (EFI_ACPI_DESCRIPTION_HEADER));
//
// Connect a telemetry data to ACPI table header.
//
CopyMem (Table + sizeof (EFI_ACPI_DESCRIPTION_HEADER), InfoBlock, InfoBlockSize);
AcpiPlatformChecksum (
(UINT8 *) Table,
((EFI_ACPI_DESCRIPTION_HEADER *)Table)->Length
);
//
// Install or update the Phat table.
//
Status = mAcpiTableProtocol->InstallAcpiTable (
mAcpiTableProtocol,
Table,
AcpiHead.Length,
&mTableKey
);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_INFO, "Install Phat AcpiTable failed, Status = [%x]. \n", Status));
} else {
DEBUG ((EFI_D_INFO, "Install Phat AcpiTable successfull. \n"));
mPhatInstalled = TRUE;
}
if (Table != NULL) {
FreePool (Table);
}
return Status;
}
/**
Get length of telemetry from hob and aip.
@param LengthOfFVI Pointer to the length of FVI.
@param LengthOfDriverHealth Pointer to total length of telemetry Driver Health data.
@retval EFI_SUCCESS Get total length successful.
@retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the results.
@retval EFI_INVALID_PARAMETER LengthOfFVI and LengthOfDriverHealth is NULL.
**/
EFI_STATUS
EFIAPI
GetLengthOfTelemetryData (
IN OUT UINT16 *LengthOfFVI,
IN OUT UINT32 *LengthOfDriverHealth
)
{
EFI_STATUS Status;
UINT16 HobLength;
HobLength = 0;
Status = EFI_SUCCESS;
if ((LengthOfFVI == NULL) && (LengthOfDriverHealth == NULL)) {
DEBUG ((EFI_D_ERROR, "GetLengthOfTelemetryData : Invalid Parameter.\n"));
return EFI_INVALID_PARAMETER;
}
if (LengthOfFVI != NULL) {
*LengthOfFVI = 0;
//
// Get FVI length from Aip Hob.
//
GetAipHobRecords (NULL, &HobLength);
//
// Get FVI length from Aip Protocol.
//
Status = CollectAipInfoFromProtocol (NULL, LengthOfFVI);
if (Status == EFI_OUT_OF_RESOURCES) {
DEBUG ((EFI_D_ERROR, "Failed to process CollectAipInfoFromProtocol due to lack of resources!\n"));
return Status;
}
if ((MAX_UINT16 - *LengthOfFVI) < (HobLength + AcpiComPonentHeadSize)) {
DEBUG ((EFI_D_ERROR, "LengthOfFVI is Greater than 4G,set the value of LengthOfFVI to zero.\n"));
*LengthOfFVI = AcpiComPonentHeadSize;
} else {
*LengthOfFVI += HobLength;
*LengthOfFVI += AcpiComPonentHeadSize;
}
}
if (LengthOfDriverHealth != NULL) {
*LengthOfDriverHealth = 0;
//
// Get Driver health length form aip protocol.
//
CollectAipInfoFromHealthDriver (NULL, LengthOfDriverHealth);
if (LengthOfFVI != NULL) {
if ((MAX_UINT32 - *LengthOfFVI) < *LengthOfDriverHealth) {
DEBUG ((EFI_D_ERROR, "TotalLength is Greater than UINT16,set the value of LengthOfDriverHealth to zero.\n"));
LengthOfDriverHealth = 0;
}
}
}
return EFI_SUCCESS;
}
/**
Collect AIP data including FVI and driver health, then convert them to Acpi format.
**/
VOID
EFIAPI
BuildPhatAcpiTable (VOID)
{
EFI_STATUS Status;
UINT16 LengthOfFVI;
UINT32 LengthOfDriverHealth;
UINT32 TotalLength;
UINT8 *TempAipBuffHeader;
UINT8 *AcpiAipBuff;
UINT8 *AcpiAipBuffHead;
UINT16 HobLength;
EFI_ACPI_DESCRIPTION_HEADER *AcpiEntry;
EFI_ACPI_DESCRIPTION_HEADER *AcpiPhatTablePointer;
LengthOfFVI = 0;
LengthOfDriverHealth = 0;
TotalLength = 0;
HobLength = 0;
TempAipBuffHeader = NULL;
AcpiAipBuff = NULL;
AcpiAipBuffHead = NULL;
AcpiEntry = NULL;
AcpiPhatTablePointer = NULL;
//
// Get LengthOfFVI and LengthOfDriverHealth.
//
Status = GetLengthOfTelemetryData (&LengthOfFVI, &LengthOfDriverHealth);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Failed to Get length of telemetry data. Status = %r\n", Status));
return;
}
DEBUG ((EFI_D_INFO, "Searching FVI is done: LengthOfFVI ==[%d], LengthOfDriverHealth == [%d] \n", LengthOfFVI, LengthOfDriverHealth));
TotalLength = LengthOfFVI + LengthOfDriverHealth;
AcpiAipBuff = AllocateZeroPool (TotalLength);
AcpiAipBuffHead = AcpiAipBuff;
if (AcpiAipBuff == NULL) {
DEBUG ((EFI_D_ERROR, "EFI_OUT_OF_RESOURCES : AcpiAipBuff allocate failed.\n"));
return;
}
((EFI_COMPONENT_VERSION_DATA *) AcpiAipBuffHead)->Revision = TELEMETRY_FVI_DATA_RECORD_REVISION;
((EFI_COMPONENT_VERSION_DATA *) AcpiAipBuffHead)->RecordLength = LengthOfFVI;
((EFI_COMPONENT_VERSION_DATA *) AcpiAipBuffHead)->RecordCount = (LengthOfFVI - AcpiComPonentHeadSize) / AcpiFviRecordSize;
AcpiAipBuffHead = AcpiAipBuff + AcpiComPonentHeadSize;
if (LengthOfFVI != AcpiComPonentHeadSize) {
//
// Get Aip data from Hobs.
//
GetAipHobRecords (&AcpiAipBuffHead, &HobLength);
TempAipBuffHeader = AcpiAipBuffHead + HobLength;
//
// Get Aip data from Protocol.
//
Status = CollectAipInfoFromProtocol (&TempAipBuffHeader, &LengthOfFVI);
if (Status == EFI_OUT_OF_RESOURCES) {
DEBUG ((EFI_D_ERROR, "Failed to process CollectAipInfoFromProtocol due to lack of resources!\n"));
if (AcpiAipBuff != NULL) {
FreePool (AcpiAipBuff);
}
return;
}
}
//
// Ready to add driver health record if they can be found
//
if (LengthOfDriverHealth != 0) {
CollectAipInfoFromHealthDriver (&TempAipBuffHeader, &LengthOfDriverHealth);
}
if (TempAipBuffHeader == NULL || LengthOfDriverHealth == 0) {
DEBUG ((EFI_D_ERROR, "No Driver health record was found. \n"));
}
//
// Initialize the Platform Health Assessment Table.
//
Status = InstallAcpiTelemetryTable (AcpiAipBuff, TotalLength);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Install Telemetry ACPI table failed, Status = [%x] \n", Status));
}
//
// Clear all Telemetry HwErrRec variable.
//
Status = ClearAllTelemetryHwErrRec ();
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Failed to ClearAll HwErrRec#### variable. Status = %r\n", Status));
}
AcpiEntry = SearchAcpiTablePointer();
if (AcpiEntry == NULL) {
DEBUG((EFI_D_ERROR, "EFI_NOT_FUND : AcpiEntry is NULL.\n"));
return;
}
//
// Set HwErrRec variable.
//
AcpiPhatTablePointer = ScanTableInXSDT (AcpiEntry, EFI_ACPI_PLATFORM_HEALTH_ASSESSMENT_TABLE_SIGNATURE);
if (AcpiPhatTablePointer == NULL) {
DEBUG ((EFI_D_ERROR, "EFI_NOT_FUND : AcpiPhatTablePointer is NULL.\n"));
}
Status = SetDriverHealthHwErrRecVariable (AcpiPhatTablePointer);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Failed to set the Health record into a HwErrRec#### variable. Status = %r\n", Status));
}
if (AcpiAipBuff != NULL) {
FreePool (AcpiAipBuff);
}
}
/**
Update PHAT callback function.
@param Event Pointer to this event
@param Context Event handler private data.
**/
VOID
EFIAPI
UpdatePhatAcpiTableCallback (
IN EFI_EVENT Event,
IN VOID *Context
)
{
BuildPhatAcpiTable();
}
/**
ReadytoBootEvent build PHAT.
@param Event Pointer to this event
@param Context Event handler private data.
**/
VOID
EFIAPI
InstallPhatAcpiTableCallback (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_EVENT AcpiEvent;
EFI_STATUS Status;
if (Event != NULL) {
gBS->CloseEvent (Event);
}
BuildPhatAcpiTable();
//
// Register rebuild PHAT table event
//
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_CALLBACK,
UpdatePhatAcpiTableCallback,
NULL,
&gPlatformAcpiUpdateEventGuid,
&AcpiEvent
);
ASSERT_EFI_ERROR (Status);
return;
}
/**
Fixup internal data pointers so that the services can be called in virtual mode.
@param[in] Event The event registered.
@param[in] Context Event context. Not used in this event handler.
**/
VOID
EFIAPI
TelemetryDriverHealthVirtualAddressChangeEvent (
IN EFI_EVENT Event,
IN VOID *Context
)
{
gRT->ConvertPointer (0, (VOID *) &mMotherBoardHealthRecBuffer);
}
/**
This is driver entry point to register the notification event.
@param[in] ImageHandle A handle for the image that is initializing this driver
@param[in] SystemTable A pointer to the EFI system table
@retval EFI_SUCCESS The initialization finished successfully.
**/
EFI_STATUS
EFIAPI
DxeTelemetryAcpiLibConstructor (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_EVENT Event;
EFI_STATUS Status;
//
// Create Address Change event
//
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_NOTIFY,
TelemetryDriverHealthVirtualAddressChangeEvent,
NULL,
&gEfiEventVirtualAddressChangeGuid,
&Event
);
ASSERT_EFI_ERROR (Status);
//
// Get Report Status Code Handler Protocol.
//
Status = gBS->LocateProtocol (&gEfiRscHandlerProtocolGuid, NULL, (VOID **) &mRscHandlerProtocol);
ASSERT_EFI_ERROR (Status);
//
// Register report status code listener for OS Loader load and start.
//
Status = mRscHandlerProtocol->Register (PhatStatusCodeListenerDxe, TPL_HIGH_LEVEL);
ASSERT_EFI_ERROR (Status);
Status = EfiCreateEventReadyToBootEx (
TPL_CALLBACK,
InstallPhatAcpiTableCallback,
NULL,
&Event
);
if (EFI_ERROR (Status)) {
return Status;
}
return EFI_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink