gdbstub.c

   1 /*
   2  * gdb server stub
   3  *
   4  * Copyright (c) 2003-2005 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * 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/>.
  18  */
  19 #include "config.h"
  20 #include "qemu-common.h"
  21 #ifdef CONFIG_USER_ONLY
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29
  30 #include "qemu.h"
  31 #else
  32 #include "monitor/monitor.h"
  33 #include "sysemu/char.h"
  34 #include "sysemu/sysemu.h"
  35 #include "exec/gdbstub.h"
  36 #endif
  37
  38 #define MAX_PACKET_LENGTH 4096
  39
  40 #include "cpu.h"
  41 #include "qemu/sockets.h"
  42 #include "sysemu/kvm.h"
  43
  44 static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
  45                                          uint8_t *buf, int len, bool is_write)
  46 {
  47     CPUClass *cc = CPU_GET_CLASS(cpu);
  48
  49     if (cc->memory_rw_debug) {
  50         return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
  51     }
  52     return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
  53 }
  54
  55 enum {
  56     GDB_SIGNAL_0 = 0,
  57     GDB_SIGNAL_INT = 2,
  58     GDB_SIGNAL_QUIT = 3,
  59     GDB_SIGNAL_TRAP = 5,
  60     GDB_SIGNAL_ABRT = 6,
  61     GDB_SIGNAL_ALRM = 14,
  62     GDB_SIGNAL_IO = 23,
  63     GDB_SIGNAL_XCPU = 24,
  64     GDB_SIGNAL_UNKNOWN = 143
  65 };
  66
  67 #ifdef CONFIG_USER_ONLY
  68
  69 /* Map target signal numbers to GDB protocol signal numbers and vice
  70  * versa.  For user emulation's currently supported systems, we can
  71  * assume most signals are defined.
  72  */
  73
  74 static int gdb_signal_table[] = {
  75     0,
  76     TARGET_SIGHUP,
  77     TARGET_SIGINT,
  78     TARGET_SIGQUIT,
  79     TARGET_SIGILL,
  80     TARGET_SIGTRAP,
  81     TARGET_SIGABRT,
  82     -1, /* SIGEMT */
  83     TARGET_SIGFPE,
  84     TARGET_SIGKILL,
  85     TARGET_SIGBUS,
  86     TARGET_SIGSEGV,
  87     TARGET_SIGSYS,
  88     TARGET_SIGPIPE,
  89     TARGET_SIGALRM,
  90     TARGET_SIGTERM,
  91     TARGET_SIGURG,
  92     TARGET_SIGSTOP,
  93     TARGET_SIGTSTP,
  94     TARGET_SIGCONT,
  95     TARGET_SIGCHLD,
  96     TARGET_SIGTTIN,
  97     TARGET_SIGTTOU,
  98     TARGET_SIGIO,
  99     TARGET_SIGXCPU,
 100     TARGET_SIGXFSZ,
 101     TARGET_SIGVTALRM,
 102     TARGET_SIGPROF,
 103     TARGET_SIGWINCH,
 104     -1, /* SIGLOST */
 105     TARGET_SIGUSR1,
 106     TARGET_SIGUSR2,
 107 #ifdef TARGET_SIGPWR
 108     TARGET_SIGPWR,
 109 #else
 110     -1,
 111 #endif
 112     -1, /* SIGPOLL */
 113     -1,
 114     -1,
 115     -1,
 116     -1,
 117     -1,
 118     -1,
 119     -1,
 120     -1,
 121     -1,
 122     -1,
 123     -1,
 124 #ifdef __SIGRTMIN
 125     __SIGRTMIN + 1,
 126     __SIGRTMIN + 2,
 127     __SIGRTMIN + 3,
 128     __SIGRTMIN + 4,
 129     __SIGRTMIN + 5,
 130     __SIGRTMIN + 6,
 131     __SIGRTMIN + 7,
 132     __SIGRTMIN + 8,
 133     __SIGRTMIN + 9,
 134     __SIGRTMIN + 10,
 135     __SIGRTMIN + 11,
 136     __SIGRTMIN + 12,
 137     __SIGRTMIN + 13,
 138     __SIGRTMIN + 14,
 139     __SIGRTMIN + 15,
 140     __SIGRTMIN + 16,
 141     __SIGRTMIN + 17,
 142     __SIGRTMIN + 18,
 143     __SIGRTMIN + 19,
 144     __SIGRTMIN + 20,
 145     __SIGRTMIN + 21,
 146     __SIGRTMIN + 22,
 147     __SIGRTMIN + 23,
 148     __SIGRTMIN + 24,
 149     __SIGRTMIN + 25,
 150     __SIGRTMIN + 26,
 151     __SIGRTMIN + 27,
 152     __SIGRTMIN + 28,
 153     __SIGRTMIN + 29,
 154     __SIGRTMIN + 30,
 155     __SIGRTMIN + 31,
 156     -1, /* SIGCANCEL */
 157     __SIGRTMIN,
 158     __SIGRTMIN + 32,
 159     __SIGRTMIN + 33,
 160     __SIGRTMIN + 34,
 161     __SIGRTMIN + 35,
 162     __SIGRTMIN + 36,
 163     __SIGRTMIN + 37,
 164     __SIGRTMIN + 38,
 165     __SIGRTMIN + 39,
 166     __SIGRTMIN + 40,
 167     __SIGRTMIN + 41,
 168     __SIGRTMIN + 42,
 169     __SIGRTMIN + 43,
 170     __SIGRTMIN + 44,
 171     __SIGRTMIN + 45,
 172     __SIGRTMIN + 46,
 173     __SIGRTMIN + 47,
 174     __SIGRTMIN + 48,
 175     __SIGRTMIN + 49,
 176     __SIGRTMIN + 50,
 177     __SIGRTMIN + 51,
 178     __SIGRTMIN + 52,
 179     __SIGRTMIN + 53,
 180     __SIGRTMIN + 54,
 181     __SIGRTMIN + 55,
 182     __SIGRTMIN + 56,
 183     __SIGRTMIN + 57,
 184     __SIGRTMIN + 58,
 185     __SIGRTMIN + 59,
 186     __SIGRTMIN + 60,
 187     __SIGRTMIN + 61,
 188     __SIGRTMIN + 62,
 189     __SIGRTMIN + 63,
 190     __SIGRTMIN + 64,
 191     __SIGRTMIN + 65,
 192     __SIGRTMIN + 66,
 193     __SIGRTMIN + 67,
 194     __SIGRTMIN + 68,
 195     __SIGRTMIN + 69,
 196     __SIGRTMIN + 70,
 197     __SIGRTMIN + 71,
 198     __SIGRTMIN + 72,
 199     __SIGRTMIN + 73,
 200     __SIGRTMIN + 74,
 201     __SIGRTMIN + 75,
 202     __SIGRTMIN + 76,
 203     __SIGRTMIN + 77,
 204     __SIGRTMIN + 78,
 205     __SIGRTMIN + 79,
 206     __SIGRTMIN + 80,
 207     __SIGRTMIN + 81,
 208     __SIGRTMIN + 82,
 209     __SIGRTMIN + 83,
 210     __SIGRTMIN + 84,
 211     __SIGRTMIN + 85,
 212     __SIGRTMIN + 86,
 213     __SIGRTMIN + 87,
 214     __SIGRTMIN + 88,
 215     __SIGRTMIN + 89,
 216     __SIGRTMIN + 90,
 217     __SIGRTMIN + 91,
 218     __SIGRTMIN + 92,
 219     __SIGRTMIN + 93,
 220     __SIGRTMIN + 94,
 221     __SIGRTMIN + 95,
 222     -1, /* SIGINFO */
 223     -1, /* UNKNOWN */
 224     -1, /* DEFAULT */
 225     -1,
 226     -1,
 227     -1,
 228     -1,
 229     -1,
 230     -1
 231 #endif
 232 };
 233 #else
 234 /* In system mode we only need SIGINT and SIGTRAP; other signals
 235    are not yet supported.  */
 236
 237 enum {
 238     TARGET_SIGINT = 2,
 239     TARGET_SIGTRAP = 5
 240 };
 241
 242 static int gdb_signal_table[] = {
 243     -1,
 244     -1,
 245     TARGET_SIGINT,
 246     -1,
 247     -1,
 248     TARGET_SIGTRAP
 249 };
 250 #endif
 251
 252 #ifdef CONFIG_USER_ONLY
 253 static int target_signal_to_gdb (int sig)
 254 {
 255     int i;
 256     for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
 257         if (gdb_signal_table[i] == sig)
 258             return i;
 259     return GDB_SIGNAL_UNKNOWN;
 260 }
 261 #endif
 262
 263 static int gdb_signal_to_target (int sig)
 264 {
 265     if (sig < ARRAY_SIZE (gdb_signal_table))
 266         return gdb_signal_table[sig];
 267     else
 268         return -1;
 269 }
 270
 271 //#define DEBUG_GDB
 272
 273 typedef struct GDBRegisterState {
 274     int base_reg;
 275     int num_regs;
 276     gdb_reg_cb get_reg;
 277     gdb_reg_cb set_reg;
 278     const char *xml;
 279     struct GDBRegisterState *next;
 280 } GDBRegisterState;
 281
 282 enum RSState {
 283     RS_INACTIVE,
 284     RS_IDLE,
 285     RS_GETLINE,
 286     RS_CHKSUM1,
 287     RS_CHKSUM2,
 288 };
 289 typedef struct GDBState {
 290     CPUState *c_cpu; /* current CPU for step/continue ops */
 291     CPUState *g_cpu; /* current CPU for other ops */
 292     CPUState *query_cpu; /* for q{f|s}ThreadInfo */
 293     enum RSState state; /* parsing state */
 294     char line_buf[MAX_PACKET_LENGTH];
 295     int line_buf_index;
 296     int line_csum;
 297     uint8_t last_packet[MAX_PACKET_LENGTH + 4];
 298     int last_packet_len;
 299     int signal;
 300 #ifdef CONFIG_USER_ONLY
 301     int fd;
 302     int running_state;
 303 #else
 304     CharDriverState *chr;
 305     CharDriverState *mon_chr;
 306 #endif
 307     char syscall_buf[256];
 308     gdb_syscall_complete_cb current_syscall_cb;
 309 } GDBState;
 310
 311 /* By default use no IRQs and no timers while single stepping so as to
 312  * make single stepping like an ICE HW step.
 313  */
 314 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
 315
 316 static GDBState *gdbserver_state;
 317
 318 bool gdb_has_xml;
 319
 320 #ifdef CONFIG_USER_ONLY
 321 /* XXX: This is not thread safe.  Do we care?  */
 322 static int gdbserver_fd = -1;
 323
 324 static int get_char(GDBState *s)
 325 {
 326     uint8_t ch;
 327     int ret;
 328
 329     for(;;) {
 330         ret = qemu_recv(s->fd, &ch, 1, 0);
 331         if (ret < 0) {
 332             if (errno == ECONNRESET)
 333                 s->fd = -1;
 334             if (errno != EINTR && errno != EAGAIN)
 335                 return -1;
 336         } else if (ret == 0) {
 337             close(s->fd);
 338             s->fd = -1;
 339             return -1;
 340         } else {
 341             break;
 342         }
 343     }
 344     return ch;
 345 }
 346 #endif
 347
 348 static enum {
 349     GDB_SYS_UNKNOWN,
 350     GDB_SYS_ENABLED,
 351     GDB_SYS_DISABLED,
 352 } gdb_syscall_mode;
 353
 354 /* If gdb is connected when the first semihosting syscall occurs then use
 355    remote gdb syscalls.  Otherwise use native file IO.  */
 356 int use_gdb_syscalls(void)
 357 {
 358     if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
 359         gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
 360                                             : GDB_SYS_DISABLED);
 361     }
 362     return gdb_syscall_mode == GDB_SYS_ENABLED;
 363 }
 364
 365 /* Resume execution.  */
 366 static inline void gdb_continue(GDBState *s)
 367 {
 368 #ifdef CONFIG_USER_ONLY
 369     s->running_state = 1;
 370 #else
 371     if (!runstate_needs_reset()) {
 372         vm_start();
 373     }
 374 #endif
 375 }
 376
 377 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
 378 {
 379 #ifdef CONFIG_USER_ONLY
 380     int ret;
 381
 382     while (len > 0) {
 383         ret = send(s->fd, buf, len, 0);
 384         if (ret < 0) {
 385             if (errno != EINTR && errno != EAGAIN)
 386                 return;
 387         } else {
 388             buf += ret;
 389             len -= ret;
 390         }
 391     }
 392 #else
 393     qemu_chr_fe_write(s->chr, buf, len);
 394 #endif
 395 }
 396
 397 static inline int fromhex(int v)
 398 {
 399     if (v >= '0' && v <= '9')
 400         return v - '0';
 401     else if (v >= 'A' && v <= 'F')
 402         return v - 'A' + 10;
 403     else if (v >= 'a' && v <= 'f')
 404         return v - 'a' + 10;
 405     else
 406         return 0;
 407 }
 408
 409 static inline int tohex(int v)
 410 {
 411     if (v < 10)
 412         return v + '0';
 413     else
 414         return v - 10 + 'a';
 415 }
 416
 417 static void memtohex(char *buf, const uint8_t *mem, int len)
 418 {
 419     int i, c;
 420     char *q;
 421     q = buf;
 422     for(i = 0; i < len; i++) {
 423         c = mem[i];
 424         *q++ = tohex(c >> 4);
 425         *q++ = tohex(c & 0xf);
 426     }
 427     *q = '\0';
 428 }
 429
 430 static void hextomem(uint8_t *mem, const char *buf, int len)
 431 {
 432     int i;
 433
 434     for(i = 0; i < len; i++) {
 435         mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
 436         buf += 2;
 437     }
 438 }
 439
 440 /* return -1 if error, 0 if OK */
 441 static int put_packet_binary(GDBState *s, const char *buf, int len)
 442 {
 443     int csum, i;
 444     uint8_t *p;
 445
 446     for(;;) {
 447         p = s->last_packet;
 448         *(p++) = '$';
 449         memcpy(p, buf, len);
 450         p += len;
 451         csum = 0;
 452         for(i = 0; i < len; i++) {
 453             csum += buf[i];
 454         }
 455         *(p++) = '#';
 456         *(p++) = tohex((csum >> 4) & 0xf);
 457         *(p++) = tohex((csum) & 0xf);
 458
 459         s->last_packet_len = p - s->last_packet;
 460         put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
 461
 462 #ifdef CONFIG_USER_ONLY
 463         i = get_char(s);
 464         if (i < 0)
 465             return -1;
 466         if (i == '+')
 467             break;
 468 #else
 469         break;
 470 #endif
 471     }
 472     return 0;
 473 }
 474
 475 /* return -1 if error, 0 if OK */
 476 static int put_packet(GDBState *s, const char *buf)
 477 {
 478 #ifdef DEBUG_GDB
 479     printf("reply='%s'\n", buf);
 480 #endif
 481
 482     return put_packet_binary(s, buf, strlen(buf));
 483 }
 484
 485 /* Encode data using the encoding for 'x' packets.  */
 486 static int memtox(char *buf, const char *mem, int len)
 487 {
 488     char *p = buf;
 489     char c;
 490
 491     while (len--) {
 492         c = *(mem++);
 493         switch (c) {
 494         case '#': case '$': case '*': case '}':
 495             *(p++) = '}';
 496             *(p++) = c ^ 0x20;
 497             break;
 498         default:
 499             *(p++) = c;
 500             break;
 501         }
 502     }
 503     return p - buf;
 504 }
 505
 506 static const char *get_feature_xml(const char *p, const char **newp,
 507                                    CPUClass *cc)
 508 {
 509     size_t len;
 510     int i;
 511     const char *name;
 512     static char target_xml[1024];
 513
 514     len = 0;
 515     while (p[len] && p[len] != ':')
 516         len++;
 517     *newp = p + len;
 518
 519     name = NULL;
 520     if (strncmp(p, "target.xml", len) == 0) {
 521         /* Generate the XML description for this CPU.  */
 522         if (!target_xml[0]) {
 523             GDBRegisterState *r;
 524             CPUState *cpu = first_cpu;
 525
 526             snprintf(target_xml, sizeof(target_xml),
 527                      "<?xml version=\"1.0\"?>"
 528                      "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
 529                      "<target>"
 530                      "<xi:include href=\"%s\"/>",
 531                      cc->gdb_core_xml_file);
 532
 533             for (r = cpu->gdb_regs; r; r = r->next) {
 534                 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
 535                 pstrcat(target_xml, sizeof(target_xml), r->xml);
 536                 pstrcat(target_xml, sizeof(target_xml), "\"/>");
 537             }
 538             pstrcat(target_xml, sizeof(target_xml), "</target>");
 539         }
 540         return target_xml;
 541     }
 542     for (i = 0; ; i++) {
 543         name = xml_builtin[i][0];
 544         if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
 545             break;
 546     }
 547     return name ? xml_builtin[i][1] : NULL;
 548 }
 549
 550 static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
 551 {
 552     CPUClass *cc = CPU_GET_CLASS(cpu);
 553     CPUArchState *env = cpu->env_ptr;
 554     GDBRegisterState *r;
 555
 556     if (reg < cc->gdb_num_core_regs) {
 557         return cc->gdb_read_register(cpu, mem_buf, reg);
 558     }
 559
 560     for (r = cpu->gdb_regs; r; r = r->next) {
 561         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
 562             return r->get_reg(env, mem_buf, reg - r->base_reg);
 563         }
 564     }
 565     return 0;
 566 }
 567
 568 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
 569 {
 570     CPUClass *cc = CPU_GET_CLASS(cpu);
 571     CPUArchState *env = cpu->env_ptr;
 572     GDBRegisterState *r;
 573
 574     if (reg < cc->gdb_num_core_regs) {
 575         return cc->gdb_write_register(cpu, mem_buf, reg);
 576     }
 577
 578     for (r = cpu->gdb_regs; r; r = r->next) {
 579         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
 580             return r->set_reg(env, mem_buf, reg - r->base_reg);
 581         }
 582     }
 583     return 0;
 584 }
 585
 586 /* Register a supplemental set of CPU registers.  If g_pos is nonzero it
 587    specifies the first register number and these registers are included in
 588    a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is
 589    gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
 590  */
 591
 592 void gdb_register_coprocessor(CPUState *cpu,
 593                               gdb_reg_cb get_reg, gdb_reg_cb set_reg,
 594                               int num_regs, const char *xml, int g_pos)
 595 {
 596     GDBRegisterState *s;
 597     GDBRegisterState **p;
 598
 599     p = &cpu->gdb_regs;
 600     while (*p) {
 601         /* Check for duplicates.  */
 602         if (strcmp((*p)->xml, xml) == 0)
 603             return;
 604         p = &(*p)->next;
 605     }
 606
 607     s = g_new0(GDBRegisterState, 1);
 608     s->base_reg = cpu->gdb_num_regs;
 609     s->num_regs = num_regs;
 610     s->get_reg = get_reg;
 611     s->set_reg = set_reg;
 612     s->xml = xml;
 613
 614     /* Add to end of list.  */
 615     cpu->gdb_num_regs += num_regs;
 616     *p = s;
 617     if (g_pos) {
 618         if (g_pos != s->base_reg) {
 619             fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
 620                     "Expected %d got %d\n", xml, g_pos, s->base_reg);
 621         } else {
 622             cpu->gdb_num_g_regs = cpu->gdb_num_regs;
 623         }
 624     }
 625 }
 626
 627 #ifndef CONFIG_USER_ONLY
 628 static const int xlat_gdb_type[] = {
 629     [GDB_WATCHPOINT_WRITE]  = BP_GDB | BP_MEM_WRITE,
 630     [GDB_WATCHPOINT_READ]   = BP_GDB | BP_MEM_READ,
 631     [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
 632 };
 633 #endif
 634
 635 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
 636 {
 637     CPUState *cpu;
 638     int err = 0;
 639
 640     if (kvm_enabled()) {
 641         return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
 642     }
 643
 644     switch (type) {
 645     case GDB_BREAKPOINT_SW:
 646     case GDB_BREAKPOINT_HW:
 647         CPU_FOREACH(cpu) {
 648             err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
 649             if (err) {
 650                 break;
 651             }
 652         }
 653         return err;
 654 #ifndef CONFIG_USER_ONLY
 655     case GDB_WATCHPOINT_WRITE:
 656     case GDB_WATCHPOINT_READ:
 657     case GDB_WATCHPOINT_ACCESS:
 658         CPU_FOREACH(cpu) {
 659             err = cpu_watchpoint_insert(cpu, addr, len, xlat_gdb_type[type],
 660                                         NULL);
 661             if (err)
 662                 break;
 663         }
 664         return err;
 665 #endif
 666     default:
 667         return -ENOSYS;
 668     }
 669 }
 670
 671 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
 672 {
 673     CPUState *cpu;
 674     int err = 0;
 675
 676     if (kvm_enabled()) {
 677         return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
 678     }
 679
 680     switch (type) {
 681     case GDB_BREAKPOINT_SW:
 682     case GDB_BREAKPOINT_HW:
 683         CPU_FOREACH(cpu) {
 684             err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
 685             if (err) {
 686                 break;
 687             }
 688         }
 689         return err;
 690 #ifndef CONFIG_USER_ONLY
 691     case GDB_WATCHPOINT_WRITE:
 692     case GDB_WATCHPOINT_READ:
 693     case GDB_WATCHPOINT_ACCESS:
 694         CPU_FOREACH(cpu) {
 695             err = cpu_watchpoint_remove(cpu, addr, len, xlat_gdb_type[type]);
 696             if (err)
 697                 break;
 698         }
 699         return err;
 700 #endif
 701     default:
 702         return -ENOSYS;
 703     }
 704 }
 705
 706 static void gdb_breakpoint_remove_all(void)
 707 {
 708     CPUState *cpu;
 709
 710     if (kvm_enabled()) {
 711         kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
 712         return;
 713     }
 714
 715     CPU_FOREACH(cpu) {
 716         cpu_breakpoint_remove_all(cpu, BP_GDB);
 717 #ifndef CONFIG_USER_ONLY
 718         cpu_watchpoint_remove_all(cpu, BP_GDB);
 719 #endif
 720     }
 721 }
 722
 723 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
 724 {
 725     CPUState *cpu = s->c_cpu;
 726     CPUClass *cc = CPU_GET_CLASS(cpu);
 727
 728     cpu_synchronize_state(cpu);
 729     if (cc->set_pc) {
 730         cc->set_pc(cpu, pc);
 731     }
 732 }
 733
 734 static CPUState *find_cpu(uint32_t thread_id)
 735 {
 736     CPUState *cpu;
 737
 738     CPU_FOREACH(cpu) {
 739         if (cpu_index(cpu) == thread_id) {
 740             return cpu;
 741         }
 742     }
 743
 744     return NULL;
 745 }
 746
 747 static int gdb_handle_packet(GDBState *s, const char *line_buf)
 748 {
 749     CPUState *cpu;
 750     CPUClass *cc;
 751     const char *p;
 752     uint32_t thread;
 753     int ch, reg_size, type, res;
 754     char buf[MAX_PACKET_LENGTH];
 755     uint8_t mem_buf[MAX_PACKET_LENGTH];
 756     uint8_t *registers;
 757     target_ulong addr, len;
 758
 759 #ifdef DEBUG_GDB
 760     printf("command='%s'\n", line_buf);
 761 #endif
 762     p = line_buf;
 763     ch = *p++;
 764     switch(ch) {
 765     case '?':
 766         /* TODO: Make this return the correct value for user-mode.  */
 767         snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
 768                  cpu_index(s->c_cpu));
 769         put_packet(s, buf);
 770         /* Remove all the breakpoints when this query is issued,
 771          * because gdb is doing and initial connect and the state
 772          * should be cleaned up.
 773          */
 774         gdb_breakpoint_remove_all();
 775         break;
 776     case 'c':
 777         if (*p != '\0') {
 778             addr = strtoull(p, (char **)&p, 16);
 779             gdb_set_cpu_pc(s, addr);
 780         }
 781         s->signal = 0;
 782         gdb_continue(s);
 783         return RS_IDLE;
 784     case 'C':
 785         s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
 786         if (s->signal == -1)
 787             s->signal = 0;
 788         gdb_continue(s);
 789         return RS_IDLE;
 790     case 'v':
 791         if (strncmp(p, "Cont", 4) == 0) {
 792             int res_signal, res_thread;
 793
 794             p += 4;
 795             if (*p == '?') {
 796                 put_packet(s, "vCont;c;C;s;S");
 797                 break;
 798             }
 799             res = 0;
 800             res_signal = 0;
 801             res_thread = 0;
 802             while (*p) {
 803                 int action, signal;
 804
 805                 if (*p++ != ';') {
 806                     res = 0;
 807                     break;
 808                 }
 809                 action = *p++;
 810                 signal = 0;
 811                 if (action == 'C' || action == 'S') {
 812                     signal = strtoul(p, (char **)&p, 16);
 813                 } else if (action != 'c' && action != 's') {
 814                     res = 0;
 815                     break;
 816                 }
 817                 thread = 0;
 818                 if (*p == ':') {
 819                     thread = strtoull(p+1, (char **)&p, 16);
 820                 }
 821                 action = tolower(action);
 822                 if (res == 0 || (res == 'c' && action == 's')) {
 823                     res = action;
 824                     res_signal = signal;
 825                     res_thread = thread;
 826                 }
 827             }
 828             if (res) {
 829                 if (res_thread != -1 && res_thread != 0) {
 830                     cpu = find_cpu(res_thread);
 831                     if (cpu == NULL) {
 832                         put_packet(s, "E22");
 833                         break;
 834                     }
 835                     s->c_cpu = cpu;
 836                 }
 837                 if (res == 's') {
 838                     cpu_single_step(s->c_cpu, sstep_flags);
 839                 }
 840                 s->signal = res_signal;
 841                 gdb_continue(s);
 842                 return RS_IDLE;
 843             }
 844             break;
 845         } else {
 846             goto unknown_command;
 847         }
 848     case 'k':
 849 #ifdef CONFIG_USER_ONLY
 850         /* Kill the target */
 851         fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
 852         exit(0);
 853 #endif
 854     case 'D':
 855         /* Detach packet */
 856         gdb_breakpoint_remove_all();
 857         gdb_syscall_mode = GDB_SYS_DISABLED;
 858         gdb_continue(s);
 859         put_packet(s, "OK");
 860         break;
 861     case 's':
 862         if (*p != '\0') {
 863             addr = strtoull(p, (char **)&p, 16);
 864             gdb_set_cpu_pc(s, addr);
 865         }
 866         cpu_single_step(s->c_cpu, sstep_flags);
 867         gdb_continue(s);
 868         return RS_IDLE;
 869     case 'F':
 870         {
 871             target_ulong ret;
 872             target_ulong err;
 873
 874             ret = strtoull(p, (char **)&p, 16);
 875             if (*p == ',') {
 876                 p++;
 877                 err = strtoull(p, (char **)&p, 16);
 878             } else {
 879                 err = 0;
 880             }
 881             if (*p == ',')
 882                 p++;
 883             type = *p;
 884             if (s->current_syscall_cb) {
 885                 s->current_syscall_cb(s->c_cpu, ret, err);
 886                 s->current_syscall_cb = NULL;
 887             }
 888             if (type == 'C') {
 889                 put_packet(s, "T02");
 890             } else {
 891                 gdb_continue(s);
 892             }
 893         }
 894         break;
 895     case 'g':
 896         cpu_synchronize_state(s->g_cpu);
 897         len = 0;
 898         for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
 899             reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
 900             len += reg_size;
 901         }
 902         memtohex(buf, mem_buf, len);
 903         put_packet(s, buf);
 904         break;
 905     case 'G':
 906         cpu_synchronize_state(s->g_cpu);
 907         registers = mem_buf;
 908         len = strlen(p) / 2;
 909         hextomem((uint8_t *)registers, p, len);
 910         for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
 911             reg_size = gdb_write_register(s->g_cpu, registers, addr);
 912             len -= reg_size;
 913             registers += reg_size;
 914         }
 915         put_packet(s, "OK");
 916         break;
 917     case 'm':
 918         addr = strtoull(p, (char **)&p, 16);
 919         if (*p == ',')
 920             p++;
 921         len = strtoull(p, NULL, 16);
 922         if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
 923             put_packet (s, "E14");
 924         } else {
 925             memtohex(buf, mem_buf, len);
 926             put_packet(s, buf);
 927         }
 928         break;
 929     case 'M':
 930         addr = strtoull(p, (char **)&p, 16);
 931         if (*p == ',')
 932             p++;
 933         len = strtoull(p, (char **)&p, 16);
 934         if (*p == ':')
 935             p++;
 936         hextomem(mem_buf, p, len);
 937         if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
 938                                    true) != 0) {
 939             put_packet(s, "E14");
 940         } else {
 941             put_packet(s, "OK");
 942         }
 943         break;
 944     case 'p':
 945         /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
 946            This works, but can be very slow.  Anything new enough to
 947            understand XML also knows how to use this properly.  */
 948         if (!gdb_has_xml)
 949             goto unknown_command;
 950         addr = strtoull(p, (char **)&p, 16);
 951         reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
 952         if (reg_size) {
 953             memtohex(buf, mem_buf, reg_size);
 954             put_packet(s, buf);
 955         } else {
 956             put_packet(s, "E14");
 957         }
 958         break;
 959     case 'P':
 960         if (!gdb_has_xml)
 961             goto unknown_command;
 962         addr = strtoull(p, (char **)&p, 16);
 963         if (*p == '=')
 964             p++;
 965         reg_size = strlen(p) / 2;
 966         hextomem(mem_buf, p, reg_size);
 967         gdb_write_register(s->g_cpu, mem_buf, addr);
 968         put_packet(s, "OK");
 969         break;
 970     case 'Z':
 971     case 'z':
 972         type = strtoul(p, (char **)&p, 16);
 973         if (*p == ',')
 974             p++;
 975         addr = strtoull(p, (char **)&p, 16);
 976         if (*p == ',')
 977             p++;
 978         len = strtoull(p, (char **)&p, 16);
 979         if (ch == 'Z')
 980             res = gdb_breakpoint_insert(addr, len, type);
 981         else
 982             res = gdb_breakpoint_remove(addr, len, type);
 983         if (res >= 0)
 984              put_packet(s, "OK");
 985         else if (res == -ENOSYS)
 986             put_packet(s, "");
 987         else
 988             put_packet(s, "E22");
 989         break;
 990     case 'H':
 991         type = *p++;
 992         thread = strtoull(p, (char **)&p, 16);
 993         if (thread == -1 || thread == 0) {
 994             put_packet(s, "OK");
 995             break;
 996         }
 997         cpu = find_cpu(thread);
 998         if (cpu == NULL) {
 999             put_packet(s, "E22");
1000             break;
1001         }
1002         switch (type) {
1003         case 'c':
1004             s->c_cpu = cpu;
1005             put_packet(s, "OK");
1006             break;
1007         case 'g':
1008             s->g_cpu = cpu;
1009             put_packet(s, "OK");
1010             break;
1011         default:
1012              put_packet(s, "E22");
1013              break;
1014         }
1015         break;
1016     case 'T':
1017         thread = strtoull(p, (char **)&p, 16);
1018         cpu = find_cpu(thread);
1019
1020         if (cpu != NULL) {
1021             put_packet(s, "OK");
1022         } else {
1023             put_packet(s, "E22");
1024         }
1025         break;
1026     case 'q':
1027     case 'Q':
1028         /* parse any 'q' packets here */
1029         if (!strcmp(p,"qemu.sstepbits")) {
1030             /* Query Breakpoint bit definitions */
1031             snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1032                      SSTEP_ENABLE,
1033                      SSTEP_NOIRQ,
1034                      SSTEP_NOTIMER);
1035             put_packet(s, buf);
1036             break;
1037         } else if (strncmp(p,"qemu.sstep",10) == 0) {
1038             /* Display or change the sstep_flags */
1039             p += 10;
1040             if (*p != '=') {
1041                 /* Display current setting */
1042                 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1043                 put_packet(s, buf);
1044                 break;
1045             }
1046             p++;
1047             type = strtoul(p, (char **)&p, 16);
1048             sstep_flags = type;
1049             put_packet(s, "OK");
1050             break;
1051         } else if (strcmp(p,"C") == 0) {
1052             /* "Current thread" remains vague in the spec, so always return
1053              *  the first CPU (gdb returns the first thread). */
1054             put_packet(s, "QC1");
1055             break;
1056         } else if (strcmp(p,"fThreadInfo") == 0) {
1057             s->query_cpu = first_cpu;
1058             goto report_cpuinfo;
1059         } else if (strcmp(p,"sThreadInfo") == 0) {
1060         report_cpuinfo:
1061             if (s->query_cpu) {
1062                 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
1063                 put_packet(s, buf);
1064                 s->query_cpu = CPU_NEXT(s->query_cpu);
1065             } else
1066                 put_packet(s, "l");
1067             break;
1068         } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1069             thread = strtoull(p+16, (char **)&p, 16);
1070             cpu = find_cpu(thread);
1071             if (cpu != NULL) {
1072                 cpu_synchronize_state(cpu);
1073                 len = snprintf((char *)mem_buf, sizeof(mem_buf),
1074                                "CPU#%d [%s]", cpu->cpu_index,
1075                                cpu->halted ? "halted " : "running");
1076                 memtohex(buf, mem_buf, len);
1077                 put_packet(s, buf);
1078             }
1079             break;
1080         }
1081 #ifdef CONFIG_USER_ONLY
1082         else if (strncmp(p, "Offsets", 7) == 0) {
1083             TaskState *ts = s->c_cpu->opaque;
1084
1085             snprintf(buf, sizeof(buf),
1086                      "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1087                      ";Bss=" TARGET_ABI_FMT_lx,
1088                      ts->info->code_offset,
1089                      ts->info->data_offset,
1090                      ts->info->data_offset);
1091             put_packet(s, buf);
1092             break;
1093         }
1094 #else /* !CONFIG_USER_ONLY */
1095         else if (strncmp(p, "Rcmd,", 5) == 0) {
1096             int len = strlen(p + 5);
1097
1098             if ((len % 2) != 0) {
1099                 put_packet(s, "E01");
1100                 break;
1101             }
1102             hextomem(mem_buf, p + 5, len);
1103             len = len / 2;
1104             mem_buf[len++] = 0;
1105             qemu_chr_be_write(s->mon_chr, mem_buf, len);
1106             put_packet(s, "OK");
1107             break;
1108         }
1109 #endif /* !CONFIG_USER_ONLY */
1110         if (strncmp(p, "Supported", 9) == 0) {
1111             snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1112             cc = CPU_GET_CLASS(first_cpu);
1113             if (cc->gdb_core_xml_file != NULL) {
1114                 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1115             }
1116             put_packet(s, buf);
1117             break;
1118         }
1119         if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1120             const char *xml;
1121             target_ulong total_len;
1122
1123             cc = CPU_GET_CLASS(first_cpu);
1124             if (cc->gdb_core_xml_file == NULL) {
1125                 goto unknown_command;
1126             }
1127
1128             gdb_has_xml = true;
1129             p += 19;
1130             xml = get_feature_xml(p, &p, cc);
1131             if (!xml) {
1132                 snprintf(buf, sizeof(buf), "E00");
1133                 put_packet(s, buf);
1134                 break;
1135             }
1136
1137             if (*p == ':')
1138                 p++;
1139             addr = strtoul(p, (char **)&p, 16);
1140             if (*p == ',')
1141                 p++;
1142             len = strtoul(p, (char **)&p, 16);
1143
1144             total_len = strlen(xml);
1145             if (addr > total_len) {
1146                 snprintf(buf, sizeof(buf), "E00");
1147                 put_packet(s, buf);
1148                 break;
1149             }
1150             if (len > (MAX_PACKET_LENGTH - 5) / 2)
1151                 len = (MAX_PACKET_LENGTH - 5) / 2;
1152             if (len < total_len - addr) {
1153                 buf[0] = 'm';
1154                 len = memtox(buf + 1, xml + addr, len);
1155             } else {
1156                 buf[0] = 'l';
1157                 len = memtox(buf + 1, xml + addr, total_len - addr);
1158             }
1159             put_packet_binary(s, buf, len + 1);
1160             break;
1161         }
1162         /* Unrecognised 'q' command.  */
1163         goto unknown_command;
1164
1165     default:
1166     unknown_command:
1167         /* put empty packet */
1168         buf[0] = '\0';
1169         put_packet(s, buf);
1170         break;
1171     }
1172     return RS_IDLE;
1173 }
1174
1175 void gdb_set_stop_cpu(CPUState *cpu)
1176 {
1177     gdbserver_state->c_cpu = cpu;
1178     gdbserver_state->g_cpu = cpu;
1179 }
1180
1181 #ifndef CONFIG_USER_ONLY
1182 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1183 {
1184     GDBState *s = gdbserver_state;
1185     CPUArchState *env = s->c_cpu->env_ptr;
1186     CPUState *cpu = s->c_cpu;
1187     char buf[256];
1188     const char *type;
1189     int ret;
1190
1191     if (running || s->state == RS_INACTIVE) {
1192         return;
1193     }
1194     /* Is there a GDB syscall waiting to be sent?  */
1195     if (s->current_syscall_cb) {
1196         put_packet(s, s->syscall_buf);
1197         return;
1198     }
1199     switch (state) {
1200     case RUN_STATE_DEBUG:
1201         if (cpu->watchpoint_hit) {
1202             switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
1203             case BP_MEM_READ:
1204                 type = "r";
1205                 break;
1206             case BP_MEM_ACCESS:
1207                 type = "a";
1208                 break;
1209             default:
1210                 type = "";
1211                 break;
1212             }
1213             snprintf(buf, sizeof(buf),
1214                      "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
1215                      GDB_SIGNAL_TRAP, cpu_index(cpu), type,
1216                      (target_ulong)cpu->watchpoint_hit->vaddr);
1217             cpu->watchpoint_hit = NULL;
1218             goto send_packet;
1219         }
1220         tb_flush(env);
1221         ret = GDB_SIGNAL_TRAP;
1222         break;
1223     case RUN_STATE_PAUSED:
1224         ret = GDB_SIGNAL_INT;
1225         break;
1226     case RUN_STATE_SHUTDOWN:
1227         ret = GDB_SIGNAL_QUIT;
1228         break;
1229     case RUN_STATE_IO_ERROR:
1230         ret = GDB_SIGNAL_IO;
1231         break;
1232     case RUN_STATE_WATCHDOG:
1233         ret = GDB_SIGNAL_ALRM;
1234         break;
1235     case RUN_STATE_INTERNAL_ERROR:
1236         ret = GDB_SIGNAL_ABRT;
1237         break;
1238     case RUN_STATE_SAVE_VM:
1239     case RUN_STATE_RESTORE_VM:
1240         return;
1241     case RUN_STATE_FINISH_MIGRATE:
1242         ret = GDB_SIGNAL_XCPU;
1243         break;
1244     default:
1245         ret = GDB_SIGNAL_UNKNOWN;
1246         break;
1247     }
1248     snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
1249
1250 send_packet:
1251     put_packet(s, buf);
1252
1253     /* disable single step if it was enabled */
1254     cpu_single_step(cpu, 0);
1255 }
1256 #endif
1257
1258 /* Send a gdb syscall request.
1259    This accepts limited printf-style format specifiers, specifically:
1260     %x  - target_ulong argument printed in hex.
1261     %lx - 64-bit argument printed in hex.
1262     %s  - string pointer (target_ulong) and length (int) pair.  */
1263 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1264 {
1265     va_list va;
1266     char *p;
1267     char *p_end;
1268     target_ulong addr;
1269     uint64_t i64;
1270     GDBState *s;
1271
1272     s = gdbserver_state;
1273     if (!s)
1274         return;
1275     s->current_syscall_cb = cb;
1276 #ifndef CONFIG_USER_ONLY
1277     vm_stop(RUN_STATE_DEBUG);
1278 #endif
1279     va_start(va, fmt);
1280     p = s->syscall_buf;
1281     p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1282     *(p++) = 'F';
1283     while (*fmt) {
1284         if (*fmt == '%') {
1285             fmt++;
1286             switch (*fmt++) {
1287             case 'x':
1288                 addr = va_arg(va, target_ulong);
1289                 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1290                 break;
1291             case 'l':
1292                 if (*(fmt++) != 'x')
1293                     goto bad_format;
1294                 i64 = va_arg(va, uint64_t);
1295                 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1296                 break;
1297             case 's':
1298                 addr = va_arg(va, target_ulong);
1299                 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1300                               addr, va_arg(va, int));
1301                 break;
1302             default:
1303             bad_format:
1304                 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1305                         fmt - 1);
1306                 break;
1307             }
1308         } else {
1309             *(p++) = *(fmt++);
1310         }
1311     }
1312     *p = 0;
1313     va_end(va);
1314 #ifdef CONFIG_USER_ONLY
1315     put_packet(s, s->syscall_buf);
1316     gdb_handlesig(s->c_cpu, 0);
1317 #else
1318     /* In this case wait to send the syscall packet until notification that
1319        the CPU has stopped.  This must be done because if the packet is sent
1320        now the reply from the syscall request could be received while the CPU
1321        is still in the running state, which can cause packets to be dropped
1322        and state transition 'T' packets to be sent while the syscall is still
1323        being processed.  */
1324     cpu_exit(s->c_cpu);
1325 #endif
1326 }
1327
1328 static void gdb_read_byte(GDBState *s, int ch)
1329 {
1330     int i, csum;
1331     uint8_t reply;
1332
1333 #ifndef CONFIG_USER_ONLY
1334     if (s->last_packet_len) {
1335         /* Waiting for a response to the last packet.  If we see the start
1336            of a new command then abandon the previous response.  */
1337         if (ch == '-') {
1338 #ifdef DEBUG_GDB
1339             printf("Got NACK, retransmitting\n");
1340 #endif
1341             put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1342         }
1343 #ifdef DEBUG_GDB
1344         else if (ch == '+')
1345             printf("Got ACK\n");
1346         else
1347             printf("Got '%c' when expecting ACK/NACK\n", ch);
1348 #endif
1349         if (ch == '+' || ch == '$')
1350             s->last_packet_len = 0;
1351         if (ch != '$')
1352             return;
1353     }
1354     if (runstate_is_running()) {
1355         /* when the CPU is running, we cannot do anything except stop
1356            it when receiving a char */
1357         vm_stop(RUN_STATE_PAUSED);
1358     } else
1359 #endif
1360     {
1361         switch(s->state) {
1362         case RS_IDLE:
1363             if (ch == '$') {
1364                 s->line_buf_index = 0;
1365                 s->state = RS_GETLINE;
1366             }
1367             break;
1368         case RS_GETLINE:
1369             if (ch == '#') {
1370             s->state = RS_CHKSUM1;
1371             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1372                 s->state = RS_IDLE;
1373             } else {
1374             s->line_buf[s->line_buf_index++] = ch;
1375             }
1376             break;
1377         case RS_CHKSUM1:
1378             s->line_buf[s->line_buf_index] = '\0';
1379             s->line_csum = fromhex(ch) << 4;
1380             s->state = RS_CHKSUM2;
1381             break;
1382         case RS_CHKSUM2:
1383             s->line_csum |= fromhex(ch);
1384             csum = 0;
1385             for(i = 0; i < s->line_buf_index; i++) {
1386                 csum += s->line_buf[i];
1387             }
1388             if (s->line_csum != (csum & 0xff)) {
1389                 reply = '-';
1390                 put_buffer(s, &reply, 1);
1391                 s->state = RS_IDLE;
1392             } else {
1393                 reply = '+';
1394                 put_buffer(s, &reply, 1);
1395                 s->state = gdb_handle_packet(s, s->line_buf);
1396             }
1397             break;
1398         default:
1399             abort();
1400         }
1401     }
1402 }
1403
1404 /* Tell the remote gdb that the process has exited.  */
1405 void gdb_exit(CPUArchState *env, int code)
1406 {
1407   GDBState *s;
1408   char buf[4];
1409
1410   s = gdbserver_state;
1411   if (!s) {
1412       return;
1413   }
1414 #ifdef CONFIG_USER_ONLY
1415   if (gdbserver_fd < 0 || s->fd < 0) {
1416       return;
1417   }
1418 #endif
1419
1420   snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1421   put_packet(s, buf);
1422
1423 #ifndef CONFIG_USER_ONLY
1424   if (s->chr) {
1425       qemu_chr_delete(s->chr);
1426   }
1427 #endif
1428 }
1429
1430 #ifdef CONFIG_USER_ONLY
1431 int
1432 gdb_queuesig (void)
1433 {
1434     GDBState *s;
1435
1436     s = gdbserver_state;
1437
1438     if (gdbserver_fd < 0 || s->fd < 0)
1439         return 0;
1440     else
1441         return 1;
1442 }
1443
1444 int
1445 gdb_handlesig(CPUState *cpu, int sig)
1446 {
1447     CPUArchState *env = cpu->env_ptr;
1448     GDBState *s;
1449     char buf[256];
1450     int n;
1451
1452     s = gdbserver_state;
1453     if (gdbserver_fd < 0 || s->fd < 0) {
1454         return sig;
1455     }
1456
1457     /* disable single step if it was enabled */
1458     cpu_single_step(cpu, 0);
1459     tb_flush(env);
1460
1461     if (sig != 0) {
1462         snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1463         put_packet(s, buf);
1464     }
1465     /* put_packet() might have detected that the peer terminated the
1466        connection.  */
1467     if (s->fd < 0) {
1468         return sig;
1469     }
1470
1471     sig = 0;
1472     s->state = RS_IDLE;
1473     s->running_state = 0;
1474     while (s->running_state == 0) {
1475         n = read(s->fd, buf, 256);
1476         if (n > 0) {
1477             int i;
1478
1479             for (i = 0; i < n; i++) {
1480                 gdb_read_byte(s, buf[i]);
1481             }
1482         } else if (n == 0 || errno != EAGAIN) {
1483             /* XXX: Connection closed.  Should probably wait for another
1484                connection before continuing.  */
1485             return sig;
1486         }
1487     }
1488     sig = s->signal;
1489     s->signal = 0;
1490     return sig;
1491 }
1492
1493 /* Tell the remote gdb that the process has exited due to SIG.  */
1494 void gdb_signalled(CPUArchState *env, int sig)
1495 {
1496     GDBState *s;
1497     char buf[4];
1498
1499     s = gdbserver_state;
1500     if (gdbserver_fd < 0 || s->fd < 0) {
1501         return;
1502     }
1503
1504     snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1505     put_packet(s, buf);
1506 }
1507
1508 static void gdb_accept(void)
1509 {
1510     GDBState *s;
1511     struct sockaddr_in sockaddr;
1512     socklen_t len;
1513     int fd;
1514
1515     for(;;) {
1516         len = sizeof(sockaddr);
1517         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1518         if (fd < 0 && errno != EINTR) {
1519             perror("accept");
1520             return;
1521         } else if (fd >= 0) {
1522 #ifndef _WIN32
1523             fcntl(fd, F_SETFD, FD_CLOEXEC);
1524 #endif
1525             break;
1526         }
1527     }
1528
1529     /* set short latency */
1530     socket_set_nodelay(fd);
1531
1532     s = g_malloc0(sizeof(GDBState));
1533     s->c_cpu = first_cpu;
1534     s->g_cpu = first_cpu;
1535     s->fd = fd;
1536     gdb_has_xml = false;
1537
1538     gdbserver_state = s;
1539
1540     fcntl(fd, F_SETFL, O_NONBLOCK);
1541 }
1542
1543 static int gdbserver_open(int port)
1544 {
1545     struct sockaddr_in sockaddr;
1546     int fd, ret;
1547
1548     fd = socket(PF_INET, SOCK_STREAM, 0);
1549     if (fd < 0) {
1550         perror("socket");
1551         return -1;
1552     }
1553 #ifndef _WIN32
1554     fcntl(fd, F_SETFD, FD_CLOEXEC);
1555 #endif
1556
1557     socket_set_fast_reuse(fd);
1558
1559     sockaddr.sin_family = AF_INET;
1560     sockaddr.sin_port = htons(port);
1561     sockaddr.sin_addr.s_addr = 0;
1562     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1563     if (ret < 0) {
1564         perror("bind");
1565         close(fd);
1566         return -1;
1567     }
1568     ret = listen(fd, 0);
1569     if (ret < 0) {
1570         perror("listen");
1571         close(fd);
1572         return -1;
1573     }
1574     return fd;
1575 }
1576
1577 int gdbserver_start(int port)
1578 {
1579     gdbserver_fd = gdbserver_open(port);
1580     if (gdbserver_fd < 0)
1581         return -1;
1582     /* accept connections */
1583     gdb_accept();
1584     return 0;
1585 }
1586
1587 /* Disable gdb stub for child processes.  */
1588 void gdbserver_fork(CPUArchState *env)
1589 {
1590     CPUState *cpu = ENV_GET_CPU(env);
1591     GDBState *s = gdbserver_state;
1592
1593     if (gdbserver_fd < 0 || s->fd < 0) {
1594         return;
1595     }
1596     close(s->fd);
1597     s->fd = -1;
1598     cpu_breakpoint_remove_all(cpu, BP_GDB);
1599     cpu_watchpoint_remove_all(cpu, BP_GDB);
1600 }
1601 #else
1602 static int gdb_chr_can_receive(void *opaque)
1603 {
1604   /* We can handle an arbitrarily large amount of data.
1605    Pick the maximum packet size, which is as good as anything.  */
1606   return MAX_PACKET_LENGTH;
1607 }
1608
1609 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1610 {
1611     int i;
1612
1613     for (i = 0; i < size; i++) {
1614         gdb_read_byte(gdbserver_state, buf[i]);
1615     }
1616 }
1617
1618 static void gdb_chr_event(void *opaque, int event)
1619 {
1620     switch (event) {
1621     case CHR_EVENT_OPENED:
1622         vm_stop(RUN_STATE_PAUSED);
1623         gdb_has_xml = false;
1624         break;
1625     default:
1626         break;
1627     }
1628 }
1629
1630 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1631 {
1632     char buf[MAX_PACKET_LENGTH];
1633
1634     buf[0] = 'O';
1635     if (len > (MAX_PACKET_LENGTH/2) - 1)
1636         len = (MAX_PACKET_LENGTH/2) - 1;
1637     memtohex(buf + 1, (uint8_t *)msg, len);
1638     put_packet(s, buf);
1639 }
1640
1641 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1642 {
1643     const char *p = (const char *)buf;
1644     int max_sz;
1645
1646     max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1647     for (;;) {
1648         if (len <= max_sz) {
1649             gdb_monitor_output(gdbserver_state, p, len);
1650             break;
1651         }
1652         gdb_monitor_output(gdbserver_state, p, max_sz);
1653         p += max_sz;
1654         len -= max_sz;
1655     }
1656     return len;
1657 }
1658
1659 #ifndef _WIN32
1660 static void gdb_sigterm_handler(int signal)
1661 {
1662     if (runstate_is_running()) {
1663         vm_stop(RUN_STATE_PAUSED);
1664     }
1665 }
1666 #endif
1667
1668 int gdbserver_start(const char *device)
1669 {
1670     GDBState *s;
1671     char gdbstub_device_name[128];
1672     CharDriverState *chr = NULL;
1673     CharDriverState *mon_chr;
1674
1675     if (!device)
1676         return -1;
1677     if (strcmp(device, "none") != 0) {
1678         if (strstart(device, "tcp:", NULL)) {
1679             /* enforce required TCP attributes */
1680             snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1681                      "%s,nowait,nodelay,server", device);
1682             device = gdbstub_device_name;
1683         }
1684 #ifndef _WIN32
1685         else if (strcmp(device, "stdio") == 0) {
1686             struct sigaction act;
1687
1688             memset(&act, 0, sizeof(act));
1689             act.sa_handler = gdb_sigterm_handler;
1690             sigaction(SIGINT, &act, NULL);
1691         }
1692 #endif
1693         chr = qemu_chr_new("gdb", device, NULL);
1694         if (!chr)
1695             return -1;
1696
1697         qemu_chr_fe_claim_no_fail(chr);
1698         qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1699                               gdb_chr_event, NULL);
1700     }
1701
1702     s = gdbserver_state;
1703     if (!s) {
1704         s = g_malloc0(sizeof(GDBState));
1705         gdbserver_state = s;
1706
1707         qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1708
1709         /* Initialize a monitor terminal for gdb */
1710         mon_chr = qemu_chr_alloc();
1711         mon_chr->chr_write = gdb_monitor_write;
1712         monitor_init(mon_chr, 0);
1713     } else {
1714         if (s->chr)
1715             qemu_chr_delete(s->chr);
1716         mon_chr = s->mon_chr;
1717         memset(s, 0, sizeof(GDBState));
1718     }
1719     s->c_cpu = first_cpu;
1720     s->g_cpu = first_cpu;
1721     s->chr = chr;
1722     s->state = chr ? RS_IDLE : RS_INACTIVE;
1723     s->mon_chr = mon_chr;
1724     s->current_syscall_cb = NULL;
1725
1726     return 0;
1727 }
1728 #endif