gdbstub.c 53.8 KB
Newer Older
bellard's avatar
bellard committed
1 2
/*
 * gdb server stub
3
 *
bellard's avatar
bellard committed
4
 * Copyright (c) 2003-2005 Fabrice Bellard
bellard's avatar
bellard committed
5 6 7 8 9 10 11 12 13 14 15 16
 *
 * 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
17
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
bellard's avatar
bellard committed
18
 */
Peter Maydell's avatar
Peter Maydell committed
19
#include "qemu/osdep.h"
20
#include "qapi/error.h"
21
#include "qemu/error-report.h"
22
#include "qemu/cutils.h"
23
#include "cpu.h"
Doug Gale's avatar
Doug Gale committed
24
#include "trace-root.h"
25
#ifdef CONFIG_USER_ONLY
26 27
#include "qemu.h"
#else
28
#include "monitor/monitor.h"
29
#include "chardev/char.h"
30
#include "chardev/char-fe.h"
31
#include "sysemu/sysemu.h"
32
#include "exec/gdbstub.h"
33
#endif
34

35 36
#define MAX_PACKET_LENGTH 4096

37
#include "qemu/sockets.h"
38
#include "sysemu/hw_accel.h"
39
#include "sysemu/kvm.h"
40
#include "exec/semihost.h"
41
#include "exec/exec-all.h"
42

Jan Kiszka's avatar
Jan Kiszka committed
43 44 45 46 47 48
#ifdef CONFIG_USER_ONLY
#define GDB_ATTACHED "0"
#else
#define GDB_ATTACHED "1"
#endif

49 50
static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
                                         uint8_t *buf, int len, bool is_write)
51
{
52 53 54 55 56 57
    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);
58
}
59

60 61 62 63 64 65 66 67
/* Return the GDB index for a given vCPU state.
 *
 * For user mode this is simply the thread id. In system mode GDB
 * numbers CPUs from 1 as 0 is reserved as an "any cpu" index.
 */
static inline int cpu_gdb_index(CPUState *cpu)
{
#if defined(CONFIG_USER_ONLY)
68 69
    TaskState *ts = (TaskState *) cpu->opaque;
    return ts->ts_tid;
70 71 72 73 74
#else
    return cpu->cpu_index + 1;
#endif
}

75 76 77
enum {
    GDB_SIGNAL_0 = 0,
    GDB_SIGNAL_INT = 2,
78
    GDB_SIGNAL_QUIT = 3,
79
    GDB_SIGNAL_TRAP = 5,
80 81 82 83
    GDB_SIGNAL_ABRT = 6,
    GDB_SIGNAL_ALRM = 14,
    GDB_SIGNAL_IO = 23,
    GDB_SIGNAL_XCPU = 24,
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
    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,
blueswir1's avatar
blueswir1 committed
127
#ifdef TARGET_SIGPWR
128
    TARGET_SIGPWR,
blueswir1's avatar
blueswir1 committed
129 130 131
#else
    -1,
#endif
132 133 134 135 136 137 138 139 140 141 142 143
    -1, /* SIGPOLL */
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
blueswir1's avatar
blueswir1 committed
144
#ifdef __SIGRTMIN
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
    __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
blueswir1's avatar
blueswir1 committed
251
#endif
252
};
bellard's avatar
bellard committed
253
#else
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
/* 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;
}
bellard's avatar
bellard committed
281
#endif
bellard's avatar
bellard committed
282

283 284 285 286 287 288 289 290
static int gdb_signal_to_target (int sig)
{
    if (sig < ARRAY_SIZE (gdb_signal_table))
        return gdb_signal_table[sig];
    else
        return -1;
}

291 292 293 294 295 296 297 298 299
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;

300
enum RSState {
301
    RS_INACTIVE,
302 303
    RS_IDLE,
    RS_GETLINE,
304 305
    RS_GETLINE_ESC,
    RS_GETLINE_RLE,
306 307 308 309
    RS_CHKSUM1,
    RS_CHKSUM2,
};
typedef struct GDBState {
310 311
    CPUState *c_cpu; /* current CPU for step/continue ops */
    CPUState *g_cpu; /* current CPU for other ops */
312
    CPUState *query_cpu; /* for q{f|s}ThreadInfo */
bellard's avatar
bellard committed
313
    enum RSState state; /* parsing state */
314
    char line_buf[MAX_PACKET_LENGTH];
315
    int line_buf_index;
316 317
    int line_sum; /* running checksum */
    int line_csum; /* checksum at the end of the packet */
318
    uint8_t last_packet[MAX_PACKET_LENGTH + 4];
319
    int last_packet_len;
320
    int signal;
bellard's avatar
bellard committed
321
#ifdef CONFIG_USER_ONLY
322
    int fd;
bellard's avatar
bellard committed
323
    int running_state;
324
#else
325
    CharBackend chr;
326
    Chardev *mon_chr;
bellard's avatar
bellard committed
327
#endif
328 329
    char syscall_buf[256];
    gdb_syscall_complete_cb current_syscall_cb;
330
} GDBState;
bellard's avatar
bellard committed
331

332 333 334 335 336
/* 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;

337 338
static GDBState *gdbserver_state;

339
bool gdb_has_xml;
340

341
#ifdef CONFIG_USER_ONLY
342 343 344
/* XXX: This is not thread safe.  Do we care?  */
static int gdbserver_fd = -1;

345
static int get_char(GDBState *s)
bellard's avatar
bellard committed
346 347 348 349 350
{
    uint8_t ch;
    int ret;

    for(;;) {
Blue Swirl's avatar
Blue Swirl committed
351
        ret = qemu_recv(s->fd, &ch, 1, 0);
bellard's avatar
bellard committed
352
        if (ret < 0) {
353 354
            if (errno == ECONNRESET)
                s->fd = -1;
355
            if (errno != EINTR)
bellard's avatar
bellard committed
356 357
                return -1;
        } else if (ret == 0) {
358 359
            close(s->fd);
            s->fd = -1;
bellard's avatar
bellard committed
360 361 362 363 364 365 366
            return -1;
        } else {
            break;
        }
    }
    return ch;
}
367
#endif
bellard's avatar
bellard committed
368

369
static enum {
pbrook's avatar
pbrook committed
370 371 372 373 374
    GDB_SYS_UNKNOWN,
    GDB_SYS_ENABLED,
    GDB_SYS_DISABLED,
} gdb_syscall_mode;

375
/* Decide if either remote gdb syscalls or native file IO should be used. */
pbrook's avatar
pbrook committed
376 377
int use_gdb_syscalls(void)
{
378 379
    SemihostingTarget target = semihosting_get_target();
    if (target == SEMIHOSTING_TARGET_NATIVE) {
380 381
        /* -semihosting-config target=native */
        return false;
382
    } else if (target == SEMIHOSTING_TARGET_GDB) {
383 384 385 386 387 388
        /* -semihosting-config target=gdb */
        return true;
    }

    /* -semihosting-config target=auto */
    /* On the first call check if gdb is connected and remember. */
pbrook's avatar
pbrook committed
389
    if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
390 391
        gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
                                            : GDB_SYS_DISABLED);
pbrook's avatar
pbrook committed
392 393 394 395
    }
    return gdb_syscall_mode == GDB_SYS_ENABLED;
}

396 397 398
/* Resume execution.  */
static inline void gdb_continue(GDBState *s)
{
Doug Gale's avatar
Doug Gale committed
399

400 401
#ifdef CONFIG_USER_ONLY
    s->running_state = 1;
Doug Gale's avatar
Doug Gale committed
402
    trace_gdbstub_op_continue();
403
#else
404
    if (!runstate_needs_reset()) {
Doug Gale's avatar
Doug Gale committed
405
        trace_gdbstub_op_continue();
406 407
        vm_start();
    }
408 409 410
#endif
}

411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
/*
 * Resume execution, per CPU actions. For user-mode emulation it's
 * equivalent to gdb_continue.
 */
static int gdb_continue_partial(GDBState *s, char *newstates)
{
    CPUState *cpu;
    int res = 0;
#ifdef CONFIG_USER_ONLY
    /*
     * This is not exactly accurate, but it's an improvement compared to the
     * previous situation, where only one CPU would be single-stepped.
     */
    CPU_FOREACH(cpu) {
        if (newstates[cpu->cpu_index] == 's') {
Doug Gale's avatar
Doug Gale committed
426
            trace_gdbstub_op_stepping(cpu->cpu_index);
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
            cpu_single_step(cpu, sstep_flags);
        }
    }
    s->running_state = 1;
#else
    int flag = 0;

    if (!runstate_needs_reset()) {
        if (vm_prepare_start()) {
            return 0;
        }

        CPU_FOREACH(cpu) {
            switch (newstates[cpu->cpu_index]) {
            case 0:
            case 1:
                break; /* nothing to do here */
            case 's':
Doug Gale's avatar
Doug Gale committed
445
                trace_gdbstub_op_stepping(cpu->cpu_index);
446 447 448 449 450
                cpu_single_step(cpu, sstep_flags);
                cpu_resume(cpu);
                flag = 1;
                break;
            case 'c':
Doug Gale's avatar
Doug Gale committed
451
                trace_gdbstub_op_continue_cpu(cpu->cpu_index);
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
                cpu_resume(cpu);
                flag = 1;
                break;
            default:
                res = -1;
                break;
            }
        }
    }
    if (flag) {
        qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
    }
#endif
    return res;
}

468
static void put_buffer(GDBState *s, const uint8_t *buf, int len)
bellard's avatar
bellard committed
469
{
470
#ifdef CONFIG_USER_ONLY
bellard's avatar
bellard committed
471 472 473
    int ret;

    while (len > 0) {
bellard's avatar
bellard committed
474
        ret = send(s->fd, buf, len, 0);
bellard's avatar
bellard committed
475
        if (ret < 0) {
476
            if (errno != EINTR)
bellard's avatar
bellard committed
477 478 479 480 481 482
                return;
        } else {
            buf += ret;
            len -= ret;
        }
    }
483
#else
484 485
    /* XXX this blocks entire thread. Rewrite to use
     * qemu_chr_fe_write and background I/O callbacks */
486
    qemu_chr_fe_write_all(&s->chr, buf, len);
487
#endif
bellard's avatar
bellard committed
488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
}

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';
}

510
/* writes 2*len+1 bytes in buf */
bellard's avatar
bellard committed
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
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;
    }
}

Doug Gale's avatar
Doug Gale committed
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
static void hexdump(const char *buf, int len,
                    void (*trace_fn)(size_t ofs, char const *text))
{
    char line_buffer[3 * 16 + 4 + 16 + 1];

    size_t i;
    for (i = 0; i < len || (i & 0xF); ++i) {
        size_t byte_ofs = i & 15;

        if (byte_ofs == 0) {
            memset(line_buffer, ' ', 3 * 16 + 4 + 16);
            line_buffer[3 * 16 + 4 + 16] = 0;
        }

        size_t col_group = (i >> 2) & 3;
        size_t hex_col = byte_ofs * 3 + col_group;
        size_t txt_col = 3 * 16 + 4 + byte_ofs;

        if (i < len) {
            char value = buf[i];

            line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
            line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
            line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
                    ? value
                    : '.';
        }

        if (byte_ofs == 0xF)
            trace_fn(i & -16, line_buffer);
    }
}

bellard's avatar
bellard committed
567
/* return -1 if error, 0 if OK */
Doug Gale's avatar
Doug Gale committed
568
static int put_packet_binary(GDBState *s, const char *buf, int len, bool dump)
bellard's avatar
bellard committed
569
{
570
    int csum, i;
571
    uint8_t *p;
bellard's avatar
bellard committed
572

Doug Gale's avatar
Doug Gale committed
573 574 575 576
    if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
        hexdump(buf, len, trace_gdbstub_io_binaryreply);
    }

bellard's avatar
bellard committed
577
    for(;;) {
578 579 580 581
        p = s->last_packet;
        *(p++) = '$';
        memcpy(p, buf, len);
        p += len;
bellard's avatar
bellard committed
582 583 584 585
        csum = 0;
        for(i = 0; i < len; i++) {
            csum += buf[i];
        }
586 587 588
        *(p++) = '#';
        *(p++) = tohex((csum >> 4) & 0xf);
        *(p++) = tohex((csum) & 0xf);
bellard's avatar
bellard committed
589

590
        s->last_packet_len = p - s->last_packet;
591
        put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
bellard's avatar
bellard committed
592

593 594 595
#ifdef CONFIG_USER_ONLY
        i = get_char(s);
        if (i < 0)
bellard's avatar
bellard committed
596
            return -1;
597
        if (i == '+')
bellard's avatar
bellard committed
598
            break;
599 600 601
#else
        break;
#endif
bellard's avatar
bellard committed
602 603 604 605
    }
    return 0;
}

606 607 608
/* return -1 if error, 0 if OK */
static int put_packet(GDBState *s, const char *buf)
{
Doug Gale's avatar
Doug Gale committed
609
    trace_gdbstub_io_reply(buf);
bellard's avatar
bellard committed
610

Doug Gale's avatar
Doug Gale committed
611
    return put_packet_binary(s, buf, strlen(buf), false);
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633
}

/* 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;
}
634

635 636
static const char *get_feature_xml(const char *p, const char **newp,
                                   CPUClass *cc)
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
{
    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;
653
            CPUState *cpu = first_cpu;
654

655 656 657 658 659 660 661 662 663 664 665 666 667 668
            pstrcat(target_xml, sizeof(target_xml),
                    "<?xml version=\"1.0\"?>"
                    "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
                    "<target>");
            if (cc->gdb_arch_name) {
                gchar *arch = cc->gdb_arch_name(cpu);
                pstrcat(target_xml, sizeof(target_xml), "<architecture>");
                pstrcat(target_xml, sizeof(target_xml), arch);
                pstrcat(target_xml, sizeof(target_xml), "</architecture>");
                g_free(arch);
            }
            pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
            pstrcat(target_xml, sizeof(target_xml), cc->gdb_core_xml_file);
            pstrcat(target_xml, sizeof(target_xml), "\"/>");
669
            for (r = cpu->gdb_regs; r; r = r->next) {
670 671 672
                pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
                pstrcat(target_xml, sizeof(target_xml), r->xml);
                pstrcat(target_xml, sizeof(target_xml), "\"/>");
673
            }
674
            pstrcat(target_xml, sizeof(target_xml), "</target>");
675 676 677 678 679 680 681 682 683 684
        }
        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;
}
685

686
static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
687
{
688
    CPUClass *cc = CPU_GET_CLASS(cpu);
689
    CPUArchState *env = cpu->env_ptr;
690
    GDBRegisterState *r;
691

692
    if (reg < cc->gdb_num_core_regs) {
693
        return cc->gdb_read_register(cpu, mem_buf, reg);
694
    }
695

696
    for (r = cpu->gdb_regs; r; r = r->next) {
697 698 699 700 701
        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;
702 703
}

704
static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
705
{
706
    CPUClass *cc = CPU_GET_CLASS(cpu);
707
    CPUArchState *env = cpu->env_ptr;
708
    GDBRegisterState *r;
709

710
    if (reg < cc->gdb_num_core_regs) {
711
        return cc->gdb_write_register(cpu, mem_buf, reg);
712
    }
713

714
    for (r = cpu->gdb_regs; r; r = r->next) {
715 716 717 718
        if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
            return r->set_reg(env, mem_buf, reg - r->base_reg);
        }
    }
bellard's avatar
bellard committed
719 720 721
    return 0;
}

722 723 724 725 726 727
/* 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.
 */

728 729 730
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)
bellard's avatar
bellard committed
731
{
732 733 734
    GDBRegisterState *s;
    GDBRegisterState **p;

735
    p = &cpu->gdb_regs;
736 737 738 739 740 741
    while (*p) {
        /* Check for duplicates.  */
        if (strcmp((*p)->xml, xml) == 0)
            return;
        p = &(*p)->next;
    }
Stefan Weil's avatar
Stefan Weil committed
742 743

    s = g_new0(GDBRegisterState, 1);
744
    s->base_reg = cpu->gdb_num_regs;
Stefan Weil's avatar
Stefan Weil committed
745 746 747 748 749
    s->num_regs = num_regs;
    s->get_reg = get_reg;
    s->set_reg = set_reg;
    s->xml = xml;

750
    /* Add to end of list.  */
751
    cpu->gdb_num_regs += num_regs;
752 753 754
    *p = s;
    if (g_pos) {
        if (g_pos != s->base_reg) {
755 756
            error_report("Error: Bad gdb register numbering for '%s', "
                         "expected %d got %d", xml, g_pos, s->base_reg);
757 758
        } else {
            cpu->gdb_num_g_regs = cpu->gdb_num_regs;
759 760
        }
    }
bellard's avatar
bellard committed
761 762
}

763
#ifndef CONFIG_USER_ONLY
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
/* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
{
    static const int xlat[] = {
        [GDB_WATCHPOINT_WRITE]  = BP_GDB | BP_MEM_WRITE,
        [GDB_WATCHPOINT_READ]   = BP_GDB | BP_MEM_READ,
        [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
    };

    CPUClass *cc = CPU_GET_CLASS(cpu);
    int cputype = xlat[gdbtype];

    if (cc->gdb_stop_before_watchpoint) {
        cputype |= BP_STOP_BEFORE_ACCESS;
    }
    return cputype;
}
781 782
#endif

783
static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
784
{
785
    CPUState *cpu;
786 787
    int err = 0;

788
    if (kvm_enabled()) {
789
        return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
790
    }
791

792 793 794
    switch (type) {
    case GDB_BREAKPOINT_SW:
    case GDB_BREAKPOINT_HW:
795
        CPU_FOREACH(cpu) {
796 797
            err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
            if (err) {
798
                break;
799
            }
800 801
        }
        return err;
802 803 804 805
#ifndef CONFIG_USER_ONLY
    case GDB_WATCHPOINT_WRITE:
    case GDB_WATCHPOINT_READ:
    case GDB_WATCHPOINT_ACCESS:
806
        CPU_FOREACH(cpu) {
807 808 809
            err = cpu_watchpoint_insert(cpu, addr, len,
                                        xlat_gdb_type(cpu, type), NULL);
            if (err) {
810
                break;
811
            }
812 813
        }
        return err;
814 815 816 817 818 819
#endif
    default:
        return -ENOSYS;
    }
}

820
static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
821
{
822
    CPUState *cpu;
823 824
    int err = 0;

825
    if (kvm_enabled()) {
826
        return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
827
    }
828

829 830 831
    switch (type) {
    case GDB_BREAKPOINT_SW:
    case GDB_BREAKPOINT_HW:
832
        CPU_FOREACH(cpu) {
833 834
            err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
            if (err) {
835
                break;
836
            }
837 838
        }
        return err;
839 840 841 842
#ifndef CONFIG_USER_ONLY
    case GDB_WATCHPOINT_WRITE:
    case GDB_WATCHPOINT_READ:
    case GDB_WATCHPOINT_ACCESS:
843
        CPU_FOREACH(cpu) {
844 845
            err = cpu_watchpoint_remove(cpu, addr, len,
                                        xlat_gdb_type(cpu, type));
846 847 848 849
            if (err)
                break;
        }
        return err;
850 851 852 853 854 855
#endif
    default:
        return -ENOSYS;
    }
}

856
static void gdb_breakpoint_remove_all(void)
857
{
858
    CPUState *cpu;
859

860
    if (kvm_enabled()) {
861
        kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
862 863 864
        return;
    }

865
    CPU_FOREACH(cpu) {
866
        cpu_breakpoint_remove_all(cpu, BP_GDB);
867
#ifndef CONFIG_USER_ONLY
868
        cpu_watchpoint_remove_all(cpu, BP_GDB);
869
#endif
870
    }
871 872
}

873 874
static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
{
875
    CPUState *cpu = s->c_cpu;
876 877

    cpu_synchronize_state(cpu);
878
    cpu_set_pc(cpu, pc);
879 880
}

881
static CPUState *find_cpu(uint32_t thread_id)
882
{
883
    CPUState *cpu;
884

885
    CPU_FOREACH(cpu) {
886
        if (cpu_gdb_index(cpu) == thread_id) {
887
            return cpu;
888
        }
889
    }
890 891

    return NULL;
892 893
}

894 895 896 897 898 899 900 901
static int is_query_packet(const char *p, const char *query, char separator)
{
    unsigned int query_len = strlen(query);

    return strncmp(p, query, query_len) == 0 &&
        (p[query_len] == '\0' || p[query_len] == separator);
}

902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
/**
 * gdb_handle_vcont - Parses and handles a vCont packet.
 * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
 *         a format error, 0 on success.
 */
static int gdb_handle_vcont(GDBState *s, const char *p)
{
    int res, idx, signal = 0;
    char cur_action;
    char *newstates;
    unsigned long tmp;
    CPUState *cpu;
#ifdef CONFIG_USER_ONLY
    int max_cpus = 1; /* global variable max_cpus exists only in system mode */

    CPU_FOREACH(cpu) {
        max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
    }
#endif
    /* uninitialised CPUs stay 0 */
    newstates = g_new0(char, max_cpus);

    /* mark valid CPUs with 1 */
    CPU_FOREACH(cpu) {
        newstates[cpu->cpu_index] = 1;
    }

    /*
     * res keeps track of what error we are returning, with -ENOTSUP meaning
     * that the command is unknown or unsupported, thus returning an empty
     * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
     *  or incorrect parameters passed.
     */
    res = 0;
    while (*p) {
        if (*p++ != ';') {
            res = -ENOTSUP;
            goto out;
        }

        cur_action = *p++;
        if (cur_action == 'C' || cur_action == 'S') {
944
            cur_action = qemu_tolower(cur_action);
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
            res = qemu_strtoul(p + 1, &p, 16, &tmp);
            if (res) {
                goto out;
            }
            signal = gdb_signal_to_target(tmp);
        } else if (cur_action != 'c' && cur_action != 's') {
            /* unknown/invalid/unsupported command */
            res = -ENOTSUP;
            goto out;
        }
        /* thread specification. special values: (none), -1 = all; 0 = any */
        if ((p[0] == ':' && p[1] == '-' && p[2] == '1') || (p[0] != ':')) {
            if (*p == ':') {
                p += 3;
            }
            for (idx = 0; idx < max_cpus; idx++) {
                if (newstates[idx] == 1) {
                    newstates[idx] = cur_action;
                }
            }
        } else if (*p == ':') {
            p++;
            res = qemu_strtoul(p, &p, 16, &tmp);
            if (res) {
                goto out;
            }
971

972
            /* 0 means any thread, so we pick the first valid CPU */
973
            cpu = tmp ? find_cpu(tmp) : first_cpu;
974 975

            /* invalid CPU/thread specified */
976
            if (!cpu) {
977 978 979
                res = -EINVAL;
                goto out;
            }
980

981 982 983 984 985 986 987 988 989 990 991 992 993 994 995
            /* only use if no previous match occourred */
            if (newstates[cpu->cpu_index] == 1) {
                newstates[cpu->cpu_index] = cur_action;
            }
        }
    }
    s->signal = signal;
    gdb_continue_partial(s, newstates);

out:
    g_free(newstates);

    return res;
}

996
static int gdb_handle_packet(GDBState *s, const char *line_buf)
bellard's avatar
bellard committed
997
{
998
    CPUState *cpu;
999
    CPUClass *cc;
bellard's avatar
bellard committed
1000
    const char *p;
1001 1002
    uint32_t thread;
    int ch, reg_size, type, res;
1003
    uint8_t mem_buf[MAX_PACKET_LENGTH];
1004
    char buf[sizeof(mem_buf) + 1 /* trailing NUL */];
1005
    uint8_t *registers;
1006
    target_ulong addr, len;
1007

Doug Gale's avatar
Doug Gale committed
1008
    trace_gdbstub_io_command(line_buf);
1009

1010 1011 1012 1013
    p = line_buf;
    ch = *p++;
    switch(ch) {
    case '?':
1014
        /* TODO: Make this return the correct value for user-mode.  */
1015
        snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
1016
                 cpu_gdb_index(s->c_cpu));
1017
        put_packet(s, buf);
1018 1019 1020 1021
        /* Remove all the breakpoints when this query is issued,
         * because gdb is doing and initial connect and the state
         * should be cleaned up.
         */
1022
        gdb_breakpoint_remove_all();
1023 1024 1025
        break;
    case 'c':
        if (*p != '\0') {
1026
            addr = strtoull(p, (char **)&p, 16);
1027
            gdb_set_cpu_pc(s, addr);
1028
        }
1029
        s->signal = 0;
1030
        gdb_continue(s);
Doug Gale's avatar
Doug Gale committed
1031
        return RS_IDLE;
1032
    case 'C':
1033 1034 1035
        s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
        if (s->signal == -1)
            s->signal = 0;
1036 1037
        gdb_continue(s);
        return RS_IDLE;
Jan Kiszka's avatar
Jan Kiszka committed
1038 1039 1040 1041 1042 1043 1044
    case 'v':
        if (strncmp(p, "Cont", 4) == 0) {
            p += 4;
            if (*p == '?') {
                put_packet(s, "vCont;c;C;s;S");
                break;
            }
1045 1046 1047

            res = gdb_handle_vcont(s, p);

Jan Kiszka's avatar
Jan Kiszka committed
1048
            if (res) {
1049 1050 1051
                if ((res == -EINVAL) || (res == -ERANGE)) {
                    put_packet(s, "E22");
                    break;
Jan Kiszka's avatar
Jan Kiszka committed
1052
                }
1053
                goto unknown_command;
Jan Kiszka's avatar
Jan Kiszka committed
1054 1055 1056 1057 1058
            }
            break;
        } else {
            goto unknown_command;
        }
1059 1060
    case 'k':
        /* Kill the target */
1061
        error_report("QEMU: Terminated via GDBstub");
1062 1063 1064
        exit(0);
    case 'D':
        /* Detach packet */
1065
        gdb_breakpoint_remove_all();
Daniel Gutson's avatar
Daniel Gutson committed
1066
        gdb_syscall_mode = GDB_SYS_DISABLED;
1067 1068 1069
        gdb_continue(s);
        put_packet(s, "OK");
        break;
1070 1071
    case 's':
        if (*p != '\0') {
1072
            addr = strtoull(p, (char **)&p, 16);
1073
            gdb_set_cpu_pc(s, addr);
1074
        }
1075
        cpu_single_step(s->c_cpu, sstep_flags);
1076
        gdb_continue(s);
Doug Gale's avatar
Doug Gale committed
1077
        return RS_IDLE;
pbrook's avatar
pbrook committed
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
    case 'F':
        {
            target_ulong ret;
            target_ulong err;

            ret = strtoull(p, (char **)&p, 16);
            if (*p == ',') {
                p++;
                err = strtoull(p, (char **)&p, 16);
            } else {
                err = 0;
            }
            if (*p == ',')
                p++;
            type = *p;
1093
            if (s->current_syscall_cb) {
1094
                s->current_syscall_cb(s->c_cpu, ret, err);
1095 1096
                s->current_syscall_cb = NULL;
            }
pbrook's avatar
pbrook committed
1097 1098 1099
            if (type == 'C') {
                put_packet(s, "T02");
            } else {
1100
                gdb_continue(s);
pbrook's avatar
pbrook committed
1101 1102 1103
            }
        }
        break;
1104
    case 'g':
1105
        cpu_synchronize_state(s->g_cpu);
1106
        len = 0;
1107
        for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
1108
            reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
1109 1110 1111
            len += reg_size;
        }
        memtohex(buf, mem_buf, len);
1112 1113 1114
        put_packet(s, buf);
        break;
    case 'G':
1115
        cpu_synchronize_state(s->g_cpu);
1116
        registers = mem_buf;
1117 1118
        len = strlen(p) / 2;
        hextomem((uint8_t *)registers, p, len);
1119
        for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
1120
            reg_size = gdb_write_register(s->g_cpu, registers, addr);
1121 1122 1123
            len -= reg_size;
            registers += reg_size;
        }
1124 1125 1126
        put_packet(s, "OK");
        break;
    case 'm':
1127
        addr = strtoull(p, (char **)&p, 16);
1128 1129
        if (*p == ',')
            p++;
1130
        len = strtoull(p, NULL, 16);
1131 1132 1133 1134 1135 1136 1137

        /* memtohex() doubles the required space */
        if (len > MAX_PACKET_LENGTH / 2) {
            put_packet (s, "E22");
            break;
        }

1138
        if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
1139 1140 1141 1142 1143
            put_packet (s, "E14");
        } else {
            memtohex(buf, mem_buf, len);
            put_packet(s, buf);
        }
1144 1145
        break;
    case 'M':
1146
        addr = strtoull(p, (char **)&p, 16);
1147 1148
        if (*p == ',')
            p++;
1149
        len = strtoull(p, (char **)&p, 16);
1150
        if (*p == ':')
1151
            p++;
1152 1153 1154 1155 1156 1157

        /* hextomem() reads 2*len bytes */
        if (len > strlen(p) / 2) {
            put_packet (s, "E22");
            break;
        }
1158
        hextomem(mem_buf, p, len);
1159
        if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
1160
                                   true) != 0) {
1161
            put_packet(s, "E14");
1162
        } else {
1163
            put_packet(s, "OK");
1164
        }
1165
        break;
1166 1167 1168 1169 1170 1171 1172
    case 'p':
        /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
           This works, but can be very slow.  Anything new enough to
           understand XML also knows how to use this properly.  */
        if (!gdb_has_xml)
            goto unknown_command;
        addr = strtoull(p, (char **)&p, 16);
1173
        reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
        if (reg_size) {
            memtohex(buf, mem_buf, reg_size);
            put_packet(s, buf);
        } else {
            put_packet(s, "E14");
        }
        break;
    case 'P':
        if (!gdb_has_xml)
            goto unknown_command;
        addr = strtoull(p, (char **)&p, 16);
        if (*p == '=')
            p++;
        reg_size = strlen(p) / 2;
        hextomem(mem_buf, p, reg_size);
1189
        gdb_write_register(s->g_cpu, mem_buf, addr);
1190 1191
        put_packet(s, "OK");
        break;
1192 1193 1194 1195 1196
    case 'Z':
    case 'z':
        type = strtoul(p, (char **)&p, 16);
        if (*p == ',')
            p++;
1197
        addr = strtoull(p, (char **)&p, 16);
1198 1199
        if (*p == ',')
            p++;
1200
        len = strtoull(p, (char **)&p, 16);
1201
        if (ch == 'Z')
1202
            res = gdb_breakpoint_insert(addr, len, type);
1203
        else
1204
            res = gdb_breakpoint_remove(addr, len, type);
1205 1206 1207
        if (res >= 0)
             put_packet(s, "OK");
        else if (res == -ENOSYS)
pbrook's avatar
pbrook committed
1208
            put_packet(s, "");
1209 1210
        else
            put_packet(s, "E22");
1211
        break;
1212 1213 1214 1215 1216 1217 1218
    case 'H':
        type = *p++;
        thread = strtoull(p, (char **)&p, 16);
        if (thread == -1 || thread == 0) {
            put_packet(s, "OK");
            break;
        }
1219 1220
        cpu = find_cpu(thread);
        if (cpu == NULL) {
1221 1222 1223 1224 1225
            put_packet(s, "E22");
            break;
        }
        switch (type) {
        case 'c':
1226
            s->c_cpu = cpu;
1227 1228 1229
            put_packet(s, "OK");
            break;
        case 'g':
1230
            s->g_cpu = cpu;
1231 1232 1233 1234 1235 1236 1237 1238 1239
            put_packet(s, "OK");
            break;
        default:
             put_packet(s, "E22");
             break;
        }
        break;
    case 'T':
        thread = strtoull(p, (char **)&p, 16);
1240
        cpu = find_cpu(thread);
1241

1242
        if (cpu != NULL) {
1243 1244
            put_packet(s, "OK");
        } else {
1245
            put_packet(s, "E22");
1246
        }
1247
        break;
1248
    case 'q':
1249 1250 1251 1252
    case 'Q':
        /* parse any 'q' packets here */
        if (!strcmp(p,"qemu.sstepbits")) {
            /* Query Breakpoint bit definitions */
blueswir1's avatar
blueswir1 committed
1253 1254 1255 1256
            snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
                     SSTEP_ENABLE,
                     SSTEP_NOIRQ,
                     SSTEP_NOTIMER);
1257 1258
            put_packet(s, buf);
            break;
1259
        } else if (is_query_packet(p, "qemu.sstep", '=')) {
1260 1261 1262 1263
            /* Display or change the sstep_flags */
            p += 10;
            if (*p != '=') {
                /* Display current setting */
blueswir1's avatar
blueswir1 committed
1264
                snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1265 1266 1267 1268 1269 1270 1271 1272
                put_packet(s, buf);
                break;
            }
            p++;
            type = strtoul(p, (char **)&p, 16);
            sstep_flags = type;
            put_packet(s, "OK");
            break;
1273 1274 1275 1276 1277 1278
        } else if (strcmp(p,"C") == 0) {
            /* "Current thread" remains vague in the spec, so always return
             *  the first CPU (gdb returns the first thread). */
            put_packet(s, "QC1");
            break;
        } else if (strcmp(p,"fThreadInfo") == 0) {
1279
            s->query_cpu = first_cpu;
1280 1281 1282 1283
            goto report_cpuinfo;
        } else if (strcmp(p,"sThreadInfo") == 0) {
        report_cpuinfo:
            if (s->query_cpu) {
1284
                snprintf(buf, sizeof(buf), "m%x", cpu_gdb_index(s->query_cpu));
1285
                put_packet(s, buf);
1286
                s->query_cpu = CPU_NEXT(s->query_cpu);
1287 1288 1289 1290 1291
            } else
                put_packet(s, "l");
            break;
        } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
            thread = strtoull(p+16, (char **)&p, 16);
1292 1293
            cpu = find_cpu(thread);
            if (cpu != NULL) {
1294
                cpu_synchronize_state(cpu);
1295 1296
                /* memtohex() doubles the required space */
                len = snprintf((char *)mem_buf, sizeof(buf) / 2,
1297
                               "CPU#%d [%s]", cpu->cpu_index,
1298
                               cpu->halted ? "halted " : "running");
Doug Gale's avatar
Doug Gale committed
1299
                trace_gdbstub_op_extra_info((char *)mem_buf);
1300 1301 1302
                memtohex(buf, mem_buf, len);
                put_packet(s, buf);
            }
1303
            break;
1304
        }
blueswir1's avatar
blueswir1 committed
1305
#ifdef CONFIG_USER_ONLY
1306
        else if (strcmp(p, "Offsets") == 0) {
1307
            TaskState *ts = s->c_cpu->opaque;
1308

blueswir1's avatar
blueswir1 committed
1309 1310 1311 1312 1313 1314
            snprintf(buf, sizeof(buf),
                     "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
                     ";Bss=" TARGET_ABI_FMT_lx,
                     ts->info->code_offset,
                     ts->info->data_offset,
                     ts->info->data_offset);
1315 1316 1317
            put_packet(s, buf);
            break;
        }
blueswir1's avatar
blueswir1 committed
1318
#else /* !CONFIG_USER_ONLY */
1319 1320 1321 1322 1323 1324 1325 1326
        else if (strncmp(p, "Rcmd,", 5) == 0) {
            int len = strlen(p + 5);

            if ((len % 2) != 0) {
                put_packet(s, "E01");
                break;
            }
            len = len / 2;
1327
            hextomem(mem_buf, p + 5, len);
1328
            mem_buf[len++] = 0;
1329
            qemu_chr_be_write(s->mon_chr, mem_buf, len);
1330 1331 1332
            put_packet(s, "OK");
            break;
        }
blueswir1's avatar
blueswir1 committed
1333
#endif /* !CONFIG_USER_ONLY */
1334
        if (is_query_packet(p, "Supported", ':')) {
1335
            snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1336 1337 1338 1339
            cc = CPU_GET_CLASS(first_cpu);
            if (cc->gdb_core_xml_file != NULL) {
                pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
            }
1340 1341 1342 1343 1344 1345 1346
            put_packet(s, buf);
            break;
        }
        if (strncmp(p, "Xfer:features:read:", 19) == 0) {
            const char *xml;
            target_ulong total_len;

1347 1348 1349 1350 1351
            cc = CPU_GET_CLASS(first_cpu);
            if (cc->gdb_core_xml_file == NULL) {
                goto unknown_command;
            }

1352
            gdb_has_xml = true;
1353
            p += 19;
1354
            xml = get_feature_xml(p, &p, cc);
1355
            if (!xml) {
1356
                snprintf(buf, sizeof(buf), "E00");
1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
                put_packet(s, buf);
                break;
            }

            if (*p == ':')
                p++;
            addr = strtoul(p, (char **)&p, 16);
            if (*p == ',')
                p++;
            len = strtoul(p, (char **)&p, 16);

            total_len = strlen(xml);
            if (addr > total_len) {
1370
                snprintf(buf, sizeof(buf), "E00");
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
                put_packet(s, buf);
                break;
            }
            if (len > (MAX_PACKET_LENGTH - 5) / 2)
                len = (MAX_PACKET_LENGTH - 5) / 2;
            if (len < total_len - addr) {
                buf[0] = 'm';
                len = memtox(buf + 1, xml + addr, len);
            } else {
                buf[0] = 'l';
                len = memtox(buf + 1, xml + addr, total_len - addr);
            }
Doug Gale's avatar
Doug Gale committed
1383
            put_packet_binary(s, buf, len + 1, true);
1384 1385
            break;
        }
Jan Kiszka's avatar
Jan Kiszka committed
1386 1387 1388 1389
        if (is_query_packet(p, "Attached", ':')) {
            put_packet(s, GDB_ATTACHED);
            break;
        }
1390 1391