haiku.git

/*
 * Copyright 2005-2007, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 *
 * Copyright 2002, Manuel J. Petit. All rights reserved.
 * Distributed under the terms of the NewOS License.
 */

/** Contains the code to interface with a remote GDB */

#include "gdb.h"

#include <string.h>
#include <stdarg.h>
#include <stdio.h>

#include <ByteOrder.h>

#include <arch/debug.h>
#include <arch/debug_console.h>
#include <debug.h>
#include <elf.h>
#include <elf_priv.h>
#include <smp.h>
#include <vm/vm.h>


enum { INIT = 0, CMDREAD, CKSUM1, CKSUM2, WAITACK, QUIT, GDBSTATES };


static char sCommand[512];
static int sCommandIndex;
static int sCheckSum;

static char sReply[512];
static char sSafeMemory[512];


// utility functions


static int
parse_nibble(int input)
{
	int nibble = 0xff;

	if (input >= '0' && input <= '9')
		nibble = input - '0';

	if (input >= 'A' && input <= 'F')
		nibble = 0x0a + input - 'A';

	if (input >= 'a' && input <= 'f')
		nibble = 0x0a + input - 'a';

	return nibble;
}


//	#pragma mark - GDB protocol


static void
gdb_ack(void)
{
	arch_debug_serial_putchar('+');
}


static void
gdb_nak(void)
{
	arch_debug_serial_putchar('-');
}


static void
gdb_resend_reply(void)
{
	arch_debug_serial_puts(sReply);
}


static void
gdb_reply(char const* format, ...)
{
	int i;
	int len;
	int sum;
	va_list args;

	va_start(args, format);
	sReply[0] = '$';
	vsprintf(sReply + 1, format, args);
	va_end(args);

	len = strlen(sReply);
	sum = 0;
	for (i = 1; i < len; i++) {
		sum += sReply[i];
	}
	sum %= 256;

	sprintf(sReply + len, "#%02x", sum);

	gdb_resend_reply();
}


static void
gdb_regreply()
{
	sReply[0] = '$';

	// get registers (architecture specific)
	ssize_t bytesWritten = arch_debug_gdb_get_registers(sReply + 1,
		sizeof(sReply) - 1);
	if (bytesWritten < 0) {
		gdb_reply("E01");
		return;
	}

	// add 1 for the leading '$'
	bytesWritten++;

	// compute check sum
	int sum = 0;
	for (int32 i = 1; i < bytesWritten; i++)
		sum += sReply[i];
	sum %= 256;

	// print check sum
	int result = snprintf(sReply + bytesWritten, sizeof(sReply) - bytesWritten,
		"#%02x", sum);
	if (result >= (ssize_t)sizeof(sReply) - bytesWritten) {
		gdb_reply("E01");
		return;
	}

	gdb_resend_reply();
}


static void
gdb_memreply(char const* bytes, int numbytes)
{
	int i;
	int len;
	int sum;

	sReply[0] = '$';
	for (i = 0; i < numbytes; i++)
		sprintf(sReply + 1 + 2 * i, "%02x", (uint8)bytes[i]);

	len = strlen(sReply);
	sum = 0;
	for (i = 1; i < len; i++)
		sum += sReply[i];
	sum %= 256;

	sprintf(sReply + len, "#%02x", sum);

	gdb_resend_reply();
}


//	#pragma mark - checksum verification


static int
gdb_verify_checksum(void)
{
	int i;
	int len;
	int sum;

	len = strlen(sCommand);
	sum = 0;
	for (i = 0; i < len; i++)
		sum += sCommand[i];
	sum %= 256;

	return (sum == sCheckSum) ? 1 : 0;
}


//	#pragma mark - command parsing


static int
gdb_parse_command(void)
{
	if (!gdb_verify_checksum()) {
		gdb_nak();
		return INIT;
	} else
		gdb_ack();

	switch (sCommand[0]) {
		case '?':
			// command '?' is used for retrieving the signal
			// that stopped the program. Fully implemeting
			// this command requires help from the debugger,
			// by now we just fake a SIGKILL
			gdb_reply("S09");	/* SIGKILL = 9 */
			break;

		case 'H':
			// Command H (actually Hct) is used to select
			// the current thread (-1 meaning all threads)
			// We just fake we recognize the the command
			// and send an 'OK' response.
			gdb_reply("OK");
			break;

		case 'q':
		{
			// query commands

			if (strcmp(sCommand + 1, "Supported") == 0) {
				// get the supported features
				gdb_reply("");
			} else if (strcmp(sCommand + 1, "Offsets") == 0) {
				// get the segment offsets
				elf_image_info* kernelImage = elf_get_kernel_image();
				gdb_reply("Text=%lx;Data=%lx;Bss=%lx",
					kernelImage->text_region.delta,
					kernelImage->data_region.delta,
					kernelImage->data_region.delta);
			} else
				gdb_reply("");

			break;
		}

		case 'c':
			// continue at address
			// TODO: Parse the address and resume there!
			return QUIT;

		case 'g':
			gdb_regreply();
			break;

		case 'G':
			// write registers
			// TODO: Implement!
			gdb_reply("E01");
			break;


		case 'm':
		{
			char* ptr;
			addr_t address;
			size_t len;

			// The 'm' command has the form mAAA,LLL
			// where AAA is the address and LLL is the
			// number of bytes.
			ptr = sCommand + 1;
			address = 0;
			len = 0;
			while (ptr && *ptr && (*ptr != ',')) {
				address <<= 4;
				address += parse_nibble(*ptr);
				ptr += 1;
			}
			if (*ptr == ',')
				ptr += 1;

			while (ptr && *ptr) {
				len <<= 4;
				len += parse_nibble(*ptr);
				ptr += 1;
			}

			if (len > 128)
				len = 128;

			// We cannot directly access the requested memory
			// for gdb may be trying to access an stray pointer
			// We copy the memory to a safe buffer using
			// the bulletproof debug_memcpy().
			if (debug_memcpy(B_CURRENT_TEAM, sSafeMemory, (char*)address, len)
					< 0) {
				gdb_reply("E02");
			} else
				gdb_memreply(sSafeMemory, len);

			break;
		}

		case 'D':
			// detach
			return QUIT;

		case 'k':
			// Command 'k' actual semantics is 'kill the damn thing'.
			// However gdb sends that command when you disconnect
			// from a debug session. I guess that 'kill' for the
			// kernel would map to reboot... however that's a
			// a very mean thing to do, instead we just quit
			// the gdb state machine and fallback to the regular
			// kernel debugger command prompt.
			return QUIT;

		case 's':
			// "step" -- resume (?) at address
			// TODO: Implement!
			gdb_reply("E01");
			break;

		default:
			gdb_reply("");
			break;
	}

	return WAITACK;
}


//	#pragma mark - protocol state machine


static int
gdb_init_handler(int input)
{
	switch (input) {
		case '$':
			memset(sCommand, 0, sizeof(sCommand));
			sCommandIndex = 0;
			return CMDREAD;

		default:
#if 0
			gdb_nak();
#else
			// looks to me like we should send
			// a NAK here but it kinda works
			// better if we just gobble all
			// junk chars silently
#endif
			return INIT;
	}
}


static int
gdb_cmdread_handler(int input)
{
	switch (input) {
		case '#':
			return CKSUM1;

		default:
			sCommand[sCommandIndex] = input;
			sCommandIndex += 1;
			return CMDREAD;
	}
}


static int
gdb_cksum1_handler(int input)
{
	int nibble = parse_nibble(input);

	if (nibble == 0xff) {
#if 0
		gdb_nak();
		return INIT;
#else
		// looks to me like we should send
		// a NAK here but it kinda works
		// better if we just gobble all
		// junk chars silently
#endif
	}

	sCheckSum = nibble << 4;

	return CKSUM2;
}


static int
gdb_cksum2_handler(int input)
{
	int nibble = parse_nibble(input);

	if (nibble == 0xff) {
#if 0
		gdb_nak();
		return INIT;
#else
		// looks to me like we should send
		// a NAK here but it kinda works
		// better if we just gobble all
		// junk chars silently
#endif
	}

	sCheckSum += nibble;

	return gdb_parse_command();
}


static int
gdb_waitack_handler(int input)
{
	switch (input) {
		case '+':
			return INIT;
		case '-':
			gdb_resend_reply();
			return WAITACK;

		default:
			// looks like gdb and us are out of sync,
			// send a NAK and retry from INIT state.
			gdb_nak();
			return INIT;
	}
}


static int
gdb_quit_handler(int input)
{
	(void)(input);

	// actually we should never be here
	return QUIT;
}


static int (*dispatch_table[GDBSTATES])(int) = {
	&gdb_init_handler,
	&gdb_cmdread_handler,
	&gdb_cksum1_handler,
	&gdb_cksum2_handler,
	&gdb_waitack_handler,
	&gdb_quit_handler
};


static int
gdb_state_dispatch(int curr, int input)
{
	if (curr < INIT || curr >= GDBSTATES)
		return QUIT;

	return dispatch_table[curr](input);
}


static int
gdb_state_machine(void)
{
	int state = INIT;
	int c;

	while (state != QUIT) {
		c = arch_debug_serial_getchar();
		state = gdb_state_dispatch(state, c);
	}

	return 0;
}


//	#pragma mark -


int
cmd_gdb(int argc, char** argv)
{
	(void)(argc);
	(void)(argv);

	return gdb_state_machine();
}