-/** @file
- UEFI driver that implements a GDB stub
-
- Note: Any code in the path of the Serial IO output can not call DEBUG as will
- will blow out the stack. Serial IO calls DEBUG, debug calls Serail IO, ...
-
-
- Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution. The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <GdbStubInternal.h>
-#include <Protocol/DebugPort.h>
-
-
-UINTN gMaxProcessorIndex = 0;
-
-//
-// Buffers for basic gdb communication
-//
-CHAR8 gInBuffer[MAX_BUF_SIZE];
-CHAR8 gOutBuffer[MAX_BUF_SIZE];
-
-// Assume gdb does a "qXfer:libraries:read::offset,length" when it connects so we can default
-// this value to FALSE. Since gdb can reconnect its self a global default is not good enough
-BOOLEAN gSymbolTableUpdate = FALSE;
-EFI_EVENT gEvent;
-VOID *gGdbSymbolEventHandlerRegistration = NULL;
-
-//
-// Globals for returning XML from qXfer:libraries:read packet
-//
-UINTN gPacketqXferLibraryOffset = 0;
-UINTN gEfiDebugImageTableEntry = 0;
-EFI_DEBUG_IMAGE_INFO_TABLE_HEADER *gDebugImageTableHeader = NULL;
-EFI_DEBUG_IMAGE_INFO *gDebugTable = NULL;
-CHAR8 gXferLibraryBuffer[2000];
-
-GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexToStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
-
-
-VOID
-EFIAPI
-GdbSymbolEventHandler (
- IN EFI_EVENT Event,
- IN VOID *Context
- )
-{
-}
-
-
-/**
- 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 notifactions on this event
- //
- Status = gBS->RegisterProtocolNotify (
- &gEfiLoadedImageProtocolGuid,
- gEvent,
- &gGdbSymbolEventHandlerRegistration
- );
- ASSERT_EFI_ERROR (Status);
-
-
- if (PcdGetBool (PcdGdbSerial)) {
- GdbInitializeSerialConsole ();
- }
-
- return EFI_SUCCESS;
-}
-
-
-
-/**
- Transfer length bytes of input buffer, starting at Address, to memory.
-
- @param length the number of the bytes to be transferred/written
- @param *address the start address of the transferring/writing the memory
- @param *new_data the new data to be written to memory
- **/
-
-VOID
-TransferFromInBufToMem (
- IN UINTN Length,
- IN unsigned char *Address,
- IN CHAR8 *NewData
- )
-{
- CHAR8 c1;
- CHAR8 c2;
-
- while (Length-- > 0) {
- c1 = (CHAR8)HexCharToInt (*NewData++);
- c2 = (CHAR8)HexCharToInt (*NewData++);
-
- if ((c1 < 0) || (c2 < 0)) {
- Print ((CHAR16 *)L"Bad message from write to memory..\n");
- SendError (GDB_EBADMEMDATA);
- return;
- }
- *Address++ = (UINT8)((c1 << 4) + c2);
- }
-
- SendSuccess();
-}
-
-
-/**
- Transfer Length bytes of memory starting at Address to an output buffer, OutBuffer. This function will finally send the buffer
- as a packet.
-
- @param Length the number of the bytes to be transferred/read
- @param *address pointer to the start address of the transferring/reading the memory
- **/
-
-VOID
-TransferFromMemToOutBufAndSend (
- IN UINTN Length,
- IN unsigned char *Address
- )
-{
- // there are Length bytes and every byte is represented as 2 hex chars
- CHAR8 OutBuffer[MAX_BUF_SIZE];
- CHAR8 *OutBufPtr; // pointer to the output buffer
- CHAR8 Char;
-
- if (ValidateAddress(Address) == FALSE) {
- SendError(14);
- return;
- }
-
- OutBufPtr = OutBuffer;
- while (Length > 0) {
-
- Char = mHexToStr[*Address >> 4];
- if ((Char >= 'A') && (Char <= 'F')) {
- Char = Char - 'A' + 'a';
- }
- *OutBufPtr++ = Char;
-
- Char = mHexToStr[*Address & 0x0f];
- if ((Char >= 'A') && (Char <= 'F')) {
- Char = Char - 'A' + 'a';
- }
- *OutBufPtr++ = Char;
-
- Address++;
- Length--;
- }
-
- *OutBufPtr = '\0' ; // the end of the buffer
- SendPacket (OutBuffer);
-}
-
-
-
-/**
- Send a GDB Remote Serial Protocol Packet
-
- $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$',
- the packet teminating character '#' and the two digit checksum.
-
- If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up
- in an infinit loop. This is so if you unplug the debugger code just keeps running
-
- @param PacketData Payload data for the packet
-
-
- @retval Number of bytes of packet data sent.
-
-**/
-UINTN
-SendPacket (
- IN CHAR8 *PacketData
- )
-{
- UINT8 CheckSum;
- UINTN Timeout;
- CHAR8 *Ptr;
- CHAR8 TestChar;
- UINTN Count;
-
- Timeout = PcdGet32 (PcdGdbMaxPacketRetryCount);
-
- Count = 0;
- do {
-
- Ptr = PacketData;
-
- if (Timeout-- == 0) {
- // Only try a finite number of times so we don't get stuck in the loop
- return Count;
- }
-
- // Packet prefix
- GdbPutChar ('$');
-
- for (CheckSum = 0, Count =0 ; *Ptr != '\0'; Ptr++, Count++) {
- GdbPutChar (*Ptr);
- CheckSum = CheckSum + *Ptr;
- }
-
- // Packet terminating character and checksum
- GdbPutChar ('#');
- GdbPutChar (mHexToStr[CheckSum >> 4]);
- GdbPutChar (mHexToStr[CheckSum & 0x0F]);
-
- TestChar = GdbGetChar ();
- } while (TestChar != '+');
-
- return Count;
-}
-
-/**
- Receive a GDB Remote Serial Protocol Packet
-
- $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$',
- the packet teminating character '#' and the two digit checksum.
-
- If host re-starts sending a packet without ending the previous packet, only the last valid packet is proccessed.
- (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)
-
- If an ack '+' is not sent resend the packet
-
- @param PacketData Payload data for the packet
-
- @retval Number of bytes of packet data received.
-
-**/
-UINTN
-ReceivePacket (
- OUT CHAR8 *PacketData,
- IN UINTN PacketDataSize
- )
-{
- UINT8 CheckSum;
- UINTN Index;
- CHAR8 Char;
- CHAR8 SumString[3];
- CHAR8 TestChar;
-
- ZeroMem (PacketData, PacketDataSize);
-
- for (;;) {
- // wait for the start of a packet
- TestChar = GdbGetChar ();
- while (TestChar != '$') {
- TestChar = GdbGetChar ();
- };
-
- retry:
- for (Index = 0, CheckSum = 0; Index < (PacketDataSize - 1); Index++) {
- Char = GdbGetChar ();
- if (Char == '$') {
- goto retry;
- }
- if (Char == '#') {
- break;
- }
-
- PacketData[Index] = Char;
- CheckSum = CheckSum + Char;
- }
- PacketData[Index] = '\0';
-
- if (Index == PacketDataSize) {
- continue;
- }
-
- SumString[0] = GdbGetChar ();
- SumString[1] = GdbGetChar ();
- SumString[2] = '\0';
-
- if (AsciiStrHexToUintn (SumString) == CheckSum) {
- // Ack: Success
- GdbPutChar ('+');
-
- // Null terminate the callers string
- PacketData[Index] = '\0';
- return Index;
- } else {
- // Ack: Failure
- GdbPutChar ('-');
- }
- }
-
- //return 0;
-}
-
-
-/**
- Empties the given buffer
- @param Buf pointer to the first element in buffer to be emptied
- **/
-VOID
-EmptyBuffer (
- IN CHAR8 *Buf
- )
-{
- *Buf = '\0';
-}
-
-
-/**
- Converts an 8-bit Hex Char into a INTN.
-
- @param Char the hex character to be converted into UINTN
- @retval a INTN, from 0 to 15, that corressponds to Char
- -1 if Char is not a hex character
- **/
-INTN
-HexCharToInt (
- IN CHAR8 Char
- )
-{
- if ((Char >= 'A') && (Char <= 'F')) {
- return Char - 'A' + 10;
- } else if ((Char >= 'a') && (Char <= 'f')) {
- return Char - 'a' + 10;
- } else if ((Char >= '0') && (Char <= '9')) {
- return Char - '0';
- } else { // if not a hex value, return a negative value
- return -1;
- }
-}
-
- // 'E' + the biggest error number is 255, so its 2 hex digits + buffer end
-CHAR8 *gError = "E__";
-
-/** 'E NN'
- Send an error with the given error number after converting to hex.
- The error number is put into the buffer in hex. '255' is the biggest errno we can send.
- ex: 162 will be sent as A2.
-
- @param errno the error number that will be sent
- **/
-VOID
-EFIAPI
-SendError (
- IN UINT8 ErrorNum
- )
-{
- //
- // Replace _, or old data, with current errno
- //
- gError[1] = mHexToStr [ErrorNum >> 4];
- gError[2] = mHexToStr [ErrorNum & 0x0f];
-
- SendPacket (gError); // send buffer
-}
-
-
-
-/**
- Send 'OK' when the function is done executing successfully.
- **/
-VOID
-EFIAPI
-SendSuccess (
- VOID
- )
-{
- SendPacket ("OK"); // send buffer
-}
-
-
-/**
- Send empty packet to specify that particular command/functionality is not supported.
- **/
-VOID
-EFIAPI
-SendNotSupported (
- VOID
- )
-{
- SendPacket ("");
-}
-
-
-
-/**
- Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints
-
- @param SystemContext Register content at time of the exception
- @param GdbExceptionType GDB exception type
- **/
-VOID
-GdbSendTSignal (
- IN EFI_SYSTEM_CONTEXT SystemContext,
- IN UINT8 GdbExceptionType
- )
-{
- CHAR8 TSignalBuffer[128];
- CHAR8 *TSignalPtr;
- UINTN BreakpointDetected;
- BREAK_TYPE BreakType;
- UINTN DataAddress;
- CHAR8 *WatchStrPtr = NULL;
- UINTN RegSize;
-
- TSignalPtr = &TSignalBuffer[0];
-
- //Construct TSignal packet
- *TSignalPtr++ = 'T';
-
- //
- // replace _, or previous value, with Exception type
- //
- *TSignalPtr++ = mHexToStr [GdbExceptionType >> 4];
- *TSignalPtr++ = mHexToStr [GdbExceptionType & 0x0f];
-
- if (GdbExceptionType == GDB_SIGTRAP) {
- if (gSymbolTableUpdate) {
- //
- // We can only send back on reason code. So if the flag is set it means the breakpoint is from our event handler
- //
- WatchStrPtr = "library:;";
- while (*WatchStrPtr != '\0') {
- *TSignalPtr++ = *WatchStrPtr++;
- }
- gSymbolTableUpdate = FALSE;
- } else {
-
-
- //
- // possible n:r pairs
- //
-
- //Retrieve the breakpoint number
- BreakpointDetected = GetBreakpointDetected (SystemContext);
-
- //Figure out if the exception is happend due to watch, rwatch or awatch.
- BreakType = GetBreakpointType (SystemContext, BreakpointDetected);
-
- //INFO: rwatch is not supported due to the way IA32 debug registers work
- if ((BreakType == DataWrite) || (BreakType == DataRead) || (BreakType == DataReadWrite)) {
-
- //Construct n:r pair
- DataAddress = GetBreakpointDataAddress (SystemContext, BreakpointDetected);
-
- //Assign appropriate buffer to print particular watchpoint type
- if (BreakType == DataWrite) {
- WatchStrPtr = "watch";
- } else if (BreakType == DataRead) {
- WatchStrPtr = "rwatch";
- } else if (BreakType == DataReadWrite) {
- WatchStrPtr = "awatch";
- }
-
- while (*WatchStrPtr != '\0') {
- *TSignalPtr++ = *WatchStrPtr++;
- }
-
- *TSignalPtr++ = ':';
-
- //Set up series of bytes in big-endian byte order. "awatch" won't work with little-endian byte order.
- RegSize = REG_SIZE;
- while (RegSize > 0) {
- RegSize = RegSize-4;
- *TSignalPtr++ = mHexToStr[(UINT8)(DataAddress >> RegSize) & 0xf];
- }
-
- //Always end n:r pair with ';'
- *TSignalPtr++ = ';';
- }
- }
- }
-
- *TSignalPtr = '\0';
-
- SendPacket (TSignalBuffer);
-}
-
-
-/**
- Translates the EFI mapping to GDB mapping
-
- @param EFIExceptionType EFI Exception that is being processed
- @retval UINTN that corresponds to EFIExceptionType's GDB exception type number
- **/
-UINT8
-ConvertEFItoGDBtype (
- IN EFI_EXCEPTION_TYPE EFIExceptionType
- )
-{
- UINTN i;
-
- for (i=0; i < MaxEfiException() ; i++) {
- if (gExceptionType[i].Exception == EFIExceptionType) {
- return gExceptionType[i].SignalNo;
- }
- }
- return GDB_SIGTRAP; // this is a GDB trap
-}
-
-
-/** "m addr,length"
- Find the Length of the area to read and the start addres. Finally, pass them to
- another function, TransferFromMemToOutBufAndSend, that will read from that memory space and
- send it as a packet.
- **/
-
-VOID
-EFIAPI
-ReadFromMemory (
- CHAR8 *PacketData
- )
-{
- UINTN Address;
- UINTN Length;
- CHAR8 AddressBuffer[MAX_ADDR_SIZE]; // the buffer that will hold the address in hex chars
- CHAR8 *AddrBufPtr; // pointer to the address buffer
- CHAR8 *InBufPtr; /// pointer to the input buffer
-
- AddrBufPtr = AddressBuffer;
- InBufPtr = &PacketData[1];
- while (*InBufPtr != ',') {
- *AddrBufPtr++ = *InBufPtr++;
- }
- *AddrBufPtr = '\0';
-
- InBufPtr++; // this skips ',' in the buffer
-
- /* Error checking */
- if (AsciiStrLen(AddressBuffer) >= MAX_ADDR_SIZE) {
- Print((CHAR16 *)L"Address is too long\n");
- SendError (GDB_EBADMEMADDRBUFSIZE);
- return;
- }
-
- // 2 = 'm' + ','
- if (AsciiStrLen(PacketData) - AsciiStrLen(AddressBuffer) - 2 >= MAX_LENGTH_SIZE) {
- Print((CHAR16 *)L"Length is too long\n");
- SendError (GDB_EBADMEMLENGTH);
- return;
- }
-
- Address = AsciiStrHexToUintn (AddressBuffer);
- Length = AsciiStrHexToUintn (InBufPtr);
-
- TransferFromMemToOutBufAndSend (Length, (unsigned char *)Address);
-}
-
-
-/** "M addr,length :XX..."
- Find the Length of the area in bytes to write and the start addres. Finally, pass them to
- another function, TransferFromInBufToMem, that will write to that memory space the info in
- the input buffer.
- **/
-VOID
-EFIAPI
-WriteToMemory (
- IN CHAR8 *PacketData
- )
-{
- UINTN Address;
- UINTN Length;
- UINTN MessageLength;
- CHAR8 AddressBuffer[MAX_ADDR_SIZE]; // the buffer that will hold the Address in hex chars
- CHAR8 LengthBuffer[MAX_LENGTH_SIZE]; // the buffer that will hold the Length in hex chars
- CHAR8 *AddrBufPtr; // pointer to the Address buffer
- CHAR8 *LengthBufPtr; // pointer to the Length buffer
- CHAR8 *InBufPtr; /// pointer to the input buffer
-
- AddrBufPtr = AddressBuffer;
- LengthBufPtr = LengthBuffer;
- InBufPtr = &PacketData[1];
-
- while (*InBufPtr != ',') {
- *AddrBufPtr++ = *InBufPtr++;
- }
- *AddrBufPtr = '\0';
-
- InBufPtr++; // this skips ',' in the buffer
-
- while (*InBufPtr != ':') {
- *LengthBufPtr++ = *InBufPtr++;
- }
- *LengthBufPtr = '\0';
-
- InBufPtr++; // this skips ':' in the buffer
-
- Address = AsciiStrHexToUintn (AddressBuffer);
- Length = AsciiStrHexToUintn (LengthBuffer);
-
- /* Error checking */
-
- //Check if Address is not too long.
- if (AsciiStrLen(AddressBuffer) >= MAX_ADDR_SIZE) {
- Print ((CHAR16 *)L"Address too long..\n");
- SendError (GDB_EBADMEMADDRBUFSIZE);
- return;
- }
-
- //Check if message length is not too long
- if (AsciiStrLen(LengthBuffer) >= MAX_LENGTH_SIZE) {
- Print ((CHAR16 *)L"Length too long..\n");
- SendError (GDB_EBADMEMLENGBUFSIZE);
- return;
- }
-
- // Check if Message is not too long/short.
- // 3 = 'M' + ',' + ':'
- MessageLength = (AsciiStrLen(PacketData) - AsciiStrLen(AddressBuffer) - AsciiStrLen(LengthBuffer) - 3);
- if (MessageLength != (2*Length)) {
- //Message too long/short. New data is not the right size.
- SendError (GDB_EBADMEMDATASIZE);
- return;
- }
- TransferFromInBufToMem (Length, (unsigned char *)Address, InBufPtr);
-}
-
-/**
- Parses breakpoint packet data and captures Breakpoint type, Address and length.
- In case of an error, function returns particular error code. Returning 0 meaning
- no error.
-
- @param PacketData Pointer to the payload data for the packet.
- @param Type Breakpoint type
- @param Address Breakpoint address
- @param Length Breakpoint length in Bytes (1 byte, 2 byte, 4 byte)
-
- @retval 1 Success
- @retval {other} Particular error code
-
-**/
-UINTN
-ParseBreakpointPacket (
- IN CHAR8 *PacketData,
- OUT UINTN *Type,
- OUT UINTN *Address,
- OUT UINTN *Length
- )
-{
- CHAR8 AddressBuffer[MAX_ADDR_SIZE];
- CHAR8 *AddressBufferPtr;
- CHAR8 *PacketDataPtr;
-
- PacketDataPtr = &PacketData[1];
- AddressBufferPtr = AddressBuffer;
-
- *Type = AsciiStrHexToUintn (PacketDataPtr);
-
- //Breakpoint/watchpoint type should be between 0 to 4
- if (*Type > 4) {
- Print ((CHAR16 *)L"Type is invalid\n");
- return 22; //EINVAL: Invalid argument.
- }
-
- //Skip ',' in the buffer.
- while (*PacketDataPtr++ != ',');
-
- //Parse Address information
- while (*PacketDataPtr != ',') {
- *AddressBufferPtr++ = *PacketDataPtr++;
- }
- *AddressBufferPtr = '\0';
-
- //Check if Address is not too long.
- if (AsciiStrLen(AddressBuffer) >= MAX_ADDR_SIZE) {
- Print ((CHAR16 *)L"Address too long..\n");
- return 40; //EMSGSIZE: Message size too long.
- }
-
- *Address = AsciiStrHexToUintn (AddressBuffer);
-
- PacketDataPtr++; //This skips , in the buffer
-
- //Parse Length information
- *Length = AsciiStrHexToUintn (PacketDataPtr);
-
- //Length should be 1, 2 or 4 bytes
- if (*Length > 4) {
- Print ((CHAR16 *)L"Length is invalid\n");
- return 22; //EINVAL: Invalid argument
- }
-
- return 0; //0 = No error
-}
-
-UINTN
-gXferObjectReadResponse (
- IN CHAR8 Type,
- IN CHAR8 *Str
- )
-{
- CHAR8 *OutBufPtr; // pointer to the output buffer
- CHAR8 Char;
- UINTN Count;
-
- // responce starts with 'm' or 'l' if it is the end
- OutBufPtr = gOutBuffer;
- *OutBufPtr++ = Type;
- Count = 1;
-
- // Binary data encoding
- OutBufPtr = gOutBuffer;
- while (*Str != '\0') {
- Char = *Str++;
- if ((Char == 0x7d) || (Char == 0x23) || (Char == 0x24) || (Char == 0x2a)) {
- // escape character
- *OutBufPtr++ = 0x7d;
-
- Char ^= 0x20;
- }
- *OutBufPtr++ = Char;
- Count++;
- }
-
- *OutBufPtr = '\0' ; // the end of the buffer
- SendPacket (gOutBuffer);
-
- return Count;
-}
-
-
-/**
- Note: This should be a library function. In the Apple case you have to add
- the size of the PE/COFF header into the starting address to make things work
- right as there is no way to pad the Mach-O for the size of the PE/COFF header.
-
-
- Returns a pointer to the PDB file name for a PE/COFF image that has been
- loaded into system memory with the PE/COFF Loader Library functions.
-
- Returns the PDB file name for the PE/COFF image specified by Pe32Data. If
- the PE/COFF image specified by Pe32Data is not a valid, then NULL is
- returned. If the PE/COFF image specified by Pe32Data does not contain a
- debug directory entry, then NULL is returned. If the debug directory entry
- in the PE/COFF image specified by Pe32Data does not contain a PDB file name,
- then NULL is returned.
- If Pe32Data is NULL, then ASSERT().
-
- @param Pe32Data Pointer to the PE/COFF image that is loaded in system
- memory.
- @param DebugBase Address that the debugger would use as the base of the image
-
- @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL
- if it cannot be retrieved. DebugBase is only valid if PDB file name is
- valid.
-
-**/
-VOID *
-EFIAPI
-PeCoffLoaderGetDebuggerInfo (
- IN VOID *Pe32Data,
- OUT VOID **DebugBase
- )
-{
- EFI_IMAGE_DOS_HEADER *DosHdr;
- EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr;
- EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry;
- EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry;
- UINTN DirCount;
- VOID *CodeViewEntryPointer;
- INTN TEImageAdjust;
- UINT32 NumberOfRvaAndSizes;
- UINT16 Magic;
- UINTN SizeOfHeaders;
-
- ASSERT (Pe32Data != NULL);
-
- TEImageAdjust = 0;
- DirectoryEntry = NULL;
- DebugEntry = NULL;
- NumberOfRvaAndSizes = 0;
- SizeOfHeaders = 0;
-
- DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
- if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
- //
- // DOS image header is present, so read the PE header after the DOS image header.
- //
- Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
- } else {
- //
- // DOS image header is not present, so PE header is at the image base.
- //
- Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
- }
-
- if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
- if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) {
- DirectoryEntry = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG];
- TEImageAdjust = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize;
- DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te +
- Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress +
- TEImageAdjust);
- }
- SizeOfHeaders = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN)Hdr.Te->BaseOfCode - (UINTN)Hdr.Te->StrippedSize;
-
- // __APPLE__ check this math...
- *DebugBase = ((CHAR8 *)Pe32Data) - TEImageAdjust;
- } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
-
- *DebugBase = Pe32Data;
-
-
- //
- // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic.
- // It is due to backward-compatibility, for some system might
- // generate PE32+ image with PE32 Magic.
- //
- switch (Hdr.Pe32->FileHeader.Machine) {
- case EFI_IMAGE_MACHINE_IA32:
- //
- // Assume PE32 image with IA32 Machine field.
- //
- Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
- break;
- case EFI_IMAGE_MACHINE_X64:
- case EFI_IMAGE_MACHINE_IA64:
- //
- // Assume PE32+ image with X64 or IPF Machine field
- //
- Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
- break;
- default:
- //
- // For unknow Machine field, use Magic in optional Header
- //
- Magic = Hdr.Pe32->OptionalHeader.Magic;
- }
-
- if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
- //
- // Use PE32 offset get Debug Directory Entry
- //
- SizeOfHeaders = Hdr.Pe32->OptionalHeader.SizeOfHeaders;
- NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
- DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
- DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
- } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
- //
- // Use PE32+ offset get Debug Directory Entry
- //
- SizeOfHeaders = Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders;
- NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
- DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
- DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
- }
-
- if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {
- DirectoryEntry = NULL;
- DebugEntry = NULL;
- }
- } else {
- return NULL;
- }
-
- if (DebugEntry == NULL || DirectoryEntry == NULL) {
- return NULL;
- }
-
- for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY), DebugEntry++) {
- if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
- if (DebugEntry->SizeOfData > 0) {
- CodeViewEntryPointer = (VOID *) ((UINTN) DebugEntry->RVA + ((UINTN)Pe32Data) + (UINTN)TEImageAdjust);
- switch (* (UINT32 *) CodeViewEntryPointer) {
- case CODEVIEW_SIGNATURE_NB10:
- return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY));
- case CODEVIEW_SIGNATURE_RSDS:
- return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY));
- case CODEVIEW_SIGNATURE_MTOC:
- *DebugBase = (VOID *)(UINTN)((UINTN)DebugBase - SizeOfHeaders);
- return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY));
- default:
- break;
- }
- }
- }
- }
-
- (void)SizeOfHeaders;
- return NULL;
-}
-
-
-
-/**
- Process "qXfer:object:read:annex:offset,length" request.
-
- Returns an XML document that contains loaded libraries. In our case it is
- infomration in the EFI Debug Inmage Table converted into an XML document.
-
- GDB will call with an arbitrary length (it can't know the real length and
- will reply with chunks of XML that are easy for us to deal with. Gdb will
- keep calling until we say we are done. XML doc looks like:
-
- <library-list>
- <library name="/a/a/c/d.dSYM"><segment address="0x10000000"/></library>
- <library name="/a/m/e/e.pdb"><segment address="0x20000000"/></library>
- <library name="/a/l/f/f.dll"><segment address="0x30000000"/></library>
- </library-list>
-
- Since we can not allocate memory in interupt context this module has
- assumptions about how it will get called:
- 1) Length will generally be max remote packet size (big enough)
- 2) First Offset of an XML document read needs to be 0
- 3) This code will return back small chunks of the XML document on every read.
- Each subseqent call will ask for the next availble part of the document.
-
- Note: The only variable size element in the XML is:
- " <library name=\"%s\"><segment address=\"%p\"/></library>\n" and it is
- based on the file path and name of the symbol file. If the symbol file name
- is bigger than the max gdb remote packet size we could update this code
- to respond back in chunks.
-
- @param Offset offset into special data area
- @param Length number of bytes to read starting at Offset
-
- **/
-VOID
-QxferLibrary (
- IN UINTN Offset,
- IN UINTN Length
- )
-{
- VOID *LoadAddress;
- CHAR8 *Pdb;
- UINTN Size;
-
- if (Offset != gPacketqXferLibraryOffset) {
- SendError (GDB_EINVALIDARG);
- Print (L"\nqXferLibrary (%d, %d) != %d\n", Offset, Length, gPacketqXferLibraryOffset);
-
- // Force a retry from the beginning
- gPacketqXferLibraryOffset = 0;
- return;
- }
-
- if (Offset == 0) {
- gPacketqXferLibraryOffset += gXferObjectReadResponse ('m', "<library-list>\n");
-
- // The owner of the table may have had to ralloc it so grab a fresh copy every time
- // we assume qXferLibrary will get called over and over again until the entire XML table is
- // returned in a tight loop. Since we are in the debugger the table should not get updated
- gDebugTable = gDebugImageTableHeader->EfiDebugImageInfoTable;
- gEfiDebugImageTableEntry = 0;
- return;
- }
-
- if (gDebugTable != NULL) {
- for (; gEfiDebugImageTableEntry < gDebugImageTableHeader->TableSize; gEfiDebugImageTableEntry++, gDebugTable++) {
- if (gDebugTable->NormalImage != NULL) {
- if ((gDebugTable->NormalImage->ImageInfoType == EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL) &&
- (gDebugTable->NormalImage->LoadedImageProtocolInstance != NULL)) {
- Pdb = PeCoffLoaderGetDebuggerInfo (
- gDebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase,
- &LoadAddress
- );
- if (Pdb != NULL) {
- Size = AsciiSPrint (
- gXferLibraryBuffer,
- sizeof (gXferLibraryBuffer),
- " <library name=\"%a\"><segment address=\"0x%p\"/></library>\n",
- Pdb,
- LoadAddress
- );
- if ((Size != 0) && (Size != (sizeof (gXferLibraryBuffer) - 1))) {
- gPacketqXferLibraryOffset += gXferObjectReadResponse ('m', gXferLibraryBuffer);
-
- // Update loop variables so we are in the right place when we get back
- gEfiDebugImageTableEntry++;
- gDebugTable++;
- return;
- } else {
- // We could handle <library> entires larger than sizeof (gXferLibraryBuffer) here if
- // needed by breaking up into N packets
- // "<library name=\"%s
- // the rest of the string (as many packets as required
- // \"><segment address=\"%d\"/></library> (fixed size)
- //
- // But right now we just skip any entry that is too big
- }
- }
- }
- }
- }
- }
-
-
- gXferObjectReadResponse ('l', "</library-list>\n");
- gPacketqXferLibraryOffset = 0;
- return;
-}
-
-
-/**
- Exception Hanldler for GDB. It will be called for all exceptions
- registered via the gExceptionType[] array.
-
- @param ExceptionType Exception that is being processed
- @param SystemContext Register content at time of the exception
- **/
-VOID
-EFIAPI
-GdbExceptionHandler (
- IN EFI_EXCEPTION_TYPE ExceptionType,
- IN OUT EFI_SYSTEM_CONTEXT SystemContext
- )
-{
- UINT8 GdbExceptionType;
- CHAR8 *Ptr;
-
-
- if (ValidateException(ExceptionType, SystemContext) == FALSE) {
- return;
- }
-
- RemoveSingleStep (SystemContext);
-
- GdbExceptionType = ConvertEFItoGDBtype (ExceptionType);
- GdbSendTSignal (SystemContext, GdbExceptionType);
-
- for( ; ; ) {
- ReceivePacket (gInBuffer, MAX_BUF_SIZE);
-
- switch (gInBuffer[0]) {
- case '?':
- GdbSendTSignal (SystemContext, GdbExceptionType);
- break;
-
- case 'c':
- ContinueAtAddress (SystemContext, gInBuffer);
- return;
-
- case 'g':
- ReadGeneralRegisters (SystemContext);
- break;
-
- case 'G':
- WriteGeneralRegisters (SystemContext, gInBuffer);
- break;
-
- case 'H':
- //Return "OK" packet since we don't have more than one thread.
- SendSuccess ();
- break;
-
- case 'm':
- ReadFromMemory (gInBuffer);
- break;
-
- case 'M':
- WriteToMemory (gInBuffer);
- break;
-
- case 'P':
- WriteNthRegister (SystemContext, gInBuffer);
- break;
-
- //
- // Still debugging this code. Not used in Darwin
- //
- case 'q':
- // General Query Packets
- if (AsciiStrnCmp (gInBuffer, "qSupported", 10) == 0) {
- // return what we currently support, we don't parse what gdb suports
- AsciiSPrint (gOutBuffer, MAX_BUF_SIZE, "qXfer:libraries:read+;PacketSize=%d", MAX_BUF_SIZE);
- SendPacket (gOutBuffer);
- } else if (AsciiStrnCmp (gInBuffer, "qXfer:libraries:read::", 22) == 0) {
- // ‘qXfer:libraries:read::offset,length
- // gInBuffer[22] is offset string, ++Ptr is length string’
- for (Ptr = &gInBuffer[22]; *Ptr != ','; Ptr++);
-
- // Not sure if multi-radix support is required. Currently only support decimal
- QxferLibrary (AsciiStrHexToUintn (&gInBuffer[22]), AsciiStrHexToUintn (++Ptr));
- } if (AsciiStrnCmp (gInBuffer, "qOffsets", 10) == 0) {
- AsciiSPrint (gOutBuffer, MAX_BUF_SIZE, "Text=1000;Data=f000;Bss=f000");
- SendPacket (gOutBuffer);
- } else {
- //Send empty packet
- SendNotSupported ();
- }
- break;
-
- case 's':
- SingleStep (SystemContext, gInBuffer);
- return;
-
- case 'z':
- RemoveBreakPoint (SystemContext, gInBuffer);
- break;
-
- case 'Z':
- InsertBreakPoint (SystemContext, gInBuffer);
- break;
-
- default:
- //Send empty packet
- SendNotSupported ();
- break;
- }
- }
-}
-
-
-/**
- Periodic callback for GDB. This function is used to catch a ctrl-c or other
- break in type command from GDB.
-
- @param SystemContext Register content at time of the call
- **/
-VOID
-EFIAPI
-GdbPeriodicCallBack (
- IN OUT EFI_SYSTEM_CONTEXT SystemContext
- )
-{
- //
- // gCtrlCBreakFlag may have been set from a previous F response package
- // and we set the global as we need to process it at a point where we
- // can update the system context. If we are in the middle of processing
- // a F Packet it is not safe to read the GDB serial stream so we need
- // to skip it on this check
- //
- if (!gCtrlCBreakFlag && !gProcessingFPacket) {
- //
- // Ctrl-C was not pending so grab any pending characters and see if they
- // are a Ctrl-c (0x03). If so set the Ctrl-C global.
- //
- while (TRUE) {
- if (!GdbIsCharAvailable ()) {
- //
- // No characters are pending so exit the loop
- //
- break;
- }
-
- if (GdbGetChar () == 0x03) {
- gCtrlCBreakFlag = TRUE;
- //
- // We have a ctrl-c so exit the loop
- //
- break;
- }
- }
- }
-
- if (gCtrlCBreakFlag) {
- //
- // Update the context to force a single step trap when we exit the GDB
- // stub. This will trasfer control to GdbExceptionHandler () and let
- // us break into the program. We don't want to break into the GDB stub.
- //
- AddSingleStep (SystemContext);
- gCtrlCBreakFlag = FALSE;
- }
-}
+/** @file\r
+ UEFI driver that implements a GDB stub\r
+\r
+ Note: Any code in the path of the Serial IO output can not call DEBUG as will\r
+ will blow out the stack. Serial IO calls DEBUG, debug calls Serail IO, ...\r
+\r
+\r
+ Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>\r
+\r
+ 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
+**/\r
+\r
+#include <GdbStubInternal.h>\r
+#include <Protocol/DebugPort.h>\r
+\r
+\r
+UINTN gMaxProcessorIndex = 0;\r
+\r
+//\r
+// Buffers for basic gdb communication\r
+//\r
+CHAR8 gInBuffer[MAX_BUF_SIZE];\r
+CHAR8 gOutBuffer[MAX_BUF_SIZE];\r
+\r
+// Assume gdb does a "qXfer:libraries:read::offset,length" when it connects so we can default\r
+// this value to FALSE. Since gdb can reconnect its self a global default is not good enough\r
+BOOLEAN gSymbolTableUpdate = FALSE;\r
+EFI_EVENT gEvent;\r
+VOID *gGdbSymbolEventHandlerRegistration = NULL;\r
+\r
+//\r
+// Globals for returning XML from qXfer:libraries:read packet\r
+//\r
+UINTN gPacketqXferLibraryOffset = 0;\r
+UINTN gEfiDebugImageTableEntry = 0;\r
+EFI_DEBUG_IMAGE_INFO_TABLE_HEADER *gDebugImageTableHeader = NULL;\r
+EFI_DEBUG_IMAGE_INFO *gDebugTable = NULL;\r
+CHAR8 gXferLibraryBuffer[2000];\r
+\r
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexToStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};\r
+\r
+\r
+VOID\r
+EFIAPI\r
+GdbSymbolEventHandler (\r
+ IN EFI_EVENT Event,\r
+ IN VOID *Context\r
+ )\r
+{\r
+}\r
+\r
+\r
+/**\r
+ The user Entry Point for Application. The user code starts with this function\r
+ as the real entry point for the image goes into a library that calls this\r
+ function.\r
+\r
+ @param[in] ImageHandle The firmware allocated handle for the EFI image.\r
+ @param[in] SystemTable A pointer to the EFI System Table.\r
+\r
+ @retval EFI_SUCCESS The entry point is executed successfully.\r
+ @retval other Some error occurs when executing this entry point.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+GdbStubEntry (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_DEBUG_SUPPORT_PROTOCOL *DebugSupport;\r
+ UINTN HandleCount;\r
+ EFI_HANDLE *Handles;\r
+ UINTN Index;\r
+ UINTN Processor;\r
+ BOOLEAN IsaSupported;\r
+\r
+ Status = EfiGetSystemConfigurationTable (&gEfiDebugImageInfoTableGuid, (VOID **)&gDebugImageTableHeader);\r
+ if (EFI_ERROR (Status)) {\r
+ gDebugImageTableHeader = NULL;\r
+ }\r
+\r
+ Status = gBS->LocateHandleBuffer (\r
+ ByProtocol,\r
+ &gEfiDebugSupportProtocolGuid,\r
+ NULL,\r
+ &HandleCount,\r
+ &Handles\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ DEBUG ((EFI_D_ERROR, "Debug Support Protocol not found\n"));\r
+\r
+ return Status;\r
+ }\r
+\r
+ DebugSupport = NULL;\r
+ IsaSupported = FALSE;\r
+ do {\r
+ HandleCount--;\r
+ Status = gBS->HandleProtocol (\r
+ Handles[HandleCount],\r
+ &gEfiDebugSupportProtocolGuid,\r
+ (VOID **) &DebugSupport\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ if (CheckIsa (DebugSupport->Isa)) {\r
+ // We found what we are looking for so break out of the loop\r
+ IsaSupported = TRUE;\r
+ break;\r
+ }\r
+ }\r
+ } while (HandleCount > 0);\r
+ FreePool (Handles);\r
+\r
+ if (!IsaSupported) {\r
+ DEBUG ((EFI_D_ERROR, "Debug Support Protocol does not support our ISA\n"));\r
+\r
+ return EFI_NOT_FOUND;\r
+ }\r
+\r
+ Status = DebugSupport->GetMaximumProcessorIndex (DebugSupport, &gMaxProcessorIndex);\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ DEBUG ((EFI_D_INFO, "Debug Support Protocol ISA %x\n", DebugSupport->Isa));\r
+ DEBUG ((EFI_D_INFO, "Debug Support Protocol Processor Index %d\n", gMaxProcessorIndex));\r
+\r
+ // Call processor-specific init routine\r
+ InitializeProcessor ();\r
+\r
+ for (Processor = 0; Processor <= gMaxProcessorIndex; Processor++) {\r
+ for (Index = 0; Index < MaxEfiException (); Index++) {\r
+ Status = DebugSupport->RegisterExceptionCallback (DebugSupport, Processor, GdbExceptionHandler, gExceptionType[Index].Exception);\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
+ //\r
+ // Current edk2 DebugPort is not interrupt context safe so we can not use it\r
+ //\r
+ Status = DebugSupport->RegisterPeriodicCallback (DebugSupport, Processor, GdbPeriodicCallBack);\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
+\r
+ //\r
+ // This even fires every time an image is added. This allows the stub to know when gdb needs\r
+ // to update the symbol table.\r
+ //\r
+ Status = gBS->CreateEvent (\r
+ EVT_NOTIFY_SIGNAL,\r
+ TPL_CALLBACK,\r
+ GdbSymbolEventHandler,\r
+ NULL,\r
+ &gEvent\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ //\r
+ // Register for protocol notifications on this event\r
+ //\r
+ Status = gBS->RegisterProtocolNotify (\r
+ &gEfiLoadedImageProtocolGuid,\r
+ gEvent,\r
+ &gGdbSymbolEventHandlerRegistration\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+\r
+ if (PcdGetBool (PcdGdbSerial)) {\r
+ GdbInitializeSerialConsole ();\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Transfer length bytes of input buffer, starting at Address, to memory.\r
+\r
+ @param length the number of the bytes to be transferred/written\r
+ @param *address the start address of the transferring/writing the memory\r
+ @param *new_data the new data to be written to memory\r
+ **/\r
+\r
+VOID\r
+TransferFromInBufToMem (\r
+ IN UINTN Length,\r
+ IN unsigned char *Address,\r
+ IN CHAR8 *NewData\r
+ )\r
+{\r
+ CHAR8 c1;\r
+ CHAR8 c2;\r
+\r
+ while (Length-- > 0) {\r
+ c1 = (CHAR8)HexCharToInt (*NewData++);\r
+ c2 = (CHAR8)HexCharToInt (*NewData++);\r
+\r
+ if ((c1 < 0) || (c2 < 0)) {\r
+ Print ((CHAR16 *)L"Bad message from write to memory..\n");\r
+ SendError (GDB_EBADMEMDATA);\r
+ return;\r
+ }\r
+ *Address++ = (UINT8)((c1 << 4) + c2);\r
+ }\r
+\r
+ SendSuccess();\r
+}\r
+\r
+\r
+/**\r
+ Transfer Length bytes of memory starting at Address to an output buffer, OutBuffer. This function will finally send the buffer\r
+ as a packet.\r
+\r
+ @param Length the number of the bytes to be transferred/read\r
+ @param *address pointer to the start address of the transferring/reading the memory\r
+ **/\r
+\r
+VOID\r
+TransferFromMemToOutBufAndSend (\r
+ IN UINTN Length,\r
+ IN unsigned char *Address\r
+ )\r
+{\r
+ // there are Length bytes and every byte is represented as 2 hex chars\r
+ CHAR8 OutBuffer[MAX_BUF_SIZE];\r
+ CHAR8 *OutBufPtr; // pointer to the output buffer\r
+ CHAR8 Char;\r
+\r
+ if (ValidateAddress(Address) == FALSE) {\r
+ SendError(14);\r
+ return;\r
+ }\r
+\r
+ OutBufPtr = OutBuffer;\r
+ while (Length > 0) {\r
+\r
+ Char = mHexToStr[*Address >> 4];\r
+ if ((Char >= 'A') && (Char <= 'F')) {\r
+ Char = Char - 'A' + 'a';\r
+ }\r
+ *OutBufPtr++ = Char;\r
+\r
+ Char = mHexToStr[*Address & 0x0f];\r
+ if ((Char >= 'A') && (Char <= 'F')) {\r
+ Char = Char - 'A' + 'a';\r
+ }\r
+ *OutBufPtr++ = Char;\r
+\r
+ Address++;\r
+ Length--;\r
+ }\r
+\r
+ *OutBufPtr = '\0' ; // the end of the buffer\r
+ SendPacket (OutBuffer);\r
+}\r
+\r
+\r
+\r
+/**\r
+ Send a GDB Remote Serial Protocol Packet\r
+\r
+ $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$',\r
+ the packet teminating character '#' and the two digit checksum.\r
+\r
+ If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up\r
+ in an infinit loop. This is so if you unplug the debugger code just keeps running\r
+\r
+ @param PacketData Payload data for the packet\r
+\r
+\r
+ @retval Number of bytes of packet data sent.\r
+\r
+**/\r
+UINTN\r
+SendPacket (\r
+ IN CHAR8 *PacketData\r
+ )\r
+{\r
+ UINT8 CheckSum;\r
+ UINTN Timeout;\r
+ CHAR8 *Ptr;\r
+ CHAR8 TestChar;\r
+ UINTN Count;\r
+\r
+ Timeout = PcdGet32 (PcdGdbMaxPacketRetryCount);\r
+\r
+ Count = 0;\r
+ do {\r
+\r
+ Ptr = PacketData;\r
+\r
+ if (Timeout-- == 0) {\r
+ // Only try a finite number of times so we don't get stuck in the loop\r
+ return Count;\r
+ }\r
+\r
+ // Packet prefix\r
+ GdbPutChar ('$');\r
+\r
+ for (CheckSum = 0, Count =0 ; *Ptr != '\0'; Ptr++, Count++) {\r
+ GdbPutChar (*Ptr);\r
+ CheckSum = CheckSum + *Ptr;\r
+ }\r
+\r
+ // Packet terminating character and checksum\r
+ GdbPutChar ('#');\r
+ GdbPutChar (mHexToStr[CheckSum >> 4]);\r
+ GdbPutChar (mHexToStr[CheckSum & 0x0F]);\r
+\r
+ TestChar = GdbGetChar ();\r
+ } while (TestChar != '+');\r
+\r
+ return Count;\r
+}\r
+\r
+/**\r
+ Receive a GDB Remote Serial Protocol Packet\r
+\r
+ $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$',\r
+ the packet teminating character '#' and the two digit checksum.\r
+\r
+ If host re-starts sending a packet without ending the previous packet, only the last valid packet is proccessed.\r
+ (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)\r
+\r
+ If an ack '+' is not sent resend the packet\r
+\r
+ @param PacketData Payload data for the packet\r
+\r
+ @retval Number of bytes of packet data received.\r
+\r
+**/\r
+UINTN\r
+ReceivePacket (\r
+ OUT CHAR8 *PacketData,\r
+ IN UINTN PacketDataSize\r
+ )\r
+{\r
+ UINT8 CheckSum;\r
+ UINTN Index;\r
+ CHAR8 Char;\r
+ CHAR8 SumString[3];\r
+ CHAR8 TestChar;\r
+\r
+ ZeroMem (PacketData, PacketDataSize);\r
+\r
+ for (;;) {\r
+ // wait for the start of a packet\r
+ TestChar = GdbGetChar ();\r
+ while (TestChar != '$') {\r
+ TestChar = GdbGetChar ();\r
+ };\r
+\r
+ retry:\r
+ for (Index = 0, CheckSum = 0; Index < (PacketDataSize - 1); Index++) {\r
+ Char = GdbGetChar ();\r
+ if (Char == '$') {\r
+ goto retry;\r
+ }\r
+ if (Char == '#') {\r
+ break;\r
+ }\r
+\r
+ PacketData[Index] = Char;\r
+ CheckSum = CheckSum + Char;\r
+ }\r
+ PacketData[Index] = '\0';\r
+\r
+ if (Index == PacketDataSize) {\r
+ continue;\r
+ }\r
+\r
+ SumString[0] = GdbGetChar ();\r
+ SumString[1] = GdbGetChar ();\r
+ SumString[2] = '\0';\r
+\r
+ if (AsciiStrHexToUintn (SumString) == CheckSum) {\r
+ // Ack: Success\r
+ GdbPutChar ('+');\r
+\r
+ // Null terminate the callers string\r
+ PacketData[Index] = '\0';\r
+ return Index;\r
+ } else {\r
+ // Ack: Failure\r
+ GdbPutChar ('-');\r
+ }\r
+ }\r
+\r
+ //return 0;\r
+}\r
+\r
+\r
+/**\r
+ Empties the given buffer\r
+ @param Buf pointer to the first element in buffer to be emptied\r
+ **/\r
+VOID\r
+EmptyBuffer (\r
+ IN CHAR8 *Buf\r
+ )\r
+{\r
+ *Buf = '\0';\r
+}\r
+\r
+\r
+/**\r
+ Converts an 8-bit Hex Char into a INTN.\r
+\r
+ @param Char the hex character to be converted into UINTN\r
+ @retval a INTN, from 0 to 15, that corressponds to Char\r
+ -1 if Char is not a hex character\r
+ **/\r
+INTN\r
+HexCharToInt (\r
+ IN CHAR8 Char\r
+ )\r
+{\r
+ if ((Char >= 'A') && (Char <= 'F')) {\r
+ return Char - 'A' + 10;\r
+ } else if ((Char >= 'a') && (Char <= 'f')) {\r
+ return Char - 'a' + 10;\r
+ } else if ((Char >= '0') && (Char <= '9')) {\r
+ return Char - '0';\r
+ } else { // if not a hex value, return a negative value\r
+ return -1;\r
+ }\r
+}\r
+\r
+ // 'E' + the biggest error number is 255, so its 2 hex digits + buffer end\r
+CHAR8 *gError = "E__";\r
+\r
+/** 'E NN'\r
+ Send an error with the given error number after converting to hex.\r
+ The error number is put into the buffer in hex. '255' is the biggest errno we can send.\r
+ ex: 162 will be sent as A2.\r
+\r
+ @param errno the error number that will be sent\r
+ **/\r
+VOID\r
+EFIAPI\r
+SendError (\r
+ IN UINT8 ErrorNum\r
+ )\r
+{\r
+ //\r
+ // Replace _, or old data, with current errno\r
+ //\r
+ gError[1] = mHexToStr [ErrorNum >> 4];\r
+ gError[2] = mHexToStr [ErrorNum & 0x0f];\r
+\r
+ SendPacket (gError); // send buffer\r
+}\r
+\r
+\r
+\r
+/**\r
+ Send 'OK' when the function is done executing successfully.\r
+ **/\r
+VOID\r
+EFIAPI\r
+SendSuccess (\r
+ VOID\r
+ )\r
+{\r
+ SendPacket ("OK"); // send buffer\r
+}\r
+\r
+\r
+/**\r
+ Send empty packet to specify that particular command/functionality is not supported.\r
+ **/\r
+VOID\r
+EFIAPI\r
+SendNotSupported (\r
+ VOID\r
+ )\r
+{\r
+ SendPacket ("");\r
+}\r
+\r
+\r
+/**\r
+ Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints\r
+\r
+ @param SystemContext Register content at time of the exception\r
+ @param GdbExceptionType GDB exception type\r
+ **/\r
+VOID\r
+GdbSendTSignal (\r
+ IN EFI_SYSTEM_CONTEXT SystemContext,\r
+ IN UINT8 GdbExceptionType\r
+ )\r
+{\r
+ CHAR8 TSignalBuffer[128];\r
+ CHAR8 *TSignalPtr;\r
+ UINTN BreakpointDetected;\r
+ BREAK_TYPE BreakType;\r
+ UINTN DataAddress;\r
+ CHAR8 *WatchStrPtr = NULL;\r
+ UINTN RegSize;\r
+\r
+ TSignalPtr = &TSignalBuffer[0];\r
+\r
+ //Construct TSignal packet\r
+ *TSignalPtr++ = 'T';\r
+\r
+ //\r
+ // replace _, or previous value, with Exception type\r
+ //\r
+ *TSignalPtr++ = mHexToStr [GdbExceptionType >> 4];\r
+ *TSignalPtr++ = mHexToStr [GdbExceptionType & 0x0f];\r
+\r
+ if (GdbExceptionType == GDB_SIGTRAP) {\r
+ if (gSymbolTableUpdate) {\r
+ //\r
+ // We can only send back on reason code. So if the flag is set it means the breakpoint is from our event handler\r
+ //\r
+ WatchStrPtr = "library:;";\r
+ while (*WatchStrPtr != '\0') {\r
+ *TSignalPtr++ = *WatchStrPtr++;\r
+ }\r
+ gSymbolTableUpdate = FALSE;\r
+ } else {\r
+\r
+\r
+ //\r
+ // possible n:r pairs\r
+ //\r
+\r
+ //Retrieve the breakpoint number\r
+ BreakpointDetected = GetBreakpointDetected (SystemContext);\r
+\r
+ //Figure out if the exception is happend due to watch, rwatch or awatch.\r
+ BreakType = GetBreakpointType (SystemContext, BreakpointDetected);\r
+\r
+ //INFO: rwatch is not supported due to the way IA32 debug registers work\r
+ if ((BreakType == DataWrite) || (BreakType == DataRead) || (BreakType == DataReadWrite)) {\r
+\r
+ //Construct n:r pair\r
+ DataAddress = GetBreakpointDataAddress (SystemContext, BreakpointDetected);\r
+\r
+ //Assign appropriate buffer to print particular watchpoint type\r
+ if (BreakType == DataWrite) {\r
+ WatchStrPtr = "watch";\r
+ } else if (BreakType == DataRead) {\r
+ WatchStrPtr = "rwatch";\r
+ } else if (BreakType == DataReadWrite) {\r
+ WatchStrPtr = "awatch";\r
+ }\r
+\r
+ while (*WatchStrPtr != '\0') {\r
+ *TSignalPtr++ = *WatchStrPtr++;\r
+ }\r
+\r
+ *TSignalPtr++ = ':';\r
+\r
+ //Set up series of bytes in big-endian byte order. "awatch" won't work with little-endian byte order.\r
+ RegSize = REG_SIZE;\r
+ while (RegSize > 0) {\r
+ RegSize = RegSize-4;\r
+ *TSignalPtr++ = mHexToStr[(UINT8)(DataAddress >> RegSize) & 0xf];\r
+ }\r
+\r
+ //Always end n:r pair with ';'\r
+ *TSignalPtr++ = ';';\r
+ }\r
+ }\r
+ }\r
+\r
+ *TSignalPtr = '\0';\r
+\r
+ SendPacket (TSignalBuffer);\r
+}\r
+\r
+\r
+/**\r
+ Translates the EFI mapping to GDB mapping\r
+\r
+ @param EFIExceptionType EFI Exception that is being processed\r
+ @retval UINTN that corresponds to EFIExceptionType's GDB exception type number\r
+ **/\r
+UINT8\r
+ConvertEFItoGDBtype (\r
+ IN EFI_EXCEPTION_TYPE EFIExceptionType\r
+ )\r
+{\r
+ UINTN Index;\r
+\r
+ for (Index = 0; Index < MaxEfiException () ; Index++) {\r
+ if (gExceptionType[Index].Exception == EFIExceptionType) {\r
+ return gExceptionType[Index].SignalNo;\r
+ }\r
+ }\r
+ return GDB_SIGTRAP; // this is a GDB trap\r
+}\r
+\r
+\r
+/** "m addr,length"\r
+ Find the Length of the area to read and the start addres. Finally, pass them to\r
+ another function, TransferFromMemToOutBufAndSend, that will read from that memory space and\r
+ send it as a packet.\r
+ **/\r
+\r
+VOID\r
+EFIAPI\r
+ReadFromMemory (\r
+ CHAR8 *PacketData\r
+ )\r
+{\r
+ UINTN Address;\r
+ UINTN Length;\r
+ CHAR8 AddressBuffer[MAX_ADDR_SIZE]; // the buffer that will hold the address in hex chars\r
+ CHAR8 *AddrBufPtr; // pointer to the address buffer\r
+ CHAR8 *InBufPtr; /// pointer to the input buffer\r
+\r
+ AddrBufPtr = AddressBuffer;\r
+ InBufPtr = &PacketData[1];\r
+ while (*InBufPtr != ',') {\r
+ *AddrBufPtr++ = *InBufPtr++;\r
+ }\r
+ *AddrBufPtr = '\0';\r
+\r
+ InBufPtr++; // this skips ',' in the buffer\r
+\r
+ /* Error checking */\r
+ if (AsciiStrLen (AddressBuffer) >= MAX_ADDR_SIZE) {\r
+ Print((CHAR16 *)L"Address is too long\n");\r
+ SendError (GDB_EBADMEMADDRBUFSIZE);\r
+ return;\r
+ }\r
+\r
+ // 2 = 'm' + ','\r
+ if (AsciiStrLen (PacketData) - AsciiStrLen (AddressBuffer) - 2 >= MAX_LENGTH_SIZE) {\r
+ Print((CHAR16 *)L"Length is too long\n");\r
+ SendError (GDB_EBADMEMLENGTH);\r
+ return;\r
+ }\r
+\r
+ Address = AsciiStrHexToUintn (AddressBuffer);\r
+ Length = AsciiStrHexToUintn (InBufPtr);\r
+\r
+ TransferFromMemToOutBufAndSend (Length, (unsigned char *)Address);\r
+}\r
+\r
+\r
+/** "M addr,length :XX..."\r
+ Find the Length of the area in bytes to write and the start addres. Finally, pass them to\r
+ another function, TransferFromInBufToMem, that will write to that memory space the info in\r
+ the input buffer.\r
+ **/\r
+VOID\r
+EFIAPI\r
+WriteToMemory (\r
+ IN CHAR8 *PacketData\r
+ )\r
+{\r
+ UINTN Address;\r
+ UINTN Length;\r
+ UINTN MessageLength;\r
+ CHAR8 AddressBuffer[MAX_ADDR_SIZE]; // the buffer that will hold the Address in hex chars\r
+ CHAR8 LengthBuffer[MAX_LENGTH_SIZE]; // the buffer that will hold the Length in hex chars\r
+ CHAR8 *AddrBufPtr; // pointer to the Address buffer\r
+ CHAR8 *LengthBufPtr; // pointer to the Length buffer\r
+ CHAR8 *InBufPtr; /// pointer to the input buffer\r
+\r
+ AddrBufPtr = AddressBuffer;\r
+ LengthBufPtr = LengthBuffer;\r
+ InBufPtr = &PacketData[1];\r
+\r
+ while (*InBufPtr != ',') {\r
+ *AddrBufPtr++ = *InBufPtr++;\r
+ }\r
+ *AddrBufPtr = '\0';\r
+\r
+ InBufPtr++; // this skips ',' in the buffer\r
+\r
+ while (*InBufPtr != ':') {\r
+ *LengthBufPtr++ = *InBufPtr++;\r
+ }\r
+ *LengthBufPtr = '\0';\r
+\r
+ InBufPtr++; // this skips ':' in the buffer\r
+\r
+ Address = AsciiStrHexToUintn (AddressBuffer);\r
+ Length = AsciiStrHexToUintn (LengthBuffer);\r
+\r
+ /* Error checking */\r
+\r
+ //Check if Address is not too long.\r
+ if (AsciiStrLen (AddressBuffer) >= MAX_ADDR_SIZE) {\r
+ Print ((CHAR16 *)L"Address too long..\n");\r
+ SendError (GDB_EBADMEMADDRBUFSIZE);\r
+ return;\r
+ }\r
+\r
+ //Check if message length is not too long\r
+ if (AsciiStrLen (LengthBuffer) >= MAX_LENGTH_SIZE) {\r
+ Print ((CHAR16 *)L"Length too long..\n");\r
+ SendError (GDB_EBADMEMLENGBUFSIZE);\r
+ return;\r
+ }\r
+\r
+ // Check if Message is not too long/short.\r
+ // 3 = 'M' + ',' + ':'\r
+ MessageLength = (AsciiStrLen (PacketData) - AsciiStrLen (AddressBuffer) - AsciiStrLen (LengthBuffer) - 3);\r
+ if (MessageLength != (2*Length)) {\r
+ //Message too long/short. New data is not the right size.\r
+ SendError (GDB_EBADMEMDATASIZE);\r
+ return;\r
+ }\r
+ TransferFromInBufToMem (Length, (unsigned char *)Address, InBufPtr);\r
+}\r
+\r
+/**\r
+ Parses breakpoint packet data and captures Breakpoint type, Address and length.\r
+ In case of an error, function returns particular error code. Returning 0 meaning\r
+ no error.\r
+\r
+ @param PacketData Pointer to the payload data for the packet.\r
+ @param Type Breakpoint type\r
+ @param Address Breakpoint address\r
+ @param Length Breakpoint length in Bytes (1 byte, 2 byte, 4 byte)\r
+\r
+ @retval 1 Success\r
+ @retval {other} Particular error code\r
+\r
+**/\r
+UINTN\r
+ParseBreakpointPacket (\r
+ IN CHAR8 *PacketData,\r
+ OUT UINTN *Type,\r
+ OUT UINTN *Address,\r
+ OUT UINTN *Length\r
+ )\r
+{\r
+ CHAR8 AddressBuffer[MAX_ADDR_SIZE];\r
+ CHAR8 *AddressBufferPtr;\r
+ CHAR8 *PacketDataPtr;\r
+\r
+ PacketDataPtr = &PacketData[1];\r
+ AddressBufferPtr = AddressBuffer;\r
+\r
+ *Type = AsciiStrHexToUintn (PacketDataPtr);\r
+\r
+ //Breakpoint/watchpoint type should be between 0 to 4\r
+ if (*Type > 4) {\r
+ Print ((CHAR16 *)L"Type is invalid\n");\r
+ return 22; //EINVAL: Invalid argument.\r
+ }\r
+\r
+ //Skip ',' in the buffer.\r
+ while (*PacketDataPtr++ != ',');\r
+\r
+ //Parse Address information\r
+ while (*PacketDataPtr != ',') {\r
+ *AddressBufferPtr++ = *PacketDataPtr++;\r
+ }\r
+ *AddressBufferPtr = '\0';\r
+\r
+ //Check if Address is not too long.\r
+ if (AsciiStrLen (AddressBuffer) >= MAX_ADDR_SIZE) {\r
+ Print ((CHAR16 *)L"Address too long..\n");\r
+ return 40; //EMSGSIZE: Message size too long.\r
+ }\r
+\r
+ *Address = AsciiStrHexToUintn (AddressBuffer);\r
+\r
+ PacketDataPtr++; //This skips , in the buffer\r
+\r
+ //Parse Length information\r
+ *Length = AsciiStrHexToUintn (PacketDataPtr);\r
+\r
+ //Length should be 1, 2 or 4 bytes\r
+ if (*Length > 4) {\r
+ Print ((CHAR16 *)L"Length is invalid\n");\r
+ return 22; //EINVAL: Invalid argument\r
+ }\r
+\r
+ return 0; //0 = No error\r
+}\r
+\r
+UINTN\r
+gXferObjectReadResponse (\r
+ IN CHAR8 Type,\r
+ IN CHAR8 *Str\r
+ )\r
+{\r
+ CHAR8 *OutBufPtr; // pointer to the output buffer\r
+ CHAR8 Char;\r
+ UINTN Count;\r
+\r
+ // Response starts with 'm' or 'l' if it is the end\r
+ OutBufPtr = gOutBuffer;\r
+ *OutBufPtr++ = Type;\r
+ Count = 1;\r
+\r
+ // Binary data encoding\r
+ OutBufPtr = gOutBuffer;\r
+ while (*Str != '\0') {\r
+ Char = *Str++;\r
+ if ((Char == 0x7d) || (Char == 0x23) || (Char == 0x24) || (Char == 0x2a)) {\r
+ // escape character\r
+ *OutBufPtr++ = 0x7d;\r
+\r
+ Char ^= 0x20;\r
+ }\r
+ *OutBufPtr++ = Char;\r
+ Count++;\r
+ }\r
+\r
+ *OutBufPtr = '\0' ; // the end of the buffer\r
+ SendPacket (gOutBuffer);\r
+\r
+ return Count;\r
+}\r
+\r
+\r
+/**\r
+ Note: This should be a library function. In the Apple case you have to add\r
+ the size of the PE/COFF header into the starting address to make things work\r
+ right as there is no way to pad the Mach-O for the size of the PE/COFF header.\r
+\r
+\r
+ Returns a pointer to the PDB file name for a PE/COFF image that has been\r
+ loaded into system memory with the PE/COFF Loader Library functions.\r
+\r
+ Returns the PDB file name for the PE/COFF image specified by Pe32Data. If\r
+ the PE/COFF image specified by Pe32Data is not a valid, then NULL is\r
+ returned. If the PE/COFF image specified by Pe32Data does not contain a\r
+ debug directory entry, then NULL is returned. If the debug directory entry\r
+ in the PE/COFF image specified by Pe32Data does not contain a PDB file name,\r
+ then NULL is returned.\r
+ If Pe32Data is NULL, then ASSERT().\r
+\r
+ @param Pe32Data Pointer to the PE/COFF image that is loaded in system\r
+ memory.\r
+ @param DebugBase Address that the debugger would use as the base of the image\r
+\r
+ @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL\r
+ if it cannot be retrieved. DebugBase is only valid if PDB file name is\r
+ valid.\r
+\r
+**/\r
+VOID *\r
+EFIAPI\r
+PeCoffLoaderGetDebuggerInfo (\r
+ IN VOID *Pe32Data,\r
+ OUT VOID **DebugBase\r
+ )\r
+{\r
+ EFI_IMAGE_DOS_HEADER *DosHdr;\r
+ EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr;\r
+ EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry;\r
+ EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry;\r
+ UINTN DirCount;\r
+ VOID *CodeViewEntryPointer;\r
+ INTN TEImageAdjust;\r
+ UINT32 NumberOfRvaAndSizes;\r
+ UINT16 Magic;\r
+ UINTN SizeOfHeaders;\r
+\r
+ ASSERT (Pe32Data != NULL);\r
+\r
+ TEImageAdjust = 0;\r
+ DirectoryEntry = NULL;\r
+ DebugEntry = NULL;\r
+ NumberOfRvaAndSizes = 0;\r
+ SizeOfHeaders = 0;\r
+\r
+ DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;\r
+ if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {\r
+ //\r
+ // DOS image header is present, so read the PE header after the DOS image header.\r
+ //\r
+ Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));\r
+ } else {\r
+ //\r
+ // DOS image header is not present, so PE header is at the image base.\r
+ //\r
+ Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;\r
+ }\r
+\r
+ if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {\r
+ if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) {\r
+ DirectoryEntry = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG];\r
+ TEImageAdjust = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize;\r
+ DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te +\r
+ Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress +\r
+ TEImageAdjust);\r
+ }\r
+ SizeOfHeaders = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN)Hdr.Te->BaseOfCode - (UINTN)Hdr.Te->StrippedSize;\r
+\r
+ // __APPLE__ check this math...\r
+ *DebugBase = ((CHAR8 *)Pe32Data) - TEImageAdjust;\r
+ } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {\r
+\r
+ *DebugBase = Pe32Data;\r
+\r
+\r
+ //\r
+ // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic.\r
+ // It is due to backward-compatibility, for some system might\r
+ // generate PE32+ image with PE32 Magic.\r
+ //\r
+ switch (Hdr.Pe32->FileHeader.Machine) {\r
+ case EFI_IMAGE_MACHINE_IA32:\r
+ //\r
+ // Assume PE32 image with IA32 Machine field.\r
+ //\r
+ Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;\r
+ break;\r
+ case EFI_IMAGE_MACHINE_X64:\r
+ case EFI_IMAGE_MACHINE_IA64:\r
+ //\r
+ // Assume PE32+ image with X64 or IPF Machine field\r
+ //\r
+ Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
+ break;\r
+ default:\r
+ //\r
+ // For unknow Machine field, use Magic in optional Header\r
+ //\r
+ Magic = Hdr.Pe32->OptionalHeader.Magic;\r
+ }\r
+\r
+ if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
+ //\r
+ // Use PE32 offset get Debug Directory Entry\r
+ //\r
+ SizeOfHeaders = Hdr.Pe32->OptionalHeader.SizeOfHeaders;\r
+ NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;\r
+ DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
+ DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);\r
+ } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {\r
+ //\r
+ // Use PE32+ offset get Debug Directory Entry\r
+ //\r
+ SizeOfHeaders = Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders;\r
+ NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;\r
+ DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
+ DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);\r
+ }\r
+\r
+ if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {\r
+ DirectoryEntry = NULL;\r
+ DebugEntry = NULL;\r
+ }\r
+ } else {\r
+ return NULL;\r
+ }\r
+\r
+ if (DebugEntry == NULL || DirectoryEntry == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY), DebugEntry++) {\r
+ if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {\r
+ if (DebugEntry->SizeOfData > 0) {\r
+ CodeViewEntryPointer = (VOID *) ((UINTN) DebugEntry->RVA + ((UINTN)Pe32Data) + (UINTN)TEImageAdjust);\r
+ switch (* (UINT32 *) CodeViewEntryPointer) {\r
+ case CODEVIEW_SIGNATURE_NB10:\r
+ return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY));\r
+ case CODEVIEW_SIGNATURE_RSDS:\r
+ return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY));\r
+ case CODEVIEW_SIGNATURE_MTOC:\r
+ *DebugBase = (VOID *)(UINTN)((UINTN)DebugBase - SizeOfHeaders);\r
+ return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY));\r
+ default:\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ (void)SizeOfHeaders;\r
+ return NULL;\r
+}\r
+\r
+\r
+/**\r
+ Process "qXfer:object:read:annex:offset,length" request.\r
+\r
+ Returns an XML document that contains loaded libraries. In our case it is\r
+ information in the EFI Debug Image Table converted into an XML document.\r
+\r
+ GDB will call with an arbitrary length (it can't know the real length and\r
+ will reply with chunks of XML that are easy for us to deal with. Gdb will\r
+ keep calling until we say we are done. XML doc looks like:\r
+\r
+ <library-list>\r
+ <library name="/a/a/c/d.dSYM"><segment address="0x10000000"/></library>\r
+ <library name="/a/m/e/e.pdb"><segment address="0x20000000"/></library>\r
+ <library name="/a/l/f/f.dll"><segment address="0x30000000"/></library>\r
+ </library-list>\r
+\r
+ Since we can not allocate memory in interrupt context this module has\r
+ assumptions about how it will get called:\r
+ 1) Length will generally be max remote packet size (big enough)\r
+ 2) First Offset of an XML document read needs to be 0\r
+ 3) This code will return back small chunks of the XML document on every read.\r
+ Each subsequent call will ask for the next available part of the document.\r
+\r
+ Note: The only variable size element in the XML is:\r
+ " <library name=\"%s\"><segment address=\"%p\"/></library>\n" and it is\r
+ based on the file path and name of the symbol file. If the symbol file name\r
+ is bigger than the max gdb remote packet size we could update this code\r
+ to respond back in chunks.\r
+\r
+ @param Offset offset into special data area\r
+ @param Length number of bytes to read starting at Offset\r
+\r
+ **/\r
+VOID\r
+QxferLibrary (\r
+ IN UINTN Offset,\r
+ IN UINTN Length\r
+ )\r
+{\r
+ VOID *LoadAddress;\r
+ CHAR8 *Pdb;\r
+ UINTN Size;\r
+\r
+ if (Offset != gPacketqXferLibraryOffset) {\r
+ SendError (GDB_EINVALIDARG);\r
+ Print (L"\nqXferLibrary (%d, %d) != %d\n", Offset, Length, gPacketqXferLibraryOffset);\r
+\r
+ // Force a retry from the beginning\r
+ gPacketqXferLibraryOffset = 0;\r
+\r
+ return;\r
+ }\r
+\r
+ if (Offset == 0) {\r
+ gPacketqXferLibraryOffset += gXferObjectReadResponse ('m', "<library-list>\n");\r
+\r
+ // The owner of the table may have had to ralloc it so grab a fresh copy every time\r
+ // we assume qXferLibrary will get called over and over again until the entire XML table is\r
+ // returned in a tight loop. Since we are in the debugger the table should not get updated\r
+ gDebugTable = gDebugImageTableHeader->EfiDebugImageInfoTable;\r
+ gEfiDebugImageTableEntry = 0;\r
+ return;\r
+ }\r
+\r
+ if (gDebugTable != NULL) {\r
+ for (; gEfiDebugImageTableEntry < gDebugImageTableHeader->TableSize; gEfiDebugImageTableEntry++, gDebugTable++) {\r
+ if (gDebugTable->NormalImage != NULL) {\r
+ if ((gDebugTable->NormalImage->ImageInfoType == EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL) &&\r
+ (gDebugTable->NormalImage->LoadedImageProtocolInstance != NULL)) {\r
+ Pdb = PeCoffLoaderGetDebuggerInfo (\r
+ gDebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase,\r
+ &LoadAddress\r
+ );\r
+ if (Pdb != NULL) {\r
+ Size = AsciiSPrint (\r
+ gXferLibraryBuffer,\r
+ sizeof (gXferLibraryBuffer),\r
+ " <library name=\"%a\"><segment address=\"0x%p\"/></library>\n",\r
+ Pdb,\r
+ LoadAddress\r
+ );\r
+ if ((Size != 0) && (Size != (sizeof (gXferLibraryBuffer) - 1))) {\r
+ gPacketqXferLibraryOffset += gXferObjectReadResponse ('m', gXferLibraryBuffer);\r
+\r
+ // Update loop variables so we are in the right place when we get back\r
+ gEfiDebugImageTableEntry++;\r
+ gDebugTable++;\r
+ return;\r
+ } else {\r
+ // We could handle <library> entires larger than sizeof (gXferLibraryBuffer) here if\r
+ // needed by breaking up into N packets\r
+ // "<library name=\"%s\r
+ // the rest of the string (as many packets as required\r
+ // \"><segment address=\"%d\"/></library> (fixed size)\r
+ //\r
+ // But right now we just skip any entry that is too big\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ gXferObjectReadResponse ('l', "</library-list>\n");\r
+ gPacketqXferLibraryOffset = 0;\r
+ return;\r
+}\r
+\r
+\r
+/**\r
+ Exception Hanldler for GDB. It will be called for all exceptions\r
+ registered via the gExceptionType[] array.\r
+\r
+ @param ExceptionType Exception that is being processed\r
+ @param SystemContext Register content at time of the exception\r
+ **/\r
+VOID\r
+EFIAPI\r
+GdbExceptionHandler (\r
+ IN EFI_EXCEPTION_TYPE ExceptionType,\r
+ IN OUT EFI_SYSTEM_CONTEXT SystemContext\r
+ )\r
+{\r
+ UINT8 GdbExceptionType;\r
+ CHAR8 *Ptr;\r
+\r
+\r
+ if (ValidateException (ExceptionType, SystemContext) == FALSE) {\r
+ return;\r
+ }\r
+\r
+ RemoveSingleStep (SystemContext);\r
+\r
+ GdbExceptionType = ConvertEFItoGDBtype (ExceptionType);\r
+ GdbSendTSignal (SystemContext, GdbExceptionType);\r
+\r
+ for( ; ; ) {\r
+ ReceivePacket (gInBuffer, MAX_BUF_SIZE);\r
+\r
+ switch (gInBuffer[0]) {\r
+ case '?':\r
+ GdbSendTSignal (SystemContext, GdbExceptionType);\r
+ break;\r
+\r
+ case 'c':\r
+ ContinueAtAddress (SystemContext, gInBuffer);\r
+ return;\r
+\r
+ case 'g':\r
+ ReadGeneralRegisters (SystemContext);\r
+ break;\r
+\r
+ case 'G':\r
+ WriteGeneralRegisters (SystemContext, gInBuffer);\r
+ break;\r
+\r
+ case 'H':\r
+ //Return "OK" packet since we don't have more than one thread.\r
+ SendSuccess ();\r
+ break;\r
+\r
+ case 'm':\r
+ ReadFromMemory (gInBuffer);\r
+ break;\r
+\r
+ case 'M':\r
+ WriteToMemory (gInBuffer);\r
+ break;\r
+\r
+ case 'P':\r
+ WriteNthRegister (SystemContext, gInBuffer);\r
+ break;\r
+\r
+ //\r
+ // Still debugging this code. Not used in Darwin\r
+ //\r
+ case 'q':\r
+ // General Query Packets\r
+ if (AsciiStrnCmp (gInBuffer, "qSupported", 10) == 0) {\r
+ // return what we currently support, we don't parse what gdb suports\r
+ AsciiSPrint (gOutBuffer, MAX_BUF_SIZE, "qXfer:libraries:read+;PacketSize=%d", MAX_BUF_SIZE);\r
+ SendPacket (gOutBuffer);\r
+ } else if (AsciiStrnCmp (gInBuffer, "qXfer:libraries:read::", 22) == 0) {\r
+ // ‘qXfer:libraries:read::offset,length\r
+ // gInBuffer[22] is offset string, ++Ptr is length string’\r
+ for (Ptr = &gInBuffer[22]; *Ptr != ','; Ptr++);\r
+\r
+ // Not sure if multi-radix support is required. Currently only support decimal\r
+ QxferLibrary (AsciiStrHexToUintn (&gInBuffer[22]), AsciiStrHexToUintn (++Ptr));\r
+ } if (AsciiStrnCmp (gInBuffer, "qOffsets", 10) == 0) {\r
+ AsciiSPrint (gOutBuffer, MAX_BUF_SIZE, "Text=1000;Data=f000;Bss=f000");\r
+ SendPacket (gOutBuffer);\r
+ } else {\r
+ //Send empty packet\r
+ SendNotSupported ();\r
+ }\r
+ break;\r
+\r
+ case 's':\r
+ SingleStep (SystemContext, gInBuffer);\r
+ return;\r
+\r
+ case 'z':\r
+ RemoveBreakPoint (SystemContext, gInBuffer);\r
+ break;\r
+\r
+ case 'Z':\r
+ InsertBreakPoint (SystemContext, gInBuffer);\r
+ break;\r
+\r
+ default:\r
+ //Send empty packet\r
+ SendNotSupported ();\r
+ break;\r
+ }\r
+ }\r
+}\r
+\r
+\r
+/**\r
+ Periodic callback for GDB. This function is used to catch a ctrl-c or other\r
+ break in type command from GDB.\r
+\r
+ @param SystemContext Register content at time of the call\r
+ **/\r
+VOID\r
+EFIAPI\r
+GdbPeriodicCallBack (\r
+ IN OUT EFI_SYSTEM_CONTEXT SystemContext\r
+ )\r
+{\r
+ //\r
+ // gCtrlCBreakFlag may have been set from a previous F response package\r
+ // and we set the global as we need to process it at a point where we\r
+ // can update the system context. If we are in the middle of processing\r
+ // a F Packet it is not safe to read the GDB serial stream so we need\r
+ // to skip it on this check\r
+ //\r
+ if (!gCtrlCBreakFlag && !gProcessingFPacket) {\r
+ //\r
+ // Ctrl-C was not pending so grab any pending characters and see if they\r
+ // are a Ctrl-c (0x03). If so set the Ctrl-C global.\r
+ //\r
+ while (TRUE) {\r
+ if (!GdbIsCharAvailable ()) {\r
+ //\r
+ // No characters are pending so exit the loop\r
+ //\r
+ break;\r
+ }\r
+\r
+ if (GdbGetChar () == 0x03) {\r
+ gCtrlCBreakFlag = TRUE;\r
+ //\r
+ // We have a ctrl-c so exit the loop\r
+ //\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ if (gCtrlCBreakFlag) {\r
+ //\r
+ // Update the context to force a single step trap when we exit the GDB\r
+ // stub. This will transfer control to GdbExceptionHandler () and let\r
+ // us break into the program. We don't want to break into the GDB stub.\r
+ //\r
+ AddSingleStep (SystemContext);\r
+ gCtrlCBreakFlag = FALSE;\r
+ }\r
+}\r
projects / mirror_edk2.git / blobdiff