--- /dev/null
+/*++\r
+\r
+Copyright (c) 2006, Intel Corporation \r
+All rights reserved. This program and the accompanying materials \r
+are licensed and made available under the terms and conditions of the BSD License \r
+which accompanies this distribution. The full text of the license may be found at \r
+http://opensource.org/licenses/bsd-license.php \r
+ \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
+\r
+Module Name:\r
+\r
+ DataHub.c\r
+\r
+Abstract:\r
+\r
+ This code produces the Data Hub protocol. It preloads the data hub\r
+ with status information copied in from PEI HOBs.\r
+ \r
+ Only code that implements the Data Hub protocol should go in this file!\r
+\r
+ The Term MTC stands for MonoTonicCounter. \r
+\r
+ For more information please look at DataHub.doc\r
+\r
+ NOTE: For extra security of the log GetNextDataRecord () could return a copy\r
+ of the data record.\r
+--*/\r
+\r
+#include "DataHub.h"\r
+\r
+CONST EFI_GUID gZeroGuid = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } };\r
+\r
+//\r
+// Worker functions private to this file\r
+//\r
+STATIC\r
+DATA_HUB_FILTER_DRIVER *\r
+FindFilterDriverByEvent (\r
+ IN LIST_ENTRY *Head,\r
+ IN EFI_EVENT Event\r
+ );\r
+\r
+STATIC\r
+EFI_DATA_RECORD_HEADER *\r
+GetNextDataRecord (\r
+ IN LIST_ENTRY *Head,\r
+ IN UINT64 ClassFilter,\r
+ IN OUT UINT64 *PtrCurrentMTC\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+EFIAPI\r
+DataHubLogData (\r
+ IN EFI_DATA_HUB_PROTOCOL *This,\r
+ IN EFI_GUID *DataRecordGuid,\r
+ IN EFI_GUID *ProducerName,\r
+ IN UINT64 DataRecordClass,\r
+ IN VOID *RawData,\r
+ IN UINT32 RawDataSize\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ Log data record into the data logging hub\r
+\r
+Arguments:\r
+\r
+ This - Protocol instance structure\r
+\r
+ DataRecordGuid - GUID that defines record contents\r
+\r
+ ProducerName - GUID that defines the name of the producer of the data\r
+\r
+ DataRecordClass - Class that defines generic record type\r
+\r
+ RawData - Data Log record as defined by DataRecordGuid\r
+ \r
+ RawDataSize - Size of Data Log data in bytes\r
+\r
+Returns: \r
+\r
+ EFI_SUCCESS - If data was logged\r
+\r
+ EFI_OUT_OF_RESOURCES - If data was not logged due to lack of system \r
+ resources.\r
+--*/\r
+{\r
+ EFI_STATUS Status;\r
+ DATA_HUB_INSTANCE *Private;\r
+ EFI_DATA_ENTRY *LogEntry;\r
+ UINT32 TotalSize;\r
+ UINT32 RecordSize;\r
+ EFI_DATA_RECORD_HEADER *Record;\r
+ VOID *Raw;\r
+ DATA_HUB_FILTER_DRIVER *FilterEntry;\r
+ LIST_ENTRY *Link;\r
+ LIST_ENTRY *Head;\r
+\r
+ Private = DATA_HUB_INSTANCE_FROM_THIS (This);\r
+\r
+ //\r
+ // Combine the storage for the internal structs and a copy of the log record.\r
+ // Record follows PrivateLogEntry. The consumer will be returned a pointer\r
+ // to Record so we don't what it to be the thing that was allocated from\r
+ // pool, so the consumer can't free an data record by mistake.\r
+ //\r
+ RecordSize = sizeof (EFI_DATA_RECORD_HEADER) + RawDataSize;\r
+ TotalSize = sizeof (EFI_DATA_ENTRY) + RecordSize;\r
+\r
+ //\r
+ // The Logging action is the critical section, so it is locked.\r
+ // The MTC asignment & update, time, and logging must be an\r
+ // atomic operation, so use the lock.\r
+ //\r
+ Status = EfiAcquireLockOrFail (&Private->DataLock);\r
+ if (EFI_ERROR (Status)) {\r
+ //\r
+ // Reentrancy detected so exit!\r
+ //\r
+ return Status;\r
+ }\r
+\r
+ LogEntry = AllocatePool (TotalSize);\r
+\r
+ if (LogEntry == NULL) {\r
+ EfiReleaseLock (&Private->DataLock);\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+\r
+ ZeroMem (LogEntry, TotalSize);\r
+\r
+ Record = (EFI_DATA_RECORD_HEADER *) (LogEntry + 1);\r
+ Raw = (VOID *) (Record + 1);\r
+\r
+ //\r
+ // Build Standard Log Header\r
+ //\r
+ Record->Version = EFI_DATA_RECORD_HEADER_VERSION;\r
+ Record->HeaderSize = sizeof (EFI_DATA_RECORD_HEADER);\r
+ Record->RecordSize = RecordSize;\r
+ CopyMem (&Record->DataRecordGuid, DataRecordGuid, sizeof (EFI_GUID));\r
+ CopyMem (&Record->ProducerName, ProducerName, sizeof (EFI_GUID));\r
+ Record->DataRecordClass = DataRecordClass;\r
+\r
+ Record->LogMonotonicCount = Private->GlobalMonotonicCount++;\r
+\r
+ gRT->GetTime (&Record->LogTime, NULL);\r
+\r
+ //\r
+ // Insert log into the internal linked list.\r
+ //\r
+ LogEntry->Signature = EFI_DATA_ENTRY_SIGNATURE;\r
+ LogEntry->Record = Record;\r
+ LogEntry->RecordSize = sizeof (EFI_DATA_ENTRY) + RawDataSize;\r
+ InsertTailList (&Private->DataListHead, &LogEntry->Link);\r
+\r
+ CopyMem (Raw, RawData, RawDataSize);\r
+\r
+ EfiReleaseLock (&Private->DataLock);\r
+\r
+ //\r
+ // Send Signal to all the filter drivers which are interested\r
+ // in the record's class and guid.\r
+ //\r
+ Head = &Private->FilterDriverListHead;\r
+ for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {\r
+ FilterEntry = FILTER_ENTRY_FROM_LINK (Link);\r
+ if (((FilterEntry->ClassFilter & DataRecordClass) != 0) &&\r
+ (CompareGuid (&FilterEntry->FilterDataRecordGuid, &gZeroGuid) || \r
+ CompareGuid (&FilterEntry->FilterDataRecordGuid, DataRecordGuid))) {\r
+ gBS->SignalEvent (FilterEntry->Event);\r
+ }\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+EFIAPI\r
+DataHubGetNextRecord (\r
+ IN EFI_DATA_HUB_PROTOCOL *This,\r
+ IN OUT UINT64 *MonotonicCount,\r
+ IN EFI_EVENT *FilterDriverEvent, OPTIONAL\r
+ OUT EFI_DATA_RECORD_HEADER **Record\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ Get a previously logged data record and the MonotonicCount for the next\r
+ availible Record. This allows all records or all records later \r
+ than a give MonotonicCount to be returned. If an optional FilterDriverEvent\r
+ is passed in with a MonotonicCout of zero return the first record \r
+ not yet read by the filter driver. If FilterDriverEvent is NULL and \r
+ MonotonicCount is zero return the first data record.\r
+\r
+Arguments:\r
+\r
+ This - The EFI_DATA_HUB_PROTOCOL instance.\r
+ MonotonicCount - Specifies the Record to return. On input, zero means\r
+ return the first record. On output, contains the next\r
+ record to availible. Zero indicates no more records.\r
+ FilterDriverEvent - If FilterDriverEvent is not passed in a MonotonicCount \r
+ of zero, it means to return the first data record. \r
+ If FilterDriverEvent is passed in, then a MonotonicCount \r
+ of zero means to return the first data not yet read by \r
+ FilterDriverEvent.\r
+ Record - Returns a dynamically allocated memory buffer with a data \r
+ record that matches MonotonicCount.\r
+\r
+Returns: \r
+\r
+ EFI_SUCCESS - Data was returned in Record.\r
+ EFI_INVALID_PARAMETER - FilterDriverEvent was passed in but does not exist.\r
+ EFI_NOT_FOUND - MonotonicCount does not match any data record in the\r
+ system. If a MonotonicCount of zero was passed in, then\r
+ no data records exist in the system.\r
+ EFI_OUT_OF_RESOURCES - Record was not returned due to lack of system resources.\r
+\r
+--*/\r
+{\r
+ DATA_HUB_INSTANCE *Private;\r
+ DATA_HUB_FILTER_DRIVER *FilterDriver;\r
+ UINT64 ClassFilter;\r
+ UINT64 FilterMonotonicCount;\r
+\r
+ Private = DATA_HUB_INSTANCE_FROM_THIS (This);\r
+\r
+ FilterDriver = NULL;\r
+ FilterMonotonicCount = 0;\r
+ ClassFilter = EFI_DATA_RECORD_CLASS_DEBUG |\r
+ EFI_DATA_RECORD_CLASS_ERROR |\r
+ EFI_DATA_RECORD_CLASS_DATA |\r
+ EFI_DATA_RECORD_CLASS_PROGRESS_CODE;\r
+\r
+ if (FilterDriverEvent != NULL) {\r
+ //\r
+ // For events the beginning is the last unread record. This info is\r
+ // stored in the instance structure, so we must look up the event\r
+ // to get the data.\r
+ //\r
+ FilterDriver = FindFilterDriverByEvent (\r
+ &Private->FilterDriverListHead,\r
+ *FilterDriverEvent\r
+ );\r
+ if (FilterDriver == NULL) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+ //\r
+ // Use the Class filter the event was created with.\r
+ //\r
+ ClassFilter = FilterDriver->ClassFilter;\r
+\r
+ if (*MonotonicCount == 0) {\r
+ //\r
+ // Use the MTC from the Filter Driver.\r
+ //\r
+ FilterMonotonicCount = FilterDriver->GetNextMonotonicCount;\r
+ if (FilterMonotonicCount != 0) {\r
+ //\r
+ // The GetNextMonotonicCount field remembers the last value from the previous time.\r
+ // But we already processed this vaule, so we need to find the next one. So if\r
+ // It is not the first time get the new record entry.\r
+ //\r
+ *Record = GetNextDataRecord (&Private->DataListHead, ClassFilter, &FilterMonotonicCount);\r
+ *MonotonicCount = FilterMonotonicCount;\r
+ if (FilterMonotonicCount == 0) {\r
+ //\r
+ // If there is no new record to get exit now.\r
+ //\r
+ return EFI_NOT_FOUND;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ //\r
+ // Return the record\r
+ //\r
+ *Record = GetNextDataRecord (&Private->DataListHead, ClassFilter, MonotonicCount);\r
+ if (*Record == NULL) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+\r
+ if (FilterDriver != NULL) {\r
+ //\r
+ // If we have a filter driver update the records that have been read.\r
+ // If MonotonicCount is zero No more reacords left.\r
+ //\r
+ if (*MonotonicCount == 0) {\r
+ if (FilterMonotonicCount != 0) {\r
+ //\r
+ // Return the result of our extra GetNextDataRecord.\r
+ //\r
+ FilterDriver->GetNextMonotonicCount = FilterMonotonicCount;\r
+ }\r
+ } else {\r
+ //\r
+ // Point to next undread record\r
+ //\r
+ FilterDriver->GetNextMonotonicCount = *MonotonicCount;\r
+ }\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+EFIAPI\r
+DataHubRegisterFilterDriver (\r
+ IN EFI_DATA_HUB_PROTOCOL * This,\r
+ IN EFI_EVENT FilterEvent,\r
+ IN EFI_TPL FilterTpl,\r
+ IN UINT64 FilterClass,\r
+ IN EFI_GUID * FilterDataRecordGuid OPTIONAL\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ This function registers the data hub filter driver that is represented \r
+ by FilterEvent. Only one instance of each FilterEvent can be registered.\r
+ After the FilterEvent is registered, it will be signaled so it can sync \r
+ with data records that have been recorded prior to the FilterEvent being \r
+ registered.\r
+ \r
+Arguments:\r
+\r
+ This - The EFI_DATA_HUB_PROTOCOL instance.\r
+ FilterEvent - The EFI_EVENT to signal whenever data that matches \r
+ FilterClass is logged in the system.\r
+ FilterTpl - The maximum EFI_TPL at which FilterEvent can be \r
+ signaled. It is strongly recommended that you use the \r
+ lowest EFI_TPL possible.\r
+ FilterClass - FilterEvent will be signaled whenever a bit in \r
+ EFI_DATA_RECORD_HEADER.DataRecordClass is also set in \r
+ FilterClass. If FilterClass is zero, no class-based \r
+ filtering will be performed.\r
+ FilterDataRecordGuid - FilterEvent will be signaled whenever FilterDataRecordGuid \r
+ matches EFI_DATA_RECORD_HEADER.DataRecordGuid. If \r
+ FilterDataRecordGuid is NULL, then no GUID-based filtering \r
+ will be performed. \r
+Returns: \r
+\r
+ EFI_SUCCESS - The filter driver event was registered.\r
+ EFI_ALREADY_STARTED - FilterEvent was previously registered and cannot be \r
+ registered again.\r
+ EFI_OUT_OF_RESOURCES - The filter driver event was not registered due to lack of \r
+ system resources.\r
+\r
+--*/\r
+{\r
+ DATA_HUB_INSTANCE *Private;\r
+ DATA_HUB_FILTER_DRIVER *FilterDriver;\r
+\r
+ Private = DATA_HUB_INSTANCE_FROM_THIS (This);\r
+\r
+ FilterDriver = (DATA_HUB_FILTER_DRIVER *) AllocateZeroPool (sizeof (DATA_HUB_FILTER_DRIVER));\r
+ if (FilterDriver == NULL) {\r
+ return EFI_OUT_OF_RESOURCES;\r
+ }\r
+ //\r
+ // Initialize filter driver info\r
+ //\r
+ FilterDriver->Signature = EFI_DATA_HUB_FILTER_DRIVER_SIGNATURE;\r
+ FilterDriver->Event = FilterEvent;\r
+ FilterDriver->Tpl = FilterTpl;\r
+ FilterDriver->GetNextMonotonicCount = 0;\r
+ if (FilterClass == 0) {\r
+ FilterDriver->ClassFilter = EFI_DATA_RECORD_CLASS_DEBUG |\r
+ EFI_DATA_RECORD_CLASS_ERROR |\r
+ EFI_DATA_RECORD_CLASS_DATA |\r
+ EFI_DATA_RECORD_CLASS_PROGRESS_CODE;\r
+ } else {\r
+ FilterDriver->ClassFilter = FilterClass;\r
+ }\r
+\r
+ if (FilterDataRecordGuid != NULL) {\r
+ CopyMem (&FilterDriver->FilterDataRecordGuid, FilterDataRecordGuid, sizeof (EFI_GUID));\r
+ }\r
+ //\r
+ // Search for duplicate entries\r
+ //\r
+ if (FindFilterDriverByEvent (&Private->FilterDriverListHead, FilterEvent) != NULL) {\r
+ FreePool (FilterDriver);\r
+ return EFI_ALREADY_STARTED;\r
+ }\r
+ //\r
+ // Make insertion an atomic operation with the lock.\r
+ //\r
+ EfiAcquireLock (&Private->DataLock);\r
+ InsertTailList (&Private->FilterDriverListHead, &FilterDriver->Link);\r
+ EfiReleaseLock (&Private->DataLock);\r
+\r
+ //\r
+ // Signal the Filter driver we just loaded so they will recieve all the\r
+ // previous history. If we did not signal here we would have to wait until\r
+ // the next data was logged to get the history. In a case where no next\r
+ // data was logged we would never get synced up.\r
+ //\r
+ gBS->SignalEvent (FilterEvent);\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+EFIAPI\r
+DataHubUnregisterFilterDriver (\r
+ IN EFI_DATA_HUB_PROTOCOL *This,\r
+ IN EFI_EVENT FilterEvent\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ Remove a Filter Driver, so it no longer gets called when data \r
+ information is logged.\r
+\r
+Arguments:\r
+\r
+ This - Protocol instance structure\r
+\r
+ FilterEvent - Event that represents a filter driver that is to be \r
+ Unregistered.\r
+\r
+Returns: \r
+\r
+ EFI_SUCCESS - If FilterEvent was unregistered\r
+\r
+ EFI_NOT_FOUND - If FilterEvent does not exist\r
+\r
+--*/\r
+{\r
+ DATA_HUB_INSTANCE *Private;\r
+ DATA_HUB_FILTER_DRIVER *FilterDriver;\r
+\r
+ Private = DATA_HUB_INSTANCE_FROM_THIS (This);\r
+\r
+ //\r
+ // Search for duplicate entries\r
+ //\r
+ FilterDriver = FindFilterDriverByEvent (\r
+ &Private->FilterDriverListHead,\r
+ FilterEvent\r
+ );\r
+ if (FilterDriver == NULL) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+ //\r
+ // Make removal an atomic operation with the lock\r
+ //\r
+ EfiAcquireLock (&Private->DataLock);\r
+ RemoveEntryList (&FilterDriver->Link);\r
+ EfiReleaseLock (&Private->DataLock);\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+//\r
+// STATIC Worker fucntions follow\r
+//\r
+STATIC\r
+DATA_HUB_FILTER_DRIVER *\r
+FindFilterDriverByEvent (\r
+ IN LIST_ENTRY *Head,\r
+ IN EFI_EVENT Event\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Search the Head list for a EFI_DATA_HUB_FILTER_DRIVER member that\r
+ represents Event and return it.\r
+\r
+Arguments:\r
+\r
+ Head - Head of dual linked list of EFI_DATA_HUB_FILTER_DRIVER\r
+ structures.\r
+\r
+ Event - Event to be search for in the Head list.\r
+\r
+Returns: \r
+\r
+ EFI_DATA_HUB_FILTER_DRIVER - Returned if Event stored in the\r
+ Head doubly linked list.\r
+\r
+ NULL - If Event is not in the list\r
+\r
+--*/\r
+{\r
+ DATA_HUB_FILTER_DRIVER *FilterEntry;\r
+ LIST_ENTRY *Link;\r
+\r
+ for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {\r
+ FilterEntry = FILTER_ENTRY_FROM_LINK (Link);\r
+ if (FilterEntry->Event == Event) {\r
+ return FilterEntry;\r
+ }\r
+ }\r
+\r
+ return NULL;\r
+}\r
+\r
+STATIC\r
+EFI_DATA_RECORD_HEADER *\r
+GetNextDataRecord (\r
+ IN LIST_ENTRY *Head,\r
+ IN UINT64 ClassFilter,\r
+ IN OUT UINT64 *PtrCurrentMTC\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Search the Head doubly linked list for the passed in MTC. Return the \r
+ matching element in Head and the MTC on the next entry.\r
+\r
+Arguments:\r
+\r
+ Head - Head of Data Log linked list.\r
+\r
+ ClassFilter - Only match the MTC if it is in the same Class as the\r
+ ClassFilter.\r
+\r
+ PtrCurrentMTC - On IN contians MTC to search for. On OUT contians next\r
+ MTC in the data log list or zero if at end of the list.\r
+ \r
+Returns:\r
+\r
+ EFI_DATA_LOG_ENTRY - Return pointer to data log data from Head list.\r
+\r
+ NULL - If no data record exists.\r
+\r
+--*/\r
+{\r
+ EFI_DATA_ENTRY *LogEntry;\r
+ LIST_ENTRY *Link;\r
+ BOOLEAN ReturnFirstEntry;\r
+ EFI_DATA_RECORD_HEADER *Record;\r
+ EFI_DATA_ENTRY *NextLogEntry;\r
+\r
+ //\r
+ // If MonotonicCount == 0 just return the first one\r
+ //\r
+ ReturnFirstEntry = (BOOLEAN) (*PtrCurrentMTC == 0);\r
+\r
+ Record = NULL;\r
+ for (Link = Head->ForwardLink; Link != Head; Link = Link->ForwardLink) {\r
+ LogEntry = DATA_ENTRY_FROM_LINK (Link);\r
+ if ((LogEntry->Record->DataRecordClass & ClassFilter) == 0) {\r
+ //\r
+ // Skip any entry that does not have the correct ClassFilter\r
+ //\r
+ continue;\r
+ }\r
+\r
+ if ((LogEntry->Record->LogMonotonicCount == *PtrCurrentMTC) || ReturnFirstEntry) {\r
+ //\r
+ // Return record to the user\r
+ //\r
+ Record = LogEntry->Record;\r
+\r
+ //\r
+ // Calculate the next MTC value. If there is no next entry set\r
+ // MTC to zero.\r
+ //\r
+ *PtrCurrentMTC = 0;\r
+ for (Link = Link->ForwardLink; Link != Head; Link = Link->ForwardLink) {\r
+ NextLogEntry = DATA_ENTRY_FROM_LINK (Link);\r
+ if ((NextLogEntry->Record->DataRecordClass & ClassFilter) != 0) {\r
+ //\r
+ // Return the MTC of the next thing to search for if found\r
+ //\r
+ *PtrCurrentMTC = NextLogEntry->Record->LogMonotonicCount;\r
+ break;\r
+ }\r
+ }\r
+ //\r
+ // Record found exit loop and return\r
+ //\r
+ break;\r
+ }\r
+ }\r
+\r
+ return Record;\r
+}\r
+//\r
+// Module Global:\r
+// Since this driver will only ever produce one instance of the Logging Hub\r
+// protocol you are not required to dynamically allocate the PrivateData.\r
+//\r
+DATA_HUB_INSTANCE mPrivateData;\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+DataHubInstall (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Install Driver to produce Data Hub protocol. \r
+\r
+Arguments:\r
+ (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)\r
+\r
+Returns: \r
+\r
+ EFI_SUCCESS - Logging Hub protocol installed\r
+\r
+ Other - No protocol installed, unload driver.\r
+\r
+--*/\r
+{\r
+ EFI_STATUS Status;\r
+ UINT32 HighMontonicCount;\r
+\r
+ mPrivateData.Signature = DATA_HUB_INSTANCE_SIGNATURE;\r
+ mPrivateData.DataHub.LogData = DataHubLogData;\r
+ mPrivateData.DataHub.GetNextRecord = DataHubGetNextRecord;\r
+ mPrivateData.DataHub.RegisterFilterDriver = DataHubRegisterFilterDriver;\r
+ mPrivateData.DataHub.UnregisterFilterDriver = DataHubUnregisterFilterDriver;\r
+\r
+ //\r
+ // Initialize Private Data in CORE_LOGGING_HUB_INSTANCE that is\r
+ // required by this protocol\r
+ //\r
+ InitializeListHead (&mPrivateData.DataListHead);\r
+ InitializeListHead (&mPrivateData.FilterDriverListHead);\r
+\r
+ EfiInitializeLock (&mPrivateData.DataLock, TPL_NOTIFY);\r
+\r
+ //\r
+ // Make sure we get a bigger MTC number on every boot!\r
+ //\r
+ Status = gRT->GetNextHighMonotonicCount (&HighMontonicCount);\r
+ if (EFI_ERROR (Status)) {\r
+ //\r
+ // if system service fails pick a sane value.\r
+ //\r
+ mPrivateData.GlobalMonotonicCount = 0;\r
+ } else {\r
+ mPrivateData.GlobalMonotonicCount = LShiftU64 ((UINT64) HighMontonicCount, 32);\r
+ }\r
+ //\r
+ // Make a new handle and install the protocol\r
+ //\r
+ mPrivateData.Handle = NULL;\r
+ Status = gBS->InstallProtocolInterface (\r
+ &mPrivateData.Handle,\r
+ &gEfiDataHubProtocolGuid,\r
+ EFI_NATIVE_INTERFACE,\r
+ &mPrivateData.DataHub\r
+ );\r
+ return Status;\r
+}\r
--- /dev/null
+/*++\r
+\r
+Copyright (c) 2006, Intel Corporation \r
+All rights reserved. This program and the accompanying materials \r
+are licensed and made available under the terms and conditions of the BSD License \r
+which accompanies this distribution. The full text of the license may be found at \r
+http://opensource.org/licenses/bsd-license.php \r
+ \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
+\r
+Module Name:\r
+\r
+ DataHub.dxs\r
+\r
+Abstract:\r
+\r
+ Dependency expression source file.\r
+ \r
+--*/ \r
+#include <DxeDepex.h>\r
+\r
+DEPENDENCY_START\r
+ TRUE\r
+DEPENDENCY_END\r
--- /dev/null
+/*++\r
+\r
+Copyright (c) 2006, Intel Corporation \r
+All rights reserved. This program and the accompanying materials \r
+are licensed and made available under the terms and conditions of the BSD License \r
+which accompanies this distribution. The full text of the license may be found at \r
+http://opensource.org/licenses/bsd-license.php \r
+ \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
+\r
+Module Name:\r
+\r
+ DataHub.h\r
+\r
+Abstract:\r
+ This code supports a the private implementation \r
+ of the Data Hub protocol\r
+\r
+--*/\r
+\r
+#ifndef _DATA_HUB_H_\r
+#define _DATA_HUB_H_\r
+\r
+//\r
+// The package level header files this module uses\r
+//\r
+#include <PiDxe.h>\r
+//\r
+// The protocols, PPI and GUID defintions for this module\r
+//\r
+#include <Protocol/DataHub.h>\r
+//\r
+// The Library classes this module consumes\r
+//\r
+#include <Library/DebugLib.h>\r
+#include <Library/UefiDriverEntryPoint.h>\r
+#include <Library/UefiLib.h>\r
+#include <Library/BaseLib.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+#include <Library/UefiRuntimeServicesTableLib.h>\r
+\r
+#define DATA_HUB_INSTANCE_SIGNATURE EFI_SIGNATURE_32 ('D', 'H', 'u', 'b')\r
+typedef struct {\r
+ UINT32 Signature;\r
+\r
+ EFI_HANDLE Handle;\r
+\r
+ //\r
+ // Produced protocol(s)\r
+ //\r
+ EFI_DATA_HUB_PROTOCOL DataHub;\r
+\r
+ //\r
+ // Private Data\r
+ //\r
+ //\r
+ // Updates to GlobalMonotonicCount, LogListHead, and FilterDriverListHead\r
+ // must be locked.\r
+ //\r
+ EFI_LOCK DataLock;\r
+\r
+ //\r
+ // Runing Monotonic Count to use for each error record.\r
+ // Increment AFTER use in an error record.\r
+ //\r
+ UINT64 GlobalMonotonicCount;\r
+\r
+ //\r
+ // List of EFI_DATA_ENTRY structures. This is the data log! The list\r
+ // must be in assending order of LogMonotonicCount.\r
+ //\r
+ LIST_ENTRY DataListHead;\r
+\r
+ //\r
+ // List of EFI_DATA_HUB_FILTER_DRIVER structures. Represents all\r
+ // the registered filter drivers.\r
+ //\r
+ LIST_ENTRY FilterDriverListHead;\r
+\r
+} DATA_HUB_INSTANCE;\r
+\r
+#define DATA_HUB_INSTANCE_FROM_THIS(this) CR (this, DATA_HUB_INSTANCE, DataHub, DATA_HUB_INSTANCE_SIGNATURE)\r
+\r
+//\r
+// Private data structure to contain the data log. One record per\r
+// structure. Head pointer to the list is the Log member of\r
+// EFI_DATA_ENTRY. Record is a copy of the data passed in.\r
+//\r
+#define EFI_DATA_ENTRY_SIGNATURE EFI_SIGNATURE_32 ('D', 'r', 'e', 'c')\r
+typedef struct {\r
+ UINT32 Signature;\r
+ LIST_ENTRY Link;\r
+\r
+ EFI_DATA_RECORD_HEADER *Record;\r
+\r
+ UINTN RecordSize;\r
+\r
+} EFI_DATA_ENTRY;\r
+\r
+#define DATA_ENTRY_FROM_LINK(link) CR (link, EFI_DATA_ENTRY, Link, EFI_DATA_ENTRY_SIGNATURE)\r
+\r
+//\r
+// Private data to contain the filter driver Event and it's\r
+// associated EFI_TPL.\r
+//\r
+#define EFI_DATA_HUB_FILTER_DRIVER_SIGNATURE EFI_SIGNATURE_32 ('D', 'h', 'F', 'd')\r
+\r
+typedef struct {\r
+ UINT32 Signature;\r
+ LIST_ENTRY Link;\r
+\r
+ //\r
+ // Store Filter Driver Event and Tpl level it can be Signaled at.\r
+ //\r
+ EFI_EVENT Event;\r
+ EFI_TPL Tpl;\r
+\r
+ //\r
+ // Monotonic count on the get next operation for Event.\r
+ // Zero indicates get next has not been called for this event yet.\r
+ //\r
+ UINT64 GetNextMonotonicCount;\r
+\r
+ //\r
+ // Filter driver will register what class filter should be used.\r
+ //\r
+ UINT64 ClassFilter;\r
+\r
+ //\r
+ // Filter driver will register what record guid filter should be used.\r
+ //\r
+ EFI_GUID FilterDataRecordGuid;\r
+\r
+} DATA_HUB_FILTER_DRIVER;\r
+\r
+#define FILTER_ENTRY_FROM_LINK(link) CR (link, DATA_HUB_FILTER_DRIVER, Link, EFI_DATA_HUB_FILTER_DRIVER_SIGNATURE)\r
+\r
+#endif\r
--- /dev/null
+#/** @file\r
+# Component description file for DataHub module.\r
+#\r
+# This driver initializes and installs the Data Hub protocol.\r
+# Copyright (c) 2006 - 2007, Intel Corporation\r
+#\r
+# All rights reserved. This program and the accompanying materials\r
+# are licensed and made available under the terms and conditions of the BSD License\r
+# which accompanies this distribution. The full text of the license may be found at\r
+# http://opensource.org/licenses/bsd-license.php\r
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+#\r
+#**/\r
+\r
+################################################################################\r
+#\r
+# Defines Section - statements that will be processed to create a Makefile.\r
+#\r
+################################################################################\r
+[Defines]\r
+ INF_VERSION = 0x00010005\r
+ BASE_NAME = DataHub\r
+ FILE_GUID = 53BCC14F-C24F-434C-B294-8ED2D4CC1860\r
+ MODULE_TYPE = DXE_DRIVER\r
+ VERSION_STRING = 1.0\r
+ EDK_RELEASE_VERSION = 0x00020000\r
+ EFI_SPECIFICATION_VERSION = 0x00020000\r
+\r
+ ENTRY_POINT = DataHubInstall\r
+\r
+#\r
+# The following information is for reference only and not required by the build tools.\r
+#\r
+# VALID_ARCHITECTURES = IA32 X64 IPF EBC\r
+#\r
+\r
+################################################################################\r
+#\r
+# Sources Section - list of files that are required for the build to succeed.\r
+#\r
+################################################################################\r
+\r
+[Sources.common]\r
+ DataHub.h\r
+ DataHub.c\r
+\r
+\r
+################################################################################\r
+#\r
+# Package Dependency Section - list of Package files that are required for\r
+# this module.\r
+#\r
+################################################################################\r
+\r
+[Packages]\r
+ IntelFrameworkPkg/IntelFrameworkPkg.dec\r
+ MdePkg/MdePkg.dec\r
+\r
+\r
+################################################################################\r
+#\r
+# Library Class Section - list of Library Classes that are required for\r
+# this module.\r
+#\r
+################################################################################\r
+\r
+[LibraryClasses]\r
+ UefiRuntimeServicesTableLib\r
+ UefiBootServicesTableLib\r
+ MemoryAllocationLib\r
+ BaseMemoryLib\r
+ BaseLib\r
+ UefiLib\r
+ UefiDriverEntryPoint\r
+ DebugLib\r
+\r
+\r
+################################################################################\r
+#\r
+# Protocol C Name Section - list of Protocol and Protocol Notify C Names\r
+# that this module uses or produces.\r
+#\r
+################################################################################\r
+\r
+[Protocols]\r
+ gEfiDataHubProtocolGuid # PROTOCOL ALWAYS_PRODUCED\r
+\r
+\r
+################################################################################\r
+#\r
+# Dependency Expression Section - list of Dependency expressions that are required for\r
+# this module.\r
+#\r
+################################################################################\r
+\r
+[Depex]\r
+ TRUE\r
+\r
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\r
+ <MsaHeader>\r
+ <ModuleName>DataHub</ModuleName>\r
+ <ModuleType>DXE_DRIVER</ModuleType>\r
+ <GuidValue>53BCC14F-C24F-434C-B294-8ED2D4CC1860</GuidValue>\r
+ <Version>1.0</Version>\r
+ <Abstract>Component description file for DataHub module.</Abstract>\r
+ <Description>This driver initializes and installs the Data Hub protocol.</Description>\r
+ <Copyright>Copyright (c) 2006 - 2007, Intel Corporation</Copyright>\r
+ <License>All rights reserved. This program and the accompanying materials\r
+ are licensed and made available under the terms and conditions of the BSD License\r
+ which accompanies this distribution. The full text of the license may be found at\r
+ http://opensource.org/licenses/bsd-license.php\r
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.</License>\r
+ <Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>\r
+ </MsaHeader>\r
+ <ModuleDefinitions>\r
+ <SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>\r
+ <BinaryModule>false</BinaryModule>\r
+ <OutputFileBasename>DataHub</OutputFileBasename>\r
+ </ModuleDefinitions>\r
+ <LibraryClassDefinitions>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>DebugLib</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>UefiDriverEntryPoint</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>UefiLib</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>BaseLib</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>BaseMemoryLib</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>MemoryAllocationLib</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>UefiBootServicesTableLib</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>UefiRuntimeServicesTableLib</Keyword>\r
+ </LibraryClass>\r
+ </LibraryClassDefinitions>\r
+ <SourceFiles>\r
+ <Filename>DataHub.c</Filename>\r
+ <Filename>DataHub.h</Filename>\r
+ <Filename>DataHub.dxs</Filename>\r
+ </SourceFiles>\r
+ <PackageDependencies>\r
+ <Package PackageGuid="1E73767F-8F52-4603-AEB4-F29B510B6766"/>\r
+ <Package PackageGuid="2759ded5-bb57-4b06-af4f-c398fa552719"/>\r
+ </PackageDependencies>\r
+ <Protocols>\r
+ <Protocol Usage="ALWAYS_PRODUCED">\r
+ <ProtocolCName>gEfiDataHubProtocolGuid</ProtocolCName>\r
+ </Protocol>\r
+ </Protocols>\r
+ <Externs>\r
+ <Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>\r
+ <Specification>EDK_RELEASE_VERSION 0x00020000</Specification>\r
+ <Extern>\r
+ <ModuleEntryPoint>DataHubInstall</ModuleEntryPoint>\r
+ </Extern>\r
+ </Externs>\r
+</ModuleSurfaceArea>\r
--- /dev/null
+/*++\r
+\r
+Copyright (c) 2006, Intel Corporation\r
+All rights reserved. This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution. The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+Module Name:\r
+\r
+ DataHubStdErr.c\r
+\r
+Abstract:\r
+\r
+ Data Hub filter driver that takes DEBUG () info from Data Hub and writes it\r
+ to StdErr if it exists.\r
+\r
+--*/\r
+\r
+//\r
+// The package level header files this module uses\r
+//\r
+#include <PiDxe.h>\r
+#include <Common/FrameworkStatusCode.h>\r
+//\r
+// The protocols, PPI and GUID defintions for this module\r
+//\r
+#include <Guid/StatusCode.h>\r
+#include <Guid/StatusCodeDataTypeId.h>\r
+#include <Protocol/DataHub.h>\r
+#include <Protocol/SimpleTextOut.h>\r
+//\r
+// The Library classes this module consumes\r
+//\r
+#include <Library/DebugLib.h>\r
+#include <Library/UefiDriverEntryPoint.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+\r
+EFI_DATA_HUB_PROTOCOL *mDataHub = NULL;\r
+\r
+EFI_EVENT mDataHubStdErrEvent;\r
+\r
+STATIC\r
+VOID\r
+EFIAPI\r
+DataHubStdErrEventHandler (\r
+ IN EFI_EVENT Event,\r
+ IN VOID *Context\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Event handler registered with the Data Hub to parse EFI_DEBUG_CODE. This\r
+ handler reads the Data Hub and sends any DEBUG info to StdErr.\r
+\r
+Arguments:\r
+ Event - The event that occured, not used\r
+ Context - DataHub Protocol Pointer\r
+\r
+Returns:\r
+ None.\r
+\r
+--*/\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_DATA_HUB_PROTOCOL *DataHub;\r
+ EFI_DATA_RECORD_HEADER *Record;\r
+ DATA_HUB_STATUS_CODE_DATA_RECORD *DataRecord;\r
+ UINT64 Mtc;\r
+ EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Sto;\r
+ INT32 OldAttribute;\r
+\r
+ DataHub = (EFI_DATA_HUB_PROTOCOL *) Context;\r
+\r
+ //\r
+ // If StdErr is not yet initialized just return a DEBUG print in the BDS\r
+ // after consoles are connect will make sure data gets flushed properly\r
+ // when StdErr is availible.\r
+ //\r
+ if (gST == NULL) {\r
+ return ;\r
+ }\r
+\r
+ if (gST->StdErr == NULL) {\r
+ return ;\r
+ }\r
+ //\r
+ // Mtc of zero means return the next record that has not been read by the\r
+ // event handler.\r
+ //\r
+ Mtc = 0;\r
+ do {\r
+ Status = DataHub->GetNextRecord (DataHub, &Mtc, &mDataHubStdErrEvent, &Record);\r
+ if (!EFI_ERROR (Status)) {\r
+ if (CompareGuid (&Record->DataRecordGuid, &gEfiStatusCodeGuid)) {\r
+ DataRecord = (DATA_HUB_STATUS_CODE_DATA_RECORD *) (((CHAR8 *) Record) + Record->HeaderSize);\r
+\r
+ if (DataRecord->Data.HeaderSize > 0) {\r
+ if (CompareGuid (&DataRecord->Data.Type, &gEfiStatusCodeDataTypeDebugGuid)) {\r
+ //\r
+ // If the Data record is from a DEBUG () then send it to Standard Error\r
+ //\r
+ Sto = gST->StdErr;\r
+ OldAttribute = Sto->Mode->Attribute;\r
+ Sto->SetAttribute (Sto, EFI_TEXT_ATTR (EFI_MAGENTA, EFI_BLACK));\r
+ Sto->OutputString (Sto, (CHAR16 *) (DataRecord + 1));\r
+ Sto->SetAttribute (Sto, OldAttribute);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ } while ((Mtc != 0) && !EFI_ERROR (Status));\r
+}\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+DataHubStdErrInitialize (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ Register an event handler with the Data Hub to parse EFI_DEBUG_CODE. This\r
+ handler reads the Data Hub and sends any DEBUG info to StdErr.\r
+\r
+Arguments:\r
+\r
+ ImageHandle - Image handle of this driver.\r
+ SystemTable - Pointer to EFI system table.\r
+\r
+Returns:\r
+\r
+ EFI_SUCCESS - The event handler was registered.\r
+ EFI_OUT_OF_RESOURCES - The event hadler was not registered due to lack of\r
+ system resources.\r
+\r
+--*/\r
+{\r
+ EFI_STATUS Status;\r
+ UINT64 DataClass;\r
+\r
+ gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, (VOID **) &mDataHub);\r
+ //\r
+ // Should never fail due to Depex grammer.\r
+ //\r
+ ASSERT (mDataHub != NULL);\r
+\r
+ //\r
+ // Create an event and register it with the filter driver\r
+ //\r
+ Status = gBS->CreateEvent (\r
+ EVT_NOTIFY_SIGNAL,\r
+ TPL_CALLBACK,\r
+ DataHubStdErrEventHandler,\r
+ mDataHub,\r
+ &mDataHubStdErrEvent\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return Status;\r
+ }\r
+\r
+ DataClass = EFI_DATA_RECORD_CLASS_DEBUG | EFI_DATA_RECORD_CLASS_ERROR;\r
+ Status = mDataHub->RegisterFilterDriver (\r
+ mDataHub,\r
+ mDataHubStdErrEvent,\r
+ TPL_CALLBACK,\r
+ DataClass,\r
+ NULL\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ gBS->CloseEvent (mDataHubStdErrEvent);\r
+ }\r
+\r
+ return Status;\r
+}\r
--- /dev/null
+/*++\r
+\r
+Copyright (c) 2006, Intel Corporation \r
+All rights reserved. This program and the accompanying materials \r
+are licensed and made available under the terms and conditions of the BSD License \r
+which accompanies this distribution. The full text of the license may be found at \r
+http://opensource.org/licenses/bsd-license.php \r
+ \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
+\r
+Module Name:\r
+ \r
+ DataHubStdErr.dxs\r
+\r
+Abstract:\r
+\r
+ Dependency expression source file.\r
+ \r
+--*/ \r
+#include <DxeDepex.h>\r
+\r
+\r
+DEPENDENCY_START\r
+ EFI_DATA_HUB_PROTOCOL_GUID \r
+DEPENDENCY_END\r
--- /dev/null
+#/** @file\r
+# Component description file for Data Hub filter driver.\r
+#\r
+# This driver takes DEBUG () info from Data Hub and writes it to StdErr if it exists.\r
+# Copyright (c) 2006 - 2007, Intel Corporation\r
+#\r
+# All rights reserved. This program and the accompanying materials\r
+# are licensed and made available under the terms and conditions of the BSD License\r
+# which accompanies this distribution. The full text of the license may be found at\r
+# http://opensource.org/licenses/bsd-license.php\r
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+#\r
+#**/\r
+\r
+################################################################################\r
+#\r
+# Defines Section - statements that will be processed to create a Makefile.\r
+#\r
+################################################################################\r
+[Defines]\r
+ INF_VERSION = 0x00010005\r
+ BASE_NAME = DataHubStdErr\r
+ FILE_GUID = CA515306-00CE-4032-874E-11B755FF6866\r
+ MODULE_TYPE = DXE_DRIVER\r
+ VERSION_STRING = 1.0\r
+ EDK_RELEASE_VERSION = 0x00020000\r
+ EFI_SPECIFICATION_VERSION = 0x00020000\r
+\r
+ ENTRY_POINT = DataHubStdErrInitialize\r
+\r
+#\r
+# The following information is for reference only and not required by the build tools.\r
+#\r
+# VALID_ARCHITECTURES = IA32 X64 IPF EBC\r
+#\r
+\r
+################################################################################\r
+#\r
+# Sources Section - list of files that are required for the build to succeed.\r
+#\r
+################################################################################\r
+\r
+[Sources.common]\r
+ DataHubStdErr.c\r
+\r
+[Includes]\r
+ IntelFrameworkModulePkg/Include\r
+\r
+################################################################################\r
+#\r
+# Package Dependency Section - list of Package files that are required for\r
+# this module.\r
+#\r
+################################################################################\r
+\r
+[Packages]\r
+ MdePkg/MdePkg.dec\r
+ IntelFrameworkPkg/IntelFrameworkPkg.dec\r
+ IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec\r
+\r
+\r
+\r
+\r
+################################################################################\r
+#\r
+# Library Class Section - list of Library Classes that are required for\r
+# this module.\r
+#\r
+################################################################################\r
+\r
+[LibraryClasses]\r
+ UefiBootServicesTableLib\r
+ BaseMemoryLib\r
+ UefiDriverEntryPoint\r
+ DebugLib\r
+\r
+\r
+################################################################################\r
+#\r
+# Guid C Name Section - list of Guids that this module uses or produces.\r
+#\r
+################################################################################\r
+\r
+[Guids]\r
+ gEfiStatusCodeDataTypeDebugGuid # SOMETIMES_CONSUMED\r
+ gEfiStatusCodeGuid # SOMETIMES_CONSUMED\r
+\r
+\r
+################################################################################\r
+#\r
+# Protocol C Name Section - list of Protocol and Protocol Notify C Names\r
+# that this module uses or produces.\r
+#\r
+################################################################################\r
+\r
+[Protocols]\r
+ gEfiDataHubProtocolGuid # PROTOCOL ALWAYS_CONSUMED\r
+\r
+\r
+################################################################################\r
+#\r
+# Dependency Expression Section - list of Dependency expressions that are required for\r
+# this module.\r
+#\r
+################################################################################\r
+\r
+[Depex]\r
+ gEfiDataHubProtocolGuid\r
+\r
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\r
+ <MsaHeader>\r
+ <ModuleName>DataHubStdErr</ModuleName>\r
+ <ModuleType>DXE_DRIVER</ModuleType>\r
+ <GuidValue>CA515306-00CE-4032-874E-11B755FF6866</GuidValue>\r
+ <Version>1.0</Version>\r
+ <Abstract>Component description file for Data Hub filter driver.</Abstract>\r
+ <Description>This driver takes DEBUG () info from Data Hub and writes it to StdErr if it exists.</Description>\r
+ <Copyright>Copyright (c) 2006 - 2007, Intel Corporation</Copyright>\r
+ <License>All rights reserved. This program and the accompanying materials\r
+ are licensed and made available under the terms and conditions of the BSD License\r
+ which accompanies this distribution. The full text of the license may be found at\r
+ http://opensource.org/licenses/bsd-license.php\r
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.</License>\r
+ <Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>\r
+ </MsaHeader>\r
+ <ModuleDefinitions>\r
+ <SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>\r
+ <BinaryModule>false</BinaryModule>\r
+ <OutputFileBasename>DataHubStdErr</OutputFileBasename>\r
+ </ModuleDefinitions>\r
+ <LibraryClassDefinitions>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>DebugLib</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>UefiDriverEntryPoint</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>BaseMemoryLib</Keyword>\r
+ </LibraryClass>\r
+ <LibraryClass Usage="ALWAYS_CONSUMED">\r
+ <Keyword>UefiBootServicesTableLib</Keyword>\r
+ </LibraryClass>\r
+ </LibraryClassDefinitions>\r
+ <SourceFiles>\r
+ <Filename>DataHubStdErr.c</Filename>\r
+ <Filename>DataHubStdErr.dxs</Filename>\r
+ </SourceFiles>\r
+ <PackageDependencies>\r
+ <Package PackageGuid="1E73767F-8F52-4603-AEB4-F29B510B6766"/>\r
+ <Package PackageGuid="2759ded5-bb57-4b06-af4f-c398fa552719"/>\r
+ <Package PackageGuid="88894582-7553-4822-B484-624E24B6DECF"/>\r
+ </PackageDependencies>\r
+ <Protocols>\r
+ <Protocol Usage="ALWAYS_CONSUMED">\r
+ <ProtocolCName>gEfiDataHubProtocolGuid</ProtocolCName>\r
+ </Protocol>\r
+ </Protocols>\r
+ <DataHubs>\r
+ <DataHubRecord Usage="SOMETIMES_CONSUMED">\r
+ <DataHubCName>DATA_HUB_STATUS_CODE_DATA_RECORD</DataHubCName>\r
+ <HelpText>DEBUG() data that is recorded in status code data hub will be sent to Standard Error.</HelpText>\r
+ </DataHubRecord>\r
+ </DataHubs>\r
+ <Guids>\r
+ <GuidCNames Usage="SOMETIMES_CONSUMED">\r
+ <GuidCName>gEfiStatusCodeGuid</GuidCName>\r
+ </GuidCNames>\r
+ <GuidCNames Usage="SOMETIMES_CONSUMED">\r
+ <GuidCName>gEfiStatusCodeDataTypeDebugGuid</GuidCName>\r
+ </GuidCNames>\r
+ </Guids>\r
+ <Externs>\r
+ <Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>\r
+ <Specification>EDK_RELEASE_VERSION 0x00020000</Specification>\r
+ <Extern>\r
+ <ModuleEntryPoint>DataHubStdErrInitialize</ModuleEntryPoint>\r
+ </Extern>\r
+ </Externs>\r
+</ModuleSurfaceArea>\r
projects / mirror_edk2.git / commitdiff