Archipelago » qemu

/*

 * gdb server stub

 *

 * Copyright (c) 2003-2005 Fabrice Bellard

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include "qemu-common.h"

#ifdef CONFIG_USER_ONLY

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include "qemu.h"

#else

#include "monitor/monitor.h"

#include "sysemu/char.h"

#include "sysemu/sysemu.h"

#include "exec/gdbstub.h"

#endif

#define MAX_PACKET_LENGTH 4096

#include "cpu.h"

#include "qemu/sockets.h"

#include "sysemu/kvm.h"

static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,

                                         uint8_t *buf, int len, bool is_write)

{

    CPUClass *cc = CPU_GET_CLASS(cpu);

    if (cc->memory_rw_debug) {

        return cc->memory_rw_debug(cpu, addr, buf, len, is_write);

    }

    return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);

}

enum {

    GDB_SIGNAL_0 = 0,

    GDB_SIGNAL_INT = 2,

    GDB_SIGNAL_QUIT = 3,

    GDB_SIGNAL_TRAP = 5,

    GDB_SIGNAL_ABRT = 6,

    GDB_SIGNAL_ALRM = 14,

    GDB_SIGNAL_IO = 23,

    GDB_SIGNAL_XCPU = 24,

    GDB_SIGNAL_UNKNOWN = 143

};

#ifdef CONFIG_USER_ONLY

/* Map target signal numbers to GDB protocol signal numbers and vice

 * versa.  For user emulation's currently supported systems, we can

 * assume most signals are defined.

 */

static int gdb_signal_table[] = {

    0,

    TARGET_SIGHUP,

    TARGET_SIGINT,

    TARGET_SIGQUIT,

    TARGET_SIGILL,

    TARGET_SIGTRAP,

    TARGET_SIGABRT,

    -1, /* SIGEMT */

    TARGET_SIGFPE,

    TARGET_SIGKILL,

    TARGET_SIGBUS,

    TARGET_SIGSEGV,

    TARGET_SIGSYS,

    TARGET_SIGPIPE,

    TARGET_SIGALRM,

    TARGET_SIGTERM,

    TARGET_SIGURG,

    TARGET_SIGSTOP,

    TARGET_SIGTSTP,

    TARGET_SIGCONT,

    TARGET_SIGCHLD,

    TARGET_SIGTTIN,

    TARGET_SIGTTOU,

    TARGET_SIGIO,

    TARGET_SIGXCPU,

    TARGET_SIGXFSZ,

    TARGET_SIGVTALRM,

    TARGET_SIGPROF,

    TARGET_SIGWINCH,

    -1, /* SIGLOST */

    TARGET_SIGUSR1,

    TARGET_SIGUSR2,

#ifdef TARGET_SIGPWR

    TARGET_SIGPWR,

#else

    -1,

#endif

    -1, /* SIGPOLL */

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

    -1,

#ifdef __SIGRTMIN

    __SIGRTMIN + 1,

    __SIGRTMIN + 2,

    __SIGRTMIN + 3,

    __SIGRTMIN + 4,

    __SIGRTMIN + 5,

    __SIGRTMIN + 6,

    __SIGRTMIN + 7,

    __SIGRTMIN + 8,

    __SIGRTMIN + 9,

    __SIGRTMIN + 10,

    __SIGRTMIN + 11,

    __SIGRTMIN + 12,

    __SIGRTMIN + 13,

    __SIGRTMIN + 14,

    __SIGRTMIN + 15,

    __SIGRTMIN + 16,

    __SIGRTMIN + 17,

    __SIGRTMIN + 18,

    __SIGRTMIN + 19,

    __SIGRTMIN + 20,

    __SIGRTMIN + 21,

    __SIGRTMIN + 22,

    __SIGRTMIN + 23,

    __SIGRTMIN + 24,

    __SIGRTMIN + 25,

    __SIGRTMIN + 26,

    __SIGRTMIN + 27,

    __SIGRTMIN + 28,

    __SIGRTMIN + 29,

    __SIGRTMIN + 30,

    __SIGRTMIN + 31,

    -1, /* SIGCANCEL */

    __SIGRTMIN,

    __SIGRTMIN + 32,

    __SIGRTMIN + 33,

    __SIGRTMIN + 34,

    __SIGRTMIN + 35,

    __SIGRTMIN + 36,

    __SIGRTMIN + 37,

    __SIGRTMIN + 38,

    __SIGRTMIN + 39,

    __SIGRTMIN + 40,

    __SIGRTMIN + 41,

    __SIGRTMIN + 42,

    __SIGRTMIN + 43,

    __SIGRTMIN + 44,

    __SIGRTMIN + 45,

    __SIGRTMIN + 46,

    __SIGRTMIN + 47,

    __SIGRTMIN + 48,

    __SIGRTMIN + 49,

    __SIGRTMIN + 50,

    __SIGRTMIN + 51,

    __SIGRTMIN + 52,

    __SIGRTMIN + 53,

    __SIGRTMIN + 54,

    __SIGRTMIN + 55,

    __SIGRTMIN + 56,

    __SIGRTMIN + 57,

    __SIGRTMIN + 58,

    __SIGRTMIN + 59,

    __SIGRTMIN + 60,

    __SIGRTMIN + 61,

    __SIGRTMIN + 62,

    __SIGRTMIN + 63,

    __SIGRTMIN + 64,

    __SIGRTMIN + 65,

    __SIGRTMIN + 66,

    __SIGRTMIN + 67,

    __SIGRTMIN + 68,

    __SIGRTMIN + 69,

    __SIGRTMIN + 70,

    __SIGRTMIN + 71,

    __SIGRTMIN + 72,

    __SIGRTMIN + 73,

    __SIGRTMIN + 74,

    __SIGRTMIN + 75,

    __SIGRTMIN + 76,

    __SIGRTMIN + 77,

    __SIGRTMIN + 78,

    __SIGRTMIN + 79,

    __SIGRTMIN + 80,

    __SIGRTMIN + 81,

    __SIGRTMIN + 82,

    __SIGRTMIN + 83,

    __SIGRTMIN + 84,

    __SIGRTMIN + 85,

    __SIGRTMIN + 86,

    __SIGRTMIN + 87,

    __SIGRTMIN + 88,

    __SIGRTMIN + 89,

    __SIGRTMIN + 90,

    __SIGRTMIN + 91,

    __SIGRTMIN + 92,

    __SIGRTMIN + 93,

    __SIGRTMIN + 94,

    __SIGRTMIN + 95,

    -1, /* SIGINFO */

    -1, /* UNKNOWN */

    -1, /* DEFAULT */

    -1,

    -1,

    -1,

    -1,

    -1,

    -1

#endif

};

#else

/* In system mode we only need SIGINT and SIGTRAP; other signals

   are not yet supported.  */

enum {

    TARGET_SIGINT = 2,

    TARGET_SIGTRAP = 5

};

static int gdb_signal_table[] = {

    -1,

    -1,

    TARGET_SIGINT,

    -1,

    -1,

    TARGET_SIGTRAP

};

#endif

#ifdef CONFIG_USER_ONLY

static int target_signal_to_gdb (int sig)

{

    int i;

    for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)

        if (gdb_signal_table[i] == sig)

            return i;

    return GDB_SIGNAL_UNKNOWN;

}

#endif

static int gdb_signal_to_target (int sig)

{

    if (sig < ARRAY_SIZE (gdb_signal_table))

        return gdb_signal_table[sig];

    else

        return -1;

}

//#define DEBUG_GDB

typedef struct GDBRegisterState {

    int base_reg;

    int num_regs;

    gdb_reg_cb get_reg;

    gdb_reg_cb set_reg;

    const char *xml;

    struct GDBRegisterState *next;

} GDBRegisterState;

enum RSState {

    RS_INACTIVE,

    RS_IDLE,

    RS_GETLINE,

    RS_CHKSUM1,

    RS_CHKSUM2,

};

typedef struct GDBState {

    CPUState *c_cpu; /* current CPU for step/continue ops */

    CPUState *g_cpu; /* current CPU for other ops */

    CPUState *query_cpu; /* for q{f|s}ThreadInfo */

    enum RSState state; /* parsing state */

    char line_buf[MAX_PACKET_LENGTH];

    int line_buf_index;

    int line_csum;

    uint8_t last_packet[MAX_PACKET_LENGTH + 4];

    int last_packet_len;

    int signal;

#ifdef CONFIG_USER_ONLY

    int fd;

    int running_state;

#else

    CharDriverState *chr;

    CharDriverState *mon_chr;

#endif

    char syscall_buf[256];

    gdb_syscall_complete_cb current_syscall_cb;

} GDBState;

/* By default use no IRQs and no timers while single stepping so as to

 * make single stepping like an ICE HW step.

 */

static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;

static GDBState *gdbserver_state;

bool gdb_has_xml;

#ifdef CONFIG_USER_ONLY

/* XXX: This is not thread safe.  Do we care?  */

static int gdbserver_fd = -1;

static int get_char(GDBState *s)

{

    uint8_t ch;

    int ret;

    for(;;) {

        ret = qemu_recv(s->fd, &ch, 1, 0);

        if (ret < 0) {

            if (errno == ECONNRESET)

                s->fd = -1;

            if (errno != EINTR && errno != EAGAIN)

                return -1;

        } else if (ret == 0) {

            close(s->fd);

            s->fd = -1;

            return -1;

        } else {

            break;

        }

    }

    return ch;

}

#endif

static enum {

    GDB_SYS_UNKNOWN,

    GDB_SYS_ENABLED,

    GDB_SYS_DISABLED,

} gdb_syscall_mode;

/* If gdb is connected when the first semihosting syscall occurs then use

   remote gdb syscalls.  Otherwise use native file IO.  */

int use_gdb_syscalls(void)

{

    if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {

        gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED

                                            : GDB_SYS_DISABLED);

    }

    return gdb_syscall_mode == GDB_SYS_ENABLED;

}

/* Resume execution.  */

static inline void gdb_continue(GDBState *s)

{

#ifdef CONFIG_USER_ONLY

    s->running_state = 1;

#else

    if (runstate_check(RUN_STATE_GUEST_PANICKED)) {

        runstate_set(RUN_STATE_DEBUG);

    }

    if (!runstate_needs_reset()) {

        vm_start();

    }

#endif

}

static void put_buffer(GDBState *s, const uint8_t *buf, int len)

{

#ifdef CONFIG_USER_ONLY

    int ret;

    while (len > 0) {

        ret = send(s->fd, buf, len, 0);

        if (ret < 0) {

            if (errno != EINTR && errno != EAGAIN)

                return;

        } else {

            buf += ret;

            len -= ret;

        }

    }

#else

    qemu_chr_fe_write(s->chr, buf, len);

#endif

}

static inline int fromhex(int v)

{

    if (v >= '0' && v <= '9')

        return v - '0';

    else if (v >= 'A' && v <= 'F')

        return v - 'A' + 10;

    else if (v >= 'a' && v <= 'f')

        return v - 'a' + 10;

    else

        return 0;

}

static inline int tohex(int v)

{

    if (v < 10)

        return v + '0';

    else

        return v - 10 + 'a';

}

static void memtohex(char *buf, const uint8_t *mem, int len)

{

    int i, c;

    char *q;

    q = buf;

    for(i = 0; i < len; i++) {

        c = mem[i];

        *q++ = tohex(c >> 4);

        *q++ = tohex(c & 0xf);

    }

    *q = '\0';

}

static void hextomem(uint8_t *mem, const char *buf, int len)

{

    int i;

    for(i = 0; i < len; i++) {

        mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);

        buf += 2;

    }

}

/* return -1 if error, 0 if OK */

static int put_packet_binary(GDBState *s, const char *buf, int len)

{

    int csum, i;

    uint8_t *p;

    for(;;) {

        p = s->last_packet;

        *(p++) = '$';

        memcpy(p, buf, len);

        p += len;

        csum = 0;

        for(i = 0; i < len; i++) {

            csum += buf[i];

        }

        *(p++) = '#';

        *(p++) = tohex((csum >> 4) & 0xf);

        *(p++) = tohex((csum) & 0xf);

        s->last_packet_len = p - s->last_packet;

        put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);

#ifdef CONFIG_USER_ONLY

        i = get_char(s);

        if (i < 0)

            return -1;

        if (i == '+')

            break;

#else

        break;

#endif

    }

    return 0;

}

/* return -1 if error, 0 if OK */

static int put_packet(GDBState *s, const char *buf)

{

#ifdef DEBUG_GDB

    printf("reply='%s'\n", buf);

#endif

    return put_packet_binary(s, buf, strlen(buf));

}

/* Encode data using the encoding for 'x' packets.  */

static int memtox(char *buf, const char *mem, int len)

{

    char *p = buf;

    char c;

    while (len--) {

        c = *(mem++);

        switch (c) {

        case '#': case '$': case '*': case '}':

            *(p++) = '}';

            *(p++) = c ^ 0x20;

            break;

        default:

            *(p++) = c;

            break;

        }

    }

    return p - buf;

}

static const char *get_feature_xml(const char *p, const char **newp,

                                   CPUClass *cc)

{

    size_t len;

    int i;

    const char *name;

    static char target_xml[1024];

    len = 0;

    while (p[len] && p[len] != ':')

        len++;

    *newp = p + len;

    name = NULL;

    if (strncmp(p, "target.xml", len) == 0) {

        /* Generate the XML description for this CPU.  */

        if (!target_xml[0]) {

            GDBRegisterState *r;

            CPUState *cpu = first_cpu;

            snprintf(target_xml, sizeof(target_xml),

                     "<?xml version=\"1.0\"?>"

                     "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"

                     "<target>"

                     "<xi:include href=\"%s\"/>",

                     cc->gdb_core_xml_file);

            for (r = cpu->gdb_regs; r; r = r->next) {

                pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");

                pstrcat(target_xml, sizeof(target_xml), r->xml);

                pstrcat(target_xml, sizeof(target_xml), "\"/>");

            }

            pstrcat(target_xml, sizeof(target_xml), "</target>");

        }

        return target_xml;

    }

    for (i = 0; ; i++) {

        name = xml_builtin[i][0];

        if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))

            break;

    }

    return name ? xml_builtin[i][1] : NULL;

}

static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)

{

    CPUClass *cc = CPU_GET_CLASS(cpu);

    CPUArchState *env = cpu->env_ptr;

    GDBRegisterState *r;

    if (reg < cc->gdb_num_core_regs) {

        return cc->gdb_read_register(cpu, mem_buf, reg);

    }

    for (r = cpu->gdb_regs; r; r = r->next) {

        if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {

            return r->get_reg(env, mem_buf, reg - r->base_reg);

        }

    }

    return 0;

}

static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)

{

    CPUClass *cc = CPU_GET_CLASS(cpu);

    CPUArchState *env = cpu->env_ptr;

    GDBRegisterState *r;

    if (reg < cc->gdb_num_core_regs) {

        return cc->gdb_write_register(cpu, mem_buf, reg);

    }

    for (r = cpu->gdb_regs; r; r = r->next) {

        if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {

            return r->set_reg(env, mem_buf, reg - r->base_reg);

        }

    }

    return 0;

}

/* Register a supplemental set of CPU registers.  If g_pos is nonzero it

   specifies the first register number and these registers are included in

   a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is

   gdb reading a CPU register, and set_reg is gdb modifying a CPU register.

 */

void gdb_register_coprocessor(CPUState *cpu,

                              gdb_reg_cb get_reg, gdb_reg_cb set_reg,

                              int num_regs, const char *xml, int g_pos)

{

    GDBRegisterState *s;

    GDBRegisterState **p;

    p = &cpu->gdb_regs;

    while (*p) {

        /* Check for duplicates.  */

        if (strcmp((*p)->xml, xml) == 0)

            return;

        p = &(*p)->next;

    }

    s = g_new0(GDBRegisterState, 1);

    s->base_reg = cpu->gdb_num_regs;

    s->num_regs = num_regs;

    s->get_reg = get_reg;

    s->set_reg = set_reg;

    s->xml = xml;

    /* Add to end of list.  */

    cpu->gdb_num_regs += num_regs;

    *p = s;

    if (g_pos) {

        if (g_pos != s->base_reg) {

            fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"

                    "Expected %d got %d\n", xml, g_pos, s->base_reg);

        } else {

            cpu->gdb_num_g_regs = cpu->gdb_num_regs;

        }

    }

}

#ifndef CONFIG_USER_ONLY

static const int xlat_gdb_type[] = {

    [GDB_WATCHPOINT_WRITE]  = BP_GDB | BP_MEM_WRITE,

    [GDB_WATCHPOINT_READ]   = BP_GDB | BP_MEM_READ,

    [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,

};

#endif

static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)

{

    CPUState *cpu;

    CPUArchState *env;

    int err = 0;

    if (kvm_enabled()) {

        return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);

    }

    switch (type) {

    case GDB_BREAKPOINT_SW:

    case GDB_BREAKPOINT_HW:

        for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {

            env = cpu->env_ptr;

            err = cpu_breakpoint_insert(env, addr, BP_GDB, NULL);

            if (err)

                break;

        }

        return err;

#ifndef CONFIG_USER_ONLY

    case GDB_WATCHPOINT_WRITE:

    case GDB_WATCHPOINT_READ:

    case GDB_WATCHPOINT_ACCESS:

        for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {

            env = cpu->env_ptr;

            err = cpu_watchpoint_insert(env, addr, len, xlat_gdb_type[type],

                                        NULL);

            if (err)

                break;

        }

        return err;

#endif

    default:

        return -ENOSYS;

    }

}

static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)

{

    CPUState *cpu;

    CPUArchState *env;

    int err = 0;

    if (kvm_enabled()) {

        return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);

    }

    switch (type) {

    case GDB_BREAKPOINT_SW:

    case GDB_BREAKPOINT_HW:

        for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {

            env = cpu->env_ptr;

            err = cpu_breakpoint_remove(env, addr, BP_GDB);

            if (err)

                break;

        }

        return err;

#ifndef CONFIG_USER_ONLY

    case GDB_WATCHPOINT_WRITE:

    case GDB_WATCHPOINT_READ:

    case GDB_WATCHPOINT_ACCESS:

        for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {

            env = cpu->env_ptr;

            err = cpu_watchpoint_remove(env, addr, len, xlat_gdb_type[type]);

            if (err)

                break;

        }

        return err;

#endif

    default:

        return -ENOSYS;

    }

}

static void gdb_breakpoint_remove_all(void)

{

    CPUState *cpu;

    CPUArchState *env;

    if (kvm_enabled()) {

        kvm_remove_all_breakpoints(gdbserver_state->c_cpu);

        return;

    }

    for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {

        env = cpu->env_ptr;

        cpu_breakpoint_remove_all(env, BP_GDB);

#ifndef CONFIG_USER_ONLY

        cpu_watchpoint_remove_all(env, BP_GDB);

#endif

    }

}

static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)

{

    CPUState *cpu = s->c_cpu;

    CPUClass *cc = CPU_GET_CLASS(cpu);

    cpu_synchronize_state(cpu);

    if (cc->set_pc) {

        cc->set_pc(cpu, pc);

    }

}

static CPUState *find_cpu(uint32_t thread_id)

{

    CPUState *cpu;

    for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {

        if (cpu_index(cpu) == thread_id) {

            return cpu;

        }

    }

    return NULL;

}

static int gdb_handle_packet(GDBState *s, const char *line_buf)

{

    CPUState *cpu;

    CPUClass *cc;

    const char *p;

    uint32_t thread;

    int ch, reg_size, type, res;

    char buf[MAX_PACKET_LENGTH];

    uint8_t mem_buf[MAX_PACKET_LENGTH];

    uint8_t *registers;

    target_ulong addr, len;

#ifdef DEBUG_GDB

    printf("command='%s'\n", line_buf);

#endif

    p = line_buf;

    ch = *p++;

    switch(ch) {

    case '?':

        /* TODO: Make this return the correct value for user-mode.  */

        snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,

                 cpu_index(s->c_cpu));

        put_packet(s, buf);

        /* Remove all the breakpoints when this query is issued,

         * because gdb is doing and initial connect and the state

         * should be cleaned up.

         */

        gdb_breakpoint_remove_all();

        break;

    case 'c':

        if (*p != '\0') {

            addr = strtoull(p, (char **)&p, 16);

            gdb_set_cpu_pc(s, addr);

        }

        s->signal = 0;

        gdb_continue(s);

        return RS_IDLE;

    case 'C':

        s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));

        if (s->signal == -1)

            s->signal = 0;

        gdb_continue(s);

        return RS_IDLE;

    case 'v':

        if (strncmp(p, "Cont", 4) == 0) {

            int res_signal, res_thread;

            p += 4;

            if (*p == '?') {

                put_packet(s, "vCont;c;C;s;S");

                break;

            }

            res = 0;

            res_signal = 0;

            res_thread = 0;

            while (*p) {

                int action, signal;

                if (*p++ != ';') {

                    res = 0;

                    break;

                }

                action = *p++;

                signal = 0;

                if (action == 'C' || action == 'S') {

                    signal = strtoul(p, (char **)&p, 16);

                } else if (action != 'c' && action != 's') {

                    res = 0;

                    break;

                }

                thread = 0;

                if (*p == ':') {

                    thread = strtoull(p+1, (char **)&p, 16);

                }

                action = tolower(action);

                if (res == 0 || (res == 'c' && action == 's')) {

                    res = action;

                    res_signal = signal;

                    res_thread = thread;

                }

            }

            if (res) {

                if (res_thread != -1 && res_thread != 0) {

                    cpu = find_cpu(res_thread);

                    if (cpu == NULL) {

                        put_packet(s, "E22");

                        break;

                    }

                    s->c_cpu = cpu;

                }

                if (res == 's') {

                    cpu_single_step(s->c_cpu, sstep_flags);

                }

                s->signal = res_signal;

                gdb_continue(s);

                return RS_IDLE;

            }

            break;

        } else {

            goto unknown_command;

        }

    case 'k':

#ifdef CONFIG_USER_ONLY

        /* Kill the target */

        fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");

        exit(0);

#endif

    case 'D':

        /* Detach packet */

        gdb_breakpoint_remove_all();

        gdb_syscall_mode = GDB_SYS_DISABLED;

        gdb_continue(s);

        put_packet(s, "OK");

        break;

    case 's':

        if (*p != '\0') {

            addr = strtoull(p, (char **)&p, 16);

            gdb_set_cpu_pc(s, addr);

        }

        cpu_single_step(s->c_cpu, sstep_flags);

        gdb_continue(s);

        return RS_IDLE;

    case 'F':

        {

            target_ulong ret;

            target_ulong err;

            ret = strtoull(p, (char **)&p, 16);

            if (*p == ',') {

                p++;

                err = strtoull(p, (char **)&p, 16);

            } else {