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 /* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
 629 static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
 630 {
 631     static const int xlat[] = {
 632         [GDB_WATCHPOINT_WRITE]  = BP_GDB | BP_MEM_WRITE,
 633         [GDB_WATCHPOINT_READ]   = BP_GDB | BP_MEM_READ,
 634         [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
 635     };
 636
 637     CPUClass *cc = CPU_GET_CLASS(cpu);
 638     int cputype = xlat[gdbtype];
 639
 640     if (cc->gdb_stop_before_watchpoint) {
 641         cputype |= BP_STOP_BEFORE_ACCESS;
 642     }
 643     return cputype;
 644 }
 645 #endif
 646
 647 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
 648 {
 649     CPUState *cpu;
 650     int err = 0;
 651
 652     if (kvm_enabled()) {
 653         return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
 654     }
 655
 656     switch (type) {
 657     case GDB_BREAKPOINT_SW:
 658     case GDB_BREAKPOINT_HW:
 659         CPU_FOREACH(cpu) {
 660             err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
 661             if (err) {
 662                 break;
 663             }
 664         }
 665         return err;
 666 #ifndef CONFIG_USER_ONLY
 667     case GDB_WATCHPOINT_WRITE:
 668     case GDB_WATCHPOINT_READ:
 669     case GDB_WATCHPOINT_ACCESS:
 670         CPU_FOREACH(cpu) {
 671             err = cpu_watchpoint_insert(cpu, addr, len,
 672                                         xlat_gdb_type(cpu, type), NULL);
 673             if (err) {
 674                 break;
 675             }
 676         }
 677         return err;
 678 #endif
 679     default:
 680         return -ENOSYS;
 681     }
 682 }
 683
 684 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
 685 {
 686     CPUState *cpu;
 687     int err = 0;
 688
 689     if (kvm_enabled()) {
 690         return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
 691     }
 692
 693     switch (type) {
 694     case GDB_BREAKPOINT_SW:
 695     case GDB_BREAKPOINT_HW:
 696         CPU_FOREACH(cpu) {
 697             err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
 698             if (err) {
 699                 break;
 700             }
 701         }
 702         return err;
 703 #ifndef CONFIG_USER_ONLY
 704     case GDB_WATCHPOINT_WRITE:
 705     case GDB_WATCHPOINT_READ:
 706     case GDB_WATCHPOINT_ACCESS:
 707         CPU_FOREACH(cpu) {
 708             err = cpu_watchpoint_remove(cpu, addr, len,
 709                                         xlat_gdb_type(cpu, type));
 710             if (err)
 711                 break;
 712         }
 713         return err;
 714 #endif
 715     default:
 716         return -ENOSYS;
 717     }
 718 }
 719
 720 static void gdb_breakpoint_remove_all(void)
 721 {
 722     CPUState *cpu;
 723
 724     if (kvm_enabled()) {
 725         kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
 726         return;
 727     }
 728
 729     CPU_FOREACH(cpu) {
 730         cpu_breakpoint_remove_all(cpu, BP_GDB);
 731 #ifndef CONFIG_USER_ONLY
 732         cpu_watchpoint_remove_all(cpu, BP_GDB);
 733 #endif
 734     }
 735 }
 736
 737 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
 738 {
 739     CPUState *cpu = s->c_cpu;
 740     CPUClass *cc = CPU_GET_CLASS(cpu);
 741
 742     cpu_synchronize_state(cpu);
 743     if (cc->set_pc) {
 744         cc->set_pc(cpu, pc);
 745     }
 746 }
 747
 748 static CPUState *find_cpu(uint32_t thread_id)
 749 {
 750     CPUState *cpu;
 751
 752     CPU_FOREACH(cpu) {
 753         if (cpu_index(cpu) == thread_id) {
 754             return cpu;
 755         }
 756     }
 757
 758     return NULL;
 759 }
 760
 761 static int gdb_handle_packet(GDBState *s, const char *line_buf)
 762 {
 763     CPUState *cpu;
 764     CPUClass *cc;
 765     const char *p;
 766     uint32_t thread;
 767     int ch, reg_size, type, res;
 768     char buf[MAX_PACKET_LENGTH];
 769     uint8_t mem_buf[MAX_PACKET_LENGTH];
 770     uint8_t *registers;
 771     target_ulong addr, len;
 772
 773 #ifdef DEBUG_GDB
 774     printf("command='%s'\n", line_buf);
 775 #endif
 776     p = line_buf;
 777     ch = *p++;
 778     switch(ch) {
 779     case '?':
 780         /* TODO: Make this return the correct value for user-mode.  */
 781         snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
 782                  cpu_index(s->c_cpu));
 783         put_packet(s, buf);
 784         /* Remove all the breakpoints when this query is issued,
 785          * because gdb is doing and initial connect and the state
 786          * should be cleaned up.
 787          */
 788         gdb_breakpoint_remove_all();
 789         break;
 790     case 'c':
 791         if (*p != '\0') {
 792             addr = strtoull(p, (char **)&p, 16);
 793             gdb_set_cpu_pc(s, addr);
 794         }
 795         s->signal = 0;
 796         gdb_continue(s);
 797         return RS_IDLE;
 798     case 'C':
 799         s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
 800         if (s->signal == -1)
 801             s->signal = 0;
 802         gdb_continue(s);
 803         return RS_IDLE;
 804     case 'v':
 805         if (strncmp(p, "Cont", 4) == 0) {
 806             int res_signal, res_thread;
 807
 808             p += 4;
 809             if (*p == '?') {
 810                 put_packet(s, "vCont;c;C;s;S");
 811                 break;
 812             }
 813             res = 0;
 814             res_signal = 0;
 815             res_thread = 0;
 816             while (*p) {
 817                 int action, signal;
 818
 819                 if (*p++ != ';') {
 820                     res = 0;
 821                     break;
 822                 }
 823                 action = *p++;
 824                 signal = 0;
 825                 if (action == 'C' || action == 'S') {
 826                     signal = strtoul(p, (char **)&p, 16);
 827                 } else if (action != 'c' && action != 's') {
 828                     res = 0;
 829                     break;
 830                 }
 831                 thread = 0;
 832                 if (*p == ':') {
 833                     thread = strtoull(p+1, (char **)&p, 16);
 834                 }
 835                 action = tolower(action);
 836                 if (res == 0 || (res == 'c' && action == 's')) {
 837                     res = action;
 838                     res_signal = signal;
 839                     res_thread = thread;
 840                 }
 841             }
 842             if (res) {
 843                 if (res_thread != -1 && res_thread != 0) {
 844                     cpu = find_cpu(res_thread);
 845                     if (cpu == NULL) {
 846                         put_packet(s, "E22");
 847                         break;
 848                     }
 849                     s->c_cpu = cpu;
 850                 }
 851                 if (res == 's') {
 852                     cpu_single_step(s->c_cpu, sstep_flags);
 853                 }
 854                 s->signal = res_signal;
 855                 gdb_continue(s);
 856                 return RS_IDLE;
 857             }
 858             break;
 859         } else {
 860             goto unknown_command;
 861         }
 862     case 'k':
 863 #ifdef CONFIG_USER_ONLY
 864         /* Kill the target */
 865         fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
 866         exit(0);
 867 #endif
 868     case 'D':
 869         /* Detach packet */
 870         gdb_breakpoint_remove_all();
 871         gdb_syscall_mode = GDB_SYS_DISABLED;
 872         gdb_continue(s);
 873         put_packet(s, "OK");
 874         break;
 875     case 's':
 876         if (*p != '\0') {
 877             addr = strtoull(p, (char **)&p, 16);
 878             gdb_set_cpu_pc(s, addr);
 879         }
 880         cpu_single_step(s->c_cpu, sstep_flags);
 881         gdb_continue(s);
 882         return RS_IDLE;
 883     case 'F':
 884         {
 885             target_ulong ret;
 886             target_ulong err;
 887
 888             ret = strtoull(p, (char **)&p, 16);
 889             if (*p == ',') {
 890                 p++;
 891                 err = strtoull(p, (char **)&p, 16);
 892             } else {
 893                 err = 0;
 894             }
 895             if (*p == ',')
 896                 p++;
 897             type = *p;
 898             if (s->current_syscall_cb) {
 899                 s->current_syscall_cb(s->c_cpu, ret, err);
 900                 s->current_syscall_cb = NULL;
 901             }
 902             if (type == 'C') {
 903                 put_packet(s, "T02");
 904             } else {
 905                 gdb_continue(s);
 906             }
 907         }
 908         break;
 909     case 'g':
 910         cpu_synchronize_state(s->g_cpu);
 911         len = 0;
 912         for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
 913             reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
 914             len += reg_size;
 915         }
 916         memtohex(buf, mem_buf, len);
 917         put_packet(s, buf);
 918         break;
 919     case 'G':
 920         cpu_synchronize_state(s->g_cpu);
 921         registers = mem_buf;
 922         len = strlen(p) / 2;
 923         hextomem((uint8_t *)registers, p, len);
 924         for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
 925             reg_size = gdb_write_register(s->g_cpu, registers, addr);
 926             len -= reg_size;
 927             registers += reg_size;
 928         }
 929         put_packet(s, "OK");
 930         break;
 931     case 'm':
 932         addr = strtoull(p, (char **)&p, 16);
 933         if (*p == ',')
 934             p++;
 935         len = strtoull(p, NULL, 16);
 936         if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
 937             put_packet (s, "E14");
 938         } else {
 939             memtohex(buf, mem_buf, len);
 940             put_packet(s, buf);
 941         }
 942         break;
 943     case 'M':
 944         addr = strtoull(p, (char **)&p, 16);
 945         if (*p == ',')
 946             p++;
 947         len = strtoull(p, (char **)&p, 16);
 948         if (*p == ':')
 949             p++;
 950         hextomem(mem_buf, p, len);
 951         if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
 952                                    true) != 0) {
 953             put_packet(s, "E14");
 954         } else {
 955             put_packet(s, "OK");
 956         }
 957         break;
 958     case 'p':
 959         /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
 960            This works, but can be very slow.  Anything new enough to
 961            understand XML also knows how to use this properly.  */
 962         if (!gdb_has_xml)
 963             goto unknown_command;
 964         addr = strtoull(p, (char **)&p, 16);
 965         reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
 966         if (reg_size) {
 967             memtohex(buf, mem_buf, reg_size);
 968             put_packet(s, buf);
 969         } else {
 970             put_packet(s, "E14");
 971         }
 972         break;
 973     case 'P':
 974         if (!gdb_has_xml)
 975             goto unknown_command;
 976         addr = strtoull(p, (char **)&p, 16);
 977         if (*p == '=')
 978             p++;
 979         reg_size = strlen(p) / 2;
 980         hextomem(mem_buf, p, reg_size);
 981         gdb_write_register(s->g_cpu, mem_buf, addr);
 982         put_packet(s, "OK");
 983         break;
 984     case 'Z':
 985     case 'z':
 986         type = strtoul(p, (char **)&p, 16);
 987         if (*p == ',')
 988             p++;
 989         addr = strtoull(p, (char **)&p, 16);
 990         if (*p == ',')
 991             p++;
 992         len = strtoull(p, (char **)&p, 16);
 993         if (ch == 'Z')
 994             res = gdb_breakpoint_insert(addr, len, type);
 995         else
 996             res = gdb_breakpoint_remove(addr, len, type);
 997         if (res >= 0)
 998              put_packet(s, "OK");
 999         else if (res == -ENOSYS)
1000             put_packet(s, "");
1001         else
1002             put_packet(s, "E22");
1003         break;
1004     case 'H':
1005         type = *p++;
1006         thread = strtoull(p, (char **)&p, 16);
1007         if (thread == -1 || thread == 0) {
1008             put_packet(s, "OK");
1009             break;
1010         }
1011         cpu = find_cpu(thread);
1012         if (cpu == NULL) {
1013             put_packet(s, "E22");
1014             break;
1015         }
1016         switch (type) {
1017         case 'c':
1018             s->c_cpu = cpu;
1019             put_packet(s, "OK");
1020             break;
1021         case 'g':
1022             s->g_cpu = cpu;
1023             put_packet(s, "OK");
1024             break;
1025         default:
1026              put_packet(s, "E22");
1027              break;
1028         }
1029         break;
1030     case 'T':
1031         thread = strtoull(p, (char **)&p, 16);
1032         cpu = find_cpu(thread);
1033
1034         if (cpu != NULL) {
1035             put_packet(s, "OK");
1036         } else {
1037             put_packet(s, "E22");
1038         }
1039         break;
1040     case 'q':
1041     case 'Q':
1042         /* parse any 'q' packets here */
1043         if (!strcmp(p,"qemu.sstepbits")) {
1044             /* Query Breakpoint bit definitions */
1045             snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1046                      SSTEP_ENABLE,
1047                      SSTEP_NOIRQ,
1048                      SSTEP_NOTIMER);
1049             put_packet(s, buf);
1050             break;
1051         } else if (strncmp(p,"qemu.sstep",10) == 0) {
1052             /* Display or change the sstep_flags */
1053             p += 10;
1054             if (*p != '=') {
1055                 /* Display current setting */
1056                 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1057                 put_packet(s, buf);
1058                 break;
1059             }
1060             p++;
1061             type = strtoul(p, (char **)&p, 16);
1062             sstep_flags = type;
1063             put_packet(s, "OK");
1064             break;
1065         } else if (strcmp(p,"C") == 0) {
1066             /* "Current thread" remains vague in the spec, so always return
1067              *  the first CPU (gdb returns the first thread). */
1068             put_packet(s, "QC1");
1069             break;
1070         } else if (strcmp(p,"fThreadInfo") == 0) {
1071             s->query_cpu = first_cpu;
1072             goto report_cpuinfo;
1073         } else if (strcmp(p,"sThreadInfo") == 0) {
1074         report_cpuinfo:
1075             if (s->query_cpu) {
1076                 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
1077                 put_packet(s, buf);
1078                 s->query_cpu = CPU_NEXT(s->query_cpu);
1079             } else
1080                 put_packet(s, "l");
1081             break;
1082         } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1083             thread = strtoull(p+16, (char **)&p, 16);
1084             cpu = find_cpu(thread);
1085             if (cpu != NULL) {
1086                 cpu_synchronize_state(cpu);
1087                 len = snprintf((char *)mem_buf, sizeof(mem_buf),
1088                                "CPU#%d [%s]", cpu->cpu_index,
1089                                cpu->halted ? "halted " : "running");
1090                 memtohex(buf, mem_buf, len);
1091                 put_packet(s, buf);
1092             }
1093             break;
1094         }
1095 #ifdef CONFIG_USER_ONLY
1096         else if (strncmp(p, "Offsets", 7) == 0) {
1097             TaskState *ts = s->c_cpu->opaque;
1098
1099             snprintf(buf, sizeof(buf),
1100                      "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1101                      ";Bss=" TARGET_ABI_FMT_lx,
1102                      ts->info->code_offset,
1103                      ts->info->data_offset,
1104                      ts->info->data_offset);
1105             put_packet(s, buf);
1106             break;
1107         }
1108 #else /* !CONFIG_USER_ONLY */
1109         else if (strncmp(p, "Rcmd,", 5) == 0) {
1110             int len = strlen(p + 5);
1111
1112             if ((len % 2) != 0) {
1113                 put_packet(s, "E01");
1114                 break;
1115             }
1116             hextomem(mem_buf, p + 5, len);
1117             len = len / 2;
1118             mem_buf[len++] = 0;
1119             qemu_chr_be_write(s->mon_chr, mem_buf, len);
1120             put_packet(s, "OK");
1121             break;
1122         }
1123 #endif /* !CONFIG_USER_ONLY */
1124         if (strncmp(p, "Supported", 9) == 0) {
1125             snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1126             cc = CPU_GET_CLASS(first_cpu);
1127             if (cc->gdb_core_xml_file != NULL) {
1128                 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1129             }
1130             put_packet(s, buf);
1131             break;
1132         }
1133         if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1134             const char *xml;
1135             target_ulong total_len;
1136
1137             cc = CPU_GET_CLASS(first_cpu);
1138             if (cc->gdb_core_xml_file == NULL) {
1139                 goto unknown_command;
1140             }
1141
1142             gdb_has_xml = true;
1143             p += 19;
1144             xml = get_feature_xml(p, &p, cc);
1145             if (!xml) {
1146                 snprintf(buf, sizeof(buf), "E00");
1147                 put_packet(s, buf);
1148                 break;
1149             }
1150
1151             if (*p == ':')
1152                 p++;
1153             addr = strtoul(p, (char **)&p, 16);
1154             if (*p == ',')
1155                 p++;
1156             len = strtoul(p, (char **)&p, 16);
1157
1158             total_len = strlen(xml);
1159             if (addr > total_len) {
1160                 snprintf(buf, sizeof(buf), "E00");
1161                 put_packet(s, buf);
1162                 break;
1163             }
1164             if (len > (MAX_PACKET_LENGTH - 5) / 2)
1165                 len = (MAX_PACKET_LENGTH - 5) / 2;
1166             if (len < total_len - addr) {
1167                 buf[0] = 'm';
1168                 len = memtox(buf + 1, xml + addr, len);
1169             } else {
1170                 buf[0] = 'l';
1171                 len = memtox(buf + 1, xml + addr, total_len - addr);
1172             }
1173             put_packet_binary(s, buf, len + 1);
1174             break;
1175         }
1176         /* Unrecognised 'q' command.  */
1177         goto unknown_command;
1178
1179     default:
1180     unknown_command:
1181         /* put empty packet */
1182         buf[0] = '\0';
1183         put_packet(s, buf);
1184         break;
1185     }
1186     return RS_IDLE;
1187 }
1188
1189 void gdb_set_stop_cpu(CPUState *cpu)
1190 {
1191     gdbserver_state->c_cpu = cpu;
1192     gdbserver_state->g_cpu = cpu;
1193 }
1194
1195 #ifndef CONFIG_USER_ONLY
1196 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1197 {
1198     GDBState *s = gdbserver_state;
1199     CPUArchState *env = s->c_cpu->env_ptr;
1200     CPUState *cpu = s->c_cpu;
1201     char buf[256];
1202     const char *type;
1203     int ret;
1204
1205     if (running || s->state == RS_INACTIVE) {
1206         return;
1207     }
1208     /* Is there a GDB syscall waiting to be sent?  */
1209     if (s->current_syscall_cb) {
1210         put_packet(s, s->syscall_buf);
1211         return;
1212     }
1213     switch (state) {
1214     case RUN_STATE_DEBUG:
1215         if (cpu->watchpoint_hit) {
1216             switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
1217             case BP_MEM_READ:
1218                 type = "r";
1219                 break;
1220             case BP_MEM_ACCESS:
1221                 type = "a";
1222                 break;
1223             default:
1224                 type = "";
1225                 break;
1226             }
1227             snprintf(buf, sizeof(buf),
1228                      "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
1229                      GDB_SIGNAL_TRAP, cpu_index(cpu), type,
1230                      (target_ulong)cpu->watchpoint_hit->vaddr);
1231             cpu->watchpoint_hit = NULL;
1232             goto send_packet;
1233         }
1234         tb_flush(env);
1235         ret = GDB_SIGNAL_TRAP;
1236         break;
1237     case RUN_STATE_PAUSED:
1238         ret = GDB_SIGNAL_INT;
1239         break;
1240     case RUN_STATE_SHUTDOWN:
1241         ret = GDB_SIGNAL_QUIT;
1242         break;
1243     case RUN_STATE_IO_ERROR:
1244         ret = GDB_SIGNAL_IO;
1245         break;
1246     case RUN_STATE_WATCHDOG:
1247         ret = GDB_SIGNAL_ALRM;
1248         break;
1249     case RUN_STATE_INTERNAL_ERROR:
1250         ret = GDB_SIGNAL_ABRT;
1251         break;
1252     case RUN_STATE_SAVE_VM:
1253     case RUN_STATE_RESTORE_VM:
1254         return;
1255     case RUN_STATE_FINISH_MIGRATE:
1256         ret = GDB_SIGNAL_XCPU;
1257         break;
1258     default:
1259         ret = GDB_SIGNAL_UNKNOWN;
1260         break;
1261     }
1262     snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
1263
1264 send_packet:
1265     put_packet(s, buf);
1266
1267     /* disable single step if it was enabled */
1268     cpu_single_step(cpu, 0);
1269 }
1270 #endif
1271
1272 /* Send a gdb syscall request.
1273    This accepts limited printf-style format specifiers, specifically:
1274     %x  - target_ulong argument printed in hex.
1275     %lx - 64-bit argument printed in hex.
1276     %s  - string pointer (target_ulong) and length (int) pair.  */
1277 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1278 {
1279     va_list va;
1280     char *p;
1281     char *p_end;
1282     target_ulong addr;
1283     uint64_t i64;
1284     GDBState *s;
1285
1286     s = gdbserver_state;
1287     if (!s)
1288         return;
1289     s->current_syscall_cb = cb;
1290 #ifndef CONFIG_USER_ONLY
1291     vm_stop(RUN_STATE_DEBUG);
1292 #endif
1293     va_start(va, fmt);
1294     p = s->syscall_buf;
1295     p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1296     *(p++) = 'F';
1297     while (*fmt) {
1298         if (*fmt == '%') {
1299             fmt++;
1300             switch (*fmt++) {
1301             case 'x':
1302                 addr = va_arg(va, target_ulong);
1303                 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1304                 break;
1305             case 'l':
1306                 if (*(fmt++) != 'x')
1307                     goto bad_format;
1308                 i64 = va_arg(va, uint64_t);
1309                 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1310                 break;
1311             case 's':
1312                 addr = va_arg(va, target_ulong);
1313                 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1314                               addr, va_arg(va, int));
1315                 break;
1316             default:
1317             bad_format:
1318                 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1319                         fmt - 1);
1320                 break;
1321             }
1322         } else {
1323             *(p++) = *(fmt++);
1324         }
1325     }
1326     *p = 0;
1327     va_end(va);
1328 #ifdef CONFIG_USER_ONLY
1329     put_packet(s, s->syscall_buf);
1330     gdb_handlesig(s->c_cpu, 0);
1331 #else
1332     /* In this case wait to send the syscall packet until notification that
1333        the CPU has stopped.  This must be done because if the packet is sent
1334        now the reply from the syscall request could be received while the CPU
1335        is still in the running state, which can cause packets to be dropped
1336        and state transition 'T' packets to be sent while the syscall is still
1337        being processed.  */
1338     cpu_exit(s->c_cpu);
1339 #endif
1340 }
1341
1342 static void gdb_read_byte(GDBState *s, int ch)
1343 {
1344     int i, csum;
1345     uint8_t reply;
1346
1347 #ifndef CONFIG_USER_ONLY
1348     if (s->last_packet_len) {
1349         /* Waiting for a response to the last packet.  If we see the start
1350            of a new command then abandon the previous response.  */
1351         if (ch == '-') {
1352 #ifdef DEBUG_GDB
1353             printf("Got NACK, retransmitting\n");
1354 #endif
1355             put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1356         }
1357 #ifdef DEBUG_GDB
1358         else if (ch == '+')
1359             printf("Got ACK\n");
1360         else
1361             printf("Got '%c' when expecting ACK/NACK\n", ch);
1362 #endif
1363         if (ch == '+' || ch == '$')
1364             s->last_packet_len = 0;
1365         if (ch != '$')
1366             return;
1367     }
1368     if (runstate_is_running()) {
1369         /* when the CPU is running, we cannot do anything except stop
1370            it when receiving a char */
1371         vm_stop(RUN_STATE_PAUSED);
1372     } else
1373 #endif
1374     {
1375         switch(s->state) {
1376         case RS_IDLE:
1377             if (ch == '$') {
1378                 s->line_buf_index = 0;
1379                 s->state = RS_GETLINE;
1380             }
1381             break;
1382         case RS_GETLINE:
1383             if (ch == '#') {
1384             s->state = RS_CHKSUM1;
1385             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1386                 s->state = RS_IDLE;
1387             } else {
1388             s->line_buf[s->line_buf_index++] = ch;
1389             }
1390             break;
1391         case RS_CHKSUM1:
1392             s->line_buf[s->line_buf_index] = '\0';
1393             s->line_csum = fromhex(ch) << 4;
1394             s->state = RS_CHKSUM2;
1395             break;
1396         case RS_CHKSUM2:
1397             s->line_csum |= fromhex(ch);
1398             csum = 0;
1399             for(i = 0; i < s->line_buf_index; i++) {
1400                 csum += s->line_buf[i];
1401             }
1402             if (s->line_csum != (csum & 0xff)) {
1403                 reply = '-';
1404                 put_buffer(s, &reply, 1);
1405                 s->state = RS_IDLE;
1406             } else {
1407                 reply = '+';
1408                 put_buffer(s, &reply, 1);
1409                 s->state = gdb_handle_packet(s, s->line_buf);
1410             }
1411             break;
1412         default:
1413             abort();
1414         }
1415     }
1416 }
1417
1418 /* Tell the remote gdb that the process has exited.  */
1419 void gdb_exit(CPUArchState *env, int code)
1420 {
1421   GDBState *s;
1422   char buf[4];
1423
1424   s = gdbserver_state;
1425   if (!s) {
1426       return;
1427   }
1428 #ifdef CONFIG_USER_ONLY
1429   if (gdbserver_fd < 0 || s->fd < 0) {
1430       return;
1431   }
1432 #endif
1433
1434   snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1435   put_packet(s, buf);
1436
1437 #ifndef CONFIG_USER_ONLY
1438   if (s->chr) {
1439       qemu_chr_delete(s->chr);
1440   }
1441 #endif
1442 }
1443
1444 #ifdef CONFIG_USER_ONLY
1445 int
1446 gdb_queuesig (void)
1447 {
1448     GDBState *s;
1449
1450     s = gdbserver_state;
1451
1452     if (gdbserver_fd < 0 || s->fd < 0)
1453         return 0;
1454     else
1455         return 1;
1456 }
1457
1458 int
1459 gdb_handlesig(CPUState *cpu, int sig)
1460 {
1461     CPUArchState *env = cpu->env_ptr;
1462     GDBState *s;
1463     char buf[256];
1464     int n;
1465
1466     s = gdbserver_state;
1467     if (gdbserver_fd < 0 || s->fd < 0) {
1468         return sig;
1469     }
1470
1471     /* disable single step if it was enabled */
1472     cpu_single_step(cpu, 0);
1473     tb_flush(env);
1474
1475     if (sig != 0) {
1476         snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1477         put_packet(s, buf);
1478     }
1479     /* put_packet() might have detected that the peer terminated the
1480        connection.  */
1481     if (s->fd < 0) {
1482         return sig;
1483     }
1484
1485     sig = 0;
1486     s->state = RS_IDLE;
1487     s->running_state = 0;
1488     while (s->running_state == 0) {
1489         n = read(s->fd, buf, 256);
1490         if (n > 0) {
1491             int i;
1492
1493             for (i = 0; i < n; i++) {
1494                 gdb_read_byte(s, buf[i]);
1495             }
1496         } else if (n == 0 || errno != EAGAIN) {
1497             /* XXX: Connection closed.  Should probably wait for another
1498                connection before continuing.  */
1499             return sig;
1500         }
1501     }
1502     sig = s->signal;
1503     s->signal = 0;
1504     return sig;
1505 }
1506
1507 /* Tell the remote gdb that the process has exited due to SIG.  */
1508 void gdb_signalled(CPUArchState *env, int sig)
1509 {
1510     GDBState *s;
1511     char buf[4];
1512
1513     s = gdbserver_state;
1514     if (gdbserver_fd < 0 || s->fd < 0) {
1515         return;
1516     }
1517
1518     snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1519     put_packet(s, buf);
1520 }
1521
1522 static void gdb_accept(void)
1523 {
1524     GDBState *s;
1525     struct sockaddr_in sockaddr;
1526     socklen_t len;
1527     int fd;
1528
1529     for(;;) {
1530         len = sizeof(sockaddr);
1531         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1532         if (fd < 0 && errno != EINTR) {
1533             perror("accept");
1534             return;
1535         } else if (fd >= 0) {
1536 #ifndef _WIN32
1537             fcntl(fd, F_SETFD, FD_CLOEXEC);
1538 #endif
1539             break;
1540         }
1541     }
1542
1543     /* set short latency */
1544     socket_set_nodelay(fd);
1545
1546     s = g_malloc0(sizeof(GDBState));
1547     s->c_cpu = first_cpu;
1548     s->g_cpu = first_cpu;
1549     s->fd = fd;
1550     gdb_has_xml = false;
1551
1552     gdbserver_state = s;
1553
1554     fcntl(fd, F_SETFL, O_NONBLOCK);
1555 }
1556
1557 static int gdbserver_open(int port)
1558 {
1559     struct sockaddr_in sockaddr;
1560     int fd, ret;
1561
1562     fd = socket(PF_INET, SOCK_STREAM, 0);
1563     if (fd < 0) {
1564         perror("socket");
1565         return -1;
1566     }
1567 #ifndef _WIN32
1568     fcntl(fd, F_SETFD, FD_CLOEXEC);
1569 #endif
1570
1571     socket_set_fast_reuse(fd);
1572
1573     sockaddr.sin_family = AF_INET;
1574     sockaddr.sin_port = htons(port);
1575     sockaddr.sin_addr.s_addr = 0;
1576     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1577     if (ret < 0) {
1578         perror("bind");
1579         close(fd);
1580         return -1;
1581     }
1582     ret = listen(fd, 0);
1583     if (ret < 0) {
1584         perror("listen");
1585         close(fd);
1586         return -1;
1587     }
1588     return fd;
1589 }
1590
1591 int gdbserver_start(int port)
1592 {
1593     gdbserver_fd = gdbserver_open(port);
1594     if (gdbserver_fd < 0)
1595         return -1;
1596     /* accept connections */
1597     gdb_accept();
1598     return 0;
1599 }
1600
1601 /* Disable gdb stub for child processes.  */
1602 void gdbserver_fork(CPUArchState *env)
1603 {
1604     CPUState *cpu = ENV_GET_CPU(env);
1605     GDBState *s = gdbserver_state;
1606
1607     if (gdbserver_fd < 0 || s->fd < 0) {
1608         return;
1609     }
1610     close(s->fd);
1611     s->fd = -1;
1612     cpu_breakpoint_remove_all(cpu, BP_GDB);
1613     cpu_watchpoint_remove_all(cpu, BP_GDB);
1614 }
1615 #else
1616 static int gdb_chr_can_receive(void *opaque)
1617 {
1618   /* We can handle an arbitrarily large amount of data.
1619    Pick the maximum packet size, which is as good as anything.  */
1620   return MAX_PACKET_LENGTH;
1621 }
1622
1623 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1624 {
1625     int i;
1626
1627     for (i = 0; i < size; i++) {
1628         gdb_read_byte(gdbserver_state, buf[i]);
1629     }
1630 }
1631
1632 static void gdb_chr_event(void *opaque, int event)
1633 {
1634     switch (event) {
1635     case CHR_EVENT_OPENED:
1636         vm_stop(RUN_STATE_PAUSED);
1637         gdb_has_xml = false;
1638         break;
1639     default:
1640         break;
1641     }
1642 }
1643
1644 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1645 {
1646     char buf[MAX_PACKET_LENGTH];
1647
1648     buf[0] = 'O';
1649     if (len > (MAX_PACKET_LENGTH/2) - 1)
1650         len = (MAX_PACKET_LENGTH/2) - 1;
1651     memtohex(buf + 1, (uint8_t *)msg, len);
1652     put_packet(s, buf);
1653 }
1654
1655 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1656 {
1657     const char *p = (const char *)buf;
1658     int max_sz;
1659
1660     max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1661     for (;;) {
1662         if (len <= max_sz) {
1663             gdb_monitor_output(gdbserver_state, p, len);
1664             break;
1665         }
1666         gdb_monitor_output(gdbserver_state, p, max_sz);
1667         p += max_sz;
1668         len -= max_sz;
1669     }
1670     return len;
1671 }
1672
1673 #ifndef _WIN32
1674 static void gdb_sigterm_handler(int signal)
1675 {
1676     if (runstate_is_running()) {
1677         vm_stop(RUN_STATE_PAUSED);
1678     }
1679 }
1680 #endif
1681
1682 int gdbserver_start(const char *device)
1683 {
1684     GDBState *s;
1685     char gdbstub_device_name[128];
1686     CharDriverState *chr = NULL;
1687     CharDriverState *mon_chr;
1688
1689     if (!device)
1690         return -1;
1691     if (strcmp(device, "none") != 0) {
1692         if (strstart(device, "tcp:", NULL)) {
1693             /* enforce required TCP attributes */
1694             snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1695                      "%s,nowait,nodelay,server", device);
1696             device = gdbstub_device_name;
1697         }
1698 #ifndef _WIN32
1699         else if (strcmp(device, "stdio") == 0) {
1700             struct sigaction act;
1701
1702             memset(&act, 0, sizeof(act));
1703             act.sa_handler = gdb_sigterm_handler;
1704             sigaction(SIGINT, &act, NULL);
1705         }
1706 #endif
1707         chr = qemu_chr_new("gdb", device, NULL);
1708         if (!chr)
1709             return -1;
1710
1711         qemu_chr_fe_claim_no_fail(chr);
1712         qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1713                               gdb_chr_event, NULL);
1714     }
1715
1716     s = gdbserver_state;
1717     if (!s) {
1718         s = g_malloc0(sizeof(GDBState));
1719         gdbserver_state = s;
1720
1721         qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1722
1723         /* Initialize a monitor terminal for gdb */
1724         mon_chr = qemu_chr_alloc();
1725         mon_chr->chr_write = gdb_monitor_write;
1726         monitor_init(mon_chr, 0);
1727     } else {
1728         if (s->chr)
1729             qemu_chr_delete(s->chr);
1730         mon_chr = s->mon_chr;
1731         memset(s, 0, sizeof(GDBState));
1732     }
1733     s->c_cpu = first_cpu;
1734     s->g_cpu = first_cpu;
1735     s->chr = chr;
1736     s->state = chr ? RS_IDLE : RS_INACTIVE;
1737     s->mon_chr = mon_chr;
1738     s->current_syscall_cb = NULL;
1739
1740     return 0;
1741 }
1742 #endif