s390x/vfio: ap: Introduce VFIO AP device

[qemu.git] / gdbstub.c

diff --git a/gdbstub.c b/gdbstub.c
index 86eed4f97c72481798ea5c6579ac6278b44c8976..c8478de8f5a613d949e8e18668a9adc276850618 100644 (file)
--- a/gdbstub.c
+++ b/gdbstub.c
@@ -21,11 +21,13 @@
 #include "qemu/error-report.h"
 #include "qemu/cutils.h"
 #include "cpu.h"
 #include "qemu/error-report.h"
 #include "qemu/cutils.h"
 #include "cpu.h"

+#include "trace-root.h"

 #ifdef CONFIG_USER_ONLY
 #include "qemu.h"
 #else
 #include "monitor/monitor.h"
 #ifdef CONFIG_USER_ONLY
 #include "qemu.h"
 #else
 #include "monitor/monitor.h"

-#include "sysemu/char.h"
+#include "chardev/char.h"
+#include "chardev/char-fe.h"

 #include "sysemu/sysemu.h"
 #include "exec/gdbstub.h"
 #endif
 #include "sysemu/sysemu.h"
 #include "exec/gdbstub.h"
 #endif


@@ -55,6 +57,21 @@ static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
     return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
 }
 
     return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
 }
 

+/* Return the GDB index for a given vCPU state.
+ *
+ * For user mode this is simply the thread id. In system mode GDB
+ * numbers CPUs from 1 as 0 is reserved as an "any cpu" index.
+ */
+static inline int cpu_gdb_index(CPUState *cpu)
+{
+#if defined(CONFIG_USER_ONLY)
+    TaskState *ts = (TaskState *) cpu->opaque;
+    return ts->ts_tid;
+#else
+    return cpu->cpu_index + 1;
+#endif
+}
+

 enum {
     GDB_SIGNAL_0 = 0,
     GDB_SIGNAL_INT = 2,
 enum {
     GDB_SIGNAL_0 = 0,
     GDB_SIGNAL_INT = 2,


@@ -271,8 +288,6 @@ static int gdb_signal_to_target (int sig)
         return -1;
 }
 
         return -1;
 }
 

-//#define DEBUG_GDB
-

 typedef struct GDBRegisterState {
     int base_reg;
     int num_regs;
 typedef struct GDBRegisterState {
     int base_reg;
     int num_regs;


@@ -381,10 +396,13 @@ int use_gdb_syscalls(void)
 /* Resume execution.  */
 static inline void gdb_continue(GDBState *s)
 {
 /* Resume execution.  */
 static inline void gdb_continue(GDBState *s)
 {

+

 #ifdef CONFIG_USER_ONLY
     s->running_state = 1;
 #ifdef CONFIG_USER_ONLY
     s->running_state = 1;

+    trace_gdbstub_op_continue();

 #else
     if (!runstate_needs_reset()) {
 #else
     if (!runstate_needs_reset()) {

+        trace_gdbstub_op_continue();

         vm_start();
     }
 #endif
         vm_start();
     }
 #endif


@@ -405,6 +423,7 @@ static int gdb_continue_partial(GDBState *s, char *newstates)
      */
     CPU_FOREACH(cpu) {
         if (newstates[cpu->cpu_index] == 's') {
      */
     CPU_FOREACH(cpu) {
         if (newstates[cpu->cpu_index] == 's') {

+            trace_gdbstub_op_stepping(cpu->cpu_index);

             cpu_single_step(cpu, sstep_flags);
         }
     }
             cpu_single_step(cpu, sstep_flags);
         }
     }


@@ -423,11 +442,13 @@ static int gdb_continue_partial(GDBState *s, char *newstates)
             case 1:
                 break; /* nothing to do here */
             case 's':
             case 1:
                 break; /* nothing to do here */
             case 's':

+                trace_gdbstub_op_stepping(cpu->cpu_index);

                 cpu_single_step(cpu, sstep_flags);
                 cpu_resume(cpu);
                 flag = 1;
                 break;
             case 'c':
                 cpu_single_step(cpu, sstep_flags);
                 cpu_resume(cpu);
                 flag = 1;
                 break;
             case 'c':

+                trace_gdbstub_op_continue_cpu(cpu->cpu_index);

                 cpu_resume(cpu);
                 flag = 1;
                 break;
                 cpu_resume(cpu);
                 flag = 1;
                 break;


@@ -486,6 +507,7 @@ static inline int tohex(int v)
         return v - 10 + 'a';
 }
 
         return v - 10 + 'a';
 }
 

+/* writes 2*len+1 bytes in buf */

 static void memtohex(char *buf, const uint8_t *mem, int len)
 {
     int i, c;
 static void memtohex(char *buf, const uint8_t *mem, int len)
 {
     int i, c;


@@ -509,12 +531,49 @@ static void hextomem(uint8_t *mem, const char *buf, int len)
     }
 }
 
     }
 }
 

+static void hexdump(const char *buf, int len,
+                    void (*trace_fn)(size_t ofs, char const *text))
+{
+    char line_buffer[3 * 16 + 4 + 16 + 1];
+
+    size_t i;
+    for (i = 0; i < len || (i & 0xF); ++i) {
+        size_t byte_ofs = i & 15;
+
+        if (byte_ofs == 0) {
+            memset(line_buffer, ' ', 3 * 16 + 4 + 16);
+            line_buffer[3 * 16 + 4 + 16] = 0;
+        }
+
+        size_t col_group = (i >> 2) & 3;
+        size_t hex_col = byte_ofs * 3 + col_group;
+        size_t txt_col = 3 * 16 + 4 + byte_ofs;
+
+        if (i < len) {
+            char value = buf[i];
+
+            line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
+            line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
+            line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
+                    ? value
+                    : '.';
+        }
+
+        if (byte_ofs == 0xF)
+            trace_fn(i & -16, line_buffer);
+    }
+}
+

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

-static int put_packet_binary(GDBState *s, const char *buf, int len)
+static int put_packet_binary(GDBState *s, const char *buf, int len, bool dump)

 {
     int csum, i;
     uint8_t *p;
 
 {
     int csum, i;
     uint8_t *p;
 

+    if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
+        hexdump(buf, len, trace_gdbstub_io_binaryreply);
+    }
+

     for(;;) {
         p = s->last_packet;
         *(p++) = '$';
     for(;;) {
         p = s->last_packet;
         *(p++) = '$';


@@ -547,11 +606,9 @@ static int put_packet_binary(GDBState *s, const char *buf, int len)
 /* return -1 if error, 0 if OK */
 static int put_packet(GDBState *s, const char *buf)
 {
 /* return -1 if error, 0 if OK */
 static int put_packet(GDBState *s, const char *buf)
 {

-#ifdef DEBUG_GDB
-    printf("reply='%s'\n", buf);
-#endif
+    trace_gdbstub_io_reply(buf);

 
 

-    return put_packet_binary(s, buf, strlen(buf));
+    return put_packet_binary(s, buf, strlen(buf), false);

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


@@ -618,6 +675,16 @@ static const char *get_feature_xml(const char *p, const char **newp,
         }
         return target_xml;
     }
         }
         return target_xml;
     }

+    if (cc->gdb_get_dynamic_xml) {
+        CPUState *cpu = first_cpu;
+        char *xmlname = g_strndup(p, len);
+        const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname);
+
+        g_free(xmlname);
+        if (xml) {
+            return xml;
+        }
+    }

     for (i = 0; ; i++) {
         name = xml_builtin[i][0];
         if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
     for (i = 0; ; i++) {
         name = xml_builtin[i][0];
         if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))


@@ -826,7 +893,7 @@ static CPUState *find_cpu(uint32_t thread_id)
     CPUState *cpu;
 
     CPU_FOREACH(cpu) {
     CPUState *cpu;
 
     CPU_FOREACH(cpu) {

-        if (cpu_index(cpu) == thread_id) {
+        if (cpu_gdb_index(cpu) == thread_id) {

             return cpu;
         }
     }
             return cpu;
         }
     }


@@ -884,7 +951,7 @@ static int gdb_handle_vcont(GDBState *s, const char *p)
 
         cur_action = *p++;
         if (cur_action == 'C' || cur_action == 'S') {
 
         cur_action = *p++;
         if (cur_action == 'C' || cur_action == 'S') {

-            cur_action = tolower(cur_action);
+            cur_action = qemu_tolower(cur_action);

             res = qemu_strtoul(p + 1, &p, 16, &tmp);
             if (res) {
                 goto out;
             res = qemu_strtoul(p + 1, &p, 16, &tmp);
             if (res) {
                 goto out;


@@ -911,23 +978,16 @@ static int gdb_handle_vcont(GDBState *s, const char *p)
             if (res) {
                 goto out;
             }
             if (res) {
                 goto out;
             }

-            idx = tmp;
+

             /* 0 means any thread, so we pick the first valid CPU */
             /* 0 means any thread, so we pick the first valid CPU */

-            if (!idx) {
-                idx = cpu_index(first_cpu);
-            }
+            cpu = tmp ? find_cpu(tmp) : first_cpu;

 
 

-            /*
-             * If we are in user mode, the thread specified is actually a
-             * thread id, and not an index. We need to find the actual
-             * CPU first, and only then we can use its index.
-             */
-            cpu = find_cpu(idx);

             /* invalid CPU/thread specified */
             /* invalid CPU/thread specified */

-            if (!idx || !cpu) {
+            if (!cpu) {

                 res = -EINVAL;
                 goto out;
             }
                 res = -EINVAL;
                 goto out;
             }

+

             /* only use if no previous match occourred */
             if (newstates[cpu->cpu_index] == 1) {
                 newstates[cpu->cpu_index] = cur_action;
             /* only use if no previous match occourred */
             if (newstates[cpu->cpu_index] == 1) {
                 newstates[cpu->cpu_index] = cur_action;


@@ -950,21 +1010,20 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)
     const char *p;
     uint32_t thread;
     int ch, reg_size, type, res;
     const char *p;
     uint32_t thread;
     int ch, reg_size, type, res;

-    char buf[MAX_PACKET_LENGTH];

     uint8_t mem_buf[MAX_PACKET_LENGTH];
     uint8_t mem_buf[MAX_PACKET_LENGTH];

+    char buf[sizeof(mem_buf) + 1 /* trailing NUL */];

     uint8_t *registers;
     target_ulong addr, len;
 
     uint8_t *registers;
     target_ulong addr, len;
 

-#ifdef DEBUG_GDB
-    printf("command='%s'\n", line_buf);
-#endif
+    trace_gdbstub_io_command(line_buf);
+

     p = line_buf;
     ch = *p++;
     switch(ch) {
     case '?':
         /* TODO: Make this return the correct value for user-mode.  */
         snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
     p = line_buf;
     ch = *p++;
     switch(ch) {
     case '?':
         /* TODO: Make this return the correct value for user-mode.  */
         snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,

-                 cpu_index(s->c_cpu));
+                 cpu_gdb_index(s->c_cpu));

         put_packet(s, buf);
         /* Remove all the breakpoints when this query is issued,
          * because gdb is doing and initial connect and the state
         put_packet(s, buf);
         /* Remove all the breakpoints when this query is issued,
          * because gdb is doing and initial connect and the state


@@ -979,7 +1038,7 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)
         }
         s->signal = 0;
         gdb_continue(s);
         }
         s->signal = 0;
         gdb_continue(s);

-       return RS_IDLE;
+        return RS_IDLE;

     case 'C':
         s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
         if (s->signal == -1)
     case 'C':
         s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
         if (s->signal == -1)


@@ -1025,7 +1084,7 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)
         }
         cpu_single_step(s->c_cpu, sstep_flags);
         gdb_continue(s);
         }
         cpu_single_step(s->c_cpu, sstep_flags);
         gdb_continue(s);

-       return RS_IDLE;
+        return RS_IDLE;

     case 'F':
         {
             target_ulong ret;
     case 'F':
         {
             target_ulong ret;


@@ -1232,7 +1291,7 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)
         } else if (strcmp(p,"sThreadInfo") == 0) {
         report_cpuinfo:
             if (s->query_cpu) {
         } else if (strcmp(p,"sThreadInfo") == 0) {
         report_cpuinfo:
             if (s->query_cpu) {

-                snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
+                snprintf(buf, sizeof(buf), "m%x", cpu_gdb_index(s->query_cpu));

                 put_packet(s, buf);
                 s->query_cpu = CPU_NEXT(s->query_cpu);
             } else
                 put_packet(s, buf);
                 s->query_cpu = CPU_NEXT(s->query_cpu);
             } else


@@ -1247,6 +1306,7 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)
                 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
                                "CPU#%d [%s]", cpu->cpu_index,
                                cpu->halted ? "halted " : "running");
                 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
                                "CPU#%d [%s]", cpu->cpu_index,
                                cpu->halted ? "halted " : "running");

+                trace_gdbstub_op_extra_info((char *)mem_buf);

                 memtohex(buf, mem_buf, len);
                 put_packet(s, buf);
             }
                 memtohex(buf, mem_buf, len);
                 put_packet(s, buf);
             }


@@ -1330,7 +1390,7 @@ static int gdb_handle_packet(GDBState *s, const char *line_buf)
                 buf[0] = 'l';
                 len = memtox(buf + 1, xml + addr, total_len - addr);
             }
                 buf[0] = 'l';
                 len = memtox(buf + 1, xml + addr, total_len - addr);
             }

-            put_packet_binary(s, buf, len + 1);
+            put_packet_binary(s, buf, len + 1, true);

             break;
         }
         if (is_query_packet(p, "Attached", ':')) {
             break;
         }
         if (is_query_packet(p, "Attached", ':')) {


@@ -1387,29 +1447,38 @@ static void gdb_vm_state_change(void *opaque, int running, RunState state)
                 type = "";
                 break;
             }
                 type = "";
                 break;
             }

+            trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
+                    (target_ulong)cpu->watchpoint_hit->vaddr);

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

-                     GDB_SIGNAL_TRAP, cpu_index(cpu), type,
+                     GDB_SIGNAL_TRAP, cpu_gdb_index(cpu), type,

                      (target_ulong)cpu->watchpoint_hit->vaddr);
             cpu->watchpoint_hit = NULL;
             goto send_packet;
                      (target_ulong)cpu->watchpoint_hit->vaddr);
             cpu->watchpoint_hit = NULL;
             goto send_packet;

+        } else {
+            trace_gdbstub_hit_break();

         }
         tb_flush(cpu);
         ret = GDB_SIGNAL_TRAP;
         break;
     case RUN_STATE_PAUSED:
         }
         tb_flush(cpu);
         ret = GDB_SIGNAL_TRAP;
         break;
     case RUN_STATE_PAUSED:

+        trace_gdbstub_hit_paused();

         ret = GDB_SIGNAL_INT;
         break;
     case RUN_STATE_SHUTDOWN:
         ret = GDB_SIGNAL_INT;
         break;
     case RUN_STATE_SHUTDOWN:

+        trace_gdbstub_hit_shutdown();

         ret = GDB_SIGNAL_QUIT;
         break;
     case RUN_STATE_IO_ERROR:
         ret = GDB_SIGNAL_QUIT;
         break;
     case RUN_STATE_IO_ERROR:

+        trace_gdbstub_hit_io_error();

         ret = GDB_SIGNAL_IO;
         break;
     case RUN_STATE_WATCHDOG:
         ret = GDB_SIGNAL_IO;
         break;
     case RUN_STATE_WATCHDOG:

+        trace_gdbstub_hit_watchdog();

         ret = GDB_SIGNAL_ALRM;
         break;
     case RUN_STATE_INTERNAL_ERROR:
         ret = GDB_SIGNAL_ALRM;
         break;
     case RUN_STATE_INTERNAL_ERROR:

+        trace_gdbstub_hit_internal_error();

         ret = GDB_SIGNAL_ABRT;
         break;
     case RUN_STATE_SAVE_VM:
         ret = GDB_SIGNAL_ABRT;
         break;
     case RUN_STATE_SAVE_VM:


@@ -1419,11 +1488,12 @@ static void gdb_vm_state_change(void *opaque, int running, RunState state)
         ret = GDB_SIGNAL_XCPU;
         break;
     default:
         ret = GDB_SIGNAL_XCPU;
         break;
     default:

+        trace_gdbstub_hit_unknown(state);

         ret = GDB_SIGNAL_UNKNOWN;
         break;
     }
     gdb_set_stop_cpu(cpu);
         ret = GDB_SIGNAL_UNKNOWN;
         break;
     }
     gdb_set_stop_cpu(cpu);

-    snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
+    snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_gdb_index(cpu));

 
 send_packet:
     put_packet(s, buf);
 
 send_packet:
     put_packet(s, buf);


@@ -1488,6 +1558,12 @@ void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
     *p = 0;
 #ifdef CONFIG_USER_ONLY
     put_packet(s, s->syscall_buf);
     *p = 0;
 #ifdef CONFIG_USER_ONLY
     put_packet(s, s->syscall_buf);

+    /* Return control to gdb for it to process the syscall request.
+     * Since the protocol requires that gdb hands control back to us
+     * using a "here are the results" F packet, we don't need to check
+     * gdb_handlesig's return value (which is the signal to deliver if
+     * execution was resumed via a continue packet).
+     */

     gdb_handlesig(s->c_cpu, 0);
 #else
     /* In this case wait to send the syscall packet until notification that
     gdb_handlesig(s->c_cpu, 0);
 #else
     /* In this case wait to send the syscall packet until notification that


@@ -1518,17 +1594,14 @@ static void gdb_read_byte(GDBState *s, int ch)
         /* Waiting for a response to the last packet.  If we see the start
            of a new command then abandon the previous response.  */
         if (ch == '-') {
         /* Waiting for a response to the last packet.  If we see the start
            of a new command then abandon the previous response.  */
         if (ch == '-') {

-#ifdef DEBUG_GDB
-            printf("Got NACK, retransmitting\n");
-#endif
+            trace_gdbstub_err_got_nack();

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

+        } else if (ch == '+') {
+            trace_gdbstub_io_got_ack();
+        } else {
+            trace_gdbstub_io_got_unexpected((uint8_t)ch);

         }
         }

-#ifdef DEBUG_GDB
-        else if (ch == '+')
-            printf("Got ACK\n");
-        else
-            printf("Got '%c' when expecting ACK/NACK\n", ch);
-#endif
+

         if (ch == '+' || ch == '$')
             s->last_packet_len = 0;
         if (ch != '$')
         if (ch == '+' || ch == '$')
             s->last_packet_len = 0;
         if (ch != '$')


@@ -1549,9 +1622,7 @@ static void gdb_read_byte(GDBState *s, int ch)
                 s->line_sum = 0;
                 s->state = RS_GETLINE;
             } else {
                 s->line_sum = 0;
                 s->state = RS_GETLINE;
             } else {

-#ifdef DEBUG_GDB
-                printf("gdbstub received garbage between packets: 0x%x\n", ch);
-#endif
+                trace_gdbstub_err_garbage((uint8_t)ch);

             }
             break;
         case RS_GETLINE:
             }
             break;
         case RS_GETLINE:


@@ -1567,9 +1638,7 @@ static void gdb_read_byte(GDBState *s, int ch)
                 /* end of command, start of checksum*/
                 s->state = RS_CHKSUM1;
             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
                 /* end of command, start of checksum*/
                 s->state = RS_CHKSUM1;
             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {

-#ifdef DEBUG_GDB
-                printf("gdbstub command buffer overrun, dropping command\n");
-#endif
+                trace_gdbstub_err_overrun();

                 s->state = RS_IDLE;
             } else {
                 /* unescaped command character */
                 s->state = RS_IDLE;
             } else {
                 /* unescaped command character */


@@ -1583,9 +1652,7 @@ static void gdb_read_byte(GDBState *s, int ch)
                 s->state = RS_CHKSUM1;
             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
                 /* command buffer overrun */
                 s->state = RS_CHKSUM1;
             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
                 /* command buffer overrun */

-#ifdef DEBUG_GDB
-                printf("gdbstub command buffer overrun, dropping command\n");
-#endif
+                trace_gdbstub_err_overrun();

                 s->state = RS_IDLE;
             } else {
                 /* parse escaped character and leave escape state */
                 s->state = RS_IDLE;
             } else {
                 /* parse escaped character and leave escape state */


@@ -1597,25 +1664,18 @@ static void gdb_read_byte(GDBState *s, int ch)
         case RS_GETLINE_RLE:
             if (ch < ' ') {
                 /* invalid RLE count encoding */
         case RS_GETLINE_RLE:
             if (ch < ' ') {
                 /* invalid RLE count encoding */

-#ifdef DEBUG_GDB
-                printf("gdbstub got invalid RLE count: 0x%x\n", ch);
-#endif
+                trace_gdbstub_err_invalid_repeat((uint8_t)ch);

                 s->state = RS_GETLINE;
             } else {
                 /* decode repeat length */
                 int repeat = (unsigned char)ch - ' ' + 3;
                 if (s->line_buf_index + repeat >= sizeof(s->line_buf) - 1) {
                     /* that many repeats would overrun the command buffer */
                 s->state = RS_GETLINE;
             } else {
                 /* decode repeat length */
                 int repeat = (unsigned char)ch - ' ' + 3;
                 if (s->line_buf_index + repeat >= sizeof(s->line_buf) - 1) {
                     /* that many repeats would overrun the command buffer */

-#ifdef DEBUG_GDB
-                    printf("gdbstub command buffer overrun,"
-                           " dropping command\n");
-#endif
+                    trace_gdbstub_err_overrun();

                     s->state = RS_IDLE;
                 } else if (s->line_buf_index < 1) {
                     /* got a repeat but we have nothing to repeat */
                     s->state = RS_IDLE;
                 } else if (s->line_buf_index < 1) {
                     /* got a repeat but we have nothing to repeat */

-#ifdef DEBUG_GDB
-                    printf("gdbstub got invalid RLE sequence\n");
-#endif
+                    trace_gdbstub_err_invalid_rle();

                     s->state = RS_GETLINE;
                 } else {
                     /* repeat the last character */
                     s->state = RS_GETLINE;
                 } else {
                     /* repeat the last character */


@@ -1630,9 +1690,7 @@ static void gdb_read_byte(GDBState *s, int ch)
         case RS_CHKSUM1:
             /* get high hex digit of checksum */
             if (!isxdigit(ch)) {
         case RS_CHKSUM1:
             /* get high hex digit of checksum */
             if (!isxdigit(ch)) {

-#ifdef DEBUG_GDB
-                printf("gdbstub got invalid command checksum digit\n");
-#endif
+                trace_gdbstub_err_checksum_invalid((uint8_t)ch);

                 s->state = RS_GETLINE;
                 break;
             }
                 s->state = RS_GETLINE;
                 break;
             }


@@ -1643,21 +1701,17 @@ static void gdb_read_byte(GDBState *s, int ch)
         case RS_CHKSUM2:
             /* get low hex digit of checksum */
             if (!isxdigit(ch)) {
         case RS_CHKSUM2:
             /* get low hex digit of checksum */
             if (!isxdigit(ch)) {

-#ifdef DEBUG_GDB
-                printf("gdbstub got invalid command checksum digit\n");
-#endif
+                trace_gdbstub_err_checksum_invalid((uint8_t)ch);

                 s->state = RS_GETLINE;
                 break;
             }
             s->line_csum |= fromhex(ch);
 
             if (s->line_csum != (s->line_sum & 0xff)) {
                 s->state = RS_GETLINE;
                 break;
             }
             s->line_csum |= fromhex(ch);
 
             if (s->line_csum != (s->line_sum & 0xff)) {

+                trace_gdbstub_err_checksum_incorrect(s->line_sum, s->line_csum);

                 /* send NAK reply */
                 reply = '-';
                 put_buffer(s, &reply, 1);
                 /* send NAK reply */
                 reply = '-';
                 put_buffer(s, &reply, 1);

-#ifdef DEBUG_GDB
-                printf("gdbstub got command packet with incorrect checksum\n");
-#endif

                 s->state = RS_IDLE;
             } else {
                 /* send ACK reply */
                 s->state = RS_IDLE;
             } else {
                 /* send ACK reply */


@@ -1677,9 +1731,6 @@ void gdb_exit(CPUArchState *env, int code)
 {
   GDBState *s;
   char buf[4];
 {
   GDBState *s;
   char buf[4];

-#ifndef CONFIG_USER_ONLY
-  Chardev *chr;
-#endif

 
   s = gdbserver_state;
   if (!s) {
 
   s = gdbserver_state;
   if (!s) {


@@ -1689,19 +1740,15 @@ void gdb_exit(CPUArchState *env, int code)
   if (gdbserver_fd < 0 || s->fd < 0) {
       return;
   }
   if (gdbserver_fd < 0 || s->fd < 0) {
       return;
   }

-#else
-  chr = qemu_chr_fe_get_driver(&s->chr);
-  if (!chr) {
-      return;
-  }

 #endif
 
 #endif
 

+  trace_gdbstub_op_exiting((uint8_t)code);
+

   snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
   put_packet(s, buf);
 
 #ifndef CONFIG_USER_ONLY
   snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
   put_packet(s, buf);
 
 #ifndef CONFIG_USER_ONLY

-  qemu_chr_fe_deinit(&s->chr);
-  object_unparent(OBJECT(chr));
+  qemu_chr_fe_deinit(&s->chr, true);

 #endif
 }
 
 #endif
 }
 


@@ -1773,7 +1820,7 @@ void gdb_signalled(CPUArchState *env, int sig)
     put_packet(s, buf);
 }
 
     put_packet(s, buf);
 }
 

-static void gdb_accept(void)
+static bool gdb_accept(void)

 {
     GDBState *s;
     struct sockaddr_in sockaddr;
 {
     GDBState *s;
     struct sockaddr_in sockaddr;


@@ -1785,17 +1832,19 @@ static void gdb_accept(void)
         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
         if (fd < 0 && errno != EINTR) {
             perror("accept");
         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
         if (fd < 0 && errno != EINTR) {
             perror("accept");

-            return;
+            return false;

         } else if (fd >= 0) {
         } else if (fd >= 0) {

-#ifndef _WIN32
-            fcntl(fd, F_SETFD, FD_CLOEXEC);
-#endif
+            qemu_set_cloexec(fd);

             break;
         }
     }
 
     /* set short latency */
             break;
         }
     }
 
     /* set short latency */

-    socket_set_nodelay(fd);
+    if (socket_set_nodelay(fd)) {
+        perror("setsockopt");
+        close(fd);
+        return false;
+    }

 
     s = g_malloc0(sizeof(GDBState));
     s->c_cpu = first_cpu;
 
     s = g_malloc0(sizeof(GDBState));
     s->c_cpu = first_cpu;


@@ -1804,6 +1853,7 @@ static void gdb_accept(void)
     gdb_has_xml = false;
 
     gdbserver_state = s;
     gdb_has_xml = false;
 
     gdbserver_state = s;

+    return true;

 }
 
 static int gdbserver_open(int port)
 }
 
 static int gdbserver_open(int port)


@@ -1816,9 +1866,7 @@ static int gdbserver_open(int port)
         perror("socket");
         return -1;
     }
         perror("socket");
         return -1;
     }

-#ifndef _WIN32
-    fcntl(fd, F_SETFD, FD_CLOEXEC);
-#endif
+    qemu_set_cloexec(fd);

 
     socket_set_fast_reuse(fd);
 
 
     socket_set_fast_reuse(fd);
 


@@ -1846,7 +1894,11 @@ int gdbserver_start(int port)
     if (gdbserver_fd < 0)
         return -1;
     /* accept connections */
     if (gdbserver_fd < 0)
         return -1;
     /* accept connections */

-    gdb_accept();
+    if (!gdb_accept()) {
+        close(gdbserver_fd);
+        gdbserver_fd = -1;
+        return -1;
+    }

     return 0;
 }
 
     return 0;
 }
 


@@ -1955,6 +2007,8 @@ static const TypeInfo char_gdb_type_info = {
 
 int gdbserver_start(const char *device)
 {
 
 int gdbserver_start(const char *device)
 {

+    trace_gdbstub_op_start(device);
+

     GDBState *s;
     char gdbstub_device_name[128];
     Chardev *chr = NULL;
     GDBState *s;
     char gdbstub_device_name[128];
     Chardev *chr = NULL;


@@ -1984,7 +2038,11 @@ int gdbserver_start(const char *device)
             sigaction(SIGINT, &act, NULL);
         }
 #endif
             sigaction(SIGINT, &act, NULL);
         }
 #endif

-        chr = qemu_chr_new_noreplay("gdb", device);
+        /*
+         * FIXME: it's a bit weird to allow using a mux chardev here
+         * and implicitly setup a monitor. We may want to break this.
+         */
+        chr = qemu_chr_new_noreplay("gdb", device, true);

         if (!chr)
             return -1;
     }
         if (!chr)
             return -1;
     }


@@ -2001,9 +2059,7 @@ int gdbserver_start(const char *device)
                                    NULL, &error_abort);
         monitor_init(mon_chr, 0);
     } else {
                                    NULL, &error_abort);
         monitor_init(mon_chr, 0);
     } else {

-        if (qemu_chr_fe_get_driver(&s->chr)) {
-            object_unparent(OBJECT(qemu_chr_fe_get_driver(&s->chr)));
-        }
+        qemu_chr_fe_deinit(&s->chr, true);

         mon_chr = s->mon_chr;
         memset(s, 0, sizeof(GDBState));
         s->mon_chr = mon_chr;
         mon_chr = s->mon_chr;
         memset(s, 0, sizeof(GDBState));
         s->mon_chr = mon_chr;


@@ -2013,7 +2069,7 @@ int gdbserver_start(const char *device)
     if (chr) {
         qemu_chr_fe_init(&s->chr, chr, &error_abort);
         qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,
     if (chr) {
         qemu_chr_fe_init(&s->chr, chr, &error_abort);
         qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,

-                                 gdb_chr_event, NULL, NULL, true);
+                                 gdb_chr_event, NULL, NULL, NULL, true);

     }
     s->state = chr ? RS_IDLE : RS_INACTIVE;
     s->mon_chr = mon_chr;
     }
     s->state = chr ? RS_IDLE : RS_INACTIVE;
     s->mon_chr = mon_chr;


@@ -2022,6 +2078,13 @@ int gdbserver_start(const char *device)
     return 0;
 }
 
     return 0;
 }
 

+void gdbserver_cleanup(void)
+{
+    if (gdbserver_state) {
+        put_packet(gdbserver_state, "W00");
+    }
+}
+

 static void register_types(void)
 {
     type_register_static(&char_gdb_type_info);
 static void register_types(void)
 {
     type_register_static(&char_gdb_type_info);