coreboot-kgpe-d16/payloads/libpayload/arch/arm/gdb.c

115 lines
3.3 KiB
C
Raw Normal View History

libpayload: Add remote GDB support This patch adds the ability to attach a GDB host through the UART to a running payload. Libpayload implements a small stub that can parse and respond to the GDB remote protocol and provide the required primitives (reading/writing registers/memory, etc.) to allow GDB to control execution. The goal of this implementation is to be as small and uninvasive as possible. It implements only the minimum amount of primitives required, and relies on GDB's impressive workaround capabilities (such as emulating breakpoints by temporarily replacing instructions) for the more complicated features. This way, a relatively tiny amount of code on the firmware side opens a vast range of capabilities to the user, not just in debugging but also in remote-controlling the firmware to change its behavior (e.g. through GDBs ability to modify variables and call functions). By default, a system with the REMOTEGDB Kconfig will only trap into GDB when executing halt() (including the calls from die_if(), assert(), and exception handlers). In addition, payloads can manually call gdb_enter() if desired. It will print a final "Ready for GDB connection." on the serial, detach the normal serial output driver and wait for the commands that GDB starts sending on attach. Based on original implementation by Gabe Black <gabeblack@chromium.org>. BUG=chrome-os-partner:18390 TEST=Boot a GDB enabled image in recovery mode (or get it to hit a halt()), close your terminal, execute '<toolchain>-gdb --symbols /build/<board>/firmware/depthcharge_gdb/depthcharge.elf --directory ~/trunk/src/third_party/coreboot/payloads/libpayload --directory ~/trunk/src/platform/depthcharge --directory ~/trunk/src/platform/vboot_reference --ex "target remote <cpu_uart_pty>"' and behold the magic. (You can also SIGSTOP your terminal's parent shell and the terminal itself, and SIGCONT them in reverse order after GDB exits. More convenient wrapper tools to do all this automatically coming soon.) Original-Change-Id: Ib440d1804126cdfdac4a8801f5015b4487e25269 Original-Signed-off-by: Julius Werner <jwerner@chromium.org> Original-Reviewed-on: https://chromium-review.googlesource.com/202563 Original-Reviewed-by: Stefan Reinauer <reinauer@chromium.org> (cherry picked from commit 9c4a642c7be2faf122fef39bdfaddd64aec68b77) Signed-off-by: Marc Jones <marc.jones@se-eng.com> Change-Id: I9238b4eb19d3ab2c98e4e1c5946cd7d252ca3c3b Reviewed-on: http://review.coreboot.org/8119 Tested-by: build bot (Jenkins) Reviewed-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
2014-05-15 20:57:38 +02:00
/*
* Copyright 2014 Google Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but without any warranty; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <exception.h>
#include <gdb.h>
#include <libpayload.h>
struct gdb_regs
{
u32 r[16];
struct fp_reg
{
u8 byte[12];
} __attribute__((packed)) f[8];
u32 fps;
u32 cpsr;
} __attribute__((packed));
static const u8 type_to_signal[] = {
[EXC_UNDEF] = GDB_SIGILL,
[EXC_SWI] = GDB_SIGTRAP,
[EXC_PABORT] = GDB_SIGSEGV,
[EXC_DABORT] = GDB_SIGSEGV,
};
/* Scratch value to write reentrant exception states to. We never read it. */
static struct exception_state sentinel_exception_state;
static int gdb_exception_hook(u32 type)
{
/*
* If we were not resumed we are in deep trouble here. GDB probably told
* us to do something stupid and caused a reentrant exception. All we
* can do is just blindly send an error code and keep going. Eventually
* GDB will tell us to resume and we return right back to the original
* exception state ("jumping over" all the nested ones).
*/
if (gdb_state.connected && !gdb_state.resumed) {
static const char error_code[] = "E22"; /* EINVAL? */
static const struct gdb_message tmp_reply = {
.buf = (u8 *)error_code,
.used = sizeof(error_code),
.size = sizeof(error_code),
};
gdb_send_reply(&tmp_reply);
gdb_command_loop(gdb_state.signal); /* preserve old signal */
} else {
if (type >= ARRAY_SIZE(type_to_signal) || !type_to_signal[type])
return 0;
exception_state_ptr = &sentinel_exception_state;
gdb_command_loop(type_to_signal[type]);
}
exception_state_ptr = &exception_state;
return 1;
}
void gdb_arch_init(void)
{
exception_install_hook(&gdb_exception_hook);
}
void gdb_arch_enter(void)
{
u32 *sp;
asm volatile ("mov %0, %%sp" : "=r"(sp) );
/* Avoid reentrant exceptions, just call the hook if in one already. */
if (sp >= exception_stack && sp <= exception_stack_end)
gdb_exception_hook(EXC_SWI);
else
asm volatile ("svc #0");
}
int gdb_arch_set_single_step(int on)
{
/* GDB seems to only need this on x86, ARM works fine without it. */
return -1;
}
void gdb_arch_encode_regs(struct gdb_message *message)
{
gdb_message_encode_bytes(message, exception_state.regs,
sizeof(exception_state.regs));
gdb_message_encode_zero_bytes(message,
offsetof(struct gdb_regs, cpsr) - offsetof(struct gdb_regs, f));
gdb_message_encode_bytes(message, &exception_state.cpsr,
sizeof(exception_state.cpsr));
}
void gdb_arch_decode_regs(int offset, struct gdb_message *message)
{
const int cpsr_hex_offset = offsetof(struct gdb_regs, cpsr) * 2;
gdb_message_decode_bytes(message, offset,
exception_state.regs, sizeof(exception_state.regs));
gdb_message_decode_bytes(message, offset + cpsr_hex_offset,
&exception_state.cpsr, sizeof(exception_state.cpsr));
}