From 3af9b38827fff65fc7e303eec07448b6d04d5f0f Mon Sep 17 00:00:00 2001 From: xli24 Date: Fri, 25 Dec 2009 06:49:52 +0000 Subject: Move Status Code Handler modules for PI implementation to MdeModulePkg. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@9608 6f19259b-4bc3-4df7-8a09-765794883524 --- .../StatusCodeHandler/Pei/MemoryStausCodeWorker.c | 153 ++++++++++++++ .../StatusCodeHandler/Pei/SerialStatusCodeWorker.c | 152 ++++++++++++++ .../StatusCodeHandler/Pei/StatusCodeHandlerPei.c | 69 +++++++ .../StatusCodeHandler/Pei/StatusCodeHandlerPei.h | 117 +++++++++++ .../StatusCodeHandler/Pei/StatusCodeHandlerPei.inf | 64 ++++++ .../RuntimeDxe/MemoryStatusCodeWorker.c | 110 ++++++++++ .../RuntimeDxe/SerialStatusCodeWorker.c | 148 ++++++++++++++ .../RuntimeDxe/StatusCodeHandlerRuntimeDxe.c | 222 +++++++++++++++++++++ .../RuntimeDxe/StatusCodeHandlerRuntimeDxe.h | 126 ++++++++++++ .../RuntimeDxe/StatusCodeHandlerRuntimeDxe.inf | 70 +++++++ .../StatusCodeHandler/Smm/MemoryStatusCodeWorker.c | 114 +++++++++++ .../StatusCodeHandler/Smm/SerialStatusCodeWorker.c | 148 ++++++++++++++ .../StatusCodeHandler/Smm/StatusCodeHandlerSmm.c | 90 +++++++++ .../StatusCodeHandler/Smm/StatusCodeHandlerSmm.h | 122 +++++++++++ .../StatusCodeHandler/Smm/StatusCodeHandlerSmm.inf | 66 ++++++ 15 files changed, 1771 insertions(+) create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Pei/MemoryStausCodeWorker.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Pei/SerialStatusCodeWorker.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.h create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.inf create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/MemoryStatusCodeWorker.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/SerialStatusCodeWorker.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.h create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.inf create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Smm/MemoryStatusCodeWorker.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Smm/SerialStatusCodeWorker.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.c create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.h create mode 100644 MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.inf (limited to 'MdeModulePkg') diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Pei/MemoryStausCodeWorker.c b/MdeModulePkg/Universal/StatusCodeHandler/Pei/MemoryStausCodeWorker.c new file mode 100644 index 0000000000..f04a17495a --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Pei/MemoryStausCodeWorker.c @@ -0,0 +1,153 @@ +/** @file + PEI memory status code worker. + + Copyright (c) 2006 - 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerPei.h" + +/** + Worker function to create one memory status code GUID'ed HOB, + using PacketIndex to identify the packet. + + @param PacketIndex Index of records packet. + + @return Pointer to the memory status code packet. + +**/ +MEMORY_STATUSCODE_PACKET_HEADER * +CreateMemoryStatusCodePacket ( + UINT16 PacketIndex + ) +{ + MEMORY_STATUSCODE_PACKET_HEADER *PacketHeader; + + // + // Build GUID'ed HOB with PCD defined size. + // + PacketHeader = BuildGuidHob ( + &gMemoryStatusCodeRecordGuid, + PcdGet16 (PcdStatusCodeMemorySize) * 1024 + sizeof (MEMORY_STATUSCODE_PACKET_HEADER) + ); + ASSERT (PacketHeader != NULL); + + PacketHeader->MaxRecordsNumber = (PcdGet16 (PcdStatusCodeMemorySize) * 1024) / sizeof (MEMORY_STATUSCODE_RECORD); + PacketHeader->PacketIndex = PacketIndex; + PacketHeader->RecordIndex = 0; + + return PacketHeader; +} + +/** + Create the first memory status code GUID'ed HOB as initialization for memory status code worker. + + @retval EFI_SUCCESS The GUID'ed HOB is created successfully. + +**/ +EFI_STATUS +MemoryStatusCodeInitializeWorker ( + VOID + ) +{ + // + // Create first memory status code GUID'ed HOB. + // + CreateMemoryStatusCodePacket (0); + + return EFI_SUCCESS; +} + + +/** + Report status code into GUID'ed HOB. + + This function reports status code into GUID'ed HOB. If not all packets are full, then + write status code into available entry. Otherwise, create a new packet for it. + + @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation. + @param CodeType Indicates the type of status code being reported. + @param Value Describes the current status of a hardware or + software entity. This includes information about the class and + subclass that is used to classify the entity as well as an operation. + For progress codes, the operation is the current activity. + For error codes, it is the exception.For debug codes,it is not defined at this time. + @param Instance The enumeration of a hardware or software entity within + the system. A system may contain multiple entities that match a class/subclass + pairing. The instance differentiates between them. An instance of 0 indicates + that instance information is unavailable, not meaningful, or not relevant. + Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS The function always return EFI_SUCCESS. + +**/ +EFI_STATUS +MemoryStatusCodeReportWorker ( + IN CONST EFI_PEI_SERVICES **PeiServices, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN CONST EFI_GUID *CallerId, + IN CONST EFI_STATUS_CODE_DATA *Data OPTIONAL + ) +{ + + EFI_PEI_HOB_POINTERS Hob; + MEMORY_STATUSCODE_PACKET_HEADER *PacketHeader; + MEMORY_STATUSCODE_RECORD *Record; + UINT16 PacketIndex; + + Record = NULL; + PacketIndex = 0; + + // + // Journal GUID'ed HOBs to find empty record entry. if found, then save status code in it. + // otherwise, create a new GUID'ed HOB. + // + Hob.Raw = GetFirstGuidHob (&gMemoryStatusCodeRecordGuid); + while (Hob.Raw != NULL) { + PacketHeader = (MEMORY_STATUSCODE_PACKET_HEADER *) GET_GUID_HOB_DATA (Hob.Guid); + + // + // Check whether pccket is full or not. + // + if (PacketHeader->RecordIndex < PacketHeader->MaxRecordsNumber) { + Record = (MEMORY_STATUSCODE_RECORD *) (PacketHeader + 1); + Record = &Record[PacketHeader->RecordIndex++]; + break; + } + // + // Cache number of found packet in PacketIndex. + // + PacketIndex++; + + Hob.Raw = GetNextGuidHob (&gMemoryStatusCodeRecordGuid, Hob.Raw); + } + + if (Record == NULL) { + // + // No available entry found, so create new packet. + // + PacketHeader = CreateMemoryStatusCodePacket (PacketIndex); + + Record = (MEMORY_STATUSCODE_RECORD *) (PacketHeader + 1); + Record = &Record[PacketHeader->RecordIndex++]; + } + + Record->CodeType = CodeType; + Record->Instance = Instance; + Record->Value = Value; + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Pei/SerialStatusCodeWorker.c b/MdeModulePkg/Universal/StatusCodeHandler/Pei/SerialStatusCodeWorker.c new file mode 100644 index 0000000000..e6ff3d078f --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Pei/SerialStatusCodeWorker.c @@ -0,0 +1,152 @@ +/** @file + Serial I/O status code reporting worker. + + Copyright (c) 2006 - 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerPei.h" + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation. + @param CodeType Indicates the type of status code being reported. + @param Value Describes the current status of a hardware or + software entity. This includes information about the class and + subclass that is used to classify the entity as well as an operation. + For progress codes, the operation is the current activity. + For error codes, it is the exception.For debug codes,it is not defined at this time. + @param Instance The enumeration of a hardware or software entity within + the system. A system may contain multiple entities that match a class/subclass + pairing. The instance differentiates between them. An instance of 0 indicates + that instance information is unavailable, not meaningful, or not relevant. + Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code reported to serial I/O successfully. + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + IN CONST EFI_PEI_SERVICES **PeiServices, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN CONST EFI_GUID *CallerId, + IN CONST EFI_STATUS_CODE_DATA *Data OPTIONAL + ) +{ + CHAR8 *Filename; + CHAR8 *Description; + CHAR8 *Format; + CHAR8 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE]; + UINT32 ErrorLevel; + UINT32 LineNumber; + UINTN CharCount; + BASE_LIST Marker; + + Buffer[0] = '\0'; + + if (Data != NULL && + ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) { + // + // Print ASSERT() information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "\n\rPEI_ASSERT!: %a (%d): %a\n\r", + Filename, + LineNumber, + Description + ); + } else if (Data != NULL && + ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) { + // + // Print DEBUG() information into output buffer. + // + CharCount = AsciiBSPrint ( + Buffer, + sizeof (Buffer), + Format, + Marker + ); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE) { + // + // Print ERROR information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "ERROR: C%x:V%x I%x", + CodeType, + Value, + Instance + ); + + if (CallerId != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + " %g", + CallerId + ); + } + + if (Data != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + " %x", + Data + ); + } + + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + "\n\r" + ); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) { + // + // Print PROGRESS information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "PROGRESS CODE: V%x I%x\n\r", + Value, + Instance + ); + } else { + // + // Code type is not defined. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "Undefined: C%x:V%x I%x\n\r", + CodeType, + Value, + Instance + ); + } + + // + // Call SerialPort Lib function to do print. + // + SerialPortWrite ((UINT8 *) Buffer, CharCount); + + return EFI_SUCCESS; +} + diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.c b/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.c new file mode 100644 index 0000000000..cdd532537c --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.c @@ -0,0 +1,69 @@ +/** @file + Report Status Code Handler PEIM which produces general handlers and hook them + onto the PEI status code router. + + Copyright (c) 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerPei.h" + +/** + Entry point of Status Code PEIM. + + This function is the entry point of this Status Code PEIM. + It initializes supported status code devices according to PCD settings, + and installs Status Code PPI. + + @param FileHandle Handle of the file being invoked. + @param PeiServices Describes the list of possible PEI Services. + + @retval EFI_SUCESS The entry point of DXE IPL PEIM executes successfully. + +**/ +EFI_STATUS +EFIAPI +StatusCodeHandlerPeiEntry ( + IN EFI_PEI_FILE_HANDLE FileHandle, + IN CONST EFI_PEI_SERVICES **PeiServices + ) +{ + EFI_STATUS Status; + EFI_PEI_RSC_HANDLER_PPI *RscHandlerPpi; + + Status = PeiServicesLocatePpi ( + &gEfiPeiRscHandlerPpiGuid, + 0, + NULL, + (VOID **) &RscHandlerPpi + ); + ASSERT_EFI_ERROR (Status); + + // + // Dispatch initialization request to sub-statuscode-devices. + // If enable UseSerial, then initialize serial port. + // if enable UseMemory, then initialize memory status code worker. + // + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + Status = SerialPortInitialize(); + ASSERT_EFI_ERROR (Status); + Status = RscHandlerPpi->Register (SerialStatusCodeReportWorker); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseMemory)) { + Status = MemoryStatusCodeInitializeWorker (); + ASSERT_EFI_ERROR (Status); + Status = RscHandlerPpi->Register (MemoryStatusCodeReportWorker); + ASSERT_EFI_ERROR (Status); + } + + return EFI_SUCCESS; +} + diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.h b/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.h new file mode 100644 index 0000000000..31c998bb5c --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.h @@ -0,0 +1,117 @@ +/** @file + Internal include file for Status Code Handler PEIM. + + Copyright (c) 2006 - 2009, Intel Corporation + All rights reserved. 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. + +**/ + +#ifndef __STATUS_CODE_HANDLER_PEI_H__ +#define __STATUS_CODE_HANDLER_PEI_H__ + + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation. + @param CodeType Indicates the type of status code being reported. + @param Value Describes the current status of a hardware or + software entity. This includes information about the class and + subclass that is used to classify the entity as well as an operation. + For progress codes, the operation is the current activity. + For error codes, it is the exception.For debug codes,it is not defined at this time. + @param Instance The enumeration of a hardware or software entity within + the system. A system may contain multiple entities that match a class/subclass + pairing. The instance differentiates between them. An instance of 0 indicates + that instance information is unavailable, not meaningful, or not relevant. + Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code reported to serial I/O successfully. + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + IN CONST EFI_PEI_SERVICES **PeiServices, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN CONST EFI_GUID *CallerId, + IN CONST EFI_STATUS_CODE_DATA *Data OPTIONAL + ); + + +/** + Create the first memory status code GUID'ed HOB as initialization for memory status code worker. + + @retval EFI_SUCCESS The GUID'ed HOB is created successfully. + +**/ +EFI_STATUS +MemoryStatusCodeInitializeWorker ( + VOID + ); + +/** + Report status code into GUID'ed HOB. + + This function reports status code into GUID'ed HOB. If not all packets are full, then + write status code into available entry. Otherwise, create a new packet for it. + + @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation. + @param CodeType Indicates the type of status code being reported. + @param Value Describes the current status of a hardware or + software entity. This includes information about the class and + subclass that is used to classify the entity as well as an operation. + For progress codes, the operation is the current activity. + For error codes, it is the exception.For debug codes,it is not defined at this time. + @param Instance The enumeration of a hardware or software entity within + the system. A system may contain multiple entities that match a class/subclass + pairing. The instance differentiates between them. An instance of 0 indicates + that instance information is unavailable, not meaningful, or not relevant. + Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS The function always return EFI_SUCCESS. + +**/ +EFI_STATUS +MemoryStatusCodeReportWorker ( + IN CONST EFI_PEI_SERVICES **PeiServices, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN CONST EFI_GUID *CallerId, + IN CONST EFI_STATUS_CODE_DATA *Data OPTIONAL + ); + +#endif + + diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.inf b/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.inf new file mode 100644 index 0000000000..189da71d0b --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.inf @@ -0,0 +1,64 @@ +#/** @file +# Report Status Code Handler PEIM which produces general handlers and hook them +# onto the PEI status code router. +# +# Copyright (c) 2009, Intel Corporation. +# +# All rights reserved. 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. +# +# +#**/ + +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = StatusCodeHandlerPei + FILE_GUID = 9D225237-FA01-464C-A949-BAABC02D31D0 + MODULE_TYPE = PEIM + ENTRY_POINT = StatusCodeHandlerPeiEntry + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF EBC (EBC is only for build) +# + +[Sources.common] + StatusCodeHandlerPei.c + StatusCodeHandlerPei.h + SerialStatusCodeWorker.c + MemoryStausCodeWorker.c + +[Packages] + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + +[LibraryClasses] + PeimEntryPoint + PeiServicesLib + PcdLib + HobLib + SerialPortLib + ReportStatusCodeLib + PrintLib + DebugLib + +[Guids] + gMemoryStatusCodeRecordGuid ## SOMETIMES_CONSUMES ## HOB + +[Ppis] + gEfiPeiRscHandlerPpiGuid ## CONSUMES + +[FeaturePcd.common] + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeUseMemory + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeUseSerial + +[Pcd.common] + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1|PcdStatusCodeUseMemory + +[Depex] + gEfiPeiRscHandlerPpiGuid diff --git a/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/MemoryStatusCodeWorker.c b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/MemoryStatusCodeWorker.c new file mode 100644 index 0000000000..2d8fcadf56 --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/MemoryStatusCodeWorker.c @@ -0,0 +1,110 @@ +/** @file + Runtime memory status code worker. + + Copyright (c) 2006 - 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerRuntimeDxe.h" + +RUNTIME_MEMORY_STATUSCODE_HEADER *mRtMemoryStatusCodeTable; + +/** + Initialize runtime memory status code table as initialization for runtime memory status code worker + + @retval EFI_SUCCESS Runtime memory status code table successfully initialized. + +**/ +EFI_STATUS +RtMemoryStatusCodeInitializeWorker ( + VOID + ) +{ + // + // Allocate runtime memory status code pool. + // + mRtMemoryStatusCodeTable = AllocateRuntimePool ( + sizeof (RUNTIME_MEMORY_STATUSCODE_HEADER) + + PcdGet16 (PcdStatusCodeMemorySize) * 1024 + ); + ASSERT (mRtMemoryStatusCodeTable != NULL); + + mRtMemoryStatusCodeTable->RecordIndex = 0; + mRtMemoryStatusCodeTable->NumberOfRecords = 0; + mRtMemoryStatusCodeTable->MaxRecordsNumber = + (PcdGet16 (PcdStatusCodeMemorySize) * 1024) / sizeof (MEMORY_STATUSCODE_RECORD); + + return EFI_SUCCESS; +} + + +/** + Report status code into runtime memory. If the runtime pool is full, roll back to the + first record and overwrite it. + + @param CodeType Indicates the type of status code being reported. + @param 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 Instance The enumeration of a hardware or software entity within + the system. Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code successfully recorded in runtime memory status code table. + +**/ +EFI_STATUS +RtMemoryStatusCodeReportWorker ( + 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 OPTIONAL + ) +{ + MEMORY_STATUSCODE_RECORD *Record; + + // + // Locate current record buffer. + // + Record = (MEMORY_STATUSCODE_RECORD *) (mRtMemoryStatusCodeTable + 1); + Record = &Record[mRtMemoryStatusCodeTable->RecordIndex++]; + + // + // Save status code. + // + Record->CodeType = CodeType; + Record->Value = Value; + Record->Instance = Instance; + + // + // If record index equals to max record number, then wrap around record index to zero. + // + // The reader of status code should compare the number of records with max records number, + // If it is equal to or larger than the max number, then the wrap-around had happened, + // so the first record is pointed by record index. + // If it is less then max number, index of the first record is zero. + // + mRtMemoryStatusCodeTable->NumberOfRecords++; + if (mRtMemoryStatusCodeTable->RecordIndex == mRtMemoryStatusCodeTable->MaxRecordsNumber) { + // + // Wrap around record index. + // + mRtMemoryStatusCodeTable->RecordIndex = 0; + } + + return EFI_SUCCESS; +} + + + diff --git a/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/SerialStatusCodeWorker.c b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/SerialStatusCodeWorker.c new file mode 100644 index 0000000000..879eec3bc7 --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/SerialStatusCodeWorker.c @@ -0,0 +1,148 @@ +/** @file + Serial I/O status code reporting worker. + + Copyright (c) 2006 - 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerRuntimeDxe.h" + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param CodeType Indicates the type of status code being reported. + @param 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 Instance The enumeration of a hardware or software entity within + the system. Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code reported to serial I/O successfully. + @retval EFI_DEVICE_ERROR EFI serial device cannot work after ExitBootService() is called. + @retval EFI_DEVICE_ERROR EFI serial device cannot work with TPL higher than TPL_CALLBACK. + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + 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 OPTIONAL + ) +{ + CHAR8 *Filename; + CHAR8 *Description; + CHAR8 *Format; + CHAR8 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE]; + UINT32 ErrorLevel; + UINT32 LineNumber; + UINTN CharCount; + BASE_LIST Marker; + + Buffer[0] = '\0'; + + if (Data != NULL && + ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) { + // + // Print ASSERT() information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "\n\rDXE_ASSERT!: %a (%d): %a\n\r", + Filename, + LineNumber, + Description + ); + } else if (Data != NULL && + ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) { + // + // Print DEBUG() information into output buffer. + // + CharCount = AsciiBSPrint ( + Buffer, + sizeof (Buffer), + Format, + Marker + ); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE) { + // + // Print ERROR information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "ERROR: C%x:V%x I%x", + CodeType, + Value, + Instance + ); + + if (CallerId != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + " %g", + CallerId + ); + } + + if (Data != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + " %x", + Data + ); + } + + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + "\n\r" + ); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) { + // + // Print PROGRESS information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "PROGRESS CODE: V%x I%x\n\r", + Value, + Instance + ); + } else { + // + // Code type is not defined. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "Undefined: C%x:V%x I%x\n\r", + CodeType, + Value, + Instance + ); + } + + // + // Call SerialPort Lib function to do print. + // + SerialPortWrite ((UINT8 *) Buffer, CharCount); + + return EFI_SUCCESS; +} + diff --git a/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.c b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.c new file mode 100644 index 0000000000..497afaa5dc --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.c @@ -0,0 +1,222 @@ +/** @file + Status Code Handler Driver which produces general handlers and hook them + onto the DXE status code router. + + Copyright (c) 2006 - 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerRuntimeDxe.h" + +EFI_EVENT mVirtualAddressChangeEvent = NULL; +EFI_EVENT mExitBootServicesEvent = NULL; +EFI_RSC_HANDLER_PROTOCOL *mRscHandlerProtocol = NULL; + +/** + Unregister status code callback functions only available at boot time from + report status code router when exiting boot services. + + @param Event Event whose notification function is being invoked. + @param Context Pointer to the notification function's context, which is + always zero in current implementation. + +**/ +VOID +EFIAPI +UnregisterBootTimeHandlers ( + IN EFI_EVENT Event, + IN VOID *Context + ) +{ + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + mRscHandlerProtocol->Unregister (SerialStatusCodeReportWorker); + } +} + +/** + Virtual address change notification call back. It converts global pointer + to virtual address. + + @param Event Event whose notification function is being invoked. + @param Context Pointer to the notification function's context, which is + always zero in current implementation. + +**/ +VOID +EFIAPI +VirtualAddressChangeCallBack ( + IN EFI_EVENT Event, + IN VOID *Context + ) +{ + // + // Convert memory status code table to virtual address; + // + EfiConvertPointer ( + 0, + (VOID **) &mRtMemoryStatusCodeTable + ); +} + +/** + Dispatch initialization request to sub status code devices based on + customized feature flags. + +**/ +VOID +InitializationDispatcherWorker ( + VOID + ) +{ + EFI_PEI_HOB_POINTERS Hob; + EFI_STATUS Status; + MEMORY_STATUSCODE_PACKET_HEADER *PacketHeader; + MEMORY_STATUSCODE_RECORD *Record; + UINTN ExpectedPacketIndex; + UINTN Index; + VOID *HobStart; + + // + // If enable UseSerial, then initialize serial port. + // if enable UseRuntimeMemory, then initialize runtime memory status code worker. + // + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + // + // Call Serial Port Lib API to initialize serial port. + // + Status = SerialPortInitialize (); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseMemory)) { + Status = RtMemoryStatusCodeInitializeWorker (); + ASSERT_EFI_ERROR (Status); + } + + // + // Replay Status code which saved in GUID'ed HOB to all supported devices. + // + if (FeaturePcdGet (PcdStatusCodeReplayIn)) { + // + // Journal GUID'ed HOBs to find all record entry, if found, + // then output record to support replay device. + // + ExpectedPacketIndex = 0; + Hob.Raw = GetFirstGuidHob (&gMemoryStatusCodeRecordGuid); + HobStart = Hob.Raw; + while (Hob.Raw != NULL) { + PacketHeader = (MEMORY_STATUSCODE_PACKET_HEADER *) GET_GUID_HOB_DATA (Hob.Guid); + if (PacketHeader->PacketIndex == ExpectedPacketIndex) { + Record = (MEMORY_STATUSCODE_RECORD *) (PacketHeader + 1); + for (Index = 0; Index < PacketHeader->RecordIndex; Index++) { + // + // Dispatch records to devices based on feature flag. + // + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + SerialStatusCodeReportWorker ( + Record[Index].CodeType, + Record[Index].Value, + Record[Index].Instance, + NULL, + NULL + ); + } + if (FeaturePcdGet (PcdStatusCodeUseMemory)) { + RtMemoryStatusCodeReportWorker ( + Record[Index].CodeType, + Record[Index].Value, + Record[Index].Instance, + NULL, + NULL + ); + } + } + ExpectedPacketIndex++; + + // + // See whether there is gap of packet or not + // + if (HobStart != NULL) { + HobStart = NULL; + Hob.Raw = HobStart; + continue; + } + } else if (HobStart != NULL) { + // + // Cache the found packet for improve the performance + // + HobStart = Hob.Raw; + } + + Hob.Raw = GetNextGuidHob (&gMemoryStatusCodeRecordGuid, Hob.Raw); + } + } +} + +/** + Entry point of DXE Status Code Driver. + + This function is the entry point of this DXE Status Code Driver. + It initializes registers status code handlers, and registers event for EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE. + + @param ImageHandle The firmware allocated handle for the EFI image. + @param SystemTable A pointer to the EFI System Table. + + @retval EFI_SUCCESS The entry point is executed successfully. + +**/ +EFI_STATUS +EFIAPI +StatusCodeHandlerRuntimeDxeEntry ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +{ + EFI_STATUS Status; + + Status = gBS->LocateProtocol ( + &gEfiRscHandlerProtocolGuid, + NULL, + (VOID **) &mRscHandlerProtocol + ); + ASSERT_EFI_ERROR (Status); + + // + // Dispatch initialization request to supported devices + // + InitializationDispatcherWorker (); + + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + mRscHandlerProtocol->Register (SerialStatusCodeReportWorker, TPL_HIGH_LEVEL); + } + if (FeaturePcdGet (PcdStatusCodeUseMemory)) { + mRscHandlerProtocol->Register (RtMemoryStatusCodeReportWorker, TPL_HIGH_LEVEL); + } + + Status = gBS->CreateEventEx ( + EVT_NOTIFY_SIGNAL, + TPL_NOTIFY, + UnregisterBootTimeHandlers, + NULL, + &gEfiEventExitBootServicesGuid, + &mExitBootServicesEvent + ); + + Status = gBS->CreateEventEx ( + EVT_NOTIFY_SIGNAL, + TPL_NOTIFY, + VirtualAddressChangeCallBack, + NULL, + &gEfiEventVirtualAddressChangeGuid, + &mVirtualAddressChangeEvent + ); + ASSERT_EFI_ERROR (Status); + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.h b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.h new file mode 100644 index 0000000000..9986f1140f --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.h @@ -0,0 +1,126 @@ +/** @file + Internal include file for Status Code Handler Driver. + + Copyright (c) 2006 - 2009, Intel Corporation + All rights reserved. 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. + +**/ + +#ifndef __STATUS_CODE_HANDLER_RUNTIME_DXE_H__ +#define __STATUS_CODE_HANDLER_RUNTIME_DXE_H__ + +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// +// Runtime memory status code worker definition +// +typedef struct { + UINT32 RecordIndex; + UINT32 NumberOfRecords; + UINT32 MaxRecordsNumber; +} RUNTIME_MEMORY_STATUSCODE_HEADER; + +extern RUNTIME_MEMORY_STATUSCODE_HEADER *mRtMemoryStatusCodeTable; + +/** + Locates Serial I/O Protocol as initialization for serial status code worker. + + @retval EFI_SUCCESS Serial I/O Protocol is successfully located. + +**/ +EFI_STATUS +EfiSerialStatusCodeInitializeWorker ( + VOID + ); + + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param CodeType Indicates the type of status code being reported. + @param 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 Instance The enumeration of a hardware or software entity within + the system. Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code reported to serial I/O successfully. + @retval EFI_DEVICE_ERROR EFI serial device cannot work after ExitBootService() is called. + @retval EFI_DEVICE_ERROR EFI serial device cannot work with TPL higher than TPL_CALLBACK. + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + 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 OPTIONAL + ); + +/** + Initialize runtime memory status code table as initialization for runtime memory status code worker + + @retval EFI_SUCCESS Runtime memory status code table successfully initialized. + +**/ +EFI_STATUS +RtMemoryStatusCodeInitializeWorker ( + VOID + ); + +/** + Report status code into runtime memory. If the runtime pool is full, roll back to the + first record and overwrite it. + + @param CodeType Indicates the type of status code being reported. + @param 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 Instance The enumeration of a hardware or software entity within + the system. Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code successfully recorded in runtime memory status code table. + +**/ +EFI_STATUS +RtMemoryStatusCodeReportWorker ( + 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 OPTIONAL + ); + +#endif diff --git a/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.inf b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.inf new file mode 100644 index 0000000000..ec176eb086 --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.inf @@ -0,0 +1,70 @@ +#/** @file +# Status Code Handler Driver which produces general handlers and hook them +# onto the DXE status code router. +# +# Copyright (c) 2006 - 2009, Intel Corporation. +# +# All rights reserved. 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. +# +# +#**/ + +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = StatusCodeHandlerRuntimeDxe + FILE_GUID = 6C2004EF-4E0E-4BE4-B14C-340EB4AA5891 + MODULE_TYPE = DXE_RUNTIME_DRIVER + ENTRY_POINT = StatusCodeHandlerRuntimeDxeEntry + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF EBC +# + +[Sources.common] + StatusCodeHandlerRuntimeDxe.c + StatusCodeHandlerRuntimeDxe.h + SerialStatusCodeWorker.c + MemoryStatusCodeWorker.c + +[Packages] + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + +[LibraryClasses] + SerialPortLib + UefiRuntimeLib + MemoryAllocationLib + UefiBootServicesTableLib + UefiDriverEntryPoint + HobLib + PcdLib + PrintLib + ReportStatusCodeLib + DebugLib + SynchronizationLib + +[Guids] + gMemoryStatusCodeRecordGuid ## CONSUMES ## HOB + gEfiEventVirtualAddressChangeGuid ## CONSUMES ## Event + gEfiEventExitBootServicesGuid ## CONSUMES ## Event + +[Protocols] + gEfiRscHandlerProtocolGuid ## CONSUMES + +[FeaturePcd] + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeReplayIn + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeUseMemory + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeUseSerial + +[Pcd] + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize |128| PcdStatusCodeUseMemory + +[Depex] + gEfiRscHandlerProtocolGuid diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Smm/MemoryStatusCodeWorker.c b/MdeModulePkg/Universal/StatusCodeHandler/Smm/MemoryStatusCodeWorker.c new file mode 100644 index 0000000000..5672ebcd0c --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Smm/MemoryStatusCodeWorker.c @@ -0,0 +1,114 @@ +/** @file + Runtime memory status code worker. + + Copyright (c) 2006 - 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerSmm.h" + +RUNTIME_MEMORY_STATUSCODE_HEADER *mSmmMemoryStatusCodeTable; + +/** + Initialize SMM memory status code table as initialization for memory status code worker + + @retval EFI_SUCCESS SMM memory status code table successfully initialized. + +**/ +EFI_STATUS +MemoryStatusCodeInitializeWorker ( + VOID + ) +{ + EFI_STATUS Status; + // + // Allocate SMM memory status code pool. + // + Status = gSmst->SmmAllocatePool ( + EfiRuntimeServicesData, + sizeof (RUNTIME_MEMORY_STATUSCODE_HEADER) + PcdGet16 (PcdStatusCodeMemorySize) * 1024, + (VOID**)&mSmmMemoryStatusCodeTable + ); + + ASSERT_EFI_ERROR(Status); + ASSERT (mSmmMemoryStatusCodeTable != NULL); + + mSmmMemoryStatusCodeTable->RecordIndex = 0; + mSmmMemoryStatusCodeTable->NumberOfRecords = 0; + mSmmMemoryStatusCodeTable->MaxRecordsNumber = + (PcdGet16 (PcdStatusCodeMemorySize) * 1024) / sizeof (MEMORY_STATUSCODE_RECORD); + + return EFI_SUCCESS; +} + + +/** + Report status code into runtime memory. If the runtime pool is full, roll back to the + first record and overwrite it. + + @param CodeType Indicates the type of status code being reported. + @param 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 Instance The enumeration of a hardware or software entity within + the system. Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code successfully recorded in runtime memory status code table. + +**/ +EFI_STATUS +MemoryStatusCodeReportWorker ( + 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 OPTIONAL + ) +{ + MEMORY_STATUSCODE_RECORD *Record; + + // + // Locate current record buffer. + // + Record = (MEMORY_STATUSCODE_RECORD *) (mSmmMemoryStatusCodeTable + 1); + Record = &Record[mSmmMemoryStatusCodeTable->RecordIndex++]; + + // + // Save status code. + // + Record->CodeType = CodeType; + Record->Value = Value; + Record->Instance = Instance; + + // + // If record index equals to max record number, then wrap around record index to zero. + // + // The reader of status code should compare the number of records with max records number, + // If it is equal to or larger than the max number, then the wrap-around had happened, + // so the first record is pointed by record index. + // If it is less then max number, index of the first record is zero. + // + mSmmMemoryStatusCodeTable->NumberOfRecords++; + if (mSmmMemoryStatusCodeTable->RecordIndex == mSmmMemoryStatusCodeTable->MaxRecordsNumber) { + // + // Wrap around record index. + // + mSmmMemoryStatusCodeTable->RecordIndex = 0; + } + + return EFI_SUCCESS; +} + + + diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Smm/SerialStatusCodeWorker.c b/MdeModulePkg/Universal/StatusCodeHandler/Smm/SerialStatusCodeWorker.c new file mode 100644 index 0000000000..3b408a2410 --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Smm/SerialStatusCodeWorker.c @@ -0,0 +1,148 @@ +/** @file + Serial I/O status code reporting worker. + + Copyright (c) 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerSmm.h" + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param CodeType Indicates the type of status code being reported. + @param 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 Instance The enumeration of a hardware or software entity within + the system. Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code reported to serial I/O successfully. + @retval EFI_DEVICE_ERROR EFI serial device cannot work after ExitBootService() is called. + @retval EFI_DEVICE_ERROR EFI serial device cannot work with TPL higher than TPL_CALLBACK. + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + 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 OPTIONAL + ) +{ + CHAR8 *Filename; + CHAR8 *Description; + CHAR8 *Format; + CHAR8 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE]; + UINT32 ErrorLevel; + UINT32 LineNumber; + UINTN CharCount; + BASE_LIST Marker; + + Buffer[0] = '\0'; + + if (Data != NULL && + ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) { + // + // Print ASSERT() information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "\n\rDXE_ASSERT!: %a (%d): %a\n\r", + Filename, + LineNumber, + Description + ); + } else if (Data != NULL && + ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) { + // + // Print DEBUG() information into output buffer. + // + CharCount = AsciiBSPrint ( + Buffer, + sizeof (Buffer), + Format, + Marker + ); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE) { + // + // Print ERROR information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "ERROR: C%x:V%x I%x", + CodeType, + Value, + Instance + ); + + if (CallerId != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + " %g", + CallerId + ); + } + + if (Data != NULL) { + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + " %x", + Data + ); + } + + CharCount += AsciiSPrint ( + &Buffer[CharCount - 1], + (sizeof (Buffer) - (sizeof (Buffer[0]) * CharCount)), + "\n\r" + ); + } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) { + // + // Print PROGRESS information into output buffer. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "PROGRESS CODE: V%x I%x\n\r", + Value, + Instance + ); + } else { + // + // Code type is not defined. + // + CharCount = AsciiSPrint ( + Buffer, + sizeof (Buffer), + "Undefined: C%x:V%x I%x\n\r", + CodeType, + Value, + Instance + ); + } + + // + // Call SerialPort Lib function to do print. + // + SerialPortWrite ((UINT8 *) Buffer, CharCount); + + return EFI_SUCCESS; +} + diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.c b/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.c new file mode 100644 index 0000000000..fc6c7e9a5a --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.c @@ -0,0 +1,90 @@ +/** @file + Status Code Handler Driver which produces general handlers and hook them + onto the SMM status code router. + + Copyright (c) 2009, Intel Corporation + All rights reserved. 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 "StatusCodeHandlerSmm.h" + +EFI_SMM_RSC_HANDLER_PROTOCOL *mRscHandlerProtocol = NULL; + + +/** + Dispatch initialization request to sub status code devices based on + customized feature flags. + +**/ +VOID +InitializationDispatcherWorker ( + VOID + ) +{ + EFI_STATUS Status; + + // + // If enable UseSerial, then initialize serial port. + // if enable UseRuntimeMemory, then initialize runtime memory status code worker. + // + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + // + // Call Serial Port Lib API to initialize serial port. + // + Status = SerialPortInitialize (); + ASSERT_EFI_ERROR (Status); + } + if (FeaturePcdGet (PcdStatusCodeUseMemory)) { + Status = MemoryStatusCodeInitializeWorker (); + ASSERT_EFI_ERROR (Status); + } +} + +/** + Entry point of SMM Status Code Driver. + + This function is the entry point of SMM Status Code Driver. + + @param ImageHandle The firmware allocated handle for the EFI image. + @param SystemTable A pointer to the EFI System Table. + + @retval EFI_SUCCESS The entry point is executed successfully. + +**/ +EFI_STATUS +EFIAPI +StatusCodeHandlerSmmEntry ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +{ + EFI_STATUS Status; + + Status = gSmst->SmmLocateProtocol ( + &gEfiSmmRscHandlerProtocolGuid, + NULL, + (VOID **) &mRscHandlerProtocol + ); + ASSERT_EFI_ERROR (Status); + + // + // Dispatch initialization request to supported devices + // + InitializationDispatcherWorker (); + + if (FeaturePcdGet (PcdStatusCodeUseSerial)) { + mRscHandlerProtocol->Register (SerialStatusCodeReportWorker); + } + if (FeaturePcdGet (PcdStatusCodeUseMemory)) { + mRscHandlerProtocol->Register (MemoryStatusCodeReportWorker); + } + + return EFI_SUCCESS; +} diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.h b/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.h new file mode 100644 index 0000000000..3127a8cd13 --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.h @@ -0,0 +1,122 @@ +/** @file + Internal include file for Status Code Handler Driver. + + Copyright (c) 2009, Intel Corporation + All rights reserved. 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. + +**/ + +#ifndef __STATUS_CODE_HANDLER_SMM_H__ +#define __STATUS_CODE_HANDLER_SMM_H__ + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +// +// Runtime memory status code worker definition +// +typedef struct { + UINT32 RecordIndex; + UINT32 NumberOfRecords; + UINT32 MaxRecordsNumber; +} RUNTIME_MEMORY_STATUSCODE_HEADER; + +extern RUNTIME_MEMORY_STATUSCODE_HEADER *mSmmMemoryStatusCodeTable; + +/** + Locates Serial I/O Protocol as initialization for serial status code worker. + + @retval EFI_SUCCESS Serial I/O Protocol is successfully located. + +**/ +EFI_STATUS +EfiSerialStatusCodeInitializeWorker ( + VOID + ); + + +/** + Convert status code value and extended data to readable ASCII string, send string to serial I/O device. + + @param CodeType Indicates the type of status code being reported. + @param 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 Instance The enumeration of a hardware or software entity within + the system. Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code reported to serial I/O successfully. + @retval EFI_DEVICE_ERROR EFI serial device cannot work after ExitBootService() is called. + @retval EFI_DEVICE_ERROR EFI serial device cannot work with TPL higher than TPL_CALLBACK. + +**/ +EFI_STATUS +SerialStatusCodeReportWorker ( + 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 OPTIONAL + ); + +/** + Initialize runtime memory status code table as initialization for runtime memory status code worker + + @retval EFI_SUCCESS Runtime memory status code table successfully initialized. + +**/ +EFI_STATUS +MemoryStatusCodeInitializeWorker ( + VOID + ); + +/** + Report status code into runtime memory. If the runtime pool is full, roll back to the + first record and overwrite it. + + @param CodeType Indicates the type of status code being reported. + @param 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 Instance The enumeration of a hardware or software entity within + the system. Valid instance numbers start with 1. + @param 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 Data This optional parameter may be used to pass additional data. + + @retval EFI_SUCCESS Status code successfully recorded in runtime memory status code table. + +**/ +EFI_STATUS +MemoryStatusCodeReportWorker ( + 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 OPTIONAL + ); + +#endif diff --git a/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.inf b/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.inf new file mode 100644 index 0000000000..b0846f23d1 --- /dev/null +++ b/MdeModulePkg/Universal/StatusCodeHandler/Smm/StatusCodeHandlerSmm.inf @@ -0,0 +1,66 @@ +#/** @file +# Status Code Handler Driver which produces general handlers and hook them +# onto the SMM status code router. +# +# Copyright (c) 2009, Intel Corporation. +# +# All rights reserved. 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. +# +# +#**/ + +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = StatusCodeHandlerSmm + FILE_GUID = 79CD78D8-6EDC-4978-BD02-3299C387AB17 + MODULE_TYPE = DXE_SMM_DRIVER + PI_SPECIFICATION_VERSION = 0x0001000A + + ENTRY_POINT = StatusCodeHandlerSmmEntry + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 +# + +[Sources.common] + StatusCodeHandlerSmm.c + StatusCodeHandlerSmm.h + SerialStatusCodeWorker.c + MemoryStatusCodeWorker.c + +[Packages] + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + +[LibraryClasses] + SerialPortLib + SmmServicesTableLib + UefiDriverEntryPoint + PcdLib + PrintLib + ReportStatusCodeLib + DebugLib + SynchronizationLib + +[Guids] + gMemoryStatusCodeRecordGuid ## CONSUMES ## HOB + +[Protocols] + gEfiSmmRscHandlerProtocolGuid ## CONSUMES + +[FeaturePcd] + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeUseMemory + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeUseSerial + +[Pcd] + gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize |128| PcdStatusCodeUseMemory + +[Depex] + gEfiSmmRscHandlerProtocolGuid -- cgit v1.2.3