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 "qemu/osdep.h"
  20 #include "qapi/error.h"
  21 #include "qemu/error-report.h"
  22 #include "qemu/cutils.h"
  23 #include "trace-root.h"
  24 #ifdef CONFIG_USER_ONLY
  25 #include "qemu.h"
  26 #else
  27 #include "monitor/monitor.h"
  28 #include "chardev/char.h"
  29 #include "chardev/char-fe.h"
  30 #include "sysemu/sysemu.h"
  31 #include "exec/gdbstub.h"
  32 #include "hw/cpu/cluster.h"
  33 #endif
  34
  35 #define MAX_PACKET_LENGTH 4096
  36
  37 #include "qemu/sockets.h"
  38 #include "sysemu/hw_accel.h"
  39 #include "sysemu/kvm.h"
  40 #include "exec/semihost.h"
  41 #include "exec/exec-all.h"
  42
  43 #ifdef CONFIG_USER_ONLY
  44 #define GDB_ATTACHED "0"
  45 #else
  46 #define GDB_ATTACHED "1"
  47 #endif
  48
  49 static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
  50                                          uint8_t *buf, int len, bool is_write)
  51 {
  52     CPUClass *cc = CPU_GET_CLASS(cpu);
  53
  54     if (cc->memory_rw_debug) {
  55         return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
  56     }
  57     return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
  58 }
  59
  60 /* Return the GDB index for a given vCPU state.
  61  *
  62  * For user mode this is simply the thread id. In system mode GDB
  63  * numbers CPUs from 1 as 0 is reserved as an "any cpu" index.
  64  */
  65 static inline int cpu_gdb_index(CPUState *cpu)
  66 {
  67 #if defined(CONFIG_USER_ONLY)
  68     TaskState *ts = (TaskState *) cpu->opaque;
  69     return ts->ts_tid;
  70 #else
  71     return cpu->cpu_index + 1;
  72 #endif
  73 }
  74
  75 enum {
  76     GDB_SIGNAL_0 = 0,
  77     GDB_SIGNAL_INT = 2,
  78     GDB_SIGNAL_QUIT = 3,
  79     GDB_SIGNAL_TRAP = 5,
  80     GDB_SIGNAL_ABRT = 6,
  81     GDB_SIGNAL_ALRM = 14,
  82     GDB_SIGNAL_IO = 23,
  83     GDB_SIGNAL_XCPU = 24,
  84     GDB_SIGNAL_UNKNOWN = 143
  85 };
  86
  87 #ifdef CONFIG_USER_ONLY
  88
  89 /* Map target signal numbers to GDB protocol signal numbers and vice
  90  * versa.  For user emulation's currently supported systems, we can
  91  * assume most signals are defined.
  92  */
  93
  94 static int gdb_signal_table[] = {
  95     0,
  96     TARGET_SIGHUP,
  97     TARGET_SIGINT,
  98     TARGET_SIGQUIT,
  99     TARGET_SIGILL,
 100     TARGET_SIGTRAP,
 101     TARGET_SIGABRT,
 102     -1, /* SIGEMT */
 103     TARGET_SIGFPE,
 104     TARGET_SIGKILL,
 105     TARGET_SIGBUS,
 106     TARGET_SIGSEGV,
 107     TARGET_SIGSYS,
 108     TARGET_SIGPIPE,
 109     TARGET_SIGALRM,
 110     TARGET_SIGTERM,
 111     TARGET_SIGURG,
 112     TARGET_SIGSTOP,
 113     TARGET_SIGTSTP,
 114     TARGET_SIGCONT,
 115     TARGET_SIGCHLD,
 116     TARGET_SIGTTIN,
 117     TARGET_SIGTTOU,
 118     TARGET_SIGIO,
 119     TARGET_SIGXCPU,
 120     TARGET_SIGXFSZ,
 121     TARGET_SIGVTALRM,
 122     TARGET_SIGPROF,
 123     TARGET_SIGWINCH,
 124     -1, /* SIGLOST */
 125     TARGET_SIGUSR1,
 126     TARGET_SIGUSR2,
 127 #ifdef TARGET_SIGPWR
 128     TARGET_SIGPWR,
 129 #else
 130     -1,
 131 #endif
 132     -1, /* SIGPOLL */
 133     -1,
 134     -1,
 135     -1,
 136     -1,
 137     -1,
 138     -1,
 139     -1,
 140     -1,
 141     -1,
 142     -1,
 143     -1,
 144 #ifdef __SIGRTMIN
 145     __SIGRTMIN + 1,
 146     __SIGRTMIN + 2,
 147     __SIGRTMIN + 3,
 148     __SIGRTMIN + 4,
 149     __SIGRTMIN + 5,
 150     __SIGRTMIN + 6,
 151     __SIGRTMIN + 7,
 152     __SIGRTMIN + 8,
 153     __SIGRTMIN + 9,
 154     __SIGRTMIN + 10,
 155     __SIGRTMIN + 11,
 156     __SIGRTMIN + 12,
 157     __SIGRTMIN + 13,
 158     __SIGRTMIN + 14,
 159     __SIGRTMIN + 15,
 160     __SIGRTMIN + 16,
 161     __SIGRTMIN + 17,
 162     __SIGRTMIN + 18,
 163     __SIGRTMIN + 19,
 164     __SIGRTMIN + 20,
 165     __SIGRTMIN + 21,
 166     __SIGRTMIN + 22,
 167     __SIGRTMIN + 23,
 168     __SIGRTMIN + 24,
 169     __SIGRTMIN + 25,
 170     __SIGRTMIN + 26,
 171     __SIGRTMIN + 27,
 172     __SIGRTMIN + 28,
 173     __SIGRTMIN + 29,
 174     __SIGRTMIN + 30,
 175     __SIGRTMIN + 31,
 176     -1, /* SIGCANCEL */
 177     __SIGRTMIN,
 178     __SIGRTMIN + 32,
 179     __SIGRTMIN + 33,
 180     __SIGRTMIN + 34,
 181     __SIGRTMIN + 35,
 182     __SIGRTMIN + 36,
 183     __SIGRTMIN + 37,
 184     __SIGRTMIN + 38,
 185     __SIGRTMIN + 39,
 186     __SIGRTMIN + 40,
 187     __SIGRTMIN + 41,
 188     __SIGRTMIN + 42,
 189     __SIGRTMIN + 43,
 190     __SIGRTMIN + 44,
 191     __SIGRTMIN + 45,
 192     __SIGRTMIN + 46,
 193     __SIGRTMIN + 47,
 194     __SIGRTMIN + 48,
 195     __SIGRTMIN + 49,
 196     __SIGRTMIN + 50,
 197     __SIGRTMIN + 51,
 198     __SIGRTMIN + 52,
 199     __SIGRTMIN + 53,
 200     __SIGRTMIN + 54,
 201     __SIGRTMIN + 55,
 202     __SIGRTMIN + 56,
 203     __SIGRTMIN + 57,
 204     __SIGRTMIN + 58,
 205     __SIGRTMIN + 59,
 206     __SIGRTMIN + 60,
 207     __SIGRTMIN + 61,
 208     __SIGRTMIN + 62,
 209     __SIGRTMIN + 63,
 210     __SIGRTMIN + 64,
 211     __SIGRTMIN + 65,
 212     __SIGRTMIN + 66,
 213     __SIGRTMIN + 67,
 214     __SIGRTMIN + 68,
 215     __SIGRTMIN + 69,
 216     __SIGRTMIN + 70,
 217     __SIGRTMIN + 71,
 218     __SIGRTMIN + 72,
 219     __SIGRTMIN + 73,
 220     __SIGRTMIN + 74,
 221     __SIGRTMIN + 75,
 222     __SIGRTMIN + 76,
 223     __SIGRTMIN + 77,
 224     __SIGRTMIN + 78,
 225     __SIGRTMIN + 79,
 226     __SIGRTMIN + 80,
 227     __SIGRTMIN + 81,
 228     __SIGRTMIN + 82,
 229     __SIGRTMIN + 83,
 230     __SIGRTMIN + 84,
 231     __SIGRTMIN + 85,
 232     __SIGRTMIN + 86,
 233     __SIGRTMIN + 87,
 234     __SIGRTMIN + 88,
 235     __SIGRTMIN + 89,
 236     __SIGRTMIN + 90,
 237     __SIGRTMIN + 91,
 238     __SIGRTMIN + 92,
 239     __SIGRTMIN + 93,
 240     __SIGRTMIN + 94,
 241     __SIGRTMIN + 95,
 242     -1, /* SIGINFO */
 243     -1, /* UNKNOWN */
 244     -1, /* DEFAULT */
 245     -1,
 246     -1,
 247     -1,
 248     -1,
 249     -1,
 250     -1
 251 #endif
 252 };
 253 #else
 254 /* In system mode we only need SIGINT and SIGTRAP; other signals
 255    are not yet supported.  */
 256
 257 enum {
 258     TARGET_SIGINT = 2,
 259     TARGET_SIGTRAP = 5
 260 };
 261
 262 static int gdb_signal_table[] = {
 263     -1,
 264     -1,
 265     TARGET_SIGINT,
 266     -1,
 267     -1,
 268     TARGET_SIGTRAP
 269 };
 270 #endif
 271
 272 #ifdef CONFIG_USER_ONLY
 273 static int target_signal_to_gdb (int sig)
 274 {
 275     int i;
 276     for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
 277         if (gdb_signal_table[i] == sig)
 278             return i;
 279     return GDB_SIGNAL_UNKNOWN;
 280 }
 281 #endif
 282
 283 static int gdb_signal_to_target (int sig)
 284 {
 285     if (sig < ARRAY_SIZE (gdb_signal_table))
 286         return gdb_signal_table[sig];
 287     else
 288         return -1;
 289 }
 290
 291 typedef struct GDBRegisterState {
 292     int base_reg;
 293     int num_regs;
 294     gdb_reg_cb get_reg;
 295     gdb_reg_cb set_reg;
 296     const char *xml;
 297     struct GDBRegisterState *next;
 298 } GDBRegisterState;
 299
 300 typedef struct GDBProcess {
 301     uint32_t pid;
 302     bool attached;
 303
 304     char target_xml[1024];
 305 } GDBProcess;
 306
 307 enum RSState {
 308     RS_INACTIVE,
 309     RS_IDLE,
 310     RS_GETLINE,
 311     RS_GETLINE_ESC,
 312     RS_GETLINE_RLE,
 313     RS_CHKSUM1,
 314     RS_CHKSUM2,
 315 };
 316 typedef struct GDBState {
 317     CPUState *c_cpu; /* current CPU for step/continue ops */
 318     CPUState *g_cpu; /* current CPU for other ops */
 319     CPUState *query_cpu; /* for q{f|s}ThreadInfo */
 320     enum RSState state; /* parsing state */
 321     char line_buf[MAX_PACKET_LENGTH];
 322     int line_buf_index;
 323     int line_sum; /* running checksum */
 324     int line_csum; /* checksum at the end of the packet */
 325     uint8_t last_packet[MAX_PACKET_LENGTH + 4];
 326     int last_packet_len;
 327     int signal;
 328 #ifdef CONFIG_USER_ONLY
 329     int fd;
 330     int running_state;
 331 #else
 332     CharBackend chr;
 333     Chardev *mon_chr;
 334 #endif
 335     bool multiprocess;
 336     GDBProcess *processes;
 337     int process_num;
 338     char syscall_buf[256];
 339     gdb_syscall_complete_cb current_syscall_cb;
 340 } GDBState;
 341
 342 /* By default use no IRQs and no timers while single stepping so as to
 343  * make single stepping like an ICE HW step.
 344  */
 345 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
 346
 347 static GDBState *gdbserver_state;
 348
 349 bool gdb_has_xml;
 350
 351 #ifdef CONFIG_USER_ONLY
 352 /* XXX: This is not thread safe.  Do we care?  */
 353 static int gdbserver_fd = -1;
 354
 355 static int get_char(GDBState *s)
 356 {
 357     uint8_t ch;
 358     int ret;
 359
 360     for(;;) {
 361         ret = qemu_recv(s->fd, &ch, 1, 0);
 362         if (ret < 0) {
 363             if (errno == ECONNRESET)
 364                 s->fd = -1;
 365             if (errno != EINTR)
 366                 return -1;
 367         } else if (ret == 0) {
 368             close(s->fd);
 369             s->fd = -1;
 370             return -1;
 371         } else {
 372             break;
 373         }
 374     }
 375     return ch;
 376 }
 377 #endif
 378
 379 static enum {
 380     GDB_SYS_UNKNOWN,
 381     GDB_SYS_ENABLED,
 382     GDB_SYS_DISABLED,
 383 } gdb_syscall_mode;
 384
 385 /* Decide if either remote gdb syscalls or native file IO should be used. */
 386 int use_gdb_syscalls(void)
 387 {
 388     SemihostingTarget target = semihosting_get_target();
 389     if (target == SEMIHOSTING_TARGET_NATIVE) {
 390         /* -semihosting-config target=native */
 391         return false;
 392     } else if (target == SEMIHOSTING_TARGET_GDB) {
 393         /* -semihosting-config target=gdb */
 394         return true;
 395     }
 396
 397     /* -semihosting-config target=auto */
 398     /* On the first call check if gdb is connected and remember. */
 399     if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
 400         gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
 401                                             : GDB_SYS_DISABLED);
 402     }
 403     return gdb_syscall_mode == GDB_SYS_ENABLED;
 404 }
 405
 406 /* Resume execution.  */
 407 static inline void gdb_continue(GDBState *s)
 408 {
 409
 410 #ifdef CONFIG_USER_ONLY
 411     s->running_state = 1;
 412     trace_gdbstub_op_continue();
 413 #else
 414     if (!runstate_needs_reset()) {
 415         trace_gdbstub_op_continue();
 416         vm_start();
 417     }
 418 #endif
 419 }
 420
 421 /*
 422  * Resume execution, per CPU actions. For user-mode emulation it's
 423  * equivalent to gdb_continue.
 424  */
 425 static int gdb_continue_partial(GDBState *s, char *newstates)
 426 {
 427     CPUState *cpu;
 428     int res = 0;
 429 #ifdef CONFIG_USER_ONLY
 430     /*
 431      * This is not exactly accurate, but it's an improvement compared to the
 432      * previous situation, where only one CPU would be single-stepped.
 433      */
 434     CPU_FOREACH(cpu) {
 435         if (newstates[cpu->cpu_index] == 's') {
 436             trace_gdbstub_op_stepping(cpu->cpu_index);
 437             cpu_single_step(cpu, sstep_flags);
 438         }
 439     }
 440     s->running_state = 1;
 441 #else
 442     int flag = 0;
 443
 444     if (!runstate_needs_reset()) {
 445         if (vm_prepare_start()) {
 446             return 0;
 447         }
 448
 449         CPU_FOREACH(cpu) {
 450             switch (newstates[cpu->cpu_index]) {
 451             case 0:
 452             case 1:
 453                 break; /* nothing to do here */
 454             case 's':
 455                 trace_gdbstub_op_stepping(cpu->cpu_index);
 456                 cpu_single_step(cpu, sstep_flags);
 457                 cpu_resume(cpu);
 458                 flag = 1;
 459                 break;
 460             case 'c':
 461                 trace_gdbstub_op_continue_cpu(cpu->cpu_index);
 462                 cpu_resume(cpu);
 463                 flag = 1;
 464                 break;
 465             default:
 466                 res = -1;
 467                 break;
 468             }
 469         }
 470     }
 471     if (flag) {
 472         qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
 473     }
 474 #endif
 475     return res;
 476 }
 477
 478 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
 479 {
 480 #ifdef CONFIG_USER_ONLY
 481     int ret;
 482
 483     while (len > 0) {
 484         ret = send(s->fd, buf, len, 0);
 485         if (ret < 0) {
 486             if (errno != EINTR)
 487                 return;
 488         } else {
 489             buf += ret;
 490             len -= ret;
 491         }
 492     }
 493 #else
 494     /* XXX this blocks entire thread. Rewrite to use
 495      * qemu_chr_fe_write and background I/O callbacks */
 496     qemu_chr_fe_write_all(&s->chr, buf, len);
 497 #endif
 498 }
 499
 500 static inline int fromhex(int v)
 501 {
 502     if (v >= '0' && v <= '9')
 503         return v - '0';
 504     else if (v >= 'A' && v <= 'F')
 505         return v - 'A' + 10;
 506     else if (v >= 'a' && v <= 'f')
 507         return v - 'a' + 10;
 508     else
 509         return 0;
 510 }
 511
 512 static inline int tohex(int v)
 513 {
 514     if (v < 10)
 515         return v + '0';
 516     else
 517         return v - 10 + 'a';
 518 }
 519
 520 /* writes 2*len+1 bytes in buf */
 521 static void memtohex(char *buf, const uint8_t *mem, int len)
 522 {
 523     int i, c;
 524     char *q;
 525     q = buf;
 526     for(i = 0; i < len; i++) {
 527         c = mem[i];
 528         *q++ = tohex(c >> 4);
 529         *q++ = tohex(c & 0xf);
 530     }
 531     *q = '\0';
 532 }
 533
 534 static void hextomem(uint8_t *mem, const char *buf, int len)
 535 {
 536     int i;
 537
 538     for(i = 0; i < len; i++) {
 539         mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
 540         buf += 2;
 541     }
 542 }
 543
 544 static void hexdump(const char *buf, int len,
 545                     void (*trace_fn)(size_t ofs, char const *text))
 546 {
 547     char line_buffer[3 * 16 + 4 + 16 + 1];
 548
 549     size_t i;
 550     for (i = 0; i < len || (i & 0xF); ++i) {
 551         size_t byte_ofs = i & 15;
 552
 553         if (byte_ofs == 0) {
 554             memset(line_buffer, ' ', 3 * 16 + 4 + 16);
 555             line_buffer[3 * 16 + 4 + 16] = 0;
 556         }
 557
 558         size_t col_group = (i >> 2) & 3;
 559         size_t hex_col = byte_ofs * 3 + col_group;
 560         size_t txt_col = 3 * 16 + 4 + byte_ofs;
 561
 562         if (i < len) {
 563             char value = buf[i];
 564
 565             line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
 566             line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
 567             line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
 568                     ? value
 569                     : '.';
 570         }
 571
 572         if (byte_ofs == 0xF)
 573             trace_fn(i & -16, line_buffer);
 574     }
 575 }
 576
 577 /* return -1 if error, 0 if OK */
 578 static int put_packet_binary(GDBState *s, const char *buf, int len, bool dump)
 579 {
 580     int csum, i;
 581     uint8_t *p;
 582
 583     if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
 584         hexdump(buf, len, trace_gdbstub_io_binaryreply);
 585     }
 586
 587     for(;;) {
 588         p = s->last_packet;
 589         *(p++) = '$';
 590         memcpy(p, buf, len);
 591         p += len;
 592         csum = 0;
 593         for(i = 0; i < len; i++) {
 594             csum += buf[i];
 595         }
 596         *(p++) = '#';
 597         *(p++) = tohex((csum >> 4) & 0xf);
 598         *(p++) = tohex((csum) & 0xf);
 599
 600         s->last_packet_len = p - s->last_packet;
 601         put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
 602
 603 #ifdef CONFIG_USER_ONLY
 604         i = get_char(s);
 605         if (i < 0)
 606             return -1;
 607         if (i == '+')
 608             break;
 609 #else
 610         break;
 611 #endif
 612     }
 613     return 0;
 614 }
 615
 616 /* return -1 if error, 0 if OK */
 617 static int put_packet(GDBState *s, const char *buf)
 618 {
 619     trace_gdbstub_io_reply(buf);
 620
 621     return put_packet_binary(s, buf, strlen(buf), false);
 622 }
 623
 624 /* Encode data using the encoding for 'x' packets.  */
 625 static int memtox(char *buf, const char *mem, int len)
 626 {
 627     char *p = buf;
 628     char c;
 629
 630     while (len--) {
 631         c = *(mem++);
 632         switch (c) {
 633         case '#': case '$': case '*': case '}':
 634             *(p++) = '}';
 635             *(p++) = c ^ 0x20;
 636             break;
 637         default:
 638             *(p++) = c;
 639             break;
 640         }
 641     }
 642     return p - buf;
 643 }
 644
 645 static uint32_t gdb_get_cpu_pid(const GDBState *s, CPUState *cpu)
 646 {
 647 #ifndef CONFIG_USER_ONLY
 648     gchar *path, *name = NULL;
 649     Object *obj;
 650     CPUClusterState *cluster;
 651     uint32_t ret;
 652
 653     path = object_get_canonical_path(OBJECT(cpu));
 654
 655     if (path == NULL) {
 656         /* Return the default process' PID */
 657         ret = s->processes[s->process_num - 1].pid;
 658         goto out;
 659     }
 660
 661     name = object_get_canonical_path_component(OBJECT(cpu));
 662     assert(name != NULL);
 663
 664     /*
 665      * Retrieve the CPU parent path by removing the last '/' and the CPU name
 666      * from the CPU canonical path.
 667      */
 668     path[strlen(path) - strlen(name) - 1] = '\0';
 669
 670     obj = object_resolve_path_type(path, TYPE_CPU_CLUSTER, NULL);
 671
 672     if (obj == NULL) {
 673         /* Return the default process' PID */
 674         ret = s->processes[s->process_num - 1].pid;
 675         goto out;
 676     }
 677
 678     cluster = CPU_CLUSTER(obj);
 679     ret = cluster->cluster_id + 1;
 680
 681 out:
 682     g_free(name);
 683     g_free(path);
 684
 685     return ret;
 686
 687 #else
 688     /* TODO: In user mode, we should use the task state PID */
 689     return s->processes[s->process_num - 1].pid;
 690 #endif
 691 }
 692
 693 static GDBProcess *gdb_get_process(const GDBState *s, uint32_t pid)
 694 {
 695     int i;
 696
 697     if (!pid) {
 698         /* 0 means any process, we take the first one */
 699         return &s->processes[0];
 700     }
 701
 702     for (i = 0; i < s->process_num; i++) {
 703         if (s->processes[i].pid == pid) {
 704             return &s->processes[i];
 705         }
 706     }
 707
 708     return NULL;
 709 }
 710
 711 static GDBProcess *gdb_get_cpu_process(const GDBState *s, CPUState *cpu)
 712 {
 713     return gdb_get_process(s, gdb_get_cpu_pid(s, cpu));
 714 }
 715
 716 static CPUState *find_cpu(uint32_t thread_id)
 717 {
 718     CPUState *cpu;
 719
 720     CPU_FOREACH(cpu) {
 721         if (cpu_gdb_index(cpu) == thread_id) {
 722             return cpu;
 723         }
 724     }
 725
 726     return NULL;
 727 }
 728
 729 static CPUState *get_first_cpu_in_process(const GDBState *s,
 730                                           GDBProcess *process)
 731 {
 732     CPUState *cpu;
 733
 734     CPU_FOREACH(cpu) {
 735         if (gdb_get_cpu_pid(s, cpu) == process->pid) {
 736             return cpu;
 737         }
 738     }
 739
 740     return NULL;
 741 }
 742
 743 static CPUState *gdb_next_cpu_in_process(const GDBState *s, CPUState *cpu)
 744 {
 745     uint32_t pid = gdb_get_cpu_pid(s, cpu);
 746     cpu = CPU_NEXT(cpu);
 747
 748     while (cpu) {
 749         if (gdb_get_cpu_pid(s, cpu) == pid) {
 750             break;
 751         }
 752
 753         cpu = CPU_NEXT(cpu);
 754     }
 755
 756     return cpu;
 757 }
 758
 759 static CPUState *gdb_get_cpu(const GDBState *s, uint32_t pid, uint32_t tid)
 760 {
 761     GDBProcess *process;
 762     CPUState *cpu;
 763
 764     if (!tid) {
 765         /* 0 means any thread, we take the first one */
 766         tid = 1;
 767     }
 768
 769     cpu = find_cpu(tid);
 770
 771     if (cpu == NULL) {
 772         return NULL;
 773     }
 774
 775     process = gdb_get_cpu_process(s, cpu);
 776
 777     if (process->pid != pid) {
 778         return NULL;
 779     }
 780
 781     if (!process->attached) {
 782         return NULL;
 783     }
 784
 785     return cpu;
 786 }
 787
 788 /* Return the cpu following @cpu, while ignoring unattached processes. */
 789 static CPUState *gdb_next_attached_cpu(const GDBState *s, CPUState *cpu)
 790 {
 791     cpu = CPU_NEXT(cpu);
 792
 793     while (cpu) {
 794         if (gdb_get_cpu_process(s, cpu)->attached) {
 795             break;
 796         }
 797
 798         cpu = CPU_NEXT(cpu);
 799     }
 800
 801     return cpu;
 802 }
 803
 804 /* Return the first attached cpu */
 805 static CPUState *gdb_first_attached_cpu(const GDBState *s)
 806 {
 807     CPUState *cpu = first_cpu;
 808     GDBProcess *process = gdb_get_cpu_process(s, cpu);
 809
 810     if (!process->attached) {
 811         return gdb_next_attached_cpu(s, cpu);
 812     }
 813
 814     return cpu;
 815 }
 816
 817 static const char *get_feature_xml(const GDBState *s, const char *p,
 818                                    const char **newp, GDBProcess *process)
 819 {
 820     size_t len;
 821     int i;
 822     const char *name;
 823     CPUState *cpu = get_first_cpu_in_process(s, process);
 824     CPUClass *cc = CPU_GET_CLASS(cpu);
 825
 826     len = 0;
 827     while (p[len] && p[len] != ':')
 828         len++;
 829     *newp = p + len;
 830
 831     name = NULL;
 832     if (strncmp(p, "target.xml", len) == 0) {
 833         char *buf = process->target_xml;
 834         const size_t buf_sz = sizeof(process->target_xml);
 835
 836         /* Generate the XML description for this CPU.  */
 837         if (!buf[0]) {
 838             GDBRegisterState *r;
 839
 840             pstrcat(buf, buf_sz,
 841                     "<?xml version=\"1.0\"?>"
 842                     "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
 843                     "<target>");
 844             if (cc->gdb_arch_name) {
 845                 gchar *arch = cc->gdb_arch_name(cpu);
 846                 pstrcat(buf, buf_sz, "<architecture>");
 847                 pstrcat(buf, buf_sz, arch);
 848                 pstrcat(buf, buf_sz, "</architecture>");
 849                 g_free(arch);
 850             }
 851             pstrcat(buf, buf_sz, "<xi:include href=\"");
 852             pstrcat(buf, buf_sz, cc->gdb_core_xml_file);
 853             pstrcat(buf, buf_sz, "\"/>");
 854             for (r = cpu->gdb_regs; r; r = r->next) {
 855                 pstrcat(buf, buf_sz, "<xi:include href=\"");
 856                 pstrcat(buf, buf_sz, r->xml);
 857                 pstrcat(buf, buf_sz, "\"/>");
 858             }
 859             pstrcat(buf, buf_sz, "</target>");
 860         }
 861         return buf;
 862     }
 863     if (cc->gdb_get_dynamic_xml) {
 864         char *xmlname = g_strndup(p, len);
 865         const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname);
 866
 867         g_free(xmlname);
 868         if (xml) {
 869             return xml;
 870         }
 871     }
 872     for (i = 0; ; i++) {
 873         name = xml_builtin[i][0];
 874         if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
 875             break;
 876     }
 877     return name ? xml_builtin[i][1] : NULL;
 878 }
 879
 880 static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
 881 {
 882     CPUClass *cc = CPU_GET_CLASS(cpu);
 883     CPUArchState *env = cpu->env_ptr;
 884     GDBRegisterState *r;
 885
 886     if (reg < cc->gdb_num_core_regs) {
 887         return cc->gdb_read_register(cpu, mem_buf, reg);
 888     }
 889
 890     for (r = cpu->gdb_regs; r; r = r->next) {
 891         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
 892             return r->get_reg(env, mem_buf, reg - r->base_reg);
 893         }
 894     }
 895     return 0;
 896 }
 897
 898 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
 899 {
 900     CPUClass *cc = CPU_GET_CLASS(cpu);
 901     CPUArchState *env = cpu->env_ptr;
 902     GDBRegisterState *r;
 903
 904     if (reg < cc->gdb_num_core_regs) {
 905         return cc->gdb_write_register(cpu, mem_buf, reg);
 906     }
 907
 908     for (r = cpu->gdb_regs; r; r = r->next) {
 909         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
 910             return r->set_reg(env, mem_buf, reg - r->base_reg);
 911         }
 912     }
 913     return 0;
 914 }
 915
 916 /* Register a supplemental set of CPU registers.  If g_pos is nonzero it
 917    specifies the first register number and these registers are included in
 918    a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is
 919    gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
 920  */
 921
 922 void gdb_register_coprocessor(CPUState *cpu,
 923                               gdb_reg_cb get_reg, gdb_reg_cb set_reg,
 924                               int num_regs, const char *xml, int g_pos)
 925 {
 926     GDBRegisterState *s;
 927     GDBRegisterState **p;
 928
 929     p = &cpu->gdb_regs;
 930     while (*p) {
 931         /* Check for duplicates.  */
 932         if (strcmp((*p)->xml, xml) == 0)
 933             return;
 934         p = &(*p)->next;
 935     }
 936
 937     s = g_new0(GDBRegisterState, 1);
 938     s->base_reg = cpu->gdb_num_regs;
 939     s->num_regs = num_regs;
 940     s->get_reg = get_reg;
 941     s->set_reg = set_reg;
 942     s->xml = xml;
 943
 944     /* Add to end of list.  */
 945     cpu->gdb_num_regs += num_regs;
 946     *p = s;
 947     if (g_pos) {
 948         if (g_pos != s->base_reg) {
 949             error_report("Error: Bad gdb register numbering for '%s', "
 950                          "expected %d got %d", xml, g_pos, s->base_reg);
 951         } else {
 952             cpu->gdb_num_g_regs = cpu->gdb_num_regs;
 953         }
 954     }
 955 }
 956
 957 #ifndef CONFIG_USER_ONLY
 958 /* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
 959 static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
 960 {
 961     static const int xlat[] = {
 962         [GDB_WATCHPOINT_WRITE]  = BP_GDB | BP_MEM_WRITE,
 963         [GDB_WATCHPOINT_READ]   = BP_GDB | BP_MEM_READ,
 964         [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
 965     };
 966
 967     CPUClass *cc = CPU_GET_CLASS(cpu);
 968     int cputype = xlat[gdbtype];
 969
 970     if (cc->gdb_stop_before_watchpoint) {
 971         cputype |= BP_STOP_BEFORE_ACCESS;
 972     }
 973     return cputype;
 974 }
 975 #endif
 976
 977 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
 978 {
 979     CPUState *cpu;
 980     int err = 0;
 981
 982     if (kvm_enabled()) {
 983         return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
 984     }
 985
 986     switch (type) {
 987     case GDB_BREAKPOINT_SW:
 988     case GDB_BREAKPOINT_HW:
 989         CPU_FOREACH(cpu) {
 990             err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
 991             if (err) {
 992                 break;
 993             }
 994         }
 995         return err;
 996 #ifndef CONFIG_USER_ONLY
 997     case GDB_WATCHPOINT_WRITE:
 998     case GDB_WATCHPOINT_READ:
 999     case GDB_WATCHPOINT_ACCESS:
1000         CPU_FOREACH(cpu) {
1001             err = cpu_watchpoint_insert(cpu, addr, len,
1002                                         xlat_gdb_type(cpu, type), NULL);
1003             if (err) {
1004                 break;
1005             }
1006         }
1007         return err;
1008 #endif
1009     default:
1010         return -ENOSYS;
1011     }
1012 }
1013
1014 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
1015 {
1016     CPUState *cpu;
1017     int err = 0;
1018
1019     if (kvm_enabled()) {
1020         return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
1021     }
1022
1023     switch (type) {
1024     case GDB_BREAKPOINT_SW:
1025     case GDB_BREAKPOINT_HW:
1026         CPU_FOREACH(cpu) {
1027             err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
1028             if (err) {
1029                 break;
1030             }
1031         }
1032         return err;
1033 #ifndef CONFIG_USER_ONLY
1034     case GDB_WATCHPOINT_WRITE:
1035     case GDB_WATCHPOINT_READ:
1036     case GDB_WATCHPOINT_ACCESS:
1037         CPU_FOREACH(cpu) {
1038             err = cpu_watchpoint_remove(cpu, addr, len,
1039                                         xlat_gdb_type(cpu, type));
1040             if (err)
1041                 break;
1042         }
1043         return err;
1044 #endif
1045     default:
1046         return -ENOSYS;
1047     }
1048 }
1049
1050 static inline void gdb_cpu_breakpoint_remove_all(CPUState *cpu)
1051 {
1052     cpu_breakpoint_remove_all(cpu, BP_GDB);
1053 #ifndef CONFIG_USER_ONLY
1054     cpu_watchpoint_remove_all(cpu, BP_GDB);
1055 #endif
1056 }
1057
1058 static void gdb_process_breakpoint_remove_all(const GDBState *s, GDBProcess *p)
1059 {
1060     CPUState *cpu = get_first_cpu_in_process(s, p);
1061
1062     while (cpu) {
1063         gdb_cpu_breakpoint_remove_all(cpu);
1064         cpu = gdb_next_cpu_in_process(s, cpu);
1065     }
1066 }
1067
1068 static void gdb_breakpoint_remove_all(void)
1069 {
1070     CPUState *cpu;
1071
1072     if (kvm_enabled()) {
1073         kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
1074         return;
1075     }
1076
1077     CPU_FOREACH(cpu) {
1078         gdb_cpu_breakpoint_remove_all(cpu);
1079     }
1080 }
1081
1082 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
1083 {
1084     CPUState *cpu = s->c_cpu;
1085
1086     cpu_synchronize_state(cpu);
1087     cpu_set_pc(cpu, pc);
1088 }
1089
1090 static char *gdb_fmt_thread_id(const GDBState *s, CPUState *cpu,
1091                            char *buf, size_t buf_size)
1092 {
1093     if (s->multiprocess) {
1094         snprintf(buf, buf_size, "p%02x.%02x",
1095                  gdb_get_cpu_pid(s, cpu), cpu_gdb_index(cpu));
1096     } else {
1097         snprintf(buf, buf_size, "%02x", cpu_gdb_index(cpu));
1098     }
1099
1100     return buf;
1101 }
1102
1103 typedef enum GDBThreadIdKind {
1104     GDB_ONE_THREAD = 0,
1105     GDB_ALL_THREADS,     /* One process, all threads */
1106     GDB_ALL_PROCESSES,
1107     GDB_READ_THREAD_ERR
1108 } GDBThreadIdKind;
1109
1110 static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
1111                                       uint32_t *pid, uint32_t *tid)
1112 {
1113     unsigned long p, t;
1114     int ret;
1115
1116     if (*buf == 'p') {
1117         buf++;
1118         ret = qemu_strtoul(buf, &buf, 16, &p);
1119
1120         if (ret) {
1121             return GDB_READ_THREAD_ERR;
1122         }
1123
1124         /* Skip '.' */
1125         buf++;
1126     } else {
1127         p = 1;
1128     }
1129
1130     ret = qemu_strtoul(buf, &buf, 16, &t);
1131
1132     if (ret) {
1133         return GDB_READ_THREAD_ERR;
1134     }
1135
1136     *end_buf = buf;
1137
1138     if (p == -1) {
1139         return GDB_ALL_PROCESSES;
1140     }
1141
1142     if (pid) {
1143         *pid = p;
1144     }
1145
1146     if (t == -1) {
1147         return GDB_ALL_THREADS;
1148     }
1149
1150     if (tid) {
1151         *tid = t;
1152     }
1153
1154     return GDB_ONE_THREAD;
1155 }
1156
1157 static int is_query_packet(const char *p, const char *query, char separator)
1158 {
1159     unsigned int query_len = strlen(query);
1160
1161     return strncmp(p, query, query_len) == 0 &&
1162         (p[query_len] == '\0' || p[query_len] == separator);
1163 }
1164
1165 /**
1166  * gdb_handle_vcont - Parses and handles a vCont packet.
1167  * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
1168  *         a format error, 0 on success.
1169  */
1170 static int gdb_handle_vcont(GDBState *s, const char *p)
1171 {
1172     int res, signal = 0;
1173     char cur_action;
1174     char *newstates;
1175     unsigned long tmp;
1176     uint32_t pid, tid;
1177     GDBProcess *process;
1178     CPUState *cpu;
1179 #ifdef CONFIG_USER_ONLY
1180     int max_cpus = 1; /* global variable max_cpus exists only in system mode */
1181
1182     CPU_FOREACH(cpu) {
1183         max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
1184     }
1185 #endif
1186     /* uninitialised CPUs stay 0 */
1187     newstates = g_new0(char, max_cpus);
1188
1189     /* mark valid CPUs with 1 */
1190     CPU_FOREACH(cpu) {
1191         newstates[cpu->cpu_index] = 1;
1192     }
1193
1194     /*
1195      * res keeps track of what error we are returning, with -ENOTSUP meaning
1196      * that the command is unknown or unsupported, thus returning an empty
1197      * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
1198      *  or incorrect parameters passed.
1199      */
1200     res = 0;
1201     while (*p) {
1202         if (*p++ != ';') {
1203             res = -ENOTSUP;
1204             goto out;
1205         }
1206
1207         cur_action = *p++;
1208         if (cur_action == 'C' || cur_action == 'S') {
1209             cur_action = qemu_tolower(cur_action);
1210             res = qemu_strtoul(p + 1, &p, 16, &tmp);
1211             if (res) {
1212                 goto out;
1213             }
1214             signal = gdb_signal_to_target(tmp);
1215         } else if (cur_action != 'c' && cur_action != 's') {
1216             /* unknown/invalid/unsupported command */
1217             res = -ENOTSUP;
1218             goto out;
1219         }
1220
1221         if (*p++ != ':') {
1222             res = -ENOTSUP;
1223             goto out;
1224         }
1225
1226         switch (read_thread_id(p, &p, &pid, &tid)) {
1227         case GDB_READ_THREAD_ERR:
1228             res = -EINVAL;
1229             goto out;
1230
1231         case GDB_ALL_PROCESSES:
1232             cpu = gdb_first_attached_cpu(s);
1233             while (cpu) {
1234                 if (newstates[cpu->cpu_index] == 1) {
1235                     newstates[cpu->cpu_index] = cur_action;
1236                 }
1237
1238                 cpu = gdb_next_attached_cpu(s, cpu);
1239             }
1240             break;
1241
1242         case GDB_ALL_THREADS:
1243             process = gdb_get_process(s, pid);
1244
1245             if (!process->attached) {
1246                 res = -EINVAL;
1247                 goto out;
1248             }
1249
1250             cpu = get_first_cpu_in_process(s, process);
1251             while (cpu) {
1252                 if (newstates[cpu->cpu_index] == 1) {
1253                     newstates[cpu->cpu_index] = cur_action;
1254                 }
1255
1256                 cpu = gdb_next_cpu_in_process(s, cpu);
1257             }
1258             break;
1259
1260         case GDB_ONE_THREAD:
1261             cpu = gdb_get_cpu(s, pid, tid);
1262
1263             /* invalid CPU/thread specified */
1264             if (!cpu) {
1265                 res = -EINVAL;
1266                 goto out;
1267             }
1268
1269             /* only use if no previous match occourred */
1270             if (newstates[cpu->cpu_index] == 1) {
1271                 newstates[cpu->cpu_index] = cur_action;
1272             }
1273             break;
1274         }
1275     }
1276     s->signal = signal;
1277     gdb_continue_partial(s, newstates);
1278
1279 out:
1280     g_free(newstates);
1281
1282     return res;
1283 }
1284
1285 static int gdb_handle_packet(GDBState *s, const char *line_buf)
1286 {
1287     CPUState *cpu;
1288     GDBProcess *process;
1289     CPUClass *cc;
1290     const char *p;
1291     uint32_t pid, tid;
1292     int ch, reg_size, type, res;
1293     uint8_t mem_buf[MAX_PACKET_LENGTH];
1294     char buf[sizeof(mem_buf) + 1 /* trailing NUL */];
1295     char thread_id[16];
1296     uint8_t *registers;
1297     target_ulong addr, len;
1298     GDBThreadIdKind thread_kind;
1299
1300     trace_gdbstub_io_command(line_buf);
1301
1302     p = line_buf;
1303     ch = *p++;
1304     switch(ch) {
1305     case '!':
1306         put_packet(s, "OK");
1307         break;
1308     case '?':
1309         /* TODO: Make this return the correct value for user-mode.  */
1310         snprintf(buf, sizeof(buf), "T%02xthread:%s;", GDB_SIGNAL_TRAP,
1311                  gdb_fmt_thread_id(s, s->c_cpu, thread_id, sizeof(thread_id)));
1312         put_packet(s, buf);
1313         /* Remove all the breakpoints when this query is issued,
1314          * because gdb is doing and initial connect and the state
1315          * should be cleaned up.
1316          */
1317         gdb_breakpoint_remove_all();
1318         break;
1319     case 'c':
1320         if (*p != '\0') {
1321             addr = strtoull(p, (char **)&p, 16);
1322             gdb_set_cpu_pc(s, addr);
1323         }
1324         s->signal = 0;
1325         gdb_continue(s);
1326         return RS_IDLE;
1327     case 'C':
1328         s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
1329         if (s->signal == -1)
1330             s->signal = 0;
1331         gdb_continue(s);
1332         return RS_IDLE;
1333     case 'v':
1334         if (strncmp(p, "Cont", 4) == 0) {
1335             p += 4;
1336             if (*p == '?') {
1337                 put_packet(s, "vCont;c;C;s;S");
1338                 break;
1339             }
1340
1341             res = gdb_handle_vcont(s, p);
1342
1343             if (res) {
1344                 if ((res == -EINVAL) || (res == -ERANGE)) {
1345                     put_packet(s, "E22");
1346                     break;
1347                 }
1348                 goto unknown_command;
1349             }
1350             break;
1351         } else if (strncmp(p, "Attach;", 7) == 0) {
1352             unsigned long pid;
1353
1354             p += 7;
1355
1356             if (qemu_strtoul(p, &p, 16, &pid)) {
1357                 put_packet(s, "E22");
1358                 break;
1359             }
1360
1361             process = gdb_get_process(s, pid);
1362
1363             if (process == NULL) {
1364                 put_packet(s, "E22");
1365                 break;
1366             }
1367
1368             cpu = get_first_cpu_in_process(s, process);
1369
1370             if (cpu == NULL) {
1371                 /* Refuse to attach an empty process */
1372                 put_packet(s, "E22");
1373                 break;
1374             }
1375
1376             process->attached = true;
1377
1378             s->g_cpu = cpu;
1379             s->c_cpu = cpu;
1380
1381             snprintf(buf, sizeof(buf), "T%02xthread:%s;", GDB_SIGNAL_TRAP,
1382                      gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id)));
1383
1384             put_packet(s, buf);
1385             break;
1386         } else {
1387             goto unknown_command;
1388         }
1389     case 'k':
1390         /* Kill the target */
1391         error_report("QEMU: Terminated via GDBstub");
1392         exit(0);
1393     case 'D':
1394         /* Detach packet */
1395         pid = 1;
1396
1397         if (s->multiprocess) {
1398             unsigned long lpid;
1399             if (*p != ';') {
1400                 put_packet(s, "E22");
1401                 break;
1402             }
1403
1404             if (qemu_strtoul(p + 1, &p, 16, &lpid)) {
1405                 put_packet(s, "E22");
1406                 break;
1407             }
1408
1409             pid = lpid;
1410         }
1411
1412         process = gdb_get_process(s, pid);
1413         gdb_process_breakpoint_remove_all(s, process);
1414         process->attached = false;
1415
1416         if (pid == gdb_get_cpu_pid(s, s->c_cpu)) {
1417             s->c_cpu = gdb_first_attached_cpu(s);
1418         }
1419
1420         if (pid == gdb_get_cpu_pid(s, s->g_cpu)) {
1421             s->g_cpu = gdb_first_attached_cpu(s);
1422         }
1423
1424         if (s->c_cpu == NULL) {
1425             /* No more process attached */
1426             gdb_syscall_mode = GDB_SYS_DISABLED;
1427             gdb_continue(s);
1428         }
1429         put_packet(s, "OK");
1430         break;
1431     case 's':
1432         if (*p != '\0') {
1433             addr = strtoull(p, (char **)&p, 16);
1434             gdb_set_cpu_pc(s, addr);
1435         }
1436         cpu_single_step(s->c_cpu, sstep_flags);
1437         gdb_continue(s);
1438         return RS_IDLE;
1439     case 'F':
1440         {
1441             target_ulong ret;
1442             target_ulong err;
1443
1444             ret = strtoull(p, (char **)&p, 16);
1445             if (*p == ',') {
1446                 p++;
1447                 err = strtoull(p, (char **)&p, 16);
1448             } else {
1449                 err = 0;
1450             }
1451             if (*p == ',')
1452                 p++;
1453             type = *p;
1454             if (s->current_syscall_cb) {
1455                 s->current_syscall_cb(s->c_cpu, ret, err);
1456                 s->current_syscall_cb = NULL;
1457             }
1458             if (type == 'C') {
1459                 put_packet(s, "T02");
1460             } else {
1461                 gdb_continue(s);
1462             }
1463         }
1464         break;
1465     case 'g':
1466         cpu_synchronize_state(s->g_cpu);
1467         len = 0;
1468         for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
1469             reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
1470             len += reg_size;
1471         }
1472         memtohex(buf, mem_buf, len);
1473         put_packet(s, buf);
1474         break;
1475     case 'G':
1476         cpu_synchronize_state(s->g_cpu);
1477         registers = mem_buf;
1478         len = strlen(p) / 2;
1479         hextomem((uint8_t *)registers, p, len);
1480         for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
1481             reg_size = gdb_write_register(s->g_cpu, registers, addr);
1482             len -= reg_size;
1483             registers += reg_size;
1484         }
1485         put_packet(s, "OK");
1486         break;
1487     case 'm':
1488         addr = strtoull(p, (char **)&p, 16);
1489         if (*p == ',')
1490             p++;
1491         len = strtoull(p, NULL, 16);
1492
1493         /* memtohex() doubles the required space */
1494         if (len > MAX_PACKET_LENGTH / 2) {
1495             put_packet (s, "E22");
1496             break;
1497         }
1498
1499         if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
1500             put_packet (s, "E14");
1501         } else {
1502             memtohex(buf, mem_buf, len);
1503             put_packet(s, buf);
1504         }
1505         break;
1506     case 'M':
1507         addr = strtoull(p, (char **)&p, 16);
1508         if (*p == ',')
1509             p++;
1510         len = strtoull(p, (char **)&p, 16);
1511         if (*p == ':')
1512             p++;
1513
1514         /* hextomem() reads 2*len bytes */
1515         if (len > strlen(p) / 2) {
1516             put_packet (s, "E22");
1517             break;
1518         }
1519         hextomem(mem_buf, p, len);
1520         if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
1521                                    true) != 0) {
1522             put_packet(s, "E14");
1523         } else {
1524             put_packet(s, "OK");
1525         }
1526         break;
1527     case 'p':
1528         /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
1529            This works, but can be very slow.  Anything new enough to
1530            understand XML also knows how to use this properly.  */
1531         if (!gdb_has_xml)
1532             goto unknown_command;
1533         addr = strtoull(p, (char **)&p, 16);
1534         reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
1535         if (reg_size) {
1536             memtohex(buf, mem_buf, reg_size);
1537             put_packet(s, buf);
1538         } else {
1539             put_packet(s, "E14");
1540         }
1541         break;
1542     case 'P':
1543         if (!gdb_has_xml)
1544             goto unknown_command;
1545         addr = strtoull(p, (char **)&p, 16);
1546         if (*p == '=')
1547             p++;
1548         reg_size = strlen(p) / 2;
1549         hextomem(mem_buf, p, reg_size);
1550         gdb_write_register(s->g_cpu, mem_buf, addr);
1551         put_packet(s, "OK");
1552         break;
1553     case 'Z':
1554     case 'z':
1555         type = strtoul(p, (char **)&p, 16);
1556         if (*p == ',')
1557             p++;
1558         addr = strtoull(p, (char **)&p, 16);
1559         if (*p == ',')
1560             p++;
1561         len = strtoull(p, (char **)&p, 16);
1562         if (ch == 'Z')
1563             res = gdb_breakpoint_insert(addr, len, type);
1564         else
1565             res = gdb_breakpoint_remove(addr, len, type);
1566         if (res >= 0)
1567              put_packet(s, "OK");
1568         else if (res == -ENOSYS)
1569             put_packet(s, "");
1570         else
1571             put_packet(s, "E22");
1572         break;
1573     case 'H':
1574         type = *p++;
1575
1576         thread_kind = read_thread_id(p, &p, &pid, &tid);
1577         if (thread_kind == GDB_READ_THREAD_ERR) {
1578             put_packet(s, "E22");
1579             break;
1580         }
1581
1582         if (thread_kind != GDB_ONE_THREAD) {
1583             put_packet(s, "OK");
1584             break;
1585         }
1586         cpu = gdb_get_cpu(s, pid, tid);
1587         if (cpu == NULL) {
1588             put_packet(s, "E22");
1589             break;
1590         }
1591         switch (type) {
1592         case 'c':
1593             s->c_cpu = cpu;
1594             put_packet(s, "OK");
1595             break;
1596         case 'g':
1597             s->g_cpu = cpu;
1598             put_packet(s, "OK");
1599             break;
1600         default:
1601              put_packet(s, "E22");
1602              break;
1603         }
1604         break;
1605     case 'T':
1606         thread_kind = read_thread_id(p, &p, &pid, &tid);
1607         if (thread_kind == GDB_READ_THREAD_ERR) {
1608             put_packet(s, "E22");
1609             break;
1610         }
1611         cpu = gdb_get_cpu(s, pid, tid);
1612
1613         if (cpu != NULL) {
1614             put_packet(s, "OK");
1615         } else {
1616             put_packet(s, "E22");
1617         }
1618         break;
1619     case 'q':
1620     case 'Q':
1621         /* parse any 'q' packets here */
1622         if (!strcmp(p,"qemu.sstepbits")) {
1623             /* Query Breakpoint bit definitions */
1624             snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1625                      SSTEP_ENABLE,
1626                      SSTEP_NOIRQ,
1627                      SSTEP_NOTIMER);
1628             put_packet(s, buf);
1629             break;
1630         } else if (is_query_packet(p, "qemu.sstep", '=')) {
1631             /* Display or change the sstep_flags */
1632             p += 10;
1633             if (*p != '=') {
1634                 /* Display current setting */
1635                 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1636                 put_packet(s, buf);
1637                 break;
1638             }
1639             p++;
1640             type = strtoul(p, (char **)&p, 16);
1641             sstep_flags = type;
1642             put_packet(s, "OK");
1643             break;
1644         } else if (strcmp(p,"C") == 0) {
1645             /*
1646              * "Current thread" remains vague in the spec, so always return
1647              * the first thread of the current process (gdb returns the
1648              * first thread).
1649              */
1650             cpu = get_first_cpu_in_process(s, gdb_get_cpu_process(s, s->g_cpu));
1651             snprintf(buf, sizeof(buf), "QC%s",
1652                      gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id)));
1653             put_packet(s, buf);
1654             break;
1655         } else if (strcmp(p,"fThreadInfo") == 0) {
1656             s->query_cpu = gdb_first_attached_cpu(s);
1657             goto report_cpuinfo;
1658         } else if (strcmp(p,"sThreadInfo") == 0) {
1659         report_cpuinfo:
1660             if (s->query_cpu) {
1661                 snprintf(buf, sizeof(buf), "m%s",
1662                          gdb_fmt_thread_id(s, s->query_cpu,
1663                                        thread_id, sizeof(thread_id)));
1664                 put_packet(s, buf);
1665                 s->query_cpu = gdb_next_attached_cpu(s, s->query_cpu);
1666             } else
1667                 put_packet(s, "l");
1668             break;
1669         } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1670             if (read_thread_id(p + 16, &p, &pid, &tid) == GDB_READ_THREAD_ERR) {
1671                 put_packet(s, "E22");
1672                 break;
1673             }
1674             cpu = gdb_get_cpu(s, pid, tid);
1675             if (cpu != NULL) {
1676                 cpu_synchronize_state(cpu);
1677
1678                 if (s->multiprocess && (s->process_num > 1)) {
1679                     /* Print the CPU model and name in multiprocess mode */
1680                     ObjectClass *oc = object_get_class(OBJECT(cpu));
1681                     const char *cpu_model = object_class_get_name(oc);
1682                     char *cpu_name =
1683                         object_get_canonical_path_component(OBJECT(cpu));
1684                     len = snprintf((char *)mem_buf, sizeof(buf) / 2,
1685                                    "%s %s [%s]", cpu_model, cpu_name,
1686                                    cpu->halted ? "halted " : "running");
1687                     g_free(cpu_name);
1688                 } else {
1689                     /* memtohex() doubles the required space */
1690                     len = snprintf((char *)mem_buf, sizeof(buf) / 2,
1691                                    "CPU#%d [%s]", cpu->cpu_index,
1692                                    cpu->halted ? "halted " : "running");
1693                 }
1694                 trace_gdbstub_op_extra_info((char *)mem_buf);
1695                 memtohex(buf, mem_buf, len);
1696                 put_packet(s, buf);
1697             }
1698             break;
1699         }
1700 #ifdef CONFIG_USER_ONLY
1701         else if (strcmp(p, "Offsets") == 0) {
1702             TaskState *ts = s->c_cpu->opaque;
1703
1704             snprintf(buf, sizeof(buf),
1705                      "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1706                      ";Bss=" TARGET_ABI_FMT_lx,
1707                      ts->info->code_offset,
1708                      ts->info->data_offset,
1709                      ts->info->data_offset);
1710             put_packet(s, buf);
1711             break;
1712         }
1713 #else /* !CONFIG_USER_ONLY */
1714         else if (strncmp(p, "Rcmd,", 5) == 0) {
1715             int len = strlen(p + 5);
1716
1717             if ((len % 2) != 0) {
1718                 put_packet(s, "E01");
1719                 break;
1720             }
1721             len = len / 2;
1722             hextomem(mem_buf, p + 5, len);
1723             mem_buf[len++] = 0;
1724             qemu_chr_be_write(s->mon_chr, mem_buf, len);
1725             put_packet(s, "OK");
1726             break;
1727         }
1728 #endif /* !CONFIG_USER_ONLY */
1729         if (is_query_packet(p, "Supported", ':')) {
1730             snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1731             cc = CPU_GET_CLASS(first_cpu);
1732             if (cc->gdb_core_xml_file != NULL) {
1733                 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1734             }
1735
1736             if (strstr(p, "multiprocess+")) {
1737                 s->multiprocess = true;
1738             }
1739             pstrcat(buf, sizeof(buf), ";multiprocess+");
1740
1741             put_packet(s, buf);
1742             break;
1743         }
1744         if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1745             const char *xml;
1746             target_ulong total_len;
1747
1748             process = gdb_get_cpu_process(s, s->g_cpu);
1749             cc = CPU_GET_CLASS(s->g_cpu);
1750             if (cc->gdb_core_xml_file == NULL) {
1751                 goto unknown_command;
1752             }
1753
1754             gdb_has_xml = true;
1755             p += 19;
1756             xml = get_feature_xml(s, p, &p, process);
1757             if (!xml) {
1758                 snprintf(buf, sizeof(buf), "E00");
1759                 put_packet(s, buf);
1760                 break;
1761             }
1762
1763             if (*p == ':')
1764                 p++;
1765             addr = strtoul(p, (char **)&p, 16);
1766             if (*p == ',')
1767                 p++;
1768             len = strtoul(p, (char **)&p, 16);
1769
1770             total_len = strlen(xml);
1771             if (addr > total_len) {
1772                 snprintf(buf, sizeof(buf), "E00");
1773                 put_packet(s, buf);
1774                 break;
1775             }
1776             if (len > (MAX_PACKET_LENGTH - 5) / 2)
1777                 len = (MAX_PACKET_LENGTH - 5) / 2;
1778             if (len < total_len - addr) {
1779                 buf[0] = 'm';
1780                 len = memtox(buf + 1, xml + addr, len);
1781             } else {
1782                 buf[0] = 'l';
1783                 len = memtox(buf + 1, xml + addr, total_len - addr);
1784             }
1785             put_packet_binary(s, buf, len + 1, true);
1786             break;
1787         }
1788         if (is_query_packet(p, "Attached", ':')) {
1789             put_packet(s, GDB_ATTACHED);
1790             break;
1791         }
1792         /* Unrecognised 'q' command.  */
1793         goto unknown_command;
1794
1795     default:
1796     unknown_command:
1797         /* put empty packet */
1798         buf[0] = '\0';
1799         put_packet(s, buf);
1800         break;
1801     }
1802     return RS_IDLE;
1803 }
1804
1805 void gdb_set_stop_cpu(CPUState *cpu)
1806 {
1807     GDBProcess *p = gdb_get_cpu_process(gdbserver_state, cpu);
1808
1809     if (!p->attached) {
1810         /*
1811          * Having a stop CPU corresponding to a process that is not attached
1812          * confuses GDB. So we ignore the request.
1813          */
1814         return;
1815     }
1816
1817     gdbserver_state->c_cpu = cpu;
1818     gdbserver_state->g_cpu = cpu;
1819 }
1820
1821 #ifndef CONFIG_USER_ONLY
1822 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1823 {
1824     GDBState *s = gdbserver_state;
1825     CPUState *cpu = s->c_cpu;
1826     char buf[256];
1827     char thread_id[16];
1828     const char *type;
1829     int ret;
1830
1831     if (running || s->state == RS_INACTIVE) {
1832         return;
1833     }
1834     /* Is there a GDB syscall waiting to be sent?  */
1835     if (s->current_syscall_cb) {
1836         put_packet(s, s->syscall_buf);
1837         return;
1838     }
1839
1840     if (cpu == NULL) {
1841         /* No process attached */
1842         return;
1843     }
1844
1845     gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id));
1846
1847     switch (state) {
1848     case RUN_STATE_DEBUG:
1849         if (cpu->watchpoint_hit) {
1850             switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
1851             case BP_MEM_READ:
1852                 type = "r";
1853                 break;
1854             case BP_MEM_ACCESS:
1855                 type = "a";
1856                 break;
1857             default:
1858                 type = "";
1859                 break;
1860             }
1861             trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
1862                     (target_ulong)cpu->watchpoint_hit->vaddr);
1863             snprintf(buf, sizeof(buf),
1864                      "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";",
1865                      GDB_SIGNAL_TRAP, thread_id, type,
1866                      (target_ulong)cpu->watchpoint_hit->vaddr);
1867             cpu->watchpoint_hit = NULL;
1868             goto send_packet;
1869         } else {
1870             trace_gdbstub_hit_break();
1871         }
1872         tb_flush(cpu);
1873         ret = GDB_SIGNAL_TRAP;
1874         break;
1875     case RUN_STATE_PAUSED:
1876         trace_gdbstub_hit_paused();
1877         ret = GDB_SIGNAL_INT;
1878         break;
1879     case RUN_STATE_SHUTDOWN:
1880         trace_gdbstub_hit_shutdown();
1881         ret = GDB_SIGNAL_QUIT;
1882         break;
1883     case RUN_STATE_IO_ERROR:
1884         trace_gdbstub_hit_io_error();
1885         ret = GDB_SIGNAL_IO;
1886         break;
1887     case RUN_STATE_WATCHDOG:
1888         trace_gdbstub_hit_watchdog();
1889         ret = GDB_SIGNAL_ALRM;
1890         break;
1891     case RUN_STATE_INTERNAL_ERROR:
1892         trace_gdbstub_hit_internal_error();
1893         ret = GDB_SIGNAL_ABRT;
1894         break;
1895     case RUN_STATE_SAVE_VM:
1896     case RUN_STATE_RESTORE_VM:
1897         return;
1898     case RUN_STATE_FINISH_MIGRATE:
1899         ret = GDB_SIGNAL_XCPU;
1900         break;
1901     default:
1902         trace_gdbstub_hit_unknown(state);
1903         ret = GDB_SIGNAL_UNKNOWN;
1904         break;
1905     }
1906     gdb_set_stop_cpu(cpu);
1907     snprintf(buf, sizeof(buf), "T%02xthread:%s;", ret, thread_id);
1908
1909 send_packet:
1910     put_packet(s, buf);
1911
1912     /* disable single step if it was enabled */
1913     cpu_single_step(cpu, 0);
1914 }
1915 #endif
1916
1917 /* Send a gdb syscall request.
1918    This accepts limited printf-style format specifiers, specifically:
1919     %x  - target_ulong argument printed in hex.
1920     %lx - 64-bit argument printed in hex.
1921     %s  - string pointer (target_ulong) and length (int) pair.  */
1922 void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
1923 {
1924     char *p;
1925     char *p_end;
1926     target_ulong addr;
1927     uint64_t i64;
1928     GDBState *s;
1929
1930     s = gdbserver_state;
1931     if (!s)
1932         return;
1933     s->current_syscall_cb = cb;
1934 #ifndef CONFIG_USER_ONLY
1935     vm_stop(RUN_STATE_DEBUG);
1936 #endif
1937     p = s->syscall_buf;
1938     p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1939     *(p++) = 'F';
1940     while (*fmt) {
1941         if (*fmt == '%') {
1942             fmt++;
1943             switch (*fmt++) {
1944             case 'x':
1945                 addr = va_arg(va, target_ulong);
1946                 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1947                 break;
1948             case 'l':
1949                 if (*(fmt++) != 'x')
1950                     goto bad_format;
1951                 i64 = va_arg(va, uint64_t);
1952                 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1953                 break;
1954             case 's':
1955                 addr = va_arg(va, target_ulong);
1956                 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1957                               addr, va_arg(va, int));
1958                 break;
1959             default:
1960             bad_format:
1961                 error_report("gdbstub: Bad syscall format string '%s'",
1962                              fmt - 1);
1963                 break;
1964             }
1965         } else {
1966             *(p++) = *(fmt++);
1967         }
1968     }
1969     *p = 0;
1970 #ifdef CONFIG_USER_ONLY
1971     put_packet(s, s->syscall_buf);
1972     /* Return control to gdb for it to process the syscall request.
1973      * Since the protocol requires that gdb hands control back to us
1974      * using a "here are the results" F packet, we don't need to check
1975      * gdb_handlesig's return value (which is the signal to deliver if
1976      * execution was resumed via a continue packet).
1977      */
1978     gdb_handlesig(s->c_cpu, 0);
1979 #else
1980     /* In this case wait to send the syscall packet until notification that
1981        the CPU has stopped.  This must be done because if the packet is sent
1982        now the reply from the syscall request could be received while the CPU
1983        is still in the running state, which can cause packets to be dropped
1984        and state transition 'T' packets to be sent while the syscall is still
1985        being processed.  */
1986     qemu_cpu_kick(s->c_cpu);
1987 #endif
1988 }
1989
1990 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1991 {
1992     va_list va;
1993
1994     va_start(va, fmt);
1995     gdb_do_syscallv(cb, fmt, va);
1996     va_end(va);
1997 }
1998
1999 static void gdb_read_byte(GDBState *s, int ch)
2000 {
2001     uint8_t reply;
2002
2003 #ifndef CONFIG_USER_ONLY
2004     if (s->last_packet_len) {
2005         /* Waiting for a response to the last packet.  If we see the start
2006            of a new command then abandon the previous response.  */
2007         if (ch == '-') {
2008             trace_gdbstub_err_got_nack();
2009             put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
2010         } else if (ch == '+') {
2011             trace_gdbstub_io_got_ack();
2012         } else {
2013             trace_gdbstub_io_got_unexpected((uint8_t)ch);
2014         }
2015
2016         if (ch == '+' || ch == '$')
2017             s->last_packet_len = 0;
2018         if (ch != '$')
2019             return;
2020     }
2021     if (runstate_is_running()) {
2022         /* when the CPU is running, we cannot do anything except stop
2023            it when receiving a char */
2024         vm_stop(RUN_STATE_PAUSED);
2025     } else
2026 #endif
2027     {
2028         switch(s->state) {
2029         case RS_IDLE:
2030             if (ch == '$') {
2031                 /* start of command packet */
2032                 s->line_buf_index = 0;
2033                 s->line_sum = 0;
2034                 s->state = RS_GETLINE;
2035             } else {
2036                 trace_gdbstub_err_garbage((uint8_t)ch);
2037             }
2038             break;
2039         case RS_GETLINE:
2040             if (ch == '}') {
2041                 /* start escape sequence */
2042                 s->state = RS_GETLINE_ESC;
2043                 s->line_sum += ch;
2044             } else if (ch == '*') {
2045                 /* start run length encoding sequence */
2046                 s->state = RS_GETLINE_RLE;
2047                 s->line_sum += ch;
2048             } else if (ch == '#') {
2049                 /* end of command, start of checksum*/
2050                 s->state = RS_CHKSUM1;
2051             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2052                 trace_gdbstub_err_overrun();
2053                 s->state = RS_IDLE;
2054             } else {
2055                 /* unescaped command character */
2056                 s->line_buf[s->line_buf_index++] = ch;
2057                 s->line_sum += ch;
2058             }
2059             break;
2060         case RS_GETLINE_ESC:
2061             if (ch == '#') {
2062                 /* unexpected end of command in escape sequence */
2063                 s->state = RS_CHKSUM1;
2064             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2065                 /* command buffer overrun */
2066                 trace_gdbstub_err_overrun();
2067                 s->state = RS_IDLE;
2068             } else {
2069                 /* parse escaped character and leave escape state */
2070                 s->line_buf[s->line_buf_index++] = ch ^ 0x20;
2071                 s->line_sum += ch;
2072                 s->state = RS_GETLINE;
2073             }
2074             break;
2075         case RS_GETLINE_RLE:
2076             if (ch < ' ') {
2077                 /* invalid RLE count encoding */
2078                 trace_gdbstub_err_invalid_repeat((uint8_t)ch);
2079                 s->state = RS_GETLINE;
2080             } else {
2081                 /* decode repeat length */
2082                 int repeat = (unsigned char)ch - ' ' + 3;
2083                 if (s->line_buf_index + repeat >= sizeof(s->line_buf) - 1) {
2084                     /* that many repeats would overrun the command buffer */
2085                     trace_gdbstub_err_overrun();
2086                     s->state = RS_IDLE;
2087                 } else if (s->line_buf_index < 1) {
2088                     /* got a repeat but we have nothing to repeat */
2089                     trace_gdbstub_err_invalid_rle();
2090                     s->state = RS_GETLINE;
2091                 } else {
2092                     /* repeat the last character */
2093                     memset(s->line_buf + s->line_buf_index,
2094                            s->line_buf[s->line_buf_index - 1], repeat);
2095                     s->line_buf_index += repeat;
2096                     s->line_sum += ch;
2097                     s->state = RS_GETLINE;
2098                 }
2099             }
2100             break;
2101         case RS_CHKSUM1:
2102             /* get high hex digit of checksum */
2103             if (!isxdigit(ch)) {
2104                 trace_gdbstub_err_checksum_invalid((uint8_t)ch);
2105                 s->state = RS_GETLINE;
2106                 break;
2107             }
2108             s->line_buf[s->line_buf_index] = '\0';
2109             s->line_csum = fromhex(ch) << 4;
2110             s->state = RS_CHKSUM2;
2111             break;
2112         case RS_CHKSUM2:
2113             /* get low hex digit of checksum */
2114             if (!isxdigit(ch)) {
2115                 trace_gdbstub_err_checksum_invalid((uint8_t)ch);
2116                 s->state = RS_GETLINE;
2117                 break;
2118             }
2119             s->line_csum |= fromhex(ch);
2120
2121             if (s->line_csum != (s->line_sum & 0xff)) {
2122                 trace_gdbstub_err_checksum_incorrect(s->line_sum, s->line_csum);
2123                 /* send NAK reply */
2124                 reply = '-';
2125                 put_buffer(s, &reply, 1);
2126                 s->state = RS_IDLE;
2127             } else {
2128                 /* send ACK reply */
2129                 reply = '+';
2130                 put_buffer(s, &reply, 1);
2131                 s->state = gdb_handle_packet(s, s->line_buf);
2132             }
2133             break;
2134         default:
2135             abort();
2136         }
2137     }
2138 }
2139
2140 /* Tell the remote gdb that the process has exited.  */
2141 void gdb_exit(CPUArchState *env, int code)
2142 {
2143   GDBState *s;
2144   char buf[4];
2145
2146   s = gdbserver_state;
2147   if (!s) {
2148       return;
2149   }
2150 #ifdef CONFIG_USER_ONLY
2151   if (gdbserver_fd < 0 || s->fd < 0) {
2152       return;
2153   }
2154 #endif
2155
2156   trace_gdbstub_op_exiting((uint8_t)code);
2157
2158   snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
2159   put_packet(s, buf);
2160
2161 #ifndef CONFIG_USER_ONLY
2162   qemu_chr_fe_deinit(&s->chr, true);
2163 #endif
2164 }
2165
2166 /*
2167  * Create the process that will contain all the "orphan" CPUs (that are not
2168  * part of a CPU cluster). Note that if this process contains no CPUs, it won't
2169  * be attachable and thus will be invisible to the user.
2170  */
2171 static void create_default_process(GDBState *s)
2172 {
2173     GDBProcess *process;
2174     int max_pid = 0;
2175
2176     if (s->process_num) {
2177         max_pid = s->processes[s->process_num - 1].pid;
2178     }
2179
2180     s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2181     process = &s->processes[s->process_num - 1];
2182
2183     /* We need an available PID slot for this process */
2184     assert(max_pid < UINT32_MAX);
2185
2186     process->pid = max_pid + 1;
2187     process->attached = false;
2188     process->target_xml[0] = '\0';
2189 }
2190
2191 #ifdef CONFIG_USER_ONLY
2192 int
2193 gdb_handlesig(CPUState *cpu, int sig)
2194 {
2195     GDBState *s;
2196     char buf[256];
2197     int n;
2198
2199     s = gdbserver_state;
2200     if (gdbserver_fd < 0 || s->fd < 0) {
2201         return sig;
2202     }
2203
2204     /* disable single step if it was enabled */
2205     cpu_single_step(cpu, 0);
2206     tb_flush(cpu);
2207
2208     if (sig != 0) {
2209         snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
2210         put_packet(s, buf);
2211     }
2212     /* put_packet() might have detected that the peer terminated the
2213        connection.  */
2214     if (s->fd < 0) {
2215         return sig;
2216     }
2217
2218     sig = 0;
2219     s->state = RS_IDLE;
2220     s->running_state = 0;
2221     while (s->running_state == 0) {
2222         n = read(s->fd, buf, 256);
2223         if (n > 0) {
2224             int i;
2225
2226             for (i = 0; i < n; i++) {
2227                 gdb_read_byte(s, buf[i]);
2228             }
2229         } else {
2230             /* XXX: Connection closed.  Should probably wait for another
2231                connection before continuing.  */
2232             if (n == 0) {
2233                 close(s->fd);
2234             }
2235             s->fd = -1;
2236             return sig;
2237         }
2238     }
2239     sig = s->signal;
2240     s->signal = 0;
2241     return sig;
2242 }
2243
2244 /* Tell the remote gdb that the process has exited due to SIG.  */
2245 void gdb_signalled(CPUArchState *env, int sig)
2246 {
2247     GDBState *s;
2248     char buf[4];
2249
2250     s = gdbserver_state;
2251     if (gdbserver_fd < 0 || s->fd < 0) {
2252         return;
2253     }
2254
2255     snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
2256     put_packet(s, buf);
2257 }
2258
2259 static bool gdb_accept(void)
2260 {
2261     GDBState *s;
2262     struct sockaddr_in sockaddr;
2263     socklen_t len;
2264     int fd;
2265
2266     for(;;) {
2267         len = sizeof(sockaddr);
2268         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
2269         if (fd < 0 && errno != EINTR) {
2270             perror("accept");
2271             return false;
2272         } else if (fd >= 0) {
2273             qemu_set_cloexec(fd);
2274             break;
2275         }
2276     }
2277
2278     /* set short latency */
2279     if (socket_set_nodelay(fd)) {
2280         perror("setsockopt");
2281         close(fd);
2282         return false;
2283     }
2284
2285     s = g_malloc0(sizeof(GDBState));
2286     create_default_process(s);
2287     s->processes[0].attached = true;
2288     s->c_cpu = gdb_first_attached_cpu(s);
2289     s->g_cpu = s->c_cpu;
2290     s->fd = fd;
2291     gdb_has_xml = false;
2292
2293     gdbserver_state = s;
2294     return true;
2295 }
2296
2297 static int gdbserver_open(int port)
2298 {
2299     struct sockaddr_in sockaddr;
2300     int fd, ret;
2301
2302     fd = socket(PF_INET, SOCK_STREAM, 0);
2303     if (fd < 0) {
2304         perror("socket");
2305         return -1;
2306     }
2307     qemu_set_cloexec(fd);
2308
2309     socket_set_fast_reuse(fd);
2310
2311     sockaddr.sin_family = AF_INET;
2312     sockaddr.sin_port = htons(port);
2313     sockaddr.sin_addr.s_addr = 0;
2314     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
2315     if (ret < 0) {
2316         perror("bind");
2317         close(fd);
2318         return -1;
2319     }
2320     ret = listen(fd, 1);
2321     if (ret < 0) {
2322         perror("listen");
2323         close(fd);
2324         return -1;
2325     }
2326     return fd;
2327 }
2328
2329 int gdbserver_start(int port)
2330 {
2331     gdbserver_fd = gdbserver_open(port);
2332     if (gdbserver_fd < 0)
2333         return -1;
2334     /* accept connections */
2335     if (!gdb_accept()) {
2336         close(gdbserver_fd);
2337         gdbserver_fd = -1;
2338         return -1;
2339     }
2340     return 0;
2341 }
2342
2343 /* Disable gdb stub for child processes.  */
2344 void gdbserver_fork(CPUState *cpu)
2345 {
2346     GDBState *s = gdbserver_state;
2347
2348     if (gdbserver_fd < 0 || s->fd < 0) {
2349         return;
2350     }
2351     close(s->fd);
2352     s->fd = -1;
2353     cpu_breakpoint_remove_all(cpu, BP_GDB);
2354     cpu_watchpoint_remove_all(cpu, BP_GDB);
2355 }
2356 #else
2357 static int gdb_chr_can_receive(void *opaque)
2358 {
2359   /* We can handle an arbitrarily large amount of data.
2360    Pick the maximum packet size, which is as good as anything.  */
2361   return MAX_PACKET_LENGTH;
2362 }
2363
2364 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
2365 {
2366     int i;
2367
2368     for (i = 0; i < size; i++) {
2369         gdb_read_byte(gdbserver_state, buf[i]);
2370     }
2371 }
2372
2373 static void gdb_chr_event(void *opaque, int event)
2374 {
2375     int i;
2376     GDBState *s = (GDBState *) opaque;
2377
2378     switch (event) {
2379     case CHR_EVENT_OPENED:
2380         /* Start with first process attached, others detached */
2381         for (i = 0; i < s->process_num; i++) {
2382             s->processes[i].attached = !i;
2383         }
2384
2385         s->c_cpu = gdb_first_attached_cpu(s);
2386         s->g_cpu = s->c_cpu;
2387
2388         vm_stop(RUN_STATE_PAUSED);
2389         gdb_has_xml = false;
2390         break;
2391     default:
2392         break;
2393     }
2394 }
2395
2396 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
2397 {
2398     char buf[MAX_PACKET_LENGTH];
2399
2400     buf[0] = 'O';
2401     if (len > (MAX_PACKET_LENGTH/2) - 1)
2402         len = (MAX_PACKET_LENGTH/2) - 1;
2403     memtohex(buf + 1, (uint8_t *)msg, len);
2404     put_packet(s, buf);
2405 }
2406
2407 static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
2408 {
2409     const char *p = (const char *)buf;
2410     int max_sz;
2411
2412     max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
2413     for (;;) {
2414         if (len <= max_sz) {
2415             gdb_monitor_output(gdbserver_state, p, len);
2416             break;
2417         }
2418         gdb_monitor_output(gdbserver_state, p, max_sz);
2419         p += max_sz;
2420         len -= max_sz;
2421     }
2422     return len;
2423 }
2424
2425 #ifndef _WIN32
2426 static void gdb_sigterm_handler(int signal)
2427 {
2428     if (runstate_is_running()) {
2429         vm_stop(RUN_STATE_PAUSED);
2430     }
2431 }
2432 #endif
2433
2434 static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
2435                              bool *be_opened, Error **errp)
2436 {
2437     *be_opened = false;
2438 }
2439
2440 static void char_gdb_class_init(ObjectClass *oc, void *data)
2441 {
2442     ChardevClass *cc = CHARDEV_CLASS(oc);
2443
2444     cc->internal = true;
2445     cc->open = gdb_monitor_open;
2446     cc->chr_write = gdb_monitor_write;
2447 }
2448
2449 #define TYPE_CHARDEV_GDB "chardev-gdb"
2450
2451 static const TypeInfo char_gdb_type_info = {
2452     .name = TYPE_CHARDEV_GDB,
2453     .parent = TYPE_CHARDEV,
2454     .class_init = char_gdb_class_init,
2455 };
2456
2457 static int find_cpu_clusters(Object *child, void *opaque)
2458 {
2459     if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
2460         GDBState *s = (GDBState *) opaque;
2461         CPUClusterState *cluster = CPU_CLUSTER(child);
2462         GDBProcess *process;
2463
2464         s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2465
2466         process = &s->processes[s->process_num - 1];
2467
2468         /*
2469          * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
2470          * runtime, we enforce here that the machine does not use a cluster ID
2471          * that would lead to PID 0.
2472          */
2473         assert(cluster->cluster_id != UINT32_MAX);
2474         process->pid = cluster->cluster_id + 1;
2475         process->attached = false;
2476         process->target_xml[0] = '\0';
2477
2478         return 0;
2479     }
2480
2481     return object_child_foreach(child, find_cpu_clusters, opaque);
2482 }
2483
2484 static int pid_order(const void *a, const void *b)
2485 {
2486     GDBProcess *pa = (GDBProcess *) a;
2487     GDBProcess *pb = (GDBProcess *) b;
2488
2489     if (pa->pid < pb->pid) {
2490         return -1;
2491     } else if (pa->pid > pb->pid) {
2492         return 1;
2493     } else {
2494         return 0;
2495     }
2496 }
2497
2498 static void create_processes(GDBState *s)
2499 {
2500     object_child_foreach(object_get_root(), find_cpu_clusters, s);
2501
2502     if (s->processes) {
2503         /* Sort by PID */
2504         qsort(s->processes, s->process_num, sizeof(s->processes[0]), pid_order);
2505     }
2506
2507     create_default_process(s);
2508 }
2509
2510 static void cleanup_processes(GDBState *s)
2511 {
2512     g_free(s->processes);
2513     s->process_num = 0;
2514     s->processes = NULL;
2515 }
2516
2517 int gdbserver_start(const char *device)
2518 {
2519     trace_gdbstub_op_start(device);
2520
2521     GDBState *s;
2522     char gdbstub_device_name[128];
2523     Chardev *chr = NULL;
2524     Chardev *mon_chr;
2525
2526     if (!first_cpu) {
2527         error_report("gdbstub: meaningless to attach gdb to a "
2528                      "machine without any CPU.");
2529         return -1;
2530     }
2531
2532     if (!device)
2533         return -1;
2534     if (strcmp(device, "none") != 0) {
2535         if (strstart(device, "tcp:", NULL)) {
2536             /* enforce required TCP attributes */
2537             snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
2538                      "%s,nowait,nodelay,server", device);
2539             device = gdbstub_device_name;
2540         }
2541 #ifndef _WIN32
2542         else if (strcmp(device, "stdio") == 0) {
2543             struct sigaction act;
2544
2545             memset(&act, 0, sizeof(act));
2546             act.sa_handler = gdb_sigterm_handler;
2547             sigaction(SIGINT, &act, NULL);
2548         }
2549 #endif
2550         /*
2551          * FIXME: it's a bit weird to allow using a mux chardev here
2552          * and implicitly setup a monitor. We may want to break this.
2553          */
2554         chr = qemu_chr_new_noreplay("gdb", device, true);
2555         if (!chr)
2556             return -1;
2557     }
2558
2559     s = gdbserver_state;
2560     if (!s) {
2561         s = g_malloc0(sizeof(GDBState));
2562         gdbserver_state = s;
2563
2564         qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
2565
2566         /* Initialize a monitor terminal for gdb */
2567         mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
2568                                    NULL, &error_abort);
2569         monitor_init(mon_chr, 0);
2570     } else {
2571         qemu_chr_fe_deinit(&s->chr, true);
2572         mon_chr = s->mon_chr;
2573         cleanup_processes(s);
2574         memset(s, 0, sizeof(GDBState));
2575         s->mon_chr = mon_chr;
2576     }
2577
2578     create_processes(s);
2579
2580     if (chr) {
2581         qemu_chr_fe_init(&s->chr, chr, &error_abort);
2582         qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,
2583                                  gdb_chr_event, NULL, s, NULL, true);
2584     }
2585     s->state = chr ? RS_IDLE : RS_INACTIVE;
2586     s->mon_chr = mon_chr;
2587     s->current_syscall_cb = NULL;
2588
2589     return 0;
2590 }
2591
2592 void gdbserver_cleanup(void)
2593 {
2594     if (gdbserver_state) {
2595         put_packet(gdbserver_state, "W00");
2596     }
2597 }
2598
2599 static void register_types(void)
2600 {
2601     type_register_static(&char_gdb_type_info);
2602 }
2603
2604 type_init(register_types);
2605 #endif