//
// TDS 3.5
//
EFI_STATUS
BBTestInvalidateInstructionCacheFunctionAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_DEBUG_SUPPORT_PROTOCOL *DebugSupport;
EFI_TEST_ASSERTION AssertionType;
UINT64 Start;
UINT64 Length;
UINTN MaxProcessorIndex;
UINTN ProcessorIndex;
//
// Get the Standard Library Interface
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiStandardTestLibraryGuid,
&StandardLib
);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - Handle standard test library",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
DebugSupport = (EFI_DEBUG_SUPPORT_PROTOCOL *)ClientInterface;
if (DebugSupport->Isa != PlatformIsa) {
return EFI_SUCCESS;
}
Status = DebugSupport->GetMaximumProcessorIndex (DebugSupport, &MaxProcessorIndex);
if (EFI_ERROR(Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"EFI_DEBUG_SUPPORT_PROTOCOL.GetMaximumProcessorIndex",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
return Status;
}
for (ProcessorIndex = 0; ProcessorIndex < MaxProcessorIndex; ProcessorIndex++) {
//
// Assertion Point 3.5.2.1
// Invoke InvalidateInstructionCache and verify interface correctness.
//
// The Physical base of the memory range to be invalidated.
Start = 0x0;
// The minimum number of bytes in the processor's instruction cache to be invalidated.
Length = 0x0;
Status = DebugSupport->InvalidateInstructionCache (DebugSupport, ProcessorIndex, (VOID*)&Start, Length);
if (EFI_ERROR(Status)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gDebugSupportBBTestFunctionAssertionGuid015,
L"EFI_DEBUG_SUPPORT_PROTOCOL.InvalidateInstructionCache - Invoke this function and verify interface correctness",
L"%a:%d:Status - %r",
__FILE__,
__LINE__,
Status
);
}
return EFI_SUCCESS;
}
/**
The user Entry Point for Application. The user code starts with this function
as the real entry point for the image goes into a library that calls this
function.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.
**/
EFI_STATUS
EFIAPI
GdbStubEntry (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_DEBUG_SUPPORT_PROTOCOL *DebugSupport;
UINTN HandleCount;
EFI_HANDLE *Handles;
UINTN Index;
UINTN Processor;
BOOLEAN IsaSupported;
Status = EfiGetSystemConfigurationTable (&gEfiDebugImageInfoTableGuid, (VOID **)&gDebugImageTableHeader);
if (EFI_ERROR (Status)) {
gDebugImageTableHeader = NULL;
}
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiDebugSupportProtocolGuid,
NULL,
&HandleCount,
&Handles
);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Debug Support Protocol not found\n"));
return Status;
}
DebugSupport = NULL;
IsaSupported = FALSE;
do {
HandleCount--;
Status = gBS->HandleProtocol (
Handles[HandleCount],
&gEfiDebugSupportProtocolGuid,
(VOID **) &DebugSupport
);
if (!EFI_ERROR (Status)) {
if (CheckIsa (DebugSupport->Isa)) {
// We found what we are looking for so break out of the loop
IsaSupported = TRUE;
break;
}
}
} while (HandleCount > 0);
FreePool (Handles);
if (!IsaSupported) {
DEBUG ((EFI_D_ERROR, "Debug Support Protocol does not support our ISA\n"));
return EFI_NOT_FOUND;
}
Status = DebugSupport->GetMaximumProcessorIndex (DebugSupport, &gMaxProcessorIndex);
ASSERT_EFI_ERROR (Status);
DEBUG ((EFI_D_INFO, "Debug Support Protocol ISA %x\n", DebugSupport->Isa));
DEBUG ((EFI_D_INFO, "Debug Support Protocol Processor Index %d\n", gMaxProcessorIndex));
// Call processor-specific init routine
InitializeProcessor ();
for (Processor = 0; Processor <= gMaxProcessorIndex; Processor++) {
for (Index = 0; Index < MaxEfiException (); Index++) {
Status = DebugSupport->RegisterExceptionCallback (DebugSupport, Processor, GdbExceptionHandler, gExceptionType[Index].Exception);
ASSERT_EFI_ERROR (Status);
}
//
// Current edk2 DebugPort is not interrupt context safe so we can not use it
//
Status = DebugSupport->RegisterPeriodicCallback (DebugSupport, Processor, GdbPeriodicCallBack);
ASSERT_EFI_ERROR (Status);
}
//
// This even fires every time an image is added. This allows the stub to know when gdb needs
// to update the symbol table.
//
Status = gBS->CreateEvent (
EVT_NOTIFY_SIGNAL,
TPL_CALLBACK,
GdbSymbolEventHandler,
NULL,
&gEvent
);
ASSERT_EFI_ERROR (Status);
//
// Register for protocol notifications on this event
//
Status = gBS->RegisterProtocolNotify (
&gEfiLoadedImageProtocolGuid,
gEvent,
&gGdbSymbolEventHandlerRegistration
);
ASSERT_EFI_ERROR (Status);
if (PcdGetBool (PcdGdbSerial)) {
GdbInitializeSerialConsole ();
}
return EFI_SUCCESS;
}
