xref: /openbmc/qemu/gdbstub/gdbstub.c (revision 2b74dd91)
1 /*
2  * gdb server stub
3  *
4  * This implements a subset of the remote protocol as described in:
5  *
6  *   https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
7  *
8  * Copyright (c) 2003-2005 Fabrice Bellard
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
22  *
23  * SPDX-License-Identifier: LGPL-2.0-or-later
24  */
25 
26 #include "qemu/osdep.h"
27 #include "qemu/ctype.h"
28 #include "qemu/cutils.h"
29 #include "qemu/module.h"
30 #include "qemu/error-report.h"
31 #include "trace.h"
32 #include "exec/gdbstub.h"
33 #include "gdbstub/commands.h"
34 #include "gdbstub/syscalls.h"
35 #ifdef CONFIG_USER_ONLY
36 #include "accel/tcg/vcpu-state.h"
37 #include "gdbstub/user.h"
38 #else
39 #include "hw/cpu/cluster.h"
40 #include "hw/boards.h"
41 #endif
42 #include "hw/core/cpu.h"
43 
44 #include "sysemu/hw_accel.h"
45 #include "sysemu/runstate.h"
46 #include "exec/replay-core.h"
47 #include "exec/hwaddr.h"
48 
49 #include "internals.h"
50 
51 typedef struct GDBRegisterState {
52     int base_reg;
53     gdb_get_reg_cb get_reg;
54     gdb_set_reg_cb set_reg;
55     const GDBFeature *feature;
56 } GDBRegisterState;
57 
58 GDBState gdbserver_state;
59 
60 void gdb_init_gdbserver_state(void)
61 {
62     g_assert(!gdbserver_state.init);
63     memset(&gdbserver_state, 0, sizeof(GDBState));
64     gdbserver_state.init = true;
65     gdbserver_state.str_buf = g_string_new(NULL);
66     gdbserver_state.mem_buf = g_byte_array_sized_new(MAX_PACKET_LENGTH);
67     gdbserver_state.last_packet = g_byte_array_sized_new(MAX_PACKET_LENGTH + 4);
68 
69     /*
70      * What single-step modes are supported is accelerator dependent.
71      * By default try to use no IRQs and no timers while single
72      * stepping so as to make single stepping like a typical ICE HW step.
73      */
74     gdbserver_state.supported_sstep_flags = accel_supported_gdbstub_sstep_flags();
75     gdbserver_state.sstep_flags = SSTEP_ENABLE | SSTEP_NOIRQ | SSTEP_NOTIMER;
76     gdbserver_state.sstep_flags &= gdbserver_state.supported_sstep_flags;
77 }
78 
79 /* writes 2*len+1 bytes in buf */
80 void gdb_memtohex(GString *buf, const uint8_t *mem, int len)
81 {
82     int i, c;
83     for(i = 0; i < len; i++) {
84         c = mem[i];
85         g_string_append_c(buf, tohex(c >> 4));
86         g_string_append_c(buf, tohex(c & 0xf));
87     }
88     g_string_append_c(buf, '\0');
89 }
90 
91 void gdb_hextomem(GByteArray *mem, const char *buf, int len)
92 {
93     int i;
94 
95     for(i = 0; i < len; i++) {
96         guint8 byte = fromhex(buf[0]) << 4 | fromhex(buf[1]);
97         g_byte_array_append(mem, &byte, 1);
98         buf += 2;
99     }
100 }
101 
102 static void hexdump(const char *buf, int len,
103                     void (*trace_fn)(size_t ofs, char const *text))
104 {
105     char line_buffer[3 * 16 + 4 + 16 + 1];
106 
107     size_t i;
108     for (i = 0; i < len || (i & 0xF); ++i) {
109         size_t byte_ofs = i & 15;
110 
111         if (byte_ofs == 0) {
112             memset(line_buffer, ' ', 3 * 16 + 4 + 16);
113             line_buffer[3 * 16 + 4 + 16] = 0;
114         }
115 
116         size_t col_group = (i >> 2) & 3;
117         size_t hex_col = byte_ofs * 3 + col_group;
118         size_t txt_col = 3 * 16 + 4 + byte_ofs;
119 
120         if (i < len) {
121             char value = buf[i];
122 
123             line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
124             line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
125             line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
126                     ? value
127                     : '.';
128         }
129 
130         if (byte_ofs == 0xF)
131             trace_fn(i & -16, line_buffer);
132     }
133 }
134 
135 /* return -1 if error, 0 if OK */
136 int gdb_put_packet_binary(const char *buf, int len, bool dump)
137 {
138     int csum, i;
139     uint8_t footer[3];
140 
141     if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
142         hexdump(buf, len, trace_gdbstub_io_binaryreply);
143     }
144 
145     for(;;) {
146         g_byte_array_set_size(gdbserver_state.last_packet, 0);
147         g_byte_array_append(gdbserver_state.last_packet,
148                             (const uint8_t *) "$", 1);
149         g_byte_array_append(gdbserver_state.last_packet,
150                             (const uint8_t *) buf, len);
151         csum = 0;
152         for(i = 0; i < len; i++) {
153             csum += buf[i];
154         }
155         footer[0] = '#';
156         footer[1] = tohex((csum >> 4) & 0xf);
157         footer[2] = tohex((csum) & 0xf);
158         g_byte_array_append(gdbserver_state.last_packet, footer, 3);
159 
160         gdb_put_buffer(gdbserver_state.last_packet->data,
161                    gdbserver_state.last_packet->len);
162 
163         if (gdb_got_immediate_ack()) {
164             break;
165         }
166     }
167     return 0;
168 }
169 
170 /* return -1 if error, 0 if OK */
171 int gdb_put_packet(const char *buf)
172 {
173     trace_gdbstub_io_reply(buf);
174 
175     return gdb_put_packet_binary(buf, strlen(buf), false);
176 }
177 
178 void gdb_put_strbuf(void)
179 {
180     gdb_put_packet(gdbserver_state.str_buf->str);
181 }
182 
183 /* Encode data using the encoding for 'x' packets.  */
184 void gdb_memtox(GString *buf, const char *mem, int len)
185 {
186     char c;
187 
188     while (len--) {
189         c = *(mem++);
190         switch (c) {
191         case '#': case '$': case '*': case '}':
192             g_string_append_c(buf, '}');
193             g_string_append_c(buf, c ^ 0x20);
194             break;
195         default:
196             g_string_append_c(buf, c);
197             break;
198         }
199     }
200 }
201 
202 static uint32_t gdb_get_cpu_pid(CPUState *cpu)
203 {
204 #ifdef CONFIG_USER_ONLY
205     return getpid();
206 #else
207     if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) {
208         /* Return the default process' PID */
209         int index = gdbserver_state.process_num - 1;
210         return gdbserver_state.processes[index].pid;
211     }
212     return cpu->cluster_index + 1;
213 #endif
214 }
215 
216 GDBProcess *gdb_get_process(uint32_t pid)
217 {
218     int i;
219 
220     if (!pid) {
221         /* 0 means any process, we take the first one */
222         return &gdbserver_state.processes[0];
223     }
224 
225     for (i = 0; i < gdbserver_state.process_num; i++) {
226         if (gdbserver_state.processes[i].pid == pid) {
227             return &gdbserver_state.processes[i];
228         }
229     }
230 
231     return NULL;
232 }
233 
234 static GDBProcess *gdb_get_cpu_process(CPUState *cpu)
235 {
236     return gdb_get_process(gdb_get_cpu_pid(cpu));
237 }
238 
239 static CPUState *find_cpu(uint32_t thread_id)
240 {
241     CPUState *cpu;
242 
243     CPU_FOREACH(cpu) {
244         if (gdb_get_cpu_index(cpu) == thread_id) {
245             return cpu;
246         }
247     }
248 
249     return NULL;
250 }
251 
252 CPUState *gdb_get_first_cpu_in_process(GDBProcess *process)
253 {
254     CPUState *cpu;
255 
256     CPU_FOREACH(cpu) {
257         if (gdb_get_cpu_pid(cpu) == process->pid) {
258             return cpu;
259         }
260     }
261 
262     return NULL;
263 }
264 
265 static CPUState *gdb_next_cpu_in_process(CPUState *cpu)
266 {
267     uint32_t pid = gdb_get_cpu_pid(cpu);
268     cpu = CPU_NEXT(cpu);
269 
270     while (cpu) {
271         if (gdb_get_cpu_pid(cpu) == pid) {
272             break;
273         }
274 
275         cpu = CPU_NEXT(cpu);
276     }
277 
278     return cpu;
279 }
280 
281 /* Return the cpu following @cpu, while ignoring unattached processes. */
282 static CPUState *gdb_next_attached_cpu(CPUState *cpu)
283 {
284     cpu = CPU_NEXT(cpu);
285 
286     while (cpu) {
287         if (gdb_get_cpu_process(cpu)->attached) {
288             break;
289         }
290 
291         cpu = CPU_NEXT(cpu);
292     }
293 
294     return cpu;
295 }
296 
297 /* Return the first attached cpu */
298 CPUState *gdb_first_attached_cpu(void)
299 {
300     CPUState *cpu = first_cpu;
301     GDBProcess *process = gdb_get_cpu_process(cpu);
302 
303     if (!process->attached) {
304         return gdb_next_attached_cpu(cpu);
305     }
306 
307     return cpu;
308 }
309 
310 static CPUState *gdb_get_cpu(uint32_t pid, uint32_t tid)
311 {
312     GDBProcess *process;
313     CPUState *cpu;
314 
315     if (!pid && !tid) {
316         /* 0 means any process/thread, we take the first attached one */
317         return gdb_first_attached_cpu();
318     } else if (pid && !tid) {
319         /* any thread in a specific process */
320         process = gdb_get_process(pid);
321 
322         if (process == NULL) {
323             return NULL;
324         }
325 
326         if (!process->attached) {
327             return NULL;
328         }
329 
330         return gdb_get_first_cpu_in_process(process);
331     } else {
332         /* a specific thread */
333         cpu = find_cpu(tid);
334 
335         if (cpu == NULL) {
336             return NULL;
337         }
338 
339         process = gdb_get_cpu_process(cpu);
340 
341         if (pid && process->pid != pid) {
342             return NULL;
343         }
344 
345         if (!process->attached) {
346             return NULL;
347         }
348 
349         return cpu;
350     }
351 }
352 
353 static const char *get_feature_xml(const char *p, const char **newp,
354                                    GDBProcess *process)
355 {
356     CPUState *cpu = gdb_get_first_cpu_in_process(process);
357     CPUClass *cc = CPU_GET_CLASS(cpu);
358     GDBRegisterState *r;
359     size_t len;
360 
361     /*
362      * qXfer:features:read:ANNEX:OFFSET,LENGTH'
363      *                     ^p    ^newp
364      */
365     char *term = strchr(p, ':');
366     *newp = term + 1;
367     len = term - p;
368 
369     /* Is it the main target xml? */
370     if (strncmp(p, "target.xml", len) == 0) {
371         if (!process->target_xml) {
372             g_autoptr(GPtrArray) xml = g_ptr_array_new_with_free_func(g_free);
373 
374             g_ptr_array_add(
375                 xml,
376                 g_strdup("<?xml version=\"1.0\"?>"
377                          "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
378                          "<target>"));
379 
380             if (cc->gdb_arch_name) {
381                 g_ptr_array_add(
382                     xml,
383                     g_markup_printf_escaped("<architecture>%s</architecture>",
384                                             cc->gdb_arch_name(cpu)));
385             }
386             for (guint i = 0; i < cpu->gdb_regs->len; i++) {
387                 r = &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
388                 g_ptr_array_add(
389                     xml,
390                     g_markup_printf_escaped("<xi:include href=\"%s\"/>",
391                                             r->feature->xmlname));
392             }
393             g_ptr_array_add(xml, g_strdup("</target>"));
394             g_ptr_array_add(xml, NULL);
395 
396             process->target_xml = g_strjoinv(NULL, (void *)xml->pdata);
397         }
398         return process->target_xml;
399     }
400     /* Is it one of the features? */
401     for (guint i = 0; i < cpu->gdb_regs->len; i++) {
402         r = &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
403         if (strncmp(p, r->feature->xmlname, len) == 0) {
404             return r->feature->xml;
405         }
406     }
407 
408     /* failed */
409     return NULL;
410 }
411 
412 void gdb_feature_builder_init(GDBFeatureBuilder *builder, GDBFeature *feature,
413                               const char *name, const char *xmlname,
414                               int base_reg)
415 {
416     char *header = g_markup_printf_escaped(
417         "<?xml version=\"1.0\"?>"
418         "<!DOCTYPE feature SYSTEM \"gdb-target.dtd\">"
419         "<feature name=\"%s\">",
420         name);
421 
422     builder->feature = feature;
423     builder->xml = g_ptr_array_new();
424     g_ptr_array_add(builder->xml, header);
425     builder->regs = g_ptr_array_new();
426     builder->base_reg = base_reg;
427     feature->xmlname = xmlname;
428     feature->name = name;
429 }
430 
431 void gdb_feature_builder_append_tag(const GDBFeatureBuilder *builder,
432                                     const char *format, ...)
433 {
434     va_list ap;
435     va_start(ap, format);
436     g_ptr_array_add(builder->xml, g_markup_vprintf_escaped(format, ap));
437     va_end(ap);
438 }
439 
440 void gdb_feature_builder_append_reg(const GDBFeatureBuilder *builder,
441                                     const char *name,
442                                     int bitsize,
443                                     int regnum,
444                                     const char *type,
445                                     const char *group)
446 {
447     if (builder->regs->len <= regnum) {
448         g_ptr_array_set_size(builder->regs, regnum + 1);
449     }
450 
451     builder->regs->pdata[regnum] = (gpointer *)name;
452 
453     if (group) {
454         gdb_feature_builder_append_tag(
455             builder,
456             "<reg name=\"%s\" bitsize=\"%d\" regnum=\"%d\" type=\"%s\" group=\"%s\"/>",
457             name, bitsize, builder->base_reg + regnum, type, group);
458     } else {
459         gdb_feature_builder_append_tag(
460             builder,
461             "<reg name=\"%s\" bitsize=\"%d\" regnum=\"%d\" type=\"%s\"/>",
462             name, bitsize, builder->base_reg + regnum, type);
463     }
464 }
465 
466 void gdb_feature_builder_end(const GDBFeatureBuilder *builder)
467 {
468     g_ptr_array_add(builder->xml, (void *)"</feature>");
469     g_ptr_array_add(builder->xml, NULL);
470 
471     builder->feature->xml = g_strjoinv(NULL, (void *)builder->xml->pdata);
472 
473     for (guint i = 0; i < builder->xml->len - 2; i++) {
474         g_free(g_ptr_array_index(builder->xml, i));
475     }
476 
477     g_ptr_array_free(builder->xml, TRUE);
478 
479     builder->feature->num_regs = builder->regs->len;
480     builder->feature->regs = (void *)g_ptr_array_free(builder->regs, FALSE);
481 }
482 
483 const GDBFeature *gdb_find_static_feature(const char *xmlname)
484 {
485     const GDBFeature *feature;
486 
487     for (feature = gdb_static_features; feature->xmlname; feature++) {
488         if (!strcmp(feature->xmlname, xmlname)) {
489             return feature;
490         }
491     }
492 
493     g_assert_not_reached();
494 }
495 
496 GArray *gdb_get_register_list(CPUState *cpu)
497 {
498     GArray *results = g_array_new(true, true, sizeof(GDBRegDesc));
499 
500     /* registers are only available once the CPU is initialised */
501     if (!cpu->gdb_regs) {
502         return results;
503     }
504 
505     for (int f = 0; f < cpu->gdb_regs->len; f++) {
506         GDBRegisterState *r = &g_array_index(cpu->gdb_regs, GDBRegisterState, f);
507         for (int i = 0; i < r->feature->num_regs; i++) {
508             const char *name = r->feature->regs[i];
509             GDBRegDesc desc = {
510                 r->base_reg + i,
511                 name,
512                 r->feature->name
513             };
514             g_array_append_val(results, desc);
515         }
516     }
517 
518     return results;
519 }
520 
521 int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg)
522 {
523     CPUClass *cc = CPU_GET_CLASS(cpu);
524     GDBRegisterState *r;
525 
526     if (reg < cc->gdb_num_core_regs) {
527         return cc->gdb_read_register(cpu, buf, reg);
528     }
529 
530     for (guint i = 0; i < cpu->gdb_regs->len; i++) {
531         r = &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
532         if (r->base_reg <= reg && reg < r->base_reg + r->feature->num_regs) {
533             return r->get_reg(cpu, buf, reg - r->base_reg);
534         }
535     }
536     return 0;
537 }
538 
539 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
540 {
541     CPUClass *cc = CPU_GET_CLASS(cpu);
542     GDBRegisterState *r;
543 
544     if (reg < cc->gdb_num_core_regs) {
545         return cc->gdb_write_register(cpu, mem_buf, reg);
546     }
547 
548     for (guint i = 0; i < cpu->gdb_regs->len; i++) {
549         r =  &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
550         if (r->base_reg <= reg && reg < r->base_reg + r->feature->num_regs) {
551             return r->set_reg(cpu, mem_buf, reg - r->base_reg);
552         }
553     }
554     return 0;
555 }
556 
557 static void gdb_register_feature(CPUState *cpu, int base_reg,
558                                  gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
559                                  const GDBFeature *feature)
560 {
561     GDBRegisterState s = {
562         .base_reg = base_reg,
563         .get_reg = get_reg,
564         .set_reg = set_reg,
565         .feature = feature
566     };
567 
568     g_array_append_val(cpu->gdb_regs, s);
569 }
570 
571 void gdb_init_cpu(CPUState *cpu)
572 {
573     CPUClass *cc = CPU_GET_CLASS(cpu);
574     const GDBFeature *feature;
575 
576     cpu->gdb_regs = g_array_new(false, false, sizeof(GDBRegisterState));
577 
578     if (cc->gdb_core_xml_file) {
579         feature = gdb_find_static_feature(cc->gdb_core_xml_file);
580         gdb_register_feature(cpu, 0,
581                              cc->gdb_read_register, cc->gdb_write_register,
582                              feature);
583         cpu->gdb_num_regs = cpu->gdb_num_g_regs = feature->num_regs;
584     }
585 
586     if (cc->gdb_num_core_regs) {
587         cpu->gdb_num_regs = cpu->gdb_num_g_regs = cc->gdb_num_core_regs;
588     }
589 }
590 
591 void gdb_register_coprocessor(CPUState *cpu,
592                               gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
593                               const GDBFeature *feature, int g_pos)
594 {
595     GDBRegisterState *s;
596     guint i;
597     int base_reg = cpu->gdb_num_regs;
598 
599     for (i = 0; i < cpu->gdb_regs->len; i++) {
600         /* Check for duplicates.  */
601         s = &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
602         if (s->feature == feature) {
603             return;
604         }
605     }
606 
607     gdb_register_feature(cpu, base_reg, get_reg, set_reg, feature);
608 
609     /* Add to end of list.  */
610     cpu->gdb_num_regs += feature->num_regs;
611     if (g_pos) {
612         if (g_pos != base_reg) {
613             error_report("Error: Bad gdb register numbering for '%s', "
614                          "expected %d got %d", feature->xml, g_pos, base_reg);
615         } else {
616             cpu->gdb_num_g_regs = cpu->gdb_num_regs;
617         }
618     }
619 }
620 
621 void gdb_unregister_coprocessor_all(CPUState *cpu)
622 {
623     /*
624      * Safe to nuke everything. GDBRegisterState::xml is static const char so
625      * it won't be freed
626      */
627     g_array_free(cpu->gdb_regs, true);
628 
629     cpu->gdb_regs = NULL;
630     cpu->gdb_num_regs = 0;
631     cpu->gdb_num_g_regs = 0;
632 }
633 
634 static void gdb_process_breakpoint_remove_all(GDBProcess *p)
635 {
636     CPUState *cpu = gdb_get_first_cpu_in_process(p);
637 
638     while (cpu) {
639         gdb_breakpoint_remove_all(cpu);
640         cpu = gdb_next_cpu_in_process(cpu);
641     }
642 }
643 
644 
645 static void gdb_set_cpu_pc(vaddr pc)
646 {
647     CPUState *cpu = gdbserver_state.c_cpu;
648 
649     cpu_synchronize_state(cpu);
650     cpu_set_pc(cpu, pc);
651 }
652 
653 void gdb_append_thread_id(CPUState *cpu, GString *buf)
654 {
655     if (gdbserver_state.multiprocess) {
656         g_string_append_printf(buf, "p%02x.%02x",
657                                gdb_get_cpu_pid(cpu), gdb_get_cpu_index(cpu));
658     } else {
659         g_string_append_printf(buf, "%02x", gdb_get_cpu_index(cpu));
660     }
661 }
662 
663 static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
664                                       uint32_t *pid, uint32_t *tid)
665 {
666     unsigned long p, t;
667     int ret;
668 
669     if (*buf == 'p') {
670         buf++;
671         ret = qemu_strtoul(buf, &buf, 16, &p);
672 
673         if (ret) {
674             return GDB_READ_THREAD_ERR;
675         }
676 
677         /* Skip '.' */
678         buf++;
679     } else {
680         p = 0;
681     }
682 
683     ret = qemu_strtoul(buf, &buf, 16, &t);
684 
685     if (ret) {
686         return GDB_READ_THREAD_ERR;
687     }
688 
689     *end_buf = buf;
690 
691     if (p == -1) {
692         return GDB_ALL_PROCESSES;
693     }
694 
695     if (pid) {
696         *pid = p;
697     }
698 
699     if (t == -1) {
700         return GDB_ALL_THREADS;
701     }
702 
703     if (tid) {
704         *tid = t;
705     }
706 
707     return GDB_ONE_THREAD;
708 }
709 
710 /**
711  * gdb_handle_vcont - Parses and handles a vCont packet.
712  * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
713  *         a format error, 0 on success.
714  */
715 static int gdb_handle_vcont(const char *p)
716 {
717     int res, signal = 0;
718     char cur_action;
719     unsigned long tmp;
720     uint32_t pid, tid;
721     GDBProcess *process;
722     CPUState *cpu;
723     GDBThreadIdKind kind;
724     unsigned int max_cpus = gdb_get_max_cpus();
725     /* uninitialised CPUs stay 0 */
726     g_autofree char *newstates = g_new0(char, max_cpus);
727 
728     /* mark valid CPUs with 1 */
729     CPU_FOREACH(cpu) {
730         newstates[cpu->cpu_index] = 1;
731     }
732 
733     /*
734      * res keeps track of what error we are returning, with -ENOTSUP meaning
735      * that the command is unknown or unsupported, thus returning an empty
736      * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
737      *  or incorrect parameters passed.
738      */
739     res = 0;
740 
741     /*
742      * target_count and last_target keep track of how many CPUs we are going to
743      * step or resume, and a pointer to the state structure of one of them,
744      * respectively
745      */
746     int target_count = 0;
747     CPUState *last_target = NULL;
748 
749     while (*p) {
750         if (*p++ != ';') {
751             return -ENOTSUP;
752         }
753 
754         cur_action = *p++;
755         if (cur_action == 'C' || cur_action == 'S') {
756             cur_action = qemu_tolower(cur_action);
757             res = qemu_strtoul(p, &p, 16, &tmp);
758             if (res) {
759                 return res;
760             }
761             signal = gdb_signal_to_target(tmp);
762         } else if (cur_action != 'c' && cur_action != 's') {
763             /* unknown/invalid/unsupported command */
764             return -ENOTSUP;
765         }
766 
767         if (*p == '\0' || *p == ';') {
768             /*
769              * No thread specifier, action is on "all threads". The
770              * specification is unclear regarding the process to act on. We
771              * choose all processes.
772              */
773             kind = GDB_ALL_PROCESSES;
774         } else if (*p++ == ':') {
775             kind = read_thread_id(p, &p, &pid, &tid);
776         } else {
777             return -ENOTSUP;
778         }
779 
780         switch (kind) {
781         case GDB_READ_THREAD_ERR:
782             return -EINVAL;
783 
784         case GDB_ALL_PROCESSES:
785             cpu = gdb_first_attached_cpu();
786             while (cpu) {
787                 if (newstates[cpu->cpu_index] == 1) {
788                     newstates[cpu->cpu_index] = cur_action;
789 
790                     target_count++;
791                     last_target = cpu;
792                 }
793 
794                 cpu = gdb_next_attached_cpu(cpu);
795             }
796             break;
797 
798         case GDB_ALL_THREADS:
799             process = gdb_get_process(pid);
800 
801             if (!process->attached) {
802                 return -EINVAL;
803             }
804 
805             cpu = gdb_get_first_cpu_in_process(process);
806             while (cpu) {
807                 if (newstates[cpu->cpu_index] == 1) {
808                     newstates[cpu->cpu_index] = cur_action;
809 
810                     target_count++;
811                     last_target = cpu;
812                 }
813 
814                 cpu = gdb_next_cpu_in_process(cpu);
815             }
816             break;
817 
818         case GDB_ONE_THREAD:
819             cpu = gdb_get_cpu(pid, tid);
820 
821             /* invalid CPU/thread specified */
822             if (!cpu) {
823                 return -EINVAL;
824             }
825 
826             /* only use if no previous match occourred */
827             if (newstates[cpu->cpu_index] == 1) {
828                 newstates[cpu->cpu_index] = cur_action;
829 
830                 target_count++;
831                 last_target = cpu;
832             }
833             break;
834         }
835     }
836 
837     /*
838      * if we're about to resume a specific set of CPUs/threads, make it so that
839      * in case execution gets interrupted, we can send GDB a stop reply with a
840      * correct value. it doesn't really matter which CPU we tell GDB the signal
841      * happened in (VM pauses stop all of them anyway), so long as it is one of
842      * the ones we resumed/single stepped here.
843      */
844     if (target_count > 0) {
845         gdbserver_state.c_cpu = last_target;
846     }
847 
848     gdbserver_state.signal = signal;
849     gdb_continue_partial(newstates);
850     return res;
851 }
852 
853 static const char *cmd_next_param(const char *param, const char delimiter)
854 {
855     static const char all_delimiters[] = ",;:=";
856     char curr_delimiters[2] = {0};
857     const char *delimiters;
858 
859     if (delimiter == '?') {
860         delimiters = all_delimiters;
861     } else if (delimiter == '0') {
862         return strchr(param, '\0');
863     } else if (delimiter == '.' && *param) {
864         return param + 1;
865     } else {
866         curr_delimiters[0] = delimiter;
867         delimiters = curr_delimiters;
868     }
869 
870     param += strcspn(param, delimiters);
871     if (*param) {
872         param++;
873     }
874     return param;
875 }
876 
877 static int cmd_parse_params(const char *data, const char *schema,
878                             GArray *params)
879 {
880     const char *curr_schema, *curr_data;
881 
882     g_assert(schema);
883     g_assert(params->len == 0);
884 
885     curr_schema = schema;
886     curr_data = data;
887     while (curr_schema[0] && curr_schema[1] && *curr_data) {
888         GdbCmdVariant this_param;
889 
890         switch (curr_schema[0]) {
891         case 'l':
892             if (qemu_strtoul(curr_data, &curr_data, 16,
893                              &this_param.val_ul)) {
894                 return -EINVAL;
895             }
896             curr_data = cmd_next_param(curr_data, curr_schema[1]);
897             g_array_append_val(params, this_param);
898             break;
899         case 'L':
900             if (qemu_strtou64(curr_data, &curr_data, 16,
901                               (uint64_t *)&this_param.val_ull)) {
902                 return -EINVAL;
903             }
904             curr_data = cmd_next_param(curr_data, curr_schema[1]);
905             g_array_append_val(params, this_param);
906             break;
907         case 's':
908             this_param.data = curr_data;
909             curr_data = cmd_next_param(curr_data, curr_schema[1]);
910             g_array_append_val(params, this_param);
911             break;
912         case 'o':
913             this_param.opcode = *(uint8_t *)curr_data;
914             curr_data = cmd_next_param(curr_data, curr_schema[1]);
915             g_array_append_val(params, this_param);
916             break;
917         case 't':
918             this_param.thread_id.kind =
919                 read_thread_id(curr_data, &curr_data,
920                                &this_param.thread_id.pid,
921                                &this_param.thread_id.tid);
922             curr_data = cmd_next_param(curr_data, curr_schema[1]);
923             g_array_append_val(params, this_param);
924             break;
925         case '?':
926             curr_data = cmd_next_param(curr_data, curr_schema[1]);
927             break;
928         default:
929             return -EINVAL;
930         }
931         curr_schema += 2;
932     }
933 
934     return 0;
935 }
936 
937 static inline int startswith(const char *string, const char *pattern)
938 {
939   return !strncmp(string, pattern, strlen(pattern));
940 }
941 
942 static bool process_string_cmd(const char *data,
943                                const GdbCmdParseEntry *cmds, int num_cmds)
944 {
945     int i;
946     g_autoptr(GArray) params = g_array_new(false, true, sizeof(GdbCmdVariant));
947 
948     if (!cmds) {
949         return false;
950     }
951 
952     for (i = 0; i < num_cmds; i++) {
953         const GdbCmdParseEntry *cmd = &cmds[i];
954         void *user_ctx = NULL;
955         g_assert(cmd->handler && cmd->cmd);
956 
957         if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
958             (!cmd->cmd_startswith && strcmp(cmd->cmd, data))) {
959             continue;
960         }
961 
962         if (cmd->schema) {
963             if (cmd_parse_params(&data[strlen(cmd->cmd)],
964                                  cmd->schema, params)) {
965                 return false;
966             }
967         }
968 
969         if (cmd->need_cpu_context) {
970             user_ctx = (void *)gdbserver_state.g_cpu;
971         }
972 
973         gdbserver_state.allow_stop_reply = cmd->allow_stop_reply;
974         cmd->handler(params, user_ctx);
975         return true;
976     }
977 
978     return false;
979 }
980 
981 static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd)
982 {
983     if (!data) {
984         return;
985     }
986 
987     g_string_set_size(gdbserver_state.str_buf, 0);
988     g_byte_array_set_size(gdbserver_state.mem_buf, 0);
989 
990     /* In case there was an error during the command parsing we must
991     * send a NULL packet to indicate the command is not supported */
992     if (!process_string_cmd(data, cmd, 1)) {
993         gdb_put_packet("");
994     }
995 }
996 
997 static void handle_detach(GArray *params, void *user_ctx)
998 {
999     GDBProcess *process;
1000     uint32_t pid = 1;
1001 
1002     if (gdbserver_state.multiprocess) {
1003         if (!params->len) {
1004             gdb_put_packet("E22");
1005             return;
1006         }
1007 
1008         pid = gdb_get_cmd_param(params, 0)->val_ul;
1009     }
1010 
1011 #ifdef CONFIG_USER_ONLY
1012     if (gdb_handle_detach_user(pid)) {
1013         return;
1014     }
1015 #endif
1016 
1017     process = gdb_get_process(pid);
1018     gdb_process_breakpoint_remove_all(process);
1019     process->attached = false;
1020 
1021     if (pid == gdb_get_cpu_pid(gdbserver_state.c_cpu)) {
1022         gdbserver_state.c_cpu = gdb_first_attached_cpu();
1023     }
1024 
1025     if (pid == gdb_get_cpu_pid(gdbserver_state.g_cpu)) {
1026         gdbserver_state.g_cpu = gdb_first_attached_cpu();
1027     }
1028 
1029     if (!gdbserver_state.c_cpu) {
1030         /* No more process attached */
1031         gdb_disable_syscalls();
1032         gdb_continue();
1033     }
1034     gdb_put_packet("OK");
1035 }
1036 
1037 static void handle_thread_alive(GArray *params, void *user_ctx)
1038 {
1039     CPUState *cpu;
1040 
1041     if (!params->len) {
1042         gdb_put_packet("E22");
1043         return;
1044     }
1045 
1046     if (gdb_get_cmd_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
1047         gdb_put_packet("E22");
1048         return;
1049     }
1050 
1051     cpu = gdb_get_cpu(gdb_get_cmd_param(params, 0)->thread_id.pid,
1052                       gdb_get_cmd_param(params, 0)->thread_id.tid);
1053     if (!cpu) {
1054         gdb_put_packet("E22");
1055         return;
1056     }
1057 
1058     gdb_put_packet("OK");
1059 }
1060 
1061 static void handle_continue(GArray *params, void *user_ctx)
1062 {
1063     if (params->len) {
1064         gdb_set_cpu_pc(gdb_get_cmd_param(params, 0)->val_ull);
1065     }
1066 
1067     gdbserver_state.signal = 0;
1068     gdb_continue();
1069 }
1070 
1071 static void handle_cont_with_sig(GArray *params, void *user_ctx)
1072 {
1073     unsigned long signal = 0;
1074 
1075     /*
1076      * Note: C sig;[addr] is currently unsupported and we simply
1077      *       omit the addr parameter
1078      */
1079     if (params->len) {
1080         signal = gdb_get_cmd_param(params, 0)->val_ul;
1081     }
1082 
1083     gdbserver_state.signal = gdb_signal_to_target(signal);
1084     if (gdbserver_state.signal == -1) {
1085         gdbserver_state.signal = 0;
1086     }
1087     gdb_continue();
1088 }
1089 
1090 static void handle_set_thread(GArray *params, void *user_ctx)
1091 {
1092     uint32_t pid, tid;
1093     CPUState *cpu;
1094 
1095     if (params->len != 2) {
1096         gdb_put_packet("E22");
1097         return;
1098     }
1099 
1100     if (gdb_get_cmd_param(params, 1)->thread_id.kind == GDB_READ_THREAD_ERR) {
1101         gdb_put_packet("E22");
1102         return;
1103     }
1104 
1105     if (gdb_get_cmd_param(params, 1)->thread_id.kind != GDB_ONE_THREAD) {
1106         gdb_put_packet("OK");
1107         return;
1108     }
1109 
1110     pid = gdb_get_cmd_param(params, 1)->thread_id.pid;
1111     tid = gdb_get_cmd_param(params, 1)->thread_id.tid;
1112 #ifdef CONFIG_USER_ONLY
1113     if (gdb_handle_set_thread_user(pid, tid)) {
1114         return;
1115     }
1116 #endif
1117     cpu = gdb_get_cpu(pid, tid);
1118     if (!cpu) {
1119         gdb_put_packet("E22");
1120         return;
1121     }
1122 
1123     /*
1124      * Note: This command is deprecated and modern gdb's will be using the
1125      *       vCont command instead.
1126      */
1127     switch (gdb_get_cmd_param(params, 0)->opcode) {
1128     case 'c':
1129         gdbserver_state.c_cpu = cpu;
1130         gdb_put_packet("OK");
1131         break;
1132     case 'g':
1133         gdbserver_state.g_cpu = cpu;
1134         gdb_put_packet("OK");
1135         break;
1136     default:
1137         gdb_put_packet("E22");
1138         break;
1139     }
1140 }
1141 
1142 static void handle_insert_bp(GArray *params, void *user_ctx)
1143 {
1144     int res;
1145 
1146     if (params->len != 3) {
1147         gdb_put_packet("E22");
1148         return;
1149     }
1150 
1151     res = gdb_breakpoint_insert(gdbserver_state.c_cpu,
1152                                 gdb_get_cmd_param(params, 0)->val_ul,
1153                                 gdb_get_cmd_param(params, 1)->val_ull,
1154                                 gdb_get_cmd_param(params, 2)->val_ull);
1155     if (res >= 0) {
1156         gdb_put_packet("OK");
1157         return;
1158     } else if (res == -ENOSYS) {
1159         gdb_put_packet("");
1160         return;
1161     }
1162 
1163     gdb_put_packet("E22");
1164 }
1165 
1166 static void handle_remove_bp(GArray *params, void *user_ctx)
1167 {
1168     int res;
1169 
1170     if (params->len != 3) {
1171         gdb_put_packet("E22");
1172         return;
1173     }
1174 
1175     res = gdb_breakpoint_remove(gdbserver_state.c_cpu,
1176                                 gdb_get_cmd_param(params, 0)->val_ul,
1177                                 gdb_get_cmd_param(params, 1)->val_ull,
1178                                 gdb_get_cmd_param(params, 2)->val_ull);
1179     if (res >= 0) {
1180         gdb_put_packet("OK");
1181         return;
1182     } else if (res == -ENOSYS) {
1183         gdb_put_packet("");
1184         return;
1185     }
1186 
1187     gdb_put_packet("E22");
1188 }
1189 
1190 /*
1191  * handle_set/get_reg
1192  *
1193  * Older gdb are really dumb, and don't use 'G/g' if 'P/p' is available.
1194  * This works, but can be very slow. Anything new enough to understand
1195  * XML also knows how to use this properly. However to use this we
1196  * need to define a local XML file as well as be talking to a
1197  * reasonably modern gdb. Responding with an empty packet will cause
1198  * the remote gdb to fallback to older methods.
1199  */
1200 
1201 static void handle_set_reg(GArray *params, void *user_ctx)
1202 {
1203     int reg_size;
1204 
1205     if (params->len != 2) {
1206         gdb_put_packet("E22");
1207         return;
1208     }
1209 
1210     reg_size = strlen(gdb_get_cmd_param(params, 1)->data) / 2;
1211     gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 1)->data, reg_size);
1212     gdb_write_register(gdbserver_state.g_cpu, gdbserver_state.mem_buf->data,
1213                        gdb_get_cmd_param(params, 0)->val_ull);
1214     gdb_put_packet("OK");
1215 }
1216 
1217 static void handle_get_reg(GArray *params, void *user_ctx)
1218 {
1219     int reg_size;
1220 
1221     if (!params->len) {
1222         gdb_put_packet("E14");
1223         return;
1224     }
1225 
1226     reg_size = gdb_read_register(gdbserver_state.g_cpu,
1227                                  gdbserver_state.mem_buf,
1228                                  gdb_get_cmd_param(params, 0)->val_ull);
1229     if (!reg_size) {
1230         gdb_put_packet("E14");
1231         return;
1232     } else {
1233         g_byte_array_set_size(gdbserver_state.mem_buf, reg_size);
1234     }
1235 
1236     gdb_memtohex(gdbserver_state.str_buf,
1237                  gdbserver_state.mem_buf->data, reg_size);
1238     gdb_put_strbuf();
1239 }
1240 
1241 static void handle_write_mem(GArray *params, void *user_ctx)
1242 {
1243     if (params->len != 3) {
1244         gdb_put_packet("E22");
1245         return;
1246     }
1247 
1248     /* gdb_hextomem() reads 2*len bytes */
1249     if (gdb_get_cmd_param(params, 1)->val_ull >
1250         strlen(gdb_get_cmd_param(params, 2)->data) / 2) {
1251         gdb_put_packet("E22");
1252         return;
1253     }
1254 
1255     gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 2)->data,
1256                  gdb_get_cmd_param(params, 1)->val_ull);
1257     if (gdb_target_memory_rw_debug(gdbserver_state.g_cpu,
1258                                    gdb_get_cmd_param(params, 0)->val_ull,
1259                                    gdbserver_state.mem_buf->data,
1260                                    gdbserver_state.mem_buf->len, true)) {
1261         gdb_put_packet("E14");
1262         return;
1263     }
1264 
1265     gdb_put_packet("OK");
1266 }
1267 
1268 static void handle_read_mem(GArray *params, void *user_ctx)
1269 {
1270     if (params->len != 2) {
1271         gdb_put_packet("E22");
1272         return;
1273     }
1274 
1275     /* gdb_memtohex() doubles the required space */
1276     if (gdb_get_cmd_param(params, 1)->val_ull > MAX_PACKET_LENGTH / 2) {
1277         gdb_put_packet("E22");
1278         return;
1279     }
1280 
1281     g_byte_array_set_size(gdbserver_state.mem_buf,
1282                           gdb_get_cmd_param(params, 1)->val_ull);
1283 
1284     if (gdb_target_memory_rw_debug(gdbserver_state.g_cpu,
1285                                    gdb_get_cmd_param(params, 0)->val_ull,
1286                                    gdbserver_state.mem_buf->data,
1287                                    gdbserver_state.mem_buf->len, false)) {
1288         gdb_put_packet("E14");
1289         return;
1290     }
1291 
1292     gdb_memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data,
1293              gdbserver_state.mem_buf->len);
1294     gdb_put_strbuf();
1295 }
1296 
1297 static void handle_write_all_regs(GArray *params, void *user_ctx)
1298 {
1299     int reg_id;
1300     size_t len;
1301     uint8_t *registers;
1302     int reg_size;
1303 
1304     if (!params->len) {
1305         return;
1306     }
1307 
1308     cpu_synchronize_state(gdbserver_state.g_cpu);
1309     len = strlen(gdb_get_cmd_param(params, 0)->data) / 2;
1310     gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 0)->data, len);
1311     registers = gdbserver_state.mem_buf->data;
1312     for (reg_id = 0;
1313          reg_id < gdbserver_state.g_cpu->gdb_num_g_regs && len > 0;
1314          reg_id++) {
1315         reg_size = gdb_write_register(gdbserver_state.g_cpu, registers, reg_id);
1316         len -= reg_size;
1317         registers += reg_size;
1318     }
1319     gdb_put_packet("OK");
1320 }
1321 
1322 static void handle_read_all_regs(GArray *params, void *user_ctx)
1323 {
1324     int reg_id;
1325     size_t len;
1326 
1327     cpu_synchronize_state(gdbserver_state.g_cpu);
1328     g_byte_array_set_size(gdbserver_state.mem_buf, 0);
1329     len = 0;
1330     for (reg_id = 0; reg_id < gdbserver_state.g_cpu->gdb_num_g_regs; reg_id++) {
1331         len += gdb_read_register(gdbserver_state.g_cpu,
1332                                  gdbserver_state.mem_buf,
1333                                  reg_id);
1334     }
1335     g_assert(len == gdbserver_state.mem_buf->len);
1336 
1337     gdb_memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, len);
1338     gdb_put_strbuf();
1339 }
1340 
1341 
1342 static void handle_step(GArray *params, void *user_ctx)
1343 {
1344     if (params->len) {
1345         gdb_set_cpu_pc(gdb_get_cmd_param(params, 0)->val_ull);
1346     }
1347 
1348     cpu_single_step(gdbserver_state.c_cpu, gdbserver_state.sstep_flags);
1349     gdb_continue();
1350 }
1351 
1352 static void handle_backward(GArray *params, void *user_ctx)
1353 {
1354     if (!gdb_can_reverse()) {
1355         gdb_put_packet("E22");
1356     }
1357     if (params->len == 1) {
1358         switch (gdb_get_cmd_param(params, 0)->opcode) {
1359         case 's':
1360             if (replay_reverse_step()) {
1361                 gdb_continue();
1362             } else {
1363                 gdb_put_packet("E14");
1364             }
1365             return;
1366         case 'c':
1367             if (replay_reverse_continue()) {
1368                 gdb_continue();
1369             } else {
1370                 gdb_put_packet("E14");
1371             }
1372             return;
1373         }
1374     }
1375 
1376     /* Default invalid command */
1377     gdb_put_packet("");
1378 }
1379 
1380 static void handle_v_cont_query(GArray *params, void *user_ctx)
1381 {
1382     gdb_put_packet("vCont;c;C;s;S");
1383 }
1384 
1385 static void handle_v_cont(GArray *params, void *user_ctx)
1386 {
1387     int res;
1388 
1389     if (!params->len) {
1390         return;
1391     }
1392 
1393     res = gdb_handle_vcont(gdb_get_cmd_param(params, 0)->data);
1394     if ((res == -EINVAL) || (res == -ERANGE)) {
1395         gdb_put_packet("E22");
1396     } else if (res) {
1397         gdb_put_packet("");
1398     }
1399 }
1400 
1401 static void handle_v_attach(GArray *params, void *user_ctx)
1402 {
1403     GDBProcess *process;
1404     CPUState *cpu;
1405 
1406     g_string_assign(gdbserver_state.str_buf, "E22");
1407     if (!params->len) {
1408         goto cleanup;
1409     }
1410 
1411     process = gdb_get_process(gdb_get_cmd_param(params, 0)->val_ul);
1412     if (!process) {
1413         goto cleanup;
1414     }
1415 
1416     cpu = gdb_get_first_cpu_in_process(process);
1417     if (!cpu) {
1418         goto cleanup;
1419     }
1420 
1421     process->attached = true;
1422     gdbserver_state.g_cpu = cpu;
1423     gdbserver_state.c_cpu = cpu;
1424 
1425     if (gdbserver_state.allow_stop_reply) {
1426         g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
1427         gdb_append_thread_id(cpu, gdbserver_state.str_buf);
1428         g_string_append_c(gdbserver_state.str_buf, ';');
1429         gdbserver_state.allow_stop_reply = false;
1430 cleanup:
1431         gdb_put_strbuf();
1432     }
1433 }
1434 
1435 static void handle_v_kill(GArray *params, void *user_ctx)
1436 {
1437     /* Kill the target */
1438     gdb_put_packet("OK");
1439     error_report("QEMU: Terminated via GDBstub");
1440     gdb_exit(0);
1441     gdb_qemu_exit(0);
1442 }
1443 
1444 static const GdbCmdParseEntry gdb_v_commands_table[] = {
1445     /* Order is important if has same prefix */
1446     {
1447         .handler = handle_v_cont_query,
1448         .cmd = "Cont?",
1449         .cmd_startswith = true
1450     },
1451     {
1452         .handler = handle_v_cont,
1453         .cmd = "Cont",
1454         .cmd_startswith = true,
1455         .allow_stop_reply = true,
1456         .schema = "s0"
1457     },
1458     {
1459         .handler = handle_v_attach,
1460         .cmd = "Attach;",
1461         .cmd_startswith = true,
1462         .allow_stop_reply = true,
1463         .schema = "l0"
1464     },
1465     {
1466         .handler = handle_v_kill,
1467         .cmd = "Kill;",
1468         .cmd_startswith = true
1469     },
1470 #ifdef CONFIG_USER_ONLY
1471     /*
1472      * Host I/O Packets. See [1] for details.
1473      * [1] https://sourceware.org/gdb/onlinedocs/gdb/Host-I_002fO-Packets.html
1474      */
1475     {
1476         .handler = gdb_handle_v_file_open,
1477         .cmd = "File:open:",
1478         .cmd_startswith = true,
1479         .schema = "s,L,L0"
1480     },
1481     {
1482         .handler = gdb_handle_v_file_close,
1483         .cmd = "File:close:",
1484         .cmd_startswith = true,
1485         .schema = "l0"
1486     },
1487     {
1488         .handler = gdb_handle_v_file_pread,
1489         .cmd = "File:pread:",
1490         .cmd_startswith = true,
1491         .schema = "l,L,L0"
1492     },
1493     {
1494         .handler = gdb_handle_v_file_readlink,
1495         .cmd = "File:readlink:",
1496         .cmd_startswith = true,
1497         .schema = "s0"
1498     },
1499 #endif
1500 };
1501 
1502 static void handle_v_commands(GArray *params, void *user_ctx)
1503 {
1504     if (!params->len) {
1505         return;
1506     }
1507 
1508     if (!process_string_cmd(gdb_get_cmd_param(params, 0)->data,
1509                             gdb_v_commands_table,
1510                             ARRAY_SIZE(gdb_v_commands_table))) {
1511         gdb_put_packet("");
1512     }
1513 }
1514 
1515 static void handle_query_qemu_sstepbits(GArray *params, void *user_ctx)
1516 {
1517     g_string_printf(gdbserver_state.str_buf, "ENABLE=%x", SSTEP_ENABLE);
1518 
1519     if (gdbserver_state.supported_sstep_flags & SSTEP_NOIRQ) {
1520         g_string_append_printf(gdbserver_state.str_buf, ",NOIRQ=%x",
1521                                SSTEP_NOIRQ);
1522     }
1523 
1524     if (gdbserver_state.supported_sstep_flags & SSTEP_NOTIMER) {
1525         g_string_append_printf(gdbserver_state.str_buf, ",NOTIMER=%x",
1526                                SSTEP_NOTIMER);
1527     }
1528 
1529     gdb_put_strbuf();
1530 }
1531 
1532 static void handle_set_qemu_sstep(GArray *params, void *user_ctx)
1533 {
1534     int new_sstep_flags;
1535 
1536     if (!params->len) {
1537         return;
1538     }
1539 
1540     new_sstep_flags = gdb_get_cmd_param(params, 0)->val_ul;
1541 
1542     if (new_sstep_flags  & ~gdbserver_state.supported_sstep_flags) {
1543         gdb_put_packet("E22");
1544         return;
1545     }
1546 
1547     gdbserver_state.sstep_flags = new_sstep_flags;
1548     gdb_put_packet("OK");
1549 }
1550 
1551 static void handle_query_qemu_sstep(GArray *params, void *user_ctx)
1552 {
1553     g_string_printf(gdbserver_state.str_buf, "0x%x",
1554                     gdbserver_state.sstep_flags);
1555     gdb_put_strbuf();
1556 }
1557 
1558 static void handle_query_curr_tid(GArray *params, void *user_ctx)
1559 {
1560     CPUState *cpu;
1561     GDBProcess *process;
1562 
1563     /*
1564      * "Current thread" remains vague in the spec, so always return
1565      * the first thread of the current process (gdb returns the
1566      * first thread).
1567      */
1568     process = gdb_get_cpu_process(gdbserver_state.g_cpu);
1569     cpu = gdb_get_first_cpu_in_process(process);
1570     g_string_assign(gdbserver_state.str_buf, "QC");
1571     gdb_append_thread_id(cpu, gdbserver_state.str_buf);
1572     gdb_put_strbuf();
1573 }
1574 
1575 static void handle_query_threads(GArray *params, void *user_ctx)
1576 {
1577     if (!gdbserver_state.query_cpu) {
1578         gdb_put_packet("l");
1579         return;
1580     }
1581 
1582     g_string_assign(gdbserver_state.str_buf, "m");
1583     gdb_append_thread_id(gdbserver_state.query_cpu, gdbserver_state.str_buf);
1584     gdb_put_strbuf();
1585     gdbserver_state.query_cpu = gdb_next_attached_cpu(gdbserver_state.query_cpu);
1586 }
1587 
1588 static void handle_query_first_threads(GArray *params, void *user_ctx)
1589 {
1590     gdbserver_state.query_cpu = gdb_first_attached_cpu();
1591     handle_query_threads(params, user_ctx);
1592 }
1593 
1594 static void handle_query_thread_extra(GArray *params, void *user_ctx)
1595 {
1596     g_autoptr(GString) rs = g_string_new(NULL);
1597     CPUState *cpu;
1598 
1599     if (!params->len ||
1600         gdb_get_cmd_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
1601         gdb_put_packet("E22");
1602         return;
1603     }
1604 
1605     cpu = gdb_get_cpu(gdb_get_cmd_param(params, 0)->thread_id.pid,
1606                       gdb_get_cmd_param(params, 0)->thread_id.tid);
1607     if (!cpu) {
1608         return;
1609     }
1610 
1611     cpu_synchronize_state(cpu);
1612 
1613     if (gdbserver_state.multiprocess && (gdbserver_state.process_num > 1)) {
1614         /* Print the CPU model and name in multiprocess mode */
1615         ObjectClass *oc = object_get_class(OBJECT(cpu));
1616         const char *cpu_model = object_class_get_name(oc);
1617         const char *cpu_name =
1618             object_get_canonical_path_component(OBJECT(cpu));
1619         g_string_printf(rs, "%s %s [%s]", cpu_model, cpu_name,
1620                         cpu->halted ? "halted " : "running");
1621     } else {
1622         g_string_printf(rs, "CPU#%d [%s]", cpu->cpu_index,
1623                         cpu->halted ? "halted " : "running");
1624     }
1625     trace_gdbstub_op_extra_info(rs->str);
1626     gdb_memtohex(gdbserver_state.str_buf, (uint8_t *)rs->str, rs->len);
1627     gdb_put_strbuf();
1628 }
1629 
1630 
1631 static char **extra_query_flags;
1632 
1633 void gdb_extend_qsupported_features(char *qflags)
1634 {
1635     if (!extra_query_flags) {
1636         extra_query_flags = g_new0(char *, 2);
1637         extra_query_flags[0] = g_strdup(qflags);
1638     } else if (!g_strv_contains((const gchar * const *) extra_query_flags,
1639                                 qflags)) {
1640         int len = g_strv_length(extra_query_flags);
1641         extra_query_flags = g_realloc_n(extra_query_flags, len + 2,
1642                                         sizeof(char *));
1643         extra_query_flags[len] = g_strdup(qflags);
1644     }
1645 }
1646 
1647 static void handle_query_supported(GArray *params, void *user_ctx)
1648 {
1649     CPUClass *cc;
1650 
1651     g_string_printf(gdbserver_state.str_buf, "PacketSize=%x", MAX_PACKET_LENGTH);
1652     cc = CPU_GET_CLASS(first_cpu);
1653     if (cc->gdb_core_xml_file) {
1654         g_string_append(gdbserver_state.str_buf, ";qXfer:features:read+");
1655     }
1656 
1657     if (gdb_can_reverse()) {
1658         g_string_append(gdbserver_state.str_buf,
1659             ";ReverseStep+;ReverseContinue+");
1660     }
1661 
1662 #if defined(CONFIG_USER_ONLY)
1663 #if defined(CONFIG_LINUX)
1664     if (get_task_state(gdbserver_state.c_cpu)) {
1665         g_string_append(gdbserver_state.str_buf, ";qXfer:auxv:read+");
1666     }
1667     g_string_append(gdbserver_state.str_buf, ";QCatchSyscalls+");
1668 
1669     g_string_append(gdbserver_state.str_buf, ";qXfer:siginfo:read+");
1670 #endif
1671     g_string_append(gdbserver_state.str_buf, ";qXfer:exec-file:read+");
1672 #endif
1673 
1674     if (params->len) {
1675         const char *gdb_supported = gdb_get_cmd_param(params, 0)->data;
1676 
1677         if (strstr(gdb_supported, "multiprocess+")) {
1678             gdbserver_state.multiprocess = true;
1679         }
1680 #if defined(CONFIG_USER_ONLY)
1681         gdb_handle_query_supported_user(gdb_supported);
1682 #endif
1683     }
1684 
1685     g_string_append(gdbserver_state.str_buf, ";vContSupported+;multiprocess+");
1686 
1687     if (extra_query_flags) {
1688         int extras = g_strv_length(extra_query_flags);
1689         for (int i = 0; i < extras; i++) {
1690             g_string_append(gdbserver_state.str_buf, extra_query_flags[i]);
1691         }
1692     }
1693 
1694     gdb_put_strbuf();
1695 }
1696 
1697 static void handle_query_xfer_features(GArray *params, void *user_ctx)
1698 {
1699     GDBProcess *process;
1700     CPUClass *cc;
1701     unsigned long len, total_len, addr;
1702     const char *xml;
1703     const char *p;
1704 
1705     if (params->len < 3) {
1706         gdb_put_packet("E22");
1707         return;
1708     }
1709 
1710     process = gdb_get_cpu_process(gdbserver_state.g_cpu);
1711     cc = CPU_GET_CLASS(gdbserver_state.g_cpu);
1712     if (!cc->gdb_core_xml_file) {
1713         gdb_put_packet("");
1714         return;
1715     }
1716 
1717     p = gdb_get_cmd_param(params, 0)->data;
1718     xml = get_feature_xml(p, &p, process);
1719     if (!xml) {
1720         gdb_put_packet("E00");
1721         return;
1722     }
1723 
1724     addr = gdb_get_cmd_param(params, 1)->val_ul;
1725     len = gdb_get_cmd_param(params, 2)->val_ul;
1726     total_len = strlen(xml);
1727     if (addr > total_len) {
1728         gdb_put_packet("E00");
1729         return;
1730     }
1731 
1732     if (len > (MAX_PACKET_LENGTH - 5) / 2) {
1733         len = (MAX_PACKET_LENGTH - 5) / 2;
1734     }
1735 
1736     if (len < total_len - addr) {
1737         g_string_assign(gdbserver_state.str_buf, "m");
1738         gdb_memtox(gdbserver_state.str_buf, xml + addr, len);
1739     } else {
1740         g_string_assign(gdbserver_state.str_buf, "l");
1741         gdb_memtox(gdbserver_state.str_buf, xml + addr, total_len - addr);
1742     }
1743 
1744     gdb_put_packet_binary(gdbserver_state.str_buf->str,
1745                       gdbserver_state.str_buf->len, true);
1746 }
1747 
1748 static void handle_query_qemu_supported(GArray *params, void *user_ctx)
1749 {
1750     g_string_printf(gdbserver_state.str_buf, "sstepbits;sstep");
1751 #ifndef CONFIG_USER_ONLY
1752     g_string_append(gdbserver_state.str_buf, ";PhyMemMode");
1753 #endif
1754     gdb_put_strbuf();
1755 }
1756 
1757 static const GdbCmdParseEntry gdb_gen_query_set_common_table[] = {
1758     /* Order is important if has same prefix */
1759     {
1760         .handler = handle_query_qemu_sstepbits,
1761         .cmd = "qemu.sstepbits",
1762     },
1763     {
1764         .handler = handle_query_qemu_sstep,
1765         .cmd = "qemu.sstep",
1766     },
1767     {
1768         .handler = handle_set_qemu_sstep,
1769         .cmd = "qemu.sstep=",
1770         .cmd_startswith = true,
1771         .schema = "l0"
1772     },
1773 };
1774 
1775 /**
1776  * extend_table() - extend one of the command tables
1777  * @table: the command table to extend (or NULL)
1778  * @extensions: a list of GdbCmdParseEntry pointers
1779  *
1780  * The entries themselves should be pointers to static const
1781  * GdbCmdParseEntry entries. If the entry is already in the table we
1782  * skip adding it again.
1783  *
1784  * Returns (a potentially freshly allocated) GPtrArray of GdbCmdParseEntry
1785  */
1786 static GPtrArray *extend_table(GPtrArray *table, GPtrArray *extensions)
1787 {
1788     if (!table) {
1789         table = g_ptr_array_new();
1790     }
1791 
1792     for (int i = 0; i < extensions->len; i++) {
1793         gpointer entry = g_ptr_array_index(extensions, i);
1794         if (!g_ptr_array_find(table, entry, NULL)) {
1795             g_ptr_array_add(table, entry);
1796         }
1797     }
1798 
1799     return table;
1800 }
1801 
1802 /**
1803  * process_extended_table() - run through an extended command table
1804  * @table: the command table to check
1805  * @data: parameters
1806  *
1807  * returns true if the command was found and executed
1808  */
1809 static bool process_extended_table(GPtrArray *table, const char *data)
1810 {
1811     for (int i = 0; i < table->len; i++) {
1812         const GdbCmdParseEntry *entry = g_ptr_array_index(table, i);
1813         if (process_string_cmd(data, entry, 1)) {
1814             return true;
1815         }
1816     }
1817     return false;
1818 }
1819 
1820 
1821 /* Ptr to GdbCmdParseEntry */
1822 static GPtrArray *extended_query_table;
1823 
1824 void gdb_extend_query_table(GPtrArray *new_queries)
1825 {
1826     extended_query_table = extend_table(extended_query_table, new_queries);
1827 }
1828 
1829 static const GdbCmdParseEntry gdb_gen_query_table[] = {
1830     {
1831         .handler = handle_query_curr_tid,
1832         .cmd = "C",
1833     },
1834     {
1835         .handler = handle_query_threads,
1836         .cmd = "sThreadInfo",
1837     },
1838     {
1839         .handler = handle_query_first_threads,
1840         .cmd = "fThreadInfo",
1841     },
1842     {
1843         .handler = handle_query_thread_extra,
1844         .cmd = "ThreadExtraInfo,",
1845         .cmd_startswith = true,
1846         .schema = "t0"
1847     },
1848 #ifdef CONFIG_USER_ONLY
1849     {
1850         .handler = gdb_handle_query_offsets,
1851         .cmd = "Offsets",
1852     },
1853 #else
1854     {
1855         .handler = gdb_handle_query_rcmd,
1856         .cmd = "Rcmd,",
1857         .cmd_startswith = true,
1858         .schema = "s0"
1859     },
1860 #endif
1861     {
1862         .handler = handle_query_supported,
1863         .cmd = "Supported:",
1864         .cmd_startswith = true,
1865         .schema = "s0"
1866     },
1867     {
1868         .handler = handle_query_supported,
1869         .cmd = "Supported",
1870         .schema = "s0"
1871     },
1872     {
1873         .handler = handle_query_xfer_features,
1874         .cmd = "Xfer:features:read:",
1875         .cmd_startswith = true,
1876         .schema = "s:l,l0"
1877     },
1878 #if defined(CONFIG_USER_ONLY)
1879 #if defined(CONFIG_LINUX)
1880     {
1881         .handler = gdb_handle_query_xfer_auxv,
1882         .cmd = "Xfer:auxv:read::",
1883         .cmd_startswith = true,
1884         .schema = "l,l0"
1885     },
1886     {
1887         .handler = gdb_handle_query_xfer_siginfo,
1888         .cmd = "Xfer:siginfo:read::",
1889         .cmd_startswith = true,
1890         .schema = "l,l0"
1891      },
1892 #endif
1893     {
1894         .handler = gdb_handle_query_xfer_exec_file,
1895         .cmd = "Xfer:exec-file:read:",
1896         .cmd_startswith = true,
1897         .schema = "l:l,l0"
1898     },
1899 #endif
1900     {
1901         .handler = gdb_handle_query_attached,
1902         .cmd = "Attached:",
1903         .cmd_startswith = true
1904     },
1905     {
1906         .handler = gdb_handle_query_attached,
1907         .cmd = "Attached",
1908     },
1909     {
1910         .handler = handle_query_qemu_supported,
1911         .cmd = "qemu.Supported",
1912     },
1913 #ifndef CONFIG_USER_ONLY
1914     {
1915         .handler = gdb_handle_query_qemu_phy_mem_mode,
1916         .cmd = "qemu.PhyMemMode",
1917     },
1918 #endif
1919 };
1920 
1921 /* Ptr to GdbCmdParseEntry */
1922 static GPtrArray *extended_set_table;
1923 
1924 void gdb_extend_set_table(GPtrArray *new_set)
1925 {
1926     extended_set_table = extend_table(extended_set_table, new_set);
1927 }
1928 
1929 static const GdbCmdParseEntry gdb_gen_set_table[] = {
1930     /* Order is important if has same prefix */
1931     {
1932         .handler = handle_set_qemu_sstep,
1933         .cmd = "qemu.sstep:",
1934         .cmd_startswith = true,
1935         .schema = "l0"
1936     },
1937 #ifndef CONFIG_USER_ONLY
1938     {
1939         .handler = gdb_handle_set_qemu_phy_mem_mode,
1940         .cmd = "qemu.PhyMemMode:",
1941         .cmd_startswith = true,
1942         .schema = "l0"
1943     },
1944 #endif
1945 #if defined(CONFIG_USER_ONLY)
1946     {
1947         .handler = gdb_handle_set_catch_syscalls,
1948         .cmd = "CatchSyscalls:",
1949         .cmd_startswith = true,
1950         .schema = "s0",
1951     },
1952 #endif
1953 };
1954 
1955 static void handle_gen_query(GArray *params, void *user_ctx)
1956 {
1957     const char *data;
1958 
1959     if (!params->len) {
1960         return;
1961     }
1962 
1963     data = gdb_get_cmd_param(params, 0)->data;
1964 
1965     if (process_string_cmd(data,
1966                            gdb_gen_query_set_common_table,
1967                            ARRAY_SIZE(gdb_gen_query_set_common_table))) {
1968         return;
1969     }
1970 
1971     if (process_string_cmd(data,
1972                            gdb_gen_query_table,
1973                            ARRAY_SIZE(gdb_gen_query_table))) {
1974         return;
1975     }
1976 
1977     if (extended_query_table &&
1978         process_extended_table(extended_query_table, data)) {
1979         return;
1980     }
1981 
1982     /* Can't handle query, return Empty response. */
1983     gdb_put_packet("");
1984 }
1985 
1986 static void handle_gen_set(GArray *params, void *user_ctx)
1987 {
1988     const char *data;
1989 
1990     if (!params->len) {
1991         return;
1992     }
1993 
1994     data = gdb_get_cmd_param(params, 0)->data;
1995 
1996     if (process_string_cmd(data,
1997                            gdb_gen_query_set_common_table,
1998                            ARRAY_SIZE(gdb_gen_query_set_common_table))) {
1999         return;
2000     }
2001 
2002     if (process_string_cmd(data,
2003                            gdb_gen_set_table,
2004                            ARRAY_SIZE(gdb_gen_set_table))) {
2005         return;
2006     }
2007 
2008     if (extended_set_table &&
2009         process_extended_table(extended_set_table, data)) {
2010         return;
2011     }
2012 
2013     /* Can't handle set, return Empty response. */
2014     gdb_put_packet("");
2015 }
2016 
2017 static void handle_target_halt(GArray *params, void *user_ctx)
2018 {
2019     if (gdbserver_state.allow_stop_reply) {
2020         g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
2021         gdb_append_thread_id(gdbserver_state.c_cpu, gdbserver_state.str_buf);
2022         g_string_append_c(gdbserver_state.str_buf, ';');
2023         gdb_put_strbuf();
2024         gdbserver_state.allow_stop_reply = false;
2025     }
2026     /*
2027      * Remove all the breakpoints when this query is issued,
2028      * because gdb is doing an initial connect and the state
2029      * should be cleaned up.
2030      */
2031     gdb_breakpoint_remove_all(gdbserver_state.c_cpu);
2032 }
2033 
2034 static int gdb_handle_packet(const char *line_buf)
2035 {
2036     const GdbCmdParseEntry *cmd_parser = NULL;
2037 
2038     trace_gdbstub_io_command(line_buf);
2039 
2040     switch (line_buf[0]) {
2041     case '!':
2042         gdb_put_packet("OK");
2043         break;
2044     case '?':
2045         {
2046             static const GdbCmdParseEntry target_halted_cmd_desc = {
2047                 .handler = handle_target_halt,
2048                 .cmd = "?",
2049                 .cmd_startswith = true,
2050                 .allow_stop_reply = true,
2051             };
2052             cmd_parser = &target_halted_cmd_desc;
2053         }
2054         break;
2055     case 'c':
2056         {
2057             static const GdbCmdParseEntry continue_cmd_desc = {
2058                 .handler = handle_continue,
2059                 .cmd = "c",
2060                 .cmd_startswith = true,
2061                 .allow_stop_reply = true,
2062                 .schema = "L0"
2063             };
2064             cmd_parser = &continue_cmd_desc;
2065         }
2066         break;
2067     case 'C':
2068         {
2069             static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
2070                 .handler = handle_cont_with_sig,
2071                 .cmd = "C",
2072                 .cmd_startswith = true,
2073                 .allow_stop_reply = true,
2074                 .schema = "l0"
2075             };
2076             cmd_parser = &cont_with_sig_cmd_desc;
2077         }
2078         break;
2079     case 'v':
2080         {
2081             static const GdbCmdParseEntry v_cmd_desc = {
2082                 .handler = handle_v_commands,
2083                 .cmd = "v",
2084                 .cmd_startswith = true,
2085                 .schema = "s0"
2086             };
2087             cmd_parser = &v_cmd_desc;
2088         }
2089         break;
2090     case 'k':
2091         /* Kill the target */
2092         error_report("QEMU: Terminated via GDBstub");
2093         gdb_exit(0);
2094         gdb_qemu_exit(0);
2095         break;
2096     case 'D':
2097         {
2098             static const GdbCmdParseEntry detach_cmd_desc = {
2099                 .handler = handle_detach,
2100                 .cmd = "D",
2101                 .cmd_startswith = true,
2102                 .schema = "?.l0"
2103             };
2104             cmd_parser = &detach_cmd_desc;
2105         }
2106         break;
2107     case 's':
2108         {
2109             static const GdbCmdParseEntry step_cmd_desc = {
2110                 .handler = handle_step,
2111                 .cmd = "s",
2112                 .cmd_startswith = true,
2113                 .allow_stop_reply = true,
2114                 .schema = "L0"
2115             };
2116             cmd_parser = &step_cmd_desc;
2117         }
2118         break;
2119     case 'b':
2120         {
2121             static const GdbCmdParseEntry backward_cmd_desc = {
2122                 .handler = handle_backward,
2123                 .cmd = "b",
2124                 .cmd_startswith = true,
2125                 .allow_stop_reply = true,
2126                 .schema = "o0"
2127             };
2128             cmd_parser = &backward_cmd_desc;
2129         }
2130         break;
2131     case 'F':
2132         {
2133             static const GdbCmdParseEntry file_io_cmd_desc = {
2134                 .handler = gdb_handle_file_io,
2135                 .cmd = "F",
2136                 .cmd_startswith = true,
2137                 .schema = "L,L,o0"
2138             };
2139             cmd_parser = &file_io_cmd_desc;
2140         }
2141         break;
2142     case 'g':
2143         {
2144             static const GdbCmdParseEntry read_all_regs_cmd_desc = {
2145                 .handler = handle_read_all_regs,
2146                 .cmd = "g",
2147                 .cmd_startswith = true
2148             };
2149             cmd_parser = &read_all_regs_cmd_desc;
2150         }
2151         break;
2152     case 'G':
2153         {
2154             static const GdbCmdParseEntry write_all_regs_cmd_desc = {
2155                 .handler = handle_write_all_regs,
2156                 .cmd = "G",
2157                 .cmd_startswith = true,
2158                 .schema = "s0"
2159             };
2160             cmd_parser = &write_all_regs_cmd_desc;
2161         }
2162         break;
2163     case 'm':
2164         {
2165             static const GdbCmdParseEntry read_mem_cmd_desc = {
2166                 .handler = handle_read_mem,
2167                 .cmd = "m",
2168                 .cmd_startswith = true,
2169                 .schema = "L,L0"
2170             };
2171             cmd_parser = &read_mem_cmd_desc;
2172         }
2173         break;
2174     case 'M':
2175         {
2176             static const GdbCmdParseEntry write_mem_cmd_desc = {
2177                 .handler = handle_write_mem,
2178                 .cmd = "M",
2179                 .cmd_startswith = true,
2180                 .schema = "L,L:s0"
2181             };
2182             cmd_parser = &write_mem_cmd_desc;
2183         }
2184         break;
2185     case 'p':
2186         {
2187             static const GdbCmdParseEntry get_reg_cmd_desc = {
2188                 .handler = handle_get_reg,
2189                 .cmd = "p",
2190                 .cmd_startswith = true,
2191                 .schema = "L0"
2192             };
2193             cmd_parser = &get_reg_cmd_desc;
2194         }
2195         break;
2196     case 'P':
2197         {
2198             static const GdbCmdParseEntry set_reg_cmd_desc = {
2199                 .handler = handle_set_reg,
2200                 .cmd = "P",
2201                 .cmd_startswith = true,
2202                 .schema = "L?s0"
2203             };
2204             cmd_parser = &set_reg_cmd_desc;
2205         }
2206         break;
2207     case 'Z':
2208         {
2209             static const GdbCmdParseEntry insert_bp_cmd_desc = {
2210                 .handler = handle_insert_bp,
2211                 .cmd = "Z",
2212                 .cmd_startswith = true,
2213                 .schema = "l?L?L0"
2214             };
2215             cmd_parser = &insert_bp_cmd_desc;
2216         }
2217         break;
2218     case 'z':
2219         {
2220             static const GdbCmdParseEntry remove_bp_cmd_desc = {
2221                 .handler = handle_remove_bp,
2222                 .cmd = "z",
2223                 .cmd_startswith = true,
2224                 .schema = "l?L?L0"
2225             };
2226             cmd_parser = &remove_bp_cmd_desc;
2227         }
2228         break;
2229     case 'H':
2230         {
2231             static const GdbCmdParseEntry set_thread_cmd_desc = {
2232                 .handler = handle_set_thread,
2233                 .cmd = "H",
2234                 .cmd_startswith = true,
2235                 .schema = "o.t0"
2236             };
2237             cmd_parser = &set_thread_cmd_desc;
2238         }
2239         break;
2240     case 'T':
2241         {
2242             static const GdbCmdParseEntry thread_alive_cmd_desc = {
2243                 .handler = handle_thread_alive,
2244                 .cmd = "T",
2245                 .cmd_startswith = true,
2246                 .schema = "t0"
2247             };
2248             cmd_parser = &thread_alive_cmd_desc;
2249         }
2250         break;
2251     case 'q':
2252         {
2253             static const GdbCmdParseEntry gen_query_cmd_desc = {
2254                 .handler = handle_gen_query,
2255                 .cmd = "q",
2256                 .cmd_startswith = true,
2257                 .schema = "s0"
2258             };
2259             cmd_parser = &gen_query_cmd_desc;
2260         }
2261         break;
2262     case 'Q':
2263         {
2264             static const GdbCmdParseEntry gen_set_cmd_desc = {
2265                 .handler = handle_gen_set,
2266                 .cmd = "Q",
2267                 .cmd_startswith = true,
2268                 .schema = "s0"
2269             };
2270             cmd_parser = &gen_set_cmd_desc;
2271         }
2272         break;
2273     default:
2274         /* put empty packet */
2275         gdb_put_packet("");
2276         break;
2277     }
2278 
2279     if (cmd_parser) {
2280         run_cmd_parser(line_buf, cmd_parser);
2281     }
2282 
2283     return RS_IDLE;
2284 }
2285 
2286 void gdb_set_stop_cpu(CPUState *cpu)
2287 {
2288     GDBProcess *p = gdb_get_cpu_process(cpu);
2289 
2290     if (!p->attached) {
2291         /*
2292          * Having a stop CPU corresponding to a process that is not attached
2293          * confuses GDB. So we ignore the request.
2294          */
2295         return;
2296     }
2297 
2298     gdbserver_state.c_cpu = cpu;
2299     gdbserver_state.g_cpu = cpu;
2300 }
2301 
2302 void gdb_read_byte(uint8_t ch)
2303 {
2304     uint8_t reply;
2305 
2306     gdbserver_state.allow_stop_reply = false;
2307 #ifndef CONFIG_USER_ONLY
2308     if (gdbserver_state.last_packet->len) {
2309         /* Waiting for a response to the last packet.  If we see the start
2310            of a new command then abandon the previous response.  */
2311         if (ch == '-') {
2312             trace_gdbstub_err_got_nack();
2313             gdb_put_buffer(gdbserver_state.last_packet->data,
2314                        gdbserver_state.last_packet->len);
2315         } else if (ch == '+') {
2316             trace_gdbstub_io_got_ack();
2317         } else {
2318             trace_gdbstub_io_got_unexpected(ch);
2319         }
2320 
2321         if (ch == '+' || ch == '$') {
2322             g_byte_array_set_size(gdbserver_state.last_packet, 0);
2323         }
2324         if (ch != '$')
2325             return;
2326     }
2327     if (runstate_is_running()) {
2328         /*
2329          * When the CPU is running, we cannot do anything except stop
2330          * it when receiving a char. This is expected on a Ctrl-C in the
2331          * gdb client. Because we are in all-stop mode, gdb sends a
2332          * 0x03 byte which is not a usual packet, so we handle it specially
2333          * here, but it does expect a stop reply.
2334          */
2335         if (ch != 0x03) {
2336             trace_gdbstub_err_unexpected_runpkt(ch);
2337         } else {
2338             gdbserver_state.allow_stop_reply = true;
2339         }
2340         vm_stop(RUN_STATE_PAUSED);
2341     } else
2342 #endif
2343     {
2344         switch(gdbserver_state.state) {
2345         case RS_IDLE:
2346             if (ch == '$') {
2347                 /* start of command packet */
2348                 gdbserver_state.line_buf_index = 0;
2349                 gdbserver_state.line_sum = 0;
2350                 gdbserver_state.state = RS_GETLINE;
2351             } else if (ch == '+') {
2352                 /*
2353                  * do nothing, gdb may preemptively send out ACKs on
2354                  * initial connection
2355                  */
2356             } else {
2357                 trace_gdbstub_err_garbage(ch);
2358             }
2359             break;
2360         case RS_GETLINE:
2361             if (ch == '}') {
2362                 /* start escape sequence */
2363                 gdbserver_state.state = RS_GETLINE_ESC;
2364                 gdbserver_state.line_sum += ch;
2365             } else if (ch == '*') {
2366                 /* start run length encoding sequence */
2367                 gdbserver_state.state = RS_GETLINE_RLE;
2368                 gdbserver_state.line_sum += ch;
2369             } else if (ch == '#') {
2370                 /* end of command, start of checksum*/
2371                 gdbserver_state.state = RS_CHKSUM1;
2372             } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
2373                 trace_gdbstub_err_overrun();
2374                 gdbserver_state.state = RS_IDLE;
2375             } else {
2376                 /* unescaped command character */
2377                 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch;
2378                 gdbserver_state.line_sum += ch;
2379             }
2380             break;
2381         case RS_GETLINE_ESC:
2382             if (ch == '#') {
2383                 /* unexpected end of command in escape sequence */
2384                 gdbserver_state.state = RS_CHKSUM1;
2385             } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
2386                 /* command buffer overrun */
2387                 trace_gdbstub_err_overrun();
2388                 gdbserver_state.state = RS_IDLE;
2389             } else {
2390                 /* parse escaped character and leave escape state */
2391                 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch ^ 0x20;
2392                 gdbserver_state.line_sum += ch;
2393                 gdbserver_state.state = RS_GETLINE;
2394             }
2395             break;
2396         case RS_GETLINE_RLE:
2397             /*
2398              * Run-length encoding is explained in "Debugging with GDB /
2399              * Appendix E GDB Remote Serial Protocol / Overview".
2400              */
2401             if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) {
2402                 /* invalid RLE count encoding */
2403                 trace_gdbstub_err_invalid_repeat(ch);
2404                 gdbserver_state.state = RS_GETLINE;
2405             } else {
2406                 /* decode repeat length */
2407                 int repeat = ch - ' ' + 3;
2408                 if (gdbserver_state.line_buf_index + repeat >= sizeof(gdbserver_state.line_buf) - 1) {
2409                     /* that many repeats would overrun the command buffer */
2410                     trace_gdbstub_err_overrun();
2411                     gdbserver_state.state = RS_IDLE;
2412                 } else if (gdbserver_state.line_buf_index < 1) {
2413                     /* got a repeat but we have nothing to repeat */
2414                     trace_gdbstub_err_invalid_rle();
2415                     gdbserver_state.state = RS_GETLINE;
2416                 } else {
2417                     /* repeat the last character */
2418                     memset(gdbserver_state.line_buf + gdbserver_state.line_buf_index,
2419                            gdbserver_state.line_buf[gdbserver_state.line_buf_index - 1], repeat);
2420                     gdbserver_state.line_buf_index += repeat;
2421                     gdbserver_state.line_sum += ch;
2422                     gdbserver_state.state = RS_GETLINE;
2423                 }
2424             }
2425             break;
2426         case RS_CHKSUM1:
2427             /* get high hex digit of checksum */
2428             if (!isxdigit(ch)) {
2429                 trace_gdbstub_err_checksum_invalid(ch);
2430                 gdbserver_state.state = RS_GETLINE;
2431                 break;
2432             }
2433             gdbserver_state.line_buf[gdbserver_state.line_buf_index] = '\0';
2434             gdbserver_state.line_csum = fromhex(ch) << 4;
2435             gdbserver_state.state = RS_CHKSUM2;
2436             break;
2437         case RS_CHKSUM2:
2438             /* get low hex digit of checksum */
2439             if (!isxdigit(ch)) {
2440                 trace_gdbstub_err_checksum_invalid(ch);
2441                 gdbserver_state.state = RS_GETLINE;
2442                 break;
2443             }
2444             gdbserver_state.line_csum |= fromhex(ch);
2445 
2446             if (gdbserver_state.line_csum != (gdbserver_state.line_sum & 0xff)) {
2447                 trace_gdbstub_err_checksum_incorrect(gdbserver_state.line_sum, gdbserver_state.line_csum);
2448                 /* send NAK reply */
2449                 reply = '-';
2450                 gdb_put_buffer(&reply, 1);
2451                 gdbserver_state.state = RS_IDLE;
2452             } else {
2453                 /* send ACK reply */
2454                 reply = '+';
2455                 gdb_put_buffer(&reply, 1);
2456                 gdbserver_state.state = gdb_handle_packet(gdbserver_state.line_buf);
2457             }
2458             break;
2459         default:
2460             abort();
2461         }
2462     }
2463 }
2464 
2465 /*
2466  * Create the process that will contain all the "orphan" CPUs (that are not
2467  * part of a CPU cluster). Note that if this process contains no CPUs, it won't
2468  * be attachable and thus will be invisible to the user.
2469  */
2470 void gdb_create_default_process(GDBState *s)
2471 {
2472     GDBProcess *process;
2473     int pid;
2474 
2475 #ifdef CONFIG_USER_ONLY
2476     assert(gdbserver_state.process_num == 0);
2477     pid = getpid();
2478 #else
2479     if (gdbserver_state.process_num) {
2480         pid = s->processes[s->process_num - 1].pid;
2481     } else {
2482         pid = 0;
2483     }
2484     /* We need an available PID slot for this process */
2485     assert(pid < UINT32_MAX);
2486     pid++;
2487 #endif
2488 
2489     s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2490     process = &s->processes[s->process_num - 1];
2491     process->pid = pid;
2492     process->attached = false;
2493     process->target_xml = NULL;
2494 }
2495 
2496