Imagelibrary/rtems
1
0
Fork 1
mirror of https://gitlab.rtems.org/rtems/rtos/rtems.git synced 2025-12-05 15:15:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
cc34558448eb48a70cb39f06d183a133971c79b3
rtems/cpukit/libdebugger/rtems-debugger-server.c
Chris Johns cc34558448 libdebugger/powerpc: Add PowerPC support 
Closes #5098
2024-08-07 05:09:38 +00:00

2058 lines
53 KiB
C
Raw Blame History

/*
* Copyright (c) 2016-2019 Chris Johns <chrisj@rtems.org>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#define RTEMS_DEBUGGER_VERBOSE_LOCK 0
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>
#include <unistd.h>
#include <rtems/bspIo.h>
#include <rtems/score/smp.h>
#include <rtems/rtems-debugger.h>
#include <rtems/debugger/rtems-debugger-server.h>
#include <rtems/debugger/rtems-debugger-remote.h>
#include "rtems-debugger-target.h"
#include "rtems-debugger-threads.h"
/*
* GDB Debugger Remote Server for RTEMS.
*/
/*
* Hack to void including bsp.h. The reset needs a better API.
*/
extern void bsp_reset(void);
/*
* Command lookup table.
*/
typedef int (*rtems_debugger_command)(uint8_t* buffer, int size);
typedef struct rtems_debugger_packet
{
const char* const label;
rtems_debugger_command command;
} rtems_debugger_packet;
/**
* Common error strings.
*/
static const char* const r_OK = "OK";
static const char* const r_E01 = "E01";
/*
* Global Debugger.
*
* The server instance is allocated on the heap so memory is only used then the
* server is running. A global is used because:
*
* 1. There can only be a single instance at once.
* 2. The backend's need access to the data and holding pointers in the TCB
* for each thread is mess.
* 3. The code is smaller and faster.
*/
rtems_debugger_server* rtems_debugger;
/**
* Print lock ot make the prints sequential. This is to debug the debugger in
* SMP.
*/
RTEMS_INTERRUPT_LOCK_DEFINE(static, printk_lock, "printk_lock")
void
rtems_debugger_printk_lock(rtems_interrupt_lock_context* lock_context)
{
rtems_interrupt_lock_acquire(&printk_lock, lock_context);
}
void
rtems_debugger_printk_unlock(rtems_interrupt_lock_context* lock_context)
{
rtems_interrupt_lock_release(&printk_lock, lock_context);
}
int
rtems_debugger_clean_printf(const char* format, ...)
{
rtems_interrupt_lock_context lock_context;
int len;
va_list ap;
va_start(ap, format);
rtems_debugger_printk_lock(&lock_context);
len = vprintk(format, ap);
rtems_debugger_printk_unlock(&lock_context);
va_end(ap);
return len;
}
int
rtems_debugger_printf(const char* format, ...)
{
rtems_interrupt_lock_context lock_context;
int len;
va_list ap;
va_start(ap, format);
rtems_debugger_printk_lock(&lock_context);
printk("[CPU:%d] ", (int) _SMP_Get_current_processor ());
len = vprintk(format, ap);
rtems_debugger_printk_unlock(&lock_context);
va_end(ap);
return len;
}
bool
rtems_debugger_verbose(void)
{
return rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_VERBOSE);
}
static inline int
hex_decode(uint8_t ch)
{
int i;
if (ch >= '0' && ch <= '9')
i = (int) (ch - '0');
else if (ch >= 'a' && ch <= 'f')
i = (int) (ch - 'a') + 10;
else if (ch >= 'A' && ch <= 'F')
i = (int) (ch - 'A') + 10;
else
i = -1;
return i;
}
static inline uint8_t
hex_encode(int val)
{
return "0123456789abcdef"[val & 0xf];
}
static inline uintptr_t
hex_decode_addr(const uint8_t* data)
{
uintptr_t ui = 0;
size_t i;
if (data[0] == '-') {
if (data[1] == '1')
ui = (uintptr_t) -1;
}
else {
for (i = 0; i < (sizeof(ui) * 2); ++i) {
int v = hex_decode(data[i]);
if (v < 0)
break;
ui = (ui << 4) | v;
}
}
return ui;
}
static inline DB_UINT
hex_decode_uint(const uint8_t* data)
{
DB_UINT ui = 0;
size_t i;
if (data[0] == '-') {
if (data[1] == '1')
ui = (DB_UINT) -1;
}
else {
for (i = 0; i < (sizeof(ui) * 2); ++i) {
int v = hex_decode(data[i]);
if (v < 0)
break;
ui = (ui << 4) | v;
}
}
return ui;
}
static inline int
hex_decode_int(const uint8_t* data)
{
return (int) hex_decode_uint(data);
}
static bool
thread_id_decode(const char* data, DB_UINT* pid, DB_UINT* tid)
{
bool is_extended = false;
if (*data == 'p') {
is_extended = true;
++data;
}
*pid = *tid = hex_decode_uint((const uint8_t*) data);
if (is_extended) {
const char* stop = strchr(data, '.');
if (stop != NULL) {
*tid = hex_decode_uint((const uint8_t*) stop + 1);
}
}
return is_extended;
}
static inline bool
check_pid(DB_UINT pid)
{
return pid == 0 || rtems_debugger->pid == (pid_t) pid;
}
void
rtems_debugger_lock(void)
{
_Mutex_recursive_Acquire(&rtems_debugger->lock);
}
void
rtems_debugger_unlock(void)
{
_Mutex_recursive_Release(&rtems_debugger->lock);
}
static int
rtems_debugger_lock_create(void)
{
_Mutex_recursive_Initialize_named(&rtems_debugger->lock, "DBlock");
return 0;
}
static int
rtems_debugger_lock_destroy(void)
{
return 0;
}
static int
rtems_debugger_task_create(const char* name,
rtems_task_priority priority,
size_t stack_size,
rtems_task_entry entry_point,
rtems_task_argument argument,
rtems_id* id)
{
rtems_name tname;
rtems_status_code sc;
tname = rtems_build_name(name[0], name[1], name[2], name[3]);
sc = rtems_task_create (tname,
priority,
stack_size,
RTEMS_PREEMPT | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_FLOATING_POINT,
id);
if (sc != RTEMS_SUCCESSFUL) {
*id = 0;
rtems_debugger_printf("error: rtems-db: thread create: %s: %s\n",
name, rtems_status_text(sc));
errno = EIO;
return -1;
}
sc = rtems_task_start(*id, entry_point, argument);
if (sc != RTEMS_SUCCESSFUL) {
rtems_debugger_printf("error: rtems-db: thread start: %s: %s\n",
name, rtems_status_text(sc));
rtems_task_delete(*id);
*id = 0;
errno = EIO;
return -1;
}
return 0;
}
static int
rtems_debugger_task_destroy(const char* name,
rtems_id id,
volatile bool* finished,
int timeout)
{
while (timeout) {
bool has_finished;
rtems_debugger_lock();
has_finished = *finished;
rtems_debugger_unlock();
if (has_finished)
break;
usleep(RTEMS_DEBUGGER_POLL_WAIT);
if (timeout < RTEMS_DEBUGGER_POLL_WAIT)
timeout = 0;
else
timeout -= RTEMS_DEBUGGER_POLL_WAIT;
}
if (timeout == 0) {
rtems_debugger_printf("rtems-db: %s not stopping, killing\n", name);
rtems_task_delete(id);
}
return 0;
}
bool
rtems_debugger_server_running(void)
{
bool running;
rtems_debugger_lock();
running = rtems_debugger->server_running;
rtems_debugger_unlock();
return running;
}
rtems_debugger_remote*
rtems_debugger_remote_handle(void)
{
rtems_debugger_remote* remote;
rtems_debugger_lock();
remote = rtems_debugger->remote;
rtems_debugger_unlock();
return remote;
}
bool
rtems_debugger_connected(void)
{
bool isconnected = false;
rtems_debugger_lock();
if (rtems_debugger->remote != NULL)
isconnected = rtems_debugger->remote->isconnected(rtems_debugger->remote);
rtems_debugger_unlock();
return isconnected;
}
bool
rtems_debugger_server_events_running(void)
{
return rtems_debugger->events_running;
}
void
rtems_debugger_server_events_signal(void)
{
_Condition_Signal(&rtems_debugger->server_cond);
}
static void
rtems_debugger_server_events_wait(void)
{
_Condition_Wait_recursive(&rtems_debugger->server_cond, &rtems_debugger->lock);
}
static int
rtems_debugger_remote_connect(void)
{
rtems_debugger_remote* remote = rtems_debugger_remote_handle();
if (remote != NULL) {
if (!remote->isconnected(remote))
return remote->connect(remote);
}
errno = EIO;
return -1;
}
static int
rtems_debugger_remote_disconnect(void)
{
rtems_debugger_remote* remote = rtems_debugger_remote_handle();
if (remote != NULL) {
if (remote->isconnected(remote))
return remote->disconnect(remote);
}
errno = EIO;
return -1;
}
static int
rtems_debugger_remote_receive(uint8_t* buffer, size_t size)
{
rtems_debugger_remote* remote = rtems_debugger_remote_handle();
ssize_t len = remote->read(remote, buffer, size);
if (len < 0 && errno != EAGAIN)
rtems_debugger_printf("rtems-db: read: (%d) %s\n",
errno, strerror(errno));
return (int) len;
}
static int
rtems_debugger_remote_send(void)
{
const uint8_t* buffer = rtems_debugger->output;
ssize_t size = rtems_debugger->output_level;
if (rtems_debugger->output_level > RTEMS_DEBUGGER_BUFFER_SIZE) {
rtems_debugger_printf("rtems-db: write too big: %d\n",
(int) rtems_debugger->output_level);
return -1;
}
if (rtems_debugger->remote_debug) {
size_t i = 0;
rtems_debugger_printf("rtems-db: put:%4zu: ", rtems_debugger->output_level);
while (i < rtems_debugger->output_level)
rtems_debugger_clean_printf("%c", (char) rtems_debugger->output[i++]);
rtems_debugger_clean_printf("\n");
}
while (size) {
rtems_debugger_remote* remote = rtems_debugger_remote_handle();
ssize_t w;
if (remote == NULL) {
errno = EIO;
return -1;
}
w = remote->write(remote, buffer, size);
if (w < 0 && errno != EINTR) {
rtems_debugger_printf("rtems-db: write: (%d) %s\n",
errno, strerror(errno));
break;
}
else {
size -= w;
buffer += w;
}
}
return (int) rtems_debugger->output_level;
}
static int
rtems_debugger_remote_send_ack(void)
{
rtems_debugger->output[0] = '+';
rtems_debugger->output_level = 1;
return rtems_debugger_remote_send();
}
static int
rtems_debugger_remote_send_nack(void)
{
rtems_debugger->output[0] = '-';
rtems_debugger->output_level = 1;
return rtems_debugger_remote_send();
}
static int
rtems_debugger_remote_packet_in(void)
{
uint8_t buf[256];
uint8_t state;
int in = 0;
uint8_t csum = 0;
uint8_t rx_csum = 0;
bool junk = false;
bool escaped = false;
bool remote_debug_header = true;
/*
* States:
* 'H' : Looking for the start character '$', '-' or '+'.
* 'P' : Looking for the checksum character '#' else buffer data.
* '1' : Looking for the first checksum character.
* '2' : Looking for the second checksum character.
* 'F' : Finished.
*/
state = 'H';
while (state != 'F') {
int r;
int i;
rtems_debugger_unlock();
r = rtems_debugger_remote_receive(buf, sizeof(buf));
rtems_debugger_lock();
if (r <= 0) {
/*
* Timeout?
*/
if (r < 0 && errno == EAGAIN) {
if (rtems_debugger->ack_pending) {
rtems_debugger_remote_send();
}
continue;
}
if (r == 0)
rtems_debugger_printf("rtems-db: remote disconnected\n");
return -1;
}
i = 0;
while (i < r) {
uint8_t c = buf[i++];
if (rtems_debugger->remote_debug && remote_debug_header) {
rtems_debugger_printf("rtems-db: get:%4d: ", r);
remote_debug_header = false;
}
if (rtems_debugger->remote_debug)
rtems_debugger_clean_printf("%c", c);
switch (state) {
case 'H':
switch (c) {
case '+':
if (rtems_debugger->remote_debug) {
rtems_debugger_clean_printf(" [[ACK%s]]\n",
rtems_debugger->ack_pending ? "" : "?");
remote_debug_header = true;
}
rtems_debugger->ack_pending = false;
break;
case '-':
if (rtems_debugger->remote_debug) {
rtems_debugger_clean_printf(" [[NACK]]\n");
remote_debug_header = true;
}
/*
* Resend.
*/
rtems_debugger_remote_send();
break;
case '$':
state = 'P';
csum = 0;
in = 0;
if (junk && rtems_debugger->remote_debug) {
rtems_debugger_clean_printf("\b [[junk dropped]]\nrtems-db: get: : $");
remote_debug_header = false;
}
break;
case '\x3':
if (rtems_debugger->remote_debug)
rtems_debugger_clean_printf("^C [[BREAK]]\n");
rtems_debugger->ack_pending = false;
rtems_debugger->input[0] = '^';
rtems_debugger->input[1] = 'C';
rtems_debugger->input[2] = '\0';
return 2;
default:
junk = true;
break;
}
break;
case 'P':
if (c == '{' && !escaped) {
escaped = true;
}
else if (c == '$' && !escaped) {
csum = 0;
in = 0;
if (rtems_debugger->remote_debug) {
rtems_debugger_clean_printf("\n");
remote_debug_header = true;
}
}
else if (c == '#' && !escaped) {
rtems_debugger->input[in] = '\0';
rx_csum = 0;
state = '1';
}
else {
if (in >= (RTEMS_DEBUGGER_BUFFER_SIZE - 1)) {
rtems_debugger_printf("rtems-db: input buffer overflow\n");
return -1;
}
csum += c;
rtems_debugger->input[in++] = c;
}
break;
case '1':
rx_csum = (rx_csum << 4) | (uint8_t) hex_decode(c);
state = '2';
break;
case '2':
rx_csum = (rx_csum << 4) | (uint8_t) hex_decode(c);
if (csum == rx_csum) {
state = 'F';
if (rtems_debugger->remote_debug)
rtems_debugger_clean_printf("\n");
rtems_debugger_remote_send_ack();
}
else {
if (rtems_debugger->remote_debug) {
rtems_debugger_clean_printf(" [[invalid checksum]]\n");
remote_debug_header = true;
rtems_debugger_remote_send_nack();
}
state = 'H';
}
break;
case 'F':
if (rtems_debugger->remote_debug)
rtems_debugger_clean_printf(" [[extra data: 0x%02x]]", (int) c);
break;
default:
rtems_debugger_printf("rtems-db: bad state\n");
rtems_debugger_remote_send_nack();
return -1;
}
}
}
return in;
}
static int
rtems_debugger_remote_packet_in_hex(uint8_t* addr,
const char* data,
size_t size)
{
size_t i;
for (i = 0; i < size; ++i) {
*addr = (hex_decode(*data++) << 4);
*addr++ |= hex_decode(*data++);
}
return 0;
}
#if KEEP_INCASE
static void
remote_packet_out_rewind(size_t size)
{
size_t i = 0;
while (rtems_debugger->output_level > 0 && i < size) {
if (rtems_debugger->output_level > 1) {
if (rtems_debugger->output[rtems_debugger->output_level - 1] == '}') {
--rtems_debugger->output_level;
}
}
--rtems_debugger->output_level;
--i;
}
}
#endif
static int
remote_packet_out_append_buffer(const char* buffer, size_t size)
{
size_t ol = rtems_debugger->output_level;
size_t i = 0;
while (i < size) {
char c = buffer[i++];
if (c == '#' || c == '$') {
if (rtems_debugger->output_level >= (RTEMS_DEBUGGER_BUFFER_SIZE - 1)) {
rtems_debugger->output_level = ol;
rtems_debugger_printf("rtems-db: output overflow\n");
return -1;
}
rtems_debugger->output[rtems_debugger->output_level++] = '}';
c ^= 0x20;
}
if (rtems_debugger->output_level >= (RTEMS_DEBUGGER_BUFFER_SIZE - 1)) {
rtems_debugger->output_level = ol;
rtems_debugger_printf("rtems-db: output overflow\n");
return -1;
}
rtems_debugger->output[rtems_debugger->output_level++] = c;
}
return 0;
}
static int
remote_packet_out_append_hex(const uint8_t* data, size_t size)
{
size_t ol = rtems_debugger->output_level;
size_t i = 0;
while (i < size) {
uint8_t byte = data[i++];
if (rtems_debugger->output_level >= (RTEMS_DEBUGGER_BUFFER_SIZE - 2)) {
rtems_debugger->output_level = ol;
rtems_debugger_printf("rtems-db: output overflow\n");
return -1;
}
rtems_debugger->output[rtems_debugger->output_level++] = hex_encode(byte >> 4);
rtems_debugger->output[rtems_debugger->output_level++] = hex_encode(byte);
}
return 0;
}
static int
remote_packet_out_append_str(const char* str)
{
return remote_packet_out_append_buffer(str, strlen(str));
}
static int
remote_packet_out_append_vprintf(const char* fmt, va_list ap)
{
int len;
char buffer[64];
len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
return remote_packet_out_append_buffer(buffer, len);
}
static int
remote_packet_out_append(const char* fmt, ...)
{
va_list ap;
int r;
va_start(ap, fmt);
r = remote_packet_out_append_vprintf(fmt, ap);
va_end(ap);
return r;
}
static void
remote_packet_out_reset(void)
{
rtems_debugger->output_level = 1;
rtems_debugger->output[0] = '$';
}
static int
remote_packet_out_buffer(const char* buffer, size_t size)
{
remote_packet_out_reset();
return remote_packet_out_append_buffer(buffer, size);
}
static int
remote_packet_out_str(const char* str)
{
remote_packet_out_reset();
return remote_packet_out_append_buffer(str, strlen(str));
}
static int
remote_packet_out(const char* fmt, ...)
{
va_list ap;
int r;
va_start(ap, fmt);
remote_packet_out_reset();
r = remote_packet_out_append_vprintf(fmt, ap);
va_end(ap);
return r;
}
static int
remote_packet_out_send(void)
{
uint8_t csum = 0;
size_t i = 1;
if (rtems_debugger->output_level >= (RTEMS_DEBUGGER_BUFFER_SIZE - 3)) {
rtems_debugger_printf("rtems-db: output overflow\n");
return -1;
}
while (i < rtems_debugger->output_level) {
csum += rtems_debugger->output[i++];
}
rtems_debugger->output[rtems_debugger->output_level++] = '#';
rtems_debugger->output[rtems_debugger->output_level++] = hex_encode((csum >> 4) & 0xf);
rtems_debugger->output[rtems_debugger->output_level++] = hex_encode(csum & 0xf);
rtems_debugger->ack_pending = true;;
return rtems_debugger_remote_send();
}
static int
remote_packet_dispatch(const rtems_debugger_packet* packet,
size_t packets,
uint8_t* buffer,
int size)
{
const rtems_debugger_packet* p;
size_t i;
int r = -1;
for (i = 0, p = &packet[0]; i < packets; ++i, ++p) {
if (strncmp(p->label,
(const char*) &buffer[0],
strlen(p->label)) == 0) {
if (rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_VERBOSE_CMDS))
rtems_debugger_printf("rtems-db: cmd: %s [%d] '%s'\n",
p->label, size, (const char*) buffer);
r = p->command(buffer, size);
break;
}
}
if (r < 0) {
remote_packet_out_buffer("", 0);
remote_packet_out_send();
}
return 0;
}
static int
remote_detach(uint8_t* buffer, int size)
{
remote_packet_out_str(r_OK);
remote_packet_out_send();
rtems_debugger_remote_disconnect();
return 0;
}
static int
remote_ut_features(uint8_t* buffer, int size)
{
return -1;
}
static int
remote_ut_osdata(uint8_t* buffer, int size)
{
return -1;
}
static const rtems_debugger_packet uninterpreted_transfer[] = {
{ .label = "qXfer:features",
.command = remote_ut_features },
{ .label = "qXfer:osdata",
.command = remote_ut_osdata },
};
#define REMOTE_UNINTERPRETED_TRANSFERS \
RTEMS_DEBUGGER_NUMOF(uninterpreted_transfer)
static int
remote_gq_uninterpreted_transfer(uint8_t* buffer, int size)
{
return remote_packet_dispatch(uninterpreted_transfer,
REMOTE_UNINTERPRETED_TRANSFERS,
buffer, size);
}
static int
remote_gq_thread_info_subsequent(uint8_t* buffer, int size)
{
rtems_debugger_threads* threads = rtems_debugger->threads;
if (threads->next >= threads->current.level)
remote_packet_out_str("l");
else {
rtems_debugger_thread* current;
const char* format = "p%d.%08lx";
current = rtems_debugger_thread_current(threads);
remote_packet_out_str("m");
while (threads->next < threads->current.level) {
int r;
r = remote_packet_out_append(format,
rtems_debugger->pid,
current[threads->next].id);
if (r < 0)
break;
format = ",p%d.%08lx";
++threads->next;
}
}
remote_packet_out_send();
return 0;
}
static int
remote_gq_thread_info_first(uint8_t* buffer, int size)
{
rtems_debugger->threads->next = 0;
return remote_gq_thread_info_subsequent(buffer, size);
}
static int
remote_gq_thread_extra_info(uint8_t* buffer, int size)
{
const char* comma;
remote_packet_out_reset();
comma = strchr((const char*) buffer, ',');
if (comma != NULL) {
DB_UINT pid = 0;
DB_UINT tid = 0;
bool extended;
extended = thread_id_decode(comma + 1, &pid, &tid);
if (extended || check_pid(pid)) {
int r;
r = rtems_debugger_thread_find_index(tid);
if (r >= 0) {
rtems_debugger_threads* threads = rtems_debugger->threads;
rtems_debugger_thread* current;
rtems_debugger_thread* thread;
char buf[128];
char str[32];
size_t l;
current = rtems_debugger_thread_current(threads);
thread = &current[r];
l = snprintf(buf, sizeof(buf),
"%4s (%08" PRIx32 "), ", thread->name, thread->id);
remote_packet_out_append_hex((const uint8_t*) buf, l);
l = snprintf(buf, sizeof(buf),
"priority(c:%3d r:%3d), ",
rtems_debugger_thread_current_priority(thread),
rtems_debugger_thread_real_priority(thread));
remote_packet_out_append_hex((const uint8_t*) buf, l);
l = snprintf(buf, sizeof(buf),
"stack(s:%6lu a:%p), ",
rtems_debugger_thread_stack_size(thread),
rtems_debugger_thread_stack_area(thread));
remote_packet_out_append_hex((const uint8_t*) buf, l);
rtems_debugger_thread_state_str(thread, str, sizeof(str));
l = snprintf(buf, sizeof(buf), "state(%s)", str);
remote_packet_out_append_hex((const uint8_t*) buf, l);
}
}
}
remote_packet_out_send();
return 0;
}
static int
remote_gq_supported(uint8_t* buffer, int size)
{
uint32_t capabilities = rtems_debugger_target_capabilities();
const char* p;
bool swbreak = false;
bool hwbreak = false;
bool vCont = false;
bool no_resumed = false;
bool multiprocess = false;
remote_packet_out("qSupported:PacketSize=%d;QNonStop-",
RTEMS_DEBUGGER_BUFFER_SIZE);
p = strchr((const char*) buffer, ':');
if (p != NULL)
++p;
while (p != NULL && *p != '\0') {
bool echo = false;
char* sc;
sc = strchr(p, ';');
if (sc != NULL) {
*sc++ = '\0';
}
if (strcmp(p, "swbreak+") == 0 &&
!swbreak && (capabilities & RTEMS_DEBUGGER_TARGET_CAP_SWBREAK) != 0) {
swbreak = true;
echo = true;
}
if (strcmp(p, "hwbreak+") == 0 &&
!hwbreak && (capabilities & RTEMS_DEBUGGER_TARGET_CAP_HWBREAK) != 0) {
hwbreak = true;
echo = true;
}
if (!vCont && strcmp(p, "vContSupported+") == 0) {
rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_VCONT;
vCont = true;
echo = true;
}
if (!no_resumed && strcmp(p, "no-resumed+") == 0) {
no_resumed = true;
echo = true;
}
if (!multiprocess && strcmp(p, "multiprocess+") == 0) {
rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_MULTIPROCESS;
multiprocess = true;
echo = true;
}
if (echo) {
remote_packet_out_append_str(";");
remote_packet_out_append_str(p);
}
else if (strncmp(p, "xmlRegisters", sizeof("xmlRegisters") - 1) == 0) {
/* ignore */
}
else {
remote_packet_out_append_str(";");
remote_packet_out_append_buffer(p, strlen(p) - 1);
remote_packet_out_append_str("-");
}
p = sc;
}
if (!swbreak && (capabilities & RTEMS_DEBUGGER_TARGET_CAP_SWBREAK) != 0) {
remote_packet_out_append_str("swbreak+;");
}
if (!hwbreak && (capabilities & RTEMS_DEBUGGER_TARGET_CAP_HWBREAK) != 0) {
remote_packet_out_append_str("hwbreak+;");
}
if (!vCont) {
remote_packet_out_append_str("vContSupported+;");
}
if (!no_resumed) {
remote_packet_out_append_str("no-resumed+;");
}
if (!multiprocess) {
remote_packet_out_append_str("multiprocess+;");
}
remote_packet_out_send();
return 0;
}
static int
remote_gq_attached(uint8_t* buffer, int size)
{
const char* response = "1";
const char* colon = strchr((const char*) buffer, ':');
if (colon != NULL) {
DB_UINT pid = hex_decode_uint((const uint8_t*) colon + 1);
if ((pid_t) pid != rtems_debugger->pid)
response = r_E01;
}
remote_packet_out_str(response);
remote_packet_out_send();
return 0;
}
static const rtems_debugger_packet general_query[] = {
{ .label = "qfThreadInfo",
.command = remote_gq_thread_info_first },
{ .label = "qsThreadInfo",
.command = remote_gq_thread_info_subsequent },
{ .label = "qThreadExtraInfo",
.command = remote_gq_thread_extra_info },
{ .label = "qSupported",
.command = remote_gq_supported },
{ .label = "qAttached",
.command = remote_gq_attached },
{ .label = "qXfer",
.command = remote_gq_uninterpreted_transfer },
};
#define REMOTE_GENERAL_QUERIES RTEMS_DEBUGGER_NUMOF(general_query)
static int
remote_general_query(uint8_t* buffer, int size)
{
return remote_packet_dispatch(general_query, REMOTE_GENERAL_QUERIES,
buffer, size);
}
static int
remote_gs_non_stop(uint8_t* buffer, int size)
{
const char* response = r_E01;
char* p = strchr((char*) buffer, ':');
if (p != NULL) {
++p;
response = r_OK;
if (*p == '0') {
rtems_debugger->flags &= ~RTEMS_DEBUGGER_FLAG_NON_STOP;
}
else if (*p == '1') {
rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_NON_STOP;
}
else
response = r_E01;
}
remote_packet_out_str(response);
remote_packet_out_send();
return 0;
}
static const rtems_debugger_packet general_set[] = {
{ .label = "QNonStop",
.command = remote_gs_non_stop },
};
#define REMOTE_GENERAL_SETS RTEMS_DEBUGGER_NUMOF(general_set)
static int
remote_general_set(uint8_t* buffer, int size)
{
return remote_packet_dispatch(general_set, REMOTE_GENERAL_SETS,
buffer, size);
}
static int
remote_v_stopped(uint8_t* buffer, int size)
{
rtems_debugger_threads* threads = rtems_debugger->threads;
if (threads->next >= threads->stopped.level)
remote_packet_out_str(r_OK);
else {
rtems_id* stopped;
remote_packet_out("T%02x", rtems_debugger->signal);
stopped = rtems_debugger_thread_stopped(threads);
while (threads->next < threads->stopped.level) {
int r;
r = remote_packet_out_append("thread:p%d.%08lx;",
rtems_debugger->pid,
stopped[threads->next]);
if (r < 0)
break;
++threads->next;
}
}
remote_packet_out_send();
return 0;
}
static int
remote_stop_reason(uint8_t* buffer, int size)
{
rtems_debugger->threads->next = 0;
return remote_v_stopped(buffer, size);
}
static int
remote_v_continue(uint8_t* buffer, int size)
{
buffer += 5;
if (buffer[0] == '?') {
/*
* You need to supply 'c' and 'C' or GDB says vCont is not supported. As
* Sammy-J says "Silly GDB".
*/
remote_packet_out_str("vCont;c;C;s;r;");
}
else {
const char* semi = (const char*) &buffer[0];
bool resume = false;
bool ok = true;
while (ok && semi != NULL) {
const char* colon = strchr(semi + 1, ':');
const char action = *(semi + 1);
DB_UINT pid = 0;
DB_UINT tid = 0;
bool extended;
if (colon != NULL) {
int r = -1;
extended = thread_id_decode(colon + 1, &pid, &tid);
if (extended || check_pid(pid)) {
rtems_debugger_threads* threads = rtems_debugger->threads;
rtems_debugger_thread* thread = NULL;
int index = 0;
if (tid != (DB_UINT) -1) {
rtems_debugger_thread* current;
current = rtems_debugger_thread_current(threads);
index = rtems_debugger_thread_find_index(tid);
if (index >= 0)
thread = &current[index];
}
switch (action) {
case 'c':
case 'C':
if (tid == (DB_UINT) -1) {
r = rtems_debugger_thread_continue_all();
}
else if (thread != NULL) {
r = rtems_debugger_thread_continue(thread);
}
if (r == 0)
resume = true;
break;
case 'S':
case 's':
if (thread != NULL) {
r = rtems_debugger_thread_step(thread);
if (r == 0)
resume = true;
}
break;
case 'r':
/*
* Range to step around inside: `r start,end`.
*/
if (thread != NULL) {
const char* comma;
comma = strchr(semi + 2, ',');
if (comma != NULL) {
DB_UINT start;
DB_UINT end;
start = hex_decode_uint((const uint8_t*) semi + 2);
end = hex_decode_uint((const uint8_t*) comma + 1);
r = rtems_debugger_thread_stepping(thread, start, end);
if (r == 0)
resume = true;
}
else {
ok = false;
}
}
break;
default:
rtems_debugger_printf("rtems-db: vCont: unkown action: %c\n", action);
ok = false;
break;
}
if (r < 0)
ok = false;
}
}
else {
rtems_debugger_printf("rtems-db: vCont: no colon\n");
ok = false;
}
semi = strchr(semi + 1, ';');
}
if (ok)
remote_packet_out_str(r_OK);
else
remote_packet_out_str(r_E01);
if (resume)
rtems_debugger_thread_system_resume(false);
}
remote_packet_out_send();
return 0;
}
static int
remote_v_kill(uint8_t* buffer, int size)
{
rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_RESET;
return remote_detach(buffer, size);
}
static const rtems_debugger_packet v_packets[] = {
{ .label = "vCont",
.command = remote_v_continue },
{ .label = "vStopped",
.command = remote_v_stopped },
{ .label = "vKill",
.command = remote_v_kill },
};
#define REMOTE_V_PACKETS RTEMS_DEBUGGER_NUMOF(v_packets)
static int
remote_v_packets(uint8_t* buffer, int size)
{
return remote_packet_dispatch(v_packets, REMOTE_V_PACKETS,
buffer, size);
}
static int
remote_thread_select(uint8_t* buffer, int size)
{
const char* response = r_OK;
int* index = NULL;
if (buffer[1] == 'g')
index = &rtems_debugger->threads->selector_gen;
else if (buffer[1] == 'c')
index = &rtems_debugger->threads->selector_cont;
else
response = r_E01;
if (index != NULL) {
DB_UINT pid = 0;
DB_UINT tid = 0;
bool extended;
extended = thread_id_decode((const char*) &buffer[2], &pid, &tid);
if (extended && !check_pid(pid)) {
response = r_E01;
}
else {
if (tid == 0 || tid == (DB_UINT) -1)
*index = (int) tid;
else {
int r;
r = rtems_debugger_thread_find_index(tid);
if (r < 0) {
response = r_E01;
*index = -1;
}
else
*index = r;
}
}
}
remote_packet_out_str(response);
remote_packet_out_send();
return 0;
}
static int
remote_thread_alive(uint8_t* buffer, int size)
{
const char* response = r_E01;
DB_UINT pid = 0;
DB_UINT tid = 0;
bool extended;
extended = thread_id_decode((const char*) &buffer[1], &pid, &tid);
if (!extended || (extended && check_pid(pid))) {
int r;
r = rtems_debugger_thread_find_index(tid);
if (r >= 0)
response = r_OK;
}
remote_packet_out_str(response);
remote_packet_out_send();
return 0;
}
static int
remote_argc_argv(uint8_t* buffer, int size)
{
return -1;
}
static int
remote_continue_at(uint8_t* buffer, int size)
{
if (!rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_VCONT)) {
char* vCont_c = "vCont;c:p1.-1";
return remote_v_continue((uint8_t*) vCont_c, strlen(vCont_c));
}
return -1;
}
static int
remote_read_general_regs(uint8_t* buffer, int size)
{
rtems_debugger_threads* threads = rtems_debugger->threads;
bool ok = false;
int r;
if (threads->selector_gen >= 0 &&
threads->selector_gen < (int) threads->current.level) {
rtems_debugger_thread* current;
rtems_debugger_thread* thread;
current = rtems_debugger_thread_current(threads);
thread = &current[threads->selector_gen];
r = rtems_debugger_target_read_regs(thread);
if (r >= 0) {
remote_packet_out_reset();
r = remote_packet_out_append_hex((const uint8_t*) &thread->registers[0],
rtems_debugger_target_reg_table_size());
if (r >= 0)
ok = true;
}
}
if (!ok)
remote_packet_out_str(r_E01);
remote_packet_out_send();
return 0;
}
static int
remote_write_general_regs(uint8_t* buffer, int size)
{
rtems_debugger_threads* threads = rtems_debugger->threads;
size_t reg_table_size = rtems_debugger_target_reg_table_size();
bool ok = false;
int r;
if (threads->selector_gen >= 0 &&
threads->selector_gen < (int) threads->current.level &&
((size - 1) / 2) == (int) reg_table_size) {
rtems_debugger_thread* current;
rtems_debugger_thread* thread;
current = rtems_debugger_thread_current(threads);
thread = &current[threads->selector_gen];
r = rtems_debugger_target_read_regs(thread);
if (r >= 0) {
r = rtems_debugger_remote_packet_in_hex((uint8_t*) &thread->registers[0],
(const char*) &buffer[1],
reg_table_size);
if (r >= 0) {
thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
ok = true;
}
}
}
if (!ok)
remote_packet_out_str(r_E01);
remote_packet_out_send();
return 0;
}
static int
remote_read_reg(uint8_t* buffer, int size)
{
rtems_debugger_threads* threads = rtems_debugger->threads;
bool ok = false;
int r;
if (threads->selector_gen >= 0
&& threads->selector_gen < (int) threads->current.level) {
size_t reg = hex_decode_int(&buffer[1]);
if (reg < rtems_debugger_target_reg_num()) {
rtems_debugger_thread* current;
rtems_debugger_thread* thread;
current = rtems_debugger_thread_current(threads);
thread = &current[threads->selector_gen];
r = rtems_debugger_target_read_regs(thread);
if (r >= 0) {
const size_t reg_size = rtems_debugger_target_reg_size(reg);
const size_t reg_offset = rtems_debugger_target_reg_offset(reg);
const uint8_t* addr = &thread->registers[reg_offset];
remote_packet_out_reset();
r = remote_packet_out_append_hex(addr, reg_size);
if (r >= 0)
ok = true;
}
}
}
if (!ok)
remote_packet_out_str(r_E01);
remote_packet_out_send();
return 0;
}
static int
remote_write_reg(uint8_t* buffer, int size)
{
rtems_debugger_threads* threads = rtems_debugger->threads;
const char* response = r_E01;
if (threads->selector_gen >= 0
&& threads->selector_gen < (int) threads->current.level) {
const char* equals;
equals = strchr((const char*) buffer, '=');
if (equals != NULL) {
size_t reg = hex_decode_int(&buffer[1]);
if (reg < rtems_debugger_target_reg_num()) {
rtems_debugger_thread* current;
rtems_debugger_thread* thread;
int r;
current = rtems_debugger_thread_current(threads);
thread = &current[threads->selector_gen];
r = rtems_debugger_target_read_regs(thread);
if (r >= 0) {
const size_t reg_size = rtems_debugger_target_reg_size(reg);
const size_t reg_offset = rtems_debugger_target_reg_offset(reg);
uint8_t* addr = &thread->registers[reg_offset];
r = rtems_debugger_remote_packet_in_hex(addr, equals + 1, reg_size);
if (r == 0) {
thread->flags |= RTEMS_DEBUGGER_THREAD_FLAG_REG_DIRTY;
response = r_OK;
}
}
}
}
}
remote_packet_out_str(response);
remote_packet_out_send();
return 0;
}
static int
remote_read_memory(uint8_t* buffer, int size)
{
const char* comma;
comma = strchr((const char*) buffer, ',');
if (comma == NULL)
remote_packet_out_str(r_E01);
else {
uintptr_t addr;
DB_UINT length;
int r;
addr = hex_decode_addr(&buffer[1]);
length = hex_decode_uint((const uint8_t*) comma + 1);
remote_packet_out_reset();
r = rtems_debugger_target_start_memory_access();
if (r == 0) {
/*
* There should be specific target access for 8, 16, 32 and 64 bit reads.
*/
r = remote_packet_out_append_hex((const uint8_t*) addr, length);
}
rtems_debugger_target_end_memory_access();
if (r < 0)
remote_packet_out_str(r_E01);
}
remote_packet_out_send();
return 0;
}
static int
remote_write_memory(uint8_t* buffer, int size)
{
const char* response = r_E01;
const char* comma;
const char* colon;
comma = strchr((const char*) buffer, ',');
colon = strchr((const char*) buffer, ':');
if (comma != NULL && colon != NULL) {
uintptr_t addr;
DB_UINT length;
int r;
addr = hex_decode_addr(&buffer[1]);
length = hex_decode_uint((const uint8_t*) comma + 1);
r = rtems_debugger_target_start_memory_access();
if (r == 0) {
r = rtems_debugger_remote_packet_in_hex((uint8_t*) addr,
colon + 1,
length);
}
rtems_debugger_target_end_memory_access();
if (r == 0)
response = r_OK;
}
remote_packet_out_str(response);
remote_packet_out_send();
return 0;
}
static int
remote_single_step(uint8_t* buffer, int size)
{
if (!rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_VCONT)) {
rtems_debugger_threads* threads = rtems_debugger->threads;
if (threads != NULL && rtems_debugger_thread_current(threads) != NULL) {
rtems_debugger_thread* current;
char vCont_s[32];
current = rtems_debugger_thread_current(threads);
snprintf(vCont_s, sizeof(vCont_s), "vCont;s:p1.%08" PRIx32 ";c:p1.-1",
current[threads->selector_cont].id);
return remote_v_continue((uint8_t*) vCont_s, strlen(vCont_s));
}
remote_packet_out_str(r_E01);
remote_packet_out_send();
return 0;
}
return -1;
}
static int
remote_breakpoints(bool insert, uint8_t* buffer, int size)
{
const char* comma1;
int r = -1;
comma1 = strchr((const char*) buffer, ',');
if (comma1 != NULL) {
const char* comma2;
comma2 = strchr(comma1 + 1, ',');
if (comma2 != NULL) {
uint32_t capabilities;
uintptr_t addr;
DB_UINT kind;
addr = hex_decode_addr((const uint8_t*) comma1 + 1);
kind = hex_decode_uint((const uint8_t*) comma2 + 1);
capabilities = rtems_debugger_target_capabilities();
switch (buffer[1]) {
case '0':
if ((capabilities & RTEMS_DEBUGGER_TARGET_CAP_SWBREAK) != 0) {
r = rtems_debugger_target_swbreak_control(insert, addr, kind);
}
break;
case '1': /* execute */
case '2': /* write */
case '3': /* read */
case '4': /* access */
if ((capabilities & RTEMS_DEBUGGER_TARGET_CAP_HWWATCH) != 0) {
rtems_debugger_target_watchpoint type;
switch (buffer[1]) {
case '1':
type = rtems_debugger_target_hw_execute;
break;
case '2':
type = rtems_debugger_target_hw_write;
break;
case '3':
type = rtems_debugger_target_hw_read;
break;
case '4':
default:
type = rtems_debugger_target_hw_read_write;
break;
}
r = rtems_debugger_target_hwbreak_control(type, insert, addr, kind);
}
break;
default:
break;
}
}
}
remote_packet_out_str(r < 0 ? r_E01 : r_OK);
remote_packet_out_send();
return 0;
}
static int
remote_insert_breakpoint(uint8_t* buffer, int size)
{
return remote_breakpoints(true, buffer, size);
}
static int
remote_remove_breakpoint(uint8_t* buffer, int size)
{
return remote_breakpoints(false, buffer, size);
}
static int
remote_break(uint8_t* buffer, int size)
{
int r;
r = rtems_debugger_thread_system_suspend();
if (r < 0) {
rtems_debugger_printf("error: rtems-db: suspend all on break\n");
}
return remote_stop_reason(buffer, size);
}
static const rtems_debugger_packet packets[] = {
{ .label = "q",
.command = remote_general_query },
{ .label = "Q",
.command = remote_general_set },
{ .label = "v",
.command = remote_v_packets },
{ .label = "H",
.command = remote_thread_select },
{ .label = "T",
.command = remote_thread_alive },
{ .label = "?",
.command = remote_stop_reason },
{ .label = "A",
.command = remote_argc_argv },
{ .label = "c",
.command = remote_continue_at },
{ .label = "g",
.command = remote_read_general_regs },
{ .label = "G",
.command = remote_write_general_regs },
{ .label = "p",
.command = remote_read_reg },
{ .label = "P",
.command = remote_write_reg },
{ .label = "m",
.command = remote_read_memory },
{ .label = "M",
.command = remote_write_memory },
{ .label = "s",
.command = remote_single_step },
{ .label = "Z",
.command = remote_insert_breakpoint },
{ .label = "z",
.command = remote_remove_breakpoint },
{ .label = "D",
.command = remote_detach },
{ .label = "k",
.command = remote_v_kill },
{ .label = "r",
.command = remote_v_kill },
{ .label = "R",
.command = remote_v_kill },
{ .label = "^C",
.command = remote_break },
};
#define REMOTE_PACKETS RTEMS_DEBUGGER_NUMOF(packets)
static int
remote_packets(uint8_t* buffer, size_t size)
{
return remote_packet_dispatch(packets, REMOTE_PACKETS,
buffer, size);
}
static void
rtems_debugger_events(rtems_task_argument arg)
{
int r = 0;
if (rtems_debugger_verbose())
rtems_debugger_printf("rtems-db: events running\n");
/*
* Hold the lock until the thread blocks waiting for an event.
*/
rtems_debugger_lock();
rtems_debugger_target_enable();
if (rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_BREAK_WAITER)) {
rtems_debugger->flags &= ~RTEMS_DEBUGGER_FLAG_BREAK_WAITER;
r = rtems_debugger_thread_system_suspend();
if (rtems_debugger_verbose())
rtems_debugger_printf("rtems-db: break waiter\n");
rtems_debugger_server_events_signal();
if (rtems_debugger_verbose())
rtems_debugger_printf("rtems-db: break waiter: signalled\n");
}
if (r == 0) {
while (rtems_debugger_server_events_running()) {
rtems_debugger_server_events_wait();
if (rtems_debugger_verbose())
rtems_debugger_printf("rtems-db: event woken\n");
if (!rtems_debugger_server_events_running())
break;
r = rtems_debugger_thread_system_suspend();
if (r < 0)
break;
r = remote_stop_reason(NULL, 0);
if (r < 0)
break;
}
}
if (r < 0)
rtems_debugger_printf("rtems-db: error in events\n");
rtems_debugger_target_disable();
rtems_debugger->events_running = false;
rtems_debugger->events_finished = true;
rtems_debugger_unlock();
if (rtems_debugger_verbose())
rtems_debugger_printf("rtems-db: events finishing\n");
rtems_task_exit();
}
static int
rtems_debugger_session(void)
{
int r;
int rr;
if (rtems_debugger_verbose())
rtems_debugger_printf("rtems-db: remote running\n");
/*
* Hold the lock until the thread blocks on the remote input.
*/
rtems_debugger_lock();
r = rtems_debugger_target_create();
if (r < 0) {
rtems_debugger_unlock();
return r;
}
r = rtems_debugger_thread_create();
if (r < 0) {
rtems_debugger_target_destroy();
rtems_debugger_unlock();
return r;
}
rtems_debugger->events_running = true;
rtems_debugger->events_finished = false;
r = rtems_debugger_task_create("DBSe",
rtems_debugger->priority,
RTEMS_DEBUGGER_STACKSIZE,
rtems_debugger_events,
0,
&rtems_debugger->events_task);
if (r < 0) {
rtems_debugger_thread_destroy();
rtems_debugger_target_destroy();
rtems_debugger_unlock();
return r;
}
while (rtems_debugger_server_running() &&
rtems_debugger_connected()) {
r = rtems_debugger_remote_packet_in();
if (r < 0)
break;
if (r > 0) {
remote_packets(&rtems_debugger->input[0], r);
}
}
rtems_debugger->events_running = false;
rtems_debugger_server_events_signal();
rtems_debugger_unlock();
rr = rtems_debugger_task_destroy("DBSe",
rtems_debugger->events_task,
&rtems_debugger->events_finished,
RTEMS_DEBUGGER_TIMEOUT_STOP);
if (rr < 0 && r == 0)
r = rr;
rtems_debugger_lock();
rr = rtems_debugger_target_destroy();
if (rr < 0 && r == 0)
r = rr;
rr = rtems_debugger_thread_destroy();
if (rr < 0 && r == 0)
r = rr;
if (rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_RESET)) {
rtems_debugger_printf("rtems-db: shutdown\n");
/*
* Wait a moment to let any disconnection protocol a transport has
* complete. The legacy stack needs this to close the connection
* to GDB and clean up.
*/
sleep(2);
/*
* No special exit code, the user will asked GDB to kill the
* target
*/
rtems_fatal_error_occurred(1122);
}
rtems_debugger->flags = 0;
rtems_debugger->ack_pending = false;
rtems_debugger_unlock();
if (rtems_debugger_verbose())
rtems_debugger_printf("rtems-db: remote finishing\n");
return r;
}
static int
rtems_debugger_create(const char* remote,
const char* device,
rtems_task_priority priority,
int timeout,
const rtems_printer* printer)
{
int r;
if (rtems_debugger != NULL) {
rtems_printf(printer, "error: rtems-db: create: already active\n");
errno = EEXIST;
return -1;
}
rtems_debugger = malloc(sizeof(rtems_debugger_server));
if (rtems_debugger == NULL) {
rtems_printf(printer, "error: rtems-db: create: no memory\n");
errno = ENOMEM;
return -1;
}
memset(rtems_debugger, 0, sizeof(rtems_debugger_server));
/*
* These do not change with a session.
*/
rtems_debugger->priority = priority;
rtems_debugger->timeout = timeout;
rtems_debugger->printer = *printer;
rtems_debugger->pid = getpid();
rtems_debugger->remote_debug = false;
rtems_chain_initialize_empty(&rtems_debugger->exception_threads);
rtems_debugger->remote = rtems_debugger_remote_find(remote);
if (rtems_debugger->remote== NULL) {
rtems_printf(printer, "error: rtems-db: remote not found: %s\n", remote);
free(rtems_debugger);
rtems_debugger = NULL;
return -1;
}
r = rtems_debugger->remote->begin(rtems_debugger->remote, device);
if (r < 0) {
rtems_printf(printer, "error: rtems-db: remote begin: %s: %s\n",
rtems_debugger->remote->name, strerror(errno));
free(rtems_debugger);
rtems_debugger = NULL;
return -1;
}
/*
* Reset at the end of the session.
*/
rtems_debugger->flags = 0;
rtems_debugger->ack_pending = false;
r = rtems_debugger_lock_create();
if (r < 0) {
free(rtems_debugger);
rtems_debugger = NULL;
return -1;
}
return 0;
}
static int
rtems_debugger_destroy(void)
{
int r;
int rr;
rtems_debugger_lock();
rtems_debugger->server_running = false;
rtems_debugger_unlock();
r = rtems_debugger_remote_disconnect();
rr = rtems_debugger->remote->end(rtems_debugger->remote);
if (rr < 0 && r == 0)
r = rr;
rr = rtems_debugger_task_destroy("DBSs",
rtems_debugger->server_task,
&rtems_debugger->server_finished,
RTEMS_DEBUGGER_TIMEOUT_STOP);
if (rr < 0 && r == 0)
r = rr;
rr = rtems_debugger_lock_destroy();
if (rr < 0 && r == 0)
r = rr;
free(rtems_debugger);
rtems_debugger = NULL;
return r;
}
static void
rtems_debugger_main(rtems_task_argument arg)
{
int r;
rtems_debugger_lock();
rtems_debugger->server_running = true;
rtems_debugger->server_finished = false;
rtems_debugger_unlock();
rtems_debugger_printf("rtems-db: remote running\n");
while (rtems_debugger_server_running()) {
r = rtems_debugger_remote_connect();
if (r < 0)
break;
rtems_debugger_session();
rtems_debugger_remote_disconnect();
}
rtems_debugger_printf("rtems-db: remote finishing\n");
rtems_debugger_lock();
rtems_debugger->server_running = false;
rtems_debugger->server_finished = true;
rtems_debugger_unlock();
rtems_task_exit();
}
int
rtems_debugger_start(const char* remote,
const char* device,
int timeout,
rtems_task_priority priority,
const rtems_printer* printer)
{
int r;
r = rtems_debugger_create(remote, device, priority, timeout, printer);
if (r < 0)
return -1;
rtems_debugger_lock();
rtems_debugger->server_running = false;
rtems_debugger->server_finished = true;
_Condition_Initialize_named(&rtems_debugger->server_cond, "DBserver");
rtems_debugger_unlock();
r = rtems_debugger_task_create("DBSs",
priority,
RTEMS_DEBUGGER_STACKSIZE,
rtems_debugger_main,
0,
&rtems_debugger->server_task);
if (r < 0) {
rtems_debugger_destroy();
return -1;
}
return 0;
}
void
rtems_debugger_server_crash(void)
{
rtems_debugger_lock();
rtems_debugger->server_running = false;
rtems_debugger_unlock();
rtems_debugger->remote->end(rtems_debugger->remote);
}
int
rtems_debugger_break(bool wait)
{
int r = 0;
if (!rtems_debugger_running()) {
errno = EIO;
r = -1;
} else {
rtems_debugger_lock();
if (rtems_debugger_server_events_running()) {
rtems_debugger_server_events_signal();
} else if (
wait && !rtems_debugger_server_flag(RTEMS_DEBUGGER_FLAG_BREAK_WAITER)) {
rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_BREAK_WAITER;
rtems_debugger_server_events_wait();
} else {
errno = EIO;
r = -1;
}
rtems_debugger_unlock();
}
return r;
}
int
rtems_debugger_stop(void)
{
return rtems_debugger_destroy();
}
bool
rtems_debugger_running(void)
{
return rtems_debugger != NULL;
}
void
rtems_debugger_set_verbose(bool on)
{
if (rtems_debugger_running()) {
if (on)
rtems_debugger->flags |= RTEMS_DEBUGGER_FLAG_VERBOSE;
else
rtems_debugger->flags &= ~RTEMS_DEBUGGER_FLAG_VERBOSE;
}
}
int
rtems_debugger_remote_debug(bool state)
{
if (rtems_debugger_running()) {
rtems_debugger_lock();
rtems_debugger->remote_debug = state;
rtems_debugger_printf("rtems-db: remote-debug is %s\n",
rtems_debugger->remote_debug ? "on" : "off");
rtems_debugger_unlock();
} else {
rtems_debugger_printf("rtems-db: debug server not running\n");
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink